@asterdoc/render 0.0.0-stage → 0.9.0

package/dist/chunk-PNYKTSIT.js

@@ -0,0 +1,1267 @@
+import {
+  RENDER_DATA_ROOTS
+} from "./chunk-U7LF3GN4.js";
+import {
+  FormattedFieldValue,
+  formatFieldData,
+  unwrapFormattedValue
+} from "./chunk-ICQLU4FL.js";
+
+// src/template/errors.ts
+function describeLocation(diagnostic) {
+  const parts = [];
+  if (diagnostic.location) parts.push(diagnostic.location);
+  if (diagnostic.position) parts.push(`line ${diagnostic.position.line}, column ${diagnostic.position.column}`);
+  return parts.join(", ");
+}
+var TemplateError = class _TemplateError extends Error {
+  code;
+  layer;
+  expression;
+  position;
+  location;
+  diagnostic;
+  constructor(diagnostic, layer) {
+    const where = [layer ? `layer "${layer}"` : "", describeLocation(diagnostic)].filter(Boolean).join(", ");
+    const expression = diagnostic.expression === void 0 ? "" : ` in {{${diagnostic.expression}}}`;
+    super(`${where ? `Template error at ${where}` : "Template error"}${expression}: ${diagnostic.message}`);
+    this.name = "TemplateError";
+    this.code = diagnostic.code;
+    this.layer = layer;
+    this.expression = diagnostic.expression;
+    this.position = diagnostic.position;
+    this.location = diagnostic.location;
+    this.diagnostic = diagnostic;
+  }
+  /** The same error, naming the layer it came from. */
+  inLayer(layer) {
+    return layer && !this.layer ? new _TemplateError(this.diagnostic, layer) : this;
+  }
+};
+var COMPARISON_HELPERS = { eq: "==", ne: "!=", gt: ">", gte: ">=", lt: "<", lte: "<=" };
+function removedSyntaxHint(source) {
+  const text = source.trim();
+  const helper = text.match(/^\(?\s*(eq|ne|gt|gte|lt|lte|not|and|or|contains|default)\s+(?![=<>!])/);
+  if (helper) {
+    const name = helper[1];
+    if (COMPARISON_HELPERS[name]) {
+      return `The "${name}" helper is removed; compare with the ${COMPARISON_HELPERS[name]} operator, such as fields.status ${COMPARISON_HELPERS[name]} "active".`;
+    }
+    if (name === "not") return 'The "not" helper is removed; write not before the condition, such as not fields.approved.';
+    if (name === "and" || name === "or") return `The "${name}" helper is removed; join conditions with the ${name} operator, such as fields.a ${name} fields.b.`;
+    if (name === "contains") return 'The "contains" helper is removed; write "value" in fields.list or contains(fields.list, "value").';
+    return 'The "default" helper is removed; use coalesce(fields.value, "fallback").';
+  }
+  if (/^(signature|initials|signatureDate|capacity|printedName)\s+["']/.test(text)) {
+    const name = text.split(/\s/)[0];
+    return `Write ${name}("location") inside a party loop, or ${name}(parties.role, "location").`;
+  }
+  if (/^INS\s/.test(text)) return "The INS form is removed; write the expression alone, such as {{fields.name}}.";
+  if (text.startsWith("&")) return "The {{& }} form is removed; use {{{ }}} to print without HTML escaping.";
+  if (/===|!==/.test(text)) return "The === and !== operators are removed; use == and !=.";
+  if (/(^|[^\w.])this\b/.test(text)) return '"this" is removed; use item inside a loop, or a full path such as fields.name.';
+  if (text.includes("../")) return '"../" is removed; use parent inside a nested loop, or a full path from the root.';
+  if (/@root\b/.test(text)) return '"@root" is removed; write the path from the root, such as fields.name.';
+  if (/@index\b/.test(text)) return '"@index" is removed; use index(item) inside a loop.';
+  if (/@first\b/.test(text)) return '"@first" is removed; use first(item) inside a loop.';
+  if (/@last\b/.test(text)) return '"@last" is removed; use last(item) inside a loop.';
+  if (/@key\b/.test(text)) return '"@key" is removed; a loop runs over a list.';
+  if (/(^|[^\w])\$[A-Za-z_]/.test(text)) return "The $name form is removed; a DOCX loop names its row, such as {{FOR line IN fields.items}} and then {{line.amount}}.";
+  if (/\.\[\d+\]/.test(text)) return "The .[n] segment is removed; index a list with [n], such as parties.preparer[0].";
+  return void 0;
+}
+
+// src/docx/render.ts
+import { defaultFormatter } from "@asterdoc/format";
+import { unzipSync, zipSync } from "fflate";
+
+// src/template/markers.ts
+import { parse } from "@asterdoc/expr";
+function positionFinder(source, base = { line: 1, column: 1 }) {
+  const lineStarts = [0];
+  for (let index = 0; index < source.length; index++) if (source[index] === "\n") lineStarts.push(index + 1);
+  return (offset) => {
+    let line = 0;
+    while (line + 1 < lineStarts.length && lineStarts[line + 1] <= offset) line++;
+    const column = offset - lineStarts[line] + 1;
+    return line === 0 ? { line: base.line, column: base.column + column - 1 } : { line: base.line + line, column };
+  };
+}
+function expressionSlot(source, position) {
+  const trimmed = source.trim();
+  if (trimmed === "") {
+    return { source: trimmed, position, problem: { code: "syntax", message: "The marker holds no expression.", expression: trimmed, position } };
+  }
+  const { ast, errors } = parse(trimmed);
+  if (ast) return { source: trimmed, ast, position };
+  const hint = removedSyntaxHint(trimmed);
+  return {
+    source: trimmed,
+    position,
+    problem: {
+      code: hint ? "removed-syntax" : "syntax",
+      message: hint ?? errors[0]?.message ?? "The expression does not parse.",
+      expression: trimmed,
+      position
+    }
+  };
+}
+var TAG = /\{\{\{[\s\S]*?\}\}\}|\{\{[\s\S]*?\}\}/g;
+function parseTemplate(template, base) {
+  const positionAt = positionFinder(template, base);
+  const root = [];
+  const stack = [];
+  let output = root;
+  let cursor = 0;
+  let skipLineBreak = false;
+  const fail2 = (message, offset) => {
+    throw new TemplateError({ code: "markers", message, position: positionAt(offset) });
+  };
+  const standalone = (start, end) => {
+    const lineStart = template.lastIndexOf("\n", start - 1) + 1;
+    const lineEndIndex = template.indexOf("\n", end);
+    const lineEnd = lineEndIndex === -1 ? template.length : lineEndIndex;
+    return /^[\t ]*$/.test(template.slice(lineStart, start)) && /^[\t \r]*$/.test(template.slice(end, lineEnd));
+  };
+  const pushText = (value) => {
+    let text = value;
+    if (skipLineBreak) {
+      text = text.replace(/^[\t ]*\r?\n?/, "");
+      skipLineBreak = false;
+    }
+    if (text.length > 0) output.push({ type: "text", value: text });
+  };
+  const trimLineBefore = () => {
+    const last = output.at(-1);
+    if (last?.type !== "text") return;
+    last.value = last.value.replace(/[\t ]*$/, "");
+    if (last.value.length === 0) output.pop();
+  };
+  for (const match of template.matchAll(TAG)) {
+    const index = match.index ?? 0;
+    const token = match[0];
+    const end = index + token.length;
+    if (index > cursor) pushText(template.slice(cursor, index));
+    else if (skipLineBreak) skipLineBreak = false;
+    cursor = end;
+    const triple = token.startsWith("{{{");
+    const inner = token.slice(triple ? 3 : 2, triple ? -3 : -2);
+    const innerOffset = index + (triple ? 3 : 2) + (inner.length - inner.trimStart().length);
+    const content = inner.trim();
+    if (!triple && content.startsWith("!")) continue;
+    const isBlockTag = !triple && (content.startsWith("#") || content.startsWith("/") || content === "else");
+    if (isBlockTag && standalone(index, end)) {
+      trimLineBefore();
+      skipLineBreak = true;
+    }
+    if (!triple && content.startsWith("#")) {
+      const body = content.slice(1);
+      const name = body.match(/^\S*/)?.[0] ?? "";
+      const expression = body.slice(name.length);
+      if (name === "with") fail2("{{#with}} is removed; write full paths, such as parties.tenant.name.", index);
+      if (name !== "if" && name !== "unless" && name !== "each") fail2(`Unsupported block {{#${name}}}; use {{#if}}, {{#unless}}, or {{#each}}.`, index);
+      const expressionOffset = innerOffset + 1 + name.length + (expression.length - expression.trimStart().length);
+      const block = {
+        type: name,
+        slot: expressionSlot(expression, positionAt(expressionOffset)),
+        children: [],
+        inverse: []
+      };
+      output.push(block);
+      stack.push({ block, output, tag: name, position: positionAt(index) });
+      output = block.children;
+      continue;
+    }
+    if (!triple && content === "else") {
+      const current = stack.at(-1);
+      if (!current) fail2("Unexpected {{else}}", index);
+      if (output === current.block.inverse) fail2("A block has more than one {{else}}", index);
+      output = current.block.inverse;
+      continue;
+    }
+    if (!triple && content.startsWith("/")) {
+      const name = content.slice(1).trim();
+      const current = stack.pop();
+      if (!current || current.tag !== name) fail2(`Unexpected closing block {{/${name}}}`, index);
+      output = current.output;
+      continue;
+    }
+    output.push({ type: "value", slot: expressionSlot(inner, positionAt(innerOffset)), escaped: !triple });
+  }
+  if (cursor < template.length) pushText(template.slice(cursor));
+  const open = stack.at(-1);
+  if (open) throw new TemplateError({ code: "markers", message: `Unclosed block {{#${open.tag}}}`, position: open.position });
+  return root;
+}
+
+// src/template/scope.ts
+import {
+  buildRegistry,
+  EvaluationError,
+  evaluate,
+  T,
+  truthy,
+  Values
+} from "@asterdoc/expr";
+var DEFAULT_REGISTRY = buildRegistry();
+var LOOP_FUNCTIONS = [
+  { name: "index", category: "collection", params: [{ name: "row", type: T.unknown }], returns: { kind: "fixed", type: T.number }, hostInjected: true, deterministic: true },
+  { name: "first", category: "collection", params: [{ name: "row", type: T.unknown }], returns: { kind: "fixed", type: T.boolean }, hostInjected: true, deterministic: true },
+  { name: "last", category: "collection", params: [{ name: "row", type: T.unknown }], returns: { kind: "fixed", type: T.boolean }, hostInjected: true, deterministic: true }
+];
+var LOOP_FUNCTION_NAMES = new Set(LOOP_FUNCTIONS.map((signature) => signature.name));
+function withLoopFunctions(base) {
+  const registry = base ?? DEFAULT_REGISTRY;
+  const signatures = new Map(registry.signatures);
+  for (const signature of LOOP_FUNCTIONS) signatures.set(signature.name, signature);
+  return {
+    signatures,
+    has: (name) => signatures.has(name),
+    get: (name) => signatures.get(name),
+    names: () => [...signatures.keys()]
+  };
+}
+function referenceSegments(node) {
+  if (node.kind === "Identifier") return [node.name];
+  if (node.kind === "Member") {
+    const base = referenceSegments(node.object);
+    return base ? [...base, node.property] : void 0;
+  }
+  if (node.kind === "Index" && (node.index.kind === "NumberLiteral" && /^\d+$/.test(node.index.value) || node.index.kind === "StringLiteral")) {
+    const base = referenceSegments(node.object);
+    return base ? [...base, node.index.value] : void 0;
+  }
+  return void 0;
+}
+var blocked = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function dataPath(value, segments) {
+  let current = value;
+  for (const [index, segment] of segments.entries()) {
+    current = unwrapFormattedValue(current);
+    if (blocked.has(segment) || current === null || current === void 0) return void 0;
+    if (typeof current !== "object") return void 0;
+    current = current[segment];
+    if (index === segments.length - 1) return current;
+  }
+  return current;
+}
+function fromValue(value) {
+  switch (value.kind) {
+    case "number":
+      return value.value.toNumber();
+    case "string":
+    case "boolean":
+      return value.value;
+    case "null":
+      return null;
+    case "array":
+      return value.value.map(fromValue);
+    case "object":
+      return Object.fromEntries([...value.value].map(([key, member]) => [key, fromValue(member)]));
+  }
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !(value instanceof FormattedFieldValue);
+}
+function frameFor(frames, name) {
+  let rows = 0;
+  for (let index = frames.length - 1; index >= 0; index--) {
+    const frame = frames[index];
+    if (frame.kind === "named") {
+      if (frame.name === name) return frame;
+      continue;
+    }
+    rows++;
+    if (name === "item" && rows === 1 || name === "parent" && rows === 2) return frame;
+  }
+  return void 0;
+}
+var TemplateScope = class _TemplateScope {
+  constructor(root, environment, frames = []) {
+    this.root = root;
+    this.environment = environment;
+    this.frames = frames;
+  }
+  root;
+  environment;
+  frames;
+  push(frame) {
+    return new _TemplateScope(this.root, this.environment, [...this.frames, frame]);
+  }
+  /** The innermost row, whatever binds it. */
+  current() {
+    return this.frames.at(-1);
+  }
+  frameFor(name) {
+    return frameFor(this.frames, name);
+  }
+  context() {
+    if (this.frames.length === 0) return this.root;
+    const rowFunction = (answer) => (args) => {
+      const frame = this.frames.find((candidate) => candidate.value === args[0]);
+      if (!frame) throw new EvaluationError("type-error", "index, first, and last take a loop row, such as item");
+      return answer(frame);
+    };
+    const rowVisible = this.root.rowVisible;
+    return {
+      lookup: (name) => this.frameFor(name)?.value ?? this.root.lookup(name),
+      asOf: this.root.asOf,
+      registry: withLoopFunctions(this.root.registry),
+      hostFunctions: {
+        ...this.root.hostFunctions,
+        index: rowFunction((frame) => Values.num(String(frame.index))),
+        first: rowFunction((frame) => Values.boolean(frame.index === 0)),
+        last: rowFunction((frame) => Values.boolean(frame.index === frame.count - 1))
+      },
+      rowVisible: rowVisible && ((listPath, indices) => {
+        const [head, ...rest] = listPath.split(".");
+        const frame = head ? this.frameFor(head) : void 0;
+        if (!frame) return rowVisible(listPath, indices);
+        if (!frame.origin) return true;
+        return rowVisible([frame.origin.listPath, ...rest].join("."), [...frame.origin.indices, ...indices]);
+      })
+    };
+  }
+  evaluate(node, source, position) {
+    try {
+      return evaluate(node, this.context());
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const code = error instanceof EvaluationError ? error.code : "evaluation-error";
+      throw new TemplateError({ code, message, expression: source, position }, this.environment.layer);
+    }
+  }
+  /** The render data an expression reads, when it is a path into it. */
+  dataAt(node) {
+    const segments = referenceSegments(node);
+    if (!segments) return void 0;
+    const [head, ...rest] = segments;
+    const frame = head ? this.frameFor(head) : void 0;
+    if (frame) return rest.length === 0 ? frame.data : dataPath(frame.data, rest);
+    return this.environment.resolveData(segments);
+  }
+  /** Where the rows of a list path sit in the artifact, when the list is a path it declares. */
+  originOf(node) {
+    const segments = referenceSegments(node);
+    if (!segments) return void 0;
+    const [head, ...rest] = segments;
+    const frame = head ? this.frameFor(head) : void 0;
+    if (frame) {
+      return frame.origin ? { listPath: [frame.origin.listPath, ...rest].join("."), indices: frame.origin.indices } : void 0;
+    }
+    return head === "fields" ? { listPath: segments.join("."), indices: [] } : void 0;
+  }
+  /**
+   * The text a placeholder prints. A path prints the value the way the
+   * artifact formats it; a computed value is formatted by its type.
+   */
+  present(node, source, position) {
+    if (node.kind === "Conditional") {
+      const test = this.evaluate(node.test, source, position);
+      return this.present(truthy(test) ? node.consequent : node.alternate, source, position);
+    }
+    if (node.kind === "Call" && node.callee === "coalesce") {
+      for (const arg of node.args) {
+        if (this.evaluate(arg, source, position).kind !== "null") return this.present(arg, source, position);
+      }
+      return "";
+    }
+    if (referenceSegments(node)) {
+      const data = this.dataAt(node);
+      if (data !== void 0 && !isPlainRecord(data) && !Array.isArray(data)) {
+        return data === null ? "" : String(data);
+      }
+      if (data instanceof FormattedFieldValue) return String(data);
+    }
+    return this.formatValue(this.evaluate(node, source, position), node);
+  }
+  formatValue(value, node) {
+    const { formatter } = this.environment;
+    switch (value.kind) {
+      case "null":
+        return "";
+      case "boolean":
+        return formatter.formatBoolean(value.value);
+      case "number":
+        return formatter.formatNumber(value.value.toNumber());
+      case "string": {
+        const signature = node.kind === "Call" ? (this.root.registry ?? DEFAULT_REGISTRY).get(node.callee) : void 0;
+        const returns = signature?.returns.kind === "fixed" ? signature.returns.type.kind : void 0;
+        if (returns === "date") return formatter.formatDate(value.value);
+        if (returns === "datetime") return formatter.formatDatetime(value.value);
+        return value.value;
+      }
+      case "array":
+        return value.value.map((element) => this.formatValue(element, node)).join(", ");
+      case "object": {
+        const amount = value.value.get("amount");
+        const currency = value.value.get("currency");
+        if (amount?.kind === "number" && currency?.kind === "string") {
+          return formatter.formatMoney({ amount: amount.value.toNumber(), currency: currency.value });
+        }
+        return "";
+      }
+    }
+  }
+};
+
+// src/text/template.ts
+var Markup = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+  toString() {
+    return this.value;
+  }
+};
+var SIGNING_DIRECTIVES = /* @__PURE__ */ new Set(["signature", "initials", "signatureDate", "capacity", "printedName"]);
+function fail(slot, message, code, layer) {
+  throw new TemplateError({ code, message, expression: slot.source, position: slot.position }, layer);
+}
+function parsed(slot, layer) {
+  if (slot.ast) return slot.ast;
+  throw new TemplateError(slot.problem, layer);
+}
+function condition(value, slot, layer) {
+  if (value.kind === "boolean") return value.value;
+  if (value.kind === "null") return false;
+  return fail(slot, `A condition must be boolean, got ${value.kind}.`, "non-boolean-gate", layer);
+}
+function loopRows(value, slot, layer) {
+  if (value.kind === "array") return value.value;
+  if (value.kind === "null") return [];
+  return fail(slot, `A loop source must be a list, got ${value.kind}.`, "type-mismatch", layer);
+}
+function loopFrames(scope, node, rows, bind) {
+  const data = unwrapFormattedValue(scope.dataAt(node));
+  const origin = scope.originOf(node);
+  return rows.map((value, index) => ({
+    ...bind,
+    value,
+    data: Array.isArray(data) ? data[index] : void 0,
+    index,
+    count: rows.length,
+    origin: origin ? { listPath: origin.listPath, indices: [...origin.indices, index] } : void 0
+  }));
+}
+function renderDirective(node, slot, scope, options) {
+  const directive = options.directives?.[node.callee];
+  if (!directive) return fail(slot, `${node.callee}() is not available in this layer.`, "unknown-function", options.layer);
+  if (node.args.length < 1 || node.args.length > 2) {
+    return fail(slot, `${node.callee} takes a location, or a party and a location, such as ${node.callee}(parties.tenant, "tenant-sign").`, "arity", options.layer);
+  }
+  const locationNode = node.args.at(-1);
+  const location = scope.evaluate(locationNode, slot.source, slot.position);
+  if (location.kind !== "string") return fail(slot, `${node.callee}'s location must be a string.`, "type-mismatch", options.layer);
+  let party;
+  if (node.args.length === 2) {
+    const partyNode = node.args[0];
+    const data = scope.dataAt(partyNode);
+    party = data === void 0 ? fromValue(scope.evaluate(partyNode, slot.source, slot.position)) : unwrapFormattedValue(data);
+  } else {
+    const row = scope.current();
+    if (!row) return fail(slot, `${node.callee}("${location.value}") needs a party: use it inside a party loop, or pass the party first, such as ${node.callee}(parties.tenant, "${location.value}").`, "arity", options.layer);
+    party = row.data === void 0 ? fromValue(row.value) : unwrapFormattedValue(row.data);
+  }
+  const result = directive(party, options.root, [location.value]);
+  if (result instanceof Markup) return result;
+  return result === null || result === void 0 ? "" : String(result);
+}
+function renderTemplateNodes(nodes, scope, options) {
+  const { escape } = options;
+  let result = "";
+  for (const node of nodes) {
+    if (node.type === "text") {
+      result += node.value;
+      continue;
+    }
+    const expression = parsed(node.slot, options.layer);
+    if (node.type === "value") {
+      const text = expression.kind === "Call" && SIGNING_DIRECTIVES.has(expression.callee) ? renderDirective(expression, node.slot, scope, options) : scope.present(expression, node.slot.source, node.slot.position);
+      result += text instanceof Markup ? text.value : node.escaped ? escape(text) : text;
+      continue;
+    }
+    const value = scope.evaluate(expression, node.slot.source, node.slot.position);
+    if (node.type === "if" || node.type === "unless") {
+      const answer = condition(value, node.slot, options.layer);
+      const include = node.type === "if" ? answer : !answer;
+      result += renderTemplateNodes(include ? node.children : node.inverse, scope, options);
+      continue;
+    }
+    const rows = loopRows(value, node.slot, options.layer);
+    if (rows.length === 0) {
+      result += renderTemplateNodes(node.inverse, scope, options);
+      continue;
+    }
+    for (const frame of loopFrames(scope, expression, rows, { kind: "each" })) {
+      result += renderTemplateNodes(node.children, scope.push(frame), options);
+    }
+  }
+  return result;
+}
+function escapeHtml(value) {
+  return value.replace(/[&<>"'`=]/g, (char) => ({
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#x27;",
+    "`": "&#x60;",
+    "=": "&#x3D;"
+  })[char]);
+}
+function renderTemplate(template, options) {
+  const scope = new TemplateScope(options.context, {
+    formatter: options.formatter,
+    resolveData: options.resolveData,
+    layer: options.layer
+  });
+  try {
+    return renderTemplateNodes(parseTemplate(template), scope, options);
+  } catch (error) {
+    throw error instanceof TemplateError ? error.inLayer(options.layer) : error;
+  }
+}
+
+// src/template/context.ts
+import {
+  buildRegistry as buildRegistry2,
+  createContext
+} from "@asterdoc/expr";
+function requestExpressions(configured, supplied) {
+  return {
+    ...configured,
+    ...supplied && { context: supplied.context }
+  };
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function templateRoots(raw, form) {
+  const nestedFields = record(raw.fields);
+  const fields = nestedFields ? { ...nestedFields } : {};
+  const items = form?.fields ? void 0 : record(raw.items);
+  const fieldIds = nestedFields ? [] : form?.fields ? Object.keys(form.fields) : Object.keys(raw).filter((key) => !RENDER_DATA_ROOTS.has(key) && !(key === "items" && items));
+  for (const id of fieldIds) if (Object.prototype.hasOwnProperty.call(raw, id)) fields[id] = raw[id];
+  const roots = { fields };
+  const parties = record(raw.parties);
+  if (parties) roots.parties = parties;
+  if (items) roots.items = items;
+  const defs = record(raw.defs);
+  if (defs) for (const [key, value] of Object.entries(defs)) roots[key] = value;
+  return roots;
+}
+function withConfiguredFunctions(context, expressions) {
+  if (!expressions.functions && !expressions.signatures) return context;
+  const configured = buildRegistry2(expressions.signatures ?? []);
+  const signatures = new Map(configured.signatures);
+  for (const [name, signature] of context.registry?.signatures ?? []) signatures.set(name, signature);
+  const registry = {
+    signatures,
+    has: (name) => signatures.has(name),
+    get: (name) => signatures.get(name),
+    names: () => [...signatures.keys()]
+  };
+  return { ...context, registry, hostFunctions: { ...expressions.functions, ...context.hostFunctions } };
+}
+function templateData(raw, prepared, form, expressions) {
+  const context = expressions?.context ? withConfiguredFunctions(expressions.context, expressions) : createContext(templateRoots(raw, form), {
+    hostFunctions: expressions?.functions,
+    registry: expressions?.signatures ? buildRegistry2(expressions.signatures) : void 0
+  });
+  const defs = record(prepared.defs);
+  return {
+    context,
+    resolveData(segments) {
+      const [head, ...rest] = segments;
+      if (head === void 0) return void 0;
+      if (head === "fields") {
+        if (rest.length === 0) return void 0;
+        return dataPath(record(prepared.fields) ?? prepared, rest);
+      }
+      if (head === "parties" || head === "annexes" || head === "items") return dataPath(prepared[head], rest);
+      if (defs && Object.prototype.hasOwnProperty.call(defs, head)) return dataPath(defs[head], rest);
+      return void 0;
+    }
+  };
+}
+
+// src/text/signatures.ts
+var defaults = {
+  signature: "[SIGNATURE]",
+  initials: "[INITIALS]",
+  date: "[DATE]",
+  capacity: "[CAPACITY]",
+  printedName: "[PRINTED NAME]",
+  capturedSignature: "[Signed]",
+  capturedInitials: "[Initialed]"
+};
+function resolveValue(value, context, fallback) {
+  return value === void 0 ? fallback : typeof value === "function" ? value(context) : value;
+}
+function isRenderParty(value) {
+  return typeof value._role === "string" && typeof value.id === "string";
+}
+var ORGANIZATION_KEYS = ["legalName", "domicile", "entityType", "entityId", "taxId"];
+function selfSignerId(party) {
+  return ORGANIZATION_KEYS.some((key) => key in party) ? "" : party.id;
+}
+function resolveContext(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const context = value;
+  if (typeof context._role === "string" && typeof context._partyId === "string" && typeof context.signerId === "string") {
+    return {
+      role: context._role,
+      partyId: context._partyId,
+      signerId: context.signerId,
+      signer: context.signer,
+      capacity: context.capacity
+    };
+  }
+  if (isRenderParty(context) && !context.signerId) {
+    const signatory = Array.isArray(context.signatories) ? context.signatories[0] : void 0;
+    return {
+      role: context._role,
+      partyId: context.id,
+      signerId: typeof signatory?.signerId === "string" ? signatory.signerId : selfSignerId(context),
+      party: context,
+      signer: signatory?.signer,
+      capacity: signatory?.capacity
+    };
+  }
+  return void 0;
+}
+function captureFor(root, context, locationId, type) {
+  if (!Array.isArray(root._captures)) return void 0;
+  return root._captures.find(
+    (capture) => capture.role === context.role && capture.partyId === context.partyId && capture.signerId === context.signerId && capture.locationId === locationId && capture.type === type
+  );
+}
+function signerFor(root, context) {
+  if (context.signer) return context.signer;
+  return root._signers && typeof root._signers === "object" ? root._signers[context.signerId] : void 0;
+}
+function placeholderContext(root, context, locationId) {
+  return {
+    role: context.role,
+    partyId: context.partyId,
+    signerId: context.signerId,
+    locationId,
+    party: context.party,
+    signer: signerFor(root, context),
+    capacity: context.capacity
+  };
+}
+function markAttributes(context, locationId) {
+  return `data-role="${escapeHtml(context.role)}" data-party-id="${escapeHtml(context.partyId)}" data-signer-id="${escapeHtml(context.signerId)}" data-location-id="${escapeHtml(locationId)}"`;
+}
+function markdownAlt(value) {
+  return value.replace(/[\\[\]]/g, (char) => `\\${char}`);
+}
+function markdownDestination(value) {
+  return value.replace(/[\s()<>\\]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`);
+}
+function contextError(name) {
+  return `[${name} error: no party. Use it inside a party or signatories loop, or pass the party first.]`;
+}
+function renderMark(type, capture, context, options, signatureDefaults) {
+  const captured = capture !== void 0;
+  const capturedOption = type === "signature" ? options.captured?.signature : options.captured?.initials;
+  const placeholderOption = type === "signature" ? options.placeholder?.signature : options.placeholder?.initials;
+  const capturedDefault = type === "signature" ? signatureDefaults.capturedSignature : signatureDefaults.capturedInitials;
+  const placeholderDefault = type === "signature" ? signatureDefaults.signature : signatureDefaults.initials;
+  const capturedContext = capture ? { ...context, capture } : void 0;
+  if (options.format === "html") {
+    const adopted = type === "signature" ? context.signer?.adopted?.signature : context.signer?.adopted?.initials;
+    const image = capture?.image ?? adopted?.image;
+    const attributes = markAttributes(context, context.locationId);
+    if (captured && image) {
+      const alt = options.altText ?? (type === "signature" ? "Signature" : "Initials");
+      const cssClass = options.cssClass ?? `${type}-image`;
+      return new Markup(`<img src="${escapeHtml(image)}" alt="${escapeHtml(alt)}" class="${escapeHtml(cssClass)}" ${attributes} />`);
+    }
+    const text = capturedContext ? resolveValue(capturedOption, capturedContext, capturedDefault) : resolveValue(placeholderOption, context, placeholderDefault);
+    return new Markup(`<span class="${type}-${captured ? "captured" : "placeholder"}" ${attributes}>${text}</span>`);
+  }
+  if (options.format === "markdown") {
+    const adopted = type === "signature" ? context.signer?.adopted?.signature : context.signer?.adopted?.initials;
+    const image = capture?.image ?? adopted?.image;
+    if (captured && image) {
+      const alt = options.altText ?? (type === "signature" ? "Signature" : "Initials");
+      return `![${markdownAlt(alt)}](${markdownDestination(image)})`;
+    }
+    const text = capturedContext ? resolveValue(capturedOption, capturedContext, capturedDefault) : resolveValue(placeholderOption, context, placeholderDefault);
+    return `_${text}_`;
+  }
+  return capturedContext ? resolveValue(capturedOption, capturedContext, capturedDefault) : resolveValue(placeholderOption, context, placeholderDefault);
+}
+function createMarkDirective(type, options, signatureDefaults) {
+  return (value, root, args) => {
+    const context = resolveContext(value);
+    if (!context) return contextError(type === "signature" ? "Signature" : "Initials");
+    const locationId = args[0];
+    const capture = context.signerId ? captureFor(root, context, locationId, type) : void 0;
+    return renderMark(type, capture, placeholderContext(root, context, locationId), options, signatureDefaults);
+  };
+}
+function createDateDirective(options, signatureDefaults) {
+  return (value, root, args) => {
+    const context = resolveContext(value);
+    if (!context) return contextError("SignatureDate");
+    const locationId = args[0];
+    const placeholder = placeholderContext(root, context, locationId);
+    const capture = context.signerId ? captureFor(root, context, locationId, "signature") : void 0;
+    if (!capture) {
+      const text2 = resolveValue(options.placeholder?.signatureDate, placeholder, signatureDefaults.date);
+      if (options.format !== "html") return text2;
+      return new Markup(`<span class="signature-date-placeholder" ${markAttributes(context, locationId)}>${text2}</span>`);
+    }
+    const captured = { ...placeholder, capture };
+    const date = capture.timestamp ? capture.timestamp.slice(0, 10) : signatureDefaults.date;
+    const text = resolveValue(options.captured?.signatureDate, captured, date);
+    if (options.format !== "html" || options.captured?.signatureDate !== void 0) return text;
+    return new Markup(`<span class="signature-date" ${markAttributes(context, locationId)}>${escapeHtml(text)}</span>`);
+  };
+}
+function createCapacityDirective(options, signatureDefaults) {
+  return (value, root, args) => {
+    const context = resolveContext(value);
+    if (!context) return contextError("Capacity");
+    const locationId = args[0];
+    const placeholder = placeholderContext(root, context, locationId);
+    const capture = context.signerId ? captureFor(root, context, locationId, "capacity") : void 0;
+    if (capture) {
+      const fallback = capture.text ?? context.capacity ?? signatureDefaults.capacity;
+      return resolveValue(options.captured?.capacity, { ...placeholder, capture }, fallback);
+    }
+    return context.capacity ?? resolveValue(options.placeholder?.capacity, placeholder, signatureDefaults.capacity);
+  };
+}
+function createPrintedNameDirective(options, signatureDefaults) {
+  return (value, root, args) => {
+    const context = resolveContext(value);
+    if (!context) return contextError("PrintedName");
+    const locationId = args[0];
+    const placeholder = placeholderContext(root, context, locationId);
+    const capture = context.signerId ? captureFor(root, context, locationId, "printed_name") : void 0;
+    if (capture) {
+      const fallback = capture.text ?? placeholder.signer?.person.name ?? signatureDefaults.printedName;
+      return resolveValue(options.captured?.printedName, { ...placeholder, capture }, fallback);
+    }
+    return placeholder.signer?.person.name ?? resolveValue(options.placeholder?.printedName, placeholder, signatureDefaults.printedName);
+  };
+}
+function createSignatureDirectives(options = {}, signatureDefaults = defaults) {
+  return {
+    signature: createMarkDirective("signature", options, signatureDefaults),
+    initials: createMarkDirective("initials", options, signatureDefaults),
+    signatureDate: createDateDirective(options, signatureDefaults),
+    capacity: createCapacityDirective(options, signatureDefaults),
+    printedName: createPrintedNameDirective(options, signatureDefaults)
+  };
+}
+function formatFor(mimeType) {
+  const type = mimeType?.toLowerCase();
+  return type === "text/html" ? "html" : type === "text/markdown" ? "markdown" : "text";
+}
+function createTextSignatureDirectives(options = {}, mimeType) {
+  return createSignatureDirectives({ ...options, format: options.format ?? formatFor(mimeType) });
+}
+
+// src/docx/signatures.ts
+var docxDefaults = {
+  signature: "_____________________________",
+  initials: "______",
+  date: "__________",
+  capacity: "________________",
+  printedName: "_______________________",
+  capturedSignature: "[Signed]",
+  capturedInitials: "[Initialed]"
+};
+function createDocxSignatureDirectives(options = {}) {
+  return createSignatureDirectives(options, docxDefaults);
+}
+
+// src/docx/render.ts
+var textDecoder = new TextDecoder();
+var textEncoder = new TextEncoder();
+function decodeXml(value) {
+  return value.replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCodePoint(Number.parseInt(code, 16))).replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code))).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+function encodeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function regexEscape(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeDelimiters(value, delimiters) {
+  if (delimiters[0] === "{{" && delimiters[1] === "}}") return value;
+  return value.replace(new RegExp(regexEscape(delimiters[0]), "g"), "{{").replace(new RegExp(regexEscape(delimiters[1]), "g"), "}}");
+}
+function paragraphText(paragraph) {
+  return [...paragraph.matchAll(/<w:t\b[^>]*>([\s\S]*?)<\/w:t>/g)].map((match) => decodeXml(match[1] ?? "")).join("");
+}
+function visibleParagraph(paragraph) {
+  return paragraphText(paragraph).trim();
+}
+function commandIn(paragraph, delimiters) {
+  const value = visibleParagraph(paragraph);
+  if (!value.startsWith(delimiters[0]) || !value.endsWith(delimiters[1])) return void 0;
+  return value.slice(delimiters[0].length, -delimiters[1].length).trim();
+}
+function controlsIn(xml, delimiters) {
+  const rows = [...xml.matchAll(/<w:tr\b[^>]*>[\s\S]*?<\/w:tr>/g)].map((match) => ({
+    start: match.index ?? 0,
+    end: (match.index ?? 0) + match[0].length,
+    value: visibleParagraph(match[0])
+  }));
+  return [...xml.matchAll(/<w:p\b[^>]*>[\s\S]*?<\/w:p>/g)].map((match) => {
+    const start = match.index ?? 0;
+    const end = start + match[0].length;
+    const command = commandIn(match[0], delimiters);
+    const marker = command === void 0 ? void 0 : `${delimiters[0]}${command}${delimiters[1]}`;
+    const row = marker === void 0 ? void 0 : rows.find((candidate) => candidate.start <= start && candidate.end >= end && candidate.value === marker);
+    return { command, start: row?.start ?? start, end: row?.end ?? end };
+  }).filter((item) => item.command !== void 0);
+}
+function normalizeInlineControls(xml, delimiters) {
+  const paragraphPattern = /<w:p\b[^>]*>[\s\S]*?<\/w:p>/g;
+  const [open, close] = delimiters.map(regexEscape);
+  const command = (body) => `${open}\\s*(?:${body})(?:(?!${close})[\\s\\S])*?${close}`;
+  const inlinePattern = new RegExp(`^\\s*${command("(?:FOR|IF)\\s")}[\\s\\S]*${command("END-(?:FOR|IF)")}\\s*$`);
+  const anyCommand = new RegExp(`(${command("(?:FOR|IF)\\s|ELSE\\s*(?=" + close + ")|END-(?:FOR|IF)")})`);
+  return xml.replace(paragraphPattern, (paragraph) => {
+    const text = paragraphText(paragraph);
+    if (!inlinePattern.test(text)) return paragraph;
+    const opening = paragraph.match(/^<w:p\b[^>]*>/)?.[0] ?? "<w:p>";
+    const properties = paragraph.match(/<w:pPr\b[\s\S]*?<\/w:pPr>/)?.[0] ?? "";
+    const makeParagraph = (text2) => {
+      const content = text2.length > 0 ? `<w:r><w:t xml:space="preserve">${encodeXml(text2)}</w:t></w:r>` : "";
+      return `${opening}${properties}${content}</w:p>`;
+    };
+    return text.split(anyCommand).filter((piece) => piece.length > 0).map(makeParagraph).join("");
+  });
+}
+var OPENING = /^(?:FOR\s+\S+\s+IN\s+.+|IF\s+.+)$/;
+var CLOSING = /^END-(?:FOR|IF)(?:\s+\S+)?$/;
+function docxControlProblems(commands) {
+  const problems = [];
+  const open = [];
+  commands.forEach((command, index) => {
+    if (command === void 0) return;
+    if (OPENING.test(command)) {
+      const kind = command.startsWith("FOR ") ? "FOR" : "IF";
+      open.push({ index, command, kind, alias: kind === "FOR" ? command.split(/\s+/)[1] : void 0, hasElse: false });
+      return;
+    }
+    if (CLOSING.test(command)) {
+      const [closer, alias] = command.split(/\s+/);
+      const block = open.pop();
+      if (!block) problems.push({ index, message: `Unexpected ${command}: no block is open.` });
+      else if (closer !== `END-${block.kind}`) problems.push({ index, message: `${command} cannot close ${block.command}; write END-${block.kind}.` });
+      else if (alias !== void 0 && alias !== block.alias) problems.push({ index, message: `${command} cannot close ${block.command}; write END-FOR ${block.alias}.` });
+      return;
+    }
+    if (command === "ELSE") {
+      const block = open.at(-1);
+      if (block?.kind !== "IF") problems.push({ index, message: "ELSE belongs inside an IF block." });
+      else if (block.hasElse) problems.push({ index, message: `${block.command} has a second ELSE; an IF takes one.` });
+      else block.hasElse = true;
+    }
+  });
+  for (const block of open) problems.push({ index: block.index, message: `Unclosed DOCX control command: ${block.command}` });
+  return problems.sort((a, b) => a.index - b.index);
+}
+var PARAGRAPH_MARK = /<!--pdc:(\d+)-->/;
+function markParagraphs(xml) {
+  let count = 0;
+  return xml.replace(/<w:p\b[^>]*>/g, (open) => `${open}<!--pdc:${++count}-->`);
+}
+function unmarkParagraphs(xml) {
+  return xml.replace(/<!--pdc:\d+-->/g, "");
+}
+function locate(run, xml) {
+  const paragraph = xml.match(PARAGRAPH_MARK)?.[1];
+  return paragraph ? `${run.part} paragraph ${paragraph}` : run.part;
+}
+function located(run, xml, render) {
+  try {
+    return render();
+  } catch (error) {
+    if (!(error instanceof TemplateError) || error.location) throw error;
+    throw new TemplateError({ ...error.diagnostic, location: locate(run, xml) }, run.options.layer);
+  }
+}
+function expandControls(xml, run) {
+  const controls = controlsIn(xml, run.delimiters);
+  const openingIndex = controls.findIndex(({ command }) => OPENING.test(command));
+  if (openingIndex === -1) return renderLeafXml(xml, run);
+  const opening = controls[openingIndex];
+  const isFor = opening.command.startsWith("FOR ");
+  let depth = 1;
+  let closing;
+  let alternative;
+  for (const control of controls.slice(openingIndex + 1)) {
+    if (OPENING.test(control.command)) depth++;
+    else if (CLOSING.test(control.command)) {
+      depth--;
+      if (depth === 0) {
+        closing = control;
+        break;
+      }
+    } else if (control.command === "ELSE" && depth === 1) alternative = control;
+  }
+  const openingXml = xml.slice(opening.start, opening.end);
+  const before = xml.slice(0, opening.start);
+  const close = closing;
+  const truthyBody = xml.slice(opening.end, alternative?.start ?? close.start);
+  const falseBody = alternative ? xml.slice(alternative.end, close.start) : "";
+  const expanded = located(run, openingXml, () => {
+    if (isFor) {
+      const match = opening.command.match(/^FOR\s+(\S+)\s+IN\s+(.+)$/);
+      const alias = match[1];
+      const slot2 = expressionSlot(match[2], { line: 1, column: 1 });
+      if (!slot2.ast) throw new TemplateError(slot2.problem, run.options.layer);
+      const rows = loopRows(run.scope.evaluate(slot2.ast, slot2.source, slot2.position), slot2, run.options.layer);
+      return loopFrames(run.scope, slot2.ast, rows, { kind: "named", name: alias }).map((frame) => expandControls(truthyBody, { ...run, scope: run.scope.push(frame) })).join("");
+    }
+    const slot = expressionSlot(opening.command.slice(3), { line: 1, column: 1 });
+    if (!slot.ast) throw new TemplateError(slot.problem, run.options.layer);
+    const value = run.scope.evaluate(slot.ast, slot.source, slot.position);
+    if (value.kind !== "boolean" && value.kind !== "null") {
+      throw new TemplateError({ code: "non-boolean-gate", message: `A condition must be boolean, got ${value.kind}.`, expression: slot.source }, run.options.layer);
+    }
+    return expandControls(value.kind === "boolean" && value.value ? truthyBody : falseBody, run);
+  });
+  return `${renderLeafXml(before, run)}${expanded}${expandControls(xml.slice(close.end), run)}`;
+}
+function validateControls(xml, run) {
+  const controls = controlsIn(xml, run.delimiters);
+  const [problem] = docxControlProblems(controls.map(({ command }) => command));
+  if (!problem) return;
+  const control = controls[problem.index];
+  throw new TemplateError({ code: "markers", message: problem.message, location: locate(run, xml.slice(control.start, control.end)) }, run.options.layer);
+}
+function renderRunText(text, run) {
+  const nodes = parseTemplate(normalizeDelimiters(text, run.delimiters));
+  const rendered = encodeXml(renderTemplateNodes(nodes, run.scope, run.options));
+  return run.processLineBreaks ? rendered.replace(/\r?\n/g, '</w:t><w:br/><w:t xml:space="preserve">') : rendered;
+}
+function renderLeafXml(xml, run) {
+  const { delimiters } = run;
+  const textNode = /(<w:t\b[^>]*>)([\s\S]*?)(<\/w:t>)/g;
+  return xml.replace(/<w:p\b[^>]*>[\s\S]*?<\/w:p>/g, (paragraph) => located(run, paragraph, () => {
+    const nodes = [...paragraph.matchAll(textNode)];
+    const texts = nodes.map((match) => decodeXml(match[2] ?? ""));
+    const visible = texts.join("");
+    let offset = 0;
+    const boundaries = texts.slice(0, -1).map((text) => offset += text.length);
+    const commandPattern = new RegExp(`${regexEscape(delimiters[0])}[\\s\\S]*?${regexEscape(delimiters[1])}`, "g");
+    const hasSplitCommand = [...visible.matchAll(commandPattern)].some((match) => boundaries.some((boundary) => boundary > match.index && boundary < match.index + match[0].length));
+    if (!hasSplitCommand) {
+      return paragraph.replace(textNode, (_, open, content, close) => `${open}${renderRunText(decodeXml(content), run)}${close}`);
+    }
+    const replacement = renderRunText(visible, run);
+    let used = false;
+    return paragraph.replace(textNode, (_, open, _content, close) => {
+      if (used) return `${open}${close}`;
+      used = true;
+      return `${open}${replacement}${close}`;
+    });
+  }));
+}
+async function renderDocx({
+  template,
+  data,
+  form,
+  formatter = defaultFormatter,
+  signatureOptions,
+  options = {},
+  expressions,
+  layer
+}) {
+  const prepared = form ? formatFieldData(data, form, formatter) : data;
+  const { context, resolveData } = templateData(data, prepared, form, expressions);
+  const directives = createDocxSignatureDirectives(signatureOptions);
+  const templateOptions = {
+    context,
+    resolveData,
+    root: prepared,
+    formatter,
+    directives,
+    escape: (text) => text,
+    layer
+  };
+  const scope = new TemplateScope(context, { formatter, resolveData, layer });
+  const files = unzipSync(template);
+  const delimiters = options.cmdDelimiter ?? ["{{", "}}"];
+  const processLineBreaks = options.processLineBreaks ?? true;
+  for (const [name, bytes] of Object.entries(files)) {
+    if (!DOCX_TEMPLATE_PARTS.test(name)) continue;
+    const xml = markParagraphs(normalizeInlineControls(textDecoder.decode(bytes), delimiters));
+    const run = { scope, options: templateOptions, delimiters, processLineBreaks, part: name };
+    validateControls(xml, run);
+    files[name] = textEncoder.encode(unmarkParagraphs(expandControls(xml, run)));
+  }
+  return zipSync(files, { level: 6 });
+}
+var DOCX_TEMPLATE_PARTS = /^word\/(?:document|header\d*|footer\d*|footnotes|endnotes)\.xml$/;
+
+// src/template/check.ts
+import { unzipSync as unzipSync2 } from "fflate";
+import { checkAst, formatType, T as T2 } from "@asterdoc/expr";
+var CheckScope = class _CheckScope {
+  constructor(env, frames = []) {
+    this.env = env;
+    this.frames = frames;
+  }
+  env;
+  frames;
+  push(frame) {
+    return new _CheckScope(this.env, [...this.frames, frame]);
+  }
+  frameFor(name) {
+    return frameFor(this.frames, name);
+  }
+  typeEnv() {
+    if (this.frames.length === 0) return this.env;
+    return {
+      registry: withLoopFunctions(this.env.registry),
+      resolve: (path) => {
+        const [head, ...rest] = path.split(".");
+        const frame = head ? this.frameFor(head) : void 0;
+        if (!frame) return this.env.resolve(path);
+        if (rest.length === 0) return frame.element;
+        if (frame.sourcePath) return this.env.resolve([frame.sourcePath, ...rest].join("."));
+        return T2.unknown;
+      }
+    };
+  }
+  /** The environment path a list expression names, so its rows' members can be typed. */
+  sourcePath(node) {
+    const segments = referenceSegments(node);
+    if (!segments || segments.some((segment) => /^\d+$/.test(segment))) return void 0;
+    const [head, ...rest] = segments;
+    const frame = head ? this.frameFor(head) : void 0;
+    if (frame) return frame.sourcePath ? [frame.sourcePath, ...rest].join(".") : void 0;
+    return segments.join(".");
+  }
+};
+function at(slot, span) {
+  return span.start.line === 1 ? { line: slot.position.line, column: slot.position.column + span.start.column - 1 } : { line: slot.position.line + span.start.line - 1, column: span.start.column };
+}
+function diagnosticsFor(slot, node, scope) {
+  const result = checkAst(node, scope.typeEnv());
+  const diagnostics = result.diagnostics.map((diagnostic) => {
+    let message = diagnostic.message;
+    const unknown = diagnostic.name;
+    if (diagnostic.code === "unknown-function" && unknown && LOOP_FUNCTION_NAMES.has(unknown)) {
+      message = `${unknown}() is valid only inside a loop.`;
+    } else if (diagnostic.code === "unknown-identifier" && (unknown === "item" || unknown === "parent")) {
+      message = unknown === "item" ? "item is valid only inside a loop." : "parent is valid only inside a nested loop.";
+    } else if (diagnostic.code === "unknown-identifier" && unknown?.split(".")[0] === "this") {
+      message = removedSyntaxHint("this");
+    }
+    return { code: diagnostic.code, message, expression: slot.source, position: at(slot, diagnostic.span) };
+  });
+  diagnostics.push(...loopFunctionMisuse(slot, node, scope));
+  return { type: result.type, diagnostics };
+}
+function loopFunctionMisuse(slot, node, scope) {
+  const found = [];
+  const visit = (current) => {
+    if (current.kind === "Call") {
+      if (LOOP_FUNCTION_NAMES.has(current.callee) && scope.frames.length > 0) {
+        const arg = current.args[0];
+        if (current.args.length !== 1 || arg?.kind !== "Identifier" || !scope.frameFor(arg.name)) {
+          found.push({ code: "type-mismatch", message: `${current.callee}() takes a loop row, such as ${current.callee}(item).`, expression: slot.source, position: at(slot, current.span) });
+        }
+      }
+      current.args.forEach(visit);
+      return;
+    }
+    for (const value of Object.values(current)) {
+      if (value && typeof value === "object" && "kind" in value && "span" in value) visit(value);
+      if (Array.isArray(value)) value.forEach((element) => element && typeof element === "object" && "kind" in element && visit(element));
+    }
+  };
+  visit(node);
+  return found;
+}
+function checkDirective(slot, node, scope) {
+  const found = [];
+  if (node.args.length < 1 || node.args.length > 2) {
+    found.push({ code: "arity", message: `${node.callee} takes a location, or a party and a location, such as ${node.callee}(parties.tenant, "tenant-sign").`, expression: slot.source, position: slot.position });
+    return found;
+  }
+  if (node.args.length === 1 && scope.frames.length === 0) {
+    found.push({ code: "arity", message: `${node.callee}() needs a party: use it inside a party loop, or pass the party first, such as ${node.callee}(parties.tenant, "location").`, expression: slot.source, position: slot.position });
+  }
+  for (const arg of node.args) found.push(...diagnosticsFor(slot, arg, scope).diagnostics);
+  const location = diagnosticsFor(slot, node.args.at(-1), scope).type;
+  if (location.kind !== "string" && location.kind !== "unknown") {
+    found.push({ code: "type-mismatch", message: `${node.callee}'s location must be a string, got ${formatType(location)}.`, expression: slot.source, position: slot.position });
+  }
+  return found;
+}
+function checkSlot(slot, scope, role) {
+  if (!slot.ast) return { diagnostics: slot.problem ? [slot.problem] : [] };
+  if (role === "value" && slot.ast.kind === "Call" && SIGNING_DIRECTIVES.has(slot.ast.callee)) {
+    return { diagnostics: checkDirective(slot, slot.ast, scope) };
+  }
+  const { type, diagnostics } = diagnosticsFor(slot, slot.ast, scope);
+  if (diagnostics.length > 0) return { diagnostics };
+  if (role === "condition" && type.kind !== "boolean") {
+    return {
+      diagnostics: [{
+        code: "non-boolean-gate",
+        message: type.kind === "unknown" ? "A condition must be boolean; its type cannot be determined. Compare it, such as value != null." : `A condition must be boolean, got ${formatType(type)}. Compare it, such as value != null.`,
+        expression: slot.source,
+        position: slot.position
+      }]
+    };
+  }
+  if (role === "loop") {
+    if (type.kind !== "array") {
+      return { diagnostics: [{ code: "type-mismatch", message: `A loop source must be a list, got ${formatType(type)}.`, expression: slot.source, position: slot.position }] };
+    }
+    return { diagnostics: [], frame: { kind: "each", element: type.element, sourcePath: scope.sourcePath(slot.ast) } };
+  }
+  return { diagnostics: [] };
+}
+function checkNodes(nodes, scope, found) {
+  for (const node of nodes) {
+    if (node.type === "text") continue;
+    if (node.type === "value") {
+      found.push(...checkSlot(node.slot, scope, "value").diagnostics);
+      continue;
+    }
+    if (node.type === "each") {
+      const { diagnostics, frame } = checkSlot(node.slot, scope, "loop");
+      found.push(...diagnostics);
+      checkNodes(node.children, frame ? scope.push(frame) : scope.push({ kind: "each", element: T2.unknown }), found);
+      checkNodes(node.inverse, scope, found);
+      continue;
+    }
+    found.push(...checkSlot(node.slot, scope, "condition").diagnostics);
+    checkNodes(node.children, scope, found);
+    checkNodes(node.inverse, scope, found);
+  }
+}
+function markerProblem(error) {
+  if (error instanceof TemplateError) return [error.diagnostic];
+  throw error;
+}
+function checkTextTemplate(template, env) {
+  let nodes;
+  try {
+    nodes = parseTemplate(template);
+  } catch (error) {
+    return markerProblem(error);
+  }
+  const found = [];
+  checkNodes(nodes, new CheckScope(env), found);
+  return found;
+}
+var textDecoder2 = new TextDecoder();
+function checkDocxTemplate(template, env, options = {}) {
+  const delimiters = options.cmdDelimiter ?? ["{{", "}}"];
+  const found = [];
+  for (const [part, bytes] of Object.entries(unzipSync2(template))) {
+    if (!DOCX_TEMPLATE_PARTS.test(part)) continue;
+    const xml = normalizeInlineControls(textDecoder2.decode(bytes), delimiters);
+    const paragraphs = [...xml.matchAll(/<w:p\b[^>]*>[\s\S]*?<\/w:p>/g)];
+    const commands = paragraphs.map((match) => commandOf(match[0], delimiters));
+    for (const { index, message } of docxControlProblems(commands)) {
+      found.push({ code: "markers", message, location: `${part} paragraph ${index + 1}` });
+    }
+    let scope = new CheckScope(env);
+    const open = [];
+    paragraphs.forEach((match, index) => {
+      const location = `${part} paragraph ${index + 1}`;
+      const locate2 = (diagnostics) => diagnostics.map((diagnostic) => ({ ...diagnostic, location }));
+      const locateCommand = (diagnostics) => diagnostics.map(({ position: _position, ...diagnostic }) => ({ ...diagnostic, location }));
+      const command = commands[index];
+      if (command !== void 0) {
+        const forMatch = command.match(/^FOR\s+(\S+)\s+IN\s+(.+)$/);
+        if (forMatch) {
+          const slot = expressionSlot(forMatch[2], { line: 1, column: 1 });
+          const { diagnostics, frame } = checkSlot(slot, scope, "loop");
+          found.push(...locateCommand(diagnostics));
+          scope = scope.push({ ...frame ?? { element: T2.unknown }, kind: "named", name: forMatch[1] });
+          open.push("FOR");
+          return;
+        }
+        if (/^IF\s+/.test(command)) {
+          found.push(...locateCommand(checkSlot(expressionSlot(command.slice(3), { line: 1, column: 1 }), scope, "condition").diagnostics));
+          open.push("IF");
+          return;
+        }
+        if (/^END-(?:FOR|IF)/.test(command)) {
+          if (open.pop() === "FOR") scope = new CheckScope(scope.env, scope.frames.slice(0, -1));
+          return;
+        }
+        if (command === "ELSE") return;
+      }
+      const text = paragraphText(match[0]);
+      if (!text.includes(delimiters[0])) return;
+      let nodes;
+      try {
+        nodes = parseTemplate(normalizeDelimiters(text, delimiters));
+      } catch (error) {
+        found.push(...locate2(markerProblem(error)));
+        return;
+      }
+      const inner = [];
+      checkNodes(nodes, scope, inner);
+      found.push(...locate2(inner));
+    });
+  }
+  return found;
+}
+function commandOf(paragraph, delimiters) {
+  const value = paragraphText(paragraph).trim();
+  if (!value.startsWith(delimiters[0]) || !value.endsWith(delimiters[1])) return void 0;
+  const inner = value.slice(delimiters[0].length, -delimiters[1].length).trim();
+  return /^(?:FOR\s|IF\s|ELSE$|END-(?:FOR|IF))/.test(inner) ? inner : void 0;
+}
+function collectDirectives(nodes, found) {
+  for (const node of nodes) {
+    if (node.type === "text") continue;
+    if (node.type === "value") {
+      const ast = node.slot.ast;
+      if (ast?.kind !== "Call" || !SIGNING_DIRECTIVES.has(ast.callee) || ast.args.length === 0) continue;
+      const location = ast.args.at(-1);
+      found.push({ directive: ast.callee, ...location.kind === "StringLiteral" && { location: location.value } });
+      continue;
+    }
+    collectDirectives(node.children, found);
+    collectDirectives(node.inverse, found);
+  }
+}
+function textTemplateSigningDirectives(template) {
+  let nodes;
+  try {
+    nodes = parseTemplate(template);
+  } catch (error) {
+    if (error instanceof TemplateError) return void 0;
+    throw error;
+  }
+  const found = [];
+  collectDirectives(nodes, found);
+  return found;
+}
+
+export {
+  TemplateError,
+  escapeHtml,
+  renderTemplate,
+  requestExpressions,
+  templateData,
+  createTextSignatureDirectives,
+  renderDocx,
+  checkTextTemplate,
+  checkDocxTemplate,
+  textTemplateSigningDirectives
+};