vde-open 0.1.7 → 0.1.8

package/dist/{main-keob540p.js → main-001DhaNk.js}

@@ -1,7 +1,6 @@
-import { r as __toESM, t as __commonJSMin } from "./rolldown-runtime-DC62tzP2.js";
+import { C as roleAllowed, N as __commonJSMin, P as __toESM, S as isValidLogicalPath, _ as classifyLink, b as encodeLogicalPath, d as analyzeDocument, g as assetTypeOf, u as ParseLimitError, v as classifyReference, x as hasHiddenSegment, y as dirnameOfLogicalPath } from "./html-static-BDV6MgA7.js";
 import { $ as literal, A as successEnvelope, B as readParamsSchema, C as VdeError, D as ExitCode, E as isVdeError, F as htmlModeChangeParamsSchema, G as sha256Schema, H as reorderParamsSchema, I as htmlModeSchema, J as watchRuleSchema, K as sourceKindSchema, L as linkOpenParamsSchema, M as closeParamsSchema, N as documentFormatSchema, P as documentIdSchema, Q as boolean, R as listParamsSchema, S as validateAnswers, U as revisionSchema, V as renderGrantParamsSchema, W as searchParamsSchema, X as _enum, Y as LIMITS, Z as array, _ as feedbackWaitParamsSchema, a as uniqueTokens, at as canonicalJson, b as submissionSchema, c as feedbackAckParamsSchema, d as feedbackDraftParamsSchema, et as number, f as feedbackForgetParamsSchema, g as feedbackSubmitParamsSchema, h as feedbackStatusSchema, i as codePointLength, it as ZodError, j as assetRecordSchema, k as errorEnvelope, l as feedbackCancelParamsSchema, m as feedbackListParamsSchema, n as batchesOf, nt as strictObject, o as answersSchema, p as feedbackIdParamsSchema, q as sourceStateSchema, r as partsOf, rt as string, s as cancellationSchema, tt as record, u as feedbackCreateParamsSchema, v as questionnaireSchema, w as exitCodeForError, x as utf8Length, y as requestIdSchema, z as openParamsSchema } from "./search-index-B7DqaWh6.js";
-import { C as roleAllowed, _ as dirnameOfLogicalPath, a as ParseLimitError, g as classifyReference, h as classifyLink, m as assetTypeOf, o as analyzeDocument, v as encodeLogicalPath, x as isValidLogicalPath, y as hasHiddenSegment } from "./rendering-rules-DiE2jI7I.js";
-import { n as scanReferences, r as extractTitle } from "./render-BJnuEfHt.js";
+import { n as scanReferences, r as extractTitle } from "./render-BX3arVZj.js";
 import { n as measureHeap, t as collectGarbage } from "./heap-C3qHm7SE.js";
 import { accessSync, constants, existsSync, stat, statSync, unwatchFile, watch, watchFile } from "node:fs";
 import { appendFile, chmod, link, lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, realpath, rename, rm, rmdir, stat as stat$1, writeFile } from "node:fs/promises";
@@ -155,7 +154,7 @@ function parseStrictJson(text) {
 }
 //#endregion
 //#region package.json
-var version = "0.1.7";
+var version = "0.1.8";
 //#endregion
 //#region src/documents/cursor.ts
 function invalidCursor(reason) {
@@ -5659,6 +5658,12 @@ async function printPage(cdp, url) {
 	if (navigation.errorText !== void 0 || navigation.loaderId === void 0) throw exportFailed("load");
 	loaderId = navigation.loaderId;
 	if (!seen.has(loaderId)) await loaded;
+	await cdp.send("Emulation.setEmulatedMedia", { media: "print" }, sessionId);
+	if ((await cdp.send("Runtime.evaluate", {
+		expression: "(async () => { document.body.getBoundingClientRect(); await document.fonts.ready; })()",
+		awaitPromise: true,
+		returnByValue: true
+	}, sessionId)).exceptionDetails !== void 0) throw exportFailed("load");
 	const { stream } = await cdp.send("Page.printToPDF", {
 		printBackground: true,
 		preferCSSPageSize: true,
@@ -5716,12 +5721,11 @@ function createPdfService(options) {
 			process.kill(-child.pid, "SIGKILL");
 		} catch {}
 	};
-	const writePage = async (path, html, slot, images) => {
+	const writePage = async (path, html, slot, assets, budget) => {
 		const file = await open(path, "wx", 384);
-		let written = 0;
 		const write = async (text) => {
-			written += Buffer.byteLength(text);
-			if (written > maxPageBytes) throw new VdeError("E_LIMIT_EXCEEDED", "The document is too large to print.", {
+			budget.written += Buffer.byteLength(text);
+			if (budget.written > maxPageBytes) throw new VdeError("E_LIMIT_EXCEEDED", "The document is too large to print.", {
 				reason: "page-size",
 				limit: maxPageBytes
 			});
@@ -5731,10 +5735,10 @@ function createPdfService(options) {
 			let last = 0;
 			for (const match of html.matchAll(new RegExp(`${slot}-(\\d+)`, "g"))) {
 				await write(html.slice(last, match.index));
-				const image = images[Number(match[1])];
-				if (image !== void 0) {
-					await write(`data:${image.mime};base64,`);
-					await write((await store.readBlob(image.sha256)).toString("base64"));
+				const asset = assets[Number(match[1])];
+				if (asset !== void 0) {
+					await write(`data:${asset.mime};base64,`);
+					await write((await store.readBlob(asset.sha256)).toString("base64"));
 				}
 				last = match.index + match[0].length;
 			}
@@ -5821,22 +5825,53 @@ function createPdfService(options) {
 	const run = async (documentId, revision, signal) => {
 		const started = Date.now();
 		const { record, entry } = documents.describeRevision(documentId, revision);
-		if (entry.format !== "markdown") throw new VdeError("E_UNSUPPORTED_FORMAT", "Only Markdown documents can be exported as PDF.", { format: entry.format });
 		const source = (await store.readBlob(entry.sourceSha256)).toString("utf8");
-		const images = entry.assets.filter((asset) => asset.role === "image" || asset.role === "svg");
 		const slot = randomBytes(16).toString("hex");
-		const html = await printer.print({
+		let assets = entry.assets.filter((asset) => asset.role === "image" || asset.role === "svg");
+		let html;
+		let stylesheets = [];
+		if (entry.format === "markdown") html = await printer.print({
 			source,
 			title: record.title,
 			documentLogicalPath: entry.documentLogicalPath,
-			images: images.map((asset) => asset.logicalPath),
+			images: assets.map((asset) => asset.logicalPath),
 			imageSlot: slot
 		});
+		else {
+			const sheets = [];
+			for (const asset of entry.assets) {
+				if (asset.role !== "style") continue;
+				const bytes = await store.readBlob(asset.sha256);
+				try {
+					sheets.push({
+						logicalPath: asset.logicalPath,
+						text: new TextDecoder("utf-8", { fatal: true }).decode(bytes)
+					});
+				} catch {}
+			}
+			const readable = new Set(sheets.map((sheet) => sheet.logicalPath));
+			assets = entry.assets.filter((asset) => asset.role === "image" || asset.role === "svg" || asset.role === "font" || asset.role === "style" && readable.has(asset.logicalPath));
+			const output = await printer.printHtml({
+				source,
+				title: record.title,
+				documentLogicalPath: entry.documentLogicalPath,
+				assets: assets.map(({ logicalPath, role }) => ({
+					logicalPath,
+					role
+				})),
+				stylesheets: sheets,
+				assetSlot: slot
+			});
+			html = output.html;
+			stylesheets = output.stylesheets;
+		}
 		const browser = options.findBrowser();
 		const directory = await mkdtemp(join(tempRoot, TEMP_PREFIX$1));
 		try {
 			const page = join(directory, "document.html");
-			await writePage(page, html, slot, images);
+			const budget = { written: 0 };
+			await writePage(page, html, slot, assets, budget);
+			for (const sheet of stylesheets) await writePage(join(directory, sheet.name), sheet.css, slot, assets, budget);
 			const { product, pdf } = await print(browser, directory, pathToFileURL(page).href, signal);
 			if (!isPdf(pdf)) throw exportFailed("output");
 			options.onEvent?.("pdf.exported", {
@@ -5857,7 +5892,7 @@ function createPdfService(options) {
 		}
 	};
 	return {
-		exportMarkdown(documentId, revision, signal) {
+		exportPdf(documentId, revision, signal) {
 			if (closed) return Promise.reject(stopping());
 			if (waiting >= MAX_WAITING) return Promise.reject(new VdeError("E_LIMIT_EXCEEDED", "Too many PDF exports are waiting.", {
 				reason: "waiting",
@@ -11257,7 +11292,7 @@ async function startManagementServer(deps, options = {}) {
 	api.post("/documents/:id/refresh", async (c) => ok(c, "documents.refresh", await deps.documents.refresh({ documentId: c.req.param("id") })));
 	api.post("/documents/:id/pdf", async (c) => {
 		const body = strictObject({ revision: revisionSchema }).parse(await c.req.json());
-		const pdf = await deps.pdf.exportMarkdown(c.req.param("id"), body.revision, c.req.raw.signal);
+		const pdf = await deps.pdf.exportPdf(c.req.param("id"), body.revision, c.req.raw.signal);
 		return c.body(new Uint8Array(pdf), 200, {
 			"Content-Type": "application/pdf",
 			"Content-Disposition": "attachment"
@@ -13807,6 +13842,10 @@ function createParseService(options = {}) {
 			op: "print",
 			input
 		}),
+		printHtml: (input) => request({
+			op: "printHtml",
+			input
+		}),
 		async close() {
 			closed = true;
 			collector.close(new VdeError("E_DAEMON_STOPPING", "The daemon is stopping."));

package/dist/{print-CR5-GDjQ.js → print-Cfa1Ytrj.js}

@@ -1,4 +1,4 @@
-import { D as escapeAttr, E as parseMarkdown, O as escapeHtml$2, k as footnoteReferenceId, n as renderedLinkOf, p as parseMarkdownDocument, r as MARKDOWN_PARSE_OPTIONS, t as localImagePath } from "./rendering-rules-DiE2jI7I.js";
+import { A as escapeAttr, D as defaultTreeAdapter, E as serialize, M as footnoteReferenceId, O as NS, T as parseFragment, c as renderedLinkOf, h as parseMarkdownDocument, i as transformStaticHtml, j as escapeHtml$2, k as parseMarkdown, l as MARKDOWN_PARSE_OPTIONS, n as resolveAssetUrl, o as transformCss, s as localImagePath, t as DiagnosticLog, w as parse, y as dirnameOfLogicalPath } from "./html-static-BDV6MgA7.js";
 //#region ../../node_modules/.pnpm/@tanstack+markdown@1.0.0_react@19.3.0/node_modules/@tanstack/markdown/dist/html.js
 function renderHtml(input, options = {}) {
 	return (typeof input === "string" ? parseMarkdown(input, options) : input).children.map((node) => renderBlock(node, options)).join("\n");
@@ -1708,6 +1708,50 @@ figure.tm-code-frame > pre {
 }
 `;
 //#endregion
+//#region ../../packages/document/src/html-print.ts
+const PRINT_CSP$1 = "default-src 'none'; img-src data:; font-src data:; style-src 'unsafe-inline' file:; base-uri 'none'; form-action 'none'";
+function renderHtmlPrintDocument(input) {
+	if (!/^[0-9a-f]{32,}$/.test(input.assetSlot)) throw new Error("The asset slot must be random hexadecimal.");
+	const assets = new Map(input.assets.map(({ logicalPath, role }) => [logicalPath, role]));
+	const readable = new Set(input.stylesheets.map(({ logicalPath }) => logicalPath));
+	const urls = /* @__PURE__ */ new Map();
+	input.assets.forEach(({ logicalPath, role }, index) => {
+		if (role === "style" && readable.has(logicalPath)) urls.set(logicalPath, `asset-${String(index)}.css`);
+		else if (role === "image" || role === "svg" || role === "font") urls.set(logicalPath, `${input.assetSlot}-${String(index)}`);
+	});
+	const log = new DiagnosticLog();
+	const transformed = transformStaticHtml({
+		source: input.source,
+		documentLogicalPath: input.documentLogicalPath,
+		assets,
+		assetUrls: urls
+	}, log);
+	const stylesheets = input.stylesheets.flatMap(({ logicalPath, text }) => {
+		const name = urls.get(logicalPath);
+		if (name === void 0 || assets.get(logicalPath) !== "style") return [];
+		return [{
+			name,
+			css: transformCss(text, "stylesheet", (url, context) => resolveAssetUrl(url, context, dirnameOfLogicalPath(logicalPath), assets, log, { assetUrls: urls })).css
+		}];
+	});
+	const document = parse(transformed.html, { scriptingEnabled: false });
+	const root = document.childNodes.find((node) => "tagName" in node && node.tagName === "html");
+	const head = root && "childNodes" in root ? root.childNodes.find((node) => "tagName" in node && node.tagName === "head") : void 0;
+	if (!head || !("tagName" in head)) throw new Error("The HTML document has no head.");
+	const prefix = parseFragment(head, `<meta charset="utf-8"><meta http-equiv="Content-Security-Policy" content="${PRINT_CSP$1}"><style>@page { size: A4; margin: 20mm; }</style>`, {}).childNodes;
+	for (const node of prefix) node.parentNode = head;
+	head.childNodes.unshift(...prefix);
+	if (!head.childNodes.some((node) => "tagName" in node && node.tagName === "title")) {
+		const title = defaultTreeAdapter.createElement("title", NS.HTML, []);
+		defaultTreeAdapter.insertText(title, input.title);
+		defaultTreeAdapter.appendChild(head, title);
+	}
+	return {
+		html: serialize(document),
+		stylesheets
+	};
+}
+//#endregion
 //#region ../../packages/document/src/print.ts
 const PRINT_CSP = "default-src 'none'; img-src data:; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'";
 const KANA = /[\u3041-\u3096\u30a1-\u30fa]/;
@@ -1776,4 +1820,4 @@ function renderPrintDocument(input) {
 	].join("\n");
 }
 //#endregion
-export { cssString, headerTitle, renderPrintDocument };
+export { cssString, headerTitle, renderHtmlPrintDocument, renderPrintDocument };

package/dist/render-BX3arVZj.js

@@ -0,0 +1,181 @@
+import { _ as classifyLink, a as scanCssReferences, f as assertWithinLimits, i as transformStaticHtml, k as parseMarkdown, l as MARKDOWN_PARSE_OPTIONS, m as markdownUrlTransform, n as resolveAssetUrl, o as transformCss, p as inlineText$1, r as scanHtmlReferences, t as DiagnosticLog, w as parse, y as dirnameOfLogicalPath } from "./html-static-BDV6MgA7.js";
+//#region ../../packages/document/src/title.ts
+const TITLE_SCAN_CHARS = 65536;
+const MAX_TITLE_LENGTH = 160;
+function inlineText(nodes) {
+	let text = "";
+	for (const node of nodes) switch (node.type) {
+		case "text":
+		case "inlineCode":
+			text += node.value;
+			break;
+		case "strong":
+		case "emphasis":
+		case "strike":
+		case "link":
+		case "inlineComponent":
+			text += inlineText(node.children);
+			break;
+		case "image":
+			text += node.alt;
+			break;
+		case "break": text += " ";
+	}
+	return text;
+}
+function normalize(text) {
+	const collapsed = text.replace(/\s+/g, " ").trim();
+	if (collapsed === "") return null;
+	return Array.from(collapsed).slice(0, MAX_TITLE_LENGTH).join("");
+}
+function markdownTitle(source) {
+	const document = parseMarkdown(source, {
+		allowHtml: false,
+		frontmatter: true
+	});
+	for (const node of document.children) if (node.type === "heading") return normalize(inlineText(node.children));
+	return null;
+}
+function findElement(node, tagName) {
+	if ("tagName" in node && node.tagName === tagName) return node;
+	if (!("childNodes" in node)) return null;
+	for (const child of node.childNodes) {
+		const found = findElement(child, tagName);
+		if (found) return found;
+	}
+	return null;
+}
+function htmlTitle(source) {
+	const title = findElement(parse(source), "title");
+	if (!title || !("childNodes" in title)) return null;
+	let text = "";
+	for (const child of title.childNodes) if (child.nodeName === "#text" && "value" in child) text += child.value;
+	return normalize(text);
+}
+function extractTitle(source, format) {
+	const head = source.slice(0, TITLE_SCAN_CHARS);
+	return format === "markdown" ? markdownTitle(head) : htmlTitle(head);
+}
+//#endregion
+//#region ../../packages/document/src/markdown-render.ts
+const MAX_LINKS = 2e3;
+const MAX_LINK_TEXT = 120;
+function parseWithImages(source) {
+	const imageUrls = [];
+	const document = parseMarkdown(source, {
+		...MARKDOWN_PARSE_OPTIONS,
+		urlTransform: (url, kind, defaultUrl) => {
+			if (kind === "image") imageUrls.push(url);
+			return markdownUrlTransform(url, kind, defaultUrl);
+		}
+	});
+	assertWithinLimits(document);
+	return {
+		blocks: document.children,
+		imageUrls
+	};
+}
+function visitInline(nodes, visit) {
+	for (const node of nodes) {
+		visit(node);
+		if ("children" in node) visitInline(node.children, visit);
+	}
+}
+function visitBlocks(nodes, visit) {
+	for (const node of nodes) switch (node.type) {
+		case "heading":
+		case "paragraph":
+			visitInline(node.children, visit);
+			break;
+		case "blockquote":
+		case "callout":
+		case "component":
+			visitBlocks(node.children, visit);
+			break;
+		case "list":
+		case "footnotes":
+			for (const item of node.items) visitBlocks(item.children, visit);
+			break;
+		case "table":
+			for (const cell of node.header) visitInline(cell.children, visit);
+			for (const row of node.rows) for (const cell of row) visitInline(cell.children, visit);
+	}
+}
+function scanMarkdownReferences(source) {
+	return parseWithImages(source).imageUrls.map((url) => ({
+		url,
+		context: "image"
+	}));
+}
+function analyzeMarkdownRender(input, log = new DiagnosticLog()) {
+	const baseDir = dirnameOfLogicalPath(input.documentLogicalPath);
+	const parsed = parseWithImages(input.source);
+	for (const url of parsed.imageUrls) resolveAssetUrl(url, "image", baseDir, input.assets, log);
+	const links = [];
+	const seen = /* @__PURE__ */ new Set();
+	visitBlocks(parsed.blocks, (node) => {
+		if (node.type !== "link" || links.length >= MAX_LINKS || seen.has(node.href)) return;
+		const target = classifyLink(node.href);
+		if (target.kind === "fragment") return;
+		seen.add(node.href);
+		links.push({
+			linkId: `lnk_${String(links.length + 1).padStart(4, "0")}`,
+			href: node.href,
+			text: inlineText$1(node.children).replace(/\s+/g, " ").trim().slice(0, MAX_LINK_TEXT),
+			kind: target.kind
+		});
+	});
+	return {
+		links,
+		diagnostics: log.list()
+	};
+}
+//#endregion
+//#region ../../packages/document/src/render-document.ts
+function renderDocument(input) {
+	const assets = new Map(input.assets.map((asset) => [asset.logicalPath, asset.role]));
+	const log = new DiagnosticLog();
+	const staticInput = {
+		source: input.source,
+		documentLogicalPath: input.documentLogicalPath,
+		assets
+	};
+	const stylesheets = input.stylesheets.map(({ logicalPath, text }) => {
+		const baseDir = dirnameOfLogicalPath(logicalPath);
+		const result = transformCss(text, "stylesheet", (url, context) => resolveAssetUrl(url, context, baseDir, assets, log));
+		if (result.invalid > 0) log.note("css-invalid", logicalPath);
+		return {
+			logicalPath,
+			css: result.css
+		};
+	});
+	if (input.format === "markdown") {
+		const info = analyzeMarkdownRender(staticInput, log);
+		return {
+			html: null,
+			stylesheets,
+			links: info.links,
+			diagnostics: info.diagnostics,
+			headingTargets: []
+		};
+	}
+	const result = transformStaticHtml({
+		...staticInput,
+		interactive: input.mode === "interactive",
+		...input.mode === "interactive" && input.sdkScript !== null ? { sdkScript: input.sdkScript } : {}
+	}, log);
+	return {
+		html: result.html,
+		stylesheets,
+		links: result.links,
+		diagnostics: result.diagnostics,
+		headingTargets: result.headingTargets
+	};
+}
+function scanReferences(kind, source) {
+	if (kind === "markdown") return scanMarkdownReferences(source);
+	if (kind === "html") return scanHtmlReferences(source);
+	return scanCssReferences(source, "stylesheet");
+}
+//#endregion
+export { scanReferences as n, extractTitle as r, renderDocument as t };