@vdhewei/xlsx-template-lib 1.2.1

package/dist/index.mjs

@@ -0,0 +1,3941 @@
+// src/core.ts
+import * as path from "path";
+import * as fs from "fs";
+import * as etree from "elementtree";
+import JsZip from "jszip";
+import * as console from "console";
+import { imageSize as sizeOf } from "image-size";
+import { isMap } from "util/types";
+var DOCUMENT_RELATIONSHIP = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+var CALC_CHAIN_RELATIONSHIP = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/calcChain";
+var SHARED_STRINGS_RELATIONSHIP = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings";
+var HYPERLINK_RELATIONSHIP = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+var BufferType = /* @__PURE__ */ ((BufferType2) => {
+  BufferType2["Base64"] = "base64";
+  BufferType2["String"] = "string";
+  BufferType2["Text"] = "text";
+  BufferType2["Blob"] = "blob";
+  BufferType2["Array"] = "array";
+  BufferType2["NodeBuffer"] = "nodebuffer";
+  BufferType2["Uint8array"] = "uint8array";
+  BufferType2["Arraybuffer"] = "arraybuffer";
+  BufferType2["BinaryString"] = "binarystring";
+  return BufferType2;
+})(BufferType || {});
+function _getSimple(obj, key) {
+  if (key.includes("[")) {
+    const parts = key.split(/[\[\]]/);
+    const property = parts[0];
+    const index = parts[1];
+    if (property && index !== void 0) {
+      return obj?.[property]?.[index];
+    }
+  }
+  if (isMap(obj)) {
+    return obj.get(key);
+  }
+  return obj?.[key];
+}
+function valueDotGet(obj, path2, defaultValue) {
+  if (!path2 || !obj) return defaultValue;
+  const keys = path2.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0) return defaultValue;
+    current = _getSimple(current, key);
+  }
+  return current === void 0 ? defaultValue : current;
+}
+function defaultValueDotGet(obj, p) {
+  return valueDotGet(obj, p.name, p.default || "");
+}
+var dateFormatter = (value, _placeholder, _key) => {
+  if (value instanceof Date) {
+    return Number(value.getTime() / (1e3 * 60 * 60 * 24) + 25569).toString();
+  }
+  return void 0;
+};
+var numberFormatter = (value, _placeholder, _key) => {
+  if (typeof value === "number") {
+    return value.toString();
+  }
+  return void 0;
+};
+var booleanFormatter = (value, _placeholder, _key) => {
+  if (typeof value === "boolean") {
+    return Number(value).toString();
+  }
+  return void 0;
+};
+var stringFormatter = (value, _placeholder, _key) => {
+  if (typeof value === "string") {
+    return value.toString();
+  }
+  return void 0;
+};
+var defaultRe = /\${(?:([^{}:]+?):)?([^{}:]+?)(?:\.([^{}:]+?))?(?::([^{}:]+?))??}/g;
+var defaultExtractPlaceholders = (inputString, options) => {
+  const matches = [];
+  const re = options.customPlaceholderRegex || defaultRe;
+  if (options.enableDefaultParsing && options.customPlaceholderRegex) {
+    let match2;
+    while ((match2 = defaultRe.exec(inputString)) !== null) {
+      matches.push({
+        placeholder: match2[0],
+        type: match2[1] || "normal",
+        name: match2[2],
+        key: match2[3],
+        subType: match2[4],
+        full: match2[0].length === inputString.length
+      });
+    }
+  }
+  let match;
+  re.lastIndex = 0;
+  while ((match = re.exec(inputString)) !== null) {
+    if (options.enableDefaultParsing && options.customPlaceholderRegex) {
+      const isDuplicate = matches.some((m) => m.placeholder === match[0]);
+      if (isDuplicate) continue;
+    }
+    matches.push({
+      placeholder: match[0],
+      type: match[1] || "normal",
+      name: match[2],
+      key: match[3],
+      subType: match[4],
+      full: match[0].length === inputString.length
+    });
+  }
+  return matches;
+};
+var defaultFormatters = [
+  dateFormatter,
+  numberFormatter,
+  booleanFormatter,
+  stringFormatter
+];
+var pattern = new RegExp("^(https?:\\/\\/)?((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|((\\d{1,3}\\.){3}\\d{1,3}))(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*(\\?[;&a-z\\d%_.~+=-]*)?(\\#[-a-z\\d_]*)?$", "i");
+var isUrl = function(str) {
+  return !!pattern.test(str);
+};
+var toArrayBuffer = function(buffer) {
+  const ab = new ArrayBuffer(buffer.length);
+  const view = new Uint8Array(ab);
+  for (let i = 0; i < buffer.length; ++i) {
+    view[i] = buffer[i];
+  }
+  return ab;
+};
+var Workbook = class _Workbook {
+  // ==================== 构造函数 ====================
+  constructor(option) {
+    this.sharedStrings = [];
+    this.sharedStringsLookup = {};
+    this.sharedStringsPath = "";
+    this.sheets = [];
+    this.sheet = null;
+    this.workbook = null;
+    this.workbookPath = null;
+    this.contentTypes = null;
+    this.prefix = null;
+    this.workbookRels = null;
+    this.calChainRel = null;
+    this.calcChainPath = "";
+    // RichData 相关属性
+    this.richDataIsInit = false;
+    this._relsrichValueRel = null;
+    this.rdrichvalue = null;
+    this.rdrichvaluestructure = null;
+    this.rdRichValueTypes = null;
+    this.richValueRel = null;
+    this.metadata = null;
+    this.option = {
+      moveImages: false,
+      substituteAllTableRow: false,
+      moveSameLineImages: false,
+      imageRatio: 100,
+      pushDownPageBreakOnTableSubstitution: false,
+      imageRootPath: null,
+      handleImageError: null,
+      ...option
+    };
+  }
+  // ==================== parse 构造函数 ====================
+  static async parse(data, option) {
+    const w = new _Workbook(option);
+    await w.loadTemplate(data);
+    return w;
+  }
+  // ==================== 扩展方法 ====================
+  /**
+   * 添加自定义替换器
+   * @param replacer - 替换函数
+   * @returns this（支持链式调用）
+   */
+  addReplacer(replacer) {
+    if (!this.option.replacers) {
+      this.option.replacers = [];
+    }
+    this.option.replacers.push(replacer);
+    return this;
+  }
+  /**
+   * 添加自定义格式化器
+   * @param formatter - 格式化函数
+   * @returns this（支持链式调用）
+   */
+  addFormatter(formatter) {
+    if (!this.option.formatters) {
+      this.option.formatters = [];
+    }
+    this.option.formatters.push(formatter);
+    return this;
+  }
+  /**
+   * 设置替换前钩子
+   * @param hook - 钩子函数
+   * @returns this（支持链式调用）
+   */
+  setBeforeReplaceHook(hook) {
+    this.option.beforeReplace = hook;
+    return this;
+  }
+  /**
+   * 设置替换后钩子
+   * @param hook - 钩子函数
+   * @returns this（支持链式调用）
+   */
+  setAfterReplaceHook(hook) {
+    this.option.afterReplace = hook;
+    return this;
+  }
+  /**
+   * 设置自定义占位符提取器
+   * @param extractor - 提取函数
+   * @returns this（支持链式调用）
+   */
+  setPlaceholderExtractor(extractor) {
+    this.option.customPlaceholderExtractor = extractor;
+    return this;
+  }
+  /**
+   * 设置自定义模板正则表达式
+   * @param regex - 正则表达式
+   * @param enableDefaultParsing - 是否同时启用默认解析，默认 false
+   * @returns this（支持链式调用）
+   */
+  setPlaceholderRegex(regex, enableDefaultParsing = false) {
+    this.option.customPlaceholderRegex = regex;
+    this.option.enableDefaultParsing = enableDefaultParsing;
+    return this;
+  }
+  /**
+   * 设置数值查询器
+   * @param h QueryFunction - 设置数值查询器
+   * @returns this（支持链式调用）
+   */
+  setQueryFunctionHandler(h) {
+    this.option.customQueryFunction = h;
+    return this;
+  }
+  // ==================== 扩展点执行方法 ====================
+  /**
+   * 执行自定义替换器链
+   * @param cell - 单元格元素
+   * @param stringValue - 字符串值
+   * @param placeholder - 占位符信息
+   * @param substitution - 替换值
+   * @returns 替换结果或 undefined
+   */
+  executeReplacers(cell, stringValue, placeholder, substitution) {
+    if (this.option.customReplacer) {
+      const result = this.option.customReplacer(cell, stringValue, placeholder, substitution);
+      if (result !== void 0 && result !== null) {
+        return result;
+      }
+    }
+    if (this.option.replacers && this.option.replacers.length > 0) {
+      for (const replacer of this.option.replacers) {
+        const result = replacer(cell, stringValue, placeholder, substitution);
+        if (result !== void 0 && result !== null) {
+          return result;
+        }
+      }
+    }
+    return void 0;
+  }
+  /**
+   * 执行格式化器链
+   * @param value - 原始值
+   * @param placeholder - 占位符信息
+   * @param key - 可选键名
+   * @returns 格式化后的字符串
+   */
+  executeFormatters(value, placeholder, key) {
+    if (this.option.formatters && this.option.formatters.length > 0) {
+      for (const formatter of this.option.formatters) {
+        const result = formatter(value, placeholder, key);
+        if (result !== void 0 && result !== null) {
+          return result;
+        }
+      }
+    }
+    for (const formatter of defaultFormatters) {
+      const result = formatter(value, placeholder, key);
+      if (result !== void 0 && result !== null) {
+        return result;
+      }
+    }
+    return "";
+  }
+  /**
+   * 执行替换前钩子
+   */
+  executeBeforeReplaceHook(stringValue, substitutions) {
+    if (this.option.beforeReplace) {
+      const result = this.option.beforeReplace(stringValue, substitutions);
+      if (result !== void 0 && result !== null) {
+        return result;
+      }
+    }
+    return stringValue;
+  }
+  /**
+   * 执行替换后钩子
+   */
+  executeAfterReplaceHook(resultString, stringValue, substitutions) {
+    if (this.option.afterReplace) {
+      return this.option.afterReplace(resultString, stringValue, substitutions);
+    }
+    return resultString;
+  }
+  // ==================== 核心方法 ====================
+  /**
+   * 删除工作表
+   */
+  async deleteSheet(sheetName) {
+    const sheet = await this.loadSheet(sheetName);
+    const sh = this.workbook.find(`sheets/sheet[@sheetId='${sheet.id}']`);
+    const sheets = this.workbook.findall("sheets/sheet");
+    const sheetIndex = sheets.indexOf(sh);
+    const definedNamesParent = this.workbook.find("definedNames");
+    if (definedNamesParent) {
+      const toRemove = [];
+      this.workbook.findall("definedNames/definedName").forEach((def) => {
+        if (def.attrib.localSheetId !== void 0) {
+          const localId = parseInt(def.attrib.localSheetId);
+          if (localId === sheetIndex) {
+            toRemove.push(def);
+          } else if (localId > sheetIndex) {
+            def.attrib.localSheetId = (localId - 1).toString();
+          }
+        }
+      });
+      toRemove.forEach((def) => {
+        definedNamesParent.remove(def);
+      });
+    }
+    this.workbook.find("sheets").remove(sh);
+    const rel = this.workbookRels.find(`Relationship[@Id='${sh.attrib["r:id"]}']`);
+    this.workbookRels.remove(rel);
+    this._rebuild();
+    return this;
+  }
+  /**
+   * 复制工作表
+   */
+  async copySheet(sheetName, copyName, binary = true) {
+    if (binary === false && !process.env.JEST_WORKER_ID) {
+      console.warn("Warning: copySheet() called with binary=false. UTF-8 characters may be corrupted.");
+    }
+    const sheet = await this.loadSheet(sheetName);
+    const newSheetIndex = (this.workbook.findall("sheets/sheet").length + 1).toString();
+    const fileName = "worksheets/sheet" + newSheetIndex + ".xml";
+    const arcName = this.prefix + "/" + fileName;
+    const sourceSheetFile = this.archive.file(sheet.filename);
+    let sheetContent = await sourceSheetFile.async(`nodebuffer`);
+    this.archive.file(arcName, sheetContent);
+    this.archive.files[arcName].options.compression = binary ? "STORE" : "DEFLATE";
+    const sheetContentType = etree.SubElement(this.contentTypes, "Override");
+    sheetContentType.attrib.PartName = "/" + arcName;
+    sheetContentType.attrib.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml";
+    const newSheet = etree.SubElement(this.workbook.find("sheets"), "sheet");
+    const finalSheetName = copyName || "Sheet" + newSheetIndex;
+    newSheet.attrib.name = finalSheetName;
+    newSheet.attrib.sheetId = newSheetIndex;
+    newSheet.attrib["r:id"] = "rId" + newSheetIndex;
+    this.workbook.findall("definedNames/definedName").forEach((element) => {
+      if (element.text && element.text.split("!").length && element.text.split("!")[0] == sheetName) {
+        const newDefinedName = etree.SubElement(this.workbook.find("definedNames"), "definedName", element.attrib);
+        newDefinedName.text = finalSheetName + "!" + element.text.split("!")[1];
+        const index = Number.parseInt(newSheetIndex, 10) - 1;
+        newDefinedName.attrib.localSheetId = `${index}`;
+      }
+    });
+    const newRel = etree.SubElement(this.workbookRels, "Relationship");
+    newRel.attrib.Type = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet";
+    newRel.attrib.Target = fileName;
+    const sourceRels = await this.loadSheetRels(sheet.filename);
+    const relFileName = "worksheets/_rels/sheet" + newSheetIndex + ".xml.rels";
+    const relArcName = this.prefix + "/" + relFileName;
+    const newRelsRoot = this.cloneElement(sourceRels.root, true);
+    const newCommentUuid = this.generateUUID();
+    sourceRels.root.findall("Relationship").forEach((rel, index) => {
+      const relType = rel.attrib.Type;
+      const target = rel.attrib.Target;
+      const needsFileCopy = [
+        "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",
+        "http://schemas.microsoft.com/office/2017/10/relationships/threadedComment",
+        "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing"
+      ];
+      if (needsFileCopy.indexOf(relType) !== -1) {
+        const sheetDirectory = path.dirname(sheet.filename);
+        const sourceFilePath = path.join(sheetDirectory, target).replace(/\\/g, "/");
+        const sourceFile = this.archive.file(sourceFilePath);
+        if (sourceFile) {
+          const fileExtension = path.extname(target);
+          const fileBaseName = path.basename(target, fileExtension);
+          const fileDir = path.dirname(target);
+          const baseNameWithoutNumber = fileBaseName.replace(/\d+$/, "");
+          const newFileName = baseNameWithoutNumber + newSheetIndex + fileExtension;
+          const newTarget = path.join(fileDir, newFileName).replace(/\\/g, "/");
+          const newFilePath = path.join(sheetDirectory, newTarget).replace(/\\/g, "/");
+          const content = sourceFile.async(`string`);
+          content.then((binaryContent) => {
+            if (relType === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing") {
+              binaryContent = binaryContent.replace(/data="\d+"/, 'data="' + newSheetIndex + '"');
+            } else if (relType === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments") {
+              const uuidWithoutBraces = newCommentUuid.replace(/[{}]/g, "");
+              binaryContent = binaryContent.replace(/(<author>tc=\{)[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}(\}<\/author>)/gi, "$1" + uuidWithoutBraces + "$2");
+              binaryContent = binaryContent.replace(/(xr:uid="\{)[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}(\}\")/gi, "$1" + uuidWithoutBraces + "$2");
+              const commentsContentType = etree.SubElement(this.contentTypes, "Override");
+              commentsContentType.attrib.PartName = "/" + newFilePath;
+              commentsContentType.attrib.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml";
+            } else if (relType === "http://schemas.microsoft.com/office/2017/10/relationships/threadedComment") {
+              const uuidWithoutBraces = newCommentUuid.replace(/[{}]/g, "");
+              binaryContent = binaryContent.replace(/(\sid="\{)[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}(\}")/gi, "$1" + uuidWithoutBraces + "$2");
+              const threadedCommentContentType = etree.SubElement(this.contentTypes, "Override");
+              threadedCommentContentType.attrib.PartName = "/" + newFilePath;
+              threadedCommentContentType.attrib.ContentType = "application/vnd.ms-excel.threadedcomments+xml";
+            }
+            this.archive.file(newFilePath, binaryContent);
+            this.archive.files[newFilePath].options.compression = binary ? "STORE" : "DEFLATE";
+            const newRelInRels = newRelsRoot.findall("Relationship")[index];
+            if (newRelInRels) {
+              newRelInRels.attrib.Target = newTarget;
+            }
+          }).catch((err) => {
+            console.log(err);
+          });
+        }
+      }
+    });
+    this.archive.file(relArcName, etree.tostring(newRelsRoot, { encoding: "utf-8" }));
+    this.archive.files[relArcName].options.compression = binary ? "STORE" : "DEFLATE";
+    this.archive.file("[Content_Types].xml", etree.tostring(this.contentTypes, { encoding: "utf-8" }));
+    this._rebuild();
+    return this;
+  }
+  /**
+   * 部分重建（复制/删除工作表后）
+   */
+  _rebuild() {
+    const order = ["worksheet", "theme", "styles", "sharedStrings"];
+    this.workbookRels.findall("*").sort((rel1, rel2) => {
+      const index1 = order.indexOf(path.basename(rel1.attrib.Type));
+      const index2 = order.indexOf(path.basename(rel2.attrib.Type));
+      if (index1 < 0 && index2 >= 0) return 1;
+      if (index1 >= 0 && index2 < 0) return -1;
+      if (index1 < 0 && index2 < 0) return 0;
+      if (index1 + index2 === 0) {
+        if (rel1.attrib.Id && rel2.attrib.Id) {
+          return rel1.attrib.Id.substring(3) - rel2.attrib.Id.substring(3);
+        }
+        return rel1._id - rel2._id;
+      }
+      return index1 - index2;
+    }).forEach((item, index) => {
+      item.attrib.Id = "rId" + (index + 1);
+    });
+    this.workbook.findall("sheets/sheet").forEach((item, index) => {
+      item.attrib["r:id"] = "rId" + (index + 1);
+      item.attrib.sheetId = (index + 1).toString();
+    });
+    this.archive.file(
+      this.prefix + "/_rels/" + path.basename(this.workbookPath) + ".rels",
+      etree.tostring(this.workbookRels, { encoding: "utf-8" })
+    );
+    this.archive.file(this.workbookPath, etree.tostring(this.workbook, { encoding: "utf-8" }));
+    this.sheets = this.loadSheets(this.prefix, this.workbook, this.workbookRels);
+  }
+  /**
+   * 从字节数组加载 .xlsx 文件
+   */
+  async loadTemplate(data) {
+    if (Buffer.isBuffer(data)) {
+      data = data.toString("binary");
+    }
+    this.archive = await JsZip.loadAsync(data, { base64: false, checkCRC32: true });
+    const text = await this.archive.file("_rels/.rels").async("string");
+    const rels = etree.parse(text).getroot();
+    const workbookPath = rels.find(`Relationship[@Type='${DOCUMENT_RELATIONSHIP}']`).attrib.Target;
+    this.workbookPath = workbookPath;
+    this.prefix = path.dirname(workbookPath);
+    const workbookText = await this.archive.file(workbookPath).async(`string`);
+    this.workbook = etree.parse(workbookText).getroot();
+    const refText = await this.archive.file(this.prefix + "/_rels/" + path.basename(workbookPath) + ".rels").async(`string`);
+    this.workbookRels = etree.parse(refText).getroot();
+    this.sheets = this.loadSheets(this.prefix, this.workbook, this.workbookRels);
+    this.calChainRel = this.workbookRels.find(`Relationship[@Type='${CALC_CHAIN_RELATIONSHIP}']`);
+    if (this.calChainRel) {
+      this.calcChainPath = this.prefix + "/" + this.calChainRel.attrib.Target;
+    }
+    this.sharedStringsPath = this.prefix + "/" + this.workbookRels.find(`Relationship[@Type='${SHARED_STRINGS_RELATIONSHIP}']`).attrib.Target;
+    this.sharedStrings = [];
+    this.sharedStringsLookup = {};
+    const sharedText = await this.archive.file(this.sharedStringsPath).async(`string`);
+    etree.parse(sharedText).getroot().findall("si").forEach((si) => {
+      const t = { text: "" };
+      si.findall("t").forEach((tmp) => {
+        t.text += tmp.text;
+      });
+      si.findall("r/t").forEach((tmp) => {
+        t.text += tmp.text;
+      });
+      this.sharedStrings.push(t.text);
+      this.sharedStringsLookup[t.text] = this.sharedStrings.length - 1;
+    });
+    const contentTypeText = await this.archive.file("[Content_Types].xml").async(`string`);
+    this.contentTypes = etree.parse(contentTypeText).getroot();
+    const jpgType = this.contentTypes.find('Default[@Extension="jpg"]');
+    if (jpgType === null) {
+      etree.SubElement(this.contentTypes, "Default", { "ContentType": "image/png", "Extension": "jpg" });
+    }
+  }
+  /**
+   * 使用给定的替换数据对所有工作表进行插值
+   */
+  async substituteAll(substitutions) {
+    const sheets = this.loadSheets(this.prefix, this.workbook, this.workbookRels);
+    for (let sheet of sheets) {
+      await this.substitute(sheet.id, substitutions);
+    }
+  }
+  /**
+   * 使用给定的替换数据对指定工作表进行插值
+   */
+  async substitute(sheetName, substitutions) {
+    const sheet = await this.loadSheet(sheetName);
+    this.sheet = sheet;
+    const dimension = sheet.root.find("dimension");
+    const sheetData = sheet.root.find("sheetData");
+    let currentRow = null;
+    let totalRowsInserted = 0;
+    let totalColumnsInserted = 0;
+    const namedTables = await this.loadTables(sheet.root, sheet.filename);
+    const rows = [];
+    let drawing = null;
+    const rels = await this.loadSheetRels(sheet.filename);
+    for (let row of sheetData.findall("row")) {
+      currentRow = this.getCurrentRow(row, totalRowsInserted);
+      row.attrib.r = `${currentRow}`;
+      rows.push(row);
+      let cells = [];
+      let cellsInserted = 0;
+      const newTableRows = [];
+      const cellsSubstituteTable = [];
+      for (let cell of row.findall("c")) {
+        let appendCell = true;
+        cell.attrib.r = this.getCurrentCell(cell, currentRow, cellsInserted);
+        if (cell.attrib.t === "s") {
+          const cellValue = cell.find("v");
+          const stringIndex = parseInt(cellValue.text.toString(), 10);
+          let strValue = this.sharedStrings[stringIndex];
+          if (strValue === void 0) {
+            break;
+          }
+          strValue = this.executeBeforeReplaceHook(strValue, substitutions);
+          for (let placeholder of this.extractPlaceholders(strValue)) {
+            let newCellsInserted = 0;
+            let substitution = this.valueGet(substitutions, placeholder);
+            const customResult = this.executeReplacers(cell, strValue, placeholder, substitution);
+            if (customResult !== void 0) {
+              strValue = customResult;
+              return;
+            }
+            if (placeholder.full && placeholder.type === "table" && substitution instanceof Array) {
+              if (placeholder.subType === "image" && drawing == null) {
+                if (rels) {
+                  drawing = await this.loadDrawing(sheet.root, sheet.filename, rels.root);
+                } else {
+                  console.log("Need to implement initRels. Or init this with Excel");
+                }
+              }
+              cellsSubstituteTable.push(cell);
+              newCellsInserted = await this.substituteTable(
+                row,
+                newTableRows,
+                cells,
+                cell,
+                namedTables,
+                substitution,
+                placeholder,
+                drawing
+              );
+              if (newCellsInserted !== 0 || substitution.length) {
+                if (substitution.length === 1) {
+                  appendCell = true;
+                }
+                if (substitution[0][placeholder.key] instanceof Array) {
+                  appendCell = false;
+                }
+              }
+              if (newCellsInserted !== 0) {
+                cellsInserted += newCellsInserted;
+                this.pushRight(this.workbook, sheet.root, cell.attrib.r, newCellsInserted);
+              }
+            }
+            if (placeholder.full && placeholder.type === "normal" && substitution instanceof Array) {
+              appendCell = false;
+              newCellsInserted = this.substituteArray(cells, cell, substitution);
+              if (newCellsInserted !== 0) {
+                cellsInserted += newCellsInserted;
+                this.pushRight(this.workbook, sheet.root, cell.attrib.r, newCellsInserted);
+              }
+            }
+            if (placeholder.type === "image" && placeholder.full) {
+              if (rels != null) {
+                if (drawing == null) {
+                  drawing = await this.loadDrawing(sheet.root, sheet.filename, rels.root);
+                }
+                this.substituteImage(cell, strValue, placeholder, substitution, drawing);
+              } else {
+                console.log("Need to implement initRels. Or init this with Excel");
+              }
+            }
+            if (placeholder.type === "imageincell" && placeholder.full) {
+              await this.substituteImageInCell(cell, substitution);
+            } else {
+              if (placeholder.key) {
+                substitution = this.valueGet(substitutions, placeholder, true);
+              }
+              strValue = this.substituteScalar(cell, strValue, placeholder, substitution);
+            }
+          }
+          strValue = this.executeAfterReplaceHook(strValue, strValue, substitutions);
+        }
+        if (appendCell) {
+          cells.push(cell);
+        }
+      }
+      this.replaceChildren(row, cells);
+      if (cellsInserted !== 0) {
+        this.updateRowSpan(row, cellsInserted);
+        if (cellsInserted > totalColumnsInserted) {
+          totalColumnsInserted = cellsInserted;
+        }
+      }
+      if (newTableRows.length > 0) {
+        if (this.option["moveImages"] && rels) {
+          if (drawing == null) {
+            drawing = await this.loadDrawing(sheet.root, sheet.filename, rels.root);
+          }
+          if (drawing != null) {
+            this.moveAllImages(drawing, row.attrib.r, newTableRows.length);
+          }
+        }
+        const cellsOverTable = row.findall("c").filter(
+          (cell) => !cellsSubstituteTable.includes(cell)
+        );
+        newTableRows.forEach((newRow) => {
+          if (this.option && this.option.substituteAllTableRow) {
+            cellsOverTable.forEach((cellOverTable) => {
+              const newCell = this.cloneElement(cellOverTable);
+              newCell.attrib.r = this.joinRef({
+                row: newRow.attrib.r,
+                col: this.splitRef(newCell.attrib.r).col
+              });
+              newRow.append(newCell);
+            });
+            const newSortRow = newRow.findall("c").sort((a, b) => {
+              const colA = this.splitRef(a.attrib.r).col;
+              const colB = this.splitRef(b.attrib.r).col;
+              return this.charToNum(colA) - this.charToNum(colB);
+            });
+            this.replaceChildren(newRow, newSortRow);
+          }
+          rows.push(newRow);
+          ++totalRowsInserted;
+        });
+        this.pushDown(this.workbook, sheet.root, namedTables, currentRow, newTableRows.length);
+      }
+    }
+    this.replaceChildren(sheetData, rows);
+    this.substituteTableColumnHeaders(namedTables, substitutions);
+    this.substituteHyperlinks(rels, substitutions);
+    if (dimension) {
+      if (totalRowsInserted > 0 || totalColumnsInserted > 0) {
+        const dimensionRange = this.splitRange(dimension.attrib.ref);
+        const dimensionEndRef = this.splitRef(dimensionRange.end);
+        dimensionEndRef.row += totalRowsInserted;
+        dimensionEndRef.col = this.numToChar(this.charToNum(dimensionEndRef.col) + totalColumnsInserted);
+        dimensionRange.end = this.joinRef(dimensionEndRef);
+        dimension.attrib.ref = this.joinRange(dimensionRange);
+      }
+    }
+    sheetData.findall("row").forEach((row) => {
+      row.findall("c").forEach((cell) => {
+        const formulas = cell.findall("f");
+        if (formulas && formulas.length > 0) {
+          cell.findall("v").forEach((v) => {
+            cell.remove(v);
+          });
+        }
+      });
+    });
+    this.archive.file(sheet.filename, etree.tostring(sheet.root, { encoding: "utf-8" }));
+    this.archive.file(this.workbookPath, etree.tostring(this.workbook, { encoding: "utf-8" }));
+    if (rels) {
+      this.archive.file(rels.filename, etree.tostring(rels.root, { encoding: "utf-8" }));
+    }
+    this.writeRichData();
+    this.archive.file("[Content_Types].xml", etree.tostring(this.contentTypes, { encoding: "utf-8" }));
+    if (this.calcChainPath && this.archive.file(this.calcChainPath)) {
+      this.archive.remove(this.calcChainPath);
+    }
+    await this.writeSharedStrings();
+    this.writeTables(namedTables);
+    this.writeDrawing(drawing);
+  }
+  /**
+   * 生成新的二进制 .xlsx 文件
+   */
+  async generate(options) {
+    return await this.archive.generateAsync(options);
+  }
+  /**
+   *  查询占位符合数据值
+   * @param substitutions 数据对象
+   * @param p  占位符
+   * @param full  是否fullKey
+   * @return any
+   */
+  valueGet(substitutions, p, full) {
+    if (this.option.customQueryFunction === void 0) {
+      if (full !== void 0 && typeof full === "boolean" && full && p.key) {
+        return valueDotGet(substitutions, p.name + "." + p.key, p.default || "");
+      }
+      return valueDotGet(substitutions, p.name, p.default || "");
+    }
+    if (full !== void 0 && typeof full === "boolean" && full && p.key && !p.name.endsWith(`.${p.key}`)) {
+      p.name = p.name + "." + p.key;
+    }
+    return this.option.customQueryFunction(substitutions, p);
+  }
+  // ==================== 辅助方法 ====================
+  async writeSharedStrings() {
+    const content = await this.archive.file(this.sharedStringsPath).async("string");
+    const root = etree.parse(content).getroot();
+    const children = root.getchildren();
+    root.delSlice(0, children.length);
+    this.sharedStrings.forEach((string) => {
+      const si = etree.Element("si");
+      const t = etree.Element("t");
+      t.text = string;
+      si.append(t);
+      root.append(si);
+    });
+    root.attrib.count = `${this.sharedStrings.length}`;
+    root.attrib.uniqueCount = `${this.sharedStrings.length}`;
+    this.archive.file(this.sharedStringsPath, etree.tostring(root, { encoding: "utf-8" }));
+  }
+  addSharedString(s) {
+    const idx = this.sharedStrings.length;
+    this.sharedStrings.push(s);
+    this.sharedStringsLookup[s] = idx;
+    return idx;
+  }
+  stringIndex(s) {
+    let idx = this.sharedStringsLookup[s];
+    if (idx === void 0) {
+      idx = this.addSharedString(s);
+    }
+    return idx;
+  }
+  replaceString(oldString, newString) {
+    let idx = this.sharedStringsLookup[oldString];
+    if (idx === void 0) {
+      idx = this.addSharedString(newString);
+    } else {
+      this.sharedStrings[idx] = newString;
+      delete this.sharedStringsLookup[oldString];
+      this.sharedStringsLookup[newString] = idx;
+    }
+    return idx;
+  }
+  loadSheets(prefix, workbook, workbookRels) {
+    const sheets = [];
+    for (const sheet of workbook.findall("sheets/sheet")) {
+      const sheetId = sheet.attrib.sheetId;
+      const relId = sheet.attrib["r:id"];
+      const relationship = workbookRels.find(`Relationship[@Id='${relId}']`);
+      const filename = prefix + "/" + relationship.attrib.Target;
+      sheets.push({
+        root: sheet,
+        filename,
+        name: sheet.attrib.name,
+        id: parseInt(sheetId, 10)
+      });
+    }
+    return sheets;
+  }
+  async loadSheet(sheet) {
+    let info = null;
+    for (let i = 0; i < this.sheets.length; ++i) {
+      if (typeof sheet === "number" && this.sheets[i].id === sheet || this.sheets[i].name === sheet) {
+        info = this.sheets[i];
+        break;
+      }
+    }
+    if (info === null && typeof sheet === "number") {
+      info = this.sheets[sheet - 1];
+    }
+    if (info === null) {
+      throw new Error("Sheet " + sheet + " not found");
+    }
+    const content = await this.archive.file(info.filename).async("string");
+    return {
+      filename: info.filename,
+      name: info.name,
+      id: info.id,
+      root: etree.parse(content).getroot()
+    };
+  }
+  async loadSheetRels(sheetFilename) {
+    const sheetDirectory = path.dirname(sheetFilename);
+    const sheetName = path.basename(sheetFilename);
+    const relsFilename = path.join(sheetDirectory, "_rels", sheetName + ".rels").replace(/\\/g, "/");
+    const relsFile = this.archive.file(relsFilename);
+    if (relsFile === null) {
+      return this.initSheetRels(sheetFilename);
+    }
+    const content = await relsFile.async("string");
+    return {
+      filename: relsFilename,
+      root: etree.parse(content).getroot()
+    };
+  }
+  initSheetRels(sheetFilename) {
+    const sheetDirectory = path.dirname(sheetFilename);
+    const sheetName = path.basename(sheetFilename);
+    const relsFilename = path.join(sheetDirectory, "_rels", sheetName + ".rels").replace(/\\/g, "/");
+    const element = etree.Element;
+    const ElementTree2 = etree.ElementTree;
+    const root = element("Relationships");
+    root.set("xmlns", "http://schemas.openxmlformats.org/package/2006/relationships");
+    const relsEtree = new ElementTree2(root);
+    return {
+      filename: relsFilename,
+      root: relsEtree.getroot()
+    };
+  }
+  async loadDrawing(sheet, sheetFilename, rels) {
+    const sheetDirectory = path.dirname(sheetFilename);
+    const drawing = { filename: "", root: null };
+    const drawingPart = sheet.find("drawing");
+    if (drawingPart === null) {
+      return this.initDrawing(sheet, rels);
+    }
+    const relationshipId = drawingPart.attrib["r:id"];
+    const target = rels.find(`Relationship[@Id='${relationshipId}']`).attrib.Target;
+    const drawingFilename = path.join(sheetDirectory, target).replace(/\\/g, "/");
+    const drawContent = await this.archive.file(drawingFilename).async("string");
+    const drawingTree = etree.parse(drawContent);
+    drawing.filename = drawingFilename;
+    drawing.root = drawingTree.getroot();
+    drawing.relFilename = path.dirname(drawingFilename) + "/_rels/" + path.basename(drawingFilename) + ".rels";
+    const relFile = this.archive.file(drawing.relFilename);
+    if (relFile === null) {
+      drawing.relRoot = etree.Element("Relationships");
+      drawing.relRoot.set("xmlns", "http://schemas.openxmlformats.org/package/2006/relationships");
+    } else {
+      const relContent = await relFile.async("string");
+      drawing.relRoot = etree.parse(relContent).getroot();
+    }
+    return drawing;
+  }
+  addContentType(partName, contentType) {
+    etree.SubElement(this.contentTypes, "Override", { "ContentType": contentType, "PartName": partName });
+  }
+  initDrawing(sheet, rels) {
+    const maxId = this.findMaxId(rels, "Relationship", "Id", /rId(\d*)/);
+    const rel = etree.SubElement(rels, "Relationship");
+    sheet.insert(sheet._children.length, etree.Element("drawing", { "r:id": "rId" + maxId }));
+    rel.set("Id", "rId" + maxId);
+    rel.set("Type", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing");
+    const drawing = {};
+    const drawingFilename = "drawing" + this.findMaxFileId(/xl\/drawings\/drawing\d*\.xml/, /drawing(\d*)\.xml/) + ".xml";
+    rel.set("Target", "../drawings/" + drawingFilename);
+    drawing.root = etree.Element("xdr:wsDr");
+    drawing.root.set("xmlns:xdr", "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing");
+    drawing.root.set("xmlns:a", "http://schemas.openxmlformats.org/drawingml/2006/main");
+    drawing.filename = "xl/drawings/" + drawingFilename;
+    drawing.relFilename = "xl/drawings/_rels/" + drawingFilename + ".rels";
+    drawing.relRoot = etree.Element("Relationships");
+    drawing.relRoot.set("xmlns", "http://schemas.openxmlformats.org/package/2006/relationships");
+    this.addContentType("/" + drawing.filename, "application/vnd.openxmlformats-officedocument.drawing+xml");
+    return drawing;
+  }
+  writeDrawing(drawing) {
+    if (drawing !== null) {
+      this.archive.file(drawing.filename, etree.tostring(drawing.root, { encoding: "utf-8" }));
+      this.archive.file(drawing.relFilename, etree.tostring(drawing.relRoot, { encoding: "utf-8" }));
+    }
+  }
+  moveAllImages(drawing, fromRow, nbRow) {
+    drawing.root.getchildren().forEach((drawElement) => {
+      if (drawElement.tag == "xdr:twoCellAnchor") {
+        this._moveTwoCellAnchor(drawElement, fromRow, nbRow);
+      }
+    });
+  }
+  _moveTwoCellAnchor(drawingElement, fromRow, nbRow) {
+    const _moveImage = (drawingElement2, fromRow2, nbRow2) => {
+      let num;
+      if (typeof nbRow2 === "string") {
+        num = Number.parseInt(nbRow2, 10);
+      } else {
+        num = nbRow2;
+      }
+      drawingElement2.find("xdr:from").find("xdr:row").text = Number.parseInt(drawingElement2.find("xdr:from").find("xdr:row").text, 10) + num;
+      drawingElement2.find("xdr:to").find("xdr:row").text = Number.parseInt(drawingElement2.find("xdr:to").find("xdr:row").text, 10) + num;
+    };
+    if (this.option["moveSameLineImages"]) {
+      if (parseInt(drawingElement.find("xdr:from").find("xdr:row").text) + 1 >= parseInt(fromRow)) {
+        _moveImage(drawingElement, fromRow, nbRow);
+      }
+    } else {
+      if (parseInt(drawingElement.find("xdr:from").find("xdr:row").text) + 1 > parseInt(fromRow)) {
+        _moveImage(drawingElement, fromRow, nbRow);
+      }
+    }
+  }
+  async loadTables(sheet, sheetFilename) {
+    const sheetDirectory = path.dirname(sheetFilename);
+    const sheetName = path.basename(sheetFilename);
+    const relsFilename = sheetDirectory + "/_rels/" + sheetName + ".rels";
+    const relsFile = this.archive.file(relsFilename);
+    const tables = [];
+    if (relsFile === null) {
+      return tables;
+    }
+    const relsContent = await relsFile.async("string");
+    const rels = etree.parse(relsContent).getroot();
+    for (let tablePart of sheet.findall("tableParts/tablePart")) {
+      const relationshipId = tablePart.attrib["r:id"];
+      const target = rels.find(`Relationship[@Id='${relationshipId}']`).attrib.Target;
+      const tableFilename = target.replace("..", this.prefix);
+      const content = await this.archive.file(tableFilename).async("string");
+      const tableTree = etree.parse(content);
+      tables.push({
+        filename: tableFilename,
+        root: tableTree.getroot()
+      });
+    }
+    return tables;
+  }
+  writeTables(tables) {
+    tables.forEach((namedTable) => {
+      this.archive.file(namedTable.filename, etree.tostring(namedTable.root, { encoding: "utf-8" }));
+    });
+  }
+  substituteHyperlinks(rels, substitutions) {
+    if (rels === null) {
+      return;
+    }
+    const relationships = rels.root._children;
+    relationships.forEach((relationship) => {
+      if (relationship.attrib.Type === HYPERLINK_RELATIONSHIP) {
+        let target = relationship.attrib.Target;
+        target = decodeURI(decodeURI(target));
+        this.extractPlaceholders(target).forEach((placeholder) => {
+          const substitution = substitutions[placeholder.name];
+          if (substitution === void 0) {
+            return;
+          }
+          target = target.replace(placeholder.placeholder, this.stringify(substitution));
+          relationship.attrib.Target = encodeURI(target);
+        });
+      }
+    });
+  }
+  substituteTableColumnHeaders(tables, substitutions) {
+    tables.forEach((table) => {
+      const root = table.root;
+      const columns = root.find("tableColumns");
+      const autoFilter = root.find("autoFilter");
+      const tableRange = this.splitRange(root.attrib.ref);
+      let idx = 0;
+      let inserted = 0;
+      const newColumns = [];
+      columns.findall("tableColumn").forEach((col) => {
+        ++idx;
+        col.attrib.id = Number(idx).toString();
+        newColumns.push(col);
+        let name = col.attrib.name;
+        this.extractPlaceholders(name).forEach((placeholder) => {
+          const substitution = substitutions[placeholder.name];
+          if (substitution === void 0) {
+            return;
+          }
+          if (placeholder.full && placeholder.type === "normal" && substitution instanceof Array) {
+            substitution.forEach((element, i) => {
+              let newCol = col;
+              if (i > 0) {
+                newCol = this.cloneElement(newCol);
+                newCol.attrib.id = Number(++idx).toString();
+                newColumns.push(newCol);
+                ++inserted;
+                tableRange.end = this.nextCol(tableRange.end);
+              }
+              newCol.attrib.name = this.stringify(element);
+            });
+          } else {
+            name = name.replace(placeholder.placeholder, this.stringify(substitution));
+            col.attrib.name = name;
+          }
+        });
+      });
+      this.replaceChildren(columns, newColumns);
+      if (inserted > 0) {
+        columns.attrib.count = Number(idx).toString();
+        root.attrib.ref = this.joinRange(tableRange);
+        if (autoFilter !== null) {
+          autoFilter.attrib.ref = this.joinRange(tableRange);
+        }
+      }
+      const tableRoot = table.root;
+      const tableRange2 = this.splitRange(tableRoot.attrib.ref);
+      const tableStart = this.splitRef(tableRange2.start);
+      const tableEnd = this.splitRef(tableRange2.end);
+      if (tableRoot.attrib.totalsRowCount) {
+        const autoFilter2 = tableRoot.find("autoFilter");
+        if (autoFilter2 !== null) {
+          autoFilter2.attrib.ref = this.joinRange({
+            start: this.joinRef(tableStart),
+            end: this.joinRef(tableEnd)
+          });
+        }
+        ++tableEnd.row;
+        tableRoot.attrib.ref = this.joinRange({
+          start: this.joinRef(tableStart),
+          end: this.joinRef(tableEnd)
+        });
+      }
+    });
+  }
+  /**
+   * 提取字符串中可能存在的占位符标记
+   * 支持扩展：自定义正则表达式和自定义提取器
+   */
+  extractPlaceholders(inputString) {
+    if (this.option.customPlaceholderExtractor) {
+      return this.option.customPlaceholderExtractor(inputString, this.option);
+    }
+    return defaultExtractPlaceholders(inputString, this.option);
+  }
+  splitRef(ref) {
+    const match = ref.match(/(?:(.+)!)?(\$)?([A-Z]+)?(\$)?([0-9]+)/);
+    return {
+      table: match && match[1] || null,
+      colAbsolute: Boolean(match && match[2]),
+      col: match && match[3] || "",
+      rowAbsolute: Boolean(match && match[4]),
+      row: parseInt(match && match[5], 10)
+    };
+  }
+  joinRef(ref) {
+    return (ref.table ? ref.table + "!" : "") + (ref.colAbsolute ? "$" : "") + ref.col.toUpperCase() + (ref.rowAbsolute ? "$" : "") + Number(ref.row).toString();
+  }
+  nextCol(ref) {
+    ref = ref.toUpperCase();
+    return ref.replace(/[A-Z]+/, (match) => {
+      return this.numToChar(this.charToNum(match) + 1);
+    });
+  }
+  nextRow(ref) {
+    ref = ref.toUpperCase();
+    return ref.replace(/[0-9]+/, (match) => {
+      return (parseInt(match, 10) + 1).toString();
+    });
+  }
+  charToNum(str) {
+    let num = 0;
+    if (typeof str === "string") {
+      for (let idx = str.length - 1, iteration = 0; idx >= 0; --idx, ++iteration) {
+        const thisChar = str.charCodeAt(idx) - 64;
+        const multiplier = Math.pow(26, iteration);
+        num += multiplier * thisChar;
+      }
+    } else {
+      num = str;
+    }
+    return num;
+  }
+  numToChar(num) {
+    let str = "";
+    for (let i = 0; num > 0; ++i) {
+      let remainder = num % 26;
+      let charCode = remainder + 64;
+      num = (num - remainder) / 26;
+      if (remainder === 0) {
+        charCode = 90;
+        --num;
+      }
+      str = String.fromCharCode(charCode) + str;
+    }
+    return str;
+  }
+  generateUUID() {
+    const hexDigits = "0123456789ABCDEF";
+    let uuid = "{";
+    for (let i = 0; i < 36; i++) {
+      if (i === 8 || i === 13 || i === 18 || i === 23) {
+        uuid += "-";
+      } else {
+        uuid += hexDigits[Math.floor(Math.random() * 16)];
+      }
+    }
+    uuid += "}";
+    return uuid;
+  }
+  isRange(ref) {
+    return ref.indexOf(":") !== -1;
+  }
+  isWithin(ref, startRef, endRef) {
+    const start = this.splitRef(startRef);
+    const end = this.splitRef(endRef);
+    const target = this.splitRef(ref);
+    start.col = `${this.charToNum(start.col)}`;
+    end.col = `${this.charToNum(end.col)}`;
+    target.col = `${this.charToNum(target.col)}`;
+    return start.row <= target.row && target.row <= end.row && start.col <= target.col && target.col <= end.col;
+  }
+  /**
+   * 将任意类型的值转换为字符串
+   * 支持扩展：使用自定义格式化器
+   */
+  stringify(value, placeholder, key) {
+    if (placeholder) {
+      return this.executeFormatters(value, placeholder, key);
+    }
+    if (value instanceof Date) {
+      return Number(value.getTime() / (1e3 * 60 * 60 * 24) + 25569).toString();
+    } else if (typeof value === "number" || typeof value === "boolean") {
+      return Number(value).toString();
+    } else if (typeof value === "string") {
+      return String(value).toString();
+    }
+    return "";
+  }
+  insertCellValue(cell, substitution) {
+    const cellValue = cell.find("v");
+    const stringify = this.stringify(substitution);
+    if (typeof substitution === "string" && substitution[0] === "=") {
+      const formula = etree.Element("f");
+      formula.text = substitution.substring(1);
+      cell.insert(1, formula);
+      delete cell.attrib.t;
+      return formula.text.toString();
+    }
+    if (typeof substitution === "number" || substitution instanceof Date) {
+      delete cell.attrib.t;
+      cellValue.text = stringify;
+    } else if (typeof substitution === "boolean") {
+      cell.attrib.t = "b";
+      cellValue.text = stringify;
+    } else {
+      cell.attrib.t = "s";
+      cellValue.text = Number(this.stringIndex(stringify)).toString();
+    }
+    return stringify;
+  }
+  /**
+   * 执行单个值的替换
+   * 支持扩展：调用自定义替换器
+   */
+  substituteScalar(cell, string, placeholder, substitution) {
+    const customResult = this.executeReplacers(cell, string, placeholder, substitution);
+    if (customResult !== void 0) {
+      if (placeholder.full) {
+        return this.insertCellValue(cell, customResult);
+      } else {
+        cell.attrib.t = "s";
+        return this.insertCellValue(cell, customResult);
+      }
+    }
+    if (placeholder.full) {
+      return this.insertCellValue(cell, substitution);
+    } else {
+      const newString = string.replace(placeholder.placeholder, this.stringify(substitution, placeholder));
+      cell.attrib.t = "s";
+      return this.insertCellValue(cell, newString);
+    }
+  }
+  substituteArray(cells, cell, substitution) {
+    let newCellsInserted = -1;
+    let currentCell = cell.attrib.r;
+    substitution.forEach((element) => {
+      ++newCellsInserted;
+      if (newCellsInserted > 0) {
+        currentCell = this.nextCol(currentCell);
+      }
+      const newCell = this.cloneElement(cell);
+      this.insertCellValue(newCell, element);
+      newCell.attrib.r = currentCell;
+      cells.push(newCell);
+    });
+    return newCellsInserted;
+  }
+  async substituteTable(row, newTableRows, cells, cell, namedTables, substitution, placeholder, drawing) {
+    let newCellsInserted = 0;
+    if (substitution.length === 0) {
+      delete cell.attrib.t;
+      this.replaceChildren(cell, []);
+    } else {
+      const parentTables = namedTables.filter((namedTable) => {
+        const range = this.splitRange(namedTable.root.attrib.ref);
+        return this.isWithin(cell.attrib.r, range.start, range.end);
+      });
+      for (const [idx, element] of substitution.entries()) {
+        let newRow;
+        let newCell;
+        let newCellsInsertedOnNewRow = 0;
+        const newCells = [];
+        const value = this.valueGet(element, placeholder);
+        if (idx === 0) {
+          if (value instanceof Array) {
+            newCellsInserted = this.substituteArray(cells, cell, value);
+          } else if (placeholder.subType == "image" && value != "") {
+            this.substituteImage(cell, placeholder.placeholder, placeholder, value, drawing);
+          } else if (placeholder.subType === "imageincell" && value != "") {
+            await this.substituteImageInCell(cell, value);
+          } else {
+            const customResult = this.executeReplacers(cell, "", placeholder, value);
+            if (customResult !== void 0) {
+              this.insertCellValue(cell, customResult);
+            } else {
+              this.insertCellValue(cell, value);
+            }
+          }
+        } else {
+          if (idx - 1 < newTableRows.length) {
+            newRow = newTableRows[idx - 1];
+          } else {
+            newRow = this.cloneElement(row, false);
+            newRow.attrib.r = this.getCurrentRow(row, newTableRows.length + 1);
+            newTableRows.push(newRow);
+          }
+          newCell = this.cloneElement(cell);
+          newCell.attrib.r = this.joinRef({
+            row: newRow.attrib.r,
+            col: this.splitRef(newCell.attrib.r).col
+          });
+          if (value instanceof Array) {
+            newCellsInsertedOnNewRow = this.substituteArray(newCells, newCell, value);
+            newCells.forEach((nc) => {
+              newRow.append(nc);
+            });
+            this.updateRowSpan(newRow, newCellsInsertedOnNewRow);
+          } else if (placeholder.subType == "image" && value != "") {
+            this.substituteImage(newCell, placeholder.placeholder, placeholder, value, drawing);
+          } else if (placeholder.subType === "imageincell" && value != "") {
+            await this.substituteImageInCell(newCell, value);
+            newRow.append(newCell);
+          } else {
+            const customResult = this.executeReplacers(newCell, "", placeholder, value);
+            if (customResult !== void 0) {
+              this.insertCellValue(newCell, customResult);
+            } else {
+              this.insertCellValue(newCell, value);
+            }
+            newRow.append(newCell);
+          }
+          const mergeCell = this.sheet.root.findall("mergeCells/mergeCell").find((c) => this.splitRange(c.attrib.ref).start === cell.attrib.r);
+          const isMergeCell = mergeCell != null;
+          if (isMergeCell) {
+            const originalMergeRange = this.splitRange(mergeCell.attrib.ref);
+            const originalMergeStart = this.splitRef(originalMergeRange.start);
+            const originalMergeEnd = this.splitRef(originalMergeRange.end);
+            for (let column = this.charToNum(originalMergeStart.col) + 1; column <= this.charToNum(originalMergeEnd.col); column++) {
+              const data = this.sheet.root.find("sheetData");
+              const children = data.getchildren();
+              const originalRow = children.find((f) => f.attrib.r == originalMergeStart.row);
+              const col = this.numToChar(column);
+              const originalCell = originalRow.getchildren().find((f) => f.attrib.r.startsWith(col));
+              const additionalCell = this.cloneElement(originalCell);
+              additionalCell.attrib.r = this.joinRef({
+                row: newRow.attrib.r,
+                col: this.numToChar(column)
+              });
+              newRow.append(additionalCell);
+            }
+          }
+          parentTables.forEach((namedTable) => {
+            const tableRoot = namedTable.root;
+            const autoFilter = tableRoot.find("autoFilter");
+            const range = this.splitRange(tableRoot.attrib.ref);
+            if (!this.isWithin(newCell.attrib.r, range.start, range.end)) {
+              range.end = this.nextRow(range.end);
+              tableRoot.attrib.ref = this.joinRange(range);
+              if (autoFilter !== null) {
+                autoFilter.attrib.ref = tableRoot.attrib.ref;
+              }
+            }
+          });
+        }
+      }
+    }
+    return newCellsInserted;
+  }
+  async initRichData() {
+    if (!this.richDataIsInit) {
+      const _relsrichValueRel = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+	            <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+	            </Relationships>`;
+      const rdrichvalue = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+	            <rvData xmlns="http://schemas.microsoft.com/office/spreadsheetml/2017/richdata" count="0">
+	            </rvData>`;
+      const rdrichvaluestructure = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+	            <rvStructures xmlns="http://schemas.microsoft.com/office/spreadsheetml/2017/richdata" count="1">
+	                <s t="_localImage">
+	                    <k n="_rvRel:LocalImageIdentifier" t="i"/>
+	                    <k n="CalcOrigin" t="i"/>
+	                </s>
+	            </rvStructures>`;
+      const rdRichValueTypes = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+	            <rvTypesInfo xmlns="http://schemas.microsoft.com/office/spreadsheetml/2017/richdata2"
+	                xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="x"
+	                xmlns:x="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+	                <global>
+	                    <keyFlags>
+	                        <key name="_Self">
+	                            <flag name="ExcludeFromFile" value="1"/>
+	                            <flag name="ExcludeFromCalcComparison" value="1"/>
+	                        </key>
+	                        <key name="_DisplayString">
+	                            <flag name="ExcludeFromCalcComparison" value="1"/>
+	                        </key>
+	                        <key name="_Flags">
+	                            <flag name="ExcludeFromCalcComparison" value="1"/>
+	                        </key>
+	                        <key name="_Format">
+	                            <flag name="ExcludeFromCalcComparison" value="1"/>
+	                        </key>
+	                        <key name="_SubLabel">
+	                            <flag name="ExcludeFromCalcComparison" value="1"/>
+	                        </key>
+	                        <key name="_Attribution">
+	                            <flag name="ExcludeFromCalcComparison" value="1"/>
+	                        </key>
+	                        <key name="_Icon">
+	                            <flag name="ExcludeFromCalcComparison" value="1"/>
+	                        </key>
+	                        <key name="_Display">
+	                            <flag name="ExcludeFromCalcComparison" value="1"/>
+	                        </key>
+	                        <key name="_CanonicalPropertyNames">
+	                            <flag name="ExcludeFromCalcComparison" value="1"/>
+	                        </key>
+	                        <key name="_ClassificationId">
+	                            <flag name="ExcludeFromCalcComparison" value="1"/>
+	                        </key>
+	                    </keyFlags>
+	                </global>
+	            </rvTypesInfo>`;
+      const richValueRel = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+	            <richValueRels xmlns="http://schemas.microsoft.com/office/spreadsheetml/2022/richvaluerel"
+	                xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+	            </richValueRels>`;
+      const metadata = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+	            <metadata xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+	                xmlns:xlrd="http://schemas.microsoft.com/office/spreadsheetml/2017/richdata">
+	                <metadataTypes count="1">
+	                    <metadataType name="XLRICHVALUE" minSupportedVersion="120000" copy="1" pasteAll="1" pasteValues="1" merge="1" splitFirst="1" rowColShift="1" clearFormats="1" clearComments="1" assign="1" coerce="1"/>
+	                </metadataTypes>
+	                <futureMetadata name="XLRICHVALUE" count="0">
+	                </futureMetadata>
+	                <valueMetadata count="0">
+	                </valueMetadata>
+	            </metadata>`;
+      const _relsrichValueRelFileName = "xl/richData/_rels/richValueRel.xml.rels";
+      const rdrichvalueFileName = "xl/richData/rdrichvalue.xml";
+      const rdrichvaluestructureFileName = "xl/richData/rdrichvaluestructure.xml";
+      const rdRichValueTypesFileName = "xl/richData/rdRichValueTypes.xml";
+      const richValueRelFileName = "xl/richData/richValueRel.xml";
+      const metadataFileName = "xl/metadata.xml";
+      this._relsrichValueRel = etree.parse(_relsrichValueRel).getroot();
+      this.rdrichvalue = etree.parse(rdrichvalue).getroot();
+      this.rdrichvaluestructure = etree.parse(rdrichvaluestructure).getroot();
+      this.rdRichValueTypes = etree.parse(rdRichValueTypes).getroot();
+      this.richValueRel = etree.parse(richValueRel).getroot();
+      this.metadata = etree.parse(metadata).getroot();
+      if (this.archive.file(_relsrichValueRelFileName)) {
+        const content = await this.archive.file(_relsrichValueRelFileName).async("string");
+        this._relsrichValueRel = etree.parse(content).getroot();
+      }
+      if (this.archive.file(rdrichvalueFileName)) {
+        const content = await this.archive.file(rdrichvalueFileName).async("string");
+        this.rdrichvalue = etree.parse(content).getroot();
+      }
+      if (this.archive.file(rdrichvaluestructureFileName)) {
+        const content = await this.archive.file(rdrichvaluestructureFileName).async("string");
+        this.rdrichvaluestructure = etree.parse(content).getroot();
+      }
+      if (this.archive.file(rdRichValueTypesFileName)) {
+        const content = await this.archive.file(rdRichValueTypesFileName).async("string");
+        this.rdRichValueTypes = etree.parse(content).getroot();
+      }
+      if (this.archive.file(richValueRelFileName)) {
+        const content = await this.archive.file(richValueRelFileName).async("string");
+        this.richValueRel = etree.parse(content).getroot();
+      }
+      if (this.archive.file(metadataFileName)) {
+        const content = await this.archive.file(metadataFileName).async("string");
+        this.metadata = etree.parse(content).getroot();
+      }
+      this.richDataIsInit = true;
+    }
+  }
+  writeRichDataAlreadyExist(element, elementSearchName, attributeName, attributeValue) {
+    for (const e of element.findall(elementSearchName)) {
+      if (e.attrib[attributeName] == attributeValue) {
+        return true;
+      }
+    }
+    return false;
+  }
+  writeRichData() {
+    if (this.richDataIsInit) {
+      const _relsrichValueRelFileName = "xl/richData/_rels/richValueRel.xml.rels";
+      const rdrichvalueFileName = "xl/richData/rdrichvalue.xml";
+      const rdrichvaluestructureFileName = "xl/richData/rdrichvaluestructure.xml";
+      const rdRichValueTypesFileName = "xl/richData/rdRichValueTypes.xml";
+      const richValueRelFileName = "xl/richData/richValueRel.xml";
+      const metadataFileName = "xl/metadata.xml";
+      const options = { encoding: "utf-8" };
+      this.archive.file(_relsrichValueRelFileName, etree.tostring(this._relsrichValueRel, options));
+      this.archive.file(rdrichvalueFileName, etree.tostring(this.rdrichvalue, options));
+      this.archive.file(rdrichvaluestructureFileName, etree.tostring(this.rdrichvaluestructure, options));
+      this.archive.file(rdRichValueTypesFileName, etree.tostring(this.rdRichValueTypes, options));
+      this.archive.file(richValueRelFileName, etree.tostring(this.richValueRel, options));
+      this.archive.file(metadataFileName, etree.tostring(this.metadata, options));
+      const broadsideMax = this.findMaxId(this.workbookRels, "Relationship", "Id", /rId(\d*)/);
+      let _rel;
+      if (!this.writeRichDataAlreadyExist(this.workbookRels, "Relationship", "Target", "richData/rdrichvaluestructure.xml")) {
+        _rel = etree.SubElement(this.workbookRels, "Relationship");
+        _rel.set("Id", "rId" + broadsideMax);
+        _rel.set("Type", "http://schemas.microsoft.com/office/2017/06/relationships/rdRichValueStructure");
+        _rel.set("Target", "richData/rdrichvaluestructure.xml");
+      }
+      if (!this.writeRichDataAlreadyExist(this.workbookRels, "Relationship", "Target", "richData/rdrichvalue.xml")) {
+        _rel = etree.SubElement(this.workbookRels, "Relationship");
+        _rel.set("Id", "rId" + (broadsideMax + 1));
+        _rel.set("Type", "http://schemas.microsoft.com/office/2017/06/relationships/rdRichValue");
+        _rel.set("Target", "richData/rdrichvalue.xml");
+      }
+      if (!this.writeRichDataAlreadyExist(this.workbookRels, "Relationship", "Target", "richData/richValueRel.xml")) {
+        _rel = etree.SubElement(this.workbookRels, "Relationship");
+        _rel.set("Id", "rId" + (broadsideMax + 2));
+        _rel.set("Type", "http://schemas.microsoft.com/office/2022/10/relationships/richValueRel");
+        _rel.set("Target", "richData/richValueRel.xml");
+      }
+      if (!this.writeRichDataAlreadyExist(this.workbookRels, "Relationship", "Target", "metadata.xml")) {
+        _rel = etree.SubElement(this.workbookRels, "Relationship");
+        _rel.set("Id", "rId" + (broadsideMax + 3));
+        _rel.set("Type", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sheetMetadata");
+        _rel.set("Target", "metadata.xml");
+      }
+      if (!this.writeRichDataAlreadyExist(this.workbookRels, "Relationship", "Target", "richData/rdRichValueTypes.xml")) {
+        _rel = etree.SubElement(this.workbookRels, "Relationship");
+        _rel.set("Id", "rId" + (broadsideMax + 4));
+        _rel.set("Type", "http://schemas.microsoft.com/office/2017/06/relationships/rdRichValueTypes");
+        _rel.set("Target", "richData/rdRichValueTypes.xml");
+      }
+      if (!this.writeRichDataAlreadyExist(this.contentTypes, "Override", "PartName", "/xl/metadata.xml")) {
+        let ctOverride = etree.SubElement(this.contentTypes, "Override");
+        ctOverride.set("PartName", "/xl/metadata.xml");
+        ctOverride.set("ContentType", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml");
+      }
+      if (!this.writeRichDataAlreadyExist(this.contentTypes, "Override", "PartName", "/xl/richData/richValueRel.xml")) {
+        let ctOverride = etree.SubElement(this.contentTypes, "Override");
+        ctOverride.set("PartName", "/xl/richData/richValueRel.xml");
+        ctOverride.set("ContentType", "application/vnd.ms-excel.richvaluerel+xml");
+      }
+      if (!this.writeRichDataAlreadyExist(this.contentTypes, "Override", "PartName", "/xl/richData/rdrichvalue.xml")) {
+        let ctOverride = etree.SubElement(this.contentTypes, "Override");
+        ctOverride.set("PartName", "/xl/richData/rdrichvalue.xml");
+        ctOverride.set("ContentType", "application/vnd.ms-excel.rdrichvalue+xml");
+      }
+      if (!this.writeRichDataAlreadyExist(this.contentTypes, "Override", "PartName", "/xl/richData/rdrichvaluestructure.xml")) {
+        let ctOverride = etree.SubElement(this.contentTypes, "Override");
+        ctOverride.set("PartName", "/xl/richData/rdrichvaluestructure.xml");
+        ctOverride.set("ContentType", "application/vnd.ms-excel.rdrichvaluestructure+xml");
+      }
+      if (!this.writeRichDataAlreadyExist(this.contentTypes, "Override", "PartName", "/xl/richData/rdRichValueTypes.xml")) {
+        let ctOverride = etree.SubElement(this.contentTypes, "Override");
+        ctOverride.set("PartName", "/xl/richData/rdRichValueTypes.xml");
+        ctOverride.set("ContentType", "application/vnd.ms-excel.rdrichvaluetypes+xml");
+      }
+      this._rebuild();
+    }
+  }
+  async substituteImageInCell(cell, substitution) {
+    if (substitution == null || substitution == "") {
+      this.insertCellValue(cell, "");
+      return true;
+    }
+    await this.initRichData();
+    const maxFildId = this.findMaxFileId(/xl\/media\/image\d*\..*/, /image(\d*)\./);
+    const fileExtension = "jpg";
+    try {
+      substitution = this.imageToBuffer(substitution);
+    } catch (error) {
+      if (this.option && this.option.handleImageError && typeof this.option.handleImageError === "function") {
+        this.option.handleImageError(substitution, error);
+      } else {
+        throw error;
+      }
+    }
+    this.archive.file("xl/media/image" + maxFildId + "." + fileExtension, toArrayBuffer(substitution), {
+      binary: true,
+      base64: false
+    });
+    const maxIdRichData = this.findMaxId(this._relsrichValueRel, "Relationship", "Id", /rId(\d*)/);
+    const _rel = etree.SubElement(this._relsrichValueRel, "Relationship");
+    _rel.set("Id", "rId" + maxIdRichData);
+    _rel.set("Type", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image");
+    _rel.set("Target", "../media/image" + maxFildId + "." + fileExtension);
+    const currentCountedRichValue = this.rdrichvalue.get("count");
+    this.rdrichvalue.set("count", parseInt(currentCountedRichValue) + 1);
+    const rv = etree.SubElement(this.rdrichvalue, "rv");
+    rv.set("s", "0");
+    const firstV = etree.SubElement(rv, "v");
+    const secondV = etree.SubElement(rv, "v");
+    firstV.text = currentCountedRichValue;
+    secondV.text = "5";
+    const rel = etree.SubElement(this.richValueRel, "rel");
+    rel.set("r:id", "rId" + maxIdRichData);
+    const futureMetadata = this.metadata.findall("futureMetadata").find((fm) => {
+      return fm.attrib.name === "XLRICHVALUE";
+    });
+    const futureMetadataCount = futureMetadata.get("count");
+    futureMetadata.set("count", parseInt(futureMetadataCount) + 1);
+    const bk = etree.SubElement(futureMetadata, "bk");
+    const extLst = etree.SubElement(bk, "extLst");
+    const ext = etree.SubElement(extLst, "ext");
+    ext.set("uri", "{3e2802c4-a4d2-4d8b-9148-e3be6c30e623}");
+    const xlrd_rvb = etree.SubElement(ext, "xlrd:rvb");
+    xlrd_rvb.set("i", futureMetadataCount);
+    const valueMetadataCount = this.metadata.find("valueMetadata").get("count");
+    this.metadata.find("valueMetadata").set("count", parseInt(valueMetadataCount) + 1);
+    const bk_VM = etree.SubElement(this.metadata.find("valueMetadata"), "bk");
+    const rc = etree.SubElement(bk_VM, "rc");
+    const XLRICHVALUEMetaDataTypeIndex = this.metadata.find("metadataTypes").findall("metadataType").findIndex((el) => {
+      return el.attrib.name === "XLRICHVALUE";
+    });
+    rc.set("t", "" + (XLRICHVALUEMetaDataTypeIndex + 1));
+    rc.set("v", valueMetadataCount);
+    cell.set("t", "e");
+    cell.set("vm", parseInt(currentCountedRichValue) + 1);
+    this.insertCellValue(cell, "#VALUE!");
+    return true;
+  }
+  substituteImage(cell, string, placeholder, substitution, drawing) {
+    this.substituteScalar(cell, string, placeholder, "");
+    if (substitution == null || substitution == "") {
+      return true;
+    }
+    const maxId = this.findMaxId(drawing.relRoot, "Relationship", "Id", /rId(\d*)/);
+    const maxFildId = this.findMaxFileId(/xl\/media\/image\d*.jpg/, /image(\d*)\.jpg/);
+    const rel = etree.SubElement(drawing.relRoot, "Relationship");
+    rel.set("Id", "rId" + maxId);
+    rel.set("Type", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image");
+    rel.set("Target", "../media/image" + maxFildId + ".jpg");
+    try {
+      substitution = this.imageToBuffer(substitution);
+    } catch (error) {
+      if (this.option && this.option.handleImageError && typeof this.option.handleImageError === "function") {
+        this.option.handleImageError(substitution, error);
+      } else {
+        throw error;
+      }
+    }
+    this.archive.file("xl/media/image" + maxFildId + ".jpg", toArrayBuffer(substitution), {
+      binary: true,
+      base64: false
+    });
+    const dimension = sizeOf(substitution);
+    let imageWidth = this.pixelsToEMUs(dimension.width);
+    let imageHeight = this.pixelsToEMUs(dimension.height);
+    let imageInMergeCell = false;
+    for (let mergeCell of this.sheet.root.findall("mergeCells/mergeCell")) {
+      if (this.cellInMergeCells(cell, mergeCell)) {
+        const mergeCellWidth = this.getWidthMergeCell(mergeCell, this.sheet);
+        const mergeCellHeight = this.getHeightMergeCell(mergeCell, this.sheet);
+        const mergeWidthEmus = this.columnWidthToEMUs(mergeCellWidth);
+        const mergeHeightEmus = this.rowHeightToEMUs(mergeCellHeight);
+        const widthRate = imageWidth / mergeWidthEmus;
+        const heightRate = imageHeight / mergeHeightEmus;
+        if (widthRate > heightRate) {
+          imageWidth = Math.floor(imageWidth / widthRate);
+          imageHeight = Math.floor(imageHeight / widthRate);
+        } else {
+          imageWidth = Math.floor(imageWidth / heightRate);
+          imageHeight = Math.floor(imageHeight / heightRate);
+        }
+        imageInMergeCell = true;
+      }
+    }
+    if (!imageInMergeCell) {
+      let ratio = 100;
+      if (this.option && this.option.imageRatio) {
+        ratio = this.option.imageRatio;
+      }
+      if (ratio <= 0) {
+        ratio = 100;
+      }
+      imageWidth = Math.floor(imageWidth * ratio / 100);
+      imageHeight = Math.floor(imageHeight * ratio / 100);
+    }
+    const imagePart = etree.SubElement(drawing.root, "xdr:oneCellAnchor");
+    const fromPart = etree.SubElement(imagePart, "xdr:from");
+    const fromCol = etree.SubElement(fromPart, "xdr:col");
+    fromCol.text = (this.charToNum(this.splitRef(cell.attrib.r).col) - 1).toString();
+    const fromColOff = etree.SubElement(fromPart, "xdr:colOff");
+    fromColOff.text = "0";
+    const fromRow = etree.SubElement(fromPart, "xdr:row");
+    fromRow.text = (this.splitRef(cell.attrib.r).row - 1).toString();
+    const fromRowOff = etree.SubElement(fromPart, "xdr:rowOff");
+    fromRowOff.text = "0";
+    const extImagePart = etree.SubElement(imagePart, "xdr:ext", { cx: `${imageWidth}`, cy: `${imageHeight}` });
+    const picNode = etree.SubElement(imagePart, "xdr:pic");
+    const nvPicPr = etree.SubElement(picNode, "xdr:nvPicPr");
+    const cNvPr = etree.SubElement(nvPicPr, "xdr:cNvPr", { id: `${maxId}`, name: "image_" + maxId, descr: "" });
+    const cNvPicPr = etree.SubElement(nvPicPr, "xdr:cNvPicPr");
+    const picLocks = etree.SubElement(cNvPicPr, "a:picLocks", { noChangeAspect: "1" });
+    const blipFill = etree.SubElement(picNode, "xdr:blipFill");
+    const blip = etree.SubElement(blipFill, "a:blip", {
+      "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+      "r:embed": "rId" + maxId
+    });
+    const stretch = etree.SubElement(blipFill, "a:stretch");
+    const fillRect = etree.SubElement(stretch, "a:fillRect");
+    const spPr = etree.SubElement(picNode, "xdr:spPr");
+    const xfrm = etree.SubElement(spPr, "a:xfrm");
+    const off = etree.SubElement(xfrm, "a:off", { x: "0", y: "0" });
+    const ext = etree.SubElement(xfrm, "a:ext", { cx: `${imageWidth}`, cy: `${imageHeight}` });
+    const prstGeom = etree.SubElement(spPr, "a:prstGeom", { "prst": "rect" });
+    const avLst = etree.SubElement(prstGeom, "a:avLst");
+    const clientData = etree.SubElement(imagePart, "xdr:clientData");
+    return true;
+  }
+  cloneElement(element, deep) {
+    const newElement = etree.Element(element.tag, element.attrib);
+    newElement.text = element.text;
+    newElement.tail = element.tail;
+    if (deep !== false) {
+      element.getchildren().forEach((child) => {
+        newElement.append(this.cloneElement(child, deep));
+      });
+    }
+    return newElement;
+  }
+  replaceChildren(parent, children) {
+    parent.delSlice(0, parent.len());
+    children.forEach((child) => {
+      parent.append(child);
+    });
+  }
+  getCurrentRow(row, rowsInserted) {
+    return parseInt(row.attrib.r, 10) + rowsInserted;
+  }
+  getCurrentCell(cell, currentRow, cellsInserted) {
+    const colRef = this.splitRef(cell.attrib.r).col;
+    const colNum = this.charToNum(colRef);
+    return this.joinRef({
+      row: currentRow,
+      col: this.numToChar(colNum + cellsInserted)
+    });
+  }
+  updateRowSpan(row, cellsInserted) {
+    if (cellsInserted !== 0 && row.attrib.spans) {
+      const rowSpan = row.attrib.spans.split(":").map((f) => parseInt(f, 10));
+      rowSpan[1] += cellsInserted;
+      row.attrib.spans = rowSpan.join(":");
+    }
+  }
+  splitRange(range) {
+    const split = range.split(":");
+    return {
+      start: split[0],
+      end: split[1]
+    };
+  }
+  joinRange(range) {
+    return range.start + ":" + range.end;
+  }
+  pushRight(workbook, sheet, currentCell, numCols) {
+    const cellRef = this.splitRef(currentCell);
+    const currentRow = cellRef.row;
+    const currentCol = this.charToNum(cellRef.col);
+    sheet.findall("mergeCells/mergeCell").forEach((mergeCell) => {
+      const mergeRange = this.splitRange(mergeCell.attrib.ref);
+      const mergeStart = this.splitRef(mergeRange.start);
+      const mergeStartCol = this.charToNum(mergeStart.col);
+      const mergeEnd = this.splitRef(mergeRange.end);
+      const mergeEndCol = this.charToNum(mergeEnd.col);
+      if (mergeStart.row === currentRow && currentCol < mergeStartCol) {
+        mergeStart.col = this.numToChar(mergeStartCol + numCols);
+        mergeEnd.col = this.numToChar(mergeEndCol + numCols);
+        mergeCell.attrib.ref = this.joinRange({
+          start: this.joinRef(mergeStart),
+          end: this.joinRef(mergeEnd)
+        });
+      }
+    });
+    workbook.findall("definedNames/definedName").forEach((name) => {
+      const ref = name.text;
+      if (this.isRange(ref)) {
+        const namedRange = this.splitRange(ref);
+        const namedStart = this.splitRef(namedRange.start);
+        const namedStartCol = this.charToNum(namedStart.col);
+        const namedEnd = this.splitRef(namedRange.end);
+        const namedEndCol = this.charToNum(namedEnd.col);
+        if (namedStart.row === currentRow && currentCol < namedStartCol) {
+          namedStart.col = this.numToChar(namedStartCol + numCols);
+          namedEnd.col = this.numToChar(namedEndCol + numCols);
+          name.text = this.joinRange({
+            start: this.joinRef(namedStart),
+            end: this.joinRef(namedEnd)
+          });
+        }
+      } else {
+        const namedRef = this.splitRef(ref);
+        const namedCol = this.charToNum(namedRef.col);
+        if (namedRef.row === currentRow && currentCol < namedCol) {
+          namedRef.col = this.numToChar(namedCol + numCols);
+          name.text = this.joinRef(namedRef);
+        }
+      }
+    });
+    sheet.findall("hyperlinks/hyperlink").forEach((hyperlink) => {
+      const ref = this.splitRef(hyperlink.attrib.ref);
+      const colNumber = this.charToNum(ref.col);
+      if (colNumber > currentCol) {
+        ref.col = this.numToChar(colNumber + numCols);
+        hyperlink.attrib.ref = this.joinRef(ref);
+      }
+    });
+  }
+  pushDown(workbook, sheet, tables, currentRow, numRows) {
+    const mergeCells = sheet.find("mergeCells");
+    sheet.findall("mergeCells/mergeCell").forEach((mergeCell) => {
+      const mergeRange = this.splitRange(mergeCell.attrib.ref);
+      const mergeStart = this.splitRef(mergeRange.start);
+      const mergeEnd = this.splitRef(mergeRange.end);
+      if (mergeStart.row > currentRow) {
+        mergeStart.row += numRows;
+        mergeEnd.row += numRows;
+        mergeCell.attrib.ref = this.joinRange({
+          start: this.joinRef(mergeStart),
+          end: this.joinRef(mergeEnd)
+        });
+      }
+      if (mergeStart.row == currentRow) {
+        for (let i = 1; i <= numRows; i++) {
+          const newMergeCell = this.cloneElement(mergeCell);
+          mergeStart.row += 1;
+          mergeEnd.row += 1;
+          newMergeCell.attrib.ref = this.joinRange({
+            start: this.joinRef(mergeStart),
+            end: this.joinRef(mergeEnd)
+          });
+          mergeCells.attrib.count += 1;
+          mergeCells._children.push(newMergeCell);
+        }
+      }
+    });
+    tables.forEach((table) => {
+      const tableRoot = table.root;
+      const tableRange = this.splitRange(tableRoot.attrib.ref);
+      const tableStart = this.splitRef(tableRange.start);
+      const tableEnd = this.splitRef(tableRange.end);
+      if (tableStart.row > currentRow) {
+        tableStart.row += numRows;
+        tableEnd.row += numRows;
+        tableRoot.attrib.ref = this.joinRange({
+          start: this.joinRef(tableStart),
+          end: this.joinRef(tableEnd)
+        });
+        const autoFilter = tableRoot.find("autoFilter");
+        if (autoFilter !== null) {
+          autoFilter.attrib.ref = tableRoot.attrib.ref;
+        }
+      }
+    });
+    workbook.findall("definedNames/definedName").forEach((name) => {
+      const ref = name.text;
+      if (this.isRange(ref)) {
+        const namedRange = this.splitRange(ref);
+        const namedStart = this.splitRef(namedRange.start);
+        const namedEnd = this.splitRef(namedRange.end);
+        if (namedStart) {
+          if (namedStart.row > currentRow) {
+            namedStart.row += numRows;
+            namedEnd.row += numRows;
+            name.text = this.joinRange({
+              start: this.joinRef(namedStart),
+              end: this.joinRef(namedEnd)
+            });
+          }
+        }
+        if (this.option && this.option.pushDownPageBreakOnTableSubstitution) {
+          if (this.sheet.name == name.text.split("!")[0].replace(/'/gi, "") && namedEnd) {
+            if (namedEnd.row > currentRow) {
+              namedEnd.row += numRows;
+              name.text = this.joinRange({
+                start: this.joinRef(namedStart),
+                end: this.joinRef(namedEnd)
+              });
+            }
+          }
+        }
+      } else {
+        const namedRef = this.splitRef(ref);
+        if (namedRef.row > currentRow) {
+          namedRef.row += numRows;
+          name.text = this.joinRef(namedRef);
+        }
+      }
+    });
+    sheet.findall("hyperlinks/hyperlink").forEach((hyperlink) => {
+      const ref = this.splitRef(hyperlink.attrib.ref);
+      if (ref.row > currentRow) {
+        ref.row += numRows;
+        hyperlink.attrib.ref = this.joinRef(ref);
+      }
+    });
+  }
+  async hideCols(sheetName, hideItemIndexes) {
+    const sheet = await this.loadSheet(sheetName);
+    this.sheet = sheet;
+    if (Array.isArray(hideItemIndexes) && hideItemIndexes.length) {
+      const cols = sheet.root.find("cols");
+      if (cols) {
+        hideItemIndexes.forEach((hideIndex) => {
+          const colIndex = hideIndex + 1;
+          const col = cols.findall("col").find((c) => {
+            const min = parseInt(c.attrib.min, 10);
+            const max = parseInt(c.attrib.max, 10);
+            return colIndex >= min && colIndex <= max;
+          });
+          if (col) {
+            col.attrib.hidden = "1";
+          }
+        });
+      }
+    }
+    this.archive.file(sheet.filename, etree.tostring(sheet.root, { encoding: "utf-8" }));
+    this._rebuild();
+    return this;
+  }
+  getWidthCell(numCol, sheet) {
+    let defaultWidth = sheet.root.find("sheetFormatPr").attrib["defaultColWidth"];
+    if (!defaultWidth) {
+      defaultWidth = "11.42578125";
+    }
+    let finalWidth = defaultWidth;
+    sheet.root.findall("cols/col").forEach((col) => {
+      if (numCol >= col.attrib["min"] && numCol <= col.attrib["max"]) {
+        if (col.attrib["width"] != void 0) {
+          finalWidth = col.attrib["width"];
+        }
+      }
+    });
+    return Number.parseFloat(finalWidth);
+  }
+  getWidthMergeCell(mergeCell, sheet) {
+    let mergeWidth = 0;
+    const mergeRange = this.splitRange(mergeCell.attrib.ref);
+    const mergeStartCol = this.charToNum(this.splitRef(mergeRange.start).col);
+    const mergeEndCol = this.charToNum(this.splitRef(mergeRange.end).col);
+    for (let i = mergeStartCol; i < mergeEndCol + 1; i++) {
+      mergeWidth += this.getWidthCell(i, sheet);
+    }
+    return mergeWidth;
+  }
+  getHeightCell(numRow, sheet) {
+    let finalHeight = sheet.root.find("sheetFormatPr").attrib["defaultRowHeight"];
+    sheet.root.findall("sheetData/row").forEach((row) => {
+      if (numRow == row.attrib["r"]) {
+        if (row.attrib["ht"] != void 0) {
+          finalHeight = row.attrib["ht"];
+        }
+      }
+    });
+    return Number.parseFloat(finalHeight);
+  }
+  getHeightMergeCell(mergeCell, sheet) {
+    let mergeHeight = 0;
+    const mergeRange = this.splitRange(mergeCell.attrib.ref);
+    const mergeStartRow = this.splitRef(mergeRange.start).row;
+    const mergeEndRow = this.splitRef(mergeRange.end).row;
+    for (let i = mergeStartRow; i < mergeEndRow + 1; i++) {
+      mergeHeight += this.getHeightCell(i, sheet);
+    }
+    return mergeHeight;
+  }
+  getNbRowOfMergeCell(mergeCell) {
+    const mergeRange = this.splitRange(mergeCell.attrib.ref);
+    const mergeStartRow = this.splitRef(mergeRange.start).row;
+    const mergeEndRow = this.splitRef(mergeRange.end).row;
+    return mergeEndRow - mergeStartRow + 1;
+  }
+  pixelsToEMUs(pixels) {
+    return Math.round(pixels * 914400 / 96);
+  }
+  columnWidthToEMUs(width) {
+    return this.pixelsToEMUs(width * 7.625579987895905);
+  }
+  rowHeightToEMUs(height) {
+    return Math.round(height / 72 * 914400);
+  }
+  findMaxFileId(fileNameRegex, idRegex) {
+    const files = this.archive.file(fileNameRegex);
+    const maxId = files.reduce((p, c) => {
+      const num = parseInt(idRegex.exec(c.name)[1]);
+      if (p == null) {
+        return num;
+      }
+      return p > num ? p : num;
+    }, 0);
+    return maxId + 1;
+  }
+  cellInMergeCells(cell, mergeCell) {
+    const cellCol = this.charToNum(this.splitRef(cell.attrib.r).col);
+    const cellRow = this.splitRef(cell.attrib.r).row;
+    const mergeRange = this.splitRange(mergeCell.attrib.ref);
+    const mergeStartCol = this.charToNum(this.splitRef(mergeRange.start).col);
+    const mergeEndCol = this.charToNum(this.splitRef(mergeRange.end).col);
+    const mergeStartRow = this.splitRef(mergeRange.start).row;
+    const mergeEndRow = this.splitRef(mergeRange.end).row;
+    if (cellCol >= mergeStartCol && cellCol <= mergeEndCol) {
+      if (cellRow >= mergeStartRow && cellRow <= mergeEndRow) {
+        return true;
+      }
+    }
+    return false;
+  }
+  imageToBuffer(imageObj) {
+    function checkImage(buffer) {
+      try {
+        sizeOf(buffer);
+        return buffer;
+      } catch (error) {
+        throw new TypeError("imageObj cannot be parse as a buffer image");
+      }
+    }
+    if (!imageObj) {
+      throw new TypeError("imageObj cannot be null");
+    }
+    if (imageObj instanceof Buffer) {
+      return checkImage(imageObj);
+    }
+    if (typeof imageObj === "string" || imageObj instanceof String) {
+      imageObj = imageObj.toString();
+      const imagePath = this.option && this.option.imageRootPath ? this.option.imageRootPath + "/" + imageObj : imageObj;
+      if (fs.existsSync(imagePath)) {
+        return checkImage(Buffer.from(fs.readFileSync(imagePath, { encoding: "base64" }), "base64"));
+      }
+      try {
+        return checkImage(Buffer.from(imageObj, "base64"));
+      } catch (error) {
+        throw new TypeError("imageObj cannot be parse as a buffer");
+      }
+    }
+    throw new TypeError("imageObj type is not supported : " + typeof imageObj);
+  }
+  findMaxId(element, tag, attr, idRegex) {
+    let maxId = 0;
+    element.findall(tag).forEach((el) => {
+      const match = idRegex.exec(el.attrib[attr]);
+      if (match == null) {
+        throw new Error("Can not find the id!");
+      }
+      const cid = parseInt(match[1]);
+      if (cid > maxId) {
+        maxId = cid;
+      }
+    });
+    return ++maxId;
+  }
+};
+var generateXlsxTemplate = async function(data, values, options) {
+  const w = await Workbook.parse(data, options);
+  await w.substituteAll(values);
+  return w.generate(options);
+};
+
+// src/helper.ts
+import exceljs from "exceljs";
+import { Stream } from "stream";
+var isPureNumber = /^[0-9]+$/;
+var isPureUppercase = /^[A-Z]+$/;
+var exprSingle = `expr`;
+var exprArr = `exprArr`;
+var exprIndex = `index`;
+var defaultKey = `!!`;
+var numberKey = `!!number`;
+var codeKey = `!!codeKey`;
+var funcCommand = "fn:";
+var RuleToken = /* @__PURE__ */ ((RuleToken2) => {
+  RuleToken2["AliasToken"] = "alias";
+  RuleToken2["CellToken"] = "cell";
+  RuleToken2["MergeCellToken"] = "mergeCell";
+  RuleToken2["RowCellToken"] = "rowCell";
+  RuleToken2["UseAliasToken"] = "@";
+  RuleToken2["RangeToken"] = "-";
+  RuleToken2["PosToken"] = ":";
+  RuleToken2["FunctionPatternToken"] = "<?>";
+  RuleToken2["AnyToken"] = "?";
+  RuleToken2["VarPatternToken"] = "${?}";
+  RuleToken2["UndefinedToken"] = "";
+  RuleToken2["EqualToken"] = "=";
+  RuleToken2["ArgPosToken"] = ",";
+  RuleToken2["LparenToken"] = "(";
+  RuleToken2["RparenToken"] = ")";
+  RuleToken2["DotGetToken"] = ".";
+  RuleToken2["CompileGenToken"] = "compile:GenCell";
+  RuleToken2["CompileMacroToken"] = "compile:Macro";
+  return RuleToken2;
+})(RuleToken || {});
+var RuleMapOptions = class _RuleMapOptions {
+  constructor(m) {
+    // rule configure area
+    this.startLine = 1;
+    this.startColumn = 1;
+    if (m === void 0) {
+      this.ruleKeyMap = defaultRuleTokenMap;
+    } else {
+      this.ruleKeyMap = m;
+    }
+  }
+  static withAllSheets(w, excludes) {
+    const compileSheets = [];
+    const options = new _RuleMapOptions();
+    if (excludes === void 0) {
+      excludes = [];
+    }
+    if (w.worksheets.length > 0 && excludes.length > 0) {
+      for (const [index, sheet] of w.worksheets.entries()) {
+        if (excludes.includes(index.toString()) || excludes.includes(sheet.name)) {
+          continue;
+        }
+        if (sheet.name.endsWith(".json")) {
+          continue;
+        }
+        compileSheets.push(sheet.name);
+      }
+    }
+    options.compileSheets = compileSheets;
+    return options;
+  }
+  parseDefault(worksheet) {
+    this.ruleKeyMap = mergeOption(this.ruleKeyMap, defaultRuleTokenMap);
+    if (this.startLine === void 0) {
+      this.startLine = 1;
+    }
+    if (this.endLine === void 0) {
+      this.endLine = worksheet.rowCount;
+    }
+    if (this.startColumn === void 0) {
+      this.startColumn = 1;
+    }
+    if (this.endColumn === void 0) {
+      this.endColumn = worksheet.columnCount;
+    }
+    return this;
+  }
+  addRuleMap(key, value) {
+    this.ruleKeyMap.set(key, value);
+    return this;
+  }
+  setStartRow(start) {
+    this.startLine = start;
+    return this;
+  }
+  setStartColumn(start) {
+    this.startColumn = start;
+    return this;
+  }
+  setEndRow(end) {
+    this.endLine = end;
+    return this;
+  }
+  setEndColumn(end) {
+    this.endColumn = end;
+    return this;
+  }
+  parseToken(value) {
+    if (value === "") {
+      return "" /* UndefinedToken */;
+    }
+    for (const [token, alias] of this.ruleKeyMap.entries()) {
+      if (alias === value) {
+        return token;
+      }
+    }
+    return "" /* UndefinedToken */;
+  }
+  getContextMap() {
+    const ctx = /* @__PURE__ */ new Map();
+    for (const [token, expr] of this.ruleKeyMap.entries()) {
+      if (!isRuleToken(token)) {
+        const value = [{
+          express: expr,
+          key: expr,
+          tokens: [token],
+          value: token.toString()
+        }];
+        ctx.set(token, value);
+      }
+    }
+    return ctx;
+  }
+  getCompileCheckHandlers() {
+    if (this.compileCheckers !== void 0 && this.compileCheckers.length > 0) {
+      return this.compileCheckers;
+    }
+    return void 0;
+  }
+};
+var CompileContext = class _CompileContext extends RuleMapOptions {
+  constructor(m) {
+    super(m);
+    this.aliasMap = /* @__PURE__ */ new Map();
+  }
+  static create(r) {
+    const ctx = new _CompileContext(r.ruleKeyMap);
+    Object.assign(ctx, { ...r });
+    return ctx.init();
+  }
+  init() {
+    if (this.ruleKeyMap === void 0) {
+      this.ruleKeyMap = defaultRuleTokenMap;
+    }
+    return this;
+  }
+  loadAlias(m) {
+    if (m.size <= 0 || !m.has("alias" /* AliasToken */)) {
+      return this;
+    }
+    const values = m.get("alias" /* AliasToken */);
+    for (const vs of values) {
+      if (typeof vs.value === "string") {
+        this.aliasMap.set(vs.key, vs.value);
+      }
+    }
+    return this;
+  }
+  /**
+   * 设置别名缓存
+   */
+  setAlias(key, value) {
+    this.aliasMap.set(key, value);
+  }
+  /**
+   * 获取别名缓存值
+   */
+  getAlias(key) {
+    return this.aliasMap.get(key);
+  }
+  /**
+   * 检查别名是否存在
+   */
+  hasAlias(key) {
+    return this.aliasMap.has(key);
+  }
+  filterSheet(sheetName) {
+    if (sheetName !== "" && this.compileSheets !== void 0 && this.compileSheets.length > 0) {
+      return this.compileSheets.includes(sheetName);
+    }
+    return false;
+  }
+};
+var defaultRuleTokenMap = /* @__PURE__ */ new Map([
+  ["alias" /* AliasToken */, "alias" /* AliasToken */.toString()],
+  ["?" /* AnyToken */, "?" /* AnyToken */.toString()],
+  ["cell" /* CellToken */, "cell" /* CellToken */.toString()],
+  ["rowCell" /* RowCellToken */, "rowCell" /* RowCellToken */.toString()],
+  ["mergeCell" /* MergeCellToken */, "mergeCell" /* MergeCellToken */.toString()],
+  ["@" /* UseAliasToken */, "@" /* UseAliasToken */.toString()],
+  [":" /* PosToken */, ":" /* PosToken */.toString()],
+  ["-" /* RangeToken */, "-" /* RangeToken */.toString()],
+  ["<?>" /* FunctionPatternToken */, "<?>" /* FunctionPatternToken */.toString()],
+  ["${?}" /* VarPatternToken */, "${?}" /* VarPatternToken */.toString()],
+  ["=" /* EqualToken */, "=" /* EqualToken */.toString()],
+  ["," /* ArgPosToken */, "," /* ArgPosToken */.toString()],
+  ["(" /* LparenToken */, "(" /* LparenToken */.toString()],
+  [")" /* RparenToken */, ")" /* RparenToken */.toString()],
+  ["." /* DotGetToken */, "." /* DotGetToken */.toString()],
+  ["compile:Macro" /* CompileMacroToken */, "compile:Macro" /* CompileMacroToken */.toString()],
+  ["compile:GenCell" /* CompileGenToken */, "compile:GenCell" /* CompileGenToken */.toString()]
+]);
+var DefaultPlaceholderCellValue = class {
+  constructor(p, merge) {
+    this.placeholder = p;
+    this.mergeCellPlaceholder = merge === void 0 ? "" : merge;
+  }
+  mergeCell(values) {
+    if (this.mergeCellPlaceholder !== void 0) {
+      return this.mergeCellPlaceholder.replace("?", values.join(","));
+    }
+    return "";
+  }
+  toString() {
+    return this.placeholder;
+  }
+};
+var _getCells = (thisArg) => {
+  let cells = [];
+  for (let j = thisArg.minColumn; j <= thisArg.maxColumn; j += thisArg.stepColumn) {
+    for (let i = thisArg.minRow; i <= thisArg.maxRow; i += thisArg.stepRow) {
+      cells.push({
+        Row: i,
+        Column: j
+      });
+    }
+  }
+  return cells;
+};
+var TokenParserManger = class _TokenParserManger {
+  // T=xxx
+  static aliasParse(ctx, token, value) {
+    if (token !== "alias" /* AliasToken */) {
+      return {
+        ok: false
+      };
+    }
+    const parser = getTokenParser("=" /* EqualToken */);
+    const { values, expr, ok } = parser.handler(ctx, "=" /* EqualToken */, value);
+    if (!ok) {
+      return {
+        ok: false
+      };
+    }
+    if (typeof expr.value !== "string" || expr.value === "") {
+      return {
+        ok: false,
+        error: new Error(`alias express right value cannot be a empty value.`)
+      };
+    }
+    return {
+      ok: true,
+      expr: {
+        express: value,
+        key: expr.key,
+        // alias key
+        value: expr.value,
+        // alias value
+        tokens: [token, "=" /* EqualToken */]
+        //  express tokens
+      },
+      values
+    };
+  }
+  // x=xx
+  static equalParse(ctx, token, value) {
+    if (token !== "=" /* EqualToken */) {
+      return {
+        ok: false
+      };
+    }
+    const equalToken = _TokenParserManger.getTokenByCtx(ctx, "=" /* EqualToken */);
+    const offset = equalToken.length;
+    const index = value.indexOf(equalToken);
+    if (index < 0) {
+      return {
+        ok: false
+      };
+    }
+    const len = value.length;
+    const key = value.substring(0, index);
+    const rightValue = value.substring(index + offset, len);
+    if (rightValue === "") {
+      return {
+        ok: false,
+        error: new Error(`equal express right value cannot be a empty value.`)
+      };
+    }
+    const expr = {
+      key,
+      value: rightValue,
+      express: value,
+      tokens: [token]
+    };
+    return {
+      ok: true,
+      values: [key, rightValue],
+      expr
+    };
+  }
+  //cell| X:Y=${?}
+  static cellParse(ctx, token, value) {
+    if (token !== "cell" /* CellToken */) {
+      return {
+        ok: false
+      };
+    }
+    const equalToken = _TokenParserManger.getTokenByCtx(ctx, "=" /* EqualToken */);
+    const eqOffset = equalToken.length;
+    const posToken = _TokenParserManger.getTokenByCtx(ctx, ":" /* PosToken */);
+    const eqIndex = value.indexOf(equalToken);
+    const posIndex = value.indexOf(posToken);
+    if (eqIndex < 0 || posIndex < 0) {
+      return {
+        ok: false
+      };
+    }
+    const parser = getTokenParser(":" /* PosToken */);
+    const varParser = getTokenParser("${?}" /* VarPatternToken */);
+    const posValue = value.substring(0, eqIndex);
+    const varValue = value.substring(eqIndex + eqOffset);
+    const posReply = parser.handler(ctx, ":" /* PosToken */, posValue);
+    if (!posReply.ok) {
+      return {
+        ok: false,
+        ...posReply
+      };
+    }
+    const varReply = varParser.handler(ctx, "${?}" /* VarPatternToken */, varValue);
+    if (!varReply.ok) {
+      return {
+        ok: false,
+        ...varReply
+      };
+    }
+    const expr = {
+      ...varReply.expr
+    };
+    expr.express = value;
+    expr.cells = posReply.expr.cells;
+    expr.value = varReply.expr.value;
+    expr.ref = varReply.expr.ref;
+    expr.tokens = [token, "=" /* EqualToken */, ...posReply.expr.tokens, ...varReply.expr.tokens];
+    return {
+      ok: true,
+      expr,
+      values: [posReply.values, varReply.values]
+    };
+  }
+  static useAliasParse(ctx, token, value) {
+    if (token !== "@" /* UseAliasToken */) {
+      return {
+        ok: false
+      };
+    }
+    const useAliasToken = _TokenParserManger.getTokenByCtx(ctx, "@" /* UseAliasToken */);
+    const offset = useAliasToken.length;
+    const has = offset !== 0 && value.indexOf(useAliasToken) >= 0;
+    if (!has) {
+      return {
+        ok: false
+      };
+    }
+    const endTokens = ["@" /* UseAliasToken */, "(" /* LparenToken */, "," /* ArgPosToken */, "." /* DotGetToken */];
+    const values = _TokenParserManger.scanToken(value, useAliasToken, _TokenParserManger.toList(ctx, endTokens));
+    if (values === void 0 || values.length <= 0) {
+      return {
+        ok: false
+      };
+    }
+    const keys = [];
+    const tokens = [];
+    const expr = {
+      express: value,
+      tokens,
+      value: keys,
+      ref: []
+    };
+    for (const v of values) {
+      tokens.push(token);
+      keys.push(v.token);
+      expr.ref.push(v.value);
+    }
+    expr.value = keys;
+    expr.tokens = tokens;
+    return {
+      expr,
+      ok: true,
+      values
+    };
+  }
+  static rangeParse(ctx, token, value) {
+    if (token !== "-" /* RangeToken */) {
+      return {
+        ok: false
+      };
+    }
+    const rangeToken = _TokenParserManger.getTokenByCtx(ctx, "-" /* RangeToken */);
+    const offset = rangeToken.length;
+    const index = value.indexOf(rangeToken);
+    if (index < 0 || offset <= 0) {
+      return {
+        ok: false
+      };
+    }
+    let setup = 1;
+    let startNumber = NaN;
+    let endNumber = NaN;
+    let startPos = value.substring(0, index).trim();
+    let endPos = value.substring(index + offset).trim();
+    const argPosToken = _TokenParserManger.getTokenByCtx(ctx, "," /* ArgPosToken */);
+    const endSetupIndex = endPos.indexOf(argPosToken);
+    if (endSetupIndex > 0) {
+      setup = Number.parseInt(endPos.substring(endSetupIndex).trim(), 10);
+      endPos = endPos.substring(0, endSetupIndex).trim();
+    }
+    if (isNaN(setup)) {
+      return {
+        ok: false,
+        error: new Error(`rangeToken parse setup NaN, ${value}`)
+      };
+    }
+    endNumber = _TokenParserManger.parsePosNumber(endPos);
+    startNumber = _TokenParserManger.parsePosNumber(startPos);
+    if (isNaN(startNumber) || isNaN(endNumber)) {
+      return {
+        ok: false,
+        error: new Error(`rangeToken parse start,end has NaN, ${value}`)
+      };
+    }
+    const expr = {
+      express: value,
+      tokens: [token],
+      value: [startNumber, endNumber, setup]
+    };
+    return {
+      expr,
+      ok: true,
+      values: [startNumber, endNumber, setup]
+    };
+  }
+  static posParse(ctx, token, value) {
+    if (token !== ":" /* PosToken */) {
+      return {
+        ok: false
+      };
+    }
+    const posToken = _TokenParserManger.getTokenByCtx(ctx, ":" /* PosToken */);
+    const offset = posToken.length;
+    const index = value.indexOf(posToken);
+    const len = value.length;
+    const column = value.substring(0, index).trim();
+    const row = value.substring(index + offset, len).trim();
+    const rangeToken = _TokenParserManger.getTokenByCtx(ctx, "-" /* RangeToken */);
+    const columnRange = column.indexOf(rangeToken);
+    const rowRange = row.indexOf(rangeToken);
+    if (rowRange > 0 || columnRange > 0) {
+      return _TokenParserManger.parseRangeValue(ctx, { rowRange, columnRange, row, column, token, express: value });
+    }
+    const cell = {
+      Row: Number.parseInt(row, 10),
+      Column: columnLetterToNumber(column)
+    };
+    const expr = {
+      value: cell,
+      cells: [cell],
+      express: value,
+      tokens: [token]
+    };
+    return {
+      ok: true,
+      values: [row, column],
+      expr
+    };
+  }
+  // value input: A-AQ:13-15=<sum(#,[compile:Macro(exprArr,[F],[13,15],!codeKey)],compile:Marco(index),0)>
+  // output: {
+  //      A:13 => sum(#,[ codeKey(F:13.value),codeKey(F:14.value),codeKey(F:15.value)],1,0),
+  //      B:13 => sum(#,[ codeKey(F:13.value),codeKey(F:14.value),codeKey(F:15.value)],2,0),
+  //      C:13 => sum(#,[ codeKey(F:13.value),codeKey(F:14.value),codeKey(F:15.value)],3,0),
+  //     ....,
+  //     A:14 => sum(#,[ codeKey(F:13.value),codeKey(F:14.value),codeKey(F:15.value)],1,0),
+  //     B:14 => sum(#,[ codeKey(F:13.value),codeKey(F:14.value),codeKey(F:15.value)],2,0),
+  //     C:14 => sum(#,[ codeKey(F:13.value),codeKey(F:14.value),codeKey(F:15.value)],3,0),
+  //  }
+  static mergeCellParse(ctx, token, value) {
+    if (token !== "mergeCell" /* MergeCellToken */ && token !== "rowCell" /* RowCellToken */) {
+      return { ok: false };
+    }
+    const equalToken = _TokenParserManger.getTokenByCtx(ctx, "=" /* EqualToken */);
+    const index = value.indexOf(equalToken);
+    const offset = equalToken.length;
+    if (index <= 0) return { ok: false, error: new Error(`merge cell config syntax error: ${value}`) };
+    const rangeStr = value.substring(0, index).trim();
+    const exprStr = value.substring(index + offset);
+    const posParser = getTokenParser(":" /* PosToken */);
+    const posReply = posParser.handler(ctx, ":" /* PosToken */, rangeStr);
+    const functionToken = getTokenParser("<?>" /* FunctionPatternToken */);
+    if (!posReply.ok) return { ok: false, ...posReply };
+    const macroGenToken = _TokenParserManger.getTokenByCtx(ctx, "compile:GenCell" /* CompileGenToken */);
+    const expr = {
+      express: value,
+      value: exprStr,
+      // The template expression
+      posExpr: posReply.expr,
+      tokens: [token, ...posReply.expr.tokens]
+    };
+    if (exprStr.startsWith(macroGenToken)) {
+      const argsSplitToken = _TokenParserManger.getTokenByCtx(ctx, "," /* ArgPosToken */);
+      const args = _TokenParserManger.split(exprStr, argsSplitToken, [`(`, `)`]);
+      const macro = _TokenParserManger.filterMacro(args);
+      const aliasTokens = _TokenParserManger.extractUseAliasTokens(ctx, args);
+      if (aliasTokens !== void 0 && aliasTokens.length > 0) {
+        expr.tokens.push(...aliasTokens);
+      }
+      if (macro !== void 0 && macro.tokens.length > 0) {
+        expr.macro = macro;
+        expr.tokens.push(...macro.tokens);
+      }
+    } else {
+      const exprReply = functionToken.handler(ctx, "<?>" /* FunctionPatternToken */, exprStr);
+      if (exprReply.error !== void 0 && exprReply.error instanceof Error) {
+        return {
+          ok: false,
+          ...exprReply
+        };
+      }
+      if (exprReply.ok && exprReply.expr !== void 0) {
+        expr.funcExpr = exprReply.expr;
+        expr.tokens.push(...exprReply.expr.tokens);
+      }
+    }
+    return {
+      ok: true,
+      expr,
+      values: [rangeStr, exprStr]
+    };
+  }
+  // G-AQ:12=compile:GenCell(compile:Macro(expr,F,12),'.',compile:Marco(index))
+  static rowCellParse(ctx, token, value) {
+    if (token !== "rowCell" /* RowCellToken */) {
+      return { ok: false };
+    }
+    return _TokenParserManger.mergeCellParse(ctx, token, value);
+  }
+  // $functionName($arg0:string,$arg1:string[],$arg2:string|number,$arg3:string|number)
+  // eg: func(A,[xx1,xx2],xxx3), sum(#,[F,12,13],1,0)
+  // $functionName not in compile:Macro,compile:GenCell
+  // extract => {func:$functionName, arguments:[$arg0,$arg1,$arg2,$argN...]}
+  // output: {func:"sum",arguments:["A",["F","12","13"],"1","0"]}
+  static functionPatternParse(ctx, token, value) {
+    if (token !== "<?>" /* FunctionPatternToken */) {
+      return { ok: false };
+    }
+    const wordToken = _TokenParserManger.getTokenByCtx(ctx, "?" /* AnyToken */);
+    const funcToken = _TokenParserManger.getTokenByCtx(ctx, "<?>" /* FunctionPatternToken */);
+    const splitIndex = funcToken.indexOf(wordToken);
+    const splitOffset = wordToken.length;
+    const funcStartToken = funcToken.substring(0, splitIndex);
+    const funcEndToken = funcToken.substring(splitIndex + splitOffset);
+    const rparenToken = _TokenParserManger.getTokenByCtx(ctx, ")" /* RparenToken */);
+    const lparenToken = _TokenParserManger.getTokenByCtx(ctx, "(" /* LparenToken */);
+    const argsSplitToken = _TokenParserManger.getTokenByCtx(ctx, "," /* ArgPosToken */);
+    if (value.startsWith(funcStartToken) && value.endsWith(funcEndToken)) {
+      const content = value.substring(1, value.length - 1);
+      const lparen = content.indexOf(lparenToken);
+      const rparen = content.lastIndexOf(rparenToken);
+      if (lparen > 0 && rparen > lparen) {
+        const funcName = content.substring(0, lparen);
+        const argsStr = content.substring(lparen + lparenToken.length, rparen);
+        const args = _TokenParserManger.split(argsStr, argsSplitToken, [`[`, `]`]);
+        const macro = _TokenParserManger.filterMacro(args);
+        const tokens = [token];
+        const expr = {
+          express: value,
+          func: funcName,
+          value: args,
+          // arguments array
+          tokens
+        };
+        const alias = _TokenParserManger.extractUseAliasTokens(ctx, args);
+        if (alias !== void 0 && alias.length > 0) {
+          expr.tokens.push(...alias);
+        }
+        if (macro !== void 0 && macro.tokens.length > 0) {
+          expr.macro = macro;
+          expr.tokens.push(...macro.tokens);
+        }
+        return {
+          ok: true,
+          expr,
+          values: [funcName, args]
+        };
+      }
+    }
+    return {
+      ok: false,
+      error: new Error(`function express systax error`)
+    };
+  }
+  static varPatternParse(ctx, token, value) {
+    if (token !== "${?}" /* VarPatternToken */) {
+      return { ok: false };
+    }
+    const wordToken = _TokenParserManger.getTokenByCtx(ctx, "?" /* AnyToken */);
+    const varToken = _TokenParserManger.getTokenByCtx(ctx, "${?}" /* VarPatternToken */);
+    const index = varToken.indexOf(wordToken);
+    const workTokenOffset = wordToken.length;
+    const startToken = varToken.substring(0, index);
+    const endToken = varToken.substring(workTokenOffset + index);
+    if (!value.startsWith(startToken) || !value.endsWith(endToken)) {
+      return {
+        ok: false,
+        error: new Error(`variable expression syntax error,\${ or } flag is miss`)
+      };
+    }
+    const innerContent = value.substring(startToken.length, value.length - endToken.length);
+    if (innerContent === "") {
+      return {
+        ok: false,
+        error: new Error("variable expression syntax error, variable name is empty")
+      };
+    }
+    const expr = {
+      express: value,
+      value: innerContent,
+      tokens: [token]
+    };
+    const aliasToken = _TokenParserManger.getTokenByCtx(ctx, "@" /* UseAliasToken */);
+    if (innerContent.indexOf(aliasToken) >= 0) {
+      const parser = getTokenParser("@" /* UseAliasToken */);
+      const aliasReply = parser.handler(ctx, "@" /* UseAliasToken */, innerContent);
+      if (aliasReply.ok) {
+        expr.ref = aliasReply.expr.ref;
+        expr.alias = aliasReply.values;
+        expr.tokens.push(...aliasReply.expr.tokens);
+      }
+    }
+    return {
+      expr,
+      ok: true,
+      values: [innerContent]
+    };
+  }
+  // compile:GenCell(expr1,expr2,...,) => {G:13=>`${expr1}${expr2}..`,G:14=>`${expr1}${expr2}..`,G:15=>`${expr1}${expr2}..`,...}
+  // compile:Macro($exprType,$X,$Y,$formater)
+  // $exprType: enums [ expr:(single value), exprArr:(array value) ]
+  // $X: column index value, number|string or number[]|string[]
+  // $Y: row index value, number or number[]
+  // $formater: enums [ codeKey(a function for format string),number(a function for string to number) ]
+  // compile:Macro(exprArr,[X1,X2],[Y1,Y2],!codeKey) =>
+  // codeKey(X1:Y1.value),codeKey(X1:Y2.value),codeKey(X2:Y1.value),codeKey(X2:Y2.value)
+  // compile:Macro(exprArr,[X1],[Y1,Y2],!codeKey) => codeKey(X1:Y1.value),codeKey(X1:Y2.value)
+  // compile:Marco(index,!number) => number(i),number(i+1),number(i+2) ,i=1
+  static compileExprExtract(value) {
+    const results = [];
+    const lp = "(" /* LparenToken */.toString();
+    const args = "," /* ArgPosToken */.toString();
+    const values = value.split(lp);
+    for (const v of values) {
+      let items = [];
+      if (v.indexOf(args) >= 0) {
+        items = v.split(args);
+      } else {
+        items.push(v);
+      }
+      for (const it of items) {
+        if (it === "compile:Macro" /* CompileMacroToken */.toString() || it.startsWith("compile:Macro" /* CompileMacroToken */) || it.endsWith("compile:Macro" /* CompileMacroToken */)) {
+          results.push("compile:Macro" /* CompileMacroToken */);
+        } else if (it === "compile:GenCell" /* CompileGenToken */.toString() || it.startsWith("compile:GenCell" /* CompileGenToken */) || it.endsWith("compile:GenCell" /* CompileGenToken */)) {
+          results.push("compile:GenCell" /* CompileGenToken */);
+        }
+      }
+    }
+    return results;
+  }
+  static getTokenByCtx(ctx, token) {
+    if (ctx.size <= 0 || !ctx.has(token)) {
+      return token.toString();
+    }
+    const values = ctx.get(token);
+    if (values.length <= 0 || values[0].key === "") {
+      return token.toString();
+    }
+    return values[0].key;
+  }
+  static scanToken(value, startToken, endTokens) {
+    let token = "";
+    let data = "";
+    let end = false;
+    let start = false;
+    const items = [];
+    const offset = [startToken, ...endTokens].sort((a, b) => a.length - b.length)[0].length;
+    const size = value.length;
+    for (let i = 0; i < size; i += offset) {
+      let leftToken;
+      if (value[i] === startToken) {
+        start = true;
+        if (token !== "") {
+          items.push({
+            token,
+            value: ""
+          });
+        }
+        token = startToken;
+      } else {
+        start = token === startToken;
+        leftToken = `${token}${value[i]}`;
+      }
+      let subfix = endTokens.filter((s) => s === leftToken);
+      end = endTokens.includes(value[i]) || subfix.length > 0;
+      if (subfix.length > 0) {
+        token = leftToken;
+        data = "";
+      }
+      if (start && end) {
+        continue;
+      }
+      if (!end) {
+        token = `${token}${value[i]}`;
+        data = `${data}${value[i]}`;
+      }
+      if (end || i + offset >= size) {
+        if (data !== "") {
+          items.push({
+            token,
+            value: data
+          });
+        }
+        token = "";
+        data = "";
+        end = false;
+      }
+    }
+    return items;
+  }
+  static split(argsStr, argsSplitToken, ignoreTokenRange) {
+    let value = "";
+    let depth = 0;
+    const items = [];
+    const splitLen = argsSplitToken.length;
+    const startLen = ignoreTokenRange[0].length;
+    const endLen = ignoreTokenRange[1].length;
+    const startToken = ignoreTokenRange[0];
+    const endToken = ignoreTokenRange[1];
+    const isToggleMode = startToken === endToken;
+    for (let i = 0; i < argsStr.length; ) {
+      const substr = argsStr.substring(i);
+      if (depth > 0 && substr.startsWith(endToken)) {
+        value += endToken;
+        i += endLen;
+        depth = isToggleMode ? 0 : depth - 1;
+        continue;
+      }
+      if (substr.startsWith(startToken)) {
+        if (!isToggleMode || depth === 0) {
+          value += startToken;
+          i += startLen;
+          depth++;
+          continue;
+        }
+      }
+      if (depth === 0 && substr.startsWith(argsSplitToken)) {
+        items.push(value);
+        value = "";
+        i += splitLen;
+        continue;
+      }
+      value += argsStr[i];
+      i++;
+    }
+    if (value !== "") {
+      items.push(value);
+    }
+    return items;
+  }
+  static filterMacro(values) {
+    const filter = {
+      tokens: [],
+      express: []
+    };
+    for (const expr of values) {
+      let items = _TokenParserManger.compileExprExtract(expr);
+      if (items === void 0 || items.length <= 0) {
+        continue;
+      }
+      filter.express.push(expr);
+      filter.tokens.push(...items);
+    }
+    return filter.tokens.push() <= 0 ? void 0 : filter;
+  }
+  static extractUseAliasTokens(ctx, args) {
+    const tokens = [];
+    const useAliasToken = _TokenParserManger.getTokenByCtx(ctx, "@" /* UseAliasToken */);
+    args.forEach((v) => v.startsWith(useAliasToken) && tokens.push("@" /* UseAliasToken */));
+    return tokens;
+  }
+  static toList(ctx, endTokens) {
+    const items = [];
+    for (const token of endTokens) {
+      items.push(_TokenParserManger.getTokenByCtx(ctx, token));
+    }
+    return items;
+  }
+  static parseRangeValue(ctx, options) {
+    let rowReply;
+    let columnReply;
+    const rangeCell = {
+      stepRow: 1,
+      stepColumn: 1,
+      minColumn: 0,
+      minRow: 0,
+      maxRow: 0,
+      maxColumn: 0,
+      getCells: function() {
+        return _getCells(this);
+      }
+    };
+    const { rowRange, row, column, columnRange, express, token } = options;
+    const rangeParse = getTokenParser("-" /* RangeToken */);
+    if (rowRange > 0) {
+      columnReply = rangeParse.handler(ctx, "-" /* RangeToken */, row);
+    } else {
+      const rowValue = Number.parseInt(row, 10);
+      rangeCell.maxRow = rowValue;
+      rangeCell.minRow = rowValue;
+    }
+    if (columnRange > 0) {
+      rowReply = rangeParse.handler(ctx, "-" /* RangeToken */, column);
+    } else {
+      const columnValue = columnLetterToNumber(column);
+      rangeCell.maxColumn = columnValue;
+      rangeCell.minColumn = columnValue;
+    }
+    if (columnReply !== void 0) {
+      if (!columnReply.ok || columnReply.values === void 0) {
+        return columnReply;
+      }
+      const values = columnReply.values;
+      let min = values[0];
+      let max = values[1];
+      let setup = values[2] ?? 1;
+      rangeCell.minRow = min;
+      rangeCell.maxRow = max;
+      rangeCell.stepRow = setup;
+    }
+    if (rowReply !== void 0) {
+      if (!rowReply.ok || rowReply.values === void 0) {
+        return rowReply;
+      }
+      const values = rowReply.values;
+      let min = values[0];
+      let max = values[1];
+      let setup = values[2] ?? 1;
+      rangeCell.minColumn = min;
+      rangeCell.maxColumn = max;
+      rangeCell.stepColumn = setup;
+    }
+    const expr = {
+      express,
+      tokens: [token],
+      //  express tokens
+      value: rangeCell
+      // alias value
+    };
+    return {
+      ok: true,
+      expr,
+      values: rangeCell
+    };
+  }
+  static parsePosNumber(value) {
+    let num = NaN;
+    if (isPureNumber.test(value)) {
+      num = Number.parseInt(value, 10);
+    } else if (isPureUppercase.test(value)) {
+      num = columnLetterToNumber(value);
+    }
+    return !isNaN(num) && num <= 0 ? NaN : num;
+  }
+};
+var defaultRuleTokenParserMap = /* @__PURE__ */ new Map([
+  ["alias" /* AliasToken */, TokenParserManger.aliasParse],
+  ["cell" /* CellToken */, TokenParserManger.cellParse],
+  ["=" /* EqualToken */, TokenParserManger.equalParse],
+  ["mergeCell" /* MergeCellToken */, TokenParserManger.mergeCellParse],
+  ["rowCell" /* RowCellToken */, TokenParserManger.rowCellParse],
+  ["@" /* UseAliasToken */, TokenParserManger.useAliasParse],
+  ["-" /* RangeToken */, TokenParserManger.rangeParse],
+  [":" /* PosToken */, TokenParserManger.posParse],
+  ["${?}" /* VarPatternToken */, TokenParserManger.varPatternParse],
+  ["<?>" /* FunctionPatternToken */, TokenParserManger.functionPatternParse]
+]);
+var macroTokens = ["compile:GenCell" /* CompileGenToken */, "compile:Macro" /* CompileMacroToken */];
+function columnLetterToNumber(letter) {
+  let num = 0;
+  for (let i = 0; i < letter.length; i++) {
+    num = num * 26 + (letter.charCodeAt(i) - 64);
+  }
+  return num;
+}
+function columnNumberToLetter(num) {
+  if (num <= 0) {
+    return "";
+  }
+  let letter = "";
+  while (num > 0) {
+    let remainder = (num - 1) % 26;
+    letter = String.fromCharCode(65 + remainder) + letter;
+    num = Math.floor((num - 1) / 26);
+  }
+  return letter;
+}
+function isBase64(str) {
+  if (str.length < 20) return false;
+  if (str.includes("\\") || str.includes(" ")) return false;
+  if (str.indexOf("./") >= 0 || str.startsWith("file://") || str.startsWith("/") || str.startsWith(".")) {
+    return false;
+  }
+  const data = str.replace(/^data:.*?;base64,/, "");
+  const cleanedStr = data.replace(/[\r\n]/g, "");
+  try {
+    return Buffer.from(cleanedStr, "base64").toString("utf-8") !== "";
+  } catch (e) {
+    return false;
+  }
+}
+function base64ToArrayBuffer(base64) {
+  const data = base64.replace(/^data:.*?;base64,/, "");
+  const binaryString = atob(data);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+function getMergeRange(ws, row, col) {
+  const merges = ws.model.merges;
+  for (const mergeStr of merges) {
+    const parts = mergeStr.split(":");
+    const tl = ws.getCell(parts[0]);
+    const br = ws.getCell(parts[1]);
+    const tlRow = Number(tl.row);
+    const tlCol = Number(tl.col);
+    const brRow = Number(br.row);
+    const brCol = Number(br.col);
+    if (row >= tlRow && row <= brRow && col >= tlCol && col <= brCol) {
+      return {
+        top: tlRow,
+        left: tlCol,
+        bottom: brRow,
+        right: brCol
+      };
+    }
+  }
+  return null;
+}
+var resolveCompileMacroGen = (ctx, expr, currentCellIndex) => {
+  let parts = [];
+  let join2 = ".";
+  const m = ctx.getContextMap();
+  const aliasToken = TokenParserManger.getTokenByCtx(m, "@" /* UseAliasToken */);
+  const genToken = TokenParserManger.getTokenByCtx(m, "compile:GenCell" /* CompileGenToken */);
+  const endTokens = ["compile:GenCell" /* CompileGenToken */, "(" /* LparenToken */, "," /* ArgPosToken */, ")" /* RparenToken */];
+  const values = TokenParserManger.scanToken(expr, genToken, TokenParserManger.toList(m, endTokens));
+  for (const [_, item] of values.entries()) {
+    if (item.value === void 0 && item.value !== "") {
+      continue;
+    }
+    if (!item.token.startsWith(aliasToken) && item.value !== exprIndex) {
+      parts.push(item.value);
+    } else {
+      parts.push(resolveAliasExpr(ctx, item.value, currentCellIndex));
+    }
+  }
+  return parts.join(join2);
+};
+var getExprEnd = function(macroExpr, matchIndex, rparenToken) {
+  return macroExpr.indexOf(rparenToken, matchIndex);
+};
+var macroFormatters = [numberKey, codeKey];
+var extractMacro = function(expr, options) {
+  let end = NaN;
+  const offset = options.startToken.length;
+  const startIndex = expr.indexOf(options.startToken);
+  const endIndex = expr.indexOf(options.endToken);
+  const argValues = expr.substring(startIndex + offset, endIndex);
+  const values = argValues.split(options.argToken);
+  const extracResult = { type: values[0], rowParam: [], columnParam: void 0 };
+  if (values.length > 1) {
+    extracResult.columnParam = columnLetterToNumber(values[1]);
+  }
+  if (macroFormatters.includes(values[values.length - 1])) {
+    end = values.length - 1;
+    extracResult.formatter = values[end];
+  }
+  if (!isNaN(end) && values.length > 2) {
+    extracResult.rowParam = values.slice(2, end).map((x) => Number.parseInt(x, 10));
+  } else if (values.length > 2) {
+    extracResult.rowParam = values.slice(2, values.length).map((x) => Number.parseInt(x, 10));
+  }
+  if (extracResult.rowParam !== void 0 && extracResult.rowParam instanceof Array && extracResult.rowParam.length === 1) {
+    extracResult.rowParam = extracResult.rowParam[0];
+  }
+  return extracResult;
+};
+var __codeKey = (str) => {
+  let vs = str.trim().replace("-", "_").replace("/", "_").trim();
+  for (; vs.indexOf("__") >= 0; ) {
+    vs = vs.replace("__", "_");
+  }
+  for (; vs.indexOf(" ") >= 0; ) {
+    vs = vs.replace(" ", "");
+  }
+  return vs.trim().toUpperCase();
+};
+var __numberKey = (str) => {
+  return Number.parseInt(str, 10).toString();
+};
+var macroFormatter = /* @__PURE__ */ new Map([
+  [codeKey, __codeKey],
+  [numberKey, __numberKey],
+  [defaultKey, (v) => v]
+]);
+var execMacroFormat = function(value, formatter) {
+  if (!macroFormatter.has(formatter)) {
+    return value;
+  }
+  return macroFormatter.get(formatter)(value);
+};
+var toCellRow = (rowVals, setup) => {
+  if (setup === void 0) {
+    setup = 1;
+  }
+  if (rowVals.length == 2) {
+    const values = [];
+    for (let start = rowVals[0]; start <= rowVals[1]; start += setup) {
+      values.push(start);
+    }
+    return values;
+  }
+  return rowVals;
+};
+var toCellColumn = (columnVals, setup) => {
+  return toCellRow(columnVals, setup);
+};
+var resolveCompileMacroExpr = (ctx, macroExpr, macroTokens2, currentCellIndex, totalCells) => {
+  if (macroTokens2 === void 0 || macroTokens2.length <= 0) {
+    return macroExpr;
+  }
+  const sheet = ctx.sheet;
+  if (sheet === void 0) {
+    throw new Error(`miss context worksheet`);
+  }
+  const m = ctx.getContextMap();
+  const argToken = TokenParserManger.getTokenByCtx(m, "," /* ArgPosToken */);
+  const rparenToken = TokenParserManger.getTokenByCtx(m, ")" /* RparenToken */);
+  const lparenToken = TokenParserManger.getTokenByCtx(m, "(" /* LparenToken */);
+  const genToken = TokenParserManger.getTokenByCtx(m, "compile:GenCell" /* CompileGenToken */);
+  const maroToken = TokenParserManger.getTokenByCtx(m, "compile:Macro" /* CompileMacroToken */);
+  const tokenMap = /* @__PURE__ */ new Map();
+  for (const [index, token] of macroTokens2.entries()) {
+    let items = [];
+    if (tokenMap.has(token)) {
+      items = tokenMap.get(token);
+    }
+    items.push(index);
+    tokenMap.set(token, items);
+  }
+  const resolveArray = (param) => {
+    if (param instanceof Array) {
+      return param;
+    }
+    return [param];
+  };
+  if (tokenMap.has("compile:Macro" /* CompileMacroToken */)) {
+    let offset = 0;
+    let exprValue = macroExpr;
+    const times = tokenMap.get("compile:Macro" /* CompileMacroToken */).length;
+    for (let i = times; i > 0; i--) {
+      const matchIndex = exprValue.indexOf(maroToken, offset);
+      if (matchIndex < 0) {
+        break;
+      }
+      offset = getExprEnd(exprValue, matchIndex, rparenToken);
+      const macroCurrent = exprValue.substring(matchIndex, offset + rparenToken.length);
+      const opts = { startToken: lparenToken, endToken: rparenToken, argToken };
+      let { type, columnParam, rowParam, formatter } = extractMacro(macroCurrent, opts);
+      let rowVals;
+      let columnVals;
+      const parts = [];
+      if (columnParam !== void 0 && rowParam !== void 0) {
+        rowVals = resolveArray(rowParam);
+        columnVals = resolveArray(columnParam);
+        const rowItems = toCellRow(rowVals);
+        const columnItems = toCellColumn(columnVals);
+        rowItems.forEach((r) => {
+          columnItems.forEach((c) => {
+            const cellValue = sheet.findCell(r, c);
+            if (cellValue === void 0 || cellValue.value === null) {
+              return;
+            }
+            const value = cellValue.value;
+            parts.push(execMacroFormat(value.toString(), formatter));
+          });
+        });
+      }
+      if (type === exprArr) {
+        macroExpr = macroExpr.replace(macroCurrent, parts.join(","));
+      } else if (type === exprSingle) {
+        macroExpr = macroExpr.replace(macroCurrent, parts[0]);
+      } else if (type === exprIndex) {
+        const indexValue = currentCellIndex + 1;
+        macroExpr = macroExpr.replace(macroCurrent, indexValue.toString());
+      }
+    }
+  }
+  if (tokenMap.has("compile:GenCell" /* CompileGenToken */)) {
+    let exprValue = macroExpr;
+    const times = tokenMap.get("compile:GenCell" /* CompileGenToken */).length;
+    for (let i = times; i > 0; i--) {
+      const matchIndex = exprValue.indexOf(genToken);
+      if (matchIndex < 0) {
+        break;
+      }
+      const offset = getExprEnd(exprValue, matchIndex, rparenToken);
+      const macroCurrent = exprValue.substring(matchIndex, offset + rparenToken.length);
+      exprValue = resolveCompileMacroGen(ctx, macroCurrent, currentCellIndex);
+    }
+    macroExpr = exprValue;
+  }
+  return macroExpr;
+};
+var loadWorkbook = async function(data) {
+  const w = new exceljs.Workbook();
+  if (typeof data === "string") {
+    if (!isBase64(data)) {
+      await w.xlsx.readFile(data);
+    } else {
+      await w.xlsx.load(base64ToArrayBuffer(data));
+    }
+  } else if (data instanceof Stream) {
+    await w.xlsx.read(data);
+  } else if (data instanceof ArrayBuffer) {
+    await w.xlsx.load(data);
+  } else if (data instanceof Buffer) {
+    await w.xlsx.load(data);
+  } else {
+    throw new Error(`unSupport buffer type ${typeof data}`);
+  }
+  return w;
+};
+var scanCellSetPlaceholder = async function(excelBuffer, cell, placeholder) {
+  const workbook = await loadWorkbook(excelBuffer);
+  const worksheet = workbook.getWorksheet(cell.Sheet);
+  if (!worksheet) return void 0;
+  workSheetSetPlaceholder(worksheet, cell, placeholder);
+  return workbook.xlsx.writeBuffer();
+};
+var workSheetSetPlaceholder = function(worksheet, cell, placeholder) {
+  const colNum = columnLetterToNumber(cell.Row);
+  const rowNum = cell.Column;
+  const targetCell = worksheet.getCell(rowNum, colNum);
+  if (targetCell.isMerged) {
+    const range = getMergeRange(worksheet, rowNum, colNum);
+    if (range) {
+      const leftCol = colNum - 1;
+      const values = [];
+      if (leftCol > 0) {
+        for (let r = range.top; r <= range.bottom; r++) {
+          const val = worksheet.getCell(r, leftCol).value;
+          if (val !== null && val !== void 0 && val !== "") {
+            values.push(String(val));
+          }
+        }
+      }
+      if (values.length === 0) {
+        targetCell.value = placeholder.toString();
+      } else {
+        targetCell.value = placeholder.mergeCell(values);
+      }
+      return worksheet;
+    }
+  }
+  const currentValue = targetCell.value;
+  if (currentValue === null || currentValue === void 0 || currentValue === "") {
+    targetCell.value = placeholder.toString();
+  }
+  return worksheet;
+};
+var compileCellTokens = ["cell" /* CellToken */, "mergeCell" /* MergeCellToken */, "rowCell" /* RowCellToken */];
+var ruleTokens = ["alias" /* AliasToken */, "cell" /* CellToken */, "mergeCell" /* MergeCellToken */, "rowCell" /* RowCellToken */];
+var isRuleToken = function(t) {
+  return ruleTokens.includes(t);
+};
+var mergeOption = function(ruleKeyMap, defaultRuleTokenMap2) {
+  for (const [key, value] of defaultRuleTokenMap2.entries()) {
+    if (!ruleKeyMap.has(key)) {
+      ruleKeyMap.set(key, value);
+    }
+  }
+  return ruleKeyMap;
+};
+var getTokenParser = function(token) {
+  if (!defaultRuleTokenParserMap.has(token)) {
+    return {
+      exists: false
+    };
+  }
+  return {
+    exists: true,
+    handler: defaultRuleTokenParserMap.get(token)
+  };
+};
+var registerTokenParser = function(token, h) {
+  if (defaultRuleTokenParserMap.has(token)) {
+    return false;
+  }
+  defaultRuleTokenParserMap.set(token, h);
+  return true;
+};
+var registerTokenParserMust = function(token, h) {
+  defaultRuleTokenParserMap.set(token, h);
+};
+var scanWorkSheetRules = function(worksheet, options) {
+  const result = { rules: options.getContextMap() };
+  for (let r = options.startLine; r <= options.endLine; r++) {
+    let emptyValue = false;
+    let ruleToken = "" /* UndefinedToken */;
+    for (let c = options.startColumn; c <= options.endColumn; c++) {
+      const cell = worksheet.findCell(r, c);
+      if (cell === void 0 || cell.value === void 0 || cell.value === null) {
+        continue;
+      }
+      const cellValue = cell.value;
+      const value = cellValue.toString();
+      let isStartCell = c === options.startColumn;
+      if (emptyValue && ruleToken === "" /* UndefinedToken */) {
+        isStartCell = true;
+      }
+      if (value === "" && isStartCell) {
+        emptyValue = true;
+        continue;
+      }
+      if (isStartCell) {
+        ruleToken = options.parseToken(value);
+        continue;
+      } else {
+        if (!isRuleToken(ruleToken)) {
+          break;
+        }
+        emptyValue = false;
+      }
+      const { handler, exists } = getTokenParser(ruleToken);
+      if (!exists) {
+        continue;
+      }
+      let values = [];
+      if (result.rules.has(ruleToken)) {
+        values = result.rules.get(ruleToken);
+      }
+      const { expr, ok } = handler(result.rules, ruleToken, value);
+      if (ok && expr !== void 0) {
+        values.push(expr);
+      }
+      result.rules.set(ruleToken, values);
+    }
+  }
+  return result;
+};
+var parseWorkSheetRules = function(worksheet, options) {
+  const result = { rules: /* @__PURE__ */ new Map() };
+  if (worksheet === void 0 || worksheet === null) {
+    return result;
+  }
+  if (options === void 0) {
+    options = new RuleMapOptions();
+  }
+  return scanWorkSheetRules(worksheet, options.parseDefault(worksheet));
+};
+var compileCheck = function(iv, ctx) {
+  if (iv.rules.size <= 0) {
+    return void 0;
+  }
+  const errs = [];
+  const values = iv.rules.get("alias" /* AliasToken */);
+  if (values !== void 0 && values.length > 0) {
+    const set = /* @__PURE__ */ new Set();
+    for (const [idx, value] of values.entries()) {
+      if (idx === 0) {
+        set.add(value.key);
+        continue;
+      }
+      if (set.has(value.key)) {
+        errs.push(Error(`Duplicate alias(${value.key},${value.express}) configuration`));
+      }
+    }
+  }
+  const handlers = ctx.getCompileCheckHandlers();
+  if (handlers !== void 0 && handlers.length > 0) {
+    for (const h of handlers) {
+      let err = h(iv, ctx);
+      if (err !== void 0 && err.length > 0) {
+        errs.push(...err);
+      }
+    }
+  }
+  if (errs.length > 0) {
+    return errs;
+  }
+  return void 0;
+};
+var getMacroTokens = function(expr) {
+  const tokens = [];
+  for (const token of expr.tokens) {
+    if (macroTokens.includes(token)) {
+      tokens.push(token);
+    }
+  }
+  return tokens;
+};
+var toRowCells = function(cells) {
+  const indexes = [];
+  const rows = [];
+  const rowMap = /* @__PURE__ */ new Map();
+  for (const cell of cells) {
+    let cells2 = [];
+    if (rowMap.has(cell.Row)) {
+      cells2 = rowMap.get(cell.Row);
+    } else {
+      indexes.push(cell.Row);
+    }
+    cells2.push(cell);
+    rowMap.set(cell.Row, cells2);
+  }
+  indexes.sort((a, b) => a - b);
+  for (const row of indexes) {
+    const values = rowMap.get(row);
+    rows.push(values);
+  }
+  return rows;
+};
+var resolveFunctionExpr = (ctx, templateValue, expr) => {
+  const anyToken = defaultRuleTokenMap.get("?" /* AnyToken */);
+  const funToken = defaultRuleTokenMap.get("<?>" /* FunctionPatternToken */);
+  const functionTokens = expr.tokens.filter((s) => s === "<?>" /* FunctionPatternToken */);
+  if (functionTokens === void 0 || functionTokens.length <= 0) {
+    return templateValue;
+  }
+  const [start, end] = funToken.split(anyToken);
+  for (let times = functionTokens.length; times > 0; times--) {
+    const index = templateValue.indexOf(start);
+    const offset = templateValue.indexOf(end);
+    if (offset > 0 && index >= 0) {
+      templateValue = templateValue.replace(start, funcCommand).replace(end, "");
+    }
+  }
+  return templateValue;
+};
+var searchIndexOf = (str, substr, position) => {
+  let index = NaN;
+  for (let sub of substr) {
+    if (position === void 0 || position === null) {
+      index = str.indexOf(sub);
+    } else {
+      index = str.indexOf(sub, position);
+    }
+    if (!isNaN(index) && index >= 0) {
+      return index;
+    }
+  }
+  return -1;
+};
+var resolveAliasExpr = (ctx, templateValue, index) => {
+  const expr = ctx.currentExpr;
+  if (expr === void 0) {
+    throw new Error(`miss context expr value`);
+  }
+  let compileValue = templateValue;
+  const aliasToken = defaultRuleTokenMap.get("@" /* UseAliasToken */);
+  let aliasTokens = expr.tokens.filter((s) => s === "@" /* UseAliasToken */);
+  if (aliasTokens.length <= 0) {
+    const num = templateValue.split(aliasToken).length - 1;
+    if (num > 0) {
+      aliasTokens = new Array(num).fill(aliasToken);
+    }
+  }
+  if (aliasTokens !== void 0 && aliasTokens.length > 0) {
+    for (let i = 0; i < aliasTokens.length; ++i) {
+      const token = aliasToken;
+      const start = compileValue.indexOf(token);
+      if (start < 0) {
+        break;
+      }
+      const offset = aliasTokens[i].length;
+      let end = searchIndexOf(compileValue, [",", ".", ")", "]"], start);
+      if (end < 0) {
+        end = compileValue.length;
+      }
+      const sv = compileValue.substring(start + offset, end);
+      const pl = `${token}${sv}`;
+      const value = ctx.getAlias(sv);
+      if (value !== void 0) {
+        if (compileValue === pl) {
+          compileValue = value;
+        } else {
+          compileValue = compileValue.replace(`${pl}`, value);
+        }
+      }
+    }
+  }
+  return compileValue;
+};
+var resolveValueExpr = (ctx, templateValue) => {
+  const expr = ctx.currentExpr;
+  if (expr === void 0 || expr.tokens.length <= 0) {
+    return templateValue;
+  }
+  const m = ctx.getContextMap();
+  const token = TokenParserManger.getTokenByCtx(m, "${?}" /* VarPatternToken */);
+  const anyToken = TokenParserManger.getTokenByCtx(m, "?" /* AnyToken */);
+  const [start, end] = token.split(anyToken);
+  if (!templateValue.startsWith(start)) {
+    templateValue = `${start}${templateValue}`;
+  }
+  if (!templateValue.endsWith(end)) {
+    templateValue = `${templateValue}${end}`;
+  }
+  return templateValue;
+};
+var compileRowCells = function(ctx, expr, cellPoints, rowIndex, errs) {
+  if (ctx.sheet === void 0) {
+    errs.push(new Error(`ctx miss worksheet`));
+    return;
+  }
+  ctx.currentExpr = expr;
+  cellPoints.forEach((cellPoint, index) => {
+    const r = cellPoint.Row;
+    const sheet = ctx.sheet;
+    const c = cellPoint.Column;
+    const cell = sheet.findCell(r, c);
+    if (cell === void 0 || cell.value !== void 0 && cell.value !== null && cell.value !== "") {
+      return;
+    }
+    let templateValue = String(expr.value);
+    const macroTokens2 = getMacroTokens(expr);
+    templateValue = resolveFunctionExpr(ctx, templateValue, expr);
+    templateValue = resolveCompileMacroExpr(ctx, templateValue, macroTokens2, index, cellPoints.length);
+    templateValue = resolveAliasExpr(ctx, templateValue, index);
+    cell.value = resolveValueExpr(ctx, templateValue);
+  });
+};
+var generateWorkSheetCellsPlaceholder = function(ctx, expr, sheet) {
+  const errs = [];
+  const posExpr = expr.posExpr;
+  let cellsItems = expr.cells;
+  if ((cellsItems === void 0 || cellsItems.length <= 0) && posExpr !== void 0 && posExpr.value !== void 0) {
+    const r = posExpr.value;
+    if (r !== void 0) {
+      cellsItems = r.getCells();
+    }
+  }
+  if (!cellsItems || cellsItems.length === 0) {
+    return void 0;
+  }
+  ctx.sheet = sheet;
+  const cells = cellsItems;
+  toRowCells(cells).forEach((cellPoints, index) => compileRowCells(ctx, expr, cellPoints, index, errs));
+  return errs.length > 0 ? errs : void 0;
+};
+var hasGeneratorToken = function(tokens) {
+  for (const t of tokens) {
+    if (compileCellTokens.includes(t)) {
+      return true;
+    }
+  }
+  return false;
+};
+var compileWorkSheetPlaceholder = function(ctx, sheet, result) {
+  if (ctx.compileSheets !== void 0 && ctx.compileSheets.length > 0 && !ctx.compileSheets.includes(sheet.name)) {
+    return void 0;
+  }
+  const errs = [];
+  for (const [token, express] of result.rules.entries()) {
+    if (!isRuleToken(token)) {
+      continue;
+    }
+    for (const expr of express) {
+      if (expr.tokens.length <= 0 || !hasGeneratorToken(expr.tokens)) {
+        continue;
+      }
+      let err = generateWorkSheetCellsPlaceholder(ctx, expr, sheet);
+      if (err !== void 0 && err.length > 0) {
+        errs.push(...err);
+      }
+    }
+  }
+  if (errs.length > 0) {
+    return errs;
+  }
+  return void 0;
+};
+var compile = async function(data, ruleSheetName, options) {
+  const workbook = await loadWorkbook(data);
+  const sheet = workbook.getWorksheet(ruleSheetName);
+  if (sheet === void 0) {
+    return {
+      workbook,
+      errs: [new Error(`compile error, ${ruleSheetName} not exists!`)]
+    };
+  }
+  if (workbook.worksheets === void 0) {
+    return {
+      workbook,
+      errs: [new Error(`worksheet, ${ruleSheetName} not exists!`)]
+    };
+  }
+  if (options === void 0) {
+    const excludes = [ruleSheetName];
+    options = RuleMapOptions.withAllSheets(workbook, excludes);
+  }
+  const result = parseWorkSheetRules(sheet, options);
+  const errs = compileCheck(result, options);
+  if (errs !== void 0) {
+    return {
+      errs,
+      workbook,
+      configure: result
+    };
+  }
+  const compileErrs = [];
+  const ctx = CompileContext.create(options).loadAlias(result.rules);
+  for (const [i, w] of workbook.worksheets.entries()) {
+    if (w.name === ruleSheetName || i === ruleSheetName || !ctx.filterSheet(w.name)) {
+      continue;
+    }
+    let err = compileWorkSheetPlaceholder(ctx, w, result);
+    if (err !== void 0 && err.length > 0) {
+      compileErrs.push(...err);
+    }
+  }
+  if (compileErrs.length > 0) {
+    return {
+      workbook,
+      configure: result,
+      errs: compileErrs
+    };
+  }
+  return {
+    workbook,
+    configure: result
+  };
+};
+var compileWorkSheet = async function(data, sheetName, options) {
+  const reply = await compile(data, sheetName, options);
+  if (reply.errs !== void 0 && reply.errs.length > 0) {
+    return reply.errs;
+  }
+  return reply.workbook.xlsx;
+};
+var fetchAlias = (m) => {
+  let sv;
+  const alias = /* @__PURE__ */ new Map();
+  if (!(m instanceof Map) && m.rules !== void 0) {
+    sv = m.rules;
+  } else if (m instanceof Map) {
+    if (m.size <= 0 || !m.has("alias" /* AliasToken */)) {
+      return alias;
+    }
+    sv = m;
+  } else {
+    return alias;
+  }
+  const values = sv.get("alias" /* AliasToken */);
+  for (const vs of values) {
+    if (typeof vs.value === "string") {
+      alias.set(vs.key, vs.value);
+    }
+  }
+  return alias;
+};
+var removeUnExportSheets = (w, options) => {
+  const removes = [];
+  if (options.compileSheets === void 0 || options.compileSheets.length <= 0) {
+    for (const [i, v] of w.worksheets.entries()) {
+      const sheetName = v.name;
+      if (sheetName.endsWith(".config") || sheetName.endsWith(".json")) {
+        removes.push(sheetName);
+      }
+    }
+  } else {
+    for (const [i, v] of w.worksheets.entries()) {
+      if (!options.compileSheets.includes(v.name)) {
+        removes.push(v.name);
+      }
+    }
+  }
+  for (const [_, name] of removes.entries()) {
+    w.removeWorksheet(name);
+  }
+  return w;
+};
+var toBuffer = async (w) => {
+  const arrayBuffer = await w.xlsx.writeBuffer();
+  return Buffer.from(arrayBuffer);
+};
+var ExprResolver = class {
+};
+ExprResolver.toBuffer = toBuffer;
+ExprResolver.compile = compile;
+ExprResolver.toRowCells = toRowCells;
+ExprResolver.fetchAlias = fetchAlias;
+ExprResolver.getExprEnd = getExprEnd;
+ExprResolver.compileCheck = compileCheck;
+ExprResolver.extractMacro = extractMacro;
+ExprResolver.compileRowCells = compileRowCells;
+ExprResolver.searchIndexOf = searchIndexOf;
+ExprResolver.resolveAliasExpr = resolveAliasExpr;
+ExprResolver.resolveValueExpr = resolveValueExpr;
+ExprResolver.resolveFunctionExpr = resolveFunctionExpr;
+ExprResolver.removeUnExportSheets = removeUnExportSheets;
+ExprResolver.resolveCompileMacroGen = resolveCompileMacroGen;
+ExprResolver.resolveCompileMacroExpr = resolveCompileMacroExpr;
+
+// src/extends.ts
+function hasToString(obj) {
+  return obj != null && typeof obj.toString === "function";
+}
+var tokenNextIter = [`root`, `groups`, `suffix`, `default`];
+var aliasKey = `__alias`;
+var ArgumentData = class {
+  constructor(fn, p) {
+    this.default = "";
+    this.groups = [];
+    this.tokenIterIndex = 0;
+    this.p = p;
+    this.func = fn;
+    this.groups = [];
+  }
+  To() {
+    return {
+      p: this.p,
+      root: this.root,
+      alias: this.alias,
+      groups: this.groups,
+      suffix: this.suffix,
+      default: this.default,
+      func: this.func
+    };
+  }
+  Add(startToken, value) {
+    if (value === void 0) {
+      this.tokenIterIndex++;
+      return;
+    }
+    switch (startToken) {
+      case `(`:
+        if (tokenNextIter[this.tokenIterIndex] === "root") {
+          this.root = value;
+          this.tokenIterIndex++;
+        }
+        break;
+      case `[`:
+        if (tokenNextIter[this.tokenIterIndex] === "groups") {
+          this.groups.push(value);
+        }
+        break;
+      case `]`:
+        if (tokenNextIter[this.tokenIterIndex] === "groups") {
+          this.groups.push(value);
+        }
+        break;
+      case `,`:
+        const token = tokenNextIter[this.tokenIterIndex];
+        if (token === "root") {
+          this.root = value;
+          this.tokenIterIndex++;
+        } else if (token === "groups") {
+          this.groups.push(value);
+        } else if (token === "suffix") {
+          this.suffix = value;
+          this.tokenIterIndex++;
+        } else if (token === "default") {
+          this.default = value;
+          this.tokenIterIndex++;
+        }
+        break;
+      case `)`:
+        this.tokenIterIndex++;
+        break;
+    }
+  }
+  ParseAlias(alias) {
+    if (alias === void 0 || this.root === void 0 || this.root === "") {
+      return;
+    }
+    const value = valueDotGet(alias, this.root);
+    if (value === void 0 || typeof value !== "string" || !hasToString(value)) {
+      return;
+    }
+    this.alias = this.root;
+    this.root = value;
+  }
+};
+var ArgumentValue = class {
+  constructor(value, defValue) {
+    this.value = value;
+    this.defaultValue = defValue;
+  }
+  isUndefined() {
+    return this.value === void 0;
+  }
+  getDefault() {
+    return this.defaultValue;
+  }
+  getNumber() {
+    return Number(this.value);
+  }
+  toString() {
+    if (this.isUndefined()) {
+      return "";
+    }
+    if (typeof this.value === "string") {
+      return this.value;
+    }
+    if (hasToString(this.value)) {
+      return this.value.toString();
+    }
+    return "";
+  }
+};
+var ArgumentValueLoader = (values, args) => {
+  let all = [];
+  for (let v of args.groups) {
+    let key = `${args.root}.${v}`;
+    if (args.suffix !== void 0 && args.suffix !== "") {
+      key = `${key}.${args.suffix}`;
+    }
+    all.push(key);
+  }
+  if (all.length <= 0) {
+    return args.default || "";
+  }
+  const items = [];
+  for (let k of all) {
+    let vs = valueDotGet(values, k);
+    items.push(new ArgumentValue(vs, args.default));
+  }
+  return items;
+};
+var sum_all = (values, argument) => {
+  let sum = NaN;
+  let emptyTimes = 0;
+  let argc = argument.groups.length;
+  let items = ArgumentValueLoader(values, argument);
+  for (let value of items) {
+    let num = value.getNumber();
+    if (value.isUndefined()) {
+      emptyTimes++;
+      num = Number(argument.default);
+    }
+    if (isNaN(sum)) {
+      sum = num;
+    } else {
+      sum = sum + Number(num);
+    }
+  }
+  if (emptyTimes === argc) {
+    return void 0;
+  }
+  if (isNaN(sum)) {
+    throw new Error(`parse ${argument.p.name} NaN error`);
+  }
+  return sum;
+};
+var sub_value = (values, argument) => {
+  let sub = NaN;
+  let emptyTimes = 0;
+  let argc = argument.groups.length;
+  let items = ArgumentValueLoader(values, argument);
+  for (let value of items) {
+    let num = value.getNumber();
+    if (value.isUndefined()) {
+      emptyTimes++;
+      num = Number(argument.default);
+    }
+    if (isNaN(num)) {
+      continue;
+    }
+    if (isNaN(sub)) {
+      sub = num;
+    } else {
+      sub = sub - Number(num);
+    }
+  }
+  if (emptyTimes === argc) {
+    return void 0;
+  }
+  if (isNaN(sub)) {
+    throw new Error(`parse ${argument.p.name} NaN error`);
+  }
+  return sub;
+};
+var defaultCommands = /* @__PURE__ */ new Map([
+  ["sum", sum_all],
+  ["sub", sub_value]
+]);
+var resolveFunc = function(value) {
+  if (value.indexOf("(") > 0 && value.endsWith(")")) {
+    const names = value.split("(");
+    return names[0];
+  }
+  return "";
+};
+var resolveArgument = function(p, data) {
+  const value = p.name;
+  const fn = resolveFunc(value);
+  const args = new ArgumentData(fn, p);
+  if (fn !== "") {
+    let key = "";
+    let startT = "";
+    const endToken = [`)`, `,`, `]`];
+    const startToken = [`(`, `,`, `[`];
+    const tokenRow = value.split(`${fn}`)[1];
+    const len = tokenRow.length;
+    for (let i = 0; i < len; i++) {
+      let start = startToken.includes(tokenRow[i]);
+      let end = endToken.includes(tokenRow[i]);
+      if (start) {
+        startT = tokenRow[i];
+      }
+      if (startT !== "" && tokenRow[i] !== startT && !end) {
+        key = `${key}${tokenRow[i]}`;
+      }
+      if (end) {
+        if (key === "") {
+          args.Add(startT, void 0);
+        } else {
+          args.Add(startT, key);
+          key = "";
+        }
+      }
+    }
+  }
+  const alias = valueDotGet(data, aliasKey);
+  if (alias !== void 0) {
+    args.ParseAlias(alias);
+  }
+  return args.To();
+};
+var commandExtendQuery = function(values, p) {
+  if (p.type !== "fn") {
+    return defaultValueDotGet(values, p);
+  }
+  const argument = resolveArgument(p, values);
+  if (argument.func !== "" && defaultCommands.has(argument.func)) {
+    return defaultCommands.get(argument.func)(values, argument);
+  }
+  return defaultValueDotGet(values, p);
+};
+var AddCommand = (key, h) => {
+  if (defaultCommands.has(key)) {
+    return false;
+  }
+  defaultCommands.set(key, h);
+  return true;
+};
+var AddCommandMust = (key, h) => {
+  defaultCommands.set(key, h);
+};
+var generateCommandsXlsxTemplate = async function(data, values, options) {
+  const w = await Workbook.parse(data, options);
+  w.setQueryFunctionHandler(commandExtendQuery);
+  await w.substituteAll(values);
+  return w.generate(options);
+};
+var getCommands = () => {
+  return defaultCommands;
+};
+var compileRuleSheetName = "export_metadata.config";
+var mergeMap = function(source, dest) {
+  for (const [key, value] of dest.entries()) {
+    source.set(key, value);
+  }
+  return source;
+};
+var generateCommandsXlsxTemplateWithCompile = async function(data, values, compileOptions, options) {
+  if (compileOptions.sheetName === void 0 || compileOptions.sheetName === "") {
+    compileOptions.sheetName = compileRuleSheetName;
+  }
+  const result = await ExprResolver.compile(data, compileOptions.sheetName, compileOptions);
+  if (result.errs !== void 0 && result.errs.length > 0) {
+    throw result.errs[0];
+  }
+  let alias = ExprResolver.fetchAlias(result.configure);
+  if (values[aliasKey] !== void 0 && values[aliasKey] instanceof Map) {
+    alias = mergeMap(alias, values[aliasKey]);
+  }
+  values[aliasKey] = alias;
+  result.workbook = ExprResolver.removeUnExportSheets(result.workbook, compileOptions);
+  const wb = await ExprResolver.toBuffer(result.workbook);
+  const w = await Workbook.parse(wb, options);
+  w.setQueryFunctionHandler(commandExtendQuery);
+  await w.substituteAll(values);
+  return w.generate(options);
+};
+export {
+  AddCommand,
+  AddCommandMust,
+  ArgumentData,
+  ArgumentValue,
+  ArgumentValueLoader,
+  BufferType,
+  CompileContext,
+  DefaultPlaceholderCellValue,
+  ExprResolver,
+  RuleMapOptions,
+  RuleToken,
+  TokenParserManger,
+  Workbook,
+  columnLetterToNumber,
+  columnNumberToLetter,
+  commandExtendQuery,
+  compileRuleSheetName,
+  compileWorkSheet,
+  compileWorkSheetPlaceholder,
+  defaultExtractPlaceholders,
+  defaultFormatters,
+  defaultValueDotGet,
+  exceljs,
+  generateCommandsXlsxTemplate,
+  generateCommandsXlsxTemplateWithCompile,
+  generateXlsxTemplate,
+  getCommands,
+  getTokenParser,
+  hasGeneratorToken,
+  isRuleToken,
+  isUrl,
+  loadWorkbook,
+  parseWorkSheetRules,
+  registerTokenParser,
+  registerTokenParserMust,
+  resolveArgument,
+  scanCellSetPlaceholder,
+  toArrayBuffer,
+  valueDotGet,
+  workSheetSetPlaceholder
+};
+//# sourceMappingURL=index.mjs.map