diff --git a/v3/ANDROID_ARCHITECTURE.md b/v3/ANDROID_ARCHITECTURE.md new file mode 100644 index 000000000..d3a589488 --- /dev/null +++ b/v3/ANDROID_ARCHITECTURE.md @@ -0,0 +1,1025 @@ +# Wails v3 Android Architecture + +## Executive Summary + +This document provides a comprehensive technical architecture for Android support in Wails v3. The implementation enables Go applications to run natively on Android with an Android WebView frontend, maintaining the Wails philosophy of using web technologies for UI while leveraging Go for business logic. + +Unlike iOS which uses CGO with Objective-C, Android uses JNI (Java Native Interface) to bridge between Java/Kotlin and Go. The Go code is compiled as a shared library (`.so`) that is loaded by the Android application at runtime. + +## Table of Contents + +1. [Architecture Overview](#architecture-overview) +2. [Core Components](#core-components) +3. [Layer Architecture](#layer-architecture) +4. [File Structure](#file-structure) +5. [Implementation Details](#implementation-details) +6. [Build System](#build-system) +7. [JNI Bridge Details](#jni-bridge-details) +8. [Asset Serving](#asset-serving) +9. [JavaScript Bridge](#javascript-bridge) +10. [Security Considerations](#security-considerations) +11. [Configuration Options](#configuration-options) +12. [Debugging](#debugging) +13. [API Reference](#api-reference) +14. [Troubleshooting](#troubleshooting) +15. [Future Enhancements](#future-enhancements) + +## Architecture Overview + +### Design Principles + +1. **Battery Efficiency First**: All architectural decisions prioritize battery life +2. **No Network Ports**: Asset serving happens in-process via `WebViewAssetLoader` +3. **JNI Bridge Pattern**: Java Activity hosts WebView, Go provides business logic +4. **Wails v3 Compatibility**: Maintain API compatibility with existing Wails v3 applications +5. **Follow Fyne's gomobile pattern**: Use `-buildmode=c-shared` for native library + +### High-Level Architecture + +``` +┌─────────────────────────────────────────────────────────────┐ +│ Android Application │ +├─────────────────────────────────────────────────────────────┤ +│ Java/Android Layer │ +│ ┌─────────────────────────────────────────────────────┐ │ +│ │ MainActivity (Activity) │ │ +│ │ ┌───────────────────────────────────────────────┐ │ │ +│ │ │ Android WebView │ │ │ +│ │ │ ┌─────────────────────────────────────────┐ │ │ │ +│ │ │ │ Web Application (HTML/JS) │ │ │ │ +│ │ │ └─────────────────────────────────────────┘ │ │ │ +│ │ └───────────────────────────────────────────────┘ │ │ +│ │ │ │ +│ │ WailsBridge WailsPathHandler WailsJSBridge│ │ +│ └─────────────────────────────────────────────────────┘ │ +├─────────────────────────────────────────────────────────────┤ +│ JNI Bridge Layer │ +│ System.loadLibrary("wails") │ +├─────────────────────────────────────────────────────────────┤ +│ Go Runtime (libwails.so) │ +│ ┌──────────────────────────────────────────────────────┐ │ +│ │ Wails Application │ │ +│ │ ┌──────────┐ ┌──────────┐ ┌──────────────────┐ │ │ +│ │ │App Logic │ │Services │ │Asset Server │ │ │ +│ │ └──────────┘ └──────────┘ └──────────────────┘ │ │ +│ └──────────────────────────────────────────────────────┘ │ +└─────────────────────────────────────────────────────────────┘ +``` + +### Comparison with iOS Architecture + +| Aspect | iOS | Android | +|--------|-----|---------| +| Native Language | Objective-C | Java | +| Bridge Technology | CGO (C headers) | JNI | +| Build Mode | `-buildmode=c-archive` (.a) | `-buildmode=c-shared` (.so) | +| Entry Point | `main.m` calls `WailsIOSMain()` | `MainActivity` loads `libwails.so` | +| WebView | WKWebView | Android WebView | +| URL Scheme | `wails://localhost` | `https://wails.localhost` | +| Asset Interception | `WKURLSchemeHandler` | `WebViewAssetLoader` + `PathHandler` | +| JS → Native | `WKScriptMessageHandler` | `@JavascriptInterface` | +| Native → JS | `evaluateJavaScript:` | `evaluateJavascript()` | +| App Lifecycle | `UIApplicationDelegate` | `Activity` lifecycle methods | + +## Core Components + +### 1. Java Components + +#### MainActivity (`MainActivity.java`) + +**Purpose**: Android Activity that hosts the WebView and manages app lifecycle. + +**Location**: `build/android/app/src/main/java/com/wails/app/MainActivity.java` + +**Key Responsibilities**: +- Initialize the native Go library via `WailsBridge` +- Configure and manage the Android WebView +- Set up asset loading via `WebViewAssetLoader` +- Handle Android lifecycle events (onCreate, onResume, onPause, onDestroy) +- Execute JavaScript in the WebView when requested by Go + +**Key Methods**: +```java +onCreate(Bundle) // Initialize bridge, setup WebView +setupWebView() // Configure WebView settings and handlers +loadApplication() // Load initial URL (https://wails.localhost/) +executeJavaScript(String) // Run JS code (called from Go via JNI) +onResume() / onPause() // Lifecycle events forwarded to Go +onDestroy() // Cleanup resources +onBackPressed() // Handle back navigation +``` + +#### WailsBridge (`WailsBridge.java`) + +**Purpose**: Manages the JNI connection between Java and Go. + +**Location**: `build/android/app/src/main/java/com/wails/app/WailsBridge.java` + +**Key Responsibilities**: +- Load the native library (`System.loadLibrary("wails")`) +- Declare and call native methods +- Manage callbacks for async operations +- Forward lifecycle events to Go + +**Native Method Declarations**: +```java +private static native void nativeInit(WailsBridge bridge); +private static native void nativeShutdown(); +private static native void nativeOnResume(); +private static native void nativeOnPause(); +private static native byte[] nativeServeAsset(String path, String method, String headers); +private static native String nativeHandleMessage(String message); +private static native String nativeGetAssetMimeType(String path); +``` + +**Key Methods**: +```java +initialize() // Call nativeInit, set up Go runtime +shutdown() // Call nativeShutdown, cleanup +serveAsset(path, method, headers) // Get asset data from Go +handleMessage(message) // Send message to Go, get response +getAssetMimeType(path) // Get MIME type for asset +executeJavaScript(js) // Execute JS (callable from Go) +emitEvent(name, data) // Emit event to frontend +``` + +#### WailsPathHandler (`WailsPathHandler.java`) + +**Purpose**: Implements `WebViewAssetLoader.PathHandler` to serve assets from Go. + +**Location**: `build/android/app/src/main/java/com/wails/app/WailsPathHandler.java` + +**Key Responsibilities**: +- Intercept all requests to `https://wails.localhost/*` +- Forward requests to Go's asset server via `WailsBridge` +- Return `WebResourceResponse` with asset data + +**Key Method**: +```java +@Nullable +public WebResourceResponse handle(@NonNull String path) { + // Normalize path (/ -> /index.html) + // Call bridge.serveAsset(path, "GET", "{}") + // Get MIME type via bridge.getAssetMimeType(path) + // Return WebResourceResponse with data +} +``` + +#### WailsJSBridge (`WailsJSBridge.java`) + +**Purpose**: JavaScript interface exposed to the WebView for Go communication. + +**Location**: `build/android/app/src/main/java/com/wails/app/WailsJSBridge.java` + +**Key Responsibilities**: +- Expose methods to JavaScript via `@JavascriptInterface` +- Forward messages from JavaScript to Go +- Support both sync and async message patterns + +**JavaScript Interface Methods**: +```java +@JavascriptInterface +public String invoke(String message) // Sync call to Go + +@JavascriptInterface +public void invokeAsync(String callbackId, String message) // Async call + +@JavascriptInterface +public void log(String level, String message) // Log to Android logcat + +@JavascriptInterface +public String platform() // Returns "android" + +@JavascriptInterface +public boolean isDebug() // Returns BuildConfig.DEBUG +``` + +**Usage from JavaScript**: +```javascript +// Synchronous call +const result = wails.invoke(JSON.stringify({type: 'call', ...})); + +// Asynchronous call +wails.invokeAsync('callback-123', JSON.stringify({type: 'call', ...})); + +// Logging +wails.log('info', 'Hello from JavaScript'); + +// Platform detection +if (wails.platform() === 'android') { ... } +``` + +### 2. Go Components + +#### Application Layer (`application_android.go`) + +**Purpose**: Main Go implementation for Android platform. + +**Location**: `v3/pkg/application/application_android.go` + +**Build Tag**: `//go:build android` + +**Key Responsibilities**: +- Export JNI functions for Java to call +- Manage global application state +- Handle lifecycle events from Android +- Serve assets and process messages + +**JNI Exports**: +```go +//export Java_com_wails_app_WailsBridge_nativeInit +func Java_com_wails_app_WailsBridge_nativeInit(env *C.JNIEnv, obj C.jobject, bridge C.jobject) + +//export Java_com_wails_app_WailsBridge_nativeShutdown +func Java_com_wails_app_WailsBridge_nativeShutdown(env *C.JNIEnv, obj C.jobject) + +//export Java_com_wails_app_WailsBridge_nativeOnResume +func Java_com_wails_app_WailsBridge_nativeOnResume(env *C.JNIEnv, obj C.jobject) + +//export Java_com_wails_app_WailsBridge_nativeOnPause +func Java_com_wails_app_WailsBridge_nativeOnPause(env *C.JNIEnv, obj C.jobject) + +//export Java_com_wails_app_WailsBridge_nativeServeAsset +func Java_com_wails_app_WailsBridge_nativeServeAsset(env *C.JNIEnv, obj C.jobject, path, method, headers *C.char) *C.char + +//export Java_com_wails_app_WailsBridge_nativeHandleMessage +func Java_com_wails_app_WailsBridge_nativeHandleMessage(env *C.JNIEnv, obj C.jobject, message *C.char) *C.char + +//export Java_com_wails_app_WailsBridge_nativeGetAssetMimeType +func Java_com_wails_app_WailsBridge_nativeGetAssetMimeType(env *C.JNIEnv, obj C.jobject, path *C.char) *C.char +``` + +**Platform Functions**: +```go +func (a *App) platformRun() // Block forever, Android manages lifecycle +func (a *App) platformQuit() // Signal quit +func (a *App) isDarkMode() bool // Query Android dark mode +``` + +#### WebView Window (`webview_window_android.go`) + +**Purpose**: Implements `webviewWindowImpl` interface for Android. + +**Location**: `v3/pkg/application/webview_window_android.go` + +**Build Tag**: `//go:build android` + +**Key Methods**: Most methods are no-ops or return defaults since Android has a single fullscreen window. + +```go +func (w *androidWebviewWindow) execJS(js string) // Execute JavaScript +func (w *androidWebviewWindow) isFullscreen() bool // Always true +func (w *androidWebviewWindow) size() (int, int) // Device dimensions +func (w *androidWebviewWindow) setBackgroundColour(col RGBA) // Set WebView bg +``` + +#### Asset Server (`assetserver_android.go`) + +**Purpose**: Configure base URL for Android asset serving. + +**Location**: `v3/internal/assetserver/assetserver_android.go` + +**Build Tag**: `//go:build android` + +```go +var baseURL = url.URL{ + Scheme: "https", + Host: "wails.localhost", +} +``` + +#### Other Platform Files + +All these files have the `//go:build android` tag: + +| File | Purpose | +|------|---------| +| `init_android.go` | Initialization (no `runtime.LockOSThread`) | +| `clipboard_android.go` | Clipboard operations (stub) | +| `dialogs_android.go` | File/message dialogs (stub) | +| `menu_android.go` | Menu handling (no-op) | +| `menuitem_android.go` | Menu items (no-op) | +| `screen_android.go` | Screen information | +| `mainthread_android.go` | Main thread dispatch | +| `signal_handler_android.go` | Signal handling (no-op) | +| `single_instance_android.go` | Single instance (via manifest) | +| `systemtray_android.go` | System tray (no-op) | +| `keys_android.go` | Keyboard handling (stub) | +| `events_common_android.go` | Event mapping | +| `messageprocessor_android.go` | Android-specific runtime methods | + +## File Structure + +``` +v3/ +├── ANDROID_ARCHITECTURE.md # This document +├── pkg/ +│ ├── application/ +│ │ ├── application_android.go # Main Android implementation +│ │ ├── application_options.go # Contains AndroidOptions struct +│ │ ├── webview_window_android.go +│ │ ├── clipboard_android.go +│ │ ├── dialogs_android.go +│ │ ├── events_common_android.go +│ │ ├── init_android.go +│ │ ├── keys_android.go +│ │ ├── mainthread_android.go +│ │ ├── menu_android.go +│ │ ├── menuitem_android.go +│ │ ├── messageprocessor_android.go +│ │ ├── messageprocessor_mobile_stub.go # Stub for non-mobile +│ │ ├── screen_android.go +│ │ ├── signal_handler_android.go +│ │ ├── signal_handler_types_android.go +│ │ ├── single_instance_android.go +│ │ └── systemtray_android.go +│ └── events/ +│ └── events_android.go +├── internal/ +│ └── assetserver/ +│ ├── assetserver_android.go +│ └── webview/ +│ └── request_android.go +└── examples/ + └── android/ + ├── main.go # Application entry point + ├── greetservice.go # Example service + ├── go.mod + ├── go.sum + ├── Taskfile.yml # Build orchestration + ├── .gitignore + ├── frontend/ # Web frontend (same as other platforms) + │ ├── index.html + │ ├── main.js + │ ├── package.json + │ └── ... + └── build/ + ├── config.yml # Build configuration + ├── Taskfile.yml # Common build tasks + ├── android/ + │ ├── Taskfile.yml # Android-specific tasks + │ ├── build.gradle # Root Gradle build + │ ├── settings.gradle + │ ├── gradle.properties + │ ├── gradlew # Gradle wrapper script + │ ├── gradle/ + │ │ └── wrapper/ + │ │ └── gradle-wrapper.properties + │ ├── scripts/ + │ │ └── deps/ + │ │ └── install_deps.go # Dependency checker + │ └── app/ + │ ├── build.gradle # App Gradle build + │ ├── proguard-rules.pro + │ └── src/ + │ └── main/ + │ ├── AndroidManifest.xml + │ ├── java/ + │ │ └── com/ + │ │ └── wails/ + │ │ └── app/ + │ │ ├── MainActivity.java + │ │ ├── WailsBridge.java + │ │ ├── WailsPathHandler.java + │ │ └── WailsJSBridge.java + │ ├── res/ + │ │ ├── layout/ + │ │ │ └── activity_main.xml + │ │ ├── values/ + │ │ │ ├── strings.xml + │ │ │ ├── colors.xml + │ │ │ └── themes.xml + │ │ └── mipmap-*/ # App icons + │ ├── assets/ # Frontend assets (copied) + │ └── jniLibs/ + │ ├── arm64-v8a/ + │ │ └── libwails.so # Generated + │ └── x86_64/ + │ └── libwails.so # Generated + ├── darwin/ # macOS build files + ├── linux/ # Linux build files + └── windows/ # Windows build files +``` + +## Implementation Details + +### Application Startup Flow + +``` +1. Android OS launches MainActivity + │ +2. MainActivity.onCreate() + │ + ├─> WailsBridge.initialize() + │ │ + │ └─> System.loadLibrary("wails") + │ │ + │ └─> Go runtime starts + │ │ + │ └─> nativeInit() called + │ │ + │ └─> globalApp = app (store reference) + │ + ├─> setupWebView() + │ │ + │ ├─> Configure WebSettings + │ ├─> Create WebViewAssetLoader with WailsPathHandler + │ ├─> Set WebViewClient for request interception + │ └─> Add WailsJSBridge via addJavascriptInterface + │ + └─> loadApplication() + │ + └─> webView.loadUrl("https://wails.localhost/") + │ + └─> WailsPathHandler.handle("/") + │ + └─> WailsBridge.serveAsset("/index.html", ...) + │ + └─> nativeServeAsset() (JNI to Go) + │ + └─> Go AssetServer returns HTML +``` + +### Asset Request Flow + +``` +WebView requests: https://wails.localhost/main.js + │ + ▼ +WebViewClient.shouldInterceptRequest() + │ + ▼ +WebViewAssetLoader.shouldInterceptRequest() + │ + ▼ +WailsPathHandler.handle("/main.js") + │ + ▼ +WailsBridge.serveAsset("/main.js", "GET", "{}") + │ + ▼ +JNI call: nativeServeAsset(path, method, headers) + │ + ▼ +Go: serveAssetForAndroid(app, "/main.js") + │ + ▼ +Go: AssetServer reads from embed.FS + │ + ▼ +Return: byte[] data + │ + ▼ +WailsPathHandler creates WebResourceResponse + │ + ▼ +WebView renders content +``` + +### JavaScript to Go Message Flow + +``` +JavaScript: wails.invoke('{"type":"call","method":"Greet","args":["World"]}') + │ + ▼ +WailsJSBridge.invoke(message) [@JavascriptInterface] + │ + ▼ +WailsBridge.handleMessage(message) + │ + ▼ +JNI call: nativeHandleMessage(message) + │ + ▼ +Go: handleMessageForAndroid(app, message) + │ + ▼ +Go: Parse JSON, route to service method + │ + ▼ +Go: Execute GreetService.Greet("World") + │ + ▼ +Return: '{"result":"Hello, World!"}' + │ + ▼ +JavaScript receives result +``` + +### Go to JavaScript Event Flow + +``` +Go: app.Event.Emit("time", "Mon, 01 Jan 2024 12:00:00") + │ + ▼ +Go: Call Java executeJavaScript via JNI callback + │ + ▼ +WailsBridge.emitEvent("time", "\"Mon, 01 Jan 2024 12:00:00\"") + │ + ▼ +JavaScript: window.wails._emit('time', "Mon, 01 Jan 2024 12:00:00") + │ + ▼ +Frontend event listeners notified +``` + +## Build System + +### Prerequisites + +1. **Go 1.21+** with CGO support +2. **Android SDK** with: + - Platform Tools (adb) + - Build Tools + - Android Emulator +3. **Android NDK r19c+** (r26d recommended) +4. **Java JDK 11+** + +### Environment Variables + +```bash +# Required +export ANDROID_HOME=$HOME/Library/Android/sdk # macOS +export ANDROID_HOME=$HOME/Android/Sdk # Linux + +# Optional (auto-detected if not set) +export ANDROID_NDK_HOME=$ANDROID_HOME/ndk/26.1.10909125 + +# Path additions +export PATH=$PATH:$ANDROID_HOME/platform-tools +export PATH=$PATH:$ANDROID_HOME/emulator +``` + +### Taskfile Commands + +```bash +# Check/install dependencies +task android:install:deps + +# Build Go shared library (default: arm64 for device) +task android:build + +# Build for emulator (x86_64) +task android:build ARCH=x86_64 + +# Build for all architectures (fat APK) +task android:compile:go:all-archs + +# Package into APK +task android:package + +# Run on emulator +task android:run + +# View logs +task android:logs + +# Clean build artifacts +task android:clean +``` + +### Build Process Details + +#### 1. Go Compilation + +```bash +# Environment for arm64 (device) +export GOOS=android +export GOARCH=arm64 +export CGO_ENABLED=1 +export CC=$NDK/toolchains/llvm/prebuilt/$HOST/bin/aarch64-linux-android21-clang + +# Build command +go build -buildmode=c-shared \ + -tags android \ + -o build/android/app/src/main/jniLibs/arm64-v8a/libwails.so +``` + +#### 2. Gradle Build + +```bash +cd build/android +./gradlew assembleDebug +# Output: app/build/outputs/apk/debug/app-debug.apk +``` + +#### 3. Installation + +```bash +adb install app-debug.apk +adb shell am start -n com.wails.app/.MainActivity +``` + +### Architecture Support + +| Architecture | GOARCH | JNI Directory | Use Case | +|--------------|--------|---------------|----------| +| arm64-v8a | arm64 | `jniLibs/arm64-v8a/` | Physical devices (most common) | +| x86_64 | amd64 | `jniLibs/x86_64/` | Emulator | +| armeabi-v7a | arm | `jniLibs/armeabi-v7a/` | Older devices (optional) | +| x86 | 386 | `jniLibs/x86/` | Older emulators (optional) | + +### Minimum SDK Configuration + +```gradle +// build/android/app/build.gradle +android { + defaultConfig { + minSdk 21 // Android 5.0 (Lollipop) - 99%+ coverage + targetSdk 34 // Android 14 - Required for Play Store + } +} +``` + +## JNI Bridge Details + +### JNI Function Naming Convention + +JNI functions must follow this naming pattern: +``` +Java___ +``` + +Example: +```go +//export Java_com_wails_app_WailsBridge_nativeInit +func Java_com_wails_app_WailsBridge_nativeInit(env *C.JNIEnv, obj C.jobject, bridge C.jobject) +``` + +Corresponds to Java: +```java +package com.wails.app; +class WailsBridge { + private static native void nativeInit(WailsBridge bridge); +} +``` + +### JNI Type Mappings + +| Java Type | JNI Type | Go CGO Type | +|-----------|----------|-------------| +| void | void | - | +| boolean | jboolean | C.jboolean | +| int | jint | C.jint | +| long | jlong | C.jlong | +| String | jstring | *C.char (via conversion) | +| byte[] | jbyteArray | *C.char (via conversion) | +| Object | jobject | C.jobject | + +### String Conversion + +```go +// Java String → Go string +goString := C.GoString((*C.char)(unsafe.Pointer(javaString))) + +// Go string → Java String (return) +return C.CString(goString) // Must be freed by Java +``` + +### Thread Safety + +- JNI calls must be made from the thread that owns the JNI environment +- Go goroutines cannot directly call JNI methods +- Use channels or callbacks to communicate between goroutines and JNI thread + +## Asset Serving + +### WebViewAssetLoader Configuration + +```java +assetLoader = new WebViewAssetLoader.Builder() + .setDomain("wails.localhost") // Custom domain + .addPathHandler("/", new WailsPathHandler(bridge)) // All paths + .build(); +``` + +### URL Scheme + +- **Base URL**: `https://wails.localhost/` +- **Why HTTPS**: Android's `WebViewAssetLoader` requires HTTPS for security +- **Domain**: `wails.localhost` is arbitrary but consistent with Wails conventions + +### Path Normalization + +```java +// In WailsPathHandler.handle() +if (path.isEmpty() || path.equals("/")) { + path = "/index.html"; +} +``` + +### MIME Type Detection + +MIME types are determined by Go based on file extension. Fallback mapping in Java: + +```java +private String getMimeType(String path) { + if (path.endsWith(".html")) return "text/html"; + if (path.endsWith(".js")) return "application/javascript"; + if (path.endsWith(".css")) return "text/css"; + // ... etc + return "application/octet-stream"; +} +``` + +## JavaScript Bridge + +### Exposed Interface + +The `WailsJSBridge` is added to the WebView as: +```java +webView.addJavascriptInterface(new WailsJSBridge(bridge, webView), "wails"); +``` + +This makes `window.wails` available in JavaScript. + +### Security Considerations + +1. **@JavascriptInterface annotation** is required for all exposed methods (Android 4.2+) +2. Only specific methods are exposed, not the entire object +3. Input validation should be performed on all received data + +### Async Pattern + +For non-blocking calls: + +```javascript +// JavaScript side +const callbackId = 'cb_' + Date.now(); +window.wails._callbacks[callbackId] = (result, error) => { + if (error) reject(error); + else resolve(result); +}; +wails.invokeAsync(callbackId, message); + +// Java side sends response via: +webView.evaluateJavascript( + "window.wails._callback('" + callbackId + "', " + result + ", null);", + null +); +``` + +## Security Considerations + +### WebView Security + +```java +WebSettings settings = webView.getSettings(); +settings.setAllowFileAccess(false); // No file:// access +settings.setAllowContentAccess(false); // No content:// access +settings.setMixedContentMode(MIXED_CONTENT_NEVER_ALLOW); // HTTPS only +``` + +### JNI Security + +1. **No arbitrary code execution**: JNI methods have fixed signatures +2. **Input validation**: All strings from Java are validated in Go +3. **Memory safety**: Go's memory management prevents buffer overflows + +### Asset Security + +1. **Same-origin policy**: Assets only served from `wails.localhost` +2. **No external network**: All assets embedded, no remote fetching +3. **Content Security Policy**: Can be set via HTML headers + +## Configuration Options + +### AndroidOptions Struct + +```go +type AndroidOptions struct { + // DisableScroll disables scrolling in the WebView + DisableScroll bool + + // DisableOverscroll disables the overscroll bounce effect + DisableOverscroll bool + + // EnableZoom allows pinch-to-zoom in the WebView (default: false) + EnableZoom bool + + // UserAgent sets a custom user agent string + UserAgent string + + // BackgroundColour sets the background colour of the WebView + BackgroundColour RGBA + + // DisableHardwareAcceleration disables hardware acceleration + DisableHardwareAcceleration bool +} +``` + +### Usage + +```go +app := application.New(application.Options{ + Name: "My App", + Android: application.AndroidOptions{ + DisableOverscroll: true, + BackgroundColour: application.NewRGB(27, 38, 54), + }, +}) +``` + +### AndroidManifest.xml Configuration + +```xml + + + + + android:hardwareAccelerated="true"> + + + + + +``` + +## Debugging + +### Logcat Filtering + +```bash +# All Wails logs +adb logcat -v time | grep -E "(Wails|WailsBridge|WailsActivity)" + +# Using task +task android:logs +``` + +### WebView Debugging + +Enable in debug builds: +```java +if (BuildConfig.DEBUG) { + WebView.setWebContentsDebuggingEnabled(true); +} +``` + +Then in Chrome: `chrome://inspect/#devices` + +### Go Debugging + +```go +func androidLogf(level string, format string, a ...interface{}) { + msg := fmt.Sprintf(format, a...) + println(fmt.Sprintf("[Android/%s] %s", level, msg)) +} +``` + +### Common Issues + +1. **"UnsatisfiedLinkError"**: Library not found or wrong architecture +2. **"No implementation found"**: JNI function name mismatch +3. **Blank WebView**: Asset serving not working, check logcat + +## API Reference + +### Go API (Same as Desktop) + +```go +// Create application +app := application.New(application.Options{ + Name: "App Name", + Assets: application.AssetOptions{ + Handler: application.AssetFileServerFS(assets), + }, + Services: []application.Service{ + application.NewService(&MyService{}), + }, + Android: application.AndroidOptions{...}, +}) + +// Run (blocks on Android) +app.Run() + +// Emit events +app.Event.Emit("eventName", data) +``` + +### JavaScript API + +```javascript +// Call Go service method +const result = await window.wails.Call.ByName('MyService.Greet', 'World'); + +// Platform detection +if (window.wails.System.Platform() === 'android') { ... } + +// Events +window.wails.Events.On('eventName', (data) => { ... }); +``` + +### Android-Specific Runtime Methods + +```javascript +// Vibrate (haptic feedback) +window.wails.Call.ByName('Android.Haptics.Vibrate', {duration: 100}); + +// Show toast +window.wails.Call.ByName('Android.Toast.Show', {message: 'Hello!'}); + +// Get device info +const info = await window.wails.Call.ByName('Android.Device.Info'); +``` + +## Troubleshooting + +### Build Errors + +**"NDK not found"** +```bash +# Set NDK path explicitly +export ANDROID_NDK_HOME=$ANDROID_HOME/ndk/26.1.10909125 +``` + +**"undefined reference to JNI function"** +- Check function name matches exactly (case-sensitive) +- Ensure `//export` comment is directly above function + +**"cannot find package"** +```bash +cd examples/android && go mod tidy +``` + +### Runtime Errors + +**App crashes on startup** +1. Check logcat for stack trace +2. Verify library is in correct jniLibs directory +3. Check architecture matches device/emulator + +**WebView shows blank** +1. Enable WebView debugging +2. Check Chrome DevTools for errors +3. Verify `https://wails.localhost/` resolves + +**JavaScript bridge not working** +1. Check `wails` object exists: `console.log(window.wails)` +2. Verify `@JavascriptInterface` annotations present +3. Check for JavaScript errors in console + +## Future Enhancements + +### Phase 1: Core Stability +- [ ] Complete JNI callback implementation for Go → Java +- [ ] Full asset server integration +- [ ] Error handling and recovery +- [ ] Unit and integration tests + +### Phase 2: Feature Parity +- [ ] Clipboard support +- [ ] File dialogs (via Storage Access Framework) +- [ ] Notifications +- [ ] Deep linking + +### Phase 3: Android-Specific Features +- [ ] Material Design 3 theming integration +- [ ] Edge-to-edge display support +- [ ] Predictive back gesture +- [ ] Picture-in-Picture mode +- [ ] Widgets + +### Phase 4: Advanced Features +- [ ] Background services +- [ ] Push notifications (FCM) +- [ ] Biometric authentication +- [ ] App Shortcuts +- [ ] Wear OS companion + +## Conclusion + +This architecture provides a solid foundation for Android support in Wails v3. The design prioritizes: + +1. **Compatibility**: Same Go code runs on all platforms +2. **Performance**: No network overhead, native rendering +3. **Security**: Sandboxed WebView, validated inputs +4. **Maintainability**: Clear separation of concerns + +The implementation follows Android best practices while maintaining the simplicity that Wails developers expect. The JNI bridge pattern, while more complex than iOS's CGO approach, provides robust interoperability between Java and Go. + +### Key Implementation Status + +| Component | Status | Notes | +|-----------|--------|-------| +| Java Activity | ✅ Complete | MainActivity with WebView | +| JNI Bridge | ✅ Complete | WailsBridge with native methods | +| Asset Handler | ✅ Complete | WailsPathHandler | +| JS Bridge | ✅ Complete | WailsJSBridge | +| Go Platform Files | ✅ Complete | All *_android.go files | +| Taskfile | ✅ Complete | Build orchestration | +| Gradle Project | ✅ Complete | App structure | +| JNI Implementation | 🔄 Partial | Needs Go → Java callbacks | +| Asset Server Integration | 🔄 Partial | Needs full wiring | +| Testing | ❌ Pending | Needs emulator testing | + +--- + +*Document Version: 1.0* +*Last Updated: November 2024* +*Wails Version: v3-alpha* diff --git a/v3/examples/android/.gitignore b/v3/examples/android/.gitignore new file mode 100644 index 000000000..edb05e60a --- /dev/null +++ b/v3/examples/android/.gitignore @@ -0,0 +1,24 @@ +# Build outputs +bin/ +*.apk +*.aab + +# Android build artifacts +build/android/.gradle/ +build/android/app/build/ +build/android/local.properties + +# JNI libraries (generated during build) +build/android/app/src/main/jniLibs/*/libwails.so + +# IDE +.idea/ +*.iml + +# OS +.DS_Store +Thumbs.db + +# Frontend build +frontend/dist/ +frontend/node_modules/ diff --git a/v3/examples/android/.task/checksum/android-common-generate-icons b/v3/examples/android/.task/checksum/android-common-generate-icons new file mode 100644 index 000000000..4534dd92e --- /dev/null +++ b/v3/examples/android/.task/checksum/android-common-generate-icons @@ -0,0 +1 @@ +a40fe27d90a25e84deeed985e4075cfa diff --git a/v3/examples/android/.task/checksum/android-common-install-frontend-deps b/v3/examples/android/.task/checksum/android-common-install-frontend-deps new file mode 100644 index 000000000..997225071 --- /dev/null +++ b/v3/examples/android/.task/checksum/android-common-install-frontend-deps @@ -0,0 +1 @@ +82dedd4f821c351be61d8e1dbb6eefa diff --git a/v3/examples/android/.task/checksum/android-generate-android-bindings b/v3/examples/android/.task/checksum/android-generate-android-bindings new file mode 100644 index 000000000..ad9ec9f0b --- /dev/null +++ b/v3/examples/android/.task/checksum/android-generate-android-bindings @@ -0,0 +1 @@ +7bfce68482b8f82eb3495774fb52ddca diff --git a/v3/examples/android/.task/checksum/build-frontend--PRODUCTION-- b/v3/examples/android/.task/checksum/build-frontend--PRODUCTION-- new file mode 100644 index 000000000..1a1bb532e --- /dev/null +++ b/v3/examples/android/.task/checksum/build-frontend--PRODUCTION-- @@ -0,0 +1 @@ +6e6cec395abdf7aed5c77ae6ab3ed264 diff --git a/v3/examples/android/.task/checksum/generate-bindings--BUILD_FLAGS--tags-android-debug--buildvcs-false--gcflags-all---l-- b/v3/examples/android/.task/checksum/generate-bindings--BUILD_FLAGS--tags-android-debug--buildvcs-false--gcflags-all---l-- new file mode 100644 index 000000000..52597e299 --- /dev/null +++ b/v3/examples/android/.task/checksum/generate-bindings--BUILD_FLAGS--tags-android-debug--buildvcs-false--gcflags-all---l-- @@ -0,0 +1 @@ +3eaf69fc9c4a0eeef54a9ebcc9b25cf7 diff --git a/v3/examples/android/Taskfile.yml b/v3/examples/android/Taskfile.yml new file mode 100644 index 000000000..4940aab8e --- /dev/null +++ b/v3/examples/android/Taskfile.yml @@ -0,0 +1,34 @@ +version: '3' + +includes: + common: ./build/Taskfile.yml + windows: ./build/windows/Taskfile.yml + darwin: ./build/darwin/Taskfile.yml + linux: ./build/linux/Taskfile.yml + android: ./build/android/Taskfile.yml + +vars: + APP_NAME: "android" + BIN_DIR: "bin" + VITE_PORT: '{{.WAILS_VITE_PORT | default 9245}}' + +tasks: + build: + summary: Builds the application + cmds: + - task: "{{OS}}:build" + + package: + summary: Packages a production build of the application + cmds: + - task: "{{OS}}:package" + + run: + summary: Runs the application + cmds: + - task: "{{OS}}:run" + + dev: + summary: Runs the application in development mode + cmds: + - wails3 dev -config ./build/config.yml -port {{.VITE_PORT}} diff --git a/v3/examples/android/build/Taskfile.yml b/v3/examples/android/build/Taskfile.yml new file mode 100644 index 000000000..209793bfd --- /dev/null +++ b/v3/examples/android/build/Taskfile.yml @@ -0,0 +1,174 @@ +version: '3' + +tasks: + go:mod:tidy: + summary: Runs `go mod tidy` + internal: true + cmds: + - go mod tidy + + install:frontend:deps: + summary: Install frontend dependencies + dir: frontend + sources: + - package.json + - package-lock.json + generates: + - node_modules/* + preconditions: + - sh: npm version + msg: "Looks like npm isn't installed. Npm is part of the Node installer: https://nodejs.org/en/download/" + cmds: + - npm install + + build:frontend: + label: build:frontend (PRODUCTION={{.PRODUCTION}}) + summary: Build the frontend project + dir: frontend + sources: + - "**/*" + generates: + - dist/**/* + deps: + - task: install:frontend:deps + - task: generate:bindings + vars: + BUILD_FLAGS: + ref: .BUILD_FLAGS + cmds: + - npm run {{.BUILD_COMMAND}} -q + env: + PRODUCTION: '{{.PRODUCTION | default "false"}}' + vars: + BUILD_COMMAND: '{{if eq .PRODUCTION "true"}}build{{else}}build:dev{{end}}' + + + frontend:vendor:puppertino: + summary: Fetches Puppertino CSS into frontend/public for consistent mobile styling + sources: + - frontend/public/puppertino/puppertino.css + generates: + - frontend/public/puppertino/puppertino.css + cmds: + - | + set -euo pipefail + mkdir -p frontend/public/puppertino + # Fetch Puppertino full.css and LICENSE from GitHub main branch + curl -fsSL https://raw.githubusercontent.com/codedgar/Puppertino/main/dist/css/full.css -o frontend/public/puppertino/puppertino.css + curl -fsSL https://raw.githubusercontent.com/codedgar/Puppertino/main/LICENSE -o frontend/public/puppertino/LICENSE + echo "Puppertino CSS updated at frontend/public/puppertino/puppertino.css" + # Ensure index.html includes Puppertino CSS and button classes + INDEX_HTML=frontend/index.html + if [ -f "$INDEX_HTML" ]; then + if ! grep -q 'href="/puppertino/puppertino.css"' "$INDEX_HTML"; then + # Insert Puppertino link tag after style.css link + awk ' + /href="\/style.css"\/?/ && !x { print; print " "; x=1; next }1 + ' "$INDEX_HTML" > "$INDEX_HTML.tmp" && mv "$INDEX_HTML.tmp" "$INDEX_HTML" + fi + # Replace default .btn with Puppertino primary button classes if present + sed -E -i'' 's/class=\"btn\"/class=\"p-btn p-prim-col\"/g' "$INDEX_HTML" || true + fi + + generate:bindings: + label: generate:bindings (BUILD_FLAGS={{.BUILD_FLAGS}}) + summary: Generates bindings for the frontend + deps: + - task: go:mod:tidy + sources: + - "**/*.[jt]s" + - exclude: frontend/**/* + - frontend/bindings/**/* # Rerun when switching between dev/production mode causes changes in output + - "**/*.go" + - go.mod + - go.sum + generates: + - frontend/bindings/**/* + cmds: + - wails3 generate bindings -f '{{.BUILD_FLAGS}}' -clean=true + + generate:icons: + summary: Generates Windows `.ico` and Mac `.icns` files from an image + dir: build + sources: + - "appicon.png" + generates: + - "darwin/icons.icns" + - "windows/icon.ico" + cmds: + - wails3 generate icons -input appicon.png -macfilename darwin/icons.icns -windowsfilename windows/icon.ico + + dev:frontend: + summary: Runs the frontend in development mode + dir: frontend + deps: + - task: install:frontend:deps + cmds: + - npm run dev -- --port {{.VITE_PORT}} --strictPort + + update:build-assets: + summary: Updates the build assets + dir: build + cmds: + - wails3 update build-assets -name "{{.APP_NAME}}" -binaryname "{{.APP_NAME}}" -config config.yml -dir . + + + ios:device:list: + summary: Lists connected iOS devices (UDIDs) + cmds: + - xcrun xcdevice list + + ios:run:device: + summary: Build, install, and launch on a physical iPhone using Apple tools (xcodebuild/devicectl) + vars: + PROJECT: '{{.PROJECT}}' # e.g., build/ios/xcode/.xcodeproj + SCHEME: '{{.SCHEME}}' # e.g., ios.dev + CONFIG: '{{.CONFIG | default "Debug"}}' + DERIVED: '{{.DERIVED | default "build/ios/DerivedData"}}' + UDID: '{{.UDID}}' # from `task ios:device:list` + BUNDLE_ID: '{{.BUNDLE_ID}}' # e.g., com.yourco.wails.ios.dev + TEAM_ID: '{{.TEAM_ID}}' # optional, if your project is not already set up for signing + preconditions: + - sh: xcrun -f xcodebuild + msg: "xcodebuild not found. Please install Xcode." + - sh: xcrun -f devicectl + msg: "devicectl not found. Please update to Xcode 15+ (which includes devicectl)." + - sh: test -n "{{.PROJECT}}" + msg: "Set PROJECT to your .xcodeproj path (e.g., PROJECT=build/ios/xcode/App.xcodeproj)." + - sh: test -n "{{.SCHEME}}" + msg: "Set SCHEME to your app scheme (e.g., SCHEME=ios.dev)." + - sh: test -n "{{.UDID}}" + msg: "Set UDID to your device UDID (see: task ios:device:list)." + - sh: test -n "{{.BUNDLE_ID}}" + msg: "Set BUNDLE_ID to your app's bundle identifier (e.g., com.yourco.wails.ios.dev)." + cmds: + - | + set -euo pipefail + echo "Building for device: UDID={{.UDID}} SCHEME={{.SCHEME}} PROJECT={{.PROJECT}}" + XCB_ARGS=( + -project "{{.PROJECT}}" + -scheme "{{.SCHEME}}" + -configuration "{{.CONFIG}}" + -destination "id={{.UDID}}" + -derivedDataPath "{{.DERIVED}}" + -allowProvisioningUpdates + -allowProvisioningDeviceRegistration + ) + # Optionally inject signing identifiers if provided + if [ -n "{{.TEAM_ID}}" ]; then XCB_ARGS+=(DEVELOPMENT_TEAM={{.TEAM_ID}}); fi + if [ -n "{{.BUNDLE_ID}}" ]; then XCB_ARGS+=(PRODUCT_BUNDLE_IDENTIFIER={{.BUNDLE_ID}}); fi + xcodebuild "${XCB_ARGS[@]}" build | xcpretty || true + # If xcpretty isn't installed, run without it + if [ "${PIPESTATUS[0]}" -ne 0 ]; then + xcodebuild "${XCB_ARGS[@]}" build + fi + # Find built .app + APP_PATH=$(find "{{.DERIVED}}/Build/Products" -type d -name "*.app" -maxdepth 3 | head -n 1) + if [ -z "$APP_PATH" ]; then + echo "Could not locate built .app under {{.DERIVED}}/Build/Products" >&2 + exit 1 + fi + echo "Installing: $APP_PATH" + xcrun devicectl device install app --device "{{.UDID}}" "$APP_PATH" + echo "Launching: {{.BUNDLE_ID}}" + xcrun devicectl device process launch --device "{{.UDID}}" --stderr console --stdout console "{{.BUNDLE_ID}}" diff --git a/v3/examples/android/build/android/Taskfile.yml b/v3/examples/android/build/android/Taskfile.yml new file mode 100644 index 000000000..5005f9f4e --- /dev/null +++ b/v3/examples/android/build/android/Taskfile.yml @@ -0,0 +1,237 @@ +version: '3' + +includes: + common: ../Taskfile.yml + +vars: + APP_ID: '{{.APP_ID | default "com.wails.app"}}' + MIN_SDK: '21' + TARGET_SDK: '34' + NDK_VERSION: 'r26d' + +tasks: + install:deps: + summary: Check and install Android development dependencies + cmds: + - go run build/android/scripts/deps/install_deps.go + env: + TASK_FORCE_YES: '{{if .YES}}true{{else}}false{{end}}' + prompt: This will check and install Android development dependencies. Continue? + + build: + summary: Creates a build of the application for Android + deps: + - task: common:go:mod:tidy + - task: generate:android:bindings + vars: + BUILD_FLAGS: + ref: .BUILD_FLAGS + - task: common:build:frontend + vars: + BUILD_FLAGS: + ref: .BUILD_FLAGS + PRODUCTION: + ref: .PRODUCTION + - task: common:generate:icons + cmds: + - echo "Building Android app {{.APP_NAME}}..." + - task: compile:go:shared + vars: + ARCH: '{{.ARCH | default "arm64"}}' + vars: + BUILD_FLAGS: '{{if eq .PRODUCTION "true"}}-tags production,android -trimpath -buildvcs=false -ldflags="-w -s"{{else}}-tags android,debug -buildvcs=false -gcflags=all="-l"{{end}}' + env: + PRODUCTION: '{{.PRODUCTION | default "false"}}' + + compile:go:shared: + summary: Compile Go code to shared library (.so) + cmds: + - | + NDK_ROOT="${ANDROID_NDK_HOME:-$ANDROID_HOME/ndk/{{.NDK_VERSION}}}" + if [ ! -d "$NDK_ROOT" ]; then + echo "Error: Android NDK not found at $NDK_ROOT" + echo "Please set ANDROID_NDK_HOME or install NDK {{.NDK_VERSION}} via Android Studio" + exit 1 + fi + + # Determine toolchain based on host OS + case "$(uname -s)" in + Darwin) HOST_TAG="darwin-x86_64" ;; + Linux) HOST_TAG="linux-x86_64" ;; + *) echo "Unsupported host OS"; exit 1 ;; + esac + + TOOLCHAIN="$NDK_ROOT/toolchains/llvm/prebuilt/$HOST_TAG" + + # Set compiler based on architecture + case "{{.ARCH}}" in + arm64) + export CC="$TOOLCHAIN/bin/aarch64-linux-android{{.MIN_SDK}}-clang" + export CXX="$TOOLCHAIN/bin/aarch64-linux-android{{.MIN_SDK}}-clang++" + export GOARCH=arm64 + JNI_DIR="arm64-v8a" + ;; + amd64|x86_64) + export CC="$TOOLCHAIN/bin/x86_64-linux-android{{.MIN_SDK}}-clang" + export CXX="$TOOLCHAIN/bin/x86_64-linux-android{{.MIN_SDK}}-clang++" + export GOARCH=amd64 + JNI_DIR="x86_64" + ;; + *) + echo "Unsupported architecture: {{.ARCH}}" + exit 1 + ;; + esac + + export CGO_ENABLED=1 + export GOOS=android + + mkdir -p {{.BIN_DIR}} + mkdir -p build/android/app/src/main/jniLibs/$JNI_DIR + + go build -buildmode=c-shared {{.BUILD_FLAGS}} \ + -o build/android/app/src/main/jniLibs/$JNI_DIR/libwails.so + vars: + BUILD_FLAGS: '{{if eq .PRODUCTION "true"}}-tags production,android -trimpath -buildvcs=false -ldflags="-w -s"{{else}}-tags android,debug -buildvcs=false -gcflags=all="-l"{{end}}' + + compile:go:all-archs: + summary: Compile Go code for all Android architectures (fat APK) + cmds: + - task: compile:go:shared + vars: + ARCH: arm64 + - task: compile:go:shared + vars: + ARCH: amd64 + + package: + summary: Packages a production build of the application into an APK + deps: + - task: build + vars: + PRODUCTION: "true" + cmds: + - task: assemble:apk + + package:fat: + summary: Packages a production build for all architectures (fat APK) + cmds: + - task: compile:go:all-archs + - task: assemble:apk + + assemble:apk: + summary: Assembles the APK using Gradle + cmds: + - | + cd build/android + ./gradlew assembleDebug + cp app/build/outputs/apk/debug/app-debug.apk ../../{{.BIN_DIR}}/{{.APP_NAME}}.apk + echo "APK created: {{.BIN_DIR}}/{{.APP_NAME}}.apk" + + assemble:apk:release: + summary: Assembles a release APK using Gradle + cmds: + - | + cd build/android + ./gradlew assembleRelease + cp app/build/outputs/apk/release/app-release-unsigned.apk ../../{{.BIN_DIR}}/{{.APP_NAME}}-release.apk + echo "Release APK created: {{.BIN_DIR}}/{{.APP_NAME}}-release.apk" + + generate:android:bindings: + internal: true + summary: Generates bindings for Android + sources: + - "**/*.go" + - go.mod + - go.sum + generates: + - frontend/bindings/**/* + cmds: + - wails3 generate bindings -f '{{.BUILD_FLAGS}}' -clean=true + env: + GOOS: android + CGO_ENABLED: 1 + GOARCH: '{{.ARCH | default "arm64"}}' + + ensure-emulator: + internal: true + summary: Ensure Android Emulator is running + silent: true + cmds: + - | + # Check if an emulator is already running + if adb devices | grep -q "emulator"; then + echo "Emulator already running" + exit 0 + fi + + # Get first available AVD + AVD_NAME=$(emulator -list-avds | head -1) + if [ -z "$AVD_NAME" ]; then + echo "No Android Virtual Devices found." + echo "Create one using: Android Studio > Tools > Device Manager" + exit 1 + fi + + echo "Starting emulator: $AVD_NAME" + emulator -avd "$AVD_NAME" -no-snapshot-load & + + # Wait for emulator to boot (max 60 seconds) + echo "Waiting for emulator to boot..." + adb wait-for-device + + for i in {1..60}; do + BOOT_COMPLETED=$(adb shell getprop sys.boot_completed 2>/dev/null | tr -d '\r') + if [ "$BOOT_COMPLETED" = "1" ]; then + echo "Emulator booted successfully" + exit 0 + fi + sleep 1 + done + + echo "Emulator boot timeout" + exit 1 + preconditions: + - sh: command -v adb + msg: "adb not found. Please install Android SDK and add platform-tools to PATH" + - sh: command -v emulator + msg: "emulator not found. Please install Android SDK and add emulator to PATH" + + deploy-emulator: + summary: Deploy to Android Emulator + deps: [package] + cmds: + - adb uninstall {{.APP_ID}} 2>/dev/null || true + - adb install {{.BIN_DIR}}/{{.APP_NAME}}.apk + - adb shell am start -n {{.APP_ID}}/.MainActivity + + run: + summary: Run the application in Android Emulator + deps: + - task: ensure-emulator + - task: build + vars: + ARCH: x86_64 + cmds: + - task: assemble:apk + - adb uninstall {{.APP_ID}} 2>/dev/null || true + - adb install {{.BIN_DIR}}/{{.APP_NAME}}.apk + - adb shell am start -n {{.APP_ID}}/.MainActivity + + logs: + summary: Stream Android logcat filtered to this app + cmds: + - adb logcat -v time | grep -E "(Wails|{{.APP_NAME}})" + + logs:all: + summary: Stream all Android logcat (verbose) + cmds: + - adb logcat -v time + + clean: + summary: Clean build artifacts + cmds: + - rm -rf {{.BIN_DIR}} + - rm -rf build/android/app/build + - rm -rf build/android/app/src/main/jniLibs/*/libwails.so + - rm -rf build/android/.gradle diff --git a/v3/examples/android/build/android/app/build.gradle b/v3/examples/android/build/android/app/build.gradle new file mode 100644 index 000000000..78fdbf7d9 --- /dev/null +++ b/v3/examples/android/build/android/app/build.gradle @@ -0,0 +1,63 @@ +plugins { + id 'com.android.application' +} + +android { + namespace 'com.wails.app' + compileSdk 34 + + buildFeatures { + buildConfig = true + } + + defaultConfig { + applicationId "com.wails.app" + minSdk 21 + targetSdk 34 + versionCode 1 + versionName "1.0" + + // Configure supported ABIs + ndk { + abiFilters 'arm64-v8a', 'x86_64' + } + } + + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' + } + debug { + debuggable true + } + } + + compileOptions { + sourceCompatibility JavaVersion.VERSION_11 + targetCompatibility JavaVersion.VERSION_11 + } + + // Source sets configuration + sourceSets { + main { + // JNI libraries are in jniLibs folder + jniLibs.srcDirs = ['src/main/jniLibs'] + // Assets for the WebView + assets.srcDirs = ['src/main/assets'] + } + } + + // Packaging options + packagingOptions { + // Don't strip Go symbols in debug builds + doNotStrip '*/arm64-v8a/libwails.so' + doNotStrip '*/x86_64/libwails.so' + } +} + +dependencies { + implementation 'androidx.appcompat:appcompat:1.6.1' + implementation 'androidx.webkit:webkit:1.9.0' + implementation 'com.google.android.material:material:1.11.0' +} diff --git a/v3/examples/android/build/android/app/proguard-rules.pro b/v3/examples/android/build/android/app/proguard-rules.pro new file mode 100644 index 000000000..8b88c3dfd --- /dev/null +++ b/v3/examples/android/build/android/app/proguard-rules.pro @@ -0,0 +1,12 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. + +# Keep native methods +-keepclasseswithmembernames class * { + native ; +} + +# Keep Wails bridge classes +-keep class com.wails.app.WailsBridge { *; } +-keep class com.wails.app.WailsJSBridge { *; } diff --git a/v3/examples/android/build/android/app/src/main/AndroidManifest.xml b/v3/examples/android/build/android/app/src/main/AndroidManifest.xml new file mode 100644 index 000000000..6c7982af1 --- /dev/null +++ b/v3/examples/android/build/android/app/src/main/AndroidManifest.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + diff --git a/v3/examples/android/build/android/app/src/main/java/com/wails/app/MainActivity.java b/v3/examples/android/build/android/app/src/main/java/com/wails/app/MainActivity.java new file mode 100644 index 000000000..3067fee09 --- /dev/null +++ b/v3/examples/android/build/android/app/src/main/java/com/wails/app/MainActivity.java @@ -0,0 +1,198 @@ +package com.wails.app; + +import android.annotation.SuppressLint; +import android.os.Bundle; +import android.util.Log; +import android.webkit.WebResourceRequest; +import android.webkit.WebResourceResponse; +import android.webkit.WebSettings; +import android.webkit.WebView; +import android.webkit.WebViewClient; + +import androidx.annotation.Nullable; +import androidx.appcompat.app.AppCompatActivity; +import androidx.webkit.WebViewAssetLoader; +import com.wails.app.BuildConfig; + +/** + * MainActivity hosts the WebView and manages the Wails application lifecycle. + * It uses WebViewAssetLoader to serve assets from the Go library without + * requiring a network server. + */ +public class MainActivity extends AppCompatActivity { + private static final String TAG = "WailsActivity"; + private static final String WAILS_SCHEME = "https"; + private static final String WAILS_HOST = "wails.localhost"; + + private WebView webView; + private WailsBridge bridge; + private WebViewAssetLoader assetLoader; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_main); + + // Initialize the native Go library + bridge = new WailsBridge(this); + bridge.initialize(); + + // Set up WebView + setupWebView(); + + // Load the application + loadApplication(); + } + + @SuppressLint("SetJavaScriptEnabled") + private void setupWebView() { + webView = findViewById(R.id.webview); + + // Configure WebView settings + WebSettings settings = webView.getSettings(); + settings.setJavaScriptEnabled(true); + settings.setDomStorageEnabled(true); + settings.setDatabaseEnabled(true); + settings.setAllowFileAccess(false); + settings.setAllowContentAccess(false); + settings.setMediaPlaybackRequiresUserGesture(false); + settings.setMixedContentMode(WebSettings.MIXED_CONTENT_NEVER_ALLOW); + + // Enable debugging in debug builds + if (BuildConfig.DEBUG) { + WebView.setWebContentsDebuggingEnabled(true); + } + + // Set up asset loader for serving local assets + assetLoader = new WebViewAssetLoader.Builder() + .setDomain(WAILS_HOST) + .addPathHandler("/", new WailsPathHandler(bridge)) + .build(); + + // Set up WebView client to intercept requests + webView.setWebViewClient(new WebViewClient() { + @Nullable + @Override + public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) { + String url = request.getUrl().toString(); + Log.d(TAG, "Intercepting request: " + url); + + // Handle wails.localhost requests + if (request.getUrl().getHost() != null && + request.getUrl().getHost().equals(WAILS_HOST)) { + + // For wails API calls (runtime, capabilities, etc.), we need to pass the full URL + // including query string because WebViewAssetLoader.PathHandler strips query params + String path = request.getUrl().getPath(); + if (path != null && path.startsWith("/wails/")) { + // Get full path with query string for runtime calls + String fullPath = path; + String query = request.getUrl().getQuery(); + if (query != null && !query.isEmpty()) { + fullPath = path + "?" + query; + } + Log.d(TAG, "Wails API call detected, full path: " + fullPath); + + // Call bridge directly with full path + byte[] data = bridge.serveAsset(fullPath, request.getMethod(), "{}"); + if (data != null && data.length > 0) { + java.io.InputStream inputStream = new java.io.ByteArrayInputStream(data); + java.util.Map headers = new java.util.HashMap<>(); + headers.put("Access-Control-Allow-Origin", "*"); + headers.put("Cache-Control", "no-cache"); + headers.put("Content-Type", "application/json"); + + return new WebResourceResponse( + "application/json", + "UTF-8", + 200, + "OK", + headers, + inputStream + ); + } + // Return error response if data is null + return new WebResourceResponse( + "application/json", + "UTF-8", + 500, + "Internal Error", + new java.util.HashMap<>(), + new java.io.ByteArrayInputStream("{}".getBytes()) + ); + } + + // For regular assets, use the asset loader + return assetLoader.shouldInterceptRequest(request.getUrl()); + } + + return super.shouldInterceptRequest(view, request); + } + + @Override + public void onPageFinished(WebView view, String url) { + super.onPageFinished(view, url); + Log.d(TAG, "Page loaded: " + url); + // Inject Wails runtime + bridge.injectRuntime(webView, url); + } + }); + + // Add JavaScript interface for Go communication + webView.addJavascriptInterface(new WailsJSBridge(bridge, webView), "wails"); + } + + private void loadApplication() { + // Load the main page from the asset server + String url = WAILS_SCHEME + "://" + WAILS_HOST + "/"; + Log.d(TAG, "Loading URL: " + url); + webView.loadUrl(url); + } + + /** + * Execute JavaScript in the WebView from the Go side + */ + public void executeJavaScript(final String js) { + runOnUiThread(() -> { + if (webView != null) { + webView.evaluateJavascript(js, null); + } + }); + } + + @Override + protected void onResume() { + super.onResume(); + if (bridge != null) { + bridge.onResume(); + } + } + + @Override + protected void onPause() { + super.onPause(); + if (bridge != null) { + bridge.onPause(); + } + } + + @Override + protected void onDestroy() { + super.onDestroy(); + if (bridge != null) { + bridge.shutdown(); + } + if (webView != null) { + webView.destroy(); + } + } + + @Override + public void onBackPressed() { + if (webView != null && webView.canGoBack()) { + webView.goBack(); + } else { + super.onBackPressed(); + } + } +} diff --git a/v3/examples/android/build/android/app/src/main/java/com/wails/app/WailsBridge.java b/v3/examples/android/build/android/app/src/main/java/com/wails/app/WailsBridge.java new file mode 100644 index 000000000..3dab65247 --- /dev/null +++ b/v3/examples/android/build/android/app/src/main/java/com/wails/app/WailsBridge.java @@ -0,0 +1,214 @@ +package com.wails.app; + +import android.content.Context; +import android.util.Log; +import android.webkit.WebView; + +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicInteger; + +/** + * WailsBridge manages the connection between the Java/Android side and the Go native library. + * It handles: + * - Loading and initializing the native Go library + * - Serving asset requests from Go + * - Passing messages between JavaScript and Go + * - Managing callbacks for async operations + */ +public class WailsBridge { + private static final String TAG = "WailsBridge"; + + static { + // Load the native Go library + System.loadLibrary("wails"); + } + + private final Context context; + private final AtomicInteger callbackIdGenerator = new AtomicInteger(0); + private final ConcurrentHashMap pendingAssetCallbacks = new ConcurrentHashMap<>(); + private final ConcurrentHashMap pendingMessageCallbacks = new ConcurrentHashMap<>(); + private WebView webView; + private volatile boolean initialized = false; + + // Native methods - implemented in Go + private static native void nativeInit(WailsBridge bridge); + private static native void nativeShutdown(); + private static native void nativeOnResume(); + private static native void nativeOnPause(); + private static native void nativeOnPageFinished(String url); + private static native byte[] nativeServeAsset(String path, String method, String headers); + private static native String nativeHandleMessage(String message); + private static native String nativeGetAssetMimeType(String path); + + public WailsBridge(Context context) { + this.context = context; + } + + /** + * Initialize the native Go library + */ + public void initialize() { + if (initialized) { + return; + } + + Log.i(TAG, "Initializing Wails bridge..."); + try { + nativeInit(this); + initialized = true; + Log.i(TAG, "Wails bridge initialized successfully"); + } catch (Exception e) { + Log.e(TAG, "Failed to initialize Wails bridge", e); + } + } + + /** + * Shutdown the native Go library + */ + public void shutdown() { + if (!initialized) { + return; + } + + Log.i(TAG, "Shutting down Wails bridge..."); + try { + nativeShutdown(); + initialized = false; + } catch (Exception e) { + Log.e(TAG, "Error during shutdown", e); + } + } + + /** + * Called when the activity resumes + */ + public void onResume() { + if (initialized) { + nativeOnResume(); + } + } + + /** + * Called when the activity pauses + */ + public void onPause() { + if (initialized) { + nativeOnPause(); + } + } + + /** + * Serve an asset from the Go asset server + * @param path The URL path requested + * @param method The HTTP method + * @param headers The request headers as JSON + * @return The asset data, or null if not found + */ + public byte[] serveAsset(String path, String method, String headers) { + if (!initialized) { + Log.w(TAG, "Bridge not initialized, cannot serve asset: " + path); + return null; + } + + Log.d(TAG, "Serving asset: " + path); + try { + return nativeServeAsset(path, method, headers); + } catch (Exception e) { + Log.e(TAG, "Error serving asset: " + path, e); + return null; + } + } + + /** + * Get the MIME type for an asset + * @param path The asset path + * @return The MIME type string + */ + public String getAssetMimeType(String path) { + if (!initialized) { + return "application/octet-stream"; + } + + try { + String mimeType = nativeGetAssetMimeType(path); + return mimeType != null ? mimeType : "application/octet-stream"; + } catch (Exception e) { + Log.e(TAG, "Error getting MIME type for: " + path, e); + return "application/octet-stream"; + } + } + + /** + * Handle a message from JavaScript + * @param message The message from JavaScript (JSON) + * @return The response to send back to JavaScript (JSON) + */ + public String handleMessage(String message) { + if (!initialized) { + Log.w(TAG, "Bridge not initialized, cannot handle message"); + return "{\"error\":\"Bridge not initialized\"}"; + } + + Log.d(TAG, "Handling message from JS: " + message); + try { + return nativeHandleMessage(message); + } catch (Exception e) { + Log.e(TAG, "Error handling message", e); + return "{\"error\":\"" + e.getMessage() + "\"}"; + } + } + + /** + * Inject the Wails runtime JavaScript into the WebView. + * Called when the page finishes loading. + * @param webView The WebView to inject into + * @param url The URL that finished loading + */ + public void injectRuntime(WebView webView, String url) { + this.webView = webView; + // Notify Go side that page has finished loading so it can inject the runtime + Log.d(TAG, "Page finished loading: " + url + ", notifying Go side"); + if (initialized) { + nativeOnPageFinished(url); + } + } + + /** + * Execute JavaScript in the WebView (called from Go side) + * @param js The JavaScript code to execute + */ + public void executeJavaScript(String js) { + if (webView != null) { + webView.post(() -> webView.evaluateJavascript(js, null)); + } + } + + /** + * Called from Go when an event needs to be emitted to JavaScript + * @param eventName The event name + * @param eventData The event data (JSON) + */ + public void emitEvent(String eventName, String eventData) { + String js = String.format("window.wails && window.wails._emit('%s', %s);", + escapeJsString(eventName), eventData); + executeJavaScript(js); + } + + private String escapeJsString(String str) { + return str.replace("\\", "\\\\") + .replace("'", "\\'") + .replace("\n", "\\n") + .replace("\r", "\\r"); + } + + // Callback interfaces + public interface AssetCallback { + void onAssetReady(byte[] data, String mimeType); + void onAssetError(String error); + } + + public interface MessageCallback { + void onResponse(String response); + void onError(String error); + } +} diff --git a/v3/examples/android/build/android/app/src/main/java/com/wails/app/WailsJSBridge.java b/v3/examples/android/build/android/app/src/main/java/com/wails/app/WailsJSBridge.java new file mode 100644 index 000000000..98ae5b247 --- /dev/null +++ b/v3/examples/android/build/android/app/src/main/java/com/wails/app/WailsJSBridge.java @@ -0,0 +1,142 @@ +package com.wails.app; + +import android.util.Log; +import android.webkit.JavascriptInterface; +import android.webkit.WebView; +import com.wails.app.BuildConfig; + +/** + * WailsJSBridge provides the JavaScript interface that allows the web frontend + * to communicate with the Go backend. This is exposed to JavaScript as the + * `window.wails` object. + * + * Similar to iOS's WKScriptMessageHandler but using Android's addJavascriptInterface. + */ +public class WailsJSBridge { + private static final String TAG = "WailsJSBridge"; + + private final WailsBridge bridge; + private final WebView webView; + + public WailsJSBridge(WailsBridge bridge, WebView webView) { + this.bridge = bridge; + this.webView = webView; + } + + /** + * Send a message to Go and return the response synchronously. + * Called from JavaScript: wails.invoke(message) + * + * @param message The message to send (JSON string) + * @return The response from Go (JSON string) + */ + @JavascriptInterface + public String invoke(String message) { + Log.d(TAG, "Invoke called: " + message); + return bridge.handleMessage(message); + } + + /** + * Send a message to Go asynchronously. + * The response will be sent back via a callback. + * Called from JavaScript: wails.invokeAsync(callbackId, message) + * + * @param callbackId The callback ID to use for the response + * @param message The message to send (JSON string) + */ + @JavascriptInterface + public void invokeAsync(final String callbackId, final String message) { + Log.d(TAG, "InvokeAsync called: " + message); + + // Handle in background thread to not block JavaScript + new Thread(() -> { + try { + String response = bridge.handleMessage(message); + sendCallback(callbackId, response, null); + } catch (Exception e) { + Log.e(TAG, "Error in async invoke", e); + sendCallback(callbackId, null, e.getMessage()); + } + }).start(); + } + + /** + * Log a message from JavaScript to Android's logcat + * Called from JavaScript: wails.log(level, message) + * + * @param level The log level (debug, info, warn, error) + * @param message The message to log + */ + @JavascriptInterface + public void log(String level, String message) { + switch (level.toLowerCase()) { + case "debug": + Log.d(TAG + "/JS", message); + break; + case "info": + Log.i(TAG + "/JS", message); + break; + case "warn": + Log.w(TAG + "/JS", message); + break; + case "error": + Log.e(TAG + "/JS", message); + break; + default: + Log.v(TAG + "/JS", message); + break; + } + } + + /** + * Get the platform name + * Called from JavaScript: wails.platform() + * + * @return "android" + */ + @JavascriptInterface + public String platform() { + return "android"; + } + + /** + * Check if we're running in debug mode + * Called from JavaScript: wails.isDebug() + * + * @return true if debug build, false otherwise + */ + @JavascriptInterface + public boolean isDebug() { + return BuildConfig.DEBUG; + } + + /** + * Send a callback response to JavaScript + */ + private void sendCallback(String callbackId, String result, String error) { + final String js; + if (error != null) { + js = String.format( + "window.wails && window.wails._callback('%s', null, '%s');", + escapeJsString(callbackId), + escapeJsString(error) + ); + } else { + js = String.format( + "window.wails && window.wails._callback('%s', %s, null);", + escapeJsString(callbackId), + result != null ? result : "null" + ); + } + + webView.post(() -> webView.evaluateJavascript(js, null)); + } + + private String escapeJsString(String str) { + if (str == null) return ""; + return str.replace("\\", "\\\\") + .replace("'", "\\'") + .replace("\n", "\\n") + .replace("\r", "\\r"); + } +} diff --git a/v3/examples/android/build/android/app/src/main/java/com/wails/app/WailsPathHandler.java b/v3/examples/android/build/android/app/src/main/java/com/wails/app/WailsPathHandler.java new file mode 100644 index 000000000..326fa9b4d --- /dev/null +++ b/v3/examples/android/build/android/app/src/main/java/com/wails/app/WailsPathHandler.java @@ -0,0 +1,118 @@ +package com.wails.app; + +import android.net.Uri; +import android.util.Log; +import android.webkit.WebResourceResponse; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.webkit.WebViewAssetLoader; + +import java.io.ByteArrayInputStream; +import java.io.InputStream; +import java.util.HashMap; +import java.util.Map; + +/** + * WailsPathHandler implements WebViewAssetLoader.PathHandler to serve assets + * from the Go asset server. This allows the WebView to load assets without + * using a network server, similar to iOS's WKURLSchemeHandler. + */ +public class WailsPathHandler implements WebViewAssetLoader.PathHandler { + private static final String TAG = "WailsPathHandler"; + + private final WailsBridge bridge; + + public WailsPathHandler(WailsBridge bridge) { + this.bridge = bridge; + } + + @Nullable + @Override + public WebResourceResponse handle(@NonNull String path) { + Log.d(TAG, "Handling path: " + path); + + // Normalize path + if (path.isEmpty() || path.equals("/")) { + path = "/index.html"; + } + + // Get asset from Go + byte[] data = bridge.serveAsset(path, "GET", "{}"); + + if (data == null || data.length == 0) { + Log.w(TAG, "Asset not found: " + path); + return null; // Return null to let WebView handle 404 + } + + // Determine MIME type + String mimeType = bridge.getAssetMimeType(path); + Log.d(TAG, "Serving " + path + " with type " + mimeType + " (" + data.length + " bytes)"); + + // Create response + InputStream inputStream = new ByteArrayInputStream(data); + Map headers = new HashMap<>(); + headers.put("Access-Control-Allow-Origin", "*"); + headers.put("Cache-Control", "no-cache"); + + return new WebResourceResponse( + mimeType, + "UTF-8", + 200, + "OK", + headers, + inputStream + ); + } + + /** + * Determine MIME type from file extension + */ + private String getMimeType(String path) { + String lowerPath = path.toLowerCase(); + + if (lowerPath.endsWith(".html") || lowerPath.endsWith(".htm")) { + return "text/html"; + } else if (lowerPath.endsWith(".js") || lowerPath.endsWith(".mjs")) { + return "application/javascript"; + } else if (lowerPath.endsWith(".css")) { + return "text/css"; + } else if (lowerPath.endsWith(".json")) { + return "application/json"; + } else if (lowerPath.endsWith(".png")) { + return "image/png"; + } else if (lowerPath.endsWith(".jpg") || lowerPath.endsWith(".jpeg")) { + return "image/jpeg"; + } else if (lowerPath.endsWith(".gif")) { + return "image/gif"; + } else if (lowerPath.endsWith(".svg")) { + return "image/svg+xml"; + } else if (lowerPath.endsWith(".ico")) { + return "image/x-icon"; + } else if (lowerPath.endsWith(".woff")) { + return "font/woff"; + } else if (lowerPath.endsWith(".woff2")) { + return "font/woff2"; + } else if (lowerPath.endsWith(".ttf")) { + return "font/ttf"; + } else if (lowerPath.endsWith(".eot")) { + return "application/vnd.ms-fontobject"; + } else if (lowerPath.endsWith(".xml")) { + return "application/xml"; + } else if (lowerPath.endsWith(".txt")) { + return "text/plain"; + } else if (lowerPath.endsWith(".wasm")) { + return "application/wasm"; + } else if (lowerPath.endsWith(".mp3")) { + return "audio/mpeg"; + } else if (lowerPath.endsWith(".mp4")) { + return "video/mp4"; + } else if (lowerPath.endsWith(".webm")) { + return "video/webm"; + } else if (lowerPath.endsWith(".webp")) { + return "image/webp"; + } + + return "application/octet-stream"; + } +} diff --git a/v3/examples/android/build/android/app/src/main/res/layout/activity_main.xml b/v3/examples/android/build/android/app/src/main/res/layout/activity_main.xml new file mode 100644 index 000000000..f278384c7 --- /dev/null +++ b/v3/examples/android/build/android/app/src/main/res/layout/activity_main.xml @@ -0,0 +1,12 @@ + + + + + + diff --git a/v3/examples/android/build/android/app/src/main/res/mipmap-hdpi/ic_launcher.png b/v3/examples/android/build/android/app/src/main/res/mipmap-hdpi/ic_launcher.png new file mode 100644 index 000000000..9409abebe Binary files /dev/null and b/v3/examples/android/build/android/app/src/main/res/mipmap-hdpi/ic_launcher.png differ diff --git a/v3/examples/android/build/android/app/src/main/res/mipmap-hdpi/ic_launcher_round.png b/v3/examples/android/build/android/app/src/main/res/mipmap-hdpi/ic_launcher_round.png new file mode 100644 index 000000000..9409abebe Binary files /dev/null and b/v3/examples/android/build/android/app/src/main/res/mipmap-hdpi/ic_launcher_round.png differ diff --git a/v3/examples/android/build/android/app/src/main/res/mipmap-mdpi/ic_launcher.png b/v3/examples/android/build/android/app/src/main/res/mipmap-mdpi/ic_launcher.png new file mode 100644 index 000000000..5b6acc048 Binary files /dev/null and b/v3/examples/android/build/android/app/src/main/res/mipmap-mdpi/ic_launcher.png differ diff --git a/v3/examples/android/build/android/app/src/main/res/mipmap-mdpi/ic_launcher_round.png b/v3/examples/android/build/android/app/src/main/res/mipmap-mdpi/ic_launcher_round.png new file mode 100644 index 000000000..5b6acc048 Binary files /dev/null and b/v3/examples/android/build/android/app/src/main/res/mipmap-mdpi/ic_launcher_round.png differ diff --git a/v3/examples/android/build/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/v3/examples/android/build/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png new file mode 100644 index 000000000..1c2c66452 Binary files /dev/null and b/v3/examples/android/build/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png differ diff --git a/v3/examples/android/build/android/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png b/v3/examples/android/build/android/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png new file mode 100644 index 000000000..1c2c66452 Binary files /dev/null and b/v3/examples/android/build/android/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png differ diff --git a/v3/examples/android/build/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/v3/examples/android/build/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png new file mode 100644 index 000000000..be557d897 Binary files /dev/null and b/v3/examples/android/build/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png differ diff --git a/v3/examples/android/build/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png b/v3/examples/android/build/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png new file mode 100644 index 000000000..be557d897 Binary files /dev/null and b/v3/examples/android/build/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png differ diff --git a/v3/examples/android/build/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png b/v3/examples/android/build/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png new file mode 100644 index 000000000..4507f32a5 Binary files /dev/null and b/v3/examples/android/build/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png differ diff --git a/v3/examples/android/build/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png b/v3/examples/android/build/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png new file mode 100644 index 000000000..4507f32a5 Binary files /dev/null and b/v3/examples/android/build/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png differ diff --git a/v3/examples/android/build/android/app/src/main/res/values/colors.xml b/v3/examples/android/build/android/app/src/main/res/values/colors.xml new file mode 100644 index 000000000..dd33f3b7d --- /dev/null +++ b/v3/examples/android/build/android/app/src/main/res/values/colors.xml @@ -0,0 +1,8 @@ + + + #3574D4 + #2C5FB8 + #1B2636 + #FFFFFFFF + #FF000000 + diff --git a/v3/examples/android/build/android/app/src/main/res/values/strings.xml b/v3/examples/android/build/android/app/src/main/res/values/strings.xml new file mode 100644 index 000000000..3ed9e4717 --- /dev/null +++ b/v3/examples/android/build/android/app/src/main/res/values/strings.xml @@ -0,0 +1,4 @@ + + + Wails App + diff --git a/v3/examples/android/build/android/app/src/main/res/values/themes.xml b/v3/examples/android/build/android/app/src/main/res/values/themes.xml new file mode 100644 index 000000000..be8a282b2 --- /dev/null +++ b/v3/examples/android/build/android/app/src/main/res/values/themes.xml @@ -0,0 +1,14 @@ + + + + diff --git a/v3/examples/android/build/android/build.gradle b/v3/examples/android/build/android/build.gradle new file mode 100644 index 000000000..d7fbab39a --- /dev/null +++ b/v3/examples/android/build/android/build.gradle @@ -0,0 +1,4 @@ +// Top-level build file where you can add configuration options common to all sub-projects/modules. +plugins { + id 'com.android.application' version '8.7.3' apply false +} diff --git a/v3/examples/android/build/android/build/reports/problems/problems-report.html b/v3/examples/android/build/android/build/reports/problems/problems-report.html new file mode 100644 index 000000000..2f0196fac --- /dev/null +++ b/v3/examples/android/build/android/build/reports/problems/problems-report.html @@ -0,0 +1,659 @@ + + + + + + + + + + + + + Gradle Configuration Cache + + + +
+ +
+ Loading... +
+ + + + + + diff --git a/v3/examples/android/build/android/gradle.properties b/v3/examples/android/build/android/gradle.properties new file mode 100644 index 000000000..b9d4426d5 --- /dev/null +++ b/v3/examples/android/build/android/gradle.properties @@ -0,0 +1,26 @@ +# Project-wide Gradle settings. +# IDE (e.g. Android Studio) users: +# Gradle settings configured through the IDE *will override* +# any settings specified in this file. + +# For more details on how to configure your build environment visit +# http://www.gradle.org/docs/current/userguide/build_environment.html + +# Specifies the JVM arguments used for the daemon process. +# The setting is particularly useful for tweaking memory settings. +org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8 + +# When configured, Gradle will run in incubating parallel mode. +# This option should only be used with decoupled projects. For more details, visit +# https://developer.android.com/build/optimize-your-build#parallel +# org.gradle.parallel=true + +# AndroidX package structure to make it clearer which packages are bundled with the +# Android operating system, and which are packaged with your app's APK +# https://developer.android.com/topic/libraries/support-library/androidx-rn +android.useAndroidX=true + +# Enables namespacing of each library's R class so that its R class includes only the +# resources declared in the library itself and none from the library's dependencies, +# thereby reducing the size of the R class for that library +android.nonTransitiveRClass=true diff --git a/v3/examples/android/build/android/gradle/wrapper/gradle-wrapper.jar b/v3/examples/android/build/android/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 000000000..f8e1ee312 Binary files /dev/null and b/v3/examples/android/build/android/gradle/wrapper/gradle-wrapper.jar differ diff --git a/v3/examples/android/build/android/gradle/wrapper/gradle-wrapper.properties b/v3/examples/android/build/android/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 000000000..23449a2b5 --- /dev/null +++ b/v3/examples/android/build/android/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,7 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip +networkTimeout=10000 +validateDistributionUrl=true +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/v3/examples/android/build/android/gradlew b/v3/examples/android/build/android/gradlew new file mode 100755 index 000000000..adff685a0 --- /dev/null +++ b/v3/examples/android/build/android/gradlew @@ -0,0 +1,248 @@ +#!/bin/sh + +# +# Copyright © 2015 the original authors. +# +# 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 +# +# https://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. +# +# SPDX-License-Identifier: Apache-2.0 +# + +############################################################################## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + + + +# Determine the Java command to use to start the JVM. +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 + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/v3/examples/android/build/android/gradlew.bat b/v3/examples/android/build/android/gradlew.bat new file mode 100644 index 000000000..e509b2dd8 --- /dev/null +++ b/v3/examples/android/build/android/gradlew.bat @@ -0,0 +1,93 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:execute +@rem Setup the command line + + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/v3/examples/android/build/android/scripts/deps/install_deps.go b/v3/examples/android/build/android/scripts/deps/install_deps.go new file mode 100644 index 000000000..d9dfedf80 --- /dev/null +++ b/v3/examples/android/build/android/scripts/deps/install_deps.go @@ -0,0 +1,151 @@ +package main + +import ( + "fmt" + "os" + "os/exec" + "path/filepath" + "runtime" + "strings" +) + +func main() { + fmt.Println("Checking Android development dependencies...") + fmt.Println() + + errors := []string{} + + // Check Go + if !checkCommand("go", "version") { + errors = append(errors, "Go is not installed. Install from https://go.dev/dl/") + } else { + fmt.Println("✓ Go is installed") + } + + // Check ANDROID_HOME + androidHome := os.Getenv("ANDROID_HOME") + if androidHome == "" { + androidHome = os.Getenv("ANDROID_SDK_ROOT") + } + if androidHome == "" { + // Try common default locations + home, _ := os.UserHomeDir() + possiblePaths := []string{ + filepath.Join(home, "Android", "Sdk"), + filepath.Join(home, "Library", "Android", "sdk"), + "/usr/local/share/android-sdk", + } + for _, p := range possiblePaths { + if _, err := os.Stat(p); err == nil { + androidHome = p + break + } + } + } + + if androidHome == "" { + errors = append(errors, "ANDROID_HOME not set. Install Android Studio and set ANDROID_HOME environment variable") + } else { + fmt.Printf("✓ ANDROID_HOME: %s\n", androidHome) + } + + // Check adb + if !checkCommand("adb", "version") { + if androidHome != "" { + platformTools := filepath.Join(androidHome, "platform-tools") + errors = append(errors, fmt.Sprintf("adb not found. Add %s to PATH", platformTools)) + } else { + errors = append(errors, "adb not found. Install Android SDK Platform-Tools") + } + } else { + fmt.Println("✓ adb is installed") + } + + // Check emulator + if !checkCommand("emulator", "-list-avds") { + if androidHome != "" { + emulatorPath := filepath.Join(androidHome, "emulator") + errors = append(errors, fmt.Sprintf("emulator not found. Add %s to PATH", emulatorPath)) + } else { + errors = append(errors, "emulator not found. Install Android Emulator via SDK Manager") + } + } else { + fmt.Println("✓ Android Emulator is installed") + } + + // Check NDK + ndkHome := os.Getenv("ANDROID_NDK_HOME") + if ndkHome == "" && androidHome != "" { + // Look for NDK in default location + ndkDir := filepath.Join(androidHome, "ndk") + if entries, err := os.ReadDir(ndkDir); err == nil { + for _, entry := range entries { + if entry.IsDir() { + ndkHome = filepath.Join(ndkDir, entry.Name()) + break + } + } + } + } + + if ndkHome == "" { + errors = append(errors, "Android NDK not found. Install NDK via Android Studio > SDK Manager > SDK Tools > NDK (Side by side)") + } else { + fmt.Printf("✓ Android NDK: %s\n", ndkHome) + } + + // Check Java + if !checkCommand("java", "-version") { + errors = append(errors, "Java not found. Install JDK 11+ (OpenJDK recommended)") + } else { + fmt.Println("✓ Java is installed") + } + + // Check for AVD (Android Virtual Device) + if checkCommand("emulator", "-list-avds") { + cmd := exec.Command("emulator", "-list-avds") + output, err := cmd.Output() + if err == nil && len(strings.TrimSpace(string(output))) > 0 { + avds := strings.Split(strings.TrimSpace(string(output)), "\n") + fmt.Printf("✓ Found %d Android Virtual Device(s)\n", len(avds)) + } else { + fmt.Println("⚠ No Android Virtual Devices found. Create one via Android Studio > Tools > Device Manager") + } + } + + fmt.Println() + + if len(errors) > 0 { + fmt.Println("❌ Missing dependencies:") + for _, err := range errors { + fmt.Printf(" - %s\n", err) + } + fmt.Println() + fmt.Println("Setup instructions:") + fmt.Println("1. Install Android Studio: https://developer.android.com/studio") + fmt.Println("2. Open SDK Manager and install:") + fmt.Println(" - Android SDK Platform (API 34)") + fmt.Println(" - Android SDK Build-Tools") + fmt.Println(" - Android SDK Platform-Tools") + fmt.Println(" - Android Emulator") + fmt.Println(" - NDK (Side by side)") + fmt.Println("3. Set environment variables:") + if runtime.GOOS == "darwin" { + fmt.Println(" export ANDROID_HOME=$HOME/Library/Android/sdk") + } else { + fmt.Println(" export ANDROID_HOME=$HOME/Android/Sdk") + } + fmt.Println(" export PATH=$PATH:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator") + fmt.Println("4. Create an AVD via Android Studio > Tools > Device Manager") + os.Exit(1) + } + + fmt.Println("✓ All Android development dependencies are installed!") +} + +func checkCommand(name string, args ...string) bool { + cmd := exec.Command(name, args...) + cmd.Stdout = nil + cmd.Stderr = nil + return cmd.Run() == nil +} diff --git a/v3/examples/android/build/android/settings.gradle b/v3/examples/android/build/android/settings.gradle new file mode 100644 index 000000000..a3f3ec3d4 --- /dev/null +++ b/v3/examples/android/build/android/settings.gradle @@ -0,0 +1,18 @@ +pluginManagement { + repositories { + google() + mavenCentral() + gradlePluginPortal() + } +} + +dependencyResolutionManagement { + repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS) + repositories { + google() + mavenCentral() + } +} + +rootProject.name = "WailsApp" +include ':app' diff --git a/v3/examples/android/build/appicon.png b/v3/examples/android/build/appicon.png new file mode 100644 index 000000000..63617fe4f Binary files /dev/null and b/v3/examples/android/build/appicon.png differ diff --git a/v3/examples/android/build/config.yml b/v3/examples/android/build/config.yml new file mode 100644 index 000000000..c8adba60d --- /dev/null +++ b/v3/examples/android/build/config.yml @@ -0,0 +1,75 @@ +# This file contains the configuration for this project. +# When you update `info` or `fileAssociations`, run `wails3 task common:update:build-assets` to update the assets. +# Note that this will overwrite any changes you have made to the assets. +version: '3' + +# This information is used to generate the build assets. +info: + companyName: "My Company" # The name of the company + productName: "My Product" # The name of the application + productIdentifier: "com.mycompany.myproduct" # The unique product identifier + description: "A program that does X" # The application description + copyright: "(c) 2025, My Company" # Copyright text + comments: "Some Product Comments" # Comments + version: "0.0.1" # The application version + +# Android build configuration (uncomment to customise Android project generation) +# Note: Keys under `android` OVERRIDE values under `info` when set. +# android: +# # The Android application ID used in the generated project (applicationId) +# applicationId: "com.mycompany.myproduct" +# # The display name shown under the app icon +# displayName: "My Product" +# # The app version code (integer, must increment for each release) +# versionCode: 1 +# # The app version name (displayed to users) +# versionName: "0.0.1" +# # Minimum SDK version (API level) +# minSdkVersion: 21 +# # Target SDK version (API level) +# targetSdkVersion: 34 +# # The company/organisation name for templates and project settings +# company: "My Company" + +# Dev mode configuration +dev_mode: + root_path: . + log_level: warn + debounce: 1000 + ignore: + dir: + - .git + - node_modules + - frontend + - bin + file: + - .DS_Store + - .gitignore + - .gitkeep + watched_extension: + - "*.go" + git_ignore: true + executes: + - cmd: wails3 task common:install:frontend:deps + type: once + - cmd: wails3 task common:dev:frontend + type: background + - cmd: go mod tidy + type: blocking + - cmd: wails3 task build + type: blocking + - cmd: wails3 task run + type: primary + +# File Associations +# More information at: https://v3.wails.io/noit/done/yet +fileAssociations: +# - ext: wails +# name: Wails +# description: Wails Application File +# iconName: wailsFileIcon +# role: Editor + +# Other data +other: + - name: My Other Data diff --git a/v3/examples/android/build/darwin/Info.dev.plist b/v3/examples/android/build/darwin/Info.dev.plist new file mode 100644 index 000000000..bd6a537fa --- /dev/null +++ b/v3/examples/android/build/darwin/Info.dev.plist @@ -0,0 +1,32 @@ + + + + CFBundlePackageType + APPL + CFBundleName + My Product + CFBundleExecutable + ios + CFBundleIdentifier + com.wails.ios + CFBundleVersion + 0.1.0 + CFBundleGetInfoString + This is a comment + CFBundleShortVersionString + 0.1.0 + CFBundleIconFile + icons + LSMinimumSystemVersion + 10.15.0 + NSHighResolutionCapable + true + NSHumanReadableCopyright + © now, My Company + NSAppTransportSecurity + + NSAllowsLocalNetworking + + + + \ No newline at end of file diff --git a/v3/examples/android/build/darwin/Info.plist b/v3/examples/android/build/darwin/Info.plist new file mode 100644 index 000000000..fb52df715 --- /dev/null +++ b/v3/examples/android/build/darwin/Info.plist @@ -0,0 +1,27 @@ + + + + CFBundlePackageType + APPL + CFBundleName + My Product + CFBundleExecutable + ios + CFBundleIdentifier + com.wails.ios + CFBundleVersion + 0.1.0 + CFBundleGetInfoString + This is a comment + CFBundleShortVersionString + 0.1.0 + CFBundleIconFile + icons + LSMinimumSystemVersion + 10.15.0 + NSHighResolutionCapable + true + NSHumanReadableCopyright + © now, My Company + + \ No newline at end of file diff --git a/v3/examples/android/build/darwin/Taskfile.yml b/v3/examples/android/build/darwin/Taskfile.yml new file mode 100644 index 000000000..f0791fea9 --- /dev/null +++ b/v3/examples/android/build/darwin/Taskfile.yml @@ -0,0 +1,81 @@ +version: '3' + +includes: + common: ../Taskfile.yml + +tasks: + build: + summary: Creates a production build of the application + deps: + - task: common:go:mod:tidy + - task: common:build:frontend + vars: + BUILD_FLAGS: + ref: .BUILD_FLAGS + PRODUCTION: + ref: .PRODUCTION + - task: common:generate:icons + cmds: + - go build {{.BUILD_FLAGS}} -o {{.OUTPUT}} + vars: + BUILD_FLAGS: '{{if eq .PRODUCTION "true"}}-tags production -trimpath -buildvcs=false -ldflags="-w -s"{{else}}-buildvcs=false -gcflags=all="-l"{{end}}' + DEFAULT_OUTPUT: '{{.BIN_DIR}}/{{.APP_NAME}}' + OUTPUT: '{{ .OUTPUT | default .DEFAULT_OUTPUT }}' + env: + GOOS: darwin + CGO_ENABLED: 1 + GOARCH: '{{.ARCH | default ARCH}}' + CGO_CFLAGS: "-mmacosx-version-min=10.15" + CGO_LDFLAGS: "-mmacosx-version-min=10.15" + MACOSX_DEPLOYMENT_TARGET: "10.15" + PRODUCTION: '{{.PRODUCTION | default "false"}}' + + build:universal: + summary: Builds darwin universal binary (arm64 + amd64) + deps: + - task: build + vars: + ARCH: amd64 + OUTPUT: "{{.BIN_DIR}}/{{.APP_NAME}}-amd64" + - task: build + vars: + ARCH: arm64 + OUTPUT: "{{.BIN_DIR}}/{{.APP_NAME}}-arm64" + cmds: + - lipo -create -output "{{.BIN_DIR}}/{{.APP_NAME}}" "{{.BIN_DIR}}/{{.APP_NAME}}-amd64" "{{.BIN_DIR}}/{{.APP_NAME}}-arm64" + - rm "{{.BIN_DIR}}/{{.APP_NAME}}-amd64" "{{.BIN_DIR}}/{{.APP_NAME}}-arm64" + + package: + summary: Packages a production build of the application into a `.app` bundle + deps: + - task: build + vars: + PRODUCTION: "true" + cmds: + - task: create:app:bundle + + package:universal: + summary: Packages darwin universal binary (arm64 + amd64) + deps: + - task: build:universal + cmds: + - task: create:app:bundle + + + create:app:bundle: + summary: Creates an `.app` bundle + cmds: + - mkdir -p {{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/{MacOS,Resources} + - cp build/darwin/icons.icns {{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/Resources + - cp {{.BIN_DIR}}/{{.APP_NAME}} {{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/MacOS + - cp build/darwin/Info.plist {{.BIN_DIR}}/{{.APP_NAME}}.app/Contents + - codesign --force --deep --sign - {{.BIN_DIR}}/{{.APP_NAME}}.app + + run: + cmds: + - mkdir -p {{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/{MacOS,Resources} + - cp build/darwin/icons.icns {{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/Resources + - cp {{.BIN_DIR}}/{{.APP_NAME}} {{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/MacOS + - cp build/darwin/Info.dev.plist {{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/Info.plist + - codesign --force --deep --sign - {{.BIN_DIR}}/{{.APP_NAME}}.dev.app + - '{{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/MacOS/{{.APP_NAME}}' diff --git a/v3/examples/android/build/darwin/icons.icns b/v3/examples/android/build/darwin/icons.icns new file mode 100644 index 000000000..1b5bd4c86 Binary files /dev/null and b/v3/examples/android/build/darwin/icons.icns differ diff --git a/v3/examples/android/build/linux/Taskfile.yml b/v3/examples/android/build/linux/Taskfile.yml new file mode 100644 index 000000000..87fd599cc --- /dev/null +++ b/v3/examples/android/build/linux/Taskfile.yml @@ -0,0 +1,119 @@ +version: '3' + +includes: + common: ../Taskfile.yml + +tasks: + build: + summary: Builds the application for Linux + deps: + - task: common:go:mod:tidy + - task: common:build:frontend + vars: + BUILD_FLAGS: + ref: .BUILD_FLAGS + PRODUCTION: + ref: .PRODUCTION + - task: common:generate:icons + cmds: + - go build {{.BUILD_FLAGS}} -o {{.BIN_DIR}}/{{.APP_NAME}} + vars: + BUILD_FLAGS: '{{if eq .PRODUCTION "true"}}-tags production -trimpath -buildvcs=false -ldflags="-w -s"{{else}}-buildvcs=false -gcflags=all="-l"{{end}}' + env: + GOOS: linux + CGO_ENABLED: 1 + GOARCH: '{{.ARCH | default ARCH}}' + PRODUCTION: '{{.PRODUCTION | default "false"}}' + + package: + summary: Packages a production build of the application for Linux + deps: + - task: build + vars: + PRODUCTION: "true" + cmds: + - task: create:appimage + - task: create:deb + - task: create:rpm + - task: create:aur + + create:appimage: + summary: Creates an AppImage + dir: build/linux/appimage + deps: + - task: build + vars: + PRODUCTION: "true" + - task: generate:dotdesktop + cmds: + - cp {{.APP_BINARY}} {{.APP_NAME}} + - cp ../../appicon.png appicon.png + - wails3 generate appimage -binary {{.APP_NAME}} -icon {{.ICON}} -desktopfile {{.DESKTOP_FILE}} -outputdir {{.OUTPUT_DIR}} -builddir {{.ROOT_DIR}}/build/linux/appimage/build + vars: + APP_NAME: '{{.APP_NAME}}' + APP_BINARY: '../../../bin/{{.APP_NAME}}' + ICON: '../../appicon.png' + DESKTOP_FILE: '../{{.APP_NAME}}.desktop' + OUTPUT_DIR: '../../../bin' + + create:deb: + summary: Creates a deb package + deps: + - task: build + vars: + PRODUCTION: "true" + cmds: + - task: generate:dotdesktop + - task: generate:deb + + create:rpm: + summary: Creates a rpm package + deps: + - task: build + vars: + PRODUCTION: "true" + cmds: + - task: generate:dotdesktop + - task: generate:rpm + + create:aur: + summary: Creates a arch linux packager package + deps: + - task: build + vars: + PRODUCTION: "true" + cmds: + - task: generate:dotdesktop + - task: generate:aur + + generate:deb: + summary: Creates a deb package + cmds: + - wails3 tool package -name {{.APP_NAME}} -format deb -config ./build/linux/nfpm/nfpm.yaml -out {{.ROOT_DIR}}/bin + + generate:rpm: + summary: Creates a rpm package + cmds: + - wails3 tool package -name {{.APP_NAME}} -format rpm -config ./build/linux/nfpm/nfpm.yaml -out {{.ROOT_DIR}}/bin + + generate:aur: + summary: Creates a arch linux packager package + cmds: + - wails3 tool package -name {{.APP_NAME}} -format archlinux -config ./build/linux/nfpm/nfpm.yaml -out {{.ROOT_DIR}}/bin + + generate:dotdesktop: + summary: Generates a `.desktop` file + dir: build + cmds: + - mkdir -p {{.ROOT_DIR}}/build/linux/appimage + - wails3 generate .desktop -name "{{.APP_NAME}}" -exec "{{.EXEC}}" -icon "{{.ICON}}" -outputfile {{.ROOT_DIR}}/build/linux/{{.APP_NAME}}.desktop -categories "{{.CATEGORIES}}" + vars: + APP_NAME: '{{.APP_NAME}}' + EXEC: '{{.APP_NAME}}' + ICON: '{{.APP_NAME}}' + CATEGORIES: 'Development;' + OUTPUTFILE: '{{.ROOT_DIR}}/build/linux/{{.APP_NAME}}.desktop' + + run: + cmds: + - '{{.BIN_DIR}}/{{.APP_NAME}}' diff --git a/v3/examples/android/build/linux/appimage/build.sh b/v3/examples/android/build/linux/appimage/build.sh new file mode 100644 index 000000000..858f091ab --- /dev/null +++ b/v3/examples/android/build/linux/appimage/build.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +# Copyright (c) 2018-Present Lea Anthony +# SPDX-License-Identifier: MIT + +# Fail script on any error +set -euxo pipefail + +# Define variables +APP_DIR="${APP_NAME}.AppDir" + +# Create AppDir structure +mkdir -p "${APP_DIR}/usr/bin" +cp -r "${APP_BINARY}" "${APP_DIR}/usr/bin/" +cp "${ICON_PATH}" "${APP_DIR}/" +cp "${DESKTOP_FILE}" "${APP_DIR}/" + +if [[ $(uname -m) == *x86_64* ]]; then + # Download linuxdeploy and make it executable + wget -q -4 -N https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage + chmod +x linuxdeploy-x86_64.AppImage + + # Run linuxdeploy to bundle the application + ./linuxdeploy-x86_64.AppImage --appdir "${APP_DIR}" --output appimage +else + # Download linuxdeploy and make it executable (arm64) + wget -q -4 -N https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-aarch64.AppImage + chmod +x linuxdeploy-aarch64.AppImage + + # Run linuxdeploy to bundle the application (arm64) + ./linuxdeploy-aarch64.AppImage --appdir "${APP_DIR}" --output appimage +fi + +# Rename the generated AppImage +mv "${APP_NAME}*.AppImage" "${APP_NAME}.AppImage" diff --git a/v3/examples/android/build/linux/desktop b/v3/examples/android/build/linux/desktop new file mode 100644 index 000000000..e9b30cf39 --- /dev/null +++ b/v3/examples/android/build/linux/desktop @@ -0,0 +1,11 @@ +[Desktop Entry] +Version=1.0 +Name=My Product +Comment=My Product Description +# The Exec line includes %u to pass the URL to the application +Exec=/usr/local/bin/ios %u +Terminal=false +Type=Application +Icon=ios +Categories=Utility; +StartupWMClass=ios diff --git a/v3/examples/android/build/linux/nfpm/nfpm.yaml b/v3/examples/android/build/linux/nfpm/nfpm.yaml new file mode 100644 index 000000000..7b78433f4 --- /dev/null +++ b/v3/examples/android/build/linux/nfpm/nfpm.yaml @@ -0,0 +1,67 @@ +# Feel free to remove those if you don't want/need to use them. +# Make sure to check the documentation at https://nfpm.goreleaser.com +# +# The lines below are called `modelines`. See `:help modeline` + +name: "ios" +arch: ${GOARCH} +platform: "linux" +version: "0.1.0" +section: "default" +priority: "extra" +maintainer: ${GIT_COMMITTER_NAME} <${GIT_COMMITTER_EMAIL}> +description: "My Product Description" +vendor: "My Company" +homepage: "https://wails.io" +license: "MIT" +release: "1" + +contents: + - src: "./bin/ios" + dst: "/usr/local/bin/ios" + - src: "./build/appicon.png" + dst: "/usr/share/icons/hicolor/128x128/apps/ios.png" + - src: "./build/linux/ios.desktop" + dst: "/usr/share/applications/ios.desktop" + +# Default dependencies for Debian 12/Ubuntu 22.04+ with WebKit 4.1 +depends: + - libgtk-3-0 + - libwebkit2gtk-4.1-0 + +# Distribution-specific overrides for different package formats and WebKit versions +overrides: + # RPM packages for RHEL/CentOS/AlmaLinux/Rocky Linux (WebKit 4.0) + rpm: + depends: + - gtk3 + - webkit2gtk4.1 + + # Arch Linux packages (WebKit 4.1) + archlinux: + depends: + - gtk3 + - webkit2gtk-4.1 + +# scripts section to ensure desktop database is updated after install +scripts: + postinstall: "./build/linux/nfpm/scripts/postinstall.sh" + # You can also add preremove, postremove if needed + # preremove: "./build/linux/nfpm/scripts/preremove.sh" + # postremove: "./build/linux/nfpm/scripts/postremove.sh" + +# replaces: +# - foobar +# provides: +# - bar +# depends: +# - gtk3 +# - libwebkit2gtk +# recommends: +# - whatever +# suggests: +# - something-else +# conflicts: +# - not-foo +# - not-bar +# changelog: "changelog.yaml" diff --git a/v3/examples/android/build/linux/nfpm/scripts/postinstall.sh b/v3/examples/android/build/linux/nfpm/scripts/postinstall.sh new file mode 100644 index 000000000..4bbb815a3 --- /dev/null +++ b/v3/examples/android/build/linux/nfpm/scripts/postinstall.sh @@ -0,0 +1,21 @@ +#!/bin/sh + +# Update desktop database for .desktop file changes +# This makes the application appear in application menus and registers its capabilities. +if command -v update-desktop-database >/dev/null 2>&1; then + echo "Updating desktop database..." + update-desktop-database -q /usr/share/applications +else + echo "Warning: update-desktop-database command not found. Desktop file may not be immediately recognized." >&2 +fi + +# Update MIME database for custom URL schemes (x-scheme-handler) +# This ensures the system knows how to handle your custom protocols. +if command -v update-mime-database >/dev/null 2>&1; then + echo "Updating MIME database..." + update-mime-database -n /usr/share/mime +else + echo "Warning: update-mime-database command not found. Custom URL schemes may not be immediately recognized." >&2 +fi + +exit 0 diff --git a/v3/examples/android/build/linux/nfpm/scripts/postremove.sh b/v3/examples/android/build/linux/nfpm/scripts/postremove.sh new file mode 100644 index 000000000..a9bf588e2 --- /dev/null +++ b/v3/examples/android/build/linux/nfpm/scripts/postremove.sh @@ -0,0 +1 @@ +#!/bin/bash diff --git a/v3/examples/android/build/linux/nfpm/scripts/preinstall.sh b/v3/examples/android/build/linux/nfpm/scripts/preinstall.sh new file mode 100644 index 000000000..a9bf588e2 --- /dev/null +++ b/v3/examples/android/build/linux/nfpm/scripts/preinstall.sh @@ -0,0 +1 @@ +#!/bin/bash diff --git a/v3/examples/android/build/linux/nfpm/scripts/preremove.sh b/v3/examples/android/build/linux/nfpm/scripts/preremove.sh new file mode 100644 index 000000000..a9bf588e2 --- /dev/null +++ b/v3/examples/android/build/linux/nfpm/scripts/preremove.sh @@ -0,0 +1 @@ +#!/bin/bash diff --git a/v3/examples/android/build/windows/Taskfile.yml b/v3/examples/android/build/windows/Taskfile.yml new file mode 100644 index 000000000..19f137616 --- /dev/null +++ b/v3/examples/android/build/windows/Taskfile.yml @@ -0,0 +1,98 @@ +version: '3' + +includes: + common: ../Taskfile.yml + +tasks: + build: + summary: Builds the application for Windows + deps: + - task: common:go:mod:tidy + - task: common:build:frontend + vars: + BUILD_FLAGS: + ref: .BUILD_FLAGS + PRODUCTION: + ref: .PRODUCTION + - task: common:generate:icons + cmds: + - task: generate:syso + - go build {{.BUILD_FLAGS}} -o {{.BIN_DIR}}/{{.APP_NAME}}.exe + - cmd: powershell Remove-item *.syso + platforms: [windows] + - cmd: rm -f *.syso + platforms: [linux, darwin] + vars: + BUILD_FLAGS: '{{if eq .PRODUCTION "true"}}-tags production -trimpath -buildvcs=false -ldflags="-w -s -H windowsgui"{{else}}-buildvcs=false -gcflags=all="-l"{{end}}' + env: + GOOS: windows + CGO_ENABLED: 0 + GOARCH: '{{.ARCH | default ARCH}}' + PRODUCTION: '{{.PRODUCTION | default "false"}}' + + package: + summary: Packages a production build of the application + cmds: + - |- + if [ "{{.FORMAT | default "nsis"}}" = "msix" ]; then + task: create:msix:package + else + task: create:nsis:installer + fi + vars: + FORMAT: '{{.FORMAT | default "nsis"}}' + + generate:syso: + summary: Generates Windows `.syso` file + dir: build + cmds: + - wails3 generate syso -arch {{.ARCH}} -icon windows/icon.ico -manifest windows/wails.exe.manifest -info windows/info.json -out ../wails_windows_{{.ARCH}}.syso + vars: + ARCH: '{{.ARCH | default ARCH}}' + + create:nsis:installer: + summary: Creates an NSIS installer + dir: build/windows/nsis + deps: + - task: build + vars: + PRODUCTION: "true" + cmds: + # Create the Microsoft WebView2 bootstrapper if it doesn't exist + - wails3 generate webview2bootstrapper -dir "{{.ROOT_DIR}}/build/windows/nsis" + - makensis -DARG_WAILS_{{.ARG_FLAG}}_BINARY="{{.ROOT_DIR}}/{{.BIN_DIR}}/{{.APP_NAME}}.exe" project.nsi + vars: + ARCH: '{{.ARCH | default ARCH}}' + ARG_FLAG: '{{if eq .ARCH "amd64"}}AMD64{{else}}ARM64{{end}}' + + create:msix:package: + summary: Creates an MSIX package + deps: + - task: build + vars: + PRODUCTION: "true" + cmds: + - |- + wails3 tool msix \ + --config "{{.ROOT_DIR}}/wails.json" \ + --name "{{.APP_NAME}}" \ + --executable "{{.ROOT_DIR}}/{{.BIN_DIR}}/{{.APP_NAME}}.exe" \ + --arch "{{.ARCH}}" \ + --out "{{.ROOT_DIR}}/{{.BIN_DIR}}/{{.APP_NAME}}-{{.ARCH}}.msix" \ + {{if .CERT_PATH}}--cert "{{.CERT_PATH}}"{{end}} \ + {{if .PUBLISHER}}--publisher "{{.PUBLISHER}}"{{end}} \ + {{if .USE_MSIX_TOOL}}--use-msix-tool{{else}}--use-makeappx{{end}} + vars: + ARCH: '{{.ARCH | default ARCH}}' + CERT_PATH: '{{.CERT_PATH | default ""}}' + PUBLISHER: '{{.PUBLISHER | default ""}}' + USE_MSIX_TOOL: '{{.USE_MSIX_TOOL | default "false"}}' + + install:msix:tools: + summary: Installs tools required for MSIX packaging + cmds: + - wails3 tool msix-install-tools + + run: + cmds: + - '{{.BIN_DIR}}/{{.APP_NAME}}.exe' diff --git a/v3/examples/android/build/windows/icon.ico b/v3/examples/android/build/windows/icon.ico new file mode 100644 index 000000000..bfa0690b7 Binary files /dev/null and b/v3/examples/android/build/windows/icon.ico differ diff --git a/v3/examples/android/build/windows/info.json b/v3/examples/android/build/windows/info.json new file mode 100644 index 000000000..850b2b5b0 --- /dev/null +++ b/v3/examples/android/build/windows/info.json @@ -0,0 +1,15 @@ +{ + "fixed": { + "file_version": "0.1.0" + }, + "info": { + "0000": { + "ProductVersion": "0.1.0", + "CompanyName": "My Company", + "FileDescription": "My Product Description", + "LegalCopyright": "© now, My Company", + "ProductName": "My Product", + "Comments": "This is a comment" + } + } +} \ No newline at end of file diff --git a/v3/examples/android/build/windows/msix/app_manifest.xml b/v3/examples/android/build/windows/msix/app_manifest.xml new file mode 100644 index 000000000..ecf2506b3 --- /dev/null +++ b/v3/examples/android/build/windows/msix/app_manifest.xml @@ -0,0 +1,52 @@ + + + + + + + My Product + My Company + My Product Description + Assets\StoreLogo.png + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/examples/android/build/windows/msix/template.xml b/v3/examples/android/build/windows/msix/template.xml new file mode 100644 index 000000000..cab2f31e0 --- /dev/null +++ b/v3/examples/android/build/windows/msix/template.xml @@ -0,0 +1,54 @@ + + + + + + + + + + + + + + + + + + + + + + + + false + My Product + My Company + My Product Description + Assets\AppIcon.png + + + + + + + diff --git a/v3/examples/android/build/windows/nsis/project.nsi b/v3/examples/android/build/windows/nsis/project.nsi new file mode 100644 index 000000000..74b8d6ad0 --- /dev/null +++ b/v3/examples/android/build/windows/nsis/project.nsi @@ -0,0 +1,112 @@ +Unicode true + +#### +## Please note: Template replacements don't work in this file. They are provided with default defines like +## mentioned underneath. +## If the keyword is not defined, "wails_tools.nsh" will populate them. +## If they are defined here, "wails_tools.nsh" will not touch them. This allows you to use this project.nsi manually +## from outside of Wails for debugging and development of the installer. +## +## For development first make a wails nsis build to populate the "wails_tools.nsh": +## > wails build --target windows/amd64 --nsis +## Then you can call makensis on this file with specifying the path to your binary: +## For a AMD64 only installer: +## > makensis -DARG_WAILS_AMD64_BINARY=..\..\bin\app.exe +## For a ARM64 only installer: +## > makensis -DARG_WAILS_ARM64_BINARY=..\..\bin\app.exe +## For a installer with both architectures: +## > makensis -DARG_WAILS_AMD64_BINARY=..\..\bin\app-amd64.exe -DARG_WAILS_ARM64_BINARY=..\..\bin\app-arm64.exe +#### +## The following information is taken from the wails_tools.nsh file, but they can be overwritten here. +#### +## !define INFO_PROJECTNAME "my-project" # Default "ios" +## !define INFO_COMPANYNAME "My Company" # Default "My Company" +## !define INFO_PRODUCTNAME "My Product Name" # Default "My Product" +## !define INFO_PRODUCTVERSION "1.0.0" # Default "0.1.0" +## !define INFO_COPYRIGHT "(c) Now, My Company" # Default "© now, My Company" +### +## !define PRODUCT_EXECUTABLE "Application.exe" # Default "${INFO_PROJECTNAME}.exe" +## !define UNINST_KEY_NAME "UninstKeyInRegistry" # Default "${INFO_COMPANYNAME}${INFO_PRODUCTNAME}" +#### +## !define REQUEST_EXECUTION_LEVEL "admin" # Default "admin" see also https://nsis.sourceforge.io/Docs/Chapter4.html +#### +## Include the wails tools +#### +!include "wails_tools.nsh" + +# The version information for this two must consist of 4 parts +VIProductVersion "${INFO_PRODUCTVERSION}.0" +VIFileVersion "${INFO_PRODUCTVERSION}.0" + +VIAddVersionKey "CompanyName" "${INFO_COMPANYNAME}" +VIAddVersionKey "FileDescription" "${INFO_PRODUCTNAME} Installer" +VIAddVersionKey "ProductVersion" "${INFO_PRODUCTVERSION}" +VIAddVersionKey "FileVersion" "${INFO_PRODUCTVERSION}" +VIAddVersionKey "LegalCopyright" "${INFO_COPYRIGHT}" +VIAddVersionKey "ProductName" "${INFO_PRODUCTNAME}" + +# Enable HiDPI support. https://nsis.sourceforge.io/Reference/ManifestDPIAware +ManifestDPIAware true + +!include "MUI.nsh" + +!define MUI_ICON "..\icon.ico" +!define MUI_UNICON "..\icon.ico" +# !define MUI_WELCOMEFINISHPAGE_BITMAP "resources\leftimage.bmp" #Include this to add a bitmap on the left side of the Welcome Page. Must be a size of 164x314 +!define MUI_FINISHPAGE_NOAUTOCLOSE # Wait on the INSTFILES page so the user can take a look into the details of the installation steps +!define MUI_ABORTWARNING # This will warn the user if they exit from the installer. + +!insertmacro MUI_PAGE_WELCOME # Welcome to the installer page. +# !insertmacro MUI_PAGE_LICENSE "resources\eula.txt" # Adds a EULA page to the installer +!insertmacro MUI_PAGE_DIRECTORY # In which folder install page. +!insertmacro MUI_PAGE_INSTFILES # Installing page. +!insertmacro MUI_PAGE_FINISH # Finished installation page. + +!insertmacro MUI_UNPAGE_INSTFILES # Uninstalling page + +!insertmacro MUI_LANGUAGE "English" # Set the Language of the installer + +## The following two statements can be used to sign the installer and the uninstaller. The path to the binaries are provided in %1 +#!uninstfinalize 'signtool --file "%1"' +#!finalize 'signtool --file "%1"' + +Name "${INFO_PRODUCTNAME}" +OutFile "..\..\..\bin\${INFO_PROJECTNAME}-${ARCH}-installer.exe" # Name of the installer's file. +InstallDir "$PROGRAMFILES64\${INFO_COMPANYNAME}\${INFO_PRODUCTNAME}" # Default installing folder ($PROGRAMFILES is Program Files folder). +ShowInstDetails show # This will always show the installation details. + +Function .onInit + !insertmacro wails.checkArchitecture +FunctionEnd + +Section + !insertmacro wails.setShellContext + + !insertmacro wails.webview2runtime + + SetOutPath $INSTDIR + + !insertmacro wails.files + + CreateShortcut "$SMPROGRAMS\${INFO_PRODUCTNAME}.lnk" "$INSTDIR\${PRODUCT_EXECUTABLE}" + CreateShortCut "$DESKTOP\${INFO_PRODUCTNAME}.lnk" "$INSTDIR\${PRODUCT_EXECUTABLE}" + + !insertmacro wails.associateFiles + + !insertmacro wails.writeUninstaller +SectionEnd + +Section "uninstall" + !insertmacro wails.setShellContext + + RMDir /r "$AppData\${PRODUCT_EXECUTABLE}" # Remove the WebView2 DataPath + + RMDir /r $INSTDIR + + Delete "$SMPROGRAMS\${INFO_PRODUCTNAME}.lnk" + Delete "$DESKTOP\${INFO_PRODUCTNAME}.lnk" + + !insertmacro wails.unassociateFiles + + !insertmacro wails.deleteUninstaller +SectionEnd diff --git a/v3/examples/android/build/windows/nsis/wails_tools.nsh b/v3/examples/android/build/windows/nsis/wails_tools.nsh new file mode 100644 index 000000000..dc9aebc17 --- /dev/null +++ b/v3/examples/android/build/windows/nsis/wails_tools.nsh @@ -0,0 +1,212 @@ +# DO NOT EDIT - Generated automatically by `wails build` + +!include "x64.nsh" +!include "WinVer.nsh" +!include "FileFunc.nsh" + +!ifndef INFO_PROJECTNAME + !define INFO_PROJECTNAME "ios" +!endif +!ifndef INFO_COMPANYNAME + !define INFO_COMPANYNAME "My Company" +!endif +!ifndef INFO_PRODUCTNAME + !define INFO_PRODUCTNAME "My Product" +!endif +!ifndef INFO_PRODUCTVERSION + !define INFO_PRODUCTVERSION "0.1.0" +!endif +!ifndef INFO_COPYRIGHT + !define INFO_COPYRIGHT "© now, My Company" +!endif +!ifndef PRODUCT_EXECUTABLE + !define PRODUCT_EXECUTABLE "${INFO_PROJECTNAME}.exe" +!endif +!ifndef UNINST_KEY_NAME + !define UNINST_KEY_NAME "${INFO_COMPANYNAME}${INFO_PRODUCTNAME}" +!endif +!define UNINST_KEY "Software\Microsoft\Windows\CurrentVersion\Uninstall\${UNINST_KEY_NAME}" + +!ifndef REQUEST_EXECUTION_LEVEL + !define REQUEST_EXECUTION_LEVEL "admin" +!endif + +RequestExecutionLevel "${REQUEST_EXECUTION_LEVEL}" + +!ifdef ARG_WAILS_AMD64_BINARY + !define SUPPORTS_AMD64 +!endif + +!ifdef ARG_WAILS_ARM64_BINARY + !define SUPPORTS_ARM64 +!endif + +!ifdef SUPPORTS_AMD64 + !ifdef SUPPORTS_ARM64 + !define ARCH "amd64_arm64" + !else + !define ARCH "amd64" + !endif +!else + !ifdef SUPPORTS_ARM64 + !define ARCH "arm64" + !else + !error "Wails: Undefined ARCH, please provide at least one of ARG_WAILS_AMD64_BINARY or ARG_WAILS_ARM64_BINARY" + !endif +!endif + +!macro wails.checkArchitecture + !ifndef WAILS_WIN10_REQUIRED + !define WAILS_WIN10_REQUIRED "This product is only supported on Windows 10 (Server 2016) and later." + !endif + + !ifndef WAILS_ARCHITECTURE_NOT_SUPPORTED + !define WAILS_ARCHITECTURE_NOT_SUPPORTED "This product can't be installed on the current Windows architecture. Supports: ${ARCH}" + !endif + + ${If} ${AtLeastWin10} + !ifdef SUPPORTS_AMD64 + ${if} ${IsNativeAMD64} + Goto ok + ${EndIf} + !endif + + !ifdef SUPPORTS_ARM64 + ${if} ${IsNativeARM64} + Goto ok + ${EndIf} + !endif + + IfSilent silentArch notSilentArch + silentArch: + SetErrorLevel 65 + Abort + notSilentArch: + MessageBox MB_OK "${WAILS_ARCHITECTURE_NOT_SUPPORTED}" + Quit + ${else} + IfSilent silentWin notSilentWin + silentWin: + SetErrorLevel 64 + Abort + notSilentWin: + MessageBox MB_OK "${WAILS_WIN10_REQUIRED}" + Quit + ${EndIf} + + ok: +!macroend + +!macro wails.files + !ifdef SUPPORTS_AMD64 + ${if} ${IsNativeAMD64} + File "/oname=${PRODUCT_EXECUTABLE}" "${ARG_WAILS_AMD64_BINARY}" + ${EndIf} + !endif + + !ifdef SUPPORTS_ARM64 + ${if} ${IsNativeARM64} + File "/oname=${PRODUCT_EXECUTABLE}" "${ARG_WAILS_ARM64_BINARY}" + ${EndIf} + !endif +!macroend + +!macro wails.writeUninstaller + WriteUninstaller "$INSTDIR\uninstall.exe" + + SetRegView 64 + WriteRegStr HKLM "${UNINST_KEY}" "Publisher" "${INFO_COMPANYNAME}" + WriteRegStr HKLM "${UNINST_KEY}" "DisplayName" "${INFO_PRODUCTNAME}" + WriteRegStr HKLM "${UNINST_KEY}" "DisplayVersion" "${INFO_PRODUCTVERSION}" + WriteRegStr HKLM "${UNINST_KEY}" "DisplayIcon" "$INSTDIR\${PRODUCT_EXECUTABLE}" + WriteRegStr HKLM "${UNINST_KEY}" "UninstallString" "$\"$INSTDIR\uninstall.exe$\"" + WriteRegStr HKLM "${UNINST_KEY}" "QuietUninstallString" "$\"$INSTDIR\uninstall.exe$\" /S" + + ${GetSize} "$INSTDIR" "/S=0K" $0 $1 $2 + IntFmt $0 "0x%08X" $0 + WriteRegDWORD HKLM "${UNINST_KEY}" "EstimatedSize" "$0" +!macroend + +!macro wails.deleteUninstaller + Delete "$INSTDIR\uninstall.exe" + + SetRegView 64 + DeleteRegKey HKLM "${UNINST_KEY}" +!macroend + +!macro wails.setShellContext + ${If} ${REQUEST_EXECUTION_LEVEL} == "admin" + SetShellVarContext all + ${else} + SetShellVarContext current + ${EndIf} +!macroend + +# Install webview2 by launching the bootstrapper +# See https://docs.microsoft.com/en-us/microsoft-edge/webview2/concepts/distribution#online-only-deployment +!macro wails.webview2runtime + !ifndef WAILS_INSTALL_WEBVIEW_DETAILPRINT + !define WAILS_INSTALL_WEBVIEW_DETAILPRINT "Installing: WebView2 Runtime" + !endif + + SetRegView 64 + # If the admin key exists and is not empty then webview2 is already installed + ReadRegStr $0 HKLM "SOFTWARE\WOW6432Node\Microsoft\EdgeUpdate\Clients\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}" "pv" + ${If} $0 != "" + Goto ok + ${EndIf} + + ${If} ${REQUEST_EXECUTION_LEVEL} == "user" + # If the installer is run in user level, check the user specific key exists and is not empty then webview2 is already installed + ReadRegStr $0 HKCU "Software\Microsoft\EdgeUpdate\Clients\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}" "pv" + ${If} $0 != "" + Goto ok + ${EndIf} + ${EndIf} + + SetDetailsPrint both + DetailPrint "${WAILS_INSTALL_WEBVIEW_DETAILPRINT}" + SetDetailsPrint listonly + + InitPluginsDir + CreateDirectory "$pluginsdir\webview2bootstrapper" + SetOutPath "$pluginsdir\webview2bootstrapper" + File "MicrosoftEdgeWebview2Setup.exe" + ExecWait '"$pluginsdir\webview2bootstrapper\MicrosoftEdgeWebview2Setup.exe" /silent /install' + + SetDetailsPrint both + ok: +!macroend + +# Copy of APP_ASSOCIATE and APP_UNASSOCIATE macros from here https://gist.github.com/nikku/281d0ef126dbc215dd58bfd5b3a5cd5b +!macro APP_ASSOCIATE EXT FILECLASS DESCRIPTION ICON COMMANDTEXT COMMAND + ; Backup the previously associated file class + ReadRegStr $R0 SHELL_CONTEXT "Software\Classes\.${EXT}" "" + WriteRegStr SHELL_CONTEXT "Software\Classes\.${EXT}" "${FILECLASS}_backup" "$R0" + + WriteRegStr SHELL_CONTEXT "Software\Classes\.${EXT}" "" "${FILECLASS}" + + WriteRegStr SHELL_CONTEXT "Software\Classes\${FILECLASS}" "" `${DESCRIPTION}` + WriteRegStr SHELL_CONTEXT "Software\Classes\${FILECLASS}\DefaultIcon" "" `${ICON}` + WriteRegStr SHELL_CONTEXT "Software\Classes\${FILECLASS}\shell" "" "open" + WriteRegStr SHELL_CONTEXT "Software\Classes\${FILECLASS}\shell\open" "" `${COMMANDTEXT}` + WriteRegStr SHELL_CONTEXT "Software\Classes\${FILECLASS}\shell\open\command" "" `${COMMAND}` +!macroend + +!macro APP_UNASSOCIATE EXT FILECLASS + ; Backup the previously associated file class + ReadRegStr $R0 SHELL_CONTEXT "Software\Classes\.${EXT}" `${FILECLASS}_backup` + WriteRegStr SHELL_CONTEXT "Software\Classes\.${EXT}" "" "$R0" + + DeleteRegKey SHELL_CONTEXT `Software\Classes\${FILECLASS}` +!macroend + +!macro wails.associateFiles + ; Create file associations + +!macroend + +!macro wails.unassociateFiles + ; Delete app associations + +!macroend \ No newline at end of file diff --git a/v3/examples/android/build/windows/wails.exe.manifest b/v3/examples/android/build/windows/wails.exe.manifest new file mode 100644 index 000000000..025555a69 --- /dev/null +++ b/v3/examples/android/build/windows/wails.exe.manifest @@ -0,0 +1,22 @@ + + + + + + + + + + + true/pm + permonitorv2,permonitor + + + + + + + + + + \ No newline at end of file diff --git a/v3/examples/android/frontend/Inter Font License.txt b/v3/examples/android/frontend/Inter Font License.txt new file mode 100644 index 000000000..00287df15 --- /dev/null +++ b/v3/examples/android/frontend/Inter Font License.txt @@ -0,0 +1,93 @@ +Copyright 2020 The Inter Project Authors (https://github.com/rsms/inter) + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +http://scripts.sil.org/OFL + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/v3/examples/android/frontend/bindings/changeme/greetservice.js b/v3/examples/android/frontend/bindings/changeme/greetservice.js new file mode 100644 index 000000000..0b93e6d75 --- /dev/null +++ b/v3/examples/android/frontend/bindings/changeme/greetservice.js @@ -0,0 +1,15 @@ +// @ts-check +// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL +// This file is automatically generated. DO NOT EDIT + +// eslint-disable-next-line @typescript-eslint/ban-ts-comment +// @ts-ignore: Unused imports +import { Call as $Call, CancellablePromise as $CancellablePromise, Create as $Create } from "@wailsio/runtime"; + +/** + * @param {string} name + * @returns {$CancellablePromise} + */ +export function Greet(name) { + return $Call.ByID(1411160069, name); +} diff --git a/v3/examples/android/frontend/bindings/changeme/index.js b/v3/examples/android/frontend/bindings/changeme/index.js new file mode 100644 index 000000000..fdf1ff435 --- /dev/null +++ b/v3/examples/android/frontend/bindings/changeme/index.js @@ -0,0 +1,8 @@ +// @ts-check +// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL +// This file is automatically generated. DO NOT EDIT + +import * as GreetService from "./greetservice.js"; +export { + GreetService +}; diff --git a/v3/examples/android/frontend/bindings/github.com/wailsapp/wails/v3/internal/eventcreate.js b/v3/examples/android/frontend/bindings/github.com/wailsapp/wails/v3/internal/eventcreate.js new file mode 100644 index 000000000..1ea105857 --- /dev/null +++ b/v3/examples/android/frontend/bindings/github.com/wailsapp/wails/v3/internal/eventcreate.js @@ -0,0 +1,9 @@ +//@ts-check +// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL +// This file is automatically generated. DO NOT EDIT + +// eslint-disable-next-line @typescript-eslint/ban-ts-comment +// @ts-ignore: Unused imports +import { Create as $Create } from "@wailsio/runtime"; + +Object.freeze($Create.Events); diff --git a/v3/examples/android/frontend/bindings/github.com/wailsapp/wails/v3/internal/eventdata.d.ts b/v3/examples/android/frontend/bindings/github.com/wailsapp/wails/v3/internal/eventdata.d.ts new file mode 100644 index 000000000..3dd1807bd --- /dev/null +++ b/v3/examples/android/frontend/bindings/github.com/wailsapp/wails/v3/internal/eventdata.d.ts @@ -0,0 +1,2 @@ +// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL +// This file is automatically generated. DO NOT EDIT diff --git a/v3/examples/android/frontend/index.html b/v3/examples/android/frontend/index.html new file mode 100644 index 000000000..f7c8de065 --- /dev/null +++ b/v3/examples/android/frontend/index.html @@ -0,0 +1,110 @@ + + + + + + + + + Wails App + + + + +
+ +

Wails + Javascript

+
+
Demo Screens
+
+ +
+
Please enter your name below 👇
+
+ + +
+
+ + +
+
+ +
+
+ +
+
+ +
+
+ +
+
+ +
+
+ + +
+
+ + +
+
+ + + + +
+
+ +
+
+ +
+
+ +
+
+ +
+
+ +
+
+ + +
+ 

+          

+
+        

+    

+    

+        
Click on the Wails logo to learn more

+        
Listening for Time event...

+    

+

+
+
+
diff --git a/v3/examples/android/frontend/main.js b/v3/examples/android/frontend/main.js
new file mode 100644
index 000000000..ad8064576
--- /dev/null
+++ b/v3/examples/android/frontend/main.js
@@ -0,0 +1,113 @@
+import {GreetService} from "./bindings/changeme";
+import * as Runtime from "@wailsio/runtime";
+
+const resultElement = document.getElementById('result');
+const timeElement = document.getElementById('time');
+const deviceInfoElement = document.getElementById('deviceInfo');
+const Events = Runtime.Events;
+const IOS = Runtime.IOS; // May be undefined in published package; we guard usages below.
+
+window.doGreet = () => {
+    let name = document.getElementById('name').value;
+    if (!name) {
+        name = 'anonymous';
+    }
+    GreetService.Greet(name).then((result) => {
+        resultElement.innerText = result;
+    }).catch((err) => {
+        console.log(err);
+    });
+}
+
+window.doHaptic = (style) => {
+    if (!IOS || !IOS.Haptics?.Impact) {
+        console.warn('IOS runtime not available in @wailsio/runtime. Skipping haptic call.');
+        return;
+    }
+    IOS.Haptics.Impact(style).catch((err) => {
+        console.error('Haptics error:', err);
+    });
+}
+
+window.getDeviceInfo = async () => {
+    if (!IOS || !IOS.Device?.Info) {
+        deviceInfoElement.innerText = 'iOS runtime not available; cannot fetch device info.';
+        return;
+    }
+    try {
+        const info = await IOS.Device.Info();
+        deviceInfoElement.innerText = JSON.stringify(info, null, 2);
+    } catch (e) {
+        deviceInfoElement.innerText = `Error: ${e?.message || e}`;
+    }
+}
+
+// Generic caller for IOS..(args)
+window.iosJsSet = async (methodPath, args) => {
+    if (!IOS) {
+        console.warn('IOS runtime not available in @wailsio/runtime.');
+        return;
+    }
+    try {
+        const [group, method] = methodPath.split('.');
+        const target = IOS?.[group];
+        const fn = target?.[method];
+        if (typeof fn !== 'function') {
+            console.warn('IOS method not found:', methodPath);
+            return;
+        }
+        await fn(args);
+    } catch (e) {
+        console.error('iosJsSet error for', methodPath, e);
+    }
+}
+
+// Emit events for Go handlers
+window.emitGo = (eventName, data) => {
+    try {
+        Events.Emit(eventName, data);
+    } catch (e) {
+        console.error('emitGo error:', e);
+    }
+}
+
+// Toggle helpers for UI switches
+window.setGoToggle = (eventName, enabled) => {
+  emitGo(eventName, { enabled: !!enabled });
+}
+
+window.setJsToggle = (methodPath, enabled) => {
+  iosJsSet(methodPath, { enabled: !!enabled });
+}
+
+Events.On('time', (payload) => {
+    // payload may be a plain value or an object with a `data` field depending on emitter/runtime
+    const value = (payload && typeof payload === 'object' && 'data' in payload) ? payload.data : payload;
+    console.log('[frontend] time event:', payload, '->', value);
+    timeElement.innerText = value;
+});
+
+// Simple pane switcher responding to native UITabBar
+function showPaneByIndex(index) {
+  const panes = [
+    document.getElementById('screen-bindings'),
+    document.getElementById('screen-go'),
+    document.getElementById('screen-js'),
+  ];
+  panes.forEach((el, i) => {
+    if (!el) return;
+    if (i === index) el.classList.add('active');
+    else el.classList.remove('active');
+  });
+}
+
+// Listen for native tab selection events posted by the iOS layer
+window.addEventListener('nativeTabSelected', (e) => {
+  const idx = (e && e.detail && typeof e.detail.index === 'number') ? e.detail.index : 0;
+  showPaneByIndex(idx);
+});
+
+// Ensure default pane is visible on load (index 0)
+window.addEventListener('DOMContentLoaded', () => {
+  showPaneByIndex(0);
+});
diff --git a/v3/examples/android/frontend/package-lock.json b/v3/examples/android/frontend/package-lock.json
new file mode 100644
index 000000000..b0b7dc68f
--- /dev/null
+++ b/v3/examples/android/frontend/package-lock.json
@@ -0,0 +1,936 @@
+{
+  "name": "frontend",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "frontend",
+      "version": "0.0.0",
+      "dependencies": {
+        "@wailsio/runtime": "latest"
+      },
+      "devDependencies": {
+        "vite": "^5.0.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.50.0.tgz",
+      "integrity": "sha512-lVgpeQyy4fWN5QYebtW4buT/4kn4p4IJ+kDNB4uYNT5b8c8DLJDg6titg20NIg7E8RWwdWZORW6vUFfrLyG3KQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.50.0.tgz",
+      "integrity": "sha512-2O73dR4Dc9bp+wSYhviP6sDziurB5/HCym7xILKifWdE9UsOe2FtNcM+I4xZjKrfLJnq5UR8k9riB87gauiQtw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.50.0.tgz",
+      "integrity": "sha512-vwSXQN8T4sKf1RHr1F0s98Pf8UPz7pS6P3LG9NSmuw0TVh7EmaE+5Ny7hJOZ0M2yuTctEsHHRTMi2wuHkdS6Hg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.50.0.tgz",
+      "integrity": "sha512-cQp/WG8HE7BCGyFVuzUg0FNmupxC+EPZEwWu2FCGGw5WDT1o2/YlENbm5e9SMvfDFR6FRhVCBePLqj0o8MN7Vw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.50.0.tgz",
+      "integrity": "sha512-UR1uTJFU/p801DvvBbtDD7z9mQL8J80xB0bR7DqW7UGQHRm/OaKzp4is7sQSdbt2pjjSS72eAtRh43hNduTnnQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.50.0.tgz",
+      "integrity": "sha512-G/DKyS6PK0dD0+VEzH/6n/hWDNPDZSMBmqsElWnCRGrYOb2jC0VSupp7UAHHQ4+QILwkxSMaYIbQ72dktp8pKA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.50.0.tgz",
+      "integrity": "sha512-u72Mzc6jyJwKjJbZZcIYmd9bumJu7KNmHYdue43vT1rXPm2rITwmPWF0mmPzLm9/vJWxIRbao/jrQmxTO0Sm9w==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.50.0.tgz",
+      "integrity": "sha512-S4UefYdV0tnynDJV1mdkNawp0E5Qm2MtSs330IyHgaccOFrwqsvgigUD29uT+B/70PDY1eQ3t40+xf6wIvXJyg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.50.0.tgz",
+      "integrity": "sha512-1EhkSvUQXJsIhk4msxP5nNAUWoB4MFDHhtc4gAYvnqoHlaL9V3F37pNHabndawsfy/Tp7BPiy/aSa6XBYbaD1g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.50.0.tgz",
+      "integrity": "sha512-EtBDIZuDtVg75xIPIK1l5vCXNNCIRM0OBPUG+tbApDuJAy9mKago6QxX+tfMzbCI6tXEhMuZuN1+CU8iDW+0UQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loongarch64-gnu": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.50.0.tgz",
+      "integrity": "sha512-BGYSwJdMP0hT5CCmljuSNx7+k+0upweM2M4YGfFBjnFSZMHOLYR0gEEj/dxyYJ6Zc6AiSeaBY8dWOa11GF/ppQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.50.0.tgz",
+      "integrity": "sha512-I1gSMzkVe1KzAxKAroCJL30hA4DqSi+wGc5gviD0y3IL/VkvcnAqwBf4RHXHyvH66YVHxpKO8ojrgc4SrWAnLg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.50.0.tgz",
+      "integrity": "sha512-bSbWlY3jZo7molh4tc5dKfeSxkqnf48UsLqYbUhnkdnfgZjgufLS/NTA8PcP/dnvct5CCdNkABJ56CbclMRYCA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.50.0.tgz",
+      "integrity": "sha512-LSXSGumSURzEQLT2e4sFqFOv3LWZsEF8FK7AAv9zHZNDdMnUPYH3t8ZlaeYYZyTXnsob3htwTKeWtBIkPV27iQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.50.0.tgz",
+      "integrity": "sha512-CxRKyakfDrsLXiCyucVfVWVoaPA4oFSpPpDwlMcDFQvrv3XY6KEzMtMZrA+e/goC8xxp2WSOxHQubP8fPmmjOQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.50.0.tgz",
+      "integrity": "sha512-8PrJJA7/VU8ToHVEPu14FzuSAqVKyo5gg/J8xUerMbyNkWkO9j2ExBho/68RnJsMGNJq4zH114iAttgm7BZVkA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.50.0.tgz",
+      "integrity": "sha512-SkE6YQp+CzpyOrbw7Oc4MgXFvTw2UIBElvAvLCo230pyxOLmYwRPwZ/L5lBe/VW/qT1ZgND9wJfOsdy0XptRvw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.50.0.tgz",
+      "integrity": "sha512-PZkNLPfvXeIOgJWA804zjSFH7fARBBCpCXxgkGDRjjAhRLOR8o0IGS01ykh5GYfod4c2yiiREuDM8iZ+pVsT+Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.50.0.tgz",
+      "integrity": "sha512-q7cIIdFvWQoaCbLDUyUc8YfR3Jh2xx3unO8Dn6/TTogKjfwrax9SyfmGGK6cQhKtjePI7jRfd7iRYcxYs93esg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.50.0.tgz",
+      "integrity": "sha512-XzNOVg/YnDOmFdDKcxxK410PrcbcqZkBmz+0FicpW5jtjKQxcW1BZJEQOF0NJa6JO7CZhett8GEtRN/wYLYJuw==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.50.0.tgz",
+      "integrity": "sha512-xMmiWRR8sp72Zqwjgtf3QbZfF1wdh8X2ABu3EaozvZcyHJeU0r+XAnXdKgs4cCAp6ORoYoCygipYP1mjmbjrsg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@wailsio/runtime": {
+      "version": "3.0.0-alpha.66",
+      "resolved": "https://registry.npmjs.org/@wailsio/runtime/-/runtime-3.0.0-alpha.66.tgz",
+      "integrity": "sha512-ENLu8rn1griL1gFHJqkq1i+BVxrrA0JPJHYneUJYuf/s54kjuQViW0RKDEe/WTDo56ABpfykrd/T8OYpPUyXUw==",
+      "license": "MIT"
+    },
+    "node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.21.5",
+        "@esbuild/android-arm": "0.21.5",
+        "@esbuild/android-arm64": "0.21.5",
+        "@esbuild/android-x64": "0.21.5",
+        "@esbuild/darwin-arm64": "0.21.5",
+        "@esbuild/darwin-x64": "0.21.5",
+        "@esbuild/freebsd-arm64": "0.21.5",
+        "@esbuild/freebsd-x64": "0.21.5",
+        "@esbuild/linux-arm": "0.21.5",
+        "@esbuild/linux-arm64": "0.21.5",
+        "@esbuild/linux-ia32": "0.21.5",
+        "@esbuild/linux-loong64": "0.21.5",
+        "@esbuild/linux-mips64el": "0.21.5",
+        "@esbuild/linux-ppc64": "0.21.5",
+        "@esbuild/linux-riscv64": "0.21.5",
+        "@esbuild/linux-s390x": "0.21.5",
+        "@esbuild/linux-x64": "0.21.5",
+        "@esbuild/netbsd-x64": "0.21.5",
+        "@esbuild/openbsd-x64": "0.21.5",
+        "@esbuild/sunos-x64": "0.21.5",
+        "@esbuild/win32-arm64": "0.21.5",
+        "@esbuild/win32-ia32": "0.21.5",
+        "@esbuild/win32-x64": "0.21.5"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/postcss": {
+      "version": "8.5.6",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.50.0.tgz",
+      "integrity": "sha512-/Zl4D8zPifNmyGzJS+3kVoyXeDeT/GrsJM94sACNg9RtUE0hrHa1bNPtRSrfHTMH5HjRzce6K7rlTh3Khiw+pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.50.0",
+        "@rollup/rollup-android-arm64": "4.50.0",
+        "@rollup/rollup-darwin-arm64": "4.50.0",
+        "@rollup/rollup-darwin-x64": "4.50.0",
+        "@rollup/rollup-freebsd-arm64": "4.50.0",
+        "@rollup/rollup-freebsd-x64": "4.50.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.50.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.50.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.50.0",
+        "@rollup/rollup-linux-arm64-musl": "4.50.0",
+        "@rollup/rollup-linux-loongarch64-gnu": "4.50.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.50.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.50.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.50.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.50.0",
+        "@rollup/rollup-linux-x64-gnu": "4.50.0",
+        "@rollup/rollup-linux-x64-musl": "4.50.0",
+        "@rollup/rollup-openharmony-arm64": "4.50.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.50.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.50.0",
+        "@rollup/rollup-win32-x64-msvc": "4.50.0",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/vite": {
+      "version": "5.4.19",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.19.tgz",
+      "integrity": "sha512-qO3aKv3HoQC8QKiNSTuUM1l9o/XX3+c+VTgLHbJWHZGeTPVAg2XwazI9UWzoxjIJCGCV2zU60uqMzjeLZuULqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.21.3",
+        "postcss": "^8.4.43",
+        "rollup": "^4.20.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    }
+  }
+}
diff --git a/v3/examples/android/frontend/package.json b/v3/examples/android/frontend/package.json
new file mode 100644
index 000000000..0a118e984
--- /dev/null
+++ b/v3/examples/android/frontend/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "frontend",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build:dev": "vite build --minify false --mode development",
+    "build": "vite build --mode production",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@wailsio/runtime": "latest"
+  },
+  "devDependencies": {
+    "vite": "^5.0.0"
+  }
+}
diff --git a/v3/examples/android/frontend/public/Inter-Medium.ttf b/v3/examples/android/frontend/public/Inter-Medium.ttf
new file mode 100644
index 000000000..a01f3777a
Binary files /dev/null and b/v3/examples/android/frontend/public/Inter-Medium.ttf differ
diff --git a/v3/examples/android/frontend/public/javascript.svg b/v3/examples/android/frontend/public/javascript.svg
new file mode 100644
index 000000000..f9abb2b72
--- /dev/null
+++ b/v3/examples/android/frontend/public/javascript.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/v3/examples/android/frontend/public/puppertino/LICENSE b/v3/examples/android/frontend/public/puppertino/LICENSE
new file mode 100644
index 000000000..ed9065e06
--- /dev/null
+++ b/v3/examples/android/frontend/public/puppertino/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Edgar Pérez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/v3/examples/android/frontend/public/puppertino/css/actions.css b/v3/examples/android/frontend/public/puppertino/css/actions.css
new file mode 100644
index 000000000..22a9d5a13
--- /dev/null
+++ b/v3/examples/android/frontend/public/puppertino/css/actions.css
@@ -0,0 +1,149 @@
+:root {
+  --font: -apple-system, "Inter", sans-serif;
+  --primary-col-ac: #0f75f5;
+  --p-modal-bg: rgba(255, 255, 255, 0.8);
+  --p-modal-bd-color: rgba(0,0,0,.1);
+  --p-modal-fallback-color: rgba(255,255,255,.95);
+  --p-actions-static-color: #555761;
+}
+
+.p-modal-opened {
+  overflow: hidden;
+}
+
+.p-action-background{
+  background: rgba(0, 0, 0, 0.7);
+  height: 100vh;
+  left: 0;
+  opacity: 0;
+  pointer-events: none;
+  position: fixed;
+  top: 0;
+  transition: 0.3s;
+  width: 100vw;
+  z-index: 5;
+}
+
+.p-action-background.nowactive {
+  opacity: 1;
+  pointer-events: auto;
+}
+
+
+.p-action-big-container{
+  position:fixed;
+  width: 100%;
+  box-sizing: border-box;
+  padding: 1rem 5vw;
+  bottom:0;
+}
+
+.p-action-container{
+  background: var(--p-modal-bg);
+  display:block;
+  margin:auto;
+  margin-bottom: 10px;
+  border-radius: 10px;
+  max-width: 700px;
+}
+
+.p-action-big-container .p-action-container:first-child{
+  margin-bottom:10px;
+}
+
+.p-action--intern{
+  width: 100%;
+  display:block;
+  margin:auto;
+  font-size: 1rem;
+  font-weight: 600;
+  text-align:center;
+  padding: 15px 0;
+  border: 0;
+  border-bottom: 1px solid #bfbfbf;
+  color: #0f75f5;
+  text-decoration:none;
+  background-color: transparent;
+}
+
+.p-action-destructive{
+  color: #c6262e;
+}
+
+.p-action-neutral{
+  color: var(--p-actions-static-color);
+}
+
+.p-action-cancel, .p-action-container a:last-child{
+  border-bottom:none;
+}
+
+.p-action-cancel{
+  font-weight:bold;
+}
+
+.p-action-icon{
+  position:relative;
+}
+.p-action-icon svg, .p-action-icon img{
+  position:absolute;
+  left:5%;
+  top:50%;
+  transform:translateY(-50%);
+}
+
+.p-action-icon-inline{
+  text-align: left;
+  display: flex;
+  align-items: center;
+}
+
+.p-action-icon-inline svg, .p-action-icon-inline img{
+  margin-left: 5%;
+  margin-right: 3%;
+}
+
+.p-action-title{
+  padding: 30px 15px;
+  border-bottom: 1px solid #bfbfbf;
+}
+
+.p-action-title--intern,.p-action-text{
+  margin:0;
+  color:var(--p-actions-static-color);
+}
+
+.p-action-title--intern{
+  margin-bottom: .3rem;
+}
+
+@supports not (backdrop-filter: blur(10px)) {
+  .p-action-container {
+    background: var(--p-modal-fallback-color);
+  }
+}
+
+.p-action-big-container{
+  -webkit-transform: translateY(30%);
+  transform: translateY(30%);
+  opacity: 0;
+  transition: opacity 0.4s, transform 0.4s;
+  transition-timing-function: ease;
+  pointer-events: none;
+}
+
+.p-action-big-container.active {
+  -webkit-transform: translateY(0);
+  transform: translateY(0);
+  opacity: 1;
+  pointer-events: all;
+}
+
+
+.p-action-big-container.active .p-action-container {
+  backdrop-filter: saturate(180%) blur(10px);
+}
+
+.p-action-big-container[aria-hidden="true"] .p-action--intern {
+  display: none;
+}
diff --git a/v3/examples/android/frontend/public/puppertino/css/buttons.css b/v3/examples/android/frontend/public/puppertino/css/buttons.css
new file mode 100644
index 000000000..4950b0053
--- /dev/null
+++ b/v3/examples/android/frontend/public/puppertino/css/buttons.css
@@ -0,0 +1,158 @@
+@charset "UTF-8";
+:root{
+  --p-btn-border: #cacaca;
+  --p-btn-def-bg: #FFFFFF;
+  --p-btn-def-col: #000000;
+  --p-btn-dir-col: #242424;
+  --p-prim-text-col: #f5f5f5;
+  --p-btn-scope-unactive: #212136;
+  --p-btn-scope-action: #212136;
+}
+
+.p-btn {
+  background: var(--p-btn-def-bg);
+  border: 1px solid var(--p-btn-border);
+  border-radius: 10px;
+  color: var(--p-btn-def-col);
+  display: inline-block;
+  font-family: -apple-system, "Inter", sans-serif;
+  font-size: 1.1rem;
+  margin: .7rem;
+  padding: .4rem 1.2rem;
+  text-decoration: none;
+  text-align: center;
+  box-shadow: 0 1px 0.375px rgba(0, 0, 0, 0.05), 0 0.25px 0.375px rgba(0, 0, 0, 0.15);
+  user-select: none;
+  cursor: pointer;
+}
+.p-btn:focus{
+  outline: 2px solid #64baff;
+}
+.p-btn.p-btn-block{
+  display: block;
+}
+.p-btn.p-btn-sm {
+  padding: .3rem 1.1rem;
+  font-size: 1rem;
+}
+.p-btn.p-btn-md {
+  padding: .8rem 2.4rem;
+  font-size: 1.6rem;
+}
+.p-btn.p-btn-lg {
+  padding: 1.2rem 2.8rem;
+  font-size: 1.8rem;
+}
+.p-btn-destructive{
+  color: #FF3B30;
+}
+.p-btn-mob{
+  padding: 10px 40px;
+  background: #227bec;
+  color: #fff;
+  border: 0;
+  box-shadow: inset 0 1px 1px rgb(255 255 255 / 41%), 0px 2px 3px -2px rgba(0,0,0,.3);
+}
+.p-btn[disabled],
+.p-btn:disabled,
+.p-btn-disabled{
+  filter:contrast(0.5) grayscale(.5) opacity(.8);
+  cursor: not-allowed;
+  box-shadow: none;
+  pointer-events: none;
+}
+
+.p-prim-col {
+  position: relative;
+  background: #007AFF;
+  border: none;
+  box-shadow: inset 0 1px 1px rgba(255, 255, 255, 0.41), 0px 2px 3px -2px rgba(0, 0, 0, 0.3);
+  color: var(--p-prim-text-col);
+  overflow: hidden; /* Ensure the ::before element doesn't overflow */
+}
+
+.p-prim-col:before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: linear-gradient(180deg, rgba(255, 255, 255, 1) 0%, rgba(255, 255, 255, 0) 100%);
+  opacity: 0.17;
+  pointer-events: none;
+}
+
+.p-btn.p-prim-col:active {
+  background: #0f75f5;
+}
+
+.p-btn-more::after {
+  content: "...";
+}
+
+.p-btn-round {
+  border: 0;
+  border-radius: 50px;
+  box-shadow: inset 0 1px 1px rgb(255 255 255 / 41%);
+  padding: 10px 30px;
+}
+
+.p-btn-icon {
+  align-items: center;
+  background: var(--p-btn-def-bg);
+  border: 2px solid currentColor;
+  border-radius: 50%;
+  color: #0f75f5;
+  display: inline-flex;
+  font-weight: 900;
+  height: 40px;
+  width: 40px;
+  justify-content: center;
+  margin: 5px;
+  text-align: center;
+  text-decoration: none;
+  box-sizing: border-box;
+  user-select: none;
+  vertical-align: bottom;
+}
+
+.p-btn-icon.p-btn-icon-no-border{
+  border: 0px;
+}
+
+.p-btn-scope {
+  background: #8e8e8e;
+  color: #fff;
+  margin: 5px;
+  padding: 2px 20px;
+  box-shadow: none;
+}
+.p-btn-scope-unactive {
+  background: transparent;
+  border-color: transparent;
+  color: var(--p-btn-scope-unactive);
+  transition: border-color 0.2s;
+}
+.p-btn-scope-unactive:hover {
+  border-color: var(--p-btn-border);
+}
+
+.p-btn-scope-outline {
+  background: transparent;
+  color: var(--p-btn-scope-action);
+  box-shadow: none;
+}
+
+.p-btn-outline {
+  background: none;
+  border-color: currentColor;
+  box-shadow: none;
+}
+
+.p-btn-outline-dash {
+  background: none;
+  border-color: currentColor;
+  border-style: dashed;
+  box-shadow: none;
+}
diff --git a/v3/examples/android/frontend/public/puppertino/css/cards.css b/v3/examples/android/frontend/public/puppertino/css/cards.css
new file mode 100644
index 000000000..b4fa2e397
--- /dev/null
+++ b/v3/examples/android/frontend/public/puppertino/css/cards.css
@@ -0,0 +1,55 @@
+:root{
+  --p-color-card: #1a1a1a;
+  --p-bg-card: #fff;
+  --p-bd-card: #c5c5c55e;
+}
+.p-card {
+  background: var(--p-bg-card);
+  border: 1px solid var(--p-bd-card);
+  color: var(--p-color-card);
+  display: block;
+  margin: 15px;
+  margin-left:7.5px;
+  margin-right:7.5px;
+  text-decoration: none;
+  border-radius: 25px;
+  padding: 20px 0px;
+  transition: .3s ease;
+  box-shadow: 0 0.5px 1px rgba(0, 0, 0, 0.1);
+}
+.p-card-image > img {
+  border-bottom: 3px solid var(--accent-article);
+  display: block;
+  margin: auto;
+  width: 100%;
+}
+.p-card-tags {
+  display: flex;
+  overflow: hidden;
+  position: relative;
+  width: 100%;
+}
+.p-card-tags::before {
+  background: linear-gradient(to right, rgba(255, 255, 255, 0) 0%, rgba(255, 255, 255, 0) 75%, white 100%);
+  content: "";
+  height: 100%;
+  position: absolute;
+  right: 0;
+  top: 0;
+  width: 30%;
+}
+.p-card-title {
+  font-size: 2rem;
+  margin-bottom: 15px;
+  margin-top: 15px;
+}
+.p-card-content {
+  padding: 15px;
+  padding-top: 15px;
+}
+.p-card-text {
+  font-size: 17px;
+  margin-bottom: 10px;
+  margin-left: 10px;
+  margin-top: 0;
+}
diff --git a/v3/examples/android/frontend/public/puppertino/css/color_palette.css b/v3/examples/android/frontend/public/puppertino/css/color_palette.css
new file mode 100644
index 000000000..33a66b91c
--- /dev/null
+++ b/v3/examples/android/frontend/public/puppertino/css/color_palette.css
@@ -0,0 +1,917 @@
+:root{
+--p-strawberry: #c6262e;
+--p-strawberry-100: #ff8c82;
+--p-strawberry-300: #ed5353;
+--p-strawberry-500: #c6262e;
+--p-strawberry-700: #a10705;
+--p-strawberry-900: #7a0000;
+
+--p-orange: #f37329;
+--p-orange-100: #ffc27d;
+--p-orange-300: #ffa154;
+--p-orange-500: #f37329;
+--p-orange-700: #cc3b02;
+--p-orange-900: #a62100;
+
+
+--p-banana: #f9c440;
+--p-banana-100: #fff394;
+--p-banana-300: #ffe16b;
+--p-banana-500: #f9c440;
+--p-banana-700: #d48e15;
+--p-banana-900: #ad5f00;
+
+--p-lime: #68b723;
+--p-lime-100: #d1ff82;
+--p-lime-300: #9bdb4d;
+--p-lime-500: #68b723;
+--p-lime-700: #3a9104;
+--p-lime-900: #206b00;
+
+--p-mint: #28bca3;
+--p-mint-100: #89ffdd;
+--p-mint-300: #43d6b5;
+--p-mint-500: #28bca3;
+--p-mint-700: #0e9a83;
+--p-mint-900: #007367;
+
+
+--p-blueberry: #3689e6;
+--p-blueberry-100: #8cd5ff;
+--p-blueberry-300: #64baff;
+--p-blueberry-500: #3689e6;
+--p-blueberry-700: #0d52bf;
+--p-blueberry-900: #002e99;
+
+--p-grape: #a56de2;
+--p-grape-100: #e4c6fa;
+--p-grape-300: #cd9ef7;
+--p-grape-500: #a56de2;
+--p-grape-700: #7239b3;
+--p-grape-900: #452981;
+
+--p-bubblegum: #de3e80;
+--p-bubblegum-100: #fe9ab8;
+--p-bubblegum-300: #f4679d;
+--p-bubblegum-500: #de3e80;
+--p-bubblegum-700: #bc245d;
+--p-bubblegum-900: #910e38;
+
+
+--p-cocoa: #715344;
+--p-cocoa-100: #a3907c;
+--p-cocoa-300: #8a715e;
+--p-cocoa-500: #715344;
+--p-cocoa-700: #57392d;
+--p-cocoa-900: #3d211b;
+
+--p-silver: #abacae;
+--p-silver-100: #fafafa;
+--p-silver-300: #d4d4d4;
+--p-silver-500: #abacae;
+--p-silver-700: #7e8087;
+--p-silver-900: #555761;
+
+--p-slate: #485a6c;
+--p-slate-100: #95a3ab;
+--p-slate-300: #667885;
+--p-slate-500: #485a6c;
+--p-slate-700: #273445;
+--p-slate-900: #0e141f;
+
+
+--p-dark: #333;
+--p-dark-100: #666;
+--p-dark-300: #4d4d4d;
+--p-dark-500: #333;
+--p-dark-700: #1a1a1a;
+--p-dark-900: #000;
+
+
+--p-apple-red: rgb(255, 59 , 48);
+--p-apple-red-dark: rgb(255, 69 , 58);
+--p-apple-orange: rgb(255,149,0);
+--p-apple-orange-dark: rgb(255,159,10);
+--p-apple-yellow: rgb(255,204,0);
+--p-apple-yellow-dark: rgb(255,214,10);
+--p-apple-green: rgb(40,205,65);
+--p-apple-green-dark: rgb(40,215,75);
+--p-apple-mint: rgb(0,199,190);
+--p-apple-mint-dark: rgb(102,212,207);
+--p-apple-teal: rgb(89, 173, 196);
+--p-apple-teal-dark: rgb(106, 196, 220);
+--p-apple-cyan: rgb(85,190,240);
+--p-apple-cyan-dark: rgb(90,200,245);
+--p-apple-blue: rgb(0, 122, 255);
+--p-apple-blue-dark: rgb(10, 132, 255);
+--p-apple-indigo: rgb(88, 86, 214);
+--p-apple-indigo-dark: rgb(94, 92, 230);
+--p-apple-purple: rgb(175, 82, 222);
+--p-apple-purple-dark: rgb(191, 90, 242);
+--p-apple-pink: rgb(255, 45, 85);
+--p-apple-pink-dark: rgb(255, 55, 95);
+--p-apple-brown: rgb(162, 132, 94);
+--p-apple-brown-dark: rgb(172, 142, 104);
+--p-apple-gray: rgb(142, 142, 147);
+--p-apple-gray-dark: rgb(152, 152, 157);
+
+}
+
+
+/*
+APPLE OFFICIAL COLORS
+*/
+
+.p-apple-red{
+  background: rgb(255, 59 , 48);
+}
+
+.p-apple-red-dark{
+  background: rgb(255, 69 , 58);
+}
+
+.p-apple-orange{
+  background: rgb(255,149,0);
+}
+
+.p-apple-orange-dark{
+  background: rgb(255,159,10);
+}
+
+.p-apple-yellow{
+  background: rgb(255,204,0);
+}
+
+.p-apple-yellow-dark{
+  background: rgb(255,214,10);
+}
+
+.p-apple-green{
+  background: rgb(40,205,65);
+}
+
+.p-apple-green-dark{
+  background: rgb(40,215,75);
+}
+
+.p-apple-mint{
+  background: rgb(0,199,190);
+}
+
+.p-apple-mint-dark{
+  background: rgb(102,212,207);
+}
+
+.p-apple-teal{
+  background: rgb(89, 173, 196);
+}
+
+.p-apple-teal-dark{
+  background: rgb(106, 196, 220);
+}
+
+.p-apple-cyan{
+  background: rgb(85,190,240);
+}
+
+.p-apple-cyan-dark{
+  background: rgb(90,200,245);
+}
+
+.p-apple-blue{
+  background: rgb(0, 122, 255);
+}
+
+.p-apple-blue-dark{
+  background: rgb(10, 132, 255);
+}
+
+.p-apple-indigo{
+  background: rgb(88, 86, 214);
+}
+
+.p-apple-indigo-dark{
+  background: rgb(94, 92, 230);
+}
+
+.p-apple-purple{
+  background: rgb(175, 82, 222);
+}
+
+.p-apple-purple-dark{
+  background: rgb(191, 90, 242);
+}
+
+.p-apple-pink{
+  background: rgb(255, 45, 85);
+}
+
+.p-apple-pink-dark{
+  background: rgb(255, 55, 95);
+}
+
+.p-apple-brown{
+  background: rgb(162, 132, 94);
+}
+
+.p-apple-brown-dark{
+  background: rgb(172, 142, 104);
+}
+
+.p-apple-gray{
+  background: rgb(142, 142, 147);
+}
+
+.p-apple-gray-dark{
+  background: rgb(152, 152, 157);
+}
+
+.p-apple-red-color{
+  color: rgb(255, 59 , 48);
+}
+
+.p-apple-red-dark-color{
+  color: rgb(255, 69 , 58);
+}
+
+.p-apple-orange-color{
+  color: rgb(255,149,0);
+}
+
+.p-apple-orange-dark-color{
+  color: rgb(255,159,10);
+}
+
+.p-apple-yellow-color{
+  color: rgb(255,204,0);
+}
+
+.p-apple-yellow-dark-color{
+  color: rgb(255,214,10);
+}
+
+.p-apple-green-color{
+  color: rgb(40,205,65);
+}
+
+.p-apple-green-dark-color{
+  color: rgb(40,215,75);
+}
+
+.p-apple-mint-color{
+  color: rgb(0,199,190);
+}
+
+.p-apple-mint-dark-color{
+  color: rgb(102,212,207);
+}
+
+.p-apple-teal-color{
+  color: rgb(89, 173, 196);
+}
+
+.p-apple-teal-dark-color{
+  color: rgb(106, 196, 220);
+}
+
+.p-apple-cyan-color{
+  color: rgb(85,190,240);
+}
+
+.p-apple-cyan-dark-color{
+  color: rgb(90,200,245);
+}
+
+.p-apple-blue-color{
+  color: rgb(0, 122, 255);
+}
+
+.p-apple-blue-dark-color{
+  color: rgb(10, 132, 255);
+}
+
+.p-apple-indigo-color{
+  color: rgb(88, 86, 214);
+}
+
+.p-apple-indigo-dark-color{
+  color: rgb(94, 92, 230);
+}
+
+.p-apple-purple-color{
+  color: rgb(175, 82, 222);
+}
+
+.p-apple-purple-dark-color{
+  color: rgb(191, 90, 242);
+}
+
+.p-apple-pink-color{
+  color: rgb(255, 45, 85);
+}
+
+.p-apple-pink-dark-color{
+  color: rgb(255, 55, 95);
+}
+
+.p-apple-brown-color{
+  color: rgb(162, 132, 94);
+}
+
+.p-apple-brown-dark-color{
+  color: rgb(172, 142, 104);
+}
+
+.p-apple-gray-color{
+  color: rgb(142, 142, 147);
+}
+
+.p-apple-gray-dark-color{
+  color: rgb(152, 152, 157);
+}
+
+.p-strawberry {
+  background: #c6262e;
+}
+
+.p-strawberry-100 {
+  background: #ff8c82;
+}
+
+.p-strawberry-300 {
+  background: #ed5353;
+}
+
+.p-strawberry-500 {
+  background: #c6262e;
+}
+
+.p-strawberry-700 {
+  background: #a10705;
+}
+
+.p-strawberry-900 {
+  background: #7a0000;
+}
+
+.p-orange {
+  background: #f37329;
+}
+
+.p-orange-100 {
+  background: #ffc27d;
+}
+
+.p-orange-300 {
+  background: #ffa154;
+}
+
+.p-orange-500 {
+  background: #f37329;
+}
+
+.p-orange-700 {
+  background: #cc3b02;
+}
+
+.p-orange-900 {
+  background: #a62100;
+}
+
+.p-banana {
+  background: #f9c440;
+}
+
+.p-banana-100 {
+  background: #fff394;
+}
+
+.p-banana-300 {
+  background: #ffe16b;
+}
+
+.p-banana-500 {
+  background: #f9c440;
+}
+
+.p-banana-700 {
+  background: #d48e15;
+}
+
+.p-banana-900 {
+  background: #ad5f00;
+}
+
+.p-lime {
+  background: #68b723;
+}
+
+.p-lime-100 {
+  background: #d1ff82;
+}
+
+.p-lime-300 {
+  background: #9bdb4d;
+}
+
+.p-lime-500 {
+  background: #68b723;
+}
+
+.p-lime-700 {
+  background: #3a9104;
+}
+
+.p-lime-900 {
+  background: #206b00;
+}
+
+.p-mint {
+  background: #28bca3;
+}
+
+.p-mint-100 {
+  background: #89ffdd;
+}
+
+.p-mint-300 {
+  background: #43d6b5;
+}
+
+.p-mint-500 {
+  background: #28bca3;
+}
+
+.p-mint-700 {
+  background: #0e9a83;
+}
+
+.p-mint-900 {
+  background: #007367;
+}
+
+.p-blueberry {
+  background: #3689e6;
+}
+
+.p-blueberry-100 {
+  background: #8cd5ff;
+}
+
+.p-blueberry-300 {
+  background: #64baff;
+}
+
+.p-blueberry-500 {
+  background: #3689e6;
+}
+
+.p-blueberry-700 {
+  background: #0d52bf;
+}
+
+.p-blueberry-900 {
+  background: #002e99;
+}
+
+.p-grape {
+  background: #a56de2;
+}
+
+.p-grape-100 {
+  background: #e4c6fa;
+}
+
+.p-grape-300 {
+  background: #cd9ef7;
+}
+
+.p-grape-500 {
+  background: #a56de2;
+}
+
+.p-grape-700 {
+  background: #7239b3;
+}
+
+.p-grape-900 {
+  background: #452981;
+}
+
+.p-bubblegum {
+  background: #de3e80;
+}
+
+.p-bubblegum-100 {
+  background: #fe9ab8;
+}
+
+.p-bubblegum-300 {
+  background: #f4679d;
+}
+
+.p-bubblegum-500 {
+  background: #de3e80;
+}
+
+.p-bubblegum-700 {
+  background: #bc245d;
+}
+
+.p-bubblegum-900 {
+  background: #910e38;
+}
+
+.p-cocoa {
+  background: #715344;
+}
+
+.p-cocoa-100 {
+  background: #a3907c;
+}
+
+.p-cocoa-300 {
+  background: #8a715e;
+}
+
+.p-cocoa-500 {
+  background: #715344;
+}
+
+.p-cocoa-700 {
+  background: #57392d;
+}
+
+.p-cocoa-900 {
+  background: #3d211b;
+}
+
+.p-silver {
+  background: #abacae;
+}
+
+.p-silver-100 {
+  background: #fafafa;
+}
+
+.p-silver-300 {
+  background: #d4d4d4;
+}
+
+.p-silver-500 {
+  background: #abacae;
+}
+
+.p-silver-700 {
+  background: #7e8087;
+}
+
+.p-silver-900 {
+  background: #555761;
+}
+
+.p-slate {
+  background: #485a6c;
+}
+
+.p-slate-100 {
+  background: #95a3ab;
+}
+
+.p-slate-300 {
+  background: #667885;
+}
+
+.p-slate-500 {
+  background: #485a6c;
+}
+
+.p-slate-700 {
+  background: #273445;
+}
+
+.p-slate-900 {
+  background: #0e141f;
+}
+
+.p-dark {
+  background: #333;
+}
+
+.p-dark-100 {
+  background: #666;
+  /* hehe */
+}
+
+.p-dark-300 {
+  background: #4d4d4d;
+}
+
+.p-dark-500 {
+  background: #333;
+}
+
+.p-dark-700 {
+  background: #1a1a1a;
+}
+
+.p-dark-900 {
+  background: #000;
+}
+
+.p-white{
+  background: #fff;
+}
+
+.p-strawberry-color {
+  color: #c6262e;
+}
+
+.p-strawberry-100-color {
+  color: #ff8c82;
+}
+
+.p-strawberry-300-color {
+  color: #ed5353;
+}
+
+.p-strawberry-500-color {
+  color: #c6262e;
+}
+
+.p-strawberry-700-color {
+  color: #a10705;
+}
+
+.p-strawberry-900-color {
+  color: #7a0000;
+}
+
+.p-orange-color {
+  color: #f37329;
+}
+
+.p-orange-100-color {
+  color: #ffc27d;
+}
+
+.p-orange-300-color {
+  color: #ffa154;
+}
+
+.p-orange-500-color {
+  color: #f37329;
+}
+
+.p-orange-700-color {
+  color: #cc3b02;
+}
+
+.p-orange-900-color {
+  color: #a62100;
+}
+
+.p-banana-color {
+  color: #f9c440;
+}
+
+.p-banana-100-color {
+  color: #fff394;
+}
+
+.p-banana-300-color {
+  color: #ffe16b;
+}
+
+.p-banana-500-color {
+  color: #f9c440;
+}
+
+.p-banana-700-color {
+  color: #d48e15;
+}
+
+.p-banana-900-color {
+  color: #ad5f00;
+}
+
+.p-lime-color {
+  color: #68b723;
+}
+
+.p-lime-100-color {
+  color: #d1ff82;
+}
+
+.p-lime-300-color {
+  color: #9bdb4d;
+}
+
+.p-lime-500-color {
+  color: #68b723;
+}
+
+.p-lime-700-color {
+  color: #3a9104;
+}
+
+.p-lime-900-color {
+  color: #206b00;
+}
+
+.p-mint-color {
+  color: #28bca3;
+}
+
+.p-mint-100-color {
+  color: #89ffdd;
+}
+
+.p-mint-300-color {
+  color: #43d6b5;
+}
+
+.p-mint-500-color {
+  color: #28bca3;
+}
+
+.p-mint-700-color {
+  color: #0e9a83;
+}
+
+.p-mint-900-color {
+  color: #007367;
+}
+
+.p-blueberry-color {
+  color: #3689e6;
+}
+
+.p-blueberry-100-color {
+  color: #8cd5ff;
+}
+
+.p-blueberry-300-color {
+  color: #64baff;
+}
+
+.p-blueberry-500-color {
+  color: #3689e6;
+}
+
+.p-blueberry-700-color {
+  color: #0d52bf;
+}
+
+.p-blueberry-900-color {
+  color: #002e99;
+}
+
+.p-grape-color {
+  color: #a56de2;
+}
+
+.p-grape-100-color {
+  color: #e4c6fa;
+}
+
+.p-grape-300-color {
+  color: #cd9ef7;
+}
+
+.p-grape-500-color {
+  color: #a56de2;
+}
+
+.p-grape-700-color {
+  color: #7239b3;
+}
+
+.p-grape-900-color {
+  color: #452981;
+}
+
+.p-bubblegum-color {
+  color: #de3e80;
+}
+
+.p-bubblegum-100-color {
+  color: #fe9ab8;
+}
+
+.p-bubblegum-300-color {
+  color: #f4679d;
+}
+
+.p-bubblegum-500-color {
+  color: #de3e80;
+}
+
+.p-bubblegum-700-color {
+  color: #bc245d;
+}
+
+.p-bubblegum-900-color {
+  color: #910e38;
+}
+
+.p-cocoa-color {
+  color: #715344;
+}
+
+.p-cocoa-100-color {
+  color: #a3907c;
+}
+
+.p-cocoa-300-color {
+  color: #8a715e;
+}
+
+.p-cocoa-500-color {
+  color: #715344;
+}
+
+.p-cocoa-700-color {
+  color: #57392d;
+}
+
+.p-cocoa-900-color {
+  color: #3d211b;
+}
+
+.p-silver-color {
+  color: #abacae;
+}
+
+.p-silver-100-color {
+  color: #fafafa;
+}
+
+.p-silver-300-color {
+  color: #d4d4d4;
+}
+
+.p-silver-500-color {
+  color: #abacae;
+}
+
+.p-silver-700-color {
+  color: #7e8087;
+}
+
+.p-silver-900-color {
+  color: #555761;
+}
+
+.p-slate-color {
+  color: #485a6c;
+}
+
+.p-slate-100-color {
+  color: #95a3ab;
+}
+
+.p-slate-300-color {
+  color: #667885;
+}
+
+.p-slate-500-color {
+  color: #485a6c;
+}
+
+.p-slate-700-color {
+  color: #273445;
+}
+
+.p-slate-900-color {
+  color: #0e141f;
+}
+
+.p-dark-color {
+  color: #333;
+}
+
+.p-dark-100-color {
+  color: #666;
+  /* hehe */
+}
+
+.p-dark-300-color {
+  color: #4d4d4d;
+}
+
+.p-dark-500-color {
+  color: #333;
+}
+
+.p-dark-700-color {
+  color: #1a1a1a;
+}
+
+.p-dark-900-color {
+  color: #000;
+}
+
+.p-white-color{
+  color: #fff;
+}
diff --git a/v3/examples/android/frontend/public/puppertino/css/dark_mode.css b/v3/examples/android/frontend/public/puppertino/css/dark_mode.css
new file mode 100644
index 000000000..3c5a03e80
--- /dev/null
+++ b/v3/examples/android/frontend/public/puppertino/css/dark_mode.css
@@ -0,0 +1 @@
+/* Puppertino dark_mode placeholder - local vendored */
diff --git a/v3/examples/android/frontend/public/puppertino/css/forms.css b/v3/examples/android/frontend/public/puppertino/css/forms.css
new file mode 100644
index 000000000..f2320ab1b
--- /dev/null
+++ b/v3/examples/android/frontend/public/puppertino/css/forms.css
@@ -0,0 +1,509 @@
+:root {
+  --primary-col:linear-gradient(to bottom, #4fc5fa 0%,#0f75f5 100%);
+  --primary-col-ac:#0f75f5;
+  --bg-color-input:#fff;
+
+  --p-checkbox-gradient: linear-gradient(180deg, #4B91F7 0%, #367AF6 100%);
+  --p-checkbox-border: rgba(0, 0, 0, 0.2);
+  --p-checkbox-border-active: rgba(0, 0, 0, 0.12);
+  --p-checkbox-bg: transparent;
+  --p-checkbox-shadow: inset 0px 1px 2px rgba(0, 0, 0, 0.15), inset 0px 0px 2px rgba(0, 0, 0, 0.10);
+
+  --p-input-bg:#fff;
+  --p-input-color: rgba(0,0,0,.85);
+  --p-input-color-plac:rgba(0,0,0,0.25);
+
+  --p-input-color:#808080;
+  --p-input-bd:rgba(0,0,0,0.15);
+  --bg-hover-color:#f9f9f9;
+  --bg-front-col:#000;
+  --invalid-color:#d6513c;
+  --valid-color:#94d63c;
+}
+
+.p-dark-mode{
+  --p-checkbox-bg: linear-gradient(180deg, rgba(255, 255, 255, 0.1) 0%, rgba(255, 255, 255, 0.13) 100%);
+  --p-checkbox-shadow: 0px 0px 1px rgba(0, 0, 0, 0.25), inset 0px 0.5px 0px rgba(255, 255, 255, 0.15);
+  --p-checkbox-border: rgba(0, 0, 0, 0);
+
+  --p-checkbox-gradient:  linear-gradient(180deg, #3168DD 0%, #2C5FC8 100%);
+  --p-checkbox-border-active: rgba(0, 0, 0, 0);
+}
+
+.p-form-select {
+  border-radius: 5px;
+  display: inline-block;
+  font-family: -apple-system, "Inter", sans-serif;
+  margin: 10px;
+  position: relative;
+}
+
+.p-form-select > select:focus{
+  outline: 2px solid #64baff;
+}
+
+.p-form-select::after {
+  background: url("data:image/svg+xml,%3Csvg fill='none' xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 12'%3E%3Cpath d='M.288 4.117 3.16 1.18c.168-.168.336-.246.54-.246a.731.731 0 0 1 .538.246L7.108 4.12c.125.121.184.27.184.45 0 .359-.293.656-.648.656a.655.655 0 0 1-.48-.211L3.701 2.465l-2.469 2.55a.664.664 0 0 1-.48.212.656.656 0 0 1-.465-1.11Zm3.41 7.324a.73.73 0 0 0 .54-.246l2.87-2.941a.601.601 0 0 0 .184-.45.656.656 0 0 0-.648-.656.677.677 0 0 0-.48.211L3.701 9.91 1.233 7.36a.68.68 0 0 0-.48-.212.656.656 0 0 0-.465 1.11l2.871 2.937c.172.168.336.246.54.246Z' fill='white' style='mix-blend-mode:luminosity'/%3E%3C/svg%3E"), #017AFF;
+  background-size: 100% 75%;
+  background-position: center;
+  background-repeat: no-repeat;
+  border-radius: 5px;
+  bottom: 0;
+  content: "";
+  display: block;
+  height: 80%;
+  pointer-events: none;
+  position: absolute;
+  right: 3%;
+  top: 10%;
+  width: 20px;
+}
+
+.p-form-select > select {
+  -webkit-appearance: none;
+  appearance: none;
+  background: var(--p-input-bg);
+  border: 1px solid var(--p-input-bd);
+  border-radius: 5px;
+  font-size: 14px;
+  margin: 0;
+  outline: none;
+  padding: 5px 35px 5px 10px;
+  position: relative;
+  width: 100%;
+  color: var(--p-input-color);
+}
+
+.p-form-text:invalid,
+.p-form-text-alt:invalid{
+  border-color: var(--invalid-color);
+}
+
+.p-form-text:valid,
+.p-form-text-alt:valid{
+  border-color: var(--valid-color);
+}
+
+.p-form-text:placeholder-shown,
+.p-form-text-alt:placeholder-shown{
+  border-color: var(--p-input-bd);
+}
+
+.p-form-text {
+  color: var(--p-input-color);
+  -webkit-appearance: none;
+  appearance: none;
+  background: var(--p-input-bg);
+  border: 1px solid var(--p-input-bd);
+  border-radius: 5px;
+  font-family: -apple-system, "Inter", sans-serif;
+  font-size: 13px;
+  margin: 10px;
+  outline: 0;
+  padding: 3px 7px;
+  resize: none;
+  transition: border-color 200ms;
+  box-shadow: 0px 0.5px 2.5px rgba(0,0,0,.3), 0px 0px 0px rgba(0,0,0,.1);
+}
+
+.p-form-text-alt {
+  color: var(--p-input-color);
+  -webkit-appearance: none;
+  appearance: none;
+  box-shadow: none;
+  background: var(--p-input-bg);
+  border: 0px;
+  border-bottom: 2px solid var(--p-input-bd);
+  padding: 10px;
+  border-top-left-radius: 3px;
+  border-top-right-radius: 3px;
+  margin: 10px;
+}
+
+
+
+.p-form-text-alt::placeholder,
+.p-form-text::placeholder
+{
+  color: var(--p-input-color-plac);
+}
+
+.p-form-text:active,
+.p-form-text:focus
+{
+  outline: 3px solid rgb(0 122 255 / 50%);
+}
+
+.p-form-text-alt:focus {
+  outline: 0;
+  outline: 3px solid rgb(0 122 255 / 50%);
+  border-color: #3689e6;
+}
+
+.p-form-no-validate:valid,
+.p-form-no-validate:invalid{
+  border-color: var(--p-input-bd);
+  color: var(--p-input-color)!important;
+}
+
+.p-form-text:focus {
+  border-color: rgb(0 122 255);
+}
+
+textarea.p-form-text {
+  -webkit-appearance: none;
+  appearance: none;
+  height: 100px;
+}
+
+.p-form-truncated {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.p-form-text[type=password] {
+  font-family: caption;
+}
+
+.p-form-label,
+.p-form-radio-cont,
+.p-form-checkbox-cont,
+.p-form-label-inline {
+  font-family: -apple-system, "Inter", sans-serif;
+}
+
+.p-form-label, .p-form-label-inline {
+  display: inline-block;
+}
+
+.p-form-label{
+  font-size: 11px;
+}
+
+.p-form-label-inline {
+  background: var(--p-input-bg);
+  padding: 5px;
+  border-bottom: 2px solid var(--p-input-bd);
+  color: #656565;
+  font-weight: 500;
+  transition: .3s;
+}
+
+.p-form-label-inline:focus-within {
+  color: #3689e6;
+  border-color: #3689e6;
+}
+
+.p-form-label-inline > .p-form-text-alt {
+  border-bottom: 0px;
+  padding: 0;
+  outline: 0;
+  background: var(--p-input-bg);
+
+}
+
+.p-form-label-inline > .p-form-text-alt:-webkit-autofill{
+  background: var(--p-input-bg);
+  -webkit-box-shadow: 0 0 0 30px rgba(0,0,0,0) inset !important;
+}
+
+.p-form-label-inline > .p-form-text-alt:invalid {
+  color: var(--invalid-color);
+}
+
+.p-form-label-inline > .p-form-text-alt:valid {
+  color: #3689e6;
+}
+
+.p-form-label-inline > .p-form-text-alt:focus{
+  color: var(--p-input-color);
+}
+
+.p-form-radio-cont,
+.p-form-checkbox-cont {
+  align-items: center;
+  display: inline-flex;
+  cursor: pointer;
+  margin: 0 10px;
+  user-select: none;
+}
+
+.p-form-radio-cont > input + span,
+.p-form-checkbox-cont > input + span {
+  background: var(--p-input-bg);
+  border: 1px solid var(--p-input-bd);
+  border-radius: 50%;
+  display: inline-block;
+  height: 20px;
+  margin-right: 5px;
+  position: relative;
+  transition: 0.2s;
+  width: 20px;
+}
+
+.p-form-radio-cont > input + span{
+  box-shadow: inset 0px 1px 2px rgba(0,0,0,0.10), inset 0px 0px 2px rgba(0,0,0,0.10);
+}
+
+.p-form-radio-cont > input:focus + span,
+.p-form-checkbox-cont > input:focus + span{
+  outline: 3px solid rgb(0 122 255 / 50%);
+}
+
+.p-form-radio-cont:hover > input + span{
+  background: #f9f9f9;
+}
+
+.p-form-radio-cont > input,
+.p-form-checkbox-cont > input {
+  opacity: 0;
+  pointer-events: none;
+  position: absolute;
+}
+
+.p-form-radio-cont > input + span::after {
+  background: #fff;
+  border-radius: 50%;
+  content: "";
+  display: block;
+  height: 30%;
+  left: calc(50% - 15%);
+  opacity: 0;
+  position: absolute;
+  top: calc(50% - 15%);
+  transform: scale(2);
+  transition: opacity 0.2s, transform 0.3s;
+  width: 30%;
+}
+
+.p-form-radio-cont > input:checked + span {
+  background: #0f75f5;
+  box-shadow: 0px 1px 2.5px 1px rgba(0, 122, 255, 0.24), inset 0px 0px 0px 0.5px rgba(0, 122, 255, 0.12);
+}
+
+.p-form-radio-cont > input:checked + span::after {
+  opacity: 1;
+  transform: scale(1);
+}
+
+.p-form-checkbox-cont > input + span {
+  border-radius: 5px;
+  box-shadow: var(--p-checkbox-shadow);
+  border: 0.5px solid var(--p-checkbox-border);
+  background: var(--p-checkbox-bg)
+}
+
+.p-form-checkbox-cont > input:checked + span {
+  background: var(--p-checkbox-gradient);
+  border: 0.5px solid var(--p-checkbox-border-active);
+  box-shadow: 0px 1px 2.5px rgba(0, 122, 255, 0.24), 0px 0px 0px 0.5px rgba(0, 122, 255, 0.12);
+}
+
+.p-form-checkbox-cont > input + span::before{
+  content: "";
+  display: block;
+  height: 100%;
+  width: 100%;
+  position: absolute;
+  left: 0%;
+  top: 0%;
+  opacity: 0;
+  transition: opacity 0.2s;
+  background-image: url("data:image/svg+xml,%3Csvg width='10' height='8' viewBox='0 0 10 8' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M4.10791 7.81299C3.83545 7.81299 3.6084 7.70459 3.42676 7.48779L1.15918 4.74121C1.08008 4.65039 1.02441 4.5625 0.992188 4.47754C0.959961 4.39258 0.943848 4.30469 0.943848 4.21387C0.943848 4.00586 1.0127 3.83447 1.15039 3.69971C1.29102 3.56201 1.4668 3.49316 1.67773 3.49316C1.91211 3.49316 2.10693 3.58838 2.26221 3.77881L4.10791 6.04297L7.68066 0.368652C7.77148 0.230957 7.86523 0.134277 7.96191 0.0786133C8.06152 0.0200195 8.18311 -0.00927734 8.32666 -0.00927734C8.5376 -0.00927734 8.71191 0.0581055 8.84961 0.192871C8.9873 0.327637 9.05615 0.497559 9.05615 0.702637C9.05615 0.778809 9.04297 0.85791 9.0166 0.939941C8.99023 1.02197 8.94922 1.10693 8.89355 1.19482L4.80225 7.45703C4.64111 7.69434 4.40967 7.81299 4.10791 7.81299Z' fill='white'/%3E%3C/svg%3E%0A");
+  background-size: 70%;
+  background-position: center;
+  background-repeat: no-repeat;
+}
+
+.p-form-checkbox-cont > input + span::after{
+  content: '';
+  width: 100%;
+  height: 100%;
+  position: absolute;
+  top: 0;
+  left: 0;
+  z-index: 9;
+}
+
+.p-form-checkbox-cont > input + span:active::after{
+  border-radius: 5px;
+  backdrop-filter: brightness(1.2);
+}
+
+.p-form-checkbox-cont > input:checked + span::before{
+  opacity: 1;
+}
+
+
+.p-form-checkbox-cont > input[disabled] + span,
+.p-form-radio-cont > input[disabled] ~ span
+{
+  opacity: .7;
+  cursor: not-allowed;
+}
+
+.p-form-button {
+  -webkit-appearance: none;
+  appearance: none;
+  background: #fff;
+  border: 1px solid var(--p-input-bd);
+  border-radius: 5px;
+  color: #333230;
+  display: inline-block;
+  font-size: 17px;
+  margin: 10px;
+  padding: 5px 20px;
+  text-decoration: none;
+}
+
+.p-form-send {
+  background: linear-gradient(to bottom, #4fc5fa 0%, #0f75f5 100%);
+  border: 0;
+  color: #fff;
+}
+
+.p-form-send:active {
+  background: #0f75f5;
+}
+
+.p-form-invalid,
+.p-form-invalid:placeholder-shown,
+.p-form-invalid:valid,
+.p-form-invalid:invalid {
+  border-color: var(--invalid-color);
+}
+
+.p-form-valid,
+.p-form-valid:placeholder-shown,
+.p-form-valid:valid,
+.p-form-valid:invalid {
+  border-color: var(--valid-color);
+}
+
+.p-form-switch {
+  --width: 80px;
+  cursor: pointer;
+  display: inline-block;
+}
+
+.p-form-switch > input:checked + span::after {
+  left: calc(100% - calc(var(--width) / 1.8));
+}
+
+.p-form-switch > input:checked + span {
+  background: #60c35b;
+}
+
+.p-form-switch > span {
+  background: #e0e0e0;
+  border: 1px solid #d3d3d3;
+  border-radius: 500px;
+  display: block;
+  height: calc(var(--width) / 1.6);
+  position: relative;
+  transition: all 0.2s;
+  width: var(--width);
+}
+
+.p-form-switch > span::after {
+  background: #f9f9f9;
+  border-radius: 50%;
+  border: 0.5px solid rgba(0, 0, 0, 0.101987);
+  box-shadow: 0px 3px 1px rgba(0, 0, 0, 0.1), 0px 1px 1px rgba(0, 0, 0, 0.16), 0px 3px 8px rgba(0, 0, 0, 0.15);
+  box-sizing: border-box;
+  content: "";
+  height: 84%;
+  left: 3%;
+  position: absolute;
+  top: 6.5%;
+  transition: all 0.2s;
+  width: 52.5%;
+}
+
+.p-form-switch > input {
+  display: none;
+}
+
+.p-chip input{
+  opacity: 0;
+  pointer-events: none;
+  position: absolute;
+}
+
+.p-chip span{
+  padding: .8rem 1rem;
+  border-radius: 1.6rem;
+  display:inline-block;
+  margin:10px;
+  background: #e4e4e4ca;
+  color: #3689e6;
+  transition: .3s;
+  user-select: none;
+  cursor:pointer;
+  font-family: -apple-system, "Inter", sans-serif;
+  font-size: 1rem;
+      -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
+    -moz-tap-highlight-color: rgba(0, 0, 0, 0);
+  text-align:center;
+}
+
+.p-chip:focus-within span{
+  outline: 2px solid #64baff;
+}
+
+.p-chip svg{
+  display:block;
+  margin:auto;
+}
+
+
+.p-chip input:checked + span{
+  background: #3689e6;
+  color:#fff;
+}
+
+.p-chip-outline span, .p-chip-outline-to-bg span{
+  background: transparent;
+  color: #3e3e3e;
+  border: 1px solid currentColor;
+}
+
+.p-chip-outline input:checked + span{
+  background: transparent;
+  color: #3689e6;
+}
+
+.p-chip-radius-b span{
+  border-radius: 5px;
+}
+
+.p-chip-dark span{
+  color: #3e3e3e;
+}
+
+.p-chip-dark input:checked + span{
+  background: #3e3e3e;
+}
+
+.p-chip input:disabled + span,
+.p-chip input[disabled] + span{
+  opacity: .5;
+  cursor: not-allowed;
+}
+
+.p-chip-big span{
+  font-size: 1.3rem;
+  padding: 1.5rem;
+  min-width: 80px;
+}
+
+.p-form-checkbox-cont[disabled],
+.p-form-label[disabled],
+.p-form-text[disabled],
+.p-form-text-alt[disabled],
+.p-form-select[disabled],
+.p-form-radio-cont[disabled]{
+  filter: grayscale(1) opacity(.3);
+  pointer-events: none;
+}
diff --git a/v3/examples/android/frontend/public/puppertino/css/layout.css b/v3/examples/android/frontend/public/puppertino/css/layout.css
new file mode 100644
index 000000000..1f9b36845
--- /dev/null
+++ b/v3/examples/android/frontend/public/puppertino/css/layout.css
@@ -0,0 +1,45 @@
+.p-large-title{
+  font-size: 2.75rem;
+}
+
+.p-layout h1 {
+  font-size: 2.25rem;
+}
+
+.p-layout h2 {
+  font-size: 1.75rem;
+}
+
+.p-layout h3 {
+  font-size: 1.58rem;
+}
+
+.p-headline {
+  font-size: 1.34rem;
+  font-weight: bold;
+}
+
+.p-layout p {
+  font-size: 1.15rem;
+}
+
+.p-layout .link,
+.p-layout input {
+  font-size: 0.813rem;
+}
+
+.p-callout {
+  font-size: 1.14rem;
+}
+
+.p-subhead {
+  font-size: 1.167rem;
+}
+
+.p-footnote {
+  font-size: 1.07rem;
+}
+
+.p-caption {
+  font-size: 0.91rem;
+}
diff --git a/v3/examples/android/frontend/public/puppertino/css/modals.css b/v3/examples/android/frontend/public/puppertino/css/modals.css
new file mode 100644
index 000000000..4d718c4f7
--- /dev/null
+++ b/v3/examples/android/frontend/public/puppertino/css/modals.css
@@ -0,0 +1 @@
+/* Puppertino modals placeholder - local vendored */
diff --git a/v3/examples/android/frontend/public/puppertino/css/newfull.css b/v3/examples/android/frontend/public/puppertino/css/newfull.css
new file mode 100644
index 000000000..622a2f364
--- /dev/null
+++ b/v3/examples/android/frontend/public/puppertino/css/newfull.css
@@ -0,0 +1,11 @@
+@import url('actions.css');
+@import url('buttons.css');
+@import url('layout.css');
+@import url('cards.css');
+@import url('color_palette.css');
+@import url('forms.css');
+@import url('modals.css');
+@import url('segmented-controls.css');
+@import url('shadows.css');
+@import url('tabs.css');
+@import url('dark_mode.css');
diff --git a/v3/examples/android/frontend/public/puppertino/css/segmented-controls.css b/v3/examples/android/frontend/public/puppertino/css/segmented-controls.css
new file mode 100644
index 000000000..22819fd5f
--- /dev/null
+++ b/v3/examples/android/frontend/public/puppertino/css/segmented-controls.css
@@ -0,0 +1 @@
+/* Puppertino segmented-controls placeholder - local vendored */
diff --git a/v3/examples/android/frontend/public/puppertino/css/shadows.css b/v3/examples/android/frontend/public/puppertino/css/shadows.css
new file mode 100644
index 000000000..060a61658
--- /dev/null
+++ b/v3/examples/android/frontend/public/puppertino/css/shadows.css
@@ -0,0 +1 @@
+/* Puppertino shadows placeholder - local vendored */
diff --git a/v3/examples/android/frontend/public/puppertino/css/tabs.css b/v3/examples/android/frontend/public/puppertino/css/tabs.css
new file mode 100644
index 000000000..61d1487ca
--- /dev/null
+++ b/v3/examples/android/frontend/public/puppertino/css/tabs.css
@@ -0,0 +1 @@
+/* Puppertino tabs placeholder - local vendored */
diff --git a/v3/examples/android/frontend/public/puppertino/puppertino.css b/v3/examples/android/frontend/public/puppertino/puppertino.css
new file mode 100644
index 000000000..905da220e
--- /dev/null
+++ b/v3/examples/android/frontend/public/puppertino/puppertino.css
@@ -0,0 +1,1774 @@
+@charset "UTF-8";
+.p-btn {
+  background: #fff;
+  border: 1px solid #cacaca;
+  border-radius: 5px;
+  color: #333230;
+  display: inline-block;
+  font-family: -apple-system, "Inter", sans-serif;
+  font-size: 17px;
+  margin: 10px;
+  padding: 5px 20px;
+  text-decoration: none;
+  /* text-shadow: 0 1px 1px rgba(0, 0, 0, 0.25); */
+}
+.p-btn-mob{
+    padding: 10px 40px;
+    background: #0f75f5;
+    color: #fff;
+}
+.p-btn[disabled] {
+  background: #d3d3d3;
+  color: #555;
+  cursor: not-allowed;
+}
+.p-btn:disabled {
+  background: #d3d3d3;
+  color: #555;
+  cursor: not-allowed;
+}
+.p-btn-disabled {
+  background: #d3d3d3;
+  color: #555;
+  cursor: not-allowed;
+}
+
+.p-prim-col {
+  background: linear-gradient(to bottom, #4fc5fa 0%, #0f75f5 100%);
+  border: 0;
+  color: #fff;
+}
+
+.p-btn.p-prim-col:active {
+  background: #0f75f5;
+}
+
+.p-btn-more::after {
+  content: "...";
+}
+
+.p-btn-round {
+  border: 0;
+  border-radius: 50px;
+  padding: 10px 30px;
+}
+
+.p-btn-icon {
+  align-items: center;
+  background: #fff;
+  border: 2px solid currentColor;
+  border-radius: 50%;
+  box-shadow: 0 3px 10px -8px #000;
+  color: #0f75f5;
+  display: inline-flex;
+  font-weight: 900;
+  height: 36px;
+  justify-content: center;
+  margin: 5px;
+  text-align: center;
+  text-decoration: none;
+  width: 36px;
+}
+
+.p-btn-scope {
+  background: #8e8e8e;
+  color: #fff;
+  margin: 5px;
+  padding: 2px 20px;
+}
+.p-btn-scope-unactive {
+  background: transparent;
+  border-color: transparent;
+  color: #212136;
+  transition: border-color 0.2s;
+}
+.p-btn-scope-unactive:hover {
+  border-color: #cacaca;
+}
+.p-btn-scope-disabled {
+  background: transparent;
+  color: #8e8e8e;
+  cursor: not-allowed;
+}
+.p-btn-scope-outline {
+  background: transparent;
+  color: #212136;
+}
+
+.p-btn-scope-outline {
+  background: transparent;
+  color: #212136;
+}
+
+.p-btn-outline {
+  background: none;
+  border-color: currentColor;
+}
+
+.p-btn-outline-dash {
+  background: none;
+  border-color: currentColor;
+  border-style: dashed;
+}
+
+.p-btn-direction {
+  color: #212136;
+  padding: 5px;
+  text-decoration: none;
+}
+
+.p-btn-direction.p-btn-d-back::before {
+  content: "❬";
+}
+
+.p-btn-direction.p-btn-d-next::after {
+  content: "❭";
+}
+
+@media (max-width: 576px) {
+  .p-btn-big-sm {
+    border: 0;
+    border-radius: 0%;
+    bottom: 0;
+    font-size: 50px;
+    left: 0;
+    margin: 0;
+    padding: 10px 0;
+    position: fixed;
+    text-align: center;
+    width: 100%;
+  }
+}
+
+/*END OF BUTTONS*/
+
+.p-card {
+  background: rgba(255, 255, 255, 0.3);
+  border: 1px solid rgba(0, 0, 0, 0.1);
+  border-radius: 3px;
+  box-shadow: 0 8px 10px -8px rgba(0, 0, 0, 0.1);
+  color: #000;
+  display: block;
+  margin-top: 30px;
+  text-decoration: none;
+}
+.p-card-image > img {
+  border-bottom: 3px solid var(--accent-article);
+  display: block;
+  margin: auto;
+  width: 100%;
+}
+.p-card-tags {
+  display: flex;
+  overflow: hidden;
+  position: relative;
+  width: 100%;
+}
+.p-card-tags::before {
+  background: linear-gradient(to right, rgba(255, 255, 255, 0) 0%, rgba(255, 255, 255, 0) 75%, white 100%);
+  content: "";
+  height: 100%;
+  position: absolute;
+  right: 0;
+  top: 0;
+  width: 30%;
+}
+.p-card-tags span,
+.p-card-tags a {
+  border: 1px solid #252525;
+  border-radius: 50px;
+  color: #252525;
+  margin: 5px;
+  padding: 5px 15px;
+  text-decoration: none;
+  transition: all 0.2s;
+}
+.p-card-tags a:hover {
+  background: #252525;
+  color: #000;
+}
+.p-card-title {
+  font-size: 2rem;
+  margin-bottom: 15px;
+  margin-top: 10px;
+}
+.p-card-content {
+  padding: 15px;
+  padding-top: 5px;
+}
+.p-card-text {
+  font-size: 17px;
+  margin-bottom: 10px;
+  margin-left: 10px;
+  margin-top: 0;
+}
+
+
+/* END OF CARDS*/
+
+.p-strawberry {
+  background: #c6262e;
+}
+
+.p-strawberry-100 {
+  background: #ff8c82;
+}
+
+.p-strawberry-300 {
+  background: #ed5353;
+}
+
+.p-strawberry-500 {
+  background: #c6262e;
+}
+
+.p-strawberry-700 {
+  background: #a10705;
+}
+
+.p-strawberry-900 {
+  background: #7a0000;
+}
+
+.p-orange {
+  background: #f37329;
+}
+
+.p-orange-100 {
+  background: #ffc27d;
+}
+
+.p-orange-300 {
+  background: #ffa154;
+}
+
+.p-orange-500 {
+  background: #f37329;
+}
+
+.p-orange-700 {
+  background: #cc3b02;
+}
+
+.p-orange-900 {
+  background: #a62100;
+}
+
+.p-banana {
+  background: #f9c440;
+}
+
+.p-banana-100 {
+  background: #fff394;
+}
+
+.p-banana-300 {
+  background: #ffe16b;
+}
+
+.p-banana-500 {
+  background: #f9c440;
+}
+
+.p-banana-700 {
+  background: #d48e15;
+}
+
+.p-banana-900 {
+  background: #ad5f00;
+}
+
+.p-lime {
+  background: #68b723;
+}
+
+.p-lime-100 {
+  background: #d1ff82;
+}
+
+.p-lime-300 {
+  background: #9bdb4d;
+}
+
+.p-lime-500 {
+  background: #68b723;
+}
+
+.p-lime-700 {
+  background: #3a9104;
+}
+
+.p-lime-900 {
+  background: #206b00;
+}
+
+.p-mint {
+  background: #28bca3;
+}
+
+.p-mint-100 {
+  background: #89ffdd;
+}
+
+.p-mint-300 {
+  background: #43d6b5;
+}
+
+.p-mint-500 {
+  background: #28bca3;
+}
+
+.p-mint-700 {
+  background: #0e9a83;
+}
+
+.p-mint-900 {
+  background: #007367;
+}
+
+.p-blueberry {
+  background: #3689e6;
+}
+
+.p-blueberry-100 {
+  background: #8cd5ff;
+}
+
+.p-blueberry-300 {
+  background: #64baff;
+}
+
+.p-blueberry-500 {
+  background: #3689e6;
+}
+
+.p-blueberry-700 {
+  background: #0d52bf;
+}
+
+.p-blueberry-900 {
+  background: #002e99;
+}
+
+.p-grape {
+  background: #a56de2;
+}
+
+.p-grape-100 {
+  background: #e4c6fa;
+}
+
+.p-grape-300 {
+  background: #cd9ef7;
+}
+
+.p-grape-500 {
+  background: #a56de2;
+}
+
+.p-grape-700 {
+  background: #7239b3;
+}
+
+.p-grape-900 {
+  background: #452981;
+}
+
+.p-bubblegum {
+  background: #de3e80;
+}
+
+.p-bubblegum-100 {
+  background: #fe9ab8;
+}
+
+.p-bubblegum-300 {
+  background: #f4679d;
+}
+
+.p-bubblegum-500 {
+  background: #de3e80;
+}
+
+.p-bubblegum-700 {
+  background: #bc245d;
+}
+
+.p-bubblegum-900 {
+  background: #910e38;
+}
+
+.p-cocoa {
+  background: #715344;
+}
+
+.p-cocoa-100 {
+  background: #a3907c;
+}
+
+.p-cocoa-300 {
+  background: #8a715e;
+}
+
+.p-cocoa-500 {
+  background: #715344;
+}
+
+.p-cocoa-700 {
+  background: #57392d;
+}
+
+.p-cocoa-900 {
+  background: #3d211b;
+}
+
+.p-silver {
+  background: #abacae;
+}
+
+.p-silver-100 {
+  background: #fafafa;
+}
+
+.p-silver-300 {
+  background: #d4d4d4;
+}
+
+.p-silver-500 {
+  background: #abacae;
+}
+
+.p-silver-700 {
+  background: #7e8087;
+}
+
+.p-silver-900 {
+  background: #555761;
+}
+
+.p-slate {
+  background: #485a6c;
+}
+
+.p-slate-100 {
+  background: #95a3ab;
+}
+
+.p-slate-300 {
+  background: #667885;
+}
+
+.p-slate-500 {
+  background: #485a6c;
+}
+
+.p-slate-700 {
+  background: #273445;
+}
+
+.p-slate-900 {
+  background: #0e141f;
+}
+
+.p-dark {
+  background: #333;
+}
+
+.p-dark-100 {
+  background: #666;
+  /* hehe */
+}
+
+.p-dark-300 {
+  background: #4d4d4d;
+}
+
+.p-dark-500 {
+  background: #333;
+}
+
+.p-dark-700 {
+  background: #1a1a1a;
+}
+
+.p-dark-900 {
+  background: #000;
+}
+
+.p-strawberry-color {
+  color: #c6262e;
+}
+
+.p-strawberry-100-color {
+  color: #ff8c82;
+}
+
+.p-strawberry-300-color {
+  color: #ed5353;
+}
+
+.p-strawberry-500-color {
+  color: #c6262e;
+}
+
+.p-strawberry-700-color {
+  color: #a10705;
+}
+
+.p-strawberry-900-color {
+  color: #7a0000;
+}
+
+.p-orange-color {
+  color: #f37329;
+}
+
+.p-orange-100-color {
+  color: #ffc27d;
+}
+
+.p-orange-300-color {
+  color: #ffa154;
+}
+
+.p-orange-500-color {
+  color: #f37329;
+}
+
+.p-orange-700-color {
+  color: #cc3b02;
+}
+
+.p-orange-900-color {
+  color: #a62100;
+}
+
+.p-banana-color {
+  color: #f9c440;
+}
+
+.p-banana-100-color {
+  color: #fff394;
+}
+
+.p-banana-300-color {
+  color: #ffe16b;
+}
+
+.p-banana-500-color {
+  color: #f9c440;
+}
+
+.p-banana-700-color {
+  color: #d48e15;
+}
+
+.p-banana-900-color {
+  color: #ad5f00;
+}
+
+.p-lime-color {
+  color: #68b723;
+}
+
+.p-lime-100-color {
+  color: #d1ff82;
+}
+
+.p-lime-300-color {
+  color: #9bdb4d;
+}
+
+.p-lime-500-color {
+  color: #68b723;
+}
+
+.p-lime-700-color {
+  color: #3a9104;
+}
+
+.p-lime-900-color {
+  color: #206b00;
+}
+
+.p-mint-color {
+  color: #28bca3;
+}
+
+.p-mint-100-color {
+  color: #89ffdd;
+}
+
+.p-mint-300-color {
+  color: #43d6b5;
+}
+
+.p-mint-500-color {
+  color: #28bca3;
+}
+
+.p-mint-700-color {
+  color: #0e9a83;
+}
+
+.p-mint-900-color {
+  color: #007367;
+}
+
+.p-blueberry-color {
+  color: #3689e6;
+}
+
+.p-blueberry-100-color {
+  color: #8cd5ff;
+}
+
+.p-blueberry-300-color {
+  color: #64baff;
+}
+
+.p-blueberry-500-color {
+  color: #3689e6;
+}
+
+.p-blueberry-700-color {
+  color: #0d52bf;
+}
+
+.p-blueberry-900-color {
+  color: #002e99;
+}
+
+.p-grape-color {
+  color: #a56de2;
+}
+
+.p-grape-100-color {
+  color: #e4c6fa;
+}
+
+.p-grape-300-color {
+  color: #cd9ef7;
+}
+
+.p-grape-500-color {
+  color: #a56de2;
+}
+
+.p-grape-700-color {
+  color: #7239b3;
+}
+
+.p-grape-900-color {
+  color: #452981;
+}
+
+.p-bubblegum-color {
+  color: #de3e80;
+}
+
+.p-bubblegum-100-color {
+  color: #fe9ab8;
+}
+
+.p-bubblegum-300-color {
+  color: #f4679d;
+}
+
+.p-bubblegum-500-color {
+  color: #de3e80;
+}
+
+.p-bubblegum-700-color {
+  color: #bc245d;
+}
+
+.p-bubblegum-900-color {
+  color: #910e38;
+}
+
+.p-cocoa-color {
+  color: #715344;
+}
+
+.p-cocoa-100-color {
+  color: #a3907c;
+}
+
+.p-cocoa-300-color {
+  color: #8a715e;
+}
+
+.p-cocoa-500-color {
+  color: #715344;
+}
+
+.p-cocoa-700-color {
+  color: #57392d;
+}
+
+.p-cocoa-900-color {
+  color: #3d211b;
+}
+
+.p-silver-color {
+  color: #abacae;
+}
+
+.p-silver-100-color {
+  color: #fafafa;
+}
+
+.p-silver-300-color {
+  color: #d4d4d4;
+}
+
+.p-silver-500-color {
+  color: #abacae;
+}
+
+.p-silver-700-color {
+  color: #7e8087;
+}
+
+.p-silver-900-color {
+  color: #555761;
+}
+
+.p-slate-color {
+  color: #485a6c;
+}
+
+.p-slate-100-color {
+  color: #95a3ab;
+}
+
+.p-slate-300-color {
+  color: #667885;
+}
+
+.p-slate-500-color {
+  color: #485a6c;
+}
+
+.p-slate-700-color {
+  color: #273445;
+}
+
+.p-slate-900-color {
+  color: #0e141f;
+}
+
+.p-dark-color {
+  color: #333;
+}
+
+.p-dark-100-color {
+  color: #666;
+  /* hehe */
+}
+
+.p-dark-300-color {
+  color: #4d4d4d;
+}
+
+.p-dark-500-color {
+  color: #333;
+}
+
+.p-dark-700-color {
+  color: #1a1a1a;
+}
+
+.p-dark-900-color {
+  color: #000;
+}
+
+/* END OF COLORS */
+
+:root {
+  --primary-col:linear-gradient(to bottom, #4fc5fa 0%,#0f75f5 100%);
+  --primary-col-ac:#0f75f5;
+  --bg-color:#fff;
+  --bg-hover-color:#f9f9f9;
+  --bg-front-col:#000;
+  --invalid-color:#d6513c;
+  --valid-color:#94d63c;
+}
+
+.p-form-select {
+  border-radius: 5px;
+  display: inline-block;
+  font-family: -apple-system, "Inter", sans-serif;
+  margin: 10px;
+  position: relative;
+}
+
+.p-form-select::before {
+  border-color: #fff transparent transparent;
+  border-style: solid;
+  border-width: 5px;
+  content: "";
+  pointer-events: none;
+  position: absolute;
+  right: 5px;
+  top: calc(50% - 3px);
+  z-index: 3;
+}
+
+.p-form-select::after {
+  background: linear-gradient(to bottom, #4fc5fa 0%, #0f75f5 100%);
+  border-bottom-right-radius: 5px;
+  border-top-right-radius: 5px;
+  bottom: 0;
+  content: "";
+  display: block;
+  height: 100%;
+  pointer-events: none;
+  position: absolute;
+  right: 0;
+  top: 0;
+  width: 20px;
+}
+
+.p-form-select > select {
+  -webkit-appearance: none;
+  background: #fff;
+  border: 1px solid #cacaca;
+  border-radius: 5px;
+  font-size: 14px;
+  margin: 0;
+  outline: none;
+  padding: 5px 30px 5px 10px;
+  position: relative;
+  width: 100%;
+}
+
+.p-form-text:invalid,
+.p-form-text-alt:invalid,
+.p-form-select > select:invalid {
+  border-color: var(--invalid-color);
+}
+
+.p-form-text:valid,
+.p-form-text-alt:valid,
+.p-form-select > select:valid {
+  border-color: var(--valid-color);
+}
+
+.p-form-text:placeholder-shown,
+.p-form-text-alt:placeholder-shown,
+.p-form-select > select:placeholder-shown {
+  border-color: #cacaca;
+}
+
+.p-form-text {
+  -webkit-appearance: none;
+  box-shadow: none;
+  background: #fff;
+  border: 1px solid #cacaca;
+  border-radius: 5px;
+  font-family: -apple-system, "Inter", sans-serif;
+  margin: 10px;
+  outline: 0;
+  padding: 5px;
+  resize: none;
+  transition: border-color 200ms;
+}
+
+.p-form-text-alt {
+  -webkit-appearance: none;
+  box-shadow: none;
+  background: #fff;
+  border: 0px;
+  border-bottom: 2px solid #cacaca;
+  padding: 10px;
+  border-top-left-radius: 5px;
+  border-top-right-radius: 5px;
+  margin: 10px;
+}
+
+.p-form-text-alt::placeholder {
+  color: #cacaca;
+}
+
+.p-form-text-alt:focus {
+  outline: 3px solid #bed8f9;
+}
+
+.p-form-no-validate:valid,
+.p-form-no-validate:invalid,
+.p-form-no-validate > select:valid,
+.p-form-no-validate > select:invalid {
+  border-color: #cacaca;
+}
+
+.p-form-text:focus {
+  border-color: #0f75f5;
+}
+
+textarea.p-form-text {
+  -webkit-appearance: none;
+  height: 100px;
+}
+
+.p-form-truncated {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.p-form-text[type=password] {
+  font-family: caption;
+}
+
+.p-form-label,
+.p-form-radio-cont,
+.p-form-checkbox-cont {
+  font-family: -apple-system, "Inter", sans-serif;
+}
+
+.p-form-label {
+  display: block;
+}
+
+.p-form-radio-cont,
+.p-form-checkbox-cont {
+  align-items: center;
+  display: inline-flex;
+  margin: 0 10px;
+}
+
+.p-form-radio-cont > input + span,
+.p-form-checkbox-cont > input + span {
+  background: #fff;
+  border: 1px solid #cacaca;
+  border-radius: 50%;
+  cursor: pointer;
+  display: inline-block;
+  height: 20px;
+  margin-right: 5px;
+  position: relative;
+  transition: background 0.2s;
+  width: 20px;
+}
+
+.p-form-radio-cont > input + span:hover {
+  background: #f9f9f9;
+}
+
+.p-form-radio-cont > input,
+.p-form-checkbox-cont > input {
+  opacity: 0;
+  pointer-events: none;
+  position: absolute;
+}
+
+.p-form-radio-cont > input + span::after {
+  background: #fff;
+  border-radius: 50%;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);
+  content: "";
+  display: block;
+  height: 30%;
+  left: calc(50% - 15%);
+  opacity: 0;
+  position: absolute;
+  top: calc(50% - 15%);
+  transform: scale(2);
+  transition: opacity 0.2s, transform 0.3s;
+  width: 30%;
+}
+
+.p-form-radio-cont > input:checked + span {
+  background: #0f75f5;
+}
+
+.p-form-radio-cont > input:checked + span::after {
+  opacity: 1;
+  transform: scale(1);
+}
+
+.p-form-checkbox-cont > input + span {
+  border-radius: 5px;
+}
+
+.p-form-checkbox-cont > input:checked + span {
+  background: #0f75f5;
+}
+
+.p-form-checkbox-cont > input + span::before,
+.p-form-checkbox-cont > input + span::after {
+  background: #fff;
+  border-radius: 20px;
+  content: "";
+  display: block;
+  height: 8%;
+  position: absolute;
+}
+
+.p-form-checkbox-cont > input + span::before {
+  right: 30%;
+  top: 15%;
+  transform: rotate(-65deg);
+  transform-origin: top right;
+  width: 70%;
+}
+
+.p-form-checkbox-cont > input + span::after {
+  left: 30%;
+  top: 43%;
+  transform: rotate(60deg);
+  transform-origin: top left;
+  width: 40%;
+}
+
+.p-form-button {
+  -webkit-appearance: none;
+  background: #fff;
+  border: 1px solid #cacaca;
+  border-radius: 5px;
+  color: #333230;
+  display: inline-block;
+  font-size: 17px;
+  margin: 10px;
+  padding: 5px 20px;
+  text-decoration: none;
+  /* text-shadow: 0 1px 1px rgba(0, 0, 0, 0.25); */
+}
+
+.p-form-send {
+  background: linear-gradient(to bottom, #4fc5fa 0%, #0f75f5 100%);
+  border: 0;
+  color: #fff;
+}
+
+.p-form-send:active {
+  background: #0f75f5;
+}
+
+.p-form-invalid,
+.p-form-invalid:placeholder-shown,
+.p-form-invalid:valid,
+.p-form-invalid:invalid {
+  border-color: var(--invalid-color);
+}
+
+.p-form-valid,
+.p-form-valid:placeholder-shown,
+.p-form-valid:valid,
+.p-form-valid:invalid {
+  border-color: var(--valid-color);
+}
+
+.p-form-switch {
+  --width: 80px;
+  cursor: pointer;
+  display: inline-block;
+}
+
+.p-form-switch > input:checked + span::after {
+  left: calc(100% - calc(var(--width) / 2.1));
+}
+
+.p-form-switch > input:checked + span {
+  background: #60c35b;
+}
+
+.p-form-switch > span {
+  background: #e0e0e0;
+  border: 1px solid #d3d3d3;
+  border-radius: 500px;
+  display: block;
+  height: calc(var(--width) / 2);
+  overflow: hidden;
+  position: relative;
+  transition: all 0.2s;
+  width: var(--width);
+}
+
+.p-form-switch > span::after {
+  background: #f9f9f9;
+  border-radius: 50%;
+  box-shadow: 0px 3px 1px rgba(0, 0, 0, 0.1), 0px 1px 1px rgba(0, 0, 0, 0.16), 0px 3px 8px rgba(0, 0, 0, 0.15);
+  content: "";
+  height: 90%;
+  left: 3%;
+  position: absolute;
+  top: 4.5%;
+  transition: all 0.2s;
+  width: 45%;
+}
+
+.p-form-switch > input {
+  display: none;
+}
+
+input[type=range].p-form-range {
+  width: 100%;
+  margin: 11.5px 0;
+  background-color: transparent;
+  -webkit-appearance: none;
+}
+input[type=range].p-form-range:focus {
+  outline: none;
+}
+input[type=range].p-form-range::-webkit-slider-runnable-track {
+  background: #cacaca;
+  border: 0;
+  width: 100%;
+  height: 2px;
+  cursor: pointer;
+}
+input[type=range].p-form-range::-webkit-slider-thumb {
+  margin-top: -11.5px;
+  width: 25px;
+  height: 25px;
+  background: #ffffff;
+  border: 1px solid rgba(115, 115, 115, 0.6);
+  border-radius: 30px;
+  cursor: pointer;
+  box-shadow: 0 3px 1px rgba(0, 0, 0, 0.1), 0 1px 1px rgba(0, 0, 0, 0.16), 0 3px 8px rgba(0, 0, 0, 0.15);
+  -webkit-appearance: none;
+}
+input[type=range].p-form-range:focus::-webkit-slider-runnable-track {
+  background: #d7d7d7;
+}
+input[type=range].p-form-range::-moz-range-track {
+  background: #cacaca;
+  border: 0;
+  width: 100%;
+  height: 2px;
+  cursor: pointer;
+}
+input[type=range].p-form-range::-moz-range-thumb {
+  width: 25px;
+  height: 25px;
+  background: #ffffff;
+  border: 1px solid rgba(115, 115, 115, 0.6);
+  border-radius: 30px;
+  box-shadow: 0 3px 1px rgba(0, 0, 0, 0.1), 0 1px 1px rgba(0, 0, 0, 0.16), 0 3px 8px rgba(0, 0, 0, 0.15);
+  cursor: pointer;
+}
+input[type=range].p-form-range::-ms-track {
+  background: transparent;
+  border-color: transparent;
+  border-width: 26.5px 0;
+  color: transparent;
+  width: 100%;
+  height: 2px;
+  cursor: pointer;
+}
+input[type=range].p-form-range::-ms-fill-lower {
+  background: #bdbdbd;
+  border: 0;
+}
+input[type=range].p-form-range::-ms-fill-upper {
+  background: #cacaca;
+  border: 0;
+}
+input[type=range].p-form-range::-ms-thumb {
+  width: 25px;
+  height: 25px;
+  background: #ffffff;
+  border: 1px solid rgba(115, 115, 115, 0.6);
+  border-radius: 30px;
+  cursor: pointer;
+  box-shadow: 0 3px 1px rgba(0, 0, 0, 0.1), 0 1px 1px rgba(0, 0, 0, 0.16), 0 3px 8px rgba(0, 0, 0, 0.15);
+  margin-top: 0px;
+  /*Needed to keep the Edge thumb centred*/
+}
+input[type=range].p-form-range:focus::-ms-fill-lower {
+  background: #cacaca;
+}
+input[type=range].p-form-range:focus::-ms-fill-upper {
+  background: #d7d7d7;
+}
+/*TODO: Use one of the selectors from https://stackoverflow.com/a/20541859/7077589 and figure out
+how to remove the virtical space around the range input in IE*/
+@supports (-ms-ime-align:auto) {
+  /* Pre-Chromium Edge only styles, selector taken from hhttps://stackoverflow.com/a/32202953/7077589 */
+  input[type=range].p-form-range {
+    margin: 0;
+    /*Edge starts the margin from the thumb, not the track as other browsers do*/
+  }
+}
+
+
+/* END OF FORMS */
+
+.p-layout .p-large-title {
+  font-size: 2.75rem;
+}
+
+.p-layout h1 {
+  font-size: 2.25rem;
+}
+
+.p-layout h2 {
+  font-size: 1.75rem;
+}
+
+.p-layout h3 {
+  font-size: 1.58rem;
+}
+
+.p-layout .p-headline {
+  font-size: 1.34rem;
+  font-weight: bold;
+}
+
+.p-layout p {
+  font-size: 1.15rem;
+}
+
+.p-layout a,
+.p-layout input {
+  font-size: 1.14rem;
+}
+
+.p-layout .p-callout {
+  font-size: 1.14rem;
+}
+
+.p-layout .p-subhead {
+  font-size: 1.167rem;
+}
+
+.p-layout .p-footnote {
+  font-size: 1.07rem;
+}
+
+.p-layout .p-caption {
+  font-size: 0.91rem;
+}
+
+/* END OF LAYOUT */
+
+:root {
+  --font: -apple-system, "Inter", sans-serif;
+  --bg-hover-color: #f9f9f9;
+  --primary-col-ac: #0f75f5;
+}
+
+.p-modal-opened {
+  overflow: hidden;
+}
+
+.p-modal-background {
+  background: rgba(0, 0, 0, 0.3);
+  height: 100vh;
+  left: 0;
+  opacity: 0;
+  pointer-events: none;
+  position: fixed;
+  top: 0;
+  transition: all 0.3s;
+  width: 100vw;
+  z-index: 5;
+}
+
+.p-modal {
+  background: rgba(255, 255, 255, 0.85);
+  border-radius: 20px;
+  top: calc(50% - 20vh);
+  bottom: unset;
+  box-shadow: 0 10px 20px -15px;
+  font-family: var(--font);
+  left: calc(50% - 20vw);
+  opacity: 0;
+  overflow: hidden;
+  pointer-events: none;
+  position: fixed;
+  text-align: center;
+  transform: scale(1.5);
+  transition: opacity 0.3s, transform 0.3s;
+  width: 40vw;
+  z-index: 9;
+}
+
+.p-modal.active {
+  backdrop-filter: saturate(180%) blur(10px);
+  opacity: 1;
+  pointer-events: auto;
+  transform: scale(1);
+}
+
+.p-modal-button-container {
+  border-radius: 20px;
+  display: flex;
+}
+
+.p-modal-button-container > a {
+  border-top: 1px solid rgba(0, 0, 0, 0.1);
+  color: var(--primary-col-ac);
+  padding: 30px 0%;
+  text-decoration: none;
+  width: 100%;
+}
+
+.p-modal-button-container > a:nth-child(2),
+.p-modal-button-container > a:nth-child(3) {
+  border-left: 1px solid rgba(0, 0, 0, 0.1);
+}
+
+.nowactive {
+  opacity: 1;
+  pointer-events: auto;
+}
+
+.p-modal p {
+  padding: 0% 5%;
+}
+
+@supports not (backdrop-filter: blur(5px)) {
+  .p-modal {
+    background: #fff;
+  }
+}
+@media (max-width: 568px) {
+  .p-modal {
+    bottom: 20%;
+    left: 15%;
+    top: unset;
+    width: 70vw;
+  }
+
+  .p-modal p {
+    font-size: 15px;
+    padding: 0% 10%;
+  }
+
+  .p-modal-button-container {
+    display: block;
+  }
+
+  .p-modal-button-container > a {
+    border-left: 0 !important;
+    display: block;
+    padding: 2vh 0%;
+  }
+}
+
+/* END OF MODALS */
+
+.p-segmented-controls {
+  --color-segmented: #3689e6;
+  --color-lighter-segment: #d2e3f9;
+  background: #fff;
+  border: 1px solid var(--color-segmented);
+  border-radius: 5px;
+  display: flex;
+  flex-wrap: wrap;
+  font-family: -apple-system, "Inter", sans-serif;
+  margin-top: 10px;
+  overflow: hidden;
+  width: 100%;
+}
+.p-segmented-controls a {
+  color: var(--color-segmented);
+  flex: auto;
+  padding: 10px;
+  text-align: center;
+  text-decoration: none;
+  transition: all 0.5s;
+}
+.p-segmented-controls a.active {
+  background: var(--color-segmented);
+  color: #fff;
+}
+.p-segmented-controls a:not(:first-child) {
+  border-left: 1px solid currentColor;
+}
+
+.p-segmented-radius {
+  border-radius: 30px;
+}
+
+.p-segmented-internal-radius a,
+.p-segmented-internal-radius a:not(:first-child) {
+  border: 0;
+  border-radius: 30px;
+}
+
+.p-segmented-controls-alt a:not(:first-child) {
+  border: 0;
+}
+.p-segmented-controls-alt a:not(:first-child).active {
+  background: var(--color-lighter-segment);
+  color: var(--color-segmented);
+  font-weight: bold;
+}
+
+.p-segmented-outline {
+  border: 2px solid var(--color-segmented);
+}
+.p-segmented-outline a:not(:first-child) {
+  border-left: 2px solid var(--color-segmented);
+}
+
+.p-segmented-controls-outline-alt a:not(:first-child) {
+  border: 2px solid transparent;
+}
+
+.p-segmented-controls-outline-alt {
+  border-radius: 30px;
+}
+.p-segmented-controls-outline-alt a {
+  border: 2px solid transparent;
+  border-radius: 30px;
+}
+.p-segmented-controls-outline-alt a.active {
+  background: #fff;
+  border-color: var(--color-segmented);
+  border-radius: 30px;
+  color: var(--color-segmented);
+  font-weight: bold;
+}
+
+.p-segmented-grey {
+  --color-segmented: #555761;
+  --color-lighter-segment: #d4d4d4;
+}
+
+/* END OF SEGMENTED CONTROLS */
+
+.p-shadow-1 {
+  box-shadow: 0 3px 10px rgba(0, 0, 0, 0.1);
+}
+
+.p-shadow-2 {
+  box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+}
+
+.p-shadow-3 {
+  box-shadow: 0 10px 18px rgba(0, 0, 0, 0.3);
+}
+
+.p-shadow-4 {
+  box-shadow: 0 25px 30px rgba(0, 0, 0, 0.2);
+}
+
+.p-to-shadow-4,
+.p-to-shadow-3,
+.p-to-shadow-2,
+.p-to-shadow-1 {
+  transition-timing-function: ease;
+  transition: box-shadow 0.5s;
+}
+
+.p-to-shadow-1:hover {
+  box-shadow: 0 3px 10px rgba(0, 0, 0, 0.1);>
+}
+
+.p-to-shadow-2:hover {
+  box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+}
+
+.p-to-shadow-3:hover {
+  box-shadow: 0 10px 18px rgba(0, 0, 0, 0.3);
+}
+
+.p-to-shadow-4:hover {
+  box-shadow: 0 25px 30px rgba(0, 0, 0, 0.2);
+}
+
+
+/* END OF SHADOWS */
+
+.p-tabs-container {
+  background: #e3e3e3;
+  border: 1px solid #e0e0e0;
+  padding: 1em;
+}
+
+.p-tabs-container.p-light {
+  background: none;
+  border: none;
+}
+
+.p-tabs-container.p-light .p-panels {
+  margin-top: 0;
+  border-radius: 0;
+  padding: 0;
+}
+
+.p-tabs {
+  display: flex;
+  justify-content: center;
+}
+
+.p-tabs > :nth-of-type(1) {
+  border-radius: 5px 0 0 5px;
+}
+
+.p-tabs > :last-child {
+  border-radius: 0 5px 5px 0;
+}
+
+.p-tab {
+  margin: 0;
+  padding: 5px 35px;
+  background: #fff;
+  color: #333230;
+  text-decoration: none;
+  /* text-shadow: 0 1px 1px rgba(0, 0, 0, 0.25); */
+  border: 1px solid #cacaca;
+  display: inline-block;
+  font-size: 17px;
+  font-family: -apple-system, "Inter", sans-serif;
+  cursor: pointer;
+}
+
+.p-tab:focus {
+  outline: 0;
+}
+
+.p-is-active {
+  background: linear-gradient(to bottom, #4fc5fa 0%, #0f75f5 100%);
+  border: 0;
+  color: #fff;
+}
+
+.p-panels {
+  margin-top: 1em;
+  background: #fff;
+  border-radius: 3px;
+  position: relative;
+  padding: 0.8em;
+  overflow: hidden;
+}
+
+.p-panel.p-is-active {
+  opacity: 1;
+  pointer-events: all;
+  background: none;
+  color: inherit;
+  position: static;
+}
+
+.p-panel {
+  position: absolute;
+  opacity: 0;
+  pointer-events: none;
+}
+
+@media (max-width: 768px) {
+  .p-tabs {
+    overflow: auto;
+  }
+  .p-tab {
+    font-size: 0.8em;
+    padding: 5px 28px;
+  }
+  .p-tabs-container {
+    padding: 0.8em;
+  }
+
+  .p-panels {
+    padding: 0.8em;
+  }
+}
+
+@media screen and (max-width: 496px) {
+  .p-tab {
+    text-align: center;
+    padding: 5px 18px;
+  }
+  .p-tabs-container {
+    padding: 0.5em;
+  }
+
+  .p-panels {
+    padding: 0.5em;
+    margin-top: 0.5em;
+  }
+}
+
+@media screen and (max-width: 378px) {
+  .p-tab {
+    text-align: center;
+    padding: 5px 10px;
+  }
+  .p-tabs-container {
+    padding: 0.5em;
+  }
+
+  .p-panels {
+    padding: 0.5em;
+    margin-top: 0.5;
+  }
+}
+
+.p-mobile-tabs {
+  position: fixed;
+  bottom: 0;
+  left: 0;
+  width: 100%;
+  padding: 15px 0px;
+  border-top: 1px solid #949494;
+  background: rgba(202, 202, 202, 0.8);
+  backdrop-filter: blur(10px);
+  display: flex;
+  font-family: -apple-system, "Inter", sans-serif;
+}
+
+.p-mobile-tabs > div {
+  flex: auto;
+  text-align: center;
+}
+
+.p-mobile-tabs a {
+  text-decoration: none;
+  color: #555;
+  transition: color 0.5s;
+  display: inline-block;
+  font-size: 0.8rem;
+}
+
+.p-mobile-tabs a.active {
+  color: #0f75f5;
+  font-weight: 600;
+}
+
+.p-mobile-tabs svg {
+  display: block;
+  margin: auto;
+  margin-bottom: 0.2rem;
+}
+
+.p-mobile-tabs--content {
+  display: none;
+}
+
+.p-mobile-tabs--content.active {
+  display: block;
+}
+
+/* END OF TABS */
+
+
+.p-action-background{
+  background: rgba(0, 0, 0, 0.3);
+    height: 100vh;
+    left: 0;
+    opacity: 0;
+    pointer-events: none;
+    position: fixed;
+    top: 0;
+    transition: all 0.3s;
+    width: 100vw;
+    z-index: 5;
+}
+
+.p-action-background.nowactive {
+    opacity: 1;
+    pointer-events: auto;
+}
+
+
+.p-action-big-container{
+  position:fixed;
+  width: 100%;
+  box-sizing: border-box;
+  padding: 1rem 5vw;
+  bottom:0;
+}
+
+.p-action-container{
+  background: rgba(255, 255, 255, 0.8);
+  backdrop-filter: blur(10px);
+  display:block;
+  margin:auto;
+  margin-bottom: 10px;
+  border-radius: 10px;
+}
+
+.p-action-big-container .p-action-container:first-child{
+  margin-bottom:10px;
+}
+
+.p-action--intern{
+  display:block;
+  margin:auto;
+  text-align:center;
+  padding: 15px 0;
+  border-bottom: 1px solid #bfbfbf;
+  font-weight: 500;
+  color: #0f75f5;
+  text-decoration:none;
+}
+
+.p-action-destructive{
+  color: #c6262e;
+}
+
+.p-action-neutral{
+  color: #555761;
+}
+
+.p-action-cancel, .p-action-container a:last-child{
+  border-bottom:none;
+}
+
+.p-action-cancel{
+  font-weight:bold;
+}
+
+.p-action-icon{
+  position:relative;
+}
+.p-action-icon svg, .p-action-icon img{
+  position:absolute;
+  left:5%;
+  top:50%;
+  transform:translateY(-50%);
+}
+
+.p-action-icon-inline{
+  text-align: left;
+  display: flex;
+  align-items: center;
+}
+
+.p-action-icon-inline svg, .p-action-icon-inline img{
+  margin-left: 5%;
+  margin-right: 3%;
+}
+
+.p-action-title{
+  padding: 30px 15px;
+  border-bottom: 1px solid #bfbfbf;
+}
+
+.p-action-title--intern,.p-action-text{
+  margin:0;
+  color:#555761;
+}
+
+.p-action-title--intern{
+  margin-bottom: .3rem;
+}
+
+@supports not (backdrop-filter: blur(10px)) {
+  .p-action-container {
+    background: rgba(255,255,255,.95);
+  }
+}
+
+.p-action-big-container{
+  -webkit-transform: translateY(30%);
+            transform: translateY(30%);
+    opacity: 0;
+  transition: opacity 0.4s, transform 0.4s;
+  transition-timing-function: ease-in-out;
+}
+
+.p-action-big-container.active {
+-webkit-transform: translateY(0);
+            transform: translateY(0);
+    opacity: 1;
+}
+
+
+/* END OF ACTIONS */
diff --git a/v3/examples/android/frontend/public/style.css b/v3/examples/android/frontend/public/style.css
new file mode 100644
index 000000000..5bf3738a9
--- /dev/null
+++ b/v3/examples/android/frontend/public/style.css
@@ -0,0 +1,327 @@
+:root {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial,
+    sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+    font-size: 16px;
+    line-height: 24px;
+    font-weight: 400;
+    color-scheme: light dark;
+    /* Desktop defaults (mobile overrides below) */
+    --bg: #ffffff;
+    --fg: #213547;
+    font-synthesis: none;
+    text-rendering: optimizeLegibility;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+    -webkit-text-size-adjust: 100%;
+    user-select: none;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+}
+
+/* Mobile bottom tabs layout (works on all themes) */
+.mobile-pane {
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+  max-width: 520px;
+  height: 70vh; /* fixed-height main screen */
+  border-radius: 12px;
+}
+.mobile-pane .p-mobile-tabs-content {
+  position: relative;
+  flex: 1 1 auto;
+  overflow: hidden; /* contain panels */
+  display: flex;
+  flex-direction: column;
+}
+.p-mobile-tabs-content .p-mobile-tabs--content {
+  display: none;
+  overflow: auto; /* scroll inside content area */
+  -webkit-overflow-scrolling: touch;
+  padding: 8px 8px 16px;
+}
+.p-mobile-tabs-content .p-mobile-tabs--content.active { display: block; }
+
+*, *::before, *::after {
+    box-sizing: border-box;
+}
+
+/* Prefer system fonts on mobile; remove custom font to reduce bundle size */
+
+h3 {
+    font-size: 3em;
+    line-height: 1.1;
+}
+
+a {
+    font-weight: 500;
+    color: #646cff;
+    text-decoration: inherit;
+}
+
+a:hover {
+    color: #535bf2;
+}
+
+/* Remove generic button styling to allow Puppertino .btn to control buttons */
+
+.result {
+    height: 20px;
+    line-height: 20px;
+}
+
+html,
+body {
+    height: 100%;
+    width: 100%;
+    overflow-x: hidden; /* prevent horizontal overflow */
+    overflow-y: auto;   /* allow vertical scroll if needed */
+}
+
+body {
+    margin: 0;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    min-width: 320px;
+    /* Use small viewport units to avoid iOS Safari URL bar issues */
+    min-height: 100svh;
+    height: auto; /* avoid forcing overflow */
+    /* Equal responsive spacing top & bottom */
+    padding-block: clamp(8px, 4vh, 48px);
+    color: var(--fg);
+    background-color: var(--bg);
+}
+
+.container {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    /* Responsive spacing between elements */
+    gap: clamp(8px, 2vh, 24px);
+    width: 100%;
+    max-width: 480px;
+    padding-inline: 16px;
+}
+
+h1 {
+    /* Responsive heading size */
+    font-size: clamp(1.6rem, 6vw, 3.2rem);
+    line-height: 1.1;
+}
+
+#app {
+    max-width: 1280px;
+    margin: 0 auto;
+    /* Responsive inner padding: horizontal only, no extra top/bottom */
+    padding: 0 clamp(12px, 4vw, 32px);
+    text-align: center;
+}
+
+.logo {
+    /* Consistent visual size across images: fix height, auto width */
+    height: clamp(80px, 18vh, 140px);
+    width: auto;
+    max-width: 80vw;
+    padding: 0.5em;
+    will-change: filter;
+}
+
+.logo:hover {
+    filter: drop-shadow(0 0 2em #e80000aa);
+}
+
+.logo.vanilla:hover {
+    filter: drop-shadow(0 0 2em #f7df1eaa);
+}
+
+.result {
+    height: 20px;
+    line-height: 20px;
+    margin: 1.5rem auto;
+    text-align: center;
+}
+
+.footer {
+    margin-top: 1rem;
+    align-content: center;
+    text-align: center;
+}
+
+/* Tabs: default hide panels, show one matching the checked radio */
+.tabs .tabs-content .tab-panel { display: none; }
+.tabs input#tab-js:checked ~ .tabs-content [data-tab="tab-js"] { display: block; }
+.tabs input#tab-go:checked ~ .tabs-content [data-tab="tab-go"] { display: block; }
+
+/* Sticky tabs header */
+.tabs .tabs-header {
+    position: sticky;
+    top: env(safe-area-inset-top);
+    z-index: 5;
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 8px;
+    padding: 8px 0;
+    background: var(--bg);
+    backdrop-filter: saturate(1.2) blur(4px);
+}
+
+/* Subtle divider under sticky header */
+.tabs .tabs-header::after {
+    content: "";
+    grid-column: 1 / -1;
+    height: 1px;
+    background: rgba(0,0,0,0.08);
+    margin-top: 8px;
+}
+
+/* Mobile-specific light mode */
+@media (max-width: 768px) and (prefers-color-scheme: light) {
+    :root {
+        --fg: #213547;
+        --bg: #ffffff;
+    }
+
+    a:hover {
+        color: #747bff;
+    }
+
+    /* allow Puppertino to style .btn */
+
+    .input-box .input {
+        color: #111827;
+        background-color: #f3f4f6;
+        border: 1px solid #e5e7eb; /* show border in light mode */
+        border-radius: 8px;
+    }
+
+    button:hover {
+        border-color: #d1d5db; /* slate-300 */
+    }
+
+    .input-box .input:focus {
+        border-color: #9ca3af; /* gray-400 */
+        box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.15); /* subtle focus ring */
+    }
+}
+
+/* let Puppertino handle .btn hover */
+
+.input-box .input {
+    border: 1px solid transparent; /* default; themed in media queries */
+    border-radius: 8px;
+    outline: none;
+    height: 30px;
+    line-height: 30px;
+    padding: 0 10px;
+    color: black;
+    background-color: rgba(240, 240, 240, 1);
+    -webkit-font-smoothing: antialiased;
+}
+
+.input-box .input:hover {
+    background-color: rgba(255, 255, 255, 1);
+}
+
+.input-box .input:focus {
+    background-color: rgba(255, 255, 255, 1);
+    outline: 2px solid transparent;
+    outline-offset: 2px;
+}
+
+/* Mobile-specific dark mode */
+@media (max-width: 768px) and (prefers-color-scheme: dark) {
+    :root {
+        color: rgba(255, 255, 255, 0.88);
+        --fg: rgba(255, 255, 255, 0.88);
+        --bg: #0f1115; /* deep dark background */
+    }
+
+    a {
+        color: #8ea2ff;
+    }
+
+    a:hover {
+        color: #aab6ff;
+    }
+
+    /* allow Puppertino to style .btn in dark mode */
+
+    .input-box .input {
+        background-color: #111827; /* gray-900 */
+        color: #e5e7eb;
+        caret-color: #ffffff;
+        border: 1px solid #374151; /* slate-700 */
+    }
+
+    .input-box .input:hover,
+    .input-box .input:focus {
+        background-color: #0b1220;
+        border-color: #4b5563; /* slate-600 */
+    }
+
+    /* allow Puppertino to handle active state */
+}
+
+/* Mobile baseline overrides (apply to both light and dark) */
+@media (max-width: 768px) {
+  /* Prevent iOS zoom on focus */
+  input, textarea, select, button { font-size: 16px; }
+
+  /* Make layout vertical and scrollable */
+  html, body {
+    height: auto;
+    min-height: 100svh;
+    overflow-x: hidden;
+    overflow-y: auto;
+    -webkit-overflow-scrolling: touch;
+  }
+
+  body {
+    padding-top: env(safe-area-inset-top);
+    padding-bottom: env(safe-area-inset-bottom);
+    position: static;
+  }
+
+  .container {
+    width: 100%;
+    max-width: 520px; /* allow a bit wider on phones */
+    align-items: stretch;
+  }
+
+  /* Stack controls vertically with full-width tap targets */
+  .input-box {
+    display: flex;
+    flex-direction: column;
+    align-items: stretch;
+    gap: 10px;
+  }
+
+  .input-box .input,
+  .input,
+  button,
+  .p-btn {
+    width: 100%;
+    min-height: 44px; /* comfortable touch target */
+  }
+
+  /* Tabs vertical and full-width */
+  .tabs {
+    display: grid;
+    grid-template-columns: 1fr;
+    gap: 8px;
+  }
+  .tabs .p-btn { width: 100%; }
+
+  /* Cap device info height for readability */
+  #deviceInfo {
+    max-height: 30vh;
+    overflow: auto;
+    padding: 8px;
+    border-radius: 8px;
+    background: rgba(0,0,0,0.04);
+  }
+}
\ No newline at end of file
diff --git a/v3/examples/android/frontend/public/wails.png b/v3/examples/android/frontend/public/wails.png
new file mode 100644
index 000000000..8bdf42483
Binary files /dev/null and b/v3/examples/android/frontend/public/wails.png differ
diff --git a/v3/examples/android/frontend/vite.config.js b/v3/examples/android/frontend/vite.config.js
new file mode 100644
index 000000000..87b093bc3
--- /dev/null
+++ b/v3/examples/android/frontend/vite.config.js
@@ -0,0 +1,11 @@
+import { defineConfig } from 'vite';
+import path from 'path';
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      // Use the local repo runtime sources instead of the published package
+      '@wailsio/runtime': path.resolve(__dirname, '../../../internal/runtime/desktop/@wailsio/runtime/src/index.ts'),
+    },
+  },
+});
diff --git a/v3/examples/android/go.mod b/v3/examples/android/go.mod
new file mode 100644
index 000000000..97d41292a
--- /dev/null
+++ b/v3/examples/android/go.mod
@@ -0,0 +1,52 @@
+module changeme
+
+go 1.24.0
+
+toolchain go1.24.6
+
+require github.com/wailsapp/wails/v3 v3.0.0-dev
+
+require (
+	dario.cat/mergo v1.0.1 // indirect
+	github.com/Microsoft/go-winio v0.6.2 // indirect
+	github.com/ProtonMail/go-crypto v1.1.6 // indirect
+	github.com/adrg/xdg v0.5.3 // indirect
+	github.com/bep/debounce v1.2.1 // indirect
+	github.com/cloudflare/circl v1.6.0 // indirect
+	github.com/cyphar/filepath-securejoin v0.4.1 // indirect
+	github.com/ebitengine/purego v0.8.2 // indirect
+	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
+	github.com/go-git/go-billy/v5 v5.6.2 // indirect
+	github.com/go-git/go-git/v5 v5.13.2 // indirect
+	github.com/go-ole/go-ole v1.3.0 // indirect
+	github.com/godbus/dbus/v5 v5.1.0 // indirect
+	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
+	github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e // indirect
+	github.com/kevinburke/ssh_config v1.2.0 // indirect
+	github.com/leaanthony/go-ansi-parser v1.6.1 // indirect
+	github.com/leaanthony/u v1.1.1 // indirect
+	github.com/lmittmann/tint v1.0.7 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/pjbgf/sha1cd v0.3.2 // indirect
+	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/samber/lo v1.49.1 // indirect
+	github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect
+	github.com/skeema/knownhosts v1.3.1 // indirect
+	github.com/wailsapp/go-webview2 v1.0.21 // indirect
+	github.com/wailsapp/mimetype v1.4.1 // indirect
+	github.com/xanzy/ssh-agent v0.3.3 // indirect
+	golang.org/x/crypto v0.36.0 // indirect
+	golang.org/x/net v0.37.0 // indirect
+	golang.org/x/sys v0.31.0 // indirect
+	golang.org/x/text v0.23.0 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+	gopkg.in/warnings.v0 v0.1.2 // indirect
+)
+
+replace github.com/wailsapp/wails/v3 => ../../
diff --git a/v3/examples/android/go.sum b/v3/examples/android/go.sum
new file mode 100644
index 000000000..cbadfe003
--- /dev/null
+++ b/v3/examples/android/go.sum
@@ -0,0 +1,146 @@
+dario.cat/mergo v1.0.1 h1:Ra4+bf83h2ztPIQYNP99R6m+Y7KfnARDfID+a+vLl4s=
+dario.cat/mergo v1.0.1/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
+github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=
+github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
+github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
+github.com/ProtonMail/go-crypto v1.1.6 h1:ZcV+Ropw6Qn0AX9brlQLAUXfqLBc7Bl+f/DmNxpLfdw=
+github.com/ProtonMail/go-crypto v1.1.6/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
+github.com/adrg/xdg v0.5.3 h1:xRnxJXne7+oWDatRhR1JLnvuccuIeCoBu2rtuLqQB78=
+github.com/adrg/xdg v0.5.3/go.mod h1:nlTsY+NNiCBGCK2tpm09vRqfVzrc2fLmXGpBLF0zlTQ=
+github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
+github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
+github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
+github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
+github.com/bep/debounce v1.2.1 h1:v67fRdBA9UQu2NhLFXrSg0Brw7CexQekrBwDMM8bzeY=
+github.com/bep/debounce v1.2.1/go.mod h1:H8yggRPQKLUhUoqrJC1bO2xNya7vanpDl7xR3ISbCJ0=
+github.com/cloudflare/circl v1.6.0 h1:cr5JKic4HI+LkINy2lg3W2jF8sHCVTBncJr5gIIq7qk=
+github.com/cloudflare/circl v1.6.0/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs=
+github.com/cyphar/filepath-securejoin v0.4.1 h1:JyxxyPEaktOD+GAnqIqTf9A8tHyAG22rowi7HkoSU1s=
+github.com/cyphar/filepath-securejoin v0.4.1/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/ebitengine/purego v0.8.2 h1:jPPGWs2sZ1UgOSgD2bClL0MJIqu58nOmIcBuXr62z1I=
+github.com/ebitengine/purego v0.8.2/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
+github.com/elazarl/goproxy v1.4.0 h1:4GyuSbFa+s26+3rmYNSuUVsx+HgPrV1bk1jXI0l9wjM=
+github.com/elazarl/goproxy v1.4.0/go.mod h1:X/5W/t+gzDyLfHW4DrMdpjqYjpXsURlBt9lpBDxZZZQ=
+github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
+github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
+github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
+github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI=
+github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=
+github.com/go-git/go-billy/v5 v5.6.2 h1:6Q86EsPXMa7c3YZ3aLAQsMA0VlWmy43r6FHqa/UNbRM=
+github.com/go-git/go-billy/v5 v5.6.2/go.mod h1:rcFC2rAsp/erv7CMz9GczHcuD0D32fWzH+MJAU+jaUU=
+github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4=
+github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII=
+github.com/go-git/go-git/v5 v5.13.2 h1:7O7xvsK7K+rZPKW6AQR1YyNhfywkv7B8/FsP3ki6Zv0=
+github.com/go-git/go-git/v5 v5.13.2/go.mod h1:hWdW5P4YZRjmpGHwRH2v3zkWcNl6HeXaXQEMGb3NJ9A=
+github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
+github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
+github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk=
+github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
+github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
+github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e h1:Q3+PugElBCf4PFpxhErSzU3/PY5sFL5Z6rfv4AbGAck=
+github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e/go.mod h1:alcuEEnZsY1WQsagKhZDsoPCRoOijYqhZvPwLG0kzVs=
+github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4=
+github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/leaanthony/go-ansi-parser v1.6.1 h1:xd8bzARK3dErqkPFtoF9F3/HgN8UQk0ed1YDKpEz01A=
+github.com/leaanthony/go-ansi-parser v1.6.1/go.mod h1:+vva/2y4alzVmmIEpk9QDhA7vLC5zKDTRwfZGOp3IWU=
+github.com/leaanthony/u v1.1.1 h1:TUFjwDGlNX+WuwVEzDqQwC2lOv0P4uhTQw7CMFdiK7M=
+github.com/leaanthony/u v1.1.1/go.mod h1:9+o6hejoRljvZ3BzdYlVL0JYCwtnAsVuN9pVTQcaRfI=
+github.com/lmittmann/tint v1.0.7 h1:D/0OqWZ0YOGZ6AyC+5Y2kD8PBEzBk6rFHVSfOqCkF9Y=
+github.com/lmittmann/tint v1.0.7/go.mod h1:HIS3gSy7qNwGCj+5oRjAutErFBl4BzdQP6cJZ0NfMwE=
+github.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU=
+github.com/matryer/is v1.4.1 h1:55ehd8zaGABKLXQUe2awZ99BD/PTc2ls+KV/dXphgEQ=
+github.com/matryer/is v1.4.1/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=
+github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=
+github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4=
+github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A=
+github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
+github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
+github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
+github.com/samber/lo v1.49.1 h1:4BIFyVfuQSEpluc7Fua+j1NolZHiEHEpaSEKdsH0tew=
+github.com/samber/lo v1.49.1/go.mod h1:dO6KHFzUKXgP8LDhU0oI8d2hekjXnGOu0DB8Jecxd6o=
+github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8=
+github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
+github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
+github.com/skeema/knownhosts v1.3.1 h1:X2osQ+RAjK76shCbvhHHHVl3ZlgDm8apHEHFqRjnBY8=
+github.com/skeema/knownhosts v1.3.1/go.mod h1:r7KTdC8l4uxWRyK2TpQZ/1o5HaSzh06ePQNxPwTcfiY=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/wailsapp/go-webview2 v1.0.21 h1:k3dtoZU4KCoN/AEIbWiPln3P2661GtA2oEgA2Pb+maA=
+github.com/wailsapp/go-webview2 v1.0.21/go.mod h1:qJmWAmAmaniuKGZPWwne+uor3AHMB5PFhqiK0Bbj8kc=
+github.com/wailsapp/mimetype v1.4.1 h1:pQN9ycO7uo4vsUUuPeHEYoUkLVkaRntMnHJxVwYhwHs=
+github.com/wailsapp/mimetype v1.4.1/go.mod h1:9aV5k31bBOv5z6u+QP8TltzvNGJPmNJD4XlAL3U+j3o=
+github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
+github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=
+golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
+golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
+golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac h1:l5+whBCLH3iH2ZNHYLbAe58bo7yrN4mVcnkHDYz5vvs=
+golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac/go.mod h1:hH+7mtFmImwwcMvScyxUhjuVHR3HGaDPMn9rMSUUbxo=
+golang.org/x/net v0.0.0-20210505024714-0287a6fb4125/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.37.0 h1:1zLorHbz+LYj7MQlSf1+2tPIIgibq2eL5xkrGk6f+2c=
+golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200810151505-1b9f1253b3ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y=
+golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
+golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
+gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
+gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/v3/examples/android/greetservice.go b/v3/examples/android/greetservice.go
new file mode 100644
index 000000000..8972c39cd
--- /dev/null
+++ b/v3/examples/android/greetservice.go
@@ -0,0 +1,7 @@
+package main
+
+type GreetService struct{}
+
+func (g *GreetService) Greet(name string) string {
+	return "Hello " + name + "!"
+}
diff --git a/v3/examples/android/main.go b/v3/examples/android/main.go
new file mode 100644
index 000000000..ba20103da
--- /dev/null
+++ b/v3/examples/android/main.go
@@ -0,0 +1,73 @@
+package main
+
+import (
+	"embed"
+	_ "embed"
+	"log"
+	"time"
+
+	"github.com/wailsapp/wails/v3/pkg/application"
+)
+
+// Wails uses Go's `embed` package to embed the frontend files into the binary.
+// Any files in the frontend/dist folder will be embedded into the binary and
+// made available to the frontend.
+// See https://pkg.go.dev/embed for more information.
+
+//go:embed all:frontend/dist
+var assets embed.FS
+
+// main function serves as the application's entry point. It initializes the application, creates a window,
+// and starts a goroutine that emits a time-based event every second. It subsequently runs the application and
+// logs any error that might occur.
+func main() {
+
+	// Create a new Wails application by providing the necessary options.
+	// Variables 'Name' and 'Description' are for application metadata.
+	// 'Assets' configures the asset server with the 'FS' variable pointing to the frontend files.
+	// 'Bind' is a list of Go struct instances. The frontend has access to the methods of these instances.
+	app := application.New(application.Options{
+		Name:        "android",
+		Description: "A demo of using raw HTML & CSS",
+		Services: []application.Service{
+			application.NewService(&GreetService{}),
+		},
+		Assets: application.AssetOptions{
+			Handler: application.AssetFileServerFS(assets),
+		},
+		Mac: application.MacOptions{
+			ApplicationShouldTerminateAfterLastWindowClosed: true,
+		},
+		Android: application.AndroidOptions{
+			// Android-specific options will go here
+		},
+	})
+
+	// Create a new window with the necessary options.
+	// 'Title' is the title of the window.
+	// 'BackgroundColour' is the background colour of the window.
+	// 'URL' is the URL that will be loaded into the webview.
+	app.Window.NewWithOptions(application.WebviewWindowOptions{
+		Title:            "Window 1",
+		BackgroundColour: application.NewRGB(27, 38, 54),
+		URL:              "/",
+	})
+
+	// Create a goroutine that emits an event containing the current time every second.
+	// The frontend can listen to this event and update the UI accordingly.
+	go func() {
+		for {
+			now := time.Now().Format(time.RFC1123)
+			app.Event.Emit("time", now)
+			time.Sleep(time.Second)
+		}
+	}()
+
+	// Run the application. This blocks until the application has been exited.
+	err := app.Run()
+
+	// If an error occurred while running the application, log it and exit.
+	if err != nil {
+		log.Fatal(err)
+	}
+}
diff --git a/v3/examples/android/main_android.go b/v3/examples/android/main_android.go
new file mode 100644
index 000000000..70a716473
--- /dev/null
+++ b/v3/examples/android/main_android.go
@@ -0,0 +1,11 @@
+//go:build android
+
+package main
+
+import "github.com/wailsapp/wails/v3/pkg/application"
+
+func init() {
+	// Register main function to be called when the Android app initializes
+	// This is necessary because in c-shared build mode, main() is not automatically called
+	application.RegisterAndroidMain(main)
+}
diff --git a/v3/internal/assetserver/assetserver_android.go b/v3/internal/assetserver/assetserver_android.go
new file mode 100644
index 000000000..ce616f47e
--- /dev/null
+++ b/v3/internal/assetserver/assetserver_android.go
@@ -0,0 +1,12 @@
+//go:build android
+
+package assetserver
+
+import "net/url"
+
+// Android uses https://wails.localhost as the base URL
+// This matches the WebViewAssetLoader domain configuration
+var baseURL = url.URL{
+	Scheme: "https",
+	Host:   "wails.localhost",
+}
diff --git a/v3/internal/assetserver/assetserver_linux.go b/v3/internal/assetserver/assetserver_linux.go
index faab164a4..ed579fad7 100644
--- a/v3/internal/assetserver/assetserver_linux.go
+++ b/v3/internal/assetserver/assetserver_linux.go
@@ -1,3 +1,5 @@
+//go:build linux && !android
+
 package assetserver
 
 import "net/url"
diff --git a/v3/internal/assetserver/bundledassets/runtime.debug.js b/v3/internal/assetserver/bundledassets/runtime.debug.js
index 3e9ec0d16..55f626249 100644
--- a/v3/internal/assetserver/bundledassets/runtime.debug.js
+++ b/v3/internal/assetserver/bundledassets/runtime.debug.js
@@ -36,6 +36,7 @@ __export(index_exports, {
   Dialogs: () => dialogs_exports,
   Events: () => events_exports,
   Flags: () => flags_exports,
+  IOS: () => ios_exports,
   Screens: () => screens_exports,
   System: () => system_exports,
   WML: () => wml_exports,
@@ -79,7 +80,8 @@ var objectNames = Object.freeze({
   Screens: 7,
   System: 8,
   Browser: 9,
-  CancelCall: 10
+  CancelCall: 10,
+  IOS: 11
 });
 var clientId = nanoid();
 function newRuntimeCaller(object, windowName = "") {
@@ -438,6 +440,30 @@ var Types = Object.freeze({
     WindowFocusOut: "linux:WindowFocusOut",
     WindowLoadChanged: "linux:WindowLoadChanged"
   }),
+  iOS: Object.freeze({
+    ApplicationDidBecomeActive: "ios:ApplicationDidBecomeActive",
+    ApplicationDidEnterBackground: "ios:ApplicationDidEnterBackground",
+    ApplicationDidFinishLaunching: "ios:ApplicationDidFinishLaunching",
+    ApplicationDidReceiveMemoryWarning: "ios:ApplicationDidReceiveMemoryWarning",
+    ApplicationWillEnterForeground: "ios:ApplicationWillEnterForeground",
+    ApplicationWillResignActive: "ios:ApplicationWillResignActive",
+    ApplicationWillTerminate: "ios:ApplicationWillTerminate",
+    WindowDidLoad: "ios:WindowDidLoad",
+    WindowWillAppear: "ios:WindowWillAppear",
+    WindowDidAppear: "ios:WindowDidAppear",
+    WindowWillDisappear: "ios:WindowWillDisappear",
+    WindowDidDisappear: "ios:WindowDidDisappear",
+    WindowSafeAreaInsetsChanged: "ios:WindowSafeAreaInsetsChanged",
+    WindowOrientationChanged: "ios:WindowOrientationChanged",
+    WindowTouchBegan: "ios:WindowTouchBegan",
+    WindowTouchMoved: "ios:WindowTouchMoved",
+    WindowTouchEnded: "ios:WindowTouchEnded",
+    WindowTouchCancelled: "ios:WindowTouchCancelled",
+    WebViewDidStartNavigation: "ios:WebViewDidStartNavigation",
+    WebViewDidFinishNavigation: "ios:WebViewDidFinishNavigation",
+    WebViewDidFailNavigation: "ios:WebViewDidFailNavigation",
+    WebViewDecidePolicyForNavigationAction: "ios:WebViewDecidePolicyForNavigationAction"
+  }),
   Common: Object.freeze({
     ApplicationOpenedWithFile: "common:ApplicationOpenedWithFile",
     ApplicationStarted: "common:ApplicationStarted",
@@ -627,7 +653,8 @@ var ZoomMethod = 45;
 var ZoomInMethod = 46;
 var ZoomOutMethod = 47;
 var ZoomResetMethod = 48;
-var WindowDropZoneDropped = 49;
+var SnapAssistMethod = 49;
+var WindowDropZoneDropped = 50;
 function getDropzoneElement(element) {
   if (!element) {
     return null;
@@ -1045,6 +1072,12 @@ var _Window = class _Window {
     };
     this[callerSym](WindowDropZoneDropped, payload);
   }
+  /* Triggers Windows 11 Snap Assist feature (Windows only).
+   * This is equivalent to pressing Win+Z and shows snap layout options.
+   */
+  SnapAssist() {
+    return this[callerSym](SnapAssistMethod);
+  }
 };
 var Window = _Window;
 var thisWindow = new Window("");
@@ -1112,7 +1145,7 @@ var window_default = thisWindow;
 
 // desktop/@wailsio/runtime/src/wml.ts
 function sendEvent(eventName, data = null) {
-  Emit(new WailsEvent(eventName, data));
+  Emit(eventName, data);
 }
 function callWindowMethod(windowName, methodName) {
   const targetWindow = window_default.Get(windowName);
@@ -1270,13 +1303,15 @@ var call4 = newRuntimeCaller(objectNames.System);
 var SystemIsDarkMode = 0;
 var SystemEnvironment = 1;
 var ApplicationFilesDroppedWithContext = 100;
-var _invoke = function() {
-  var _a2, _b, _c, _d, _e;
+var _invoke = (function() {
+  var _a2, _b, _c, _d, _e, _f;
   try {
     if ((_b = (_a2 = window.chrome) == null ? void 0 : _a2.webview) == null ? void 0 : _b.postMessage) {
       return window.chrome.webview.postMessage.bind(window.chrome.webview);
     } else if ((_e = (_d = (_c = window.webkit) == null ? void 0 : _c.messageHandlers) == null ? void 0 : _d["external"]) == null ? void 0 : _e.postMessage) {
       return window.webkit.messageHandlers["external"].postMessage.bind(window.webkit.messageHandlers["external"]);
+    } else if ((_f = window.wails) == null ? void 0 : _f.invoke) {
+      return (msg) => window.wails.invoke(typeof msg === "string" ? msg : JSON.stringify(msg));
     }
   } catch (e) {
   }
@@ -1287,7 +1322,7 @@ var _invoke = function() {
     "color: #ffffff; font-style: italic; font-weight: bold;"
   );
   return null;
-}();
+})();
 function invoke(msg) {
   _invoke == null ? void 0 : _invoke(msg);
 }
@@ -1306,25 +1341,32 @@ function Environment() {
   return call4(SystemEnvironment);
 }
 function IsWindows() {
-  return window._wails.environment.OS === "windows";
+  var _a2, _b;
+  return ((_b = (_a2 = window._wails) == null ? void 0 : _a2.environment) == null ? void 0 : _b.OS) === "windows";
 }
 function IsLinux() {
-  return window._wails.environment.OS === "linux";
+  var _a2, _b;
+  return ((_b = (_a2 = window._wails) == null ? void 0 : _a2.environment) == null ? void 0 : _b.OS) === "linux";
 }
 function IsMac() {
-  return window._wails.environment.OS === "darwin";
+  var _a2, _b;
+  return ((_b = (_a2 = window._wails) == null ? void 0 : _a2.environment) == null ? void 0 : _b.OS) === "darwin";
 }
 function IsAMD64() {
-  return window._wails.environment.Arch === "amd64";
+  var _a2, _b;
+  return ((_b = (_a2 = window._wails) == null ? void 0 : _a2.environment) == null ? void 0 : _b.Arch) === "amd64";
 }
 function IsARM() {
-  return window._wails.environment.Arch === "arm";
+  var _a2, _b;
+  return ((_b = (_a2 = window._wails) == null ? void 0 : _a2.environment) == null ? void 0 : _b.Arch) === "arm";
 }
 function IsARM64() {
-  return window._wails.environment.Arch === "arm64";
+  var _a2, _b;
+  return ((_b = (_a2 = window._wails) == null ? void 0 : _a2.environment) == null ? void 0 : _b.Arch) === "arm64";
 }
 function IsDebug() {
-  return Boolean(window._wails.environment.Debug);
+  var _a2, _b;
+  return Boolean((_b = (_a2 = window._wails) == null ? void 0 : _a2.environment) == null ? void 0 : _b.Debug);
 }
 function HandlePlatformFileDrop(filenames, x, y) {
   const element = document.elementFromPoint(x, y);
@@ -1429,12 +1471,38 @@ window._wails.setResizable = (value) => {
     setResize();
   }
 };
-window.addEventListener("mousedown", update, { capture: true });
-window.addEventListener("mousemove", update, { capture: true });
-window.addEventListener("mouseup", update, { capture: true });
-for (const ev of ["click", "contextmenu", "dblclick"]) {
-  window.addEventListener(ev, suppressEvent, { capture: true });
+var dragInitDone = false;
+function isMobile() {
+  var _a2, _b;
+  const os = (_b = (_a2 = window._wails) == null ? void 0 : _a2.environment) == null ? void 0 : _b.OS;
+  if (os === "ios" || os === "android") return true;
+  const ua = navigator.userAgent || navigator.vendor || window.opera || "";
+  return /android|iphone|ipad|ipod|iemobile|wpdesktop/i.test(ua);
 }
+function tryInitDragHandlers() {
+  if (dragInitDone) return;
+  if (isMobile()) return;
+  window.addEventListener("mousedown", update, { capture: true });
+  window.addEventListener("mousemove", update, { capture: true });
+  window.addEventListener("mouseup", update, { capture: true });
+  for (const ev of ["click", "contextmenu", "dblclick"]) {
+    window.addEventListener(ev, suppressEvent, { capture: true });
+  }
+  dragInitDone = true;
+}
+tryInitDragHandlers();
+document.addEventListener("DOMContentLoaded", tryInitDragHandlers, { once: true });
+var dragEnvPolls = 0;
+var dragEnvPoll = window.setInterval(() => {
+  if (dragInitDone) {
+    window.clearInterval(dragEnvPoll);
+    return;
+  }
+  tryInitDragHandlers();
+  if (++dragEnvPolls > 100) {
+    window.clearInterval(dragEnvPoll);
+  }
+}, 50);
 function suppressEvent(event) {
   if (dragging || resizing) {
     event.stopImmediatePropagation();
@@ -2627,6 +2695,30 @@ function GetCurrent() {
   return call9(getCurrent);
 }
 
+// desktop/@wailsio/runtime/src/ios.ts
+var ios_exports = {};
+__export(ios_exports, {
+  Device: () => Device,
+  Haptics: () => Haptics
+});
+var call10 = newRuntimeCaller(objectNames.IOS);
+var HapticsImpact = 0;
+var DeviceInfo = 1;
+var Haptics;
+((Haptics2) => {
+  function Impact(style = "medium") {
+    return call10(HapticsImpact, { style });
+  }
+  Haptics2.Impact = Impact;
+})(Haptics || (Haptics = {}));
+var Device;
+((Device2) => {
+  function Info2() {
+    return call10(DeviceInfo);
+  }
+  Device2.Info = Info2;
+})(Device || (Device = {}));
+
 // desktop/@wailsio/runtime/src/index.ts
 window._wails = window._wails || {};
 window._wails.invoke = invoke;
@@ -2643,9 +2735,10 @@ export {
   dialogs_exports as Dialogs,
   events_exports as Events,
   flags_exports as Flags,
+  ios_exports as IOS,
   screens_exports as Screens,
   system_exports as System,
   wml_exports as WML,
   window_default as Window
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../runtime/desktop/@wailsio/runtime/src/index.ts", "../../runtime/desktop/@wailsio/runtime/src/wml.ts", "../../runtime/desktop/@wailsio/runtime/src/browser.ts", "../../runtime/desktop/@wailsio/runtime/src/nanoid.ts", "../../runtime/desktop/@wailsio/runtime/src/runtime.ts", "../../runtime/desktop/@wailsio/runtime/src/dialogs.ts", "../../runtime/desktop/@wailsio/runtime/src/events.ts", "../../runtime/desktop/@wailsio/runtime/src/listener.ts", "../../runtime/desktop/@wailsio/runtime/src/event_types.ts", "../../runtime/desktop/@wailsio/runtime/src/utils.ts", "../../runtime/desktop/@wailsio/runtime/src/window.ts", "../../runtime/desktop/compiled/main.js", "../../runtime/desktop/@wailsio/runtime/src/system.ts", "../../runtime/desktop/@wailsio/runtime/src/contextmenu.ts", "../../runtime/desktop/@wailsio/runtime/src/flags.ts", "../../runtime/desktop/@wailsio/runtime/src/drag.ts", "../../runtime/desktop/@wailsio/runtime/src/application.ts", "../../runtime/desktop/@wailsio/runtime/src/calls.ts", "../../runtime/desktop/@wailsio/runtime/src/callable.ts", "../../runtime/desktop/@wailsio/runtime/src/cancellable.ts", "../../runtime/desktop/@wailsio/runtime/src/clipboard.ts", "../../runtime/desktop/@wailsio/runtime/src/create.ts", "../../runtime/desktop/@wailsio/runtime/src/screens.ts"],
  "sourcesContent": ["/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n// Setup\r\nwindow._wails = window._wails || {};\r\n\r\nimport \"./contextmenu.js\";\r\nimport \"./drag.js\";\r\n\r\n// Re-export public API\r\nimport * as Application from \"./application.js\";\r\nimport * as Browser from \"./browser.js\";\r\nimport * as Call from \"./calls.js\";\r\nimport * as Clipboard from \"./clipboard.js\";\r\nimport * as Create from \"./create.js\";\r\nimport * as Dialogs from \"./dialogs.js\";\r\nimport * as Events from \"./events.js\";\r\nimport * as Flags from \"./flags.js\";\r\nimport * as Screens from \"./screens.js\";\r\nimport * as System from \"./system.js\";\r\nimport Window from \"./window.js\";\r\nimport * as WML from \"./wml.js\";\r\n\r\nexport {\r\n    Application,\r\n    Browser,\r\n    Call,\r\n    Clipboard,\r\n    Dialogs,\r\n    Events,\r\n    Flags,\r\n    Screens,\r\n    System,\r\n    Window,\r\n    WML\r\n};\r\n\r\n/**\r\n * An internal utility consumed by the binding generator.\r\n *\r\n * @ignore\r\n * @internal\r\n */\r\nexport { Create };\r\n\r\nexport * from \"./cancellable.js\";\r\n\r\n// Notify backend\r\nwindow._wails.invoke = System.invoke;\r\nSystem.invoke(\"wails:runtime:ready\");\r\n", "/*\r\n _     __     _ __\r\n| |  / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\nimport { OpenURL } from \"./browser.js\";\r\nimport { Question } from \"./dialogs.js\";\r\nimport { Emit, WailsEvent } from \"./events.js\";\r\nimport { canAbortListeners, whenReady } from \"./utils.js\";\r\nimport Window from \"./window.js\";\r\n\r\n/**\r\n * Sends an event with the given name and optional data.\r\n *\r\n * @param eventName - - The name of the event to send.\r\n * @param [data=null] - - Optional data to send along with the event.\r\n */\r\nfunction sendEvent(eventName: string, data: any = null): void {\r\n    Emit(new WailsEvent(eventName, data));\r\n}\r\n\r\n/**\r\n * Calls a method on a specified window.\r\n *\r\n * @param windowName - The name of the window to call the method on.\r\n * @param methodName - The name of the method to call.\r\n */\r\nfunction callWindowMethod(windowName: string, methodName: string) {\r\n    const targetWindow = Window.Get(windowName);\r\n    const method = (targetWindow as any)[methodName];\r\n\r\n    if (typeof method !== \"function\") {\r\n        console.error(`Window method '${methodName}' not found`);\r\n        return;\r\n    }\r\n\r\n    try {\r\n        method.call(targetWindow);\r\n    } catch (e) {\r\n        console.error(`Error calling window method '${methodName}': `, e);\r\n    }\r\n}\r\n\r\n/**\r\n * Responds to a triggering event by running appropriate WML actions for the current target.\r\n */\r\nfunction onWMLTriggered(ev: Event): void {\r\n    const element = ev.currentTarget as Element;\r\n\r\n    function runEffect(choice = \"Yes\") {\r\n        if (choice !== \"Yes\")\r\n            return;\r\n\r\n        const eventType = element.getAttribute('wml-event') || element.getAttribute('data-wml-event');\r\n        const targetWindow = element.getAttribute('wml-target-window') || element.getAttribute('data-wml-target-window') || \"\";\r\n        const windowMethod = element.getAttribute('wml-window') || element.getAttribute('data-wml-window');\r\n        const url = element.getAttribute('wml-openurl') || element.getAttribute('data-wml-openurl');\r\n\r\n        if (eventType !== null)\r\n            sendEvent(eventType);\r\n        if (windowMethod !== null)\r\n            callWindowMethod(targetWindow, windowMethod);\r\n        if (url !== null)\r\n            void OpenURL(url);\r\n    }\r\n\r\n    const confirm = element.getAttribute('wml-confirm') || element.getAttribute('data-wml-confirm');\r\n\r\n    if (confirm) {\r\n        Question({\r\n            Title: \"Confirm\",\r\n            Message: confirm,\r\n            Detached: false,\r\n            Buttons: [\r\n                { Label: \"Yes\" },\r\n                { Label: \"No\", IsDefault: true }\r\n            ]\r\n        }).then(runEffect);\r\n    } else {\r\n        runEffect();\r\n    }\r\n}\r\n\r\n// Private field names.\r\nconst controllerSym = Symbol(\"controller\");\r\nconst triggerMapSym = Symbol(\"triggerMap\");\r\nconst elementCountSym = Symbol(\"elementCount\");\r\n\r\n/**\r\n * AbortControllerRegistry does not actually remember active event listeners: instead\r\n * it ties them to an AbortSignal and uses an AbortController to remove them all at once.\r\n */\r\nclass AbortControllerRegistry {\r\n    // Private fields.\r\n    [controllerSym]: AbortController;\r\n\r\n    constructor() {\r\n        this[controllerSym] = new AbortController();\r\n    }\r\n\r\n    /**\r\n     * Returns an options object for addEventListener that ties the listener\r\n     * to the AbortSignal from the current AbortController.\r\n     *\r\n     * @param element - An HTML element\r\n     * @param triggers - The list of active WML trigger events for the specified elements\r\n     */\r\n    set(element: Element, triggers: string[]): AddEventListenerOptions {\r\n        return { signal: this[controllerSym].signal };\r\n    }\r\n\r\n    /**\r\n     * Removes all registered event listeners and resets the registry.\r\n     */\r\n    reset(): void {\r\n        this[controllerSym].abort();\r\n        this[controllerSym] = new AbortController();\r\n    }\r\n}\r\n\r\n/**\r\n * WeakMapRegistry maps active trigger events to each DOM element through a WeakMap.\r\n * This ensures that the mapping remains private to this module, while still allowing garbage\r\n * collection of the involved elements.\r\n */\r\nclass WeakMapRegistry {\r\n    /** Stores the current element-to-trigger mapping. */\r\n    [triggerMapSym]: WeakMap<Element, string[]>;\r\n    /** Counts the number of elements with active WML triggers. */\r\n    [elementCountSym]: number;\r\n\r\n    constructor() {\r\n        this[triggerMapSym] = new WeakMap();\r\n        this[elementCountSym] = 0;\r\n    }\r\n\r\n    /**\r\n     * Sets active triggers for the specified element.\r\n     *\r\n     * @param element - An HTML element\r\n     * @param triggers - The list of active WML trigger events for the specified element\r\n     */\r\n    set(element: Element, triggers: string[]): AddEventListenerOptions {\r\n        if (!this[triggerMapSym].has(element)) { this[elementCountSym]++; }\r\n        this[triggerMapSym].set(element, triggers);\r\n        return {};\r\n    }\r\n\r\n    /**\r\n     * Removes all registered event listeners.\r\n     */\r\n    reset(): void {\r\n        if (this[elementCountSym] <= 0)\r\n            return;\r\n\r\n        for (const element of document.body.querySelectorAll('*')) {\r\n            if (this[elementCountSym] <= 0)\r\n                break;\r\n\r\n            const triggers = this[triggerMapSym].get(element);\r\n            if (triggers != null) { this[elementCountSym]--; }\r\n\r\n            for (const trigger of triggers || [])\r\n                element.removeEventListener(trigger, onWMLTriggered);\r\n        }\r\n\r\n        this[triggerMapSym] = new WeakMap();\r\n        this[elementCountSym] = 0;\r\n    }\r\n}\r\n\r\nconst triggerRegistry = canAbortListeners() ? new AbortControllerRegistry() : new WeakMapRegistry();\r\n\r\n/**\r\n * Adds event listeners to the specified element.\r\n */\r\nfunction addWMLListeners(element: Element): void {\r\n    const triggerRegExp = /\\S+/g;\r\n    const triggerAttr = (element.getAttribute('wml-trigger') || element.getAttribute('data-wml-trigger') || \"click\");\r\n    const triggers: string[] = [];\r\n\r\n    let match;\r\n    while ((match = triggerRegExp.exec(triggerAttr)) !== null)\r\n        triggers.push(match[0]);\r\n\r\n    const options = triggerRegistry.set(element, triggers);\r\n    for (const trigger of triggers)\r\n        element.addEventListener(trigger, onWMLTriggered, options);\r\n}\r\n\r\n/**\r\n * Schedules an automatic reload of WML to be performed as soon as the document is fully loaded.\r\n */\r\nexport function Enable(): void {\r\n    whenReady(Reload);\r\n}\r\n\r\n/**\r\n * Reloads the WML page by adding necessary event listeners and browser listeners.\r\n */\r\nexport function Reload(): void {\r\n    triggerRegistry.reset();\r\n    document.body.querySelectorAll('[wml-event], [wml-window], [wml-openurl], [data-wml-event], [data-wml-window], [data-wml-openurl]').forEach(addWMLListeners);\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\r\n\r\nconst call = newRuntimeCaller(objectNames.Browser);\r\n\r\nconst BrowserOpenURL = 0;\r\n\r\n/**\r\n * Open a browser window to the given URL.\r\n *\r\n * @param url - The URL to open\r\n */\r\nexport function OpenURL(url: string | URL): Promise<void> {\r\n    return call(BrowserOpenURL, {url: url.toString()});\r\n}\r\n", "// Source: https://github.com/ai/nanoid\r\n\r\n// The MIT License (MIT)\r\n//\r\n// Copyright 2017 Andrey Sitnik <andrey@sitnik.ru>\r\n//\r\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\r\n// this software and associated documentation files (the \"Software\"), to deal in\r\n// the Software without restriction, including without limitation the rights to\r\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r\n// the Software, and to permit persons to whom the Software is furnished to do so,\r\n//     subject to the following conditions:\r\n//\r\n//     The above copyright notice and this permission notice shall be included in all\r\n// copies or substantial portions of the Software.\r\n//\r\n//     THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r\n\r\n// This alphabet uses `A-Za-z0-9_-` symbols.\r\n// The order of characters is optimized for better gzip and brotli compression.\r\n// References to the same file (works both for gzip and brotli):\r\n// `'use`, `andom`, and `rict'`\r\n// References to the brotli default dictionary:\r\n// `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`\r\nconst urlAlphabet =\r\n    'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\r\n\r\nexport function nanoid(size: number = 21): string {\r\n    let id = ''\r\n    // A compact alternative for `for (var i = 0; i < step; i++)`.\r\n    let i = size | 0\r\n    while (i--) {\r\n        // `| 0` is more compact and faster than `Math.floor()`.\r\n        id += urlAlphabet[(Math.random() * 64) | 0]\r\n    }\r\n    return id\r\n}\r\n", "/*\r\n _     __     _ __\r\n| |  / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\nimport { nanoid } from './nanoid.js';\r\n\r\nconst runtimeURL = window.location.origin + \"/wails/runtime\";\r\n\r\n// Object Names\r\nexport const objectNames = Object.freeze({\r\n    Call: 0,\r\n    Clipboard: 1,\r\n    Application: 2,\r\n    Events: 3,\r\n    ContextMenu: 4,\r\n    Dialog: 5,\r\n    Window: 6,\r\n    Screens: 7,\r\n    System: 8,\r\n    Browser: 9,\r\n    CancelCall: 10,\r\n});\r\nexport let clientId = nanoid();\r\n\r\n/**\r\n * Creates a new runtime caller with specified ID.\r\n *\r\n * @param object - The object to invoke the method on.\r\n * @param windowName - The name of the window.\r\n * @return The new runtime caller function.\r\n */\r\nexport function newRuntimeCaller(object: number, windowName: string = '') {\r\n    return function (method: number, args: any = null) {\r\n        return runtimeCallWithID(object, method, windowName, args);\r\n    };\r\n}\r\n\r\nasync function runtimeCallWithID(objectID: number, method: number, windowName: string, args: any): Promise<any> {\r\n    let url = new URL(runtimeURL);\r\n    url.searchParams.append(\"object\", objectID.toString());\r\n    url.searchParams.append(\"method\", method.toString());\r\n    if (args) { url.searchParams.append(\"args\", JSON.stringify(args)); }\r\n\r\n    let headers: Record<string, string> = {\r\n        [\"x-wails-client-id\"]: clientId\r\n    }\r\n    if (windowName) {\r\n        headers[\"x-wails-window-name\"] = windowName;\r\n    }\r\n\r\n    let response = await fetch(url, { headers });\r\n    if (!response.ok) {\r\n        throw new Error(await response.text());\r\n    }\r\n\r\n    if ((response.headers.get(\"Content-Type\")?.indexOf(\"application/json\") ?? -1) !== -1) {\r\n        return response.json();\r\n    } else {\r\n        return response.text();\r\n    }\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\r\nimport { nanoid } from './nanoid.js';\r\n\r\n// setup\r\nwindow._wails = window._wails || {};\r\nwindow._wails.dialogErrorCallback = dialogErrorCallback;\r\nwindow._wails.dialogResultCallback = dialogResultCallback;\r\n\r\ntype PromiseResolvers = Omit<PromiseWithResolvers<any>, \"promise\">;\r\n\r\nconst call = newRuntimeCaller(objectNames.Dialog);\r\nconst dialogResponses = new Map<string, PromiseResolvers>();\r\n\r\n// Define constants from the `methods` object in Title Case\r\nconst DialogInfo = 0;\r\nconst DialogWarning = 1;\r\nconst DialogError = 2;\r\nconst DialogQuestion = 3;\r\nconst DialogOpenFile = 4;\r\nconst DialogSaveFile = 5;\r\n\r\nexport interface OpenFileDialogOptions {\r\n    /** Indicates if directories can be chosen. */\r\n    CanChooseDirectories?: boolean;\r\n    /** Indicates if files can be chosen. */\r\n    CanChooseFiles?: boolean;\r\n    /** Indicates if directories can be created. */\r\n    CanCreateDirectories?: boolean;\r\n    /** Indicates if hidden files should be shown. */\r\n    ShowHiddenFiles?: boolean;\r\n    /** Indicates if aliases should be resolved. */\r\n    ResolvesAliases?: boolean;\r\n    /** Indicates if multiple selection is allowed. */\r\n    AllowsMultipleSelection?: boolean;\r\n    /** Indicates if the extension should be hidden. */\r\n    HideExtension?: boolean;\r\n    /** Indicates if hidden extensions can be selected. */\r\n    CanSelectHiddenExtension?: boolean;\r\n    /** Indicates if file packages should be treated as directories. */\r\n    TreatsFilePackagesAsDirectories?: boolean;\r\n    /** Indicates if other file types are allowed. */\r\n    AllowsOtherFiletypes?: boolean;\r\n    /** Array of file filters. */\r\n    Filters?: FileFilter[];\r\n    /** Title of the dialog. */\r\n    Title?: string;\r\n    /** Message to show in the dialog. */\r\n    Message?: string;\r\n    /** Text to display on the button. */\r\n    ButtonText?: string;\r\n    /** Directory to open in the dialog. */\r\n    Directory?: string;\r\n    /** Indicates if the dialog should appear detached from the main window. */\r\n    Detached?: boolean;\r\n}\r\n\r\nexport interface SaveFileDialogOptions {\r\n    /** Default filename to use in the dialog. */\r\n    Filename?: string;\r\n    /** Indicates if directories can be chosen. */\r\n    CanChooseDirectories?: boolean;\r\n    /** Indicates if files can be chosen. */\r\n    CanChooseFiles?: boolean;\r\n    /** Indicates if directories can be created. */\r\n    CanCreateDirectories?: boolean;\r\n    /** Indicates if hidden files should be shown. */\r\n    ShowHiddenFiles?: boolean;\r\n    /** Indicates if aliases should be resolved. */\r\n    ResolvesAliases?: boolean;\r\n    /** Indicates if the extension should be hidden. */\r\n    HideExtension?: boolean;\r\n    /** Indicates if hidden extensions can be selected. */\r\n    CanSelectHiddenExtension?: boolean;\r\n    /** Indicates if file packages should be treated as directories. */\r\n    TreatsFilePackagesAsDirectories?: boolean;\r\n    /** Indicates if other file types are allowed. */\r\n    AllowsOtherFiletypes?: boolean;\r\n    /** Array of file filters. */\r\n    Filters?: FileFilter[];\r\n    /** Title of the dialog. */\r\n    Title?: string;\r\n    /** Message to show in the dialog. */\r\n    Message?: string;\r\n    /** Text to display on the button. */\r\n    ButtonText?: string;\r\n    /** Directory to open in the dialog. */\r\n    Directory?: string;\r\n    /** Indicates if the dialog should appear detached from the main window. */\r\n    Detached?: boolean;\r\n}\r\n\r\nexport interface MessageDialogOptions {\r\n    /** The title of the dialog window. */\r\n    Title?: string;\r\n    /** The main message to show in the dialog. */\r\n    Message?: string;\r\n    /** Array of button options to show in the dialog. */\r\n    Buttons?: Button[];\r\n    /** True if the dialog should appear detached from the main window (if applicable). */\r\n    Detached?: boolean;\r\n}\r\n\r\nexport interface Button {\r\n    /** Text that appears within the button. */\r\n    Label?: string;\r\n    /** True if the button should cancel an operation when clicked. */\r\n    IsCancel?: boolean;\r\n    /** True if the button should be the default action when the user presses enter. */\r\n    IsDefault?: boolean;\r\n}\r\n\r\nexport interface FileFilter {\r\n    /** Display name for the filter, it could be \"Text Files\", \"Images\" etc. */\r\n    DisplayName?: string;\r\n    /** Pattern to match for the filter, e.g. \"*.txt;*.md\" for text markdown files. */\r\n    Pattern?: string;\r\n}\r\n\r\n/**\r\n * Handles the result of a dialog request.\r\n *\r\n * @param id - The id of the request to handle the result for.\r\n * @param data - The result data of the request.\r\n * @param isJSON - Indicates whether the data is JSON or not.\r\n */\r\nfunction dialogResultCallback(id: string, data: string, isJSON: boolean): void {\r\n    let resolvers = getAndDeleteResponse(id);\r\n    if (!resolvers) {\r\n        return;\r\n    }\r\n\r\n    if (isJSON) {\r\n        try {\r\n            resolvers.resolve(JSON.parse(data));\r\n        } catch (err: any) {\r\n            resolvers.reject(new TypeError(\"could not parse result: \" + err.message, { cause: err }));\r\n        }\r\n    } else {\r\n        resolvers.resolve(data);\r\n    }\r\n}\r\n\r\n/**\r\n * Handles the error from a dialog request.\r\n *\r\n * @param id - The id of the promise handler.\r\n * @param message - An error message.\r\n */\r\nfunction dialogErrorCallback(id: string, message: string): void {\r\n    getAndDeleteResponse(id)?.reject(new window.Error(message));\r\n}\r\n\r\n/**\r\n * Retrieves and removes the response associated with the given ID from the dialogResponses map.\r\n *\r\n * @param id - The ID of the response to be retrieved and removed.\r\n * @returns The response object associated with the given ID, if any.\r\n */\r\nfunction getAndDeleteResponse(id: string): PromiseResolvers | undefined {\r\n    const response = dialogResponses.get(id);\r\n    dialogResponses.delete(id);\r\n    return response;\r\n}\r\n\r\n/**\r\n * Generates a unique ID using the nanoid library.\r\n *\r\n * @returns A unique ID that does not exist in the dialogResponses set.\r\n */\r\nfunction generateID(): string {\r\n    let result;\r\n    do {\r\n        result = nanoid();\r\n    } while (dialogResponses.has(result));\r\n    return result;\r\n}\r\n\r\n/**\r\n * Presents a dialog of specified type with the given options.\r\n *\r\n * @param type - Dialog type.\r\n * @param options - Options for the dialog.\r\n * @returns A promise that resolves with result of dialog.\r\n */\r\nfunction dialog(type: number, options: MessageDialogOptions | OpenFileDialogOptions | SaveFileDialogOptions = {}): Promise<any> {\r\n    const id = generateID();\r\n    return new Promise((resolve, reject) => {\r\n        dialogResponses.set(id, { resolve, reject });\r\n        call(type, Object.assign({ \"dialog-id\": id }, options)).catch((err: any) => {\r\n            dialogResponses.delete(id);\r\n            reject(err);\r\n        });\r\n    });\r\n}\r\n\r\n/**\r\n * Presents an info dialog.\r\n *\r\n * @param options - Dialog options\r\n * @returns A promise that resolves with the label of the chosen button.\r\n */\r\nexport function Info(options: MessageDialogOptions): Promise<string> { return dialog(DialogInfo, options); }\r\n\r\n/**\r\n * Presents a warning dialog.\r\n *\r\n * @param options - Dialog options.\r\n * @returns A promise that resolves with the label of the chosen button.\r\n */\r\nexport function Warning(options: MessageDialogOptions): Promise<string> { return dialog(DialogWarning, options); }\r\n\r\n/**\r\n * Presents an error dialog.\r\n *\r\n * @param options - Dialog options.\r\n * @returns A promise that resolves with the label of the chosen button.\r\n */\r\nexport function Error(options: MessageDialogOptions): Promise<string> { return dialog(DialogError, options); }\r\n\r\n/**\r\n * Presents a question dialog.\r\n *\r\n * @param options - Dialog options.\r\n * @returns A promise that resolves with the label of the chosen button.\r\n */\r\nexport function Question(options: MessageDialogOptions): Promise<string> { return dialog(DialogQuestion, options); }\r\n\r\n/**\r\n * Presents a file selection dialog to pick one or more files to open.\r\n *\r\n * @param options - Dialog options.\r\n * @returns Selected file or list of files, or a blank string/empty list if no file has been selected.\r\n */\r\nexport function OpenFile(options: OpenFileDialogOptions & { AllowsMultipleSelection: true }): Promise<string[]>;\r\nexport function OpenFile(options: OpenFileDialogOptions & { AllowsMultipleSelection?: false | undefined }): Promise<string>;\r\nexport function OpenFile(options: OpenFileDialogOptions): Promise<string | string[]>;\r\nexport function OpenFile(options: OpenFileDialogOptions): Promise<string | string[]> { return dialog(DialogOpenFile, options) ?? []; }\r\n\r\n/**\r\n * Presents a file selection dialog to pick a file to save.\r\n *\r\n * @param options - Dialog options.\r\n * @returns Selected file, or a blank string if no file has been selected.\r\n */\r\nexport function SaveFile(options: SaveFileDialogOptions): Promise<string> { return dialog(DialogSaveFile, options); }\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\r\nimport { eventListeners, Listener, listenerOff } from \"./listener.js\";\r\n\r\n// Setup\r\nwindow._wails = window._wails || {};\r\nwindow._wails.dispatchWailsEvent = dispatchWailsEvent;\r\n\r\nconst call = newRuntimeCaller(objectNames.Events);\r\nconst EmitMethod = 0;\r\n\r\nexport { Types } from \"./event_types.js\";\r\n\r\n/**\r\n * The type of handlers for a given event.\r\n */\r\nexport type Callback = (ev: WailsEvent) => void;\r\n\r\n/**\r\n * Represents a system event or a custom event emitted through wails-provided facilities.\r\n */\r\nexport class WailsEvent {\r\n    /**\r\n     * The name of the event.\r\n     */\r\n    name: string;\r\n\r\n    /**\r\n     * Optional data associated with the emitted event.\r\n     */\r\n    data: any;\r\n\r\n    /**\r\n     * Name of the originating window. Omitted for application events.\r\n     * Will be overridden if set manually.\r\n     */\r\n    sender?: string;\r\n\r\n    constructor(name: string, data: any = null) {\r\n        this.name = name;\r\n        this.data = data;\r\n    }\r\n}\r\n\r\nfunction dispatchWailsEvent(event: any) {\r\n    let listeners = eventListeners.get(event.name);\r\n    if (!listeners) {\r\n        return;\r\n    }\r\n\r\n    let wailsEvent = new WailsEvent(event.name, event.data);\r\n    if ('sender' in event) {\r\n        wailsEvent.sender = event.sender;\r\n    }\r\n\r\n    listeners = listeners.filter(listener => !listener.dispatch(wailsEvent));\r\n    if (listeners.length === 0) {\r\n        eventListeners.delete(event.name);\r\n    } else {\r\n        eventListeners.set(event.name, listeners);\r\n    }\r\n}\r\n\r\n/**\r\n * Register a callback function to be called multiple times for a specific event.\r\n *\r\n * @param eventName - The name of the event to register the callback for.\r\n * @param callback - The callback function to be called when the event is triggered.\r\n * @param maxCallbacks - The maximum number of times the callback can be called for the event. Once the maximum number is reached, the callback will no longer be called.\r\n * @returns A function that, when called, will unregister the callback from the event.\r\n */\r\nexport function OnMultiple(eventName: string, callback: Callback, maxCallbacks: number) {\r\n    let listeners = eventListeners.get(eventName) || [];\r\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\r\n    listeners.push(thisListener);\r\n    eventListeners.set(eventName, listeners);\r\n    return () => listenerOff(thisListener);\r\n}\r\n\r\n/**\r\n * Registers a callback function to be executed when the specified event occurs.\r\n *\r\n * @param eventName - The name of the event to register the callback for.\r\n * @param callback - The callback function to be called when the event is triggered.\r\n * @returns A function that, when called, will unregister the callback from the event.\r\n */\r\nexport function On(eventName: string, callback: Callback): () => void {\r\n    return OnMultiple(eventName, callback, -1);\r\n}\r\n\r\n/**\r\n * Registers a callback function to be executed only once for the specified event.\r\n *\r\n * @param eventName - The name of the event to register the callback for.\r\n * @param callback - The callback function to be called when the event is triggered.\r\n * @returns A function that, when called, will unregister the callback from the event.\r\n */\r\nexport function Once(eventName: string, callback: Callback): () => void {\r\n    return OnMultiple(eventName, callback, 1);\r\n}\r\n\r\n/**\r\n * Removes event listeners for the specified event names.\r\n *\r\n * @param eventNames - The name of the events to remove listeners for.\r\n */\r\nexport function Off(...eventNames: [string, ...string[]]): void {\r\n    eventNames.forEach(eventName => eventListeners.delete(eventName));\r\n}\r\n\r\n/**\r\n * Removes all event listeners.\r\n */\r\nexport function OffAll(): void {\r\n    eventListeners.clear();\r\n}\r\n\r\n/**\r\n * Emits an event using the name and data.\r\n *\r\n * @returns A promise that will be fulfilled once the event has been emitted.\r\n * @param name - the name of the event to emit.\r\n * @param data - the data to be sent with the event.\r\n */\r\nexport function Emit(name: string, data?: any): Promise<void> {\r\n    let eventName: string;\r\n    let eventData: any;\r\n\r\n    if (typeof name === 'object' && name !== null && 'name' in name && 'data' in name) {\r\n        // If name is an object with a name property, use it directly\r\n        eventName = name['name'];\r\n        eventData = name['data'];\r\n    } else {\r\n        // Otherwise use the standard parameters\r\n        eventName = name as string;\r\n        eventData = data;\r\n    }\r\n\r\n    return call(EmitMethod, { name: eventName, data: eventData });\r\n}\r\n\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n// The following utilities have been factored out of ./events.ts\r\n// for testing purposes.\r\n\r\nexport const eventListeners = new Map<string, Listener[]>();\r\n\r\nexport class Listener {\r\n    eventName: string;\r\n    callback: (data: any) => void;\r\n    maxCallbacks: number;\r\n\r\n    constructor(eventName: string, callback: (data: any) => void, maxCallbacks: number) {\r\n        this.eventName = eventName;\r\n        this.callback = callback;\r\n        this.maxCallbacks = maxCallbacks || -1;\r\n    }\r\n\r\n    dispatch(data: any): boolean {\r\n        try {\r\n            this.callback(data);\r\n        } catch (err) {\r\n            console.error(err);\r\n        }\r\n\r\n        if (this.maxCallbacks === -1) return false;\r\n        this.maxCallbacks -= 1;\r\n        return this.maxCallbacks === 0;\r\n    }\r\n}\r\n\r\nexport function listenerOff(listener: Listener): void {\r\n    let listeners = eventListeners.get(listener.eventName);\r\n    if (!listeners) {\r\n        return;\r\n    }\r\n\r\n    listeners = listeners.filter(l => l !== listener);\r\n    if (listeners.length === 0) {\r\n        eventListeners.delete(listener.eventName);\r\n    } else {\r\n        eventListeners.set(listener.eventName, listeners);\r\n    }\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH \u00C2 MODIWL\r\n// This file is automatically generated. DO NOT EDIT\r\n\r\nexport const Types = Object.freeze({\r\n\tWindows: Object.freeze({\r\n\t\tAPMPowerSettingChange: \"windows:APMPowerSettingChange\",\r\n\t\tAPMPowerStatusChange: \"windows:APMPowerStatusChange\",\r\n\t\tAPMResumeAutomatic: \"windows:APMResumeAutomatic\",\r\n\t\tAPMResumeSuspend: \"windows:APMResumeSuspend\",\r\n\t\tAPMSuspend: \"windows:APMSuspend\",\r\n\t\tApplicationStarted: \"windows:ApplicationStarted\",\r\n\t\tSystemThemeChanged: \"windows:SystemThemeChanged\",\r\n\t\tWebViewNavigationCompleted: \"windows:WebViewNavigationCompleted\",\r\n\t\tWindowActive: \"windows:WindowActive\",\r\n\t\tWindowBackgroundErase: \"windows:WindowBackgroundErase\",\r\n\t\tWindowClickActive: \"windows:WindowClickActive\",\r\n\t\tWindowClosing: \"windows:WindowClosing\",\r\n\t\tWindowDidMove: \"windows:WindowDidMove\",\r\n\t\tWindowDidResize: \"windows:WindowDidResize\",\r\n\t\tWindowDPIChanged: \"windows:WindowDPIChanged\",\r\n\t\tWindowDragDrop: \"windows:WindowDragDrop\",\r\n\t\tWindowDragEnter: \"windows:WindowDragEnter\",\r\n\t\tWindowDragLeave: \"windows:WindowDragLeave\",\r\n\t\tWindowDragOver: \"windows:WindowDragOver\",\r\n\t\tWindowEndMove: \"windows:WindowEndMove\",\r\n\t\tWindowEndResize: \"windows:WindowEndResize\",\r\n\t\tWindowFullscreen: \"windows:WindowFullscreen\",\r\n\t\tWindowHide: \"windows:WindowHide\",\r\n\t\tWindowInactive: \"windows:WindowInactive\",\r\n\t\tWindowKeyDown: \"windows:WindowKeyDown\",\r\n\t\tWindowKeyUp: \"windows:WindowKeyUp\",\r\n\t\tWindowKillFocus: \"windows:WindowKillFocus\",\r\n\t\tWindowNonClientHit: \"windows:WindowNonClientHit\",\r\n\t\tWindowNonClientMouseDown: \"windows:WindowNonClientMouseDown\",\r\n\t\tWindowNonClientMouseLeave: \"windows:WindowNonClientMouseLeave\",\r\n\t\tWindowNonClientMouseMove: \"windows:WindowNonClientMouseMove\",\r\n\t\tWindowNonClientMouseUp: \"windows:WindowNonClientMouseUp\",\r\n\t\tWindowPaint: \"windows:WindowPaint\",\r\n\t\tWindowRestore: \"windows:WindowRestore\",\r\n\t\tWindowSetFocus: \"windows:WindowSetFocus\",\r\n\t\tWindowShow: \"windows:WindowShow\",\r\n\t\tWindowStartMove: \"windows:WindowStartMove\",\r\n\t\tWindowStartResize: \"windows:WindowStartResize\",\r\n\t\tWindowUnFullscreen: \"windows:WindowUnFullscreen\",\r\n\t\tWindowZOrderChanged: \"windows:WindowZOrderChanged\",\r\n\t\tWindowMinimise: \"windows:WindowMinimise\",\r\n\t\tWindowUnMinimise: \"windows:WindowUnMinimise\",\r\n\t\tWindowMaximise: \"windows:WindowMaximise\",\r\n\t\tWindowUnMaximise: \"windows:WindowUnMaximise\",\r\n\t}),\r\n\tMac: Object.freeze({\r\n\t\tApplicationDidBecomeActive: \"mac:ApplicationDidBecomeActive\",\r\n\t\tApplicationDidChangeBackingProperties: \"mac:ApplicationDidChangeBackingProperties\",\r\n\t\tApplicationDidChangeEffectiveAppearance: \"mac:ApplicationDidChangeEffectiveAppearance\",\r\n\t\tApplicationDidChangeIcon: \"mac:ApplicationDidChangeIcon\",\r\n\t\tApplicationDidChangeOcclusionState: \"mac:ApplicationDidChangeOcclusionState\",\r\n\t\tApplicationDidChangeScreenParameters: \"mac:ApplicationDidChangeScreenParameters\",\r\n\t\tApplicationDidChangeStatusBarFrame: \"mac:ApplicationDidChangeStatusBarFrame\",\r\n\t\tApplicationDidChangeStatusBarOrientation: \"mac:ApplicationDidChangeStatusBarOrientation\",\r\n\t\tApplicationDidChangeTheme: \"mac:ApplicationDidChangeTheme\",\r\n\t\tApplicationDidFinishLaunching: \"mac:ApplicationDidFinishLaunching\",\r\n\t\tApplicationDidHide: \"mac:ApplicationDidHide\",\r\n\t\tApplicationDidResignActive: \"mac:ApplicationDidResignActive\",\r\n\t\tApplicationDidUnhide: \"mac:ApplicationDidUnhide\",\r\n\t\tApplicationDidUpdate: \"mac:ApplicationDidUpdate\",\r\n\t\tApplicationShouldHandleReopen: \"mac:ApplicationShouldHandleReopen\",\r\n\t\tApplicationWillBecomeActive: \"mac:ApplicationWillBecomeActive\",\r\n\t\tApplicationWillFinishLaunching: \"mac:ApplicationWillFinishLaunching\",\r\n\t\tApplicationWillHide: \"mac:ApplicationWillHide\",\r\n\t\tApplicationWillResignActive: \"mac:ApplicationWillResignActive\",\r\n\t\tApplicationWillTerminate: \"mac:ApplicationWillTerminate\",\r\n\t\tApplicationWillUnhide: \"mac:ApplicationWillUnhide\",\r\n\t\tApplicationWillUpdate: \"mac:ApplicationWillUpdate\",\r\n\t\tMenuDidAddItem: \"mac:MenuDidAddItem\",\r\n\t\tMenuDidBeginTracking: \"mac:MenuDidBeginTracking\",\r\n\t\tMenuDidClose: \"mac:MenuDidClose\",\r\n\t\tMenuDidDisplayItem: \"mac:MenuDidDisplayItem\",\r\n\t\tMenuDidEndTracking: \"mac:MenuDidEndTracking\",\r\n\t\tMenuDidHighlightItem: \"mac:MenuDidHighlightItem\",\r\n\t\tMenuDidOpen: \"mac:MenuDidOpen\",\r\n\t\tMenuDidPopUp: \"mac:MenuDidPopUp\",\r\n\t\tMenuDidRemoveItem: \"mac:MenuDidRemoveItem\",\r\n\t\tMenuDidSendAction: \"mac:MenuDidSendAction\",\r\n\t\tMenuDidSendActionToItem: \"mac:MenuDidSendActionToItem\",\r\n\t\tMenuDidUpdate: \"mac:MenuDidUpdate\",\r\n\t\tMenuWillAddItem: \"mac:MenuWillAddItem\",\r\n\t\tMenuWillBeginTracking: \"mac:MenuWillBeginTracking\",\r\n\t\tMenuWillDisplayItem: \"mac:MenuWillDisplayItem\",\r\n\t\tMenuWillEndTracking: \"mac:MenuWillEndTracking\",\r\n\t\tMenuWillHighlightItem: \"mac:MenuWillHighlightItem\",\r\n\t\tMenuWillOpen: \"mac:MenuWillOpen\",\r\n\t\tMenuWillPopUp: \"mac:MenuWillPopUp\",\r\n\t\tMenuWillRemoveItem: \"mac:MenuWillRemoveItem\",\r\n\t\tMenuWillSendAction: \"mac:MenuWillSendAction\",\r\n\t\tMenuWillSendActionToItem: \"mac:MenuWillSendActionToItem\",\r\n\t\tMenuWillUpdate: \"mac:MenuWillUpdate\",\r\n\t\tWebViewDidCommitNavigation: \"mac:WebViewDidCommitNavigation\",\r\n\t\tWebViewDidFinishNavigation: \"mac:WebViewDidFinishNavigation\",\r\n\t\tWebViewDidReceiveServerRedirectForProvisionalNavigation: \"mac:WebViewDidReceiveServerRedirectForProvisionalNavigation\",\r\n\t\tWebViewDidStartProvisionalNavigation: \"mac:WebViewDidStartProvisionalNavigation\",\r\n\t\tWindowDidBecomeKey: \"mac:WindowDidBecomeKey\",\r\n\t\tWindowDidBecomeMain: \"mac:WindowDidBecomeMain\",\r\n\t\tWindowDidBeginSheet: \"mac:WindowDidBeginSheet\",\r\n\t\tWindowDidChangeAlpha: \"mac:WindowDidChangeAlpha\",\r\n\t\tWindowDidChangeBackingLocation: \"mac:WindowDidChangeBackingLocation\",\r\n\t\tWindowDidChangeBackingProperties: \"mac:WindowDidChangeBackingProperties\",\r\n\t\tWindowDidChangeCollectionBehavior: \"mac:WindowDidChangeCollectionBehavior\",\r\n\t\tWindowDidChangeEffectiveAppearance: \"mac:WindowDidChangeEffectiveAppearance\",\r\n\t\tWindowDidChangeOcclusionState: \"mac:WindowDidChangeOcclusionState\",\r\n\t\tWindowDidChangeOrderingMode: \"mac:WindowDidChangeOrderingMode\",\r\n\t\tWindowDidChangeScreen: \"mac:WindowDidChangeScreen\",\r\n\t\tWindowDidChangeScreenParameters: \"mac:WindowDidChangeScreenParameters\",\r\n\t\tWindowDidChangeScreenProfile: \"mac:WindowDidChangeScreenProfile\",\r\n\t\tWindowDidChangeScreenSpace: \"mac:WindowDidChangeScreenSpace\",\r\n\t\tWindowDidChangeScreenSpaceProperties: \"mac:WindowDidChangeScreenSpaceProperties\",\r\n\t\tWindowDidChangeSharingType: \"mac:WindowDidChangeSharingType\",\r\n\t\tWindowDidChangeSpace: \"mac:WindowDidChangeSpace\",\r\n\t\tWindowDidChangeSpaceOrderingMode: \"mac:WindowDidChangeSpaceOrderingMode\",\r\n\t\tWindowDidChangeTitle: \"mac:WindowDidChangeTitle\",\r\n\t\tWindowDidChangeToolbar: \"mac:WindowDidChangeToolbar\",\r\n\t\tWindowDidDeminiaturize: \"mac:WindowDidDeminiaturize\",\r\n\t\tWindowDidEndSheet: \"mac:WindowDidEndSheet\",\r\n\t\tWindowDidEnterFullScreen: \"mac:WindowDidEnterFullScreen\",\r\n\t\tWindowDidEnterVersionBrowser: \"mac:WindowDidEnterVersionBrowser\",\r\n\t\tWindowDidExitFullScreen: \"mac:WindowDidExitFullScreen\",\r\n\t\tWindowDidExitVersionBrowser: \"mac:WindowDidExitVersionBrowser\",\r\n\t\tWindowDidExpose: \"mac:WindowDidExpose\",\r\n\t\tWindowDidFocus: \"mac:WindowDidFocus\",\r\n\t\tWindowDidMiniaturize: \"mac:WindowDidMiniaturize\",\r\n\t\tWindowDidMove: \"mac:WindowDidMove\",\r\n\t\tWindowDidOrderOffScreen: \"mac:WindowDidOrderOffScreen\",\r\n\t\tWindowDidOrderOnScreen: \"mac:WindowDidOrderOnScreen\",\r\n\t\tWindowDidResignKey: \"mac:WindowDidResignKey\",\r\n\t\tWindowDidResignMain: \"mac:WindowDidResignMain\",\r\n\t\tWindowDidResize: \"mac:WindowDidResize\",\r\n\t\tWindowDidUpdate: \"mac:WindowDidUpdate\",\r\n\t\tWindowDidUpdateAlpha: \"mac:WindowDidUpdateAlpha\",\r\n\t\tWindowDidUpdateCollectionBehavior: \"mac:WindowDidUpdateCollectionBehavior\",\r\n\t\tWindowDidUpdateCollectionProperties: \"mac:WindowDidUpdateCollectionProperties\",\r\n\t\tWindowDidUpdateShadow: \"mac:WindowDidUpdateShadow\",\r\n\t\tWindowDidUpdateTitle: \"mac:WindowDidUpdateTitle\",\r\n\t\tWindowDidUpdateToolbar: \"mac:WindowDidUpdateToolbar\",\r\n\t\tWindowDidZoom: \"mac:WindowDidZoom\",\r\n\t\tWindowFileDraggingEntered: \"mac:WindowFileDraggingEntered\",\r\n\t\tWindowFileDraggingExited: \"mac:WindowFileDraggingExited\",\r\n\t\tWindowFileDraggingPerformed: \"mac:WindowFileDraggingPerformed\",\r\n\t\tWindowHide: \"mac:WindowHide\",\r\n\t\tWindowMaximise: \"mac:WindowMaximise\",\r\n\t\tWindowUnMaximise: \"mac:WindowUnMaximise\",\r\n\t\tWindowMinimise: \"mac:WindowMinimise\",\r\n\t\tWindowUnMinimise: \"mac:WindowUnMinimise\",\r\n\t\tWindowShouldClose: \"mac:WindowShouldClose\",\r\n\t\tWindowShow: \"mac:WindowShow\",\r\n\t\tWindowWillBecomeKey: \"mac:WindowWillBecomeKey\",\r\n\t\tWindowWillBecomeMain: \"mac:WindowWillBecomeMain\",\r\n\t\tWindowWillBeginSheet: \"mac:WindowWillBeginSheet\",\r\n\t\tWindowWillChangeOrderingMode: \"mac:WindowWillChangeOrderingMode\",\r\n\t\tWindowWillClose: \"mac:WindowWillClose\",\r\n\t\tWindowWillDeminiaturize: \"mac:WindowWillDeminiaturize\",\r\n\t\tWindowWillEnterFullScreen: \"mac:WindowWillEnterFullScreen\",\r\n\t\tWindowWillEnterVersionBrowser: \"mac:WindowWillEnterVersionBrowser\",\r\n\t\tWindowWillExitFullScreen: \"mac:WindowWillExitFullScreen\",\r\n\t\tWindowWillExitVersionBrowser: \"mac:WindowWillExitVersionBrowser\",\r\n\t\tWindowWillFocus: \"mac:WindowWillFocus\",\r\n\t\tWindowWillMiniaturize: \"mac:WindowWillMiniaturize\",\r\n\t\tWindowWillMove: \"mac:WindowWillMove\",\r\n\t\tWindowWillOrderOffScreen: \"mac:WindowWillOrderOffScreen\",\r\n\t\tWindowWillOrderOnScreen: \"mac:WindowWillOrderOnScreen\",\r\n\t\tWindowWillResignMain: \"mac:WindowWillResignMain\",\r\n\t\tWindowWillResize: \"mac:WindowWillResize\",\r\n\t\tWindowWillUnfocus: \"mac:WindowWillUnfocus\",\r\n\t\tWindowWillUpdate: \"mac:WindowWillUpdate\",\r\n\t\tWindowWillUpdateAlpha: \"mac:WindowWillUpdateAlpha\",\r\n\t\tWindowWillUpdateCollectionBehavior: \"mac:WindowWillUpdateCollectionBehavior\",\r\n\t\tWindowWillUpdateCollectionProperties: \"mac:WindowWillUpdateCollectionProperties\",\r\n\t\tWindowWillUpdateShadow: \"mac:WindowWillUpdateShadow\",\r\n\t\tWindowWillUpdateTitle: \"mac:WindowWillUpdateTitle\",\r\n\t\tWindowWillUpdateToolbar: \"mac:WindowWillUpdateToolbar\",\r\n\t\tWindowWillUpdateVisibility: \"mac:WindowWillUpdateVisibility\",\r\n\t\tWindowWillUseStandardFrame: \"mac:WindowWillUseStandardFrame\",\r\n\t\tWindowZoomIn: \"mac:WindowZoomIn\",\r\n\t\tWindowZoomOut: \"mac:WindowZoomOut\",\r\n\t\tWindowZoomReset: \"mac:WindowZoomReset\",\r\n\t}),\r\n\tLinux: Object.freeze({\r\n\t\tApplicationStartup: \"linux:ApplicationStartup\",\r\n\t\tSystemThemeChanged: \"linux:SystemThemeChanged\",\r\n\t\tWindowDeleteEvent: \"linux:WindowDeleteEvent\",\r\n\t\tWindowDidMove: \"linux:WindowDidMove\",\r\n\t\tWindowDidResize: \"linux:WindowDidResize\",\r\n\t\tWindowFocusIn: \"linux:WindowFocusIn\",\r\n\t\tWindowFocusOut: \"linux:WindowFocusOut\",\r\n\t\tWindowLoadChanged: \"linux:WindowLoadChanged\",\r\n\t}),\r\n\tCommon: Object.freeze({\r\n\t\tApplicationOpenedWithFile: \"common:ApplicationOpenedWithFile\",\r\n\t\tApplicationStarted: \"common:ApplicationStarted\",\r\n\t\tApplicationLaunchedWithUrl: \"common:ApplicationLaunchedWithUrl\",\r\n\t\tThemeChanged: \"common:ThemeChanged\",\r\n\t\tWindowClosing: \"common:WindowClosing\",\r\n\t\tWindowDidMove: \"common:WindowDidMove\",\r\n\t\tWindowDidResize: \"common:WindowDidResize\",\r\n\t\tWindowDPIChanged: \"common:WindowDPIChanged\",\r\n\t\tWindowFilesDropped: \"common:WindowFilesDropped\",\r\n\t\tWindowFocus: \"common:WindowFocus\",\r\n\t\tWindowFullscreen: \"common:WindowFullscreen\",\r\n\t\tWindowHide: \"common:WindowHide\",\r\n\t\tWindowLostFocus: \"common:WindowLostFocus\",\r\n\t\tWindowMaximise: \"common:WindowMaximise\",\r\n\t\tWindowMinimise: \"common:WindowMinimise\",\r\n\t\tWindowToggleFrameless: \"common:WindowToggleFrameless\",\r\n\t\tWindowRestore: \"common:WindowRestore\",\r\n\t\tWindowRuntimeReady: \"common:WindowRuntimeReady\",\r\n\t\tWindowShow: \"common:WindowShow\",\r\n\t\tWindowUnFullscreen: \"common:WindowUnFullscreen\",\r\n\t\tWindowUnMaximise: \"common:WindowUnMaximise\",\r\n\t\tWindowUnMinimise: \"common:WindowUnMinimise\",\r\n\t\tWindowZoom: \"common:WindowZoom\",\r\n\t\tWindowZoomIn: \"common:WindowZoomIn\",\r\n\t\tWindowZoomOut: \"common:WindowZoomOut\",\r\n\t\tWindowZoomReset: \"common:WindowZoomReset\",\r\n\t\tWindowDropZoneFilesDropped: \"common:WindowDropZoneFilesDropped\",\r\n\t}),\r\n});\r\n", "/*\r\n _     __     _ __\r\n| |  / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/**\r\n * Logs a message to the console with custom formatting.\r\n *\r\n * @param message - The message to be logged.\r\n */\r\nexport function debugLog(message: any) {\r\n    // eslint-disable-next-line\r\n    console.log(\r\n        '%c wails3 %c ' + message + ' ',\r\n        'background: #aa0000; color: #fff; border-radius: 3px 0px 0px 3px; padding: 1px; font-size: 0.7rem',\r\n        'background: #009900; color: #fff; border-radius: 0px 3px 3px 0px; padding: 1px; font-size: 0.7rem'\r\n    );\r\n}\r\n\r\n/**\r\n * Checks whether the webview supports the {@link MouseEvent#buttons} property.\r\n * Looking at you macOS High Sierra!\r\n */\r\nexport function canTrackButtons(): boolean {\r\n    return (new MouseEvent('mousedown')).buttons === 0;\r\n}\r\n\r\n/**\r\n * Checks whether the browser supports removing listeners by triggering an AbortSignal\r\n * (see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#signal).\r\n */\r\nexport function canAbortListeners() {\r\n    if (!EventTarget || !AbortSignal || !AbortController)\r\n        return false;\r\n\r\n    let result = true;\r\n\r\n    const target = new EventTarget();\r\n    const controller = new AbortController();\r\n    target.addEventListener('test', () => { result = false; }, { signal: controller.signal });\r\n    controller.abort();\r\n    target.dispatchEvent(new CustomEvent('test'));\r\n\r\n    return result;\r\n}\r\n\r\n/**\r\n * Resolves the closest HTMLElement ancestor of an event's target.\r\n */\r\nexport function eventTarget(event: Event): HTMLElement {\r\n    if (event.target instanceof HTMLElement) {\r\n        return event.target;\r\n    } else if (!(event.target instanceof HTMLElement) && event.target instanceof Node) {\r\n        return event.target.parentElement ?? document.body;\r\n    } else {\r\n        return document.body;\r\n    }\r\n}\r\n\r\n/***\r\n This technique for proper load detection is taken from HTMX:\r\n\r\n BSD 2-Clause License\r\n\r\n Copyright (c) 2020, Big Sky Software\r\n All rights reserved.\r\n\r\n Redistribution and use in source and binary forms, with or without\r\n modification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice, this\r\n list of conditions and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\r\n AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r\n DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\r\n FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r\n SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\r\n CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\r\n OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r\n OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n ***/\r\n\r\nlet isReady = false;\r\ndocument.addEventListener('DOMContentLoaded', () => { isReady = true });\r\n\r\nexport function whenReady(callback: () => void) {\r\n    if (isReady || document.readyState === 'complete') {\r\n        callback();\r\n    } else {\r\n        document.addEventListener('DOMContentLoaded', callback);\r\n    }\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\r\nimport type { Screen } from \"./screens.js\";\r\n\r\n// NEW: Dropzone constants\r\nconst DROPZONE_ATTRIBUTE = 'data-wails-dropzone';\r\nconst DROPZONE_HOVER_CLASS = 'wails-dropzone-hover'; // User can style this class\r\nlet currentHoveredDropzone: Element | null = null;\r\n\r\nconst PositionMethod                    = 0;\r\nconst CenterMethod                      = 1;\r\nconst CloseMethod                       = 2;\r\nconst DisableSizeConstraintsMethod      = 3;\r\nconst EnableSizeConstraintsMethod       = 4;\r\nconst FocusMethod                       = 5;\r\nconst ForceReloadMethod                 = 6;\r\nconst FullscreenMethod                  = 7;\r\nconst GetScreenMethod                   = 8;\r\nconst GetZoomMethod                     = 9;\r\nconst HeightMethod                      = 10;\r\nconst HideMethod                        = 11;\r\nconst IsFocusedMethod                   = 12;\r\nconst IsFullscreenMethod                = 13;\r\nconst IsMaximisedMethod                 = 14;\r\nconst IsMinimisedMethod                 = 15;\r\nconst MaximiseMethod                    = 16;\r\nconst MinimiseMethod                    = 17;\r\nconst NameMethod                        = 18;\r\nconst OpenDevToolsMethod                = 19;\r\nconst RelativePositionMethod            = 20;\r\nconst ReloadMethod                      = 21;\r\nconst ResizableMethod                   = 22;\r\nconst RestoreMethod                     = 23;\r\nconst SetPositionMethod                 = 24;\r\nconst SetAlwaysOnTopMethod              = 25;\r\nconst SetBackgroundColourMethod         = 26;\r\nconst SetFramelessMethod                = 27;\r\nconst SetFullscreenButtonEnabledMethod  = 28;\r\nconst SetMaxSizeMethod                  = 29;\r\nconst SetMinSizeMethod                  = 30;\r\nconst SetRelativePositionMethod         = 31;\r\nconst SetResizableMethod                = 32;\r\nconst SetSizeMethod                     = 33;\r\nconst SetTitleMethod                    = 34;\r\nconst SetZoomMethod                     = 35;\r\nconst ShowMethod                        = 36;\r\nconst SizeMethod                        = 37;\r\nconst ToggleFullscreenMethod            = 38;\r\nconst ToggleMaximiseMethod              = 39;\r\nconst ToggleFramelessMethod             = 40; \r\nconst UnFullscreenMethod                = 41;\r\nconst UnMaximiseMethod                  = 42;\r\nconst UnMinimiseMethod                  = 43;\r\nconst WidthMethod                       = 44;\r\nconst ZoomMethod                        = 45;\r\nconst ZoomInMethod                      = 46;\r\nconst ZoomOutMethod                     = 47;\r\nconst ZoomResetMethod                   = 48;\r\nconst WindowDropZoneDropped             = 49;\r\n\r\nfunction getDropzoneElement(element: Element | null): Element | null {\r\n    if (!element) {\r\n        return null;\r\n    }\r\n    // Allow dropzone attribute to be on the element itself or any parent\r\n    return element.closest(`[${DROPZONE_ATTRIBUTE}]`);\r\n}\r\n\r\n/**\r\n * A record describing the position of a window.\r\n */\r\ninterface Position {\r\n    /** The horizontal position of the window. */\r\n    x: number;\r\n    /** The vertical position of the window. */\r\n    y: number;\r\n}\r\n\r\n/**\r\n * A record describing the size of a window.\r\n */\r\ninterface Size {\r\n    /** The width of the window. */\r\n    width: number;\r\n    /** The height of the window. */\r\n    height: number;\r\n}\r\n\r\n// Private field names.\r\nconst callerSym = Symbol(\"caller\");\r\n\r\nclass Window {\r\n    // Private fields.\r\n    private [callerSym]: (message: number, args?: any) => Promise<any>;\r\n\r\n    /**\r\n     * Initialises a window object with the specified name.\r\n     *\r\n     * @private\r\n     * @param name - The name of the target window.\r\n     */\r\n    constructor(name: string = '') {\r\n        this[callerSym] = newRuntimeCaller(objectNames.Window, name)\r\n\r\n        // bind instance method to make them easily usable in event handlers\r\n        for (const method of Object.getOwnPropertyNames(Window.prototype)) {\r\n            if (\r\n                method !== \"constructor\"\r\n                && typeof (this as any)[method] === \"function\"\r\n            ) {\r\n                (this as any)[method] = (this as any)[method].bind(this);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Gets the specified window.\r\n     *\r\n     * @param name - The name of the window to get.\r\n     * @returns The corresponding window object.\r\n     */\r\n    Get(name: string): Window {\r\n        return new Window(name);\r\n    }\r\n\r\n    /**\r\n     * Returns the absolute position of the window.\r\n     *\r\n     * @returns The current absolute position of the window.\r\n     */\r\n    Position(): Promise<Position> {\r\n        return this[callerSym](PositionMethod);\r\n    }\r\n\r\n    /**\r\n     * Centers the window on the screen.\r\n     */\r\n    Center(): Promise<void> {\r\n        return this[callerSym](CenterMethod);\r\n    }\r\n\r\n    /**\r\n     * Closes the window.\r\n     */\r\n    Close(): Promise<void> {\r\n        return this[callerSym](CloseMethod);\r\n    }\r\n\r\n    /**\r\n     * Disables min/max size constraints.\r\n     */\r\n    DisableSizeConstraints(): Promise<void> {\r\n        return this[callerSym](DisableSizeConstraintsMethod);\r\n    }\r\n\r\n    /**\r\n     * Enables min/max size constraints.\r\n     */\r\n    EnableSizeConstraints(): Promise<void> {\r\n        return this[callerSym](EnableSizeConstraintsMethod);\r\n    }\r\n\r\n    /**\r\n     * Focuses the window.\r\n     */\r\n    Focus(): Promise<void> {\r\n        return this[callerSym](FocusMethod);\r\n    }\r\n\r\n    /**\r\n     * Forces the window to reload the page assets.\r\n     */\r\n    ForceReload(): Promise<void> {\r\n        return this[callerSym](ForceReloadMethod);\r\n    }\r\n\r\n    /**\r\n     * Switches the window to fullscreen mode.\r\n     */\r\n    Fullscreen(): Promise<void> {\r\n        return this[callerSym](FullscreenMethod);\r\n    }\r\n\r\n    /**\r\n     * Returns the screen that the window is on.\r\n     *\r\n     * @returns The screen the window is currently on.\r\n     */\r\n    GetScreen(): Promise<Screen> {\r\n        return this[callerSym](GetScreenMethod);\r\n    }\r\n\r\n    /**\r\n     * Returns the current zoom level of the window.\r\n     *\r\n     * @returns The current zoom level.\r\n     */\r\n    GetZoom(): Promise<number> {\r\n        return this[callerSym](GetZoomMethod);\r\n    }\r\n\r\n    /**\r\n     * Returns the height of the window.\r\n     *\r\n     * @returns The current height of the window.\r\n     */\r\n    Height(): Promise<number> {\r\n        return this[callerSym](HeightMethod);\r\n    }\r\n\r\n    /**\r\n     * Hides the window.\r\n     */\r\n    Hide(): Promise<void> {\r\n        return this[callerSym](HideMethod);\r\n    }\r\n\r\n    /**\r\n     * Returns true if the window is focused.\r\n     *\r\n     * @returns Whether the window is currently focused.\r\n     */\r\n    IsFocused(): Promise<boolean> {\r\n        return this[callerSym](IsFocusedMethod);\r\n    }\r\n\r\n    /**\r\n     * Returns true if the window is fullscreen.\r\n     *\r\n     * @returns Whether the window is currently fullscreen.\r\n     */\r\n    IsFullscreen(): Promise<boolean> {\r\n        return this[callerSym](IsFullscreenMethod);\r\n    }\r\n\r\n    /**\r\n     * Returns true if the window is maximised.\r\n     *\r\n     * @returns Whether the window is currently maximised.\r\n     */\r\n    IsMaximised(): Promise<boolean> {\r\n        return this[callerSym](IsMaximisedMethod);\r\n    }\r\n\r\n    /**\r\n     * Returns true if the window is minimised.\r\n     *\r\n     * @returns Whether the window is currently minimised.\r\n     */\r\n    IsMinimised(): Promise<boolean> {\r\n        return this[callerSym](IsMinimisedMethod);\r\n    }\r\n\r\n    /**\r\n     * Maximises the window.\r\n     */\r\n    Maximise(): Promise<void> {\r\n        return this[callerSym](MaximiseMethod);\r\n    }\r\n\r\n    /**\r\n     * Minimises the window.\r\n     */\r\n    Minimise(): Promise<void> {\r\n        return this[callerSym](MinimiseMethod);\r\n    }\r\n\r\n    /**\r\n     * Returns the name of the window.\r\n     *\r\n     * @returns The name of the window.\r\n     */\r\n    Name(): Promise<string> {\r\n        return this[callerSym](NameMethod);\r\n    }\r\n\r\n    /**\r\n     * Opens the development tools pane.\r\n     */\r\n    OpenDevTools(): Promise<void> {\r\n        return this[callerSym](OpenDevToolsMethod);\r\n    }\r\n\r\n    /**\r\n     * Returns the relative position of the window to the screen.\r\n     *\r\n     * @returns The current relative position of the window.\r\n     */\r\n    RelativePosition(): Promise<Position> {\r\n        return this[callerSym](RelativePositionMethod);\r\n    }\r\n\r\n    /**\r\n     * Reloads the page assets.\r\n     */\r\n    Reload(): Promise<void> {\r\n        return this[callerSym](ReloadMethod);\r\n    }\r\n\r\n    /**\r\n     * Returns true if the window is resizable.\r\n     *\r\n     * @returns Whether the window is currently resizable.\r\n     */\r\n    Resizable(): Promise<boolean> {\r\n        return this[callerSym](ResizableMethod);\r\n    }\r\n\r\n    /**\r\n     * Restores the window to its previous state if it was previously minimised, maximised or fullscreen.\r\n     */\r\n    Restore(): Promise<void> {\r\n        return this[callerSym](RestoreMethod);\r\n    }\r\n\r\n    /**\r\n     * Sets the absolute position of the window.\r\n     *\r\n     * @param x - The desired horizontal absolute position of the window.\r\n     * @param y - The desired vertical absolute position of the window.\r\n     */\r\n    SetPosition(x: number, y: number): Promise<void> {\r\n        return this[callerSym](SetPositionMethod, { x, y });\r\n    }\r\n\r\n    /**\r\n     * Sets the window to be always on top.\r\n     *\r\n     * @param alwaysOnTop - Whether the window should stay on top.\r\n     */\r\n    SetAlwaysOnTop(alwaysOnTop: boolean): Promise<void> {\r\n        return this[callerSym](SetAlwaysOnTopMethod, { alwaysOnTop });\r\n    }\r\n\r\n    /**\r\n     * Sets the background colour of the window.\r\n     *\r\n     * @param r - The desired red component of the window background.\r\n     * @param g - The desired green component of the window background.\r\n     * @param b - The desired blue component of the window background.\r\n     * @param a - The desired alpha component of the window background.\r\n     */\r\n    SetBackgroundColour(r: number, g: number, b: number, a: number): Promise<void> {\r\n        return this[callerSym](SetBackgroundColourMethod, { r, g, b, a });\r\n    }\r\n\r\n    /**\r\n     * Removes the window frame and title bar.\r\n     *\r\n     * @param frameless - Whether the window should be frameless.\r\n     */\r\n    SetFrameless(frameless: boolean): Promise<void> {\r\n        return this[callerSym](SetFramelessMethod, { frameless });\r\n    }\r\n\r\n    /**\r\n     * Disables the system fullscreen button.\r\n     *\r\n     * @param enabled - Whether the fullscreen button should be enabled.\r\n     */\r\n    SetFullscreenButtonEnabled(enabled: boolean): Promise<void> {\r\n        return this[callerSym](SetFullscreenButtonEnabledMethod, { enabled });\r\n    }\r\n\r\n    /**\r\n     * Sets the maximum size of the window.\r\n     *\r\n     * @param width - The desired maximum width of the window.\r\n     * @param height - The desired maximum height of the window.\r\n     */\r\n    SetMaxSize(width: number, height: number): Promise<void> {\r\n        return this[callerSym](SetMaxSizeMethod, { width, height });\r\n    }\r\n\r\n    /**\r\n     * Sets the minimum size of the window.\r\n     *\r\n     * @param width - The desired minimum width of the window.\r\n     * @param height - The desired minimum height of the window.\r\n     */\r\n    SetMinSize(width: number, height: number): Promise<void> {\r\n        return this[callerSym](SetMinSizeMethod, { width, height });\r\n    }\r\n\r\n    /**\r\n     * Sets the relative position of the window to the screen.\r\n     *\r\n     * @param x - The desired horizontal relative position of the window.\r\n     * @param y - The desired vertical relative position of the window.\r\n     */\r\n    SetRelativePosition(x: number, y: number): Promise<void> {\r\n        return this[callerSym](SetRelativePositionMethod, { x, y });\r\n    }\r\n\r\n    /**\r\n     * Sets whether the window is resizable.\r\n     *\r\n     * @param resizable - Whether the window should be resizable.\r\n     */\r\n    SetResizable(resizable: boolean): Promise<void> {\r\n        return this[callerSym](SetResizableMethod, { resizable });\r\n    }\r\n\r\n    /**\r\n     * Sets the size of the window.\r\n     *\r\n     * @param width - The desired width of the window.\r\n     * @param height - The desired height of the window.\r\n     */\r\n    SetSize(width: number, height: number): Promise<void> {\r\n        return this[callerSym](SetSizeMethod, { width, height });\r\n    }\r\n\r\n    /**\r\n     * Sets the title of the window.\r\n     *\r\n     * @param title - The desired title of the window.\r\n     */\r\n    SetTitle(title: string): Promise<void> {\r\n        return this[callerSym](SetTitleMethod, { title });\r\n    }\r\n\r\n    /**\r\n     * Sets the zoom level of the window.\r\n     *\r\n     * @param zoom - The desired zoom level.\r\n     */\r\n    SetZoom(zoom: number): Promise<void> {\r\n        return this[callerSym](SetZoomMethod, { zoom });\r\n    }\r\n\r\n    /**\r\n     * Shows the window.\r\n     */\r\n    Show(): Promise<void> {\r\n        return this[callerSym](ShowMethod);\r\n    }\r\n\r\n    /**\r\n     * Returns the size of the window.\r\n     *\r\n     * @returns The current size of the window.\r\n     */\r\n    Size(): Promise<Size> {\r\n        return this[callerSym](SizeMethod);\r\n    }\r\n\r\n    /**\r\n     * Toggles the window between fullscreen and normal.\r\n     */\r\n    ToggleFullscreen(): Promise<void> {\r\n        return this[callerSym](ToggleFullscreenMethod);\r\n    }\r\n\r\n    /**\r\n     * Toggles the window between maximised and normal.\r\n     */\r\n    ToggleMaximise(): Promise<void> {\r\n        return this[callerSym](ToggleMaximiseMethod);\r\n    }\r\n\r\n    /**\r\n     * Toggles the window between frameless and normal.\r\n     */\r\n    ToggleFrameless(): Promise<void> {\r\n        return this[callerSym](ToggleFramelessMethod);\r\n    }\r\n\r\n    /**\r\n     * Un-fullscreens the window.\r\n     */\r\n    UnFullscreen(): Promise<void> {\r\n        return this[callerSym](UnFullscreenMethod);\r\n    }\r\n\r\n    /**\r\n     * Un-maximises the window.\r\n     */\r\n    UnMaximise(): Promise<void> {\r\n        return this[callerSym](UnMaximiseMethod);\r\n    }\r\n\r\n    /**\r\n     * Un-minimises the window.\r\n     */\r\n    UnMinimise(): Promise<void> {\r\n        return this[callerSym](UnMinimiseMethod);\r\n    }\r\n\r\n    /**\r\n     * Returns the width of the window.\r\n     *\r\n     * @returns The current width of the window.\r\n     */\r\n    Width(): Promise<number> {\r\n        return this[callerSym](WidthMethod);\r\n    }\r\n\r\n    /**\r\n     * Zooms the window.\r\n     */\r\n    Zoom(): Promise<void> {\r\n        return this[callerSym](ZoomMethod);\r\n    }\r\n\r\n    /**\r\n     * Increases the zoom level of the webview content.\r\n     */\r\n    ZoomIn(): Promise<void> {\r\n        return this[callerSym](ZoomInMethod);\r\n    }\r\n\r\n    /**\r\n     * Decreases the zoom level of the webview content.\r\n     */\r\n    ZoomOut(): Promise<void> {\r\n        return this[callerSym](ZoomOutMethod);\r\n    }\r\n\r\n    /**\r\n     * Resets the zoom level of the webview content.\r\n     */\r\n    ZoomReset(): Promise<void> {\r\n        return this[callerSym](ZoomResetMethod);\r\n    }\r\n\r\n    /**\r\n     * Handles file drops originating from platform-specific code (e.g., macOS native drag-and-drop).\r\n     * Gathers information about the drop target element and sends it back to the Go backend.\r\n     *\r\n     * @param filenames - An array of file paths (strings) that were dropped.\r\n     * @param x - The x-coordinate of the drop event.\r\n     * @param y - The y-coordinate of the drop event.\r\n     */\r\n    HandlePlatformFileDrop(filenames: string[], x: number, y: number): void {\r\n        const element = document.elementFromPoint(x, y);\r\n\r\n        // NEW: Check if the drop target is a valid dropzone\r\n        const dropzoneTarget = getDropzoneElement(element);\r\n\r\n        if (!dropzoneTarget) {\r\n            console.log(`Wails Runtime: Drop on element (or no element) at ${x},${y} which is not a designated dropzone. Ignoring. Element:`, element);\r\n            // No need to call backend if not a valid dropzone target\r\n            return;\r\n        }\r\n\r\n        console.log(`Wails Runtime: Drop on designated dropzone. Element at (${x}, ${y}):`, element, 'Effective dropzone:', dropzoneTarget);\r\n        const elementDetails = {\r\n            id: dropzoneTarget.id,\r\n            classList: Array.from(dropzoneTarget.classList),\r\n            attributes: {} as { [key: string]: string },\r\n        };\r\n        for (let i = 0; i < dropzoneTarget.attributes.length; i++) {\r\n            const attr = dropzoneTarget.attributes[i];\r\n            elementDetails.attributes[attr.name] = attr.value;\r\n        }\r\n\r\n        const payload = {\r\n            filenames,\r\n            x,\r\n            y,\r\n            elementDetails,\r\n        };\r\n\r\n        this[callerSym](WindowDropZoneDropped, payload);\r\n    }\r\n}\r\n\r\n/**\r\n * The window within which the script is running.\r\n */\r\nconst thisWindow = new Window('');\r\n\r\n// NEW: Global Drag Event Listeners\r\nfunction setupGlobalDropzoneListeners() {\r\n    const docElement = document.documentElement;\r\n    let dragEnterCounter = 0; // To handle dragenter/dragleave on child elements\r\n\r\n    docElement.addEventListener('dragenter', (event) => {\r\n        event.preventDefault();\r\n        if (event.dataTransfer && event.dataTransfer.types.includes('Files')) {\r\n            dragEnterCounter++;\r\n            const targetElement = document.elementFromPoint(event.clientX, event.clientY);\r\n            const dropzone = getDropzoneElement(targetElement);\r\n\r\n            // Clear previous hover regardless, then apply new if valid\r\n            if (currentHoveredDropzone && currentHoveredDropzone !== dropzone) {\r\n                currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS);\r\n            }\r\n\r\n            if (dropzone) {\r\n                dropzone.classList.add(DROPZONE_HOVER_CLASS);\r\n                event.dataTransfer.dropEffect = 'copy';\r\n                currentHoveredDropzone = dropzone;\r\n            } else {\r\n                event.dataTransfer.dropEffect = 'none';\r\n                currentHoveredDropzone = null; // Ensure it's cleared if no dropzone found\r\n            }\r\n        }\r\n    }, false);\r\n\r\n    docElement.addEventListener('dragover', (event) => {\r\n        event.preventDefault(); // Necessary to allow drop\r\n        if (event.dataTransfer && event.dataTransfer.types.includes('Files')) {\r\n            // No need to query elementFromPoint again if already handled by dragenter correctly\r\n            // Just ensure dropEffect is continuously set based on currentHoveredDropzone\r\n            if (currentHoveredDropzone) {\r\n                 // Re-apply class just in case it was removed by some other JS\r\n                if(!currentHoveredDropzone.classList.contains(DROPZONE_HOVER_CLASS)) {\r\n                    currentHoveredDropzone.classList.add(DROPZONE_HOVER_CLASS);\r\n                }\r\n                event.dataTransfer.dropEffect = 'copy';\r\n            } else {\r\n                event.dataTransfer.dropEffect = 'none';\r\n            }\r\n        }\r\n    }, false);\r\n\r\n    docElement.addEventListener('dragleave', (event) => {\r\n        event.preventDefault();\r\n        if (event.dataTransfer && event.dataTransfer.types.includes('Files')) {\r\n            dragEnterCounter--;\r\n            // Only remove hover if drag truly left the window or the last dropzone\r\n            if (dragEnterCounter === 0 || event.relatedTarget === null || (currentHoveredDropzone && !currentHoveredDropzone.contains(event.relatedTarget as Node))) {\r\n                if (currentHoveredDropzone) {\r\n                    currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS);\r\n                    currentHoveredDropzone = null;\r\n                }\r\n                dragEnterCounter = 0; // Reset counter if it went negative or left window\r\n            }\r\n        }\r\n    }, false);\r\n\r\n    docElement.addEventListener('drop', (event) => {\r\n        event.preventDefault(); // Prevent default browser file handling\r\n        dragEnterCounter = 0; // Reset counter\r\n        if (currentHoveredDropzone) {\r\n            currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS);\r\n            currentHoveredDropzone = null;\r\n        }\r\n        // The actual drop processing is initiated by the native side calling HandlePlatformFileDrop\r\n        // HandlePlatformFileDrop will then check if the drop was on a valid zone.\r\n    }, false);\r\n}\r\n\r\n// Initialize listeners when the script loads\r\nif (typeof window !== \"undefined\" && typeof document !== \"undefined\") {\r\n    setupGlobalDropzoneListeners();\r\n}\r\n\r\nexport default thisWindow;\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\nimport * as Runtime from \"../@wailsio/runtime/src\";\r\n\r\n// NOTE: the following methods MUST be imported explicitly because of how esbuild injection works\r\nimport { Enable as EnableWML } from \"../@wailsio/runtime/src/wml\";\r\nimport { debugLog } from \"../@wailsio/runtime/src/utils\";\r\n\r\nwindow.wails = Runtime;\r\nEnableWML();\r\n\r\nif (DEBUG) {\r\n    debugLog(\"Wails Runtime Loaded\")\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\r\n\r\nconst call = newRuntimeCaller(objectNames.System);\r\n\r\nconst SystemIsDarkMode = 0;\r\nconst SystemEnvironment = 1;\r\nconst ApplicationFilesDroppedWithContext = 100; // New method ID for enriched drop event\r\n\r\nconst _invoke = (function () {\r\n    try {\r\n        if ((window as any).chrome?.webview?.postMessage) {\r\n            return (window as any).chrome.webview.postMessage.bind((window as any).chrome.webview);\r\n        } else if ((window as any).webkit?.messageHandlers?.['external']?.postMessage) {\r\n            return (window as any).webkit.messageHandlers['external'].postMessage.bind((window as any).webkit.messageHandlers['external']);\r\n        }\r\n    } catch(e) {}\r\n\r\n    console.warn('\\n%c\u26A0\uFE0F Browser Environment Detected %c\\n\\n%cOnly UI previews are available in the browser. For full functionality, please run the application in desktop mode.\\nMore information at: https://v3.wails.io/learn/build/#using-a-browser-for-development\\n',\r\n        'background: #ffffff; color: #000000; font-weight: bold; padding: 4px 8px; border-radius: 4px; border: 2px solid #000000;',\r\n        'background: transparent;',\r\n        'color: #ffffff; font-style: italic; font-weight: bold;');\r\n    return null;\r\n})();\r\n\r\nexport function invoke(msg: any): void {\r\n    _invoke?.(msg);\r\n}\r\n\r\n/**\r\n * Retrieves the system dark mode status.\r\n *\r\n * @returns A promise that resolves to a boolean value indicating if the system is in dark mode.\r\n */\r\nexport function IsDarkMode(): Promise<boolean> {\r\n    return call(SystemIsDarkMode);\r\n}\r\n\r\n/**\r\n * Fetches the capabilities of the application from the server.\r\n *\r\n * @returns A promise that resolves to an object containing the capabilities.\r\n */\r\nexport async function Capabilities(): Promise<Record<string, any>> {\r\n    let response = await fetch(\"/wails/capabilities\");\r\n    if (response.ok) {\r\n        return response.json();\r\n    } else {\r\n        throw new Error(\"could not fetch capabilities: \" + response.statusText);\r\n    }\r\n}\r\n\r\nexport interface OSInfo {\r\n    /** The branding of the OS. */\r\n    Branding: string;\r\n    /** The ID of the OS. */\r\n    ID: string;\r\n    /** The name of the OS. */\r\n    Name: string;\r\n    /** The version of the OS. */\r\n    Version: string;\r\n}\r\n\r\nexport interface EnvironmentInfo {\r\n    /** The architecture of the system. */\r\n    Arch: string;\r\n    /** True if the application is running in debug mode, otherwise false. */\r\n    Debug: boolean;\r\n    /** The operating system in use. */\r\n    OS: string;\r\n    /** Details of the operating system. */\r\n    OSInfo: OSInfo;\r\n    /** Additional platform information. */\r\n    PlatformInfo: Record<string, any>;\r\n}\r\n\r\n/**\r\n * Retrieves environment details.\r\n *\r\n * @returns A promise that resolves to an object containing OS and system architecture.\r\n */\r\nexport function Environment(): Promise<EnvironmentInfo> {\r\n    return call(SystemEnvironment);\r\n}\r\n\r\n/**\r\n * Checks if the current operating system is Windows.\r\n *\r\n * @return True if the operating system is Windows, otherwise false.\r\n */\r\nexport function IsWindows(): boolean {\r\n    return window._wails.environment.OS === \"windows\";\r\n}\r\n\r\n/**\r\n * Checks if the current operating system is Linux.\r\n *\r\n * @returns Returns true if the current operating system is Linux, false otherwise.\r\n */\r\nexport function IsLinux(): boolean {\r\n    return window._wails.environment.OS === \"linux\";\r\n}\r\n\r\n/**\r\n * Checks if the current environment is a macOS operating system.\r\n *\r\n * @returns True if the environment is macOS, false otherwise.\r\n */\r\nexport function IsMac(): boolean {\r\n    return window._wails.environment.OS === \"darwin\";\r\n}\r\n\r\n/**\r\n * Checks if the current environment architecture is AMD64.\r\n *\r\n * @returns True if the current environment architecture is AMD64, false otherwise.\r\n */\r\nexport function IsAMD64(): boolean {\r\n    return window._wails.environment.Arch === \"amd64\";\r\n}\r\n\r\n/**\r\n * Checks if the current architecture is ARM.\r\n *\r\n * @returns True if the current architecture is ARM, false otherwise.\r\n */\r\nexport function IsARM(): boolean {\r\n    return window._wails.environment.Arch === \"arm\";\r\n}\r\n\r\n/**\r\n * Checks if the current environment is ARM64 architecture.\r\n *\r\n * @returns Returns true if the environment is ARM64 architecture, otherwise returns false.\r\n */\r\nexport function IsARM64(): boolean {\r\n    return window._wails.environment.Arch === \"arm64\";\r\n}\r\n\r\n/**\r\n * Reports whether the app is being run in debug mode.\r\n *\r\n * @returns True if the app is being run in debug mode.\r\n */\r\nexport function IsDebug(): boolean {\r\n    return Boolean(window._wails.environment.Debug);\r\n}\r\n\r\n/**\r\n * Handles file drops originating from platform-specific code (e.g., macOS native drag-and-drop).\r\n * Gathers information about the drop target element and sends it back to the Go backend.\r\n *\r\n * @param filenames - An array of file paths (strings) that were dropped.\r\n * @param x - The x-coordinate of the drop event.\r\n * @param y - The y-coordinate of the drop event.\r\n */\r\nexport function HandlePlatformFileDrop(filenames: string[], x: number, y: number): void {\r\n    const element = document.elementFromPoint(x, y);\r\n    const elementId = element ? element.id : '';\r\n    const classList = element ? Array.from(element.classList) : [];\r\n\r\n    const payload = {\r\n        filenames,\r\n        x,\r\n        y,\r\n        elementId,\r\n        classList,\r\n    };\r\n\r\n    call(ApplicationFilesDroppedWithContext, payload)\r\n        .then(() => {\r\n            // Optional: Log success or handle if needed\r\n            console.log(\"Platform file drop processed and sent to Go.\");\r\n        })\r\n        .catch(err => {\r\n            // Optional: Log error\r\n            console.error(\"Error sending platform file drop to Go:\", err);\r\n        });\r\n}\r\n\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\r\nimport { IsDebug } from \"./system.js\";\r\nimport { eventTarget } from \"./utils\";\r\n\r\n// setup\r\nwindow.addEventListener('contextmenu', contextMenuHandler);\r\n\r\nconst call = newRuntimeCaller(objectNames.ContextMenu);\r\n\r\nconst ContextMenuOpen = 0;\r\n\r\nfunction openContextMenu(id: string, x: number, y: number, data: any): void {\r\n    void call(ContextMenuOpen, {id, x, y, data});\r\n}\r\n\r\nfunction contextMenuHandler(event: MouseEvent) {\r\n    const target = eventTarget(event);\r\n\r\n    // Check for custom context menu\r\n    const customContextMenu = window.getComputedStyle(target).getPropertyValue(\"--custom-contextmenu\").trim();\r\n\r\n    if (customContextMenu) {\r\n        event.preventDefault();\r\n        const data = window.getComputedStyle(target).getPropertyValue(\"--custom-contextmenu-data\");\r\n        openContextMenu(customContextMenu, event.clientX, event.clientY, data);\r\n    } else {\r\n        processDefaultContextMenu(event, target);\r\n    }\r\n}\r\n\r\n\r\n/*\r\n--default-contextmenu: auto; (default) will show the default context menu if contentEditable is true OR text has been selected OR element is input or textarea\r\n--default-contextmenu: show; will always show the default context menu\r\n--default-contextmenu: hide; will always hide the default context menu\r\n\r\nThis rule is inherited like normal CSS rules, so nesting works as expected\r\n*/\r\nfunction processDefaultContextMenu(event: MouseEvent, target: HTMLElement) {\r\n    // Debug builds always show the menu\r\n    if (IsDebug()) {\r\n        return;\r\n    }\r\n\r\n    // Process default context menu\r\n    switch (window.getComputedStyle(target).getPropertyValue(\"--default-contextmenu\").trim()) {\r\n        case 'show':\r\n            return;\r\n        case 'hide':\r\n            event.preventDefault();\r\n            return;\r\n    }\r\n\r\n    // Check if contentEditable is true\r\n    if (target.isContentEditable) {\r\n        return;\r\n    }\r\n\r\n    // Check if text has been selected\r\n    const selection = window.getSelection();\r\n    const hasSelection = selection && selection.toString().length > 0;\r\n    if (hasSelection) {\r\n        for (let i = 0; i < selection.rangeCount; i++) {\r\n            const range = selection.getRangeAt(i);\r\n            const rects = range.getClientRects();\r\n            for (let j = 0; j < rects.length; j++) {\r\n                const rect = rects[j];\r\n                if (document.elementFromPoint(rect.left, rect.top) === target) {\r\n                    return;\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    // Check if tag is input or textarea.\r\n    if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {\r\n        if (hasSelection || (!target.readOnly && !target.disabled)) {\r\n            return;\r\n        }\r\n    }\r\n\r\n    // hide default context menu\r\n    event.preventDefault();\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/**\r\n * Retrieves the value associated with the specified key from the flag map.\r\n *\r\n * @param key - The key to retrieve the value for.\r\n * @return The value associated with the specified key.\r\n */\r\nexport function GetFlag(key: string): any {\r\n    try {\r\n        return window._wails.flags[key];\r\n    } catch (e) {\r\n        throw new Error(\"Unable to retrieve flag '\" + key + \"': \" + e, { cause: e });\r\n    }\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\nimport { invoke, IsWindows } from \"./system.js\";\r\nimport { GetFlag } from \"./flags.js\";\r\nimport { canTrackButtons, eventTarget } from \"./utils.js\";\r\n\r\n// Setup\r\nlet canDrag = false;\r\nlet dragging = false;\r\n\r\nlet resizable = false;\r\nlet canResize = false;\r\nlet resizing = false;\r\nlet resizeEdge: string = \"\";\r\nlet defaultCursor = \"auto\";\r\n\r\nlet buttons = 0;\r\nconst buttonsTracked = canTrackButtons();\r\n\r\nwindow._wails = window._wails || {};\r\nwindow._wails.setResizable = (value: boolean): void => {\r\n    resizable = value;\r\n    if (!resizable) {\r\n        // Stop resizing if in progress.\r\n        canResize = resizing = false;\r\n        setResize();\r\n    }\r\n};\r\n\r\nwindow.addEventListener('mousedown', update, { capture: true });\r\nwindow.addEventListener('mousemove', update, { capture: true });\r\nwindow.addEventListener('mouseup', update, { capture: true });\r\nfor (const ev of ['click', 'contextmenu', 'dblclick']) {\r\n    window.addEventListener(ev, suppressEvent, { capture: true });\r\n}\r\n\r\nfunction suppressEvent(event: Event) {\r\n    // Suppress click events while resizing or dragging.\r\n    if (dragging || resizing) {\r\n        event.stopImmediatePropagation();\r\n        event.stopPropagation();\r\n        event.preventDefault();\r\n    }\r\n}\r\n\r\n// Use constants to avoid comparing strings multiple times.\r\nconst MouseDown = 0;\r\nconst MouseUp   = 1;\r\nconst MouseMove = 2;\r\n\r\nfunction update(event: MouseEvent) {\r\n    // Windows suppresses mouse events at the end of dragging or resizing,\r\n    // so we need to be smart and synthesize button events.\r\n\r\n    let eventType: number, eventButtons = event.buttons;\r\n    switch (event.type) {\r\n        case 'mousedown':\r\n            eventType = MouseDown;\r\n            if (!buttonsTracked) { eventButtons = buttons | (1 << event.button); }\r\n            break;\r\n        case 'mouseup':\r\n            eventType = MouseUp;\r\n            if (!buttonsTracked) { eventButtons = buttons & ~(1 << event.button); }\r\n            break;\r\n        default:\r\n            eventType = MouseMove;\r\n            if (!buttonsTracked) { eventButtons = buttons; }\r\n            break;\r\n    }\r\n\r\n    let released = buttons & ~eventButtons;\r\n    let pressed = eventButtons & ~buttons;\r\n\r\n    buttons = eventButtons;\r\n\r\n    // Synthesize a release-press sequence if we detect a press of an already pressed button.\r\n    if (eventType === MouseDown && !(pressed & event.button)) {\r\n        released |= (1 << event.button);\r\n        pressed |= (1 << event.button);\r\n    }\r\n\r\n    // Suppress all button events during dragging and resizing,\r\n    // unless this is a mouseup event that is ending a drag action.\r\n    if (\r\n        eventType !== MouseMove // Fast path for mousemove\r\n        && resizing\r\n        || (\r\n            dragging\r\n            && (\r\n                eventType === MouseDown\r\n                || event.button !== 0\r\n            )\r\n        )\r\n    ) {\r\n        event.stopImmediatePropagation();\r\n        event.stopPropagation();\r\n        event.preventDefault();\r\n    }\r\n\r\n    // Handle releases\r\n    if (released & 1) { primaryUp(event); }\r\n    // Handle presses\r\n    if (pressed & 1) { primaryDown(event); }\r\n\r\n    // Handle mousemove\r\n    if (eventType === MouseMove) { onMouseMove(event); };\r\n}\r\n\r\nfunction primaryDown(event: MouseEvent): void {\r\n    // Reset readiness state.\r\n    canDrag = false;\r\n    canResize = false;\r\n\r\n    // Ignore repeated clicks on macOS and Linux.\r\n    if (!IsWindows()) {\r\n        if (event.type === 'mousedown' && event.button === 0 && event.detail !== 1) {\r\n            return;\r\n        }\r\n    }\r\n\r\n    if (resizeEdge) {\r\n        // Ready to resize if the primary button was pressed for the first time.\r\n        canResize = true;\r\n        // Do not start drag operations when on resize edges.\r\n        return;\r\n    }\r\n\r\n    // Retrieve target element\r\n    const target = eventTarget(event);\r\n\r\n    // Ready to drag if the primary button was pressed for the first time on a draggable element.\r\n    // Ignore clicks on the scrollbar.\r\n    const style = window.getComputedStyle(target);\r\n    canDrag = (\r\n        style.getPropertyValue(\"--wails-draggable\").trim() === \"drag\"\r\n        && (\r\n            event.offsetX - parseFloat(style.paddingLeft) < target.clientWidth\r\n            && event.offsetY - parseFloat(style.paddingTop) < target.clientHeight\r\n        )\r\n    );\r\n}\r\n\r\nfunction primaryUp(event: MouseEvent) {\r\n    // Stop dragging and resizing.\r\n    canDrag = false;\r\n    dragging = false;\r\n    canResize = false;\r\n    resizing = false;\r\n}\r\n\r\nconst cursorForEdge = Object.freeze({\r\n    \"se-resize\": \"nwse-resize\",\r\n    \"sw-resize\": \"nesw-resize\",\r\n    \"nw-resize\": \"nwse-resize\",\r\n    \"ne-resize\": \"nesw-resize\",\r\n    \"w-resize\": \"ew-resize\",\r\n    \"n-resize\": \"ns-resize\",\r\n    \"s-resize\": \"ns-resize\",\r\n    \"e-resize\": \"ew-resize\",\r\n})\r\n\r\nfunction setResize(edge?: keyof typeof cursorForEdge): void {\r\n    if (edge) {\r\n        if (!resizeEdge) { defaultCursor = document.body.style.cursor; }\r\n        document.body.style.cursor = cursorForEdge[edge];\r\n    } else if (!edge && resizeEdge) {\r\n        document.body.style.cursor = defaultCursor;\r\n    }\r\n\r\n    resizeEdge = edge || \"\";\r\n}\r\n\r\nfunction onMouseMove(event: MouseEvent): void {\r\n    if (canResize && resizeEdge) {\r\n        // Start resizing.\r\n        resizing = true;\r\n        invoke(\"wails:resize:\" + resizeEdge);\r\n    } else if (canDrag) {\r\n        // Start dragging.\r\n        dragging = true;\r\n        invoke(\"wails:drag\");\r\n    }\r\n\r\n    if (dragging || resizing) {\r\n        // Either drag or resize is ongoing,\r\n        // reset readiness and stop processing.\r\n        canDrag = canResize = false;\r\n        return;\r\n    }\r\n\r\n    if (!resizable || !IsWindows()) {\r\n        if (resizeEdge) { setResize(); }\r\n        return;\r\n    }\r\n\r\n    const resizeHandleHeight = GetFlag(\"system.resizeHandleHeight\") || 5;\r\n    const resizeHandleWidth = GetFlag(\"system.resizeHandleWidth\") || 5;\r\n\r\n    // Extra pixels for the corner areas.\r\n    const cornerExtra = GetFlag(\"resizeCornerExtra\") || 10;\r\n\r\n    const rightBorder = (window.outerWidth - event.clientX) < resizeHandleWidth;\r\n    const leftBorder = event.clientX < resizeHandleWidth;\r\n    const topBorder = event.clientY < resizeHandleHeight;\r\n    const bottomBorder = (window.outerHeight - event.clientY) < resizeHandleHeight;\r\n\r\n    // Adjust for corner areas.\r\n    const rightCorner = (window.outerWidth - event.clientX) < (resizeHandleWidth + cornerExtra);\r\n    const leftCorner = event.clientX < (resizeHandleWidth + cornerExtra);\r\n    const topCorner = event.clientY < (resizeHandleHeight + cornerExtra);\r\n    const bottomCorner = (window.outerHeight - event.clientY) < (resizeHandleHeight + cornerExtra);\r\n\r\n    if (!leftCorner && !topCorner && !bottomCorner && !rightCorner) {\r\n        // Optimisation: out of all corner areas implies out of borders.\r\n        setResize();\r\n    }\r\n    // Detect corners.\r\n    else if (rightCorner && bottomCorner) setResize(\"se-resize\");\r\n    else if (leftCorner && bottomCorner) setResize(\"sw-resize\");\r\n    else if (leftCorner && topCorner) setResize(\"nw-resize\");\r\n    else if (topCorner && rightCorner) setResize(\"ne-resize\");\r\n    // Detect borders.\r\n    else if (leftBorder) setResize(\"w-resize\");\r\n    else if (topBorder) setResize(\"n-resize\");\r\n    else if (bottomBorder) setResize(\"s-resize\");\r\n    else if (rightBorder) setResize(\"e-resize\");\r\n    // Out of border area.\r\n    else setResize();\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\r\nconst call = newRuntimeCaller(objectNames.Application);\r\n\r\nconst HideMethod = 0;\r\nconst ShowMethod = 1;\r\nconst QuitMethod = 2;\r\n\r\n/**\r\n * Hides a certain method by calling the HideMethod function.\r\n */\r\nexport function Hide(): Promise<void> {\r\n    return call(HideMethod);\r\n}\r\n\r\n/**\r\n * Calls the ShowMethod and returns the result.\r\n */\r\nexport function Show(): Promise<void> {\r\n    return call(ShowMethod);\r\n}\r\n\r\n/**\r\n * Calls the QuitMethod to terminate the program.\r\n */\r\nexport function Quit(): Promise<void> {\r\n    return call(QuitMethod);\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\nimport { CancellablePromise, type CancellablePromiseWithResolvers } from \"./cancellable.js\";\r\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\r\nimport { nanoid } from \"./nanoid.js\";\r\n\r\n// Setup\r\nwindow._wails = window._wails || {};\r\nwindow._wails.callResultHandler = resultHandler;\r\nwindow._wails.callErrorHandler = errorHandler;\r\n\r\ntype PromiseResolvers = Omit<CancellablePromiseWithResolvers<any>, \"promise\" | \"oncancelled\">\r\n\r\nconst call = newRuntimeCaller(objectNames.Call);\r\nconst cancelCall = newRuntimeCaller(objectNames.CancelCall);\r\nconst callResponses = new Map<string, PromiseResolvers>();\r\n\r\nconst CallBinding = 0;\r\nconst CancelMethod = 0\r\n\r\n/**\r\n * Holds all required information for a binding call.\r\n * May provide either a method ID or a method name, but not both.\r\n */\r\nexport type CallOptions = {\r\n    /** The numeric ID of the bound method to call. */\r\n    methodID: number;\r\n    /** The fully qualified name of the bound method to call. */\r\n    methodName?: never;\r\n    /** Arguments to be passed into the bound method. */\r\n    args: any[];\r\n} | {\r\n    /** The numeric ID of the bound method to call. */\r\n    methodID?: never;\r\n    /** The fully qualified name of the bound method to call. */\r\n    methodName: string;\r\n    /** Arguments to be passed into the bound method. */\r\n    args: any[];\r\n};\r\n\r\n/**\r\n * Exception class that will be thrown in case the bound method returns an error.\r\n * The value of the {@link RuntimeError#name} property is \"RuntimeError\".\r\n */\r\nexport class RuntimeError extends Error {\r\n    /**\r\n     * Constructs a new RuntimeError instance.\r\n     * @param message - The error message.\r\n     * @param options - Options to be forwarded to the Error constructor.\r\n     */\r\n    constructor(message?: string, options?: ErrorOptions) {\r\n        super(message, options);\r\n        this.name = \"RuntimeError\";\r\n    }\r\n}\r\n\r\n/**\r\n * Handles the result of a call request.\r\n *\r\n * @param id - The id of the request to handle the result for.\r\n * @param data - The result data of the request.\r\n * @param isJSON - Indicates whether the data is JSON or not.\r\n */\r\nfunction resultHandler(id: string, data: string, isJSON: boolean): void {\r\n    const resolvers = getAndDeleteResponse(id);\r\n    if (!resolvers) {\r\n        return;\r\n    }\r\n\r\n    if (!data) {\r\n        resolvers.resolve(undefined);\r\n    } else if (!isJSON) {\r\n        resolvers.resolve(data);\r\n    } else {\r\n        try {\r\n            resolvers.resolve(JSON.parse(data));\r\n        } catch (err: any) {\r\n            resolvers.reject(new TypeError(\"could not parse result: \" + err.message, { cause: err }));\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Handles the error from a call request.\r\n *\r\n * @param id - The id of the promise handler.\r\n * @param data - The error data to reject the promise handler with.\r\n * @param isJSON - Indicates whether the data is JSON or not.\r\n */\r\nfunction errorHandler(id: string, data: string, isJSON: boolean): void {\r\n    const resolvers = getAndDeleteResponse(id);\r\n    if (!resolvers) {\r\n        return;\r\n    }\r\n\r\n    if (!isJSON) {\r\n        resolvers.reject(new Error(data));\r\n    } else {\r\n        let error: any;\r\n        try {\r\n            error = JSON.parse(data);\r\n        } catch (err: any) {\r\n            resolvers.reject(new TypeError(\"could not parse error: \" + err.message, { cause: err }));\r\n            return;\r\n        }\r\n\r\n        let options: ErrorOptions = {};\r\n        if (error.cause) {\r\n            options.cause = error.cause;\r\n        }\r\n\r\n        let exception;\r\n        switch (error.kind) {\r\n            case \"ReferenceError\":\r\n                exception = new ReferenceError(error.message, options);\r\n                break;\r\n            case \"TypeError\":\r\n                exception = new TypeError(error.message, options);\r\n                break;\r\n            case \"RuntimeError\":\r\n                exception = new RuntimeError(error.message, options);\r\n                break;\r\n            default:\r\n                exception = new Error(error.message, options);\r\n                break;\r\n        }\r\n\r\n        resolvers.reject(exception);\r\n    }\r\n}\r\n\r\n/**\r\n * Retrieves and removes the response associated with the given ID from the callResponses map.\r\n *\r\n * @param id - The ID of the response to be retrieved and removed.\r\n * @returns The response object associated with the given ID, if any.\r\n */\r\nfunction getAndDeleteResponse(id: string): PromiseResolvers | undefined {\r\n    const response = callResponses.get(id);\r\n    callResponses.delete(id);\r\n    return response;\r\n}\r\n\r\n/**\r\n * Generates a unique ID using the nanoid library.\r\n *\r\n * @returns A unique ID that does not exist in the callResponses set.\r\n */\r\nfunction generateID(): string {\r\n    let result;\r\n    do {\r\n        result = nanoid();\r\n    } while (callResponses.has(result));\r\n    return result;\r\n}\r\n\r\n/**\r\n * Call a bound method according to the given call options.\r\n *\r\n * In case of failure, the returned promise will reject with an exception\r\n * among ReferenceError (unknown method), TypeError (wrong argument count or type),\r\n * {@link RuntimeError} (method returned an error), or other (network or internal errors).\r\n * The exception might have a \"cause\" field with the value returned\r\n * by the application- or service-level error marshaling functions.\r\n *\r\n * @param options - A method call descriptor.\r\n * @returns The result of the call.\r\n */\r\nexport function Call(options: CallOptions): CancellablePromise<any> {\r\n    const id = generateID();\r\n\r\n    const result = CancellablePromise.withResolvers<any>();\r\n    callResponses.set(id, { resolve: result.resolve, reject: result.reject });\r\n\r\n    const request = call(CallBinding, Object.assign({ \"call-id\": id }, options));\r\n    let running = false;\r\n\r\n    request.then(() => {\r\n        running = true;\r\n    }, (err) => {\r\n        callResponses.delete(id);\r\n        result.reject(err);\r\n    });\r\n\r\n    const cancel = () => {\r\n        callResponses.delete(id);\r\n        return cancelCall(CancelMethod, {\"call-id\": id}).catch((err) => {\r\n            console.error(\"Error while requesting binding call cancellation:\", err);\r\n        });\r\n    };\r\n\r\n    result.oncancelled = () => {\r\n        if (running) {\r\n            return cancel();\r\n        } else {\r\n            return request.then(cancel);\r\n        }\r\n    };\r\n\r\n    return result.promise;\r\n}\r\n\r\n/**\r\n * Calls a bound method by name with the specified arguments.\r\n * See {@link Call} for details.\r\n *\r\n * @param methodName - The name of the method in the format 'package.struct.method'.\r\n * @param args - The arguments to pass to the method.\r\n * @returns The result of the method call.\r\n */\r\nexport function ByName(methodName: string, ...args: any[]): CancellablePromise<any> {\r\n    return Call({ methodName, args });\r\n}\r\n\r\n/**\r\n * Calls a method by its numeric ID with the specified arguments.\r\n * See {@link Call} for details.\r\n *\r\n * @param methodID - The ID of the method to call.\r\n * @param args - The arguments to pass to the method.\r\n * @return The result of the method call.\r\n */\r\nexport function ByID(methodID: number, ...args: any[]): CancellablePromise<any> {\r\n    return Call({ methodID, args });\r\n}\r\n", "// Source: https://github.com/inspect-js/is-callable\r\n\r\n// The MIT License (MIT)\r\n//\r\n// Copyright (c) 2015 Jordan Harband\r\n//\r\n// Permission is hereby granted, free of charge, to any person obtaining a copy\r\n// of this software and associated documentation files (the \"Software\"), to deal\r\n// in the Software without restriction, including without limitation the rights\r\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n// copies of the Software, and to permit persons to whom the Software is\r\n// furnished to do so, subject to the following conditions:\r\n//\r\n// The above copyright notice and this permission notice shall be included in all\r\n// copies or substantial portions of the Software.\r\n//\r\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n// SOFTWARE.\r\n\r\nvar fnToStr = Function.prototype.toString;\r\nvar reflectApply: typeof Reflect.apply | false | null = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;\r\nvar badArrayLike: any;\r\nvar isCallableMarker: any;\r\nif (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {\r\n    try {\r\n        badArrayLike = Object.defineProperty({}, 'length', {\r\n            get: function () {\r\n                throw isCallableMarker;\r\n            }\r\n        });\r\n        isCallableMarker = {};\r\n        // eslint-disable-next-line no-throw-literal\r\n        reflectApply(function () { throw 42; }, null, badArrayLike);\r\n    } catch (_) {\r\n        if (_ !== isCallableMarker) {\r\n            reflectApply = null;\r\n        }\r\n    }\r\n} else {\r\n    reflectApply = null;\r\n}\r\n\r\nvar constructorRegex = /^\\s*class\\b/;\r\nvar isES6ClassFn = function isES6ClassFunction(value: any): boolean {\r\n    try {\r\n        var fnStr = fnToStr.call(value);\r\n        return constructorRegex.test(fnStr);\r\n    } catch (e) {\r\n        return false; // not a function\r\n    }\r\n};\r\n\r\nvar tryFunctionObject = function tryFunctionToStr(value: any): boolean {\r\n    try {\r\n        if (isES6ClassFn(value)) { return false; }\r\n        fnToStr.call(value);\r\n        return true;\r\n    } catch (e) {\r\n        return false;\r\n    }\r\n};\r\nvar toStr = Object.prototype.toString;\r\nvar objectClass = '[object Object]';\r\nvar fnClass = '[object Function]';\r\nvar genClass = '[object GeneratorFunction]';\r\nvar ddaClass = '[object HTMLAllCollection]'; // IE 11\r\nvar ddaClass2 = '[object HTML document.all class]';\r\nvar ddaClass3 = '[object HTMLCollection]'; // IE 9-10\r\nvar hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`\r\n\r\nvar isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing\r\n\r\nvar isDDA: (value: any) => boolean = function isDocumentDotAll() { return false; };\r\nif (typeof document === 'object') {\r\n    // Firefox 3 canonicalizes DDA to undefined when it's not accessed directly\r\n    var all = document.all;\r\n    if (toStr.call(all) === toStr.call(document.all)) {\r\n        isDDA = function isDocumentDotAll(value) {\r\n            /* globals document: false */\r\n            // in IE 6-8, typeof document.all is \"object\" and it's truthy\r\n            if ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {\r\n                try {\r\n                    var str = toStr.call(value);\r\n                    return (\r\n                        str === ddaClass\r\n                        || str === ddaClass2\r\n                        || str === ddaClass3 // opera 12.16\r\n                        || str === objectClass // IE 6-8\r\n                    ) && value('') == null; // eslint-disable-line eqeqeq\r\n                } catch (e) { /**/ }\r\n            }\r\n            return false;\r\n        };\r\n    }\r\n}\r\n\r\nfunction isCallableRefApply<T>(value: T | unknown): value is (...args: any[]) => any  {\r\n    if (isDDA(value)) { return true; }\r\n    if (!value) { return false; }\r\n    if (typeof value !== 'function' && typeof value !== 'object') { return false; }\r\n    try {\r\n        (reflectApply as any)(value, null, badArrayLike);\r\n    } catch (e) {\r\n        if (e !== isCallableMarker) { return false; }\r\n    }\r\n    return !isES6ClassFn(value) && tryFunctionObject(value);\r\n}\r\n\r\nfunction isCallableNoRefApply<T>(value: T | unknown): value is (...args: any[]) => any {\r\n    if (isDDA(value)) { return true; }\r\n    if (!value) { return false; }\r\n    if (typeof value !== 'function' && typeof value !== 'object') { return false; }\r\n    if (hasToStringTag) { return tryFunctionObject(value); }\r\n    if (isES6ClassFn(value)) { return false; }\r\n    var strClass = toStr.call(value);\r\n    if (strClass !== fnClass && strClass !== genClass && !(/^\\[object HTML/).test(strClass)) { return false; }\r\n    return tryFunctionObject(value);\r\n};\r\n\r\nexport default reflectApply ? isCallableRefApply : isCallableNoRefApply;\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\nimport isCallable from \"./callable.js\";\r\n\r\n/**\r\n * Exception class that will be used as rejection reason\r\n * in case a {@link CancellablePromise} is cancelled successfully.\r\n *\r\n * The value of the {@link name} property is the string `\"CancelError\"`.\r\n * The value of the {@link cause} property is the cause passed to the cancel method, if any.\r\n */\r\nexport class CancelError extends Error {\r\n    /**\r\n     * Constructs a new `CancelError` instance.\r\n     * @param message - The error message.\r\n     * @param options - Options to be forwarded to the Error constructor.\r\n     */\r\n    constructor(message?: string, options?: ErrorOptions) {\r\n        super(message, options);\r\n        this.name = \"CancelError\";\r\n    }\r\n}\r\n\r\n/**\r\n * Exception class that will be reported as an unhandled rejection\r\n * in case a {@link CancellablePromise} rejects after being cancelled,\r\n * or when the `oncancelled` callback throws or rejects.\r\n *\r\n * The value of the {@link name} property is the string `\"CancelledRejectionError\"`.\r\n * The value of the {@link cause} property is the reason the promise rejected with.\r\n *\r\n * Because the original promise was cancelled,\r\n * a wrapper promise will be passed to the unhandled rejection listener instead.\r\n * The {@link promise} property holds a reference to the original promise.\r\n */\r\nexport class CancelledRejectionError extends Error {\r\n    /**\r\n     * Holds a reference to the promise that was cancelled and then rejected.\r\n     */\r\n    promise: CancellablePromise<unknown>;\r\n\r\n    /**\r\n     * Constructs a new `CancelledRejectionError` instance.\r\n     * @param promise - The promise that caused the error originally.\r\n     * @param reason - The rejection reason.\r\n     * @param info - An optional informative message specifying the circumstances in which the error was thrown.\r\n     *               Defaults to the string `\"Unhandled rejection in cancelled promise.\"`.\r\n     */\r\n    constructor(promise: CancellablePromise<unknown>, reason?: any, info?: string) {\r\n        super((info ?? \"Unhandled rejection in cancelled promise.\") + \" Reason: \" + errorMessage(reason), { cause: reason });\r\n        this.promise = promise;\r\n        this.name = \"CancelledRejectionError\";\r\n    }\r\n}\r\n\r\ntype CancellablePromiseResolver<T> = (value: T | PromiseLike<T> | CancellablePromiseLike<T>) => void;\r\ntype CancellablePromiseRejector = (reason?: any) => void;\r\ntype CancellablePromiseCanceller = (cause?: any) => void | PromiseLike<void>;\r\ntype CancellablePromiseExecutor<T> = (resolve: CancellablePromiseResolver<T>, reject: CancellablePromiseRejector) => void;\r\n\r\nexport interface CancellablePromiseLike<T> {\r\n    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1> | CancellablePromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2> | CancellablePromiseLike<TResult2>) | undefined | null): CancellablePromiseLike<TResult1 | TResult2>;\r\n    cancel(cause?: any): void | PromiseLike<void>;\r\n}\r\n\r\n/**\r\n * Wraps a cancellable promise along with its resolution methods.\r\n * The `oncancelled` field will be null initially but may be set to provide a custom cancellation function.\r\n */\r\nexport interface CancellablePromiseWithResolvers<T> {\r\n    promise: CancellablePromise<T>;\r\n    resolve: CancellablePromiseResolver<T>;\r\n    reject: CancellablePromiseRejector;\r\n    oncancelled: CancellablePromiseCanceller | null;\r\n}\r\n\r\ninterface CancellablePromiseState {\r\n    readonly root: CancellablePromiseState;\r\n    resolving: boolean;\r\n    settled: boolean;\r\n    reason?: CancelError;\r\n}\r\n\r\n// Private field names.\r\nconst barrierSym = Symbol(\"barrier\");\r\nconst cancelImplSym = Symbol(\"cancelImpl\");\r\nconst species = Symbol.species ?? Symbol(\"speciesPolyfill\");\r\n\r\n/**\r\n * A promise with an attached method for cancelling long-running operations (see {@link CancellablePromise#cancel}).\r\n * Cancellation can optionally be bound to an {@link AbortSignal}\r\n * for better composability (see {@link CancellablePromise#cancelOn}).\r\n *\r\n * Cancelling a pending promise will result in an immediate rejection\r\n * with an instance of {@link CancelError} as reason,\r\n * but whoever started the promise will be responsible\r\n * for actually aborting the underlying operation.\r\n * To this purpose, the constructor and all chaining methods\r\n * accept optional cancellation callbacks.\r\n *\r\n * If a `CancellablePromise` still resolves after having been cancelled,\r\n * the result will be discarded. If it rejects, the reason\r\n * will be reported as an unhandled rejection,\r\n * wrapped in a {@link CancelledRejectionError} instance.\r\n * To facilitate the handling of cancellation requests,\r\n * cancelled `CancellablePromise`s will _not_ report unhandled `CancelError`s\r\n * whose `cause` field is the same as the one with which the current promise was cancelled.\r\n *\r\n * All usual promise methods are defined and return a `CancellablePromise`\r\n * whose cancel method will cancel the parent operation as well, propagating the cancellation reason\r\n * upwards through promise chains.\r\n * Conversely, cancelling a promise will not automatically cancel dependent promises downstream:\r\n * ```ts\r\n * let root = new CancellablePromise((resolve, reject) => { ... });\r\n * let child1 = root.then(() => { ... });\r\n * let child2 = child1.then(() => { ... });\r\n * let child3 = root.catch(() => { ... });\r\n * child1.cancel(); // Cancels child1 and root, but not child2 or child3\r\n * ```\r\n * Cancelling a promise that has already settled is safe and has no consequence.\r\n *\r\n * The `cancel` method returns a promise that _always fulfills_\r\n * after the whole chain has processed the cancel request\r\n * and all attached callbacks up to that moment have run.\r\n *\r\n * All ES2024 promise methods (static and instance) are defined on CancellablePromise,\r\n * but actual availability may vary with OS/webview version.\r\n *\r\n * In line with the proposal at https://github.com/tc39/proposal-rm-builtin-subclassing,\r\n * `CancellablePromise` does not support transparent subclassing.\r\n * Extenders should take care to provide their own method implementations.\r\n * This might be reconsidered in case the proposal is retired.\r\n *\r\n * CancellablePromise is a wrapper around the DOM Promise object\r\n * and is compliant with the [Promises/A+ specification](https://promisesaplus.com/)\r\n * (it passes the [compliance suite](https://github.com/promises-aplus/promises-tests))\r\n * if so is the underlying implementation.\r\n */\r\nexport class CancellablePromise<T> extends Promise<T> implements PromiseLike<T>, CancellablePromiseLike<T> {\r\n    // Private fields.\r\n    /** @internal */\r\n    private [barrierSym]!: Partial<PromiseWithResolvers<void>> | null;\r\n    /** @internal */\r\n    private readonly [cancelImplSym]!: (reason: CancelError) => void | PromiseLike<void>;\r\n\r\n    /**\r\n     * Creates a new `CancellablePromise`.\r\n     *\r\n     * @param executor - A callback used to initialize the promise. This callback is passed two arguments:\r\n     *                   a `resolve` callback used to resolve the promise with a value\r\n     *                   or the result of another promise (possibly cancellable),\r\n     *                   and a `reject` callback used to reject the promise with a provided reason or error.\r\n     *                   If the value provided to the `resolve` callback is a thenable _and_ cancellable object\r\n     *                   (it has a `then` _and_ a `cancel` method),\r\n     *                   cancellation requests will be forwarded to that object and the oncancelled will not be invoked anymore.\r\n     *                   If any one of the two callbacks is called _after_ the promise has been cancelled,\r\n     *                   the provided values will be cancelled and resolved as usual,\r\n     *                   but their results will be discarded.\r\n     *                   However, if the resolution process ultimately ends up in a rejection\r\n     *                   that is not due to cancellation, the rejection reason\r\n     *                   will be wrapped in a {@link CancelledRejectionError}\r\n     *                   and bubbled up as an unhandled rejection.\r\n     * @param oncancelled - It is the caller's responsibility to ensure that any operation\r\n     *                      started by the executor is properly halted upon cancellation.\r\n     *                      This optional callback can be used to that purpose.\r\n     *                      It will be called _synchronously_ with a cancellation cause\r\n     *                      when cancellation is requested, _after_ the promise has already rejected\r\n     *                      with a {@link CancelError}, but _before_\r\n     *                      any {@link then}/{@link catch}/{@link finally} callback runs.\r\n     *                      If the callback returns a thenable, the promise returned from {@link cancel}\r\n     *                      will only fulfill after the former has settled.\r\n     *                      Unhandled exceptions or rejections from the callback will be wrapped\r\n     *                      in a {@link CancelledRejectionError} and bubbled up as unhandled rejections.\r\n     *                      If the `resolve` callback is called before cancellation with a cancellable promise,\r\n     *                      cancellation requests on this promise will be diverted to that promise,\r\n     *                      and the original `oncancelled` callback will be discarded.\r\n     */\r\n    constructor(executor: CancellablePromiseExecutor<T>, oncancelled?: CancellablePromiseCanceller) {\r\n        let resolve!: (value: T | PromiseLike<T>) => void;\r\n        let reject!: (reason?: any) => void;\r\n        super((res, rej) => { resolve = res; reject = rej; });\r\n\r\n        if ((this.constructor as any)[species] !== Promise) {\r\n            throw new TypeError(\"CancellablePromise does not support transparent subclassing. Please refrain from overriding the [Symbol.species] static property.\");\r\n        }\r\n\r\n        let promise: CancellablePromiseWithResolvers<T> = {\r\n            promise: this,\r\n            resolve,\r\n            reject,\r\n            get oncancelled() { return oncancelled ?? null; },\r\n            set oncancelled(cb) { oncancelled = cb ?? undefined; }\r\n        };\r\n\r\n        const state: CancellablePromiseState = {\r\n            get root() { return state; },\r\n            resolving: false,\r\n            settled: false\r\n        };\r\n\r\n        // Setup cancellation system.\r\n        void Object.defineProperties(this, {\r\n            [barrierSym]: {\r\n                configurable: false,\r\n                enumerable: false,\r\n                writable: true,\r\n                value: null\r\n            },\r\n            [cancelImplSym]: {\r\n                configurable: false,\r\n                enumerable: false,\r\n                writable: false,\r\n                value: cancellerFor(promise, state)\r\n            }\r\n        });\r\n\r\n        // Run the actual executor.\r\n        const rejector = rejectorFor(promise, state);\r\n        try {\r\n            executor(resolverFor(promise, state), rejector);\r\n        } catch (err) {\r\n            if (state.resolving) {\r\n                console.log(\"Unhandled exception in CancellablePromise executor.\", err);\r\n            } else {\r\n                rejector(err);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Cancels immediately the execution of the operation associated with this promise.\r\n     * The promise rejects with a {@link CancelError} instance as reason,\r\n     * with the {@link CancelError#cause} property set to the given argument, if any.\r\n     *\r\n     * Has no effect if called after the promise has already settled;\r\n     * repeated calls in particular are safe, but only the first one\r\n     * will set the cancellation cause.\r\n     *\r\n     * The `CancelError` exception _need not_ be handled explicitly _on the promises that are being cancelled:_\r\n     * cancelling a promise with no attached rejection handler does not trigger an unhandled rejection event.\r\n     * Therefore, the following idioms are all equally correct:\r\n     * ```ts\r\n     * new CancellablePromise((resolve, reject) => { ... }).cancel();\r\n     * new CancellablePromise((resolve, reject) => { ... }).then(...).cancel();\r\n     * new CancellablePromise((resolve, reject) => { ... }).then(...).catch(...).cancel();\r\n     * ```\r\n     * Whenever some cancelled promise in a chain rejects with a `CancelError`\r\n     * with the same cancellation cause as itself, the error will be discarded silently.\r\n     * However, the `CancelError` _will still be delivered_ to all attached rejection handlers\r\n     * added by {@link then} and related methods:\r\n     * ```ts\r\n     * let cancellable = new CancellablePromise((resolve, reject) => { ... });\r\n     * cancellable.then(() => { ... }).catch(console.log);\r\n     * cancellable.cancel(); // A CancelError is printed to the console.\r\n     * ```\r\n     * If the `CancelError` is not handled downstream by the time it reaches\r\n     * a _non-cancelled_ promise, it _will_ trigger an unhandled rejection event,\r\n     * just like normal rejections would:\r\n     * ```ts\r\n     * let cancellable = new CancellablePromise((resolve, reject) => { ... });\r\n     * let chained = cancellable.then(() => { ... }).then(() => { ... }); // No catch...\r\n     * cancellable.cancel(); // Unhandled rejection event on chained!\r\n     * ```\r\n     * Therefore, it is important to either cancel whole promise chains from their tail,\r\n     * as shown in the correct idioms above, or take care of handling errors everywhere.\r\n     *\r\n     * @returns A cancellable promise that _fulfills_ after the cancel callback (if any)\r\n     * and all handlers attached up to the call to cancel have run.\r\n     * If the cancel callback returns a thenable, the promise returned by `cancel`\r\n     * will also wait for that thenable to settle.\r\n     * This enables callers to wait for the cancelled operation to terminate\r\n     * without being forced to handle potential errors at the call site.\r\n     * ```ts\r\n     * cancellable.cancel().then(() => {\r\n     *     // Cleanup finished, it's safe to do something else.\r\n     * }, (err) => {\r\n     *     // Unreachable: the promise returned from cancel will never reject.\r\n     * });\r\n     * ```\r\n     * Note that the returned promise will _not_ handle implicitly any rejection\r\n     * that might have occurred already in the cancelled chain.\r\n     * It will just track whether registered handlers have been executed or not.\r\n     * Therefore, unhandled rejections will never be silently handled by calling cancel.\r\n     */\r\n    cancel(cause?: any): CancellablePromise<void> {\r\n        return new CancellablePromise<void>((resolve) => {\r\n            // INVARIANT: the result of this[cancelImplSym] and the barrier do not ever reject.\r\n            // Unfortunately macOS High Sierra does not support Promise.allSettled.\r\n            Promise.all([\r\n                this[cancelImplSym](new CancelError(\"Promise cancelled.\", { cause })),\r\n                currentBarrier(this)\r\n            ]).then(() => resolve(), () => resolve());\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Binds promise cancellation to the abort event of the given {@link AbortSignal}.\r\n     * If the signal has already aborted, the promise will be cancelled immediately.\r\n     * When either condition is verified, the cancellation cause will be set\r\n     * to the signal's abort reason (see {@link AbortSignal#reason}).\r\n     *\r\n     * Has no effect if called (or if the signal aborts) _after_ the promise has already settled.\r\n     * Only the first signal to abort will set the cancellation cause.\r\n     *\r\n     * For more details about the cancellation process,\r\n     * see {@link cancel} and the `CancellablePromise` constructor.\r\n     *\r\n     * This method enables `await`ing cancellable promises without having\r\n     * to store them for future cancellation, e.g.:\r\n     * ```ts\r\n     * await longRunningOperation().cancelOn(signal);\r\n     * ```\r\n     * instead of:\r\n     * ```ts\r\n     * let promiseToBeCancelled = longRunningOperation();\r\n     * await promiseToBeCancelled;\r\n     * ```\r\n     *\r\n     * @returns This promise, for method chaining.\r\n     */\r\n    cancelOn(signal: AbortSignal): CancellablePromise<T> {\r\n        if (signal.aborted) {\r\n            void this.cancel(signal.reason)\r\n        } else {\r\n            signal.addEventListener('abort', () => void this.cancel(signal.reason), {capture: true});\r\n        }\r\n\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Attaches callbacks for the resolution and/or rejection of the `CancellablePromise`.\r\n     *\r\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\r\n     * with the same semantics as the `oncancelled` argument of the constructor.\r\n     * When the parent promise rejects or is cancelled, the `onrejected` callback will run,\r\n     * _even after the returned promise has been cancelled:_\r\n     * in that case, should it reject or throw, the reason will be wrapped\r\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\r\n     *\r\n     * @param onfulfilled The callback to execute when the Promise is resolved.\r\n     * @param onrejected The callback to execute when the Promise is rejected.\r\n     * @returns A `CancellablePromise` for the completion of whichever callback is executed.\r\n     * The returned promise is hooked up to propagate cancellation requests up the chain, but not down:\r\n     *\r\n     *   - if the parent promise is cancelled, the `onrejected` handler will be invoked with a `CancelError`\r\n     *     and the returned promise _will resolve regularly_ with its result;\r\n     *   - conversely, if the returned promise is cancelled, _the parent promise is cancelled too;_\r\n     *     the `onrejected` handler will still be invoked with the parent's `CancelError`,\r\n     *     but its result will be discarded\r\n     *     and the returned promise will reject with a `CancelError` as well.\r\n     *\r\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\r\n     * up the entire promise chain have been run.\r\n     *\r\n     * If either callback returns a cancellable promise,\r\n     * cancellation requests will be diverted to it,\r\n     * and the specified `oncancelled` callback will be discarded.\r\n     */\r\n    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1> | CancellablePromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2> | CancellablePromiseLike<TResult2>) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<TResult1 | TResult2> {\r\n        if (!(this instanceof CancellablePromise)) {\r\n            throw new TypeError(\"CancellablePromise.prototype.then called on an invalid object.\");\r\n        }\r\n\r\n        // NOTE: TypeScript's built-in type for then is broken,\r\n        // as it allows specifying an arbitrary TResult1 != T even when onfulfilled is not a function.\r\n        // We cannot fix it if we want to CancellablePromise to implement PromiseLike<T>.\r\n\r\n        if (!isCallable(onfulfilled)) { onfulfilled = identity as any; }\r\n        if (!isCallable(onrejected)) { onrejected = thrower; }\r\n\r\n        if (onfulfilled === identity && onrejected == thrower) {\r\n            // Shortcut for trivial arguments.\r\n            return new CancellablePromise((resolve) => resolve(this as any));\r\n        }\r\n\r\n        const barrier: Partial<PromiseWithResolvers<void>> = {};\r\n        this[barrierSym] = barrier;\r\n\r\n        return new CancellablePromise<TResult1 | TResult2>((resolve, reject) => {\r\n            void super.then(\r\n                (value) => {\r\n                    if (this[barrierSym] === barrier) { this[barrierSym] = null; }\r\n                    barrier.resolve?.();\r\n\r\n                    try {\r\n                        resolve(onfulfilled!(value));\r\n                    } catch (err) {\r\n                        reject(err);\r\n                    }\r\n                },\r\n                (reason?) => {\r\n                    if (this[barrierSym] === barrier) { this[barrierSym] = null; }\r\n                    barrier.resolve?.();\r\n\r\n                    try {\r\n                        resolve(onrejected!(reason));\r\n                    } catch (err) {\r\n                        reject(err);\r\n                    }\r\n                }\r\n            );\r\n        }, async (cause?) => {\r\n            //cancelled = true;\r\n            try {\r\n                return oncancelled?.(cause);\r\n            } finally {\r\n                await this.cancel(cause);\r\n            }\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Attaches a callback for only the rejection of the Promise.\r\n     *\r\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\r\n     * with the same semantics as the `oncancelled` argument of the constructor.\r\n     * When the parent promise rejects or is cancelled, the `onrejected` callback will run,\r\n     * _even after the returned promise has been cancelled:_\r\n     * in that case, should it reject or throw, the reason will be wrapped\r\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\r\n     *\r\n     * It is equivalent to\r\n     * ```ts\r\n     * cancellablePromise.then(undefined, onrejected, oncancelled);\r\n     * ```\r\n     * and the same caveats apply.\r\n     *\r\n     * @returns A Promise for the completion of the callback.\r\n     * Cancellation requests on the returned promise\r\n     * will propagate up the chain to the parent promise,\r\n     * but not in the other direction.\r\n     *\r\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\r\n     * up the entire promise chain have been run.\r\n     *\r\n     * If `onrejected` returns a cancellable promise,\r\n     * cancellation requests will be diverted to it,\r\n     * and the specified `oncancelled` callback will be discarded.\r\n     * See {@link then} for more details.\r\n     */\r\n    catch<TResult = never>(onrejected?: ((reason: any) => (PromiseLike<TResult> | TResult)) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<T | TResult> {\r\n        return this.then(undefined, onrejected, oncancelled);\r\n    }\r\n\r\n    /**\r\n     * Attaches a callback that is invoked when the CancellablePromise is settled (fulfilled or rejected). The\r\n     * resolved value cannot be accessed or modified from the callback.\r\n     * The returned promise will settle in the same state as the original one\r\n     * after the provided callback has completed execution,\r\n     * unless the callback throws or returns a rejecting promise,\r\n     * in which case the returned promise will reject as well.\r\n     *\r\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\r\n     * with the same semantics as the `oncancelled` argument of the constructor.\r\n     * Once the parent promise settles, the `onfinally` callback will run,\r\n     * _even after the returned promise has been cancelled:_\r\n     * in that case, should it reject or throw, the reason will be wrapped\r\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\r\n     *\r\n     * This method is implemented in terms of {@link then} and the same caveats apply.\r\n     * It is polyfilled, hence available in every OS/webview version.\r\n     *\r\n     * @returns A Promise for the completion of the callback.\r\n     * Cancellation requests on the returned promise\r\n     * will propagate up the chain to the parent promise,\r\n     * but not in the other direction.\r\n     *\r\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\r\n     * up the entire promise chain have been run.\r\n     *\r\n     * If `onfinally` returns a cancellable promise,\r\n     * cancellation requests will be diverted to it,\r\n     * and the specified `oncancelled` callback will be discarded.\r\n     * See {@link then} for more details.\r\n     */\r\n    finally(onfinally?: (() => void) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<T> {\r\n        if (!(this instanceof CancellablePromise)) {\r\n            throw new TypeError(\"CancellablePromise.prototype.finally called on an invalid object.\");\r\n        }\r\n\r\n        if (!isCallable(onfinally)) {\r\n            return this.then(onfinally, onfinally, oncancelled);\r\n        }\r\n\r\n        return this.then(\r\n            (value) => CancellablePromise.resolve(onfinally()).then(() => value),\r\n            (reason?) => CancellablePromise.resolve(onfinally()).then(() => { throw reason; }),\r\n            oncancelled,\r\n        );\r\n    }\r\n\r\n    /**\r\n     * We use the `[Symbol.species]` static property, if available,\r\n     * to disable the built-in automatic subclassing features from {@link Promise}.\r\n     * It is critical for performance reasons that extenders do not override this.\r\n     * Once the proposal at https://github.com/tc39/proposal-rm-builtin-subclassing\r\n     * is either accepted or retired, this implementation will have to be revised accordingly.\r\n     *\r\n     * @ignore\r\n     * @internal\r\n     */\r\n    static get [species]() {\r\n        return Promise;\r\n    }\r\n\r\n    /**\r\n     * Creates a CancellablePromise that is resolved with an array of results\r\n     * when all of the provided Promises resolve, or rejected when any Promise is rejected.\r\n     *\r\n     * Every one of the provided objects that is a thenable _and_ cancellable object\r\n     * will be cancelled when the returned promise is cancelled, with the same cause.\r\n     *\r\n     * @group Static Methods\r\n     */\r\n    static all<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>[]>;\r\n    static all<T extends readonly unknown[] | []>(values: T): CancellablePromise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;\r\n    static all<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\r\n        let collected = Array.from(values);\r\n        const promise = collected.length === 0\r\n            ? CancellablePromise.resolve(collected)\r\n            : new CancellablePromise<unknown>((resolve, reject) => {\r\n                void Promise.all(collected).then(resolve, reject);\r\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\r\n        return promise;\r\n    }\r\n\r\n    /**\r\n     * Creates a CancellablePromise that is resolved with an array of results\r\n     * when all of the provided Promises resolve or reject.\r\n     *\r\n     * Every one of the provided objects that is a thenable _and_ cancellable object\r\n     * will be cancelled when the returned promise is cancelled, with the same cause.\r\n     *\r\n     * @group Static Methods\r\n     */\r\n    static allSettled<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<PromiseSettledResult<Awaited<T>>[]>;\r\n    static allSettled<T extends readonly unknown[] | []>(values: T): CancellablePromise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>;\r\n    static allSettled<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\r\n        let collected = Array.from(values);\r\n        const promise = collected.length === 0\r\n            ? CancellablePromise.resolve(collected)\r\n            : new CancellablePromise<unknown>((resolve, reject) => {\r\n                void Promise.allSettled(collected).then(resolve, reject);\r\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\r\n        return promise;\r\n    }\r\n\r\n    /**\r\n     * The any function returns a promise that is fulfilled by the first given promise to be fulfilled,\r\n     * or rejected with an AggregateError containing an array of rejection reasons\r\n     * if all of the given promises are rejected.\r\n     * It resolves all elements of the passed iterable to promises as it runs this algorithm.\r\n     *\r\n     * Every one of the provided objects that is a thenable _and_ cancellable object\r\n     * will be cancelled when the returned promise is cancelled, with the same cause.\r\n     *\r\n     * @group Static Methods\r\n     */\r\n    static any<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>>;\r\n    static any<T extends readonly unknown[] | []>(values: T): CancellablePromise<Awaited<T[number]>>;\r\n    static any<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\r\n        let collected = Array.from(values);\r\n        const promise = collected.length === 0\r\n            ? CancellablePromise.resolve(collected)\r\n            : new CancellablePromise<unknown>((resolve, reject) => {\r\n                void Promise.any(collected).then(resolve, reject);\r\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\r\n        return promise;\r\n    }\r\n\r\n    /**\r\n     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved or rejected.\r\n     *\r\n     * Every one of the provided objects that is a thenable _and_ cancellable object\r\n     * will be cancelled when the returned promise is cancelled, with the same cause.\r\n     *\r\n     * @group Static Methods\r\n     */\r\n    static race<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>>;\r\n    static race<T extends readonly unknown[] | []>(values: T): CancellablePromise<Awaited<T[number]>>;\r\n    static race<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\r\n        let collected = Array.from(values);\r\n        const promise = new CancellablePromise<unknown>((resolve, reject) => {\r\n            void Promise.race(collected).then(resolve, reject);\r\n        }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\r\n        return promise;\r\n    }\r\n\r\n    /**\r\n     * Creates a new cancelled CancellablePromise for the provided cause.\r\n     *\r\n     * @group Static Methods\r\n     */\r\n    static cancel<T = never>(cause?: any): CancellablePromise<T> {\r\n        const p = new CancellablePromise<T>(() => {});\r\n        p.cancel(cause);\r\n        return p;\r\n    }\r\n\r\n    /**\r\n     * Creates a new CancellablePromise that cancels\r\n     * after the specified timeout, with the provided cause.\r\n     *\r\n     * If the {@link AbortSignal.timeout} factory method is available,\r\n     * it is used to base the timeout on _active_ time rather than _elapsed_ time.\r\n     * Otherwise, `timeout` falls back to {@link setTimeout}.\r\n     *\r\n     * @group Static Methods\r\n     */\r\n    static timeout<T = never>(milliseconds: number, cause?: any): CancellablePromise<T> {\r\n        const promise = new CancellablePromise<T>(() => {});\r\n        if (AbortSignal && typeof AbortSignal === 'function' && AbortSignal.timeout && typeof AbortSignal.timeout === 'function') {\r\n            AbortSignal.timeout(milliseconds).addEventListener('abort', () => void promise.cancel(cause));\r\n        } else {\r\n            setTimeout(() => void promise.cancel(cause), milliseconds);\r\n        }\r\n        return promise;\r\n    }\r\n\r\n    /**\r\n     * Creates a new CancellablePromise that resolves after the specified timeout.\r\n     * The returned promise can be cancelled without consequences.\r\n     *\r\n     * @group Static Methods\r\n     */\r\n    static sleep(milliseconds: number): CancellablePromise<void>;\r\n    /**\r\n     * Creates a new CancellablePromise that resolves after\r\n     * the specified timeout, with the provided value.\r\n     * The returned promise can be cancelled without consequences.\r\n     *\r\n     * @group Static Methods\r\n     */\r\n    static sleep<T>(milliseconds: number, value: T): CancellablePromise<T>;\r\n    static sleep<T = void>(milliseconds: number, value?: T): CancellablePromise<T> {\r\n        return new CancellablePromise<T>((resolve) => {\r\n            setTimeout(() => resolve(value!), milliseconds);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Creates a new rejected CancellablePromise for the provided reason.\r\n     *\r\n     * @group Static Methods\r\n     */\r\n    static reject<T = never>(reason?: any): CancellablePromise<T> {\r\n        return new CancellablePromise<T>((_, reject) => reject(reason));\r\n    }\r\n\r\n    /**\r\n     * Creates a new resolved CancellablePromise.\r\n     *\r\n     * @group Static Methods\r\n     */\r\n    static resolve(): CancellablePromise<void>;\r\n    /**\r\n     * Creates a new resolved CancellablePromise for the provided value.\r\n     *\r\n     * @group Static Methods\r\n     */\r\n    static resolve<T>(value: T): CancellablePromise<Awaited<T>>;\r\n    /**\r\n     * Creates a new resolved CancellablePromise for the provided value.\r\n     *\r\n     * @group Static Methods\r\n     */\r\n    static resolve<T>(value: T | PromiseLike<T>): CancellablePromise<Awaited<T>>;\r\n    static resolve<T = void>(value?: T | PromiseLike<T>): CancellablePromise<Awaited<T>> {\r\n        if (value instanceof CancellablePromise) {\r\n            // Optimise for cancellable promises.\r\n            return value;\r\n        }\r\n        return new CancellablePromise<any>((resolve) => resolve(value));\r\n    }\r\n\r\n    /**\r\n     * Creates a new CancellablePromise and returns it in an object, along with its resolve and reject functions\r\n     * and a getter/setter for the cancellation callback.\r\n     *\r\n     * This method is polyfilled, hence available in every OS/webview version.\r\n     *\r\n     * @group Static Methods\r\n     */\r\n    static withResolvers<T>(): CancellablePromiseWithResolvers<T> {\r\n        let result: CancellablePromiseWithResolvers<T> = { oncancelled: null } as any;\r\n        result.promise = new CancellablePromise<T>((resolve, reject) => {\r\n            result.resolve = resolve;\r\n            result.reject = reject;\r\n        }, (cause?: any) => { result.oncancelled?.(cause); });\r\n        return result;\r\n    }\r\n}\r\n\r\n/**\r\n * Returns a callback that implements the cancellation algorithm for the given cancellable promise.\r\n * The promise returned from the resulting function does not reject.\r\n */\r\nfunction cancellerFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState) {\r\n    let cancellationPromise: void | PromiseLike<void> = undefined;\r\n\r\n    return (reason: CancelError): void | PromiseLike<void> => {\r\n        if (!state.settled) {\r\n            state.settled = true;\r\n            state.reason = reason;\r\n            promise.reject(reason);\r\n\r\n            // Attach an error handler that ignores this specific rejection reason and nothing else.\r\n            // In theory, a sane underlying implementation at this point\r\n            // should always reject with our cancellation reason,\r\n            // hence the handler will never throw.\r\n            void Promise.prototype.then.call(promise.promise, undefined, (err) => {\r\n                if (err !== reason) {\r\n                    throw err;\r\n                }\r\n            });\r\n        }\r\n\r\n        // If reason is not set, the promise resolved regularly, hence we must not call oncancelled.\r\n        // If oncancelled is unset, no need to go any further.\r\n        if (!state.reason || !promise.oncancelled) { return; }\r\n\r\n        cancellationPromise = new Promise<void>((resolve) => {\r\n            try {\r\n                resolve(promise.oncancelled!(state.reason!.cause));\r\n            } catch (err) {\r\n                Promise.reject(new CancelledRejectionError(promise.promise, err, \"Unhandled exception in oncancelled callback.\"));\r\n            }\r\n        }).catch((reason?) => {\r\n            Promise.reject(new CancelledRejectionError(promise.promise, reason, \"Unhandled rejection in oncancelled callback.\"));\r\n        });\r\n\r\n        // Unset oncancelled to prevent repeated calls.\r\n        promise.oncancelled = null;\r\n\r\n        return cancellationPromise;\r\n    }\r\n}\r\n\r\n/**\r\n * Returns a callback that implements the resolution algorithm for the given cancellable promise.\r\n */\r\nfunction resolverFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState): CancellablePromiseResolver<T> {\r\n    return (value) => {\r\n        if (state.resolving) { return; }\r\n        state.resolving = true;\r\n\r\n        if (value === promise.promise) {\r\n            if (state.settled) { return; }\r\n            state.settled = true;\r\n            promise.reject(new TypeError(\"A promise cannot be resolved with itself.\"));\r\n            return;\r\n        }\r\n\r\n        if (value != null && (typeof value === 'object' || typeof value === 'function')) {\r\n            let then: any;\r\n            try {\r\n                then = (value as any).then;\r\n            } catch (err) {\r\n                state.settled = true;\r\n                promise.reject(err);\r\n                return;\r\n            }\r\n\r\n            if (isCallable(then)) {\r\n                try {\r\n                    let cancel = (value as any).cancel;\r\n                    if (isCallable(cancel)) {\r\n                        const oncancelled = (cause?: any) => {\r\n                            Reflect.apply(cancel, value, [cause]);\r\n                        };\r\n                        if (state.reason) {\r\n                            // If already cancelled, propagate cancellation.\r\n                            // The promise returned from the canceller algorithm does not reject\r\n                            // so it can be discarded safely.\r\n                            void cancellerFor({ ...promise, oncancelled }, state)(state.reason);\r\n                        } else {\r\n                            promise.oncancelled = oncancelled;\r\n                        }\r\n                    }\r\n                } catch {}\r\n\r\n                const newState: CancellablePromiseState = {\r\n                    root: state.root,\r\n                    resolving: false,\r\n                    get settled() { return this.root.settled },\r\n                    set settled(value) { this.root.settled = value; },\r\n                    get reason() { return this.root.reason }\r\n                };\r\n\r\n                const rejector = rejectorFor(promise, newState);\r\n                try {\r\n                    Reflect.apply(then, value, [resolverFor(promise, newState), rejector]);\r\n                } catch (err) {\r\n                    rejector(err);\r\n                }\r\n                return; // IMPORTANT!\r\n            }\r\n        }\r\n\r\n        if (state.settled) { return; }\r\n        state.settled = true;\r\n        promise.resolve(value);\r\n    };\r\n}\r\n\r\n/**\r\n * Returns a callback that implements the rejection algorithm for the given cancellable promise.\r\n */\r\nfunction rejectorFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState): CancellablePromiseRejector {\r\n    return (reason?) => {\r\n        if (state.resolving) { return; }\r\n        state.resolving = true;\r\n\r\n        if (state.settled) {\r\n            try {\r\n                if (reason instanceof CancelError && state.reason instanceof CancelError && Object.is(reason.cause, state.reason.cause)) {\r\n                    // Swallow late rejections that are CancelErrors whose cancellation cause is the same as ours.\r\n                    return;\r\n                }\r\n            } catch {}\r\n\r\n            void Promise.reject(new CancelledRejectionError(promise.promise, reason));\r\n        } else {\r\n            state.settled = true;\r\n            promise.reject(reason);\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Cancels all values in an array that look like cancellable thenables.\r\n * Returns a promise that fulfills once all cancellation procedures for the given values have settled.\r\n */\r\nfunction cancelAll(parent: CancellablePromise<unknown>, values: any[], cause?: any): Promise<void> {\r\n    const results = [];\r\n\r\n    for (const value of values) {\r\n        let cancel: CancellablePromiseCanceller;\r\n        try {\r\n            if (!isCallable(value.then)) { continue; }\r\n            cancel = value.cancel;\r\n            if (!isCallable(cancel)) { continue; }\r\n        } catch { continue; }\r\n\r\n        let result: void | PromiseLike<void>;\r\n        try {\r\n            result = Reflect.apply(cancel, value, [cause]);\r\n        } catch (err) {\r\n            Promise.reject(new CancelledRejectionError(parent, err, \"Unhandled exception in cancel method.\"));\r\n            continue;\r\n        }\r\n\r\n        if (!result) { continue; }\r\n        results.push(\r\n            (result instanceof Promise  ? result : Promise.resolve(result)).catch((reason?) => {\r\n                Promise.reject(new CancelledRejectionError(parent, reason, \"Unhandled rejection in cancel method.\"));\r\n            })\r\n        );\r\n    }\r\n\r\n    return Promise.all(results) as any;\r\n}\r\n\r\n/**\r\n * Returns its argument.\r\n */\r\nfunction identity<T>(x: T): T {\r\n    return x;\r\n}\r\n\r\n/**\r\n * Throws its argument.\r\n */\r\nfunction thrower(reason?: any): never {\r\n    throw reason;\r\n}\r\n\r\n/**\r\n * Attempts various strategies to convert an error to a string.\r\n */\r\nfunction errorMessage(err: any): string {\r\n    try {\r\n        if (err instanceof Error || typeof err !== 'object' || err.toString !== Object.prototype.toString) {\r\n            return \"\" + err;\r\n        }\r\n    } catch {}\r\n\r\n    try {\r\n        return JSON.stringify(err);\r\n    } catch {}\r\n\r\n    try {\r\n        return Object.prototype.toString.call(err);\r\n    } catch {}\r\n\r\n    return \"<could not convert error to string>\";\r\n}\r\n\r\n/**\r\n * Gets the current barrier promise for the given cancellable promise. If necessary, initialises the barrier.\r\n */\r\nfunction currentBarrier<T>(promise: CancellablePromise<T>): Promise<void> {\r\n    let pwr: Partial<PromiseWithResolvers<void>> = promise[barrierSym] ?? {};\r\n    if (!('promise' in pwr)) {\r\n        Object.assign(pwr, promiseWithResolvers<void>());\r\n    }\r\n    if (promise[barrierSym] == null) {\r\n        pwr.resolve!();\r\n        promise[barrierSym] = pwr;\r\n    }\r\n    return pwr.promise!;\r\n}\r\n\r\n// Polyfill Promise.withResolvers.\r\nlet promiseWithResolvers = Promise.withResolvers;\r\nif (promiseWithResolvers && typeof promiseWithResolvers === 'function') {\r\n    promiseWithResolvers = promiseWithResolvers.bind(Promise);\r\n} else {\r\n    promiseWithResolvers = function <T>(): PromiseWithResolvers<T> {\r\n        let resolve!: (value: T | PromiseLike<T>) => void;\r\n        let reject!: (reason?: any) => void;\r\n        const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej; });\r\n        return { promise, resolve, reject };\r\n    }\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\r\n\r\nconst call = newRuntimeCaller(objectNames.Clipboard);\r\n\r\nconst ClipboardSetText = 0;\r\nconst ClipboardText = 1;\r\n\r\n/**\r\n * Sets the text to the Clipboard.\r\n *\r\n * @param text - The text to be set to the Clipboard.\r\n * @return A Promise that resolves when the operation is successful.\r\n */\r\nexport function SetText(text: string): Promise<void> {\r\n    return call(ClipboardSetText, {text});\r\n}\r\n\r\n/**\r\n * Get the Clipboard text\r\n *\r\n * @returns A promise that resolves with the text from the Clipboard.\r\n */\r\nexport function Text(): Promise<string> {\r\n    return call(ClipboardText);\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/**\r\n * Any is a dummy creation function for simple or unknown types.\r\n */\r\nexport function Any<T = any>(source: any): T {\r\n    return source;\r\n}\r\n\r\n/**\r\n * ByteSlice is a creation function that replaces\r\n * null strings with empty strings.\r\n */\r\nexport function ByteSlice(source: any): string {\r\n    return ((source == null) ? \"\" : source);\r\n}\r\n\r\n/**\r\n * Array takes a creation function for an arbitrary type\r\n * and returns an in-place creation function for an array\r\n * whose elements are of that type.\r\n */\r\nexport function Array<T = any>(element: (source: any) => T): (source: any) => T[] {\r\n    if (element === Any) {\r\n        return (source) => (source === null ? [] : source);\r\n    }\r\n\r\n    return (source) => {\r\n        if (source === null) {\r\n            return [];\r\n        }\r\n        for (let i = 0; i < source.length; i++) {\r\n            source[i] = element(source[i]);\r\n        }\r\n        return source;\r\n    };\r\n}\r\n\r\n/**\r\n * Map takes creation functions for two arbitrary types\r\n * and returns an in-place creation function for an object\r\n * whose keys and values are of those types.\r\n */\r\nexport function Map<V = any>(key: (source: any) => string, value: (source: any) => V): (source: any) => Record<string, V> {\r\n    if (value === Any) {\r\n        return (source) => (source === null ? {} : source);\r\n    }\r\n\r\n    return (source) => {\r\n        if (source === null) {\r\n            return {};\r\n        }\r\n        for (const key in source) {\r\n            source[key] = value(source[key]);\r\n        }\r\n        return source;\r\n    };\r\n}\r\n\r\n/**\r\n * Nullable takes a creation function for an arbitrary type\r\n * and returns a creation function for a nullable value of that type.\r\n */\r\nexport function Nullable<T = any>(element: (source: any) => T): (source: any) => (T | null) {\r\n    if (element === Any) {\r\n        return Any;\r\n    }\r\n\r\n    return (source) => (source === null ? null : element(source));\r\n}\r\n\r\n/**\r\n * Struct takes an object mapping field names to creation functions\r\n * and returns an in-place creation function for a struct.\r\n */\r\nexport function Struct(createField: Record<string, (source: any) => any>):\r\n    <U extends Record<string, any> = any>(source: any) => U\r\n{\r\n    let allAny = true;\r\n    for (const name in createField) {\r\n        if (createField[name] !== Any) {\r\n            allAny = false;\r\n            break;\r\n        }\r\n    }\r\n    if (allAny) {\r\n        return Any;\r\n    }\r\n\r\n    return (source) => {\r\n        for (const name in createField) {\r\n            if (name in source) {\r\n                source[name] = createField[name](source[name]);\r\n            }\r\n        }\r\n        return source;\r\n    };\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\nexport interface Size {\r\n    /** The width of a rectangular area. */\r\n    Width: number;\r\n    /** The height of a rectangular area. */\r\n    Height: number;\r\n}\r\n\r\nexport interface Rect {\r\n    /** The X coordinate of the origin. */\r\n    X: number;\r\n    /** The Y coordinate of the origin. */\r\n    Y: number;\r\n    /** The width of the rectangle. */\r\n    Width: number;\r\n    /** The height of the rectangle. */\r\n    Height: number;\r\n}\r\n\r\nexport interface Screen {\r\n    /** Unique identifier for the screen. */\r\n    ID: string;\r\n    /** Human-readable name of the screen. */\r\n    Name: string;\r\n    /** The scale factor of the screen (DPI/96). 1 = standard DPI, 2 = HiDPI (Retina), etc. */\r\n    ScaleFactor: number;\r\n    /** The X coordinate of the screen. */\r\n    X: number;\r\n    /** The Y coordinate of the screen. */\r\n    Y: number;\r\n    /** Contains the width and height of the screen. */\r\n    Size: Size;\r\n    /** Contains the bounds of the screen in terms of X, Y, Width, and Height. */\r\n    Bounds: Rect;\r\n    /** Contains the physical bounds of the screen in terms of X, Y, Width, and Height (before scaling). */\r\n    PhysicalBounds: Rect;\r\n    /** Contains the area of the screen that is actually usable (excluding taskbar and other system UI). */\r\n    WorkArea: Rect;\r\n    /** Contains the physical WorkArea of the screen (before scaling). */\r\n    PhysicalWorkArea: Rect;\r\n    /** True if this is the primary monitor selected by the user in the operating system. */\r\n    IsPrimary: boolean;\r\n    /** The rotation of the screen. */\r\n    Rotation: number;\r\n}\r\n\r\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\r\nconst call = newRuntimeCaller(objectNames.Screens);\r\n\r\nconst getAll = 0;\r\nconst getPrimary = 1;\r\nconst getCurrent = 2;\r\n\r\n/**\r\n * Gets all screens.\r\n *\r\n * @returns A promise that resolves to an array of Screen objects.\r\n */\r\nexport function GetAll(): Promise<Screen[]> {\r\n    return call(getAll);\r\n}\r\n\r\n/**\r\n * Gets the primary screen.\r\n *\r\n * @returns A promise that resolves to the primary screen.\r\n */\r\nexport function GetPrimary(): Promise<Screen> {\r\n    return call(getPrimary);\r\n}\r\n\r\n/**\r\n * Gets the current active screen.\r\n *\r\n * @returns A promise that resolves with the current active screen.\r\n */\r\nexport function GetCurrent(): Promise<Screen> {\r\n    return call(getCurrent);\r\n}\r\n"],
  "mappings": "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",
  "names": ["_a", "Error", "call", "_a", "Error", "call", "_a", "resizable", "call", "_a", "call", "call", "HideMethod", "ShowMethod", "isDocumentDotAll", "_a", "reason", "value", "call", "getAndDeleteResponse", "generateID", "call", "Array", "Map", "Array", "Map", "key", "call"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../runtime/desktop/@wailsio/runtime/src/index.ts", "../../runtime/desktop/@wailsio/runtime/src/wml.ts", "../../runtime/desktop/@wailsio/runtime/src/browser.ts", "../../runtime/desktop/@wailsio/runtime/src/nanoid.ts", "../../runtime/desktop/@wailsio/runtime/src/runtime.ts", "../../runtime/desktop/@wailsio/runtime/src/dialogs.ts", "../../runtime/desktop/@wailsio/runtime/src/events.ts", "../../runtime/desktop/@wailsio/runtime/src/listener.ts", "../../runtime/desktop/@wailsio/runtime/src/event_types.ts", "../../runtime/desktop/@wailsio/runtime/src/utils.ts", "../../runtime/desktop/@wailsio/runtime/src/window.ts", "../../runtime/desktop/compiled/main.js", "../../runtime/desktop/@wailsio/runtime/src/system.ts", "../../runtime/desktop/@wailsio/runtime/src/contextmenu.ts", "../../runtime/desktop/@wailsio/runtime/src/flags.ts", "../../runtime/desktop/@wailsio/runtime/src/drag.ts", "../../runtime/desktop/@wailsio/runtime/src/application.ts", "../../runtime/desktop/@wailsio/runtime/src/calls.ts", "../../runtime/desktop/@wailsio/runtime/src/callable.ts", "../../runtime/desktop/@wailsio/runtime/src/cancellable.ts", "../../runtime/desktop/@wailsio/runtime/src/clipboard.ts", "../../runtime/desktop/@wailsio/runtime/src/create.ts", "../../runtime/desktop/@wailsio/runtime/src/screens.ts", "../../runtime/desktop/@wailsio/runtime/src/ios.ts"],
  "sourcesContent": ["/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// Setup\nwindow._wails = window._wails || {};\n\nimport \"./contextmenu.js\";\nimport \"./drag.js\";\n\n// Re-export public API\nimport * as Application from \"./application.js\";\nimport * as Browser from \"./browser.js\";\nimport * as Call from \"./calls.js\";\nimport * as Clipboard from \"./clipboard.js\";\nimport * as Create from \"./create.js\";\nimport * as Dialogs from \"./dialogs.js\";\nimport * as Events from \"./events.js\";\nimport * as Flags from \"./flags.js\";\nimport * as Screens from \"./screens.js\";\nimport * as System from \"./system.js\";\nimport * as IOS from \"./ios.js\";\nimport Window from \"./window.js\";\nimport * as WML from \"./wml.js\";\n\nexport {\n    Application,\n    Browser,\n    Call,\n    Clipboard,\n    Dialogs,\n    Events,\n    Flags,\n    Screens,\n    System,\n    IOS,\n    Window,\n    WML\n};\n\n/**\n * An internal utility consumed by the binding generator.\n *\n * @ignore\n * @internal\n */\nexport { Create };\n\nexport * from \"./cancellable.js\";\n\n// Notify backend\nwindow._wails.invoke = System.invoke;\nSystem.invoke(\"wails:runtime:ready\");\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { OpenURL } from \"./browser.js\";\nimport { Question } from \"./dialogs.js\";\nimport { Emit } from \"./events.js\";\nimport { canAbortListeners, whenReady } from \"./utils.js\";\nimport Window from \"./window.js\";\n\n/**\n * Sends an event with the given name and optional data.\n *\n * @param eventName - - The name of the event to send.\n * @param [data=null] - - Optional data to send along with the event.\n */\nfunction sendEvent(eventName: string, data: any = null): void {\n    Emit(eventName, data);\n}\n\n/**\n * Calls a method on a specified window.\n *\n * @param windowName - The name of the window to call the method on.\n * @param methodName - The name of the method to call.\n */\nfunction callWindowMethod(windowName: string, methodName: string) {\n    const targetWindow = Window.Get(windowName);\n    const method = (targetWindow as any)[methodName];\n\n    if (typeof method !== \"function\") {\n        console.error(`Window method '${methodName}' not found`);\n        return;\n    }\n\n    try {\n        method.call(targetWindow);\n    } catch (e) {\n        console.error(`Error calling window method '${methodName}': `, e);\n    }\n}\n\n/**\n * Responds to a triggering event by running appropriate WML actions for the current target.\n */\nfunction onWMLTriggered(ev: Event): void {\n    const element = ev.currentTarget as Element;\n\n    function runEffect(choice = \"Yes\") {\n        if (choice !== \"Yes\")\n            return;\n\n        const eventType = element.getAttribute('wml-event') || element.getAttribute('data-wml-event');\n        const targetWindow = element.getAttribute('wml-target-window') || element.getAttribute('data-wml-target-window') || \"\";\n        const windowMethod = element.getAttribute('wml-window') || element.getAttribute('data-wml-window');\n        const url = element.getAttribute('wml-openurl') || element.getAttribute('data-wml-openurl');\n\n        if (eventType !== null)\n            sendEvent(eventType);\n        if (windowMethod !== null)\n            callWindowMethod(targetWindow, windowMethod);\n        if (url !== null)\n            void OpenURL(url);\n    }\n\n    const confirm = element.getAttribute('wml-confirm') || element.getAttribute('data-wml-confirm');\n\n    if (confirm) {\n        Question({\n            Title: \"Confirm\",\n            Message: confirm,\n            Detached: false,\n            Buttons: [\n                { Label: \"Yes\" },\n                { Label: \"No\", IsDefault: true }\n            ]\n        }).then(runEffect);\n    } else {\n        runEffect();\n    }\n}\n\n// Private field names.\nconst controllerSym = Symbol(\"controller\");\nconst triggerMapSym = Symbol(\"triggerMap\");\nconst elementCountSym = Symbol(\"elementCount\");\n\n/**\n * AbortControllerRegistry does not actually remember active event listeners: instead\n * it ties them to an AbortSignal and uses an AbortController to remove them all at once.\n */\nclass AbortControllerRegistry {\n    // Private fields.\n    [controllerSym]: AbortController;\n\n    constructor() {\n        this[controllerSym] = new AbortController();\n    }\n\n    /**\n     * Returns an options object for addEventListener that ties the listener\n     * to the AbortSignal from the current AbortController.\n     *\n     * @param element - An HTML element\n     * @param triggers - The list of active WML trigger events for the specified elements\n     */\n    set(element: Element, triggers: string[]): AddEventListenerOptions {\n        return { signal: this[controllerSym].signal };\n    }\n\n    /**\n     * Removes all registered event listeners and resets the registry.\n     */\n    reset(): void {\n        this[controllerSym].abort();\n        this[controllerSym] = new AbortController();\n    }\n}\n\n/**\n * WeakMapRegistry maps active trigger events to each DOM element through a WeakMap.\n * This ensures that the mapping remains private to this module, while still allowing garbage\n * collection of the involved elements.\n */\nclass WeakMapRegistry {\n    /** Stores the current element-to-trigger mapping. */\n    [triggerMapSym]: WeakMap<Element, string[]>;\n    /** Counts the number of elements with active WML triggers. */\n    [elementCountSym]: number;\n\n    constructor() {\n        this[triggerMapSym] = new WeakMap();\n        this[elementCountSym] = 0;\n    }\n\n    /**\n     * Sets active triggers for the specified element.\n     *\n     * @param element - An HTML element\n     * @param triggers - The list of active WML trigger events for the specified element\n     */\n    set(element: Element, triggers: string[]): AddEventListenerOptions {\n        if (!this[triggerMapSym].has(element)) { this[elementCountSym]++; }\n        this[triggerMapSym].set(element, triggers);\n        return {};\n    }\n\n    /**\n     * Removes all registered event listeners.\n     */\n    reset(): void {\n        if (this[elementCountSym] <= 0)\n            return;\n\n        for (const element of document.body.querySelectorAll('*')) {\n            if (this[elementCountSym] <= 0)\n                break;\n\n            const triggers = this[triggerMapSym].get(element);\n            if (triggers != null) { this[elementCountSym]--; }\n\n            for (const trigger of triggers || [])\n                element.removeEventListener(trigger, onWMLTriggered);\n        }\n\n        this[triggerMapSym] = new WeakMap();\n        this[elementCountSym] = 0;\n    }\n}\n\nconst triggerRegistry = canAbortListeners() ? new AbortControllerRegistry() : new WeakMapRegistry();\n\n/**\n * Adds event listeners to the specified element.\n */\nfunction addWMLListeners(element: Element): void {\n    const triggerRegExp = /\\S+/g;\n    const triggerAttr = (element.getAttribute('wml-trigger') || element.getAttribute('data-wml-trigger') || \"click\");\n    const triggers: string[] = [];\n\n    let match;\n    while ((match = triggerRegExp.exec(triggerAttr)) !== null)\n        triggers.push(match[0]);\n\n    const options = triggerRegistry.set(element, triggers);\n    for (const trigger of triggers)\n        element.addEventListener(trigger, onWMLTriggered, options);\n}\n\n/**\n * Schedules an automatic reload of WML to be performed as soon as the document is fully loaded.\n */\nexport function Enable(): void {\n    whenReady(Reload);\n}\n\n/**\n * Reloads the WML page by adding necessary event listeners and browser listeners.\n */\nexport function Reload(): void {\n    triggerRegistry.reset();\n    document.body.querySelectorAll('[wml-event], [wml-window], [wml-openurl], [data-wml-event], [data-wml-window], [data-wml-openurl]').forEach(addWMLListeners);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.Browser);\n\nconst BrowserOpenURL = 0;\n\n/**\n * Open a browser window to the given URL.\n *\n * @param url - The URL to open\n */\nexport function OpenURL(url: string | URL): Promise<void> {\n    return call(BrowserOpenURL, {url: url.toString()});\n}\n", "// Source: https://github.com/ai/nanoid\n\n// The MIT License (MIT)\n//\n// Copyright 2017 Andrey Sitnik <andrey@sitnik.ru>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n//     subject to the following conditions:\n//\n//     The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n//     THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// This alphabet uses `A-Za-z0-9_-` symbols.\n// The order of characters is optimized for better gzip and brotli compression.\n// References to the same file (works both for gzip and brotli):\n// `'use`, `andom`, and `rict'`\n// References to the brotli default dictionary:\n// `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`\nconst urlAlphabet =\n    'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\n\nexport function nanoid(size: number = 21): string {\n    let id = ''\n    // A compact alternative for `for (var i = 0; i < step; i++)`.\n    let i = size | 0\n    while (i--) {\n        // `| 0` is more compact and faster than `Math.floor()`.\n        id += urlAlphabet[(Math.random() * 64) | 0]\n    }\n    return id\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { nanoid } from './nanoid.js';\n\nconst runtimeURL = window.location.origin + \"/wails/runtime\";\n\n// Object Names\nexport const objectNames = Object.freeze({\n    Call: 0,\n    Clipboard: 1,\n    Application: 2,\n    Events: 3,\n    ContextMenu: 4,\n    Dialog: 5,\n    Window: 6,\n    Screens: 7,\n    System: 8,\n    Browser: 9,\n    CancelCall: 10,\n    IOS: 11,\n});\nexport let clientId = nanoid();\n\n/**\n * Creates a new runtime caller with specified ID.\n *\n * @param object - The object to invoke the method on.\n * @param windowName - The name of the window.\n * @return The new runtime caller function.\n */\nexport function newRuntimeCaller(object: number, windowName: string = '') {\n    return function (method: number, args: any = null) {\n        return runtimeCallWithID(object, method, windowName, args);\n    };\n}\n\nasync function runtimeCallWithID(objectID: number, method: number, windowName: string, args: any): Promise<any> {\n    let url = new URL(runtimeURL);\n    url.searchParams.append(\"object\", objectID.toString());\n    url.searchParams.append(\"method\", method.toString());\n    if (args) { url.searchParams.append(\"args\", JSON.stringify(args)); }\n\n    let headers: Record<string, string> = {\n        [\"x-wails-client-id\"]: clientId\n    }\n    if (windowName) {\n        headers[\"x-wails-window-name\"] = windowName;\n    }\n\n    let response = await fetch(url, { headers });\n    if (!response.ok) {\n        throw new Error(await response.text());\n    }\n\n    if ((response.headers.get(\"Content-Type\")?.indexOf(\"application/json\") ?? -1) !== -1) {\n        return response.json();\n    } else {\n        return response.text();\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\nimport { nanoid } from './nanoid.js';\n\n// setup\nwindow._wails = window._wails || {};\nwindow._wails.dialogErrorCallback = dialogErrorCallback;\nwindow._wails.dialogResultCallback = dialogResultCallback;\n\ntype PromiseResolvers = Omit<PromiseWithResolvers<any>, \"promise\">;\n\nconst call = newRuntimeCaller(objectNames.Dialog);\nconst dialogResponses = new Map<string, PromiseResolvers>();\n\n// Define constants from the `methods` object in Title Case\nconst DialogInfo = 0;\nconst DialogWarning = 1;\nconst DialogError = 2;\nconst DialogQuestion = 3;\nconst DialogOpenFile = 4;\nconst DialogSaveFile = 5;\n\nexport interface OpenFileDialogOptions {\n    /** Indicates if directories can be chosen. */\n    CanChooseDirectories?: boolean;\n    /** Indicates if files can be chosen. */\n    CanChooseFiles?: boolean;\n    /** Indicates if directories can be created. */\n    CanCreateDirectories?: boolean;\n    /** Indicates if hidden files should be shown. */\n    ShowHiddenFiles?: boolean;\n    /** Indicates if aliases should be resolved. */\n    ResolvesAliases?: boolean;\n    /** Indicates if multiple selection is allowed. */\n    AllowsMultipleSelection?: boolean;\n    /** Indicates if the extension should be hidden. */\n    HideExtension?: boolean;\n    /** Indicates if hidden extensions can be selected. */\n    CanSelectHiddenExtension?: boolean;\n    /** Indicates if file packages should be treated as directories. */\n    TreatsFilePackagesAsDirectories?: boolean;\n    /** Indicates if other file types are allowed. */\n    AllowsOtherFiletypes?: boolean;\n    /** Array of file filters. */\n    Filters?: FileFilter[];\n    /** Title of the dialog. */\n    Title?: string;\n    /** Message to show in the dialog. */\n    Message?: string;\n    /** Text to display on the button. */\n    ButtonText?: string;\n    /** Directory to open in the dialog. */\n    Directory?: string;\n    /** Indicates if the dialog should appear detached from the main window. */\n    Detached?: boolean;\n}\n\nexport interface SaveFileDialogOptions {\n    /** Default filename to use in the dialog. */\n    Filename?: string;\n    /** Indicates if directories can be chosen. */\n    CanChooseDirectories?: boolean;\n    /** Indicates if files can be chosen. */\n    CanChooseFiles?: boolean;\n    /** Indicates if directories can be created. */\n    CanCreateDirectories?: boolean;\n    /** Indicates if hidden files should be shown. */\n    ShowHiddenFiles?: boolean;\n    /** Indicates if aliases should be resolved. */\n    ResolvesAliases?: boolean;\n    /** Indicates if the extension should be hidden. */\n    HideExtension?: boolean;\n    /** Indicates if hidden extensions can be selected. */\n    CanSelectHiddenExtension?: boolean;\n    /** Indicates if file packages should be treated as directories. */\n    TreatsFilePackagesAsDirectories?: boolean;\n    /** Indicates if other file types are allowed. */\n    AllowsOtherFiletypes?: boolean;\n    /** Array of file filters. */\n    Filters?: FileFilter[];\n    /** Title of the dialog. */\n    Title?: string;\n    /** Message to show in the dialog. */\n    Message?: string;\n    /** Text to display on the button. */\n    ButtonText?: string;\n    /** Directory to open in the dialog. */\n    Directory?: string;\n    /** Indicates if the dialog should appear detached from the main window. */\n    Detached?: boolean;\n}\n\nexport interface MessageDialogOptions {\n    /** The title of the dialog window. */\n    Title?: string;\n    /** The main message to show in the dialog. */\n    Message?: string;\n    /** Array of button options to show in the dialog. */\n    Buttons?: Button[];\n    /** True if the dialog should appear detached from the main window (if applicable). */\n    Detached?: boolean;\n}\n\nexport interface Button {\n    /** Text that appears within the button. */\n    Label?: string;\n    /** True if the button should cancel an operation when clicked. */\n    IsCancel?: boolean;\n    /** True if the button should be the default action when the user presses enter. */\n    IsDefault?: boolean;\n}\n\nexport interface FileFilter {\n    /** Display name for the filter, it could be \"Text Files\", \"Images\" etc. */\n    DisplayName?: string;\n    /** Pattern to match for the filter, e.g. \"*.txt;*.md\" for text markdown files. */\n    Pattern?: string;\n}\n\n/**\n * Handles the result of a dialog request.\n *\n * @param id - The id of the request to handle the result for.\n * @param data - The result data of the request.\n * @param isJSON - Indicates whether the data is JSON or not.\n */\nfunction dialogResultCallback(id: string, data: string, isJSON: boolean): void {\n    let resolvers = getAndDeleteResponse(id);\n    if (!resolvers) {\n        return;\n    }\n\n    if (isJSON) {\n        try {\n            resolvers.resolve(JSON.parse(data));\n        } catch (err: any) {\n            resolvers.reject(new TypeError(\"could not parse result: \" + err.message, { cause: err }));\n        }\n    } else {\n        resolvers.resolve(data);\n    }\n}\n\n/**\n * Handles the error from a dialog request.\n *\n * @param id - The id of the promise handler.\n * @param message - An error message.\n */\nfunction dialogErrorCallback(id: string, message: string): void {\n    getAndDeleteResponse(id)?.reject(new window.Error(message));\n}\n\n/**\n * Retrieves and removes the response associated with the given ID from the dialogResponses map.\n *\n * @param id - The ID of the response to be retrieved and removed.\n * @returns The response object associated with the given ID, if any.\n */\nfunction getAndDeleteResponse(id: string): PromiseResolvers | undefined {\n    const response = dialogResponses.get(id);\n    dialogResponses.delete(id);\n    return response;\n}\n\n/**\n * Generates a unique ID using the nanoid library.\n *\n * @returns A unique ID that does not exist in the dialogResponses set.\n */\nfunction generateID(): string {\n    let result;\n    do {\n        result = nanoid();\n    } while (dialogResponses.has(result));\n    return result;\n}\n\n/**\n * Presents a dialog of specified type with the given options.\n *\n * @param type - Dialog type.\n * @param options - Options for the dialog.\n * @returns A promise that resolves with result of dialog.\n */\nfunction dialog(type: number, options: MessageDialogOptions | OpenFileDialogOptions | SaveFileDialogOptions = {}): Promise<any> {\n    const id = generateID();\n    return new Promise((resolve, reject) => {\n        dialogResponses.set(id, { resolve, reject });\n        call(type, Object.assign({ \"dialog-id\": id }, options)).catch((err: any) => {\n            dialogResponses.delete(id);\n            reject(err);\n        });\n    });\n}\n\n/**\n * Presents an info dialog.\n *\n * @param options - Dialog options\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Info(options: MessageDialogOptions): Promise<string> { return dialog(DialogInfo, options); }\n\n/**\n * Presents a warning dialog.\n *\n * @param options - Dialog options.\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Warning(options: MessageDialogOptions): Promise<string> { return dialog(DialogWarning, options); }\n\n/**\n * Presents an error dialog.\n *\n * @param options - Dialog options.\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Error(options: MessageDialogOptions): Promise<string> { return dialog(DialogError, options); }\n\n/**\n * Presents a question dialog.\n *\n * @param options - Dialog options.\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Question(options: MessageDialogOptions): Promise<string> { return dialog(DialogQuestion, options); }\n\n/**\n * Presents a file selection dialog to pick one or more files to open.\n *\n * @param options - Dialog options.\n * @returns Selected file or list of files, or a blank string/empty list if no file has been selected.\n */\nexport function OpenFile(options: OpenFileDialogOptions & { AllowsMultipleSelection: true }): Promise<string[]>;\nexport function OpenFile(options: OpenFileDialogOptions & { AllowsMultipleSelection?: false | undefined }): Promise<string>;\nexport function OpenFile(options: OpenFileDialogOptions): Promise<string | string[]>;\nexport function OpenFile(options: OpenFileDialogOptions): Promise<string | string[]> { return dialog(DialogOpenFile, options) ?? []; }\n\n/**\n * Presents a file selection dialog to pick a file to save.\n *\n * @param options - Dialog options.\n * @returns Selected file, or a blank string if no file has been selected.\n */\nexport function SaveFile(options: SaveFileDialogOptions): Promise<string> { return dialog(DialogSaveFile, options); }\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nimport { eventListeners, Listener, listenerOff } from \"./listener.js\";\n\n// Setup\nwindow._wails = window._wails || {};\nwindow._wails.dispatchWailsEvent = dispatchWailsEvent;\n\nconst call = newRuntimeCaller(objectNames.Events);\nconst EmitMethod = 0;\n\nexport { Types } from \"./event_types.js\";\n\n/**\n * The type of handlers for a given event.\n */\nexport type Callback = (ev: WailsEvent) => void;\n\n/**\n * Represents a system event or a custom event emitted through wails-provided facilities.\n */\nexport class WailsEvent {\n    /**\n     * The name of the event.\n     */\n    name: string;\n\n    /**\n     * Optional data associated with the emitted event.\n     */\n    data: any;\n\n    /**\n     * Name of the originating window. Omitted for application events.\n     * Will be overridden if set manually.\n     */\n    sender?: string;\n\n    constructor(name: string, data: any = null) {\n        this.name = name;\n        this.data = data;\n    }\n}\n\nfunction dispatchWailsEvent(event: any) {\n    let listeners = eventListeners.get(event.name);\n    if (!listeners) {\n        return;\n    }\n\n    let wailsEvent = new WailsEvent(event.name, event.data);\n    if ('sender' in event) {\n        wailsEvent.sender = event.sender;\n    }\n\n    listeners = listeners.filter(listener => !listener.dispatch(wailsEvent));\n    if (listeners.length === 0) {\n        eventListeners.delete(event.name);\n    } else {\n        eventListeners.set(event.name, listeners);\n    }\n}\n\n/**\n * Register a callback function to be called multiple times for a specific event.\n *\n * @param eventName - The name of the event to register the callback for.\n * @param callback - The callback function to be called when the event is triggered.\n * @param maxCallbacks - The maximum number of times the callback can be called for the event. Once the maximum number is reached, the callback will no longer be called.\n * @returns A function that, when called, will unregister the callback from the event.\n */\nexport function OnMultiple(eventName: string, callback: Callback, maxCallbacks: number) {\n    let listeners = eventListeners.get(eventName) || [];\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\n    listeners.push(thisListener);\n    eventListeners.set(eventName, listeners);\n    return () => listenerOff(thisListener);\n}\n\n/**\n * Registers a callback function to be executed when the specified event occurs.\n *\n * @param eventName - The name of the event to register the callback for.\n * @param callback - The callback function to be called when the event is triggered.\n * @returns A function that, when called, will unregister the callback from the event.\n */\nexport function On(eventName: string, callback: Callback): () => void {\n    return OnMultiple(eventName, callback, -1);\n}\n\n/**\n * Registers a callback function to be executed only once for the specified event.\n *\n * @param eventName - The name of the event to register the callback for.\n * @param callback - The callback function to be called when the event is triggered.\n * @returns A function that, when called, will unregister the callback from the event.\n */\nexport function Once(eventName: string, callback: Callback): () => void {\n    return OnMultiple(eventName, callback, 1);\n}\n\n/**\n * Removes event listeners for the specified event names.\n *\n * @param eventNames - The name of the events to remove listeners for.\n */\nexport function Off(...eventNames: [string, ...string[]]): void {\n    eventNames.forEach(eventName => eventListeners.delete(eventName));\n}\n\n/**\n * Removes all event listeners.\n */\nexport function OffAll(): void {\n    eventListeners.clear();\n}\n\n/**\n * Emits an event using the name and data.\n *\n * @returns A promise that will be fulfilled once the event has been emitted.\n * @param name - the name of the event to emit.\n * @param data - the data to be sent with the event.\n */\nexport function Emit(name: string, data?: any): Promise<void> {\n    let eventName: string;\n    let eventData: any;\n\n    if (typeof name === 'object' && name !== null && 'name' in name && 'data' in name) {\n        // If name is an object with a name property, use it directly\n        eventName = name['name'];\n        eventData = name['data'];\n    } else {\n        // Otherwise use the standard parameters\n        eventName = name as string;\n        eventData = data;\n    }\n\n    return call(EmitMethod, { name: eventName, data: eventData });\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// The following utilities have been factored out of ./events.ts\n// for testing purposes.\n\nexport const eventListeners = new Map<string, Listener[]>();\n\nexport class Listener {\n    eventName: string;\n    callback: (data: any) => void;\n    maxCallbacks: number;\n\n    constructor(eventName: string, callback: (data: any) => void, maxCallbacks: number) {\n        this.eventName = eventName;\n        this.callback = callback;\n        this.maxCallbacks = maxCallbacks || -1;\n    }\n\n    dispatch(data: any): boolean {\n        try {\n            this.callback(data);\n        } catch (err) {\n            console.error(err);\n        }\n\n        if (this.maxCallbacks === -1) return false;\n        this.maxCallbacks -= 1;\n        return this.maxCallbacks === 0;\n    }\n}\n\nexport function listenerOff(listener: Listener): void {\n    let listeners = eventListeners.get(listener.eventName);\n    if (!listeners) {\n        return;\n    }\n\n    listeners = listeners.filter(l => l !== listener);\n    if (listeners.length === 0) {\n        eventListeners.delete(listener.eventName);\n    } else {\n        eventListeners.set(listener.eventName, listeners);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH \u00C2 MODIWL\n// This file is automatically generated. DO NOT EDIT\n\nexport const Types = Object.freeze({\n\tWindows: Object.freeze({\n\t\tAPMPowerSettingChange: \"windows:APMPowerSettingChange\",\n\t\tAPMPowerStatusChange: \"windows:APMPowerStatusChange\",\n\t\tAPMResumeAutomatic: \"windows:APMResumeAutomatic\",\n\t\tAPMResumeSuspend: \"windows:APMResumeSuspend\",\n\t\tAPMSuspend: \"windows:APMSuspend\",\n\t\tApplicationStarted: \"windows:ApplicationStarted\",\n\t\tSystemThemeChanged: \"windows:SystemThemeChanged\",\n\t\tWebViewNavigationCompleted: \"windows:WebViewNavigationCompleted\",\n\t\tWindowActive: \"windows:WindowActive\",\n\t\tWindowBackgroundErase: \"windows:WindowBackgroundErase\",\n\t\tWindowClickActive: \"windows:WindowClickActive\",\n\t\tWindowClosing: \"windows:WindowClosing\",\n\t\tWindowDidMove: \"windows:WindowDidMove\",\n\t\tWindowDidResize: \"windows:WindowDidResize\",\n\t\tWindowDPIChanged: \"windows:WindowDPIChanged\",\n\t\tWindowDragDrop: \"windows:WindowDragDrop\",\n\t\tWindowDragEnter: \"windows:WindowDragEnter\",\n\t\tWindowDragLeave: \"windows:WindowDragLeave\",\n\t\tWindowDragOver: \"windows:WindowDragOver\",\n\t\tWindowEndMove: \"windows:WindowEndMove\",\n\t\tWindowEndResize: \"windows:WindowEndResize\",\n\t\tWindowFullscreen: \"windows:WindowFullscreen\",\n\t\tWindowHide: \"windows:WindowHide\",\n\t\tWindowInactive: \"windows:WindowInactive\",\n\t\tWindowKeyDown: \"windows:WindowKeyDown\",\n\t\tWindowKeyUp: \"windows:WindowKeyUp\",\n\t\tWindowKillFocus: \"windows:WindowKillFocus\",\n\t\tWindowNonClientHit: \"windows:WindowNonClientHit\",\n\t\tWindowNonClientMouseDown: \"windows:WindowNonClientMouseDown\",\n\t\tWindowNonClientMouseLeave: \"windows:WindowNonClientMouseLeave\",\n\t\tWindowNonClientMouseMove: \"windows:WindowNonClientMouseMove\",\n\t\tWindowNonClientMouseUp: \"windows:WindowNonClientMouseUp\",\n\t\tWindowPaint: \"windows:WindowPaint\",\n\t\tWindowRestore: \"windows:WindowRestore\",\n\t\tWindowSetFocus: \"windows:WindowSetFocus\",\n\t\tWindowShow: \"windows:WindowShow\",\n\t\tWindowStartMove: \"windows:WindowStartMove\",\n\t\tWindowStartResize: \"windows:WindowStartResize\",\n\t\tWindowUnFullscreen: \"windows:WindowUnFullscreen\",\n\t\tWindowZOrderChanged: \"windows:WindowZOrderChanged\",\n\t\tWindowMinimise: \"windows:WindowMinimise\",\n\t\tWindowUnMinimise: \"windows:WindowUnMinimise\",\n\t\tWindowMaximise: \"windows:WindowMaximise\",\n\t\tWindowUnMaximise: \"windows:WindowUnMaximise\",\n\t}),\n\tMac: Object.freeze({\n\t\tApplicationDidBecomeActive: \"mac:ApplicationDidBecomeActive\",\n\t\tApplicationDidChangeBackingProperties: \"mac:ApplicationDidChangeBackingProperties\",\n\t\tApplicationDidChangeEffectiveAppearance: \"mac:ApplicationDidChangeEffectiveAppearance\",\n\t\tApplicationDidChangeIcon: \"mac:ApplicationDidChangeIcon\",\n\t\tApplicationDidChangeOcclusionState: \"mac:ApplicationDidChangeOcclusionState\",\n\t\tApplicationDidChangeScreenParameters: \"mac:ApplicationDidChangeScreenParameters\",\n\t\tApplicationDidChangeStatusBarFrame: \"mac:ApplicationDidChangeStatusBarFrame\",\n\t\tApplicationDidChangeStatusBarOrientation: \"mac:ApplicationDidChangeStatusBarOrientation\",\n\t\tApplicationDidChangeTheme: \"mac:ApplicationDidChangeTheme\",\n\t\tApplicationDidFinishLaunching: \"mac:ApplicationDidFinishLaunching\",\n\t\tApplicationDidHide: \"mac:ApplicationDidHide\",\n\t\tApplicationDidResignActive: \"mac:ApplicationDidResignActive\",\n\t\tApplicationDidUnhide: \"mac:ApplicationDidUnhide\",\n\t\tApplicationDidUpdate: \"mac:ApplicationDidUpdate\",\n\t\tApplicationShouldHandleReopen: \"mac:ApplicationShouldHandleReopen\",\n\t\tApplicationWillBecomeActive: \"mac:ApplicationWillBecomeActive\",\n\t\tApplicationWillFinishLaunching: \"mac:ApplicationWillFinishLaunching\",\n\t\tApplicationWillHide: \"mac:ApplicationWillHide\",\n\t\tApplicationWillResignActive: \"mac:ApplicationWillResignActive\",\n\t\tApplicationWillTerminate: \"mac:ApplicationWillTerminate\",\n\t\tApplicationWillUnhide: \"mac:ApplicationWillUnhide\",\n\t\tApplicationWillUpdate: \"mac:ApplicationWillUpdate\",\n\t\tMenuDidAddItem: \"mac:MenuDidAddItem\",\n\t\tMenuDidBeginTracking: \"mac:MenuDidBeginTracking\",\n\t\tMenuDidClose: \"mac:MenuDidClose\",\n\t\tMenuDidDisplayItem: \"mac:MenuDidDisplayItem\",\n\t\tMenuDidEndTracking: \"mac:MenuDidEndTracking\",\n\t\tMenuDidHighlightItem: \"mac:MenuDidHighlightItem\",\n\t\tMenuDidOpen: \"mac:MenuDidOpen\",\n\t\tMenuDidPopUp: \"mac:MenuDidPopUp\",\n\t\tMenuDidRemoveItem: \"mac:MenuDidRemoveItem\",\n\t\tMenuDidSendAction: \"mac:MenuDidSendAction\",\n\t\tMenuDidSendActionToItem: \"mac:MenuDidSendActionToItem\",\n\t\tMenuDidUpdate: \"mac:MenuDidUpdate\",\n\t\tMenuWillAddItem: \"mac:MenuWillAddItem\",\n\t\tMenuWillBeginTracking: \"mac:MenuWillBeginTracking\",\n\t\tMenuWillDisplayItem: \"mac:MenuWillDisplayItem\",\n\t\tMenuWillEndTracking: \"mac:MenuWillEndTracking\",\n\t\tMenuWillHighlightItem: \"mac:MenuWillHighlightItem\",\n\t\tMenuWillOpen: \"mac:MenuWillOpen\",\n\t\tMenuWillPopUp: \"mac:MenuWillPopUp\",\n\t\tMenuWillRemoveItem: \"mac:MenuWillRemoveItem\",\n\t\tMenuWillSendAction: \"mac:MenuWillSendAction\",\n\t\tMenuWillSendActionToItem: \"mac:MenuWillSendActionToItem\",\n\t\tMenuWillUpdate: \"mac:MenuWillUpdate\",\n\t\tWebViewDidCommitNavigation: \"mac:WebViewDidCommitNavigation\",\n\t\tWebViewDidFinishNavigation: \"mac:WebViewDidFinishNavigation\",\n\t\tWebViewDidReceiveServerRedirectForProvisionalNavigation: \"mac:WebViewDidReceiveServerRedirectForProvisionalNavigation\",\n\t\tWebViewDidStartProvisionalNavigation: \"mac:WebViewDidStartProvisionalNavigation\",\n\t\tWindowDidBecomeKey: \"mac:WindowDidBecomeKey\",\n\t\tWindowDidBecomeMain: \"mac:WindowDidBecomeMain\",\n\t\tWindowDidBeginSheet: \"mac:WindowDidBeginSheet\",\n\t\tWindowDidChangeAlpha: \"mac:WindowDidChangeAlpha\",\n\t\tWindowDidChangeBackingLocation: \"mac:WindowDidChangeBackingLocation\",\n\t\tWindowDidChangeBackingProperties: \"mac:WindowDidChangeBackingProperties\",\n\t\tWindowDidChangeCollectionBehavior: \"mac:WindowDidChangeCollectionBehavior\",\n\t\tWindowDidChangeEffectiveAppearance: \"mac:WindowDidChangeEffectiveAppearance\",\n\t\tWindowDidChangeOcclusionState: \"mac:WindowDidChangeOcclusionState\",\n\t\tWindowDidChangeOrderingMode: \"mac:WindowDidChangeOrderingMode\",\n\t\tWindowDidChangeScreen: \"mac:WindowDidChangeScreen\",\n\t\tWindowDidChangeScreenParameters: \"mac:WindowDidChangeScreenParameters\",\n\t\tWindowDidChangeScreenProfile: \"mac:WindowDidChangeScreenProfile\",\n\t\tWindowDidChangeScreenSpace: \"mac:WindowDidChangeScreenSpace\",\n\t\tWindowDidChangeScreenSpaceProperties: \"mac:WindowDidChangeScreenSpaceProperties\",\n\t\tWindowDidChangeSharingType: \"mac:WindowDidChangeSharingType\",\n\t\tWindowDidChangeSpace: \"mac:WindowDidChangeSpace\",\n\t\tWindowDidChangeSpaceOrderingMode: \"mac:WindowDidChangeSpaceOrderingMode\",\n\t\tWindowDidChangeTitle: \"mac:WindowDidChangeTitle\",\n\t\tWindowDidChangeToolbar: \"mac:WindowDidChangeToolbar\",\n\t\tWindowDidDeminiaturize: \"mac:WindowDidDeminiaturize\",\n\t\tWindowDidEndSheet: \"mac:WindowDidEndSheet\",\n\t\tWindowDidEnterFullScreen: \"mac:WindowDidEnterFullScreen\",\n\t\tWindowDidEnterVersionBrowser: \"mac:WindowDidEnterVersionBrowser\",\n\t\tWindowDidExitFullScreen: \"mac:WindowDidExitFullScreen\",\n\t\tWindowDidExitVersionBrowser: \"mac:WindowDidExitVersionBrowser\",\n\t\tWindowDidExpose: \"mac:WindowDidExpose\",\n\t\tWindowDidFocus: \"mac:WindowDidFocus\",\n\t\tWindowDidMiniaturize: \"mac:WindowDidMiniaturize\",\n\t\tWindowDidMove: \"mac:WindowDidMove\",\n\t\tWindowDidOrderOffScreen: \"mac:WindowDidOrderOffScreen\",\n\t\tWindowDidOrderOnScreen: \"mac:WindowDidOrderOnScreen\",\n\t\tWindowDidResignKey: \"mac:WindowDidResignKey\",\n\t\tWindowDidResignMain: \"mac:WindowDidResignMain\",\n\t\tWindowDidResize: \"mac:WindowDidResize\",\n\t\tWindowDidUpdate: \"mac:WindowDidUpdate\",\n\t\tWindowDidUpdateAlpha: \"mac:WindowDidUpdateAlpha\",\n\t\tWindowDidUpdateCollectionBehavior: \"mac:WindowDidUpdateCollectionBehavior\",\n\t\tWindowDidUpdateCollectionProperties: \"mac:WindowDidUpdateCollectionProperties\",\n\t\tWindowDidUpdateShadow: \"mac:WindowDidUpdateShadow\",\n\t\tWindowDidUpdateTitle: \"mac:WindowDidUpdateTitle\",\n\t\tWindowDidUpdateToolbar: \"mac:WindowDidUpdateToolbar\",\n\t\tWindowDidZoom: \"mac:WindowDidZoom\",\n\t\tWindowFileDraggingEntered: \"mac:WindowFileDraggingEntered\",\n\t\tWindowFileDraggingExited: \"mac:WindowFileDraggingExited\",\n\t\tWindowFileDraggingPerformed: \"mac:WindowFileDraggingPerformed\",\n\t\tWindowHide: \"mac:WindowHide\",\n\t\tWindowMaximise: \"mac:WindowMaximise\",\n\t\tWindowUnMaximise: \"mac:WindowUnMaximise\",\n\t\tWindowMinimise: \"mac:WindowMinimise\",\n\t\tWindowUnMinimise: \"mac:WindowUnMinimise\",\n\t\tWindowShouldClose: \"mac:WindowShouldClose\",\n\t\tWindowShow: \"mac:WindowShow\",\n\t\tWindowWillBecomeKey: \"mac:WindowWillBecomeKey\",\n\t\tWindowWillBecomeMain: \"mac:WindowWillBecomeMain\",\n\t\tWindowWillBeginSheet: \"mac:WindowWillBeginSheet\",\n\t\tWindowWillChangeOrderingMode: \"mac:WindowWillChangeOrderingMode\",\n\t\tWindowWillClose: \"mac:WindowWillClose\",\n\t\tWindowWillDeminiaturize: \"mac:WindowWillDeminiaturize\",\n\t\tWindowWillEnterFullScreen: \"mac:WindowWillEnterFullScreen\",\n\t\tWindowWillEnterVersionBrowser: \"mac:WindowWillEnterVersionBrowser\",\n\t\tWindowWillExitFullScreen: \"mac:WindowWillExitFullScreen\",\n\t\tWindowWillExitVersionBrowser: \"mac:WindowWillExitVersionBrowser\",\n\t\tWindowWillFocus: \"mac:WindowWillFocus\",\n\t\tWindowWillMiniaturize: \"mac:WindowWillMiniaturize\",\n\t\tWindowWillMove: \"mac:WindowWillMove\",\n\t\tWindowWillOrderOffScreen: \"mac:WindowWillOrderOffScreen\",\n\t\tWindowWillOrderOnScreen: \"mac:WindowWillOrderOnScreen\",\n\t\tWindowWillResignMain: \"mac:WindowWillResignMain\",\n\t\tWindowWillResize: \"mac:WindowWillResize\",\n\t\tWindowWillUnfocus: \"mac:WindowWillUnfocus\",\n\t\tWindowWillUpdate: \"mac:WindowWillUpdate\",\n\t\tWindowWillUpdateAlpha: \"mac:WindowWillUpdateAlpha\",\n\t\tWindowWillUpdateCollectionBehavior: \"mac:WindowWillUpdateCollectionBehavior\",\n\t\tWindowWillUpdateCollectionProperties: \"mac:WindowWillUpdateCollectionProperties\",\n\t\tWindowWillUpdateShadow: \"mac:WindowWillUpdateShadow\",\n\t\tWindowWillUpdateTitle: \"mac:WindowWillUpdateTitle\",\n\t\tWindowWillUpdateToolbar: \"mac:WindowWillUpdateToolbar\",\n\t\tWindowWillUpdateVisibility: \"mac:WindowWillUpdateVisibility\",\n\t\tWindowWillUseStandardFrame: \"mac:WindowWillUseStandardFrame\",\n\t\tWindowZoomIn: \"mac:WindowZoomIn\",\n\t\tWindowZoomOut: \"mac:WindowZoomOut\",\n\t\tWindowZoomReset: \"mac:WindowZoomReset\",\n\t}),\n\tLinux: Object.freeze({\n\t\tApplicationStartup: \"linux:ApplicationStartup\",\n\t\tSystemThemeChanged: \"linux:SystemThemeChanged\",\n\t\tWindowDeleteEvent: \"linux:WindowDeleteEvent\",\n\t\tWindowDidMove: \"linux:WindowDidMove\",\n\t\tWindowDidResize: \"linux:WindowDidResize\",\n\t\tWindowFocusIn: \"linux:WindowFocusIn\",\n\t\tWindowFocusOut: \"linux:WindowFocusOut\",\n\t\tWindowLoadChanged: \"linux:WindowLoadChanged\",\n\t}),\n\tiOS: Object.freeze({\n\t\tApplicationDidBecomeActive: \"ios:ApplicationDidBecomeActive\",\n\t\tApplicationDidEnterBackground: \"ios:ApplicationDidEnterBackground\",\n\t\tApplicationDidFinishLaunching: \"ios:ApplicationDidFinishLaunching\",\n\t\tApplicationDidReceiveMemoryWarning: \"ios:ApplicationDidReceiveMemoryWarning\",\n\t\tApplicationWillEnterForeground: \"ios:ApplicationWillEnterForeground\",\n\t\tApplicationWillResignActive: \"ios:ApplicationWillResignActive\",\n\t\tApplicationWillTerminate: \"ios:ApplicationWillTerminate\",\n\t\tWindowDidLoad: \"ios:WindowDidLoad\",\n\t\tWindowWillAppear: \"ios:WindowWillAppear\",\n\t\tWindowDidAppear: \"ios:WindowDidAppear\",\n\t\tWindowWillDisappear: \"ios:WindowWillDisappear\",\n\t\tWindowDidDisappear: \"ios:WindowDidDisappear\",\n\t\tWindowSafeAreaInsetsChanged: \"ios:WindowSafeAreaInsetsChanged\",\n\t\tWindowOrientationChanged: \"ios:WindowOrientationChanged\",\n\t\tWindowTouchBegan: \"ios:WindowTouchBegan\",\n\t\tWindowTouchMoved: \"ios:WindowTouchMoved\",\n\t\tWindowTouchEnded: \"ios:WindowTouchEnded\",\n\t\tWindowTouchCancelled: \"ios:WindowTouchCancelled\",\n\t\tWebViewDidStartNavigation: \"ios:WebViewDidStartNavigation\",\n\t\tWebViewDidFinishNavigation: \"ios:WebViewDidFinishNavigation\",\n\t\tWebViewDidFailNavigation: \"ios:WebViewDidFailNavigation\",\n\t\tWebViewDecidePolicyForNavigationAction: \"ios:WebViewDecidePolicyForNavigationAction\",\n\t}),\n\tCommon: Object.freeze({\n\t\tApplicationOpenedWithFile: \"common:ApplicationOpenedWithFile\",\n\t\tApplicationStarted: \"common:ApplicationStarted\",\n\t\tApplicationLaunchedWithUrl: \"common:ApplicationLaunchedWithUrl\",\n\t\tThemeChanged: \"common:ThemeChanged\",\n\t\tWindowClosing: \"common:WindowClosing\",\n\t\tWindowDidMove: \"common:WindowDidMove\",\n\t\tWindowDidResize: \"common:WindowDidResize\",\n\t\tWindowDPIChanged: \"common:WindowDPIChanged\",\n\t\tWindowFilesDropped: \"common:WindowFilesDropped\",\n\t\tWindowFocus: \"common:WindowFocus\",\n\t\tWindowFullscreen: \"common:WindowFullscreen\",\n\t\tWindowHide: \"common:WindowHide\",\n\t\tWindowLostFocus: \"common:WindowLostFocus\",\n\t\tWindowMaximise: \"common:WindowMaximise\",\n\t\tWindowMinimise: \"common:WindowMinimise\",\n\t\tWindowToggleFrameless: \"common:WindowToggleFrameless\",\n\t\tWindowRestore: \"common:WindowRestore\",\n\t\tWindowRuntimeReady: \"common:WindowRuntimeReady\",\n\t\tWindowShow: \"common:WindowShow\",\n\t\tWindowUnFullscreen: \"common:WindowUnFullscreen\",\n\t\tWindowUnMaximise: \"common:WindowUnMaximise\",\n\t\tWindowUnMinimise: \"common:WindowUnMinimise\",\n\t\tWindowZoom: \"common:WindowZoom\",\n\t\tWindowZoomIn: \"common:WindowZoomIn\",\n\t\tWindowZoomOut: \"common:WindowZoomOut\",\n\t\tWindowZoomReset: \"common:WindowZoomReset\",\n\t\tWindowDropZoneFilesDropped: \"common:WindowDropZoneFilesDropped\",\n\t}),\n});\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Logs a message to the console with custom formatting.\n *\n * @param message - The message to be logged.\n */\nexport function debugLog(message: any) {\n    // eslint-disable-next-line\n    console.log(\n        '%c wails3 %c ' + message + ' ',\n        'background: #aa0000; color: #fff; border-radius: 3px 0px 0px 3px; padding: 1px; font-size: 0.7rem',\n        'background: #009900; color: #fff; border-radius: 0px 3px 3px 0px; padding: 1px; font-size: 0.7rem'\n    );\n}\n\n/**\n * Checks whether the webview supports the {@link MouseEvent#buttons} property.\n * Looking at you macOS High Sierra!\n */\nexport function canTrackButtons(): boolean {\n    return (new MouseEvent('mousedown')).buttons === 0;\n}\n\n/**\n * Checks whether the browser supports removing listeners by triggering an AbortSignal\n * (see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#signal).\n */\nexport function canAbortListeners() {\n    if (!EventTarget || !AbortSignal || !AbortController)\n        return false;\n\n    let result = true;\n\n    const target = new EventTarget();\n    const controller = new AbortController();\n    target.addEventListener('test', () => { result = false; }, { signal: controller.signal });\n    controller.abort();\n    target.dispatchEvent(new CustomEvent('test'));\n\n    return result;\n}\n\n/**\n * Resolves the closest HTMLElement ancestor of an event's target.\n */\nexport function eventTarget(event: Event): HTMLElement {\n    if (event.target instanceof HTMLElement) {\n        return event.target;\n    } else if (!(event.target instanceof HTMLElement) && event.target instanceof Node) {\n        return event.target.parentElement ?? document.body;\n    } else {\n        return document.body;\n    }\n}\n\n/***\n This technique for proper load detection is taken from HTMX:\n\n BSD 2-Clause License\n\n Copyright (c) 2020, Big Sky Software\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions are met:\n\n 1. Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n ***/\n\nlet isReady = false;\ndocument.addEventListener('DOMContentLoaded', () => { isReady = true });\n\nexport function whenReady(callback: () => void) {\n    if (isReady || document.readyState === 'complete') {\n        callback();\n    } else {\n        document.addEventListener('DOMContentLoaded', callback);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\nimport type { Screen } from \"./screens.js\";\n\n// NEW: Dropzone constants\nconst DROPZONE_ATTRIBUTE = 'data-wails-dropzone';\nconst DROPZONE_HOVER_CLASS = 'wails-dropzone-hover'; // User can style this class\nlet currentHoveredDropzone: Element | null = null;\n\nconst PositionMethod                    = 0;\nconst CenterMethod                      = 1;\nconst CloseMethod                       = 2;\nconst DisableSizeConstraintsMethod      = 3;\nconst EnableSizeConstraintsMethod       = 4;\nconst FocusMethod                       = 5;\nconst ForceReloadMethod                 = 6;\nconst FullscreenMethod                  = 7;\nconst GetScreenMethod                   = 8;\nconst GetZoomMethod                     = 9;\nconst HeightMethod                      = 10;\nconst HideMethod                        = 11;\nconst IsFocusedMethod                   = 12;\nconst IsFullscreenMethod                = 13;\nconst IsMaximisedMethod                 = 14;\nconst IsMinimisedMethod                 = 15;\nconst MaximiseMethod                    = 16;\nconst MinimiseMethod                    = 17;\nconst NameMethod                        = 18;\nconst OpenDevToolsMethod                = 19;\nconst RelativePositionMethod            = 20;\nconst ReloadMethod                      = 21;\nconst ResizableMethod                   = 22;\nconst RestoreMethod                     = 23;\nconst SetPositionMethod                 = 24;\nconst SetAlwaysOnTopMethod              = 25;\nconst SetBackgroundColourMethod         = 26;\nconst SetFramelessMethod                = 27;\nconst SetFullscreenButtonEnabledMethod  = 28;\nconst SetMaxSizeMethod                  = 29;\nconst SetMinSizeMethod                  = 30;\nconst SetRelativePositionMethod         = 31;\nconst SetResizableMethod                = 32;\nconst SetSizeMethod                     = 33;\nconst SetTitleMethod                    = 34;\nconst SetZoomMethod                     = 35;\nconst ShowMethod                        = 36;\nconst SizeMethod                        = 37;\nconst ToggleFullscreenMethod            = 38;\nconst ToggleMaximiseMethod              = 39;\nconst ToggleFramelessMethod             = 40; \nconst UnFullscreenMethod                = 41;\nconst UnMaximiseMethod                  = 42;\nconst UnMinimiseMethod                  = 43;\nconst WidthMethod                       = 44;\nconst ZoomMethod                        = 45;\nconst ZoomInMethod                      = 46;\nconst ZoomOutMethod                     = 47;\nconst ZoomResetMethod                   = 48;\nconst SnapAssistMethod                  = 49;\nconst WindowDropZoneDropped             = 50;\n\nfunction getDropzoneElement(element: Element | null): Element | null {\n    if (!element) {\n        return null;\n    }\n    // Allow dropzone attribute to be on the element itself or any parent\n    return element.closest(`[${DROPZONE_ATTRIBUTE}]`);\n}\n\n/**\n * A record describing the position of a window.\n */\ninterface Position {\n    /** The horizontal position of the window. */\n    x: number;\n    /** The vertical position of the window. */\n    y: number;\n}\n\n/**\n * A record describing the size of a window.\n */\ninterface Size {\n    /** The width of the window. */\n    width: number;\n    /** The height of the window. */\n    height: number;\n}\n\n// Private field names.\nconst callerSym = Symbol(\"caller\");\n\nclass Window {\n    // Private fields.\n    private [callerSym]: (message: number, args?: any) => Promise<any>;\n\n    /**\n     * Initialises a window object with the specified name.\n     *\n     * @private\n     * @param name - The name of the target window.\n     */\n    constructor(name: string = '') {\n        this[callerSym] = newRuntimeCaller(objectNames.Window, name)\n\n        // bind instance method to make them easily usable in event handlers\n        for (const method of Object.getOwnPropertyNames(Window.prototype)) {\n            if (\n                method !== \"constructor\"\n                && typeof (this as any)[method] === \"function\"\n            ) {\n                (this as any)[method] = (this as any)[method].bind(this);\n            }\n        }\n    }\n\n    /**\n     * Gets the specified window.\n     *\n     * @param name - The name of the window to get.\n     * @returns The corresponding window object.\n     */\n    Get(name: string): Window {\n        return new Window(name);\n    }\n\n    /**\n     * Returns the absolute position of the window.\n     *\n     * @returns The current absolute position of the window.\n     */\n    Position(): Promise<Position> {\n        return this[callerSym](PositionMethod);\n    }\n\n    /**\n     * Centers the window on the screen.\n     */\n    Center(): Promise<void> {\n        return this[callerSym](CenterMethod);\n    }\n\n    /**\n     * Closes the window.\n     */\n    Close(): Promise<void> {\n        return this[callerSym](CloseMethod);\n    }\n\n    /**\n     * Disables min/max size constraints.\n     */\n    DisableSizeConstraints(): Promise<void> {\n        return this[callerSym](DisableSizeConstraintsMethod);\n    }\n\n    /**\n     * Enables min/max size constraints.\n     */\n    EnableSizeConstraints(): Promise<void> {\n        return this[callerSym](EnableSizeConstraintsMethod);\n    }\n\n    /**\n     * Focuses the window.\n     */\n    Focus(): Promise<void> {\n        return this[callerSym](FocusMethod);\n    }\n\n    /**\n     * Forces the window to reload the page assets.\n     */\n    ForceReload(): Promise<void> {\n        return this[callerSym](ForceReloadMethod);\n    }\n\n    /**\n     * Switches the window to fullscreen mode.\n     */\n    Fullscreen(): Promise<void> {\n        return this[callerSym](FullscreenMethod);\n    }\n\n    /**\n     * Returns the screen that the window is on.\n     *\n     * @returns The screen the window is currently on.\n     */\n    GetScreen(): Promise<Screen> {\n        return this[callerSym](GetScreenMethod);\n    }\n\n    /**\n     * Returns the current zoom level of the window.\n     *\n     * @returns The current zoom level.\n     */\n    GetZoom(): Promise<number> {\n        return this[callerSym](GetZoomMethod);\n    }\n\n    /**\n     * Returns the height of the window.\n     *\n     * @returns The current height of the window.\n     */\n    Height(): Promise<number> {\n        return this[callerSym](HeightMethod);\n    }\n\n    /**\n     * Hides the window.\n     */\n    Hide(): Promise<void> {\n        return this[callerSym](HideMethod);\n    }\n\n    /**\n     * Returns true if the window is focused.\n     *\n     * @returns Whether the window is currently focused.\n     */\n    IsFocused(): Promise<boolean> {\n        return this[callerSym](IsFocusedMethod);\n    }\n\n    /**\n     * Returns true if the window is fullscreen.\n     *\n     * @returns Whether the window is currently fullscreen.\n     */\n    IsFullscreen(): Promise<boolean> {\n        return this[callerSym](IsFullscreenMethod);\n    }\n\n    /**\n     * Returns true if the window is maximised.\n     *\n     * @returns Whether the window is currently maximised.\n     */\n    IsMaximised(): Promise<boolean> {\n        return this[callerSym](IsMaximisedMethod);\n    }\n\n    /**\n     * Returns true if the window is minimised.\n     *\n     * @returns Whether the window is currently minimised.\n     */\n    IsMinimised(): Promise<boolean> {\n        return this[callerSym](IsMinimisedMethod);\n    }\n\n    /**\n     * Maximises the window.\n     */\n    Maximise(): Promise<void> {\n        return this[callerSym](MaximiseMethod);\n    }\n\n    /**\n     * Minimises the window.\n     */\n    Minimise(): Promise<void> {\n        return this[callerSym](MinimiseMethod);\n    }\n\n    /**\n     * Returns the name of the window.\n     *\n     * @returns The name of the window.\n     */\n    Name(): Promise<string> {\n        return this[callerSym](NameMethod);\n    }\n\n    /**\n     * Opens the development tools pane.\n     */\n    OpenDevTools(): Promise<void> {\n        return this[callerSym](OpenDevToolsMethod);\n    }\n\n    /**\n     * Returns the relative position of the window to the screen.\n     *\n     * @returns The current relative position of the window.\n     */\n    RelativePosition(): Promise<Position> {\n        return this[callerSym](RelativePositionMethod);\n    }\n\n    /**\n     * Reloads the page assets.\n     */\n    Reload(): Promise<void> {\n        return this[callerSym](ReloadMethod);\n    }\n\n    /**\n     * Returns true if the window is resizable.\n     *\n     * @returns Whether the window is currently resizable.\n     */\n    Resizable(): Promise<boolean> {\n        return this[callerSym](ResizableMethod);\n    }\n\n    /**\n     * Restores the window to its previous state if it was previously minimised, maximised or fullscreen.\n     */\n    Restore(): Promise<void> {\n        return this[callerSym](RestoreMethod);\n    }\n\n    /**\n     * Sets the absolute position of the window.\n     *\n     * @param x - The desired horizontal absolute position of the window.\n     * @param y - The desired vertical absolute position of the window.\n     */\n    SetPosition(x: number, y: number): Promise<void> {\n        return this[callerSym](SetPositionMethod, { x, y });\n    }\n\n    /**\n     * Sets the window to be always on top.\n     *\n     * @param alwaysOnTop - Whether the window should stay on top.\n     */\n    SetAlwaysOnTop(alwaysOnTop: boolean): Promise<void> {\n        return this[callerSym](SetAlwaysOnTopMethod, { alwaysOnTop });\n    }\n\n    /**\n     * Sets the background colour of the window.\n     *\n     * @param r - The desired red component of the window background.\n     * @param g - The desired green component of the window background.\n     * @param b - The desired blue component of the window background.\n     * @param a - The desired alpha component of the window background.\n     */\n    SetBackgroundColour(r: number, g: number, b: number, a: number): Promise<void> {\n        return this[callerSym](SetBackgroundColourMethod, { r, g, b, a });\n    }\n\n    /**\n     * Removes the window frame and title bar.\n     *\n     * @param frameless - Whether the window should be frameless.\n     */\n    SetFrameless(frameless: boolean): Promise<void> {\n        return this[callerSym](SetFramelessMethod, { frameless });\n    }\n\n    /**\n     * Disables the system fullscreen button.\n     *\n     * @param enabled - Whether the fullscreen button should be enabled.\n     */\n    SetFullscreenButtonEnabled(enabled: boolean): Promise<void> {\n        return this[callerSym](SetFullscreenButtonEnabledMethod, { enabled });\n    }\n\n    /**\n     * Sets the maximum size of the window.\n     *\n     * @param width - The desired maximum width of the window.\n     * @param height - The desired maximum height of the window.\n     */\n    SetMaxSize(width: number, height: number): Promise<void> {\n        return this[callerSym](SetMaxSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the minimum size of the window.\n     *\n     * @param width - The desired minimum width of the window.\n     * @param height - The desired minimum height of the window.\n     */\n    SetMinSize(width: number, height: number): Promise<void> {\n        return this[callerSym](SetMinSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the relative position of the window to the screen.\n     *\n     * @param x - The desired horizontal relative position of the window.\n     * @param y - The desired vertical relative position of the window.\n     */\n    SetRelativePosition(x: number, y: number): Promise<void> {\n        return this[callerSym](SetRelativePositionMethod, { x, y });\n    }\n\n    /**\n     * Sets whether the window is resizable.\n     *\n     * @param resizable - Whether the window should be resizable.\n     */\n    SetResizable(resizable: boolean): Promise<void> {\n        return this[callerSym](SetResizableMethod, { resizable });\n    }\n\n    /**\n     * Sets the size of the window.\n     *\n     * @param width - The desired width of the window.\n     * @param height - The desired height of the window.\n     */\n    SetSize(width: number, height: number): Promise<void> {\n        return this[callerSym](SetSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the title of the window.\n     *\n     * @param title - The desired title of the window.\n     */\n    SetTitle(title: string): Promise<void> {\n        return this[callerSym](SetTitleMethod, { title });\n    }\n\n    /**\n     * Sets the zoom level of the window.\n     *\n     * @param zoom - The desired zoom level.\n     */\n    SetZoom(zoom: number): Promise<void> {\n        return this[callerSym](SetZoomMethod, { zoom });\n    }\n\n    /**\n     * Shows the window.\n     */\n    Show(): Promise<void> {\n        return this[callerSym](ShowMethod);\n    }\n\n    /**\n     * Returns the size of the window.\n     *\n     * @returns The current size of the window.\n     */\n    Size(): Promise<Size> {\n        return this[callerSym](SizeMethod);\n    }\n\n    /**\n     * Toggles the window between fullscreen and normal.\n     */\n    ToggleFullscreen(): Promise<void> {\n        return this[callerSym](ToggleFullscreenMethod);\n    }\n\n    /**\n     * Toggles the window between maximised and normal.\n     */\n    ToggleMaximise(): Promise<void> {\n        return this[callerSym](ToggleMaximiseMethod);\n    }\n\n    /**\n     * Toggles the window between frameless and normal.\n     */\n    ToggleFrameless(): Promise<void> {\n        return this[callerSym](ToggleFramelessMethod);\n    }\n\n    /**\n     * Un-fullscreens the window.\n     */\n    UnFullscreen(): Promise<void> {\n        return this[callerSym](UnFullscreenMethod);\n    }\n\n    /**\n     * Un-maximises the window.\n     */\n    UnMaximise(): Promise<void> {\n        return this[callerSym](UnMaximiseMethod);\n    }\n\n    /**\n     * Un-minimises the window.\n     */\n    UnMinimise(): Promise<void> {\n        return this[callerSym](UnMinimiseMethod);\n    }\n\n    /**\n     * Returns the width of the window.\n     *\n     * @returns The current width of the window.\n     */\n    Width(): Promise<number> {\n        return this[callerSym](WidthMethod);\n    }\n\n    /**\n     * Zooms the window.\n     */\n    Zoom(): Promise<void> {\n        return this[callerSym](ZoomMethod);\n    }\n\n    /**\n     * Increases the zoom level of the webview content.\n     */\n    ZoomIn(): Promise<void> {\n        return this[callerSym](ZoomInMethod);\n    }\n\n    /**\n     * Decreases the zoom level of the webview content.\n     */\n    ZoomOut(): Promise<void> {\n        return this[callerSym](ZoomOutMethod);\n    }\n\n    /**\n     * Resets the zoom level of the webview content.\n     */\n    ZoomReset(): Promise<void> {\n        return this[callerSym](ZoomResetMethod);\n    }\n\n    /**\n     * Handles file drops originating from platform-specific code (e.g., macOS native drag-and-drop).\n     * Gathers information about the drop target element and sends it back to the Go backend.\n     *\n     * @param filenames - An array of file paths (strings) that were dropped.\n     * @param x - The x-coordinate of the drop event.\n     * @param y - The y-coordinate of the drop event.\n     */\n    HandlePlatformFileDrop(filenames: string[], x: number, y: number): void {\n        const element = document.elementFromPoint(x, y);\n\n        // NEW: Check if the drop target is a valid dropzone\n        const dropzoneTarget = getDropzoneElement(element);\n\n        if (!dropzoneTarget) {\n            console.log(`Wails Runtime: Drop on element (or no element) at ${x},${y} which is not a designated dropzone. Ignoring. Element:`, element);\n            // No need to call backend if not a valid dropzone target\n            return;\n        }\n\n        console.log(`Wails Runtime: Drop on designated dropzone. Element at (${x}, ${y}):`, element, 'Effective dropzone:', dropzoneTarget);\n        const elementDetails = {\n            id: dropzoneTarget.id,\n            classList: Array.from(dropzoneTarget.classList),\n            attributes: {} as { [key: string]: string },\n        };\n        for (let i = 0; i < dropzoneTarget.attributes.length; i++) {\n            const attr = dropzoneTarget.attributes[i];\n            elementDetails.attributes[attr.name] = attr.value;\n        }\n\n        const payload = {\n            filenames,\n            x,\n            y,\n            elementDetails,\n        };\n\n        this[callerSym](WindowDropZoneDropped, payload);\n    }\n  \n    /* Triggers Windows 11 Snap Assist feature (Windows only).\n     * This is equivalent to pressing Win+Z and shows snap layout options.\n     */\n    SnapAssist(): Promise<void> {\n        return this[callerSym](SnapAssistMethod);\n    }\n}\n\n/**\n * The window within which the script is running.\n */\nconst thisWindow = new Window('');\n\n// NEW: Global Drag Event Listeners\nfunction setupGlobalDropzoneListeners() {\n    const docElement = document.documentElement;\n    let dragEnterCounter = 0; // To handle dragenter/dragleave on child elements\n\n    docElement.addEventListener('dragenter', (event) => {\n        event.preventDefault();\n        if (event.dataTransfer && event.dataTransfer.types.includes('Files')) {\n            dragEnterCounter++;\n            const targetElement = document.elementFromPoint(event.clientX, event.clientY);\n            const dropzone = getDropzoneElement(targetElement);\n\n            // Clear previous hover regardless, then apply new if valid\n            if (currentHoveredDropzone && currentHoveredDropzone !== dropzone) {\n                currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS);\n            }\n\n            if (dropzone) {\n                dropzone.classList.add(DROPZONE_HOVER_CLASS);\n                event.dataTransfer.dropEffect = 'copy';\n                currentHoveredDropzone = dropzone;\n            } else {\n                event.dataTransfer.dropEffect = 'none';\n                currentHoveredDropzone = null; // Ensure it's cleared if no dropzone found\n            }\n        }\n    }, false);\n\n    docElement.addEventListener('dragover', (event) => {\n        event.preventDefault(); // Necessary to allow drop\n        if (event.dataTransfer && event.dataTransfer.types.includes('Files')) {\n            // No need to query elementFromPoint again if already handled by dragenter correctly\n            // Just ensure dropEffect is continuously set based on currentHoveredDropzone\n            if (currentHoveredDropzone) {\n                 // Re-apply class just in case it was removed by some other JS\n                if(!currentHoveredDropzone.classList.contains(DROPZONE_HOVER_CLASS)) {\n                    currentHoveredDropzone.classList.add(DROPZONE_HOVER_CLASS);\n                }\n                event.dataTransfer.dropEffect = 'copy';\n            } else {\n                event.dataTransfer.dropEffect = 'none';\n            }\n        }\n    }, false);\n\n    docElement.addEventListener('dragleave', (event) => {\n        event.preventDefault();\n        if (event.dataTransfer && event.dataTransfer.types.includes('Files')) {\n            dragEnterCounter--;\n            // Only remove hover if drag truly left the window or the last dropzone\n            if (dragEnterCounter === 0 || event.relatedTarget === null || (currentHoveredDropzone && !currentHoveredDropzone.contains(event.relatedTarget as Node))) {\n                if (currentHoveredDropzone) {\n                    currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS);\n                    currentHoveredDropzone = null;\n                }\n                dragEnterCounter = 0; // Reset counter if it went negative or left window\n            }\n        }\n    }, false);\n\n    docElement.addEventListener('drop', (event) => {\n        event.preventDefault(); // Prevent default browser file handling\n        dragEnterCounter = 0; // Reset counter\n        if (currentHoveredDropzone) {\n            currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS);\n            currentHoveredDropzone = null;\n        }\n        // The actual drop processing is initiated by the native side calling HandlePlatformFileDrop\n        // HandlePlatformFileDrop will then check if the drop was on a valid zone.\n    }, false);\n}\n\n// Initialize listeners when the script loads\nif (typeof window !== \"undefined\" && typeof document !== \"undefined\") {\n    setupGlobalDropzoneListeners();\n}\n\nexport default thisWindow;\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport * as Runtime from \"../@wailsio/runtime/src\";\n\n// NOTE: the following methods MUST be imported explicitly because of how esbuild injection works\nimport { Enable as EnableWML } from \"../@wailsio/runtime/src/wml\";\nimport { debugLog } from \"../@wailsio/runtime/src/utils\";\n\nwindow.wails = Runtime;\nEnableWML();\n\nif (DEBUG) {\n    debugLog(\"Wails Runtime Loaded\")\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.System);\n\nconst SystemIsDarkMode = 0;\nconst SystemEnvironment = 1;\nconst ApplicationFilesDroppedWithContext = 100; // New method ID for enriched drop event\n\nconst _invoke = (function () {\n    try {\n        // Windows WebView2\n        if ((window as any).chrome?.webview?.postMessage) {\n            return (window as any).chrome.webview.postMessage.bind((window as any).chrome.webview);\n        }\n        // macOS/iOS WKWebView\n        else if ((window as any).webkit?.messageHandlers?.['external']?.postMessage) {\n            return (window as any).webkit.messageHandlers['external'].postMessage.bind((window as any).webkit.messageHandlers['external']);\n        }\n        // Android WebView - uses addJavascriptInterface which exposes window.wails.invoke\n        else if ((window as any).wails?.invoke) {\n            return (msg: any) => (window as any).wails.invoke(typeof msg === 'string' ? msg : JSON.stringify(msg));\n        }\n    } catch(e) {}\n\n    console.warn('\\n%c\u26A0\uFE0F Browser Environment Detected %c\\n\\n%cOnly UI previews are available in the browser. For full functionality, please run the application in desktop mode.\\nMore information at: https://v3.wails.io/learn/build/#using-a-browser-for-development\\n',\n        'background: #ffffff; color: #000000; font-weight: bold; padding: 4px 8px; border-radius: 4px; border: 2px solid #000000;',\n        'background: transparent;',\n        'color: #ffffff; font-style: italic; font-weight: bold;');\n    return null;\n})();\n\nexport function invoke(msg: any): void {\n    _invoke?.(msg);\n}\n\n/**\n * Retrieves the system dark mode status.\n *\n * @returns A promise that resolves to a boolean value indicating if the system is in dark mode.\n */\nexport function IsDarkMode(): Promise<boolean> {\n    return call(SystemIsDarkMode);\n}\n\n/**\n * Fetches the capabilities of the application from the server.\n *\n * @returns A promise that resolves to an object containing the capabilities.\n */\nexport async function Capabilities(): Promise<Record<string, any>> {\n    let response = await fetch(\"/wails/capabilities\");\n    if (response.ok) {\n        return response.json();\n    } else {\n        throw new Error(\"could not fetch capabilities: \" + response.statusText);\n    }\n}\n\nexport interface OSInfo {\n    /** The branding of the OS. */\n    Branding: string;\n    /** The ID of the OS. */\n    ID: string;\n    /** The name of the OS. */\n    Name: string;\n    /** The version of the OS. */\n    Version: string;\n}\n\nexport interface EnvironmentInfo {\n    /** The architecture of the system. */\n    Arch: string;\n    /** True if the application is running in debug mode, otherwise false. */\n    Debug: boolean;\n    /** The operating system in use. */\n    OS: string;\n    /** Details of the operating system. */\n    OSInfo: OSInfo;\n    /** Additional platform information. */\n    PlatformInfo: Record<string, any>;\n}\n\n/**\n * Retrieves environment details.\n *\n * @returns A promise that resolves to an object containing OS and system architecture.\n */\nexport function Environment(): Promise<EnvironmentInfo> {\n    return call(SystemEnvironment);\n}\n\n/**\n * Checks if the current operating system is Windows.\n *\n * @return True if the operating system is Windows, otherwise false.\n */\nexport function IsWindows(): boolean {\n    return (window as any)._wails?.environment?.OS === \"windows\";\n}\n\n/**\n * Checks if the current operating system is Linux.\n *\n * @returns Returns true if the current operating system is Linux, false otherwise.\n */\nexport function IsLinux(): boolean {\n    return (window as any)._wails?.environment?.OS === \"linux\";\n}\n\n/**\n * Checks if the current environment is a macOS operating system.\n *\n * @returns True if the environment is macOS, false otherwise.\n */\nexport function IsMac(): boolean {\n    return (window as any)._wails?.environment?.OS === \"darwin\";\n}\n\n/**\n * Checks if the current environment architecture is AMD64.\n *\n * @returns True if the current environment architecture is AMD64, false otherwise.\n */\nexport function IsAMD64(): boolean {\n    return (window as any)._wails?.environment?.Arch === \"amd64\";\n}\n\n/**\n * Checks if the current architecture is ARM.\n *\n * @returns True if the current architecture is ARM, false otherwise.\n */\nexport function IsARM(): boolean {\n    return (window as any)._wails?.environment?.Arch === \"arm\";\n}\n\n/**\n * Checks if the current environment is ARM64 architecture.\n *\n * @returns Returns true if the environment is ARM64 architecture, otherwise returns false.\n */\nexport function IsARM64(): boolean {\n    return (window as any)._wails?.environment?.Arch === \"arm64\";\n}\n\n/**\n * Reports whether the app is being run in debug mode.\n *\n * @returns True if the app is being run in debug mode.\n */\nexport function IsDebug(): boolean {\n    return Boolean((window as any)._wails?.environment?.Debug);\n}\n\n/**\n * Handles file drops originating from platform-specific code (e.g., macOS native drag-and-drop).\n * Gathers information about the drop target element and sends it back to the Go backend.\n *\n * @param filenames - An array of file paths (strings) that were dropped.\n * @param x - The x-coordinate of the drop event.\n * @param y - The y-coordinate of the drop event.\n */\nexport function HandlePlatformFileDrop(filenames: string[], x: number, y: number): void {\n    const element = document.elementFromPoint(x, y);\n    const elementId = element ? element.id : '';\n    const classList = element ? Array.from(element.classList) : [];\n\n    const payload = {\n        filenames,\n        x,\n        y,\n        elementId,\n        classList,\n    };\n\n    call(ApplicationFilesDroppedWithContext, payload)\n        .then(() => {\n            // Optional: Log success or handle if needed\n            console.log(\"Platform file drop processed and sent to Go.\");\n        })\n        .catch(err => {\n            // Optional: Log error\n            console.error(\"Error sending platform file drop to Go:\", err);\n        });\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nimport { IsDebug } from \"./system.js\";\nimport { eventTarget } from \"./utils\";\n\n// setup\nwindow.addEventListener('contextmenu', contextMenuHandler);\n\nconst call = newRuntimeCaller(objectNames.ContextMenu);\n\nconst ContextMenuOpen = 0;\n\nfunction openContextMenu(id: string, x: number, y: number, data: any): void {\n    void call(ContextMenuOpen, {id, x, y, data});\n}\n\nfunction contextMenuHandler(event: MouseEvent) {\n    const target = eventTarget(event);\n\n    // Check for custom context menu\n    const customContextMenu = window.getComputedStyle(target).getPropertyValue(\"--custom-contextmenu\").trim();\n\n    if (customContextMenu) {\n        event.preventDefault();\n        const data = window.getComputedStyle(target).getPropertyValue(\"--custom-contextmenu-data\");\n        openContextMenu(customContextMenu, event.clientX, event.clientY, data);\n    } else {\n        processDefaultContextMenu(event, target);\n    }\n}\n\n\n/*\n--default-contextmenu: auto; (default) will show the default context menu if contentEditable is true OR text has been selected OR element is input or textarea\n--default-contextmenu: show; will always show the default context menu\n--default-contextmenu: hide; will always hide the default context menu\n\nThis rule is inherited like normal CSS rules, so nesting works as expected\n*/\nfunction processDefaultContextMenu(event: MouseEvent, target: HTMLElement) {\n    // Debug builds always show the menu\n    if (IsDebug()) {\n        return;\n    }\n\n    // Process default context menu\n    switch (window.getComputedStyle(target).getPropertyValue(\"--default-contextmenu\").trim()) {\n        case 'show':\n            return;\n        case 'hide':\n            event.preventDefault();\n            return;\n    }\n\n    // Check if contentEditable is true\n    if (target.isContentEditable) {\n        return;\n    }\n\n    // Check if text has been selected\n    const selection = window.getSelection();\n    const hasSelection = selection && selection.toString().length > 0;\n    if (hasSelection) {\n        for (let i = 0; i < selection.rangeCount; i++) {\n            const range = selection.getRangeAt(i);\n            const rects = range.getClientRects();\n            for (let j = 0; j < rects.length; j++) {\n                const rect = rects[j];\n                if (document.elementFromPoint(rect.left, rect.top) === target) {\n                    return;\n                }\n            }\n        }\n    }\n\n    // Check if tag is input or textarea.\n    if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {\n        if (hasSelection || (!target.readOnly && !target.disabled)) {\n            return;\n        }\n    }\n\n    // hide default context menu\n    event.preventDefault();\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Retrieves the value associated with the specified key from the flag map.\n *\n * @param key - The key to retrieve the value for.\n * @return The value associated with the specified key.\n */\nexport function GetFlag(key: string): any {\n    try {\n        return window._wails.flags[key];\n    } catch (e) {\n        throw new Error(\"Unable to retrieve flag '\" + key + \"': \" + e, { cause: e });\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { invoke, IsWindows } from \"./system.js\";\nimport { GetFlag } from \"./flags.js\";\nimport { canTrackButtons, eventTarget } from \"./utils.js\";\n\n// Setup\nlet canDrag = false;\nlet dragging = false;\n\nlet resizable = false;\nlet canResize = false;\nlet resizing = false;\nlet resizeEdge: string = \"\";\nlet defaultCursor = \"auto\";\n\nlet buttons = 0;\nconst buttonsTracked = canTrackButtons();\n\nwindow._wails = window._wails || {};\nwindow._wails.setResizable = (value: boolean): void => {\n    resizable = value;\n    if (!resizable) {\n        // Stop resizing if in progress.\n        canResize = resizing = false;\n        setResize();\n    }\n};\n\n// Defer attaching mouse listeners until we know we're not on mobile.\nlet dragInitDone = false;\nfunction isMobile(): boolean {\n    const os = (window as any)._wails?.environment?.OS;\n    if (os === \"ios\" || os === \"android\") return true;\n    // Fallback heuristic if environment not yet set\n    const ua = navigator.userAgent || navigator.vendor || (window as any).opera || \"\";\n    return /android|iphone|ipad|ipod|iemobile|wpdesktop/i.test(ua);\n}\nfunction tryInitDragHandlers(): void {\n    if (dragInitDone) return;\n    if (isMobile()) return;\n    window.addEventListener('mousedown', update, { capture: true });\n    window.addEventListener('mousemove', update, { capture: true });\n    window.addEventListener('mouseup', update, { capture: true });\n    for (const ev of ['click', 'contextmenu', 'dblclick']) {\n        window.addEventListener(ev, suppressEvent, { capture: true });\n    }\n    dragInitDone = true;\n}\n// Attempt immediate init (in case environment already present)\ntryInitDragHandlers();\n// Also attempt on DOM ready\ndocument.addEventListener('DOMContentLoaded', tryInitDragHandlers, { once: true });\n// As a last resort, poll for environment for a short period\nlet dragEnvPolls = 0;\nconst dragEnvPoll = window.setInterval(() => {\n    if (dragInitDone) { window.clearInterval(dragEnvPoll); return; }\n    tryInitDragHandlers();\n    if (++dragEnvPolls > 100) { window.clearInterval(dragEnvPoll); }\n}, 50);\n\nfunction suppressEvent(event: Event) {\n    // Suppress click events while resizing or dragging.\n    if (dragging || resizing) {\n        event.stopImmediatePropagation();\n        event.stopPropagation();\n        event.preventDefault();\n    }\n}\n\n// Use constants to avoid comparing strings multiple times.\nconst MouseDown = 0;\nconst MouseUp   = 1;\nconst MouseMove = 2;\n\nfunction update(event: MouseEvent) {\n    // Windows suppresses mouse events at the end of dragging or resizing,\n    // so we need to be smart and synthesize button events.\n\n    let eventType: number, eventButtons = event.buttons;\n    switch (event.type) {\n        case 'mousedown':\n            eventType = MouseDown;\n            if (!buttonsTracked) { eventButtons = buttons | (1 << event.button); }\n            break;\n        case 'mouseup':\n            eventType = MouseUp;\n            if (!buttonsTracked) { eventButtons = buttons & ~(1 << event.button); }\n            break;\n        default:\n            eventType = MouseMove;\n            if (!buttonsTracked) { eventButtons = buttons; }\n            break;\n    }\n\n    let released = buttons & ~eventButtons;\n    let pressed = eventButtons & ~buttons;\n\n    buttons = eventButtons;\n\n    // Synthesize a release-press sequence if we detect a press of an already pressed button.\n    if (eventType === MouseDown && !(pressed & event.button)) {\n        released |= (1 << event.button);\n        pressed |= (1 << event.button);\n    }\n\n    // Suppress all button events during dragging and resizing,\n    // unless this is a mouseup event that is ending a drag action.\n    if (\n        eventType !== MouseMove // Fast path for mousemove\n        && resizing\n        || (\n            dragging\n            && (\n                eventType === MouseDown\n                || event.button !== 0\n            )\n        )\n    ) {\n        event.stopImmediatePropagation();\n        event.stopPropagation();\n        event.preventDefault();\n    }\n\n    // Handle releases\n    if (released & 1) { primaryUp(event); }\n    // Handle presses\n    if (pressed & 1) { primaryDown(event); }\n\n    // Handle mousemove\n    if (eventType === MouseMove) { onMouseMove(event); };\n}\n\nfunction primaryDown(event: MouseEvent): void {\n    // Reset readiness state.\n    canDrag = false;\n    canResize = false;\n\n    // Ignore repeated clicks on macOS and Linux.\n    if (!IsWindows()) {\n        if (event.type === 'mousedown' && event.button === 0 && event.detail !== 1) {\n            return;\n        }\n    }\n\n    if (resizeEdge) {\n        // Ready to resize if the primary button was pressed for the first time.\n        canResize = true;\n        // Do not start drag operations when on resize edges.\n        return;\n    }\n\n    // Retrieve target element\n    const target = eventTarget(event);\n\n    // Ready to drag if the primary button was pressed for the first time on a draggable element.\n    // Ignore clicks on the scrollbar.\n    const style = window.getComputedStyle(target);\n    canDrag = (\n        style.getPropertyValue(\"--wails-draggable\").trim() === \"drag\"\n        && (\n            event.offsetX - parseFloat(style.paddingLeft) < target.clientWidth\n            && event.offsetY - parseFloat(style.paddingTop) < target.clientHeight\n        )\n    );\n}\n\nfunction primaryUp(event: MouseEvent) {\n    // Stop dragging and resizing.\n    canDrag = false;\n    dragging = false;\n    canResize = false;\n    resizing = false;\n}\n\nconst cursorForEdge = Object.freeze({\n    \"se-resize\": \"nwse-resize\",\n    \"sw-resize\": \"nesw-resize\",\n    \"nw-resize\": \"nwse-resize\",\n    \"ne-resize\": \"nesw-resize\",\n    \"w-resize\": \"ew-resize\",\n    \"n-resize\": \"ns-resize\",\n    \"s-resize\": \"ns-resize\",\n    \"e-resize\": \"ew-resize\",\n})\n\nfunction setResize(edge?: keyof typeof cursorForEdge): void {\n    if (edge) {\n        if (!resizeEdge) { defaultCursor = document.body.style.cursor; }\n        document.body.style.cursor = cursorForEdge[edge];\n    } else if (!edge && resizeEdge) {\n        document.body.style.cursor = defaultCursor;\n    }\n\n    resizeEdge = edge || \"\";\n}\n\nfunction onMouseMove(event: MouseEvent): void {\n    if (canResize && resizeEdge) {\n        // Start resizing.\n        resizing = true;\n        invoke(\"wails:resize:\" + resizeEdge);\n    } else if (canDrag) {\n        // Start dragging.\n        dragging = true;\n        invoke(\"wails:drag\");\n    }\n\n    if (dragging || resizing) {\n        // Either drag or resize is ongoing,\n        // reset readiness and stop processing.\n        canDrag = canResize = false;\n        return;\n    }\n\n    if (!resizable || !IsWindows()) {\n        if (resizeEdge) { setResize(); }\n        return;\n    }\n\n    const resizeHandleHeight = GetFlag(\"system.resizeHandleHeight\") || 5;\n    const resizeHandleWidth = GetFlag(\"system.resizeHandleWidth\") || 5;\n\n    // Extra pixels for the corner areas.\n    const cornerExtra = GetFlag(\"resizeCornerExtra\") || 10;\n\n    const rightBorder = (window.outerWidth - event.clientX) < resizeHandleWidth;\n    const leftBorder = event.clientX < resizeHandleWidth;\n    const topBorder = event.clientY < resizeHandleHeight;\n    const bottomBorder = (window.outerHeight - event.clientY) < resizeHandleHeight;\n\n    // Adjust for corner areas.\n    const rightCorner = (window.outerWidth - event.clientX) < (resizeHandleWidth + cornerExtra);\n    const leftCorner = event.clientX < (resizeHandleWidth + cornerExtra);\n    const topCorner = event.clientY < (resizeHandleHeight + cornerExtra);\n    const bottomCorner = (window.outerHeight - event.clientY) < (resizeHandleHeight + cornerExtra);\n\n    if (!leftCorner && !topCorner && !bottomCorner && !rightCorner) {\n        // Optimisation: out of all corner areas implies out of borders.\n        setResize();\n    }\n    // Detect corners.\n    else if (rightCorner && bottomCorner) setResize(\"se-resize\");\n    else if (leftCorner && bottomCorner) setResize(\"sw-resize\");\n    else if (leftCorner && topCorner) setResize(\"nw-resize\");\n    else if (topCorner && rightCorner) setResize(\"ne-resize\");\n    // Detect borders.\n    else if (leftBorder) setResize(\"w-resize\");\n    else if (topBorder) setResize(\"n-resize\");\n    else if (bottomBorder) setResize(\"s-resize\");\n    else if (rightBorder) setResize(\"e-resize\");\n    // Out of border area.\n    else setResize();\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nconst call = newRuntimeCaller(objectNames.Application);\n\nconst HideMethod = 0;\nconst ShowMethod = 1;\nconst QuitMethod = 2;\n\n/**\n * Hides a certain method by calling the HideMethod function.\n */\nexport function Hide(): Promise<void> {\n    return call(HideMethod);\n}\n\n/**\n * Calls the ShowMethod and returns the result.\n */\nexport function Show(): Promise<void> {\n    return call(ShowMethod);\n}\n\n/**\n * Calls the QuitMethod to terminate the program.\n */\nexport function Quit(): Promise<void> {\n    return call(QuitMethod);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { CancellablePromise, type CancellablePromiseWithResolvers } from \"./cancellable.js\";\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nimport { nanoid } from \"./nanoid.js\";\n\n// Setup\nwindow._wails = window._wails || {};\nwindow._wails.callResultHandler = resultHandler;\nwindow._wails.callErrorHandler = errorHandler;\n\ntype PromiseResolvers = Omit<CancellablePromiseWithResolvers<any>, \"promise\" | \"oncancelled\">\n\nconst call = newRuntimeCaller(objectNames.Call);\nconst cancelCall = newRuntimeCaller(objectNames.CancelCall);\nconst callResponses = new Map<string, PromiseResolvers>();\n\nconst CallBinding = 0;\nconst CancelMethod = 0\n\n/**\n * Holds all required information for a binding call.\n * May provide either a method ID or a method name, but not both.\n */\nexport type CallOptions = {\n    /** The numeric ID of the bound method to call. */\n    methodID: number;\n    /** The fully qualified name of the bound method to call. */\n    methodName?: never;\n    /** Arguments to be passed into the bound method. */\n    args: any[];\n} | {\n    /** The numeric ID of the bound method to call. */\n    methodID?: never;\n    /** The fully qualified name of the bound method to call. */\n    methodName: string;\n    /** Arguments to be passed into the bound method. */\n    args: any[];\n};\n\n/**\n * Exception class that will be thrown in case the bound method returns an error.\n * The value of the {@link RuntimeError#name} property is \"RuntimeError\".\n */\nexport class RuntimeError extends Error {\n    /**\n     * Constructs a new RuntimeError instance.\n     * @param message - The error message.\n     * @param options - Options to be forwarded to the Error constructor.\n     */\n    constructor(message?: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"RuntimeError\";\n    }\n}\n\n/**\n * Handles the result of a call request.\n *\n * @param id - The id of the request to handle the result for.\n * @param data - The result data of the request.\n * @param isJSON - Indicates whether the data is JSON or not.\n */\nfunction resultHandler(id: string, data: string, isJSON: boolean): void {\n    const resolvers = getAndDeleteResponse(id);\n    if (!resolvers) {\n        return;\n    }\n\n    if (!data) {\n        resolvers.resolve(undefined);\n    } else if (!isJSON) {\n        resolvers.resolve(data);\n    } else {\n        try {\n            resolvers.resolve(JSON.parse(data));\n        } catch (err: any) {\n            resolvers.reject(new TypeError(\"could not parse result: \" + err.message, { cause: err }));\n        }\n    }\n}\n\n/**\n * Handles the error from a call request.\n *\n * @param id - The id of the promise handler.\n * @param data - The error data to reject the promise handler with.\n * @param isJSON - Indicates whether the data is JSON or not.\n */\nfunction errorHandler(id: string, data: string, isJSON: boolean): void {\n    const resolvers = getAndDeleteResponse(id);\n    if (!resolvers) {\n        return;\n    }\n\n    if (!isJSON) {\n        resolvers.reject(new Error(data));\n    } else {\n        let error: any;\n        try {\n            error = JSON.parse(data);\n        } catch (err: any) {\n            resolvers.reject(new TypeError(\"could not parse error: \" + err.message, { cause: err }));\n            return;\n        }\n\n        let options: ErrorOptions = {};\n        if (error.cause) {\n            options.cause = error.cause;\n        }\n\n        let exception;\n        switch (error.kind) {\n            case \"ReferenceError\":\n                exception = new ReferenceError(error.message, options);\n                break;\n            case \"TypeError\":\n                exception = new TypeError(error.message, options);\n                break;\n            case \"RuntimeError\":\n                exception = new RuntimeError(error.message, options);\n                break;\n            default:\n                exception = new Error(error.message, options);\n                break;\n        }\n\n        resolvers.reject(exception);\n    }\n}\n\n/**\n * Retrieves and removes the response associated with the given ID from the callResponses map.\n *\n * @param id - The ID of the response to be retrieved and removed.\n * @returns The response object associated with the given ID, if any.\n */\nfunction getAndDeleteResponse(id: string): PromiseResolvers | undefined {\n    const response = callResponses.get(id);\n    callResponses.delete(id);\n    return response;\n}\n\n/**\n * Generates a unique ID using the nanoid library.\n *\n * @returns A unique ID that does not exist in the callResponses set.\n */\nfunction generateID(): string {\n    let result;\n    do {\n        result = nanoid();\n    } while (callResponses.has(result));\n    return result;\n}\n\n/**\n * Call a bound method according to the given call options.\n *\n * In case of failure, the returned promise will reject with an exception\n * among ReferenceError (unknown method), TypeError (wrong argument count or type),\n * {@link RuntimeError} (method returned an error), or other (network or internal errors).\n * The exception might have a \"cause\" field with the value returned\n * by the application- or service-level error marshaling functions.\n *\n * @param options - A method call descriptor.\n * @returns The result of the call.\n */\nexport function Call(options: CallOptions): CancellablePromise<any> {\n    const id = generateID();\n\n    const result = CancellablePromise.withResolvers<any>();\n    callResponses.set(id, { resolve: result.resolve, reject: result.reject });\n\n    const request = call(CallBinding, Object.assign({ \"call-id\": id }, options));\n    let running = false;\n\n    request.then(() => {\n        running = true;\n    }, (err) => {\n        callResponses.delete(id);\n        result.reject(err);\n    });\n\n    const cancel = () => {\n        callResponses.delete(id);\n        return cancelCall(CancelMethod, {\"call-id\": id}).catch((err) => {\n            console.error(\"Error while requesting binding call cancellation:\", err);\n        });\n    };\n\n    result.oncancelled = () => {\n        if (running) {\n            return cancel();\n        } else {\n            return request.then(cancel);\n        }\n    };\n\n    return result.promise;\n}\n\n/**\n * Calls a bound method by name with the specified arguments.\n * See {@link Call} for details.\n *\n * @param methodName - The name of the method in the format 'package.struct.method'.\n * @param args - The arguments to pass to the method.\n * @returns The result of the method call.\n */\nexport function ByName(methodName: string, ...args: any[]): CancellablePromise<any> {\n    return Call({ methodName, args });\n}\n\n/**\n * Calls a method by its numeric ID with the specified arguments.\n * See {@link Call} for details.\n *\n * @param methodID - The ID of the method to call.\n * @param args - The arguments to pass to the method.\n * @return The result of the method call.\n */\nexport function ByID(methodID: number, ...args: any[]): CancellablePromise<any> {\n    return Call({ methodID, args });\n}\n", "// Source: https://github.com/inspect-js/is-callable\n\n// The MIT License (MIT)\n//\n// Copyright (c) 2015 Jordan Harband\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\nvar fnToStr = Function.prototype.toString;\nvar reflectApply: typeof Reflect.apply | false | null = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;\nvar badArrayLike: any;\nvar isCallableMarker: any;\nif (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {\n    try {\n        badArrayLike = Object.defineProperty({}, 'length', {\n            get: function () {\n                throw isCallableMarker;\n            }\n        });\n        isCallableMarker = {};\n        // eslint-disable-next-line no-throw-literal\n        reflectApply(function () { throw 42; }, null, badArrayLike);\n    } catch (_) {\n        if (_ !== isCallableMarker) {\n            reflectApply = null;\n        }\n    }\n} else {\n    reflectApply = null;\n}\n\nvar constructorRegex = /^\\s*class\\b/;\nvar isES6ClassFn = function isES6ClassFunction(value: any): boolean {\n    try {\n        var fnStr = fnToStr.call(value);\n        return constructorRegex.test(fnStr);\n    } catch (e) {\n        return false; // not a function\n    }\n};\n\nvar tryFunctionObject = function tryFunctionToStr(value: any): boolean {\n    try {\n        if (isES6ClassFn(value)) { return false; }\n        fnToStr.call(value);\n        return true;\n    } catch (e) {\n        return false;\n    }\n};\nvar toStr = Object.prototype.toString;\nvar objectClass = '[object Object]';\nvar fnClass = '[object Function]';\nvar genClass = '[object GeneratorFunction]';\nvar ddaClass = '[object HTMLAllCollection]'; // IE 11\nvar ddaClass2 = '[object HTML document.all class]';\nvar ddaClass3 = '[object HTMLCollection]'; // IE 9-10\nvar hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`\n\nvar isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing\n\nvar isDDA: (value: any) => boolean = function isDocumentDotAll() { return false; };\nif (typeof document === 'object') {\n    // Firefox 3 canonicalizes DDA to undefined when it's not accessed directly\n    var all = document.all;\n    if (toStr.call(all) === toStr.call(document.all)) {\n        isDDA = function isDocumentDotAll(value) {\n            /* globals document: false */\n            // in IE 6-8, typeof document.all is \"object\" and it's truthy\n            if ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {\n                try {\n                    var str = toStr.call(value);\n                    return (\n                        str === ddaClass\n                        || str === ddaClass2\n                        || str === ddaClass3 // opera 12.16\n                        || str === objectClass // IE 6-8\n                    ) && value('') == null; // eslint-disable-line eqeqeq\n                } catch (e) { /**/ }\n            }\n            return false;\n        };\n    }\n}\n\nfunction isCallableRefApply<T>(value: T | unknown): value is (...args: any[]) => any  {\n    if (isDDA(value)) { return true; }\n    if (!value) { return false; }\n    if (typeof value !== 'function' && typeof value !== 'object') { return false; }\n    try {\n        (reflectApply as any)(value, null, badArrayLike);\n    } catch (e) {\n        if (e !== isCallableMarker) { return false; }\n    }\n    return !isES6ClassFn(value) && tryFunctionObject(value);\n}\n\nfunction isCallableNoRefApply<T>(value: T | unknown): value is (...args: any[]) => any {\n    if (isDDA(value)) { return true; }\n    if (!value) { return false; }\n    if (typeof value !== 'function' && typeof value !== 'object') { return false; }\n    if (hasToStringTag) { return tryFunctionObject(value); }\n    if (isES6ClassFn(value)) { return false; }\n    var strClass = toStr.call(value);\n    if (strClass !== fnClass && strClass !== genClass && !(/^\\[object HTML/).test(strClass)) { return false; }\n    return tryFunctionObject(value);\n};\n\nexport default reflectApply ? isCallableRefApply : isCallableNoRefApply;\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport isCallable from \"./callable.js\";\n\n/**\n * Exception class that will be used as rejection reason\n * in case a {@link CancellablePromise} is cancelled successfully.\n *\n * The value of the {@link name} property is the string `\"CancelError\"`.\n * The value of the {@link cause} property is the cause passed to the cancel method, if any.\n */\nexport class CancelError extends Error {\n    /**\n     * Constructs a new `CancelError` instance.\n     * @param message - The error message.\n     * @param options - Options to be forwarded to the Error constructor.\n     */\n    constructor(message?: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"CancelError\";\n    }\n}\n\n/**\n * Exception class that will be reported as an unhandled rejection\n * in case a {@link CancellablePromise} rejects after being cancelled,\n * or when the `oncancelled` callback throws or rejects.\n *\n * The value of the {@link name} property is the string `\"CancelledRejectionError\"`.\n * The value of the {@link cause} property is the reason the promise rejected with.\n *\n * Because the original promise was cancelled,\n * a wrapper promise will be passed to the unhandled rejection listener instead.\n * The {@link promise} property holds a reference to the original promise.\n */\nexport class CancelledRejectionError extends Error {\n    /**\n     * Holds a reference to the promise that was cancelled and then rejected.\n     */\n    promise: CancellablePromise<unknown>;\n\n    /**\n     * Constructs a new `CancelledRejectionError` instance.\n     * @param promise - The promise that caused the error originally.\n     * @param reason - The rejection reason.\n     * @param info - An optional informative message specifying the circumstances in which the error was thrown.\n     *               Defaults to the string `\"Unhandled rejection in cancelled promise.\"`.\n     */\n    constructor(promise: CancellablePromise<unknown>, reason?: any, info?: string) {\n        super((info ?? \"Unhandled rejection in cancelled promise.\") + \" Reason: \" + errorMessage(reason), { cause: reason });\n        this.promise = promise;\n        this.name = \"CancelledRejectionError\";\n    }\n}\n\ntype CancellablePromiseResolver<T> = (value: T | PromiseLike<T> | CancellablePromiseLike<T>) => void;\ntype CancellablePromiseRejector = (reason?: any) => void;\ntype CancellablePromiseCanceller = (cause?: any) => void | PromiseLike<void>;\ntype CancellablePromiseExecutor<T> = (resolve: CancellablePromiseResolver<T>, reject: CancellablePromiseRejector) => void;\n\nexport interface CancellablePromiseLike<T> {\n    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1> | CancellablePromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2> | CancellablePromiseLike<TResult2>) | undefined | null): CancellablePromiseLike<TResult1 | TResult2>;\n    cancel(cause?: any): void | PromiseLike<void>;\n}\n\n/**\n * Wraps a cancellable promise along with its resolution methods.\n * The `oncancelled` field will be null initially but may be set to provide a custom cancellation function.\n */\nexport interface CancellablePromiseWithResolvers<T> {\n    promise: CancellablePromise<T>;\n    resolve: CancellablePromiseResolver<T>;\n    reject: CancellablePromiseRejector;\n    oncancelled: CancellablePromiseCanceller | null;\n}\n\ninterface CancellablePromiseState {\n    readonly root: CancellablePromiseState;\n    resolving: boolean;\n    settled: boolean;\n    reason?: CancelError;\n}\n\n// Private field names.\nconst barrierSym = Symbol(\"barrier\");\nconst cancelImplSym = Symbol(\"cancelImpl\");\nconst species = Symbol.species ?? Symbol(\"speciesPolyfill\");\n\n/**\n * A promise with an attached method for cancelling long-running operations (see {@link CancellablePromise#cancel}).\n * Cancellation can optionally be bound to an {@link AbortSignal}\n * for better composability (see {@link CancellablePromise#cancelOn}).\n *\n * Cancelling a pending promise will result in an immediate rejection\n * with an instance of {@link CancelError} as reason,\n * but whoever started the promise will be responsible\n * for actually aborting the underlying operation.\n * To this purpose, the constructor and all chaining methods\n * accept optional cancellation callbacks.\n *\n * If a `CancellablePromise` still resolves after having been cancelled,\n * the result will be discarded. If it rejects, the reason\n * will be reported as an unhandled rejection,\n * wrapped in a {@link CancelledRejectionError} instance.\n * To facilitate the handling of cancellation requests,\n * cancelled `CancellablePromise`s will _not_ report unhandled `CancelError`s\n * whose `cause` field is the same as the one with which the current promise was cancelled.\n *\n * All usual promise methods are defined and return a `CancellablePromise`\n * whose cancel method will cancel the parent operation as well, propagating the cancellation reason\n * upwards through promise chains.\n * Conversely, cancelling a promise will not automatically cancel dependent promises downstream:\n * ```ts\n * let root = new CancellablePromise((resolve, reject) => { ... });\n * let child1 = root.then(() => { ... });\n * let child2 = child1.then(() => { ... });\n * let child3 = root.catch(() => { ... });\n * child1.cancel(); // Cancels child1 and root, but not child2 or child3\n * ```\n * Cancelling a promise that has already settled is safe and has no consequence.\n *\n * The `cancel` method returns a promise that _always fulfills_\n * after the whole chain has processed the cancel request\n * and all attached callbacks up to that moment have run.\n *\n * All ES2024 promise methods (static and instance) are defined on CancellablePromise,\n * but actual availability may vary with OS/webview version.\n *\n * In line with the proposal at https://github.com/tc39/proposal-rm-builtin-subclassing,\n * `CancellablePromise` does not support transparent subclassing.\n * Extenders should take care to provide their own method implementations.\n * This might be reconsidered in case the proposal is retired.\n *\n * CancellablePromise is a wrapper around the DOM Promise object\n * and is compliant with the [Promises/A+ specification](https://promisesaplus.com/)\n * (it passes the [compliance suite](https://github.com/promises-aplus/promises-tests))\n * if so is the underlying implementation.\n */\nexport class CancellablePromise<T> extends Promise<T> implements PromiseLike<T>, CancellablePromiseLike<T> {\n    // Private fields.\n    /** @internal */\n    private [barrierSym]!: Partial<PromiseWithResolvers<void>> | null;\n    /** @internal */\n    private readonly [cancelImplSym]!: (reason: CancelError) => void | PromiseLike<void>;\n\n    /**\n     * Creates a new `CancellablePromise`.\n     *\n     * @param executor - A callback used to initialize the promise. This callback is passed two arguments:\n     *                   a `resolve` callback used to resolve the promise with a value\n     *                   or the result of another promise (possibly cancellable),\n     *                   and a `reject` callback used to reject the promise with a provided reason or error.\n     *                   If the value provided to the `resolve` callback is a thenable _and_ cancellable object\n     *                   (it has a `then` _and_ a `cancel` method),\n     *                   cancellation requests will be forwarded to that object and the oncancelled will not be invoked anymore.\n     *                   If any one of the two callbacks is called _after_ the promise has been cancelled,\n     *                   the provided values will be cancelled and resolved as usual,\n     *                   but their results will be discarded.\n     *                   However, if the resolution process ultimately ends up in a rejection\n     *                   that is not due to cancellation, the rejection reason\n     *                   will be wrapped in a {@link CancelledRejectionError}\n     *                   and bubbled up as an unhandled rejection.\n     * @param oncancelled - It is the caller's responsibility to ensure that any operation\n     *                      started by the executor is properly halted upon cancellation.\n     *                      This optional callback can be used to that purpose.\n     *                      It will be called _synchronously_ with a cancellation cause\n     *                      when cancellation is requested, _after_ the promise has already rejected\n     *                      with a {@link CancelError}, but _before_\n     *                      any {@link then}/{@link catch}/{@link finally} callback runs.\n     *                      If the callback returns a thenable, the promise returned from {@link cancel}\n     *                      will only fulfill after the former has settled.\n     *                      Unhandled exceptions or rejections from the callback will be wrapped\n     *                      in a {@link CancelledRejectionError} and bubbled up as unhandled rejections.\n     *                      If the `resolve` callback is called before cancellation with a cancellable promise,\n     *                      cancellation requests on this promise will be diverted to that promise,\n     *                      and the original `oncancelled` callback will be discarded.\n     */\n    constructor(executor: CancellablePromiseExecutor<T>, oncancelled?: CancellablePromiseCanceller) {\n        let resolve!: (value: T | PromiseLike<T>) => void;\n        let reject!: (reason?: any) => void;\n        super((res, rej) => { resolve = res; reject = rej; });\n\n        if ((this.constructor as any)[species] !== Promise) {\n            throw new TypeError(\"CancellablePromise does not support transparent subclassing. Please refrain from overriding the [Symbol.species] static property.\");\n        }\n\n        let promise: CancellablePromiseWithResolvers<T> = {\n            promise: this,\n            resolve,\n            reject,\n            get oncancelled() { return oncancelled ?? null; },\n            set oncancelled(cb) { oncancelled = cb ?? undefined; }\n        };\n\n        const state: CancellablePromiseState = {\n            get root() { return state; },\n            resolving: false,\n            settled: false\n        };\n\n        // Setup cancellation system.\n        void Object.defineProperties(this, {\n            [barrierSym]: {\n                configurable: false,\n                enumerable: false,\n                writable: true,\n                value: null\n            },\n            [cancelImplSym]: {\n                configurable: false,\n                enumerable: false,\n                writable: false,\n                value: cancellerFor(promise, state)\n            }\n        });\n\n        // Run the actual executor.\n        const rejector = rejectorFor(promise, state);\n        try {\n            executor(resolverFor(promise, state), rejector);\n        } catch (err) {\n            if (state.resolving) {\n                console.log(\"Unhandled exception in CancellablePromise executor.\", err);\n            } else {\n                rejector(err);\n            }\n        }\n    }\n\n    /**\n     * Cancels immediately the execution of the operation associated with this promise.\n     * The promise rejects with a {@link CancelError} instance as reason,\n     * with the {@link CancelError#cause} property set to the given argument, if any.\n     *\n     * Has no effect if called after the promise has already settled;\n     * repeated calls in particular are safe, but only the first one\n     * will set the cancellation cause.\n     *\n     * The `CancelError` exception _need not_ be handled explicitly _on the promises that are being cancelled:_\n     * cancelling a promise with no attached rejection handler does not trigger an unhandled rejection event.\n     * Therefore, the following idioms are all equally correct:\n     * ```ts\n     * new CancellablePromise((resolve, reject) => { ... }).cancel();\n     * new CancellablePromise((resolve, reject) => { ... }).then(...).cancel();\n     * new CancellablePromise((resolve, reject) => { ... }).then(...).catch(...).cancel();\n     * ```\n     * Whenever some cancelled promise in a chain rejects with a `CancelError`\n     * with the same cancellation cause as itself, the error will be discarded silently.\n     * However, the `CancelError` _will still be delivered_ to all attached rejection handlers\n     * added by {@link then} and related methods:\n     * ```ts\n     * let cancellable = new CancellablePromise((resolve, reject) => { ... });\n     * cancellable.then(() => { ... }).catch(console.log);\n     * cancellable.cancel(); // A CancelError is printed to the console.\n     * ```\n     * If the `CancelError` is not handled downstream by the time it reaches\n     * a _non-cancelled_ promise, it _will_ trigger an unhandled rejection event,\n     * just like normal rejections would:\n     * ```ts\n     * let cancellable = new CancellablePromise((resolve, reject) => { ... });\n     * let chained = cancellable.then(() => { ... }).then(() => { ... }); // No catch...\n     * cancellable.cancel(); // Unhandled rejection event on chained!\n     * ```\n     * Therefore, it is important to either cancel whole promise chains from their tail,\n     * as shown in the correct idioms above, or take care of handling errors everywhere.\n     *\n     * @returns A cancellable promise that _fulfills_ after the cancel callback (if any)\n     * and all handlers attached up to the call to cancel have run.\n     * If the cancel callback returns a thenable, the promise returned by `cancel`\n     * will also wait for that thenable to settle.\n     * This enables callers to wait for the cancelled operation to terminate\n     * without being forced to handle potential errors at the call site.\n     * ```ts\n     * cancellable.cancel().then(() => {\n     *     // Cleanup finished, it's safe to do something else.\n     * }, (err) => {\n     *     // Unreachable: the promise returned from cancel will never reject.\n     * });\n     * ```\n     * Note that the returned promise will _not_ handle implicitly any rejection\n     * that might have occurred already in the cancelled chain.\n     * It will just track whether registered handlers have been executed or not.\n     * Therefore, unhandled rejections will never be silently handled by calling cancel.\n     */\n    cancel(cause?: any): CancellablePromise<void> {\n        return new CancellablePromise<void>((resolve) => {\n            // INVARIANT: the result of this[cancelImplSym] and the barrier do not ever reject.\n            // Unfortunately macOS High Sierra does not support Promise.allSettled.\n            Promise.all([\n                this[cancelImplSym](new CancelError(\"Promise cancelled.\", { cause })),\n                currentBarrier(this)\n            ]).then(() => resolve(), () => resolve());\n        });\n    }\n\n    /**\n     * Binds promise cancellation to the abort event of the given {@link AbortSignal}.\n     * If the signal has already aborted, the promise will be cancelled immediately.\n     * When either condition is verified, the cancellation cause will be set\n     * to the signal's abort reason (see {@link AbortSignal#reason}).\n     *\n     * Has no effect if called (or if the signal aborts) _after_ the promise has already settled.\n     * Only the first signal to abort will set the cancellation cause.\n     *\n     * For more details about the cancellation process,\n     * see {@link cancel} and the `CancellablePromise` constructor.\n     *\n     * This method enables `await`ing cancellable promises without having\n     * to store them for future cancellation, e.g.:\n     * ```ts\n     * await longRunningOperation().cancelOn(signal);\n     * ```\n     * instead of:\n     * ```ts\n     * let promiseToBeCancelled = longRunningOperation();\n     * await promiseToBeCancelled;\n     * ```\n     *\n     * @returns This promise, for method chaining.\n     */\n    cancelOn(signal: AbortSignal): CancellablePromise<T> {\n        if (signal.aborted) {\n            void this.cancel(signal.reason)\n        } else {\n            signal.addEventListener('abort', () => void this.cancel(signal.reason), {capture: true});\n        }\n\n        return this;\n    }\n\n    /**\n     * Attaches callbacks for the resolution and/or rejection of the `CancellablePromise`.\n     *\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\n     * with the same semantics as the `oncancelled` argument of the constructor.\n     * When the parent promise rejects or is cancelled, the `onrejected` callback will run,\n     * _even after the returned promise has been cancelled:_\n     * in that case, should it reject or throw, the reason will be wrapped\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\n     *\n     * @param onfulfilled The callback to execute when the Promise is resolved.\n     * @param onrejected The callback to execute when the Promise is rejected.\n     * @returns A `CancellablePromise` for the completion of whichever callback is executed.\n     * The returned promise is hooked up to propagate cancellation requests up the chain, but not down:\n     *\n     *   - if the parent promise is cancelled, the `onrejected` handler will be invoked with a `CancelError`\n     *     and the returned promise _will resolve regularly_ with its result;\n     *   - conversely, if the returned promise is cancelled, _the parent promise is cancelled too;_\n     *     the `onrejected` handler will still be invoked with the parent's `CancelError`,\n     *     but its result will be discarded\n     *     and the returned promise will reject with a `CancelError` as well.\n     *\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\n     * up the entire promise chain have been run.\n     *\n     * If either callback returns a cancellable promise,\n     * cancellation requests will be diverted to it,\n     * and the specified `oncancelled` callback will be discarded.\n     */\n    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1> | CancellablePromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2> | CancellablePromiseLike<TResult2>) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<TResult1 | TResult2> {\n        if (!(this instanceof CancellablePromise)) {\n            throw new TypeError(\"CancellablePromise.prototype.then called on an invalid object.\");\n        }\n\n        // NOTE: TypeScript's built-in type for then is broken,\n        // as it allows specifying an arbitrary TResult1 != T even when onfulfilled is not a function.\n        // We cannot fix it if we want to CancellablePromise to implement PromiseLike<T>.\n\n        if (!isCallable(onfulfilled)) { onfulfilled = identity as any; }\n        if (!isCallable(onrejected)) { onrejected = thrower; }\n\n        if (onfulfilled === identity && onrejected == thrower) {\n            // Shortcut for trivial arguments.\n            return new CancellablePromise((resolve) => resolve(this as any));\n        }\n\n        const barrier: Partial<PromiseWithResolvers<void>> = {};\n        this[barrierSym] = barrier;\n\n        return new CancellablePromise<TResult1 | TResult2>((resolve, reject) => {\n            void super.then(\n                (value) => {\n                    if (this[barrierSym] === barrier) { this[barrierSym] = null; }\n                    barrier.resolve?.();\n\n                    try {\n                        resolve(onfulfilled!(value));\n                    } catch (err) {\n                        reject(err);\n                    }\n                },\n                (reason?) => {\n                    if (this[barrierSym] === barrier) { this[barrierSym] = null; }\n                    barrier.resolve?.();\n\n                    try {\n                        resolve(onrejected!(reason));\n                    } catch (err) {\n                        reject(err);\n                    }\n                }\n            );\n        }, async (cause?) => {\n            //cancelled = true;\n            try {\n                return oncancelled?.(cause);\n            } finally {\n                await this.cancel(cause);\n            }\n        });\n    }\n\n    /**\n     * Attaches a callback for only the rejection of the Promise.\n     *\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\n     * with the same semantics as the `oncancelled` argument of the constructor.\n     * When the parent promise rejects or is cancelled, the `onrejected` callback will run,\n     * _even after the returned promise has been cancelled:_\n     * in that case, should it reject or throw, the reason will be wrapped\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\n     *\n     * It is equivalent to\n     * ```ts\n     * cancellablePromise.then(undefined, onrejected, oncancelled);\n     * ```\n     * and the same caveats apply.\n     *\n     * @returns A Promise for the completion of the callback.\n     * Cancellation requests on the returned promise\n     * will propagate up the chain to the parent promise,\n     * but not in the other direction.\n     *\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\n     * up the entire promise chain have been run.\n     *\n     * If `onrejected` returns a cancellable promise,\n     * cancellation requests will be diverted to it,\n     * and the specified `oncancelled` callback will be discarded.\n     * See {@link then} for more details.\n     */\n    catch<TResult = never>(onrejected?: ((reason: any) => (PromiseLike<TResult> | TResult)) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<T | TResult> {\n        return this.then(undefined, onrejected, oncancelled);\n    }\n\n    /**\n     * Attaches a callback that is invoked when the CancellablePromise is settled (fulfilled or rejected). The\n     * resolved value cannot be accessed or modified from the callback.\n     * The returned promise will settle in the same state as the original one\n     * after the provided callback has completed execution,\n     * unless the callback throws or returns a rejecting promise,\n     * in which case the returned promise will reject as well.\n     *\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\n     * with the same semantics as the `oncancelled` argument of the constructor.\n     * Once the parent promise settles, the `onfinally` callback will run,\n     * _even after the returned promise has been cancelled:_\n     * in that case, should it reject or throw, the reason will be wrapped\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\n     *\n     * This method is implemented in terms of {@link then} and the same caveats apply.\n     * It is polyfilled, hence available in every OS/webview version.\n     *\n     * @returns A Promise for the completion of the callback.\n     * Cancellation requests on the returned promise\n     * will propagate up the chain to the parent promise,\n     * but not in the other direction.\n     *\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\n     * up the entire promise chain have been run.\n     *\n     * If `onfinally` returns a cancellable promise,\n     * cancellation requests will be diverted to it,\n     * and the specified `oncancelled` callback will be discarded.\n     * See {@link then} for more details.\n     */\n    finally(onfinally?: (() => void) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<T> {\n        if (!(this instanceof CancellablePromise)) {\n            throw new TypeError(\"CancellablePromise.prototype.finally called on an invalid object.\");\n        }\n\n        if (!isCallable(onfinally)) {\n            return this.then(onfinally, onfinally, oncancelled);\n        }\n\n        return this.then(\n            (value) => CancellablePromise.resolve(onfinally()).then(() => value),\n            (reason?) => CancellablePromise.resolve(onfinally()).then(() => { throw reason; }),\n            oncancelled,\n        );\n    }\n\n    /**\n     * We use the `[Symbol.species]` static property, if available,\n     * to disable the built-in automatic subclassing features from {@link Promise}.\n     * It is critical for performance reasons that extenders do not override this.\n     * Once the proposal at https://github.com/tc39/proposal-rm-builtin-subclassing\n     * is either accepted or retired, this implementation will have to be revised accordingly.\n     *\n     * @ignore\n     * @internal\n     */\n    static get [species]() {\n        return Promise;\n    }\n\n    /**\n     * Creates a CancellablePromise that is resolved with an array of results\n     * when all of the provided Promises resolve, or rejected when any Promise is rejected.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static all<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>[]>;\n    static all<T extends readonly unknown[] | []>(values: T): CancellablePromise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;\n    static all<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = collected.length === 0\n            ? CancellablePromise.resolve(collected)\n            : new CancellablePromise<unknown>((resolve, reject) => {\n                void Promise.all(collected).then(resolve, reject);\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * Creates a CancellablePromise that is resolved with an array of results\n     * when all of the provided Promises resolve or reject.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static allSettled<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<PromiseSettledResult<Awaited<T>>[]>;\n    static allSettled<T extends readonly unknown[] | []>(values: T): CancellablePromise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>;\n    static allSettled<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = collected.length === 0\n            ? CancellablePromise.resolve(collected)\n            : new CancellablePromise<unknown>((resolve, reject) => {\n                void Promise.allSettled(collected).then(resolve, reject);\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * The any function returns a promise that is fulfilled by the first given promise to be fulfilled,\n     * or rejected with an AggregateError containing an array of rejection reasons\n     * if all of the given promises are rejected.\n     * It resolves all elements of the passed iterable to promises as it runs this algorithm.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static any<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>>;\n    static any<T extends readonly unknown[] | []>(values: T): CancellablePromise<Awaited<T[number]>>;\n    static any<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = collected.length === 0\n            ? CancellablePromise.resolve(collected)\n            : new CancellablePromise<unknown>((resolve, reject) => {\n                void Promise.any(collected).then(resolve, reject);\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved or rejected.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static race<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>>;\n    static race<T extends readonly unknown[] | []>(values: T): CancellablePromise<Awaited<T[number]>>;\n    static race<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = new CancellablePromise<unknown>((resolve, reject) => {\n            void Promise.race(collected).then(resolve, reject);\n        }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * Creates a new cancelled CancellablePromise for the provided cause.\n     *\n     * @group Static Methods\n     */\n    static cancel<T = never>(cause?: any): CancellablePromise<T> {\n        const p = new CancellablePromise<T>(() => {});\n        p.cancel(cause);\n        return p;\n    }\n\n    /**\n     * Creates a new CancellablePromise that cancels\n     * after the specified timeout, with the provided cause.\n     *\n     * If the {@link AbortSignal.timeout} factory method is available,\n     * it is used to base the timeout on _active_ time rather than _elapsed_ time.\n     * Otherwise, `timeout` falls back to {@link setTimeout}.\n     *\n     * @group Static Methods\n     */\n    static timeout<T = never>(milliseconds: number, cause?: any): CancellablePromise<T> {\n        const promise = new CancellablePromise<T>(() => {});\n        if (AbortSignal && typeof AbortSignal === 'function' && AbortSignal.timeout && typeof AbortSignal.timeout === 'function') {\n            AbortSignal.timeout(milliseconds).addEventListener('abort', () => void promise.cancel(cause));\n        } else {\n            setTimeout(() => void promise.cancel(cause), milliseconds);\n        }\n        return promise;\n    }\n\n    /**\n     * Creates a new CancellablePromise that resolves after the specified timeout.\n     * The returned promise can be cancelled without consequences.\n     *\n     * @group Static Methods\n     */\n    static sleep(milliseconds: number): CancellablePromise<void>;\n    /**\n     * Creates a new CancellablePromise that resolves after\n     * the specified timeout, with the provided value.\n     * The returned promise can be cancelled without consequences.\n     *\n     * @group Static Methods\n     */\n    static sleep<T>(milliseconds: number, value: T): CancellablePromise<T>;\n    static sleep<T = void>(milliseconds: number, value?: T): CancellablePromise<T> {\n        return new CancellablePromise<T>((resolve) => {\n            setTimeout(() => resolve(value!), milliseconds);\n        });\n    }\n\n    /**\n     * Creates a new rejected CancellablePromise for the provided reason.\n     *\n     * @group Static Methods\n     */\n    static reject<T = never>(reason?: any): CancellablePromise<T> {\n        return new CancellablePromise<T>((_, reject) => reject(reason));\n    }\n\n    /**\n     * Creates a new resolved CancellablePromise.\n     *\n     * @group Static Methods\n     */\n    static resolve(): CancellablePromise<void>;\n    /**\n     * Creates a new resolved CancellablePromise for the provided value.\n     *\n     * @group Static Methods\n     */\n    static resolve<T>(value: T): CancellablePromise<Awaited<T>>;\n    /**\n     * Creates a new resolved CancellablePromise for the provided value.\n     *\n     * @group Static Methods\n     */\n    static resolve<T>(value: T | PromiseLike<T>): CancellablePromise<Awaited<T>>;\n    static resolve<T = void>(value?: T | PromiseLike<T>): CancellablePromise<Awaited<T>> {\n        if (value instanceof CancellablePromise) {\n            // Optimise for cancellable promises.\n            return value;\n        }\n        return new CancellablePromise<any>((resolve) => resolve(value));\n    }\n\n    /**\n     * Creates a new CancellablePromise and returns it in an object, along with its resolve and reject functions\n     * and a getter/setter for the cancellation callback.\n     *\n     * This method is polyfilled, hence available in every OS/webview version.\n     *\n     * @group Static Methods\n     */\n    static withResolvers<T>(): CancellablePromiseWithResolvers<T> {\n        let result: CancellablePromiseWithResolvers<T> = { oncancelled: null } as any;\n        result.promise = new CancellablePromise<T>((resolve, reject) => {\n            result.resolve = resolve;\n            result.reject = reject;\n        }, (cause?: any) => { result.oncancelled?.(cause); });\n        return result;\n    }\n}\n\n/**\n * Returns a callback that implements the cancellation algorithm for the given cancellable promise.\n * The promise returned from the resulting function does not reject.\n */\nfunction cancellerFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState) {\n    let cancellationPromise: void | PromiseLike<void> = undefined;\n\n    return (reason: CancelError): void | PromiseLike<void> => {\n        if (!state.settled) {\n            state.settled = true;\n            state.reason = reason;\n            promise.reject(reason);\n\n            // Attach an error handler that ignores this specific rejection reason and nothing else.\n            // In theory, a sane underlying implementation at this point\n            // should always reject with our cancellation reason,\n            // hence the handler will never throw.\n            void Promise.prototype.then.call(promise.promise, undefined, (err) => {\n                if (err !== reason) {\n                    throw err;\n                }\n            });\n        }\n\n        // If reason is not set, the promise resolved regularly, hence we must not call oncancelled.\n        // If oncancelled is unset, no need to go any further.\n        if (!state.reason || !promise.oncancelled) { return; }\n\n        cancellationPromise = new Promise<void>((resolve) => {\n            try {\n                resolve(promise.oncancelled!(state.reason!.cause));\n            } catch (err) {\n                Promise.reject(new CancelledRejectionError(promise.promise, err, \"Unhandled exception in oncancelled callback.\"));\n            }\n        }).catch((reason?) => {\n            Promise.reject(new CancelledRejectionError(promise.promise, reason, \"Unhandled rejection in oncancelled callback.\"));\n        });\n\n        // Unset oncancelled to prevent repeated calls.\n        promise.oncancelled = null;\n\n        return cancellationPromise;\n    }\n}\n\n/**\n * Returns a callback that implements the resolution algorithm for the given cancellable promise.\n */\nfunction resolverFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState): CancellablePromiseResolver<T> {\n    return (value) => {\n        if (state.resolving) { return; }\n        state.resolving = true;\n\n        if (value === promise.promise) {\n            if (state.settled) { return; }\n            state.settled = true;\n            promise.reject(new TypeError(\"A promise cannot be resolved with itself.\"));\n            return;\n        }\n\n        if (value != null && (typeof value === 'object' || typeof value === 'function')) {\n            let then: any;\n            try {\n                then = (value as any).then;\n            } catch (err) {\n                state.settled = true;\n                promise.reject(err);\n                return;\n            }\n\n            if (isCallable(then)) {\n                try {\n                    let cancel = (value as any).cancel;\n                    if (isCallable(cancel)) {\n                        const oncancelled = (cause?: any) => {\n                            Reflect.apply(cancel, value, [cause]);\n                        };\n                        if (state.reason) {\n                            // If already cancelled, propagate cancellation.\n                            // The promise returned from the canceller algorithm does not reject\n                            // so it can be discarded safely.\n                            void cancellerFor({ ...promise, oncancelled }, state)(state.reason);\n                        } else {\n                            promise.oncancelled = oncancelled;\n                        }\n                    }\n                } catch {}\n\n                const newState: CancellablePromiseState = {\n                    root: state.root,\n                    resolving: false,\n                    get settled() { return this.root.settled },\n                    set settled(value) { this.root.settled = value; },\n                    get reason() { return this.root.reason }\n                };\n\n                const rejector = rejectorFor(promise, newState);\n                try {\n                    Reflect.apply(then, value, [resolverFor(promise, newState), rejector]);\n                } catch (err) {\n                    rejector(err);\n                }\n                return; // IMPORTANT!\n            }\n        }\n\n        if (state.settled) { return; }\n        state.settled = true;\n        promise.resolve(value);\n    };\n}\n\n/**\n * Returns a callback that implements the rejection algorithm for the given cancellable promise.\n */\nfunction rejectorFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState): CancellablePromiseRejector {\n    return (reason?) => {\n        if (state.resolving) { return; }\n        state.resolving = true;\n\n        if (state.settled) {\n            try {\n                if (reason instanceof CancelError && state.reason instanceof CancelError && Object.is(reason.cause, state.reason.cause)) {\n                    // Swallow late rejections that are CancelErrors whose cancellation cause is the same as ours.\n                    return;\n                }\n            } catch {}\n\n            void Promise.reject(new CancelledRejectionError(promise.promise, reason));\n        } else {\n            state.settled = true;\n            promise.reject(reason);\n        }\n    }\n}\n\n/**\n * Cancels all values in an array that look like cancellable thenables.\n * Returns a promise that fulfills once all cancellation procedures for the given values have settled.\n */\nfunction cancelAll(parent: CancellablePromise<unknown>, values: any[], cause?: any): Promise<void> {\n    const results = [];\n\n    for (const value of values) {\n        let cancel: CancellablePromiseCanceller;\n        try {\n            if (!isCallable(value.then)) { continue; }\n            cancel = value.cancel;\n            if (!isCallable(cancel)) { continue; }\n        } catch { continue; }\n\n        let result: void | PromiseLike<void>;\n        try {\n            result = Reflect.apply(cancel, value, [cause]);\n        } catch (err) {\n            Promise.reject(new CancelledRejectionError(parent, err, \"Unhandled exception in cancel method.\"));\n            continue;\n        }\n\n        if (!result) { continue; }\n        results.push(\n            (result instanceof Promise  ? result : Promise.resolve(result)).catch((reason?) => {\n                Promise.reject(new CancelledRejectionError(parent, reason, \"Unhandled rejection in cancel method.\"));\n            })\n        );\n    }\n\n    return Promise.all(results) as any;\n}\n\n/**\n * Returns its argument.\n */\nfunction identity<T>(x: T): T {\n    return x;\n}\n\n/**\n * Throws its argument.\n */\nfunction thrower(reason?: any): never {\n    throw reason;\n}\n\n/**\n * Attempts various strategies to convert an error to a string.\n */\nfunction errorMessage(err: any): string {\n    try {\n        if (err instanceof Error || typeof err !== 'object' || err.toString !== Object.prototype.toString) {\n            return \"\" + err;\n        }\n    } catch {}\n\n    try {\n        return JSON.stringify(err);\n    } catch {}\n\n    try {\n        return Object.prototype.toString.call(err);\n    } catch {}\n\n    return \"<could not convert error to string>\";\n}\n\n/**\n * Gets the current barrier promise for the given cancellable promise. If necessary, initialises the barrier.\n */\nfunction currentBarrier<T>(promise: CancellablePromise<T>): Promise<void> {\n    let pwr: Partial<PromiseWithResolvers<void>> = promise[barrierSym] ?? {};\n    if (!('promise' in pwr)) {\n        Object.assign(pwr, promiseWithResolvers<void>());\n    }\n    if (promise[barrierSym] == null) {\n        pwr.resolve!();\n        promise[barrierSym] = pwr;\n    }\n    return pwr.promise!;\n}\n\n// Polyfill Promise.withResolvers.\nlet promiseWithResolvers = Promise.withResolvers;\nif (promiseWithResolvers && typeof promiseWithResolvers === 'function') {\n    promiseWithResolvers = promiseWithResolvers.bind(Promise);\n} else {\n    promiseWithResolvers = function <T>(): PromiseWithResolvers<T> {\n        let resolve!: (value: T | PromiseLike<T>) => void;\n        let reject!: (reason?: any) => void;\n        const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej; });\n        return { promise, resolve, reject };\n    }\n}", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.Clipboard);\n\nconst ClipboardSetText = 0;\nconst ClipboardText = 1;\n\n/**\n * Sets the text to the Clipboard.\n *\n * @param text - The text to be set to the Clipboard.\n * @return A Promise that resolves when the operation is successful.\n */\nexport function SetText(text: string): Promise<void> {\n    return call(ClipboardSetText, {text});\n}\n\n/**\n * Get the Clipboard text\n *\n * @returns A promise that resolves with the text from the Clipboard.\n */\nexport function Text(): Promise<string> {\n    return call(ClipboardText);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Any is a dummy creation function for simple or unknown types.\n */\nexport function Any<T = any>(source: any): T {\n    return source;\n}\n\n/**\n * ByteSlice is a creation function that replaces\n * null strings with empty strings.\n */\nexport function ByteSlice(source: any): string {\n    return ((source == null) ? \"\" : source);\n}\n\n/**\n * Array takes a creation function for an arbitrary type\n * and returns an in-place creation function for an array\n * whose elements are of that type.\n */\nexport function Array<T = any>(element: (source: any) => T): (source: any) => T[] {\n    if (element === Any) {\n        return (source) => (source === null ? [] : source);\n    }\n\n    return (source) => {\n        if (source === null) {\n            return [];\n        }\n        for (let i = 0; i < source.length; i++) {\n            source[i] = element(source[i]);\n        }\n        return source;\n    };\n}\n\n/**\n * Map takes creation functions for two arbitrary types\n * and returns an in-place creation function for an object\n * whose keys and values are of those types.\n */\nexport function Map<V = any>(key: (source: any) => string, value: (source: any) => V): (source: any) => Record<string, V> {\n    if (value === Any) {\n        return (source) => (source === null ? {} : source);\n    }\n\n    return (source) => {\n        if (source === null) {\n            return {};\n        }\n        for (const key in source) {\n            source[key] = value(source[key]);\n        }\n        return source;\n    };\n}\n\n/**\n * Nullable takes a creation function for an arbitrary type\n * and returns a creation function for a nullable value of that type.\n */\nexport function Nullable<T = any>(element: (source: any) => T): (source: any) => (T | null) {\n    if (element === Any) {\n        return Any;\n    }\n\n    return (source) => (source === null ? null : element(source));\n}\n\n/**\n * Struct takes an object mapping field names to creation functions\n * and returns an in-place creation function for a struct.\n */\nexport function Struct(createField: Record<string, (source: any) => any>):\n    <U extends Record<string, any> = any>(source: any) => U\n{\n    let allAny = true;\n    for (const name in createField) {\n        if (createField[name] !== Any) {\n            allAny = false;\n            break;\n        }\n    }\n    if (allAny) {\n        return Any;\n    }\n\n    return (source) => {\n        for (const name in createField) {\n            if (name in source) {\n                source[name] = createField[name](source[name]);\n            }\n        }\n        return source;\n    };\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nexport interface Size {\n    /** The width of a rectangular area. */\n    Width: number;\n    /** The height of a rectangular area. */\n    Height: number;\n}\n\nexport interface Rect {\n    /** The X coordinate of the origin. */\n    X: number;\n    /** The Y coordinate of the origin. */\n    Y: number;\n    /** The width of the rectangle. */\n    Width: number;\n    /** The height of the rectangle. */\n    Height: number;\n}\n\nexport interface Screen {\n    /** Unique identifier for the screen. */\n    ID: string;\n    /** Human-readable name of the screen. */\n    Name: string;\n    /** The scale factor of the screen (DPI/96). 1 = standard DPI, 2 = HiDPI (Retina), etc. */\n    ScaleFactor: number;\n    /** The X coordinate of the screen. */\n    X: number;\n    /** The Y coordinate of the screen. */\n    Y: number;\n    /** Contains the width and height of the screen. */\n    Size: Size;\n    /** Contains the bounds of the screen in terms of X, Y, Width, and Height. */\n    Bounds: Rect;\n    /** Contains the physical bounds of the screen in terms of X, Y, Width, and Height (before scaling). */\n    PhysicalBounds: Rect;\n    /** Contains the area of the screen that is actually usable (excluding taskbar and other system UI). */\n    WorkArea: Rect;\n    /** Contains the physical WorkArea of the screen (before scaling). */\n    PhysicalWorkArea: Rect;\n    /** True if this is the primary monitor selected by the user in the operating system. */\n    IsPrimary: boolean;\n    /** The rotation of the screen. */\n    Rotation: number;\n}\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nconst call = newRuntimeCaller(objectNames.Screens);\n\nconst getAll = 0;\nconst getPrimary = 1;\nconst getCurrent = 2;\n\n/**\n * Gets all screens.\n *\n * @returns A promise that resolves to an array of Screen objects.\n */\nexport function GetAll(): Promise<Screen[]> {\n    return call(getAll);\n}\n\n/**\n * Gets the primary screen.\n *\n * @returns A promise that resolves to the primary screen.\n */\nexport function GetPrimary(): Promise<Screen> {\n    return call(getPrimary);\n}\n\n/**\n * Gets the current active screen.\n *\n * @returns A promise that resolves with the current active screen.\n */\nexport function GetCurrent(): Promise<Screen> {\n    return call(getCurrent);\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.IOS);\n\n// Method IDs\nconst HapticsImpact = 0;\nconst DeviceInfo = 1;\n\nexport namespace Haptics {\n    export type ImpactStyle = \"light\"|\"medium\"|\"heavy\"|\"soft\"|\"rigid\";\n    export function Impact(style: ImpactStyle = \"medium\"): Promise<void> {\n        return call(HapticsImpact, { style });\n    }\n}\n\nexport namespace Device {\n    export interface Info {\n        model: string;\n        systemName: string;\n        systemVersion: string;\n        isSimulator: boolean;\n    }\n    export function Info(): Promise<Info> {\n        return call(DeviceInfo);\n    }\n}\n"],
  "mappings": "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",
  "names": ["_a", "Error", "call", "_a", "Error", "call", "_a", "resizable", "call", "_a", "call", "_a", "call", "HideMethod", "ShowMethod", "isDocumentDotAll", "_a", "reason", "value", "call", "getAndDeleteResponse", "generateID", "call", "Array", "Map", "Array", "Map", "key", "call", "call", "Haptics", "Device", "Info"]
}

diff --git a/v3/internal/assetserver/webview/request_android.go b/v3/internal/assetserver/webview/request_android.go
new file mode 100644
index 000000000..aabe2aacb
--- /dev/null
+++ b/v3/internal/assetserver/webview/request_android.go
@@ -0,0 +1,102 @@
+//go:build android
+
+package webview
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+)
+
+// Request interface for Android asset requests
+// On Android, requests are handled via JNI from Java's WebViewAssetLoader
+
+// androidRequest implements the Request interface for Android
+type androidRequest struct {
+	url     string
+	method  string
+	headers http.Header
+	body    io.ReadCloser
+	rw      *androidResponseWriter
+}
+
+// NewRequestFromJNI creates a new request from JNI parameters
+func NewRequestFromJNI(url string, method string, headersJSON string) Request {
+	return &androidRequest{
+		url:     url,
+		method:  method,
+		headers: http.Header{},
+		body:    http.NoBody,
+	}
+}
+
+func (r *androidRequest) URL() (string, error) {
+	return r.url, nil
+}
+
+func (r *androidRequest) Method() (string, error) {
+	return r.method, nil
+}
+
+func (r *androidRequest) Header() (http.Header, error) {
+	return r.headers, nil
+}
+
+func (r *androidRequest) Body() (io.ReadCloser, error) {
+	return r.body, nil
+}
+
+func (r *androidRequest) Response() ResponseWriter {
+	if r.rw == nil {
+		r.rw = &androidResponseWriter{}
+	}
+	return r.rw
+}
+
+func (r *androidRequest) Close() error {
+	if r.body != nil {
+		return r.body.Close()
+	}
+	return nil
+}
+
+// androidResponseWriter implements ResponseWriter for Android
+type androidResponseWriter struct {
+	statusCode int
+	headers    http.Header
+	body       bytes.Buffer
+	finished   bool
+}
+
+func (w *androidResponseWriter) Header() http.Header {
+	if w.headers == nil {
+		w.headers = http.Header{}
+	}
+	return w.headers
+}
+
+func (w *androidResponseWriter) Write(data []byte) (int, error) {
+	return w.body.Write(data)
+}
+
+func (w *androidResponseWriter) WriteHeader(statusCode int) {
+	w.statusCode = statusCode
+}
+
+func (w *androidResponseWriter) Finish() error {
+	w.finished = true
+	return nil
+}
+
+// Code returns the HTTP status code of the response
+func (w *androidResponseWriter) Code() int {
+	if w.statusCode == 0 {
+		return 200
+	}
+	return w.statusCode
+}
+
+// GetResponseData returns the response data for JNI
+func (w *androidResponseWriter) GetResponseData() []byte {
+	return w.body.Bytes()
+}
diff --git a/v3/internal/assetserver/webview/request_linux.go b/v3/internal/assetserver/webview/request_linux.go
index 32969a1ba..192e9df5d 100644
--- a/v3/internal/assetserver/webview/request_linux.go
+++ b/v3/internal/assetserver/webview/request_linux.go
@@ -1,5 +1,4 @@
-//go:build linux
-// +build linux
+//go:build linux && !android
 
 package webview
 
diff --git a/v3/internal/assetserver/webview/request_linux_purego.go b/v3/internal/assetserver/webview/request_linux_purego.go
index bf724a55b..34937d25f 100644
--- a/v3/internal/assetserver/webview/request_linux_purego.go
+++ b/v3/internal/assetserver/webview/request_linux_purego.go
@@ -1,5 +1,4 @@
-//go:build linux && purego
-// +build linux,purego
+//go:build linux && purego && !android
 
 package webview
 
diff --git a/v3/internal/assetserver/webview/responsewriter_linux.go b/v3/internal/assetserver/webview/responsewriter_linux.go
index 169b68ab5..ca232afc0 100644
--- a/v3/internal/assetserver/webview/responsewriter_linux.go
+++ b/v3/internal/assetserver/webview/responsewriter_linux.go
@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && !android
 
 package webview
 
diff --git a/v3/internal/assetserver/webview/responsewriter_linux_purego.go b/v3/internal/assetserver/webview/responsewriter_linux_purego.go
index 6742d1bda..804765226 100644
--- a/v3/internal/assetserver/webview/responsewriter_linux_purego.go
+++ b/v3/internal/assetserver/webview/responsewriter_linux_purego.go
@@ -1,5 +1,4 @@
-//go:build linux && purego
-// +build linux,purego
+//go:build linux && purego && !android
 
 package webview
 
diff --git a/v3/internal/assetserver/webview/webkit2.go b/v3/internal/assetserver/webview/webkit2.go
index 21156a4c5..dfc79ef7e 100644
--- a/v3/internal/assetserver/webview/webkit2.go
+++ b/v3/internal/assetserver/webview/webkit2.go
@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && !android
 
 package webview
 
diff --git a/v3/internal/operatingsystem/os_android.go b/v3/internal/operatingsystem/os_android.go
new file mode 100644
index 000000000..494b84d78
--- /dev/null
+++ b/v3/internal/operatingsystem/os_android.go
@@ -0,0 +1,17 @@
+//go:build android
+
+package operatingsystem
+
+import (
+	"fmt"
+	"runtime"
+)
+
+func platformInfo() (*OS, error) {
+	return &OS{
+		ID:       "android",
+		Name:     "Android",
+		Version:  fmt.Sprintf("Go %s", runtime.Version()),
+		Branding: "Android",
+	}, nil
+}
diff --git a/v3/internal/operatingsystem/os_linux.go b/v3/internal/operatingsystem/os_linux.go
index 715207dc5..04cd39b9a 100644
--- a/v3/internal/operatingsystem/os_linux.go
+++ b/v3/internal/operatingsystem/os_linux.go
@@ -1,5 +1,4 @@
-//go:build linux
-// +build linux
+//go:build linux && !android
 
 package operatingsystem
 
diff --git a/v3/internal/operatingsystem/webkit_linux.go b/v3/internal/operatingsystem/webkit_linux.go
index 96fcb6c1a..8424f298c 100644
--- a/v3/internal/operatingsystem/webkit_linux.go
+++ b/v3/internal/operatingsystem/webkit_linux.go
@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && !android
 
 package operatingsystem
 
diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json b/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json
index 3248d6e75..53763754b 100644
--- a/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json
+++ b/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@wailsio/runtime",
-  "version": "3.0.0-alpha.68",
+  "version": "3.0.0-alpha.69",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@wailsio/runtime",
-      "version": "3.0.0-alpha.68",
+      "version": "3.0.0-alpha.69",
       "license": "MIT",
       "devDependencies": {
         "happy-dom": "^17.1.1",
@@ -16,7 +16,7 @@
         "typedoc-plugin-markdown": "^4.4.2",
         "typedoc-plugin-mdn-links": "^4.0.13",
         "typedoc-plugin-missing-exports": "^3.1.0",
-        "typescript": "^5.9.2",
+        "typescript": "^5.9.3",
         "vitest": "^3.0.6"
       }
     },
@@ -2663,9 +2663,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.9.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.2.tgz",
-      "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==",
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
       "dev": true,
       "license": "Apache-2.0",
       "bin": {
diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/package.json b/v3/internal/runtime/desktop/@wailsio/runtime/package.json
index 33207f6ee..174130542 100644
--- a/v3/internal/runtime/desktop/@wailsio/runtime/package.json
+++ b/v3/internal/runtime/desktop/@wailsio/runtime/package.json
@@ -49,7 +49,7 @@
     "typedoc-plugin-markdown": "^4.4.2",
     "typedoc-plugin-mdn-links": "^4.0.13",
     "typedoc-plugin-missing-exports": "^3.1.0",
-    "typescript": "^5.9.2",
+    "typescript": "^5.9.3",
     "vitest": "^3.0.6"
   },
   "overrides": {
diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/src/system.ts b/v3/internal/runtime/desktop/@wailsio/runtime/src/system.ts
index 426642d97..f0b4b1773 100644
--- a/v3/internal/runtime/desktop/@wailsio/runtime/src/system.ts
+++ b/v3/internal/runtime/desktop/@wailsio/runtime/src/system.ts
@@ -18,11 +18,18 @@ const ApplicationFilesDroppedWithContext = 100; // New method ID for enriched dr
 
 const _invoke = (function () {
     try {
+        // Windows WebView2
         if ((window as any).chrome?.webview?.postMessage) {
             return (window as any).chrome.webview.postMessage.bind((window as any).chrome.webview);
-        } else if ((window as any).webkit?.messageHandlers?.['external']?.postMessage) {
+        }
+        // macOS/iOS WKWebView
+        else if ((window as any).webkit?.messageHandlers?.['external']?.postMessage) {
             return (window as any).webkit.messageHandlers['external'].postMessage.bind((window as any).webkit.messageHandlers['external']);
         }
+        // Android WebView - uses addJavascriptInterface which exposes window.wails.invoke
+        else if ((window as any).wails?.invoke) {
+            return (msg: any) => (window as any).wails.invoke(typeof msg === 'string' ? msg : JSON.stringify(msg));
+        }
     } catch(e) {}
 
     console.warn('\n%c⚠️ Browser Environment Detected %c\n\n%cOnly UI previews are available in the browser. For full functionality, please run the application in desktop mode.\nMore information at: https://v3.wails.io/learn/build/#using-a-browser-for-development\n',
diff --git a/v3/internal/runtime/package-lock.json b/v3/internal/runtime/package-lock.json
new file mode 100644
index 000000000..f75f8cf7b
--- /dev/null
+++ b/v3/internal/runtime/package-lock.json
@@ -0,0 +1,6 @@
+{
+  "name": "runtime",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}
diff --git a/v3/internal/runtime/runtime_android.go b/v3/internal/runtime/runtime_android.go
new file mode 100644
index 000000000..ab212a891
--- /dev/null
+++ b/v3/internal/runtime/runtime_android.go
@@ -0,0 +1,16 @@
+//go:build android
+
+package runtime
+
+// Android uses window.wails.invoke which is set up via addJavascriptInterface in WailsJSBridge
+// We need to log the state to debug why it's not being detected
+var invoke = `
+console.log('[Wails Android Runtime] Injecting runtime, window.wails exists:', !!window.wails);
+console.log('[Wails Android Runtime] window.wails.invoke exists:', !!(window.wails && window.wails.invoke));
+window._wails.invoke=function(m){
+    console.log('[Wails Android Runtime] _wails.invoke called:', m);
+    return window.wails.invoke(typeof m==='string'?m:JSON.stringify(m));
+};
+console.log('[Wails Android Runtime] Runtime injection complete');
+`
+var flags = ""
diff --git a/v3/internal/runtime/runtime_linux.go b/v3/internal/runtime/runtime_linux.go
index 7d9f32569..cb7af6ff2 100644
--- a/v3/internal/runtime/runtime_linux.go
+++ b/v3/internal/runtime/runtime_linux.go
@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && !android
 
 package runtime
 
diff --git a/v3/pkg/application/application_android.go b/v3/pkg/application/application_android.go
new file mode 100644
index 000000000..46a45fc17
--- /dev/null
+++ b/v3/pkg/application/application_android.go
@@ -0,0 +1,686 @@
+//go:build android && cgo
+
+package application
+
+/*
+#include 
+#include 
+#include 
+
+// Global JavaVM reference for thread attachment
+static JavaVM* g_jvm = NULL;
+
+// Global reference to bridge object (must be a global ref, not local)
+static jobject g_bridge = NULL;
+
+// Cached method ID for executeJavaScript
+static jmethodID g_executeJsMethod = NULL;
+
+// Helper function to convert Java String to C string
+static const char* jstringToC(JNIEnv *env, jstring jstr) {
+    if (jstr == NULL) return NULL;
+    return (*env)->GetStringUTFChars(env, jstr, NULL);
+}
+
+// Helper function to release Java String
+static void releaseJString(JNIEnv *env, jstring jstr, const char* cstr) {
+    if (jstr != NULL && cstr != NULL) {
+        (*env)->ReleaseStringUTFChars(env, jstr, cstr);
+    }
+}
+
+// Helper function to create Java byte array from C data
+static jbyteArray createByteArray(JNIEnv *env, const void* data, int len) {
+    if (data == NULL || len <= 0) return NULL;
+    jbyteArray arr = (*env)->NewByteArray(env, len);
+    if (arr != NULL) {
+        (*env)->SetByteArrayRegion(env, arr, 0, len, (const jbyte*)data);
+    }
+    return arr;
+}
+
+// Helper function to create Java String from C string
+static jstring createJString(JNIEnv *env, const char* str) {
+    if (str == NULL) return NULL;
+    return (*env)->NewStringUTF(env, str);
+}
+
+// Store JavaVM and create global reference to bridge
+static void storeBridgeRef(JNIEnv *env, jobject bridge) {
+    // Get JavaVM
+    if ((*env)->GetJavaVM(env, &g_jvm) != 0) {
+        return;
+    }
+
+    // Create global reference to bridge object
+    g_bridge = (*env)->NewGlobalRef(env, bridge);
+    if (g_bridge == NULL) {
+        return;
+    }
+
+    // Cache the executeJavaScript method ID
+    jclass bridgeClass = (*env)->GetObjectClass(env, g_bridge);
+    if (bridgeClass != NULL) {
+        g_executeJsMethod = (*env)->GetMethodID(env, bridgeClass, "executeJavaScript", "(Ljava/lang/String;)V");
+        (*env)->DeleteLocalRef(env, bridgeClass);
+    }
+}
+
+// Android logging via __android_log_print
+#include 
+#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, "WailsNative", __VA_ARGS__)
+
+// Execute JavaScript via the bridge - can be called from any thread
+static void executeJavaScriptOnBridge(const char* js) {
+    LOGD("executeJavaScriptOnBridge called, js length: %d", js ? (int)strlen(js) : -1);
+
+    if (g_jvm == NULL) {
+        LOGD("executeJavaScriptOnBridge: g_jvm is NULL");
+        return;
+    }
+    if (g_bridge == NULL) {
+        LOGD("executeJavaScriptOnBridge: g_bridge is NULL");
+        return;
+    }
+    if (g_executeJsMethod == NULL) {
+        LOGD("executeJavaScriptOnBridge: g_executeJsMethod is NULL");
+        return;
+    }
+    if (js == NULL) {
+        LOGD("executeJavaScriptOnBridge: js is NULL");
+        return;
+    }
+
+    JNIEnv *env = NULL;
+    int needsDetach = 0;
+
+    // Get JNIEnv for current thread
+    jint result = (*g_jvm)->GetEnv(g_jvm, (void**)&env, JNI_VERSION_1_6);
+    LOGD("executeJavaScriptOnBridge: GetEnv result = %d", result);
+    if (result == JNI_EDETACHED) {
+        // Attach current thread to JVM
+        LOGD("executeJavaScriptOnBridge: Attaching thread");
+        if ((*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL) != 0) {
+            LOGD("executeJavaScriptOnBridge: AttachCurrentThread failed");
+            return;
+        }
+        needsDetach = 1;
+    } else if (result != JNI_OK) {
+        LOGD("executeJavaScriptOnBridge: GetEnv failed with %d", result);
+        return;
+    }
+
+    // Create Java string and call method
+    jstring jJs = (*env)->NewStringUTF(env, js);
+    LOGD("executeJavaScriptOnBridge: jJs created: %p", jJs);
+    if (jJs != NULL) {
+        LOGD("executeJavaScriptOnBridge: Calling Java method");
+        (*env)->CallVoidMethod(env, g_bridge, g_executeJsMethod, jJs);
+        LOGD("executeJavaScriptOnBridge: Java method called");
+        (*env)->DeleteLocalRef(env, jJs);
+    }
+
+    // Check for exceptions
+    if ((*env)->ExceptionCheck(env)) {
+        LOGD("executeJavaScriptOnBridge: Exception occurred!");
+        (*env)->ExceptionDescribe(env);
+        (*env)->ExceptionClear(env);
+    }
+
+    // Detach if we attached
+    if (needsDetach) {
+        LOGD("executeJavaScriptOnBridge: Detaching thread");
+        (*g_jvm)->DetachCurrentThread(g_jvm);
+    }
+
+    LOGD("executeJavaScriptOnBridge: Done");
+}
+*/
+import "C"
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"time"
+	"unsafe"
+
+	"github.com/wailsapp/wails/v3/internal/runtime"
+)
+
+var (
+	// Global reference to the app for JNI callbacks
+	globalApp     *App
+	globalAppLock sync.RWMutex
+
+	// JNI environment and class references
+	javaVM       unsafe.Pointer
+	bridgeObject unsafe.Pointer
+
+	// Android main function registration
+	androidMainFunc func()
+	androidMainLock sync.Mutex
+
+	// App ready signal
+	appReady     = make(chan struct{})
+	appReadyOnce sync.Once
+)
+
+func init() {
+	androidLogf("info", "🤖 [application_android.go] init() called")
+}
+
+// RegisterAndroidMain registers the main function to be called when the Android app starts.
+// This should be called from init() in your main.go file for Android builds.
+// Example:
+//
+//	func init() {
+//		application.RegisterAndroidMain(main)
+//	}
+func RegisterAndroidMain(mainFunc func()) {
+	androidMainLock.Lock()
+	defer androidMainLock.Unlock()
+	androidMainFunc = mainFunc
+	androidLogf("info", "🤖 [application_android.go] Android main function registered")
+}
+
+// signalAppReady signals that the app is ready to serve requests
+func signalAppReady() {
+	appReadyOnce.Do(func() {
+		close(appReady)
+		androidLogf("info", "🤖 [application_android.go] App ready signal sent")
+	})
+}
+
+// waitForAppReady waits for the app to be ready, with a timeout
+func waitForAppReady(timeout time.Duration) bool {
+	select {
+	case <-appReady:
+		return true
+	case <-time.After(timeout):
+		return false
+	}
+}
+
+func androidLogf(level string, format string, a ...interface{}) {
+	msg := fmt.Sprintf(format, a...)
+	// For now, just use println - we'll connect to Android's Log.* later
+	println(fmt.Sprintf("[Android/%s] %s", level, msg))
+}
+
+func (a *App) platformRun() {
+	androidLogf("info", "🤖 [application_android.go] platformRun() called")
+
+	// Store global reference for JNI callbacks
+	globalAppLock.Lock()
+	globalApp = a
+	globalAppLock.Unlock()
+
+	// Signal that the app is ready to serve requests
+	signalAppReady()
+
+	androidLogf("info", "🤖 [application_android.go] App ready, waiting for Android lifecycle...")
+
+	// Block forever - Android manages the app lifecycle via JNI callbacks
+	select {}
+}
+
+func (a *App) platformQuit() {
+	androidLogf("info", "🤖 [application_android.go] platformQuit() called")
+	// Android will handle app termination
+}
+
+func (a *App) isDarkMode() bool {
+	// TODO: Query Android for dark mode status
+	return false
+}
+
+func (a *App) isWindows() bool {
+	return false
+}
+
+// Platform-specific app implementation for Android
+type androidApp struct {
+	parent *App
+}
+
+func newPlatformApp(app *App) *androidApp {
+	androidLogf("info", "🤖 [application_android.go] newPlatformApp() called")
+	return &androidApp{
+		parent: app,
+	}
+}
+
+func (a *androidApp) run() error {
+	androidLogf("info", "🤖 [application_android.go] androidApp.run() called")
+
+	// Emit application started event
+	a.parent.Event.Emit("ApplicationStarted")
+
+	a.parent.platformRun()
+	return nil
+}
+
+func (a *androidApp) destroy() {
+	androidLogf("info", "🤖 [application_android.go] androidApp.destroy() called")
+}
+
+func (a *androidApp) setIcon(_ []byte) {
+	// Android app icon is set through AndroidManifest.xml
+}
+
+func (a *androidApp) name() string {
+	return a.parent.options.Name
+}
+
+func (a *androidApp) GetFlags(options Options) map[string]any {
+	return nil
+}
+
+func (a *androidApp) getAccentColor() string {
+	return ""
+}
+
+func (a *androidApp) getCurrentWindowID() uint {
+	return 0
+}
+
+func (a *androidApp) hide() {
+	// Android manages app visibility
+}
+
+func (a *androidApp) isDarkMode() bool {
+	return a.parent.isDarkMode()
+}
+
+func (a *androidApp) on(_ uint) {
+	// Android event handling
+}
+
+func (a *androidApp) setApplicationMenu(_ *Menu) {
+	// Android doesn't have application menus in the same way
+}
+
+func (a *androidApp) show() {
+	// Android manages app visibility
+}
+
+func (a *androidApp) showAboutDialog(_ string, _ string, _ []byte) {
+	// TODO: Implement Android about dialog
+}
+
+func (a *androidApp) getPrimaryScreen() (*Screen, error) {
+	screens, err := getScreens()
+	if err != nil || len(screens) == 0 {
+		return nil, err
+	}
+	return screens[0], nil
+}
+
+func (a *androidApp) getScreens() ([]*Screen, error) {
+	return getScreens()
+}
+
+func (a *App) logPlatformInfo() {
+	// Log Android platform info
+	androidLogf("info", "Platform: Android")
+}
+
+func (a *App) platformEnvironment() map[string]any {
+	return map[string]any{
+		"platform": "android",
+	}
+}
+
+func fatalHandler(errFunc func(error)) {
+	// Android fatal handler
+}
+
+// JNI Export Functions - Called from Java
+
+//export Java_com_wails_app_WailsBridge_nativeInit
+func Java_com_wails_app_WailsBridge_nativeInit(env *C.JNIEnv, obj C.jobject, bridge C.jobject) {
+	androidLogf("info", "🤖 [JNI] nativeInit called")
+
+	// Store references for later use (legacy - keeping for compatibility)
+	javaVM = unsafe.Pointer(env)
+	bridgeObject = unsafe.Pointer(bridge)
+
+	// Store JavaVM and bridge global reference for JNI callbacks
+	C.storeBridgeRef(env, bridge)
+	androidLogf("info", "🤖 [JNI] Bridge reference stored for JNI callbacks")
+
+	// Start the registered main function in a goroutine
+	androidMainLock.Lock()
+	mainFunc := androidMainFunc
+	androidMainLock.Unlock()
+
+	if mainFunc != nil {
+		androidLogf("info", "🤖 [JNI] Starting registered main function in goroutine")
+		go mainFunc()
+	} else {
+		androidLogf("warn", "🤖 [JNI] No main function registered! Call application.RegisterAndroidMain(main) in init()")
+	}
+
+	androidLogf("info", "🤖 [JNI] nativeInit complete")
+}
+
+//export Java_com_wails_app_WailsBridge_nativeShutdown
+func Java_com_wails_app_WailsBridge_nativeShutdown(env *C.JNIEnv, obj C.jobject) {
+	androidLogf("info", "🤖 [JNI] nativeShutdown called")
+
+	globalAppLock.Lock()
+	if globalApp != nil {
+		globalApp.Quit()
+	}
+	globalAppLock.Unlock()
+}
+
+//export Java_com_wails_app_WailsBridge_nativeOnResume
+func Java_com_wails_app_WailsBridge_nativeOnResume(env *C.JNIEnv, obj C.jobject) {
+	androidLogf("info", "🤖 [JNI] nativeOnResume called")
+
+	globalAppLock.RLock()
+	app := globalApp
+	globalAppLock.RUnlock()
+
+	if app != nil {
+		app.Event.Emit("ApplicationResumed")
+	}
+}
+
+//export Java_com_wails_app_WailsBridge_nativeOnPause
+func Java_com_wails_app_WailsBridge_nativeOnPause(env *C.JNIEnv, obj C.jobject) {
+	androidLogf("info", "🤖 [JNI] nativeOnPause called")
+
+	globalAppLock.RLock()
+	app := globalApp
+	globalAppLock.RUnlock()
+
+	if app != nil {
+		app.Event.Emit("ApplicationPaused")
+	}
+}
+
+//export Java_com_wails_app_WailsBridge_nativeOnPageFinished
+func Java_com_wails_app_WailsBridge_nativeOnPageFinished(env *C.JNIEnv, obj C.jobject, jurl C.jstring) {
+	cUrl := C.jstringToC(env, jurl)
+	defer C.releaseJString(env, jurl, cUrl)
+	url := C.GoString(cUrl)
+
+	androidLogf("info", "🤖 [JNI] nativeOnPageFinished called: %s", url)
+
+	globalAppLock.RLock()
+	app := globalApp
+	globalAppLock.RUnlock()
+
+	if app == nil {
+		androidLogf("error", "🤖 [JNI] nativeOnPageFinished: app is nil")
+		return
+	}
+
+	// Inject the runtime into the first window (with proper locking)
+	app.windowsLock.RLock()
+	windowCount := len(app.windows)
+	androidLogf("info", "🤖 [JNI] nativeOnPageFinished: window count = %d", windowCount)
+	for id, win := range app.windows {
+		androidLogf("info", "🤖 [JNI] Found window ID: %d", id)
+		if win != nil {
+			androidLogf("info", "🤖 [JNI] Injecting runtime.Core() into window %d", id)
+			// Get the runtime core JavaScript
+			runtimeJS := runtime.Core()
+			androidLogf("info", "🤖 [JNI] Runtime JS length: %d bytes", len(runtimeJS))
+			app.windowsLock.RUnlock()
+			// IMPORTANT: We must bypass win.ExecJS because it queues if runtimeLoaded is false.
+			// On Android, we need to inject the runtime directly since the runtime hasn't been loaded yet.
+			// This is the bootstrap injection that enables the runtime to load.
+			androidLogf("info", "🤖 [JNI] Calling executeJavaScript directly (bypassing queue)")
+			executeJavaScript(runtimeJS)
+			// Emit event
+			app.Event.Emit("PageFinished", url)
+			return
+		}
+	}
+	app.windowsLock.RUnlock()
+
+	androidLogf("warn", "🤖 [JNI] nativeOnPageFinished: no windows found to inject runtime")
+	// Emit event even if no windows
+	app.Event.Emit("PageFinished", url)
+}
+
+//export Java_com_wails_app_WailsBridge_nativeServeAsset
+func Java_com_wails_app_WailsBridge_nativeServeAsset(env *C.JNIEnv, obj C.jobject, jpath C.jstring, jmethod C.jstring, jheaders C.jstring) C.jbyteArray {
+	// Convert Java strings to Go strings
+	cPath := C.jstringToC(env, jpath)
+	cMethod := C.jstringToC(env, jmethod)
+	defer C.releaseJString(env, jpath, cPath)
+	defer C.releaseJString(env, jmethod, cMethod)
+
+	goPath := C.GoString(cPath)
+	goMethod := C.GoString(cMethod)
+
+	androidLogf("debug", "🤖 [JNI] nativeServeAsset: %s %s", goMethod, goPath)
+
+	// Wait for the app to be ready (timeout after 10 seconds)
+	if !waitForAppReady(10 * time.Second) {
+		androidLogf("error", "🤖 [JNI] Timeout waiting for app to be ready")
+		return C.createByteArray(env, nil, 0)
+	}
+
+	globalAppLock.RLock()
+	app := globalApp
+	globalAppLock.RUnlock()
+
+	if app == nil || app.assets == nil {
+		androidLogf("error", "🤖 [JNI] App or assets not initialized after ready signal")
+		return C.createByteArray(env, nil, 0)
+	}
+
+	// Serve the asset through the asset server
+	data, err := serveAssetForAndroid(app, goPath)
+	if err != nil {
+		androidLogf("error", "🤖 [JNI] Error serving asset %s: %v", goPath, err)
+		return C.createByteArray(env, nil, 0)
+	}
+
+	androidLogf("debug", "🤖 [JNI] Serving asset %s (%d bytes)", goPath, len(data))
+
+	// Create Java byte array from the data
+	// Handle empty data case to avoid index out of range panic
+	if len(data) == 0 {
+		return C.createByteArray(env, nil, 0)
+	}
+	return C.createByteArray(env, unsafe.Pointer(&data[0]), C.int(len(data)))
+}
+
+//export Java_com_wails_app_WailsBridge_nativeHandleMessage
+func Java_com_wails_app_WailsBridge_nativeHandleMessage(env *C.JNIEnv, obj C.jobject, jmessage C.jstring) C.jstring {
+	// Convert Java string to Go string
+	cMessage := C.jstringToC(env, jmessage)
+	defer C.releaseJString(env, jmessage, cMessage)
+
+	goMessage := C.GoString(cMessage)
+
+	androidLogf("debug", "🤖 [JNI] nativeHandleMessage: %s", goMessage)
+
+	globalAppLock.RLock()
+	app := globalApp
+	globalAppLock.RUnlock()
+
+	if app == nil {
+		errorResponse := `{"error":"App not initialized"}`
+		return C.createJString(env, C.CString(errorResponse))
+	}
+
+	// Parse and handle the message
+	response := handleMessageForAndroid(app, goMessage)
+	return C.createJString(env, C.CString(response))
+}
+
+//export Java_com_wails_app_WailsBridge_nativeGetAssetMimeType
+func Java_com_wails_app_WailsBridge_nativeGetAssetMimeType(env *C.JNIEnv, obj C.jobject, jpath C.jstring) C.jstring {
+	// Convert Java string to Go string
+	cPath := C.jstringToC(env, jpath)
+	defer C.releaseJString(env, jpath, cPath)
+
+	goPath := C.GoString(cPath)
+	mimeType := getMimeTypeForPath(goPath)
+	return C.createJString(env, C.CString(mimeType))
+}
+
+// Helper functions
+
+func serveAssetForAndroid(app *App, path string) ([]byte, error) {
+	// Check if this is a runtime call (includes query string)
+	isRuntimeCall := strings.HasPrefix(path, "/wails/runtime")
+
+	// Normalize path for regular assets (not runtime calls)
+	if !isRuntimeCall {
+		if path == "" || path == "/" {
+			path = "/index.html"
+		}
+	}
+
+	// Ensure path starts with /
+	if len(path) > 0 && path[0] != '/' {
+		path = "/" + path
+	}
+
+	// Check if asset server is available
+	if app.assets == nil {
+		return nil, fmt.Errorf("asset server not initialized")
+	}
+
+	// Create a fake HTTP request
+	fullURL := "https://wails.localhost" + path
+	androidLogf("debug", "🤖 [serveAssetForAndroid] Creating request for: %s", fullURL)
+
+	req, err := http.NewRequest("GET", fullURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	// For runtime calls (/wails/runtime), we need to add the window ID header
+	// This is required by the MessageProcessor to route the call correctly
+	if isRuntimeCall {
+		// Get the first window (on Android, there's typically only one)
+		windows := app.Window.GetAll()
+		androidLogf("debug", "🤖 [serveAssetForAndroid] Runtime call, found %d windows", len(windows))
+		if len(windows) > 0 {
+			// Use the first window's ID
+			windowID := windows[0].ID()
+			req.Header.Set("x-wails-window-id", fmt.Sprintf("%d", windowID))
+			androidLogf("debug", "🤖 [serveAssetForAndroid] Added window ID header: %d", windowID)
+		} else {
+			androidLogf("warn", "🤖 [serveAssetForAndroid] No windows available for runtime call")
+		}
+	}
+
+	// Use httptest.ResponseRecorder to capture the response
+	recorder := httptest.NewRecorder()
+
+	// Serve the request through the asset server
+	app.assets.ServeHTTP(recorder, req)
+
+	// Check response status
+	result := recorder.Result()
+	defer result.Body.Close()
+
+	// Read the response body
+	body, err := io.ReadAll(result.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	androidLogf("debug", "🤖 [serveAssetForAndroid] Response status: %d, body length: %d", result.StatusCode, len(body))
+
+	// For runtime calls, we need to return the body even for error responses
+	// so the JavaScript can see the error message
+	if isRuntimeCall {
+		if result.StatusCode != http.StatusOK {
+			androidLogf("warn", "🤖 [serveAssetForAndroid] Runtime call returned status %d: %s", result.StatusCode, string(body))
+		}
+		// Return the body regardless of status - the JS will handle errors
+		return body, nil
+	}
+
+	// For regular assets, check status codes
+	if result.StatusCode == http.StatusNotFound {
+		return nil, fmt.Errorf("asset not found: %s", path)
+	}
+
+	if result.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("asset server error: status %d for %s", result.StatusCode, path)
+	}
+
+	return body, nil
+}
+
+func handleMessageForAndroid(app *App, message string) string {
+	// Parse the message
+	var msg map[string]interface{}
+	if err := json.Unmarshal([]byte(message), &msg); err != nil {
+		return fmt.Sprintf(`{"error":"%s"}`, err.Error())
+	}
+
+	// TODO: Route to appropriate handler based on message type
+	// For now, return success
+	return `{"success":true}`
+}
+
+func getMimeTypeForPath(path string) string {
+	// Simple MIME type detection based on extension
+	switch {
+	case endsWith(path, ".html"), endsWith(path, ".htm"):
+		return "text/html"
+	case endsWith(path, ".js"), endsWith(path, ".mjs"):
+		return "application/javascript"
+	case endsWith(path, ".css"):
+		return "text/css"
+	case endsWith(path, ".json"):
+		return "application/json"
+	case endsWith(path, ".png"):
+		return "image/png"
+	case endsWith(path, ".jpg"), endsWith(path, ".jpeg"):
+		return "image/jpeg"
+	case endsWith(path, ".gif"):
+		return "image/gif"
+	case endsWith(path, ".svg"):
+		return "image/svg+xml"
+	case endsWith(path, ".ico"):
+		return "image/x-icon"
+	case endsWith(path, ".woff"):
+		return "font/woff"
+	case endsWith(path, ".woff2"):
+		return "font/woff2"
+	case endsWith(path, ".ttf"):
+		return "font/ttf"
+	default:
+		return "application/octet-stream"
+	}
+}
+
+func endsWith(s, suffix string) bool {
+	return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix
+}
+
+// executeJavaScript executes JavaScript code in the Android WebView via JNI callback
+func executeJavaScript(js string) {
+	androidLogf("info", "🤖 executeJavaScript called, length: %d", len(js))
+	if js == "" {
+		androidLogf("warn", "🤖 executeJavaScript: empty JS string")
+		return
+	}
+
+	// Convert Go string to C string and call the JNI bridge
+	androidLogf("info", "🤖 executeJavaScript: calling C.executeJavaScriptOnBridge")
+	cJs := C.CString(js)
+	defer C.free(unsafe.Pointer(cJs))
+
+	C.executeJavaScriptOnBridge(cJs)
+	androidLogf("info", "🤖 executeJavaScript: done")
+}
diff --git a/v3/pkg/application/application_android_nocgo.go b/v3/pkg/application/application_android_nocgo.go
new file mode 100644
index 000000000..cd897031e
--- /dev/null
+++ b/v3/pkg/application/application_android_nocgo.go
@@ -0,0 +1,224 @@
+//go:build android && !cgo
+
+package application
+
+import (
+	"encoding/json"
+	"fmt"
+	"sync"
+	"unsafe"
+)
+
+var (
+	// Global reference to the app for JNI callbacks
+	globalApp     *App
+	globalAppLock sync.RWMutex
+
+	// JNI environment and class references
+	javaVM       unsafe.Pointer
+	bridgeObject unsafe.Pointer
+)
+
+func init() {
+	androidLogf("info", "🤖 [application_android.go] init() called")
+}
+
+func androidLogf(level string, format string, a ...interface{}) {
+	msg := fmt.Sprintf(format, a...)
+	// For now, just use println - we'll connect to Android's Log.* later
+	println(fmt.Sprintf("[Android/%s] %s", level, msg))
+}
+
+func (a *App) platformRun() {
+	androidLogf("info", "🤖 [application_android.go] platformRun() called")
+
+	// Store global reference for JNI callbacks
+	globalAppLock.Lock()
+	globalApp = a
+	globalAppLock.Unlock()
+
+	androidLogf("info", "🤖 [application_android.go] Waiting for Android lifecycle...")
+
+	// Block forever - Android manages the app lifecycle via JNI callbacks
+	select {}
+}
+
+func (a *App) platformQuit() {
+	androidLogf("info", "🤖 [application_android.go] platformQuit() called")
+	// Android will handle app termination
+}
+
+func (a *App) isDarkMode() bool {
+	// TODO: Query Android for dark mode status
+	return false
+}
+
+func (a *App) isWindows() bool {
+	return false
+}
+
+// Platform-specific app implementation for Android
+type androidApp struct {
+	parent *App
+}
+
+func newPlatformApp(app *App) *androidApp {
+	androidLogf("info", "🤖 [application_android.go] newPlatformApp() called")
+	return &androidApp{
+		parent: app,
+	}
+}
+
+func (a *androidApp) run() error {
+	androidLogf("info", "🤖 [application_android.go] androidApp.run() called")
+
+	// Wire common events
+	a.setupCommonEvents()
+
+	// Emit application started event
+	a.parent.Event.Emit("ApplicationStarted")
+
+	a.parent.platformRun()
+	return nil
+}
+
+func (a *androidApp) destroy() {
+	androidLogf("info", "🤖 [application_android.go] androidApp.destroy() called")
+}
+
+func (a *androidApp) setIcon(_ []byte) {
+	// Android app icon is set through AndroidManifest.xml
+}
+
+func (a *androidApp) name() string {
+	return a.parent.options.Name
+}
+
+func (a *androidApp) GetFlags(options Options) map[string]any {
+	return nil
+}
+
+func (a *androidApp) getAccentColor() string {
+	return ""
+}
+
+func (a *androidApp) getCurrentWindowID() uint {
+	return 0
+}
+
+func (a *androidApp) hide() {
+	// Android manages app visibility
+}
+
+func (a *androidApp) isDarkMode() bool {
+	return a.parent.isDarkMode()
+}
+
+func (a *androidApp) on(_ uint) {
+	// Android event handling
+}
+
+func (a *androidApp) setApplicationMenu(_ *Menu) {
+	// Android doesn't have application menus in the same way
+}
+
+func (a *androidApp) show() {
+	// Android manages app visibility
+}
+
+func (a *androidApp) showAboutDialog(_ string, _ string, _ []byte) {
+	// TODO: Implement Android about dialog
+}
+
+func (a *androidApp) getPrimaryScreen() (*Screen, error) {
+	screens, err := getScreens()
+	if err != nil || len(screens) == 0 {
+		return nil, err
+	}
+	return screens[0], nil
+}
+
+func (a *androidApp) getScreens() ([]*Screen, error) {
+	return getScreens()
+}
+
+func (a *App) logPlatformInfo() {
+	// Log Android platform info
+	androidLogf("info", "Platform: Android")
+}
+
+func (a *App) platformEnvironment() map[string]any {
+	return map[string]any{
+		"platform": "android",
+	}
+}
+
+func fatalHandler(errFunc func(error)) {
+	// Android fatal handler
+}
+
+// Helper functions
+
+func serveAssetForAndroid(app *App, path string) ([]byte, error) {
+	// Normalize path
+	if path == "" || path == "/" {
+		path = "/index.html"
+	}
+
+	// TODO: Use the actual asset server to serve the file
+	// For now, return a placeholder
+	return nil, fmt.Errorf("asset serving not yet implemented: %s", path)
+}
+
+func handleMessageForAndroid(app *App, message string) string {
+	// Parse the message
+	var msg map[string]interface{}
+	if err := json.Unmarshal([]byte(message), &msg); err != nil {
+		return fmt.Sprintf(`{"error":"%s"}`, err.Error())
+	}
+
+	// TODO: Route to appropriate handler based on message type
+	// For now, return success
+	return `{"success":true}`
+}
+
+func getMimeTypeForPath(path string) string {
+	// Simple MIME type detection based on extension
+	switch {
+	case endsWith(path, ".html"), endsWith(path, ".htm"):
+		return "text/html"
+	case endsWith(path, ".js"), endsWith(path, ".mjs"):
+		return "application/javascript"
+	case endsWith(path, ".css"):
+		return "text/css"
+	case endsWith(path, ".json"):
+		return "application/json"
+	case endsWith(path, ".png"):
+		return "image/png"
+	case endsWith(path, ".jpg"), endsWith(path, ".jpeg"):
+		return "image/jpeg"
+	case endsWith(path, ".gif"):
+		return "image/gif"
+	case endsWith(path, ".svg"):
+		return "image/svg+xml"
+	case endsWith(path, ".ico"):
+		return "image/x-icon"
+	case endsWith(path, ".woff"):
+		return "font/woff"
+	case endsWith(path, ".woff2"):
+		return "font/woff2"
+	case endsWith(path, ".ttf"):
+		return "font/ttf"
+	default:
+		return "application/octet-stream"
+	}
+}
+
+func endsWith(s, suffix string) bool {
+	return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix
+}
+
+// executeJavaScript is a stub for non-cgo builds
+func executeJavaScript(js string) {
+	androidLogf("warn", "executeJavaScript called but cgo is not enabled")
+}
diff --git a/v3/pkg/application/application_linux.go b/v3/pkg/application/application_linux.go
index b92c2c6aa..0d204f184 100644
--- a/v3/pkg/application/application_linux.go
+++ b/v3/pkg/application/application_linux.go
@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && !android
 
 package application
 
diff --git a/v3/pkg/application/application_options.go b/v3/pkg/application/application_options.go
index 96668ae9d..84263761b 100644
--- a/v3/pkg/application/application_options.go
+++ b/v3/pkg/application/application_options.go
@@ -31,6 +31,9 @@ type Options struct {
 	// IOS is the iOS specific configuration for iOS builds
 	IOS IOSOptions
 
+	// Android is the Android specific configuration for Android builds
+	Android AndroidOptions
+
 	// Services allows you to bind Go methods to the frontend.
 	Services []Service
 
@@ -316,3 +319,26 @@ const (
     NativeTabIconList    NativeTabIcon = "list.bullet"
     NativeTabIconFolder  NativeTabIcon = "folder"
 )
+
+/********* Android Options *********/
+
+// AndroidOptions contains options for Android applications.
+type AndroidOptions struct {
+	// DisableScroll disables scrolling in the WebView
+	DisableScroll bool
+
+	// DisableBounce disables the overscroll bounce effect
+	DisableOverscroll bool
+
+	// EnableZoom allows pinch-to-zoom in the WebView (default: false)
+	EnableZoom bool
+
+	// UserAgent sets a custom user agent string
+	UserAgent string
+
+	// BackgroundColour sets the background colour of the WebView
+	BackgroundColour RGBA
+
+	// DisableHardwareAcceleration disables hardware acceleration for the WebView
+	DisableHardwareAcceleration bool
+}
diff --git a/v3/pkg/application/clipboard_android.go b/v3/pkg/application/clipboard_android.go
new file mode 100644
index 000000000..4c44eaa1f
--- /dev/null
+++ b/v3/pkg/application/clipboard_android.go
@@ -0,0 +1,35 @@
+//go:build android
+
+package application
+
+type androidClipboardImpl struct{}
+
+func newClipboardImpl() clipboardImpl {
+	return &androidClipboardImpl{}
+}
+
+func (c *androidClipboardImpl) setText(text string) bool {
+	// Android clipboard implementation would go here
+	// TODO: Implement via JNI to Android ClipboardManager
+	return true
+}
+
+func (c *androidClipboardImpl) text() (string, bool) {
+	// Android clipboard implementation would go here
+	// TODO: Implement via JNI to Android ClipboardManager
+	return "", false
+}
+
+// SetClipboardText sets the clipboard text on Android
+func (c *ClipboardManager) SetClipboardText(text string) error {
+	// Android clipboard implementation would go here
+	// For now, return nil as a placeholder
+	return nil
+}
+
+// GetClipboardText gets the clipboard text on Android
+func (c *ClipboardManager) GetClipboardText() (string, error) {
+	// Android clipboard implementation would go here
+	// For now, return empty string
+	return "", nil
+}
diff --git a/v3/pkg/application/clipboard_linux.go b/v3/pkg/application/clipboard_linux.go
index 1c662cd6f..97085260b 100644
--- a/v3/pkg/application/clipboard_linux.go
+++ b/v3/pkg/application/clipboard_linux.go
@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && !android
 
 package application
 
diff --git a/v3/pkg/application/dialogs_android.go b/v3/pkg/application/dialogs_android.go
new file mode 100644
index 000000000..a962dfba0
--- /dev/null
+++ b/v3/pkg/application/dialogs_android.go
@@ -0,0 +1,90 @@
+//go:build android
+
+package application
+
+// dialogsImpl implements dialogs for Android
+type dialogsImpl struct {
+	// Android-specific fields if needed
+}
+
+func newDialogsImpl() *dialogsImpl {
+	return &dialogsImpl{}
+}
+
+// Android dialog implementations would use AlertDialog
+// These are placeholder implementations for now
+
+func (d *dialogsImpl) info(id uint, param MessageDialogOptions) {
+	// TODO: Implement using AlertDialog
+}
+
+func (d *dialogsImpl) warning(id uint, param MessageDialogOptions) {
+	// TODO: Implement using AlertDialog
+}
+
+func (d *dialogsImpl) error(id uint, param MessageDialogOptions) {
+	// TODO: Implement using AlertDialog
+}
+
+func (d *dialogsImpl) question(id uint, param MessageDialogOptions) chan bool {
+	// TODO: Implement using AlertDialog
+	ch := make(chan bool, 1)
+	ch <- false
+	return ch
+}
+
+func (d *dialogsImpl) openFile(id uint, param OpenFileDialogOptions) chan string {
+	// TODO: Implement using Android file picker intent
+	ch := make(chan string, 1)
+	ch <- ""
+	return ch
+}
+
+func (d *dialogsImpl) openMultipleFiles(id uint, param OpenFileDialogOptions) chan []string {
+	// TODO: Implement using Android file picker intent
+	ch := make(chan []string, 1)
+	ch <- []string{}
+	return ch
+}
+
+func (d *dialogsImpl) openDirectory(id uint, param OpenFileDialogOptions) chan string {
+	// TODO: Implement using Android file picker intent
+	ch := make(chan string, 1)
+	ch <- ""
+	return ch
+}
+
+func (d *dialogsImpl) saveFile(id uint, param SaveFileDialogOptions) chan string {
+	// TODO: Implement using Android file picker intent
+	ch := make(chan string, 1)
+	ch <- ""
+	return ch
+}
+
+type androidDialog struct {
+	dialog *MessageDialog
+}
+
+func (d *androidDialog) show() {
+	// TODO: Implement using AlertDialog
+}
+
+func newDialogImpl(d *MessageDialog) *androidDialog {
+	return &androidDialog{
+		dialog: d,
+	}
+}
+
+func (d *dialogsImpl) show() (chan string, error) {
+	ch := make(chan string, 1)
+	ch <- ""
+	return ch, nil
+}
+
+func newOpenFileDialogImpl(_ *OpenFileDialogStruct) openFileDialogImpl {
+	return &dialogsImpl{}
+}
+
+func newSaveFileDialogImpl(_ *SaveFileDialogStruct) saveFileDialogImpl {
+	return &dialogsImpl{}
+}
diff --git a/v3/pkg/application/dialogs_linux.go b/v3/pkg/application/dialogs_linux.go
index 018547ce3..a64c3f83f 100644
--- a/v3/pkg/application/dialogs_linux.go
+++ b/v3/pkg/application/dialogs_linux.go
@@ -1,3 +1,5 @@
+//go:build linux && !android
+
 package application
 
 func (a *linuxApp) showAboutDialog(title string, message string, icon []byte) {
diff --git a/v3/pkg/application/events_common_android.go b/v3/pkg/application/events_common_android.go
new file mode 100644
index 000000000..b0aa0b912
--- /dev/null
+++ b/v3/pkg/application/events_common_android.go
@@ -0,0 +1,23 @@
+//go:build android
+
+package application
+
+import "github.com/wailsapp/wails/v3/pkg/events"
+
+// Map platform events → common events (same pattern as macOS & others)
+var commonApplicationEventMap = map[events.ApplicationEventType]events.ApplicationEventType{
+	events.Android.ActivityCreated: events.Common.ApplicationStarted,
+}
+
+// setupCommonEvents forwards Android platform events to their common counterparts
+func (a *androidApp) setupCommonEvents() {
+	for sourceEvent, targetEvent := range commonApplicationEventMap {
+		sourceEvent := sourceEvent
+		targetEvent := targetEvent
+		a.parent.Event.OnApplicationEvent(sourceEvent, func(event *ApplicationEvent) {
+			event.Id = uint(targetEvent)
+			androidLogf("info", "[events_common_android.go] Forwarding Android event %d → common %d", sourceEvent, targetEvent)
+			applicationEvents <- event
+		})
+	}
+}
diff --git a/v3/pkg/application/events_common_linux.go b/v3/pkg/application/events_common_linux.go
index d16232648..8fbbbaa57 100644
--- a/v3/pkg/application/events_common_linux.go
+++ b/v3/pkg/application/events_common_linux.go
@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && !android
 
 package application
 
diff --git a/v3/pkg/application/init_android.go b/v3/pkg/application/init_android.go
new file mode 100644
index 000000000..ac8b336bd
--- /dev/null
+++ b/v3/pkg/application/init_android.go
@@ -0,0 +1,13 @@
+//go:build android
+
+package application
+
+import "fmt"
+
+func init() {
+	fmt.Println("🤖 [init_android.go] START init()")
+	// On Android, we don't call runtime.LockOSThread()
+	// The Android runtime handles thread management via JNI
+	// and calling LockOSThread can interfere with the JNI environment
+	fmt.Println("🤖 [init_android.go] END init() - no LockOSThread on Android")
+}
diff --git a/v3/pkg/application/keys_android.go b/v3/pkg/application/keys_android.go
new file mode 100644
index 000000000..d63b07aa6
--- /dev/null
+++ b/v3/pkg/application/keys_android.go
@@ -0,0 +1,9 @@
+//go:build android
+
+package application
+
+// Android keyboard handling stub
+
+func acceleratorToString(accelerator *accelerator) string {
+	return ""
+}
diff --git a/v3/pkg/application/keys_linux.go b/v3/pkg/application/keys_linux.go
index e7b44e380..9ae8dd8bf 100644
--- a/v3/pkg/application/keys_linux.go
+++ b/v3/pkg/application/keys_linux.go
@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && !android
 
 package application
 
diff --git a/v3/pkg/application/linux_cgo.go b/v3/pkg/application/linux_cgo.go
index b1e4e2152..5f8b01a8e 100644
--- a/v3/pkg/application/linux_cgo.go
+++ b/v3/pkg/application/linux_cgo.go
@@ -1,4 +1,4 @@
-//go:build linux && cgo
+//go:build linux && cgo && !android
 
 package application
 
diff --git a/v3/pkg/application/mainthread_android.go b/v3/pkg/application/mainthread_android.go
new file mode 100644
index 000000000..c3f69a9ad
--- /dev/null
+++ b/v3/pkg/application/mainthread_android.go
@@ -0,0 +1,29 @@
+//go:build android
+
+package application
+
+import "fmt"
+
+// isOnMainThread returns whether the current goroutine is on the main thread
+func (a *androidApp) isOnMainThread() bool {
+	// On Android, Go runs in its own thread separate from the UI thread
+	// UI operations need to be dispatched via JNI to the main thread
+	return false
+}
+
+// dispatchOnMainThread executes a function on the Android main/UI thread
+func (a *androidApp) dispatchOnMainThread(id uint) {
+	fmt.Printf("🤖 [mainthread_android.go] dispatchOnMainThread(id=%d)\n", id)
+	// TODO: Implement via JNI callback to Activity.runOnUiThread()
+	// For now, execute the callback directly
+	mainThreadFunctionStoreLock.RLock()
+	fn := mainThreadFunctionStore[id]
+	if fn == nil {
+		mainThreadFunctionStoreLock.RUnlock()
+		fmt.Printf("🤖 [mainthread_android.go] ERROR: dispatchOnMainThread called with invalid id: %d\n", id)
+		return
+	}
+	delete(mainThreadFunctionStore, id)
+	mainThreadFunctionStoreLock.RUnlock()
+	fn()
+}
diff --git a/v3/pkg/application/mainthread_linux.go b/v3/pkg/application/mainthread_linux.go
index a718688bc..27873f840 100644
--- a/v3/pkg/application/mainthread_linux.go
+++ b/v3/pkg/application/mainthread_linux.go
@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && !android
 
 package application
 
diff --git a/v3/pkg/application/menu_android.go b/v3/pkg/application/menu_android.go
new file mode 100644
index 000000000..8bb4a48d1
--- /dev/null
+++ b/v3/pkg/application/menu_android.go
@@ -0,0 +1,26 @@
+//go:build android
+
+package application
+
+// Android menu stubs - Android doesn't have traditional application menus
+
+func (m *Menu) handleStyleChange() {}
+
+type androidMenu struct {
+	menu *Menu
+}
+
+func newMenuImpl(menu *Menu) *androidMenu {
+	return &androidMenu{
+		menu: menu,
+	}
+}
+
+func (m *androidMenu) update() {
+	// Android doesn't have traditional menus
+}
+
+func defaultApplicationMenu() *Menu {
+	// No application menu on Android
+	return nil
+}
diff --git a/v3/pkg/application/menu_linux.go b/v3/pkg/application/menu_linux.go
index b6235c2da..b47ad6dd0 100644
--- a/v3/pkg/application/menu_linux.go
+++ b/v3/pkg/application/menu_linux.go
@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && !android
 
 package application
 
diff --git a/v3/pkg/application/menuitem_android.go b/v3/pkg/application/menuitem_android.go
new file mode 100644
index 000000000..0c78d1cf8
--- /dev/null
+++ b/v3/pkg/application/menuitem_android.go
@@ -0,0 +1,24 @@
+//go:build android
+
+package application
+
+import "unsafe"
+
+// Android doesn't have traditional menu items like desktop platforms
+// These are placeholder implementations
+
+func (m *MenuItem) handleStyleChange() {}
+
+func (m *MenuItem) handleLabelChange() {}
+
+func (m *MenuItem) handleCheckedChange() {}
+
+func (m *MenuItem) handleEnabledChange() {}
+
+func (m *MenuItem) handleTooltipChange() {}
+
+func (m *MenuItem) handleSubmenuChange() {}
+
+func (m *MenuItem) nativeMenuItem() unsafe.Pointer {
+	return nil
+}
diff --git a/v3/pkg/application/menuitem_linux.go b/v3/pkg/application/menuitem_linux.go
index 68a3ddd4a..deaf5f973 100644
--- a/v3/pkg/application/menuitem_linux.go
+++ b/v3/pkg/application/menuitem_linux.go
@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && !android
 
 package application
 
diff --git a/v3/pkg/application/messageprocessor_android.go b/v3/pkg/application/messageprocessor_android.go
new file mode 100644
index 000000000..f35a7dd1b
--- /dev/null
+++ b/v3/pkg/application/messageprocessor_android.go
@@ -0,0 +1,74 @@
+//go:build android
+
+package application
+
+import (
+	"fmt"
+	"net/http"
+)
+
+const (
+	AndroidHapticsVibrate = 0
+	AndroidDeviceInfo     = 1
+	AndroidToast          = 2
+)
+
+var androidMethodNames = map[int]string{
+	AndroidHapticsVibrate: "Haptics.Vibrate",
+	AndroidDeviceInfo:     "Device.Info",
+	AndroidToast:          "Toast.Show",
+}
+
+func (m *MessageProcessor) processAndroidMethod(method int, rw http.ResponseWriter, r *http.Request, window Window, params QueryParams) {
+	switch method {
+	case AndroidHapticsVibrate:
+		args, _ := params.Args()
+		duration := 100 // default 100ms
+		if d := args.Int("duration"); d != nil {
+			duration = *d
+		}
+		androidHapticsVibrate(duration)
+		m.ok(rw)
+	case AndroidDeviceInfo:
+		m.json(rw, androidDeviceInfo())
+	case AndroidToast:
+		args, _ := params.Args()
+		message := ""
+		if s := args.String("message"); s != nil {
+			message = *s
+		}
+		androidShowToast(message)
+		m.ok(rw)
+	default:
+		m.httpError(rw, "Invalid Android call:", fmt.Errorf("unknown method: %d", method))
+		return
+	}
+
+	m.Info("Runtime call:", "method", "Android."+androidMethodNames[method])
+}
+
+// processIOSMethod is a stub on Android
+func (m *MessageProcessor) processIOSMethod(method int, rw http.ResponseWriter, r *http.Request, window Window, params QueryParams) {
+	m.httpError(rw, "iOS methods not available on Android:", fmt.Errorf("unknown method: %d", method))
+}
+
+// Android-specific runtime functions (stubs for now)
+
+func androidHapticsVibrate(durationMs int) {
+	// TODO: Implement via JNI to Android Vibrator service
+	androidLogf("debug", "Haptics vibrate: %dms", durationMs)
+}
+
+func androidDeviceInfo() map[string]interface{} {
+	// TODO: Implement via JNI to get actual device info
+	return map[string]interface{}{
+		"platform": "android",
+		"model":    "Unknown",
+		"version":  "Unknown",
+	}
+}
+
+func androidShowToast(message string) {
+	// TODO: Implement via JNI to Android Toast
+	androidLogf("debug", "Toast: %s", message)
+}
diff --git a/v3/pkg/application/messageprocessor_ios.go b/v3/pkg/application/messageprocessor_ios.go
index 77026a011..ad4bc1bf1 100644
--- a/v3/pkg/application/messageprocessor_ios.go
+++ b/v3/pkg/application/messageprocessor_ios.go
@@ -1,3 +1,5 @@
+//go:build ios
+
 package application
 
 import (
diff --git a/v3/pkg/application/messageprocessor_mobile_stub.go b/v3/pkg/application/messageprocessor_mobile_stub.go
new file mode 100644
index 000000000..5bc1100c4
--- /dev/null
+++ b/v3/pkg/application/messageprocessor_mobile_stub.go
@@ -0,0 +1,18 @@
+//go:build !ios && !android
+
+package application
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// processIOSMethod is a stub for non-mobile platforms
+func (m *MessageProcessor) processIOSMethod(method int, rw http.ResponseWriter, r *http.Request, window Window, params QueryParams) {
+	m.httpError(rw, "iOS methods not available:", fmt.Errorf("unknown method: %d", method))
+}
+
+// processAndroidMethod is a stub for non-mobile platforms
+func (m *MessageProcessor) processAndroidMethod(method int, rw http.ResponseWriter, r *http.Request, window Window, params QueryParams) {
+	m.httpError(rw, "Android methods not available:", fmt.Errorf("unknown method: %d", method))
+}
diff --git a/v3/pkg/application/screen_android.go b/v3/pkg/application/screen_android.go
new file mode 100644
index 000000000..03f03f280
--- /dev/null
+++ b/v3/pkg/application/screen_android.go
@@ -0,0 +1,32 @@
+//go:build android
+
+package application
+
+// getScreens returns the available screens for Android
+func getScreens() ([]*Screen, error) {
+	// Android typically has one main display
+	// TODO: Support for multi-display via DisplayManager
+	return []*Screen{
+		{
+			ID:        "main",
+			Name:      "Main Display",
+			IsPrimary: true,
+			Size: Size{
+				Width:  1080,
+				Height: 2400,
+			},
+			Bounds: Rect{
+				X:      0,
+				Y:      0,
+				Width:  1080,
+				Height: 2400,
+			},
+			WorkArea: Rect{
+				X:      0,
+				Y:      0,
+				Width:  1080,
+				Height: 2340, // Minus navigation bar
+			},
+		},
+	}, nil
+}
diff --git a/v3/pkg/application/screen_linux.go b/v3/pkg/application/screen_linux.go
index f6dfdf59d..250da29a5 100644
--- a/v3/pkg/application/screen_linux.go
+++ b/v3/pkg/application/screen_linux.go
@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && !android
 
 package application
 
diff --git a/v3/pkg/application/signal_handler_android.go b/v3/pkg/application/signal_handler_android.go
new file mode 100644
index 000000000..61c8a297c
--- /dev/null
+++ b/v3/pkg/application/signal_handler_android.go
@@ -0,0 +1,19 @@
+//go:build android
+
+package application
+
+import (
+	"os"
+)
+
+// setupSignalHandler sets up signal handling for Android
+// On Android, we don't handle Unix signals directly as the app lifecycle
+// is managed by the Android runtime
+func setupSignalHandler() {
+	// No-op on Android - lifecycle managed by Android framework
+}
+
+// handleSignal processes a signal
+func handleSignal(_ os.Signal) {
+	// No-op on Android
+}
diff --git a/v3/pkg/application/signal_handler_types_android.go b/v3/pkg/application/signal_handler_types_android.go
new file mode 100644
index 000000000..ed5835c20
--- /dev/null
+++ b/v3/pkg/application/signal_handler_types_android.go
@@ -0,0 +1,8 @@
+//go:build android
+
+package application
+
+import "os"
+
+// signalType is a placeholder type for Android where signals are not used
+type signalType = os.Signal
diff --git a/v3/pkg/application/single_instance_android.go b/v3/pkg/application/single_instance_android.go
new file mode 100644
index 000000000..e08cbc172
--- /dev/null
+++ b/v3/pkg/application/single_instance_android.go
@@ -0,0 +1,33 @@
+//go:build android
+
+package application
+
+// setupSingleInstance sets up single instance on Android
+func (a *App) setupSingleInstance() error {
+	// Android apps handle single instance via launch mode in manifest
+	return nil
+}
+
+type androidLock struct {
+	manager *singleInstanceManager
+}
+
+func newPlatformLock(manager *singleInstanceManager) (platformLock, error) {
+	return &androidLock{
+		manager: manager,
+	}, nil
+}
+
+func (l *androidLock) acquire(uniqueID string) error {
+	// Android apps handle single instance via launch mode in manifest
+	return nil
+}
+
+func (l *androidLock) release() {
+	// Android apps handle single instance via launch mode in manifest
+}
+
+func (l *androidLock) notify(data string) error {
+	// Android apps handle single instance via launch mode in manifest
+	return nil
+}
diff --git a/v3/pkg/application/single_instance_linux.go b/v3/pkg/application/single_instance_linux.go
index 28c9e5483..7078b9ced 100644
--- a/v3/pkg/application/single_instance_linux.go
+++ b/v3/pkg/application/single_instance_linux.go
@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && !android
 
 package application
 
diff --git a/v3/pkg/application/systemtray_android.go b/v3/pkg/application/systemtray_android.go
new file mode 100644
index 000000000..489a58853
--- /dev/null
+++ b/v3/pkg/application/systemtray_android.go
@@ -0,0 +1,102 @@
+//go:build android
+
+package application
+
+// Android doesn't have system tray support
+// These are placeholder implementations
+
+func (t *SystemTray) update() {}
+
+func (t *SystemTray) setMenu(menu *Menu) {
+	// Android doesn't have system tray
+}
+
+func (t *SystemTray) close() {
+	// Android doesn't have system tray
+}
+
+func (t *SystemTray) attachWindow(window *WebviewWindow) {
+	// Android doesn't have system tray
+}
+
+func (t *SystemTray) detachWindow(windowID uint) {
+	// Android doesn't have system tray
+}
+
+type androidSystemTray struct {
+	parent *SystemTray
+}
+
+func newSystemTrayImpl(s *SystemTray) systemTrayImpl {
+	return &androidSystemTray{
+		parent: s,
+	}
+}
+
+func (s *androidSystemTray) run() {
+	// Android doesn't have system tray
+}
+
+func (s *androidSystemTray) setLabel(_ string) {
+	// Android doesn't have system tray
+}
+
+func (s *androidSystemTray) setMenu(_ *Menu) {
+	// Android doesn't have system tray
+}
+
+func (s *androidSystemTray) setIcon(_ []byte) {
+	// Android doesn't have system tray
+}
+
+func (s *androidSystemTray) setDarkModeIcon(_ []byte) {
+	// Android doesn't have system tray
+}
+
+func (s *androidSystemTray) destroy() {
+	// Android doesn't have system tray
+}
+
+func (s *androidSystemTray) setIconPosition(_ IconPosition) {
+	// Android doesn't have system tray
+}
+
+func (s *androidSystemTray) positionWindow(_ Window, _ int) error {
+	return nil
+}
+
+func (s *androidSystemTray) detachWindowPositioning(_ uint) {
+	// Android doesn't have system tray
+}
+
+func (s *androidSystemTray) setTemplateIcon(_ []byte) {
+	// Android doesn't have system tray
+}
+
+func (s *androidSystemTray) openMenu() {
+	// Android doesn't have system tray
+}
+
+func (s *androidSystemTray) setTooltip(_ string) {
+	// Android doesn't have system tray
+}
+
+func (s *androidSystemTray) bounds() (*Rect, error) {
+	return nil, nil
+}
+
+func (s *androidSystemTray) getScreen() (*Screen, error) {
+	screens, err := getScreens()
+	if err != nil || len(screens) == 0 {
+		return nil, err
+	}
+	return screens[0], nil
+}
+
+func (s *androidSystemTray) Show() {
+	// Android doesn't have system tray
+}
+
+func (s *androidSystemTray) Hide() {
+	// Android doesn't have system tray
+}
diff --git a/v3/pkg/application/systemtray_linux.go b/v3/pkg/application/systemtray_linux.go
index ea139b636..a51b917bb 100644
--- a/v3/pkg/application/systemtray_linux.go
+++ b/v3/pkg/application/systemtray_linux.go
@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && !android
 
 /*
 Portions of this code are derived from the project:
diff --git a/v3/pkg/application/webview_window_android.go b/v3/pkg/application/webview_window_android.go
new file mode 100644
index 000000000..ed41a5add
--- /dev/null
+++ b/v3/pkg/application/webview_window_android.go
@@ -0,0 +1,364 @@
+//go:build android
+
+package application
+
+import "unsafe"
+
+// androidWebviewWindow implements the webviewWindowImpl interface for Android
+type androidWebviewWindow struct {
+	windowID uint32 // Wails window ID for tracking
+	parent   *WebviewWindow
+}
+
+func newWindowImpl(parent *WebviewWindow) *androidWebviewWindow {
+	return &androidWebviewWindow{
+		parent: parent,
+	}
+}
+
+func (w *androidWebviewWindow) center() {}
+
+func (w *androidWebviewWindow) close() {}
+
+func (w *androidWebviewWindow) destroy() {
+	w.parent.markAsDestroyed()
+}
+
+func (w *androidWebviewWindow) execJS(js string) {
+	// Execute JavaScript via JNI callback to Java's WailsBridge.executeJavaScript()
+	androidLogf("debug", "execJS: %s", js)
+	executeJavaScript(js)
+}
+
+func (w *androidWebviewWindow) flash(_ bool) {}
+
+func (w *androidWebviewWindow) focus() {}
+
+func (w *androidWebviewWindow) forceReload() {}
+
+func (w *androidWebviewWindow) fullscreen() {}
+
+func (w *androidWebviewWindow) getScreen() (*Screen, error) {
+	// Android has a single "screen" (the device display)
+	return &Screen{
+		ID:        "main",
+		Name:      "Main Display",
+		IsPrimary: true,
+	}, nil
+}
+
+func (w *androidWebviewWindow) getZoom() float64 {
+	return 1.0
+}
+
+func (w *androidWebviewWindow) handleDragAndDropMessage(_ string) {}
+
+func (w *androidWebviewWindow) hasParent() bool {
+	return false
+}
+
+func (w *androidWebviewWindow) height() int {
+	return 2400 // Default Android height (common flagship)
+}
+
+func (w *androidWebviewWindow) hide() {}
+
+func (w *androidWebviewWindow) isAlwaysOnTop() bool {
+	return false
+}
+
+func (w *androidWebviewWindow) isCloseRequested() bool {
+	return false
+}
+
+func (w *androidWebviewWindow) setCloseRequested(_ bool) {}
+
+func (w *androidWebviewWindow) isFocused() bool {
+	return true
+}
+
+func (w *androidWebviewWindow) isFullscreen() bool {
+	return true // Android apps are typically fullscreen
+}
+
+func (w *androidWebviewWindow) isMaximised() bool {
+	return true
+}
+
+func (w *androidWebviewWindow) isMinimised() bool {
+	return false
+}
+
+func (w *androidWebviewWindow) isNormal() bool {
+	return false
+}
+
+func (w *androidWebviewWindow) isVisible() bool {
+	return true
+}
+
+func (w *androidWebviewWindow) maximise() {}
+
+func (w *androidWebviewWindow) minimise() {}
+
+func (w *androidWebviewWindow) openContextMenu(_ *Menu, _ *ContextMenuData) {}
+
+func (w *androidWebviewWindow) openDevTools() {}
+
+func (w *androidWebviewWindow) print() error {
+	return nil
+}
+
+func (w *androidWebviewWindow) reload() {}
+
+func (w *androidWebviewWindow) relativePosition() (int, int) {
+	return 0, 0
+}
+
+func (w *androidWebviewWindow) resizable() bool {
+	return false
+}
+
+func (w *androidWebviewWindow) restore() {}
+
+func (w *androidWebviewWindow) setAbsolutePosition(_ int, _ int) {}
+
+func (w *androidWebviewWindow) setAlwaysOnTop(_ bool) {}
+
+func (w *androidWebviewWindow) setBackgroundColour(col RGBA) {
+	// TODO: Send background colour to Java via JNI
+	androidLogf("debug", "setBackgroundColour: rgba(%d,%d,%d,%d)", col.Red, col.Green, col.Blue, col.Alpha)
+}
+
+func (w *androidWebviewWindow) setEnabled(_ bool) {}
+
+func (w *androidWebviewWindow) setFrameless(_ bool) {}
+
+func (w *androidWebviewWindow) setFullscreenButtonEnabled(_ bool) {}
+
+func (w *androidWebviewWindow) setMaxSize(_ int, _ int) {}
+
+func (w *androidWebviewWindow) setMinSize(_ int, _ int) {}
+
+func (w *androidWebviewWindow) setRelativePosition(_ int, _ int) {}
+
+func (w *androidWebviewWindow) setResizable(_ bool) {}
+
+func (w *androidWebviewWindow) setSize(_ int, _ int) {}
+
+func (w *androidWebviewWindow) setTitle(_ string) {}
+
+func (w *androidWebviewWindow) setZoom(_ float64) {}
+
+func (w *androidWebviewWindow) show() {}
+
+func (w *androidWebviewWindow) size() (int, int) {
+	return 1080, 2400 // Default Android size (common flagship)
+}
+
+func (w *androidWebviewWindow) toggleDevTools() {}
+
+func (w *androidWebviewWindow) unfullscreen() {}
+
+func (w *androidWebviewWindow) unmaximise() {}
+
+func (w *androidWebviewWindow) unminimise() {}
+
+func (w *androidWebviewWindow) width() int {
+	return 1080 // Default Android width
+}
+
+func (w *androidWebviewWindow) zoom() {}
+
+func (w *androidWebviewWindow) zoomIn() {}
+
+func (w *androidWebviewWindow) zoomOut() {}
+
+func (w *androidWebviewWindow) zoomReset() {}
+
+func (w *androidWebviewWindow) setParent(_ *WebviewWindow) error {
+	return nil
+}
+
+func (w *androidWebviewWindow) run() {
+	androidLogf("info", "androidWebviewWindow.run() called")
+	// Android WebView is created and managed by the Java Activity
+	// Just store the window ID for reference
+	w.windowID = uint32(w.parent.ID())
+}
+
+func (w *androidWebviewWindow) setIgnoreMouseEvents(_ bool) {}
+
+func (w *androidWebviewWindow) setOpacity(_ float32) {}
+
+func (w *androidWebviewWindow) setTheme(_ Theme) {}
+
+func (w *androidWebviewWindow) setPinned(_ bool) {}
+
+func (w *androidWebviewWindow) startResize(_ string) error {
+	return nil
+}
+
+func (w *androidWebviewWindow) startDrag() error {
+	return nil
+}
+
+func (w *androidWebviewWindow) enableDevTools() {}
+
+func (w *androidWebviewWindow) disableContextMenu() {}
+
+func (w *androidWebviewWindow) disableDefaultContextMenu() {}
+
+func (w *androidWebviewWindow) setShouldClose(_ func() bool) {}
+
+func (w *androidWebviewWindow) absolutePosition() (int, int) {
+	return 0, 0
+}
+
+func (w *androidWebviewWindow) startMove() {}
+
+func (w *androidWebviewWindow) windowMenu() *Menu {
+	return nil
+}
+
+func (w *androidWebviewWindow) setWindowMenu(_ *Menu) {}
+
+func (w *androidWebviewWindow) isIgnoreMouseEvents() bool {
+	return false
+}
+
+func (w *androidWebviewWindow) flashCancel() {}
+
+func (w *androidWebviewWindow) setFocusable(_ bool) {}
+
+func (w *androidWebviewWindow) bounds() Rect {
+	return Rect{
+		X:      0,
+		Y:      0,
+		Width:  1080,
+		Height: 2400,
+	}
+}
+
+func (w *androidWebviewWindow) copy() {
+	// Android copy implementation
+}
+
+func (w *androidWebviewWindow) cut() {
+	// Android cut implementation
+}
+
+func (w *androidWebviewWindow) paste() {
+	// Android paste implementation
+}
+
+func (w *androidWebviewWindow) selectAll() {
+	// Android select all implementation
+}
+
+func (w *androidWebviewWindow) undo() {
+	// Android undo implementation
+}
+
+func (w *androidWebviewWindow) redo() {
+	// Android redo implementation
+}
+
+func (w *androidWebviewWindow) delete() {
+	// Android delete implementation
+}
+
+func (w *androidWebviewWindow) getBorderSizes() *LRTB {
+	return &LRTB{}
+}
+
+func (w *androidWebviewWindow) handleKeyEvent(acceleratorString string) {
+	// Android handle key event
+}
+
+func (w *androidWebviewWindow) hideMenuBar() {
+	// Android doesn't have menu bar
+}
+
+func (w *androidWebviewWindow) unhideMenuBar() {
+	// Android doesn't have menu bar
+}
+
+func (w *androidWebviewWindow) toggleMenuBar() {
+	// Android doesn't have menu bar
+}
+
+func (w *androidWebviewWindow) isMenuBarHidden() bool {
+	return true // Android doesn't have menu bar
+}
+
+func (w *androidWebviewWindow) nativeWindow() unsafe.Pointer {
+	return nil
+}
+
+func (w *androidWebviewWindow) on(eventID uint) {
+	// Android event handling
+}
+
+func (w *androidWebviewWindow) position() (int, int) {
+	return 0, 0
+}
+
+func (w *androidWebviewWindow) physicalBounds() Rect {
+	return Rect{
+		X:      0,
+		Y:      0,
+		Width:  1080,
+		Height: 2400,
+	}
+}
+
+func (w *androidWebviewWindow) setBounds(bounds Rect) {
+	// Android set bounds - not applicable on mobile
+}
+
+func (w *androidWebviewWindow) setMinimiseButtonState(_ ButtonState) {
+	// Android doesn't have minimize buttons like desktop platforms
+}
+
+func (w *androidWebviewWindow) setMaximiseButtonState(_ ButtonState) {
+	// Android doesn't have maximize buttons like desktop platforms
+}
+
+func (w *androidWebviewWindow) setCloseButtonState(_ ButtonState) {
+	// Android doesn't have close buttons like desktop platforms
+}
+
+func (w *androidWebviewWindow) setContentProtection(_ bool) {
+	// Android content protection - could be implemented with FLAG_SECURE
+}
+
+func (w *androidWebviewWindow) setHTML(html string) {
+	// TODO: Implement via JNI
+	androidLogf("debug", "setHTML called")
+}
+
+func (w *androidWebviewWindow) setMenu(_ *Menu) {
+	// Android doesn't support window menus like desktop platforms
+}
+
+func (w *androidWebviewWindow) setPhysicalBounds(_ Rect) {
+	// Android doesn't support arbitrary window bounds - apps are fullscreen
+}
+
+func (w *androidWebviewWindow) setPosition(_ int, _ int) {
+	// Android doesn't support window positioning - apps are fullscreen
+}
+
+func (w *androidWebviewWindow) setURL(url string) {
+	// TODO: Implement via JNI
+	androidLogf("debug", "setURL: %s", url)
+}
+
+func (w *androidWebviewWindow) showMenuBar() {
+	// Android doesn't have menu bars like desktop platforms
+}
+
+func (w *androidWebviewWindow) snapAssist() {
+	// Android doesn't support window snap assist like Windows
+}
diff --git a/v3/pkg/application/webview_window_linux.go b/v3/pkg/application/webview_window_linux.go
index 7f82f8b84..9041a8311 100644
--- a/v3/pkg/application/webview_window_linux.go
+++ b/v3/pkg/application/webview_window_linux.go
@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && !android
 
 package application
 
diff --git a/v3/pkg/application/webview_window_linux_dev.go b/v3/pkg/application/webview_window_linux_dev.go
index 3f34a6e64..65ba83132 100644
--- a/v3/pkg/application/webview_window_linux_dev.go
+++ b/v3/pkg/application/webview_window_linux_dev.go
@@ -1,4 +1,4 @@
-//go:build linux && !production
+//go:build linux && !production && !android
 
 package application
 
diff --git a/v3/pkg/application/webview_window_linux_production.go b/v3/pkg/application/webview_window_linux_production.go
index c65520b8e..5011ad035 100644
--- a/v3/pkg/application/webview_window_linux_production.go
+++ b/v3/pkg/application/webview_window_linux_production.go
@@ -1,4 +1,4 @@
-//go:build linux && production && !devtools
+//go:build linux && production && !devtools && !android
 
 package application
 
diff --git a/v3/pkg/events/events.go b/v3/pkg/events/events.go
index 34e131e85..1bfae55f1 100644
--- a/v3/pkg/events/events.go
+++ b/v3/pkg/events/events.go
@@ -465,7 +465,41 @@ func newWindowsEvents() windowsEvents {
 	}
 }
 
-var IOS = newIOSEvents()
+var Android = newAndroidEvents()
+
+type androidEvents struct {
+	ActivityCreated             ApplicationEventType
+	ActivityStarted             ApplicationEventType
+	ActivityResumed             ApplicationEventType
+	ActivityPaused              ApplicationEventType
+	ActivityStopped             ApplicationEventType
+	ActivityDestroyed           ApplicationEventType
+	ApplicationLowMemory        ApplicationEventType
+	ApplicationConfigChanged    ApplicationEventType
+	WebViewDidStartNavigation   WindowEventType
+	WebViewDidFinishNavigation  WindowEventType
+	WebViewDidFailNavigation    WindowEventType
+	WebViewReceivedError        WindowEventType
+}
+
+func newAndroidEvents() androidEvents {
+	return androidEvents{
+		ActivityCreated:             1257,
+		ActivityStarted:             1258,
+		ActivityResumed:             1259,
+		ActivityPaused:              1260,
+		ActivityStopped:             1261,
+		ActivityDestroyed:           1262,
+		ApplicationLowMemory:        1263,
+		ApplicationConfigChanged:    1264,
+		WebViewDidStartNavigation:   1265,
+		WebViewDidFinishNavigation:  1266,
+		WebViewDidFailNavigation:    1267,
+		WebViewReceivedError:        1268,
+	}
+}
+
+var iOS = newIOSEvents()
 
 type iosEvents struct {
 	ApplicationDidBecomeActive             ApplicationEventType
@@ -757,4 +791,16 @@ var eventToJS = map[uint]string{
 	1254: "ios:WebViewDidFinishNavigation",
 	1255: "ios:WebViewDidFailNavigation",
 	1256: "ios:WebViewDecidePolicyForNavigationAction",
+	1257: "android:ActivityCreated",
+	1258: "android:ActivityStarted",
+	1259: "android:ActivityResumed",
+	1260: "android:ActivityPaused",
+	1261: "android:ActivityStopped",
+	1262: "android:ActivityDestroyed",
+	1263: "android:ApplicationLowMemory",
+	1264: "android:ApplicationConfigChanged",
+	1265: "android:WebViewDidStartNavigation",
+	1266: "android:WebViewDidFinishNavigation",
+	1267: "android:WebViewDidFailNavigation",
+	1268: "android:WebViewReceivedError",
 }
diff --git a/v3/pkg/events/events_android.go b/v3/pkg/events/events_android.go
new file mode 100644
index 000000000..c4b354641
--- /dev/null
+++ b/v3/pkg/events/events_android.go
@@ -0,0 +1,22 @@
+//go:build android
+
+package events
+
+// Android events implementation
+
+const MAX_EVENTS = 100
+
+var hasListener [MAX_EVENTS]bool
+
+func registerListener(event uint) {
+	if event < MAX_EVENTS {
+		hasListener[event] = true
+	}
+}
+
+func hasListeners(event uint) bool {
+	if event < MAX_EVENTS {
+		return hasListener[event]
+	}
+	return false
+}