@lupinum/nuxt-pdf 0.3.0

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

@@ -0,0 +1,1132 @@
+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 { parse, compileScript, compileTemplate, babelParse } from '@vue/compiler-sfc';
+import remapping from '@jridgewell/remapping';
+import { transform } from 'esbuild';
+import { createUnimport } from 'unimport';
+import { PDF_DEFINITION_PROPERTY } from '../../dist/runtime/shared/template.js';
+
+const EXCLUDED_ROOT_DIRECTORIES = /* @__PURE__ */ new Set(["assets", "components", "fonts"]);
+const PDF_STRUCTURE_EVENTS = /* @__PURE__ */ new Set(["add", "addDir", "unlink", "unlinkDir"]);
+const normalizePathForIgnore = (path) => path.replaceAll("\\", "/");
+const classifyPdfWatchEvent = (event, absolutePath, layers, isIgnored) => {
+  if (isIgnored?.(normalizePathForIgnore(absolutePath))) return "ignore";
+  for (const layer of layers) {
+    const pdfsDir = join(resolve(layer.rootDir), "pdfs");
+    const pathWithinPdfs = relative(pdfsDir, absolutePath);
+    if (pathWithinPdfs.startsWith("..") || isAbsolute(pathWithinPdfs)) {
+      continue;
+    }
+    if (PDF_STRUCTURE_EVENTS.has(event)) return "restart";
+    if (event !== "change") return "ignore";
+    const [rootDirectory] = pathWithinPdfs.split(/[\\/]/);
+    return rootDirectory === "assets" || rootDirectory === "fonts" ? "restart" : "refresh";
+  }
+  return "ignore";
+};
+const compareText = (left, right) => {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+};
+const normalizeRelativePath = (value) => {
+  const slashPath = value.replaceAll("\\", "/");
+  if (isAbsolute(value) || slashPath.startsWith("/") || /^[a-z]:\//i.test(slashPath) || slashPath.split("/").includes("..")) {
+    throw new TypeError(`PDF template path must stay inside pdfs/: "${value}".`);
+  }
+  const normalized = posix.normalize(slashPath).replace(/^\.\//, "");
+  if (normalized === "." || normalized === "") {
+    throw new TypeError("PDF template path cannot be empty.");
+  }
+  return normalized;
+};
+const templateKeyFromRelativePath = (relativePath) => {
+  const normalized = normalizeRelativePath(relativePath);
+  const [rootDirectory] = normalized.split("/");
+  if (rootDirectory && EXCLUDED_ROOT_DIRECTORIES.has(rootDirectory)) {
+    return null;
+  }
+  if (!normalized.endsWith(".vue")) return null;
+  const key = normalized.slice(0, -".vue".length);
+  if (key === "") {
+    throw new TypeError(`Invalid PDF template path: "${relativePath}".`);
+  }
+  return key;
+};
+const candidateOrder = (left, right) => left.layerIndex - right.layerIndex || compareText(left.relativePath, right.relativePath) || compareText(left.filePath, right.filePath);
+const normalizePdfTemplateCandidates = (candidates) => {
+  const templatesByKey = /* @__PURE__ */ new Map();
+  const keysWithinLayers = /* @__PURE__ */ new Map();
+  for (const candidate of [...candidates].sort(candidateOrder)) {
+    if (!Number.isInteger(candidate.layerIndex) || candidate.layerIndex < 0) {
+      throw new TypeError("PDF template layerIndex must be a non-negative integer.");
+    }
+    const relativePath = normalizeRelativePath(candidate.relativePath);
+    const key = templateKeyFromRelativePath(relativePath);
+    if (key == null) continue;
+    if (!isAbsolute(candidate.filePath) && !/^[a-z]:[\\/]/i.test(candidate.filePath)) {
+      throw new TypeError(
+        `PDF template filePath must be absolute: "${candidate.filePath}".`
+      );
+    }
+    const template = {
+      key,
+      filePath: candidate.filePath,
+      relativePath,
+      layerIndex: candidate.layerIndex,
+      layerName: candidate.layerName ?? `layer-${candidate.layerIndex}`
+    };
+    const layerKey = `${candidate.layerIndex}\0${key}`;
+    const duplicate = keysWithinLayers.get(layerKey);
+    if (duplicate) {
+      throw new TypeError(
+        `PDF template collision for "${key}" in ${template.layerName}: "${duplicate.filePath}" and "${template.filePath}".`
+      );
+    }
+    keysWithinLayers.set(layerKey, template);
+    if (!templatesByKey.has(key)) {
+      templatesByKey.set(key, template);
+    }
+  }
+  return [...templatesByKey.values()].sort(
+    (left, right) => compareText(left.key, right.key)
+  );
+};
+const findFiles = async (directory, options, relativeDirectory = "") => {
+  let entries;
+  try {
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  entries.sort((left, right) => compareText(left.name, right.name));
+  const files = [];
+  for (const entry of entries) {
+    const absolutePath = join(directory, entry.name);
+    const relativePath = relativeDirectory ? posix.join(relativeDirectory, entry.name) : entry.name;
+    if (relativeDirectory === "" && entry.isDirectory() && options.excludedRootDirectories?.has(entry.name)) {
+      continue;
+    }
+    if (options.isIgnored?.(normalizePathForIgnore(absolutePath))) continue;
+    if (entry.isDirectory()) {
+      files.push(...await findFiles(
+        join(directory, entry.name),
+        options,
+        relativePath
+      ));
+    } else if (entry.isFile() && options.include(entry.name)) {
+      files.push(relativePath);
+    }
+  }
+  return files;
+};
+const VUE_FILES = {
+  excludedRootDirectories: EXCLUDED_ROOT_DIRECTORIES,
+  include: (filename) => filename.endsWith(".vue")
+};
+const PDF_COMPONENT_FILES = {
+  include: (filename) => filename.endsWith(".vue")
+};
+const PDF_IMAGE_FILES = {
+  include: (filename) => /\.(?:jpe?g|png)$/i.test(filename)
+};
+const discoverPdfTemplates = async (layers, isIgnored) => {
+  const candidates = [];
+  for (const [layerIndex, layer] of layers.entries()) {
+    const rootDir = resolve(layer.rootDir);
+    const pdfsDir = join(rootDir, "pdfs");
+    const files = await findFiles(pdfsDir, { ...VUE_FILES, isIgnored });
+    for (const relativePath of files) {
+      candidates.push({
+        filePath: join(pdfsDir, ...relativePath.split("/")),
+        relativePath,
+        layerIndex,
+        layerName: layer.name
+      });
+    }
+  }
+  return normalizePdfTemplateCandidates(candidates);
+};
+const discoverPdfComponentFiles = async (layers, isIgnored) => {
+  const files = /* @__PURE__ */ new Set();
+  for (const layer of layers) {
+    const directory = join(resolve(layer.rootDir), "pdfs", "components");
+    for (const relativePath of await findFiles(directory, {
+      ...PDF_COMPONENT_FILES,
+      isIgnored
+    })) {
+      files.add(join(directory, ...relativePath.split("/")));
+    }
+  }
+  return [...files].sort(compareText);
+};
+const discoverPdfImageFiles = async (layers, isIgnored) => {
+  const files = /* @__PURE__ */ new Map();
+  for (const [layerIndex, layer] of layers.entries()) {
+    const rootDir = join(resolve(layer.rootDir), "pdfs", "assets");
+    for (const key of await findFiles(rootDir, {
+      ...PDF_IMAGE_FILES,
+      isIgnored
+    })) {
+      if (!files.has(key)) {
+        files.set(key, {
+          filePath: join(rootDir, ...key.split("/")),
+          key,
+          rootDir,
+          layerIndex
+        });
+      }
+    }
+  }
+  return [...files.values()].sort((left, right) => compareText(left.key, right.key));
+};
+
+const DEFAULT_MAX_PDF_FONT_BYTES = 5 * 1024 * 1024;
+const FONT_WEIGHT_VALUES = {
+  black: 900,
+  bold: 700,
+  demibold: 600,
+  extrabold: 800,
+  extralight: 200,
+  hairline: 100,
+  heavy: 900,
+  light: 300,
+  medium: 500,
+  normal: 400,
+  semibold: 600,
+  thin: 100,
+  ultrabold: 800,
+  ultralight: 200
+};
+const FONT_STYLES = /* @__PURE__ */ new Set([
+  "italic",
+  "normal",
+  "oblique"
+]);
+const STANDARD_FONT_FAMILIES = /* @__PURE__ */ new Set([
+  "Courier",
+  "Courier-Bold",
+  "Courier-BoldOblique",
+  "Courier-Oblique",
+  "Helvetica",
+  "Helvetica-Bold",
+  "Helvetica-BoldOblique",
+  "Helvetica-Oblique",
+  "Times-Bold",
+  "Times-BoldItalic",
+  "Times-Italic",
+  "Times-Roman"
+]);
+const fontError = (source, message) => new TypeError(`Invalid PDF font "${source}": ${message}`);
+const isPdfFontsRoot = (root) => {
+  const parts = root.replaceAll("\\", "/").split("/").filter(Boolean);
+  return parts.at(-2)?.toLowerCase() === "pdfs" && parts.at(-1)?.toLowerCase() === "fonts";
+};
+const isContained = (root, target) => {
+  const pathFromRoot = relative(root, target);
+  return pathFromRoot !== "" && pathFromRoot !== ".." && !pathFromRoot.startsWith(`..${sep}`) && !isAbsolute(pathFromRoot);
+};
+const prepareFontRoots = async (roots) => {
+  if (roots.length === 0) {
+    throw new TypeError("At least one absolute pdfs/fonts root is required.");
+  }
+  const prepared = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    if (typeof root !== "string" || !isAbsolute(root) || !isPdfFontsRoot(root)) {
+      throw new TypeError(
+        `PDF font root "${root}" must be an absolute pdfs/fonts directory.`
+      );
+    }
+    let rootRealPath;
+    try {
+      rootRealPath = await realpath(root);
+    } catch (error) {
+      throw new TypeError(`PDF font root "${root}" does not exist.`, {
+        cause: error
+      });
+    }
+    const pdfsRealPath = await realpath(dirname(root));
+    if (!isContained(pdfsRealPath, rootRealPath)) {
+      throw new TypeError(
+        `PDF font root "${root}" resolves outside its pdfs directory.`
+      );
+    }
+    const rootStats = await stat(rootRealPath);
+    if (!rootStats.isDirectory()) {
+      throw new TypeError(`PDF font root "${root}" must be a directory.`);
+    }
+    if (seen.has(rootRealPath)) continue;
+    seen.add(rootRealPath);
+    prepared.push({ realPath: rootRealPath, sourcePath: root });
+  }
+  return prepared;
+};
+const validateRelativeSource = (source) => {
+  if (typeof source !== "string" || source.trim() === "") {
+    throw fontError(String(source), "src must be a non-empty relative path.");
+  }
+  const value = source.trim();
+  const pathParts = value.split(/[\\/]+/);
+  if (value.includes("\0")) {
+    throw fontError(value, "null bytes are not allowed in src.");
+  }
+  if (isAbsolute(value) || win32.isAbsolute(value) || /^[a-z][a-z\d+.-]*:/i.test(value) || value.startsWith("//")) {
+    throw fontError(value, "src must be a relative local path.");
+  }
+  if (pathParts.includes("..")) {
+    throw fontError(value, "parent path segments are not allowed.");
+  }
+  return value;
+};
+const resolveFontFile = async (source, roots) => {
+  const pathParts = source.split(/[\\/]+/).filter((part) => part !== ".");
+  for (const root of roots) {
+    const candidate = resolve(root.sourcePath, ...pathParts);
+    let candidateRealPath;
+    try {
+      candidateRealPath = await realpath(candidate);
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      throw fontError(source, "the source file could not be resolved.");
+    }
+    if (!isContained(root.realPath, candidateRealPath)) {
+      throw fontError(source, "the resolved path escapes its pdfs/fonts root.");
+    }
+    return candidateRealPath;
+  }
+  throw fontError(source, "the source file was not found in any pdfs/fonts root.");
+};
+const normalizeFontWeight = (source, weight) => {
+  if (weight === void 0) return void 0;
+  if (typeof weight === "string") {
+    const value = FONT_WEIGHT_VALUES[weight];
+    if (value === void 0) {
+      throw fontError(source, `unsupported fontWeight "${weight}".`);
+    }
+    return value;
+  }
+  if (!Number.isInteger(weight) || weight < 1 || weight > 1e3) {
+    throw fontError(source, "numeric fontWeight must be an integer from 1 to 1000.");
+  }
+  return weight;
+};
+const validateFontSource = (src) => {
+  if (typeof src === "string" && /^https?:/i.test(src.trim())) {
+    throw fontError(
+      "<remote-font>",
+      "remote fonts are unsupported; use a local file in pdfs/fonts/."
+    );
+  }
+  return validateRelativeSource(src);
+};
+const validateDeclaration = (declaration) => {
+  const source = validateFontSource(declaration?.src);
+  const label = source;
+  if (typeof declaration.family !== "string" || declaration.family.trim() === "") {
+    throw fontError(label, "family must be a non-empty string.");
+  }
+  const family = declaration.family.trim();
+  if (Object.prototype.hasOwnProperty.call(Object.prototype, family)) {
+    throw fontError(label, `family "${family}" is a reserved object key.`);
+  }
+  if (STANDARD_FONT_FAMILIES.has(family)) {
+    throw fontError(label, `family "${family}" is reserved by a standard PDF font.`);
+  }
+  if (declaration.fontStyle !== void 0 && !FONT_STYLES.has(declaration.fontStyle)) {
+    throw fontError(label, `unsupported fontStyle "${declaration.fontStyle}".`);
+  }
+  return {
+    family,
+    fontStyle: declaration.fontStyle,
+    fontWeight: normalizeFontWeight(label, declaration.fontWeight),
+    source
+  };
+};
+const detectFontFormat = (bytes) => {
+  if (bytes.byteLength < 12) 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;
+  if (isTrueType) return "ttf";
+  if (isOpenType) return "otf";
+  return void 0;
+};
+const validateSfntStructure = (source, bytes, format) => {
+  const data = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const tableCount = data.readUInt16BE(4);
+  const directoryEnd = 12 + tableCount * 16;
+  if (tableCount < 1 || tableCount > 4096 || directoryEnd > data.byteLength) {
+    throw fontError(source, "the SFNT table directory is corrupt or truncated.");
+  }
+  const tables = /* @__PURE__ */ new Set();
+  for (let index = 0; index < tableCount; index += 1) {
+    const record = 12 + index * 16;
+    const tag = data.toString("latin1", record, record + 4);
+    const offset = data.readUInt32BE(record + 8);
+    const length = data.readUInt32BE(record + 12);
+    const end = offset + length;
+    if (!/^[\x20-\x7E]{4}$/u.test(tag) || tables.has(tag) || offset < directoryEnd || !Number.isSafeInteger(end) || end > data.byteLength) {
+      throw fontError(source, "the SFNT table directory is corrupt or truncated.");
+    }
+    tables.add(tag);
+  }
+  const outlineTable = format === "ttf" ? tables.has("glyf") : tables.has("CFF ") || tables.has("CFF2");
+  if (!tables.has("head") || !tables.has("maxp") || !tables.has("cmap") || !outlineTable) {
+    throw fontError(source, "the font is missing required SFNT tables.");
+  }
+};
+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 (bytes.byteLength < 12) {
+    throw fontError(source, "the file is too small to be a TTF or OTF font.");
+  }
+  const format = detectFontFormat(bytes);
+  if (!format) {
+    throw fontError(source, "the file has an unsupported TTF or OTF signature.");
+  }
+  if (`.${format}` !== extension) {
+    throw fontError(source, "the file extension does not match its TTF or OTF signature.");
+  }
+  validateSfntStructure(source, bytes, format);
+  return format;
+};
+const readFont = async (source, filePath, maxBytes) => {
+  const file = await open(filePath, "r");
+  let bytes;
+  try {
+    const fileStats = await file.stat();
+    if (!fileStats.isFile()) {
+      throw fontError(source, "the resolved source must be a regular file.");
+    }
+    if (fileStats.size > maxBytes) {
+      throw fontError(source, `the source exceeds the ${maxBytes}-byte limit.`);
+    }
+    bytes = await file.readFile();
+    if (bytes.byteLength > maxBytes) {
+      throw fontError(source, `the source exceeds the ${maxBytes}-byte limit.`);
+    }
+  } finally {
+    await file.close();
+  }
+  const format = fontFormat(source, bytes);
+  return `data:font/${format};base64,${Buffer.from(bytes).toString("base64")}`;
+};
+const bundlePdfFonts = async (declarations, options) => {
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_PDF_FONT_BYTES;
+  if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) {
+    throw new TypeError("PDF font maxBytes must be a positive safe integer.");
+  }
+  if (declarations.length === 0) return Object.freeze([]);
+  let preparedRoots;
+  const getRoots = async () => preparedRoots ??= await prepareFontRoots(options.fontRoots);
+  const result = [];
+  const registrations = /* @__PURE__ */ new Set();
+  for (const declaration of declarations) {
+    const validated = validateDeclaration(declaration);
+    const label = validated.source;
+    const registration = [
+      validated.family,
+      validated.fontStyle ?? "normal",
+      validated.fontWeight ?? 400
+    ].join("\0");
+    if (registrations.has(registration)) {
+      throw fontError(
+        label,
+        `duplicates family "${validated.family}" with the same style and weight.`
+      );
+    }
+    const filePath = await resolveFontFile(validated.source, await getRoots());
+    const src = await readFont(validated.source, filePath, maxBytes);
+    const { family, fontStyle, fontWeight } = validated;
+    registrations.add(registration);
+    result.push(Object.freeze({ family, fontStyle, fontWeight, src }));
+  }
+  return Object.freeze(result);
+};
+
+const authoringImportContexts = /* @__PURE__ */ new Map();
+class PdfSfcCompileError extends Error {
+  column;
+  filename;
+  line;
+  constructor(filename, line, column, message) {
+    super(`[nuxt-pdf] ${filename}:${line}:${column} ${message}`);
+    this.name = "PdfSfcCompileError";
+    this.filename = filename;
+    this.line = line;
+    this.column = column;
+  }
+}
+const COMPONENT_VARIABLE = "__nuxtPdfComponent";
+const VIRTUAL_PREFIX = "\0nuxt-pdf:sfc:";
+const VIRTUAL_SUFFIX = ".mjs";
+const METADATA_KEYS = /* @__PURE__ */ new Set([
+  "filename",
+  "language",
+  "maxPasses",
+  "sampleData",
+  "scenarios",
+  "title"
+]);
+const PRODUCTION_METADATA_KEYS = /* @__PURE__ */ new Set([
+  "filename",
+  "language",
+  "maxPasses",
+  "title"
+]);
+const createPdfSfcPlugin = (options) => ({
+  name: "nuxt-pdf:sfc",
+  enforce: "pre",
+  resolveId(source, importer) {
+    const filename = resolvePdfImport(source, importer);
+    if (!filename) return null;
+    if (options.files.has(filename)) return virtualPdfId(filename);
+    return importer?.startsWith(VIRTUAL_PREFIX) ? resolveRelativeModule(filename) : null;
+  },
+  async load(id) {
+    const filename = filenameFromVirtualId(id);
+    if (!filename) return null;
+    const kind = options.files.get(filename);
+    if (!kind) return null;
+    return compilePdfSfc(
+      await readFile(filename, "utf8"),
+      filename,
+      kind,
+      options.isProduction,
+      options.composablesImport
+    );
+  },
+  async transform(source, id) {
+    if (id.includes("?") || id.startsWith(VIRTUAL_PREFIX)) return null;
+    const filename = resolve(id);
+    const kind = options.files.get(filename);
+    if (!kind) return null;
+    return compilePdfSfc(
+      source,
+      filename,
+      kind,
+      options.isProduction,
+      options.composablesImport
+    );
+  }
+});
+const MODULE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json"
+];
+function resolveRelativeModule(filename) {
+  const extension = extname(filename);
+  const candidates = MODULE_EXTENSIONS.includes(
+    extension
+  ) ? [filename] : [
+    filename,
+    ...MODULE_EXTENSIONS.map((extension2) => `${filename}${extension2}`),
+    ...MODULE_EXTENSIONS.map((extension2) => resolve(filename, `index${extension2}`))
+  ];
+  for (const candidate of candidates) {
+    if (candidate.endsWith(".vue") || !existsSync(candidate)) continue;
+    try {
+      if (statSync(candidate).isFile()) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function resolvePdfImport(source, importer) {
+  if (source.startsWith("\0") || source.includes("?")) return void 0;
+  if (isAbsolute(source)) return resolve(source);
+  if (!source.startsWith(".")) return void 0;
+  const importerFilename = importer?.startsWith(VIRTUAL_PREFIX) ? filenameFromVirtualId(importer) : importer?.split("?", 1)[0];
+  return importerFilename ? resolve(dirname(importerFilename), source) : void 0;
+}
+function virtualPdfId(filename) {
+  return `${VIRTUAL_PREFIX}${Buffer.from(filename).toString("base64url")}${VIRTUAL_SUFFIX}`;
+}
+function filenameFromVirtualId(id) {
+  if (!id.startsWith(VIRTUAL_PREFIX) || !id.endsWith(VIRTUAL_SUFFIX)) return void 0;
+  const encoded = id.slice(VIRTUAL_PREFIX.length, -VIRTUAL_SUFFIX.length);
+  try {
+    return Buffer.from(encoded, "base64url").toString("utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function compilePdfSfc(source, filename, kind, isProduction = false, composablesImport) {
+  const compilerFilename = normalizeCompilerPath(filename);
+  const original = parsePdfSfc(source, compilerFilename);
+  assertSupportedBlocks(original, compilerFilename);
+  assertTemplate(original, compilerFilename);
+  assertSynchronousSetup(original, compilerFilename);
+  assertSupportedTemplate(original, compilerFilename);
+  const metadata = extractMetadata(
+    source,
+    original,
+    compilerFilename,
+    kind,
+    isProduction
+  );
+  const cleaned = parsePdfSfc(metadata.source, compilerFilename);
+  const component = compileComponent(cleaned, compilerFilename, isProduction);
+  const autoImportedComponent = await injectAuthoringImports(
+    component.code,
+    compilerFilename,
+    composablesImport
+  );
+  const metadataCode = kind === "template" ? `${COMPONENT_VARIABLE}.${PDF_DEFINITION_PROPERTY} = ${metadata.expression}
+` : "";
+  const loader = scriptLoader(cleaned);
+  try {
+    const result = await transform([
+      autoImportedComponent.code,
+      metadataCode,
+      `export default ${COMPONENT_VARIABLE}`
+    ].filter(Boolean).join("\n"), {
+      charset: "utf8",
+      format: "esm",
+      loader,
+      sourcefile: compilerFilename,
+      sourcemap: true,
+      sourcesContent: true,
+      target: "es2022"
+    });
+    const esbuildMap = result.map ? JSON.parse(result.map) : null;
+    const map = esbuildMap && autoImportedComponent.map && component.map ? remapping(
+      [esbuildMap, autoImportedComponent.map, component.map],
+      () => null
+    ) : null;
+    if (map) map.sourcesContent = map.sources.map(() => source);
+    return { code: result.code, map };
+  } catch (error) {
+    throw normalizeBuildError(error, compilerFilename);
+  }
+}
+function normalizeCompilerPath(path) {
+  return path.replaceAll("\\", "/");
+}
+function parsePdfSfc(source, filename) {
+  const result = parse(source, {
+    filename,
+    sourceMap: true
+  });
+  if (result.errors.length > 0) {
+    throw normalizeCompilerError(result.errors[0], filename);
+  }
+  return result.descriptor;
+}
+function assertSupportedBlocks(descriptor, filename) {
+  const style = descriptor.styles[0];
+  if (style) {
+    throw errorAtBlock(
+      filename,
+      style,
+      "<style> blocks are not supported in PDF components."
+    );
+  }
+  const customBlock = descriptor.customBlocks[0];
+  if (customBlock) {
+    throw errorAtBlock(
+      filename,
+      customBlock,
+      `<${customBlock.type}> custom blocks are not supported in PDF components.`
+    );
+  }
+}
+function assertTemplate(descriptor, filename) {
+  if (descriptor.template) return;
+  throw new PdfSfcCompileError(
+    filename,
+    1,
+    1,
+    "A PDF component must contain a <template> block."
+  );
+}
+const FUNCTION_NODE_TYPES = /* @__PURE__ */ new Set([
+  "ArrowFunctionExpression",
+  "ClassMethod",
+  "ClassPrivateMethod",
+  "FunctionDeclaration",
+  "FunctionExpression",
+  "ObjectMethod"
+]);
+function assertSynchronousSetup(descriptor, filename) {
+  const block = descriptor.scriptSetup;
+  if (!block) return;
+  const program = parseScriptProgram(block, filename);
+  walkAst(program, [], (node, ancestors) => {
+    const isTopLevelAwait = node.type === "AwaitExpression" || node.type === "ForOfStatement" && node.await === true;
+    if (!isTopLevelAwait) return;
+    if (ancestors.some((parent) => FUNCTION_NODE_TYPES.has(parent.type))) return;
+    throw errorAtNode(
+      filename,
+      block,
+      node,
+      "Top-level await is not supported in PDF templates. Load request data before render(props) and pass it through typed props."
+    );
+  });
+}
+function assertSupportedTemplate(descriptor, filename) {
+  const block = descriptor.template;
+  const ast = block?.ast;
+  if (!block || !ast) return;
+  walkTemplateAst(ast, (node) => {
+    if (node.type === 1 && node.tag?.toLowerCase() === "teleport") {
+      throw errorAtTemplateNode(
+        filename,
+        node,
+        "Teleport is not supported in PDF templates because the PDF renderer has no external host target."
+      );
+    }
+    if (node.type === 7 && node.name === "show") {
+      throw errorAtTemplateNode(
+        filename,
+        node,
+        "v-show is not supported in PDF templates. Use v-if; PDF styles are not browser CSS."
+      );
+    }
+  });
+}
+function extractMetadata(source, descriptor, filename, kind, isProduction) {
+  const calls = [
+    ...findMacroCalls(descriptor.script, filename),
+    ...findMacroCalls(descriptor.scriptSetup, filename)
+  ];
+  if (kind === "component") {
+    if (calls[0]) {
+      throw errorAtNode(
+        filename,
+        calls[0].block,
+        calls[0].call,
+        "definePdf() is only allowed in discovered PDF templates."
+      );
+    }
+    return { expression: "", source };
+  }
+  if (calls.length === 0) {
+    throw new PdfSfcCompileError(
+      filename,
+      descriptor.scriptSetup?.loc.start.line ?? 1,
+      descriptor.scriptSetup?.loc.start.column ?? 1,
+      "A PDF template must contain exactly one top-level definePdf({...}) call."
+    );
+  }
+  if (calls.length > 1) {
+    throw errorAtNode(
+      filename,
+      calls[1].block,
+      calls[1].call,
+      `A PDF template must contain exactly one definePdf() call; found ${calls.length}.`
+    );
+  }
+  const macro = calls[0];
+  if (macro.block !== descriptor.scriptSetup) {
+    throw errorAtNode(
+      filename,
+      macro.block,
+      macro.call,
+      "definePdf() must be a top-level statement in <script setup>."
+    );
+  }
+  if (!macro.statement) {
+    throw errorAtNode(
+      filename,
+      macro.block,
+      macro.call,
+      "definePdf() must be a standalone top-level statement."
+    );
+  }
+  if (!macro.argument || macro.argument.type !== "ObjectExpression") {
+    throw errorAtNode(
+      filename,
+      macro.block,
+      macro.call,
+      "definePdf() requires one static object argument."
+    );
+  }
+  const metadataProperties = assertMetadataShape(
+    macro.argument,
+    filename,
+    macro.block
+  );
+  assertMetadataHoistable(source, descriptor, filename, macro);
+  const blockOffset = macro.block.loc.start.offset;
+  const argumentStart = requiredOffset(macro.argument.start, filename, macro.block);
+  const argumentEnd = requiredOffset(macro.argument.end, filename, macro.block);
+  const statementStart = requiredOffset(macro.statement.start, filename, macro.block);
+  const statementEnd = requiredOffset(macro.statement.end, filename, macro.block);
+  const absoluteStatementStart = blockOffset + statementStart;
+  const absoluteStatementEnd = blockOffset + statementEnd;
+  return {
+    expression: isProduction ? productionMetadataExpression(
+      metadataProperties,
+      macro.block,
+      filename
+    ) : macro.block.content.slice(argumentStart, argumentEnd),
+    source: replaceWithWhitespace(
+      source,
+      absoluteStatementStart,
+      absoluteStatementEnd
+    )
+  };
+}
+function findMacroCalls(block, filename, name = "definePdf") {
+  if (!block) return [];
+  const program = parseScriptProgram(block, filename);
+  const calls = [];
+  walkAst(program, [], (node, ancestors) => {
+    if (node.type !== "CallExpression") return;
+    const callee = asAstNode(node.callee);
+    if (callee?.type !== "Identifier" || callee.name !== name) return;
+    const parent = ancestors.at(-1);
+    const grandparent = ancestors.at(-2);
+    const isTopLevelStatement = parent?.type === "ExpressionStatement" && parent.expression === node && grandparent?.type === "Program";
+    const args = Array.isArray(node.arguments) ? node.arguments : [];
+    calls.push({
+      argument: args.length === 1 ? asAstNode(args[0]) : void 0,
+      block,
+      call: node,
+      statement: isTopLevelStatement ? parent : void 0
+    });
+  });
+  return calls;
+}
+function parseScriptProgram(block, filename) {
+  const plugins = [];
+  if (block.lang === "ts" || block.lang === "tsx") plugins.push("typescript");
+  if (block.lang === "jsx" || block.lang === "tsx") plugins.push("jsx");
+  try {
+    return babelParse(block.content, {
+      plugins,
+      sourceType: "module"
+    }).program;
+  } catch (error) {
+    throw normalizeScriptParseError(error, filename, block);
+  }
+}
+function assertMetadataHoistable(source, descriptor, filename, macro) {
+  const block = descriptor.scriptSetup;
+  if (!block || !macro.argument || !macro.statement) return;
+  const blockOffset = block.loc.start.offset;
+  const argumentStart = requiredOffset(macro.argument.start, filename, block);
+  const argumentEnd = requiredOffset(macro.argument.end, filename, block);
+  const replacements = [];
+  for (const call of findMacroCalls(block, filename, "defineOptions")) {
+    if (!call.statement) continue;
+    replacements.push({
+      start: blockOffset + requiredOffset(call.statement.start, filename, block),
+      end: blockOffset + requiredOffset(call.statement.end, filename, block),
+      value: ""
+    });
+  }
+  replacements.push({
+    start: blockOffset + requiredOffset(macro.statement.start, filename, block),
+    end: blockOffset + requiredOffset(macro.statement.end, filename, block),
+    value: `defineOptions(${block.content.slice(argumentStart, argumentEnd)})`
+  });
+  const validationSource = replacements.sort((left, right) => right.start - left.start).reduce(
+    (result, replacement) => result.slice(0, replacement.start) + replacement.value + result.slice(replacement.end),
+    source
+  );
+  try {
+    const validation = parsePdfSfc(validationSource, filename);
+    compileScript(validation, {
+      id: "nuxt-pdf-metadata-hoist",
+      sourceMap: false
+    });
+  } catch (error) {
+    if (errorMessage(error).includes(
+      "`defineOptions()` in <script setup> cannot reference locally declared variables"
+    )) {
+      throw errorAtNode(
+        filename,
+        block,
+        macro.call,
+        "definePdf() metadata cannot reference locally declared <script setup> bindings because it is evaluated at module scope. Inline the value or import it from a side-effect-free module."
+      );
+    }
+  }
+}
+function assertMetadataShape(object, filename, block) {
+  const properties = Array.isArray(object.properties) ? object.properties : [];
+  const keys = /* @__PURE__ */ new Map();
+  for (const value of properties) {
+    const property = asAstNode(value);
+    if (!property || property.type === "SpreadElement") {
+      throw errorAtNode(
+        filename,
+        block,
+        property ?? object,
+        "definePdf() metadata cannot contain spread properties."
+      );
+    }
+    if (property.type !== "ObjectProperty" && property.type !== "ObjectMethod") {
+      throw errorAtNode(
+        filename,
+        block,
+        property,
+        "definePdf() metadata must use ordinary static properties."
+      );
+    }
+    if (property.computed === true) {
+      throw errorAtNode(
+        filename,
+        block,
+        property,
+        "definePdf() metadata keys cannot be computed."
+      );
+    }
+    const key = metadataKey(asAstNode(property.key));
+    if (!key || !METADATA_KEYS.has(key)) {
+      throw errorAtNode(
+        filename,
+        block,
+        property,
+        `Unsupported definePdf() metadata key${key ? ` "${key}"` : ""}.`
+      );
+    }
+    if (keys.has(key)) {
+      throw errorAtNode(
+        filename,
+        block,
+        property,
+        `Duplicate definePdf() metadata key "${key}".`
+      );
+    }
+    if (!isRuntimeMetadataKey(key) && isFunctionProperty(property)) {
+      throw errorAtNode(
+        filename,
+        block,
+        property,
+        `definePdf() metadata key "${key}" cannot be a function. Functions are only supported for "title" and "filename".`
+      );
+    }
+    keys.set(key, property);
+  }
+  return keys;
+}
+function productionMetadataExpression(properties, block, filename) {
+  const retained = [...properties].filter(([key]) => PRODUCTION_METADATA_KEYS.has(key)).map(([, property]) => {
+    const start = requiredOffset(property.start, filename, block);
+    const end = requiredOffset(property.end, filename, block);
+    return block.content.slice(start, end);
+  });
+  return `{${retained.join(",")}}`;
+}
+function isRuntimeMetadataKey(key) {
+  return key === "title" || key === "filename";
+}
+function isFunctionProperty(property) {
+  if (property.type === "ObjectMethod") return true;
+  const value = asAstNode(property.value);
+  return value?.type === "ArrowFunctionExpression" || value?.type === "FunctionExpression";
+}
+function compileComponent(descriptor, filename, isProduction) {
+  if (descriptor.scriptSetup) {
+    try {
+      const result = compileScript(descriptor, {
+        genDefaultAs: COMPONENT_VARIABLE,
+        id: "nuxt-pdf",
+        inlineTemplate: true,
+        isProd: isProduction,
+        sourceMap: true,
+        templateOptions: {
+          filename,
+          isProd: isProduction,
+          ssr: false,
+          transformAssetUrls: false
+        }
+      });
+      return {
+        code: result.content,
+        map: result.map ? JSON.parse(JSON.stringify(result.map)) : null
+      };
+    } catch (error) {
+      throw normalizeCompilerError(error, filename);
+    }
+  }
+  let scriptCode = `const ${COMPONENT_VARIABLE} = { __name: ${JSON.stringify(componentName(filename))} }`;
+  let bindings;
+  if (descriptor.script) {
+    try {
+      const script = compileScript(descriptor, {
+        genDefaultAs: COMPONENT_VARIABLE,
+        id: "nuxt-pdf",
+        isProd: isProduction,
+        sourceMap: true
+      });
+      scriptCode = script.content;
+      bindings = script.bindings;
+    } catch (error) {
+      throw normalizeCompilerError(error, filename);
+    }
+  }
+  const template = compileTemplate({
+    compilerOptions: { bindingMetadata: bindings },
+    filename,
+    id: "nuxt-pdf",
+    isProd: isProduction,
+    source: descriptor.template.content,
+    ssr: false,
+    transformAssetUrls: false
+  });
+  if (template.errors.length > 0) {
+    throw normalizeCompilerError(template.errors[0], filename);
+  }
+  return {
+    code: [
+      scriptCode,
+      template.code,
+      `${COMPONENT_VARIABLE}.render = render`
+    ].join("\n"),
+    // The separately compiled script and template do not share one generated
+    // coordinate space. Returning no map is safer than publishing a false one.
+    map: null
+  };
+}
+async function injectAuthoringImports(componentCode, filename, composablesImport) {
+  const normalizedComposablesImport = composablesImport ? normalizeCompilerPath(composablesImport) : void 0;
+  const key = normalizedComposablesImport ?? "";
+  let context = authoringImportContexts.get(key);
+  if (!context) {
+    context = createUnimport({
+      imports: normalizedComposablesImport ? [{ from: normalizedComposablesImport, name: "usePdfPageNumbers" }] : [],
+      presets: ["vue"]
+    });
+    authoringImportContexts.set(key, context);
+  }
+  const result = await context.injectImports(componentCode, filename);
+  return {
+    code: result.s.toString(),
+    map: JSON.parse(result.s.generateMap({
+      hires: true,
+      includeContent: true,
+      source: filename
+    }).toString())
+  };
+}
+function scriptLoader(descriptor) {
+  const languages = [descriptor.script?.lang, descriptor.scriptSetup?.lang];
+  if (languages.includes("tsx")) return "tsx";
+  if (languages.includes("ts")) return "ts";
+  if (languages.includes("jsx")) return "jsx";
+  return "js";
+}
+function componentName(filename) {
+  const basename = filename.replaceAll("\\", "/").split("/").at(-1) ?? "PdfComponent.vue";
+  return basename.replace(/\.vue$/i, "");
+}
+function metadataKey(node) {
+  if (!node) return void 0;
+  if (node.type === "Identifier" && typeof node.name === "string") return node.name;
+  if (node.type === "StringLiteral" && typeof node.value === "string") return node.value;
+  return void 0;
+}
+function walkAst(node, ancestors, visit) {
+  visit(node, ancestors);
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        const child2 = asAstNode(item);
+        if (child2) walkAst(child2, [...ancestors, node], visit);
+      }
+      continue;
+    }
+    const child = asAstNode(value);
+    if (child) walkAst(child, [...ancestors, node], visit);
+  }
+}
+function walkTemplateAst(node, visit) {
+  visit(node);
+  for (const child of node.props ?? []) walkTemplateAst(child, visit);
+  for (const child of node.children ?? []) walkTemplateAst(child, visit);
+}
+function asAstNode(value) {
+  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string" ? value : void 0;
+}
+function requiredOffset(value, filename, block) {
+  if (typeof value === "number") return value;
+  throw errorAtBlock(
+    filename,
+    block,
+    "Unable to determine the definePdf() source range."
+  );
+}
+function replaceWithWhitespace(source, start, end) {
+  const whitespace = source.slice(start, end).replace(/[^\r\n]/g, " ");
+  return source.slice(0, start) + whitespace + source.slice(end);
+}
+function errorAtNode(filename, block, node, message) {
+  const nodeLine = node.loc?.start.line ?? 1;
+  const line = block.loc.start.line + nodeLine - 1;
+  const column = nodeLine === 1 ? block.loc.start.column + (node.loc?.start.column ?? 0) : (node.loc?.start.column ?? 0) + 1;
+  return new PdfSfcCompileError(filename, line, column, message);
+}
+function errorAtBlock(filename, block, message) {
+  return new PdfSfcCompileError(
+    filename,
+    block.loc.start.line,
+    block.loc.start.column,
+    message
+  );
+}
+function errorAtTemplateNode(filename, node, message) {
+  return new PdfSfcCompileError(
+    filename,
+    node.loc?.start.line ?? 1,
+    node.loc?.start.column ?? 1,
+    message
+  );
+}
+function normalizeScriptParseError(error, filename, block) {
+  const location = errorLocation(error);
+  const line = block.loc.start.line + (location?.line ?? 1) - 1;
+  const column = location?.line === 1 ? block.loc.start.column + (location.column ?? 0) : (location?.column ?? 0) + 1;
+  return new PdfSfcCompileError(filename, line, column, errorMessage(error));
+}
+function normalizeCompilerError(error, filename) {
+  if (error instanceof PdfSfcCompileError) return error;
+  const location = errorLocation(error);
+  return new PdfSfcCompileError(
+    filename,
+    location?.line ?? 1,
+    (location?.column ?? 0) + 1,
+    errorMessage(error)
+  );
+}
+function normalizeBuildError(error, filename) {
+  const first = isRecord(error) && Array.isArray(error.errors) && error.errors.length > 0 ? error.errors[0] : error;
+  const location = isRecord(first) && isRecord(first.location) ? first.location : void 0;
+  return new PdfSfcCompileError(
+    filename,
+    typeof location?.line === "number" ? location.line : 1,
+    typeof location?.column === "number" ? location.column + 1 : 1,
+    errorMessage(first)
+  );
+}
+function errorLocation(error) {
+  if (!isRecord(error) || !isRecord(error.loc)) return void 0;
+  const location = isRecord(error.loc.start) ? error.loc.start : error.loc;
+  return typeof location.line === "number" && typeof location.column === "number" ? { column: location.column, line: location.line } : void 0;
+}
+function errorMessage(error) {
+  if (typeof error === "string") return error;
+  if (error instanceof Error) return error.message;
+  if (isRecord(error) && typeof error.text === "string") return error.text;
+  if (isRecord(error) && typeof error.message === "string") return error.message;
+  return "Failed to compile PDF component.";
+}
+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 };