@vdhewei/xlsx-template-lib 1.3.5 → 1.4.2

package/dist/bin.js

@@ -0,0 +1,1626 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __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"));
+var import_stream = require("stream");
+var isPureNumber = /^[0-9]+$/;
+var isPureUppercase = /^[A-Z]+$/;
+var exprSingle = `expr`;
+var exprArr = `exprArr`;
+var exprIndex = `index`;
+var defaultKey = `!!`;
+var numberKey = `!!number`;
+var codeKey = `!!codeKey`;
+var codeAliasKey = `!!codeAliasKey`;
+var funcCommand = "fn:";
+var RuleMapOptions = class _RuleMapOptions {
+  constructor(m) {
+    // rule configure area
+    this.startLine = 1;
+    this.startColumn = 1;
+    if (m === void 0) {
+      this.ruleKeyMap = defaultRuleTokenMap;
+    } else {
+      this.ruleKeyMap = m;
+    }
+  }
+  static withAllSheets(w, excludes) {
+    const compileSheets = [];
+    const options = new _RuleMapOptions();
+    if (excludes === void 0) {
+      excludes = [];
+    }
+    if (w.worksheets.length > 0 && excludes.length > 0) {
+      for (const [index, sheet] of w.worksheets.entries()) {
+        if (excludes.includes(index.toString()) || excludes.includes(sheet.name)) {
+          continue;
+        }
+        if (sheet.name.endsWith(".json")) {
+          continue;
+        }
+        compileSheets.push(sheet.name);
+      }
+    }
+    options.compileSheets = compileSheets;
+    return options;
+  }
+  parseDefault(worksheet) {
+    this.ruleKeyMap = mergeOption(this.ruleKeyMap, defaultRuleTokenMap);
+    if (this.startLine === void 0 || isNaN(this.startLine) || this.startLine < 0) {
+      this.startLine = 1;
+    }
+    if (this.endLine === void 0 || isNaN(this.endLine) || this.endLine < 0) {
+      this.endLine = worksheet.rowCount;
+    }
+    if (this.startColumn === void 0 || isNaN(this.startColumn) || this.startColumn < 0) {
+      this.startColumn = 1;
+    }
+    if (this.endColumn === void 0 || isNaN(this.endColumn) || this.endColumn < 0) {
+      this.endColumn = worksheet.columnCount;
+    }
+    return this;
+  }
+  addRuleMap(key, value) {
+    this.ruleKeyMap.set(key, value);
+    return this;
+  }
+  setStartRow(start) {
+    this.startLine = start;
+    return this;
+  }
+  setStartColumn(start) {
+    this.startColumn = start;
+    return this;
+  }
+  setEndRow(end) {
+    this.endLine = end;
+    return this;
+  }
+  setEndColumn(end) {
+    this.endColumn = end;
+    return this;
+  }
+  parseToken(value) {
+    if (value === "") {
+      return "" /* UndefinedToken */;
+    }
+    for (const [token, alias] of this.ruleKeyMap.entries()) {
+      if (alias === value) {
+        return token;
+      }
+    }
+    return "" /* UndefinedToken */;
+  }
+  getContextMap() {
+    const ctx = /* @__PURE__ */ new Map();
+    for (const [token, expr] of this.ruleKeyMap.entries()) {
+      if (!isRuleToken(token)) {
+        const value = [{
+          express: expr,
+          key: expr,
+          tokens: [token],
+          value: token.toString()
+        }];
+        ctx.set(token, value);
+      }
+    }
+    return ctx;
+  }
+  getCompileCheckHandlers() {
+    if (this.compileCheckers !== void 0 && this.compileCheckers.length > 0) {
+      return this.compileCheckers;
+    }
+    return void 0;
+  }
+};
+var CompileContext = class _CompileContext extends RuleMapOptions {
+  constructor(m) {
+    super(m);
+    this.aliasMap = /* @__PURE__ */ new Map();
+  }
+  static create(r) {
+    const ctx = new _CompileContext(r.ruleKeyMap);
+    Object.assign(ctx, { ...r });
+    return ctx.init();
+  }
+  init() {
+    if (this.ruleKeyMap === void 0) {
+      this.ruleKeyMap = defaultRuleTokenMap;
+    }
+    return this;
+  }
+  loadAlias(m) {
+    if (m.size <= 0 || !m.has("alias" /* AliasToken */)) {
+      return this;
+    }
+    const values = m.get("alias" /* AliasToken */);
+    for (const vs of values) {
+      if (typeof vs.value === "string") {
+        this.aliasMap.set(vs.key, vs.value);
+      }
+    }
+    return this;
+  }
+  /**
+   * 设置别名缓存
+   */
+  setAlias(key, value) {
+    this.aliasMap.set(key, value);
+  }
+  /**
+   * 获取别名缓存值
+   */
+  getAlias(key) {
+    return this.aliasMap.get(key);
+  }
+  /**
+   * 检查别名是否存在
+   */
+  hasAlias(key) {
+    return this.aliasMap.has(key);
+  }
+  filterSheet(sheetName) {
+    if (sheetName !== "" && this.compileSheets !== void 0 && this.compileSheets.length > 0) {
+      return this.compileSheets.includes(sheetName);
+    }
+    return false;
+  }
+};
+var defaultRuleTokenMap = /* @__PURE__ */ new Map([
+  ["alias" /* AliasToken */, "alias" /* AliasToken */.toString()],
+  ["?" /* AnyToken */, "?" /* AnyToken */.toString()],
+  ["cell" /* CellToken */, "cell" /* CellToken */.toString()],
+  ["rowCell" /* RowCellToken */, "rowCell" /* RowCellToken */.toString()],
+  ["mergeCell" /* MergeCellToken */, "mergeCell" /* MergeCellToken */.toString()],
+  ["@" /* UseAliasToken */, "@" /* UseAliasToken */.toString()],
+  [":" /* PosToken */, ":" /* PosToken */.toString()],
+  ["-" /* RangeToken */, "-" /* RangeToken */.toString()],
+  ["<?>" /* FunctionPatternToken */, "<?>" /* FunctionPatternToken */.toString()],
+  ["${?}" /* VarPatternToken */, "${?}" /* VarPatternToken */.toString()],
+  ["=" /* EqualToken */, "=" /* EqualToken */.toString()],
+  ["," /* ArgPosToken */, "," /* ArgPosToken */.toString()],
+  ["(" /* LparenToken */, "(" /* LparenToken */.toString()],
+  [")" /* RparenToken */, ")" /* RparenToken */.toString()],
+  ["." /* DotGetToken */, "." /* DotGetToken */.toString()],
+  ["compile:Macro" /* CompileMacroToken */, "compile:Macro" /* CompileMacroToken */.toString()],
+  ["compile:GenCell" /* CompileGenToken */, "compile:GenCell" /* CompileGenToken */.toString()]
+]);
+var _getCells = (thisArg) => {
+  let cells = [];
+  for (let j = thisArg.minColumn; j <= thisArg.maxColumn; j += thisArg.stepColumn) {
+    for (let i = thisArg.minRow; i <= thisArg.maxRow; i += thisArg.stepRow) {
+      cells.push({
+        Row: i,
+        Column: j
+      });
+    }
+  }
+  return cells;
+};
+var TokenParserManger = class _TokenParserManger {
+  // T=xxx
+  static aliasParse(ctx, token, value) {
+    if (token !== "alias" /* AliasToken */) {
+      return {
+        ok: false
+      };
+    }
+    const parser = getTokenParser("=" /* EqualToken */);
+    const { values, expr, ok } = parser.handler(ctx, "=" /* EqualToken */, value);
+    if (!ok) {
+      return {
+        ok: false
+      };
+    }
+    if (typeof expr.value !== "string" || expr.value === "") {
+      return {
+        ok: false,
+        error: new Error(`alias express right value cannot be a empty value.`)
+      };
+    }
+    return {
+      ok: true,
+      expr: {
+        express: value,
+        key: expr.key,
+        // alias key
+        value: expr.value,
+        // alias value
+        tokens: [token, "=" /* EqualToken */]
+        //  express tokens
+      },
+      values
+    };
+  }
+  // x=xx
+  static equalParse(ctx, token, value) {
+    if (token !== "=" /* EqualToken */) {
+      return {
+        ok: false
+      };
+    }
+    const equalToken = _TokenParserManger.getTokenByCtx(ctx, "=" /* EqualToken */);
+    const offset = equalToken.length;
+    const index = value.indexOf(equalToken);
+    if (index < 0) {
+      return {
+        ok: false
+      };
+    }
+    const len = value.length;
+    const key = value.substring(0, index);
+    const rightValue = value.substring(index + offset, len);
+    if (rightValue === "") {
+      return {
+        ok: false,
+        error: new Error(`equal express right value cannot be a empty value.`)
+      };
+    }
+    const expr = {
+      key,
+      value: rightValue,
+      express: value,
+      tokens: [token]
+    };
+    return {
+      ok: true,
+      values: [key, rightValue],
+      expr
+    };
+  }
+  //cell| X:Y=${?}
+  static cellParse(ctx, token, value) {
+    if (token !== "cell" /* CellToken */) {
+      return {
+        ok: false
+      };
+    }
+    const equalToken = _TokenParserManger.getTokenByCtx(ctx, "=" /* EqualToken */);
+    const eqOffset = equalToken.length;
+    const posToken = _TokenParserManger.getTokenByCtx(ctx, ":" /* PosToken */);
+    const eqIndex = value.indexOf(equalToken);
+    const posIndex = value.indexOf(posToken);
+    if (eqIndex < 0 || posIndex < 0) {
+      return {
+        ok: false
+      };
+    }
+    const parser = getTokenParser(":" /* PosToken */);
+    const varParser = getTokenParser("${?}" /* VarPatternToken */);
+    const posValue = value.substring(0, eqIndex);
+    const varValue = value.substring(eqIndex + eqOffset);
+    const posReply = parser.handler(ctx, ":" /* PosToken */, posValue);
+    if (!posReply.ok) {
+      return {
+        ok: false,
+        ...posReply
+      };
+    }
+    const varReply = varParser.handler(ctx, "${?}" /* VarPatternToken */, varValue);
+    if (!varReply.ok) {
+      return {
+        ok: false,
+        ...varReply
+      };
+    }
+    const expr = {
+      ...varReply.expr
+    };
+    expr.express = value;
+    expr.cells = posReply.expr.cells;
+    expr.value = varReply.expr.value;
+    expr.ref = varReply.expr.ref;
+    expr.tokens = [token, "=" /* EqualToken */, ...posReply.expr.tokens, ...varReply.expr.tokens];
+    return {
+      ok: true,
+      expr,
+      values: [posReply.values, varReply.values]
+    };
+  }
+  static useAliasParse(ctx, token, value) {
+    if (token !== "@" /* UseAliasToken */) {
+      return {
+        ok: false
+      };
+    }
+    const useAliasToken = _TokenParserManger.getTokenByCtx(ctx, "@" /* UseAliasToken */);
+    const offset = useAliasToken.length;
+    const has = offset !== 0 && value.indexOf(useAliasToken) >= 0;
+    if (!has) {
+      return {
+        ok: false
+      };
+    }
+    const endTokens = ["@" /* UseAliasToken */, "(" /* LparenToken */, "," /* ArgPosToken */, "." /* DotGetToken */];
+    const values = _TokenParserManger.scanToken(value, useAliasToken, _TokenParserManger.toList(ctx, endTokens));
+    if (values === void 0 || values.length <= 0) {
+      return {
+        ok: false
+      };
+    }
+    const keys = [];
+    const tokens = [];
+    const expr = {
+      express: value,
+      tokens,
+      value: keys,
+      ref: []
+    };
+    for (const v of values) {
+      tokens.push(token);
+      keys.push(v.token);
+      expr.ref.push(v.value);
+    }
+    expr.value = keys;
+    expr.tokens = tokens;
+    return {
+      expr,
+      ok: true,
+      values
+    };
+  }
+  static rangeParse(ctx, token, value) {
+    if (token !== "-" /* RangeToken */) {
+      return {
+        ok: false
+      };
+    }
+    const rangeToken = _TokenParserManger.getTokenByCtx(ctx, "-" /* RangeToken */);
+    const offset = rangeToken.length;
+    const index = value.indexOf(rangeToken);
+    if (index < 0 || offset <= 0) {
+      return {
+        ok: false
+      };
+    }
+    let setup = 1;
+    let startNumber = NaN;
+    let endNumber = NaN;
+    let startPos = value.substring(0, index).trim();
+    let endPos = value.substring(index + offset).trim();
+    const argPosToken = _TokenParserManger.getTokenByCtx(ctx, "," /* ArgPosToken */);
+    const endSetupIndex = endPos.indexOf(argPosToken);
+    if (endSetupIndex > 0) {
+      setup = Number.parseInt(endPos.substring(endSetupIndex).trim(), 10);
+      endPos = endPos.substring(0, endSetupIndex).trim();
+    }
+    if (isNaN(setup)) {
+      return {
+        ok: false,
+        error: new Error(`rangeToken parse setup NaN, ${value}`)
+      };
+    }
+    endNumber = _TokenParserManger.parsePosNumber(endPos);
+    startNumber = _TokenParserManger.parsePosNumber(startPos);
+    if (isNaN(startNumber) || isNaN(endNumber)) {
+      return {
+        ok: false,
+        error: new Error(`rangeToken parse start,end has NaN, ${value}`)
+      };
+    }
+    const expr = {
+      express: value,
+      tokens: [token],
+      value: [startNumber, endNumber, setup]
+    };
+    return {
+      expr,
+      ok: true,
+      values: [startNumber, endNumber, setup]
+    };
+  }
+  static posParse(ctx, token, value) {
+    if (token !== ":" /* PosToken */) {
+      return {
+        ok: false
+      };
+    }
+    const posToken = _TokenParserManger.getTokenByCtx(ctx, ":" /* PosToken */);
+    const offset = posToken.length;
+    const index = value.indexOf(posToken);
+    const len = value.length;
+    const column = value.substring(0, index).trim();
+    const row = value.substring(index + offset, len).trim();
+    const rangeToken = _TokenParserManger.getTokenByCtx(ctx, "-" /* RangeToken */);
+    const columnRange = column.indexOf(rangeToken);
+    const rowRange = row.indexOf(rangeToken);
+    if (rowRange > 0 || columnRange > 0) {
+      return _TokenParserManger.parseRangeValue(ctx, { rowRange, columnRange, row, column, token, express: value });
+    }
+    const cell = {
+      Row: Number.parseInt(row, 10),
+      Column: columnLetterToNumber(column)
+    };
+    const expr = {
+      value: cell,
+      cells: [cell],
+      express: value,
+      tokens: [token]
+    };
+    return {
+      ok: true,
+      values: [row, column],
+      expr
+    };
+  }
+  // value input: A-AQ:13-15=<sum(#,[compile:Macro(exprArr,[F],[13,15],!codeKey)],compile:Marco(index),0)>
+  // output: {
+  //      A:13 => sum(#,[ codeKey(F:13.value),codeKey(F:14.value),codeKey(F:15.value)],1,0),
+  //      B:13 => sum(#,[ codeKey(F:13.value),codeKey(F:14.value),codeKey(F:15.value)],2,0),
+  //      C:13 => sum(#,[ codeKey(F:13.value),codeKey(F:14.value),codeKey(F:15.value)],3,0),
+  //     ....,
+  //     A:14 => sum(#,[ codeKey(F:13.value),codeKey(F:14.value),codeKey(F:15.value)],1,0),
+  //     B:14 => sum(#,[ codeKey(F:13.value),codeKey(F:14.value),codeKey(F:15.value)],2,0),
+  //     C:14 => sum(#,[ codeKey(F:13.value),codeKey(F:14.value),codeKey(F:15.value)],3,0),
+  //  }
+  static mergeCellParse(ctx, token, value) {
+    if (token !== "mergeCell" /* MergeCellToken */ && token !== "rowCell" /* RowCellToken */) {
+      return { ok: false };
+    }
+    const equalToken = _TokenParserManger.getTokenByCtx(ctx, "=" /* EqualToken */);
+    const index = value.indexOf(equalToken);
+    const offset = equalToken.length;
+    if (index <= 0) return { ok: false, error: new Error(`merge cell config syntax error: ${value}`) };
+    const rangeStr = value.substring(0, index).trim();
+    const exprStr = value.substring(index + offset);
+    const posParser = getTokenParser(":" /* PosToken */);
+    const posReply = posParser.handler(ctx, ":" /* PosToken */, rangeStr);
+    const functionToken = getTokenParser("<?>" /* FunctionPatternToken */);
+    if (!posReply.ok) return { ok: false, ...posReply };
+    const macroGenToken = _TokenParserManger.getTokenByCtx(ctx, "compile:GenCell" /* CompileGenToken */);
+    const expr = {
+      express: value,
+      value: exprStr,
+      // The template expression
+      posExpr: posReply.expr,
+      tokens: [token, ...posReply.expr.tokens]
+    };
+    if (exprStr.startsWith(macroGenToken)) {
+      const argsSplitToken = _TokenParserManger.getTokenByCtx(ctx, "," /* ArgPosToken */);
+      const args = _TokenParserManger.split(exprStr, argsSplitToken, [`(`, `)`]);
+      const macro = _TokenParserManger.filterMacro(args);
+      const aliasTokens = _TokenParserManger.extractUseAliasTokens(ctx, args);
+      if (aliasTokens !== void 0 && aliasTokens.length > 0) {
+        expr.tokens.push(...aliasTokens);
+      }
+      if (macro !== void 0 && macro.tokens.length > 0) {
+        expr.macro = macro;
+        expr.tokens.push(...macro.tokens);
+      }
+    } else {
+      const exprReply = functionToken.handler(ctx, "<?>" /* FunctionPatternToken */, exprStr);
+      if (exprReply.error !== void 0 && exprReply.error instanceof Error) {
+        return {
+          ok: false,
+          ...exprReply
+        };
+      }
+      if (exprReply.ok && exprReply.expr !== void 0) {
+        expr.funcExpr = exprReply.expr;
+        expr.tokens.push(...exprReply.expr.tokens);
+      }
+    }
+    return {
+      ok: true,
+      expr,
+      values: [rangeStr, exprStr]
+    };
+  }
+  // G-AQ:12=compile:GenCell(compile:Macro(expr,F,12),'.',compile:Marco(index))
+  static rowCellParse(ctx, token, value) {
+    if (token !== "rowCell" /* RowCellToken */) {
+      return { ok: false };
+    }
+    return _TokenParserManger.mergeCellParse(ctx, token, value);
+  }
+  // $functionName($arg0:string,$arg1:string[],$arg2:string|number,$arg3:string|number)
+  // eg: func(A,[xx1,xx2],xxx3), sum(#,[F,12,13],1,0)
+  // $functionName not in compile:Macro,compile:GenCell
+  // extract => {func:$functionName, arguments:[$arg0,$arg1,$arg2,$argN...]}
+  // output: {func:"sum",arguments:["A",["F","12","13"],"1","0"]}
+  static functionPatternParse(ctx, token, value) {
+    if (token !== "<?>" /* FunctionPatternToken */) {
+      return { ok: false };
+    }
+    const wordToken = _TokenParserManger.getTokenByCtx(ctx, "?" /* AnyToken */);
+    const funcToken = _TokenParserManger.getTokenByCtx(ctx, "<?>" /* FunctionPatternToken */);
+    const splitIndex = funcToken.indexOf(wordToken);
+    const splitOffset = wordToken.length;
+    const funcStartToken = funcToken.substring(0, splitIndex);
+    const funcEndToken = funcToken.substring(splitIndex + splitOffset);
+    const rparenToken = _TokenParserManger.getTokenByCtx(ctx, ")" /* RparenToken */);
+    const lparenToken = _TokenParserManger.getTokenByCtx(ctx, "(" /* LparenToken */);
+    const argsSplitToken = _TokenParserManger.getTokenByCtx(ctx, "," /* ArgPosToken */);
+    if (value.startsWith(funcStartToken) && value.endsWith(funcEndToken)) {
+      const content = value.substring(1, value.length - 1);
+      const lparen = content.indexOf(lparenToken);
+      const rparen = content.lastIndexOf(rparenToken);
+      if (lparen > 0 && rparen > lparen) {
+        const funcName = content.substring(0, lparen);
+        const argsStr = content.substring(lparen + lparenToken.length, rparen);
+        const args = _TokenParserManger.split(argsStr, argsSplitToken, [`[`, `]`]);
+        const macro = _TokenParserManger.filterMacro(args);
+        const tokens = [token];
+        const expr = {
+          express: value,
+          func: funcName,
+          value: args,
+          // arguments array
+          tokens
+        };
+        const alias = _TokenParserManger.extractUseAliasTokens(ctx, args);
+        if (alias !== void 0 && alias.length > 0) {
+          expr.tokens.push(...alias);
+        }
+        if (macro !== void 0 && macro.tokens.length > 0) {
+          expr.macro = macro;
+          expr.tokens.push(...macro.tokens);
+        }
+        return {
+          ok: true,
+          expr,
+          values: [funcName, args]
+        };
+      }
+    }
+    return {
+      ok: false,
+      error: new Error(`function express systax error`)
+    };
+  }
+  static varPatternParse(ctx, token, value) {
+    if (token !== "${?}" /* VarPatternToken */) {
+      return { ok: false };
+    }
+    const wordToken = _TokenParserManger.getTokenByCtx(ctx, "?" /* AnyToken */);
+    const varToken = _TokenParserManger.getTokenByCtx(ctx, "${?}" /* VarPatternToken */);
+    const index = varToken.indexOf(wordToken);
+    const workTokenOffset = wordToken.length;
+    const startToken = varToken.substring(0, index);
+    const endToken = varToken.substring(workTokenOffset + index);
+    if (!value.startsWith(startToken) || !value.endsWith(endToken)) {
+      return {
+        ok: false,
+        error: new Error(`variable expression syntax error,\${ or } flag is miss`)
+      };
+    }
+    const innerContent = value.substring(startToken.length, value.length - endToken.length);
+    if (innerContent === "") {
+      return {
+        ok: false,
+        error: new Error("variable expression syntax error, variable name is empty")
+      };
+    }
+    const expr = {
+      express: value,
+      value: innerContent,
+      tokens: [token]
+    };
+    const aliasToken = _TokenParserManger.getTokenByCtx(ctx, "@" /* UseAliasToken */);
+    if (innerContent.indexOf(aliasToken) >= 0) {
+      const parser = getTokenParser("@" /* UseAliasToken */);
+      const aliasReply = parser.handler(ctx, "@" /* UseAliasToken */, innerContent);
+      if (aliasReply.ok) {
+        expr.ref = aliasReply.expr.ref;
+        expr.alias = aliasReply.values;
+        expr.tokens.push(...aliasReply.expr.tokens);
+      }
+    }
+    return {
+      expr,
+      ok: true,
+      values: [innerContent]
+    };
+  }
+  // compile:GenCell(expr1,expr2,...,) => {G:13=>`${expr1}${expr2}..`,G:14=>`${expr1}${expr2}..`,G:15=>`${expr1}${expr2}..`,...}
+  // compile:Macro($exprType,$X,$Y,$formater)
+  // $exprType: enums [ expr:(single value), exprArr:(array value) ]
+  // $X: column index value, number|string or number[]|string[]
+  // $Y: row index value, number or number[]
+  // $formater: enums [ codeKey(a function for format string),number(a function for string to number) ]
+  // compile:Macro(exprArr,[X1,X2],[Y1,Y2],!codeKey) =>
+  // codeKey(X1:Y1.value),codeKey(X1:Y2.value),codeKey(X2:Y1.value),codeKey(X2:Y2.value)
+  // compile:Macro(exprArr,[X1],[Y1,Y2],!codeKey) => codeKey(X1:Y1.value),codeKey(X1:Y2.value)
+  // compile:Marco(index,!number) => number(i),number(i+1),number(i+2) ,i=1
+  static compileExprExtract(value) {
+    const results = [];
+    const lp = "(" /* LparenToken */.toString();
+    const args = "," /* ArgPosToken */.toString();
+    const values = value.split(lp);
+    for (const v of values) {
+      let items = [];
+      if (v.indexOf(args) >= 0) {
+        items = v.split(args);
+      } else {
+        items.push(v);
+      }
+      for (const it of items) {
+        if (it === "compile:Macro" /* CompileMacroToken */.toString() || it.startsWith("compile:Macro" /* CompileMacroToken */) || it.endsWith("compile:Macro" /* CompileMacroToken */)) {
+          results.push("compile:Macro" /* CompileMacroToken */);
+        } else if (it === "compile:GenCell" /* CompileGenToken */.toString() || it.startsWith("compile:GenCell" /* CompileGenToken */) || it.endsWith("compile:GenCell" /* CompileGenToken */)) {
+          results.push("compile:GenCell" /* CompileGenToken */);
+        }
+      }
+    }
+    return results;
+  }
+  static getTokenByCtx(ctx, token) {
+    if (ctx.size <= 0 || !ctx.has(token)) {
+      return token.toString();
+    }
+    const values = ctx.get(token);
+    if (values.length <= 0 || values[0].key === "") {
+      return token.toString();
+    }
+    return values[0].key;
+  }
+  static scanToken(value, startToken, endTokens) {
+    let token = "";
+    let data = "";
+    let end = false;
+    let start = false;
+    const items = [];
+    const offset = [startToken, ...endTokens].sort((a, b) => a.length - b.length)[0].length;
+    const size = value.length;
+    for (let i = 0; i < size; i += offset) {
+      let leftToken;
+      if (value[i] === startToken) {
+        start = true;
+        if (token !== "") {
+          items.push({
+            token,
+            value: ""
+          });
+        }
+        token = startToken;
+      } else {
+        start = token === startToken;
+        leftToken = `${token}${value[i]}`;
+      }
+      let subfix = endTokens.filter((s) => s === leftToken);
+      end = endTokens.includes(value[i]) || subfix.length > 0;
+      if (subfix.length > 0) {
+        token = leftToken;
+        data = "";
+      }
+      if (start && end) {
+        continue;
+      }
+      if (!end) {
+        token = `${token}${value[i]}`;
+        data = `${data}${value[i]}`;
+      }
+      if (end || i + offset >= size) {
+        if (data !== "") {
+          items.push({
+            token,
+            value: data
+          });
+        }
+        token = "";
+        data = "";
+        end = false;
+      }
+    }
+    return items;
+  }
+  static split(argsStr, argsSplitToken, ignoreTokenRange) {
+    let value = "";
+    let depth = 0;
+    const items = [];
+    const splitLen = argsSplitToken.length;
+    const startLen = ignoreTokenRange[0].length;
+    const endLen = ignoreTokenRange[1].length;
+    const startToken = ignoreTokenRange[0];
+    const endToken = ignoreTokenRange[1];
+    const isToggleMode = startToken === endToken;
+    for (let i = 0; i < argsStr.length; ) {
+      const substr = argsStr.substring(i);
+      if (depth > 0 && substr.startsWith(endToken)) {
+        value += endToken;
+        i += endLen;
+        depth = isToggleMode ? 0 : depth - 1;
+        continue;
+      }
+      if (substr.startsWith(startToken)) {
+        if (!isToggleMode || depth === 0) {
+          value += startToken;
+          i += startLen;
+          depth++;
+          continue;
+        }
+      }
+      if (depth === 0 && substr.startsWith(argsSplitToken)) {
+        items.push(value);
+        value = "";
+        i += splitLen;
+        continue;
+      }
+      value += argsStr[i];
+      i++;
+    }
+    if (value !== "") {
+      items.push(value);
+    }
+    return items;
+  }
+  static filterMacro(values) {
+    const filter = {
+      tokens: [],
+      express: []
+    };
+    for (const expr of values) {
+      let items = _TokenParserManger.compileExprExtract(expr);
+      if (items === void 0 || items.length <= 0) {
+        continue;
+      }
+      filter.express.push(expr);
+      filter.tokens.push(...items);
+    }
+    return filter.tokens.push() <= 0 ? void 0 : filter;
+  }
+  static extractUseAliasTokens(ctx, args) {
+    const tokens = [];
+    const useAliasToken = _TokenParserManger.getTokenByCtx(ctx, "@" /* UseAliasToken */);
+    args.forEach((v) => v.startsWith(useAliasToken) && tokens.push("@" /* UseAliasToken */));
+    return tokens;
+  }
+  static toList(ctx, endTokens) {
+    const items = [];
+    for (const token of endTokens) {
+      items.push(_TokenParserManger.getTokenByCtx(ctx, token));
+    }
+    return items;
+  }
+  static parseRangeValue(ctx, options) {
+    let rowReply;
+    let columnReply;
+    const rangeCell = {
+      stepRow: 1,
+      stepColumn: 1,
+      minColumn: 0,
+      minRow: 0,
+      maxRow: 0,
+      maxColumn: 0,
+      getCells: function() {
+        return _getCells(this);
+      }
+    };
+    const { rowRange, row, column, columnRange, express, token } = options;
+    const rangeParse = getTokenParser("-" /* RangeToken */);
+    if (rowRange > 0) {
+      columnReply = rangeParse.handler(ctx, "-" /* RangeToken */, row);
+    } else {
+      const rowValue = Number.parseInt(row, 10);
+      rangeCell.maxRow = rowValue;
+      rangeCell.minRow = rowValue;
+    }
+    if (columnRange > 0) {
+      rowReply = rangeParse.handler(ctx, "-" /* RangeToken */, column);
+    } else {
+      const columnValue = columnLetterToNumber(column);
+      rangeCell.maxColumn = columnValue;
+      rangeCell.minColumn = columnValue;
+    }
+    if (columnReply !== void 0) {
+      if (!columnReply.ok || columnReply.values === void 0) {
+        return columnReply;
+      }
+      const values = columnReply.values;
+      let min = values[0];
+      let max = values[1];
+      let setup = values[2] ?? 1;
+      rangeCell.minRow = min;
+      rangeCell.maxRow = max;
+      rangeCell.stepRow = setup;
+    }
+    if (rowReply !== void 0) {
+      if (!rowReply.ok || rowReply.values === void 0) {
+        return rowReply;
+      }
+      const values = rowReply.values;
+      let min = values[0];
+      let max = values[1];
+      let setup = values[2] ?? 1;
+      rangeCell.minColumn = min;
+      rangeCell.maxColumn = max;
+      rangeCell.stepColumn = setup;
+    }
+    const expr = {
+      express,
+      tokens: [token],
+      //  express tokens
+      value: rangeCell
+      // alias value
+    };
+    return {
+      ok: true,
+      expr,
+      values: rangeCell
+    };
+  }
+  static parsePosNumber(value) {
+    let num = NaN;
+    if (isPureNumber.test(value)) {
+      num = Number.parseInt(value, 10);
+    } else if (isPureUppercase.test(value)) {
+      num = columnLetterToNumber(value);
+    }
+    return !isNaN(num) && num <= 0 ? NaN : num;
+  }
+};
+var defaultRuleTokenParserMap = /* @__PURE__ */ new Map([
+  ["alias" /* AliasToken */, TokenParserManger.aliasParse],
+  ["cell" /* CellToken */, TokenParserManger.cellParse],
+  ["=" /* EqualToken */, TokenParserManger.equalParse],
+  ["mergeCell" /* MergeCellToken */, TokenParserManger.mergeCellParse],
+  ["rowCell" /* RowCellToken */, TokenParserManger.rowCellParse],
+  ["@" /* UseAliasToken */, TokenParserManger.useAliasParse],
+  ["-" /* RangeToken */, TokenParserManger.rangeParse],
+  [":" /* PosToken */, TokenParserManger.posParse],
+  ["${?}" /* VarPatternToken */, TokenParserManger.varPatternParse],
+  ["<?>" /* FunctionPatternToken */, TokenParserManger.functionPatternParse]
+]);
+var macroTokens = ["compile:GenCell" /* CompileGenToken */, "compile:Macro" /* CompileMacroToken */];
+function columnLetterToNumber(letter) {
+  let num = 0;
+  for (let i = 0; i < letter.length; i++) {
+    num = num * 26 + (letter.charCodeAt(i) - 64);
+  }
+  return num;
+}
+function isBase64(str) {
+  if (str.length < 20) return false;
+  if (str.includes("\\") || str.includes(" ")) return false;
+  if (str.indexOf("./") >= 0 || str.startsWith("file://") || str.startsWith("/") || str.startsWith(".")) {
+    return false;
+  }
+  const data = str.replace(/^data:.*?;base64,/, "");
+  const cleanedStr = data.replace(/[\r\n]/g, "");
+  try {
+    return Buffer.from(cleanedStr, "base64").toString("utf-8") !== "";
+  } catch (e) {
+    return false;
+  }
+}
+function base64ToArrayBuffer(base64) {
+  const data = base64.replace(/^data:.*?;base64,/, "");
+  const binaryString = atob(data);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+var resolveCompileMacroGen = (ctx, expr, currentCellIndex) => {
+  let parts = [];
+  let join = ".";
+  const m = ctx.getContextMap();
+  const aliasToken = TokenParserManger.getTokenByCtx(m, "@" /* UseAliasToken */);
+  const genToken = TokenParserManger.getTokenByCtx(m, "compile:GenCell" /* CompileGenToken */);
+  const endTokens = ["compile:GenCell" /* CompileGenToken */, "(" /* LparenToken */, "," /* ArgPosToken */, ")" /* RparenToken */];
+  const values = TokenParserManger.scanToken(expr, genToken, TokenParserManger.toList(m, endTokens));
+  for (const [_, item] of values.entries()) {
+    if (item.value === void 0 && item.value !== "") {
+      continue;
+    }
+    if (!item.token.startsWith(aliasToken) && item.value !== exprIndex) {
+      parts.push(item.value);
+    } else {
+      parts.push(resolveAliasExpr(ctx, item.value, currentCellIndex));
+    }
+  }
+  return parts.join(join);
+};
+var getExprEnd = function(macroExpr, matchIndex, rparenToken) {
+  return macroExpr.indexOf(rparenToken, matchIndex);
+};
+var macroFormatters = [numberKey, codeKey, codeAliasKey];
+var extractMacro = function(expr, options) {
+  let end = NaN;
+  const offset = options.startToken.length;
+  const startIndex = expr.indexOf(options.startToken);
+  const endIndex = expr.indexOf(options.endToken);
+  const argValues = expr.substring(startIndex + offset, endIndex);
+  const values = argValues.split(options.argToken);
+  const extracResult = { type: values[0], rowParam: [], columnParam: void 0 };
+  if (values.length > 1) {
+    extracResult.columnParam = columnLetterToNumber(values[1]);
+  }
+  if (macroFormatters.includes(values[values.length - 1])) {
+    end = values.length - 1;
+    extracResult.formatter = values[end];
+  }
+  if (!isNaN(end) && values.length > 2) {
+    extracResult.rowParam = values.slice(2, end).map((x) => Number.parseInt(x, 10));
+  } else if (values.length > 2) {
+    extracResult.rowParam = values.slice(2, values.length).map((x) => Number.parseInt(x, 10));
+  }
+  if (extracResult.rowParam !== void 0 && extracResult.rowParam instanceof Array && extracResult.rowParam.length === 1) {
+    extracResult.rowParam = extracResult.rowParam[0];
+  }
+  return extracResult;
+};
+var __codeKey = (str) => {
+  const replaces = [" ", `-`, `/`, `,`, `'`, `&`, `.`, `(`, `)`, `{`, `}`, `@`, `\\`, `[`, `]`, `#`, `:`];
+  for (const k of replaces) {
+    str = str.replaceAll(k, "_").trim();
+    if (str.indexOf("__") >= 0) {
+      str = str.replaceAll("__", "_");
+    }
+  }
+  if (str.startsWith("_")) {
+    str = str.substring(1);
+  }
+  if (str.endsWith("_")) {
+    str = str.substring(0, str.length - 1);
+  }
+  return str.toUpperCase();
+};
+var __numberKey = (str) => {
+  return Number.parseInt(str, 10).toString();
+};
+var __codeAliasKey = (str) => {
+  const key = __codeKey(str);
+  if (key !== "") {
+    return `${defaultRuleTokenMap.get("@" /* UseAliasToken */)}${key}`;
+  }
+  return "";
+};
+var macroFormatter = /* @__PURE__ */ new Map([
+  [codeKey, __codeKey],
+  [numberKey, __numberKey],
+  [codeAliasKey, __codeAliasKey],
+  [defaultKey, (v) => v]
+]);
+var execMacroFormat = function(value, formatter) {
+  if (!macroFormatter.has(formatter)) {
+    return value;
+  }
+  return macroFormatter.get(formatter)(value);
+};
+var toCellRow = (rowVals, setup) => {
+  if (setup === void 0) {
+    setup = 1;
+  }
+  if (rowVals.length == 2) {
+    const values = [];
+    for (let start = rowVals[0]; start <= rowVals[1]; start += setup) {
+      values.push(start);
+    }
+    return values;
+  }
+  return rowVals;
+};
+var toCellColumn = (columnVals, setup) => {
+  return toCellRow(columnVals, setup);
+};
+var toCellValue = (value) => {
+  if (typeof value !== "string") {
+    const rText = value;
+    if (rText !== void 0 && rText.richText !== void 0 && rText.richText.length > 0) {
+      const values = [];
+      for (const [_, v] of rText.richText.entries()) {
+        if (v === void 0 || v === null) {
+          continue;
+        }
+        const text = v.text !== void 0 && v.text !== null ? v.text : void 0;
+        if (text !== void 0 && text !== "" && text !== "[object]") {
+          values.push(text.trim());
+        }
+      }
+      return values.join(" ");
+    }
+    const hText = value;
+    if (hText !== void 0 && hText.text !== null && hText.hyperlink !== null) {
+      return `[${hText.text}](${hText.hyperlink})`;
+    }
+  }
+  return value.toString();
+};
+var resolveCompileMacroExpr = (ctx, macroExpr, macroTokens2, currentCellIndex, totalCells) => {
+  if (macroTokens2 === void 0 || macroTokens2.length <= 0) {
+    return macroExpr;
+  }
+  const sheet = ctx.sheet;
+  if (sheet === void 0) {
+    throw new Error(`miss context worksheet`);
+  }
+  const m = ctx.getContextMap();
+  const argToken = TokenParserManger.getTokenByCtx(m, "," /* ArgPosToken */);
+  const rparenToken = TokenParserManger.getTokenByCtx(m, ")" /* RparenToken */);
+  const lparenToken = TokenParserManger.getTokenByCtx(m, "(" /* LparenToken */);
+  const genToken = TokenParserManger.getTokenByCtx(m, "compile:GenCell" /* CompileGenToken */);
+  const maroToken = TokenParserManger.getTokenByCtx(m, "compile:Macro" /* CompileMacroToken */);
+  const tokenMap = /* @__PURE__ */ new Map();
+  for (const [index, token] of macroTokens2.entries()) {
+    let items = [];
+    if (tokenMap.has(token)) {
+      items = tokenMap.get(token);
+    }
+    items.push(index);
+    tokenMap.set(token, items);
+  }
+  const resolveArray = (param) => {
+    if (param instanceof Array) {
+      return param;
+    }
+    return [param];
+  };
+  if (tokenMap.has("compile:Macro" /* CompileMacroToken */)) {
+    let offset = 0;
+    let exprValue = macroExpr;
+    const times = tokenMap.get("compile:Macro" /* CompileMacroToken */).length;
+    for (let i = times; i > 0; i--) {
+      const matchIndex = exprValue.indexOf(maroToken, offset);
+      if (matchIndex < 0) {
+        break;
+      }
+      offset = getExprEnd(exprValue, matchIndex, rparenToken);
+      const macroCurrent = exprValue.substring(matchIndex, offset + rparenToken.length);
+      const opts = { startToken: lparenToken, endToken: rparenToken, argToken };
+      let { type, columnParam, rowParam, formatter } = extractMacro(macroCurrent, opts);
+      let rowVals;
+      let columnVals;
+      const parts = [];
+      if (columnParam !== void 0 && rowParam !== void 0) {
+        rowVals = resolveArray(rowParam);
+        columnVals = resolveArray(columnParam);
+        const rowItems = toCellRow(rowVals);
+        const columnItems = toCellColumn(columnVals);
+        rowItems.forEach((r) => {
+          columnItems.forEach((c) => {
+            const cellValue = sheet.findCell(r, c);
+            if (cellValue === void 0 || cellValue.value === null) {
+              return;
+            }
+            const value = toCellValue(cellValue.value);
+            let exprValue2 = execMacroFormat(value, formatter);
+            parts.push(exprValue2);
+          });
+        });
+      }
+      if (type === exprArr) {
+        macroExpr = macroExpr.replace(macroCurrent, parts.join(","));
+      } else if (type === exprSingle) {
+        macroExpr = macroExpr.replace(macroCurrent, parts[0]);
+      } else if (type === exprIndex) {
+        const indexValue = currentCellIndex + 1;
+        macroExpr = macroExpr.replace(macroCurrent, indexValue.toString());
+      }
+    }
+  }
+  if (tokenMap.has("compile:GenCell" /* CompileGenToken */)) {
+    let exprValue = macroExpr;
+    const times = tokenMap.get("compile:GenCell" /* CompileGenToken */).length;
+    for (let i = times; i > 0; i--) {
+      const matchIndex = exprValue.indexOf(genToken);
+      if (matchIndex < 0) {
+        break;
+      }
+      const offset = getExprEnd(exprValue, matchIndex, rparenToken);
+      const macroCurrent = exprValue.substring(matchIndex, offset + rparenToken.length);
+      exprValue = resolveCompileMacroGen(ctx, macroCurrent, currentCellIndex);
+    }
+    macroExpr = exprValue;
+  }
+  return macroExpr;
+};
+var loadWorkbook = async function(data) {
+  const w = new import_exceljs.default.Workbook();
+  if (typeof data === "string") {
+    if (!isBase64(data)) {
+      await w.xlsx.readFile(data);
+    } else {
+      await w.xlsx.load(base64ToArrayBuffer(data));
+    }
+  } else if (data instanceof import_stream.Stream) {
+    await w.xlsx.read(data);
+  } else if (data instanceof ArrayBuffer) {
+    await w.xlsx.load(data);
+  } else if (data instanceof Buffer) {
+    await w.xlsx.load(data);
+  } else {
+    throw new Error(`unSupport buffer type ${typeof data}`);
+  }
+  return w;
+};
+var compileCellTokens = ["cell" /* CellToken */, "mergeCell" /* MergeCellToken */, "rowCell" /* RowCellToken */];
+var ruleTokens = ["alias" /* AliasToken */, "cell" /* CellToken */, "mergeCell" /* MergeCellToken */, "rowCell" /* RowCellToken */];
+var isRuleToken = function(t) {
+  return ruleTokens.includes(t);
+};
+var mergeOption = function(ruleKeyMap, defaultRuleTokenMap2) {
+  for (const [key, value] of defaultRuleTokenMap2.entries()) {
+    if (!ruleKeyMap.has(key)) {
+      ruleKeyMap.set(key, value);
+    }
+  }
+  return ruleKeyMap;
+};
+var getTokenParser = function(token) {
+  if (!defaultRuleTokenParserMap.has(token)) {
+    return {
+      exists: false
+    };
+  }
+  return {
+    exists: true,
+    handler: defaultRuleTokenParserMap.get(token)
+  };
+};
+var scanWorkSheetRules = function(worksheet, options) {
+  const result = { rules: options.getContextMap() };
+  for (let r = options.startLine; r <= options.endLine; r++) {
+    let emptyValue = false;
+    let ruleToken = "" /* UndefinedToken */;
+    for (let c = options.startColumn; c <= options.endColumn; c++) {
+      const cell = worksheet.findCell(r, c);
+      if (cell === void 0 || cell.value === void 0 || cell.value === null) {
+        continue;
+      }
+      const cellValue = cell.value;
+      const value = cellValue.toString();
+      let isStartCell = c === options.startColumn;
+      if (emptyValue && ruleToken === "" /* UndefinedToken */) {
+        isStartCell = true;
+      }
+      if (value === "" && isStartCell) {
+        emptyValue = true;
+        continue;
+      }
+      if (isStartCell) {
+        ruleToken = options.parseToken(value);
+        continue;
+      } else {
+        if (!isRuleToken(ruleToken)) {
+          break;
+        }
+        emptyValue = false;
+      }
+      const { handler, exists } = getTokenParser(ruleToken);
+      if (!exists) {
+        continue;
+      }
+      let values = [];
+      if (result.rules.has(ruleToken)) {
+        values = result.rules.get(ruleToken);
+      }
+      const { expr, ok } = handler(result.rules, ruleToken, value);
+      if (ok && expr !== void 0) {
+        values.push(expr);
+      }
+      result.rules.set(ruleToken, values);
+    }
+  }
+  return result;
+};
+var parseWorkSheetRules = function(worksheet, options) {
+  const result = { rules: /* @__PURE__ */ new Map() };
+  if (worksheet === void 0 || worksheet === null) {
+    return result;
+  }
+  if (options === void 0) {
+    options = new RuleMapOptions();
+  }
+  return scanWorkSheetRules(worksheet, options.parseDefault(worksheet));
+};
+var compileCheck = function(iv, ctx) {
+  if (iv.rules.size <= 0) {
+    return void 0;
+  }
+  const errs = [];
+  const values = iv.rules.get("alias" /* AliasToken */);
+  if (values !== void 0 && values.length > 0) {
+    const set = /* @__PURE__ */ new Set();
+    for (const [idx, value] of values.entries()) {
+      if (idx === 0) {
+        set.add(value.key);
+        continue;
+      }
+      if (set.has(value.key)) {
+        errs.push(Error(`Duplicate alias(${value.key},${value.express}) configuration`));
+      }
+    }
+  }
+  const handlers = ctx.getCompileCheckHandlers();
+  if (handlers !== void 0 && handlers.length > 0) {
+    for (const h of handlers) {
+      let err = h(iv, ctx);
+      if (err !== void 0 && err.length > 0) {
+        errs.push(...err);
+      }
+    }
+  }
+  if (errs.length > 0) {
+    return errs;
+  }
+  return void 0;
+};
+var getMacroTokens = function(expr) {
+  const tokens = [];
+  for (const token of expr.tokens) {
+    if (macroTokens.includes(token)) {
+      tokens.push(token);
+    }
+  }
+  return tokens;
+};
+var toRowCells = function(cells) {
+  const indexes = [];
+  const rows = [];
+  const rowMap = /* @__PURE__ */ new Map();
+  for (const cell of cells) {
+    let cells2 = [];
+    if (rowMap.has(cell.Row)) {
+      cells2 = rowMap.get(cell.Row);
+    } else {
+      indexes.push(cell.Row);
+    }
+    cells2.push(cell);
+    rowMap.set(cell.Row, cells2);
+  }
+  indexes.sort((a, b) => a - b);
+  for (const row of indexes) {
+    const values = rowMap.get(row);
+    rows.push(values);
+  }
+  return rows;
+};
+var resolveFunctionExpr = (ctx, templateValue, expr) => {
+  const anyToken = defaultRuleTokenMap.get("?" /* AnyToken */);
+  const funToken = defaultRuleTokenMap.get("<?>" /* FunctionPatternToken */);
+  const functionTokens = expr.tokens.filter((s) => s === "<?>" /* FunctionPatternToken */);
+  if (functionTokens === void 0 || functionTokens.length <= 0) {
+    return templateValue;
+  }
+  const [start, end] = funToken.split(anyToken);
+  for (let times = functionTokens.length; times > 0; times--) {
+    const index = templateValue.indexOf(start);
+    const offset = templateValue.indexOf(end);
+    if (offset > 0 && index >= 0) {
+      templateValue = templateValue.replace(start, funcCommand).replace(end, "");
+    }
+  }
+  return templateValue;
+};
+var searchIndexOf = (str, substr, position) => {
+  let index = NaN;
+  for (let sub of substr) {
+    if (position === void 0 || position === null) {
+      index = str.indexOf(sub);
+    } else {
+      index = str.indexOf(sub, position);
+    }
+    if (!isNaN(index) && index >= 0) {
+      return index;
+    }
+  }
+  return -1;
+};
+var resolveAliasExpr = (ctx, templateValue, index) => {
+  const expr = ctx.currentExpr;
+  if (expr === void 0) {
+    throw new Error(`miss context expr value`);
+  }
+  let compileValue = templateValue;
+  const aliasToken = defaultRuleTokenMap.get("@" /* UseAliasToken */);
+  let aliasTokens = expr.tokens.filter((s) => s === "@" /* UseAliasToken */);
+  if (aliasTokens.length <= 0) {
+    const num = templateValue.split(aliasToken).length - 1;
+    if (num > 0) {
+      aliasTokens = new Array(num).fill(aliasToken);
+    }
+  }
+  if (aliasTokens !== void 0 && aliasTokens.length > 0) {
+    for (let i = 0; i < aliasTokens.length; ++i) {
+      const token = aliasToken;
+      const start = compileValue.indexOf(token);
+      if (start < 0) {
+        break;
+      }
+      const offset = aliasTokens[i].length;
+      let end = searchIndexOf(compileValue, [",", ".", ")", "]"], start);
+      if (end < 0) {
+        end = compileValue.length;
+      }
+      const sv = compileValue.substring(start + offset, end);
+      const pl = `${token}${sv}`;
+      const value = ctx.getAlias(sv);
+      if (value !== void 0) {
+        if (compileValue === pl) {
+          compileValue = value;
+        } else {
+          compileValue = compileValue.replace(`${pl}`, value);
+        }
+      }
+    }
+  }
+  return compileValue;
+};
+var resolveValueExpr = (ctx, templateValue) => {
+  const expr = ctx.currentExpr;
+  if (expr === void 0 || expr.tokens.length <= 0) {
+    return templateValue;
+  }
+  const m = ctx.getContextMap();
+  const token = TokenParserManger.getTokenByCtx(m, "${?}" /* VarPatternToken */);
+  const anyToken = TokenParserManger.getTokenByCtx(m, "?" /* AnyToken */);
+  const [start, end] = token.split(anyToken);
+  if (!templateValue.startsWith(start)) {
+    templateValue = `${start}${templateValue}`;
+  }
+  if (!templateValue.endsWith(end)) {
+    templateValue = `${templateValue}${end}`;
+  }
+  return templateValue;
+};
+var compileRowCells = function(ctx, expr, cellPoints, rowIndex, errs) {
+  if (ctx.sheet === void 0) {
+    errs.push(new Error(`ctx miss worksheet`));
+    return;
+  }
+  ctx.currentExpr = expr;
+  try {
+    cellPoints.forEach((cellPoint, index) => {
+      const r = cellPoint.Row;
+      const sheet = ctx.sheet;
+      const c = cellPoint.Column;
+      const cell = sheet.findCell(r, c);
+      if (cell === void 0 || cell.value !== void 0 && cell.value !== null && cell.value !== "") {
+        return;
+      }
+      let templateValue = String(expr.value);
+      const macroTokens2 = getMacroTokens(expr);
+      templateValue = resolveFunctionExpr(ctx, templateValue, expr);
+      templateValue = resolveCompileMacroExpr(ctx, templateValue, macroTokens2, index, cellPoints.length);
+      templateValue = resolveAliasExpr(ctx, templateValue, index);
+      cell.value = resolveValueExpr(ctx, templateValue);
+    });
+  } catch (err) {
+    const msg = err.message;
+    throw new Error(`expr:${expr.express}, resolve error: ${msg}`);
+  }
+};
+var generateWorkSheetCellsPlaceholder = function(ctx, expr, sheet) {
+  const errs = [];
+  const posExpr = expr.posExpr;
+  let cellsItems = expr.cells;
+  if ((cellsItems === void 0 || cellsItems.length <= 0) && posExpr !== void 0 && posExpr.value !== void 0) {
+    const r = posExpr.value;
+    if (r !== void 0) {
+      cellsItems = r.getCells();
+    }
+  }
+  if (!cellsItems || cellsItems.length === 0) {
+    return void 0;
+  }
+  ctx.sheet = sheet;
+  const cells = cellsItems;
+  toRowCells(cells).forEach((cellPoints, index) => compileRowCells(ctx, expr, cellPoints, index, errs));
+  return errs.length > 0 ? errs : void 0;
+};
+var hasGeneratorToken = function(tokens) {
+  for (const t of tokens) {
+    if (compileCellTokens.includes(t)) {
+      return true;
+    }
+  }
+  return false;
+};
+var compileWorkSheetPlaceholder = function(ctx, sheet, result) {
+  if (ctx.compileSheets !== void 0 && ctx.compileSheets.length > 0 && !ctx.compileSheets.includes(sheet.name)) {
+    return void 0;
+  }
+  const errs = [];
+  for (const [token, express] of result.rules.entries()) {
+    if (!isRuleToken(token)) {
+      continue;
+    }
+    for (const expr of express) {
+      if (expr.tokens.length <= 0 || !hasGeneratorToken(expr.tokens)) {
+        continue;
+      }
+      let err = generateWorkSheetCellsPlaceholder(ctx, expr, sheet);
+      if (err !== void 0 && err.length > 0) {
+        errs.push(...err);
+      }
+    }
+  }
+  if (errs.length > 0) {
+    return errs;
+  }
+  return void 0;
+};
+var loadCompileSheets = (workbook, ruleSheetName) => {
+  let first;
+  let sheets = [];
+  for (const [_, w] of workbook.worksheets.entries()) {
+    if (w.name === ruleSheetName) {
+      continue;
+    }
+    if (first === "") {
+      first = w.name;
+    }
+    if (!w.name.endsWith(".json") && !w.name.endsWith(".config")) {
+      sheets.push(w.name);
+    }
+  }
+  if (sheets.length <= 0 && first !== "") {
+    sheets.push(first);
+  }
+  return sheets;
+};
+var compile = async function(data, ruleSheetName, options) {
+  const workbook = await loadWorkbook(data);
+  const sheet = workbook.getWorksheet(ruleSheetName);
+  if (sheet === void 0) {
+    return {
+      workbook
+    };
+  }
+  if (workbook.worksheets === void 0) {
+    return {
+      workbook,
+      errs: [new Error(`worksheet, ${ruleSheetName} not exists!`)]
+    };
+  }
+  if (options === void 0) {
+    const excludes = [ruleSheetName];
+    options = RuleMapOptions.withAllSheets(workbook, excludes);
+  }
+  options = options.parseDefault(sheet);
+  if (options.compileSheets === void 0 || options.compileSheets.length === 0) {
+    options.compileSheets = loadCompileSheets(workbook, ruleSheetName);
+  }
+  const result = parseWorkSheetRules(sheet, options);
+  const errs = compileCheck(result, options);
+  if (errs !== void 0) {
+    return {
+      errs,
+      workbook,
+      configure: result
+    };
+  }
+  const compileErrs = [];
+  const ctx = CompileContext.create(options).loadAlias(result.rules);
+  for (const [i, w] of workbook.worksheets.entries()) {
+    if (w.name === ruleSheetName || i === ruleSheetName || !ctx.filterSheet(w.name)) {
+      continue;
+    }
+    let err = compileWorkSheetPlaceholder(ctx, w, result);
+    if (err !== void 0 && err.length > 0) {
+      compileErrs.push(...err);
+    }
+  }
+  if (compileErrs.length > 0) {
+    return {
+      workbook,
+      configure: result,
+      errs: compileErrs
+    };
+  }
+  return {
+    workbook,
+    configure: result
+  };
+};
+var fetchAlias = (m) => {
+  let sv;
+  const alias = /* @__PURE__ */ new Map();
+  if (m !== void 0 && m !== null && !(m instanceof Map) && m?.rules !== void 0) {
+    sv = m.rules;
+  } else if (m instanceof Map) {
+    if (m.size <= 0 || !m.has("alias" /* AliasToken */)) {
+      return alias;
+    }
+    sv = m;
+  } else {
+    return alias;
+  }
+  const values = sv.get("alias" /* AliasToken */);
+  for (const vs of values) {
+    if (typeof vs.value === "string") {
+      alias.set(vs.key, vs.value);
+    }
+  }
+  return alias;
+};
+var removeUnExportSheets = (w, options) => {
+  const removes = [];
+  if (typeof options.skipRemoveUnExportSheet === "boolean" && options.skipRemoveUnExportSheet === true) {
+    return w;
+  }
+  if (options.compileSheets === void 0 || options.compileSheets.length <= 0) {
+    for (const [i, v] of w.worksheets.entries()) {
+      const sheetName = v.name;
+      if (sheetName.endsWith(".config") || sheetName.endsWith(".json")) {
+        removes.push(sheetName);
+      }
+    }
+  } else {
+    for (const [i, v] of w.worksheets.entries()) {
+      if (!options.compileSheets.includes(v.name)) {
+        removes.push(v.name);
+      }
+    }
+  }
+  for (const [_, name] of removes.entries()) {
+    w.removeWorksheet(name);
+  }
+  return w;
+};
+var toBuffer = async (w) => {
+  const arrayBuffer = await w.xlsx.writeBuffer();
+  return Buffer.from(arrayBuffer);
+};
+var ExprResolver = class {
+};
+ExprResolver.toBuffer = toBuffer;
+ExprResolver.compile = compile;
+ExprResolver.toRowCells = toRowCells;
+ExprResolver.fetchAlias = fetchAlias;
+ExprResolver.getExprEnd = getExprEnd;
+ExprResolver.compileCheck = compileCheck;
+ExprResolver.extractMacro = extractMacro;
+ExprResolver.compileRowCells = compileRowCells;
+ExprResolver.searchIndexOf = searchIndexOf;
+ExprResolver.resolveAliasExpr = resolveAliasExpr;
+ExprResolver.resolveValueExpr = resolveValueExpr;
+ExprResolver.resolveFunctionExpr = resolveFunctionExpr;
+ExprResolver.removeUnExportSheets = removeUnExportSheets;
+ExprResolver.resolveCompileMacroGen = resolveCompileMacroGen;
+ExprResolver.resolveCompileMacroExpr = resolveCompileMacroExpr;
+
+// src/extends.ts
+var import_promises = __toESM(require("fs/promises"));
+
+// 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);
+});
+program.parse(process.argv);
+//# sourceMappingURL=bin.js.map