@formfeed/engine 0.1.0 → 0.2.0

package/index.js

@@ -449,7 +449,7 @@ var formatHelpers = [
     name: "asset",
     doc: {
       signature: "asset(name)",
-      description: "URL of a workspace asset (logo, background) on the CDN.",
+      description: "URL of a file in the workspace library (logo, background) on the CDN. Upload it on the Files page or with `POST /files` and use the name it has there; relative image paths resolve against the same library.",
       example: `<img src="{{ asset('logo.png') }}">`,
       category: "document"
     },
@@ -949,6 +949,12 @@ function helperDocs(registry = defaultHelpers()) {
 // packages/engine/src/lib/engines/handlebars.ts
 import Handlebars from "handlebars";
 
+// packages/engine/src/lib/unavailable.ts
+var UNAVAILABLE = {};
+function unavailableHelper(name) {
+  return UNAVAILABLE[name];
+}
+
 // packages/engine/src/lib/analysis/tags.ts
 function rangeAt(line, column, length) {
   return {
@@ -1128,7 +1134,10 @@ function missingPathDiagnostics(variables, sampleData, loopSources, builtinRoots
     const root = v.path[0];
     if (!root || builtinRoots4.has(root)) continue;
     let path = v.path;
-    if (loopSources.has(root)) {
+    if (v.source !== void 0) {
+      if (!v.source) continue;
+      path = [...v.source, ...v.path.slice(1)];
+    } else if (loopSources.has(root)) {
       const source = loopSources.get(root);
       if (!source) continue;
       path = [...source, ...v.path.slice(1)];
@@ -1387,6 +1396,13 @@ function analyzeHandlebars(source, opts = {}) {
         range: f.range,
         fix: { title: `Rename to ${preferred}`, replacement: preferred }
       });
+    } else if (unavailableHelper(f.name)) {
+      diagnostics.push({
+        severity: "warning",
+        code: "unavailable-helper",
+        message: unavailableHelper(f.name),
+        range: f.range
+      });
     } else if (!f.known) {
       diagnostics.push({
         severity: "error",
@@ -1495,6 +1511,151 @@ var handlebarsEngine = {
 
 // packages/engine/src/lib/engines/jinja2.ts
 import nunjucks from "nunjucks/browser/nunjucks.js";
+
+// packages/engine/src/lib/engines/python-format.ts
+var SPEC = /^(?:([\s\S])?([<>=^]))?([+\- ])?(#)?(0)?(\d+)?([,_])?(?:\.(\d+))?([bcdeEfFgGnosxX%])?$/;
+function group(digits, separator) {
+  return digits.replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+}
+function pythonExponent(text) {
+  return text.replace(/e([+-])(\d)$/i, (m, sign, digit) => `${m[0]}${sign}0${digit}`);
+}
+function formatNumber(value, type, precision, alternate) {
+  if (!Number.isFinite(value)) return Number.isNaN(value) ? "nan" : "inf";
+  const abs = Math.abs(value);
+  switch (type) {
+    case "f":
+    case "F":
+      return abs.toFixed(precision ?? 6);
+    case "%":
+      return `${(abs * 100).toFixed(precision ?? 6)}%`;
+    case "e":
+    case "E": {
+      const text = pythonExponent(abs.toExponential(precision ?? 6));
+      return type === "E" ? text.toUpperCase() : text;
+    }
+    case "g":
+    case "G": {
+      const p = precision === 0 ? 1 : precision ?? 6;
+      const exp = abs === 0 ? 0 : Math.floor(Math.log10(abs));
+      let text = exp < -4 || exp >= p ? pythonExponent(abs.toExponential(p - 1)) : abs.toFixed(Math.max(0, p - 1 - exp));
+      if (!alternate) {
+        const [mantissa = "", exponent] = text.split("e");
+        const trimmed = mantissa.includes(".") ? mantissa.replace(/0+$/, "").replace(/\.$/, "") : mantissa;
+        text = exponent === void 0 ? trimmed : `${trimmed}e${exponent}`;
+      }
+      return type === "G" ? text.toUpperCase() : text;
+    }
+    case "d":
+    case "n":
+      return String(Math.trunc(abs));
+    case "b":
+      return (alternate ? "0b" : "") + Math.trunc(abs).toString(2);
+    case "o":
+      return (alternate ? "0o" : "") + Math.trunc(abs).toString(8);
+    case "x":
+      return (alternate ? "0x" : "") + Math.trunc(abs).toString(16);
+    case "X":
+      return (alternate ? "0X" : "") + Math.trunc(abs).toString(16).toUpperCase();
+    default:
+      return precision === void 0 ? String(abs) : formatNumber(abs, "g", precision, alternate);
+  }
+}
+function formatValue(value, spec) {
+  const m = SPEC.exec(spec);
+  if (!m) return String(value ?? "");
+  const [, fillChar, alignChar, sign, alt, zero, widthText, grouping, precisionText, type = ""] = m;
+  const precision = precisionText === void 0 ? void 0 : Number(precisionText);
+  const width = widthText === void 0 ? 0 : Number(widthText);
+  const numericType = /[bdeEfFgGnoxX%]/.test(type);
+  const asNumber = typeof value === "number" ? value : typeof value === "boolean" ? Number(value) : numericType && value !== null && value !== void 0 && String(value).trim() !== "" && Number.isFinite(Number(value)) ? Number(value) : void 0;
+  let body;
+  let prefix = "";
+  if (asNumber !== void 0 && type !== "s" && type !== "c") {
+    body = formatNumber(asNumber, type, precision, Boolean(alt));
+    if (grouping) {
+      const [int = "", ...rest] = body.split(".");
+      const radix = /^0[box]/i.exec(int)?.[0] ?? "";
+      body = radix + group(int.slice(radix.length), grouping) + (rest.length ? `.${rest.join(".")}` : "");
+    }
+    const negative = asNumber < 0 || Object.is(asNumber, -0);
+    prefix = negative ? "-" : sign === "+" ? "+" : sign === " " ? " " : "";
+  } else if (type === "c" && asNumber !== void 0) {
+    body = String.fromCodePoint(asNumber);
+  } else {
+    body = String(value ?? "None");
+    if (precision !== void 0 && !numericType) body = body.slice(0, precision);
+  }
+  const isNumber = asNumber !== void 0 && type !== "s";
+  const align = alignChar ?? (zero && isNumber ? "=" : isNumber ? ">" : "<");
+  const fill = fillChar ?? (zero && !alignChar ? "0" : " ");
+  const pad = Math.max(0, width - prefix.length - body.length);
+  switch (align) {
+    case "<":
+      return prefix + body + fill.repeat(pad);
+    case "^":
+      return fill.repeat(Math.floor(pad / 2)) + prefix + body + fill.repeat(Math.ceil(pad / 2));
+    case "=":
+      return prefix + fill.repeat(pad) + body;
+    default:
+      return fill.repeat(pad) + prefix + body;
+  }
+}
+function lookupField(name, positional, named, next) {
+  const [head = "", ...rest] = name.split(/(?=[.[])/);
+  let value = head === "" ? positional[next()] : /^\d+$/.test(head) ? positional[Number(head)] : named[head];
+  for (const part of rest) {
+    const key = part.startsWith("[") ? part.slice(1, -1) : part.slice(1);
+    value = value !== null && typeof value === "object" ? value[Array.isArray(value) && /^\d+$/.test(key) ? Number(key) : key] : void 0;
+  }
+  return value;
+}
+function pythonFormat(template, positional, named = {}) {
+  let auto = 0;
+  const next = () => auto++;
+  const render = (text) => {
+    let out = "";
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+      if (ch === "}") {
+        out += "}";
+        if (text[i + 1] === "}") i++;
+        continue;
+      }
+      if (ch !== "{") {
+        out += ch;
+        continue;
+      }
+      if (text[i + 1] === "{") {
+        out += "{";
+        i++;
+        continue;
+      }
+      let depth = 1;
+      let j = i + 1;
+      for (; j < text.length && depth > 0; j++) {
+        if (text[j] === "{") depth++;
+        else if (text[j] === "}") depth--;
+      }
+      if (depth > 0) {
+        out += text.slice(i);
+        break;
+      }
+      const field = text.slice(i + 1, j - 1);
+      const colon = field.indexOf(":");
+      const head = colon < 0 ? field : field.slice(0, colon);
+      const name = head.replace(/![rsa]$/, "");
+      const value = lookupField(name, positional, named, next);
+      const spec = colon < 0 ? "" : render(field.slice(colon + 1));
+      out += value === void 0 ? "" : formatValue(value, spec);
+      i = j - 1;
+    }
+    return out;
+  };
+  return render(template);
+}
+
+// packages/engine/src/lib/engines/jinja2.ts
 var nunjucksBuiltinFilters = /* @__PURE__ */ new Set([
   "abs",
   "batch",
@@ -1549,7 +1710,12 @@ var builtinRoots2 = /* @__PURE__ */ new Set([
   "joiner",
   "lipsum",
   "varargs",
-  "kwargs"
+  "kwargs",
+  "namespace",
+  // Jinja2's spelling of the literals, which the compat layer resolves at runtime
+  "True",
+  "False",
+  "None"
 ]);
 var stringMethods = {
   upper: (s) => s.toUpperCase(),
@@ -1578,12 +1744,8 @@ var stringMethods = {
   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++] ?? "")
-    );
+    const named = keywordArgs(args);
+    return pythonFormat(s, named ? args.slice(0, -1) : args, named ?? {});
   },
   zfill: (s, width) => s.padStart(Number(width), "0"),
   count: (s, sub) => s.split(String(sub)).length - 1,
@@ -1598,6 +1760,92 @@ var stringMethods = {
     return f.repeat(left) + s + f.repeat(total - left);
   }
 };
+function keywordArgs(args) {
+  const last = args.at(-1);
+  if (!last || typeof last !== "object" || !Object.prototype.hasOwnProperty.call(last, "__keywords")) return void 0;
+  const { __keywords: _marker, ...named } = last;
+  return named;
+}
+var JinjaNamespace = class {
+};
+function namespace(...args) {
+  const ns = new JinjaNamespace();
+  const named = keywordArgs(args);
+  for (const arg of named ? [...args.slice(0, -1), named] : args)
+    if (arg && typeof arg === "object") Object.assign(ns, arg);
+  return ns;
+}
+function setNamespaceAttribute(target, key, value) {
+  if (!(target instanceof JinjaNamespace)) throw new Error("Cannot assign attribute on non-namespace object");
+  target[String(key)] = value;
+}
+var toList = (v) => Array.isArray(v) ? v : v === void 0 || v === null ? [] : typeof v === "string" ? [...v] : [v];
+var attributeOf = (item, path) => String(path ?? "").split(".").reduce((acc, key) => acc !== null && typeof acc === "object" ? acc[key] : void 0, item);
+var jinjaTests = {
+  none: (v) => v === null,
+  true: (v) => v === true,
+  false: (v) => v === false,
+  in: (v, container) => typeof container === "string" ? container.includes(String(v)) : Array.isArray(container) ? container.includes(v) : !!container && typeof container === "object" && String(v) in container,
+  "==": (v, a) => v === a,
+  "!=": (v, a) => v !== a,
+  ">": (v, a) => v > a,
+  ">=": (v, a) => v >= a,
+  "<": (v, a) => v < a,
+  "<=": (v, a) => v <= a
+};
+function runTest(self, name, value, arg) {
+  const own = jinjaTests[name];
+  if (own) return own(value, arg);
+  return self.env.getTest(name).call(self, value, arg) === true;
+}
+function installJinjaFilters(env) {
+  const lookup = env;
+  const helperTruncate = lookup.getFilter("truncate");
+  lookup.addFilter("truncate", function(value, ...args) {
+    const named = keywordArgs(args);
+    const p = named ? args.slice(0, -1) : args;
+    if (!named && typeof p[1] !== "boolean" && p.length < 3) return helperTruncate.call(this, value, ...args);
+    const s = String(value ?? "");
+    const length = Number(p[0] ?? named?.["length"] ?? 255);
+    const killwords = Boolean(p[1] ?? named?.["killwords"] ?? false);
+    const end = String(p[2] ?? named?.["end"] ?? "...");
+    const leeway = Number(p[3] ?? named?.["leeway"] ?? 5);
+    if (s.length <= length + leeway) return s;
+    const cut = s.slice(0, Math.max(0, length - end.length));
+    if (killwords) return cut + end;
+    const space = cut.lastIndexOf(" ");
+    return (space >= 0 ? cut.slice(0, space) : cut) + end;
+  });
+  const helperMap = lookup.getFilter("map");
+  lookup.addFilter("map", function(value, ...args) {
+    const named = keywordArgs(args);
+    const p = named ? args.slice(0, -1) : args;
+    if (named && "attribute" in named)
+      return toList(value).map((item) => {
+        const v = attributeOf(item, named["attribute"]);
+        return v === void 0 && "default" in named ? named["default"] : v;
+      });
+    const items = toList(value);
+    if (typeof p[0] === "string" && !items.some((item) => item !== null && typeof item === "object")) {
+      let filter;
+      try {
+        filter = lookup.getFilter(p[0]);
+      } catch {
+        filter = void 0;
+      }
+      if (filter) return items.map((item) => filter.call(this, item, ...p.slice(1)));
+    }
+    return helperMap.call(this, value, ...args);
+  });
+  const byAttribute = (keep) => function(value, attribute, test, arg) {
+    return toList(value).filter((item) => {
+      const v = attributeOf(item, attribute);
+      return (test === void 0 ? Boolean(v) : runTest(this, String(test), v, arg)) === keep;
+    });
+  };
+  lookup.addFilter("selectattr", byAttribute(true));
+  lookup.addFilter("rejectattr", byAttribute(false));
+}
 function trimChars(s, chars, side) {
   if (chars === void 0 || chars === null)
     return side === "both" ? s.trim() : side === "left" ? s.trimStart() : s.trimEnd();
@@ -1618,6 +1866,20 @@ function installCompat() {
     this.compile(node.target, frame);
     this._emit(")");
   };
+  const compileSet = nunjucks.compiler.Compiler.prototype.compileSet;
+  nunjucks.runtime["formfeedSetAttribute"] = setNamespaceAttribute;
+  nunjucks.compiler.Compiler.prototype.compileSet = function(node, frame) {
+    const [target, ...more] = node.targets;
+    if (!target || more.length || target.typename !== "LookupVal") return compileSet.call(this, node, frame);
+    this._emit("runtime.formfeedSetAttribute(");
+    this._compileExpression(target["target"], frame);
+    this._emit(", ");
+    this._compileExpression(target["val"], frame);
+    this._emit(", ");
+    if (node.value) this._compileExpression(node.value, frame);
+    else this.compile(node.body, frame);
+    this._emitLine(");");
+  };
   const original = nunjucks.runtime.memberLookup;
   nunjucks.runtime.memberLookup = (obj, val2, ...rest) => {
     if (typeof obj === "string" && typeof val2 === "string" && Object.prototype.hasOwnProperty.call(stringMethods, val2)) {
@@ -1664,6 +1926,8 @@ function createEnvironment(ctx) {
     env.addFilter(name, wrapped);
     env.addGlobal(name, wrapped);
   }
+  env.addGlobal("namespace", namespace);
+  installJinjaFilters(env);
   return env;
 }
 var validationContext2 = {
@@ -1704,6 +1968,13 @@ function pathOf(node) {
 function inScope(w, name) {
   return w.scopes.some((s) => s.has(name));
 }
+function sourceOf(w, name) {
+  for (let i = w.scopes.length - 1; i >= 0; i--) {
+    const scope = w.scopes[i];
+    if (scope?.has(name)) return scope.get(name) ?? null;
+  }
+  return null;
+}
 function walk2(node, w) {
   if (!node || typeof node !== "object") return;
   switch (node.typename) {
@@ -1712,10 +1983,12 @@ function walk2(node, w) {
       const p = pathOf(node);
       if (p) {
         const root = p.path[0] ?? "";
+        const bound = inScope(w, root);
         w.variables.push({
           path: p.path,
           range: nodeRange(p.root, p.path.join(".").length),
-          kind: inScope(w, root) ? "loop-var" : "read"
+          kind: bound ? "loop-var" : "read",
+          ...bound ? { source: sourceOf(w, root) } : {}
         });
       }
       if (node.typename === "LookupVal" && !p) {
@@ -1761,18 +2034,18 @@ function walk2(node, w) {
       const source = pathOf(arr);
       const nameNode = node["name"];
       const names = nameNode.typename === "Array" ? nameNode.children ?? [] : [nameNode];
-      const scope = /* @__PURE__ */ new Set();
+      const root = source?.path[0] ?? "";
+      const items = !source ? null : inScope(w, root) ? ((s) => s ? [...s, ...source.path.slice(1)] : null)(sourceOf(w, root)) : source.path;
+      const scope = /* @__PURE__ */ new Map();
       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
-        );
+        const bound = names.length === 1 ? items : null;
+        scope.set(name, bound);
         w.variables.push({
           path: [name],
           range: nodeRange(n, name.length),
-          kind: "loop-var"
+          kind: "loop-var",
+          source: bound
         });
       }
       w.scopes.push(scope);
@@ -1790,8 +2063,7 @@ function walk2(node, w) {
             range: nodeRange(p.root, p.path.join(".").length),
             kind: "assigned"
           });
-          w.scopes[0]?.add(p.path[0] ?? "");
-          w.loopSources.set(p.path[0] ?? "", null);
+          if (p.path.length === 1 || !inScope(w, p.path[0] ?? "")) w.scopes[0]?.set(p.path[0] ?? "", null);
         }
       }
       walk2(node["value"], w);
@@ -1800,17 +2072,27 @@ function walk2(node, w) {
     }
     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 scope = /* @__PURE__ */ new Map();
+      for (const child of args.children ?? []) {
+        if (child.typename === "Symbol") scope.set(String(child.value), null);
+        if (child.typename === "KeywordArgs")
+          for (const pair of child.children ?? []) {
+            const key = pair["key"];
+            if (key) scope.set(String(key.value), null);
+            walk2(pair["value"], w);
+          }
+      }
       const nameNode = node["name"];
-      w.scopes[0]?.add(String(nameNode.value));
-      w.loopSources.set(String(nameNode.value), null);
+      w.scopes[0]?.set(String(nameNode.value), null);
       w.scopes.push(scope);
       walk2(node["body"], w);
       w.scopes.pop();
       return;
     }
+    case "Pair": {
+      walk2(node["value"], w);
+      return;
+    }
     case "Include":
     case "Extends":
     case "Import":
@@ -1823,15 +2105,17 @@ function walk2(node, w) {
         });
       else walk2(tpl, w);
       if (node.typename === "Import")
-        w.scopes[0]?.add(
-          String(node["target"]?.value ?? "")
+        w.scopes[0]?.set(
+          String(node["target"]?.value ?? ""),
+          null
         );
       if (node.typename === "FromImport")
         for (const n of node["names"].children ?? [])
-          w.scopes[0]?.add(
+          w.scopes[0]?.set(
             String(
               n.typename === "Pair" ? n["value"].value : n.value
-            )
+            ),
+            null
           );
       return;
     }
@@ -1849,12 +2133,6 @@ function walk2(node, w) {
       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);
@@ -1862,8 +2140,7 @@ function analyzeJinja2(source, opts = {}) {
     variables: [],
     filters: [],
     includes: [],
-    loopSources: /* @__PURE__ */ new Map(),
-    scopes: [/* @__PURE__ */ new Set()],
+    scopes: [/* @__PURE__ */ new Map()],
     helpers
   };
   try {
@@ -1892,6 +2169,13 @@ function analyzeJinja2(source, opts = {}) {
         range: f.range,
         fix: { title: `Rename to ${preferred}`, replacement: preferred }
       });
+    } else if (unavailableHelper(f.name)) {
+      diagnostics.push({
+        severity: "warning",
+        code: "unavailable-helper",
+        message: unavailableHelper(f.name),
+        range: f.range
+      });
     } else if (!f.known) {
       diagnostics.push({
         severity: "error",
@@ -1905,7 +2189,7 @@ function analyzeJinja2(source, opts = {}) {
   const dataDiagnostics = missingPathDiagnostics(
     w.variables,
     opts.sampleData,
-    w.loopSources,
+    /* @__PURE__ */ new Map(),
     builtin
   );
   return {
@@ -2038,6 +2322,10 @@ var liquidBuiltinFilters = /* @__PURE__ */ new Set([
   "url_decode",
   "url_encode",
   "where",
+  "where_exp",
+  "find_exp",
+  "reject_exp",
+  "group_by_exp",
   "raw",
   "sum",
   "group_by",
@@ -2292,6 +2580,13 @@ function analyzeLiquid(source, opts = {}) {
         range: f.range,
         fix: { title: `Rename to ${preferred}`, replacement: preferred }
       });
+    } else if (unavailableHelper(f.name)) {
+      diagnostics.push({
+        severity: "warning",
+        code: "unavailable-helper",
+        message: unavailableHelper(f.name),
+        range: f.range
+      });
     } else if (!f.known) {
       diagnostics.push({
         severity: "error",
@@ -2833,7 +3128,12 @@ function mapApitemplateSettings(input) {
   return { settings, ignored, notes };
 }
 
-// packages/engine/src/lib/import/apitemplate.ts
+// packages/api-types/src/lib/assets.ts
+var SEGMENT = "[A-Za-z0-9][A-Za-z0-9._-]*";
+var ASSET_NAME_PATTERN = new RegExp(`^${SEGMENT}(?:/${SEGMENT})*$`);
+var ASSET_MAX_BYTES = 10 * 1024 * 1024;
+
+// packages/engine/src/lib/import/common.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)}`;
@@ -2847,6 +3147,85 @@ function parseSample(value) {
     return { data: {}, error: e instanceof Error ? e.message : String(e) };
   }
 }
+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 notesFor(source, pattern, note, { once = false } = {}) {
+  const global = new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`);
+  const out = [];
+  for (const m of source.matchAll(global)) {
+    out.push({ ...note, ...positionOf2(source, m.index ?? 0) });
+    if (once) break;
+  }
+  return out;
+}
+function checkTemplate(engineId, html, sampleData, name, docs) {
+  const errors = [];
+  const warnings = [];
+  const engine = getEngine(engineId);
+  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: docs.syntax });
+  }
+  const fromDiagnostic = (d) => ({
+    code: d.code,
+    message: d.message,
+    line: d.range.start.line,
+    column: d.range.start.column,
+    docs: d.code === "unknown-filter" ? docs.filters : d.code.startsWith("missing-") ? docs.sampleData : docs.syntax
+  });
+  for (const d of engine.analyze(html, { sampleData }).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);
+  }
+  return { errors, warnings };
+}
+function lengthMm(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value === "number" && Number.isFinite(value)) 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;
+}
+function toBase64(value) {
+  if (typeof value === "string") return value;
+  const bytes = value instanceof Uint8Array ? value : value && typeof value === "object" && Array.isArray(value.data) ? Uint8Array.from(value.data) : Array.isArray(value) ? Uint8Array.from(value) : void 0;
+  if (!bytes) return void 0;
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768) binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return btoa(binary);
+}
+var mimeByExtension = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  css: "text/css",
+  js: "text/javascript",
+  html: "text/html",
+  json: "application/json",
+  txt: "text/plain"
+};
+function mimeOf(name) {
+  return mimeByExtension[name.split(".").pop()?.toLowerCase() ?? ""] ?? "application/octet-stream";
+}
+
+// packages/engine/src/lib/import/apitemplate.ts
+var HIDDEN_WRAPPER = "apitemplate-is-content-hidden";
 var pythonisms = [
   {
     pattern: /\{\{[^}]*%\s*\(/,
@@ -2879,12 +3258,6 @@ var pythonisms = [
     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;
@@ -2902,12 +3275,7 @@ function setInLoop(source) {
   }
   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";
@@ -2927,29 +3295,28 @@ function importApitemplate(input) {
   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 ?? "";
+  let css2 = input.css ?? "";
+  if (html.includes(HIDDEN_WRAPPER)) {
+    css2 = `.${HIDDEN_WRAPPER} { display: none !important; }
+${css2}`;
+    changes.push(`elements of the editor class "${HIDDEN_WRAPPER}" are hidden by a rule added to the 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(", ")}`);
+  const checked = checkTemplate("jinja2", html, sample.data, name, {
+    syntax: "/templates/languages#jinja2",
+    filters: "/templates/helpers",
+    sampleData: "/migrate/apitemplate-io#sample-data"
+  });
+  warnings.push(...checked.warnings);
+  const aliasHits = /\|\s*(currency_format|table|page_break|raw|translate)\b/g;
+  const aliases = [...new Set([...html.matchAll(aliasHits)].map((m) => m[1]))];
+  if (aliases.length) changes.push(`apitemplate.io filters kept through aliases: ${aliases.join(", ")}`);
   return {
+    source: "apitemplate",
     name,
     slug: slugFromName(name),
     kind,
@@ -2959,12 +3326,767 @@ function importApitemplate(input) {
     head: "",
     settings,
     sampleData: sample.data,
-    errors,
+    errors: checked.errors,
     warnings,
     changes
   };
 }
 
+// packages/engine/src/lib/import/scss.ts
+var DOCS = "/migrate/pdfmonkey#styles";
+var needsCompiler = [
+  { pattern: /@(mixin|include)\b/, what: "@mixin/@include" },
+  { pattern: /@extend\b/, what: "@extend" },
+  { pattern: /@(if|else|each|for|while|function|return)\b/, what: "SCSS control flow and functions" },
+  { pattern: /@(use|forward)\b/, what: "@use/@forward" },
+  { pattern: /(^|[\s,{])%[a-zA-Z_][\w-]*\s*\{/m, what: "%placeholder selectors" },
+  { pattern: /\b(darken|lighten|saturate|desaturate|adjust-hue|mix|transparentize|opacify|fade-in|fade-out|percentage|map-get|nth)\s*\(/, what: "Sass colour and map functions" },
+  { pattern: /#\{/, what: "interpolation #{\u2026}" }
+];
+function isScss(source) {
+  return /(^|[^\w-])\$[a-zA-Z_][\w-]*\s*:/m.test(source) || /^\s*\/\//m.test(source) || needsCompiler.some((r) => r.pattern.test(source));
+}
+function topLevelVariables(source) {
+  const vars = /* @__PURE__ */ new Map();
+  let depth = 0;
+  let statement = "";
+  for (const ch of source) {
+    if (ch === "{") {
+      depth++;
+      statement = "";
+    } else if (ch === "}") {
+      depth = Math.max(0, depth - 1);
+      statement = "";
+    } else if (ch === ";" && depth === 0) {
+      const m = /^\s*\$([a-zA-Z_][\w-]*)\s*:\s*([\s\S]+?)\s*(!default)?\s*$/.exec(statement);
+      if (m && m[1] && m[2]) vars.set(m[1], m[2]);
+      statement = "";
+    } else statement += ch;
+  }
+  return vars;
+}
+function convertScss(source, compile) {
+  const warnings = [];
+  const changes = [];
+  if (!source.trim() || !isScss(source)) return { css: source, warnings, changes };
+  if (compile) {
+    try {
+      const css3 = compile(source);
+      changes.push("SCSS compiled to CSS");
+      return { css: css3, warnings, changes };
+    } catch (e) {
+      warnings.push({
+        code: "scss-compile",
+        message: `The SCSS did not compile (${e instanceof Error ? e.message.split("\n")[0] : String(e)}); it was converted without a compiler instead.`,
+        docs: DOCS
+      });
+    }
+  }
+  let css2 = source.replace(/^[ \t]*\/\/.*(\r?\n)?/gm, "");
+  if (css2 !== source) changes.push("SCSS line comments (//) removed");
+  const vars = topLevelVariables(css2);
+  if (vars.size) {
+    css2 = css2.replace(/(?<=^|[;{}\s])\$([a-zA-Z_][\w-]*)\s*:[^;{}]*;[ \t]*\r?\n?/gm, (m, name) => vars.has(name) ? "" : m);
+    const names = [...vars.keys()].sort((a, b) => b.length - a.length);
+    for (let pass = 0; pass < 5; pass++) {
+      const before = css2;
+      for (const name of names) css2 = css2.replace(new RegExp(`\\$${name}(?![\\w-])`, "g"), vars.get(name) ?? "");
+      if (css2 === before) break;
+    }
+    changes.push(`SCSS variables substituted: ${names.map((n) => `$${n}`).join(", ")}`);
+  }
+  for (const rule of needsCompiler)
+    warnings.push(
+      ...notesFor(css2, rule.pattern, {
+        code: "scss-needs-compiler",
+        message: `The stylesheet uses ${rule.what}, which only a Sass compiler resolves; convert it to CSS by hand or import with the Formfeed app, which compiles SCSS.`,
+        docs: DOCS
+      }, { once: true })
+    );
+  warnings.push(
+    ...notesFor(css2, /\$[a-zA-Z_][\w-]*/, {
+      code: "scss-variable",
+      message: "A SCSS variable that is not declared at the top level was left in place; replace it with its value or a CSS custom property.",
+      docs: DOCS
+    }, { once: true })
+  );
+  return { css: css2, warnings, changes };
+}
+
+// packages/engine/src/lib/import/pdfmonkey.ts
+var DOCS2 = "/migrate/pdfmonkey";
+var strftime = {
+  Y: "yyyy",
+  y: "yy",
+  m: "MM",
+  "-m": "M",
+  d: "dd",
+  "-d": "d",
+  e: "d",
+  H: "HH",
+  "-H": "H",
+  k: "H",
+  I: "hh",
+  "-I": "h",
+  l: "h",
+  M: "mm",
+  "-M": "m",
+  S: "ss",
+  "-S": "s",
+  L: "SSS",
+  p: "a",
+  P: "aaa",
+  B: "MMMM",
+  b: "MMM",
+  h: "MMM",
+  A: "EEEE",
+  a: "EEE",
+  u: "i",
+  z: "xx",
+  F: "yyyy-MM-dd",
+  D: "MM/dd/yy",
+  T: "HH:mm:ss",
+  R: "HH:mm",
+  r: "hh:mm:ss a"
+};
+function strftimeToDateFns(format) {
+  let out = "";
+  let literal = "";
+  const unmapped = [];
+  const flushLiteral = () => {
+    if (!literal) return;
+    out += /[A-Za-z']/.test(literal) ? `'${literal.replace(/'/g, "''")}'` : literal;
+    literal = "";
+  };
+  for (let i = 0; i < format.length; i++) {
+    const ch = format[i] ?? "";
+    if (ch !== "%") {
+      literal += ch;
+      continue;
+    }
+    const flag = format[i + 1] === "-" ? "-" : "";
+    const directive = format[i + 1 + flag.length] ?? "";
+    i += flag.length + 1;
+    if (directive === "%") {
+      literal += "%";
+      continue;
+    }
+    const token = strftime[`${flag}${directive}`] ?? strftime[directive];
+    if (token) {
+      flushLiteral();
+      out += token;
+    } else {
+      unmapped.push(`%${flag}${directive}`);
+      literal += `%${flag}${directive}`;
+    }
+  }
+  flushLiteral();
+  return { format: out, unmapped };
+}
+var quote = (value) => value.includes('"') && !value.includes("'") ? `'${value}'` : `"${value}"`;
+function localeForSeparators(delimiter, separator) {
+  const key = `${delimiter.replace(/\u00a0/g, " ")}|${separator}`;
+  return {
+    ",|.": "en-US",
+    ".|,": "de-DE",
+    " |,": "fr-FR",
+    "'|.": "de-CH"
+  }[key];
+}
+function keywordArgs2(args) {
+  const out = {};
+  for (const m of args.matchAll(/([a-z_]\w*)\s*:\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[^,\s|]+)/g)) {
+    const raw = m[2] ?? "";
+    out[m[1] ?? ""] = /^["']/.test(raw) ? raw.slice(1, -1) : raw;
+  }
+  return out;
+}
+var unsupportedFilters = {
+  to_sentence: 'use `join: ", "`, or `array_to_sentence_string` for "a, b, and c"',
+  ensure_protocol: 'store the URL with its protocol, or prepend it with `prepend: "https:"`',
+  format: "use `number: 2` for decimals or `round: 2`; printf padding has no equivalent",
+  parse_json: "send the value as JSON in the payload instead of a string",
+  in_time_zone: 'pass the zone to `date` as its second argument: `date: "dd.MM.yyyy", "Europe/Berlin"`'
+};
+function mapLiquid(source, fn) {
+  return source.replace(/(\{\{-?|\{%-?)([\s\S]*?)(-?\}\}|-?%\})/g, (_m, open, inner, close) => `${open}${fn(inner)}${close}`);
+}
+function convertDialect(source, changes) {
+  const errors = [];
+  const warnings = [];
+  let out = mapLiquid(source, (inner) => {
+    let expr = inner;
+    expr = expr.replace(/\|\s*([a-z_]\w*)\s*,\s*(?=[a-z_]\w*\s*:)/g, (_m, name) => {
+      changes.add("filter arguments written with a colon (`| filter: key: value`) instead of a comma");
+      return `| ${name}: `;
+    });
+    expr = expr.replace(
+      /\|\s*in_time_zone\s*:\s*(["'])([^"']+)\1\s*\|\s*date\s*:\s*(["'])((?:(?!\3).)*)\3/g,
+      (_m, _q, zone, _q2, fmt) => {
+        changes.add("`in_time_zone` merged into `date` as its timezone argument");
+        return `| date: ${quote(fmt)}, ${quote(zone)}`;
+      }
+    );
+    expr = expr.replace(/\|\s*date\s*:\s*(["'])((?:(?!\1).)*)\1/g, (m, _q, fmt) => {
+      if (!fmt.includes("%")) return m;
+      const converted = strftimeToDateFns(fmt);
+      changes.add("date formats converted from strftime (%d.%m.%Y) to date-fns tokens (dd.MM.yyyy)");
+      if (converted.unmapped.length)
+        warnings.push({
+          code: "date-directive",
+          message: `The date format "${fmt}" uses ${converted.unmapped.join(", ")}, which has no date-fns equivalent; it is kept literally.`,
+          docs: `${DOCS2}#dates`
+        });
+      return `| date: ${quote(converted.format)}`;
+    });
+    expr = expr.replace(/(["'])today\1(\s*\|\s*date\b)/g, '"now"$2');
+    expr = expr.replace(/\|\s*slice_by\b/g, () => {
+      changes.add("`slice_by` renamed to `chunk`");
+      return "| chunk";
+    });
+    expr = expr.replace(/\s*\|\s*entities\b/g, () => {
+      changes.add("`entities` removed: header and footer render UTF-8 directly");
+      return "";
+    });
+    expr = expr.replace(/\|\s*with_delimiter\b(\s*:\s*[^|]*)?/g, (m, args) => {
+      const opts = keywordArgs2(args ?? "");
+      const locale = localeForSeparators(opts["delimiter"] ?? ",", opts["separator"] ?? ".");
+      if (!locale) {
+        warnings.push({
+          code: "number-separators",
+          message: `with_delimiter with delimiter "${opts["delimiter"] ?? ","}" and separator "${opts["separator"] ?? "."}" has no matching locale; it was kept and will fail.`,
+          docs: `${DOCS2}#numbers`
+        });
+        return m;
+      }
+      if (opts["strip_insignificant_zeros"] === "true")
+        warnings.push({
+          code: "number-strip-zeros",
+          message: "`strip_insignificant_zeros` has no equivalent; `number` shows up to three decimals without fixed precision.",
+          docs: `${DOCS2}#numbers`
+        });
+      changes.add("`with_delimiter` converted to `number` with a locale that has the same separators");
+      const decimals = opts["strip_insignificant_zeros"] === "true" ? "nil" : opts["precision"] ?? "nil";
+      return `| number: ${decimals}, ${quote(locale)} `;
+    });
+    return expr;
+  });
+  for (const [filter, instead] of Object.entries(unsupportedFilters))
+    errors.push(
+      ...notesFor(out, new RegExp(`\\|\\s*${filter}\\b`), {
+        code: "pdfmonkey-filter",
+        message: `PDFMonkey's \`${filter}\` filter has no Formfeed equivalent: ${instead}.`,
+        docs: `${DOCS2}#filters`
+      })
+    );
+  warnings.push(
+    ...notesFor(out, /\|\s*divided_by\s*:\s*-?\d+\s*(?=[|}%]|-?%\}|-?\}\})/, {
+      code: "integer-division",
+      message: "PDFMonkey (Ruby Liquid) divides two integers without remainder: `7 | divided_by: 2` is 3 there and 3.5 here. Add `| floor` if the template relies on it.",
+      docs: `${DOCS2}#numbers`
+    })
+  );
+  out = out.replace(/\[%\s*data_form_field[^\]]*\]/g, (m) => {
+    warnings.push({ code: "pdf-forms", message: "PDF form markers are not supported; the marker is kept as text.", docs: `${DOCS2}#forms`, ...positionOf2(out, out.indexOf(m)) });
+    return m;
+  });
+  return { source: out, errors, warnings, changes };
+}
+function splitParams(params) {
+  const out = [];
+  for (const m of params.matchAll(/([A-Za-z_]\w*)\s*:\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[^,]+)/g))
+    out.push([m[1] ?? "", (m[2] ?? "").trim()]);
+  return out;
+}
+function inlineIncludes(source, blocks, errors, changes) {
+  let out = source;
+  for (let depth = 0; depth < 6; depth++) {
+    let inlined = false;
+    out = out.replace(/\{%-?\s*include\s+(["'])([^"']+)\1\s*(?:,\s*([\s\S]*?))?\s*-?%\}/g, (m, _q, name, params) => {
+      const body = blocks.get(name);
+      if (body === void 0) return m;
+      inlined = true;
+      changes.add("snippets and partials inlined into the template");
+      const assigns = splitParams(params ?? "").map(([k, v]) => `{% assign ${k} = ${v} %}`).join("");
+      return `${assigns}${body}`;
+    });
+    if (!inlined) break;
+  }
+  for (const m of out.matchAll(/\{%-?\s*include\s+(["'])([^"']+)\1/g))
+    errors.push({
+      code: "snippet-missing",
+      message: `The snippet "${m[2]}" is not part of the template; paste its code in the import dialog (Snippets) or with --snippet ${m[2]}=file.liquid.`,
+      docs: `${DOCS2}#snippets`,
+      ...positionOf2(out, m.index ?? 0)
+    });
+  return out;
+}
+var cssPaperFormats = { a3: "A3", a4: "A4", a5: "A5", letter: "Letter" };
+var isoSizes = { a0: [841, 1189], a1: [594, 841], a2: [420, 594], a6: [105, 148] };
+var escapeHtml2 = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+function simpleHeaderFooter(part, margin) {
+  const cells = ["left", "center", "right"].map((side) => part[side] ?? "");
+  if (!cells.some((c) => c.trim())) return void 0;
+  const cell = (text, align) => `<div style="flex: 1; text-align: ${align}">${escapeHtml2(text).replace(/\[page\]/g, '<span class="pageNumber"></span>').replace(/\[topage\]/g, '<span class="totalPages"></span>')}</div>`;
+  return `<div style="display: flex; width: 100%; font-size: 10px; padding: 0 ${margin.right} 0 ${margin.left}">${cell(cells[0] ?? "", "left")}${cell(cells[1] ?? "", "center")}${cell(cells[2] ?? "", "right")}</div>`;
+}
+function mapSettings(input, kind, warnings, changes) {
+  const settings = {};
+  const format = String(input.paper_format ?? "a4").toLowerCase();
+  if (format === "custom") {
+    const width = lengthMm(input.paper_width);
+    const height = lengthMm(input.paper_height);
+    if (width && height) settings.paper = { width, height };
+    else warnings.push({ code: "setting-ignored", message: "Custom paper size without width and height; A4 is used.", docs: `${DOCS2}#settings` });
+  } else if (cssPaperFormats[format]) settings.paper = { format: cssPaperFormats[format] };
+  else if (isoSizes[format]) {
+    const [w, h] = isoSizes[format] ?? [210, 297];
+    settings.paper = { width: `${w}mm`, height: `${h}mm` };
+    changes.add(`${format.toUpperCase()} kept as its size in millimetres`);
+  } else warnings.push({ code: "setting-ignored", message: `Paper format "${input.paper_format}" is unknown; A4 is used.`, docs: `${DOCS2}#settings` });
+  if (String(input.orientation ?? "").toLowerCase() === "landscape") settings.paper = { ...settings.paper, landscape: true };
+  const m = input.margin ?? {};
+  const margin = {
+    top: lengthMm(m.top) ?? "10mm",
+    right: lengthMm(m.right) ?? "10mm",
+    bottom: lengthMm(m.bottom) ?? "10mm",
+    left: lengthMm(m.left) ?? "10mm"
+  };
+  settings.margin = margin;
+  changes.add("paper, orientation and margins mapped (empty PDFMonkey margins are 10 mm)");
+  let header;
+  let footer;
+  for (const [key, part] of [
+    ["header", input.header],
+    ["footer", input.footer]
+  ]) {
+    if (!part) continue;
+    const html = part.content?.trim() ? part.content : simpleHeaderFooter(part, margin);
+    if (!html) continue;
+    if (key === "header") header = html;
+    else footer = html;
+    changes.add(
+      part.content?.trim() ? "header and footer HTML moved to the Header and Footer tabs" : "simple header and footer rebuilt as HTML with page numbers; check the font size"
+    );
+  }
+  if (kind === "image") {
+    settings.image = { width: 1200, height: 630, deviceScaleFactor: 2, format: "png", ...input.transparent_background ? { transparent: true } : {} };
+    changes.add("image size defaults to 1200 \xD7 630 (PDFMonkey sets it per request; change it in Settings)");
+  }
+  if (input.inject_javascript)
+    warnings.push({
+      code: "inject-javascript",
+      message: "PDFMonkey exposed the payload to scripts as `$docPayload`; Formfeed does not. Render the values into the markup, or write them into a script tag with the json filter.",
+      docs: `${DOCS2}#javascript`
+    });
+  if (input.use_paged)
+    warnings.push({ code: "paged-js", message: "The template waited for Paged.js; check page breaks and margin boxes in the true render.", docs: `${DOCS2}#paged-js` });
+  if (input.use_forms) warnings.push({ code: "pdf-forms", message: "PDF form fields are not supported.", docs: `${DOCS2}#forms` });
+  if (input.use_emojis) changes.add("`use_emojis` dropped: emoji render with the system emoji font");
+  return { settings, header, footer };
+}
+function convertMarkup(html, settings, warnings, changes) {
+  let out = html;
+  const tailwind = /<script\b[^>]*\bsrc=["'][^"']*tailwind[^"']*["'][^>]*>\s*<\/script>\s*|<link\b[^>]*\bhref=["'][^"']*tailwind[^"']*\.css["'][^>]*>\s*/gi;
+  if (tailwind.test(out)) {
+    out = out.replace(tailwind, "");
+    settings.tailwind = true;
+    changes.add("Tailwind script removed and Tailwind mode switched on (Formfeed compiles the classes)");
+  }
+  warnings.push(
+    ...notesFor(out, /pagedjs|paged\.polyfill/i, {
+      code: "paged-js",
+      message: "The template loads Paged.js; Formfeed paginates with Chromium, so check running headers and margin boxes in the true render.",
+      docs: `${DOCS2}#paged-js`
+    }, { once: true }),
+    ...notesFor(out, /qr-code-styling|@bitjson\/qr-code|qrcode(\.min)?\.js|qrcodejs/i, {
+      code: "qr-library",
+      message: 'A JavaScript QR library is loaded; the `qrcode` helper renders QR codes without scripts: `<img src="{{ url | qrcode }}">`.',
+      docs: "/templates/helpers#qrcode"
+    }, { once: true }),
+    ...notesFor(out, /\$docPayload/, {
+      code: "inject-javascript",
+      message: "`$docPayload` is not defined in Formfeed; render the values into the markup or write them into a script tag with the json filter.",
+      docs: `${DOCS2}#javascript`
+    }, { once: true })
+  );
+  return out;
+}
+function importPdfmonkey(input, options = {}) {
+  const tpl = "document_template" in input ? input.document_template : input;
+  const errors = [];
+  const warnings = [];
+  const changes = /* @__PURE__ */ new Set();
+  const pick2 = (published, draft) => {
+    const empty = (v) => v === void 0 || v === null || v === "";
+    if (options.draft) return empty(draft) ? published : draft;
+    if (empty(published) && !empty(draft)) {
+      changes.add("the template was never published; the draft was imported");
+      return draft;
+    }
+    return published;
+  };
+  const name = (tpl.identifier ?? "").trim() || "Imported template";
+  const kind = String(tpl.output_type ?? "").toLowerCase() === "image" ? "image" : "pdf";
+  if (tpl.edition_mode === "builder")
+    errors.push({
+      code: "builder-template",
+      message: "This is a PDFMonkey Builder template; its format is not documented, so only code templates can be imported. Recreate it in the Formfeed editor.",
+      docs: DOCS2
+    });
+  const mapped = mapSettings(pick2(tpl.settings, tpl.settings_draft) ?? {}, kind, warnings, changes);
+  const settings = mapped.settings;
+  let body = String(pick2(tpl.body, tpl.body_draft) ?? "");
+  const blocks = new Map(Object.entries(options.snippets ?? {}));
+  body = body.replace(/\{%-?\s*partial\s+(["'])([^"']+)\1\s*-?%\}([\s\S]*?)\{%-?\s*endpartial\s*-?%\}/g, (_m, _q, partialName, content) => {
+    blocks.set(partialName, content);
+    return "";
+  });
+  body = body.replace(/\{%-?\s*load_snippets\b[\s\S]*?-?%\}/g, () => {
+    changes.add("`load_snippets` removed");
+    return "";
+  });
+  body = inlineIncludes(body, blocks, errors, changes);
+  const converted = convertDialect(body, changes);
+  errors.push(...converted.errors);
+  warnings.push(...converted.warnings);
+  const html = convertMarkup(converted.source, settings, warnings, changes);
+  for (const key of ["header", "footer"]) {
+    const part = mapped[key];
+    if (!part) continue;
+    const result = convertDialect(inlineIncludes(part, blocks, errors, changes), changes);
+    settings[key] = { html: result.source };
+    errors.push(...result.errors.map((n) => ({ ...n, message: `${key}: ${n.message}` })));
+    warnings.push(...result.warnings.map((n) => ({ ...n, message: `${key}: ${n.message}` })));
+  }
+  const scss = convertScss(String(pick2(tpl.scss_style, tpl.scss_style_draft) ?? ""), options.compileScss);
+  warnings.push(...scss.warnings);
+  for (const change of scss.changes) changes.add(change);
+  const sample = parseSample(pick2(tpl.sample_data, tpl.sample_data_draft));
+  if (sample.error)
+    warnings.push({ code: "sample-json", message: `Sample data is not valid JSON (${sample.error}); the draft starts without sample data.`, docs: `${DOCS2}#sample-data` });
+  const checked = checkTemplate("liquid", html, sample.data, name, {
+    syntax: "/templates/languages#liquid",
+    filters: `${DOCS2}#filters`,
+    sampleData: `${DOCS2}#sample-data`
+  });
+  const explained = new Set(errors.filter((e) => e.code === "pdfmonkey-filter").map((e) => e.line));
+  const generic = (e) => e.code === "unknown-filter" || e.code === "syntax-error" && /undefined filter/i.test(e.message);
+  errors.push(...checked.errors.filter((e) => !(generic(e) && explained.has(e.line))));
+  warnings.push(...checked.warnings);
+  return {
+    source: "pdfmonkey",
+    name,
+    slug: slugFromName(name),
+    kind,
+    engine: "liquid",
+    html,
+    css: scss.css,
+    head: "",
+    settings,
+    sampleData: sample.data,
+    errors,
+    warnings,
+    changes: [...changes]
+  };
+}
+
+// packages/engine/src/lib/import/jsreport.ts
+var DOCS3 = "/migrate/jsreport";
+var COLLECTIONS = ["templates", "data", "assets", "components", "scripts", "folders"];
+function readJsreportExport(files) {
+  const bundle = { templates: [], data: [], assets: [], components: [], scripts: [], folders: [] };
+  for (const [path, text] of Object.entries(files)) {
+    const normalized = path.replace(/\\/g, "/").replace(/^\.?\//, "");
+    if (normalized === "metadata.json") {
+      try {
+        bundle.version = String(JSON.parse(text).reporterVersion ?? "");
+      } catch {
+      }
+      continue;
+    }
+    const collection = normalized.split("/")[0];
+    if (!COLLECTIONS.includes(collection) || !normalized.endsWith(".json")) continue;
+    try {
+      bundle[collection].push(JSON.parse(text));
+    } catch {
+    }
+  }
+  if (!bundle.templates.length) throw new Error("No templates found: this does not look like a jsreport export (.jsrexport).");
+  return bundle;
+}
+function folderPath(bundle, entity) {
+  const parts = [];
+  let shortid = entity.folder?.shortid;
+  for (let guard = 0; shortid && guard < 20; guard++) {
+    const folder = bundle.folders.find((f) => f.shortid === shortid);
+    if (!folder) break;
+    parts.unshift(folder.name ?? "");
+    shortid = folder.folder?.shortid;
+  }
+  return parts.filter(Boolean).join("/");
+}
+function pathOf2(bundle, entity) {
+  const folder = folderPath(bundle, entity);
+  return folder ? `${folder}/${entity.name ?? ""}` : entity.name ?? "";
+}
+function jsreportTemplates(bundle) {
+  return bundle.templates.map((t) => ({ ref: t.shortid ?? t._id ?? t.name ?? "", name: t.name ?? "", path: pathOf2(bundle, t), engine: t.engine ?? "", recipe: t.recipe ?? "" })).sort((a, b) => a.path.localeCompare(b.path));
+}
+function byPath(bundle, list2, ref) {
+  const wanted = ref.replace(/^\.?\/+/, "");
+  return list2.find((e) => pathOf2(bundle, e) === wanted) ?? list2.find((e) => e.name === wanted.split("/").pop());
+}
+function decodeText(base64) {
+  const binary = atob(base64);
+  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+  return new TextDecoder().decode(bytes);
+}
+function assetBase64(content) {
+  if (typeof content === "string") {
+    const compact = content.replace(/\s/g, "");
+    if (compact.length % 4 === 0 && /^[A-Za-z0-9+/]*={0,2}$/.test(compact)) return compact;
+    return toBase64(new TextEncoder().encode(content));
+  }
+  return toBase64(content);
+}
+var escapeMustaches = (text) => text.replace(/\{\{/g, "\\{{");
+function resolveAssets(source, bundle, options, warnings, changes) {
+  const v3 = /\{\{\{?\s*asset\s+(["'])([^"']+)\1(?:\s+(["'])([^"']+)\3)?\s*\}?\}\}/g;
+  const v2 = /\{#asset\s+([^\s}]+)(?:\s+@encoding=(\w+))?\s*\}/g;
+  const replace = (whole, ref, encoding = "utf8") => {
+    const asset = byPath(bundle, bundle.assets, ref);
+    if (!asset) {
+      warnings.push({ code: "asset-missing", message: `The asset "${ref}" is not in the export. Upload it to the workspace file library under that name, or replace the call with a full https URL.`, docs: `${DOCS3}#assets` });
+      return `{{asset "${ref}"}}`;
+    }
+    if (encoding === "link" || !asset.content && asset.link) {
+      if (asset.link && /^https?:\/\//.test(asset.link)) return asset.link;
+      warnings.push({ code: "asset-link", message: `The asset "${ref}" is linked from the jsreport server, which this import cannot read. Upload the file to the workspace file library under that name, or replace the call with a full https URL.`, docs: `${DOCS3}#assets` });
+      return `{{asset "${asset.name}"}}`;
+    }
+    const base64 = assetBase64(asset.content);
+    if (base64 === void 0) return whole;
+    const bytes = Math.floor(base64.length * 3 / 4);
+    if (encoding === "utf8" || encoding === "string") {
+      changes.add("text assets (CSS, scripts, snippets) inlined");
+      return escapeMustaches(decodeText(base64));
+    }
+    if (bytes > options.inlineAssetBytes) {
+      warnings.push({
+        code: "asset-large",
+        message: `The asset "${asset.name}" (${Math.round(bytes / 1024)} KB) is larger than the inline limit. Upload it to the workspace file library under that name, import with a higher inline limit, or replace the call with a full https URL.`,
+        docs: `${DOCS3}#assets`
+      });
+      return `{{asset "${asset.name}"}}`;
+    }
+    changes.add("binary assets (images, fonts) inlined as data URIs");
+    return encoding === "base64" ? base64 : `data:${mimeOf(asset.name ?? "")};base64,${base64}`;
+  };
+  return source.replace(v3, (whole, _q, ref, _q2, encoding) => replace(whole, ref, encoding)).replace(v2, (whole, ref, encoding) => replace(whole, ref, encoding));
+}
+function inlineChildren(source, bundle, errors, warnings, changes) {
+  let out = source;
+  for (let depth = 0; depth < 6; depth++) {
+    const before = out;
+    out = out.replace(/\{\{\{?\s*childTemplate\s+(["'])([^"']+)\1[^}]*\}?\}\}|\{#child\s+([^\s}]+)[^}]*\}/g, (whole, _q, v3, v2) => {
+      const ref = v3 ?? v2 ?? "";
+      const child = byPath(bundle, bundle.templates, ref);
+      if (!child?.content) {
+        errors.push({ code: "child-missing", message: `The child template "${ref}" is not in the export.`, docs: `${DOCS3}#child-templates` });
+        return whole;
+      }
+      changes.add("child templates inlined");
+      return child.content;
+    });
+    out = out.replace(/\{\{\{?\s*component\s+(["'])([^"']+)\1([^}]*)\}?\}\}/g, (whole, _q, ref, props) => {
+      const component = byPath(bundle, bundle.components, ref);
+      if (!component?.content) {
+        errors.push({ code: "component-missing", message: `The component "${ref}" is not in the export.`, docs: `${DOCS3}#components` });
+        return whole;
+      }
+      if (props.trim())
+        warnings.push({
+          code: "component-props",
+          message: `The component "${ref}" received properties (${props.trim()}); it was inlined with the surrounding data, so reference those values directly.`,
+          docs: `${DOCS3}#components`
+        });
+      if (component.helpers?.trim())
+        warnings.push({ code: "custom-helpers", message: `The component "${ref}" has JavaScript helpers, which Formfeed does not run.`, docs: `${DOCS3}#helpers` });
+      changes.add("components inlined");
+      return component.content;
+    });
+    if (out === before) break;
+  }
+  return out;
+}
+function helperNames(script) {
+  const names = /* @__PURE__ */ new Set();
+  for (const m of script.matchAll(/(?:^|[\s;])(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/g)) names.add(m[1] ?? "");
+  for (const m of script.matchAll(/(?:^|[\s;])(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:function\b|\([^)]*\)\s*=>|[A-Za-z_$][\w$]*\s*=>)/g)) names.add(m[1] ?? "");
+  names.delete("");
+  return [...names];
+}
+function mapChrome(template, kind, warnings, changes) {
+  const settings = {};
+  const chrome = template.chrome ?? {};
+  const str2 = (key) => typeof chrome[key] === "string" && chrome[key].trim() ? chrome[key].trim() : void 0;
+  const paper = {};
+  const format = str2("format");
+  if (format) paper.format = format.charAt(0).toUpperCase() + format.slice(1).toLowerCase();
+  const width = lengthMm(str2("width"));
+  const height = lengthMm(str2("height"));
+  if (width && height) {
+    paper.width = width;
+    paper.height = height;
+  }
+  if (chrome["landscape"] === true || chrome["landscape"] === "true") paper.landscape = true;
+  if (Object.keys(paper).length) settings.paper = paper;
+  const margin = {};
+  for (const side of ["top", "right", "bottom", "left"]) {
+    const value = lengthMm(str2(`margin${side[0]?.toUpperCase()}${side.slice(1)}`));
+    if (value) margin[side] = value;
+  }
+  if (Object.keys(margin).length) settings.margin = margin;
+  const showHeaderFooter = chrome["displayHeaderFooter"] === true || chrome["displayHeaderFooter"] === "true";
+  if (showHeaderFooter) {
+    const header = str2("headerTemplate");
+    const footer = str2("footerTemplate");
+    if (header) settings.header = { html: header };
+    if (footer) settings.footer = { html: footer };
+    if (header || footer) changes.add("Chromium header and footer templates moved to the Header and Footer tabs");
+  }
+  if (chrome["printBackground"] !== void 0) settings.printBackground = chrome["printBackground"] === true || chrome["printBackground"] === "true";
+  if (chrome["scale"] !== void 0 && Number.isFinite(Number(chrome["scale"]))) settings.scale = Number(chrome["scale"]);
+  const ranges = str2("pageRanges");
+  if (ranges) settings.pageRanges = ranges;
+  if (chrome["waitForNetworkIdle"] === true || chrome["waitForNetworkIdle"] === "true") settings.waitFor = { networkIdle: true };
+  if (chrome["waitForJS"] === true || chrome["waitForJS"] === "true")
+    warnings.push({
+      code: "wait-for-js",
+      message: "The template sets window.JSREPORT_READY_TO_START; Formfeed waits for a CSS selector instead (Settings \u2192 Wait for).",
+      docs: `${DOCS3}#settings`
+    });
+  if (str2("mediaType") === "screen") warnings.push({ code: "setting-ignored", message: 'mediaType "screen" is not supported; Formfeed prints with the print media type.', docs: `${DOCS3}#settings` });
+  if (kind === "image") {
+    const img = template.chromeImage ?? {};
+    const type = String(img["type"] ?? "png").toLowerCase();
+    settings.image = {
+      width: Number(img["viewportWidth"] ?? 0) || 1200,
+      height: Number(img["viewportHeight"] ?? 0) || 630,
+      format: type === "jpeg" || type === "jpg" ? "jpeg" : "png",
+      ...Number.isFinite(Number(img["quality"])) && img["quality"] !== void 0 ? { quality: Number(img["quality"]) } : {},
+      ...img["fullPage"] === true ? { fullPage: true } : {},
+      ...img["omitBackground"] === true ? { transparent: true } : {}
+    };
+    changes.add("chrome-image options mapped to the image settings");
+  }
+  const meta = template.pdfMeta ?? {};
+  const metadata = Object.fromEntries(
+    ["title", "author", "subject", "keywords"].filter((k) => typeof meta[k] === "string" && meta[k]).map((k) => [k, String(meta[k])])
+  );
+  if (Object.keys(metadata).length) {
+    settings.pdf = { metadata };
+    changes.add("PDF metadata (pdfMeta) mapped");
+  }
+  changes.add("chrome-pdf options mapped: paper, orientation, margins, background, scale, page ranges");
+  return settings;
+}
+function importJsreport(bundle, ref, options = {}) {
+  const opts = { inlineAssetBytes: options.inlineAssetBytes ?? 256 * 1024 };
+  const template = bundle.templates.find((t) => t.shortid === ref || t._id === ref) ?? byPath(bundle, bundle.templates, ref);
+  if (!template) throw new Error(`No template "${ref}" in the export.`);
+  const errors = [];
+  const warnings = [];
+  const changes = /* @__PURE__ */ new Set();
+  const name = (template.name ?? "").trim() || "Imported template";
+  const engine = String(template.engine ?? "handlebars").toLowerCase();
+  if (engine !== "handlebars" && engine !== "none")
+    errors.push({
+      code: "unsupported-engine",
+      message: `The template uses the ${engine} engine; Formfeed runs Handlebars, Liquid and Jinja2. It was imported as Handlebars and needs rewriting.`,
+      docs: `${DOCS3}#engines`
+    });
+  if (engine === "none") changes.add("template without an engine imported as Handlebars");
+  const recipe = String(template.recipe ?? "chrome-pdf").toLowerCase();
+  const kind = recipe === "chrome-image" ? "image" : "pdf";
+  if (!["chrome-pdf", "chrome-image", "html"].includes(recipe))
+    errors.push({
+      code: "unsupported-recipe",
+      message: `The ${recipe} recipe has no Formfeed equivalent; the template was imported as a PDF template.`,
+      docs: `${DOCS3}#recipes`
+    });
+  if (recipe === "html") changes.add("html recipe imported as a PDF template");
+  const settings = mapChrome(template, kind, warnings, changes);
+  let html = inlineChildren(template.content ?? "", bundle, errors, warnings, changes);
+  html = resolveAssets(html, bundle, opts, warnings, changes);
+  for (const key of ["header", "footer"]) {
+    const part = settings[key]?.html;
+    if (part) settings[key] = { html: resolveAssets(inlineChildren(part, bundle, errors, warnings, changes), bundle, opts, warnings, changes) };
+  }
+  html = html.replace(/\{\{\{?\s*toJS\s+([^}]+?)\s*\}?\}\}/g, (_m, value) => {
+    changes.add("`toJS` replaced by `json`");
+    return `{{{json ${value}}}}`;
+  });
+  const helperSources = [
+    template.helpers ?? "",
+    ...bundle.assets.filter((a) => a.isSharedHelper).map((a) => {
+      const b64 = assetBase64(a.content);
+      return b64 ? decodeText(b64) : "";
+    })
+  ].filter((s) => s.trim());
+  const helpers = helperSources.flatMap(helperNames);
+  if (helpers.length)
+    warnings.push({
+      code: "custom-helpers",
+      message: `The template defines JavaScript helpers (${helpers.join(", ")}); Formfeed does not run custom code. Replace each call with a built-in helper, or compute the value before sending the data.`,
+      docs: `${DOCS3}#helpers`
+    });
+  warnings.push(
+    ...notesFor(html, /\{\{\{?\s*(pdfAddPageItem|pdfCreatePagesGroup|pdfFormField|module)\b/, {
+      code: "jsreport-helper",
+      message: "A jsreport system helper (pdf-utils or module) has no Formfeed equivalent.",
+      docs: `${DOCS3}#helpers`
+    })
+  );
+  if (template.scripts?.length)
+    warnings.push({ code: "scripts", message: "The template runs jsreport scripts (beforeRender/afterRender); load that data in your application and send it with the render request.", docs: `${DOCS3}#scripts` });
+  if (template.pdfOperations?.length)
+    warnings.push({ code: "pdf-operations", message: "pdf-utils operations (merge, append, headers from another template) are not imported.", docs: `${DOCS3}#pdf-utils` });
+  if (template.pdfPassword && Object.values(template.pdfPassword).some(Boolean))
+    warnings.push({ code: "pdf-password", message: "PDF password protection is not imported.", docs: `${DOCS3}#settings` });
+  if (template.localization?.language)
+    warnings.push({ code: "localization", message: "jsreport localization files are not imported; use the template dictionaries and the `t` helper.", docs: "/templates/helpers#t" });
+  const dataEntity = template.data?.shortid ? bundle.data.find((d) => d.shortid === template.data?.shortid) : void 0;
+  const sample = parseSample(dataEntity?.dataJson);
+  if (sample.error) warnings.push({ code: "sample-json", message: `The sample data is not valid JSON (${sample.error}).`, docs: `${DOCS3}#sample-data` });
+  if (dataEntity) changes.add(`sample data "${dataEntity.name}" became the default data set`);
+  if (new TextEncoder().encode(html).length > 1e6)
+    errors.push({ code: "too-large", message: 'The template is larger than 1 MB after inlining its assets; upload the large files as workspace assets and reference them with {{asset "name"}}.', docs: `${DOCS3}#assets` });
+  const checked = checkTemplate("handlebars", html, sample.data, name, {
+    syntax: "/templates/languages#handlebars",
+    filters: `${DOCS3}#helpers`,
+    sampleData: `${DOCS3}#sample-data`
+  });
+  errors.push(...checked.errors);
+  warnings.push(...checked.warnings);
+  return {
+    source: "jsreport",
+    name,
+    slug: slugFromName(name),
+    kind,
+    engine: "handlebars",
+    html,
+    css: "",
+    head: "",
+    settings,
+    sampleData: sample.data,
+    errors,
+    warnings,
+    changes: [...changes]
+  };
+}
+
 // packages/engine/src/lib/assemble.ts
 function defaultSettings() {
   return {
@@ -3184,6 +4306,37 @@ document.addEventListener('click', function (event) {
   } catch (e) {}
 }, true);
 </script>`;
+var pageNavScript = `<script>
+(function () {
+  var pages = function () { return document.querySelectorAll('.pagedjs_page'); };
+  window.addEventListener('message', function (event) {
+    var data = event.data;
+    if (!data || data.type !== 'formfeed:goto-page') return;
+    var page = pages()[(data.page || 1) - 1];
+    if (page && page.scrollIntoView) page.scrollIntoView({ block: 'start' });
+  });
+  var current = 0;
+  var report = function () {
+    var list = pages();
+    if (!list.length) return;
+    var best = 1;
+    var bestTop = Infinity;
+    for (var i = 0; i < list.length; i++) {
+      var top = Math.abs(list[i].getBoundingClientRect().top);
+      if (top < bestTop) { bestTop = top; best = i + 1; }
+    }
+    if (best === current) return;
+    current = best;
+    try { parent.postMessage({ type: 'formfeed:page', page: best }, '*'); } catch (e) {}
+  };
+  var queued = false;
+  window.addEventListener('scroll', function () {
+    if (queued) return;
+    queued = true;
+    requestAnimationFrame(function () { queued = false; report(); });
+  }, { passive: true });
+})();
+</script>`;
 function flowDocument(draft) {
   const { settings, kind, headerHtml, footerHtml } = draft;
   const margin = settings.margin ?? {};
@@ -3210,11 +4363,12 @@ 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 selectorGuard = `<script>(function(){var q=DocumentFragment.prototype.querySelectorAll;DocumentFragment.prototype.querySelectorAll=function(s){try{return q.call(this,s);}catch(e){console.warn('formfeed paged preview: skipped a selector Paged.js could not use:',s);return q.call(this,':not(*)');}};})();</script>`;
   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}`);
+  return draft.document.replace("</head>", `<style data-formfeed="paged">${runningCss}</style>${selectorGuard}${config}${script}${inspectScript}${pageNavScript}</head>`).replace(/(<body[^>]*>)/, `$1${header}${footer}`);
 }
 export {
   DefaultHelperRegistry,
@@ -3229,6 +4383,7 @@ export {
   chartInitScript,
   chartMarkup,
   chartPayload,
+  convertScss,
   createHelperRegistry,
   defaultHelpers,
   defaultLimits,
@@ -3246,9 +4401,13 @@ export {
   helperDocs,
   imageMarkup,
   importApitemplate,
+  importJsreport,
+  importPdfmonkey,
   inferSchema,
+  isScss,
   jinja2Engine,
   jinjaTags,
+  jsreportTemplates,
   liquidBuiltinFilters,
   liquidEngine,
   liquidTags,
@@ -3261,6 +4420,7 @@ export {
   paperOf,
   printReset,
   qrSvg,
+  readJsreportExport,
   renderVersion,
   resolvePath,
   scanBlocks,
@@ -3268,6 +4428,7 @@ export {
   slugFromName,
   snippets,
   snippetsFor,
+  strftimeToDateFns,
   toDate,
   toNumber
 };