@worm-vue3-print/core 1.0.1

package/dist/index.js

@@ -0,0 +1,1758 @@
+// src/lexer.ts
+var DANGEROUS_PROPS = /* @__PURE__ */ new Set([
+  "constructor",
+  "__proto__",
+  "prototype",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__"
+]);
+var RESERVED_WORDS = /* @__PURE__ */ new Set([
+  "new",
+  "function",
+  "class",
+  "this",
+  "delete",
+  "typeof",
+  "void",
+  "in",
+  "of",
+  "var",
+  "let",
+  "const",
+  "return",
+  "if",
+  "while",
+  "for"
+]);
+function tokenize(input) {
+  const tokens = [];
+  let i = 0;
+  const n = input.length;
+  while (i < n) {
+    const ch = input[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (/[0-9]/.test(ch) || ch === "." && i + 1 < n && /[0-9]/.test(input[i + 1])) {
+      let j = i;
+      while (j < n && /[0-9.]/.test(input[j])) j++;
+      tokens.push({ type: "num", value: input.slice(i, j), position: i });
+      i = j;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      let j = i + 1;
+      let s = "";
+      while (j < n && input[j] !== ch) {
+        if (input[j] === "\\" && j + 1 < n) {
+          s += input[j + 1];
+          j += 2;
+        } else {
+          s += input[j];
+          j++;
+        }
+      }
+      if (j >= n) throw new Error("\u5B57\u7B26\u4E32\u672A\u95ED\u5408");
+      tokens.push({ type: "str", value: s, position: i });
+      i = j + 1;
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(ch)) {
+      let j = i;
+      while (j < n && /[A-Za-z0-9_$]/.test(input[j])) j++;
+      const word = input.slice(i, j);
+      if (RESERVED_WORDS.has(word)) {
+        throw new Error(`\u4E0D\u5141\u8BB8\u4F7F\u7528\u5173\u952E\u5B57: ${word}`);
+      }
+      if (DANGEROUS_PROPS.has(word)) {
+        throw new Error(`\u7981\u6B62\u8BBF\u95EE: ${word}`);
+      }
+      if (word === "true" || word === "false") {
+        tokens.push({ type: "bool", value: word, position: i });
+      } else {
+        tokens.push({ type: "ident", value: word, position: i });
+      }
+      i = j;
+      continue;
+    }
+    const three = input.slice(i, i + 3);
+    if (three === "===" || three === "!==") {
+      tokens.push({ type: "punc", value: three, position: i });
+      i += 3;
+      continue;
+    }
+    const two = input.slice(i, i + 2);
+    if (two === "=>") throw new Error("\u4E0D\u5141\u8BB8\u51FD\u6570\u5B9A\u4E49");
+    if (["==", "!=", "<=", ">=", "&&", "||"].includes(two)) {
+      tokens.push({ type: "punc", value: two, position: i });
+      i += 2;
+      continue;
+    }
+    if (ch === "=") throw new Error("\u4E0D\u5141\u8BB8\u8D4B\u503C");
+    if (ch === ";") throw new Error("\u4E0D\u5141\u8BB8\u591A\u6761\u8BED\u53E5");
+    if ("+-*/%()[]{},:.?!<>".includes(ch)) {
+      tokens.push({ type: "punc", value: ch, position: i });
+      i++;
+      continue;
+    }
+    throw new Error(`\u975E\u6CD5\u5B57\u7B26: ${ch}`);
+  }
+  return tokens;
+}
+
+// src/parser.ts
+function parse(tokens) {
+  const parser = new Parser(tokens);
+  return parser.parse();
+}
+var Parser = class {
+  constructor(tokens) {
+    this.pos = 0;
+    this.tokens = tokens;
+  }
+  parse() {
+    const node = this.parseTernary();
+    if (this.pos < this.tokens.length) {
+      throw new Error(`\u8868\u8FBE\u5F0F\u5B58\u5728\u591A\u4F59\u5185\u5BB9: ${this.tokens[this.pos].value}`);
+    }
+    return node;
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  next() {
+    const t = this.tokens[this.pos++];
+    if (!t) throw new Error("\u8868\u8FBE\u5F0F\u610F\u5916\u7ED3\u675F");
+    return t;
+  }
+  eatPunc(value) {
+    const t = this.peek();
+    if (t && t.type === "punc" && t.value === value) {
+      this.pos++;
+      return true;
+    }
+    return false;
+  }
+  expectPunc(value) {
+    if (!this.eatPunc(value)) {
+      const pos = this.peek()?.position ?? 0;
+      throw new Error(`\u4F4D\u7F6E ${pos}: \u671F\u671B "${value}"`);
+    }
+  }
+  // 三元运算符 ?: (优先级最低)
+  parseTernary() {
+    const cond = this.parseLogicalOr();
+    if (this.eatPunc("?")) {
+      const consequent = this.parseTernary();
+      this.expectPunc(":");
+      const alternate = this.parseTernary();
+      return { type: "ternary", cond, consequent, alternate };
+    }
+    return cond;
+  }
+  // ||
+  parseLogicalOr() {
+    let left = this.parseLogicalAnd();
+    while (this.eatPunc("||")) {
+      const right = this.parseLogicalAnd();
+      left = { type: "binary", op: "||", left, right };
+    }
+    return left;
+  }
+  // &&
+  parseLogicalAnd() {
+    let left = this.parseEquality();
+    while (this.eatPunc("&&")) {
+      const right = this.parseEquality();
+      left = { type: "binary", op: "&&", left, right };
+    }
+    return left;
+  }
+  // == != === !==
+  parseEquality() {
+    let left = this.parseRelational();
+    for (; ; ) {
+      const t = this.peek();
+      if (t?.type === "punc" && ["==", "!=", "===", "!=="].includes(t.value)) {
+        this.pos++;
+        const right = this.parseRelational();
+        left = { type: "binary", op: t.value, left, right };
+      } else {
+        return left;
+      }
+    }
+  }
+  // < > <= >=
+  parseRelational() {
+    let left = this.parseAdditive();
+    for (; ; ) {
+      const t = this.peek();
+      if (t?.type === "punc" && ["<", ">", "<=", ">="].includes(t.value)) {
+        this.pos++;
+        const right = this.parseAdditive();
+        left = { type: "binary", op: t.value, left, right };
+      } else {
+        return left;
+      }
+    }
+  }
+  // + - (二元)
+  parseAdditive() {
+    let left = this.parseMultiplicative();
+    for (; ; ) {
+      const t = this.peek();
+      if (t?.type === "punc" && (t.value === "+" || t.value === "-")) {
+        this.pos++;
+        const right = this.parseMultiplicative();
+        left = { type: "binary", op: t.value, left, right };
+      } else {
+        return left;
+      }
+    }
+  }
+  // * / %
+  parseMultiplicative() {
+    let left = this.parseUnary();
+    for (; ; ) {
+      const t = this.peek();
+      if (t?.type === "punc" && ["*", "/", "%"].includes(t.value)) {
+        this.pos++;
+        const right = this.parseUnary();
+        left = { type: "binary", op: t.value, left, right };
+      } else {
+        return left;
+      }
+    }
+  }
+  // 一元 ! - +
+  parseUnary() {
+    const t = this.peek();
+    if (t?.type === "punc" && ["!", "-", "+"].includes(t.value)) {
+      this.pos++;
+      const arg = this.parseUnary();
+      return { type: "unary", op: t.value, arg, prefix: true };
+    }
+    return this.parsePostfix();
+  }
+  // 成员访问 x.y, x[i], 函数调用 f()
+  parsePostfix() {
+    let node = this.parsePrimary();
+    for (; ; ) {
+      if (this.eatPunc(".")) {
+        const prop = this.next();
+        if (prop.type !== "ident") {
+          throw new Error(`\u4F4D\u7F6E ${prop.position}: \u6210\u5458\u8BBF\u95EE\u9700\u8981\u5C5E\u6027\u540D`);
+        }
+        node = {
+          type: "member",
+          object: node,
+          property: prop.value,
+          computed: false
+        };
+      } else if (this.eatPunc("[")) {
+        const index = this.parseTernary();
+        this.expectPunc("]");
+        if (index.type === "str") {
+          node = {
+            type: "member",
+            object: node,
+            property: index.value,
+            computed: false
+          };
+        } else {
+          node = {
+            type: "member",
+            object: node,
+            property: index.name ?? String(index.value),
+            computed: true
+          };
+        }
+      } else if (this.peek()?.type === "punc" && this.peek()?.value === "(" && (node.type === "ident" || node.type === "member")) {
+        this.pos++;
+        const args = this.parseArgs();
+        node = { type: "call", callee: node, args };
+      } else {
+        return node;
+      }
+    }
+  }
+  parseArgs() {
+    const args = [];
+    if (this.eatPunc(")")) return args;
+    for (; ; ) {
+      args.push(this.parseTernary());
+      if (this.eatPunc(")")) return args;
+      this.expectPunc(",");
+    }
+  }
+  parsePrimary() {
+    const t = this.next();
+    if (t.type === "num") {
+      const v = Number(t.value);
+      if (isNaN(v)) throw new Error(`\u975E\u6CD5\u6570\u5B57: ${t.value}`);
+      return { type: "num", value: v };
+    }
+    if (t.type === "str") {
+      return { type: "str", value: t.value };
+    }
+    if (t.type === "bool") {
+      return { type: "bool", value: t.value === "true" };
+    }
+    if (t.type === "ident") {
+      return { type: "ident", name: t.value };
+    }
+    if (t.value === "(") {
+      const inner = this.parseTernary();
+      this.expectPunc(")");
+      return inner;
+    }
+    if (t.value === "[") {
+      const elements = [];
+      if (!this.eatPunc("]")) {
+        for (; ; ) {
+          elements.push(this.parseTernary());
+          if (this.eatPunc("]")) break;
+          this.expectPunc(",");
+        }
+      }
+      return { type: "array", elements };
+    }
+    if (t.value === "{") {
+      const properties = [];
+      if (!this.eatPunc("}")) {
+        for (; ; ) {
+          const keyToken = this.next();
+          if (keyToken.type !== "ident" && keyToken.type !== "str") {
+            throw new Error(`\u4F4D\u7F6E ${keyToken.position}: \u5BF9\u8C61\u952E\u5FC5\u987B\u662F\u6807\u8BC6\u7B26\u6216\u5B57\u7B26\u4E32`);
+          }
+          this.expectPunc(":");
+          properties.push({ key: keyToken.value, value: this.parseTernary() });
+          if (this.eatPunc("}")) break;
+          this.expectPunc(",");
+        }
+      }
+      return { type: "object", properties };
+    }
+    throw new Error(`\u4F4D\u7F6E ${t.position}: \u610F\u5916\u7684\u7B26\u53F7: ${t.value}`);
+  }
+};
+
+// src/evaluator.ts
+var SAFE_GLOBALS = {
+  Math,
+  Number,
+  String,
+  Boolean,
+  parseInt,
+  parseFloat,
+  isNaN,
+  true: true,
+  false: false,
+  null: null,
+  undefined: void 0
+};
+var DANGEROUS_PROPS2 = /* @__PURE__ */ new Set([
+  "constructor",
+  "__proto__",
+  "prototype",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__"
+]);
+var CALLABLE_GLOBALS = /* @__PURE__ */ new Set(["Number", "String", "Boolean", "parseInt", "parseFloat", "isNaN"]);
+function evaluate(node, context, functions = {}) {
+  switch (node.type) {
+    case "num":
+      return node.value;
+    case "str":
+      return node.value;
+    case "bool":
+      return node.value;
+    case "ident":
+      return evalIdent(node.name, context, functions);
+    case "binary":
+      return evalBinary(node, context, functions);
+    case "unary":
+      return evalUnary(node, context, functions);
+    case "ternary":
+      return evaluate(node.cond, context, functions) ? evaluate(node.consequent, context, functions) : evaluate(node.alternate, context, functions);
+    case "member":
+      return evalMember(node, context, functions);
+    case "call":
+      return evalCall(node, context, functions);
+    case "array":
+      return node.elements.map((e) => evaluate(e, context, functions));
+    case "object":
+      return Object.fromEntries(
+        node.properties.map((p) => [p.key, evaluate(p.value, context, functions)])
+      );
+  }
+}
+function evalIdent(name, context, functions) {
+  if (Object.prototype.hasOwnProperty.call(context, name)) {
+    return context[name];
+  }
+  if (Object.prototype.hasOwnProperty.call(SAFE_GLOBALS, name)) {
+    return SAFE_GLOBALS[name];
+  }
+  throw new Error(`\u672A\u5B9A\u4E49\u7684\u6807\u8BC6\u7B26: ${name}`);
+}
+function evalBinary(node, context, functions) {
+  const left = evaluate(node.left, context, functions);
+  const right = evaluate(node.right, context, functions);
+  switch (node.op) {
+    case "+":
+      return left + right;
+    case "-":
+      return left - right;
+    case "*":
+      return left * right;
+    case "/":
+      return left / right;
+    case "%":
+      return left % right;
+    case "<":
+      return left < right;
+    case ">":
+      return left > right;
+    case "<=":
+      return left <= right;
+    case ">=":
+      return left >= right;
+    case "==":
+      return left == right;
+    case "!=":
+      return left != right;
+    case "===":
+      return left === right;
+    case "!==":
+      return left !== right;
+    case "&&":
+      return left && right;
+    case "||":
+      return left || right;
+    default:
+      throw new Error(`\u672A\u77E5\u8FD0\u7B97\u7B26: ${node.op}`);
+  }
+}
+function evalUnary(node, context, functions) {
+  const arg = evaluate(node.arg, context, functions);
+  switch (node.op) {
+    case "-":
+      return -arg;
+    case "+":
+      return +arg;
+    case "!":
+      return !arg;
+    default:
+      throw new Error(`\u672A\u77E5\u4E00\u5143\u8FD0\u7B97\u7B26: ${node.op}`);
+  }
+}
+function evalMember(node, context, functions) {
+  const obj = evaluate(node.object, context, functions);
+  if (obj == null) {
+    throw new Error("\u65E0\u6CD5\u8BBF\u95EE\u7A7A\u503C\u7684\u5C5E\u6027");
+  }
+  if (DANGEROUS_PROPS2.has(node.property)) {
+    throw new Error(`\u7981\u6B62\u8BBF\u95EE\u5C5E\u6027: ${node.property}`);
+  }
+  return obj[node.property];
+}
+function evalCall(node, context, functions) {
+  if (node.callee.type === "ident" && CALLABLE_GLOBALS.has(node.callee.name)) {
+    const fn = SAFE_GLOBALS[node.callee.name];
+    const args = node.args.map((a) => evaluate(a, context, functions));
+    return fn(...args);
+  }
+  if (node.callee.type === "member" && node.callee.object.type === "ident" && node.callee.object.name === "Math") {
+    const method = Math[node.callee.property];
+    if (typeof method !== "function") {
+      throw new Error(`Math.${node.callee.property} \u4E0D\u662F\u65B9\u6CD5`);
+    }
+    const args = node.args.map((a) => evaluate(a, context, functions));
+    return method(...args);
+  }
+  let fnName;
+  if (node.callee.type === "ident") {
+    fnName = node.callee.name;
+  } else if (node.callee.type === "member") {
+    throw new Error("\u4E0D\u652F\u6301\u65B9\u6CD5\u8C03\u7528\uFF0C\u8BF7\u4F7F\u7528\u9876\u7EA7\u51FD\u6570");
+  }
+  if (fnName && functions[fnName]) {
+    const args = node.args.map((a) => evaluate(a, context, functions));
+    return functions[fnName](...args);
+  }
+  if (fnName && Object.prototype.hasOwnProperty.call(context, fnName)) {
+    throw new Error(`${fnName} \u4E0D\u662F\u51FD\u6570`);
+  }
+  throw new Error(`\u4E0D\u5141\u8BB8\u8C03\u7528: ${fnName ?? "\u8868\u8FBE\u5F0F"}`);
+}
+
+// src/template-parser.ts
+function parseTemplate(template) {
+  const parts = [];
+  let i = 0;
+  const n = template.length;
+  while (i < n) {
+    if (template[i] === "{") {
+      let depth = 1;
+      let j2 = i + 1;
+      while (j2 < n && depth > 0) {
+        if (template[j2] === "{") depth++;
+        else if (template[j2] === "}") depth--;
+        j2++;
+      }
+      if (depth !== 0) {
+        throw new Error(`\u4F4D\u7F6E ${i}: \u82B1\u62EC\u53F7\u672A\u95ED\u5408`);
+      }
+      const exprStr = template.slice(i + 1, j2 - 1);
+      if (exprStr.trim() === "") {
+        throw new Error(`\u4F4D\u7F6E ${i}: \u7A7A\u8868\u8FBE\u5F0F`);
+      }
+      const tokens = tokenize(exprStr);
+      const expression = parse(tokens);
+      parts.push({ type: "expr", expression });
+      i = j2;
+      continue;
+    }
+    let j = i;
+    while (j < n && template[j] !== "{") {
+      if (template[j] === "\\" && j + 1 < n && (template[j + 1] === "{" || template[j + 1] === "}")) {
+        j += 2;
+      } else {
+        j++;
+      }
+    }
+    parts.push({ type: "text", value: template.slice(i, j).replace(/\\([{}])/g, "$1") });
+    i = j;
+  }
+  return { type: "template", parts };
+}
+function renderTemplate(ast, context, functions = {}) {
+  let result = "";
+  for (const part of ast.parts) {
+    if (part.type === "text") {
+      result += part.value;
+    } else {
+      const value = evaluate(part.expression, context, functions);
+      result += String(value ?? "");
+    }
+  }
+  return result;
+}
+function compileTemplate(template, functions = {}) {
+  const ast = parseTemplate(template);
+  return (context) => renderTemplate(ast, context, functions);
+}
+
+// src/utils.ts
+function getByPath(obj, path) {
+  if (obj == null || path == null) return void 0;
+  if (typeof obj === "object" && path in obj) return obj[path];
+  const parts = path.split(".");
+  let cur = obj;
+  for (const p of parts) {
+    if (cur == null) return void 0;
+    cur = cur[p];
+  }
+  return cur;
+}
+
+// src/functions/format.ts
+function formatMoney(value) {
+  const num = Number(value);
+  if (isNaN(num)) return String(value);
+  const sign = num < 0 ? "-" : "";
+  const abs = Math.abs(num);
+  const [intPart, decPart] = abs.toFixed(2).split(".");
+  const formatted = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return `${sign}${formatted}.${decPart}`;
+}
+function formatDate(value, fmt) {
+  let date;
+  if (value instanceof Date) {
+    date = value;
+  } else if (typeof value === "number") {
+    date = new Date(value);
+  } else if (typeof value === "string") {
+    date = new Date(value);
+  } else {
+    return String(value);
+  }
+  if (isNaN(date.getTime())) return String(value);
+  const pad = (n) => String(n).padStart(2, "0");
+  return fmt.replace("YYYY", String(date.getFullYear())).replace("MM", pad(date.getMonth() + 1)).replace("DD", pad(date.getDate())).replace("HH", pad(date.getHours())).replace("mm", pad(date.getMinutes())).replace("ss", pad(date.getSeconds()));
+}
+function toUpperCaseAmount(value) {
+  const num = Number(value);
+  if (isNaN(num)) return String(value);
+  if (num === 0) return "\u96F6\u5143\u6574";
+  const digits = ["\u96F6", "\u58F9", "\u8D30", "\u53C1", "\u8086", "\u4F0D", "\u9646", "\u67D2", "\u634C", "\u7396"];
+  const units = ["", "\u62FE", "\u4F70", "\u4EDF"];
+  const bigUnits = ["", "\u4E07", "\u4EBF"];
+  const sign = num < 0 ? "\u8D1F" : "";
+  const abs = Math.abs(num);
+  const [intStr, decStr] = abs.toFixed(2).split(".");
+  const intNum = parseInt(intStr, 10);
+  let result = "";
+  if (intNum > 0) {
+    const intChars = intStr.split("").reverse();
+    let groupIdx = 0;
+    let lastDigit = 0;
+    let needZero = false;
+    for (let i = 0; i < intChars.length; i++) {
+      const d = parseInt(intChars[i], 10);
+      const unit = units[groupIdx % 4];
+      const bigUnit = bigUnits[Math.floor(groupIdx / 4)];
+      if (d === 0) {
+        if (lastDigit !== 0) needZero = true;
+      } else {
+        if (needZero) {
+          result = "\u96F6" + result;
+          needZero = false;
+        }
+        result = digits[d] + unit + result;
+        lastDigit = d;
+      }
+      if (groupIdx % 4 === 3 && groupIdx > 0) {
+        result = bigUnit + result;
+      }
+      groupIdx++;
+    }
+    result += "\u5143";
+  }
+  const jiao = parseInt(decStr[0], 10);
+  const fen = parseInt(decStr[1], 10);
+  if (jiao === 0 && fen === 0) {
+    result += "\u6574";
+  } else {
+    if (jiao > 0) {
+      result += digits[jiao] + "\u89D2";
+    }
+    if (fen > 0) {
+      result += digits[fen] + "\u5206";
+    }
+  }
+  return sign + result;
+}
+function ifFn(condition, trueVal, falseVal) {
+  return condition ? trueVal : falseVal;
+}
+
+// src/functions/aggregate.ts
+function sum(rows, field) {
+  return rows.reduce((acc, row) => acc + (Number(getByPath(row, field)) || 0), 0);
+}
+function avg(rows, field) {
+  if (rows.length === 0) return 0;
+  return sum(rows, field) / rows.length;
+}
+function count(rows, field) {
+  return rows.length;
+}
+function min(rows, field) {
+  if (rows.length === 0) return 0;
+  return Math.min(...rows.map((row) => Number(getByPath(row, field)) || 0));
+}
+function max(rows, field) {
+  if (rows.length === 0) return 0;
+  return Math.max(...rows.map((row) => Number(getByPath(row, field)) || 0));
+}
+
+// src/functions/system.ts
+var _pageIndex = 1;
+var _totalPages = 1;
+function setPageIndex(v) {
+  _pageIndex = v;
+}
+function setTotalPages(v) {
+  _totalPages = v;
+}
+var systemVars = {
+  pageIndex: () => _pageIndex,
+  totalPages: () => _totalPages,
+  printDate: () => {
+    const now = /* @__PURE__ */ new Date();
+    const y = now.getFullYear();
+    const m = String(now.getMonth() + 1).padStart(2, "0");
+    const d = String(now.getDate()).padStart(2, "0");
+    return `${y}-${m}-${d}`;
+  },
+  printTime: () => Date.now()
+};
+
+// src/render/expression-eval.ts
+var RenderEngine = class {
+  constructor() {
+    this.functions = {};
+  }
+  registerFunction(name, fn) {
+    this.functions[name] = fn;
+  }
+  evaluate(expression, context) {
+    const tokens = tokenize(expression);
+    const ast = parse(tokens);
+    return evaluate(ast, context, this.functions);
+  }
+  render(template, context) {
+    return compileTemplate(template, this.functions)(context);
+  }
+};
+var engine = new RenderEngine();
+var FORMAT_FUNCTIONS = {
+  MONEY: formatMoney,
+  DATE: formatDate,
+  UPPER: toUpperCaseAmount,
+  IF: ifFn,
+  CONCAT: (...args) => args.filter((v) => v != null).map(String).join(""),
+  IFEMPTY: (v, d) => v != null && v !== "" ? String(v) : d,
+  ROUND: (n, d) => Number(Number(n).toFixed(d)),
+  LEN: (s) => String(s).length
+};
+for (const [name, fn] of Object.entries(FORMAT_FUNCTIONS)) {
+  engine.registerFunction(name, fn);
+}
+function aggregate(fn, field, rows) {
+  switch (fn.toUpperCase()) {
+    case "SUM":
+      return sum(rows, field);
+    case "AVG":
+      return avg(rows, field);
+    case "COUNT":
+      return count(rows, field);
+    case "MIN":
+      return min(rows, field);
+    case "MAX":
+      return max(rows, field);
+    default:
+      return 0;
+  }
+}
+function safeEval(expr, context) {
+  return engine.evaluate(expr, context);
+}
+function evaluateTemplate(text, ctx) {
+  if (!text) return "";
+  if (!text.includes("{")) return text;
+  const rows = Array.isArray(ctx.rows) ? ctx.rows : [];
+  const processedText = text.replace(/\{([^}]+)\}/g, (_match, inner) => {
+    let expr = inner.trim();
+    expr = expr.replace(/\b(SUM|AVG|COUNT|MIN|MAX)\(([^)]+)\)/g, (_m, fn, arg) => {
+      const field = arg.trim().replace(/^['"]|['"]$/g, "");
+      return String(aggregate(fn, field, rows));
+    });
+    return `{${expr}}`;
+  });
+  try {
+    return engine.render(processedText, ctx);
+  } catch {
+    return text;
+  }
+}
+
+// src/render/data-binder.ts
+function bindData(template, printData, baseUrl) {
+  const raw = printData ?? {};
+  const data = Array.isArray(raw) ? raw[0] ?? {} : raw;
+  const bound = JSON.parse(JSON.stringify(template));
+  if (bound.header?.elements) {
+    bound.header.elements = bound.header.elements.map((el) => bindElement(el, data, baseUrl));
+  }
+  if (bound.footer?.elements) {
+    bound.footer.elements = bound.footer.elements.map((el) => bindElement(el, data, baseUrl));
+  }
+  if (bound.firstPageOverlay?.elements) {
+    bound.firstPageOverlay.elements = bound.firstPageOverlay.elements.map((el) => bindElement(el, data, baseUrl));
+  }
+  bound.elements = bound.elements.map((el) => bindElement(el, data, baseUrl));
+  return bound;
+}
+function bindElement(el, data, baseUrl) {
+  const cloned = { ...el, options: { ...el.options } };
+  if (typeof cloned.options.formatter === "string") {
+    cloned.options.formatter = evaluateTemplate(cloned.options.formatter, data);
+  }
+  const isImage = cloned.type === "image" || cloned.printElementType?.type === "image";
+  if (isImage && typeof cloned.options.src === "string") {
+    let src = cloned.options.src;
+    if (src.includes("{")) {
+      src = evaluateTemplate(src, data);
+    }
+    if (src && baseUrl && src.startsWith("/")) {
+      src = baseUrl.replace(/\/+$/, "") + src;
+    }
+    cloned.options.src = src;
+  }
+  if (cloned.type === "table" || cloned.printElementType?.type === "table") {
+    bindTableData(cloned, data);
+  }
+  return cloned;
+}
+function resolveListSource(opts, data) {
+  const explicitKey = opts.dataSource ?? opts.fields?.[0]?.dataSource ?? opts.fields?.[0]?.field;
+  if (explicitKey && Array.isArray(data[explicitKey])) {
+    return { list: data[explicitKey], key: explicitKey };
+  }
+  for (const [k, v] of Object.entries(data)) {
+    if (Array.isArray(v)) return { list: v, key: k };
+  }
+  return { list: [], key: explicitKey };
+}
+function bindTableData(el, data) {
+  const opts = el.options;
+  const rows = opts.tableRows;
+  if (!Array.isArray(rows) || rows.length === 0) return;
+  const mode = opts.tableMode ?? "dynamic";
+  const { list, key } = mode === "dynamic" ? resolveListSource(opts, data) : { list: [], key: void 0 };
+  const itemCtx = (item) => key ? { ...data, ...item, [key]: item } : { ...data, ...item };
+  const summaryRows = key ? list.map((item) => ({ ...item, [key]: item })) : list;
+  const renderRows = [];
+  const dataRowCtx = [];
+  const subtotalTemplates = [];
+  const summaryRenderRows = [];
+  let dataStartIdx = -1;
+  for (const row of rows) {
+    if (mode === "dynamic" && row.type === "data") {
+      for (const item of list) {
+        if (dataStartIdx < 0) dataStartIdx = renderRows.length;
+        const ctx = itemCtx(item);
+        renderRows.push(makeRenderRow(row, (cell) => {
+          const formatter = cell.formatter;
+          if (!formatter) return "";
+          return evaluateTemplate(formatter, ctx);
+        }));
+        dataRowCtx.push(ctx);
+      }
+      continue;
+    }
+    if (mode === "dynamic" && row.type === "subtotal") {
+      const tpl = makeRenderRow(row, (cell) => {
+        const formatter = cell.formatter;
+        if (!formatter) return "";
+        return evaluateTemplate(formatter, { rows: summaryRows, ...data });
+      }, true);
+      subtotalTemplates.push(tpl);
+      renderRows.push(tpl);
+      continue;
+    }
+    if (mode === "dynamic" && row.type === "summary") {
+      const summaryRow = makeRenderRow(row, (cell) => {
+        const formatter = cell.formatter;
+        if (!formatter) return "";
+        return evaluateTemplate(formatter, { rows: summaryRows, ...data });
+      });
+      summaryRenderRows.push(summaryRow);
+      renderRows.push(summaryRow);
+      continue;
+    }
+    renderRows.push(makeRenderRow(row, (cell) => {
+      const formatter = cell.formatter;
+      if (!formatter) return "";
+      return evaluateTemplate(formatter, data);
+    }));
+  }
+  opts._renderRows = renderRows;
+  opts._repeatHeaderCount = countRepeatHeader(rows);
+  opts._dataRowCtx = dataRowCtx;
+  opts._dataStartIdx = dataStartIdx < 0 ? renderRows.length : dataStartIdx;
+  opts._subtotalTemplates = subtotalTemplates;
+  opts._summaryRows = summaryRenderRows;
+  opts._mainData = data;
+}
+function makeRenderRow(row, resolve, keepRaw = false) {
+  return {
+    type: row.type,
+    height: row.height ?? 8,
+    cells: row.cells.map((cell) => ({
+      content: cell.merged ? "" : resolve(cell),
+      ...keepRaw ? { rawFormatter: cell.merged ? "" : cell.formatter ?? "" } : {},
+      cellType: cell.cellType,
+      barcodeType: cell.barcodeType,
+      qrCodeLevel: cell.qrCodeLevel,
+      showBarcodeText: cell.showBarcodeText,
+      rowspan: cell.rowspan ?? 1,
+      colspan: cell.colspan ?? 1,
+      merged: cell.merged === true,
+      align: cell.align,
+      valign: cell.valign,
+      fontSize: cell.fontSize,
+      fontWeight: cell.fontWeight,
+      color: cell.color,
+      backgroundColor: cell.backgroundColor,
+      borders: cell.borders,
+      padding: cell.padding,
+      wordWrap: cell.wordWrap
+    }))
+  };
+}
+function countRepeatHeader(rows) {
+  let n = 0;
+  for (const row of rows) {
+    if (row.type === "header" && row.repeatOnPage === true) {
+      n++;
+    } else {
+      break;
+    }
+  }
+  return n;
+}
+function injectSystemVariables(html) {
+  const now = /* @__PURE__ */ new Date();
+  const printDate = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+  return html.replace(/\{printDate\}/g, printDate);
+}
+
+// src/render/types.ts
+var PAPER_DIMENSIONS = {
+  A4: { width: 210, height: 297 },
+  A3: { width: 297, height: 420 },
+  A5: { width: 148, height: 210 },
+  Letter: { width: 216, height: 279 },
+  Legal: { width: 216, height: 356 },
+  CUSTOM: { width: 210, height: 297 }
+};
+function getPaperDimensions(template) {
+  const base = template.paperSize === "CUSTOM" ? { width: template.customWidth ?? 210, height: template.customHeight ?? 297 } : PAPER_DIMENSIONS[template.paperSize];
+  if (template.orientation === "landscape") {
+    return { width: base.height, height: base.width };
+  }
+  return { ...base };
+}
+
+// src/render/css-builder.ts
+function mm(value) {
+  return `${value}mm`;
+}
+function buildPageCss(template) {
+  const paper = getPaperDimensions(template);
+  const { top: mt, right: mr, bottom: mb, left: ml } = template.margins;
+  const headerH = template.header?.height ?? 0;
+  const footerH = template.footer?.height ?? 0;
+  const overlayH = template.firstPageOverlay?.height ?? 0;
+  const contentWidth = paper.width - ml - mr;
+  return `
+/* \u2500\u2500 \u6253\u5370\u7EB8\u5F20\uFF1A\u6D4F\u89C8\u5668\u539F\u751F\u6253\u5370\u6309\u6B64\u5C3A\u5BF8\u5206\u9875\uFF08Playwright page.pdf \u4EE5\u663E\u5F0F\u5BBD\u9AD8\u4E3A\u51C6\uFF0C\u65E0\u526F\u4F5C\u7528\uFF09 \u2500\u2500 */
+@page { size: ${mm(paper.width)} ${mm(paper.height)}; margin: 0; }
+
+/* \u2500\u2500 \u5168\u5C40\u91CD\u7F6E \u2500\u2500 */
+* { margin: 0; padding: 0; box-sizing: border-box; }
+body { font-family: "Microsoft YaHei", "PingFang SC", "Helvetica Neue", Arial, sans-serif; }
+
+/* \u2500\u2500 \u5C4F\u5E55\u9884\u89C8\uFF1A\u7070\u5E95 + \u7EB8\u5F20\u9634\u5F71/\u9875\u95F4\u8DDD\uFF1B\u6253\u5370\u65F6\u53BB\u9664 \u2500\u2500 */
+@media screen {
+  body { background: #e9ebee; }
+  .print-page { margin: 12px auto; box-shadow: 0 2px 12px rgba(0, 0, 0, 0.18); }
+}
+@media print {
+  body { background: #fff; }
+  .print-page { margin: 0; box-shadow: none; }
+}
+
+/* \u2500\u2500 \u7EB8\u5F20\u9875\u9762 \u2500\u2500 */
+.print-page {
+  width: ${mm(paper.width)};
+  min-height: ${mm(paper.height)};
+  padding: ${mm(mt)} ${mm(mr)} ${mm(mb)} ${mm(ml)};
+  position: relative;
+  page-break-after: always;
+  overflow: hidden;
+}
+.print-page:last-child {
+  page-break-after: auto;
+}
+
+/* \u2500\u2500 \u9875\u7709 \u2500\u2500 */
+.page-header {
+  width: ${mm(contentWidth)};
+  height: ${mm(headerH)};
+  position: relative;
+}
+
+/* \u2500\u2500 \u9875\u811A\uFF1A\u7EDD\u5BF9\u5B9A\u4F4D\u56FA\u5B9A\u5728\u9875\u9762\u5E95\u90E8\uFF08\u5185\u5BB9\u4E0D\u8DB3\u65F6\u4E0D\u968F\u6587\u6863\u6D41\u4E0A\u6D6E\uFF09 \u2500\u2500 */
+.page-footer {
+  width: ${mm(contentWidth)};
+  height: ${mm(footerH)};
+  position: absolute;
+  bottom: 0;
+  left: 0;
+}
+
+/* \u2500\u2500 \u5185\u5BB9\u533A \u2500\u2500 */
+.content-area {
+  width: ${mm(contentWidth)};
+  position: relative;
+  overflow: visible;
+}
+
+/* \u2500\u2500 \u9996\u9875\u53E0\u52A0\u533A\u57DF \u2500\u2500 */
+.first-page-overlay {
+  width: ${mm(contentWidth)};
+  height: ${mm(overlayH)};
+  position: relative;
+}
+
+/* \u2500\u2500 \u5143\u7D20\u901A\u7528\u5B9A\u4F4D \u2500\u2500 */
+.print-element {
+  position: absolute;
+  overflow: hidden;
+}
+
+/* \u2500\u2500 \u8868\u683C\u6837\u5F0F \u2500\u2500 */
+.print-table {
+  width: 100%;
+  border-collapse: collapse;
+  table-layout: fixed;
+}
+.print-table th,
+.print-table td {
+  border: 1px solid #ccc;
+  padding: 2mm 3mm;
+  word-break: break-all;
+  overflow: hidden;
+}
+.print-table thead th {
+  background-color: #f5f5f5;
+  font-weight: bold;
+}
+
+/* \u2500\u2500 \u6D4B\u91CF\u6A21\u5F0F \u2500\u2500 */
+.measure-mode .print-page {
+  height: auto;
+  min-height: auto;
+  overflow: visible;
+}
+.measure-mode .content-area {
+  height: auto;
+  overflow: visible;
+}
+`.trim();
+}
+function elementPositionStyle(left, top, width, height) {
+  const parts = [
+    `position:absolute`,
+    `left:${mm(left)}`,
+    `top:${mm(top)}`,
+    `width:${mm(width)}`
+  ];
+  if (height !== void 0 && height > 0) {
+    parts.push(`height:${mm(height)}`);
+  }
+  return parts.join(";") + ";";
+}
+
+// src/render/pagination-engine.ts
+function paginationOf(el) {
+  return el.options?.pagination ?? el.pagination;
+}
+function tablePaginationOf(el) {
+  return el.options?.tablePagination ?? el.tablePagination;
+}
+var SAFETY_MARGIN = 2;
+function isTableEl(el) {
+  return el.type === "table" || el.printElementType?.type === "table";
+}
+function tableDesignBottom(el) {
+  const opts = el.options ?? {};
+  const top = opts.top ?? 0;
+  const rows = opts.tableRows ?? [];
+  if (rows.length > 0) {
+    return top + rows.reduce((s, r) => s + (r.height ?? 0), 0);
+  }
+  return top + (opts.height ?? 0);
+}
+function buildFollowMap(sorted) {
+  const map = /* @__PURE__ */ new Map();
+  let currentTableId = null;
+  let currentTableBottom = -1;
+  for (const el of sorted) {
+    if (isTableEl(el)) {
+      currentTableId = el.id;
+      currentTableBottom = tableDesignBottom(el);
+      map.set(el.id, []);
+      continue;
+    }
+    const top = el.options?.top ?? 0;
+    if (currentTableId && top >= currentTableBottom) {
+      map.get(currentTableId).push(el.id);
+    }
+  }
+  return map;
+}
+function followGroupHeight(el, members, template, measuredElements) {
+  let cursorBottom = tableDesignBottom(el);
+  let total = 0;
+  for (const id of members) {
+    const m = template.elements.find((e) => e.id === id);
+    if (!m) continue;
+    const mTop = m.options?.top ?? 0;
+    total += Math.max(mTop - cursorBottom, 0);
+    total += measuredElements.get(id)?.measuredHeight ?? m.options?.height ?? 0;
+    cursorBottom = mTop + (m.options?.height ?? 0);
+  }
+  return total;
+}
+function paginate(template, measuredElements) {
+  const paper = getPaperDimensions(template);
+  const { top: mt, bottom: mb } = template.margins;
+  const headerH = template.header?.height ?? 0;
+  const footerH = template.footer?.height ?? 0;
+  const overlayH = template.firstPageOverlay?.height ?? 0;
+  const contentHeight = paper.height - mt - mb - headerH - footerH;
+  if (contentHeight <= 0) {
+    throw new Error(
+      `\u9875\u9762\u53EF\u7528\u9AD8\u5EA6\u4E0D\u8DB3: paper=${paper.height}mm, margins=${mt + mb}mm, header=${headerH}mm, footer=${footerH}mm`
+    );
+  }
+  const sorted = [...template.elements].sort((a, b) => {
+    const topA = a.options?.top ?? 0;
+    const topB = b.options?.top ?? 0;
+    return topA - topB;
+  });
+  const followMap = buildFollowMap(sorted);
+  const followOwner = /* @__PURE__ */ new Map();
+  for (const [tableId, members] of followMap) {
+    for (const m of members) followOwner.set(m, tableId);
+  }
+  const pages = [];
+  let currentPage = [];
+  let remaining = contentHeight - overlayH - SAFETY_MARGIN;
+  let isFirstPage = true;
+  let pageBroken = false;
+  function sectionTop(el) {
+    return pageBroken ? 0 : el.options?.top ?? 0;
+  }
+  function fullPageHeight() {
+    return isFirstPage ? contentHeight - overlayH - SAFETY_MARGIN : contentHeight - SAFETY_MARGIN;
+  }
+  function finishPage() {
+    pages.push({ pageIndex: pages.length, sections: [...currentPage] });
+    currentPage = [];
+    remaining = contentHeight - SAFETY_MARGIN;
+    isFirstPage = false;
+    pageBroken = true;
+  }
+  let i = 0;
+  while (i < sorted.length) {
+    const el = sorted[i];
+    if (followOwner.has(el.id)) {
+      i++;
+      continue;
+    }
+    if (paginationOf(el)?.pageable === false) {
+      currentPage.push({ elementId: el.id, type: "element", renderTop: sectionTop(el) });
+      i++;
+      continue;
+    }
+    if (isTableEl(el)) {
+      i = paginateTable(el, measuredElements, i);
+    } else {
+      i = paginateNonTable(el, measuredElements, sorted, i);
+    }
+  }
+  if (currentPage.length > 0) {
+    pages.push({ pageIndex: pages.length, sections: [...currentPage] });
+  }
+  if (pages.length === 0) {
+    pages.push({ pageIndex: 0, sections: [] });
+  }
+  return pages;
+  function paginateNonTable(el, measured, sortedList, idx) {
+    const elHeight = measured.get(el.id)?.measuredHeight ?? el.options?.height ?? 0;
+    if (elHeight <= remaining) {
+      currentPage.push({ elementId: el.id, type: "element", renderTop: sectionTop(el) });
+      remaining -= elHeight;
+      if (paginationOf(el)?.keepWithNext && idx + 1 < sortedList.length) {
+        const nextEl = sortedList[idx + 1];
+        const nextHeight = measured.get(nextEl.id)?.measuredHeight ?? nextEl.options?.height ?? 0;
+        if (elHeight + nextHeight > fullPageHeight()) {
+          return idx + 1;
+        }
+        if (nextHeight > remaining) {
+          currentPage.pop();
+          finishPage();
+          currentPage.push({ elementId: el.id, type: "element", renderTop: sectionTop(el) });
+          remaining -= elHeight;
+        }
+      }
+      return idx + 1;
+    }
+    finishPage();
+    currentPage.push({ elementId: el.id, type: "element", renderTop: sectionTop(el) });
+    remaining -= elHeight;
+    return idx + 1;
+  }
+  function paginateTable(el, measured, idx) {
+    const opts = el.options ?? {};
+    const renderRows = opts._renderRows ?? [];
+    const rowHeights = measured.get(el.id)?.measuredRowHeights ?? [];
+    const hasSubtotal = (opts._subtotalTemplates?.length ?? 0) > 0;
+    const hasSummary = (opts._summaryRows?.length ?? 0) > 0;
+    const subtotalH = hasSubtotal ? specialRowHeight(renderRows, rowHeights, "subtotal") : 0;
+    const summaryH = hasSummary ? specialRowHeight(renderRows, rowHeights, "summary") : 0;
+    const isSpecial = (r) => hasSubtotal && r.type === "subtotal" || hasSummary && r.type === "summary";
+    const bodyRows = renderRows.filter((r) => !isSpecial(r));
+    const bodyHeights = rowHeights.filter((_, i2) => !isSpecial(renderRows[i2]));
+    opts._renderRows = bodyRows;
+    const rowCount = Math.min(bodyRows.length, bodyHeights.length);
+    const repeatCount = opts._repeatHeaderCount ?? 0;
+    const repeatH = measured.get(el.id)?.repeatHeaderHeight ?? rowHeights.slice(0, repeatCount).reduce((s, h) => s + h, 0);
+    const freshAvail = contentHeight - SAFETY_MARGIN;
+    if (repeatH > freshAvail) {
+      throw new Error(
+        `\u8868\u683C ${el.id} \u7684\u91CD\u590D\u8868\u5934\u9AD8\u5EA6 (${repeatH.toFixed(1)}mm) \u8D85\u8FC7\u9875\u9762\u53EF\u7528\u9AD8\u5EA6 (${freshAvail.toFixed(1)}mm)\uFF0C\u8BF7\u51CF\u5C11\u91CD\u590D\u8868\u5934\u884C`
+      );
+    }
+    if (rowCount === 0) {
+      currentPage.push({
+        elementId: el.id,
+        type: "table-slice",
+        startRow: 0,
+        endRow: 0,
+        summary: summaryH > 0,
+        renderTop: sectionTop(el)
+      });
+      remaining -= summaryH;
+      applyFollowGroup(el, measured);
+      return idx + 1;
+    }
+    const totalH = bodyHeights.slice(0, rowCount).reduce((s, h) => s + h, 0);
+    const totalNeed = totalH + subtotalH + summaryH;
+    if (tablePaginationOf(el)?.enabled === false) {
+      if (totalNeed > remaining && currentPage.length > 0) finishPage();
+      currentPage.push({
+        elementId: el.id,
+        type: "table-slice",
+        startRow: 0,
+        endRow: rowCount,
+        subtotal: subtotalH > 0,
+        summary: summaryH > 0,
+        renderTop: sectionTop(el)
+      });
+      remaining -= totalNeed;
+      applyFollowGroup(el, measured);
+      return idx + 1;
+    }
+    const groups = buildRowGroups(bodyRows, rowCount);
+    let sliceStart = 0;
+    let firstSlice = true;
+    for (const g of groups) {
+      const gh = bodyHeights.slice(g.start, g.end).reduce((s, h) => s + h, 0);
+      if (gh + subtotalH <= remaining) {
+        remaining -= gh;
+        continue;
+      }
+      if (g.start > sliceStart) {
+        currentPage.push({
+          elementId: el.id,
+          type: "table-slice",
+          startRow: sliceStart,
+          endRow: g.start,
+          subtotal: subtotalH > 0,
+          ...!firstSlice && repeatCount > 0 ? { repeatHeader: true } : {},
+          renderTop: sectionTop(el)
+        });
+        firstSlice = false;
+        sliceStart = g.start;
+      }
+      finishPage();
+      if (!firstSlice) remaining -= repeatH;
+      remaining -= gh;
+    }
+    if (sliceStart < rowCount) {
+      currentPage.push({
+        elementId: el.id,
+        type: "table-slice",
+        startRow: sliceStart,
+        endRow: rowCount,
+        subtotal: subtotalH > 0,
+        ...!firstSlice && repeatCount > 0 ? { repeatHeader: true } : {},
+        renderTop: sectionTop(el)
+      });
+    }
+    if (summaryH > 0) {
+      if (summaryH <= remaining) {
+        const lastIdx = currentPage.length - 1;
+        const last = currentPage[lastIdx];
+        if (last && last.type === "table-slice" && last.elementId === el.id) {
+          currentPage[lastIdx] = { ...last, summary: true };
+          remaining -= summaryH;
+        } else {
+          finishPage();
+          currentPage.push({ elementId: el.id, type: "table-slice", startRow: rowCount, endRow: rowCount, summary: true, renderTop: 0 });
+          remaining -= summaryH;
+        }
+      } else {
+        finishPage();
+        currentPage.push({ elementId: el.id, type: "table-slice", startRow: rowCount, endRow: rowCount, summary: true, renderTop: 0 });
+        remaining -= summaryH;
+      }
+    }
+    applyFollowGroup(el, measured);
+    return idx + 1;
+  }
+  function applyFollowGroup(el, measured) {
+    const members = followMap.get(el.id) ?? [];
+    if (members.length === 0) return;
+    const followH = followGroupHeight(el, members, template, measured);
+    const opts = el.options ?? {};
+    if (followH <= remaining) {
+      const lastIdx = currentPage.length - 1;
+      const last = currentPage[lastIdx];
+      if (last && last.type === "table-slice" && last.elementId === el.id) {
+        currentPage[lastIdx] = {
+          ...last,
+          type: "flow-group",
+          followElementIds: members,
+          // 沿用该切片在本页的定位 top（续片已 stamp 为 0）
+          groupTop: last.renderTop ?? opts.top ?? 0
+        };
+        remaining -= followH;
+        return;
+      }
+    }
+    finishPage();
+    currentPage.push({
+      elementId: el.id,
+      type: "flow-group",
+      startRow: 0,
+      endRow: 0,
+      followElementIds: members,
+      groupTop: 0
+    });
+    remaining -= followH;
+  }
+}
+function buildRowGroups(renderRows, rowCount) {
+  const groups = [];
+  let start = 0;
+  let end = 1;
+  for (let r = 0; r < rowCount; r++) {
+    for (const cell of renderRows[r]?.cells ?? []) {
+      if (!cell.merged && (cell.rowspan ?? 1) > 1) end = Math.max(end, r + cell.rowspan);
+    }
+    if (r + 1 >= end) {
+      groups.push({ start, end: r + 1 });
+      start = r + 1;
+      end = start + 1;
+    }
+  }
+  return groups;
+}
+function specialRowHeight(renderRows, rowHeights, type) {
+  let h = 0;
+  for (let i = 0; i < renderRows.length; i++) {
+    if (renderRows[i]?.type === type) h += rowHeights[i] ?? 0;
+  }
+  return h;
+}
+
+// src/render/html-generator.ts
+function generateHtml(template, pageLayouts, printData, options) {
+  const css = buildPageCss(template);
+  const isMeasure = options?.isMeasurementPass === true;
+  const totalPages = isMeasure ? 1 : pageLayouts.length;
+  const ctx = { codeRenderer: options?.codeRenderer };
+  if (isMeasure) {
+    return generateMeasurementHtml(template, css, ctx);
+  }
+  return generateFinalHtml(template, pageLayouts, css, totalPages, ctx);
+}
+function generateMeasurementHtml(template, css, ctx) {
+  const paper = getPaperDims(template);
+  const contentWidth = paper.width - template.margins.left - template.margins.right;
+  const elementsHtml = template.elements.map((el) => renderElement(el, true, void 0, void 0, ctx)).join("\n");
+  const headerHtml = renderAreaElements(
+    template.header?.elements ?? [],
+    contentWidth,
+    0,
+    // pageIndex placeholder
+    0,
+    // totalPages placeholder
+    ctx
+  );
+  const overlayHtml = renderAreaElements(template.firstPageOverlay?.elements ?? [], contentWidth, void 0, void 0, ctx);
+  let html = `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="UTF-8">
+<style>${css}</style>
+</head>
+<body class="measure-mode">
+<section class="print-page" data-measure-page="0">
+  <div class="page-header">${headerHtml}</div>
+  <div class="first-page-overlay">${overlayHtml}</div>
+  <div class="content-area" style="height:auto;overflow:visible;">
+    ${elementsHtml}
+  </div>
+</section>
+</body>
+</html>`;
+  html = injectSystemVariables(html);
+  return html;
+}
+function generateFinalHtml(template, pageLayouts, css, totalPages, ctx) {
+  const pagesHtml = pageLayouts.map((page) => {
+    const pageNum = page.pageIndex + 1;
+    return renderPage(template, page, pageNum, totalPages, ctx);
+  }).join("\n");
+  let html = `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="UTF-8">
+<style>${css}</style>
+</head>
+<body>
+${pagesHtml}
+</body>
+</html>`;
+  html = injectSystemVariables(html);
+  return html;
+}
+function renderPage(template, page, pageNum, totalPages, ctx) {
+  const paper = getPaperDims(template);
+  const contentWidth = paper.width - template.margins.left - template.margins.right;
+  const headerHtml = renderAreaElements(
+    template.header?.elements ?? [],
+    contentWidth,
+    pageNum,
+    totalPages,
+    ctx
+  );
+  const footerHtml = renderAreaElements(
+    template.footer?.elements ?? [],
+    contentWidth,
+    pageNum,
+    totalPages,
+    ctx
+  );
+  const overlayHtml = page.pageIndex === 0 ? `<div class="first-page-overlay">${renderAreaElements(template.firstPageOverlay?.elements ?? [], contentWidth, void 0, void 0, ctx)}</div>` : "";
+  let contentHtml = page.sections.map((section) => renderSection(section, template, ctx)).join("\n");
+  contentHtml = contentHtml.replace(/\{pageIndex\}/g, String(pageNum));
+  contentHtml = contentHtml.replace(/\{totalPages\}/g, String(totalPages));
+  return `<section class="print-page" data-page="${pageNum}">
+  <div class="page-header">${headerHtml}</div>
+  ${overlayHtml}
+  <div class="content-area">
+    ${contentHtml}
+  </div>
+  <div class="page-footer">${footerHtml}</div>
+</section>`;
+}
+function renderSection(section, template, ctx) {
+  const el = findElement(template, section.elementId);
+  if (!el) {
+    return `<!-- element not found: ${section.elementId} -->`;
+  }
+  if (section.type === "table-slice") {
+    return renderTableSlice(el, section, ctx);
+  }
+  if (section.type === "flow-group") {
+    return renderFlowGroup(el, section, template, ctx);
+  }
+  return renderElement(el, false, void 0, section.renderTop, ctx);
+}
+var V_ALIGN_FLEX = { top: "flex-start", middle: "center", bottom: "flex-end" };
+var H_ALIGN_FLEX = { left: "flex-start", center: "center", right: "flex-end" };
+function textStyle(opts) {
+  const parts = [];
+  if (opts.fontSize) parts.push(`font-size:${opts.fontSize}pt`);
+  if (opts.fontFamily) parts.push(`font-family:${opts.fontFamily}`);
+  if (opts.fontWeight) parts.push(`font-weight:${opts.fontWeight}`);
+  if (opts.color) parts.push(`color:${opts.color}`);
+  if (opts.backgroundColor) parts.push(`background-color:${opts.backgroundColor}`);
+  if (opts.lineHeight) parts.push(`line-height:${opts.lineHeight}pt`);
+  if (opts.letterSpacing) parts.push(`letter-spacing:${opts.letterSpacing}pt`);
+  if (opts.verticalAlign) {
+    parts.push(`display:flex;align-items:${V_ALIGN_FLEX[opts.verticalAlign] ?? "flex-start"}`);
+    parts.push(`justify-content:${H_ALIGN_FLEX[opts.textAlign ?? "left"] ?? "flex-start"}`);
+  }
+  if (opts.textAlign) parts.push(`text-align:${opts.textAlign}`);
+  return parts.length ? parts.join(";") + ";" : "";
+}
+function renderElement(el, isMeasure, containerStyle, overrideTop, ctx) {
+  const opts = el.options ?? {};
+  const left = opts.left ?? 0;
+  const top = overrideTop ?? opts.top ?? 0;
+  const width = opts.width ?? 100;
+  const height = opts.height ?? void 0;
+  const style = containerStyle ?? elementPositionStyle(left, top, width, height);
+  const measureAttr = isMeasure ? ` data-measure-id="${el.id}"` : "";
+  const type = el.type || el.printElementType?.type || "text";
+  switch (type) {
+    case "table":
+      return renderTableElement(el, isMeasure, measureAttr, ctx);
+    case "image":
+      return `<div class="print-element" style="${style}"${measureAttr}>
+  <img src="${esc(opts.src ?? "")}" style="width:100%;height:100%;object-fit:contain;" />
+</div>`;
+    case "barcode":
+    case "qrcode": {
+      const codeValue = String(opts.formatter ?? opts.testData ?? "").trim();
+      const fill = type === "barcode";
+      return `<div class="print-element" style="${style}"${measureAttr}>
+  ${codeImgHtml(codeValue, type, opts, `<span>${esc(codeValue)}</span>`, fill, ctx?.codeRenderer)}
+</div>`;
+    }
+    case "hline":
+      return `<div class="print-element" style="${style};border-top:1px solid #000;height:0;"${measureAttr}></div>`;
+    case "vline":
+      return `<div class="print-element" style="${style};border-left:1px solid #000;width:0;"${measureAttr}></div>`;
+    case "rect":
+      return `<div class="print-element" style="${style};border:${opts.borderWidth ?? 1}px solid ${opts.borderColor ?? "#000"};"${measureAttr}></div>`;
+    case "oval":
+      return `<div class="print-element" style="${style};border:${opts.borderWidth ?? 1}px solid ${opts.borderColor ?? "#000"};border-radius:50%;"${measureAttr}></div>`;
+    case "longText":
+      return `<div class="print-element" style="${style}${textStyle(opts)}overflow:visible;"${measureAttr}>${esc(opts.formatter ?? opts.testData ?? "")}</div>`;
+    case "html":
+      return `<div class="print-element" style="${style}"${measureAttr}>${opts.testData ?? opts.title ?? ""}</div>`;
+    default:
+      return `<div class="print-element" style="${style}${textStyle(opts)}"${measureAttr}>${esc(opts.formatter ?? opts.testData ?? "")}</div>`;
+  }
+}
+function codeImgHtml(value, cellType, opts, fallbackHtml, fill = false, codeRenderer) {
+  if (!value || !codeRenderer) return fallbackHtml;
+  try {
+    const svg = codeRenderer.render(value, cellType, {
+      barcodeType: opts.barcodeType,
+      qrCodeLevel: opts.qrCodeLevel != null ? String(opts.qrCodeLevel) : void 0,
+      showText: opts.hideTitle !== void 0 ? !opts.hideTitle : opts.showBarcodeText,
+      barWidth: typeof opts.barWidth === "number" ? opts.barWidth : void 0,
+      fontSize: typeof opts.fontSize === "number" ? opts.fontSize : void 0
+    });
+    const src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+    const style = fill ? "width:100%;height:100%;object-fit:contain;display:block;margin:auto;" : "max-width:100%;max-height:100%;display:block;margin:auto;";
+    return `<img src="${src}" style="${style}" />`;
+  } catch {
+    return fallbackHtml;
+  }
+}
+function matrixCellStyle(cell, opts) {
+  const parts = [];
+  const fontSize = cell.fontSize ?? opts.tableDefaultFontSize;
+  const color = cell.color ?? opts.tableDefaultColor;
+  const padding = cell.padding ?? opts.tableDefaultPadding ?? 1;
+  if (fontSize) parts.push(`font-size:${fontSize}pt`);
+  if (cell.fontWeight) parts.push(`font-weight:${cell.fontWeight}`);
+  if (color) parts.push(`color:${color}`);
+  if (cell.backgroundColor) parts.push(`background-color:${cell.backgroundColor}`);
+  parts.push(`text-align:${cell.align ?? "left"}`);
+  parts.push(`vertical-align:${cell.valign ?? "middle"}`);
+  parts.push(`padding:${padding}mm`);
+  parts.push(cell.wordWrap === false ? "white-space:nowrap;overflow:hidden" : "word-break:break-all");
+  const b = cell.borders ?? {};
+  for (const side of ["top", "right", "bottom", "left"]) {
+    const border = b[side];
+    parts.push(border ? `border-${side}:${border.width}pt ${border.style} ${border.color}` : `border-${side}:none`);
+  }
+  return parts.join(";");
+}
+function renderMatrixRows(renderRows, start, end, opts, withRowIndex, ctx) {
+  const trs = [];
+  for (let r = start; r < end; r++) {
+    const row = renderRows[r];
+    if (!row) continue;
+    const idxAttr = withRowIndex ? ` data-row-index="${r}"` : "";
+    const tds = row.cells.filter((cell) => !cell.merged).map((cell) => {
+      const span = `${cell.rowspan > 1 ? ` rowspan="${cell.rowspan}"` : ""}${cell.colspan > 1 ? ` colspan="${cell.colspan}"` : ""}`;
+      let inner;
+      if (cell.cellType === "barcode" || cell.cellType === "qrcode") {
+        const cellFill = cell.cellType === "barcode";
+        inner = `<div style="width:100%;height:100%;display:flex;align-items:center;justify-content:center;overflow:hidden;">${codeImgHtml(cell.content, cell.cellType, cell, esc(cell.content), cellFill, ctx?.codeRenderer)}</div>`;
+      } else {
+        inner = esc(cell.content);
+      }
+      return `<td${span} style="${matrixCellStyle(cell, opts)}">${inner}</td>`;
+    }).join("");
+    trs.push(`<tr${idxAttr} style="height:${row.height}mm;">${tds}</tr>`);
+  }
+  return trs.join("\n");
+}
+function matrixTableHtml(el, bodyHtml) {
+  const opts = el.options;
+  const colWidths = opts.tableColWidths ?? [];
+  const colgroup = colWidths.map((w) => `<col style="width:${w}mm;">`).join("");
+  const tableWidth = colWidths.reduce((s, w) => s + w, 0);
+  return `<table class="print-table" data-element-id="${el.id}" style="border-collapse:collapse;table-layout:fixed;width:${tableWidth}mm;">
+    <colgroup>${colgroup}</colgroup>
+    <tbody>${bodyHtml}</tbody>
+  </table>`;
+}
+function renderTableElement(el, isMeasure, measureAttr, ctx) {
+  const opts = el.options;
+  const style = elementPositionStyle(opts.left ?? 0, opts.top ?? 0, opts.width ?? 100);
+  const renderRows = opts._renderRows ?? [];
+  const bodyHtml = renderMatrixRows(renderRows, 0, renderRows.length, opts, isMeasure, ctx);
+  return `<div class="print-element" style="${style};overflow:visible;"${measureAttr}>
+  ${matrixTableHtml(el, bodyHtml)}
+</div>`;
+}
+function renderTableSlice(el, section, ctx) {
+  const opts = el.options;
+  const style = elementPositionStyle(opts.left ?? 0, section.renderTop ?? opts.top ?? 0, opts.width ?? 100);
+  const renderRows = opts._renderRows ?? [];
+  const startRow = section.startRow ?? 0;
+  const endRow = section.endRow ?? renderRows.length;
+  const repeatCount = opts._repeatHeaderCount ?? 0;
+  const repeatHtml = section.repeatHeader && repeatCount > 0 ? renderMatrixRows(renderRows, 0, repeatCount, opts, false, ctx) : "";
+  const bodyHtml = renderMatrixRows(renderRows, startRow, endRow, opts, false, ctx);
+  const subtotalHtml = section.subtotal ? renderSubtotalRows(el, section, opts, ctx) : "";
+  const summaryHtml = section.summary ? renderSummaryRows(el, opts, ctx) : "";
+  return `<div class="print-element" style="${style};overflow:visible;">
+  ${matrixTableHtml(el, `${repeatHtml}
+${bodyHtml}${subtotalHtml}${summaryHtml}`)}
+</div>`;
+}
+function renderSubtotalRows(el, section, opts, ctx) {
+  const templates = opts._subtotalTemplates ?? [];
+  if (templates.length === 0) return "";
+  const dataRowCtx = opts._dataRowCtx ?? [];
+  const dataStartIdx = opts._dataStartIdx ?? 0;
+  const mainData = opts._mainData ?? {};
+  const bodyLen = opts._renderRows?.length ?? 0;
+  const startRow = section.startRow ?? 0;
+  const endRow = section.endRow ?? bodyLen;
+  const dataStart = Math.max(startRow, dataStartIdx);
+  const dataEnd = Math.max(endRow, dataStart);
+  const pageCtx = dataEnd > dataStartIdx ? dataRowCtx.slice(Math.max(dataStart - dataStartIdx, 0), dataEnd - dataStartIdx) : [];
+  const rows = templates.map((tpl) => ({
+    ...tpl,
+    cells: tpl.cells.map((cell) => cell.rawFormatter ? { ...cell, content: evaluateTemplate(cell.rawFormatter, { rows: pageCtx, ...mainData }) } : cell)
+  }));
+  return renderMatrixRows(rows, 0, rows.length, opts, false, ctx);
+}
+function renderSummaryRows(el, opts, ctx) {
+  const summaryRows = opts._summaryRows ?? [];
+  if (summaryRows.length === 0) return "";
+  return renderMatrixRows(summaryRows, 0, summaryRows.length, opts, false, ctx);
+}
+function renderFlowGroup(el, section, template, ctx) {
+  const opts = el.options ?? {};
+  const tableLeft = opts.left ?? 0;
+  const tableWidth = opts.width ?? 100;
+  const groupTop = section.groupTop ?? opts.top ?? 0;
+  const style = `position:absolute;left:${mm(tableLeft)};top:${mm(groupTop)};width:${mm(tableWidth)};overflow:visible;`;
+  const startRow = section.startRow ?? 0;
+  const endRow = section.endRow ?? 0;
+  let sliceHtml = "";
+  if (endRow > startRow || section.subtotal || section.summary) {
+    const renderRows = opts._renderRows ?? [];
+    const repeatCount = opts._repeatHeaderCount ?? 0;
+    const repeatHtml = section.repeatHeader && repeatCount > 0 ? renderMatrixRows(renderRows, 0, repeatCount, opts, false, ctx) : "";
+    const bodyHtml = renderMatrixRows(renderRows, startRow, endRow, opts, false, ctx);
+    const subtotalHtml = section.subtotal ? renderSubtotalRows(el, section, opts, ctx) : "";
+    const summaryHtml = section.summary ? renderSummaryRows(el, opts, ctx) : "";
+    sliceHtml = `<div class="flow-slice" style="position:relative;width:${mm(tableWidth)};overflow:visible;">
+  ${matrixTableHtml(el, `${repeatHtml}
+${bodyHtml}${subtotalHtml}${summaryHtml}`)}
+</div>`;
+  }
+  let cursorBottom = tableDesignBottom(el);
+  const followHtml = (section.followElementIds ?? []).map((id) => {
+    const m = findElement(template, id);
+    if (!m) return "";
+    const mTop = m.options?.top ?? 0;
+    const mLeft = m.options?.left ?? 0;
+    const mWidth = m.options?.width ?? tableWidth;
+    const mHeight = m.options?.height ?? 0;
+    const gap = Math.max(mTop - cursorBottom, 0);
+    cursorBottom = mTop + mHeight;
+    const type = m.type || m.printElementType?.type || "text";
+    const needsHeight = type === "rect" || type === "oval" || type === "image";
+    const flowStyle = [
+      "position:relative",
+      `left:${mm(mLeft - tableLeft)}`,
+      `width:${mm(mWidth)}`,
+      ...needsHeight && mHeight > 0 ? [`height:${mm(mHeight)}`] : [],
+      `margin-top:${mm(gap)}`,
+      "overflow:visible"
+    ].join(";") + ";";
+    return renderElement(m, false, flowStyle, void 0, ctx);
+  }).join("\n");
+  return `<div class="flow-group" style="${style}">
+${sliceHtml}
+${followHtml}
+</div>`;
+}
+function renderAreaElements(elements, _contentWidth, pageIndex, totalPages, ctx) {
+  return elements.map((el) => {
+    let html = renderAreaElement(el, ctx);
+    if (pageIndex !== void 0) {
+      html = html.replace(/\{pageIndex\}/g, String(pageIndex));
+    }
+    if (totalPages !== void 0) {
+      html = html.replace(/\{totalPages\}/g, String(totalPages));
+    }
+    return html;
+  }).join("\n");
+}
+function renderAreaElement(el, ctx) {
+  return renderElement(el, false, void 0, void 0, ctx);
+}
+function findElement(template, id) {
+  return template.elements.find((el) => el.id === id);
+}
+function getPaperDims(template) {
+  return getPaperDimensions(template);
+}
+function esc(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/index.ts
+var TemplateEngine = class {
+  constructor(options) {
+    this.functions = {};
+    if (options?.functions) {
+      this.functions = { ...options.functions };
+    }
+  }
+  registerFunction(name, fn) {
+    this.functions[name] = fn;
+  }
+  evaluate(expression, context) {
+    const tokens = tokenize(expression);
+    const ast = parse(tokens);
+    return evaluate(ast, context, this.functions);
+  }
+  render(template, context) {
+    return compileTemplate(template, this.functions)(context);
+  }
+};
+export {
+  PAPER_DIMENSIONS,
+  TemplateEngine,
+  avg,
+  bindData,
+  buildPageCss,
+  compileTemplate,
+  count,
+  elementPositionStyle,
+  evaluate,
+  evaluateTemplate,
+  formatDate,
+  formatMoney,
+  generateHtml,
+  getByPath,
+  getPaperDimensions,
+  ifFn,
+  injectSystemVariables,
+  max,
+  min,
+  mm,
+  paginate,
+  parse,
+  parseTemplate,
+  renderTemplate,
+  safeEval,
+  setPageIndex,
+  setTotalPages,
+  sum,
+  systemVars,
+  tableDesignBottom,
+  toUpperCaseAmount,
+  tokenize
+};