@worm-vue3-print/core 1.2.1 → 1.2.2

package/dist/designer/index.cjs

@@ -0,0 +1,2419 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/designer/index.ts
+var designer_exports = {};
+__export(designer_exports, {
+  DEFAULT_DEMO_DATA: () => DEFAULT_DEMO_DATA,
+  ELEMENT_BINDING_REGISTRY: () => ELEMENT_BINDING_REGISTRY,
+  EXTENDED_FUNCTIONS: () => EXTENDED_FUNCTIONS,
+  FIT_SCALE_MIN_PERCENT: () => FIT_SCALE_MIN_PERCENT,
+  GHOST_BORDER_CSS: () => GHOST_BORDER_CSS,
+  MIN_COL_WIDTH_MM: () => MIN_COL_WIDTH_MM,
+  MIN_SCALE_PERCENT: () => MIN_SCALE_PERCENT,
+  PAPER_PRESETS: () => PAPER_PRESETS,
+  PRESET_COLORS: () => PRESET_COLORS,
+  PROPERTY_REGISTRY: () => PROPERTY_REGISTRY,
+  RESIZE_POINTS: () => RESIZE_POINTS,
+  RULER_THICKNESS: () => RULER_THICKNESS,
+  ZONE_ALLOWED_TYPES: () => ZONE_ALLOWED_TYPES,
+  applyBorderPreset: () => applyBorderPreset,
+  buildRulerTicks: () => buildRulerTicks,
+  calcResizeRect: () => calcResizeRect,
+  canMergeReason: () => canMergeReason,
+  chooseMajorStepMM: () => chooseMajorStepMM,
+  clampResizedColumnWidth: () => clampResizedColumnWidth,
+  clampScalePercent: () => clampScalePercent,
+  clampToZone: () => clampToZone,
+  computeAdsorb: () => computeAdsorb,
+  computeFitScale: () => computeFitScale,
+  createCell: () => createCell,
+  createDefaultOptions: () => createDefaultOptions,
+  createDefaultTable: () => createDefaultTable,
+  createFieldElement: () => createFieldElement,
+  createRuntimeElement: () => createRuntimeElement,
+  deleteCol: () => deleteCol,
+  deleteRow: () => deleteRow,
+  engine: () => engine2,
+  evaluateTemplate: () => evaluateTemplate2,
+  filterGroups: () => filterGroups,
+  finalizeElementZone: () => finalizeElementZone,
+  findMainCell: () => findMainCell,
+  generateGroupId: () => generateGroupId,
+  generateId: () => generateId,
+  getDemoData: () => getDemoData,
+  getElementBindings: () => getElementBindings,
+  getPaperDimensions: () => getPaperDimensions,
+  getPaperSizeMM: () => getPaperSizeMM,
+  getSpanRect: () => getSpanRect,
+  getTableCellBindings: () => getTableCellBindings,
+  getZoneRects: () => getZoneRects,
+  groupFields: () => groupFields,
+  insertCol: () => insertCol,
+  insertRow: () => insertRow,
+  matchKeywords: () => matchKeywords,
+  mergeCells: () => mergeCells,
+  minorStepMM: () => minorStepMM,
+  mmToPx: () => mmToPx,
+  nextWheelScale: () => nextWheelScale,
+  normalizeSelection: () => normalizeSelection,
+  normalizeTemplateUnits: () => normalizeTemplateUnits,
+  ptToMm: () => ptToMm,
+  pxToMm: () => pxToMm,
+  resolveBarcodeDesignValue: () => resolveBarcodeDesignValue,
+  resolveCellBorderCss: () => resolveCellBorderCss,
+  resolveTextBinding: () => resolveTextBinding,
+  safeEval: () => safeEval2,
+  searchProperties: () => searchProperties,
+  setRowType: () => setRowType,
+  splitCells: () => splitCells,
+  syncTableElementSize: () => syncTableElementSize,
+  useAlign: () => useAlign,
+  useBindingDisplay: () => useBindingDisplay,
+  useGroup: () => useGroup,
+  useKeyboard: () => useKeyboard,
+  useResize: () => useResize,
+  zoneFromPaperPoint: () => zoneFromPaperPoint
+});
+module.exports = __toCommonJS(designer_exports);
+
+// 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/designer/utils/scale.ts
+var MIN_SCALE_PERCENT = 25;
+var FIT_SCALE_MIN_PERCENT = 5;
+function clampScalePercent(percent) {
+  return Math.max(MIN_SCALE_PERCENT, percent);
+}
+function nextWheelScale(percent, direction, factor = 1.1) {
+  const next = direction > 0 ? percent * factor : percent / factor;
+  return clampScalePercent(Math.round(next));
+}
+function computeFitScale(containerW, containerH, paperW, paperH, ratio = 0.9) {
+  if (paperW <= 0 || paperH <= 0) return 100;
+  const fit = Math.min(containerW / paperW, containerH / paperH) * ratio;
+  const pct = Math.round(fit * 100);
+  return Math.max(FIT_SCALE_MIN_PERCENT, pct);
+}
+
+// src/designer/utils/migrate.ts
+var PT_KEYS = ["left", "top", "width", "height"];
+function convertElement(el) {
+  const options = { ...el.options };
+  for (const key of PT_KEYS) {
+    const v = options[key];
+    if (typeof v === "number" && Number.isFinite(v)) {
+      ;
+      options[key] = round2(ptToMm(v));
+    }
+  }
+  return { ...el, options };
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+function normalizeTemplateUnits(data) {
+  if (data.unit === "mm") return data;
+  const convert = (els) => els?.map(convertElement) ?? [];
+  return {
+    ...data,
+    unit: "mm",
+    elements: convert(data.elements),
+    header: data.header ? { ...data.header, elements: convert(data.header.elements) } : data.header,
+    footer: data.footer ? { ...data.footer, elements: convert(data.footer.elements) } : data.footer,
+    firstPageOverlay: data.firstPageOverlay ? { ...data.firstPageOverlay, elements: convert(data.firstPageOverlay.elements) } : data.firstPageOverlay
+  };
+}
+
+// src/designer/utils/default-config.ts
+var PAPER_PRESETS = {
+  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 }
+};
+function getPaperDimensions(t) {
+  let base;
+  if (t.paperSize === "CUSTOM") {
+    base = {
+      width: t.customWidth ?? 210,
+      height: t.customHeight ?? 297
+    };
+  } else {
+    base = PAPER_PRESETS[t.paperSize] || PAPER_PRESETS["A4"];
+  }
+  return t.orientation === "landscape" ? { width: base.height, height: base.width } : base;
+}
+
+// src/designer/utils/table-matrix.ts
+function createCellIdGenerator() {
+  let seq = 0;
+  return function genCellId2() {
+    seq += 1;
+    return `cell-${Date.now().toString(36)}-${seq}`;
+  };
+}
+function createRowIdGenerator() {
+  let seq = 0;
+  return function genRowId2() {
+    seq += 1;
+    return `row-${Date.now().toString(36)}-${seq}`;
+  };
+}
+var genCellId = createCellIdGenerator();
+var genRowId = createRowIdGenerator();
+var DEFAULT_BORDER = { width: 0.75, style: "solid", color: "#333333" };
+function deepClone(v) {
+  return JSON.parse(JSON.stringify(v));
+}
+function createCell(partial) {
+  return {
+    id: genCellId(),
+    borders: {
+      top: { ...DEFAULT_BORDER },
+      right: { ...DEFAULT_BORDER },
+      bottom: { ...DEFAULT_BORDER },
+      left: { ...DEFAULT_BORDER }
+    },
+    ...partial
+  };
+}
+function createDefaultTable() {
+  const colWidths = [50, 50, 50];
+  const mk = (type, repeat) => ({
+    id: genRowId(),
+    type,
+    height: 8,
+    ...repeat !== void 0 ? { repeatOnPage: repeat } : {},
+    cells: colWidths.map(() => createCell())
+  });
+  const header = mk("header", true);
+  header.cells.forEach((c, i) => {
+    c.formatter = `\u5217${i + 1}`;
+    c.align = "center";
+    c.fontWeight = "bold";
+  });
+  return { rows: [header, mk("data"), mk("subtotal"), mk("summary")], colWidths };
+}
+function findMainCell(rows, r, c) {
+  if (!rows[r].cells[c].merged) {
+    return { r, c };
+  }
+  for (let ri = r; ri >= 0; ri--) {
+    for (let ci = c; ci >= 0; ci--) {
+      const cell = rows[ri].cells[ci];
+      if (cell.merged) {
+        continue;
+      }
+      const rs = cell.rowspan ?? 1;
+      const cs = cell.colspan ?? 1;
+      if (ri + rs - 1 >= r && ci + cs - 1 >= c) {
+        return { r: ri, c: ci };
+      }
+    }
+  }
+  return { r, c };
+}
+function getSpanRect(rows, r, c) {
+  const main = findMainCell(rows, r, c);
+  const cell = rows[main.r].cells[main.c];
+  return {
+    r1: main.r,
+    c1: main.c,
+    r2: main.r + (cell.rowspan ?? 1) - 1,
+    c2: main.c + (cell.colspan ?? 1) - 1
+  };
+}
+function normalizeSelection(rows, a, b) {
+  let rect = {
+    r1: Math.min(a.r, b.r),
+    c1: Math.min(a.c, b.c),
+    r2: Math.max(a.r, b.r),
+    c2: Math.max(a.c, b.c)
+  };
+  for (; ; ) {
+    let changed = false;
+    for (let r = rect.r1; r <= rect.r2; r++) {
+      for (let c = rect.c1; c <= rect.c2; c++) {
+        const span = getSpanRect(rows, r, c);
+        const merged = {
+          r1: Math.min(rect.r1, span.r1),
+          c1: Math.min(rect.c1, span.c1),
+          r2: Math.max(rect.r2, span.r2),
+          c2: Math.max(rect.c2, span.c2)
+        };
+        if (merged.r1 !== rect.r1 || merged.c1 !== rect.c1 || merged.r2 !== rect.r2 || merged.c2 !== rect.c2) {
+          rect = merged;
+          changed = true;
+        }
+      }
+    }
+    if (!changed) {
+      return rect;
+    }
+  }
+}
+function canMergeReason(rows, rect) {
+  const cellCount = (rect.r2 - rect.r1 + 1) * (rect.c2 - rect.c1 + 1);
+  if (cellCount < 2) {
+    return "\u81F3\u5C11\u9009\u62E9 2 \u4E2A\u5355\u5143\u683C";
+  }
+  const types = /* @__PURE__ */ new Set();
+  for (let r = rect.r1; r <= rect.r2; r++) {
+    types.add(rows[r].type);
+  }
+  if (types.size > 1) {
+    return "\u5408\u5E76\u533A\u57DF\u4E0D\u80FD\u8DE8\u8D8A\u4E0D\u540C\u7C7B\u578B\u7684\u884C";
+  }
+  const norm = normalizeSelection(rows, { r: rect.r1, c: rect.c1 }, { r: rect.r2, c: rect.c2 });
+  if (norm.r1 !== rect.r1 || norm.c1 !== rect.c1 || norm.r2 !== rect.r2 || norm.c2 !== rect.c2) {
+    return "\u9009\u533A\u4E0E\u5DF2\u6709\u5408\u5E76\u533A\u57DF\u90E8\u5206\u91CD\u53E0";
+  }
+  return null;
+}
+function mergeCells(rows, rect) {
+  const main = rows[rect.r1].cells[rect.c1];
+  const contents = [];
+  for (let r = rect.r1; r <= rect.r2; r++) {
+    for (let c = rect.c1; c <= rect.c2; c++) {
+      const cell = rows[r].cells[c];
+      if (cell.formatter) {
+        contents.push(cell.formatter);
+      }
+      if (r === rect.r1 && c === rect.c1) {
+        continue;
+      }
+      cell.merged = true;
+      cell.rowspan = 1;
+      cell.colspan = 1;
+      cell.formatter = "";
+    }
+  }
+  main.rowspan = rect.r2 - rect.r1 + 1;
+  main.colspan = rect.c2 - rect.c1 + 1;
+  main.formatter = contents.join(" ");
+}
+function splitCells(rows, rect) {
+  for (let r = rect.r1; r <= rect.r2; r++) {
+    for (let c = rect.c1; c <= rect.c2; c++) {
+      const cell = rows[r].cells[c];
+      if (!cell.merged && ((cell.rowspan ?? 1) > 1 || (cell.colspan ?? 1) > 1)) {
+        const span = getSpanRect(rows, r, c);
+        const styleSrc = cell;
+        for (let sr = span.r1; sr <= span.r2; sr++) {
+          for (let sc = span.c1; sc <= span.c2; sc++) {
+            const t = rows[sr].cells[sc];
+            t.merged = false;
+            t.rowspan = 1;
+            t.colspan = 1;
+            copyCellStyle(styleSrc, t);
+          }
+        }
+        cell.rowspan = 1;
+        cell.colspan = 1;
+      }
+    }
+  }
+}
+function copyCellStyle(src, dst) {
+  if (src === dst) {
+    return;
+  }
+  dst.align = src.align;
+  dst.valign = src.valign;
+  dst.fontSize = src.fontSize;
+  dst.fontWeight = src.fontWeight;
+  dst.color = src.color;
+  dst.backgroundColor = src.backgroundColor;
+  dst.borders = src.borders ? deepClone(src.borders) : void 0;
+  dst.padding = src.padding;
+  dst.wordWrap = src.wordWrap;
+}
+function insertRow(rows, index, position) {
+  const insertAt = position === "above" ? index : index + 1;
+  const ref = rows[index];
+  const colCount = ref.cells.length;
+  const type = ref.type === "data" ? "header" : ref.type;
+  const newRow = {
+    id: `row-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+    type,
+    height: ref.height,
+    cells: Array.from({ length: colCount }, () => createCell())
+  };
+  for (let c = 0; c < colCount; c++) {
+    if (insertAt > 0 && insertAt < rows.length) {
+      const span = getSpanRect(rows, insertAt - 1, c);
+      if (span.r1 < insertAt && span.r2 >= insertAt) {
+        const main = rows[span.r1].cells[span.c1];
+        main.rowspan = (main.rowspan ?? 1) + 1;
+        newRow.cells[c].merged = true;
+      }
+    }
+  }
+  rows.splice(insertAt, 0, newRow);
+}
+function deleteRow(rows, index) {
+  if (rows.length <= 1) {
+    return "\u4E0D\u80FD\u5220\u9664\u6700\u540E\u4E00\u884C";
+  }
+  const row = rows[index];
+  const colCount = row.cells.length;
+  for (let c = 0; c < colCount; c++) {
+    const cell = row.cells[c];
+    if (!cell.merged && (cell.rowspan ?? 1) > 1) {
+      const next = rows[index + 1].cells[c];
+      Object.assign(next, deepClone(cell), { id: next.id });
+      next.rowspan = (cell.rowspan ?? 1) - 1;
+      next.merged = false;
+    } else if (cell.merged) {
+      const span = getSpanRect(rows, index, c);
+      if (span.r1 < index && span.c1 === c) {
+        const main = rows[span.r1].cells[span.c1];
+        main.rowspan = (main.rowspan ?? 1) - 1;
+      }
+    }
+  }
+  rows.splice(index, 1);
+  return null;
+}
+function insertCol(rows, colWidths, index, position) {
+  const insertAt = position === "left" ? index : index + 1;
+  colWidths.splice(insertAt, 0, colWidths[index]);
+  for (const row of rows) {
+    const newCell = createCell();
+    if (insertAt > 0 && insertAt < row.cells.length) {
+      const r = rows.indexOf(row);
+      const span = getSpanRect(rows, r, insertAt - 1);
+      if (span.c1 < insertAt && span.c2 >= insertAt) {
+        const main = rows[span.r1].cells[span.c1];
+        if (r === span.r1) {
+          main.colspan = (main.colspan ?? 1) + 1;
+        }
+        newCell.merged = true;
+      }
+    }
+    row.cells.splice(insertAt, 0, newCell);
+  }
+}
+function deleteCol(rows, colWidths, index) {
+  if (colWidths.length <= 1) {
+    return "\u4E0D\u80FD\u5220\u9664\u6700\u540E\u4E00\u5217";
+  }
+  for (let r = 0; r < rows.length; r++) {
+    const cell = rows[r].cells[index];
+    if (!cell.merged && (cell.colspan ?? 1) > 1) {
+      const next = rows[r].cells[index + 1];
+      Object.assign(next, deepClone(cell), { id: next.id });
+      next.colspan = (cell.colspan ?? 1) - 1;
+      next.merged = false;
+    } else if (cell.merged) {
+      const span = getSpanRect(rows, r, index);
+      if (span.c1 < index && span.r1 === r) {
+        const main = rows[span.r1].cells[span.c1];
+        main.colspan = (main.colspan ?? 1) - 1;
+      }
+    }
+  }
+  for (const row of rows) {
+    row.cells.splice(index, 1);
+  }
+  colWidths.splice(index, 1);
+  return null;
+}
+function setRowType(rows, index, type) {
+  if (type === "data") {
+    const existing = rows.findIndex((r, i) => r.type === "data" && i !== index);
+    if (existing >= 0) {
+      return `\u6570\u636E\u884C\u5DF2\u5B58\u5728\uFF08\u7B2C ${existing + 1} \u884C\uFF09\uFF0C\u5168\u8868\u6700\u591A\u4E00\u884C`;
+    }
+  }
+  if (type === "header") {
+    for (let i = 0; i < index; i++) {
+      if (rows[i].type !== "header") {
+        return "\u6807\u9898\u884C\u5FC5\u987B\u4ECE\u8868\u683C\u9876\u90E8\u8FDE\u7EED\u8BBE\u7F6E";
+      }
+    }
+  }
+  if (type === "subtotal" || type === "summary") {
+    const dataIdx = rows.findIndex((r) => r.type === "data");
+    if (dataIdx < 0) {
+      return "\u8BF7\u5148\u8BBE\u7F6E\u6570\u636E\u884C\uFF0C\u5C0F\u8BA1/\u6C47\u603B\u884C\u5FC5\u987B\u4F4D\u4E8E\u6570\u636E\u884C\u4E4B\u540E";
+    }
+    if (index < dataIdx) {
+      return "\u5C0F\u8BA1/\u6C47\u603B\u884C\u5FC5\u987B\u4F4D\u4E8E\u6570\u636E\u884C\u4E4B\u540E";
+    }
+  }
+  if (type === "subtotal") {
+    if (rows.slice(0, index).some((r) => r.type === "summary")) {
+      return "\u5C0F\u8BA1\u884C\u5FC5\u987B\u4F4D\u4E8E\u6C47\u603B\u884C\u4E4B\u524D";
+    }
+  }
+  if (type === "summary") {
+    if (rows.slice(index + 1).some((r) => r.type === "subtotal")) {
+      return "\u6C47\u603B\u884C\u5FC5\u987B\u4F4D\u4E8E\u5C0F\u8BA1\u884C\u4E4B\u540E";
+    }
+  }
+  if (rows[index].type === "header" && type !== "header") {
+    for (let i = index + 1; i < rows.length; i++) {
+      if (rows[i].type === "header") {
+        return "\u53D6\u6D88\u8BE5\u6807\u9898\u884C\u4F1A\u5BFC\u81F4\u6807\u9898\u884C\u4E0D\u8FDE\u7EED\uFF0C\u8BF7\u5148\u8C03\u6574\u540E\u7EED\u6807\u9898\u884C";
+      }
+    }
+  }
+  rows[index].type = type;
+  if (type !== "header") {
+    delete rows[index].repeatOnPage;
+  }
+  return null;
+}
+function applyBorderPreset(rows, rect, preset, border) {
+  for (let r = rect.r1; r <= rect.r2; r++) {
+    for (let c = rect.c1; c <= rect.c2; c++) {
+      const cell = rows[r].cells[c];
+      if (cell.merged) {
+        continue;
+      }
+      if (preset === "none") {
+        delete cell.borders;
+        continue;
+      }
+      const span = getSpanRect(rows, r, c);
+      const atTop = span.r1 === rect.r1;
+      const atBottom = span.r2 === rect.r2;
+      const atLeft = span.c1 === rect.c1;
+      const atRight = span.c2 === rect.c2;
+      const b = { ...cell.borders ?? {} };
+      if (preset === "all") {
+        b.top = { ...border };
+        b.bottom = { ...border };
+        b.left = { ...border };
+        b.right = { ...border };
+      } else if (preset === "outer") {
+        if (atTop) {
+          b.top = { ...border };
+        }
+        if (atBottom) {
+          b.bottom = { ...border };
+        }
+        if (atLeft) {
+          b.left = { ...border };
+        }
+        if (atRight) {
+          b.right = { ...border };
+        }
+      } else if (preset === "inner") {
+        if (!atTop) {
+          b.top = { ...border };
+        }
+        if (!atBottom) {
+          b.bottom = { ...border };
+        }
+        if (!atLeft) {
+          b.left = { ...border };
+        }
+        if (!atRight) {
+          b.right = { ...border };
+        }
+      }
+      cell.borders = b;
+    }
+  }
+}
+var GHOST_BORDER_CSS = "1px dashed rgba(0,0,0,0.18)";
+function resolveCellBorderCss(b, opts = {}) {
+  if (b && b.style !== "none") return `${b.width}pt ${b.style} ${b.color}`;
+  if (opts.designMode && opts.showGhostBorder !== false) return GHOST_BORDER_CSS;
+  return "none";
+}
+function syncTableElementSize(options) {
+  const wMm = (options.tableColWidths ?? []).reduce((s, w) => s + w, 0);
+  const hMm = (options.tableRows ?? []).reduce((s, r) => s + r.height, 0);
+  options.width = Math.round(wMm * 100) / 100;
+  options.height = Math.round(hMm * 100) / 100;
+}
+var MIN_COL_WIDTH_MM = 5;
+function clampResizedColumnWidth(colWidths, index, targetMm, maxTableWidth) {
+  const others = colWidths.reduce((s, w, i) => i === index ? s : s + w, 0);
+  const cap = maxTableWidth === Infinity ? Infinity : Math.max(MIN_COL_WIDTH_MM, maxTableWidth - others);
+  const rounded = Math.round(targetMm * 10) / 10;
+  return Math.min(Math.max(rounded, MIN_COL_WIDTH_MM), cap);
+}
+
+// src/designer/utils/element-factory.ts
+function generateId() {
+  return `el-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function createDefaultOptions(type) {
+  const base = { left: 7, top: 17.6, width: 42.3, height: 7.1 };
+  switch (type) {
+    case "text":
+      return { ...base, formatter: "\u6587\u672C", fontSize: 12, textAlign: "left", height: 5.3 };
+    case "image":
+      return { ...base, width: 28.2, height: 28.2, fit: "contain" };
+    case "longText":
+      return { ...base, width: 141.1, height: 28.2, fontSize: 12, lineHeight: 18 };
+    case "table": {
+      const { rows, colWidths } = createDefaultTable();
+      const totalW = colWidths.reduce((s, w) => s + w, 0);
+      const totalH = rows.reduce((s, r) => s + r.height, 0);
+      return {
+        ...base,
+        width: totalW,
+        height: totalH,
+        // 表格尺寸由列宽/行高(mm)派生，与渲染端一致
+        tableMode: "dynamic",
+        tableRows: rows,
+        tableColWidths: colWidths,
+        tableDefaultFontSize: 10,
+        tableDefaultColor: "#333333",
+        tableDefaultPadding: 1,
+        fields: [],
+        tablePagination: { enabled: true }
+      };
+    }
+    case "hline":
+      return { ...base, width: 70.6, height: 1.8, borderWidth: 0.75 };
+    case "vline":
+      return { ...base, width: 1.8, height: 35.3, borderWidth: 0.75 };
+    case "rect":
+      return { ...base, width: 28.2, height: 28.2, borderWidth: 1, borderColor: "#333" };
+    case "oval":
+      return { ...base, width: 28.2, height: 28.2, borderWidth: 1, borderColor: "#333" };
+    case "barcode":
+      return { ...base, width: 56.4, height: 14.1, title: "\u6761\u5F62\u7801", barcodeType: "code128", testData: "12345678" };
+    case "qrcode":
+      return { ...base, width: 28.2, height: 28.2, title: "\u4E8C\u7EF4\u7801", testData: "qrcode" };
+    case "html":
+      return { ...base, width: 28.2, height: 28.2 };
+    default:
+      return base;
+  }
+}
+function createRuntimeElement(type, options) {
+  const typeMetaMap = {
+    text: { title: "\u6587\u672C" },
+    image: { title: "\u56FE\u7247" },
+    longText: { title: "\u957F\u6587" },
+    table: { title: "\u8868\u683C" },
+    hline: { title: "\u6A2A\u7EBF" },
+    vline: { title: "\u7AD6\u7EBF" },
+    rect: { title: "\u77E9\u5F62" },
+    oval: { title: "\u692D\u5706" },
+    barcode: { title: "\u6761\u5F62\u7801" },
+    qrcode: { title: "\u4E8C\u7EF4\u7801" },
+    html: { title: "HTML" },
+    pageNumber: { title: "\u9875\u7801" }
+  };
+  return {
+    id: generateId(),
+    options: { ...createDefaultOptions(type), ...options },
+    printElementType: { type, title: typeMetaMap[type]?.title || type }
+  };
+}
+
+// src/designer/utils/zone-layout.ts
+var ZONE_ALLOWED_TYPES = ["text", "image", "hline", "vline", "rect", "oval", "barcode", "qrcode"];
+function getPaperSizeMM(t) {
+  return getPaperDimensions(t);
+}
+function getZoneRects(t) {
+  const paper = getPaperSizeMM(t);
+  const m = t.margins;
+  const headerH = t.header.height;
+  const footerH = t.footer.height;
+  const contentW = paper.width - m.left - m.right;
+  const contentH = paper.height - m.top - m.bottom - headerH - footerH;
+  const rect = (l, tp, w, h) => ({
+    left: l,
+    top: tp,
+    width: w,
+    height: h
+  });
+  return {
+    header: rect(m.left, m.top, contentW, headerH),
+    content: rect(m.left, m.top + headerH, contentW, contentH),
+    footer: rect(m.left, paper.height - m.bottom - footerH, contentW, footerH)
+  };
+}
+function zoneFromPaperPoint(t, _x, y) {
+  const r = getZoneRects(t);
+  if (r.footer.height > 0 && y >= r.footer.top) return "footer";
+  if (r.header.height > 0 && y < r.header.top + r.header.height) return "header";
+  return "content";
+}
+function clampToZone(el, zone) {
+  const o = el.options;
+  o.width = Math.min(o.width, zone.width);
+  o.height = Math.min(o.height, zone.height);
+  o.left = Math.min(Math.max(0, o.left), zone.width - o.width);
+  o.top = Math.min(Math.max(0, o.top), zone.height - o.height);
+}
+function finalizeElementZone(el, t) {
+  const rects = getZoneRects(t);
+  const fromZone = el.zone || "content";
+  const from = rects[fromZone];
+  const cx = from.left + el.options.left + el.options.width / 2;
+  const cy = from.top + el.options.top + el.options.height / 2;
+  let target = zoneFromPaperPoint(t, cx, cy);
+  let rejected = false;
+  if (target !== "content" && !ZONE_ALLOWED_TYPES.includes(el.printElementType.type)) {
+    target = "content";
+    rejected = true;
+  }
+  if (target !== fromZone) {
+    const to = rects[target];
+    el.options.left = from.left + el.options.left - to.left;
+    el.options.top = from.top + el.options.top - to.top;
+    el.zone = target;
+  }
+  if (target !== "content") {
+    clampToZone(el, rects[target]);
+  } else if (rejected) {
+    clampToZone(el, rects.content);
+  }
+  return { rejected };
+}
+
+// src/designer/utils/ruler.ts
+var RULER_THICKNESS = 22;
+var STEP_SEQUENCE = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1e3];
+function chooseMajorStepMM(scale, targetPx = 64) {
+  const pxPerMM = scale * (96 / 25.4);
+  for (const step of STEP_SEQUENCE) {
+    if (step * pxPerMM >= targetPx) return step;
+  }
+  return STEP_SEQUENCE[STEP_SEQUENCE.length - 1];
+}
+function minorStepMM(majorStepMM) {
+  const exp = Math.floor(Math.log10(majorStepMM) + 1e-9);
+  const base = majorStepMM / 10 ** exp;
+  if (base === 5 || base === 1 && majorStepMM >= 10) return majorStepMM / 5;
+  if (base === 2) return majorStepMM / 2;
+  return null;
+}
+function roundMM(mm2) {
+  return Math.round(mm2 * 1e3) / 1e3;
+}
+function buildRulerTicks(startMM, endMM, majorStepMM) {
+  if (endMM < startMM || majorStepMM <= 0) return [];
+  const minor = minorStepMM(majorStepMM);
+  const fine = minor ?? majorStepMM;
+  const first = Math.ceil(startMM / fine - 1e-9) * fine;
+  const lastIndex = Math.floor((endMM - first) / fine + 1e-9);
+  const ticks = [];
+  for (let i = 0; i <= lastIndex; i++) {
+    const mm2 = roundMM(first + i * fine);
+    const isMajor = Math.abs(mm2 / majorStepMM - Math.round(mm2 / majorStepMM)) < 1e-6;
+    if (isMajor) {
+      ticks.push({ mm: mm2, major: true, label: String(mm2) });
+    } else {
+      ticks.push({ mm: mm2, major: false });
+    }
+  }
+  return ticks;
+}
+
+// src/designer/utils/preset-colors.ts
+var PRESET_COLORS = [
+  "#000000",
+  "#333333",
+  "#666666",
+  "#999999",
+  "#cccccc",
+  "#ffffff",
+  "#e53935",
+  "#fb8c00",
+  "#1e88e5",
+  "#43a047",
+  "#8d6e63",
+  "#00acc1"
+];
+
+// src/designer/utils/property-search.ts
+var PROPERTY_REGISTRY = [
+  {
+    group: "position-size",
+    groupLabel: "\u4F4D\u7F6E\u4E0E\u5C3A\u5BF8",
+    items: [
+      { key: "ps-left", keywords: ["X", "\u6A2A\u5750\u6807", "left", "\u4F4D\u7F6E"] },
+      { key: "ps-top", keywords: ["Y", "\u7EB5\u5750\u6807", "top", "\u4F4D\u7F6E"] },
+      { key: "ps-width", keywords: ["W", "\u5BBD\u5EA6", "width", "\u5C3A\u5BF8"] },
+      { key: "ps-height", keywords: ["H", "\u9AD8\u5EA6", "height", "\u5C3A\u5BF8"] }
+    ]
+  },
+  {
+    group: "appearance",
+    groupLabel: "\u5916\u89C2",
+    items: [
+      { key: "ap-font-size", keywords: ["\u5B57\u4F53\u5927\u5C0F", "fontsize", "\u5B57\u53F7"] },
+      { key: "ap-font-weight", keywords: ["\u5B57\u4F53\u7C97\u7EC6", "\u7C97\u4F53", "bold"] },
+      { key: "ap-align", keywords: ["\u5BF9\u9F50", "align"] },
+      { key: "ap-vertical-align", keywords: ["\u5782\u76F4\u5BF9\u9F50", "verticalalign", "\u9876\u5BF9\u9F50", "\u5E95\u5BF9\u9F50"] },
+      { key: "ap-color", keywords: ["\u989C\u8272", "color"] },
+      { key: "ap-bg-color", keywords: ["\u80CC\u666F\u8272", "background"] },
+      { key: "ap-line-height", keywords: ["\u884C\u9AD8", "lineheight"] },
+      { key: "ap-letter-spacing", keywords: ["\u5B57\u95F4\u8DDD", "letterspacing"] }
+    ]
+  },
+  {
+    group: "content",
+    groupLabel: "\u5185\u5BB9",
+    items: [
+      { key: "ct-title", keywords: ["\u5185\u5BB9", "\u6587\u672C", "title"] },
+      { key: "ct-formatter", keywords: ["\u683C\u5F0F\u5316", "\u8868\u8FBE\u5F0F", "formatter"] },
+      { key: "ct-table-mode", keywords: ["\u6570\u636E\u6A21\u5F0F", "\u9759\u6001\u5E03\u5C40", "\u52A8\u6001\u6570\u636E"] },
+      { key: "ct-table-source", keywords: ["\u6570\u636E\u6E90", "\u5217\u8868\u5B57\u6BB5"] },
+      { key: "ct-table-font", keywords: ["\u9ED8\u8BA4\u5B57\u53F7", "\u9ED8\u8BA4\u989C\u8272", "\u9ED8\u8BA4\u5185\u8FB9\u8DDD"] },
+      { key: "ct-table-cols", keywords: ["\u5217\u5BBD", "\u8868\u683C\u5217"] }
+    ]
+  },
+  {
+    group: "border-bg",
+    groupLabel: "\u8FB9\u6846\u4E0E\u80CC\u666F",
+    items: [
+      { key: "bb-border-width", keywords: ["\u8FB9\u6846\u5BBD\u5EA6", "border"] },
+      { key: "bb-border-color", keywords: ["\u8FB9\u6846\u989C\u8272"] },
+      { key: "bb-bg-color", keywords: ["\u80CC\u666F\u8272", "background"] }
+    ]
+  },
+  {
+    group: "binding",
+    groupLabel: "\u5B57\u6BB5\u7ED1\u5B9A",
+    items: [
+      { key: "bd-formatter", keywords: ["\u683C\u5F0F\u5316", "\u8868\u8FBE\u5F0F", "formatter", "fx", "\u5B57\u6BB5", "\u7ED1\u5B9A", "field"] },
+      { key: "bd-content", keywords: ["\u5185\u5BB9", "\u8868\u8FBE\u5F0F", "\u6587\u672C", "\u53D8\u91CF"] }
+    ]
+  },
+  {
+    group: "pagination",
+    groupLabel: "\u5206\u9875",
+    items: [
+      { key: "pg-enabled", keywords: ["\u5206\u9875", "pagination", "\u542F\u7528\u5206\u9875"] },
+      { key: "pg-pageable", keywords: ["\u53C2\u4E0E\u5206\u9875", "pageable"] },
+      { key: "pg-keep-with-next", keywords: ["\u540C\u9875", "keepWithNext"] }
+    ]
+  },
+  {
+    group: "advanced",
+    groupLabel: "\u9AD8\u7EA7",
+    items: [
+      { key: "ad-locked", keywords: ["\u9501\u5B9A", "lock"] },
+      { key: "ad-fixed", keywords: ["\u6BCF\u9875\u91CD\u590D", "repeat"] },
+      { key: "ad-z-index", keywords: ["\u5C42\u7EA7", "zindex"] },
+      { key: "ad-delete", keywords: ["\u5220\u9664"] }
+    ]
+  }
+];
+function matchKeywords(search, keywords) {
+  const s = search.trim().toLowerCase();
+  if (!s) {
+    return true;
+  }
+  return keywords.some((k) => k.toLowerCase().includes(s));
+}
+function searchProperties(search) {
+  const groups = [];
+  const itemKeys = /* @__PURE__ */ new Set();
+  for (const g of PROPERTY_REGISTRY) {
+    const matched = g.items.filter((item) => matchKeywords(search, [...item.keywords, g.groupLabel]));
+    if (matched.length > 0) {
+      groups.push(g.group);
+      for (const item of matched) {
+        itemKeys.add(item.key);
+      }
+    }
+  }
+  return { groups, itemKeys };
+}
+
+// src/designer/utils/field-groups.ts
+function groupFields(fields) {
+  const sorted = [...fields].sort((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0));
+  const groupMap = /* @__PURE__ */ new Map();
+  const groupOrder = [];
+  for (const f of sorted) {
+    const dot = f.fieldKey.indexOf(".");
+    if (dot === -1) continue;
+    const key = f.fieldKey.slice(0, dot);
+    let g = groupMap.get(key);
+    if (!g) {
+      g = { key, label: key, isList: false, fields: [] };
+      groupMap.set(key, g);
+      groupOrder.push(key);
+    }
+    g.fields.push(f);
+  }
+  const groups = [];
+  const standalone = [];
+  for (const f of sorted) {
+    if (f.fieldKey.includes(".")) continue;
+    const g = groupMap.get(f.fieldKey);
+    if (g) {
+      g.label = f.fieldLabel;
+      g.isList = f.fieldType === "list";
+    } else {
+      standalone.push(f);
+    }
+  }
+  if (standalone.length) groups.push({ key: "", label: "", isList: false, fields: standalone });
+  for (const key of groupOrder) groups.push(groupMap.get(key));
+  return groups;
+}
+function filterGroups(groups, keyword) {
+  const kw = keyword.trim().toLowerCase();
+  if (!kw) return groups;
+  return groups.map((g) => ({
+    ...g,
+    fields: g.fields.filter(
+      (f) => f.fieldLabel.toLowerCase().includes(kw) || f.fieldKey.toLowerCase().includes(kw)
+    )
+  })).filter((g) => g.fields.length > 0);
+}
+
+// src/designer/utils/binding-registry.ts
+var ELEMENT_BINDING_REGISTRY = {
+  text: [
+    { targetPath: "options.formatter", label: "\u5185\u5BB9", dataSource: "main" }
+  ],
+  longText: [
+    { targetPath: "options.formatter", label: "\u5185\u5BB9", dataSource: "main" },
+    { targetPath: "options.styler", label: "\u6837\u5F0F", dataSource: "main" }
+  ],
+  barcode: [
+    { targetPath: "options.formatter", label: "\u5185\u5BB9", dataSource: "main" }
+  ],
+  qrcode: [
+    { targetPath: "options.formatter", label: "\u5185\u5BB9", dataSource: "main" }
+  ],
+  image: [
+    { targetPath: "options.src", label: "\u5185\u5BB9", dataSource: "main", placeholder: "\u8F93\u5165\u56FE\u7247\u8DEF\u5F84\uFF0C\u652F\u6301 /docfiles/... \u76F8\u5BF9\u8DEF\u5F84\u3001\u7EDD\u5BF9 URL \u6216 {\u5B57\u6BB5} \u8868\u8FBE\u5F0F" }
+  ],
+  table: []
+};
+function getTableCellBindings(rowType, rowIndex, cellIndex, listField) {
+  if (rowType === "data") {
+    return [{
+      targetPath: `options.tableRows[${rowIndex}].cells[${cellIndex}].formatter`,
+      label: "\u5185\u5BB9",
+      dataSource: "list",
+      listField,
+      placeholder: "{name}"
+    }];
+  }
+  if (rowType === "subtotal") {
+    return [{
+      targetPath: `options.tableRows[${rowIndex}].cells[${cellIndex}].formatter`,
+      label: "\u5185\u5BB9",
+      dataSource: "subtotal",
+      placeholder: "{MONEY(SUM(amount))}"
+    }];
+  }
+  if (rowType === "summary") {
+    return [{
+      targetPath: `options.tableRows[${rowIndex}].cells[${cellIndex}].formatter`,
+      label: "\u5185\u5BB9",
+      dataSource: "summary",
+      placeholder: "{MONEY(SUM(amount))}"
+    }];
+  }
+  return [{
+    targetPath: `options.tableRows[${rowIndex}].cells[${cellIndex}].formatter`,
+    label: "\u5185\u5BB9",
+    dataSource: "main",
+    placeholder: "\u5408\u8BA1: {order.total}"
+  }];
+}
+function getElementBindings(element) {
+  const type = element.printElementType.type;
+  const staticBindings = ELEMENT_BINDING_REGISTRY[type] ?? [];
+  const dynamicBindings = [];
+  if (type === "table") {
+    const listField = element.options.dataSource;
+    for (const [ri, row] of (element.options.tableRows ?? []).entries()) {
+      for (const [ci, cell] of row.cells.entries()) {
+        if (cell.merged) continue;
+        dynamicBindings.push(...getTableCellBindings(row.type, ri, ci, listField));
+      }
+    }
+  }
+  return [...staticBindings, ...dynamicBindings];
+}
+
+// src/designer/utils/demo-data.ts
+function getDemoData() {
+  return DEFAULT_DEMO_DATA;
+}
+var DEFAULT_DEMO_DATA = {
+  supplier: {
+    name: "\u946B\u8FBE\u4E94\u91D1\u6709\u9650\u516C\u53F8",
+    phone: "0571-88776655",
+    address: "\u676D\u5DDE\u5E02\u8427\u5C71\u533A\u7ECF\u6D4E\u5F00\u53D1\u533A88\u53F7"
+  },
+  receiver: {
+    name: "\u674E\u56DB",
+    phone: "13912345678",
+    address: "\u676D\u5DDE\u5E02\u4F59\u676D\u533A\u6587\u4E00\u897F\u8DEF998\u53F7"
+  },
+  order: {
+    no: "PO20260801001",
+    date: "2026-08-01",
+    total: 69543.75
+  },
+  // 50 条商品明细, 用于验证多页分页效果
+  goods: [
+    { name: "\u78B3\u94A2\u87BA\u4E1D M8", spec: "M14\xD710", unit: "\u4E2A", qty: 100, price: 0.5, amount: 50, remark: "A\u7EA7" },
+    { name: "\u4E0D\u9508\u94A2\u87BA\u6BCD M10", spec: "M16\xD711", unit: "\u5957", qty: 117, price: 0.75, amount: 87.75, remark: "" },
+    { name: "\u5F39\u7C27\u57AB\u5708 M12", spec: "M6\xD712", unit: "\u76D2", qty: 134, price: 1, amount: 134, remark: "" },
+    { name: "\u516D\u89D2\u87BA\u6813 M14", spec: "M5\xD713", unit: "\u652F", qty: 151, price: 1.25, amount: 188.75, remark: "" },
+    { name: "\u5185\u516D\u89D2\u87BA\u9489 M16", spec: "M20\xD714", unit: "\u888B", qty: 168, price: 1.5, amount: 252, remark: "" },
+    { name: "\u5E73\u57AB\u5708 M6", spec: "M4\xD715", unit: "\u4EF6", qty: 185, price: 1.75, amount: 323.75, remark: "" },
+    { name: "\u81EA\u653B\u87BA\u9489 M5", spec: "M3\xD716", unit: "\u6839", qty: 202, price: 2, amount: 404, remark: "" },
+    { name: "\u53CC\u5934\u87BA\u67F1 M20", spec: "M8\xD717", unit: "\u5305", qty: 219, price: 2.25, amount: 492.75, remark: "A\u7EA7" },
+    { name: "\u7D27\u5B9A\u87BA\u9489 M4", spec: "M10\xD718", unit: "\u53EA", qty: 236, price: 2.5, amount: 590, remark: "" },
+    { name: "\u5341\u5B57\u76D8\u5934\u9489 M3", spec: "M12\xD719", unit: "\u7EC4", qty: 253, price: 2.75, amount: 695.75, remark: "" },
+    { name: "\u78B3\u94A2\u87BA\u4E1D M8", spec: "M14\xD720", unit: "\u4E2A", qty: 270, price: 3, amount: 810, remark: "" },
+    { name: "\u4E0D\u9508\u94A2\u87BA\u6BCD M10", spec: "M16\xD721", unit: "\u5957", qty: 287, price: 3.25, amount: 932.75, remark: "" },
+    { name: "\u5F39\u7C27\u57AB\u5708 M12", spec: "M6\xD722", unit: "\u76D2", qty: 304, price: 3.5, amount: 1064, remark: "" },
+    { name: "\u516D\u89D2\u87BA\u6813 M14", spec: "M5\xD723", unit: "\u652F", qty: 321, price: 3.75, amount: 1203.75, remark: "" },
+    { name: "\u5185\u516D\u89D2\u87BA\u9489 M16", spec: "M20\xD724", unit: "\u888B", qty: 338, price: 4, amount: 1352, remark: "A\u7EA7" },
+    { name: "\u5E73\u57AB\u5708 M6", spec: "M4\xD725", unit: "\u4EF6", qty: 355, price: 4.25, amount: 1508.75, remark: "" },
+    { name: "\u81EA\u653B\u87BA\u9489 M5", spec: "M3\xD726", unit: "\u6839", qty: 372, price: 4.5, amount: 1674, remark: "" },
+    { name: "\u53CC\u5934\u87BA\u67F1 M20", spec: "M8\xD727", unit: "\u5305", qty: 389, price: 4.75, amount: 1847.75, remark: "" },
+    { name: "\u7D27\u5B9A\u87BA\u9489 M4", spec: "M10\xD728", unit: "\u53EA", qty: 406, price: 5, amount: 2030, remark: "" },
+    { name: "\u5341\u5B57\u76D8\u5934\u9489 M3", spec: "M12\xD729", unit: "\u7EC4", qty: 423, price: 5.25, amount: 2220.75, remark: "" },
+    { name: "\u78B3\u94A2\u87BA\u4E1D M8", spec: "M14\xD730", unit: "\u4E2A", qty: 440, price: 0.5, amount: 220, remark: "" },
+    { name: "\u4E0D\u9508\u94A2\u87BA\u6BCD M10", spec: "M16\xD731", unit: "\u5957", qty: 457, price: 0.75, amount: 342.75, remark: "A\u7EA7" },
+    { name: "\u5F39\u7C27\u57AB\u5708 M12", spec: "M6\xD732", unit: "\u76D2", qty: 474, price: 1, amount: 474, remark: "" },
+    { name: "\u516D\u89D2\u87BA\u6813 M14", spec: "M5\xD733", unit: "\u652F", qty: 491, price: 1.25, amount: 613.75, remark: "" },
+    { name: "\u5185\u516D\u89D2\u87BA\u9489 M16", spec: "M20\xD734", unit: "\u888B", qty: 508, price: 1.5, amount: 762, remark: "" },
+    { name: "\u5E73\u57AB\u5708 M6", spec: "M4\xD735", unit: "\u4EF6", qty: 525, price: 1.75, amount: 918.75, remark: "" },
+    { name: "\u81EA\u653B\u87BA\u9489 M5", spec: "M3\xD736", unit: "\u6839", qty: 542, price: 2, amount: 1084, remark: "" },
+    { name: "\u53CC\u5934\u87BA\u67F1 M20", spec: "M8\xD737", unit: "\u5305", qty: 559, price: 2.25, amount: 1257.75, remark: "" },
+    { name: "\u7D27\u5B9A\u87BA\u9489 M4", spec: "M10\xD738", unit: "\u53EA", qty: 576, price: 2.5, amount: 1440, remark: "A\u7EA7" },
+    { name: "\u5341\u5B57\u76D8\u5934\u9489 M3", spec: "M12\xD739", unit: "\u7EC4", qty: 593, price: 2.75, amount: 1630.75, remark: "" },
+    { name: "\u78B3\u94A2\u87BA\u4E1D M8", spec: "M14\xD740", unit: "\u4E2A", qty: 610, price: 3, amount: 1830, remark: "" },
+    { name: "\u4E0D\u9508\u94A2\u87BA\u6BCD M10", spec: "M16\xD741", unit: "\u5957", qty: 627, price: 3.25, amount: 2037.75, remark: "" },
+    { name: "\u5F39\u7C27\u57AB\u5708 M12", spec: "M6\xD742", unit: "\u76D2", qty: 644, price: 3.5, amount: 2254, remark: "" },
+    { name: "\u516D\u89D2\u87BA\u6813 M14", spec: "M5\xD743", unit: "\u652F", qty: 661, price: 3.75, amount: 2478.75, remark: "" },
+    { name: "\u5185\u516D\u89D2\u87BA\u9489 M16", spec: "M20\xD744", unit: "\u888B", qty: 678, price: 4, amount: 2712, remark: "" },
+    { name: "\u5E73\u57AB\u5708 M6", spec: "M4\xD745", unit: "\u4EF6", qty: 695, price: 4.25, amount: 2953.75, remark: "A\u7EA7" },
+    { name: "\u81EA\u653B\u87BA\u9489 M5", spec: "M3\xD746", unit: "\u6839", qty: 712, price: 4.5, amount: 3204, remark: "" },
+    { name: "\u53CC\u5934\u87BA\u67F1 M20", spec: "M8\xD747", unit: "\u5305", qty: 729, price: 4.75, amount: 3462.75, remark: "" },
+    { name: "\u7D27\u5B9A\u87BA\u9489 M4", spec: "M10\xD748", unit: "\u53EA", qty: 746, price: 5, amount: 3730, remark: "" },
+    { name: "\u5341\u5B57\u76D8\u5934\u9489 M3", spec: "M12\xD749", unit: "\u7EC4", qty: 763, price: 5.25, amount: 4005.75, remark: "" },
+    { name: "\u78B3\u94A2\u87BA\u4E1D M8", spec: "M14\xD710", unit: "\u4E2A", qty: 780, price: 0.5, amount: 390, remark: "" },
+    { name: "\u4E0D\u9508\u94A2\u87BA\u6BCD M10", spec: "M16\xD711", unit: "\u5957", qty: 797, price: 0.75, amount: 597.75, remark: "" },
+    { name: "\u5F39\u7C27\u57AB\u5708 M12", spec: "M6\xD712", unit: "\u76D2", qty: 814, price: 1, amount: 814, remark: "A\u7EA7" },
+    { name: "\u516D\u89D2\u87BA\u6813 M14", spec: "M5\xD713", unit: "\u652F", qty: 831, price: 1.25, amount: 1038.75, remark: "" },
+    { name: "\u5185\u516D\u89D2\u87BA\u9489 M16", spec: "M20\xD714", unit: "\u888B", qty: 848, price: 1.5, amount: 1272, remark: "" },
+    { name: "\u5E73\u57AB\u5708 M6", spec: "M4\xD715", unit: "\u4EF6", qty: 865, price: 1.75, amount: 1513.75, remark: "" },
+    { name: "\u81EA\u653B\u87BA\u9489 M5", spec: "M3\xD716", unit: "\u6839", qty: 882, price: 2, amount: 1764, remark: "" },
+    { name: "\u53CC\u5934\u87BA\u67F1 M20", spec: "M8\xD717", unit: "\u5305", qty: 899, price: 2.25, amount: 2022.75, remark: "" },
+    { name: "\u7D27\u5B9A\u87BA\u9489 M4", spec: "M10\xD718", unit: "\u53EA", qty: 916, price: 2.5, amount: 2290, remark: "" },
+    { name: "\u5341\u5B57\u76D8\u5934\u9489 M3", spec: "M12\xD719", unit: "\u7EC4", qty: 933, price: 2.75, amount: 2565.75, remark: "A\u7EA7" }
+  ]
+};
+
+// src/lexer.ts
+var DANGEROUS_PROPS = /* @__PURE__ */ new Set([
+  "constructor",
+  "__proto__",
+  "prototype",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__"
+]);
+var RESERVED_WORDS = /* @__PURE__ */ new Set([
+  "new",
+  "function",
+  "class",
+  "this",
+  "delete",
+  "typeof",
+  "void",
+  "in",
+  "of",
+  "var",
+  "let",
+  "const",
+  "return",
+  "if",
+  "while",
+  "for"
+]);
+function tokenize(input) {
+  const tokens = [];
+  let i = 0;
+  const n = input.length;
+  while (i < n) {
+    const ch = input[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (/[0-9]/.test(ch) || ch === "." && i + 1 < n && /[0-9]/.test(input[i + 1])) {
+      let j = i;
+      while (j < n && /[0-9.]/.test(input[j])) j++;
+      tokens.push({ type: "num", value: input.slice(i, j), position: i });
+      i = j;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      let j = i + 1;
+      let s = "";
+      while (j < n && input[j] !== ch) {
+        if (input[j] === "\\" && j + 1 < n) {
+          s += input[j + 1];
+          j += 2;
+        } else {
+          s += input[j];
+          j++;
+        }
+      }
+      if (j >= n) throw new Error("\u5B57\u7B26\u4E32\u672A\u95ED\u5408");
+      tokens.push({ type: "str", value: s, position: i });
+      i = j + 1;
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(ch)) {
+      let j = i;
+      while (j < n && /[A-Za-z0-9_$]/.test(input[j])) j++;
+      const word = input.slice(i, j);
+      if (RESERVED_WORDS.has(word)) {
+        throw new Error(`\u4E0D\u5141\u8BB8\u4F7F\u7528\u5173\u952E\u5B57: ${word}`);
+      }
+      if (DANGEROUS_PROPS.has(word)) {
+        throw new Error(`\u7981\u6B62\u8BBF\u95EE: ${word}`);
+      }
+      if (word === "true" || word === "false") {
+        tokens.push({ type: "bool", value: word, position: i });
+      } else {
+        tokens.push({ type: "ident", value: word, position: i });
+      }
+      i = j;
+      continue;
+    }
+    const three = input.slice(i, i + 3);
+    if (three === "===" || three === "!==") {
+      tokens.push({ type: "punc", value: three, position: i });
+      i += 3;
+      continue;
+    }
+    const two = input.slice(i, i + 2);
+    if (two === "=>") throw new Error("\u4E0D\u5141\u8BB8\u51FD\u6570\u5B9A\u4E49");
+    if (["==", "!=", "<=", ">=", "&&", "||"].includes(two)) {
+      tokens.push({ type: "punc", value: two, position: i });
+      i += 2;
+      continue;
+    }
+    if (ch === "=") throw new Error("\u4E0D\u5141\u8BB8\u8D4B\u503C");
+    if (ch === ";") throw new Error("\u4E0D\u5141\u8BB8\u591A\u6761\u8BED\u53E5");
+    if ("+-*/%()[]{},:.?!<>".includes(ch)) {
+      tokens.push({ type: "punc", value: ch, position: i });
+      i++;
+      continue;
+    }
+    throw new Error(`\u975E\u6CD5\u5B57\u7B26: ${ch}`);
+  }
+  return tokens;
+}
+
+// src/parser.ts
+function parse(tokens) {
+  const parser = new Parser(tokens);
+  return parser.parse();
+}
+var Parser = class {
+  constructor(tokens) {
+    this.pos = 0;
+    this.tokens = tokens;
+  }
+  parse() {
+    const node = this.parseTernary();
+    if (this.pos < this.tokens.length) {
+      throw new Error(`\u8868\u8FBE\u5F0F\u5B58\u5728\u591A\u4F59\u5185\u5BB9: ${this.tokens[this.pos].value}`);
+    }
+    return node;
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  next() {
+    const t = this.tokens[this.pos++];
+    if (!t) throw new Error("\u8868\u8FBE\u5F0F\u610F\u5916\u7ED3\u675F");
+    return t;
+  }
+  eatPunc(value) {
+    const t = this.peek();
+    if (t && t.type === "punc" && t.value === value) {
+      this.pos++;
+      return true;
+    }
+    return false;
+  }
+  expectPunc(value) {
+    if (!this.eatPunc(value)) {
+      const pos = this.peek()?.position ?? 0;
+      throw new Error(`\u4F4D\u7F6E ${pos}: \u671F\u671B "${value}"`);
+    }
+  }
+  // 三元运算符 ?: (优先级最低)
+  parseTernary() {
+    const cond = this.parseLogicalOr();
+    if (this.eatPunc("?")) {
+      const consequent = this.parseTernary();
+      this.expectPunc(":");
+      const alternate = this.parseTernary();
+      return { type: "ternary", cond, consequent, alternate };
+    }
+    return cond;
+  }
+  // ||
+  parseLogicalOr() {
+    let left = this.parseLogicalAnd();
+    while (this.eatPunc("||")) {
+      const right = this.parseLogicalAnd();
+      left = { type: "binary", op: "||", left, right };
+    }
+    return left;
+  }
+  // &&
+  parseLogicalAnd() {
+    let left = this.parseEquality();
+    while (this.eatPunc("&&")) {
+      const right = this.parseEquality();
+      left = { type: "binary", op: "&&", left, right };
+    }
+    return left;
+  }
+  // == != === !==
+  parseEquality() {
+    let left = this.parseRelational();
+    for (; ; ) {
+      const t = this.peek();
+      if (t?.type === "punc" && ["==", "!=", "===", "!=="].includes(t.value)) {
+        this.pos++;
+        const right = this.parseRelational();
+        left = { type: "binary", op: t.value, left, right };
+      } else {
+        return left;
+      }
+    }
+  }
+  // < > <= >=
+  parseRelational() {
+    let left = this.parseAdditive();
+    for (; ; ) {
+      const t = this.peek();
+      if (t?.type === "punc" && ["<", ">", "<=", ">="].includes(t.value)) {
+        this.pos++;
+        const right = this.parseAdditive();
+        left = { type: "binary", op: t.value, left, right };
+      } else {
+        return left;
+      }
+    }
+  }
+  // + - (二元)
+  parseAdditive() {
+    let left = this.parseMultiplicative();
+    for (; ; ) {
+      const t = this.peek();
+      if (t?.type === "punc" && (t.value === "+" || t.value === "-")) {
+        this.pos++;
+        const right = this.parseMultiplicative();
+        left = { type: "binary", op: t.value, left, right };
+      } else {
+        return left;
+      }
+    }
+  }
+  // * / %
+  parseMultiplicative() {
+    let left = this.parseUnary();
+    for (; ; ) {
+      const t = this.peek();
+      if (t?.type === "punc" && ["*", "/", "%"].includes(t.value)) {
+        this.pos++;
+        const right = this.parseUnary();
+        left = { type: "binary", op: t.value, left, right };
+      } else {
+        return left;
+      }
+    }
+  }
+  // 一元 ! - +
+  parseUnary() {
+    const t = this.peek();
+    if (t?.type === "punc" && ["!", "-", "+"].includes(t.value)) {
+      this.pos++;
+      const arg = this.parseUnary();
+      return { type: "unary", op: t.value, arg, prefix: true };
+    }
+    return this.parsePostfix();
+  }
+  // 成员访问 x.y, x[i], 函数调用 f()
+  parsePostfix() {
+    let node = this.parsePrimary();
+    for (; ; ) {
+      if (this.eatPunc(".")) {
+        const prop = this.next();
+        if (prop.type !== "ident") {
+          throw new Error(`\u4F4D\u7F6E ${prop.position}: \u6210\u5458\u8BBF\u95EE\u9700\u8981\u5C5E\u6027\u540D`);
+        }
+        node = {
+          type: "member",
+          object: node,
+          property: prop.value,
+          computed: false
+        };
+      } else if (this.eatPunc("[")) {
+        const index = this.parseTernary();
+        this.expectPunc("]");
+        if (index.type === "str") {
+          node = {
+            type: "member",
+            object: node,
+            property: index.value,
+            computed: false
+          };
+        } else {
+          node = {
+            type: "member",
+            object: node,
+            property: index.name ?? String(index.value),
+            computed: true
+          };
+        }
+      } else if (this.peek()?.type === "punc" && this.peek()?.value === "(" && (node.type === "ident" || node.type === "member")) {
+        this.pos++;
+        const args = this.parseArgs();
+        node = { type: "call", callee: node, args };
+      } else {
+        return node;
+      }
+    }
+  }
+  parseArgs() {
+    const args = [];
+    if (this.eatPunc(")")) return args;
+    for (; ; ) {
+      args.push(this.parseTernary());
+      if (this.eatPunc(")")) return args;
+      this.expectPunc(",");
+    }
+  }
+  parsePrimary() {
+    const t = this.next();
+    if (t.type === "num") {
+      const v = Number(t.value);
+      if (isNaN(v)) throw new Error(`\u975E\u6CD5\u6570\u5B57: ${t.value}`);
+      return { type: "num", value: v };
+    }
+    if (t.type === "str") {
+      return { type: "str", value: t.value };
+    }
+    if (t.type === "bool") {
+      return { type: "bool", value: t.value === "true" };
+    }
+    if (t.type === "ident") {
+      return { type: "ident", name: t.value };
+    }
+    if (t.value === "(") {
+      const inner = this.parseTernary();
+      this.expectPunc(")");
+      return inner;
+    }
+    if (t.value === "[") {
+      const elements = [];
+      if (!this.eatPunc("]")) {
+        for (; ; ) {
+          elements.push(this.parseTernary());
+          if (this.eatPunc("]")) break;
+          this.expectPunc(",");
+        }
+      }
+      return { type: "array", elements };
+    }
+    if (t.value === "{") {
+      const properties = [];
+      if (!this.eatPunc("}")) {
+        for (; ; ) {
+          const keyToken = this.next();
+          if (keyToken.type !== "ident" && keyToken.type !== "str") {
+            throw new Error(`\u4F4D\u7F6E ${keyToken.position}: \u5BF9\u8C61\u952E\u5FC5\u987B\u662F\u6807\u8BC6\u7B26\u6216\u5B57\u7B26\u4E32`);
+          }
+          this.expectPunc(":");
+          properties.push({ key: keyToken.value, value: this.parseTernary() });
+          if (this.eatPunc("}")) break;
+          this.expectPunc(",");
+        }
+      }
+      return { type: "object", properties };
+    }
+    throw new Error(`\u4F4D\u7F6E ${t.position}: \u610F\u5916\u7684\u7B26\u53F7: ${t.value}`);
+  }
+};
+
+// src/evaluator.ts
+var SAFE_GLOBALS = {
+  Math,
+  Number,
+  String,
+  Boolean,
+  parseInt,
+  parseFloat,
+  isNaN,
+  true: true,
+  false: false,
+  null: null,
+  undefined: void 0
+};
+var DANGEROUS_PROPS2 = /* @__PURE__ */ new Set([
+  "constructor",
+  "__proto__",
+  "prototype",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__"
+]);
+var CALLABLE_GLOBALS = /* @__PURE__ */ new Set(["Number", "String", "Boolean", "parseInt", "parseFloat", "isNaN"]);
+function evaluate(node, context, functions = {}) {
+  switch (node.type) {
+    case "num":
+      return node.value;
+    case "str":
+      return node.value;
+    case "bool":
+      return node.value;
+    case "ident":
+      return evalIdent(node.name, context, functions);
+    case "binary":
+      return evalBinary(node, context, functions);
+    case "unary":
+      return evalUnary(node, context, functions);
+    case "ternary":
+      return evaluate(node.cond, context, functions) ? evaluate(node.consequent, context, functions) : evaluate(node.alternate, context, functions);
+    case "member":
+      return evalMember(node, context, functions);
+    case "call":
+      return evalCall(node, context, functions);
+    case "array":
+      return node.elements.map((e) => evaluate(e, context, functions));
+    case "object":
+      return Object.fromEntries(
+        node.properties.map((p) => [p.key, evaluate(p.value, context, functions)])
+      );
+  }
+}
+function evalIdent(name, context, functions) {
+  if (Object.prototype.hasOwnProperty.call(context, name)) {
+    return context[name];
+  }
+  if (Object.prototype.hasOwnProperty.call(SAFE_GLOBALS, name)) {
+    return SAFE_GLOBALS[name];
+  }
+  throw new Error(`\u672A\u5B9A\u4E49\u7684\u6807\u8BC6\u7B26: ${name}`);
+}
+function evalBinary(node, context, functions) {
+  const left = evaluate(node.left, context, functions);
+  const right = evaluate(node.right, context, functions);
+  switch (node.op) {
+    case "+":
+      return left + right;
+    case "-":
+      return left - right;
+    case "*":
+      return left * right;
+    case "/":
+      return left / right;
+    case "%":
+      return left % right;
+    case "<":
+      return left < right;
+    case ">":
+      return left > right;
+    case "<=":
+      return left <= right;
+    case ">=":
+      return left >= right;
+    case "==":
+      return left == right;
+    case "!=":
+      return left != right;
+    case "===":
+      return left === right;
+    case "!==":
+      return left !== right;
+    case "&&":
+      return left && right;
+    case "||":
+      return left || right;
+    default:
+      throw new Error(`\u672A\u77E5\u8FD0\u7B97\u7B26: ${node.op}`);
+  }
+}
+function evalUnary(node, context, functions) {
+  const arg = evaluate(node.arg, context, functions);
+  switch (node.op) {
+    case "-":
+      return -arg;
+    case "+":
+      return +arg;
+    case "!":
+      return !arg;
+    default:
+      throw new Error(`\u672A\u77E5\u4E00\u5143\u8FD0\u7B97\u7B26: ${node.op}`);
+  }
+}
+function evalMember(node, context, functions) {
+  const obj = evaluate(node.object, context, functions);
+  if (obj == null) {
+    throw new Error("\u65E0\u6CD5\u8BBF\u95EE\u7A7A\u503C\u7684\u5C5E\u6027");
+  }
+  if (DANGEROUS_PROPS2.has(node.property)) {
+    throw new Error(`\u7981\u6B62\u8BBF\u95EE\u5C5E\u6027: ${node.property}`);
+  }
+  return obj[node.property];
+}
+function evalCall(node, context, functions) {
+  if (node.callee.type === "ident" && CALLABLE_GLOBALS.has(node.callee.name)) {
+    const fn = SAFE_GLOBALS[node.callee.name];
+    const args = node.args.map((a) => evaluate(a, context, functions));
+    return fn(...args);
+  }
+  if (node.callee.type === "member" && node.callee.object.type === "ident" && node.callee.object.name === "Math") {
+    const method = Math[node.callee.property];
+    if (typeof method !== "function") {
+      throw new Error(`Math.${node.callee.property} \u4E0D\u662F\u65B9\u6CD5`);
+    }
+    const args = node.args.map((a) => evaluate(a, context, functions));
+    return method(...args);
+  }
+  let fnName;
+  if (node.callee.type === "ident") {
+    fnName = node.callee.name;
+  } else if (node.callee.type === "member") {
+    throw new Error("\u4E0D\u652F\u6301\u65B9\u6CD5\u8C03\u7528\uFF0C\u8BF7\u4F7F\u7528\u9876\u7EA7\u51FD\u6570");
+  }
+  if (fnName && functions[fnName]) {
+    const args = node.args.map((a) => evaluate(a, context, functions));
+    return functions[fnName](...args);
+  }
+  if (fnName && Object.prototype.hasOwnProperty.call(context, fnName)) {
+    throw new Error(`${fnName} \u4E0D\u662F\u51FD\u6570`);
+  }
+  throw new Error(`\u4E0D\u5141\u8BB8\u8C03\u7528: ${fnName ?? "\u8868\u8FBE\u5F0F"}`);
+}
+
+// src/template-parser.ts
+function parseTemplate(template) {
+  const parts = [];
+  let i = 0;
+  const n = template.length;
+  while (i < n) {
+    if (template[i] === "{") {
+      let depth = 1;
+      let j2 = i + 1;
+      while (j2 < n && depth > 0) {
+        if (template[j2] === "{") depth++;
+        else if (template[j2] === "}") depth--;
+        j2++;
+      }
+      if (depth !== 0) {
+        throw new Error(`\u4F4D\u7F6E ${i}: \u82B1\u62EC\u53F7\u672A\u95ED\u5408`);
+      }
+      const exprStr = template.slice(i + 1, j2 - 1);
+      if (exprStr.trim() === "") {
+        throw new Error(`\u4F4D\u7F6E ${i}: \u7A7A\u8868\u8FBE\u5F0F`);
+      }
+      const tokens = tokenize(exprStr);
+      const expression = parse(tokens);
+      parts.push({ type: "expr", expression });
+      i = j2;
+      continue;
+    }
+    let j = i;
+    while (j < n && template[j] !== "{") {
+      if (template[j] === "\\" && j + 1 < n && (template[j + 1] === "{" || template[j + 1] === "}")) {
+        j += 2;
+      } else {
+        j++;
+      }
+    }
+    parts.push({ type: "text", value: template.slice(i, j).replace(/\\([{}])/g, "$1") });
+    i = j;
+  }
+  return { type: "template", parts };
+}
+function renderTemplate(ast, context, functions = {}) {
+  let result = "";
+  for (const part of ast.parts) {
+    if (part.type === "text") {
+      result += part.value;
+    } else {
+      const value = evaluate(part.expression, context, functions);
+      result += String(value ?? "");
+    }
+  }
+  return result;
+}
+function compileTemplate(template, functions = {}) {
+  const ast = parseTemplate(template);
+  return (context) => renderTemplate(ast, context, functions);
+}
+
+// src/utils.ts
+function getByPath(obj, path) {
+  if (obj == null || path == null) return void 0;
+  if (typeof obj === "object" && path in obj) return obj[path];
+  const parts = path.split(".");
+  let cur = obj;
+  for (const p of parts) {
+    if (cur == null) return void 0;
+    cur = cur[p];
+  }
+  return cur;
+}
+
+// src/functions/format.ts
+function formatMoney(value) {
+  const num = Number(value);
+  if (isNaN(num)) return String(value);
+  const sign = num < 0 ? "-" : "";
+  const abs = Math.abs(num);
+  const [intPart, decPart] = abs.toFixed(2).split(".");
+  const formatted = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return `${sign}${formatted}.${decPart}`;
+}
+function formatDate(value, fmt) {
+  let date;
+  if (value instanceof Date) {
+    date = value;
+  } else if (typeof value === "number") {
+    date = new Date(value);
+  } else if (typeof value === "string") {
+    date = new Date(value);
+  } else {
+    return String(value);
+  }
+  if (isNaN(date.getTime())) return String(value);
+  const pad = (n) => String(n).padStart(2, "0");
+  return fmt.replace("YYYY", String(date.getFullYear())).replace("MM", pad(date.getMonth() + 1)).replace("DD", pad(date.getDate())).replace("HH", pad(date.getHours())).replace("mm", pad(date.getMinutes())).replace("ss", pad(date.getSeconds()));
+}
+function toUpperCaseAmount(value) {
+  const num = Number(value);
+  if (isNaN(num)) return String(value);
+  if (num === 0) return "\u96F6\u5143\u6574";
+  const digits = ["\u96F6", "\u58F9", "\u8D30", "\u53C1", "\u8086", "\u4F0D", "\u9646", "\u67D2", "\u634C", "\u7396"];
+  const units = ["", "\u62FE", "\u4F70", "\u4EDF"];
+  const bigUnits = ["", "\u4E07", "\u4EBF"];
+  const sign = num < 0 ? "\u8D1F" : "";
+  const abs = Math.abs(num);
+  const [intStr, decStr] = abs.toFixed(2).split(".");
+  const intNum = parseInt(intStr, 10);
+  let result = "";
+  if (intNum > 0) {
+    const intChars = intStr.split("").reverse();
+    let groupIdx = 0;
+    let lastDigit = 0;
+    let needZero = false;
+    for (let i = 0; i < intChars.length; i++) {
+      const d = parseInt(intChars[i], 10);
+      const unit = units[groupIdx % 4];
+      const bigUnit = bigUnits[Math.floor(groupIdx / 4)];
+      if (d === 0) {
+        if (lastDigit !== 0) needZero = true;
+      } else {
+        if (needZero) {
+          result = "\u96F6" + result;
+          needZero = false;
+        }
+        result = digits[d] + unit + result;
+        lastDigit = d;
+      }
+      if (groupIdx % 4 === 3 && groupIdx > 0) {
+        result = bigUnit + result;
+      }
+      groupIdx++;
+    }
+    result += "\u5143";
+  }
+  const jiao = parseInt(decStr[0], 10);
+  const fen = parseInt(decStr[1], 10);
+  if (jiao === 0 && fen === 0) {
+    result += "\u6574";
+  } else {
+    if (jiao > 0) {
+      result += digits[jiao] + "\u89D2";
+    }
+    if (fen > 0) {
+      result += digits[fen] + "\u5206";
+    }
+  }
+  return sign + result;
+}
+function ifFn(condition, trueVal, falseVal) {
+  return condition ? trueVal : falseVal;
+}
+
+// src/functions/aggregate.ts
+function sum(rows, field) {
+  return rows.reduce((acc, row) => acc + (Number(getByPath(row, field)) || 0), 0);
+}
+function avg(rows, field) {
+  if (rows.length === 0) return 0;
+  return sum(rows, field) / rows.length;
+}
+function count(rows, field) {
+  return rows.length;
+}
+function min(rows, field) {
+  if (rows.length === 0) return 0;
+  return Math.min(...rows.map((row) => Number(getByPath(row, field)) || 0));
+}
+function max(rows, field) {
+  if (rows.length === 0) return 0;
+  return Math.max(...rows.map((row) => Number(getByPath(row, field)) || 0));
+}
+
+// src/render/expression-eval.ts
+var RenderEngine = class {
+  constructor() {
+    this.functions = {};
+  }
+  registerFunction(name, fn) {
+    this.functions[name] = fn;
+  }
+  evaluate(expression, context) {
+    const tokens = tokenize(expression);
+    const ast = parse(tokens);
+    return evaluate(ast, context, this.functions);
+  }
+  render(template, context) {
+    return compileTemplate(template, this.functions)(context);
+  }
+};
+var engine = new RenderEngine();
+var FORMAT_FUNCTIONS = {
+  MONEY: formatMoney,
+  DATE: formatDate,
+  UPPER: toUpperCaseAmount,
+  IF: ifFn,
+  CONCAT: (...args) => args.filter((v) => v != null).map(String).join(""),
+  IFEMPTY: (v, d) => v != null && v !== "" ? String(v) : d,
+  ROUND: (n, d) => Number(Number(n).toFixed(d)),
+  LEN: (s) => String(s).length
+};
+for (const [name, fn] of Object.entries(FORMAT_FUNCTIONS)) {
+  engine.registerFunction(name, fn);
+}
+
+// src/index.ts
+var TemplateEngine = class {
+  constructor(options) {
+    this.functions = {};
+    if (options?.functions) {
+      this.functions = { ...options.functions };
+    }
+  }
+  registerFunction(name, fn) {
+    this.functions[name] = fn;
+  }
+  evaluate(expression, context) {
+    const tokens = tokenize(expression);
+    const ast = parse(tokens);
+    return evaluate(ast, context, this.functions);
+  }
+  render(template, context) {
+    return compileTemplate(template, this.functions)(context);
+  }
+};
+
+// src/designer/utils/engine.ts
+var engine2 = new TemplateEngine();
+
+// src/designer/utils/expression-eval.ts
+var EXTENDED_FUNCTIONS = {
+  MONEY: formatMoney,
+  CONCAT: (...args) => args.filter((v) => v != null).join(""),
+  IF: ifFn,
+  FORMAT: (value) => {
+    if (typeof value !== "number") return String(value);
+    return value.toLocaleString("zh-CN", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+  },
+  SUBSTR: (str, start, len) => String(str).slice(start, len ? start + len : void 0),
+  LEN: (str) => String(str).length,
+  ROUND: (num, decimals) => Number(Number(num).toFixed(decimals)),
+  NOW: () => (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+  IFEMPTY: (value, defaultVal) => value != null && value !== "" ? String(value) : defaultVal,
+  PAD: (value, len, char) => String(value).padStart(len, char),
+  REPLACE: (str, from, to) => String(str).replace(new RegExp(from, "g"), to),
+  JSON: (value) => JSON.stringify(value, null, 2),
+  DATE: formatDate,
+  UPPER: toUpperCaseAmount
+};
+for (const [name, fn] of Object.entries(EXTENDED_FUNCTIONS)) {
+  engine2.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 safeEval2(expr, context, _callableNames) {
+  return engine2.evaluate(expr, context);
+}
+function evaluateTemplate2(text, ctx) {
+  if (!text) return "";
+  if (!text.includes("{")) return text;
+  const rows = Array.isArray(ctx.rows) ? ctx.rows : [];
+  let 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 {
+    const result = engine2.render(processedText, ctx);
+    return result;
+  } catch {
+    return text;
+  }
+}
+
+// src/designer/utils/binding.ts
+function createFieldElement(field) {
+  return createRuntimeElement("text", {
+    formatter: `{${field.fieldKey}}`,
+    title: field.fieldLabel
+  });
+}
+function resolveTextBinding(options, data) {
+  if (options.formatter) {
+    if (!data || data.length === 0) return "";
+    const row = data[0];
+    try {
+      return engine2.render(options.formatter, row ?? {});
+    } catch {
+      return options.formatter;
+    }
+  }
+  return "";
+}
+function lookupDemoPath(path) {
+  let cur = DEFAULT_DEMO_DATA;
+  for (const seg of path.split(".")) {
+    if (cur == null) return void 0;
+    cur = Array.isArray(cur) ? cur[0]?.[seg] : cur[seg];
+  }
+  return cur;
+}
+function resolveBarcodeDesignValue(formatter, listSource) {
+  const first = listSource?.[0];
+  const resolved = (formatter ?? "").replace(/\{([^{}]+)\}/g, (_, expr) => {
+    const key = expr.trim();
+    const v = key.includes(".") ? lookupDemoPath(key) : first?.[key] ?? lookupDemoPath(key);
+    return v == null ? "" : String(v);
+  }).trim();
+  return resolved || "1234567890128";
+}
+
+// src/designer/interactions/adsorb.ts
+var SNAP_COLORS = {
+  left: "#3b82f6",
+  center: "#10b981",
+  right: "#f59e0b",
+  top: "#3b82f6",
+  middle: "#10b981",
+  bottom: "#f59e0b"
+};
+function snapColor(mk) {
+  if (mk === "vCenter") return SNAP_COLORS.center;
+  if (mk === "hCenter") return SNAP_COLORS.middle;
+  return SNAP_COLORS[mk] ?? SNAP_COLORS.left;
+}
+function computeAdsorb(movingRect, others, manualGuides, config = {}) {
+  const adsorbMin = config.adsorbMin ?? 1;
+  const adsorbLineMin = config.adsorbLineMin ?? 2;
+  const showAdsorbLine = config.showAdsorbLine ?? true;
+  let left = movingRect.left;
+  let top = movingRect.top;
+  const lines = [];
+  const m = {
+    left: movingRect.left,
+    right: movingRect.left + movingRect.width,
+    vCenter: movingRect.left + movingRect.width / 2,
+    top: movingRect.top,
+    bottom: movingRect.top + movingRect.height,
+    hCenter: movingRect.top + movingRect.height / 2
+  };
+  let minDist = Infinity;
+  for (const other of others) {
+    if (other.id === movingRect.id) continue;
+    const o = {
+      left: other.left,
+      right: other.left + other.width,
+      vCenter: other.left + other.width / 2,
+      top: other.top,
+      bottom: other.top + other.height,
+      hCenter: other.top + other.height / 2
+    };
+    const hPairs = [
+      ["left", "left"],
+      ["left", "vCenter"],
+      ["left", "right"],
+      ["vCenter", "left"],
+      ["vCenter", "vCenter"],
+      ["vCenter", "right"],
+      ["right", "left"],
+      ["right", "vCenter"],
+      ["right", "right"]
+    ];
+    const vPairs = [
+      ["top", "top"],
+      ["top", "hCenter"],
+      ["top", "bottom"],
+      ["hCenter", "top"],
+      ["hCenter", "hCenter"],
+      ["hCenter", "bottom"],
+      ["bottom", "top"],
+      ["bottom", "hCenter"],
+      ["bottom", "bottom"]
+    ];
+    for (const [mk, ok] of hPairs) {
+      const dist = Math.abs(m[mk] - o[ok]);
+      if (dist <= adsorbMin && dist < minDist) {
+        minDist = dist;
+        left = movingRect.left + (o[ok] - m[mk]);
+      }
+    }
+    for (const [mk, ok] of vPairs) {
+      const dist = Math.abs(m[mk] - o[ok]);
+      if (dist <= adsorbMin && dist < minDist) {
+        minDist = dist;
+        top = movingRect.top + (o[ok] - m[mk]);
+      }
+    }
+  }
+  if (manualGuides) {
+    const m2 = {
+      left,
+      right: left + movingRect.width,
+      vCenter: left + movingRect.width / 2,
+      top,
+      bottom: top + movingRect.height,
+      hCenter: top + movingRect.height / 2
+    };
+    const hKeys = ["left", "vCenter", "right"];
+    for (const pos of manualGuides.vertical) {
+      for (const k of hKeys) {
+        const d = Math.abs(m2[k] - pos);
+        if (d <= adsorbMin && d < minDist) {
+          minDist = d;
+          left = movingRect.left + (pos - m2[k]);
+        }
+      }
+    }
+    const vKeys = ["top", "hCenter", "bottom"];
+    for (const pos of manualGuides.horizontal) {
+      for (const k of vKeys) {
+        const d = Math.abs(m2[k] - pos);
+        if (d <= adsorbMin && d < minDist) {
+          minDist = d;
+          top = movingRect.top + (pos - m2[k]);
+        }
+      }
+    }
+  }
+  const adjustedM = {
+    left,
+    right: left + movingRect.width,
+    vCenter: left + movingRect.width / 2,
+    top,
+    bottom: top + movingRect.height,
+    hCenter: top + movingRect.height / 2
+  };
+  if (showAdsorbLine) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const other of others) {
+      if (other.id === movingRect.id) continue;
+      const o = {
+        left: other.left,
+        right: other.left + other.width,
+        vCenter: other.left + other.width / 2,
+        top: other.top,
+        bottom: other.top + other.height,
+        hCenter: other.top + other.height / 2
+      };
+      const hPairs = [
+        ["left", "left"],
+        ["left", "vCenter"],
+        ["left", "right"],
+        ["vCenter", "left"],
+        ["vCenter", "vCenter"],
+        ["vCenter", "right"],
+        ["right", "left"],
+        ["right", "vCenter"],
+        ["right", "right"]
+      ];
+      const vPairs = [
+        ["top", "top"],
+        ["top", "hCenter"],
+        ["top", "bottom"],
+        ["hCenter", "top"],
+        ["hCenter", "hCenter"],
+        ["hCenter", "bottom"],
+        ["bottom", "top"],
+        ["bottom", "hCenter"],
+        ["bottom", "bottom"]
+      ];
+      for (const [mk, ok] of hPairs) {
+        const dist = Math.abs(adjustedM[mk] - o[ok]);
+        if (dist <= adsorbLineMin) {
+          const key = `v:${o[ok]}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            lines.push({ type: "vertical", position: o[ok], id: other.id, color: snapColor(mk) });
+          }
+        }
+      }
+      for (const [mk, ok] of vPairs) {
+        const dist = Math.abs(adjustedM[mk] - o[ok]);
+        if (dist <= adsorbLineMin) {
+          const key = `h:${o[ok]}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            lines.push({ type: "horizontal", position: o[ok], id: other.id, color: snapColor(mk) });
+          }
+        }
+      }
+    }
+  }
+  if (manualGuides) {
+    for (const pos of manualGuides.vertical) {
+      if (!lines.some((l) => l.type === "vertical" && l.position === pos)) {
+        lines.push({ type: "vertical", position: pos });
+      }
+    }
+    for (const pos of manualGuides.horizontal) {
+      if (!lines.some((l) => l.type === "horizontal" && l.position === pos)) {
+        lines.push({ type: "horizontal", position: pos });
+      }
+    }
+  }
+  return { left, top, lines };
+}
+
+// src/designer/interactions/useAlign.ts
+function useAlign() {
+  function align(elements, mode) {
+    if (elements.length < 2) return;
+    const bounds = {
+      minLeft: Math.min(...elements.map((e) => e.options.left)),
+      maxRight: Math.max(...elements.map((e) => e.options.left + e.options.width)),
+      minTop: Math.min(...elements.map((e) => e.options.top)),
+      maxBottom: Math.max(...elements.map((e) => e.options.top + e.options.height))
+    };
+    switch (mode) {
+      case "left":
+        elements.forEach((e) => {
+          e.options.left = bounds.minLeft;
+        });
+        break;
+      case "right":
+        elements.forEach((e) => {
+          e.options.left = bounds.maxRight - e.options.width;
+        });
+        break;
+      case "top":
+        elements.forEach((e) => {
+          e.options.top = bounds.minTop;
+        });
+        break;
+      case "bottom":
+        elements.forEach((e) => {
+          e.options.top = bounds.maxBottom - e.options.height;
+        });
+        break;
+      case "vertical": {
+        const centerX = bounds.minLeft + (bounds.maxRight - bounds.minLeft) / 2;
+        elements.forEach((e) => {
+          e.options.left = centerX - e.options.width / 2;
+        });
+        break;
+      }
+      case "horizontal": {
+        const centerY = bounds.minTop + (bounds.maxBottom - bounds.minTop) / 2;
+        elements.forEach((e) => {
+          e.options.top = centerY - e.options.height / 2;
+        });
+        break;
+      }
+      case "distributeHor": {
+        const sorted = [...elements].sort((a, b) => a.options.left - b.options.left);
+        const totalW = sorted.reduce((s, e) => s + e.options.width, 0);
+        const gap = (bounds.maxRight - bounds.minLeft - totalW) / (sorted.length - 1);
+        let x = bounds.minLeft;
+        sorted.forEach((e) => {
+          e.options.left = x;
+          x += e.options.width + gap;
+        });
+        break;
+      }
+      case "distributeVer": {
+        const sorted = [...elements].sort((a, b) => a.options.top - b.options.top);
+        const totalH = sorted.reduce((s, e) => s + e.options.height, 0);
+        const gap = (bounds.maxBottom - bounds.minTop - totalH) / (sorted.length - 1);
+        let y = bounds.minTop;
+        sorted.forEach((e) => {
+          e.options.top = y;
+          y += e.options.height + gap;
+        });
+        break;
+      }
+    }
+  }
+  return { align };
+}
+
+// src/designer/interactions/useGroup.ts
+function generateGroupId() {
+  return `grp-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+}
+function useGroup() {
+  function group(elements, selectedIds) {
+    const selected = elements.filter((e) => selectedIds.has(e.id));
+    if (selected.length < 2) return elements;
+    const groupId = generateGroupId();
+    return elements.map(
+      (e) => selectedIds.has(e.id) ? { ...e, options: { ...e.options, groupId } } : e
+    );
+  }
+  function ungroup(elements, selectedIds) {
+    const selected = elements.filter((e) => selectedIds.has(e.id));
+    const groupIds = new Set(selected.map((e) => e.options.groupId).filter(Boolean));
+    return elements.map(
+      (e) => e.options.groupId && groupIds.has(e.options.groupId) ? { ...e, options: { ...e.options, groupId: void 0 } } : e
+    );
+  }
+  function getGroupedIds(elements, selectedId) {
+    const el = elements.find((e) => e.id === selectedId);
+    if (!el?.options.groupId) return /* @__PURE__ */ new Set([selectedId]);
+    const ids = /* @__PURE__ */ new Set();
+    for (const e of elements) {
+      if (e.options.groupId === el.options.groupId) {
+        ids.add(e.id);
+      }
+    }
+    return ids;
+  }
+  return { group, ungroup, getGroupedIds };
+}
+
+// src/designer/interactions/useKeyboard.ts
+var STEP = 1;
+var STEP_LARGE = 10;
+var STEP_SMALL = 0.5;
+function useKeyboard(handlers) {
+  function onKeyDown(e) {
+    const tag = e.target.tagName;
+    if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return;
+    const ctrl = e.ctrlKey || e.metaKey;
+    if (e.key.startsWith("Arrow")) {
+      e.preventDefault();
+      const step = e.shiftKey ? STEP_LARGE : e.ctrlKey ? STEP_SMALL : STEP;
+      const dx = e.key === "ArrowLeft" ? -step : e.key === "ArrowRight" ? step : 0;
+      const dy = e.key === "ArrowUp" ? -step : e.key === "ArrowDown" ? step : 0;
+      handlers.onMove?.(dx, dy);
+      return;
+    }
+    if (e.key === "Delete" || e.key === "Backspace") {
+      e.preventDefault();
+      handlers.onDelete?.();
+      return;
+    }
+    if (ctrl) {
+      const k = e.key.toLowerCase();
+      if (k === "c") {
+        e.preventDefault();
+        handlers.onCopy?.();
+      } else if (k === "v") {
+        e.preventDefault();
+        handlers.onPaste?.();
+      } else if (k === "a") {
+        e.preventDefault();
+        handlers.onSelectAll?.();
+      } else if (k === "d") {
+        e.preventDefault();
+        handlers.onDuplicate?.();
+      } else if (k === "z") {
+        e.preventDefault();
+        e.shiftKey ? handlers.onRedo?.() : handlers.onUndo?.();
+      } else if (k === "y") {
+        e.preventDefault();
+        handlers.onRedo?.();
+      } else if (k === "1") {
+        e.preventDefault();
+        handlers.onResetZoom?.();
+      } else if (k === "l") {
+        e.preventDefault();
+        handlers.onAlignLeft?.();
+      } else if (k === "r") {
+        e.preventDefault();
+        handlers.onAlignRight?.();
+      } else if (k === "e") {
+        e.preventDefault();
+        handlers.onAlignCenterH?.();
+      } else if (k === "t") {
+        e.preventDefault();
+        handlers.onAlignTop?.();
+      } else if (k === "b") {
+        e.preventDefault();
+        handlers.onAlignBottom?.();
+      } else if (k === "g") {
+        e.preventDefault();
+        e.shiftKey ? handlers.onUngroup?.() : handlers.onGroup?.();
+      }
+    }
+  }
+  function setup() {
+    document.addEventListener("keydown", onKeyDown);
+  }
+  function cleanup() {
+    document.removeEventListener("keydown", onKeyDown);
+  }
+  return { setup, cleanup };
+}
+
+// src/designer/interactions/useResize.ts
+var RESIZE_POINTS = ["nw", "n", "ne", "e", "se", "s", "sw", "w"];
+function calcResizeRect(point, startRect, dx, dy, minW, minH) {
+  let { left, top, width, height } = startRect;
+  switch (point) {
+    case "e":
+      width = Math.max(minW, startRect.width + dx);
+      break;
+    case "w":
+      width = Math.max(minW, startRect.width - dx);
+      left = startRect.left + startRect.width - width;
+      break;
+    case "s":
+      height = Math.max(minH, startRect.height + dy);
+      break;
+    case "n":
+      height = Math.max(minH, startRect.height - dy);
+      top = startRect.top + startRect.height - height;
+      break;
+    case "se":
+      width = Math.max(minW, startRect.width + dx);
+      height = Math.max(minH, startRect.height + dy);
+      break;
+    case "sw":
+      width = Math.max(minW, startRect.width - dx);
+      left = startRect.left + startRect.width - width;
+      height = Math.max(minH, startRect.height + dy);
+      break;
+    case "ne":
+      width = Math.max(minW, startRect.width + dx);
+      height = Math.max(minH, startRect.height - dy);
+      top = startRect.top + startRect.height - height;
+      break;
+    case "nw":
+      width = Math.max(minW, startRect.width - dx);
+      left = startRect.left + startRect.width - width;
+      height = Math.max(minH, startRect.height - dy);
+      top = startRect.top + startRect.height - height;
+      break;
+  }
+  return { left, top, width, height };
+}
+function useResize(options) {
+  let startX = 0, startY = 0;
+  let startRect = { left: 0, top: 0, width: 0, height: 0 };
+  let activePoint = null;
+  function startResize(point, e) {
+    activePoint = point;
+    startX = e.clientX;
+    startY = e.clientY;
+    startRect = { ...options.getRect() };
+    options.onStart?.();
+    document.addEventListener("mousemove", onResizeMove);
+    document.addEventListener("mouseup", onResizeEnd);
+    e.preventDefault();
+  }
+  function onResizeMove(e) {
+    if (!activePoint) {
+      return;
+    }
+    const scale = options.getScale?.() || 1;
+    const dx = (e.clientX - startX) / scale;
+    const dy = (e.clientY - startY) / scale;
+    const minW = options.minWidth || 20;
+    const minH = options.minHeight || 20;
+    options.onResize(calcResizeRect(activePoint, startRect, dx, dy, minW, minH));
+  }
+  function onResizeEnd() {
+    activePoint = null;
+    options.onStop?.();
+    document.removeEventListener("mousemove", onResizeMove);
+    document.removeEventListener("mouseup", onResizeEnd);
+  }
+  function cleanup() {
+    document.removeEventListener("mousemove", onResizeMove);
+    document.removeEventListener("mouseup", onResizeEnd);
+  }
+  return { startResize, cleanup };
+}
+
+// src/designer/interactions/useBindingDisplay.ts
+function getNestedValue(obj, path) {
+  return path.split(".").reduce((current, key) => current?.[key], obj);
+}
+function useBindingDisplay() {
+  function getBindingDisplayState(element) {
+    const formatter = element.options.formatter;
+    const title = element.options.title;
+    if (!formatter) {
+      return {
+        status: "unbound",
+        badge: title || "\u6587\u672C",
+        badgeColor: "#909399",
+        demoPreview: title || "\u6587\u672C"
+      };
+    }
+    const demoData = getDemoData();
+    const fieldMatch = formatter.match(/\{([^}]+)\}/);
+    if (fieldMatch) {
+      const fieldPath = fieldMatch[1];
+      const demoValue = getNestedValue(demoData, fieldPath);
+      return {
+        status: "bound",
+        badge: `fx ${formatter}`,
+        badgeColor: "#409EFF",
+        demoPreview: demoValue != null ? String(demoValue) : formatter
+      };
+    }
+    return {
+      status: "bound",
+      badge: `fx ${formatter}`,
+      badgeColor: "#409EFF",
+      demoPreview: formatter
+    };
+  }
+  return { getBindingDisplayState };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_DEMO_DATA,
+  ELEMENT_BINDING_REGISTRY,
+  EXTENDED_FUNCTIONS,
+  FIT_SCALE_MIN_PERCENT,
+  GHOST_BORDER_CSS,
+  MIN_COL_WIDTH_MM,
+  MIN_SCALE_PERCENT,
+  PAPER_PRESETS,
+  PRESET_COLORS,
+  PROPERTY_REGISTRY,
+  RESIZE_POINTS,
+  RULER_THICKNESS,
+  ZONE_ALLOWED_TYPES,
+  applyBorderPreset,
+  buildRulerTicks,
+  calcResizeRect,
+  canMergeReason,
+  chooseMajorStepMM,
+  clampResizedColumnWidth,
+  clampScalePercent,
+  clampToZone,
+  computeAdsorb,
+  computeFitScale,
+  createCell,
+  createDefaultOptions,
+  createDefaultTable,
+  createFieldElement,
+  createRuntimeElement,
+  deleteCol,
+  deleteRow,
+  engine,
+  evaluateTemplate,
+  filterGroups,
+  finalizeElementZone,
+  findMainCell,
+  generateGroupId,
+  generateId,
+  getDemoData,
+  getElementBindings,
+  getPaperDimensions,
+  getPaperSizeMM,
+  getSpanRect,
+  getTableCellBindings,
+  getZoneRects,
+  groupFields,
+  insertCol,
+  insertRow,
+  matchKeywords,
+  mergeCells,
+  minorStepMM,
+  mmToPx,
+  nextWheelScale,
+  normalizeSelection,
+  normalizeTemplateUnits,
+  ptToMm,
+  pxToMm,
+  resolveBarcodeDesignValue,
+  resolveCellBorderCss,
+  resolveTextBinding,
+  safeEval,
+  searchProperties,
+  setRowType,
+  splitCells,
+  syncTableElementSize,
+  useAlign,
+  useBindingDisplay,
+  useGroup,
+  useKeyboard,
+  useResize,
+  zoneFromPaperPoint
+});