@worm-vue3-print/core 1.2.2 → 1.3.1

package/dist/chunk-KFRPTLFV.js

@@ -0,0 +1,3819 @@
+// 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/numeric.ts
+var MAX_DIGITS = 20;
+var EXTRA_SCALE = 8;
+function toNumber(value, fallback = 0) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : fallback;
+  if (typeof value === "string") {
+    const s = value.trim();
+    if (s === "") return fallback;
+    const n = Number(s);
+    return Number.isFinite(n) ? n : fallback;
+  }
+  if (value == null) return fallback;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  return fallback;
+}
+function isNumericLike(value) {
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value === "string") {
+    const s = value.trim();
+    return s !== "" && Number.isFinite(Number(s));
+  }
+  return false;
+}
+function normalizeFloat(value) {
+  if (!Number.isFinite(value) || Number.isInteger(value)) return value;
+  if (Math.abs(value) >= 1e15) return value;
+  return Number(value.toPrecision(12));
+}
+function decimalsOf(n) {
+  if (!Number.isFinite(n) || Number.isInteger(n)) return 0;
+  const s = String(n);
+  if (s.includes("e") || s.includes("E")) return 0;
+  const i = s.indexOf(".");
+  return i === -1 ? 0 : s.length - i - 1;
+}
+function rescale(value, decimals) {
+  if (!Number.isFinite(value)) return 0;
+  const d = Math.min(Math.max(decimals, 0), 12);
+  if (d === 0) return Math.round(value);
+  const f = 10 ** d;
+  const scaled = value * f;
+  if (!Number.isFinite(scaled) || Math.abs(scaled) >= 1e15) return normalizeFloat(value);
+  return Math.round(scaled) / f;
+}
+function decimalAdd(left, right) {
+  const a = toNumber(left);
+  const b = toNumber(right);
+  const raw = a + b;
+  return rescale(raw, Math.max(decimalsOf(a), decimalsOf(b)));
+}
+function decimalSubtract(left, right) {
+  const a = toNumber(left);
+  const b = toNumber(right);
+  const raw = a - b;
+  return rescale(raw, Math.max(decimalsOf(a), decimalsOf(b)));
+}
+function decimalMultiply(left, right) {
+  const a = toNumber(left);
+  const b = toNumber(right);
+  const raw = a * b;
+  return rescale(raw, decimalsOf(a) + decimalsOf(b));
+}
+function decimalDivide(left, right) {
+  const a = toNumber(left);
+  const b = toNumber(right);
+  if (b === 0) return 0;
+  return normalizeFloat(a / b);
+}
+function decimalModulo(left, right) {
+  const a = toNumber(left);
+  const b = toNumber(right);
+  if (b === 0) return 0;
+  return normalizeFloat(a % b);
+}
+function normalizeDigits(digits) {
+  if (digits === void 0 || digits === null) return 2;
+  const d = Math.trunc(toNumber(digits, 2));
+  if (!Number.isFinite(d)) return 2;
+  return Math.min(Math.max(d, -MAX_DIGITS), MAX_DIGITS);
+}
+function roundTo(value, digits, mode) {
+  const n = toNumber(value, 0);
+  const d = normalizeDigits(digits);
+  if (n === 0) return 0;
+  if (Math.abs(n) >= 1e21) return normalizeFloat(n);
+  const scale = Math.max(d, 0) + EXTRA_SCALE;
+  const fixed = n.toFixed(scale);
+  if (!/^-?\d+(\.\d+)?$/.test(fixed)) return normalizeFloat(n);
+  const negative = fixed.startsWith("-");
+  const digitsStr = fixed.replace("-", "").replace(".", "");
+  let scaled = BigInt(digitsStr || "0");
+  if (negative) scaled = -scaled;
+  const pow10 = 10n ** BigInt(scale - d);
+  const sign = scaled < 0n ? -1n : 1n;
+  const abs = scaled < 0n ? -scaled : scaled;
+  let q = abs / pow10;
+  const r = abs % pow10;
+  const doubled = 2n * r;
+  if (mode === "up") {
+    if (r !== 0n) q += 1n;
+  } else if (mode !== "down" && doubled >= pow10) {
+    if (doubled > pow10 || mode === "half-up" || q % 2n === 1n) q += 1n;
+  }
+  const result = sign * q;
+  return normalizeFloat(d >= 0 ? Number(result) / 10 ** d : Number(result) * 10 ** -d);
+}
+
+// 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) {
+    // 数值运算统一走十进制精确实现：消除 0.1 + 0.2 类浮点噪声、字符串数字按数值处理、除零兜底 0
+    case "+":
+      return isNumericOperands(left, right) ? decimalAdd(left, right) : concatOperands(left, right);
+    case "-":
+      return decimalSubtract(left, right);
+    case "*":
+      return decimalMultiply(left, right);
+    case "/":
+      return decimalDivide(left, right);
+    case "%":
+      return decimalModulo(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 decimalSubtract(0, arg);
+    case "+":
+      return toNumber(arg);
+    case "!":
+      return !arg;
+    default:
+      throw new Error(`\u672A\u77E5\u4E00\u5143\u8FD0\u7B97\u7B26: ${node.op}`);
+  }
+}
+function concatOperands(left, right) {
+  return `${left == null ? "" : String(left)}${right == null ? "" : String(right)}`;
+}
+function isNumericOperands(left, right) {
+  const l = operandKind(left);
+  const r = operandKind(right);
+  if (l === "other" || r === "other") return false;
+  return l === "num" || r === "num";
+}
+function operandKind(value) {
+  if (value == null || value === "") return "neutral";
+  if (isNumericLike(value)) return "num";
+  return "other";
+}
+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 pad3 = (n) => String(n).padStart(2, "0");
+  return fmt.replace("YYYY", String(date.getFullYear())).replace("MM", pad3(date.getMonth() + 1)).replace("DD", pad3(date.getDate())).replace("HH", pad3(date.getHours())).replace("mm", pad3(date.getMinutes())).replace("ss", pad3(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/functions/math.ts
+function addNumbers(...values) {
+  return values.reduce((acc, v) => decimalAdd(acc, v), 0);
+}
+function subtractNumbers(...values) {
+  if (values.length === 0) return 0;
+  return values.slice(1).reduce((acc, v) => decimalSubtract(acc, v), decimalAdd(values[0], 0));
+}
+function multiplyNumbers(...values) {
+  if (values.length === 0) return 0;
+  return values.reduce((acc, v) => decimalMultiply(acc, v), 1);
+}
+function divideNumbers(a, b) {
+  return decimalDivide(a, b);
+}
+function round(value, digits) {
+  return roundTo(value, digits, "half-up");
+}
+function roundUp(value, digits) {
+  return roundTo(value, digits, "up");
+}
+function roundDown(value, digits) {
+  return roundTo(value, digits, "down");
+}
+function roundHalfEven(value, digits) {
+  return roundTo(value, digits, "half-even");
+}
+
+// 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,
+  LEN: (s) => String(s).length,
+  // 四则运算（与 +/-/*// 运算符同一套数值语义，供不方便写运算符的场景使用）
+  ADD: addNumbers,
+  SUB: subtractNumbers,
+  MUL: multiplyNumbers,
+  DIV: divideNumbers,
+  // 数值修约
+  ROUND: round,
+  ROUNDUP: roundUp,
+  CEIL: roundUp,
+  ROUNDDOWN: roundDown,
+  FLOOR: roundDown,
+  ROUNDBANK: roundHalfEven
+};
+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, fontBaseUrl) {
+  const data = { ...resolveSystemVariables(), ...printData ?? {} };
+  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));
+  const fontBase = fontBaseUrl ?? baseUrl;
+  if (fontBase && bound.fonts?.length) {
+    const prefix = fontBase.replace(/\/+$/, "");
+    bound.fonts = bound.fonts.map((font) => ({
+      ...font,
+      files: (font.files ?? []).map((file) => ({
+        ...file,
+        // 绝对 URL（含协议相对 //）原样使用
+        url: file.url?.startsWith("/") && !file.url.startsWith("//") ? prefix + file.url : file.url
+      }))
+    }));
+  }
+  return bound;
+}
+function bindElement(el, data, baseUrl) {
+  const cloned = { ...el, options: { ...el.options } };
+  if (typeof cloned.options.formatter === "string") {
+    const raw = cloned.options.formatter;
+    if (referencesPageNumbers(raw)) {
+      cloned.options.rawFormatter = raw;
+    } else {
+      cloned.options.formatter = evaluateTemplate(raw, 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) => {
+          return resolveCellText(cell, ctx);
+        }));
+        dataRowCtx.push(ctx);
+      }
+      continue;
+    }
+    if (mode === "dynamic" && row.type === "subtotal") {
+      const tpl = makeRenderRow(row, (cell) => resolveCellText(cell, { rows: summaryRows, ...data }), true);
+      subtotalTemplates.push(tpl);
+      renderRows.push(tpl);
+      continue;
+    }
+    if (mode === "dynamic" && row.type === "summary") {
+      const summaryRow = makeRenderRow(row, (cell) => resolveCellText(cell, { rows: summaryRows, ...data }));
+      summaryRenderRows.push(summaryRow);
+      renderRows.push(summaryRow);
+      continue;
+    }
+    renderRows.push(makeRenderRow(row, (cell) => resolveCellText(cell, 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 resolveCellText(cell, ctx) {
+  const formatter = cell.formatter;
+  if (!formatter) return "";
+  if (referencesPageNumbers(formatter)) return formatter;
+  return evaluateTemplate(formatter, ctx);
+}
+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）与引用页码的单元格都保留原始表达式：前者按当页数据行重算，后者按当页页码重算
+      ...(keepRaw || referencesPageNumbers(cell.formatter)) && !cell.merged ? { rawFormatter: cell.formatter ?? "" } : {},
+      cellType: cell.cellType,
+      barcodeType: cell.barcodeType,
+      qrCodeLevel: cell.qrCodeLevel,
+      showBarcodeText: cell.showBarcodeText,
+      printerDpi: cell.printerDpi,
+      fit: cell.fit,
+      maxWidth: cell.maxWidth,
+      maxHeight: cell.maxHeight,
+      rowspan: cell.rowspan ?? 1,
+      colspan: cell.colspan ?? 1,
+      merged: cell.merged === true,
+      align: cell.align,
+      valign: cell.valign,
+      fontSize: cell.fontSize,
+      fontFamily: cell.fontFamily,
+      fontWeight: cell.fontWeight,
+      color: cell.color,
+      backgroundColor: cell.backgroundColor,
+      borders: cell.borders,
+      padding: cell.padding,
+      wordWrap: cell.wordWrap,
+      textFit: cell.textFit,
+      shrinkMinFontSize: cell.shrinkMinFontSize
+    }))
+  };
+}
+function countRepeatHeader(rows) {
+  const headerCount = countLeadingHeaderRows(rows);
+  if (headerCount === 0) return 0;
+  const enabled = rows.slice(0, headerCount).some((row) => row.repeatOnPage === true);
+  if (!enabled) return 0;
+  return alignToRowspanBoundary(rows, headerCount);
+}
+function countLeadingHeaderRows(rows) {
+  let n = 0;
+  for (const row of rows) {
+    if (row?.type !== "header") break;
+    n++;
+  }
+  return n;
+}
+function isRowspanComplete(rows, n) {
+  for (let r = 0; r < n; r++) {
+    for (const cell of rows[r]?.cells ?? []) {
+      if (cell?.merged) continue;
+      if (r + (cell?.rowspan ?? 1) > n) return false;
+    }
+  }
+  return true;
+}
+function alignToRowspanBoundary(rows, max2) {
+  for (let n = max2; n >= 1; n--) {
+    if (isRowspanComplete(rows, n)) return n;
+  }
+  return 1;
+}
+var pad2 = (n) => String(n).padStart(2, "0");
+function resolveSystemVariables(now = /* @__PURE__ */ new Date(), page = {}) {
+  return {
+    printDate: `${now.getFullYear()}-${pad2(now.getMonth() + 1)}-${pad2(now.getDate())}`,
+    printTime: `${pad2(now.getHours())}:${pad2(now.getMinutes())}:${pad2(now.getSeconds())}`,
+    pageIndex: page.pageIndex ?? 1,
+    totalPages: page.totalPages ?? 1
+  };
+}
+function referencesPageNumbers(expr) {
+  return typeof expr === "string" && /\b(pageIndex|totalPages)\b/.test(expr);
+}
+function injectSystemVariables(html, now = /* @__PURE__ */ new Date()) {
+  const { printDate, printTime } = resolveSystemVariables(now);
+  return html.replace(/\{printDate\}/g, printDate).replace(/\{printTime\}/g, printTime);
+}
+
+// src/print/fonts.ts
+function buildFontFaceCss(fonts) {
+  const blocks = [];
+  for (const font of fonts ?? []) {
+    const family = font?.family?.trim();
+    if (!family) continue;
+    const quoted = `"${family.replace(/"/g, "")}"`;
+    for (const file of font.files ?? []) {
+      const url = file?.url?.trim();
+      if (!url) continue;
+      const weight = Number.isFinite(file.weight) ? Number(file.weight) : 400;
+      const style = file.style === "italic" ? "italic" : "normal";
+      blocks.push(
+        `@font-face{font-family:${quoted};src:url("${url}")${fontFormatHint(url)};font-weight:${weight};font-style:${style};font-display:block;}`
+      );
+    }
+  }
+  return blocks.length ? `${blocks.join("")}
+` : "";
+}
+function fontFormatHint(url) {
+  const path = url.split(/[?#]/)[0].toLowerCase();
+  if (path.endsWith(".woff2")) return ' format("woff2")';
+  if (path.endsWith(".woff")) return ' format("woff")';
+  if (path.endsWith(".ttf")) return ' format("truetype")';
+  if (path.endsWith(".otf")) return ' format("opentype")';
+  return "";
+}
+var FALLBACK_FONT_STACK = [
+  '"Microsoft YaHei"',
+  '"PingFang SC"',
+  '"Helvetica Neue"',
+  "Arial",
+  "sans-serif"
+];
+function escapeInlineStyleValue(cssValue) {
+  return cssValue.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function toFontFamilyStack(family) {
+  const name = family?.trim();
+  if (!name) return FALLBACK_FONT_STACK.join(", ");
+  const head = name.includes(",") ? name : `"${name.replace(/"/g, "")}"`;
+  return [head, ...FALLBACK_FONT_STACK].join(", ");
+}
+
+// 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 },
+  // 针式打印纸（241 系列等分）：11 英寸整张 279.4mm 按等分取整
+  DOT_FULL: { width: 241, height: 279.4 },
+  DOT_HALF: { width: 241, height: 139.7 },
+  DOT_THIRD: { width: 241, height: 93.1 },
+  // 标签纸
+  LABEL_80X60: { width: 80, height: 60 },
+  LABEL_60X40: { width: 60, height: 40 },
+  LABEL_40X30: { width: 40, height: 30 },
+  // 小票纸（热敏卷纸）：高度仅为设计画布高度，出纸按内容推导
+  THERMAL_57: { width: 57, height: 297 },
+  THERMAL_80: { width: 80, height: 297 },
+  THERMAL_110: { width: 110, height: 297 },
+  CUSTOM: { width: 210, height: 297 },
+  // 连续纸：默认 80mm 热敏；高度仅为设计画布高度，出纸按内容推导
+  CONTINUOUS: { width: 80, height: 297 }
+};
+var CONTINUOUS_PAPER_SIZES = /* @__PURE__ */ new Set([
+  "CONTINUOUS",
+  "THERMAL_57",
+  "THERMAL_80",
+  "THERMAL_110"
+]);
+function isContinuousPaperSize(paperSize) {
+  return CONTINUOUS_PAPER_SIZES.has(paperSize);
+}
+function getPaperDimensions(template) {
+  const continuous = isContinuousPaperSize(template.paperSize);
+  const base = template.paperSize === "CUSTOM" || continuous ? {
+    width: template.customWidth ?? PAPER_DIMENSIONS[template.paperSize].width,
+    height: template.customHeight ?? PAPER_DIMENSIONS[template.paperSize].height
+  } : PAPER_DIMENSIONS[template.paperSize];
+  if (template.orientation === "landscape" && !continuous) {
+    return { width: base.height, height: base.width };
+  }
+  return { ...base };
+}
+function getOutputPaperDimensions(template) {
+  const continuous = isContinuousPaperSize(template.paperSize);
+  if (continuous || template.tiling?.enabled === true) {
+    return getPaperDimensions(template);
+  }
+  const design = getPaperDimensions(template);
+  const swap = template.outputRotation === 90 || template.outputRotation === 270;
+  return swap ? { width: design.height, height: design.width } : design;
+}
+function getOutputRotationAngle(template) {
+  const continuous = isContinuousPaperSize(template.paperSize);
+  if (continuous || template.tiling?.enabled === true) return 0;
+  return template.outputRotation ?? 0;
+}
+function isContinuousPaper(template) {
+  return isContinuousPaperSize(template.paperSize);
+}
+
+// src/render/css-builder.ts
+function mm(value) {
+  return `${value}mm`;
+}
+function resolveOuterPaper(template, pageHeightMm) {
+  const out = getOutputPaperDimensions(template);
+  return pageHeightMm && pageHeightMm > 0 && isContinuousPaper(template) ? { width: out.width, height: pageHeightMm } : out;
+}
+function resolveAreaPaper(template, pageHeightMm) {
+  const design = getPaperDimensions(template);
+  return pageHeightMm && pageHeightMm > 0 && isContinuousPaper(template) ? { width: design.width, height: pageHeightMm } : design;
+}
+function screenBlock() {
+  return `
+/* \u2500\u2500 \u5168\u5C40\u91CD\u7F6E \u2500\u2500 */
+* { margin: 0; padding: 0; box-sizing: border-box; }
+
+/* \u6253\u5370\u5FC5\u987B\u4FDD\u7559\u5143\u7D20\u80CC\u666F\u8272\uFF08Chromium \u9ED8\u8BA4\u5254\u9664\u80CC\u666F\uFF0C\u9700\u663E\u5F0F\u58F0\u660E\uFF09 */
+* { -webkit-print-color-adjust: exact; print-color-adjust: exact; }
+
+body { font-family: ${FALLBACK_FONT_STACK.join(", ")}; }
+
+/* \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; }
+}
+`;
+}
+function watermarkBlock() {
+  return `
+/* \u2500\u2500 \u6C34\u5370\u5C42\uFF1A\u8986\u76D6\u6574\u9875\u3001\u4F4D\u4E8E\u6240\u6709\u5185\u5BB9\u4E4B\u4E0B\uFF08\u663E\u5F0F\u77E2\u91CF\u74E6\u7247\uFF0C\u7981\u6B62\u7528 CSS \u5E73\u94FA\u80CC\u666F\uFF1A
+       Chromium \u4F1A\u628A\u5B83\u7F16\u8BD1\u6210 PDF \u5E73\u94FA\u56FE\u6848\uFF0C\u51FA\u7EB8\u94FE\u8DEF\u7684 RIP \u4F1A\u5FFD\u7565\u56FE\u6848\u77E9\u9635\u5BFC\u81F4\u6C34\u5370\u653E\u5927/\u9519\u4F4D\uFF09 \u2500\u2500 */
+.watermark-layer {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  z-index: 0;
+  pointer-events: none;
+  overflow: hidden;
+}
+/* \u5355\u5757\u6C34\u5370\u74E6\u7247\uFF1A\u4F4D\u7F6E/\u5C3A\u5BF8\u7531 core \u7684\u74E6\u7247\u7F51\u683C\u7ED9\u51FA\uFF08mm\uFF09 */
+.watermark-tile {
+  position: absolute;
+  pointer-events: none;
+}
+`;
+}
+function elementBlock() {
+  return `
+/* \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;
+}
+`;
+}
+function pageRuleBlock(paper) {
+  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; }
+`;
+}
+function buildRotorCss(area, margins, angle) {
+  const base = `
+/* \u2500\u2500 \u51FA\u7EB8\u8F6C\u5B50\uFF1A\u8BBE\u8BA1\u7A3F\u6574\u9875\u65CB\u8F6C ${angle}\xB0 \u586B\u5165\u51FA\u7EB8\u7EB8\u5F20 \u2500\u2500 */
+.print-page-rotor {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: ${mm(area.width)};
+  height: ${mm(area.height)};
+  padding: ${mm(margins.top)} ${mm(margins.right)} ${mm(margins.bottom)} ${mm(margins.left)};
+  box-sizing: border-box;
+  transform-origin: 0 0;
+}`;
+  if (angle === 0) return base.trim();
+  const transforms = {
+    90: `translate(${mm(area.height)}, 0mm) rotate(90deg)`,
+    180: `translate(${mm(area.width)}, ${mm(area.height)}) rotate(180deg)`,
+    270: `translate(0mm, ${mm(area.width)}) rotate(270deg)`
+  };
+  const tf = transforms[angle];
+  return [
+    base.trim(),
+    `.print-page-rotor-${angle} {
+  transform: ${tf};
+}`
+  ].join("\n");
+}
+function pageGeometryBlock(template, outerPaper, pageSel, rotated) {
+  const { top: mt, right: mr, bottom: mb, left: ml } = template.margins;
+  const padding = rotated ? "0" : `${mm(mt)} ${mm(mr)} ${mm(mb)} ${mm(ml)}`;
+  return `
+/* \u2500\u2500 \u7EB8\u5F20\u9875\u9762 \u2500\u2500 */
+${pageSel} {
+  width: ${mm(outerPaper.width)};
+  min-height: ${mm(outerPaper.height)};
+  background: ${template.pageBackground ?? "#fff"};
+  padding: ${padding};
+  position: relative;
+  page-break-after: always;
+  overflow: hidden;
+}
+.print-page:last-child {
+  page-break-after: auto;
+}
+`;
+}
+function areaGeometryBlock(template, paper, desc) {
+  const { right: mr, left: ml } = template.margins;
+  const { bottom: mb } = 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 \u9875\u7709 \u2500\u2500 */
+${desc}.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
+   \u7528\u663E\u5F0F top \u5B9A\u4F4D\u5230\u300C\u7EB8\u9AD8 - \u4E0B\u8FB9\u8DDD - \u9875\u811A\u9AD8\u300D\uFF0C\u4FDD\u8BC1\u4E0B\u8FB9\u8DDD\u751F\u6548\u3001
+   \u4E0E\u8BBE\u8BA1\u5668 CanvasPaper \u7684\u4E09\u533A\u51E0\u4F55\u4E00\u81F4\u3002 */
+${desc}.page-footer {
+  width: ${mm(contentWidth)};
+  height: ${mm(footerH)};
+  position: absolute;
+  top: ${mm(paper.height - mb - footerH)};
+  left: 0;
+}
+
+/* \u2500\u2500 \u5185\u5BB9\u533A \u2500\u2500 */
+${desc}.content-area {
+  width: ${mm(contentWidth)};
+  position: relative;
+  overflow: visible;
+}
+
+/* \u2500\u2500 \u9996\u9875\u53E0\u52A0\u533A\u57DF \u2500\u2500 */
+${desc}.first-page-overlay {
+  width: ${mm(contentWidth)};
+  height: ${mm(overlayH)};
+  position: relative;
+}
+`;
+}
+function buildBasePageCss() {
+  return [screenBlock(), watermarkBlock(), elementBlock()].join("").trim();
+}
+function buildPageRuleCss(template, pageHeightMm) {
+  return pageRuleBlock(resolveOuterPaper(template, pageHeightMm)).trim();
+}
+function buildPageGeometryCss(template, scope, pageHeightMm) {
+  const angle = getOutputRotationAngle(template);
+  const rotated = angle !== 0;
+  const outer = resolveOuterPaper(template, pageHeightMm);
+  const area = resolveAreaPaper(template, pageHeightMm);
+  const pageSel = scope ? `${scope}.print-page` : ".print-page";
+  const desc = scope ? `${scope} ` : "";
+  return [
+    pageGeometryBlock(template, outer, pageSel, rotated),
+    areaGeometryBlock(template, area, desc),
+    ...rotated ? [buildRotorCss(area, template.margins, angle)] : []
+  ].join("").trim();
+}
+function buildPageCss(template, pageHeightMm) {
+  const angle = getOutputRotationAngle(template);
+  const rotated = angle !== 0;
+  const outer = resolveOuterPaper(template, pageHeightMm);
+  const area = resolveAreaPaper(template, pageHeightMm);
+  return [
+    pageRuleBlock(outer),
+    screenBlock(),
+    pageGeometryBlock(template, outer, ".print-page", rotated),
+    watermarkBlock(),
+    areaGeometryBlock(template, area, ""),
+    elementBlock(),
+    ...rotated ? [buildRotorCss(area, template.margins, angle)] : []
+  ].join("").trim();
+}
+var COPY_BREAK_CSS = ".print-copy:not(:last-child){break-after:page;page-break-after:always;}";
+function buildBatchPageCss(template, copies) {
+  if (!isContinuousPaper(template)) {
+    return `${buildPageCss(template)}
+${COPY_BREAK_CSS}`;
+  }
+  const { bottom: mb } = template.margins;
+  const footerH = template.footer?.height ?? 0;
+  const width = getPaperDimensions(template).width;
+  const base = buildPageCss(template, copies[0]?.heightMm);
+  const scoped = copies.map((copy, i) => {
+    const h = copy.heightMm;
+    const rules = [
+      `@page copy${i} { size: ${mm(width)} ${h ? mm(h) : "auto"}; margin: 0; }`,
+      `.print-copy-${i} { page: copy${i}; }`
+    ];
+    if (h) {
+      rules.push(`.print-copy-${i} .print-page { min-height: ${mm(h)}; }`);
+      rules.push(`.print-copy-${i} .page-footer { top: ${mm(h - mb - footerH)}; }`);
+    }
+    return rules.join("\n");
+  }).join("\n");
+  return `${base}
+${scoped}
+${COPY_BREAK_CSS}`;
+}
+function buildSheetPageCss(layout) {
+  return `
+/* \u2500\u2500 \u62FC\u7248\u7EB8\u5F20\uFF1A@page \u5C3A\u5BF8 = \u76EE\u6807\u7EB8\u3002\u670D\u52A1\u7AEF/\u5BA2\u6237\u7AEF\u94FE\u8DEF\u4EE5 paperMm \u663E\u5F0F\u5B9A\u5C3A\u5BF8\u3001\u4E0D\u770B\u8FD9\u91CC\uFF0C
+      \u4F46\u6D4F\u89C8\u5668\u94FE\u8DEF\u53EA\u770B @page\uFF0C\u6545\u8FD9\u6761\u662F\u786C\u9700\u6C42 \u2500\u2500 */
+@page { size: ${mm(layout.sheet.width)} ${mm(layout.sheet.height)}; margin: 0; }
+
+/* \u2500\u2500 \u4E00\u5F20\u76EE\u6807\u7EB8 \u2500\u2500 */
+.print-sheet {
+  width: ${mm(layout.sheet.width)};
+  height: ${mm(layout.sheet.height)};
+  position: relative;
+  overflow: hidden;
+  break-after: page;
+  page-break-after: always;
+}
+.print-sheet:last-child { break-after: auto; page-break-after: auto; }
+
+/* \u2500\u2500 \u4E00\u683C\uFF1A\u7EDD\u5BF9\u5B9A\u4F4D\uFF0C\u4F4D\u7F6E\u7531 tilePosition() \u4EE5\u884C\u5185 style \u7ED9\u51FA \u2500\u2500 */
+.print-tile {
+  position: absolute;
+  width: ${mm(layout.tile.width)};
+  height: ${mm(layout.tile.height)};
+  overflow: hidden;
+}
+/* \u9632\u5FA1\u6027\u58F0\u660E\uFF1A\u7EDD\u5BF9\u5B9A\u4F4D + overflow:hidden \u5BB9\u5668\u5185\u7684\u540E\u4EE3\u4E0D\u4EA7\u751F\u5206\u9875\u70B9\uFF0C\u5F53\u524D\u5E03\u5C40\u4E0B\u65E0\u5B9E\u9645\u4F5C\u7528\uFF1B
+   \u82E5\u5C06\u6765\u6539\u7528 flex/grid \u5E03\u5C40\uFF0C\u683C\u5185\u6574\u9875\u4F1A\u91CD\u65B0\u53C2\u4E0E\u5206\u9875\uFF0C\u6545\u4FDD\u7559 */
+.print-tile > .print-page { break-after: auto; page-break-after: auto; }
+
+@media screen {
+  .print-sheet { margin: 12px auto; box-shadow: 0 2px 12px rgba(0, 0, 0, 0.18); }
+  /* \u5FC5\u9700\uFF1A\u62B5\u6D88\u6807\u7B7E CSS \u7684 @media screen{.print-page{margin:12px auto}}\uFF0C
+     \u5426\u5219\u8BBE\u8BA1\u5668\u9884\u89C8\u9519\u4F4D 3.17mm\u3001\u4E0E\u51FA\u7EB8\u4E0D\u4E00\u81F4 */
+  .print-tile > .print-page { margin: 0; box-shadow: none; }
+}
+`;
+}
+function elementPositionStyle(left, top, width, height, zIndex) {
+  const parts = [
+    `position:absolute`,
+    `left:${mm(left)}`,
+    `top:${mm(top)}`,
+    `width:${mm(width)}`
+  ];
+  if (height !== void 0 && height > 0) {
+    parts.push(`height:${mm(height)}`);
+  }
+  if (zIndex !== void 0) {
+    parts.push(`z-index:${zIndex}`);
+  }
+  return parts.join(";") + ";";
+}
+
+// src/designer/utils/units.ts
+function ptToMm(pt) {
+  return pt / 2.83464566929;
+}
+function pxToMm(px) {
+  return px * (25.4 / 96);
+}
+function mmToPx(mm2) {
+  return mm2 * (96 / 25.4);
+}
+
+// src/render/text-fit.ts
+var DEFAULT_SHRINK_MIN_FONT_SIZE_PT = 6;
+var MIN_SHRINK_FONT_SIZE_PT = 1;
+var VALID_FITS = ["clip", "shrink", "autoHeight"];
+function normalizeFit(value) {
+  return typeof value === "string" && VALID_FITS.includes(value) ? value : void 0;
+}
+var ELEMENT_DEFAULT_FIT = {
+  text: "clip",
+  longText: "autoHeight"
+};
+function resolveElementTextFit(type, opts) {
+  return normalizeFit(opts?.textFit) ?? ELEMENT_DEFAULT_FIT[type] ?? "clip";
+}
+function resolveCellTextFit(cell) {
+  return normalizeFit(cell?.textFit) ?? (cell?.wordWrap === false ? "clip" : "autoHeight");
+}
+function resolveShrinkMinFontSize(pt) {
+  if (typeof pt !== "number" || !Number.isFinite(pt) || pt <= 0) return DEFAULT_SHRINK_MIN_FONT_SIZE_PT;
+  return Math.max(pt, MIN_SHRINK_FONT_SIZE_PT);
+}
+function roundFontSize(pt) {
+  return Math.round(pt * 100) / 100;
+}
+function floorFontSize(pt) {
+  return Math.floor(pt * 100) / 100;
+}
+function cellFitKey(elementId, kind, rowIndex, colIndex) {
+  return `${elementId}#${kind}#${rowIndex}:${colIndex}`;
+}
+function parseCellFitKey(key) {
+  const first = key.indexOf("#");
+  if (first < 0) return void 0;
+  const last = key.lastIndexOf("#");
+  const kind = key.slice(first + 1, last);
+  if (kind !== "b" && kind !== "st" && kind !== "sm") return void 0;
+  const [rowIndex, colIndex] = key.slice(last + 1).split(":").map(Number);
+  if (!Number.isFinite(rowIndex) || !Number.isFinite(colIndex)) return void 0;
+  return { elementId: key.slice(0, first), kind, rowIndex, colIndex };
+}
+function cellFitWidthMm(colWidths, colIndex, cell, defaultPadding = 1) {
+  const span = Math.max(cell?.colspan ?? 1, 1);
+  let width = 0;
+  for (let i = 0; i < span; i++) {
+    width += colWidths[colIndex + i] ?? 0;
+  }
+  if (width <= 0) return 0;
+  const padding = cell?.padding ?? defaultPadding;
+  const borderMm = (ptToMm(cell?.borders?.left?.width ?? 0) + ptToMm(cell?.borders?.right?.width ?? 0)) / 2;
+  return Math.max(width - padding * 2 - borderMm, 0.5);
+}
+function cellFitCapMm(rows, rowIndex, cell, defaultPadding = 1) {
+  const span = Math.max(cell?.rowspan ?? 1, 1);
+  let height = 0;
+  for (let i = 0; i < span; i++) {
+    height += rows[rowIndex + i]?.height ?? 8;
+  }
+  const padding = cell?.padding ?? defaultPadding;
+  const borderMm = (ptToMm(cell?.borders?.top?.width ?? 0) + ptToMm(cell?.borders?.bottom?.width ?? 0)) / 2;
+  return Math.max(height - padding * 2 - borderMm, 0.5);
+}
+
+// src/render/watermark.ts
+var PX_PER_MM = 96 / 25.4;
+var MM_PER_PX = 25.4 / 96;
+var WATERMARK_DEFAULTS = {
+  color: "#cccccc",
+  opacity: 0.15,
+  rotate: -30,
+  /** 瓦片默认尺寸（px）：决定平铺疏密，默认 260×180 */
+  tileWidth: 260,
+  tileHeight: 180,
+  /** 瓦片下限（px），防止文字裁剪/异常平铺 */
+  minTileWidth: 140,
+  minTileHeight: 100,
+  /** 瓦片字号固定 16px：密度只改变平铺疏密，不改字体大小 */
+  fontSize: 16
+};
+var WATERMARK_DENSITY_PRESETS = {
+  dense: { width: 200, height: 120, label: "\u5BC6" },
+  medium: { width: 260, height: 180, label: "\u4E2D\uFF08\u9ED8\u8BA4\uFF09" },
+  loose: { width: 340, height: 260, label: "\u758F" }
+};
+function clampTile(value, fallback, min2) {
+  const n = typeof value === "number" && Number.isFinite(value) ? value : fallback;
+  return Math.max(min2, Math.round(n));
+}
+function resolveTileSize(wm) {
+  return {
+    width: clampTile(wm?.tileWidth, WATERMARK_DEFAULTS.tileWidth, WATERMARK_DEFAULTS.minTileWidth),
+    height: clampTile(wm?.tileHeight, WATERMARK_DEFAULTS.tileHeight, WATERMARK_DEFAULTS.minTileHeight)
+  };
+}
+function isWatermarkVisible(wm) {
+  if (!wm) return false;
+  if (!wm.mode || wm.mode === "fixed") {
+    return !!wm.content && wm.content.trim().length > 0;
+  }
+  return !!wm.binding && wm.binding.trim().length > 0;
+}
+function resolveWatermarkText(wm, printData, systemVars2) {
+  if (!wm) return "";
+  let text = "";
+  if (!wm.mode || wm.mode === "fixed") {
+    text = wm.content ?? "";
+  } else if (typeof wm.binding === "string" && wm.binding.trim()) {
+    const binding = wm.binding.trim();
+    const data = Array.isArray(printData) ? printData[0] ?? {} : printData ?? {};
+    const ctx = { ...resolveSystemVariables(), ...systemVars2, ...data };
+    let resolved;
+    if (binding.includes("{")) {
+      resolved = evaluateTemplate(binding, ctx);
+    } else {
+      try {
+        resolved = safeEval(binding, ctx);
+      } catch {
+        resolved = void 0;
+      }
+      if (resolved == null || typeof resolved === "object") {
+        resolved = getByPath(data, binding);
+      }
+    }
+    if (resolved != null && typeof resolved !== "object" && String(resolved) !== binding) {
+      text = String(resolved);
+    } else {
+      text = wm.testData ?? `[${wm.binding}]`;
+    }
+  }
+  if (wm.timestamp && text) {
+    text = `${text} ${formatTimestamp(wm.format)}`;
+  }
+  return text;
+}
+function pad(n) {
+  return String(n).padStart(2, "0");
+}
+function formatTimestamp(format) {
+  const fmt = format && format.trim() ? format : "YYYY-MM-DD HH:mm";
+  const d = /* @__PURE__ */ new Date();
+  const map = {
+    YYYY: String(d.getFullYear()),
+    MM: pad(d.getMonth() + 1),
+    DD: pad(d.getDate()),
+    HH: pad(d.getHours()),
+    mm: pad(d.getMinutes()),
+    ss: pad(d.getSeconds())
+  };
+  return fmt.replace(/YYYY|MM|DD|HH|mm|ss/g, (k) => map[k] ?? k);
+}
+function round4(n) {
+  return Math.round(n * 1e4) / 1e4;
+}
+function escXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function resolveWatermarkLayout(wm, printData, paperMm, systemVars2) {
+  if (!isWatermarkVisible(wm)) return null;
+  const text = resolveWatermarkText(wm, printData, systemVars2);
+  if (!text) return null;
+  const tile = resolveTileSize(wm);
+  const tileWidthMm = round4(tile.width * MM_PER_PX);
+  const tileHeightMm = round4(tile.height * MM_PER_PX);
+  const paper = {
+    width: Math.max(0, Number.isFinite(paperMm?.width) ? paperMm.width : 0),
+    height: Math.max(0, Number.isFinite(paperMm?.height) ? paperMm.height : 0)
+  };
+  const columns = Math.max(1, Math.ceil(paper.width / tileWidthMm));
+  const rows = Math.max(1, Math.ceil(paper.height / tileHeightMm));
+  const tiles = [];
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < columns; c++) {
+      tiles.push({
+        leftMm: round4(c * tileWidthMm),
+        topMm: round4(r * tileHeightMm),
+        widthMm: tileWidthMm,
+        heightMm: tileHeightMm
+      });
+    }
+  }
+  return {
+    text,
+    color: wm?.color || WATERMARK_DEFAULTS.color,
+    rotate: wm?.rotate ?? WATERMARK_DEFAULTS.rotate,
+    opacity: wm?.opacity ?? WATERMARK_DEFAULTS.opacity,
+    fontSizePx: WATERMARK_DEFAULTS.fontSize,
+    tileWidthPx: tile.width,
+    tileHeightPx: tile.height,
+    tileWidthMm,
+    tileHeightMm,
+    columns,
+    rows,
+    tiles
+  };
+}
+function renderWatermarkTileSvg(layout, tile) {
+  const tileWidthPx = layout.tileWidthPx;
+  const tileHeightPx = layout.tileHeightPx;
+  const cx = tileWidthPx / 2;
+  const cy = tileHeightPx / 2;
+  const style = `left:${tile.leftMm}mm;top:${tile.topMm}mm;width:${tile.widthMm}mm;height:${tile.heightMm}mm`;
+  return `<svg class="watermark-tile" style="${style}" viewBox="0 0 ${tileWidthPx} ${tileHeightPx}" xmlns="http://www.w3.org/2000/svg"><text x="${cx}" y="${cy}" font-size="${layout.fontSizePx}" fill="${layout.color}" text-anchor="middle" dominant-baseline="middle" transform="rotate(${layout.rotate},${cx},${cy})">${escXml(layout.text)}</text></svg>`;
+}
+function renderWatermarkLayerHtml(wm, printData, paperMm, systemVars2) {
+  const layout = resolveWatermarkLayout(wm, printData, paperMm, systemVars2);
+  if (!layout) return "";
+  const tiles = layout.tiles.map((t) => renderWatermarkTileSvg(layout, t)).join("\n");
+  return `
+<div class="watermark-layer" style="opacity:${layout.opacity}">
+${tiles}
+</div>`;
+}
+
+// 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, excludedIds) {
+  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;
+    }
+    if (excludedIds?.has(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) {
+  const tableBottom = tableDesignBottom(el);
+  let maxBottom = tableBottom;
+  for (const id of members) {
+    const m = template.elements.find((e) => e.id === id);
+    if (!m) continue;
+    maxBottom = Math.max(maxBottom, (m.options?.top ?? 0) + (m.options?.height ?? 0));
+  }
+  return Math.max(maxBottom - tableBottom, 0);
+}
+function effectiveHeight(el, measured) {
+  return Math.max(el.options?.height ?? 0, measured.get(el.id)?.measuredHeight ?? 0);
+}
+function buildPaginationUnits(sorted, measured, groupMap) {
+  const unitOf = /* @__PURE__ */ new Map();
+  for (const members of groupMap.values()) {
+    if (members.length < 2) continue;
+    const unit = {
+      anchorId: members[0].id,
+      ids: members.map((m) => m.id),
+      forceFirstPage: members.some((m) => paginationOf(m)?.pageable === false)
+    };
+    for (const m of members) unitOf.set(m.id, unit);
+  }
+  const eligible = sorted.filter(
+    (el) => !isTableEl(el) && !el.options?.groupId && paginationOf(el)?.pageable !== false
+  );
+  const parent = /* @__PURE__ */ new Map();
+  eligible.forEach((el) => parent.set(el.id, el.id));
+  const find = (id) => {
+    let root = id;
+    while (parent.get(root) !== root) root = parent.get(root);
+    let cur = id;
+    while (parent.get(cur) !== root) {
+      const next = parent.get(cur);
+      parent.set(cur, root);
+      cur = next;
+    }
+    return root;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent.set(rb, ra);
+  };
+  const active = [];
+  for (const el of eligible) {
+    const top = el.options?.top ?? 0;
+    for (let i = active.length - 1; i >= 0; i--) {
+      if (active[i].bottom <= top) active.splice(i, 1);
+    }
+    const bottom = top + effectiveHeight(el, measured);
+    for (const a of active) {
+      if (a.bottom > top) union(el.id, a.id);
+    }
+    active.push({ id: el.id, top, bottom });
+  }
+  const clusters = /* @__PURE__ */ new Map();
+  for (const el of eligible) {
+    const root = find(el.id);
+    const arr = clusters.get(root);
+    if (arr) arr.push(el.id);
+    else clusters.set(root, [el.id]);
+  }
+  for (const ids of clusters.values()) {
+    if (ids.length < 2) continue;
+    const unit = { anchorId: ids[0], ids, forceFirstPage: false };
+    for (const id of ids) unitOf.set(id, unit);
+  }
+  return unitOf;
+}
+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 continuous = isContinuousPaper(template);
+  const contentHeight = continuous ? Number.POSITIVE_INFINITY : paper.height - mt - mb - headerH - footerH;
+  if (!continuous && 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 orderIndex = /* @__PURE__ */ new Map();
+  template.elements.forEach((e, idx) => orderIndex.set(e.id, idx));
+  const sorted = [...template.elements].sort((a, b) => {
+    const topA = a.options?.top ?? 0;
+    const topB = b.options?.top ?? 0;
+    if (topA !== topB) return topA - topB;
+    const zA = a.options?.zIndex ?? 0;
+    const zB = b.options?.zIndex ?? 0;
+    if (zA !== zB) return zA - zB;
+    return (orderIndex.get(a.id) ?? 0) - (orderIndex.get(b.id) ?? 0);
+  });
+  const explicitGroupIds = /* @__PURE__ */ new Set();
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const el of sorted) {
+    if (isTableEl(el)) continue;
+    const gid = el.options?.groupId;
+    if (!gid) continue;
+    explicitGroupIds.add(el.id);
+    const arr = groupMap.get(gid);
+    if (arr) arr.push(el);
+    else groupMap.set(gid, [el]);
+  }
+  const followMap = buildFollowMap(sorted, explicitGroupIds);
+  const followOwner = /* @__PURE__ */ new Map();
+  for (const [tableId, members] of followMap) {
+    for (const m of members) followOwner.set(m, tableId);
+  }
+  const elById = /* @__PURE__ */ new Map();
+  for (const el of sorted) elById.set(el.id, el);
+  const unitOf = buildPaginationUnits(sorted, measuredElements, groupMap);
+  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;
+  }
+  let overflowOnCurrent = false;
+  function pushPage() {
+    pages.push(
+      overflowOnCurrent ? { pageIndex: pages.length, sections: [...currentPage], overflow: true } : { pageIndex: pages.length, sections: [...currentPage] }
+    );
+  }
+  function noteOverflow(bottom) {
+    if (bottom > contentHeight) overflowOnCurrent = true;
+  }
+  function finishPage(overflow = false) {
+    if (currentPage.length === 0) {
+      overflowOnCurrent = overflowOnCurrent || overflow;
+      return;
+    }
+    pushPage();
+    currentPage = [];
+    remaining = contentHeight - SAFETY_MARGIN;
+    isFirstPage = false;
+    pageBroken = true;
+    overflowOnCurrent = false;
+  }
+  let i = 0;
+  while (i < sorted.length) {
+    const el = sorted[i];
+    if (followOwner.has(el.id)) {
+      i++;
+      continue;
+    }
+    const unit = unitOf.get(el.id);
+    if (unit && unit.anchorId !== el.id) {
+      i++;
+      continue;
+    }
+    if (paginationOf(el)?.pageable === false || unit?.forceFirstPage) {
+      if (unit) {
+        for (const id of unit.ids) {
+          currentPage.push({ elementId: id, type: "element", renderTop: elById.get(id)?.options?.top ?? 0 });
+        }
+      } else {
+        currentPage.push({ elementId: el.id, type: "element", renderTop: sectionTop(el) });
+      }
+      i++;
+      continue;
+    }
+    if (isTableEl(el)) {
+      i = paginateTable(el, measuredElements, i);
+    } else if (unit) {
+      i = paginateUnit(unit, i);
+    } else {
+      i = paginateNonTable(el, measuredElements, sorted, i);
+    }
+  }
+  if (currentPage.length > 0) {
+    pushPage();
+  }
+  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) {
+      const top2 = pageBroken ? 0 : el.options?.top ?? 0;
+      noteOverflow(top2 + elHeight);
+      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;
+    }
+    const top = pageBroken ? 0 : el.options?.top ?? 0;
+    finishPage(top + elHeight > contentHeight);
+    currentPage.push({ elementId: el.id, type: "element", renderTop: sectionTop(el) });
+    remaining -= elHeight;
+    return idx + 1;
+  }
+  function paginateUnit(unit, idx) {
+    const members = unit.ids.map((id) => elById.get(id)).filter((m) => !!m);
+    let minTop = Number.POSITIVE_INFINITY;
+    let maxBottom = Number.NEGATIVE_INFINITY;
+    for (const m of members) {
+      const top2 = m.options?.top ?? 0;
+      minTop = Math.min(minTop, top2);
+      maxBottom = Math.max(maxBottom, top2 + effectiveHeight(m, measuredElements));
+    }
+    const unitHeight = Math.max(maxBottom - minTop, 0);
+    const place = () => {
+      const offset = pageBroken ? -minTop : 0;
+      noteOverflow(minTop + offset + unitHeight);
+      for (const m of members) {
+        currentPage.push({
+          elementId: m.id,
+          type: "element",
+          renderTop: (m.options?.top ?? 0) + offset
+        });
+      }
+      remaining -= unitHeight;
+    };
+    if (unitHeight <= remaining) {
+      place();
+      return idx + 1;
+    }
+    const top = pageBroken ? 0 : minTop;
+    finishPage(top + unitHeight > contentHeight);
+    place();
+    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/barcode-dot.ts
+var MM_PER_INCH = 25.4;
+var BARCODE_QUIET_ZONE_MODULES = 10;
+var BARCODE_BAR_HEIGHT_MODULES = 30;
+var BARCODE_TEXT_FONT_SIZE_MODULES = 10;
+var BARCODE_MARGIN_BOTTOM_MODULES = 2;
+var BARCODE_MODULE_WIDTH_MM = 0.25;
+function barcodeUnitsPerModule(barWidth) {
+  const raw = typeof barWidth === "number" && Number.isFinite(barWidth) ? barWidth : 2;
+  return Math.max(1, raw / 2);
+}
+function barcodePreferredModuleWidthMm(barWidth) {
+  return barcodeUnitsPerModule(barWidth) * BARCODE_MODULE_WIDTH_MM;
+}
+function barcodeAvailableBoxMm(boxMm, maxMm) {
+  const box = typeof boxMm === "number" && boxMm > 0 ? boxMm : Number.POSITIVE_INFINITY;
+  const limit = typeof maxMm === "number" && maxMm > 0 ? Math.min(box, maxMm) : box;
+  return Number.isFinite(limit) ? limit : 0;
+}
+function resolveBarcodeSize(input) {
+  const unitWidth = Math.max(1, Math.ceil(input.unitWidth));
+  const unitHeight = Math.max(1, Math.ceil(input.unitHeight));
+  const preferredModuleMm = barcodePreferredModuleWidthMm(input.barWidth);
+  const maxModuleMm = Math.min(
+    input.boxWidthMm > 0 ? input.boxWidthMm / unitWidth : Number.POSITIVE_INFINITY,
+    input.boxHeightMm > 0 ? input.boxHeightMm / unitHeight : Number.POSITIVE_INFINITY
+  );
+  const dpi = input.dpi;
+  if (typeof dpi === "number" && Number.isFinite(dpi) && dpi > 0) {
+    const dotsPerMm = dpi / MM_PER_INCH;
+    const preferredDots = Math.max(1, Math.round(preferredModuleMm * dotsPerMm));
+    const maxDots = Math.floor(maxModuleMm * dotsPerMm);
+    if (maxDots >= 1) {
+      const dotsPerModule = Math.min(preferredDots, maxDots);
+      const moduleWidthMm2 = dotsPerModule / dotsPerMm;
+      return {
+        moduleWidthMm: moduleWidthMm2,
+        widthMm: unitWidth * moduleWidthMm2,
+        heightMm: unitHeight * moduleWidthMm2,
+        dotsPerModule,
+        scaledDown: dotsPerModule < preferredDots
+      };
+    }
+  }
+  const moduleWidthMm = Math.min(preferredModuleMm, maxModuleMm);
+  return {
+    moduleWidthMm,
+    widthMm: unitWidth * moduleWidthMm,
+    heightMm: unitHeight * moduleWidthMm,
+    dotsPerModule: null,
+    scaledDown: moduleWidthMm < preferredModuleMm
+  };
+}
+
+// src/render/html-generator.ts
+function pageVarsContext(vars) {
+  return { ...vars.data ?? {}, pageIndex: vars.pageIndex, totalPages: vars.totalPages };
+}
+function pageVarsData(printData) {
+  if (Array.isArray(printData)) return printData[0] ?? {};
+  return printData ?? {};
+}
+function generateHtml(template, pageLayouts, printData, options) {
+  const css = buildFontFaceCss(template.fonts) + buildPageCss(template, options?.pageHeightMm);
+  const isMeasure = options?.isMeasurementPass === true;
+  const totalPages = isMeasure ? 1 : pageLayouts.length;
+  const ctx = {
+    codeRenderer: options?.codeRenderer,
+    pageHeightMm: options?.pageHeightMm
+  };
+  if (isMeasure) {
+    return generateMeasurementHtml(template, css, ctx, printData);
+  }
+  return generateFinalHtml(template, pageLayouts, css, totalPages, ctx, printData);
+}
+function generateMeasurementHtml(template, css, ctx, printData) {
+  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">
+  ${renderWatermarkLayerHtml(template.watermark, printData, getPaperDims(template))}
+  <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 renderFinalPages(template, pageLayouts, printData, ctx, options) {
+  const pageOffset = options?.pageOffset ?? 0;
+  const totalPages = options?.totalPages ?? pageLayouts.length;
+  const pagesHtml = pageLayouts.map((page) => {
+    const pageNum = page.pageIndex + 1 + pageOffset;
+    return renderPage(template, page, pageNum, totalPages, ctx, printData, options?.pageClass);
+  }).join("\n");
+  return injectSystemVariables(pagesHtml);
+}
+function wrapHtmlDocument(css, bodyInnerHtml, bodyClass) {
+  const html = `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="UTF-8">
+<style>${css}</style>
+</head>
+<body${bodyClass ? ` class="${bodyClass}"` : ""}>
+${bodyInnerHtml}
+</body>
+</html>`;
+  return injectSystemVariables(html);
+}
+function generateFinalHtml(template, pageLayouts, css, _totalPages2, ctx, printData) {
+  const bodyInner = renderFinalPages(template, pageLayouts, printData ?? {}, ctx);
+  return wrapHtmlDocument(
+    css,
+    bodyInner,
+    isContinuousPaper(template) ? "continuous" : void 0
+  );
+}
+function renderPage(template, page, pageNum, totalPages, ctx, printData, pageClass) {
+  const paper = getPaperDims(template);
+  const paperMm = {
+    width: paper.width,
+    height: ctx.pageHeightMm && ctx.pageHeightMm > 0 ? ctx.pageHeightMm : paper.height
+  };
+  const contentWidth = paper.width - template.margins.left - template.margins.right;
+  const pageVars = { pageIndex: pageNum, totalPages, data: pageVarsData(printData) };
+  const scoped = withPageNumbers(template, pageVars);
+  const pageCtx = { ...ctx, pageVars };
+  const headerHtml = renderAreaElements(
+    scoped.header?.elements ?? [],
+    contentWidth,
+    pageNum,
+    totalPages,
+    pageCtx
+  );
+  const footerHtml = renderAreaElements(
+    scoped.footer?.elements ?? [],
+    contentWidth,
+    pageNum,
+    totalPages,
+    pageCtx
+  );
+  const overlayHtml = page.pageIndex === 0 ? `<div class="first-page-overlay">${renderAreaElements(scoped.firstPageOverlay?.elements ?? [], contentWidth, pageNum, totalPages, pageCtx)}</div>` : "";
+  let contentHtml = page.sections.map((section) => renderSection(section, scoped, pageCtx)).join("\n");
+  contentHtml = contentHtml.replace(/\{pageIndex\}/g, String(pageNum));
+  contentHtml = contentHtml.replace(/\{totalPages\}/g, String(totalPages));
+  const pageInner = `
+  ${renderWatermarkLayerHtml(template.watermark, printData, paperMm, { pageIndex: pageNum, totalPages })}
+  <div class="page-header">${headerHtml}</div>
+  ${overlayHtml}
+  <div class="content-area">
+    ${contentHtml}
+  </div>
+  <div class="page-footer">${footerHtml}</div>`;
+  const rot = getOutputRotationAngle(template);
+  const pageBody = rot !== 0 ? `<div class="print-page-rotor print-page-rotor-${rot}">${pageInner}</div>` : pageInner;
+  return `<section class="print-page${pageClass ? ` ${pageClass}` : ""}" data-page="${pageNum}">
+  ${pageBody}
+</section>`;
+}
+function withPageNumbers(template, vars) {
+  if (!templateReferencesPageNumbers(template)) return template;
+  const context = pageVarsContext(vars);
+  const mapEl = (el) => {
+    const raw = el.options?.rawFormatter;
+    if (typeof raw !== "string") return el;
+    return { ...el, options: { ...el.options, formatter: evaluateTemplate(raw, context) } };
+  };
+  const mapArea = (area) => area ? { ...area, elements: (area.elements ?? []).map(mapEl) } : area;
+  return {
+    ...template,
+    elements: template.elements.map(mapEl),
+    header: mapArea(template.header),
+    footer: mapArea(template.footer),
+    firstPageOverlay: mapArea(template.firstPageOverlay)
+  };
+}
+function templateReferencesPageNumbers(template) {
+  const areas = [
+    template.elements,
+    template.header?.elements,
+    template.footer?.elements,
+    template.firstPageOverlay?.elements
+  ];
+  return areas.some((list) => (list ?? []).some((el) => typeof el.options?.rawFormatter === "string"));
+}
+function resolveCellContent(cell, ctx) {
+  const raw = cell.rawFormatter;
+  if (typeof raw === "string" && raw !== "" && ctx?.pageVars) {
+    return evaluateTemplate(raw, pageVarsContext(ctx.pageVars));
+  }
+  return cell.content;
+}
+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 = [];
+  const fontSize = opts._fitFontSize === void 0 ? opts.fontSize : roundFontSize(opts._fitFontSize);
+  if (fontSize) parts.push(`font-size:${fontSize}pt`);
+  if (opts.fontFamily) parts.push(`font-family:${escapeInlineStyleValue(toFontFamilyStack(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 elementFitStyle(fit, opts) {
+  if (fit === "autoHeight") return "overflow:visible;";
+  if (opts.wordWrap === false) return "white-space:nowrap;text-overflow:ellipsis;";
+  return "";
+}
+function fitAttrs(fit, key, baseFontSizePt, opts) {
+  if (fit !== "shrink") return "";
+  const min2 = resolveShrinkMinFontSize(opts.shrinkMinFontSize);
+  return ` data-fit="shrink" data-fit-key="${esc(key)}" data-fit-base="${baseFontSizePt}" data-fit-min="${min2}"`;
+}
+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 type = el.type || el.printElementType?.type || "text";
+  const fit = resolveElementTextFit(type, opts);
+  const fitHeight = fit === "autoHeight" ? void 0 : height;
+  const style = containerStyle ?? elementPositionStyle(left, top, width, fitHeight, opts.zIndex);
+  const measureAttr = isMeasure ? ` data-measure-id="${el.id}"` : "";
+  const fitAttr = fitAttrs(fit, el.id, opts.fontSize ?? 12, opts);
+  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();
+      return `<div class="print-element" style="${style}"${measureAttr}>
+  ${codeImgHtml(codeValue, type, opts, {
+        fallback: `<span>${esc(codeValue)}</span>`,
+        codeRenderer: ctx?.codeRenderer,
+        fit: opts.fit,
+        maxWidth: opts.maxWidth,
+        maxHeight: opts.maxHeight,
+        printerDpi: opts.printerDpi,
+        targetWidthMm: opts.width,
+        targetHeightMm: opts.height
+      })}
+</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)}${elementFitStyle(fit, opts)}"${measureAttr}${fitAttr}>${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)}${elementFitStyle(fit, opts)}"${measureAttr}${fitAttr}>${esc(opts.formatter ?? opts.testData ?? "")}</div>`;
+  }
+}
+function codeImgHtml(value, cellType, opts, io) {
+  if (!value || !io.codeRenderer) return io.fallback;
+  const { fallback, codeRenderer, fit, maxWidth, maxHeight } = io;
+  const isBarcode = cellType === "barcode";
+  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,
+      printerDpi: isBarcode ? io.printerDpi : void 0,
+      targetWidthMm: isBarcode ? barcodeAvailableBoxMm(io.targetWidthMm, maxWidth) : void 0,
+      targetHeightMm: isBarcode ? barcodeAvailableBoxMm(io.targetHeightMm, maxHeight) : void 0
+    });
+    if (isBarcode && /^<svg[\s>]/i.test(svg)) return inlineCodeSvgHtml(svg);
+    const src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+    const styleParts = [];
+    styleParts.push("max-width:100%", "max-height:100%", "display:block", "margin:auto");
+    if (fit) {
+      styleParts.push(`object-fit:${fit}`);
+    }
+    if (maxWidth) {
+      styleParts.push(`max-width:${maxWidth}mm`);
+    }
+    if (maxHeight) {
+      styleParts.push(`max-height:${maxHeight}mm`);
+    }
+    const style = styleParts.join(";");
+    return `<img src="${src}" style="${style}" />`;
+  } catch {
+    return fallback;
+  }
+}
+function inlineCodeSvgHtml(svg) {
+  const styled = svg.replace(/<svg\b/, '<svg style="display:block"');
+  return `<div style="width:100%;height:100%;display:flex;align-items:center;justify-content:center;overflow:hidden;">${styled}</div>`;
+}
+function matrixCellStyle(cell, opts) {
+  const parts = [];
+  const fontSize = cell.fittedFontSize ?? 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.fontFamily) parts.push(`font-family:${escapeInlineStyleValue(toFontFamilyStack(cell.fontFamily))}`);
+  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, fitOwner = { elementId: "", kind: "b" }, rowLimit) {
+  const trs = [];
+  const defaultPadding = opts.tableDefaultPadding ?? 1;
+  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.map((cell, ci) => ({ cell, ci })).filter(({ cell }) => !cell.merged).map(({ cell, ci }) => {
+      const rowspan = rowLimit === void 0 ? cell.rowspan ?? 1 : Math.max(1, Math.min(cell.rowspan ?? 1, rowLimit - r));
+      const span = `${rowspan > 1 ? ` rowspan="${rowspan}"` : ""}${cell.colspan > 1 ? ` colspan="${cell.colspan}"` : ""}`;
+      const colIndex = ci;
+      let inner;
+      if (cell.cellType === "barcode" || cell.cellType === "qrcode") {
+        const codeValue = resolveCellContent(cell, ctx);
+        inner = `<div style="width:100%;height:100%;display:flex;align-items:center;justify-content:center;overflow:hidden;">${codeImgHtml(codeValue, cell.cellType, cell, {
+          fallback: esc(codeValue),
+          codeRenderer: ctx?.codeRenderer,
+          fit: cell.fit,
+          maxWidth: cell.maxWidth,
+          maxHeight: cell.maxHeight,
+          printerDpi: cell.printerDpi,
+          // 可用框 = 单元格内容区（列宽/行高扣除内边距与塌陷边框）；列宽缺失时宽度为 0 → 不约束宽度
+          targetWidthMm: cellFitWidthMm(opts.tableColWidths ?? [], ci, cell, defaultPadding),
+          targetHeightMm: cellFitCapMm(renderRows, r, cell, defaultPadding)
+        })}</div>`;
+      } else if (cell.cellType === "image") {
+        const fit = cell.fit || "contain";
+        const maxWidth = cell.maxWidth ? `max-width:${cell.maxWidth}mm;` : "max-width:100%;";
+        const maxHeight = cell.maxHeight ? `max-height:${cell.maxHeight}mm;` : "max-height:100%;";
+        inner = `<div style="width:100%;height:100%;display:flex;align-items:center;justify-content:center;overflow:hidden;"><img src="${esc(resolveCellContent(cell, ctx))}" style="object-fit:${fit};${maxWidth}${maxHeight}display:block;" /></div>`;
+      } else {
+        inner = renderTextCellInner(renderRows, r, colIndex, cell, opts, fitOwner, defaultPadding, ctx);
+      }
+      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 renderTextCellInner(renderRows, rowIndex, colIndex, cell, opts, fitOwner, defaultPadding, ctx) {
+  const fit = resolveCellTextFit(cell);
+  const text = esc(resolveCellContent(cell, ctx));
+  if (fit === "autoHeight") return text;
+  const capMm = cellFitCapMm(renderRows, rowIndex, cell, defaultPadding);
+  const nowrap = cell.wordWrap === false;
+  const style = [
+    `max-height:${capMm}mm`,
+    "overflow:hidden",
+    ...nowrap ? ["white-space:nowrap", "text-overflow:ellipsis"] : []
+  ].join(";");
+  const attrs = fit === "shrink" && fitOwner.elementId ? ` data-fit="shrink" data-fit-key="${esc(cellFitKey(fitOwner.elementId, fitOwner.kind, rowIndex, colIndex))}" data-fit-base="${cell.fontSize ?? opts.tableDefaultFontSize ?? 12}" data-fit-min="${resolveShrinkMinFontSize(cell.shrinkMinFontSize)}" data-fit-mm="${capMm}"` : "";
+  return `<div class="cell-fit" style="${style}"${attrs}>${text}</div>`;
+}
+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, void 0, opts.zIndex);
+  const renderRows = opts._renderRows ?? [];
+  const bodyHtml = renderMatrixRows(renderRows, 0, renderRows.length, opts, isMeasure, ctx, { elementId: el.id, kind: "b" });
+  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, void 0, opts.zIndex);
+  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, { elementId: el.id, kind: "b" }, repeatCount) : "";
+  const bodyHtml = renderMatrixRows(renderRows, startRow, endRow, opts, false, ctx, { elementId: el.id, kind: "b" });
+  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 pageVars = ctx?.pageVars ? pageVarsContext(ctx.pageVars) : {};
+  const rows = templates.map((tpl) => ({
+    ...tpl,
+    cells: tpl.cells.map((cell) => cell.rawFormatter ? {
+      ...cell,
+      content: evaluateTemplate(cell.rawFormatter, { rows: pageCtx, ...mainData, ...pageVars }),
+      // 已按本页上下文求值，清标记避免渲染时再按页码重算一次（会丢掉 rows）
+      rawFormatter: ""
+    } : cell)
+  }));
+  return renderMatrixRows(rows, 0, rows.length, opts, false, ctx, { elementId: el.id, kind: "st" });
+}
+function renderSummaryRows(el, opts, ctx) {
+  const summaryRows = opts._summaryRows ?? [];
+  if (summaryRows.length === 0) return "";
+  return renderMatrixRows(summaryRows, 0, summaryRows.length, opts, false, ctx, { elementId: el.id, kind: "sm" });
+}
+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 tableBottom = tableDesignBottom(el);
+  const zStyle = typeof opts.zIndex === "number" ? `z-index:${opts.zIndex};` : "";
+  const style = `position:absolute;left:${mm(tableLeft)};top:${mm(groupTop)};width:${mm(tableWidth)};overflow:visible;${zStyle}`;
+  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, { elementId: el.id, kind: "b" }, repeatCount) : "";
+    const bodyHtml = renderMatrixRows(renderRows, startRow, endRow, opts, false, ctx, { elementId: el.id, kind: "b" });
+    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>`;
+  }
+  const followIds = section.followElementIds ?? [];
+  const followExtent = followIds.reduce((maxBottom, id) => {
+    const m = findElement(template, id);
+    if (!m) return maxBottom;
+    return Math.max(maxBottom, (m.options?.top ?? 0) + (m.options?.height ?? 0));
+  }, tableBottom);
+  const followHtml = followIds.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 mZ = m.options?.zIndex;
+    const type = m.type || m.printElementType?.type || "text";
+    const needsHeight = type === "rect" || type === "oval" || type === "image";
+    const flowStyle = [
+      "position:absolute",
+      `left:${mm(mLeft - tableLeft)}`,
+      `top:${mm(mTop - tableBottom)}`,
+      `width:${mm(mWidth)}`,
+      ...needsHeight && mHeight > 0 ? [`height:${mm(mHeight)}`] : [],
+      ...typeof mZ === "number" ? [`z-index:${mZ}`] : [],
+      "overflow:visible"
+    ].join(";") + ";";
+    return renderElement(m, false, flowStyle, void 0, ctx);
+  }).join("\n");
+  const followWrap = followIds.length > 0 ? `<div class="flow-follow" style="position:relative;width:${mm(tableWidth)};height:${mm(Math.max(followExtent - tableBottom, 0))};overflow:visible;">
+${followHtml}
+</div>` : "";
+  return `<div class="flow-group" style="${style}">
+${sliceHtml}
+${followWrap}
+</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/render/continuous-paper.ts
+var MIN_CONTINUOUS_HEIGHT_MM = 25.4;
+function composeContinuousHeight(template, contentBottomMm) {
+  const mb = template.margins?.bottom ?? 0;
+  const footerH = template.footer?.height ?? 0;
+  const height = Math.max(contentBottomMm, 0) + footerH + mb;
+  return Math.max(MIN_CONTINUOUS_HEIGHT_MM, Math.round(height * 100) / 100);
+}
+
+// src/print/units.ts
+var PX_PER_MM2 = 3.7795275591;
+var MICROMETERS_PER_MM = 1e3;
+var MM_PER_INCH2 = 25.4;
+var MICROMETERS_PER_INCH = 25400;
+function pxToMm2(px) {
+  return px / PX_PER_MM2;
+}
+function mmToPx2(mm2) {
+  return Math.round(mm2 * PX_PER_MM2);
+}
+function millimetersToMicrometers(mm2) {
+  return Math.round(mm2 * MICROMETERS_PER_MM);
+}
+function micrometersToMillimeters(um) {
+  return um / MICROMETERS_PER_MM;
+}
+function millimetersToInches(mm2) {
+  return mm2 / MM_PER_INCH2;
+}
+
+// src/print/errors.ts
+var PrintFailure = class extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "PrintFailure";
+    this.code = code;
+    this.cause = cause;
+  }
+};
+function toPrintFailure(err, fallbackCode, context) {
+  if (err instanceof PrintFailure) return err;
+  const detail = err instanceof Error ? err.message : String(err);
+  return new PrintFailure(fallbackCode, `${context}\uFF1A${detail}`, err);
+}
+async function withTimeout(task, ms, code, message) {
+  let timer;
+  try {
+    return await Promise.race([
+      task,
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new PrintFailure(code, message)), ms);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+// src/print/paper.ts
+function positive(value) {
+  return typeof value === "number" && value > 0 ? value : void 0;
+}
+function escapeHeightMm(input) {
+  return positive(input.paperHeightMm) ?? positive(input.override?.height);
+}
+function resolvePaperMm(input) {
+  const width = positive(input.override?.width) ?? input.paperMm.width;
+  const overrideHeight = positive(input.override?.height);
+  if (input.continuous) {
+    return overrideHeight ? { paperMm: { width, height: overrideHeight }, heightSource: "config" } : { paperMm: { width, height: input.paperMm.height }, heightSource: "derived" };
+  }
+  return { paperMm: { width, height: overrideHeight ?? input.paperMm.height }, heightSource: "config" };
+}
+function paperViewportPx(paper) {
+  return { width: mmToPx2(paper.width), height: mmToPx2(paper.height) };
+}
+
+// src/print/pdf-spec.ts
+var ZERO_MARGINS_MM = { top: 0, right: 0, bottom: 0, left: 0 };
+function buildPdfTargetSpec(paperMm) {
+  return {
+    paperMm,
+    marginsMm: { ...ZERO_MARGINS_MM },
+    printBackground: true,
+    scale: 1,
+    preferCSSPageSize: false
+  };
+}
+function toElectronPrintToPdfOptions(spec) {
+  return {
+    margins: { ...spec.marginsMm },
+    pageSize: {
+      width: millimetersToInches(spec.paperMm.width),
+      height: millimetersToInches(spec.paperMm.height)
+    },
+    printBackground: spec.printBackground,
+    scale: spec.scale,
+    preferCSSPageSize: spec.preferCSSPageSize
+  };
+}
+function toPlaywrightPdfOptions(spec) {
+  const mm2 = (value) => `${value}mm`;
+  return {
+    width: mm2(spec.paperMm.width),
+    height: mm2(spec.paperMm.height),
+    margin: {
+      top: mm2(spec.marginsMm.top),
+      right: mm2(spec.marginsMm.right),
+      bottom: mm2(spec.marginsMm.bottom),
+      left: mm2(spec.marginsMm.left)
+    },
+    printBackground: spec.printBackground,
+    preferCSSPageSize: spec.preferCSSPageSize
+  };
+}
+function buildScreenshotTargetSpec() {
+  return { type: "png", fullPage: true, omitBackground: false };
+}
+
+// src/print/measure.ts
+function normalizeMeasurements(raw, template) {
+  const index = new Map(template.elements.map((el) => [el.id, el]));
+  const measured = /* @__PURE__ */ new Map();
+  for (const item of raw) {
+    const element = index.get(item.id);
+    const repeatCount = element?.options?._repeatHeaderCount ?? 0;
+    const rowHeights = item.rowHeightsPx?.map(pxToMm2);
+    measured.set(item.id, {
+      id: item.id,
+      measuredHeight: pxToMm2(item.heightPx),
+      measuredRowHeights: rowHeights,
+      repeatHeaderHeight: rowHeights && rowHeights.length > 0 && repeatCount > 0 ? rowHeights.slice(0, repeatCount).reduce((sum2, h) => sum2 + h, 0) : 0
+    });
+  }
+  return measured;
+}
+
+// src/print/apply-text-fit.ts
+var CELL_ROW_SOURCES = {
+  b: "_renderRows",
+  st: "_subtotalTemplates",
+  sm: "_summaryRows"
+};
+function applyTextFitSizes(template, fits) {
+  if (!fits || fits.length === 0) return;
+  const index = /* @__PURE__ */ new Map();
+  const collect = (elements) => {
+    for (const el of elements ?? []) index.set(el.id, el);
+  };
+  collect(template.elements);
+  collect(template.header?.elements);
+  collect(template.footer?.elements);
+  collect(template.firstPageOverlay?.elements);
+  for (const fit of fits) {
+    const parsed = parseCellFitKey(fit.key);
+    if (!parsed) {
+      const el2 = index.get(fit.key);
+      if (el2) el2.options._fitFontSize = roundFontSize(fit.fontSizePt);
+      continue;
+    }
+    const el = index.get(parsed.elementId);
+    const rows = el?.options?.[CELL_ROW_SOURCES[parsed.kind]];
+    const cell = rows?.[parsed.rowIndex]?.cells?.[parsed.colIndex];
+    if (cell) cell.fittedFontSize = roundFontSize(fit.fontSizePt);
+  }
+}
+
+// src/print/codes.ts
+function codeSpecKey(value, cellType, opts = {}) {
+  return JSON.stringify([
+    value,
+    cellType,
+    opts.barcodeType ?? null,
+    opts.qrCodeLevel ?? null,
+    opts.showText ?? null,
+    opts.barWidth ?? null,
+    opts.fontSize ?? null
+  ]);
+}
+function createMapCodeRenderer(map) {
+  return {
+    render(value, cellType, opts) {
+      const svg = map.get(codeSpecKey(value, cellType, opts));
+      if (!svg) throw new Error(`\u7801\u503C\u672A\u6E32\u67D3\uFF1A${value}`);
+      return svg;
+    }
+  };
+}
+function createCollectingCodeRenderer(base) {
+  const collected = /* @__PURE__ */ new Map();
+  return {
+    renderer: {
+      render(value, cellType, opts = {}) {
+        const key = codeSpecKey(value, cellType, opts);
+        const hit = base?.get(key);
+        if (hit) return hit;
+        collected.set(key, { key, value, cellType, opts });
+        throw new Error("collect");
+      }
+    },
+    takeSpecs() {
+      const specs = [...collected.values()];
+      collected.clear();
+      return specs;
+    }
+  };
+}
+function mergeCodeMaps(...maps) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const map of maps) {
+    for (const [key, svg] of map) merged.set(key, svg);
+  }
+  return merged;
+}
+
+// src/print/driver.ts
+var EXECUTOR_TARGETS = {
+  waitReady: "window",
+  readMeasurements: "document",
+  readContentBottom: "document",
+  renderCodes: "none",
+  applyTextFit: "document"
+};
+
+// src/print/ports.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_READINESS_MS = 5e3;
+
+// src/print/dom-host-runtime.ts
+function createDomHostRuntime(factory, bundle) {
+  return {
+    async withSession(options, fn) {
+      const driver = await factory.createDriver();
+      const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+      const readinessMs = options.readinessMs ?? DEFAULT_READINESS_MS;
+      const budget = () => Math.max(1, deadline - Date.now());
+      const fail = (err, code, context) => toPrintFailure(err, code, context);
+      let injected = false;
+      const ensureExecutor = async () => {
+        if (injected) return;
+        if (driver.requiresExecutor === false) {
+          injected = true;
+          return;
+        }
+        if (!bundle) throw new PrintFailure("INTERNAL", "\u7F3A\u5C11 core DOM \u6267\u884C\u5668\u4EA7\u7269");
+        await driver.injectExecutor(bundle);
+        injected = true;
+      };
+      const load = async (html, viewport) => {
+        await driver.open(viewport);
+        await driver.setContent(html);
+        injected = false;
+        await ensureExecutor();
+        await driver.evaluate("waitReady", [readinessMs]);
+      };
+      const session = {
+        async renderCodes(specs) {
+          if (specs.length === 0) return /* @__PURE__ */ new Map();
+          const ms = budget();
+          return withTimeout(
+            (async () => {
+              try {
+                await ensureExecutor();
+                const map = await driver.evaluate("renderCodes", [specs]);
+                return new Map(Object.entries(map));
+              } catch (err) {
+                throw fail(err, "INTERNAL", "\u7801\u503C\u6E32\u67D3\u5931\u8D25");
+              }
+            })(),
+            ms,
+            "RENDER_TIMEOUT",
+            `\u7801\u503C\u6E32\u67D3\u8D85\u8FC7 ${ms}ms`
+          );
+        },
+        async measure(html, viewport) {
+          const ms = budget();
+          return withTimeout(
+            (async () => {
+              try {
+                await load(html, viewport);
+                const fits = await driver.evaluate("applyTextFit") ?? [];
+                const measurements = await driver.evaluate("readMeasurements");
+                return { measurements, fits };
+              } catch (err) {
+                throw fail(err, "MEASURE_FAILED", "\u6D4B\u91CF\u5931\u8D25");
+              }
+            })(),
+            ms,
+            "RENDER_TIMEOUT",
+            `\u6D4B\u91CF\u8D85\u8FC7 ${ms}ms`
+          );
+        },
+        async probeContentBottom(html, viewport) {
+          const ms = budget();
+          return withTimeout(
+            (async () => {
+              try {
+                await load(html, viewport);
+                return await driver.evaluate("readContentBottom");
+              } catch (err) {
+                throw fail(err, "MEASURE_FAILED", "\u8FDE\u7EED\u7EB8\u63A2\u9488\u5931\u8D25");
+              }
+            })(),
+            ms,
+            "RENDER_TIMEOUT",
+            `\u8FDE\u7EED\u7EB8\u63A2\u9488\u8D85\u8FC7 ${ms}ms`
+          );
+        },
+        async toPdf(html, spec, viewport) {
+          if (!driver.pdf) throw new PrintFailure("UNSUPPORTED_RUNTIME", "\u5F53\u524D\u5BBF\u4E3B\u4E0D\u652F\u6301\u751F\u6210 PDF");
+          const ms = budget();
+          return withTimeout(
+            (async () => {
+              try {
+                await load(html, viewport);
+                return await driver.pdf(html, spec);
+              } catch (err) {
+                throw fail(err, "PDF_FAILED", "PDF \u751F\u6210\u5931\u8D25");
+              }
+            })(),
+            ms,
+            "RENDER_TIMEOUT",
+            `PDF \u751F\u6210\u8D85\u8FC7 ${ms}ms`
+          );
+        },
+        async toScreenshot(html, spec, viewport) {
+          if (!driver.screenshot) throw new PrintFailure("UNSUPPORTED_RUNTIME", "\u5F53\u524D\u5BBF\u4E3B\u4E0D\u652F\u6301\u622A\u56FE");
+          const ms = budget();
+          return withTimeout(
+            (async () => {
+              try {
+                await load(html, viewport);
+                return await driver.screenshot(html, spec);
+              } catch (err) {
+                throw fail(err, "SCREENSHOT_FAILED", "\u622A\u56FE\u5931\u8D25");
+              }
+            })(),
+            ms,
+            "RENDER_TIMEOUT",
+            `\u622A\u56FE\u8D85\u8FC7 ${ms}ms`
+          );
+        }
+      };
+      try {
+        return await fn(session);
+      } finally {
+        try {
+          await driver.close();
+        } catch {
+        }
+      }
+    }
+  };
+}
+
+// src/print/normalize-print-data.ts
+var MAX_BATCH_COPIES = 500;
+function isPlainRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function normalizePrintData(raw) {
+  if (raw === void 0) return { mode: "single", data: {} };
+  if (!Array.isArray(raw)) return { mode: "single", data: raw };
+  if (raw.length === 0) {
+    throw new Error("\u6279\u91CF\u6253\u5370\u6570\u636E\u5FC5\u987B\u662F\u975E\u7A7A\u5BF9\u8C61\u6570\u7EC4");
+  }
+  if (raw.length > MAX_BATCH_COPIES) {
+    throw new Error(`\u6279\u91CF\u6253\u5370\u6700\u591A\u652F\u6301 ${MAX_BATCH_COPIES} \u4EFD\uFF0C\u5F53\u524D ${raw.length} \u4EFD`);
+  }
+  for (let i = 0; i < raw.length; i++) {
+    if (!isPlainRecord(raw[i])) {
+      throw new Error(`\u6279\u91CF\u6253\u5370\u6570\u636E\u7B2C ${i + 1} \u9879\u5FC5\u987B\u662F\u5BF9\u8C61`);
+    }
+  }
+  return { mode: "batch", dataList: raw };
+}
+
+// src/print/batch-compose.ts
+function composeBatchHtml(copies) {
+  const bound = copies[0].bound;
+  const continuous = isContinuousPaper(bound);
+  const bodyInner = copies.map((copy, i) => {
+    const cls = continuous ? `print-copy print-copy-${i}` : "print-copy";
+    const pages = renderFinalPages(copy.bound, copy.pageLayouts, copy.data, {
+      codeRenderer: copy.codeRenderer,
+      pageHeightMm: copy.derivedHeightMm
+    });
+    return `<section class="${cls}">
+${pages}
+</section>`;
+  }).join("\n");
+  const pageCss = continuous ? buildBatchPageCss(bound, copies.map((c) => ({ heightMm: c.derivedHeightMm }))) : `${buildPageCss(bound)}
+.print-copy:not(:last-child){break-after:page;page-break-after:always;}`;
+  const css = buildFontFaceCss(bound.fonts) + pageCss;
+  return {
+    html: wrapHtmlDocument(
+      css,
+      bodyInner,
+      continuous ? "continuous" : void 0
+    ),
+    pageCount: copies.reduce((sum2, c) => sum2 + c.pageLayouts.length, 0),
+    copyPaperMm: copies.map((c) => c.paperMm)
+  };
+}
+
+// src/print/tiling.ts
+var TILE_DEFAULTS = {
+  enabled: true,
+  sheetPaperSize: "A4",
+  sheetOrientation: "portrait",
+  sheetMargin: { top: 10, right: 10, bottom: 10, left: 10 },
+  gapX: 2,
+  gapY: 2,
+  columns: 2
+};
+var TilingError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "TilingError";
+    this.code = code;
+  }
+};
+function roundMm(value) {
+  return Math.round(value * 10) / 10;
+}
+function normalizeTilingOptions(t) {
+  const raw = t.tiling;
+  return {
+    ...TILE_DEFAULTS,
+    ...raw,
+    sheetMargin: { ...TILE_DEFAULTS.sheetMargin, ...raw?.sheetMargin ?? {} }
+  };
+}
+function resolveSheetMm(t, opts) {
+  const cfg = normalizeTilingOptions(t);
+  const ov = opts?.paperOverride;
+  if (ov && typeof ov.width === "number" && ov.width > 0 && typeof ov.height === "number" && ov.height > 0) {
+    return { width: ov.width, height: ov.height };
+  }
+  if (cfg.sheetPaperSize === "CUSTOM") {
+    return {
+      width: cfg.sheetCustomWidth ?? PAPER_DIMENSIONS.A4.width,
+      height: cfg.sheetCustomHeight ?? PAPER_DIMENSIONS.A4.height
+    };
+  }
+  const preset = cfg.sheetPaperSize ?? "A4";
+  const base = PAPER_DIMENSIONS[preset] ?? PAPER_DIMENSIONS.A4;
+  return cfg.sheetOrientation === "landscape" ? { width: base.height, height: base.width } : { ...base };
+}
+function availableArea(sheet, margin) {
+  return {
+    w: sheet.width - margin.left - margin.right,
+    h: sheet.height - margin.top - margin.bottom
+  };
+}
+function calcMaxColumns(availW, labelW, gapX) {
+  return Math.max(0, Math.floor((availW + gapX) / (labelW + gapX)));
+}
+function computeTileLayout(t, opts) {
+  const issues = validateTiling(t, opts);
+  if (issues.length) throw new TilingError(issues[0].code, issues[0].message);
+  const cfg = normalizeTilingOptions(t);
+  const sheet = resolveSheetMm(t, opts);
+  const label = getPaperDimensions(t);
+  const avail = availableArea(sheet, cfg.sheetMargin);
+  const rows = Math.floor((avail.h + cfg.gapY) / (label.height + cfg.gapY));
+  return {
+    tile: { width: label.width, height: label.height },
+    sheet,
+    columns: cfg.columns,
+    rows,
+    perSheet: cfg.columns * rows,
+    maxColumns: calcMaxColumns(avail.w, label.width, cfg.gapX),
+    margin: { ...cfg.sheetMargin },
+    gapX: cfg.gapX,
+    gapY: cfg.gapY
+  };
+}
+function tilePosition(layout, index) {
+  const slot = index % layout.perSheet;
+  const col = slot % layout.columns;
+  const row = Math.floor(slot / layout.columns);
+  return {
+    left: roundMm(layout.margin.left + col * (layout.tile.width + layout.gapX)),
+    top: roundMm(layout.margin.top + row * (layout.tile.height + layout.gapY))
+  };
+}
+function computeMaxColumns(t, opts) {
+  const cfg = normalizeTilingOptions(t);
+  const sheet = resolveSheetMm(t, opts);
+  const label = getPaperDimensions(t);
+  const availW = sheet.width - cfg.sheetMargin.left - cfg.sheetMargin.right;
+  return calcMaxColumns(availW, label.width, cfg.gapX);
+}
+function validateTiling(t, opts) {
+  const issues = [];
+  const cfg = normalizeTilingOptions(t);
+  if (isContinuousPaper(t)) {
+    issues.push({
+      code: "CONTINUOUS_UNSUPPORTED",
+      message: "\u8FDE\u7EED\u7EB8\u4E0D\u652F\u6301\u62FC\u7248\u6253\u5370\uFF0C\u8BF7\u5C06\u6A21\u677F\u7EB8\u5F20\u6539\u4E3A\u56FA\u5B9A\u7EB8\u5F20\u6216\u5173\u95ED\u62FC\u7248"
+    });
+  }
+  const sheetPaperSize = cfg.sheetPaperSize;
+  const sheetContinuous = isContinuousPaperSize(sheetPaperSize ?? "");
+  if (sheetContinuous) {
+    issues.push({ code: "SHEET_CONTINUOUS", message: "\u62FC\u7248\u76EE\u6807\u7EB8\u5F20\u4E0D\u80FD\u662F\u8FDE\u7EED\u7EB8" });
+  }
+  const customSizeInvalid = cfg.sheetPaperSize === "CUSTOM" && !((cfg.sheetCustomWidth ?? 0) > 0 && (cfg.sheetCustomHeight ?? 0) > 0);
+  if (customSizeInvalid) {
+    issues.push({
+      code: "SHEET_SIZE_INVALID",
+      message: "\u62FC\u7248\u81EA\u5B9A\u4E49\u7EB8\u5F20\u5BBD\u9AD8\u5FC5\u987B\u662F\u5927\u4E8E 0 \u7684\u6570\u503C\uFF08mm\uFF09"
+    });
+  }
+  if (customSizeInvalid || sheetContinuous) return issues;
+  const sheet = resolveSheetMm(t, opts);
+  const label = getPaperDimensions(t);
+  const avail = availableArea(sheet, cfg.sheetMargin);
+  const marginLR = roundMm(cfg.sheetMargin.left + cfg.sheetMargin.right);
+  if (!Number.isInteger(cfg.columns) || cfg.columns < 1) {
+    issues.push({ code: "COLUMNS_INVALID", message: "\u62FC\u7248\u5217\u6570\u5FC5\u987B\u662F\u5927\u4E8E 0 \u7684\u6574\u6570" });
+    return issues;
+  }
+  const maxColumns = calcMaxColumns(avail.w, label.width, cfg.gapX);
+  if (cfg.columns > maxColumns) {
+    const needW = roundMm(cfg.columns * label.width + (cfg.columns - 1) * cfg.gapX);
+    issues.push({
+      code: "COLUMNS_OVERFLOW",
+      message: "\u62FC\u7248\u5217\u6570 " + cfg.columns + " \u8D85\u51FA\u7EB8\u9762\u53EF\u7528\u5BBD\u5EA6\uFF1A" + roundMm(sheet.width) + "mm \u2212 \u5DE6\u53F3\u7559\u767D " + marginLR + "mm = " + roundMm(avail.w) + "mm\uFF0C\u6700\u591A\u53EF\u653E " + maxColumns + " \u5217\uFF1B\u5F53\u524D " + cfg.columns + " \u5217 " + label.width + "mm \u6807\u7B7E\u542B\u95F4\u8DDD\u9700\u8981 " + needW + "mm"
+    });
+  }
+  if (Math.floor((avail.h + cfg.gapY) / (label.height + cfg.gapY)) < 1) {
+    issues.push({
+      code: "LABEL_TOO_TALL",
+      message: "\u6807\u7B7E\u9AD8\u5EA6 " + label.height + "mm \u8D85\u51FA\u7EB8\u9762\u53EF\u7528\u9AD8\u5EA6 " + roundMm(avail.h) + "mm\uFF0C\u62FC\u7248\u6BCF\u5F20 0 \u884C\uFF1B\u8BF7\u7F29\u5C0F\u6807\u7B7E\u9AD8\u5EA6\u6216\u6539\u7528\u6A2A\u5411\u7EB8"
+    });
+  }
+  return issues;
+}
+
+// src/print/tile-compose.ts
+function composeTiledHtml(input) {
+  const { copies, layout } = input;
+  const bound = copies[0].bound;
+  const sheets = [];
+  for (let start = 0; start < copies.length; start += layout.perSheet) {
+    const tiles = copies.slice(start, start + layout.perSheet).map((copy, i) => {
+      const pos = tilePosition(layout, i);
+      const page = renderFinalPages(copy.bound, copy.pageLayouts, copy.data, {
+        codeRenderer: copy.codeRenderer
+      });
+      return `<div class="print-tile" style="left:${pos.left}mm;top:${pos.top}mm">
+${page}
+</div>`;
+    }).join("\n");
+    sheets.push(`<section class="print-sheet">
+${tiles}
+</section>`);
+  }
+  const css = buildFontFaceCss(bound.fonts) + buildPageCss(bound) + "\n" + buildSheetPageCss(layout);
+  return {
+    html: wrapHtmlDocument(css, sheets.join("\n")),
+    sheetCount: sheets.length,
+    perSheet: layout.perSheet
+  };
+}
+
+// src/print/multi-template.ts
+function pageLabel(p, index) {
+  return p.name ? `\u7B2C ${index + 1} \u9875\u300C${p.name}\u300D` : `\u7B2C ${index + 1} \u9875`;
+}
+function normalizeTemplate(templateJson) {
+  const pages = isMultiPageTemplate(templateJson) ? templateJson.pages : [templateJson];
+  if (pages.length === 0) {
+    throw new Error("\u591A\u9875\u9762\u6A21\u677F\u81F3\u5C11\u9700\u8981\u4E00\u9875");
+  }
+  if (pages.length === 1) return pages;
+  const firstPaper = getPaperDimensions(pages[0]);
+  pages.forEach((p, i) => {
+    if (isContinuousPaper(p)) {
+      throw new Error(`\u591A\u9875\u9762\u6A21\u677F\u4E0D\u652F\u6301\u8FDE\u7EED\u7EB8\uFF08${pageLabel(p, i)}\uFF09`);
+    }
+    if (p.tiling?.enabled === true) {
+      throw new Error(`\u591A\u9875\u9762\u6A21\u677F\u4E0D\u652F\u6301\u6807\u7B7E\u62FC\u7248\uFF08${pageLabel(p, i)}\uFF09`);
+    }
+    const d = getPaperDimensions(p);
+    if (d.width !== firstPaper.width || d.height !== firstPaper.height) {
+      throw new Error(
+        `\u591A\u9875\u9762\u6A21\u677F\u5404\u9875\u7EB8\u5F20\u5C3A\u5BF8\u5FC5\u987B\u4E00\u81F4\uFF08${pageLabel(p, i)} ${d.width}\xD7${d.height}mm \u4E0E\u9996\u9875 ${firstPaper.width}\xD7${firstPaper.height}mm \u4E0D\u540C\uFF09`
+      );
+    }
+  });
+  return pages;
+}
+function isMultiPageTemplate(templateJson) {
+  return Array.isArray(templateJson.pages);
+}
+function mergeFontDeclarations(pages) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const p of pages) {
+    for (const f of p.fonts ?? []) {
+      const key = f.family;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      merged.push(f);
+    }
+  }
+  return merged;
+}
+function composeMultiPageDocument(copies) {
+  if (copies.length === 0) {
+    throw new Error("\u591A\u9875\u9762\u6A21\u677F\u81F3\u5C11\u9700\u8981\u4E00\u4EFD\u6570\u636E");
+  }
+  const templates = copies[0].boundPages;
+  const css = buildFontFaceCss(mergeFontDeclarations(templates)) + [
+    buildPageRuleCss(templates[0]),
+    buildBasePageCss(),
+    ...templates.map((t, i) => buildPageGeometryCss(t, `.mt-${i}`)),
+    ...copies.length > 1 ? [COPY_BREAK_CSS] : []
+  ].join("\n\n");
+  const bodyInner = copies.map((copy) => {
+    const totalPages = copy.layoutsPerPage.reduce((s, ls) => s + ls.length, 0);
+    let offset = 0;
+    const fragments = copy.layoutsPerPage.map((layouts, i) => {
+      const html = renderFinalPages(
+        copy.boundPages[i],
+        layouts,
+        copy.data,
+        { codeRenderer: copy.codeRenderers?.[i] },
+        {
+          pageOffset: offset,
+          totalPages,
+          pageClass: `mt-${i}`
+        }
+      );
+      offset += layouts.length;
+      return html;
+    });
+    const pages = fragments.join("\n");
+    return copies.length > 1 ? `<section class="print-copy">
+${pages}
+</section>` : pages;
+  }).join("\n");
+  const pageCount = copies.reduce(
+    (sum2, c) => sum2 + c.layoutsPerPage.reduce((s, ls) => s + ls.length, 0),
+    0
+  );
+  const pageLayouts = [];
+  let g = 0;
+  for (const c of copies) {
+    for (const ls of c.layoutsPerPage) {
+      for (const p of ls) pageLayouts.push({ ...p, pageIndex: g++ });
+    }
+  }
+  return {
+    html: wrapHtmlDocument(css, bodyInner),
+    pageCount,
+    pageLayouts
+  };
+}
+
+// src/print/pipeline.ts
+async function prepareDocument(job, runtime) {
+  return runtime.withSession(job, (session) => prepareWithSession(job, session));
+}
+async function renderPdf(job, runtime) {
+  return runtime.withSession(job, async (session) => {
+    const prepared = await prepareWithSession(job, session);
+    const viewport = paperViewportPx(prepared.paperMm);
+    const pdf = await session.toPdf(prepared.html, buildPdfTargetSpec(prepared.paperMm), viewport);
+    return { pdf, prepared };
+  });
+}
+async function renderScreenshot(job, runtime) {
+  return runtime.withSession(job, async (session) => {
+    const pageTemplates = normalizeTemplate(job.templateJson);
+    if (pageTemplates.length > 1) {
+      const normalized2 = normalizePrintData(job.printData);
+      const data2 = normalized2.mode === "batch" ? normalized2.dataList[0] : normalized2.data;
+      const copy = await prepareMultiCopy(job, session, data2);
+      const doc = composeMultiPageDocument([copy]);
+      const viewport2 = paperViewportPx(getPaperDimensions(pageTemplates[0]));
+      return session.toScreenshot(doc.html, buildScreenshotTargetSpec(), viewport2);
+    }
+    const singleJob = pageTemplates[0] !== job.templateJson ? { ...job, templateJson: pageTemplates[0] } : job;
+    const normalized = normalizePrintData(singleJob.printData);
+    const data = normalized.mode === "batch" ? normalized.dataList[0] : normalized.data;
+    const bound = bindData(singleJob.templateJson, data, singleJob.baseUrl, singleJob.fontBaseUrl);
+    const built = await buildHtmlWithCodes({
+      bound,
+      job: singleJob,
+      session,
+      data,
+      pageLayouts: [],
+      isMeasurementPass: true
+    });
+    const viewport = paperViewportPx(getPaperDimensions(bound));
+    return session.toScreenshot(built.html, buildScreenshotTargetSpec(), viewport);
+  });
+}
+async function prepareWithSession(job, session) {
+  const pageTemplates = normalizeTemplate(job.templateJson);
+  if (pageTemplates.length > 1) {
+    const normalized2 = normalizePrintData(job.printData);
+    const rows = normalized2.mode === "batch" ? normalized2.dataList : [normalized2.data];
+    const copies2 = [];
+    for (let i = 0; i < rows.length; i++) {
+      try {
+        copies2.push(await prepareMultiCopy(job, session, rows[i]));
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        throw new Error(`\u7B2C ${i + 1} \u4EFD\u6E32\u67D3\u5931\u8D25\uFF1A${reason}`);
+      }
+    }
+    const doc = composeMultiPageDocument(copies2);
+    return {
+      html: doc.html,
+      pageCount: doc.pageCount,
+      paperMm: getOutputPaperDimensions(pageTemplates[0]),
+      continuous: false,
+      heightSource: "config",
+      pageLayouts: doc.pageLayouts,
+      copies: copies2.length
+    };
+  }
+  const singleJob = pageTemplates[0] !== job.templateJson ? { ...job, templateJson: pageTemplates[0] } : job;
+  const template = pageTemplates[0];
+  const normalized = normalizePrintData(singleJob.printData);
+  if (normalized.mode === "single") {
+    const single = await prepareSingleWithSession(singleJob, session, normalized.data);
+    if (template.tiling?.enabled === true) {
+      return composeTiledPrepared(singleJob, [{
+        bound: single.bound,
+        pageLayouts: single.pageLayouts,
+        data: normalized.data,
+        codeRenderer: single.codeRenderer,
+        derivedHeightMm: single.derivedHeightMm,
+        paperMm: single.paperMm,
+        heightSource: single.heightSource
+      }]);
+    }
+    return toPreparedDocument(single);
+  }
+  const copies = [];
+  for (let i = 0; i < normalized.dataList.length; i++) {
+    try {
+      const single = await prepareSingleWithSession(singleJob, session, normalized.dataList[i]);
+      copies.push({
+        bound: single.bound,
+        pageLayouts: single.pageLayouts,
+        data: normalized.dataList[i],
+        codeRenderer: single.codeRenderer,
+        derivedHeightMm: single.derivedHeightMm,
+        paperMm: single.paperMm,
+        heightSource: single.heightSource
+      });
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      throw new Error(`\u7B2C ${i + 1} \u4EFD\u6E32\u67D3\u5931\u8D25\uFF1A${reason}`);
+    }
+  }
+  if (template.tiling?.enabled === true) {
+    return composeTiledPrepared(singleJob, copies);
+  }
+  const merged = composeBatchHtml(copies);
+  return {
+    html: merged.html,
+    pageCount: merged.pageCount,
+    paperMm: copies[0].paperMm,
+    continuous: isContinuousPaper(copies[0].bound),
+    // 同模板同参数各份来源必然一致；不能用 derivedHeightMm 是否存在判断——
+    // 连续纸逃生门时该字段有值但来源是 config
+    heightSource: copies[0].heightSource,
+    // 各份 pageIndex 均从 0 开始，批量拼接后该字段仅作调试用途
+    pageLayouts: copies.flatMap((c) => c.pageLayouts),
+    copies: copies.length,
+    copyPaperMm: merged.copyPaperMm
+  };
+}
+function toPreparedDocument(s) {
+  return {
+    html: s.html,
+    pageCount: s.pageCount,
+    paperMm: s.paperMm,
+    continuous: s.continuous,
+    heightSource: s.heightSource,
+    pageLayouts: s.pageLayouts,
+    copies: 1
+  };
+}
+function composeTiledPrepared(job, copies) {
+  const bound = copies[0].bound;
+  const layout = computeTileLayout(bound, { paperOverride: job.paperOverride });
+  copies.forEach((copy, i) => {
+    const overflow = copy.pageLayouts[0]?.overflow === true;
+    if (copy.pageLayouts.length !== 1 || overflow) {
+      const detail = overflow ? "\u5185\u5BB9\u8D85\u51FA\u7EB8\u5F20\u9AD8\u5EA6" : `\u6E32\u67D3\u51FA ${copy.pageLayouts.length} \u9875`;
+      throw new Error(
+        `\u62FC\u7248\u8981\u6C42\u6BCF\u4EFD\u6807\u7B7E\u6070\u597D 1 \u9875\uFF0C\u7B2C ${i + 1} \u4EFD${detail}\uFF1B\u8BF7\u7F29\u5C0F\u5185\u5BB9\u6216\u8C03\u6574\u6807\u7B7E\u7EB8\u5F20\u9AD8\u5EA6`
+      );
+    }
+  });
+  const tiled = composeTiledHtml({
+    copies: copies.map((c) => ({
+      bound: c.bound,
+      pageLayouts: c.pageLayouts,
+      data: c.data,
+      codeRenderer: c.codeRenderer
+    })),
+    layout
+  });
+  return {
+    html: tiled.html,
+    // 语义变更：pageCount = 实际输出张数（客户端任务历史、预览「共 N 页」都按此口径）
+    pageCount: tiled.sheetCount,
+    paperMm: { width: layout.sheet.width, height: layout.sheet.height },
+    continuous: false,
+    heightSource: "config",
+    // 调试用途；各份 pageIndex 均从 0 开始
+    pageLayouts: copies.flatMap((c) => c.pageLayouts),
+    copies: copies.length
+  };
+}
+async function prepareSingleWithSession(job, session, data) {
+  const bound = bindData(job.templateJson, data, job.baseUrl, job.fontBaseUrl);
+  const continuous = isContinuousPaper(bound);
+  const designPaper = getPaperDimensions(bound);
+  const viewport = paperViewportPx(designPaper);
+  const heightEscape = escapeHeightMm({ paperHeightMm: job.paperHeightMm, override: job.paperOverride });
+  const measurement = await buildHtmlWithCodes({
+    bound,
+    job,
+    session,
+    data,
+    pageLayouts: [],
+    isMeasurementPass: true
+  });
+  const measurements = await session.measure(measurement.html, viewport);
+  applyTextFitSizes(bound, measurements.fits);
+  const pageLayouts = paginate(bound, normalizeMeasurements(measurements.measurements, bound));
+  const finalBuild = await buildHtmlWithCodes({
+    bound,
+    job,
+    session,
+    data,
+    pageLayouts,
+    isMeasurementPass: false,
+    baseMap: measurement.map
+  });
+  let html = finalBuild.html;
+  let derivedHeightMm;
+  if (continuous) {
+    if (heightEscape && heightEscape > 0) {
+      derivedHeightMm = heightEscape;
+    } else {
+      const bottomPx = await session.probeContentBottom(html, viewport);
+      derivedHeightMm = composeContinuousHeight(bound, pxToMm2(bottomPx));
+    }
+    html = generateHtml(bound, pageLayouts, data, {
+      codeRenderer: finalBuild.codeRenderer,
+      pageHeightMm: derivedHeightMm
+    });
+  }
+  const overrideForPaper = continuous && heightEscape ? { ...job.paperOverride, height: heightEscape } : job.paperOverride;
+  const outputPaper = getOutputPaperDimensions(bound);
+  const { paperMm, heightSource } = resolvePaperMm({
+    paperMm: { width: outputPaper.width, height: derivedHeightMm ?? outputPaper.height },
+    continuous,
+    override: overrideForPaper
+  });
+  return {
+    html,
+    pageCount: pageLayouts.length,
+    paperMm,
+    continuous,
+    heightSource,
+    pageLayouts,
+    copies: 1,
+    bound,
+    codeRenderer: finalBuild.codeRenderer,
+    derivedHeightMm
+  };
+}
+async function prepareMultiCopy(job, session, data) {
+  const templates = normalizeTemplate(job.templateJson);
+  const viewport = paperViewportPx(getPaperDimensions(templates[0]));
+  const boundPages = [];
+  const layoutsPerPage = [];
+  const codeRenderers = [];
+  for (const t of templates) {
+    const bound = bindData(t, data, job.baseUrl, job.fontBaseUrl);
+    const measurement = await buildHtmlWithCodes({ bound, job, session, data, pageLayouts: [], isMeasurementPass: true });
+    const measurements = await session.measure(measurement.html, viewport);
+    applyTextFitSizes(bound, measurements.fits);
+    const layouts = paginate(bound, normalizeMeasurements(measurements.measurements, bound));
+    const final = await buildHtmlWithCodes({ bound, job, session, data, pageLayouts: layouts, isMeasurementPass: false, baseMap: measurement.map });
+    boundPages.push(bound);
+    layoutsPerPage.push(layouts);
+    codeRenderers.push(final.codeRenderer);
+  }
+  return { boundPages, layoutsPerPage, data, codeRenderers };
+}
+async function buildHtmlWithCodes(input) {
+  const baseMap = input.baseMap ?? /* @__PURE__ */ new Map();
+  if (input.job.codeRenderer) {
+    const html2 = generateHtml(input.bound, input.pageLayouts, input.data, {
+      isMeasurementPass: input.isMeasurementPass,
+      codeRenderer: input.job.codeRenderer
+    });
+    return { html: html2, codeRenderer: input.job.codeRenderer, map: baseMap };
+  }
+  const collector = createCollectingCodeRenderer(baseMap);
+  const draft = generateHtml(input.bound, input.pageLayouts, input.data, {
+    isMeasurementPass: input.isMeasurementPass,
+    codeRenderer: collector.renderer
+  });
+  const extra = collector.takeSpecs();
+  const rendered = extra.length > 0 ? await input.session.renderCodes(extra) : /* @__PURE__ */ new Map();
+  const map = mergeCodeMaps(baseMap, rendered);
+  const codeRenderer = map.size > 0 ? createMapCodeRenderer(map) : void 0;
+  if (extra.length === 0) return { html: draft, codeRenderer, map };
+  const html = generateHtml(input.bound, input.pageLayouts, input.data, {
+    isMeasurementPass: input.isMeasurementPass,
+    codeRenderer
+  });
+  return { html, codeRenderer, map };
+}
+
+export {
+  tokenize,
+  parse,
+  evaluate,
+  parseTemplate,
+  renderTemplate,
+  compileTemplate,
+  getByPath,
+  formatMoney,
+  formatDate,
+  toUpperCaseAmount,
+  ifFn,
+  sum,
+  avg,
+  count,
+  min,
+  max,
+  setPageIndex,
+  setTotalPages,
+  systemVars,
+  addNumbers,
+  subtractNumbers,
+  multiplyNumbers,
+  divideNumbers,
+  round,
+  roundUp,
+  roundDown,
+  roundHalfEven,
+  safeEval,
+  evaluateTemplate,
+  bindData,
+  resolveSystemVariables,
+  injectSystemVariables,
+  buildFontFaceCss,
+  FALLBACK_FONT_STACK,
+  escapeInlineStyleValue,
+  toFontFamilyStack,
+  PAPER_DIMENSIONS,
+  isContinuousPaperSize,
+  getPaperDimensions,
+  isContinuousPaper,
+  mm,
+  buildBasePageCss,
+  buildPageRuleCss,
+  buildPageGeometryCss,
+  buildPageCss,
+  elementPositionStyle,
+  ptToMm,
+  pxToMm,
+  mmToPx,
+  DEFAULT_SHRINK_MIN_FONT_SIZE_PT,
+  MIN_SHRINK_FONT_SIZE_PT,
+  resolveElementTextFit,
+  resolveCellTextFit,
+  resolveShrinkMinFontSize,
+  roundFontSize,
+  floorFontSize,
+  cellFitKey,
+  parseCellFitKey,
+  cellFitWidthMm,
+  cellFitCapMm,
+  PX_PER_MM,
+  MM_PER_PX,
+  WATERMARK_DEFAULTS,
+  WATERMARK_DENSITY_PRESETS,
+  isWatermarkVisible,
+  resolveWatermarkText,
+  formatTimestamp,
+  resolveWatermarkLayout,
+  renderWatermarkTileSvg,
+  renderWatermarkLayerHtml,
+  tableDesignBottom,
+  paginate,
+  MM_PER_INCH,
+  BARCODE_QUIET_ZONE_MODULES,
+  BARCODE_BAR_HEIGHT_MODULES,
+  BARCODE_TEXT_FONT_SIZE_MODULES,
+  BARCODE_MARGIN_BOTTOM_MODULES,
+  BARCODE_MODULE_WIDTH_MM,
+  barcodeUnitsPerModule,
+  barcodePreferredModuleWidthMm,
+  barcodeAvailableBoxMm,
+  resolveBarcodeSize,
+  generateHtml,
+  MIN_CONTINUOUS_HEIGHT_MM,
+  composeContinuousHeight,
+  MICROMETERS_PER_MM,
+  MM_PER_INCH2,
+  MICROMETERS_PER_INCH,
+  pxToMm2,
+  mmToPx2,
+  millimetersToMicrometers,
+  micrometersToMillimeters,
+  millimetersToInches,
+  PrintFailure,
+  toPrintFailure,
+  withTimeout,
+  escapeHeightMm,
+  resolvePaperMm,
+  paperViewportPx,
+  buildPdfTargetSpec,
+  toElectronPrintToPdfOptions,
+  toPlaywrightPdfOptions,
+  buildScreenshotTargetSpec,
+  normalizeMeasurements,
+  applyTextFitSizes,
+  codeSpecKey,
+  createMapCodeRenderer,
+  createCollectingCodeRenderer,
+  mergeCodeMaps,
+  EXECUTOR_TARGETS,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_READINESS_MS,
+  createDomHostRuntime,
+  MAX_BATCH_COPIES,
+  normalizePrintData,
+  composeBatchHtml,
+  TILE_DEFAULTS,
+  TilingError,
+  roundMm,
+  normalizeTilingOptions,
+  resolveSheetMm,
+  computeTileLayout,
+  tilePosition,
+  computeMaxColumns,
+  validateTiling,
+  composeTiledHtml,
+  normalizeTemplate,
+  isMultiPageTemplate,
+  mergeFontDeclarations,
+  composeMultiPageDocument,
+  prepareDocument,
+  renderPdf,
+  renderScreenshot
+};