@lupinum/nuxt-pdf 0.4.0-beta.1 → 0.4.0-beta.3

package/dist/runtime/server/engine/fonts.js

@@ -1,5 +1,5 @@
 import FontStore from "@react-pdf/font";
-const isBundledFontSource = (src) => /^data:font\/(?:otf|ttf);base64,[A-Za-z0-9+/]+={0,2}$/.test(src);
+const isBundledFontSource = (src) => /^data:font\/(?:otf|ttf|woff2);base64,[A-Za-z0-9+/]+={0,2}$/.test(src);
 export const createPdfFontStore = (fonts = []) => {
   const fontStore = new FontStore();
   for (const font of fonts) {

package/dist/runtime/server/engine/render-document.d.ts

@@ -1,5 +1,6 @@
 import { type DocumentNode, type SafeDocumentNode } from '@react-pdf/layout';
 import { type PdfFontStore } from './fonts.js';
+import type { PdfLayoutWarning } from '../../shared/template.js';
 import { type RenderLimits } from '../render-limits.js';
 export interface PdfEngineOptions {
     compress?: boolean;
@@ -16,6 +17,12 @@ type DocumentMetadata = DocumentNode['props'];
 export declare const layoutPdfTree: (document: DocumentNode, fontStore: PdfFontStore, limits?: RenderLimits) => Promise<SafeDocumentNode>;
 /** The number of laid-out pages in a serialized document. */
 export declare const countPages: (layout: SafeDocumentNode) => number;
+/**
+ * Find blocks that cannot fit on any ordinary page because pagination is not
+ * allowed to split them. No text, ids, or other authored content enters the
+ * public diagnostics object.
+ */
+export declare const collectLayoutWarnings: (layout: SafeDocumentNode) => PdfLayoutWarning[];
 /**
  * Map every `id` (named destination) to the **first** 1-based page it appears
  * on. `id` is the key `render/src/operations/setDestination.ts` emits and that a

package/dist/runtime/server/engine/render-document.js

@@ -12,6 +12,7 @@ import {
 import {
   PDF_PRIMITIVES
 } from "../../authoring.js";
+import { PDF_PRIMITIVE_NAMES } from "../../renderer/index.js";
 import {
   enforceMaxPages
 } from "../render-limits.js";
@@ -117,6 +118,52 @@ const visitPageNodes = (page, visit) => {
 };
 const documentPages = (layout) => layout.children ?? [];
 export const countPages = (layout) => documentPages(layout).length;
+const NON_WRAPPING_NODE_TYPES = /* @__PURE__ */ new Set([
+  PDF_PRIMITIVES.Image,
+  PDF_PRIMITIVES.Note,
+  PDF_PRIMITIVES.Svg
+]);
+const WARNING_NODE_TYPES = /* @__PURE__ */ new Set([
+  PDF_PRIMITIVES.Image,
+  PDF_PRIMITIVES.Link,
+  PDF_PRIMITIVES.Note,
+  PDF_PRIMITIVES.Svg,
+  PDF_PRIMITIVES.Text,
+  PDF_PRIMITIVES.View
+]);
+const finiteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+const roundedPoints = (value) => Math.round(value * 100) / 100;
+const pageContentHeight = (page) => {
+  const style = page.style;
+  const pageHeight = finiteNumber(style?.height) ?? finiteNumber(page.box.height);
+  if (pageHeight === void 0) return void 0;
+  const paddingTop = finiteNumber(page.box.paddingTop) ?? finiteNumber(style?.paddingTop) ?? 0;
+  const paddingBottom = finiteNumber(page.box.paddingBottom) ?? finiteNumber(style?.paddingBottom) ?? 0;
+  return pageHeight - paddingTop - paddingBottom;
+};
+const cannotWrap = (node) => NON_WRAPPING_NODE_TYPES.has(node.type) || node.props.wrap === false;
+export const collectLayoutWarnings = (layout) => {
+  const warnings = [];
+  documentPages(layout).forEach((pageNode, pageIndex) => {
+    if (!("props" in pageNode)) return;
+    const page = pageNode;
+    const availableHeight = pageContentHeight(page);
+    if (availableHeight === void 0 || availableHeight <= 0) return;
+    visitPageNodes(page, (node) => {
+      if (node === page || node.props.fixed === true || !WARNING_NODE_TYPES.has(node.type) || !cannotWrap(node)) return;
+      const nodeHeight = finiteNumber(node.box.height);
+      if (nodeHeight === void 0 || nodeHeight <= availableHeight + 1e-3) return;
+      warnings.push({
+        code: "PDF_UNBREAKABLE_NODE_OVERFLOW",
+        pageNumber: pageIndex + 1,
+        nodeType: PDF_PRIMITIVE_NAMES[node.type],
+        nodeHeight: roundedPoints(nodeHeight),
+        availableHeight: roundedPoints(availableHeight)
+      });
+    });
+  });
+  return warnings;
+};
 const nodeId = (node) => {
   const id = node.props?.id;
   return typeof id === "string" && id.length > 0 ? id : void 0;

package/dist/runtime/server/index.d.ts

@@ -2,4 +2,4 @@ export { createPdfPreviewEntry, createPdfRegistry, createPdfTemplate, } from './
 export { NuxtPdfError, PDF_ERROR_CODES, } from '../shared/errors.js';
 export type { PdfErrorCode } from '../shared/errors.js';
 export type { PdfPreviewEntry, PdfPreviewEntryOptions, PdfRegistry, PdfRegistryEntries, } from './registry.js';
-export type { PdfRenderDiagnostics, PdfRenderResult, PdfComponentProps, PdfTemplate, } from '../shared/template.js';
+export type { PdfLayoutWarning, PdfRenderDiagnostics, PdfRenderResult, PdfComponentProps, PdfTemplate, } from '../shared/template.js';

package/dist/runtime/server/preview.js

@@ -99,6 +99,10 @@ const htmlResponse = (title, content, status = 200) => new Response(`<!doctype h
       .font-faces .label { color: #8b948b; font-size: 0.78rem; letter-spacing: 0.04em; text-transform: uppercase; margin-bottom: 8px; }
       .font-faces ul { list-style: none; margin: 0; padding: 0; display: grid; gap: 6px; }
       .font-faces li { color: #d7ddd7; font-size: 0.85rem; line-height: 1.5; }
+      .layout-warnings { border: 1px solid #765b23; background: #211b0f; border-left: 3px solid #e2b653; border-radius: 10px; padding: 12px 16px; margin-bottom: 16px; }
+      .layout-warnings .label { color: #e8c977; font-size: 0.78rem; letter-spacing: 0.04em; text-transform: uppercase; margin-bottom: 8px; }
+      .layout-warnings ul { margin: 0; padding-left: 20px; display: grid; gap: 6px; }
+      .layout-warnings li { color: #f0dfb2; font-size: 0.85rem; line-height: 1.5; }
       .error { border: 1px solid #6b2f2b; background: #1d1210; border-left: 3px solid #ef786f; border-radius: 10px; padding: 18px 20px; }
       .error h2 { margin: 0 0 12px; font-size: 1.1rem; color: #f3d7d3; }
       .error dl { display: grid; grid-template-columns: max-content 1fr; gap: 6px 16px; margin: 0 0 12px; }
@@ -173,13 +177,17 @@ const diagnosticsPanel = (diagnostics) => {
     stat("Size", formatBytes(diagnostics.byteLength)),
     stat("Pages", String(diagnostics.pageCount)),
     stat("Layout passes", String(diagnostics.passes)),
+    stat("Layout warnings", String(diagnostics.layoutWarnings.length)),
     stat("Font faces", String(diagnostics.registeredFontFaces.length))
   ].join("");
+  const warnings = diagnostics.layoutWarnings.length > 0 ? `<div class="layout-warnings"><div class="label">Layout warnings</div><ul>${diagnostics.layoutWarnings.map(
+    (warning) => `<li><strong>${escapeHtml(warning.nodeType)}</strong> on page ${warning.pageNumber} is ${warning.nodeHeight} pt tall, but only ${warning.availableHeight} pt is available. Allow it to wrap or make it smaller.</li>`
+  ).join("")}</ul></div>` : "";
   const fonts = diagnostics.registeredFontFaces.length > 0 ? `<div class="font-faces"><div class="label">Registered font faces</div><ul>${diagnostics.registeredFontFaces.map((face) => {
     const attributes = [face.fontWeight, face.fontStyle].filter((value) => value !== void 0);
     return `<li>${escapeHtml(face.family)}${attributes.length > 0 ? ` \u2014 ${escapeHtml(attributes.join(" "))}` : ""}</li>`;
   }).join("")}</ul></div>` : "";
-  return `<div class="diagnostics">${stats}</div>${fonts}`;
+  return `<div class="diagnostics">${stats}</div>${warnings}${fonts}`;
 };
 const errorDetails = (error, fallbackKey, fallbackFile) => {
   const code = error instanceof NuxtPdfError ? error.code : "PDF_RENDER_ERROR";

package/dist/runtime/server/registry.d.ts

@@ -4,7 +4,7 @@ import { type PdfImageAssetMap } from './assets/resolve-asset.js';
 import type { RemoteAssetPolicy } from './assets/remote.js';
 import { type PdfRenderLimits } from './render-limits.js';
 import type { BundledPdfFontDescriptor } from '../fonts.js';
-export type { PdfRenderDiagnostics } from '../shared/template.js';
+export type { PdfLayoutWarning, PdfRenderDiagnostics, } from '../shared/template.js';
 export interface PdfTemplateRuntimeOptions {
     assets?: PdfImageAssetMap;
     file?: string;

package/dist/runtime/server/registry.js

@@ -10,7 +10,11 @@ import {
   createPdfImageResolutionState,
   resolvePdfImageAssets
 } from "./assets/resolve-asset.js";
-import { countPages, renderDocument } from "./engine/render-document.js";
+import {
+  collectLayoutWarnings,
+  countPages,
+  renderDocument
+} from "./engine/render-document.js";
 import { renderDocumentMultiPass } from "./engine/layout-passes.js";
 import {
   createRenderLimits,
@@ -140,6 +144,7 @@ const renderTemplate = async (component, props, metadata, options, maxPasses, li
       );
       return {
         bytes: result2.bytes,
+        layoutWarnings: collectLayoutWarnings(result2.layout),
         metadata: completedMetadata(live.document, metadata),
         passes: result2.passes,
         pageCount: countPages(result2.layout)
@@ -150,6 +155,7 @@ const renderTemplate = async (component, props, metadata, options, maxPasses, li
     const result = await renderDocument(document, { fontStore, limits });
     return {
       bytes: result.bytes,
+      layoutWarnings: collectLayoutWarnings(result.layout),
       metadata: completedMetadata(mounted.document, metadata),
       passes: 1,
       pageCount: countPages(result.layout)
@@ -176,6 +182,7 @@ export const createPdfTemplate = (key, component, options = {}) => {
     const definitionMetadata = resolveMetadata(ref, definition, props);
     const {
       bytes,
+      layoutWarnings,
       metadata,
       passes,
       pageCount
@@ -189,6 +196,7 @@ export const createPdfTemplate = (key, component, options = {}) => {
     );
     const result = createPdfRenderResult(bytes, metadata, {
       durationMs: performance.now() - start,
+      layoutWarnings,
       pageCount,
       passes,
       registeredFontFaces: (options.fonts ?? []).map((font) => ({

package/dist/runtime/server/result.js

@@ -43,6 +43,7 @@ export const createPdfRenderResult = (source, metadata, diagnostics) => {
   const completedDiagnostics = Object.freeze({
     byteLength: bytes.byteLength,
     durationMs: diagnostics.durationMs,
+    layoutWarnings: Object.freeze(diagnostics.layoutWarnings.map((warning) => Object.freeze({ ...warning }))),
     pageCount: diagnostics.pageCount,
     passes: diagnostics.passes,
     registeredFontFaces: Object.freeze(diagnostics.registeredFontFaces.map((face) => Object.freeze({ ...face })))

package/dist/runtime/shared/index.d.ts

@@ -1,4 +1,4 @@
 export { NuxtPdfError, PDF_ERROR_CODES, } from './errors.js';
 export type { NuxtPdfErrorOptions, PdfErrorCode, } from './errors.js';
 export { PDF_DEFINITION_PROPERTY, } from './template.js';
-export type { PdfComponent, PdfComponentProps, PdfDefinition, PdfDisposition, PdfMetadataValue, PdfRenderDiagnostics, PdfRenderResult, PdfResponseInit, PdfTemplate, ResolvedPdfMetadata, } from './template.js';
+export type { PdfComponent, PdfComponentProps, PdfDefinition, PdfDisposition, PdfLayoutWarning, PdfMetadataValue, PdfRenderDiagnostics, PdfRenderResult, PdfResponseInit, PdfTemplate, ResolvedPdfMetadata, } from './template.js';

package/dist/runtime/shared/template.d.ts

@@ -41,8 +41,16 @@ export interface PdfRenderDiagnostics {
     readonly byteLength: number;
     readonly pageCount: number;
     readonly passes: number;
+    readonly layoutWarnings: readonly PdfLayoutWarning[];
     readonly registeredFontFaces: readonly PdfRegisteredFontFace[];
 }
+export interface PdfLayoutWarning {
+    readonly code: 'PDF_UNBREAKABLE_NODE_OVERFLOW';
+    readonly pageNumber: number;
+    readonly nodeType: 'PdfImage' | 'PdfLink' | 'PdfNote' | 'PdfSvg' | 'PdfText' | 'PdfView';
+    readonly nodeHeight: number;
+    readonly availableHeight: number;
+}
 export interface PdfRegisteredFontFace {
     readonly family: string;
     readonly fontStyle?: string;

package/dist/server.d.mts

@@ -0,0 +1,4 @@
+export { PdfRegistry, PdfRegistryEntries, createPdfRegistry, createPdfTemplate } from '../dist/runtime/server/registry.js';
+export { NuxtPdfError, PDF_ERROR_CODES, PdfErrorCode } from '../dist/runtime/shared/errors.js';
+export { usePdfPageNumbers } from '../dist/runtime/composables/index.js';
+export { PdfComponentProps, PdfDefinition, PdfRenderResult, PdfTemplate } from '../dist/runtime/shared/template.js';

package/dist/server.mjs

@@ -0,0 +1,3 @@
+export { createPdfRegistry, createPdfTemplate } from '../dist/runtime/server/registry.js';
+export { NuxtPdfError, PDF_ERROR_CODES } from '../dist/runtime/shared/errors.js';
+export { usePdfPageNumbers } from '../dist/runtime/composables/index.js';

package/dist/shared/nuxt-pdf.D3hUPqOJ.mjs

@@ -0,0 +1,203 @@
+import { PDF_STUB_NAMES } from '../../dist/runtime/components/stubs.js';
+import { joinURL } from 'ufo';
+import { Buffer } from 'node:buffer';
+import { pdfImageFormatFromKey, loadPdfImageAsset } from '../../dist/runtime/server/assets/resolve-asset.js';
+
+const generateAuthoringTypes = (componentsImport, composablesImport, definePdfImport) => `declare global {
+  const definePdf: typeof import(${JSON.stringify(definePdfImport)})['definePdf']
+  const usePdfPageNumbers: typeof import(${JSON.stringify(composablesImport)})['usePdfPageNumbers']
+}
+
+declare module 'vue' {
+  interface GlobalComponents {
+${PDF_STUB_NAMES.map((name) => `    ${name}: typeof import(${JSON.stringify(componentsImport)})['${name}']`).join("\n")}
+  }
+}
+
+export {}
+`;
+
+const compareText = (left, right) => {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+};
+const quote = (value) => JSON.stringify(value);
+const generatePdfPreviewConfig = (baseURL, buildAssetsDir) => `export const hmrClientPath = ${quote(joinURL(
+  baseURL.replace(/^\.\//, "/") || "/",
+  buildAssetsDir,
+  "@vite/client"
+))}
+`;
+const importPath = (filePath) => filePath.replaceAll("\\", "/");
+const runtimeOptionsSource = (options) => {
+  const assets = options.assets ?? [];
+  const fonts = options.fonts ?? [];
+  const { remote, limits } = options;
+  for (const asset of assets) {
+    if (asset.root !== void 0 === (asset.dataB64 !== void 0)) {
+      throw new TypeError(
+        `PDF image asset "${asset.key}" must declare exactly one of root or dataB64.`
+      );
+    }
+  }
+  if (assets.length === 0 && fonts.length === 0 && !remote && !limits) return [];
+  const lines = ["", "const __pdfRuntimeOptions = Object.freeze({"];
+  if (assets.length > 0) {
+    lines.push("  assets: Object.freeze({");
+    for (const asset of assets) {
+      const entry = asset.root !== void 0 ? `{ format: ${quote(asset.format)}, root: ${quote(asset.root)} }` : `{ dataB64: ${quote(asset.dataB64 ?? "")}, format: ${quote(asset.format)} }`;
+      lines.push(`    ${quote(asset.key)}: Object.freeze(${entry}),`);
+    }
+    lines.push("  }),");
+  }
+  if (fonts.length > 0) {
+    lines.push("  fonts: Object.freeze([");
+    for (const font of fonts) {
+      lines.push(`    Object.freeze(${JSON.stringify(font)}),`);
+    }
+    lines.push("  ]),");
+  }
+  if (remote) {
+    lines.push(`  remote: Object.freeze(${JSON.stringify(remote)}),`);
+  }
+  if (limits) {
+    lines.push(`  limits: Object.freeze(${JSON.stringify(limits)}),`);
+  }
+  lines.push("})");
+  return lines;
+};
+const orderedTemplates = (templates) => {
+  const result = [...templates].sort(
+    (left, right) => compareText(left.key, right.key)
+  );
+  const keys = /* @__PURE__ */ new Map();
+  for (const template of result) {
+    const duplicate = keys.get(template.key);
+    if (duplicate) {
+      throw new TypeError(
+        `Cannot generate duplicate PDF template key "${template.key}" from "${duplicate.filePath}" and "${template.filePath}".`
+      );
+    }
+    keys.set(template.key, template);
+  }
+  return result;
+};
+const validateOptions = (options) => {
+  if (options.runtimeImport.trim() === "") {
+    throw new TypeError("runtimeImport is required to generate the PDF registry.");
+  }
+};
+const generatePdfRuntimeRegistry = (templates, options) => {
+  validateOptions(options);
+  const ordered = orderedTemplates(templates);
+  const runtimeImports = options.development ? "createPdfPreviewEntry, createPdfRegistry, createPdfTemplate" : "createPdfRegistry, createPdfTemplate";
+  const lines = [
+    `import { ${runtimeImports} } from ${quote(options.runtimeImport)}`
+  ];
+  ordered.forEach((template, index) => {
+    lines.push(
+      `import __pdfTemplate${index} from ${quote(importPath(template.filePath))}`
+    );
+  });
+  const runtimeOptions = runtimeOptionsSource(options);
+  lines.push(...runtimeOptions, "", "const registry = createPdfRegistry({");
+  ordered.forEach((template, index) => {
+    const file = quote(`pdfs/${template.relativePath}`);
+    const runtimeArgument = options.development ? runtimeOptions.length > 0 ? `, { ...__pdfRuntimeOptions, file: ${file} }` : `, { file: ${file} }` : runtimeOptions.length > 0 ? ", __pdfRuntimeOptions" : "";
+    lines.push(
+      `  ${quote(template.key)}: createPdfTemplate(${quote(template.key)}, __pdfTemplate${index}${runtimeArgument}),`
+    );
+  });
+  lines.push("})");
+  if (options.development) {
+    lines.push("", "export const pdfPreview = Object.freeze({");
+    ordered.forEach((template, index) => {
+      lines.push(
+        `  ${quote(template.key)}: createPdfPreviewEntry(registry.pdf[${quote(template.key)}], __pdfTemplate${index}, { file: ${quote(`pdfs/${template.relativePath}`)} }),`
+      );
+    });
+    lines.push("})");
+  }
+  lines.push(
+    "",
+    "export const pdf = registry.pdf",
+    "export const renderPdf = registry.renderPdf",
+    "export const getPdfTemplate = registry.getPdfTemplate",
+    "export const pdfTemplateKeys = registry.pdfTemplateKeys",
+    `export { NuxtPdfError, PDF_ERROR_CODES } from ${quote(options.runtimeImport)}`,
+    ""
+  );
+  return lines.join("\n");
+};
+const generatePdfRegistryTypes = (templates, options) => {
+  validateOptions(options);
+  const ordered = orderedTemplates(templates);
+  const lines = [
+    `import type { PdfComponentProps, PdfRenderResult, PdfTemplate } from ${quote(options.runtimeImport)}`
+  ];
+  ordered.forEach((template, index) => {
+    lines.push(
+      "",
+      `type PdfComponent${index} = typeof import(${quote(importPath(template.filePath))})['default']`,
+      `type PdfProps${index} = PdfComponentProps<PdfComponent${index}>`
+    );
+  });
+  lines.push("", "export declare const pdf: {");
+  ordered.forEach((template, index) => {
+    lines.push(
+      `  readonly ${quote(template.key)}: PdfTemplate<PdfProps${index}>`
+    );
+  });
+  lines.push("}", "");
+  if (ordered.length === 0) {
+    lines.push(
+      "export declare function renderPdf(name: never, props: never): Promise<PdfRenderResult>",
+      "export declare function getPdfTemplate(name: never): never"
+    );
+  } else {
+    ordered.forEach((template, index) => {
+      lines.push(
+        `export declare function renderPdf(name: ${quote(template.key)}, props: PdfProps${index}): Promise<PdfRenderResult>`
+      );
+    });
+    lines.push(
+      "export declare function renderPdf(name: string, props: Record<string, unknown>, escapeHatch: { readonly unsafe: true }): Promise<PdfRenderResult>"
+    );
+    lines.push("");
+    ordered.forEach((template, index) => {
+      lines.push(
+        `export declare function getPdfTemplate(name: ${quote(template.key)}): PdfTemplate<PdfProps${index}>`
+      );
+    });
+  }
+  lines.push(
+    "",
+    `export declare const pdfTemplateKeys: readonly [${ordered.map((template) => quote(template.key)).join(", ")}]`,
+    "export type PdfTemplateKey = typeof pdfTemplateKeys[number]",
+    `export { NuxtPdfError, PDF_ERROR_CODES } from ${quote(options.runtimeImport)}`,
+    `export type { PdfErrorCode } from ${quote(options.runtimeImport)}`,
+    ""
+  );
+  return lines.join("\n");
+};
+
+async function preparePdfImageAssets(images, limits, development) {
+  const entries = [];
+  for (const image of images) {
+    const format = pdfImageFormatFromKey(image.key);
+    if (development) {
+      entries.push({ format, key: image.key, root: image.rootDir });
+      continue;
+    }
+    const loaded = await loadPdfImageAsset(image.key, {
+      roots: [image.rootDir],
+      maxBytes: limits.maxImageBytes,
+      maxPixels: limits.maxImagePixels
+    });
+    entries.push({ dataB64: Buffer.from(loaded.data).toString("base64"), format, key: image.key });
+  }
+  return entries;
+}
+
+export { generateAuthoringTypes as a, generatePdfRegistryTypes as b, generatePdfPreviewConfig as c, generatePdfRuntimeRegistry as g, preparePdfImageAssets as p };

package/dist/shared/{nuxt-pdf._V584vX4.mjs → nuxt-pdf.DMC_Rdsz.mjs}

@@ -1,7 +1,7 @@
 import { readdir, realpath, open, stat, readFile } from 'node:fs/promises';
 import { resolve, join, relative, isAbsolute, posix, sep, dirname, extname, win32 } from 'node:path';
 import { Buffer } from 'node:buffer';
-import { existsSync, statSync } from 'node:fs';
+import { existsSync, statSync, readFileSync } from 'node:fs';
 import { parse, compileScript, compileTemplate, babelParse } from '@vue/compiler-sfc';
 import remapping from '@jridgewell/remapping';
 import { transform } from 'esbuild';
@@ -185,6 +185,7 @@ const discoverPdfImageFiles = async (layers, isIgnored) => {
 };
 
 const DEFAULT_MAX_PDF_FONT_BYTES = 5 * 1024 * 1024;
+const DEFAULT_MAX_PDF_DECOMPRESSED_FONT_BYTES = 20 * 1024 * 1024;
 const FONT_WEIGHT_VALUES = {
   black: 900,
   bold: 700,
@@ -347,13 +348,53 @@ const validateDeclaration = (declaration) => {
   };
 };
 const detectFontFormat = (bytes) => {
-  if (bytes.byteLength < 12) return void 0;
+  if (bytes.byteLength < 4) return void 0;
   const isTrueType = bytes[0] === 0 && bytes[1] === 1 && bytes[2] === 0 && bytes[3] === 0;
   const isOpenType = bytes[0] === 79 && bytes[1] === 84 && bytes[2] === 84 && bytes[3] === 79;
+  const isWoff2 = bytes[0] === 119 && bytes[1] === 79 && bytes[2] === 70 && bytes[3] === 50;
   if (isTrueType) return "ttf";
   if (isOpenType) return "otf";
+  if (isWoff2) return "woff2";
   return void 0;
 };
+const validateWoff2Structure = (source, bytes) => {
+  if (bytes.byteLength < 48) {
+    throw fontError(source, "the WOFF2 header is corrupt or truncated.");
+  }
+  const data = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const flavor = data.readUInt32BE(4);
+  const declaredLength = data.readUInt32BE(8);
+  const tableCount = data.readUInt16BE(12);
+  const reserved = data.readUInt16BE(14);
+  const decompressedSize = data.readUInt32BE(16);
+  const compressedSize = data.readUInt32BE(20);
+  const isTrueType = flavor === 65536;
+  const isOpenType = flavor === 1330926671;
+  if (!isTrueType && !isOpenType) {
+    throw fontError(source, "the WOFF2 font must wrap a TTF or OTF font.");
+  }
+  if (declaredLength !== bytes.byteLength || tableCount < 1 || tableCount > 4096 || reserved !== 0 || compressedSize < 1 || compressedSize > bytes.byteLength - 48) {
+    throw fontError(source, "the WOFF2 header is corrupt or truncated.");
+  }
+  if (decompressedSize < 12 || decompressedSize > DEFAULT_MAX_PDF_DECOMPRESSED_FONT_BYTES) {
+    throw fontError(
+      source,
+      `the decompressed WOFF2 font exceeds the ${DEFAULT_MAX_PDF_DECOMPRESSED_FONT_BYTES}-byte limit.`
+    );
+  }
+  const metadataOffset = data.readUInt32BE(28);
+  const metadataLength = data.readUInt32BE(32);
+  const metadataOriginalLength = data.readUInt32BE(36);
+  const privateOffset = data.readUInt32BE(40);
+  const privateLength = data.readUInt32BE(44);
+  const metadataAbsent = metadataOffset === 0 && metadataLength === 0 && metadataOriginalLength === 0;
+  const metadataPresent = metadataOffset >= 48 && metadataLength > 0 && metadataOriginalLength > 0 && metadataOffset + metadataLength <= bytes.byteLength;
+  const privateAbsent = privateOffset === 0 && privateLength === 0;
+  const privatePresent = privateOffset >= 48 && privateLength > 0 && privateOffset + privateLength <= bytes.byteLength;
+  if (!metadataAbsent && !metadataPresent || !privateAbsent && !privatePresent) {
+    throw fontError(source, "the WOFF2 optional data blocks are corrupt.");
+  }
+};
 const validateSfntStructure = (source, bytes, format) => {
   const data = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   const tableCount = data.readUInt16BE(4);
@@ -380,20 +421,21 @@ const validateSfntStructure = (source, bytes, format) => {
 };
 const fontFormat = (source, bytes) => {
   const extension = extname(source).toLowerCase();
-  if (extension !== ".otf" && extension !== ".ttf") {
-    throw fontError(source, "only .ttf and .otf files are supported.");
+  if (extension !== ".otf" && extension !== ".ttf" && extension !== ".woff2") {
+    throw fontError(source, "only .ttf, .otf, and .woff2 files are supported.");
   }
-  if (bytes.byteLength < 12) {
-    throw fontError(source, "the file is too small to be a TTF or OTF font.");
+  if (bytes.byteLength < 4) {
+    throw fontError(source, "the file is too small to be a supported font.");
   }
   const format = detectFontFormat(bytes);
   if (!format) {
-    throw fontError(source, "the file has an unsupported TTF or OTF signature.");
+    throw fontError(source, "the file has an unsupported font signature.");
   }
   if (`.${format}` !== extension) {
-    throw fontError(source, "the file extension does not match its TTF or OTF signature.");
+    throw fontError(source, "the file extension does not match its font signature.");
   }
-  validateSfntStructure(source, bytes, format);
+  if (format === "woff2") validateWoff2Structure(source, bytes);
+  else validateSfntStructure(source, bytes, format);
   return format;
 };
 const readFont = async (source, filePath, maxBytes) => {
@@ -451,6 +493,10 @@ const bundlePdfFonts = async (declarations, options) => {
 };
 
 const authoringImportContexts = /* @__PURE__ */ new Map();
+const compilerFileSystem = {
+  fileExists: (file) => statSync(file, { throwIfNoEntry: false })?.isFile() ?? false,
+  readFile: (file) => readFileSync(file, "utf8")
+};
 class PdfSfcCompileError extends Error {
   column;
   filename;
@@ -840,6 +886,7 @@ function assertMetadataHoistable(source, descriptor, filename, macro) {
   try {
     const validation = parsePdfSfc(validationSource, filename);
     compileScript(validation, {
+      fs: compilerFileSystem,
       id: "nuxt-pdf-metadata-hoist",
       sourceMap: false
     });
@@ -934,6 +981,7 @@ function compileComponent(descriptor, filename, isProduction) {
   if (descriptor.scriptSetup) {
     try {
       const result = compileScript(descriptor, {
+        fs: compilerFileSystem,
         genDefaultAs: COMPONENT_VARIABLE,
         id: "nuxt-pdf",
         inlineTemplate: true,
@@ -959,6 +1007,7 @@ function compileComponent(descriptor, filename, isProduction) {
   if (descriptor.script) {
     try {
       const script = compileScript(descriptor, {
+        fs: compilerFileSystem,
         genDefaultAs: COMPONENT_VARIABLE,
         id: "nuxt-pdf",
         isProd: isProduction,
@@ -1129,4 +1178,4 @@ function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
 
-export { discoverPdfComponentFiles as a, discoverPdfImageFiles as b, bundlePdfFonts as c, discoverPdfTemplates as d, createPdfSfcPlugin as e, classifyPdfWatchEvent as f, compilePdfSfc as g, templateKeyFromRelativePath as t };
+export { discoverPdfImageFiles as a, bundlePdfFonts as b, compilePdfSfc as c, discoverPdfTemplates as d, discoverPdfComponentFiles as e, createPdfSfcPlugin as f, classifyPdfWatchEvent as g, templateKeyFromRelativePath as t };

package/dist/test.mjs

@@ -10,7 +10,7 @@ import { mkdir, writeFile, rm, readFile, readdir } from 'node:fs/promises';
 import { resolve, dirname, join, relative, basename } from 'node:path';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { build } from 'esbuild';
-import { t as templateKeyFromRelativePath, b as discoverPdfImageFiles, c as bundlePdfFonts, g as compilePdfSfc } from './shared/nuxt-pdf._V584vX4.mjs';
+import { t as templateKeyFromRelativePath, a as discoverPdfImageFiles, b as bundlePdfFonts, c as compilePdfSfc } from './shared/nuxt-pdf.DMC_Rdsz.mjs';
 import { pdfImageFormatFromKey } from '../dist/runtime/server/assets/resolve-asset.js';
 import '@vue/compiler-sfc';
 import '@jridgewell/remapping';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lupinum/nuxt-pdf",
-  "version": "0.4.0-beta.1",
+  "version": "0.4.0-beta.3",
   "description": "Author and render PDFs with Vue components in Nuxt",
   "keywords": [
     "nuxt",
@@ -30,6 +30,14 @@
     "./test": {
       "types": "./dist/test.d.mts",
       "import": "./dist/test.mjs"
+    },
+    "./build": {
+      "types": "./dist/build.d.mts",
+      "import": "./dist/build.mjs"
+    },
+    "./server": {
+      "types": "./dist/server.d.mts",
+      "import": "./dist/server.mjs"
     }
   },
   "main": "./dist/module.mjs",
@@ -76,15 +84,15 @@
     "test:package-metadata": "node scripts/check-api-report.mjs",
     "test:performance": "node --expose-gc ./node_modules/vitest/vitest.mjs run --config vitest.performance.config.ts",
     "test:prepare": "pnpm dev:prepare && nuxt prepare test/fixtures/layers",
-    "test:production": "vitest run --config vitest.production.config.ts",
+    "test:production": "pnpm build && vitest run --config vitest.production.config.ts",
     "test:quickstart": "node scripts/test-package-quickstart.mjs",
     "test:raster": "vitest run --config vitest.raster.config.ts",
     "test:version-headings": "node scripts/check-version-headings.mjs",
-    "test:workflows": "node scripts/check-workflow-policy.mjs",
+    "test:workflows": "node scripts/check-workflow-policy.mjs && node scripts/test-npm-recovery.mjs && node scripts/test-release-recovery.mjs",
     "check:vercel": "node scripts/check-vercel-config.mjs",
     "test:serverless": "vitest run --config vitest.serverless.config.ts",
     "test:watch": "vitest watch",
-    "typecheck": "nuxt prepare && vue-tsc --noEmit && nuxt prepare test/fixtures/basic && vue-tsc --noEmit -p test/fixtures/basic/tsconfig.json && pnpm test:prepare && pnpm --dir playground exec vue-tsc --noEmit",
+    "typecheck": "pnpm test:prepare && nuxt prepare && vue-tsc --noEmit && nuxt prepare test/fixtures/basic && vue-tsc --noEmit -p test/fixtures/basic/tsconfig.json && pnpm --dir playground exec vue-tsc --noEmit",
     "audit:all": "pnpm audit",
     "verify": "pnpm audit:all && pnpm check",
     "check": "pnpm format:check && pnpm check:vercel && pnpm typecheck && pnpm test:docs && pnpm test:version-headings && pnpm test:workflows && pnpm test:dependencies && pnpm test && pnpm test:production && pnpm test:serverless && pnpm build && pnpm test:package-metadata && pnpm dev:build && pnpm test:artifact"
@@ -97,11 +105,13 @@
     "@react-pdf/pdfkit": "5.1.1",
     "@react-pdf/primitives": "4.3.0",
     "@react-pdf/render": "4.5.1",
-    "@vue/compiler-sfc": "3.5.40",
+    "@vue/compiler-sfc": "3.5.42",
     "esbuild": "0.28.1",
     "h3": "1.15.11",
     "ufo": "1.6.4",
-    "unimport": "6.3.0"
+    "unimport": "6.3.0",
+    "typescript": "~5.9.3",
+    "vue-tsc": "^3.3.3"
   },
   "peerDependencies": {
     "@napi-rs/canvas": "^0.1.97",
@@ -137,10 +147,8 @@
     "publint": "^0.3.21",
     "react": "19.2.0",
     "source-code-pro": "2.42.0",
-    "typescript": "~5.9.3",
     "vitest": "^4.1.8",
-    "vue": "3.5.40",
-    "vue-tsc": "^3.3.3",
+    "vue": "3.5.42",
     "yaml": "2.9.0"
   }
 }