@kekonic/diagrams-studio 1.0.0-rc.4

package/dist/browser/favicon.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48" fill="none">
+  <rect width="48" height="48" fill="#432990"/>
+  <path d="M14 36V12H34" stroke="#f8f7ff" stroke-width="5" stroke-linejoin="miter"/>
+  <path d="M14 24H29" stroke="#f8f7ff" stroke-width="5" stroke-linejoin="miter"/>
+  <rect x="29.5" y="7.5" width="9" height="9" fill="#f8f7ff"/>
+  <rect x="24.5" y="19.5" width="9" height="9" fill="#f8f7ff"/>
+  <rect x="9.5" y="31.5" width="9" height="9" fill="#f8f7ff"/>
+</svg>

package/dist/browser/index.html

@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="en" data-theme="dark">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="color-scheme" content="dark light" />
+    <meta name="kdiagram-icon-api" content="./__kdiagram/icons" />
+    <meta name="kdiagram-public-studio" content="https://diagrams.kekonic.com/studio/" />
+    <link rel="icon" href="./favicon.svg" type="image/svg+xml" />
+    <title>Kekonic Diagrams Studio</title>
+    <script type="module" crossorigin src="./assets/index-D4UABSTV.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-D15KDLkg.css">
+  </head>
+  <body>
+    <div id="app"></div>
+  </body>
+</html>

package/dist/index.d.mts

@@ -0,0 +1,173 @@
+import { Diagnostic, GraphModel, InteractiveRenderOptions, RenderResult, RenderStats, SourceRange, ThemeMode } from "@kekonic/diagrams";
+
+//#region src/protocol.d.ts
+declare const STUDIO_PROTOCOL_VERSION: 1;
+type StudioDocument = {
+  id: string;
+  path: string;
+  label: string;
+  revision: number;
+  source: string;
+};
+type StudioCapabilities = {
+  write: boolean;
+  export: true;
+};
+type StudioSelection = {
+  documentId: string;
+  range?: SourceRange;
+  graphElement?: {
+    type: "node" | "edge";
+    id: string;
+  };
+};
+type StudioViewport = {
+  zoom: number;
+  x: number;
+  y: number;
+};
+type StudioPresentation = {
+  theme: "dark" | "light";
+  options: InteractiveRenderOptions;
+};
+type StudioRender = {
+  documentId: string;
+  revision: number;
+  ok: boolean;
+  svg?: string;
+  diagnostics: Diagnostic[];
+  graph?: GraphModel;
+  stats: RenderStats;
+};
+type StudioServerMessage = {
+  version: 1;
+  type: "ready";
+  sessionId: string;
+  documents: StudioDocument[];
+  activeDocumentId: string;
+  capabilities: StudioCapabilities;
+  presentation: StudioPresentation;
+} | ({
+  version: 1;
+  type: "document";
+  reason: "open" | "external" | "saved";
+} & StudioDocument) | ({
+  version: 1;
+  type: "render";
+} & StudioRender) | {
+  version: 1;
+  type: "selection";
+  selection: StudioSelection;
+} | {
+  version: 1;
+  type: "viewport";
+  viewport: StudioViewport;
+} | {
+  version: 1;
+  type: "presentation";
+  presentation: StudioPresentation;
+} | {
+  version: 1;
+  type: "saved";
+  documentId: string;
+  revision: number;
+} | {
+  version: 1;
+  type: "error";
+  code: string;
+  message: string;
+  requestType?: string;
+};
+type StudioClientMessage = {
+  version: 1;
+  type: "open";
+  documentId: string;
+} | {
+  version: 1;
+  type: "source";
+  documentId: string;
+  revision: number;
+  source: string;
+} | {
+  version: 1;
+  type: "save";
+  documentId: string;
+  revision: number;
+  source: string;
+} | {
+  version: 1;
+  type: "selection";
+  selection: StudioSelection;
+} | {
+  version: 1;
+  type: "viewport";
+  viewport: StudioViewport;
+} | {
+  version: 1;
+  type: "presentation";
+  presentation: StudioPresentation;
+};
+declare function parseStudioClientMessage(value: unknown): StudioClientMessage;
+declare function studioMessageJson(message: StudioServerMessage): string;
+//#endregion
+//#region src/preview.d.ts
+type StudioRenderer = (source: string, options: InteractiveRenderOptions) => Promise<RenderResult>;
+type StudioPreviewCoordinator = {
+  render(documentId: string, revision: number, source: string, options: InteractiveRenderOptions): Promise<StudioRender | undefined>;
+  invalidate(documentId: string): void;
+};
+/**
+ * Drops stale async renders so every host observes monotonically newer document results.
+ * Rendering stays injected, keeping this coordinator browser-safe and renderer-neutral.
+ */
+declare function createStudioPreviewCoordinator(renderer: StudioRenderer): StudioPreviewCoordinator;
+//#endregion
+//#region src/state.d.ts
+type StudioState = {
+  connected: boolean;
+  sessionId?: string;
+  documents: StudioDocument[];
+  activeDocumentId?: string;
+  capabilities: StudioCapabilities;
+  presentation: StudioPresentation;
+  render?: StudioRender;
+  selection?: StudioSelection;
+  viewport: StudioViewport;
+  error?: {
+    code: string;
+    message: string;
+  };
+};
+declare const INITIAL_STUDIO_STATE: StudioState;
+declare function reduceStudioMessage(state: StudioState, message: StudioServerMessage): StudioState;
+//#endregion
+//#region src/presentation.d.ts
+type StudioPresentationControls = {
+  /** Diagram palette authored through `render.theme`. */theme: "dark" | "light";
+  direction: "" | "LR" | "RL" | "TD" | "BT";
+  density: "" | "compact" | "normal" | "spacious";
+  spacingScale: number | null;
+  nodePlacement: "" | "straight" | "balanced" | "basic";
+  groupLayout: "" | "auto" | "compound" | "flat" | "swimlane";
+  modelOrder: "" | "on" | "off";
+  groupGap: "" | "40" | "90" | "170";
+  edgeGaps: "" | "tight" | "normal" | "wide";
+  edgeStyle: "" | "metro" | "rounded" | "orthogonal" | "straight" | "bezier";
+  crossings: "" | "jumps" | "smart" | "gaps" | "none";
+  roundedCorners: boolean;
+  showPorts: boolean;
+  showBounds: boolean;
+};
+declare const DEFAULT_STUDIO_PRESENTATION: StudioPresentationControls;
+declare function buildStudioRenderOptions(options: StudioPresentationControls, diagramTheme?: ThemeMode): InteractiveRenderOptions;
+//#endregion
+//#region src/source-settings.d.ts
+type StudioSourceSetting = "theme" | "direction" | "density" | "groupLayout" | "edgeStyle" | "crossings";
+type StudioSourceSettings = Pick<StudioPresentationControls, StudioSourceSetting>;
+declare function readStudioSourceSettings(source: string): StudioSourceSettings;
+/** Apply one end-user diagram setting as a minimal source edit. Empty values remove the setting. */
+declare function updateStudioSourceSetting(source: string, setting: StudioSourceSetting, value: string): string;
+declare function resetStudioSourceSettings(source: string): string;
+//#endregion
+export { DEFAULT_STUDIO_PRESENTATION, INITIAL_STUDIO_STATE, STUDIO_PROTOCOL_VERSION, type StudioCapabilities, type StudioClientMessage, type StudioDocument, type StudioPresentation, type StudioPresentationControls, type StudioPreviewCoordinator, type StudioRender, type StudioRenderer, type StudioSelection, type StudioServerMessage, type StudioSourceSetting, type StudioSourceSettings, type StudioState, type StudioViewport, buildStudioRenderOptions, createStudioPreviewCoordinator, parseStudioClientMessage, readStudioSourceSettings, reduceStudioMessage, resetStudioSourceSettings, studioMessageJson, updateStudioSourceSetting };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,457 @@
+import { parse } from "@kekonic/diagrams-core";
+//#region src/protocol.ts
+const STUDIO_PROTOCOL_VERSION = 1;
+function parseStudioClientMessage(value) {
+	if (!isRecord(value) || value.version !== 1 || typeof value.type !== "string") throw new Error("Expected a version 1 studio message");
+	switch (value.type) {
+		case "open": return {
+			version: 1,
+			type: "open",
+			documentId: requiredString(value.documentId, "documentId")
+		};
+		case "source":
+		case "save": return {
+			version: 1,
+			type: value.type,
+			documentId: requiredString(value.documentId, "documentId"),
+			revision: requiredRevision(value.revision),
+			source: requiredString(value.source, "source", true)
+		};
+		case "selection": return {
+			version: 1,
+			type: "selection",
+			selection: parseSelection(value.selection)
+		};
+		case "viewport": return {
+			version: 1,
+			type: "viewport",
+			viewport: parseViewport(value.viewport)
+		};
+		case "presentation": return {
+			version: 1,
+			type: "presentation",
+			presentation: parsePresentation(value.presentation)
+		};
+		default: throw new Error(`Unknown studio message type: ${value.type}`);
+	}
+}
+function studioMessageJson(message) {
+	return JSON.stringify(message);
+}
+function parseSelection(value) {
+	if (!isRecord(value)) throw new Error("selection must be an object");
+	const selection = { documentId: requiredString(value.documentId, "selection.documentId") };
+	if (value.range != null) selection.range = value.range;
+	if (isRecord(value.graphElement)) {
+		const type = value.graphElement.type;
+		if (type !== "node" && type !== "edge") throw new Error("Invalid graph element type");
+		selection.graphElement = {
+			type,
+			id: requiredString(value.graphElement.id, "selection.graphElement.id")
+		};
+	}
+	return selection;
+}
+function parseViewport(value) {
+	if (!isRecord(value)) throw new Error("viewport must be an object");
+	const zoom = requiredFinite(value.zoom, "viewport.zoom");
+	if (zoom < .1 || zoom > 8) throw new Error("viewport.zoom must be between 0.1 and 8");
+	return {
+		zoom,
+		x: requiredFinite(value.x, "viewport.x"),
+		y: requiredFinite(value.y, "viewport.y")
+	};
+}
+function parsePresentation(value) {
+	if (!isRecord(value) || value.theme !== "dark" && value.theme !== "light") throw new Error("presentation.theme must be dark or light");
+	if (!isRecord(value.options)) throw new Error("presentation.options must be an object");
+	return {
+		theme: value.theme,
+		options: value.options
+	};
+}
+function requiredString(value, label, allowEmpty = false) {
+	if (typeof value !== "string" || !allowEmpty && value.length === 0) throw new Error(`${label} must be a string`);
+	return value;
+}
+function requiredRevision(value) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new Error("revision must be a non-negative safe integer");
+	return value;
+}
+function requiredFinite(value, label) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${label} must be finite`);
+	return value;
+}
+function isRecord(value) {
+	return value != null && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
+//#region src/preview.ts
+/**
+* Drops stale async renders so every host observes monotonically newer document results.
+* Rendering stays injected, keeping this coordinator browser-safe and renderer-neutral.
+*/
+function createStudioPreviewCoordinator(renderer) {
+	const generations = /* @__PURE__ */ new Map();
+	return {
+		async render(documentId, revision, source, options) {
+			const generation = (generations.get(documentId) ?? 0) + 1;
+			generations.set(documentId, generation);
+			const result = await renderer(source, options);
+			if (generations.get(documentId) !== generation) return void 0;
+			return {
+				documentId,
+				revision,
+				ok: result.ok,
+				svg: result.svg,
+				diagnostics: uniqueDiagnostics(result.diagnostics),
+				graph: result.graph,
+				stats: result.stats
+			};
+		},
+		invalidate(documentId) {
+			generations.set(documentId, (generations.get(documentId) ?? 0) + 1);
+		}
+	};
+}
+function uniqueDiagnostics(diagnostics) {
+	const seen = /* @__PURE__ */ new Set();
+	return diagnostics.filter((diagnostic) => {
+		const { start, end } = diagnostic.range;
+		const key = `${diagnostic.code}:${diagnostic.severity}:${start.offset}:${end.offset}:${diagnostic.message}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+//#endregion
+//#region src/state.ts
+const INITIAL_STUDIO_STATE = {
+	connected: false,
+	documents: [],
+	capabilities: {
+		write: false,
+		export: true
+	},
+	presentation: {
+		theme: "dark",
+		options: { theme: "dark" }
+	},
+	viewport: {
+		zoom: 1,
+		x: 0,
+		y: 0
+	}
+};
+function reduceStudioMessage(state, message) {
+	switch (message.type) {
+		case "ready": return {
+			...state,
+			connected: true,
+			sessionId: message.sessionId,
+			documents: message.documents,
+			activeDocumentId: message.activeDocumentId,
+			capabilities: message.capabilities,
+			presentation: message.presentation,
+			error: void 0
+		};
+		case "document": {
+			const documents = state.documents.some((item) => item.id === message.id) ? state.documents.map((item) => item.id === message.id ? documentFromMessage(message) : item) : [...state.documents, documentFromMessage(message)];
+			return {
+				...state,
+				documents,
+				activeDocumentId: message.id,
+				error: void 0
+			};
+		}
+		case "render":
+			if (message.documentId !== state.activeDocumentId) return state;
+			if (state.render && message.revision < state.render.revision) return state;
+			return {
+				...state,
+				render: message
+			};
+		case "selection": return {
+			...state,
+			selection: message.selection
+		};
+		case "viewport": return {
+			...state,
+			viewport: message.viewport
+		};
+		case "presentation": return {
+			...state,
+			presentation: message.presentation
+		};
+		case "saved": return state;
+		case "error": return {
+			...state,
+			error: {
+				code: message.code,
+				message: message.message
+			}
+		};
+	}
+}
+function documentFromMessage(message) {
+	return {
+		id: message.id,
+		path: message.path,
+		label: message.label,
+		revision: message.revision,
+		source: message.source
+	};
+}
+//#endregion
+//#region src/presentation.ts
+const DEFAULT_STUDIO_PRESENTATION = {
+	theme: "dark",
+	direction: "",
+	density: "",
+	spacingScale: null,
+	nodePlacement: "",
+	groupLayout: "",
+	modelOrder: "",
+	groupGap: "",
+	edgeGaps: "",
+	edgeStyle: "",
+	crossings: "",
+	roundedCorners: false,
+	showPorts: false,
+	showBounds: false
+};
+const EDGE_GAP_PRESETS = {
+	tight: {
+		edgeNodeSpacing: 28,
+		edgeEdgeSpacing: 14,
+		edgeLabelSpacing: 10
+	},
+	normal: {
+		edgeNodeSpacing: 36,
+		edgeEdgeSpacing: 28,
+		edgeLabelSpacing: 16
+	},
+	wide: {
+		edgeNodeSpacing: 72,
+		edgeEdgeSpacing: 56,
+		edgeLabelSpacing: 28
+	}
+};
+function buildStudioRenderOptions(options, diagramTheme = options.theme) {
+	const layout = {};
+	if (options.spacingScale != null) layout.spacingScale = options.spacingScale;
+	if (options.density) layout.density = options.density;
+	if (options.direction) layout.direction = options.direction;
+	if (options.nodePlacement) layout.nodePlacement = options.nodePlacement;
+	if (options.groupLayout) layout.groupLayout = options.groupLayout;
+	if (options.modelOrder === "on") layout.considerModelOrder = true;
+	if (options.modelOrder === "off") layout.considerModelOrder = false;
+	if (options.groupGap) layout.groupGap = Number(options.groupGap);
+	if (options.edgeGaps) Object.assign(layout, EDGE_GAP_PRESETS[options.edgeGaps]);
+	const edges = {};
+	if (options.edgeStyle) edges.route = options.edgeStyle;
+	if (options.crossings) edges.crossings = options.crossings;
+	return {
+		theme: diagramTheme,
+		layout,
+		edges,
+		...options.roundedCorners ? { roundedCorners: true } : {},
+		debug: {
+			showPorts: options.showPorts,
+			showBounds: options.showBounds
+		}
+	};
+}
+//#endregion
+//#region src/source-settings.ts
+const EMPTY_SETTINGS = {
+	theme: "dark",
+	direction: "",
+	density: "",
+	groupLayout: "",
+	edgeStyle: "",
+	crossings: ""
+};
+function readStudioSourceSettings(source) {
+	const diagram = firstDiagram(source);
+	if (!diagram) return { ...EMPTY_SETTINGS };
+	const result = { ...EMPTY_SETTINGS };
+	for (const statement of diagram.statements) if (statement.type === "Directive" && statement.name === "direction") result.direction = oneOf(String(statement.value ?? ""), [
+		"LR",
+		"RL",
+		"TD",
+		"BT"
+	]);
+	else if (statement.type === "Directive" && statement.name === "density") result.density = oneOf(String(statement.value ?? ""), [
+		"compact",
+		"normal",
+		"spacious"
+	]);
+	else if (statement.type === "LayoutBlock") {
+		const direction = stringProperty(statement.properties, "direction");
+		const density = stringProperty(statement.properties, "density");
+		if (direction) result.direction = oneOf(direction, [
+			"LR",
+			"RL",
+			"TD",
+			"BT"
+		]);
+		if (density) result.density = oneOf(density, [
+			"compact",
+			"normal",
+			"spacious"
+		]);
+		const groupLayout = stringProperty(statement.properties, "groupLayout");
+		if (groupLayout) result.groupLayout = oneOf(groupLayout, [
+			"auto",
+			"compound",
+			"flat",
+			"swimlane"
+		]);
+	} else if (statement.type === "EdgePolicyBlock") {
+		const edgeStyle = stringProperty(statement.properties, "route");
+		const crossings = stringProperty(statement.properties, "crossings");
+		if (edgeStyle) result.edgeStyle = oneOf(edgeStyle, [
+			"metro",
+			"rounded",
+			"orthogonal",
+			"straight",
+			"bezier"
+		]);
+		if (crossings) result.crossings = oneOf(crossings, [
+			"jumps",
+			"smart",
+			"gaps",
+			"none"
+		]);
+	} else if (statement.type === "RenderBlock") result.theme = oneOf(String(statement.properties.theme ?? "dark"), ["dark", "light"]) || "dark";
+	return result;
+}
+/** Apply one end-user diagram setting as a minimal source edit. Empty values remove the setting. */
+function updateStudioSourceSetting(source, setting, value) {
+	const diagram = firstDiagram(source);
+	if (!diagram) return source;
+	if (setting === "direction" || setting === "density") {
+		const layout = diagram.statements.find((item) => item.type === "LayoutBlock");
+		if (value && layout?.properties[setting] != null) return updateBlock(source, diagram, "LayoutBlock", "layout", setting, value);
+		const withoutDirective = updateDirective(source, diagram, setting, value);
+		if (value) return withoutDirective;
+		const reparsed = firstDiagram(withoutDirective);
+		return reparsed ? updateBlock(withoutDirective, reparsed, "LayoutBlock", "layout", setting, "") : withoutDirective;
+	}
+	if (setting === "groupLayout") return updateBlock(source, diagram, "LayoutBlock", "layout", "groupLayout", value);
+	if (setting === "theme") return updateBlock(source, diagram, "RenderBlock", "render", "theme", value);
+	return updateBlock(source, diagram, "EdgePolicyBlock", "edges", setting === "edgeStyle" ? "route" : "crossings", value);
+}
+function resetStudioSourceSettings(source) {
+	return Object.keys(EMPTY_SETTINGS).reduce((current, setting) => updateStudioSourceSetting(current, setting, ""), source);
+}
+function firstDiagram(source) {
+	const first = parse(source).body[0];
+	return first?.type === "Diagram" ? first : null;
+}
+function updateDirective(source, diagram, name, value) {
+	const statement = diagram.statements.find((item) => item.type === "Directive" && item.name === name);
+	if (statement) {
+		if (!value) return removePolicyStatement(source, diagram, statement);
+		return replaceRange(source, statement.range.start.offset, statement.range.end.offset, `${name} ${value}`);
+	}
+	return value ? insertPolicyStatement(source, diagram, `${name} ${value}`, policyRank(name)) : source;
+}
+function updateBlock(source, diagram, type, keyword, property, value) {
+	const block = diagram.statements.find((item) => item.type === type);
+	if (!block) return value ? insertPolicyStatement(source, diagram, printBlock(keyword, { [property]: value }), policyRank(keyword)) : source;
+	const blockSource = source.slice(block.range.start.offset, block.range.end.offset);
+	const openingBrace = blockSource.indexOf("{");
+	const closingBrace = blockSource.lastIndexOf("}");
+	if (!blockSource.slice(openingBrace + 1, closingBrace).includes("\n")) {
+		const properties = { ...block.properties };
+		if (value) properties[property] = value;
+		else delete properties[property];
+		if (Object.keys(properties).length === 0) return removePolicyStatement(source, diagram, block);
+		return replaceRange(source, block.range.start.offset, block.range.end.offset, printBlock(keyword, properties));
+	}
+	const propertyLine = new RegExp(`^([\\t ]*${escapeRegex(property)}[\\t ]*:[\\t ]*)(.*?)([\\t ]*//.*)?$`, "m");
+	const match = propertyLine.exec(blockSource);
+	if (match) {
+		const updatedBlock = value ? blockSource.replace(propertyLine, `$1${value}$3`) : removeMatchedLine(blockSource, match.index, match[0].length);
+		if (!updatedBlock.slice(updatedBlock.indexOf("{") + 1, updatedBlock.lastIndexOf("}")).trim()) return removePolicyStatement(source, diagram, block);
+		return replaceRange(source, block.range.start.offset, block.range.end.offset, updatedBlock);
+	}
+	if (!value) return source;
+	const addition = `${indentationAt(source, block.range.start.offset)}  ${property}: ${value}\n`;
+	const updatedBlock = `${blockSource.slice(0, closingBrace)}${addition}${blockSource.slice(closingBrace)}`;
+	return replaceRange(source, block.range.start.offset, block.range.end.offset, updatedBlock);
+}
+function printBlock(keyword, properties, indent = "") {
+	return `${keyword} {\n${Object.entries(properties).map(([key, value]) => `${indent}  ${key}: ${printValue(value)}`).join("\n")}\n${indent}}`;
+}
+function insertPolicyStatement(source, diagram, statement, rank) {
+	const indent = `${indentationAt(source, diagram.range.start.offset)}  `;
+	const rendered = statement.split("\n").map((line) => `${indent}${line}`).join("\n");
+	const target = diagram.statements.find((item) => policyRank(item) > rank);
+	if (target) {
+		const insertionOffset = source.lastIndexOf("\n", target.range.start.offset - 1) + 1;
+		const separatesContent = policyRank(target) === Number.POSITIVE_INFINITY;
+		return `${source.slice(0, insertionOffset)}${rendered}\n${separatesContent ? "\n" : ""}${source.slice(insertionOffset)}`;
+	}
+	const closingBrace = source.lastIndexOf("}", diagram.range.end.offset);
+	if (closingBrace < 0) return source;
+	return `${source.slice(0, closingBrace)}${rendered}\n${source.slice(closingBrace)}`;
+}
+function policyRank(value) {
+	const name = typeof value === "string" ? value : value.type === "Directive" ? value.name : value.type === "LayoutBlock" ? "layout" : value.type === "EdgePolicyBlock" ? "edges" : value.type === "RenderBlock" ? "render" : value.type === "PresentationBlock" ? "presentation" : "content";
+	const order = [
+		"direction",
+		"density",
+		"layout",
+		"edges",
+		"render",
+		"presentation"
+	];
+	return order.indexOf(name) === -1 ? Number.POSITIVE_INFINITY : order.indexOf(name);
+}
+function removeStatementLine(source, statement) {
+	const start = source.lastIndexOf("\n", statement.range.start.offset - 1) + 1;
+	const nextNewline = source.indexOf("\n", statement.range.end.offset);
+	return replaceRange(source, start, nextNewline < 0 ? statement.range.end.offset : nextNewline + 1, "");
+}
+function removePolicyStatement(source, diagram, statement) {
+	const updated = removeStatementLine(source, statement);
+	if (diagram.statements.some((item) => item !== statement && policyRank(item) < Number.POSITIVE_INFINITY)) return updated;
+	const firstStatement = firstDiagram(updated)?.statements[0];
+	if (!firstStatement) return updated;
+	const lineStart = updated.lastIndexOf("\n", firstStatement.range.start.offset - 1) + 1;
+	const preceding = updated.slice(0, lineStart);
+	return preceding.endsWith("\n\n") ? `${preceding.slice(0, -1)}${updated.slice(lineStart)}` : updated;
+}
+function indentationAt(source, offset) {
+	const lineStart = source.lastIndexOf("\n", offset - 1) + 1;
+	return /^\s*/.exec(source.slice(lineStart, offset))?.[0] ?? "";
+}
+function replaceRange(source, start, end, replacement) {
+	return `${source.slice(0, start)}${replacement}${source.slice(end)}`;
+}
+function stringProperty(properties, name) {
+	const value = properties[name];
+	return typeof value === "string" ? value : "";
+}
+function printValue(value) {
+	return Array.isArray(value) ? `[${value.join(", ")}]` : String(value);
+}
+function removeMatchedLine(source, start, length) {
+	const lineStart = source.lastIndexOf("\n", start - 1) + 1;
+	const nextNewline = source.indexOf("\n", start + length);
+	const lineEnd = nextNewline < 0 ? start + length : nextNewline + 1;
+	return `${source.slice(0, lineStart)}${source.slice(lineEnd)}`;
+}
+function escapeRegex(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function oneOf(value, allowed) {
+	return allowed.includes(value) ? value : "";
+}
+//#endregion
+export { DEFAULT_STUDIO_PRESENTATION, INITIAL_STUDIO_STATE, STUDIO_PROTOCOL_VERSION, buildStudioRenderOptions, createStudioPreviewCoordinator, parseStudioClientMessage, readStudioSourceSettings, reduceStudioMessage, resetStudioSourceSettings, studioMessageJson, updateStudioSourceSetting };
+
+//# sourceMappingURL=index.mjs.map