@pollium/vyva-convert 0.0.0-stage → 0.1.0

package/dist/export/docx.js

@@ -0,0 +1,382 @@
+import { fitWithin } from "./image-size.js";
+import { blocksOfHtml } from "./html-blocks.js";
+import { CODE_FONT } from "@pollium/vyva-core/code";
+import { AlignmentType, BorderStyle, Document, ExternalHyperlink, Footer, Header, HeadingLevel, ImageRun, LevelFormat, Packer, PageBreak, PageNumber, Paragraph, ShadingType, Table, TableCell, TableRow, TextRun, WidthType } from "docx";
+//#region src/export/docx.ts
+const DOCX_MIME = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+const TWIPS_PER_MM = 56.7;
+const A4_WIDTH_MM = 210;
+const PX_PER_MM = 3.78;
+const CODE_FILL = "F3F4F6";
+const MUTED = "6B7280";
+const LINE = "D5D9E0";
+const DOCX_IMAGE_TYPES = {
+	png: "png",
+	jpg: "jpg",
+	gif: "gif"
+};
+const hex = (color) => color.replace("#", "").toUpperCase();
+const lighten = (color, amount) => {
+	const value = hex(color);
+	const channel = (offset) => Math.round(parseInt(value.slice(offset, offset + 2), 16) * amount + 255 * (1 - amount)).toString(16).padStart(2, "0");
+	return `${channel(0)}${channel(2)}${channel(4)}`.toUpperCase();
+};
+const ALIGNMENTS = {
+	left: AlignmentType.LEFT,
+	center: AlignmentType.CENTER,
+	right: AlignmentType.RIGHT,
+	justify: AlignmentType.JUSTIFIED
+};
+const HEADINGS = [
+	HeadingLevel.HEADING_1,
+	HeadingLevel.HEADING_2,
+	HeadingLevel.HEADING_3,
+	HeadingLevel.HEADING_4
+];
+const levels = (bullet) => [
+	0,
+	1,
+	2
+].map((level) => ({
+	level,
+	format: bullet ? LevelFormat.BULLET : [
+		LevelFormat.DECIMAL,
+		LevelFormat.LOWER_LETTER,
+		LevelFormat.LOWER_ROMAN
+	][level],
+	text: bullet ? [
+		"•",
+		"◦",
+		"▪"
+	][level] : `%${level + 1}.`,
+	alignment: AlignmentType.LEFT,
+	style: { paragraph: { indent: {
+		left: 360 * (level + 1),
+		hanging: 260
+	} } }
+}));
+var DocxComposer = class {
+	#bundle;
+	#content;
+	#listInstance = 0;
+	constructor(bundle, content) {
+		this.#bundle = bundle;
+		this.#content = content;
+	}
+	get accent() {
+		return hex(this.#content.design.accentColor);
+	}
+	get maxImageWidth() {
+		const { margins } = this.#content.design;
+		return Math.round((A4_WIDTH_MM - margins.left - margins.right) * PX_PER_MM);
+	}
+	runs(runs, extra = {}) {
+		return runs.map((run) => {
+			if (run.isBreak === true) return new TextRun({
+				text: "",
+				break: 1
+			});
+			const text = new TextRun({
+				text: run.text,
+				bold: run.bold || extra.bold,
+				italics: run.italic,
+				strike: run.strike,
+				...run.underline || run.link !== null ? { underline: {} } : {},
+				...run.color !== null ? { color: hex(run.color) } : run.link !== null ? { color: this.accent } : extra.color === void 0 ? {} : { color: extra.color },
+				...run.code ? { font: CODE_FONT } : {},
+				...run.sizePx !== null ? { size: Math.round(run.sizePx * .75 * 2) } : extra.size === void 0 ? {} : { size: extra.size },
+				...run.highlight !== null ? { shading: {
+					type: ShadingType.CLEAR,
+					fill: hex(run.highlight),
+					color: "auto"
+				} } : run.code ? { shading: {
+					type: ShadingType.CLEAR,
+					fill: CODE_FILL,
+					color: "auto"
+				} } : {}
+			});
+			return run.link === null || !/^(https?:|mailto:)/i.test(run.link) ? text : new ExternalHyperlink({
+				link: run.link,
+				children: [text]
+			});
+		});
+	}
+	image(image, block) {
+		const type = image === void 0 ? void 0 : DOCX_IMAGE_TYPES[image.extension];
+		if (image === void 0 || type === void 0) return null;
+		const maxWidth = block.widthPx !== null ? Math.min(this.maxImageWidth, Math.round(block.widthPx)) : block.widthPercent === null ? this.maxImageWidth : Math.round(this.maxImageWidth * Math.min(100, block.widthPercent) / 100);
+		const size = fitWithin(image.size, maxWidth, 900);
+		const alt = block.alt;
+		return new Paragraph({
+			alignment: block.align === "left" ? AlignmentType.LEFT : block.align === "right" ? AlignmentType.RIGHT : AlignmentType.CENTER,
+			spacing: {
+				before: 120,
+				after: 120
+			},
+			children: [new ImageRun({
+				type,
+				data: image.data,
+				transformation: size,
+				altText: {
+					name: alt || "Image",
+					description: alt,
+					title: alt
+				}
+			})]
+		});
+	}
+	block(block) {
+		if (block.kind === "heading") return [new Paragraph({
+			heading: HEADINGS[block.level - 1],
+			...block.align === null ? {} : { alignment: ALIGNMENTS[block.align] },
+			children: this.runs(block.runs)
+		})];
+		if (block.kind === "paragraph") return [new Paragraph({
+			spacing: { after: 120 },
+			...block.align === null ? {} : { alignment: ALIGNMENTS[block.align] },
+			...block.quote ? {
+				indent: { left: 360 },
+				border: { left: {
+					style: BorderStyle.SINGLE,
+					size: 18,
+					color: this.accent,
+					space: 8
+				} }
+			} : {},
+			children: this.runs(block.runs, block.quote ? { color: MUTED } : {})
+		})];
+		if (block.kind === "list") {
+			this.#listInstance += 1;
+			const instance = this.#listInstance;
+			return block.items.map((item) => item.checked === null ? new Paragraph({
+				numbering: {
+					reference: block.ordered ? "numbers" : "bullets",
+					level: Math.min(item.level, 2),
+					instance
+				},
+				children: this.runs(item.runs)
+			}) : new Paragraph({
+				indent: { left: 360 * (item.level + 1) },
+				children: [new TextRun({
+					text: item.checked ? "☑ " : "☐ ",
+					color: this.accent
+				}), ...this.runs(item.runs)]
+			}));
+		}
+		if (block.kind === "table") {
+			const columns = Math.max(1, ...block.rows.map((row) => row.length));
+			return [new Table({
+				width: {
+					size: 100,
+					type: WidthType.PERCENTAGE
+				},
+				rows: block.rows.map((row) => new TableRow({
+					...row.every((cell) => cell.header) ? { tableHeader: true } : {},
+					children: Array.from({ length: columns }, (_, index) => {
+						const cell = row[index] ?? {
+							runs: [],
+							header: false
+						};
+						return new TableCell({
+							children: [new Paragraph({ children: this.runs(cell.runs, cell.header ? { bold: true } : {}) })],
+							...cell.header ? { shading: {
+								type: ShadingType.CLEAR,
+								fill: lighten(this.#content.design.accentColor, .12),
+								color: "auto"
+							} } : {},
+							margins: {
+								top: 60,
+								bottom: 60,
+								left: 100,
+								right: 100
+							}
+						});
+					})
+				}))
+			}), new Paragraph({ children: [] })];
+		}
+		if (block.kind === "code") return block.text.split("\n").map((line, index, lines) => new Paragraph({
+			shading: {
+				type: ShadingType.CLEAR,
+				fill: CODE_FILL,
+				color: "auto"
+			},
+			spacing: {
+				before: index === 0 ? 120 : 0,
+				after: index === lines.length - 1 ? 160 : 0
+			},
+			children: [new TextRun({
+				text: line === "" ? " " : line,
+				font: CODE_FONT,
+				size: 18
+			})]
+		}));
+		if (block.kind === "image") {
+			const paragraph = this.image(this.#bundle.images.get(block.fileId), block);
+			return paragraph === null ? [] : [paragraph];
+		}
+		if (block.kind === "rule") return [new Paragraph({
+			border: { bottom: {
+				style: BorderStyle.SINGLE,
+				size: 6,
+				color: LINE,
+				space: 4
+			} },
+			children: []
+		})];
+		return [new Paragraph({ children: [new PageBreak()] })];
+	}
+	body() {
+		return this.#content.blocks.flatMap((block) => blocksOfHtml(block.html)).flatMap((block) => this.block(block));
+	}
+	header() {
+		const { design } = this.#content;
+		const logo = design.headerLogoFileId === null ? void 0 : this.#bundle.images.get(design.headerLogoFileId);
+		const type = logo === void 0 ? void 0 : DOCX_IMAGE_TYPES[logo.extension];
+		const children = [];
+		if (logo !== void 0 && type !== void 0) children.push(new ImageRun({
+			type,
+			data: logo.data,
+			transformation: fitWithin(logo.size, 160, 40),
+			altText: {
+				name: "Logo",
+				description: "Logo",
+				title: "Logo"
+			}
+		}));
+		if (design.headerText.trim() !== "") children.push(new TextRun({
+			text: `${children.length > 0 ? "   " : ""}${design.headerText}`,
+			color: MUTED,
+			size: 16
+		}));
+		return new Header({ children: children.length === 0 ? [] : [new Paragraph({
+			border: { bottom: {
+				style: BorderStyle.SINGLE,
+				size: 4,
+				color: LINE,
+				space: 4
+			} },
+			children
+		})] });
+	}
+	footer() {
+		const { design } = this.#content;
+		const children = [];
+		if (design.footerText.trim() !== "") children.push(new TextRun({
+			text: design.showPageNumbers ? `${design.footerText}  ·  ` : design.footerText,
+			color: MUTED,
+			size: 16
+		}));
+		if (design.showPageNumbers) children.push(new TextRun({
+			children: [
+				PageNumber.CURRENT,
+				" / ",
+				PageNumber.TOTAL_PAGES
+			],
+			color: MUTED,
+			size: 16
+		}));
+		return new Footer({ children: children.length === 0 ? [] : [new Paragraph({
+			alignment: AlignmentType.RIGHT,
+			children
+		})] });
+	}
+};
+const buildDocx = async (content, bundle) => {
+	const composer = new DocxComposer(bundle, content);
+	const { design } = content;
+	const size = Math.round(design.baseSize * 2);
+	const ink = hex(design.textColor);
+	const accent = composer.accent;
+	const margin = (mm) => Math.round(mm * TWIPS_PER_MM);
+	const document = new Document({
+		title: bundle.title,
+		styles: { default: {
+			document: {
+				run: {
+					font: design.font,
+					size,
+					color: ink
+				},
+				paragraph: { spacing: { line: 300 } }
+			},
+			heading1: {
+				run: {
+					font: design.font,
+					size: size * 2,
+					bold: true,
+					color: accent
+				},
+				paragraph: { spacing: {
+					before: 240,
+					after: 120
+				} }
+			},
+			heading2: {
+				run: {
+					font: design.font,
+					size: Math.round(size * 1.5),
+					bold: true,
+					color: accent
+				},
+				paragraph: { spacing: {
+					before: 280,
+					after: 100
+				} }
+			},
+			heading3: {
+				run: {
+					font: design.font,
+					size: Math.round(size * 1.2),
+					bold: true,
+					color: accent
+				},
+				paragraph: { spacing: {
+					before: 220,
+					after: 80
+				} }
+			},
+			heading4: {
+				run: {
+					font: design.font,
+					size: Math.round(size * 1.05),
+					bold: true,
+					color: accent
+				},
+				paragraph: { spacing: {
+					before: 200,
+					after: 60
+				} }
+			},
+			hyperlink: { run: {
+				color: accent,
+				underline: {}
+			} }
+		} },
+		numbering: { config: [{
+			reference: "bullets",
+			levels: levels(true)
+		}, {
+			reference: "numbers",
+			levels: levels(false)
+		}] },
+		sections: [{
+			properties: { page: { margin: {
+				top: margin(design.margins.top),
+				bottom: margin(design.margins.bottom),
+				left: margin(design.margins.left),
+				right: margin(design.margins.right)
+			} } },
+			headers: { default: composer.header() },
+			footers: { default: composer.footer() },
+			children: composer.body()
+		}]
+	});
+	return {
+		data: await Packer.toBuffer(document),
+		contentType: DOCX_MIME,
+		extension: "docx"
+	};
+};
+//#endregion
+export { buildDocx };

package/dist/export/fonts.d.ts

@@ -0,0 +1,16 @@
+import { FontFamily } from "@pollium/vyva-core/content";
+//#region src/export/fonts.d.ts
+declare const SUBSETS: readonly ["latin", "latin-ext"];
+declare const STYLES: readonly ["normal", "italic"];
+type Subset = typeof SUBSETS[number];
+type Style = typeof STYLES[number];
+export interface FontFile {
+  family: FontFamily;
+  name: string;
+  style: Style;
+  subset: Subset;
+  data: Buffer;
+}
+export declare const fontFilesOf: (families: Iterable<FontFamily>) => Promise<FontFile[]>;
+export declare const fontFaces: (files: FontFile[], urlOf: (file: FontFile) => string) => string;
+//#endregion

package/dist/export/fonts.js

@@ -0,0 +1,37 @@
+import { createRequire } from "node:module";
+import { readFile } from "node:fs/promises";
+//#region src/export/fonts.ts
+const PACKAGES = {
+	Inter: "inter",
+	Roboto: "roboto",
+	"Open Sans": "open-sans",
+	Montserrat: "montserrat",
+	Lora: "lora",
+	Merriweather: "merriweather",
+	"Playfair Display": "playfair-display",
+	"JetBrains Mono": "jetbrains-mono"
+};
+const SUBSETS = ["latin", "latin-ext"];
+const STYLES = ["normal", "italic"];
+const RANGES = {
+	latin: "U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD",
+	"latin-ext": "U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF"
+};
+const require = createRequire(import.meta.url);
+const filesOf = (family) => {
+	const slug = PACKAGES[family];
+	return Promise.all(SUBSETS.flatMap((subset) => STYLES.map(async (style) => {
+		const name = `${slug}-${subset}-wght-${style}.woff2`;
+		return {
+			family,
+			name,
+			style,
+			subset,
+			data: await readFile(require.resolve(`@fontsource-variable/${slug}/files/${name}`))
+		};
+	})));
+};
+const fontFilesOf = async (families) => (await Promise.all([...new Set(families)].map(filesOf))).flat();
+const fontFaces = (files, urlOf) => files.map((file) => `@font-face{font-family:'${file.family}';font-style:${file.style};font-weight:100 900;font-display:block;src:url('${urlOf(file)}') format('woff2');unicode-range:${RANGES[file.subset]}}`).join("\n");
+//#endregion
+export { fontFaces, fontFilesOf };

package/dist/export/html-blocks.d.ts

@@ -0,0 +1,58 @@
+//#region src/export/html-blocks.d.ts
+export interface Run {
+  text: string;
+  bold: boolean;
+  italic: boolean;
+  underline: boolean;
+  strike: boolean;
+  code: boolean;
+  color: string | null;
+  highlight: string | null;
+  sizePx: number | null;
+  link: string | null;
+  isBreak?: boolean;
+}
+export type Align = 'left' | 'center' | 'right' | 'justify';
+export type Block = {
+  kind: 'paragraph';
+  runs: Run[];
+  align: Align | null;
+  quote: boolean;
+} | {
+  kind: 'heading';
+  level: 1 | 2 | 3 | 4;
+  runs: Run[];
+  align: Align | null;
+} | {
+  kind: 'list';
+  ordered: boolean;
+  items: Array<{
+    runs: Run[];
+    checked: boolean | null;
+    level: number;
+  }>;
+} | {
+  kind: 'table';
+  rows: Array<Array<{
+    runs: Run[];
+    header: boolean;
+  }>>;
+} | {
+  kind: 'code';
+  language: string | null;
+  text: string;
+} | {
+  kind: 'image';
+  fileId: string;
+  alt: string;
+  widthPercent: number | null;
+  widthPx: number | null;
+  align: 'left' | 'center' | 'right';
+} | {
+  kind: 'rule';
+} | {
+  kind: 'pageBreak';
+};
+export declare const blocksOfHtml: (html: string) => Block[];
+export declare const plainOfRuns: (runs: Run[]) => string;
+//#endregion

package/dist/export/html-blocks.js

@@ -0,0 +1,170 @@
+import { DomUtils, parseDocument } from "htmlparser2";
+//#region src/export/html-blocks.ts
+const BASE = {
+	text: "",
+	bold: false,
+	italic: false,
+	underline: false,
+	strike: false,
+	code: false,
+	color: null,
+	highlight: null,
+	sizePx: null,
+	link: null
+};
+const HEADING_LEVELS = /* @__PURE__ */ new Map([
+	["h1", 1],
+	["h2", 2],
+	["h3", 3],
+	["h4", 4]
+]);
+const isElement = (node) => DomUtils.isTag(node);
+const styleOf = (element) => Object.fromEntries((element.attribs.style ?? "").split(";").map((part) => part.split(":").map((value) => value.trim())).filter((pair) => pair.length >= 2 && pair[0] !== "").map(([key, ...value]) => [key.toLowerCase(), value.join(":")]));
+const COLOR = /^#[0-9a-f]{6}$/i;
+const toHex = (value) => {
+	if (value === void 0) return null;
+	if (COLOR.test(value)) return value.toLowerCase();
+	if (/^#[0-9a-f]{3}$/i.test(value)) return `#${value.slice(1).split("").map((char) => char + char).join("")}`.toLowerCase();
+	const match = /^rgba?\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})/i.exec(value);
+	return match === null ? null : `#${match.slice(1, 4).map((part) => Math.min(255, Number(part)).toString(16).padStart(2, "0")).join("")}`;
+};
+const sizeToPx = (value) => {
+	if (value === void 0) return null;
+	const match = /^(\d+(?:\.\d+)?)(px|pt|em|rem)$/.exec(value);
+	if (match === null) return null;
+	const amount = Number(match[1]);
+	return match[2] === "pt" ? amount * 96 / 72 : match[2] === "px" ? amount : amount * 16;
+};
+const alignOf = (element) => {
+	const align = styleOf(element)["text-align"];
+	return align === "left" || align === "center" || align === "right" || align === "justify" ? align : null;
+};
+const runsOf = (nodes, inherited = BASE) => nodes.flatMap((node) => {
+	if (node.type === "text") return node.data === "" ? [] : [{
+		...inherited,
+		text: node.data.replace(/\s+/g, " ")
+	}];
+	if (!isElement(node)) return [];
+	const style = styleOf(node);
+	const next = {
+		...inherited,
+		bold: inherited.bold || node.name === "strong" || node.name === "b" || style["font-weight"] === "700" || style["font-weight"] === "bold",
+		italic: inherited.italic || node.name === "em" || node.name === "i",
+		underline: inherited.underline || node.name === "u",
+		strike: inherited.strike || node.name === "s",
+		code: inherited.code || node.name === "code",
+		color: toHex(style.color) ?? inherited.color,
+		highlight: node.name === "mark" ? toHex(style["background-color"]) ?? "#fff3a3" : toHex(style["background-color"]) ?? inherited.highlight,
+		sizePx: sizeToPx(style["font-size"]) ?? inherited.sizePx,
+		link: node.name === "a" && typeof node.attribs.href === "string" ? node.attribs.href : inherited.link
+	};
+	if (node.name === "br") return [{
+		...inherited,
+		text: "",
+		isBreak: true
+	}];
+	if (node.name === "img" || node.name === "input" || node.name === "label") return [];
+	return runsOf(node.children, next);
+});
+const textOf = (nodes) => nodes.map((node) => node.type === "text" ? node.data : isElement(node) ? textOf(node.children) : "").join("");
+const trimRuns = (runs) => {
+	const copy = runs.map((run) => ({ ...run }));
+	if (copy.length > 0) copy[0].text = copy[0].text.replace(/^\s+/, "");
+	if (copy.length > 0) copy[copy.length - 1].text = copy[copy.length - 1].text.replace(/\s+$/, "");
+	return copy.filter((run) => run.text !== "" || run.isBreak === true);
+};
+const imageOf = (element) => {
+	const fileId = element.attribs["data-file-id"];
+	if (fileId === void 0) return null;
+	const width = styleOf(element).width ?? "";
+	const percent = /^(\d+(?:\.\d+)?)%$/.exec(width);
+	const pixels = /^(\d+(?:\.\d+)?)px$/.exec(width);
+	const align = element.attribs["data-align"];
+	return {
+		kind: "image",
+		fileId,
+		alt: element.attribs.alt ?? "",
+		widthPercent: percent === null ? null : Number(percent[1]),
+		widthPx: pixels === null ? null : Number(pixels[1]),
+		align: align === "left" || align === "right" ? align : "center"
+	};
+};
+const listItems = (list, level) => list.children.filter(isElement).filter((child) => child.name === "li").flatMap((item) => {
+	const nested = item.children.filter(isElement).filter((child) => child.name === "ul" || child.name === "ol");
+	const own = item.children.filter((child) => !(isElement(child) && (child.name === "ul" || child.name === "ol")));
+	const checked = item.attribs["data-type"] === "taskItem" ? item.attribs["data-checked"] === "true" : null;
+	return [{
+		runs: trimRuns(runsOf(own)),
+		checked,
+		level
+	}, ...nested.flatMap((child) => listItems(child, level + 1))];
+});
+const tableRows = (table) => {
+	const rows = [];
+	const visit = (node) => {
+		for (const child of node.children.filter(isElement)) if (child.name === "tr") rows.push(child.children.filter(isElement).filter((cell) => cell.name === "td" || cell.name === "th").map((cell) => ({
+			runs: trimRuns(runsOf(cell.children)),
+			header: cell.name === "th"
+		})));
+		else if ([
+			"thead",
+			"tbody",
+			"tfoot"
+		].includes(child.name)) visit(child);
+	};
+	visit(table);
+	return rows;
+};
+const blockOf = (element) => {
+	const { name } = element;
+	const level = HEADING_LEVELS.get(name);
+	if (level !== void 0) return [{
+		kind: "heading",
+		level,
+		runs: trimRuns(runsOf(element.children)),
+		align: alignOf(element)
+	}];
+	if (name === "p") {
+		const images = element.children.filter(isElement).filter((child) => child.name === "img").flatMap((child) => imageOf(child) ?? []);
+		const runs = trimRuns(runsOf(element.children));
+		return [...runs.length === 0 && images.length > 0 ? [] : [{
+			kind: "paragraph",
+			runs,
+			align: alignOf(element),
+			quote: false
+		}], ...images];
+	}
+	if (name === "blockquote") return element.children.filter(isElement).flatMap(blockOf).map((block) => block.kind === "paragraph" ? {
+		...block,
+		quote: true
+	} : block);
+	if (name === "ul" || name === "ol") return [{
+		kind: "list",
+		ordered: name === "ol",
+		items: listItems(element, 0)
+	}];
+	if (name === "table") return [{
+		kind: "table",
+		rows: tableRows(element)
+	}];
+	if (name === "pre") {
+		const code = element.children.filter(isElement).find((child) => child.name === "code");
+		return [{
+			kind: "code",
+			language: /language-([a-z0-9+#-]+)/.exec(code?.attribs.class ?? element.attribs.class ?? "")?.[1] ?? null,
+			text: textOf(element.children).replace(/\n$/, "")
+		}];
+	}
+	if (name === "img") {
+		const image = imageOf(element);
+		return image === null ? [] : [image];
+	}
+	if (name === "hr") return [{ kind: "rule" }];
+	if (name === "div" && element.attribs["data-type"] === "page-break") return [{ kind: "pageBreak" }];
+	if (name === "div") return element.children.filter(isElement).flatMap(blockOf);
+	return [];
+};
+const blocksOfHtml = (html) => parseDocument(html).children.filter(isElement).flatMap(blockOf);
+const plainOfRuns = (runs) => runs.map((run) => run.isBreak === true ? "\n" : run.text).join("");
+//#endregion
+export { blocksOfHtml, plainOfRuns };

package/dist/export/html.d.ts

@@ -0,0 +1,8 @@
+import { ExportBundle, ExportedFile } from "./bundle.js";
+import { Content } from "@pollium/vyva-core/content";
+import { FileUrl } from "@pollium/vyva-core/render";
+//#region src/export/html.d.ts
+export declare const bodyOf: (content: Content, fileUrl: FileUrl) => string;
+export declare const pageHtml: ({ title, language }: ExportBundle, css: string, body: string) => string;
+export declare const buildHtml: (content: Content, bundle: ExportBundle) => Promise<ExportedFile>;
+//#endregion