@flighthq/binpack 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './packRectangles';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './packRectangles';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/dist/packRectangles.d.ts

@@ -0,0 +1,3 @@
+import type { BinPackOptions, PackableRectangle, PackResult } from '@flighthq/types';
+export declare function packRectangles(rects: readonly Readonly<PackableRectangle>[], options?: Readonly<BinPackOptions>): PackResult;
+//# sourceMappingURL=packRectangles.d.ts.map

package/dist/packRectangles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packRectangles.d.ts","sourceRoot":"","sources":["../src/packRectangles.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAmB,UAAU,EAAe,MAAM,iBAAiB,CAAC;AAiBnH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,SAAS,QAAQ,CAAC,iBAAiB,CAAC,EAAE,EAC7C,OAAO,CAAC,EAAE,QAAQ,CAAC,cAAc,CAAC,GACjC,UAAU,CAuDZ"}

package/dist/packRectangles.js

@@ -0,0 +1,269 @@
+import { intersectsRectangle } from '@flighthq/geometry';
+// Places a set of rectangles without overlap into a bin using the MaxRects algorithm with the
+// Best-Short-Side-Fit (BSSF) heuristic, and reports each placement, the used bin extent, and any ids
+// that did not fit.
+//
+// The result is deterministic: the same `rects` (by value) and `options` always produce an identical
+// `PackResult`. Inputs are sorted by descending area, then descending height, then width, then id
+// before placement — a total order with no reliance on sort stability — and no `Math.random`/`Date`
+// is consulted.
+//
+// Padding and border are honored geometrically: every pair of placements is at least `padding` apart
+// and every placement is at least `border` from the reported bin edge. When `allowRotation` is set, a
+// rectangle may be turned 90° (reported via `rotated` and swapped `width`/`height`) if that fits
+// better. A `growable` bin starts small and grows toward `maxWidth`/`maxHeight`; a fixed bin overflows
+// into `unpacked`. The reported `width`/`height` is the tight used extent, then adjusted for `square`
+// and `powerOfTwo` when those are set.
+export function packRectangles(rects, options) {
+    const padding = options?.padding ?? 0;
+    const border = options?.border ?? 0;
+    const allowRotation = options?.allowRotation ?? false;
+    const growable = options?.growable ?? true;
+    const powerOfTwo = options?.powerOfTwo ?? false;
+    const square = options?.square ?? false;
+    const maxWidth = options?.maxWidth ?? DEFAULT_MAX_EXTENT;
+    const maxHeight = options?.maxHeight ?? DEFAULT_MAX_EXTENT;
+    if (rects.length === 0) {
+        return {
+            placements: [],
+            width: finalizeExtent(0, powerOfTwo),
+            height: finalizeExtent(0, powerOfTwo),
+            unpacked: [],
+        };
+    }
+    const sorted = sortRectanglesForPacking(rects);
+    // The smallest bin each dimension must reach for a rectangle to fit at all, accounting for the
+    // border on both sides. A rectangle wider than `maxWidth` (and, if rotatable, taller than
+    // `maxHeight` in its other orientation) can never be placed and lands in `unpacked`.
+    let needWidth = 2 * border;
+    let needHeight = 2 * border;
+    let totalArea = 0;
+    for (const rect of sorted) {
+        const shortSide = Math.min(rect.width, rect.height);
+        const requiredWidth = (allowRotation ? shortSide : rect.width) + 2 * border;
+        const requiredHeight = (allowRotation ? shortSide : rect.height) + 2 * border;
+        needWidth = Math.max(needWidth, requiredWidth);
+        needHeight = Math.max(needHeight, requiredHeight);
+        totalArea += (rect.width + padding) * (rect.height + padding);
+    }
+    // A fixed bin is exactly the cap; a growable bin starts at a square seed sized to the total area (but
+    // at least large enough to hold the largest single rectangle) and grows from there.
+    const seed = Math.ceil(Math.sqrt(totalArea)) + 2 * border;
+    let binWidth = growable ? Math.min(Math.max(seed, needWidth), maxWidth) : maxWidth;
+    let binHeight = growable ? Math.min(Math.max(seed, needHeight), maxHeight) : maxHeight;
+    let attempt = packIntoBin(sorted, binWidth, binHeight, padding, border, allowRotation);
+    while (attempt.unpacked.length > 0 && growable && (binWidth < maxWidth || binHeight < maxHeight)) {
+        if (binWidth <= binHeight && binWidth < maxWidth) {
+            binWidth = Math.min(binWidth * 2, maxWidth);
+        }
+        else if (binHeight < maxHeight) {
+            binHeight = Math.min(binHeight * 2, maxHeight);
+        }
+        else {
+            binWidth = Math.min(binWidth * 2, maxWidth);
+        }
+        attempt = packIntoBin(sorted, binWidth, binHeight, padding, border, allowRotation);
+    }
+    return finalizeResult(attempt, border, powerOfTwo, square);
+}
+// Rounds `value` up to the next power of two (>= 1). Used only for the final `powerOfTwo` adjustment.
+function ceilToPowerOfTwo(value) {
+    if (value <= 1)
+        return 1;
+    let result = 1;
+    while (result < value)
+        result *= 2;
+    return result;
+}
+// Turns the raw placements from `packIntoBin` into the public `PackResult`, shifting effective-space
+// coordinates back into bin space by `border` and finalizing the reported extent for `square` /
+// `powerOfTwo`.
+function finalizeResult(packed, border, powerOfTwo, square) {
+    let contentRight = 0;
+    let contentBottom = 0;
+    for (const placement of packed.placements) {
+        contentRight = Math.max(contentRight, placement.x + placement.width);
+        contentBottom = Math.max(contentBottom, placement.y + placement.height);
+    }
+    let width = packed.placements.length > 0 ? contentRight + border : 0;
+    let height = packed.placements.length > 0 ? contentBottom + border : 0;
+    if (square) {
+        width = Math.max(width, height);
+        height = width;
+    }
+    width = finalizeExtent(width, powerOfTwo);
+    height = finalizeExtent(height, powerOfTwo);
+    if (square) {
+        width = Math.max(width, height);
+        height = width;
+    }
+    return {
+        placements: packed.placements.map((placement) => ({ ...placement })),
+        width,
+        height,
+        unpacked: [...packed.unpacked],
+    };
+}
+// Applies the `powerOfTwo` rounding (if set) to a single extent value.
+function finalizeExtent(value, powerOfTwo) {
+    return powerOfTwo && value > 0 ? ceilToPowerOfTwo(value) : value;
+}
+// Best-Short-Side-Fit search: over every free rectangle (and, when rotation is allowed, both
+// orientations of the piece), pick the fit that leaves the smallest leftover short side, breaking
+// ties by smallest leftover long side, then by top-most / left-most free rectangle, then by the
+// unrotated orientation. Returns the chosen placement, or `null` when the piece fits nowhere.
+//
+// `pieceWidth`/`pieceHeight` are the effective footprint (rectangle size plus the trailing padding
+// gutter) in the unrotated orientation.
+function findBestPlacement(free, pieceWidth, pieceHeight, allowRotation) {
+    let best = null;
+    let bestShort = Number.POSITIVE_INFINITY;
+    let bestLong = Number.POSITIVE_INFINITY;
+    for (const node of free) {
+        // Two candidate orientations: unrotated, then (optionally) the 90° turn.
+        for (let rotated = 0; rotated <= (allowRotation ? 1 : 0); rotated++) {
+            const width = rotated ? pieceHeight : pieceWidth;
+            const height = rotated ? pieceWidth : pieceHeight;
+            if (width > node.width || height > node.height)
+                continue;
+            const leftoverHorizontal = node.width - width;
+            const leftoverVertical = node.height - height;
+            const shortSide = Math.min(leftoverHorizontal, leftoverVertical);
+            const longSide = Math.max(leftoverHorizontal, leftoverVertical);
+            if (best === null || shortSide < bestShort || (shortSide === bestShort && longSide < bestLong)) {
+                best = { x: node.x, y: node.y, footprintWidth: width, footprintHeight: height, rotated: rotated === 1 };
+                bestShort = shortSide;
+                bestLong = longSide;
+            }
+        }
+    }
+    return best;
+}
+// True when the whole of `inner` lies within `outer` — the containment test used to prune redundant
+// free rectangles after a split.
+function isFreeRectangleContained(inner, outer) {
+    return (inner.x >= outer.x &&
+        inner.y >= outer.y &&
+        inner.x + inner.width <= outer.x + outer.width &&
+        inner.y + inner.height <= outer.y + outer.height);
+}
+// Runs one MaxRects pass at a fixed bin size. Every rectangle is inflated to an "effective" footprint
+// of `(width + padding) x (height + padding)` — the trailing gutter is what guarantees at least
+// `padding` between neighbors — and packed into the effective usable region
+// `(binWidth - 2*border + padding) x (binHeight - 2*border + padding)`. This construction makes the
+// actual placement satisfy `x >= border` and `x + width <= binWidth - border` (likewise vertically),
+// so `border` is respected on every side while the last row/column's gutter costs no real space.
+function packIntoBin(sorted, binWidth, binHeight, padding, border, allowRotation) {
+    const usableWidth = binWidth - 2 * border + padding;
+    const usableHeight = binHeight - 2 * border + padding;
+    const placements = [];
+    const unpacked = [];
+    if (usableWidth <= 0 || usableHeight <= 0) {
+        for (const rect of sorted)
+            unpacked.push(rect.id);
+        return { placements, unpacked };
+    }
+    const free = [{ x: 0, y: 0, width: usableWidth, height: usableHeight }];
+    for (const rect of sorted) {
+        const pieceWidth = rect.width + padding;
+        const pieceHeight = rect.height + padding;
+        const placement = findBestPlacement(free, pieceWidth, pieceHeight, allowRotation);
+        if (placement === null) {
+            unpacked.push(rect.id);
+            continue;
+        }
+        placements.push({
+            id: rect.id,
+            x: placement.x + border,
+            y: placement.y + border,
+            width: placement.rotated ? rect.height : rect.width,
+            height: placement.rotated ? rect.width : rect.height,
+            rotated: placement.rotated,
+        });
+        splitFreeRectangles(free, placement);
+        pruneFreeRectangles(free);
+    }
+    return { placements, unpacked };
+}
+// Removes any free rectangle fully contained within another. MaxRects splitting can leave redundant
+// free rectangles nested inside larger ones; pruning them keeps the search cheap and the free list
+// non-redundant.
+function pruneFreeRectangles(free) {
+    for (let i = 0; i < free.length; i++) {
+        for (let j = i + 1; j < free.length; j++) {
+            if (isFreeRectangleContained(free[i], free[j])) {
+                free.splice(i, 1);
+                i--;
+                break;
+            }
+            if (isFreeRectangleContained(free[j], free[i])) {
+                free.splice(j, 1);
+                j--;
+            }
+        }
+    }
+}
+// Deterministic total order over the input rectangles: descending area, then descending height, then
+// descending width, then ascending id (numbers before strings; numbers numerically, strings
+// lexicographically). Returns a new array; the input is not mutated.
+function sortRectanglesForPacking(rects) {
+    return [...rects].sort((a, b) => {
+        const areaA = a.width * a.height;
+        const areaB = b.width * b.height;
+        if (areaA !== areaB)
+            return areaB - areaA;
+        if (a.height !== b.height)
+            return b.height - a.height;
+        if (a.width !== b.width)
+            return b.width - a.width;
+        return compareRectangleId(a.id, b.id);
+    });
+}
+// MaxRects splitting: for every free rectangle overlapping the just-placed footprint, replace it with
+// the (up to four) sub-rectangles covering the parts of it the footprint does not cover. The footprint
+// is the effective size (rectangle plus padding gutter), so the reserved padding is carved out of the
+// free space here.
+function splitFreeRectangles(free, placement) {
+    const usedX = placement.x;
+    const usedY = placement.y;
+    const usedRight = placement.x + placement.footprintWidth;
+    const usedBottom = placement.y + placement.footprintHeight;
+    const used = {
+        x: usedX,
+        y: usedY,
+        width: placement.footprintWidth,
+        height: placement.footprintHeight,
+    };
+    for (let i = free.length - 1; i >= 0; i--) {
+        const node = free[i];
+        if (!intersectsRectangle(node, used))
+            continue;
+        const nodeRight = node.x + node.width;
+        const nodeBottom = node.y + node.height;
+        free.splice(i, 1);
+        if (usedX > node.x)
+            free.push({ x: node.x, y: node.y, width: usedX - node.x, height: node.height });
+        if (usedRight < nodeRight)
+            free.push({ x: usedRight, y: node.y, width: nodeRight - usedRight, height: node.height });
+        if (usedY > node.y)
+            free.push({ x: node.x, y: node.y, width: node.width, height: usedY - node.y });
+        if (usedBottom < nodeBottom) {
+            free.push({ x: node.x, y: usedBottom, width: node.width, height: nodeBottom - usedBottom });
+        }
+    }
+}
+// Orders two rectangle ids for the deterministic input sort: numbers before strings, numbers
+// ascending, strings lexicographically.
+function compareRectangleId(a, b) {
+    const aNumber = typeof a === 'number';
+    const bNumber = typeof b === 'number';
+    if (aNumber && bNumber)
+        return a - b;
+    if (aNumber !== bNumber)
+        return aNumber ? -1 : 1;
+    return String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0;
+}
+// The default width/height cap when `maxWidth`/`maxHeight` are unset — large enough to be effectively
+// unbounded for typical inputs while keeping growth from running away.
+const DEFAULT_MAX_EXTENT = 16384;
+//# sourceMappingURL=packRectangles.js.map

package/dist/packRectangles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"packRectangles.js","sourceRoot":"","sources":["../src/packRectangles.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@flighthq/binpack",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/geometry": "0.1.0",
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "2D rectangle bin-packing — MaxRects placement with padding/border, optional power-of-two/square/rotation, and a fixed or growable bin; plain-data rectangles in, placements + used extent + unpacked out",
+  "sideEffects": false
+}

package/src/packRectangles.test.ts

@@ -0,0 +1,189 @@
+import type { PackableRectangle, PackedRectangle } from '@flighthq/types';
+import { describe, expect, it } from 'vitest';
+
+import { packRectangles } from './packRectangles';
+
+describe('packRectangles', () => {
+  it('places ~20 varied rectangles with no pairwise overlap, inside the bin, at their input size', () => {
+    const rects: PackableRectangle[] = [];
+    for (let i = 0; i < 20; i++) {
+      rects.push({ id: i, width: 8 + ((i * 7) % 40), height: 6 + ((i * 13) % 34) });
+    }
+
+    const result = packRectangles(rects, { padding: 1, border: 2 });
+    expect(result.unpacked).toEqual([]);
+    expect(result.placements).toHaveLength(20);
+
+    const sizeById = new Map(rects.map((rect) => [rect.id, rect] as const));
+    for (const placement of result.placements) {
+      const input = sizeById.get(placement.id)!;
+      const expectedWidth = placement.rotated ? input.height : input.width;
+      const expectedHeight = placement.rotated ? input.width : input.height;
+      expect(placement.width).toBe(expectedWidth);
+      expect(placement.height).toBe(expectedHeight);
+
+      expect(placement.x).toBeGreaterThanOrEqual(2);
+      expect(placement.y).toBeGreaterThanOrEqual(2);
+      expect(placement.x + placement.width).toBeLessThanOrEqual(result.width - 2);
+      expect(placement.y + placement.height).toBeLessThanOrEqual(result.height - 2);
+    }
+
+    for (let i = 0; i < result.placements.length; i++) {
+      for (let j = i + 1; j < result.placements.length; j++) {
+        expect(rectanglesOverlap(result.placements[i], result.placements[j])).toBe(false);
+      }
+    }
+  });
+
+  it('leaves nothing unpacked when everything fits in a growable bin', () => {
+    const rects: PackableRectangle[] = [
+      { id: 'a', width: 30, height: 20 },
+      { id: 'b', width: 40, height: 40 },
+      { id: 'c', width: 10, height: 60 },
+      { id: 'd', width: 25, height: 25 },
+      { id: 'e', width: 50, height: 15 },
+    ];
+
+    const result = packRectangles(rects);
+    expect(result.unpacked).toEqual([]);
+    expect(result.placements).toHaveLength(5);
+    for (let i = 0; i < result.placements.length; i++) {
+      for (let j = i + 1; j < result.placements.length; j++) {
+        expect(rectanglesOverlap(result.placements[i], result.placements[j])).toBe(false);
+      }
+    }
+  });
+
+  it('reports overflow ids in a fixed bin and keeps the placed rectangles non-overlapping', () => {
+    const rects: PackableRectangle[] = [];
+    for (let i = 0; i < 12; i++) {
+      rects.push({ id: i, width: 20, height: 20 });
+    }
+
+    const result = packRectangles(rects, { growable: false, maxWidth: 44, maxHeight: 44 });
+    expect(result.unpacked.length).toBeGreaterThan(0);
+    expect(result.placements.length + result.unpacked.length).toBe(12);
+    for (let i = 0; i < result.placements.length; i++) {
+      for (let j = i + 1; j < result.placements.length; j++) {
+        expect(rectanglesOverlap(result.placements[i], result.placements[j])).toBe(false);
+      }
+    }
+  });
+
+  it('respects padding between neighbors and border at the bin edge', () => {
+    const rects: PackableRectangle[] = [
+      { id: 'a', width: 10, height: 10 },
+      { id: 'b', width: 10, height: 10 },
+    ];
+
+    const result = packRectangles(rects, { padding: 2, border: 4 });
+    expect(result.unpacked).toEqual([]);
+
+    const a = result.placements.find((p) => p.id === 'a')!;
+    const b = result.placements.find((p) => p.id === 'b')!;
+    expect(a).toEqual({ id: 'a', x: 4, y: 4, width: 10, height: 10, rotated: false });
+    expect(b).toEqual({ id: 'b', x: 16, y: 4, width: 10, height: 10, rotated: false });
+
+    // Gap between the two neighbors is exactly the padding.
+    expect(b.x - (a.x + a.width)).toBe(2);
+    // Every placement is at least `border` from every bin edge.
+    for (const placement of result.placements) {
+      expect(placement.x).toBeGreaterThanOrEqual(4);
+      expect(placement.y).toBeGreaterThanOrEqual(4);
+      expect(placement.x + placement.width).toBeLessThanOrEqual(result.width - 4);
+      expect(placement.y + placement.height).toBeLessThanOrEqual(result.height - 4);
+    }
+  });
+
+  it('reports power-of-two and square extents that still contain every placement', () => {
+    const rects: PackableRectangle[] = [
+      { id: 'a', width: 30, height: 20 },
+      { id: 'b', width: 17, height: 41 },
+      { id: 'c', width: 25, height: 9 },
+    ];
+
+    const result = packRectangles(rects, { powerOfTwo: true, square: true });
+    expect(isPowerOfTwo(result.width)).toBe(true);
+    expect(isPowerOfTwo(result.height)).toBe(true);
+    expect(result.width).toBe(result.height);
+
+    for (const placement of result.placements) {
+      expect(placement.x + placement.width).toBeLessThanOrEqual(result.width);
+      expect(placement.y + placement.height).toBeLessThanOrEqual(result.height);
+    }
+  });
+
+  it('rotates a rectangle when rotation is required to fit a fixed bin', () => {
+    const rects: PackableRectangle[] = [{ id: 'tall', width: 8, height: 20 }];
+    const options = { growable: false as const, maxWidth: 20, maxHeight: 8 };
+
+    const withRotation = packRectangles(rects, { ...options, allowRotation: true });
+    expect(withRotation.unpacked).toEqual([]);
+    expect(withRotation.placements).toHaveLength(1);
+    const placed = withRotation.placements[0];
+    expect(placed.rotated).toBe(true);
+    expect(placed.width).toBe(20);
+    expect(placed.height).toBe(8);
+
+    const withoutRotation = packRectangles(rects, { ...options, allowRotation: false });
+    expect(withoutRotation.placements).toEqual([]);
+    expect(withoutRotation.unpacked).toEqual(['tall']);
+  });
+
+  it('grows to fit a rectangle that would need rotation in a fixed bin', () => {
+    const rects: PackableRectangle[] = [{ id: 'tall', width: 8, height: 20 }];
+    const result = packRectangles(rects, { allowRotation: false });
+    expect(result.unpacked).toEqual([]);
+    expect(result.placements[0].rotated).toBe(false);
+    expect(result.placements[0].width).toBe(8);
+    expect(result.placements[0].height).toBe(20);
+  });
+
+  it('produces a deep-equal result for the same input packed twice', () => {
+    const rects: PackableRectangle[] = [];
+    for (let i = 0; i < 15; i++) {
+      rects.push({ id: `r${i}`, width: 5 + ((i * 11) % 30), height: 5 + ((i * 17) % 28) });
+    }
+    const options = { padding: 1, border: 3, allowRotation: true };
+
+    const first = packRectangles(rects, options);
+    const second = packRectangles(rects, options);
+    expect(second).toEqual(first);
+  });
+
+  it('returns an empty result with a zero-size bin for empty input', () => {
+    const result = packRectangles([]);
+    expect(result).toEqual({ placements: [], width: 0, height: 0, unpacked: [] });
+  });
+
+  it('packs a single rectangle at the border corner', () => {
+    const result = packRectangles([{ id: 'only', width: 12, height: 7 }], { border: 3 });
+    expect(result.unpacked).toEqual([]);
+    expect(result.placements).toEqual([{ id: 'only', x: 3, y: 3, width: 12, height: 7, rotated: false }]);
+    expect(result.width).toBe(18);
+    expect(result.height).toBe(13);
+  });
+
+  it('reports a rectangle larger than a fixed bin as unpacked', () => {
+    const result = packRectangles([{ id: 'big', width: 500, height: 500 }], {
+      growable: false,
+      maxWidth: 64,
+      maxHeight: 64,
+    });
+    expect(result.placements).toEqual([]);
+    expect(result.unpacked).toEqual(['big']);
+  });
+
+  it('reports a rectangle larger than the growth cap as unpacked', () => {
+    const result = packRectangles([{ id: 'huge', width: 200, height: 10 }], { maxWidth: 64, maxHeight: 64 });
+    expect(result.unpacked).toEqual(['huge']);
+  });
+});
+
+function isPowerOfTwo(value: number): boolean {
+  return value > 0 && (value & (value - 1)) === 0;
+}
+
+function rectanglesOverlap(a: Readonly<PackedRectangle>, b: Readonly<PackedRectangle>): boolean {
+  return !(a.x + a.width <= b.x || b.x + b.width <= a.x || a.y + a.height <= b.y || b.y + b.height <= a.y);
+}