@gct-paas/word 0.1.38 → 0.1.41

package/dist/index.es.js

@@ -16765,7 +16765,7 @@ function speedometer(samplesCount, min) {
   let tail = 0;
   let firstSampleTS;
   min = min !== void 0 ? min : 1e3;
-  return function push(chunkLength) {
+  return function push2(chunkLength) {
     const now2 = Date.now();
     const startedAt = timestamps[tail];
     if (!firstSampleTS) {
@@ -18618,7 +18618,7 @@ function setupPlatformAdapters(options) {
   triggerUtil.register({
     handle: triggerHandler
   });
-  plugins?.forEach((plugin) => plugin.install());
+  plugins?.forEach((plugin2) => plugin2.install());
 }
 function setupVueRuntime(options) {
   const { app } = options;
@@ -35239,7 +35239,7 @@ var ResizeObserver$1 = (
     return (_a = observers.get(this))[method4].apply(_a, arguments);
   };
 });
-var index = (function() {
+var index$1 = (function() {
   if (typeof global$1.ResizeObserver !== "undefined") {
     return global$1.ResizeObserver;
   }
@@ -35260,7 +35260,7 @@ function addResizeListener(element, fn) {
   if (isServer) return;
   if (!element.__resizeListeners__) {
     element.__resizeListeners__ = [];
-    element.__ro__ = new index(resizeHandler);
+    element.__ro__ = new index$1(resizeHandler);
     element.__ro__.observe(element);
   }
   element.__resizeListeners__.push(fn);
@@ -40919,6 +40919,22 @@ class LayoutContext {
     this.paragraph?.addChild(run);
     this.layoutRun = run;
   }
+  /** 子表可见行下标 → rawData 存储下标（跳过 deleted_ 行） */
+  mapSubtableVisibleIndex(templatePath, visibleIndex, axis) {
+    if (visibleIndex === void 0) return void 0;
+    const parsed = parseValuePath(templatePath);
+    const dm = this.doc.dataManager;
+    if (axis === "n_y" && parsed.parentFieldPath) {
+      return dm.resolveSubtableVisibleIndex(parsed.parentFieldPath, visibleIndex);
+    }
+    if (axis === "n_x" && parsed.linkFieldPath) {
+      return dm.resolveSubtableVisibleIndex(parsed.linkFieldPath, visibleIndex);
+    }
+    if (parsed.isSubTable && parsed.parentFieldPath) {
+      return dm.resolveSubtableVisibleIndex(parsed.parentFieldPath, visibleIndex);
+    }
+    return visibleIndex;
+  }
   /**
    * 根据 dataIndex 替换 path 中的 [n] 为实际值
    * @param path 包含 [n] 的路径，如 "$.items[n].name"
@@ -40928,7 +40944,11 @@ class LayoutContext {
     if (!path2) return void 0;
     const { type: type4, dataIndex, xDataIndex, yDataIndex, cellZone } = this.cell?.subRenderer || {};
     if (isLinkSubTableType(type4) && cellZone === "cross") {
-      return replacePathIndexPlaceholders({ x: xDataIndex, y: yDataIndex, templatePath: path2 });
+      return replacePathIndexPlaceholders({
+        x: this.mapSubtableVisibleIndex(path2, xDataIndex, "n_x"),
+        y: this.mapSubtableVisibleIndex(path2, yDataIndex, "n_y"),
+        templatePath: path2
+      });
     }
     if (!path2.includes("[n]")) {
       return path2;
@@ -40936,6 +40956,10 @@ class LayoutContext {
     let n = dataIndex;
     if (isLinkSubTableType(type4)) {
       n = cellZone === "horizontal" ? yDataIndex : xDataIndex;
+      const axis = cellZone === "horizontal" ? "n_y" : "n_x";
+      n = this.mapSubtableVisibleIndex(path2, n, axis);
+    } else {
+      n = this.mapSubtableVisibleIndex(path2, n, "n");
     }
     if (n === void 0) return path2;
     return replacePathIndexPlaceholder(n, path2);
@@ -42166,8 +42190,12 @@ function walkOoxmlElementTree(node, visit) {
 function resolveItemCountByRegionId(runtimeJson, infos) {
   const regions = listCheckTableRegionsInRuntimeJson(runtimeJson);
   if (regions.length === 0) return {};
-  const count = infos.data?.length ?? 0;
-  return { [regions[0].regionId]: count };
+  const apiCount = infos.data?.length ?? 0;
+  const itemCountByRegionId = {};
+  for (const region of regions) {
+    itemCountByRegionId[region.regionId] = Math.max(apiCount, 1);
+  }
+  return itemCountByRegionId;
 }
 function mergeCheckTableItemInfosIntoDefaults(defaultsMap, runtimeJson, infos, options) {
   const regions = listCheckTableRegionsInRuntimeJson(runtimeJson);
@@ -42246,14 +42274,14 @@ const basicAttrs = {
   required: [
     {
       from: "required_",
-      to: "newSpecificConfig.newRequired",
+      to: "required",
       transform: (value) => Boolean(value)
-    },
-    {
-      from: "_",
-      to: "newSpecificConfig.newFieldName",
-      transform: () => "值"
     }
+    // {
+    //   from: '_',
+    //   to: 'newSpecificConfig.newFieldName',
+    //   transform: () => '值',
+    // },
   ],
   placeholder: [{ from: "tip_text_", to: "placeholder" }],
   showType: [
@@ -42366,7 +42394,7 @@ const DYN_CONFIG_BY_TYPE = {
       },
       {
         from: "digits_",
-        to: "newSpecificConfig.newPrecision",
+        to: "newSpecificConfig.digits",
         transform: (value) => {
           const n = parseInt(String(value), 10);
           return Number.isNaN(n) ? void 0 : n;
@@ -42384,11 +42412,57 @@ const DYN_CONFIG_BY_TYPE = {
       ...basicAttrs.showType,
       {
         from: "_",
-        to: "newSpecificConfig.newOptions",
-        transform: (_v, _t2, row) => [
-          { label: row.true_text_ || "是", value: true, refFields: [], _item: {} },
-          { label: row.false_text_ || "否", value: false, refFields: [], _item: {} }
-        ]
+        to: "optionsJson",
+        transform: (_v, _t2, row) => {
+          const options = [
+            { label: row.true_text_ || "是", value: true, refFields: [], _item: {} },
+            { label: row.false_text_ || "否", value: false, refFields: [], _item: {} }
+          ];
+          const json = JSON.stringify(options);
+          return json;
+        }
+      },
+      {
+        from: "_",
+        to: "computedOptions",
+        transform: (_v, _t2, row) => {
+          const options = [
+            { label: row.true_text_ || "是", value: true, refFields: [], _item: {} },
+            { label: row.false_text_ || "否", value: false, refFields: [], _item: {} }
+          ];
+          const json = JSON.stringify(options);
+          return json;
+        }
+      },
+      {
+        from: "_",
+        to: "iconLabelSpace",
+        transform: () => 8
+      },
+      {
+        from: "_",
+        to: "labelPosition",
+        transform: () => "after"
+      },
+      {
+        from: "_",
+        to: "direction",
+        transform: () => "landscape"
+      },
+      {
+        from: "_",
+        to: "controlSize",
+        transform: () => 24
+      },
+      {
+        from: "_",
+        to: "controlEnumSpace",
+        transform: () => 16
+      },
+      {
+        from: "_",
+        to: "showMode",
+        transform: () => "both"
       },
       { from: "validate_true_", to: "validateTrue" },
       { from: "validate_false_", to: "validateFalse" }
@@ -42494,12 +42568,6 @@ function buildPropsFromRow(row, config, baseProps = {}) {
     const val = rowDef.transform ? rowDef.transform(raw, config.fieldType, row, baseProps) : raw;
     if (val !== void 0) set(patch, rowDef.to, val);
   }
-  const options = get(patch, "newSpecificConfig.newOptions");
-  if (Array.isArray(options) && options.length > 0) {
-    const json = JSON.stringify(options);
-    patch.computedOptions = json;
-    patch.optionsJson = json;
-  }
   return patch;
 }
 function resolveFwType(fieldType, props) {
@@ -43770,7 +43838,8 @@ class TableExpander {
   /** 编辑模式只展开一份；预览/填报模式按数据路径长度重复 */
   getRepeatCount(region) {
     if (this.doc.mode === DocModeTypeConst.Edit) return 1;
-    return this.data.get(region.subValuePath || region.valuePath)?.length || 1;
+    const path2 = region.subValuePath || region.valuePath;
+    return this.data.countActiveSubtableRows(path2) || 1;
   }
   // ─── 循环子表 / 二维子表（纵向重复）────────────────────────
   initializeRepeatingRowsInRange(region) {
@@ -44020,8 +44089,8 @@ class TableExpander {
     if (this.doc.mode === DocModeTypeConst.Edit) return 1;
     const path2 = region.subValuePath || region.valuePath;
     if (path2) {
-      const data = this.data.get(path2);
-      if (Array.isArray(data) && data.length > 0) return data.length;
+      const activeCount = this.data.countActiveSubtableRows(path2);
+      if (activeCount > 0) return activeCount;
     }
     return Math.max(1, region.end.row - region.start.row + 1);
   }
@@ -46861,6 +46930,61 @@ class PostChangePipeline {
     }
   }
 }
+function hasRowId(row) {
+  const id = row.id_ ?? row.id;
+  return id !== void 0 && id !== null && String(id).trim() !== "";
+}
+function hasPersistedCrossCell(rawData, tableKey, axis, row) {
+  const uid = axis === "y" ? row.__gw_y_uid : row.__gw_x_uid;
+  if (!uid) return false;
+  const uidField = axis === "y" ? "__gw_y_uid" : "__gw_x_uid";
+  for (const crossKey of Object.keys(rawData)) {
+    if (!crossKey.includes(":")) continue;
+    const [yKey, xKey] = crossKey.split(":");
+    const onThisAxis = axis === "y" ? yKey === tableKey : xKey === tableKey;
+    if (!onThisAxis) continue;
+    const crossRows = rawData[crossKey];
+    if (!Array.isArray(crossRows)) continue;
+    if (crossRows.some((cell) => cell?.[uidField] === uid && hasRowId(cell))) {
+      return true;
+    }
+  }
+  return false;
+}
+function isPersistedSubtableRow(row, ctx) {
+  if (!row || typeof row !== "object") return false;
+  if (hasRowId(row)) return true;
+  if (ctx?.rawData && ctx.tableKey && ctx.axis) {
+    return hasPersistedCrossCell(ctx.rawData, ctx.tableKey, ctx.axis, row);
+  }
+  return false;
+}
+function countActiveSubtableRows(rows) {
+  if (!Array.isArray(rows)) return 0;
+  return rows.filter((row) => !row?.deleted_).length;
+}
+function resolveSubtableStorageIndex(rows, visibleIndex) {
+  if (!Array.isArray(rows) || visibleIndex < 0) return visibleIndex;
+  let seen = -1;
+  for (let i = 0; i < rows.length; i++) {
+    if (!rows[i]?.deleted_) {
+      seen++;
+      if (seen === visibleIndex) return i;
+    }
+  }
+  return visibleIndex;
+}
+function resolveSubtableInsertIndex(rows, visibleIndex) {
+  if (!Array.isArray(rows)) return 0;
+  let seen = -1;
+  for (let i = 0; i < rows.length; i++) {
+    if (!rows[i]?.deleted_) {
+      seen++;
+      if (seen === visibleIndex) return i;
+    }
+  }
+  return rows.length;
+}
 const DEFAULT_EMPTY_ITEM = Object.freeze({ __gw_default: true });
 class DataManager {
   doc;
@@ -46947,6 +47071,17 @@ class DataManager {
   getLabel(path2) {
     return this.get(this.getLabelPath(path2)) || this.get(path2);
   }
+  /** 子表数组路径下未软删行数 */
+  countActiveSubtableRows(arrayPath) {
+    const rows = this.getByPath(this.rawData, arrayPath);
+    return countActiveSubtableRows(rows);
+  }
+  /** 版面可见行下标 → rawData 数组实际下标 */
+  resolveSubtableVisibleIndex(arrayPath, visibleIndex) {
+    const rows = this.getByPath(this.rawData, arrayPath);
+    if (!Array.isArray(rows)) return visibleIndex;
+    return resolveSubtableStorageIndex(rows, visibleIndex);
+  }
   assignField(target, fieldPath, value) {
     if (!fieldPath.includes(".") && !fieldPath.includes("[")) {
       target[fieldPath] = value;
@@ -47348,7 +47483,8 @@ class DataManager {
         arr = [{ ...DEFAULT_EMPTY_ITEM }];
         this.set(path2, arr);
       }
-      if (index2 < 0 || index2 > arr.length) {
+      const storageIndex = resolveSubtableInsertIndex(arr, index2);
+      if (storageIndex < 0 || storageIndex > arr.length) {
         throw new Error(`Index ${index2} out of bounds for array of length ${arr.length}`);
       }
       const oldValue = [...arr];
@@ -47357,9 +47493,9 @@ class DataManager {
       const clonedValues = values.map(
         (value) => axisInfo ? this.prepareAxisRowForInsert(arr, axisInfo, value) : this.deepClone(value)
       );
-      arr.splice(index2, 0, ...clonedValues);
+      arr.splice(storageIndex, 0, ...clonedValues);
       if (axisInfo) {
-        for (let i = index2; i < arr.length; i++) {
+        for (let i = storageIndex; i < arr.length; i++) {
           this.ensureAxisRowAndUid(tableKey, i, axisInfo.axis);
         }
       }
@@ -47382,14 +47518,26 @@ class DataManager {
       if (!Array.isArray(arr)) {
         throw new Error(`Path "${path2}" is not an array`);
       }
-      if (index2 < 0 || index2 >= arr.length) {
+      const storageIndex = resolveSubtableStorageIndex(arr, index2);
+      if (storageIndex < 0 || storageIndex >= arr.length) {
         throw new Error(`Index ${index2} out of bounds for array of length ${arr.length}`);
       }
-      const oldValue = [...arr];
-      const removedValue = arr.splice(index2, 1)[0];
-      this.emit(path2, arr, oldValue);
       const tableKey = path2.replace(/^\$\./, "").replace(/\[(n|\d+)\]/g, "");
       const axisInfo = this.resolveAxisByTableKey(tableKey);
+      const row = arr[storageIndex];
+      if (isPersistedSubtableRow(row, {
+        rawData: this.rawData,
+        tableKey,
+        axis: axisInfo?.axis
+      })) {
+        const oldValue2 = this.deepClone(arr);
+        row.deleted_ = true;
+        this.emit(path2, arr, oldValue2);
+        return row;
+      }
+      const oldValue = [...arr];
+      const removedValue = arr.splice(storageIndex, 1)[0];
+      this.emit(path2, arr, oldValue);
       if (axisInfo) {
         const uidField = axisInfo.axis === "y" ? "__gw_y_uid" : "__gw_x_uid";
         this.cleanupCrossByAxisUid(tableKey, axisInfo.axis, removedValue?.[uidField]);
@@ -47470,6 +47618,52 @@ class DataManager {
         }
       }
     }
+    this.syncSubTableRowsToLayout();
+  }
+  /**
+   * 补齐二维/检验表的关联轴子表（如 f_ewblink / f_jianyan2）到动态关联铺砖槽位数。
+   * 不处理主体轴（如 f_ewb / f_jianyan1），避免覆盖接口行或误扩纵向轴。
+   */
+  syncSubTableRowsToLayout() {
+    const listSubTables = this.doc?.model?.getSubTableInfoList;
+    if (typeof listSubTables !== "function") return;
+    for (const info of listSubTables.call(this.doc?.model)) {
+      if (!info.field || !["check-table-2d-link", "sub-table-2d-link"].includes(info.subType)) {
+        continue;
+      }
+      const linkFieldKey = info.field;
+      const layoutRows = this.doc?.model?.getSubTableLayoutSlotCount(linkFieldKey) ?? 0;
+      if (layoutRows <= 0) continue;
+      const dataRows = this.countSubTableDataRows(linkFieldKey);
+      const targetRows = Math.max(dataRows, layoutRows);
+      if (targetRows <= dataRows) continue;
+      this.ensureCheckTableLinkLayoutRows(linkFieldKey, targetRows);
+    }
+  }
+  /** 子表在 rawData 中的行数（支持尚未转成数组的 { data: [] } 接口形态，此时返回 0 且不在此阶段强转） */
+  countSubTableDataRows(subTableKey) {
+    const existing = this.rawData?.[subTableKey];
+    if (Array.isArray(existing)) return existing.length;
+    if (existing?.data && Array.isArray(existing.data)) return existing.data.length;
+    return 0;
+  }
+  /**
+   * 为检验表关联轴补足铺砖行：占位标记 + __gw_x_uid（与 push/insert 行为一致）。
+   */
+  ensureCheckTableLinkLayoutRows(linkFieldKey, rowCount) {
+    const raw = this.rawData?.[linkFieldKey];
+    if (raw != null && !Array.isArray(raw)) {
+      return;
+    }
+    let arr = raw;
+    if (!Array.isArray(arr)) {
+      arr = [];
+      this.rawData[linkFieldKey] = arr;
+    }
+    for (let i = arr.length; i < rowCount; i++) {
+      arr.push({ ...DEFAULT_EMPTY_ITEM });
+      this.ensureAxisRowAndUid(linkFieldKey, i, "x");
+    }
   }
   applyInitDataCrossWildcard(path2, value) {
     const parse = parseValuePath(path2);
@@ -47512,8 +47706,7 @@ class DataManager {
    * layoutRows 为 0（如二维表纵向 f_ewb）时不按分组扩行，仅保证至少 1 行可绑定。
    */
   resolveInitRowCount(subTableKey) {
-    const existing = this.rawData?.[subTableKey];
-    const dataRows = Array.isArray(existing) ? existing.length : 0;
+    const dataRows = this.countSubTableDataRows(subTableKey);
     const layoutRows = this.doc?.model?.getSubTableLayoutSlotCount(subTableKey) ?? 1;
     if (layoutRows > 0) {
       return Math.max(dataRows, layoutRows);
@@ -47525,7 +47718,11 @@ class DataManager {
    * @param asPlaceholder true：push/insert 用的系统占位行（带 __gw_default）；false：applyInitData 物化行（空对象）
    */
   ensureSubTableRowCount(subTableKey, rowCount, asPlaceholder = true) {
-    let arr = this.rawData?.[subTableKey];
+    const raw = this.rawData?.[subTableKey];
+    if (raw != null && !Array.isArray(raw)) {
+      return [];
+    }
+    let arr = raw;
     if (!Array.isArray(arr)) {
       arr = [];
       this.rawData[subTableKey] = arr;
@@ -50108,13 +50305,15 @@ class DocModel {
       };
     });
     const table2DRegions = tables.filter((w2) => w2.has2DTable).flatMap((w2) => w2._2DTable).map((item) => {
+      const crossKey = item.subFieldKey && item.linkFieldKey ? `${item.subFieldKey}:${item.linkFieldKey}` : void 0;
       const result = [];
       if (item.subFieldKey) {
         result.push({
           field: item.subFieldKey,
           key: "dyn",
           name: "二维表",
-          subType: "sub-table-2d"
+          subType: "sub-table-2d",
+          crossKey
         });
       }
       if (item.linkFieldKey) {
@@ -50122,19 +50321,22 @@ class DocModel {
           field: item.linkFieldKey,
           key: "newfixed",
           name: "二维表-关联",
-          subType: "sub-table-2d-link"
+          subType: "sub-table-2d-link",
+          crossKey
         });
       }
       return result;
     }).flat();
     const checkTableRegions = tables.filter((w2) => w2.hasCheckTable).flatMap((w2) => w2.checkTable).map((item) => {
+      const crossKey = item.subFieldKey && item.linkFieldKey ? `${item.subFieldKey}:${item.linkFieldKey}` : void 0;
       const result = [];
       if (item.subFieldKey) {
         result.push({
           field: item.subFieldKey,
           key: "newfixed",
           name: "检验表-动态",
-          subType: "check-table-2d"
+          subType: "check-table-2d",
+          crossKey
         });
       }
       if (item.linkFieldKey) {
@@ -50142,7 +50344,8 @@ class DocModel {
           field: item.linkFieldKey,
           key: "newfixed",
           name: "检验表-关联",
-          subType: "check-table-2d-link"
+          subType: "check-table-2d-link",
+          crossKey
         });
       }
       return result;
@@ -50153,8 +50356,8 @@ class DocModel {
    * 根据版面数据分组 / 动态关联铺砖，计算子表字段在 rawData 中应初始化的行数。
    *
    * - 固定表：槽位归 subFieldKey（bounded + itemRegion）
-   * - 二维表 / 检验表：动态分组铺砖在关联轴，槽位归 linkFieldKey（如 f_ewblink）；
-   *   纵向 subFieldKey（如 f_ewb）不由 itemRegion 撑行，返回 0
+   * - 二维表 / 检验表：动态分组铺砖槽位归 linkFieldKey（如 f_jianyan2）；
+   *   纵向 subFieldKey（如 f_jianyan1）由检验项条数撑行，返回 0
    * - 其它子表无分组：返回 1
    */
   getSubTableLayoutSlotCount(subFieldKey) {
@@ -50166,15 +50369,14 @@ class DocModel {
         if (region.subFieldKey !== subFieldKey || !region.itemRegion) continue;
         const fillDirection = region.widgetMeta?.props?.fillDirection ?? "x";
         max = Math.max(max, countDataGroupSlots(region, region.itemRegion, fillDirection));
-        region.type;
       }
       for (const region of [...table.checkTable, ...table._2DTable]) {
         if (!region.itemRegion) continue;
         const range3 = expandDataGroupRowRange(region, region.itemRegion);
-        const slots = countDataGroupSlots(range3, region.itemRegion);
+        const fillDirection = region.widgetMeta?.props?.fillDirection ?? "x";
+        const slots = countDataGroupSlots(range3, region.itemRegion, fillDirection);
         if (region.linkFieldKey === subFieldKey) {
           max = Math.max(max, slots);
-          region.type;
         }
         if (region.subFieldKey === subFieldKey) {
           isLinkSubTableSubAxisOnly = true;
@@ -51581,63 +51783,48 @@ function transformSourceDataList(data, dict = {}) {
   return list || [];
 }
 function conversionFormState(payload) {
-  const { interfaceData, masterSlaveList, instances } = payload || {};
+  const { interfaceData, masterSlaveList, subTableInfoList } = payload || {};
   const formState = {};
   if (interfaceData && interfaceData.data) {
     merge(formState, transformSourceData(interfaceData.data, interfaceData.dict));
   }
-  let _2dKeys = [];
-  if (instances) {
-    const _2DFieldList = instances.map(({ valuePath }) => {
-      if (valuePath.includes(":")) {
-        const { fieldKey, parentFieldKey, linkFieldKey } = parseValuePath(valuePath);
-        const group2DKey = `${parentFieldKey}:${linkFieldKey}`;
-        return {
-          fieldKey,
-          group2DKey
-        };
-      } else {
-        return null;
-      }
-    }).filter(Boolean);
-    Object.entries(groupBy$1(_2DFieldList, "group2DKey")).forEach(([group2DKey, fields]) => {
-      _2dKeys.push(group2DKey);
-      const [parentFieldKey, linkFieldKey] = group2DKey.split(":");
-      const parentState = formState[parentFieldKey];
-      const keys2 = ["id_", "group_", ...fields.map((f) => f.fieldKey)];
-      formState[linkFieldKey]?.data.forEach((row) => {
-        row.__gw_x_uid = row.group_;
-      });
-      formState[group2DKey] = {
-        data: parentState?.data.map((row) => {
-          const { group_: g_ } = row;
-          const _row = pick(row, keys2);
-          if (g_) {
-            const [y2, x2] = g_.split(":");
-            _row.__gw_y_uid = y2;
-            _row.__gw_x_uid = x2;
-          }
-          return _row;
-        }) || [],
-        dict: parentState?.dict || []
-      };
-      const addedYUids = [];
-      formState[parentFieldKey] = {
-        data: [],
-        dict: formState[parentFieldKey]?.dict || []
-      };
-      parentState?.data.forEach((row) => {
-        const yUid = row.group_.split(":")[0];
-        if (addedYUids.includes(yUid)) return;
-        addedYUids.push(yUid);
-        formState[parentFieldKey].data.push({
-          ...row,
-          __gw_y_uid: yUid
-        });
+  const crossKeyList = Array.from(new Set(subTableInfoList.map((o) => o.crossKey).filter(Boolean)));
+  crossKeyList.forEach((crossKey) => {
+    const [parentFieldKey, linkFieldKey] = crossKey.split(":");
+    const parentState = formState[parentFieldKey];
+    formState[linkFieldKey]?.data.forEach((row) => {
+      row.__gw_x_uid = row.group_;
+    });
+    formState[crossKey] = {
+      data: parentState?.data.map((row) => {
+        const { group_ } = row;
+        const _row = { ...row };
+        if (group_) {
+          const [yid, xid] = group_.split(":");
+          _row.__gw_y_uid = yid;
+          _row.__gw_x_uid = xid;
+        }
+        return _row;
+      }) || [],
+      dict: parentState?.dict || []
+    };
+    const addedYids = [];
+    formState[parentFieldKey] = {
+      data: [],
+      dict: formState[parentFieldKey]?.dict || []
+    };
+    parentState?.data.forEach((row) => {
+      if (!row.group_?.includes(":")) return;
+      const yid = row.group_.split(":")[0];
+      if (addedYids.includes(yid)) return;
+      addedYids.push(yid);
+      formState[parentFieldKey].data.push({
+        ...row,
+        __gw_y_uid: yid
       });
     });
-  }
-  masterSlaveList.map((item) => item.key).concat(_2dKeys).forEach((k) => {
+  });
+  masterSlaveList.map((item) => item.key).concat(crossKeyList).forEach((k) => {
     const subFormData = formState[k];
     if (subFormData) {
       formState[k] = transformSourceDataList([...subFormData.data], subFormData.dict);
@@ -51645,27 +51832,38 @@ function conversionFormState(payload) {
   });
   return formState;
 }
-function getSubmitFormData(formData) {
+function resolveSubmitCrossKeys(formData, subTableInfoList) {
+  if (subTableInfoList?.length) {
+    const fromModel = [
+      ...new Set(
+        subTableInfoList.map((item) => item.crossKey).filter((key) => typeof key === "string" && key.length > 0)
+      )
+    ];
+    if (fromModel.length) return fromModel;
+  }
+  return Object.keys(formData).filter((k) => k.includes(":"));
+}
+function getSubmitFormData(formData, subTableInfoList) {
   const _formData = { ...formData };
-  Object.keys(_formData).filter((k) => k.includes(":")).forEach((_2DKey) => {
-    const [subKey] = _2DKey.split(":");
-    const _2DData = _formData[_2DKey];
-    const subData = [..._formData[subKey] || []];
-    if ([_2DData, subData].every(Array.isArray)) {
-      _formData[subKey] = [];
-      _2DData.forEach((obj) => {
-        const { __gw_y_uid, __gw_x_uid } = obj;
-        const row = subData.find((row2) => row2.__gw_y_uid === __gw_y_uid);
-        if (!row) return;
+  resolveSubmitCrossKeys(_formData, subTableInfoList).forEach((crossKey) => {
+    const [subKey, linkKey] = crossKey.split(":");
+    const subData = _formData[subKey] || [];
+    const linkData = _formData[linkKey] || [];
+    const crossData = _formData[crossKey] || [];
+    _formData[subKey] = [];
+    subData.forEach((subRow) => {
+      const { __gw_y_uid: yid } = subRow;
+      linkData.forEach((linkRow) => {
+        const { __gw_x_uid: xid } = linkRow;
+        const crossRow = crossData.find((row) => row.__gw_y_uid === yid && row.__gw_x_uid === xid) || {};
         _formData[subKey].push({
-          // 保留动态关联前端键值到 group_
-          group_: `${__gw_y_uid}:${__gw_x_uid}`,
-          ...row,
-          ...omit(obj, FILTER_KEYS)
+          ...subRow,
+          ...omit(crossRow, FILTER_KEYS),
+          group_: `${yid}:${xid}`
         });
       });
-    }
-    delete _formData[_2DKey];
+    });
+    delete _formData[crossKey];
   });
   const realFormData = Object.keys(_formData).reduce((reducedData, fieldKey) => {
     const fieldValue = _formData[fieldKey];
@@ -52445,6 +52643,1750 @@ async function loadDataValuesByAutofillRules(record, ctx, instances, autofillRul
     { needReplacePathIndexPlaceholder: true, sourceValuePath }
   );
 }
+class Hooks {
+  /**
+   * @callback HookCallback
+   * @this {*|Jsep} this
+   * @param {Jsep} env
+   * @returns: void
+   */
+  /**
+   * Adds the given callback to the list of callbacks for the given hook.
+   *
+   * The callback will be invoked when the hook it is registered for is run.
+   *
+   * One callback function can be registered to multiple hooks and the same hook multiple times.
+   *
+   * @param {string|object} name The name of the hook, or an object of callbacks keyed by name
+   * @param {HookCallback|boolean} callback The callback function which is given environment variables.
+   * @param {?boolean} [first=false] Will add the hook to the top of the list (defaults to the bottom)
+   * @public
+   */
+  add(name2, callback, first) {
+    if (typeof arguments[0] != "string") {
+      for (let name3 in arguments[0]) {
+        this.add(name3, arguments[0][name3], arguments[1]);
+      }
+    } else {
+      (Array.isArray(name2) ? name2 : [name2]).forEach(function(name3) {
+        this[name3] = this[name3] || [];
+        if (callback) {
+          this[name3][first ? "unshift" : "push"](callback);
+        }
+      }, this);
+    }
+  }
+  /**
+   * Runs a hook invoking all registered callbacks with the given environment variables.
+   *
+   * Callbacks will be invoked synchronously and in the order in which they were registered.
+   *
+   * @param {string} name The name of the hook.
+   * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
+   * @public
+   */
+  run(name2, env) {
+    this[name2] = this[name2] || [];
+    this[name2].forEach(function(callback) {
+      callback.call(env && env.context ? env.context : env, env);
+    });
+  }
+}
+class Plugins {
+  constructor(jsep2) {
+    this.jsep = jsep2;
+    this.registered = {};
+  }
+  /**
+   * @callback PluginSetup
+   * @this {Jsep} jsep
+   * @returns: void
+   */
+  /**
+   * Adds the given plugin(s) to the registry
+   *
+   * @param {object} plugins
+   * @param {string} plugins.name The name of the plugin
+   * @param {PluginSetup} plugins.init The init function
+   * @public
+   */
+  register() {
+    for (var _len = arguments.length, plugins = new Array(_len), _key = 0; _key < _len; _key++) {
+      plugins[_key] = arguments[_key];
+    }
+    plugins.forEach((plugin2) => {
+      if (typeof plugin2 !== "object" || !plugin2.name || !plugin2.init) {
+        throw new Error("Invalid JSEP plugin format");
+      }
+      if (this.registered[plugin2.name]) {
+        return;
+      }
+      plugin2.init(this.jsep);
+      this.registered[plugin2.name] = plugin2;
+    });
+  }
+}
+class Jsep {
+  /**
+   * @returns {string}
+   */
+  static get version() {
+    return "1.4.0";
+  }
+  /**
+   * @returns {string}
+   */
+  static toString() {
+    return "JavaScript Expression Parser (JSEP) v" + Jsep.version;
+  }
+  // ==================== CONFIG ================================
+  /**
+   * @method addUnaryOp
+   * @param {string} op_name The name of the unary op to add
+   * @returns {Jsep}
+   */
+  static addUnaryOp(op_name) {
+    Jsep.max_unop_len = Math.max(op_name.length, Jsep.max_unop_len);
+    Jsep.unary_ops[op_name] = 1;
+    return Jsep;
+  }
+  /**
+   * @method jsep.addBinaryOp
+   * @param {string} op_name The name of the binary op to add
+   * @param {number} precedence The precedence of the binary op (can be a float). Higher number = higher precedence
+   * @param {boolean} [isRightAssociative=false] whether operator is right-associative
+   * @returns {Jsep}
+   */
+  static addBinaryOp(op_name, precedence, isRightAssociative) {
+    Jsep.max_binop_len = Math.max(op_name.length, Jsep.max_binop_len);
+    Jsep.binary_ops[op_name] = precedence;
+    if (isRightAssociative) {
+      Jsep.right_associative.add(op_name);
+    } else {
+      Jsep.right_associative.delete(op_name);
+    }
+    return Jsep;
+  }
+  /**
+   * @method addIdentifierChar
+   * @param {string} char The additional character to treat as a valid part of an identifier
+   * @returns {Jsep}
+   */
+  static addIdentifierChar(char) {
+    Jsep.additional_identifier_chars.add(char);
+    return Jsep;
+  }
+  /**
+   * @method addLiteral
+   * @param {string} literal_name The name of the literal to add
+   * @param {*} literal_value The value of the literal
+   * @returns {Jsep}
+   */
+  static addLiteral(literal_name, literal_value) {
+    Jsep.literals[literal_name] = literal_value;
+    return Jsep;
+  }
+  /**
+   * @method removeUnaryOp
+   * @param {string} op_name The name of the unary op to remove
+   * @returns {Jsep}
+   */
+  static removeUnaryOp(op_name) {
+    delete Jsep.unary_ops[op_name];
+    if (op_name.length === Jsep.max_unop_len) {
+      Jsep.max_unop_len = Jsep.getMaxKeyLen(Jsep.unary_ops);
+    }
+    return Jsep;
+  }
+  /**
+   * @method removeAllUnaryOps
+   * @returns {Jsep}
+   */
+  static removeAllUnaryOps() {
+    Jsep.unary_ops = {};
+    Jsep.max_unop_len = 0;
+    return Jsep;
+  }
+  /**
+   * @method removeIdentifierChar
+   * @param {string} char The additional character to stop treating as a valid part of an identifier
+   * @returns {Jsep}
+   */
+  static removeIdentifierChar(char) {
+    Jsep.additional_identifier_chars.delete(char);
+    return Jsep;
+  }
+  /**
+   * @method removeBinaryOp
+   * @param {string} op_name The name of the binary op to remove
+   * @returns {Jsep}
+   */
+  static removeBinaryOp(op_name) {
+    delete Jsep.binary_ops[op_name];
+    if (op_name.length === Jsep.max_binop_len) {
+      Jsep.max_binop_len = Jsep.getMaxKeyLen(Jsep.binary_ops);
+    }
+    Jsep.right_associative.delete(op_name);
+    return Jsep;
+  }
+  /**
+   * @method removeAllBinaryOps
+   * @returns {Jsep}
+   */
+  static removeAllBinaryOps() {
+    Jsep.binary_ops = {};
+    Jsep.max_binop_len = 0;
+    return Jsep;
+  }
+  /**
+   * @method removeLiteral
+   * @param {string} literal_name The name of the literal to remove
+   * @returns {Jsep}
+   */
+  static removeLiteral(literal_name) {
+    delete Jsep.literals[literal_name];
+    return Jsep;
+  }
+  /**
+   * @method removeAllLiterals
+   * @returns {Jsep}
+   */
+  static removeAllLiterals() {
+    Jsep.literals = {};
+    return Jsep;
+  }
+  // ==================== END CONFIG ============================
+  /**
+   * @returns {string}
+   */
+  get char() {
+    return this.expr.charAt(this.index);
+  }
+  /**
+   * @returns {number}
+   */
+  get code() {
+    return this.expr.charCodeAt(this.index);
+  }
+  /**
+   * @param {string} expr a string with the passed in express
+   * @returns Jsep
+   */
+  constructor(expr) {
+    this.expr = expr;
+    this.index = 0;
+  }
+  /**
+   * static top-level parser
+   * @returns {jsep.Expression}
+   */
+  static parse(expr) {
+    return new Jsep(expr).parse();
+  }
+  /**
+   * Get the longest key length of any object
+   * @param {object} obj
+   * @returns {number}
+   */
+  static getMaxKeyLen(obj) {
+    return Math.max(0, ...Object.keys(obj).map((k) => k.length));
+  }
+  /**
+   * `ch` is a character code in the next three functions
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isDecimalDigit(ch) {
+    return ch >= 48 && ch <= 57;
+  }
+  /**
+   * Returns the precedence of a binary operator or `0` if it isn't a binary operator. Can be float.
+   * @param {string} op_val
+   * @returns {number}
+   */
+  static binaryPrecedence(op_val) {
+    return Jsep.binary_ops[op_val] || 0;
+  }
+  /**
+   * Looks for start of identifier
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isIdentifierStart(ch) {
+    return ch >= 65 && ch <= 90 || // A...Z
+    ch >= 97 && ch <= 122 || // a...z
+    ch >= 128 && !Jsep.binary_ops[String.fromCharCode(ch)] || // any non-ASCII that is not an operator
+    Jsep.additional_identifier_chars.has(String.fromCharCode(ch));
+  }
+  /**
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isIdentifierPart(ch) {
+    return Jsep.isIdentifierStart(ch) || Jsep.isDecimalDigit(ch);
+  }
+  /**
+   * throw error at index of the expression
+   * @param {string} message
+   * @throws
+   */
+  throwError(message) {
+    const error = new Error(message + " at character " + this.index);
+    error.index = this.index;
+    error.description = message;
+    throw error;
+  }
+  /**
+   * Run a given hook
+   * @param {string} name
+   * @param {jsep.Expression|false} [node]
+   * @returns {?jsep.Expression}
+   */
+  runHook(name2, node) {
+    if (Jsep.hooks[name2]) {
+      const env = {
+        context: this,
+        node
+      };
+      Jsep.hooks.run(name2, env);
+      return env.node;
+    }
+    return node;
+  }
+  /**
+   * Runs a given hook until one returns a node
+   * @param {string} name
+   * @returns {?jsep.Expression}
+   */
+  searchHook(name2) {
+    if (Jsep.hooks[name2]) {
+      const env = {
+        context: this
+      };
+      Jsep.hooks[name2].find(function(callback) {
+        callback.call(env.context, env);
+        return env.node;
+      });
+      return env.node;
+    }
+  }
+  /**
+   * Push `index` up to the next non-space character
+   */
+  gobbleSpaces() {
+    let ch = this.code;
+    while (ch === Jsep.SPACE_CODE || ch === Jsep.TAB_CODE || ch === Jsep.LF_CODE || ch === Jsep.CR_CODE) {
+      ch = this.expr.charCodeAt(++this.index);
+    }
+    this.runHook("gobble-spaces");
+  }
+  /**
+   * Top-level method to parse all expressions and returns compound or single node
+   * @returns {jsep.Expression}
+   */
+  parse() {
+    this.runHook("before-all");
+    const nodes = this.gobbleExpressions();
+    const node = nodes.length === 1 ? nodes[0] : {
+      type: Jsep.COMPOUND,
+      body: nodes
+    };
+    return this.runHook("after-all", node);
+  }
+  /**
+   * top-level parser (but can be reused within as well)
+   * @param {number} [untilICode]
+   * @returns {jsep.Expression[]}
+   */
+  gobbleExpressions(untilICode) {
+    let nodes = [], ch_i, node;
+    while (this.index < this.expr.length) {
+      ch_i = this.code;
+      if (ch_i === Jsep.SEMCOL_CODE || ch_i === Jsep.COMMA_CODE) {
+        this.index++;
+      } else {
+        if (node = this.gobbleExpression()) {
+          nodes.push(node);
+        } else if (this.index < this.expr.length) {
+          if (ch_i === untilICode) {
+            break;
+          }
+          this.throwError('Unexpected "' + this.char + '"');
+        }
+      }
+    }
+    return nodes;
+  }
+  /**
+   * The main parsing function.
+   * @returns {?jsep.Expression}
+   */
+  gobbleExpression() {
+    const node = this.searchHook("gobble-expression") || this.gobbleBinaryExpression();
+    this.gobbleSpaces();
+    return this.runHook("after-expression", node);
+  }
+  /**
+   * Search for the operation portion of the string (e.g. `+`, `===`)
+   * Start by taking the longest possible binary operations (3 characters: `===`, `!==`, `>>>`)
+   * and move down from 3 to 2 to 1 character until a matching binary operation is found
+   * then, return that binary operation
+   * @returns {string|boolean}
+   */
+  gobbleBinaryOp() {
+    this.gobbleSpaces();
+    let to_check = this.expr.substr(this.index, Jsep.max_binop_len);
+    let tc_len = to_check.length;
+    while (tc_len > 0) {
+      if (Jsep.binary_ops.hasOwnProperty(to_check) && (!Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) {
+        this.index += tc_len;
+        return to_check;
+      }
+      to_check = to_check.substr(0, --tc_len);
+    }
+    return false;
+  }
+  /**
+   * This function is responsible for gobbling an individual expression,
+   * e.g. `1`, `1+2`, `a+(b*2)-Math.sqrt(2)`
+   * @returns {?jsep.BinaryExpression}
+   */
+  gobbleBinaryExpression() {
+    let node, biop, prec, stack, biop_info, left, right, i, cur_biop;
+    left = this.gobbleToken();
+    if (!left) {
+      return left;
+    }
+    biop = this.gobbleBinaryOp();
+    if (!biop) {
+      return left;
+    }
+    biop_info = {
+      value: biop,
+      prec: Jsep.binaryPrecedence(biop),
+      right_a: Jsep.right_associative.has(biop)
+    };
+    right = this.gobbleToken();
+    if (!right) {
+      this.throwError("Expected expression after " + biop);
+    }
+    stack = [left, biop_info, right];
+    while (biop = this.gobbleBinaryOp()) {
+      prec = Jsep.binaryPrecedence(biop);
+      if (prec === 0) {
+        this.index -= biop.length;
+        break;
+      }
+      biop_info = {
+        value: biop,
+        prec,
+        right_a: Jsep.right_associative.has(biop)
+      };
+      cur_biop = biop;
+      const comparePrev = (prev) => biop_info.right_a && prev.right_a ? prec > prev.prec : prec <= prev.prec;
+      while (stack.length > 2 && comparePrev(stack[stack.length - 2])) {
+        right = stack.pop();
+        biop = stack.pop().value;
+        left = stack.pop();
+        node = {
+          type: Jsep.BINARY_EXP,
+          operator: biop,
+          left,
+          right
+        };
+        stack.push(node);
+      }
+      node = this.gobbleToken();
+      if (!node) {
+        this.throwError("Expected expression after " + cur_biop);
+      }
+      stack.push(biop_info, node);
+    }
+    i = stack.length - 1;
+    node = stack[i];
+    while (i > 1) {
+      node = {
+        type: Jsep.BINARY_EXP,
+        operator: stack[i - 1].value,
+        left: stack[i - 2],
+        right: node
+      };
+      i -= 2;
+    }
+    return node;
+  }
+  /**
+   * An individual part of a binary expression:
+   * e.g. `foo.bar(baz)`, `1`, `"abc"`, `(a % 2)` (because it's in parenthesis)
+   * @returns {boolean|jsep.Expression}
+   */
+  gobbleToken() {
+    let ch, to_check, tc_len, node;
+    this.gobbleSpaces();
+    node = this.searchHook("gobble-token");
+    if (node) {
+      return this.runHook("after-token", node);
+    }
+    ch = this.code;
+    if (Jsep.isDecimalDigit(ch) || ch === Jsep.PERIOD_CODE) {
+      return this.gobbleNumericLiteral();
+    }
+    if (ch === Jsep.SQUOTE_CODE || ch === Jsep.DQUOTE_CODE) {
+      node = this.gobbleStringLiteral();
+    } else if (ch === Jsep.OBRACK_CODE) {
+      node = this.gobbleArray();
+    } else {
+      to_check = this.expr.substr(this.index, Jsep.max_unop_len);
+      tc_len = to_check.length;
+      while (tc_len > 0) {
+        if (Jsep.unary_ops.hasOwnProperty(to_check) && (!Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) {
+          this.index += tc_len;
+          const argument = this.gobbleToken();
+          if (!argument) {
+            this.throwError("missing unaryOp argument");
+          }
+          return this.runHook("after-token", {
+            type: Jsep.UNARY_EXP,
+            operator: to_check,
+            argument,
+            prefix: true
+          });
+        }
+        to_check = to_check.substr(0, --tc_len);
+      }
+      if (Jsep.isIdentifierStart(ch)) {
+        node = this.gobbleIdentifier();
+        if (Jsep.literals.hasOwnProperty(node.name)) {
+          node = {
+            type: Jsep.LITERAL,
+            value: Jsep.literals[node.name],
+            raw: node.name
+          };
+        } else if (node.name === Jsep.this_str) {
+          node = {
+            type: Jsep.THIS_EXP
+          };
+        }
+      } else if (ch === Jsep.OPAREN_CODE) {
+        node = this.gobbleGroup();
+      }
+    }
+    if (!node) {
+      return this.runHook("after-token", false);
+    }
+    node = this.gobbleTokenProperty(node);
+    return this.runHook("after-token", node);
+  }
+  /**
+   * Gobble properties of of identifiers/strings/arrays/groups.
+   * e.g. `foo`, `bar.baz`, `foo['bar'].baz`
+   * It also gobbles function calls:
+   * e.g. `Math.acos(obj.angle)`
+   * @param {jsep.Expression} node
+   * @returns {jsep.Expression}
+   */
+  gobbleTokenProperty(node) {
+    this.gobbleSpaces();
+    let ch = this.code;
+    while (ch === Jsep.PERIOD_CODE || ch === Jsep.OBRACK_CODE || ch === Jsep.OPAREN_CODE || ch === Jsep.QUMARK_CODE) {
+      let optional;
+      if (ch === Jsep.QUMARK_CODE) {
+        if (this.expr.charCodeAt(this.index + 1) !== Jsep.PERIOD_CODE) {
+          break;
+        }
+        optional = true;
+        this.index += 2;
+        this.gobbleSpaces();
+        ch = this.code;
+      }
+      this.index++;
+      if (ch === Jsep.OBRACK_CODE) {
+        node = {
+          type: Jsep.MEMBER_EXP,
+          computed: true,
+          object: node,
+          property: this.gobbleExpression()
+        };
+        if (!node.property) {
+          this.throwError('Unexpected "' + this.char + '"');
+        }
+        this.gobbleSpaces();
+        ch = this.code;
+        if (ch !== Jsep.CBRACK_CODE) {
+          this.throwError("Unclosed [");
+        }
+        this.index++;
+      } else if (ch === Jsep.OPAREN_CODE) {
+        node = {
+          type: Jsep.CALL_EXP,
+          "arguments": this.gobbleArguments(Jsep.CPAREN_CODE),
+          callee: node
+        };
+      } else if (ch === Jsep.PERIOD_CODE || optional) {
+        if (optional) {
+          this.index--;
+        }
+        this.gobbleSpaces();
+        node = {
+          type: Jsep.MEMBER_EXP,
+          computed: false,
+          object: node,
+          property: this.gobbleIdentifier()
+        };
+      }
+      if (optional) {
+        node.optional = true;
+      }
+      this.gobbleSpaces();
+      ch = this.code;
+    }
+    return node;
+  }
+  /**
+   * Parse simple numeric literals: `12`, `3.4`, `.5`. Do this by using a string to
+   * keep track of everything in the numeric literal and then calling `parseFloat` on that string
+   * @returns {jsep.Literal}
+   */
+  gobbleNumericLiteral() {
+    let number4 = "", ch, chCode;
+    while (Jsep.isDecimalDigit(this.code)) {
+      number4 += this.expr.charAt(this.index++);
+    }
+    if (this.code === Jsep.PERIOD_CODE) {
+      number4 += this.expr.charAt(this.index++);
+      while (Jsep.isDecimalDigit(this.code)) {
+        number4 += this.expr.charAt(this.index++);
+      }
+    }
+    ch = this.char;
+    if (ch === "e" || ch === "E") {
+      number4 += this.expr.charAt(this.index++);
+      ch = this.char;
+      if (ch === "+" || ch === "-") {
+        number4 += this.expr.charAt(this.index++);
+      }
+      while (Jsep.isDecimalDigit(this.code)) {
+        number4 += this.expr.charAt(this.index++);
+      }
+      if (!Jsep.isDecimalDigit(this.expr.charCodeAt(this.index - 1))) {
+        this.throwError("Expected exponent (" + number4 + this.char + ")");
+      }
+    }
+    chCode = this.code;
+    if (Jsep.isIdentifierStart(chCode)) {
+      this.throwError("Variable names cannot start with a number (" + number4 + this.char + ")");
+    } else if (chCode === Jsep.PERIOD_CODE || number4.length === 1 && number4.charCodeAt(0) === Jsep.PERIOD_CODE) {
+      this.throwError("Unexpected period");
+    }
+    return {
+      type: Jsep.LITERAL,
+      value: parseFloat(number4),
+      raw: number4
+    };
+  }
+  /**
+   * Parses a string literal, staring with single or double quotes with basic support for escape codes
+   * e.g. `"hello world"`, `'this is\nJSEP'`
+   * @returns {jsep.Literal}
+   */
+  gobbleStringLiteral() {
+    let str = "";
+    const startIndex = this.index;
+    const quote = this.expr.charAt(this.index++);
+    let closed = false;
+    while (this.index < this.expr.length) {
+      let ch = this.expr.charAt(this.index++);
+      if (ch === quote) {
+        closed = true;
+        break;
+      } else if (ch === "\\") {
+        ch = this.expr.charAt(this.index++);
+        switch (ch) {
+          case "n":
+            str += "\n";
+            break;
+          case "r":
+            str += "\r";
+            break;
+          case "t":
+            str += "	";
+            break;
+          case "b":
+            str += "\b";
+            break;
+          case "f":
+            str += "\f";
+            break;
+          case "v":
+            str += "\v";
+            break;
+          default:
+            str += ch;
+        }
+      } else {
+        str += ch;
+      }
+    }
+    if (!closed) {
+      this.throwError('Unclosed quote after "' + str + '"');
+    }
+    return {
+      type: Jsep.LITERAL,
+      value: str,
+      raw: this.expr.substring(startIndex, this.index)
+    };
+  }
+  /**
+   * Gobbles only identifiers
+   * e.g.: `foo`, `_value`, `$x1`
+   * Also, this function checks if that identifier is a literal:
+   * (e.g. `true`, `false`, `null`) or `this`
+   * @returns {jsep.Identifier}
+   */
+  gobbleIdentifier() {
+    let ch = this.code, start = this.index;
+    if (Jsep.isIdentifierStart(ch)) {
+      this.index++;
+    } else {
+      this.throwError("Unexpected " + this.char);
+    }
+    while (this.index < this.expr.length) {
+      ch = this.code;
+      if (Jsep.isIdentifierPart(ch)) {
+        this.index++;
+      } else {
+        break;
+      }
+    }
+    return {
+      type: Jsep.IDENTIFIER,
+      name: this.expr.slice(start, this.index)
+    };
+  }
+  /**
+   * Gobbles a list of arguments within the context of a function call
+   * or array literal. This function also assumes that the opening character
+   * `(` or `[` has already been gobbled, and gobbles expressions and commas
+   * until the terminator character `)` or `]` is encountered.
+   * e.g. `foo(bar, baz)`, `my_func()`, or `[bar, baz]`
+   * @param {number} termination
+   * @returns {jsep.Expression[]}
+   */
+  gobbleArguments(termination) {
+    const args = [];
+    let closed = false;
+    let separator_count = 0;
+    while (this.index < this.expr.length) {
+      this.gobbleSpaces();
+      let ch_i = this.code;
+      if (ch_i === termination) {
+        closed = true;
+        this.index++;
+        if (termination === Jsep.CPAREN_CODE && separator_count && separator_count >= args.length) {
+          this.throwError("Unexpected token " + String.fromCharCode(termination));
+        }
+        break;
+      } else if (ch_i === Jsep.COMMA_CODE) {
+        this.index++;
+        separator_count++;
+        if (separator_count !== args.length) {
+          if (termination === Jsep.CPAREN_CODE) {
+            this.throwError("Unexpected token ,");
+          } else if (termination === Jsep.CBRACK_CODE) {
+            for (let arg = args.length; arg < separator_count; arg++) {
+              args.push(null);
+            }
+          }
+        }
+      } else if (args.length !== separator_count && separator_count !== 0) {
+        this.throwError("Expected comma");
+      } else {
+        const node = this.gobbleExpression();
+        if (!node || node.type === Jsep.COMPOUND) {
+          this.throwError("Expected comma");
+        }
+        args.push(node);
+      }
+    }
+    if (!closed) {
+      this.throwError("Expected " + String.fromCharCode(termination));
+    }
+    return args;
+  }
+  /**
+   * Responsible for parsing a group of things within parentheses `()`
+   * that have no identifier in front (so not a function call)
+   * This function assumes that it needs to gobble the opening parenthesis
+   * and then tries to gobble everything within that parenthesis, assuming
+   * that the next thing it should see is the close parenthesis. If not,
+   * then the expression probably doesn't have a `)`
+   * @returns {boolean|jsep.Expression}
+   */
+  gobbleGroup() {
+    this.index++;
+    let nodes = this.gobbleExpressions(Jsep.CPAREN_CODE);
+    if (this.code === Jsep.CPAREN_CODE) {
+      this.index++;
+      if (nodes.length === 1) {
+        return nodes[0];
+      } else if (!nodes.length) {
+        return false;
+      } else {
+        return {
+          type: Jsep.SEQUENCE_EXP,
+          expressions: nodes
+        };
+      }
+    } else {
+      this.throwError("Unclosed (");
+    }
+  }
+  /**
+   * Responsible for parsing Array literals `[1, 2, 3]`
+   * This function assumes that it needs to gobble the opening bracket
+   * and then tries to gobble the expressions as arguments.
+   * @returns {jsep.ArrayExpression}
+   */
+  gobbleArray() {
+    this.index++;
+    return {
+      type: Jsep.ARRAY_EXP,
+      elements: this.gobbleArguments(Jsep.CBRACK_CODE)
+    };
+  }
+}
+const hooks = new Hooks();
+Object.assign(Jsep, {
+  hooks,
+  plugins: new Plugins(Jsep),
+  // Node Types
+  // ----------
+  // This is the full set of types that any JSEP node can be.
+  // Store them here to save space when minified
+  COMPOUND: "Compound",
+  SEQUENCE_EXP: "SequenceExpression",
+  IDENTIFIER: "Identifier",
+  MEMBER_EXP: "MemberExpression",
+  LITERAL: "Literal",
+  THIS_EXP: "ThisExpression",
+  CALL_EXP: "CallExpression",
+  UNARY_EXP: "UnaryExpression",
+  BINARY_EXP: "BinaryExpression",
+  ARRAY_EXP: "ArrayExpression",
+  TAB_CODE: 9,
+  LF_CODE: 10,
+  CR_CODE: 13,
+  SPACE_CODE: 32,
+  PERIOD_CODE: 46,
+  // '.'
+  COMMA_CODE: 44,
+  // ','
+  SQUOTE_CODE: 39,
+  // single quote
+  DQUOTE_CODE: 34,
+  // double quotes
+  OPAREN_CODE: 40,
+  // (
+  CPAREN_CODE: 41,
+  // )
+  OBRACK_CODE: 91,
+  // [
+  CBRACK_CODE: 93,
+  // ]
+  QUMARK_CODE: 63,
+  // ?
+  SEMCOL_CODE: 59,
+  // ;
+  COLON_CODE: 58,
+  // :
+  // Operations
+  // ----------
+  // Use a quickly-accessible map to store all of the unary operators
+  // Values are set to `1` (it really doesn't matter)
+  unary_ops: {
+    "-": 1,
+    "!": 1,
+    "~": 1,
+    "+": 1
+  },
+  // Also use a map for the binary operations but set their values to their
+  // binary precedence for quick reference (higher number = higher precedence)
+  // see [Order of operations](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)
+  binary_ops: {
+    "||": 1,
+    "??": 1,
+    "&&": 2,
+    "|": 3,
+    "^": 4,
+    "&": 5,
+    "==": 6,
+    "!=": 6,
+    "===": 6,
+    "!==": 6,
+    "<": 7,
+    ">": 7,
+    "<=": 7,
+    ">=": 7,
+    "<<": 8,
+    ">>": 8,
+    ">>>": 8,
+    "+": 9,
+    "-": 9,
+    "*": 10,
+    "/": 10,
+    "%": 10,
+    "**": 11
+  },
+  // sets specific binary_ops as right-associative
+  right_associative: /* @__PURE__ */ new Set(["**"]),
+  // Additional valid identifier chars, apart from a-z, A-Z and 0-9 (except on the starting char)
+  additional_identifier_chars: /* @__PURE__ */ new Set(["$", "_"]),
+  // Literals
+  // ----------
+  // Store the values to return for the various literals we may encounter
+  literals: {
+    "true": true,
+    "false": false,
+    "null": null
+  },
+  // Except for `this`, which is special. This could be changed to something like `'self'` as well
+  this_str: "this"
+});
+Jsep.max_unop_len = Jsep.getMaxKeyLen(Jsep.unary_ops);
+Jsep.max_binop_len = Jsep.getMaxKeyLen(Jsep.binary_ops);
+const jsep = (expr) => new Jsep(expr).parse();
+const stdClassProps = Object.getOwnPropertyNames(class Test {
+});
+Object.getOwnPropertyNames(Jsep).filter((prop) => !stdClassProps.includes(prop) && jsep[prop] === void 0).forEach((m) => {
+  jsep[m] = Jsep[m];
+});
+jsep.Jsep = Jsep;
+const CONDITIONAL_EXP = "ConditionalExpression";
+var ternary = {
+  name: "ternary",
+  init(jsep2) {
+    jsep2.hooks.add("after-expression", function gobbleTernary(env) {
+      if (env.node && this.code === jsep2.QUMARK_CODE) {
+        this.index++;
+        const test2 = env.node;
+        const consequent = this.gobbleExpression();
+        if (!consequent) {
+          this.throwError("Expected expression");
+        }
+        this.gobbleSpaces();
+        if (this.code === jsep2.COLON_CODE) {
+          this.index++;
+          const alternate = this.gobbleExpression();
+          if (!alternate) {
+            this.throwError("Expected expression");
+          }
+          env.node = {
+            type: CONDITIONAL_EXP,
+            test: test2,
+            consequent,
+            alternate
+          };
+          if (test2.operator && jsep2.binary_ops[test2.operator] <= 0.9) {
+            let newTest = test2;
+            while (newTest.right.operator && jsep2.binary_ops[newTest.right.operator] <= 0.9) {
+              newTest = newTest.right;
+            }
+            env.node.test = newTest.right;
+            newTest.right = env.node;
+            env.node = test2;
+          }
+        } else {
+          this.throwError("Expected :");
+        }
+      }
+    });
+  }
+};
+jsep.plugins.register(ternary);
+const FSLASH_CODE = 47;
+const BSLASH_CODE = 92;
+var index = {
+  name: "regex",
+  init(jsep2) {
+    jsep2.hooks.add("gobble-token", function gobbleRegexLiteral(env) {
+      if (this.code === FSLASH_CODE) {
+        const patternIndex = ++this.index;
+        let inCharSet = false;
+        while (this.index < this.expr.length) {
+          if (this.code === FSLASH_CODE && !inCharSet) {
+            const pattern4 = this.expr.slice(patternIndex, this.index);
+            let flags = "";
+            while (++this.index < this.expr.length) {
+              const code = this.code;
+              if (code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57) {
+                flags += this.char;
+              } else {
+                break;
+              }
+            }
+            let value;
+            try {
+              value = new RegExp(pattern4, flags);
+            } catch (e) {
+              this.throwError(e.message);
+            }
+            env.node = {
+              type: jsep2.LITERAL,
+              value,
+              raw: this.expr.slice(patternIndex - 1, this.index)
+            };
+            env.node = this.gobbleTokenProperty(env.node);
+            return env.node;
+          }
+          if (this.code === jsep2.OBRACK_CODE) {
+            inCharSet = true;
+          } else if (inCharSet && this.code === jsep2.CBRACK_CODE) {
+            inCharSet = false;
+          }
+          this.index += this.code === BSLASH_CODE ? 2 : 1;
+        }
+        this.throwError("Unclosed Regex");
+      }
+    });
+  }
+};
+const PLUS_CODE = 43;
+const MINUS_CODE = 45;
+const plugin = {
+  name: "assignment",
+  assignmentOperators: /* @__PURE__ */ new Set(["=", "*=", "**=", "/=", "%=", "+=", "-=", "<<=", ">>=", ">>>=", "&=", "^=", "|=", "||=", "&&=", "??="]),
+  updateOperators: [PLUS_CODE, MINUS_CODE],
+  assignmentPrecedence: 0.9,
+  init(jsep2) {
+    const updateNodeTypes = [jsep2.IDENTIFIER, jsep2.MEMBER_EXP];
+    plugin.assignmentOperators.forEach((op) => jsep2.addBinaryOp(op, plugin.assignmentPrecedence, true));
+    jsep2.hooks.add("gobble-token", function gobbleUpdatePrefix(env) {
+      const code = this.code;
+      if (plugin.updateOperators.some((c2) => c2 === code && c2 === this.expr.charCodeAt(this.index + 1))) {
+        this.index += 2;
+        env.node = {
+          type: "UpdateExpression",
+          operator: code === PLUS_CODE ? "++" : "--",
+          argument: this.gobbleTokenProperty(this.gobbleIdentifier()),
+          prefix: true
+        };
+        if (!env.node.argument || !updateNodeTypes.includes(env.node.argument.type)) {
+          this.throwError(`Unexpected ${env.node.operator}`);
+        }
+      }
+    });
+    jsep2.hooks.add("after-token", function gobbleUpdatePostfix(env) {
+      if (env.node) {
+        const code = this.code;
+        if (plugin.updateOperators.some((c2) => c2 === code && c2 === this.expr.charCodeAt(this.index + 1))) {
+          if (!updateNodeTypes.includes(env.node.type)) {
+            this.throwError(`Unexpected ${env.node.operator}`);
+          }
+          this.index += 2;
+          env.node = {
+            type: "UpdateExpression",
+            operator: code === PLUS_CODE ? "++" : "--",
+            argument: env.node,
+            prefix: false
+          };
+        }
+      }
+    });
+    jsep2.hooks.add("after-expression", function gobbleAssignment(env) {
+      if (env.node) {
+        updateBinariesToAssignments(env.node);
+      }
+    });
+    function updateBinariesToAssignments(node) {
+      if (plugin.assignmentOperators.has(node.operator)) {
+        node.type = "AssignmentExpression";
+        updateBinariesToAssignments(node.left);
+        updateBinariesToAssignments(node.right);
+      } else if (!node.operator) {
+        Object.values(node).forEach((val) => {
+          if (val && typeof val === "object") {
+            updateBinariesToAssignments(val);
+          }
+        });
+      }
+    }
+  }
+};
+jsep.plugins.register(index, plugin);
+jsep.addUnaryOp("typeof");
+jsep.addUnaryOp("void");
+jsep.addLiteral("null", null);
+jsep.addLiteral("undefined", void 0);
+const BLOCKED_PROTO_PROPERTIES = /* @__PURE__ */ new Set(["constructor", "__proto__", "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__"]);
+const SafeEval = {
+  /**
+   * @param {jsep.Expression} ast
+   * @param {Record<string, any>} subs
+   */
+  evalAst(ast, subs) {
+    switch (ast.type) {
+      case "BinaryExpression":
+      case "LogicalExpression":
+        return SafeEval.evalBinaryExpression(ast, subs);
+      case "Compound":
+        return SafeEval.evalCompound(ast, subs);
+      case "ConditionalExpression":
+        return SafeEval.evalConditionalExpression(ast, subs);
+      case "Identifier":
+        return SafeEval.evalIdentifier(ast, subs);
+      case "Literal":
+        return SafeEval.evalLiteral(ast, subs);
+      case "MemberExpression":
+        return SafeEval.evalMemberExpression(ast, subs);
+      case "UnaryExpression":
+        return SafeEval.evalUnaryExpression(ast, subs);
+      case "ArrayExpression":
+        return SafeEval.evalArrayExpression(ast, subs);
+      case "CallExpression":
+        return SafeEval.evalCallExpression(ast, subs);
+      case "AssignmentExpression":
+        return SafeEval.evalAssignmentExpression(ast, subs);
+      default:
+        throw SyntaxError("Unexpected expression", ast);
+    }
+  },
+  evalBinaryExpression(ast, subs) {
+    const result = {
+      "||": (a, b2) => a || b2(),
+      "&&": (a, b2) => a && b2(),
+      "|": (a, b2) => a | b2(),
+      "^": (a, b2) => a ^ b2(),
+      "&": (a, b2) => a & b2(),
+      // eslint-disable-next-line eqeqeq -- API
+      "==": (a, b2) => a == b2(),
+      // eslint-disable-next-line eqeqeq -- API
+      "!=": (a, b2) => a != b2(),
+      "===": (a, b2) => a === b2(),
+      "!==": (a, b2) => a !== b2(),
+      "<": (a, b2) => a < b2(),
+      ">": (a, b2) => a > b2(),
+      "<=": (a, b2) => a <= b2(),
+      ">=": (a, b2) => a >= b2(),
+      "<<": (a, b2) => a << b2(),
+      ">>": (a, b2) => a >> b2(),
+      ">>>": (a, b2) => a >>> b2(),
+      "+": (a, b2) => a + b2(),
+      "-": (a, b2) => a - b2(),
+      "*": (a, b2) => a * b2(),
+      "/": (a, b2) => a / b2(),
+      "%": (a, b2) => a % b2()
+    }[ast.operator](SafeEval.evalAst(ast.left, subs), () => SafeEval.evalAst(ast.right, subs));
+    return result;
+  },
+  evalCompound(ast, subs) {
+    let last2;
+    for (let i = 0; i < ast.body.length; i++) {
+      if (ast.body[i].type === "Identifier" && ["var", "let", "const"].includes(ast.body[i].name) && ast.body[i + 1] && ast.body[i + 1].type === "AssignmentExpression") {
+        i += 1;
+      }
+      const expr = ast.body[i];
+      last2 = SafeEval.evalAst(expr, subs);
+    }
+    return last2;
+  },
+  evalConditionalExpression(ast, subs) {
+    if (SafeEval.evalAst(ast.test, subs)) {
+      return SafeEval.evalAst(ast.consequent, subs);
+    }
+    return SafeEval.evalAst(ast.alternate, subs);
+  },
+  evalIdentifier(ast, subs) {
+    if (Object.hasOwn(subs, ast.name)) {
+      return subs[ast.name];
+    }
+    throw ReferenceError(`${ast.name} is not defined`);
+  },
+  evalLiteral(ast) {
+    return ast.value;
+  },
+  evalMemberExpression(ast, subs) {
+    const prop = String(
+      // NOTE: `String(value)` throws error when
+      // value has overwritten the toString method to return non-string
+      // i.e. `value = {toString: () => []}`
+      ast.computed ? SafeEval.evalAst(ast.property) : ast.property.name
+      // `object.property` property is Identifier
+    );
+    const obj = SafeEval.evalAst(ast.object, subs);
+    if (obj === void 0 || obj === null) {
+      throw TypeError(`Cannot read properties of ${obj} (reading '${prop}')`);
+    }
+    if (!Object.hasOwn(obj, prop) && BLOCKED_PROTO_PROPERTIES.has(prop)) {
+      throw TypeError(`Cannot read properties of ${obj} (reading '${prop}')`);
+    }
+    const result = obj[prop];
+    if (typeof result === "function") {
+      return result.bind(obj);
+    }
+    return result;
+  },
+  evalUnaryExpression(ast, subs) {
+    const result = {
+      "-": (a) => -SafeEval.evalAst(a, subs),
+      "!": (a) => !SafeEval.evalAst(a, subs),
+      "~": (a) => ~SafeEval.evalAst(a, subs),
+      // eslint-disable-next-line no-implicit-coercion -- API
+      "+": (a) => +SafeEval.evalAst(a, subs),
+      typeof: (a) => typeof SafeEval.evalAst(a, subs),
+      // eslint-disable-next-line no-void, sonarjs/void-use -- feature
+      void: (a) => void SafeEval.evalAst(a, subs)
+    }[ast.operator](ast.argument);
+    return result;
+  },
+  evalArrayExpression(ast, subs) {
+    return ast.elements.map((el) => SafeEval.evalAst(el, subs));
+  },
+  evalCallExpression(ast, subs) {
+    const args = ast.arguments.map((arg) => SafeEval.evalAst(arg, subs));
+    const func = SafeEval.evalAst(ast.callee, subs);
+    if (func === Function) {
+      throw new Error("Function constructor is disabled");
+    }
+    return func(...args);
+  },
+  evalAssignmentExpression(ast, subs) {
+    if (ast.left.type !== "Identifier") {
+      throw SyntaxError("Invalid left-hand side in assignment");
+    }
+    const id = ast.left.name;
+    const value = SafeEval.evalAst(ast.right, subs);
+    subs[id] = value;
+    return subs[id];
+  }
+};
+class SafeScript {
+  /**
+   * @param {string} expr Expression to evaluate
+   */
+  constructor(expr) {
+    this.code = expr;
+    this.ast = jsep(this.code);
+  }
+  /**
+   * @param {object} context Object whose items will be added
+   *   to evaluation
+   * @returns {EvaluatedResult} Result of evaluated code
+   */
+  runInNewContext(context) {
+    const keyMap = Object.assign(/* @__PURE__ */ Object.create(null), context);
+    return SafeEval.evalAst(this.ast, keyMap);
+  }
+}
+function push(arr, item) {
+  arr = arr.slice();
+  arr.push(item);
+  return arr;
+}
+function unshift(item, arr) {
+  arr = arr.slice();
+  arr.unshift(item);
+  return arr;
+}
+class NewError extends Error {
+  /**
+   * @param {AnyResult} value The evaluated scalar value
+   */
+  constructor(value) {
+    super('JSONPath should not be called with "new" (it prevents return of (unwrapped) scalar values)');
+    this.avoidNew = true;
+    this.value = value;
+    this.name = "NewError";
+  }
+}
+function JSONPath(opts, expr, obj, callback, otherTypeCallback) {
+  if (!(this instanceof JSONPath)) {
+    try {
+      return new JSONPath(opts, expr, obj, callback, otherTypeCallback);
+    } catch (e) {
+      if (!e.avoidNew) {
+        throw e;
+      }
+      return e.value;
+    }
+  }
+  if (typeof opts === "string") {
+    otherTypeCallback = callback;
+    callback = obj;
+    obj = expr;
+    expr = opts;
+    opts = null;
+  }
+  const optObj = opts && typeof opts === "object";
+  opts = opts || {};
+  this.json = opts.json || obj;
+  this.path = opts.path || expr;
+  this.resultType = opts.resultType || "value";
+  this.flatten = opts.flatten || false;
+  this.wrap = Object.hasOwn(opts, "wrap") ? opts.wrap : true;
+  this.sandbox = opts.sandbox || {};
+  this.eval = opts.eval === void 0 ? "safe" : opts.eval;
+  this.ignoreEvalErrors = typeof opts.ignoreEvalErrors === "undefined" ? false : opts.ignoreEvalErrors;
+  this.parent = opts.parent || null;
+  this.parentProperty = opts.parentProperty || null;
+  this.callback = opts.callback || callback || null;
+  this.otherTypeCallback = opts.otherTypeCallback || otherTypeCallback || function() {
+    throw new TypeError("You must supply an otherTypeCallback callback option with the @other() operator.");
+  };
+  if (opts.autostart !== false) {
+    const args = {
+      path: optObj ? opts.path : expr
+    };
+    if (!optObj) {
+      args.json = obj;
+    } else if ("json" in opts) {
+      args.json = opts.json;
+    }
+    const ret = this.evaluate(args);
+    if (!ret || typeof ret !== "object") {
+      throw new NewError(ret);
+    }
+    return ret;
+  }
+}
+JSONPath.prototype.evaluate = function(expr, json, callback, otherTypeCallback) {
+  let currParent = this.parent, currParentProperty = this.parentProperty;
+  let {
+    flatten: flatten2,
+    wrap
+  } = this;
+  this.currResultType = this.resultType;
+  this.currEval = this.eval;
+  this.currSandbox = this.sandbox;
+  callback = callback || this.callback;
+  this.currOtherTypeCallback = otherTypeCallback || this.otherTypeCallback;
+  json = json || this.json;
+  expr = expr || this.path;
+  if (expr && typeof expr === "object" && !Array.isArray(expr)) {
+    if (!expr.path && expr.path !== "") {
+      throw new TypeError('You must supply a "path" property when providing an object argument to JSONPath.evaluate().');
+    }
+    if (!Object.hasOwn(expr, "json")) {
+      throw new TypeError('You must supply a "json" property when providing an object argument to JSONPath.evaluate().');
+    }
+    ({
+      json
+    } = expr);
+    flatten2 = Object.hasOwn(expr, "flatten") ? expr.flatten : flatten2;
+    this.currResultType = Object.hasOwn(expr, "resultType") ? expr.resultType : this.currResultType;
+    this.currSandbox = Object.hasOwn(expr, "sandbox") ? expr.sandbox : this.currSandbox;
+    wrap = Object.hasOwn(expr, "wrap") ? expr.wrap : wrap;
+    this.currEval = Object.hasOwn(expr, "eval") ? expr.eval : this.currEval;
+    callback = Object.hasOwn(expr, "callback") ? expr.callback : callback;
+    this.currOtherTypeCallback = Object.hasOwn(expr, "otherTypeCallback") ? expr.otherTypeCallback : this.currOtherTypeCallback;
+    currParent = Object.hasOwn(expr, "parent") ? expr.parent : currParent;
+    currParentProperty = Object.hasOwn(expr, "parentProperty") ? expr.parentProperty : currParentProperty;
+    expr = expr.path;
+  }
+  currParent = currParent || null;
+  currParentProperty = currParentProperty || null;
+  if (Array.isArray(expr)) {
+    expr = JSONPath.toPathString(expr);
+  }
+  if (!expr && expr !== "" || !json) {
+    return void 0;
+  }
+  const exprList = JSONPath.toPathArray(expr);
+  if (exprList[0] === "$" && exprList.length > 1) {
+    exprList.shift();
+  }
+  this._hasParentSelector = null;
+  const result = this._trace(exprList, json, ["$"], currParent, currParentProperty, callback).filter(function(ea2) {
+    return ea2 && !ea2.isParentSelector;
+  });
+  if (!result.length) {
+    return wrap ? [] : void 0;
+  }
+  if (!wrap && result.length === 1 && !result[0].hasArrExpr) {
+    return this._getPreferredOutput(result[0]);
+  }
+  return result.reduce((rslt, ea2) => {
+    const valOrPath = this._getPreferredOutput(ea2);
+    if (flatten2 && Array.isArray(valOrPath)) {
+      rslt = rslt.concat(valOrPath);
+    } else {
+      rslt.push(valOrPath);
+    }
+    return rslt;
+  }, []);
+};
+JSONPath.prototype._getPreferredOutput = function(ea2) {
+  const resultType = this.currResultType;
+  switch (resultType) {
+    case "all": {
+      const path2 = Array.isArray(ea2.path) ? ea2.path : JSONPath.toPathArray(ea2.path);
+      ea2.pointer = JSONPath.toPointer(path2);
+      ea2.path = typeof ea2.path === "string" ? ea2.path : JSONPath.toPathString(ea2.path);
+      return ea2;
+    }
+    case "value":
+    case "parent":
+    case "parentProperty":
+      return ea2[resultType];
+    case "path":
+      return JSONPath.toPathString(ea2[resultType]);
+    case "pointer":
+      return JSONPath.toPointer(ea2.path);
+    default:
+      throw new TypeError("Unknown result type");
+  }
+};
+JSONPath.prototype._handleCallback = function(fullRetObj, callback, type4) {
+  if (callback) {
+    const preferredOutput = this._getPreferredOutput(fullRetObj);
+    fullRetObj.path = typeof fullRetObj.path === "string" ? fullRetObj.path : JSONPath.toPathString(fullRetObj.path);
+    callback(preferredOutput, type4, fullRetObj);
+  }
+};
+JSONPath.prototype._trace = function(expr, val, path2, parent2, parentPropName, callback, hasArrExpr, literalPriority) {
+  let retObj;
+  if (!expr.length) {
+    retObj = {
+      path: path2,
+      value: val,
+      parent: parent2,
+      parentProperty: parentPropName,
+      hasArrExpr
+    };
+    this._handleCallback(retObj, callback, "value");
+    return retObj;
+  }
+  const loc = expr[0], x2 = expr.slice(1);
+  const ret = [];
+  function addRet(elems) {
+    if (Array.isArray(elems)) {
+      elems.forEach((t) => {
+        ret.push(t);
+      });
+    } else {
+      ret.push(elems);
+    }
+  }
+  if ((typeof loc !== "string" || literalPriority) && val && Object.hasOwn(val, loc)) {
+    addRet(this._trace(x2, val[loc], push(path2, loc), val, loc, callback, hasArrExpr));
+  } else if (loc === "*") {
+    this._walk(val, (m) => {
+      addRet(this._trace(x2, val[m], push(path2, m), val, m, callback, true, true));
+    });
+  } else if (loc === "..") {
+    addRet(this._trace(x2, val, path2, parent2, parentPropName, callback, hasArrExpr));
+    this._walk(val, (m) => {
+      if (typeof val[m] === "object") {
+        addRet(this._trace(expr.slice(), val[m], push(path2, m), val, m, callback, true));
+      }
+    });
+  } else if (loc === "^") {
+    this._hasParentSelector = true;
+    return {
+      path: path2.slice(0, -1),
+      expr: x2,
+      isParentSelector: true
+    };
+  } else if (loc === "~") {
+    retObj = {
+      path: push(path2, loc),
+      value: parentPropName,
+      parent: parent2,
+      parentProperty: null
+    };
+    this._handleCallback(retObj, callback, "property");
+    return retObj;
+  } else if (loc === "$") {
+    addRet(this._trace(x2, val, path2, null, null, callback, hasArrExpr));
+  } else if (/^(-?\d*):(-?\d*):?(\d*)$/u.test(loc)) {
+    addRet(this._slice(loc, x2, val, path2, parent2, parentPropName, callback));
+  } else if (loc.indexOf("?(") === 0) {
+    if (this.currEval === false) {
+      throw new Error("Eval [?(expr)] prevented in JSONPath expression.");
+    }
+    const safeLoc = loc.replace(/^\?\((.*?)\)$/u, "$1");
+    const nested = /@.?([^?]*)[['](\??\(.*?\))(?!.\)\])[\]']/gu.exec(safeLoc);
+    if (nested) {
+      this._walk(val, (m) => {
+        const npath = [nested[2]];
+        const nvalue = nested[1] ? val[m][nested[1]] : val[m];
+        const filterResults = this._trace(npath, nvalue, path2, parent2, parentPropName, callback, true);
+        if (filterResults.length > 0) {
+          addRet(this._trace(x2, val[m], push(path2, m), val, m, callback, true));
+        }
+      });
+    } else {
+      this._walk(val, (m) => {
+        if (this._eval(safeLoc, val[m], m, path2, parent2, parentPropName)) {
+          addRet(this._trace(x2, val[m], push(path2, m), val, m, callback, true));
+        }
+      });
+    }
+  } else if (loc[0] === "(") {
+    if (this.currEval === false) {
+      throw new Error("Eval [(expr)] prevented in JSONPath expression.");
+    }
+    addRet(this._trace(unshift(this._eval(loc, val, path2.at(-1), path2.slice(0, -1), parent2, parentPropName), x2), val, path2, parent2, parentPropName, callback, hasArrExpr));
+  } else if (loc[0] === "@") {
+    let addType = false;
+    const valueType = loc.slice(1, -2);
+    switch (valueType) {
+      case "scalar":
+        if (!val || !["object", "function"].includes(typeof val)) {
+          addType = true;
+        }
+        break;
+      case "boolean":
+      case "string":
+      case "undefined":
+      case "function":
+        if (typeof val === valueType) {
+          addType = true;
+        }
+        break;
+      case "integer":
+        if (Number.isFinite(val) && !(val % 1)) {
+          addType = true;
+        }
+        break;
+      case "number":
+        if (Number.isFinite(val)) {
+          addType = true;
+        }
+        break;
+      case "nonFinite":
+        if (typeof val === "number" && !Number.isFinite(val)) {
+          addType = true;
+        }
+        break;
+      case "object":
+        if (val && typeof val === valueType) {
+          addType = true;
+        }
+        break;
+      case "array":
+        if (Array.isArray(val)) {
+          addType = true;
+        }
+        break;
+      case "other":
+        addType = this.currOtherTypeCallback(val, path2, parent2, parentPropName);
+        break;
+      case "null":
+        if (val === null) {
+          addType = true;
+        }
+        break;
+      /* c8 ignore next 2 */
+      default:
+        throw new TypeError("Unknown value type " + valueType);
+    }
+    if (addType) {
+      retObj = {
+        path: path2,
+        value: val,
+        parent: parent2,
+        parentProperty: parentPropName
+      };
+      this._handleCallback(retObj, callback, "value");
+      return retObj;
+    }
+  } else if (loc[0] === "`" && val && Object.hasOwn(val, loc.slice(1))) {
+    const locProp = loc.slice(1);
+    addRet(this._trace(x2, val[locProp], push(path2, locProp), val, locProp, callback, hasArrExpr, true));
+  } else if (loc.includes(",")) {
+    const parts = loc.split(",");
+    for (const part of parts) {
+      addRet(this._trace(unshift(part, x2), val, path2, parent2, parentPropName, callback, true));
+    }
+  } else if (!literalPriority && val && Object.hasOwn(val, loc)) {
+    addRet(this._trace(x2, val[loc], push(path2, loc), val, loc, callback, hasArrExpr, true));
+  }
+  if (this._hasParentSelector) {
+    for (let t = 0; t < ret.length; t++) {
+      const rett = ret[t];
+      if (rett && rett.isParentSelector) {
+        const tmp = this._trace(rett.expr, val, rett.path, parent2, parentPropName, callback, hasArrExpr);
+        if (Array.isArray(tmp)) {
+          ret[t] = tmp[0];
+          const tl = tmp.length;
+          for (let tt2 = 1; tt2 < tl; tt2++) {
+            t++;
+            ret.splice(t, 0, tmp[tt2]);
+          }
+        } else {
+          ret[t] = tmp;
+        }
+      }
+    }
+  }
+  return ret;
+};
+JSONPath.prototype._walk = function(val, f) {
+  if (Array.isArray(val)) {
+    const n = val.length;
+    for (let i = 0; i < n; i++) {
+      f(i);
+    }
+  } else if (val && typeof val === "object") {
+    Object.keys(val).forEach((m) => {
+      f(m);
+    });
+  }
+};
+JSONPath.prototype._slice = function(loc, expr, val, path2, parent2, parentPropName, callback) {
+  if (!Array.isArray(val)) {
+    return void 0;
+  }
+  const len = val.length, parts = loc.split(":"), step = parts[2] && Number.parseInt(parts[2]) || 1;
+  let start = parts[0] && Number.parseInt(parts[0]) || 0, end = parts[1] && Number.parseInt(parts[1]) || len;
+  start = start < 0 ? Math.max(0, start + len) : Math.min(len, start);
+  end = end < 0 ? Math.max(0, end + len) : Math.min(len, end);
+  const ret = [];
+  for (let i = start; i < end; i += step) {
+    const tmp = this._trace(unshift(i, expr), val, path2, parent2, parentPropName, callback, true);
+    tmp.forEach((t) => {
+      ret.push(t);
+    });
+  }
+  return ret;
+};
+JSONPath.prototype._eval = function(code, _v, _vname, path2, parent2, parentPropName) {
+  this.currSandbox._$_parentProperty = parentPropName;
+  this.currSandbox._$_parent = parent2;
+  this.currSandbox._$_property = _vname;
+  this.currSandbox._$_root = this.json;
+  this.currSandbox._$_v = _v;
+  const containsPath = code.includes("@path");
+  if (containsPath) {
+    this.currSandbox._$_path = JSONPath.toPathString(path2.concat([_vname]));
+  }
+  const scriptCacheKey = this.currEval + "Script:" + code;
+  if (!JSONPath.cache[scriptCacheKey]) {
+    let script = code.replaceAll("@parentProperty", "_$_parentProperty").replaceAll("@parent", "_$_parent").replaceAll("@property", "_$_property").replaceAll("@root", "_$_root").replaceAll(/@([.\s)[])/gu, "_$_v$1");
+    if (containsPath) {
+      script = script.replaceAll("@path", "_$_path");
+    }
+    if (this.currEval === "safe" || this.currEval === true || this.currEval === void 0) {
+      JSONPath.cache[scriptCacheKey] = new this.safeVm.Script(script);
+    } else if (this.currEval === "native") {
+      JSONPath.cache[scriptCacheKey] = new this.vm.Script(script);
+    } else if (typeof this.currEval === "function" && this.currEval.prototype && Object.hasOwn(this.currEval.prototype, "runInNewContext")) {
+      const CurrEval = this.currEval;
+      JSONPath.cache[scriptCacheKey] = new CurrEval(script);
+    } else if (typeof this.currEval === "function") {
+      JSONPath.cache[scriptCacheKey] = {
+        runInNewContext: (context) => this.currEval(script, context)
+      };
+    } else {
+      throw new TypeError(`Unknown "eval" property "${this.currEval}"`);
+    }
+  }
+  try {
+    return JSONPath.cache[scriptCacheKey].runInNewContext(this.currSandbox);
+  } catch (e) {
+    if (this.ignoreEvalErrors) {
+      return false;
+    }
+    throw new Error("jsonPath: " + e.message + ": " + code);
+  }
+};
+JSONPath.cache = {};
+JSONPath.toPathString = function(pathArr) {
+  const x2 = pathArr, n = x2.length;
+  let p = "$";
+  for (let i = 1; i < n; i++) {
+    if (!/^(~|\^|@.*?\(\))$/u.test(x2[i])) {
+      p += /^[0-9*]+$/u.test(x2[i]) ? "[" + x2[i] + "]" : "['" + x2[i] + "']";
+    }
+  }
+  return p;
+};
+JSONPath.toPointer = function(pointer) {
+  const x2 = pointer, n = x2.length;
+  let p = "";
+  for (let i = 1; i < n; i++) {
+    if (!/^(~|\^|@.*?\(\))$/u.test(x2[i])) {
+      p += "/" + x2[i].toString().replaceAll("~", "~0").replaceAll("/", "~1");
+    }
+  }
+  return p;
+};
+JSONPath.toPathArray = function(expr) {
+  const {
+    cache
+  } = JSONPath;
+  if (cache[expr]) {
+    return cache[expr].concat();
+  }
+  const subx = [];
+  const normalized = expr.replaceAll(/@(?:null|boolean|number|string|integer|undefined|nonFinite|scalar|array|object|function|other)\(\)/gu, ";$&;").replaceAll(/[['](\??\(.*?\))[\]'](?!.\])/gu, function($0, $1) {
+    return "[#" + (subx.push($1) - 1) + "]";
+  }).replaceAll(/\[['"]([^'\]]*)['"]\]/gu, function($0, prop) {
+    return "['" + prop.replaceAll(".", "%@%").replaceAll("~", "%%@@%%") + "']";
+  }).replaceAll("~", ";~;").replaceAll(/['"]?\.['"]?(?![^[]*\])|\[['"]?/gu, ";").replaceAll("%@%", ".").replaceAll("%%@@%%", "~").replaceAll(/(?:;)?(\^+)(?:;)?/gu, function($0, ups) {
+    return ";" + ups.split("").join(";") + ";";
+  }).replaceAll(/;;;|;;/gu, ";..;").replaceAll(/;$|'?\]|'$/gu, "");
+  const exprList = normalized.split(";").map(function(exp) {
+    const match = exp.match(/#(\d+)/u);
+    return !match || !match[1] ? exp : subx[match[1]];
+  });
+  cache[expr] = exprList;
+  return cache[expr].concat();
+};
+JSONPath.prototype.safeVm = {
+  Script: SafeScript
+};
+const moveToAnotherArray = function(source, target, conditionCb) {
+  const il = source.length;
+  for (let i = 0; i < il; i++) {
+    const item = source[i];
+    if (conditionCb(item)) {
+      target.push(source.splice(i--, 1)[0]);
+    }
+  }
+};
+class Script {
+  /**
+   * @param {string} expr Expression to evaluate
+   */
+  constructor(expr) {
+    this.code = expr;
+  }
+  /**
+   * @param {object} context Object whose items will be added
+   *   to evaluation
+   * @returns {EvaluatedResult} Result of evaluated code
+   */
+  runInNewContext(context) {
+    let expr = this.code;
+    const keys2 = Object.keys(context);
+    const funcs = [];
+    moveToAnotherArray(keys2, funcs, (key) => {
+      return typeof context[key] === "function";
+    });
+    const values = keys2.map((vr) => {
+      return context[vr];
+    });
+    const funcString = funcs.reduce((s, func) => {
+      let fString = context[func].toString();
+      if (!/function/u.test(fString)) {
+        fString = "function " + fString;
+      }
+      return "var " + func + "=" + fString + ";" + s;
+    }, "");
+    expr = funcString + expr;
+    if (!/(['"])use strict\1/u.test(expr) && !keys2.includes("arguments")) {
+      expr = "var arguments = undefined;" + expr;
+    }
+    expr = expr.replace(/;\s*$/u, "");
+    const lastStatementEnd = expr.lastIndexOf(";");
+    const code = lastStatementEnd !== -1 ? expr.slice(0, lastStatementEnd + 1) + " return " + expr.slice(lastStatementEnd + 1) : " return " + expr;
+    return new Function(...keys2, code)(...values);
+  }
+}
+JSONPath.prototype.vm = {
+  Script
+};
 const parseJsonSchema = (schema2, paramsConfig = /* @__PURE__ */ new Map()) => {
   if (!schema2 || typeof schema2 !== "object") return schema2;
   switch (schema2.type) {
@@ -52466,7 +54408,7 @@ const parseJsonSchema = (schema2, paramsConfig = /* @__PURE__ */ new Map()) => {
 };
 function processJsonSchemaSubModel0(mapItem, apiData) {
   return mapItem.fields.reduce((acc, { leftFieldKey, rightFieldKey }) => {
-    let value = get(apiData, `${rightFieldKey}.0`);
+    let value = JSONPath({ path: rightFieldKey, json: apiData })?.[0];
     value = (Array.isArray(value) ? value[0] : value) ?? void 0;
     acc[leftFieldKey] = typeof value === "object" ? void 0 : value;
     return acc;
@@ -52474,7 +54416,7 @@ function processJsonSchemaSubModel0(mapItem, apiData) {
 }
 function processJsonSchemaSubModel1(mapItem, apiData) {
   const fieldValues = mapItem.fields.reduce((acc, { leftFieldKey, rightFieldKey }) => {
-    let value = get(apiData, rightFieldKey);
+    let value = JSONPath({ path: rightFieldKey, json: apiData });
     let arr = Array.isArray(value) ? value.filter((v) => v != null && typeof v !== "object") : value != null && typeof value !== "object" ? [value] : [];
     acc[leftFieldKey] = arr;
     return acc;
@@ -98183,8 +100125,18 @@ async function resolveCheckTableItemInfos(ctx) {
     protocolKey: checkTableDs.joinModelKey,
     instId: ctx.instanceId
   });
+  res.data?.forEach((item) => {
+    delete item.id_;
+  });
   return res;
 }
+async function waitForDataManagerSettle() {
+  await nextTick();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+}
+function syncInitRawDataSnapshot(doc) {
+  doc.docRuntimeMeta.handleInfo.initRawDataSnapshot = cloneDeep(doc.dataManager.getRawData());
+}
 function snapshotDocInfo(docInst) {
   return {
     pages: docInst?.pages ?? [],
@@ -98198,6 +100150,7 @@ async function initializeDocumentEngine(props, payload, result) {
   const { id, requestInfo, fillModeType, paramsConfig } = result;
   const mainModelKey = requestInfo.modelKey || payload.modelKey || "";
   const materialNo = paramsConfig?.materialNo || requestInfo.materialNo;
+  await payload.ctx.runtime.ensureModelFieldsReady(mainModelKey);
   await addSubModelsToFieldScope(mainModelKey, payload.ctx);
   const masterSlaveList = payload.ctx.runtime.getMasterSlaveFieldList(mainModelKey);
   const cloneRuntimeJson = cloneDeep(JSON.parse(requestInfo.runtimeJson || "{}"));
@@ -98252,7 +100205,7 @@ async function initializeDocumentEngine(props, payload, result) {
   const rawData = conversionFormState({
     masterSlaveList,
     interfaceData,
-    instances
+    subTableInfoList: docModel.getSubTableInfoList() ?? []
   });
   const docRuntimeMeta = {
     ...requestInfo,
@@ -98279,7 +100232,8 @@ async function initializeDocumentEngine(props, payload, result) {
   });
   doc.dataManager.setRawData(rawData, defaultDataMap);
   doc.dataManager.applyInitData({ ...paramMap, ...dsMap });
-  doc.docRuntimeMeta.handleInfo.initRawDataSnapshot = cloneDeep(doc.dataManager.getRawData());
+  await waitForDataManagerSettle();
+  syncInitRawDataSnapshot(doc);
   const docInfo = snapshotDocInfo(doc);
   return {
     doc,
@@ -98290,7 +100244,8 @@ async function finalizeDesignModelImport(doc, docModel) {
   doc.setModel(docModel);
   const mainModelKey = doc.mainModelKey;
   doc.dataManager.setRawData({}, {});
-  doc.docRuntimeMeta.handleInfo.initRawDataSnapshot = cloneDeep(doc.dataManager.getRawData());
+  await waitForDataManagerSettle();
+  syncInitRawDataSnapshot(doc);
   doc.commandManager.undoStack.length = 0;
   doc.commandManager.redoStack.length = 0;
   doc.eventManager.cursorController.clearCursor();
@@ -98353,6 +100308,7 @@ function useDocumentFactory(props, payload) {
   watch(
     () => finisher.value,
     () => {
+      if (!docIns.value) return;
       console.log("Document request success");
       payload.onDocumentLoadSuccess?.();
     }
@@ -98388,6 +100344,7 @@ function useDocumentFactory(props, payload) {
       } = freshExecute;
       const mainModelKey = requestInfo.modelKey || payload.modelKey || "";
       const materialNo = paramsConfig?.materialNo || props.materialNo;
+      await payload.ctx.runtime.ensureModelFieldsReady(mainModelKey);
       const masterSlaveList = payload.ctx.runtime.getMasterSlaveFieldList(mainModelKey);
       const instances = doc.model?.getWidgetInstances() ?? [];
       const { initDocModelJson } = doc.docRuntimeMeta.handleInfo;
@@ -98416,13 +100373,13 @@ function useDocumentFactory(props, payload) {
       const rawData = conversionFormState({
         masterSlaveList,
         interfaceData,
-        instances
+        subTableInfoList: doc.model?.getSubTableInfoList() ?? []
       });
       doc.dataManager.setRawData(rawData);
-      await nextTick();
-      doc.docRuntimeMeta.handleInfo.initRawDataSnapshot = cloneDeep(doc.dataManager.getRawData());
+      await waitForDataManagerSettle();
+      syncInitRawDataSnapshot(doc);
     } finally {
-      await new Promise((resolve) => setTimeout(resolve, 0));
+      await waitForDataManagerSettle();
       isRefreshingData.value = false;
       doc.eventManager.cursorController.clearCursor();
     }
@@ -98888,6 +100845,13 @@ class SuiteRuntime {
   getModel(modelKey) {
     return this.modelService.getModelSync(modelKey);
   }
+  /**
+   * 确保主模型字段已拉取并写入缓存（避免 preload 与文档 immediate 加载竞态）。
+   */
+  async ensureModelFieldsReady(modelKey) {
+    if (!modelKey) return;
+    await this.loadFieldList(modelKey);
+  }
   getMasterSlaveFieldList(modelKey) {
     return this.fieldService.getFieldList(modelKey)?.filter((i) => i.type === FIELD_TYPE.MASTERSLAVE) || [];
   }
@@ -103364,7 +105328,8 @@ const _sfc_main$2y = /* @__PURE__ */ defineComponent({
     };
     const copyRow = () => {
       const { path: path2, index: index2 } = getCtx();
-      const data = props.doc.dataManager.get(`${path2}[${index2}]`) || {};
+      const storageIndex = props.doc.dataManager.resolveSubtableVisibleIndex(path2, index2);
+      const data = props.doc.dataManager.get(`${path2}[${storageIndex}]`) || {};
       props.doc.dataManager.insertAt(path2, index2 + 1, data);
     };
     const actionHandlers = {
@@ -103506,7 +105471,7 @@ const _sfc_main$2y = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const SubTableAction = /* @__PURE__ */ _export_sfc(_sfc_main$2y, [["__scopeId", "data-v-a58c6b2e"]]);
+const SubTableAction = /* @__PURE__ */ _export_sfc(_sfc_main$2y, [["__scopeId", "data-v-da25771b"]]);
 const _sfc_main$2x = /* @__PURE__ */ defineComponent({
   __name: "index",
   props: {
@@ -103889,9 +105854,6 @@ function rowKey(row, fallbackIndex) {
   }
   return `idx:${fallbackIndex}`;
 }
-function normalizeFormData(data) {
-  return getSubmitFormData(data || {});
-}
 function getFieldMeta(metaMap, runtimePath) {
   if (!metaMap) return {};
   return metaMap.get(runtimePath) || {};
@@ -103991,8 +105953,8 @@ function buildWidgetFieldMetaMap(instances) {
   return map;
 }
 function buildFieldChangeList(params) {
-  const baseline = normalizeFormData(params.baselineData);
-  const current = normalizeFormData(params.currentData);
+  const baseline = getSubmitFormData(params.baselineData || {}, params.subTableInfoList);
+  const current = getSubmitFormData(params.currentData || {}, params.subTableInfoList);
   const changeList = [];
   const keys2 = /* @__PURE__ */ new Set([...Object.keys(baseline || {}), ...Object.keys(current || {})]);
   for (const fieldKey of keys2) {
@@ -104091,8 +106053,9 @@ function useDocOperations(docRef) {
     const baselineSnapshot = doc.dataManager.getRawData();
     const instances = doc.getWidgetInstances() ?? [];
     const widgetMetaMap = buildWidgetFieldMetaMap(instances);
+    const subTableInfoList = doc.model?.getSubTableInfoList() ?? [];
     doc.setMode(DocModeTypeConst.Fill);
-    return { baselineSnapshot, widgetMetaMap };
+    return { baselineSnapshot, widgetMetaMap, subTableInfoList };
   }
   async function computeBaselineChanges(ctx) {
     await Promise.resolve();
@@ -104104,7 +106067,8 @@ function useDocOperations(docRef) {
     return buildFieldChangeList({
       baselineData: ctx.baselineSnapshot,
       currentData,
-      widgetMetaMap: ctx.widgetMetaMap
+      widgetMetaMap: ctx.widgetMetaMap,
+      subTableInfoList: ctx.subTableInfoList
     });
   }
   function setAnnotation(ids, list) {
@@ -104203,6 +106167,13 @@ function useDocController(factory2, ops) {
         rawData() {
           return doc.dataManager.getRawData();
         },
+        getSubmitFormData(formData) {
+          const subTableInfoList = doc.model?.getSubTableInfoList() ?? [];
+          return getSubmitFormData(
+            formData ?? doc.dataManager.getRawData(),
+            subTableInfoList
+          );
+        },
         setRawData(data, defaultDataMap) {
           doc.dataManager.setRawData(data, defaultDataMap);
         },
@@ -104308,9 +106279,14 @@ function useDocLooperAutoSaveNotify(factory2, ops, options) {
   }
   function releaseSuppressOnLoad() {
     cancelFlushNotify();
-    Promise.resolve().then(() => {
+    void (async () => {
+      await waitForDataManagerSettle();
+      const doc = factory2.docIns.value;
+      if (doc) {
+        syncInitRawDataSnapshot(doc);
+      }
       suppress = false;
-    });
+    })();
   }
   if (options.suppressSignal) {
     watch(
@@ -111134,10 +113110,10 @@ const _sfc_main$1X = /* @__PURE__ */ defineComponent({
       get() {
         if (docInst.value.isInEditMode()) {
           const value2 = docInst.value?.dataManager?.getDefault(runtimeValuePath.value);
-          return getValue$1(value2, isMultiple.value);
+          return toBoolean(getValue$1(value2, isMultiple.value));
         }
         const value = docInst.value?.dataManager?.get(runtimeValuePath.value);
-        return getValue$1(value, isMultiple.value);
+        return toBoolean(getValue$1(value, isMultiple.value));
       },
       set(v) {
         const data = setValue(v, runtimeValuePath.value, {
@@ -122331,8 +124307,8 @@ const edhrSuitePlugin = {
   key: SUITE_KEY,
   install: installEdhrSuite
 };
-function registerSuite(plugin) {
-  plugin.install();
+function registerSuite(plugin2) {
+  plugin2.install();
 }
 const _hoisted_1$e = { class: "options-dropdown" };
 const _hoisted_2$9 = { class: "options-search" };
@@ -124852,7 +126828,6 @@ export {
   GctLayout,
   PageSizeEnumConst,
   edhrSuitePlugin,
-  getSubmitFormData,
   registerSuite,
   setupPlatformAdapters,
   setupVueRuntime,