@huh-david/bmp-js 0.3.0 → 0.4.1

package/dist/index.cjs

@@ -28,16 +28,39 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/binary.ts
+function toUint8Array(input) {
+  if (input instanceof ArrayBuffer) {
+    return new Uint8Array(input);
+  }
+  return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+}
+function assertInteger(name, value) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+}
+
 // src/decoder.ts
+var FILE_HEADER_SIZE = 14;
+var INFO_HEADER_MIN = 40;
+var CORE_HEADER_SIZE = 12;
+function rowStride(width, bitPP) {
+  return Math.floor((bitPP * width + 31) / 32) * 4;
+}
 var BmpDecoder = class {
   pos = 0;
-  buffer;
-  isWithAlpha;
+  bytes;
+  view;
+  options;
   bottomUp = true;
+  dibStart = FILE_HEADER_SIZE;
+  paletteEntrySize = 4;
+  externalMaskOffset = 0;
   maskRed = 0;
   maskGreen = 0;
   maskBlue = 0;
-  mask0 = 0;
+  maskAlpha = 0;
   fileSize;
   reserved;
   offset;
@@ -54,67 +77,174 @@ var BmpDecoder = class {
   importantColors;
   palette;
   data;
-  constructor(buffer, isWithAlpha = false) {
-    this.buffer = buffer;
-    this.isWithAlpha = isWithAlpha;
-    const flag = this.buffer.toString("utf-8", 0, this.pos += 2);
-    if (flag !== "BM") {
-      throw new Error("Invalid BMP File");
-    }
-    this.parseHeader();
+  constructor(input, options = {}) {
+    this.bytes = toUint8Array(input);
+    this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);
+    this.options = {
+      treat16BitAs15BitAlpha: options.treat16BitAs15BitAlpha ?? false,
+      toRGBA: options.toRGBA ?? false
+    };
+    this.parseFileHeader();
+    this.parseDibHeader();
+    this.parsePalette();
+    this.pos = this.offset;
     this.parseRGBA();
+    this.transformToRgbaIfNeeded();
   }
-  parseHeader() {
-    this.fileSize = this.buffer.readUInt32LE(this.pos);
-    this.pos += 4;
-    this.reserved = this.buffer.readUInt32LE(this.pos);
-    this.pos += 4;
-    this.offset = this.buffer.readUInt32LE(this.pos);
-    this.pos += 4;
-    this.headerSize = this.buffer.readUInt32LE(this.pos);
-    this.pos += 4;
-    this.width = this.buffer.readUInt32LE(this.pos);
-    this.pos += 4;
-    this.height = this.buffer.readInt32LE(this.pos);
-    this.pos += 4;
-    this.planes = this.buffer.readUInt16LE(this.pos);
-    this.pos += 2;
-    this.bitPP = this.buffer.readUInt16LE(this.pos);
-    this.pos += 2;
-    this.compress = this.buffer.readUInt32LE(this.pos);
-    this.pos += 4;
-    this.rawSize = this.buffer.readUInt32LE(this.pos);
-    this.pos += 4;
-    this.hr = this.buffer.readUInt32LE(this.pos);
-    this.pos += 4;
-    this.vr = this.buffer.readUInt32LE(this.pos);
-    this.pos += 4;
-    this.colors = this.buffer.readUInt32LE(this.pos);
-    this.pos += 4;
-    this.importantColors = this.buffer.readUInt32LE(this.pos);
-    this.pos += 4;
-    if (this.bitPP === 16 && this.isWithAlpha) {
-      this.bitPP = 15;
+  ensureReadable(offset, size, context) {
+    if (offset < 0 || size < 0 || offset + size > this.bytes.length) {
+      throw new Error(`BMP decode out-of-range while reading ${context}`);
     }
-    if (this.bitPP < 15) {
-      const len = this.colors === 0 ? 1 << this.bitPP : this.colors;
-      this.palette = new Array(len);
-      for (let i = 0; i < len; i += 1) {
-        const blue = this.buffer.readUInt8(this.pos++);
-        const green = this.buffer.readUInt8(this.pos++);
-        const red = this.buffer.readUInt8(this.pos++);
-        const quad = this.buffer.readUInt8(this.pos++);
-        this.palette[i] = { red, green, blue, quad };
-      }
+  }
+  readUInt8(offset = this.pos) {
+    this.ensureReadable(offset, 1, "uint8");
+    if (offset === this.pos) this.pos += 1;
+    return this.view.getUint8(offset);
+  }
+  readUInt16LE(offset = this.pos) {
+    this.ensureReadable(offset, 2, "uint16");
+    if (offset === this.pos) this.pos += 2;
+    return this.view.getUint16(offset, true);
+  }
+  readInt16LE(offset = this.pos) {
+    this.ensureReadable(offset, 2, "int16");
+    if (offset === this.pos) this.pos += 2;
+    return this.view.getInt16(offset, true);
+  }
+  readUInt32LE(offset = this.pos) {
+    this.ensureReadable(offset, 4, "uint32");
+    if (offset === this.pos) this.pos += 4;
+    return this.view.getUint32(offset, true);
+  }
+  readInt32LE(offset = this.pos) {
+    this.ensureReadable(offset, 4, "int32");
+    if (offset === this.pos) this.pos += 4;
+    return this.view.getInt32(offset, true);
+  }
+  parseFileHeader() {
+    this.ensureReadable(0, FILE_HEADER_SIZE, "file header");
+    if (this.bytes[0] !== 66 || this.bytes[1] !== 77) {
+      throw new Error("Invalid BMP file signature");
     }
+    this.pos = 2;
+    this.fileSize = this.readUInt32LE();
+    this.reserved = this.readUInt32LE();
+    this.offset = this.readUInt32LE();
+    if (this.offset < FILE_HEADER_SIZE || this.offset > this.bytes.length) {
+      throw new Error(`Invalid pixel data offset: ${this.offset}`);
+    }
+  }
+  parseDibHeader() {
+    this.pos = this.dibStart;
+    this.headerSize = this.readUInt32LE();
+    if (this.headerSize < CORE_HEADER_SIZE) {
+      throw new Error(`Unsupported DIB header size: ${this.headerSize}`);
+    }
+    this.ensureReadable(this.dibStart, this.headerSize, "DIB header");
+    if (this.headerSize === CORE_HEADER_SIZE) {
+      this.parseCoreHeader();
+      return;
+    }
+    if (this.headerSize < INFO_HEADER_MIN) {
+      throw new Error(`Unsupported DIB header size: ${this.headerSize}`);
+    }
+    this.parseInfoHeader();
+  }
+  parseCoreHeader() {
+    const width = this.readUInt16LE(this.dibStart + 4);
+    const height = this.readUInt16LE(this.dibStart + 6);
+    this.width = width;
+    this.height = height;
+    this.planes = this.readUInt16LE(this.dibStart + 8);
+    this.bitPP = this.readUInt16LE(this.dibStart + 10);
+    this.compress = 0;
+    this.rawSize = 0;
+    this.hr = 0;
+    this.vr = 0;
+    this.colors = 0;
+    this.importantColors = 0;
+    this.bottomUp = true;
+    this.paletteEntrySize = 3;
+    this.externalMaskOffset = this.dibStart + this.headerSize;
+    this.validateDimensions();
+  }
+  parseInfoHeader() {
+    const rawWidth = this.readInt32LE(this.dibStart + 4);
+    const rawHeight = this.readInt32LE(this.dibStart + 8);
+    this.width = rawWidth;
+    this.height = rawHeight;
+    this.planes = this.readUInt16LE(this.dibStart + 12);
+    this.bitPP = this.readUInt16LE(this.dibStart + 14);
+    this.compress = this.readUInt32LE(this.dibStart + 16);
+    this.rawSize = this.readUInt32LE(this.dibStart + 20);
+    this.hr = this.readUInt32LE(this.dibStart + 24);
+    this.vr = this.readUInt32LE(this.dibStart + 28);
+    this.colors = this.readUInt32LE(this.dibStart + 32);
+    this.importantColors = this.readUInt32LE(this.dibStart + 36);
+    this.paletteEntrySize = 4;
+    this.externalMaskOffset = this.dibStart + this.headerSize;
     if (this.height < 0) {
       this.height *= -1;
       this.bottomUp = false;
     }
+    if (this.width < 0) {
+      this.width *= -1;
+    }
+    if (this.bitPP === 16 && this.options.treat16BitAs15BitAlpha) {
+      this.bitPP = 15;
+    }
+    this.validateDimensions();
+    this.parseBitMasks();
+  }
+  validateDimensions() {
+    if (!Number.isInteger(this.width) || !Number.isInteger(this.height) || this.width <= 0 || this.height <= 0) {
+      throw new Error(`Invalid BMP dimensions: ${this.width}x${this.height}`);
+    }
+  }
+  parseBitMasks() {
+    if (!(this.bitPP === 16 || this.bitPP === 32) || !(this.compress === 3 || this.compress === 6)) {
+      return;
+    }
+    const inHeaderMaskStart = this.dibStart + 40;
+    const hasMasksInHeader = this.headerSize >= 52;
+    const maskStart = hasMasksInHeader ? inHeaderMaskStart : this.externalMaskOffset;
+    const maskCount = this.compress === 6 || this.headerSize >= 56 ? 4 : 3;
+    this.ensureReadable(maskStart, maskCount * 4, "bit masks");
+    this.maskRed = this.readUInt32LE(maskStart);
+    this.maskGreen = this.readUInt32LE(maskStart + 4);
+    this.maskBlue = this.readUInt32LE(maskStart + 8);
+    this.maskAlpha = maskCount >= 4 ? this.readUInt32LE(maskStart + 12) : 0;
+    if (!hasMasksInHeader) {
+      this.externalMaskOffset += maskCount * 4;
+    }
+  }
+  parsePalette() {
+    if (this.bitPP >= 16) {
+      return;
+    }
+    const colorCount = this.colors === 0 ? 1 << this.bitPP : this.colors;
+    if (colorCount <= 0) {
+      return;
+    }
+    const paletteStart = this.externalMaskOffset;
+    const paletteSize = colorCount * this.paletteEntrySize;
+    if (paletteStart + paletteSize > this.offset) {
+      throw new Error("Palette data overlaps or exceeds pixel data offset");
+    }
+    this.palette = new Array(colorCount);
+    for (let i = 0; i < colorCount; i += 1) {
+      const base = paletteStart + i * this.paletteEntrySize;
+      const blue = this.readUInt8(base);
+      const green = this.readUInt8(base + 1);
+      const red = this.readUInt8(base + 2);
+      const quad = this.paletteEntrySize === 4 ? this.readUInt8(base + 3) : 0;
+      this.palette[i] = { red, green, blue, quad };
+    }
   }
   parseRGBA() {
-    const len = this.width * this.height * 4;
-    this.data = Buffer.alloc(len);
+    const pixelCount = this.width * this.height;
+    const len = pixelCount * 4;
+    this.data = new Uint8Array(len);
     switch (this.bitPP) {
       case 1:
         this.bit1();
@@ -141,317 +271,274 @@ var BmpDecoder = class {
         throw new Error(`Unsupported BMP bit depth: ${this.bitPP}`);
     }
   }
+  transformToRgbaIfNeeded() {
+    if (!this.options.toRGBA) {
+      return;
+    }
+    for (let i = 0; i < this.data.length; i += 4) {
+      const alpha = this.data[i] ?? 0;
+      const blue = this.data[i + 1] ?? 0;
+      const green = this.data[i + 2] ?? 0;
+      const red = this.data[i + 3] ?? 0;
+      this.data[i] = red;
+      this.data[i + 1] = green;
+      this.data[i + 2] = blue;
+      this.data[i + 3] = alpha;
+    }
+  }
   getPaletteColor(index) {
     const color = this.palette?.[index];
     if (color) {
       return color;
     }
-    return {
-      red: 255,
-      green: 255,
-      blue: 255,
-      quad: 0
-    };
+    return { red: 255, green: 255, blue: 255, quad: 0 };
+  }
+  setPixel(destY, x, alpha, blue, green, red) {
+    const base = (destY * this.width + x) * 4;
+    this.data[base] = alpha;
+    this.data[base + 1] = blue;
+    this.data[base + 2] = green;
+    this.data[base + 3] = red;
   }
   bit1() {
-    const xLen = Math.ceil(this.width / 8);
-    const mode = xLen % 4;
-    for (let y = this.height - 1; y >= 0; y -= 1) {
-      const line = this.bottomUp ? y : this.height - 1 - y;
-      for (let x = 0; x < xLen; x += 1) {
-        const b = this.buffer.readUInt8(this.pos++);
-        const location = line * this.width * 4 + x * 8 * 4;
-        for (let i = 0; i < 8; i += 1) {
-          if (x * 8 + i >= this.width) {
-            break;
-          }
-          const rgb = this.getPaletteColor(b >> 7 - i & 1);
-          this.data[location + i * 4] = 0;
-          this.data[location + i * 4 + 1] = rgb.blue;
-          this.data[location + i * 4 + 2] = rgb.green;
-          this.data[location + i * 4 + 3] = rgb.red;
-        }
-      }
-      if (mode !== 0) {
-        this.pos += 4 - mode;
+    const stride = rowStride(this.width, 1);
+    const bytesPerRow = Math.ceil(this.width / 8);
+    for (let srcRow = 0; srcRow < this.height; srcRow += 1) {
+      const rowStart = this.offset + srcRow * stride;
+      this.ensureReadable(rowStart, bytesPerRow, "1-bit row");
+      const destY = this.bottomUp ? this.height - 1 - srcRow : srcRow;
+      for (let x = 0; x < this.width; x += 1) {
+        const packed = this.readUInt8(rowStart + Math.floor(x / 8));
+        const bit = packed >> 7 - x % 8 & 1;
+        const rgb = this.getPaletteColor(bit);
+        this.setPixel(destY, x, 255, rgb.blue, rgb.green, rgb.red);
       }
     }
   }
   bit4() {
     if (this.compress === 2) {
-      let setPixelData2 = function(rgbIndex) {
-        const rgb = this.getPaletteColor(rgbIndex);
-        this.data[location] = 0;
-        this.data[location + 1] = rgb.blue;
-        this.data[location + 2] = rgb.green;
-        this.data[location + 3] = rgb.red;
-        location += 4;
-      };
-      var setPixelData = setPixelData2;
-      this.data.fill(255);
-      let location = 0;
-      let lines = this.bottomUp ? this.height - 1 : 0;
-      let lowNibble = false;
-      while (location < this.data.length) {
-        const a = this.buffer.readUInt8(this.pos++);
-        const b = this.buffer.readUInt8(this.pos++);
-        if (a === 0) {
-          if (b === 0) {
-            lines += this.bottomUp ? -1 : 1;
-            location = lines * this.width * 4;
-            lowNibble = false;
-            continue;
-          }
-          if (b === 1) {
-            break;
-          }
-          if (b === 2) {
-            const x = this.buffer.readUInt8(this.pos++);
-            const y = this.buffer.readUInt8(this.pos++);
-            lines += this.bottomUp ? -y : y;
-            location += y * this.width * 4 + x * 4;
-            continue;
-          }
-          let c = this.buffer.readUInt8(this.pos++);
-          for (let i = 0; i < b; i += 1) {
-            if (lowNibble) {
-              setPixelData2.call(this, c & 15);
-            } else {
-              setPixelData2.call(this, (c & 240) >> 4);
-            }
-            if ((i & 1) === 1 && i + 1 < b) {
-              c = this.buffer.readUInt8(this.pos++);
-            }
-            lowNibble = !lowNibble;
-          }
-          if ((b + 1 >> 1 & 1) === 1) {
-            this.pos += 1;
-          }
-        } else {
-          for (let i = 0; i < a; i += 1) {
-            if (lowNibble) {
-              setPixelData2.call(this, b & 15);
-            } else {
-              setPixelData2.call(this, (b & 240) >> 4);
-            }
-            lowNibble = !lowNibble;
-          }
-        }
-      }
+      this.bit4Rle();
       return;
     }
-    const xLen = Math.ceil(this.width / 2);
-    const mode = xLen % 4;
-    for (let y = this.height - 1; y >= 0; y -= 1) {
-      const line = this.bottomUp ? y : this.height - 1 - y;
-      for (let x = 0; x < xLen; x += 1) {
-        const b = this.buffer.readUInt8(this.pos++);
-        const location = line * this.width * 4 + x * 2 * 4;
-        const before = b >> 4;
-        const after = b & 15;
-        let rgb = this.getPaletteColor(before);
-        this.data[location] = 0;
-        this.data[location + 1] = rgb.blue;
-        this.data[location + 2] = rgb.green;
-        this.data[location + 3] = rgb.red;
-        if (x * 2 + 1 >= this.width) {
-          break;
-        }
-        rgb = this.getPaletteColor(after);
-        this.data[location + 4] = 0;
-        this.data[location + 5] = rgb.blue;
-        this.data[location + 6] = rgb.green;
-        this.data[location + 7] = rgb.red;
-      }
-      if (mode !== 0) {
-        this.pos += 4 - mode;
+    const stride = rowStride(this.width, 4);
+    const bytesPerRow = Math.ceil(this.width / 2);
+    for (let srcRow = 0; srcRow < this.height; srcRow += 1) {
+      const rowStart = this.offset + srcRow * stride;
+      this.ensureReadable(rowStart, bytesPerRow, "4-bit row");
+      const destY = this.bottomUp ? this.height - 1 - srcRow : srcRow;
+      for (let x = 0; x < this.width; x += 1) {
+        const packed = this.readUInt8(rowStart + Math.floor(x / 2));
+        const idx = x % 2 === 0 ? (packed & 240) >> 4 : packed & 15;
+        const rgb = this.getPaletteColor(idx);
+        this.setPixel(destY, x, 255, rgb.blue, rgb.green, rgb.red);
       }
     }
   }
   bit8() {
     if (this.compress === 1) {
-      let setPixelData2 = function(rgbIndex) {
-        const rgb = this.getPaletteColor(rgbIndex);
-        this.data[location] = 0;
-        this.data[location + 1] = rgb.blue;
-        this.data[location + 2] = rgb.green;
-        this.data[location + 3] = rgb.red;
-        location += 4;
-      };
-      var setPixelData = setPixelData2;
-      this.data.fill(255);
-      let location = 0;
-      let lines = this.bottomUp ? this.height - 1 : 0;
-      while (location < this.data.length) {
-        const a = this.buffer.readUInt8(this.pos++);
-        const b = this.buffer.readUInt8(this.pos++);
-        if (a === 0) {
-          if (b === 0) {
-            lines += this.bottomUp ? -1 : 1;
-            location = lines * this.width * 4;
-            continue;
-          }
-          if (b === 1) {
-            break;
-          }
-          if (b === 2) {
-            const x = this.buffer.readUInt8(this.pos++);
-            const y = this.buffer.readUInt8(this.pos++);
-            lines += this.bottomUp ? -y : y;
-            location += y * this.width * 4 + x * 4;
-            continue;
-          }
-          for (let i = 0; i < b; i += 1) {
-            const c = this.buffer.readUInt8(this.pos++);
-            setPixelData2.call(this, c);
-          }
-          if ((b & 1) === 1) {
-            this.pos += 1;
-          }
-        } else {
-          for (let i = 0; i < a; i += 1) {
-            setPixelData2.call(this, b);
-          }
-        }
-      }
+      this.bit8Rle();
       return;
     }
-    const mode = this.width % 4;
-    for (let y = this.height - 1; y >= 0; y -= 1) {
-      const line = this.bottomUp ? y : this.height - 1 - y;
+    const stride = rowStride(this.width, 8);
+    const bytesPerRow = this.width;
+    for (let srcRow = 0; srcRow < this.height; srcRow += 1) {
+      const rowStart = this.offset + srcRow * stride;
+      this.ensureReadable(rowStart, bytesPerRow, "8-bit row");
+      const destY = this.bottomUp ? this.height - 1 - srcRow : srcRow;
       for (let x = 0; x < this.width; x += 1) {
-        const b = this.buffer.readUInt8(this.pos++);
-        const location = line * this.width * 4 + x * 4;
-        const rgb = this.getPaletteColor(b);
-        this.data[location] = 0;
-        this.data[location + 1] = rgb.blue;
-        this.data[location + 2] = rgb.green;
-        this.data[location + 3] = rgb.red;
-      }
-      if (mode !== 0) {
-        this.pos += 4 - mode;
+        const idx = this.readUInt8(rowStart + x);
+        const rgb = this.getPaletteColor(idx);
+        this.setPixel(destY, x, 255, rgb.blue, rgb.green, rgb.red);
       }
     }
   }
   bit15() {
-    const difW = this.width % 3;
-    const m = 31;
-    for (let y = this.height - 1; y >= 0; y -= 1) {
-      const line = this.bottomUp ? y : this.height - 1 - y;
+    const stride = rowStride(this.width, 16);
+    const max = 31;
+    for (let srcRow = 0; srcRow < this.height; srcRow += 1) {
+      const rowStart = this.offset + srcRow * stride;
+      this.ensureReadable(rowStart, this.width * 2, "15-bit row");
+      const destY = this.bottomUp ? this.height - 1 - srcRow : srcRow;
       for (let x = 0; x < this.width; x += 1) {
-        const value = this.buffer.readUInt16LE(this.pos);
-        this.pos += 2;
-        const blue = (value & m) / m * 255;
-        const green = (value >> 5 & m) / m * 255;
-        const red = (value >> 10 & m) / m * 255;
-        const alpha = value >> 15 !== 0 ? 255 : 0;
-        const location = line * this.width * 4 + x * 4;
-        this.data[location] = alpha;
-        this.data[location + 1] = blue | 0;
-        this.data[location + 2] = green | 0;
-        this.data[location + 3] = red | 0;
+        const value = this.readUInt16LE(rowStart + x * 2);
+        const blue = (value >> 0 & max) / max * 255;
+        const green = (value >> 5 & max) / max * 255;
+        const red = (value >> 10 & max) / max * 255;
+        const alpha = (value & 32768) !== 0 ? 255 : 0;
+        this.setPixel(destY, x, alpha, blue | 0, green | 0, red | 0);
       }
-      this.pos += difW;
     }
   }
+  scaleMasked(value, mask) {
+    if (mask === 0) return 0;
+    let shift = 0;
+    let bits = 0;
+    let m = mask;
+    while ((m & 1) === 0) {
+      shift += 1;
+      m >>>= 1;
+    }
+    while ((m & 1) === 1) {
+      bits += 1;
+      m >>>= 1;
+    }
+    const component = (value & mask) >>> shift;
+    if (bits >= 8) {
+      return component >>> bits - 8;
+    }
+    return component << 8 - bits & 255;
+  }
   bit16() {
-    const difW = this.width % 2 * 2;
-    this.maskRed = 31744;
-    this.maskGreen = 992;
-    this.maskBlue = 31;
-    this.mask0 = 0;
-    if (this.compress === 3) {
-      this.maskRed = this.buffer.readUInt32LE(this.pos);
-      this.pos += 4;
-      this.maskGreen = this.buffer.readUInt32LE(this.pos);
-      this.pos += 4;
-      this.maskBlue = this.buffer.readUInt32LE(this.pos);
-      this.pos += 4;
-      this.mask0 = this.buffer.readUInt32LE(this.pos);
-      this.pos += 4;
-    }
-    const ns = [0, 0, 0];
-    for (let i = 0; i < 16; i += 1) {
-      if ((this.maskRed >> i & 1) !== 0) ns[0] += 1;
-      if ((this.maskGreen >> i & 1) !== 0) ns[1] += 1;
-      if ((this.maskBlue >> i & 1) !== 0) ns[2] += 1;
-    }
-    ns[1] += ns[0];
-    ns[2] += ns[1];
-    ns[0] = 8 - ns[0];
-    ns[1] -= 8;
-    ns[2] -= 8;
-    for (let y = this.height - 1; y >= 0; y -= 1) {
-      const line = this.bottomUp ? y : this.height - 1 - y;
+    if (this.maskRed === 0 && this.maskGreen === 0 && this.maskBlue === 0) {
+      this.maskRed = 31744;
+      this.maskGreen = 992;
+      this.maskBlue = 31;
+    }
+    const stride = rowStride(this.width, 16);
+    for (let srcRow = 0; srcRow < this.height; srcRow += 1) {
+      const rowStart = this.offset + srcRow * stride;
+      this.ensureReadable(rowStart, this.width * 2, "16-bit row");
+      const destY = this.bottomUp ? this.height - 1 - srcRow : srcRow;
       for (let x = 0; x < this.width; x += 1) {
-        const value = this.buffer.readUInt16LE(this.pos);
-        this.pos += 2;
-        const blue = (value & this.maskBlue) << ns[0];
-        const green = (value & this.maskGreen) >> ns[1];
-        const red = (value & this.maskRed) >> ns[2];
-        const location = line * this.width * 4 + x * 4;
-        this.data[location] = 0;
-        this.data[location + 1] = blue;
-        this.data[location + 2] = green;
-        this.data[location + 3] = red;
+        const value = this.readUInt16LE(rowStart + x * 2);
+        const blue = this.scaleMasked(value, this.maskBlue);
+        const green = this.scaleMasked(value, this.maskGreen);
+        const red = this.scaleMasked(value, this.maskRed);
+        const alpha = this.maskAlpha !== 0 ? this.scaleMasked(value, this.maskAlpha) : 255;
+        this.setPixel(destY, x, alpha, blue, green, red);
       }
-      this.pos += difW;
     }
   }
   bit24() {
-    for (let y = this.height - 1; y >= 0; y -= 1) {
-      const line = this.bottomUp ? y : this.height - 1 - y;
+    const stride = rowStride(this.width, 24);
+    for (let srcRow = 0; srcRow < this.height; srcRow += 1) {
+      const rowStart = this.offset + srcRow * stride;
+      this.ensureReadable(rowStart, this.width * 3, "24-bit row");
+      const destY = this.bottomUp ? this.height - 1 - srcRow : srcRow;
       for (let x = 0; x < this.width; x += 1) {
-        const blue = this.buffer.readUInt8(this.pos++);
-        const green = this.buffer.readUInt8(this.pos++);
-        const red = this.buffer.readUInt8(this.pos++);
-        const location = line * this.width * 4 + x * 4;
-        this.data[location] = 0;
-        this.data[location + 1] = blue;
-        this.data[location + 2] = green;
-        this.data[location + 3] = red;
+        const base = rowStart + x * 3;
+        const blue = this.readUInt8(base);
+        const green = this.readUInt8(base + 1);
+        const red = this.readUInt8(base + 2);
+        this.setPixel(destY, x, 255, blue, green, red);
       }
-      this.pos += this.width % 4;
     }
   }
   bit32() {
-    if (this.compress === 3) {
-      this.maskRed = this.buffer.readUInt32LE(this.pos);
-      this.pos += 4;
-      this.maskGreen = this.buffer.readUInt32LE(this.pos);
-      this.pos += 4;
-      this.maskBlue = this.buffer.readUInt32LE(this.pos);
-      this.pos += 4;
-      this.mask0 = this.buffer.readUInt32LE(this.pos);
-      this.pos += 4;
-      for (let y = this.height - 1; y >= 0; y -= 1) {
-        const line = this.bottomUp ? y : this.height - 1 - y;
-        for (let x = 0; x < this.width; x += 1) {
-          const alpha = this.buffer.readUInt8(this.pos++);
-          const blue = this.buffer.readUInt8(this.pos++);
-          const green = this.buffer.readUInt8(this.pos++);
-          const red = this.buffer.readUInt8(this.pos++);
-          const location = line * this.width * 4 + x * 4;
-          this.data[location] = alpha;
-          this.data[location + 1] = blue;
-          this.data[location + 2] = green;
-          this.data[location + 3] = red;
+    const stride = rowStride(this.width, 32);
+    for (let srcRow = 0; srcRow < this.height; srcRow += 1) {
+      const rowStart = this.offset + srcRow * stride;
+      this.ensureReadable(rowStart, this.width * 4, "32-bit row");
+      const destY = this.bottomUp ? this.height - 1 - srcRow : srcRow;
+      for (let x = 0; x < this.width; x += 1) {
+        const base = rowStart + x * 4;
+        if (this.compress === 3 || this.compress === 6) {
+          const pixel = this.readUInt32LE(base);
+          const red = this.scaleMasked(pixel, this.maskRed || 16711680);
+          const green = this.scaleMasked(pixel, this.maskGreen || 65280);
+          const blue = this.scaleMasked(pixel, this.maskBlue || 255);
+          const alpha = this.maskAlpha === 0 ? 255 : this.scaleMasked(pixel, this.maskAlpha);
+          this.setPixel(destY, x, alpha, blue, green, red);
+        } else {
+          const blue = this.readUInt8(base);
+          const green = this.readUInt8(base + 1);
+          const red = this.readUInt8(base + 2);
+          const alpha = this.readUInt8(base + 3);
+          this.setPixel(destY, x, alpha, blue, green, red);
         }
       }
-      return;
     }
-    for (let y = this.height - 1; y >= 0; y -= 1) {
-      const line = this.bottomUp ? y : this.height - 1 - y;
-      for (let x = 0; x < this.width; x += 1) {
-        const blue = this.buffer.readUInt8(this.pos++);
-        const green = this.buffer.readUInt8(this.pos++);
-        const red = this.buffer.readUInt8(this.pos++);
-        const alpha = this.buffer.readUInt8(this.pos++);
-        const location = line * this.width * 4 + x * 4;
-        this.data[location] = alpha;
-        this.data[location + 1] = blue;
-        this.data[location + 2] = green;
-        this.data[location + 3] = red;
+  }
+  bit8Rle() {
+    this.data.fill(255);
+    this.pos = this.offset;
+    let x = 0;
+    let y = this.bottomUp ? this.height - 1 : 0;
+    while (this.pos < this.bytes.length) {
+      const count = this.readUInt8();
+      const value = this.readUInt8();
+      if (count === 0) {
+        if (value === 0) {
+          x = 0;
+          y += this.bottomUp ? -1 : 1;
+          continue;
+        }
+        if (value === 1) {
+          break;
+        }
+        if (value === 2) {
+          x += this.readUInt8();
+          y += this.bottomUp ? -this.readUInt8() : this.readUInt8();
+          continue;
+        }
+        for (let i = 0; i < value; i += 1) {
+          const idx = this.readUInt8();
+          const rgb2 = this.getPaletteColor(idx);
+          if (x < this.width && y >= 0 && y < this.height) {
+            this.setPixel(y, x, 255, rgb2.blue, rgb2.green, rgb2.red);
+          }
+          x += 1;
+        }
+        if ((value & 1) === 1) {
+          this.pos += 1;
+        }
+        continue;
+      }
+      const rgb = this.getPaletteColor(value);
+      for (let i = 0; i < count; i += 1) {
+        if (x < this.width && y >= 0 && y < this.height) {
+          this.setPixel(y, x, 255, rgb.blue, rgb.green, rgb.red);
+        }
+        x += 1;
+      }
+    }
+  }
+  bit4Rle() {
+    this.data.fill(255);
+    this.pos = this.offset;
+    let x = 0;
+    let y = this.bottomUp ? this.height - 1 : 0;
+    while (this.pos < this.bytes.length) {
+      const count = this.readUInt8();
+      const value = this.readUInt8();
+      if (count === 0) {
+        if (value === 0) {
+          x = 0;
+          y += this.bottomUp ? -1 : 1;
+          continue;
+        }
+        if (value === 1) {
+          break;
+        }
+        if (value === 2) {
+          x += this.readUInt8();
+          y += this.bottomUp ? -this.readUInt8() : this.readUInt8();
+          continue;
+        }
+        let current = this.readUInt8();
+        for (let i = 0; i < value; i += 1) {
+          const nibble = i % 2 === 0 ? (current & 240) >> 4 : current & 15;
+          const rgb = this.getPaletteColor(nibble);
+          if (x < this.width && y >= 0 && y < this.height) {
+            this.setPixel(y, x, 255, rgb.blue, rgb.green, rgb.red);
+          }
+          x += 1;
+          if (i % 2 === 1 && i + 1 < value) {
+            current = this.readUInt8();
+          }
+        }
+        if ((value + 1 >> 1 & 1) === 1) {
+          this.pos += 1;
+        }
+        continue;
+      }
+      for (let i = 0; i < count; i += 1) {
+        const nibble = i % 2 === 0 ? (value & 240) >> 4 : value & 15;
+        const rgb = this.getPaletteColor(nibble);
+        if (x < this.width && y >= 0 && y < this.height) {
+          this.setPixel(y, x, 255, rgb.blue, rgb.green, rgb.red);
+        }
+        x += 1;
       }
     }
   }
@@ -459,92 +546,96 @@ var BmpDecoder = class {
     return this.data;
   }
 };
-function decode(bmpData) {
-  return new BmpDecoder(bmpData);
+function decode(bmpData, options) {
+  return new BmpDecoder(bmpData, options);
 }
 
 // src/encoder.ts
+var FILE_HEADER_SIZE2 = 14;
+var INFO_HEADER_SIZE = 40;
+var RGB_TRIPLE_SIZE = 3;
+var BYTES_PER_PIXEL_ABGR = 4;
+function rowStride24(width) {
+  const raw = width * RGB_TRIPLE_SIZE;
+  return raw + 3 & ~3;
+}
+function normalizeEncodeOptions(qualityOrOptions) {
+  if (typeof qualityOrOptions === "number" || typeof qualityOrOptions === "undefined") {
+    return {
+      orientation: "top-down",
+      bitPP: 24
+    };
+  }
+  return {
+    orientation: qualityOrOptions.orientation ?? "top-down",
+    bitPP: qualityOrOptions.bitPP ?? 24
+  };
+}
 var BmpEncoder = class {
-  buffer;
+  pixelData;
   width;
   height;
-  extraBytes;
-  rgbSize;
-  headerInfoSize;
-  flag = "BM";
-  reserved = 0;
-  offset = 54;
-  fileSize;
-  planes = 1;
-  bitPP = 24;
-  compress = 0;
-  hr = 0;
-  vr = 0;
-  colors = 0;
-  importantColors = 0;
-  pos = 0;
-  constructor(imgData) {
-    this.buffer = imgData.data;
+  options;
+  constructor(imgData, options) {
+    this.pixelData = imgData.data;
     this.width = imgData.width;
     this.height = imgData.height;
-    this.extraBytes = this.width % 4;
-    this.rgbSize = this.height * (3 * this.width + this.extraBytes);
-    this.headerInfoSize = 40;
-    this.fileSize = this.rgbSize + this.offset;
+    this.options = options;
+    assertInteger("width", this.width);
+    assertInteger("height", this.height);
+    if (this.options.bitPP !== 24) {
+      throw new Error(
+        `Unsupported encode bit depth: ${this.options.bitPP}. Only 24-bit output is supported.`
+      );
+    }
+    const minLength = this.width * this.height * BYTES_PER_PIXEL_ABGR;
+    if (this.pixelData.length < minLength) {
+      throw new Error(
+        `Image data is too short: expected at least ${minLength} bytes for ${this.width}x${this.height} ABGR data.`
+      );
+    }
   }
   encode() {
-    const tempBuffer = Buffer.alloc(this.offset + this.rgbSize);
-    tempBuffer.write(this.flag, this.pos, 2);
-    this.pos += 2;
-    tempBuffer.writeUInt32LE(this.fileSize, this.pos);
-    this.pos += 4;
-    tempBuffer.writeUInt32LE(this.reserved, this.pos);
-    this.pos += 4;
-    tempBuffer.writeUInt32LE(this.offset, this.pos);
-    this.pos += 4;
-    tempBuffer.writeUInt32LE(this.headerInfoSize, this.pos);
-    this.pos += 4;
-    tempBuffer.writeUInt32LE(this.width, this.pos);
-    this.pos += 4;
-    tempBuffer.writeInt32LE(-this.height, this.pos);
-    this.pos += 4;
-    tempBuffer.writeUInt16LE(this.planes, this.pos);
-    this.pos += 2;
-    tempBuffer.writeUInt16LE(this.bitPP, this.pos);
-    this.pos += 2;
-    tempBuffer.writeUInt32LE(this.compress, this.pos);
-    this.pos += 4;
-    tempBuffer.writeUInt32LE(this.rgbSize, this.pos);
-    this.pos += 4;
-    tempBuffer.writeUInt32LE(this.hr, this.pos);
-    this.pos += 4;
-    tempBuffer.writeUInt32LE(this.vr, this.pos);
-    this.pos += 4;
-    tempBuffer.writeUInt32LE(this.colors, this.pos);
-    this.pos += 4;
-    tempBuffer.writeUInt32LE(this.importantColors, this.pos);
-    this.pos += 4;
-    let i = 0;
-    const rowBytes = 3 * this.width + this.extraBytes;
-    for (let y = 0; y < this.height; y += 1) {
+    const stride = rowStride24(this.width);
+    const imageSize = stride * this.height;
+    const offset = FILE_HEADER_SIZE2 + INFO_HEADER_SIZE;
+    const totalSize = offset + imageSize;
+    const output = new Uint8Array(totalSize);
+    const view = new DataView(output.buffer, output.byteOffset, output.byteLength);
+    output[0] = 66;
+    output[1] = 77;
+    view.setUint32(2, totalSize, true);
+    view.setUint32(6, 0, true);
+    view.setUint32(10, offset, true);
+    view.setUint32(14, INFO_HEADER_SIZE, true);
+    view.setInt32(18, this.width, true);
+    const signedHeight = this.options.orientation === "top-down" ? -this.height : this.height;
+    view.setInt32(22, signedHeight, true);
+    view.setUint16(26, 1, true);
+    view.setUint16(28, 24, true);
+    view.setUint32(30, 0, true);
+    view.setUint32(34, imageSize, true);
+    view.setUint32(38, 0, true);
+    view.setUint32(42, 0, true);
+    view.setUint32(46, 0, true);
+    view.setUint32(50, 0, true);
+    for (let fileRow = 0; fileRow < this.height; fileRow += 1) {
+      const srcY = this.options.orientation === "top-down" ? fileRow : this.height - 1 - fileRow;
+      const rowStart = offset + fileRow * stride;
       for (let x = 0; x < this.width; x += 1) {
-        const p = this.pos + y * rowBytes + x * 3;
-        i += 1;
-        tempBuffer[p] = this.buffer.readUInt8(i++);
-        tempBuffer[p + 1] = this.buffer.readUInt8(i++);
-        tempBuffer[p + 2] = this.buffer.readUInt8(i++);
-      }
-      if (this.extraBytes > 0) {
-        const fillOffset = this.pos + y * rowBytes + this.width * 3;
-        tempBuffer.fill(0, fillOffset, fillOffset + this.extraBytes);
+        const source = (srcY * this.width + x) * BYTES_PER_PIXEL_ABGR;
+        const target = rowStart + x * RGB_TRIPLE_SIZE;
+        output[target] = this.pixelData[source + 1] ?? 0;
+        output[target + 1] = this.pixelData[source + 2] ?? 0;
+        output[target + 2] = this.pixelData[source + 3] ?? 0;
       }
     }
-    return tempBuffer;
+    return output;
   }
 };
-function encode(imgData, quality = 100) {
-  void quality;
-  const encoder = new BmpEncoder(imgData);
+function encode(imgData, qualityOrOptions) {
+  const options = normalizeEncodeOptions(qualityOrOptions);
+  const encoder = new BmpEncoder(imgData, options);
   const data = encoder.encode();
   return {
     data,