@agile-team/mach-report 2.16.0 → 2.18.0

package/dist/{template-registry-Cw3vRTX2.js → template-registry-BIhIHOab.js}

@@ -1,35 +1,35 @@
-import { v as X } from "./matrix-CGRGkn5s.js";
-import { v as Y, c as Q } from "./computed-C-4C2S5h.js";
-import { c as j, r as Z, R as ee } from "./component-tree-Ca6YYfHq.js";
-import { c as te } from "./code-options-BKXXY7NI.js";
-import { v as ie, e as se } from "./param-validation-Do7Eg8Zv.js";
-import { v as ne, a as oe } from "./tree-CjVZLRw7.js";
-function ae(e, i, t) {
+import { k as q, v as X, c as Y } from "./computed-C8NRZQss.js";
+import { d as Q, v as Z } from "./matrix-Dy-tyY7E.js";
+import { c as B, v as ee, r as te, R as ie } from "./component-tree-CvW4lzpv.js";
+import { c as se } from "./code-options-BKXXY7NI.js";
+import { v as ne, m as ae } from "./param-validation-CnDEd2l-.js";
+import { a as oe, b as fe, v as re } from "./column-visual-BpgQVWwT.js";
+function de(e, i, t) {
   e !== void 0 && (typeof e != "string" || !e.trim() || e.length > 4096) && t.push({ path: i, message: "来源范围应为不超过 4096 字符的非空字符串" });
 }
-function D(e, i, t) {
+function j(e, i, t) {
   e.editable !== void 0 && typeof e.editable != "boolean" && t.push({ path: `${i}.editable`, message: "编辑控制应为布尔值" }), e.valueType !== void 0 && !["text", "number", "boolean"].includes(e.valueType) && t.push({ path: `${i}.valueType`, message: "编辑类型应为 text、number 或 boolean" });
 }
-function fe(e, i, t) {
-  D(e, i, t), e.indentMm !== void 0 && (typeof e.indentMm != "number" || !Number.isFinite(e.indentMm) || e.indentMm < 0) && t.push({ path: `${i}.indentMm`, message: "单元格缩进应为有限非负数" }), e.derived !== void 0 && typeof e.derived != "boolean" && t.push({ path: `${i}.derived`, message: "派生结果标记应为布尔值" }), V(e.source, `${i}.source`, t, !0), e.formula !== void 0 && typeof e.formula != "string" && t.push({ path: `${i}.formula`, message: "单元格公式应为字符串" });
+function he(e, i, t) {
+  j(e, i, t), e.indentMm !== void 0 && (typeof e.indentMm != "number" || !Number.isFinite(e.indentMm) || e.indentMm < 0) && t.push({ path: `${i}.indentMm`, message: "单元格缩进应为有限非负数" }), e.derived !== void 0 && typeof e.derived != "boolean" && t.push({ path: `${i}.derived`, message: "派生结果标记应为布尔值" }), D(e.source, `${i}.source`, t, !0), e.formula !== void 0 && typeof e.formula != "string" && t.push({ path: `${i}.formula`, message: "单元格公式应为字符串" });
 }
-function V(e, i, t, s = !1) {
+function D(e, i, t, s = !1) {
   if (e === void 0) return;
   if (!e || typeof e != "object" || Array.isArray(e)) {
     t.push({ path: i, message: "业务来源应为对象" });
     return;
   }
   const n = e;
-  ae(n.sourceScope, `${i}.sourceScope`, t);
-  for (const o of ["datasetId", ...s ? ["field"] : []])
-    (typeof n[o] != "string" || !n[o].trim()) && t.push({ path: `${i}.${o}`, message: "业务标识应为非空字符串" });
-  for (const o of ["rowKey", "revision"]) {
-    const a = n[o];
-    a === void 0 && !(s && o === "rowKey") || typeof a != "string" && !(typeof a == "number" && Number.isFinite(a)) && t.push({ path: `${i}.${o}`, message: "业务键及修订号应为字符串或有限数字" });
+  de(n.sourceScope, `${i}.sourceScope`, t);
+  for (const a of ["datasetId", ...s ? ["field"] : []])
+    (typeof n[a] != "string" || !n[a].trim()) && t.push({ path: `${i}.${a}`, message: "业务标识应为非空字符串" });
+  for (const a of ["rowKey", "revision"]) {
+    const o = n[a];
+    o === void 0 && !(s && a === "rowKey") || typeof o != "string" && !(typeof o == "number" && Number.isFinite(o)) && t.push({ path: `${i}.${a}`, message: "业务键及修订号应为字符串或有限数字" });
   }
   n.sourceToken !== void 0 && typeof n.sourceToken != "string" && t.push({ path: `${i}.sourceToken`, message: "来源令牌应为字符串" });
 }
-const re = /* @__PURE__ */ new Set([
+const ue = /* @__PURE__ */ new Set([
   "text",
   "image",
   "barcode",
@@ -45,58 +45,58 @@ function g(e) {
 function E(e) {
   return e === null ? "null" : typeof e == "string" ? JSON.stringify(e.slice(0, 120)) : ["number", "boolean", "undefined"].includes(typeof e) ? String(e) : `[${typeof e}]`;
 }
-function de(e, i, t, s) {
+function me(e, i, t, s) {
   const n = e[i];
   (typeof n != "number" || !Number.isFinite(n)) && s.push({ path: `${t}.${i}`, message: `应为有限数字，实际 ${E(n)}` });
 }
-function ue(e, i, t) {
+function ce(e, i, t) {
   if (e !== void 0) {
     const s = `${i}.table`;
     if (!g(e)) t.push({ path: s, message: "逻辑表来源应为对象" });
     else {
-      V(e.source, `${s}.source`, t), (typeof e.id != "string" || !e.id.trim()) && t.push({ path: `${s}.id`, message: "逻辑表 ID 应为非空字符串" });
+      D(e.source, `${s}.source`, t), (typeof e.id != "string" || !e.id.trim()) && t.push({ path: `${s}.id`, message: "逻辑表 ID 应为非空字符串" });
       const n = e.role;
       ["header", "body", "group-header", "subtotal", "grand-total"].includes(n) || t.push({ path: `${s}.role`, message: "未知逻辑表行角色" });
-      const o = e.rowIndex;
-      (typeof o != "number" || !Number.isInteger(o) || (n === "header" ? o !== -1 : o < 0)) && t.push({ path: `${s}.rowIndex`, message: "表头索引应为 -1，内容行索引应为非负整数" }), (!Array.isArray(e.columnKeys) || e.columnKeys.some((a) => typeof a != "string")) && t.push({ path: `${s}.columnKeys`, message: "逻辑列字段应为字符串数组" }), e.layout !== void 0 && e.layout !== "page" && e.layout !== "wide" && t.push({ path: `${s}.layout`, message: "布局应为 page 或 wide" }), e.title !== void 0 && typeof e.title != "string" && t.push({ path: `${s}.title`, message: "逻辑表名称应为字符串" });
+      const a = e.rowIndex;
+      (typeof a != "number" || !Number.isInteger(a) || (n === "header" ? a !== -1 : a < 0)) && t.push({ path: `${s}.rowIndex`, message: "表头索引应为 -1，内容行索引应为非负整数" }), (!Array.isArray(e.columnKeys) || e.columnKeys.some((o) => typeof o != "string")) && t.push({ path: `${s}.columnKeys`, message: "逻辑列字段应为字符串数组" }), e.layout !== void 0 && e.layout !== "page" && e.layout !== "wide" && t.push({ path: `${s}.layout`, message: "布局应为 page 或 wide" }), e.title !== void 0 && typeof e.title != "string" && t.push({ path: `${s}.title`, message: "逻辑表名称应为字符串" });
     }
   }
 }
-function he(e, i, t, s) {
+function ge(e, i, t, s) {
   if (e !== void 0)
     if (!g(e) || !Array.isArray(e.cells))
       t.push({ path: `${i}.grid.cells`, message: "grid.cells 应为二维数组" });
     else {
       const n = e.paddingMm;
-      n !== void 0 && (typeof n != "number" || !Number.isFinite(n) || n < 0) && t.push({ path: `${i}.grid.paddingMm`, message: "单元格内距应为有限非负数" }), e.cells.forEach((o, a) => {
-        if (!Array.isArray(o)) {
-          t.push({ path: `${i}.grid.cells.${a}`, message: "行应为数组" });
+      n !== void 0 && (typeof n != "number" || !Number.isFinite(n) || n < 0) && t.push({ path: `${i}.grid.paddingMm`, message: "单元格内距应为有限非负数" }), e.cells.forEach((a, o) => {
+        if (!Array.isArray(a)) {
+          t.push({ path: `${i}.grid.cells.${o}`, message: "行应为数组" });
           return;
         }
-        o.forEach((f, r) => {
+        a.forEach((f, r) => {
           if (f == null) return;
-          const d = `${i}.grid.cells.${a}.${r}`;
+          const d = `${i}.grid.cells.${o}.${r}`;
           if (!g(f)) {
             t.push({ path: d, message: "网格单元格应为对象或 null" });
             return;
           }
-          fe(f, d, t), K(f.richParagraphs, d, t), Array.isArray(f.children) && f.children.forEach((u, p) => {
-            I(u, `${i}.grid.cells.${a}.${r}.children.${p}`, t, s);
+          he(f, d, t), f.dataBar !== void 0 && !ee(f.dataBar) && t.push({ path: `${d}.dataBar`, message: "数据条应包含 0–1 有序比例与 #RRGGBB 颜色" }), V(f.richParagraphs, d, t), Array.isArray(f.children) && f.children.forEach((h, p) => {
+            I(h, `${i}.grid.cells.${o}.${r}.children.${p}`, t, s);
           });
         });
       });
     }
 }
-function S(e, i, t, s) {
+function N(e, i, t, s) {
   e !== void 0 && !i.includes(e) && s.push({ path: t, message: "未知富文本属性值" });
 }
-function F(e, i, t, s, n = 0) {
-  for (const o of i) {
-    const a = e[o];
-    a !== void 0 && (typeof a != "number" || !Number.isFinite(a) || a < n) && s.push({ path: `${t}.${o}`, message: "富文本数值应为范围内有限数字" });
+function T(e, i, t, s, n = 0) {
+  for (const a of i) {
+    const o = e[a];
+    o !== void 0 && (typeof o != "number" || !Number.isFinite(o) || o < n) && s.push({ path: `${t}.${a}`, message: "富文本数值应为范围内有限数字" });
   }
 }
-function me(e, i, t) {
+function pe(e, i, t) {
   if (e !== void 0) {
     if (!g(e)) {
       t.push({ path: i, message: "富文本样式应为对象" });
@@ -106,37 +106,37 @@ function me(e, i, t) {
       e[s] !== void 0 && typeof e[s] != "string" && t.push({ path: `${i}.${s}`, message: "富文本样式应为字符串" });
     for (const s of ["bold", "italic", "underline", "borderTop", "borderRight", "borderBottom", "borderLeft"])
       e[s] !== void 0 && typeof e[s] != "boolean" && t.push({ path: `${i}.${s}`, message: "富文本样式应为布尔值" });
-    F(e, ["fontSize", "fontSizePx", "lineWidthPt", "lineHeight", "opacity"], i, t), F(e, ["letterSpacing", "rotateDeg"], i, t, -1 / 0), typeof e.opacity == "number" && e.opacity > 1 && t.push({ path: `${i}.opacity`, message: "透明度不能大于1" }), S(e.align, ["left", "center", "right", "justify"], `${i}.align`, t), S(e.verticalAlign, ["top", "middle", "bottom"], `${i}.verticalAlign`, t);
+    T(e, ["fontSize", "fontSizePx", "lineWidthPt", "lineHeight", "opacity"], i, t), T(e, ["letterSpacing", "rotateDeg"], i, t, -1 / 0), typeof e.opacity == "number" && e.opacity > 1 && t.push({ path: `${i}.opacity`, message: "透明度不能大于1" }), N(e.align, ["left", "center", "right", "justify"], `${i}.align`, t), N(e.verticalAlign, ["top", "middle", "bottom"], `${i}.verticalAlign`, t);
   }
 }
-function ce(e, i, t) {
+function ye(e, i, t) {
   if (!g(e)) {
     t.push({ path: i, message: "富文本片段应为对象" });
     return;
   }
-  S(e.kind, ["text", "field"], `${i}.kind`, t);
+  N(e.kind, ["text", "field"], `${i}.kind`, t);
   for (const s of ["text", "field"])
     e[s] !== void 0 && typeof e[s] != "string" && t.push({ path: `${i}.${s}`, message: "富文本内容应为字符串" });
-  me(e.style, `${i}.style`, t);
+  pe(e.style, `${i}.style`, t);
 }
-function K(e, i, t) {
+function V(e, i, t) {
   if (e !== void 0) {
     if (!Array.isArray(e)) {
       t.push({ path: `${i}.richParagraphs`, message: "richParagraphs 应为数组" });
       return;
     }
     e.forEach((s, n) => {
-      const o = `${i}.richParagraphs.${n}`;
+      const a = `${i}.richParagraphs.${n}`;
       if (!g(s) || !Array.isArray(s.segments)) {
-        t.push({ path: o, message: "段落缺少 segments 数组" });
+        t.push({ path: a, message: "段落缺少 segments 数组" });
         return;
       }
-      S(s.align, ["left", "center", "right", "justify"], `${o}.align`, t), F(s, ["lineHeight", "spaceBeforeMm", "spaceAfterMm", "indentMm"], o, t), s.segments.forEach((a, f) => ce(a, `${o}.segments.${f}`, t));
+      N(s.align, ["left", "center", "right", "justify"], `${a}.align`, t), T(s, ["lineHeight", "spaceBeforeMm", "spaceAfterMm", "indentMm"], a, t), s.segments.forEach((o, f) => ye(o, `${a}.segments.${f}`, t));
     });
   }
 }
-function H(e, i, t, s = []) {
-  const n = j([e], i);
+function K(e, i, t, s = []) {
+  const n = B([e], i);
   if (n) {
     t.push(n);
     return;
@@ -149,53 +149,62 @@ function I(e, i, t, s = []) {
     return;
   }
   const n = e.kind;
-  typeof n != "string" ? t.push({ path: `${i}.kind`, message: "组件缺少 kind 字符串" }) : re.has(n) || s.push({
+  typeof n != "string" ? t.push({ path: `${i}.kind`, message: "组件缺少 kind 字符串" }) : ue.has(n) || s.push({
     path: `${i}.kind`,
     message: `未知组件类型 ${E(n)}，将以兜底方式渲染`
   });
-  for (const o of ["leftMm", "topMm", "widthMm", "heightMm"])
-    de(e, o, i, t);
+  for (const a of ["leftMm", "topMm", "widthMm", "heightMm"])
+    me(e, a, i, t);
   typeof e.leftMm == "number" && e.leftMm < -100 && t.push({ path: `${i}.leftMm`, message: "几何数值异常（leftMm<-100）" });
-  for (const o of ["widthMm", "heightMm"])
-    typeof e[o] == "number" && e[o] < 0 && t.push({ path: `${i}.${o}`, message: "组件尺寸不能为负数" });
-  ue(e.table, i, t), ge(e.code, n, i, t), e.pageAnchor !== void 0 && !["header", "footer"].includes(e.pageAnchor) && t.push({ path: `${i}.pageAnchor`, message: "页面锚点应为 header 或 footer" }), e.lineDirection !== void 0 && !["down", "up"].includes(e.lineDirection) && t.push({ path: `${i}.lineDirection`, message: "线段方向应为 down 或 up" }), he(e.grid, i, t, s), K(e.richParagraphs, i, t);
+  for (const a of ["widthMm", "heightMm"])
+    typeof e[a] == "number" && e[a] < 0 && t.push({ path: `${i}.${a}`, message: "组件尺寸不能为负数" });
+  ce(e.table, i, t), $e(e.code, n, i, t), le(e, i, t), e.pageAnchor !== void 0 && !["header", "footer"].includes(e.pageAnchor) && t.push({ path: `${i}.pageAnchor`, message: "页面锚点应为 header 或 footer" }), e.lineDirection !== void 0 && !["down", "up"].includes(e.lineDirection) && t.push({ path: `${i}.lineDirection`, message: "线段方向应为 down 或 up" }), ge(e.grid, i, t, s), V(e.richParagraphs, i, t);
 }
-function ge(e, i, t, s) {
+function le(e, i, t) {
+  if (e.chartBinding !== void 0)
+    try {
+      if (Q(e.chartBinding), e.kind !== "chart" || ["binding", "imageData", "grid", "pageAnchor"].some((s) => e[s] !== void 0)) throw new Error("绑定图表不能设置图片、网格、记录绑定或页眉页脚");
+      if (typeof e.widthMm != "number" || e.widthMm < 45 || typeof e.heightMm != "number" || e.heightMm < 35) throw new Error("绑定图表至少需要 45×35mm");
+    } catch (s) {
+      t.push({ path: `${i}.chartBinding`, message: s instanceof Error ? s.message : String(s) });
+    }
+}
+function $e(e, i, t, s) {
   if (e !== void 0)
-    for (const n of te(e, i)) s.push({ path: `${t}.code${n.path ? `.${n.path}` : ""}`, message: n.message });
+    for (const n of se(e, i)) s.push({ path: `${t}.code${n.path ? `.${n.path}` : ""}`, message: n.message });
 }
-function J(e, i, t) {
+function H(e, i, t) {
   if (!g(e)) return;
-  e.binding !== void 0 && t.push({ path: `${i}.binding`, message: "渲染计划不允许未解析字段绑定" });
+  e.binding !== void 0 && t.push({ path: `${i}.binding`, message: "渲染计划不允许未解析字段绑定" }), e.chartBinding !== void 0 && t.push({ path: `${i}.chartBinding`, message: "渲染计划不允许未解析图表绑定" });
   const s = e.grid;
-  !g(s) || !Array.isArray(s.cells) || s.cells.forEach((n, o) => {
-    Array.isArray(n) && n.forEach((a, f) => {
-      !g(a) || !Array.isArray(a.children) || a.children.forEach((r, d) => J(r, `${i}.grid.cells.${o}.${f}.children.${d}`, t));
+  !g(s) || !Array.isArray(s.cells) || s.cells.forEach((n, a) => {
+    Array.isArray(n) && n.forEach((o, f) => {
+      !g(o) || !Array.isArray(o.children) || o.children.forEach((r, d) => H(r, `${i}.grid.cells.${a}.${f}.children.${d}`, t));
     });
   });
 }
-function pe(e, i, t, s = []) {
+function be(e, i, t, s = []) {
   if (!g(e)) {
     t.push({ path: i, message: "页应为对象" });
     return;
   }
-  const n = e.pageWidthMm, o = e.pageHeightMm;
-  (typeof n != "number" || !Number.isFinite(n) || n <= 0) && t.push({ path: `${i}.pageWidthMm`, message: `页宽非法: ${E(n)}` }), (typeof o != "number" || !(o > 0 && o < 5e3)) && t.push({ path: `${i}.pageHeightMm`, message: `页高非法: ${E(o)}` }), e.layout !== void 0 && e.layout !== "page" && e.layout !== "wide" && t.push({ path: `${i}.layout`, message: "布局应为 page 或 wide" });
-  const a = e.components;
-  if (!Array.isArray(a))
+  const n = e.pageWidthMm, a = e.pageHeightMm;
+  (typeof n != "number" || !Number.isFinite(n) || n <= 0) && t.push({ path: `${i}.pageWidthMm`, message: `页宽非法: ${E(n)}` }), (typeof a != "number" || !(a > 0 && a < 5e3)) && t.push({ path: `${i}.pageHeightMm`, message: `页高非法: ${E(a)}` }), e.layout !== void 0 && e.layout !== "page" && e.layout !== "wide" && t.push({ path: `${i}.layout`, message: "布局应为 page 或 wide" });
+  const o = e.components;
+  if (!Array.isArray(o))
     t.push({ path: `${i}.components`, message: "components 应为数组" });
-  else if (Array.isArray(a)) {
-    const f = j(a, `${i}.components`);
+  else if (Array.isArray(o)) {
+    const f = B(o, `${i}.components`);
     if (f) {
       t.push(f);
       return;
     }
-    a.forEach((r, d) => {
-      I(r, `${i}.components.${d}`, t, s), J(r, `${i}.components.${d}`, t);
+    o.forEach((r, d) => {
+      I(r, `${i}.components.${d}`, t, s), H(r, `${i}.components.${d}`, t);
     });
   }
 }
-function ye(e) {
+function Ae(e) {
   const i = [], t = [], s = g(e) ? e.pages : void 0;
   if (g(e) && e.requiresRecalculation !== void 0 && typeof e.requiresRecalculation != "boolean" && i.push({ path: "$.requiresRecalculation", message: "重算能力要求应为布尔值" }), !Array.isArray(s))
     i.push({
@@ -203,25 +212,25 @@ function ye(e) {
       message: e == null ? "渲染计划为空" : "渲染计划缺少 pages 数组"
     });
   else {
-    const n = Z(s);
+    const n = te(s);
     if (n) return { ok: !1, errors: [...i, n], warnings: t };
-    s.forEach((a, f) => pe(a, `$.pages.${f}`, i, t)), s.length > 2e3 && t.push({
+    s.forEach((o, f) => be(o, `$.pages.${f}`, i, t)), s.length > 2e3 && t.push({
       path: "$.pages",
       message: `页数异常大（${s.length} 页），渲染与打印耗时可能显著增加`
     });
-    const o = s.reduce(
-      (a, f) => a + (g(f) && Array.isArray(f.components) ? f.components.length : 0),
+    const a = s.reduce(
+      (o, f) => o + (g(f) && Array.isArray(f.components) ? f.components.length : 0),
       0
     );
-    o > 5e4 && t.push({
+    a > 5e4 && t.push({
       path: "$.pages",
-      message: `组件总数异常大（${o} 个），可能触发浏览器性能限制`
+      message: `组件总数异常大（${a} 个），可能触发浏览器性能限制`
     });
   }
   return { ok: i.length === 0, errors: i, warnings: t };
 }
-function Qe(e) {
-  const i = ye(e);
+function st(e) {
+  const i = Ae(e);
   if (!i.ok) {
     const t = i.errors.slice(0, 3).map((s) => `${s.path}: ${s.message}`).join("; ");
     throw new Error(`渲染计划校验失败(${i.errors.length} 处): ${t}`);
@@ -231,69 +240,69 @@ function Qe(e) {
 function O(e) {
   return e.kind === "list" ? e.id : e.nid;
 }
-function le(e) {
+function we(e) {
   return e.kind === "list" ? !1 : e.pageAnchor !== void 0 || e.kind === "text" && typeof e.text == "string" && /\{(?:page|totalPages)\}/.test(e.text);
 }
-function $e(e, i) {
+function Me(e, i) {
   const t = e.filter((n) => i.componentIds.includes(O(n) ?? ""));
   if (t.filter((n) => n.kind === "list" && n.cardinality !== "record").length && t.length !== 1) throw new Error("纵向重复区域必须独占流式分段，不能与静态或单记录区域并排");
   for (const n of t) {
-    const o = n.kind === "list" ? n.topMm + (n.rowHeightMm ?? 0) : n.topMm + n.heightMm;
-    if (n.topMm < i.topMm - 1e-3 || o > i.topMm + i.heightMm + 1e-3) throw new Error("流式分段应完整包含其组件的原始纵向范围");
+    const a = n.kind === "list" ? n.topMm + (n.rowHeightMm ?? 0) : n.topMm + n.heightMm;
+    if (n.topMm < i.topMm - 1e-3 || a > i.topMm + i.heightMm + 1e-3) throw new Error("流式分段应完整包含其组件的原始纵向范围");
   }
 }
-function Ze(e, i) {
+function nt(e, i) {
   if (!i) return e.map((s) => ({ components: [s] }));
   const t = new Map(e.map((s) => [O(s), s]));
   return i.bands.map((s) => ({ band: s, components: s.componentIds.map((n) => {
-    const o = t.get(n);
-    if (!o) throw new Error(`流式区域引用不存在的组件：${n}`);
-    return o;
+    const a = t.get(n);
+    if (!a) throw new Error(`流式区域引用不存在的组件：${n}`);
+    return a;
   }) }));
 }
-function be(e, i) {
+function ve(e, i) {
   if (!i || !Array.isArray(i.bands) || !i.bands.length || i.bands.length > 1e4) throw new Error("流式排版应包含 1–10000 个区域");
   const t = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set();
   for (const n of e) {
-    if (le(n)) continue;
-    const o = O(n);
-    if (!o || t.has(o)) throw new Error("流式排版组件应具有唯一标识");
-    t.add(o);
+    if (we(n)) continue;
+    const a = O(n);
+    if (!a || t.has(a)) throw new Error("流式排版组件应具有唯一标识");
+    t.add(a);
   }
-  if (Ae(e, i, t, s), s.size !== t.size) throw new Error("流式排版必须显式包含每个非锚点组件");
+  if (ke(e, i, t, s), s.size !== t.size) throw new Error("流式排版必须显式包含每个非锚点组件");
 }
-function Ae(e, i, t, s) {
+function ke(e, i, t, s) {
   let n = -1 / 0;
-  for (const o of i.bands) {
-    if (!Number.isFinite(o.topMm) || !Number.isFinite(o.heightMm) || o.topMm < 0 || o.heightMm <= 0 || o.topMm < n - 1e-3) throw new Error("流式区域应按原始位置排序，尺寸有效且不重叠");
-    if (!Array.isArray(o.componentIds) || !o.componentIds.length) throw new Error("流式区域不能没有组件");
-    for (const a of o.componentIds) {
-      if (!t.has(a) || s.has(a)) throw new Error(`流式区域组件缺失、重复或包含页锚点：${a}`);
-      s.add(a);
+  for (const a of i.bands) {
+    if (!Number.isFinite(a.topMm) || !Number.isFinite(a.heightMm) || a.topMm < 0 || a.heightMm <= 0 || a.topMm < n - 1e-3) throw new Error("流式区域应按原始位置排序，尺寸有效且不重叠");
+    if (!Array.isArray(a.componentIds) || !a.componentIds.length) throw new Error("流式区域不能没有组件");
+    for (const o of a.componentIds) {
+      if (!t.has(o) || s.has(o)) throw new Error(`流式区域组件缺失、重复或包含页锚点：${o}`);
+      s.add(o);
     }
-    $e(e, o), n = o.topMm + o.heightMm;
+    Me(e, a), n = a.topMm + a.heightMm;
   }
 }
-const we = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+const Ee = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
 function l(e) {
   return !!e && typeof e == "object" && !Array.isArray(e);
 }
-function N(e) {
-  return typeof e == "string" && !!e.trim() && !we.has(e);
+function v(e) {
+  return typeof e == "string" && !!e.trim() && !Ee.has(e);
 }
-function v(e, i, t, s) {
+function S(e, i, t, s) {
   for (const n of Object.keys(e)) i.includes(n) || s.push({ path: `${t}.${n}`, message: "存在未知配置字段" });
 }
-function Me(e, i, t) {
+function Ne(e, i, t) {
   if (e !== void 0) {
     if (!l(e) || !["number", "percent", "date"].includes(String(e.kind))) {
       t.push({ path: i, message: "绑定格式应为 number、percent 或 date" });
       return;
     }
-    v(e, e.kind === "date" ? ["kind", "pattern"] : e.kind === "number" ? ["kind", "digits", "thousands"] : ["kind", "digits"], i, t), e.digits !== void 0 && (!Number.isInteger(e.digits) || Number(e.digits) < 0 || Number(e.digits) > 100) && t.push({ path: `${i}.digits`, message: "精度应为 0..100 整数" }), e.thousands !== void 0 && typeof e.thousands != "boolean" && t.push({ path: `${i}.thousands`, message: "千分位开关应为布尔值" }), e.pattern !== void 0 && typeof e.pattern != "string" && t.push({ path: `${i}.pattern`, message: "日期格式应为字符串" });
+    S(e, e.kind === "date" ? ["kind", "pattern"] : e.kind === "number" ? ["kind", "digits", "thousands"] : ["kind", "digits"], i, t), e.digits !== void 0 && (!Number.isInteger(e.digits) || Number(e.digits) < 0 || Number(e.digits) > 100) && t.push({ path: `${i}.digits`, message: "精度应为 0..100 整数" }), e.thousands !== void 0 && typeof e.thousands != "boolean" && t.push({ path: `${i}.thousands`, message: "千分位开关应为布尔值" }), e.pattern !== void 0 && typeof e.pattern != "string" && t.push({ path: `${i}.pattern`, message: "日期格式应为字符串" });
   }
 }
-function Ne(e, i, t) {
+function Se(e, i, t) {
   const s = e.binding;
   if (s === void 0) return;
   const n = `${i}.binding`;
@@ -301,103 +310,99 @@ function Ne(e, i, t) {
     t.push({ path: n, message: "字段绑定应为对象" });
     return;
   }
-  (!["text", "image", "barcode", "qrcode"].includes(String(e.kind)) || e.grid !== void 0) && t.push({ path: n, message: "绑定仅支持独立文本、图片、条码与二维码组件" }), v(s, ["field", "format", "prefix", "suffix", "emptyText"], n, t), N(s.field) || t.push({ path: `${n}.field`, message: "绑定字段应为安全的非空字段名（按字面读取自有字段）" });
-  for (const o of ["prefix", "suffix", "emptyText"]) s[o] !== void 0 && typeof s[o] != "string" && t.push({ path: `${n}.${o}`, message: "应为字符串" });
-  Me(s.format, `${n}.format`, t), e.kind === "image" && ["format", "prefix", "suffix"].some((o) => s[o] !== void 0) && t.push({ path: n, message: "图片绑定直接读取 PNG/JPEG data URL，不支持文本格式或前后缀" });
+  (!["text", "image", "barcode", "qrcode"].includes(String(e.kind)) || e.grid !== void 0) && t.push({ path: n, message: "绑定仅支持独立文本、图片、条码与二维码组件" }), S(s, ["field", "format", "prefix", "suffix", "emptyText"], n, t), v(s.field) || t.push({ path: `${n}.field`, message: "绑定字段应为安全的非空字段名（按字面读取自有字段）" });
+  for (const a of ["prefix", "suffix", "emptyText"]) s[a] !== void 0 && typeof s[a] != "string" && t.push({ path: `${n}.${a}`, message: "应为字符串" });
+  Ne(s.format, `${n}.format`, t), e.kind === "image" && ["format", "prefix", "suffix"].some((a) => s[a] !== void 0) && t.push({ path: n, message: "图片绑定直接读取 PNG/JPEG data URL，不支持文本格式或前后缀" });
 }
-function ke(e, i) {
+function xe(e, i) {
   if (!l(e)) {
     i.push({ path: "$.repeat", message: "逐记录配置应为对象" });
     return;
   }
-  v(e, ["dataset", "rowKey", "copies"], "$.repeat", i), N(e.dataset) || i.push({ path: "$.repeat.dataset", message: "数据集应为安全的非空名称" }), e.rowKey !== void 0 && !N(e.rowKey) && i.push({ path: "$.repeat.rowKey", message: "业务主键应为安全的非空字段名" });
+  S(e, ["dataset", "rowKey", "copies"], "$.repeat", i), v(e.dataset) || i.push({ path: "$.repeat.dataset", message: "数据集应为安全的非空名称" }), e.rowKey !== void 0 && !v(e.rowKey) && i.push({ path: "$.repeat.rowKey", message: "业务主键应为安全的非空字段名" });
   const t = e.copies;
-  t !== void 0 && (l(t) ? (v(t, ["field"], "$.repeat.copies", i), N(t.field) || i.push({ path: "$.repeat.copies.field", message: "复制数字段应为安全的非空字段名" })) : (!Number.isSafeInteger(t) || Number(t) < 1 || Number(t) > 1e3) && i.push({ path: "$.repeat.copies", message: "每条记录复制数应为 1..1000 整数" }));
+  t !== void 0 && (l(t) ? (S(t, ["field"], "$.repeat.copies", i), v(t.field) || i.push({ path: "$.repeat.copies.field", message: "复制数字段应为安全的非空字段名" })) : (!Number.isSafeInteger(t) || Number(t) < 1 || Number(t) > 1e3) && i.push({ path: "$.repeat.copies", message: "每条记录复制数应为 1..1000 整数" }));
 }
-function W(e, i, t, s) {
+function J(e, i, t, s) {
   if (!l(e)) return;
-  Ne(e, i, s), e.binding !== void 0 && !t && s.push({ path: `${i}.binding`, message: "字段绑定需要模板 repeat 数据集；普通报表请使用列表字段" }), t && e.kind === "list" && s.push({ path: i, message: "逐记录标签使用固定组件；动态列表请使用普通报表模板" });
+  Se(e, i, s), e.binding !== void 0 && !t && s.push({ path: `${i}.binding`, message: "字段绑定需要模板 repeat 数据集；普通报表请使用列表字段" }), t && e.kind === "list" && s.push({ path: i, message: "逐记录标签使用固定组件；动态列表请使用普通报表模板" }), e.chartBinding !== void 0 && (t || i.includes(".children.")) && s.push({ path: `${i}.chartBinding`, message: "数据图表应放在普通报表的页面或流式分区，不放在逐记录标签或嵌套单元格内" });
   const n = e.grid;
-  l(n) && Array.isArray(n.cells) && n.cells.forEach((o, a) => {
-    Array.isArray(o) && o.forEach((f, r) => {
-      l(f) && Array.isArray(f.children) && f.children.forEach((d, u) => W(d, `${i}.grid.cells.${a}.${r}.children.${u}`, t, s));
+  l(n) && Array.isArray(n.cells) && n.cells.forEach((a, o) => {
+    Array.isArray(a) && a.forEach((f, r) => {
+      l(f) && Array.isArray(f.children) && f.children.forEach((d, h) => J(d, `${i}.grid.cells.${o}.${r}.children.${h}`, t, s));
     });
   });
 }
-function Ee(e, i) {
+function Re(e, i) {
   const t = e.repeat !== void 0;
-  t && ke(e.repeat, i), Array.isArray(e.pages) && e.pages.forEach((s, n) => {
+  t && xe(e.repeat, i), Array.isArray(e.pages) && e.pages.forEach((s, n) => {
     if (!l(s)) return;
-    const o = `$.pages.${n}`;
-    t && (s.layout === "wide" || s.flow !== void 0) && i.push({ path: o, message: "逐记录标签仅支持固定尺寸页面，不支持宽表或流式分区" }), Array.isArray(s.components) && s.components.forEach((a, f) => {
-      const r = `${o}.components.${f}`;
-      if (W(a, r, t, i), !t || !l(a)) return;
-      const { leftMm: d, topMm: u, widthMm: p, heightMm: y } = a;
-      [d, u, p, y, s.widthMm, s.heightMm].every((A) => typeof A == "number" && Number.isFinite(A)) && (Number(d) < 0 || Number(u) < 0 || Number(d) + Number(p) > Number(s.widthMm) + 1e-3 || Number(u) + Number(y) > Number(s.heightMm) + 1e-3) && i.push({ path: r, message: "标签组件超出纸张边界，请调整位置或尺寸" });
+    const a = `$.pages.${n}`;
+    t && (s.layout === "wide" || s.flow !== void 0) && i.push({ path: a, message: "逐记录标签仅支持固定尺寸页面，不支持宽表或流式分区" }), Array.isArray(s.components) && s.components.forEach((o, f) => {
+      const r = `${a}.components.${f}`;
+      if (J(o, r, t, i), !t || !l(o)) return;
+      const { leftMm: d, topMm: h, widthMm: p, heightMm: y } = o;
+      [d, h, p, y, s.widthMm, s.heightMm].every((A) => typeof A == "number" && Number.isFinite(A)) && (Number(d) < 0 || Number(h) < 0 || Number(d) + Number(p) > Number(s.widthMm) + 1e-3 || Number(h) + Number(y) > Number(s.heightMm) + 1e-3) && i.push({ path: r, message: "标签组件超出纸张边界，请调整位置或尺寸" });
     });
   });
 }
-function G(e) {
+function Te(e) {
   return !!e && typeof e == "object" && !Array.isArray(e);
 }
-function T(e, i, t) {
-  if (e !== void 0) {
-    if (!G(e)) {
-      t.push({ path: i, message: "条件应为对象" });
-      return;
+function F(e, i, t) {
+  if (e !== void 0)
+    try {
+      q(e);
+    } catch (s) {
+      t.push({ path: i, message: s instanceof Error ? s.message : String(s) });
     }
-    (typeof e.field != "string" || !e.field.trim()) && t.push({ path: `${i}.field`, message: "条件需要字段" }), e.numeric !== void 0 && e.numeric !== "number" && e.numeric !== "decimal" && t.push({ path: `${i}.numeric`, message: "未知条件数值模式" }), [">", ">=", "<", "<=", "==", "!="].includes(e.op) || t.push({ path: `${i}.op`, message: "未知条件运算符" }), typeof e.value != "string" && !(typeof e.value == "number" && Number.isFinite(e.value)) && t.push({
-      path: `${i}.value`,
-      message: "条件值应为字符串或有限数字"
-    });
-  }
 }
-function U(e, i, t) {
+function W(e, i, t) {
   if (e === void 0) return;
   if (!Array.isArray(e) || e.length > 2048) {
     t.push({ path: i, message: "聚合应为数组且最多 2048 项" });
     return;
   }
   const s = /* @__PURE__ */ new Set();
-  e.forEach((n, o) => {
-    const a = `${i}.${o}`;
-    if (!G(n)) {
-      t.push({ path: a, message: "聚合应为对象" });
+  e.forEach((n, a) => {
+    const o = `${i}.${a}`;
+    if (!Te(n)) {
+      t.push({ path: o, message: "聚合应为对象" });
       return;
     }
     const f = n.field;
     typeof f != "string" || !f.trim() || s.has(f) ? t.push({
-      path: `${a}.field`,
+      path: `${o}.field`,
       message: "聚合输出字段应非空且唯一"
     }) : s.add(f), n.numeric !== void 0 && n.numeric !== "number" && n.numeric !== "decimal" && t.push({
-      path: `${a}.numeric`,
+      path: `${o}.numeric`,
       message: "数值模式应为 number 或 decimal"
     }), n.digits !== void 0 && (!Number.isInteger(n.digits) || Number(n.digits) < 0 || Number(n.digits) > 100) && t.push({
-      path: `${a}.digits`,
+      path: `${o}.digits`,
       message: "小数位应为 0–100 的整数"
     });
     try {
-      Q({
+      Y({
         ...n,
         field: n.valueField ?? f
       });
     } catch (r) {
       t.push({
-        path: a,
+        path: o,
         message: r instanceof Error ? r.message : String(r)
       });
     }
   });
 }
-function Se(e, i, t) {
+function Fe(e, i, t) {
   if (e === void 0) return;
-  const s = Y(e);
+  const s = X(e);
   for (const n of s.errors) t.push({ path: i, message: n });
 }
-function ve(e, i, t) {
+function Ie(e, i, t) {
   if (e !== void 0)
     try {
-      X(e);
+      Z(e);
     } catch (s) {
       t.push({
         path: i,
@@ -405,65 +410,65 @@ function ve(e, i, t) {
       });
     }
 }
-function xe(e, i, t) {
+function Oe(e, i, t) {
   if (e.tree === void 0) return;
   const s = `${i}.tree`;
   try {
-    ne(e.tree);
+    oe(e.tree);
     const n = e.tree;
     if (e.matrix || e.detail || e.groupBy || Array.isArray(e.groups) && e.groups.length || e.rowVisibleWhen) throw new Error("树形布局不能同时配置普通分组、矩阵、主从或行可见条件");
     if (e.rowKey !== void 0 && e.rowKey !== n.idField) throw new Error("树形 rowKey 应与 idField 一致");
-    if (!Array.isArray(e.columns) || !e.columns.some((o) => o && o.field === n.labelField && !o.hidden)) throw new Error("树形布局需要可见的标签列");
-    Array.isArray(e.computed) && oe(n, e.computed);
+    if (!Array.isArray(e.columns) || !e.columns.some((a) => a && a.field === n.labelField && !a.hidden)) throw new Error("树形布局需要可见的标签列");
+    Array.isArray(e.computed) && fe(n, e.computed);
   } catch (n) {
     t.push({ path: s, message: n instanceof Error ? n.message : String(n) });
   }
 }
-const B = "1.0";
+const G = "1.0";
 class w extends Error {
   constructor(i) {
     super(`模板校验失败：${i.slice(0, 3).map((t) => `${t.path}: ${t.message}`).join("; ")}`), this.errors = i, this.name = "ReportTemplateError";
   }
 }
-const Re = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]), Fe = /* @__PURE__ */ new Set(["schemaVersion", "id", "name", "revision", "description", "template"]), Te = /* @__PURE__ */ new Set(["left", "center", "right", "justify"]), k = 2e5, Ie = 64, P = 1e7;
-function h(e) {
+const Pe = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]), Ce = /* @__PURE__ */ new Set(["schemaVersion", "id", "name", "revision", "description", "template"]), Le = /* @__PURE__ */ new Set(["left", "center", "right", "justify"]), k = 2e5, _e = 64, P = 1e7;
+function u(e) {
   return !!e && typeof e == "object" && !Array.isArray(e);
 }
-function Oe(e, i, t) {
+function Be(e, i, t) {
   const s = Object.getPrototypeOf(e), n = Array.isArray(e);
   if (n ? s !== Array.prototype : s !== Object.prototype && s !== null)
     return t.push({ path: i, message: "模板对象必须使用普通 JSON 对象原型" }), !1;
   if (n) {
-    const o = Object.keys(e);
-    if (o.length !== e.length || o.some((a) => !/^(0|[1-9]\d*)$/.test(a) || Number(a) >= e.length))
+    const a = Object.keys(e);
+    if (a.length !== e.length || a.some((o) => !/^(0|[1-9]\d*)$/.test(o) || Number(o) >= e.length))
       return t.push({ path: i, message: "模板数组不能包含空位或额外属性" }), !1;
   }
   return Object.getOwnPropertySymbols(e).length > 0 ? (t.push({ path: i, message: "模板不能包含 Symbol 键" }), !1) : !0;
 }
-function Pe(e, i, t, s) {
-  return Re.has(e) ? (s.push({ path: t, message: "模板不能包含可能污染原型的键" }), !1) : i.get || i.set || !i.enumerable ? (s.push({ path: t, message: "模板不能包含访问器或不可枚举字段" }), !1) : !0;
+function je(e, i, t, s) {
+  return Pe.has(e) ? (s.push({ path: t, message: "模板不能包含可能污染原型的键" }), !1) : i.get || i.set || !i.enumerable ? (s.push({ path: t, message: "模板不能包含访问器或不可枚举字段" }), !1) : !0;
 }
-function Le(e) {
+function De(e) {
   return e === null || typeof e == "boolean" || typeof e == "number" && Number.isFinite(e);
 }
-function L(e, i) {
+function C(e, i) {
   const t = /* @__PURE__ */ new Set();
-  let s = 0, n = 0, o = !1;
-  const a = (f, r, d) => {
-    if (!o) {
+  let s = 0, n = 0, a = !1;
+  const o = (f, r, d) => {
+    if (!a) {
       if (++s > k) {
         s === k + 1 && i.push({ path: r, message: "模板超过 JSON 节点安全上限" });
         return;
       }
-      if (d > Ie) {
+      if (d > _e) {
         i.push({ path: r, message: "模板嵌套层级过深" });
         return;
       }
       if (typeof f == "string") {
-        n += f.length, n > P && (o = !0, i.push({ path: r, message: "模板文本超过 1000 万字符的安全上限" }));
+        n += f.length, n > P && (a = !0, i.push({ path: r, message: "模板文本超过 1000 万字符的安全上限" }));
         return;
       }
-      if (!Le(f)) {
+      if (!De(f)) {
         if (!f || typeof f != "object") {
           i.push({ path: r, message: "模板只允许 JSON 值，不允许函数、undefined 或非有限数字" });
           return;
@@ -472,37 +477,37 @@ function L(e, i) {
           i.push({ path: r, message: "模板不能包含循环引用" });
           return;
         }
-        if (Oe(f, r, i)) {
+        if (Be(f, r, i)) {
           t.add(f);
-          for (const [u, p] of Object.entries(Object.getOwnPropertyDescriptors(f))) {
-            if (Array.isArray(f) && u === "length") continue;
-            const y = `${r}.${u}`;
-            if (Pe(u, p, y, i) && a(p.value, y, d + 1), s > k || o) break;
+          for (const [h, p] of Object.entries(Object.getOwnPropertyDescriptors(f))) {
+            if (Array.isArray(f) && h === "length") continue;
+            const y = `${r}.${h}`;
+            if (je(h, p, y, i) && o(p.value, y, d + 1), s > k || a) break;
           }
           t.delete(f);
         }
       }
     }
   };
-  a(e, "$", 0);
+  o(e, "$", 0);
 }
 function m(e, i, t, s, n = !1) {
-  const o = e[i];
-  o === void 0 && !n || (typeof o != "string" || n && !o.trim()) && s.push({ path: `${t}.${i}`, message: n ? "应为非空字符串" : "应为字符串" });
-}
-function c(e, i, t, s, n = 0, o = !1) {
   const a = e[i];
-  a === void 0 && !o || (typeof a != "number" || !Number.isFinite(a) || a < n) && s.push({ path: `${t}.${i}`, message: `应为大于等于 ${n} 的有限数字` });
+  a === void 0 && !n || (typeof a != "string" || n && !a.trim()) && s.push({ path: `${t}.${i}`, message: n ? "应为非空字符串" : "应为字符串" });
+}
+function c(e, i, t, s, n = 0, a = !1) {
+  const o = e[i];
+  o === void 0 && !a || (typeof o != "number" || !Number.isFinite(o) || o < n) && s.push({ path: `${t}.${i}`, message: `应为大于等于 ${n} 的有限数字` });
 }
 function b(e, i, t, s) {
   e[i] !== void 0 && typeof e[i] != "boolean" && s.push({ path: `${t}.${i}`, message: "应为布尔值" });
 }
 function M(e, i, t, s = !1) {
-  e !== void 0 && !Te.has(e) && !(s && e === "auto") && t.push({ path: i, message: `未知对齐方式${s ? "（支持 auto）" : ""}` });
+  e !== void 0 && !Le.has(e) && !(s && e === "auto") && t.push({ path: i, message: `未知对齐方式${s ? "（支持 auto）" : ""}` });
 }
 function $(e, i, t) {
   if (e !== void 0) {
-    if (!h(e)) {
+    if (!u(e)) {
       t.push({ path: i, message: "样式应为对象" });
       return;
     }
@@ -514,237 +519,237 @@ function $(e, i, t) {
     for (const s of ["fontFamily", "color", "backgroundColor", "lineColor", "borderColor"]) m(e, s, i, t);
   }
 }
-function _e(e, i, t) {
+function Ve(e, i, t) {
   if (e === void 0) return;
   if (!Array.isArray(e)) {
     t.push({ path: i, message: "参数定义应为数组" });
     return;
   }
   const s = /* @__PURE__ */ new Set(), n = t.length;
-  e.forEach((o, a) => {
-    const f = `${i}.${a}`;
-    if (!h(o)) {
+  e.forEach((a, o) => {
+    const f = `${i}.${o}`;
+    if (!u(a)) {
       t.push({ path: f, message: "参数定义应为对象" });
       return;
     }
-    m(o, "field", f, t, !0), typeof o.field == "string" && (s.has(o.field) && t.push({ path: `${f}.field`, message: "参数名重复" }), s.add(o.field)), o.type !== void 0 && !["text", "number", "date", "month", "year", "dateRange", "select"].includes(o.type) && t.push({ path: `${f}.type`, message: "未知参数类型" });
-    for (const r of ["label", "defaultValue", "placeholder"]) m(o, r, f, t);
-    b(o, "required", f, t);
+    m(a, "field", f, t, !0), typeof a.field == "string" && (s.has(a.field) && t.push({ path: `${f}.field`, message: "参数名重复" }), s.add(a.field)), a.type !== void 0 && !["text", "number", "date", "month", "year", "dateRange", "select", "multiSelect", "cascader", "numberRange"].includes(a.type) && t.push({ path: `${f}.type`, message: "未知参数类型" });
+    for (const r of ["label", "defaultValue", "placeholder"]) m(a, r, f, t);
+    b(a, "required", f, t);
     for (const r of ["minLength", "maxLength"]) {
-      const d = o[r];
+      const d = a[r];
       d !== void 0 && (typeof d != "number" || !Number.isSafeInteger(d) || d < 0) && t.push({ path: `${f}.${r}`, message: "长度边界应为非负整数" });
     }
-    Ce(o, f, t), o.options !== void 0 && (Array.isArray(o.options) ? o.options.forEach((r, d) => {
-      const u = `${f}.options.${d}`;
-      if (!h(r)) t.push({ path: u, message: "选项应为对象" });
+    Ke(a, f, t), a.options !== void 0 && (Array.isArray(a.options) ? a.options.forEach((r, d) => {
+      const h = `${f}.options.${d}`;
+      if (!u(r)) t.push({ path: h, message: "选项应为对象" });
       else
-        for (const p of ["label", "value"]) typeof r[p] != "string" && t.push({ path: `${u}.${p}`, message: "选项标签与值应为字符串（允许空白选项）" });
+        for (const p of ["label", "value"]) typeof r[p] != "string" && t.push({ path: `${h}.${p}`, message: "选项标签与值应为字符串（允许空白选项）" });
     }) : t.push({ path: `${f}.options`, message: "选项应为数组" }));
-  }), t.length === n && t.push(...ie(e).map((o) => ({ path: o.path.replace("$.paramDefs", i), message: o.message })));
+  }), t.length === n && t.push(...ne(e).map((a) => ({ path: a.path.replace("$.paramDefs", i), message: a.message })));
 }
-function Ce(e, i, t) {
-  for (const o of ["min", "max"]) {
-    const a = e[o];
-    if (a === void 0) continue;
-    se(e.type, a) || e.type === "number" && typeof a == "number" && Number.isFinite(a) || t.push({ path: `${i}.${o}`, message: "数字使用有限数字边界，日期/月/年使用对应规范字符串边界" });
+function Ke(e, i, t) {
+  for (const a of ["min", "max"]) {
+    const o = e[a];
+    if (o === void 0) continue;
+    ae(e.type, o) || ["number", "numberRange"].includes(e.type) && typeof o == "number" && Number.isFinite(o) || t.push({ path: `${i}.${a}`, message: "数字使用有限数字边界，日期/月/年使用对应规范字符串边界" });
   }
   const s = typeof e.min == "number" && typeof e.max == "number" && e.min > e.max, n = typeof e.min == "string" && typeof e.max == "string" && e.min > e.max;
   (s || n) && t.push({ path: i, message: "最小边界不能大于最大边界" }), typeof e.minLength == "number" && typeof e.maxLength == "number" && e.minLength > e.maxLength && t.push({ path: i, message: "最小长度不能大于最大长度" });
 }
-function z(e, i, t) {
+function U(e, i, t) {
   if (!Array.isArray(e) || e.length === 0) {
     t.push({ path: i, message: "列表至少需要一列" });
     return;
   }
-  e.every((s) => h(s) && s.hidden === !0) && t.push({ path: i, message: "列表至少需要一列可见列" }), e.forEach((s, n) => {
-    const o = `${i}.${n}`;
-    if (!h(s)) {
-      t.push({ path: o, message: "列应为对象" });
+  e.every((s) => u(s) && s.hidden === !0) && t.push({ path: i, message: "列表至少需要一列可见列" }), e.forEach((s, n) => {
+    const a = `${i}.${n}`;
+    if (!u(s)) {
+      t.push({ path: a, message: "列应为对象" });
       return;
     }
-    if (D(s, o, t), b(s, "hidden", o, t), T(s.visibleWhen, `${o}.visibleWhen`, t), typeof s.header != "string" && t.push({ path: `${o}.header`, message: "表头应为字符串（允许空白表头）" }), m(s, "field", o, t, !0), c(s, "widthMm", o, t, Number.MIN_VALUE, !0), $(s.style, `${o}.style`, t), $(s.headerStyle, `${o}.headerStyle`, t), M(s.align, `${o}.align`, t, !0), M(s.headerAlign, `${o}.headerAlign`, t), s.semanticRole !== void 0 && !["identifier", "dimension", "measure", "date", "text"].includes(s.semanticRole) && t.push({ path: `${o}.semanticRole`, message: "未知列语义" }), s.format !== void 0)
-      if (!h(s.format) || !["number", "percent", "date"].includes(s.format.kind))
-        t.push({ path: `${o}.format`, message: "未知列格式" });
+    if (j(s, a, t), s.visual !== void 0 && !re(s.visual) && t.push({ path: `${a}.visual`, message: "列可视化配置无效，请检查类型、数值范围和颜色" }), b(s, "hidden", a, t), F(s.visibleWhen, `${a}.visibleWhen`, t), typeof s.header != "string" && t.push({ path: `${a}.header`, message: "表头应为字符串（允许空白表头）" }), m(s, "field", a, t, !0), c(s, "widthMm", a, t, Number.MIN_VALUE, !0), $(s.style, `${a}.style`, t), $(s.headerStyle, `${a}.headerStyle`, t), M(s.align, `${a}.align`, t, !0), M(s.headerAlign, `${a}.headerAlign`, t), s.semanticRole !== void 0 && !["identifier", "dimension", "measure", "date", "text"].includes(s.semanticRole) && t.push({ path: `${a}.semanticRole`, message: "未知列语义" }), s.format !== void 0)
+      if (!u(s.format) || !["number", "percent", "date"].includes(s.format.kind))
+        t.push({ path: `${a}.format`, message: "未知列格式" });
       else {
-        const a = s.format.digits;
-        a !== void 0 && (typeof a != "number" || !Number.isInteger(a) || a < 0 || a > 100) && t.push({ path: `${o}.format.digits`, message: "小数位应为 0–100 的整数" }), b(s.format, "thousands", `${o}.format`, t), m(s.format, "pattern", `${o}.format`, t);
+        const o = s.format.digits;
+        o !== void 0 && (typeof o != "number" || !Number.isInteger(o) || o < 0 || o > 100) && t.push({ path: `${a}.format.digits`, message: "小数位应为 0–100 的整数" }), b(s.format, "thousands", `${a}.format`, t), m(s.format, "pattern", `${a}.format`, t);
       }
-    s.rules !== void 0 && (Array.isArray(s.rules) ? s.rules.forEach((a, f) => {
-      const r = `${o}.rules.${f}`;
-      if (!h(a) || !h(a.when)) {
+    s.rules !== void 0 && (Array.isArray(s.rules) ? s.rules.forEach((o, f) => {
+      const r = `${a}.rules.${f}`;
+      if (!u(o) || !u(o.when)) {
         t.push({ path: r, message: "条件格式缺少 when 对象" });
         return;
       }
-      T(a.when, `${r}.when`, t), m(a.when, "field", `${r}.when`, t, !0), [">", ">=", "<", "<=", "==", "!="].includes(a.when.op) || t.push({ path: `${r}.when.op`, message: "未知条件运算符" }), typeof a.when.value != "number" && typeof a.when.value != "string" && t.push({ path: `${r}.when.value`, message: "条件值应为数字或字符串" }), $(a.style, `${r}.style`, t);
-    }) : t.push({ path: `${o}.rules`, message: "条件格式应为数组" }));
+      F(o.when, `${r}.when`, t), $(o.style, `${r}.style`, t);
+    }) : t.push({ path: `${a}.rules`, message: "条件格式应为数组" }));
   });
 }
-function q(e, i, t) {
+function z(e, i, t) {
   if (e !== void 0) {
-    if (!h(e)) {
+    if (!u(e)) {
       t.push({ path: i, message: "分组应为对象" });
       return;
     }
     m(e, "field", i, t, !0);
     for (const s of ["headerTemplate", "subtotalLabel"]) m(e, s, i, t);
     for (const s of ["headerStyle", "subtotalStyle"]) $(e[s], `${i}.${s}`, t);
-    b(e, "keepWithNext", i, t), b(e, "repeatHeader", i, t), U(e.aggregates, `${i}.aggregates`, t), e.subtotal !== void 0 && (!Array.isArray(e.subtotal) || e.subtotal.some((s) => typeof s != "string")) && t.push({ path: `${i}.subtotal`, message: "小计字段应为字符串数组" });
+    b(e, "keepWithNext", i, t), b(e, "repeatHeader", i, t), W(e.aggregates, `${i}.aggregates`, t), e.subtotal !== void 0 && (!Array.isArray(e.subtotal) || e.subtotal.some((s) => typeof s != "string")) && t.push({ path: `${i}.subtotal`, message: "小计字段应为字符串数组" });
   }
 }
-function je(e, i, t) {
+function He(e, i, t) {
   if (!(e === void 0 || typeof e == "boolean")) {
-    if (!h(e)) {
+    if (!u(e)) {
       t.push({ path: i, message: "合计应为布尔值或对象" });
       return;
     }
-    m(e, "label", i, t), U(e.aggregates, `${i}.aggregates`, t), $(e.style, `${i}.style`, t), e.fields !== void 0 && (!Array.isArray(e.fields) || e.fields.some((s) => typeof s != "string")) && t.push({ path: `${i}.fields`, message: "合计字段应为字符串数组" });
+    m(e, "label", i, t), W(e.aggregates, `${i}.aggregates`, t), $(e.style, `${i}.style`, t), e.fields !== void 0 && (!Array.isArray(e.fields) || e.fields.some((s) => typeof s != "string")) && t.push({ path: `${i}.fields`, message: "合计字段应为字符串数组" });
   }
 }
-function De(e, i, t, s) {
+function Je(e, i, t, s) {
   const n = { kind: "rect", leftMm: 0, topMm: 0, widthMm: 1, heightMm: 1, grid: e };
-  if (H(n, t, s, []), _(n, t, s), !h(e) || !Array.isArray(e.cells)) return;
-  const o = e.cells, a = Array.isArray(i) ? i.length : 0;
-  if (o.length * a > k) {
+  if (K(n, t, s, []), L(n, t, s), !u(e) || !Array.isArray(e.cells)) return;
+  const a = e.cells, o = Array.isArray(i) ? i.length : 0;
+  if (a.length * o > k) {
     s.push({ path: t, message: "表头逻辑网格超过 20 万格安全上限" });
     return;
   }
-  e.cells.length || s.push({ path: `${t}.cells`, message: "表头至少需要一行" }), Array.isArray(e.colWidthsMm) && e.colWidthsMm.length !== a && s.push({ path: `${t}.colWidthsMm`, message: "表头列宽数量应与列表列数一致" }), Array.isArray(e.rowHeightsMm) && e.rowHeightsMm.length !== e.cells.length && s.push({ path: `${t}.rowHeightsMm`, message: "表头行高数量应与行数一致" }), Ve(o, a, t, s);
+  e.cells.length || s.push({ path: `${t}.cells`, message: "表头至少需要一行" }), Array.isArray(e.colWidthsMm) && e.colWidthsMm.length !== o && s.push({ path: `${t}.colWidthsMm`, message: "表头列宽数量应与列表列数一致" }), Array.isArray(e.rowHeightsMm) && e.rowHeightsMm.length !== e.cells.length && s.push({ path: `${t}.rowHeightsMm`, message: "表头行高数量应与行数一致" }), We(a, o, t, s);
 }
-function Ve(e, i, t, s) {
+function We(e, i, t, s) {
   const n = /* @__PURE__ */ new Set();
-  e.forEach((o, a) => {
-    if (!Array.isArray(o)) return;
+  e.forEach((a, o) => {
+    if (!Array.isArray(a)) return;
     let f = 0;
-    o.forEach((r, d) => {
-      for (; n.has(`${a}:${f}`); ) f++;
-      const u = h(r) && typeof r.colSpan == "number" ? r.colSpan : 1, p = h(r) && typeof r.rowSpan == "number" ? r.rowSpan : 1;
-      (f + u > i || a + p > e.length) && s.push({ path: `${t}.cells.${a}.${d}`, message: "表头合并区域超出表头边界" });
-      for (let y = a; y < Math.min(e.length, a + p); y++)
-        for (let A = f; A < Math.min(i, f + u); A++)
-          n.has(`${y}:${A}`) && s.push({ path: `${t}.cells.${a}.${d}`, message: "表头合并区域重叠" }), n.add(`${y}:${A}`);
-      f += u;
+    a.forEach((r, d) => {
+      for (; n.has(`${o}:${f}`); ) f++;
+      const h = u(r) && typeof r.colSpan == "number" ? r.colSpan : 1, p = u(r) && typeof r.rowSpan == "number" ? r.rowSpan : 1;
+      (f + h > i || o + p > e.length) && s.push({ path: `${t}.cells.${o}.${d}`, message: "表头合并区域超出表头边界" });
+      for (let y = o; y < Math.min(e.length, o + p); y++)
+        for (let A = f; A < Math.min(i, f + h); A++)
+          n.has(`${y}:${A}`) && s.push({ path: `${t}.cells.${o}.${d}`, message: "表头合并区域重叠" }), n.add(`${y}:${A}`);
+      f += h;
     });
   });
 }
-function Ke(e, i, t) {
-  if (xe(e, i, t), Se(e.computed, `${i}.computed`, t), ve(e.matrix, `${i}.matrix`, t), e.matrix && (e.detail || e.groupBy || Array.isArray(e.groups) && e.groups.length || e.grandTotal) && t.push({ path: `${i}.matrix`, message: "矩阵请使用自身 totals 汇总，不能同时配置普通分组、总计或主从明细" }), T(e.rowVisibleWhen, `${i}.rowVisibleWhen`, t), e.groups !== void 0 && (!Array.isArray(e.groups) || e.groups.length > 16 ? t.push({ path: `${i}.groups`, message: "分组应为数组，最多 16 级" }) : e.groups.forEach((o, a) => q(o, `${i}.groups.${a}`, t))), e.detail === void 0) return;
+function Ge(e, i, t) {
+  if (Oe(e, i, t), Fe(e.computed, `${i}.computed`, t), Ie(e.matrix, `${i}.matrix`, t), e.matrix && (e.detail || e.groupBy || Array.isArray(e.groups) && e.groups.length || e.grandTotal) && t.push({ path: `${i}.matrix`, message: "矩阵请使用自身 totals 汇总，不能同时配置普通分组、总计或主从明细" }), F(e.rowVisibleWhen, `${i}.rowVisibleWhen`, t), e.groups !== void 0 && (!Array.isArray(e.groups) || e.groups.length > 16 ? t.push({ path: `${i}.groups`, message: "分组应为数组，最多 16 级" }) : e.groups.forEach((a, o) => z(a, `${i}.groups.${o}`, t))), e.detail === void 0) return;
   const s = e.detail, n = `${i}.detail`;
-  if (!h(s)) {
+  if (!u(s)) {
     t.push({ path: n, message: "主从关联应为对象" });
     return;
   }
-  for (const o of ["dataset", "parentKey", "foreignKey"]) m(s, o, n, t, !0);
-  for (const o of ["rowKey", "revisionField", "sourceTokenField"]) m(s, o, n, t, s[o] !== void 0);
-  m(s, "label", n, t), b(s, "header", n, t), c(s, "rowHeightMm", n, t, Number.MIN_VALUE), z(s.columns, `${n}.columns`, t), s.unmatched !== void 0 && s.unmatched !== "error" && s.unmatched !== "ignore" && t.push({ path: `${n}.unmatched`, message: "未关联明细策略应为 error 或 ignore" });
+  for (const a of ["dataset", "parentKey", "foreignKey"]) m(s, a, n, t, !0);
+  for (const a of ["rowKey", "revisionField", "sourceTokenField"]) m(s, a, n, t, s[a] !== void 0);
+  m(s, "label", n, t), b(s, "header", n, t), c(s, "rowHeightMm", n, t, Number.MIN_VALUE), U(s.columns, `${n}.columns`, t), s.unmatched !== void 0 && s.unmatched !== "error" && s.unmatched !== "ignore" && t.push({ path: `${n}.unmatched`, message: "未关联明细策略应为 error 或 ignore" });
 }
-function He(e, i, t) {
+function Ue(e, i, t) {
   for (const s of ["leftMm", "topMm"]) c(e, s, i, t, -1 / 0, !0);
   c(e, "widthMm", i, t, Number.MIN_VALUE, !0), m(e, "dataset", i, t, !0), m(e, "title", i, t);
   for (const s of ["rowKey", "revisionField", "sourceTokenField"]) m(e, s, i, t, e[s] !== void 0);
-  e.headerGrid !== void 0 && De(e.headerGrid, e.columns, `${i}.headerGrid`, t), e.layout !== void 0 && e.layout !== "page" && e.layout !== "wide" && t.push({ path: `${i}.layout`, message: "布局应为 page 或 wide" }), z(e.columns, `${i}.columns`, t);
+  e.headerGrid !== void 0 && Je(e.headerGrid, e.columns, `${i}.headerGrid`, t), e.layout !== void 0 && e.layout !== "page" && e.layout !== "wide" && t.push({ path: `${i}.layout`, message: "布局应为 page 或 wide" }), U(e.columns, `${i}.columns`, t);
   for (const s of ["fontSizePt", "rowHeightMm"]) c(e, s, i, t, Number.MIN_VALUE);
   c(e, "paddingMm", i, t);
   for (const s of ["header", "headerBold", "headerEveryPage", "border"]) b(e, s, i, t);
-  e.cardinality !== void 0 && e.cardinality !== "record" && t.push({ path: `${i}.cardinality`, message: "单记录区域类型应为 record" }), m(e, "headerBackgroundColor", i, t), M(e.align, `${i}.align`, t, !0), M(e.headerAlign, `${i}.headerAlign`, t), $(e.headerStyle, `${i}.headerStyle`, t), Ke(e, i, t), q(e.groupBy, `${i}.groupBy`, t), je(e.grandTotal, `${i}.grandTotal`, t);
+  e.cardinality !== void 0 && e.cardinality !== "record" && t.push({ path: `${i}.cardinality`, message: "单记录区域类型应为 record" }), m(e, "headerBackgroundColor", i, t), M(e.align, `${i}.align`, t, !0), M(e.headerAlign, `${i}.headerAlign`, t), $(e.headerStyle, `${i}.headerStyle`, t), Ge(e, i, t), z(e.groupBy, `${i}.groupBy`, t), He(e.grandTotal, `${i}.grandTotal`, t);
 }
-function C(e, i, t) {
+function _(e, i, t) {
   Array.isArray(e.richParagraphs) && e.richParagraphs.forEach((s, n) => {
-    if (!h(s)) return;
-    const o = `${i}.richParagraphs.${n}`;
-    M(s.align, `${o}.align`, t);
-    for (const a of ["lineHeight", "spaceBeforeMm", "spaceAfterMm", "indentMm"]) c(s, a, o, t);
-    Array.isArray(s.segments) && s.segments.forEach((a, f) => {
-      const r = `${o}.segments.${f}`;
-      if (!h(a)) {
+    if (!u(s)) return;
+    const a = `${i}.richParagraphs.${n}`;
+    M(s.align, `${a}.align`, t);
+    for (const o of ["lineHeight", "spaceBeforeMm", "spaceAfterMm", "indentMm"]) c(s, o, a, t);
+    Array.isArray(s.segments) && s.segments.forEach((o, f) => {
+      const r = `${a}.segments.${f}`;
+      if (!u(o)) {
         t.push({ path: r, message: "富文本片段应为对象" });
         return;
       }
-      a.kind !== void 0 && a.kind !== "text" && a.kind !== "field" && t.push({ path: `${r}.kind`, message: "未知富文本片段类型" });
-      for (const d of ["text", "field"]) m(a, d, r, t);
-      $(a.style, `${r}.style`, t);
+      o.kind !== void 0 && o.kind !== "text" && o.kind !== "field" && t.push({ path: `${r}.kind`, message: "未知富文本片段类型" });
+      for (const d of ["text", "field"]) m(o, d, r, t);
+      $(o.style, `${r}.style`, t);
     });
   });
 }
-function _(e, i, t) {
+function L(e, i, t) {
   $(e.style, `${i}.style`, t);
   for (const n of ["text", "rawText", "imageData", "fallbackText", "nid", "rkey"]) m(e, n, i, t);
-  if (e.lines !== void 0 && (!Array.isArray(e.lines) || e.lines.some((n) => typeof n != "string")) && t.push({ path: `${i}.lines`, message: "文本行应为字符串数组" }), C(e, i, t), !h(e.grid)) return;
+  if (e.lines !== void 0 && (!Array.isArray(e.lines) || e.lines.some((n) => typeof n != "string")) && t.push({ path: `${i}.lines`, message: "文本行应为字符串数组" }), _(e, i, t), !u(e.grid)) return;
   const s = e.grid;
   c(s, "gapMm", `${i}.grid`, t), c(s, "paddingMm", `${i}.grid`, t);
   for (const n of ["colWidthsMm", "rowHeightsMm"]) {
-    const o = s[n];
-    o !== void 0 && (!Array.isArray(o) || o.some((a) => typeof a != "number" || !Number.isFinite(a) || a < 0)) && t.push({ path: `${i}.grid.${n}`, message: "网格尺寸应为有限非负数字数组" });
-  }
-  Array.isArray(s.cells) && s.cells.forEach((n, o) => {
-    Array.isArray(n) && n.forEach((a, f) => {
-      const r = `${i}.grid.cells.${o}.${f}`;
-      if (a !== null) {
-        if (!h(a)) {
+    const a = s[n];
+    a !== void 0 && (!Array.isArray(a) || a.some((o) => typeof o != "number" || !Number.isFinite(o) || o < 0)) && t.push({ path: `${i}.grid.${n}`, message: "网格尺寸应为有限非负数字数组" });
+  }
+  Array.isArray(s.cells) && s.cells.forEach((n, a) => {
+    Array.isArray(n) && n.forEach((o, f) => {
+      const r = `${i}.grid.cells.${a}.${f}`;
+      if (o !== null) {
+        if (!u(o)) {
           t.push({ path: r, message: "网格单元格应为对象或 null" });
           return;
         }
-        for (const d of ["text", "rawText", "numberFormat"]) m(a, d, r, t);
+        for (const d of ["text", "rawText", "numberFormat"]) m(o, d, r, t);
         for (const d of ["colSpan", "rowSpan"]) {
-          const u = a[d];
-          u !== void 0 && (typeof u != "number" || !Number.isInteger(u) || u <= 0) && t.push({ path: `${r}.${d}`, message: "跨度应为正整数" });
+          const h = o[d];
+          h !== void 0 && (typeof h != "number" || !Number.isInteger(h) || h <= 0) && t.push({ path: `${r}.${d}`, message: "跨度应为正整数" });
         }
-        a.value !== void 0 && a.value !== null && !["string", "number", "boolean"].includes(typeof a.value) && t.push({ path: `${r}.value`, message: "Excel 原始值应为字符串、数字、布尔值或 null" }), $(a.style, `${r}.style`, t), C(a, r, t), a.children !== void 0 && (Array.isArray(a.children) ? a.children.forEach((d, u) => {
-          h(d) && _(d, `${r}.children.${u}`, t);
+        o.value !== void 0 && o.value !== null && !["string", "number", "boolean"].includes(typeof o.value) && t.push({ path: `${r}.value`, message: "Excel 原始值应为字符串、数字、布尔值或 null" }), $(o.style, `${r}.style`, t), _(o, r, t), o.children !== void 0 && (Array.isArray(o.children) ? o.children.forEach((d, h) => {
+          u(d) && L(d, `${r}.children.${h}`, t);
         }) : t.push({ path: `${r}.children`, message: "嵌套组件应为数组" }));
       }
     });
   });
 }
-function Je(e, i, t) {
+function ze(e, i, t) {
   if (!(e.flow === void 0 || !Array.isArray(e.components)))
     try {
-      be(e.components, e.flow);
+      ve(e.components, e.flow);
     } catch (s) {
       t.push({ path: `${i}.flow`, message: s instanceof Error ? s.message : String(s) });
     }
 }
-function We(e) {
+function qe(e) {
   const i = [], t = [];
-  return L(e, i), i.length ? { ok: !1, errors: i, warnings: t } : (h(e) ? (e.schemaVersion !== void 0 && e.schemaVersion !== ee && i.push({ path: "$.schemaVersion", message: "不支持的模板 schemaVersion" }), _e(e.params, "$.params", i), Ee(e, i), !Array.isArray(e.pages) || e.pages.length === 0 ? i.push({ path: "$.pages", message: "模板至少需要一页" }) : e.pages.forEach((s, n) => {
-    const o = `$.pages.${n}`;
-    if (!h(s)) {
-      i.push({ path: o, message: "页应为对象" });
+  return C(e, i), i.length ? { ok: !1, errors: i, warnings: t } : (u(e) ? (e.schemaVersion !== void 0 && e.schemaVersion !== ie && i.push({ path: "$.schemaVersion", message: "不支持的模板 schemaVersion" }), Ve(e.params, "$.params", i), Re(e, i), !Array.isArray(e.pages) || e.pages.length === 0 ? i.push({ path: "$.pages", message: "模板至少需要一页" }) : e.pages.forEach((s, n) => {
+    const a = `$.pages.${n}`;
+    if (!u(s)) {
+      i.push({ path: a, message: "页应为对象" });
       return;
     }
-    c(s, "widthMm", o, i, Number.MIN_VALUE, !0), c(s, "heightMm", o, i, Number.MIN_VALUE, !0), s.layout !== void 0 && s.layout !== "page" && s.layout !== "wide" && i.push({ path: `${o}.layout`, message: "布局应为 page 或 wide" }), typeof s.heightMm == "number" && s.heightMm >= 5e3 && i.push({ path: `${o}.heightMm`, message: "页高应小于 5000mm" });
-    for (const a of ["marginTopMm", "marginBottomMm", "marginLeftMm", "marginRightMm"]) c(s, a, o, i);
-    typeof s.widthMm == "number" && Number(s.marginLeftMm ?? 0) + Number(s.marginRightMm ?? 0) >= s.widthMm && i.push({ path: o, message: "横向页边距占满页面" }), typeof s.heightMm == "number" && Number(s.marginTopMm ?? 0) + Number(s.marginBottomMm ?? 0) >= s.heightMm && i.push({ path: o, message: "纵向页边距占满页面" }), Array.isArray(s.components) ? s.components.forEach((a, f) => {
-      const r = `${o}.components.${f}`;
-      h(a) && a.kind === "list" ? He(a, r, i) : (H(a, r, i, t), h(a) && _(a, r, i));
-    }) : i.push({ path: `${o}.components`, message: "组件应为数组" }), Je(s, o, i);
+    c(s, "widthMm", a, i, Number.MIN_VALUE, !0), c(s, "heightMm", a, i, Number.MIN_VALUE, !0), s.layout !== void 0 && s.layout !== "page" && s.layout !== "wide" && i.push({ path: `${a}.layout`, message: "布局应为 page 或 wide" }), typeof s.heightMm == "number" && s.heightMm >= 5e3 && i.push({ path: `${a}.heightMm`, message: "页高应小于 5000mm" });
+    for (const o of ["marginTopMm", "marginBottomMm", "marginLeftMm", "marginRightMm"]) c(s, o, a, i);
+    typeof s.widthMm == "number" && Number(s.marginLeftMm ?? 0) + Number(s.marginRightMm ?? 0) >= s.widthMm && i.push({ path: a, message: "横向页边距占满页面" }), typeof s.heightMm == "number" && Number(s.marginTopMm ?? 0) + Number(s.marginBottomMm ?? 0) >= s.heightMm && i.push({ path: a, message: "纵向页边距占满页面" }), Array.isArray(s.components) ? s.components.forEach((o, f) => {
+      const r = `${a}.components.${f}`;
+      u(o) && o.kind === "list" ? Ue(o, r, i) : (K(o, r, i, t), u(o) && L(o, r, i));
+    }) : i.push({ path: `${a}.components`, message: "组件应为数组" }), ze(s, a, i);
   })) : i.push({ path: "$", message: "模板应为对象" }), { ok: i.length === 0, errors: i, warnings: t });
 }
-function Ge(e) {
+function Xe(e) {
   const i = [], t = [];
-  if (L(e, i), i.length) return { ok: !1, errors: i, warnings: t };
-  if (!h(e)) i.push({ path: "$", message: "模板文档应为对象" });
+  if (C(e, i), i.length) return { ok: !1, errors: i, warnings: t };
+  if (!u(e)) i.push({ path: "$", message: "模板文档应为对象" });
   else {
     for (const n of Object.keys(e))
-      Fe.has(n) || i.push({ path: `$.${n}`, message: "模板文档存在未知字段；只保存模板与描述，不保存取数或业务数据" });
-    e.schemaVersion !== B && i.push({ path: "$.schemaVersion", message: "不支持的模板文档版本" });
+      Ce.has(n) || i.push({ path: `$.${n}`, message: "模板文档存在未知字段；只保存模板与描述，不保存取数或业务数据" });
+    e.schemaVersion !== G && i.push({ path: "$.schemaVersion", message: "不支持的模板文档版本" });
     for (const n of ["id", "name"]) m(e, n, "$", i, !0);
     for (const n of ["revision", "description"]) m(e, n, "$", i);
-    const s = We(e.template);
+    const s = qe(e.template);
     i.push(...s.errors.map((n) => ({ ...n, path: `$.template${n.path.slice(1)}` }))), t.push(...s.warnings.map((n) => ({ ...n, path: `$.template${n.path.slice(1)}` })));
   }
   return { ok: i.length === 0, errors: i, warnings: t };
 }
 function R(e) {
-  const i = Ge(e);
+  const i = Xe(e);
   if (!i.ok) throw new w(i.errors);
 }
-function et(e) {
+function at(e) {
   const i = [];
-  if (L(e, i), i.length) throw new w(i);
-  const t = { ...e, schemaVersion: e.schemaVersion ?? B };
+  if (C(e, i), i.length) throw new w(i);
+  const t = { ...e, schemaVersion: e.schemaVersion ?? G };
   return R(t), x(t);
 }
-function tt(e) {
+function ot(e) {
   let i = e;
   if (typeof e == "string") {
     if (e.length > P)
@@ -757,7 +762,7 @@ function tt(e) {
   }
   return R(i), x(i);
 }
-function it(e) {
+function ft(e) {
   R(e);
   const i = JSON.stringify(e, null, 2);
   if (i.length > P) throw new w([{ path: "$", message: "模板 JSON 超过 1000 万字符的导出/导入上限" }]);
@@ -766,7 +771,7 @@ function it(e) {
 function x(e) {
   return JSON.parse(JSON.stringify(e));
 }
-function st(e = []) {
+function rt(e = []) {
   const i = /* @__PURE__ */ new Map(), t = {
     get: (s) => {
       const n = i.get(s);
@@ -784,18 +789,18 @@ function st(e = []) {
 }
 export {
   w as R,
-  ye as a,
-  B as b,
-  Qe as c,
-  st as d,
-  et as e,
-  H as f,
-  pe as g,
-  Ge as h,
-  be as i,
-  Ee as j,
-  tt as p,
-  Ze as r,
-  it as s,
-  We as v
+  G as a,
+  Ae as b,
+  st as c,
+  rt as d,
+  at as e,
+  K as f,
+  be as g,
+  Xe as h,
+  ve as i,
+  Re as j,
+  ot as p,
+  nt as r,
+  ft as s,
+  qe as v
 };