@flighthq/bitmap 0.3.0-next.1021.f5f1ee0

package/src/bitmapImageChannel.test.ts

@@ -0,0 +1,19 @@
+import { ImageChannel } from './bitmapImageChannel';
+
+describe('ImageChannel', () => {
+  it('has Red = 0', () => {
+    expect(ImageChannel.Red).toBe(0);
+  });
+
+  it('has Green = 1', () => {
+    expect(ImageChannel.Green).toBe(1);
+  });
+
+  it('has Blue = 2', () => {
+    expect(ImageChannel.Blue).toBe(2);
+  });
+
+  it('has Alpha = 3', () => {
+    expect(ImageChannel.Alpha).toBe(3);
+  });
+});

package/src/bitmapMedian.test.ts

@@ -0,0 +1,39 @@
+import { createBitmap } from './bitmap';
+import { medianBitmap } from './bitmapMedian';
+
+function region(bitmap: ReturnType<typeof createBitmap>, x = 0, y = 0, width = bitmap.width, height = bitmap.height) {
+  return { bitmap, x, y, width, height };
+}
+
+describe('medianBitmap', () => {
+  it('removes an isolated salt pixel without blurring', () => {
+    // 3x3 of black with a single white (R=255) center; the median is black.
+    const source = createBitmap(3, 3);
+    for (let i = 0; i < 9; i++) source.data[i * 4 + 3] = 255;
+    source.data[4 * 4] = 255;
+    const out = new Uint8ClampedArray(3 * 3 * 4);
+    medianBitmap(out, region(source), 1);
+    expect(out[4 * 4]).toBe(0);
+  });
+
+  it('preserves a hard edge (median is not an average)', () => {
+    // Left half 0, right half 255 across a 4x1 row; the boundary stays crisp.
+    const source = createBitmap(4, 1);
+    source.data[0] = 0;
+    source.data[4] = 0;
+    source.data[8] = 255;
+    source.data[12] = 255;
+    const out = new Uint8ClampedArray(4 * 4);
+    medianBitmap(out, region(source), 1);
+    expect(out[4]).toBe(0);
+    expect(out[8]).toBe(255);
+  });
+
+  it('radius 0 copies the source', () => {
+    const source = createBitmap(1, 1, 0x123456ff);
+    const out = new Uint8ClampedArray(4);
+    medianBitmap(out, region(source), 0);
+    expect(out[0]).toBe(0x12);
+    expect(out[3]).toBe(0xff);
+  });
+});

package/src/bitmapMorphological.test.ts

@@ -0,0 +1,69 @@
+import { createBitmap } from './bitmap';
+import { dilateBitmap, erodeBitmap } from './bitmapMorphological';
+
+function region(bitmap: ReturnType<typeof createBitmap>, x = 0, y = 0, width = bitmap.width, height = bitmap.height) {
+  return { bitmap, x, y, width, height };
+}
+
+describe('dilateBitmap', () => {
+  it('expands a single bright pixel into its neighborhood', () => {
+    const source = createBitmap(3, 1);
+    source.data[1 * 4 + 3] = 255; // center pixel fully opaque
+    const out = new Uint8ClampedArray(3 * 4);
+    dilateBitmap(out, region(source), 1);
+    expect(out[0 * 4 + 3]).toBe(255);
+    expect(out[1 * 4 + 3]).toBe(255);
+    expect(out[2 * 4 + 3]).toBe(255);
+  });
+
+  it('with radius 0 is an identity copy', () => {
+    const source = createBitmap(3, 1);
+    source.data.set([10, 20, 30, 100], 0);
+    source.data.set([50, 60, 70, 200], 4);
+    const out = new Uint8ClampedArray(3 * 4);
+    dilateBitmap(out, region(source), 0);
+    expect(out[0]).toBe(10);
+    expect(out[4]).toBe(50);
+  });
+
+  it('is dual to erodeBitmap (dilate after erode has no-smaller effect)', () => {
+    const source = createBitmap(5, 1);
+    for (let i = 1; i < 4; i++) source.data[i * 4 + 3] = 255; // pixels 1-3 opaque
+    const eroded = new Uint8ClampedArray(5 * 4);
+    const dilated = new Uint8ClampedArray(5 * 4);
+    erodeBitmap(eroded, region(source), 1);
+    dilateBitmap(dilated, region(source), 1);
+    // Dilation always >= source, erosion always <= source for alpha
+    expect(dilated[1 * 4 + 3]).toBeGreaterThanOrEqual(source.data[1 * 4 + 3]);
+    expect(eroded[1 * 4 + 3]).toBeLessThanOrEqual(source.data[1 * 4 + 3]);
+  });
+});
+
+describe('erodeBitmap', () => {
+  it('shrinks an isolated bright pixel to dark when radius covers neighbors', () => {
+    const source = createBitmap(3, 1);
+    source.data[1 * 4 + 3] = 255; // only center opaque
+    const out = new Uint8ClampedArray(3 * 4);
+    erodeBitmap(out, region(source), 1);
+    // Center eroded to 0 because transparent neighbors dominate the min
+    expect(out[1 * 4 + 3]).toBe(0);
+  });
+
+  it('with radius 0 is an identity copy', () => {
+    const source = createBitmap(3, 1);
+    source.data.set([10, 20, 30, 100], 4);
+    const out = new Uint8ClampedArray(3 * 4);
+    erodeBitmap(out, region(source), 0);
+    expect(out[4]).toBe(10);
+    expect(out[7]).toBe(100);
+  });
+
+  it('preserves a fully opaque field', () => {
+    const source = createBitmap(5, 1, 0xffffffff);
+    const out = new Uint8ClampedArray(5 * 4);
+    erodeBitmap(out, region(source), 2);
+    for (let i = 0; i < 5; i++) {
+      expect(out[i * 4 + 3]).toBe(255);
+    }
+  });
+});

package/src/bitmapNoise.test.ts

@@ -0,0 +1,163 @@
+import { createBitmap } from './bitmap';
+import {
+  fillBitmapNoise,
+  fillBitmapPerlinNoise,
+  fillBitmapTurbulence,
+  BITMAP_NOISE_CHANNEL_A,
+  BITMAP_NOISE_CHANNEL_R,
+} from './bitmapNoise';
+
+function region(bitmap: ReturnType<typeof createBitmap>, x = 0, y = 0, width = bitmap.width, height = bitmap.height) {
+  return { bitmap, x, y, width, height };
+}
+
+describe('fillBitmapNoise', () => {
+  it('is deterministic for the same seed', () => {
+    const a = createBitmap(4, 4);
+    const b = createBitmap(4, 4);
+    fillBitmapNoise(region(a), 12345);
+    fillBitmapNoise(region(b), 12345);
+    expect(Array.from(a.data)).toEqual(Array.from(b.data));
+  });
+
+  it('produces different output for different seeds', () => {
+    const a = createBitmap(8, 8);
+    const b = createBitmap(8, 8);
+    fillBitmapNoise(region(a), 1);
+    fillBitmapNoise(region(b), 2);
+    expect(Array.from(a.data)).not.toEqual(Array.from(b.data));
+  });
+
+  it('grayscale gives every pixel equal R, G, B', () => {
+    const bitmap = createBitmap(4, 4);
+    fillBitmapNoise(region(bitmap), 99, 0, 255, true);
+    for (let i = 0; i < bitmap.data.length; i += 4) {
+      expect(bitmap.data[i]).toBe(bitmap.data[i + 1]);
+      expect(bitmap.data[i + 1]).toBe(bitmap.data[i + 2]);
+    }
+  });
+
+  it('respects the low/high range and sets alpha opaque', () => {
+    const bitmap = createBitmap(8, 8);
+    fillBitmapNoise(region(bitmap), 7, 100, 110);
+    for (let i = 0; i < bitmap.data.length; i += 4) {
+      expect(bitmap.data[i]).toBeGreaterThanOrEqual(100);
+      expect(bitmap.data[i]).toBeLessThanOrEqual(110);
+      expect(bitmap.data[i + 3]).toBe(255);
+    }
+  });
+
+  it('fills only the given sub-region', () => {
+    const bitmap = createBitmap(2, 1, 0x000000ff);
+    fillBitmapNoise(region(bitmap, 1, 0, 1, 1), 5, 200, 255);
+    expect(bitmap.data[0]).toBe(0); // left pixel untouched
+    expect(bitmap.data[4]).toBeGreaterThanOrEqual(200);
+  });
+});
+
+describe('fillBitmapPerlinNoise', () => {
+  it('is deterministic for the same seed', () => {
+    const a = createBitmap(8, 8);
+    const b = createBitmap(8, 8);
+    fillBitmapPerlinNoise(region(a), 16, 16, 3, 42);
+    fillBitmapPerlinNoise(region(b), 16, 16, 3, 42);
+    expect(Array.from(a.data)).toEqual(Array.from(b.data));
+  });
+
+  it('keeps values in range and alpha opaque', () => {
+    const bitmap = createBitmap(8, 8);
+    fillBitmapPerlinNoise(region(bitmap), 8, 8, 2, 5);
+    for (let i = 0; i < bitmap.data.length; i += 4) {
+      expect(bitmap.data[i]).toBeGreaterThanOrEqual(0);
+      expect(bitmap.data[i]).toBeLessThanOrEqual(255);
+      expect(bitmap.data[i + 3]).toBe(255);
+    }
+  });
+
+  it('grayscale gives every pixel equal R, G, B', () => {
+    const bitmap = createBitmap(8, 8);
+    fillBitmapPerlinNoise(region(bitmap), 8, 8, 2, 5, true);
+    for (let i = 0; i < bitmap.data.length; i += 4) {
+      expect(bitmap.data[i]).toBe(bitmap.data[i + 1]);
+      expect(bitmap.data[i + 1]).toBe(bitmap.data[i + 2]);
+    }
+  });
+
+  it('produces smooth low-frequency fields (neighbors stay close)', () => {
+    const bitmap = createBitmap(16, 1);
+    fillBitmapPerlinNoise(region(bitmap), 32, 32, 1, 3, true);
+    let maxStep = 0;
+    for (let x = 1; x < 16; x++) {
+      maxStep = Math.max(maxStep, Math.abs(bitmap.data[x * 4] - bitmap.data[(x - 1) * 4]));
+    }
+    expect(maxStep).toBeLessThan(64);
+  });
+
+  it('fills selected channels only and leaves alpha opaque by default', () => {
+    const bitmap = createBitmap(8, 8, 0x000000ff);
+    fillBitmapPerlinNoise(region(bitmap), 8, 8, 2, 5, false, false, BITMAP_NOISE_CHANNEL_R);
+    for (let i = 0; i < bitmap.data.length; i += 4) {
+      // G and B were not selected, so they stay at their initial 0.
+      expect(bitmap.data[i + 1]).toBe(0);
+      expect(bitmap.data[i + 2]).toBe(0);
+      // Alpha not selected -> forced opaque.
+      expect(bitmap.data[i + 3]).toBe(255);
+    }
+  });
+});
+
+describe('fillBitmapTurbulence', () => {
+  it('is deterministic for the same seed', () => {
+    const a = createBitmap(8, 8);
+    const b = createBitmap(8, 8);
+    fillBitmapTurbulence(region(a), 16, 16, 3, 42);
+    fillBitmapTurbulence(region(b), 16, 16, 3, 42);
+    expect(Array.from(a.data)).toEqual(Array.from(b.data));
+  });
+
+  it('keeps values in range and alpha opaque', () => {
+    const bitmap = createBitmap(8, 8);
+    fillBitmapTurbulence(region(bitmap), 8, 8, 2, 5);
+    for (let i = 0; i < bitmap.data.length; i += 4) {
+      expect(bitmap.data[i]).toBeGreaterThanOrEqual(0);
+      expect(bitmap.data[i]).toBeLessThanOrEqual(255);
+      expect(bitmap.data[i + 3]).toBe(255);
+    }
+  });
+
+  it('grayscale gives every pixel equal R, G, B', () => {
+    const bitmap = createBitmap(8, 8);
+    fillBitmapTurbulence(region(bitmap), 8, 8, 2, 5, true);
+    for (let i = 0; i < bitmap.data.length; i += 4) {
+      expect(bitmap.data[i]).toBe(bitmap.data[i + 1]);
+      expect(bitmap.data[i + 1]).toBe(bitmap.data[i + 2]);
+    }
+  });
+
+  it('writes noise into alpha when the A channel is selected', () => {
+    const bitmap = createBitmap(8, 8, 0x000000ff);
+    fillBitmapTurbulence(region(bitmap), 4, 4, 3, 9, false, false, BITMAP_NOISE_CHANNEL_A);
+    let sawNonOpaque = false;
+    for (let i = 0; i < bitmap.data.length; i += 4) {
+      if (bitmap.data[i + 3] !== 255) sawNonOpaque = true;
+    }
+    expect(sawNonOpaque).toBe(true);
+  });
+
+  it('differs from the smooth fractal sum for the same parameters', () => {
+    const turbulent = createBitmap(8, 8);
+    const fractal = createBitmap(8, 8);
+    fillBitmapTurbulence(region(turbulent), 8, 8, 3, 7, true);
+    fillBitmapPerlinNoise(region(fractal), 8, 8, 3, 7, true);
+    expect(Array.from(turbulent.data)).not.toEqual(Array.from(fractal.data));
+  });
+
+  it('fills only the given sub-region', () => {
+    const bitmap = createBitmap(2, 1, 0x010203ff);
+    fillBitmapTurbulence(region(bitmap, 1, 0, 1, 1), 8, 8, 2, 3);
+    // Left pixel untouched.
+    expect(bitmap.data[0]).toBe(1);
+    expect(bitmap.data[1]).toBe(2);
+    expect(bitmap.data[2]).toBe(3);
+  });
+});

package/src/bitmapPaletteMap.test.ts

@@ -0,0 +1,49 @@
+import { createBitmap } from './bitmap';
+import { applyBitmapPaletteMap } from './bitmapPaletteMap';
+
+function region(bitmap: ReturnType<typeof createBitmap>, x = 0, y = 0, width = bitmap.width, height = bitmap.height) {
+  return { bitmap, x, y, width, height };
+}
+
+function invertTable(): number[] {
+  const table = new Array<number>(256);
+  for (let i = 0; i < 256; i++) table[i] = 255 - i;
+  return table;
+}
+
+describe('applyBitmapPaletteMap', () => {
+  it('remaps a channel through its lookup table', () => {
+    const source = createBitmap(1, 1, 0x10203040);
+    const out = createBitmap(1, 1);
+    applyBitmapPaletteMap(region(out), region(source), invertTable(), null, null, null);
+    expect(out.data[0]).toBe(255 - 0x10);
+    expect(out.data[1]).toBe(0x20);
+    expect(out.data[2]).toBe(0x30);
+    expect(out.data[3]).toBe(0x40);
+  });
+
+  it('null maps leave every channel unchanged', () => {
+    const source = createBitmap(1, 1, 0x11223344);
+    const out = createBitmap(1, 1);
+    applyBitmapPaletteMap(region(out), region(source), null, null, null, null);
+    expect(out.data[0]).toBe(0x11);
+    expect(out.data[3]).toBe(0x44);
+  });
+
+  it('is safe in place', () => {
+    const img = createBitmap(1, 1, 0x00ff00ff);
+    applyBitmapPaletteMap(region(img), region(img), invertTable(), invertTable(), invertTable(), null);
+    expect(img.data[0]).toBe(255);
+    expect(img.data[1]).toBe(0);
+    expect(img.data[2]).toBe(255);
+    expect(img.data[3]).toBe(0xff);
+  });
+
+  it('maps only the given sub-region', () => {
+    const source = createBitmap(2, 1, 0x80808080);
+    const out = createBitmap(2, 1);
+    applyBitmapPaletteMap(region(out, 1, 0, 1, 1), region(source, 1, 0, 1, 1), invertTable(), null, null, null);
+    expect(out.data[4]).toBe(255 - 0x80);
+    expect(out.data[0]).toBe(0); // untouched left pixel
+  });
+});

package/src/bitmapPixel.test.ts

@@ -0,0 +1,117 @@
+import { createBitmap } from './bitmap';
+import { ImageChannel } from './bitmapImageChannel';
+import {
+  getBitmapPixel,
+  getBitmapPixelChannel,
+  getBitmapPixelLuminance,
+  getBitmapPixelRgb,
+  setBitmapPixel,
+  setBitmapPixelRgb,
+} from './bitmapPixel';
+
+describe('getBitmapPixel', () => {
+  it('reads back a full 0xRRGGBBAA value written by setBitmapPixel', () => {
+    const img = createBitmap(2, 2);
+    setBitmapPixel(img, 0, 0, 0xaabbcc80);
+    expect(getBitmapPixel(img, 0, 0)).toBe(0xaabbcc80);
+  });
+
+  it('reads the first pixel at (0, 0)', () => {
+    const img = createBitmap(8, 8);
+    setBitmapPixel(img, 0, 0, 0xdeadbeef);
+    expect(getBitmapPixel(img, 0, 0)).toBe(0xdeadbeef);
+  });
+
+  it('reads the last pixel at (width-1, height-1)', () => {
+    const img = createBitmap(8, 8);
+    setBitmapPixel(img, 7, 7, 0xcafebabe);
+    expect(getBitmapPixel(img, 7, 7)).toBe(0xcafebabe);
+  });
+
+  it('round-trips an RGBA value', () => {
+    const img = createBitmap(4, 4);
+    setBitmapPixel(img, 1, 2, 0x11223380);
+    expect(getBitmapPixel(img, 1, 2)).toBe(0x11223380);
+  });
+
+  it('stores alpha in the fourth byte', () => {
+    const img = createBitmap(2, 2);
+    setBitmapPixel(img, 0, 0, 0x112233de);
+    expect(img.data[3]).toBe(0xde);
+  });
+});
+
+describe('getBitmapPixelChannel', () => {
+  it('reads a single channel by index', () => {
+    const img = createBitmap(2, 2);
+    setBitmapPixel(img, 0, 0, 0xaabbccdd);
+    expect(getBitmapPixelChannel(img, 0, 0, ImageChannel.Red)).toBe(0xaa);
+    expect(getBitmapPixelChannel(img, 0, 0, ImageChannel.Green)).toBe(0xbb);
+    expect(getBitmapPixelChannel(img, 0, 0, ImageChannel.Blue)).toBe(0xcc);
+    expect(getBitmapPixelChannel(img, 0, 0, ImageChannel.Alpha)).toBe(0xdd);
+  });
+});
+
+describe('getBitmapPixelLuminance', () => {
+  it('returns 0 for black', () => {
+    const img = createBitmap(1, 1, 0x000000ff);
+    expect(getBitmapPixelLuminance(img, 0, 0)).toBe(0);
+  });
+
+  it('returns 255 for white', () => {
+    const img = createBitmap(1, 1, 0xffffffff);
+    expect(getBitmapPixelLuminance(img, 0, 0)).toBe(255);
+  });
+
+  it('uses W3C luma weighting (green is heaviest)', () => {
+    const red = createBitmap(1, 1, 0xff0000ff);
+    const green = createBitmap(1, 1, 0x00ff00ff);
+    const blue = createBitmap(1, 1, 0x0000ffff);
+    expect(getBitmapPixelLuminance(green, 0, 0)).toBeGreaterThan(getBitmapPixelLuminance(red, 0, 0));
+    expect(getBitmapPixelLuminance(red, 0, 0)).toBeGreaterThan(getBitmapPixelLuminance(blue, 0, 0));
+  });
+});
+
+describe('getBitmapPixelRgb', () => {
+  it('reads back a 0xRRGGBB value without alpha', () => {
+    const img = createBitmap(2, 2);
+    setBitmapPixelRgb(img, 0, 0, 0xaabbcc);
+    expect(getBitmapPixelRgb(img, 0, 0)).toBe(0xaabbcc);
+  });
+
+  it('round-trips an RGB value', () => {
+    const img = createBitmap(4, 4);
+    setBitmapPixelRgb(img, 1, 2, 0x112233);
+    expect(getBitmapPixelRgb(img, 1, 2)).toBe(0x112233);
+  });
+});
+
+describe('setBitmapPixel', () => {
+  it('writes all four RGBA channels', () => {
+    const img = createBitmap(2, 2);
+    setBitmapPixel(img, 1, 0, 0xadbeefde);
+    expect(getBitmapPixel(img, 1, 0)).toBe(0xadbeefde);
+  });
+
+  it('writes to the last pixel at (width-1, height-1)', () => {
+    const img = createBitmap(8, 8);
+    setBitmapPixel(img, 7, 7, 0xfedcba98);
+    expect(getBitmapPixel(img, 7, 7)).toBe(0xfedcba98);
+  });
+
+  it('bumps the bitmap version (self-invalidation)', () => {
+    const img = createBitmap(2, 2);
+    const before = img.version;
+    setBitmapPixel(img, 1, 0, 0xadbeefde);
+    expect(img.version).toBe(before + 1);
+  });
+});
+
+describe('setBitmapPixelRgb', () => {
+  it('writes RGB channels without touching alpha', () => {
+    const img = createBitmap(2, 2, 0x000000ff);
+    setBitmapPixelRgb(img, 0, 0, 0x112233);
+    expect(img.data[3]).toBe(0xff);
+    expect(getBitmapPixelRgb(img, 0, 0)).toBe(0x112233);
+  });
+});

package/src/bitmapPixelate.test.ts

@@ -0,0 +1,40 @@
+import { createBitmap } from './bitmap';
+import { pixelateBitmap } from './bitmapPixelate';
+
+function region(bitmap: ReturnType<typeof createBitmap>, x = 0, y = 0, width = bitmap.width, height = bitmap.height) {
+  return { bitmap, x, y, width, height };
+}
+
+describe('pixelateBitmap', () => {
+  it('averages a block to a single uniform color', () => {
+    // 2x1 row: R=0 and R=100; a block of 2 averages both to 50.
+    const source = createBitmap(2, 1);
+    source.data[0] = 0;
+    source.data[4] = 100;
+    source.data[3] = 255;
+    source.data[7] = 255;
+    const out = new Uint8ClampedArray(2 * 4);
+    pixelateBitmap(out, region(source), 2);
+    expect(out[0]).toBe(50);
+    expect(out[4]).toBe(50);
+  });
+
+  it('keeps each block independent', () => {
+    const source = createBitmap(2, 1);
+    source.data[0] = 10;
+    source.data[4] = 200;
+    const out = new Uint8ClampedArray(2 * 4);
+    pixelateBitmap(out, region(source), 1);
+    expect(out[0]).toBe(10);
+    expect(out[4]).toBe(200);
+  });
+
+  it('can use source.bitmap.data as out for a full-bitmap region', () => {
+    const bitmap = createBitmap(2, 1);
+    bitmap.data[0] = 0;
+    bitmap.data[4] = 80;
+    pixelateBitmap(bitmap.data, region(bitmap), 2);
+    expect(bitmap.data[0]).toBe(40);
+    expect(bitmap.data[4]).toBe(40);
+  });
+});

package/src/bitmapQuery.test.ts

@@ -0,0 +1,42 @@
+import { createBitmap } from './bitmap';
+import { fillBitmapRectangle } from './bitmapFill';
+import { getBitmapColorBoundsRectangle } from './bitmapQuery';
+
+function region(bitmap: ReturnType<typeof createBitmap>, x = 0, y = 0, width = bitmap.width, height = bitmap.height) {
+  return { bitmap, x, y, width, height };
+}
+
+describe('getBitmapColorBoundsRectangle', () => {
+  it('returns null when no pixels match', () => {
+    const img = createBitmap(4, 4);
+    expect(getBitmapColorBoundsRectangle(region(img), 0xffffffff, 0xffffffff)).toBeNull();
+  });
+
+  it('finds the bounding rect of matching pixels', () => {
+    const img = createBitmap(8, 8);
+    fillBitmapRectangle(region(img, 2, 3, 3, 2), 0xff0000ff);
+    const rect = getBitmapColorBoundsRectangle(region(img), 0xffffffff, 0xff0000ff);
+    expect(rect).toEqual({ x: 2, y: 3, width: 3, height: 2 });
+  });
+
+  it('finds non-matching pixels when findColor is false', () => {
+    const img = createBitmap(4, 4, 0xffffffff);
+    fillBitmapRectangle(region(img, 1, 1, 2, 2), 0x000000ff);
+    const rect = getBitmapColorBoundsRectangle(region(img), 0xffffffff, 0xffffffff, false);
+    expect(rect).toEqual({ x: 1, y: 1, width: 2, height: 2 });
+  });
+
+  it('respects the mask', () => {
+    const img = createBitmap(2, 2);
+    fillBitmapRectangle(region(img), 0x112233ff);
+    const rect = getBitmapColorBoundsRectangle(region(img), 0xff0000ff, 0x110000ff);
+    expect(rect).not.toBeNull();
+  });
+
+  it('reports bitmap-absolute coordinates when scanning a sub-region', () => {
+    const img = createBitmap(8, 8);
+    fillBitmapRectangle(region(img, 5, 5, 2, 2), 0xff0000ff);
+    const rect = getBitmapColorBoundsRectangle(region(img, 4, 4, 4, 4), 0xffffffff, 0xff0000ff);
+    expect(rect).toEqual({ x: 5, y: 5, width: 2, height: 2 });
+  });
+});

package/src/bitmapRegion.test.ts

@@ -0,0 +1,34 @@
+import { createBitmap } from './bitmap';
+import { createBitmapRegion, setBitmapRegion } from './bitmapRegion';
+
+describe('createBitmapRegion', () => {
+  it('covers the whole bitmap when no bounds are given', () => {
+    const bitmap = createBitmap(7, 5);
+    const r = createBitmapRegion(bitmap);
+    expect(r).toEqual({ bitmap, x: 0, y: 0, width: 7, height: 5 });
+  });
+
+  it('uses the supplied bounds', () => {
+    const bitmap = createBitmap(8, 8);
+    const r = createBitmapRegion(bitmap, 1, 2, 3, 4);
+    expect(r).toEqual({ bitmap, x: 1, y: 2, width: 3, height: 4 });
+  });
+});
+
+describe('setBitmapRegion', () => {
+  it('mutates the existing region without allocating a new object', () => {
+    const bitmap = createBitmap(8, 8);
+    const r = createBitmapRegion(bitmap);
+    const returned = setBitmapRegion(r, bitmap, 2, 3, 4, 5);
+    expect(returned).toBe(r);
+    expect(r).toEqual({ bitmap, x: 2, y: 3, width: 4, height: 5 });
+  });
+
+  it('covers the whole bitmap when no bounds are given', () => {
+    const a = createBitmap(2, 2);
+    const b = createBitmap(6, 9);
+    const r = createBitmapRegion(a);
+    setBitmapRegion(r, b);
+    expect(r).toEqual({ bitmap: b, x: 0, y: 0, width: 6, height: 9 });
+  });
+});

package/src/bitmapResize.test.ts

@@ -0,0 +1,106 @@
+import { createBitmap } from './bitmap';
+import { getBitmapPixel } from './bitmapPixel';
+import { resizeBitmap } from './bitmapResize';
+
+function region(bitmap: ReturnType<typeof createBitmap>, x = 0, y = 0, width = bitmap.width, height = bitmap.height) {
+  return { bitmap, x, y, width, height };
+}
+
+describe('resizeBitmap', () => {
+  it('nearest upscales by pixel duplication', () => {
+    const source = createBitmap(2, 1);
+    source.data.set([10, 20, 30, 255], 0);
+    source.data.set([40, 50, 60, 255], 4);
+    const out = createBitmap(4, 1);
+    resizeBitmap(region(out), region(source), 'nearest');
+    expect(getBitmapPixel(out, 0, 0)).toBe(getBitmapPixel(source, 0, 0));
+    expect(getBitmapPixel(out, 1, 0)).toBe(getBitmapPixel(source, 0, 0));
+    expect(getBitmapPixel(out, 2, 0)).toBe(getBitmapPixel(source, 1, 0));
+    expect(getBitmapPixel(out, 3, 0)).toBe(getBitmapPixel(source, 1, 0));
+  });
+
+  it('bilinear interpolates between source pixels', () => {
+    const source = createBitmap(2, 1);
+    source.data.set([0, 0, 0, 255], 0);
+    source.data.set([100, 100, 100, 255], 4);
+    const out = createBitmap(4, 1);
+    resizeBitmap(region(out), region(source), 'bilinear');
+    expect(out.data[0]).toBe(0);
+    expect(out.data[4]).toBeGreaterThanOrEqual(out.data[0]);
+    expect(out.data[8]).toBeGreaterThan(out.data[4]);
+    expect(out.data[12]).toBe(100);
+  });
+
+  it('bicubic produces a smoother interpolation than bilinear', () => {
+    const source = createBitmap(2, 1);
+    source.data.set([0, 0, 0, 255], 0);
+    source.data.set([200, 200, 200, 255], 4);
+    const out = createBitmap(4, 1);
+    resizeBitmap(region(out), region(source), 'bicubic');
+    // Bicubic should produce a monotonically increasing sequence
+    expect(out.data[4]).toBeGreaterThanOrEqual(out.data[0]);
+    expect(out.data[8]).toBeGreaterThanOrEqual(out.data[4]);
+    expect(out.data[12]).toBeGreaterThanOrEqual(out.data[8]);
+  });
+
+  it('premultiplied option prevents dark-halo bleed at transparent edges', () => {
+    // Red pixel adjacent to fully transparent. Straight-alpha blend mixes the
+    // hidden black of the transparent pixel into the output. Premultiplied
+    // blending keeps the red pure on the opaque side.
+    const source = createBitmap(2, 1);
+    source.data.set([255, 0, 0, 255], 0); // opaque red
+    source.data.set([0, 0, 0, 0], 4); // transparent
+    const straight = createBitmap(4, 1);
+    resizeBitmap(region(straight), region(source), 'bilinear');
+    const premul = createBitmap(4, 1);
+    resizeBitmap(region(premul), region(source), { mode: 'bilinear', premultiplied: true });
+    // At the boundary (pixel 1), premultiplied keeps red higher than straight
+    expect(premul.data[4]).toBeGreaterThanOrEqual(straight.data[4]);
+  });
+
+  it('downscales by averaging toward the source values', () => {
+    const source = createBitmap(4, 1, 0x40608000);
+    const out = createBitmap(2, 1);
+    resizeBitmap(region(out), region(source), 'bilinear');
+    expect(out.data[0]).toBe(0x40);
+    expect(out.data[1]).toBe(0x60);
+    expect(out.data[2]).toBe(0x80);
+  });
+
+  it('resamples a source sub-region into a dest sub-region', () => {
+    const source = createBitmap(4, 1);
+    source.data.set([10, 0, 0, 255], 2 * 4); // source pixel (2,0)
+    const out = createBitmap(4, 1);
+    resizeBitmap(region(out, 0, 0, 2, 1), region(source, 2, 0, 1, 1), 'nearest');
+    expect(out.data[0]).toBe(10);
+    expect(out.data[4]).toBe(10);
+    expect(out.data[8]).toBe(0); // outside the dest sub-region
+  });
+
+  it("edgeMode 'wrap' wraps boundary interpolation", () => {
+    // 2px source [black, white]. With wrap, the right boundary wraps to the left.
+    const source = createBitmap(2, 1);
+    source.data.set([0, 0, 0, 255], 0);
+    source.data.set([200, 200, 200, 255], 4);
+    const outClamp = createBitmap(4, 1);
+    resizeBitmap(region(outClamp), region(source), { mode: 'bilinear', edgeMode: 'clamp' });
+    const outWrap = createBitmap(4, 1);
+    resizeBitmap(region(outWrap), region(source), { mode: 'bilinear', edgeMode: 'wrap' });
+    // The rightmost pixel should differ: clamp repeats edge, wrap uses the other side.
+    expect(outClamp.data[12]).not.toBe(outWrap.data[12]);
+  });
+
+  it("edgeMode 'transparent' fades boundary pixels to transparent", () => {
+    const source = createBitmap(2, 1, 0xff0000ff);
+    const out = createBitmap(4, 1);
+    resizeBitmap(region(out), region(source), { mode: 'bilinear', edgeMode: 'transparent' });
+    // The rightmost pixel samples partially out-of-bounds → alpha drops
+    expect(out.data[12 + 3]).toBeLessThan(255);
+  });
+
+  it('is a no-op when a dimension is zero', () => {
+    const source = createBitmap(2, 2, 0xffffffff);
+    const out = createBitmap(0, 0);
+    expect(() => resizeBitmap(region(out), region(source))).not.toThrow();
+  });
+});