@haklex/rich-ext-excalidraw 0.49.1 → 0.50.0

package/dist/useExcalidrawFont-DAmoYxvU.js

@@ -0,0 +1,795 @@
+import { createContext, memo, use, useCallback, useEffect, useMemo, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { PenLine, TriangleAlert } from "lucide-react";
+import { RoughGenerator } from "roughjs/bin/generator";
+//#region src/ExcalidrawConfigContext.tsx
+var ExcalidrawConfigContext = createContext({});
+function ExcalidrawConfigProvider({ apiUrl, fontCssHref, saveSnapshot, children }) {
+	const value = useMemo(() => ({
+		apiUrl,
+		fontCssHref,
+		saveSnapshot
+	}), [
+		apiUrl,
+		fontCssHref,
+		saveSnapshot
+	]);
+	return /* @__PURE__ */ jsx(ExcalidrawConfigContext.Provider, {
+		value,
+		children
+	});
+}
+function useExcalidrawConfig() {
+	return use(ExcalidrawConfigContext);
+}
+//#endregion
+//#region src/styles.css.ts
+var excalidrawStaticContainer = "_1c3wdzl0";
+var excalidrawEditorContainer = "_1c3wdzl1";
+var excalidrawPlaceholder = "_1c3wdzl2";
+var excalidrawStateLayer = "_1c3wdzl3";
+var excalidrawStateIcon = "_1c3wdzl4";
+var excalidrawLoading = "_1c3wdzl6";
+var excalidrawEmpty = "_1c3wdzl7";
+var excalidrawError = "_1c3wdzl8";
+var excalidrawErrorIcon = "_1c3wdzl9";
+var excalidrawFullscreenPopup = "_1c3wdzlb";
+var excalidrawDialogHeader = "_1c3wdzlc";
+var excalidrawDialogHeaderTitle = "_1c3wdzld";
+var excalidrawStatusDot = "_1c3wdzle";
+var excalidrawDialogTitle = "_1c3wdzlf";
+var excalidrawDialogMeta = "_1c3wdzlg";
+var excalidrawHeaderActions = "_1c3wdzlh";
+var excalidrawHeaderClose = "_1c3wdzli";
+var excalidrawActionBarBtn = "_1c3wdzlj";
+var excalidrawActionBarSep = "_1c3wdzlk";
+var excalidrawActionBarUrl = "_1c3wdzll";
+var excalidrawDialogCanvas = "_1c3wdzlm";
+var excalidrawConfirmActions = "_1c3wdzln";
+var excalidrawConfirmBtn = "_1c3wdzlo";
+var excalidrawConfirmBtnPrimary = "_1c3wdzlp";
+var excalidrawConfirmBtnDanger = "_1c3wdzlq";
+var excalidrawEditOverlay = "_1c3wdzlr";
+var excalidrawEditLabel = "_1c3wdzls";
+//#endregion
+//#region src/ExcalidrawFrameStates.tsx
+var ExcalidrawPlaceholderState = ({ elementCount }) => {
+	const label = elementCount ? `Whiteboard · ${elementCount} elements` : "Whiteboard";
+	return /* @__PURE__ */ jsxs("div", {
+		"aria-label": label,
+		className: excalidrawStateLayer,
+		children: [/* @__PURE__ */ jsx(PenLine, {
+			"aria-hidden": true,
+			className: excalidrawStateIcon
+		}), /* @__PURE__ */ jsx("span", { children: label })]
+	});
+};
+var ExcalidrawLoadingState = () => /* @__PURE__ */ jsx("div", {
+	"aria-busy": true,
+	className: excalidrawLoading,
+	children: /* @__PURE__ */ jsx("span", { children: "Loading whiteboard…" })
+});
+var ExcalidrawEmptyState = () => /* @__PURE__ */ jsx("div", {
+	className: excalidrawEmpty,
+	children: /* @__PURE__ */ jsx("span", { children: "Empty whiteboard" })
+});
+var ExcalidrawErrorState = ({ message, onRetry }) => /* @__PURE__ */ jsxs("div", {
+	className: excalidrawError,
+	role: "alert",
+	children: [
+		/* @__PURE__ */ jsx(TriangleAlert, {
+			"aria-hidden": true,
+			className: excalidrawErrorIcon
+		}),
+		/* @__PURE__ */ jsx("span", { children: message }),
+		onRetry && /* @__PURE__ */ jsx("button", {
+			className: "_1c3wdzla",
+			type: "button",
+			onClick: onRetry,
+			children: "Retry"
+		})
+	]
+});
+//#endregion
+//#region src/scene/fonts.ts
+var EXCALIDRAW_FONT_STACK = {
+	hand: "\"Excalifont\", \"LXGW WenKai Screen\", \"Virgil\", \"Comic Sans MS\", \"Segoe Print\", \"Bradley Hand\", cursive",
+	sans: "Helvetica, \"PingFang SC\", \"Microsoft YaHei\", \"Segoe UI Emoji\", \"Segoe UI Symbol\", system-ui, sans-serif",
+	mono: "\"Cascadia Code\", \"Cascadia\", ui-monospace, SFMono-Regular, \"SF Mono\", Menlo, Consolas, monospace"
+};
+function fontFamilyToCss(id) {
+	switch (id) {
+		case 3: return EXCALIDRAW_FONT_STACK.mono;
+		default: return EXCALIDRAW_FONT_STACK.hand;
+	}
+}
+//#endregion
+//#region src/scene/rough.ts
+var _gen = null;
+function gen() {
+	if (!_gen) _gen = new RoughGenerator();
+	return _gen;
+}
+function roughOptionsForElement(el, override) {
+	const dashes = strokeDash(el.strokeStyle, el.strokeWidth);
+	const opts = {
+		seed: el.seed || 1,
+		stroke: el.strokeColor,
+		strokeWidth: el.strokeWidth,
+		roughness: el.roughness,
+		disableMultiStroke: el.strokeWidth < 2,
+		fill: el.backgroundColor === "transparent" ? void 0 : el.backgroundColor,
+		fillStyle: el.fillStyle,
+		fillWeight: el.strokeWidth / 2,
+		hachureGap: el.strokeWidth * 4,
+		preserveVertices: false
+	};
+	if (dashes) opts.strokeLineDash = dashes;
+	return {
+		...opts,
+		...override
+	};
+}
+function strokeDash(style, w) {
+	if (style === "solid") return void 0;
+	if (style === "dashed") return [8, 8 + w];
+	if (style === "dotted") return [1.5, 6 + w];
+}
+function rectangle(el, override) {
+	return gen().rectangle(0, 0, el.width, el.height, roughOptionsForElement(el, override));
+}
+function ellipse(el, override) {
+	return gen().ellipse(el.width / 2, el.height / 2, el.width, el.height, roughOptionsForElement(el, override));
+}
+function diamond(el, override) {
+	const hw = el.width / 2;
+	const hh = el.height / 2;
+	return gen().polygon([
+		[hw, 0],
+		[el.width, hh],
+		[hw, el.height],
+		[0, hh]
+	], roughOptionsForElement(el, override));
+}
+function path(d, options) {
+	return gen().path(d, options);
+}
+function linearPath(points, options) {
+	return gen().linearPath(points, options);
+}
+function curve(points, options) {
+	return gen().curve(points, options);
+}
+function opsToPath(ops) {
+	let d = "";
+	for (const { op, data } of ops) switch (op) {
+		case "move":
+			d += `M${data[0]} ${data[1]} `;
+			break;
+		case "lineTo":
+			d += `L${data[0]} ${data[1]} `;
+			break;
+		case "bcurveTo": d += `C${data[0]} ${data[1]}, ${data[2]} ${data[3]}, ${data[4]} ${data[5]} `;
+	}
+	return d.trim();
+}
+function drawableToOpSets(drawable) {
+	return drawable.sets.map((set) => ({
+		type: set.type,
+		d: opsToPath(set.ops)
+	}));
+}
+function roundedRectPath(width, height, radius) {
+	const r = Math.max(0, Math.min(radius, width / 2, height / 2));
+	return [
+		`M ${r} 0`,
+		`L ${width - r} 0`,
+		`Q ${width} 0 ${width} ${r}`,
+		`L ${width} ${height - r}`,
+		`Q ${width} ${height} ${width - r} ${height}`,
+		`L ${r} ${height}`,
+		`Q 0 ${height} 0 ${height - r}`,
+		`L 0 ${r}`,
+		`Q 0 0 ${r} 0`,
+		"Z"
+	].join(" ");
+}
+var PROPORTIONAL_RADIUS = .25;
+var FIXED_RADIUS = 32;
+function getCornerRadius(el) {
+	if (!el.roundness) return 0;
+	if (el.roundness.type === 3) {
+		const min = Math.min(el.width, el.height);
+		return Math.min(min * PROPORTIONAL_RADIUS, FIXED_RADIUS);
+	}
+	return el.roundness.value ?? 0;
+}
+//#endregion
+//#region src/scene/Scene.tsx
+var SVG_PADDING = 32;
+function computeSceneBounds(elements) {
+	if (elements.length === 0) return {
+		minX: 0,
+		minY: 0,
+		width: 100,
+		height: 100
+	};
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (const el of elements) {
+		if (el.isDeleted) continue;
+		const x0 = el.x;
+		const y0 = el.y;
+		const x1 = el.x + el.width;
+		const y1 = el.y + el.height;
+		if (x0 < minX) minX = x0;
+		if (y0 < minY) minY = y0;
+		if (x1 > maxX) maxX = x1;
+		if (y1 > maxY) maxY = y1;
+	}
+	if (!Number.isFinite(minX)) return {
+		minX: 0,
+		minY: 0,
+		width: 100,
+		height: 100
+	};
+	return {
+		minX: minX - SVG_PADDING,
+		minY: minY - SVG_PADDING,
+		width: maxX - minX + 64,
+		height: maxY - minY + 64
+	};
+}
+var DARK_SCENE_FILTER = "invert(93%) hue-rotate(180deg)";
+var COUNTER_INVERT_FILTER_ID = "rich-excalidraw-counter-invert";
+var SceneDarkContext = createContext(false);
+var CounterInvertFilter = () => /* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsxs("filter", {
+	colorInterpolationFilters: "sRGB",
+	id: COUNTER_INVERT_FILTER_ID,
+	children: [/* @__PURE__ */ jsx("feColorMatrix", {
+		type: "hueRotate",
+		values: "180"
+	}), /* @__PURE__ */ jsx("feColorMatrix", {
+		type: "matrix",
+		values: "-1.16279 0 0 0 1.081395 0 -1.16279 0 0 1.081395 0 0 -1.16279 0 1.081395 0 0 0 1 0"
+	})]
+}) });
+var SceneContent = memo(({ dark = false, files, scene }) => {
+	const elements = scene.elements.filter((el) => !el.isDeleted);
+	return /* @__PURE__ */ jsxs(SceneDarkContext, {
+		value: dark,
+		children: [dark && /* @__PURE__ */ jsx(CounterInvertFilter, {}), elements.map((el) => /* @__PURE__ */ jsx(ElementGroup, {
+			el,
+			files
+		}, el.id))]
+	});
+});
+SceneContent.displayName = "SceneContent";
+var Scene = ({ className, files, scene, style, theme = "light" }) => {
+	const bounds = computeSceneBounds(scene.elements.filter((el) => !el.isDeleted));
+	const isDark = theme === "dark";
+	return /* @__PURE__ */ jsx("svg", {
+		className,
+		preserveAspectRatio: "xMidYMid meet",
+		role: "img",
+		viewBox: `${bounds.minX} ${bounds.minY} ${bounds.width} ${bounds.height}`,
+		xmlns: "http://www.w3.org/2000/svg",
+		style: {
+			width: "100%",
+			height: "100%",
+			display: "block",
+			...isDark ? { filter: DARK_SCENE_FILTER } : null,
+			...style
+		},
+		children: /* @__PURE__ */ jsx(SceneContent, {
+			dark: isDark,
+			files: files ?? scene.files,
+			scene
+		})
+	});
+};
+var ElementGroup = ({ el, files }) => {
+	const cx = el.x + el.width / 2;
+	const cy = el.y + el.height / 2;
+	const angleDeg = el.angle * 180 / Math.PI;
+	const transform = `translate(${el.x} ${el.y}) rotate(${angleDeg} ${el.width / 2} ${el.height / 2})`;
+	return /* @__PURE__ */ jsx("g", {
+		"data-cx": cx,
+		"data-cy": cy,
+		"data-id": el.id,
+		"data-type": el.type,
+		opacity: el.opacity != null ? el.opacity / 100 : 1,
+		transform,
+		children: /* @__PURE__ */ jsx(ElementContent, {
+			el,
+			files
+		})
+	});
+};
+var ElementContent = ({ el, files }) => {
+	switch (el.type) {
+		case "rectangle": return /* @__PURE__ */ jsx(RectangleRender, { el });
+		case "ellipse": return /* @__PURE__ */ jsx(EllipseRender, { el });
+		case "diamond": return /* @__PURE__ */ jsx(DiamondRender, { el });
+		case "line":
+		case "arrow": return /* @__PURE__ */ jsx(LinearRender, { el });
+		case "freedraw": return /* @__PURE__ */ jsx(FreedrawRender, { el });
+		case "text": return /* @__PURE__ */ jsx(TextRender, { el });
+		case "image": return /* @__PURE__ */ jsx(ImageRender, {
+			el,
+			files
+		});
+		case "frame":
+		case "magicframe": return /* @__PURE__ */ jsx(FrameRender, { el });
+		case "embeddable":
+		case "iframe": return /* @__PURE__ */ jsx(EmbedPlaceholder, { el });
+		default: return null;
+	}
+};
+var PathSet = ({ drawable, fillColor, strokeColor, strokeWidth }) => {
+	const opSets = drawableToOpSets(drawable);
+	return /* @__PURE__ */ jsx(Fragment, { children: opSets.map((set, i) => {
+		if (set.type === "path") return /* @__PURE__ */ jsx("path", {
+			d: set.d,
+			fill: "none",
+			stroke: strokeColor,
+			strokeLinecap: "round",
+			strokeLinejoin: "round",
+			strokeWidth
+		}, i);
+		if (set.type === "fillPath") return /* @__PURE__ */ jsx("path", {
+			d: set.d,
+			fill: fillColor || "none",
+			fillRule: "evenodd",
+			stroke: "none"
+		}, i);
+		return /* @__PURE__ */ jsx("path", {
+			d: set.d,
+			fill: "none",
+			stroke: fillColor || strokeColor,
+			strokeLinecap: "round",
+			strokeLinejoin: "round",
+			strokeWidth: drawable.options.fillWeight ?? strokeWidth / 2
+		}, i);
+	}) });
+};
+var RectangleRender = ({ el }) => {
+	const radius = getCornerRadius(el);
+	const opts = roughOptionsForElement(el);
+	const drawable = radius > 0 ? path(roundedRectPath(el.width, el.height, radius), opts) : rectangle(el);
+	return /* @__PURE__ */ jsx(PathSet, {
+		drawable,
+		fillColor: el.backgroundColor !== "transparent" ? el.backgroundColor : void 0,
+		strokeColor: el.strokeColor,
+		strokeWidth: el.strokeWidth
+	});
+};
+var EllipseRender = ({ el }) => {
+	const drawable = ellipse(el);
+	return /* @__PURE__ */ jsx(PathSet, {
+		drawable,
+		fillColor: el.backgroundColor !== "transparent" ? el.backgroundColor : void 0,
+		strokeColor: el.strokeColor,
+		strokeWidth: el.strokeWidth
+	});
+};
+var DiamondRender = ({ el }) => {
+	const drawable = diamond(el);
+	return /* @__PURE__ */ jsx(PathSet, {
+		drawable,
+		fillColor: el.backgroundColor !== "transparent" ? el.backgroundColor : void 0,
+		strokeColor: el.strokeColor,
+		strokeWidth: el.strokeWidth
+	});
+};
+var ARROWHEAD_LENGTH = 18;
+function arrowheadAngle(points, end) {
+	if (points.length < 2) return {
+		x: 0,
+		y: 0,
+		angle: 0
+	};
+	const idx = end === "end" ? points.length - 1 : 0;
+	const next = end === "end" ? points.length - 2 : 1;
+	const [x, y] = points[idx];
+	const [px, py] = points[next];
+	return {
+		x,
+		y,
+		angle: Math.atan2(y - py, x - px)
+	};
+}
+var Arrowhead = ({ angle, color, shape, strokeWidth, x, y }) => {
+	if (!shape) return null;
+	if (shape === "arrow" || shape === "triangle" || shape === "triangle_outline") {
+		const len = ARROWHEAD_LENGTH;
+		const a1 = angle + Math.PI - Math.PI / 7;
+		const a2 = angle + Math.PI + Math.PI / 7;
+		const x1 = x + Math.cos(a1) * len;
+		const y1 = y + Math.sin(a1) * len;
+		const x2 = x + Math.cos(a2) * len;
+		const y2 = y + Math.sin(a2) * len;
+		if (shape === "arrow") return /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("line", {
+			stroke: color,
+			strokeLinecap: "round",
+			strokeWidth,
+			x1: x,
+			x2: x1,
+			y1: y,
+			y2: y1
+		}), /* @__PURE__ */ jsx("line", {
+			stroke: color,
+			strokeLinecap: "round",
+			strokeWidth,
+			x1: x,
+			x2,
+			y1: y,
+			y2
+		})] });
+		return /* @__PURE__ */ jsx("polygon", {
+			fill: shape === "triangle" ? color : "none",
+			points: `${x},${y} ${x1},${y1} ${x2},${y2}`,
+			stroke: color,
+			strokeLinejoin: "round",
+			strokeWidth
+		});
+	}
+	if (shape === "dot" || shape === "circle" || shape === "circle_outline") return /* @__PURE__ */ jsx("circle", {
+		cx: x,
+		cy: y,
+		fill: shape === "circle_outline" ? "none" : color,
+		r: ARROWHEAD_LENGTH / 3,
+		stroke: color,
+		strokeWidth
+	});
+	if (shape === "bar") {
+		const len = ARROWHEAD_LENGTH / 1.5;
+		const perp = angle + Math.PI / 2;
+		return /* @__PURE__ */ jsx("line", {
+			stroke: color,
+			strokeLinecap: "round",
+			strokeWidth,
+			x1: x + Math.cos(perp) * len,
+			x2: x - Math.cos(perp) * len,
+			y1: y + Math.sin(perp) * len,
+			y2: y - Math.sin(perp) * len
+		});
+	}
+	return null;
+};
+var LinearRender = ({ el }) => {
+	const points = el.points && el.points.length > 0 ? el.points : [[0, 0], [el.width, el.height]];
+	const isCurved = el.roundness?.type === 2;
+	const opts = roughOptionsForElement(el, {
+		fill: void 0,
+		fillStyle: void 0
+	});
+	const drawable = isCurved && points.length > 2 ? curve(points, opts) : linearPath(points, opts);
+	const startHead = el.startArrowhead;
+	const endHead = el.type === "arrow" ? el.endArrowhead ?? "arrow" : el.endArrowhead;
+	const startInfo = startHead ? arrowheadAngle(points, "start") : null;
+	const endInfo = endHead ? arrowheadAngle(points, "end") : null;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(PathSet, {
+			drawable,
+			strokeColor: el.strokeColor,
+			strokeWidth: el.strokeWidth
+		}),
+		startHead && startInfo && /* @__PURE__ */ jsx(Arrowhead, {
+			angle: startInfo.angle + Math.PI,
+			color: el.strokeColor,
+			shape: startHead,
+			strokeWidth: el.strokeWidth,
+			x: startInfo.x,
+			y: startInfo.y
+		}),
+		endHead && endInfo && /* @__PURE__ */ jsx(Arrowhead, {
+			angle: endInfo.angle,
+			color: el.strokeColor,
+			shape: endHead,
+			strokeWidth: el.strokeWidth,
+			x: endInfo.x,
+			y: endInfo.y
+		})
+	] });
+};
+var FreedrawRender = ({ el }) => {
+	if (!el.points || el.points.length === 0) return null;
+	if (el.points.length === 1) {
+		const [x, y] = el.points[0];
+		return /* @__PURE__ */ jsx("circle", {
+			cx: x,
+			cy: y,
+			fill: el.strokeColor,
+			r: el.strokeWidth
+		});
+	}
+	const d = el.points.map(([x, y], i) => `${i === 0 ? "M" : "L"}${x} ${y}`).join(" ");
+	return /* @__PURE__ */ jsx("path", {
+		d,
+		fill: "none",
+		stroke: el.strokeColor,
+		strokeLinecap: "round",
+		strokeLinejoin: "round",
+		strokeWidth: el.strokeWidth
+	});
+};
+var DEFAULT_LINE_HEIGHT = 1.25;
+var TextRender = ({ el }) => {
+	const lineHeight = el.lineHeight ?? DEFAULT_LINE_HEIGHT;
+	const lines = el.text.split("\n");
+	const fontSize = el.fontSize;
+	const family = fontFamilyToCss(el.fontFamily);
+	const anchor = el.textAlign === "center" ? "middle" : el.textAlign === "right" ? "end" : "start";
+	const ax = el.textAlign === "center" ? el.width / 2 : el.textAlign === "right" ? el.width : 0;
+	const dy = fontSize * lineHeight;
+	const baseline = fontSize * .82;
+	return /* @__PURE__ */ jsx("text", {
+		dominantBaseline: "alphabetic",
+		fill: el.strokeColor,
+		fontFamily: family,
+		fontSize,
+		style: { whiteSpace: "pre" },
+		textAnchor: anchor,
+		x: ax,
+		y: baseline,
+		children: lines.map((line, i) => /* @__PURE__ */ jsx("tspan", {
+			dy: i === 0 ? 0 : dy,
+			x: ax,
+			children: line || " "
+		}, i))
+	});
+};
+var ImageRender = ({ el, files }) => {
+	const dark = use(SceneDarkContext);
+	const file = el.fileId && files ? files[el.fileId] : void 0;
+	if (!file?.dataURL) return /* @__PURE__ */ jsx(ImagePlaceholder, {
+		el,
+		label: "Image"
+	});
+	const scaleX = el.scale?.[0] ?? 1;
+	const scaleY = el.scale?.[1] ?? 1;
+	return /* @__PURE__ */ jsx("image", {
+		filter: dark ? `url(#${COUNTER_INVERT_FILTER_ID})` : void 0,
+		height: el.height,
+		href: file.dataURL,
+		preserveAspectRatio: "none",
+		width: el.width,
+		transform: scaleX !== 1 || scaleY !== 1 ? `translate(${scaleX < 0 ? el.width : 0} ${scaleY < 0 ? el.height : 0}) scale(${scaleX} ${scaleY})` : void 0
+	});
+};
+var ImagePlaceholder = ({ el, label }) => {
+	return /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("rect", {
+		fill: "none",
+		height: el.height,
+		stroke: el.strokeColor || "#888",
+		strokeDasharray: "4 4",
+		strokeWidth: 1,
+		width: el.width
+	}), /* @__PURE__ */ jsx("text", {
+		dominantBaseline: "middle",
+		fill: el.strokeColor || "#888",
+		fontFamily: fontFamilyToCss(1),
+		fontSize: Math.min(16, el.height / 4),
+		textAnchor: "middle",
+		x: el.width / 2,
+		y: el.height / 2,
+		children: label
+	})] });
+};
+var FrameRender = ({ el }) => {
+	const name = el.name || (el.type === "magicframe" ? "Magic frame" : "Frame");
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("rect", {
+		fill: "none",
+		height: el.height,
+		rx: 4,
+		stroke: "#bbb",
+		strokeWidth: 1.5,
+		width: el.width
+	}), /* @__PURE__ */ jsx("text", {
+		fill: "#999",
+		fontFamily: fontFamilyToCss(2),
+		fontSize: 12,
+		x: 4,
+		y: -4,
+		children: name
+	})] });
+};
+var EmbedPlaceholder = ({ el }) => /* @__PURE__ */ jsx(ImagePlaceholder, {
+	el,
+	label: "Embed"
+});
+//#endregion
+//#region src/scene/normalize.ts
+function toScene(data) {
+	if (!data) return null;
+	if (typeof data !== "object") return null;
+	if (!Array.isArray(data.elements) && data.data !== void 0) return toScene(data.data);
+	return {
+		type: "excalidraw",
+		elements: Array.isArray(data.elements) ? data.elements : [],
+		appState: data.appState ?? {},
+		files: data.files ?? {}
+	};
+}
+function countElements(scene) {
+	return scene.elements.filter((el) => !el.isDeleted).length;
+}
+//#endregion
+//#region src/types.ts
+var LOCAL_SCENE_PATH = /^(?:\.{1,2}\/)?[\w-][\w./-]*\.excalidraw$/;
+function isLocalScenePath(ref) {
+	return LOCAL_SCENE_PATH.test(ref);
+}
+function parseSnapshot(raw) {
+	if (!raw || !raw.trim()) return null;
+	try {
+		const json = JSON.parse(raw);
+		if (json && typeof json === "object") return {
+			type: "inline",
+			data: json
+		};
+	} catch {}
+	const lines = raw.split("\n");
+	const firstLine = lines[0].trim();
+	if (!firstLine.startsWith("http") && !firstLine.startsWith("blob:") && !firstLine.startsWith("ref:") && !isLocalScenePath(firstLine)) return null;
+	const remaining = lines.slice(1).join("\n").trim();
+	if (remaining) try {
+		const delta = JSON.parse(remaining);
+		if (delta && typeof delta === "object") return {
+			type: "delta",
+			baseUrl: firstLine,
+			delta
+		};
+	} catch {}
+	return {
+		type: "remote",
+		url: firstLine
+	};
+}
+function serializeSnapshot(snapshot) {
+	switch (snapshot.type) {
+		case "inline": return JSON.stringify(snapshot.data);
+		case "remote": return snapshot.url;
+		case "delta": return [snapshot.baseUrl, JSON.stringify(snapshot.delta)].join("\n");
+	}
+}
+//#endregion
+//#region src/useExcalidrawData.ts
+function resolveUrl(url, apiUrl) {
+	const refLine = url;
+	if (url.startsWith("http") || url.startsWith("blob:") || isLocalScenePath(url)) return {
+		fetchUrl: url,
+		refLine
+	};
+	if (url.startsWith("ref:") && apiUrl) return {
+		fetchUrl: `${apiUrl}/objects/${url.slice(4)}`,
+		refLine
+	};
+	return { error: url.startsWith("ref:") ? "Missing apiUrl for ref resolution" : "Unrecognized snapshot format" };
+}
+function typedToParsed(typed, apiUrl) {
+	switch (typed.type) {
+		case "inline": return {
+			type: "inline",
+			snapshot: typed.data
+		};
+		case "remote": {
+			const result = resolveUrl(typed.url, apiUrl);
+			if ("error" in result) return {
+				type: "error",
+				error: result.error
+			};
+			return {
+				type: "remote",
+				fetchUrl: result.fetchUrl,
+				refLine: result.refLine
+			};
+		}
+		case "delta": {
+			const result = resolveUrl(typed.baseUrl, apiUrl);
+			if ("error" in result) return {
+				type: "error",
+				error: result.error
+			};
+			return {
+				type: "incremental",
+				fetchUrl: result.fetchUrl,
+				refLine: result.refLine,
+				delta: typed.delta
+			};
+		}
+	}
+}
+function stringToParsed(data, apiUrl) {
+	const typed = parseSnapshot(data);
+	if (!typed) return { type: "empty" };
+	return typedToParsed(typed, apiUrl);
+}
+function useExcalidrawData(data) {
+	const { apiUrl } = useExcalidrawConfig();
+	const parsed = useMemo(() => {
+		if (data === null || data === void 0) return { type: "empty" };
+		if (typeof data === "string") return stringToParsed(data, apiUrl);
+		return typedToParsed(data, apiUrl);
+	}, [data, apiUrl]);
+	const [remoteSnapshot, setRemoteSnapshot] = useState();
+	const [baseData, setBaseData] = useState();
+	const [loading, setLoading] = useState(parsed.type === "remote" || parsed.type === "incremental");
+	const [error, setError] = useState("");
+	const [attempt, setAttempt] = useState(0);
+	const retry = useCallback(() => setAttempt((n) => n + 1), []);
+	useEffect(() => {
+		if (parsed.type !== "remote" && parsed.type !== "incremental") return;
+		const { fetchUrl } = parsed;
+		const delta = parsed.type === "incremental" ? parsed.delta : void 0;
+		let cancelled = false;
+		setLoading(true);
+		setError("");
+		fetch(fetchUrl).then((res) => {
+			if (!res.ok) throw new Error(`HTTP ${res.status}`);
+			return res.json();
+		}).then(async (json) => {
+			if (cancelled) return;
+			setBaseData(json);
+			if ((delta ? Object.keys(delta) : []).length > 0) {
+				const { patch } = await import("jsondiffpatch");
+				if (cancelled) return;
+				const patched = patch(structuredClone(json), delta);
+				setRemoteSnapshot(patched);
+			} else setRemoteSnapshot(json);
+			setLoading(false);
+		}).catch((err) => {
+			if (!cancelled) {
+				setError(err instanceof Error ? err.message : "Failed to load");
+				setLoading(false);
+			}
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [parsed, attempt]);
+	if (parsed.type === "inline") return {
+		snapshot: parsed.snapshot,
+		loading: false,
+		error: "",
+		retry
+	};
+	if (parsed.type === "remote" || parsed.type === "incremental") return {
+		snapshot: remoteSnapshot,
+		loading,
+		error,
+		retry,
+		baseRef: parsed.refLine,
+		baseData
+	};
+	if (parsed.type === "error") return {
+		snapshot: void 0,
+		loading: false,
+		error: parsed.error,
+		retry
+	};
+	return {
+		snapshot: void 0,
+		loading: false,
+		error: "",
+		retry
+	};
+}
+//#endregion
+//#region src/useExcalidrawFont.ts
+function useExcalidrawFont() {
+	const { fontCssHref } = useExcalidrawConfig();
+	useEffect(() => {
+		if (!fontCssHref || typeof document === "undefined") return;
+		if (document.head.querySelector(`link[href="${CSS.escape(fontCssHref)}"]`)) return;
+		const link = document.createElement("link");
+		link.rel = "stylesheet";
+		link.href = fontCssHref;
+		document.head.append(link);
+	}, [fontCssHref]);
+}
+//#endregion
+export { excalidrawEditorContainer as A, excalidrawDialogCanvas as C, excalidrawDialogTitle as D, excalidrawDialogMeta as E, excalidrawStaticContainer as F, excalidrawStatusDot as I, ExcalidrawConfigProvider as L, excalidrawHeaderActions as M, excalidrawHeaderClose as N, excalidrawEditLabel as O, excalidrawPlaceholder as P, useExcalidrawConfig as R, excalidrawConfirmBtnPrimary as S, excalidrawDialogHeaderTitle as T, excalidrawActionBarSep as _, serializeSnapshot as a, excalidrawConfirmBtn as b, DARK_SCENE_FILTER as c, computeSceneBounds as d, ExcalidrawEmptyState as f, excalidrawActionBarBtn as g, ExcalidrawPlaceholderState as h, parseSnapshot as i, excalidrawFullscreenPopup as j, excalidrawEditOverlay as k, Scene as l, ExcalidrawLoadingState as m, useExcalidrawData as n, countElements as o, ExcalidrawErrorState as p, isLocalScenePath as r, toScene as s, useExcalidrawFont as t, SceneContent as u, excalidrawActionBarUrl as v, excalidrawDialogHeader as w, excalidrawConfirmBtnDanger as x, excalidrawConfirmActions as y };