@cenk1cenk2/md-printer 2.20.12 → 3.0.0

package/dist/commands/index.mjs

@@ -1,311 +1,190 @@
-import { DEFAULT_LANGUAGE, I18N_DIRECTORY, RequiredTemplateFiles, TEMPLATE_DIRECTORY, TemplateFiles } from "../constants/template.constants.mjs";
 import { InputFileType, OutputFileType } from "../constants/file.constants.mjs";
-import { I18nService } from "../services/i18n.service.mjs";
+import { BrowserService } from "../services/renderer/browser.service.mjs";
+import { PrinterService } from "../services/printer.service.mjs";
+import { PreviewService } from "../services/session/preview.service.mjs";
+import { SessionService } from "../services/session/session.service.mjs";
+import { PrinterModule } from "../services/printer.module.mjs";
 import "../services/index.mjs";
-import tailwind from "@tailwindcss/postcss";
-import { watch } from "chokidar";
-import graymatter from "gray-matter";
-import { defaultConfig } from "md-to-pdf/dist/lib/config.js";
-import { convertMdToPdf } from "md-to-pdf/dist/lib/md-to-pdf.js";
-import { serveDirectory } from "md-to-pdf/dist/lib/serve-dir.js";
-import Nunjucks from "nunjucks";
-import { basename, dirname, extname, isAbsolute, join } from "path";
-import postcss from "postcss";
-import * as Puppeteer from "puppeteer";
-import puppeteer from "puppeteer";
-import showdown from "showdown";
-import { Args, Command, ConfigService, FileSystemService, Flags, JsonParser, MergeStrategy, ParserService, YamlParser, merge } from "@cenk1cenk2/oclif-common";
-
+import { mkdir } from "fs/promises";
+import { dirname } from "path";
+import { text } from "stream/consumers";
+import writeFileAtomic from "write-file-atomic";
+import { Args, CliModule, Command, Flags, JsonParser, ParserService, YamlParser } from "@cenk1cenk2/oclif-common";
 //#region src/commands/index.ts
-const { parsePDFOptions, unitToPixels } = Puppeteer;
 var MDPrinter = class extends Command {
-	static description = "Generates a PDF from the given markdown file with the selected HTML template.";
+	static description = "Renders a markdown or yaml file through a Svelte template into a PDF or HTML document.";
 	static flags = {
-		stdin: Flags.string({
+		stdin: Flags.boolean({
 			char: "I",
-			description: "Read the input from stdin.",
-			required: false,
-			exclusive: ["file"],
-			allowStdin: "only"
+			description: "Read the input from stdin."
 		}),
 		["input-filetype"]: Flags.string({
 			char: "f",
 			options: Object.values(InputFileType),
-			description: "File type to be processed. By default it is detected by the file extension.",
-			default: "md"
+			description: "Input file type. Detected from the file extension, markdown for stdin and unknown extensions."
 		}),
 		["output-filetype"]: Flags.string({
 			char: "F",
 			options: Object.values(OutputFileType),
-			description: "File type to be processed. By default it is detected by the file extension.",
-			default: "pdf"
+			description: "Output file type, defaults to pdf. Overwrites the one defined in front-matter."
 		}),
 		stdout: Flags.boolean({
 			char: "O",
-			description: "Write to stdout instead of a file."
+			description: "Write the output to stdout instead of a file."
 		}),
 		template: Flags.string({
 			char: "t",
-			default: "default",
-			description: "HTML template for the generated PDF file."
+			description: "Built-in template name or path to a template directory, defaults to \"default\". Overwrites the one defined in front-matter."
 		}),
 		title: Flags.string({
 			char: "T",
-			description: "Overwrite document title."
+			description: "Document title. Overwrites the one defined in front-matter or the template."
 		}),
 		language: Flags.string({
 			char: "l",
-			description: "Language code for template translations. Overwrites the one defined in front-matter and template settings."
+			description: "Language for template translations. Overwrites the one defined in front-matter and template settings."
 		}),
 		browser: Flags.string({
 			char: "b",
-			description: "Browser path that is going to be used for the PDF generation.",
-			default: "/usr/bin/brave"
+			description: "Browser executable used for printing. Discovered automatically when omitted (Brave, Chrome, Chromium, Edge)."
+		}),
+		continuous: Flags.boolean({ description: "Render the PDF as a single continuous page without page breaks." }),
+		preview: Flags.boolean({
+			char: "p",
+			description: "Rebuild whenever the input, the template or its assets change, show the HTML and the PDF in a live preview and rewrite the output file when there is one."
 		}),
-		watch: Flags.boolean({
-			char: "w",
-			description: "Watch the changes on the given file."
+		host: Flags.string({
+			description: "Loopback host for the preview server, it serves the files next to the input and is never exposed to the network.",
+			options: [
+				"127.0.0.1",
+				"localhost",
+				"::1"
+			],
+			default: "127.0.0.1"
 		}),
-		dev: Flags.boolean({
-			char: "d",
-			description: "Run with Chrome browser instead of publishing the file."
+		port: Flags.integer({
+			description: "Port for the preview server, random when 0.",
+			default: 0
 		}),
-		continuous: Flags.boolean({ description: "Render PDF as a single continuous page without page breaks." })
+		open: Flags.boolean({
+			description: "Open the preview window, --no-open keeps rebuilding and writing without one.",
+			default: true,
+			allowNo: true
+		}),
+		sign: Flags.boolean({ description: "Sign the PDF with a qualified electronic signature through ID Austria (A-Trust)." }),
+		["sign-provider"]: Flags.string({ description: "Signature provider, defaults to a-trust. Overwrites the one defined in front-matter and template settings." }),
+		["sign-certificate"]: Flags.string({ description: "Signer certificate (DER or PEM) used for the visible signature block and to verify the returned signature." })
 	};
 	static args = {
-		file: Args.string({ description: "File to be processed." }),
+		file: Args.string({
+			description: "Markdown or yaml file to render.",
+			ignoreStdin: true
+		}),
 		output: Args.string({
-			description: "Output file that will be generated. Overwrites the one define in front-matter.",
-			required: false
+			description: "Output file. Overwrites the one defined in front-matter.",
+			required: false,
+			ignoreStdin: true
 		})
 	};
-	nunjucks = Nunjucks.configure({
-		autoescape: false,
-		throwOnUndefined: true,
-		trimBlocks: true,
-		lstripBlocks: false
-	});
-	cs;
-	fs;
-	i18n;
+	printer;
 	browser;
-	register(cli) {
-		return {
-			...cli,
-			providers: [...cli.providers ?? [], I18nService]
-		};
+	register(_cli, options) {
+		const cli = CliModule.forRoot({
+			...options,
+			logger: { stderr: true }
+		});
+		cli.imports.push(PrinterModule.forRoot({ browser: this.flags.browser }));
+		return cli;
 	}
 	async shouldRunBefore() {
-		this.cs = this.app.get(ConfigService);
-		this.fs = this.app.get(FileSystemService);
-		this.i18n = this.app.get(I18nService);
 		await this.app.get(ParserService).register(JsonParser, YamlParser);
-		this.nunjucks.addFilter("markdown_to_html", (markdown) => {
-			return new showdown.Converter().makeHtml(markdown);
-		});
-		this.tasks.options = { silentRendererCondition: true };
-		if (!this.args.file && !this.flags.stdin) throw new Error("Either --stdin or file argument must be provided.");
+		this.printer = this.app.get(PrinterService);
+		this.browser = this.app.get(BrowserService);
 	}
 	async run() {
-		this.tasks.add([{ task: async (ctx) => {
-			if (this.args.file) {
-				ctx.file = isAbsolute(this.args.file) ? this.args.file : join(process.cwd(), this.args.file);
-				if (!this.fs.exists(ctx.file)) throw new Error(`File does not exists: ${ctx.file}`);
-				this.logger.info("Loading file: %s", ctx.file);
-				ctx.content = await this.fs.read(ctx.file);
-			} else ctx.content = this.flags.stdin;
-			switch (this.flags["input-filetype"] ? this.flags["input-filetype"] : extname(ctx.file).replace(/^\./, "")) {
-				case "md": {
-					const data = graymatter(ctx.content);
-					ctx.content = data.content;
-					ctx.metadata = data.data;
-					break;
-				}
-				case "yaml":
-				case "yml":
-					ctx.metadata = await this.app.get(ParserService).parse(ctx.file, ctx.content);
-					break;
-				default: throw new Error("File type is not accepted.");
-			}
-		} }, { task: async (ctx) => {
-			const template = ctx.metadata?.template ?? this.flags.template;
-			ctx.templates = (/* @__PURE__ */ new RegExp(/\.\.?\//)).test(template) ? join(process.cwd(), template) : join(this.config.root, TEMPLATE_DIRECTORY, template);
-			this.logger.info("Loading template: %s from %s", template, ctx.templates);
-			await Promise.all(RequiredTemplateFiles.map(async (file) => {
-				const current = join(ctx.templates, file);
-				if (!this.fs.exists(current)) throw new Error(`Template does not exists: ${current}`);
-			}));
-			const paths = {
-				["settings.json"]: join(ctx.templates, "settings.json"),
-				["main.css"]: join(ctx.templates, "main.css"),
-				["tailwind.css"]: join(ctx.templates, "tailwind.css"),
-				["header.html"]: join(ctx.templates, "header.html"),
-				["footer.html"]: join(ctx.templates, "footer.html"),
-				["template.html.j2"]: join(ctx.templates, "template.html.j2")
-			};
-			const title = ctx.metadata?.document_title ?? this.flags.title;
-			ctx.options = await this.cs.extend([paths["settings.json"], {
-				dest: this.args?.output ?? ctx.metadata?.dest ?? `${basename(this.args.file, extname(this.args.file))}.${this.flags["output-filetype"]}`,
-				...title ? { document_title: title } : {},
-				launch_options: { executablePath: this.flags.browser }
-			}]);
-			ctx.renderContinuous = this.flags.continuous || ctx.metadata?.continuous === true || ctx.options.continuous === true;
-			this.flags.stdout ??= ctx.metadata.stdout;
-			if (this.flags.stdout) ctx.options.dest = "stdout";
-			if (this.flags["output-filetype"] === "html" || ctx.metadata["output-filetype"] === "html") ctx.options.as_html = true;
-			this.logger.debug("Options: %o", ctx.options);
-			if (this.fs.exists(paths["header.html"])) {
-				this.logger.debug("Header exists for template.");
-				ctx.options.pdf_options.headerTemplate = await this.fs.read(paths["header.html"]);
-			}
-			if (this.fs.exists(paths["footer.html"])) {
-				this.logger.debug("Footer exists for template.");
-				ctx.options.pdf_options.footerTemplate = await this.fs.read(paths["footer.html"]);
-			}
-			if (this.fs.exists(paths["template.html.j2"])) {
-				this.logger.debug("Design template exists for template.");
-				ctx.template = await this.fs.read(paths["template.html.j2"]);
-				this.logger.debug("Metadata: %o", ctx.metadata);
-			}
-			if (this.fs.exists(paths["main.css"])) {
-				this.logger.debug("CSS exists for template.");
-				ctx.options.css = await this.fs.read(paths["main.css"]);
-			}
-			if (this.fs.exists(paths["tailwind.css"])) {
-				this.logger.debug("Tailwind CSS exists for template: %s -> %s", paths["tailwind.css"]);
-				ctx.options.css = await postcss([tailwind({ base: ctx.templates })]).process(await this.fs.read(paths["tailwind.css"]), { from: paths["tailwind.css"] }).then((result) => result.css);
-			}
-			await this.applyTranslations(ctx);
-			await this.applyDocumentTitle(ctx);
-		} }]);
-	}
-	async shouldRunAfter(ctx) {
-		if (this.flags.watch) {
-			this.logger.info("Running in watch mode.");
-			watch([
-				TEMPLATE_DIRECTORY,
-				this.args.file,
-				join(ctx.templates, "**/*")
-			]).on("change", async () => {
-				await this.run();
-				const ctx = await this.runTasks();
-				this.logger.info("Waiting for the next change.");
-				return this.runMd2Pdf(ctx).catch((err) => {
-					this.logger.error(err);
-				});
-			});
-			return this.runMd2Pdf(ctx);
-		}
-		await this.runMd2Pdf(ctx);
-		if (this.browser) await this.browser.close();
+		const flags = {
+			file: this.flags.stdin ? void 0 : this.args.file,
+			output: this.flags.stdin ? this.args.output ?? this.args.file : this.args.output,
+			stdin: this.flags.stdin ? await text(process.stdin) : void 0,
+			inputFiletype: this.flags["input-filetype"],
+			outputFiletype: this.flags["output-filetype"],
+			stdout: this.flags.stdout,
+			template: this.flags.template,
+			title: this.flags.title,
+			language: this.flags.language,
+			continuous: this.flags.continuous,
+			sign: this.flags.sign,
+			signProvider: this.flags["sign-provider"],
+			signCertificate: this.flags["sign-certificate"]
+		};
+		if (this.flags.preview) await this.session(flags);
+		else await this.print(flags);
 	}
-	context(ctx) {
-		const context = {
-			...ctx.metadata ?? {},
-			content: ctx.content
+	async print(flags) {
+		const input = await this.printer.input(flags);
+		const ctx = {
+			input,
+			options: await this.printer.options(flags, input)
 		};
-		if (ctx.t) {
-			context.t = ctx.t;
-			context.language = ctx.language;
+		this.logger.debug("Options: %o", ctx.options);
+		await this.printer.prepare(ctx);
+		const document = await this.printer.document(ctx, await this.printer.bundle(ctx.options));
+		let { content } = await this.printer.output(ctx, document);
+		if (ctx.signature) {
+			content = await this.printer.sign(ctx, content);
+			this.logger.info("Document is signed.");
 		}
-		return context;
-	}
-	async applyDocumentTitle(ctx) {
-		const title = ctx.options.document_title ?? this.args.file;
-		if (!title) return;
-		ctx.options.document_title = this.nunjucks.renderString(title, this.context(ctx));
-		this.logger.info("Document title will be: %s", ctx.options.document_title);
+		await this.write(ctx, content);
 	}
-	async applyTranslations(ctx) {
-		ctx.language = this.flags.language ?? ctx.metadata?.language ?? ctx.options.i18n?.language ?? "en";
-		ctx.t = await this.i18n.load(join(ctx.templates, I18N_DIRECTORY), {
-			language: ctx.language,
-			fallback: ctx.options.i18n?.fallback
+	async session(flags) {
+		if (flags.stdout) throw new Error("Writing to stdout is not supported with --preview.");
+		const session = this.app.get(SessionService);
+		const preview = this.app.get(PreviewService);
+		let writes = Promise.resolve();
+		session.on("building", () => preview.building());
+		session.on("failed", (err) => {
+			this.logger.error(err.message);
+			preview.failed(err);
 		});
-		if (ctx.t) this.logger.info("Rendering with language: %s", ctx.language);
-	}
-	continuousBrowser(browser) {
-		return new Proxy(browser, { get: (target, property, receiver) => {
-			if (property !== "newPage") {
-				const value = Reflect.get(target, property, receiver);
-				return typeof value === "function" ? value.bind(target) : value;
-			}
-			return async () => {
-				const page = await browser.newPage();
-				const pdf = page.pdf.bind(page);
-				page.pdf = async (pdfOptions = {}) => {
-					const parsed = parsePDFOptions(pdfOptions, "cm");
-					const width = parsed.landscape ? parsed.height : parsed.width;
-					const margin = parsed.margin;
-					const viewport = page.viewport();
-					await page.setViewport({
-						width: Math.ceil(Math.max(width - margin.left - margin.right, 1) * unitToPixels.cm),
-						height: viewport?.height ?? 800,
-						deviceScaleFactor: viewport?.deviceScaleFactor ?? 1
-					});
-					const contentHeight = await page.evaluate(async () => {
-						if ("fonts" in document) await document.fonts.ready;
-						await Promise.all(Array.from(document.images).map((image) => {
-							if (image.complete) return;
-							return new Promise((resolve) => {
-								image.addEventListener("load", resolve, { once: true });
-								image.addEventListener("error", resolve, { once: true });
-							});
-						}));
-						const bodyTop = document.body.getBoundingClientRect().top;
-						const bottom = Math.max(document.body.getBoundingClientRect().bottom, ...Array.from(document.body.querySelectorAll("*")).map((element) => element.getBoundingClientRect().bottom));
-						return Math.max(document.body.scrollHeight, document.documentElement.scrollHeight, document.body.getBoundingClientRect().height, document.documentElement.getBoundingClientRect().height, bottom - bodyTop);
-					});
-					const height = parsePDFOptions({ height: Math.ceil(contentHeight + unitToPixels.cm) }, "cm").height + margin.top + margin.bottom;
-					const options = {
-						...pdfOptions,
-						width: `${width}cm`,
-						height: `${height}cm`,
-						landscape: false
-					};
-					delete options.format;
-					return pdf(options);
-				};
-				return page;
-			};
-		} });
-	}
-	async runMd2Pdf(ctx) {
-		const options = merge(MergeStrategy.EXTEND, { basedir: process.cwd() }, defaultConfig, ctx.options, { devtools: this.flags.dev });
-		if (!this.browser) {
-			const browser = await puppeteer.launch({
-				devtools: options.devtools,
-				...options.launch_options
-			});
-			this.browser = ctx.renderContinuous ? this.continuousBrowser(browser) : browser;
-		}
-		const server = await serveDirectory(ctx.options);
-		options.port = server.address().port;
-		let output;
-		if (ctx.template) {
-			this.logger.info("Rendering as template.");
-			output = await convertMdToPdf({ content: this.nunjucks.renderString(ctx.template, this.context(ctx)) }, options, { browser: this.browser });
-		} else {
-			this.logger.info("Rendering as plain file.");
-			output = await convertMdToPdf({ content: ctx.content }, options, { browser: this.browser });
-		}
-		await new Promise((resolve, reject) => server.close((err) => {
-			if (err) return reject(err);
-			resolve(null);
-		}));
-		if (output) {
-			if (this.flags.stdout) {
-				process.stdout.write(output.content);
+		session.on("ready", async (build) => {
+			preview.ready(build);
+			if (!build.ctx.options.dest) {
+				this.logger.info("Rebuilt in %dms.", build.ms);
 				return;
 			}
-			if (!output.filename) throw new Error("Output should either be defined with the variable or front-matter.");
-			this.logger.info("Output file will be: %s", output.filename);
-			await this.fs.mkdir(dirname(output.filename));
-			this.logger.info("Writing file to output: %s", output.filename);
-			await this.fs.write(output.filename, output.content);
+			session.ignore(build.ctx.options.dest);
+			writes = writes.then(() => this.write(build.ctx, build.output)).catch((err) => this.logger.error(err.message));
+			await writes;
+		});
+		if (flags.sign) this.logger.warn("Signing is skipped while previewing, run without --preview to sign the document.");
+		process.removeAllListeners("SIGINT");
+		process.removeAllListeners("SIGTERM");
+		const stopped = new Promise((resolve) => {
+			process.once("SIGINT", () => resolve());
+			process.once("SIGTERM", () => resolve());
+		});
+		await session.start(flags);
+		const url = await preview.listen({
+			host: this.flags.host,
+			port: this.flags.port
+		});
+		this.logger.info("Preview is running at %s, press Ctrl+C to stop.", url);
+		await Promise.race([stopped, this.flags.open ? preview.open(this.browser.executable(), url) : new Promise(() => void 0)]);
+		await preview.close();
+		await session.stop();
+		await writes;
+	}
+	async write(ctx, content) {
+		const { dest } = ctx.options;
+		if (!dest) {
+			if (!this.flags.stdout) throw new Error("No output file to write, pass an output argument, set dest in front-matter or use --stdout.");
+			process.stdout.write(content);
+			return;
 		}
+		await mkdir(dirname(dest), { recursive: true });
+		await writeFileAtomic(dest, content);
+		this.logger.info("Written: %s", dest);
 	}
 };
-
 //#endregion
-export { MDPrinter as default };
+export { MDPrinter as default };

package/dist/components/Date.svelte

@@ -0,0 +1 @@
+<span class="date"></span>

package/dist/components/Markdown.svelte

@@ -0,0 +1,20 @@
+<!--
+  @component
+  The markdown document, with directives rendered as components. Styled by github-markdown-css when the template imports it.
+-->
+<script>
+  import { getContext } from 'svelte'
+
+  import Nodes from './Nodes.svelte'
+
+  /** @type {{ class?: string }} */
+  let { class: className = '' } = $props()
+</script>
+
+<article class="markdown-body {className}"><Nodes nodes={getContext('md-printer:markdown')} /></article>
+
+<style>
+  :global(.page-break) {
+    break-after: page;
+  }
+</style>

package/dist/components/Nodes.svelte

@@ -0,0 +1,32 @@
+<!--
+  @component
+  Resolved markdown: HTML as is, directives as the components registered for them, and the elements around a directive as elements.
+-->
+<script>
+  import { getContext } from 'svelte'
+
+  // eslint-disable-next-line import/no-self-import -- a Svelte 5 component recurses by importing itself
+  import Nodes from './Nodes.svelte'
+
+  /** @type {{ nodes: import('../interfaces/markdown.interface.js').MarkdownNode[] }} */
+  let { nodes } = $props()
+
+  /** @type {Record<string, import('svelte').Component<any>>} */
+  const components = getContext('md-printer:components')
+</script>
+
+{#each nodes as node, index (index)}
+  {#if node.type === 'html'}
+    <!-- eslint-disable-next-line svelte/no-at-html-tags -- markdown input is trusted, same as the document itself -->
+    {@html node.html}
+  {:else if node.type === 'element'}
+    <svelte:element this={node.tag} {...node.attributes}><Nodes nodes={node.children} /></svelte:element>
+  {:else}
+    {@const Component = components[node.name]}
+    {#if node.children.length}
+      <Component {...node.props}><Nodes nodes={node.children} /></Component>
+    {:else}
+      <Component {...node.props} />
+    {/if}
+  {/if}
+{/each}

package/dist/components/Page.svelte

@@ -0,0 +1,20 @@
+<!--
+  @component
+  Page layout: renders `children` as the document body and the `header` / `footer` snippets into the printed header and footer of every page.
+-->
+<script>
+  import { getContext } from 'svelte'
+
+  /** @type {{ header?: import('svelte').Snippet, footer?: import('svelte').Snippet, children?: import('svelte').Snippet }} */
+  let { header, footer, children } = $props()
+
+  const mode = getContext('md-printer:mode')
+</script>
+
+{#if mode === 'header'}
+  {@render header?.()}
+{:else if mode === 'footer'}
+  {@render footer?.()}
+{:else}
+  {@render children?.()}
+{/if}

package/dist/components/PageBreak.svelte

@@ -0,0 +1,5 @@
+<!--
+  @component
+  Starts a new page in the printed PDF. In markdown, `<div class="page-break"></div>` does the same.
+-->
+<div class="page-break" style="break-after: page"></div>

package/dist/components/PageNumber.svelte

@@ -0,0 +1 @@
+<span class="pageNumber"></span>

package/dist/components/SignatureBlock.svelte

@@ -0,0 +1,56 @@
+<!--
+  @component
+  Visible block for a digitally signed document, filled from the `signature` prop md-printer passes to templates when signing is enabled.
+  Styled with Tailwind classes, so the template needs a `<style lang="postcss">` block importing Tailwind.
+-->
+<script>
+  /**
+   * @type {{
+   *   signature: { date: string, name?: string, issuer?: string, serial?: string },
+   *   labels?: { title?: string, by?: string, date?: string, issuer?: string, verify?: string },
+   *   class?: string
+   * }}
+   */
+  let { signature, labels = {}, class: className = '' } = $props()
+
+  const text = $derived({
+    title: 'Digitally signed',
+    by: 'Signed by',
+    date: 'Date',
+    issuer: 'Certificate',
+    verify: 'This document carries a qualified electronic signature. Verify it at',
+    ...labels
+  })
+</script>
+
+<div class="w-full overflow-hidden rounded-xl border-y-2 shadow-md shadow-gray-300 border-gray-900! text-xs {className}">
+  <div class="flex items-center gap-3 px-5 py-3 bg-gray-900 text-white">
+    <svg class="w-5 h-5 shrink-0" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+      <path d="M12 3l7 3v6c0 4.5-3 7.5-7 9-4-1.5-7-4.5-7-9V6l7-3z" />
+      <path d="M9 12l2 2 4-4" />
+    </svg>
+    <span class="font-extrabold uppercase tracking-wider">{text.title}</span>
+  </div>
+  <div class="flex flex-col px-5 py-2">
+    {#if signature.name}
+      <div class="flex justify-between gap-4 py-2">
+        <span class="font-semibold text-gray-400">{text.by}</span>
+        <span class="font-semibold text-right">{signature.name}</span>
+      </div>
+    {/if}
+    <div class="flex justify-between gap-4 py-2 border-t border-t-gray-100/30">
+      <span class="font-semibold text-gray-400">{text.date}</span>
+      <span class="text-right">{signature.date}</span>
+    </div>
+    {#if signature.issuer}
+      <div class="flex justify-between gap-4 py-2 border-t border-t-gray-100/30">
+        <span class="font-semibold text-gray-400">{text.issuer}</span>
+        <span class="text-right text-[0.6rem]">{signature.issuer} · {signature.serial}</span>
+      </div>
+    {/if}
+  </div>
+  <p class="px-5 py-3 bg-gray-50 text-[0.6rem] text-gray-400 leading-snug">
+    {text.verify}
+    <a href="https://www.signaturpruefung.gv.at" class="font-semibold text-gray-900 underline">signaturpruefung.gv.at</a>
+  </p>
+</div>

package/dist/components/Title.svelte

@@ -0,0 +1 @@
+<span class="title"></span>

package/dist/components/TotalPages.svelte

@@ -0,0 +1 @@
+<span class="totalPages"></span>

package/dist/components/index.ts

@@ -0,0 +1,8 @@
+export { default as Date } from './Date.svelte'
+export { default as Markdown } from './Markdown.svelte'
+export { default as Page } from './Page.svelte'
+export { default as PageBreak } from './PageBreak.svelte'
+export { default as PageNumber } from './PageNumber.svelte'
+export { default as SignatureBlock } from './SignatureBlock.svelte'
+export { default as Title } from './Title.svelte'
+export { default as TotalPages } from './TotalPages.svelte'

package/dist/constants/file.constants.mjs

@@ -1,10 +1,4 @@
 //#region src/constants/file.constants.ts
-const OUTPUT_FILE_ACCEPTED_TYPES = [".pdf"];
-const INPUT_FILE_ACCEPTED_TYPES = [
-	".md",
-	".yml",
-	".yaml"
-];
 let OutputFileType = /* @__PURE__ */ function(OutputFileType) {
 	OutputFileType["PDF"] = "pdf";
 	OutputFileType["HTML"] = "html";
@@ -16,6 +10,5 @@ let InputFileType = /* @__PURE__ */ function(InputFileType) {
 	InputFileType["YAML_SHORT"] = "yml";
 	return InputFileType;
 }({});
-
 //#endregion
-export { INPUT_FILE_ACCEPTED_TYPES, InputFileType, OUTPUT_FILE_ACCEPTED_TYPES, OutputFileType };
+export { InputFileType, OutputFileType };

package/dist/constants/index.mjs

@@ -1,4 +1,3 @@
-import { DEFAULT_LANGUAGE, I18N_ACCEPTED_TYPES, I18N_DIRECTORY, RequiredTemplateFiles, TEMPLATE_DIRECTORY, TemplateFiles } from "./template.constants.mjs";
-import { INPUT_FILE_ACCEPTED_TYPES, InputFileType, OUTPUT_FILE_ACCEPTED_TYPES, OutputFileType } from "./file.constants.mjs";
-
-export { DEFAULT_LANGUAGE, I18N_ACCEPTED_TYPES, I18N_DIRECTORY, INPUT_FILE_ACCEPTED_TYPES, InputFileType, OUTPUT_FILE_ACCEPTED_TYPES, OutputFileType, RequiredTemplateFiles, TEMPLATE_DIRECTORY, TemplateFiles };
+import { ContextKey, DEFAULT_HIGHLIGHT_STYLE, DEFAULT_LANGUAGE, DEFAULT_PDF_OPTIONS, DEFAULT_TEMPLATE, DIRECTIVE_TAG, Directory, I18N_ACCEPTED_TYPES, MediaType, ModuleSpecifier, PAGE_BREAK_CLASS, PRINTER_MODULE_OPTIONS, RenderMode, TAILWIND_STYLE_LANG, TemplateFiles } from "./template.constants.mjs";
+import { InputFileType, OutputFileType } from "./file.constants.mjs";
+export { ContextKey, DEFAULT_HIGHLIGHT_STYLE, DEFAULT_LANGUAGE, DEFAULT_PDF_OPTIONS, DEFAULT_TEMPLATE, DIRECTIVE_TAG, Directory, I18N_ACCEPTED_TYPES, InputFileType, MediaType, ModuleSpecifier, OutputFileType, PAGE_BREAK_CLASS, PRINTER_MODULE_OPTIONS, RenderMode, TAILWIND_STYLE_LANG, TemplateFiles };