@shbernal/ts-xlsx 3.1.0 → 3.2.0

package/dist/core/formula.d.ts

@@ -1,6 +1,6 @@
 /**
  * Quote a sheet name for use in a reference exactly when Excel would: a name that is not a plain
- * identifier, or that would read as a cell address, is wrapped in single quotes with its internal
+ * identifier, or that would read as a reference, is wrapped in single quotes with its internal
  * quotes doubled, and a simple name is left bare. Shared by everything that *builds* a qualified
  * reference: the `_FilterDatabase` name the writer derives from an autofilter, and the `.xlsb`
  * reader's Ptg decoder, which has only a sheet index to work from and must spell the prefix itself.
@@ -11,7 +11,8 @@
  */
 export declare function quoteSheetName(name: string, last?: string): string;
 /**
- * Prefix every modern function called by its plain name with `_xlfn.` so Excel accepts the stored
+ * Prefix every future function called by its plain name with the prefix Excel stores it under
+ * (`_xlfn.`, or `_xlfn._xlws.` for the worksheet-only FILTER, SORT and PY) so Excel accepts the stored
  * formula. Names already prefixed are left alone (never doubled), unknown/legacy functions pass
  * through untouched, and opaque regions (string literals, sheet names, structured references) are
  * preserved verbatim. No other rewriting occurs: in particular no `@` implicit-intersection operator
@@ -19,34 +20,66 @@ export declare function quoteSheetName(name: string, last?: string): string;
  */
 export declare function mangleFunctions(formula: string): string;
 /**
- * Strip the `_xlfn.` function prefix and the `_xlpm.` LET-parameter prefix back to the plain names,
- * so the model holds the readable form regardless of how a file stored it. Opaque regions (string
- * literals, sheet names, structured references) are left untouched.
+ * Strip the `_xlfn.` function prefix (with the `_xlws.` a worksheet-only function adds after it), the
+ * `_xlpm.` LET-parameter prefix and the `_xleta.` prefix of a function passed as a value back to the
+ * plain names, so the model holds the readable form regardless of how a file stored it. Opaque regions
+ * (string literals, sheet names, structured references) are left untouched.
+ *
+ * `definedNames` is every name the workbook defines, whatever its scope, as {@link definedNameKeys}
+ * spells them. A function passed as a value keeps its prefix when one of them is spelled like it,
+ * since the bare name could then read as that name. Excel's own formula text does the same: with a
+ * `LEN` defined only on another sheet, `Range.Formula` still reports `MAP(A1:A3,_xleta.LEN)`.
  */
-export declare function unmangleFunctions(formula: string): string;
+export declare function unmangleFunctions(formula: string, definedNames: ReadonlySet<string>): string;
 /**
  * Prefix every LET/LAMBDA parameter identifier with `_xlpm.`, at its declaration and at each
  * reference within the binding call's parentheses, so Excel accepts the stored formula. The prefix
  * is lexically scoped: a name is only rewritten inside the call that binds it, opaque regions are
  * copied verbatim, and a lambda-valued parameter used as a call (`f(…)`) is prefixed too. Formulas
- * with no LET/LAMBDA pass through unchanged.
+ * with no LET/LAMBDA pass through unchanged. A parameter matches case-insensitively, as Excel's names
+ * do, and every reference to it is written in the spelling it was declared with, as Excel writes it.
  */
 export declare function mangleParams(formula: string): string;
 /**
- * Mangle a model formula into its on-disk form: LET/LAMBDA parameter names first (`_xlpm.`), then the
- * modern-function prefix (`_xlfn.`). Ordering matters: parameter mangling reads the plain LET/LAMBDA
- * names before the function pass qualifies them. The inverse for both prefixes is unmangleFunctions.
+ * Prefix every built-in function a formula passes as a value with `_xleta.`, uppercased as Excel writes
+ * it, so Excel reads the function rather than a defined name spelled like it. A value is any use that
+ * is not a call: the `SUM` in `BYROW(A1:A3,SUM)`, in `LET(f,SUM,f(A1:A3))`, in `SUM+1`.
+ *
+ * `namesInScope` is {@link formulaNamesInScope} for where the formula sits, and a function name among
+ * them stays bare, because there it means the defined name. Run after {@link mangleParams}, so that a
+ * LET or LAMBDA parameter spelled like a function already carries `_xlpm.`.
+ *
+ * A name is not a value where it names a sheet (`SUM!A1`, `SUM:Other!A1`) or a table (`Rate[Amount]`),
+ * where a sheet or workbook qualifies it (`S1!SUM`), or inside an error literal: the `N` of `#N/A` is a
+ * function too.
  */
-export declare function mangleFormula(formula: string): string;
+export declare function mangleFunctionValues(formula: string, namesInScope: ReadonlySet<string>): string;
 /**
- * Shift every relative cell reference in a formula by `colDelta` columns and `rowDelta` rows, leaving
- * absolute (`$`-anchored) axes fixed. This is how a shared-formula clone recovers its own formula from
- * the master's: a master `A1*2` shared one row down reads back as `A2*2`, and `$A$1*B1` shared one row
- * and one column across as `$A$1*C2`. String literals, single-quoted sheet names, and bracketed
- * structured references are copied verbatim, and a sheet-qualified reference shifts the cell while its
- * sheet name is untouched. Function names and defined names carry no row digits, so they pass through.
+ * How a formula compares names: uppercased, as Excel's names are case-insensitive. The reader's form of
+ * the set {@link unmangleFunctions} takes, built from every name the workbook defines.
+ */
+export declare function definedNameKeys(names: readonly {
+    readonly name: string;
+}[]): ReadonlySet<string>;
+/**
+ * The names a bare name in a formula resolves to, as {@link definedNameKeys} spells them: every
+ * workbook-level name, and the names scoped to `sheet`. For a cell formula `sheet` is the cell's own
+ * sheet; for a defined name's formula it is the sheet that name is scoped to, and `undefined` for a
+ * workbook-level name. A sheet is matched case-insensitively, as it is everywhere else.
+ */
+export declare function formulaNamesInScope(names: readonly {
+    readonly name: string;
+    readonly scope?: string | undefined;
+}[], sheet: string | undefined): ReadonlySet<string>;
+/**
+ * Mangle a model formula into its on-disk form: LET/LAMBDA parameter names first (`_xlpm.`), then the
+ * functions it passes as values (`_xleta.`), then the modern-function prefix (`_xlfn.`). Ordering
+ * matters: parameter mangling reads the plain LET/LAMBDA names before the function pass qualifies them,
+ * and a parameter spelled like a function has to carry `_xlpm.` before the value pass looks for
+ * functions. `namesInScope` is {@link formulaNamesInScope} for where the formula sits. The inverse for
+ * every prefix is unmangleFunctions.
  */
-export declare function translateFormula(formula: string, colDelta: number, rowDelta: number): string;
+export declare function mangleFormula(formula: string, namesInScope: ReadonlySet<string>): string;
 /**
  * A number as it appears *inside formula text*, which is not the same serialisation as an
  * attribute's.

package/dist/core/formula.js

@@ -1,79 +1,32 @@
 import { assertWritableNumber } from '../errors.js';
-import { MAX_COLUMN, MAX_ROW, numberToColumn, tryColumnToNumber } from './address.js';
-import { MODERN_FUNCTIONS } from './modern-functions.js';
-import { REF_ERROR } from './value.js';
-const XLFN = '_xlfn.';
+import { nameReadsAsReference } from './address.js';
+import { scanFormula, skipOpaque } from './formula-scan.js';
+import { FUNCTION_VALUE_NAMES } from './function-values.js';
+import { FUTURE_FUNCTION_PREFIXES } from './future-functions.js';
 const XLPM = '_xlpm.';
+const XLETA = '_xleta.';
 export function quoteSheetName(name, last) {
     const names = last === undefined ? [name] : [name, last];
     const joined = names.join(':');
     return names.every(isBareSheetName) ? joined : `'${joined.replace(/'/g, "''")}'`;
 }
 function isBareSheetName(name) {
-    return /^[A-Za-z_][A-Za-z0-9_.]*$/.test(name) && !/^[A-Za-z]{1,3}\d+$/.test(name);
+    return /^[A-Za-z_][A-Za-z0-9_.]*$/.test(name) && !nameReadsAsReference(name);
 }
 const SCOPING_FUNCTIONS = new Set(['LET', 'LAMBDA']);
 const FUNCTION_CALL = /(?<![A-Za-z0-9_.])([A-Za-z_][A-Za-z0-9_.]*)(\s*\()/g;
-const PREFIX = /_xlfn\.|_xlpm\./g;
-function skipOpaque(formula, index) {
-    const opener = formula[index];
-    const n = formula.length;
-    if (opener === '"' || opener === "'") {
-        let j = index + 1;
-        while (j < n) {
-            if (formula[j] === opener) {
-                if (formula[j + 1] === opener) {
-                    j += 2;
-                    continue;
-                }
-                return j + 1;
-            }
-            j += 1;
-        }
-        return n;
-    }
-    if (opener === '[') {
-        let depth = 0;
-        let j = index;
-        while (j < n) {
-            const ch = formula[j];
-            if (ch === '[')
-                depth += 1;
-            else if (ch === ']') {
-                depth -= 1;
-                if (depth === 0)
-                    return j + 1;
-            }
-            j += 1;
-        }
-        return n;
-    }
-    return index;
-}
-function scanFormula(formula, transform) {
-    let out = '';
-    let codeStart = 0;
-    let i = 0;
-    const n = formula.length;
-    while (i < n) {
-        const past = skipOpaque(formula, i);
-        if (past > i) {
-            out += transform(formula.slice(codeStart, i));
-            out += formula.slice(i, past);
-            i = past;
-            codeStart = past;
-        }
-        else {
-            i += 1;
-        }
-    }
-    return out + transform(formula.slice(codeStart));
-}
+const PREFIX = /_xlfn\.(?:_xlws\.)?|_xlpm\./g;
+const FUNCTION_VALUE_PREFIX = /_xleta\.([A-Za-z_][A-Za-z0-9_.]*)/g;
 export function mangleFunctions(formula) {
-    return scanFormula(formula, (code) => code.replace(FUNCTION_CALL, (whole, name, open) => MODERN_FUNCTIONS.has(name.toUpperCase()) ? `${XLFN}${name}${open}` : whole));
+    return scanFormula(formula, (code) => code.replace(FUNCTION_CALL, (whole, name, open) => {
+        const prefix = FUTURE_FUNCTION_PREFIXES.get(name.toUpperCase());
+        return prefix === undefined ? whole : `${prefix}${name}${open}`;
+    }));
 }
-export function unmangleFunctions(formula) {
-    return scanFormula(formula, (code) => code.replace(PREFIX, ''));
+export function unmangleFunctions(formula, definedNames) {
+    return scanFormula(formula, (code) => code
+        .replace(PREFIX, '')
+        .replace(FUNCTION_VALUE_PREFIX, (whole, name) => definedNames.has(name.toUpperCase()) ? whole : name));
 }
 const NAME_START = /[A-Za-z_]/;
 const NAME_CHAR = /[A-Za-z0-9_.]/;
@@ -136,13 +89,13 @@ function boundName(formula, [start, end]) {
     return name.startsWith(XLPM) ? undefined : name;
 }
 function parameterNames(formula, keyword, args) {
-    const names = new Set();
+    const names = new Map();
     const isLambda = keyword === 'LAMBDA';
     for (let a = 0; a < args.length - 1; a += 1) {
         if (isLambda || a % 2 === 0) {
             const name = boundName(formula, args[a]);
-            if (name !== undefined)
-                names.add(name);
+            if (name !== undefined && !names.has(name.toUpperCase()))
+                names.set(name.toUpperCase(), name);
         }
     }
     return names;
@@ -152,7 +105,15 @@ export function mangleParams(formula) {
     let i = 0;
     const n = formula.length;
     const frames = [];
-    const inScope = (name) => frames.some((frame) => frame.names.has(name));
+    const declared = (name) => {
+        const key = name.toUpperCase();
+        for (let f = frames.length - 1; f >= 0; f -= 1) {
+            const spelling = frames[f]?.names.get(key);
+            if (spelling !== undefined)
+                return spelling;
+        }
+        return undefined;
+    };
     while (i < n) {
         const top = frames[frames.length - 1];
         if (top !== undefined && i >= top.end) {
@@ -177,35 +138,65 @@ export function mangleParams(formula) {
         while (k < n && WHITESPACE.test(formula[k] ?? ''))
             k += 1;
         const heads = formula[k] === '(';
-        if (heads && SCOPING_FUNCTIONS.has(name.toUpperCase()) && !inScope(name)) {
+        if (heads && SCOPING_FUNCTIONS.has(name.toUpperCase()) && declared(name) === undefined) {
             const { close, args } = parseCall(formula, k);
             out += formula.slice(i, k + 1);
             frames.push({ end: close, names: parameterNames(formula, name.toUpperCase(), args) });
             i = k + 1;
             continue;
         }
-        out += inScope(name) ? `${XLPM}${name}` : name;
+        const spelling = declared(name);
+        out += spelling === undefined ? name : `${XLPM}${spelling}`;
         i = nameEnd;
     }
     return out;
 }
-export function mangleFormula(formula) {
-    return mangleFunctions(mangleParams(formula));
-}
-const CELL_REFERENCE = /(?<![A-Za-z0-9_.])(\$?)([A-Z]{1,3})(\$?)([0-9]{1,7})(?![A-Za-z0-9_.!(])/g;
-export function translateFormula(formula, colDelta, rowDelta) {
-    if (colDelta === 0 && rowDelta === 0)
-        return formula;
-    return scanFormula(formula, (code) => code.replace(CELL_REFERENCE, (_match, colAbs, colLetters, rowAbs, rowDigits) => {
-        const decoded = tryColumnToNumber(colLetters);
-        if (decoded === undefined)
-            return REF_ERROR;
-        const col = colAbs === '$' ? decoded : decoded + colDelta;
-        const row = rowAbs === '$' ? Number(rowDigits) : Number(rowDigits) + rowDelta;
-        if (col < 1 || col > MAX_COLUMN || row < 1 || row > MAX_ROW)
-            return REF_ERROR;
-        return `${colAbs}${numberToColumn(col)}${rowAbs}${row}`;
-    }));
+export function mangleFunctionValues(formula, namesInScope) {
+    let out = '';
+    let i = 0;
+    while (i < formula.length) {
+        const past = skipOpaque(formula, i);
+        if (past > i) {
+            out += formula.slice(i, past);
+            i = past;
+            continue;
+        }
+        const end = readName(formula, i);
+        if (end === i) {
+            out += formula.charAt(i);
+            i += 1;
+            continue;
+        }
+        const name = formula.slice(i, end);
+        out += isFunctionValue(formula, i, end, namesInScope) ? `${XLETA}${name.toUpperCase()}` : name;
+        i = end;
+    }
+    return out;
+}
+const QUALIFIES_NAME = /[A-Za-z0-9_.!#\]]/;
+const NAMES_A_CONTAINER = /[!:[]/;
+function isFunctionValue(formula, start, end, namesInScope) {
+    const name = formula.slice(start, end).toUpperCase();
+    if (!FUNCTION_VALUE_NAMES.has(name) || namesInScope.has(name))
+        return false;
+    if (QUALIFIES_NAME.test(formula.charAt(start - 1)))
+        return false;
+    if (NAMES_A_CONTAINER.test(formula.charAt(end)))
+        return false;
+    let next = end;
+    while (WHITESPACE.test(formula.charAt(next)))
+        next += 1;
+    return formula.charAt(next) !== '(';
+}
+export function definedNameKeys(names) {
+    return new Set(names.map(({ name }) => name.toUpperCase()));
+}
+export function formulaNamesInScope(names, sheet) {
+    const wanted = sheet?.toLowerCase();
+    return definedNameKeys(names.filter(({ scope }) => scope === undefined || scope.toLowerCase() === wanted));
+}
+export function mangleFormula(formula, namesInScope) {
+    return mangleFunctions(mangleFunctionValues(mangleParams(formula), namesInScope));
 }
 export function formulaNumberLiteral(value) {
     assertWritableNumber(value);

package/dist/core/function-values.d.ts

@@ -0,0 +1,4 @@
+export declare const NOT_VALUES: ReadonlySet<string>;
+export declare const OLDER_FUNCTION_VALUES: readonly string[];
+/** Every built-in function Excel stores under `_xleta.` when a formula passes it as a value. */
+export declare const FUNCTION_VALUE_NAMES: ReadonlySet<string>;

package/dist/core/function-values.js

@@ -0,0 +1,58 @@
+import { FUTURE_FUNCTION_PREFIXES } from './future-functions.js';
+const OLDER_FUNCTIONS = `
+  ABS ACCRINT ACCRINTM ACOS ACOSH ADDRESS AMORDEGRC AMORLINC AND AREAS ASC ASIN ASINH ATAN ATAN2 ATANH
+  AVEDEV AVERAGE AVERAGEA AVERAGEIF AVERAGEIFS
+  BAHTTEXT BESSELI BESSELJ BESSELK BESSELY BETADIST BETAINV BIN2DEC BIN2HEX BIN2OCT BINOMDIST
+  CEILING CELL CHAR CHIDIST CHIINV CHITEST CHOOSE CLEAN CODE COLUMN COLUMNS COMBIN COMPLEX CONCATENATE
+  CONFIDENCE CONVERT CORREL COS COSH COUNT COUNTA COUNTBLANK COUNTIF COUNTIFS COUPDAYBS COUPDAYS
+  COUPDAYSNC COUPNCD COUPNUM COUPPCD COVAR CRITBINOM CUBEKPIMEMBER CUBEMEMBER CUBEMEMBERPROPERTY
+  CUBERANKEDMEMBER CUBESET CUBESETCOUNT CUBEVALUE CUMIPMT CUMPRINC
+  DATE DATEDIF DATESTRING DATEVALUE DAVERAGE DAY DAYS360 DB DBCS DCOUNT DCOUNTA DDB DEC2BIN DEC2HEX
+  DEC2OCT DEGREES DELTA DEVSQ DGET DISC DMAX DMIN DOLLAR DOLLARDE DOLLARFR DPRODUCT DSTDEV DSTDEVP DSUM
+  DURATION DVAR DVARP
+  EDATE EFFECT EOMONTH ERF ERFC ERROR.TYPE EVEN EXACT EXP EXPONDIST
+  FACT FACTDOUBLE FDIST FIND FINDB FINV FISHER FISHERINV FIXED FLOOR FORECAST FREQUENCY FTEST FV
+  FVSCHEDULE
+  GAMMADIST GAMMAINV GAMMALN GCD GEOMEAN GESTEP GETPIVOTDATA GROWTH
+  HARMEAN HEX2BIN HEX2DEC HEX2OCT HLOOKUP HOUR HYPERLINK HYPGEOMDIST
+  IF IFERROR IMABS IMAGINARY IMARGUMENT IMCONJUGATE IMCOS IMDIV IMEXP IMLN IMLOG10 IMLOG2 IMPOWER
+  IMPRODUCT IMREAL IMSIN IMSQRT IMSUB IMSUM INDEX INDIRECT INFO INT INTERCEPT INTRATE IPMT IRR ISBLANK
+  ISERR ISERROR ISEVEN ISLOGICAL ISNA ISNONTEXT ISNUMBER ISODD ISPMT ISREF ISTEXT ISTHAIDIGIT
+  KURT
+  LARGE LCM LEFT LEFTB LEN LENB LINEST LN LOG LOGEST LOGINV LOGNORMDIST LOOKUP LOWER
+  MATCH MAX MAXA MDETERM MDURATION MEDIAN MID MIDB MIN MINA MINUTE MINVERSE MIRR MMULT MOD MODE MONTH
+  MROUND MULTINOMIAL
+  N NA NEGBINOMDIST NETWORKDAYS NOMINAL NORMDIST NORMINV NORMSDIST NORMSINV NOT NOW NPER NPV
+  NUMBERSTRING
+  OCT2BIN OCT2DEC OCT2HEX ODD ODDFPRICE ODDFYIELD ODDLPRICE ODDLYIELD OFFSET OR
+  PEARSON PERCENTILE PERCENTRANK PERMUT PHONETIC PI PMT POISSON POWER PPMT PRICE PRICEDISC PRICEMAT
+  PROB PRODUCT PROPER PV
+  QUARTILE QUOTIENT
+  RADIANS RAND RANDBETWEEN RANK RATE RECEIVED REPLACE REPLACEB REPT RIGHT RIGHTB ROMAN ROUND
+  ROUNDBAHTDOWN ROUNDBAHTUP ROUNDDOWN ROUNDUP ROW ROWS RSQ RTD
+  SEARCH SEARCHB SECOND SERIES SERIESSUM SIGN SIN SINH SKEW SLN SLOPE SMALL SQRT SQRTPI STANDARDIZE
+  STDEV STDEVA STDEVP STDEVPA STEYX SUBSTITUTE SUBTOTAL SUM SUMIF SUMIFS SUMPRODUCT SUMSQ SUMX2MY2
+  SUMX2PY2 SUMXMY2 SYD
+  T TAN TANH TBILLEQ TBILLPRICE TBILLYIELD TDIST TEXT THAIDAYOFWEEK THAIDIGIT THAIMONTHOFYEAR
+  THAINUMSOUND THAINUMSTRING THAISTRINGLENGTH THAIYEAR TIME TIMEVALUE TINV TODAY TRANSPOSE TREND TRIM
+  TRIMMEAN TRUNC TTEST TYPE
+  UPPER USDOLLAR
+  VALUE VAR VARA VARP VARPA VDB VLOOKUP
+  WEEKDAY WEEKNUM WEIBULL WORKDAY
+  XIRR XNPV
+  YEAR YEARFRAC YIELD YIELDDISC YIELDMAT
+  ZTEST
+`;
+export const NOT_VALUES = new Set([
+    'LAMBDA',
+    'LET',
+    'PYTHON_STR',
+    'PYTHON_TYPE',
+    'PYTHON_TYPENAME',
+    'QUERYSTRING',
+]);
+export const OLDER_FUNCTION_VALUES = OLDER_FUNCTIONS.trim().split(/\s+/);
+export const FUNCTION_VALUE_NAMES = new Set([
+    ...OLDER_FUNCTION_VALUES,
+    ...[...FUTURE_FUNCTION_PREFIXES.keys()].filter((name) => !NOT_VALUES.has(name)),
+]);

package/dist/core/future-functions.d.ts

@@ -0,0 +1,3 @@
+/** The prefix a future function carries on disk. */
+export type FutureFunctionPrefix = '_xlfn.' | '_xlfn._xlws.';
+export declare const FUTURE_FUNCTION_PREFIXES: ReadonlyMap<string, FutureFunctionPrefix>;

package/dist/core/{modern-functions.js → future-functions.js}

@@ -1,148 +1,179 @@
-export const MODERN_FUNCTIONS = new Set([
-    'FILTER',
-    'SORT',
-    'SORTBY',
-    'UNIQUE',
-    'SEQUENCE',
-    'RANDARRAY',
-    'XLOOKUP',
-    'XMATCH',
-    'LAMBDA',
-    'LET',
-    'BYROW',
-    'BYCOL',
-    'MAKEARRAY',
-    'MAP',
-    'REDUCE',
-    'SCAN',
-    'ISOMITTED',
-    'VSTACK',
-    'HSTACK',
-    'TOROW',
-    'TOCOL',
-    'WRAPROWS',
-    'WRAPCOLS',
-    'TAKE',
-    'DROP',
-    'EXPAND',
-    'CHOOSEROWS',
-    'CHOOSECOLS',
-    'TEXTJOIN',
-    'CONCAT',
-    'TEXTBEFORE',
-    'TEXTAFTER',
-    'TEXTSPLIT',
-    'ARRAYTOTEXT',
-    'VALUETOTEXT',
-    'IFS',
-    'SWITCH',
-    'MAXIFS',
-    'MINIFS',
-    'AGGREGATE',
+const WORKSHEET_ONLY_FUNCTIONS = ['FILTER', 'PY', 'SORT'];
+const SPECIFIED_FUNCTIONS = [
     'ACOT',
     'ACOTH',
-    'COT',
-    'COTH',
-    'CSC',
-    'CSCH',
-    'SEC',
-    'SECH',
+    'AGGREGATE',
     'ARABIC',
     'BASE',
-    'DECIMAL',
-    'COMBINA',
-    'PERMUTATIONA',
-    'GAMMA',
-    'GAUSS',
-    'PHI',
-    'MUNIT',
-    'BITAND',
-    'BITOR',
-    'BITXOR',
-    'BITLSHIFT',
-    'BITRSHIFT',
-    'IMCOSH',
-    'IMCOT',
-    'IMCSC',
-    'IMCSCH',
-    'IMSEC',
-    'IMSECH',
-    'IMSINH',
-    'IMTAN',
-    'DAYS',
-    'ISOWEEKNUM',
-    'IFNA',
-    'NUMBERVALUE',
-    'SHEET',
-    'SHEETS',
-    'FORMULATEXT',
-    'ISFORMULA',
-    'ENCODEURL',
-    'WEBSERVICE',
-    'FILTERXML',
-    'UNICHAR',
-    'UNICODE',
-    'XOR',
-    'PDURATION',
-    'RRI',
     'BETA.DIST',
     'BETA.INV',
     'BINOM.DIST',
     'BINOM.DIST.RANGE',
     'BINOM.INV',
+    'BITAND',
+    'BITLSHIFT',
+    'BITOR',
+    'BITRSHIFT',
+    'BITXOR',
+    'BYCOL',
+    'BYROW',
+    'CEILING.MATH',
+    'CEILING.PRECISE',
     'CHISQ.DIST',
     'CHISQ.DIST.RT',
     'CHISQ.INV',
     'CHISQ.INV.RT',
     'CHISQ.TEST',
+    'CHOOSECOLS',
+    'CHOOSEROWS',
+    'COMBINA',
+    'CONCAT',
     'CONFIDENCE.NORM',
     'CONFIDENCE.T',
+    'COT',
+    'COTH',
     'COVARIANCE.P',
     'COVARIANCE.S',
+    'CSC',
+    'CSCH',
+    'DAYS',
+    'DECIMAL',
+    'DROP',
+    'ERF.PRECISE',
+    'ERFC.PRECISE',
+    'EXPAND',
     'EXPON.DIST',
     'F.DIST',
     'F.DIST.RT',
     'F.INV',
     'F.INV.RT',
     'F.TEST',
+    'FIELDVALUE',
+    'FILTERXML',
+    'FLOOR.MATH',
+    'FLOOR.PRECISE',
+    'FORECAST.ETS',
+    'FORECAST.ETS.CONFINT',
+    'FORECAST.ETS.SEASONALITY',
+    'FORECAST.ETS.STAT',
+    'FORECAST.LINEAR',
+    'FORMULATEXT',
+    'GAMMA',
     'GAMMA.DIST',
     'GAMMA.INV',
     'GAMMALN.PRECISE',
+    'GAUSS',
+    'HSTACK',
     'HYPGEOM.DIST',
+    'IFNA',
+    'IFS',
+    'IMCOSH',
+    'IMCOT',
+    'IMCSC',
+    'IMCSCH',
+    'IMSEC',
+    'IMSECH',
+    'IMSINH',
+    'IMTAN',
+    'ISFORMULA',
+    'ISOMITTED',
+    'ISOWEEKNUM',
+    'LAMBDA',
+    'LET',
     'LOGNORM.DIST',
     'LOGNORM.INV',
+    'MAKEARRAY',
+    'MAP',
+    'MAXIFS',
+    'MINIFS',
     'MODE.MULT',
     'MODE.SNGL',
+    'MUNIT',
     'NEGBINOM.DIST',
     'NORM.DIST',
     'NORM.INV',
     'NORM.S.DIST',
     'NORM.S.INV',
+    'NUMBERVALUE',
+    'PDURATION',
     'PERCENTILE.EXC',
     'PERCENTILE.INC',
     'PERCENTRANK.EXC',
     'PERCENTRANK.INC',
+    'PERMUTATIONA',
+    'PHI',
     'POISSON.DIST',
+    'PQSOURCE',
+    'PYTHON_STR',
+    'PYTHON_TYPE',
+    'PYTHON_TYPENAME',
     'QUARTILE.EXC',
     'QUARTILE.INC',
+    'QUERYSTRING',
+    'RANDARRAY',
     'RANK.AVG',
     'RANK.EQ',
+    'REDUCE',
+    'RRI',
+    'SCAN',
+    'SEC',
+    'SECH',
+    'SEQUENCE',
+    'SHEET',
+    'SHEETS',
     'SKEW.P',
+    'SORTBY',
     'STDEV.P',
     'STDEV.S',
+    'SWITCH',
     'T.DIST',
     'T.DIST.2T',
     'T.DIST.RT',
     'T.INV',
     'T.INV.2T',
     'T.TEST',
+    'TAKE',
+    'TEXTAFTER',
+    'TEXTBEFORE',
+    'TEXTJOIN',
+    'TEXTSPLIT',
+    'TOCOL',
+    'TOROW',
+    'UNICHAR',
+    'UNICODE',
+    'UNIQUE',
     'VAR.P',
     'VAR.S',
+    'VSTACK',
+    'WEBSERVICE',
     'WEIBULL.DIST',
+    'WRAPCOLS',
+    'WRAPROWS',
+    'XLOOKUP',
+    'XOR',
     'Z.TEST',
-    'CEILING.PRECISE',
-    'FLOOR.PRECISE',
-    'ISO.CEILING',
-    'ERF.PRECISE',
-    'ERFC.PRECISE',
+];
+const OBSERVED_FUNCTIONS = [
+    'ANCHORARRAY',
+    'ARRAYTOTEXT',
+    'DETECTLANGUAGE',
+    'ENCODEURL',
+    'GROUPBY',
+    'IMAGE',
+    'PERCENTOF',
+    'PIVOTBY',
+    'REGEXEXTRACT',
+    'REGEXREPLACE',
+    'REGEXTEST',
+    'SINGLE',
+    'STOCKHISTORY',
+    'TRANSLATE',
+    'TRIMRANGE',
+    'VALUETOTEXT',
+    'XMATCH',
+];
+export const FUTURE_FUNCTION_PREFIXES = new Map([
+    ...WORKSHEET_ONLY_FUNCTIONS.map((name) => [name, '_xlfn._xlws.']),
+    ...SPECIFIED_FUNCTIONS.map((name) => [name, '_xlfn.']),
+    ...OBSERVED_FUNCTIONS.map((name) => [name, '_xlfn.']),
 ]);