documents.js 2.3.2 → 3.0.0

package/dist/convert/factor-styles.js

@@ -0,0 +1,362 @@
+import { flattenPackage } from "./flatten.js";
+import { canonicalKey } from "./canonicalise.js";
+import { decomposeDrawPage, decomposeSection, decomposeSheet, decomposeSlide } from "./decompose.js";
+//#region src/convert/factor-styles.ts
+const PARAGRAPH_STYLE_KEYS = [
+	"alignment",
+	"spacingBeforePt",
+	"spacingAfterPt",
+	"lineSpacing",
+	"indentLeftPt",
+	"indentFirstLinePt"
+];
+const RUN_STYLE_KEYS = [
+	"bold",
+	"italic",
+	"underline",
+	"strike",
+	"fontFamily",
+	"sizePt",
+	"color"
+];
+function isShapeGroupWrapper(wrapper) {
+	return !("kind" in wrapper.node);
+}
+function isAnchorGroupWrapper(wrapper) {
+	return "kind" in wrapper.node && wrapper.node.kind === "paragraph";
+}
+function isSlideGroupWrapper(wrapper) {
+	return "kind" in wrapper.node && wrapper.node.kind === "slide";
+}
+function isDrawPageGroupWrapper(wrapper) {
+	return "kind" in wrapper.node && wrapper.node.kind === "drawPage";
+}
+function isHeadingGroup(group) {
+	return group.node.headingLevel !== void 0;
+}
+function assemblePackage(content, pages) {
+	const envelope = {
+		metadata: content.metadata,
+		...content.symbolTable !== void 0 ? { symbolTable: content.symbolTable } : {},
+		...pages !== void 0 ? { pages: [...pages] } : {}
+	};
+	switch (content.kind) {
+		case "wordprocessing": return mint({
+			kind: "wordprocessing",
+			...envelope,
+			children: content.sections.map(decomposeSection)
+		});
+		case "presentation": return mint({
+			kind: "presentation",
+			...envelope,
+			children: content.slides.map(decomposeSlide)
+		});
+		case "spreadsheet": return mint({
+			kind: "spreadsheet",
+			...envelope,
+			children: content.sheets.map(decomposeSheet)
+		});
+		case "drawing": return mint({
+			kind: "drawing",
+			...envelope,
+			children: content.pages.map(decomposeDrawPage)
+		});
+		case "formula": return mint({
+			kind: "formula",
+			...envelope,
+			children: [content.formula]
+		});
+	}
+}
+function factorStyles(pkg) {
+	return assemblePackage(flattenPackage(pkg), pkg.pages);
+}
+function extentOf(wrapper) {
+	if (isShapeGroupWrapper(wrapper)) return flowExtent(wrapper.children);
+	if (isAnchorGroupWrapper(wrapper)) return [wrapper.node, ...flowExtent(wrapper.children)];
+	if (isSlideGroupWrapper(wrapper)) return wrapper.children.flatMap(extentOf);
+	if (isDrawPageGroupWrapper(wrapper)) {
+		const paragraphs = [];
+		for (const child of wrapper.children) if ("node" in child) paragraphs.push(...extentOf(child));
+		return paragraphs;
+	}
+	return flowExtent(wrapper.children);
+}
+function flowExtent(children) {
+	const paragraphs = [];
+	for (const child of children) if ("node" in child && "children" in child) paragraphs.push(...extentOf(child));
+	else if (child.kind === "paragraph") paragraphs.push(child);
+	return paragraphs;
+}
+function paragraphTuple(paragraph, keys) {
+	const tuple = {};
+	for (const key of keys) if (paragraph[key] !== void 0) tuple[key] = paragraph[key];
+	return tuple;
+}
+function runTuple(run, keys) {
+	const tuple = {};
+	for (const key of keys) if (run[key] !== void 0) tuple[key] = run[key];
+	return tuple;
+}
+function commonParagraphKeys(extent, frozen) {
+	return PARAGRAPH_STYLE_KEYS.filter((key) => !frozen.has(key) && extent.every((paragraph) => paragraph[key] !== void 0));
+}
+function commonRunKeys(extent, frozen) {
+	const runs = extent.flatMap((paragraph) => paragraph.runs);
+	if (runs.length === 0) return [];
+	return RUN_STYLE_KEYS.filter((key) => !frozen.has(key) && runs.every((run) => run[key] !== void 0));
+}
+function bestParagraphCandidate(extent, keys, factored) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const paragraph of extent) {
+		if (factored.has(paragraph)) continue;
+		const tuple = paragraphTuple(paragraph, keys);
+		if (Object.keys(tuple).length === 0) continue;
+		const key = canonicalKey(tuple);
+		const existing = groups.get(key);
+		if (existing === void 0) groups.set(key, {
+			tuple,
+			keys,
+			positions: [paragraph]
+		});
+		else existing.positions.push(paragraph);
+	}
+	return bestGroup(groups);
+}
+function bestRunCandidate(extent, keys, factored) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const paragraph of extent) for (const run of paragraph.runs) {
+		if (factored.has(run)) continue;
+		const tuple = runTuple(run, keys);
+		if (Object.keys(tuple).length === 0) continue;
+		const key = canonicalKey(tuple);
+		const existing = groups.get(key);
+		if (existing === void 0) groups.set(key, {
+			tuple,
+			keys,
+			positions: [run]
+		});
+		else existing.positions.push(run);
+	}
+	return bestGroup(groups);
+}
+function bestGroup(groups) {
+	let best;
+	for (const group of groups.values()) {
+		if (group.positions.length < 2) continue;
+		if (best === void 0 || group.positions.length > best.positions.length) best = group;
+	}
+	return best;
+}
+function plan(wrapper, visit, frozenParagraphs, frozenRuns, state, entries) {
+	const extent = extentOf(wrapper);
+	const paragraphCandidate = extent.length > 0 ? bestParagraphCandidate(extent, commonParagraphKeys(extent, frozenParagraphs), state.factoredParagraphs) : void 0;
+	const runCandidate = extent.length > 0 ? bestRunCandidate(extent, commonRunKeys(extent, frozenRuns), state.factoredRuns) : void 0;
+	const nextFrozenParagraphs = new Set(frozenParagraphs);
+	const nextFrozenRuns = new Set(frozenRuns);
+	if (paragraphCandidate !== void 0 || runCandidate !== void 0) {
+		const content = {
+			...paragraphCandidate !== void 0 ? { paragraph: paragraphCandidate.tuple } : {},
+			...runCandidate !== void 0 ? { run: runCandidate.tuple } : {}
+		};
+		const contentKey = canonicalKey(content);
+		const existing = entries.get(contentKey);
+		if (existing === void 0) entries.set(contentKey, {
+			content,
+			wrappers: [wrapper],
+			frequency: (paragraphCandidate?.positions.length ?? 0) + (runCandidate?.positions.length ?? 0),
+			firstVisit: visit.index
+		});
+		else {
+			existing.wrappers.push(wrapper);
+			existing.frequency += (paragraphCandidate?.positions.length ?? 0) + (runCandidate?.positions.length ?? 0);
+		}
+		if (paragraphCandidate !== void 0) {
+			for (const paragraph of paragraphCandidate.positions) {
+				state.factoredParagraphs.add(paragraph);
+				state.paragraphStrips.set(paragraph, paragraphCandidate.keys);
+			}
+			for (const key of paragraphCandidate.keys) nextFrozenParagraphs.add(key);
+		}
+		if (runCandidate !== void 0) {
+			for (const run of runCandidate.positions) {
+				state.factoredRuns.add(run);
+				state.runStrips.set(run, runCandidate.keys);
+			}
+			for (const key of runCandidate.keys) nextFrozenRuns.add(key);
+		}
+	}
+	visit.index += 1;
+	for (const child of childWrappers(wrapper)) plan(child, visit, nextFrozenParagraphs, nextFrozenRuns, state, entries);
+}
+function childWrappers(wrapper) {
+	if (isShapeGroupWrapper(wrapper) || isAnchorGroupWrapper(wrapper)) {
+		const wrappers = [];
+		for (const child of wrapper.children) if ("node" in child && "children" in child) wrappers.push(child);
+		return wrappers;
+	}
+	if (isSlideGroupWrapper(wrapper)) return [...wrapper.children];
+	if (isDrawPageGroupWrapper(wrapper)) {
+		const shapes = [];
+		for (const child of wrapper.children) if ("node" in child) shapes.push(child);
+		return shapes;
+	}
+	const wrappers = [];
+	for (const child of wrapper.children) if ("node" in child && "children" in child) wrappers.push(child);
+	return wrappers;
+}
+function mint(pkg) {
+	const state = {
+		factoredParagraphs: /* @__PURE__ */ new Set(),
+		factoredRuns: /* @__PURE__ */ new Set(),
+		wrapperRefs: /* @__PURE__ */ new Map(),
+		paragraphStrips: /* @__PURE__ */ new Map(),
+		runStrips: /* @__PURE__ */ new Map()
+	};
+	const entries = /* @__PURE__ */ new Map();
+	const visit = { index: 0 };
+	const emptyParagraphs = /* @__PURE__ */ new Set();
+	const emptyRuns = /* @__PURE__ */ new Set();
+	switch (pkg.kind) {
+		case "wordprocessing":
+			for (const root of pkg.children) plan(root, visit, emptyParagraphs, emptyRuns, state, entries);
+			break;
+		case "presentation":
+			for (const root of pkg.children) plan(root, visit, emptyParagraphs, emptyRuns, state, entries);
+			break;
+		case "drawing": for (const root of pkg.children) plan(root, visit, emptyParagraphs, emptyRuns, state, entries);
+	}
+	if (entries.size === 0) return pkg;
+	const ordered = [...entries.values()].sort((a, b) => b.frequency - a.frequency || a.firstVisit - b.firstVisit || canonicalKey(a.content).localeCompare(canonicalKey(b.content)));
+	const styles = {};
+	ordered.forEach((entry, index) => {
+		const id = `s${index + 1}`;
+		styles[id] = entry.content;
+		for (const wrapper of entry.wrappers) state.wrapperRefs.set(wrapper, id);
+	});
+	switch (pkg.kind) {
+		case "wordprocessing": return {
+			...pkg,
+			styles,
+			children: pkg.children.map((group) => rebuildSectionGroup(group, state))
+		};
+		case "presentation": return {
+			...pkg,
+			styles,
+			children: pkg.children.map((group) => rebuildSlideGroup(group, state))
+		};
+		case "drawing": return {
+			...pkg,
+			styles,
+			children: pkg.children.map((group) => rebuildDrawPageGroup(group, state))
+		};
+		case "spreadsheet":
+		case "formula": return {
+			...pkg,
+			styles
+		};
+	}
+}
+function rebuildSlideGroup(group, state) {
+	const children = group.children.map((shape) => rebuildShapeGroup(shape, state));
+	const ref = state.wrapperRefs.get(group);
+	return ref === void 0 && children.every((child, index) => child === group.children[index]) ? group : {
+		node: group.node,
+		...ref !== void 0 ? { style: ref } : {},
+		children
+	};
+}
+function rebuildDrawPageGroup(group, state) {
+	const children = group.children.map((child) => "node" in child ? rebuildShapeGroup(child, state) : child);
+	const ref = state.wrapperRefs.get(group);
+	return ref === void 0 && children.every((child, index) => child === group.children[index]) ? group : {
+		node: group.node,
+		...ref !== void 0 ? { style: ref } : {},
+		children
+	};
+}
+function rebuildSectionGroup(group, state) {
+	const children = group.children.map((child) => rebuildSectionChild(child, state));
+	const ref = state.wrapperRefs.get(group);
+	return ref === void 0 && children.every((child, index) => child === group.children[index]) ? group : {
+		node: group.node,
+		...ref !== void 0 ? { style: ref } : {},
+		children
+	};
+}
+function rebuildSectionChild(child, state) {
+	if ("node" in child && "children" in child) return isHeadingGroup(child) ? rebuildHeadingGroup(child, state, rebuildSectionChild) : rebuildListGroup(child, state, rebuildListChild);
+	if (child.kind === "paragraph") return rebuildParagraph(child, state);
+	return child;
+}
+function rebuildListChild(child, state) {
+	if ("node" in child && "children" in child) return rebuildListGroup(child, state, rebuildListChild);
+	if (child.kind === "paragraph") return rebuildParagraph(child, state);
+	return child;
+}
+function rebuildShapeGroup(group, state) {
+	const children = group.children.map((child) => rebuildListChild(child, state));
+	const ref = state.wrapperRefs.get(group);
+	return ref === void 0 && children.every((child, index) => child === group.children[index]) ? group : {
+		node: group.node,
+		...ref !== void 0 ? { style: ref } : {},
+		children
+	};
+}
+function rebuildHeadingGroup(group, state, rebuildChild) {
+	const anchor = rebuildParagraph(group.node, state);
+	assertHeadingAnchor(anchor);
+	const children = group.children.map((child) => rebuildChild(child, state));
+	const ref = state.wrapperRefs.get(group);
+	return ref === void 0 && anchor === group.node && children.every((child, index) => child === group.children[index]) ? group : {
+		node: anchor,
+		...ref !== void 0 ? { style: ref } : {},
+		children
+	};
+}
+function rebuildListGroup(group, state, rebuildChild) {
+	const anchor = rebuildParagraph(group.node, state);
+	assertListAnchor(anchor);
+	const children = group.children.map((child) => rebuildChild(child, state));
+	const ref = state.wrapperRefs.get(group);
+	return ref === void 0 && anchor === group.node && children.every((child, index) => child === group.children[index]) ? group : {
+		node: anchor,
+		...ref !== void 0 ? { style: ref } : {},
+		children
+	};
+}
+function assertHeadingAnchor(paragraph) {
+	if (paragraph.headingLevel === void 0) throw new Error("factorStyles: stripping dropped a heading anchor's headingLevel");
+}
+function assertListAnchor(paragraph) {
+	if (paragraph.list === void 0) throw new Error("factorStyles: stripping dropped a list anchor's list membership");
+}
+function rebuildParagraph(paragraph, state) {
+	const strips = state.paragraphStrips.get(paragraph);
+	const base = strips === void 0 ? paragraph : stripParagraphKeys(paragraph, strips);
+	let changed = base !== paragraph;
+	const runs = [];
+	for (const run of base.runs) {
+		const runStrips = state.runStrips.get(run);
+		const rebuilt = runStrips === void 0 ? run : stripRunKeys(run, runStrips);
+		changed ||= rebuilt !== run;
+		runs.push(rebuilt);
+	}
+	if (!changed) return paragraph;
+	return {
+		...base,
+		runs
+	};
+}
+function stripParagraphKeys(paragraph, keys) {
+	const copy = { ...paragraph };
+	for (const key of keys) delete copy[key];
+	return copy;
+}
+function stripRunKeys(run, keys) {
+	const copy = { ...run };
+	for (const key of keys) delete copy[key];
+	return copy;
+}
+//#endregion
+export { assemblePackage, factorStyles };

package/dist/convert/flatten.cjs

@@ -0,0 +1,137 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let document_schema_js = require("document-schema.js");
+//#region src/convert/flatten.ts
+function chainWithRef(chain, group) {
+	return group.style === void 0 ? chain : [...chain, group.style];
+}
+function entryOf(styles, chain) {
+	if (chain.length === 0) return void 0;
+	if (styles === void 0) throw new Error("flattenPackage: a group carries a style ref but the package has no styles table");
+	return (0, document_schema_js.resolveStyleChain)(styles, chain);
+}
+function applyEntry(entry, paragraph) {
+	const withParagraph = (0, document_schema_js.applyParagraphStyleProperties)(entry.paragraph, paragraph);
+	const runProperties = entry.run;
+	if (runProperties === void 0) return withParagraph;
+	return {
+		...withParagraph,
+		runs: withParagraph.runs.map((run) => (0, document_schema_js.applyRunStyleProperties)(runProperties, run))
+	};
+}
+function flattenPackage(pkg) {
+	const styles = pkg.styles;
+	const envelope = {
+		metadata: pkg.metadata,
+		...pkg.symbolTable !== void 0 ? { symbolTable: pkg.symbolTable } : {}
+	};
+	switch (pkg.kind) {
+		case "wordprocessing": return {
+			kind: "wordprocessing",
+			...envelope,
+			sections: pkg.children.map((group) => ({
+				...untag(group.node),
+				blocks: flattenSectionChildren(styles, chainWithRef([], group), group.children)
+			}))
+		};
+		case "presentation": return {
+			kind: "presentation",
+			...envelope,
+			slides: pkg.children.map((group) => {
+				const chain = chainWithRef([], group);
+				return {
+					...untag(group.node),
+					shapes: group.children.map((shape) => flattenShape(styles, chain, shape))
+				};
+			})
+		};
+		case "spreadsheet": return {
+			kind: "spreadsheet",
+			...envelope,
+			sheets: pkg.children.map((group) => {
+				const images = [];
+				const embedded = [];
+				for (const child of group.children) if ("kind" in child) images.push(child);
+				else embedded.push(child);
+				return {
+					...untag(group.node),
+					images,
+					...embedded.length > 0 ? { embeddedObjects: embedded } : {}
+				};
+			})
+		};
+		case "drawing": return {
+			kind: "drawing",
+			...envelope,
+			pages: pkg.children.map((group) => {
+				const chain = chainWithRef([], group);
+				const shapes = [];
+				const vectors = [];
+				for (const child of group.children) if ("node" in child) shapes.push(flattenShape(styles, chain, child));
+				else vectors.push(child);
+				return {
+					...untag(group.node),
+					shapes,
+					vectors
+				};
+			})
+		};
+		case "formula": {
+			const first = pkg.children[0];
+			if (pkg.children.length !== 1 || first === void 0 || !document_schema_js.ContentFormulaSchema.safeParse(first).success) throw new Error("flattenPackage: a formula package takes exactly one ContentFormula node");
+			return {
+				kind: "formula",
+				...envelope,
+				formula: first
+			};
+		}
+	}
+}
+function untag(descriptor) {
+	const copy = { ...descriptor };
+	delete copy.kind;
+	return copy;
+}
+function flattenShape(styles, chain, group) {
+	return {
+		...group.node,
+		blocks: flattenListChildren(styles, chainWithRef(chain, group), group.children)
+	};
+}
+function flattenSectionChildren(styles, chain, children) {
+	const blocks = [];
+	for (const child of children) if (isHeadingGroup(child)) {
+		const own = chainWithRef(chain, child);
+		blocks.push(resolveAnchor(styles, own, child.node), ...flattenSectionChildren(styles, own, child.children));
+	} else if (isListGroup(child)) {
+		const own = chainWithRef(chain, child);
+		blocks.push(resolveAnchor(styles, own, child.node), ...flattenListChildren(styles, own, child.children));
+	} else if (child.kind === "paragraph") {
+		const entry = entryOf(styles, chain);
+		blocks.push(entry === void 0 ? child : applyEntry(entry, child));
+	} else blocks.push(child);
+	return blocks;
+}
+function flattenListChildren(styles, chain, children) {
+	const blocks = [];
+	for (const child of children) if (isListGroup(child)) {
+		const own = chainWithRef(chain, child);
+		blocks.push(resolveAnchor(styles, own, child.node), ...flattenListChildren(styles, own, child.children));
+	} else if (child.kind === "paragraph") {
+		const entry = entryOf(styles, chain);
+		blocks.push(entry === void 0 ? child : applyEntry(entry, child));
+	} else blocks.push(child);
+	return blocks;
+}
+function isHeadingGroup(child) {
+	return "node" in child && "children" in child && child.node.kind === "paragraph" && child.node.headingLevel !== void 0;
+}
+function isListGroup(child) {
+	return "node" in child && "children" in child && child.node.kind === "paragraph" && child.node.list !== void 0;
+}
+function resolveAnchor(styles, chain, anchor) {
+	const entry = entryOf(styles, chain);
+	if (entry === void 0) return anchor;
+	return applyEntry(entry, anchor);
+}
+//#endregion
+exports.flattenPackage = flattenPackage;

package/dist/convert/flatten.d.cts

@@ -0,0 +1,5 @@
+import { ContentDocument, DocumentPackage } from "document-schema.js";
+//#region src/convert/flatten.d.ts
+declare function flattenPackage(pkg: DocumentPackage): ContentDocument;
+//#endregion
+export { flattenPackage };

package/dist/convert/flatten.d.ts

@@ -0,0 +1,5 @@
+import { ContentDocument, DocumentPackage } from "document-schema.js";
+//#region src/convert/flatten.d.ts
+declare function flattenPackage(pkg: DocumentPackage): ContentDocument;
+//#endregion
+export { flattenPackage };

package/dist/convert/flatten.js

@@ -0,0 +1,136 @@
+import { ContentFormulaSchema, applyParagraphStyleProperties, applyRunStyleProperties, resolveStyleChain } from "document-schema.js";
+//#region src/convert/flatten.ts
+function chainWithRef(chain, group) {
+	return group.style === void 0 ? chain : [...chain, group.style];
+}
+function entryOf(styles, chain) {
+	if (chain.length === 0) return void 0;
+	if (styles === void 0) throw new Error("flattenPackage: a group carries a style ref but the package has no styles table");
+	return resolveStyleChain(styles, chain);
+}
+function applyEntry(entry, paragraph) {
+	const withParagraph = applyParagraphStyleProperties(entry.paragraph, paragraph);
+	const runProperties = entry.run;
+	if (runProperties === void 0) return withParagraph;
+	return {
+		...withParagraph,
+		runs: withParagraph.runs.map((run) => applyRunStyleProperties(runProperties, run))
+	};
+}
+function flattenPackage(pkg) {
+	const styles = pkg.styles;
+	const envelope = {
+		metadata: pkg.metadata,
+		...pkg.symbolTable !== void 0 ? { symbolTable: pkg.symbolTable } : {}
+	};
+	switch (pkg.kind) {
+		case "wordprocessing": return {
+			kind: "wordprocessing",
+			...envelope,
+			sections: pkg.children.map((group) => ({
+				...untag(group.node),
+				blocks: flattenSectionChildren(styles, chainWithRef([], group), group.children)
+			}))
+		};
+		case "presentation": return {
+			kind: "presentation",
+			...envelope,
+			slides: pkg.children.map((group) => {
+				const chain = chainWithRef([], group);
+				return {
+					...untag(group.node),
+					shapes: group.children.map((shape) => flattenShape(styles, chain, shape))
+				};
+			})
+		};
+		case "spreadsheet": return {
+			kind: "spreadsheet",
+			...envelope,
+			sheets: pkg.children.map((group) => {
+				const images = [];
+				const embedded = [];
+				for (const child of group.children) if ("kind" in child) images.push(child);
+				else embedded.push(child);
+				return {
+					...untag(group.node),
+					images,
+					...embedded.length > 0 ? { embeddedObjects: embedded } : {}
+				};
+			})
+		};
+		case "drawing": return {
+			kind: "drawing",
+			...envelope,
+			pages: pkg.children.map((group) => {
+				const chain = chainWithRef([], group);
+				const shapes = [];
+				const vectors = [];
+				for (const child of group.children) if ("node" in child) shapes.push(flattenShape(styles, chain, child));
+				else vectors.push(child);
+				return {
+					...untag(group.node),
+					shapes,
+					vectors
+				};
+			})
+		};
+		case "formula": {
+			const first = pkg.children[0];
+			if (pkg.children.length !== 1 || first === void 0 || !ContentFormulaSchema.safeParse(first).success) throw new Error("flattenPackage: a formula package takes exactly one ContentFormula node");
+			return {
+				kind: "formula",
+				...envelope,
+				formula: first
+			};
+		}
+	}
+}
+function untag(descriptor) {
+	const copy = { ...descriptor };
+	delete copy.kind;
+	return copy;
+}
+function flattenShape(styles, chain, group) {
+	return {
+		...group.node,
+		blocks: flattenListChildren(styles, chainWithRef(chain, group), group.children)
+	};
+}
+function flattenSectionChildren(styles, chain, children) {
+	const blocks = [];
+	for (const child of children) if (isHeadingGroup(child)) {
+		const own = chainWithRef(chain, child);
+		blocks.push(resolveAnchor(styles, own, child.node), ...flattenSectionChildren(styles, own, child.children));
+	} else if (isListGroup(child)) {
+		const own = chainWithRef(chain, child);
+		blocks.push(resolveAnchor(styles, own, child.node), ...flattenListChildren(styles, own, child.children));
+	} else if (child.kind === "paragraph") {
+		const entry = entryOf(styles, chain);
+		blocks.push(entry === void 0 ? child : applyEntry(entry, child));
+	} else blocks.push(child);
+	return blocks;
+}
+function flattenListChildren(styles, chain, children) {
+	const blocks = [];
+	for (const child of children) if (isListGroup(child)) {
+		const own = chainWithRef(chain, child);
+		blocks.push(resolveAnchor(styles, own, child.node), ...flattenListChildren(styles, own, child.children));
+	} else if (child.kind === "paragraph") {
+		const entry = entryOf(styles, chain);
+		blocks.push(entry === void 0 ? child : applyEntry(entry, child));
+	} else blocks.push(child);
+	return blocks;
+}
+function isHeadingGroup(child) {
+	return "node" in child && "children" in child && child.node.kind === "paragraph" && child.node.headingLevel !== void 0;
+}
+function isListGroup(child) {
+	return "node" in child && "children" in child && child.node.kind === "paragraph" && child.node.list !== void 0;
+}
+function resolveAnchor(styles, chain, anchor) {
+	const entry = entryOf(styles, chain);
+	if (entry === void 0) return anchor;
+	return applyEntry(entry, anchor);
+}
+//#endregion
+export { flattenPackage };

package/dist/convert/from-package.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_model_geometry = require("../model/geometry.cjs");
+const require_convert_flatten = require("./flatten.cjs");
 const require_layout_shared = require("../layout/shared.cjs");
 require("../layout/sheets.cjs");
 const require_layout_drawing = require("../layout/drawing.cjs");
@@ -15,7 +16,7 @@ function buildDocumentBytes(pkg, target) {
 	if (target === "odf") throw new Error("'odf' (a standalone formula document) cannot be built from a DocumentPackage -- there is no ContentDocument-to-odf builder");
 	const content = require_codecs_registry.DOCUMENT_FORMAT_CODECS[target].content;
 	if (!content?.write) throw new Error(`DocumentFormat '${target}' has no content.write codec in DOCUMENT_FORMAT_CODECS, and is not 'pdf'/'odf' -- this is an internal invariant violation, not a caller error`);
-	return require_codecs_registry.requireArrayBufferBytes(content.write(pkg.content));
+	return require_codecs_registry.requireArrayBufferBytes(content.write(require_convert_flatten.flattenPackage(pkg)));
 }
 function pageOfFrame(state, frame) {
 	return state.pages[frame.pageIndex];
@@ -173,7 +174,7 @@ function layoutDocumentFromPackage(pkg) {
 		pages,
 		images: {}
 	};
-	const content = pkg.content;
+	const content = require_convert_flatten.flattenPackage(pkg);
 	if (content.kind === "wordprocessing") for (const section of content.sections) emitBlocks(state, section.blocks);
 	else if (content.kind === "presentation") for (const slide of content.slides) for (const shape of slide.shapes) emitBlocks(state, shape.blocks);
 	else if (content.kind === "spreadsheet") for (const sheet of content.sheets) emitSheet(state, sheet);
@@ -182,7 +183,7 @@ function layoutDocumentFromPackage(pkg) {
 		for (const shape of drawPage.shapes) emitBlocks(state, shape.blocks);
 	}
 	return {
-		formatVersion: document_schema_js.LAYOUT_FORMAT_VERSION,
+		formatVersion: pdf_codec.LAYOUT_FORMAT_VERSION,
 		metadata: content.metadata,
 		pages,
 		images: state.images

package/dist/convert/from-package.d.cts

@@ -1,5 +1,6 @@
 import { DocumentFormat } from "./port.cjs";
-import { DocumentPackage, LayoutDocument } from "document-schema.js";
+import { DocumentPackage } from "document-schema.js";
+import { LayoutDocument } from "pdf-codec";
 //#region src/convert/from-package.d.ts
 declare function buildDocumentBytes(pkg: DocumentPackage, target: DocumentFormat): Uint8Array<ArrayBuffer>;
 declare function layoutDocumentFromPackage(pkg: DocumentPackage): LayoutDocument;