@nitra/zebra 6.2.0 → 7.0.0

package/dist/plugin.js

@@ -1,1297 +1,843 @@
-import { WebPlugin, registerPlugin } from '@capacitor/core';
-
-/**
- * ZebraPrinterWeb - Web implementation for development
- *
- * Uses local printer-server.js (TCP/IP) or Web Bluetooth API.
- * Falls back to BLE when TCP/IP is not available (like iOS).
- *
- * Production (iOS) uses the native BLE implementation.
- */
-/**
- * @typedef {import('../definitions').EchoOptions} EchoOptions
- * @typedef {import('../definitions').EchoResult} EchoResult
- * @typedef {import('../definitions').PrintTextOptions} PrintTextOptions
- * @typedef {import('../definitions').PrintResult} PrintResult
- * @typedef {import('../definitions').PrinterStatus} PrinterStatus
- * @typedef {import('../definitions').PrinterStatusResult} PrinterStatusResult
- * @typedef {import('../definitions').ScanResult} ScanResult
- * @typedef {import('../definitions').ConnectOptions} ConnectOptions
- * @typedef {import('../definitions').ConnectResult} ConnectResult
- * @typedef {import('../definitions').DisconnectResult} DisconnectResult
- * @typedef {import('../definitions').PermissionResult} PermissionResult
- */
-
-const API_BASE = '/api/printer';
-
-// Zebra printer BLE service UUIDs
-const ZEBRA_SERVICE_UUID = '38eb4a80-c570-11e3-9507-0002a5d5c51b';
-const ZEBRA_WRITE_CHAR_UUID = '38eb4a82-c570-11e3-9507-0002a5d5c51b';
-// Alternative service for some Zebra models
-const ZEBRA_SPP_SERVICE_UUID = '00001101-0000-1000-8000-00805f9b34fb';
-
-// LocalStorage key for persisting printer settings
-const STORAGE_KEY = 'zebra_printer_settings';
-
-class ZebraPrinterWeb extends WebPlugin {
-  constructor() {
-    super();
-    this.serviceAvailable = null;
-    this.defaultSubnet = this._getDefaultSubnet();
-    // BLE state
-    this.bleDevice = null;
-    this.bleServer = null;
-    this.bleCharacteristic = null;
-    this.discoveredBleDevices = [];
-    // Load last printer from localStorage
-    this.connectedPrinter = this._loadFromStorage();
-    if (this.connectedPrinter) {
-      console.log(
-        '[Storage] Loaded:',
-        this.connectedPrinter.name || this.connectedPrinter.ip
-      );
-    }
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // LOCAL STORAGE PERSISTENCE
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Load printer settings from localStorage
-   * @returns {Object|null} Saved printer settings or null
-   */
-  _loadFromStorage() {
-    try {
-      if (typeof localStorage === 'undefined') return null;
-      const saved = localStorage.getItem(STORAGE_KEY);
-      return saved ? JSON.parse(saved) : null;
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Save printer settings to localStorage
-   * @param {Object} printer - Printer settings to save
-   */
-  _saveToStorage(printer) {
-    try {
-      if (typeof localStorage === 'undefined') return;
-      if (printer) {
-        // Don't save BLE device reference (can't be serialized)
-        const toSave = { ...printer };
-        delete toSave.bleDevice;
-        localStorage.setItem(STORAGE_KEY, JSON.stringify(toSave));
-        console.log('[Storage] Saved:', toSave.name || toSave.ip);
-      } else {
-        localStorage.removeItem(STORAGE_KEY);
-        console.log('[Storage] Cleared');
-      }
-    } catch {
-      // Ignore storage errors
-    }
-  }
-
-  /**
-   * Clear saved printer from localStorage
-   * @returns {{success: boolean, message: string}} Result object
-   */
-  clearSavedPrinter() {
-    this._saveToStorage(null);
-    return { success: true, message: 'Saved printer cleared' };
-  }
-
-  /**
-   * Check if Web Bluetooth is supported
-   * @returns {boolean} True if Web Bluetooth API is available
-   */
-  _isBleSupported() {
-    return (
-      typeof navigator !== 'undefined' && navigator.bluetooth !== undefined
-    );
-  }
-
-  /**
-   * Delay helper for BLE chunk sending
-   * @param {number} ms - Milliseconds to delay
-   * @returns {Promise<void>} Resolves after delay
-   */
-  _delay(ms) {
-    const { promise, resolve } = Promise.withResolvers();
-    setTimeout(resolve, ms);
-    return promise;
-  }
-
-  /**
-   * Check if printer-server is reachable
-   * @returns {Promise<boolean>} True if reachable
-   */
-  async _checkService() {
-    if (this.serviceAvailable !== null) {
-      return this.serviceAvailable;
-    }
-
-    try {
-      const response = await fetch(`${API_BASE}/status`, {
-        method: 'GET',
-        headers: { 'Content-Type': 'application/json' },
-      });
-      const data = await response.json();
-      this.serviceAvailable = data.success === true;
-      return this.serviceAvailable;
-    } catch (error) {
-      console.warn('ZebraPrinter: service check failed', error);
-      this.serviceAvailable = false;
-      return false;
-    }
-  }
-
-  /**
-   * Scan for BLE printers using Web Bluetooth API
-   * @returns {Promise<ScanResult>} List of discovered BLE printers
-   */
-  async _scanBlePrinters() {
-    if (!this._isBleSupported()) {
-      return {
-        success: false,
-        error: 'Web Bluetooth is not supported in this browser',
-        printers: [],
-        count: 0,
-      };
-    }
-
-    try {
-      console.log('[BLE] Scanning...');
-
-      // Request device with Zebra name prefixes
-      const device = await navigator.bluetooth.requestDevice({
-        filters: [
-          { namePrefix: 'Zebra' },
-          { namePrefix: 'ZT' },
-          { namePrefix: 'ZD' },
-          { namePrefix: 'ZQ' },
-          { namePrefix: 'XXZHN' },
-        ],
-        optionalServices: [ZEBRA_SERVICE_UUID, ZEBRA_SPP_SERVICE_UUID],
-      });
-
-      console.log('[BLE] Found:', device.name);
-
-      // Store discovered device
-      if (!this.discoveredBleDevices.some((d) => d.id === device.id)) {
-        this.discoveredBleDevices.push(device);
-      }
-
-      return {
-        success: true,
-        printers: this.discoveredBleDevices.map((d) => ({
-          name: d.name || 'Zebra Printer',
-          address: d.id,
-          type: 'bluetooth',
-          paired: false,
-        })),
-        count: this.discoveredBleDevices.length,
-      };
-    } catch (error) {
-      console.warn('[BLE] Scan failed:', error.message);
-      return {
-        success: false,
-        error: error.message || 'BLE scan failed',
-        printers: [],
-        count: 0,
-      };
-    }
-  }
-
-  /**
-   * Connect to a BLE printer
-   * @param {string} deviceId - Device ID from scan
-   * @returns {Promise<ConnectResult>} Connection result with success status
-   */
-  async _connectBle(deviceId) {
-    if (!this._isBleSupported()) {
-      return {
-        success: false,
-        connected: false,
-        error: 'Web Bluetooth is not supported',
-      };
-    }
-
-    try {
-      let device = this.discoveredBleDevices.find((d) => d.id === deviceId);
-
-      // If device not found, request new device
-      if (!device) {
-        console.log('[BLE] Device not cached, requesting...');
-        device = await navigator.bluetooth.requestDevice({
-          filters: [
-            { namePrefix: 'Zebra' },
-            { namePrefix: 'ZT' },
-            { namePrefix: 'ZD' },
-            { namePrefix: 'ZQ' },
-            { namePrefix: 'XXZHN' },
-          ],
-          optionalServices: [ZEBRA_SERVICE_UUID, ZEBRA_SPP_SERVICE_UUID],
-        });
-        this.discoveredBleDevices.push(device);
-      }
-
-      console.log('[BLE] Connecting to', device.name);
-
-      // Connect to GATT server
-      this.bleServer = await device.gatt.connect();
-      this.bleDevice = device;
-
-      console.log('[BLE] GATT connected');
-
-      // Try to get Zebra service
-      let service;
-      try {
-        service = await this.bleServer.getPrimaryService(ZEBRA_SERVICE_UUID);
-        console.log('[BLE] Found Zebra service');
-      } catch {
-        // Try alternative service
-        console.log('[BLE] Trying alternative services...');
-        const services = await this.bleServer.getPrimaryServices();
-        console.log('[BLE] Found', services.length, 'services');
-
-        for (const svc of services) {
-          console.log(`  - Service: ${svc.uuid}`);
-          try {
-            const chars = await svc.getCharacteristics();
-            for (const char of chars) {
-              console.log(
-                `    - Characteristic: ${char.uuid}, props:`,
-                char.properties
-              );
-              if (
-                char.properties.write ||
-                char.properties.writeWithoutResponse
-              ) {
-                service = svc;
-                this.bleCharacteristic = char;
-                console.log('[BLE] Found writable characteristic');
-                break;
-              }
-            }
-            if (this.bleCharacteristic) break;
-          } catch {
-            console.warn('[BLE] Could not get characteristics for', svc.uuid);
-          }
-        }
-      }
-
-      // Get write characteristic if not found yet
-      if (service && !this.bleCharacteristic) {
-        try {
-          this.bleCharacteristic = await service.getCharacteristic(
-            ZEBRA_WRITE_CHAR_UUID
-          );
-          console.log('[BLE] Found Zebra write characteristic');
-        } catch {
-          // Find any writable characteristic
-          const chars = await service.getCharacteristics();
-          for (const char of chars) {
-            if (char.properties.write || char.properties.writeWithoutResponse) {
-              this.bleCharacteristic = char;
-              console.log('[BLE] Found alternative write characteristic');
-              break;
-            }
-          }
-        }
-      }
-
-      if (!this.bleCharacteristic) {
-        throw new Error('No writable characteristic found on printer');
-      }
-
-      // Update connected printer state
-      this.connectedPrinter = {
-        name: device.name || 'Zebra Printer',
-        address: device.id,
-        type: 'bluetooth',
-        bleDevice: device,
-      };
-
-      // Save to localStorage (without bleDevice reference)
-      this._saveToStorage(this.connectedPrinter);
-
-      // Listen for disconnection
-      device.addEventListener('gattserverdisconnected', () => {
-        console.log('[BLE] Disconnected');
-        this.bleDevice = null;
-        this.bleServer = null;
-        this.bleCharacteristic = null;
-        if (this.connectedPrinter?.type === 'bluetooth') {
-          this.connectedPrinter = null;
-        }
-      });
-
-      return {
-        success: true,
-        connected: true,
-        address: device.id,
-        type: 'bluetooth',
-        message: `Connected to ${device.name}`,
-      };
-    } catch (error) {
-      console.error('[BLE] Connection failed:', error);
-      return {
-        success: false,
-        connected: false,
-        error: error.message || 'BLE connection failed',
-      };
-    }
-  }
-
-  /**
-   * Send data to BLE printer in chunks
-   * @param {string} data - Data to send
-   * @returns {Promise<boolean>} True if data sent successfully
-   */
-  async _sendBlePrint(data) {
-    if (!this.bleCharacteristic) {
-      console.error('[BLE] No characteristic available');
-      return false;
-    }
-
-    try {
-      const encoder = new TextEncoder();
-      const bytes = encoder.encode(data);
-      const MTU_SIZE = 20; // Standard BLE MTU
-
-      console.log('[BLE] Sending', bytes.length, 'bytes');
-
-      for (let offset = 0; offset < bytes.length; offset += MTU_SIZE) {
-        const chunk = bytes.slice(
-          offset,
-          Math.min(offset + MTU_SIZE, bytes.length)
-        );
-
-        if (this.bleCharacteristic.properties.writeWithoutResponse) {
-          await this.bleCharacteristic.writeValueWithoutResponse(chunk);
-        } else {
-          await this.bleCharacteristic.writeValue(chunk);
-        }
-
-        // Small delay between chunks like iOS
-        if (offset + MTU_SIZE < bytes.length) {
-          await this._delay(50);
-        }
-      }
-
-      console.log('[BLE] Data sent');
-      return true;
-    } catch (error) {
-      console.error('[BLE] Send failed:', error);
-      return false;
-    }
-  }
-
-  /**
-   * Disconnect BLE printer
-   */
-  _disconnectBle() {
-    if (this.bleDevice?.gatt?.connected) {
-      this.bleDevice.gatt.disconnect();
-    }
-    this.bleDevice = null;
-    this.bleServer = null;
-    this.bleCharacteristic = null;
-  }
-
-  /**
-   * Fetch wrapper with error handling
-   * @param {string} endpoint - API route
-   * @param {RequestInit} [options] - Fetch configuration
-   * @returns {Promise<any>} Response JSON
-   */
-  async _fetch(endpoint, options = {}) {
-    try {
-      const response = await fetch(`${API_BASE}${endpoint}`, {
-        headers: { 'Content-Type': 'application/json' },
-        ...options,
-      });
-      return await response.json();
-    } catch (error) {
-      console.warn(`ZebraPrinter Web: ${endpoint} failed -`, error.message);
-      return {
-        success: false,
-        error:
-          'Printer service is not available. Ensure Vite dev server runs with printer-server plugin.',
-        serviceUnavailable: true,
-      };
-    }
-  }
-
-  /**
-   * Derive default subnet from host IP, if possible
-   * @returns {string} Example: "192.168.1" or "10.0.0"
-   */
-  _getDefaultSubnet() {
-    if (typeof window === 'undefined') return '192.168.1';
-    const host = window.location.hostname;
-    const ipMatch = host.match(
-      /^(10|172\.(1[6-9]|2[0-9]|3[0-1])|192\.168)\.(\d+)\.(\d+)$/
-    );
-    if (ipMatch) {
-      return `${ipMatch[1]}.${ipMatch[3]}`;
-    }
-    return '192.168.1';
-  }
-
-  /**
-   * Wrap plain text into a basic ZPL label unless it already looks like ZPL
-   * @param {string} text - Input text or ZPL
-   * @returns {string} ZPL payload
-   */
-  _wrapTextIfNeeded(text) {
-    const isZplLike =
-      typeof text === 'string' &&
-      /\^XA/i.test(text) &&
-      (/\^XZ/i.test(text) || /\^JUS/i.test(text));
-    if (isZplLike) {
-      return text;
-    }
-
-    const safeText = String(text ?? '').replaceAll(/\r?\n/g, String.raw`\&`);
-    return [
-      '^XA',
-      '^CI28',
-      '^FO50,50',
-      '^A0N,30,30',
-      `^FD${safeText}^FS`,
-      '^XZ',
-    ].join('\n');
-  }
-
-  /**
-   * Echo a value
-   * @param {EchoOptions} options - Input data
-   * @returns {Promise<EchoResult & {platform: string, serviceAvailable: boolean}>} Echo result with platform info
-   */
-  async echo(options) {
-    console.log('ZebraPrinter: echo called with options:', options);
-    const serviceOk = await this._checkService();
-    return {
-      value: options.value,
-      platform: 'web',
-      serviceAvailable: serviceOk,
-    };
-  }
-
-  /**
-   * Check if required permissions are granted
-   * @returns {Promise<PermissionResult>} Permission status
-   */
-  async checkPermissions() {
-    const serviceOk = await this._checkService();
-    const bleSupported = this._isBleSupported();
-
-    // With BLE support, we can work even without printer-server
-    const hasPermissions = serviceOk || bleSupported;
-
-    if (!hasPermissions) {
-      console.warn(
-        'ZebraPrinter: no print method available (no printer-server, no BLE)'
-      );
-      return {
-        hasPermissions: false,
-        missingPermissions: ['printer-server', 'bluetooth'],
-        bluetoothSupported: false,
-        bleSupported: false,
-        webMode: true,
-        serviceAvailable: false,
-      };
-    }
-
-    return {
-      hasPermissions: true,
-      missingPermissions: [],
-      bluetoothSupported: bleSupported,
-      bleSupported: bleSupported,
-      webMode: true,
-      serviceAvailable: serviceOk,
-      // New: indicate which methods are available
-      tcpAvailable: serviceOk,
-      bleAvailable: bleSupported,
-    };
-  }
-
-  /**
-   * Request required permissions
-   * @returns {Promise<PermissionResult>} Permission status
-   */
-  async requestPermissions() {
-    // Not needed on web - just check service
-    return await this.checkPermissions();
-  }
-
-  /**
-   * Print text to the connected printer
-   * @param {PrintTextOptions} options - Parameters with ZPL text
-   * @returns {Promise<PrintResult>} Print result
-   */
-  async printText(options) {
-    const { text } = options || {};
-
-    if (!text) {
-      return {
-        success: false,
-        message: 'No text provided for printing',
-        error: 'Missing text parameter',
-      };
-    }
-
-    const zplPayload = this._wrapTextIfNeeded(text);
-
-    // If connected via BLE, use BLE printing
-    if (this.connectedPrinter?.type === 'bluetooth' && this.bleCharacteristic) {
-      console.log('[BLE] Printing...');
-      const success = await this._sendBlePrint(zplPayload);
-
-      if (success) {
-        return {
-          success: true,
-          message: 'Print successful (BLE)',
-          zpl: `${zplPayload.slice(0, 100)}...`,
-          bytes: zplPayload.length,
-          method: 'bluetooth',
-        };
-      }
-
-      return {
-        success: false,
-        message: 'BLE print failed',
-        error: 'Failed to send data to printer via Bluetooth',
-      };
-    }
-
-    // Otherwise use TCP/IP via printer-server
-    const result = await this._fetch('/print', {
-      method: 'POST',
-      body: JSON.stringify({
-        zpl: zplPayload,
-        ip: this.connectedPrinter?.ip,
-      }),
-    });
-
-    if (result.success) {
-      return {
-        success: true,
-        message: 'Print successful',
-        zpl: `${zplPayload.slice(0, 100)}...`,
-        bytes: zplPayload.length,
-        method: 'tcp',
-      };
-    }
-
-    return {
-      success: false,
-      message: result.error || 'Print failed',
-      error: result.error,
-    };
-  }
-
-  /**
-   * Get printer status
-   * @returns {Promise<PrinterStatus>} Printer status
-   */
-  async getStatus() {
-    if (!this.connectedPrinter) {
-      return {
-        connected: false,
-        status: 'disconnected',
-      };
-    }
-
-    // BLE connection status
-    if (this.connectedPrinter.type === 'bluetooth') {
-      const isConnected =
-        this.bleDevice?.gatt?.connected === true &&
-        this.bleCharacteristic !== null;
-      return {
-        connected: isConnected,
-        status: isConnected ? 'connected' : 'disconnected',
-        printerAddress: this.connectedPrinter.address,
-        printerType: 'bluetooth',
-      };
-    }
-
-    // TCP/IP status
-    const result = await this._fetch('/check', {
-      method: 'POST',
-      body: JSON.stringify({ ip: this.connectedPrinter.ip }),
-    });
-
-    return {
-      connected: result.reachable === true,
-      status: result.reachable ? 'connected' : 'disconnected',
-      printerAddress: this.connectedPrinter.ip,
-      printerType: 'network',
-    };
-  }
-
-  /**
-   * Check printer status with ZPL command
-   * @returns {Promise<PrinterStatusResult>} Status request result
-   */
-  async checkPrinterStatus() {
-    if (!this.connectedPrinter) {
-      return {
-        success: false,
-        message: 'No printer connected',
-        error: 'Not connected',
-      };
-    }
-
-    const statusCommand = '~HS';
-
-    // BLE status check
-    if (this.connectedPrinter.type === 'bluetooth' && this.bleCharacteristic) {
-      const success = await this._sendBlePrint(statusCommand);
-      return {
-        success,
-        message: success
-          ? 'Status command sent (BLE)'
-          : 'Failed to send status command',
-        command: statusCommand,
-        method: 'bluetooth',
-      };
-    }
-
-    // TCP/IP status check
-    const result = await this._fetch('/print', {
-      method: 'POST',
-      body: JSON.stringify({
-        zpl: statusCommand,
-        ip: this.connectedPrinter.ip,
-      }),
-    });
-
-    return {
-      success: result.success,
-      message: result.success ? 'Status command sent' : result.error,
-      command: statusCommand,
-      method: 'tcp',
-    };
-  }
-
-  /**
-   * Scan for available printers
-   * @param {{subnet?: string, useBle?: boolean, skipCache?: boolean}} [options] - Custom subnet or BLE mode
-   * @returns {Promise<ScanResult>} List of found printers
-   */
-  async scanForPrinters(options = {}) {
-    const { useBle, skipCache } = options;
-    const serviceOk = await this._checkService();
-    const bleSupported = this._isBleSupported();
-
-    // Check if last saved printer is still reachable (fast reconnect)
-    if (!skipCache && !useBle) {
-      const lastPrinter = this._loadFromStorage();
-      if (lastPrinter?.ip && serviceOk) {
-        console.log('[Cache] Checking:', lastPrinter.ip);
-        const check = await this._fetch('/check', {
-          method: 'POST',
-          body: JSON.stringify({ ip: lastPrinter.ip }),
-        });
-
-        if (check.reachable) {
-          console.log('[Cache] Printer reachable');
-          // Auto-connect to last printer
-          this.connectedPrinter = lastPrinter;
-          return {
-            success: true,
-            printers: [
-              {
-                name: lastPrinter.name || `Zebra @ ${lastPrinter.ip}`,
-                address: lastPrinter.ip,
-                type: 'network',
-                paired: true, // Mark as "paired" since it was saved
-              },
-            ],
-            count: 1,
-            fromCache: true,
-            autoConnected: true,
-          };
-        }
-        console.log('[Cache] Printer not reachable, scanning...');
-      }
-    }
-
-    // If explicitly requesting BLE or printer-server not available
-    if (useBle || !serviceOk) {
-      if (!bleSupported) {
-        return {
-          success: false,
-          error:
-            'Web Bluetooth is not supported in this browser. Use Chrome or Edge.',
-          printers: [],
-          count: 0,
-        };
-      }
-
-      console.log('[Web] Using BLE scan...');
-      return await this._scanBlePrinters();
-    }
-
-    const subnet = options.subnet || this.defaultSubnet || '192.168.1';
-
-    // Try TCP/IP scan first
-    const result = await this._fetch(
-      `/scan?subnet=${encodeURIComponent(subnet)}`
-    );
-
-    if (result.success && result.printers?.length > 0) {
-      return {
-        success: true,
-        printers: (result.printers || []).map((p) => ({
-          name: p.name || `Zebra @ ${p.ip}`,
-          address: p.ip || p.address,
-          type: 'network',
-          paired: false,
-        })),
-        count: result.printers?.length || 0,
-        method: 'tcp',
-      };
-    }
-
-    // Fallback to BLE if TCP/IP found nothing and BLE is supported
-    if (bleSupported) {
-      console.log('[Web] TCP/IP found nothing, trying BLE...');
-      const bleResult = await this._scanBlePrinters();
-
-      if (bleResult.success) {
-        return {
-          ...bleResult,
-          method: 'bluetooth',
-          tcpFallback: true,
-        };
-      }
-    }
-
-    return {
-      success: false,
-      error: result.error || 'No printers found',
-      printers: [],
-      count: 0,
-      bleAvailable: bleSupported,
-    };
-  }
-
-  /**
-   * Connect to a printer
-   * @param {ConnectOptions} options - Connection parameters
-   * @returns {Promise<ConnectResult>} Connection result
-   */
-  async connect(options) {
-    const { address, type } = options || {};
-
-    // BLE connection (like iOS)
-    if (type === 'bluetooth') {
-      if (!this._isBleSupported()) {
-        return {
-          success: false,
-          connected: false,
-          error:
-            'Web Bluetooth is not supported in this browser. Use Chrome or Edge.',
-        };
-      }
-
-      console.log('[Web] Connecting via BLE...');
-      return await this._connectBle(address);
-    }
-
-    // If no address provided but BLE devices were discovered, connect via BLE
-    if (!address && this.discoveredBleDevices.length > 0) {
-      console.log('[Web] No IP, using discovered BLE device...');
-      return await this._connectBle(this.discoveredBleDevices[0].id);
-    }
-
-    if (!address) {
-      // No address and no BLE devices - try to scan BLE
-      if (this._isBleSupported()) {
-        console.log('[Web] No address, scanning BLE...');
-        const scanResult = await this._scanBlePrinters();
-        if (scanResult.success && scanResult.printers.length > 0) {
-          return await this._connectBle(scanResult.printers[0].address);
-        }
-      }
-
-      return {
-        success: false,
-        connected: false,
-        error: 'Printer address (IP) not provided',
-      };
-    }
-
-    // TCP/IP connection via printer-server
-    const result = await this._fetch('/connect', {
-      method: 'POST',
-      body: JSON.stringify({ ip: address }),
-    });
-
-    if (result.success) {
-      this.connectedPrinter = {
-        ip: address,
-        name: result.printer?.name || `Zebra @ ${address}`,
-        type: 'network',
-      };
-
-      // Save to localStorage for quick reconnect
-      this._saveToStorage(this.connectedPrinter);
-
-      return {
-        success: true,
-        connected: true,
-        address,
-        type: 'network',
-        message: 'Connected to printer',
-      };
-    }
-
-    // If TCP connection failed and BLE is supported, offer BLE as fallback
-    if (this._isBleSupported()) {
-      console.log('[Web] TCP failed, trying BLE...');
-      return await this._connectBle(address);
-    }
-
-    return {
-      success: false,
-      connected: false,
-      error: result.error || 'Connection failed',
-    };
-  }
-
-  /**
-   * Connect to printer by MAC address (web - redirect to IP)
-   * @param {ConnectOptions} options - Connection parameters
-   * @returns {Promise<ConnectResult>} Connection result
-   */
-  async connectByAddress(options) {
-    console.warn('ZebraPrinter Web: connectByAddress - use IP address on web');
-    return await this.connect(options);
-  }
-
-  /**
-   * Check device by address
-   * @param {ConnectOptions} options - Parameters with address
-   * @returns {Promise<ConnectResult>} Reachability info
-   */
-  async checkDeviceByAddress(options) {
-    const { address } = options || {};
-
-    if (!address) {
-      return {
-        success: false,
-        error: 'Address not provided',
-      };
-    }
-
-    const result = await this._fetch('/check', {
-      method: 'POST',
-      body: JSON.stringify({ ip: address }),
-    });
-
-    return {
-      success: true,
-      reachable: result.reachable,
-      address,
-    };
-  }
-
-  /**
-   * Disconnect from the printer
-   * @param {{clearSaved?: boolean}} [options] - Options for disconnect
-   * @returns {Promise<DisconnectResult>} Disconnect result
-   */
-  async disconnect(options = {}) {
-    // Disconnect BLE if connected
-    if (this.connectedPrinter?.type === 'bluetooth') {
-      this._disconnectBle();
-    }
-
-    // Optionally clear saved printer
-    if (options.clearSaved) {
-      this._saveToStorage(null);
-    }
-
-    this.connectedPrinter = null;
-    await Promise.resolve();
-    return {
-      success: true,
-      connected: false,
-    };
-  }
-
-  /**
-   * Get device network info (web not supported directly)
-   * @returns {Promise<{supported: boolean, type: string, error?: string, ip?: string, ssid?: string}>} Network info proxied via printer-server if available
-   */
-  async getNetworkInfo() {
-    const serviceOk = await this._checkService();
-    if (!serviceOk) {
-      return {
-        supported: false,
-        type: 'unknown',
-        error: 'Printer service not available for network info',
-      };
-    }
-
-    const result = await this._fetch('/network-info', { method: 'GET' });
-
-    if (result?.success) {
-      return {
-        supported: true,
-        type: result.type || 'unknown',
-        ip: result.ip,
-        ssid: result.ssid,
-      };
-    }
-
-    return {
-      supported: false,
-      type: 'unknown',
-      error: result?.error || 'Network info not available',
-    };
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // DEV HELPER METHODS
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Get saved printer from localStorage
-   * @returns {Object|null} Saved printer settings
-   */
-  getSavedPrinter() {
-    return this._loadFromStorage();
-  }
-
-  /**
-   * Try to auto-connect to saved printer
-   * @returns {Promise<ConnectResult>} Connection result
-   */
-  async autoConnect() {
-    const savedPrinter = this._loadFromStorage();
-
-    if (!savedPrinter) {
-      return {
-        success: false,
-        connected: false,
-        error: 'No saved printer found',
-      };
-    }
-
-    console.log('[AutoConnect] Trying:', savedPrinter.name);
-
-    // For BLE printers, need to re-scan and connect
-    if (savedPrinter.type === 'bluetooth') {
-      return await this.connect({
-        type: 'bluetooth',
-        address: savedPrinter.address,
-      });
-    }
-
-    // For TCP/IP printers, check if reachable first
-    if (savedPrinter.ip) {
-      const check = await this._fetch('/check', {
-        method: 'POST',
-        body: JSON.stringify({ ip: savedPrinter.ip }),
-      });
-
-      if (check.reachable) {
-        this.connectedPrinter = savedPrinter;
-        return {
-          success: true,
-          connected: true,
-          address: savedPrinter.ip,
-          type: 'network',
-          message: 'Auto-connected to saved printer',
-          fromCache: true,
-        };
-      }
-    }
-
-    return {
-      success: false,
-      connected: false,
-      error: 'Saved printer not reachable',
-    };
-  }
-
-  /**
-   * Show PWA-style printer picker dialog
-   * Creates a native-feeling modal for printer selection
-   * @param {{title?: string, scanOnOpen?: boolean}} [options] - Dialog options
-   * @returns {Promise<{success: boolean, printer?: Object, cancelled?: boolean}>} Selected printer or cancellation
-   */
-  async showPrinterPicker(options = {}) {
-    const { title = 'Select Printer', scanOnOpen = true } = options;
-
-    const { promise, resolve } = Promise.withResolvers();
-
-    // Create modal container
-    const overlay = document.createElement('div');
-    overlay.id = 'zebra-printer-picker';
-    overlay.innerHTML = this._getPickerHTML(title);
-    document.body.append(overlay);
-
-    // Store state for this picker instance
-    const pickerState = {
-      printers: [],
-      resolve,
-      cleanup: () => overlay.remove(),
-    };
-
-    // Setup event handlers
-    this._setupPickerEvents(overlay, pickerState);
-
-    // Auto-scan if requested
-    if (scanOnOpen) {
-      await this._updatePickerPrinters(overlay, {});
-    }
-
-    return promise;
-  }
-
-  /**
-   * Get picker HTML template
-   * @private
-   * @param {string} title - Dialog title
-   * @returns {string} HTML string
-   */
-  _getPickerHTML(title) {
-    const bleButton = this._isBleSupported()
-      ? '<button class="zpp-btn zpp-btn-ble" data-action="ble">BLE</button>'
-      : '';
-
-    return `
-      <style>
-        #zebra-printer-picker {
-          position: fixed;
-          inset: 0;
-          z-index: 999999;
-          display: flex;
-          align-items: center;
-          justify-content: center;
-          background: rgba(0, 0, 0, 0.5);
-          backdrop-filter: blur(4px);
-          font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-        }
-        .zpp-modal {
-          background: white;
-          border-radius: 16px;
-          width: 90%;
-          max-width: 400px;
-          max-height: 80vh;
-          overflow: hidden;
-          box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
-          animation: zpp-slideUp 0.3s ease-out;
-        }
-        @keyframes zpp-slideUp {
-          from { opacity: 0; transform: translateY(20px); }
-          to { opacity: 1; transform: translateY(0); }
-        }
-        .zpp-header {
-          padding: 20px;
-          border-bottom: 1px solid #e5e7eb;
-          display: flex;
-          align-items: center;
-          justify-content: space-between;
-        }
-        .zpp-header h2 { margin: 0; font-size: 18px; font-weight: 600; color: #111827; }
-        .zpp-close { background: none; border: none; padding: 8px; cursor: pointer; border-radius: 8px; color: #6b7280; font-size: 18px; }
-        .zpp-close:hover { background: #f3f4f6; }
-        .zpp-content { padding: 16px; max-height: 400px; overflow-y: auto; }
-        .zpp-loading { text-align: center; padding: 40px 20px; color: #6b7280; }
-        .zpp-spinner {
-          width: 40px; height: 40px;
-          border: 3px solid #e5e7eb; border-top-color: #3b82f6;
-          border-radius: 50%; animation: zpp-spin 1s linear infinite;
-          margin: 0 auto 16px;
-        }
-        @keyframes zpp-spin { to { transform: rotate(360deg); } }
-        .zpp-list { list-style: none; margin: 0; padding: 0; }
-        .zpp-item {
-          display: flex; align-items: center; padding: 16px;
-          border: 1px solid #e5e7eb; border-radius: 12px;
-          margin-bottom: 8px; cursor: pointer; transition: all 0.15s ease;
-        }
-        .zpp-item:hover { border-color: #3b82f6; background: #eff6ff; }
-        .zpp-item.saved { border-color: #10b981; background: #ecfdf5; }
-        .zpp-icon {
-          width: 40px; height: 40px; background: #f3f4f6; border-radius: 10px;
-          display: flex; align-items: center; justify-content: center;
-          margin-right: 12px; font-size: 20px;
-        }
-        .zpp-info { flex: 1; }
-        .zpp-name { font-weight: 500; color: #111827; margin-bottom: 2px; }
-        .zpp-addr { font-size: 13px; color: #6b7280; }
-        .zpp-badge { font-size: 11px; padding: 2px 8px; border-radius: 9999px; background: #10b981; color: white; margin-left: 8px; }
-        .zpp-empty { text-align: center; padding: 40px 20px; color: #6b7280; }
-        .zpp-actions { padding: 16px; border-top: 1px solid #e5e7eb; display: flex; gap: 8px; }
-        .zpp-btn {
-          flex: 1; padding: 12px 16px; border-radius: 10px;
-          font-size: 14px; font-weight: 500; cursor: pointer;
-          border: none; transition: all 0.15s ease;
-        }
-        .zpp-btn-secondary { background: #f3f4f6; color: #374151; }
-        .zpp-btn-secondary:hover { background: #e5e7eb; }
-        .zpp-btn-primary { background: #3b82f6; color: white; }
-        .zpp-btn-primary:hover { background: #2563eb; }
-        .zpp-btn-ble { background: #8b5cf6; color: white; }
-        .zpp-btn-ble:hover { background: #7c3aed; }
-      </style>
-      <div class="zpp-modal">
-        <div class="zpp-header">
-          <h2>${title}</h2>
-          <button class="zpp-close" data-action="close">✕</button>
-        </div>
-        <div class="zpp-content">
-          <div class="zpp-loading">
-            <div class="zpp-spinner"></div>
-            <div>Searching for printers...</div>
-          </div>
-        </div>
-        <div class="zpp-actions">
-          <button class="zpp-btn zpp-btn-secondary" data-action="cancel">Cancel</button>
-          <button class="zpp-btn zpp-btn-primary" data-action="rescan">Rescan</button>
-          ${bleButton}
-        </div>
-      </div>
-    `;
-  }
-
-  /**
-   * Setup picker event handlers
-   * @private
-   * @param {HTMLElement} overlay - Picker overlay element
-   * @param {Object} state - Picker state object
-   */
-  _setupPickerEvents(overlay, state) {
-    // Handle button clicks
-    overlay.addEventListener('click', async (e) => {
-      const action = e.target.dataset?.action;
-
-      if (action === 'close' || action === 'cancel') {
-        state.cleanup();
-        state.resolve({ success: false, cancelled: true });
-        return;
-      }
-
-      if (action === 'rescan') {
-        await this._updatePickerPrinters(overlay, { skipCache: true });
-        return;
-      }
-
-      if (action === 'ble') {
-        await this._updatePickerPrinters(overlay, { useBle: true });
-        return;
-      }
-
-      // Check if clicked on printer item
-      const item = e.target.closest('.zpp-item');
-      if (item) {
-        const printer = {
-          address: item.dataset.address,
-          type: item.dataset.type,
-          name: item.dataset.name,
-        };
-
-        state.cleanup();
-
-        // Auto-connect to selected printer
-        const connectResult = await this.connect({
-          address: printer.address,
-          type: printer.type,
-        });
-
-        state.resolve({
-          success: connectResult.success,
-          printer: connectResult.success ? printer : undefined,
-          error: connectResult.error,
-        });
-      }
-    });
-
-    // Close on overlay click (outside modal)
-    overlay.addEventListener('click', (e) => {
-      if (e.target === overlay) {
-        state.cleanup();
-        state.resolve({ success: false, cancelled: true });
-      }
-    });
-  }
-
-  /**
-   * Update picker with scanned printers
-   * @private
-   * @param {HTMLElement} overlay - Picker overlay element
-   * @param {Object} options - Scan options
-   */
-  async _updatePickerPrinters(overlay, options) {
-    const content = overlay.querySelector('.zpp-content');
-    const loadingMsg = options.useBle
-      ? 'Scanning for Bluetooth printers...'
-      : 'Searching for printers...';
-
-    content.innerHTML = `
-      <div class="zpp-loading">
-        <div class="zpp-spinner"></div>
-        <div>${loadingMsg}</div>
-      </div>
-    `;
-
-    const result = await this.scanForPrinters(options);
-    const printers = result.printers || [];
-
-    if (printers.length === 0) {
-      content.innerHTML = `
-        <div class="zpp-empty">
-          <div style="font-size: 32px; margin-bottom: 16px; opacity: 0.5;">⎙</div>
-          <div>No printers found</div>
-          <div style="font-size: 13px; margin-top: 8px;">Make sure the printer is on and connected to the network</div>
-        </div>
-      `;
-      return;
-    }
-
-    const savedPrinter = this._loadFromStorage();
-    let html = '<ul class="zpp-list">';
-
-    for (const p of printers) {
-      const isSaved =
-        savedPrinter?.ip === p.address || savedPrinter?.address === p.address;
-      const icon = p.type === 'bluetooth' ? 'BT' : 'IP';
-      const typeLabel = p.type === 'bluetooth' ? 'Bluetooth' : 'Network';
-      const badge = p.paired ? '<span class="zpp-badge">Saved</span>' : '';
-
-      html += `
-        <li class="zpp-item ${isSaved ? 'saved' : ''}" 
-            data-address="${p.address}" 
-            data-type="${p.type}" 
-            data-name="${p.name}">
-          <div class="zpp-icon">${icon}</div>
-          <div class="zpp-info">
-            <div class="zpp-name">${p.name}${badge}</div>
-            <div class="zpp-addr">${p.address} • ${typeLabel}</div>
-          </div>
-        </li>
-      `;
-    }
-
-    html += '</ul>';
-    content.innerHTML = html;
-  }
+import { WebPlugin, registerPlugin } from "@capacitor/core";
+
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region ../node_modules/.bun/consola@3.4.2/node_modules/consola/dist/core.mjs
+function isPlainObject$1(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) return false;
+	if (Symbol.iterator in value) return false;
+	if (Symbol.toStringTag in value) return Object.prototype.toString.call(value) === "[object Module]";
+	return true;
 }
-
-const ZebraPrinter = registerPlugin('ZebraPrinter', {
-  web: () => new ZebraPrinterWeb(),
-  // iOS and Android plugins will be auto-discovered via the Capacitor config
-});
-
-export { ZebraPrinter };
-//# sourceMappingURL=plugin.js.map
+function _defu(baseObject, defaults, namespace = ".", merger) {
+	if (!isPlainObject$1(defaults)) return _defu(baseObject, {}, namespace, merger);
+	const object = Object.assign({}, defaults);
+	for (const key in baseObject) {
+		if (key === "__proto__" || key === "constructor") continue;
+		const value = baseObject[key];
+		if (value === null || value === void 0) continue;
+		if (merger && merger(object, key, value, namespace)) continue;
+		if (Array.isArray(value) && Array.isArray(object[key])) object[key] = [...value, ...object[key]];
+		else if (isPlainObject$1(value) && isPlainObject$1(object[key])) object[key] = _defu(value, object[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
+		else object[key] = value;
+	}
+	return object;
+}
+function createDefu(merger) {
+	return (...arguments_) => arguments_.reduce((p, c) => _defu(p, c, "", merger), {});
+}
+function isPlainObject(obj) {
+	return Object.prototype.toString.call(obj) === "[object Object]";
+}
+function isLogObj(arg) {
+	if (!isPlainObject(arg)) return false;
+	if (!arg.message && !arg.args) return false;
+	if (arg.stack) return false;
+	return true;
+}
+function _normalizeLogLevel(input, types = {}, defaultLevel = 3) {
+	if (input === void 0) return defaultLevel;
+	if (typeof input === "number") return input;
+	if (types[input] && types[input].level !== void 0) return types[input].level;
+	return defaultLevel;
+}
+function createConsola$1(options = {}) {
+	return new Consola(options);
+}
+var LogLevels, LogTypes, defu, paused, queue, Consola;
+var init_core = __esmMin((() => {
+	LogLevels = {
+		silent: Number.NEGATIVE_INFINITY,
+		fatal: 0,
+		error: 0,
+		warn: 1,
+		log: 2,
+		info: 3,
+		success: 3,
+		fail: 3,
+		ready: 3,
+		start: 3,
+		box: 3,
+		debug: 4,
+		trace: 5,
+		verbose: Number.POSITIVE_INFINITY
+	};
+	LogTypes = {
+		silent: { level: -1 },
+		fatal: { level: LogLevels.fatal },
+		error: { level: LogLevels.error },
+		warn: { level: LogLevels.warn },
+		log: { level: LogLevels.log },
+		info: { level: LogLevels.info },
+		success: { level: LogLevels.success },
+		fail: { level: LogLevels.fail },
+		ready: { level: LogLevels.info },
+		start: { level: LogLevels.info },
+		box: { level: LogLevels.info },
+		debug: { level: LogLevels.debug },
+		trace: { level: LogLevels.trace },
+		verbose: { level: LogLevels.verbose }
+	};
+	defu = createDefu();
+	paused = false;
+	queue = [];
+	Consola = class Consola {
+		options;
+		_lastLog;
+		_mockFn;
+		/**
+		* Creates an instance of Consola with specified options or defaults.
+		*
+		* @param {Partial<ConsolaOptions>} [options={}] - Configuration options for the Consola instance.
+		*/
+		constructor(options = {}) {
+			const types = options.types || LogTypes;
+			this.options = defu({
+				...options,
+				defaults: { ...options.defaults },
+				level: _normalizeLogLevel(options.level, types),
+				reporters: [...options.reporters || []]
+			}, {
+				types: LogTypes,
+				throttle: 1e3,
+				throttleMin: 5,
+				formatOptions: {
+					date: true,
+					colors: false,
+					compact: true
+				}
+			});
+			for (const type in types) {
+				const defaults = {
+					type,
+					...this.options.defaults,
+					...types[type]
+				};
+				this[type] = this._wrapLogFn(defaults);
+				this[type].raw = this._wrapLogFn(defaults, true);
+			}
+			if (this.options.mockFn) this.mockTypes();
+			this._lastLog = {};
+		}
+		/**
+		* Gets the current log level of the Consola instance.
+		*
+		* @returns {number} The current log level.
+		*/
+		get level() {
+			return this.options.level;
+		}
+		/**
+		* Sets the minimum log level that will be output by the instance.
+		*
+		* @param {number} level - The new log level to set.
+		*/
+		set level(level) {
+			this.options.level = _normalizeLogLevel(level, this.options.types, this.options.level);
+		}
+		/**
+		* Displays a prompt to the user and returns the response.
+		* Throw an error if `prompt` is not supported by the current configuration.
+		*
+		* @template T
+		* @param {string} message - The message to display in the prompt.
+		* @param {T} [opts] - Optional options for the prompt. See {@link PromptOptions}.
+		* @returns {promise<T>} A promise that infer with the prompt options. See {@link PromptOptions}.
+		*/
+		prompt(message, opts) {
+			if (!this.options.prompt) throw new Error("prompt is not supported!");
+			return this.options.prompt(message, opts);
+		}
+		/**
+		* Creates a new instance of Consola, inheriting options from the current instance, with possible overrides.
+		*
+		* @param {Partial<ConsolaOptions>} options - Optional overrides for the new instance. See {@link ConsolaOptions}.
+		* @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+		*/
+		create(options) {
+			const instance = new Consola({
+				...this.options,
+				...options
+			});
+			if (this._mockFn) instance.mockTypes(this._mockFn);
+			return instance;
+		}
+		/**
+		* Creates a new Consola instance with the specified default log object properties.
+		*
+		* @param {InputLogObject} defaults - Default properties to include in any log from the new instance. See {@link InputLogObject}.
+		* @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+		*/
+		withDefaults(defaults) {
+			return this.create({
+				...this.options,
+				defaults: {
+					...this.options.defaults,
+					...defaults
+				}
+			});
+		}
+		/**
+		* Creates a new Consola instance with a specified tag, which will be included in every log.
+		*
+		* @param {string} tag - The tag to include in each log of the new instance.
+		* @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+		*/
+		withTag(tag) {
+			return this.withDefaults({ tag: this.options.defaults.tag ? this.options.defaults.tag + ":" + tag : tag });
+		}
+		/**
+		* Adds a custom reporter to the Consola instance.
+		* Reporters will be called for each log message, depending on their implementation and log level.
+		*
+		* @param {ConsolaReporter} reporter - The reporter to add. See {@link ConsolaReporter}.
+		* @returns {Consola} The current Consola instance.
+		*/
+		addReporter(reporter) {
+			this.options.reporters.push(reporter);
+			return this;
+		}
+		/**
+		* Removes a custom reporter from the Consola instance.
+		* If no reporter is specified, all reporters will be removed.
+		*
+		* @param {ConsolaReporter} reporter - The reporter to remove. See {@link ConsolaReporter}.
+		* @returns {Consola} The current Consola instance.
+		*/
+		removeReporter(reporter) {
+			if (reporter) {
+				const i = this.options.reporters.indexOf(reporter);
+				if (i !== -1) return this.options.reporters.splice(i, 1);
+			} else this.options.reporters.splice(0);
+			return this;
+		}
+		/**
+		* Replaces all reporters of the Consola instance with the specified array of reporters.
+		*
+		* @param {ConsolaReporter[]} reporters - The new reporters to set. See {@link ConsolaReporter}.
+		* @returns {Consola} The current Consola instance.
+		*/
+		setReporters(reporters) {
+			this.options.reporters = Array.isArray(reporters) ? reporters : [reporters];
+			return this;
+		}
+		wrapAll() {
+			this.wrapConsole();
+			this.wrapStd();
+		}
+		restoreAll() {
+			this.restoreConsole();
+			this.restoreStd();
+		}
+		/**
+		* Overrides console methods with Consola logging methods for consistent logging.
+		*/
+		wrapConsole() {
+			for (const type in this.options.types) {
+				if (!console["__" + type]) console["__" + type] = console[type];
+				console[type] = this[type].raw;
+			}
+		}
+		/**
+		* Restores the original console methods, removing Consola overrides.
+		*/
+		restoreConsole() {
+			for (const type in this.options.types) if (console["__" + type]) {
+				console[type] = console["__" + type];
+				delete console["__" + type];
+			}
+		}
+		/**
+		* Overrides standard output and error streams to redirect them through Consola.
+		*/
+		wrapStd() {
+			this._wrapStream(this.options.stdout, "log");
+			this._wrapStream(this.options.stderr, "log");
+		}
+		_wrapStream(stream, type) {
+			if (!stream) return;
+			if (!stream.__write) stream.__write = stream.write;
+			stream.write = (data) => {
+				this[type].raw(String(data).trim());
+			};
+		}
+		/**
+		* Restores the original standard output and error streams, removing the Consola redirection.
+		*/
+		restoreStd() {
+			this._restoreStream(this.options.stdout);
+			this._restoreStream(this.options.stderr);
+		}
+		_restoreStream(stream) {
+			if (!stream) return;
+			if (stream.__write) {
+				stream.write = stream.__write;
+				delete stream.__write;
+			}
+		}
+		/**
+		* Pauses logging, queues incoming logs until resumed.
+		*/
+		pauseLogs() {
+			paused = true;
+		}
+		/**
+		* Resumes logging, processing any queued logs.
+		*/
+		resumeLogs() {
+			paused = false;
+			const _queue = queue.splice(0);
+			for (const item of _queue) item[0]._logFn(item[1], item[2]);
+		}
+		/**
+		* Replaces logging methods with mocks if a mock function is provided.
+		*
+		* @param {ConsolaOptions["mockFn"]} mockFn - The function to use for mocking logging methods. See {@link ConsolaOptions["mockFn"]}.
+		*/
+		mockTypes(mockFn) {
+			const _mockFn = mockFn || this.options.mockFn;
+			this._mockFn = _mockFn;
+			if (typeof _mockFn !== "function") return;
+			for (const type in this.options.types) {
+				this[type] = _mockFn(type, this.options.types[type]) || this[type];
+				this[type].raw = this[type];
+			}
+		}
+		_wrapLogFn(defaults, isRaw) {
+			return (...args) => {
+				if (paused) {
+					queue.push([
+						this,
+						defaults,
+						args,
+						isRaw
+					]);
+					return;
+				}
+				return this._logFn(defaults, args, isRaw);
+			};
+		}
+		_logFn(defaults, args, isRaw) {
+			if ((defaults.level || 0) > this.level) return false;
+			const logObj = {
+				date: /* @__PURE__ */ new Date(),
+				args: [],
+				...defaults,
+				level: _normalizeLogLevel(defaults.level, this.options.types)
+			};
+			if (!isRaw && args.length === 1 && isLogObj(args[0])) Object.assign(logObj, args[0]);
+			else logObj.args = [...args];
+			if (logObj.message) {
+				logObj.args.unshift(logObj.message);
+				delete logObj.message;
+			}
+			if (logObj.additional) {
+				if (!Array.isArray(logObj.additional)) logObj.additional = logObj.additional.split("\n");
+				logObj.args.push("\n" + logObj.additional.join("\n"));
+				delete logObj.additional;
+			}
+			logObj.type = typeof logObj.type === "string" ? logObj.type.toLowerCase() : "log";
+			logObj.tag = typeof logObj.tag === "string" ? logObj.tag : "";
+			const resolveLog = (newLog = false) => {
+				const repeated = (this._lastLog.count || 0) - this.options.throttleMin;
+				if (this._lastLog.object && repeated > 0) {
+					const args2 = [...this._lastLog.object.args];
+					if (repeated > 1) args2.push(`(repeated ${repeated} times)`);
+					this._log({
+						...this._lastLog.object,
+						args: args2
+					});
+					this._lastLog.count = 1;
+				}
+				if (newLog) {
+					this._lastLog.object = logObj;
+					this._log(logObj);
+				}
+			};
+			clearTimeout(this._lastLog.timeout);
+			const diffTime = this._lastLog.time && logObj.date ? logObj.date.getTime() - this._lastLog.time.getTime() : 0;
+			this._lastLog.time = logObj.date;
+			if (diffTime < this.options.throttle) try {
+				const serializedLog = JSON.stringify([
+					logObj.type,
+					logObj.tag,
+					logObj.args
+				]);
+				const isSameLog = this._lastLog.serialized === serializedLog;
+				this._lastLog.serialized = serializedLog;
+				if (isSameLog) {
+					this._lastLog.count = (this._lastLog.count || 0) + 1;
+					if (this._lastLog.count > this.options.throttleMin) {
+						this._lastLog.timeout = setTimeout(resolveLog, this.options.throttle);
+						return;
+					}
+				}
+			} catch {}
+			resolveLog(true);
+		}
+		_log(logObj) {
+			for (const reporter of this.options.reporters) reporter.log(logObj, { options: this.options });
+		}
+	};
+	Consola.prototype.add = Consola.prototype.addReporter;
+	Consola.prototype.remove = Consola.prototype.removeReporter;
+	Consola.prototype.clear = Consola.prototype.removeReporter;
+	Consola.prototype.withScope = Consola.prototype.withTag;
+	Consola.prototype.mock = Consola.prototype.mockTypes;
+	Consola.prototype.pause = Consola.prototype.pauseLogs;
+	Consola.prototype.resume = Consola.prototype.resumeLogs;
+}));
+
+//#endregion
+//#region ../node_modules/.bun/consola@3.4.2/node_modules/consola/dist/browser.mjs
+function createConsola(options = {}) {
+	return createConsola$1({
+		reporters: options.reporters || [new BrowserReporter({})],
+		prompt(message, options2 = {}) {
+			if (options2.type === "confirm") return Promise.resolve(confirm(message));
+			return Promise.resolve(prompt(message));
+		},
+		...options
+	});
+}
+var BrowserReporter, consola;
+var init_browser$1 = __esmMin((() => {
+	init_core();
+	BrowserReporter = class {
+		options;
+		defaultColor;
+		levelColorMap;
+		typeColorMap;
+		constructor(options) {
+			this.options = { ...options };
+			this.defaultColor = "#7f8c8d";
+			this.levelColorMap = {
+				0: "#c0392b",
+				1: "#f39c12",
+				3: "#00BCD4"
+			};
+			this.typeColorMap = { success: "#2ecc71" };
+		}
+		_getLogFn(level) {
+			if (level < 1) return console.__error || console.error;
+			if (level === 1) return console.__warn || console.warn;
+			return console.__log || console.log;
+		}
+		log(logObj) {
+			const consoleLogFn = this._getLogFn(logObj.level);
+			const type = logObj.type === "log" ? "" : logObj.type;
+			const tag = logObj.tag || "";
+			const style = `
+      background: ${this.typeColorMap[logObj.type] || this.levelColorMap[logObj.level] || this.defaultColor};
+      border-radius: 0.5em;
+      color: white;
+      font-weight: bold;
+      padding: 2px 0.5em;
+    `;
+			const badge = `%c${[tag, type].filter(Boolean).join(":")}`;
+			if (typeof logObj.args[0] === "string") consoleLogFn(`${badge}%c ${logObj.args[0]}`, style, "", ...logObj.args.slice(1));
+			else consoleLogFn(badge, style, ...logObj.args);
+		}
+	};
+	consola = createConsola();
+}));
+
+//#endregion
+//#region ../node_modules/.bun/@nitra+consola@2.3.0/node_modules/@nitra/consola/src/browser.js
+var options, CanvasPopupReporter, isPopupDebugEnabled, canvasPopupReporter, defaultConsola;
+var init_browser = __esmMin((() => {
+	init_browser$1();
+	options = {};
+	if (typeof __CONSOLA_LEVEL_DEBUG__ !== "undefined") options.level = 4;
+	else if (typeof location !== "undefined" && location.protocol === "http:") options.level = 4;
+	else if (typeof process !== "undefined" && (process.env.DEV || process.env.CONSOLA_LEVEL_DEBUG)) options.level = 4;
+	CanvasPopupReporter = class CanvasPopupReporter {
+		static PADDING = 12;
+		static LABEL_PADDING = 8;
+		static LINE_HEIGHT = 20;
+		static BUTTON_SIZE = 18;
+		static BUTTON_PADDING = 6;
+		static MIN_HEIGHT = 36;
+		static MAX_MESSAGE_LENGTH = 500;
+		static FONT_TEXT = "13px -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, sans-serif";
+		static FONT_MONO = "11px monospace";
+		constructor() {
+			this.canvas = null;
+			this.ctx = null;
+			this.messages = [];
+			this.messageId = 0;
+			this.initCanvas();
+		}
+		initCanvas() {
+			if (typeof document === "undefined") return;
+			const init = () => {
+				if (!document.body) {
+					setTimeout(init, 10);
+					return;
+				}
+				let canvas = document.querySelector("#consola-popup-canvas");
+				if (!canvas) {
+					canvas = document.createElement("canvas");
+					canvas.id = "consola-popup-canvas";
+					canvas.style.position = "fixed";
+					canvas.style.top = "0";
+					canvas.style.left = "0";
+					canvas.style.width = "100%";
+					canvas.style.height = "100%";
+					canvas.style.pointerEvents = "auto";
+					canvas.style.zIndex = "999999";
+					document.body.append(canvas);
+					canvas.addEventListener("click", (e) => this.handleClick(e));
+				}
+				this.canvas = canvas;
+				this.resizeCanvas();
+				window.addEventListener("resize", () => this.resizeCanvas());
+				this.animate();
+			};
+			if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", init);
+			else init();
+		}
+		handleClick(event) {
+			if (!this.canvas || !this.ctx) return;
+			const rect = this.canvas.getBoundingClientRect();
+			const x = event.clientX - rect.left;
+			const y = event.clientY - rect.top;
+			for (let i = this.messages.length - 1; i >= 0; i--) {
+				const msg = this.messages[i];
+				if (msg.fileInfo && msg.fileLinkX && msg.fileLinkY && msg.fileLinkWidth) {
+					if (x >= msg.fileLinkX - msg.fileLinkWidth && x <= msg.fileLinkX && y >= msg.fileLinkY && y <= msg.fileLinkY + 14) {
+						console.log(`%c${msg.fileInfo.file}:${msg.fileInfo.line}`, "color: #1976D2; text-decoration: underline;");
+						return;
+					}
+				}
+				const buttonX = msg.x + (msg.width || 200) - CanvasPopupReporter.BUTTON_SIZE - CanvasPopupReporter.BUTTON_PADDING;
+				const buttonY = msg.y + CanvasPopupReporter.BUTTON_PADDING;
+				if (x >= buttonX && x <= buttonX + CanvasPopupReporter.BUTTON_SIZE && y >= buttonY && y <= buttonY + CanvasPopupReporter.BUTTON_SIZE) {
+					const index = this.messages.findIndex((m) => m.id === msg.id);
+					if (index !== -1) this.messages.splice(index, 1);
+					return;
+				}
+			}
+		}
+		resizeCanvas() {
+			if (!this.canvas) return;
+			this.canvas.width = window.innerWidth;
+			this.canvas.height = window.innerHeight;
+			this.ctx = this.canvas.getContext("2d");
+		}
+		getColorForType(type) {
+			const colors = {
+				trace: "#9E9E9E",
+				debug: "#607D8B",
+				info: "#2196F3",
+				log: "#2196F3",
+				warn: "#FFC107",
+				error: "#D32F2F",
+				fatal: "#7B1FA2",
+				success: "#4CAF50",
+				start: "#00BCD4",
+				box: "#9E9E9E",
+				ready: "#4CAF50",
+				fail: "#D32F2F"
+			};
+			return colors[type] || colors.log || "#616161";
+		}
+		getTypeLabel(type) {
+			return type || "log";
+		}
+		getFileInfo() {
+			try {
+				const stack = (/* @__PURE__ */ new Error("Stack trace")).stack;
+				if (!stack) return null;
+				const skipPatterns = [
+					"CanvasPopupReporter",
+					"browser.js",
+					"consola",
+					"createLogger"
+				];
+				const lines = stack.split("\n").slice(4, 15);
+				for (const line of lines) {
+					const trimmed = line.trim();
+					if (!skipPatterns.some((pattern) => trimmed.includes(pattern))) {
+						const match = trimmed.match(/\(?([^()]+):(\d+):(\d+)\)?/) || trimmed.match(/at\s+[^(]*\(?([^:]+):(\d+):(\d+)\)?/);
+						if (match) {
+							let file = match[1].trim();
+							const lineNum = match[2];
+							if (file.includes("://")) file = file.slice(file.indexOf("://") + 3).slice(file.indexOf("/"));
+							if (file.includes("/src/")) file = file.slice(file.indexOf("/src/") + 5);
+							const queryIndex = file.indexOf("?");
+							if (queryIndex > 0) file = file.slice(0, queryIndex);
+							const hashIndex = file.indexOf("#");
+							if (hashIndex > 0) file = file.slice(0, hashIndex);
+							if (file.startsWith("/")) file = file.slice(1);
+							if (file && lineNum) return {
+								file,
+								line: parseInt(lineNum, 10),
+								column: parseInt(match[3], 10),
+								fullPath: match[0]
+							};
+						}
+					}
+				}
+			} catch {}
+			return null;
+		}
+		formatMessage(logObj) {
+			const args = logObj.args || [];
+			if (args.length === 0) return "";
+			const message = args.map((arg) => {
+				if (arg instanceof Error) {
+					let msg = `${arg.name || "Error"}: ${arg.message || ""}`;
+					if (arg.stack && arg.stack !== arg.message) msg += "\n" + arg.stack.split("\n").slice(0, 3).join("\n");
+					return msg;
+				}
+				if (arg === null) return "null";
+				if (arg === void 0) return "undefined";
+				if (typeof arg === "object") try {
+					const str = arg.toString?.();
+					if (str && str !== "[object Object]") return str;
+					return JSON.stringify(arg, null, 2);
+				} catch {
+					return String(arg);
+				}
+				return String(arg);
+			}).join(" ");
+			return message.length > CanvasPopupReporter.MAX_MESSAGE_LENGTH ? message.slice(0, CanvasPopupReporter.MAX_MESSAGE_LENGTH) + "..." : message;
+		}
+		calculateMessageHeight(message, maxWidth) {
+			if (!this.ctx) return CanvasPopupReporter.MIN_HEIGHT;
+			this.ctx.save();
+			this.ctx.font = CanvasPopupReporter.FONT_TEXT;
+			const words = message.split(" ");
+			const lines = [];
+			let currentLine = "";
+			for (const word of words) {
+				const testLine = currentLine ? `${currentLine} ${word}` : word;
+				if (this.ctx.measureText(testLine).width > maxWidth && currentLine) {
+					lines.push(currentLine);
+					currentLine = word;
+				} else currentLine = testLine;
+			}
+			if (currentLine) lines.push(currentLine);
+			this.ctx.restore();
+			return Math.max(CanvasPopupReporter.MIN_HEIGHT, lines.length * CanvasPopupReporter.LINE_HEIGHT + CanvasPopupReporter.PADDING * 2);
+		}
+		log(logObj) {
+			if (!this.canvas || !this.ctx) return;
+			const message = this.formatMessage(logObj);
+			if (!message) return;
+			const type = logObj.type || "log";
+			const color = this.getColorForType(type);
+			const typeLabel = this.getTypeLabel(type);
+			const id = this.messageId++;
+			const fileInfo = this.getFileInfo();
+			this.ctx.save();
+			this.ctx.font = CanvasPopupReporter.FONT_MONO;
+			const labelWidth = this.ctx.measureText(typeLabel).width + 16;
+			let fileLinkWidth = 0;
+			if (fileInfo) {
+				const fileLinkText = `${fileInfo.file}:${fileInfo.line}`;
+				fileLinkWidth = this.ctx.measureText(fileLinkText).width + 12;
+			}
+			this.ctx.restore();
+			const textMaxWidth = this.canvas.width - 40 - labelWidth - CanvasPopupReporter.PADDING * 2 - CanvasPopupReporter.BUTTON_SIZE - CanvasPopupReporter.BUTTON_PADDING - fileLinkWidth;
+			const boxHeight = this.calculateMessageHeight(message, textMaxWidth);
+			this.messages.push({
+				id,
+				text: message,
+				color,
+				type,
+				typeLabel,
+				fileInfo,
+				timestamp: Date.now(),
+				y: this.canvas.height,
+				opacity: 1,
+				x: 20,
+				height: boxHeight,
+				width: 0
+			});
+		}
+		animate() {
+			if (!this.canvas || !this.ctx) return;
+			this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+			let currentY = this.canvas.height - 20;
+			for (let i = this.messages.length - 1; i >= 0; i--) {
+				const msg = this.messages[i];
+				const msgHeight = msg.height || 60;
+				const targetY = currentY - msgHeight;
+				msg.y += (targetY - msg.y) * .1;
+				currentY = targetY - 10;
+				this.ctx.save();
+				this.ctx.globalAlpha = msg.opacity;
+				this.ctx.font = "13px -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, sans-serif";
+				this.ctx.textBaseline = "top";
+				const padding = CanvasPopupReporter.PADDING;
+				const labelPadding = CanvasPopupReporter.LABEL_PADDING;
+				const maxWidth = this.canvas.width - 40;
+				const lineHeight = CanvasPopupReporter.LINE_HEIGHT;
+				this.ctx.font = CanvasPopupReporter.FONT_MONO;
+				const labelWidth = this.ctx.measureText(msg.typeLabel || "log").width + labelPadding * 2;
+				const buttonSize = CanvasPopupReporter.BUTTON_SIZE;
+				const buttonPadding = CanvasPopupReporter.BUTTON_PADDING;
+				let fileLinkWidth = 0;
+				let fileLinkText = "";
+				if (msg.fileInfo) {
+					fileLinkText = `${msg.fileInfo.file}:${msg.fileInfo.line}`;
+					this.ctx.font = CanvasPopupReporter.FONT_MONO;
+					fileLinkWidth = this.ctx.measureText(fileLinkText).width + 12;
+				}
+				this.ctx.font = CanvasPopupReporter.FONT_TEXT;
+				const textMaxWidthForHeight = maxWidth - labelWidth - padding * 2 - fileLinkWidth - buttonSize - buttonPadding;
+				const calculatedHeight = this.calculateMessageHeight(msg.text, textMaxWidthForHeight);
+				if (msg.height !== calculatedHeight) msg.height = calculatedHeight;
+				const words = msg.text.split(" ");
+				const lines = [];
+				let currentLine = "";
+				const textMaxWidth = textMaxWidthForHeight;
+				for (const word of words) {
+					const testLine = currentLine ? currentLine + " " + word : word;
+					if (this.ctx.measureText(testLine).width > textMaxWidth && currentLine) {
+						lines.push(currentLine);
+						currentLine = word;
+					} else currentLine = testLine;
+				}
+				if (currentLine) lines.push(currentLine);
+				const maxTextWidth = lines.length > 0 ? Math.max(...lines.map((line) => this.ctx.measureText(line).width)) : 0;
+				const boxWidth = Math.min(labelWidth + padding * 2 + maxTextWidth + fileLinkWidth + buttonSize + buttonPadding, maxWidth);
+				const boxHeight = Math.max(msg.height || calculatedHeight, CanvasPopupReporter.MIN_HEIGHT);
+				msg.fileLinkX = msg.x + labelWidth + padding * 2 + maxTextWidth;
+				msg.fileLinkY = msg.y + padding;
+				msg.fileLinkWidth = fileLinkWidth;
+				msg.width = boxWidth;
+				this.ctx.fillStyle = "#ffffff";
+				this.ctx.fillRect(msg.x, msg.y, boxWidth, boxHeight);
+				this.ctx.shadowColor = "rgba(0, 0, 0, 0.1)";
+				this.ctx.shadowBlur = 8;
+				this.ctx.shadowOffsetX = 0;
+				this.ctx.shadowOffsetY = 2;
+				this.ctx.fillRect(msg.x, msg.y, boxWidth, boxHeight);
+				this.ctx.shadowBlur = 0;
+				this.ctx.shadowOffsetX = 0;
+				this.ctx.shadowOffsetY = 0;
+				this.ctx.strokeStyle = "#e0e0e0";
+				this.ctx.lineWidth = 1;
+				this.ctx.strokeRect(msg.x, msg.y, boxWidth, boxHeight);
+				this.ctx.fillStyle = msg.color;
+				this.ctx.fillRect(msg.x, msg.y, labelWidth, boxHeight);
+				this.ctx.fillStyle = "#ffffff";
+				this.ctx.font = CanvasPopupReporter.FONT_MONO;
+				this.ctx.fontWeight = "bold";
+				const labelTextY = msg.y + boxHeight / 2 - 6;
+				this.ctx.textAlign = "center";
+				this.ctx.fillText(msg.typeLabel, msg.x + labelWidth / 2, labelTextY);
+				this.ctx.textAlign = "left";
+				this.ctx.fillStyle = "#212121";
+				this.ctx.font = CanvasPopupReporter.FONT_TEXT;
+				const textStartX = msg.x + labelWidth + padding;
+				for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) this.ctx.fillText(lines[lineIndex], textStartX, msg.y + padding + lineIndex * lineHeight, maxTextWidth);
+				if (msg.fileInfo && fileLinkText) {
+					this.ctx.fillStyle = "#1976D2";
+					this.ctx.font = CanvasPopupReporter.FONT_MONO;
+					this.ctx.textAlign = "right";
+					const fileLinkX = msg.x + boxWidth - buttonSize - buttonPadding - 6;
+					const fileLinkY = msg.y + padding + 2;
+					this.ctx.fillText(fileLinkText, fileLinkX, fileLinkY);
+					this.ctx.textAlign = "left";
+					this.ctx.strokeStyle = "#1976D2";
+					this.ctx.lineWidth = 1;
+					const textMetrics = this.ctx.measureText(fileLinkText);
+					this.ctx.beginPath();
+					this.ctx.moveTo(fileLinkX - textMetrics.width, fileLinkY + 11);
+					this.ctx.lineTo(fileLinkX, fileLinkY + 11);
+					this.ctx.stroke();
+				}
+				const buttonX = msg.x + boxWidth - buttonSize - buttonPadding;
+				const buttonY = msg.y + buttonPadding;
+				this.ctx.strokeStyle = "#999999";
+				this.ctx.lineWidth = 1.5;
+				this.ctx.lineCap = "round";
+				const crossPadding = 4;
+				this.ctx.beginPath();
+				this.ctx.moveTo(buttonX + crossPadding, buttonY + crossPadding);
+				this.ctx.lineTo(buttonX + buttonSize - crossPadding, buttonY + buttonSize - crossPadding);
+				this.ctx.moveTo(buttonX + buttonSize - crossPadding, buttonY + crossPadding);
+				this.ctx.lineTo(buttonX + crossPadding, buttonY + buttonSize - crossPadding);
+				this.ctx.stroke();
+				this.ctx.restore();
+			}
+			requestAnimationFrame(() => this.animate());
+		}
+	};
+	isPopupDebugEnabled = false;
+	if (typeof document !== "undefined") try {
+		const envValue = import.meta.env?.VITE_CONSOLA_POPUP_DEBUG;
+		if (envValue !== void 0 && envValue !== null && envValue !== "") isPopupDebugEnabled = String(envValue).toLowerCase() === "true" || envValue === true;
+	} catch {}
+	if (!isPopupDebugEnabled && typeof process !== "undefined" && process.env) {
+		const processValue = process.env.VITE_CONSOLA_POPUP_DEBUG;
+		if (processValue) isPopupDebugEnabled = String(processValue).toLowerCase() === "true";
+	}
+	canvasPopupReporter = null;
+	if (isPopupDebugEnabled && typeof document !== "undefined") canvasPopupReporter = new CanvasPopupReporter();
+	defaultConsola = consola.create(options);
+	if (isPopupDebugEnabled && typeof document !== "undefined" && canvasPopupReporter) defaultConsola.addReporter(canvasPopupReporter);
+}));
+
+//#endregion
+//#region src/web.js
+var web_exports = /* @__PURE__ */ __exportAll({ ZebraWeb: () => ZebraWeb });
+var ZebraWeb;
+var init_web = __esmMin((() => {
+	init_browser();
+	ZebraWeb = class extends WebPlugin {
+		async print(zpl) {
+			try {
+				defaultConsola.debug("Запит на підключення до принтера...", "info");
+				const port = await navigator.serial.requestPort();
+				defaultConsola.debug("Порт вибрано, відкриваємо з'єднання...", "info");
+				await port.open({
+					baudRate: 9600,
+					dataBits: 8,
+					parity: "none",
+					stopBits: 1,
+					flowControl: "none"
+				});
+				defaultConsola.debug("З'єднання відкрито!", "success");
+				port.writable.getWriter();
+				isConnected.value = true;
+				defaultConsola.debug("Принтер готовий до друку", "success");
+			} catch (error) {
+				defaultConsola.debug(`Помилка підключення: ${error.message}`, "error");
+				isConnected.value = false;
+			}
+			console.consola.debug("print from web capacitor plugin", zpl);
+			return true;
+		}
+	};
+}));
+
+//#endregion
+//#region src/index.js
+const Zebra = registerPlugin("Zebra", { web: () => Promise.resolve().then(() => (init_web(), web_exports)).then((m) => new m.ZebraWeb()) });
+
+//#endregion
+export { Zebra };
+//# sourceMappingURL=plugin.js.map