@grida/svg-editor 1.0.0-alpha.15 → 1.0.0-alpha.17

package/dist/{dom-Dee6FtgZ.js → dom-CaByuo6C.js}

@@ -1,4 +1,4 @@
-const require_model = require("./model-CJ1Ctq14.js");
+const require_model = require("./model-GpysNbOv.js");
 let _grida_cmath = require("@grida/cmath");
 _grida_cmath = require_model.__toESM(_grida_cmath);
 let _grida_svg_parse = require("@grida/svg/parse");
@@ -1007,15 +1007,18 @@ function create_attention_tracker(container) {
 	};
 	container.addEventListener("pointerenter", on_enter);
 	container.addEventListener("pointerleave", on_leave);
-	const is_attended = () => {
+	const is_focus_within = () => {
 		const owner = container.ownerDocument;
-		if (!owner) return pointer_over;
+		if (!owner) return false;
 		const active = owner.activeElement;
-		if (active && active !== owner.body && container.contains(active)) return true;
-		return pointer_over;
+		return !!active && active !== owner.body && container.contains(active);
+	};
+	const is_attended = () => {
+		return is_focus_within() || pointer_over;
 	};
 	return {
 		is_attended,
+		is_focus_within,
 		dispose: () => {
 			container.removeEventListener("pointerenter", on_enter);
 			container.removeEventListener("pointerleave", on_leave);
@@ -1640,6 +1643,48 @@ const IS_MODIFIER_KEY = {
 *  live `<text>` element out from under the about-to-mount text surface. */
 const TEXT_EDIT_PENDING = { __pending: true };
 /**
+* Wire a web-font settle source to the editor's geometry channel.
+*
+* The DOM surface re-serializes the `<svg>` on every editor tick, but a
+* `<text>` / `<tspan>` bbox can change with NO attribute write: a web font
+* finishing load AFTER its `font-family` / `font-size` was already written.
+* The IR never sees that reflow, so nothing bumps `geometry_version` and
+* every bounds-keyed consumer (snap, HUD chrome, size meter) stays stuck at
+* the fallback-face metrics until the next real edit.
+*
+* Listens for `loadingdone` on `source` (a `FontFaceSet`, or any injected
+* `EventTarget` in tests) and calls `bump` once per settle. COARSE on
+* purpose: one bump clears the WHOLE bounds cache, not just text nodes —
+* consistent with the package's pessimistic-invalidation stance, and far
+* cheaper than scoping the bump to the (possibly many) reflowed runs.
+*
+* Also bumps once when `source.ready` resolves (when present): fonts that
+* settled before attach — a cache hit, or `font-display` resolving the same
+* tick the surface mounts — never re-fire `loadingdone`, so a document
+* mounted post-settle still needs one bump to re-read at the real metrics.
+*
+* Returns a teardown that removes the listener and neutralizes the pending
+* `ready` bump (leak guard) — call it on surface detach.
+*
+* Factored out of the surface so it can be unit-tested with a fake
+* `EventTarget` in the node-only test env (jsdom's `FontFaceSet` is
+* incomplete); never a real font / network.
+*/
+function install_font_load_geometry_bump(source, bump) {
+	if (!source) return () => {};
+	const on_fonts_settled = () => bump();
+	source.addEventListener("loadingdone", on_fonts_settled);
+	let alive = true;
+	const ready = source.ready;
+	if (ready && typeof ready.then === "function") ready.then(() => {
+		if (alive) bump();
+	});
+	return () => {
+		alive = false;
+		source.removeEventListener("loadingdone", on_fonts_settled);
+	};
+}
+/**
 * Attach a DOM surface to a headless editor. Returns a `DomSurfaceHandle`
 * whose `detach()` is the inverse — DOM cleared, listeners removed,
 * gestures uninstalled.
@@ -1665,6 +1710,7 @@ var DomSurface = class DomSurface {
 		this.svg_root = null;
 		this.teardown = [];
 		this.element_index = /* @__PURE__ */ new Map();
+		this.rendered_doc_revision = -1;
 		this.last_pointer = {
 			x: 0,
 			y: 0
@@ -1689,6 +1735,7 @@ var DomSurface = class DomSurface {
 		this.container = options.container;
 		const container = this.container;
 		this.fit_on_attach = options.fit === true;
+		this.clipboard_enabled = options.clipboard !== false;
 		this.attention = create_attention_tracker(container);
 		this.teardown.push(() => this.attention.dispose());
 		if (process.env.NODE_ENV !== "production" && container.children.length > 0) console.warn("@grida/svg-editor: surface container is not empty at attach time. Render chrome (toolbars, layer lists, inspectors) as siblings of the container, not children — otherwise clicks on those children will silently break. See README §Surface.");
@@ -1696,6 +1743,8 @@ var DomSurface = class DomSurface {
 		container.style.overflow = "hidden";
 		container.style.userSelect = "none";
 		container.style.webkitUserSelect = "none";
+		container.tabIndex = -1;
+		container.style.outline = "none";
 		const translate_options = () => {
 			const style = this.editor.style;
 			const zoom = this.camera.zoom || 1;
@@ -1711,7 +1760,9 @@ var DomSurface = class DomSurface {
 			open_preview: (label) => this.editor_internal().history.preview(label),
 			open_snap: (ids) => this.open_snap_session_for(ids),
 			options: translate_options,
-			project_delta: (id, d) => this._geometry_provider?.world_delta_to_local(id, d) ?? d
+			project_delta: (id, d) => this._geometry_provider?.world_delta_to_local(id, d) ?? d,
+			set_selection: (ids) => this.editor.commands.select(ids),
+			on_clone_commit: (record) => this.editor_internal().seed_duplication(record)
 		});
 		const resize_options = () => {
 			const style = this.editor.style;
@@ -1779,6 +1830,7 @@ var DomSurface = class DomSurface {
 			shapeOf: (id) => this.shape_of(id),
 			vectorOf: (id) => this.vector_of(id),
 			onIntent: (i) => this.commit_intent(i),
+			onTap: (t) => this.handle_tap(t),
 			style: {
 				chromeColor: editor.style.chrome_color,
 				showRotationHandles: true
@@ -1838,7 +1890,7 @@ var DomSurface = class DomSurface {
 			this.current_tool = editor.state.tool;
 			this.hud.setVectorSelectionMode(this.current_tool.type === "lasso" ? "lasso" : "marquee");
 			this.hud.setVectorBendMode(this.current_tool.type === "bend" ? "always" : "auto");
-			this.render();
+			this.flush_dom();
 			this.sync_surface_selection();
 			this.hud.setPixelGrid({
 				enabled: editor.style.pixel_grid,
@@ -1885,6 +1937,8 @@ var DomSurface = class DomSurface {
 			win.addEventListener("resize", fn);
 			this.teardown.push(() => win.removeEventListener("resize", fn));
 		}
+		const detach_font_listener = install_font_load_geometry_bump(options.font_load_source ?? container.ownerDocument.fonts ?? null, () => editor._internal.bump_geometry());
+		this.teardown.push(detach_font_listener);
 		this.wire_events();
 		const internal = editor._internal;
 		this.editor_hover_internal = internal;
@@ -1892,12 +1946,14 @@ var DomSurface = class DomSurface {
 		this.teardown.push(() => internal.set_content_edit_driver(null));
 		internal.set_computed_resolver({
 			computed_property: (id, name) => {
+				this.flush_dom();
 				const el = this.element_index.get(id);
 				if (!el) return null;
 				const value = getComputedStyle(el).getPropertyValue(name);
 				return value === "" ? null : value;
 			},
 			computed_paint: (id, channel) => {
+				this.flush_dom();
 				const el = this.element_index.get(id);
 				if (!el) return null;
 				const computed = getComputedStyle(el).getPropertyValue(channel);
@@ -1914,7 +1970,8 @@ var DomSurface = class DomSurface {
 			root: () => this.svg_root,
 			camera: () => this.camera,
 			container: () => this.container,
-			pick_at_world: (p, allow_root) => this._pick_node_at_world(p, allow_root)
+			pick_at_world: (p, allow_root) => this._pick_node_at_world(p, allow_root),
+			flush: () => this.flush_dom()
 		}), {
 			subscribe_structure: (cb) => editor.subscribe_with_selector((s) => s.structure_version, () => cb()),
 			subscribe_geometry: (cb) => editor.subscribe_geometry(cb)
@@ -2096,6 +2153,25 @@ var DomSurface = class DomSurface {
 	detach_gestures() {
 		this.gestures._dispose();
 	}
+	/**
+	* Bring the live DOM up to date with the doc IR iff it is stale.
+	*
+	* Staleness contract: anything that reads the LIVE DOM as a proxy for
+	* document state — the geometry driver (`getBBox` / `getCTM`), the
+	* computed-style resolver — MUST call this first. Doc listeners (the
+	* geometry channel, editor `subscribe`) fire synchronously inside the
+	* mutation, BEFORE the surface's render listener has projected the new
+	* attrs into the DOM; a read in that window returns the PREVIOUS
+	* geometry, and through `MemoizedGeometryProvider` it would be cached as
+	* if current — every later consumer (align, resize_to, snap) then plans
+	* against one-mutation-stale bounds. Same model as CSS layout: reading
+	* `offsetWidth` flushes pending layout; reading `bounds_of` flushes the
+	* pending render.
+	*/
+	flush_dom() {
+		if (this.rendered_doc_revision === this.editor._internal.doc.revision) return;
+		this.render();
+	}
 	render() {
 		if (this.text_edit) return;
 		const owner_doc = this.container.ownerDocument;
@@ -2122,6 +2198,7 @@ var DomSurface = class DomSurface {
 			for (let c = el.firstElementChild; c; c = c.nextElementSibling) if (c instanceof SVGElement) tag_walk(c);
 		};
 		tag_walk(new_svg);
+		this.rendered_doc_revision = doc.revision;
 	}
 	sync_canvas_size() {
 		const cr = this.container.getBoundingClientRect();
@@ -2716,6 +2793,60 @@ var DomSurface = class DomSurface {
 		});
 		on(win, "blur", () => this.sync_modifiers(null));
 		on(this.container, "contextmenu", (e) => e.preventDefault());
+		if (this.clipboard_enabled) {
+			on(owner_doc, "copy", (e) => this.on_copy_or_cut(e, "copy"));
+			on(owner_doc, "cut", (e) => this.on_copy_or_cut(e, "cut"));
+			on(owner_doc, "paste", (e) => this.on_paste(e));
+		}
+	}
+	/**
+	* Gate for claiming a native clipboard gesture. Deliberately STRICTER
+	* than the keyboard attention gate: focus-based only — pointer-over is
+	* a sufficient signal for a keystroke (worst case: a stolen scroll) but
+	* not for clipboard (worst case: destroying what the user believed they
+	* copied, or routing a paste meant for a host text field into the
+	* document). A user with text selected in a sibling panel and the
+	* pointer idly over the canvas must get their text copy.
+	*/
+	claims_clipboard(kind) {
+		if (this.text_edit) return false;
+		if (this.editor.state.mode !== "select") return false;
+		if (!this.attention.is_focus_within()) return false;
+		if (require_model.is_text_input_focused()) return false;
+		if (kind !== "paste") {
+			const sel = this.container.ownerDocument.getSelection();
+			if (sel && !sel.isCollapsed) return false;
+		}
+		return true;
+	}
+	/**
+	* Act-then-claim: an empty selection returns without `preventDefault()`,
+	* leaving the browser default (and the OS clipboard) untouched. The
+	* buffer-only `_internal.clipboard` variants are used here — the event's
+	* DataTransfer is this gesture's ONE external channel (the public
+	* commands would additionally write the provider; one gesture, one
+	* external write — FRD §Transport).
+	*/
+	on_copy_or_cut(e, kind) {
+		if (!this.claims_clipboard(kind)) return;
+		if (!e.clipboardData) return;
+		const internal = this.editor_internal();
+		const payload = kind === "copy" ? internal.clipboard.copy() : internal.clipboard.cut();
+		if (payload === null) return;
+		e.clipboardData.setData("text/plain", payload);
+		e.preventDefault();
+	}
+	/**
+	* Claim-then-act (mirrors the keydown claim doctrine: swallow when the
+	* gesture is aimed at the editor, not just when a handler consumed):
+	* a refused paste — junk text — still claims; the suppressed default is
+	* a no-op on a div anyway.
+	*/
+	on_paste(e) {
+		if (!this.claims_clipboard("paste")) return;
+		e.preventDefault();
+		const text = e.clipboardData?.getData("text/plain");
+		if (text) this.editor.commands.paste(text);
 	}
 	/**
 	* Master signal for modifier-driven UX consumers (measurement, future
@@ -2737,7 +2868,7 @@ var DomSurface = class DomSurface {
 			kind: "modifiers",
 			mods: next
 		});
-		if (prev.shift !== next.shift && this.translate_orchestrator.has_active_session()) this.translate_orchestrator.redrive_modifiers(this.current_translate_modifiers());
+		if ((prev.shift !== next.shift || prev.alt !== next.alt) && this.translate_orchestrator.has_active_session()) this.translate_orchestrator.redrive_modifiers(this.current_translate_modifiers());
 		if (prev.shift !== next.shift && this.resize_orchestrator.has_active_session()) this.resize_orchestrator.redrive_modifiers(this.current_resize_modifiers());
 		if (prev.shift !== next.shift && this.rotate_orchestrator.has_active_session()) this.rotate_orchestrator.redrive_modifiers(this.current_rotate_modifiers());
 		this.redraw();
@@ -2758,6 +2889,7 @@ var DomSurface = class DomSurface {
 			} else if (kind === "pointer_up") this.text_edit.pointerUp();
 			return;
 		}
+		if (kind === "pointer_down") this.container.focus({ preventScroll: true });
 		const cr = this.container.getBoundingClientRect();
 		const x = e.clientX - cr.left;
 		const y = e.clientY - cr.top;
@@ -2968,6 +3100,26 @@ var DomSurface = class DomSurface {
 		if (this.editor.keymap.claims(e)) e.preventDefault();
 		this.editor.keymap.dispatch(e);
 	}
+	/**
+	* Re-express a HUD tap as an editor {@link PickEvent} and fan it out on the
+	* editor's pick channel. The HUD already resolved everything that matters —
+	* the pointer-down point, the hit node, and click-vs-drag — so this is a
+	* pure translation (HUD `[x, y]` tuple → editor `{ x, y }` doc-space point)
+	* with NO re-hit-testing. Taking the hit from the HUD (not a fresh
+	* `node_at_point`) guarantees the pick and the selection it accompanies can
+	* never disagree. Observe-only: this mutates no editor state.
+	*/
+	handle_tap(tap) {
+		this.editor._internal.push_pick({
+			point: {
+				x: tap.point[0],
+				y: tap.point[1]
+			},
+			node_id: tap.hit,
+			button: tap.button,
+			mods: tap.mods
+		});
+	}
 	commit_intent(intent) {
 		switch (intent.kind) {
 			case "select":
@@ -3054,13 +3206,15 @@ var DomSurface = class DomSurface {
 		});
 		if (intent.phase === "commit") this.request_redraw();
 	}
-	/** Snapshot of HUD modifier state mapped to pipeline `TranslateModifiers`.
+	/** Snapshot of HUD modifier state mapped to the orchestrator's `GestureModifiers`.
 	*  Pull-at-consume: HUD is the canonical store (see `sync_modifiers`),
 	*  read live so mid-drag Shift press/release reflects on the next pass. */
 	current_translate_modifiers() {
+		const mods = this.hud.modifiers();
 		return {
-			axis_lock: this.hud.modifiers().shift ? "by_dominance" : "off",
-			force_disable_snap: false
+			axis_lock: mods.shift ? "by_dominance" : "off",
+			force_disable_snap: false,
+			clone: mods.alt
 		};
 	}
 	/** Snapshot of HUD modifier state mapped to `ResizeModifiers`. Same
@@ -4399,6 +4553,7 @@ var SvgGeometryDriver = class {
 		this.accessors = accessors;
 	}
 	bounds_of(id) {
+		this.accessors.flush();
 		const el = this.accessors.element_for(id);
 		if (!el) return null;
 		if (el instanceof SVGSVGElement) return svg_viewport_bounds(el);
@@ -4450,6 +4605,7 @@ var SvgGeometryDriver = class {
 		return out;
 	}
 	nodes_in_rect(rect) {
+		this.accessors.flush();
 		const root = this.accessors.root();
 		if (!root) return [];
 		const hits = [];
@@ -4462,6 +4618,7 @@ var SvgGeometryDriver = class {
 		return hits;
 	}
 	node_at_point(p) {
+		this.accessors.flush();
 		return this.accessors.pick_at_world(p, true);
 	}
 	/** World→local delta projection. The frame an element's position is
@@ -4477,6 +4634,7 @@ var SvgGeometryDriver = class {
 	*  the local delta. Identity (→ delta unchanged) for flat frames,
 	*  top-level nodes, and any degenerate / unavailable matrix. */
 	world_delta_to_local(id, delta) {
+		this.accessors.flush();
 		const parent = this.accessors.element_for(id)?.parentNode;
 		const root = this.accessors.root();
 		if (!(parent instanceof SVGGraphicsElement) || !root) return delta;
@@ -4547,6 +4705,12 @@ Object.defineProperty(exports, "attach_dom_surface", {
 		return attach_dom_surface;
 	}
 });
+Object.defineProperty(exports, "install_font_load_geometry_bump", {
+	enumerable: true,
+	get: function() {
+		return install_font_load_geometry_bump;
+	}
+});
 Object.defineProperty(exports, "inverse_project_rect", {
 	enumerable: true,
 	get: function() {

package/dist/{dom-CK6GlgFF.d.mts → dom-TctdgRnn.d.mts}

@@ -1,4 +1,4 @@
-import { c as SvgEditor, p as Gestures, s as SurfaceHandle, w as Camera } from "./editor-Dl7c0q5A.mjs";
+import { c as SvgEditor, p as Gestures, s as SurfaceHandle, w as Camera } from "./editor-KqpIW1qm.mjs";
 import cmath from "@grida/cmath";
 import { guide } from "@grida/cmath/_snap";
 
@@ -13,6 +13,35 @@ type SnapOptions = {
 declare const DEFAULT_SNAP_OPTIONS: SnapOptions;
 //#endregion
 //#region src/dom.d.ts
+/**
+ * Wire a web-font settle source to the editor's geometry channel.
+ *
+ * The DOM surface re-serializes the `<svg>` on every editor tick, but a
+ * `<text>` / `<tspan>` bbox can change with NO attribute write: a web font
+ * finishing load AFTER its `font-family` / `font-size` was already written.
+ * The IR never sees that reflow, so nothing bumps `geometry_version` and
+ * every bounds-keyed consumer (snap, HUD chrome, size meter) stays stuck at
+ * the fallback-face metrics until the next real edit.
+ *
+ * Listens for `loadingdone` on `source` (a `FontFaceSet`, or any injected
+ * `EventTarget` in tests) and calls `bump` once per settle. COARSE on
+ * purpose: one bump clears the WHOLE bounds cache, not just text nodes —
+ * consistent with the package's pessimistic-invalidation stance, and far
+ * cheaper than scoping the bump to the (possibly many) reflowed runs.
+ *
+ * Also bumps once when `source.ready` resolves (when present): fonts that
+ * settled before attach — a cache hit, or `font-display` resolving the same
+ * tick the surface mounts — never re-fire `loadingdone`, so a document
+ * mounted post-settle still needs one bump to re-read at the real metrics.
+ *
+ * Returns a teardown that removes the listener and neutralizes the pending
+ * `ready` bump (leak guard) — call it on surface detach.
+ *
+ * Factored out of the surface so it can be unit-tested with a fake
+ * `EventTarget` in the node-only test env (jsdom's `FontFaceSet` is
+ * incomplete); never a real font / network.
+ */
+declare function install_font_load_geometry_bump(source: EventTarget | null, bump: () => void): () => void;
 type DomSurfaceOptions = {
   /** Mount the SVG inside this container. */container: HTMLElement;
   /**
@@ -21,6 +50,18 @@ type DomSurfaceOptions = {
    * carte via `handle.gestures.bind(...)`.
    */
   gestures?: boolean;
+  /**
+   * Wire native ClipboardEvent transport — `copy` / `cut` / `paste`
+   * listeners on the owner document, gated by the clipboard attention
+   * discipline. Default `true`. Pass `false` to route ALL clipboard
+   * traffic through the `ClipboardProvider` seam instead (the
+   * configuration under which a host's paste-time screening governs
+   * every path) — see docs/wg/feat-svg-editor/clipboard.md §Transport
+   * "Host control over the native path". Focus management (the container
+   * focusing on pointerdown) stays either way — it is a general canvas
+   * mitigation, not a clipboard feature.
+   */
+  clipboard?: boolean;
   /**
    * Auto-fit the document into the viewport on initial attach. Default
    * `false`. Mirrors Excalidraw's `initialData.scrollToContent`.
@@ -33,6 +74,19 @@ type DomSurfaceOptions = {
    * when `fit: true`.
    */
   initial_camera?: cmath.Transform;
+  /**
+   * Font-load settle source — the `EventTarget` whose `loadingdone` event
+   * signals "web fonts finished loading, text may have reflowed." Defaults
+   * to `container.ownerDocument.fonts` (the live `FontFaceSet`). The
+   * surface installs a `loadingdone` listener that advances the editor's
+   * geometry channel so text bounds re-read at the settled glyph metrics
+   * (see ../docs/geometry.md §Limitations "Text bbox depends on font").
+   *
+   * Injectable as a DOM seam: jsdom's `FontFaceSet` is incomplete, so
+   * tests pass a plain `EventTarget` stub and `dispatchEvent(new Event(
+   * "loadingdone"))` to simulate a settle without a real font / network.
+   */
+  font_load_source?: EventTarget;
 };
 /**
  * Surface handle for the DOM surface. Extends the editor's core
@@ -111,4 +165,4 @@ declare function inverse_project_rect(rect: {
   f: number;
 }, offset: readonly [number, number]): cmath.Rectangle | null;
 //#endregion
-export { project_delta_inverse_ctm as a, SnapOptions as c, inverse_project_rect as i, DomSurfaceOptions as n, project_point_through_ctm as o, attach_dom_surface as r, DEFAULT_SNAP_OPTIONS as s, DomSurfaceHandle as t };
+export { inverse_project_rect as a, DEFAULT_SNAP_OPTIONS as c, install_font_load_geometry_bump as i, SnapOptions as l, DomSurfaceOptions as n, project_delta_inverse_ctm as o, attach_dom_surface as r, project_point_through_ctm as s, DomSurfaceHandle as t };

package/dist/dom.d.mts

@@ -1,3 +1,3 @@
-import { C as BoundsResolver, E as CameraOptions, T as CameraConstraints, d as GestureContext, f as GestureId, g as MemoizedGeometryProvider, h as GeometrySignals, i as DomComputedResolver, m as GeometryProvider, p as Gestures, r as DomComputedPaint, u as GestureBinding, w as Camera } from "./editor-Dl7c0q5A.mjs";
-import { a as project_delta_inverse_ctm, c as SnapOptions, i as inverse_project_rect, n as DomSurfaceOptions, o as project_point_through_ctm, r as attach_dom_surface, s as DEFAULT_SNAP_OPTIONS, t as DomSurfaceHandle } from "./dom-CK6GlgFF.mjs";
-export { type BoundsResolver, Camera, type CameraConstraints, type CameraOptions, DEFAULT_SNAP_OPTIONS, type DomComputedPaint, type DomComputedResolver, DomSurfaceHandle, DomSurfaceOptions, type GeometryProvider, type GeometrySignals, type GestureBinding, type GestureContext, type GestureId, Gestures, MemoizedGeometryProvider, type SnapOptions, attach_dom_surface, inverse_project_rect, project_delta_inverse_ctm, project_point_through_ctm };
+import { C as BoundsResolver, E as CameraOptions, T as CameraConstraints, d as GestureContext, f as GestureId, g as MemoizedGeometryProvider, h as GeometrySignals, i as DomComputedResolver, m as GeometryProvider, p as Gestures, r as DomComputedPaint, u as GestureBinding, w as Camera } from "./editor-KqpIW1qm.mjs";
+import { a as inverse_project_rect, c as DEFAULT_SNAP_OPTIONS, i as install_font_load_geometry_bump, l as SnapOptions, n as DomSurfaceOptions, o as project_delta_inverse_ctm, r as attach_dom_surface, s as project_point_through_ctm, t as DomSurfaceHandle } from "./dom-TctdgRnn.mjs";
+export { type BoundsResolver, Camera, type CameraConstraints, type CameraOptions, DEFAULT_SNAP_OPTIONS, type DomComputedPaint, type DomComputedResolver, DomSurfaceHandle, DomSurfaceOptions, type GeometryProvider, type GeometrySignals, type GestureBinding, type GestureContext, type GestureId, Gestures, MemoizedGeometryProvider, type SnapOptions, attach_dom_surface, install_font_load_geometry_bump, inverse_project_rect, project_delta_inverse_ctm, project_point_through_ctm };

package/dist/dom.d.ts

@@ -1,3 +1,3 @@
-import { C as BoundsResolver, E as CameraOptions, T as CameraConstraints, d as GestureContext, f as GestureId, g as MemoizedGeometryProvider, h as GeometrySignals, i as DomComputedResolver, m as GeometryProvider, p as Gestures, r as DomComputedPaint, u as GestureBinding, w as Camera } from "./editor-BKoo9SPL.js";
-import { a as project_delta_inverse_ctm, c as SnapOptions, i as inverse_project_rect, n as DomSurfaceOptions, o as project_point_through_ctm, r as attach_dom_surface, s as DEFAULT_SNAP_OPTIONS, t as DomSurfaceHandle } from "./dom-CsKXTaNw.js";
-export { type BoundsResolver, Camera, type CameraConstraints, type CameraOptions, DEFAULT_SNAP_OPTIONS, type DomComputedPaint, type DomComputedResolver, DomSurfaceHandle, DomSurfaceOptions, type GeometryProvider, type GeometrySignals, type GestureBinding, type GestureContext, type GestureId, Gestures, MemoizedGeometryProvider, type SnapOptions, attach_dom_surface, inverse_project_rect, project_delta_inverse_ctm, project_point_through_ctm };
+import { C as BoundsResolver, E as CameraOptions, T as CameraConstraints, d as GestureContext, f as GestureId, g as MemoizedGeometryProvider, h as GeometrySignals, i as DomComputedResolver, m as GeometryProvider, p as Gestures, r as DomComputedPaint, u as GestureBinding, w as Camera } from "./editor-BSxTUsW_.js";
+import { a as inverse_project_rect, c as DEFAULT_SNAP_OPTIONS, i as install_font_load_geometry_bump, l as SnapOptions, n as DomSurfaceOptions, o as project_delta_inverse_ctm, r as attach_dom_surface, s as project_point_through_ctm, t as DomSurfaceHandle } from "./dom-BMzX1CXZ.js";
+export { type BoundsResolver, Camera, type CameraConstraints, type CameraOptions, DEFAULT_SNAP_OPTIONS, type DomComputedPaint, type DomComputedResolver, DomSurfaceHandle, DomSurfaceOptions, type GeometryProvider, type GeometrySignals, type GestureBinding, type GestureContext, type GestureId, Gestures, MemoizedGeometryProvider, type SnapOptions, attach_dom_surface, install_font_load_geometry_bump, inverse_project_rect, project_delta_inverse_ctm, project_point_through_ctm };

package/dist/dom.js

@@ -1,10 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_dom = require("./dom-Dee6FtgZ.js");
+const require_dom = require("./dom-CaByuo6C.js");
 exports.Camera = require_dom.Camera;
 exports.DEFAULT_SNAP_OPTIONS = require_dom.DEFAULT_SNAP_OPTIONS;
 exports.Gestures = require_dom.Gestures;
 exports.MemoizedGeometryProvider = require_dom.MemoizedGeometryProvider;
 exports.attach_dom_surface = require_dom.attach_dom_surface;
+exports.install_font_load_geometry_bump = require_dom.install_font_load_geometry_bump;
 exports.inverse_project_rect = require_dom.inverse_project_rect;
 exports.project_delta_inverse_ctm = require_dom.project_delta_inverse_ctm;
 exports.project_point_through_ctm = require_dom.project_point_through_ctm;

package/dist/dom.mjs

@@ -1,2 +1,2 @@
-import { a as Gestures, c as Camera, i as project_point_through_ctm, n as inverse_project_rect, o as DEFAULT_SNAP_OPTIONS, r as project_delta_inverse_ctm, s as MemoizedGeometryProvider, t as attach_dom_surface } from "./dom-DILY80j7.mjs";
-export { Camera, DEFAULT_SNAP_OPTIONS, Gestures, MemoizedGeometryProvider, attach_dom_surface, inverse_project_rect, project_delta_inverse_ctm, project_point_through_ctm };
+import { a as project_point_through_ctm, c as MemoizedGeometryProvider, i as project_delta_inverse_ctm, l as Camera, n as install_font_load_geometry_bump, o as Gestures, r as inverse_project_rect, s as DEFAULT_SNAP_OPTIONS, t as attach_dom_surface } from "./dom-Bjj9xySE.mjs";
+export { Camera, DEFAULT_SNAP_OPTIONS, Gestures, MemoizedGeometryProvider, attach_dom_surface, install_font_load_geometry_bump, inverse_project_rect, project_delta_inverse_ctm, project_point_through_ctm };