document-model.js 4.2.0 → 4.3.1

package/dist/decompose.js

@@ -0,0 +1,177 @@
+import { findConstructMarkerImbalance } from "./content.js";
+//#region src/decompose.ts
+function isHeadingParagraph(paragraph) {
+	return paragraph.headingLevel !== void 0;
+}
+function isListParagraph(paragraph) {
+	return paragraph.list !== void 0;
+}
+var ConstructMarkerImbalanceError = class extends Error {
+	imbalance;
+	constructor(imbalance) {
+		super(imbalance.kind === "unmatchedEnd" ? `decompose: the constructEnd marker at index ${imbalance.index} of this container's block flow closes no open construct` : `decompose: the constructStart marker at index ${imbalance.index} of this container's block flow is never closed`);
+		this.name = "ConstructMarkerImbalanceError";
+		this.imbalance = imbalance;
+	}
+};
+function decompose(content) {
+	switch (content.kind) {
+		case "wordprocessing": return content.sections.map(decomposeSection);
+		case "presentation": return content.slides.map(decomposeSlide);
+		case "spreadsheet": return content.sheets.map(decomposeSheet);
+		case "drawing": return content.pages.map(decomposeDrawPage);
+		case "formula": return [content.formula];
+	}
+}
+function decomposeSection(section) {
+	const { blocks, ...rest } = section;
+	return {
+		node: {
+			kind: "section",
+			...rest
+		},
+		children: decomposeSectionBlocks(blocks)
+	};
+}
+function assertBalancedConstructMarkers(blocks) {
+	const imbalance = findConstructMarkerImbalance(blocks);
+	if (imbalance !== void 0) throw new ConstructMarkerImbalanceError(imbalance);
+}
+function decomposeSectionBlocks(blocks) {
+	assertBalancedConstructMarkers(blocks);
+	return walkSectionBlocks(blocks.values());
+}
+function walkSectionBlocks(cursor) {
+	const root = [];
+	const headingStack = [];
+	const listStack = [];
+	const headingScope = () => headingStack.at(-1)?.children ?? root;
+	for (let step = cursor.next(); step.done !== true; step = cursor.next()) {
+		const block = step.value;
+		if (block.kind === "constructEnd") return root;
+		if (block.kind === "constructStart") {
+			openConstructGroup(block.descriptor, cursor, listStack, headingScope());
+			continue;
+		}
+		if (block.kind !== "paragraph") {
+			const parent = listStack.at(-1);
+			(parent !== void 0 ? parent.children : headingScope()).push(block);
+			continue;
+		}
+		if (isHeadingParagraph(block)) {
+			listStack.length = 0;
+			const level = block.headingLevel;
+			for (let top = headingStack.at(-1); top !== void 0 && top.node.headingLevel >= level; top = headingStack.at(-1)) headingStack.pop();
+			const group = {
+				node: block,
+				children: []
+			};
+			const parent = headingStack.at(-1);
+			(parent !== void 0 ? parent.children : root).push(group);
+			headingStack.push(group);
+		} else if (isListParagraph(block)) openListGroup(listStack, headingScope(), block);
+		else {
+			listStack.length = 0;
+			headingScope().push(block);
+		}
+	}
+	return root;
+}
+function decomposeSlide(slide) {
+	const { shapes, ...rest } = slide;
+	return {
+		node: {
+			kind: "slide",
+			...rest
+		},
+		children: shapes.map(decomposeShape)
+	};
+}
+function decomposeSheet(sheet) {
+	const { images, embeddedObjects, ...rest } = sheet;
+	const children = [...images, ...embeddedObjects ?? []];
+	return {
+		node: {
+			kind: "sheet",
+			...rest
+		},
+		children
+	};
+}
+function decomposeDrawPage(page) {
+	const { shapes, vectors, ...rest } = page;
+	const children = [...shapes.map(decomposeShape), ...vectors];
+	return {
+		node: {
+			kind: "drawPage",
+			...rest
+		},
+		children
+	};
+}
+function decomposeShape(shape) {
+	const { blocks, ...rest } = shape;
+	return {
+		node: rest,
+		children: decomposeShapeBlocks(blocks)
+	};
+}
+function decomposeShapeBlocks(blocks) {
+	assertBalancedConstructMarkers(blocks);
+	return walkShapeBlocks(blocks.values());
+}
+function walkShapeBlocks(cursor) {
+	const root = [];
+	const listStack = [];
+	for (let step = cursor.next(); step.done !== true; step = cursor.next()) {
+		const block = step.value;
+		if (block.kind === "constructEnd") return root;
+		if (block.kind === "constructStart") {
+			const parent = listStack.at(-1);
+			(parent !== void 0 ? parent.children : root).push({
+				node: block.descriptor,
+				children: walkShapeBlocks(cursor)
+			});
+			continue;
+		}
+		if (block.kind !== "paragraph") {
+			const parent = listStack.at(-1);
+			(parent !== void 0 ? parent.children : root).push(block);
+			continue;
+		}
+		if (isListParagraph(block)) {
+			openListGroup(listStack, root, block);
+			continue;
+		}
+		listStack.length = 0;
+		root.push(block);
+	}
+	return root;
+}
+function openConstructGroup(descriptor, cursor, listStack, headingScope) {
+	const parent = listStack.at(-1);
+	if (parent === void 0) {
+		headingScope.push({
+			node: descriptor,
+			children: walkSectionBlocks(cursor)
+		});
+		return;
+	}
+	parent.children.push({
+		node: descriptor,
+		children: walkShapeBlocks(cursor)
+	});
+}
+function openListGroup(listStack, scopeChildren, paragraph) {
+	const level = paragraph.list.level;
+	for (let top = listStack.at(-1); top !== void 0 && top.node.list.level >= level; top = listStack.at(-1)) listStack.pop();
+	const group = {
+		node: paragraph,
+		children: []
+	};
+	const parent = listStack.at(-1);
+	(parent !== void 0 ? parent.children : scopeChildren).push(group);
+	listStack.push(group);
+}
+//#endregion
+export { ConstructMarkerImbalanceError, decompose, decomposeDrawPage, decomposeSection, decomposeShape, decomposeSheet, decomposeSlide, isHeadingParagraph, isListParagraph };

package/dist/definitions.d.cts

@@ -1,4 +1,4 @@
-import { L as ContentRun, j as ContentParagraph } from "./content-BmqzegMG.cjs";
+import { L as ContentRun, j as ContentParagraph } from "./content-CFXL4jMV.cjs";
 import { z } from "zod";
 //#region src/definitions.d.ts
 declare const StyleParagraphPropertiesSchema: z.ZodObject<{

package/dist/definitions.d.ts

@@ -1,4 +1,4 @@
-import { L as ContentRun, j as ContentParagraph } from "./content-CIwPb_yh.js";
+import { L as ContentRun, j as ContentParagraph } from "./content-32bPQ3aj.js";
 import { z } from "zod";
 //#region src/definitions.d.ts
 declare const StyleParagraphPropertiesSchema: z.ZodObject<{

package/dist/factor-styles.cjs

@@ -0,0 +1,435 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_canonicalise = require("./canonicalise.cjs");
+const require_decompose = require("./decompose.cjs");
+const require_flatten = require("./flatten.cjs");
+//#region src/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 isConstructGroup(child) {
+	return "node" in child && "children" in child && child.node.kind !== "paragraph";
+}
+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(require_decompose.decomposeSection)
+		});
+		case "presentation": return mint({
+			kind: "presentation",
+			...envelope,
+			children: content.slides.map(require_decompose.decomposeSlide)
+		});
+		case "spreadsheet": return mint({
+			kind: "spreadsheet",
+			...envelope,
+			children: content.sheets.map(require_decompose.decomposeSheet)
+		});
+		case "drawing": return mint({
+			kind: "drawing",
+			...envelope,
+			children: content.pages.map(require_decompose.decomposeDrawPage)
+		});
+		case "formula": return mint({
+			kind: "formula",
+			...envelope,
+			children: [content.formula]
+		});
+	}
+}
+function factorStyles(pkg) {
+	const reassembled = assemblePackage(require_flatten.flattenPackage(pkg), pkg.pages);
+	if (pkg.definitions === void 0) return reassembled;
+	return {
+		...reassembled,
+		definitions: pkg.definitions
+	};
+}
+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 = require_canonicalise.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 = require_canonicalise.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, branch, state, entries) {
+	const extent = extentOf(wrapper);
+	const paragraphCandidate = extent.length > 0 ? bestParagraphCandidate(extent, commonParagraphKeys(extent, branch.frozenParagraphs), branch.factoredParagraphs) : void 0;
+	const runCandidate = extent.length > 0 ? bestRunCandidate(extent, commonRunKeys(extent, branch.frozenRuns), branch.factoredRuns) : void 0;
+	const nextFrozenParagraphs = new Set(branch.frozenParagraphs);
+	const nextFrozenRuns = new Set(branch.frozenRuns);
+	const nextFactoredParagraphs = new Set(branch.factoredParagraphs);
+	const nextFactoredRuns = new Set(branch.factoredRuns);
+	if (paragraphCandidate !== void 0 || runCandidate !== void 0) {
+		const content = {
+			...paragraphCandidate !== void 0 ? { paragraph: paragraphCandidate.tuple } : {},
+			...runCandidate !== void 0 ? { run: runCandidate.tuple } : {}
+		};
+		const contentKey = require_canonicalise.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);
+		}
+		const strips = {
+			paragraphs: /* @__PURE__ */ new Map(),
+			runs: /* @__PURE__ */ new Map()
+		};
+		if (paragraphCandidate !== void 0) {
+			for (const paragraph of paragraphCandidate.positions) {
+				nextFactoredParagraphs.add(paragraph);
+				strips.paragraphs.set(paragraph, paragraphCandidate.keys);
+			}
+			for (const key of paragraphCandidate.keys) nextFrozenParagraphs.add(key);
+		}
+		if (runCandidate !== void 0) {
+			for (const run of runCandidate.positions) {
+				nextFactoredRuns.add(run);
+				strips.runs.set(run, runCandidate.keys);
+			}
+			for (const key of runCandidate.keys) nextFrozenRuns.add(key);
+		}
+		state.wrapperStrips.set(wrapper, strips);
+	}
+	visit.index += 1;
+	const next = {
+		frozenParagraphs: nextFrozenParagraphs,
+		frozenRuns: nextFrozenRuns,
+		factoredParagraphs: nextFactoredParagraphs,
+		factoredRuns: nextFactoredRuns
+	};
+	for (const child of childWrappers(wrapper)) plan(child, visit, next, 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 = {
+		wrapperRefs: /* @__PURE__ */ new Map(),
+		wrapperStrips: /* @__PURE__ */ new Map()
+	};
+	const entries = /* @__PURE__ */ new Map();
+	const visit = { index: 0 };
+	const rootBranch = {
+		frozenParagraphs: /* @__PURE__ */ new Set(),
+		frozenRuns: /* @__PURE__ */ new Set(),
+		factoredParagraphs: /* @__PURE__ */ new Set(),
+		factoredRuns: /* @__PURE__ */ new Set()
+	};
+	switch (pkg.kind) {
+		case "wordprocessing":
+			for (const root of pkg.children) plan(root, visit, rootBranch, state, entries);
+			break;
+		case "presentation":
+			for (const root of pkg.children) plan(root, visit, rootBranch, state, entries);
+			break;
+		case "drawing": for (const root of pkg.children) plan(root, visit, rootBranch, state, entries);
+	}
+	if (entries.size === 0) return pkg;
+	const ordered = [...entries.values()].sort((a, b) => b.frequency - a.frequency || a.firstVisit - b.firstVisit);
+	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 innerChain(group, chain, state) {
+	const own = state.wrapperStrips.get(group);
+	return own === void 0 ? chain : [...chain, own];
+}
+function paragraphStripsOf(chain, paragraph) {
+	let result;
+	for (const strips of chain) {
+		const found = strips.paragraphs.get(paragraph);
+		if (found !== void 0) result = found;
+	}
+	return result;
+}
+function runStripsOf(chain, run) {
+	let result;
+	for (const strips of chain) {
+		const found = strips.runs.get(run);
+		if (found !== void 0) result = found;
+	}
+	return result;
+}
+function rebuildSlideGroup(group, chain, state) {
+	const inner = innerChain(group, chain, state);
+	const children = group.children.map((shape) => rebuildShapeGroup(shape, inner, 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, chain, state) {
+	const inner = innerChain(group, chain, state);
+	const children = group.children.map((child) => "node" in child ? rebuildShapeGroup(child, inner, 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, chain, state) {
+	const inner = innerChain(group, chain, state);
+	const children = group.children.map((child) => rebuildSectionChild(child, inner, 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, chain, state) {
+	if (isConstructGroup(child)) return rebuildSectionConstructGroup(child, chain, state);
+	if ("node" in child && "children" in child) return isHeadingGroup(child) ? rebuildHeadingGroup(child, chain, state, rebuildSectionChild) : rebuildListGroup(child, chain, state, rebuildListChild);
+	if (child.kind === "paragraph") return rebuildParagraph(child, chain);
+	return child;
+}
+function rebuildListChild(child, chain, state) {
+	if (isConstructGroup(child)) return rebuildShapeConstructGroup(child, chain, state);
+	if ("node" in child && "children" in child) return rebuildListGroup(child, chain, state, rebuildListChild);
+	if (child.kind === "paragraph") return rebuildParagraph(child, chain);
+	return child;
+}
+function rebuildShapeGroup(group, chain, state) {
+	const inner = innerChain(group, chain, state);
+	const children = group.children.map((child) => rebuildListChild(child, inner, 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 rebuildSectionConstructGroup(group, chain, state) {
+	const inner = innerChain(group, chain, state);
+	const children = group.children.map((child) => rebuildSectionChild(child, inner, 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 rebuildShapeConstructGroup(group, chain, state) {
+	const inner = innerChain(group, chain, state);
+	const children = group.children.map((child) => rebuildListChild(child, inner, 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, chain, state, rebuildChild) {
+	const inner = innerChain(group, chain, state);
+	const anchor = rebuildParagraph(group.node, inner);
+	assertHeadingAnchor(anchor);
+	const children = group.children.map((child) => rebuildChild(child, inner, 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, chain, state, rebuildChild) {
+	const inner = innerChain(group, chain, state);
+	const anchor = rebuildParagraph(group.node, inner);
+	assertListAnchor(anchor);
+	const children = group.children.map((child) => rebuildChild(child, inner, 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, chain) {
+	const strips = paragraphStripsOf(chain, paragraph);
+	const base = strips === void 0 ? paragraph : stripParagraphKeys(paragraph, strips);
+	let changed = base !== paragraph;
+	const runs = [];
+	for (const run of base.runs) {
+		const runStrips = runStripsOf(chain, 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
+exports.assemblePackage = assemblePackage;
+exports.factorStyles = factorStyles;
+exports.mint = mint;

package/dist/factor-styles.d.cts

@@ -0,0 +1,9 @@
+import { l as PageSize } from "./geometry-CvcjSwnA.cjs";
+import { m as ContentDocument } from "./content-CFXL4jMV.cjs";
+import { DocumentPackage } from "./package.cjs";
+//#region src/factor-styles.d.ts
+declare function assemblePackage(content: ContentDocument, pages?: readonly PageSize[]): DocumentPackage;
+declare function factorStyles(pkg: DocumentPackage): DocumentPackage;
+declare function mint(pkg: DocumentPackage): DocumentPackage;
+//#endregion
+export { assemblePackage, factorStyles, mint };

package/dist/factor-styles.d.ts

@@ -0,0 +1,9 @@
+import { l as PageSize } from "./geometry-CvcjSwnA.js";
+import { m as ContentDocument } from "./content-32bPQ3aj.js";
+import { DocumentPackage } from "./package.js";
+//#region src/factor-styles.d.ts
+declare function assemblePackage(content: ContentDocument, pages?: readonly PageSize[]): DocumentPackage;
+declare function factorStyles(pkg: DocumentPackage): DocumentPackage;
+declare function mint(pkg: DocumentPackage): DocumentPackage;
+//#endregion
+export { assemblePackage, factorStyles, mint };