deckjsx 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as Text, c as isAuthorNode, i as Slide, l as isContentNode, n as Image, o as View, r as Shape, s as createElement, t as Fragment, u as isSlideNode } from "./jsx-lqMAdW2X.mjs";
+import { a as isContentNode, c as toLegacyJsxNode, d as Slide, f as Text, i as isAuthorNode, l as Image, m as isAuthorTreeNode, n as createElement, o as isSlideNode, p as View, s as isLegacyAuthorNode, t as Fragment, u as Shape } from "./jsx-Crlbye9V.mjs";
 import { createRequire } from "node:module";
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
@@ -3863,24 +3863,15 @@ function compileGroupNode(node, parentFrame, idGenerator, placement, clipRect, c
 		}, childClipRect, context)
 	};
 }
-function compileTextNode(node, parentFrame, idGenerator, placement, clipRect, context) {
-	const { props } = node;
-	const textLengthContext = getTextLengthContext(props, context);
-	const resolved = frameFromProps(props, parentFrame, placement, textLengthContext);
-	const strokes = resolveNodeStrokes(props, textLengthContext);
-	const shadow = parseShadowShorthand(props.textShadow ?? props.boxShadow);
+function textStyleFromProps(props, textLengthContext) {
 	const list = resolveListStyle(props, textLengthContext);
 	const lineHeight = resolveLineHeight(props.lineHeight, textLengthContext);
 	const underlineStyle = resolveUnderlineStyle(props.textDecorationStyle);
 	const underlineColor = normalizeColor(props.textDecorationColor);
 	const textDirection = resolveTextDirection(props.writingMode);
 	const tabStops = resolveTabStops(props.tabStops, textLengthContext);
-	const hyperlink = props.href ? {
-		url: props.href,
-		...props.tooltip ? { tooltip: props.tooltip } : {}
-	} : void 0;
 	const fontSizePt = props.fontSize === void 0 ? void 0 : parsePointValue(props.fontSize, 0, textLengthContext);
-	const style = {
+	return {
 		fontFamily: props.fontFamily,
 		fontSizePt,
 		fontWeight: props.fontWeight,
@@ -3908,6 +3899,48 @@ function compileTextNode(node, parentFrame, idGenerator, placement, clipRect, co
 		...props.superscript ? { superscript: true } : {},
 		...props.subscript ? { subscript: true } : {}
 	};
+}
+function isEmptyRunStyle(style) {
+	return Object.values(style).every((value) => value === void 0);
+}
+function flattenUnknownChildren(children) {
+	return children.flatMap((child) => Array.isArray(child) ? flattenUnknownChildren(child) : [child]);
+}
+function extractRichTextRuns(children, textTransform, textLengthContext) {
+	const runs = [];
+	for (const child of flattenUnknownChildren(children)) {
+		if (child === null || child === void 0 || child === false || child === true) continue;
+		if (typeof child === "string" || typeof child === "number") {
+			runs.push({ text: extractText([child], textTransform) });
+			continue;
+		}
+		if (typeof child === "object" && child !== null && "kind" in child) {
+			const authorNode = child;
+			if (authorNode.kind !== "text") throw new Error("Text nodes can only contain primitive text or inline text runs.");
+			const props = normalizeTextProps(authorNode.props);
+			const childLengthContext = getTextLengthContext(props, textLengthContext);
+			const style = textStyleFromProps(props, childLengthContext);
+			const text = extractRichTextRuns(authorNode.children, props.textTransform ?? textTransform, childLengthContext).map((run) => run.text).join("");
+			runs.push({
+				text,
+				...!isEmptyRunStyle(style) ? { style } : {}
+			});
+		}
+	}
+	return runs;
+}
+function compileTextNode(node, parentFrame, idGenerator, placement, clipRect, context) {
+	const { props } = node;
+	const textLengthContext = getTextLengthContext(props, context);
+	const resolved = frameFromProps(props, parentFrame, placement, textLengthContext);
+	const strokes = resolveNodeStrokes(props, textLengthContext);
+	const shadow = parseShadowShorthand(props.textShadow ?? props.boxShadow);
+	const hyperlink = props.href ? {
+		url: props.href,
+		...props.tooltip ? { tooltip: props.tooltip } : {}
+	} : void 0;
+	const style = textStyleFromProps(props, textLengthContext);
+	const runs = extractRichTextRuns(node.source.children, props.textTransform, textLengthContext);
 	const visibleFrame = intersectClipRect({
 		xEmu: resolved.xEmu,
 		yEmu: resolved.yEmu,
@@ -3930,7 +3963,10 @@ function compileTextNode(node, parentFrame, idGenerator, placement, clipRect, co
 		...props.visibility !== void 0 ? { visibility: props.visibility } : {},
 		flipH: resolved.flipH,
 		flipV: resolved.flipV,
-		content: { text: extractText(node.source.children, props.textTransform) },
+		content: {
+			text: runs.map((run) => run.text).join(""),
+			...runs.length > 1 || runs.some((run) => run.style) ? { runs } : {}
+		},
 		style,
 		fill: backgroundFill.fill,
 		...backgroundFill.backgroundLayers ? { backgroundLayers: backgroundFill.backgroundLayers } : {},
@@ -4102,13 +4138,775 @@ function renderPresentation(options, slides) {
 		version: "0.1",
 		meta: options.meta,
 		size: slideSize,
-		slides: slides.map((factory, slideIndex) => compileSlide(factory({
-			slideIndex,
-			totalSlides: slides.length
-		}), {
-			slideIndex,
-			totalSlides: slides.length
-		}, slideFrame, idGenerator, lengthContext))
+		slides: slides.map((factory, slideIndex) => {
+			return compileSlide(toLegacyJsxNode(factory({ composition: {
+				slideIndex,
+				totalSlides: slides.length,
+				deckSlideIndex: slideIndex,
+				deckTotalSlides: slides.length
+			} })), { slideIndex }, slideFrame, idGenerator, lengthContext);
+		})
+	};
+}
+//#endregion
+//#region src/diagnostics/format.ts
+function formatSpan(path) {
+	return `  at ${path}`;
+}
+function formatDiagnostic(diagnostic) {
+	const lines = [`${diagnostic.severity}[${diagnostic.code}]: ${diagnostic.title}`];
+	if (diagnostic.message) lines.push(`  ${diagnostic.message}`);
+	for (const label of diagnostic.labels) {
+		lines.push(formatSpan(label.path));
+		lines.push(`   = ${label.message}`);
+	}
+	for (const note of diagnostic.notes ?? []) lines.push(`note: ${note}`);
+	for (const help of diagnostic.help ?? []) lines.push(`help: ${help}`);
+	return lines.join("\n");
+}
+function formatDiagnostics(diagnostics) {
+	return diagnostics.items.map((item) => formatDiagnostic(item)).join("\n\n");
+}
+//#endregion
+//#region src/diagnostics/errors.ts
+var DeckDiagnosticError = class extends Error {
+	diagnostics;
+	constructor(message, diagnostics) {
+		super(message);
+		this.name = "DeckDiagnosticError";
+		this.diagnostics = diagnostics;
+	}
+};
+var SemanticGraphDiagnosticError = class extends DeckDiagnosticError {
+	constructor(diagnostics) {
+		super(formatDiagnostics(diagnostics), diagnostics);
+		this.name = "SemanticGraphDiagnosticError";
+	}
+};
+var CompositionDiagnosticError = class extends DeckDiagnosticError {
+	constructor(diagnostics) {
+		super(formatDiagnostics(diagnostics), diagnostics);
+		this.name = "CompositionDiagnosticError";
+	}
+};
+//#endregion
+//#region src/diagnostics/index.ts
+function createDiagnostics(items = []) {
+	return {
+		items,
+		hasErrors: items.some((item) => item.severity === "error"),
+		hasWarnings: items.some((item) => item.severity === "warning")
+	};
+}
+function diagnostic(input) {
+	return input;
+}
+//#endregion
+//#region src/composition/types.ts
+const COMPOSITION_SOURCE = Symbol("deckjsx.compositionSource");
+function sourceIdentity(value) {
+	return value;
+}
+//#endregion
+//#region src/composition/resolve.ts
+const MAX_COMPOSITION_DEPTH = 64;
+const ROOT_SOURCE = { kind: "root" };
+function addDiagnostic$1(context, item) {
+	context.diagnostics.push(item);
+}
+function compositionDiagnostic(input) {
+	return diagnostic({
+		severity: "error",
+		code: input.code,
+		title: input.title,
+		message: input.message,
+		labels: [{
+			path: input.path,
+			message: input.message
+		}],
+		...input.help ? { help: input.help } : {}
+	});
+}
+function sourcePathFor(parentPath, sourceKey) {
+	return parentPath === "root" ? sourceKey : `${parentPath}/${sourceKey}`;
+}
+function sourceOriginFor(parent, sourceKey) {
+	return {
+		kind: "mounted",
+		sourceKey,
+		sourceIdentity: sourceIdentity(`${parent.kind === "root" ? "" : `${parent.sourceIdentity}/`}${sourceKey}`)
+	};
+}
+function sourceMaterialFor(source) {
+	return source.kind === "root" ? ["source", "root"] : ["source", source.sourceIdentity];
+}
+function validateSourceKey(sourceKey) {
+	if (sourceKey.trim().length === 0) return "Source Key must not be empty.";
+	if (sourceKey === "." || sourceKey === "..") return "Source Key must not be dot or dot-dot.";
+	if (sourceKey.includes("/")) return "Source Key must not contain /.";
+}
+function describeInvalidRoot(value) {
+	if (isLegacyAuthorNode(value)) return "Slide factory returned a legacy author node.";
+	if (isAuthorTreeNode(value)) return "Slide factory returned an author tree node that is not a <Slide /> root.";
+	if (value === null) return "Slide factory returned null.";
+	return `Slide factory returned ${typeof value}.`;
+}
+function isSlideRoot(value) {
+	return value.kind === "element" && value.source.kind === "component" && value.source.component === "Slide";
+}
+function isPromiseLike(value) {
+	return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function mapSlotOrigins(value, origin, targets, seen) {
+	if (isAuthorTreeNode(value)) {
+		targets.set(value, origin);
+		return;
+	}
+	if (!Array.isArray(value)) return;
+	if (seen.has(value)) return;
+	seen.add(value);
+	value.forEach((item) => mapSlotOrigins(item, origin, targets, seen));
+}
+function collectSourceSlots(context, parent) {
+	const origins = /* @__PURE__ */ new WeakMap();
+	if (!context.present || typeof context.value !== "object" || context.value === null) return origins;
+	Object.entries(context.value).forEach(([field, value]) => {
+		mapSlotOrigins(value, {
+			source: parent.slotOwnerSource,
+			field,
+			identityMaterial: [...parent.slotOwnerMaterial, `slot:${field}`]
+		}, origins, /* @__PURE__ */ new WeakSet());
+	});
+	return origins;
+}
+function childContextFor(entry, context, path) {
+	if (entry.invalidExtraContext) {
+		addDiagnostic$1(context, compositionDiagnostic({
+			code: "E_COMPOSITION_INVALID_MOUNT",
+			title: "mount received invalid source context",
+			path,
+			message: "A Bound Source cannot receive additional Source Context."
+		}));
+		return;
+	}
+	if (entry.contextProvider === void 0) return { present: false };
+	if (typeof entry.contextProvider !== "function") return {
+		present: true,
+		value: entry.contextProvider
+	};
+	try {
+		const value = context.context.present ? entry.contextProvider(context.context.value) : entry.contextProvider();
+		if (isPromiseLike(value)) {
+			addDiagnostic$1(context, compositionDiagnostic({
+				code: "E_COMPOSITION_CONTEXT_MAPPER_ASYNC",
+				title: "source context mapper returned a Promise",
+				path,
+				message: "Source Context Mappers must be synchronous in v0.3."
+			}));
+			return;
+		}
+		return {
+			present: true,
+			value
+		};
+	} catch (error) {
+		addDiagnostic$1(context, compositionDiagnostic({
+			code: "E_COMPOSITION_CONTEXT_MAPPER_FAILED",
+			title: "source context mapper failed",
+			path,
+			message: error instanceof Error ? error.message : "Source Context Mapper threw."
+		}));
+		return;
+	}
+}
+function resolveSource(source, context) {
+	const sourceState = source[COMPOSITION_SOURCE]();
+	const effectiveContext = context.context.present ? context.context : sourceState.boundContext;
+	if (context.depth > MAX_COMPOSITION_DEPTH) {
+		addDiagnostic$1(context, compositionDiagnostic({
+			code: "E_COMPOSITION_DEPTH_EXCEEDED",
+			title: "composition depth exceeded",
+			path: context.sourcePath,
+			message: `Composition depth exceeded ${MAX_COMPOSITION_DEPTH}.`
+		}));
+		return;
+	}
+	if (context.stack.indexOf(sourceState.cycleId) !== -1) {
+		addDiagnostic$1(context, compositionDiagnostic({
+			code: "E_COMPOSITION_CYCLE",
+			title: "composition cycle detected",
+			path: context.sourcePath,
+			message: "A Deck cannot mount itself through its descendant sources."
+		}));
+		return;
+	}
+	const entries = [];
+	let slideCount = 0;
+	const sourceKeys = /* @__PURE__ */ new Set();
+	const slotOrigins = collectSourceSlots(effectiveContext, context);
+	const nextContextBase = {
+		diagnostics: context.diagnostics,
+		stack: [...context.stack, sourceState.cycleId],
+		depth: context.depth + 1
+	};
+	sourceState.entries.forEach((entry, index) => {
+		if (entry.kind === "slide") {
+			entries.push({
+				kind: "slide",
+				factory: entry.factory,
+				path: `${context.sourcePath} > slideFactory[${index}]`
+			});
+			slideCount += 1;
+			return;
+		}
+		const mountPath = `${context.sourcePath} > mount[${entry.sourceKey}]`;
+		const invalidKey = validateSourceKey(entry.sourceKey);
+		if (invalidKey) {
+			addDiagnostic$1(context, compositionDiagnostic({
+				code: "E_COMPOSITION_INVALID_SOURCE_KEY",
+				title: "invalid source key",
+				path: mountPath,
+				message: invalidKey
+			}));
+			return;
+		}
+		if (sourceKeys.has(entry.sourceKey)) {
+			addDiagnostic$1(context, compositionDiagnostic({
+				code: "E_COMPOSITION_DUPLICATE_SOURCE_KEY",
+				title: "duplicate source key",
+				path: mountPath,
+				message: `Source Key "${entry.sourceKey}" is already used in this parent source.`
+			}));
+			return;
+		}
+		sourceKeys.add(entry.sourceKey);
+		const childContext = childContextFor(entry, context, mountPath);
+		if (!childContext) return;
+		const childSource = sourceOriginFor(context.source, entry.sourceKey);
+		const childPlan = resolveSource(entry.source, {
+			...nextContextBase,
+			source: childSource,
+			sourceIdentityMaterial: sourceMaterialFor(childSource),
+			sourcePath: sourcePathFor(context.sourcePath, entry.sourceKey),
+			context: childContext,
+			slotOwnerSource: context.source,
+			slotOwnerMaterial: context.sourceIdentityMaterial
+		});
+		if (!childPlan) return;
+		entries.push({
+			kind: "source",
+			source: childPlan
+		});
+		slideCount += childPlan.slideCount;
+	});
+	return {
+		source: context.source,
+		sourceIdentityMaterial: context.sourceIdentityMaterial,
+		context: effectiveContext,
+		entries,
+		slideCount,
+		slotOrigins
+	};
+}
+function flattenPlan(plan, deckTotalSlides, deckSlideIndex, roots, diagnostics) {
+	let sourceSlideIndex = 0;
+	let nextDeckSlideIndex = deckSlideIndex;
+	for (const entry of plan.entries) {
+		if (entry.kind === "source") {
+			nextDeckSlideIndex = flattenPlan(entry.source, deckTotalSlides, nextDeckSlideIndex, roots, diagnostics);
+			sourceSlideIndex += entry.source.slideCount;
+			continue;
+		}
+		const composition = {
+			...plan.source.kind === "mounted" ? { sourceKey: plan.source.sourceKey } : {},
+			slideIndex: sourceSlideIndex,
+			totalSlides: plan.slideCount,
+			deckSlideIndex: nextDeckSlideIndex,
+			deckTotalSlides
+		};
+		const input = plan.context.present ? {
+			context: plan.context.value,
+			composition
+		} : { composition };
+		const root = entry.factory(input);
+		if (!isAuthorTreeNode(root) || !isSlideRoot(root)) diagnostics.push(compositionDiagnostic({
+			code: "E_COMPOSITION_INVALID_ROOT",
+			title: "slide factory must return a <Slide /> root",
+			path: entry.path,
+			message: describeInvalidRoot(root),
+			help: ["Return <Slide>...</Slide> from the slide factory passed to deck.add()."]
+		}));
+		else roots.push({
+			root,
+			source: plan.source,
+			sourceIdentityMaterial: plan.sourceIdentityMaterial,
+			path: entry.path,
+			composition,
+			slotOrigins: plan.slotOrigins
+		});
+		sourceSlideIndex += 1;
+		nextDeckSlideIndex += 1;
+	}
+	return nextDeckSlideIndex;
+}
+function resolveComposition(source) {
+	const diagnostics = [];
+	const rootPlan = resolveSource(source, {
+		diagnostics,
+		stack: [],
+		depth: 0,
+		source: ROOT_SOURCE,
+		sourceIdentityMaterial: sourceMaterialFor(ROOT_SOURCE),
+		sourcePath: "root",
+		context: { present: false },
+		slotOwnerSource: ROOT_SOURCE,
+		slotOwnerMaterial: sourceMaterialFor(ROOT_SOURCE)
+	});
+	if (!rootPlan) return { diagnostics: createDiagnostics(diagnostics) };
+	const roots = [];
+	flattenPlan(rootPlan, rootPlan.slideCount, 0, roots, diagnostics);
+	const resolvedDiagnostics = createDiagnostics(diagnostics);
+	return {
+		...resolvedDiagnostics.hasErrors ? {} : { roots },
+		diagnostics: resolvedDiagnostics
+	};
+}
+//#endregion
+//#region src/graph/identity.ts
+function slug(value) {
+	return value.replace(/[^a-zA-Z0-9:_-]+/g, "_");
+}
+function graphNodeId(material) {
+	return slug(material.join("/"));
+}
+function styleEntityId(material) {
+	return slug(`style/${material.join("/")}`);
+}
+function assetEntityId(material) {
+	return slug(`asset/${material.join("/")}`);
+}
+//#endregion
+//#region src/graph/roles.ts
+function semanticKindForTag(tag) {
+	if (tag === "img") return "image";
+	if (tag === "p" || tag.startsWith("h") || tag === "span") return tag === "span" ? "textRun" : "text";
+	return "container";
+}
+function semanticKindForComponent(component) {
+	switch (component) {
+		case "Slide": return "slide";
+		case "View": return "container";
+		case "Text": return "text";
+		case "Image": return "image";
+		case "Shape": return "shape";
+	}
+}
+function semanticRoleForTag(tag) {
+	switch (tag) {
+		case "article":
+		case "aside":
+		case "footer":
+		case "header":
+		case "main":
+		case "nav":
+		case "section": return {
+			kind: "sectioning",
+			tag
+		};
+		case "div": return { kind: "genericContainer" };
+		case "figure": return { kind: "figure" };
+		case "p": return { kind: "paragraph" };
+		case "h1":
+		case "h2":
+		case "h3":
+		case "h4":
+		case "h5":
+		case "h6": return {
+			kind: "heading",
+			level: Number(tag.slice(1))
+		};
+		case "img": return { kind: "image" };
+		case "span": return;
+	}
+}
+function semanticRoleForComponent(component) {
+	switch (component) {
+		case "Slide": return { kind: "slide" };
+		case "Image": return { kind: "image" };
+		case "Shape": return { kind: "shape" };
+		case "Text":
+		case "View": return;
+	}
+}
+//#endregion
+//#region src/graph/build.ts
+function keySegment(key, index) {
+	return key === void 0 ? `index:${index}` : `key:${String(key)}`;
+}
+function sourceName(node) {
+	return node.source.kind === "tag" ? node.source.tag : node.source.component;
+}
+function nodeSemanticKind(node) {
+	return node.source.kind === "tag" ? semanticKindForTag(node.source.tag) : semanticKindForComponent(node.source.component);
+}
+function nodeRole(node) {
+	return node.source.kind === "tag" ? semanticRoleForTag(node.source.tag) : semanticRoleForComponent(node.source.component);
+}
+function sourceFor(context) {
+	return context.activeSlot?.source ?? context.source;
+}
+function contextForNode(node, context) {
+	const slot = context.slotOrigins.get(node);
+	if (!slot) return context;
+	return {
+		...context,
+		activeSlot: slot,
+		parentMaterial: [...context.parentMaterial, ...slot.identityMaterial],
+		path: `${context.path} > slot[${slot.field}]`
+	};
+}
+function originFor(node, path, context) {
+	return {
+		kind: "authored",
+		path,
+		source: sourceFor(context),
+		...node.sourceSpan ? { sourceSpan: node.sourceSpan } : {}
+	};
+}
+function textOriginFor(node, path, context) {
+	return {
+		kind: "authored",
+		path,
+		source: sourceFor(context),
+		...node.sourceSpan ? { sourceSpan: node.sourceSpan } : {}
+	};
+}
+function propsWithoutStyle(props) {
+	const { style: _style, children: _children, ...direct } = props;
+	return Object.keys(direct).length === 0 ? void 0 : direct;
+}
+function styleRefFor(state, idMaterial, target, props) {
+	const style = props.style;
+	const direct = propsWithoutStyle(props);
+	if (style === void 0 && direct === void 0) return;
+	const id = styleEntityId(idMaterial);
+	state.styles.set(id, {
+		id,
+		target,
+		authored: {
+			...style !== void 0 ? { style } : {},
+			...direct !== void 0 ? { direct } : {}
+		}
+	});
+	return id;
+}
+function addDiagnostic(state, item) {
+	state.diagnostics.push(item);
+}
+function invalidStructure(path, title, message, help) {
+	return diagnostic({
+		severity: "error",
+		code: "E_SEMANTIC_STRUCTURE",
+		title,
+		labels: [{
+			path,
+			message
+		}],
+		...message ? { message } : {},
+		...help ? { help } : {}
+	});
+}
+function assetForImage(state, idMaterial, props, path) {
+	if (typeof props.src !== "string" && typeof props.data !== "string") {
+		addDiagnostic(state, invalidStructure(path, "image source is missing", "Image nodes require either src or data.", ["Add a src path or data URL to the image."]));
+		return;
+	}
+	const id = assetEntityId(idMaterial);
+	const entity = {
+		id,
+		kind: "image",
+		source: typeof props.src === "string" ? {
+			kind: "path",
+			path: props.src
+		} : {
+			kind: "data",
+			data: props.data
+		},
+		metadata: typeof props.data === "string" && props.data.startsWith("data:") ? { mediaType: props.data.slice(5, props.data.indexOf(";")) || void 0 } : {},
+		resolution: "unresolved"
+	};
+	state.assets.set(id, entity);
+	return id;
+}
+function semanticBase(state, node, id, kind, path, material, context) {
+	const styleRef = styleRefFor(state, material, kind, node.props);
+	return {
+		id,
+		kind,
+		origin: originFor(node, path, context),
+		...node.source.kind === "tag" ? { authoredTag: node.source.tag } : {},
+		...node.source.kind === "component" ? { authoredComponent: node.source.component } : {},
+		...node.key !== void 0 ? { key: node.key } : {},
+		...nodeRole(node) ? { role: nodeRole(node) } : {},
+		...styleRef ? { styleRef } : {}
+	};
+}
+function buildTextRunFromLeaf(state, leaf, context, index) {
+	const text = typeof leaf.value === "string" ? leaf.value : String(leaf.value);
+	if (text.trim().length === 0) return;
+	const segment = `text:${index}`;
+	const id = graphNodeId([...context.parentMaterial, segment]);
+	const path = `${context.path} > text[${index}]`;
+	state.nodes.set(id, {
+		id,
+		kind: "textRun",
+		origin: textOriginFor(leaf, path, context),
+		text
+	});
+	return {
+		id,
+		kind: "textRun"
+	};
+}
+function buildImplicitTextNode(state, leaf, context, index) {
+	const run = buildTextRunFromLeaf(state, leaf, {
+		...context,
+		parentMaterial: [...context.parentMaterial, `implicit-text:${index}`],
+		path: `${context.path} > implicitText[${index}]`
+	}, 0);
+	if (!run) return;
+	const id = graphNodeId([...context.parentMaterial, `implicit-text:${index}`]);
+	state.nodes.set(id, {
+		id,
+		kind: "text",
+		origin: {
+			kind: "implicit",
+			path: `${context.path} > implicitText[${index}]`,
+			source: sourceFor(context),
+			...leaf.sourceSpan ? { sourceSpan: leaf.sourceSpan } : {},
+			reason: "primitive-text-in-container"
+		},
+		implicit: true,
+		inlineChildren: [run.id]
+	});
+	return {
+		id,
+		kind: "text"
+	};
+}
+function buildChildren(state, children, context) {
+	const ids = [];
+	children.forEach((child, index) => {
+		if (child.kind === "fragment") {
+			const childContext = contextForNode(child, context);
+			const segment = `fragment:${keySegment(child.key, index)}`;
+			ids.push(...buildChildren(state, child.children, {
+				...childContext,
+				parentMaterial: [...childContext.parentMaterial, segment],
+				path: `${childContext.path} > fragment[${keySegment(child.key, index)}]`
+			}));
+			return;
+		}
+		const built = buildNode(state, child, context, index);
+		if (built) ids.push(built.id);
+	});
+	return ids;
+}
+function buildTextLikeNode(state, node, id, path, material, context) {
+	const inlineChildren = [];
+	node.children.forEach((child, index) => {
+		if (child.kind === "text") {
+			const run = buildTextRunFromLeaf(state, child, {
+				...context,
+				parentId: id,
+				parentMaterial: material,
+				path,
+				inline: true
+			}, index);
+			if (run) inlineChildren.push(run.id);
+			return;
+		}
+		if (child.kind === "fragment") {
+			const childContext = contextForNode(child, {
+				...context,
+				parentId: id,
+				parentMaterial: material,
+				path,
+				inline: true
+			});
+			const segment = `fragment:${keySegment(child.key, index)}`;
+			inlineChildren.push(...buildChildren(state, child.children, {
+				...childContext,
+				parentMaterial: [...childContext.parentMaterial, segment],
+				path: `${childContext.path} > fragment[${keySegment(child.key, index)}]`
+			}));
+			return;
+		}
+		if (child.source.kind === "tag" && child.source.tag === "span") {
+			const built = buildNode(state, child, {
+				...context,
+				parentId: id,
+				parentMaterial: material,
+				path,
+				inline: true
+			}, index);
+			if (built) inlineChildren.push(built.id);
+			return;
+		}
+		addDiagnostic(state, invalidStructure(`${path} > ${sourceName(child)}[${index}]`, "block content cannot appear inside text", "Text-like elements accept primitive text and inline spans only."));
+	});
+	state.nodes.set(id, {
+		...semanticBase(state, node, id, "text", path, material, context),
+		kind: "text",
+		inlineChildren
+	});
+	return {
+		id,
+		kind: "text"
+	};
+}
+function collectInlineText(state, children, path) {
+	let text = "";
+	children.forEach((child, index) => {
+		if (child.kind === "text") {
+			text += typeof child.value === "string" ? child.value : String(child.value);
+			return;
+		}
+		if (child.kind === "fragment") {
+			text += collectInlineText(state, child.children, `${path} > fragment[${keySegment(child.key, index)}]`);
+			return;
+		}
+		if (child.source.kind === "tag" && child.source.tag === "span") {
+			text += collectInlineText(state, child.children, `${path} > span[${keySegment(child.key, index)}]`);
+			return;
+		}
+		addDiagnostic(state, invalidStructure(`${path} > ${sourceName(child)}[${index}]`, "block content cannot appear inside span", "span accepts primitive text or nested inline spans only."));
+	});
+	return text;
+}
+function buildNode(state, node, context, index) {
+	const nodeContext = contextForNode(node, context);
+	if (node.kind === "fragment") return;
+	if (node.kind === "text") return nodeContext.inline ? buildTextRunFromLeaf(state, node, nodeContext, index) : buildImplicitTextNode(state, node, nodeContext, index);
+	const kind = nodeSemanticKind(node);
+	const segment = `${sourceName(node)}:${keySegment(node.key, index)}`;
+	const material = [...nodeContext.parentMaterial, segment];
+	const id = graphNodeId(material);
+	const path = `${nodeContext.path} > ${sourceName(node)}[${keySegment(node.key, index)}]`;
+	if (kind === "textRun") {
+		if (!context.inline) {
+			addDiagnostic(state, invalidStructure(path, "span cannot appear here", "span must be inside a text-like element.", ["Wrap the span in <p>...</p> or move it inside an existing text element."]));
+			return;
+		}
+		const text = collectInlineText(state, node.children, path);
+		state.nodes.set(id, {
+			...semanticBase(state, node, id, "textRun", path, material, nodeContext),
+			kind: "textRun",
+			text
+		});
+		return {
+			id,
+			kind: "textRun"
+		};
+	}
+	if (kind === "text") return buildTextLikeNode(state, node, id, path, material, nodeContext);
+	if (kind === "image") {
+		if (node.children.length > 0) addDiagnostic(state, invalidStructure(path, "image cannot have children", "Image nodes are leaf nodes."));
+		const assetRef = assetForImage(state, material, node.props, path);
+		state.nodes.set(id, {
+			...semanticBase(state, node, id, "image", path, material, nodeContext),
+			kind: "image",
+			...assetRef ? { assetRef } : {}
+		});
+		return {
+			id,
+			kind: "image"
+		};
+	}
+	const childIds = buildChildren(state, node.children, {
+		parentId: id,
+		parentMaterial: material,
+		path,
+		inline: false,
+		source: sourceFor(nodeContext),
+		slotOrigins: nodeContext.slotOrigins,
+		activeSlot: nodeContext.activeSlot
+	});
+	state.nodes.set(id, {
+		...semanticBase(state, node, id, kind, path, material, nodeContext),
+		kind,
+		children: childIds
+	});
+	return {
+		id,
+		kind
+	};
+}
+function rootSource() {
+	return { kind: "root" };
+}
+function asComposedRoot(root, index) {
+	if (root.kind !== "element") throw new Error("Semantic graph roots must be element nodes.");
+	return {
+		root,
+		source: rootSource(),
+		sourceIdentityMaterial: ["source", "root"],
+		path: `document > slideFactory[${index}]`,
+		composition: {
+			slideIndex: index,
+			totalSlides: 0,
+			deckSlideIndex: index,
+			deckTotalSlides: 0
+		},
+		slotOrigins: /* @__PURE__ */ new WeakMap()
+	};
+}
+function buildSemanticAuthorGraph(roots) {
+	const documentId = graphNodeId(["document", "root"]);
+	const state = {
+		nodes: /* @__PURE__ */ new Map(),
+		styles: /* @__PURE__ */ new Map(),
+		assets: /* @__PURE__ */ new Map(),
+		diagnostics: []
+	};
+	const slideIds = [];
+	roots.forEach((root, index) => {
+		const composed = "root" in root ? root : asComposedRoot(root, index);
+		const built = buildNode(state, composed.root, {
+			parentId: documentId,
+			parentMaterial: [
+				"document",
+				"root",
+				...composed.sourceIdentityMaterial
+			],
+			path: composed.path,
+			inline: false,
+			source: composed.source,
+			slotOrigins: composed.slotOrigins
+		}, composed.composition.slideIndex);
+		if (built) slideIds.push(built.id);
+	});
+	const documentNode = {
+		id: documentId,
+		kind: "document",
+		origin: {
+			kind: "implicit",
+			path: "document",
+			source: rootSource()
+		},
+		role: { kind: "document" },
+		children: slideIds
+	};
+	state.nodes.set(documentId, documentNode);
+	const diagnostics = createDiagnostics(state.diagnostics);
+	return {
+		graph: {
+			documentId,
+			nodes: state.nodes,
+			styles: state.styles,
+			assets: state.assets
+		},
+		diagnostics
 	};
 }
 //#endregion
@@ -14974,6 +15772,24 @@ function toPptxTabStops(tabStops) {
 		...tabStop.alignment ? { alignment: tabStop.alignment } : {}
 	}));
 }
+function toPptxTextRunOptions(style) {
+	if (!style) return;
+	const options = {
+		fontFace: style.fontFamily,
+		fontSize: style.fontSizePt,
+		color: style.color,
+		bold: style.fontWeight === "bold" || typeof style.fontWeight === "number" && style.fontWeight >= 600,
+		italic: style.italic,
+		underline: toPptxUnderline(style),
+		strike: style.strike,
+		charSpacing: style.charSpacing,
+		superscript: style.superscript,
+		subscript: style.subscript,
+		breakLine: false
+	};
+	if (Object.values(options).every((value) => value === void 0 || value === false)) return;
+	return options;
+}
 function emitOutlineShape(slide, shapeName, frame, outline, radiusEmu, effectiveOpacity, rotation, flipH, flipV) {
 	if (!outline) return;
 	const insetEmu = pointsToEmu(outline.widthPt) / 2;
@@ -15048,7 +15864,14 @@ function emitText(slide, node, inheritedOpacity) {
 	emitOutlineShape(slide, node.radiusEmu && node.radiusEmu > 0 ? "roundRect" : "rect", node.frame, node.outline, node.radiusEmu, effectiveOpacity, node.rotation, node.flipH, node.flipV);
 	emitEdgeStrokes(slide, node.frame, node.edgeStrokes, effectiveOpacity, node.rotation, node.flipH, node.flipV);
 	emitBackgroundLayers(slide, node.frame, node.backgroundLayers, node.radiusEmu && node.radiusEmu > 0 ? "roundRect" : "rect", node.radiusEmu, effectiveOpacity, node.rotation, node.flipH, node.flipV);
-	slide.addText(node.content.text, {
+	const textContent = node.content.runs ? node.content.runs.map((run) => {
+		const options = toPptxTextRunOptions(run.style);
+		return {
+			text: run.text,
+			...options ? { options } : {}
+		};
+	}) : node.content.text;
+	slide.addText(textContent, {
 		x: emuToInches(node.frame.xEmu),
 		y: emuToInches(node.frame.yEmu),
 		w: emuToInches(node.frame.widthEmu),
@@ -15212,22 +16035,105 @@ async function outputPresentation(presentation, config) {
 }
 //#endregion
 //#region src/deck.ts
+function hasMountedSources(entries) {
+	return entries.some((entry) => entry.kind === "mount");
+}
+function directSlideFactories(entries) {
+	return entries.flatMap((entry) => entry.kind === "slide" ? [entry.factory] : []);
+}
+function mountedSourceError() {
+	return /* @__PURE__ */ new Error("Mounted sources are supported by compile() only until the output pipeline supports graph composition.");
+}
+function compileSource(source, config = {}) {
+	const composition = resolveComposition(source);
+	if (composition.diagnostics.hasErrors) {
+		if (config.mode === "inspect") return { diagnostics: composition.diagnostics };
+		throw new CompositionDiagnosticError(composition.diagnostics);
+	}
+	const result = buildSemanticAuthorGraph(composition.roots ?? []);
+	if (config.mode === "inspect") return result;
+	if (result.diagnostics.hasErrors) throw new SemanticGraphDiagnosticError(result.diagnostics);
+	if (!result.graph) throw new SemanticGraphDiagnosticError(result.diagnostics);
+	return result.graph;
+}
+var BoundSource = class {
+	#source;
+	#sourceContext;
+	constructor(source, sourceContext) {
+		this.#source = source;
+		this.#sourceContext = sourceContext;
+	}
+	[COMPOSITION_SOURCE]() {
+		const source = this.#source[COMPOSITION_SOURCE]();
+		return {
+			entries: source.entries,
+			cycleId: source.cycleId,
+			boundContext: {
+				present: true,
+				value: this.#sourceContext
+			}
+		};
+	}
+	compile(config = {}) {
+		return compileSource(this, config);
+	}
+	render() {
+		const source = this.#source[COMPOSITION_SOURCE]();
+		if (hasMountedSources(source.entries)) throw mountedSourceError();
+		return renderPresentation(this.#source.options, directSlideFactories(source.entries).map((factory) => (input) => factory({
+			...input,
+			context: this.#sourceContext
+		})));
+	}
+	async output(config) {
+		await outputPresentation(this.render(), config);
+	}
+};
 var Deck = class {
 	#options;
-	#slides = [];
+	#entries = [];
+	withSource;
 	constructor(options) {
 		this.#options = options;
+		this.withSource = ((sourceContext) => new BoundSource(this, sourceContext));
+	}
+	get options() {
+		return this.#options;
+	}
+	[COMPOSITION_SOURCE]() {
+		return {
+			entries: this.#entries,
+			cycleId: this,
+			boundContext: { present: false }
+		};
 	}
 	add(slide) {
-		this.#slides.push(slide);
+		this.#entries.push({
+			kind: "slide",
+			factory: slide
+		});
+		return this;
+	}
+	mount(sourceKey, child, ...context) {
+		this.#entries.push({
+			kind: "mount",
+			sourceKey,
+			source: child,
+			...context.length > 0 ? { contextProvider: context[0] } : {},
+			...child instanceof BoundSource && context.length > 0 ? { invalidExtraContext: true } : {}
+		});
 		return this;
 	}
 	render() {
-		return renderPresentation(this.#options, this.#slides);
+		if (hasMountedSources(this.#entries)) throw mountedSourceError();
+		return renderPresentation(this.#options, directSlideFactories(this.#entries));
+	}
+	compile(config = {}) {
+		return compileSource(this, config);
 	}
 	async output(config) {
 		await outputPresentation(this.render(), config);
 	}
 };
 //#endregion
-export { Deck, EMU_PER_INCH, Fragment, Image, POINTS_PER_INCH, Shape, Slide, Text, View, createElement, isAuthorNode, isContentNode, isSlideNode, pptxgenjsBackend };
+export { CompositionDiagnosticError, Deck, DeckDiagnosticError, EMU_PER_INCH, Fragment, Image, POINTS_PER_INCH, SemanticGraphDiagnosticError, Shape, Slide, Text, View, createElement, formatDiagnostic, formatDiagnostics, isAuthorNode, isContentNode, isSlideNode, pptxgenjsBackend };