@pollium/vyva-convert 0.0.0-stage → 0.1.0

package/dist/export/html.js

@@ -0,0 +1,31 @@
+import { fontFaces, fontFilesOf } from "./fonts.js";
+import { DECK_SIZES } from "@pollium/vyva-core/content";
+import { CONTENT_CSS, renderDocument, renderSlide } from "@pollium/vyva-core/render";
+import { escapeHtml } from "@pollium/vyva-core/escape";
+//#region src/export/html.ts
+const SCREEN_PX_PER_INCH = 96;
+const SLIDE_PX_PER_INCH = 144;
+const SCREEN_CSS = "body{margin:0;background:#f3f4f6;display:flex;justify-content:center;padding:24px 0}.vy-doc{box-shadow:0 1px 4px rgba(0,0,0,.12)}";
+const dataUrl = (contentType, data) => `data:${contentType};base64,${data.toString("base64")}`;
+const bodyOf = (content, fileUrl) => {
+	if (content.kind === "document") return renderDocument(content, fileUrl);
+	const { width, height } = DECK_SIZES[content.format];
+	const zoom = SCREEN_PX_PER_INCH / SLIDE_PX_PER_INCH;
+	return content.slides.map((slide) => `<div class="vy-print-slide" style="width:${width * zoom}px;height:${height * zoom}px"><div style="width:${width}px;height:${height}px;transform:scale(${zoom});transform-origin:0 0">${renderSlide(slide, content, fileUrl)}</div></div>`).join("");
+};
+const pageHtml = ({ title, language }, css, body) => `<!doctype html><html lang="${escapeHtml(language)}"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${escapeHtml(title)}</title><style>${css}</style></head><body>${body}</body></html>`;
+const buildHtml = async (content, bundle) => {
+	const fonts = fontFaces(await fontFilesOf(bundle.fonts), (file) => dataUrl("font/woff2", file.data));
+	const fileUrl = (id) => {
+		const image = bundle.images.get(id);
+		return image === void 0 ? null : dataUrl(image.contentType, image.data);
+	};
+	const html = pageHtml(bundle, `${fonts}${CONTENT_CSS}${SCREEN_CSS}`, bodyOf(content, fileUrl));
+	return {
+		data: Buffer.from(html, "utf8"),
+		contentType: "text/html; charset=utf-8",
+		extension: "html"
+	};
+};
+//#endregion
+export { bodyOf, buildHtml, pageHtml };

package/dist/export/image-size.d.ts

@@ -0,0 +1,8 @@
+//#region src/export/image-size.d.ts
+export interface ImageSize {
+  width: number;
+  height: number;
+}
+export declare const imageSize: (data: Buffer, contentType: string) => ImageSize;
+export declare const fitWithin: (size: ImageSize, maxWidth: number, maxHeight: number) => ImageSize;
+//#endregion

package/dist/export/image-size.js

@@ -0,0 +1,83 @@
+//#region src/export/image-size.ts
+const FALLBACK = {
+	width: 800,
+	height: 600
+};
+const pngSize = (data) => data.length >= 24 ? {
+	width: data.readUInt32BE(16),
+	height: data.readUInt32BE(20)
+} : null;
+const gifSize = (data) => data.length >= 10 ? {
+	width: data.readUInt16LE(6),
+	height: data.readUInt16LE(8)
+} : null;
+const JPEG_FRAMES = /* @__PURE__ */ new Set([
+	192,
+	193,
+	194,
+	195,
+	197,
+	198,
+	199,
+	201,
+	202,
+	203,
+	205,
+	206,
+	207
+]);
+const jpegSize = (data) => {
+	let offset = 2;
+	while (offset + 9 < data.length) {
+		if (data[offset] !== 255) {
+			offset += 1;
+			continue;
+		}
+		const marker = data[offset + 1];
+		if (JPEG_FRAMES.has(marker)) return {
+			height: data.readUInt16BE(offset + 5),
+			width: data.readUInt16BE(offset + 7)
+		};
+		offset += 2 + data.readUInt16BE(offset + 2);
+	}
+	return null;
+};
+const webpSize = (data) => {
+	if (data.length < 30 || data.toString("ascii", 0, 4) !== "RIFF" || data.toString("ascii", 8, 12) !== "WEBP") return null;
+	const chunk = data.toString("ascii", 12, 16);
+	if (chunk === "VP8X") return {
+		width: 1 + data.readUIntLE(24, 3),
+		height: 1 + data.readUIntLE(27, 3)
+	};
+	if (chunk === "VP8L") {
+		const bits = data.readUInt32LE(21);
+		return {
+			width: 1 + (bits & 16383),
+			height: 1 + (bits >> 14 & 16383)
+		};
+	}
+	if (chunk === "VP8 ") return {
+		width: data.readUInt16LE(26) & 16383,
+		height: data.readUInt16LE(28) & 16383
+	};
+	return null;
+};
+const READERS = {
+	"image/png": pngSize,
+	"image/gif": gifSize,
+	"image/jpeg": jpegSize,
+	"image/webp": webpSize
+};
+const imageSize = (data, contentType) => {
+	const size = READERS[contentType]?.(data) ?? null;
+	return size !== null && size.width > 0 && size.height > 0 ? size : FALLBACK;
+};
+const fitWithin = (size, maxWidth, maxHeight) => {
+	const scale = Math.min(1, maxWidth / size.width, maxHeight / size.height);
+	return {
+		width: Math.round(size.width * scale),
+		height: Math.round(size.height * scale)
+	};
+};
+//#endregion
+export { fitWithin, imageSize };

package/dist/export/pdf.d.ts

@@ -0,0 +1,28 @@
+import { ExportBundle, ExportedFile } from "./bundle.js";
+import { Content } from "@pollium/vyva-core/content";
+//#region src/export/pdf.d.ts
+export interface PdfFile {
+  name: string;
+  data: Uint8Array;
+  contentType: string;
+}
+export interface PdfMargins {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+}
+export interface PdfPage {
+  width: number;
+  height: number;
+  margins: PdfMargins;
+}
+export interface PdfJob {
+  html: string;
+  files: PdfFile[];
+  footerHtml: string | null;
+  page: PdfPage;
+}
+export type PdfEngine = (job: PdfJob) => Promise<Uint8Array>;
+export declare const buildPdf: (content: Content, bundle: ExportBundle, engine: PdfEngine) => Promise<ExportedFile>;
+//#endregion

package/dist/export/pdf.js

@@ -0,0 +1,84 @@
+import { fontFaces, fontFilesOf } from "./fonts.js";
+import { bodyOf, pageHtml } from "./html.js";
+import { DECK_SIZES } from "@pollium/vyva-core/content";
+import { CONTENT_CSS } from "@pollium/vyva-core/render";
+import { escapeHtml } from "@pollium/vyva-core/escape";
+//#region src/export/pdf.ts
+const SLIDE_PX_PER_INCH = 144;
+const MM_PER_INCH = 25.4;
+const A4_INCHES = {
+	width: 8.27,
+	height: 11.69
+};
+const FOOTER_ROOM_MM = 4;
+const NO_MARGINS = {
+	top: 0,
+	right: 0,
+	bottom: 0,
+	left: 0
+};
+const PRINT_CSS = `
+@page{size:auto}
+html,body{margin:0;padding:0;-webkit-print-color-adjust:exact;print-color-adjust:exact}
+.vy-print-slide{break-after:page;overflow:hidden}
+.vy-print-slide:last-child{break-after:auto}
+.vy-doc{width:auto;min-height:0;padding:0}
+.vy-doc .vy-doc-footer{display:none}
+.vy-doc img{break-inside:avoid}
+.vy-doc tr,.vy-doc pre,.vy-doc blockquote{break-inside:avoid}
+.vy-doc h1,.vy-doc h2,.vy-doc h3,.vy-doc h4{break-after:avoid}
+`;
+const inches = (mm) => mm / MM_PER_INCH;
+const pageOf = (content) => {
+	if (content.kind === "deck") {
+		const { width, height } = DECK_SIZES[content.format];
+		return {
+			width: width / SLIDE_PX_PER_INCH,
+			height: height / SLIDE_PX_PER_INCH,
+			margins: NO_MARGINS
+		};
+	}
+	const { margins } = content.design;
+	return {
+		...A4_INCHES,
+		margins: {
+			top: inches(margins.top),
+			right: inches(margins.right),
+			bottom: inches(margins.bottom + FOOTER_ROOM_MM),
+			left: inches(margins.left)
+		}
+	};
+};
+const footerOf = (content) => {
+	if (content.kind !== "document") return null;
+	const { design } = content;
+	const text = escapeHtml(design.footerText);
+	if (text === "" && !design.showPageNumbers) return null;
+	const number = design.showPageNumbers ? "<span><span class=\"pageNumber\"></span> / <span class=\"totalPages\"></span></span>" : "<span></span>";
+	const side = (mm) => `${inches(mm).toFixed(3)}in`;
+	return `<html><head><style>.vy-page-footer{box-sizing:border-box;display:flex;justify-content:space-between;width:100%;padding:0 ${side(design.margins.right)} 0 ${side(design.margins.left)};font-family:system-ui,-apple-system,'Segoe UI',sans-serif;font-size:8pt;color:#6b7280}</style></head><body><div class="vy-page-footer"><span>${text}</span>${number}</div></body></html>`;
+};
+const buildPdf = async (content, bundle, engine) => {
+	const fonts = await fontFilesOf(bundle.fonts);
+	const css = `${fontFaces(fonts, (file) => file.name)}${CONTENT_CSS}${PRINT_CSS}`;
+	return {
+		data: await engine({
+			html: pageHtml(bundle, css, bodyOf(content, (id) => bundle.images.get(id)?.name ?? null)),
+			files: [...[...bundle.images.values()].map(({ name, data, contentType }) => ({
+				name,
+				data,
+				contentType
+			})), ...fonts.map(({ name, data }) => ({
+				name,
+				data,
+				contentType: "font/woff2"
+			}))],
+			footerHtml: footerOf(content),
+			page: pageOf(content)
+		}),
+		contentType: "application/pdf",
+		extension: "pdf"
+	};
+};
+//#endregion
+export { buildPdf };

package/dist/export/pptx.d.ts

@@ -0,0 +1,5 @@
+import { ExportBundle, ExportedFile } from "./bundle.js";
+import { DeckContent } from "@pollium/vyva-core/content";
+//#region src/export/pptx.d.ts
+export declare const buildPptx: (deck: DeckContent, bundle: ExportBundle) => Promise<ExportedFile>;
+//#endregion

package/dist/export/pptx.js

@@ -0,0 +1,310 @@
+import { blocksOfHtml } from "./html-blocks.js";
+import { CODE_FONT, CODE_LINE_HEIGHT, CODE_PALETTES, codeLines } from "@pollium/vyva-core/code";
+import { DECK_SIZES, TEXT_SHAPES } from "@pollium/vyva-core/content";
+import { bandHeight, footerHeight, footerSegments, hasBand, hasFooter, inkOn } from "@pollium/vyva-core/deck-frame";
+import PptxGenJS from "pptxgenjs";
+//#region src/export/pptx.ts
+const PPTX_MIME = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+const LAYOUT = "VYVA";
+const PX_PER_INCH = 144;
+const PT_PER_PX = 72 / PX_PER_INCH;
+const CODE_PADDING_EMS = .8;
+const inch = (px) => Number((px / PX_PER_INCH).toFixed(4));
+const hex = (color) => color.replace("#", "").toUpperCase();
+const transparency = (opacity) => Math.round((1 - Math.min(1, Math.max(0, opacity))) * 100);
+const dataUrl = (contentType, data) => `${contentType};base64,${data.toString("base64")}`;
+const runProps = (run, style) => ({
+	bold: run.bold || style.isBold,
+	italic: run.italic,
+	...run.underline ? { underline: { style: "sng" } } : {},
+	...run.strike ? { strike: "sngStrike" } : {},
+	...run.color === null ? {} : { color: hex(run.color) },
+	...run.highlight === null ? {} : { highlight: hex(run.highlight) },
+	...run.code ? { fontFace: CODE_FONT } : {},
+	...run.sizePx === null ? {} : { fontSize: Math.max(6, Math.round(run.sizePx * PT_PER_PX)) },
+	...run.link !== null && /^(https?:|mailto:)/i.test(run.link) ? { hyperlink: { url: run.link } } : {}
+});
+const textRuns = (html, style) => {
+	const out = [];
+	const push = (runs, paragraph) => {
+		const visible = runs.filter((run) => run.isBreak !== true);
+		if (visible.length === 0) {
+			out.push({
+				text: "",
+				options: {
+					...paragraph,
+					breakLine: true
+				}
+			});
+			return;
+		}
+		visible.forEach((run, index) => out.push({
+			text: run.text,
+			options: {
+				...runProps(run, style),
+				...index === 0 ? paragraph : {},
+				...index === visible.length - 1 ? { breakLine: true } : {}
+			}
+		}));
+	};
+	for (const block of blocksOfHtml(html)) if (block.kind === "paragraph" || block.kind === "heading") push(block.runs, block.align === null ? {} : { align: block.align });
+	else if (block.kind === "list") block.items.forEach((item) => push(item.runs, {
+		bullet: block.ordered ? { type: "number" } : true,
+		indentLevel: item.level
+	}));
+	else if (block.kind === "code") block.text.split("\n").forEach((line) => out.push({
+		text: line,
+		options: {
+			fontFace: CODE_FONT,
+			breakLine: true
+		}
+	}));
+	const last = out.at(-1);
+	if (last?.options !== void 0) last.options.breakLine = false;
+	return out;
+};
+const textOptions = (style, deck) => ({
+	fontFace: deck.theme.font,
+	fontSize: Math.max(6, Math.round(style.fontSize * PT_PER_PX)),
+	color: hex(style.color),
+	align: style.align,
+	valign: style.verticalAlign,
+	lineSpacingMultiple: style.lineHeight
+});
+const addText = (slide, element, deck) => {
+	slide.addText(textRuns(element.html, element.style), {
+		x: inch(element.x),
+		y: inch(element.y),
+		w: inch(element.w),
+		h: inch(element.h),
+		...textOptions(element.style, deck),
+		margin: 0,
+		rotate: element.rotation,
+		transparency: transparency(element.opacity),
+		...element.fill === null ? {} : { fill: { color: hex(element.fill) } }
+	});
+};
+const addImage = (slide, element, bundle) => {
+	const image = bundle.images.get(element.fileId);
+	if (image === void 0) return;
+	slide.addImage({
+		data: dataUrl(image.contentType, image.data),
+		x: inch(element.x),
+		y: inch(element.y),
+		w: inch(element.w),
+		h: inch(element.h),
+		rotate: element.rotation,
+		transparency: transparency(element.opacity),
+		rounding: element.radius >= Math.min(element.w, element.h) / 2,
+		altText: element.alt,
+		sizing: {
+			type: element.fit === "contain" ? "contain" : "cover",
+			w: inch(element.w),
+			h: inch(element.h)
+		}
+	});
+};
+const SHAPES = {
+	rect: "rect",
+	rounded: "roundRect",
+	ellipse: "ellipse",
+	triangle: "triangle",
+	line: "line",
+	arrow: "line"
+};
+const addShape = (slide, element, deck) => {
+	const isLine = element.shape === "line" || element.shape === "arrow";
+	const lineColor = element.stroke ?? element.fill;
+	const box = {
+		x: inch(element.x),
+		y: inch(isLine ? element.y + element.h / 2 : element.y),
+		w: inch(element.w),
+		h: isLine ? 0 : inch(element.h)
+	};
+	const paint = {
+		rotate: element.rotation,
+		...isLine || element.fill === null ? { fill: { type: "none" } } : { fill: {
+			color: hex(element.fill),
+			transparency: transparency(element.opacity)
+		} },
+		...lineColor === null || element.strokeWidth === 0 && !isLine ? { line: { type: "none" } } : { line: {
+			color: hex(lineColor),
+			width: Math.max(.5, element.strokeWidth * PT_PER_PX),
+			...element.shape === "arrow" ? { endArrowType: "triangle" } : {}
+		} },
+		...element.shape === "rounded" ? { rectRadius: .18 } : {}
+	};
+	if (element.text !== void 0 && TEXT_SHAPES.includes(element.shape) && element.text.html.trim() !== "") {
+		slide.addText(textRuns(element.text.html, element.text.style), {
+			...box,
+			...paint,
+			...textOptions(element.text.style, deck),
+			shape: SHAPES[element.shape],
+			margin: 6
+		});
+		return;
+	}
+	slide.addShape(SHAPES[element.shape], {
+		...box,
+		...paint
+	});
+};
+const addCode = (slide, element) => {
+	const palette = CODE_PALETTES[element.colorScheme];
+	const lines = codeLines(element.code, element.language, element.colorScheme);
+	const runs = lines.flatMap((line, index) => {
+		const tokens = line.length === 0 ? [{
+			text: " ",
+			color: palette.foreground
+		}] : line;
+		return tokens.map((token, at) => ({
+			text: token.text,
+			options: {
+				color: hex(token.color),
+				...at === tokens.length - 1 && index < lines.length - 1 ? { breakLine: true } : {}
+			}
+		}));
+	});
+	const padding = Math.round(element.fontSize * CODE_PADDING_EMS * PT_PER_PX);
+	slide.addText(runs, {
+		x: inch(element.x),
+		y: inch(element.y),
+		w: inch(element.w),
+		h: inch(element.h),
+		fontFace: CODE_FONT,
+		fontSize: Math.max(6, Math.round(element.fontSize * PT_PER_PX)),
+		color: hex(palette.foreground),
+		fill: { color: hex(palette.background) },
+		rectRadius: .08,
+		shape: "roundRect",
+		valign: "top",
+		align: "left",
+		lineSpacingMultiple: CODE_LINE_HEIGHT,
+		margin: [
+			padding,
+			padding,
+			padding,
+			padding
+		],
+		wrap: false,
+		rotate: element.rotation,
+		transparency: transparency(element.opacity)
+	});
+};
+const addTable = (slide, element, deck) => {
+	const columns = Math.max(1, ...element.rows.map((row) => row.length));
+	const rows = element.rows.map((row, index) => Array.from({ length: columns }, (_, column) => {
+		const isHeader = element.hasHeader && index === 0;
+		return {
+			text: row[column] ?? "",
+			options: isHeader ? {
+				bold: true,
+				color: "FFFFFF",
+				fill: { color: hex(element.headerFill) }
+			} : { color: hex(deck.theme.text) }
+		};
+	}));
+	slide.addTable(rows, {
+		x: inch(element.x),
+		y: inch(element.y),
+		w: inch(element.w),
+		colW: Array.from({ length: columns }, () => inch(element.w / columns)),
+		fontFace: deck.theme.font,
+		fontSize: Math.max(6, Math.round(element.fontSize * PT_PER_PX)),
+		border: {
+			type: "solid",
+			color: hex(element.borderColor),
+			pt: 1
+		},
+		valign: "middle",
+		margin: .06
+	});
+};
+const addBackground = (slide, background, deck, bundle) => {
+	if (background?.type === "image") {
+		const image = bundle.images.get(background.fileId);
+		if (image !== void 0) {
+			slide.background = { data: dataUrl(image.contentType, image.data) };
+			if (background.dim > 0) {
+				const { width, height } = DECK_SIZES[deck.format];
+				slide.addShape("rect", {
+					x: 0,
+					y: 0,
+					w: inch(width),
+					h: inch(height),
+					fill: {
+						color: "000000",
+						transparency: transparency(background.dim)
+					},
+					line: { type: "none" }
+				});
+			}
+			return;
+		}
+	}
+	slide.background = { color: hex(background?.type === "color" ? background.color : deck.theme.background) };
+};
+const addBand = (slide, source, deck) => {
+	if (!hasBand(deck.theme, source)) return;
+	const { width } = DECK_SIZES[deck.format];
+	slide.addShape("rect", {
+		x: 0,
+		y: 0,
+		w: inch(width),
+		h: inch(bandHeight(deck.format)),
+		fill: { color: hex(deck.theme.accent) },
+		line: { type: "none" }
+	});
+};
+const addFooter = (slide, source, deck) => {
+	if (!hasFooter(deck.theme, source)) return;
+	const { width, height } = DECK_SIZES[deck.format];
+	const tall = footerHeight(deck.format);
+	const third = width / 3;
+	footerSegments(source, deck).forEach((segment, index) => {
+		slide.addText(segment.text, {
+			x: inch(third * index),
+			y: inch(height - tall),
+			w: inch(third),
+			h: inch(tall),
+			fill: { color: hex(segment.fill) },
+			color: hex(inkOn(segment.fill)),
+			fontFace: deck.theme.font,
+			fontSize: Math.round(tall * .48 * PT_PER_PX),
+			align: segment.align,
+			valign: "middle",
+			margin: Math.round(tall * .5 * PT_PER_PX)
+		});
+	});
+};
+const buildPptx = async (deck, bundle) => {
+	const { width, height } = DECK_SIZES[deck.format];
+	const pptx = new PptxGenJS();
+	pptx.defineLayout({
+		name: LAYOUT,
+		width: inch(width),
+		height: inch(height)
+	});
+	pptx.layout = LAYOUT;
+	pptx.title = bundle.title;
+	for (const source of deck.slides) {
+		const slide = pptx.addSlide();
+		addBackground(slide, source.background, deck, bundle);
+		addBand(slide, source, deck);
+		for (const element of source.elements) if (element.type === "text") addText(slide, element, deck);
+		else if (element.type === "image") addImage(slide, element, bundle);
+		else if (element.type === "shape") addShape(slide, element, deck);
+		else if (element.type === "code") addCode(slide, element);
+		else addTable(slide, element, deck);
+		addFooter(slide, source, deck);
+	}
+	const data = await pptx.write({ outputType: "uint8array" });
+	if (!(data instanceof Uint8Array)) throw new TypeError("PptxGenJS did not write the presentation as bytes");
+	return {
+		data,
+		contentType: PPTX_MIME,
+		extension: "pptx"
+	};
+};
+//#endregion
+export { buildPptx };

package/dist/export.d.ts

@@ -0,0 +1,19 @@
+import { ExportedFile, ReadImage } from "./export/bundle.js";
+import { PdfEngine } from "./export/pdf.js";
+import { Content, ContentKind } from "@pollium/vyva-core/content";
+//#region src/export.d.ts
+export declare const EXPORT_FORMATS: {
+  readonly document: readonly ["pdf", "docx", "html"];
+  readonly deck: readonly ["pptx", "pdf"];
+};
+export type ExportFormat = typeof EXPORT_FORMATS[ContentKind][number];
+export interface ExportOptions {
+  title: string;
+  readImage: ReadImage;
+  pdfEngine?: PdfEngine;
+  language?: string;
+}
+export declare const isExportFormat: (value: unknown) => value is ExportFormat;
+export declare const canExport: (kind: ContentKind, format: ExportFormat) => boolean;
+export declare const exportContent: (content: Content, format: ExportFormat, { title, readImage, pdfEngine, language }: ExportOptions) => Promise<ExportedFile>;
+//#endregion

package/dist/export.js

@@ -0,0 +1,39 @@
+import { ConvertError } from "./errors.js";
+import { bundleOf } from "./export/bundle.js";
+import { buildDocx } from "./export/docx.js";
+import { buildHtml } from "./export/html.js";
+import { buildPdf } from "./export/pdf.js";
+import { buildPptx } from "./export/pptx.js";
+//#region src/export.ts
+const EXPORT_FORMATS = {
+	document: [
+		"pdf",
+		"docx",
+		"html"
+	],
+	deck: ["pptx", "pdf"]
+};
+const DEFAULT_LANGUAGE = "en";
+const FORMATS = new Set(Object.values(EXPORT_FORMATS).flat());
+const isExportFormat = (value) => typeof value === "string" && FORMATS.has(value);
+const canExport = (kind, format) => {
+	return EXPORT_FORMATS[kind].includes(format);
+};
+const engineOf = (engine) => {
+	if (engine === void 0) throw new TypeError("Exporting as pdf needs a pdfEngine");
+	return engine;
+};
+const exportContent = async (content, format, { title, readImage, pdfEngine, language = DEFAULT_LANGUAGE }) => {
+	if (!canExport(content.kind, format)) throw new ConvertError("unsupported", `A ${content.kind} cannot be exported as ${format}`);
+	const engine = format === "pdf" ? engineOf(pdfEngine) : null;
+	const bundle = await bundleOf(content, {
+		title,
+		language,
+		readImage
+	});
+	if (engine !== null) return buildPdf(content, bundle, engine);
+	if (format === "html") return buildHtml(content, bundle);
+	return content.kind === "document" ? buildDocx(content, bundle) : buildPptx(content, bundle);
+};
+//#endregion
+export { EXPORT_FORMATS, canExport, exportContent, isExportFormat };

package/dist/font-widths.d.ts

@@ -0,0 +1,8 @@
+import { FontFamily } from "@pollium/vyva-core/content";
+//#region src/font-widths.d.ts
+export declare const MEASURED_CHARS = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ–—‘’‚“”„•…€→←↑↓≤≥≠×÷✓";
+export declare const FONT_WIDTHS: Record<FontFamily, {
+  regular: number[];
+  bold: number[];
+}>;
+//#endregion