taro-bluetooth-print 2.1.0 → 2.1.1

package/dist/index.es.js

@@ -43,6 +43,196 @@ var PrinterState = /* @__PURE__ */ ((PrinterState2) => {
   PrinterState2["PAUSED"] = "paused";
   return PrinterState2;
 })(PrinterState || {});
+class EventEmitter {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Subscribe to an event
+   *
+   * @param event - Event name
+   * @param handler - Event handler function
+   * @returns Unsubscribe function
+   */
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(handler);
+    return () => this.off(event, handler);
+  }
+  /**
+   * Subscribe to an event, but only for the first occurrence
+   *
+   * @param event - Event name
+   * @param handler - Event handler function
+   * @returns Unsubscribe function
+   */
+  once(event, handler) {
+    const wrappedHandler = (data) => {
+      handler(data);
+      this.off(event, wrappedHandler);
+    };
+    return this.on(event, wrappedHandler);
+  }
+  /**
+   * Adds a listener to the beginning of the listeners array for the specified event
+   *
+   * @param event - Event name
+   * @param handler - Event handler function
+   * @returns Unsubscribe function
+   */
+  prepend(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    const existingHandlers = this.listeners.get(event);
+    const newHandlers = /* @__PURE__ */ new Set();
+    newHandlers.add(handler);
+    existingHandlers.forEach((h) => newHandlers.add(h));
+    this.listeners.set(event, newHandlers);
+    return () => this.off(event, handler);
+  }
+  /**
+   * Adds a one-time listener to the beginning of the listeners array for the specified event
+   *
+   * @param event - Event name
+   * @param handler - Event handler function
+   * @returns Unsubscribe function
+   */
+  prependOnce(event, handler) {
+    const wrappedHandler = (data) => {
+      handler(data);
+      this.off(event, wrappedHandler);
+    };
+    return this.prepend(event, wrappedHandler);
+  }
+  /**
+   * Unsubscribe from an event
+   *
+   * @param event - Event name
+   * @param handler - Event handler function to remove
+   */
+  off(event, handler) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.listeners.delete(event);
+      }
+    }
+  }
+  /**
+   * Emit an event to all subscribers
+   *
+   * @param event - Event name
+   * @param data - Event payload (optional for void events)
+   */
+  emit(event, data) {
+    const handlers = this.listeners.get(event);
+    if (!handlers || handlers.size === 0) {
+      return;
+    }
+    const handlersCopy = new Set(handlers);
+    handlersCopy.forEach((handler) => {
+      try {
+        if (data === void 0 || data === null) {
+          handler();
+        } else {
+          handler(data);
+        }
+      } catch (error) {
+        console.error(`Error in event handler for "${String(event)}":`, error);
+      }
+    });
+  }
+  /**
+   * Asynchronously emit an event to all subscribers, waiting for all handlers to complete
+   *
+   * @param event - Event name
+   * @param data - Event payload (optional for void events)
+   * @returns Promise that resolves when all handlers have completed
+   */
+  emitAsync(event, data) {
+    return __async(this, null, function* () {
+      const handlers = this.listeners.get(event);
+      if (!handlers || handlers.size === 0) {
+        return;
+      }
+      const handlersCopy = new Set(handlers);
+      const promises = [];
+      handlersCopy.forEach((handler) => {
+        promises.push(
+          new Promise((resolve) => {
+            try {
+              if (data === void 0 || data === null) {
+                handler();
+              } else {
+                handler(data);
+              }
+            } catch (error) {
+              console.error(`Error in event handler for "${String(event)}":`, error);
+            } finally {
+              resolve();
+            }
+          })
+        );
+      });
+      yield Promise.all(promises);
+    });
+  }
+  /**
+   * Remove all event listeners
+   * @param event - Optional event name to remove all listeners for a specific event
+   */
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+  }
+  /**
+   * Get the number of listeners for an event
+   *
+   * @param event - Event name
+   * @returns Number of listeners
+   */
+  listenerCount(event) {
+    var _a, _b;
+    return (_b = (_a = this.listeners.get(event)) == null ? void 0 : _a.size) != null ? _b : 0;
+  }
+  /**
+   * Get all listeners for an event
+   *
+   * @param event - Event name
+   * @returns Array of event handlers
+   */
+  getListeners(event) {
+    const handlers = this.listeners.get(event);
+    if (!handlers) {
+      return [];
+    }
+    return Array.from(handlers);
+  }
+  /**
+   * Get all event names that have listeners
+   *
+   * @returns Array of event names
+   */
+  eventNames() {
+    return Array.from(this.listeners.keys());
+  }
+  /**
+   * Check if there are any listeners for an event
+   *
+   * @param event - Event name
+   * @returns True if there are listeners, false otherwise
+   */
+  hasListeners(event) {
+    return this.listenerCount(event) > 0;
+  }
+}
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
   LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
@@ -52,19 +242,97 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   return LogLevel2;
 })(LogLevel || {});
 const _Logger = class _Logger {
+  /**
+   * Configures the logger
+   *
+   * @param config - Configuration options
+   */
+  static configure(config) {
+    this.config = __spreadValues(__spreadValues({}, this.config), config);
+  }
   /**
    * Sets the global log level
    *
    * @param level - Minimum log level to output
    */
   static setLevel(level) {
-    this.level = level;
+    this.config.level = level;
   }
   /**
    * Gets the current log level
    */
   static getLevel() {
-    return this.level;
+    return this.config.level;
+  }
+  /**
+   * Formats the log prefix
+   */
+  static formatPrefix(level, scope) {
+    const levelNames = {
+      [
+        0
+        /* DEBUG */
+      ]: "DEBUG",
+      [
+        1
+        /* INFO */
+      ]: "INFO",
+      [
+        2
+        /* WARN */
+      ]: "WARN",
+      [
+        3
+        /* ERROR */
+      ]: "ERROR",
+      [
+        4
+        /* NONE */
+      ]: "NONE"
+    };
+    const scopedPrefix = scope ? `${this.config.prefix}:${scope}` : this.config.prefix;
+    return `${scopedPrefix} [${levelNames[level]}]`;
+  }
+  /**
+   * Formats a complete log message for custom handlers
+   */
+  static formatMessage(level, message, args, scope) {
+    const prefix = this.formatPrefix(level, scope);
+    return `${prefix} ${message}`;
+  }
+  /**
+   * Logs a message with the specified level
+   */
+  static log(level, message, args, scope) {
+    if (this.config.level > level) {
+      return;
+    }
+    const prefix = this.formatPrefix(level, scope);
+    const formatted = this.formatMessage(level, message, args, scope);
+    const entry = {
+      level,
+      message,
+      args,
+      timestamp: /* @__PURE__ */ new Date(),
+      scope,
+      formatted
+    };
+    if (this.config.handler) {
+      this.config.handler(entry);
+    } else {
+      switch (level) {
+        case 0:
+        case 1:
+          console.log(prefix, message, ...args);
+          break;
+        case 2:
+          console.warn(prefix, message, ...args);
+          break;
+        case 3:
+          console.error(prefix, message, ...args);
+          break;
+      }
+    }
   }
   /**
    * Logs a debug message (only in DEBUG level)
@@ -73,9 +341,7 @@ const _Logger = class _Logger {
    * @param args - Additional arguments to log
    */
   static debug(message, ...args) {
-    if (this.level <= 0) {
-      console.log(`${this.prefix} [DEBUG]`, message, ...args);
-    }
+    this.log(0, message, args);
   }
   /**
    * Logs an info message (DEBUG and INFO levels)
@@ -84,9 +350,7 @@ const _Logger = class _Logger {
    * @param args - Additional arguments to log
    */
   static info(message, ...args) {
-    if (this.level <= 1) {
-      console.log(`${this.prefix} [INFO]`, message, ...args);
-    }
+    this.log(1, message, args);
   }
   /**
    * Logs a warning message (DEBUG, INFO, and WARN levels)
@@ -95,9 +359,7 @@ const _Logger = class _Logger {
    * @param args - Additional arguments to log
    */
   static warn(message, ...args) {
-    if (this.level <= 2) {
-      console.warn(`${this.prefix} [WARN]`, message, ...args);
-    }
+    this.log(2, message, args);
   }
   /**
    * Logs an error message (all levels except NONE)
@@ -106,9 +368,7 @@ const _Logger = class _Logger {
    * @param args - Additional arguments to log
    */
   static error(message, ...args) {
-    if (this.level <= 3) {
-      console.error(`${this.prefix} [ERROR]`, message, ...args);
-    }
+    this.log(3, message, args);
   }
   /**
    * Creates a scoped logger with a specific prefix
@@ -117,408 +377,549 @@ const _Logger = class _Logger {
    * @returns Scoped logger instance
    */
   static scope(scope) {
-    const scopedPrefix = `${this.prefix}:${scope}`;
     return {
       debug: (message, ...args) => {
-        if (_Logger.level <= 0) {
-          console.log(`${scopedPrefix} [DEBUG]`, message, ...args);
-        }
+        _Logger.log(0, message, args, scope);
       },
       info: (message, ...args) => {
-        if (_Logger.level <= 1) {
-          console.log(`${scopedPrefix} [INFO]`, message, ...args);
-        }
+        _Logger.log(1, message, args, scope);
       },
       warn: (message, ...args) => {
-        if (_Logger.level <= 2) {
-          console.warn(`${scopedPrefix} [WARN]`, message, ...args);
-        }
+        _Logger.log(2, message, args, scope);
       },
       error: (message, ...args) => {
-        if (_Logger.level <= 3) {
-          console.error(`${scopedPrefix} [ERROR]`, message, ...args);
-        }
+        _Logger.log(3, message, args, scope);
       }
     };
   }
 };
-_Logger.level = 2;
-_Logger.prefix = "[TaroBTPrint]";
+_Logger.config = {
+  level: 2,
+  prefix: "[TaroBTPrint]"
+};
 let Logger = _Logger;
-const logger = Logger.scope("Encoding");
-const _Encoding = class _Encoding {
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["CONNECTION_FAILED"] = "CONNECTION_FAILED";
+  ErrorCode2["CONNECTION_TIMEOUT"] = "CONNECTION_TIMEOUT";
+  ErrorCode2["DEVICE_NOT_FOUND"] = "DEVICE_NOT_FOUND";
+  ErrorCode2["DEVICE_DISCONNECTED"] = "DEVICE_DISCONNECTED";
+  ErrorCode2["SERVICE_NOT_FOUND"] = "SERVICE_NOT_FOUND";
+  ErrorCode2["CHARACTERISTIC_NOT_FOUND"] = "CHARACTERISTIC_NOT_FOUND";
+  ErrorCode2["SERVICE_DISCOVERY_FAILED"] = "SERVICE_DISCOVERY_FAILED";
+  ErrorCode2["WRITE_FAILED"] = "WRITE_FAILED";
+  ErrorCode2["WRITE_TIMEOUT"] = "WRITE_TIMEOUT";
+  ErrorCode2["PRINT_JOB_IN_PROGRESS"] = "PRINT_JOB_IN_PROGRESS";
+  ErrorCode2["PRINT_JOB_CANCELLED"] = "PRINT_JOB_CANCELLED";
+  ErrorCode2["PRINT_JOB_FAILED"] = "PRINT_JOB_FAILED";
+  ErrorCode2["INVALID_CONFIGURATION"] = "INVALID_CONFIGURATION";
+  ErrorCode2["ENCODING_NOT_SUPPORTED"] = "ENCODING_NOT_SUPPORTED";
+  ErrorCode2["INVALID_IMAGE_DATA"] = "INVALID_IMAGE_DATA";
+  ErrorCode2["INVALID_QR_DATA"] = "INVALID_QR_DATA";
+  ErrorCode2["PLATFORM_NOT_SUPPORTED"] = "PLATFORM_NOT_SUPPORTED";
+  return ErrorCode2;
+})(ErrorCode || {});
+class BluetoothPrintError extends Error {
   /**
-   * Encodes a string to a Uint8Array using the specified encoding
-   *
-   * @param text - Text to encode
-   * @param encoding - Target encoding (default: 'GBK')
-   * @returns Encoded bytes
-   *
-   * @remarks
-   * Note: Native TextEncoder only supports UTF-8.
-   * For GBK encoding, a third-party library or polyfill is recommended.
-   * Currently falls back to UTF-8 with a warning.
-   *
-   * @example
-   * ```typescript
-   * // UTF-8 encoding
-   * const utf8 = Encoding.encode('Hello', 'UTF-8');
+   * Creates a new BluetoothPrintError
    *
-   * // GBK encoding (currently falls back to UTF-8)
-   * const gbk = Encoding.encode('你好', 'GBK');
-   * ```
+   * @param code - Error code from ErrorCode enum
+   * @param message - Human-readable error message
+   * @param originalError - Original error that caused this error (optional)
    */
-  static encode(text, encoding = "GBK") {
-    if (!text || typeof text !== "string") {
-      return new Uint8Array(0);
-    }
-    const normalizedEncoding = encoding.toUpperCase().replace("-", "");
-    if (normalizedEncoding === "UTF8" || normalizedEncoding === "UTF-8") {
-      return this.utf8Encoder.encode(text);
-    }
-    if (!this.warningShown) {
-      logger.warn(
-        `Encoding ${encoding} not yet fully implemented, falling back to UTF-8. This may cause display issues with some printers.`
-      );
-      this.warningShown = true;
+  constructor(code, message, originalError) {
+    super(message);
+    this.code = code;
+    this.originalError = originalError;
+    this.name = "BluetoothPrintError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, BluetoothPrintError);
     }
-    return this.utf8Encoder.encode(text);
   }
   /**
-   * Checks if an encoding is supported
-   *
-   * @param encoding - Encoding name to check
-   * @returns True if supported, false otherwise
-   *
-   * @example
-   * ```typescript
-   * if (Encoding.isSupported('GBK')) {
-   *   console.log('GBK is supported');
-   * }
-   * ```
+   * Returns a detailed error message including the error code
    */
-  static isSupported(encoding) {
-    if (!encoding || typeof encoding !== "string") {
-      return false;
+  toString() {
+    let result = `${this.name} [${this.code}]: ${this.message}`;
+    if (this.originalError) {
+      result += `
+Caused by: ${this.originalError.message}`;
     }
-    const normalizedEncoding = encoding.toUpperCase().replace("-", "");
-    return normalizedEncoding === "UTF8" || normalizedEncoding === "UTF-8";
+    return result;
   }
-};
-_Encoding.utf8Encoder = new TextEncoder();
-_Encoding.warningShown = false;
-let Encoding = _Encoding;
-class ImageProcessing {
-  /**
-   * Convert RGBA data to monochrome bitmap (1 bit per pixel)
-   * suitable for ESC/POS GS v 0 command.
-   * Uses Floyd-Steinberg dithering for better quality.
-   *
-   * @param data - RGBA pixel data as Uint8Array
-   * @param width - Image width in pixels
-   * @param height - Image height in pixels
-   * @returns Monochrome bitmap data as Uint8Array
-   *
-   * @example
-   * ```typescript
-   * const imageData = new Uint8Array(width * height * 4); // RGBA
-   * const bitmap = ImageProcessing.toBitmap(imageData, width, height);
-   * ```
-   */
-  static toBitmap(data, width, height) {
-    if (!data || !(data instanceof Uint8Array) || width <= 0 || height <= 0) {
-      return new Uint8Array(0);
+}
+var Token = (
+  /** @class */
+  /* @__PURE__ */ function() {
+    function Token2(name) {
+      this.name = name;
     }
-    if (data.length !== width * height * 4) {
-      throw new Error(`Invalid image data length: expected ${width * height * 4}, got ${data.length}`);
+    return Token2;
+  }()
+);
+var __extends$1 = /* @__PURE__ */ function() {
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+    };
+    return extendStatics(d, b);
+  };
+  return function(d, b) {
+    extendStatics(d, b);
+    function __() {
+      this.constructor = d;
     }
-    const bytesPerLine = Math.ceil(width / 8);
-    const bitmap = new Uint8Array(bytesPerLine * height);
-    const grayscale = new Float32Array(width * height);
-    for (let i = 0; i < data.length; i += 4) {
-      const index = i / 4;
-      const r = data[i] || 0;
-      const g = data[i + 1] || 0;
-      const b = data[i + 2] || 0;
-      grayscale[index] = 0.299 * r + 0.587 * g + 0.114 * b;
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+var ServiceNotFoundError = (
+  /** @class */
+  function(_super) {
+    __extends$1(ServiceNotFoundError2, _super);
+    function ServiceNotFoundError2(identifier) {
+      var _a, _b;
+      var _this = _super.call(this) || this;
+      _this.name = "ServiceNotFoundError";
+      _this.normalizedIdentifier = "<UNKNOWN_IDENTIFIER>";
+      if (typeof identifier === "string") {
+        _this.normalizedIdentifier = identifier;
+      } else if (identifier instanceof Token) {
+        _this.normalizedIdentifier = "Token<" + (identifier.name || "UNSET_NAME") + ">";
+      } else if (identifier && (identifier.name || ((_a = identifier.prototype) === null || _a === void 0 ? void 0 : _a.name))) {
+        _this.normalizedIdentifier = "MaybeConstructable<" + identifier.name + ">" || "MaybeConstructable<" + ((_b = identifier.prototype) === null || _b === void 0 ? void 0 : _b.name) + ">";
+      }
+      return _this;
     }
-    for (let y = 0; y < height; y++) {
-      for (let x = 0; x < width; x++) {
-        const index = y * width + x;
-        const oldPixel = grayscale[index] || 0;
-        const newPixel = oldPixel < 128 ? 0 : 255;
-        if (newPixel === 0) {
-          const byteIndex = y * bytesPerLine + Math.floor(x / 8);
-          const bitIndex = 7 - x % 8;
-          bitmap[byteIndex] = (bitmap[byteIndex] || 0) | 1 << bitIndex;
+    Object.defineProperty(ServiceNotFoundError2.prototype, "message", {
+      get: function() {
+        return 'Service with "' + this.normalizedIdentifier + '" identifier was not found in the container. Register it before usage via explicitly calling the "Container.set" function or using the "@Service()" decorator.';
+      },
+      enumerable: false,
+      configurable: true
+    });
+    return ServiceNotFoundError2;
+  }(Error)
+);
+var __extends = /* @__PURE__ */ function() {
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+    };
+    return extendStatics(d, b);
+  };
+  return function(d, b) {
+    extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+var CannotInstantiateValueError = (
+  /** @class */
+  function(_super) {
+    __extends(CannotInstantiateValueError2, _super);
+    function CannotInstantiateValueError2(identifier) {
+      var _a, _b;
+      var _this = _super.call(this) || this;
+      _this.name = "CannotInstantiateValueError";
+      _this.normalizedIdentifier = "<UNKNOWN_IDENTIFIER>";
+      if (typeof identifier === "string") {
+        _this.normalizedIdentifier = identifier;
+      } else if (identifier instanceof Token) {
+        _this.normalizedIdentifier = "Token<" + (identifier.name || "UNSET_NAME") + ">";
+      } else if (identifier && (identifier.name || ((_a = identifier.prototype) === null || _a === void 0 ? void 0 : _a.name))) {
+        _this.normalizedIdentifier = "MaybeConstructable<" + identifier.name + ">" || "MaybeConstructable<" + ((_b = identifier.prototype) === null || _b === void 0 ? void 0 : _b.name) + ">";
+      }
+      return _this;
+    }
+    Object.defineProperty(CannotInstantiateValueError2.prototype, "message", {
+      get: function() {
+        return 'Cannot instantiate the requested value for the "' + this.normalizedIdentifier + `" identifier. The related metadata doesn't contain a factory or a type to instantiate.`;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    return CannotInstantiateValueError2;
+  }(Error)
+);
+var EMPTY_VALUE = Symbol("EMPTY_VALUE");
+var __assign = function() {
+  __assign = Object.assign || function(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+        t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var __spreadArrays = function() {
+  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+  for (var r = Array(s), k = 0, i = 0; i < il; i++)
+    for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+      r[k] = a[j];
+  return r;
+};
+var ContainerInstance = (
+  /** @class */
+  function() {
+    function ContainerInstance2(id) {
+      this.services = [];
+      this.id = id;
+    }
+    ContainerInstance2.prototype.has = function(identifier) {
+      return !!this.findService(identifier);
+    };
+    ContainerInstance2.prototype.get = function(identifier) {
+      var globalContainer = Container.of(void 0);
+      var globalService = globalContainer.findService(identifier);
+      var scopedService = this.findService(identifier);
+      if (globalService && globalService.global === true)
+        return this.getServiceValue(globalService);
+      if (scopedService)
+        return this.getServiceValue(scopedService);
+      if (globalService && this !== globalContainer) {
+        var clonedService = __assign({}, globalService);
+        clonedService.value = EMPTY_VALUE;
+        this.set(clonedService);
+        var value = this.getServiceValue(clonedService);
+        this.set(__assign(__assign({}, clonedService), { value }));
+        return value;
+      }
+      if (globalService)
+        return this.getServiceValue(globalService);
+      throw new ServiceNotFoundError(identifier);
+    };
+    ContainerInstance2.prototype.getMany = function(identifier) {
+      var _this = this;
+      return this.findAllServices(identifier).map(function(service) {
+        return _this.getServiceValue(service);
+      });
+    };
+    ContainerInstance2.prototype.set = function(identifierOrServiceMetadata, value) {
+      var _this = this;
+      if (identifierOrServiceMetadata instanceof Array) {
+        identifierOrServiceMetadata.forEach(function(data) {
+          return _this.set(data);
+        });
+        return this;
+      }
+      if (typeof identifierOrServiceMetadata === "string" || identifierOrServiceMetadata instanceof Token) {
+        return this.set({
+          id: identifierOrServiceMetadata,
+          type: null,
+          value,
+          factory: void 0,
+          global: false,
+          multiple: false,
+          eager: false,
+          transient: false
+        });
+      }
+      if (typeof identifierOrServiceMetadata === "function") {
+        return this.set({
+          id: identifierOrServiceMetadata,
+          // TODO: remove explicit casting
+          type: identifierOrServiceMetadata,
+          value,
+          factory: void 0,
+          global: false,
+          multiple: false,
+          eager: false,
+          transient: false
+        });
+      }
+      var newService = __assign({ id: new Token("UNREACHABLE"), type: null, factory: void 0, value: EMPTY_VALUE, global: false, multiple: false, eager: false, transient: false }, identifierOrServiceMetadata);
+      var service = this.findService(newService.id);
+      if (service && service.multiple !== true) {
+        Object.assign(service, newService);
+      } else {
+        this.services.push(newService);
+      }
+      if (newService.eager) {
+        this.get(newService.id);
+      }
+      return this;
+    };
+    ContainerInstance2.prototype.remove = function(identifierOrIdentifierArray) {
+      var _this = this;
+      if (Array.isArray(identifierOrIdentifierArray)) {
+        identifierOrIdentifierArray.forEach(function(id) {
+          return _this.remove(id);
+        });
+      } else {
+        this.services = this.services.filter(function(service) {
+          if (service.id === identifierOrIdentifierArray) {
+            _this.destroyServiceInstance(service);
+            return false;
+          }
+          return true;
+        });
+      }
+      return this;
+    };
+    ContainerInstance2.prototype.reset = function(options) {
+      var _this = this;
+      if (options === void 0) {
+        options = { strategy: "resetValue" };
+      }
+      switch (options.strategy) {
+        case "resetValue":
+          this.services.forEach(function(service) {
+            return _this.destroyServiceInstance(service);
+          });
+          break;
+        case "resetServices":
+          this.services.forEach(function(service) {
+            return _this.destroyServiceInstance(service);
+          });
+          this.services = [];
+          break;
+        default:
+          throw new Error("Received invalid reset strategy.");
+      }
+      return this;
+    };
+    ContainerInstance2.prototype.findAllServices = function(identifier) {
+      return this.services.filter(function(service) {
+        return service.id === identifier;
+      });
+    };
+    ContainerInstance2.prototype.findService = function(identifier) {
+      return this.services.find(function(service) {
+        return service.id === identifier;
+      });
+    };
+    ContainerInstance2.prototype.getServiceValue = function(serviceMetadata) {
+      var _a;
+      var value = EMPTY_VALUE;
+      if (serviceMetadata.value !== EMPTY_VALUE) {
+        return serviceMetadata.value;
+      }
+      if (!serviceMetadata.factory && !serviceMetadata.type) {
+        throw new CannotInstantiateValueError(serviceMetadata.id);
+      }
+      if (serviceMetadata.factory) {
+        if (serviceMetadata.factory instanceof Array) {
+          var factoryInstance = void 0;
+          try {
+            factoryInstance = this.get(serviceMetadata.factory[0]);
+          } catch (error) {
+            if (error instanceof ServiceNotFoundError) {
+              factoryInstance = new serviceMetadata.factory[0]();
+            } else {
+              throw error;
+            }
+          }
+          value = factoryInstance[serviceMetadata.factory[1]](this, serviceMetadata.id);
+        } else {
+          value = serviceMetadata.factory(this, serviceMetadata.id);
         }
-        const quantError = oldPixel - newPixel;
-        this.distributeError(grayscale, width, height, x, y, quantError);
       }
+      if (!serviceMetadata.factory && serviceMetadata.type) {
+        var constructableTargetType = serviceMetadata.type;
+        var paramTypes = ((_a = Reflect) === null || _a === void 0 ? void 0 : _a.getMetadata("design:paramtypes", constructableTargetType)) || [];
+        var params = this.initializeParams(constructableTargetType, paramTypes);
+        params.push(this);
+        value = new (constructableTargetType.bind.apply(constructableTargetType, __spreadArrays([void 0], params)))();
+      }
+      if (!serviceMetadata.transient && value !== EMPTY_VALUE) {
+        serviceMetadata.value = value;
+      }
+      if (value === EMPTY_VALUE) {
+        throw new CannotInstantiateValueError(serviceMetadata.id);
+      }
+      if (serviceMetadata.type) {
+        this.applyPropertyHandlers(serviceMetadata.type, value);
+      }
+      return value;
+    };
+    ContainerInstance2.prototype.initializeParams = function(target, paramTypes) {
+      var _this = this;
+      return paramTypes.map(function(paramType, index) {
+        var paramHandler = Container.handlers.find(function(handler) {
+          return (handler.object === target || handler.object === Object.getPrototypeOf(target)) && handler.index === index;
+        });
+        if (paramHandler)
+          return paramHandler.value(_this);
+        if (paramType && paramType.name && !_this.isPrimitiveParamType(paramType.name)) {
+          return _this.get(paramType);
+        }
+        return void 0;
+      });
+    };
+    ContainerInstance2.prototype.isPrimitiveParamType = function(paramTypeName) {
+      return ["string", "boolean", "number", "object"].includes(paramTypeName.toLowerCase());
+    };
+    ContainerInstance2.prototype.applyPropertyHandlers = function(target, instance) {
+      var _this = this;
+      Container.handlers.forEach(function(handler) {
+        if (typeof handler.index === "number")
+          return;
+        if (handler.object.constructor !== target && !(target.prototype instanceof handler.object.constructor))
+          return;
+        if (handler.propertyName) {
+          instance[handler.propertyName] = handler.value(_this);
+        }
+      });
+    };
+    ContainerInstance2.prototype.destroyServiceInstance = function(serviceMetadata, force) {
+      if (force === void 0) {
+        force = false;
+      }
+      var shouldResetValue = force || !!serviceMetadata.type || !!serviceMetadata.factory;
+      if (shouldResetValue) {
+        if (typeof (serviceMetadata === null || serviceMetadata === void 0 ? void 0 : serviceMetadata.value)["destroy"] === "function") {
+          try {
+            serviceMetadata.value.destroy();
+          } catch (error) {
+          }
+        }
+        serviceMetadata.value = EMPTY_VALUE;
+      }
+    };
+    return ContainerInstance2;
+  }()
+);
+var Container = (
+  /** @class */
+  function() {
+    function Container2() {
     }
-    return bitmap;
-  }
-  /**
-   * Distribute quantization error to neighboring pixels using Floyd-Steinberg algorithm
-   *
-   * @param grayscale - Grayscale image data
-   * @param width - Image width
-   * @param height - Image height
-   * @param x - Current x position
-   * @param y - Current y position
-   * @param error - Quantization error to distribute
-   */
-  static distributeError(grayscale, width, height, x, y, error) {
-    const distribute = (dx, dy, factor) => {
-      const nx = x + dx;
-      const ny = y + dy;
-      if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
-        const index = ny * width + nx;
-        grayscale[index] = Math.max(0, Math.min(255, (grayscale[index] || 0) + error * factor));
+    Container2.of = function(containerId) {
+      if (containerId === void 0) {
+        containerId = "default";
+      }
+      if (containerId === "default")
+        return this.globalInstance;
+      var container = this.instances.find(function(instance) {
+        return instance.id === containerId;
+      });
+      if (!container) {
+        container = new ContainerInstance(containerId);
+        this.instances.push(container);
       }
+      return container;
     };
-    distribute(1, 0, 7 / 16);
-    distribute(-1, 1, 3 / 16);
-    distribute(0, 1, 5 / 16);
-    distribute(1, 1, 1 / 16);
-  }
+    Container2.has = function(identifier) {
+      return this.globalInstance.has(identifier);
+    };
+    Container2.get = function(identifier) {
+      return this.globalInstance.get(identifier);
+    };
+    Container2.getMany = function(id) {
+      return this.globalInstance.getMany(id);
+    };
+    Container2.set = function(identifierOrServiceMetadata, value) {
+      this.globalInstance.set(identifierOrServiceMetadata, value);
+      return this;
+    };
+    Container2.remove = function(identifierOrIdentifierArray) {
+      this.globalInstance.remove(identifierOrIdentifierArray);
+      return this;
+    };
+    Container2.reset = function(containerId) {
+      if (containerId === void 0) {
+        containerId = "default";
+      }
+      if (containerId == "default") {
+        this.globalInstance.reset();
+        this.instances.forEach(function(instance2) {
+          return instance2.reset();
+        });
+      } else {
+        var instance = this.instances.find(function(instance2) {
+          return instance2.id === containerId;
+        });
+        if (instance) {
+          instance.reset();
+          this.instances.splice(this.instances.indexOf(instance), 1);
+        }
+      }
+      return this;
+    };
+    Container2.registerHandler = function(handler) {
+      this.handlers.push(handler);
+      return this;
+    };
+    Container2.import = function(services) {
+      return this;
+    };
+    Container2.handlers = [];
+    Container2.globalInstance = new ContainerInstance("default");
+    Container2.instances = [];
+    return Container2;
+  }()
+);
+function Service(optionsOrServiceIdentifier) {
+  return function(targetConstructor) {
+    var serviceMetadata = {
+      id: targetConstructor,
+      // TODO: Let's investigate why we receive Function type instead of a constructable.
+      type: targetConstructor,
+      factory: void 0,
+      multiple: false,
+      global: false,
+      eager: false,
+      transient: false,
+      value: EMPTY_VALUE
+    };
+    if (optionsOrServiceIdentifier instanceof Token || typeof optionsOrServiceIdentifier === "string") {
+      serviceMetadata.id = optionsOrServiceIdentifier;
+    }
+    Container.set(serviceMetadata);
+  };
 }
-class EscPos {
+class BaseAdapter {
   constructor() {
-    this.logger = Logger.scope("EscPos");
+    this.serviceCache = /* @__PURE__ */ new Map();
+    this.logger = Logger.scope("BaseAdapter");
   }
   /**
-   * Initializes the printer
-   * Sends ESC @ command to reset printer to default state
-   *
-   * @returns Array of command buffers
+   * Register a callback for connection state changes
+   * @param callback - Function to call when the state changes
    */
-  init() {
-    return [new Uint8Array([27, 64])];
+  onStateChange(callback) {
+    this.stateCallback = callback;
   }
   /**
-   * Generates text print command
-   *
-   * @param content - Text content to print
-   * @param encoding - Text encoding (default: 'GBK')
-   * @returns Array of command buffers
-   *
-   * @example
-   * ```typescript
-   * driver.text('你好世界', 'GBK');
-   * ```
+   * Updates the internal state and notifies callbacks
+   * @param state - New printer state
    */
-  text(content, encoding = "GBK") {
-    if (!content || typeof content !== "string") {
-      return [];
+  updateState(state) {
+    if (this.stateCallback) {
+      this.stateCallback(state);
     }
-    const encoded = Encoding.encode(content, encoding);
-    return [encoded];
   }
   /**
-   * Generates line feed command
-   *
-   * @param lines - Number of lines to feed (default: 1)
-   * @returns Array of command buffers
-   *
-   * @example
-   * ```typescript
-   * driver.feed(3); // Feed 3 lines
-   * ```
+   * Validates device ID
+   * @param deviceId - Device ID to validate
+   * @throws BluetoothPrintError if device ID is invalid
    */
-  feed(lines = 1) {
-    const safeLines = Math.max(1, Math.min(255, Math.floor(lines)));
-    return [new Uint8Array([27, 100, safeLines])];
+  validateDeviceId(deviceId) {
+    if (!deviceId || typeof deviceId !== "string") {
+      throw new BluetoothPrintError(ErrorCode.DEVICE_NOT_FOUND, "Invalid device ID provided");
+    }
   }
   /**
-   * Generates paper cut command
-   *
-   * @returns Array of command buffers
-   *
-   * @example
-   * ```typescript
-   * driver.cut();
-   * ```
+   * Validates buffer data
+   * @param buffer - Buffer to validate
+   * @throws BluetoothPrintError if buffer is invalid
    */
-  cut() {
-    return [new Uint8Array([29, 86, 0])];
+  validateBuffer(buffer) {
+    if (!buffer || !(buffer instanceof ArrayBuffer)) {
+      throw new BluetoothPrintError(ErrorCode.PRINT_JOB_FAILED, "Invalid buffer data provided");
+    }
   }
   /**
-   * Generates image print command
-   * Uses Floyd-Steinberg dithering for better quality
-   *
-   * @param data - RGBA pixel data
-   * @param width - Image width in pixels
-   * @param height - Image height in pixels
-   * @returns Array of command buffers
-   *
-   * @example
-   * ```typescript
-   * const imageData = new Uint8Array(width * height * 4); // RGBA
-   * driver.image(imageData, 200, 100);
-   * ```
-   */
-  image(data, width, height) {
-    if (!data || !(data instanceof Uint8Array) || width <= 0 || height <= 0) {
-      return [];
-    }
-    if (data.length !== width * height * 4) {
-      this.logger.warn(`Invalid image data length: expected ${width * height * 4}, got ${data.length}`);
-      return [];
-    }
-    const bitmap = ImageProcessing.toBitmap(data, width, height);
-    const bytesPerLine = Math.ceil(width / 8);
-    const xL = bytesPerLine % 256;
-    const xH = Math.floor(bytesPerLine / 256);
-    const yL = height % 256;
-    const yH = Math.floor(height / 256);
-    const header = new Uint8Array([29, 118, 48, 0, xL, xH, yL, yH]);
-    return [header, bitmap];
-  }
-  /**
-   * Generates QR code print command
-   *
-   * @param content - QR code content (URL, text, etc.)
-   * @param options - QR code options
-   * @returns Array of command buffers
-   *
-   * @example
-   * ```typescript
-   * driver.qr('https://example.com', {
-   *   model: 2,
-   *   size: 8,
-   *   errorCorrection: 'M'
-   * });
-   * ```
-   */
-  qr(content, options) {
-    var _a, _b, _c, _d;
-    if (!content || typeof content !== "string") {
-      return [];
-    }
-    const model = (_a = options == null ? void 0 : options.model) != null ? _a : 2;
-    const size = Math.max(1, Math.min(16, (_b = options == null ? void 0 : options.size) != null ? _b : 6));
-    const errorCorrection = (_c = options == null ? void 0 : options.errorCorrection) != null ? _c : "M";
-    const commands = [];
-    commands.push(
-      new Uint8Array([29, 40, 107, 4, 0, 49, 65, model === 1 ? 49 : 50, 0])
-    );
-    commands.push(new Uint8Array([29, 40, 107, 3, 0, 49, 67, size]));
-    const ecMap = { L: 48, M: 49, Q: 50, H: 51 };
-    const ecValue = (_d = ecMap[errorCorrection]) != null ? _d : 49;
-    commands.push(
-      new Uint8Array([29, 40, 107, 3, 0, 49, 69, ecValue])
-    );
-    const data = Encoding.encode(content, "GBK");
-    const len = data.length + 3;
-    const pL = len % 256;
-    const pH = Math.floor(len / 256);
-    commands.push(new Uint8Array([29, 40, 107, pL, pH, 49, 80, 48]));
-    commands.push(data);
-    commands.push(new Uint8Array([29, 40, 107, 3, 0, 49, 81, 48]));
-    return commands;
-  }
-}
-var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
-  ErrorCode2["CONNECTION_FAILED"] = "CONNECTION_FAILED";
-  ErrorCode2["CONNECTION_TIMEOUT"] = "CONNECTION_TIMEOUT";
-  ErrorCode2["DEVICE_NOT_FOUND"] = "DEVICE_NOT_FOUND";
-  ErrorCode2["DEVICE_DISCONNECTED"] = "DEVICE_DISCONNECTED";
-  ErrorCode2["SERVICE_NOT_FOUND"] = "SERVICE_NOT_FOUND";
-  ErrorCode2["CHARACTERISTIC_NOT_FOUND"] = "CHARACTERISTIC_NOT_FOUND";
-  ErrorCode2["SERVICE_DISCOVERY_FAILED"] = "SERVICE_DISCOVERY_FAILED";
-  ErrorCode2["WRITE_FAILED"] = "WRITE_FAILED";
-  ErrorCode2["WRITE_TIMEOUT"] = "WRITE_TIMEOUT";
-  ErrorCode2["PRINT_JOB_IN_PROGRESS"] = "PRINT_JOB_IN_PROGRESS";
-  ErrorCode2["PRINT_JOB_CANCELLED"] = "PRINT_JOB_CANCELLED";
-  ErrorCode2["PRINT_JOB_FAILED"] = "PRINT_JOB_FAILED";
-  ErrorCode2["INVALID_CONFIGURATION"] = "INVALID_CONFIGURATION";
-  ErrorCode2["ENCODING_NOT_SUPPORTED"] = "ENCODING_NOT_SUPPORTED";
-  ErrorCode2["INVALID_IMAGE_DATA"] = "INVALID_IMAGE_DATA";
-  ErrorCode2["INVALID_QR_DATA"] = "INVALID_QR_DATA";
-  ErrorCode2["PLATFORM_NOT_SUPPORTED"] = "PLATFORM_NOT_SUPPORTED";
-  return ErrorCode2;
-})(ErrorCode || {});
-class BluetoothPrintError extends Error {
-  /**
-   * Creates a new BluetoothPrintError
-   *
-   * @param code - Error code from ErrorCode enum
-   * @param message - Human-readable error message
-   * @param originalError - Original error that caused this error (optional)
-   */
-  constructor(code, message, originalError) {
-    super(message);
-    this.code = code;
-    this.originalError = originalError;
-    this.name = "BluetoothPrintError";
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, BluetoothPrintError);
-    }
-  }
-  /**
-   * Returns a detailed error message including the error code
-   */
-  toString() {
-    let result = `${this.name} [${this.code}]: ${this.message}`;
-    if (this.originalError) {
-      result += `
-Caused by: ${this.originalError.message}`;
-    }
-    return result;
-  }
-}
-class BaseAdapter {
-  constructor() {
-    this.serviceCache = /* @__PURE__ */ new Map();
-    this.logger = Logger.scope("BaseAdapter");
-  }
-  /**
-   * Register a callback for connection state changes
-   * @param callback - Function to call when the state changes
-   */
-  onStateChange(callback) {
-    this.stateCallback = callback;
-  }
-  /**
-   * Updates the internal state and notifies callbacks
-   * @param state - New printer state
-   */
-  updateState(state) {
-    if (this.stateCallback) {
-      this.stateCallback(state);
-    }
-  }
-  /**
-   * Validates device ID
-   * @param deviceId - Device ID to validate
-   * @throws BluetoothPrintError if device ID is invalid
-   */
-  validateDeviceId(deviceId) {
-    if (!deviceId || typeof deviceId !== "string") {
-      throw new BluetoothPrintError(
-        ErrorCode.DEVICE_NOT_FOUND,
-        "Invalid device ID provided"
-      );
-    }
-  }
-  /**
-   * Validates buffer data
-   * @param buffer - Buffer to validate
-   * @throws BluetoothPrintError if buffer is invalid
-   */
-  validateBuffer(buffer) {
-    if (!buffer || !(buffer instanceof ArrayBuffer)) {
-      throw new BluetoothPrintError(
-        ErrorCode.PRINT_JOB_FAILED,
-        "Invalid buffer data provided"
-      );
-    }
-  }
-  /**
-   * Validates adapter options
-   * @param options - Options to validate
-   * @returns Validated options with default values
+   * Validates adapter options
+   * @param options - Options to validate
+   * @returns Validated options with default values
    */
   validateOptions(options) {
     var _a, _b, _c;
@@ -578,13 +979,17 @@ class TaroAdapter extends BaseAdapter {
       this.updateState(PrinterState.CONNECTING);
       this.logger.debug("Connecting to device:", deviceId);
       try {
+        let timeoutId;
         const connectionPromise = Taro.createBLEConnection({ deviceId });
         const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => {
+          timeoutId = setTimeout(() => {
             reject(new Error("Connection timeout after 10 seconds"));
           }, 1e4);
         });
         yield Promise.race([connectionPromise, timeoutPromise]);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
         this.logger.info("BLE connection established");
         yield this.discoverServices(deviceId);
         this.updateState(PrinterState.CONNECTED);
@@ -661,10 +1066,7 @@ class TaroAdapter extends BaseAdapter {
         const state = yield Taro.getBLEConnectionState({ deviceId });
         if (!state.connected) {
           this.cleanupDevice(deviceId);
-          throw new BluetoothPrintError(
-            ErrorCode.DEVICE_DISCONNECTED,
-            "Device disconnected"
-          );
+          throw new BluetoothPrintError(ErrorCode.DEVICE_DISCONNECTED, "Device disconnected");
         }
       } catch (error) {
         this.cleanupDevice(deviceId);
@@ -790,15 +1192,19 @@ class AlipayAdapter extends BaseAdapter {
       this.updateState(PrinterState.CONNECTING);
       this.logger.debug("Connecting to device:", deviceId);
       try {
+        let timeoutId;
         const connectionPromise = my.createBLEConnection({
           deviceId
         });
         const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => {
+          timeoutId = setTimeout(() => {
             reject(new Error("Connection timeout after 10 seconds"));
           }, 1e4);
         });
         yield Promise.race([connectionPromise, timeoutPromise]);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
         this.logger.info("BLE connection established");
         yield this.discoverServices(deviceId);
         this.updateState(PrinterState.CONNECTED);
@@ -879,10 +1285,7 @@ class AlipayAdapter extends BaseAdapter {
         });
         if (!state.connected) {
           this.cleanupDevice(deviceId);
-          throw new BluetoothPrintError(
-            ErrorCode.DEVICE_DISCONNECTED,
-            "Device disconnected"
-          );
+          throw new BluetoothPrintError(ErrorCode.DEVICE_DISCONNECTED, "Device disconnected");
         }
       } catch (error) {
         this.cleanupDevice(deviceId);
@@ -1010,15 +1413,19 @@ class BaiduAdapter extends BaseAdapter {
       this.updateState(PrinterState.CONNECTING);
       this.logger.debug("Connecting to device:", deviceId);
       try {
+        let timeoutId;
         const connectionPromise = swan.createBLEConnection({
           deviceId
         });
         const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => {
+          timeoutId = setTimeout(() => {
             reject(new Error("Connection timeout after 10 seconds"));
           }, 1e4);
         });
         yield Promise.race([connectionPromise, timeoutPromise]);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
         this.logger.info("BLE connection established");
         yield this.discoverServices(deviceId);
         this.updateState(PrinterState.CONNECTED);
@@ -1099,10 +1506,7 @@ class BaiduAdapter extends BaseAdapter {
         });
         if (!state.connected) {
           this.cleanupDevice(deviceId);
-          throw new BluetoothPrintError(
-            ErrorCode.DEVICE_DISCONNECTED,
-            "Device disconnected"
-          );
+          throw new BluetoothPrintError(ErrorCode.DEVICE_DISCONNECTED, "Device disconnected");
         }
       } catch (error) {
         this.cleanupDevice(deviceId);
@@ -1230,15 +1634,19 @@ class ByteDanceAdapter extends BaseAdapter {
       this.updateState(PrinterState.CONNECTING);
       this.logger.debug("Connecting to device:", deviceId);
       try {
+        let timeoutId;
         const connectionPromise = tt.createBLEConnection({
           deviceId
         });
         const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => {
+          timeoutId = setTimeout(() => {
             reject(new Error("Connection timeout after 10 seconds"));
           }, 1e4);
         });
         yield Promise.race([connectionPromise, timeoutPromise]);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
         this.logger.info("BLE connection established");
         yield this.discoverServices(deviceId);
         this.updateState(PrinterState.CONNECTED);
@@ -1319,10 +1727,7 @@ class ByteDanceAdapter extends BaseAdapter {
         });
         if (!state.connected) {
           this.cleanupDevice(deviceId);
-          throw new BluetoothPrintError(
-            ErrorCode.DEVICE_DISCONNECTED,
-            "Device disconnected"
-          );
+          throw new BluetoothPrintError(ErrorCode.DEVICE_DISCONNECTED, "Device disconnected");
         }
       } catch (error) {
         this.cleanupDevice(deviceId);
@@ -1441,201 +1846,902 @@ var PlatformType = /* @__PURE__ */ ((PlatformType2) => {
   PlatformType2["UNKNOWN"] = "unknown";
   return PlatformType2;
 })(PlatformType || {});
+function hasRequestMethod(obj) {
+  return typeof obj === "object" && obj !== null && "request" in obj;
+}
+function isWindowWithNavigator(obj) {
+  return typeof obj === "object" && obj !== null && "navigator" in obj;
+}
 function detectPlatform() {
-  if (typeof wx !== "undefined" && wx.request) {
+  if (typeof wx !== "undefined" && hasRequestMethod(wx)) {
     return "wechat";
   }
-  if (typeof my !== "undefined" && my.request) {
+  if (typeof my !== "undefined" && hasRequestMethod(my)) {
     return "alipay";
   }
-  if (typeof swan !== "undefined" && swan.request) {
+  if (typeof swan !== "undefined" && hasRequestMethod(swan)) {
     return "baidu";
   }
-  if (typeof tt !== "undefined" && tt.request) {
+  if (typeof tt !== "undefined" && hasRequestMethod(tt)) {
     return "bytedance";
   }
-  if (typeof window !== "undefined" && window.navigator) {
+  if (typeof window !== "undefined" && isWindowWithNavigator(window)) {
     return "web";
   }
-  return "unknown";
+  return "unknown";
+}
+class AdapterFactory {
+  /**
+   * Creates an adapter instance based on the detected platform
+   *
+   * @returns An instance of the appropriate adapter for the current platform
+   * @throws BluetoothPrintError if the platform is not supported
+   */
+  static create() {
+    const platform = detectPlatform();
+    switch (platform) {
+      case PlatformType.WECHAT:
+        return new TaroAdapter();
+      case PlatformType.ALIPAY:
+        return new AlipayAdapter();
+      case PlatformType.BAIDU:
+        return new BaiduAdapter();
+      case PlatformType.BYTEDANCE:
+        return new ByteDanceAdapter();
+      default:
+        throw new BluetoothPrintError(
+          ErrorCode.PLATFORM_NOT_SUPPORTED,
+          `Platform ${platform} is not supported. Please use a supported mini-program platform.`
+        );
+    }
+  }
+  /**
+   * Creates an adapter instance for a specific platform
+   *
+   * @param platform - The platform type to create an adapter for
+   * @returns An instance of the appropriate adapter for the specified platform
+   * @throws BluetoothPrintError if the platform is not supported
+   */
+  static createForPlatform(platform) {
+    switch (platform) {
+      case PlatformType.WECHAT:
+        return new TaroAdapter();
+      case PlatformType.ALIPAY:
+        return new AlipayAdapter();
+      case PlatformType.BAIDU:
+        return new BaiduAdapter();
+      case PlatformType.BYTEDANCE:
+        return new ByteDanceAdapter();
+      default:
+        throw new BluetoothPrintError(
+          ErrorCode.PLATFORM_NOT_SUPPORTED,
+          `Platform ${platform} is not supported.`
+        );
+    }
+  }
+}
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let ConnectionManager = class {
+  /**
+   * Creates a new ConnectionManager instance
+   */
+  constructor(adapter) {
+    var _a, _b;
+    this.deviceId = null;
+    this.state = PrinterState.DISCONNECTED;
+    this.logger = Logger.scope("ConnectionManager");
+    this.adapter = adapter || AdapterFactory.create();
+    (_b = (_a = this.adapter).onStateChange) == null ? void 0 : _b.call(_a, (state) => {
+      this.state = state;
+      this.logger.debug("State changed:", state);
+    });
+  }
+  /**
+   * Connects to a Bluetooth device
+   *
+   * @param deviceId - Bluetooth device ID
+   * @returns Promise<void>
+   */
+  connect(deviceId) {
+    return __async(this, null, function* () {
+      this.logger.info("Connecting to device:", deviceId);
+      try {
+        this.deviceId = deviceId;
+        yield this.adapter.connect(deviceId);
+        this.state = PrinterState.CONNECTED;
+        this.logger.info("Connected successfully");
+      } catch (error) {
+        this.deviceId = null;
+        this.state = PrinterState.DISCONNECTED;
+        const printError = error instanceof BluetoothPrintError ? error : new BluetoothPrintError(
+          ErrorCode.CONNECTION_FAILED,
+          "Connection failed",
+          error
+        );
+        this.logger.error("Connection failed:", printError);
+        throw printError;
+      }
+    });
+  }
+  /**
+   * Disconnects from the current device
+   *
+   * @returns Promise<void>
+   */
+  disconnect() {
+    return __async(this, null, function* () {
+      if (!this.deviceId) {
+        this.logger.warn("Disconnect called but no device connected");
+        return;
+      }
+      const deviceId = this.deviceId;
+      this.logger.info("Disconnecting from device:", deviceId);
+      try {
+        yield this.adapter.disconnect(deviceId);
+        this.deviceId = null;
+        this.state = PrinterState.DISCONNECTED;
+        this.logger.info("Disconnected successfully");
+      } catch (error) {
+        const printError = new BluetoothPrintError(
+          ErrorCode.DEVICE_DISCONNECTED,
+          "Disconnect failed",
+          error
+        );
+        this.logger.error("Disconnect failed:", printError);
+        throw printError;
+      }
+    });
+  }
+  /**
+   * Checks if a device is connected
+   *
+   * @returns boolean - True if connected, false otherwise
+   */
+  isConnected() {
+    return this.state === PrinterState.CONNECTED;
+  }
+  /**
+   * Gets the current device ID
+   *
+   * @returns string | null - Device ID or null if not connected
+   */
+  getDeviceId() {
+    return this.deviceId;
+  }
+  /**
+   * Gets the current connection state
+   *
+   * @returns PrinterState - Current state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Gets the printer adapter instance
+   *
+   * @returns IPrinterAdapter - Printer adapter
+   */
+  getAdapter() {
+    return this.adapter;
+  }
+};
+ConnectionManager = __decorateClass$3([
+  Service()
+], ConnectionManager);
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let PrintJobManager = class {
+  /**
+   * Creates a new PrintJobManager instance
+   *
+   * @param connectionManagerOrAdapter - Connection manager instance or adapter instance (for backward compatibility)
+   * @param adapter - Printer adapter instance (optional, will be taken from connectionManager if not provided)
+   */
+  constructor(connectionManagerOrAdapter, adapter) {
+    this.jobBuffer = null;
+    this.jobOffset = 0;
+    this._isPaused = false;
+    this._isInProgress = false;
+    this.adapterOptions = {};
+    this.logger = Logger.scope("PrintJobManager");
+    if (adapter) {
+      this.connectionManager = connectionManagerOrAdapter;
+      this.adapter = adapter;
+    } else if (connectionManagerOrAdapter && typeof connectionManagerOrAdapter.connect === "function") {
+      this.adapter = connectionManagerOrAdapter;
+      this.connectionManager = {
+        getDeviceId: () => "test-device",
+        // Default device ID for backward compatibility
+        isConnected: () => true,
+        getState: () => PrinterState.CONNECTED,
+        // Default to CONNECTED
+        connect: () => Promise.resolve(),
+        disconnect: () => Promise.resolve(),
+        getAdapter: () => this.adapter
+      };
+    } else {
+      this.connectionManager = connectionManagerOrAdapter;
+      if (this.connectionManager && typeof this.connectionManager.getAdapter === "function") {
+        this.adapter = this.connectionManager.getAdapter();
+      } else {
+        throw new Error(
+          "Printer adapter not provided and could not be retrieved from connection manager"
+        );
+      }
+    }
+  }
+  /**
+   * Starts a print job
+   *
+   * @param buffer - Print data buffer
+   * @returns Promise<void>
+   */
+  start(buffer) {
+    return __async(this, null, function* () {
+      if (this._isInProgress) {
+        throw new BluetoothPrintError(
+          ErrorCode.PRINT_JOB_IN_PROGRESS,
+          "A print job is already in progress. Wait for completion or cancel it."
+        );
+      }
+      this.logger.info(`Starting print job: ${buffer.length} bytes`);
+      this.jobBuffer = buffer;
+      this.jobOffset = 0;
+      this._isPaused = false;
+      this._isInProgress = true;
+      try {
+        yield this.processJob();
+        if (this._isPaused) {
+          this.logger.info("Print job paused");
+        } else {
+          this.logger.info("Print job completed successfully");
+          this._isInProgress = false;
+          this.jobBuffer = null;
+          this.jobOffset = 0;
+        }
+      } catch (error) {
+        this.logger.error("Print job failed:", error);
+        this._isInProgress = false;
+        this.jobBuffer = null;
+        this.jobOffset = 0;
+        const printError = error instanceof BluetoothPrintError ? error : new BluetoothPrintError(ErrorCode.PRINT_JOB_FAILED, "Print job failed", error);
+        throw printError;
+      }
+    });
+  }
+  /**
+   * Pauses the current print job
+   */
+  pause() {
+    if (!this._isInProgress) {
+      this.logger.warn("Pause called but no print job in progress");
+      return;
+    }
+    this._isPaused = true;
+    this.logger.info("Print job paused");
+  }
+  /**
+   * Resumes a paused print job
+   *
+   * @returns Promise<void>
+   */
+  resume() {
+    return __async(this, null, function* () {
+      if (!this._isInProgress || !this._isPaused) {
+        this.logger.warn("Resume called but no paused print job");
+        return;
+      }
+      this._isPaused = false;
+      this.logger.info("Print job resumed");
+      try {
+        yield this.processJob();
+        if (!this._isPaused) {
+          this.logger.info("Print job completed successfully");
+          this._isInProgress = false;
+          this.jobBuffer = null;
+          this.jobOffset = 0;
+        }
+      } catch (error) {
+        this.logger.error("Print job failed after resume:", error);
+        this._isInProgress = false;
+        this.jobBuffer = null;
+        this.jobOffset = 0;
+        const printError = error instanceof BluetoothPrintError ? error : new BluetoothPrintError(ErrorCode.PRINT_JOB_FAILED, "Print job failed", error);
+        throw printError;
+      }
+    });
+  }
+  /**
+   * Cancels the current print job
+   */
+  cancel() {
+    if (!this._isInProgress) {
+      this.logger.warn("Cancel called but no print job in progress");
+      return;
+    }
+    this._isPaused = false;
+    this._isInProgress = false;
+    this.jobBuffer = null;
+    this.jobOffset = 0;
+    this.logger.info("Print job cancelled");
+  }
+  /**
+   * Gets the number of bytes remaining to print
+   *
+   * @returns number - Bytes remaining
+   */
+  remaining() {
+    if (this.jobBuffer) {
+      return this.jobBuffer.length - this.jobOffset;
+    }
+    return 0;
+  }
+  /**
+   * Checks if the print job is paused
+   *
+   * @returns boolean - True if paused, false otherwise
+   */
+  isPaused() {
+    return this._isPaused;
+  }
+  /**
+   * Checks if a print job is in progress
+   *
+   * @returns boolean - True if in progress, false otherwise
+   */
+  isInProgress() {
+    return this._isInProgress;
+  }
+  /**
+   * Sets adapter options for write operations
+   *
+   * @param options - Adapter options
+   */
+  setOptions(options) {
+    this.adapterOptions = __spreadValues(__spreadValues({}, this.adapterOptions), options);
+    this.logger.debug("Adapter options updated:", this.adapterOptions);
+  }
+  /**
+   * Processes the print job in chunks
+   * Supports pause/resume functionality
+   *
+   * @returns Promise<void>
+   */
+  processJob() {
+    return __async(this, null, function* () {
+      if (!this.jobBuffer) {
+        return;
+      }
+      if (!this.adapter || typeof this.adapter.write !== "function") {
+        throw new BluetoothPrintError(
+          ErrorCode.INVALID_CONFIGURATION,
+          "Printer adapter does not support write operation"
+        );
+      }
+      const printerChunkSize = 512;
+      const total = this.jobBuffer.length;
+      const jobBuffer = this.jobBuffer;
+      try {
+        while (this.jobOffset < jobBuffer.length) {
+          if (this._isPaused) {
+            this.logger.debug("Job paused at offset:", this.jobOffset);
+            return;
+          }
+          const end = Math.min(this.jobOffset + printerChunkSize, jobBuffer.length);
+          const chunk = jobBuffer.slice(this.jobOffset, end);
+          yield this.adapter.write(this.getDeviceId(), chunk.buffer, this.adapterOptions);
+          this.jobOffset = end;
+          this.logger.debug(`Processed ${this.jobOffset}/${total} bytes`);
+        }
+      } catch (error) {
+        this.logger.error("Error processing job:", error);
+        throw error;
+      }
+    });
+  }
+  /**
+   * Gets the current device ID from the connection manager
+   *
+   * @returns string - Device ID
+   * @throws BluetoothPrintError if no device is connected
+   */
+  getDeviceId() {
+    const deviceId = this.connectionManager.getDeviceId();
+    if (!deviceId) {
+      throw new BluetoothPrintError(ErrorCode.DEVICE_DISCONNECTED, "Device ID not available");
+    }
+    return deviceId;
+  }
+};
+PrintJobManager = __decorateClass$2([
+  Service()
+], PrintJobManager);
+const logger = Logger.scope("Encoding");
+const _Encoding = class _Encoding {
+  /**
+   * Configures the encoding utility
+   *
+   * @param config - Configuration options
+   *
+   * @example
+   * ```typescript
+   * Encoding.configure({
+   *   showWarnings: false
+   * });
+   * ```
+   */
+  static configure(config) {
+    this.config = __spreadValues(__spreadValues({}, this.config), config);
+  }
+  /**
+   * Encodes a string to a Uint8Array using the specified encoding
+   *
+   * @param text - Text to encode
+   * @param encoding - Target encoding (default: 'GBK')
+   * @returns Encoded bytes
+   *
+   * @remarks
+   * Note: Native TextEncoder only supports UTF-8.
+   * For GBK encoding, a third-party library or polyfill is recommended.
+   * Currently falls back to UTF-8 with a warning (configurable).
+   *
+   * @example
+   * ```typescript
+   * // UTF-8 encoding
+   * const utf8 = Encoding.encode('Hello', 'UTF-8');
+   *
+   * // GBK encoding (currently falls back to UTF-8)
+   * const gbk = Encoding.encode('你好', 'GBK');
+   * ```
+   */
+  static encode(text, encoding = "GBK") {
+    if (!text || typeof text !== "string") {
+      return new Uint8Array(0);
+    }
+    const normalizedEncoding = encoding.toUpperCase().replace("-", "");
+    if (normalizedEncoding === "UTF8" || normalizedEncoding === "UTF-8") {
+      return this.utf8Encoder.encode(text);
+    }
+    if (this.config.showWarnings && !this.warningShown) {
+      logger.warn(
+        `Encoding ${encoding} not yet fully implemented, falling back to UTF-8. This may cause display issues with some printers.`
+      );
+      this.warningShown = true;
+    }
+    return this.utf8Encoder.encode(text);
+  }
+  /**
+   * Checks if an encoding is supported
+   *
+   * @param encoding - Encoding name to check
+   * @returns True if supported, false otherwise
+   *
+   * @example
+   * ```typescript
+   * if (Encoding.isSupported('GBK')) {
+   *   console.log('GBK is supported');
+   * } 
+   * ```
+   */
+  static isSupported(encoding) {
+    if (!encoding || typeof encoding !== "string") {
+      return false;
+    }
+    const normalizedEncoding = encoding.toUpperCase().replace("-", "");
+    return normalizedEncoding === "UTF8" || normalizedEncoding === "UTF-8";
+  }
+};
+_Encoding.utf8Encoder = new TextEncoder();
+_Encoding.warningShown = false;
+_Encoding.config = {
+  showWarnings: true
+};
+let Encoding = _Encoding;
+class ImageProcessing {
+  /**
+   * Convert RGBA data to monochrome bitmap (1 bit per pixel)
+   * suitable for ESC/POS GS v 0 command.
+   * Uses Floyd-Steinberg dithering for better quality.
+   *
+   * @param data - RGBA pixel data as Uint8Array
+   * @param width - Image width in pixels
+   * @param height - Image height in pixels
+   * @returns Monochrome bitmap data as Uint8Array
+   *
+   * @example
+   * ```typescript
+   * const imageData = new Uint8Array(width * height * 4); // RGBA
+   * const bitmap = ImageProcessing.toBitmap(imageData, width, height);
+   * ```
+   */
+  static toBitmap(data, width, height) {
+    if (!data || !(data instanceof Uint8Array) || width <= 0 || height <= 0) {
+      return new Uint8Array(0);
+    }
+    if (data.length !== width * height * 4) {
+      throw new Error(
+        `Invalid image data length: expected ${width * height * 4}, got ${data.length}`
+      );
+    }
+    const bytesPerLine = Math.ceil(width / 8);
+    const bitmap = new Uint8Array(bytesPerLine * height);
+    const grayscale = new Float32Array(width * height);
+    for (let i = 0; i < data.length; i += 4) {
+      const index = i / 4;
+      const r = data[i] || 0;
+      const g = data[i + 1] || 0;
+      const b = data[i + 2] || 0;
+      grayscale[index] = 0.299 * r + 0.587 * g + 0.114 * b;
+    }
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const index = y * width + x;
+        const oldPixel = grayscale[index] || 0;
+        const newPixel = oldPixel < 128 ? 0 : 255;
+        if (newPixel === 0) {
+          const byteIndex = y * bytesPerLine + Math.floor(x / 8);
+          const bitIndex = 7 - x % 8;
+          bitmap[byteIndex] = (bitmap[byteIndex] || 0) | 1 << bitIndex;
+        }
+        const quantError = oldPixel - newPixel;
+        this.distributeError(grayscale, width, height, x, y, quantError);
+      }
+    }
+    return bitmap;
+  }
+  /**
+   * Distribute quantization error to neighboring pixels using Floyd-Steinberg algorithm
+   *
+   * @param grayscale - Grayscale image data
+   * @param width - Image width
+   * @param height - Image height
+   * @param x - Current x position
+   * @param y - Current y position
+   * @param error - Quantization error to distribute
+   */
+  static distributeError(grayscale, width, height, x, y, error) {
+    const distribute = (dx, dy, factor) => {
+      const nx = x + dx;
+      const ny = y + dy;
+      if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
+        const index = ny * width + nx;
+        grayscale[index] = Math.max(0, Math.min(255, (grayscale[index] || 0) + error * factor));
+      }
+    };
+    distribute(1, 0, 7 / 16);
+    distribute(-1, 1, 3 / 16);
+    distribute(0, 1, 5 / 16);
+    distribute(1, 1, 1 / 16);
+  }
+}
+class EscPos {
+  constructor() {
+    this.logger = Logger.scope("EscPos");
+  }
+  /**
+   * Initializes the printer
+   * Sends ESC @ command to reset printer to default state
+   *
+   * @returns Array of command buffers
+   */
+  init() {
+    return [new Uint8Array([27, 64])];
+  }
+  /**
+   * Generates text print command
+   *
+   * @param content - Text content to print
+   * @param encoding - Text encoding (default: 'GBK')
+   * @returns Array of command buffers
+   *
+   * @example
+   * ```typescript
+   * driver.text('你好世界', 'GBK');
+   * ```
+   */
+  text(content, encoding = "GBK") {
+    if (!content || typeof content !== "string") {
+      return [];
+    }
+    const encoded = Encoding.encode(content, encoding);
+    return [encoded];
+  }
+  /**
+   * Generates line feed command
+   *
+   * @param lines - Number of lines to feed (default: 1)
+   * @returns Array of command buffers
+   *
+   * @example
+   * ```typescript
+   * driver.feed(3); // Feed 3 lines
+   * ```
+   */
+  feed(lines = 1) {
+    const safeLines = Math.max(1, Math.min(255, Math.floor(lines)));
+    return [new Uint8Array([27, 100, safeLines])];
+  }
+  /**
+   * Generates paper cut command
+   *
+   * @returns Array of command buffers
+   *
+   * @example
+   * ```typescript
+   * driver.cut();
+   * ```
+   */
+  cut() {
+    return [new Uint8Array([29, 86, 0])];
+  }
+  /**
+   * Generates image print command
+   * Uses Floyd-Steinberg dithering for better quality
+   *
+   * @param data - RGBA pixel data
+   * @param width - Image width in pixels
+   * @param height - Image height in pixels
+   * @returns Array of command buffers
+   *
+   * @example
+   * ```typescript
+   * const imageData = new Uint8Array(width * height * 4); // RGBA
+   * driver.image(imageData, 200, 100);
+   * ```
+   */
+  image(data, width, height) {
+    if (!data || !(data instanceof Uint8Array) || width <= 0 || height <= 0) {
+      return [];
+    }
+    if (data.length !== width * height * 4) {
+      this.logger.warn(
+        `Invalid image data length: expected ${width * height * 4}, got ${data.length}`
+      );
+      return [];
+    }
+    const bitmap = ImageProcessing.toBitmap(data, width, height);
+    const bytesPerLine = Math.ceil(width / 8);
+    const xL = bytesPerLine % 256;
+    const xH = Math.floor(bytesPerLine / 256);
+    const yL = height % 256;
+    const yH = Math.floor(height / 256);
+    const header = new Uint8Array([29, 118, 48, 0, xL, xH, yL, yH]);
+    return [header, bitmap];
+  }
+  /**
+   * Generates QR code print command
+   *
+   * @param content - QR code content (URL, text, etc.)
+   * @param options - QR code options
+   * @returns Array of command buffers
+   *
+   * @example
+   * ```typescript
+   * driver.qr('https://example.com', {
+   *   model: 2,
+   *   size: 8,
+   *   errorCorrection: 'M'
+   * });
+   * ```
+   */
+  qr(content, options) {
+    var _a, _b, _c, _d;
+    if (!content || typeof content !== "string") {
+      return [];
+    }
+    const model = (_a = options == null ? void 0 : options.model) != null ? _a : 2;
+    const size = Math.max(1, Math.min(16, (_b = options == null ? void 0 : options.size) != null ? _b : 6));
+    const errorCorrection = (_c = options == null ? void 0 : options.errorCorrection) != null ? _c : "M";
+    const commands = [];
+    commands.push(
+      new Uint8Array([29, 40, 107, 4, 0, 49, 65, model === 1 ? 49 : 50, 0])
+    );
+    commands.push(new Uint8Array([29, 40, 107, 3, 0, 49, 67, size]));
+    const ecMap = { L: 48, M: 49, Q: 50, H: 51 };
+    const ecValue = (_d = ecMap[errorCorrection]) != null ? _d : 49;
+    commands.push(new Uint8Array([29, 40, 107, 3, 0, 49, 69, ecValue]));
+    const data = Encoding.encode(content, "GBK");
+    const len = data.length + 3;
+    const pL = len % 256;
+    const pH = Math.floor(len / 256);
+    commands.push(new Uint8Array([29, 40, 107, pL, pH, 49, 80, 48]));
+    commands.push(data);
+    commands.push(new Uint8Array([29, 40, 107, 3, 0, 49, 81, 48]));
+    return commands;
+  }
 }
-class AdapterFactory {
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let CommandBuilder = class {
   /**
-   * Creates an adapter instance based on the detected platform
-   * 
-   * @returns An instance of the appropriate adapter for the current platform
-   * @throws BluetoothPrintError if the platform is not supported
+   * Creates a new CommandBuilder instance
+   *
+   * @param driver - Printer driver instance
    */
-  static create() {
-    const platform = detectPlatform();
-    switch (platform) {
-      case PlatformType.WECHAT:
-        return new TaroAdapter();
-      case PlatformType.ALIPAY:
-        return new AlipayAdapter();
-      case PlatformType.BAIDU:
-        return new BaiduAdapter();
-      case PlatformType.BYTEDANCE:
-        return new ByteDanceAdapter();
-      default:
-        throw new BluetoothPrintError(
-          ErrorCode.PLATFORM_NOT_SUPPORTED,
-          `Platform ${platform} is not supported. Please use a supported mini-program platform.`
-        );
-    }
+  constructor(driver) {
+    this.buffer = [];
+    this.logger = Logger.scope("CommandBuilder");
+    this.driver = driver || new EscPos();
+    this.buffer.push(...this.driver.init());
   }
   /**
-   * Creates an adapter instance for a specific platform
-   * 
-   * @param platform - The platform type to create an adapter for
-   * @returns An instance of the appropriate adapter for the specified platform
-   * @throws BluetoothPrintError if the platform is not supported
+   * Adds text to the print queue
+   *
+   * @param content - Text content
+   * @param encoding - Text encoding
+   * @returns this - For method chaining
    */
-  static createForPlatform(platform) {
-    switch (platform) {
-      case PlatformType.WECHAT:
-        return new TaroAdapter();
-      case PlatformType.ALIPAY:
-        return new AlipayAdapter();
-      case PlatformType.BAIDU:
-        return new BaiduAdapter();
-      case PlatformType.BYTEDANCE:
-        return new ByteDanceAdapter();
-      default:
-        throw new BluetoothPrintError(
-          ErrorCode.PLATFORM_NOT_SUPPORTED,
-          `Platform ${platform} is not supported.`
-        );
-    }
-  }
-}
-class EventEmitter {
-  constructor() {
-    this.listeners = /* @__PURE__ */ new Map();
+  text(content, encoding) {
+    this.logger.debug("Adding text:", content.substring(0, 50));
+    this.buffer.push(...this.driver.text(content, encoding));
+    return this;
   }
   /**
-   * Subscribe to an event
+   * Adds line feeds to the print queue
    *
-   * @param event - Event name
-   * @param handler - Event handler function
-   * @returns Unsubscribe function
+   * @param lines - Number of lines to feed
+   * @returns this - For method chaining
    */
-  on(event, handler) {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, /* @__PURE__ */ new Set());
-    }
-    this.listeners.get(event).add(handler);
-    return () => this.off(event, handler);
+  feed(lines = 1) {
+    this.logger.debug("Adding feed:", lines);
+    this.buffer.push(...this.driver.feed(lines));
+    return this;
   }
   /**
-   * Subscribe to an event, but only for the first occurrence
+   * Adds a paper cut command to the print queue
    *
-   * @param event - Event name
-   * @param handler - Event handler function
-   * @returns Unsubscribe function
+   * @returns this - For method chaining
    */
-  once(event, handler) {
-    const wrappedHandler = (data) => {
-      handler(data);
-      this.off(event, wrappedHandler);
-    };
-    return this.on(event, wrappedHandler);
+  cut() {
+    this.logger.debug("Adding cut command");
+    this.buffer.push(...this.driver.cut());
+    return this;
   }
   /**
-   * Unsubscribe from an event
+   * Adds an image to the print queue
    *
-   * @param event - Event name
-   * @param handler - Event handler function to remove
+   * @param data - Image data as Uint8Array
+   * @param width - Image width
+   * @param height - Image height
+   * @returns this - For method chaining
    */
-  off(event, handler) {
-    const handlers = this.listeners.get(event);
-    if (handlers) {
-      handlers.delete(handler);
-      if (handlers.size === 0) {
-        this.listeners.delete(event);
-      }
-    }
+  image(data, width, height) {
+    this.logger.debug(`Adding image: ${width}x${height}`);
+    this.buffer.push(...this.driver.image(data, width, height));
+    return this;
   }
   /**
-   * Emit an event to all subscribers
+   * Adds a QR code to the print queue
    *
-   * @param event - Event name
-   * @param data - Event payload (optional for void events)
+   * @param content - QR code content
+   * @param options - QR code options
+   * @returns this - For method chaining
    */
-  emit(event, data) {
-    const handlers = this.listeners.get(event);
-    if (!handlers || handlers.size === 0) {
-      return;
-    }
-    const handlersCopy = new Set(handlers);
-    handlersCopy.forEach((handler) => {
-      try {
-        if (data === void 0 && data === null) {
-          handler("");
-        } else {
-          handler(data);
-        }
-      } catch (error) {
-        console.error(`Error in event handler for "${String(event)}":`, error);
-      }
-    });
+  qr(content, options) {
+    this.logger.debug("Adding QR code:", content.substring(0, 50));
+    this.buffer.push(...this.driver.qr(content, options));
+    return this;
   }
   /**
-   * Remove all event listeners
-   * @param event - Optional event name to remove all listeners for a specific event
+   * Clears the print queue
+   *
+   * @returns this - For method chaining
    */
-  removeAllListeners(event) {
-    if (event) {
-      this.listeners.delete(event);
-    } else {
-      this.listeners.clear();
-    }
+  clear() {
+    this.logger.debug("Clearing buffer");
+    this.buffer = [];
+    this.buffer.push(...this.driver.init());
+    return this;
   }
   /**
-   * Get the number of listeners for an event
+   * Gets the current buffer
    *
-   * @param event - Event name
-   * @returns Number of listeners
+   * @returns Uint8Array - Current print buffer
    */
-  listenerCount(event) {
-    var _a, _b;
-    return (_b = (_a = this.listeners.get(event)) == null ? void 0 : _a.size) != null ? _b : 0;
+  getBuffer() {
+    const totalLength = this.buffer.reduce((acc, b) => acc + b.length, 0);
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const b of this.buffer) {
+      combined.set(b, offset);
+      offset += b.length;
+    }
+    return combined;
   }
   /**
-   * Check if there are any listeners for an event
+   * Gets the total number of bytes in the buffer
    *
-   * @param event - Event name
-   * @returns True if there are listeners, false otherwise
+   * @returns number - Total bytes
    */
-  hasListeners(event) {
-    return this.listenerCount(event) > 0;
+  getTotalBytes() {
+    return this.buffer.reduce((acc, b) => acc + b.length, 0);
   }
-}
-class BluetoothPrinter extends EventEmitter {
+};
+CommandBuilder = __decorateClass$1([
+  Service()
+], CommandBuilder);
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let BluetoothPrinter = class extends EventEmitter {
   /**
    * Creates a new BluetoothPrinter instance
    *
-   * @param adapter - Custom adapter implementation (defaults to platform-specific adapter)
-   * @param driver - Custom driver implementation (defaults to EscPos)
+   * @param connectionManagerOrAdapter - Connection manager instance or printer adapter instance (for backward compatibility)
+   * @param printJobManagerOrDriver - Print job manager instance or printer driver instance (for backward compatibility)
+   * @param commandBuilder - Command builder instance (optional)
    */
-  constructor(adapter, driver) {
-    var _a, _b;
+  constructor(connectionManagerOrAdapter, printJobManagerOrDriver, commandBuilder) {
     super();
-    this.deviceId = null;
-    this.buffer = [];
-    this.adapterOptions = {};
-    this.isPaused = false;
-    this.jobBuffer = null;
-    this.jobOffset = 0;
     this.logger = Logger.scope("BluetoothPrinter");
     this.state = PrinterState.DISCONNECTED;
-    this.adapter = adapter || AdapterFactory.create();
-    this.driver = driver || new EscPos();
-    (_b = (_a = this.adapter).onStateChange) == null ? void 0 : _b.call(_a, (state) => {
-      this.state = state;
-      this.emit("state-change", state);
-      this.logger.debug("State changed:", state);
-    });
+    if (connectionManagerOrAdapter && typeof connectionManagerOrAdapter.connect === "function") {
+      const adapter = connectionManagerOrAdapter;
+      const driver = printJobManagerOrDriver;
+      this.connectionManager = new ConnectionManager(adapter);
+      this.printJobManager = new PrintJobManager(this.connectionManager, adapter);
+      this.commandBuilder = new CommandBuilder(driver);
+    } else {
+      this.connectionManager = connectionManagerOrAdapter;
+      this.printJobManager = printJobManagerOrDriver;
+      this.commandBuilder = commandBuilder;
+      if (!this.connectionManager) {
+        this.connectionManager = new ConnectionManager();
+        this.printJobManager = new PrintJobManager(this.connectionManager);
+        this.commandBuilder = new CommandBuilder();
+      }
+    }
+    this.updateState();
+  }
+  /**
+   * Updates the current state based on the connection manager and print job manager states
+   */
+  updateState() {
+    let connectionState;
+    if (this.connectionManager && typeof this.connectionManager.getState === "function") {
+      connectionState = this.connectionManager.getState();
+    } else {
+      connectionState = PrinterState.CONNECTED;
+    }
+    let isPrinting = false;
+    let isPaused = false;
+    if (this.printJobManager) {
+      isPrinting = typeof this.printJobManager.isInProgress === "function" ? this.printJobManager.isInProgress() : false;
+      isPaused = typeof this.printJobManager.isPaused === "function" ? this.printJobManager.isPaused() : false;
+    }
+    if (isPaused) {
+      this.state = PrinterState.PAUSED;
+    } else if (isPrinting) {
+      this.state = PrinterState.PRINTING;
+    } else {
+      this.state = connectionState;
+    }
+    this.emit("state-change", this.state);
+    this.logger.debug("State updated:", this.state);
   }
   /**
    * Connects to a Bluetooth device
@@ -1653,20 +2759,19 @@ class BluetoothPrinter extends EventEmitter {
     return __async(this, null, function* () {
       this.logger.info("Connecting to device:", deviceId);
       try {
-        this.deviceId = deviceId;
-        yield this.adapter.connect(deviceId);
-        this.buffer.push(...this.driver.init());
+        yield this.connectionManager.connect(deviceId);
+        this.updateState();
         this.emit("connected", deviceId);
         this.logger.info("Connected successfully");
         return this;
       } catch (error) {
-        this.deviceId = null;
         const printError = error instanceof BluetoothPrintError ? error : new BluetoothPrintError(
           ErrorCode.CONNECTION_FAILED,
           "Connection failed",
           error
         );
         this.emit("error", printError);
+        this.updateState();
         throw printError;
       }
     });
@@ -1683,18 +2788,16 @@ class BluetoothPrinter extends EventEmitter {
    */
   disconnect() {
     return __async(this, null, function* () {
-      if (!this.deviceId) {
+      const deviceId = this.connectionManager.getDeviceId();
+      if (!deviceId) {
         this.logger.warn("Disconnect called but no device connected");
         return;
       }
-      const deviceId = this.deviceId;
       this.logger.info("Disconnecting from device:", deviceId);
       try {
-        yield this.adapter.disconnect(deviceId);
-        this.deviceId = null;
-        this.buffer = [];
-        this.jobBuffer = null;
-        this.jobOffset = 0;
+        yield this.connectionManager.disconnect();
+        this.printJobManager.cancel();
+        this.updateState();
         this.emit("disconnected", deviceId);
         this.logger.info("Disconnected successfully");
       } catch (error) {
@@ -1704,6 +2807,7 @@ class BluetoothPrinter extends EventEmitter {
           error
         );
         this.emit("error", printError);
+        this.updateState();
         throw printError;
       }
     });
@@ -1721,8 +2825,7 @@ class BluetoothPrinter extends EventEmitter {
    * ```
    */
   text(content, encoding) {
-    this.logger.debug("Adding text:", content.substring(0, 50));
-    this.buffer.push(...this.driver.text(content, encoding));
+    this.commandBuilder.text(content, encoding);
     return this;
   }
   /**
@@ -1737,8 +2840,7 @@ class BluetoothPrinter extends EventEmitter {
    * ```
    */
   feed(lines = 1) {
-    this.logger.debug("Adding feed:", lines);
-    this.buffer.push(...this.driver.feed(lines));
+    this.commandBuilder.feed(lines);
     return this;
   }
   /**
@@ -1752,8 +2854,7 @@ class BluetoothPrinter extends EventEmitter {
    * ```
    */
   cut() {
-    this.logger.debug("Adding cut command");
-    this.buffer.push(...this.driver.cut());
+    this.commandBuilder.cut();
     return this;
   }
   /**
@@ -1771,8 +2872,7 @@ class BluetoothPrinter extends EventEmitter {
    * ```
    */
   image(data, width, height) {
-    this.logger.debug(`Adding image: ${width}x${height}`);
-    this.buffer.push(...this.driver.image(data, width, height));
+    this.commandBuilder.image(data, width, height);
     return this;
   }
   /**
@@ -1788,8 +2888,7 @@ class BluetoothPrinter extends EventEmitter {
    * ```
    */
   qr(content, options) {
-    this.logger.debug("Adding QR code:", content.substring(0, 50));
-    this.buffer.push(...this.driver.qr(content, options));
+    this.commandBuilder.qr(content, options);
     return this;
   }
   /**
@@ -1804,8 +2903,7 @@ class BluetoothPrinter extends EventEmitter {
    * ```
    */
   setOptions(options) {
-    this.adapterOptions = __spreadValues(__spreadValues({}, this.adapterOptions), options);
-    this.logger.debug("Adapter options updated:", this.adapterOptions);
+    this.printJobManager.setOptions(options);
     return this;
   }
   /**
@@ -1820,9 +2918,8 @@ class BluetoothPrinter extends EventEmitter {
    * ```
    */
   pause() {
-    this.isPaused = true;
-    this.state = PrinterState.PAUSED;
-    this.emit("state-change", PrinterState.PAUSED);
+    this.printJobManager.pause();
+    this.updateState();
     this.logger.info("Print job paused");
   }
   /**
@@ -1837,16 +2934,11 @@ class BluetoothPrinter extends EventEmitter {
    */
   resume() {
     return __async(this, null, function* () {
-      if (!this.isPaused || !this.jobBuffer) {
-        this.logger.warn("Resume called but job not paused or no job buffer");
-        return;
-      }
-      this.isPaused = false;
-      this.state = PrinterState.PRINTING;
-      this.emit("state-change", PrinterState.PRINTING);
-      this.logger.info("Print job resumed");
+      this.logger.info("Resuming print job");
       try {
-        yield this.processJob();
+        yield this.printJobManager.resume();
+        this.updateState();
+        this.logger.info("Print job resumed");
       } catch (error) {
         const printError = new BluetoothPrintError(
           ErrorCode.PRINT_JOB_FAILED,
@@ -1854,6 +2946,7 @@ class BluetoothPrinter extends EventEmitter {
           error
         );
         this.emit("error", printError);
+        this.updateState();
         throw printError;
       }
     });
@@ -1867,12 +2960,9 @@ class BluetoothPrinter extends EventEmitter {
    * ```
    */
   cancel() {
-    this.isPaused = false;
-    this.jobBuffer = null;
-    this.jobOffset = 0;
-    this.buffer = [];
-    this.state = this.deviceId ? PrinterState.CONNECTED : PrinterState.DISCONNECTED;
-    this.emit("state-change", this.state);
+    this.printJobManager.cancel();
+    this.commandBuilder.clear();
+    this.updateState();
     this.logger.info("Print job cancelled");
   }
   /**
@@ -1886,10 +2976,7 @@ class BluetoothPrinter extends EventEmitter {
    * ```
    */
   remaining() {
-    if (this.jobBuffer) {
-      return this.jobBuffer.length - this.jobOffset;
-    }
-    return this.buffer.reduce((acc, b) => acc + b.length, 0);
+    return this.printJobManager.remaining();
   }
   /**
    * Sends all queued commands to the printer
@@ -1907,91 +2994,39 @@ class BluetoothPrinter extends EventEmitter {
    */
   print() {
     return __async(this, null, function* () {
-      if (!this.deviceId) {
+      if (!this.connectionManager.isConnected()) {
         throw new BluetoothPrintError(
           ErrorCode.CONNECTION_FAILED,
           "Printer not connected. Call connect() first."
         );
       }
-      if (this.jobBuffer) {
-        throw new BluetoothPrintError(
-          ErrorCode.PRINT_JOB_IN_PROGRESS,
-          "A print job is already in progress. Wait for completion or cancel it."
-        );
-      }
-      const totalLength = this.buffer.reduce((acc, b) => acc + b.length, 0);
-      this.logger.info(`Starting print job: ${totalLength} bytes`);
-      const combined = new Uint8Array(totalLength);
-      let offset = 0;
-      for (const b of this.buffer) {
-        combined.set(b, offset);
-        offset += b.length;
-      }
-      this.jobBuffer = combined;
-      this.jobOffset = 0;
-      this.buffer = [];
-      this.isPaused = false;
-      this.state = PrinterState.PRINTING;
-      this.emit("state-change", this.state);
+      const buffer = this.commandBuilder.getBuffer();
+      this.logger.info(`Starting print job: ${buffer.length} bytes`);
+      this.commandBuilder.clear();
+      this.updateState();
       try {
-        yield this.processJob();
-        if (this.isPaused) {
+        yield this.printJobManager.start(buffer);
+        const isPaused = typeof this.printJobManager.isPaused === "function" ? this.printJobManager.isPaused() : false;
+        if (isPaused) {
           this.logger.info("Print job paused");
         } else {
           this.emit("print-complete");
           this.logger.info("Print job completed successfully");
-          this.state = PrinterState.CONNECTED;
-          this.emit("state-change", this.state);
         }
       } catch (error) {
+        this.logger.error("Print job failed with error:", error);
         const printError = error instanceof BluetoothPrintError ? error : new BluetoothPrintError(ErrorCode.PRINT_JOB_FAILED, "Print job failed", error);
         this.emit("error", printError);
-        this.state = PrinterState.CONNECTED;
-        this.emit("state-change", this.state);
         throw printError;
-      }
-    });
-  }
-  /**
-   * Processes the print job in chunks
-   * Supports pause/resume and emits progress events
-   */
-  processJob() {
-    return __async(this, null, function* () {
-      if (!this.jobBuffer || !this.deviceId) return;
-      const printerChunkSize = 512;
-      const total = this.jobBuffer.length;
-      const deviceId = this.deviceId;
-      const jobBuffer = this.jobBuffer;
-      try {
-        while (this.jobOffset < jobBuffer.length) {
-          if (this.isPaused) {
-            this.logger.debug("Job paused at offset:", this.jobOffset);
-            return;
-          }
-          if (this.state !== PrinterState.CONNECTED && this.state !== PrinterState.PRINTING && this.state !== PrinterState.PAUSED) {
-            throw new BluetoothPrintError(
-              ErrorCode.DEVICE_DISCONNECTED,
-              "Device disconnected during print job"
-            );
-          }
-          const end = Math.min(this.jobOffset + printerChunkSize, jobBuffer.length);
-          const chunk = jobBuffer.slice(this.jobOffset, end);
-          yield this.adapter.write(deviceId, chunk.buffer, this.adapterOptions);
-          this.jobOffset = end;
-          if (this.hasListeners("progress")) {
-            this.emit("progress", { sent: this.jobOffset, total });
-          }
-        }
       } finally {
-        if (this.jobOffset >= jobBuffer.length) {
-          this.jobBuffer = null;
-          this.jobOffset = 0;
-        }
+        this.updateState();
       }
     });
   }
-}
+};
+BluetoothPrinter = __decorateClass([
+  Service()
+], BluetoothPrinter);
 const DEFAULT_CONFIG = {
   adapter: {
     chunkSize: 20,