@inditextech/weave-sdk 5.6.0 → 5.7.0-SNAPSHOT.596.1

package/dist/sdk.js

@@ -9502,7 +9502,7 @@ var WeaveRegisterManager = class {
 };
 //#endregion
 //#region package.json
-var version = "5.6.0";
+var version = "5.7.0-SNAPSHOT.596.1";
 //#endregion
 //#region src/managers/setup.ts
 var WeaveSetupManager = class {
@@ -14396,6 +14396,2062 @@ var WeaveTextNode = class extends WeaveNode {
 	}
 };
 //#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.at(-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) => {
+		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;
+function flattenBlock(block) {
+	const graphemes = [];
+	const runOf = [];
+	for (let ri = 0; ri < block.runs.length; ri++) for (const g of splitGraphemes(block.runs[ri].t)) {
+		graphemes.push(g);
+		runOf.push(ri);
+	}
+	return {
+		graphemes,
+		runOf
+	};
+}
+function trimTrailingSpace(graphemes, start, end) {
+	let e = end;
+	while (e > start && WS.test(graphemes[e - 1])) e--;
+	return e;
+}
+function skipSpace(graphemes, from) {
+	let i = from;
+	while (i < graphemes.length && WS.test(graphemes[i])) i++;
+	return i;
+}
+const isNum = (v) => v !== void 0 && !Number.isNaN(v);
+/** Konva's word wrap: break after the last space/dash that fits (0 = no break). */
+function wordWrapIndex(graphemes, start, matchLen, matchWidth, maxWidth) {
+	const nextChar = graphemes[start + matchLen];
+	if ((nextChar === " " || nextChar === "-") && matchWidth <= maxWidth) return matchLen;
+	const seg = graphemes.slice(start, start + matchLen);
+	return Math.max(seg.lastIndexOf(" "), seg.lastIndexOf("-")) + 1;
+}
+function applyAlign(lines, align, width, padding) {
+	if (align === "left") return;
+	for (const line of lines) {
+		const free = width - line.width - padding * 2;
+		line.offsetX = align === "center" ? free / 2 : free;
+	}
+}
+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 = isNum(bounds.width);
+		const fixedHeight = isNum(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 offset = 0;
+		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);
+			const emitted = this.emitLines(entry, block, p, offset, lines, {
+				font,
+				style,
+				lineHeightPx,
+				maxHeightPx: fixedHeight ? maxHeightPx : void 0
+			});
+			textWidth = Math.max(textWidth, emitted.maxWidth);
+			if (emitted.stopped) break;
+			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;
+		applyAlign(lines, style.align, width, padding);
+		return {
+			lines,
+			textWidth,
+			textHeight: style.fontSize,
+			lineHeightPx,
+			width,
+			height
+		};
+	}
+	/** Append a paragraph's lines to `lines`; stops once a fixed height is full. */
+	emitLines(entry, block, paragraph, offset, lines, opts) {
+		const { font, style, lineHeightPx, maxHeightPx } = opts;
+		let maxWidth = 0;
+		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 startChar = entry.graphemes.slice(0, pl.startG).join("").length;
+			lines.push({
+				paragraph,
+				start: offset + startChar,
+				end: offset + startChar + text.length,
+				text,
+				width: segments.reduce((a, s) => a + s.width, 0),
+				measuredWidth: pl.measuredWidth,
+				offsetX: 0,
+				y: lines.length * lineHeightPx,
+				segments,
+				lastInParagraph: pl.lastInParagraph
+			});
+			maxWidth = Math.max(maxWidth, pl.measuredWidth);
+			if (maxHeightPx !== void 0 && (lines.length + 1) * lineHeightPx > maxHeightPx) return {
+				stopped: true,
+				maxWidth
+			};
+		}
+		return {
+			stopped: false,
+			maxWidth
+		};
+	}
+	rangeWidth(entry, 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;
+	}
+	/**
+	* Longest prefix of graphemes[start..n) that fits `maxWidth`, found with an
+	* exponential probe (bounds the work to about one line) plus a binary
+	* search, like Konva. Always consumes at least one grapheme.
+	*/
+	longestFit(start, n, maxWidth, width) {
+		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);
+		}
+		return {
+			matchLen,
+			matchWidth
+		};
+	}
+	layoutParagraph(block, sig, font, style, fixedWidth, maxWidth) {
+		const { graphemes, runOf } = flattenBlock(block);
+		const entry = {
+			sig,
+			graphemes,
+			runOf,
+			lines: []
+		};
+		const n = graphemes.length;
+		const spacing = style.letterSpacing;
+		const width = (a, b) => this.rangeWidth(entry, 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 { matchLen, matchWidth } = this.longestFit(start, n, maxWidth, width);
+			if (start + matchLen >= n) {
+				entry.lines.push({
+					startG: start,
+					endG: n,
+					measuredWidth: matchWidth,
+					lastInParagraph: true
+				});
+				return entry;
+			}
+			if (wrapAtWord) {
+				const wrapped = wordWrapIndex(graphemes, start, matchLen, matchWidth, maxWidth);
+				if (wrapped > 0) {
+					matchLen = wrapped;
+					matchWidth = width(start, start + matchLen);
+				}
+			}
+			const end = start + matchLen;
+			entry.lines.push({
+				startG: start,
+				endG: trimTrailingSpace(graphemes, start, end),
+				measuredWidth: matchWidth,
+				lastInParagraph: false
+			});
+			start = skipSpace(graphemes, end);
+		}
+		const last = entry.lines.at(-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;
+		});
+	}
+	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))
+		};
+	}
+	_sceneFunc = (ctx, shape) => {
+		const self = shape;
+		const layout = self.ensureLayout();
+		if (layout.lines.length === 0) return;
+		const padding = self.padding();
+		const lineHeightPx = layout.lineHeightPx;
+		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");
+		const alignY = self.verticalOffset(layout);
+		ctx.translate(padding, alignY + padding);
+		const range = self.visibleRange();
+		const top = alignY + padding;
+		for (let n = 0; n < layout.lines.length; n++) {
+			const lineTop = top + n * lineHeightPx;
+			if (range && (lineTop + lineHeightPx < range.y1 - lineHeightPx || lineTop > range.y2 + lineHeightPx)) continue;
+			self.paintLine(ctx, layout.lines[n], translateY + n * lineHeightPx);
+		}
+	};
+	/** Vertical offset of the text block inside the box (verticalAlign). */
+	verticalOffset(layout) {
+		const used = layout.lines.length * layout.lineHeightPx + this.padding() * 2;
+		const va = this.verticalAlign();
+		if (va === "middle") return (this.getHeight() - used) / 2;
+		if (va === "bottom") return this.getHeight() - used;
+		return 0;
+	}
+	paintLine(ctx, line, y) {
+		const decoration = this.textDecoration();
+		const fontSize = this.fontSize();
+		ctx.save();
+		if (decoration.includes("underline")) this.strokeDecoration(ctx, line, y + Math.round(fontSize / 4));
+		for (const seg of line.segments) this.paintSegment(ctx, seg.t, line.offsetX + seg.x, y);
+		if (decoration.includes("line-through")) this.strokeDecoration(ctx, line, y - Math.round(fontSize / 4));
+		ctx.restore();
+	}
+	strokeDecoration(ctx, line, y) {
+		ctx.save();
+		ctx.beginPath();
+		ctx.moveTo(line.offsetX, y);
+		ctx.lineTo(line.offsetX + Math.round(line.width), y);
+		ctx.lineWidth = this.fontSize() / 15;
+		ctx.strokeStyle = this.fill();
+		ctx.stroke();
+		ctx.restore();
+	}
+	paintSegment(ctx, text, x, y) {
+		const spacing = this.letterSpacing();
+		if (spacing === 0) {
+			this.fillText(ctx, text, x, y);
+			return;
+		}
+		let cx = x;
+		for (const ch of Array.from(text)) {
+			this.fillText(ctx, ch, cx, y);
+			cx += this.measureSize(ch).width + spacing;
+		}
+	}
+	fillText(ctx, text, x, y) {
+		const self = this;
+		self._partialText = text;
+		self._partialTextX = x;
+		self._partialTextY = y;
+		ctx.fillStrokeShape(this);
+	}
+	_hitFunc = (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?.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) return layout.lines.at(-1)?.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
+		};
+		if (this.host.selectAllOnStart) this.model.selectAll();
+		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();
+		}
+	};
+	/** Keys the session handles itself; everything else stays native. */
+	handleSessionKey(e) {
+		const mod = e.ctrlKey || e.metaKey;
+		const key = e.key.toLowerCase();
+		const isUndo = mod && key === "z" && !e.shiftKey;
+		const isRedo = mod && (key === "y" || key === "z" && e.shiftKey);
+		if (e.key === "Escape") this.host.onRequestExit("escape");
+		else if (isUndo) this.undo();
+		else if (isRedo) this.redo();
+		else if (e.key === "Tab") return true;
+		else return false;
+		return true;
+	}
+	handleNavigationKey(e) {
+		if (e.ctrlKey || e.metaKey) return false;
+		if ((e.key === "ArrowUp" || e.key === "ArrowDown") && !e.altKey) {
+			this.moveVertically(e.key === "ArrowUp" ? -1 : 1, e.shiftKey);
+			return true;
+		}
+		if (e.key === "Home" || e.key === "End") {
+			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 true;
+		}
+		return false;
+	}
+	onKeyDown = (e) => {
+		e.stopPropagation();
+		if (this.handleSessionKey(e)) {
+			e.preventDefault();
+			return;
+		}
+		if (this.composing) return;
+		if (this.handleNavigationKey(e)) {
+			e.preventDefault();
+			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();
+		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.editKindFor(inputType);
+		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);
+	};
+	editKindFor(inputType) {
+		if (this.composing || inputType.includes("Composition")) return "ime";
+		if (inputType.startsWith("delete")) return "delete";
+		if (inputType === "insertFromPaste") return "paste";
+		return "type";
+	}
+	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]);
+		if (this.host.outlineColor) {
+			const scale = Math.hypot(abs.m[0], abs.m[1]) || 1;
+			const lw = (this.host.outlineWidth ?? 1) / scale;
+			const { width, height } = this.target.getSize();
+			ctx.setAttr("strokeStyle", this.host.outlineColor);
+			ctx.setAttr("lineWidth", lw);
+			ctx.beginPath();
+			const pad = (this.host.outlinePadding ?? 0) / scale;
+			ctx.rect(-pad, -pad, width + pad * 2, height + pad * 2);
+			ctx.stroke();
+		}
+		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,
+	edition: { outline: {
+		enabled: true,
+		color: "#0074ff",
+		width: 1,
+		padding: 0
+	} },
+	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"];
+const CORNER_ANCHOR_SET = new Set(CORNER_ANCHORS);
+const SIDE_ANCHOR_SET = new Set(SIDE_ANCHORS);
+/**
+* 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
+				};
+			},
+			selectAllOnStart: !create,
+			caretColor: this.config.cursor.color,
+			selectionColor: WEAVE_TEXT_V2_SELECTION_COLOR,
+			...this.config.edition.outline.enabled && {
+				outlineColor: this.config.edition.outline.color,
+				outlineWidth: this.config.edition.outline.width,
+				outlinePadding: this.config.edition.outline.padding
+			},
+			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_ANCHOR_SET.has(actualAnchor ?? "");
+		const isCorner = () => CORNER_ANCHOR_SET.has(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 };
+		for (const key of Object.keys(cleanedAttrs)) if (typeof cleanedAttrs[key] === "function") delete cleanedAttrs[key];
+		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) {
+		const next = WeaveTextNode.updateNodeState(prevNodeState, nextProps);
+		if (nextProps.blocks) next.props.blocks = nextProps.blocks;
+		else delete next.props.blocks;
+		return next;
+	}
+	static getSchema() {
+		return WeaveTextNode.getSchema();
+	}
+};
+//#endregion
 //#region src/nodes/image/constants.ts
 const WEAVE_IMAGE_NODE_TYPE = "image";
 const WEAVE_STAGE_IMAGE_CROPPING_MODE = "image-cropping";
@@ -33564,4 +35620,4 @@ function getJSONFromYjsBinary(actualState) {
 	return JSON.parse(actualStateString);
 }
 //#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, 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, sleep, spreadLabelProps, weavejsToYjsBinary };