@vdhewei/xlsx-template-lib 1.5.0 → 1.6.1

package/dist/bin.js

@@ -6,34 +6,2396 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key) && key !== except)
         __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return to;
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/dotenv@17.3.1/node_modules/dotenv/package.json
+var require_package = __commonJS({
+  "node_modules/.pnpm/dotenv@17.3.1/node_modules/dotenv/package.json"(exports2, module2) {
+    module2.exports = {
+      name: "dotenv",
+      version: "17.3.1",
+      description: "Loads environment variables from .env file",
+      main: "lib/main.js",
+      types: "lib/main.d.ts",
+      exports: {
+        ".": {
+          types: "./lib/main.d.ts",
+          require: "./lib/main.js",
+          default: "./lib/main.js"
+        },
+        "./config": "./config.js",
+        "./config.js": "./config.js",
+        "./lib/env-options": "./lib/env-options.js",
+        "./lib/env-options.js": "./lib/env-options.js",
+        "./lib/cli-options": "./lib/cli-options.js",
+        "./lib/cli-options.js": "./lib/cli-options.js",
+        "./package.json": "./package.json"
+      },
+      scripts: {
+        "dts-check": "tsc --project tests/types/tsconfig.json",
+        lint: "standard",
+        pretest: "npm run lint && npm run dts-check",
+        test: "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
+        "test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+        prerelease: "npm test",
+        release: "standard-version"
+      },
+      repository: {
+        type: "git",
+        url: "git://github.com/motdotla/dotenv.git"
+      },
+      homepage: "https://github.com/motdotla/dotenv#readme",
+      funding: "https://dotenvx.com",
+      keywords: [
+        "dotenv",
+        "env",
+        ".env",
+        "environment",
+        "variables",
+        "config",
+        "settings"
+      ],
+      readmeFilename: "README.md",
+      license: "BSD-2-Clause",
+      devDependencies: {
+        "@types/node": "^18.11.3",
+        decache: "^4.6.2",
+        sinon: "^14.0.1",
+        standard: "^17.0.0",
+        "standard-version": "^9.5.0",
+        tap: "^19.2.0",
+        typescript: "^4.8.4"
+      },
+      engines: {
+        node: ">=12"
+      },
+      browser: {
+        fs: false
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/dotenv@17.3.1/node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "node_modules/.pnpm/dotenv@17.3.1/node_modules/dotenv/lib/main.js"(exports2, module2) {
+    "use strict";
+    var fs5 = require("fs");
+    var path4 = require("path");
+    var os = require("os");
+    var crypto = require("crypto");
+    var packageJson = require_package();
+    var version = packageJson.version;
+    var TIPS = [
+      "\u{1F510} encrypt with Dotenvx: https://dotenvx.com",
+      "\u{1F510} prevent committing .env to code: https://dotenvx.com/precommit",
+      "\u{1F510} prevent building .env in docker: https://dotenvx.com/prebuild",
+      "\u{1F916} agentic secret storage: https://dotenvx.com/as2",
+      "\u26A1\uFE0F secrets for agents: https://dotenvx.com/as2",
+      "\u{1F6E1}\uFE0F auth for agents: https://vestauth.com",
+      "\u{1F6E0}\uFE0F  run anywhere with `dotenvx run -- yourcommand`",
+      "\u2699\uFE0F  specify custom .env file path with { path: '/custom/path/.env' }",
+      "\u2699\uFE0F  enable debug logging with { debug: true }",
+      "\u2699\uFE0F  override existing env vars with { override: true }",
+      "\u2699\uFE0F  suppress all logs with { quiet: true }",
+      "\u2699\uFE0F  write to custom object with { processEnv: myObject }",
+      "\u2699\uFE0F  load multiple .env files with { path: ['.env.local', '.env'] }"
+    ];
+    function _getRandomTip() {
+      return TIPS[Math.floor(Math.random() * TIPS.length)];
+    }
+    function parseBoolean(value) {
+      if (typeof value === "string") {
+        return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
+      }
+      return Boolean(value);
+    }
+    function supportsAnsi() {
+      return process.stdout.isTTY;
+    }
+    function dim(text) {
+      return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
+    }
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse2(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options) {
+      options = options || {};
+      const vaultPath = _vaultPath(options);
+      options.path = vaultPath;
+      const result = DotenvModule.configDotenv(options);
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _warn(message) {
+      console.error(`[dotenv@${version}][WARN] ${message}`);
+    }
+    function _debug(message) {
+      console.log(`[dotenv@${version}][DEBUG] ${message}`);
+    }
+    function _log(message) {
+      console.log(`[dotenv@${version}] ${message}`);
+    }
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs5.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path4.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs5.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path4.join(os.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options) {
+      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (debug || !quiet) {
+        _log("Loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    function configDotenv(options) {
+      const dotenvPath = path4.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("No encoding is specified. UTF-8 is used by default");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path5 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs5.readFileSync(path5, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`Failed to load ${path5} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      const populated = DotenvModule.populate(processEnv, parsedAll, options);
+      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+      if (debug || !quiet) {
+        const keysCount = Object.keys(populated).length;
+        const shortPaths = [];
+        for (const filePath of optionPaths) {
+          try {
+            const relative = path4.relative(process.cwd(), filePath);
+            shortPaths.push(relative);
+          } catch (e) {
+            if (debug) {
+              _debug(`Failed to load ${filePath} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        _log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+      }
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      const populated = {};
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+            populated[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
+        }
+      }
+      return populated;
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config,
+      decrypt,
+      parse: parse2,
+      populate
+    };
+    module2.exports.configDotenv = DotenvModule.configDotenv;
+    module2.exports._configVault = DotenvModule._configVault;
+    module2.exports._parseVault = DotenvModule._parseVault;
+    module2.exports.config = DotenvModule.config;
+    module2.exports.decrypt = DotenvModule.decrypt;
+    module2.exports.parse = DotenvModule.parse;
+    module2.exports.populate = DotenvModule.populate;
+    module2.exports = DotenvModule;
+  }
+});
+
+// src/bin.ts
+var import_chalk2 = __toESM(require("chalk"));
+var import_commander = require("commander");
+var fs4 = __toESM(require("fs/promises"));
+var import_node_fs2 = require("fs");
+var path3 = __toESM(require("path"));
+
+// src/core.ts
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var etree = __toESM(require("elementtree"));
+var import_jszip = __toESM(require("jszip"));
+var console2 = __toESM(require("console"));
+var import_image_size = require("image-size");
+var import_types = require("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";
+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 ((0, import_types.isMap)(obj)) {
+    return obj.get(key);
+  }
+  return obj?.[key];
+}
+function valueDotGet(obj, path4, defaultValue) {
+  if (!path4 || !obj) return defaultValue;
+  const keys = path4.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 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) {
+      console2.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) => {
+            console2.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 import_jszip.default.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 {
+                  console2.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 {
+                console2.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 = (0, import_image_size.imageSize)(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 {
+        (0, import_image_size.imageSize)(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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/bin.ts
-var import_chalk = __toESM(require("chalk"));
-var import_commander = require("commander");
-
-// src/core.ts
-var etree = __toESM(require("elementtree"));
-var import_jszip = __toESM(require("jszip"));
-var console2 = __toESM(require("console"));
-var import_image_size = require("image-size");
-var import_types = require("util/types");
-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");
 
 // src/helper.ts
 var import_exceljs = __toESM(require("exceljs"));
@@ -929,7 +3291,7 @@ function base64ToArrayBuffer(base64) {
 }
 var resolveCompileMacroGen = (ctx, expr, currentCellIndex) => {
   let parts = [];
-  let join = ".";
+  let join3 = ".";
   const m = ctx.getContextMap();
   const aliasToken = TokenParserManger.getTokenByCtx(m, "@" /* UseAliasToken */);
   const genToken = TokenParserManger.getTokenByCtx(m, "compile:GenCell" /* CompileGenToken */);
@@ -945,7 +3307,15 @@ var resolveCompileMacroGen = (ctx, expr, currentCellIndex) => {
       parts.push(resolveAliasExpr(ctx, item.value, currentCellIndex));
     }
   }
-  return parts.join(join);
+  if (parts.length === 1) {
+    return parts[0];
+  }
+  let end = parts[parts.length - 1];
+  if (end.startsWith('"') && end.length >= 3 && end.endsWith('"')) {
+    join3 = end;
+    return parts.slice(0, parts.length - 1).join(join3);
+  }
+  return parts.join(join3);
 };
 var getExprEnd = function(macroExpr, matchIndex, rparenToken) {
   return macroExpr.indexOf(rparenToken, matchIndex);
@@ -993,7 +3363,17 @@ var __codeKey = (str, expr) => {
   return str.toUpperCase();
 };
 var __numberKey = (str, expr) => {
-  return Number.parseInt(str, 10).toString();
+  if (str === "NaN" || str === "Infinity" || str === "null" || str === "[object object]") {
+    return str;
+  }
+  if (str.startsWith("0x")) {
+    return str.substring(2);
+  }
+  let v = Number.parseInt(str, 10);
+  if (isNaN(v)) {
+    return str;
+  }
+  return v.toString();
 };
 var __codeAliasKey = (str, expr) => {
   const key = __codeKey(str);
@@ -1567,7 +3947,7 @@ var fetchAlias = (m) => {
   return alias;
 };
 var removeUnExportSheets = (w, options) => {
-  const removes = [];
+  let removes = [];
   if (typeof options.skipRemoveUnExportSheet === "boolean" && options.skipRemoveUnExportSheet === true) {
     return w;
   }
@@ -1585,6 +3965,9 @@ var removeUnExportSheets = (w, options) => {
       }
     }
   }
+  if (removes.length === w.worksheets.length && w.worksheets[0].name === removes[0]) {
+    removes = removes.slice(1, removes.length);
+  }
   for (const [_, name] of removes.entries()) {
     w.removeWorksheet(name);
   }
@@ -1614,23 +3997,619 @@ ExprResolver.resolveCompileMacroExpr = resolveCompileMacroExpr;
 
 // src/extends.ts
 var import_promises = __toESM(require("fs/promises"));
+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 compileRuleSheetName = "export_metadata.config";
+var mergeMap = function(source, dest) {
+  for (const [key, value] of dest.entries()) {
+    source.set(key, value);
+  }
+  return source;
+};
+var autoRegisterAlias = function(values, configure) {
+  let alias = ExprResolver.fetchAlias(configure);
+  if (values[aliasKey] !== void 0 && values[aliasKey] instanceof Map) {
+    alias = mergeMap(alias, values[aliasKey]);
+  }
+  values[aliasKey] = alias;
+  return values;
+};
+var compileAll = async (buf, compileOpts, renderData) => {
+  if (compileOpts === void 0 || compileOpts.sheetName === "") {
+    return buf;
+  }
+  const result = await ExprResolver.compile(buf, compileOpts.sheetName, compileOpts);
+  if (result.errs !== void 0 && result.errs.length > 0) {
+    throw result.errs[0];
+  }
+  if (compileOpts.remove !== void 0 && compileOpts.remove === true) {
+    result.workbook = ExprResolver.removeUnExportSheets(result.workbook, compileOpts);
+  }
+  if (renderData !== void 0) {
+    autoRegisterAlias(renderData, result.configure);
+  }
+  return await ExprResolver.toBuffer(result.workbook);
+};
 
 // src/biz.ts
 var import_node_path = require("path");
 var import_lodash = require("lodash");
 var import_adm_zip = __toESM(require("adm-zip"));
+var XlsxRender = class _XlsxRender extends Workbook {
+  constructor(option) {
+    super(option);
+  }
+  static async create(data, option) {
+    const w = await super.parse(data, option);
+    w.setQueryFunctionHandler(commandExtendQuery);
+    const app = new _XlsxRender(option);
+    Object.assign(app, { ...w });
+    return app;
+  }
+  async render(values, sheetName) {
+    await this.substitute(sheetName, values);
+  }
+  getSheets() {
+    return this.sheets;
+  }
+};
+
+// src/bin-helpers.ts
+var path2 = __toESM(require("path"));
+var url = __toESM(require("url"));
+var import_node_fs = require("fs");
+var fs3 = __toESM(require("fs/promises"));
+var import_chalk = __toESM(require("chalk"));
+var import_meta = {};
+function generateOutputFilename(inputFile) {
+  const basename3 = path2.basename(inputFile, path2.extname(inputFile));
+  const timestamp = Date.now();
+  return `${basename3}_${timestamp}.xlsx`;
+}
+async function resolveFilePath(filePath) {
+  const resolvedPath = path2.resolve(filePath);
+  if ((0, import_node_fs.existsSync)(resolvedPath)) {
+    return resolvedPath;
+  }
+  const scriptDir = path2.dirname(url.fileURLToPath(import_meta.url));
+  const relativePath = path2.resolve(scriptDir, filePath);
+  if ((0, import_node_fs.existsSync)(relativePath)) {
+    return relativePath;
+  }
+  throw new Error(`File not found: ${filePath}`);
+}
+async function parseRenderData(dataOption) {
+  if (!dataOption) {
+    return {};
+  }
+  try {
+    return JSON.parse(dataOption);
+  } catch (e) {
+    try {
+      const filePath = await resolveFilePath(dataOption);
+      const fileContent = await fs3.readFile(filePath, "utf-8");
+      return JSON.parse(fileContent);
+    } catch (e2) {
+      if (dataOption.startsWith("http://") || dataOption.startsWith("https://")) {
+        let fetch;
+        try {
+          fetch = globalThis.fetch;
+        } catch (e3) {
+          try {
+            const nodeFetch = await import("node-fetch");
+            fetch = nodeFetch.default;
+          } catch (e4) {
+            throw new Error("Remote URLs require Node.js 18+ or node-fetch package");
+          }
+        }
+        const response = await fetch(dataOption);
+        return response.json();
+      }
+      throw new Error(`Failed to parse render data from: ${dataOption}`);
+    }
+  }
+}
+function checkSheetAndPlaceholders(xlsx, sheetName) {
+  const sheets = xlsx.getSheets();
+  const sheet = sheets.find((s) => s.name === sheetName);
+  if (!sheet) {
+    throw new Error(`Sheet "${sheetName}" not found in Excel file`);
+  }
+}
+async function addRuleToSheet(xlsxBuffer, ruleType, ruleExpr, sheetName = "export_metadata.config") {
+  const workbook = await loadWorkbook(xlsxBuffer);
+  let worksheet = workbook.getWorksheet(sheetName);
+  if (!worksheet) {
+    worksheet = workbook.addWorksheet(sheetName);
+    console.log(import_chalk.default.gray(`Created new sheet: ${sheetName}`));
+  }
+  let startRow = 1;
+  let currentRow = 1;
+  let columnCount = 0;
+  worksheet.eachRow((row, rowNumber) => {
+    const cell = row.getCell(1);
+    const cellValue = cell.value?.toString().trim();
+    if (!cellValue) {
+      return;
+    }
+    if (cellValue.toLowerCase() === ruleType.toLowerCase()) {
+      let col = 2;
+      while (col <= 4) {
+        const ruleCell = row.getCell(col);
+        if (ruleCell.value) {
+          columnCount++;
+        }
+        col++;
+      }
+      if (columnCount < 4) {
+        currentRow = rowNumber;
+        startRow = rowNumber;
+      } else {
+        currentRow = rowNumber + 1;
+      }
+    }
+  });
+  if (startRow === 1 && currentRow === 1 && worksheet.rowCount === 0) {
+    currentRow = 1;
+  }
+  let targetRow = worksheet.getRow(currentRow);
+  if (!targetRow.getCell(1).value) {
+    const typeCell = targetRow.getCell(1);
+    typeCell.value = ruleType;
+    typeCell.font = { bold: true };
+    typeCell.alignment = { horizontal: "center", vertical: "middle" };
+  }
+  let ruleCol = 2;
+  while (ruleCol <= 4) {
+    const existingCell = targetRow.getCell(ruleCol);
+    if (!existingCell.value) {
+      break;
+    }
+    ruleCol++;
+  }
+  if (ruleCol <= 4) {
+    const ruleCell = targetRow.getCell(ruleCol);
+    ruleCell.value = ruleExpr;
+    ruleCell.alignment = { vertical: "middle" };
+    const column = worksheet.getColumn(ruleCol);
+    column.width = Math.max(column.width || 10, ruleExpr.length + 2);
+    console.log(import_chalk.default.gray(`Added rule ${ruleType} at row ${currentRow}, column ${ruleCol}`));
+  } else {
+    throw new Error(`Cannot add more than 4 rules for type: ${ruleType}`);
+  }
+  const buffer = await workbook.xlsx.writeBuffer();
+  return Buffer.from(buffer);
+}
+async function parseRulesFromFile(filePath) {
+  const resolvedPath = await resolveFilePath(filePath);
+  const fileContent = await fs3.readFile(resolvedPath, "utf-8");
+  const lines = fileContent.split("\n");
+  const rules = [];
+  const validTypes = ["cell", "alias", "rowCell", "mergeCell"];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    const spaceIndex = line.indexOf(" ");
+    if (spaceIndex === -1) {
+      console.log(import_chalk.default.yellow(`\u26A0 Line ${i + 1}: Invalid format. Expected "<type> ruleExpr"`));
+      continue;
+    }
+    const type = line.substring(0, spaceIndex).trim();
+    const rule = line.substring(spaceIndex + 1).trim();
+    if (!type || !rule) {
+      console.log(import_chalk.default.yellow(`\u26A0 Line ${i + 1}: Invalid format. Expected "<type> ruleExpr"`));
+      continue;
+    }
+    if (!validTypes.includes(type)) {
+      console.log(import_chalk.default.yellow(`\u26A0 Line ${i + 1}: Invalid rule type "${type}". Must be one of: ${validTypes.join(", ")}`));
+      continue;
+    }
+    rules.push({ type, rule });
+  }
+  if (rules.length === 0) {
+    throw new Error("No valid rules found in file");
+  }
+  return rules;
+}
+async function addMultipleRulesToSheet(xlsxBuffer, rules) {
+  let buffer = xlsxBuffer;
+  for (const { type, rule } of rules) {
+    console.log(import_chalk.default.gray(`Adding ${type} rule: ${rule}`));
+    buffer = await addRuleToSheet(buffer, type, rule);
+  }
+  return buffer;
+}
 
 // src/bin.ts
-var program = new import_commander.Command();
-program.name("xlsx-cli").version("1.0.0");
-program.command("compile").argument("<string>", "xlsx file path").option("-s,--save <string>", "save compiled xlsx file to user dir").option("-r,--remove", "remove configure rules sheet", false).action((cmd, xlsxFile, options) => {
-  const resolver = ExprResolver;
-  console.log(import_chalk.default.green("xlsxFile %s"), xlsxFile);
-  console.log(import_chalk.default.red("options %s"), options);
-});
-program.command("render").argument("<string>", "xlsx file path").option("-c,--compile", "auto compile flag", false).option("-s,--save <string>", "save render xlsx file to user dir").action((cmd, xlsxFile, options) => {
-  console.log(import_chalk.default.green("xlsxFile %s"), xlsxFile);
-  console.log(import_chalk.default.red("options %s"), options);
+async function main() {
+  let version = "1.0.0";
+  try {
+    const possiblePaths = [
+      path3.join(process.cwd(), "package.json"),
+      path3.join(process.cwd(), "..", "package.json")
+    ];
+    for (const packagePath of possiblePaths) {
+      if ((0, import_node_fs2.existsSync)(packagePath)) {
+        const packageJson = JSON.parse(await fs4.readFile(packagePath, "utf-8"));
+        version = packageJson.version;
+        break;
+      }
+    }
+  } catch (e) {
+  }
+  const envPath = path3.join(process.cwd(), ".env");
+  if ((0, import_node_fs2.existsSync)(envPath)) {
+    try {
+      const dotenv = (await Promise.resolve().then(() => __toESM(require_main()))).default;
+      dotenv.config({ debug: false, path: envPath });
+    } catch (e) {
+    }
+  }
+  const program = new import_commander.Command();
+  program.name("xlsx-cli").version(version);
+  program.command("compile").argument("<string>", "xlsx file path").option("-s,--save <string>", "save compiled xlsx file to user dir").option("-n,--sheet-name <string>", "compile xlsx sheet name when xlsx has multiple sheets").option("-r,--remove", "remove configure rules sheet", false).action(async (xlsxFile, options) => {
+    try {
+      console.log(import_chalk2.default.green("\u{1F4C4} Compiling Excel file..."));
+      const filePath = await resolveFilePath(xlsxFile);
+      console.log(import_chalk2.default.gray(`Loading file: ${filePath}`));
+      const buffer = await fs4.readFile(filePath);
+      const xlsx = await XlsxRender.create(buffer);
+      const sheets = xlsx.getSheets();
+      const sheetName = options.sheetName || sheets[0].name;
+      console.log(import_chalk2.default.gray(`Target sheet: ${sheetName}`));
+      const ruleSheetName = options.sheetName || compileRuleSheetName;
+      console.log(import_chalk2.default.gray("Compiling rules..."));
+      const compiledBuffer = await compileAll(buffer, {
+        sheetName: ruleSheetName,
+        remove: options.remove || false
+      });
+      console.log(import_chalk2.default.green("\u2713 Compilation completed"));
+      const outputFile = options.save || path3.join(process.cwd(), generateOutputFilename(xlsxFile));
+      console.log(import_chalk2.default.gray(`Saving to: ${outputFile}`));
+      await fs4.writeFile(outputFile, compiledBuffer);
+      console.log(import_chalk2.default.green("\u2713 Excel file compiled successfully!"));
+      console.log(import_chalk2.default.green(`\u{1F4C1} Output: ${outputFile}`));
+    } catch (error) {
+      console.error(import_chalk2.default.red("\u2717 Compilation failed:"));
+      console.error(import_chalk2.default.red(error instanceof Error ? error.message : String(error)));
+      process.exit(1);
+    }
+  });
+  program.command("render").argument("<string>", "xlsx file path").option("-c,--compile", "auto compile flag", false).option("-n,--sheet-name <string>", "render xlsx sheet name when xlsx has multiple sheets").option("-s,--save <string>", "save render xlsx file to user dir").option("-d,--data <string>", "render xlsx file data from").action(async (xlsxFile, options) => {
+    try {
+      console.log(import_chalk2.default.green("\u{1F4C4} Rendering Excel template..."));
+      const filePath = await resolveFilePath(xlsxFile);
+      console.log(import_chalk2.default.gray(`Loading file: ${filePath}`));
+      let buffer = await fs4.readFile(filePath);
+      let xlsx = await XlsxRender.create(buffer);
+      const sheets = xlsx.getSheets();
+      const sheetName = options.sheetName || sheets[0].name;
+      console.log(import_chalk2.default.gray(`Target sheet: ${sheetName}`));
+      checkSheetAndPlaceholders(xlsx, sheetName);
+      console.log(import_chalk2.default.gray("Sheet validation passed"));
+      const renderData = await parseRenderData(options.data);
+      if (Object.keys(renderData).length > 0) {
+        console.log(import_chalk2.default.gray(`Render data loaded with ${Object.keys(renderData).length} keys`));
+      }
+      if (options.compile) {
+        console.log(import_chalk2.default.gray("Auto-compiling rules..."));
+        const ruleSheetName = options.sheetName || compileRuleSheetName;
+        const compiledResult = await compileAll(buffer, {
+          sheetName: ruleSheetName,
+          remove: false
+          // Don't remove rule sheet during render
+        });
+        buffer = Buffer.from(compiledResult);
+        xlsx = await XlsxRender.create(buffer);
+        console.log(import_chalk2.default.green("\u2713 Auto-compilation completed"));
+      }
+      console.log(import_chalk2.default.gray("Rendering template..."));
+      await xlsx.render(renderData, sheetName);
+      const outputBuffer = await xlsx.generate({
+        type: "nodebuffer" /* NodeBuffer */,
+        compression: "DEFLATE",
+        compressionOptions: {
+          level: 9
+        }
+      });
+      const outputFile = options.save || path3.join(process.cwd(), generateOutputFilename(xlsxFile));
+      console.log(import_chalk2.default.gray(`Saving to: ${outputFile}`));
+      await fs4.writeFile(outputFile, outputBuffer);
+      console.log(import_chalk2.default.green("\u2713 Excel template rendered successfully!"));
+      console.log(import_chalk2.default.green(`\u{1F4C1} Output: ${outputFile}`));
+    } catch (error) {
+      console.error(import_chalk2.default.red("\u2717 Rendering failed:"));
+      console.error(import_chalk2.default.red(error instanceof Error ? error.message : String(error)));
+      process.exit(1);
+    }
+  });
+  program.command("rules").argument("<string>", "xlsx compile rules setting").option("-t,--type <string>", "xlsx compile rule type <cell,alias,rowCell,mergeCell> (optional when using -f)").option("-r,--rule <string>", "xlsx compile rule expr (can be specified multiple times)").option("-f,--file <string>", "read rules from file (format: <type> ruleExpr per line)").option("-s,--save <string>", "save compiled xlsx file to user dir").action(async (xlsxFile, options) => {
+    try {
+      console.log(import_chalk2.default.green("\u{1F4DD} Adding rule configuration..."));
+      const validTypes = ["cell", "alias", "rowCell", "mergeCell"];
+      let rules = [];
+      if (options.file) {
+        console.log(import_chalk2.default.gray(`Reading rules from file: ${options.file}`));
+        rules = await parseRulesFromFile(options.file);
+        console.log(import_chalk2.default.green(`\u2713 Loaded ${rules.length} rules from file`));
+      } else if (options.rule) {
+        const ruleArray = Array.isArray(options.rule) ? options.rule : [options.rule];
+        if (options.type) {
+          if (!validTypes.includes(options.type)) {
+            console.error(import_chalk2.default.red(`Invalid rule type: ${options.type}. Must be one of: ${validTypes.join(", ")}`));
+            process.exit(1);
+          }
+          for (const rule of ruleArray) {
+            rules.push({ type: options.type, rule });
+          }
+        } else {
+          console.error(import_chalk2.default.red("Error: -t,--type is required when using -r,--rule"));
+          process.exit(1);
+        }
+        console.log(import_chalk2.default.green(`\u2713 Loaded ${rules.length} rules from command line`));
+      } else {
+        console.error(import_chalk2.default.red("Error: Either -f,--file or -r,--rule must be specified"));
+        process.exit(1);
+      }
+      if (rules.length === 0) {
+        console.error(import_chalk2.default.red("Error: No rules to add"));
+        process.exit(1);
+      }
+      const filePath = await resolveFilePath(xlsxFile);
+      console.log(import_chalk2.default.gray(`Loading file: ${filePath}`));
+      const buffer = await fs4.readFile(filePath);
+      const updatedBuffer = await addMultipleRulesToSheet(buffer, rules);
+      const outputFile = options.save || path3.join(process.cwd(), generateOutputFilename(xlsxFile));
+      console.log(import_chalk2.default.gray(`Saving to: ${outputFile}`));
+      await fs4.writeFile(outputFile, updatedBuffer);
+      console.log(import_chalk2.default.green("\u2713 All rules added successfully!"));
+      console.log(import_chalk2.default.green(`\u{1F4C1} Output: ${outputFile}`));
+    } catch (error) {
+      console.error(import_chalk2.default.red("\u2717 Failed to add rule configuration:"));
+      console.error(import_chalk2.default.red(error instanceof Error ? error.message : String(error)));
+      process.exit(1);
+    }
+  });
+  program.parse(process.argv);
+}
+main().catch((error) => {
+  console.error(import_chalk2.default.red("\u2717 Fatal error:"));
+  console.error(import_chalk2.default.red(error instanceof Error ? error.message : String(error)));
+  process.exit(1);
 });
-program.parse(process.argv);
 //# sourceMappingURL=bin.js.map