@react-x11/components 0.8.0 → 0.10.0

package/dist/maps/gl/placement.js

@@ -0,0 +1,642 @@
+import { resolveZoomed } from '../style.js';
+import { TILE_EXTENT } from './buckets.js';
+import { parseColor, premultiplied } from './color.js';
+import { LABEL_STRIDE, LEVEL_SNAP, LINE_MARGIN, LabelField, STRAIGHT_FRACTION, estimateWidth, } from '../anchors.js';
+import { fieldReach } from './text.js';
+import { DEFAULT_ICON_COLOR, DEFAULT_ICON_GLYPH_COLOR, DEFAULT_ICON_SIZE, ICON_GAP, isMapIcon, } from '../icons.js';
+/** Floats per label instance; the layout `renderer.ts` binds. */
+export const LABEL_INSTANCE = 19;
+/** Logical pixels between two labels, and the extra a newcomer needs. The
+ *  extra is the hysteresis: the label already shown wins a tie by it. */
+const PADDING = 4;
+const NEW_PADDING = 3;
+/** Logical pixels a label keeps from the view's edge. */
+const EDGE = 6;
+/** How long a label takes to appear or leave. */
+export const FADE_MS = 220;
+/** How near a new anchor must be, in label heights, to a shown label of
+ *  the same name to be that label — across a level change, say. */
+const MATCH = 2;
+/** The collision grid's cell, device pixels. */
+const CELL = 64;
+/**
+ * The frame's label state: what is shown, how visibly, and the collision
+ * index a pass builds.
+ */
+export class LabelPlacer {
+    _shown = new Set();
+    _style = null;
+    /** The last batch's time; null before the first, which advances no fade. */
+    _last = null;
+    _grid = new CollisionGrid();
+    _colors = new Map();
+    /** Estimated widths in ems, by text — a street name is asked about
+     *  once per anchor per frame. */
+    _ems = new Map();
+    _instances = new Float32Array(LABEL_INSTANCE * 64);
+    stats = { candidates: 0, placed: 0, drawn: 0, ms: 0 };
+    /** Labels still changing visibility: another frame is worth drawing. */
+    get animating() {
+        for (const shown of this._shown) {
+            if (shown.placed ? shown.opacity < 1 : shown.opacity > 0)
+                return true;
+        }
+        return false;
+    }
+    /** Forget everything shown — the style's layers are not the same ones. */
+    reset() {
+        this._shown.clear();
+    }
+    /**
+     * Choose the frame's labels. Asks `atlas` for each contender's box, as
+     * the frame's budget allows, and for each winner's field.
+     */
+    place(frame, atlas) {
+        const started = now();
+        const { width, height, scale, zoom, style } = frame;
+        if (style !== this._style) {
+            this._shown.clear();
+            this._style = style;
+        }
+        const layers = this._layersAt(style, zoom, scale);
+        const candidates = [];
+        const halfW = width / 2;
+        const halfH = height / 2;
+        // What is shown, first — at the ground it was placed on, for as long as
+        // the map still names it there: the tile under it must carry the name.
+        // A label is not its tile's (a level change keeps it), but it is the
+        // data's — a new source, a filter, a text field takes it off the map.
+        const named = (text, sx, sy) => {
+            let covered = false;
+            for (const tile of frame.tiles) {
+                const clip = tile.clip;
+                if (sx < clip.x ||
+                    sy < clip.y ||
+                    sx >= clip.x + clip.width ||
+                    sy >= clip.y + clip.height) {
+                    continue;
+                }
+                covered = true;
+                const data = tile.data.labels;
+                if (data && textsOf(data).has(text))
+                    return true;
+            }
+            // Nothing drawn there yet: no tile has said otherwise.
+            return !covered;
+        };
+        const byKey = new Map();
+        for (const shown of this._shown) {
+            const layer = layers[shown.layer];
+            if (!layer)
+                continue;
+            const list = byKey.get(shown.key);
+            if (list)
+                list.push(shown);
+            else
+                byKey.set(shown.key, [shown]);
+            if (!shown.placed)
+                continue;
+            let dx = shown.mx - frame.centerX;
+            dx -= Math.round(dx);
+            const sx = halfW + dx * frame.world;
+            const sy = halfH + (shown.my - frame.centerY) * frame.world;
+            if (!named(shown.text, sx, sy))
+                continue;
+            const c = this._candidate(shown.key, shown.text, shown.layer, layer, shown.priority, shown.point, sx, sy, shown.angle, shown.avail, shown.clear, shown.length, shown.dev, frame.world, frame);
+            if (c) {
+                c.shown = shown;
+                candidates.push(c);
+            }
+        }
+        // Every anchor the view's tiles offer — unless nothing new is admitted.
+        const offered = frame.admit === false ? [] : frame.tiles;
+        for (const tile of offered) {
+            const data = tile.data.labels;
+            if (!data || data.count === 0)
+                continue;
+            const ppu = tile.size / TILE_EXTENT;
+            const clip = tile.clip;
+            const a = data.anchors;
+            for (let i = 0; i < data.count; i++) {
+                const at = i * LABEL_STRIDE;
+                const index = a[at + LabelField.layer];
+                const layer = layers[index];
+                if (!layer)
+                    continue;
+                const sx = tile.x + a[at + LabelField.x] * ppu;
+                const sy = tile.y + a[at + LabelField.y] * ppu;
+                if (sx < clip.x ||
+                    sy < clip.y ||
+                    sx >= clip.x + clip.width ||
+                    sy >= clip.y + clip.height) {
+                    continue;
+                }
+                const text = data.texts[a[at + LabelField.text]];
+                const avail = a[at + LabelField.avail];
+                const c = this._candidate(`${layer.id}|${text}`, text, index, layer, a[at + LabelField.priority], avail < 0, sx, sy, a[at + LabelField.angle], avail, a[at + LabelField.clear], a[at + LabelField.length], a[at + LabelField.dev], ppu, frame);
+                if (c)
+                    candidates.push(c);
+            }
+        }
+        candidates.sort(compare);
+        // Greedy, in that order: a label is placed if it fits its street, is
+        // whole inside the view, is not a repeat of one just placed, and
+        // overlaps nothing placed before it.
+        const grid = this._grid;
+        grid.reset();
+        const placedAt = new Map();
+        const winners = [];
+        const inset = EDGE * scale;
+        for (const c of candidates) {
+            const repeatAt = placedAt.get(c.key);
+            if (repeatAt) {
+                const limit = c.repeat * c.repeat;
+                let near = false;
+                for (let r = 0; r < repeatAt.length; r += 2) {
+                    const dx = repeatAt[r] - c.sx;
+                    const dy = repeatAt[r + 1] - c.sy;
+                    if (dx * dx + dy * dy < limit) {
+                        near = true;
+                        break;
+                    }
+                }
+                if (near)
+                    continue;
+            }
+            const box = atlas.measure(c.text, c.size);
+            if (!box || box.width === 0)
+                continue;
+            let w = box.width;
+            let h = box.height;
+            if (!c.point) {
+                const need = w / 2 + h * LINE_MARGIN;
+                if (c.avail < (c.shown ? need * 0.9 : need))
+                    continue;
+            }
+            // An icon on the point and the name beside it are one box, placed
+            // and given way as one.
+            const icon = this._icon(layers[c.layer], c.point, atlas);
+            if (icon) {
+                const full = icon.size + icon.gap + w;
+                c.ox = (full - icon.size) / 2;
+                w = full;
+                h = Math.max(h, icon.size);
+            }
+            const bx = c.sx + c.ox;
+            const hw = (Math.abs(c.cos) * w + Math.abs(c.sin) * h) / 2;
+            const hh = (Math.abs(c.sin) * w + Math.abs(c.cos) * h) / 2;
+            if (bx - hw < inset ||
+                c.sy - hh < inset ||
+                bx + hw > width - inset ||
+                c.sy + hh > height - inset) {
+                continue;
+            }
+            const testPad = (PADDING / 2 + (c.shown ? 0 : NEW_PADDING)) * scale;
+            if (grid.hits(c, w, h, testPad))
+                continue;
+            grid.insert(c, w, h, (PADDING / 2) * scale);
+            winners.push({ c, width: w, height: h });
+            if (repeatAt)
+                repeatAt.push(c.sx, c.sy);
+            else
+                placedAt.set(c.key, [c.sx, c.sy]);
+        }
+        // What won becomes what is shown: the label it already was, one of the
+        // same name close by that is fading out, or a new one.
+        for (const shown of this._shown)
+            shown.placed = false;
+        for (const { c, height } of winners) {
+            let shown = c.shown;
+            if (!shown) {
+                const reach = MATCH * height;
+                for (const other of byKey.get(c.key) ?? []) {
+                    if (other.placed)
+                        continue;
+                    let dx = other.mx - c.mx;
+                    dx -= Math.round(dx);
+                    const dist = Math.hypot(dx, other.my - c.my) * frame.world;
+                    if (dist <= reach) {
+                        shown = other;
+                        break;
+                    }
+                }
+                if (!shown || shown.opacity <= 0) {
+                    // A label nobody can see moves to the anchor that won; one that
+                    // can be seen keeps its ground and is judged there next pass.
+                    const fresh = shown ??
+                        {
+                            key: c.key,
+                            text: c.text,
+                            layer: c.layer,
+                            size: c.size,
+                            opacity: 0,
+                            placed: false,
+                        };
+                    fresh.mx = c.mx;
+                    fresh.my = c.my;
+                    fresh.angle = c.angle;
+                    fresh.point = c.point;
+                    fresh.avail = c.rawAvail * c.toMercator;
+                    fresh.clear = c.rawClear * c.toMercator;
+                    fresh.length = c.rawLength * c.toMercator;
+                    fresh.dev = c.rawDev * c.toMercator;
+                    fresh.priority = c.priority;
+                    shown = fresh;
+                    this._shown.add(shown);
+                }
+            }
+            shown.placed = true;
+            shown.size = c.size;
+            atlas.entry(shown.text);
+            const icon = this._icon(layers[shown.layer], shown.point, atlas);
+            if (icon) {
+                atlas.icon(icon.name, 'plate');
+                atlas.icon(icon.name, 'glyph');
+            }
+        }
+        this.stats = {
+            candidates: candidates.length,
+            placed: winners.length,
+            drawn: this.stats.drawn,
+            ms: now() - started,
+        };
+    }
+    /**
+     * The frame's instances: every shown label at its ground's place on
+     * screen, faded by where it is in its fade. Advances the fades, and lets
+     * go of labels that have faded out.
+     */
+    batch(frame, atlas) {
+        const dt = this._last === null ? 0 : Math.max(0, frame.now - this._last);
+        this._last = frame.now;
+        const step = dt / FADE_MS;
+        const layers = this._layersAt(frame.style, frame.zoom, frame.scale);
+        // How far past its glyphs a field sees, in its own texels: the widest
+        // halo it can draw, times the label's scale.
+        const reach = fieldReach(atlas.pad);
+        const halfW = frame.width / 2;
+        const halfH = frame.height / 2;
+        let count = 0;
+        let labels = 0;
+        for (const shown of [...this._shown]) {
+            const layer = layers[shown.layer];
+            // One field for every size: a zoom ramp that grows the type draws the
+            // same raster larger, the frame it changes.
+            const entry = atlas.entry(shown.text);
+            // A name set beside an icon waits for the icon as well: the name
+            // alone is what the icon is there to explain.
+            const icon = this._icon(layer, shown.point, atlas);
+            const plate = icon ? atlas.icon(icon.name, 'plate') : null;
+            const glyph = icon ? atlas.icon(icon.name, 'glyph') : null;
+            const ready = entry !== null && (!icon || (plate !== null && glyph !== null));
+            // Nothing to show yet: wait at zero rather than fade in unseen.
+            if (ready && layer) {
+                shown.opacity = shown.placed
+                    ? Math.min(1, shown.opacity + step)
+                    : Math.max(0, shown.opacity - step);
+            }
+            else if (!shown.placed || !layer) {
+                shown.opacity = 0;
+            }
+            if (!shown.placed && shown.opacity <= 0) {
+                this._shown.delete(shown);
+                continue;
+            }
+            if (!ready || !entry || !layer || shown.opacity <= 0)
+                continue;
+            let dx = shown.mx - frame.centerX;
+            dx -= Math.round(dx);
+            const sx = halfW + dx * frame.world;
+            const sy = halfH + (shown.my - frame.centerY) * frame.world;
+            const eased = shown.opacity * shown.opacity * (3 - 2 * shown.opacity);
+            const ink = premultiplied(layer.ink, eased);
+            const halo = layer.halo ? premultiplied(layer.halo, eased) : ZERO;
+            const k = shown.size / atlas.base;
+            const haloPx = layer.halo ? Math.min(layer.haloPx, reach * k) : 0;
+            if (icon && plate && glyph) {
+                // The plate under its halo, the glyph on it, and the name level
+                // beside it: the string is its field less the margin, and its
+                // left edge goes the gap past the plate's right.
+                const ki = icon.size / atlas.base;
+                const plateHalo = layer.halo ? Math.min(layer.haloPx, reach * ki) : 0;
+                count = this._put(count, sx, sy, 0, plate, premultiplied(icon.plate, eased), halo, plateHalo, ki);
+                count = this._put(count, sx, sy, 0, glyph, premultiplied(icon.glyph, eased), ZERO, 0, ki);
+                const tx = sx +
+                    icon.size / 2 +
+                    icon.gap +
+                    ((entry.width - 2 * atlas.pad) * k) / 2;
+                count = this._put(count, tx, sy, 0, entry, ink, halo, haloPx, k);
+            }
+            else {
+                count = this._put(count, sx, sy, shown.angle, entry, ink, halo, haloPx, k);
+            }
+            labels++;
+        }
+        this.stats.drawn = labels;
+        return { atlas, instances: this._instances, count, labels };
+    }
+    /** One instance — a label's string, or a piece of its icon — written at
+     *  `count`: answers the count after it. Level (`angle` 0) is set on
+     *  whole pixels. */
+    _put(count, x, y, angle, entry, ink, halo, haloPx, scale) {
+        if (this._instances.length < (count + 1) * LABEL_INSTANCE) {
+            const grown = new Float32Array(this._instances.length * 2);
+            grown.set(this._instances);
+            this._instances = grown;
+        }
+        const d = this._instances;
+        const at = count * LABEL_INSTANCE;
+        const level = angle === 0;
+        d[at] = x;
+        d[at + 1] = y;
+        d[at + 2] = level ? 1 : Math.cos(angle);
+        d[at + 3] = level ? 0 : Math.sin(angle);
+        d[at + 4] = entry.x;
+        d[at + 5] = entry.y;
+        d[at + 6] = entry.width;
+        d[at + 7] = entry.height;
+        d[at + 8] = ink[0];
+        d[at + 9] = ink[1];
+        d[at + 10] = ink[2];
+        d[at + 11] = ink[3];
+        d[at + 12] = halo[0];
+        d[at + 13] = halo[1];
+        d[at + 14] = halo[2];
+        d[at + 15] = halo[3];
+        d[at + 16] = haloPx;
+        d[at + 17] = level ? 1 : 0;
+        d[at + 18] = scale;
+        return count + 1;
+    }
+    // --- internals -------------------------------------------------------------
+    /** One anchor as a contender, or null when it cannot be one at all at
+     *  this zoom — off the view, or on a run too bent or too short for even
+     *  a short name. `unit` is device pixels per unit of the lengths given. */
+    _candidate(key, text, index, layer, priority, point, sx, sy, angle, avail, clear, length, dev, unit, frame) {
+        if (sx < 0 || sy < 0 || sx >= frame.width || sy >= frame.height)
+            return null;
+        const size = layer.size;
+        let ems = this._ems.get(text);
+        if (ems === undefined) {
+            if (this._ems.size > 20000)
+                this._ems.clear();
+            ems = estimateWidth(text, 1);
+            this._ems.set(text, ems);
+        }
+        const estimate = ems * size;
+        if (!point) {
+            if (dev * unit > size * STRAIGHT_FRACTION)
+                return null;
+            // Well short of even an under-estimate of the name: no need to
+            // measure it to know.
+            if (avail * unit < estimate * 0.35)
+                return null;
+        }
+        const level = point || Math.abs(angle) < LEVEL_SNAP;
+        const a = level ? 0 : angle;
+        const clearPx = clear * unit;
+        const mx = frame.centerX + (sx - frame.width / 2) / frame.world;
+        const my = frame.centerY + (sy - frame.height / 2) / frame.world;
+        const cx = sx - frame.width / 2;
+        const cy = sy - frame.height / 2;
+        return {
+            key,
+            text,
+            layer: index,
+            rank: layer.rank,
+            priority,
+            size,
+            point,
+            sx,
+            sy,
+            ox: 0,
+            angle: a,
+            cos: Math.cos(a),
+            sin: Math.sin(a),
+            avail: point ? Infinity : avail * unit,
+            clear: clearPx,
+            length: length * unit,
+            toMercator: unit / frame.world,
+            rawAvail: avail,
+            rawClear: clear,
+            rawLength: length,
+            rawDev: dev,
+            mx,
+            my,
+            shown: null,
+            clean: point || clearPx >= estimate / 2 ? 1 : 0,
+            centre: cx * cx + cy * cy,
+            repeat: layer.repeat,
+        };
+    }
+    /** The icon a label of `layer` is set with: none for a name along a
+     *  street, and none where the atlas cannot draw it — the name is then set
+     *  alone rather than not at all. */
+    _icon(layer, point, atlas) {
+        const icon = point ? (layer?.icon ?? null) : null;
+        return icon && !atlas.iconFailed(icon.name) ? icon : null;
+    }
+    /** Each symbol layer's labelling at this zoom, by layer index — null
+     *  where it does not label. */
+    _layersAt(style, zoom, scale) {
+        return style.layers.map(({ layer }) => {
+            if (layer.type !== 'symbol' || layer.visible === false)
+                return null;
+            if (layer.minZoom !== undefined && zoom < layer.minZoom)
+                return null;
+            if (layer.maxZoom !== undefined && zoom >= layer.maxZoom)
+                return null;
+            const symbol = layer;
+            const ink = this._color(symbol.textColor ? resolveZoomed(symbol.textColor, zoom) : '#000000');
+            if (!ink)
+                return null;
+            const halo = symbol.textHaloColor
+                ? this._color(resolveZoomed(symbol.textHaloColor, zoom))
+                : null;
+            const haloWidth = symbol.textHaloWidth === undefined
+                ? 1
+                : resolveZoomed(symbol.textHaloWidth, zoom);
+            // Not rounded: a field draws any size, so a ramp grows the type
+            // continuously rather than a whole pixel at a time.
+            const size = Math.max(1, (symbol.textSize === undefined
+                ? 12
+                : resolveZoomed(symbol.textSize, zoom)) * scale);
+            return {
+                id: layer.id,
+                rank: symbol.rank ?? 0,
+                size,
+                repeat: (symbol.repeatDistance ?? 250) * scale,
+                ink,
+                halo: halo && haloWidth > 0 ? halo : null,
+                haloPx: haloWidth * scale,
+                icon: this._iconOf(symbol, zoom, scale),
+            };
+        });
+    }
+    /** A layer's icon at this zoom, or null where it sets none — or names
+     *  one this version does not draw, or a colour that does not parse. */
+    _iconOf(symbol, zoom, scale) {
+        if (!isMapIcon(symbol.icon))
+            return null;
+        const plate = this._color(symbol.iconColor
+            ? resolveZoomed(symbol.iconColor, zoom)
+            : DEFAULT_ICON_COLOR);
+        const glyph = this._color(symbol.iconGlyphColor
+            ? resolveZoomed(symbol.iconGlyphColor, zoom)
+            : DEFAULT_ICON_GLYPH_COLOR);
+        if (!plate || !glyph)
+            return null;
+        const size = symbol.iconSize === undefined
+            ? DEFAULT_ICON_SIZE
+            : resolveZoomed(symbol.iconSize, zoom);
+        return {
+            name: symbol.icon,
+            size: Math.max(1, Math.round(size * scale)),
+            gap: ICON_GAP * scale,
+            plate,
+            glyph,
+        };
+    }
+    _color(value) {
+        let color = this._colors.get(value);
+        if (color === undefined) {
+            color = parseColor(value);
+            this._colors.set(value, color);
+        }
+        return color;
+    }
+}
+const ZERO = [0, 0, 0, 0];
+/** Every name a tile's label layers carry, made once per tile. */
+const texts = new WeakMap();
+function textsOf(data) {
+    let set = texts.get(data);
+    if (!set) {
+        set = new Set(data.texts);
+        texts.set(data, set);
+    }
+    return set;
+}
+function compare(a, b) {
+    return (b.rank - a.rank ||
+        b.priority - a.priority ||
+        (b.shown ? 1 : 0) - (a.shown ? 1 : 0) ||
+        b.clean - a.clean ||
+        b.length - a.length ||
+        a.centre - b.centre ||
+        (a.key < b.key ? -1 : a.key > b.key ? 1 : 0) ||
+        a.sx - b.sx ||
+        a.sy - b.sy);
+}
+/**
+ * Collision shapes over a grid of cells. A level label is its box; a
+ * rotated one is a chain of circles along its baseline, each as tall as
+ * the text — which follows a slanted name closely where its box would
+ * claim the whole corner-to-corner rectangle around it.
+ */
+class CollisionGrid {
+    /** Five numbers per shape: kind (0 box, 1 circle), then x0, y0, x1, y1
+     *  or cx, cy, r, 0. */
+    _shapes = [];
+    _cells = new Map();
+    _scratch = [];
+    reset() {
+        this._shapes.length = 0;
+        this._cells.clear();
+    }
+    hits(c, w, h, pad) {
+        const shapes = this._shapesOf(c, w, h, pad);
+        for (let s = 0; s < shapes.length; s += 5) {
+            const [x0, y0, x1, y1] = bounds(shapes, s);
+            for (let gx = cell(x0); gx <= cell(x1); gx++) {
+                for (let gy = cell(y0); gy <= cell(y1); gy++) {
+                    const list = this._cells.get(cellKey(gx, gy));
+                    if (!list)
+                        continue;
+                    for (const other of list) {
+                        if (overlaps(shapes, s, this._shapes, other))
+                            return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    insert(c, w, h, pad) {
+        const shapes = this._shapesOf(c, w, h, pad);
+        for (let s = 0; s < shapes.length; s += 5) {
+            const index = this._shapes.length;
+            for (let k = 0; k < 5; k++)
+                this._shapes.push(shapes[s + k]);
+            const [x0, y0, x1, y1] = bounds(shapes, s);
+            for (let gx = cell(x0); gx <= cell(x1); gx++) {
+                for (let gy = cell(y0); gy <= cell(y1); gy++) {
+                    const key = cellKey(gx, gy);
+                    const list = this._cells.get(key);
+                    if (list)
+                        list.push(index);
+                    else
+                        this._cells.set(key, [index]);
+                }
+            }
+        }
+    }
+    _shapesOf(c, w, h, pad) {
+        const out = this._scratch;
+        out.length = 0;
+        if (c.angle === 0) {
+            const x = c.sx + c.ox;
+            out.push(0, x - w / 2 - pad, c.sy - h / 2 - pad, x + w / 2 + pad, c.sy + h / 2 + pad);
+            return out;
+        }
+        const r = h / 2 + pad;
+        const span = Math.max(0, w - h);
+        const n = span > 0 ? Math.ceil(span / r) + 1 : 1;
+        for (let i = 0; i < n; i++) {
+            const t = n === 1 ? 0 : -span / 2 + (span * i) / (n - 1);
+            out.push(1, c.sx + c.cos * t, c.sy + c.sin * t, r, 0);
+        }
+        return out;
+    }
+}
+function bounds(shapes, s) {
+    if (shapes[s] === 0)
+        return [shapes[s + 1], shapes[s + 2], shapes[s + 3], shapes[s + 4]];
+    const r = shapes[s + 3];
+    return [
+        shapes[s + 1] - r,
+        shapes[s + 2] - r,
+        shapes[s + 1] + r,
+        shapes[s + 2] + r,
+    ];
+}
+function overlaps(a, i, b, j) {
+    const ka = a[i];
+    const kb = b[j];
+    if (ka === 0 && kb === 0) {
+        return (a[i + 1] < b[j + 3] &&
+            a[i + 3] > b[j + 1] &&
+            a[i + 2] < b[j + 4] &&
+            a[i + 4] > b[j + 2]);
+    }
+    if (ka === 1 && kb === 1) {
+        const dx = a[i + 1] - b[j + 1];
+        const dy = a[i + 2] - b[j + 2];
+        const r = a[i + 3] + b[j + 3];
+        return dx * dx + dy * dy < r * r;
+    }
+    const [box, bi, circle, ci] = ka === 0 ? [a, i, b, j] : [b, j, a, i];
+    const cx = circle[ci + 1];
+    const cy = circle[ci + 2];
+    const r = circle[ci + 3];
+    const nx = Math.max(box[bi + 1], Math.min(cx, box[bi + 3]));
+    const ny = Math.max(box[bi + 2], Math.min(cy, box[bi + 4]));
+    const dx = cx - nx;
+    const dy = cy - ny;
+    return dx * dx + dy * dy < r * r;
+}
+const cell = (v) => Math.floor(v / CELL);
+const cellKey = (gx, gy) => (gx + 4096) * 16384 + (gy + 4096);
+const globals = globalThis;
+const now = () => globals.performance?.now() ?? Date.now();
+//# sourceMappingURL=placement.js.map