deckjsx 0.2.0 → 0.2.1

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,442 @@ 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({
+				slideIndex,
+				totalSlides: slides.length,
+				context: {
+					slideIndex,
+					totalSlides: slides.length
+				}
+			})), {
+				slideIndex,
+				totalSlides: slides.length
+			}, 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";
+	}
+};
+//#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/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 originFor(node, path) {
+	return {
+		kind: "authored",
+		path,
+		...node.sourceSpan ? { sourceSpan: node.sourceSpan } : {}
+	};
+}
+function textOriginFor(node, path) {
+	return {
+		kind: "authored",
+		path,
+		...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) {
+	const styleRef = styleRefFor(state, material, kind, node.props);
+	return {
+		id,
+		kind,
+		origin: originFor(node, path),
+		...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),
+		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}]`,
+			...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 segment = `fragment:${keySegment(child.key, index)}`;
+			ids.push(...buildChildren(state, child.children, {
+				...context,
+				parentMaterial: [...context.parentMaterial, segment],
+				path: `${context.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) {
+	const inlineChildren = [];
+	node.children.forEach((child, index) => {
+		if (child.kind === "text") {
+			const run = buildTextRunFromLeaf(state, child, {
+				parentId: id,
+				parentMaterial: material,
+				path,
+				inline: true
+			}, index);
+			if (run) inlineChildren.push(run.id);
+			return;
+		}
+		if (child.kind === "fragment") {
+			inlineChildren.push(...buildChildren(state, child.children, {
+				parentId: id,
+				parentMaterial: [...material, `fragment:${keySegment(child.key, index)}`],
+				path: `${path} > fragment[${keySegment(child.key, index)}]`,
+				inline: true
+			}));
+			return;
+		}
+		if (child.source.kind === "tag" && child.source.tag === "span") {
+			const built = buildNode(state, child, {
+				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),
+		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) {
+	if (node.kind === "fragment") return;
+	if (node.kind === "text") return context.inline ? buildTextRunFromLeaf(state, node, context, index) : buildImplicitTextNode(state, node, context, index);
+	const kind = nodeSemanticKind(node);
+	const segment = `${sourceName(node)}:${keySegment(node.key, index)}`;
+	const material = [...context.parentMaterial, segment];
+	const id = graphNodeId(material);
+	const path = `${context.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),
+			kind: "textRun",
+			text
+		});
+		return {
+			id,
+			kind: "textRun"
+		};
+	}
+	if (kind === "text") return buildTextLikeNode(state, node, id, path, material);
+	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),
+			kind: "image",
+			...assetRef ? { assetRef } : {}
+		});
+		return {
+			id,
+			kind: "image"
+		};
+	}
+	const childIds = buildChildren(state, node.children, {
+		parentId: id,
+		parentMaterial: material,
+		path,
+		inline: false
+	});
+	state.nodes.set(id, {
+		...semanticBase(state, node, id, kind, path, material),
+		kind,
+		children: childIds
+	});
+	return {
+		id,
+		kind
+	};
+}
+function buildSemanticAuthorGraph(roots) {
+	const documentId = graphNodeId(["document", "root"]);
+	const state = {
+		nodes: /* @__PURE__ */ new Map(),
+		styles: /* @__PURE__ */ new Map(),
+		assets: /* @__PURE__ */ new Map(),
+		diagnostics: []
+	};
+	const documentNode = {
+		id: documentId,
+		kind: "document",
+		origin: {
+			kind: "implicit",
+			path: "document"
+		},
+		role: { kind: "document" },
+		children: buildChildren(state, roots, {
+			parentId: documentId,
+			parentMaterial: ["document", "root"],
+			path: "document",
+			inline: false
+		})
+	};
+	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 +15439,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 +15531,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,6 +15702,33 @@ async function outputPresentation(presentation, config) {
 }
 //#endregion
 //#region src/deck.ts
+function isSlideRoot(value) {
+	return value.kind === "element" && value.source.kind === "component" && value.source.component === "Slide";
+}
+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 invalidRootSourceSpan(value) {
+	return isAuthorTreeNode(value) ? value.sourceSpan : void 0;
+}
+function invalidRootDiagnostic(value, slideIndex) {
+	const path = `document > slideFactory[${slideIndex}]`;
+	return diagnostic({
+		severity: "error",
+		code: "E_COMPILE_ROOT",
+		title: "slide factory must return a <Slide /> root",
+		message: describeInvalidRoot(value),
+		labels: [{
+			path,
+			message: "Expected a deckjsx Author Tree <Slide /> node.",
+			...invalidRootSourceSpan(value) ? { sourceSpan: invalidRootSourceSpan(value) } : {}
+		}],
+		help: ["Return <Slide>...</Slide> from the slide factory passed to deck.add()."]
+	});
+}
 var Deck = class {
 	#options;
 	#slides = [];
@@ -15225,9 +15742,38 @@ var Deck = class {
 	render() {
 		return renderPresentation(this.#options, this.#slides);
 	}
+	compile(config = {}) {
+		const roots = [];
+		const diagnostics = [];
+		this.#slides.forEach((factory, slideIndex) => {
+			const root = factory({
+				slideIndex,
+				totalSlides: this.#slides.length,
+				context: {
+					slideIndex,
+					totalSlides: this.#slides.length
+				}
+			});
+			if (!isAuthorTreeNode(root) || !isSlideRoot(root)) {
+				diagnostics.push(invalidRootDiagnostic(root, slideIndex));
+				return;
+			}
+			roots.push(root);
+		});
+		if (diagnostics.length > 0) {
+			const result = { diagnostics: createDiagnostics(diagnostics) };
+			if (config.mode === "inspect") return result;
+			throw new SemanticGraphDiagnosticError(result.diagnostics);
+		}
+		const result = buildSemanticAuthorGraph(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;
+	}
 	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 { Deck, DeckDiagnosticError, EMU_PER_INCH, Fragment, Image, POINTS_PER_INCH, SemanticGraphDiagnosticError, Shape, Slide, Text, View, createElement, formatDiagnostic, formatDiagnostics, isAuthorNode, isContentNode, isSlideNode, pptxgenjsBackend };