@inditextech/weave-sdk 5.5.0 → 5.7.0-SNAPSHOT.595.1

package/dist/types.js

@@ -5937,6 +5937,7 @@ const MOVE_TOOL_STATE = {
 };
 //#endregion
 //#region src/nodes/node.ts
+const nodeInstanceListeners = /* @__PURE__ */ new WeakMap();
 const augmentKonvaNodeClass = (config) => {
 	const { transform } = config ?? {};
 	Konva.Node.prototype.getTransformerProperties = function() {
@@ -5952,6 +5953,8 @@ const augmentKonvaNodeClass = (config) => {
 	Konva.Node.prototype.triggerCrop = function() {};
 	Konva.Node.prototype.closeCrop = function() {};
 	Konva.Node.prototype.resetCrop = function() {};
+	Konva.Node.prototype.flipHorizontal = function() {};
+	Konva.Node.prototype.flipVertical = function() {};
 	Konva.Node.prototype.dblClick = function() {};
 	Konva.Node.prototype.click = function() {};
 	Konva.Node.prototype.allowedAnchors = function() {
@@ -6037,6 +6040,8 @@ var WeaveNode = class {
 		};
 		node.updatePosition = function() {};
 		node.resetCrop = function() {};
+		node.flipHorizontal = function() {};
+		node.flipVertical = function() {};
 		node.handleMouseover = function() {};
 		node.handleMouseout = function() {};
 		node.handleSelectNode = function() {};
@@ -6207,7 +6212,7 @@ var WeaveNode = class {
 			node.draggable(false);
 		};
 		if (node.getAttrs().locked ?? false) {
-			this.instance.removeEventListener("onNodesChange", handleNodesChange);
+			this.removeNodeInstanceListeners(node, false);
 			node.off("transformstart");
 			node.off("transform");
 			node.off("transformend");
@@ -6217,7 +6222,7 @@ var WeaveNode = class {
 			node.off("pointerover");
 			node.off("pointerleave");
 		} else {
-			this.instance.addEventListener("onNodesChange", handleNodesChange);
+			this.setNodeInstanceListener(node, "onNodesChange", handleNodesChange);
 			node.off("transformstart");
 			node.on("transformstart", (e) => {
 				if (e.target.getAttrs().strokeScaleEnabled !== false) {
@@ -6276,7 +6281,7 @@ var WeaveNode = class {
 			});
 			const stage = this.instance.getStage();
 			let originalPosition = null;
-			this.instance.addEventListener("onSelectionState", (state) => {
+			this.setNodeInstanceListener(node, "onSelectionState", (state) => {
 				const selectedNodes = this.getSelectionPlugin()?.getSelectedNodes() ?? [];
 				if (!state && selectedNodes?.some((n) => n.getAttrs().id === node.getAttrs().id)) originalPosition = node.getAbsolutePosition();
 			});
@@ -6592,8 +6597,39 @@ var WeaveNode = class {
 	async onRegister() {}
 	onAdd(nodeInstance) {}
 	onDestroy(nodeInstance) {
+		this.removeNodeInstanceListeners(nodeInstance);
 		nodeInstance.destroy();
 	}
+	/**
+	* Registers a Weave instance listener on behalf of a node. Only one listener
+	* is kept per node and event: registering the same event again for the same
+	* node replaces the previous listener, including the ones registered by
+	* setupDefaultNodeEvents (onNodesChange, onSelectionState).
+	*/
+	setNodeInstanceListener(node, event, callback) {
+		let listeners = nodeInstanceListeners.get(node);
+		if (!listeners) {
+			listeners = /* @__PURE__ */ new Map();
+			nodeInstanceListeners.set(node, listeners);
+		}
+		const previous = listeners.get(event);
+		if (previous) this.instance.removeEventListener(event, previous);
+		listeners.set(event, callback);
+		this.instance.addEventListener(event, callback);
+	}
+	/**
+	* Removes the listeners registered with setNodeInstanceListener for the node
+	* and, unless disabled, for its descendants.
+	*/
+	removeNodeInstanceListeners(node, includeDescendants = true) {
+		const nodes = includeDescendants && node instanceof Konva.Container ? [node, ...node.find(() => true)] : [node];
+		for (const actNode of nodes) {
+			const listeners = nodeInstanceListeners.get(actNode);
+			if (!listeners) continue;
+			for (const [event, callback] of listeners) this.instance.removeEventListener(event, callback);
+			nodeInstanceListeners.delete(actNode);
+		}
+	}
 	onDestroyInstance() {}
 	serialize(instance) {
 		const attrs = instance.getAttrs();
@@ -9466,7 +9502,7 @@ var WeaveRegisterManager = class {
 };
 //#endregion
 //#region package.json
-var version = "5.5.0";
+var version = "5.7.0-SNAPSHOT.595.1";
 //#endregion
 //#region src/managers/setup.ts
 var WeaveSetupManager = class {
@@ -11187,6 +11223,9 @@ var Weave = class {
 	getBoundingBox(nodes, config) {
 		return getBoundingBox(nodes, config);
 	}
+	flipImage(node, options) {
+		this.getNodeHandler("image")?.flipImage(node, options);
+	}
 	stateTransactional(callback, origin) {
 		this.stateManager.stateTransactional(callback, origin);
 	}
@@ -14304,99 +14343,2084 @@ var WeaveTextNode = class extends WeaveNode {
 		};
 	}
 	static addNodeState(defaultNodeState, props) {
-		return mergeExceptArrays(defaultNodeState, { props: {
-			x: props.x,
-			y: props.y,
-			width: props.width,
-			...props.height && { height: props.height },
-			FontFamily: props.fontFamily,
-			fontSize: props.fontSize,
-			fontStyle: props.fontStyle,
-			fontVariant: props.fontVariant,
-			textDecoration: props.textDecoration,
-			letterSpacing: props.letterSpacing,
-			lineHeight: props.lineHeight,
-			align: props.align,
-			verticalAlign: props.verticalAlign,
-			rotation: props.rotation,
-			fill: props.fill,
-			text: props.text,
-			layout: props.layout,
-			...props.strokeEnabled && { strokeEnabled: props.strokeEnabled },
-			...props.stroke && { stroke: props.stroke },
-			...props.strokeWidth && { strokeWidth: props.strokeWidth },
-			...props.fillAfterStrokeEnabled && { fillAfterStrokeEnabled: props.fillAfterStrokeEnabled },
-			...props.link && { link: props.link }
-		} });
+		return mergeExceptArrays(defaultNodeState, { props: {
+			x: props.x,
+			y: props.y,
+			width: props.width,
+			...props.height && { height: props.height },
+			FontFamily: props.fontFamily,
+			fontSize: props.fontSize,
+			fontStyle: props.fontStyle,
+			fontVariant: props.fontVariant,
+			textDecoration: props.textDecoration,
+			letterSpacing: props.letterSpacing,
+			lineHeight: props.lineHeight,
+			align: props.align,
+			verticalAlign: props.verticalAlign,
+			rotation: props.rotation,
+			fill: props.fill,
+			text: props.text,
+			layout: props.layout,
+			...props.strokeEnabled && { strokeEnabled: props.strokeEnabled },
+			...props.stroke && { stroke: props.stroke },
+			...props.strokeWidth && { strokeWidth: props.strokeWidth },
+			...props.fillAfterStrokeEnabled && { fillAfterStrokeEnabled: props.fillAfterStrokeEnabled },
+			...props.link && { link: props.link }
+		} });
+	}
+	static updateNodeState(prevNodeState, nextProps) {
+		return mergeExceptArrays(prevNodeState, { props: {
+			x: nextProps.x,
+			y: nextProps.y,
+			width: nextProps.width,
+			...nextProps.height && { height: nextProps.height },
+			FontFamily: nextProps.fontFamily,
+			fontSize: nextProps.fontSize,
+			fontStyle: nextProps.fontStyle,
+			fontVariant: nextProps.fontVariant,
+			textDecoration: nextProps.textDecoration,
+			letterSpacing: nextProps.letterSpacing,
+			lineHeight: nextProps.lineHeight,
+			align: nextProps.align,
+			verticalAlign: nextProps.verticalAlign,
+			rotation: nextProps.rotation,
+			fill: nextProps.fill,
+			text: nextProps.text,
+			layout: nextProps.layout,
+			...nextProps.strokeEnabled && { strokeEnabled: nextProps.strokeEnabled },
+			...nextProps.stroke && { stroke: nextProps.stroke },
+			...nextProps.strokeWidth && { strokeWidth: nextProps.strokeWidth },
+			...nextProps.fillAfterStrokeEnabled && { fillAfterStrokeEnabled: nextProps.fillAfterStrokeEnabled },
+			...nextProps.link && { link: nextProps.link }
+		} });
+	}
+	static getSchema() {
+		return super.getSchema().extend({
+			type: z.literal(WEAVE_TEXT_NODE_TYPE).describe(`Type of the node, for a text node it will always be "${WEAVE_TEXT_NODE_TYPE}"`),
+			props: z.object({
+				nodeType: z.literal(WEAVE_TEXT_NODE_TYPE).describe(`Type of the node, for a text node it will always be "${WEAVE_TEXT_NODE_TYPE}"`),
+				width: z.number().describe("Width of the text in pixels"),
+				height: z.number().optional().describe("Height of the text in pixels. Optional if layout is auto-height or smart."),
+				fontFamily: z.string().default("Arial").describe("Font family of the text, e.g. Arial, Helvetica, etc."),
+				fontSize: z.number().default(16).describe("Font size of the text in pixels."),
+				fontStyle: z.string().regex(/^(?:normal|bold|\d+)(?: italic)?$/).default("normal").describe("Font style of the text, can be \"normal\", \"bold\", \"400\", \"italic\" or a combination like \"bold italic\" or \"700 italic\"."),
+				fontVariant: z.enum(["normal", "small-caps"]).describe("Font variant of the text, can be \"normal\" or \"small-caps\"."),
+				textDecoration: z.enum([
+					"line-through",
+					"underline",
+					""
+				]).default("").describe("Text decoration can be \"line-through\", \"underline\" or empty string for none."),
+				letterSpacing: z.number().default(0).describe("Spacing between letters in pixels."),
+				lineHeight: z.number().default(1).describe("Line height of the text, as a multiplier of font size."),
+				align: z.enum([
+					"left",
+					"center",
+					"right",
+					"justify"
+				]).default("left").describe("Text alignment, can be \"left\", \"center\", \"right\" or \"justify\"."),
+				verticalAlign: z.enum([
+					"top",
+					"middle",
+					"bottom"
+				]).default("top").describe("Vertical alignment of the text, can be 'top', 'middle' or 'bottom'."),
+				fill: z.string().default("#000000ff").describe("Fill color of the text  in hex format with alpha channel (e.g. #RRGGBBAA)."),
+				text: z.string().default("text").describe("The actual text content of the node."),
+				link: z.string().url().refine((value) => isValidTextLink(value), { message: "Link must be an absolute http:// or https:// URL." }).optional().describe("External URL the whole text of the node links to. When set, the text is forced underlined and coloured with the configured link colours regardless of fill/textDecoration, is clickable, and opens the URL in a new tab. Only http(s) URLs are accepted. Omit/remove to make the node plain text again."),
+				linkPreviousFill: z.string().optional().describe("Internal bookkeeping: the fill colour the node had right before a link was set, captured automatically so it can be restored when the link is removed. Managed automatically — do not set directly."),
+				linkPreviousTextDecoration: z.string().optional().describe("Internal bookkeeping: the textDecoration the node had right before a link was set, captured automatically so it can be restored when the link is removed. Managed automatically — do not set directly."),
+				strokeEnabled: z.boolean().default(false).describe("Whether the text outline is enabled."),
+				stroke: z.string().optional().default("#d6d6d6").describe("Color of the text outline in hex format with alpha channel (e.g. #RRGGBBAA)."),
+				strokeWidth: z.number().optional().default(2).describe("Width of the text outline in pixels."),
+				strokeScaleEnabled: z.boolean().default(true).describe("Whether the stroke width should scale when the node is scaled."),
+				fillAfterStrokeEnabled: z.boolean().default(true).describe("Whether the fill should be drawn after the stroke. If false, the stroke will be drawn on top of the fill."),
+				layout: z.enum(TEXT_LAYOUT).default(TEXT_LAYOUT.SMART).describe("Layout mode of the text node. Can be:\n- 'fixed': the text node will have fixed width and height, and the text will be scaled to fit the node.\n- 'auto-height': the width of the text node will be fixed, but the height will adjust to fit the text content.\n- 'auto-all': both width and height of the text node will adjust to fit the text content.\n- 'smart': the text node will try to adjust its size based on the content and layout, but it will not exceed the initial width and height set on the node.")
+			})
+		});
+	}
+};
+//#endregion
+//#region src/nodes/text-v2/model.ts
+function isEmptyMarks(m) {
+	return !m || Object.keys(m).length === 0;
+}
+function sameMarks(a, b) {
+	if (isEmptyMarks(a) && isEmptyMarks(b)) return true;
+	if (isEmptyMarks(a) || isEmptyMarks(b)) return false;
+	const ka = Object.keys(a);
+	const kb = Object.keys(b);
+	return ka.length === kb.length && ka.every((k) => a[k] === b[k]);
+}
+/** Merge adjacent runs with equal marks and drop empty runs (keeps >= 0). */
+function normalizeRuns(runs) {
+	const out = [];
+	for (const run of runs) {
+		if (run.t === "") continue;
+		const last = out[out.length - 1];
+		if (last && sameMarks(last.m, run.m)) last.t += run.t;
+		else out.push({
+			t: run.t,
+			...isEmptyMarks(run.m) ? {} : { m: run.m }
+		});
+	}
+	return out;
+}
+/**
+* Synthesize blocks from legacy plain `text`. One run per paragraph; a
+* legacy whole-text `link` becomes a full-range `link` mark.
+*/
+function synthesizeBlocks(text, link) {
+	return (text ?? "").split("\n").map((paragraph) => ({ runs: paragraph === "" ? [] : [{
+		t: paragraph,
+		...link ? { m: { link } } : {}
+	}] }));
+}
+/** Resolve blocks of a node: stored `blocks` or lazily synthesized (no write). */
+function resolveBlocks(attrs) {
+	if (Array.isArray(attrs.blocks) && attrs.blocks.length > 0) return attrs.blocks;
+	return synthesizeBlocks(attrs.text ?? "", attrs.link);
+}
+function blockText(block) {
+	return block.runs.map((r) => r.t).join("");
+}
+/** Derived mirror for the `text` attribute. */
+function blocksToText(blocks) {
+	return blocks.map(blockText).join("\n");
+}
+/** Slice runs of a block between local offsets [from, to). */
+function sliceRuns(runs, from, to) {
+	const out = [];
+	let pos = 0;
+	for (const run of runs) {
+		const start = pos;
+		const end = pos + run.t.length;
+		pos = end;
+		const s = Math.max(from, start);
+		const e = Math.min(to, end);
+		if (s < e) out.push({
+			t: run.t.slice(s - start, e - start),
+			m: run.m
+		});
+	}
+	return out;
+}
+/** Marks of the run at (or immediately before) a local offset. */
+function marksAt(runs, offset) {
+	let pos = 0;
+	let found;
+	for (const run of runs) {
+		const end = pos + run.t.length;
+		if (offset > pos && offset <= end) return run.m;
+		if (offset === pos && !found) found = run.m;
+		pos = end;
+	}
+	return found;
+}
+/**
+* Replace the global range [start, end) (newline counts as 1 char between
+* blocks) with plain `insert`. Marks on untouched text are preserved; the
+* inserted text inherits marks of the character before `start`.
+*/
+function replaceRange(blocks, start, end, insert) {
+	const total = blocksToText(blocks).length;
+	start = Math.max(0, Math.min(start, total));
+	end = Math.max(start, Math.min(end, total));
+	let before = [];
+	let after = [];
+	const prefixBlocks = [];
+	const suffixBlocks = [];
+	let inheritedMarks;
+	let pos = 0;
+	blocks.forEach((block, i) => {
+		const len = blockText(block).length;
+		const bStart = pos;
+		const bEnd = pos + len;
+		pos = bEnd + 1;
+		if (bEnd < start) prefixBlocks.push(block);
+		else if (bStart > end) suffixBlocks.push(block);
+		else {
+			if (start >= bStart && start <= bEnd) {
+				const local = start - bStart;
+				before = sliceRuns(block.runs, 0, local);
+				inheritedMarks = marksAt(block.runs, local);
+			}
+			if (end >= bStart && end <= bEnd) after = sliceRuns(block.runs, end - bStart, len);
+		}
+	});
+	const lines = insert.split("\n");
+	const mk = (t) => t === "" ? [] : [{
+		t,
+		...isEmptyMarks(inheritedMarks) ? {} : { m: inheritedMarks }
+	}];
+	const middle = [];
+	lines.forEach((line, idx) => {
+		let runs = mk(line);
+		if (idx === 0) runs = [...before, ...runs];
+		if (idx === lines.length - 1) runs = [...runs, ...after];
+		middle.push({ runs: normalizeRuns(runs) });
+	});
+	return [
+		...prefixBlocks,
+		...middle,
+		...suffixBlocks
+	];
+}
+//#endregion
+//#region src/nodes/text-v2/layout/engine.ts
+/** Quote multi-word families like `Konva` does so the font shorthand parses. */
+function normalizeFontFamily(fontFamily) {
+	return fontFamily.split(",").map((family) => {
+		family = family.trim();
+		const hasSpace = family.includes(" ");
+		const hasQuotes = family.includes("\"") || family.includes("'");
+		return hasSpace && !hasQuotes ? `"${family}"` : family;
+	}).join(", ");
+}
+function fontString(s) {
+	return `${s.fontStyle} ${s.fontVariant} ${s.fontSize}px ${normalizeFontFamily(s.fontFamily)}`;
+}
+let sharedContext = null;
+/** Default measurer: works on browser, node-canvas and skia-canvas backends. */
+const canvasMeasurer = (font, text) => {
+	sharedContext ??= Konva.Util.createCanvasElement().getContext("2d");
+	sharedContext.font = font;
+	return sharedContext.measureText(text).width;
+};
+const graphemeSegmenter = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : null;
+function splitGraphemes(text) {
+	if (text === "") return [];
+	if (graphemeSegmenter) return Array.from(graphemeSegmenter.segment(text), (s) => s.segment);
+	return Array.from(text);
+}
+const now = () => typeof performance !== "undefined" ? performance.now() : Date.now();
+const WS = /\s/;
+const MAX_CACHE = 2e4;
+const MAX_CACHED_CHUNK = 256;
+var TextLayoutEngine = class {
+	measure;
+	cache = /* @__PURE__ */ new Map();
+	paragraphs = [];
+	/** Entries by signature, so paragraphs that shifted index are reused. */
+	pool = /* @__PURE__ */ new Map();
+	lastParagraphsRelaid = 0;
+	constructor(measurer = canvasMeasurer) {
+		this.measure = measurer;
+	}
+	/** Number of paragraphs recomputed by the last `layout()` call. */
+	getLastRelaidCount() {
+		return this.lastParagraphsRelaid;
+	}
+	clearCaches() {
+		this.cache.clear();
+		this.paragraphs = [];
+		this.pool.clear();
+	}
+	paragraphSig(block, style, bounds) {
+		const fixedWidth = bounds.width !== void 0 && !Number.isNaN(bounds.width);
+		const maxWidth = (bounds.width ?? 0) - bounds.padding * 2;
+		return `${fontString(style)}|${style.letterSpacing}|${style.wrap}|${fixedWidth ? maxWidth : "auto"}|${JSON.stringify(block.runs)}`;
+	}
+	/**
+	* Pre-compute paragraph layouts for `blocks` within a time budget so a
+	* following `layout()` is cheap. Call repeatedly until it returns true.
+	* Lets callers time-slice very large content (e.g. bulk paste).
+	*/
+	warm(blocks, style, bounds, budgetMs) {
+		const font = fontString(style);
+		const fixedWidth = bounds.width !== void 0 && !Number.isNaN(bounds.width);
+		const maxWidth = (bounds.width ?? 0) - bounds.padding * 2;
+		const deadline = now() + budgetMs;
+		for (const block of blocks) {
+			const sig = this.paragraphSig(block, style, bounds);
+			if (this.pool.has(sig)) continue;
+			this.pool.set(sig, this.layoutParagraph(block, sig, font, style, fixedWidth, maxWidth));
+			if (now() >= deadline) return false;
+		}
+		return true;
+	}
+	measureChunk(font, text, spacing) {
+		if (text === "") return 0;
+		if (text.length > MAX_CACHED_CHUNK) return this.measure(font, text) + text.length * spacing;
+		const key = `${font}\u0000${text}`;
+		let w = this.cache.get(key);
+		if (w === void 0) {
+			w = this.measure(font, text);
+			if (this.cache.size >= MAX_CACHE) this.cache.clear();
+			this.cache.set(key, w);
+		}
+		return w + text.length * spacing;
+	}
+	layout(blocks, style, bounds) {
+		const font = fontString(style);
+		const padding = bounds.padding;
+		const fixedWidth = bounds.width !== void 0 && !Number.isNaN(bounds.width);
+		const fixedHeight = bounds.height !== void 0 && !Number.isNaN(bounds.height);
+		const maxWidth = (bounds.width ?? 0) - padding * 2;
+		const maxHeightPx = (bounds.height ?? 0) - padding * 2;
+		const lineHeightPx = style.lineHeight * style.fontSize;
+		const sigBase = `${font}|${style.letterSpacing}|${style.wrap}|${fixedWidth ? maxWidth : "auto"}`;
+		const prev = this.paragraphs;
+		const next = [];
+		let relaid = 0;
+		const lines = [];
+		let textWidth = 0;
+		let currentHeightPx = 0;
+		let offset = 0;
+		outer: for (let p = 0; p < blocks.length; p++) {
+			const block = blocks[p];
+			const sig = `${sigBase}|${JSON.stringify(block.runs)}`;
+			let entry = prev[p]?.sig === sig ? prev[p] : this.pool.get(sig);
+			if (!entry) {
+				entry = this.layoutParagraph(block, sig, font, style, fixedWidth, maxWidth);
+				relaid++;
+			}
+			next.push(entry);
+			for (const pl of entry.lines) {
+				const text = entry.graphemes.slice(pl.startG, pl.endG).join("");
+				const segments = this.buildSegments(entry, block, pl, font, style);
+				const width = segments.reduce((a, s) => a + s.width, 0);
+				const startChar = entry.graphemes.slice(0, pl.startG).join("").length;
+				lines.push({
+					paragraph: p,
+					start: offset + startChar,
+					end: offset + startChar + text.length,
+					text,
+					width,
+					measuredWidth: pl.measuredWidth,
+					offsetX: 0,
+					y: lines.length * lineHeightPx,
+					segments,
+					lastInParagraph: pl.lastInParagraph
+				});
+				textWidth = Math.max(textWidth, pl.measuredWidth);
+				currentHeightPx += lineHeightPx;
+				if (fixedHeight && currentHeightPx + lineHeightPx > maxHeightPx) break outer;
+			}
+			offset += blockText(block).length + 1;
+		}
+		this.paragraphs = next;
+		this.pool = new Map(next.map((e) => [e.sig, e]));
+		this.lastParagraphsRelaid = relaid;
+		const width = fixedWidth ? bounds.width : textWidth + padding * 2;
+		const height = fixedHeight ? bounds.height : lines.length * lineHeightPx + padding * 2;
+		if (style.align !== "left") for (const line of lines) {
+			const free = width - line.width - padding * 2;
+			line.offsetX = style.align === "center" ? free / 2 : free;
+		}
+		return {
+			lines,
+			textWidth,
+			textHeight: style.fontSize,
+			lineHeightPx,
+			width,
+			height
+		};
+	}
+	rangeWidth(entry, runs, from, to, font, spacing) {
+		let width = 0;
+		let i = from;
+		while (i < to) {
+			const run = entry.runOf[i];
+			let j = i;
+			while (j < to && entry.runOf[j] === run) j++;
+			width += this.measureChunk(font, entry.graphemes.slice(i, j).join(""), spacing);
+			i = j;
+		}
+		return width;
+	}
+	layoutParagraph(block, sig, font, style, fixedWidth, maxWidth) {
+		const graphemes = [];
+		const runOf = [];
+		block.runs.forEach((run, ri) => {
+			for (const g of splitGraphemes(run.t)) {
+				graphemes.push(g);
+				runOf.push(ri);
+			}
+		});
+		const entry = {
+			sig,
+			graphemes,
+			runOf,
+			lines: []
+		};
+		const n = graphemes.length;
+		const spacing = style.letterSpacing;
+		const width = (a, b) => this.rangeWidth(entry, block.runs, a, b, font, spacing);
+		const shouldWrap = style.wrap !== "none";
+		const wrapAtWord = style.wrap !== "char" && shouldWrap;
+		const whole = width(0, n);
+		if (!fixedWidth || !shouldWrap || whole <= maxWidth || n === 0) {
+			entry.lines.push({
+				startG: 0,
+				endG: n,
+				measuredWidth: whole,
+				lastInParagraph: true
+			});
+			return entry;
+		}
+		let start = 0;
+		while (start < n) {
+			let low = 0;
+			let high = n - start;
+			let probe = Math.min(high, 32);
+			while (probe < high && width(start, start + probe) <= maxWidth) probe = Math.min(high, probe * 2);
+			high = probe;
+			let matchLen = 0;
+			let matchWidth = 0;
+			while (low < high) {
+				const mid = low + high >>> 1;
+				const w = width(start, start + mid + 1);
+				if (w <= maxWidth) {
+					low = mid + 1;
+					matchLen = mid + 1;
+					matchWidth = w;
+				} else high = mid;
+			}
+			if (matchLen === 0) {
+				matchLen = 1;
+				matchWidth = width(start, start + 1);
+			}
+			if (start + matchLen >= n) {
+				entry.lines.push({
+					startG: start,
+					endG: n,
+					measuredWidth: matchWidth,
+					lastInParagraph: true
+				});
+				return entry;
+			}
+			if (wrapAtWord) {
+				const nextChar = graphemes[start + matchLen];
+				const nextIsSpaceOrDash = nextChar === " " || nextChar === "-";
+				let wrapIndex;
+				if (nextIsSpaceOrDash && matchWidth <= maxWidth) wrapIndex = matchLen;
+				else {
+					const seg = graphemes.slice(start, start + matchLen);
+					wrapIndex = Math.max(seg.lastIndexOf(" "), seg.lastIndexOf("-")) + 1;
+				}
+				if (wrapIndex > 0) {
+					matchLen = wrapIndex;
+					matchWidth = width(start, start + matchLen);
+				}
+			}
+			let end = start + matchLen;
+			let trimmedEnd = end;
+			while (trimmedEnd > start && WS.test(graphemes[trimmedEnd - 1])) trimmedEnd--;
+			entry.lines.push({
+				startG: start,
+				endG: trimmedEnd,
+				measuredWidth: matchWidth,
+				lastInParagraph: false
+			});
+			while (end < n && WS.test(graphemes[end])) end++;
+			start = end;
+		}
+		const last = entry.lines[entry.lines.length - 1];
+		if (last) last.lastInParagraph = true;
+		return entry;
+	}
+	buildSegments(entry, block, pl, font, style) {
+		const segments = [];
+		let x = 0;
+		let i = pl.startG;
+		while (i < pl.endG) {
+			const run = entry.runOf[i];
+			let j = i;
+			while (j < pl.endG && entry.runOf[j] === run) j++;
+			const t = entry.graphemes.slice(i, j).join("");
+			const width = this.measureChunk(font, t, style.letterSpacing);
+			segments.push({
+				t,
+				m: block.runs[run].m,
+				x,
+				width
+			});
+			x += width;
+			i = j;
+		}
+		return segments;
+	}
+};
+//#endregion
+//#region src/nodes/text-v2/shape.ts
+const LAYOUT_ATTRS = [
+	"text",
+	"blocks",
+	"link",
+	"fontSize",
+	"fontFamily",
+	"fontStyle",
+	"fontVariant",
+	"lineHeight",
+	"letterSpacing",
+	"wrap",
+	"align",
+	"padding",
+	"width",
+	"height"
+];
+/**
+* Canvas shape that lays out and paints blocks/runs text with the
+* `TextLayoutEngine`. Exposes Konva.Text-compatible getters/setters so
+* code written against `Konva.Text` keeps working.
+*/
+var WeaveTextV2Shape = class extends Konva.Shape {
+	engine = new TextLayoutEngine();
+	naturalEngine = new TextLayoutEngine();
+	layoutCache = null;
+	blocksKey = {};
+	blocksCache = [];
+	viewport = null;
+	constructor(config) {
+		super(config);
+		this.className = "WeaveTextV2Shape";
+		this.on(LAYOUT_ATTRS.map((a) => `${a}Change.konva`).join(" "), () => {
+			this.layoutCache = null;
+		});
+		this.sceneFunc(this._paint);
+		this.hitFunc(this._hit);
+	}
+	text(value) {
+		if (value === void 0) return typeof this.attrs.text === "string" ? this.attrs.text : blocksToText(this.getBlocks());
+		return this.setText(value);
+	}
+	setText(value) {
+		this._setAttr("blocks", void 0);
+		this._setAttr("text", value == null ? "" : String(value));
+		return this;
+	}
+	/** Resolved blocks: stored or lazily synthesized (never written back). */
+	getBlocks() {
+		const k = this.blocksKey;
+		const { blocks, text, link } = this.attrs;
+		if (k.b !== blocks || k.t !== text || k.l !== link) {
+			this.blocksCache = resolveBlocks({
+				blocks,
+				text,
+				link
+			});
+			this.blocksKey = {
+				b: blocks,
+				t: text,
+				l: link
+			};
+		}
+		return this.blocksCache;
+	}
+	/** Replace content with blocks, keeping the `text` mirror in sync. */
+	setBlocks(blocks) {
+		this._setAttr("blocks", blocks);
+		this._setAttr("text", blocksToText(blocks));
+		return this;
+	}
+	fontSize(v) {
+		return this.accessor("fontSize", 12, v);
+	}
+	fontFamily(v) {
+		return this.accessor("fontFamily", "Arial", v);
+	}
+	fontStyle(v) {
+		return this.accessor("fontStyle", "normal", v);
+	}
+	fontVariant(v) {
+		return this.accessor("fontVariant", "normal", v);
+	}
+	lineHeight(v) {
+		return this.accessor("lineHeight", 1, v);
+	}
+	letterSpacing(v) {
+		return this.accessor("letterSpacing", 0, v);
+	}
+	padding(v) {
+		return this.accessor("padding", 0, v);
+	}
+	align(v) {
+		return this.accessor("align", "left", v);
+	}
+	verticalAlign(v) {
+		return this.accessor("verticalAlign", "top", v);
+	}
+	wrap(v) {
+		return this.accessor("wrap", "word", v);
+	}
+	textDecoration(v) {
+		return this.accessor("textDecoration", "", v);
+	}
+	accessor(name, fallback, value) {
+		if (value === void 0) return this.attrs[name] ?? fallback;
+		this.setAttr(name, value);
+		return this;
+	}
+	getTextWidth() {
+		return this.ensureLayout().textWidth;
+	}
+	getTextHeight() {
+		return this.fontSize();
+	}
+	measureSize(text) {
+		return {
+			width: canvasMeasurer(fontString(this.style()), text),
+			height: this.fontSize()
+		};
+	}
+	getWidth() {
+		const w = this.attrs.width;
+		return w === void 0 || w === "auto" || Number.isNaN(w) ? this.ensureLayout().width : w;
+	}
+	getHeight() {
+		const h = this.attrs.height;
+		return h === void 0 || h === "auto" || Number.isNaN(h) ? this.ensureLayout().height : h;
+	}
+	style() {
+		return {
+			fontSize: this.fontSize(),
+			fontFamily: this.fontFamily(),
+			fontStyle: this.fontStyle(),
+			fontVariant: this.fontVariant(),
+			lineHeight: this.lineHeight(),
+			letterSpacing: this.letterSpacing(),
+			wrap: this.wrap(),
+			align: this.align()
+		};
+	}
+	/** Lazy, cached layout. Size accessors and painting force it. */
+	ensureLayout() {
+		if (!this.layoutCache) {
+			const w = this.attrs.width;
+			const h = this.attrs.height;
+			const num = (v) => typeof v === "number" && !Number.isNaN(v) ? v : void 0;
+			this.layoutCache = this.engine.layout(this.getBlocks(), this.style(), {
+				width: num(w),
+				height: num(h),
+				padding: this.padding()
+			});
+		}
+		return this.layoutCache;
+	}
+	/** Size the text would take with no width constraint (for auto layouts). */
+	measureNaturalSize() {
+		const out = this.naturalEngine.layout(this.getBlocks(), this.style(), {
+			width: void 0,
+			height: void 0,
+			padding: this.padding()
+		});
+		return {
+			width: out.width,
+			height: out.height
+		};
+	}
+	/** Rendered width of a string with this shape's font and letter spacing. */
+	measureText(text) {
+		return canvasMeasurer(fontString(this.style()), text) + text.length * this.letterSpacing();
+	}
+	/** Offset of the first line inside the box (padding + vertical align). */
+	getContentOffset() {
+		const padding = this.padding();
+		const layout = this.ensureLayout();
+		const used = layout.lines.length * layout.lineHeightPx + padding * 2;
+		const va = this.verticalAlign();
+		let alignY = 0;
+		if (va === "middle") alignY = (this.getHeight() - used) / 2;
+		else if (va === "bottom") alignY = this.getHeight() - used;
+		return {
+			x: padding,
+			y: alignY + padding
+		};
+	}
+	/** Pre-compute layout for candidate blocks within a time budget. */
+	warmLayout(blocks, budgetMs) {
+		const num = (v) => typeof v === "number" && !Number.isNaN(v) ? v : void 0;
+		return this.engine.warm(blocks, this.style(), {
+			width: num(this.attrs.width),
+			height: num(this.attrs.height),
+			padding: this.padding()
+		}, budgetMs);
+	}
+	/** Optional visible y-range in local coordinates, used for line culling. */
+	setViewport(range) {
+		this.viewport = range;
+	}
+	visibleRange() {
+		if (this.viewport) return this.viewport;
+		const stage = this.getStage();
+		if (!stage) return null;
+		const inv = this.getAbsoluteTransform().copy().invert();
+		const w = stage.width();
+		const h = stage.height();
+		const pts = [
+			inv.point({
+				x: 0,
+				y: 0
+			}),
+			inv.point({
+				x: w,
+				y: 0
+			}),
+			inv.point({
+				x: 0,
+				y: h
+			}),
+			inv.point({
+				x: w,
+				y: h
+			})
+		];
+		return {
+			y1: Math.min(...pts.map((p) => p.y)),
+			y2: Math.max(...pts.map((p) => p.y))
+		};
+	}
+	_paint = (ctx, shape) => {
+		const self = shape;
+		const layout = self.ensureLayout();
+		if (layout.lines.length === 0) return;
+		const fontSize = self.fontSize();
+		const padding = self.padding();
+		const lineHeightPx = layout.lineHeightPx;
+		const decoration = self.textDecoration();
+		const underline = decoration.includes("underline");
+		const lineThrough = decoration.includes("line-through");
+		const spacing = self.letterSpacing();
+		const fill = self.fill();
+		let baseline = "middle";
+		let translateY = lineHeightPx / 2;
+		if (!Konva.legacyTextRendering) {
+			const m = self.measureMetrics();
+			baseline = "alphabetic";
+			translateY = (m.ascent - m.descent) / 2 + lineHeightPx / 2;
+		}
+		ctx.setAttr("font", fontString(self.style()));
+		ctx.setAttr("textBaseline", baseline);
+		ctx.setAttr("textAlign", "left");
+		let alignY = 0;
+		const va = self.verticalAlign();
+		const used = layout.lines.length * lineHeightPx + padding * 2;
+		if (va === "middle") alignY = (self.getHeight() - used) / 2;
+		else if (va === "bottom") alignY = self.getHeight() - used;
+		ctx.translate(padding, alignY + padding);
+		const range = self.visibleRange();
+		const paintSelf = self;
+		for (let n = 0; n < layout.lines.length; n++) {
+			const line = layout.lines[n];
+			const y = translateY + n * lineHeightPx;
+			if (range && (alignY + padding + n * lineHeightPx + lineHeightPx < range.y1 - lineHeightPx || alignY + padding + n * lineHeightPx > range.y2 + lineHeightPx)) continue;
+			ctx.save();
+			const baseX = line.offsetX;
+			if (underline) {
+				ctx.save();
+				ctx.beginPath();
+				const uy = y + Math.round(fontSize / 4);
+				ctx.moveTo(baseX, uy);
+				ctx.lineTo(baseX + Math.round(line.width), uy);
+				ctx.lineWidth = fontSize / 15;
+				ctx.strokeStyle = fill;
+				ctx.stroke();
+				ctx.restore();
+			}
+			for (const seg of line.segments) {
+				let x = baseX + seg.x;
+				if (spacing !== 0) for (const ch of Array.from(seg.t)) {
+					paintSelf._partialText = ch;
+					paintSelf._partialTextX = x;
+					paintSelf._partialTextY = y;
+					ctx.fillStrokeShape(self);
+					x += self.measureSize(ch).width + spacing;
+				}
+				else {
+					paintSelf._partialText = seg.t;
+					paintSelf._partialTextX = x;
+					paintSelf._partialTextY = y;
+					ctx.fillStrokeShape(self);
+				}
+			}
+			if (lineThrough) {
+				ctx.save();
+				ctx.beginPath();
+				const ly = y - Math.round(fontSize / 4);
+				ctx.moveTo(baseX, ly);
+				ctx.lineTo(baseX + Math.round(line.width), ly);
+				ctx.lineWidth = fontSize / 15;
+				ctx.strokeStyle = fill;
+				ctx.stroke();
+				ctx.restore();
+			}
+			ctx.restore();
+		}
+	};
+	_hit = (ctx, shape) => {
+		ctx.beginPath();
+		const self = shape;
+		ctx.rect(0, 0, self.getWidth(), self.getHeight());
+		ctx.closePath();
+		ctx.fillStrokeShape(shape);
+	};
+	metricsCache = null;
+	/** Font ascent/descent used for baseline placement (parity with Konva.Text). */
+	measureMetrics() {
+		const font = fontString(this.style());
+		if (this.metricsCache?.key === font) return this.metricsCache;
+		const ctx = Konva.Util.createCanvasElement().getContext("2d");
+		ctx.font = font;
+		const m = ctx.measureText("M");
+		const scale = this.fontSize() / 100;
+		const ascent = m.fontBoundingBoxAscent ?? 91 * scale;
+		const descent = m.fontBoundingBoxDescent ?? 21 * scale;
+		this.metricsCache = {
+			key: font,
+			ascent,
+			descent
+		};
+		return this.metricsCache;
+	}
+};
+Object.assign(WeaveTextV2Shape.prototype, {
+	_fillFunc(ctx) {
+		ctx.fillText(this._partialText, this._partialTextX, this._partialTextY);
+	},
+	_strokeFunc(ctx) {
+		ctx.setAttr("miterLimit", 2);
+		ctx.strokeText(this._partialText, this._partialTextX, this._partialTextY);
+	}
+});
+//#endregion
+//#region src/nodes/text-v2/edit/geometry.ts
+const graphemeSeg = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : null;
+const wordSeg = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter(void 0, { granularity: "word" }) : null;
+function boundaries(text, seg) {
+	if (!seg) return Array.from({ length: text.length + 1 }, (_, i) => i);
+	const out = [0];
+	for (const s of seg.segment(text)) out.push(s.index + s.segment.length);
+	return out;
+}
+function prevGrapheme(text, offset) {
+	if (offset <= 0) return 0;
+	const b = boundaries(text, graphemeSeg);
+	for (let i = b.length - 1; i >= 0; i--) if (b[i] < offset) return b[i];
+	return 0;
+}
+function nextGrapheme(text, offset) {
+	if (offset >= text.length) return text.length;
+	const b = boundaries(text, graphemeSeg);
+	for (const v of b) if (v > offset) return v;
+	return text.length;
+}
+/** Word segment [start, end) containing (or adjacent to) the offset. */
+function wordRangeAt(text, offset) {
+	if (text === "") return [0, 0];
+	offset = Math.max(0, Math.min(offset, text.length));
+	if (!wordSeg) {
+		let s = offset;
+		let e = offset;
+		while (s > 0 && /\S/.test(text[s - 1])) s--;
+		while (e < text.length && /\S/.test(text[e])) e++;
+		return [s, e];
+	}
+	let last = [offset, offset];
+	for (const seg of wordSeg.segment(text)) {
+		const s = seg.index;
+		const e = s + seg.segment.length;
+		last = [s, e];
+		if (offset < e) return [s, e];
+	}
+	return last;
+}
+/** Paragraph range [start, end) (no trailing newline) containing offset. */
+function paragraphRangeAt(text, offset) {
+	offset = Math.max(0, Math.min(offset, text.length));
+	const s = text.lastIndexOf("\n", offset - 1) + 1;
+	let e = text.indexOf("\n", offset);
+	if (e === -1) e = text.length;
+	return [s, e];
+}
+/** Previous word start (Ctrl+Left semantics). */
+function prevWordBoundary(text, offset) {
+	let i = offset;
+	while (i > 0 && /\s/.test(text[i - 1])) i--;
+	if (i === 0) return 0;
+	return wordRangeAt(text, i - 1)[0];
+}
+/** Next word end (Ctrl+Right semantics). */
+function nextWordBoundary(text, offset) {
+	let i = offset;
+	while (i < text.length && /\s/.test(text[i])) i++;
+	if (i >= text.length) return text.length;
+	return wordRangeAt(text, i)[1];
+}
+function lineIndexAt(layout, offset) {
+	const lines = layout.lines;
+	if (lines.length === 0) return 0;
+	let fallback = 0;
+	for (let i = 0; i < lines.length; i++) {
+		const l = lines[i];
+		if (l.start <= offset) fallback = i;
+		if (offset >= l.start && offset <= l.end) {
+			const next = lines[i + 1];
+			if (offset === l.end && !l.lastInParagraph && next && next.start === offset) continue;
+			return i;
+		}
+	}
+	return fallback;
+}
+function lineX(line, offset, measure) {
+	const k = Math.max(0, Math.min(offset - line.start, line.text.length));
+	return line.offsetX + (k === 0 ? 0 : measure(line.text.slice(0, k)));
+}
+/** Caret rectangle in text-local coordinates (before padding/valign offset). */
+function caretRect(layout, offset, measure) {
+	const i = lineIndexAt(layout, offset);
+	const line = layout.lines[i];
+	if (!line) return {
+		x: 0,
+		y: 0,
+		height: layout.lineHeightPx,
+		line: 0
+	};
+	return {
+		x: lineX(line, offset, measure),
+		y: i * layout.lineHeightPx,
+		height: layout.lineHeightPx,
+		line: i
+	};
+}
+/** Offset closest to a point in text-local coordinates. */
+function offsetFromPoint(layout, point, measure) {
+	const lines = layout.lines;
+	if (lines.length === 0) return 0;
+	return offsetInLine(lines[Math.max(0, Math.min(lines.length - 1, Math.floor(point.y / layout.lineHeightPx)))], point.x, measure);
+}
+function offsetInLine(line, x, measure) {
+	const rel = x - line.offsetX;
+	if (rel <= 0 || line.text === "") return line.start;
+	const b = boundaries(line.text, graphemeSeg);
+	let prevW = 0;
+	for (let k = 1; k < b.length; k++) {
+		const w = measure(line.text.slice(0, b[k]));
+		if (rel < (prevW + w) / 2) return line.start + b[k - 1];
+		prevW = w;
+	}
+	return line.end;
+}
+/** Move one visual line up/down keeping a desired x. */
+function moveVertical(layout, offset, dir, desiredX, measure) {
+	const j = lineIndexAt(layout, offset) + dir;
+	if (j < 0) return 0;
+	if (j >= layout.lines.length) {
+		const last = layout.lines[layout.lines.length - 1];
+		return last ? last.end : 0;
+	}
+	return offsetInLine(layout.lines[j], desiredX, measure);
+}
+function lineHome(layout, offset) {
+	return layout.lines[lineIndexAt(layout, offset)]?.start ?? 0;
+}
+function lineEnd(layout, offset) {
+	return layout.lines[lineIndexAt(layout, offset)]?.end ?? 0;
+}
+/** Selection rectangles (one per touched line) in text-local coordinates. */
+function selectionRects(layout, from, to, measure) {
+	if (from > to) [from, to] = [to, from];
+	if (from === to) return [];
+	const out = [];
+	layout.lines.forEach((line, i) => {
+		const hasNewline = line.lastInParagraph;
+		const lineFrom = Math.max(from, line.start);
+		const lineTo = Math.min(to, hasNewline ? line.end + 1 : line.end);
+		if (lineTo <= lineFrom && !(line.start === line.end && from <= line.start && to > line.start)) return;
+		const x1 = lineX(line, Math.min(lineFrom, line.end), measure);
+		let x2 = lineX(line, Math.min(lineTo, line.end), measure);
+		if (hasNewline && to > line.end) x2 += Math.max(4, layout.textHeight / 3);
+		if (x2 <= x1) return;
+		out.push({
+			x: x1,
+			y: i * layout.lineHeightPx,
+			width: x2 - x1,
+			height: layout.lineHeightPx
+		});
+	});
+	return out;
+}
+//#endregion
+//#region src/nodes/text-v2/edit/model.ts
+/**
+* Session-local edit state: content + selection + undo/redo with
+* coalescing. Typing and deleting merge into one entry while they continue
+* in the same direction without a selection move; paste and IME composition
+* are always one entry each. Independent of Konva and the DOM.
+*/
+var TextEditModel = class {
+	blocks;
+	anchor = 0;
+	focus = 0;
+	/** x kept while moving vertically; reset by any other move. */
+	desiredX = null;
+	undoStack = [];
+	redoStack = [];
+	lastKind = null;
+	lastEditEnd = -1;
+	composing = false;
+	constructor(blocks) {
+		this.blocks = blocks;
+		const len = blocksToText(blocks).length;
+		this.anchor = this.focus = len;
+	}
+	getBlocks() {
+		return this.blocks;
+	}
+	getText() {
+		return blocksToText(this.blocks);
+	}
+	getSelection() {
+		return {
+			start: Math.min(this.anchor, this.focus),
+			end: Math.max(this.anchor, this.focus)
+		};
+	}
+	getSelectedText() {
+		const { start, end } = this.getSelection();
+		return this.getText().slice(start, end);
+	}
+	canUndo() {
+		return this.undoStack.length > 0;
+	}
+	canRedo() {
+		return this.redoStack.length > 0;
+	}
+	setSelection(anchor, focus) {
+		const len = this.getText().length;
+		this.anchor = Math.max(0, Math.min(anchor, len));
+		this.focus = Math.max(0, Math.min(focus, len));
+		this.breakCoalescing();
+	}
+	moveTo(offset, extend = false, keepDesiredX = false) {
+		const len = this.getText().length;
+		const o = Math.max(0, Math.min(offset, len));
+		this.focus = o;
+		if (!extend) this.anchor = o;
+		if (!keepDesiredX) this.desiredX = null;
+		this.breakCoalescing();
+	}
+	selectAll() {
+		this.anchor = 0;
+		this.focus = this.getText().length;
+		this.breakCoalescing();
+	}
+	breakCoalescing() {
+		if (!this.composing) this.lastKind = null;
+	}
+	beginComposition() {
+		this.composing = true;
+		this.lastKind = null;
+	}
+	endComposition() {
+		this.composing = false;
+		this.lastKind = null;
+	}
+	snapshot() {
+		return {
+			blocks: this.blocks,
+			anchor: this.anchor,
+			focus: this.focus
+		};
+	}
+	record(kind, editStart) {
+		if (!(this.lastKind === kind && (kind === "type" || kind === "delete" || kind === "ime") && (kind === "ime" || this.lastEditEnd === editStart || kind === "delete"))) {
+			this.undoStack.push(this.snapshot());
+			if (this.undoStack.length > 500) this.undoStack.shift();
+		}
+		this.redoStack = [];
+		this.lastKind = kind;
+	}
+	/** Replace [start,end) with plain text and put the caret after it. */
+	replaceRange(start, end, text, kind) {
+		const len = this.getText().length;
+		start = Math.max(0, Math.min(start, len));
+		end = Math.max(start, Math.min(end, len));
+		if (start === end && text === "") return false;
+		this.record(kind, start);
+		this.blocks = replaceRange(this.blocks, start, end, text);
+		this.anchor = this.focus = start + text.length;
+		this.lastEditEnd = this.focus;
+		this.desiredX = null;
+		return true;
+	}
+	replaceSelection(text, kind) {
+		const { start, end } = this.getSelection();
+		return this.replaceRange(start, end, text, kind);
+	}
+	backspace(byWord = false) {
+		const { start, end } = this.getSelection();
+		if (start !== end) return this.replaceRange(start, end, "", "delete");
+		if (start === 0) return false;
+		const text = this.getText();
+		const from = byWord ? prevWordBoundary(text, start) : prevGrapheme(text, start);
+		return this.replaceRange(from, start, "", "delete");
+	}
+	del(byWord = false) {
+		const { start, end } = this.getSelection();
+		if (start !== end) return this.replaceRange(start, end, "", "delete");
+		const text = this.getText();
+		if (start >= text.length) return false;
+		const to = byWord ? nextWordBoundary(text, start) : nextGrapheme(text, start);
+		return this.replaceRange(start, to, "", "delete");
+	}
+	undo() {
+		const prev = this.undoStack.pop();
+		if (!prev) return false;
+		this.redoStack.push(this.snapshot());
+		this.restore(prev);
+		return true;
+	}
+	redo() {
+		const next = this.redoStack.pop();
+		if (!next) return false;
+		this.undoStack.push(this.snapshot());
+		this.restore(next);
+		return true;
+	}
+	restore(s) {
+		this.blocks = s.blocks;
+		this.anchor = s.anchor;
+		this.focus = s.focus;
+		this.lastKind = null;
+		this.desiredX = null;
+	}
+};
+const SLICE_BUDGET_MS = 8;
+const BLINK_MS = 530;
+var TextEditSession = class {
+	model;
+	target;
+	host;
+	id;
+	abort = new AbortController();
+	textarea = null;
+	overlay = null;
+	blinkTimer;
+	caretOn = true;
+	dragging = false;
+	composing = false;
+	pendingTimer;
+	pendingFlush = false;
+	destroyed = false;
+	initialJson;
+	constructor(target, host, id = "text-edit-session") {
+		this.target = target;
+		this.host = host;
+		this.id = id;
+		this.model = new TextEditModel(target.getBlocks());
+		this.initialJson = JSON.stringify(this.model.getBlocks());
+	}
+	start() {
+		const signal = this.abort.signal;
+		host_signal(this.host.signal, this.abort);
+		this.createTextarea();
+		this.createOverlay();
+		const ta = this.textarea;
+		const opts = { signal };
+		ta.addEventListener("keydown", this.onKeyDown, opts);
+		ta.addEventListener("keyup", this.onKeyUp, opts);
+		ta.addEventListener("beforeinput", this.onBeforeInput, opts);
+		ta.addEventListener("input", this.onInput, opts);
+		ta.addEventListener("paste", this.onPaste, opts);
+		ta.addEventListener("compositionstart", this.onCompositionStart, opts);
+		ta.addEventListener("compositionend", this.onCompositionEnd, opts);
+		ta.addEventListener("select", this.syncFromTextarea, opts);
+		ta.ownerDocument.addEventListener("selectionchange", this.syncFromTextarea, opts);
+		window.addEventListener("pointerdown", this.onPointerDown, {
+			signal,
+			capture: true
+		});
+		window.addEventListener("pointermove", this.onPointerMove, { signal });
+		window.addEventListener("pointerup", this.onPointerUp, { signal });
+		window.addEventListener("mousedown", this.onMouseDown, {
+			signal,
+			capture: true
+		});
+		window.weaveTextEditing = {
+			...window.weaveTextEditing ?? {},
+			[this.id]: this.id
+		};
+		this.syncTextarea();
+		ta.focus();
+		this.positionTextarea();
+		this.startBlink();
+		this.repaint();
+	}
+	/** Final content and whether it differs from when the session started. */
+	getResult() {
+		return {
+			blocks: this.model.getBlocks(),
+			changed: JSON.stringify(this.model.getBlocks()) !== this.initialJson
+		};
+	}
+	destroy() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		this.flushPending();
+		this.abort.abort();
+		clearInterval(this.blinkTimer);
+		clearTimeout(this.pendingTimer);
+		this.textarea?.remove();
+		this.textarea = null;
+		const layer = this.overlay?.getLayer();
+		this.overlay?.destroy();
+		this.overlay = null;
+		layer?.batchDraw();
+		const w = window;
+		if (w.weaveTextEditing) delete w.weaveTextEditing[this.id];
+	}
+	focus() {
+		this.textarea?.focus();
+	}
+	createTextarea() {
+		const ta = this.host.container.ownerDocument.createElement("textarea");
+		ta.setAttribute("autocapitalize", "off");
+		ta.setAttribute("autocomplete", "off");
+		ta.setAttribute("autocorrect", "off");
+		ta.setAttribute("spellcheck", "false");
+		ta.setAttribute("wrap", "off");
+		ta.setAttribute("aria-label", "Text editor");
+		ta.tabIndex = 1;
+		Object.assign(ta.style, {
+			position: "absolute",
+			left: "0px",
+			top: "0px",
+			width: "1px",
+			height: "1em",
+			margin: "0",
+			padding: "0",
+			border: "0",
+			outline: "none",
+			resize: "none",
+			overflow: "hidden",
+			whiteSpace: "pre",
+			opacity: "0",
+			fontSize: "16px",
+			background: "transparent",
+			color: "transparent",
+			caretColor: "transparent",
+			pointerEvents: "none",
+			zIndex: "1"
+		});
+		this.host.container.appendChild(ta);
+		this.textarea = ta;
+	}
+	syncTextarea() {
+		const ta = this.textarea;
+		if (!ta || this.composing) return;
+		const text = this.model.getText();
+		if (ta.value !== text) ta.value = text;
+		const { start, end } = this.model.getSelection();
+		const backward = this.model.focus < this.model.anchor;
+		if (ta.selectionStart !== start || ta.selectionEnd !== end) ta.setSelectionRange(start, end, backward ? "backward" : "forward");
+	}
+	positionTextarea() {
+		const ta = this.textarea;
+		if (!ta) return;
+		const c = this.caretStagePoint();
+		const p = this.host.stageToContainer(c);
+		ta.style.left = `${p.x}px`;
+		ta.style.top = `${p.y}px`;
+	}
+	caretStagePoint() {
+		const r = caretRect(this.target.getLayout(), this.model.focus, this.target.measure);
+		const o = this.target.getContentOffset();
+		return this.target.getAbsoluteTransform().point({
+			x: r.x + o.x,
+			y: r.y + o.y
+		});
+	}
+	syncFromTextarea = () => {
+		const ta = this.textarea;
+		if (!ta || this.composing || this.destroyed) return;
+		if (ta.getRootNode().activeElement !== ta) return;
+		if (ta.value !== this.model.getText()) return;
+		const backward = ta.selectionDirection === "backward";
+		const a = backward ? ta.selectionEnd : ta.selectionStart;
+		const f = backward ? ta.selectionStart : ta.selectionEnd;
+		if (a !== this.model.anchor || f !== this.model.focus) {
+			this.model.setSelection(a, f);
+			this.afterSelectionChange();
+		}
+	};
+	onKeyDown = (e) => {
+		e.stopPropagation();
+		const mod = e.ctrlKey || e.metaKey;
+		const key = e.key.toLowerCase();
+		if (e.key === "Escape") {
+			e.preventDefault();
+			this.host.onRequestExit("escape");
+			return;
+		}
+		if (mod && key === "z" && !e.shiftKey) {
+			e.preventDefault();
+			this.undo();
+			return;
+		}
+		if (mod && (key === "y" || key === "z" && e.shiftKey)) {
+			e.preventDefault();
+			this.redo();
+			return;
+		}
+		if (e.key === "Tab") {
+			e.preventDefault();
+			return;
+		}
+		if (this.composing) return;
+		if ((e.key === "ArrowUp" || e.key === "ArrowDown") && !mod && !e.altKey) {
+			e.preventDefault();
+			this.moveVertically(e.key === "ArrowUp" ? -1 : 1, e.shiftKey);
+			return;
+		}
+		if ((e.key === "Home" || e.key === "End") && !mod) {
+			e.preventDefault();
+			const layout = this.target.getLayout();
+			const to = e.key === "Home" ? lineHome(layout, this.model.focus) : lineEnd(layout, this.model.focus);
+			this.model.moveTo(to, e.shiftKey);
+			this.afterSelectionChange();
+			return;
+		}
+		setTimeout(this.syncFromTextarea, 0);
+	};
+	onKeyUp = (e) => {
+		e.stopPropagation();
+		this.syncFromTextarea();
+	};
+	onBeforeInput = (e) => {
+		if (e.inputType === "historyUndo" || e.inputType === "historyRedo") e.preventDefault();
+	};
+	moveVertically(dir, extend) {
+		const layout = this.target.getLayout();
+		if (this.model.desiredX === null) this.model.desiredX = caretRect(layout, this.model.focus, this.target.measure).x;
+		const to = moveVertical(layout, this.model.focus, dir, this.model.desiredX, this.target.measure);
+		this.model.moveTo(to, extend, true);
+		this.afterSelectionChange();
+	}
+	onInput = (e) => {
+		const ta = this.textarea;
+		if (!ta) return;
+		const oldText = this.model.getText();
+		const newText = ta.value;
+		if (oldText === newText) return;
+		let p = 0;
+		const max = Math.min(oldText.length, newText.length);
+		while (p < max && oldText[p] === newText[p]) p++;
+		let s = 0;
+		while (s < max - p && oldText[oldText.length - 1 - s] === newText[newText.length - 1 - s]) s++;
+		const inserted = newText.slice(p, newText.length - s);
+		const inputType = e.inputType ?? "";
+		const kind = this.composing || inputType.includes("Composition") ? "ime" : inputType.startsWith("delete") ? "delete" : inputType === "insertFromPaste" ? "paste" : "type";
+		this.model.replaceRange(p, oldText.length - s, inserted, kind);
+		this.model.anchor = this.model.focus = Math.min(ta.selectionEnd, this.model.getText().length);
+		this.afterContentChange(inserted.length);
+	};
+	onPaste = (e) => {
+		e.stopPropagation();
+		e.preventDefault();
+		const raw = e.clipboardData?.getData("text/plain") ?? "";
+		if (raw === "") return;
+		this.insertText(raw.replace(/\r\n?/g, "\n"), "paste");
+	};
+	onCompositionStart = () => {
+		this.composing = true;
+		this.model.beginComposition();
+	};
+	onCompositionEnd = () => {
+		this.composing = false;
+		this.model.endComposition();
+		this.syncFromTextarea();
+	};
+	/** Programmatic insert at the selection (paste, tests, host actions). */
+	insertText(text, kind = "paste") {
+		if (this.model.replaceSelection(text, kind)) {
+			this.syncTextarea();
+			this.afterContentChange(text.length);
+		}
+	}
+	undo() {
+		this.flushPending();
+		if (this.model.undo()) {
+			this.syncTextarea();
+			this.afterContentChange(0, true);
+		}
+	}
+	redo() {
+		this.flushPending();
+		if (this.model.redo()) {
+			this.syncTextarea();
+			this.afterContentChange(0, true);
+		}
+	}
+	toLocal(e) {
+		const stagePt = this.host.clientToStage(e.clientX, e.clientY);
+		const p = this.target.getAbsoluteTransform().copy().invert().point(stagePt);
+		const o = this.target.getContentOffset();
+		return {
+			x: p.x - o.x,
+			y: p.y - o.y
+		};
+	}
+	isInside(local) {
+		const o = this.target.getContentOffset();
+		const { width, height } = this.target.getSize();
+		return local.x + o.x >= 0 && local.y + o.y >= 0 && local.x + o.x <= width && local.y + o.y <= height;
+	}
+	onMouseDown = (e) => {
+		if (this.isInside(this.toLocal(e))) e.preventDefault();
+	};
+	onPointerDown = (e) => {
+		if (e.button !== 0 && e.pointerType === "mouse") return;
+		if (this.textarea && e.target === this.textarea) return;
+		const local = this.toLocal(e);
+		if (!this.isInside(local)) {
+			e.stopPropagation();
+			this.host.onRequestExit("outside");
+			return;
+		}
+		e.stopPropagation();
+		e.preventDefault();
+		const offset = offsetFromPoint(this.target.getLayout(), local, this.target.measure);
+		const text = this.model.getText();
+		if (e.detail >= 3) {
+			const [s, en] = paragraphRangeAt(text, offset);
+			this.model.setSelection(s, en);
+		} else if (e.detail === 2) {
+			const [s, en] = wordRangeAt(text, offset);
+			this.model.setSelection(s, en);
+		} else {
+			this.model.moveTo(offset, e.shiftKey);
+			this.dragging = true;
+		}
+		this.syncTextarea();
+		this.afterSelectionChange();
+		this.textarea?.focus();
+	};
+	onPointerMove = (e) => {
+		if (!this.dragging) return;
+		const local = this.toLocal(e);
+		const offset = offsetFromPoint(this.target.getLayout(), local, this.target.measure);
+		this.model.moveTo(offset, true);
+		this.syncTextarea();
+		this.afterSelectionChange();
+	};
+	onPointerUp = () => {
+		if (!this.dragging) return;
+		this.dragging = false;
+		this.textarea?.focus();
+	};
+	afterSelectionChange() {
+		this.syncTextarea();
+		this.positionTextarea();
+		this.resetBlink();
+		this.repaint();
+	}
+	afterContentChange(insertedLength, immediate = false) {
+		this.flushPending();
+		if (!immediate && insertedLength > 2e4 && typeof this.target.warmLayout === "function") {
+			this.pendingFlush = true;
+			this.sliceLayout();
+		} else this.applyContent();
+		this.resetBlink();
+	}
+	sliceLayout = () => {
+		if (!this.pendingFlush || this.destroyed) return;
+		if (this.target.warmLayout(this.model.getBlocks(), SLICE_BUDGET_MS)) this.flushPending();
+		else this.pendingTimer = setTimeout(this.sliceLayout, 0);
+	};
+	flushPending() {
+		if (!this.pendingFlush) return;
+		this.pendingFlush = false;
+		clearTimeout(this.pendingTimer);
+		this.applyContent();
+	}
+	applyContent() {
+		this.target.setBlocks(this.model.getBlocks());
+		this.host.onChange?.(this.model.getBlocks());
+		this.positionTextarea();
+		this.target.requestRedraw();
+		this.repaint();
+	}
+	createOverlay() {
+		const layer = this.host.utilityLayer;
+		if (!layer) return;
+		const overlay = new Konva.Shape({
+			name: "text-v2-edit-overlay",
+			listening: false,
+			sceneFunc: (ctx, shape) => this.paintOverlay(ctx, shape)
+		});
+		layer.add(overlay);
+		overlay.moveToTop();
+		this.overlay = overlay;
+	}
+	paintOverlay(ctx, shape) {
+		if (this.destroyed || this.pendingFlush) return;
+		const layout = this.target.getLayout();
+		const abs = this.target.getAbsoluteTransform();
+		const rel = shape.getAbsoluteTransform().copy().invert().multiply(abs);
+		const o = this.target.getContentOffset();
+		ctx.save();
+		ctx.transform(rel.m[0], rel.m[1], rel.m[2], rel.m[3], rel.m[4], rel.m[5]);
+		ctx.translate(o.x, o.y);
+		const { start, end } = this.model.getSelection();
+		if (start !== end) {
+			ctx.setAttr("fillStyle", this.host.selectionColor);
+			for (const r of selectionRects(layout, start, end, this.target.measure)) ctx.fillRect(r.x, r.y, r.width, r.height);
+		} else if (this.caretOn) {
+			const c = caretRect(layout, this.model.focus, this.target.measure);
+			const scale = Math.hypot(abs.m[0], abs.m[1]) || 1;
+			const w = Math.max(1, 1.5) / scale;
+			ctx.setAttr("fillStyle", this.host.caretColor);
+			ctx.fillRect(c.x - w / 2, c.y, w, c.height);
+		}
+		ctx.restore();
+	}
+	repaint() {
+		this.overlay?.getLayer()?.batchDraw();
+	}
+	startBlink() {
+		this.blinkTimer = setInterval(() => {
+			this.caretOn = !this.caretOn;
+			this.repaint();
+		}, BLINK_MS);
+	}
+	resetBlink() {
+		this.caretOn = true;
+		if (this.blinkTimer) {
+			clearInterval(this.blinkTimer);
+			this.startBlink();
+		}
+	}
+};
+function host_signal(signal, abort) {
+	if (!signal) return;
+	if (signal.aborted) abort.abort();
+	else signal.addEventListener("abort", () => abort.abort(), { once: true });
+}
+//#endregion
+//#region src/nodes/text-v2/constants.ts
+/** Default threshold for `onTextSizeWarning` (chars of serialized blocks). */
+const WEAVE_TEXT_V2_SIZE_WARNING_THRESHOLD = 2e5;
+const WEAVE_TEXT_V2_SELECTION_COLOR = "rgba(66, 133, 244, 0.35)";
+const WEAVE_TEXT_V2_DEFAULT_CONFIG = {
+	...WEAVE_TEXT_NODE_DEFAULT_CONFIG,
+	sizeWarning: { threshold: WEAVE_TEXT_V2_SIZE_WARNING_THRESHOLD }
+};
+//#endregion
+//#region src/nodes/text-v2/text-v2.ts
+const CORNER_ANCHORS = [
+	"top-left",
+	"top-right",
+	"bottom-left",
+	"bottom-right"
+];
+const SIDE_ANCHORS = ["middle-right", "middle-left"];
+/**
+* Drop-in replacement for `WeaveTextNode`. Same `nodeType` (`'text'`), so
+* existing documents load unchanged; register it INSTEAD of `WeaveTextNode`
+* (handlers are keyed by node type). Renders through `WeaveTextV2Shape`
+* (blocks/runs model + layout engine) instead of `Konva.Text`.
+*/
+var WeaveTextV2Node = class extends WeaveNode {
+	config;
+	nodeType = WEAVE_TEXT_NODE_TYPE;
+	createNode = false;
+	editing = false;
+	editingNodeId = null;
+	session = null;
+	sizeWarned = false;
+	nodeRenderedAddedRegistered = false;
+	keyPressHandler;
+	constructor(params) {
+		super();
+		this.config = (0, import_merge.default)({}, WEAVE_TEXT_V2_DEFAULT_CONFIG, params?.config);
+	}
+	initialize() {
+		this.keyPressHandler = void 0;
+		this.editing = false;
+		this.editingNodeId = null;
+		this.session = null;
+		this.nodeRenderedAddedRegistered = false;
+	}
+	/**
+	* Resolve width/height for the layout mode. Auto modes size from the
+	* engine's natural measure (independent of zoom, unlike the DOM-based
+	* measure of the legacy node).
+	*/
+	resolveSize(shape, props) {
+		let width = props.width;
+		let height = props.height;
+		if (props.layout === TEXT_LAYOUT.AUTO_ALL) {
+			const nat = shape.measureNaturalSize();
+			width = nat.width + 2;
+			height = nat.height + 2;
+		}
+		if (props.layout === TEXT_LAYOUT.SMART && !props.smartFixedWidth) {
+			width = Math.max(1, shape.measureNaturalSize().width * 1.01);
+			height = void 0;
+		}
+		if (props.layout === TEXT_LAYOUT.SMART && props.smartFixedWidth) height = void 0;
+		if (props.layout === TEXT_LAYOUT.AUTO_HEIGHT) height = void 0;
+		return {
+			width,
+			height
+		};
+	}
+	measureMultilineText(shape) {
+		return () => {
+			const nat = shape.measureNaturalSize();
+			return {
+				width: Math.max(1, nat.width),
+				height: Math.max(1, nat.height)
+			};
+		};
+	}
+	linkOverrides(props) {
+		return {
+			linkPreviousFill: props.link ? props.linkPreviousFill ?? props.fill : props.linkPreviousFill,
+			linkPreviousTextDecoration: props.link ? props.linkPreviousTextDecoration ?? props.textDecoration : props.linkPreviousTextDecoration
+		};
+	}
+	outlineProps() {
+		return this.config.outline.enabled ? {
+			strokeEnabled: true,
+			stroke: this.config.outline.color,
+			strokeWidth: this.config.outline.width,
+			fillAfterStrokeEnabled: true
+		} : { strokeEnabled: false };
+	}
+	onRender(props) {
+		const { linkPreviousFill, linkPreviousTextDecoration } = this.linkOverrides(props);
+		const text = new WeaveTextV2Shape({
+			...props,
+			name: "node",
+			...this.outlineProps(),
+			...props.link && {
+				textDecoration: "underline",
+				fill: this.config.link.defaultColor,
+				linkPreviousFill,
+				linkPreviousTextDecoration
+			}
+		});
+		this.setupDefaultNodeAugmentation(text);
+		const defaultTransformerProperties = this.defaultGetTransformerProperties(this.config.transform);
+		text.getTransformerProperties = function() {
+			const layout = this.getAttrs().layout;
+			if (layout === TEXT_LAYOUT.SMART) return {
+				...defaultTransformerProperties,
+				ignoreStroke: true,
+				resizeEnabled: true,
+				keepRatio: false,
+				enabledAnchors: []
+			};
+			if (layout === TEXT_LAYOUT.AUTO_ALL) return {
+				...defaultTransformerProperties,
+				ignoreStroke: true,
+				resizeEnabled: false,
+				enabledAnchors: []
+			};
+			if (layout === TEXT_LAYOUT.AUTO_HEIGHT) return {
+				...defaultTransformerProperties,
+				ignoreStroke: true,
+				resizeEnabled: true,
+				enabledAnchors: SIDE_ANCHORS
+			};
+			return defaultTransformerProperties;
+		};
+		text.allowedAnchors = function() {
+			const layout = this.getAttrs().layout;
+			if (layout === TEXT_LAYOUT.SMART) return [...CORNER_ANCHORS, ...SIDE_ANCHORS];
+			if (layout === TEXT_LAYOUT.AUTO_ALL) return [];
+			if (layout === TEXT_LAYOUT.AUTO_HEIGHT) return SIDE_ANCHORS;
+			return [
+				...CORNER_ANCHORS,
+				"top-center",
+				"bottom-center",
+				...SIDE_ANCHORS
+			];
+		};
+		text.setAttrs({ measureMultilineText: this.measureMultilineText(text) });
+		this.setupDefaultNodeEvents(text, { performScaleReset: false });
+		text.dblClick = () => {
+			if (this.editing) return;
+			if (!(this.isSelecting() && this.isNodeSelected(text))) return;
+			this.triggerEditMode(text);
+		};
+		text.setAttr("triggerEditMode", this.triggerEditMode.bind(this));
+		this.setupLinkBehavior(text);
+		this.setupTransform(text);
+		if (!this.nodeRenderedAddedRegistered) {
+			this.instance.addEventListener("onNodeRenderedAdded", (node) => {
+				if (this.editing && this.editingNodeId !== null && node.id() === this.editingNodeId && node.getAttr("cancelEditMode")) node.getAttr("cancelEditMode")?.();
+			});
+			this.nodeRenderedAddedRegistered = true;
+		}
+		this.registerKeyPress();
+		return text;
+	}
+	handleKeyPress = (e) => {
+		if (e.code !== "Enter" || this.instance.getActiveAction() !== "selectionTool" || this.editing) return;
+		e.preventDefault();
+		const selected = this.getNodesSelectionPlugin()?.getSelectedNodes() ?? [];
+		if (this.isSelecting() && selected.length === 1 && selected[0].getAttrs().nodeType === "text") this.triggerEditMode(selected[0]);
+	};
+	registerKeyPress() {
+		if (this.instance.isServerSide() || this.keyPressHandler) return;
+		this.keyPressHandler = this.handleKeyPress.bind(this);
+		window.addEventListener("keypress", this.keyPressHandler, { signal: this.instance.getEventsController().signal });
+	}
+	onAdd() {
+		this.registerKeyPress();
+	}
+	onDestroyInstance() {
+		super.onDestroyInstance();
+		this.session?.destroy();
+		this.session = null;
+		if (!this.instance.isServerSide() && this.keyPressHandler) {
+			window.removeEventListener("keypress", this.keyPressHandler);
+			this.keyPressHandler = void 0;
+		}
+	}
+	/** Re-apply layout-driven width/height after live content changes. */
+	applySize(shape) {
+		const { width, height } = this.resolveSize(shape, shape.getAttrs());
+		shape.setAttrs({
+			width,
+			height
+		});
+	}
+	editTarget(shape) {
+		return {
+			getBlocks: () => shape.getBlocks(),
+			setBlocks: (blocks) => {
+				shape.setBlocks(blocks);
+				this.applySize(shape);
+			},
+			getLayout: () => shape.ensureLayout(),
+			measure: (t) => shape.measureText(t),
+			getAbsoluteTransform: () => shape.getAbsoluteTransform(),
+			getContentOffset: () => shape.getContentOffset(),
+			getSize: () => ({
+				width: shape.getWidth(),
+				height: shape.getHeight()
+			}),
+			getFontSize: () => shape.fontSize(),
+			requestRedraw: () => shape.getLayer()?.batchDraw(),
+			warmLayout: (blocks, budget) => shape.warmLayout(blocks, budget)
+		};
+	}
+	triggerEditMode(shape, create = false) {
+		if (create) this.createNode = true;
+		if (!this.instance.setMutexLock({
+			nodeIds: [shape.id()],
+			operation: "text-edit"
+		})) return;
+		this.editing = true;
+		this.editingNodeId = shape.id();
+		this.sizeWarned = false;
+		const selectionPlugin = this.instance.getPlugin("nodesSelection");
+		if (selectionPlugin) {
+			const tr = selectionPlugin.getTransformer();
+			this.instance.disablePlugin("nodesSelection");
+			tr.hide();
+		}
+		const stage = this.instance.getStage();
+		const container = stage.container();
+		const rect = () => container.getBoundingClientRect();
+		this.session = new TextEditSession(this.editTarget(shape), {
+			utilityLayer: this.instance.getUtilityLayer(),
+			container,
+			clientToStage: (cx, cy) => {
+				const r = rect();
+				const sx = r.width ? stage.width() / r.width : 1;
+				const sy = r.height ? stage.height() / r.height : 1;
+				return {
+					x: (cx - r.left) * sx,
+					y: (cy - r.top) * sy
+				};
+			},
+			stageToContainer: (p) => {
+				const r = rect();
+				const sx = r.width ? r.width / stage.width() : 1;
+				const sy = r.height ? r.height / stage.height() : 1;
+				return {
+					x: p.x * sx,
+					y: p.y * sy
+				};
+			},
+			caretColor: this.config.cursor.color,
+			selectionColor: WEAVE_TEXT_V2_SELECTION_COLOR,
+			signal: this.instance.getEventsController().signal,
+			onChange: (blocks) => this.checkSize(shape, blocks),
+			onRequestExit: () => this.exitEditMode(shape)
+		}, shape.id());
+		shape.setAttr("cancelEditMode", () => this.exitEditMode(shape));
+		stage.mode(WEAVE_STAGE_TEXT_EDITION_MODE);
+		this.session.start();
+		this.instance.emitEvent("onEnterTextNodeEditMode", { node: shape });
+	}
+	checkSize(shape, blocks) {
+		const threshold = this.config.sizeWarning.threshold;
+		if (blocksToText(blocks).length * 8 < threshold) {
+			this.sizeWarned = false;
+			return;
+		}
+		const size = JSON.stringify(blocks).length;
+		if (size > threshold && !this.sizeWarned) {
+			this.sizeWarned = true;
+			this.instance.emitEvent("onTextSizeWarning", {
+				node: shape,
+				size,
+				threshold
+			});
+		} else if (size <= threshold) this.sizeWarned = false;
+	}
+	exitEditMode(shape) {
+		const session = this.session;
+		if (!session || !this.editing) return;
+		const { changed } = session.getResult();
+		session.destroy();
+		this.session = null;
+		this.instance.releaseMutexLock();
+		const stage = this.instance.getStage();
+		stage.mode(WEAVE_STAGE_DEFAULT_MODE);
+		this.editing = false;
+		this.editingNodeId = null;
+		shape.setAttr("cancelEditMode", void 0);
+		this.commitNode(shape, changed);
+		const liveNode = stage.findOne(`#${shape.id()}`) ?? shape;
+		const selectionPlugin = this.instance.getPlugin("nodesSelection");
+		if (selectionPlugin) {
+			this.instance.enablePlugin("nodesSelection");
+			selectionPlugin.setSelectedNodes([liveNode]);
+			this.instance.triggerAction(SELECTION_TOOL_ACTION_NAME);
+		}
+		stage.container().tabIndex = 1;
+		stage.container().click();
+		stage.container().focus();
+		this.instance.emitEvent("onExitTextNodeEditMode", { node: liveNode });
+	}
+	/** One `updateNode` per session; none when content is unchanged. */
+	commitNode(shape, changed) {
+		const live = this.instance.getStage().findOne(`#${shape.id()}`) ?? shape;
+		if (this.createNode) {
+			const serialized = this.serialize(live);
+			if (live.text() !== "") {
+				const container = live.getParent();
+				live.destroy();
+				this.instance.addNode(serialized, container?.getAttrs().id);
+			} else live.destroy();
+		} else if (changed) this.instance.updateNode(this.serialize(live));
+		this.createNode = false;
+	}
+	setupTransform(text) {
+		let actualAnchor = void 0;
+		const isSide = () => SIDE_ANCHORS.includes(actualAnchor ?? "");
+		const isCorner = () => CORNER_ANCHORS.includes(actualAnchor ?? "");
+		const autoWidthLayout = () => [TEXT_LAYOUT.AUTO_HEIGHT, TEXT_LAYOUT.SMART].includes(text.getAttrs().layout);
+		text.on("transformstart", (e) => {
+			const ctrlOrMeta = e.evt.ctrlKey || e.evt.metaKey;
+			this.instance.emitEvent("onTransform", e.target);
+			actualAnchor = this.getNodesSelectionPlugin()?.getTransformer()?.getActiveAnchor();
+			const layout = text.getAttrs().layout;
+			this.getNodesSelectionPlugin()?.getTransformer()?.keepRatio(layout === TEXT_LAYOUT.SMART && isCorner() || layout === TEXT_LAYOUT.FIXED && ctrlOrMeta);
+			if (autoWidthLayout() && isSide()) {
+				text.wrap("word");
+				text.scaleY(1);
+				text.height(void 0);
+			}
+			e.cancelBubble = true;
+		});
+		text.on("transform", () => {
+			if (autoWidthLayout() && isSide()) {
+				text.width(text.width() * text.scaleX());
+				text.scaleX(1);
+				text.scaleY(1);
+				text.height(void 0);
+				text.getLayer()?.batchDraw();
+			}
+			const layout = text.getAttrs().layout;
+			if (this.isSelecting() && this.isNodeSelected(text) && (layout !== TEXT_LAYOUT.SMART || !isCorner())) {
+				text.width(text.width() * text.scaleX());
+				resetScale(text);
+				text.fontSize(text.fontSize() * text.scaleY());
+			}
+			text.setAttr("shouldUpdateOnTransform", false);
+			text.getLayer()?.batchDraw();
+		});
+		text.on("transformend", () => {
+			this.instance.emitEvent("onTransform", null);
+			let definedSmartWidth = false;
+			let smartFixedWidth = text.getAttr("smartFixedWidth") ?? false;
+			const layout = text.getAttrs().layout;
+			if (layout !== TEXT_LAYOUT.SMART && !isCorner()) this.scaleReset(text);
+			if (layout === TEXT_LAYOUT.SMART && isCorner()) text.setAttrs({
+				width: Math.ceil(text.width() * text.scaleX()),
+				height: Math.ceil(text.height() * text.scaleY()),
+				fontSize: text.fontSize() * text.scaleY(),
+				scaleX: 1,
+				scaleY: 1
+			});
+			if (autoWidthLayout() && isSide() && !smartFixedWidth && !definedSmartWidth) {
+				text.setAttr("smartFixedWidth", true);
+				smartFixedWidth = true;
+				definedSmartWidth = true;
+				text.width(Math.ceil(text.width() * text.scaleX()));
+				text.scaleX(1);
+				text.scaleY(1);
+				text.height(void 0);
+				text.getLayer()?.batchDraw();
+				text.height(Math.ceil(text.height()));
+			}
+			if (layout === TEXT_LAYOUT.SMART && isSide() && smartFixedWidth && !definedSmartWidth) {
+				text.width(Math.ceil(text.width() * text.scaleX()));
+				text.scaleX(1);
+			}
+			this.instance.updateNode(this.serialize(text));
+		});
+	}
+	onUpdate(nodeInstance, nextProps) {
+		const shape = nodeInstance;
+		if (this.editing && this.editingNodeId === shape.id()) nextProps = {
+			...nextProps,
+			text: shape.attrs.text,
+			blocks: shape.attrs.blocks
+		};
+		const isLinked = Boolean(nextProps.link);
+		const { linkPreviousFill, linkPreviousTextDecoration } = this.linkOverrides(nextProps);
+		shape.setAttrs({
+			...nextProps,
+			...this.outlineProps(),
+			link: nextProps.link,
+			linkPreviousFill: isLinked ? linkPreviousFill : void 0,
+			linkPreviousTextDecoration: isLinked ? linkPreviousTextDecoration : void 0,
+			...isLinked && {
+				textDecoration: "underline",
+				fill: this.config.link.defaultColor
+			}
+		});
+		if (nextProps.blocks === void 0 && shape.attrs.blocks !== void 0) shape.setAttr("blocks", void 0);
+		const { width, height } = this.resolveSize(shape, nextProps);
+		shape.setAttrs({
+			width,
+			height
+		});
+		if (!this.editing) {
+			const selection = this.getNodesSelectionPlugin();
+			if (selection) selection.setSelectedNodes(selection.getSelectedNodes());
+		}
+	}
+	serialize(instance) {
+		const attrs = instance.getAttrs();
+		const cleanedAttrs = { ...attrs };
+		delete cleanedAttrs.mutexLocked;
+		delete cleanedAttrs.mutexUserId;
+		delete cleanedAttrs.draggable;
+		delete cleanedAttrs.triggerEditMode;
+		delete cleanedAttrs.cancelEditMode;
+		delete cleanedAttrs.measureMultilineText;
+		delete cleanedAttrs.overridesMouseControl;
+		delete cleanedAttrs.shouldUpdateOnTransform;
+		delete cleanedAttrs.dragBoundFunc;
+		if (cleanedAttrs.link) {
+			if (typeof cleanedAttrs.linkPreviousFill === "string") cleanedAttrs.fill = cleanedAttrs.linkPreviousFill;
+			if (typeof cleanedAttrs.linkPreviousTextDecoration === "string") cleanedAttrs.textDecoration = cleanedAttrs.linkPreviousTextDecoration;
+		}
+		return {
+			key: attrs.id ?? "",
+			type: attrs.nodeType,
+			props: {
+				...cleanedAttrs,
+				isCloned: void 0,
+				isCloneOrigin: void 0,
+				id: attrs.id ?? "",
+				nodeType: attrs.nodeType,
+				children: []
+			}
+		};
+	}
+	setupLinkBehavior(text) {
+		text.handleMouseover = () => {
+			if (!text.getAttrs().link) return;
+			text.fill(this.config.link.hoverColor);
+			text.getLayer()?.batchDraw();
+		};
+		text.handleMouseout = () => {
+			if (!text.getAttrs().link) return;
+			text.fill(this.config.link.defaultColor);
+			text.getLayer()?.batchDraw();
+		};
+		text.defineMousePointer = () => text.getAttrs().link ? "pointer" : "default";
+		let linkClickTimeout;
+		const clearLinkClickTimeout = () => {
+			if (linkClickTimeout) {
+				clearTimeout(linkClickTimeout);
+				linkClickTimeout = void 0;
+			}
+		};
+		const previousDblClick = text.dblClick?.bind(text) ?? (() => {});
+		text.dblClick = () => {
+			clearLinkClickTimeout();
+			previousDblClick();
+		};
+		text.click = ({ wasSelected, ctrlOrMetaPressed }) => {
+			if (!text.getAttrs().link) return;
+			if (ctrlOrMetaPressed) {
+				clearLinkClickTimeout();
+				this.openTextLink(text);
+				return;
+			}
+			if (wasSelected) {
+				clearLinkClickTimeout();
+				linkClickTimeout = setTimeout(() => {
+					linkClickTimeout = void 0;
+					this.openTextLink(text);
+				}, Konva.dblClickWindow);
+			}
+		};
+	}
+	openTextLink(textNode) {
+		if (this.instance.isServerSide()) return;
+		const link = textNode.getAttrs().link;
+		if (typeof link !== "string" || !isValidTextLink(link)) return;
+		window.open(link, "_blank", "noopener,noreferrer");
+	}
+	getLink(nodeInstance) {
+		const link = nodeInstance.getAttrs().link;
+		return typeof link === "string" ? link : void 0;
+	}
+	setLink(nodeInstance, url) {
+		if (!isValidTextLink(url)) return;
+		const serialized = this.serialize(nodeInstance);
+		serialized.props.linkPreviousFill = serialized.props.fill;
+		serialized.props.linkPreviousTextDecoration = serialized.props.textDecoration;
+		serialized.props.link = url;
+		this.instance.updateNode(serialized);
+	}
+	removeLink(nodeInstance) {
+		const serialized = this.serialize(nodeInstance);
+		delete serialized.props.link;
+		delete serialized.props.linkPreviousFill;
+		delete serialized.props.linkPreviousTextDecoration;
+		this.instance.updateNode(serialized);
+	}
+	resetSmartLayout(textNode) {
+		textNode.setAttr("smartFixedWidth", void 0);
+		textNode.width(Math.max(1, textNode.measureNaturalSize().width * 1.01));
+		this.instance.updateNode(this.serialize(textNode));
+	}
+	static defaultState(nodeId, params) {
+		return WeaveTextNode.defaultState(nodeId, params);
+	}
+	static addNodeState(defaultNodeState, props) {
+		return mergeExceptArrays(WeaveTextNode.addNodeState(defaultNodeState, props), { props: { ...props.blocks && { blocks: props.blocks } } });
 	}
 	static updateNodeState(prevNodeState, nextProps) {
-		return mergeExceptArrays(prevNodeState, { props: {
-			x: nextProps.x,
-			y: nextProps.y,
-			width: nextProps.width,
-			...nextProps.height && { height: nextProps.height },
-			FontFamily: nextProps.fontFamily,
-			fontSize: nextProps.fontSize,
-			fontStyle: nextProps.fontStyle,
-			fontVariant: nextProps.fontVariant,
-			textDecoration: nextProps.textDecoration,
-			letterSpacing: nextProps.letterSpacing,
-			lineHeight: nextProps.lineHeight,
-			align: nextProps.align,
-			verticalAlign: nextProps.verticalAlign,
-			rotation: nextProps.rotation,
-			fill: nextProps.fill,
-			text: nextProps.text,
-			layout: nextProps.layout,
-			...nextProps.strokeEnabled && { strokeEnabled: nextProps.strokeEnabled },
-			...nextProps.stroke && { stroke: nextProps.stroke },
-			...nextProps.strokeWidth && { strokeWidth: nextProps.strokeWidth },
-			...nextProps.fillAfterStrokeEnabled && { fillAfterStrokeEnabled: nextProps.fillAfterStrokeEnabled },
-			...nextProps.link && { link: nextProps.link }
-		} });
+		const next = WeaveTextNode.updateNodeState(prevNodeState, nextProps);
+		if (nextProps.blocks) next.props.blocks = nextProps.blocks;
+		else delete next.props.blocks;
+		return next;
 	}
 	static getSchema() {
-		return super.getSchema().extend({
-			type: z.literal(WEAVE_TEXT_NODE_TYPE).describe(`Type of the node, for a text node it will always be "${WEAVE_TEXT_NODE_TYPE}"`),
-			props: z.object({
-				nodeType: z.literal(WEAVE_TEXT_NODE_TYPE).describe(`Type of the node, for a text node it will always be "${WEAVE_TEXT_NODE_TYPE}"`),
-				width: z.number().describe("Width of the text in pixels"),
-				height: z.number().optional().describe("Height of the text in pixels. Optional if layout is auto-height or smart."),
-				fontFamily: z.string().default("Arial").describe("Font family of the text, e.g. Arial, Helvetica, etc."),
-				fontSize: z.number().default(16).describe("Font size of the text in pixels."),
-				fontStyle: z.string().regex(/^(?:normal|bold|\d+)(?: italic)?$/).default("normal").describe("Font style of the text, can be \"normal\", \"bold\", \"400\", \"italic\" or a combination like \"bold italic\" or \"700 italic\"."),
-				fontVariant: z.enum(["normal", "small-caps"]).describe("Font variant of the text, can be \"normal\" or \"small-caps\"."),
-				textDecoration: z.enum([
-					"line-through",
-					"underline",
-					""
-				]).default("").describe("Text decoration can be \"line-through\", \"underline\" or empty string for none."),
-				letterSpacing: z.number().default(0).describe("Spacing between letters in pixels."),
-				lineHeight: z.number().default(1).describe("Line height of the text, as a multiplier of font size."),
-				align: z.enum([
-					"left",
-					"center",
-					"right",
-					"justify"
-				]).default("left").describe("Text alignment, can be \"left\", \"center\", \"right\" or \"justify\"."),
-				verticalAlign: z.enum([
-					"top",
-					"middle",
-					"bottom"
-				]).default("top").describe("Vertical alignment of the text, can be 'top', 'middle' or 'bottom'."),
-				fill: z.string().default("#000000ff").describe("Fill color of the text  in hex format with alpha channel (e.g. #RRGGBBAA)."),
-				text: z.string().default("text").describe("The actual text content of the node."),
-				link: z.string().url().refine((value) => isValidTextLink(value), { message: "Link must be an absolute http:// or https:// URL." }).optional().describe("External URL the whole text of the node links to. When set, the text is forced underlined and coloured with the configured link colours regardless of fill/textDecoration, is clickable, and opens the URL in a new tab. Only http(s) URLs are accepted. Omit/remove to make the node plain text again."),
-				linkPreviousFill: z.string().optional().describe("Internal bookkeeping: the fill colour the node had right before a link was set, captured automatically so it can be restored when the link is removed. Managed automatically — do not set directly."),
-				linkPreviousTextDecoration: z.string().optional().describe("Internal bookkeeping: the textDecoration the node had right before a link was set, captured automatically so it can be restored when the link is removed. Managed automatically — do not set directly."),
-				strokeEnabled: z.boolean().default(false).describe("Whether the text outline is enabled."),
-				stroke: z.string().optional().default("#d6d6d6").describe("Color of the text outline in hex format with alpha channel (e.g. #RRGGBBAA)."),
-				strokeWidth: z.number().optional().default(2).describe("Width of the text outline in pixels."),
-				strokeScaleEnabled: z.boolean().default(true).describe("Whether the stroke width should scale when the node is scaled."),
-				fillAfterStrokeEnabled: z.boolean().default(true).describe("Whether the fill should be drawn after the stroke. If false, the stroke will be drawn on top of the fill."),
-				layout: z.enum(TEXT_LAYOUT).default(TEXT_LAYOUT.SMART).describe("Layout mode of the text node. Can be:\n- 'fixed': the text node will have fixed width and height, and the text will be scaled to fit the node.\n- 'auto-height': the width of the text node will be fixed, but the height will adjust to fit the text content.\n- 'auto-all': both width and height of the text node will adjust to fit the text content.\n- 'smart': the text node will try to adjust its size based on the content and layout, but it will not exceed the initial width and height set on the node.")
-			})
-		});
+		return WeaveTextNode.getSchema();
 	}
 };
 //#endregion
@@ -14487,24 +16511,64 @@ var WeaveImageCrop = class WeaveImageCrop {
 		this.onClose = () => {};
 		this.handleHide = this.hide.bind(this);
 	}
-	setupCropImage(imageAttrs, visible) {
-		this.cropGroup.destroyChildren();
+	/**
+	* Mirrors the start of a segment inside a container along one axis:
+	* the segment [start, start + length] inside [0, size] becomes
+	* [size - start - length, size - start]. Used to convert between visual
+	* space (what the user sees on a flipped image) and source space (where
+	* the crop information is stored). It is its own inverse.
+	*/
+	static mirrorOffset(start, length, size) {
+		return size - start - length;
+	}
+	/**
+	* Returns the offset (in uncropped display units) of the visible crop
+	* window inside the visually rendered uncropped image, along with the real
+	* scale. When the image is flipped the stored crop (source space) is
+	* mirrored to match what the user sees.
+	*/
+	getVisualCropOffset(imageAttrs) {
 		const actualScale = imageAttrs.uncroppedImage.width / imageAttrs.imageInfo.width;
 		const realScale = actualScale / (imageAttrs.cropInfo ? imageAttrs.cropInfo.scaleX : actualScale);
+		let x = 0;
+		let y = 0;
+		if (imageAttrs.cropInfo) {
+			x = imageAttrs.cropInfo.x * realScale;
+			y = imageAttrs.cropInfo.y * realScale;
+			if (imageAttrs.flipX === true) x = WeaveImageCrop.mirrorOffset(x, imageAttrs.cropInfo.width * realScale, imageAttrs.uncroppedImage.width);
+			if (imageAttrs.flipY === true) y = WeaveImageCrop.mirrorOffset(y, imageAttrs.cropInfo.height * realScale, imageAttrs.uncroppedImage.height);
+		}
+		return {
+			x,
+			y,
+			realScale
+		};
+	}
+	setupCropImage(imageAttrs, visible) {
+		this.cropGroup.destroyChildren();
+		const { x, y, realScale } = this.getVisualCropOffset(imageAttrs);
+		const flipX = imageAttrs.flipX === true;
+		const flipY = imageAttrs.flipY === true;
 		this.cropImage = new Konva.Image({
-			x: imageAttrs.cropInfo ? -imageAttrs.cropInfo.x * realScale : 0,
-			y: imageAttrs.cropInfo ? -imageAttrs.cropInfo.y * realScale : 0,
+			x: -x,
+			y: -y,
 			width: imageAttrs.uncroppedImage.width,
 			height: imageAttrs.uncroppedImage.height,
-			scaleX: 1,
-			scaleY: 1,
+			scaleX: flipX ? -1 : 1,
+			scaleY: flipY ? -1 : 1,
+			offsetX: flipX ? imageAttrs.uncroppedImage.width : 0,
+			offsetY: flipY ? imageAttrs.uncroppedImage.height : 0,
 			image: this.internalImage.image(),
 			crop: void 0,
 			visible,
 			listening: false,
 			draggable: false
 		});
-		return { realScale };
+		return {
+			realScale,
+			offsetX: x,
+			offsetY: y
+		};
 	}
 	show(onClose, options) {
 		this.onClose = onClose;
@@ -14515,9 +16579,9 @@ var WeaveImageCrop = class WeaveImageCrop {
 		this.image.listening(false);
 		const imageAttrs = this.image.getAttrs();
 		this.internalImage.hide();
-		const { realScale } = this.setupCropImage(imageAttrs, true);
-		this.imageOffsetX = imageAttrs.cropInfo ? imageAttrs.cropInfo.x * realScale : 0;
-		this.imageOffsetY = imageAttrs.cropInfo ? imageAttrs.cropInfo.y * realScale : 0;
+		const { realScale, offsetX, offsetY } = this.setupCropImage(imageAttrs, true);
+		this.imageOffsetX = offsetX;
+		this.imageOffsetY = offsetY;
 		const cropModeConfiguration = this.node.getConfiguration().cropMode;
 		this.cropRect = new Konva.Rect({
 			x: 0,
@@ -14565,7 +16629,10 @@ var WeaveImageCrop = class WeaveImageCrop {
 				const center = this.cropImage.getAbsolutePosition();
 				const width = this.cropImage.width() * stage.scaleX();
 				const height = this.cropImage.height() * stage.scaleY();
-				const offset = this.cropImage.offset();
+				const offset = {
+					x: this.cropImage.scaleX() < 0 ? 0 : this.cropImage.offsetX(),
+					y: this.cropImage.scaleY() < 0 ? 0 : this.cropImage.offsetY()
+				};
 				const corners = [
 					{
 						x: -offset.x,
@@ -14909,11 +16976,15 @@ var WeaveImageCrop = class WeaveImageCrop {
 		if (!intersectionRect) return;
 		const imageAttrs = this.image.getAttrs();
 		const actualScale = imageAttrs.uncroppedImage.width / imageAttrs.imageInfo.width;
+		let sourceX = clipRectGroup.x + this.imageOffsetX;
+		let sourceY = clipRectGroup.y + this.imageOffsetY;
+		if (imageAttrs.flipX === true) sourceX = WeaveImageCrop.mirrorOffset(sourceX, clipRectGroup.width, imageAttrs.uncroppedImage.width);
+		if (imageAttrs.flipY === true) sourceY = WeaveImageCrop.mirrorOffset(sourceY, clipRectGroup.height, imageAttrs.uncroppedImage.height);
 		const realClipRect = {
 			scaleX: actualScale,
 			scaleY: actualScale,
-			x: WeaveImageCrop.roundTo6Decimals(clipRectGroup.x + this.imageOffsetX),
-			y: WeaveImageCrop.roundTo6Decimals(clipRectGroup.y + this.imageOffsetY),
+			x: WeaveImageCrop.roundTo6Decimals(sourceX),
+			y: WeaveImageCrop.roundTo6Decimals(sourceY),
 			width: WeaveImageCrop.roundTo6Decimals(clipRectGroup.width),
 			height: WeaveImageCrop.roundTo6Decimals(clipRectGroup.height)
 		};
@@ -14955,16 +17026,18 @@ var WeaveImageCrop = class WeaveImageCrop {
 		if (!intersectionRect || !intersectionRectAbs) return;
 		const imageAttrs = this.image.getAttrs();
 		const actualScale = imageAttrs.uncroppedImage.width / imageAttrs.imageInfo.width;
-		const realScale = actualScale / (imageAttrs.cropInfo ? imageAttrs.cropInfo.scaleX : actualScale);
-		const imageOffsetX = imageAttrs.cropInfo ? imageAttrs.cropInfo.x * realScale : 0;
-		const imageOffsetY = imageAttrs.cropInfo ? imageAttrs.cropInfo.y * realScale : 0;
+		const { x: imageOffsetX, y: imageOffsetY } = this.getVisualCropOffset(imageAttrs);
 		const diffX = intersectionRect.x - imageRect.x;
 		const diffY = intersectionRect.y - imageRect.y;
+		let sourceX = diffX + imageOffsetX;
+		let sourceY = diffY + imageOffsetY;
+		if (imageAttrs.flipX === true) sourceX = WeaveImageCrop.mirrorOffset(sourceX, intersectionRect.width, imageAttrs.uncroppedImage.width);
+		if (imageAttrs.flipY === true) sourceY = WeaveImageCrop.mirrorOffset(sourceY, intersectionRect.height, imageAttrs.uncroppedImage.height);
 		const realClipRect = {
 			scaleX: actualScale,
 			scaleY: actualScale,
-			x: WeaveImageCrop.roundTo6Decimals(diffX + imageOffsetX),
-			y: WeaveImageCrop.roundTo6Decimals(diffY + imageOffsetY),
+			x: WeaveImageCrop.roundTo6Decimals(sourceX),
+			y: WeaveImageCrop.roundTo6Decimals(sourceY),
 			width: WeaveImageCrop.roundTo6Decimals(intersectionRect.width),
 			height: WeaveImageCrop.roundTo6Decimals(intersectionRect.height)
 		};
@@ -15270,6 +17343,27 @@ var WeaveImageNode = class extends WeaveNode {
 		if (!internalImage || !cropGroup) return;
 		new WeaveImageCrop(this.instance, this, imageNode, internalImage, cropGroup).unCrop();
 	};
+	flipImage = (imageNode, options) => {
+		if (imageNode.getAttrs().cropping) return;
+		const prop = options.axis === "horizontal" ? "flipX" : "flipY";
+		this.instance.stateTransactional(() => {
+			imageNode.setAttrs({ [prop]: !(imageNode.getAttrs()[prop] ?? false) });
+			this.applyFlip(imageNode);
+			this.cacheNode(imageNode);
+			this.instance.updateNode(this.serialize(imageNode));
+		});
+	};
+	applyFlip(image) {
+		const attrs = image.getAttrs();
+		const internalImage = image.findOne(`#${attrs.id}-image`);
+		if (!internalImage) return;
+		const flipX = attrs.flipX === true;
+		const flipY = attrs.flipY === true;
+		internalImage.scaleX(flipX ? -1 : 1);
+		internalImage.scaleY(flipY ? -1 : 1);
+		internalImage.offsetX(flipX ? internalImage.width() : 0);
+		internalImage.offsetY(flipY ? internalImage.height() : 0);
+	}
 	loadAsyncElement(nodeId) {
 		this.instance.loadAsyncElement(nodeId, WEAVE_IMAGE_NODE_TYPE);
 	}
@@ -15317,6 +17411,12 @@ var WeaveImageNode = class extends WeaveNode {
 				new WeaveImageCrop(this.instance, this, image, internalImage, cropGroup).unCrop();
 			};
 		}
+		image.flipHorizontal = () => {
+			this.flipImage(image, { axis: "horizontal" });
+		};
+		image.flipVertical = () => {
+			this.flipImage(image, { axis: "vertical" });
+		};
 		const defaultTransformerProperties = this.defaultGetTransformerProperties(this.config.transform);
 		image.getTransformerProperties = function() {
 			return defaultTransformerProperties;
@@ -15932,6 +18032,10 @@ var WeaveImageNode = class extends WeaveNode {
 		if (!this.imageState[imageAttrs.id ?? ""]?.loaded) return;
 	}
 	updateImageCrop(image) {
+		this.updateImageCropGeometry(image);
+		this.applyFlip(image);
+	}
+	updateImageCropGeometry(image) {
 		const imageAttrs = image.getAttrs();
 		const internalImage = image?.findOne(`#${imageAttrs.id}-image`);
 		if (!this.imageState[imageAttrs.id ?? ""]?.loaded) return;
@@ -16009,8 +18113,12 @@ var WeaveImageNode = class extends WeaveNode {
 			});
 		}
 		if (internalImage) {
-			internalImage.width(Math.max(5, internalImage.width() * internalImage.scaleX()));
-			internalImage.height(Math.max(5, internalImage.height() * internalImage.scaleY()));
+			internalImage.offset({
+				x: 0,
+				y: 0
+			});
+			internalImage.width(Math.max(5, internalImage.width() * Math.abs(internalImage.scaleX())));
+			internalImage.height(Math.max(5, internalImage.height() * Math.abs(internalImage.scaleY())));
 			internalImage.scale({
 				x: 1,
 				y: 1
@@ -16065,7 +18173,7 @@ var WeaveImageNode = class extends WeaveNode {
 			clearTimeout(this.imageTryoutIds[nodeId]);
 			delete this.imageTryoutIds[nodeId];
 		}
-		nodeInstance.destroy();
+		super.onDestroy(nodeInstance);
 	}
 	loadImageTryout(imageId) {
 		this.imageTryoutIds[imageId] = setTimeout(() => {
@@ -16152,7 +18260,9 @@ var WeaveImageNode = class extends WeaveNode {
 				width: props.uncroppedImage.width,
 				height: props.uncroppedImage.height
 			},
-			cropping: props.cropping
+			cropping: props.cropping,
+			...props.flipX !== void 0 && { flipX: props.flipX },
+			...props.flipY !== void 0 && { flipY: props.flipY }
 		} });
 	}
 	static updateNodeState(prevNodeState, nextProps) {
@@ -16175,7 +18285,9 @@ var WeaveImageNode = class extends WeaveNode {
 				width: nextProps.uncroppedImage?.width,
 				height: nextProps.uncroppedImage?.height
 			} },
-			cropping: nextProps.cropping
+			cropping: nextProps.cropping,
+			...nextProps.flipX !== void 0 && { flipX: nextProps.flipX },
+			...nextProps.flipY !== void 0 && { flipY: nextProps.flipY }
 		} });
 	}
 	static getSchema() {
@@ -16199,7 +18311,9 @@ var WeaveImageNode = class extends WeaveNode {
 					width: z.number().describe("The width of the image before cropping, used for cropping calculations"),
 					height: z.number().describe("The height of the image before cropping, used for cropping calculations")
 				}),
-				cropping: z.boolean().default(false).describe("Whether the image is currently being cropped")
+				cropping: z.boolean().default(false).describe("Whether the image is currently being cropped"),
+				flipX: z.boolean().optional().describe("Whether the image is flipped horizontally"),
+				flipY: z.boolean().optional().describe("Whether the image is flipped vertically")
 			})
 		});
 	}
@@ -16716,14 +18830,26 @@ var WeaveRegularPolygonNode = class extends WeaveNode {
 //#region src/nodes/polygon/constants.ts
 const WEAVE_POLYGON_NODE_TYPE = "polygon";
 //#endregion
+//#region src/utils/native-backend.ts
+const MODULE_NOT_FOUND_CODES = ["ERR_MODULE_NOT_FOUND", "MODULE_NOT_FOUND"];
+const isMissingPackageError = (error, packageName) => error instanceof Error && MODULE_NOT_FOUND_CODES.includes(error.code ?? "") && error.message.includes(`'${packageName}'`);
+const loadNativeBackend = async (packageName, setupFunctionName, load) => {
+	try {
+		await load();
+	} catch (error) {
+		if (isMissingPackageError(error, packageName)) throw new Error(`${setupFunctionName}() requires the "${packageName}" package. Install it with \`npm install ${packageName}\`, using the version required by @inditextech/weave-sdk.`, { cause: error });
+		throw error;
+	}
+};
+//#endregion
 //#region src/backend.ts
 const setupSkiaBackend = async () => {
 	globalThis._weave_serverSideBackend = WEAVE_KONVA_BACKEND.SKIA;
-	await import("konva/skia-backend");
+	await loadNativeBackend("skia-canvas", "setupSkiaBackend", () => import("konva/skia-backend"));
 };
 const setupCanvasBackend = async () => {
 	globalThis._weave_serverSideBackend = WEAVE_KONVA_BACKEND.CANVAS;
-	await import("konva/canvas-backend");
+	await loadNativeBackend("canvas", "setupCanvasBackend", () => import("konva/canvas-backend"));
 };
 //#endregion
 //#region src/nodes/polygon/presets.ts
@@ -19638,7 +21764,7 @@ var WeaveCommentNode = class extends WeaveNode {
 		this.normalizeNodeSize(commentNode);
 	}
 	onDestroy(nodeInstance) {
-		nodeInstance.destroy();
+		super.onDestroy(nodeInstance);
 	}
 	expandNode(commentNode) {
 		const widthExpanded = this.config.style.expanded.width;
@@ -23292,6 +25418,70 @@ const RECTANGLE_TOOL_STATE = {
 	["ADDED"]: "added"
 };
 //#endregion
+//#region src/actions/shared/shape-geometry.ts
+/** Returns the normalized bounds described by a drag, including its modifiers. */
+function getShapeDragBounds(anchor, pointer, options = {}) {
+	const { centered = false, constrained = false, aspectRatio = 1 } = options;
+	const deltaX = Math.abs(pointer.x - anchor.x);
+	const deltaY = Math.abs(pointer.y - anchor.y);
+	let width = deltaX;
+	let height = deltaY;
+	if (constrained && aspectRatio > 0) {
+		if (width / (height || Number.EPSILON) > aspectRatio) height = width / aspectRatio;
+		else width = height * aspectRatio;
+	}
+	if (constrained && aspectRatio > 0 && width > 0 && height > 0) {
+		const minimumSizeScale = Math.max(1, 1 / width, 1 / height);
+		width *= minimumSizeScale;
+		height *= minimumSizeScale;
+	} else {
+		width = Math.max(1, width);
+		height = Math.max(1, height);
+	}
+	if (centered) {
+		width *= 2;
+		height *= 2;
+		return {
+			x: anchor.x - width / 2,
+			y: anchor.y - height / 2,
+			width,
+			height
+		};
+	}
+	const signedWidth = Math.sign(pointer.x - anchor.x || 1) * width;
+	const signedHeight = Math.sign(pointer.y - anchor.y || 1) * height;
+	return {
+		x: Math.min(anchor.x, anchor.x + signedWidth),
+		y: Math.min(anchor.y, anchor.y + signedHeight),
+		width,
+		height
+	};
+}
+//#endregion
+//#region src/actions/shared/shape-keyboard.ts
+/** Binds the common keyboard behavior for tools that create shapes by dragging. */
+function bindShapeDragKeyboardHandlers(signal, isActionActive, isDragInProgress, canUpdateModifiers, onCancel, onModifiersChange) {
+	const handleModifierKey = (event) => {
+		if (event.key !== "Shift" && event.key !== "Alt") return;
+		const actionActive = isActionActive();
+		const dragInProgress = isDragInProgress();
+		if (event.type === "keydown" && event.key === "Alt" && actionActive && dragInProgress) event.preventDefault();
+		if (!actionActive || !canUpdateModifiers()) return;
+		onModifiersChange({
+			shiftKey: event.shiftKey,
+			altKey: event.altKey
+		});
+	};
+	window.addEventListener("keydown", (event) => {
+		if (isActionActive() && (event.code === "Enter" || event.code === "Escape")) {
+			onCancel();
+			return;
+		}
+		handleModifierKey(event);
+	}, { signal });
+	window.addEventListener("keyup", handleModifierKey, { signal });
+}
+//#endregion
 //#region src/actions/rectangle-tool/rectangle-tool.ts
 var WeaveRectangleToolAction = class extends WeaveAction {
 	initialized = false;
@@ -23337,16 +25527,7 @@ var WeaveRectangleToolAction = class extends WeaveAction {
 	}
 	setupEvents() {
 		const stage = this.instance.getStage();
-		window.addEventListener("keydown", (e) => {
-			if (e.code === "Enter" && this.instance.getActiveAction() === "rectangleTool") {
-				this.cancelAction();
-				return;
-			}
-			if (e.code === "Escape" && this.instance.getActiveAction() === "rectangleTool") {
-				this.cancelAction();
-				return;
-			}
-		}, { signal: this.instance.getEventsController().signal });
+		bindShapeDragKeyboardHandlers(this.instance.getEventsController().signal, () => this.instance.getActiveAction() === RECTANGLE_TOOL_ACTION_NAME, () => this.state === RECTANGLE_TOOL_STATE.DEFINING_SIZE, () => this.state === RECTANGLE_TOOL_STATE.DEFINING_SIZE && this.moved, () => this.cancelAction(), (modifiers) => this.handleMovement(modifiers));
 		stage.on("pointermove", () => {
 			if (this.state === RECTANGLE_TOOL_STATE.IDLE) return;
 			this.setCursor();
@@ -23372,12 +25553,12 @@ var WeaveRectangleToolAction = class extends WeaveAction {
 				this.state = RECTANGLE_TOOL_STATE.ADDING;
 				return;
 			}
-			if (this.state === RECTANGLE_TOOL_STATE.DEFINING_SIZE) this.handleMovement();
+			if (this.state === RECTANGLE_TOOL_STATE.DEFINING_SIZE) this.handleMovement(e.evt);
 		});
 		stage.on("pointerup", (e) => {
 			this.pointers.delete(e.evt.pointerId);
 			if (this.isTap(e)) this.moved = false;
-			if (this.state === RECTANGLE_TOOL_STATE.DEFINING_SIZE) this.handleSettingSize();
+			if (this.state === RECTANGLE_TOOL_STATE.DEFINING_SIZE) this.handleSettingSize(e.evt);
 		});
 		this.initialized = true;
 	}
@@ -23411,7 +25592,7 @@ var WeaveRectangleToolAction = class extends WeaveAction {
 		}
 		this.setState(RECTANGLE_TOOL_STATE.DEFINING_SIZE);
 	}
-	handleSettingSize() {
+	handleSettingSize(modifiers = {}) {
 		if (this.rectId && this.tempRectNode && this.clickPoint && this.container) {
 			const { mousePoint } = this.instance.getMousePointerRelativeToContainer(this.container);
 			const rectPos = {
@@ -23421,10 +25602,14 @@ var WeaveRectangleToolAction = class extends WeaveAction {
 			let rectWidth = this.props.width;
 			let rectHeight = this.props.height;
 			if (this.moved) {
-				rectPos.x = Math.min(this.clickPoint.x, mousePoint.x);
-				rectPos.y = Math.min(this.clickPoint.y, mousePoint.y);
-				rectWidth = Math.abs(this.clickPoint.x - mousePoint.x);
-				rectHeight = Math.abs(this.clickPoint.y - mousePoint.y);
+				const bounds = getShapeDragBounds(this.clickPoint, mousePoint, {
+					centered: modifiers.altKey,
+					constrained: modifiers.shiftKey
+				});
+				rectPos.x = bounds.x;
+				rectPos.y = bounds.y;
+				rectWidth = bounds.width;
+				rectHeight = bounds.height;
 			}
 			this.tempRectNode.setAttrs({
 				...this.props,
@@ -23456,16 +25641,20 @@ var WeaveRectangleToolAction = class extends WeaveAction {
 		}
 		this.cancelAction();
 	}
-	handleMovement() {
+	handleMovement(modifiers = {}) {
 		if (this.state !== RECTANGLE_TOOL_STATE.DEFINING_SIZE) return;
 		if (this.rectId && this.tempRectNode && this.measureContainer && this.clickPoint) {
 			this.moved = true;
 			const { mousePoint } = this.instance.getMousePointerRelativeToContainer(this.measureContainer);
-			const deltaX = mousePoint.x - this.clickPoint?.x;
-			const deltaY = mousePoint.y - this.clickPoint?.y;
+			const bounds = getShapeDragBounds(this.clickPoint, mousePoint, {
+				centered: modifiers.altKey,
+				constrained: modifiers.shiftKey
+			});
 			this.tempRectNode.setAttrs({
-				width: deltaX,
-				height: deltaY
+				x: bounds.x,
+				y: bounds.y,
+				width: bounds.width,
+				height: bounds.height
 			});
 		}
 	}
@@ -23564,16 +25753,7 @@ var WeaveEllipseToolAction = class extends WeaveAction {
 	}
 	setupEvents() {
 		const stage = this.instance.getStage();
-		window.addEventListener("keydown", (e) => {
-			if (e.code === "Enter" && this.instance.getActiveAction() === "ellipseTool") {
-				this.cancelAction();
-				return;
-			}
-			if (e.code === "Escape" && this.instance.getActiveAction() === "ellipseTool") {
-				this.cancelAction();
-				return;
-			}
-		}, { signal: this.instance.getEventsController().signal });
+		bindShapeDragKeyboardHandlers(this.instance.getEventsController().signal, () => this.instance.getActiveAction() === ELLIPSE_TOOL_ACTION_NAME, () => this.state === ELLIPSE_TOOL_STATE.DEFINING_SIZE, () => this.state === ELLIPSE_TOOL_STATE.DEFINING_SIZE && this.moved, () => this.cancelAction(), (modifiers) => this.handleMovement(modifiers));
 		stage.on("pointerdown", (e) => {
 			this.setTapStart(e);
 			this.pointers.set(e.evt.pointerId, {
@@ -23600,7 +25780,7 @@ var WeaveEllipseToolAction = class extends WeaveAction {
 			}
 			if (this.state === ELLIPSE_TOOL_STATE.DEFINING_SIZE) {
 				this.moved = true;
-				this.handleMovement();
+				this.handleMovement(e.evt);
 			}
 		});
 		stage.on("pointerup", (e) => {
@@ -23608,7 +25788,7 @@ var WeaveEllipseToolAction = class extends WeaveAction {
 			if (this.isTap(e)) this.moved = false;
 			if (this.state === ELLIPSE_TOOL_STATE.DEFINING_SIZE) {
 				this.creating = false;
-				this.handleSettingSize();
+				this.handleSettingSize(e.evt);
 			}
 		});
 		this.initialized = true;
@@ -23632,8 +25812,8 @@ var WeaveEllipseToolAction = class extends WeaveAction {
 		if (nodeHandler) {
 			const node = nodeHandler.create(this.ellipseId, {
 				...this.props,
-				x: this.clickPoint?.x ?? 0 + this.props.radiusX,
-				y: this.clickPoint?.y ?? 0 + this.props.radiusY,
+				x: this.clickPoint?.x ?? 0,
+				y: this.clickPoint?.y ?? 0,
 				radiusX: 1,
 				radiusY: 1
 			});
@@ -23641,22 +25821,28 @@ var WeaveEllipseToolAction = class extends WeaveAction {
 		}
 		this.setState(ELLIPSE_TOOL_STATE.DEFINING_SIZE);
 	}
-	handleSettingSize() {
+	handleSettingSize(modifiers = {}) {
 		const ellipse = this.instance.getStage().findOne(`#${this.ellipseId}`);
 		if (this.ellipseId && this.clickPoint && this.container && ellipse) {
 			const { mousePoint } = this.instance.getMousePointerRelativeToContainer(this.container);
 			const nodeHandler = this.instance.getNodeHandler("ellipse");
-			const ellipsePos = {
+			let ellipsePos = {
 				x: this.clickPoint.x,
 				y: this.clickPoint.y
 			};
-			let ellipseRadiusX = this.props.radiusY;
+			let ellipseRadiusX = this.props.radiusX;
 			let ellipseRadiusY = this.props.radiusY;
 			if (this.moved) {
-				ellipsePos.x = Math.min(this.clickPoint.x, mousePoint.x);
-				ellipsePos.y = Math.min(this.clickPoint.y, mousePoint.y);
-				ellipseRadiusX = Math.abs(this.clickPoint.x - mousePoint.x);
-				ellipseRadiusY = Math.abs(this.clickPoint.y - mousePoint.y);
+				const bounds = getShapeDragBounds(this.clickPoint, mousePoint, {
+					centered: modifiers.altKey,
+					constrained: modifiers.shiftKey
+				});
+				ellipsePos = {
+					x: bounds.x,
+					y: bounds.y
+				};
+				ellipseRadiusX = bounds.width;
+				ellipseRadiusY = bounds.height;
 			}
 			ellipse.setAttrs({
 				...this.props,
@@ -23670,27 +25856,23 @@ var WeaveEllipseToolAction = class extends WeaveAction {
 		}
 		this.cancelAction();
 	}
-	handleMovement() {
+	handleMovement(modifiers = {}) {
 		if (this.state !== ELLIPSE_TOOL_STATE.DEFINING_SIZE) return;
 		const ellipse = this.instance.getStage().findOne(`#${this.ellipseId}`);
 		if (this.ellipseId && this.container && this.clickPoint && ellipse) {
 			const { mousePoint } = this.instance.getMousePointerRelativeToContainer(this.container);
-			const deltaX = Math.abs(mousePoint.x - this.clickPoint?.x);
-			const deltaY = Math.abs(mousePoint.y - this.clickPoint?.y);
-			const ellipsePos = {
-				x: this.clickPoint.x,
-				y: this.clickPoint.y
-			};
-			if (this.moved) {
-				ellipsePos.x = Math.min(this.clickPoint.x, mousePoint.x);
-				ellipsePos.y = Math.min(this.clickPoint.y, mousePoint.y);
-			}
+			const bounds = getShapeDragBounds(this.clickPoint, mousePoint, {
+				centered: modifiers.altKey,
+				constrained: modifiers.shiftKey
+			});
 			const nodeHandler = this.instance.getNodeHandler("ellipse");
 			if (nodeHandler) nodeHandler.onUpdate(ellipse, {
 				...this.props,
 				id: this.ellipseId,
-				radiusX: deltaX / 2,
-				radiusY: deltaY / 2
+				x: bounds.x,
+				y: bounds.y,
+				radiusX: bounds.width / 2,
+				radiusY: bounds.height / 2
 			});
 		}
 	}
@@ -26661,16 +28843,7 @@ var WeaveRegularPolygonToolAction = class extends WeaveAction {
 	}
 	setupEvents() {
 		const stage = this.instance.getStage();
-		window.addEventListener("keydown", (e) => {
-			if (e.code === "Enter" && this.instance.getActiveAction() === "regularPolygonTool") {
-				this.cancelAction();
-				return;
-			}
-			if (e.code === "Escape" && this.instance.getActiveAction() === "regularPolygonTool") {
-				this.cancelAction();
-				return;
-			}
-		}, { signal: this.instance.getEventsController().signal });
+		bindShapeDragKeyboardHandlers(this.instance.getEventsController().signal, () => this.instance.getActiveAction() === REGULAR_POLYGON_TOOL_ACTION_NAME, () => this.state === REGULAR_POLYGON_TOOL_STATE.DEFINING_SIZE, () => this.state === REGULAR_POLYGON_TOOL_STATE.DEFINING_SIZE && this.moved, () => this.cancelAction(), (modifiers) => this.handleMovement(modifiers));
 		stage.on("pointerdown", (e) => {
 			this.setTapStart(e);
 			this.pointers.set(e.evt.pointerId, {
@@ -26697,7 +28870,7 @@ var WeaveRegularPolygonToolAction = class extends WeaveAction {
 			}
 			if (this.state === REGULAR_POLYGON_TOOL_STATE.DEFINING_SIZE) {
 				this.moved = true;
-				this.handleMovement();
+				this.handleMovement(e.evt);
 			}
 		});
 		stage.on("pointerup", (e) => {
@@ -26705,7 +28878,7 @@ var WeaveRegularPolygonToolAction = class extends WeaveAction {
 			if (this.isTap(e)) this.moved = false;
 			if (this.state === REGULAR_POLYGON_TOOL_STATE.DEFINING_SIZE) {
 				this.creating = false;
-				this.handleSettingSize();
+				this.handleSettingSize(e.evt);
 			}
 		});
 		this.initialized = true;
@@ -26737,20 +28910,26 @@ var WeaveRegularPolygonToolAction = class extends WeaveAction {
 		}
 		this.setState(REGULAR_POLYGON_TOOL_STATE.DEFINING_SIZE);
 	}
-	handleSettingSize() {
+	handleSettingSize(modifiers = {}) {
 		const regularPolygon = this.instance.getStage().findOne(`#${this.regularPolygonId}`);
 		if (this.regularPolygonId && this.clickPoint && this.container && regularPolygon) {
 			const { mousePoint } = this.instance.getMousePointerRelativeToContainer(this.container);
 			const nodeHandler = this.instance.getNodeHandler("regular-polygon");
-			const starPos = {
+			let starPos = {
 				x: this.clickPoint.x,
 				y: this.clickPoint.y
 			};
 			let newRadius = this.props.radius;
 			if (this.moved) {
-				starPos.x = Math.min(this.clickPoint.x, mousePoint.x);
-				starPos.y = Math.min(this.clickPoint.y, mousePoint.y);
-				newRadius = Math.abs(this.clickPoint.x - mousePoint.x);
+				const bounds = getShapeDragBounds(this.clickPoint, mousePoint, {
+					centered: modifiers.altKey,
+					constrained: true
+				});
+				starPos = {
+					x: bounds.x,
+					y: bounds.y
+				};
+				newRadius = bounds.width;
 			}
 			regularPolygon.setAttrs({
 				...this.props,
@@ -26763,25 +28942,22 @@ var WeaveRegularPolygonToolAction = class extends WeaveAction {
 		}
 		this.cancelAction();
 	}
-	handleMovement() {
+	handleMovement(modifiers = {}) {
 		if (this.state !== REGULAR_POLYGON_TOOL_STATE.DEFINING_SIZE) return;
 		const regularPolygon = this.instance.getStage().findOne(`#${this.regularPolygonId}`);
 		if (this.regularPolygonId && this.container && this.clickPoint && regularPolygon) {
 			const { mousePoint } = this.instance.getMousePointerRelativeToContainer(this.container);
-			const deltaX = Math.abs(mousePoint.x - this.clickPoint?.x);
-			const starPos = {
-				x: this.clickPoint.x,
-				y: this.clickPoint.y
-			};
-			if (this.moved) {
-				starPos.x = Math.min(this.clickPoint.x, mousePoint.x);
-				starPos.y = Math.min(this.clickPoint.y, mousePoint.y);
-			}
+			const bounds = getShapeDragBounds(this.clickPoint, mousePoint, {
+				centered: modifiers.altKey,
+				constrained: true
+			});
 			const nodeHandler = this.instance.getNodeHandler("regular-polygon");
 			if (nodeHandler) nodeHandler.onUpdate(regularPolygon, {
 				...this.props,
 				id: this.regularPolygonId,
-				radius: deltaX / 2
+				x: bounds.x,
+				y: bounds.y,
+				radius: bounds.width / 2
 			});
 		}
 	}
@@ -26830,14 +29006,22 @@ const POLYGON_TOOL_ACTION_NAME = "polygonTool";
 const POLYGON_TOOL_STATE = {
 	["IDLE"]: "idle",
 	["ADDING"]: "adding",
+	["DEFINING_SIZE"]: "defining-size",
 	["ADDED"]: "added"
 };
 //#endregion
 //#region src/actions/polygon-tool/polygon-tool.ts
+const MIN_POLYGON_DRAG_DISTANCE = 3;
 var WeavePolygonToolAction = class extends WeaveAction {
 	initialized = false;
 	state;
 	polygonId;
+	pointers;
+	clickPoint;
+	container;
+	moved;
+	placementCommitted;
+	polygonNode;
 	cancelAction;
 	preset;
 	onPropsChange = void 0;
@@ -26851,6 +29035,12 @@ var WeavePolygonToolAction = class extends WeaveAction {
 		this.initialized = false;
 		this.state = POLYGON_TOOL_STATE.IDLE;
 		this.polygonId = null;
+		this.pointers = /* @__PURE__ */ new Map();
+		this.clickPoint = null;
+		this.container = void 0;
+		this.moved = false;
+		this.placementCommitted = false;
+		this.polygonNode = null;
 		this.props = this.initProps();
 	}
 	getName() {
@@ -26875,18 +29065,41 @@ var WeavePolygonToolAction = class extends WeaveAction {
 	}
 	setupEvents() {
 		const stage = this.instance.getStage();
-		window.addEventListener("keydown", (e) => {
-			if ((e.code === "Enter" || e.code === "Escape") && this.instance.getActiveAction() === "polygonTool") this.cancelAction();
-		}, { signal: this.instance.getEventsController().signal });
+		bindShapeDragKeyboardHandlers(this.instance.getEventsController().signal, () => this.instance.getActiveAction() === POLYGON_TOOL_ACTION_NAME, () => this.state === POLYGON_TOOL_STATE.DEFINING_SIZE, () => this.state === POLYGON_TOOL_STATE.DEFINING_SIZE && this.moved, () => this.cancelAction(), (modifiers) => this.handleMovement(modifiers));
 		stage.on("pointermove", () => {
 			if (this.state === POLYGON_TOOL_STATE.IDLE) return;
 			this.setCursor();
 		});
 		stage.on("pointerdown", (e) => {
 			this.setTapStart(e);
+			this.pointers.set(e.evt.pointerId, {
+				x: e.evt.clientX,
+				y: e.evt.clientY
+			});
 			if (this.state !== POLYGON_TOOL_STATE.ADDING) return;
 			this.handleAdding();
 		});
+		stage.on("pointermove", (e) => {
+			if (this.state === POLYGON_TOOL_STATE.IDLE) return;
+			this.setCursor();
+			if (!this.isPressed(e) || !this.pointers.has(e.evt.pointerId)) return;
+			if (this.state === POLYGON_TOOL_STATE.DEFINING_SIZE) {
+				const pointerStart = this.pointers.get(e.evt.pointerId);
+				if (!pointerStart || Math.hypot(e.evt.clientX - pointerStart.x, e.evt.clientY - pointerStart.y) < MIN_POLYGON_DRAG_DISTANCE) return;
+				this.moved = true;
+				this.handleMovement(e.evt);
+			}
+		});
+		stage.on("pointerup", (e) => {
+			this.pointers.delete(e.evt.pointerId);
+			if (this.isTap(e)) this.moved = false;
+			if (this.state === POLYGON_TOOL_STATE.DEFINING_SIZE) this.handleSettingSize(e.evt);
+		});
+		stage.on("pointercancel", (e) => {
+			if (!this.pointers.has(e.evt.pointerId)) return;
+			this.pointers.delete(e.evt.pointerId);
+			if (this.state === POLYGON_TOOL_STATE.DEFINING_SIZE) this.cancelAction();
+		});
 		this.initialized = true;
 	}
 	setState(state) {
@@ -26900,7 +29113,10 @@ var WeavePolygonToolAction = class extends WeaveAction {
 	}
 	handleAdding() {
 		const { mousePoint, container } = this.instance.getMousePointer();
+		this.clickPoint = mousePoint;
+		this.container = container;
 		this.polygonId = v4();
+		this.polygonNode = null;
 		const presetDef = WEAVE_POLYGON_PRESETS[this.preset];
 		const scaleFactor = this.props.scaleFactor ?? 1;
 		const { points, innerRect, width, height } = instantiatePreset(presetDef, presetDef.defaultWidth * scaleFactor, presetDef.defaultHeight * scaleFactor);
@@ -26916,15 +29132,49 @@ var WeavePolygonToolAction = class extends WeaveAction {
 				points,
 				innerRect
 			});
+			this.polygonNode = node;
 			this.instance.addNode(node, container?.getAttrs().id);
 		}
-		this.instance.emitEvent("onAddedPolygon");
+		this.setState(POLYGON_TOOL_STATE.DEFINING_SIZE);
+	}
+	handleMovement(modifiers = {}) {
+		if (this.state !== POLYGON_TOOL_STATE.DEFINING_SIZE || !this.polygonId || !this.clickPoint || !this.container) return;
+		const polygon = this.instance.getStage().findOne(`#${this.polygonId}`);
+		const nodeHandler = this.instance.getNodeHandler(WEAVE_POLYGON_NODE_TYPE);
+		const presetDef = WEAVE_POLYGON_PRESETS[this.preset];
+		if (!polygon || !nodeHandler) return;
+		const { mousePoint } = this.instance.getMousePointerRelativeToContainer(this.container);
+		const defaultGeometry = instantiatePreset(presetDef, presetDef.defaultWidth, presetDef.defaultHeight);
+		const bounds = getShapeDragBounds(this.clickPoint, mousePoint, {
+			centered: modifiers.altKey,
+			constrained: modifiers.shiftKey,
+			aspectRatio: defaultGeometry.width / defaultGeometry.height
+		});
+		const geometry = instantiatePreset(presetDef, bounds.width * presetDef.defaultWidth / defaultGeometry.width, bounds.height * presetDef.defaultHeight / defaultGeometry.height);
+		nodeHandler.onUpdate(polygon, {
+			...this.props,
+			id: this.polygonId,
+			x: bounds.x,
+			y: bounds.y,
+			...geometry
+		});
+	}
+	handleSettingSize(modifiers = {}) {
+		if (this.moved) this.handleMovement(modifiers);
+		const polygon = this.polygonId && this.instance.getStage().findOne(`#${this.polygonId}`);
+		const nodeHandler = this.instance.getNodeHandler(WEAVE_POLYGON_NODE_TYPE);
+		if (polygon && nodeHandler) {
+			this.instance.updateNode(nodeHandler.serialize(polygon));
+			this.placementCommitted = true;
+			this.instance.emitEvent("onAddedPolygon");
+		}
 		this.cancelAction();
 	}
 	trigger(cancelAction, params) {
 		if (!this.instance) throw new Error("Instance not defined");
 		if (!this.initialized) this.setupEvents();
 		this.preset = params?.presetId ?? "pentagon";
+		this.placementCommitted = false;
 		const stage = this.instance.getStage();
 		stage.container().tabIndex = 1;
 		stage.container().focus();
@@ -26937,13 +29187,21 @@ var WeavePolygonToolAction = class extends WeaveAction {
 	cleanup() {
 		const stage = this.instance.getStage();
 		stage.container().style.cursor = "default";
+		const isCancelledPlacement = this.state === POLYGON_TOOL_STATE.DEFINING_SIZE && this.polygonId !== null && !this.placementCommitted;
+		if (isCancelledPlacement && this.polygonNode) this.instance.removeNode(this.polygonNode);
 		const selectionPlugin = this.instance.getPlugin("nodesSelection");
 		if (selectionPlugin) {
-			const node = stage.findOne(`#${this.polygonId}`);
+			const node = isCancelledPlacement ? void 0 : stage.findOne(`#${this.polygonId}`);
 			if (node) selectionPlugin.setSelectedNodes([node]);
 			this.instance.triggerAction(SELECTION_TOOL_ACTION_NAME);
 		}
 		this.polygonId = null;
+		this.pointers.clear();
+		this.clickPoint = null;
+		this.container = void 0;
+		this.moved = false;
+		this.placementCommitted = false;
+		this.polygonNode = null;
 		this.setState(POLYGON_TOOL_STATE.IDLE);
 	}
 	setCursor() {
@@ -33313,6 +35571,6 @@ var WeaveNodesSnappingPlugin = class extends WeavePlugin {
 	}
 };
 //#endregion
-export { ALIGN_NODES_ALIGN_TO, ALIGN_NODES_TOOL_ACTION_NAME, ALIGN_NODES_TOOL_STATE, BRUSH_TOOL_ACTION_NAME, BRUSH_TOOL_DEFAULT_CONFIG, BRUSH_TOOL_STATE, CONNECTOR_TOOL_ACTION_NAME, CONNECTOR_TOOL_DEFAULT_CONFIG, CONNECTOR_TOOL_STATE, COPY_PASTE_NODES_PLUGIN_STATE, DEFAULT_GUIDE_TOOL_ACTION_CONFIG, DEFAULT_SNAPPING_MANAGER_CONFIG, ELLIPSE_TOOL_ACTION_NAME, ELLIPSE_TOOL_STATE, ERASER_TOOL_ACTION_NAME, ERASER_TOOL_STATE, FRAME_TOOL_ACTION_NAME, FRAME_TOOL_STATE, GUIDE_DISTANCE_NAME, GUIDE_DISTANCE_ORIGIN, GUIDE_KIND, GUIDE_NAME, GUIDE_ORIENTATION, GUIDE_STATE, GUIDE_TOOL_ACTION_NAME, GUIDE_TOOL_STATE, LINE_TOOL_ACTION_NAME, LINE_TOOL_DEFAULT_CONFIG, LINE_TOOL_STATE, MEASURE_TOOL_ACTION_NAME, MEASURE_TOOL_STATE, MOVE_ORIENTATION, MOVE_TOOL_ACTION_NAME, MOVE_TOOL_STATE, PEN_TOOL_ACTION_NAME, PEN_TOOL_STATE, POLYGON_TOOL_ACTION_NAME, POLYGON_TOOL_STATE, PREVIEW_HANDOVER_MAX_FRAMES, PREVIEW_ID_SUFFIX, RECTANGLE_TOOL_ACTION_NAME, RECTANGLE_TOOL_STATE, REGULAR_POLYGON_TOOL_ACTION_NAME, REGULAR_POLYGON_TOOL_STATE, SELECTION_TOOL_ACTION_NAME, SELECTION_TOOL_STATE, STAGE_MINIMAP_DEFAULT_CONFIG, STAR_TOOL_ACTION_NAME, STAR_TOOL_STATE, TEXT_LAYOUT, TEXT_TOOL_ACTION_NAME, TEXT_TOOL_STATE, VIDEO_TOOL_ACTION_NAME, VIDEO_TOOL_STATE, WEAVE_ARROW_NODE_TYPE, WEAVE_ARROW_TOOL_ACTION_NAME, WEAVE_ARROW_TOOL_STATE, WEAVE_COMMENTS_RENDERER_KEY, WEAVE_COMMENTS_TOOL_LAYER_ID, WEAVE_COMMENT_CREATE_ACTION, WEAVE_COMMENT_NODE_ACTION, WEAVE_COMMENT_NODE_DEFAULTS, WEAVE_COMMENT_NODE_TYPE, WEAVE_COMMENT_STATUS, WEAVE_COMMENT_TOOL_ACTION_NAME, WEAVE_COMMENT_TOOL_DEFAULT_CONFIG, WEAVE_COMMENT_TOOL_STATE, WEAVE_COMMENT_VIEW_ACTION, WEAVE_CONNECTOR_NODE_ANCHOR_ORIGIN, WEAVE_CONNECTOR_NODE_DECORATOR_TYPE, WEAVE_CONNECTOR_NODE_DEFAULT_CONFIG, WEAVE_CONNECTOR_NODE_LINE_ORIGIN, WEAVE_CONNECTOR_NODE_LINE_TYPE, WEAVE_CONNECTOR_NODE_TYPE, WEAVE_COPY_PASTE_CONFIG_DEFAULT, WEAVE_COPY_PASTE_NODES_KEY, WEAVE_COPY_PASTE_PASTE_CATCHER_ID, WEAVE_COPY_PASTE_PASTE_MODES, WEAVE_DEFAULT_USER_INFO_FUNCTION, WEAVE_ELLIPSE_NODE_TYPE, WEAVE_FRAME_DEFAULT_BACKGROUND_COLOR, WEAVE_FRAME_NODE_DEFAULT_CONFIG, WEAVE_FRAME_NODE_DEFAULT_PROPS, WEAVE_FRAME_NODE_TYPE, WEAVE_GRID_DEFAULT_CONFIG, WEAVE_GRID_DOT_TYPES, WEAVE_GRID_LAYER_ID, WEAVE_GRID_TYPES, WEAVE_GROUP_NODE_TYPE, WEAVE_IMAGES_TOOL_ACTION_NAME, WEAVE_IMAGES_TOOL_DEFAULT_CONFIG, WEAVE_IMAGES_TOOL_STATE, WEAVE_IMAGES_TOOL_UPLOAD_TYPE, WEAVE_IMAGE_CROP_ANCHOR_POSITION, WEAVE_IMAGE_CROP_END_TYPE, WEAVE_IMAGE_DEFAULT_CONFIG, WEAVE_IMAGE_NODE_TYPE, WEAVE_IMAGE_TOOL_ACTION_NAME, WEAVE_IMAGE_TOOL_CONFIG_DEFAULT, WEAVE_IMAGE_TOOL_STATE, WEAVE_IMAGE_TOOL_UPLOAD_TYPE, WEAVE_LAYER_NODE_TYPE, WEAVE_LINE_NODE_DEFAULT_CONFIG, WEAVE_LINE_NODE_TYPE, WEAVE_MEASURE_NODE_DEFAULT_CONFIG, WEAVE_MEASURE_NODE_TYPE, WEAVE_MEASURE_TOOL_DEFAULT_CONFIG, WEAVE_NODES_MULTI_SELECTION_FEEDBACK_PLUGIN_DEFAULT_CONFIG, WEAVE_NODES_MULTI_SELECTION_FEEDBACK_PLUGIN_KEY, WEAVE_NODES_MULTI_SELECTION_FEEDBACK_PLUGIN_LAYER_ID, WEAVE_NODES_SELECTION_DEFAULT_CONFIG, WEAVE_NODES_SELECTION_KEY, WEAVE_NODES_SELECTION_LAYER_ID, WEAVE_NODES_SNAPPING_PLUGIN_KEY, WEAVE_POLYGON_NODE_TYPE, WEAVE_POLYGON_PRESETS, WEAVE_RECTANGLE_NODE_TYPE, WEAVE_REGULAR_POLYGON_NODE_TYPE, WEAVE_SHAPE_LABEL_DEFAULTS, WEAVE_STAGE_DEFAULT_MODE, WEAVE_STAGE_DROP_AREA_KEY, WEAVE_STAGE_GRID_PLUGIN_KEY, WEAVE_STAGE_IMAGE_CROPPING_MODE, WEAVE_STAGE_KEYBOARD_MOVE_DEFAULT_CONFIG, WEAVE_STAGE_KEYBOARD_MOVE_KEY, WEAVE_STAGE_KEYBOARD_MOVE_ORIENTATION, WEAVE_STAGE_MINIMAP_KEY, WEAVE_STAGE_NODE_TYPE, WEAVE_STAGE_PANNING_DEFAULT_CONFIG, WEAVE_STAGE_PANNING_KEY, WEAVE_STAGE_PANNING_THROTTLE_MS, WEAVE_STAGE_SHAPE_LABEL_EDITION_MODE, WEAVE_STAGE_TEXT_EDITION_MODE, WEAVE_STAGE_ZOOM_DEFAULT_CONFIG, WEAVE_STAGE_ZOOM_KEY, WEAVE_STAGE_ZOOM_TYPE, WEAVE_STAR_NODE_TYPE, WEAVE_STROKE_NODE_DEFAULT_CONFIG, WEAVE_STROKE_NODE_TYPE, WEAVE_STROKE_SINGLE_NODE_DEFAULT_CONFIG, WEAVE_STROKE_SINGLE_NODE_TIP_SIDE, WEAVE_STROKE_SINGLE_NODE_TIP_TYPE, WEAVE_STROKE_SINGLE_NODE_TYPE, WEAVE_STROKE_TOOL_ACTION_NAME, WEAVE_STROKE_TOOL_ACTION_NAME_ALIASES, WEAVE_STROKE_TOOL_DEFAULT_CONFIG, WEAVE_STROKE_TOOL_STATE, WEAVE_TEXT_LINK_ALLOWED_PROTOCOLS, WEAVE_TEXT_NODE_DEFAULT_CONFIG, WEAVE_TEXT_NODE_TYPE, WEAVE_USERS_POINTERS_CONFIG_DEFAULT_PROPS, WEAVE_USERS_POINTERS_KEY, WEAVE_USERS_PRESENCE_CONFIG_DEFAULT_PROPS, WEAVE_USERS_PRESENCE_PLUGIN_KEY, WEAVE_USERS_SELECTION_KEY, WEAVE_USER_POINTER_KEY, WEAVE_USER_PRESENCE_KEY, WEAVE_USER_SELECTION_KEY, WEAVE_VIDEO_DEFAULT_CONFIG, WEAVE_VIDEO_NODE_TYPE, Weave, WeaveAction, WeaveAlignNodesToolAction, WeaveArrowNode, WeaveArrowToolAction, WeaveBrushToolAction, WeaveCommentNode, WeaveCommentToolAction, WeaveCommentsRendererPlugin, WeaveConnectedUsersPlugin, WeaveConnectorNode, WeaveConnectorToolAction, WeaveContextMenuPlugin, WeaveCopyPasteNodesPlugin, WeaveEllipseNode, WeaveEllipseToolAction, WeaveEraserToolAction, WeaveExportNodesToolAction, WeaveExportStageToolAction, WeaveFitToScreenToolAction, WeaveFitToSelectionToolAction, WeaveFrameNode, WeaveFrameToolAction, WeaveGroupNode, WeaveGuideToolAction, WeaveImageNode, WeaveImageToolAction, WeaveImagesToolAction, WeaveLayerNode, WeaveLineNode, WeaveLineToolAction, WeaveMeasureNode, WeaveMeasureToolAction, WeaveMoveToolAction, WeaveNode, WeaveNodesMultiSelectionFeedbackPlugin, WeaveNodesSelectionPlugin, WeaveNodesSnappingPlugin, WeavePenToolAction, WeavePlugin, WeavePolygonNode, WeavePolygonToolAction, WeaveRectangleNode, WeaveRectangleToolAction, WeaveRegularPolygonNode, WeaveRegularPolygonToolAction, WeaveRenderer, WeaveSelectionToolAction, WeaveStageDropAreaPlugin, WeaveStageGridPlugin, WeaveStageKeyboardMovePlugin, WeaveStageMinimapPlugin, WeaveStageNode, WeaveStagePanningPlugin, WeaveStageResizePlugin, WeaveStageZoomPlugin, WeaveStarNode, WeaveStarToolAction, WeaveStateManipulation, WeaveStore, WeaveStrokeNode, WeaveStrokeSingleNode, WeaveStrokeToolAction, WeaveTextNode, WeaveTextToolAction, WeaveUsersPointersPlugin, WeaveUsersPresencePlugin, WeaveUsersSelectionPlugin, WeaveVideoNode, WeaveVideoToolAction, WeaveZoomInToolAction, WeaveZoomOutToolAction, buildAncestorGroupIds, canComposite, clearContainerTargets, computeEllipseLabelMinSize, computePolygonLabelMinSize, computeRectangleLabelMinSize, containerOverCursor, containsNodeDeep, defaultInitialState, downscaleImageFile, downscaleImageFromURL, getBoundingBox, getDownscaleRatio, getExportBoundingBox, getImageSizeFromFile, getJSONFromYjsBinary, getSelectedNodesMetadata, getShapeLabelSchemaFields, getStageClickPoint, getTargetAndSkipNodes, getTargetedNode, getTopmostShadowHost, getVisibleNodes, getVisibleNodesInViewport, hasFrames, hasImages, instantiatePreset, intersectArrays, isArray, isIOS, isInShadowDOM, isNodeInSelection, isNumber, isObject, isServer, labelId, loadImageSource, mapJsonToYjsArray, mapJsonToYjsElements, mapJsonToYjsMap, memoize, mergeExceptArrays, moveNodeToContainer, moveNodeToContainerNT, resetScale, setupCanvasBackend, setupSkiaBackend, sleep, spreadLabelProps, weavejsToYjsBinary };
+export { ALIGN_NODES_ALIGN_TO, ALIGN_NODES_TOOL_ACTION_NAME, ALIGN_NODES_TOOL_STATE, BRUSH_TOOL_ACTION_NAME, BRUSH_TOOL_DEFAULT_CONFIG, BRUSH_TOOL_STATE, CONNECTOR_TOOL_ACTION_NAME, CONNECTOR_TOOL_DEFAULT_CONFIG, CONNECTOR_TOOL_STATE, COPY_PASTE_NODES_PLUGIN_STATE, DEFAULT_GUIDE_TOOL_ACTION_CONFIG, DEFAULT_SNAPPING_MANAGER_CONFIG, ELLIPSE_TOOL_ACTION_NAME, ELLIPSE_TOOL_STATE, ERASER_TOOL_ACTION_NAME, ERASER_TOOL_STATE, FRAME_TOOL_ACTION_NAME, FRAME_TOOL_STATE, GUIDE_DISTANCE_NAME, GUIDE_DISTANCE_ORIGIN, GUIDE_KIND, GUIDE_NAME, GUIDE_ORIENTATION, GUIDE_STATE, GUIDE_TOOL_ACTION_NAME, GUIDE_TOOL_STATE, LINE_TOOL_ACTION_NAME, LINE_TOOL_DEFAULT_CONFIG, LINE_TOOL_STATE, MEASURE_TOOL_ACTION_NAME, MEASURE_TOOL_STATE, MOVE_ORIENTATION, MOVE_TOOL_ACTION_NAME, MOVE_TOOL_STATE, PEN_TOOL_ACTION_NAME, PEN_TOOL_STATE, POLYGON_TOOL_ACTION_NAME, POLYGON_TOOL_STATE, PREVIEW_HANDOVER_MAX_FRAMES, PREVIEW_ID_SUFFIX, RECTANGLE_TOOL_ACTION_NAME, RECTANGLE_TOOL_STATE, REGULAR_POLYGON_TOOL_ACTION_NAME, REGULAR_POLYGON_TOOL_STATE, SELECTION_TOOL_ACTION_NAME, SELECTION_TOOL_STATE, STAGE_MINIMAP_DEFAULT_CONFIG, STAR_TOOL_ACTION_NAME, STAR_TOOL_STATE, TEXT_LAYOUT, TEXT_TOOL_ACTION_NAME, TEXT_TOOL_STATE, TextLayoutEngine, VIDEO_TOOL_ACTION_NAME, VIDEO_TOOL_STATE, WEAVE_ARROW_NODE_TYPE, WEAVE_ARROW_TOOL_ACTION_NAME, WEAVE_ARROW_TOOL_STATE, WEAVE_COMMENTS_RENDERER_KEY, WEAVE_COMMENTS_TOOL_LAYER_ID, WEAVE_COMMENT_CREATE_ACTION, WEAVE_COMMENT_NODE_ACTION, WEAVE_COMMENT_NODE_DEFAULTS, WEAVE_COMMENT_NODE_TYPE, WEAVE_COMMENT_STATUS, WEAVE_COMMENT_TOOL_ACTION_NAME, WEAVE_COMMENT_TOOL_DEFAULT_CONFIG, WEAVE_COMMENT_TOOL_STATE, WEAVE_COMMENT_VIEW_ACTION, WEAVE_CONNECTOR_NODE_ANCHOR_ORIGIN, WEAVE_CONNECTOR_NODE_DECORATOR_TYPE, WEAVE_CONNECTOR_NODE_DEFAULT_CONFIG, WEAVE_CONNECTOR_NODE_LINE_ORIGIN, WEAVE_CONNECTOR_NODE_LINE_TYPE, WEAVE_CONNECTOR_NODE_TYPE, WEAVE_COPY_PASTE_CONFIG_DEFAULT, WEAVE_COPY_PASTE_NODES_KEY, WEAVE_COPY_PASTE_PASTE_CATCHER_ID, WEAVE_COPY_PASTE_PASTE_MODES, WEAVE_DEFAULT_USER_INFO_FUNCTION, WEAVE_ELLIPSE_NODE_TYPE, WEAVE_FRAME_DEFAULT_BACKGROUND_COLOR, WEAVE_FRAME_NODE_DEFAULT_CONFIG, WEAVE_FRAME_NODE_DEFAULT_PROPS, WEAVE_FRAME_NODE_TYPE, WEAVE_GRID_DEFAULT_CONFIG, WEAVE_GRID_DOT_TYPES, WEAVE_GRID_LAYER_ID, WEAVE_GRID_TYPES, WEAVE_GROUP_NODE_TYPE, WEAVE_IMAGES_TOOL_ACTION_NAME, WEAVE_IMAGES_TOOL_DEFAULT_CONFIG, WEAVE_IMAGES_TOOL_STATE, WEAVE_IMAGES_TOOL_UPLOAD_TYPE, WEAVE_IMAGE_CROP_ANCHOR_POSITION, WEAVE_IMAGE_CROP_END_TYPE, WEAVE_IMAGE_DEFAULT_CONFIG, WEAVE_IMAGE_NODE_TYPE, WEAVE_IMAGE_TOOL_ACTION_NAME, WEAVE_IMAGE_TOOL_CONFIG_DEFAULT, WEAVE_IMAGE_TOOL_STATE, WEAVE_IMAGE_TOOL_UPLOAD_TYPE, WEAVE_LAYER_NODE_TYPE, WEAVE_LINE_NODE_DEFAULT_CONFIG, WEAVE_LINE_NODE_TYPE, WEAVE_MEASURE_NODE_DEFAULT_CONFIG, WEAVE_MEASURE_NODE_TYPE, WEAVE_MEASURE_TOOL_DEFAULT_CONFIG, WEAVE_NODES_MULTI_SELECTION_FEEDBACK_PLUGIN_DEFAULT_CONFIG, WEAVE_NODES_MULTI_SELECTION_FEEDBACK_PLUGIN_KEY, WEAVE_NODES_MULTI_SELECTION_FEEDBACK_PLUGIN_LAYER_ID, WEAVE_NODES_SELECTION_DEFAULT_CONFIG, WEAVE_NODES_SELECTION_KEY, WEAVE_NODES_SELECTION_LAYER_ID, WEAVE_NODES_SNAPPING_PLUGIN_KEY, WEAVE_POLYGON_NODE_TYPE, WEAVE_POLYGON_PRESETS, WEAVE_RECTANGLE_NODE_TYPE, WEAVE_REGULAR_POLYGON_NODE_TYPE, WEAVE_SHAPE_LABEL_DEFAULTS, WEAVE_STAGE_DEFAULT_MODE, WEAVE_STAGE_DROP_AREA_KEY, WEAVE_STAGE_GRID_PLUGIN_KEY, WEAVE_STAGE_IMAGE_CROPPING_MODE, WEAVE_STAGE_KEYBOARD_MOVE_DEFAULT_CONFIG, WEAVE_STAGE_KEYBOARD_MOVE_KEY, WEAVE_STAGE_KEYBOARD_MOVE_ORIENTATION, WEAVE_STAGE_MINIMAP_KEY, WEAVE_STAGE_NODE_TYPE, WEAVE_STAGE_PANNING_DEFAULT_CONFIG, WEAVE_STAGE_PANNING_KEY, WEAVE_STAGE_PANNING_THROTTLE_MS, WEAVE_STAGE_SHAPE_LABEL_EDITION_MODE, WEAVE_STAGE_TEXT_EDITION_MODE, WEAVE_STAGE_ZOOM_DEFAULT_CONFIG, WEAVE_STAGE_ZOOM_KEY, WEAVE_STAGE_ZOOM_TYPE, WEAVE_STAR_NODE_TYPE, WEAVE_STROKE_NODE_DEFAULT_CONFIG, WEAVE_STROKE_NODE_TYPE, WEAVE_STROKE_SINGLE_NODE_DEFAULT_CONFIG, WEAVE_STROKE_SINGLE_NODE_TIP_SIDE, WEAVE_STROKE_SINGLE_NODE_TIP_TYPE, WEAVE_STROKE_SINGLE_NODE_TYPE, WEAVE_STROKE_TOOL_ACTION_NAME, WEAVE_STROKE_TOOL_ACTION_NAME_ALIASES, WEAVE_STROKE_TOOL_DEFAULT_CONFIG, WEAVE_STROKE_TOOL_STATE, WEAVE_TEXT_LINK_ALLOWED_PROTOCOLS, WEAVE_TEXT_NODE_DEFAULT_CONFIG, WEAVE_TEXT_NODE_TYPE, WEAVE_USERS_POINTERS_CONFIG_DEFAULT_PROPS, WEAVE_USERS_POINTERS_KEY, WEAVE_USERS_PRESENCE_CONFIG_DEFAULT_PROPS, WEAVE_USERS_PRESENCE_PLUGIN_KEY, WEAVE_USERS_SELECTION_KEY, WEAVE_USER_POINTER_KEY, WEAVE_USER_PRESENCE_KEY, WEAVE_USER_SELECTION_KEY, WEAVE_VIDEO_DEFAULT_CONFIG, WEAVE_VIDEO_NODE_TYPE, Weave, WeaveAction, WeaveAlignNodesToolAction, WeaveArrowNode, WeaveArrowToolAction, WeaveBrushToolAction, WeaveCommentNode, WeaveCommentToolAction, WeaveCommentsRendererPlugin, WeaveConnectedUsersPlugin, WeaveConnectorNode, WeaveConnectorToolAction, WeaveContextMenuPlugin, WeaveCopyPasteNodesPlugin, WeaveEllipseNode, WeaveEllipseToolAction, WeaveEraserToolAction, WeaveExportNodesToolAction, WeaveExportStageToolAction, WeaveFitToScreenToolAction, WeaveFitToSelectionToolAction, WeaveFrameNode, WeaveFrameToolAction, WeaveGroupNode, WeaveGuideToolAction, WeaveImageNode, WeaveImageToolAction, WeaveImagesToolAction, WeaveLayerNode, WeaveLineNode, WeaveLineToolAction, WeaveMeasureNode, WeaveMeasureToolAction, WeaveMoveToolAction, WeaveNode, WeaveNodesMultiSelectionFeedbackPlugin, WeaveNodesSelectionPlugin, WeaveNodesSnappingPlugin, WeavePenToolAction, WeavePlugin, WeavePolygonNode, WeavePolygonToolAction, WeaveRectangleNode, WeaveRectangleToolAction, WeaveRegularPolygonNode, WeaveRegularPolygonToolAction, WeaveRenderer, WeaveSelectionToolAction, WeaveStageDropAreaPlugin, WeaveStageGridPlugin, WeaveStageKeyboardMovePlugin, WeaveStageMinimapPlugin, WeaveStageNode, WeaveStagePanningPlugin, WeaveStageResizePlugin, WeaveStageZoomPlugin, WeaveStarNode, WeaveStarToolAction, WeaveStateManipulation, WeaveStore, WeaveStrokeNode, WeaveStrokeSingleNode, WeaveStrokeToolAction, WeaveTextNode, WeaveTextToolAction, WeaveTextV2Node, WeaveTextV2Shape, WeaveUsersPointersPlugin, WeaveUsersPresencePlugin, WeaveUsersSelectionPlugin, WeaveVideoNode, WeaveVideoToolAction, WeaveZoomInToolAction, WeaveZoomOutToolAction, buildAncestorGroupIds, canComposite, clearContainerTargets, computeEllipseLabelMinSize, computePolygonLabelMinSize, computeRectangleLabelMinSize, containerOverCursor, containsNodeDeep, defaultInitialState, downscaleImageFile, downscaleImageFromURL, getBoundingBox, getDownscaleRatio, getExportBoundingBox, getImageSizeFromFile, getJSONFromYjsBinary, getSelectedNodesMetadata, getShapeLabelSchemaFields, getStageClickPoint, getTargetAndSkipNodes, getTargetedNode, getTopmostShadowHost, getVisibleNodes, getVisibleNodesInViewport, hasFrames, hasImages, instantiatePreset, intersectArrays, isArray, isIOS, isInShadowDOM, isNodeInSelection, isNumber, isObject, isServer, labelId, loadImageSource, mapJsonToYjsArray, mapJsonToYjsElements, mapJsonToYjsMap, memoize, mergeExceptArrays, moveNodeToContainer, moveNodeToContainerNT, resetScale, setupCanvasBackend, setupSkiaBackend, sleep, spreadLabelProps, weavejsToYjsBinary };
 
 //# sourceMappingURL=types.js.map