@cenk1cenk2/md-printer 2.20.12 → 3.0.0

package/dist/services/session/session.service.mjs

@@ -0,0 +1,115 @@
+import "../../constants/template.constants.mjs";
+import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.mjs";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.mjs";
+import { PrinterService } from "../printer.service.mjs";
+import { dirname, join, resolve } from "path";
+import { LoggerService } from "@cenk1cenk2/oclif-common";
+import { Injectable } from "@nestjs/common";
+import { EventEmitter } from "events";
+import { watch } from "chokidar";
+import { debounce } from "perfect-debounce";
+//#region src/services/session/session.service.ts
+let SessionService = class SessionService extends EventEmitter {
+	logger;
+	printer;
+	watcher;
+	bundle;
+	stopped = false;
+	modules = /* @__PURE__ */ new Set();
+	watched = /* @__PURE__ */ new Set();
+	version = 0;
+	building;
+	flags;
+	ignored = /* @__PURE__ */ new Set();
+	build = debounce(() => this.stopped ? Promise.resolve() : this.building = this.run(), 50);
+	constructor(logger, printer) {
+		super();
+		this.logger = logger;
+		this.printer = printer;
+		this.logger.setup(this.constructor.name);
+	}
+	async start(flags) {
+		this.flags = flags;
+		this.watcher = watch([], {
+			ignoreInitial: true,
+			atomic: true
+		}).on("change", (path) => this.changed(path)).on("add", (path) => this.changed(path)).on("unlink", (path) => this.changed(path));
+		await this.build();
+	}
+	async onModuleDestroy() {
+		await this.stop();
+	}
+	ignore(path) {
+		this.ignored.add(resolve(path));
+	}
+	async stop() {
+		this.stopped = true;
+		this.build.cancel();
+		await this.building;
+		await this.watcher?.close();
+		this.watcher = void 0;
+	}
+	changed(path) {
+		const file = resolve(path);
+		if (this.ignored.has(file)) return;
+		this.logger.debug("Changed: %s", file);
+		if (this.modules.has(file) || this.bundle && dirname(file) === join(this.bundle.template, "components")) this.bundle = void 0;
+		this.build();
+	}
+	async run() {
+		const started = performance.now();
+		this.emit("building");
+		try {
+			const input = await this.printer.input(this.flags);
+			const options = await this.printer.options(this.flags, input);
+			const template = join(options.template, "Template.svelte");
+			this.modules.add(template);
+			this.watch([
+				input.file,
+				template,
+				join(options.template, "settings.json"),
+				join(options.template, "i18n"),
+				join(options.template, "components"),
+				options.sign.certificate && resolve(options.sign.certificate)
+			]);
+			if (this.bundle?.template !== options.template) this.bundle = {
+				template: options.template,
+				bundle: this.printer.bundle(options)
+			};
+			const cached = this.bundle;
+			const bundle = await cached.bundle.catch((err) => {
+				if (this.bundle === cached) this.bundle = void 0;
+				throw err;
+			});
+			if (this.bundle !== cached) return;
+			this.modules = /* @__PURE__ */ new Set([template, ...bundle.modules]);
+			this.watch(bundle.modules);
+			const ctx = {
+				input,
+				options
+			};
+			await this.printer.prepare(ctx);
+			const document = await this.printer.document(ctx, bundle);
+			this.watch(document.dependencies);
+			const { content, assets } = await this.printer.output(ctx, document);
+			this.watch(assets);
+			this.emit("ready", {
+				version: ++this.version,
+				ms: Math.round(performance.now() - started),
+				ctx,
+				document,
+				output: content
+			});
+		} catch (err) {
+			this.emit("failed", err instanceof Error ? err : new Error(String(err)));
+		}
+	}
+	watch(paths) {
+		const fresh = paths.filter((path) => path && !this.watched.has(path));
+		for (const path of fresh) this.watched.add(path);
+		if (fresh.length) this.watcher.add(fresh);
+	}
+};
+SessionService = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [typeof LoggerService === "undefined" ? Object : LoggerService, typeof PrinterService === "undefined" ? Object : PrinterService])], SessionService);
+//#endregion
+export { SessionService };

package/dist/services/signature/adapters/a-trust.adapter.mjs

@@ -0,0 +1,106 @@
+import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.mjs";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.mjs";
+import { isLoopbackRequest } from "../../loopback.mjs";
+import { SignatureAdapter } from "../signature.adapter.mjs";
+import { readFile } from "fs/promises";
+import { LoggerService } from "@cenk1cenk2/oclif-common";
+import { Injectable } from "@nestjs/common";
+import { spawn } from "child_process";
+import { once } from "events";
+import { createServer } from "http";
+import getRawBody from "raw-body";
+//#region src/services/signature/adapters/a-trust.adapter.ts
+let ATrustAdapter = class ATrustAdapter extends SignatureAdapter {
+	logger;
+	name = "a-trust";
+	constructor(logger) {
+		super();
+		this.logger = logger;
+		this.logger.setup(this.constructor.name);
+	}
+	async sign(request) {
+		return this.collect(await this.session(this.request(request)));
+	}
+	request({ pdf, excluded: [from, to] }) {
+		return [
+			"<?xml version=\"1.0\" encoding=\"UTF-8\"?>",
+			"<sl:CreateCMSSignatureRequest xmlns:sl=\"http://www.buergerkarte.at/namespaces/securitylayer/1.2#\" Structure=\"detached\" PAdESCompatibility=\"true\">",
+			"<sl:KeyboxIdentifier>SecureSignatureKeypair</sl:KeyboxIdentifier>",
+			"<sl:DataObject>",
+			"<sl:MetaInfo><sl:MimeType>application/pdf</sl:MimeType></sl:MetaInfo>",
+			`<sl:Content><sl:Base64Content>${Buffer.from(pdf).fill(0, from, to + 1).toString("base64")}</sl:Base64Content></sl:Content>`,
+			`<sl:ExcludedByteRange><sl:From>${from}</sl:From><sl:To>${to}</sl:To></sl:ExcludedByteRange>`,
+			"</sl:DataObject>",
+			"</sl:CreateCMSSignatureRequest>"
+		].join("");
+	}
+	async session(request) {
+		let url = "https://service.a-trust.at/mobile/https-security-layer-request/default.aspx";
+		let response = await fetch(url, {
+			method: "POST",
+			body: new URLSearchParams([["XMLRequest", request]]),
+			redirect: "manual"
+		});
+		while (response.status === 301 || response.status === 302) {
+			url = new URL(response.headers.get("location"), url).href;
+			response = await fetch(url, { redirect: "manual" });
+		}
+		if (!response.ok || !url.includes("/identification.aspx")) throw new Error(`A-Trust did not start a signing session, ended at ${url} with ${response.status}: ${(await response.text()).slice(0, 500)}`);
+		this.logger.debug("A-Trust signing session started: %s", url);
+		return url;
+	}
+	async collect(login) {
+		let resolve;
+		const result = new Promise((done) => {
+			resolve = done;
+		});
+		const page = await readFile(new URL("./a-trust.html", import.meta.url));
+		const server = createServer(async (req, res) => {
+			if (!isLoopbackRequest(req, req.method === "POST" ? `http://127.0.0.1:${server.address().port}` : void 0)) {
+				res.writeHead(403);
+				return res.end();
+			}
+			if (req.method === "GET" && req.url === "/session") {
+				res.setHeader("content-type", "application/json");
+				res.writeHead(200);
+				return res.end(JSON.stringify({ login }));
+			}
+			if (req.method !== "POST" || req.url !== "/signature") {
+				res.setHeader("content-type", "text/html; charset=utf-8");
+				res.writeHead(200);
+				return res.end(page);
+			}
+			const body = await getRawBody(req, {
+				limit: "1mb",
+				encoding: true
+			}).catch((err) => {
+				res.writeHead(err.status ?? 400);
+				res.end();
+			});
+			if (body === void 0) return;
+			const cms = (body.match(/<(?:\w+:)?CMSSignature>([^<]+)</)?.[1] ?? body).replace(/\s+/g, "");
+			if (!/^MII[A-Za-z0-9+/=]+$/.test(cms)) {
+				res.writeHead(400);
+				return res.end("This does not look like a signature, it should start with MII.");
+			}
+			res.writeHead(200);
+			res.end("Signature received, you can close this tab.");
+			resolve(Buffer.from(cms, "base64"));
+		});
+		server.listen(0, "127.0.0.1");
+		await once(server, "listening");
+		const url = `http://127.0.0.1:${server.address().port}/`;
+		this.logger.info("Sign the document in the browser, then paste the signature back: %s", url);
+		this.open(url);
+		return result.finally(() => server.close());
+	}
+	open(url) {
+		spawn("xdg-open", [url], {
+			stdio: "ignore",
+			detached: true
+		}).on("error", (err) => this.logger.warn("Can not open the browser, open the link manually: %s", err.message)).unref();
+	}
+};
+ATrustAdapter = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [typeof LoggerService === "undefined" ? Object : LoggerService])], ATrustAdapter);
+//#endregion
+export { ATrustAdapter };

package/dist/services/signature/adapters/a-trust.html

@@ -0,0 +1,77 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>md-printer signature</title>
+    <style>
+      body {
+        font-family: system-ui, sans-serif;
+        margin: 0;
+        padding: 16px;
+        background: #f4f4f5;
+        color: #18181b;
+      }
+      main {
+        max-width: 560px;
+        margin: 0 auto;
+        display: grid;
+        gap: 12px;
+      }
+      iframe {
+        width: 100%;
+        height: 600px;
+        border: 0;
+        border-radius: 12px;
+        background: #fff;
+      }
+      textarea {
+        width: 100%;
+        height: 96px;
+        box-sizing: border-box;
+        border-radius: 8px;
+        padding: 8px;
+        font: 12px ui-monospace, monospace;
+      }
+      button {
+        width: 100%;
+        padding: 10px;
+        border: 0;
+        border-radius: 8px;
+        background: #18181b;
+        color: #fff;
+        font-weight: 600;
+      }
+    </style>
+  </head>
+  <body>
+    <main id="main">
+      <iframe id="login"></iframe>
+      <p>Log in and approve the signature. When the signature starting with <code>MII</code> shows up above, paste it here.</p>
+      <form id="form">
+        <textarea name="signature" placeholder="MII..." required></textarea>
+        <button>Sign PDF</button>
+      </form>
+    </main>
+    <script>
+      fetch('/session')
+        .then((response) => response.json())
+        .then(({ login }) => (document.getElementById('login').src = login))
+
+      document.getElementById('form').addEventListener('submit', async (event) => {
+        event.preventDefault()
+
+        const response = await fetch('/signature', { method: 'POST', body: new FormData(event.target).get('signature') })
+        const message = document.createElement('p')
+
+        message.textContent = await response.text()
+
+        if (response.ok) {
+          document.getElementById('main').replaceChildren(message)
+        } else {
+          event.target.append(message)
+        }
+      })
+    </script>
+  </body>
+</html>

package/dist/services/signature/index.mjs

@@ -0,0 +1,4 @@
+import { SignatureAdapter } from "./signature.adapter.mjs";
+import { ATrustAdapter } from "./adapters/a-trust.adapter.mjs";
+import { SignatureService } from "./signature.service.mjs";
+export { ATrustAdapter, SignatureAdapter, SignatureService };

package/dist/services/signature/signature.adapter.mjs

@@ -0,0 +1,4 @@
+//#region src/services/signature/signature.adapter.ts
+var SignatureAdapter = class {};
+//#endregion
+export { SignatureAdapter };

package/dist/services/signature/signature.service.mjs

@@ -0,0 +1,95 @@
+import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.mjs";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.mjs";
+import { ATrustAdapter } from "./adapters/a-trust.adapter.mjs";
+import { isAbsolute, join } from "path";
+import { FileSystemService } from "@cenk1cenk2/oclif-common";
+import { Injectable } from "@nestjs/common";
+import { plainAddPlaceholder } from "@signpdf/placeholder-plain";
+import { SUBFILTER_ETSI_CADES_DETACHED, findByteRange, removeTrailingNewLine } from "@signpdf/utils";
+import { X509Certificate } from "crypto";
+import { homedir } from "os";
+//#region src/services/signature/signature.service.ts
+var _SignatureService;
+let SignatureService = class SignatureService {
+	static {
+		_SignatureService = this;
+	}
+	fs;
+	static LENGTH = 16384;
+	adapters;
+	constructor(fs, aTrust) {
+		this.fs = fs;
+		this.adapters = [aTrust];
+	}
+	get providers() {
+		return this.adapters.map((adapter) => adapter.name);
+	}
+	async certificate(file, date) {
+		const path = file.replace(/^~(?=\/|$)/, homedir());
+		const certificate = new X509Certificate(await this.fs.extra.readFile(isAbsolute(path) ? path : join(process.cwd(), path)));
+		if (date < certificate.validFromDate || date > certificate.validToDate) throw new Error(`Signing certificate is not valid at ${date.toISOString()}, it is valid from ${certificate.validFrom} to ${certificate.validTo}.`);
+		return certificate;
+	}
+	describe(date, certificate) {
+		return {
+			date: date.toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC"),
+			name: certificate && this.commonName(certificate.subject),
+			issuer: certificate && this.commonName(certificate.issuer),
+			serial: certificate?.serialNumber
+		};
+	}
+	async sign(pdf, options) {
+		const request = this.prepare(pdf, options);
+		const cms = await this.adapter(options.provider).sign(request);
+		if (options.certificate && !cms.includes(options.certificate.raw)) throw new Error("The returned signature was not created with the configured certificate, the signature block would show the wrong signer.");
+		return this.embed(request, cms);
+	}
+	adapter(provider) {
+		if (!provider) return this.adapters[0];
+		const adapter = this.adapters.find((adapter) => adapter.name === provider);
+		if (!adapter) throw new Error(`Unknown signature provider "${provider}", available: ${this.providers.join(", ")}`);
+		return adapter;
+	}
+	prepare(pdf, options) {
+		const prepared = removeTrailingNewLine(plainAddPlaceholder({
+			pdfBuffer: pdf,
+			reason: options.reason ?? "",
+			location: options.location ?? "",
+			contactInfo: options.contact ?? "",
+			name: "",
+			signingTime: options.date,
+			signatureLength: _SignatureService.LENGTH,
+			subFilter: SUBFILTER_ETSI_CADES_DETACHED,
+			appName: "md-printer"
+		}));
+		const { byteRangePlaceholder, byteRangePlaceholderPosition } = findByteRange(prepared);
+		if (!byteRangePlaceholder) throw new Error("Can not find the signature byte range placeholder in the PDF.");
+		const byteRangeEnd = byteRangePlaceholderPosition + byteRangePlaceholder.length;
+		const from = prepared.indexOf("<", prepared.indexOf("/Contents ", byteRangeEnd));
+		const to = prepared.indexOf(">", from);
+		return {
+			pdf: Buffer.concat([
+				prepared.subarray(0, byteRangePlaceholderPosition),
+				Buffer.from(`/ByteRange [0 ${from} ${to + 1} ${prepared.length - to - 1}]`.padEnd(byteRangePlaceholder.length, " ")),
+				prepared.subarray(byteRangeEnd)
+			]),
+			excluded: [from, to]
+		};
+	}
+	embed({ pdf, excluded: [from, to] }, cms) {
+		const signature = cms.toString("hex");
+		const length = to - from - 1;
+		if (signature.length > length) throw new Error(`Signature is ${signature.length} bytes but the placeholder only fits ${length}.`);
+		return Buffer.concat([
+			pdf.subarray(0, from + 1),
+			Buffer.from(signature.padEnd(length, "0")),
+			pdf.subarray(to)
+		]);
+	}
+	commonName(name) {
+		return name.split("\n").find((part) => part.startsWith("CN="))?.slice(3);
+	}
+};
+SignatureService = _SignatureService = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [typeof FileSystemService === "undefined" ? Object : FileSystemService, typeof ATrustAdapter === "undefined" ? Object : ATrustAdapter])], SignatureService);
+//#endregion
+export { SignatureService };

package/dist/services/template/Document.svelte

@@ -0,0 +1,21 @@
+<!--
+  @component
+  HTML document around the rendered template body.
+-->
+<script>
+  /** @type {import('@interfaces').DocumentShellProps} */
+  let { lang, title, head, body } = $props()
+</script>
+
+<html {lang}>
+  <head>
+    <meta charset="utf-8" />
+    {#if title !== undefined}
+      <title>{title}</title>
+    {/if}
+    <!-- eslint-disable-next-line svelte/no-at-html-tags -- styles and head elements rendered by md-printer -->
+    {@html head}
+  </head>
+  <!-- eslint-disable-next-line svelte/no-at-html-tags -- the template body rendered by md-printer -->
+  <body>{@html body}</body>
+</html>

package/dist/services/template/Margin.svelte

@@ -0,0 +1,15 @@
+<!--
+  @component
+  Wrapper for a header or footer snippet printed into Chrome's isolated page margin, which ignores the page stylesheet and defaults to a tiny font.
+-->
+<script>
+  /** @type {import('@interfaces').MarginShellProps} */
+  let { styles, body } = $props()
+</script>
+
+<!-- eslint-disable-next-line svelte/no-at-html-tags -- styles collected by md-printer for the isolated margin document -->
+{@html styles}
+<div style="font-size: 10px; width: 100%; box-sizing: border-box; -webkit-print-color-adjust: exact; print-color-adjust: exact">
+  <!-- eslint-disable-next-line svelte/no-at-html-tags -- the header or footer snippet rendered by md-printer -->
+  {@html body}
+</div>

package/dist/services/template/assets.mjs

@@ -0,0 +1,127 @@
+import { readFile, realpath } from "fs/promises";
+import { isAbsolute, relative, sep } from "path";
+import { toHtml } from "hast-util-to-html";
+import { visit } from "unist-util-visit";
+import { fileURLToPath, pathToFileURL } from "url";
+import { fromHtml } from "hast-util-from-html";
+import { transform, transformStyleAttribute } from "lightningcss";
+import mime from "mime";
+import { parseSrcset, stringifySrcset } from "srcset";
+//#region src/services/template/assets.ts
+const REFERENCES = {
+	img: ["src", "srcSet"],
+	source: ["src", "srcSet"],
+	input: ["src"],
+	video: ["poster"],
+	image: ["href", "xLinkHref"]
+};
+function mimeType(path) {
+	return mime.getType(path) ?? "application/octet-stream";
+}
+/**
+* Images and fonts, the assets that can be embedded into a page as data URIs.
+*/
+function isInlinableAsset(path) {
+	return /^(image|font)\//.test(mime.getType(path) ?? "");
+}
+function dataUri(path, content) {
+	return `data:${mimeType(path)};base64,${content.toString("base64")}`;
+}
+/**
+* Resolves symlinks first, so a link inside the directory can not reach a file outside of it.
+*/
+async function resolveConfined(path, base) {
+	const [real, root] = await Promise.all([realpath(path), realpath(base)]).catch(() => []);
+	if (!real) return;
+	const rel = relative(root, real);
+	return rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel) ? void 0 : real;
+}
+/**
+* Replaces local image references in HTML with data URIs: the image attributes, `style` attributes and `<style>` elements.
+* Remote references are fetched as well when `remote` is set, which Chrome's isolated header/footer templates need.
+* Document content is `confined` to its directory, the same rule the PDF renderer applies to the assets a page loads.
+*/
+async function inlineHtml(markup, base, options = {}) {
+	const assets = /* @__PURE__ */ new Set();
+	const inline = inliner(base, options, assets);
+	const tree = fromHtml(markup, { fragment: !/^<!doctype/i.test(markup) });
+	const pending = [];
+	visit(tree, "element", (node) => {
+		const { properties } = node;
+		for (const name of REFERENCES[node.tagName] ?? []) {
+			const value = properties[name];
+			if (typeof value !== "string") continue;
+			pending.push((async () => {
+				properties[name] = name === "srcSet" ? stringifySrcset(await Promise.all(parseSrcset(value).map(async (candidate) => ({
+					...candidate,
+					url: await inline(candidate.url) ?? candidate.url
+				})))) : await inline(value) ?? value;
+			})());
+		}
+		if (typeof properties.style === "string") {
+			const style = properties.style;
+			pending.push(stylesheet(style, inline, true).then((css) => {
+				properties.style = css;
+			}));
+		}
+		if (node.tagName === "style") {
+			for (const child of node.children) if (child.type === "text") pending.push(stylesheet(child.value, inline).then((css) => {
+				child.value = css;
+			}));
+		}
+	});
+	await Promise.all(pending);
+	return {
+		content: toHtml(tree, { characterReferences: { useNamedReferences: true } }),
+		assets: [...assets]
+	};
+}
+/**
+* Replaces local `url()` references in CSS with data URIs, with the same options as `inlineHtml`.
+*/
+async function inlineCss(css, base, options = {}) {
+	const assets = /* @__PURE__ */ new Set();
+	return {
+		content: await stylesheet(css, inliner(base, options, assets)),
+		assets: [...assets]
+	};
+}
+function inliner(base, { remote = false, confined = false, cache = /* @__PURE__ */ new Map() }, assets) {
+	return async (reference) => {
+		const asset = await (cache.get(reference) ?? cache.set(reference, load(reference, base, remote, confined)).get(reference));
+		if (asset?.path) assets.add(asset.path);
+		return asset?.uri;
+	};
+}
+async function stylesheet(css, inline, attribute = false) {
+	const options = {
+		filename: "style.css",
+		code: Buffer.from(css),
+		analyzeDependencies: { preserveImports: true },
+		errorRecovery: true
+	};
+	const { code, dependencies } = attribute ? transformStyleAttribute({
+		...options,
+		analyzeDependencies: true
+	}) : transform(options);
+	return (await Promise.all(dependencies.map(async (dependency) => [`"${dependency.placeholder}"`, JSON.stringify(dependency.type === "url" && await inline(dependency.url) || dependency.url)]))).reduce((result, [placeholder, value]) => result.replace(placeholder, () => value), code.toString());
+}
+async function load(reference, base, remote, confined) {
+	const url = reference.startsWith("#") ? void 0 : URL.parse(reference, pathToFileURL(`${base}${sep}`));
+	if (url?.protocol === "http:" || url?.protocol === "https:") {
+		if (!remote) return;
+		const response = await fetch(url).catch(() => void 0);
+		if (!response?.ok) return;
+		return { uri: `data:${response.headers.get("content-type") ?? mimeType(url.pathname)};base64,${Buffer.from(await response.arrayBuffer()).toString("base64")}` };
+	}
+	if (url?.protocol !== "file:" || url.host) return;
+	const path = fileURLToPath(url);
+	const file = confined ? await resolveConfined(path, base) : path;
+	if (!file || !isInlinableAsset(path)) return;
+	return readFile(file).then((content) => ({
+		uri: dataUri(path, content),
+		path: file
+	}), () => void 0);
+}
+//#endregion
+export { dataUri, inlineCss, inlineHtml, isInlinableAsset, mimeType, resolveConfined };

package/dist/services/template/render.entry.ts

@@ -0,0 +1,32 @@
+import Template from 'md-printer:template'
+import components from 'md-printer:template-components'
+import { render } from 'svelte/server'
+
+import Document from './Document.svelte'
+import Margin from './Margin.svelte'
+import Nodes from '../../components/Nodes.svelte'
+import type { DocumentShellProps, MarginShellProps, MarkdownNode, RenderedPart, TemplateProps } from '@interfaces'
+
+export { components }
+
+/**
+ * Entry of every template bundle, compiled at runtime together with the template it renders.
+ */
+export function part(props: TemplateProps, context: [string, unknown][]): Promise<RenderedPart> {
+  return Promise.resolve(render(Template, { props, context: new Map(context) }))
+}
+
+/**
+ * The markdown as one HTML string, for templates that place it with `{@html content}`. Plain HTML is kept as is, without Svelte's hydration markers.
+ */
+export function content(nodes: MarkdownNode[], context: [string, unknown][]): string {
+  return nodes.map((node) => (node.type === 'html' ? node.html : render(Nodes, { props: { nodes: [node] }, context: new Map(context) }).body)).join('')
+}
+
+export function document(props: DocumentShellProps): string {
+  return `<!doctype html>${render(Document, { props }).body}`
+}
+
+export function margin(props: MarginShellProps): string {
+  return render(Margin, { props }).body
+}

package/dist/services/template/svelte.plugin.mjs

@@ -0,0 +1,66 @@
+import "../../constants/template.constants.mjs";
+import { dataUri, isInlinableAsset } from "./assets.mjs";
+import { readFile, readdir } from "fs/promises";
+import { basename, dirname, extname, join } from "path";
+import { pathToFileURL } from "url";
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { compile, preprocess } from "svelte/compiler";
+//#region src/services/template/svelte.plugin.ts
+/**
+* `svelte` resolves to md-printer's copy, since templates can live outside any `node_modules`. `<style lang="postcss">` blocks are collected
+* instead of compiled per component, so the template's stylesheet goes through Tailwind once. `md-printer:template-components` maps the shared
+* components and the template's `components/*.svelte` by name, the template's winning.
+*/
+function sveltePlugin({ template, components, root, stylesheets }) {
+	const require = createRequire(root);
+	return {
+		name: "md-printer:svelte",
+		resolveId(id) {
+			if (id === "md-printer:template") return template;
+			if (id === "@cenk1cenk2/md-printer/components") return components;
+			if (id === "md-printer:template-components") return `\0${id}`;
+			if (id === "svelte" || id.startsWith("svelte/")) return {
+				id: pathToFileURL(require.resolve(id)).href,
+				external: true
+			};
+			return null;
+		},
+		async load(id) {
+			if (id === `\0md-printer:template-components`) {
+				const directory = join(dirname(template), "components");
+				const files = existsSync(directory) ? (await readdir(directory)).filter((file) => extname(file) === ".svelte").sort() : [];
+				return [
+					`import * as shared from ${JSON.stringify("@cenk1cenk2/md-printer/components")}`,
+					...files.map((file, index) => `import $${index} from ${JSON.stringify(join(directory, file))}`),
+					"const { Markdown, ...builtins } = shared",
+					`export default { ...builtins, ${files.map((file, index) => `${JSON.stringify(basename(file, ".svelte"))}: $${index}`).join(", ")} }`
+				].join("\n");
+			}
+			if (!isInlinableAsset(id)) return null;
+			return `export default ${JSON.stringify(dataUri(id, await readFile(id)))}`;
+		},
+		async transform(code, id) {
+			if (extname(id) !== ".svelte") return null;
+			const { code: source } = await preprocess(code, { style: ({ content, attributes }) => {
+				if (attributes.lang !== "postcss") return;
+				stylesheets.push({
+					file: id,
+					source: content
+				});
+				return { code: "" };
+			} }, { filename: id });
+			const { js } = compile(source, {
+				filename: id,
+				generate: "server",
+				css: "injected"
+			});
+			return {
+				code: js.code,
+				map: js.map
+			};
+		}
+	};
+}
+//#endregion
+export { sveltePlugin };