@formfeed/engine 0.1.0

package/index.js

@@ -0,0 +1,3273 @@
+// packages/engine/src/lib/errors.ts
+var EngineSyntaxError = class extends Error {
+  constructor(engine, message, line, column) {
+    super(message);
+    this.engine = engine;
+    this.line = line;
+    this.column = column;
+  }
+  name = "EngineSyntaxError";
+  get position() {
+    return { line: this.line, column: this.column };
+  }
+};
+var RenderLimitError = class extends Error {
+  constructor(limit, message) {
+    super(message);
+    this.limit = limit;
+  }
+  name = "RenderLimitError";
+};
+var RenderError = class extends Error {
+  constructor(engine, message, line, column) {
+    super(message);
+    this.engine = engine;
+    this.line = line;
+    this.column = column;
+  }
+  name = "RenderError";
+};
+
+// packages/engine/src/lib/limits.ts
+var defaultLimits = {
+  ms: 5e3,
+  outputBytes: 20 * 1024 * 1024,
+  includeDepth: 8
+};
+var encoder = new TextEncoder();
+function enforceLimits(output, startedAt, limits) {
+  const elapsed = Date.now() - startedAt;
+  if (elapsed > limits.ms)
+    throw new RenderLimitError(
+      "ms",
+      `Template render took ${elapsed} ms; the limit is ${limits.ms} ms`
+    );
+  if (output.length > limits.outputBytes / 4) {
+    const bytes = encoder.encode(output).length;
+    if (bytes > limits.outputBytes) {
+      throw new RenderLimitError(
+        "outputBytes",
+        `Rendered HTML is ${bytes} bytes; the limit is ${limits.outputBytes} bytes`
+      );
+    }
+  }
+  return output;
+}
+function depthGuard(resolve2, includeDepth) {
+  const stack = [];
+  return (name) => {
+    if (stack.length >= includeDepth)
+      throw new RenderLimitError(
+        "includeDepth",
+        `Includes nest deeper than ${includeDepth} (${[...stack, name].join(" \u2192 ")})`
+      );
+    if (stack.includes(name))
+      throw new RenderLimitError(
+        "includeDepth",
+        `Partial "${name}" includes itself`
+      );
+    stack.push(name);
+    try {
+      return resolve2(name);
+    } finally {
+      stack.pop();
+    }
+  };
+}
+
+// packages/engine/src/lib/helpers/codes.ts
+import { toSVG } from "bwip-js";
+import { create as createQr } from "qrcode";
+import { render as renderQrSvg } from "qrcode/lib/renderer/svg-tag.js";
+
+// packages/engine/src/lib/helpers/format.ts
+import { TZDate } from "@date-fns/tz";
+import { add, format as formatDate, isValid, parseISO } from "date-fns";
+import { de, enGB, enUS, es, fr, it, nl } from "date-fns/locale";
+import { marked } from "marked";
+import { toCardinal as deWords } from "n2words/de";
+import { toCardinal as enWords } from "n2words/en";
+import { toCardinal as esWords } from "n2words/es";
+import { toCardinal as frWords } from "n2words/fr";
+import { toCardinal as itWords } from "n2words/it";
+import { toCardinal as nlWords } from "n2words/nl";
+var dateLocales = {
+  de,
+  en: enGB,
+  "en-GB": enGB,
+  "en-US": enUS,
+  fr,
+  es,
+  it,
+  nl
+};
+function dateLocale(locale) {
+  return dateLocales[locale] ?? dateLocales[locale.split("-")[0] ?? ""] ?? enGB;
+}
+function toNumber(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const n = Number(value.replace(/\s/g, "").replace(",", "."));
+    return Number.isFinite(n) ? n : NaN;
+  }
+  if (typeof value === "bigint") return Number(value);
+  return NaN;
+}
+function toDate(value, tz) {
+  if (value === "now" || value === void 0 || value === null || value === "")
+    return new TZDate(Date.now(), tz);
+  if (value instanceof Date) return new TZDate(value.getTime(), tz);
+  if (typeof value === "number")
+    return new TZDate(value < 1e12 ? value * 1e3 : value, tz);
+  if (typeof value === "string") {
+    const iso = parseISO(value);
+    if (isValid(iso)) {
+      return /^\d{4}-\d{2}-\d{2}$/.test(value) ? new TZDate(iso.getFullYear(), iso.getMonth(), iso.getDate(), tz) : new TZDate(iso.getTime(), tz);
+    }
+    const parsed = new Date(value);
+    if (isValid(parsed)) return new TZDate(parsed.getTime(), tz);
+  }
+  return null;
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+var str = (v) => v === void 0 || v === null ? "" : String(v);
+var opt = (v, fallback) => v === void 0 || v === null || v === "" ? fallback : v;
+var wordsByLang = {
+  de: deWords,
+  en: enWords,
+  es: esWords,
+  fr: frWords,
+  it: itWords,
+  nl: nlWords
+};
+var formatHelpers = [
+  {
+    name: "money",
+    aliases: ["currency"],
+    deprecatedAlias: { currency_format: "money" },
+    doc: {
+      signature: "money(value, currency?, locale?)",
+      description: "Formats a number as currency with Intl.NumberFormat. Defaults come from the template settings.",
+      example: "{{ line.total | money('EUR') }} \u2192 1.234,50 \u20AC",
+      category: "format"
+    },
+    fn: (ctx, value, currency, locale) => {
+      const n = toNumber(value);
+      if (Number.isNaN(n)) return str(value);
+      return new Intl.NumberFormat(opt(locale, ctx.locale), {
+        style: "currency",
+        currency: opt(currency, ctx.currency)
+      }).format(n);
+    }
+  },
+  {
+    name: "number",
+    doc: {
+      signature: "number(value, decimals?, locale?)",
+      description: "Formats a number with grouping and a fixed number of decimals.",
+      example: "{{ qty | number(2) }} \u2192 1.234,00",
+      category: "format"
+    },
+    fn: (ctx, value, decimals, locale) => {
+      const n = toNumber(value);
+      if (Number.isNaN(n)) return str(value);
+      const d = decimals === void 0 || decimals === null ? void 0 : Number(decimals);
+      return new Intl.NumberFormat(opt(locale, ctx.locale), {
+        minimumFractionDigits: d,
+        maximumFractionDigits: d ?? 3
+      }).format(n);
+    }
+  },
+  {
+    name: "date",
+    doc: {
+      signature: "date(value, format?, tz?, locale?)",
+      description: "Formats a date with date-fns tokens (e.g. 'dd.MM.yyyy', 'PPP'). Accepts ISO strings, epoch numbers and 'now'.",
+      example: "{{ invoice.date | date('dd.MM.yyyy') }}",
+      category: "format"
+    },
+    fn: (ctx, value, format, tz, locale) => {
+      const d = toDate(value, opt(tz, ctx.timezone));
+      if (!d) return str(value);
+      return formatDate(d, opt(format, "PP"), {
+        locale: dateLocale(opt(locale, ctx.locale))
+      });
+    }
+  },
+  {
+    name: "dateAdd",
+    aliases: ["date_add"],
+    doc: {
+      signature: "dateAdd(value, amount, unit)",
+      description: "Adds days, weeks, months or years to a date; returns an ISO string for further formatting.",
+      example: "{{ invoice.date | dateAdd(14, 'days') | date('PP') }}",
+      category: "format"
+    },
+    fn: (ctx, value, amount, unit) => {
+      const d = toDate(value, ctx.timezone);
+      if (!d) return str(value);
+      const n = toNumber(amount);
+      const u = str(unit || "days").replace(/s?$/, "s");
+      return add(d, { [u]: n }).toISOString();
+    }
+  },
+  {
+    name: "add",
+    aliases: ["plus"],
+    doc: {
+      signature: "add(a, b)",
+      description: "a + b (Handlebars has no arithmetic of its own).",
+      example: "{{add @index 1}}",
+      category: "format"
+    },
+    fn: (_ctx, a, b) => toNumber(a) + toNumber(b)
+  },
+  {
+    name: "subtract",
+    aliases: ["minus", "sub"],
+    doc: {
+      signature: "subtract(a, b)",
+      description: "a minus b.",
+      example: "{{subtract total discount}}",
+      category: "format"
+    },
+    fn: (_ctx, a, b) => toNumber(a) - toNumber(b)
+  },
+  {
+    name: "multiply",
+    aliases: ["times", "mul"],
+    doc: {
+      signature: "multiply(a, b)",
+      description: "a times b.",
+      example: "{{money (multiply line.qty line.price)}}",
+      category: "format"
+    },
+    fn: (_ctx, a, b) => toNumber(a) * toNumber(b)
+  },
+  {
+    name: "divide",
+    aliases: ["divided_by", "div"],
+    doc: {
+      signature: "divide(a, b)",
+      description: "a divided by b; empty when b is 0.",
+      example: "{{divide total count}}",
+      category: "format"
+    },
+    fn: (_ctx, a, b) => toNumber(b) === 0 ? "" : toNumber(a) / toNumber(b)
+  },
+  {
+    name: "round",
+    doc: {
+      signature: "round(value, decimals = 0)",
+      description: "Rounds half away from zero.",
+      example: "{{ 2.345 | round(2) }} gives 2.35",
+      category: "format"
+    },
+    fn: (_ctx, value, decimals) => {
+      const n = toNumber(value);
+      const f = 10 ** (decimals === void 0 || decimals === null ? 0 : Number(decimals));
+      return Number.isNaN(n) ? "" : Math.round((Math.abs(n) + Number.EPSILON) * f) / f * Math.sign(n);
+    }
+  },
+  {
+    name: "upper",
+    aliases: ["upcase"],
+    doc: {
+      signature: "upper(value)",
+      description: "Upper-cases a string.",
+      example: "{{ name | upper }}",
+      category: "text"
+    },
+    fn: (_ctx, value) => str(value).toUpperCase()
+  },
+  {
+    name: "lower",
+    aliases: ["downcase"],
+    doc: {
+      signature: "lower(value)",
+      description: "Lower-cases a string.",
+      example: "{{ name | lower }}",
+      category: "text"
+    },
+    fn: (_ctx, value) => str(value).toLowerCase()
+  },
+  {
+    name: "title",
+    aliases: ["capitalize_words"],
+    doc: {
+      signature: "title(value)",
+      description: "Capitalises every word.",
+      example: "{{ 'hello world' | title }} \u2192 Hello World",
+      category: "text"
+    },
+    fn: (_ctx, value) => str(value).replace(
+      /\p{L}[\p{L}\p{M}]*/gu,
+      (w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()
+    )
+  },
+  {
+    name: "truncate",
+    doc: {
+      signature: "truncate(value, length = 255, suffix = '\u2026')",
+      description: "Cuts a string to `length` characters and appends the suffix when cut.",
+      example: "{{ description | truncate(40) }}",
+      category: "text"
+    },
+    fn: (_ctx, value, length, suffix) => {
+      const s = str(value);
+      const max = opt(Number(length), 255);
+      const end = opt(suffix, "\u2026");
+      return s.length <= max ? s : s.slice(0, Math.max(0, max - end.length)) + end;
+    }
+  },
+  {
+    name: "replace",
+    doc: {
+      signature: "replace(value, search, replacement)",
+      description: "Replaces every occurrence of `search`.",
+      example: "{{ iban | replace(' ', '') }}",
+      category: "text"
+    },
+    fn: (_ctx, value, search, replacement) => str(value).split(str(search)).join(str(replacement))
+  },
+  {
+    name: "split",
+    doc: {
+      signature: "split(value, separator = ',')",
+      description: "Splits a string into a list.",
+      example: "{% for tag in tags | split(',') %}",
+      category: "text"
+    },
+    fn: (_ctx, value, separator) => str(value).split(str(opt(separator, ",")))
+  },
+  {
+    name: "join",
+    doc: {
+      signature: "join(list, separator = ', ')",
+      description: "Joins a list into a string.",
+      example: "{{ tags | join(' \xB7 ') }}",
+      category: "collection"
+    },
+    fn: (_ctx, value, separator) => Array.isArray(value) ? value.map(str).join(str(opt(separator, ", "))) : str(value)
+  },
+  {
+    name: "default",
+    aliases: ["d"],
+    doc: {
+      signature: "default(value, fallback)",
+      description: "Returns the fallback when the value is empty, null or undefined.",
+      example: "{{ customer.vat | default('\u2014') }}",
+      category: "text"
+    },
+    fn: (_ctx, value, fallback) => value === void 0 || value === null || value === "" ? fallback : value
+  },
+  {
+    name: "nl2br",
+    html: true,
+    doc: {
+      signature: "nl2br(value)",
+      description: "Escapes the text and turns line breaks into <br>.",
+      example: "{{ address | nl2br }}",
+      category: "text"
+    },
+    fn: (_ctx, value) => escapeHtml(str(value)).replace(/\r?\n/g, "<br>\n")
+  },
+  {
+    name: "markdown",
+    html: true,
+    doc: {
+      signature: "markdown(value)",
+      description: "Renders Markdown to HTML (no sanitiser: template data is trusted by the author).",
+      example: "{{ notes | markdown }}",
+      category: "text"
+    },
+    fn: (_ctx, value) => marked.parse(str(value), {
+      async: false,
+      gfm: true,
+      breaks: false
+    })
+  },
+  {
+    name: "safe",
+    aliases: ["raw"],
+    html: true,
+    doc: {
+      signature: "safe(value)",
+      description: "Marks a string as HTML so the engine does not escape it.",
+      example: "{{ html_snippet | safe }}",
+      category: "text"
+    },
+    fn: (_ctx, value) => str(value)
+  },
+  {
+    name: "json",
+    aliases: ["tojson", "dump"],
+    doc: {
+      signature: "json(value, indent = 2)",
+      description: "Serialises a value as JSON; handy while building a template.",
+      example: "<pre>{{ invoice | json }}</pre>",
+      category: "debug"
+    },
+    fn: (_ctx, value, indent) => JSON.stringify(value, null, opt(Number(indent), 2))
+  },
+  {
+    name: "numToWords",
+    aliases: ["num_to_words", "spellout"],
+    doc: {
+      signature: "numToWords(value, locale?)",
+      description: "Spells a number out in words (de, en, fr, es, it, nl).",
+      example: "{{ total | numToWords('de') }} \u2192 zweihundertdreiundvierzig",
+      category: "format"
+    },
+    fn: (ctx, value, locale) => {
+      const n = toNumber(value);
+      if (Number.isNaN(n)) return str(value);
+      const lang = str(opt(locale, ctx.locale)).split("-")[0] ?? "en";
+      return (wordsByLang[lang] ?? enWords)(n);
+    }
+  },
+  {
+    name: "t",
+    aliases: ["translate"],
+    doc: {
+      signature: "t(key, params?)",
+      description: "Looks a key up in the template's i18n dictionary for the request locale; `{name}` placeholders come from params.",
+      example: "{{ t('invoice.title', { number: invoice.number }) }}",
+      category: "text"
+    },
+    fn: (ctx, key, params) => {
+      const dictionaries = ctx.i18n ?? {};
+      const lang = ctx.locale.split("-")[0] ?? ctx.locale;
+      const text = dictionaries[ctx.locale]?.[str(key)] ?? dictionaries[lang]?.[str(key)] ?? dictionaries["en"]?.[str(key)] ?? str(key);
+      const p = params ?? {};
+      return text.replace(/\{(\w+)\}/g, (_, name) => str(p[name]));
+    }
+  },
+  {
+    name: "asset",
+    doc: {
+      signature: "asset(name)",
+      description: "URL of a workspace asset (logo, background) on the CDN.",
+      example: `<img src="{{ asset('logo.png') }}">`,
+      category: "document"
+    },
+    fn: (ctx, name) => `${(ctx.assetBaseUrl ?? "").replace(/\/$/, "")}/${str(name).replace(/^\//, "")}`
+  },
+  {
+    name: "pageBreak",
+    aliases: ["page_break"],
+    html: true,
+    doc: {
+      signature: "pageBreak()",
+      description: "Starts a new page in PDF output.",
+      example: "{{ pageBreak() }}",
+      category: "document"
+    },
+    fn: () => '<div class="page-break" style="break-after:page"></div>'
+  }
+];
+
+// packages/engine/src/lib/helpers/codes.ts
+var svgDataUri = (svg) => `data:image/svg+xml;utf8,${encodeURIComponent(svg)}`;
+var barcodeTypes = {
+  code128: "code128",
+  ean13: "ean13",
+  ean8: "ean8",
+  upc: "upca",
+  upca: "upca",
+  itf14: "itf14",
+  code39: "code39",
+  qrcode: "qrcode",
+  datamatrix: "datamatrix",
+  pdf417: "pdf417"
+};
+function qrSvg(value, options = {}) {
+  const qr = createQr(value, { errorCorrectionLevel: options.ecc ?? "M" });
+  const svg = renderQrSvg(qr, {
+    width: options.size ?? 160,
+    margin: options.margin ?? 1,
+    color: {
+      dark: (options.color ?? "#000000").replace(/^(#?)/, "#").slice(0, 9),
+      light: (options.background ?? "#ffffff").replace(/^(#?)/, "#")
+    }
+  });
+  return svg;
+}
+function epcPayload(input) {
+  const amount = input.amount === void 0 || input.amount === "" ? "" : `EUR${toNumber(input.amount).toFixed(2)}`;
+  return [
+    "BCD",
+    "002",
+    "1",
+    "SCT",
+    (input.bic ?? "").replace(/\s/g, ""),
+    String(input.name ?? "").slice(0, 70),
+    String(input.iban ?? "").replace(/\s/g, ""),
+    amount,
+    (input.purpose ?? "").slice(0, 4),
+    (input.reference ?? "").slice(0, 35),
+    input.reference ? "" : (input.text ?? "").slice(0, 140),
+    ""
+  ].join("\n");
+}
+var codeHelpers = [
+  {
+    name: "qrcode",
+    aliases: ["qr"],
+    doc: {
+      signature: "qrcode(value, { size = 160, ecc = 'M', margin = 1, color, background })",
+      description: "QR code as an SVG data URI for an <img> src.",
+      example: '<img src="{{ qrcode(order.url, { size: 120 }) }}">',
+      category: "code"
+    },
+    fn: (_ctx, value, options) => svgDataUri(qrSvg(String(value ?? ""), options ?? {}))
+  },
+  {
+    name: "barcode",
+    doc: {
+      signature: "barcode(value, { type = 'code128', height = 12, width, text = true, scale = 2 })",
+      description: "Barcode (code128, ean13, ean8, upc, itf14, code39, datamatrix, pdf417) as an SVG data URI.",
+      example: `<img src="{{ barcode(item.sku, { type: 'code128' }) }}">`,
+      category: "code"
+    },
+    fn: (_ctx, value, options) => {
+      const o = options ?? {};
+      const bcid = barcodeTypes[String(o.type ?? "code128").toLowerCase()] ?? "code128";
+      const svg = toSVG({
+        bcid,
+        text: String(value ?? ""),
+        height: o.height ?? 12,
+        ...o.width === void 0 ? {} : { width: o.width },
+        scale: o.scale ?? 2,
+        includetext: o.text !== false,
+        textxalign: "center"
+      });
+      return svgDataUri(svg);
+    }
+  },
+  {
+    name: "epcQr",
+    aliases: ["epc_qr", "girocode"],
+    doc: {
+      signature: "epcQr({ name, iban, bic?, amount?, reference?, text? }, { size })",
+      description: "SEPA credit transfer QR code (EPC069-12 / GiroCode) that banking apps scan to prefill a payment.",
+      example: '<img src="{{ epcQr({ name: company.name, iban: company.iban, amount: invoice.total, reference: invoice.number }) }}">',
+      category: "code"
+    },
+    // Payment fields and QR options may arrive together: Jinja2 passes two objects, Handlebars one
+    // hash (`{{epcQr name=… iban=… size=200}}`), and Liquid, which cannot build an object literal,
+    // keyword arguments (`{{ company.iban | epcQr: name: company.name, amount: invoice.total }}`,
+    // where a string input is the IBAN). They are merged and split by field name.
+    fn: (_ctx, input, options) => {
+      const fields = {
+        ...input && typeof input === "object" ? input : typeof input === "string" && input ? { iban: input } : {},
+        ...options ?? {}
+      };
+      const payment = {};
+      const qr = {};
+      for (const [key, value] of Object.entries(fields))
+        (EPC_FIELDS.has(key) ? payment : qr)[key] = value;
+      return svgDataUri(
+        qrSvg(epcPayload(payment), {
+          ecc: "M",
+          ...qr
+        })
+      );
+    }
+  }
+];
+var EPC_FIELDS = /* @__PURE__ */ new Set(["name", "iban", "bic", "amount", "reference", "text", "purpose"]);
+
+// packages/engine/src/lib/helpers/collections.ts
+var list = (v) => Array.isArray(v) ? v : v === void 0 || v === null ? [] : [v];
+var get = (item, path) => String(path ?? "").split(".").filter(Boolean).reduce(
+  (acc, key) => acc && typeof acc === "object" ? acc[key] : void 0,
+  item
+);
+var numbers = (v, path) => list(v).map((item) => toNumber(path ? get(item, path) : item)).filter((n) => !Number.isNaN(n));
+var collectionHelpers = [
+  {
+    name: "sum",
+    doc: {
+      signature: "sum(list, path?)",
+      description: "Sum of the items, or of `path` inside each item.",
+      example: "{{ invoice.lines | sum('total') | money }}",
+      category: "collection"
+    },
+    fn: (_ctx, value, path) => numbers(value, path).reduce((a, b) => a + b, 0)
+  },
+  {
+    name: "avg",
+    doc: {
+      signature: "avg(list, path?)",
+      description: "Average of the items or of `path` inside each item.",
+      example: "{{ scores | avg | number(1) }}",
+      category: "collection"
+    },
+    fn: (_ctx, value, path) => {
+      const ns = numbers(value, path);
+      return ns.length ? ns.reduce((a, b) => a + b, 0) / ns.length : 0;
+    }
+  },
+  {
+    name: "min",
+    doc: {
+      signature: "min(list, path?)",
+      description: "Smallest number.",
+      example: "{{ prices | min }}",
+      category: "collection"
+    },
+    fn: (_ctx, value, path) => Math.min(...numbers(value, path))
+  },
+  {
+    name: "max",
+    doc: {
+      signature: "max(list, path?)",
+      description: "Largest number.",
+      example: "{{ prices | max }}",
+      category: "collection"
+    },
+    fn: (_ctx, value, path) => Math.max(...numbers(value, path))
+  },
+  {
+    name: "groupBy",
+    aliases: ["group_by", "groupby"],
+    doc: {
+      signature: "groupBy(list, path)",
+      description: "Groups items by a field; returns a list of `{ key, items }`.",
+      example: "{% for group in lines | groupBy('category') %}{{ group.key }}{% endfor %}",
+      category: "collection"
+    },
+    fn: (_ctx, value, path) => {
+      const groups = /* @__PURE__ */ new Map();
+      for (const item of list(value)) {
+        const key = String(get(item, path) ?? "");
+        groups.set(key, [...groups.get(key) ?? [], item]);
+      }
+      return [...groups.entries()].map(([key, items]) => ({ key, items }));
+    }
+  },
+  {
+    name: "sortBy",
+    aliases: ["sort_by", "sort"],
+    doc: {
+      signature: "sortBy(list, path?, direction = 'asc')",
+      description: "Sorts items by a field (numbers numerically, strings by locale).",
+      example: "{% for l in lines | sortBy('position') %}",
+      category: "collection"
+    },
+    fn: (ctx, value, path, direction) => {
+      const dir = String(direction ?? "asc").toLowerCase() === "desc" ? -1 : 1;
+      const collator = new Intl.Collator(ctx.locale, { numeric: true });
+      return [...list(value)].sort((a, b) => {
+        const x = path ? get(a, path) : a;
+        const y = path ? get(b, path) : b;
+        if (typeof x === "number" && typeof y === "number")
+          return (x - y) * dir;
+        return collator.compare(String(x ?? ""), String(y ?? "")) * dir;
+      });
+    }
+  },
+  {
+    name: "where",
+    aliases: ["filter_by"],
+    doc: {
+      signature: "where(list, path, value?)",
+      description: "Keeps items whose field equals `value` (or is truthy when omitted).",
+      example: "{% for l in lines | where('taxable', true) %}",
+      category: "collection"
+    },
+    fn: (_ctx, value, path, expected) => list(value).filter((item) => {
+      const v = get(item, path);
+      return expected === void 0 ? Boolean(v) : v === expected || String(v) === String(expected);
+    })
+  },
+  {
+    name: "pluck",
+    aliases: ["map"],
+    doc: {
+      signature: "pluck(list, path)",
+      description: "Extracts one field from every item.",
+      example: "{{ lines | pluck('sku') | join(', ') }}",
+      category: "collection"
+    },
+    fn: (_ctx, value, path) => list(value).map((item) => get(item, path))
+  },
+  {
+    name: "chunk",
+    aliases: ["batch"],
+    doc: {
+      signature: "chunk(list, size)",
+      description: "Splits a list into lists of `size` items (rows of labels, columns).",
+      example: "{% for row in labels | chunk(3) %}",
+      category: "collection"
+    },
+    fn: (_ctx, value, size) => {
+      const n = Math.max(1, toNumber(size) || 1);
+      const items = list(value);
+      const out = [];
+      for (let i = 0; i < items.length; i += n) out.push(items.slice(i, i + n));
+      return out;
+    }
+  },
+  {
+    name: "range",
+    doc: {
+      signature: "range(start, end?, step = 1)",
+      description: "List of numbers from start to end (exclusive).",
+      example: "{% for i in range(1, 4) %}",
+      category: "collection"
+    },
+    fn: (_ctx, start, end, step) => {
+      let from = toNumber(start);
+      const to = end === void 0 || end === null ? from : toNumber(end);
+      if (end === void 0 || end === null) from = 0;
+      const by = toNumber(step) || 1;
+      const out = [];
+      for (let i = from; by > 0 ? i < to : i > to; i += by) out.push(i);
+      return out;
+    }
+  },
+  {
+    name: "first",
+    doc: {
+      signature: "first(list)",
+      description: "First item.",
+      example: "{{ lines | first }}",
+      category: "collection"
+    },
+    fn: (_ctx, value) => list(value)[0]
+  },
+  {
+    name: "last",
+    doc: {
+      signature: "last(list)",
+      description: "Last item.",
+      example: "{{ lines | last }}",
+      category: "collection"
+    },
+    fn: (_ctx, value) => list(value).at(-1)
+  },
+  {
+    name: "length",
+    aliases: ["size", "count"],
+    doc: {
+      signature: "length(value)",
+      description: "Number of items in a list, keys in an object or characters in a string.",
+      example: "{{ lines | length }}",
+      category: "collection"
+    },
+    fn: (_ctx, value) => Array.isArray(value) || typeof value === "string" ? value.length : value && typeof value === "object" ? Object.keys(value).length : 0
+  }
+];
+
+// packages/engine/src/lib/helpers/document.ts
+var css = (value) => {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const n = toNumber(value);
+  return Number.isFinite(n) && String(value).trim() === String(n) ? `${n}px` : String(value);
+};
+function chartPayload(spec) {
+  const options = { ...spec.options ?? {} };
+  options["animation"] = false;
+  options["responsive"] = false;
+  return { type: spec.type ?? "bar", data: spec.data ?? {}, options };
+}
+function chartMarkup(spec, id) {
+  const width = toNumber(spec.width ?? 480) || 480;
+  const height = toNumber(spec.height ?? 240) || 240;
+  const payload = escapeHtml(JSON.stringify(chartPayload(spec)));
+  const idAttr = id ? ` id="${escapeHtml(id)}"` : "";
+  return `<canvas class="ff-chart"${idAttr} width="${width}" height="${height}" style="width:${width}px;height:${height}px" data-ff-chart="${payload}"></canvas>`;
+}
+function imageMarkup(url, options = {}) {
+  const styles = [
+    css(options.width) ? `width:${css(options.width)}` : "",
+    css(options.height) ? `height:${css(options.height)}` : "",
+    options.fit ? `object-fit:${options.fit}` : ""
+  ].filter(Boolean).join(";");
+  const cls = options.class ? ` class="${escapeHtml(options.class)}"` : "";
+  const style = styles ? ` style="${styles}"` : "";
+  return `<img src="${escapeHtml(url)}" alt="${escapeHtml(options.alt ?? "")}"${cls}${style}>`;
+}
+var asObject = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var documentHelpers = [
+  {
+    name: "chart",
+    html: true,
+    doc: {
+      signature: "chart({ type, data, options, width, height })",
+      description: "Draws a Chart.js chart (bar, line, pie, doughnut, radar, \u2026) from a chart configuration; animations are disabled so PDF and preview match.",
+      example: "{{ chart({ type: 'bar', data: sales, width: 480, height: 240 }) }}",
+      category: "document"
+    },
+    fn: (_ctx, spec, extra) => chartMarkup({ ...asObject(spec), ...asObject(extra) })
+  },
+  {
+    name: "image",
+    html: true,
+    doc: {
+      signature: "image(url, { width, height, fit, alt })",
+      description: "Places an image with fixed size and crop mode (`cover`, `contain`, `fill`); the render-worker fetches it through its cache and blocks private hosts.",
+      example: "{{ image(product.photo, { width: 120, height: 80, fit: 'cover' }) }}",
+      category: "document"
+    },
+    fn: (_ctx, url, options) => imageMarkup(String(url ?? ""), asObject(options))
+  }
+];
+
+// packages/engine/src/lib/helpers/logic.ts
+var same = (a, b) => a === b || a !== null && b !== null && a !== void 0 && b !== void 0 && String(a) === String(b);
+function compare(a, b) {
+  const x = typeof a === "number" ? a : Number(a);
+  const y = typeof b === "number" ? b : Number(b);
+  if (a !== "" && b !== "" && Number.isFinite(x) && Number.isFinite(y)) return x - y;
+  return String(a ?? "").localeCompare(String(b ?? ""));
+}
+var truthy = (v) => Array.isArray(v) ? v.length > 0 : Boolean(v);
+var comparison = (name, test, description) => ({
+  name,
+  doc: {
+    signature: `${name}(a, b)`,
+    description,
+    example: `{{#if (${name} invoice.total 1000)}}\u2026{{/if}}`,
+    category: "logic"
+  },
+  fn: (_ctx, a, b) => test(a, b)
+});
+var logicHelpers = [
+  comparison("eq", same, 'True when both values are equal; `1` equals `"1"`.'),
+  comparison("ne", (a, b) => !same(a, b), "True when the values differ."),
+  comparison("gt", (a, b) => compare(a, b) > 0, "Greater than; numbers as numbers, anything else as text."),
+  comparison("gte", (a, b) => compare(a, b) >= 0, "Greater than or equal."),
+  comparison("lt", (a, b) => compare(a, b) < 0, "Less than."),
+  comparison("lte", (a, b) => compare(a, b) <= 0, "Less than or equal."),
+  {
+    name: "and",
+    doc: {
+      signature: "and(a, b, \u2026)",
+      description: "True when every value is true; an empty list counts as false.",
+      example: '{{#if (and customer.vatId (eq country "DE"))}}\u2026{{/if}}',
+      category: "logic"
+    },
+    fn: (_ctx, ...values) => values.length > 0 && values.every(truthy)
+  },
+  {
+    name: "or",
+    doc: {
+      signature: "or(a, b, \u2026)",
+      description: "True when any value is true.",
+      example: "{{#if (or invoice.paid invoice.credited)}}\u2026{{/if}}",
+      category: "logic"
+    },
+    fn: (_ctx, ...values) => values.some(truthy)
+  },
+  {
+    name: "not",
+    doc: {
+      signature: "not(value)",
+      description: "The opposite truth value.",
+      example: "{{#if (not invoice.paid)}}\u2026{{/if}}",
+      category: "logic"
+    },
+    fn: (_ctx, value) => !truthy(value)
+  }
+];
+
+// packages/engine/src/lib/helpers/registry.ts
+var DefaultHelperRegistry = class {
+  byName = /* @__PURE__ */ new Map();
+  aliasToName = /* @__PURE__ */ new Map();
+  constructor(definitions = []) {
+    for (const d of definitions) this.register(d);
+  }
+  get definitions() {
+    return this.byName;
+  }
+  register(definition) {
+    this.byName.set(definition.name, definition);
+    for (const alias of definition.aliases ?? [])
+      this.aliasToName.set(alias, definition.name);
+    for (const alias of Object.keys(definition.deprecatedAlias ?? {}))
+      this.aliasToName.set(alias, definition.name);
+  }
+  get(name) {
+    return this.byName.get(name) ?? this.byName.get(this.aliasToName.get(name) ?? "");
+  }
+  has(name) {
+    return this.get(name) !== void 0;
+  }
+  names() {
+    return [...this.byName.keys(), ...this.aliasToName.keys()];
+  }
+  /** The preferred name when `name` is a deprecated alias, otherwise undefined. */
+  deprecationOf(name) {
+    const def = this.get(name);
+    return def?.deprecatedAlias?.[name];
+  }
+  bind(ctx) {
+    const bound = /* @__PURE__ */ new Map();
+    for (const def of this.byName.values()) {
+      const entry = {
+        fn: (...args) => def.fn(ctx, ...args),
+        html: def.html ?? false
+      };
+      bound.set(def.name, entry);
+      for (const alias of def.aliases ?? []) bound.set(alias, entry);
+      for (const alias of Object.keys(def.deprecatedAlias ?? {}))
+        bound.set(alias, entry);
+    }
+    return bound;
+  }
+};
+
+// packages/engine/src/lib/helpers/index.ts
+var builtinHelpers = [
+  ...formatHelpers,
+  ...collectionHelpers,
+  ...logicHelpers,
+  ...codeHelpers,
+  ...documentHelpers
+];
+function createHelperRegistry(extra = []) {
+  return new DefaultHelperRegistry([...builtinHelpers, ...extra]);
+}
+var shared;
+function defaultHelpers() {
+  return shared ??= createHelperRegistry();
+}
+function helperDocs(registry = defaultHelpers()) {
+  return [...registry.definitions.values()].map((d) => ({
+    name: d.name,
+    aliases: d.aliases ?? [],
+    ...d.doc
+  }));
+}
+
+// packages/engine/src/lib/engines/handlebars.ts
+import Handlebars from "handlebars";
+
+// packages/engine/src/lib/analysis/tags.ts
+function rangeAt(line, column, length) {
+  return {
+    start: { line, column },
+    end: { line, column: column + Math.max(1, length) }
+  };
+}
+function positionOf(source, offset) {
+  let line = 1;
+  let last = -1;
+  for (let i = 0; i < offset && i < source.length; i++) {
+    if (source.charCodeAt(i) === 10) {
+      line++;
+      last = i;
+    }
+  }
+  return { line, column: offset - last };
+}
+function rangeOf(source, start, end) {
+  return { start: positionOf(source, start), end: positionOf(source, end) };
+}
+var jinjaTags = {
+  pattern: /\{%-?\s*(\w+)([\s\S]*?)-?%\}/g,
+  openers: {
+    for: "for",
+    if: "if",
+    block: "block",
+    raw: "raw",
+    macro: "macro",
+    set: "other",
+    call: "other",
+    filter: "other",
+    autoescape: "other",
+    verbatim: "raw"
+  },
+  closers: {
+    endfor: "for",
+    endif: "if",
+    endblock: "block",
+    endraw: "raw",
+    endmacro: "macro",
+    endset: "set",
+    endcall: "call",
+    endfilter: "filter",
+    endautoescape: "autoescape",
+    endverbatim: "verbatim"
+  },
+  continuations: ["elif", "else"]
+};
+var liquidTags = {
+  pattern: /\{%-?\s*(\w+)([\s\S]*?)-?%\}/g,
+  openers: {
+    for: "for",
+    if: "if",
+    unless: "if",
+    case: "if",
+    raw: "raw",
+    capture: "other",
+    tablerow: "for",
+    comment: "other"
+  },
+  closers: {
+    endfor: "for",
+    endif: "if",
+    endunless: "unless",
+    endcase: "case",
+    endraw: "raw",
+    endcapture: "capture",
+    endtablerow: "tablerow",
+    endcomment: "comment"
+  },
+  continuations: ["elsif", "else", "when"]
+};
+function scanBlocks(source, spec) {
+  const blocks = [];
+  const diagnostics = [];
+  const stack = [];
+  const pattern = new RegExp(spec.pattern.source, "g");
+  let m;
+  let inRaw = null;
+  const isBlockOpener = (keyword, rest) => keyword === "set" ? !rest.includes("=") : keyword in spec.openers;
+  while (m = pattern.exec(source)) {
+    const keyword = m[1] ?? "";
+    const rest = m[2] ?? "";
+    const range = rangeOf(source, m.index, m.index + m[0].length);
+    if (inRaw) {
+      if (spec.closers[keyword] === inRaw) {
+        const open = stack.pop();
+        if (open) open.block.close = range;
+        inRaw = null;
+      }
+      continue;
+    }
+    if (isBlockOpener(keyword, rest)) {
+      const block = {
+        type: spec.openers[keyword] ?? "other",
+        open: range
+      };
+      blocks.push(block);
+      stack.push({ keyword, block });
+      if (block.type === "raw" || keyword === "comment") inRaw = keyword;
+    } else if (keyword in spec.closers) {
+      const expected = spec.closers[keyword];
+      const top = stack.at(-1);
+      if (!top) {
+        diagnostics.push({
+          severity: "error",
+          code: "unexpected-end-tag",
+          message: `Unexpected {% ${keyword} %} without an open block`,
+          range
+        });
+      } else if (top.keyword !== expected) {
+        diagnostics.push({
+          severity: "error",
+          code: "mismatched-end-tag",
+          message: `Expected {% end${top.keyword} %} to close the {% ${top.keyword} %} at line ${top.block.open.start.line}, found {% ${keyword} %}`,
+          range
+        });
+        const idx = stack.map((s) => s.keyword).lastIndexOf(expected);
+        if (idx >= 0) {
+          const closed = stack.splice(idx, 1)[0];
+          if (closed) closed.block.close = range;
+        }
+      } else {
+        stack.pop();
+        top.block.close = range;
+      }
+    } else if (spec.continuations.includes(keyword) && !stack.length) {
+      diagnostics.push({
+        severity: "error",
+        code: "unexpected-tag",
+        message: `{% ${keyword} %} outside of a block`,
+        range
+      });
+    }
+  }
+  for (const open of stack) {
+    diagnostics.push({
+      severity: "error",
+      code: "unclosed-block",
+      message: `{% ${open.keyword} %} is never closed; add {% end${open.keyword} %}`,
+      range: open.block.open
+    });
+  }
+  return { blocks, diagnostics };
+}
+function resolvePath(data, path) {
+  let current = data;
+  for (const key of path) {
+    if (Array.isArray(current)) {
+      if (/^\d+$/.test(key)) {
+        current = current[Number(key)];
+        continue;
+      }
+      const hit = current.find(
+        (item) => item && typeof item === "object" && key in item
+      );
+      if (!hit) return { found: false, value: void 0 };
+      current = hit[key];
+      continue;
+    }
+    if (current && typeof current === "object" && key in current) {
+      current = current[key];
+    } else {
+      return { found: false, value: void 0 };
+    }
+  }
+  return { found: true, value: current };
+}
+function missingPathDiagnostics(variables, sampleData, loopSources, builtinRoots4) {
+  if (sampleData === void 0 || sampleData === null || typeof sampleData !== "object")
+    return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const v of variables) {
+    if (v.kind === "assigned") continue;
+    const root = v.path[0];
+    if (!root || builtinRoots4.has(root)) continue;
+    let path = v.path;
+    if (loopSources.has(root)) {
+      const source = loopSources.get(root);
+      if (!source) continue;
+      path = [...source, ...v.path.slice(1)];
+    }
+    const key = path.join(".");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (!resolvePath(sampleData, path).found) {
+      out.push({
+        severity: "warning",
+        code: "unknown-variable",
+        message: `"${v.path.join(".")}" is not present in the sample data`,
+        range: v.range
+      });
+    }
+  }
+  return out;
+}
+
+// packages/engine/src/lib/engines/handlebars.ts
+var builtinHelpers2 = /* @__PURE__ */ new Set([
+  "if",
+  "unless",
+  "each",
+  "with",
+  "lookup",
+  "log",
+  "blockHelperMissing",
+  "helperMissing"
+]);
+var builtinRoots = /* @__PURE__ */ new Set([
+  "this",
+  "@index",
+  "@key",
+  "@first",
+  "@last",
+  "@root",
+  "lookup"
+]);
+function createInstance(ctx) {
+  const hb = Handlebars.create();
+  for (const [name, { fn, html }] of ctx.helpers.bind(ctx)) {
+    hb.registerHelper(name, function(...args) {
+      const options = args.at(-1);
+      const params = args.slice(0, -1);
+      const hasHash = !!options?.hash && Object.keys(options.hash).length > 0;
+      if (params.length === 0 && !hasHash && this !== null && this !== void 0 && Object.prototype.hasOwnProperty.call(Object(this), name))
+        return this[name];
+      if (hasHash) params.push(options.hash);
+      const result = fn(...params);
+      return html ? new hb.SafeString(String(result ?? "")) : result;
+    });
+  }
+  return hb;
+}
+var validationContext = {
+  locale: "en",
+  timezone: "UTC",
+  currency: "EUR",
+  partials: () => void 0,
+  helpers: defaultHelpers(),
+  limits: { ms: 2e3, outputBytes: 20 * 1024 * 1024, includeDepth: 8 }
+};
+function toSyntaxError(e) {
+  const err = e;
+  const message = String(err.message ?? e);
+  const m = /Parse error on line (\d+)/.exec(message);
+  const line = err.lineNumber ?? (m ? Number(m[1]) : 1);
+  const column = typeof err.column === "number" ? err.column + 1 : 1;
+  return new EngineSyntaxError(
+    "handlebars",
+    message.split("\n")[0] ?? message,
+    line,
+    column
+  );
+}
+function toRange(loc) {
+  if (!loc) return rangeAt(1, 1, 1);
+  return {
+    start: { line: loc.start.line, column: loc.start.column + 1 },
+    end: { line: loc.end.line, column: loc.end.column + 1 }
+  };
+}
+function pathParts(path) {
+  const parts = path.parts.map(String);
+  if (path.data) return [`@${parts[0] ?? ""}`, ...parts.slice(1)];
+  return parts;
+}
+function resolve(w, path) {
+  const parts = pathParts(path);
+  const original = path.original;
+  let depth = 0;
+  let rest = parts;
+  while (original.startsWith("../".repeat(depth + 1))) depth++;
+  const rootScope = w.scopes[0] ?? {
+    source: [],
+    params: /* @__PURE__ */ new Map(),
+    loop: false
+  };
+  const scope = w.scopes[w.scopes.length - 1 - depth] ?? rootScope;
+  if (rest[0] === "this") rest = rest.slice(1);
+  if (original.startsWith("@root"))
+    return { abs: rest, kind: "read", display: parts };
+  const first = rest[0] ?? "";
+  for (let i = w.scopes.length - 1 - depth; i >= 0; i--) {
+    const s = w.scopes[i];
+    if (s?.params.has(first)) {
+      const src = s.params.get(first);
+      return {
+        abs: src ? [...src, ...rest.slice(1)] : null,
+        kind: "loop-var",
+        display: parts
+      };
+    }
+  }
+  const inLoop = w.scopes.slice(0, w.scopes.length - depth).some((s) => s.loop);
+  return {
+    abs: scope.source ? [...scope.source, ...rest] : null,
+    kind: inLoop || scope !== w.scopes[0] ? "loop-var" : "read",
+    display: parts
+  };
+}
+function walk(node, w) {
+  if (!node) return;
+  switch (node.type) {
+    case "Program":
+      for (const s of node.body) walk(s, w);
+      return;
+    case "MustacheStatement":
+    case "SubExpression": {
+      const n = node;
+      const path = n.path;
+      const name = path.original;
+      const bare = n.params.length === 0 && Object.keys(n.hash?.pairs ?? {}).length === 0;
+      const isHelper = !bare || builtinHelpers2.has(name) || takesNoArguments(w.helpers, name);
+      if (isHelper && path.type === "PathExpression") {
+        w.filters.push({
+          name,
+          range: toRange(path.loc),
+          known: w.helpers.has(name) || builtinHelpers2.has(name)
+        });
+      } else if (path.type === "PathExpression") {
+        recordVariable(w, path);
+      } else {
+        walk(path, w);
+      }
+      for (const p of n.params) walk(p, w);
+      for (const pair of n.hash?.pairs ?? []) walk(pair.value, w);
+      return;
+    }
+    case "BlockStatement": {
+      const n = node;
+      const path = n.path;
+      const name = path.original;
+      const type = name === "each" ? "for" : name === "if" || name === "unless" ? "if" : "block";
+      w.blocks.push({ type, open: toRange(n.loc), close: toRange(n.loc) });
+      if (!builtinHelpers2.has(name)) {
+        w.filters.push({
+          name,
+          range: toRange(path.loc),
+          known: w.helpers.has(name)
+        });
+      }
+      for (const p of n.params) walk(p, w);
+      const subject = n.params[0];
+      const subjectPath = subject?.type === "PathExpression" ? resolve(w, subject).abs : null;
+      const scope = {
+        source: w.scopes.at(-1)?.source ?? [],
+        params: /* @__PURE__ */ new Map(),
+        loop: false
+      };
+      if (name === "each") {
+        scope.loop = true;
+        scope.source = subjectPath;
+        const [item, index] = n.program?.blockParams ?? [];
+        if (item) scope.params.set(item, subjectPath);
+        if (index) scope.params.set(index, null);
+      } else if (name === "with") {
+        scope.source = subjectPath;
+        const [alias] = n.program?.blockParams ?? [];
+        if (alias) scope.params.set(alias, subjectPath);
+      } else {
+        for (const p of n.program?.blockParams ?? []) scope.params.set(p, null);
+      }
+      w.scopes.push(scope);
+      walk(n.program, w);
+      w.scopes.pop();
+      walk(n.inverse, w);
+      return;
+    }
+    case "PartialStatement":
+    case "PartialBlockStatement": {
+      const n = node;
+      const nameNode = n.name;
+      if (nameNode.type === "PathExpression")
+        w.includes.push({ name: nameNode.original, range: toRange(n.loc) });
+      for (const p of n.params) walk(p, w);
+      for (const pair of n.hash?.pairs ?? []) walk(pair.value, w);
+      return;
+    }
+    case "PathExpression":
+      recordVariable(w, node);
+      return;
+    default:
+      return;
+  }
+}
+function takesNoArguments(helpers, name) {
+  return /^\w+\(\)$/.test(helpers.get(name)?.doc.signature ?? "");
+}
+function recordVariable(w, path) {
+  const parts = pathParts(path);
+  if (parts.length === 0 || builtinRoots.has(parts[0] ?? "") || path.data)
+    return;
+  const r = resolve(w, path);
+  const ref = {
+    path: r.display,
+    range: toRange(path.loc),
+    kind: r.kind
+  };
+  w.variables.push(ref);
+  const key = r.display.join(".");
+  if (r.kind === "loop-var") w.loopSources.set(key, r.abs);
+}
+function analyzeHandlebars(source, opts = {}) {
+  const helpers = opts.helpers ?? defaultHelpers();
+  const w = {
+    variables: [],
+    filters: [],
+    includes: [],
+    blocks: [],
+    scopes: [{ source: [], params: /* @__PURE__ */ new Map(), loop: false }],
+    helpers,
+    loopSources: /* @__PURE__ */ new Map()
+  };
+  const diagnostics = [];
+  try {
+    walk(Handlebars.parse(source), w);
+  } catch (e) {
+    const err = toSyntaxError(e);
+    diagnostics.push({
+      severity: "error",
+      code: "syntax-error",
+      message: err.message,
+      range: rangeAt(err.line, err.column, 1)
+    });
+  }
+  const registry = helpers;
+  for (const f of w.filters) {
+    const preferred = registry.deprecationOf?.(f.name);
+    if (preferred) {
+      diagnostics.push({
+        severity: "warning",
+        code: "deprecated-filter",
+        message: `"${f.name}" is a compatibility alias; use "${preferred}"`,
+        range: f.range,
+        fix: { title: `Rename to ${preferred}`, replacement: preferred }
+      });
+    } else if (!f.known) {
+      diagnostics.push({
+        severity: "error",
+        code: "unknown-filter",
+        message: `Unknown helper "${f.name}"`,
+        range: f.range
+      });
+    }
+  }
+  const forCheck = w.variables.map(
+    (v) => v.kind === "loop-var" ? { ...v, path: [v.path.join(".")] } : v
+  );
+  const dataDiagnostics = missingPathDiagnostics(
+    forCheck,
+    opts.sampleData,
+    w.loopSources,
+    /* @__PURE__ */ new Set([...builtinRoots, ...helpers.names()])
+  ).map((d) => ({
+    ...d,
+    message: d.message.replace(/"([^"]+)"/, (_, p) => `"${p}"`)
+  }));
+  return {
+    variables: w.variables,
+    filters: w.filters,
+    includes: w.includes,
+    blocks: w.blocks,
+    diagnostics: [...diagnostics, ...dataDiagnostics]
+  };
+}
+var HandlebarsCompiled = class {
+  constructor(name, source) {
+    this.name = name;
+    this.source = source;
+  }
+  engine = "handlebars";
+  runtimes = /* @__PURE__ */ new WeakMap();
+  runtime(ctx) {
+    let rt = this.runtimes.get(ctx);
+    if (!rt) {
+      const hb = createInstance(ctx);
+      rt = {
+        hb,
+        template: hb.compile(this.source, {
+          strict: false,
+          noEscape: false,
+          preventIndent: true
+        })
+      };
+      this.runtimes.set(ctx, rt);
+    }
+    return rt;
+  }
+  async render(data, ctx) {
+    const started = Date.now();
+    const { template } = this.runtime(ctx);
+    const partials = {};
+    const collect = (source, depth) => {
+      for (const inc of analyzeHandlebars(source).includes) {
+        if (inc.name in partials) continue;
+        if (depth >= ctx.limits.includeDepth) {
+          throw new RenderLimitError(
+            "includeDepth",
+            `Partials nest deeper than ${ctx.limits.includeDepth} (${inc.name})`
+          );
+        }
+        const src = ctx.partials(inc.name);
+        if (src === void 0) continue;
+        partials[inc.name] = src;
+        collect(src, depth + 1);
+      }
+    };
+    collect(this.source, 0);
+    try {
+      const out = template(data ?? {}, {
+        partials,
+        allowProtoPropertiesByDefault: false,
+        allowProtoMethodsByDefault: false
+      });
+      return enforceLimits(out, started, ctx.limits);
+    } catch (e) {
+      if (e instanceof Error && e.name === "RenderLimitError") throw e;
+      const err = e;
+      throw new RenderError(
+        "handlebars",
+        String(err.message ?? e),
+        err.lineNumber,
+        err.column === void 0 ? void 0 : err.column + 1
+      );
+    }
+  }
+};
+var handlebarsEngine = {
+  id: "handlebars",
+  compile(source, opts = {}) {
+    const name = opts.name ?? "template";
+    try {
+      createInstance(validationContext).precompile(source, { strict: false });
+    } catch (e) {
+      throw toSyntaxError(e);
+    }
+    return new HandlebarsCompiled(name, source);
+  },
+  analyze: analyzeHandlebars,
+  render: (tpl, data, ctx) => tpl.render(data, ctx)
+};
+
+// packages/engine/src/lib/engines/jinja2.ts
+import nunjucks from "nunjucks/browser/nunjucks.js";
+var nunjucksBuiltinFilters = /* @__PURE__ */ new Set([
+  "abs",
+  "batch",
+  "capitalize",
+  "center",
+  "default",
+  "d",
+  "dictsort",
+  "dump",
+  "escape",
+  "e",
+  "first",
+  "float",
+  "forceescape",
+  "groupby",
+  "indent",
+  "int",
+  "join",
+  "last",
+  "length",
+  "list",
+  "lower",
+  "nl2br",
+  "random",
+  "reject",
+  "rejectattr",
+  "replace",
+  "reverse",
+  "round",
+  "safe",
+  "select",
+  "selectattr",
+  "slice",
+  "sort",
+  "string",
+  "striptags",
+  "sum",
+  "title",
+  "trim",
+  "truncate",
+  "upper",
+  "urlencode",
+  "urlize",
+  "wordcount"
+]);
+var builtinRoots2 = /* @__PURE__ */ new Set([
+  "loop",
+  "caller",
+  "super",
+  "range",
+  "cycler",
+  "joiner",
+  "lipsum",
+  "varargs",
+  "kwargs"
+]);
+var stringMethods = {
+  upper: (s) => s.toUpperCase(),
+  lower: (s) => s.toLowerCase(),
+  strip: (s, chars) => trimChars(s, chars, "both"),
+  lstrip: (s, chars) => trimChars(s, chars, "left"),
+  rstrip: (s, chars) => trimChars(s, chars, "right"),
+  title: (s) => s.replace(
+    /\p{L}[\p{L}\p{M}]*/gu,
+    (w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()
+  ),
+  capitalize: (s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase(),
+  startswith: (s, p) => s.startsWith(String(p)),
+  endswith: (s, p) => s.endsWith(String(p)),
+  replace: (s, a, b, count) => {
+    const n = count === void 0 ? Infinity : Number(count);
+    let out = s;
+    let done = 0;
+    while (done < n && out.includes(String(a))) {
+      out = out.replace(String(a), String(b));
+      done++;
+      if (String(a) === "") break;
+    }
+    return out;
+  },
+  split: (s, sep, max) => sep === void 0 || sep === null ? s.trim().split(/\s+/) : s.split(String(sep), max === void 0 ? void 0 : Number(max) + 1),
+  join: (s, list2) => Array.isArray(list2) ? list2.join(s) : String(list2),
+  format: (s, ...args) => {
+    let i = 0;
+    const named = args.at(-1) && typeof args.at(-1) === "object" ? args.at(-1) : {};
+    return s.replace(
+      /\{(\w*)\}/g,
+      (_, key) => String(key ? named[key] ?? "" : args[i++] ?? "")
+    );
+  },
+  zfill: (s, width) => s.padStart(Number(width), "0"),
+  count: (s, sub) => s.split(String(sub)).length - 1,
+  find: (s, sub) => s.indexOf(String(sub)),
+  isdigit: (s) => /^\d+$/.test(s),
+  isalpha: (s) => /^\p{L}+$/u.test(s),
+  splitlines: (s) => s.split(/\r?\n/),
+  center: (s, width, fill) => {
+    const total = Math.max(0, Number(width) - s.length);
+    const left = Math.floor(total / 2);
+    const f = String(fill ?? " ");
+    return f.repeat(left) + s + f.repeat(total - left);
+  }
+};
+function trimChars(s, chars, side) {
+  if (chars === void 0 || chars === null)
+    return side === "both" ? s.trim() : side === "left" ? s.trimStart() : s.trimEnd();
+  const set = new Set(String(chars));
+  let start = 0;
+  let end = s.length;
+  if (side !== "right") while (start < end && set.has(s[start] ?? "")) start++;
+  if (side !== "left") while (end > start && set.has(s[end - 1] ?? "")) end--;
+  return s.slice(start, end);
+}
+var compatInstalled = false;
+function installCompat() {
+  if (compatInstalled) return;
+  compatInstalled = true;
+  nunjucks.installJinjaCompat();
+  nunjucks.compiler.Compiler.prototype.compileNot = function(node, frame) {
+    this._emit("!(");
+    this.compile(node.target, frame);
+    this._emit(")");
+  };
+  const original = nunjucks.runtime.memberLookup;
+  nunjucks.runtime.memberLookup = (obj, val2, ...rest) => {
+    if (typeof obj === "string" && typeof val2 === "string" && Object.prototype.hasOwnProperty.call(stringMethods, val2)) {
+      const method = stringMethods[val2];
+      if (method) return (...args) => method(obj, ...args);
+    }
+    if (obj && typeof obj === "object" && !Array.isArray(obj) && typeof val2 === "string" && Object.prototype.hasOwnProperty.call(obj, val2)) {
+      const own = obj[val2];
+      return typeof own === "function" ? (...args) => own.apply(obj, args) : own;
+    }
+    if (obj && typeof obj === "object" && !Array.isArray(obj) && val2 === "get" && !("get" in obj)) {
+      return (key, fallback) => String(key) in obj ? obj[String(key)] : fallback;
+    }
+    return original(obj, val2, ...rest);
+  };
+}
+var PartialLoader = class extends nunjucks.Loader {
+  constructor(lookup) {
+    super();
+    this.lookup = lookup;
+  }
+  async = false;
+  getSource(name) {
+    const src = this.lookup(name);
+    return src === void 0 ? null : { src, path: name, noCache: true };
+  }
+};
+function createEnvironment(ctx) {
+  installCompat();
+  const env = new nunjucks.Environment(
+    new PartialLoader(ctx.partials),
+    {
+      autoescape: true,
+      throwOnUndefined: false,
+      trimBlocks: false,
+      lstripBlocks: false
+    }
+  );
+  for (const [name, { fn, html }] of ctx.helpers.bind(ctx)) {
+    const wrapped = (...args) => {
+      const result = fn(...args);
+      return html ? new nunjucks.runtime.SafeString(String(result ?? "")) : result;
+    };
+    env.addFilter(name, wrapped);
+    env.addGlobal(name, wrapped);
+  }
+  return env;
+}
+var validationContext2 = {
+  locale: "en",
+  timezone: "UTC",
+  currency: "EUR",
+  partials: () => void 0,
+  helpers: defaultHelpers(),
+  limits: { ms: 2e3, outputBytes: 20 * 1024 * 1024, includeDepth: 8 },
+  i18n: {}
+};
+function toSyntaxError2(e, fallbackLine = 1) {
+  const err = e;
+  const message = String(err.message ?? e).replace(/^\(.*?\)\s*/, "").replace(/^\[Line \d+, Column \d+\]\s*/, "").trim();
+  const fromMessage = /\[Line (\d+), Column (\d+)\]/.exec(
+    String(err.message ?? "")
+  );
+  const line = typeof err.lineno === "number" ? err.lineno + 1 : fromMessage ? Number(fromMessage[1]) : fallbackLine;
+  const column = typeof err.colno === "number" ? err.colno + 1 : fromMessage ? Number(fromMessage[2]) : 1;
+  return new EngineSyntaxError("jinja2", message, line, column);
+}
+function nodeRange(node, length = 1) {
+  return rangeAt(node.lineno + 1, node.colno + 1, length);
+}
+function pathOf(node) {
+  if (node.typename === "Symbol")
+    return { path: [String(node.value)], root: node };
+  if (node.typename === "LookupVal") {
+    const target = pathOf(node["target"]);
+    const val2 = node["val"];
+    if (!target) return void 0;
+    if (val2.typename === "Literal")
+      return { path: [...target.path, String(val2.value)], root: target.root };
+    return target;
+  }
+  return void 0;
+}
+function inScope(w, name) {
+  return w.scopes.some((s) => s.has(name));
+}
+function walk2(node, w) {
+  if (!node || typeof node !== "object") return;
+  switch (node.typename) {
+    case "Symbol":
+    case "LookupVal": {
+      const p = pathOf(node);
+      if (p) {
+        const root = p.path[0] ?? "";
+        w.variables.push({
+          path: p.path,
+          range: nodeRange(p.root, p.path.join(".").length),
+          kind: inScope(w, root) ? "loop-var" : "read"
+        });
+      }
+      if (node.typename === "LookupVal" && !p) {
+        walk2(node["target"], w);
+        walk2(node["val"], w);
+      } else if (node.typename === "LookupVal") {
+        const val2 = node["val"];
+        if (val2.typename !== "Literal") walk2(val2, w);
+      }
+      return;
+    }
+    case "Filter": {
+      const nameNode = node["name"];
+      const name = String(nameNode.value);
+      w.filters.push({
+        name,
+        range: nodeRange(nameNode, name.length),
+        known: w.helpers.has(name) || nunjucksBuiltinFilters.has(name)
+      });
+      const args = node["args"];
+      for (const child of args.children ?? []) walk2(child, w);
+      return;
+    }
+    case "FunCall": {
+      const nameNode = node["name"];
+      if (nameNode.typename === "Symbol" && (w.helpers.has(String(nameNode.value)) || builtinRoots2.has(String(nameNode.value)))) {
+        const name = String(nameNode.value);
+        w.filters.push({
+          name,
+          range: nodeRange(nameNode, name.length),
+          known: true
+        });
+      } else {
+        walk2(nameNode, w);
+      }
+      const args = node["args"];
+      for (const child of args.children ?? []) walk2(child, w);
+      return;
+    }
+    case "For": {
+      const arr = node["arr"];
+      walk2(arr, w);
+      const source = pathOf(arr);
+      const nameNode = node["name"];
+      const names = nameNode.typename === "Array" ? nameNode.children ?? [] : [nameNode];
+      const scope = /* @__PURE__ */ new Set();
+      for (const n of names) {
+        const name = String(n.value);
+        scope.add(name);
+        w.loopSources.set(
+          name,
+          names.length === 1 && source && !inScope(w, source.path[0] ?? "") ? source.path : names.length === 1 && source ? resolveLoopSource(w, source.path) : null
+        );
+        w.variables.push({
+          path: [name],
+          range: nodeRange(n, name.length),
+          kind: "loop-var"
+        });
+      }
+      w.scopes.push(scope);
+      walk2(node["body"], w);
+      w.scopes.pop();
+      walk2(node["else_"], w);
+      return;
+    }
+    case "Set": {
+      for (const target of node["targets"] ?? []) {
+        const p = pathOf(target);
+        if (p) {
+          w.variables.push({
+            path: p.path,
+            range: nodeRange(p.root, p.path.join(".").length),
+            kind: "assigned"
+          });
+          w.scopes[0]?.add(p.path[0] ?? "");
+          w.loopSources.set(p.path[0] ?? "", null);
+        }
+      }
+      walk2(node["value"], w);
+      walk2(node["body"], w);
+      return;
+    }
+    case "Macro": {
+      const args = node["args"];
+      const scope = /* @__PURE__ */ new Set();
+      for (const child of args.children ?? [])
+        if (child.typename === "Symbol") scope.add(String(child.value));
+      const nameNode = node["name"];
+      w.scopes[0]?.add(String(nameNode.value));
+      w.loopSources.set(String(nameNode.value), null);
+      w.scopes.push(scope);
+      walk2(node["body"], w);
+      w.scopes.pop();
+      return;
+    }
+    case "Include":
+    case "Extends":
+    case "Import":
+    case "FromImport": {
+      const tpl = node["template"];
+      if (tpl.typename === "Literal")
+        w.includes.push({
+          name: String(tpl.value),
+          range: nodeRange(tpl, String(tpl.value).length + 2)
+        });
+      else walk2(tpl, w);
+      if (node.typename === "Import")
+        w.scopes[0]?.add(
+          String(node["target"]?.value ?? "")
+        );
+      if (node.typename === "FromImport")
+        for (const n of node["names"].children ?? [])
+          w.scopes[0]?.add(
+            String(
+              n.typename === "Pair" ? n["value"].value : n.value
+            )
+          );
+      return;
+    }
+    default:
+      break;
+  }
+  if (node.children) {
+    for (const child of node.children) walk2(child, w);
+    return;
+  }
+  for (const field of node.fields ?? []) {
+    const value = node[field];
+    if (Array.isArray(value)) for (const v of value) walk2(v, w);
+    else if (value && typeof value === "object" && "typename" in value)
+      walk2(value, w);
+  }
+}
+function resolveLoopSource(w, path) {
+  const root = path[0] ?? "";
+  if (!w.loopSources.has(root)) return path;
+  const source = w.loopSources.get(root);
+  return source ? [...source, ...path.slice(1)] : null;
+}
+function analyzeJinja2(source, opts = {}) {
+  const helpers = opts.helpers ?? defaultHelpers();
+  const { blocks, diagnostics } = scanBlocks(source, jinjaTags);
+  const w = {
+    variables: [],
+    filters: [],
+    includes: [],
+    loopSources: /* @__PURE__ */ new Map(),
+    scopes: [/* @__PURE__ */ new Set()],
+    helpers
+  };
+  try {
+    installCompat();
+    const root = nunjucks.parser.parse(source, [], {});
+    walk2(root, w);
+  } catch (e) {
+    const err = toSyntaxError2(e);
+    if (!diagnostics.some((d) => d.severity === "error")) {
+      diagnostics.push({
+        severity: "error",
+        code: "syntax-error",
+        message: err.message,
+        range: rangeAt(err.line, err.column, 1)
+      });
+    }
+  }
+  const registry = helpers;
+  for (const f of w.filters) {
+    const preferred = registry.deprecationOf?.(f.name);
+    if (preferred) {
+      diagnostics.push({
+        severity: "warning",
+        code: "deprecated-filter",
+        message: `"${f.name}" is an apitemplate.io compatibility alias; use "${preferred}"`,
+        range: f.range,
+        fix: { title: `Rename to ${preferred}`, replacement: preferred }
+      });
+    } else if (!f.known) {
+      diagnostics.push({
+        severity: "error",
+        code: "unknown-filter",
+        message: `Unknown filter or helper "${f.name}"`,
+        range: f.range
+      });
+    }
+  }
+  const builtin = /* @__PURE__ */ new Set([...builtinRoots2, ...helpers.names()]);
+  const dataDiagnostics = missingPathDiagnostics(
+    w.variables,
+    opts.sampleData,
+    w.loopSources,
+    builtin
+  );
+  return {
+    variables: w.variables,
+    filters: w.filters,
+    includes: w.includes,
+    blocks,
+    diagnostics: [...diagnostics, ...dataDiagnostics]
+  };
+}
+var Jinja2Template = class {
+  constructor(name, source) {
+    this.name = name;
+    this.source = source;
+  }
+  engine = "jinja2";
+  runtimes = /* @__PURE__ */ new WeakMap();
+  runtime(ctx) {
+    let tpl = this.runtimes.get(ctx);
+    if (!tpl) {
+      const env = createEnvironment(ctx);
+      tpl = new nunjucks.Template(this.source, env, this.name, true);
+      this.runtimes.set(ctx, tpl);
+    }
+    return tpl;
+  }
+  render(data, ctx) {
+    const started = Date.now();
+    const tpl = this.runtime(ctx);
+    return new Promise((resolve2, reject) => {
+      try {
+        tpl.render(
+          data ?? {},
+          (err, res) => {
+            if (err) {
+              const e = err;
+              reject(
+                new RenderError(
+                  "jinja2",
+                  String(e.message ?? err).replace(/^\(.*?\)\s*/, ""),
+                  e.lineno === void 0 ? void 0 : e.lineno + 1,
+                  e.colno === void 0 ? void 0 : e.colno + 1
+                )
+              );
+              return;
+            }
+            try {
+              resolve2(enforceLimits(res ?? "", started, ctx.limits));
+            } catch (limit) {
+              reject(limit);
+            }
+          }
+        );
+      } catch (e) {
+        reject(e instanceof Error ? e : new RenderError("jinja2", String(e)));
+      }
+    });
+  }
+};
+var jinja2Engine = {
+  id: "jinja2",
+  compile(source, opts = {}) {
+    const name = opts.name ?? "template";
+    try {
+      installCompat();
+      new nunjucks.Template(
+        source,
+        createEnvironment(validationContext2),
+        name,
+        true
+      );
+    } catch (e) {
+      throw toSyntaxError2(e);
+    }
+    return new Jinja2Template(name, source);
+  },
+  analyze: analyzeJinja2,
+  render: (tpl, data, ctx) => tpl.render(data, ctx)
+};
+
+// packages/engine/src/lib/engines/liquid.ts
+import { Liquid } from "liquidjs";
+var liquidBuiltinFilters = /* @__PURE__ */ new Set([
+  "abs",
+  "append",
+  "at_least",
+  "at_most",
+  "capitalize",
+  "ceil",
+  "compact",
+  "concat",
+  "date",
+  "default",
+  "divided_by",
+  "downcase",
+  "escape",
+  "escape_once",
+  "first",
+  "floor",
+  "join",
+  "json",
+  "last",
+  "lstrip",
+  "map",
+  "minus",
+  "modulo",
+  "newline_to_br",
+  "plus",
+  "prepend",
+  "remove",
+  "remove_first",
+  "replace",
+  "replace_first",
+  "reverse",
+  "round",
+  "rstrip",
+  "size",
+  "slice",
+  "sort",
+  "sort_natural",
+  "split",
+  "strip",
+  "strip_html",
+  "strip_newlines",
+  "times",
+  "truncate",
+  "truncatewords",
+  "uniq",
+  "upcase",
+  "url_decode",
+  "url_encode",
+  "where",
+  "raw",
+  "sum",
+  "group_by",
+  "find",
+  "reject",
+  "has",
+  "find_index",
+  "to_integer",
+  "array_to_sentence_string",
+  "normalize_whitespace",
+  "number_of_words",
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "inspect",
+  "type",
+  "sample",
+  "time_zone"
+]);
+var builtinRoots3 = /* @__PURE__ */ new Set([
+  "forloop",
+  "tablerowloop",
+  "true",
+  "false",
+  "nil",
+  "null",
+  "empty",
+  "blank",
+  "continue",
+  "break"
+]);
+var keywords = /* @__PURE__ */ new Set([
+  "and",
+  "or",
+  "not",
+  "in",
+  "contains",
+  "with",
+  "for",
+  "as",
+  "reversed",
+  "limit",
+  "offset",
+  "by",
+  "cols",
+  "else"
+]);
+function partialFs(resolve2) {
+  const read = (file) => {
+    const src = resolve2(file);
+    if (src === void 0) throw new Error(`Partial "${file}" not found`);
+    return src;
+  };
+  return {
+    readFileSync: read,
+    readFile: (file) => Promise.resolve(read(file)),
+    existsSync: (file) => resolve2(file) !== void 0,
+    exists: (file) => Promise.resolve(resolve2(file) !== void 0),
+    resolve: (_root, file, ext) => ext && !file.endsWith(ext) ? `${file}${ext}` : file,
+    contains: () => Promise.resolve(true),
+    sep: "/",
+    dirname: () => ""
+  };
+}
+function collectKeywordArgs(args, isKeyword) {
+  const positional = [];
+  const named = {};
+  let sawNamed = false;
+  args.forEach((arg, index) => {
+    if (isKeyword(index) && Array.isArray(arg) && typeof arg[0] === "string") {
+      named[arg[0]] = arg[1];
+      sawNamed = true;
+    } else positional.push(arg);
+  });
+  return sawNamed ? [...positional, named] : positional;
+}
+function createLiquid(ctx) {
+  const liquid = new Liquid({
+    strictFilters: true,
+    strictVariables: false,
+    ownPropertyOnly: true,
+    relativeReference: false,
+    extname: "",
+    root: [""],
+    fs: partialFs(ctx.partials),
+    renderLimit: ctx.limits.ms,
+    memoryLimit: ctx.limits.outputBytes * 4,
+    parseLimit: 2e6
+  });
+  for (const [name, { fn }] of ctx.helpers.bind(ctx))
+    liquid.registerFilter(name, function(input, ...argv) {
+      const tokens = this.token?.args ?? [];
+      return fn(
+        ...collectKeywordArgs([input, ...argv], (i) => i > 0 && Array.isArray(tokens[i - 1]))
+      );
+    });
+  return liquid;
+}
+var validationContext3 = {
+  locale: "en",
+  timezone: "UTC",
+  currency: "EUR",
+  partials: () => void 0,
+  helpers: defaultHelpers(),
+  limits: { ms: 2e3, outputBytes: 20 * 1024 * 1024, includeDepth: 8 }
+};
+function toSyntaxError3(e) {
+  const err = e;
+  let line = err.line ?? 1;
+  let column = err.col ?? 1;
+  const pos = err.token?.getPosition?.();
+  if (pos) [line, column] = pos;
+  const message = String(err.message ?? e).replace(/,\s*line:\d+,\s*col:\d+/, "").trim();
+  return new EngineSyntaxError("liquid", message, line, column);
+}
+var identifier = /(?<![\w."'])([A-Za-z_][\w]*)((?:\.[A-Za-z_]\w*|\[\d+\])*)/g;
+function pathsIn(expression, base, source, out, scopes) {
+  const stripped = expression.replace(
+    /(["'])(?:\\.|(?!\1).)*\1/g,
+    (m) => " ".repeat(m.length)
+  );
+  for (const m of stripped.matchAll(identifier)) {
+    const root = m[1] ?? "";
+    if (keywords.has(root) || builtinRoots3.has(root) || /^\d/.test(root))
+      continue;
+    const path = [root, ...(m[2] ?? "").split(/[.[\]]+/).filter(Boolean)];
+    const start = base + (m.index ?? 0);
+    out.push({
+      path,
+      range: rangeOf(source, start, start + m[0].length),
+      kind: scopes.has(root) ? "loop-var" : "read"
+    });
+  }
+}
+function analyzeLiquid(source, opts = {}) {
+  const helpers = opts.helpers ?? defaultHelpers();
+  const { blocks, diagnostics } = scanBlocks(source, liquidTags);
+  const variables = [];
+  const filters = [];
+  const includes = [];
+  const loopSources = /* @__PURE__ */ new Map();
+  try {
+    new Liquid({ strictFilters: false, fs: partialFs(() => "") }).parse(source);
+  } catch (e) {
+    const err = toSyntaxError3(e);
+    if (!diagnostics.some((d) => d.severity === "error")) {
+      diagnostics.push({
+        severity: "error",
+        code: "syntax-error",
+        message: err.message,
+        range: {
+          start: { line: err.line, column: err.column },
+          end: { line: err.line, column: err.column + 1 }
+        }
+      });
+    }
+  }
+  const filterNames = (expr, base) => {
+    for (const m of expr.matchAll(/\|\s*([A-Za-z_]\w*)/g)) {
+      const name = m[1] ?? "";
+      const start = base + (m.index ?? 0) + m[0].indexOf(name);
+      filters.push({
+        name,
+        range: rangeOf(source, start, start + name.length),
+        known: helpers.has(name) || liquidBuiltinFilters.has(name)
+      });
+    }
+  };
+  const withoutFilters = (expr) => expr.split("|")[0] ?? expr;
+  for (const m of source.matchAll(/\{\{-?([\s\S]*?)-?\}\}/g)) {
+    const inner = m[1] ?? "";
+    const base = (m.index ?? 0) + m[0].indexOf(inner);
+    pathsIn(withoutFilters(inner), base, source, variables, loopSources);
+    filterNames(inner, base);
+  }
+  for (const m of source.matchAll(/\{%-?\s*(\w+)([\s\S]*?)-?%\}/g)) {
+    const keyword = m[1] ?? "";
+    const rest = m[2] ?? "";
+    const base = (m.index ?? 0) + m[0].indexOf(rest, 2 + keyword.length);
+    if (keyword === "for" || keyword === "tablerow") {
+      const fm = /^\s*([A-Za-z_]\w*)\s+in\s+([\w.[\]]+)/.exec(rest);
+      if (fm) {
+        const name = fm[1] ?? "";
+        const src = (fm[2] ?? "").split(/[.[\]]+/).filter(Boolean);
+        const root = src[0] ?? "";
+        loopSources.set(
+          name,
+          loopSources.has(root) ? loopSources.get(root) ? [...loopSources.get(root), ...src.slice(1)] : null : src
+        );
+        const start = base + rest.indexOf(name);
+        variables.push({
+          path: [name],
+          range: rangeOf(source, start, start + name.length),
+          kind: "loop-var"
+        });
+        pathsIn(
+          rest.slice(fm[0].length - (fm[2] ?? "").length),
+          base + fm[0].length - (fm[2] ?? "").length,
+          source,
+          variables,
+          loopSources
+        );
+      }
+    } else if (keyword === "assign" || keyword === "capture" || keyword === "increment" || keyword === "decrement") {
+      const am = /^\s*([A-Za-z_]\w*)/.exec(rest);
+      if (am) {
+        const name = am[1] ?? "";
+        const start = base + rest.indexOf(name);
+        variables.push({
+          path: [name],
+          range: rangeOf(source, start, start + name.length),
+          kind: "assigned"
+        });
+        loopSources.set(name, null);
+        if (keyword === "assign") {
+          const value = rest.slice(am[0].length).replace(/^\s*=/, "");
+          pathsIn(
+            withoutFilters(value),
+            base + rest.length - value.length,
+            source,
+            variables,
+            loopSources
+          );
+          filterNames(value, base + rest.length - value.length);
+        }
+      }
+    } else if (keyword === "render" || keyword === "include") {
+      const im = /^\s*(["'])([^"']+)\1/.exec(rest);
+      if (im) {
+        const start = base + rest.indexOf(im[0]);
+        includes.push({
+          name: im[2] ?? "",
+          range: rangeOf(source, start, start + im[0].length)
+        });
+      }
+    } else if (["if", "elsif", "unless", "case", "when", "echo", "cycle"].includes(
+      keyword
+    )) {
+      pathsIn(withoutFilters(rest), base, source, variables, loopSources);
+      if (keyword === "echo") filterNames(rest, base);
+    }
+  }
+  const registry = helpers;
+  for (const f of filters) {
+    const preferred = registry.deprecationOf?.(f.name);
+    if (preferred) {
+      diagnostics.push({
+        severity: "warning",
+        code: "deprecated-filter",
+        message: `"${f.name}" is a compatibility alias; use "${preferred}"`,
+        range: f.range,
+        fix: { title: `Rename to ${preferred}`, replacement: preferred }
+      });
+    } else if (!f.known) {
+      diagnostics.push({
+        severity: "error",
+        code: "unknown-filter",
+        message: `Unknown filter "${f.name}"`,
+        range: f.range
+      });
+    }
+  }
+  const byPosition = (a, b) => a.range.start.line - b.range.start.line || a.range.start.column - b.range.start.column;
+  variables.sort(byPosition);
+  filters.sort(byPosition);
+  const dataDiagnostics = missingPathDiagnostics(
+    variables,
+    opts.sampleData,
+    loopSources,
+    /* @__PURE__ */ new Set([...builtinRoots3, ...helpers.names()])
+  );
+  return {
+    variables,
+    filters,
+    includes,
+    blocks,
+    diagnostics: [...diagnostics, ...dataDiagnostics]
+  };
+}
+var LiquidCompiled = class {
+  constructor(name, source) {
+    this.name = name;
+    this.source = source;
+  }
+  engine = "liquid";
+  runtimes = /* @__PURE__ */ new WeakMap();
+  runtime(ctx) {
+    let rt = this.runtimes.get(ctx);
+    if (!rt) {
+      const liquid = createLiquid(ctx);
+      rt = { liquid, templates: liquid.parse(this.source, this.name) };
+      this.runtimes.set(ctx, rt);
+    }
+    return rt;
+  }
+  async render(data, ctx) {
+    const started = Date.now();
+    const { liquid, templates } = this.runtime(ctx);
+    try {
+      const out = await liquid.render(
+        templates,
+        data ?? {}
+      );
+      return enforceLimits(out, started, ctx.limits);
+    } catch (e) {
+      if (e instanceof Error && e.name === "RenderLimitError") throw e;
+      const err = e;
+      const pos = err.token?.getPosition?.();
+      throw new RenderError(
+        "liquid",
+        String(err.message ?? e),
+        pos?.[0],
+        pos?.[1]
+      );
+    }
+  }
+};
+var liquidEngine = {
+  id: "liquid",
+  compile(source, opts = {}) {
+    const name = opts.name ?? "template";
+    try {
+      createLiquid(validationContext3).parse(source, name);
+    } catch (e) {
+      throw toSyntaxError3(e);
+    }
+    return new LiquidCompiled(name, source);
+  },
+  analyze: analyzeLiquid,
+  render: (tpl, data, ctx) => tpl.render(data, ctx)
+};
+
+// packages/engine/src/lib/engines/index.ts
+var engines = {
+  jinja2: jinja2Engine,
+  liquid: liquidEngine,
+  handlebars: handlebarsEngine
+};
+var engineIds = ["jinja2", "liquid", "handlebars"];
+function getEngine(id) {
+  const engine = engines[id];
+  if (!engine)
+    throw new Error(
+      `Unknown template engine "${id}"; expected one of ${engineIds.join(", ")}`
+    );
+  return engine;
+}
+
+// packages/engine/src/lib/schema.ts
+var isoDateTime = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/;
+var isoDate = /^\d{4}-\d{2}-\d{2}$/;
+var email = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var uri = /^https?:\/\/\S+$/;
+function typeOf(value) {
+  if (value === null || value === void 0) return "null";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "number")
+    return Number.isInteger(value) ? "integer" : "number";
+  return typeof value === "object" ? "object" : typeof value;
+}
+function formatOf(value) {
+  if (isoDateTime.test(value)) return "date-time";
+  if (isoDate.test(value)) return "date";
+  if (email.test(value)) return "email";
+  if (uri.test(value)) return "uri";
+  return void 0;
+}
+function unionTypes(a, b) {
+  const set = /* @__PURE__ */ new Set([
+    ...Array.isArray(a) ? a : a ? [a] : [],
+    ...Array.isArray(b) ? b : b ? [b] : []
+  ]);
+  if (set.has("number")) set.delete("integer");
+  const list2 = [...set];
+  return list2.length === 1 ? list2[0] : list2;
+}
+function merge(a, b) {
+  if (!a) return b;
+  const out = { type: unionTypes(a.type, b.type) };
+  if (a.format && a.format === b.format) out.format = a.format;
+  if (a.properties || b.properties) {
+    out.properties = { ...a.properties };
+    for (const [key, schema] of Object.entries(b.properties ?? {}))
+      out.properties[key] = merge(out.properties[key], schema);
+    const req = new Set(a.required ?? []);
+    out.required = (b.required ?? []).filter((k) => req.has(k));
+    if (out.required.length === 0) delete out.required;
+  }
+  if (a.items || b.items) out.items = merge(a.items, b.items ?? {});
+  const examples = [...a.examples ?? [], ...b.examples ?? []].filter(
+    (v, i, arr) => arr.findIndex((x) => JSON.stringify(x) === JSON.stringify(v)) === i
+  );
+  if (examples.length) out.examples = examples.slice(0, 3);
+  return out;
+}
+function infer(value) {
+  const type = typeOf(value);
+  switch (type) {
+    case "array": {
+      const items = value.map(infer);
+      const schema = { type: "array" };
+      if (items.length)
+        schema.items = items.reduce(
+          (acc, s) => merge(acc, s),
+          void 0
+        );
+      return schema;
+    }
+    case "object": {
+      const properties = {};
+      for (const [key, v] of Object.entries(value))
+        properties[key] = infer(v);
+      return {
+        type: "object",
+        properties,
+        required: Object.keys(properties),
+        additionalProperties: true
+      };
+    }
+    case "string": {
+      const schema = { type: "string", examples: [value] };
+      const format = formatOf(value);
+      if (format) schema.format = format;
+      return schema;
+    }
+    case "null":
+      return { type: "null" };
+    default:
+      return { type, examples: [value] };
+  }
+}
+function inferSchema(sample) {
+  return {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    ...infer(sample)
+  };
+}
+function schemaPaths(schema, prefix = []) {
+  const out = [];
+  const type = Array.isArray(schema.type) ? schema.type.join(" | ") : schema.type ?? "any";
+  if (prefix.length)
+    out.push({
+      path: prefix,
+      type,
+      format: schema.format,
+      example: schema.examples?.[0]
+    });
+  for (const [key, child] of Object.entries(schema.properties ?? {}))
+    out.push(...schemaPaths(child, [...prefix, key]));
+  if (schema.items) out.push(...schemaPaths(schema.items, [...prefix, "[]"]));
+  return out;
+}
+
+// packages/engine/src/lib/snippets.ts
+var loop = (engine, item, list2, body) => engine === "handlebars" ? `{{#each ${list2}}}
+${body.replace(/\{\{ item\./g, "{{ ")}
+{{/each}}` : `{% for ${item} in ${list2} %}
+${body}
+{% endfor %}`;
+var val = (engine, expr, filter) => {
+  if (!filter) return `{{ ${expr} }}`;
+  if (engine === "handlebars")
+    return `{{${filter.split("(")[0]} ${expr}${filter.includes("(") ? " " + filter.slice(filter.indexOf("(") + 1, -1) : ""}}}`;
+  return engine === "liquid" ? `{{ ${expr} | ${filter.replace("(", ": ").replace(")", "")} }}` : `{{ ${expr} | ${filter} }}`;
+};
+function forAll(build) {
+  return {
+    jinja2: build("jinja2"),
+    liquid: build("liquid"),
+    handlebars: build("handlebars")
+  };
+}
+var snippets = [
+  {
+    id: "invoice-table",
+    title: "Invoice table",
+    description: "Line items with description, quantity, unit price and line total.",
+    source: forAll(
+      (e) => `<table class="ff-lines">
+  <thead><tr><th>Description</th><th class="num">Qty</th><th class="num">Unit price</th><th class="num">Total</th></tr></thead>
+  <tbody>
+${loop(e, "line", "invoice.lines", `    <tr><td>${val(e, "line.description")}</td><td class="num">${val(e, "line.qty", "number(0)")}</td><td class="num">${val(e, "line.price", "money")}</td><td class="num">${val(e, "line.total", "money")}</td></tr>`)}
+  </tbody>
+</table>$0`
+    ),
+    sampleData: {
+      invoice: {
+        lines: [
+          { description: "Consulting", qty: 8, price: 120, total: 960 },
+          { description: "Implementation", qty: 20, price: 110, total: 2200 }
+        ]
+      }
+    },
+    css: `.ff-lines { width: 100%; border-collapse: collapse; font-size: 10pt; }
+.ff-lines th, .ff-lines td { padding: 6px 8px; border-bottom: 1px solid #ddd; text-align: left; }
+.ff-lines .num { text-align: right; white-space: nowrap; }
+.ff-lines thead th { border-bottom: 2px solid #222; }`
+  },
+  {
+    id: "totals",
+    title: "Totals block",
+    description: "Net, VAT and gross totals right-aligned under a table.",
+    source: forAll(
+      (e) => `<table class="ff-totals">
+  <tr><td>Net</td><td class="num">${val(e, "invoice.net", "money")}</td></tr>
+  <tr><td>VAT ${val(e, "invoice.vat_rate")} %</td><td class="num">${val(e, "invoice.vat", "money")}</td></tr>
+  <tr class="grand"><td>Total</td><td class="num">${val(e, "invoice.total", "money")}</td></tr>
+</table>$0`
+    ),
+    sampleData: {
+      invoice: { net: 3160, vat_rate: 19, vat: 600.4, total: 3760.4 }
+    },
+    css: `.ff-totals { margin-left: auto; margin-top: 12px; border-collapse: collapse; font-size: 10pt; }
+.ff-totals td { padding: 4px 8px; }
+.ff-totals .num { text-align: right; min-width: 90px; }
+.ff-totals .grand td { border-top: 2px solid #222; font-weight: 600; }`
+  },
+  {
+    id: "address-block",
+    title: "Address block",
+    description: "Recipient name and postal address lines.",
+    source: forAll(
+      (e) => `<address class="ff-address">
+  <strong>${val(e, "customer.name")}</strong><br>
+  ${val(e, "customer.street")}<br>
+  ${val(e, "customer.zip")} ${val(e, "customer.city")}<br>
+  ${val(e, "customer.country")}
+</address>$0`
+    ),
+    sampleData: {
+      customer: {
+        name: "Muster GmbH",
+        street: "Musterstra\xDFe 1",
+        zip: "10115",
+        city: "Berlin",
+        country: "Deutschland"
+      }
+    },
+    css: `.ff-address { font-style: normal; line-height: 1.4; }`
+  },
+  {
+    id: "page-footer",
+    title: "Footer with page numbers",
+    description: "Paste into the Footer tab: company line and \u201CPage x of y\u201D.",
+    source: forAll(
+      (e) => `<div style="width:100%;display:flex;justify-content:space-between;font-size:9px;color:#666">
+  <span>${val(e, "company.name")} \xB7 ${val(e, "company.email")}</span>
+  <span>Page <span class="pageNumber"></span> of <span class="totalPages"></span></span>
+</div>$0`
+    ),
+    sampleData: { company: { name: "Acme GmbH", email: "hello@acme.example" } }
+  },
+  {
+    id: "cover-page",
+    title: "Cover page",
+    description: "Title, subtitle and date on a page of its own.",
+    source: forAll(
+      (e) => `<section class="ff-cover">
+  <h1>${val(e, "report.title")}</h1>
+  <p class="subtitle">${val(e, "report.subtitle")}</p>
+  <p class="date">${val(e, "report.date", "date('PPP')")}</p>
+</section>
+<div class="page-break"></div>$0`
+    ),
+    sampleData: {
+      report: {
+        title: "Quarterly report",
+        subtitle: "Q3 2026",
+        date: "2026-09-30"
+      }
+    },
+    css: `.ff-cover { min-height: 60vh; display: flex; flex-direction: column; justify-content: center; }
+.ff-cover h1 { font-size: 32pt; margin: 0 0 8px; }
+.ff-cover .subtitle { font-size: 16pt; color: #444; margin: 0; }
+.ff-cover .date { margin-top: 24px; color: #666; }`
+  },
+  {
+    id: "signature",
+    title: "Signature line",
+    description: "Place, date and a signature line.",
+    source: forAll(
+      (e) => `<div class="ff-signature">
+  <div class="line"></div>
+  <div>${val(e, "signature.place")}, ${val(e, "signature.date", "date('PP')")} \xB7 ${val(e, "signature.name")}</div>
+</div>$0`
+    ),
+    sampleData: {
+      signature: {
+        place: "Berlin",
+        date: "2026-09-07",
+        name: "Philipp Staudt"
+      }
+    },
+    css: `.ff-signature { margin-top: 48px; width: 260px; font-size: 9pt; color: #444; }
+.ff-signature .line { border-top: 1px solid #222; margin-bottom: 6px; }`
+  },
+  {
+    id: "epc-qr",
+    title: "SEPA payment QR code",
+    description: "GiroCode that banking apps scan to prefill the transfer.",
+    source: {
+      jinja2: `<figure class="ff-qr">
+  <img src="{{ epcQr({ name: company.name, iban: company.iban, bic: company.bic, amount: invoice.total, reference: invoice.number }, { size: 120 }) }}" alt="Payment QR code">
+  <figcaption>Scan to pay</figcaption>
+</figure>$0`,
+      liquid: `<figure class="ff-qr">
+  <img src="{{ payment | epcQr }}" alt="Payment QR code">
+  <figcaption>Scan to pay</figcaption>
+</figure>$0`,
+      handlebars: `<figure class="ff-qr">
+  <img src="{{epcQr payment size=120}}" alt="Payment QR code">
+  <figcaption>Scan to pay</figcaption>
+</figure>$0`
+    },
+    sampleData: {
+      company: {
+        name: "Acme GmbH",
+        iban: "DE02120300000000202051",
+        bic: "BYLADEM1001"
+      },
+      invoice: { number: "2026-0042", total: 3760.4 },
+      payment: {
+        name: "Acme GmbH",
+        iban: "DE02120300000000202051",
+        bic: "BYLADEM1001",
+        amount: 3760.4,
+        reference: "2026-0042"
+      }
+    },
+    css: `.ff-qr { margin: 16px 0; text-align: center; width: 140px; }
+.ff-qr figcaption { font-size: 8pt; color: #666; }`
+  },
+  {
+    id: "chart",
+    title: "Chart",
+    description: "Bar chart drawn with Chart.js from a chart configuration in the data.",
+    source: {
+      jinja2: `<figure class="ff-chart-box">
+  {{ chart(salesChart) }}
+  <figcaption>{{ salesChart.caption }}</figcaption>
+</figure>$0`,
+      liquid: `<figure class="ff-chart-box">
+  {{ salesChart | chart }}
+  <figcaption>{{ salesChart.caption }}</figcaption>
+</figure>$0`,
+      handlebars: `<figure class="ff-chart-box">
+  {{chart salesChart}}
+  <figcaption>{{salesChart.caption}}</figcaption>
+</figure>$0`
+    },
+    sampleData: {
+      salesChart: {
+        type: "bar",
+        caption: "Revenue per quarter",
+        width: 480,
+        height: 240,
+        data: {
+          labels: ["Q1", "Q2", "Q3", "Q4"],
+          datasets: [
+            {
+              label: "Revenue",
+              data: [12e3, 15500, 14200, 18900],
+              backgroundColor: "#3E63DD"
+            }
+          ]
+        }
+      }
+    },
+    css: `.ff-chart-box { margin: 16px 0; break-inside: avoid; }
+.ff-chart-box figcaption { font-size: 9pt; color: #666; margin-top: 4px; }`
+  },
+  {
+    id: "two-columns",
+    title: "Two-column layout",
+    description: "Two equal columns that stay side by side in print.",
+    source: forAll(
+      () => `<div class="ff-columns">
+  <div>$1</div>
+  <div>$0</div>
+</div>`
+    ),
+    css: `.ff-columns { display: flex; gap: 24px; }
+.ff-columns > div { flex: 1 1 0; min-width: 0; }`
+  }
+];
+function snippetsFor(engine) {
+  return snippets.map((s) => ({ ...s, code: s.source[engine] }));
+}
+function mergeSampleData(base, extra) {
+  if (!extra) return base;
+  const target = base && typeof base === "object" && !Array.isArray(base) ? { ...base } : {};
+  for (const [key, value] of Object.entries(extra)) {
+    const existing = target[key];
+    if (existing === void 0) target[key] = value;
+    else if (existing && typeof existing === "object" && !Array.isArray(existing) && value && typeof value === "object" && !Array.isArray(value)) {
+      target[key] = mergeSampleData(existing, value);
+    }
+  }
+  return target;
+}
+
+// packages/api-types/src/lib/apitemplate.ts
+var paperFormats = {
+  a3: "A3",
+  a4: "A4",
+  a5: "A5",
+  letter: "Letter",
+  legal: "Legal",
+  tabloid: "Tabloid",
+  ledger: "Ledger"
+};
+function pick(input, ...keys) {
+  for (const key of keys) if (input[key] !== void 0 && input[key] !== null && input[key] !== "") return input[key];
+  return void 0;
+}
+function toLength(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value === "number") return `${value}mm`;
+  const text = String(value).trim();
+  if (/^-?\d+(\.\d+)?$/.test(text)) return `${text}mm`;
+  if (/^-?\d+(\.\d+)?(mm|cm|in|px|pt)$/i.test(text)) return text.toLowerCase();
+  return void 0;
+}
+var truthy2 = (value) => value === true || value === 1 || value === "1" || value === "true" || value === "yes";
+function convertHeaderFooter(html) {
+  if (typeof html !== "string" || !html.trim()) return void 0;
+  return html.replace(/\{\{\s*page_number\s*\}\}/gi, '<span class="pageNumber"></span>').replace(/\{\{\s*total_pages\s*\}\}/gi, '<span class="totalPages"></span>');
+}
+function mapApitemplateSettings(input) {
+  const settings = {};
+  const notes = [];
+  const used = /* @__PURE__ */ new Set();
+  const take = (...keys) => {
+    const value = pick(input ?? {}, ...keys);
+    for (const key of keys) if ((input ?? {})[key] !== void 0) used.add(key);
+    return value;
+  };
+  if (!input) return { settings, ignored: [], notes };
+  const paperSize = take("paper_size", "paperSize", "page_size", "format");
+  const orientation = take("orientation");
+  const width = toLength(take("custom_width", "customWidth", "width"));
+  const height = toLength(take("custom_height", "customHeight", "height"));
+  const paper = {};
+  if (typeof paperSize === "string") {
+    const format = paperFormats[paperSize.toLowerCase()];
+    if (format) paper["format"] = format;
+    else notes.push(`paper size "${paperSize}" is not a known format; A4 is used`);
+  }
+  if (width && height) {
+    paper["width"] = width;
+    paper["height"] = height;
+    notes.push("custom page size kept as explicit width and height");
+  }
+  if (orientation !== void 0) {
+    const landscape = orientation === "landscape" || orientation === 2 || orientation === "2" || orientation === "Landscape";
+    paper["landscape"] = landscape;
+  }
+  if (Object.keys(paper).length) settings["paper"] = paper;
+  const margin = {};
+  for (const side of ["top", "right", "bottom", "left"]) {
+    const value = toLength(take(`margin_${side}`, `margin${side[0].toUpperCase()}${side.slice(1)}`));
+    if (value) margin[side] = value;
+  }
+  if (Object.keys(margin).length) settings["margin"] = margin;
+  const header = convertHeaderFooter(take("header_template", "headerTemplate", "header_html", "header"));
+  const footer = convertHeaderFooter(take("footer_template", "footerTemplate", "footer_html", "footer"));
+  const displayHeaderFooter = take("displayHeaderFooter", "display_header_footer", "print_header_footer");
+  if (header && (displayHeaderFooter === void 0 || truthy2(displayHeaderFooter))) settings["header"] = { html: header };
+  if (footer && (displayHeaderFooter === void 0 || truthy2(displayHeaderFooter))) settings["footer"] = { html: footer };
+  const printBackground = take("print_background", "printBackground");
+  if (printBackground !== void 0) settings["printBackground"] = truthy2(printBackground);
+  const scale = take("scale");
+  if (scale !== void 0 && Number.isFinite(Number(scale))) settings["scale"] = Number(scale);
+  const pageRanges = take("page_ranges", "pageRanges");
+  if (typeof pageRanges === "string" && pageRanges.trim()) settings["pageRanges"] = pageRanges.trim();
+  const preferCss = take("prefer_css_page_size", "preferCSSPageSize", "preferCssPageSize");
+  if (preferCss !== void 0) settings["preferCssPageSize"] = truthy2(preferCss);
+  const imageType = take("output_image_type", "outputImageType", "image_type");
+  const viewportWidth = take("viewport_width", "viewportWidth", "image_width");
+  const viewportHeight = take("viewport_height", "viewportHeight", "image_height");
+  const deviceScale = take("device_scale", "deviceScaleFactor", "image_resample_scale");
+  const image = {};
+  if (imageType !== void 0) {
+    const t = String(imageType).toLowerCase();
+    image["format"] = t === "1" || t === "jpeg" || t === "jpg" ? "jpeg" : "png";
+  }
+  if (viewportWidth !== void 0 && Number.isFinite(Number(viewportWidth))) image["width"] = Number(viewportWidth);
+  if (viewportHeight !== void 0 && Number.isFinite(Number(viewportHeight))) image["height"] = Number(viewportHeight);
+  if (deviceScale !== void 0 && Number.isFinite(Number(deviceScale))) image["deviceScaleFactor"] = Number(deviceScale);
+  if (Object.keys(image).length) settings["image"] = image;
+  const ignored = Object.keys(input).filter((k) => !used.has(k));
+  return { settings, ignored, notes };
+}
+
+// packages/engine/src/lib/import/apitemplate.ts
+function slugFromName(name) {
+  const slug = name.toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+  return slug.length >= 2 ? slug : `imported-${Date.now().toString(36)}`;
+}
+function parseSample(value) {
+  if (value === void 0 || value === null || value === "") return { data: {} };
+  if (typeof value !== "string") return { data: value };
+  try {
+    return { data: JSON.parse(value) };
+  } catch (e) {
+    return { data: {}, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+var pythonisms = [
+  {
+    pattern: /\{\{[^}]*%\s*\(/,
+    code: "python-format-operator",
+    message: 'Python "%" string formatting is not supported; use the format() shim or a filter such as number() or money().',
+    docs: "/migrate/apitemplate-io#strings"
+  },
+  {
+    pattern: /loop\.cycle\s*\(/,
+    code: "loop-cycle",
+    message: "`loop.cycle()` is not available; use `cycler()` or `loop.index % n`.",
+    docs: "/migrate/apitemplate-io#loops"
+  },
+  {
+    pattern: /\{%-?\s*(macro|call|filter|autoescape)\b/,
+    code: "partial-support",
+    message: "Jinja2 macros, call blocks, filter blocks and autoescape blocks run with Nunjucks semantics; check the output.",
+    docs: "/templates/languages#jinja2"
+  },
+  {
+    pattern: /\bis\s+(divisibleby|sameas|escaped|mapping|sequence|callable)\b/,
+    code: "jinja-test",
+    message: "This Jinja2 test is not available; rewrite it with an expression (for example `x % 2 == 0`).",
+    docs: "/migrate/apitemplate-io#tests"
+  },
+  {
+    pattern: /\{%-?\s*(import|from)\b/,
+    code: "imports",
+    message: "Jinja2 imports refer to files apitemplate.io kept next to the template; move the macros into this template or a Formfeed partial.",
+    docs: "/templates/languages#partials"
+  }
+];
+function positionOf2(source, index) {
+  const before = source.slice(0, index);
+  const line = before.split("\n").length;
+  const column = index - before.lastIndexOf("\n");
+  return { line, column };
+}
+function setInLoop(source) {
+  const notes = [];
+  const forRe = /\{%-?\s*for\b[\s\S]*?\{%-?\s*endfor\s*-?%\}/g;
+  for (const m of source.matchAll(forRe)) {
+    const setAt = m[0].search(/\{%-?\s*set\s+\w+\s*=/);
+    if (setAt >= 0) {
+      const pos = positionOf2(source, m.index + setAt);
+      notes.push({
+        code: "set-in-loop",
+        message: "A {% set %} inside a loop: in Python Jinja2 the value is lost after the loop, in Nunjucks it is kept. Check code that relies on either behaviour.",
+        docs: "/migrate/apitemplate-io#loops",
+        ...pos
+      });
+    }
+  }
+  return notes;
+}
+function fromDiagnostic(d) {
+  const docs = d.code === "unknown-filter" ? "/templates/helpers" : d.code.startsWith("missing-") ? "/migrate/apitemplate-io#sample-data" : "/templates/languages#jinja2";
+  return { code: d.code, message: d.message, line: d.range.start.line, column: d.range.start.column, docs };
+}
+function importApitemplate(input) {
+  const errors = [];
+  const warnings = [];
+  const changes = [];
+  const name = (input.name ?? "").trim() || "Imported template";
+  const format = String(input.format ?? "").toUpperCase();
+  const kind = format === "JPEG" || format === "PNG" || format === "JPG" ? "image" : "pdf";
+  if (kind === "image") changes.push(`${format} template imported as an image template`);
+  const mapped = mapApitemplateSettings(input.settings ?? void 0);
+  const settings = mapped.settings;
+  for (const note of mapped.notes) changes.push(note);
+  for (const key of mapped.ignored)
+    warnings.push({ code: "setting-ignored", message: `Setting "${key}" has no Formfeed equivalent and was dropped.`, docs: "/migrate/apitemplate-io#settings" });
+  if (settings.header?.html || settings.footer?.html) changes.push("header and footer templates moved to the Header and Footer tabs");
+  if (kind === "image" && !settings.image) {
+    settings.image = { width: 1200, height: 630, deviceScaleFactor: 2, format: format === "PNG" ? "png" : "jpeg" };
+    changes.push("image size defaults to 1200 \xD7 630 (change it in Settings)");
+  }
+  const sample = parseSample(input.sample_data);
+  if (sample.error) warnings.push({ code: "sample-json", message: `Sample data is not valid JSON (${sample.error}); the draft starts without sample data.`, docs: "/migrate/apitemplate-io#sample-data" });
+  const html = input.html ?? "";
+  const css2 = input.css ?? "";
+  for (const rule of pythonisms) {
+    const m = rule.pattern.exec(html);
+    if (m) warnings.push({ code: rule.code, message: rule.message, docs: rule.docs, ...positionOf2(html, m.index) });
+  }
+  warnings.push(...setInLoop(html));
+  const engine = getEngine("jinja2");
+  try {
+    engine.compile(html, { name });
+  } catch (e) {
+    const err = e;
+    errors.push({ code: "syntax-error", message: err.message, line: err.line, column: err.column, docs: "/templates/languages#jinja2" });
+  }
+  const analysis = engine.analyze(html, { sampleData: sample.data });
+  for (const d of analysis.diagnostics) {
+    const note = fromDiagnostic(d);
+    if (d.severity === "error") {
+      if (!errors.some((x) => x.code === note.code && x.line === note.line)) errors.push(note);
+    } else warnings.push(note);
+  }
+  const aliasHits = analysis.filters.filter((f) => ["currency_format", "table", "page_break", "raw", "translate"].includes(f.name));
+  if (aliasHits.length) changes.push(`apitemplate.io filters kept through aliases: ${[...new Set(aliasHits.map((f) => f.name))].join(", ")}`);
+  return {
+    name,
+    slug: slugFromName(name),
+    kind,
+    engine: "jinja2",
+    html,
+    css: css2,
+    head: "",
+    settings,
+    sampleData: sample.data,
+    errors,
+    warnings,
+    changes
+  };
+}
+
+// packages/engine/src/lib/assemble.ts
+function defaultSettings() {
+  return {
+    paper: {
+      format: "A4",
+      width: null,
+      height: null,
+      unit: "mm",
+      landscape: false
+    },
+    margin: { top: "20mm", right: "15mm", bottom: "20mm", left: "15mm" },
+    header: null,
+    footer: null,
+    printBackground: true,
+    scale: 1,
+    preferCssPageSize: false,
+    pageRanges: "",
+    waitFor: { networkIdle: true, selector: null, timeoutMs: 5e3, delayMs: 0 },
+    pdf: { tagged: false, outline: false, metadata: { title: "", author: "" } },
+    image: {
+      width: 1200,
+      height: 630,
+      deviceScaleFactor: 2,
+      format: "png",
+      quality: 90,
+      fullPage: false,
+      transparent: false,
+      clipSelector: null
+    },
+    locale: "en-GB",
+    timezone: "Europe/Berlin",
+    currency: "EUR",
+    tailwind: false,
+    watermark: null
+  };
+}
+function isPlainObject(v) {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+function mergeSettings(...layers) {
+  const out = {};
+  const apply = (target, source) => {
+    for (const [key, value] of Object.entries(source)) {
+      if (value === void 0) continue;
+      if (isPlainObject(value) && isPlainObject(target[key]))
+        apply(target[key], value);
+      else if (isPlainObject(value)) target[key] = apply({}, value);
+      else target[key] = value;
+    }
+    return target;
+  };
+  for (const layer of [defaultSettings(), ...layers])
+    if (layer) apply(out, layer);
+  return out;
+}
+function pageSize(settings) {
+  const paper = settings.paper ?? {};
+  if (paper.width && paper.height) return `${paper.width} ${paper.height}`;
+  return `${paper.format ?? "A4"}${paper.landscape ? " landscape" : ""}`;
+}
+function printReset(settings, kind = "pdf") {
+  const m = settings.margin ?? {};
+  const page = kind === "pdf" ? `@page { size: ${pageSize(settings)}; margin: ${m.top ?? "0"} ${m.right ?? "0"} ${m.bottom ?? "0"} ${m.left ?? "0"}; }
+` : "";
+  return `${page}html, body { margin: 0; padding: 0; }
+body { -webkit-print-color-adjust: exact; print-color-adjust: exact; }
+img, svg { max-width: 100%; }
+.page-break, .new-page { break-after: page; }
+.avoid-break { break-inside: avoid; }
+table { break-inside: auto; border-collapse: collapse; }
+tr { break-inside: avoid; }
+thead { display: table-header-group; }
+tfoot { display: table-footer-group; }
+${kind === "image" ? `html, body { width: ${settings.image?.width ?? 1200}px; min-height: ${settings.image?.height ?? 630}px; overflow: hidden; }
+` : ""}`;
+}
+var fontFormats = {
+  woff2: "woff2",
+  woff: "woff",
+  ttf: "truetype",
+  otf: "opentype"
+};
+function fontFaceCss(fonts, referencedIn) {
+  if (!fonts?.length) return "";
+  const haystack = referencedIn.toLowerCase();
+  return fonts.filter((f) => haystack.includes(f.family.toLowerCase())).map((f) => {
+    const format = fontFormats[f.format ?? "woff2"] ?? f.format ?? "woff2";
+    return `@font-face { font-family: "${f.family.replace(/"/g, "")}"; font-weight: ${f.weight ?? 400}; font-style: ${f.style ?? "normal"}; font-display: block; src: url("${f.url.replace(/"/g, "%22")}") format("${format}"); }`;
+  }).join("\n");
+}
+function chartInitScript() {
+  return `<script>window.formfeedDrawCharts=function(){if(typeof Chart==='undefined')return;var all=Chart.instances||{};for(var k in all){if(all[k]&&all[k].canvas&&!all[k].canvas.isConnected){try{all[k].destroy();}catch(e){}}}var cs=document.querySelectorAll('canvas[data-ff-chart]');for(var i=0;i<cs.length;i++){var c=cs[i];try{if(Chart.getChart(c))continue;var s=JSON.parse(c.getAttribute('data-ff-chart')||'{}');new Chart(c.getContext('2d'),s);c.setAttribute('data-ff-chart-ready','1');}catch(e){console.error('formfeed chart',e);}}};if(!window.PagedConfig){window.formfeedDrawCharts();}</script>`;
+}
+function chartScripts(html, vendor) {
+  if (!vendor?.chartJs || !html.includes("data-ff-chart"))
+    return { head: "", body: "" };
+  const lib = "inline" in vendor.chartJs ? `<script>${vendor.chartJs.inline}</script>` : `<script src="${escapeHtml(vendor.chartJs.src)}"></script>`;
+  return { head: `${lib}
+`, body: `${chartInitScript()}
+` };
+}
+function assembleDocument(input) {
+  const settings = mergeSettings(input.settings);
+  const kind = input.kind ?? "pdf";
+  const locale = settings.locale ?? "en";
+  const base = input.assetBaseUrl ? `<base href="${escapeHtml(input.assetBaseUrl.replace(/\/?$/, "/"))}">
+` : "";
+  const title = input.title ? `<title>${escapeHtml(input.title)}</title>
+` : "";
+  const fonts = fontFaceCss(
+    input.fonts,
+    `${input.css ?? ""}
+${input.head ?? ""}
+${input.html}`
+  );
+  const fontStyle = fonts ? `<style data-formfeed="fonts">${fonts}</style>
+` : "";
+  const tailwind = settings.tailwind ? input.extraCss ? `<style data-formfeed="tailwind">${input.extraCss}</style>
+` : input.vendor?.tailwind ? `<script src="${escapeHtml(input.vendor.tailwind.src)}"></script>
+` : "" : input.extraCss ? `<style data-formfeed="extra">${input.extraCss}</style>
+` : "";
+  const charts = chartScripts(input.html, input.vendor);
+  return `<!doctype html>
+<html lang="${escapeHtml(locale.split("_")[0] ?? locale)}">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+${base}${title}${input.head ?? ""}
+${fontStyle}<style data-formfeed="reset">${printReset(settings, kind)}</style>
+${tailwind}<style data-formfeed="template">${input.css ?? ""}</style>
+${charts.head}</head>
+<body class="formfeed-body formfeed-${kind}${input.mode === "preview" ? " formfeed-preview" : ""}">
+${input.html}
+${charts.body}</body>
+</html>
+`;
+}
+async function renderVersion(version, data, ctx, mode = "print", extras = {}) {
+  const engine = getEngine(version.engine);
+  const settings = mergeSettings(version.settings);
+  const renderCtx = {
+    ...ctx,
+    locale: settings.locale ?? ctx.locale,
+    timezone: settings.timezone ?? ctx.timezone,
+    currency: settings.currency ?? ctx.currency
+  };
+  const renderPart = async (source, name) => source ? engine.render(engine.compile(source, { name }), data, renderCtx) : void 0;
+  const [html, headerHtml, footerHtml, title] = await Promise.all([
+    engine.render(
+      engine.compile(version.html, { name: "template" }),
+      data,
+      renderCtx
+    ),
+    renderPart(settings.header?.html, "header"),
+    renderPart(settings.footer?.html, "footer"),
+    renderPart(settings.pdf?.metadata?.title, "title")
+  ]);
+  const inlineCss = [
+    fontFaceCss(
+      extras.fonts,
+      `${version.css ?? ""}
+${version.head ?? ""}
+${html}
+${headerHtml ?? ""}
+${footerHtml ?? ""}`
+    ),
+    extras.extraCss ?? ""
+  ].filter(Boolean).join("\n");
+  return {
+    document: assembleDocument({
+      html,
+      css: version.css,
+      head: version.head,
+      settings,
+      kind: version.kind,
+      assetBaseUrl: ctx.assetBaseUrl,
+      mode,
+      title: title?.trim() || void 0,
+      ...extras
+    }),
+    headerHtml,
+    footerHtml,
+    title: title?.trim() || void 0,
+    settings,
+    inlineCss
+  };
+}
+
+// packages/engine/src/lib/preview.ts
+var paperSizes = {
+  A4: ["210mm", "297mm"],
+  A5: ["148mm", "210mm"],
+  A3: ["297mm", "420mm"],
+  Letter: ["8.5in", "11in"],
+  Legal: ["8.5in", "14in"]
+};
+function paperOf(settings) {
+  const paper = settings.paper ?? {};
+  const size = paper.width && paper.height ? [paper.width, paper.height] : paperSizes[paper.format ?? "A4"] ?? paperSizes["A4"];
+  const w = size?.[0] ?? "210mm";
+  const h = size?.[1] ?? "297mm";
+  return paper.landscape ? { width: h, height: w } : { width: w, height: h };
+}
+var pageNumberSpans = (html, page, total) => html.replace(/<span class="pageNumber"><\/span>/g, page).replace(/<span class="totalPages"><\/span>/g, total);
+var inspectScript = `<script>
+document.addEventListener('click', function (event) {
+  var el = event.target;
+  if (!el || el.nodeType !== 1) return;
+  try {
+    parent.postMessage({
+      type: 'formfeed:inspect',
+      tag: el.tagName.toLowerCase(),
+      id: el.id || null,
+      classes: (el.className && el.className.baseVal !== undefined ? el.className.baseVal : el.className || '').toString().trim().split(' ').filter(Boolean),
+      text: (el.textContent || '').trim().slice(0, 80),
+    }, '*');
+  } catch (e) {}
+}, true);
+</script>`;
+function flowDocument(draft) {
+  const { settings, kind, headerHtml, footerHtml } = draft;
+  const margin = settings.margin ?? {};
+  const paper = paperOf(settings);
+  const chrome = kind === "pdf" ? `<style data-formfeed="preview">
+html { background: #e5e7eb; }
+body.formfeed-preview { box-sizing: border-box; width: ${paper.width}; min-height: ${paper.height}; margin: 24px auto; background: #fff; box-shadow: 0 1px 3px rgba(0,0,0,.2), 0 8px 24px rgba(0,0,0,.08); padding: ${margin.top ?? "0"} ${margin.right ?? "0"} ${margin.bottom ?? "0"} ${margin.left ?? "0"}; }
+.formfeed-chrome { color: #6b7280; font: 10px/1.3 system-ui, sans-serif; }
+</style>` : `<style data-formfeed="preview">html { background: #e5e7eb; } body.formfeed-preview { margin: 24px auto; background: #fff; box-shadow: 0 1px 3px rgba(0,0,0,.2); }</style>`;
+  const header = headerHtml ? `<div class="formfeed-chrome" style="margin-bottom:8px">${headerHtml}</div>` : "";
+  const footer = footerHtml ? `<div class="formfeed-chrome" style="margin-top:8px">${pageNumberSpans(footerHtml, "1", "1")}</div>` : "";
+  return draft.document.replace("</head>", `${chrome}${inspectScript}</head>`).replace(/(<body[^>]*>)/, `$1${header}`).replace("</body>", `${footer}</body>`);
+}
+function pagedDocument(draft, options) {
+  const { headerHtml, footerHtml } = draft;
+  const runningCss = `
+@page { ${headerHtml ? "@top-center { content: element(ffHeader); }" : ""} ${footerHtml ? "@bottom-center { content: element(ffFooter); }" : ""} }
+.ff-running-header { position: running(ffHeader); }
+.ff-running-footer { position: running(ffFooter); }
+.ff-running-header, .ff-running-footer { color: #6b7280; font: 10px/1.3 system-ui, sans-serif; width: 100%; }
+.ff-page-no::after { content: counter(page); }
+.ff-page-total::after { content: counter(pages); }
+html { background: #e5e7eb; }
+.pagedjs_pages { margin: 0 auto; }
+.pagedjs_page { background: #fff; box-shadow: 0 1px 3px rgba(0,0,0,.2), 0 8px 24px rgba(0,0,0,.08); margin: 16px auto; }
+`;
+  const config = `<script>window.PagedConfig = { auto: true, after: function (flow) { try { if (window.formfeedDrawCharts) window.formfeedDrawCharts(); } catch (e) {} try { parent.postMessage({ type: 'formfeed:pages', pages: flow.total }, '*'); } catch (e) {} } };</script>`;
+  const script = `<script src="${options.pagedScriptUrl}"></script>`;
+  const header = headerHtml ? `<div class="ff-running-header">${pageNumberSpans(headerHtml, '<span class="ff-page-no"></span>', '<span class="ff-page-total"></span>')}</div>` : "";
+  const footer = footerHtml ? `<div class="ff-running-footer">${pageNumberSpans(footerHtml, '<span class="ff-page-no"></span>', '<span class="ff-page-total"></span>')}</div>` : "";
+  return draft.document.replace("</head>", `<style data-formfeed="paged">${runningCss}</style>${config}${script}${inspectScript}</head>`).replace(/(<body[^>]*>)/, `$1${header}${footer}`);
+}
+export {
+  DefaultHelperRegistry,
+  EngineSyntaxError,
+  RenderError,
+  RenderLimitError,
+  analyzeHandlebars,
+  analyzeJinja2,
+  analyzeLiquid,
+  assembleDocument,
+  builtinHelpers,
+  chartInitScript,
+  chartMarkup,
+  chartPayload,
+  createHelperRegistry,
+  defaultHelpers,
+  defaultLimits,
+  defaultSettings,
+  depthGuard,
+  enforceLimits,
+  engineIds,
+  engines,
+  epcPayload,
+  escapeHtml,
+  flowDocument,
+  fontFaceCss,
+  getEngine,
+  handlebarsEngine,
+  helperDocs,
+  imageMarkup,
+  importApitemplate,
+  inferSchema,
+  jinja2Engine,
+  jinjaTags,
+  liquidBuiltinFilters,
+  liquidEngine,
+  liquidTags,
+  mergeSampleData,
+  mergeSettings,
+  nunjucksBuiltinFilters,
+  pageNumberSpans,
+  pageSize,
+  pagedDocument,
+  paperOf,
+  printReset,
+  qrSvg,
+  renderVersion,
+  resolvePath,
+  scanBlocks,
+  schemaPaths,
+  slugFromName,
+  snippets,
+  snippetsFor,
+  toDate,
+  toNumber
+};