@quan-erp/shared-frontend-core 1.0.0

package/dist/index.js

@@ -0,0 +1,2921 @@
+import { Camera as Camera$1, CameraResultType, CameraSource } from '@capacitor/camera';
+import { Device as Device$1 } from '@capacitor/device';
+import { LocalNotifications } from '@capacitor/local-notifications';
+import { Filesystem, Directory } from '@capacitor/filesystem';
+import { SQLiteConnection, CapacitorSQLite } from '@capacitor-community/sqlite';
+import { Geolocation } from '@capacitor/geolocation';
+import { Network as Network$1 } from '@capacitor/network';
+import { BleClient } from '@capacitor-community/bluetooth-le';
+import { Clipboard as Clipboard$1 } from '@capacitor/clipboard';
+import { Haptics, ImpactStyle, NotificationType } from '@capacitor/haptics';
+import { WebHaptics } from 'web-haptics';
+import { ScreenOrientation } from '@awesome-cordova-plugins/screen-orientation';
+import FingerprintJS from '@fingerprintjs/fingerprintjs';
+
+const browserOrignalNavigator = window.navigator;
+const browserOriginalLocalStorage = window.localStorage;
+// Freeze the original originalNavigator to prevent tampering
+Object.defineProperty(window, 'navigator', {
+    get: () => {
+        console.warn('Access to originalNavigator is blocked. Use the provided API.');
+        return browserOrignalNavigator;
+    },
+    configurable: false,
+    enumerable: true,
+});
+Object.defineProperty(window, 'localStorage', {
+    get: () => {
+        console.warn('Access to originalNavigator is blocked. Use the provided API.');
+        return browserOriginalLocalStorage;
+    },
+    configurable: false,
+    enumerable: true,
+});
+
+/**
+ * Utility service to identify the active application shell context (Desktop, Mobile, or Web).
+ * Used for dynamic feature detection and directing API requests to Capacitor, Electron, or browser-native APIs.
+ */
+class Platforms {
+    /**
+     * Determines if the application is running inside an Electron desktop window context.
+     * Checks if the `electron` IPC bridge object has been injected into the global `window` scope.
+     *
+     * @returns `true` if executed in an Electron shell environment, `false` otherwise.
+     */
+    static isDesktop() {
+        return typeof window !== "undefined" && typeof window?.electron !== "undefined";
+    }
+    /**
+     * Determines if the application is running as a native mobile application (Android/iOS).
+     * Inspects the global Capacitor plugin bridge interface properties.
+     *
+     * @returns `true` if executed within a native mobile app container, `false` otherwise.
+     */
+    static isMobile() {
+        const Capacitor = window.Capacitor;
+        return typeof Capacitor !== "undefined" && Capacitor.isNativePlatform();
+    }
+    /**
+     * Determines if the application is running in a traditional web browser environment.
+     * Checks that neither Electron desktop bindings nor Capacitor native app plugins are initialized.
+     *
+     * @returns `true` if running strictly on a standard web page, `false` otherwise.
+     */
+    static isWeb() {
+        return !this.isDesktop() && !this.isMobile();
+    }
+}
+
+class CapacitorCamera {
+    videoEl;
+    stream;
+    async requestPermission() {
+        try {
+            const status = await Camera$1.checkPermissions();
+            if (status.camera === 'granted')
+                return true;
+            // request permission if not granted
+            const request = await Camera$1.requestPermissions({ permissions: ['camera'] });
+            return request.camera === 'granted';
+        }
+        catch (err) {
+            console.warn('Camera permission denied:', err);
+            return false;
+        }
+    }
+    async takePicture() {
+        const result = await Camera$1.getPhoto({
+            quality: 80,
+            resultType: CameraResultType.DataUrl
+        });
+        return result.dataUrl;
+    }
+    async startPreview(videoElement) {
+        this.videoEl = videoElement;
+        console.log(this.videoEl);
+        console.log(browserOrignalNavigator);
+        const info = await Device$1.getInfo();
+        console.log('WebView version:', info.webViewVersion);
+        console.log('medias', browserOrignalNavigator.mediaDevices);
+        try {
+            this.stream = await browserOrignalNavigator.mediaDevices.getUserMedia({ video: { facingMode: "environment" } });
+            this.videoEl.srcObject = this.stream;
+            await this.videoEl.play();
+        }
+        catch (err) {
+            console.error("Failed to start camera preview:", err);
+        }
+    }
+    stopPreview() {
+        if (this.stream) {
+            this.stream.getTracks().forEach(track => track.stop());
+            this.stream = undefined;
+        }
+        if (this.videoEl) {
+            this.videoEl.pause();
+            this.videoEl.srcObject = null;
+        }
+    }
+    async pickImageFromGallery({ resultType = CameraResultType.Uri }) {
+        const result = await Camera$1.getPhoto({
+            quality: 80,
+            resultType: resultType, // or Uri
+            source: CameraSource.Photos // <-- gallery
+        });
+        return result.dataUrl;
+    }
+    pickVideoFromGallery() {
+        // TODO: ADD SUPPORT FOR pick from gallery
+        throw new Error("no support yet");
+    }
+}
+class WebCamera {
+    stream;
+    videoEl;
+    async takePicture() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const stream = await browserOrignalNavigator.mediaDevices.getUserMedia({ video: true });
+                const track = stream.getVideoTracks()[0];
+                const imageCapture = new ImageCapture(track);
+                const blob = await imageCapture.takePhoto();
+                const reader = new FileReader();
+                reader.onloadend = () => resolve(reader.result);
+                reader.readAsDataURL(blob);
+                track.stop();
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    async startPreview(videoElement) {
+        this.videoEl = videoElement;
+        this.stream = await browserOrignalNavigator.mediaDevices.getUserMedia({ video: true });
+        videoElement.srcObject = this.stream;
+        await videoElement.play();
+    }
+    stopPreview() {
+        if (this.stream) {
+            this.stream.getTracks().forEach(track => track.stop());
+            this.stream = undefined;
+        }
+        if (this.videoEl) {
+            this.videoEl.pause();
+            this.videoEl.srcObject = null;
+        }
+    }
+    async requestPermission() {
+        try {
+            // This must be triggered by a user gesture (click)
+            const stream = await browserOrignalNavigator.mediaDevices.getUserMedia({ video: true });
+            // immediately stop the stream; we just wanted permission
+            stream.getTracks().forEach(track => track.stop());
+            return true;
+        }
+        catch (err) {
+            console.warn("Camera permission denied:", err);
+            return false;
+        }
+    }
+    pickImageFromGallery({ resultType }) {
+        // TODO: ADD SUPPORT FOR pick from gallery
+        throw new Error("no support yet");
+    }
+    pickVideoFromGallery() {
+        // TODO: ADD SUPPORT FOR pick from gallery
+        throw new Error("no support yet");
+    }
+}
+class ElectronCamera extends WebCamera {
+}
+/**
+ * Cross-platform Camera tracking utility that delegates permission requests, image capturing,
+ * live video element previews, and photo/video gallery selection to Capacitor Camera,
+ * Electron, or HTML5 MediaStream APIs depending on the active platform.
+ */
+class Camera {
+    static _instance;
+    impl;
+    // Private constructor to prevent direct instantiation
+    constructor() {
+        if (Platforms.isMobile()) {
+            this.impl = new CapacitorCamera();
+        }
+        else if (Platforms.isDesktop()) {
+            this.impl = new ElectronCamera();
+        }
+        else {
+            this.impl = new WebCamera();
+        }
+    }
+    /**
+     * Singleton instance of the Camera utility.
+     */
+    static get instance() {
+        if (!this._instance) {
+            this._instance = new Camera();
+        }
+        return this._instance;
+    }
+    /**
+     * Checks and requests permission to access the camera hardware.
+     * @returns A promise resolving to true if access was successfully granted.
+     */
+    requestPermission() {
+        return this.impl.requestPermission();
+    }
+    /**
+     * Captures a single image using the device camera.
+     * @returns A promise resolving to the picture data encoded as a Base64 string or file URL.
+     */
+    takePicture() {
+        return this.impl.takePicture();
+    }
+    /**
+     * Binds a real-time camera stream to a given HTMLVideoElement for a custom camera preview layout.
+     * @param videoElement The HTML5 Video element to bind the streaming media tracks to.
+     */
+    startPreview(videoElement) {
+        return this.impl.startPreview(videoElement);
+    }
+    /**
+     * Disconnects and releases the active camera streams, stopping the custom preview window.
+     */
+    stopPreview() {
+        this.impl.stopPreview();
+    }
+    /**
+     * Triggers the platform's image picker to select a photo from the local photo gallery.
+     * @param options Target result layout configurations.
+     * @returns A promise resolving to the chosen image's Base64 data or URI path.
+     */
+    pickImageFromGallery(options) {
+        return this.impl.pickImageFromGallery(options);
+    }
+    /**
+     * Triggers the platform's video picker to select a video file from the local library.
+     * @returns A promise resolving to the chosen video's file path or URL.
+     */
+    pickVideoFromGallery() {
+        return this.impl.pickVideoFromGallery();
+    }
+}
+
+// notifications.ts
+/**
+ * Capacitor-specific implementation of INotifications for mobile platforms (Android/iOS).
+ * Uses `@capacitor/local-notifications` to schedule push-like local system notifications.
+ */
+class CapacitorNotifications {
+    permissionGranted = false;
+    channelCreated = false;
+    /**
+     * Requests notification permissions from the Capacitor local notification manager.
+     * @returns A promise resolving to `true` if display permissions are granted, `false` otherwise.
+     */
+    async requestPermission() {
+        try {
+            const status = await LocalNotifications.requestPermissions();
+            this.permissionGranted = status.display === 'granted';
+            return this.permissionGranted;
+        }
+        catch (err) {
+            console.error('Capacitor local notification permission error:', err);
+            return false;
+        }
+    }
+    /**
+     * Sends a local notification on mobile platforms.
+     * Automatically registers a default notification channel if not already created.
+     * @param title The notification title.
+     * @param options Additional options containing body string and custom channel ID.
+     */
+    async sendNotification(title, options) {
+        if (!this.permissionGranted) {
+            console.warn('Notifications permission not granted');
+            return;
+        }
+        if (!this.channelCreated) {
+            console.log('create notification channel');
+            await LocalNotifications.createChannel({
+                id: 'default',
+                name: 'Default Channel',
+                importance: 5, // max importance
+                sound: 'default',
+                visibility: 1, // public
+            });
+            this.channelCreated = true;
+        }
+        console.log('scheduled');
+        await LocalNotifications.schedule({
+            notifications: [
+                {
+                    title,
+                    body: options?.body || '',
+                    id: options?.id ?? (new Date().getTime() % 2147483647), // unique ID
+                    schedule: { at: new Date(Date.now() + 1000) }, // slight delay to show immediately
+                    // sound: 'default',
+                    smallIcon: 'ic_stat_icon',
+                    channelId: 'default',
+                },
+            ],
+        });
+        console.log('permission pushed');
+    }
+}
+/**
+ * Electron-specific notification implementation for desktop environments.
+ * Delegates to the default system-level Chromium Notification API.
+ */
+class ElectronNotifications {
+    /**
+     * Requests notification permission. Electron apps usually have notification rights by default.
+     * @returns A promise resolving to `true`.
+     */
+    async requestPermission() {
+        return true; // Electron notifications are usually allowed by default
+    }
+    /**
+     * Triggers a desktop notification using Chromium's HTML5 Notification API.
+     * @param title The title of the desktop notification.
+     * @param options Options containing the body of the notification.
+     */
+    async sendNotification(title, options) {
+        try {
+            new Notification(title, { body: options?.body });
+        }
+        catch (err) {
+            console.error('Electron notification error:', err);
+        }
+    }
+}
+/**
+ * Standard browser/web notification implementation.
+ * Wraps browser-native HTML5 Web Notification API.
+ */
+class WebNotifications {
+    /**
+     * Requests permission using the standard browser Web Notification API.
+     * @returns A promise resolving to `true` if permission is granted, `false` otherwise.
+     */
+    async requestPermission() {
+        try {
+            const result = await Notification.requestPermission();
+            return result === 'granted';
+        }
+        catch (err) {
+            console.error('Web notification permission error:', err);
+            return false;
+        }
+    }
+    /**
+     * Triggers a standard browser notification when permitted.
+     * @param title The notification title.
+     * @param options Options containing the body of the notification.
+     */
+    async sendNotification(title, options) {
+        try {
+            if ('serviceWorker' in navigator) {
+                const registration = await navigator.serviceWorker.getRegistration();
+                if (registration) {
+                    await registration.showNotification(title, { body: options?.body });
+                    return;
+                }
+            }
+            new Notification(title, { body: options?.body });
+        }
+        catch (err) {
+            console.error('Web notification error:', err);
+            try {
+                new Notification(title, { body: options?.body });
+            }
+            catch (fallbackErr) {
+                console.error('Fallback web notification error:', fallbackErr);
+            }
+        }
+    }
+}
+/**
+ * Singleton wrapper and router for cross-platform local notification features.
+ * Automatically delegates calls to the appropriate platform-specific implementation.
+ */
+class Notifications {
+    static _instance;
+    impl;
+    /**
+     * Private constructor to enforce singleton usage pattern.
+     * Selects and instantiates the underlying notification engine based on platform type.
+     */
+    constructor() {
+        if (Platforms.isMobile()) {
+            this.impl = new CapacitorNotifications();
+        }
+        else if (Platforms.isDesktop()) {
+            this.impl = new ElectronNotifications();
+        }
+        else {
+            this.impl = new WebNotifications();
+        }
+    }
+    /**
+     * Gets the current active global singleton instance of `Notifications`.
+     */
+    static get instance() {
+        if (!this._instance) {
+            this._instance = new Notifications();
+        }
+        return this._instance;
+    }
+    /**
+     * Requests authorization/permission from the user to display notifications.
+     * Delegates to the active platform implementation.
+     * @returns A promise resolving to `true` if permission was granted, `false` otherwise.
+     */
+    requestPermission() {
+        return this.impl.requestPermission();
+    }
+    /**
+     * Triggers or schedules a local notification.
+     * Delegates to the active platform implementation.
+     * @param title The title text of the notification.
+     * @param options Configuration options including message body and unique ID.
+     */
+    sendNotification(title, options) {
+        return this.impl.sendNotification(title, options);
+    }
+}
+
+class WebFileSystem {
+    async requestPermission() {
+        console.log('WebFileSystem: requestPermission');
+    }
+    async write(path, data) {
+        localStorage.setItem(path, data);
+    }
+    async read(path) {
+        const data = localStorage.getItem(path);
+        if (!data)
+            throw new Error("File not found");
+        return data;
+    }
+    async delete(path) {
+        localStorage.removeItem(path);
+    }
+    async exists(path) {
+        return localStorage.getItem(path) !== null;
+    }
+}
+class CapacitorFileSystem {
+    async requestPermission() {
+        const status = await Filesystem.requestPermissions();
+        if (status.publicStorage === "granted") {
+            return true;
+        }
+        return false;
+    }
+    async write(options) {
+        await Filesystem.writeFile(options);
+    }
+    async read(options) {
+        const result = await Filesystem.readFile(options);
+        return result;
+    }
+    async delete(path) {
+        await Filesystem.deleteFile({
+            path,
+            directory: Directory.Data,
+        });
+    }
+    async exists(path) {
+        try {
+            await Filesystem.stat({
+                path,
+                directory: Directory.Data,
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getUri(options) {
+        return await Filesystem.getUri(options);
+    }
+    async stat(option) {
+        return await Filesystem.stat(option);
+    }
+}
+class ElectronFileSystem {
+    async requestPermission() {
+        return true;
+    }
+    async write(path, data) {
+        window.FileSystem.writeFile(path, data);
+    }
+    async read(path) {
+        return window.FileSystem.readFile(path);
+    }
+    async delete(path) {
+        window.FileSystem.deleteFile(path);
+    }
+    async exists(path) {
+        return window.FileSystem.fileExists(path);
+    }
+}
+/**
+ * Cross-platform FileSystem utility that delegates persistent local read/write file transactions
+ * to native Capacitor plugins, Electron preload APIs, or falling back to Web localStorage.
+ */
+class FileSystem {
+    impl;
+    static _instance;
+    /**
+     * Singleton instance of the FileSystem utility.
+     */
+    static get instance() {
+        if (!this._instance) {
+            // Capacitor native
+            if (Platforms.isMobile()) {
+                this._instance = new CapacitorFileSystem();
+                return this._instance;
+            }
+            // Electron preload
+            if (Platforms.isDesktop()) {
+                this._instance = new ElectronFileSystem();
+                return this._instance;
+            }
+            // Web fallback
+            this._instance = new WebFileSystem();
+        }
+        return this._instance;
+    }
+    /**
+     * Requests native filesystem permissions on the current device.
+     * @returns A promise resolving to true if permissions were granted.
+     */
+    requestPermission() {
+        return this.impl.requestPermission();
+    }
+    /**
+     * Writes text or data to a specific file.
+     * @param path Target relative path of the file.
+     * @param data Raw content or options to write.
+     */
+    write(path, data) {
+        return this.impl.write(path, data);
+    }
+    /**
+     * Reads text or data from a specific file.
+     * @param path Target relative path of the file.
+     * @returns A promise resolving to the read contents.
+     */
+    read(path) {
+        return this.impl.read(path);
+    }
+    /**
+     * Deletes a file from the device storage.
+     * @param path Target relative path to delete.
+     */
+    delete(path) {
+        return this.impl.delete(path);
+    }
+    /**
+     * Verifies if a file exists at the specified path.
+     * @param path Target relative path to test.
+     * @returns A promise resolving to true if the file exists, false otherwise.
+     */
+    exists(path) {
+        return this.impl.exists(path);
+    }
+}
+
+// /**
+//  * Retrieves a connection to the local SQLite database. Initializes schema tables if they do not exist.
+//  * *Note: Supported only on mobile and desktop platforms.*
+//  * @returns A promise resolving to the SQLiteDBConnection instance.
+//  */
+// export async function getDB(): Promise<SQLiteDBConnection> {
+//     if (Platforms.isWeb()) throw new Error("Database is not supported in Web")
+//     if (db === null) {
+//         const sqlite = new SQLiteConnection(CapacitorSQLite);
+//         // Sync JS connection state with Native after a webview reload
+//         try {
+//             await sqlite.checkConnectionsConsistency();
+//         } catch (e) {
+//             console.error("Failed to check connection consistency", e);
+//         }
+//         // Handle webview hard reloads: check if native connection already exists
+//         const isConn = (await sqlite.isConnection('quan-erp.db', false)).result;
+//         if (isConn) {
+//             db = await sqlite.retrieveConnection('quan-erp.db', false);
+//         } else {
+//             db = await sqlite.createConnection('quan-erp.db', false, 'no-encryption', 1, false);
+//         }
+//         const isOpen = (await db.isDBOpen()).result;
+//         if (!isOpen) {
+//             await db.open();
+//         }
+//         await db.execute(`
+//             CREATE TABLE IF NOT EXISTS plugins (
+//                 id INTEGER PRIMARY KEY AUTOINCREMENT,
+//                 name TEXT NOT NULL,
+//                 version TEXT NOT NULL
+//             )
+//         `)
+//         return db;
+//     }
+//     return db;
+// }
+/**
+ * Mobile-specific local SQLite database helper.
+ */
+class Database {
+    static _instance = null;
+    constructor() { }
+    /**
+     * Retrieves the singleton mobile SQLite database connection.
+     * @returns A promise resolving to the database connection instance.
+     */
+    static async getInstance() {
+        if (!Platforms.isMobile())
+            throw new Error("SQLite is supported only on mobile");
+        if (!Database._instance) {
+            const sqlite = new SQLiteConnection(CapacitorSQLite);
+            try {
+                await sqlite.checkConnectionsConsistency();
+            }
+            catch (e) {
+                console.error("Failed to check connection consistency", e);
+            }
+            const isConn = (await sqlite.isConnection('quan-erp.db', false)).result;
+            if (isConn) {
+                Database._instance = await sqlite.retrieveConnection('quan-erp.db', false);
+            }
+            else {
+                Database._instance = await sqlite.createConnection('quan-erp.db', false, 'no-encryption', 1, false);
+            }
+            const isOpen = (await Database._instance.isDBOpen()).result;
+            if (!isOpen) {
+                await Database._instance.open();
+            }
+        }
+        return Database._instance;
+    }
+}
+
+// Web implementation
+class WebLocation {
+    watchers = new Map();
+    nextId = 1;
+    async requestPermission() {
+        if (!browserOrignalNavigator.geolocation)
+            return false;
+        try {
+            // Prompt permission
+            await new Promise((resolve, reject) => {
+                browserOrignalNavigator.geolocation.getCurrentPosition(resolve, reject);
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getCurrentPosition() {
+        return new Promise((resolve, reject) => {
+            browserOrignalNavigator.geolocation.getCurrentPosition((pos) => resolve({ latitude: pos.coords.latitude, longitude: pos.coords.longitude }), reject);
+        });
+    }
+    watchPosition(callback) {
+        const id = this.nextId++;
+        const watchId = browserOrignalNavigator.geolocation.watchPosition((pos) => callback({ latitude: pos.coords.latitude, longitude: pos.coords.longitude }));
+        this.watchers.set(id, watchId);
+        return Promise.resolve(String(id));
+    }
+    clearWatch(watchId) {
+        const id = this.watchers.get(Number(watchId));
+        if (id != null)
+            browserOrignalNavigator.geolocation.clearWatch(id);
+        this.watchers.delete(Number(watchId));
+    }
+}
+// Capacitor implementation
+class CapacitorLocation extends WebLocation {
+    async requestPermission() {
+        try {
+            const perm = await Geolocation.requestPermissions();
+            return perm.location === 'granted';
+        }
+        catch {
+            return false;
+        }
+    }
+    async getCurrentPosition() {
+        const pos = await Geolocation.getCurrentPosition();
+        return { latitude: pos.coords.latitude, longitude: pos.coords.longitude };
+    }
+    async watchPosition(callback) {
+        const watchId = await Geolocation.watchPosition({}, (pos) => {
+            callback({ latitude: pos.coords.latitude, longitude: pos.coords.longitude });
+        });
+        return watchId;
+    }
+    clearWatch(watchId) {
+        Geolocation.clearWatch({ id: watchId });
+    }
+}
+// Electron implementation (can fallback to Web API)
+class ElectronLocation extends WebLocation {
+}
+// Singleton cross-platform wrapper
+/**
+ * Cross-platform Geolocation utility that delegates location tracking and watch requests
+ * to native Capacitor plugins, Electron, or Web Geolocation APIs depending on the runtime environment.
+ */
+class Location {
+    static _instance;
+    impl;
+    // Private constructor
+    constructor() {
+        if (Platforms.isMobile()) {
+            this.impl = new CapacitorLocation();
+        }
+        else if (Platforms.isDesktop()) {
+            this.impl = new ElectronLocation();
+        }
+        else {
+            this.impl = new WebLocation();
+        }
+    }
+    /**
+     * Singleton instance of the Location utility.
+     */
+    static get instance() {
+        if (!this._instance) {
+            this._instance = new Location();
+        }
+        return this._instance;
+    }
+    /**
+     * Requests location tracking permissions on the current device.
+     * @returns A promise resolving to true if location access was granted.
+     */
+    requestPermission() {
+        return this.impl.requestPermission();
+    }
+    /**
+     * Obtains the current static geolocation coordinates.
+     * @returns A promise resolving to coordinates containing latitude and longitude.
+     */
+    getCurrentPosition() {
+        return this.impl.getCurrentPosition();
+    }
+    /**
+     * Registers a continuous watch listener on the device's location coordinates.
+     * @param callback Callback function executed whenever location updates occur.
+     * @returns A promise resolving to a string watch ID which can be cleared.
+     */
+    watchPosition(callback) {
+        return this.impl.watchPosition(callback);
+    }
+    /**
+     * Cancels an ongoing geolocation watch listener session.
+     * @param watchId The string ID of the watch listener to release.
+     */
+    clearWatch(watchId) {
+        this.impl.clearWatch(watchId);
+    }
+}
+
+/**
+ * Central system utility class for managing, requesting, and query-checking application permissions.
+ * Serves as a standard interface for handling high-security mobile device feature access (Camera, Location, Push, etc.).
+ */
+class Permissions {
+}
+
+/**
+ * Cross-platform Network connection and status tracking utility.
+ */
+class Network {
+    /**
+     * Checks if the device is currently online.
+     * @returns A promise resolving to true if connected, false otherwise.
+     */
+    static async isOnline() {
+        // 1. Browser fallback (works also inside Electron renderer)
+        if (typeof browserOrignalNavigator !== "undefined" && "onLine" in browserOrignalNavigator) {
+            return browserOrignalNavigator.onLine;
+        }
+        // 2. Capacitor Native (mobile / desktop)
+        try {
+            const status = await Network$1.getStatus();
+            return status.connected;
+        }
+        catch (e) {
+            // 3. Final fallback
+            return false;
+        }
+    }
+    /**
+     * Registers a listener to observe changes in the device's online/offline connection state.
+     * @param callback Callback function executed whenever network state changes.
+     */
+    static async listenNetwork(callback) {
+        try {
+            const { Network } = await import('@capacitor/network');
+            Network.addListener("networkStatusChange", status => {
+                callback(status.connected);
+            });
+        }
+        catch (e) {
+            // Web fallback
+            window.addEventListener("online", () => callback(true));
+            window.addEventListener("offline", () => callback(false));
+        }
+    }
+}
+
+class CapacitorBluetooth {
+    devices = new Map();
+    connectedDevices = new Set();
+    constructor() {
+        BleClient.initialize();
+    }
+    async requestPermission() {
+        try {
+            await BleClient.requestLEScan({ services: ['0000180f-0000-1000-8000-00805f9b34fb'] }, (result) => {
+                console.log('Device found:', result.device.name, result.device.deviceId);
+            });
+            return true;
+        }
+        catch (err) {
+            console.warn('Permission denied:', err);
+            return false;
+        }
+    }
+    async scan() {
+        console.log('Capacitor: scanning for devices...');
+        this.devices.clear();
+        try {
+            const device = await BleClient.requestDevice({
+                services: ['0000180f-0000-1000-8000-00805f9b34fb'], // example
+            });
+            console.log('Found device:', device.name, device.deviceId);
+            this.devices.set(device.deviceId, device);
+            // Return as BluetoothDeviceInfo array
+            return [{
+                    id: device.deviceId,
+                    name: device.name,
+                }];
+        }
+        catch (err) {
+            console.error('Scan failed or canceled:', err);
+            return []; // return empty array on failure
+        }
+    }
+    async connect(deviceId) {
+        const device = this.devices.get(deviceId);
+        if (!device)
+            throw new Error('Device not found');
+        await BleClient.connect(deviceId);
+        this.connectedDevices.add(deviceId);
+        console.log('Connected to', device.name);
+    }
+    async disconnect(deviceId) {
+        try {
+            await BleClient.disconnect(deviceId);
+            this.connectedDevices.delete(deviceId);
+            console.log('Disconnected from', deviceId);
+        }
+        catch (err) {
+            console.warn('Error disconnecting', err);
+        }
+    }
+    async isConnected(deviceId) {
+        return this.connectedDevices.has(deviceId);
+    }
+}
+class ElectronBluetooth {
+    connectedDevices = new Map();
+    async requestPermission() {
+        try {
+            // Trigger the permission prompt (must be from user gesture)
+            await browserOrignalNavigator.bluetooth.requestDevice({ acceptAllDevices: true });
+            return true;
+        }
+        catch (err) {
+            console.warn('Permission denied or canceled:', err);
+            return false;
+        }
+    }
+    async scan() {
+        console.log('Electron: scanning...');
+        const devices = [];
+        try {
+            const device = await browserOrignalNavigator.bluetooth.requestDevice({
+                acceptAllDevices: true,
+                optionalServices: ['battery_service'], // example
+            });
+            console.log('Found device:', device.name, device.id);
+            this.connectedDevices.set(device.id, device);
+            devices.push({
+                id: device.id,
+                name: device.name,
+            });
+            return devices;
+        }
+        catch (err) {
+            console.error('Scan failed:', err);
+            return [];
+        }
+    }
+    async connect(deviceId) {
+        const device = this.connectedDevices.get(deviceId);
+        if (!device)
+            throw new Error('Device not found');
+        const server = await device.gatt?.connect();
+        if (!server)
+            throw new Error('Failed to connect');
+        console.log('Connected to', device.name);
+    }
+    async disconnect(deviceId) {
+        const device = this.connectedDevices.get(deviceId);
+        if (device?.gatt?.connected) {
+            device.gatt.disconnect();
+            console.log('Disconnected from', device.name);
+        }
+    }
+    async isConnected(deviceId) {
+        const device = this.connectedDevices.get(deviceId);
+        return !!device?.gatt?.connected;
+    }
+}
+class WebBluetooth {
+    devices = new Map();
+    connectedDevices = new Map();
+    async requestPermission() {
+        try {
+            // Try a dummy request to trigger permission prompt
+            await browserOrignalNavigator.bluetooth.requestDevice({
+                acceptAllDevices: true,
+            });
+            return true;
+        }
+        catch (err) {
+            console.warn('Permission denied or user canceled:', err);
+            return false;
+        }
+    }
+    async scan() {
+        try {
+            const device = await browserOrignalNavigator.bluetooth.requestDevice({
+                acceptAllDevices: true,
+                optionalServices: ['battery_service'],
+            });
+            this.devices.set(device.id, device);
+            return [{ id: device.id, name: device.name }];
+        }
+        catch (err) {
+            console.error('Scan failed:', err);
+            return [];
+        }
+    }
+    async connect(deviceId) {
+        const device = this.devices.get(deviceId);
+        if (!device)
+            throw new Error('Device not found');
+        const server = await device.gatt?.connect();
+        if (!server)
+            throw new Error('Failed to connect');
+        this.connectedDevices.set(deviceId, server);
+        console.log(`Web: connected to ${device.name}`);
+    }
+    async disconnect(deviceId) {
+        const server = this.connectedDevices.get(deviceId);
+        if (server?.connected) {
+            server.disconnect();
+            console.log(`Web: disconnected from ${deviceId}`);
+        }
+        this.connectedDevices.delete(deviceId);
+    }
+    async isConnected(deviceId) {
+        const server = this.connectedDevices.get(deviceId);
+        return server?.connected ?? false;
+    }
+}
+/**
+ * Cross-platform Bluetooth LE tracking utility that delegates permission prompts, scanning,
+ * and connection lifecycle methods to Capacitor BLE plugins, Electron, or Web Bluetooth APIs.
+ */
+class Bluetooth {
+    impl;
+    // Static instance
+    static _instance;
+    constructor() {
+        if (Platforms.isMobile()) {
+            this.impl = new CapacitorBluetooth();
+        }
+        else if (Platforms.isDesktop()) {
+            this.impl = new ElectronBluetooth();
+        }
+        else {
+            this.impl = new WebBluetooth();
+        }
+    }
+    /**
+     * Singleton instance of the Bluetooth LE utility.
+     */
+    static get instance() {
+        if (!Bluetooth._instance) {
+            Bluetooth._instance = new Bluetooth();
+        }
+        return Bluetooth._instance;
+    }
+    /**
+     * Triggers the platform's native Bluetooth permission prompt or scan dialog.
+     * @returns A promise resolving to true if permission was granted.
+     */
+    requestPermission() {
+        return this.impl.requestPermission();
+    }
+    /**
+     * Initiates a scanner session to discover nearby Bluetooth LE peripherals.
+     * @returns A promise resolving to a list of discovered devices.
+     */
+    scan() {
+        return this.impl.scan();
+    }
+    /**
+     * Connects to a specific Bluetooth LE device.
+     * @param deviceId Unique hardware identifier of the target device.
+     */
+    connect(deviceId) {
+        return this.impl.connect(deviceId);
+    }
+    /**
+     * Closes the active GATT connection with a specific device.
+     * @param deviceId Unique hardware identifier of the target device.
+     */
+    disconnect(deviceId) {
+        return this.impl.disconnect(deviceId);
+    }
+    /**
+     * Checks if a specific device is currently connected.
+     * @param deviceId Unique hardware identifier of the target device.
+     * @returns A promise resolving to true if connected, false otherwise.
+     */
+    isConnected(deviceId) {
+        return this.impl.isConnected(deviceId);
+    }
+}
+
+// clipboard.ts
+class CapacitorClipboard {
+    async readText() {
+        const { value } = await Clipboard$1.read();
+        return value || '';
+    }
+    async writeText(text) {
+        await Clipboard$1.write({ string: text });
+    }
+    async requestPermission() {
+        // Capacitor usually allows clipboard by default
+        return true;
+    }
+}
+class ElectronClipboard {
+    electronClipboard = window.electron?.clipboard;
+    async readText() {
+        return this.electronClipboard ? this.electronClipboard.readText() : '';
+    }
+    async writeText(text) {
+        if (this.electronClipboard)
+            this.electronClipboard.writeText(text);
+    }
+    async requestPermission() {
+        // Electron clipboard access is unrestricted
+        return true;
+    }
+}
+class WebClipboard {
+    async readText() {
+        try {
+            return await browserOrignalNavigator.clipboard.readText();
+        }
+        catch {
+            return '';
+        }
+    }
+    async writeText(text) {
+        try {
+            await browserOrignalNavigator.clipboard.writeText(text);
+        }
+        catch { }
+    }
+    async requestPermission() {
+        try {
+            // Try a dummy write to request permission
+            await browserOrignalNavigator.clipboard.writeText('');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+/**
+ * Cross-platform Clipboard utility that delegates copy/paste text actions
+ * to native Capacitor plugins, Electron, or browser Clipboard APIs depending on the environment.
+ */
+class Clipboard {
+    static _instance;
+    impl;
+    constructor() {
+        this.impl = this.detectPlatform();
+    }
+    /**
+     * Singleton instance of the Clipboard utility.
+     */
+    static get instance() {
+        if (!Clipboard._instance) {
+            Clipboard._instance = new Clipboard();
+        }
+        return Clipboard._instance;
+    }
+    detectPlatform() {
+        // Capacitor
+        if (Platforms.isMobile()) {
+            return new CapacitorClipboard();
+        }
+        // Electron
+        if (Platforms.isDesktop()) {
+            return new ElectronClipboard();
+        }
+        // Web fallback
+        return new WebClipboard();
+    }
+    /**
+     * Reads plain text from the system clipboard.
+     * @returns A promise resolving to the clipboard's string value.
+     */
+    readText() {
+        return this.impl.readText();
+    }
+    /**
+     * Writes the specified text to the system clipboard.
+     * @param text The plain text string to copy.
+     */
+    writeText(text) {
+        return this.impl.writeText(text);
+    }
+    /**
+     * Requests system clipboard permission prompts on the current platform.
+     * @returns A promise resolving to true if clipboard access was successfully permitted.
+     */
+    requestPermission() {
+        return this.impl.requestPermission();
+    }
+}
+
+class CapacitorBattery {
+    async getLevel() {
+        const info = await browserOrignalNavigator.getBattery?.(); // Capacitor/Battery plugin
+        return info?.level ?? 1;
+    }
+    async isCharging() {
+        const info = await browserOrignalNavigator.getBattery?.();
+        return info?.charging ?? true;
+    }
+    onLevelChange(callback) {
+        browserOrignalNavigator.getBattery?.()?.then((b) => b.addEventListener('levelchange', () => callback(b.level)));
+    }
+    onChargingChange(callback) {
+        browserOrignalNavigator.getBattery?.()?.then((b) => b.addEventListener('chargingchange', () => callback(b.charging)));
+    }
+}
+class ElectronBattery extends CapacitorBattery {
+}
+class WebBattery extends CapacitorBattery {
+}
+/**
+ * Cross-platform Battery tracking utility that delegates status lookups and level change event
+ * subscriptions to native Capacitor plugins, Electron, or Web Battery APIs.
+ */
+class Battery {
+    static _instance;
+    constructor() { }
+    static get impl() {
+        if (!this._instance) {
+            if (window.Capacitor?.isNativePlatform) {
+                this._instance = new CapacitorBattery();
+            }
+            else if (typeof window.electron !== 'undefined') {
+                this._instance = new ElectronBattery();
+            }
+            else {
+                this._instance = new WebBattery();
+            }
+        }
+        return this._instance;
+    }
+    /**
+     * Get the current battery level as a number between 0 and 1.
+     * @returns {Promise<number>} A promise that resolves with the battery level.
+     */
+    static getLevel() {
+        return this.impl.getLevel();
+    }
+    /**
+     * Check whether the device is currently charging.
+     * @returns {Promise<boolean>} A promise that resolves to true if charging, false otherwise.
+     */
+    static isCharging() {
+        return this.impl.isCharging();
+    }
+    /**
+     * Subscribe to battery level changes.
+     * @param {(level: number) => void} callback - Callback invoked when the battery level changes.
+     * @returns {() => void} A function to unsubscribe from the level change event.
+     */
+    static onLevelChange(callback) {
+        return this.impl.onLevelChange(callback);
+    }
+    /**
+     * Subscribe to charging status changes.
+     * @param {(charging: boolean) => void} callback - Callback invoked when the charging status changes.
+     * @returns {() => void} A function to unsubscribe from the charging change event.
+     */
+    static onChargingChange(callback) {
+        return this.impl.onChargingChange(callback);
+    }
+}
+
+/**
+ * Capacitor implementation utilizing mobile shell services and browser-native APIs.
+ */
+class CapacitorSystem {
+    /**
+     * Fetches Capacitor device information metadata.
+     */
+    getInfo() {
+        return Device$1.getInfo();
+    }
+    /**
+     * Desktop and device CPU usage mock fallback.
+     */
+    async getCPUUsage() {
+        // No standard Capacitor API, fallback
+        return 0;
+    }
+    /**
+     * Attempts to resolve memory usage using native Device parameters.
+     */
+    async getMemoryUsage() {
+        const info = await Device$1.getInfo();
+        if (info.platform === 'android') {
+            // Only Android exposes total memory via Device plugin
+            return {
+                total: 0,
+                used: info.memUsed || 0, // no precise usage info
+            };
+        }
+        return { used: 0, total: 0 }; // fallback for iOS / web
+    }
+    /**
+     * Resolves core thread count.
+     */
+    async getCPUCoreCount() {
+        return navigator.hardwareConcurrency;
+    }
+    /**
+     * Resolves system physical memory capacity.
+     */
+    async getDeviceMemory() {
+        return navigator.deviceMemory;
+    }
+    /**
+     * Resolves effective network latency profiles.
+     */
+    getNetworkType() {
+        return navigator.connection?.effectiveType;
+    }
+}
+/**
+ * Electron desktop system implementation.
+ * Queries CPU, RAM, and hardware metrics via desktop-bound IPC helper bridges.
+ */
+class ElectronSystem {
+    /**
+     * Resolves system platform specifications.
+     */
+    async getInfo() {
+        const info = await window.electron.getSystemInfo();
+        return info;
+    }
+    /**
+     * Queries real-time processor load via desktop shell process monitors.
+     */
+    async getCPUUsage() {
+        const metrics = await window.electron.getMetrics();
+        return metrics.cpu; // 0..1
+    }
+    /**
+     * Queries real-time memory allocations.
+     */
+    async getMemoryUsage() {
+        const metrics = await window.electron.getMetrics();
+        return metrics.memory; // { used, total }
+    }
+    /**
+     * Queries physical thread count metrics.
+     */
+    async getCPUCoreCount() {
+        const info = await window.electron.getSystemInfo();
+        return info.cpu?.cores;
+    }
+    /**
+     * Resolves total RAM size in Gigabytes.
+     */
+    async getDeviceMemory() {
+        const info = await window.electron.getSystemInfo();
+        return info.memory?.total / (1024 ** 3);
+    }
+    /**
+     * Queries effective network speed profiles.
+     */
+    getNetworkType() {
+        return navigator.connection?.effectiveType;
+    }
+}
+/**
+ * Browser-native web system metrics client.
+ * Relies on standard DOM capabilities and performance parameters.
+ */
+class WebSystem {
+    /**
+     * Parses browser and platform credentials from the standard user-agent.
+     */
+    async getInfo() {
+        const uaData = browserOrignalNavigator.userAgentData;
+        return {
+            browser: uaData?.brands?.find((b) => b.brand.includes("Chrome"))?.brand || "Chrome",
+            version: uaData?.brands?.find((b) => b.brand.includes("Chrome"))?.version,
+            platform: uaData?.platform,
+            mobile: uaData?.mobile,
+        };
+    }
+    /**
+     * Process usage mock fallback.
+     */
+    async getCPUUsage() {
+        // Web has no direct CPU access; fallback to 0
+        return 0;
+    }
+    /**
+     * Resolves standard JS heap size allocations if performance memory APIs are supported.
+     */
+    async getMemoryUsage() {
+        const mem = performance.memory;
+        if (mem) {
+            return { used: mem.usedJSHeapSize, total: mem.totalJSHeapSize };
+        }
+        return { used: 0, total: 0 };
+    }
+    /**
+     * Resolves browser-reported thread concurrency limits.
+     */
+    async getCPUCoreCount() {
+        return browserOrignalNavigator.hardwareConcurrency;
+    }
+    /**
+     * Resolves browser-reported device memory size in Gigabytes.
+     */
+    async getDeviceMemory() {
+        return browserOrignalNavigator.deviceMemory;
+    }
+    /**
+     * Resolves connection type details from browser connection descriptors.
+     */
+    getNetworkType() {
+        return browserOrignalNavigator.connection?.effectiveType;
+    }
+}
+/**
+ * Singleton proxy class routing diagnostic query operations to the resolved platform system helper.
+ */
+class System {
+    static _instance;
+    constructor() { }
+    /**
+     * Internal getter to resolve the target native interface service.
+     */
+    static get impl() {
+        if (!this._instance) {
+            if (Platforms.isMobile()) {
+                this._instance = new CapacitorSystem();
+            }
+            else if (Platforms.isDesktop()) {
+                this._instance = new ElectronSystem();
+            }
+            else {
+                this._instance = new WebSystem();
+            }
+        }
+        return this._instance;
+    }
+    /**
+     * Resolves current CPU usage fraction.
+     */
+    static getCPUUsage() {
+        return this.impl.getCPUUsage();
+    }
+    /**
+     * Resolves allocated and free heap memory details.
+     */
+    static getMemoryUsage() {
+        return this.impl.getMemoryUsage();
+    }
+    /**
+     * Resolves host system core counts.
+     */
+    static getCPUCoreCount() {
+        return this.impl.getCPUCoreCount();
+    }
+    /**
+     * Resolves physical device memory in GB.
+     */
+    static getDeviceMemory() {
+        return this.impl.getDeviceMemory();
+    }
+    /**
+     * Resolves network connection speed indicator tags.
+     */
+    static getNetworkType() {
+        return this.impl.getNetworkType();
+    }
+    /**
+     * Fetches detailed platform environment descriptors.
+     */
+    static getInfo() {
+        return System.impl.getInfo();
+    }
+}
+
+/**
+ * Web client haptic engine utilizing browser standard `navigator.vibrate` or `web-haptics` utilities.
+ */
+class WebVibration {
+    haptics;
+    /**
+     * Initializes the WebVibration instance and registers fallback web-haptics listeners.
+     */
+    constructor() {
+        this.haptics = new WebHaptics({
+            showSwitch: false, // optional: hide/show toggle
+        });
+    }
+    /**
+     * Triggers standard browser-native vibration patterns.
+     * @param vibration Haptic duration options.
+     */
+    async vibrate(vibration) {
+        if ("vibrate" in browserOrignalNavigator || WebHaptics.isSupported) {
+            await this.haptics.trigger(vibration);
+        }
+        else {
+            console.warn("Vibration not supported in this browser");
+        }
+    }
+    /**
+     * Resets browser vibration activity by sending a zero-intensity trigger.
+     */
+    cancel() {
+        browserOrignalNavigator.vibrate(0);
+    }
+}
+/**
+ * Mobile-specific vibration driver utilizing native system haptics via `@capacitor/haptics`.
+ */
+class CapacitorVibration {
+    /**
+     * Dispatches native haptic system feedback on Android and iOS devices.
+     * Maps arrays of pulses into consecutive physical haptic impacts.
+     * @param duration Millisecond pulse duration configurations.
+     */
+    async vibrate(duration) {
+        if (Array.isArray(duration)) {
+            for (const dur of duration) {
+                await Haptics.impact({ style: ImpactStyle.Medium });
+            }
+        }
+        else {
+            // Single impact for simplicity
+            Haptics.impact({ style: ImpactStyle.Medium });
+        }
+    }
+    /**
+     * Cancels native haptics or triggers a subtle success alert.
+     */
+    cancel() {
+        // Trigger a neutral notification as "cancel" placeholder
+        Haptics.notification({ type: NotificationType.Success });
+    }
+}
+/**
+ * Electron desktop vibration controller fallback.
+ */
+class ElectronVibration {
+    /**
+     * Mock vibration method warning users that desktop hardware lacks vibration motors.
+     */
+    vibrate(duration) {
+        console.warn("Vibration not supported on desktop");
+    }
+    /**
+     * No-op cancel routine.
+     */
+    cancel() {
+        // noop
+    }
+}
+/**
+ * Singleton wrapper and router managing device vibrations across platforms.
+ */
+class Vibration {
+    static _instance;
+    impl;
+    /**
+     * Private constructor to enforce standard singleton instantiation, resolving target driver at runtime.
+     */
+    constructor() {
+        if (Platforms.isMobile()) {
+            this.impl = new CapacitorVibration();
+        }
+        else {
+            this.impl = new WebVibration();
+        }
+    }
+    /**
+     * Retrieves the global active, platform-resolved singleton vibration engine instance.
+     */
+    static get instance() {
+        if (!this._instance) {
+            this._instance = new Vibration();
+        }
+        return this._instance;
+    }
+    /**
+     * Triggers vibration using the platform resolved driver.
+     * @param duration A numeric duration in milliseconds or a structured pattern array.
+     */
+    vibrate(duration) {
+        this.impl.vibrate(duration);
+    }
+    /**
+     * Cancels all active vibration outputs.
+     */
+    cancel() {
+        this.impl.cancel();
+    }
+}
+
+class WebMicrophone {
+    stream = null;
+    async requestPermission() {
+        try {
+            const status = await browserOrignalNavigator.permissions.query({ name: "microphone" });
+            if (status.state === "granted")
+                return true;
+            // Request permission
+            await browserOrignalNavigator.mediaDevices.getUserMedia({ audio: true });
+            return true;
+        }
+        catch (err) {
+            console.error("Mic permission denied:", err);
+            return false;
+        }
+    }
+    async start() {
+        this.stream = await browserOrignalNavigator.mediaDevices.getUserMedia({ audio: true });
+    }
+    stop() {
+        if (this.stream) {
+            this.stream.getTracks().forEach(t => t.stop());
+            this.stream = null;
+        }
+    }
+    getStream() {
+        return this.stream;
+    }
+}
+class ElectronMicrophone extends WebMicrophone {
+}
+class CapacitorMicrophone {
+    stream = null;
+    async start() {
+        // This automatically triggers OS permission UI
+        this.stream = await browserOrignalNavigator.mediaDevices.getUserMedia({ audio: true });
+    }
+    async requestPermission() {
+        return true;
+    }
+    stop() {
+        if (this.stream) {
+            this.stream.getTracks().forEach(t => t.stop());
+            this.stream = null;
+        }
+    }
+    getStream() {
+        return this.stream;
+    }
+}
+// Singleton wrapper
+/**
+ * Cross-platform Microphone utility that delegates audio capture streams and recording permissions
+ * to Capacitor plugins, Electron, or browser MediaStream APIs depending on the environment.
+ */
+class Microphone {
+    static _instance;
+    impl;
+    constructor() {
+        if (Platforms.isMobile()) {
+            this.impl = new CapacitorMicrophone();
+        }
+        else if (Platforms.isDesktop()) {
+            this.impl = new ElectronMicrophone();
+        }
+        else {
+            this.impl = new WebMicrophone();
+        }
+    }
+    /**
+     * Singleton instance of the Microphone utility.
+     */
+    static get instance() {
+        if (!this._instance)
+            this._instance = new Microphone();
+        return this._instance;
+    }
+    /**
+     * Requests microphone permissions from the operating system or browser.
+     * @returns A promise resolving to true if permission was granted.
+     */
+    requestPermission() {
+        return this.impl.requestPermission();
+    }
+    /**
+     * Initiates the microphone sensor and binds it to an active audio MediaStream.
+     */
+    start() {
+        return this.impl.start();
+    }
+    /**
+     * Halts microphone streaming and closes all associated audio media tracks.
+     */
+    stop() {
+        return this.impl.stop();
+    }
+    /**
+     * Obtains the raw HTML5 MediaStream containing active audio tracks.
+     * @returns The active MediaStream or null if not streaming.
+     */
+    getStream() {
+        return this.impl.getStream();
+    }
+}
+
+/**
+ * Web-native orientation listener using viewport dimension ratios.
+ * Listens to standard DOM window 'orientationchange' events.
+ */
+let WebOrientation$1 = class WebOrientation {
+    listeners = new Set();
+    /**
+     * Initializes the WebOrientation instance and registers the global resize/orientation listener.
+     */
+    constructor() {
+        window.addEventListener("orientationchange", this.handleChange);
+    }
+    /**
+     * Internal handler invoked when native window orientation changes.
+     */
+    handleChange = () => {
+        const o = this.getOrientation();
+        this.listeners.forEach(cb => cb(o));
+    };
+    /**
+     * Evaluates current viewport widths and heights to determine orientation.
+     * @returns 'landscape' if viewport width > height, otherwise 'portrait'.
+     */
+    getOrientation() {
+        return window.innerWidth > window.innerHeight ? "landscape" : "portrait";
+    }
+    /**
+     * Registers a callback listener for screen orientation updates.
+     * @param callback Callback receiving new orientation.
+     */
+    onChange(callback) {
+        this.listeners.add(callback);
+    }
+    /**
+     * Unregisters a callback listener.
+     * @param callback Callback to remove.
+     */
+    offChange(callback) {
+        this.listeners.delete(callback);
+    }
+};
+/**
+ * Capacitor-specific implementation using `@awesome-cordova-plugins/screen-orientation`
+ * to leverage native mobile system sensors and orientation lock statuses.
+ */
+let CapacitorOrientation$1 = class CapacitorOrientation {
+    callbackSet = new Set();
+    /**
+     * Initializes the mobile screen orientation event subscribers.
+     */
+    constructor() {
+        ScreenOrientation.onChange().subscribe(() => {
+            const o = this.getOrientation();
+            this.callbackSet.forEach(cb => cb(o));
+        });
+    }
+    /**
+     * Checks native mobile screen orientation status.
+     * @returns 'landscape' or 'portrait'.
+     */
+    getOrientation() {
+        const type = ScreenOrientation.type; // e.g., "portrait-primary", "landscape-secondary"
+        return type.startsWith('landscape') ? 'landscape' : 'portrait';
+    }
+    /**
+     * Registers a subscriber callback for orientation changes.
+     * @param cb Callback receiving new orientation.
+     */
+    onChange(cb) {
+        this.callbackSet.add(cb);
+    }
+    /**
+     * Unregisters a subscriber callback.
+     * @param cb Callback to remove.
+     */
+    offChange(cb) {
+        this.callbackSet.delete(cb);
+    }
+};
+/**
+ * Electron-specific desktop window orientation tracker.
+ * Translates viewport resizing into mock orientation state updates.
+ */
+let ElectronOrientation$1 = class ElectronOrientation {
+    callbacks = new Set();
+    /**
+     * Sets up resize listener on desktop shell.
+     */
+    constructor() {
+        window.addEventListener('resize', this.handleResize);
+    }
+    /**
+     * Handles internal resize events to calculate dynamic aspect ratio modifications.
+     */
+    handleResize = () => {
+        const o = this.getOrientation();
+        this.callbacks.forEach(cb => cb(o));
+    };
+    /**
+     * Maps degrees of hardware rotation into portrait/landscape.
+     * @param rotation The degree measurement (0, 90, 180, 270).
+     */
+    getOrientationFromRotation(rotation) {
+        return rotation === 0 || rotation === 180 ? 'portrait' : 'landscape';
+    }
+    /**
+     * Inspects dynamic dimensions of the Electron shell window frame.
+     * @returns 'landscape' or 'portrait'.
+     */
+    getOrientation() {
+        return window.innerWidth > window.innerHeight ? 'landscape' : 'portrait';
+    }
+    /**
+     * Adds an event listener for orientation shifts.
+     * @param cb Callback receiving the updated screen state.
+     */
+    onChange(cb) {
+        this.callbacks.add(cb);
+    }
+    /**
+     * Removes an event listener.
+     * @param cb Callback to remove.
+     */
+    offChange(cb) {
+        this.callbacks.delete(cb);
+    }
+};
+/**
+ * Singleton wrapper and router for managing screen and window orientation states across platforms.
+ */
+class Orientation {
+    static _instance;
+    impl;
+    /**
+     * Enforces single instance behavior and resolves target device implementation at runtime.
+     */
+    constructor() {
+        if (Platforms.isDesktop()) {
+            this.impl = new ElectronOrientation$1();
+        }
+        else if (Platforms.isMobile()) {
+            this.impl = new CapacitorOrientation$1();
+        }
+        else {
+            this.impl = new WebOrientation$1();
+        }
+    }
+    /**
+     * Accesses the active, platform-resolved singleton orientation service.
+     */
+    static get instance() {
+        if (!this._instance) {
+            this._instance = new Orientation();
+        }
+        return this._instance;
+    }
+    /**
+     * Retrieves current viewport or physical device screen orientation.
+     */
+    getOrientation() {
+        return this.impl.getOrientation();
+    }
+    /**
+     * Subscribes a listener to orientation modification events.
+     * @param callback Callback receiving standard landscape/portrait codes.
+     */
+    onChange(callback) {
+        this.impl.onChange(callback);
+    }
+    /**
+     * Unsubscribes a listener.
+     * @param callback Callback to remove.
+     */
+    offChange(callback) {
+        this.impl.offChange(callback);
+    }
+}
+
+/**
+ * Placeholder interface and configuration utilities for SQLite database connection management.
+ *
+ * > [!NOTE]
+ * > Local SQLite instance connections, initializations, and transactions on mobile and desktop platforms
+ * > are actively managed by the dynamic helper class `Database` and the functional accessor `getDB()`
+ * > implemented in `database.ts` (relying on `@capacitor-community/sqlite`).
+ */
+class SQLitePlaceholder {
+    /**
+     * Informational utility function that returns database module metadata.
+     * @returns An object containing sqlite configuration details.
+     */
+    static getMetadata() {
+        return {
+            name: "SQLite-Core",
+            engine: "CapacitorSQLite"
+        };
+    }
+}
+
+/**
+ * Web-native printer helper using browser standard `window.print()` workflows.
+ * Opens a temporary hidden frame or window to present the content dialog to the user.
+ */
+class WebPrinter {
+    /**
+     * Opens a temporary tab frame and initiates the native system print pop-up.
+     * @param html HTML text content to print.
+     */
+    printHTML(html) {
+        const win = window.open('', '_blank');
+        if (!win)
+            return;
+        win.document.write(html);
+        win.document.close();
+        win.focus();
+        win.print();
+    }
+}
+/**
+ * Electron-specific printer helper to coordinate with physical native queues.
+ * Currently serves as a feature placeholder.
+ */
+class ElectronPrinter {
+    /**
+     * Desktop platform custom print dispatcher.
+     * @param html HTML source code to print.
+     */
+    async printHTML(html) {
+        // TODO: not supported
+        throw new Error('not supported yet');
+    }
+}
+/**
+ * Mobile-specific printer implementation utilizing native OS print spoolers.
+ * Currently serves as a feature placeholder.
+ */
+class MobilePrinter {
+    /**
+     * Mobile platform custom print dispatcher.
+     * @param html HTML source code to print.
+     */
+    async printHTML(html) {
+        // TODO: not supported
+        throw new Error('not supported yet');
+    }
+}
+/**
+ * Singleton wrapper and dynamic platform router for the system print engine services.
+ */
+class Printer {
+    static _instance = null;
+    /**
+     * Retrieves the global active singleton printing service instance.
+     * Resolves the target implementation at runtime according to the platform profile.
+     */
+    static get instance() {
+        if (this._instance === null) {
+            if (Platforms.isDesktop()) {
+                this._instance = new ElectronPrinter();
+            }
+            else if (Platforms.isMobile()) {
+                this._instance = new MobilePrinter();
+            }
+            else {
+                this._instance = new WebPrinter();
+            }
+        }
+        return this._instance;
+    }
+}
+
+let backendApi = null;
+function setBackendAPI(url) {
+    backendApi = url;
+}
+function getBackendAPI() {
+    return backendApi;
+}
+
+/**
+ * Utility class for resolving static asset URLs served by plugins on the backend.
+ */
+class PluginAssets {
+    /**
+     * Resolves the backend network URL for a given plugin asset.
+     * @param metadata The plugin's module metadata.
+     * @param url The relative asset path (e.g., 'images/logo.png').
+     * @returns The fully qualified absolute URL pointing to the backend static resource.
+     */
+    static network(metadata, url) {
+        const normalizedPath = '/' + url.replace(/^\.?\//, '');
+        return `${getBackendAPI()}/modules/${metadata.name}/${metadata.pluginVersion}/frontend${normalizedPath}`;
+    }
+}
+
+/**
+ * Utility class for high-performance locale-aware number and currency formatting.
+ * Features an internal cache to reuse Intl.NumberFormat instances across repetitive calls.
+ */
+class NumberFormatter {
+    /**
+     * Map cache key-value store holding instantiated Intl.NumberFormat objects.
+     */
+    static formats = new Map();
+    /**
+     * Formats a numeric value according to the specified locale and formatting configuration.
+     * Caches the underlying Intl.NumberFormat instance based on a normalized cache key.
+     *
+     * @param num The numeric value to format.
+     * @param locale The RFC 5646 language tag representing the locale (e.g., 'en-US', 'my-MM'). Defaults to 'en-US'.
+     * @param options Standard ECMAScript Internationalization API number format options.
+     * @returns The formatted string representation of the number.
+     */
+    static format(num, locale = 'en-US', options) {
+        // Sort options keys for consistent cache key
+        const sortedOptions = options
+            ? Object.keys(options)
+                .sort()
+                .reduce((acc, key) => {
+                acc[key] = options[key];
+                return acc;
+            }, {})
+            : {};
+        const key = locale + JSON.stringify(sortedOptions);
+        let formatter = this.formats.get(key);
+        if (!formatter) {
+            formatter = new Intl.NumberFormat(locale, sortedOptions);
+            this.formats.set(key, formatter);
+        }
+        return formatter.format(num);
+    }
+}
+
+/**
+ * Capacitor native implementation utilizing mobile system services to resolve settings.
+ * Relies on `@capacitor/device` plugin.
+ *
+ * *Note: Class name spelling maintained as `CacacitorLocale` to preserve compatibility with existing references.*
+ */
+class CacacitorLocale {
+    /**
+     * Resolves language code on mobile system settings.
+     * @returns E.g. "en" or "my".
+     */
+    async getDeviceLocale() {
+        const info = await Device$1.getLanguageCode();
+        return info.value; // e.g. "en", "zh"
+    }
+}
+/**
+ * Electron desktop local shell locale resolver.
+ * Currently serves as a feature placeholder.
+ */
+class ElectronLocale {
+    /**
+     * Resolves language code on desktop settings.
+     */
+    async getDeviceLocale() {
+        throw new Error("Method not implemented.");
+    }
+}
+/**
+ * Web browser native environment locale resolver.
+ * Inspects default HTML5 `navigator.language` parameters.
+ */
+class WebLocale {
+    /**
+     * Resolves browser-default language code.
+     */
+    async getDeviceLocale() {
+        return Promise.resolve(navigator.language);
+    }
+}
+/**
+ * Singleton service wrapper and router for managing, retrieving, and query-caching system locale settings.
+ */
+class SystemLocale {
+    static _instance;
+    /**
+     * Accesses the active global, platform-resolved singleton locale service instance.
+     */
+    static get instance() {
+        if (Platforms.isMobile()) {
+            this._instance = new CacacitorLocale();
+        }
+        else if (Platforms.isDesktop()) {
+            this._instance = new ElectronLocale();
+        }
+        else {
+            this._instance = new WebLocale();
+        }
+        return this._instance;
+    }
+}
+
+/**
+ * Classifies device performance capabilities into low, mid, or high tiers.
+ * Used for dynamic feature gating and layout optimization.
+ */
+class DeviceClassDetector {
+    static _instance;
+    /**
+     * Singleton instance of the DeviceClassDetector.
+     */
+    static get instance() {
+        if (!DeviceClassDetector._instance) {
+            DeviceClassDetector._instance = new DeviceClassDetector();
+        }
+        return DeviceClassDetector._instance;
+    }
+    /**
+     * Detects the performance tier of the current device.
+     * Leverages RAM memory parameters, CPU core counts, and network speed signals.
+     * @returns A promise resolving to "low", "mid", "high", or "unknown" tier.
+     */
+    async detect() {
+        const memory = await System.getDeviceMemory(); // GB
+        const cores = await System.getCPUCoreCount(); // number
+        const connection = System.getNetworkType(); // "4g" | "3g" | etc
+        if (!memory && !cores && !connection) {
+            return "unknown";
+        }
+        let score = 0;
+        let signals = 0;
+        // RAM
+        if (memory !== undefined && memory !== null) {
+            signals++;
+            if (memory <= 2)
+                score += 0;
+            else if (memory <= 4)
+                score += 1;
+            else
+                score += 2;
+        }
+        // CPU
+        if (cores !== undefined && cores !== null) {
+            signals++;
+            if (cores <= 4)
+                score += 0;
+            else if (cores <= 8)
+                score += 1;
+            else
+                score += 2;
+        }
+        // Network
+        if (connection !== undefined && connection !== null) {
+            signals++;
+            if (connection === "slow-2g" || connection === "2g")
+                score += 0;
+            else if (connection === "3g")
+                score += 1;
+            else
+                score += 2;
+        }
+        if (signals <= 1) {
+            return "unknown";
+        }
+        if (score <= 2)
+            return "low";
+        if (score <= 4)
+            return "mid";
+        return "high";
+    }
+}
+
+class WebOrientation {
+    handler;
+    start(callback) {
+        this.handler = (event) => {
+            callback({ alpha: event.alpha, beta: event.beta, gamma: event.gamma });
+        };
+        window.addEventListener('deviceorientation', this.handler);
+    }
+    stop() {
+        if (this.handler) {
+            window.removeEventListener('deviceorientation', this.handler);
+            this.handler = undefined;
+        }
+    }
+    async requestOrientationPermission() {
+        if (typeof DeviceOrientationEvent !== "undefined" &&
+            typeof DeviceOrientationEvent.requestPermission === "function") {
+            try {
+                const response = await DeviceOrientationEvent.requestPermission();
+                return response === "granted";
+            }
+            catch {
+                return false;
+            }
+        }
+        // Non-iOS browsers
+        return true;
+    }
+}
+class CapacitorOrientation extends WebOrientation {
+}
+class ElectronOrientation extends WebOrientation {
+}
+/**
+ * Cross-platform Motion Orientation helper class that yields platform-specific trackers.
+ */
+class MotionOrientation {
+    /**
+     * Creates and returns a new instance of IMotionOrientation optimized for the current platform.
+     * @returns A platform-specific instance of IMotionOrientation.
+     */
+    static getNewinstance() {
+        if (Platforms.isMobile()) {
+            return new CapacitorOrientation();
+        }
+        else if (Platforms.isDesktop()) {
+            return new ElectronOrientation();
+        }
+        else {
+            return new WebOrientation();
+        }
+    }
+}
+
+/**
+ * Core utility class that leverages continuous dynamic device gyroscope and accelerometer sensors
+ * to predict if the user is holding their phone in their left or right hand.
+ */
+class UserHandBehaviorDetector {
+    hand = "unknown";
+    started = false;
+    samples = [];
+    SAMPLE_SIZE = 25;
+    TILT_THRESHOLD = 10; // degrees
+    CHANGE_DELAY = 500;
+    lastReportedHand = "unknown";
+    pendingHand = "unknown";
+    changeTimer;
+    motionsOrientation;
+    isInitial = true;
+    /**
+     * Dynamic event listener callback called when holding posture matches change thresholds.
+     */
+    onChange;
+    /**
+     * Private constructor initializing standard sensor listeners and checking platform permissions.
+     */
+    constructor() {
+        this.motionsOrientation = MotionOrientation.getNewinstance();
+        this.motionsOrientation.requestOrientationPermission();
+    }
+    /**
+     * Factory instantiator method to construct new instances of `UserHandBehaviorDetector`.
+     */
+    static getNewInstance() {
+        return new UserHandBehaviorDetector();
+    }
+    /**
+     * Activates continuous data tracking and registers the initial posture feedback callback.
+     * @param callback Callback receiving left/right hand classifications.
+     */
+    start(callback) {
+        if (this.started)
+            return;
+        this.started = true;
+        this.onChange = callback;
+        // Subscribe to Motion orientation events
+        this.motionsOrientation.start(this.handleOrientation);
+    }
+    /**
+     * Terminates continuous gyroscope updates and resets buffers.
+     */
+    stop() {
+        if (!this.started)
+            return;
+        this.started = false;
+        this.motionsOrientation.stop();
+        this.samples = [];
+        this.hand = "unknown";
+        this.onChange = undefined;
+        this.lastReportedHand = "unknown";
+    }
+    /**
+     * Resolves the current holding hand prediction.
+     */
+    getHand() {
+        return this.hand;
+    }
+    /**
+     * Sets the classification confirmation delay.
+     * @param delay Confirmation threshold timing in milliseconds.
+     */
+    setDelay(delay) {
+        this.CHANGE_DELAY = delay;
+    }
+    /**
+     * Internally flags classification match transitions and dispatches event listeners.
+     */
+    confirmHandChange(hand) {
+        this.hand = hand;
+        this.lastReportedHand = hand;
+        if (this.onChange) {
+            this.onChange(hand);
+        }
+    }
+    /**
+     * Throttles hand-holding prediction shifts to prevent rapid toggling noise.
+     */
+    scheduleChange(hand) {
+        if (this.pendingHand === hand)
+            return;
+        this.pendingHand = hand;
+        if (this.changeTimer) {
+            clearTimeout(this.changeTimer);
+        }
+        if (this.isInitial) {
+            this.confirmHandChange(this.pendingHand);
+            return;
+        }
+        this.changeTimer = window.setTimeout(() => {
+            if (this.pendingHand !== this.lastReportedHand) {
+                this.confirmHandChange(this.pendingHand);
+            }
+        }, this.CHANGE_DELAY);
+    }
+    /**
+     * Continuous gyroscope feed event reader.
+     * Computes orientation averages and applies geometric thresholds to resolve holding fingers/thumb angles.
+     */
+    handleOrientation = ({ alpha, beta, gamma }) => {
+        if (!this.started) {
+            console.log('stopped returned');
+            return;
+        }
+        if (gamma == null || beta == null)
+            return;
+        // Adjust for upside-down or flipped phone
+        let adjustedGamma = gamma;
+        let adjustedBeta = beta;
+        if (beta > 90 || beta < -90) {
+            adjustedGamma = -gamma;
+            adjustedBeta = beta > 0 ? beta - 180 : beta + 180;
+        }
+        // Add to sample buffer
+        this.samples.push({ gamma: adjustedGamma, beta: adjustedBeta });
+        if (this.samples.length > this.SAMPLE_SIZE)
+            this.samples.shift();
+        // Compute average gamma and beta for smoothing
+        const avgGamma = this.samples.reduce((sum, s) => sum + s.gamma, 0) / this.samples.length;
+        const avgBeta = this.samples.reduce((sum, s) => sum + s.beta, 0) / this.samples.length;
+        // Hand detection thresholds
+        const ROLL_THRESHOLD = 2; // sensitive left/right tilt
+        const FORWARD_TILT_MIN = 10; // minimum forward tilt to consider
+        const FORWARD_TILT_MAX = 80; // allow lying down / sleeping positions
+        let newHand = "unknown";
+        // Upright / forward-tilted detection
+        if (Math.abs(avgBeta) >= FORWARD_TILT_MIN && Math.abs(avgBeta) <= FORWARD_TILT_MAX) {
+            if (avgGamma > ROLL_THRESHOLD)
+                newHand = "left";
+            else if (avgGamma < -ROLL_THRESHOLD)
+                newHand = "right";
+        }
+        // Optional: horizontal / lying down detection
+        else if (Math.abs(avgBeta) < FORWARD_TILT_MIN) {
+            if (avgGamma > 15)
+                newHand = "left";
+            else if (avgGamma < -15)
+                newHand = "right";
+        }
+        // Trigger onChange only if hand side changed
+        if (newHand !== this.lastReportedHand) {
+            this.scheduleChange(newHand);
+        }
+    };
+}
+
+class WebGyroscope {
+    handler;
+    start(callback) {
+        this.handler = (event) => {
+            if (event.rotationRate) {
+                callback({ alpha: event.rotationRate.alpha, beta: event.rotationRate.beta, gamma: event.rotationRate.gamma });
+            }
+        };
+        window.addEventListener('devicemotion', this.handler, true);
+    }
+    stop() {
+        if (this.handler) {
+            window.removeEventListener('devicemotion', this.handler);
+            this.handler = undefined;
+        }
+    }
+}
+class CapacitorGyroscope extends WebGyroscope {
+}
+class ElectronGyroscope extends WebGyroscope {
+}
+/**
+ * Cross-platform Gyroscope sensor tracking utility that delegates angular velocity queries
+ * to native Capacitor plugins, Electron, or Web DeviceOrientation APIs depending on the environment.
+ */
+class Gryoscope {
+    static _instance;
+    impl;
+    constructor() {
+        if (Platforms.isMobile()) {
+            this.impl = new CapacitorGyroscope();
+        }
+        else if (Platforms.isDesktop()) {
+            this.impl = new ElectronGyroscope();
+        }
+        else {
+            this.impl = new WebGyroscope();
+        }
+    }
+    /**
+     * Singleton instance of the Gyroscope tracker.
+     */
+    static get instance() {
+        if (!this._instance)
+            this._instance = new Gryoscope();
+        return this._instance;
+    }
+    /**
+     * Starts listening to gyroscope rotation rate events.
+     * @param callback Callback function receiving rotation speed on alpha, beta, and gamma axes.
+     */
+    start(callback) {
+        this.impl.start(callback);
+    }
+    /**
+     * Stops listening to gyroscope events and releases sensor listeners.
+     */
+    stop() {
+        this.impl.stop();
+    }
+}
+
+class WebAccelerometer {
+    handler;
+    start(callback) {
+        this.handler = (event) => {
+            if (event.acceleration) {
+                callback({ x: event.acceleration.x, y: event.acceleration.y, z: event.acceleration.z });
+            }
+        };
+        window.addEventListener('devicemotion', this.handler, true);
+    }
+    stop() {
+        if (this.handler) {
+            window.removeEventListener('devicemotion', this.handler);
+            this.handler = undefined;
+        }
+    }
+}
+class CapacitorAccelerometer extends WebAccelerometer {
+}
+class ElectronAccelerometer extends WebAccelerometer {
+}
+/**
+ * Cross-platform Accelerometer tracking utility that delegates sensor reading requests
+ * to native Capacitor modules, Electron, or Web APIs depending on the active platform.
+ */
+class Accelerometer {
+    static _instance;
+    impl;
+    constructor() {
+        if (Platforms.isMobile()) {
+            this.impl = new CapacitorAccelerometer();
+        }
+        else if (Platforms.isDesktop()) {
+            this.impl = new ElectronAccelerometer();
+        }
+        else {
+            this.impl = new WebAccelerometer();
+        }
+    }
+    /**
+     * Singleton instance of the Accelerometer tracker.
+     */
+    static get instance() {
+        if (!this._instance)
+            this._instance = new Accelerometer();
+        return this._instance;
+    }
+    /**
+     * Starts listening to accelerometer sensor data streams.
+     * @param callback Callback function receiving acceleration data on x, y, and z axes (in m/s²).
+     */
+    start(callback) {
+        this.impl.start(callback);
+    }
+    /**
+     * Stops listening to the accelerometer sensor data streams and cleans up underlying listeners.
+     */
+    stop() {
+        this.impl.stop();
+    }
+}
+
+const apis = {};
+/**
+ * Registry interface for dynamic runtime plugin interoperability and component exporting/importing.
+ * Allows plugins within the modular ERP system to expose functional APIs securely and consume external capabilities dynamically.
+ */
+class PluginAPI {
+    /**
+     * Exposes a specific API service from a plugin, registering it within the shared system registry.
+     * Prevents re-definition of keys once registered to ensure runtime immutability and prevent injection attacks.
+     *
+     * @param pluginName The unique namespace name of the exporting plugin.
+     * @param apiName The identifying key representing the exported service.
+     * @param value The functional API surface, class instance, or utility being shared.
+     * @throws Error if the plugin namespace and API key combination is already registered.
+     */
+    static expose(pluginName, apiName, value) {
+        const key = `${pluginName}|${apiName}`;
+        if (apis[key] !== undefined) {
+            throw new Error(`Plugin "${pluginName}" already exposed API "${apiName}".`);
+        }
+        // Define the property as non-writable and non-configurable to guarantee stability
+        Object.defineProperty(apis, key, {
+            value,
+            writable: false, // cannot overwrite
+            configurable: false, // cannot delete or redefine
+            enumerable: true
+        });
+    }
+    /**
+     * Resolves and retrieves an exposed API service from another plugin namespace.
+     *
+     * @param pluginName The namespace of the target plugin.
+     * @param apiName The key identifying the requested API surface.
+     * @returns The resolved service instance cast to generic type T.
+     */
+    static use(pluginName, apiName) {
+        return apis[`${pluginName}|${apiName}`];
+    }
+    /**
+     * Gets the current raw internal registry map of all exposed APIs.
+     */
+    static get store() {
+        return apis;
+    }
+    /**
+     * Lists the keys of all registered APIs in the system for inspection and debugging.
+     * @returns An array of API identifiers in the format: "pluginName|apiName".
+     */
+    static debug() {
+        return Object.keys(apis);
+    }
+}
+
+function uuidToMacAddress(uuid) {
+    const clean = uuid.replace(/[^a-fA-F0-9]/g, "");
+    if (clean.length >= 12) {
+        const part = clean.slice(-12).toLowerCase();
+        return part.match(/.{1,2}/g)?.join(":") || "02:00:00:00:00:00";
+    }
+    return "02:00:00:00:00:00";
+}
+function generateUUIDFallback() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === "x" ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+class CapacitorDevice {
+    async getDeviceId() {
+        try {
+            const idResult = await Device$1.getId();
+            return idResult.identifier || idResult.uuid;
+        }
+        catch (err) {
+            console.warn("Failed to get Capacitor Device ID:", err);
+            let localId = localStorage.getItem("capacitor_device_id");
+            if (!localId) {
+                localId = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : generateUUIDFallback();
+                localStorage.setItem("capacitor_device_id", localId);
+            }
+            return localId;
+        }
+    }
+    async getMacAddress() {
+        const deviceId = await this.getDeviceId();
+        return uuidToMacAddress(deviceId);
+    }
+}
+class ElectronDevice {
+    async getDeviceId() {
+        let localId = localStorage.getItem("desktop_device_id");
+        if (!localId) {
+            try {
+                const mac = await this.getMacAddress();
+                if (mac && mac !== "02:00:00:00:00:00") {
+                    localId = mac;
+                }
+            }
+            catch (e) {
+                // Ignore
+            }
+            if (!localId) {
+                localId = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : generateUUIDFallback();
+            }
+            localStorage.setItem("desktop_device_id", localId);
+        }
+        return localId;
+    }
+    async getMacAddress() {
+        try {
+            const info = await window.electron?.getSystemInfo();
+            if (info && info.networkInterfaces) {
+                const interfaces = info.networkInterfaces;
+                for (const name of Object.keys(interfaces)) {
+                    const list = interfaces[name];
+                    if (Array.isArray(list)) {
+                        for (const iface of list) {
+                            if (iface && iface.mac && !iface.internal && iface.mac !== "00:00:00:00:00:00") {
+                                return iface.mac;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.warn("Failed to get MAC address from Electron system info:", err);
+        }
+        // Fallback to deriving from Device ID if no network interface is found
+        try {
+            let localId = localStorage.getItem("desktop_device_id");
+            if (!localId) {
+                localId = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : generateUUIDFallback();
+                localStorage.setItem("desktop_device_id", localId);
+            }
+            return uuidToMacAddress(localId);
+        }
+        catch (err) {
+            return "02:00:00:00:00:00";
+        }
+    }
+}
+class WebDevice {
+    async getDeviceId() {
+        let localId = localStorage.getItem("web_device_id");
+        if (!localId) {
+            localId = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : generateUUIDFallback();
+            localStorage.setItem("web_device_id", localId);
+        }
+        return localId;
+    }
+    async getMacAddress() {
+        const deviceId = await this.getDeviceId();
+        return uuidToMacAddress(deviceId);
+    }
+}
+/**
+ * Cross-platform Device utility that delegates unique hardware identity and address querying
+ * to native Capacitor modules, Electron system layers, or persistent Web local storage keys.
+ */
+class Device {
+    impl;
+    static _instance;
+    constructor() {
+        if (Platforms.isMobile()) {
+            this.impl = new CapacitorDevice();
+        }
+        else if (Platforms.isDesktop()) {
+            this.impl = new ElectronDevice();
+        }
+        else {
+            this.impl = new WebDevice();
+        }
+    }
+    /**
+     * Singleton instance of the Device utility.
+     */
+    static get instance() {
+        if (!Device._instance) {
+            Device._instance = new Device();
+        }
+        return Device._instance;
+    }
+    /**
+     * Retrieves the physical network interface MAC address of the host machine (desktop)
+     * or a derived stable custom MAC identifier matching the hardware device profile.
+     * @returns A promise resolving to the MAC address string.
+     */
+    getMacAddress() {
+        return this.impl.getMacAddress();
+    }
+    /**
+     * Retrieves a platform-specific persistent unique device identifier.
+     * @returns A promise resolving to the device ID string.
+     */
+    getDeviceId() {
+        return this.impl.getDeviceId();
+    }
+}
+
+/**
+ * Generates a highly unique, stable client fingerprint based on canvas pixel drawings
+ * and key browser navigator settings to serve as an offline-first fallback.
+ * @returns A positive hexadecimal hash representing the device metrics signature.
+ */
+function getLocalBrowserFingerprint() {
+    if (typeof window === "undefined" || typeof navigator === "undefined") {
+        return "server-fingerprint";
+    }
+    const parts = [
+        navigator.userAgent || "",
+        navigator.language || "",
+        navigator.deviceMemory || "",
+        navigator.hardwareConcurrency || "",
+        typeof screen !== "undefined" ? screen.width : "",
+        typeof screen !== "undefined" ? screen.height : "",
+        typeof screen !== "undefined" ? screen.colorDepth : "",
+        new Date().getTimezoneOffset(),
+        typeof Intl !== "undefined" ? Intl.DateTimeFormat().resolvedOptions().timeZone : "",
+    ];
+    // Canvas fingerprint
+    try {
+        const canvas = document.createElement("canvas");
+        const ctx = canvas.getContext("2d");
+        if (ctx) {
+            canvas.width = 200;
+            canvas.height = 50;
+            ctx.textBaseline = "alphabetic";
+            ctx.fillStyle = "#f60";
+            ctx.fillRect(125, 1, 62, 20);
+            ctx.fillStyle = "#069";
+            ctx.fillText("Quan ERP Fingerprint", 2, 15);
+            ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
+            ctx.fillText("Quan ERP Fingerprint", 4, 17);
+            parts.push(canvas.toDataURL());
+        }
+    }
+    catch (e) {
+        // ignore canvas failures
+    }
+    const str = parts.join("|||");
+    let hash = 2166136261;
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16);
+}
+class CapacitorDeviceFingerprint {
+    async getFingerprint() {
+        try {
+            const fp = await FingerprintJS.load();
+            const result = await fp.get();
+            return result.visitorId;
+        }
+        catch (err) {
+            // Fallback to local browser fingerprint combined with device ID
+            try {
+                const deviceId = await Device.instance.getDeviceId();
+                return `cap-${deviceId}-${getLocalBrowserFingerprint()}`;
+            }
+            catch (fallbackErr) {
+                return `cap-fallback-${getLocalBrowserFingerprint()}`;
+            }
+        }
+    }
+}
+class ElectronDeviceFingerprint {
+    async getFingerprint() {
+        // For desktop, retrieve the MAC address from Device singleton
+        try {
+            const mac = await Device.instance.getMacAddress();
+            if (mac && mac !== "02:00:00:00:00:00") {
+                return mac;
+            }
+        }
+        catch (err) {
+            console.warn("Failed to get desktop MAC address fingerprint:", err);
+        }
+        // Fallback to local desktop device ID
+        try {
+            return await Device.instance.getDeviceId();
+        }
+        catch (err) {
+            return `desktop-fallback-${getLocalBrowserFingerprint()}`;
+        }
+    }
+}
+class WebDeviceFingerprint {
+    async getFingerprint() {
+        try {
+            const fp = await FingerprintJS.load();
+            const result = await fp.get();
+            return result.visitorId;
+        }
+        catch (err) {
+            // Fallback to local canvas fingerprint combined with local storage ID
+            try {
+                const deviceId = await Device.instance.getDeviceId();
+                return `web-${deviceId}-${getLocalBrowserFingerprint()}`;
+            }
+            catch (fallbackErr) {
+                return `web-fallback-${getLocalBrowserFingerprint()}`;
+            }
+        }
+    }
+}
+/**
+ * Cross-platform Device Fingerprint tracking utility that delegates fingerprinting queries
+ * to native physical hardware parameters on desktop (e.g. MAC address) and FingerprintJS
+ * npm package on web, PWA, or Capacitor.
+ */
+class DeviceFingerprint {
+    impl;
+    static _instance;
+    constructor() {
+        if (Platforms.isDesktop()) {
+            this.impl = new ElectronDeviceFingerprint();
+        }
+        else if (Platforms.isMobile()) {
+            this.impl = new CapacitorDeviceFingerprint();
+        }
+        else {
+            this.impl = new WebDeviceFingerprint();
+        }
+    }
+    /**
+     * Singleton instance of the DeviceFingerprint utility.
+     */
+    static get instance() {
+        if (!DeviceFingerprint._instance) {
+            DeviceFingerprint._instance = new DeviceFingerprint();
+        }
+        return DeviceFingerprint._instance;
+    }
+    /**
+     * Retrieves the platform-optimized unique device fingerprint identifier.
+     * @returns A promise resolving to the visitor/device fingerprint string.
+     */
+    getFingerprint() {
+        return this.impl.getFingerprint();
+    }
+}
+
+/**
+ * Utility class for parsing, checking, and comparing Semantic Versioning (SemVer) format strings.
+ */
+class Version {
+    /**
+     * Compares two semantic version strings to determine their precedence.
+     * Supports basic SemVer standards (`major.minor.patch[-prerelease]`).
+     *
+     * @param version The source version string to compare.
+     * @param withVersion The target version string to compare against.
+     * @returns `1` if the source version is newer, `-1` if the target is newer, or `0` if they are identical.
+     */
+    static compare(version, withVersion) {
+        // Strip out optional prefixes (like 'v')
+        const cleanA = version.replace(/^v/, '');
+        const cleanB = withVersion.replace(/^v/, '');
+        // Split major, minor, patch and extract numeric tokens
+        const partsA = cleanA.split('-')[0].split('.').map(Number);
+        const partsB = cleanB.split('-')[0].split('.').map(Number);
+        const maxLength = Math.max(partsA.length, partsB.length);
+        for (let i = 0; i < maxLength; i++) {
+            const valA = partsA[i] || 0;
+            const valB = partsB[i] || 0;
+            if (valA > valB)
+                return 1;
+            if (valA < valB)
+                return -1;
+        }
+        // Handle optional pre-release tag comparisons (e.g. "1.0.0-beta.1" vs "1.0.0")
+        const tagA = cleanA.includes('-') ? cleanA.substring(cleanA.indexOf('-') + 1) : '';
+        const tagB = cleanB.includes('-') ? cleanB.substring(cleanB.indexOf('-') + 1) : '';
+        if (tagA && !tagB) {
+            // A has pre-release tag, B does not. Pre-release is mathematically older/lower priority
+            return -1;
+        }
+        if (!tagA && tagB) {
+            // B has pre-release tag, A does not. B is older/lower priority
+            return 1;
+        }
+        if (tagA && tagB) {
+            // Both have pre-release tags, compare lexicographically
+            if (tagA > tagB)
+                return 1;
+            if (tagA < tagB)
+                return -1;
+        }
+        return 0;
+    }
+    /**
+     * Determines whether transitioning from an old version to a new version introduces breaking changes.
+     * Breaking changes are defined as a change in the major version component (e.g., `1.x.x` to `2.x.x`).
+     *
+     * @param oldV The existing/old version string.
+     * @param newV The incoming/new version string.
+     * @returns `true` if a major upgrade bump occurs, `false` otherwise.
+     */
+    static isBreakingChange(oldV, newV) {
+        const [oldMajor] = oldV.split('.').map(Number);
+        const [newMajor] = newV.split('.').map(Number);
+        return newMajor > oldMajor;
+    }
+    /**
+     * Performs a comprehensive version shift analysis, providing flag indicators.
+     *
+     * @param oldV The existing reference version.
+     * @param newV The target version to analyze.
+     * @returns A structured result state describing the upgrade relationship.
+     */
+    static analyzeVersion(oldV, newV) {
+        const comparedResult = Version.compare(oldV, newV);
+        return {
+            isNewer: comparedResult === -1,
+            isOlder: comparedResult === 1,
+            isSame: comparedResult === 0,
+            isBreaking: Version.isBreakingChange(oldV, newV)
+        };
+    }
+}
+
+class ResponseDto {
+    status;
+    message;
+    payload;
+}
+class RequestDto {
+    payload;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+
+export { Accelerometer, Battery, Bluetooth, Camera, CapacitorAccelerometer, CapacitorBluetooth, CapacitorCamera, CapacitorClipboard, CapacitorFileSystem, CapacitorGyroscope, CapacitorLocation, CapacitorNotifications, Clipboard, Database, Device, DeviceClassDetector, DeviceFingerprint, ElectronAccelerometer, ElectronBluetooth, ElectronCamera, ElectronClipboard, ElectronFileSystem, ElectronGyroscope, ElectronLocation, ElectronMicrophone, ElectronNotifications, ElectronPrinter, ElectronSystem, ElectronVibration, FileSystem, Gryoscope, Location, Microphone, MobilePrinter, MotionOrientation, Network, Notifications, NumberFormatter, Orientation, Permissions, Platforms, PluginAPI, PluginAssets, Printer, RequestDto, ResponseDto, SQLitePlaceholder, System, SystemLocale, UserHandBehaviorDetector, Version, Vibration, WebAccelerometer, WebBluetooth, WebCamera, WebClipboard, WebFileSystem, WebGyroscope, WebLocation, WebNotifications, WebPrinter, WebVibration, getBackendAPI, setBackendAPI };