office-viewer 0.3.11 → 0.3.13

package/lib/excel/formula/functions/util/getFirstStrings.d.ts

@@ -0,0 +1,5 @@
+import { EvalResult } from '../../eval/EvalResult';
+/**
+ * 获取参数中的字符串，如果是数组则取第一个
+ */
+export declare function getFirstStrings(args: EvalResult[]): string[];

package/lib/excel/formula/functions/util/getNumber.d.ts

@@ -0,0 +1,11 @@
+import { EvalResult } from '../../eval/EvalResult';
+/**
+ *
+ * 获取参数中的数字
+ * @param arg
+ * @param defaultValue 默认值
+ * @returns
+ */
+export declare function getNumber(arg: EvalResult, defaultValue?: number, booleanToNumber?: boolean): number | undefined;
+export declare function getNumberOrThrow(arg: EvalResult, booleanToNumber?: boolean): number;
+export declare function getNumberWithDefault(arg: EvalResult, defaultValue: number): number;

package/lib/excel/formula/functions/util/getNumbers.d.ts

@@ -0,0 +1,9 @@
+import { EvalResult } from '../../eval/EvalResult';
+/**
+ *
+ * 获取参数中的数字
+ * @param args
+ * @param process 自定义检查函数
+ * @returns
+ */
+export declare function getNumbers(args: EvalResult[], process?: (arg: number | undefined, origin: EvalResult) => number | undefined, booleanToNumber?: boolean): number[];

package/lib/excel/formula/functions/util/getNumbersWithUndefined.d.ts

@@ -0,0 +1,12 @@
+import { EvalResult } from '../../eval/EvalResult';
+type NumOr = number | undefined;
+/**
+ *
+ * 获取参数中的数字
+ * @param args
+ * @param process 自定义检查函数
+ * @returns
+ */
+export declare function getNumber2DArray(args: EvalResult): NumOr[][];
+export declare function getNumber2DArrayOrThrow(args: EvalResult): number[][];
+export {};

package/lib/excel/formula/functions/util/getSingleValue.d.ts

@@ -0,0 +1,5 @@
+import { EvalResult } from '../../eval/EvalResult';
+/**
+ * 获取数据，如果遇到数组会持续找到数组内的值
+ */
+export declare function getSingleValue(value: EvalResult): EvalResult;

package/lib/excel/formula/functions/util/getString.d.ts

@@ -0,0 +1,4 @@
+import { EvalResult } from '../../eval/EvalResult';
+export declare function getString(arg: EvalResult, defaultValue?: string): string | undefined;
+export declare function getStringOrThrow(arg: EvalResult): string;
+export declare function getStringWithDefault(arg: EvalResult, defaultValue: string): string;

package/lib/excel/formula/functions/util/getStrings.d.ts

@@ -0,0 +1,2 @@
+import { EvalResult } from '../../eval/EvalResult';
+export declare function getStrings(args: EvalResult[]): string[];

package/lib/excel/formula/functions/util/jStat.d.ts

@@ -0,0 +1,79 @@
+export declare const jStat: {
+    beta: {
+        pdf: (x: number, alpha: number, beta: number) => number;
+        cdf: (x: number, alpha: number, beta: number) => number;
+        inv: (x: number, alpha: number, beta: number) => number;
+    };
+    binomial: {
+        pdf: (k: number, n: number, p: number) => number;
+        cdf: (x: number, n: number, p: number) => number;
+    };
+    chisquare: {
+        pdf: (x: number, dof: number) => number;
+        cdf: (x: number, dof: number) => number;
+        inv: (p: number, dof: number) => number;
+    };
+    normal: {
+        pdf: (x: number, mean: number, std: number) => number;
+        cdf: (x: number, mean: number, std: number) => number;
+        inv: (p: number, mean: number, std: number) => number;
+    };
+    centralF: {
+        pdf: (x: number, df1: number, df2: number) => number;
+        cdf: (x: number, df1: number, df2: number) => number;
+        inv: (x: number, df1: number, df2: number) => number;
+    };
+    studentt: {
+        pdf: (x: number, dof: number) => number;
+        cdf: (x: number, dof: number) => number;
+        inv: (p: number, dof: number) => number;
+    };
+    exponential: {
+        pdf: (x: number, rate: number) => number;
+        cdf: (x: number, rate: number) => number;
+        inv: (p: number, rate: number) => number;
+    };
+    gamma: {
+        pdf: (x: number, shape: number, scale: number) => number;
+        cdf: (x: number, shape: number, scale: number) => number;
+        inv: (p: number, shape: number, scale: number) => number;
+    };
+    lognormal: {
+        pdf: (x: number, mu: number, sigma: number) => number;
+        cdf: (x: number, mu: number, sigma: number) => number;
+        inv: (p: number, mu: number, sigma: number) => number;
+    };
+    negbin: {
+        pdf: (k: number, r: number, p: number) => number;
+        cdf: (x: number, r: number, p: number) => number;
+    };
+    poisson: {
+        pdf: (k: number, l: number) => number;
+        cdf: (x: number, l: number) => number;
+    };
+    erf: (x: number) => number;
+    ibetainv: (p: number, a: number, b: number) => number;
+    combination: (n: number, m: number) => number;
+    combinationln: (n: number, m: number) => number;
+    factorialln: (n: number) => number;
+    factorial: (n: number) => number;
+    betafn: (x: number, y: number) => number;
+    betaln: (x: number, y: number) => number;
+    ibeta: (x: number, a: number, b: number) => number;
+    betacf: (x: number, a: number, b: number) => number;
+    gammaln: (x: number) => number;
+    gammafn: (x: number) => number;
+    lowRegGamma: (a: number, x: number) => number;
+    gammapinv: (p: number, a: number) => number;
+    normalci: (...arg: number[]) => any[];
+    erfcinv: (p: number) => number;
+    erfc: (x: number) => number;
+    stdev: (arr: number[], flag?: boolean) => number;
+    variance: (arr: number[], flag?: boolean) => number;
+    mean: (arr: number[]) => number;
+    sum: (arr: number[]) => number;
+    sumsqerr: (arr: number[]) => number;
+    tci: (...arg: number[]) => any[];
+    covariance: (arr1: number[], arr2: number[]) => number;
+    corrcoeff: (arr1: number[], arr2: number[]) => number;
+};

package/lib/excel/formula/functions/util/loopArgs.d.ts

@@ -0,0 +1,2 @@
+import { EvalResult } from '../../eval/EvalResult';
+export declare function loopArgs(args: EvalResult[], hook: (arg: EvalResult) => void): void;

package/lib/excel/formula/functions/util/wildCard.d.ts

@@ -0,0 +1,4 @@
+export declare const WildCard: {
+    isWildCard: (obj: string) => boolean;
+    toRegex: (lookupText: string, flags?: string) => RegExp;
+};

package/lib/excel/formula/parser/ArrayParse.d.ts

@@ -0,0 +1,7 @@
+import { Parser } from '../Parser';
+import { ASTNode } from '../ast/ASTNode';
+import { Token } from '../tokenizer';
+import { PrefixParse } from './PrefixParse';
+export declare class ArrayParse implements PrefixParse {
+    parse(parser: Parser, token: Token): ASTNode;
+}

package/lib/excel/formula/parser/BinaryOperator.d.ts

@@ -0,0 +1,10 @@
+import { Parser } from '../Parser';
+import { ASTNode } from '../ast/ASTNode';
+import { Token } from '../tokenizer';
+import { InfixParse } from './InfixParse';
+export declare class BinaryOperator implements InfixParse {
+    precedence: number;
+    constructor(precedence: number);
+    parse(parser: Parser, left: ASTNode, token: Token): ASTNode;
+    getPrecedence(): number;
+}

package/lib/excel/formula/parser/ConstantParse.d.ts

@@ -0,0 +1,7 @@
+import { Parser } from '../Parser';
+import { ASTNode } from '../ast/ASTNode';
+import { Token } from '../tokenizer';
+import { PrefixParse } from './PrefixParse';
+export declare class ConstantParse implements PrefixParse {
+    parse(parser: Parser, token: Token): ASTNode;
+}

package/lib/excel/formula/parser/FunctionParse.d.ts

@@ -0,0 +1,7 @@
+import { Parser } from '../Parser';
+import { ASTNode } from '../ast/ASTNode';
+import { Token } from '../tokenizer';
+import { PrefixParse } from './PrefixParse';
+export declare class FunctionParse implements PrefixParse {
+    parse(parser: Parser, token: Token): ASTNode;
+}

package/lib/excel/formula/parser/GroupParse.d.ts

@@ -0,0 +1,7 @@
+import { Parser } from '../Parser';
+import { ASTNode } from '../ast/ASTNode';
+import { Token } from '../tokenizer';
+import { PrefixParse } from './PrefixParse';
+export declare class GroupParse implements PrefixParse {
+    parse(parser: Parser, token: Token): ASTNode;
+}

package/lib/excel/formula/parser/InfixParse.d.ts

@@ -0,0 +1,7 @@
+import type { Parser } from '../Parser';
+import { ASTNode } from '../ast/ASTNode';
+import { Token } from '../tokenizer';
+export interface InfixParse {
+    parse(parser: Parser, left: ASTNode, token: Token): ASTNode;
+    getPrecedence(): number;
+}

package/lib/excel/formula/parser/PercentParse.d.ts

@@ -0,0 +1,10 @@
+import { Parser } from '../Parser';
+import { ASTNode } from '../ast/ASTNode';
+import { Token } from '../tokenizer';
+import { InfixParse } from './InfixParse';
+export declare class PercentParse implements InfixParse {
+    precedence: number;
+    constructor(precedence: number);
+    parse(parser: Parser, left: ASTNode, token: Token): ASTNode;
+    getPrecedence(): number;
+}

package/lib/excel/formula/parser/PrefixOpParse.d.ts

@@ -0,0 +1,9 @@
+import { Parser } from '../Parser';
+import { ASTNode } from '../ast/ASTNode';
+import { Token } from '../tokenizer';
+import { PrefixParse } from './PrefixParse';
+export declare class PrefixOpParse implements PrefixParse {
+    precedence: number;
+    constructor(precedence: number);
+    parse(parser: Parser, token: Token): ASTNode;
+}

package/lib/excel/formula/parser/PrefixParse.d.ts

@@ -0,0 +1,6 @@
+import { Parser } from '../Parser';
+import { ASTNode } from '../ast/ASTNode';
+import { Token } from '../tokenizer';
+export interface PrefixParse {
+    parse(parser: Parser, token: Token): ASTNode;
+}

package/lib/excel/formula/parser/RefParse.d.ts

@@ -0,0 +1,7 @@
+import { Parser } from '../Parser';
+import { ASTNode } from '../ast/ASTNode';
+import { Token } from '../tokenizer';
+import { PrefixParse } from './PrefixParse';
+export declare class RefParse implements PrefixParse {
+    parse(parser: Parser, token: Token): ASTNode;
+}

package/lib/excel/formula/parser/parseCriteria.d.ts

@@ -0,0 +1,12 @@
+export type Criteria = {
+    op: '<>' | '<' | '<=' | '>' | '>=' | '=' | 'wc';
+    value: string | number | boolean | RegExp;
+    isArray?: boolean;
+    match?: boolean;
+};
+/**
+ * Parse criteria, support comparison and wild card match.
+ * @param {string|number} criteria
+ * @return {{op: string, value: string|number|boolean|RegExp, match: boolean|undefined}} - The parsed criteria.
+ */
+export declare function parseCriteria(criteria: string | number): Criteria;

package/lib/excel/formula/parser/remoteQuote.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 去掉字符串两边的引号
+ */
+export declare function removeQuote(str: string): string;

package/lib/excel/formula/parser/tokenIsRef.d.ts

@@ -0,0 +1,2 @@
+import { Token } from '../tokenizer';
+export declare function tokenIsRef(token?: Token): boolean | undefined;

package/lib/excel/formula/parser/tokenPriorityMap.d.ts

@@ -0,0 +1,9 @@
+export declare const Precedence: {
+    PLUS: number;
+    MUL: number;
+    CARET: number;
+    COMPARE: number;
+    PREFIX: number;
+    POSTFIX: number;
+    FUNCTION: number;
+};

package/lib/excel/formula/tokenizer.d.ts

@@ -0,0 +1,118 @@
+/**
+ * 将 excel 公式解析成 token
+ */
+export declare const tokenDefines: {
+    SPACE: {
+        pattern: RegExp;
+    };
+    STRING: {
+        pattern: RegExp;
+    };
+    SHEET_QUOTE: {
+        pattern: RegExp;
+    };
+    SINGLE_QUOTE_STRING: {
+        pattern: RegExp;
+    };
+    FUNCTION: {
+        pattern: RegExp;
+    };
+    ERROR: {
+        pattern: RegExp;
+    };
+    ERROR_REF: {
+        pattern: RegExp;
+    };
+    SHEET: {
+        pattern: RegExp;
+    };
+    BOOLEAN: {
+        pattern: RegExp;
+    };
+    CELL: {
+        pattern: RegExp;
+    };
+    NAME: {
+        pattern: RegExp;
+    };
+    NUMBER: {
+        pattern: RegExp;
+    };
+    AT: {
+        pattern: RegExp;
+    };
+    COMMA: {
+        pattern: RegExp;
+    };
+    COLON: {
+        pattern: RegExp;
+    };
+    SEMICOLON: {
+        pattern: RegExp;
+    };
+    OPEN_PAREN: {
+        pattern: RegExp;
+    };
+    CLOSE_PAREN: {
+        pattern: RegExp;
+    };
+    OPEN_BRACKET: {
+        pattern: RegExp;
+    };
+    CLOSE_BRACKET: {
+        pattern: RegExp;
+    };
+    OPEN_CURLY: {
+        pattern: RegExp;
+    };
+    CLOSE_CURLY: {
+        pattern: RegExp;
+    };
+    MUL: {
+        pattern: RegExp;
+    };
+    DIV: {
+        pattern: RegExp;
+    };
+    PLUS: {
+        pattern: RegExp;
+    };
+    MINUS: {
+        pattern: RegExp;
+    };
+    CONCAT: {
+        pattern: RegExp;
+    };
+    CARET: {
+        pattern: RegExp;
+    };
+    PERCENT: {
+        pattern: RegExp;
+    };
+    NE: {
+        pattern: RegExp;
+    };
+    GE: {
+        pattern: RegExp;
+    };
+    LE: {
+        pattern: RegExp;
+    };
+    GT: {
+        pattern: RegExp;
+    };
+    LT: {
+        pattern: RegExp;
+    };
+    EQ: {
+        pattern: RegExp;
+    };
+};
+export type TokenName = keyof typeof tokenDefines;
+export type Token = {
+    name: TokenName;
+    value: string;
+    start: number;
+    end: number;
+};
+export declare function tokenize(formula: string): Token[];

package/lib/excel/io/excel/parseWorkbook.js

@@ -54,53 +54,57 @@ function parseWorkbook(parser, styleSheet) {
                         theme: theme
                     };
                     sharedStrings = [];
-                    if (!parser.fileExists('xl/sharedStrings.xml')) return [3 /*break*/, 8];
-                    return [4 /*yield*/, parseSharedStrings.parseSharedStrings(parser.getString('xl/sharedStrings.xml'))];
+                    if (!parser.fileExists('xl/sharedStrings.xml.json')) return [3 /*break*/, 7];
+                    sharedStrings = JSON.parse(parser.getString('xl/sharedStrings.xml.json'));
+                    return [3 /*break*/, 9];
                 case 7:
-                    sharedStrings = _f.sent();
-                    _f.label = 8;
+                    if (!parser.fileExists('xl/sharedStrings.xml')) return [3 /*break*/, 9];
+                    return [4 /*yield*/, parseSharedStrings.parseSharedStrings(parser.getString('xl/sharedStrings.xml'))];
                 case 8:
-                    _f.trys.push([8, 16, 17, 18]);
-                    _a = tslib.__values(node.children || []), _b = _a.next();
+                    sharedStrings = _f.sent();
                     _f.label = 9;
                 case 9:
-                    if (!!_b.done) return [3 /*break*/, 15];
+                    _f.trys.push([9, 17, 18, 19]);
+                    _a = tslib.__values(node.children || []), _b = _a.next();
+                    _f.label = 10;
+                case 10:
+                    if (!!_b.done) return [3 /*break*/, 16];
                     child = _b.value;
                     tag = child.tag;
                     _c = tag;
                     switch (_c) {
-                        case 'sheets': return [3 /*break*/, 10];
-                        case 'calcPr': return [3 /*break*/, 12];
-                        case 'definedNames': return [3 /*break*/, 13];
+                        case 'sheets': return [3 /*break*/, 11];
+                        case 'calcPr': return [3 /*break*/, 13];
+                        case 'definedNames': return [3 /*break*/, 14];
                     }
-                    return [3 /*break*/, 14];
-                case 10:
+                    return [3 /*break*/, 15];
+                case 11:
                     _d = workbook;
                     return [4 /*yield*/, parseSheet.parseSheets(child, parser, workbook, sharedStrings)];
-                case 11:
-                    _d.sheets = _f.sent();
-                    return [3 /*break*/, 14];
                 case 12:
-                    workbook.calcPr = autoParse.autoParse(child, ExcelTypes.CT_CalcPr_Attributes);
-                    return [3 /*break*/, 14];
+                    _d.sheets = _f.sent();
+                    return [3 /*break*/, 15];
                 case 13:
-                    workbook.definedNames = parseDefinedNames.parseDefinedNames(child);
-                    return [3 /*break*/, 14];
+                    workbook.calcPr = autoParse.autoParse(child, ExcelTypes.CT_CalcPr_Attributes);
+                    return [3 /*break*/, 15];
                 case 14:
+                    workbook.definedNames = parseDefinedNames.parseDefinedNames(child);
+                    return [3 /*break*/, 15];
+                case 15:
                     _b = _a.next();
-                    return [3 /*break*/, 9];
-                case 15: return [3 /*break*/, 18];
-                case 16:
+                    return [3 /*break*/, 10];
+                case 16: return [3 /*break*/, 19];
+                case 17:
                     e_1_1 = _f.sent();
                     e_1 = { error: e_1_1 };
-                    return [3 /*break*/, 18];
-                case 17:
+                    return [3 /*break*/, 19];
+                case 18:
                     try {
                         if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
                     }
                     finally { if (e_1) throw e_1.error; }
                     return [7 /*endfinally*/];
-                case 18: return [2 /*return*/, workbook];
+                case 19: return [2 /*return*/, workbook];
             }
         });
     });

package/lib/excel/io/excel/util/Range.d.ts

@@ -5,6 +5,7 @@ import { ViewRange } from '../../../sheet/ViewRange';
 import { RangeRef } from '../../../types/RangeRef';
 /**
  * 解析选区字符串，比如 A1:B2
+ * 还支持 A 或者 A:B 这种整列选择
  */
 export declare function parseRange(range: string): RangeRef;
 /**
@@ -35,6 +36,14 @@ export declare function inRange(range: RangeRef, otherRange: RangeRef): boolean;
  * @param range2
  */
 export declare function rangeEqual(range1: RangeRef, range2: RangeRef): boolean;
+/**
+ * 获取两个选区的交集
+ */
+export declare function getIntersectRange(range1: RangeRef, range2: RangeRef): RangeRef | null;
+/**
+ * 获取多个选区之间的交集
+ */
+export declare function getIntersectRanges(ranges: RangeRef[]): RangeRef | null;
 /**
  * 判断两个选区是否相交
  */
@@ -64,3 +73,6 @@ export declare function viewRangeToRangeRef(viewRange: ViewRange): {
     endRow: number;
     endCol: number;
 };
+/**
+ * 获取量选区
+ */

package/lib/excel/io/excel/util/Range.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
+var Consts = require('../../../render/Consts.js');
 var decodeAddress = require('./decodeAddress.js');
 var numberToLetters = require('./numberToLetters.js');
 
@@ -11,6 +12,7 @@ var numberToLetters = require('./numberToLetters.js');
  */
 /**
  * 解析选区字符串，比如 A1:B2
+ * 还支持 A 或者 A:B 这种整列选择
  */
 function parseRange(range) {
     if (range.indexOf(':') !== -1) {
@@ -19,6 +21,16 @@ function parseRange(range) {
             throw new Error('range 格式错误');
         }
         var _a = tslib.__read(parts, 2), start = _a[0], end = _a[1];
+        if (start.match(/^[A-Z]{1,3}$/) && end.match(/^[A-Z]{1,3}$/)) {
+            var startCol = decodeAddress.columnNameToNumber(start);
+            var endCol = decodeAddress.columnNameToNumber(end);
+            return {
+                startRow: 0,
+                startCol: startCol,
+                endRow: Consts.MAX_ROW,
+                endCol: endCol
+            };
+        }
         var startRange = decodeAddress.decodeAddress(start);
         var endRange = decodeAddress.decodeAddress(end);
         return {
@@ -29,6 +41,15 @@ function parseRange(range) {
         };
     }
     else {
+        if (range.match(/^[A-Z]{1,3}$/)) {
+            var col = decodeAddress.columnNameToNumber(range);
+            return {
+                startRow: 0,
+                startCol: col,
+                endRow: Consts.MAX_ROW,
+                endCol: col
+            };
+        }
         var startRange = decodeAddress.decodeAddress(range);
         return {
             startRow: startRange.row,
@@ -120,6 +141,9 @@ function viewRangeToRangeRef(viewRange) {
         endCol: cols[cols.length - 1]
     };
 }
+/**
+ * 获取量选区
+ */
 
 exports.isCellInRange = isCellInRange;
 exports.isMergeCell = isMergeCell;

package/lib/excel/io/excel/util/__tests__/range.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/excel/io/excel/util/decodeAddress.d.ts

@@ -9,3 +9,9 @@ export declare function decodeAddress(value: string): {
     col: number;
     row: number;
 };
+/**
+ * 将 A 转成 0
+ * @param columnName
+ * @returns
+ */
+export declare function columnNameToNumber(columnName: string): number;

package/lib/excel/io/excel/util/decodeAddress.js

@@ -63,5 +63,23 @@ function decodeAddress(value) {
     }
     return address;
 }
+/**
+ * 将 A 转成 0
+ * @param columnName
+ * @returns
+ */
+function columnNameToNumber(columnName) {
+    columnName = columnName.toUpperCase();
+    var len = columnName.length;
+    var number = 0;
+    for (var i = 0; i < len; i++) {
+        var code = columnName.charCodeAt(i);
+        if (!isNaN(code)) {
+            number += (code - 64) * Math.pow(26, (len - i - 1));
+        }
+    }
+    return number - 1;
+}
 
+exports.columnNameToNumber = columnNameToNumber;
 exports.decodeAddress = decodeAddress;

package/lib/excel/lang/lang.d.ts

@@ -23,7 +23,7 @@ declare const languages: {
         count: string;
         sum: string;
     };
-    zh_CN: Record<"autoFilter.sortAscending" | "autoFilter.sortDescending" | "checkBox.selectAll" | "checkBox.search" | "customFilter.equal" | "customFilter.notEqual" | "customFilter.greaterThan" | "customFilter.greaterThanOrEqual" | "customFilter.lessThan" | "customFilter.lessThanOrEqual" | "customFilter.beginsWith" | "customFilter.notBeginsWith" | "customFilter.endsWith" | "customFilter.notEndsWith" | "customFilter.contains" | "customFilter.notContains" | "customFilter.and" | "customFilter.or" | "average" | "count" | "sum", string>;
+    zh_CN: Record<"count" | "sum" | "average" | "customFilter.equal" | "customFilter.notEqual" | "customFilter.beginsWith" | "customFilter.notBeginsWith" | "customFilter.endsWith" | "customFilter.notEndsWith" | "customFilter.contains" | "customFilter.notContains" | "customFilter.greaterThan" | "customFilter.greaterThanOrEqual" | "customFilter.lessThan" | "customFilter.lessThanOrEqual" | "autoFilter.sortAscending" | "autoFilter.sortDescending" | "checkBox.selectAll" | "checkBox.search" | "customFilter.and" | "customFilter.or", string>;
 };
 export type Language = keyof typeof languages;
 export declare function getTranslate(language: string): (key: EnKeys) => string;

package/lib/excel/render/ExcelRender.js

@@ -347,7 +347,7 @@ var ExcelRender = /** @class */ (function () {
      */
     ExcelRender.prototype.loadFont = function () {
         return tslib.__awaiter(this, void 0, void 0, function () {
-            var fontURL, notAvailableFonts, needReDraw, notAvailableFonts_1, notAvailableFonts_1_1, font, fontFace, e_1_1;
+            var fontURL, notAvailableFonts, needReDraw, notAvailableFonts_1, notAvailableFonts_1_1, font, fontFace, e_1_1, currentSheet;
             var e_1, _a;
             return tslib.__generator(this, function (_b) {
                 switch (_b.label) {
@@ -396,6 +396,8 @@ var ExcelRender = /** @class */ (function () {
                         if (needReDraw) {
                             // 宽度可能变化
                             measureTextWithCache.inValidTextSizeCache();
+                            currentSheet = this.workbook.getActiveSheet();
+                            currentSheet.clearFontCache();
                             this.setNeedReDraw();
                         }
                         return [2 /*return*/];