@flighthq/bitmap 0.3.0-edge.1458.0c01b63

package/src/bitmapComposite.test.ts

@@ -0,0 +1,259 @@
+import { BitmapCompositeMode } from '@flighthq/types/contract';
+
+import { createBitmap } from './bitmap';
+import {
+  compositeBitmapPixels,
+  compositeBitmapRegion,
+  extractBitmapPixels,
+  extractBitmapPixels32,
+  writeBitmapPixels,
+  writeBitmapPixels32,
+} from './bitmapComposite';
+
+function region(bitmap: ReturnType<typeof createBitmap>, x = 0, y = 0, width = bitmap.width, height = bitmap.height) {
+  return { bitmap, x, y, width, height };
+}
+
+describe('compositeBitmapPixels', () => {
+  it('alpha-composites pixels over the destination', () => {
+    const dest = createBitmap(1, 1, 0x0000ffff);
+    const pixels = new Uint8ClampedArray([0xff, 0, 0, 0xff]);
+    compositeBitmapPixels(region(dest), pixels);
+    expect(dest.data[0]).toBe(0xff);
+    expect(dest.data[2]).toBe(0);
+    expect(dest.data[3]).toBe(0xff);
+  });
+
+  it('blends semi-transparent source over destination', () => {
+    const dest = createBitmap(1, 1, 0x000000ff);
+    const pixels = new Uint8ClampedArray([0xff, 0xff, 0xff, 0x80]);
+    compositeBitmapPixels(region(dest), pixels);
+    expect(dest.data[0]).toBeGreaterThan(0);
+    expect(dest.data[0]).toBeLessThan(0xff);
+    expect(dest.data[3]).toBe(0xff);
+  });
+
+  it('silently skips pixels outside destination bounds', () => {
+    const dest = createBitmap(1, 1);
+    const pixels = new Uint8ClampedArray([0xff, 0xff, 0xff, 0xff]);
+    compositeBitmapPixels(region(dest, 5, 5, 1, 1), pixels);
+    expect(dest.data[3]).toBe(0);
+  });
+
+  it('multiply blend mode multiplies source and destination channels', () => {
+    const dest = createBitmap(1, 1, 0xff0000ff); // RGBA: opaque red
+    const pixels = new Uint8ClampedArray([128, 128, 128, 255]);
+    compositeBitmapPixels(region(dest), pixels, BitmapCompositeMode.Multiply);
+    expect(dest.data[0]).toBe(128); // 255 * 128 / 255
+    expect(dest.data[1]).toBe(0); // 0 * 128 / 255
+    expect(dest.data[2]).toBe(0);
+    expect(dest.data[3]).toBe(255);
+  });
+
+  it('add blend mode clamps the sum of channels', () => {
+    const dest = createBitmap(1, 1, 0x640000ff); // RGBA: opaque dark red (R=100)
+    const pixels = new Uint8ClampedArray([200, 0, 0, 255]);
+    compositeBitmapPixels(region(dest), pixels, BitmapCompositeMode.Add);
+    expect(dest.data[0]).toBe(255); // min(255, 100 + 200)
+  });
+
+  it('defaults to source-over (Normal) when no blend mode is given', () => {
+    const dest = createBitmap(1, 1, 0xff0000ff); // RGBA: opaque red
+    const pixels = new Uint8ClampedArray([0, 0, 255, 255]);
+    compositeBitmapPixels(region(dest), pixels);
+    expect(dest.data[0]).toBe(0);
+    expect(dest.data[2]).toBe(255);
+  });
+
+  it('overlay blend mode darkens on dark backdrops', () => {
+    const dest = createBitmap(1, 1, 0x400000ff); // RGBA: R=64
+    const pixels = new Uint8ClampedArray([200, 0, 0, 255]);
+    compositeBitmapPixels(region(dest), pixels, BitmapCompositeMode.Overlay);
+    expect(dest.data[0]).toBe(100); // 2 * 64 * 200 / 255
+  });
+
+  it('hardlight blend mode is overlay with operands swapped', () => {
+    const dest = createBitmap(1, 1, 0xc80000ff); // RGBA: R=200
+    const pixels = new Uint8ClampedArray([64, 0, 0, 255]);
+    compositeBitmapPixels(region(dest), pixels, BitmapCompositeMode.HardLight);
+    expect(dest.data[0]).toBe(100); // 2 * 200 * 64 / 255
+  });
+
+  it('invert blend mode inverts the backdrop, ignoring source color', () => {
+    const dest = createBitmap(1, 1, 0xc80000ff); // RGBA: R=200
+    const pixels = new Uint8ClampedArray([0, 0, 0, 255]);
+    compositeBitmapPixels(region(dest), pixels, BitmapCompositeMode.Invert);
+    expect(dest.data[0]).toBe(55); // 255 - 200
+  });
+
+  it('DestinationOut (erase) knocks alpha out of the backdrop, keeping color', () => {
+    const dest = createBitmap(1, 1, 0xff0000ff); // RGBA: opaque red
+    const pixels = new Uint8ClampedArray([0, 0, 0, 128]);
+    compositeBitmapPixels(region(dest), pixels, BitmapCompositeMode.DestinationOut);
+    expect(dest.data[0]).toBe(255); // color untouched
+    expect(dest.data[3]).toBe(127); // 255 * (1 - 128/255)
+  });
+
+  it('DestinationIn (alpha) masks the backdrop to the source coverage', () => {
+    const dest = createBitmap(1, 1, 0xff0000ff); // RGBA: opaque red
+    const pixels = new Uint8ClampedArray([0, 0, 0, 128]);
+    compositeBitmapPixels(region(dest), pixels, BitmapCompositeMode.DestinationIn);
+    expect(dest.data[0]).toBe(255); // backdrop color kept
+    expect(dest.data[3]).toBe(128); // 255 * (128/255)
+  });
+
+  it('Copy overwrites the backdrop with the source', () => {
+    const dest = createBitmap(1, 1, 0xff0000ff); // opaque red
+    const pixels = new Uint8ClampedArray([0, 0, 255, 128]); // semi-transparent blue
+    compositeBitmapPixels(region(dest), pixels, BitmapCompositeMode.Copy);
+    expect(dest.data[2]).toBe(255);
+    expect(dest.data[3]).toBe(128); // source alpha replaces, no source-over
+  });
+});
+
+describe('compositeBitmapRegion', () => {
+  it('alpha-composites a region of one bitmap over another', () => {
+    const source = createBitmap(1, 1, 0xff0000ff);
+    const dest = createBitmap(1, 1, 0x0000ffff);
+    compositeBitmapRegion(region(dest), region(source));
+    expect(dest.data[0]).toBe(0xff);
+    expect(dest.data[2]).toBe(0);
+  });
+
+  it('clips to the smaller of source and dest dimensions', () => {
+    const source = createBitmap(1, 1, 0xff0000ff);
+    const dest = createBitmap(3, 3);
+    compositeBitmapRegion(region(dest, 1, 1, 2, 2), region(source));
+    expect(dest.data[(1 * 3 + 1) * 4]).toBe(0xff);
+    expect(dest.data[(1 * 3 + 2) * 4]).toBe(0);
+  });
+
+  it('applies the blend mode to the source region', () => {
+    const source = createBitmap(1, 1, 0x808080ff); // RGBA: opaque gray
+    const dest = createBitmap(1, 1, 0xff0000ff); // RGBA: opaque red
+    compositeBitmapRegion(region(dest), region(source), BitmapCompositeMode.Multiply);
+    expect(dest.data[0]).toBe(128); // 255 * 128 / 255
+    expect(dest.data[1]).toBe(0);
+  });
+});
+
+describe('extractBitmapPixels', () => {
+  it('copies a bitmap region into a tightly-packed buffer', () => {
+    const source = createBitmap(2, 2);
+    const i = (1 * 2 + 1) * 4;
+    source.data[i] = 0xff;
+    source.data[i + 3] = 0xff;
+    const out = new Uint8ClampedArray(4);
+    extractBitmapPixels(out, region(source, 1, 1, 1, 1));
+    expect(out[0]).toBe(0xff);
+    expect(out[3]).toBe(0xff);
+  });
+
+  it('silently skips pixels outside source bounds', () => {
+    const source = createBitmap(1, 1, 0xffffffff);
+    const out = new Uint8ClampedArray(4 * 4);
+    extractBitmapPixels(out, region(source, -1, -1, 2, 2));
+    const i = (1 * 2 + 1) * 4;
+    expect(out[i]).toBe(0xff);
+    expect(out[i + 3]).toBe(0xff);
+    expect(out[0]).toBe(0);
+  });
+
+  it('source.bitmap.data can be passed as out for a full-bitmap extraction', () => {
+    const source = createBitmap(2, 2, 0xaabbccff);
+    extractBitmapPixels(source.data, region(source));
+    expect(source.data[0]).toBe(0xaa);
+    expect(source.data[3]).toBe(0xff);
+  });
+});
+
+describe('extractBitmapPixels32', () => {
+  it('packs each pixel into one 0xRRGGBBAA entry', () => {
+    const source = createBitmap(2, 2);
+    const i = (1 * 2 + 1) * 4;
+    source.data[i] = 0x11;
+    source.data[i + 1] = 0x22;
+    source.data[i + 2] = 0x33;
+    source.data[i + 3] = 0x44;
+    const out = new Uint32Array(1);
+    extractBitmapPixels32(out, region(source, 1, 1, 1, 1));
+    expect(out[0]).toBe(0x11223344);
+  });
+
+  it('round-trips with writeBitmapPixels32', () => {
+    const source = createBitmap(3, 2);
+    for (let p = 0; p < 6; p++) {
+      const i = p * 4;
+      source.data[i] = p * 10 + 1;
+      source.data[i + 1] = p * 10 + 2;
+      source.data[i + 2] = p * 10 + 3;
+      source.data[i + 3] = p * 10 + 4;
+    }
+    const packed = new Uint32Array(6);
+    extractBitmapPixels32(packed, region(source));
+    const dest = createBitmap(3, 2);
+    writeBitmapPixels32(region(dest), packed);
+    expect(Array.from(dest.data)).toEqual(Array.from(source.data));
+  });
+
+  it('silently skips pixels outside source bounds', () => {
+    const source = createBitmap(1, 1, 0xffffffff);
+    const out = new Uint32Array(4);
+    extractBitmapPixels32(out, region(source, -1, -1, 2, 2));
+    expect(out[1 * 2 + 1]).toBe(0xffffffff);
+    expect(out[0]).toBe(0);
+  });
+});
+
+describe('writeBitmapPixels', () => {
+  it('writes pixels at the given destination region', () => {
+    const dest = createBitmap(3, 3);
+    const pixels = new Uint8ClampedArray([0x33, 0x66, 0x99, 0xff]);
+    writeBitmapPixels(region(dest, 1, 1, 1, 1), pixels);
+    const i = (1 * 3 + 1) * 4;
+    expect(dest.data[i]).toBe(0x33);
+    expect(dest.data[i + 1]).toBe(0x66);
+    expect(dest.data[i + 2]).toBe(0x99);
+    expect(dest.data[i + 3]).toBe(0xff);
+  });
+
+  it('overwrites existing content', () => {
+    const dest = createBitmap(1, 1, 0x0000ffff);
+    const pixels = new Uint8ClampedArray([0xff, 0, 0, 0xff]);
+    writeBitmapPixels(region(dest), pixels);
+    expect(dest.data[2]).toBe(0);
+    expect(dest.data[0]).toBe(0xff);
+  });
+
+  it('silently clips writes outside destination bounds', () => {
+    const dest = createBitmap(1, 1);
+    const pixels = new Uint8ClampedArray([0xff, 0xff, 0xff, 0xff]);
+    writeBitmapPixels(region(dest, 5, 5, 1, 1), pixels);
+    expect(dest.data[3]).toBe(0);
+  });
+});
+
+describe('writeBitmapPixels32', () => {
+  it('unpacks each 0xRRGGBBAA entry into the destination region', () => {
+    const dest = createBitmap(3, 3);
+    writeBitmapPixels32(region(dest, 1, 1, 1, 1), new Uint32Array([0x33669900 | 0xff]));
+    const i = (1 * 3 + 1) * 4;
+    expect(dest.data[i]).toBe(0x33);
+    expect(dest.data[i + 1]).toBe(0x66);
+    expect(dest.data[i + 2]).toBe(0x99);
+    expect(dest.data[i + 3]).toBe(0xff);
+  });
+
+  it('overwrites existing content', () => {
+    const dest = createBitmap(1, 1, 0x0000ffff);
+    writeBitmapPixels32(region(dest), new Uint32Array([0xff0000ff]));
+    expect(dest.data[0]).toBe(0xff);
+    expect(dest.data[2]).toBe(0);
+  });
+
+  it('silently clips writes outside destination bounds', () => {
+    const dest = createBitmap(1, 1);
+    writeBitmapPixels32(region(dest, 5, 5, 1, 1), new Uint32Array([0xffffffff]));
+    expect(dest.data[3]).toBe(0);
+  });
+});

package/src/bitmapConvolution.test.ts

@@ -0,0 +1,130 @@
+import { createBitmap } from './bitmap';
+import { convolveBitmap } from './bitmapConvolution';
+
+function region(bitmap: ReturnType<typeof createBitmap>, x = 0, y = 0, width = bitmap.width, height = bitmap.height) {
+  return { bitmap, x, y, width, height };
+}
+
+describe('convolveBitmap', () => {
+  it('applies a convolution matrix to the source region', () => {
+    const source = createBitmap(3, 1);
+    source.data[0] = 10;
+    source.data[4] = 20;
+    source.data[8] = 30;
+    const out = new Uint8ClampedArray(4);
+    convolveBitmap(out, region(source, 1, 0, 1, 1), {
+      matrix: [1, 1, 1],
+      matrixX: 3,
+      matrixY: 1,
+      preserveAlpha: false,
+    });
+    expect(out[0]).toBe(20);
+  });
+
+  it("'clamp' edge mode (default) repeats the nearest edge pixel", () => {
+    // 1px source, 3-wide kernel: all three samples hit the single source pixel
+    const source = createBitmap(1, 1, 0x606060ff);
+    const out = new Uint8ClampedArray(4);
+    convolveBitmap(out, region(source), {
+      matrix: [1, 1, 1],
+      matrixX: 3,
+      matrixY: 1,
+      divisor: 3,
+      preserveAlpha: false,
+    });
+    expect(out[0]).toBe(0x60);
+  });
+
+  it("'mirror' edge mode reflects at boundaries", () => {
+    // 3px source [10, 20, 30]. 5-wide kernel [1, 0, 0, 0, 0] picks 2 positions left.
+    // For px=0, offsetX=2: rawSampleX = 0 + 0 + 0 - 2 = -2.
+    // mirror(-2, 3) reflects to x=1 (value 20), while clamp(-2) gives x=0 (value 10).
+    const source = createBitmap(3, 1);
+    source.data[0] = 10;
+    source.data[4] = 20;
+    source.data[8] = 30;
+    const out = new Uint8ClampedArray(3 * 4);
+    convolveBitmap(out, region(source), {
+      edge: 'mirror',
+      matrix: [1, 0, 0, 0, 0],
+      matrixX: 5,
+      matrixY: 1,
+      divisor: 1,
+      preserveAlpha: false,
+    });
+    expect(out[0]).toBe(20);
+  });
+
+  it("'transparent' edge mode treats out-of-bounds as transparent black", () => {
+    // 1px source (opaque black), 3-wide kernel [1, 0, 0] — leftmost sample
+    // is out of bounds and contributes transparent black (all zeros).
+    const source = createBitmap(1, 1, 0x000000ff);
+    const out = new Uint8ClampedArray(4);
+    convolveBitmap(out, region(source), {
+      edge: 'transparent',
+      divisor: 1,
+      matrix: [1, 0, 0],
+      matrixX: 3,
+      matrixY: 1,
+      preserveAlpha: false,
+    });
+    expect(out[0]).toBe(0);
+    expect(out[3]).toBe(0);
+  });
+
+  it("'wrap' edge mode tiles the source toroidally", () => {
+    // 3px source [10, 20, 30]. The leftmost kernel position for px=0 wraps to px=2.
+    const source = createBitmap(3, 1);
+    source.data[0] = 10;
+    source.data[4] = 20;
+    source.data[8] = 30;
+    const out = new Uint8ClampedArray(3 * 4);
+    convolveBitmap(out, region(source), {
+      edge: 'wrap',
+      matrix: [1, 0, 0], // picks left neighbor only
+      matrixX: 3,
+      matrixY: 1,
+      divisor: 1,
+      preserveAlpha: false,
+    });
+    // px=0 left neighbor wraps to px=2 → value 30
+    expect(out[0]).toBe(30);
+  });
+
+  it('preserves source alpha by default', () => {
+    const source = createBitmap(1, 1, 0x00000044);
+    const out = new Uint8ClampedArray(4);
+    convolveBitmap(out, region(source), {
+      bias: 255,
+      matrix: [1],
+      matrixX: 1,
+      matrixY: 1,
+    });
+    expect(out[3]).toBe(0x44);
+  });
+
+  it('throws when matrix dimensions are not positive', () => {
+    const source = createBitmap(1, 1);
+    const out = new Uint8ClampedArray(4);
+    expect(() => convolveBitmap(out, region(source), { matrix: [], matrixX: 0, matrixY: 1 })).toThrow();
+  });
+
+  it('throws when matrix is too short for its declared dimensions', () => {
+    const source = createBitmap(1, 1);
+    const out = new Uint8ClampedArray(4);
+    expect(() => convolveBitmap(out, region(source), { matrix: [1], matrixX: 3, matrixY: 3 })).toThrow();
+  });
+
+  it('treats an explicit divisor of 0 as passthrough (no division by zero)', () => {
+    const source = createBitmap(1, 1, 0x804020ff);
+    const out = new Uint8ClampedArray(4);
+    convolveBitmap(out, region(source), {
+      divisor: 0,
+      matrix: [1],
+      matrixX: 1,
+      matrixY: 1,
+      preserveAlpha: false,
+    });
+    expect(out[0]).toBe(0x80);
+  });
+});

package/src/bitmapCopy.test.ts

@@ -0,0 +1,48 @@
+import { createBitmap } from './bitmap';
+import { copyBitmapChannel, copyBitmapPixels } from './bitmapCopy';
+import { ImageChannel } from './bitmapImageChannel';
+import { getBitmapPixel, setBitmapPixel } from './bitmapPixel';
+
+function region(bitmap: ReturnType<typeof createBitmap>, x = 0, y = 0, width = bitmap.width, height = bitmap.height) {
+  return { bitmap, x, y, width, height };
+}
+
+describe('copyBitmapChannel', () => {
+  it('copies the red channel to the blue channel', () => {
+    const src = createBitmap(2, 2);
+    src.data[0] = 0xab;
+    const dst = createBitmap(2, 2);
+    copyBitmapChannel(region(dst), ImageChannel.Blue, region(src), ImageChannel.Red);
+    expect(dst.data[2]).toBe(src.data[0]);
+  });
+
+  it('copies the alpha channel independently', () => {
+    const src = createBitmap(1, 1);
+    setBitmapPixel(src, 0, 0, 0x000000de);
+    const dst = createBitmap(1, 1);
+    copyBitmapChannel(region(dst), ImageChannel.Alpha, region(src), ImageChannel.Alpha);
+    expect(dst.data[3]).toBe(0xde);
+  });
+});
+
+describe('copyBitmapPixels', () => {
+  it('copies a region without alpha blend', () => {
+    const src = createBitmap(2, 2, 0xaabbccff);
+    const dst = createBitmap(4, 4);
+    copyBitmapPixels(region(dst, 1, 1, 2, 2), region(src, 0, 0, 2, 2));
+    expect(getBitmapPixel(dst, 1, 1)).toBe(0xaabbccff);
+    expect(getBitmapPixel(dst, 0, 0)).toBe(0x00000000);
+  });
+
+  it('alpha-composites when composite is true', () => {
+    const src = createBitmap(1, 1);
+    setBitmapPixel(src, 0, 0, 0xff000080);
+    const dst = createBitmap(1, 1);
+    setBitmapPixel(dst, 0, 0, 0x0000ffff);
+    copyBitmapPixels(region(dst), region(src), true);
+    const result = getBitmapPixel(dst, 0, 0);
+    expect(result & 0xff).toBe(0xff); // alpha opaque after composite
+    expect((result >>> 24) & 0xff).toBeGreaterThan(0); // red blended in
+    expect((result >> 8) & 0xff).toBeGreaterThan(0); // blue retained
+  });
+});

package/src/bitmapCoverage.test.ts

@@ -0,0 +1,39 @@
+import { createBitmap } from './bitmap';
+import { getBitmapCoverage } from './bitmapCoverage';
+import { setBitmapPixel } from './bitmapPixel';
+
+describe('getBitmapCoverage', () => {
+  it('returns 0 for a bitmap still entirely the background colour', () => {
+    expect(getBitmapCoverage(createBitmap(4, 4, 0x123456ff), 0x123456ff)).toBe(0);
+  });
+
+  it('returns 0 for a fully transparent bitmap against a transparent background', () => {
+    expect(getBitmapCoverage(createBitmap(4, 4, 0x00000000), 0x00000000)).toBe(0);
+  });
+
+  it('counts pixels that differ from the background on any channel', () => {
+    const bitmap = createBitmap(2, 2, 0x000000ff);
+    setBitmapPixel(bitmap, 0, 0, 0xff0000ff);
+    expect(getBitmapCoverage(bitmap, 0x000000ff)).toBe(0.25);
+  });
+
+  it('measures a fully painted bitmap as full coverage', () => {
+    const bitmap = createBitmap(2, 2, 0x000000ff);
+    setBitmapPixel(bitmap, 0, 0, 0xffffffff);
+    setBitmapPixel(bitmap, 1, 0, 0xffffffff);
+    setBitmapPixel(bitmap, 0, 1, 0xffffffff);
+    setBitmapPixel(bitmap, 1, 1, 0xffffffff);
+    expect(getBitmapCoverage(bitmap, 0x000000ff)).toBe(1);
+  });
+
+  it('ignores differences within the channel tolerance', () => {
+    const bitmap = createBitmap(2, 1, 0x000000ff);
+    setBitmapPixel(bitmap, 0, 0, 0x050505ff); // 5 per channel
+    expect(getBitmapCoverage(bitmap, 0x000000ff, 5)).toBe(0);
+    expect(getBitmapCoverage(bitmap, 0x000000ff, 4)).toBe(0.5);
+  });
+
+  it('returns 0 for an empty bitmap', () => {
+    expect(getBitmapCoverage(createBitmap(0, 0), 0x000000ff)).toBe(0);
+  });
+});

package/src/bitmapCrop.test.ts

@@ -0,0 +1,116 @@
+import { createBitmap } from './bitmap';
+import { cropBitmap, extendBitmap, trimBitmap } from './bitmapCrop';
+import { getBitmapPixel, setBitmapPixel } from './bitmapPixel';
+
+describe('cropBitmap', () => {
+  it('returns a bitmap with the requested dimensions', () => {
+    const src = createBitmap(10, 10, 0xff0000ff);
+    const out = cropBitmap(src, { x: 2, y: 3, width: 4, height: 5 });
+    expect(out.width).toBe(4);
+    expect(out.height).toBe(5);
+  });
+
+  it('copies pixels from the source region', () => {
+    const src = createBitmap(4, 4);
+    setBitmapPixel(src, 2, 1, 0x00ff00ff);
+    const out = cropBitmap(src, { x: 2, y: 1, width: 2, height: 2 });
+    expect(getBitmapPixel(out, 0, 0)).toBe(0x00ff00ff);
+  });
+
+  it('fills pixels outside the source with transparent black', () => {
+    const src = createBitmap(2, 2, 0xffffffff);
+    // Crop region extends beyond source.
+    const out = cropBitmap(src, { x: 1, y: 1, width: 3, height: 3 });
+    // (0,0) is inside source — opaque white.
+    expect(getBitmapPixel(out, 0, 0)).toBe(0xffffffff);
+    // (2,2) is outside source — transparent black.
+    expect(getBitmapPixel(out, 2, 2)).toBe(0x00000000);
+  });
+
+  it('preserves source colorSpace and alphaType', () => {
+    const src = createBitmap(2, 2, 0xff0000ff);
+    const out = cropBitmap(src, { x: 0, y: 0, width: 2, height: 2 });
+    expect(out.colorSpace).toBe(src.colorSpace);
+    expect(out.alphaType).toBe(src.alphaType);
+  });
+
+  it('returns a distinct bitmap object', () => {
+    const src = createBitmap(2, 2, 0xff0000ff);
+    const out = cropBitmap(src, { x: 0, y: 0, width: 2, height: 2 });
+    expect(out).not.toBe(src);
+    expect(out.data).not.toBe(src.data);
+  });
+});
+
+describe('extendBitmap', () => {
+  it('returns a bitmap padded by the correct number of pixels', () => {
+    const src = createBitmap(2, 2, 0x0000ffff);
+    const out = extendBitmap(src, 1, 2, 3, 4);
+    expect(out.width).toBe(2 + 1 + 3);
+    expect(out.height).toBe(2 + 2 + 4);
+  });
+
+  it('copies source pixels into the center region', () => {
+    const src = createBitmap(2, 2, 0xabcdefff);
+    const out = extendBitmap(src, 1, 1, 1, 1);
+    expect(getBitmapPixel(out, 1, 1)).toBe(0xabcdefff);
+  });
+
+  it('transparent edge mode fills padding with transparent black by default', () => {
+    const src = createBitmap(2, 2, 0xff0000ff);
+    const out = extendBitmap(src, 1, 1, 1, 1);
+    expect(getBitmapPixel(out, 0, 0)).toBe(0x00000000);
+  });
+
+  it('transparent edge mode uses fillColor when provided', () => {
+    const src = createBitmap(2, 2, 0xff0000ff);
+    const out = extendBitmap(src, 1, 1, 1, 1, 'transparent', 0xffffffff);
+    expect(getBitmapPixel(out, 0, 0)).toBe(0xffffffff);
+  });
+
+  it('clamp edge mode repeats border pixels in padding', () => {
+    const src = createBitmap(2, 2, 0x0000ffff);
+    // Set a distinct border pixel.
+    setBitmapPixel(src, 0, 0, 0x123456ff);
+    const out = extendBitmap(src, 1, 1, 0, 0, 'clamp');
+    // Top-left padding comes from source (0,0).
+    expect(getBitmapPixel(out, 0, 0)).toBe(0x123456ff);
+  });
+
+  it('wrap edge mode tiles the source in padding', () => {
+    const src = createBitmap(2, 2);
+    setBitmapPixel(src, 0, 0, 0xff0000ff);
+    setBitmapPixel(src, 1, 0, 0x00ff00ff);
+    // Extend by 2 on the right → first padding column maps to source col 0.
+    const out = extendBitmap(src, 0, 0, 2, 0, 'wrap');
+    expect(getBitmapPixel(out, 2, 0)).toBe(0xff0000ff);
+    expect(getBitmapPixel(out, 3, 0)).toBe(0x00ff00ff);
+  });
+});
+
+describe('trimBitmap', () => {
+  it('removes transparent border rows and columns', () => {
+    const src = createBitmap(5, 5);
+    // Only pixel (2,2) is non-transparent.
+    setBitmapPixel(src, 2, 2, 0xff0000ff);
+    const out = trimBitmap(src);
+    expect(out.width).toBe(1);
+    expect(out.height).toBe(1);
+    expect(getBitmapPixel(out, 0, 0)).toBe(0xff0000ff);
+  });
+
+  it('returns a 1×1 transparent bitmap for a fully transparent input', () => {
+    const src = createBitmap(3, 3);
+    const out = trimBitmap(src);
+    expect(out.width).toBe(1);
+    expect(out.height).toBe(1);
+    expect(getBitmapPixel(out, 0, 0) & 0xff).toBe(0);
+  });
+
+  it('returns a bitmap equal to the source when there is no transparent border', () => {
+    const src = createBitmap(2, 2, 0xff0000ff);
+    const out = trimBitmap(src);
+    expect(out.width).toBe(2);
+    expect(out.height).toBe(2);
+  });
+});