label-printer 0.5.4 → 0.7.0

package/dist/index.js

@@ -22,9 +22,9 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __export = (target, all) => {
+var __export = (target2, all) => {
   for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+    __defProp(target2, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -34,15 +34,15 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+var __toESM = (mod2, isNodeMode, target2) => (target2 = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
   // compatible transform (i.e. "__esModule" has not been set), then set
   // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
+  isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target2, "default", { value: mod2, enumerable: true }) : target2,
+  mod2
 ));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -87,10 +87,10 @@ var Command = class {
     fn(this.commandString);
   }
   /**
-   * Write the command data to a USB device
+   * Write the command data to a device
    * @param device Device to write to
    */
-  write(device) {
+  writeTo(device) {
     return __async(this, null, function* () {
       yield this.writeString(this.commandString, device);
       yield this.terminateCommand(device);
@@ -144,10 +144,10 @@ var CommandGroup = class extends Command {
       this.commands[commandIndex].print(fn);
     }
   }
-  write(device) {
+  writeTo(device) {
     return __async(this, null, function* () {
       for (let commandIndex in this.commands) {
-        yield this.commands[commandIndex].write(device);
+        yield this.commands[commandIndex].writeTo(device);
       }
     });
   }
@@ -424,14 +424,15 @@ var ImageProcessor = class {
   /**
    * Get pixel information about an image
    * @param image Image to process (local file path, remote URL, data URL, or Blob)
+   * @param target Optional target raster size. Useful for vector inputs (e.g. SVG) to rasterize at the final size.
    * @returns Promise with image data including width, height, pixel data, and bits per pixel
    */
-  static getImageData(image2) {
+  static getImageData(image2, target2) {
     return __async(this, null, function* () {
       if (typeof window !== "undefined") {
-        return this.getImageDataBrowser(image2);
+        return this.getImageDataBrowser(image2, target2);
       } else {
-        return this.getImageDataNode(image2);
+        return this.getImageDataNode(image2, target2);
       }
     });
   }
@@ -439,74 +440,76 @@ var ImageProcessor = class {
   /**
    * Get pixel information about an image in browser environment
    * @param image Image to process
+   * @param target Optional target raster size.
    * @returns Promise with image data
    */
-  static getImageDataBrowser(image2) {
+  static getImageDataBrowser(image2, target2) {
     return __async(this, null, function* () {
-      return new Promise((resolve, reject) => {
-        const img = new Image();
-        img.crossOrigin = "anonymous";
-        img.onload = () => {
-          try {
-            const canvas = document.createElement("canvas");
-            const ctx = canvas.getContext("2d");
-            if (!ctx) {
-              reject(new Error("Could not get canvas context"));
-              return;
-            }
-            canvas.width = img.width;
-            canvas.height = img.height;
-            ctx.drawImage(img, 0, 0);
-            const imageData = ctx.getImageData(0, 0, img.width, img.height);
-            resolve({
-              data: new Uint8Array(imageData.data),
-              width: img.width,
-              height: img.height,
-              bitsPerPixel: 4
-              // RGBA
-            });
-          } catch (error) {
-            reject(error);
-          }
-        };
-        img.onerror = () => reject(new Error("Failed to load image"));
-        if (typeof image2 === "string") {
-          img.src = image2;
-        } else {
-          const url2 = URL.createObjectURL(image2);
-          img.onload = () => {
-            URL.revokeObjectURL(url2);
-            resolve({
-              data: new Uint8Array(0),
-              // Will be set by the actual onload
-              width: 0,
-              height: 0,
-              bitsPerPixel: 4
-            });
-          };
-          img.src = url2;
+      var _a, _b;
+      const loadImage = (src2) => {
+        return new Promise((resolve, reject) => {
+          const img = new Image();
+          img.crossOrigin = "anonymous";
+          img.onload = () => resolve(img);
+          img.onerror = () => reject(new Error("Failed to load image"));
+          img.src = src2;
+        });
+      };
+      let src;
+      let revokeUrl;
+      if (typeof image2 === "string") {
+        src = this.normalizePotentialSVGSource(image2);
+      } else {
+        revokeUrl = URL.createObjectURL(image2);
+        src = revokeUrl;
+      }
+      try {
+        const img = yield loadImage(src);
+        const canvas = document.createElement("canvas");
+        const ctx = canvas.getContext("2d");
+        if (!ctx) {
+          throw new Error("Could not get canvas context");
         }
-      });
+        const width = (_a = target2 == null ? void 0 : target2.width) != null ? _a : img.width;
+        const height = (_b = target2 == null ? void 0 : target2.height) != null ? _b : img.height;
+        canvas.width = width;
+        canvas.height = height;
+        ctx.drawImage(img, 0, 0, width, height);
+        const imageData2 = ctx.getImageData(0, 0, width, height);
+        return {
+          data: new Uint8Array(imageData2.data),
+          width,
+          height,
+          bitsPerPixel: 4
+        };
+      } finally {
+        if (revokeUrl) URL.revokeObjectURL(revokeUrl);
+      }
     });
   }
   /******** NODEJS ********/
   /**
    * Get pixel information about an image in Node.js environment
    * @param image Image to process
+   * @param target Optional target raster size.
    * @returns Promise with image data
    */
-  static getImageDataNode(image2) {
+  static getImageDataNode(image2, _target) {
     return __async(this, null, function* () {
       console.log("Processing image in Node.js environment");
       if (image2 instanceof Blob) {
         throw new Error("Blob input not supported in Node.js environment. Use file path or data URL instead.");
       }
+      const trimmed = image2.trim();
+      if (trimmed.startsWith("<svg")) {
+        return this.rasterizeSVGNode(trimmed, _target);
+      }
       if (image2.startsWith("data:")) {
-        return this.getImageFromData(image2);
+        return this.getImageFromData(image2, _target);
       } else if (image2.startsWith("http://") || image2.startsWith("https://")) {
-        return this.getImageFromUrl(image2);
+        return this.getImageFromUrl(image2, _target);
       } else {
-        return this.getImageFromFile(image2);
+        return this.getImageFromFile(image2, _target);
       }
     });
   }
@@ -515,7 +518,7 @@ var ImageProcessor = class {
   * @param dataURL Data URL string
   * @returns Promise with image data
   */
-  static getImageFromData(dataURL) {
+  static getImageFromData(dataURL, target2) {
     return __async(this, null, function* () {
       var _a;
       const [header, data] = dataURL.split(",");
@@ -523,8 +526,13 @@ var ImageProcessor = class {
       if (!(mimeType == null ? void 0 : mimeType.startsWith("image/"))) {
         throw new Error("Invalid image data URL");
       }
-      const buffer2 = Buffer.from(data, "base64");
       const extension = mimeType.split("/")[1].toLowerCase();
+      if (extension === "svg+xml" || mimeType === "image/svg+xml") {
+        const isBase64 = header.includes(";base64");
+        const svgText = isBase64 ? Buffer.from(data, "base64").toString("utf8") : decodeURIComponent(data);
+        return this.rasterizeSVGNode(svgText, target2);
+      }
+      const buffer2 = Buffer.from(data, "base64");
       return this.parse(buffer2, extension);
     });
   }
@@ -533,7 +541,7 @@ var ImageProcessor = class {
    * @param image 
    * @returns 
    */
-  static getImageFromFile(image) {
+  static getImageFromFile(image, target) {
     return __async(this, null, function* () {
       const fs = yield eval("require")("fs");
       const path = yield eval("require")("path");
@@ -542,6 +550,10 @@ var ImageProcessor = class {
       }
       const buffer = fs.readFileSync(image);
       const ext = path.extname(image).toLowerCase();
+      if (ext === ".svg") {
+        const svgText = buffer.toString("utf8");
+        return this.rasterizeSVGNode(svgText, target);
+      }
       return this.parse(buffer, ext);
     });
   }
@@ -550,16 +562,16 @@ var ImageProcessor = class {
    * @param url Remote image URL
    * @returns Promise with image data
    */
-  static getImageFromUrl(url2) {
+  static getImageFromUrl(url2, target2) {
     return __async(this, null, function* () {
       let fetch;
       try {
         fetch = globalThis.fetch;
       } catch (e) {
-        return this.fetchWithHttps(url2);
+        return this.fetchWithHttps(url2, target2);
       }
       if (!fetch) {
-        return this.fetchWithHttps(url2);
+        return this.fetchWithHttps(url2, target2);
       }
       const response = yield fetch(url2);
       if (!response.ok) {
@@ -569,6 +581,10 @@ var ImageProcessor = class {
       const buffer2 = Buffer.from(arrayBuffer);
       const contentType = response.headers.get("content-type");
       const imageType = this.getImageType(contentType || "", url2);
+      if (imageType === "svg") {
+        const svgText = buffer2.toString("utf8");
+        return this.rasterizeSVGNode(svgText, target2);
+      }
       return this.parse(buffer2, imageType);
     });
   }
@@ -577,7 +593,7 @@ var ImageProcessor = class {
    * @param url Remote image URL
    * @returns Promise with image data
    */
-  static fetchWithHttps(url) {
+  static fetchWithHttps(url, target) {
     return __async(this, null, function* () {
       const https = yield eval("require")("https");
       const http = yield eval("require")("http");
@@ -597,8 +613,12 @@ var ImageProcessor = class {
               const buffer2 = Buffer.concat(chunks);
               const contentType = response.headers["content-type"] || "";
               const imageType = this.getImageType(contentType || "", url);
-              const data = this.parse(buffer2, imageType);
-              resolve(data);
+              if (imageType === "svg") {
+                const svgText = buffer2.toString("utf8");
+                resolve(this.rasterizeSVGNode(svgText, target));
+                return;
+              }
+              resolve(this.parse(buffer2, imageType));
             } catch (error) {
               reject(error);
             }
@@ -626,6 +646,8 @@ var ImageProcessor = class {
         return "png";
       } else if (contentType.includes("jpeg") || contentType.includes("jpg")) {
         return "jpeg";
+      } else if (contentType.includes("svg")) {
+        return "svg";
       }
     }
     const urlLower = url2.toLowerCase();
@@ -633,32 +655,57 @@ var ImageProcessor = class {
       return "png";
     } else if (urlLower.includes(".jpg") || urlLower.includes(".jpeg")) {
       return "jpeg";
+    } else if (urlLower.includes(".svg")) {
+      return "svg";
     }
     return "";
   }
   /**
-  * 
-  * @param buffer 
-  * @param extension 
-  * @returns 
-  */
+   * Parse image data by extension
+   */
   static parse(buffer2, extension) {
-    console.log(`Parsing image with extension: ${extension}`);
-    if (extension === "png") {
+    const normalizedExtension = extension.startsWith(".") ? extension.slice(1) : extension;
+    console.log(`Parsing image with extension: ${normalizedExtension}`);
+    if (normalizedExtension === "png") {
       return parsePNG(buffer2);
-    } else if (extension === "jpeg" || extension === "jpg") {
+    } else if (normalizedExtension === "jpeg" || normalizedExtension === "jpg") {
       return this.parseJPEG(buffer2);
+    } else if (normalizedExtension === "svg") {
+      throw new Error("svg-not-supported-in-node");
     } else {
-      throw new Error(`Unsupported image format: ${extension}. Supported formats: PNG, JPEG`);
+      throw new Error(`Unsupported image format: ${normalizedExtension}. Supported formats: PNG, JPEG`);
     }
   }
-  /**
-   * JPEG parser that creates a meaningful placeholder image
-   * Note: Full JPEG decoding requires complex DCT and Huffman decoding.
-   * This creates a gradient pattern based on the image dimensions.
-   * @param buffer JPEG file buffer
-   * @returns Image data
-   */
+  static rasterizeSVGNode(svg, target) {
+    let Resvg;
+    try {
+      Resvg = eval("require")("@resvg/resvg-js").Resvg;
+    } catch (_e) {
+      throw new Error("svg-rasterizer-missing");
+    }
+    const fitTo = target ? { mode: "width", value: target.width } : void 0;
+    const resvg = new Resvg(svg, {
+      fitTo
+    });
+    const pngData = resvg.render().asPng();
+    const pngBuffer = Buffer.from(pngData);
+    const imageData = parsePNG(pngBuffer);
+    if (target && (imageData.width !== target.width || imageData.height !== target.height)) {
+      return this.resize(imageData, target.width, target.height);
+    }
+    return imageData;
+  }
+  static normalizePotentialSVGSource(source) {
+    const trimmed = source.trim();
+    const isInlineSvg = trimmed.startsWith("<svg");
+    const isSvgDataUrl = trimmed.startsWith("data:image/svg+xml");
+    if (isInlineSvg) {
+      const encoded = encodeURIComponent(trimmed);
+      return `data:image/svg+xml;charset=utf-8,${encoded}`;
+    }
+    if (isSvgDataUrl) return source;
+    return source;
+  }
   static parseJPEG(buffer2) {
     if (buffer2[0] !== 255 || buffer2[1] !== 216) {
       throw new Error("Invalid JPEG file");
@@ -725,8 +772,8 @@ var ImageProcessor = class {
    * @param imageData Original image data
    * @returns Grayscale image data
    */
-  static toGrayscale(imageData) {
-    const { data, width, height } = imageData;
+  static toGrayscale(imageData2) {
+    const { data, width, height } = imageData2;
     const grayscaleData = new Uint8Array(data.length);
     for (let i = 0; i < data.length; i += 4) {
       const r = data[i];
@@ -743,7 +790,7 @@ var ImageProcessor = class {
       data: grayscaleData,
       width,
       height,
-      bitsPerPixel: imageData.bitsPerPixel
+      bitsPerPixel: imageData2.bitsPerPixel
     };
   }
   /**
@@ -753,8 +800,8 @@ var ImageProcessor = class {
    * @param newHeight Target height
    * @returns Resized image data
    */
-  static resize(imageData, newWidth, newHeight) {
-    const { data, width, height, bitsPerPixel } = imageData;
+  static resize(imageData2, newWidth, newHeight) {
+    const { data, width, height, bitsPerPixel } = imageData2;
     const resizedData = new Uint8Array(newWidth * newHeight * bitsPerPixel);
     const xRatio = width / newWidth;
     const yRatio = height / newHeight;
@@ -782,15 +829,17 @@ var ImageProcessor_default = ImageProcessor;
 // src/helpers/ImageUtils.ts
 var BLACK_PIXEL = 0;
 var WHITE_PIXEL = 1;
+var DEFAULT_THRESHOLD = 200;
 var ImageUtils = class {
   /**
    * Get pixel information about an image
    * @param image Image to process
+   * @param target Optional target raster size. Useful for vector inputs (e.g. SVG) to rasterize at the final size.
    * @returns 
    */
-  static getPixels(image2) {
+  static getPixels(image2, target2) {
     return __async(this, null, function* () {
-      return yield ImageProcessor_default.getImageData(image2);
+      return yield ImageProcessor_default.getImageData(image2, target2);
     });
   }
   /**
@@ -810,7 +859,10 @@ var ImageUtils = class {
         width,
         height,
         bitsPerPixel
-      } = yield this.getPixels(image2);
+      } = yield this.getPixels(
+        image2,
+        destinationWidth != null && destinationHeight != null ? { width: destinationWidth, height: destinationHeight } : void 0
+      );
       const dim = getSizePreserveAspect(width, height, destinationWidth, destinationHeight);
       const dWidth = dim.width;
       const dHeight = dim.height;
@@ -826,16 +878,16 @@ var ImageUtils = class {
           const r = data[baseIndex];
           const g = data[baseIndex + 1];
           const b = data[baseIndex + 2];
-          const a = data[baseIndex + 3];
-          if (a > 128) {
-            const avg = (r + g + b) / 3;
-            if (avg > 128) {
-              bitmapData[destinationIndex] = WHITE_PIXEL;
-            } else {
-              bitmapData[destinationIndex] = BLACK_PIXEL;
-            }
-          } else {
+          const a = bitsPerPixel > 3 ? data[baseIndex + 3] : 255;
+          const alpha = a / 255;
+          const rC = r * alpha + 255 * (1 - alpha);
+          const gC = g * alpha + 255 * (1 - alpha);
+          const bC = b * alpha + 255 * (1 - alpha);
+          const luminance = 0.299 * rC + 0.587 * gC + 0.114 * bC;
+          if (luminance > DEFAULT_THRESHOLD) {
             bitmapData[destinationIndex] = WHITE_PIXEL;
+          } else {
+            bitmapData[destinationIndex] = BLACK_PIXEL;
           }
           destinationIndex += 1;
         }
@@ -916,7 +968,7 @@ var TSPLBitmapCommand = class _TSPLBitmapCommand extends TSPLVisualCommand {
         return 2;
     }
   }
-  write(device) {
+  writeTo(device) {
     return __async(this, null, function* () {
       yield this.writeString(this.commandWithoutBytes, device);
       yield this.writeBytes(this.bitmap.bytes, device);
@@ -1097,7 +1149,7 @@ var TSPLDownload = class extends TSPLCommand {
   get commandString() {
     return `DOWNLOAD "${this.fileName}", ${this.data.byteLength},`;
   }
-  write(device) {
+  writeTo(device) {
     return __async(this, null, function* () {
       yield this.writeString(this.commandString, device);
       yield this.writeBytes(this.data, device);
@@ -1281,14 +1333,14 @@ __export(printers_exports, {
 // src/printers/Printer.ts
 var Printer = class {
   constructor(device) {
-    this.usbDevice = device;
+    this.device = device;
   }
   /**
    * Close the printer USB
    */
   close() {
     return __async(this, null, function* () {
-      yield this.usbDevice.close();
+      yield this.device.close();
     });
   }
   /**
@@ -1317,8 +1369,8 @@ var Printer = class {
    */
   writeCommand(command) {
     return __async(this, null, function* () {
-      if (!this.usbDevice.opened) yield this.usbDevice.openAndConfigure();
-      yield command.write(this.usbDevice);
+      if (!this.device.opened) yield this.device.openAndConfigure();
+      yield command.writeTo(this.device);
     });
   }
   /**
@@ -1486,8 +1538,214 @@ var UsbDevice = class {
   }
 };
 
+// src/helpers/NetworkDevice.ts
+var unsupportedNetworkError = "network-unsupported";
+var stringHelper2 = new StringUtils();
+var getNet = () => {
+  if (typeof window !== "undefined") {
+    throw unsupportedNetworkError;
+  }
+  return eval("require")("net");
+};
+var NetworkDevice = class {
+  /**
+   * Create a TCP-based device.
+   *
+   * This is intended for raw printing ports (typically 9100). It is Node-only.
+   *
+   * @param host Hostname or IP
+   * @param port TCP port (defaults to 9100)
+   * @param connectTimeoutMs Connection timeout
+   * @param readTimeoutMs Read timeout used by `readData`/`readString`
+   */
+  constructor(host, port = 9100, connectTimeoutMs = 2e3, readTimeoutMs = 500) {
+    this.host = host;
+    this.port = port;
+    this.connectTimeoutMs = connectTimeoutMs;
+    this.readTimeoutMs = readTimeoutMs;
+  }
+  get opened() {
+    return !!this.socket;
+  }
+  openAndConfigure() {
+    return __async(this, null, function* () {
+      if (this.socket) return;
+      const net = getNet();
+      yield new Promise((resolve, reject) => {
+        let settled = false;
+        const timeout = setTimeout(() => {
+          var _a;
+          if (settled) return;
+          settled = true;
+          try {
+            (_a = this.socket) == null ? void 0 : _a.destroy();
+          } catch (_e) {
+          }
+          this.socket = void 0;
+          reject(new Error("network-connect-timeout"));
+        }, this.connectTimeoutMs);
+        try {
+          const socket = net.createConnection({ host: this.host, port: this.port }, () => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeout);
+            resolve();
+          });
+          socket.once("error", (err) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeout);
+            this.socket = void 0;
+            reject(err);
+          });
+          this.socket = socket;
+        } catch (e) {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timeout);
+          this.socket = void 0;
+          reject(e);
+        }
+      });
+    });
+  }
+  close() {
+    return __async(this, null, function* () {
+      if (!this.socket) return;
+      const socket = this.socket;
+      this.socket = void 0;
+      try {
+        socket.end();
+      } catch (_e) {
+        try {
+          socket.destroy();
+        } catch (_e2) {
+        }
+      }
+    });
+  }
+  writeData(data) {
+    return __async(this, null, function* () {
+      if (!this.socket) {
+        throw new Error("network-not-open");
+      }
+      yield new Promise((resolve, reject) => {
+        try {
+          this.socket.write(data, (err) => {
+            if (err) reject(err);
+            else resolve();
+          });
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+  }
+  writeString(text) {
+    return __async(this, null, function* () {
+      const bytes = stringHelper2.toUTF8Array(text);
+      yield this.writeData(bytes);
+    });
+  }
+  readData(length) {
+    return __async(this, null, function* () {
+      if (!this.socket) {
+        throw new Error("network-not-open");
+      }
+      const socket = this.socket;
+      const buffer2 = yield new Promise((resolve, reject) => {
+        let settled = false;
+        const onData = (data) => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          resolve(data);
+        };
+        const onError = (err) => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          reject(err);
+        };
+        const cleanup = () => {
+          clearTimeout(timeout);
+          socket.removeListener("data", onData);
+          socket.removeListener("error", onError);
+        };
+        const timeout = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          resolve(void 0);
+        }, this.readTimeoutMs);
+        socket.once("data", onData);
+        socket.once("error", onError);
+      });
+      if (!buffer2) return void 0;
+      if (buffer2.byteLength > length) return void 0;
+      return new DataView(buffer2.buffer.slice(buffer2.byteOffset, buffer2.byteOffset + buffer2.byteLength));
+    });
+  }
+  readString(length) {
+    return __async(this, null, function* () {
+      const bytes = yield this.readData(length);
+      if (bytes) return stringHelper2.toString(bytes);
+      return void 0;
+    });
+  }
+};
+
+// src/helpers/BonjourUtils.ts
+var unsupportedBonjourError = "bonjour-unsupported";
+var getBonjour = () => {
+  var _a;
+  if (typeof window !== "undefined") {
+    throw unsupportedBonjourError;
+  }
+  const mod = eval("require")("bonjour");
+  const factory = mod && ((_a = mod.default) != null ? _a : mod);
+  if (typeof factory !== "function") {
+    throw new Error("bonjour-invalid-module");
+  }
+  return factory;
+};
+var discoverBonjourServices = (types, timeoutMs = 1500) => __async(null, null, function* () {
+  if (typeof window !== "undefined") return [];
+  const factory2 = getBonjour();
+  const bonjour = factory2();
+  try {
+    const results = [];
+    const seen = /* @__PURE__ */ new Set();
+    const browsers = types.map((type) => {
+      return bonjour.find({ type }, (service) => {
+        var _a;
+        const host = ((_a = service == null ? void 0 : service.referer) == null ? void 0 : _a.address) || (service == null ? void 0 : service.host);
+        const port = service == null ? void 0 : service.port;
+        if (!host || !port) return;
+        const key = `${host}:${port}`;
+        if (seen.has(key)) return;
+        seen.add(key);
+        results.push({ host, port, name: service == null ? void 0 : service.name, type });
+      });
+    });
+    yield new Promise((resolve) => setTimeout(resolve, timeoutMs));
+    for (const browser of browsers) {
+      try {
+        browser.stop();
+      } catch (_e) {
+      }
+    }
+    return results;
+  } finally {
+    try {
+      bonjour.destroy();
+    } catch (_e) {
+    }
+  }
+});
+
 // src/printers/TSPLPrinter.ts
-var TSPLPrinter = class extends Printer {
+var TSPLPrinter = class _TSPLPrinter extends Printer {
   get language() {
     return "tspl";
   }
@@ -1501,12 +1759,152 @@ var TSPLPrinter = class extends Printer {
     return __async(this, null, function* () {
       if (!device.opened) yield device.openAndConfigure();
       const testCommand = new TSPLRawCommand("~!I");
-      yield testCommand.write(device);
+      yield testCommand.writeTo(device);
       const response = yield device.readString(64);
       yield device.close();
       return !!response;
     });
   }
+  /**
+   * Discover TSPL-capable printers on the local network.
+   *
+   * Strategy:
+   * - Use Bonjour/mDNS to discover "printer-ish" services to obtain a set of candidate hosts.
+   * - For each unique host, probe TCP/9100 by sending the TSPL identify command (~!I).
+   * - Only return devices that respond to the TSPL probe.
+   * - If Bonjour yields no candidates (e.g. mDNS is blocked), fall back to a conservative
+   *   subnet scan on local private /24 networks (still verified by the same TSPL probe).
+   */
+  static discoverDevices() {
+    return __async(this, null, function* () {
+      if (typeof window !== "undefined") return [];
+      const services = yield discoverBonjourServices([
+        "pdl-datastream",
+        "printer",
+        "ipp",
+        "ipps"
+      ]);
+      let uniqueHosts = Array.from(new Set(services.map((s) => s.host).filter(Boolean)));
+      if (uniqueHosts.length === 0) {
+        uniqueHosts = yield _TSPLPrinter.discoverHostsBySubnetScan();
+      }
+      const candidates = uniqueHosts.map((host) => ({ host, port: 9100 }));
+      const concurrency = 5;
+      const verified = [];
+      for (let i = 0; i < candidates.length; i += concurrency) {
+        const batch = candidates.slice(i, i + concurrency);
+        const results = yield Promise.all(batch.map((c) => __async(null, null, function* () {
+          const device = new NetworkDevice(c.host, c.port, 4e3, 1e3);
+          try {
+            const ok = yield _TSPLPrinter.try(device);
+            return ok ? device : void 0;
+          } catch (_e) {
+            try {
+              yield device.close();
+            } catch (_e2) {
+            }
+            return void 0;
+          }
+        })));
+        verified.push(...results.filter(Boolean));
+      }
+      return verified;
+    });
+  }
+  /**
+   * Fallback discovery mechanism used when Bonjour/mDNS returns no printer candidates.
+   *
+   * It derives local private IPv4 /24 prefixes from the current machine's network interfaces
+   * and probes TCP/9100 using the TSPL identify command.
+   *
+   * The scan is intentionally conservative:
+   * - Limited number of prefixes
+   * - Concurrency limits
+   * - Total time cap
+   * - Early-exit when at least one printer is found
+   */
+  static discoverHostsBySubnetScan() {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      if (typeof window !== "undefined") return [];
+      const req = _TSPLPrinter.getNodeRequire();
+      if (!req) return [];
+      const os = req("os");
+      const networkInterfaces = (_b = (_a = os.networkInterfaces) == null ? void 0 : _a.call(os)) != null ? _b : {};
+      const privatePrefixes = /* @__PURE__ */ new Set();
+      const isPrivateIpv4 = (ip) => {
+        if (ip.startsWith("10.")) return true;
+        if (ip.startsWith("192.168.")) return true;
+        const m = ip.match(/^172\.(\d+)\./);
+        if (m) {
+          const n = Number(m[1]);
+          return n >= 16 && n <= 31;
+        }
+        return false;
+      };
+      for (const key of Object.keys(networkInterfaces)) {
+        const infos = (_c = networkInterfaces[key]) != null ? _c : [];
+        for (const info of infos) {
+          const family = info == null ? void 0 : info.family;
+          const address = info == null ? void 0 : info.address;
+          const internal = info == null ? void 0 : info.internal;
+          if (internal) continue;
+          if (family !== "IPv4") continue;
+          if (typeof address !== "string") continue;
+          if (!isPrivateIpv4(address)) continue;
+          const parts = address.split(".");
+          if (parts.length !== 4) continue;
+          privatePrefixes.add(`${parts[0]}.${parts[1]}.${parts[2]}`);
+        }
+      }
+      const prefixes = Array.from(privatePrefixes).slice(0, 2);
+      if (prefixes.length === 0) return [];
+      const hosts = [];
+      for (const prefix of prefixes) {
+        for (let i = 1; i <= 254; i++) {
+          hosts.push(`${prefix}.${i}`);
+        }
+      }
+      const concurrency = 30;
+      const verifiedHosts = [];
+      const startedAt = Date.now();
+      const maxDurationMs = 15e3;
+      for (let i = 0; i < hosts.length; i += concurrency) {
+        if (Date.now() - startedAt > maxDurationMs) break;
+        if (verifiedHosts.length > 0) break;
+        const batch = hosts.slice(i, i + concurrency);
+        const results = yield Promise.all(batch.map((host) => __async(null, null, function* () {
+          const device = new NetworkDevice(host, 9100, 800, 800);
+          try {
+            const ok = yield _TSPLPrinter.try(device);
+            return ok ? host : void 0;
+          } catch (_e) {
+            try {
+              yield device.close();
+            } catch (_e2) {
+            }
+            return void 0;
+          }
+        })));
+        verifiedHosts.push(...results.filter(Boolean));
+      }
+      return verifiedHosts;
+    });
+  }
+  /**
+   * Returns a Node-style `require` function.
+   *
+   * This is used to keep runtime dependencies Node-only while still allowing the library to
+   * be imported/bundled in browser contexts.
+   *
+   * Tests may inject a custom require implementation via `globalThis.__label_printer_require`.
+   */
+  static getNodeRequire() {
+    if (typeof window !== "undefined") return void 0;
+    const override = globalThis.__label_printer_require;
+    if (typeof override === "function") return override;
+    return eval("require");
+  }
 };
 
 // src/printers/PrinterService.ts
@@ -1531,12 +1929,40 @@ var PrinterService = class _PrinterService {
       return void 0;
     });
   }
+  /**
+   * Discover devices using printer-specific discovery hooks.
+   *
+   * Each printer class may optionally implement `static discoverDevices(): Promise<Device[]>`
+   * to find candidates over non-USB transports.
+   *
+   * Candidates returned here are still verified by `printerForDevice` via the printer
+   * class' `try(device)` method.
+   */
+  static discoverDevices() {
+    return __async(this, null, function* () {
+      const classes = [TSPLPrinter];
+      const discoveryResults = yield Promise.all(classes.map((cls) => __async(null, null, function* () {
+        const discoverer = cls.discoverDevices;
+        if (typeof discoverer === "function") {
+          try {
+            return yield discoverer.call(cls);
+          } catch (_e) {
+            return [];
+          }
+        }
+        return [];
+      })));
+      return discoveryResults.flat();
+    });
+  }
   /**
    * @returns List of available printers
    */
   static getPrinters() {
     return __async(this, null, function* () {
-      const devices = yield getDevices();
+      const usbDevices = yield getDevices();
+      const discoveredDevices = yield _PrinterService.discoverDevices();
+      const devices = [...usbDevices, ...discoveredDevices];
       const optionalPrinters = yield Promise.all(devices.map(_PrinterService.printerForDevice));
       return optionalPrinters.filter((printer) => !!printer);
     });