@grida/svg-editor 1.0.0-alpha.13 → 1.0.0-alpha.14

package/dist/insertions-BJ-6o6o5.js

@@ -1,2399 +0,0 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
-let _grida_cmath = require("@grida/cmath");
-_grida_cmath = __toESM(_grida_cmath);
-let _grida_svg_pathdata = require("@grida/svg/pathdata");
-let _grida_svg_parse = require("@grida/svg/parse");
-//#region src/util/dom.ts
-/**
-* `true` when the document's active element is a text-input-like control
-* (input / textarea / contentEditable). Used by keymap + gesture defaults
-* to avoid hijacking keystrokes while the user is typing.
-*/
-function is_text_input_focused() {
-	if (typeof document === "undefined") return false;
-	const el = document.activeElement;
-	if (!el) return false;
-	const tag = el.tagName;
-	if (tag === "INPUT" || tag === "TEXTAREA") return true;
-	if (el.isContentEditable) return true;
-	return false;
-}
-//#endregion
-//#region src/core/group.ts
-/**
-* Tags that may be valid children of a `<g>` element. Wrapping any other
-* tag in `<g>` would produce content-model-invalid SVG (e.g. `<tspan>`
-* must live inside `<text>`; `<stop>` must live inside a gradient).
-*/
-const STRUCTURAL_GRAPHICS_SET = new Set([
-	"g",
-	"defs",
-	"svg",
-	"use",
-	"image",
-	"switch",
-	"foreignObject",
-	"path",
-	"rect",
-	"circle",
-	"ellipse",
-	"line",
-	"polyline",
-	"polygon",
-	"text",
-	"a"
-]);
-/**
-* Tags whose content model is constrained — a freshly-inserted `<g>`
-* here would either be invalid (text-content / gradient / filter
-* parents) or semantically meaningless (defs, symbol).
-*/
-const CONSTRAINED_PARENT_SET = new Set([
-	"text",
-	"tspan",
-	"defs",
-	"clipPath",
-	"mask",
-	"pattern",
-	"marker",
-	"symbol",
-	"filter",
-	"linearGradient",
-	"radialGradient",
-	"animateMotion",
-	"switch"
-]);
-/**
-* Read-only policy gate. Returns a plan when grouping the given
-* selection is accepted; returns `null` (rejected) otherwise.
-*
-* Decision tree matches `packages/grida-svg-editor/docs/wg/feat-svg-editor/grouping.md`. Default
-* stance: "when unclear, reject."
-*/
-function plan_group(doc, ids) {
-	if (ids.length === 0) return null;
-	const parent = doc.parent_of(ids[0]);
-	if (parent === null) return null;
-	for (const id of ids) {
-		if (doc.parent_of(id) !== parent) return null;
-		if (!STRUCTURAL_GRAPHICS_SET.has(doc.tag_of(id))) return null;
-	}
-	if (CONSTRAINED_PARENT_SET.has(doc.tag_of(parent))) return null;
-	const siblings = doc.element_children_of(parent);
-	const sibling_index = /* @__PURE__ */ new Map();
-	for (let i = 0; i < siblings.length; i++) sibling_index.set(siblings[i], i);
-	const indices = [];
-	for (const id of ids) {
-		const i = sibling_index.get(id);
-		if (i === void 0) return null;
-		indices.push(i);
-	}
-	const sorted = Array.from(new Set(indices)).sort((a, b) => a - b);
-	for (let i = 1; i < sorted.length; i++) if (sorted[i] !== sorted[i - 1] + 1) return null;
-	const children = sorted.map((i) => siblings[i]);
-	const last_index = sorted[sorted.length - 1];
-	const original_positions = /* @__PURE__ */ new Map();
-	for (const i of sorted) original_positions.set(siblings[i], siblings[i + 1] ?? null);
-	return {
-		parent,
-		insert_before: siblings[last_index + 1] ?? null,
-		children,
-		original_positions
-	};
-}
-//#endregion
-//#region src/core/translate-pipeline/pipeline.ts
-/** The funnel. Threads `plan` through `stages` in order; aggregates
-*  guide emissions. Pure: same inputs → same outputs. */
-function run_translate_pipeline(init, stages, ctx) {
-	let plan = init;
-	const guides = [];
-	for (const stage of stages) {
-		const out = stage.run(plan, ctx);
-		plan = out.plan;
-		if (out.emit?.guide) guides.push(out.emit.guide);
-	}
-	return {
-		plan,
-		guides
-	};
-}
-//#endregion
-//#region src/core/transform/parse.ts
-/** SVG `<number>` production (spec-aligned subset). */
-const SVG_NUMBER_SRC = "[+-]?(?:\\d+\\.?\\d*|\\.\\d+)(?:[eE][+-]?\\d+)?";
-/** Recognized function names. Names are case-sensitive per SVG 1.1 §7.6. */
-const FUNCTION_RE = /\s*([A-Za-z]+)\s*\(([^)]*)\)\s*/y;
-/** Number tokens, comma- or whitespace-separated, inside a single call. */
-const NUMBER_GLOBAL_RE = new RegExp(SVG_NUMBER_SRC, "g");
-/** Identity / no-op string forms. SVG 2 §11.6.1 lets `transform="none"`
-*  mean the identity transform. CSS-wide keywords are normalized at
-*  parse time per SVG 2 cascade. */
-const IDENTITY_RE = /^\s*(?:none|inherit|unset|initial|revert|revert-layer)?\s*$/;
-function parse_args(args) {
-	const tokens = args.match(NUMBER_GLOBAL_RE);
-	if (!tokens) return [];
-	const out = [];
-	for (const t of tokens) {
-		const n = parseFloat(t);
-		if (!Number.isFinite(n)) return null;
-		out.push(n);
-	}
-	return out;
-}
-function build_op(name, a) {
-	switch (name) {
-		case "matrix":
-			if (a.length !== 6) return null;
-			return {
-				type: "matrix",
-				a: a[0],
-				b: a[1],
-				c: a[2],
-				d: a[3],
-				e: a[4],
-				f: a[5]
-			};
-		case "translate":
-			if (a.length !== 1 && a.length !== 2) return null;
-			return {
-				type: "translate",
-				tx: a[0],
-				ty: a.length === 2 ? a[1] : 0
-			};
-		case "rotate":
-			if (a.length !== 1 && a.length !== 3) return null;
-			return {
-				type: "rotate",
-				angle: a[0],
-				cx: a.length === 3 ? a[1] : 0,
-				cy: a.length === 3 ? a[2] : 0,
-				explicit_pivot: a.length === 3
-			};
-		case "scale":
-			if (a.length !== 1 && a.length !== 2) return null;
-			return {
-				type: "scale",
-				sx: a[0],
-				sy: a.length === 2 ? a[1] : a[0]
-			};
-		case "skewX":
-			if (a.length !== 1) return null;
-			return {
-				type: "skewX",
-				angle: a[0]
-			};
-		case "skewY":
-			if (a.length !== 1) return null;
-			return {
-				type: "skewY",
-				angle: a[0]
-			};
-		default: return null;
-	}
-}
-/**
-* Parse a `transform=""` attribute string into a list of typed ops.
-*
-*   parse_transform_list(null)               => []
-*   parse_transform_list("")                 => []
-*   parse_transform_list("none")             => []
-*   parse_transform_list("translate(10 20)") => [{type:"translate",tx:10,ty:20}]
-*   parse_transform_list("rotate(30 50 50)") => [{type:"rotate",angle:30,cx:50,cy:50}]
-*   parse_transform_list("foo(1)")           => null   // unknown function
-*   parse_transform_list("matrix(1 0 0)")    => null   // wrong arg count
-*/
-function parse_transform_list(input) {
-	if (input === null) return [];
-	if (IDENTITY_RE.test(input)) return [];
-	const ops = [];
-	FUNCTION_RE.lastIndex = 0;
-	let pos = 0;
-	while (pos < input.length) {
-		FUNCTION_RE.lastIndex = pos;
-		const m = FUNCTION_RE.exec(input);
-		if (!m || m.index !== pos) return null;
-		const name = m[1];
-		const args = parse_args(m[2]);
-		if (args === null) return null;
-		const op = build_op(name, args);
-		if (!op) return null;
-		ops.push(op);
-		pos = FUNCTION_RE.lastIndex;
-		while (pos < input.length && /[\s,]/.test(input[pos])) pos++;
-	}
-	return ops;
-}
-//#endregion
-//#region src/core/transform/emit.ts
-function n(x) {
-	return String(x);
-}
-function emit_op(op) {
-	switch (op.type) {
-		case "matrix": return `matrix(${n(op.a)} ${n(op.b)} ${n(op.c)} ${n(op.d)} ${n(op.e)} ${n(op.f)})`;
-		case "translate": return `translate(${n(op.tx)} ${n(op.ty)})`;
-		case "rotate": return `rotate(${n(op.angle)} ${n(op.cx)} ${n(op.cy)})`;
-		case "scale": return `scale(${n(op.sx)} ${n(op.sy)})`;
-		case "skewX": return `skewX(${n(op.angle)})`;
-		case "skewY": return `skewY(${n(op.angle)})`;
-	}
-}
-/** Concatenate ops with single-space separator. Returns `""` for empty
-*  list (identity). Caller decides whether to write `transform=""`,
-*  `transform="none"`, or remove the attribute entirely. */
-function emit_transform_list(ops) {
-	return ops.map(emit_op).join(" ");
-}
-//#endregion
-//#region src/core/transform/classify.ts
-function is_identity_translate(op) {
-	return op.type === "translate" && op.tx === 0 && op.ty === 0;
-}
-function is_identity_rotate(op) {
-	return op.type === "rotate" && op.angle === 0;
-}
-function classify(ops) {
-	const trimmed = ops.filter((op) => !is_identity_translate(op) && !is_identity_rotate(op));
-	if (trimmed.length === 0) return "identity";
-	if (trimmed.length === 1) {
-		if (trimmed[0].type === "translate") return "leading_translate_only";
-		if (trimmed[0].type === "rotate") return "single_rotate_only";
-		return "mixed";
-	}
-	if (trimmed.length === 2 && trimmed[0].type === "translate" && trimmed[1].type === "rotate") return "leading_translate_then_single_rotate";
-	return "mixed";
-}
-//#endregion
-//#region src/core/transform/recompose.ts
-function recompose_with_pivot(ops, new_cx, new_cy) {
-	const tx_op = ops.find((op) => op.type === "translate");
-	const tx = tx_op?.type === "translate" ? tx_op.tx : 0;
-	const ty = tx_op?.type === "translate" ? tx_op.ty : 0;
-	return emit_transform_list(ops.map((op) => op.type === "rotate" ? {
-		type: "rotate",
-		angle: op.angle,
-		cx: new_cx - tx,
-		cy: new_cy - ty,
-		explicit_pivot: true
-	} : op));
-}
-//#endregion
-//#region src/core/transform/project.ts
-function op_matrix(op) {
-	switch (op.type) {
-		case "matrix": return [[
-			op.a,
-			op.c,
-			op.e
-		], [
-			op.b,
-			op.d,
-			op.f
-		]];
-		case "translate": return [[
-			1,
-			0,
-			op.tx
-		], [
-			0,
-			1,
-			op.ty
-		]];
-		case "rotate": {
-			const t = op.angle * Math.PI / 180;
-			const cos = Math.cos(t);
-			const sin = Math.sin(t);
-			return [[
-				cos,
-				-sin,
-				op.cx - op.cx * cos + op.cy * sin
-			], [
-				sin,
-				cos,
-				op.cy - op.cx * sin - op.cy * cos
-			]];
-		}
-		case "scale": return [[
-			op.sx,
-			0,
-			0
-		], [
-			0,
-			op.sy,
-			0
-		]];
-		case "skewX": {
-			const t = op.angle * Math.PI / 180;
-			return [[
-				1,
-				Math.tan(t),
-				0
-			], [
-				0,
-				1,
-				0
-			]];
-		}
-		case "skewY": {
-			const t = op.angle * Math.PI / 180;
-			return [[
-				1,
-				0,
-				0
-			], [
-				Math.tan(t),
-				1,
-				0
-			]];
-		}
-	}
-}
-/** Compose a transform-list into a single 2×3 affine. Ops compose
-*  source-order = left-to-right multiplication: `transform="A B C"` maps
-*  a column-vector point `p` as `A · B · C · p` (per SVG 1.1 §7.5). */
-function compose(ops) {
-	let m = _grida_cmath.default.transform.identity;
-	for (const op of ops) m = _grida_cmath.default.transform.multiply(m, op_matrix(op));
-	return m;
-}
-/** Axis-aligned doc-space bounding box of `local` under `transform_str`.
-*  Returns `local` unchanged when the transform is absent / empty /
-*  unparseable (i.e. local-frame ≡ doc-space in those cases). */
-function project_local_bbox(local, transform_str) {
-	if (!transform_str) return local;
-	const ops = parse_transform_list(transform_str);
-	if (ops === null || ops.length === 0) return local;
-	const m = compose(ops);
-	const projected = [
-		[local.x, local.y],
-		[local.x + local.width, local.y],
-		[local.x + local.width, local.y + local.height],
-		[local.x, local.y + local.height]
-	].map((p) => _grida_cmath.default.vector2.transform(p, m));
-	return _grida_cmath.default.rect.fromPointsOrZero(projected);
-}
-//#endregion
-//#region src/core/hit-shape-svg.ts
-/** Tags that never participate in picking. Containers and non-rendering
-*  metadata. The root `<svg>` is in this set — root pickability is a
-*  host decision (measurement HUD wants it, selection doesn't), gated
-*  by an explicit `allow_root` flag at the caller. */
-const TRANSPARENT_TAGS = new Set([
-	"g",
-	"svg",
-	"defs",
-	"symbol",
-	"clipPath",
-	"mask",
-	"marker",
-	"pattern",
-	"linearGradient",
-	"radialGradient",
-	"stop",
-	"filter",
-	"title",
-	"desc",
-	"metadata",
-	"style",
-	"script"
-]);
-function is_transparent_tag(tag) {
-	return TRANSPARENT_TAGS.has(tag);
-}
-function num$1(doc, id, name, fallback = 0) {
-	return _grida_svg_parse.svg_parse.parse_number(doc.get_attr(id, name), fallback);
-}
-/**
-* Hit-shape derived from document attributes. Returns `null` when the
-* node has no derivable shape (transparent tag, malformed attrs, or a
-* `transform=` we can't compose cleanly — matrix / scale / skew / mixed).
-*
-* For `transform=` values that classify to identity / leading-translate /
-* single-rotate / translate-then-rotate, the returned shape is the
-* post-transform polygon/segment (rotated rects become 4-corner polygons),
-* so picking lands on the rendered outline rather than the silent AABB
-* fallback in `SvgHitShapeDriver`.
-*
-* Caveat: see "Known issues" #1 at the top of this file — ancestor CTM
-* is still NOT composed here. Inside a `<g transform="...">` the shape
-* is still in the ancestor-relative frame.
-*/
-function hit_shape_of_doc(doc, id) {
-	const tag = doc.tag_of(id);
-	const ops = parse_transform_list(doc.get_attr(id, "transform"));
-	if (ops === null) return null;
-	if (classify(ops) === "mixed") return null;
-	const xform = pick_affine(ops);
-	const has_rotation = xform.angle_rad !== 0;
-	switch (tag) {
-		case "rect": {
-			const x = num$1(doc, id, "x");
-			const y = num$1(doc, id, "y");
-			const w = num$1(doc, id, "width");
-			const h = num$1(doc, id, "height");
-			if (!has_rotation) {
-				const t = xform.translate;
-				return {
-					kind: "rect",
-					x: x + t.x,
-					y: y + t.y,
-					width: w,
-					height: h
-				};
-			}
-			return {
-				kind: "polygon",
-				pts: [
-					{
-						x,
-						y
-					},
-					{
-						x: x + w,
-						y
-					},
-					{
-						x: x + w,
-						y: y + h
-					},
-					{
-						x,
-						y: y + h
-					}
-				].map((p) => transform_point(p, xform)),
-				closed: true
-			};
-		}
-		case "circle": {
-			const cx = num$1(doc, id, "cx");
-			const cy = num$1(doc, id, "cy");
-			const r = num$1(doc, id, "r");
-			const tc = transform_point({
-				x: cx,
-				y: cy
-			}, xform);
-			return {
-				kind: "ellipse",
-				cx: tc.x,
-				cy: tc.y,
-				rx: r,
-				ry: r
-			};
-		}
-		case "ellipse": {
-			const cx = num$1(doc, id, "cx");
-			const cy = num$1(doc, id, "cy");
-			const rx = num$1(doc, id, "rx");
-			const ry = num$1(doc, id, "ry");
-			if (has_rotation) return null;
-			const tc = transform_point({
-				x: cx,
-				y: cy
-			}, xform);
-			return {
-				kind: "ellipse",
-				cx: tc.x,
-				cy: tc.y,
-				rx,
-				ry
-			};
-		}
-		case "line": return {
-			kind: "segment",
-			a: transform_point({
-				x: num$1(doc, id, "x1"),
-				y: num$1(doc, id, "y1")
-			}, xform),
-			b: transform_point({
-				x: num$1(doc, id, "x2"),
-				y: num$1(doc, id, "y2")
-			}, xform)
-		};
-		case "polyline": {
-			const pts = _grida_svg_parse.svg_parse.parse_points(doc.get_attr(id, "points") ?? "");
-			if (pts.length === 0) return null;
-			return {
-				kind: "polyline",
-				pts: pts.map((q) => transform_point({
-					x: q.x,
-					y: q.y
-				}, xform)),
-				closed: false
-			};
-		}
-		case "polygon": {
-			const pts = _grida_svg_parse.svg_parse.parse_points(doc.get_attr(id, "points") ?? "");
-			if (pts.length === 0) return null;
-			return {
-				kind: "polygon",
-				pts: pts.map((q) => transform_point({
-					x: q.x,
-					y: q.y
-				}, xform)),
-				closed: true
-			};
-		}
-		case "path": {
-			const d = doc.get_attr(id, "d") ?? "";
-			const pts = path_control_polyline(d);
-			if (pts.length === 0) return null;
-			return {
-				kind: "path",
-				pts: pts.map((p) => transform_point(p, xform)),
-				closed: /[zZ]\s*$/.test(d)
-			};
-		}
-		default: return null;
-	}
-}
-function pick_affine(ops) {
-	let tx = 0;
-	let ty = 0;
-	let pivot = {
-		x: 0,
-		y: 0
-	};
-	let angle_rad = 0;
-	for (const op of ops) if (op.type === "translate") {
-		tx = op.tx;
-		ty = op.ty;
-	} else if (op.type === "rotate") {
-		pivot = {
-			x: op.cx,
-			y: op.cy
-		};
-		angle_rad = op.angle * Math.PI / 180;
-	}
-	return {
-		translate: {
-			x: tx,
-			y: ty
-		},
-		pivot,
-		angle_rad
-	};
-}
-/** Apply (rotate around pivot by angle_rad, then translate). Mirrors the
-*  SVG transform-list semantic order: `translate(...) rotate(...)` means
-*  matrix product T·R applied to P → translation moves the *rotated*
-*  point. */
-function transform_point(p, x) {
-	let q = p;
-	if (x.angle_rad !== 0) {
-		const c = Math.cos(x.angle_rad);
-		const s = Math.sin(x.angle_rad);
-		const dx = q.x - x.pivot.x;
-		const dy = q.y - x.pivot.y;
-		q = {
-			x: x.pivot.x + dx * c - dy * s,
-			y: x.pivot.y + dx * s + dy * c
-		};
-	}
-	if (x.translate.x !== 0 || x.translate.y !== 0) q = {
-		x: q.x + x.translate.x,
-		y: q.y + x.translate.y
-	};
-	return q;
-}
-/** Path-`d` → control-polyline approximation. Each command contributes
-*  any control points it carries (Q: x1/y1; C: x1/y1 + x2/y2) plus its
-*  endpoint. T/S shorthand and A arcs contribute only the endpoint at
-*  this fidelity. Returns `[]` for unparseable input. */
-function path_control_polyline(d) {
-	if (!d) return [];
-	let path;
-	try {
-		path = new _grida_svg_pathdata.SVGPathData(d).toAbs();
-	} catch {
-		return [];
-	}
-	const out = [];
-	for (const cmd of path.commands) {
-		const c = cmd;
-		if (typeof c.x1 === "number" && typeof c.y1 === "number") out.push({
-			x: c.x1,
-			y: c.y1
-		});
-		if (typeof c.x2 === "number" && typeof c.y2 === "number") out.push({
-			x: c.x2,
-			y: c.y2
-		});
-		if (typeof c.x === "number" && typeof c.y === "number") out.push({
-			x: c.x,
-			y: c.y
-		});
-	}
-	return out;
-}
-//#endregion
-//#region src/core/intents.ts
-function num(doc, id, name, fallback = 0) {
-	return _grida_svg_parse.svg_parse.parse_number(doc.get_attr(id, name), fallback);
-}
-function capture_translate_baseline(doc, id) {
-	const tag = doc.tag_of(id);
-	const own_transform = doc.get_attr(id, "transform");
-	if (own_transform !== null || tag === "g") return {
-		type: "viaTransform",
-		transform: own_transform
-	};
-	switch (tag) {
-		case "rect": return {
-			type: "rect",
-			x: num(doc, id, "x"),
-			y: num(doc, id, "y")
-		};
-		case "circle": return {
-			type: "circle",
-			cx: num(doc, id, "cx"),
-			cy: num(doc, id, "cy")
-		};
-		case "ellipse": return {
-			type: "ellipse",
-			cx: num(doc, id, "cx"),
-			cy: num(doc, id, "cy")
-		};
-		case "line": return {
-			type: "line",
-			x1: num(doc, id, "x1"),
-			y1: num(doc, id, "y1"),
-			x2: num(doc, id, "x2"),
-			y2: num(doc, id, "y2")
-		};
-		case "polyline": return {
-			type: "polyline",
-			points: doc.get_attr(id, "points") ?? ""
-		};
-		case "polygon": return {
-			type: "polygon",
-			points: doc.get_attr(id, "points") ?? ""
-		};
-		case "path": return {
-			type: "path",
-			d: doc.get_attr(id, "d") ?? ""
-		};
-		case "text": return {
-			type: "text",
-			x: num(doc, id, "x"),
-			y: num(doc, id, "y")
-		};
-		case "tspan": return {
-			type: "tspan",
-			x: num(doc, id, "x"),
-			y: num(doc, id, "y")
-		};
-		case "image": return {
-			type: "image",
-			x: num(doc, id, "x"),
-			y: num(doc, id, "y")
-		};
-		case "use": return {
-			type: "use",
-			x: num(doc, id, "x"),
-			y: num(doc, id, "y")
-		};
-		default: return { type: "unsupported" };
-	}
-}
-/**
-* Batch variant of {@link capture_translate_baseline} — captures baselines
-* for a set of ids into a `ReadonlyMap`. Used wherever a translate
-* operation needs to remember the pre-translation state of multiple
-* nodes (drag gesture, RPC, dwell detection).
-*/
-function capture_translate_baselines(doc, ids) {
-	const out = /* @__PURE__ */ new Map();
-	for (const id of ids) out.set(id, capture_translate_baseline(doc, id));
-	return out;
-}
-/**
-* Representative anchor point of a `TranslateBaseline` — the attribute
-* coordinate `apply_translate` offsets. Used by callers that need to
-* align baselines to an external lattice (pixel-grid, custom snap).
-*
-* Rules per element kind:
-*   - rect / text / tspan / image / use: `(x, y)`
-*   - circle / ellipse: `(cx, cy)` (no radius subtracted — consistent
-*     anchor across all kinds, not a true bounds top-left)
-*   - line / polyline / polygon: min of endpoints / points
-*   - path: first M/m command's coords (best-effort; the path-data
-*     layer would be needed for a tight bbox)
-*   - viaTransform / unsupported: `null` — no document-space anchor
-*     available without the doc itself
-*/
-function baseline_anchor(b) {
-	switch (b.type) {
-		case "rect":
-		case "text":
-		case "tspan":
-		case "image":
-		case "use": return {
-			x: b.x,
-			y: b.y
-		};
-		case "circle":
-		case "ellipse": return {
-			x: b.cx,
-			y: b.cy
-		};
-		case "line": return {
-			x: Math.min(b.x1, b.x2),
-			y: Math.min(b.y1, b.y2)
-		};
-		case "polyline":
-		case "polygon": return _grida_svg_parse.svg_parse.points_top_left(_grida_svg_parse.svg_parse.parse_points(b.points));
-		case "path": return _grida_svg_parse.svg_parse.parse_path_first_move(b.d);
-		case "viaTransform": {
-			const ops = parse_transform_list(b.transform);
-			if (ops === null) return null;
-			for (const op of ops) {
-				if (op.type === "translate") return {
-					x: op.tx,
-					y: op.ty
-				};
-				break;
-			}
-			return null;
-		}
-		case "unsupported": return null;
-	}
-}
-/**
-* Top-left of the union over a collection of `TranslateBaseline`s.
-* Returns `null` when no baseline yields an anchor (e.g. all
-* `viaTransform` / `unsupported`). Callers fall through (no alignment).
-*/
-function baseline_union_top_left(baselines) {
-	const anchors = [];
-	for (const b of baselines.values()) {
-		const p = baseline_anchor(b);
-		if (p) anchors.push(p);
-	}
-	return _grida_svg_parse.svg_parse.points_top_left(anchors);
-}
-function shift_points_string(points, dx, dy) {
-	if (dx === 0 && dy === 0) return points;
-	return _grida_svg_parse.svg_parse.parse_points(points).map((p) => `${p.x + dx},${p.y + dy}`).join(" ");
-}
-function compose_leading_translate(existing, dx, dy) {
-	if (dx === 0 && dy === 0) return existing ? existing : null;
-	if (!existing) return `translate(${dx} ${dy})`;
-	const lead = _grida_svg_parse.svg_parse.parse_leading_translate(existing);
-	if (lead) {
-		const tx = lead.tx + dx;
-		const ty = lead.ty + dy;
-		return lead.rest ? `translate(${tx} ${ty}) ${lead.rest}` : `translate(${tx} ${ty})`;
-	}
-	return `translate(${dx} ${dy}) ${existing}`;
-}
-function shift_path_d(d, dx, dy) {
-	if (dx === 0 && dy === 0) return d;
-	try {
-		return new _grida_svg_pathdata.SVGPathData(d).transform(_grida_svg_pathdata.SVGPathDataTransformer.TRANSLATE(dx, dy)).encode();
-	} catch {
-		return d;
-	}
-}
-function apply_translate(doc, id, baseline, dx, dy) {
-	switch (baseline.type) {
-		case "viaTransform":
-			doc.set_attr(id, "transform", compose_leading_translate(baseline.transform ?? "", dx, dy));
-			return;
-		case "rect":
-		case "image":
-		case "use":
-		case "text":
-		case "tspan":
-			doc.set_attr(id, "x", String(baseline.x + dx));
-			doc.set_attr(id, "y", String(baseline.y + dy));
-			return;
-		case "circle":
-		case "ellipse":
-			doc.set_attr(id, "cx", String(baseline.cx + dx));
-			doc.set_attr(id, "cy", String(baseline.cy + dy));
-			return;
-		case "line":
-			doc.set_attr(id, "x1", String(baseline.x1 + dx));
-			doc.set_attr(id, "y1", String(baseline.y1 + dy));
-			doc.set_attr(id, "x2", String(baseline.x2 + dx));
-			doc.set_attr(id, "y2", String(baseline.y2 + dy));
-			return;
-		case "polyline":
-		case "polygon":
-			doc.set_attr(id, "points", shift_points_string(baseline.points, dx, dy));
-			return;
-		case "path":
-			doc.set_attr(id, "d", shift_path_d(baseline.d, dx, dy));
-			return;
-		case "unsupported": return;
-	}
-}
-function is_resizable(tag) {
-	switch (tag) {
-		case "rect":
-		case "image":
-		case "use":
-		case "circle":
-		case "ellipse":
-		case "line":
-		case "polyline":
-		case "polygon":
-		case "path":
-		case "text": return true;
-		default: return false;
-	}
-}
-function capture_resize_baseline(doc, id, bbox) {
-	const tag = doc.tag_of(id);
-	let attrs;
-	switch (tag) {
-		case "rect":
-			attrs = {
-				kind: "rect",
-				x: num(doc, id, "x"),
-				y: num(doc, id, "y"),
-				w: num(doc, id, "width", bbox.width),
-				h: num(doc, id, "height", bbox.height)
-			};
-			break;
-		case "image":
-			attrs = {
-				kind: "image",
-				x: num(doc, id, "x"),
-				y: num(doc, id, "y"),
-				w: num(doc, id, "width", bbox.width),
-				h: num(doc, id, "height", bbox.height)
-			};
-			break;
-		case "use":
-			attrs = {
-				kind: "use",
-				x: num(doc, id, "x"),
-				y: num(doc, id, "y"),
-				w: num(doc, id, "width", bbox.width),
-				h: num(doc, id, "height", bbox.height)
-			};
-			break;
-		case "circle":
-			attrs = {
-				kind: "circle",
-				cx: num(doc, id, "cx"),
-				cy: num(doc, id, "cy"),
-				r: num(doc, id, "r")
-			};
-			break;
-		case "ellipse":
-			attrs = {
-				kind: "ellipse",
-				cx: num(doc, id, "cx"),
-				cy: num(doc, id, "cy"),
-				rx: num(doc, id, "rx"),
-				ry: num(doc, id, "ry")
-			};
-			break;
-		case "line":
-			attrs = {
-				kind: "line",
-				x1: num(doc, id, "x1"),
-				y1: num(doc, id, "y1"),
-				x2: num(doc, id, "x2"),
-				y2: num(doc, id, "y2")
-			};
-			break;
-		case "polyline":
-			attrs = {
-				kind: "polyline",
-				points: doc.get_attr(id, "points") ?? ""
-			};
-			break;
-		case "polygon":
-			attrs = {
-				kind: "polygon",
-				points: doc.get_attr(id, "points") ?? ""
-			};
-			break;
-		case "path":
-			attrs = {
-				kind: "path",
-				d: doc.get_attr(id, "d") ?? ""
-			};
-			break;
-		case "text":
-			attrs = {
-				kind: "text",
-				x: num(doc, id, "x"),
-				y: num(doc, id, "y"),
-				fontSize: parseFloat(doc.get_attr(id, "font-size") ?? "16") || 16
-			};
-			break;
-		default: attrs = { kind: "unsupported" };
-	}
-	return {
-		bbox,
-		attrs
-	};
-}
-function compute_resize_factors(baseline, dir, dx, dy, shift) {
-	const b = baseline.bbox;
-	let anchorX = 0;
-	let anchorY = 0;
-	let baseHX = 0;
-	let baseHY = 0;
-	let affectsX = true;
-	let affectsY = true;
-	switch (dir) {
-		case "nw":
-			anchorX = b.x + b.width;
-			anchorY = b.y + b.height;
-			baseHX = b.x;
-			baseHY = b.y;
-			break;
-		case "n":
-			anchorX = b.x + b.width / 2;
-			anchorY = b.y + b.height;
-			baseHX = b.x + b.width / 2;
-			baseHY = b.y;
-			affectsX = false;
-			break;
-		case "ne":
-			anchorX = b.x;
-			anchorY = b.y + b.height;
-			baseHX = b.x + b.width;
-			baseHY = b.y;
-			break;
-		case "e":
-			anchorX = b.x;
-			anchorY = b.y + b.height / 2;
-			baseHX = b.x + b.width;
-			baseHY = b.y + b.height / 2;
-			affectsY = false;
-			break;
-		case "se":
-			anchorX = b.x;
-			anchorY = b.y;
-			baseHX = b.x + b.width;
-			baseHY = b.y + b.height;
-			break;
-		case "s":
-			anchorX = b.x + b.width / 2;
-			anchorY = b.y;
-			baseHX = b.x + b.width / 2;
-			baseHY = b.y + b.height;
-			affectsX = false;
-			break;
-		case "sw":
-			anchorX = b.x + b.width;
-			anchorY = b.y;
-			baseHX = b.x;
-			baseHY = b.y + b.height;
-			break;
-		case "w":
-			anchorX = b.x + b.width;
-			anchorY = b.y + b.height / 2;
-			baseHX = b.x;
-			baseHY = b.y + b.height / 2;
-			affectsY = false;
-			break;
-	}
-	const newHX = baseHX + (affectsX ? dx : 0);
-	const newHY = baseHY + (affectsY ? dy : 0);
-	const denomX = baseHX - anchorX;
-	const denomY = baseHY - anchorY;
-	let sx = affectsX && denomX !== 0 ? (newHX - anchorX) / denomX : 1;
-	let sy = affectsY && denomY !== 0 ? (newHY - anchorY) / denomY : 1;
-	if (shift && affectsX && affectsY) {
-		const mag = Math.max(Math.abs(sx), Math.abs(sy));
-		sx = sx >= 0 ? mag : -mag;
-		sy = sy >= 0 ? mag : -mag;
-	}
-	sx = Math.max(.001, sx);
-	sy = Math.max(.001, sy);
-	return {
-		sx,
-		sy,
-		origin: {
-			x: anchorX,
-			y: anchorY
-		}
-	};
-}
-function scale_points_string(points, origin, sx, sy) {
-	return _grida_svg_parse.svg_parse.parse_points(points).map((p) => {
-		return `${origin.x + (p.x - origin.x) * sx},${origin.y + (p.y - origin.y) * sy}`;
-	}).join(" ");
-}
-function scale_path_d(d, origin, sx, sy) {
-	try {
-		const e = origin.x * (1 - sx);
-		const f = origin.y * (1 - sy);
-		return new _grida_svg_pathdata.SVGPathData(d).transform(_grida_svg_pathdata.SVGPathDataTransformer.MATRIX(sx, 0, 0, sy, e, f)).encode();
-	} catch {
-		return d;
-	}
-}
-function bbox_center(points) {
-	if (points.length === 0) return null;
-	const r = _grida_cmath.default.rect.fromPointsOrZero(points.map((p) => [p.x, p.y]));
-	return {
-		cx: r.x + r.width / 2,
-		cy: r.y + r.height / 2
-	};
-}
-function new_local_center(doc, id) {
-	switch (doc.tag_of(id)) {
-		case "rect":
-		case "image":
-		case "use": {
-			const x = num(doc, id, "x");
-			const y = num(doc, id, "y");
-			return {
-				cx: x + num(doc, id, "width") / 2,
-				cy: y + num(doc, id, "height") / 2
-			};
-		}
-		case "circle":
-		case "ellipse": return {
-			cx: num(doc, id, "cx"),
-			cy: num(doc, id, "cy")
-		};
-		case "line": {
-			const x1 = num(doc, id, "x1");
-			const y1 = num(doc, id, "y1");
-			const x2 = num(doc, id, "x2");
-			const y2 = num(doc, id, "y2");
-			return {
-				cx: (x1 + x2) / 2,
-				cy: (y1 + y2) / 2
-			};
-		}
-		case "polyline":
-		case "polygon": {
-			const points = doc.get_attr(id, "points");
-			if (!points) return null;
-			return bbox_center(_grida_svg_parse.svg_parse.parse_points(points));
-		}
-		case "path": {
-			const d = doc.get_attr(id, "d");
-			if (!d) return null;
-			return bbox_center(path_control_polyline(d));
-		}
-		default: return null;
-	}
-}
-/** Translate every local-frame coord of `id`'s geometry by (dx, dy). The
-*  primitive arms write intrinsic attrs directly — we can't route through
-*  `apply_translate` here because `capture_translate_baseline` returns
-*  `viaTransform` whenever the node has a `transform=`, and that branch
-*  prepends a `translate()` to the transform string, which would clobber
-*  the pivot rewrite the caller is about to do. */
-function shift_geometry(doc, id, dx, dy) {
-	switch (doc.tag_of(id)) {
-		case "rect":
-		case "image":
-		case "use":
-			doc.set_attr(id, "x", String(num(doc, id, "x") + dx));
-			doc.set_attr(id, "y", String(num(doc, id, "y") + dy));
-			return;
-		case "circle":
-		case "ellipse":
-			doc.set_attr(id, "cx", String(num(doc, id, "cx") + dx));
-			doc.set_attr(id, "cy", String(num(doc, id, "cy") + dy));
-			return;
-		case "line":
-			doc.set_attr(id, "x1", String(num(doc, id, "x1") + dx));
-			doc.set_attr(id, "y1", String(num(doc, id, "y1") + dy));
-			doc.set_attr(id, "x2", String(num(doc, id, "x2") + dx));
-			doc.set_attr(id, "y2", String(num(doc, id, "y2") + dy));
-			return;
-		case "polyline":
-		case "polygon": {
-			const points = doc.get_attr(id, "points");
-			if (points) doc.set_attr(id, "points", shift_points_string(points, dx, dy));
-			return;
-		}
-		case "path": {
-			const d = doc.get_attr(id, "d");
-			if (d) doc.set_attr(id, "d", shift_path_d(d, dx, dy));
-			return;
-		}
-	}
-}
-/**
-* Commit-only. Moves the rotate pivot to the new local center and shifts
-* geometry by δ = (R − I) · Δc so the doc-space rendering is unchanged.
-* Without the shift, changing the pivot offsets the rect in doc space and
-* the HUD's stable-matrix chrome falls out of alignment with the element.
-*/
-function renormalize_rotate_pivot(doc, id) {
-	const existing = doc.get_attr(id, "transform");
-	if (existing === null || existing.indexOf("rotate") === -1) return;
-	const ops = parse_transform_list(existing);
-	if (ops === null) return;
-	const cls = classify(ops);
-	if (cls !== "single_rotate_only" && cls !== "leading_translate_then_single_rotate") return;
-	const rot = find_op(ops, "rotate");
-	if (!rot || rot.explicit_pivot !== true) return;
-	const c_pre = new_local_center(doc, id);
-	if (!c_pre) return;
-	const dc_x = c_pre.cx - rot.cx;
-	const dc_y = c_pre.cy - rot.cy;
-	if (dc_x === 0 && dc_y === 0) return;
-	const theta = rot.angle * Math.PI / 180;
-	const cos = Math.cos(theta);
-	const sin = Math.sin(theta);
-	const dx = (cos - 1) * dc_x - sin * dc_y;
-	const dy = sin * dc_x + (cos - 1) * dc_y;
-	shift_geometry(doc, id, dx, dy);
-	const next = recompose_with_pivot(ops, c_pre.cx + dx, c_pre.cy + dy);
-	if (next === existing) return;
-	doc.set_attr(id, "transform", next);
-}
-function apply_resize(doc, id, baseline, sx, sy, origin, phase = "commit") {
-	const a = baseline.attrs;
-	switch (a.kind) {
-		case "rect":
-		case "image":
-		case "use":
-			doc.set_attr(id, "x", String(origin.x + (a.x - origin.x) * sx));
-			doc.set_attr(id, "y", String(origin.y + (a.y - origin.y) * sy));
-			doc.set_attr(id, "width", String(Math.max(.001, a.w * sx)));
-			doc.set_attr(id, "height", String(Math.max(.001, a.h * sy)));
-			break;
-		case "circle": {
-			const s = Math.min(sx, sy);
-			doc.set_attr(id, "cx", String(origin.x + (a.cx - origin.x) * s));
-			doc.set_attr(id, "cy", String(origin.y + (a.cy - origin.y) * s));
-			doc.set_attr(id, "r", String(Math.max(.001, a.r * s)));
-			break;
-		}
-		case "ellipse":
-			doc.set_attr(id, "cx", String(origin.x + (a.cx - origin.x) * sx));
-			doc.set_attr(id, "cy", String(origin.y + (a.cy - origin.y) * sy));
-			doc.set_attr(id, "rx", String(Math.max(.001, a.rx * sx)));
-			doc.set_attr(id, "ry", String(Math.max(.001, a.ry * sy)));
-			break;
-		case "line":
-			doc.set_attr(id, "x1", String(origin.x + (a.x1 - origin.x) * sx));
-			doc.set_attr(id, "y1", String(origin.y + (a.y1 - origin.y) * sy));
-			doc.set_attr(id, "x2", String(origin.x + (a.x2 - origin.x) * sx));
-			doc.set_attr(id, "y2", String(origin.y + (a.y2 - origin.y) * sy));
-			break;
-		case "polyline":
-		case "polygon":
-			doc.set_attr(id, "points", scale_points_string(a.points, origin, sx, sy));
-			break;
-		case "path":
-			doc.set_attr(id, "d", scale_path_d(a.d, origin, sx, sy));
-			break;
-		case "text": {
-			if (!(sx !== 1 && sy !== 1)) return;
-			const s = Math.min(sx, sy);
-			doc.set_attr(id, "x", String(origin.x + (a.x - origin.x) * s));
-			doc.set_attr(id, "y", String(origin.y + (a.y - origin.y) * s));
-			doc.set_attr(id, "font-size", String(Math.max(1, a.fontSize * s)));
-			return;
-		}
-		case "unsupported": return;
-	}
-	if (phase === "commit") renormalize_rotate_pivot(doc, id);
-}
-/**
-* Inspect a node and decide whether the rotate gesture is safe to apply.
-* Used by the rotate-orchestrator at gesture commit to drop the preview
-* with a chip rather than emit a defensible-but-noisy `transform=`.
-*
-* Order of checks matches the order the user is most likely to see; the
-* first failure short-circuits.
-*/
-function is_rotatable(doc, id) {
-	const ops = parse_transform_list(doc.get_attr(id, "transform"));
-	if (ops === null) return {
-		kind: "refuse",
-		reason: "non-trivial-transform"
-	};
-	if (classify(ops) === "mixed") return {
-		kind: "refuse",
-		reason: "non-trivial-transform"
-	};
-	if (doc.tag_of(id) === "text" || doc.tag_of(id) === "tspan") {
-		const text_rotate = doc.get_attr(id, "rotate");
-		if (text_rotate !== null && text_rotate.trim() !== "") return {
-			kind: "refuse",
-			reason: "text-with-glyph-rotate"
-		};
-	}
-	const style = doc.get_attr(id, "style");
-	if (style && /(?:^|;)\s*transform\s*:/i.test(style)) return {
-		kind: "refuse",
-		reason: "css-property-transform"
-	};
-	for (const c of doc.children_of(id)) if (doc.is_element(c) && doc.tag_of(c) === "animateTransform") return {
-		kind: "refuse",
-		reason: "animated-transform"
-	};
-	return { kind: "yes" };
-}
-function find_op(ops, type) {
-	for (const op of ops) if (op.type === type) return op;
-	return null;
-}
-function capture_rotate_baseline(doc, id, pivot) {
-	const transform = doc.get_attr(id, "transform");
-	const ops = parse_transform_list(transform) ?? [];
-	const lead = find_op(ops, "translate");
-	const rot = find_op(ops, "rotate");
-	return {
-		transform,
-		leading_translate: lead ? {
-			x: lead.tx,
-			y: lead.ty
-		} : null,
-		current_rotation_deg: rot?.angle ?? 0,
-		pivot
-	};
-}
-function capture_rotate_baselines(doc, ids, pivot) {
-	const out = /* @__PURE__ */ new Map();
-	for (const id of ids) out.set(id, capture_rotate_baseline(doc, id, pivot));
-	return out;
-}
-const RAD_TO_DEG = 180 / Math.PI;
-/** Snap trailing FP noise off the 10th decimal place. The rad→deg
-*  conversion + addition produce e.g. `29.999999999999996` for what the
-*  user dragged as "30°"; rounding to 1e-9 absorbs the noise without
-*  losing any user-meaningful precision (SVG coordinates rarely go past
-*  4 decimals in authored content).
-*
-*  Limits drift accumulation across a long gesture: each frame's emit
-*  re-renders from `current_rotation_deg + delta_deg`, where the delta
-*  is recomputed against the gesture-start anchor — not accumulated. So
-*  noise stays bounded per-frame. */
-function fmt_angle(n) {
-	return String(Math.round(n * 1e9) / 1e9);
-}
-/**
-* Compose `baseline.current_rotation_deg + degrees(angle_radians)` into a
-* single `rotate(θ_total cx cy)` token, preserving any leading translate
-* the baseline captured. Pivot is expressed in pre-translate local space
-* (`pivot - leading_translate`), which is the correct space for
-* `rotate(θ cx cy)` per SVG 1.1 §7.6.
-*
-* Identity-restore: when angle === 0 AND current_rotation === 0, restore
-* the original `transform=` byte-equal (may have been null). This is the
-* round-trip invariant the "rotated then rotated back" test locks down.
-*/
-function apply_rotate(doc, id, baseline, angle_radians) {
-	const angle_deg = angle_radians * RAD_TO_DEG;
-	const total = baseline.current_rotation_deg + angle_deg;
-	if (total === 0 && angle_deg === 0) {
-		doc.set_attr(id, "transform", baseline.transform);
-		return;
-	}
-	const tx = baseline.leading_translate?.x ?? 0;
-	const ty = baseline.leading_translate?.y ?? 0;
-	const cx = baseline.pivot.x - tx;
-	const cy = baseline.pivot.y - ty;
-	const rotate_token = `rotate(${fmt_angle(total)} ${cx} ${cy})`;
-	const str = baseline.leading_translate ? `translate(${tx} ${ty}) ${rotate_token}` : rotate_token;
-	doc.set_attr(id, "transform", str);
-}
-/**
-* Allows identity, leading-translate-only, and `(translate?) rotate(θ cx cy)`
-* with an explicit 3-arg pivot. Refuses 1-arg `rotate(θ)`: re-emitting it
-* would canonicalize the source and violate P1 round-trip.
-*/
-function is_resizable_node(doc, id) {
-	if (!is_resizable(doc.tag_of(id))) return false;
-	const ops = parse_transform_list(doc.get_attr(id, "transform"));
-	if (ops === null) return false;
-	const cls = classify(ops);
-	if (cls === "identity" || cls === "leading_translate_only") return true;
-	if (cls === "single_rotate_only" || cls === "leading_translate_then_single_rotate") return find_op(ops, "rotate")?.explicit_pivot === true;
-	return false;
-}
-//#endregion
-//#region src/core/translate-pipeline/stages.ts
-/** Bridges `ctx.input.movement` (Movement) → `plan.delta` (Vec2),
-*  collapsing the lesser axis when `axis_lock === "by_dominance"`. */
-const stage_axis_lock = {
-	name: "axis_lock",
-	run(plan, ctx) {
-		const m = ctx.input.movement;
-		const locked = ctx.modifiers.axis_lock === "by_dominance" ? _grida_cmath.default.ext.movement.axisLockedByDominance(m) : m;
-		const [x, y] = _grida_cmath.default.ext.movement.normalize(locked);
-		return { plan: {
-			...plan,
-			delta: {
-				x,
-				y
-			}
-		} };
-	}
-};
-/** Consults `ctx.snap_session` for geometry-aligned correction; emits a
-*  guide per `ctx.snap_policy`. Identity on `force_disable_snap`, missing
-*  session, or `snap_enabled === false`. */
-const stage_snap = {
-	name: "snap",
-	run(plan, ctx) {
-		if (ctx.modifiers.force_disable_snap) return { plan };
-		if (!ctx.snap_session) return { plan };
-		if (!ctx.options.snap_enabled) return { plan };
-		const r = ctx.snap_session.snap(plan.delta, {
-			enabled: true,
-			threshold_px: ctx.options.snap_threshold_px
-		}, ctx.snap_policy);
-		return {
-			plan: {
-				...plan,
-				delta: r.delta
-			},
-			emit: r.guide ? { guide: r.guide } : void 0
-		};
-	}
-};
-/** Quantizes the agent-union origin + plan.delta to integer multiples
-*  of `options.pixel_grid_quantum`. Anchor comes from the snap session
-*  when open; falls back to `baseline_union_top_left` (RPC path).
-*  Identity when quantum is `null` or `<= 0`. */
-const stage_pixel_grid = {
-	name: "pixel_grid",
-	run(plan, ctx) {
-		const q = ctx.options.pixel_grid_quantum;
-		if (q === null || q <= 0) return { plan };
-		const anchor = ctx.snap_session?.baseline_union_readonly ?? baseline_union_top_left(plan.baselines);
-		if (!anchor) return { plan };
-		const qx = Math.round((anchor.x + plan.delta.x) / q) * q - anchor.x;
-		const qy = Math.round((anchor.y + plan.delta.y) / q) * q - anchor.y;
-		return { plan: {
-			...plan,
-			delta: {
-				x: qx,
-				y: qy
-			}
-		} };
-	}
-};
-const STAGES_DEFAULT$1 = Object.freeze([
-	stage_axis_lock,
-	stage_snap,
-	stage_pixel_grid
-]);
-const STAGES_NUDGE = Object.freeze([stage_axis_lock, stage_pixel_grid]);
-const STAGES_RPC$1 = Object.freeze([stage_axis_lock]);
-//#endregion
-//#region src/core/translate-pipeline/apply.ts
-/** Apply the plan: for each id, run `apply_translate` with the
-*  baseline + world-space delta. Does NOT emit; caller wraps with
-*  history machinery and calls `emit()` after. */
-function applyTranslatePlan(doc, plan) {
-	for (const id of plan.ids) {
-		const baseline = plan.baselines.get(id);
-		if (!baseline) continue;
-		apply_translate(doc, id, baseline, plan.delta.x, plan.delta.y);
-	}
-}
-/** Reset each id to its baseline (delta = 0). Used by undo closures. */
-function revertTranslatePlan(doc, plan) {
-	for (const id of plan.ids) {
-		const baseline = plan.baselines.get(id);
-		if (!baseline) continue;
-		apply_translate(doc, id, baseline, 0, 0);
-	}
-}
-/** Prepare a one-shot, headless translate. Captures baselines, runs
-*  the pipeline with `stages` (default `STAGES_RPC`), returns ready-to-
-*  record closures. Caller wraps in history (e.g. `history.atomic`).
-*  See `./README.md` for the per-caller stage lists. */
-function prepare_translate_rpc(args) {
-	const { doc, ids, delta, options, emit, stages = STAGES_RPC$1 } = args;
-	const filtered_ids = doc.prune_nested_nodes(ids);
-	const plan0 = {
-		ids: filtered_ids,
-		baselines: capture_translate_baselines(doc, filtered_ids),
-		delta: {
-			x: 0,
-			y: 0
-		}
-	};
-	const { plan } = run_translate_pipeline(plan0, stages, {
-		input: {
-			ids: plan0.ids,
-			movement: [delta.x, delta.y]
-		},
-		modifiers: {
-			axis_lock: "off",
-			force_disable_snap: true
-		},
-		options,
-		snap_session: null,
-		snap_policy: "engine"
-	});
-	return {
-		plan,
-		apply: () => {
-			applyTranslatePlan(doc, plan);
-			emit();
-		},
-		revert: () => {
-			revertTranslatePlan(doc, plan);
-			emit();
-		}
-	};
-}
-//#endregion
-//#region src/core/translate-pipeline/orchestrator.ts
-const PROVIDER_ID$1 = "svg-editor";
-var TranslateOrchestrator = class {
-	constructor(deps) {
-		this.deps = deps;
-		this.active = null;
-		this._last_guides = [];
-	}
-	/** Guides emitted by the most recent pipeline run. Cleared on
-	*  cancel/dispose. HUD compositors read this to draw snap chrome. */
-	get last_guides() {
-		return this._last_guides;
-	}
-	/** True while a gesture session is open. */
-	has_active_session() {
-		return this.active !== null;
-	}
-	/** Per-frame drive: lazily opens a session on first call, runs the
-	*  pipeline, writes apply/revert into the preview, and commits when
-	*  `opts.phase === "commit"`. */
-	drive(input, modifiers, opts) {
-		if (this.active === null) this.active = this.open(input.ids, opts.snap, opts.label ?? "move");
-		const session = this.active;
-		const stages = opts.stages ?? STAGES_DEFAULT$1;
-		const result = this.run_pass(session, input.movement, modifiers, opts.policy, stages);
-		session.last_movement = input.movement;
-		session.last_policy = opts.policy;
-		session.last_stages = stages;
-		this.write_preview_delta(session, result.plan);
-		if (opts.phase === "commit") {
-			session.preview.commit();
-			this.dispose_session();
-		}
-		return result;
-	}
-	/** Re-run the current preview frame with new modifiers, reusing the
-	*  last-known movement / policy / stages. Used when a modifier key
-	*  changes between pointer-move events (Shift down/up mid-drag).
-	*  No-op when no session is active. */
-	redrive_modifiers(modifiers) {
-		if (!this.active) return null;
-		const session = this.active;
-		const result = this.run_pass(session, session.last_movement, modifiers, session.last_policy, session.last_stages);
-		this.write_preview_delta(session, result.plan);
-		return result;
-	}
-	/** Cancel an in-flight gesture (Escape, programmatic abort). */
-	cancel() {
-		if (!this.active) return;
-		this.active.preview.discard();
-		this.dispose_session();
-	}
-	/** Build a plan + context, run the pipeline, stash guides. Pure
-	*  computation — does not touch the preview. */
-	run_pass(session, movement, modifiers, policy, stages) {
-		const result = run_translate_pipeline({
-			ids: session.ids,
-			baselines: session.baselines,
-			delta: {
-				x: 0,
-				y: 0
-			}
-		}, stages, {
-			input: {
-				ids: session.ids,
-				movement
-			},
-			modifiers,
-			options: this.deps.options(),
-			snap_session: session.snap,
-			snap_policy: policy
-		});
-		this._last_guides = result.guides;
-		return result;
-	}
-	open(ids, snap, label) {
-		const doc = this.deps.get_doc();
-		const filtered = doc.prune_nested_nodes(ids);
-		return {
-			ids: filtered,
-			baselines: capture_translate_baselines(doc, filtered),
-			snap: snap ? this.deps.open_snap(filtered) : null,
-			preview: this.deps.open_preview(label),
-			last_movement: [0, 0],
-			last_policy: "engine",
-			last_stages: STAGES_DEFAULT$1
-		};
-	}
-	/** Bind a fresh apply/revert pair (closure over `plan`) into the
-	*  preview slot. Called from both `drive` (per pointer frame) and
-	*  `redrive_modifiers` (on modifier flip). */
-	write_preview_delta(session, plan) {
-		const doc = this.deps.get_doc();
-		const emit = this.deps.emit;
-		session.preview.set({
-			providerId: PROVIDER_ID$1,
-			apply: () => {
-				applyTranslatePlan(doc, plan);
-				emit();
-			},
-			revert: () => {
-				revertTranslatePlan(doc, plan);
-				emit();
-			}
-		});
-	}
-	dispose_session() {
-		if (!this.active) return;
-		this.active.snap?.dispose();
-		this.active = null;
-		this._last_guides = [];
-	}
-};
-//#endregion
-//#region src/core/translate-pipeline/nudge-dwell-watcher.ts
-/** Hold-time after the last firing detection. Show is immediate (next
-*  frame); only the hide edge is delayed. */
-const HIDE_MS = 500;
-var NudgeDwellWatcher = class {
-	constructor(deps) {
-		this.deps = deps;
-		this._guides = [];
-		this.raf_id = null;
-		this.hide_timer = null;
-		this.unsubscribe = deps.editor.subscribe_translate_commit(() => this.schedule_detect());
-	}
-	/** Currently-published dwell guides. Empty between detections. */
-	get guides() {
-		return this._guides;
-	}
-	/** Drop any pending detection / held guide. Idempotent. */
-	cancel_pending() {
-		this.clear_raf();
-		this.clear_hide();
-		this.publish_guides([]);
-	}
-	dispose() {
-		this.unsubscribe();
-		this.cancel_pending();
-	}
-	schedule_detect() {
-		if (this.raf_id !== null) return;
-		this.raf_id = this.deps.window.requestAnimationFrame(() => {
-			this.raf_id = null;
-			this.detect();
-		});
-	}
-	detect() {
-		const ids = this.deps.editor.state.selection;
-		if (ids.length === 0) {
-			this.publish_guides([]);
-			this.clear_hide();
-			return;
-		}
-		const snap = this.deps.open_snap(ids);
-		if (!snap) {
-			this.publish_guides([]);
-			this.clear_hide();
-			return;
-		}
-		try {
-			const plan0 = {
-				ids: [...ids],
-				baselines: capture_translate_baselines(this.deps.editor.document, ids),
-				delta: {
-					x: 0,
-					y: 0
-				}
-			};
-			const result = run_translate_pipeline(plan0, STAGES_DEFAULT$1, {
-				input: {
-					ids: plan0.ids,
-					movement: [0, 0]
-				},
-				modifiers: {
-					axis_lock: "off",
-					force_disable_snap: false
-				},
-				options: this.deps.options(),
-				snap_session: snap,
-				snap_policy: "aligned"
-			});
-			if (result.guides.length === 0) {
-				this.publish_guides([]);
-				this.clear_hide();
-				return;
-			}
-			this.publish_guides(result.guides);
-			this.arm_hide();
-		} finally {
-			snap.dispose();
-		}
-	}
-	arm_hide() {
-		this.clear_hide();
-		this.hide_timer = this.deps.window.setTimeout(() => {
-			this.hide_timer = null;
-			this.publish_guides([]);
-		}, HIDE_MS);
-	}
-	publish_guides(next) {
-		if (next.length === 0 && this._guides.length === 0) return;
-		this._guides = next;
-		this.deps.on_guides_change();
-	}
-	clear_raf() {
-		if (this.raf_id === null) return;
-		this.deps.window.cancelAnimationFrame(this.raf_id);
-		this.raf_id = null;
-	}
-	clear_hide() {
-		if (this.hide_timer === null) return;
-		this.deps.window.clearTimeout(this.hide_timer);
-		this.hide_timer = null;
-	}
-};
-//#endregion
-//#region src/core/rotate-pipeline/pipeline.ts
-/** The funnel. Threads `plan` through `stages` in order. Pure: same
-*  inputs → same outputs. */
-function run_rotate_pipeline(init, stages, _ctx) {
-	let plan = init;
-	for (const stage of stages) plan = stage.run(plan, _ctx).plan;
-	return { plan };
-}
-/** Default stage list for HUD-driven rotate gestures (drag). */
-const STAGES_DEFAULT = Object.freeze([{
-	name: "angle_snap",
-	run(plan, ctx) {
-		if (ctx.modifiers.force_disable_snap) return { plan };
-		if (ctx.modifiers.angle_snap !== "step") return { plan };
-		const step = ctx.options.angle_snap_step_radians;
-		if (step === null || step <= 0) return { plan };
-		const snapped = Math.round(plan.angle_radians / step) * step;
-		return { plan: {
-			...plan,
-			angle_radians: snapped
-		} };
-	}
-}]);
-/** Stage list for headless RPC paths (`commands.rotate`, `rotate_to`).
-*  No snap — the caller passed an exact angle on purpose. */
-const STAGES_RPC = Object.freeze([]);
-//#endregion
-//#region src/core/rotate-pipeline/apply.ts
-function applyRotatePlan(doc, plan) {
-	for (const m of plan.members) apply_rotate(doc, m.id, m.baseline, plan.angle_radians);
-}
-/** Reset each member to its baseline rotation (angle_radians = 0). Used
-*  by undo closures. Identity-restore byte-equality kicks in when the
-*  baseline had no pre-existing rotation. */
-function revertRotatePlan(doc, plan) {
-	for (const m of plan.members) apply_rotate(doc, m.id, m.baseline, 0);
-}
-/** Headless one-shot rotate. Captures per-member baselines around the
-*  shared pivot, runs the pipeline with `stages` (default `STAGES_RPC`),
-*  returns ready-to-record closures + per-member refusal verdicts. The
-*  caller wraps the closures in history (e.g. `history.atomic`).
-*
-*  Verdicts: if any member returns `kind: "refuse"`, the caller SHOULD
-*  drop the gesture and emit a chip instead of committing. The `apply`
-*  closure here doesn't gate on verdicts — that's a policy decision at
-*  the call site (a programmatic `commands.rotate` may still want to
-*  force-write through; the interactive path does not). */
-function prepare_rotate_rpc(args) {
-	const { doc, ids, pivot, angle_radians, options, emit, stages = STAGES_RPC } = args;
-	const filtered_ids = doc.prune_nested_nodes(ids);
-	const baselines = capture_rotate_baselines(doc, filtered_ids, pivot);
-	const members = filtered_ids.map((id) => ({
-		id,
-		baseline: baselines.get(id)
-	}));
-	const verdicts = /* @__PURE__ */ new Map();
-	for (const id of filtered_ids) verdicts.set(id, is_rotatable(doc, id));
-	const { plan } = run_rotate_pipeline({
-		members,
-		pivot,
-		angle_radians
-	}, stages, {
-		input: {
-			ids: filtered_ids,
-			angle_radians
-		},
-		modifiers: {
-			angle_snap: "off",
-			force_disable_snap: true
-		},
-		options
-	});
-	return {
-		plan,
-		verdicts,
-		apply: () => {
-			applyRotatePlan(doc, plan);
-			emit();
-		},
-		revert: () => {
-			revertRotatePlan(doc, plan);
-			emit();
-		}
-	};
-}
-//#endregion
-//#region src/core/rotate-pipeline/orchestrator.ts
-const PROVIDER_ID = "svg-editor";
-function ids_key(ids) {
-	return [...ids].sort().join("\0");
-}
-var RotateOrchestrator = class {
-	constructor(deps) {
-		this.deps = deps;
-		this.active = null;
-	}
-	has_active_session() {
-		return this.active !== null;
-	}
-	is_active_for(ids) {
-		return this.active !== null && this.active.ids_key === ids_key(ids);
-	}
-	/** Per-frame drive. Opens a session lazily on the first call. Returns
-	*  `null` when `ids` is empty. On commit, returns a `RotateCommitOutcome`
-	*  the caller uses to surface refusal chips. */
-	drive(input, modifiers, opts) {
-		if (input.ids.length === 0) return null;
-		const key = ids_key(input.ids);
-		if (this.active && this.active.ids_key !== key) {
-			this.active.preview.discard();
-			this.dispose_session();
-		}
-		if (this.active === null) this.active = this.open(input.ids, opts.label ?? "rotate");
-		const session = this.active;
-		const stages = opts.stages ?? STAGES_DEFAULT;
-		const result = this.run_pass(session, input.angle_radians, modifiers, stages);
-		session.last_angle = input.angle_radians;
-		session.last_stages = stages;
-		this.write_preview(session, result.plan);
-		if (opts.phase === "commit") {
-			let outcome;
-			let refused = false;
-			for (const v of session.verdicts.values()) if (v.kind === "refuse") {
-				refused = true;
-				break;
-			}
-			if (refused) {
-				session.preview.discard();
-				outcome = {
-					kind: "refused",
-					verdicts: session.verdicts
-				};
-			} else {
-				session.preview.commit();
-				outcome = {
-					kind: "committed",
-					plan: result.plan
-				};
-			}
-			this.dispose_session();
-			return {
-				result,
-				outcome
-			};
-		}
-		return {
-			result,
-			outcome: null
-		};
-	}
-	redrive_modifiers(modifiers) {
-		if (!this.active) return null;
-		const session = this.active;
-		const result = this.run_pass(session, session.last_angle, modifiers, session.last_stages);
-		this.write_preview(session, result.plan);
-		return result;
-	}
-	cancel() {
-		if (!this.active) return;
-		this.active.preview.discard();
-		this.dispose_session();
-	}
-	run_pass(session, angle_radians, modifiers, stages) {
-		return run_rotate_pipeline({
-			members: session.members,
-			pivot: session.pivot,
-			angle_radians
-		}, stages, {
-			input: {
-				ids: session.members.map((m) => m.id),
-				angle_radians
-			},
-			modifiers,
-			options: this.deps.options()
-		});
-	}
-	open(ids, label) {
-		const doc = this.deps.get_doc();
-		const filtered = doc.prune_nested_nodes(ids);
-		const pivot = compute_union_center(filtered, this.deps.bbox_world);
-		const baselines = capture_rotate_baselines(doc, filtered, pivot);
-		const members = filtered.map((id) => ({
-			id,
-			baseline: baselines.get(id)
-		}));
-		const verdicts = /* @__PURE__ */ new Map();
-		for (const id of filtered) verdicts.set(id, is_rotatable(doc, id));
-		return {
-			ids_key: ids_key(ids),
-			members,
-			pivot,
-			verdicts,
-			preview: this.deps.open_preview(label),
-			last_angle: 0,
-			last_stages: STAGES_DEFAULT
-		};
-	}
-	write_preview(session, plan) {
-		const doc = this.deps.get_doc();
-		const emit = this.deps.emit;
-		session.preview.set({
-			providerId: PROVIDER_ID,
-			apply: () => {
-				applyRotatePlan(doc, plan);
-				emit();
-			},
-			revert: () => {
-				revertRotatePlan(doc, plan);
-				emit();
-			}
-		});
-	}
-	dispose_session() {
-		this.active = null;
-	}
-};
-function compute_union_center(ids, bbox_world) {
-	const rects = ids.map(bbox_world);
-	const u = _grida_cmath.default.rect.union(rects);
-	return {
-		x: u.x + u.width / 2,
-		y: u.y + u.height / 2
-	};
-}
-//#endregion
-//#region src/core/paint.ts
-/**
-* Parse a *computed* paint string into the discriminated union. Returns null
-* for `inherit` / `var()` / empty. Returns an invalid-computed-value record
-* for syntactic errors (rare; we're permissive).
-*/
-function parse_paint(declared) {
-	if (declared === null || declared === "") return null;
-	const trimmed = declared.trim();
-	if (trimmed === "") return null;
-	if (trimmed === "inherit" || trimmed === "initial" || trimmed === "unset" || trimmed === "revert" || trimmed === "revert-layer") return null;
-	if (/^var\s*\(/i.test(trimmed)) return {
-		error: "invalid_at_computed_value_time",
-		reason: "var() substitution requires a cascade engine (not implemented)"
-	};
-	if (trimmed === "none") return { kind: "none" };
-	if (trimmed === "context-fill" || trimmed === "contextFill") return { kind: "context_fill" };
-	if (trimmed === "context-stroke" || trimmed === "contextStroke") return { kind: "context_stroke" };
-	const url_match = trimmed.match(/^url\(\s*(["']?)#([^)"']+)\1\s*\)\s*(.*)$/i);
-	if (url_match) {
-		const id = url_match[2];
-		const rest = url_match[3].trim();
-		let fallback;
-		if (rest !== "") {
-			const f = parse_paint(rest);
-			if (f && f.kind === "none") fallback = { kind: "none" };
-			else if (f && f.kind === "color") fallback = {
-				kind: "color",
-				value: f.value
-			};
-		}
-		return fallback ? {
-			kind: "ref",
-			id,
-			fallback
-		} : {
-			kind: "ref",
-			id
-		};
-	}
-	if (/^currentcolor$/i.test(trimmed)) return {
-		kind: "color",
-		value: { kind: "current_color" }
-	};
-	return {
-		kind: "color",
-		value: {
-			kind: "rgb",
-			value: trimmed
-		}
-	};
-}
-/** Serialize a Paint back to an SVG attribute / inline-style value. */
-function serialize_paint(paint) {
-	switch (paint.kind) {
-		case "none": return "none";
-		case "context_fill": return "context-fill";
-		case "context_stroke": return "context-stroke";
-		case "color": return paint.value.kind === "current_color" ? "currentColor" : paint.value.value;
-		case "ref":
-			if (paint.fallback) {
-				const f = paint.fallback.kind === "none" ? "none" : paint.fallback.value.kind === "current_color" ? "currentColor" : paint.fallback.value.value;
-				return `url(#${paint.id}) ${f}`;
-			}
-			return `url(#${paint.id})`;
-	}
-}
-//#endregion
-//#region src/types.ts
-const TOOL_CURSOR = { type: "cursor" };
-const DEFAULT_STYLE = {
-	chrome_color: "#2563eb",
-	handle_size: 8,
-	handle_fill: "#ffffff",
-	handle_stroke: "#2563eb",
-	endpoint_dot_radius: 5,
-	selection_outline_width: 2,
-	measurement_color: "#ff3a30",
-	show_size_meter: true,
-	snap_enabled: true,
-	snap_threshold_px: 6,
-	hit_tolerance_px: 0,
-	snap_to_pixel_grid: false,
-	pixel_grid_size: 1,
-	pixel_grid: true,
-	angle_snap_step_radians: Math.PI / 12
-};
-/** v1 default fill — gray so newly-drawn shapes are visible against white.
-*  Matches the main canvas convention. A future preset may override. */
-const DEFAULT_FILL = "#D9D9D9";
-/**
-* Initial attrs for the moment of pointer-down — zero-size at the click
-* point. Seeds the pending node before any drag movement so the HUD
-* selection chrome can render a (zero-size) box without a flicker.
-*
-* Per tag:
-*  - rect    → x = px, y = py, width = 0, height = 0
-*  - ellipse → cx = px, cy = py, rx = 0, ry = 0
-*  - line    → x1 = x2 = px, y1 = y2 = py
-*/
-function initial_attrs(tag, point) {
-	switch (tag) {
-		case "rect": return {
-			x: fmt(point.x),
-			y: fmt(point.y),
-			width: "0",
-			height: "0"
-		};
-		case "ellipse": return {
-			cx: fmt(point.x),
-			cy: fmt(point.y),
-			rx: "0",
-			ry: "0"
-		};
-		case "line": return {
-			x1: fmt(point.x),
-			y1: fmt(point.y),
-			x2: fmt(point.x),
-			y2: fmt(point.y)
-		};
-	}
-}
-/**
-* Attrs for click-no-drag commit — default-sized shape centered on the
-* click point. (Rect's `x`/`y` are top-left in SVG, so we offset by
-* `size/2` to center; ellipse's `cx`/`cy` are already center.)
-*/
-function default_attrs(tag, point, size = 100) {
-	switch (tag) {
-		case "rect": return {
-			x: fmt(point.x - size / 2),
-			y: fmt(point.y - size / 2),
-			width: fmt(size),
-			height: fmt(size)
-		};
-		case "ellipse": return {
-			cx: fmt(point.x),
-			cy: fmt(point.y),
-			rx: fmt(size / 2),
-			ry: fmt(size / 2)
-		};
-		case "line": return {
-			x1: fmt(point.x - size / 2),
-			y1: fmt(point.y),
-			x2: fmt(point.x + size / 2),
-			y2: fmt(point.y)
-		};
-	}
-}
-/**
-* Drag math — pure. Given anchor + current + modifiers, returns geometry
-* attrs for the in-progress node.
-*
-* Per-tag rules:
-*  - rect    → x / y / width / height
-*      Shift: width === height (the larger of the two deltas wins, signs
-*             preserved so the rect can still flip across the anchor).
-*      Alt:   anchor is treated as center; rect grows symmetrically.
-*  - ellipse → cx / cy / rx / ry
-*      Shift: rx === ry (uniform circle).
-*      Alt:   anchor is treated as center (default for ellipse anyway —
-*             Alt makes the anchor act as center even when Shift is on).
-*      Without Alt the anchor is one corner of the ellipse's bbox; with
-*      Alt the anchor is the center.
-*  - line    → x1 / y1 / x2 / y2
-*      Shift: angle quantized to 0° / 45° / 90°.
-*      Alt:   anchor is the midpoint of the line (mirror the drag).
-*/
-function compute_drag_attrs(tag, anchor, current, modifiers) {
-	switch (tag) {
-		case "rect": return rect_attrs(anchor, current, modifiers);
-		case "ellipse": return ellipse_attrs(anchor, current, modifiers);
-		case "line": return line_attrs(anchor, current, modifiers);
-	}
-}
-/** Default paint attrs for a freshly-inserted shape. v1: gray fill, no
-*  stroke. Line gets a stroke (otherwise it's invisible — `<line>` has no
-*  fill area). Hard-coded for v1; a future preset may swap these. */
-function default_paint_attrs(tag) {
-	switch (tag) {
-		case "rect":
-		case "ellipse": return { fill: DEFAULT_FILL };
-		case "line": return {
-			stroke: "#000000",
-			"stroke-width": "1"
-		};
-	}
-}
-function rect_attrs(anchor, current, mods) {
-	let dx = current.x - anchor.x;
-	let dy = current.y - anchor.y;
-	if (mods.shift) {
-		const m = Math.max(Math.abs(dx), Math.abs(dy));
-		dx = dx < 0 ? -m : m;
-		dy = dy < 0 ? -m : m;
-	}
-	let x;
-	let y;
-	let w;
-	let h;
-	if (mods.alt) {
-		x = anchor.x - Math.abs(dx);
-		y = anchor.y - Math.abs(dy);
-		w = Math.abs(dx) * 2;
-		h = Math.abs(dy) * 2;
-	} else {
-		x = Math.min(anchor.x, anchor.x + dx);
-		y = Math.min(anchor.y, anchor.y + dy);
-		w = Math.abs(dx);
-		h = Math.abs(dy);
-	}
-	return {
-		x: fmt(x),
-		y: fmt(y),
-		width: fmt(w),
-		height: fmt(h)
-	};
-}
-function ellipse_attrs(anchor, current, mods) {
-	let dx = current.x - anchor.x;
-	let dy = current.y - anchor.y;
-	if (mods.shift) {
-		const m = Math.max(Math.abs(dx), Math.abs(dy));
-		dx = dx < 0 ? -m : m;
-		dy = dy < 0 ? -m : m;
-	}
-	let cx;
-	let cy;
-	let rx;
-	let ry;
-	if (mods.alt) {
-		cx = anchor.x;
-		cy = anchor.y;
-		rx = Math.abs(dx);
-		ry = Math.abs(dy);
-	} else {
-		cx = anchor.x + dx / 2;
-		cy = anchor.y + dy / 2;
-		rx = Math.abs(dx) / 2;
-		ry = Math.abs(dy) / 2;
-	}
-	return {
-		cx: fmt(cx),
-		cy: fmt(cy),
-		rx: fmt(rx),
-		ry: fmt(ry)
-	};
-}
-function line_attrs(anchor, current, mods) {
-	let dx = current.x - anchor.x;
-	let dy = current.y - anchor.y;
-	if (mods.shift) {
-		const len = Math.hypot(dx, dy);
-		if (len > 0) {
-			const angle = Math.atan2(dy, dx);
-			const step = Math.PI / 4;
-			const quantized = Math.round(angle / step) * step;
-			dx = Math.cos(quantized) * len;
-			dy = Math.sin(quantized) * len;
-		}
-	}
-	let x1;
-	let y1;
-	let x2;
-	let y2;
-	if (mods.alt) {
-		x1 = anchor.x - dx;
-		y1 = anchor.y - dy;
-		x2 = anchor.x + dx;
-		y2 = anchor.y + dy;
-	} else {
-		x1 = anchor.x;
-		y1 = anchor.y;
-		x2 = anchor.x + dx;
-		y2 = anchor.y + dy;
-	}
-	return {
-		x1: fmt(x1),
-		y1: fmt(y1),
-		x2: fmt(x2),
-		y2: fmt(y2)
-	};
-}
-/** Format a numeric value for SVG attr output. Rounds to 4 decimals to
-*  suppress IEEE-754 noise (`0.30000000000000004` → `0.3`); `String()`
-*  drops trailing zeros and the decimal point for integers. */
-function fmt(n) {
-	return String(Math.round(n * 1e4) / 1e4);
-}
-//#endregion
-Object.defineProperty(exports, "DEFAULT_STYLE", {
-	enumerable: true,
-	get: function() {
-		return DEFAULT_STYLE;
-	}
-});
-Object.defineProperty(exports, "NudgeDwellWatcher", {
-	enumerable: true,
-	get: function() {
-		return NudgeDwellWatcher;
-	}
-});
-Object.defineProperty(exports, "RotateOrchestrator", {
-	enumerable: true,
-	get: function() {
-		return RotateOrchestrator;
-	}
-});
-Object.defineProperty(exports, "STAGES_NUDGE", {
-	enumerable: true,
-	get: function() {
-		return STAGES_NUDGE;
-	}
-});
-Object.defineProperty(exports, "STRUCTURAL_GRAPHICS_SET", {
-	enumerable: true,
-	get: function() {
-		return STRUCTURAL_GRAPHICS_SET;
-	}
-});
-Object.defineProperty(exports, "TOOL_CURSOR", {
-	enumerable: true,
-	get: function() {
-		return TOOL_CURSOR;
-	}
-});
-Object.defineProperty(exports, "TranslateOrchestrator", {
-	enumerable: true,
-	get: function() {
-		return TranslateOrchestrator;
-	}
-});
-Object.defineProperty(exports, "__exportAll", {
-	enumerable: true,
-	get: function() {
-		return __exportAll;
-	}
-});
-Object.defineProperty(exports, "__toESM", {
-	enumerable: true,
-	get: function() {
-		return __toESM;
-	}
-});
-Object.defineProperty(exports, "apply_resize", {
-	enumerable: true,
-	get: function() {
-		return apply_resize;
-	}
-});
-Object.defineProperty(exports, "apply_rotate", {
-	enumerable: true,
-	get: function() {
-		return apply_rotate;
-	}
-});
-Object.defineProperty(exports, "apply_translate", {
-	enumerable: true,
-	get: function() {
-		return apply_translate;
-	}
-});
-Object.defineProperty(exports, "capture_resize_baseline", {
-	enumerable: true,
-	get: function() {
-		return capture_resize_baseline;
-	}
-});
-Object.defineProperty(exports, "capture_translate_baseline", {
-	enumerable: true,
-	get: function() {
-		return capture_translate_baseline;
-	}
-});
-Object.defineProperty(exports, "compute_drag_attrs", {
-	enumerable: true,
-	get: function() {
-		return compute_drag_attrs;
-	}
-});
-Object.defineProperty(exports, "compute_resize_factors", {
-	enumerable: true,
-	get: function() {
-		return compute_resize_factors;
-	}
-});
-Object.defineProperty(exports, "default_attrs", {
-	enumerable: true,
-	get: function() {
-		return default_attrs;
-	}
-});
-Object.defineProperty(exports, "default_paint_attrs", {
-	enumerable: true,
-	get: function() {
-		return default_paint_attrs;
-	}
-});
-Object.defineProperty(exports, "emit_transform_list", {
-	enumerable: true,
-	get: function() {
-		return emit_transform_list;
-	}
-});
-Object.defineProperty(exports, "hit_shape_of_doc", {
-	enumerable: true,
-	get: function() {
-		return hit_shape_of_doc;
-	}
-});
-Object.defineProperty(exports, "initial_attrs", {
-	enumerable: true,
-	get: function() {
-		return initial_attrs;
-	}
-});
-Object.defineProperty(exports, "is_resizable", {
-	enumerable: true,
-	get: function() {
-		return is_resizable;
-	}
-});
-Object.defineProperty(exports, "is_resizable_node", {
-	enumerable: true,
-	get: function() {
-		return is_resizable_node;
-	}
-});
-Object.defineProperty(exports, "is_text_input_focused", {
-	enumerable: true,
-	get: function() {
-		return is_text_input_focused;
-	}
-});
-Object.defineProperty(exports, "is_transparent_tag", {
-	enumerable: true,
-	get: function() {
-		return is_transparent_tag;
-	}
-});
-Object.defineProperty(exports, "parse_paint", {
-	enumerable: true,
-	get: function() {
-		return parse_paint;
-	}
-});
-Object.defineProperty(exports, "parse_transform_list", {
-	enumerable: true,
-	get: function() {
-		return parse_transform_list;
-	}
-});
-Object.defineProperty(exports, "plan_group", {
-	enumerable: true,
-	get: function() {
-		return plan_group;
-	}
-});
-Object.defineProperty(exports, "prepare_rotate_rpc", {
-	enumerable: true,
-	get: function() {
-		return prepare_rotate_rpc;
-	}
-});
-Object.defineProperty(exports, "prepare_translate_rpc", {
-	enumerable: true,
-	get: function() {
-		return prepare_translate_rpc;
-	}
-});
-Object.defineProperty(exports, "project_local_bbox", {
-	enumerable: true,
-	get: function() {
-		return project_local_bbox;
-	}
-});
-Object.defineProperty(exports, "serialize_paint", {
-	enumerable: true,
-	get: function() {
-		return serialize_paint;
-	}
-});