@oh-just-another/scene 0.57.0

package/dist/snap.d.ts

@@ -0,0 +1,88 @@
+import type { Vec2 } from "@oh-just-another/types";
+import type { Scene } from "./scene.js";
+/**
+ * One snap target a contributor can offer for a probe point. `snapped` is
+ * the world-space position the probe should jump to; `kind` and `metadata`
+ * help downstream consumers (renderers, edge-endpoint builders) decide what
+ * to do with the snap.
+ */
+export interface SnapCandidate {
+    readonly snapped: Vec2;
+    /** Squared distance from probe to `snapped`. Smaller wins. */
+    readonly distance: number;
+    /** What kind of snap this is. Hosts use it to decide downstream. */
+    readonly kind: "grid" | "anchor" | "outline" | "guideline";
+    /** Optional payload — anchor ref, outline ratio, alignment line, etc. */
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Per-call context handed to every contributor. Includes the probe point,
+ * the active scene, an optional set of shape ids to exclude from snap (e.g.
+ * the shape currently being dragged), and the snap threshold in world units.
+ */
+export interface SnapContext {
+    readonly scene: Scene;
+    readonly probe: Vec2;
+    readonly threshold: number;
+    readonly excludeElementIds?: ReadonlySet<string>;
+    /**
+     * What kind of gesture is asking for snap. Contributors can filter
+     * themselves out by gesture (e.g. anchor snap only applies during edge
+     * draw, not when dragging a shape).
+     */
+    readonly gesture: "draw-edge" | "edit-edge-endpoint" | "move-shape" | "draw-shape";
+}
+/**
+ * A snap source. Plugins implement this to add a new snap rule (e.g. snap
+ * to ruler lines, page margins, ...). Built-ins: grid, anchor, outline,
+ * guideline.
+ *
+ * Contributors return zero or more candidates. The engine keeps the best
+ * (closest within threshold) per `kind` and exposes them all so renderers
+ * can paint guides for each.
+ */
+export interface SnapContributor {
+    readonly id: string;
+    contribute(ctx: SnapContext): readonly SnapCandidate[];
+}
+/**
+ * Combines contributors. Stateless — instance is a thin container.
+ *
+ * ```ts
+ * const engine = new SnapEngine([gridSnapper, anchorSnapper, outlineSnapper]);
+ * const result = engine.snap({ scene, probe, threshold: 8, gesture: "draw-edge" });
+ * if (result.best) editor.useSnap(result.best);
+ * ```
+ */
+export declare class SnapEngine {
+    private readonly contributors;
+    constructor(contributors: readonly SnapContributor[]);
+    /**
+     * Run every contributor, collect their candidates within `threshold`,
+     * and return them sorted by distance. `best` is the closest overall.
+     */
+    snap(ctx: SnapContext): {
+        readonly best: SnapCandidate | null;
+        readonly all: readonly SnapCandidate[];
+    };
+}
+/**
+ * Snap the probe to the nearest grid intersection. No-op when the scene
+ * viewport has no `gridSize`.
+ */
+export declare const gridSnapper: SnapContributor;
+/**
+ * Snap edge endpoints to the nearest port on the shape under the probe.
+ * Only contributes for edge-related gestures.
+ */
+export declare const anchorSnapper: SnapContributor;
+/**
+ * Snap edge endpoints to the nearest point on a shape's outline. Useful
+ * as a fallback when the user wants the connector "on this edge" rather
+ * than at one of the 9 named ports. Combines well with `anchorSnapper`:
+ * since anchors live on the same bounding rectangle, the anchor snap
+ * usually wins when the pointer is close to a corner / midpoint, and
+ * outline snap takes over for arbitrary positions in between.
+ */
+export declare const outlineSnapper: SnapContributor;
+//# sourceMappingURL=snap.d.ts.map

package/dist/snap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snap.d.ts","sourceRoot":"","sources":["../src/snap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAGnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAKxC;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;IACvB,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,CAAC;IAC3D,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACvD;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACjD;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,oBAAoB,GAAG,YAAY,GAAG,YAAY,CAAC;CACpF;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,GAAG,EAAE,WAAW,GAAG,SAAS,aAAa,EAAE,CAAC;CACxD;AAED;;;;;;;;GAQG;AACH,qBAAa,UAAU;IACT,OAAO,CAAC,QAAQ,CAAC,YAAY;gBAAZ,YAAY,EAAE,SAAS,eAAe,EAAE;IAErE;;;OAGG;IACH,IAAI,CAAC,GAAG,EAAE,WAAW,GAAG;QACtB,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,CAAC;QACpC,QAAQ,CAAC,GAAG,EAAE,SAAS,aAAa,EAAE,CAAC;KACxC;CAUF;AAID;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,eAazB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,eAqB3B,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,EAAE,eAqB5B,CAAC"}

package/dist/snap.js

@@ -0,0 +1,128 @@
+import { findNearestOutlinePoint } from "./outline.js";
+import { findNearestAnchor, snapExcludedAnchors } from "./anchors.js";
+import { SNAP_PROBE_CULL_RADIUS } from "./constants.js";
+/**
+ * Combines contributors. Stateless — instance is a thin container.
+ *
+ * ```ts
+ * const engine = new SnapEngine([gridSnapper, anchorSnapper, outlineSnapper]);
+ * const result = engine.snap({ scene, probe, threshold: 8, gesture: "draw-edge" });
+ * if (result.best) editor.useSnap(result.best);
+ * ```
+ */
+export class SnapEngine {
+    contributors;
+    constructor(contributors) {
+        this.contributors = contributors;
+    }
+    /**
+     * Run every contributor, collect their candidates within `threshold`,
+     * and return them sorted by distance. `best` is the closest overall.
+     */
+    snap(ctx) {
+        const candidates = [];
+        for (const c of this.contributors) {
+            for (const cand of c.contribute(ctx)) {
+                if (cand.distance <= ctx.threshold * ctx.threshold)
+                    candidates.push(cand);
+            }
+        }
+        candidates.sort((a, b) => a.distance - b.distance);
+        return { best: candidates[0] ?? null, all: candidates };
+    }
+}
+// --- Built-in contributors ---
+/**
+ * Snap the probe to the nearest grid intersection. No-op when the scene
+ * viewport has no `gridSize`.
+ */
+export const gridSnapper = {
+    id: "grid",
+    contribute(ctx) {
+        const size = ctx.scene.viewport.gridSize;
+        if (!size || size <= 0)
+            return [];
+        const snapped = {
+            x: Math.round(ctx.probe.x / size) * size,
+            y: Math.round(ctx.probe.y / size) * size,
+        };
+        const dx = snapped.x - ctx.probe.x;
+        const dy = snapped.y - ctx.probe.y;
+        return [{ snapped, distance: dx * dx + dy * dy, kind: "grid" }];
+    },
+};
+/**
+ * Snap edge endpoints to the nearest port on the shape under the probe.
+ * Only contributes for edge-related gestures.
+ */
+export const anchorSnapper = {
+    id: "anchor",
+    contribute(ctx) {
+        if (ctx.gesture !== "draw-edge" && ctx.gesture !== "edit-edge-endpoint")
+            return [];
+        const out = [];
+        for (const shape of ctx.scene.elements.values()) {
+            if (ctx.excludeElementIds?.has(shape.id))
+                continue;
+            // Cheap reject: skip shapes whose AABB is far from the probe.
+            if (!isProbeNearElement(shape, ctx.probe, ctx.threshold))
+                continue;
+            const nearest = findNearestAnchor(shape, ctx.probe, snapExcludedAnchors(shape));
+            const dx = nearest.world.x - ctx.probe.x;
+            const dy = nearest.world.y - ctx.probe.y;
+            out.push({
+                snapped: nearest.world,
+                distance: dx * dx + dy * dy,
+                kind: "anchor",
+                metadata: { elementId: shape.id, ref: nearest.ref },
+            });
+        }
+        return out;
+    },
+};
+/**
+ * Snap edge endpoints to the nearest point on a shape's outline. Useful
+ * as a fallback when the user wants the connector "on this edge" rather
+ * than at one of the 9 named ports. Combines well with `anchorSnapper`:
+ * since anchors live on the same bounding rectangle, the anchor snap
+ * usually wins when the pointer is close to a corner / midpoint, and
+ * outline snap takes over for arbitrary positions in between.
+ */
+export const outlineSnapper = {
+    id: "outline",
+    contribute(ctx) {
+        if (ctx.gesture !== "draw-edge" && ctx.gesture !== "edit-edge-endpoint")
+            return [];
+        const out = [];
+        for (const shape of ctx.scene.elements.values()) {
+            if (ctx.excludeElementIds?.has(shape.id))
+                continue;
+            if (!isProbeNearElement(shape, ctx.probe, ctx.threshold))
+                continue;
+            const nearest = findNearestOutlinePoint(shape, ctx.probe);
+            if (!nearest)
+                continue;
+            const dx = nearest.world.x - ctx.probe.x;
+            const dy = nearest.world.y - ctx.probe.y;
+            out.push({
+                snapped: nearest.world,
+                distance: dx * dx + dy * dy,
+                kind: "outline",
+                metadata: { elementId: shape.id, ratio: nearest.ratio },
+            });
+        }
+        return out;
+    },
+};
+const isProbeNearElement = (shape, probe, threshold) => {
+    // Cheap AABB-around-position test. Hosts can register more precise
+    // contributors if their shape types deserve it.
+    const cushion = threshold;
+    const px = probe.x - shape.position.x;
+    const py = probe.y - shape.position.y;
+    // `SNAP_PROBE_CULL_RADIUS` is intentionally generous; the inner
+    // `findNearestAnchor` does the precise check.
+    return (Math.abs(px) <= SNAP_PROBE_CULL_RADIUS + cushion &&
+        Math.abs(py) <= SNAP_PROBE_CULL_RADIUS + cushion);
+};
+//# sourceMappingURL=snap.js.map

package/dist/snap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snap.js","sourceRoot":"","sources":["../src/snap.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAGvD,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAkDxD;;;;;;;;GAQG;AACH,MAAM,OAAO,UAAU;IACQ;IAA7B,YAA6B,YAAwC;QAAxC,iBAAY,GAAZ,YAAY,CAA4B;IAAG,CAAC;IAEzE;;;OAGG;IACH,IAAI,CAAC,GAAgB;QAInB,MAAM,UAAU,GAAoB,EAAE,CAAC;QACvC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YAClC,KAAK,MAAM,IAAI,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;gBACrC,IAAI,IAAI,CAAC,QAAQ,IAAI,GAAG,CAAC,SAAS,GAAG,GAAG,CAAC,SAAS;oBAAE,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC5E,CAAC;QACH,CAAC;QACD,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC;QACnD,OAAO,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,GAAG,EAAE,UAAU,EAAE,CAAC;IAC1D,CAAC;CACF;AAED,gCAAgC;AAEhC;;;GAGG;AACH,MAAM,CAAC,MAAM,WAAW,GAAoB;IAC1C,EAAE,EAAE,MAAM;IACV,UAAU,CAAC,GAAG;QACZ,MAAM,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC;QACzC,IAAI,CAAC,IAAI,IAAI,IAAI,IAAI,CAAC;YAAE,OAAO,EAAE,CAAC;QAClC,MAAM,OAAO,GAAS;YACpB,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,IAAI;YACxC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,IAAI;SACzC,CAAC;QACF,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;QACnC,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;QACnC,OAAO,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;IAClE,CAAC;CACF,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,aAAa,GAAoB;IAC5C,EAAE,EAAE,QAAQ;IACZ,UAAU,CAAC,GAAG;QACZ,IAAI,GAAG,CAAC,OAAO,KAAK,WAAW,IAAI,GAAG,CAAC,OAAO,KAAK,oBAAoB;YAAE,OAAO,EAAE,CAAC;QACnF,MAAM,GAAG,GAAoB,EAAE,CAAC;QAChC,KAAK,MAAM,KAAK,IAAI,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;YAChD,IAAI,GAAG,CAAC,iBAAiB,EAAE,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;gBAAE,SAAS;YACnD,8DAA8D;YAC9D,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,SAAS,CAAC;gBAAE,SAAS;YACnE,MAAM,OAAO,GAAG,iBAAiB,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,mBAAmB,CAAC,KAAK,CAAC,CAAC,CAAC;YAChF,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YACzC,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YACzC,GAAG,CAAC,IAAI,CAAC;gBACP,OAAO,EAAE,OAAO,CAAC,KAAK;gBACtB,QAAQ,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE;gBAC3B,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,EAAE,GAAG,EAAE,OAAO,CAAC,GAAuB,EAAE;aACxE,CAAC,CAAC;QACL,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;CACF,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,cAAc,GAAoB;IAC7C,EAAE,EAAE,SAAS;IACb,UAAU,CAAC,GAAG;QACZ,IAAI,GAAG,CAAC,OAAO,KAAK,WAAW,IAAI,GAAG,CAAC,OAAO,KAAK,oBAAoB;YAAE,OAAO,EAAE,CAAC;QACnF,MAAM,GAAG,GAAoB,EAAE,CAAC;QAChC,KAAK,MAAM,KAAK,IAAI,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;YAChD,IAAI,GAAG,CAAC,iBAAiB,EAAE,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;gBAAE,SAAS;YACnD,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,SAAS,CAAC;gBAAE,SAAS;YACnE,MAAM,OAAO,GAAG,uBAAuB,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;YAC1D,IAAI,CAAC,OAAO;gBAAE,SAAS;YACvB,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YACzC,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YACzC,GAAG,CAAC,IAAI,CAAC;gBACP,OAAO,EAAE,OAAO,CAAC,KAAK;gBACtB,QAAQ,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE;gBAC3B,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE;aACxD,CAAC,CAAC;QACL,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;CACF,CAAC;AAEF,MAAM,kBAAkB,GAAG,CAAC,KAAkB,EAAE,KAAW,EAAE,SAAiB,EAAW,EAAE;IACzF,mEAAmE;IACnE,gDAAgD;IAChD,MAAM,OAAO,GAAG,SAAS,CAAC;IAC1B,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;IACtC,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;IACtC,gEAAgE;IAChE,8CAA8C;IAC9C,OAAO,CACL,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,sBAAsB,GAAG,OAAO;QAChD,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,sBAAsB,GAAG,OAAO,CACjD,CAAC;AACJ,CAAC,CAAC"}

package/dist/spatial.d.ts

@@ -0,0 +1,38 @@
+import type { Bounds, ElementId } from "@oh-just-another/types";
+/**
+ * Uniform-cell spatial index over shape world-AABBs.
+ *
+ * Cells are addressed by `(cellX, cellY) = (floor(x / cellSize), floor(y / cellSize))`,
+ * and a shape's AABB is registered in every cell it overlaps. Range queries
+ * iterate the overlapping cells and collect candidates; the caller filters
+ * against the precise AABB.
+ *
+ * Trade-off vs an R-tree: a grid is simpler, has predictable memory, and is
+ * very fast for editor-scale scenes (≤ ~10k shapes) where cell count is small
+ * and shapes are roughly uniform in size.
+ */
+export declare class SpatialGrid {
+    /** Cell side length in world units. */
+    readonly cellSize: number;
+    /** `cellKey(cellX, cellY)` → set of shape ids overlapping the cell. */
+    private readonly cells;
+    /** Reverse index: shape id → cached AABB, used on remove/update. */
+    private readonly bounds;
+    constructor(cellSize?: number);
+    /** Number of indexed shapes. */
+    get size(): number;
+    insert(id: ElementId, b: Bounds): void;
+    remove(id: ElementId): void;
+    update(id: ElementId, b: Bounds): void;
+    /**
+     * Ids whose AABB overlaps `range`. The returned set is a superset of the
+     * true answer — the caller must filter against precise bounds. Order is
+     * arbitrary.
+     */
+    query(range: Bounds): ReadonlySet<ElementId>;
+    /** Drop all entries. */
+    clear(): void;
+    /** Iterate cell keys that overlap `b`. */
+    private eachCell;
+}
+//# sourceMappingURL=spatial.d.ts.map

package/dist/spatial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spatial.d.ts","sourceRoot":"","sources":["../src/spatial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;;;;;;;;GAWG;AACH,qBAAa,WAAW;IACtB,uCAAuC;IACvC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,uEAAuE;IACvE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAE3D,oEAAoE;IACpE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;gBAE3C,QAAQ,SAAM;IAK1B,gCAAgC;IAChC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,MAAM,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAetC,MAAM,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI;IAY3B,MAAM,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAKtC;;;;OAIG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC,SAAS,CAAC;IAU5C,wBAAwB;IACxB,KAAK,IAAI,IAAI;IAKb,0CAA0C;IAC1C,OAAO,CAAC,QAAQ;CAWjB"}

package/dist/spatial.js

@@ -0,0 +1,95 @@
+/**
+ * Uniform-cell spatial index over shape world-AABBs.
+ *
+ * Cells are addressed by `(cellX, cellY) = (floor(x / cellSize), floor(y / cellSize))`,
+ * and a shape's AABB is registered in every cell it overlaps. Range queries
+ * iterate the overlapping cells and collect candidates; the caller filters
+ * against the precise AABB.
+ *
+ * Trade-off vs an R-tree: a grid is simpler, has predictable memory, and is
+ * very fast for editor-scale scenes (≤ ~10k shapes) where cell count is small
+ * and shapes are roughly uniform in size.
+ */
+export class SpatialGrid {
+    /** Cell side length in world units. */
+    cellSize;
+    /** `cellKey(cellX, cellY)` → set of shape ids overlapping the cell. */
+    cells = new Map();
+    /** Reverse index: shape id → cached AABB, used on remove/update. */
+    bounds = new Map();
+    constructor(cellSize = 256) {
+        if (cellSize <= 0)
+            throw new Error("cellSize must be positive");
+        this.cellSize = cellSize;
+    }
+    /** Number of indexed shapes. */
+    get size() {
+        return this.bounds.size;
+    }
+    insert(id, b) {
+        if (this.bounds.has(id)) {
+            throw new Error(`Element already indexed: ${id}`);
+        }
+        this.bounds.set(id, b);
+        this.eachCell(b, (key) => {
+            let cell = this.cells.get(key);
+            if (!cell) {
+                cell = new Set();
+                this.cells.set(key, cell);
+            }
+            cell.add(id);
+        });
+    }
+    remove(id) {
+        const b = this.bounds.get(id);
+        if (!b)
+            return;
+        this.bounds.delete(id);
+        this.eachCell(b, (key) => {
+            const cell = this.cells.get(key);
+            if (!cell)
+                return;
+            cell.delete(id);
+            if (cell.size === 0)
+                this.cells.delete(key);
+        });
+    }
+    update(id, b) {
+        this.remove(id);
+        this.insert(id, b);
+    }
+    /**
+     * Ids whose AABB overlaps `range`. The returned set is a superset of the
+     * true answer — the caller must filter against precise bounds. Order is
+     * arbitrary.
+     */
+    query(range) {
+        const out = new Set();
+        this.eachCell(range, (key) => {
+            const cell = this.cells.get(key);
+            if (!cell)
+                return;
+            for (const id of cell)
+                out.add(id);
+        });
+        return out;
+    }
+    /** Drop all entries. */
+    clear() {
+        this.cells.clear();
+        this.bounds.clear();
+    }
+    /** Iterate cell keys that overlap `b`. */
+    eachCell(b, fn) {
+        const minCx = Math.floor(b.x / this.cellSize);
+        const minCy = Math.floor(b.y / this.cellSize);
+        const maxCx = Math.floor((b.x + b.width) / this.cellSize);
+        const maxCy = Math.floor((b.y + b.height) / this.cellSize);
+        for (let cy = minCy; cy <= maxCy; cy++) {
+            for (let cx = minCx; cx <= maxCx; cx++) {
+                fn(`${cx},${cy}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=spatial.js.map

package/dist/spatial.js.map

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

package/dist/style.d.ts

@@ -0,0 +1,87 @@
+import type { Color } from "@oh-just-another/types";
+export type LineCap = "butt" | "round" | "square";
+export type LineJoin = "miter" | "round" | "bevel";
+/**
+ * Where the stroke sits relative to the shape's path.
+ *   `center`  — half the stroke width inside the path, half outside.
+ *               Canvas2D / SVG default.
+ *   `inside`  — stroke is fully inside the path (path = outer edge).
+ *               Useful when shape bounds must match the fill region
+ *               exactly (auto-layout / hit-tests).
+ *   `outside` — stroke is fully outside (path = inner edge).
+ */
+export type StrokeAlign = "center" | "inside" | "outside";
+/**
+ * Corner-rounding spec for shapes that support it (rectangle, container,
+ * box arrow, …). Borrowed from standard's adaptive model:
+ *   `sharp`  — no rounding (sharp corners). Equivalent to omitting the
+ *              field; kept for explicit serialisation.
+ *   `round`  — rounded corners. Without `value`, falls back to the
+ *              adaptive radius (fixed 32 px for big shapes, scales to
+ *              25 % of the smaller side for shapes < 128 px so they
+ *              don't read as a capsule).
+ */
+export interface Roundness {
+    readonly type: "sharp" | "round";
+    /**
+     * Override the rounded-corner radius in world units. Ignored when
+     * `type === "sharp"`. When omitted on `round` shapes the renderer
+     * applies the adaptive default (see {@link Style}).
+     */
+    readonly value?: number;
+}
+/**
+ * Visual style for shapes and edges. Every field is optional so that scenes,
+ * patches and partial updates stay compact; renderers fall back to library
+ * defaults when a field is omitted.
+ */
+export interface Style {
+    readonly fill?: Color;
+    readonly stroke?: Color;
+    readonly strokeWidth?: number;
+    readonly opacity?: number;
+    readonly dashArray?: readonly number[];
+    readonly lineCap?: LineCap;
+    readonly lineJoin?: LineJoin;
+    /** Stroke alignment relative to the path. Defaults to `center`. */
+    readonly strokeAlign?: StrokeAlign;
+    /** Corner-rounding spec. Omitted = sharp corners. */
+    readonly roundness?: Roundness;
+}
+export type TextAlign = "left" | "center" | "right";
+export type TextBaseline = "top" | "middle" | "bottom";
+export type FontWeight = "normal" | "bold";
+export type FontStyle = "normal" | "italic";
+/**
+ * Text decorations (underline / strikethrough). Both can be on at once.
+ * Rendered as thin line-rects under / through the text by the renderer,
+ * so they work identically on Canvas2D and WebGL2.
+ */
+export interface TextDecoration {
+    readonly underline?: boolean;
+    readonly strikethrough?: boolean;
+}
+/**
+ * Text-specific style overlay. Inherits all `Style` fields (fill = text color,
+ * stroke = outline). Layout metrics live on the `TextElement` itself, not here.
+ */
+export interface TextStyle extends Style {
+    readonly textAlign?: TextAlign;
+    readonly textBaseline?: TextBaseline;
+    /** Bold toggle. Default `"normal"`. */
+    readonly fontWeight?: FontWeight;
+    /** Italic toggle. Default `"normal"`. */
+    readonly fontStyle?: FontStyle;
+    /** Underline / strikethrough. Omitted = neither. */
+    readonly textDecoration?: TextDecoration;
+}
+/**
+ * How far a shape's stroke extends OUTSIDE its geometric contour, in world
+ * units. Depends on stroke width and alignment: `outside` → the full width,
+ * `center` → half, `inside` → none. No stroke → 0. Used to place the
+ * selection halo a constant distance beyond the shape's VISIBLE outer edge
+ * (contour + this extent), regardless of border thickness / alignment.
+ */
+export declare const strokeOutsideExtent: (style: Style) => number;
+export declare const getCornerRadius: (roundness: Roundness | undefined, width: number, height: number) => number;
+//# sourceMappingURL=style.d.ts.map

package/dist/style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.d.ts","sourceRoot":"","sources":["../src/style.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAMpD,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAClD,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AAEnD;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE1D;;;;;;;;;GASG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;IACnC,qDAAqD;IACrD,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;CAChC;AAED,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;AACpD,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;AACvD,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,MAAM,CAAC;AAC3C,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE5C;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;GAGG;AACH,MAAM,WAAW,SAAU,SAAQ,KAAK;IACtC,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;IAC/B,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC;IACrC,uCAAuC;IACvC,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;IACjC,yCAAyC;IACzC,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;IAC/B,oDAAoD;IACpD,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;CAC1C;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,KAAK,KAAG,MAalD,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,WAAW,SAAS,GAAG,SAAS,EAChC,OAAO,MAAM,EACb,QAAQ,MAAM,KACb,MAcF,CAAC"}

package/dist/style.js

@@ -0,0 +1,43 @@
+import { ADAPTIVE_CORNER_RADIUS, PROPORTIONAL_CORNER_RADIUS, } from "./constants.js";
+/**
+ * How far a shape's stroke extends OUTSIDE its geometric contour, in world
+ * units. Depends on stroke width and alignment: `outside` → the full width,
+ * `center` → half, `inside` → none. No stroke → 0. Used to place the
+ * selection halo a constant distance beyond the shape's VISIBLE outer edge
+ * (contour + this extent), regardless of border thickness / alignment.
+ */
+export const strokeOutsideExtent = (style) => {
+    const hasStroke = style.stroke !== undefined && style.stroke !== "transparent";
+    if (!hasStroke)
+        return 0;
+    const w = style.strokeWidth ?? 1;
+    if (w <= 0)
+        return 0;
+    switch (style.strokeAlign ?? "center") {
+        case "outside":
+            return w;
+        case "inside":
+            return 0;
+        default:
+            return w / 2;
+    }
+};
+export const getCornerRadius = (roundness, width, height) => {
+    if (!roundness || roundness.type === "sharp")
+        return 0;
+    const smaller = Math.min(Math.abs(width), Math.abs(height));
+    if (smaller <= 0)
+        return 0;
+    if (roundness.value !== undefined) {
+        // Honour the override but clamp to half the smaller side so
+        // the corner radii can't overlap on narrow shapes (would
+        // produce a degenerate path).
+        return Math.max(0, Math.min(roundness.value, smaller / 2));
+    }
+    // Adaptive default: proportional below the cutoff, fixed above.
+    const cutoff = ADAPTIVE_CORNER_RADIUS / PROPORTIONAL_CORNER_RADIUS;
+    if (smaller <= cutoff)
+        return smaller * PROPORTIONAL_CORNER_RADIUS;
+    return ADAPTIVE_CORNER_RADIUS;
+};
+//# sourceMappingURL=style.js.map

package/dist/style.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.js","sourceRoot":"","sources":["../src/style.ts"],"names":[],"mappings":"AACA,OAAO,EACL,sBAAsB,EACtB,0BAA0B,GAC3B,MAAM,gBAAgB,CAAC;AAqFxB;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,KAAY,EAAU,EAAE;IAC1D,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,aAAa,CAAC;IAC/E,IAAI,CAAC,SAAS;QAAE,OAAO,CAAC,CAAC;IACzB,MAAM,CAAC,GAAG,KAAK,CAAC,WAAW,IAAI,CAAC,CAAC;IACjC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IACrB,QAAQ,KAAK,CAAC,WAAW,IAAI,QAAQ,EAAE,CAAC;QACtC,KAAK,SAAS;YACZ,OAAO,CAAC,CAAC;QACX,KAAK,QAAQ;YACX,OAAO,CAAC,CAAC;QACX;YACE,OAAO,CAAC,GAAG,CAAC,CAAC;IACjB,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,SAAgC,EAChC,KAAa,EACb,MAAc,EACN,EAAE;IACV,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,IAAI,KAAK,OAAO;QAAE,OAAO,CAAC,CAAC;IACvD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5D,IAAI,OAAO,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IAC3B,IAAI,SAAS,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QAClC,4DAA4D;QAC5D,yDAAyD;QACzD,8BAA8B;QAC9B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC;IAC7D,CAAC;IACD,gEAAgE;IAChE,MAAM,MAAM,GAAG,sBAAsB,GAAG,0BAA0B,CAAC;IACnE,IAAI,OAAO,IAAI,MAAM;QAAE,OAAO,OAAO,GAAG,0BAA0B,CAAC;IACnE,OAAO,sBAAsB,CAAC;AAChC,CAAC,CAAC"}

package/dist/text-measure.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Optional host-provided text measurer. The text bounder
+ * (`getElementLocalBounds` for `TextElement`) is otherwise purely
+ * geometric (`chars × fontSize × factor`), which can diverge a lot
+ * from the actually-rendered width — the WebGL2 MSDF path draws with a
+ * WASM-baked font whose glyph advances differ from any geometric
+ * estimate, so the selection box would not hug the text.
+ *
+ * A host (the interaction layer) injects a measurer backed by the
+ * renderer's `measureText` (which itself matches the active text
+ * backend). When set, the bounder uses it for accurate width; when
+ * absent (headless / tests), it falls back to the geometric estimate.
+ *
+ * Returns the measured width in world px, or `null` to defer to the
+ * geometric estimate for that call. `opts` carries weight/style so the
+ * measurer matches the *rendered* width — bold/italic change glyph
+ * advances, so without it the bounds lag behind a bolded text and the
+ * glyphs overflow the element box.
+ */
+export interface TextMeasureOpts {
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+}
+export type TextMeasurer = (text: string, fontFamily: string, fontSize: number, opts?: TextMeasureOpts) => number | null;
+/** Install (or clear, with `null`) the active text measurer. */
+export declare const setTextMeasurer: (measurer: TextMeasurer | null) => void;
+/** The active text measurer, or `null` when none is installed. */
+export declare const getTextMeasurer: () => TextMeasurer | null;
+//# sourceMappingURL=text-measure.d.ts.map

package/dist/text-measure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-measure.d.ts","sourceRoot":"","sources":["../src/text-measure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,MAAM,YAAY,GAAG,CACzB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,eAAe,KACnB,MAAM,GAAG,IAAI,CAAC;AAInB,gEAAgE;AAChE,eAAO,MAAM,eAAe,GAAI,UAAU,YAAY,GAAG,IAAI,KAAG,IAE/D,CAAC;AAEF,kEAAkE;AAClE,eAAO,MAAM,eAAe,QAAO,YAAY,GAAG,IAAsB,CAAC"}

package/dist/text-measure.js

@@ -0,0 +1,8 @@
+let activeMeasurer = null;
+/** Install (or clear, with `null`) the active text measurer. */
+export const setTextMeasurer = (measurer) => {
+    activeMeasurer = measurer;
+};
+/** The active text measurer, or `null` when none is installed. */
+export const getTextMeasurer = () => activeMeasurer;
+//# sourceMappingURL=text-measure.js.map

package/dist/text-measure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-measure.js","sourceRoot":"","sources":["../src/text-measure.ts"],"names":[],"mappings":"AA+BA,IAAI,cAAc,GAAwB,IAAI,CAAC;AAE/C,gEAAgE;AAChE,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,QAA6B,EAAQ,EAAE;IACrE,cAAc,GAAG,QAAQ,CAAC;AAC5B,CAAC,CAAC;AAEF,kEAAkE;AAClE,MAAM,CAAC,MAAM,eAAe,GAAG,GAAwB,EAAE,CAAC,cAAc,CAAC"}

package/dist/three-way-merge.d.ts

@@ -0,0 +1,59 @@
+import type { ElementId } from "@oh-just-another/types";
+import type { Scene } from "./scene.js";
+import type { Element } from "./shape.js";
+/**
+ * Pure three-way merge for scene shapes. Takes the common ancestor of two
+ * branches + the two heads, returns a merge report:
+ *
+ *   - `autoMerged.elements` — every shape that could be auto-resolved.
+ *     A change is auto-applied when at most one branch touched it
+ *     vs the ancestor; both-touched-identically is also auto-applied
+ *     (degenerate "no conflict").
+ *   - `conflicts[]` — shapes where ancestor / source / target all
+ *     diverge differently. Host UI (`<MergeDialog>`) presents these
+ *     for user resolution; `applyConflictResolution` produces the
+ *     final scene from a chosen `ours / theirs / both` per conflict.
+ *
+ * No history / patch generation here — caller composes the
+ * resolved Scene and pushes it through `Editor.loadScene` (or
+ * derives a patch via `diffSceneElements`).
+ *
+ * Equality semantics: scene mutations always produce fresh shape
+ * references via `apply(scene, patch)`. Reference equality is
+ * sufficient to detect "did this branch touch the shape?". For
+ * cross-process / cross-document scenarios where references differ
+ * naturally, callers can pass a custom `compareElements` predicate.
+ */
+export interface ThreeWayMergeReport {
+    /** Best-effort merged scene; conflicts retain the `target` version. */
+    readonly autoMerged: Scene;
+    readonly conflicts: readonly ThreeWayMergeConflict[];
+}
+export interface ThreeWayMergeConflict {
+    readonly elementId: ElementId;
+    /** Element as it stood in the common ancestor (or null when added in both branches). */
+    readonly base: Element | null;
+    readonly source: Element | null;
+    readonly target: Element | null;
+}
+export interface ThreeWayMergeOptions {
+    /**
+     * Custom equality predicate. Default = reference equality (the
+     * intended use; scene mutations always allocate new shape objects).
+     */
+    readonly compareElements?: (a: Element, b: Element) => boolean;
+}
+export declare const mergeScenesThreeWay: (ancestor: Scene, source: Scene, target: Scene, options?: ThreeWayMergeOptions) => ThreeWayMergeReport;
+/**
+ * Apply user-supplied resolutions to a merge report's conflicts and
+ * return the final scene. Each resolution picks `ours` (target),
+ * `theirs` (source), or `both` (target keeps original; source lands
+ * as a duplicate via the `cloneWithNewId` helper supplied by the
+ * caller — defaults to a "{id}-copy" suffix).
+ */
+export interface ConflictResolutionInput {
+    readonly elementId: ElementId;
+    readonly choice: "ours" | "theirs" | "both";
+}
+export declare const applyConflictResolutions: (report: ThreeWayMergeReport, resolutions: readonly ConflictResolutionInput[], cloneWithNewId?: (shape: Element) => Element) => Scene;
+//# sourceMappingURL=three-way-merge.d.ts.map

package/dist/three-way-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"three-way-merge.d.ts","sourceRoot":"","sources":["../src/three-way-merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,mBAAmB;IAClC,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,SAAS,qBAAqB,EAAE,CAAC;CACtD;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,wFAAwF;IACxF,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;CAChE;AAED,eAAO,MAAM,mBAAmB,GAC9B,UAAU,KAAK,EACf,QAAQ,KAAK,EACb,QAAQ,KAAK,EACb,UAAS,oBAAyB,KACjC,mBAgEF,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;CAC7C;AAED,eAAO,MAAM,wBAAwB,GACnC,QAAQ,mBAAmB,EAC3B,aAAa,SAAS,uBAAuB,EAAE,EAC/C,iBAAgB,CAAC,KAAK,EAAE,OAAO,KAAK,OAAsB,KACzD,KA4BF,CAAC"}