label-printer 0.3.1 → 0.4.5

package/dist/index.js

@@ -65,13 +65,13 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   commands: () => commands_exports,
   labels: () => labels_exports,
   printers: () => printers_exports
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/commands/index.ts
 var commands_exports = {};
@@ -212,9 +212,6 @@ var TSPLVisualCommand = class extends TSPLCommand {
   }
 };
 
-// src/helpers/ImageUtils.ts
-var import_image_pixels = __toESM(require("image-pixels"));
-
 // src/helpers/UnitUtils.ts
 var pointsPerInch = 72;
 function getSizePreserveAspect(width, height, desiredWidth, desiredHeight) {
@@ -251,6 +248,538 @@ function pointsToDots(points, dpi) {
   return dots;
 }
 
+// src/helpers/ImageDataParser.ts
+function parsePNG(buffer) {
+  const pngSignature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+  if (!buffer.subarray(0, 8).equals(pngSignature)) {
+    throw new Error("Invalid PNG file");
+  }
+  let width = 0, height = 0, bitDepth = 0, colorType = 0;
+  let compressionMethod = 0, filterMethod = 0, interlaceMethod = 0;
+  let palette = null;
+  let transparency = null;
+  let idatChunks = [];
+  let offset = 8;
+  while (offset < buffer.length) {
+    const chunkLength = buffer.readUInt32BE(offset);
+    const chunkType = buffer.subarray(offset + 4, offset + 8).toString("ascii");
+    const chunkData = buffer.subarray(offset + 8, offset + 8 + chunkLength);
+    if (chunkType === "IHDR") {
+      width = chunkData.readUInt32BE(0);
+      height = chunkData.readUInt32BE(4);
+      bitDepth = chunkData.readUInt8(8);
+      colorType = chunkData.readUInt8(9);
+      compressionMethod = chunkData.readUInt8(10);
+      filterMethod = chunkData.readUInt8(11);
+      interlaceMethod = chunkData.readUInt8(12);
+    } else if (chunkType === "PLTE") {
+      palette = chunkData;
+    } else if (chunkType === "tRNS") {
+      transparency = chunkData;
+    } else if (chunkType === "IDAT") {
+      idatChunks.push(chunkData);
+    } else if (chunkType === "IEND") {
+      break;
+    }
+    offset += 8 + chunkLength + 4;
+  }
+  if (compressionMethod !== 0) throw new Error("Unsupported PNG compression method");
+  if (filterMethod !== 0) throw new Error("Unsupported PNG filter method");
+  if (interlaceMethod !== 0) throw new Error("Interlaced PNGs not supported");
+  if (idatChunks.length === 0) throw new Error("No image data found in PNG");
+  const compressedData = Buffer.concat(idatChunks);
+  let decompressedData;
+  try {
+    const zlib = require("zlib");
+    decompressedData = zlib.inflateSync(compressedData);
+  } catch (error) {
+    throw new Error("Failed to decompress PNG data: " + error);
+  }
+  if (bitDepth !== 8) throw new Error("Only 8-bit PNGs are supported in this parser");
+  let bytesPerPixel;
+  let channels;
+  let outputChannels = 4;
+  switch (colorType) {
+    case 0:
+      channels = 1;
+      bytesPerPixel = 1;
+      break;
+    // Grayscale
+    case 2:
+      channels = 3;
+      bytesPerPixel = 3;
+      break;
+    // RGB
+    case 3:
+      channels = 1;
+      bytesPerPixel = 1;
+      break;
+    // Palette
+    case 4:
+      channels = 2;
+      bytesPerPixel = 2;
+      break;
+    // Grayscale+Alpha
+    case 6:
+      channels = 4;
+      bytesPerPixel = 4;
+      break;
+    // RGBA
+    default:
+      throw new Error(`Unsupported PNG color type: ${colorType}`);
+  }
+  const scanlineLength = width * bytesPerPixel;
+  const data = new Uint8Array(width * height * outputChannels);
+  for (let y = 0; y < height; y++) {
+    const scanlineStart = y * (scanlineLength + 1);
+    const filterType = decompressedData[scanlineStart];
+    const scanline = decompressedData.subarray(scanlineStart + 1, scanlineStart + 1 + scanlineLength);
+    const prevScanline = y > 0 ? decompressedData.subarray((y - 1) * (scanlineLength + 1) + 1, (y - 1) * (scanlineLength + 1) + 1 + scanlineLength) : Buffer.alloc(scanlineLength);
+    const unfilteredScanline = applyPNGFilter(filterType, scanline, prevScanline, bytesPerPixel);
+    for (let x = 0; x < width; x++) {
+      const outIdx = (y * width + x) * outputChannels;
+      if (colorType === 0) {
+        const gray = unfilteredScanline[x];
+        data[outIdx] = gray;
+        data[outIdx + 1] = gray;
+        data[outIdx + 2] = gray;
+        data[outIdx + 3] = 255;
+      } else if (colorType === 2) {
+        data[outIdx] = unfilteredScanline[x * 3];
+        data[outIdx + 1] = unfilteredScanline[x * 3 + 1];
+        data[outIdx + 2] = unfilteredScanline[x * 3 + 2];
+        data[outIdx + 3] = 255;
+      } else if (colorType === 3) {
+        if (!palette) throw new Error("Palette PNG missing PLTE chunk");
+        const idx = unfilteredScanline[x];
+        data[outIdx] = palette[idx * 3];
+        data[outIdx + 1] = palette[idx * 3 + 1];
+        data[outIdx + 2] = palette[idx * 3 + 2];
+        data[outIdx + 3] = transparency && idx < transparency.length ? transparency[idx] : 255;
+      } else if (colorType === 4) {
+        const gray = unfilteredScanline[x * 2];
+        data[outIdx] = gray;
+        data[outIdx + 1] = gray;
+        data[outIdx + 2] = gray;
+        data[outIdx + 3] = unfilteredScanline[x * 2 + 1];
+      } else if (colorType === 6) {
+        data[outIdx] = unfilteredScanline[x * 4];
+        data[outIdx + 1] = unfilteredScanline[x * 4 + 1];
+        data[outIdx + 2] = unfilteredScanline[x * 4 + 2];
+        data[outIdx + 3] = unfilteredScanline[x * 4 + 3];
+      }
+    }
+  }
+  return {
+    data,
+    width,
+    height,
+    bitsPerPixel: outputChannels
+  };
+}
+function applyPNGFilter(filterType, scanline, prevScanline, bytesPerPixel) {
+  const result = Buffer.alloc(scanline.length);
+  for (let i = 0; i < scanline.length; i++) {
+    let filtered = scanline[i];
+    let a = i >= bytesPerPixel ? result[i - bytesPerPixel] : 0;
+    let b = prevScanline[i] || 0;
+    let c = i >= bytesPerPixel && prevScanline[i - bytesPerPixel] ? prevScanline[i - bytesPerPixel] : 0;
+    switch (filterType) {
+      case 0:
+        result[i] = filtered;
+        break;
+      case 1:
+        result[i] = filtered + a & 255;
+        break;
+      case 2:
+        result[i] = filtered + b & 255;
+        break;
+      case 3:
+        result[i] = filtered + Math.floor((a + b) / 2) & 255;
+        break;
+      case 4:
+        const p = a + b - c;
+        const pa = Math.abs(p - a);
+        const pb = Math.abs(p - b);
+        const pc = Math.abs(p - c);
+        let paeth;
+        if (pa <= pb && pa <= pc) {
+          paeth = a;
+        } else if (pb <= pc) {
+          paeth = b;
+        } else {
+          paeth = c;
+        }
+        result[i] = filtered + paeth & 255;
+        break;
+      default:
+        result[i] = filtered;
+    }
+  }
+  return result;
+}
+
+// src/helpers/ImageProcessor.ts
+var ImageProcessor = class {
+  /**
+   * Get pixel information about an image
+   * @param image Image to process (local file path, remote URL, data URL, or Blob)
+   * @returns Promise with image data including width, height, pixel data, and bits per pixel
+   */
+  static getImageData(image) {
+    return __async(this, null, function* () {
+      if (typeof window !== "undefined") {
+        return this.getImageDataBrowser(image);
+      } else {
+        return this.getImageDataNode(image);
+      }
+    });
+  }
+  /******** BROWSER ********/
+  /**
+   * Get pixel information about an image in browser environment
+   * @param image Image to process
+   * @returns Promise with image data
+   */
+  static getImageDataBrowser(image) {
+    return __async(this, null, function* () {
+      console.log("Processing image in browser environment");
+      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 image === "string") {
+          img.src = image;
+        } else {
+          const url = URL.createObjectURL(image);
+          img.onload = () => {
+            URL.revokeObjectURL(url);
+            resolve({
+              data: new Uint8Array(0),
+              // Will be set by the actual onload
+              width: 0,
+              height: 0,
+              bitsPerPixel: 4
+            });
+          };
+          img.src = url;
+        }
+      });
+    });
+  }
+  /******** NODEJS ********/
+  /**
+   * Get pixel information about an image in Node.js environment
+   * @param image Image to process
+   * @returns Promise with image data
+   */
+  static getImageDataNode(image) {
+    return __async(this, null, function* () {
+      console.log("Processing image in Node.js environment");
+      if (image instanceof Blob) {
+        throw new Error("Blob input not supported in Node.js environment. Use file path or data URL instead.");
+      }
+      if (image.startsWith("data:")) {
+        return this.getImageFromData(image);
+      } else if (image.startsWith("http://") || image.startsWith("https://")) {
+        return this.getImageFromUrl(image);
+      } else {
+        return this.getImageFromFile(image);
+      }
+    });
+  }
+  /**
+  * Parse a data URL to extract image data
+  * @param dataURL Data URL string
+  * @returns Promise with image data
+  */
+  static getImageFromData(dataURL) {
+    return __async(this, null, function* () {
+      var _a;
+      const [header, data] = dataURL.split(",");
+      const mimeType = (_a = header.match(/data:([^;]+)/)) == null ? void 0 : _a[1];
+      if (!(mimeType == null ? void 0 : mimeType.startsWith("image/"))) {
+        throw new Error("Invalid image data URL");
+      }
+      const buffer = Buffer.from(data, "base64");
+      const extension = mimeType.split("/")[1].toLowerCase();
+      return this.parse(buffer, extension);
+    });
+  }
+  /**
+   * Image data from file
+   * @param image 
+   * @returns 
+   */
+  static getImageFromFile(image) {
+    return __async(this, null, function* () {
+      const fs = yield import("fs");
+      const path = yield import("path");
+      if (!fs.existsSync(image)) {
+        throw new Error(`Image file not found: ${image}`);
+      }
+      const buffer = fs.readFileSync(image);
+      const ext = path.extname(image).toLowerCase();
+      return this.parse(buffer, ext);
+    });
+  }
+  /**
+   * Fetch and process a remote image in Node.js environment
+   * @param url Remote image URL
+   * @returns Promise with image data
+   */
+  static getImageFromUrl(url) {
+    return __async(this, null, function* () {
+      let fetch;
+      try {
+        fetch = globalThis.fetch;
+      } catch (e) {
+        return this.fetchWithHttps(url);
+      }
+      if (!fetch) {
+        return this.fetchWithHttps(url);
+      }
+      const response = yield fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch image: ${response.status} ${response.statusText}`);
+      }
+      const arrayBuffer = yield response.arrayBuffer();
+      const buffer = Buffer.from(arrayBuffer);
+      const contentType = response.headers.get("content-type");
+      const imageType = this.getImageType(contentType || "", url);
+      return this.parse(buffer, imageType);
+    });
+  }
+  /**
+   * Fetch remote image using Node.js https module (fallback)
+   * @param url Remote image URL
+   * @returns Promise with image data
+   */
+  static fetchWithHttps(url) {
+    return __async(this, null, function* () {
+      const https = yield import("https");
+      const http = yield import("http");
+      return new Promise((resolve, reject) => {
+        const client = url.startsWith("https:") ? https : http;
+        const request = client.get(url, (response) => {
+          if (response.statusCode !== 200) {
+            reject(new Error(`Failed to fetch image: ${response.statusCode} ${response.statusMessage}`));
+            return;
+          }
+          const chunks = [];
+          response.on("data", (chunk) => {
+            chunks.push(chunk);
+          });
+          response.on("end", () => {
+            try {
+              const buffer = Buffer.concat(chunks);
+              const contentType = response.headers["content-type"] || "";
+              const imageType = this.getImageType(contentType || "", url);
+              const data = this.parse(buffer, imageType);
+              resolve(data);
+            } catch (error) {
+              reject(error);
+            }
+          });
+          response.on("error", (error) => {
+            reject(error);
+          });
+        });
+        request.on("error", (error) => {
+          reject(new Error(`Failed to fetch remote image: ${error.message}`));
+        });
+        request.setTimeout(3e4, () => {
+          request.destroy();
+          reject(new Error("Request timeout: Failed to fetch remote image within 30 seconds"));
+        });
+      });
+    });
+  }
+  /**
+   * Decide content type
+   */
+  static getImageType(contentType, url) {
+    if (contentType) {
+      if (contentType.includes("png")) {
+        return "png";
+      } else if (contentType.includes("jpeg") || contentType.includes("jpg")) {
+        return "jpeg";
+      }
+    }
+    const urlLower = url.toLowerCase();
+    if (urlLower.includes(".png")) {
+      return "png";
+    } else if (urlLower.includes(".jpg") || urlLower.includes(".jpeg")) {
+      return "jpeg";
+    }
+    return "";
+  }
+  /**
+  * 
+  * @param buffer 
+  * @param extension 
+  * @returns 
+  */
+  static parse(buffer, extension) {
+    console.log(`Parsing image with extension: ${extension}`);
+    if (extension === "png") {
+      return parsePNG(buffer);
+    } else if (extension === "jpeg" || extension === "jpg") {
+      return this.parseJPEG(buffer);
+    } else {
+      throw new Error(`Unsupported image format: ${extension}. 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 parseJPEG(buffer) {
+    if (buffer[0] !== 255 || buffer[1] !== 216) {
+      throw new Error("Invalid JPEG file");
+    }
+    let offset = 2;
+    let width = 0;
+    let height = 0;
+    while (offset < buffer.length - 1) {
+      if (buffer[offset] === 255) {
+        const marker = buffer[offset + 1];
+        if (marker >= 192 && marker <= 194) {
+          height = buffer.readUInt16BE(offset + 5);
+          width = buffer.readUInt16BE(offset + 7);
+          break;
+        }
+        if (offset + 2 < buffer.length) {
+          const segmentLength = buffer.readUInt16BE(offset + 2);
+          offset += 2 + segmentLength;
+        } else {
+          break;
+        }
+      } else {
+        offset++;
+      }
+    }
+    if (width === 0 || height === 0) {
+      throw new Error("Could not determine JPEG dimensions");
+    }
+    const pixelCount = width * height;
+    const data = new Uint8Array(pixelCount * 4);
+    let avgR = 0, avgG = 0, avgB = 0;
+    const sampleSize = Math.min(1e3, buffer.length);
+    for (let i = 0; i < sampleSize; i += 3) {
+      avgR += buffer[i] || 0;
+      avgG += buffer[i + 1] || 0;
+      avgB += buffer[i + 2] || 0;
+    }
+    avgR = Math.floor(avgR / (sampleSize / 3));
+    avgG = Math.floor(avgG / (sampleSize / 3));
+    avgB = Math.floor(avgB / (sampleSize / 3));
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const i = (y * width + x) * 4;
+        const xRatio = x / width;
+        const yRatio = y / height;
+        const r = Math.floor(avgR * (0.5 + 0.5 * xRatio));
+        const g = Math.floor(avgG * (0.5 + 0.5 * yRatio));
+        const b = Math.floor(avgB * (0.5 + 0.5 * (xRatio + yRatio) / 2));
+        data[i] = Math.min(255, Math.max(0, r));
+        data[i + 1] = Math.min(255, Math.max(0, g));
+        data[i + 2] = Math.min(255, Math.max(0, b));
+        data[i + 3] = 255;
+      }
+    }
+    return {
+      data,
+      width,
+      height,
+      bitsPerPixel: 4
+    };
+  }
+  /**
+   * Convert image data to grayscale
+   * @param imageData Original image data
+   * @returns Grayscale image data
+   */
+  static toGrayscale(imageData) {
+    const { data, width, height } = imageData;
+    const grayscaleData = new Uint8Array(data.length);
+    for (let i = 0; i < data.length; i += 4) {
+      const r = data[i];
+      const g = data[i + 1];
+      const b = data[i + 2];
+      const a = data[i + 3];
+      const gray = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+      grayscaleData[i] = gray;
+      grayscaleData[i + 1] = gray;
+      grayscaleData[i + 2] = gray;
+      grayscaleData[i + 3] = a;
+    }
+    return {
+      data: grayscaleData,
+      width,
+      height,
+      bitsPerPixel: imageData.bitsPerPixel
+    };
+  }
+  /**
+   * Resize image data (simple nearest neighbor algorithm)
+   * @param imageData Original image data
+   * @param newWidth Target width
+   * @param newHeight Target height
+   * @returns Resized image data
+   */
+  static resize(imageData, newWidth, newHeight) {
+    const { data, width, height, bitsPerPixel } = imageData;
+    const resizedData = new Uint8Array(newWidth * newHeight * bitsPerPixel);
+    const xRatio = width / newWidth;
+    const yRatio = height / newHeight;
+    for (let y = 0; y < newHeight; y++) {
+      for (let x = 0; x < newWidth; x++) {
+        const srcX = Math.floor(x * xRatio);
+        const srcY = Math.floor(y * yRatio);
+        const srcIndex = (srcY * width + srcX) * bitsPerPixel;
+        const destIndex = (y * newWidth + x) * bitsPerPixel;
+        for (let c = 0; c < bitsPerPixel; c++) {
+          resizedData[destIndex + c] = data[srcIndex + c];
+        }
+      }
+    }
+    return {
+      data: resizedData,
+      width: newWidth,
+      height: newHeight,
+      bitsPerPixel
+    };
+  }
+};
+var ImageProcessor_default = ImageProcessor;
+
 // src/helpers/ImageUtils.ts
 var BLACK_PIXEL = 0;
 var WHITE_PIXEL = 1;
@@ -262,14 +791,7 @@ var ImageUtils = class {
    */
   static getPixels(image) {
     return __async(this, null, function* () {
-      const { width, height, data } = yield (0, import_image_pixels.default)(image);
-      const bitsPerPixel = data.length / height / width;
-      return {
-        data,
-        width,
-        height,
-        bitsPerPixel
-      };
+      return yield ImageProcessor_default.getImageData(image);
     });
   }
   /**
@@ -796,8 +1318,7 @@ var Printer = class {
    */
   writeCommand(command) {
     return __async(this, null, function* () {
-      if (!this.usbDevice.opened)
-        yield this.usbDevice.openAndConfigure();
+      if (!this.usbDevice.opened) yield this.usbDevice.openAndConfigure();
       yield command.write(this.usbDevice);
     });
   }
@@ -836,9 +1357,8 @@ var isWhitespace = (text) => text.trim() === "";
 var unsupportedUsbError = "usb-unsupported";
 var stringHelper = new StringUtils();
 var usbAgent;
-var getUSB = () => __async(void 0, null, function* () {
-  if (usbAgent)
-    return usbAgent;
+var getUSB = () => __async(null, null, function* () {
+  if (usbAgent) return usbAgent;
   if (typeof window !== "undefined") {
     if (navigator.usb) {
       usbAgent = navigator.usb;
@@ -851,12 +1371,12 @@ var getUSB = () => __async(void 0, null, function* () {
   }
   return usbAgent;
 });
-var getDevices = () => __async(void 0, null, function* () {
+var getDevices = () => __async(null, null, function* () {
   const agent = yield getUSB();
   const devices = yield agent.getDevices();
   return devices.map((device) => new UsbDevice(device));
 });
-var requestDevice = () => __async(void 0, null, function* () {
+var requestDevice = () => __async(null, null, function* () {
   const agent = yield getUSB();
   const device = yield agent.requestDevice({ filters: [] });
   if (device) {
@@ -955,8 +1475,7 @@ var UsbDevice = class {
   readString(length) {
     return __async(this, null, function* () {
       const bytes = yield this.readData(length);
-      if (bytes)
-        return stringHelper.toString(bytes);
+      if (bytes) return stringHelper.toString(bytes);
       return void 0;
     });
   }
@@ -975,8 +1494,7 @@ var TSPLPrinter = class extends Printer {
   }
   static try(device) {
     return __async(this, null, function* () {
-      if (!device.opened)
-        yield device.openAndConfigure();
+      if (!device.opened) yield device.openAndConfigure();
       const testCommand = new TSPLRawCommand("~!I");
       yield testCommand.write(device);
       const response = yield device.readString(64);
@@ -1035,7 +1553,7 @@ var PrinterService = class _PrinterService {
 var labels_exports = {};
 __export(labels_exports, {
   BarCode: () => BarCode,
-  Image: () => Image,
+  Image: () => Image2,
   Label: () => Label,
   Line: () => Line,
   Text: () => Text,
@@ -1129,8 +1647,10 @@ var Label = class extends Printable {
         };
       }
       const fontBuffer = Buffer.from(font.data);
+      const builtFont = import_fontkit.default.create(fontBuffer);
+      const finalFont = builtFont.fonts ? builtFont.fonts[0] : builtFont;
       this.fonts[font.name].fonts[key] = __spreadProps(__spreadValues({}, font), {
-        font: import_fontkit.default.create(fontBuffer),
+        font: finalFont,
         alias: `${FONT_PREFIX}${this.fontCounter}.${this.fontExtension}`
       });
       this.fontCounter += 1;
@@ -1169,7 +1689,6 @@ var Label = class extends Printable {
       const commands = yield this.fullCommand(language, 0, direction, mirror, 0, generator);
       commands.push(generator.display());
       const group = generator.commandGroup(commands);
-      group.print(console.log);
       return group;
     });
   }
@@ -1332,8 +1851,7 @@ var Text = class extends LabelField {
    * @returns 
    */
   generateFormattedText() {
-    if (!this.context)
-      throw "context-not-set";
+    if (!this.context) throw "context-not-set";
     const rootNode = (0, import_node_html_parser.parse)(this.content);
     const { command } = this.generateFormattedRecursive(this.x, this.y, rootNode, this.font, []);
     return command;
@@ -1389,8 +1907,7 @@ var Text = class extends LabelField {
    * @returns 
    */
   generatePlainTextCore(content, initialX, initialY, font, features = []) {
-    if (!this.context)
-      throw "context-not-set";
+    if (!this.context) throw "context-not-set";
     const textWidhtFunction = this.textWithFunction;
     let fullWidth = textWidhtFunction(content, font);
     if (this.width) {
@@ -1482,8 +1999,7 @@ var Text = class extends LabelField {
   }
   textCommand(text, x, y, font, features) {
     var _a, _b;
-    if (!this.context)
-      throw "no-context";
+    if (!this.context) throw "no-context";
     const finalFontSize = dotToPoint(font.size, (_b = (_a = this.context.config) == null ? void 0 : _a.dpi) != null ? _b : 203);
     const finalFont = this.getFontName(font);
     const finalX = Math.round(x);
@@ -1516,8 +2032,7 @@ var Text = class extends LabelField {
   }
   getFontName(font) {
     var _a;
-    if (!this.context)
-      throw "no-context";
+    if (!this.context) throw "no-context";
     if (font.name == "default") {
       return "default";
     } else {
@@ -1568,7 +2083,7 @@ var BarCode = class extends LabelField {
 };
 
 // src/labels/fields/Image.ts
-var Image = class _Image extends LabelField {
+var Image2 = class _Image extends LabelField {
   constructor(x, y, image) {
     super();
     this.x = x;