xls-codec 1.0.1 → 2.0.0

package/dist/biff/ptg-functions.js

@@ -0,0 +1,381 @@
+//#region src/biff/ptg-functions.ts
+const FTAB_ENTRIES = [
+	[0, ["COUNT"]],
+	[1, ["IF"]],
+	[2, ["ISNA", 1]],
+	[3, ["ISERROR", 1]],
+	[4, ["SUM"]],
+	[5, ["AVERAGE"]],
+	[6, ["MIN"]],
+	[7, ["MAX"]],
+	[8, ["ROW"]],
+	[9, ["COLUMN"]],
+	[10, ["NA", 0]],
+	[11, ["NPV"]],
+	[12, ["STDEV"]],
+	[13, ["DOLLAR"]],
+	[14, ["FIXED"]],
+	[15, ["SIN", 1]],
+	[16, ["COS", 1]],
+	[17, ["TAN", 1]],
+	[18, ["ATAN", 1]],
+	[19, ["PI", 0]],
+	[20, ["SQRT", 1]],
+	[21, ["EXP", 1]],
+	[22, ["LN", 1]],
+	[23, ["LOG10", 1]],
+	[24, ["ABS", 1]],
+	[25, ["INT", 1]],
+	[26, ["SIGN", 1]],
+	[27, ["ROUND", 2]],
+	[28, ["LOOKUP"]],
+	[29, ["INDEX"]],
+	[30, ["REPT", 2]],
+	[31, ["MID", 3]],
+	[32, ["LEN", 1]],
+	[33, ["VALUE", 1]],
+	[34, ["TRUE", 0]],
+	[35, ["FALSE", 0]],
+	[36, ["AND"]],
+	[37, ["OR"]],
+	[38, ["NOT", 1]],
+	[39, ["MOD", 2]],
+	[40, ["DCOUNT", 3]],
+	[41, ["DSUM", 3]],
+	[42, ["DAVERAGE", 3]],
+	[43, ["DMIN", 3]],
+	[44, ["DMAX", 3]],
+	[45, ["DSTDEV", 3]],
+	[46, ["VAR"]],
+	[47, ["DVAR", 3]],
+	[48, ["TEXT", 2]],
+	[49, ["LINEST"]],
+	[50, ["TREND"]],
+	[51, ["LOGEST"]],
+	[52, ["GROWTH"]],
+	[53, ["GOTO", 1]],
+	[54, ["HALT"]],
+	[55, ["RETURN"]],
+	[56, ["PV"]],
+	[57, ["FV"]],
+	[58, ["NPER"]],
+	[59, ["PMT"]],
+	[60, ["RATE"]],
+	[61, ["MIRR", 3]],
+	[62, ["IRR"]],
+	[63, ["RAND", 0]],
+	[64, ["MATCH"]],
+	[65, ["DATE", 3]],
+	[66, ["TIME", 3]],
+	[67, ["DAY", 1]],
+	[68, ["MONTH", 1]],
+	[69, ["YEAR", 1]],
+	[70, ["WEEKDAY"]],
+	[71, ["HOUR", 1]],
+	[72, ["MINUTE", 1]],
+	[73, ["SECOND", 1]],
+	[74, ["NOW", 0]],
+	[75, ["AREAS", 1]],
+	[76, ["ROWS", 1]],
+	[77, ["COLUMNS", 1]],
+	[78, ["OFFSET"]],
+	[79, ["ABSREF", 2]],
+	[80, ["RELREF", 2]],
+	[81, ["ARGUMENT"]],
+	[82, ["SEARCH"]],
+	[83, ["TRANSPOSE", 1]],
+	[84, ["ERROR"]],
+	[85, ["STEP", 0]],
+	[86, ["TYPE", 1]],
+	[87, ["ECHO"]],
+	[88, ["SET.NAME"]],
+	[89, ["CALLER", 0]],
+	[90, ["DEREF", 1]],
+	[91, ["WINDOWS"]],
+	[92, ["SERIES"]],
+	[93, ["DOCUMENTS"]],
+	[94, ["ACTIVE.CELL", 0]],
+	[95, ["SELECTION", 0]],
+	[96, ["RESULT"]],
+	[97, ["ATAN2", 2]],
+	[98, ["ASIN", 1]],
+	[99, ["ACOS", 1]],
+	[100, ["CHOOSE"]],
+	[101, ["HLOOKUP"]],
+	[102, ["VLOOKUP"]],
+	[103, ["LINKS"]],
+	[104, ["INPUT"]],
+	[105, ["ISREF", 1]],
+	[106, ["GET.FORMULA", 1]],
+	[107, ["GET.NAME"]],
+	[108, ["SET.VALUE", 2]],
+	[109, ["LOG"]],
+	[110, ["EXEC"]],
+	[111, ["CHAR", 1]],
+	[112, ["LOWER", 1]],
+	[113, ["UPPER", 1]],
+	[114, ["PROPER", 1]],
+	[115, ["LEFT"]],
+	[116, ["RIGHT"]],
+	[117, ["EXACT", 2]],
+	[118, ["TRIM", 1]],
+	[119, ["REPLACE", 4]],
+	[120, ["SUBSTITUTE"]],
+	[121, ["CODE", 1]],
+	[122, ["NAMES"]],
+	[123, ["DIRECTORY"]],
+	[124, ["FIND"]],
+	[125, ["CELL"]],
+	[126, ["ISERR", 1]],
+	[127, ["ISTEXT", 1]],
+	[128, ["ISNUMBER", 1]],
+	[129, ["ISBLANK", 1]],
+	[130, ["T", 1]],
+	[131, ["N", 1]],
+	[132, ["FOPEN"]],
+	[133, ["FCLOSE", 1]],
+	[134, ["FSIZE", 1]],
+	[135, ["FREADLN", 1]],
+	[136, ["FREAD", 2]],
+	[137, ["FWRITELN", 2]],
+	[138, ["FWRITE", 2]],
+	[139, ["FPOS"]],
+	[140, ["DATEVALUE", 1]],
+	[141, ["TIMEVALUE", 1]],
+	[142, ["SLN", 3]],
+	[143, ["SYD", 4]],
+	[144, ["DDB"]],
+	[145, ["GET.DEF"]],
+	[146, ["REFTEXT"]],
+	[147, ["TEXTREF"]],
+	[148, ["INDIRECT"]],
+	[149, ["REGISTER"]],
+	[150, ["CALL"]],
+	[151, ["ADD.BAR"]],
+	[152, ["ADD.MENU"]],
+	[153, ["ADD.COMMAND"]],
+	[154, ["ENABLE.COMMAND"]],
+	[155, ["CHECK.COMMAND"]],
+	[156, ["RENAME.COMMAND"]],
+	[157, ["SHOW.BAR"]],
+	[158, ["DELETE.MENU"]],
+	[159, ["DELETE.COMMAND"]],
+	[160, ["GET.CHART.ITEM"]],
+	[161, ["DIALOG.BOX", 1]],
+	[162, ["CLEAN", 1]],
+	[163, ["MDETERM", 1]],
+	[164, ["MINVERSE", 1]],
+	[165, ["MMULT", 2]],
+	[166, ["FILES"]],
+	[167, ["IPMT"]],
+	[168, ["PPMT"]],
+	[169, ["COUNTA"]],
+	[170, ["CANCEL.KEY"]],
+	[171, ["FOR"]],
+	[172, ["WHILE", 1]],
+	[173, ["BREAK", 0]],
+	[174, ["NEXT", 0]],
+	[175, ["INITIATE", 2]],
+	[176, ["REQUEST", 2]],
+	[177, ["POKE", 3]],
+	[178, ["EXECUTE", 2]],
+	[179, ["TERMINATE", 1]],
+	[180, ["RESTART"]],
+	[181, ["HELP"]],
+	[182, ["GET.BAR"]],
+	[183, ["PRODUCT"]],
+	[184, ["FACT", 1]],
+	[185, ["GET.CELL"]],
+	[186, ["GET.WORKSPACE", 1]],
+	[187, ["GET.WINDOW"]],
+	[188, ["GET.DOCUMENT"]],
+	[189, ["DPRODUCT", 3]],
+	[190, ["ISNONTEXT", 1]],
+	[191, ["GET.NOTE"]],
+	[192, ["NOTE"]],
+	[193, ["STDEVP"]],
+	[194, ["VARP"]],
+	[195, ["DSTDEVP", 3]],
+	[196, ["DVARP", 3]],
+	[197, ["TRUNC"]],
+	[198, ["ISLOGICAL", 1]],
+	[199, ["DCOUNTA", 3]],
+	[200, ["DELETE.BAR", 1]],
+	[201, ["UNREGISTER", 1]],
+	[204, ["USDOLLAR"]],
+	[205, ["FINDB"]],
+	[206, ["SEARCHB"]],
+	[207, ["REPLACEB", 4]],
+	[208, ["LEFTB"]],
+	[209, ["RIGHTB"]],
+	[210, ["MIDB", 3]],
+	[211, ["LENB", 1]],
+	[212, ["ROUNDUP", 2]],
+	[213, ["ROUNDDOWN", 2]],
+	[214, ["ASC", 1]],
+	[215, ["DBCS", 1]],
+	[216, ["RANK"]],
+	[219, ["ADDRESS"]],
+	[220, ["DAYS360"]],
+	[221, ["TODAY", 0]],
+	[222, ["VDB"]],
+	[223, ["ELSE", 0]],
+	[224, ["ELSE.IF", 1]],
+	[225, ["END.IF", 0]],
+	[226, ["FOR.CELL"]],
+	[227, ["MEDIAN"]],
+	[228, ["SUMPRODUCT"]],
+	[229, ["SINH", 1]],
+	[230, ["COSH", 1]],
+	[231, ["TANH", 1]],
+	[232, ["ASINH", 1]],
+	[233, ["ACOSH", 1]],
+	[234, ["ATANH", 1]],
+	[235, ["DGET", 3]],
+	[236, ["CREATE.OBJECT"]],
+	[237, ["VOLATILE"]],
+	[238, ["LAST.ERROR", 0]],
+	[239, ["CUSTOM.UNDO"]],
+	[240, ["CUSTOM.REPEAT"]],
+	[241, ["FORMULA.CONVERT"]],
+	[242, ["GET.LINK.INFO"]],
+	[243, ["TEXT.BOX"]],
+	[244, ["INFO", 1]],
+	[245, ["GROUP", 0]],
+	[246, ["GET.OBJECT"]],
+	[247, ["DB"]],
+	[248, ["PAUSE"]],
+	[251, ["RESUME"]],
+	[252, ["FREQUENCY", 2]],
+	[253, ["ADD.TOOLBAR"]],
+	[254, ["DELETE.TOOLBAR", 1]],
+	[256, ["RESET.TOOLBAR", 1]],
+	[257, ["EVALUATE", 1]],
+	[258, ["GET.TOOLBAR"]],
+	[259, ["GET.TOOL"]],
+	[260, ["SPELLING.CHECK"]],
+	[261, ["ERROR.TYPE", 1]],
+	[262, ["APP.TITLE"]],
+	[263, ["WINDOW.TITLE"]],
+	[264, ["SAVE.TOOLBAR"]],
+	[265, ["ENABLE.TOOL", 3]],
+	[266, ["PRESS.TOOL", 3]],
+	[267, ["REGISTER.ID"]],
+	[268, ["GET.WORKBOOK"]],
+	[269, ["AVEDEV"]],
+	[270, ["BETADIST"]],
+	[271, ["GAMMALN", 1]],
+	[272, ["BETAINV"]],
+	[273, ["BINOMDIST", 4]],
+	[274, ["CHIDIST", 2]],
+	[275, ["CHIINV", 2]],
+	[276, ["COMBIN", 2]],
+	[277, ["CONFIDENCE", 3]],
+	[278, ["CRITBINOM", 3]],
+	[279, ["EVEN", 1]],
+	[280, ["EXPONDIST", 3]],
+	[281, ["FDIST", 3]],
+	[282, ["FINV", 3]],
+	[283, ["FISHER", 1]],
+	[284, ["FISHERINV", 1]],
+	[285, ["FLOOR", 2]],
+	[286, ["GAMMADIST", 4]],
+	[287, ["GAMMAINV", 3]],
+	[288, ["CEILING", 2]],
+	[289, ["HYPGEOMDIST", 4]],
+	[290, ["LOGNORMDIST", 3]],
+	[291, ["LOGINV", 3]],
+	[292, ["NEGBINOMDIST", 3]],
+	[293, ["NORMDIST", 4]],
+	[294, ["NORMSDIST", 1]],
+	[295, ["NORMINV", 3]],
+	[296, ["NORMSINV", 1]],
+	[297, ["STANDARDIZE", 3]],
+	[298, ["ODD", 1]],
+	[299, ["PERMUT", 2]],
+	[300, ["POISSON", 3]],
+	[301, ["TDIST", 3]],
+	[302, ["WEIBULL", 4]],
+	[303, ["SUMXMY2", 2]],
+	[304, ["SUMX2MY2", 2]],
+	[305, ["SUMX2PY2", 2]],
+	[306, ["CHITEST", 2]],
+	[307, ["CORREL", 2]],
+	[308, ["COVAR", 2]],
+	[309, ["FORECAST", 3]],
+	[310, ["FTEST", 2]],
+	[311, ["INTERCEPT", 2]],
+	[312, ["PEARSON", 2]],
+	[313, ["RSQ", 2]],
+	[314, ["STEYX", 2]],
+	[315, ["SLOPE", 2]],
+	[316, ["TTEST", 4]],
+	[317, ["PROB"]],
+	[318, ["DEVSQ"]],
+	[319, ["GEOMEAN"]],
+	[320, ["HARMEAN"]],
+	[321, ["SUMSQ"]],
+	[322, ["KURT"]],
+	[323, ["SKEW"]],
+	[324, ["ZTEST"]],
+	[325, ["LARGE", 2]],
+	[326, ["SMALL", 2]],
+	[327, ["QUARTILE", 2]],
+	[328, ["PERCENTILE", 2]],
+	[329, ["PERCENTRANK"]],
+	[330, ["MODE"]],
+	[331, ["TRIMMEAN", 2]],
+	[332, ["TINV", 2]],
+	[334, ["MOVIE.COMMAND"]],
+	[335, ["GET.MOVIE"]],
+	[336, ["CONCATENATE"]],
+	[337, ["POWER", 2]],
+	[338, ["PIVOT.ADD.DATA"]],
+	[339, ["GET.PIVOT.TABLE"]],
+	[340, ["GET.PIVOT.FIELD"]],
+	[341, ["GET.PIVOT.ITEM"]],
+	[342, ["RADIANS", 1]],
+	[343, ["DEGREES", 1]],
+	[344, ["SUBTOTAL"]],
+	[345, ["SUMIF"]],
+	[346, ["COUNTIF", 2]],
+	[347, ["COUNTBLANK", 1]],
+	[348, ["SCENARIO.GET"]],
+	[349, ["OPTIONS.LISTS.GET", 1]],
+	[350, ["ISPMT", 4]],
+	[351, ["DATEDIF", 3]],
+	[352, ["DATESTRING", 1]],
+	[353, ["NUMBERSTRING", 2]],
+	[354, ["ROMAN"]],
+	[355, ["OPEN.DIALOG"]],
+	[356, ["SAVE.DIALOG"]],
+	[357, ["VIEW.GET"]],
+	[358, ["GETPIVOTDATA"]],
+	[359, ["HYPERLINK"]],
+	[360, ["PHONETIC", 1]],
+	[361, ["AVERAGEA"]],
+	[362, ["MAXA"]],
+	[363, ["MINA"]],
+	[364, ["STDEVPA"]],
+	[365, ["VARPA"]],
+	[366, ["STDEVA"]],
+	[367, ["VARA"]],
+	[368, ["BAHTTEXT", 1]],
+	[369, ["THAIDAYOFWEEK", 1]],
+	[370, ["THAIDIGIT", 1]],
+	[371, ["THAIMONTHOFYEAR", 1]],
+	[372, ["THAINUMSOUND", 1]],
+	[373, ["THAINUMSTRING", 1]],
+	[374, ["THAISTRINGLENGTH", 1]],
+	[375, ["ISTHAIDIGIT", 1]],
+	[376, ["ROUNDBAHTDOWN", 1]],
+	[377, ["ROUNDBAHTUP", 1]],
+	[378, ["THAIYEAR", 1]],
+	[379, ["RTD"]]
+];
+/** A function's displayed name, by its Ftab index -- consulted for both PtgFunc and PtgFuncVar. */
+const FTAB_NAMES = new Map(FTAB_ENTRIES.map(([iftab, [name]]) => [iftab, name]));
+/** A function's fixed argument count, by its Ftab index -- consulted only for PtgFunc, whose own token carries no count. Absent for every entry [MS-XLS]'s grammar gives an optional or repeated argument, which is never resolved through PtgFunc in practice (see the module comment). */
+const FTAB_FIXED_ARITY = new Map(FTAB_ENTRIES.filter((entry) => entry[1][1] !== void 0).map(([iftab, [, arity]]) => [iftab, arity]));
+//#endregion
+export { FTAB_FIXED_ARITY, FTAB_NAMES };

package/dist/biff/ptg.cjs

@@ -0,0 +1,319 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_biff_cursor = require("./cursor.cjs");
+const require_biff_strings = require("./strings.cjs");
+const require_biff_errors = require("./errors.cjs");
+const require_biff_ptg_functions = require("./ptg-functions.cjs");
+let document_schema_js = require("document-schema.js");
+//#region src/biff/ptg.ts
+const PRECEDENCE_COMPARISON = 1;
+const PRECEDENCE_CONCAT = 2;
+const PRECEDENCE_ADD_SUB = 3;
+const PRECEDENCE_MUL_DIV = 4;
+const PRECEDENCE_POWER = 5;
+const PRECEDENCE_PERCENT = 6;
+const PRECEDENCE_UNARY = 7;
+const PRECEDENCE_ATOMIC = 8;
+function pushAtomic(stack, text) {
+	stack.push({
+		text,
+		precedence: PRECEDENCE_ATOMIC
+	});
+}
+function wrapBelow(operand, minimum) {
+	return operand.precedence < minimum ? `(${operand.text})` : operand.text;
+}
+function wrapAtOrBelow(operand, minimum) {
+	return operand.precedence <= minimum ? `(${operand.text})` : operand.text;
+}
+/** Pops two operands and pushes their combination -- the left wrapped only if its own precedence is strictly lower than this operator's, the right wrapped if its precedence is lower than or equal to it (see the module comment for why the same rule is correct for every operator here). Returns false, changing nothing, when fewer than two operands are on the stack -- a malformed token stream this reader declines to guess at rather than reading past. */
+function applyBinary(stack, symbol, precedence) {
+	const right = stack.pop();
+	const left = stack.pop();
+	if (left === void 0 || right === void 0) return false;
+	stack.push({
+		text: `${wrapBelow(left, precedence)}${symbol}${wrapAtOrBelow(right, precedence)}`,
+		precedence
+	});
+	return true;
+}
+function applyPrefix(stack, symbol) {
+	const operand = stack.pop();
+	if (operand === void 0) return false;
+	stack.push({
+		text: `${symbol}${wrapBelow(operand, PRECEDENCE_UNARY)}`,
+		precedence: PRECEDENCE_UNARY
+	});
+	return true;
+}
+function applyPercent(stack) {
+	const operand = stack.pop();
+	if (operand === void 0) return false;
+	stack.push({
+		text: `${wrapBelow(operand, PRECEDENCE_PERCENT)}%`,
+		precedence: PRECEDENCE_PERCENT
+	});
+	return true;
+}
+/** PtgParen ([MS-XLS] 2.5.198.80): a pure display token restating parentheses the formula's own author typed, regardless of whether the grouping they express is otherwise necessary. Wrapped unconditionally rather than through precedence comparison, since the point is to reproduce exactly what was there, not to decide afresh whether it was needed. */
+function applyParen(stack) {
+	const operand = stack.pop();
+	if (operand === void 0) return false;
+	stack.push({
+		text: `(${operand.text})`,
+		precedence: PRECEDENCE_ATOMIC
+	});
+	return true;
+}
+/** Pops exactly `arity` operands (in argument order) and pushes `name(arg1,arg2,...)`. A function call's own arguments never need wrapping regardless of what built them -- the parentheses already bound them unambiguously -- so every argument is taken as its bare text. */
+function applyFunctionCall(stack, name, arity) {
+	if (stack.length < arity) return false;
+	const args = stack.splice(stack.length - arity, arity);
+	stack.push({
+		text: `${name}(${args.map((operand) => operand.text).join(",")})`,
+		precedence: PRECEDENCE_ATOMIC
+	});
+	return true;
+}
+/** PtgAttrSum ([MS-XLS] 2.5.198.41): the optimisation a real producer emits in place of a PtgFuncVar call to SUM with a single reference-class argument, wrapping whatever is already on top of the stack. */
+function applySum(stack) {
+	return applyFunctionCall(stack, "SUM", 1);
+}
+function quoteStringLiteral(value) {
+	return `"${value.replaceAll("\"", "\"\"")}"`;
+}
+const COLUMN_INDEX_MASK = 16383;
+const COLUMN_RELATIVE_BIT = 16384;
+const ROW_RELATIVE_BIT = 32768;
+function pointFrom(row, columnField) {
+	return {
+		row,
+		column: columnField & COLUMN_INDEX_MASK,
+		columnAbsolute: (columnField & COLUMN_RELATIVE_BIT) === 0,
+		rowAbsolute: (columnField & ROW_RELATIVE_BIT) === 0
+	};
+}
+function formatPoint(point) {
+	return `${`${point.columnAbsolute ? "$" : ""}${(0, document_schema_js.columnIndexToLetters)(point.column)}`}${`${point.rowAbsolute ? "$" : ""}${point.row + 1}`}`;
+}
+/** RgceLoc ([MS-XLS] 2.5.198.109): a single cell reference, as PtgRef/PtgRef3d carry it -- a plain row then a ColRelU column field. */
+function readLoc(cursor) {
+	return pointFrom(cursor.u16(), cursor.u16());
+}
+/** RgceArea ([MS-XLS] 2.5.198.105): a rectangular range, as PtgArea/PtgArea3d carry it -- both row bounds, then both corners' own ColRelU column fields. */
+function readArea(cursor) {
+	const rowFirst = cursor.u16();
+	const rowLast = cursor.u16();
+	const columnFirstField = cursor.u16();
+	const columnLastField = cursor.u16();
+	return [pointFrom(rowFirst, columnFirstField), pointFrom(rowLast, columnLastField)];
+}
+const SIMPLE_SHEET_NAME_RE = /^[A-Za-z_][A-Za-z0-9_.]*$/;
+function quoteSheetLabel(label) {
+	return SIMPLE_SHEET_NAME_RE.test(label) ? label : `'${label.replaceAll("'", "''")}'`;
+}
+/** The `'Sheet'!` or `'First:Last'!` prefix a 3D reference's own ixti resolves to, or undefined when this reader does not resolve it (see WorkbookGlobals.sheetRanges) -- an unresolved ixti aborts the whole formula's parse, the same as any other unsupported token. */
+function resolveSheetLabel(ixti, context) {
+	const range = context.sheetRanges[ixti];
+	if (range === void 0) return;
+	const first = context.sheets[range.firstSheetIndex]?.name;
+	const last = context.sheets[range.lastSheetIndex]?.name;
+	if (first === void 0 || last === void 0) return;
+	return `${quoteSheetLabel(range.firstSheetIndex === range.lastSheetIndex ? first : `${first}:${last}`)}!`;
+}
+const PTG_ADD = 3;
+const PTG_SUB = 4;
+const PTG_MUL = 5;
+const PTG_DIV = 6;
+const PTG_POWER = 7;
+const PTG_CONCAT = 8;
+const PTG_LT = 9;
+const PTG_LE = 10;
+const PTG_EQ = 11;
+const PTG_GE = 12;
+const PTG_GT = 13;
+const PTG_NE = 14;
+const PTG_UPLUS = 18;
+const PTG_UMINUS = 19;
+const PTG_PERCENT = 20;
+const PTG_PAREN = 21;
+const PTG_MISSARG = 22;
+const PTG_STR = 23;
+const PTG_ERR = 28;
+const PTG_BOOL = 29;
+const PTG_INT = 30;
+const PTG_NUM = 31;
+const PTG_FUNC_REF = 33;
+const PTG_FUNC_VALUE = 65;
+const PTG_FUNC_ARRAY = 97;
+const PTG_FUNCVAR_REF = 34;
+const PTG_FUNCVAR_VALUE = 66;
+const PTG_FUNCVAR_ARRAY = 98;
+const PTG_REF_REF = 36;
+const PTG_REF_VALUE = 68;
+const PTG_REF_ARRAY = 100;
+const PTG_AREA_REF = 37;
+const PTG_AREA_VALUE = 69;
+const PTG_AREA_ARRAY = 101;
+const PTG_REF3D_REF = 58;
+const PTG_REF3D_VALUE = 90;
+const PTG_REF3D_ARRAY = 122;
+const PTG_AREA3D_REF = 59;
+const PTG_AREA3D_VALUE = 91;
+const PTG_AREA3D_ARRAY = 123;
+const PTG_ATTR_OPCODE = 25;
+const PTG_ATTR_SEMI = 1;
+const PTG_ATTR_IF = 2;
+const PTG_ATTR_CHOOSE = 4;
+const PTG_ATTR_GOTO = 8;
+const PTG_ATTR_SUM = 16;
+const PTG_ATTR_BAXCEL_A = 32;
+const PTG_ATTR_BAXCEL_B = 33;
+const PTG_ATTR_SPACE = 64;
+const PTG_ATTR_SPACE_SEMI = 65;
+/** The four bytes every PtgAttr subtype but PtgAttrChoose occupies: the shared opcode, the subtype flag byte (already consumed by the caller), and two more this module never inspects. */
+const PTG_ATTR_TRAILING_BYTES = 2;
+/**
+* Parses a Formula record's compiled expression into the text a spreadsheet application would show, or returns undefined for a token this reader does not resolve -- a shared formula's PtgExp, an array constant's PtgArray, a defined name, a natural-language reference, or a 3D reference into a genuinely external workbook (see the module comment for the full list). The caller leaves ContentSheetCell.formula absent in that case, exactly as for any other unsupported construct.
+*
+* `rgce` is the formula's own token bytes, already sliced to their declared length (CellParsedFormula.cce) by the caller -- this function reads exactly that many bytes and nothing past them.
+*/
+function parseFormulaText(rgce, context) {
+	const cursor = new require_biff_cursor.BlockCursor([rgce]);
+	const stack = [];
+	while (cursor.remainingInBlock() > 0) switch (cursor.u8()) {
+		case PTG_ADD:
+			if (!applyBinary(stack, "+", PRECEDENCE_ADD_SUB)) return void 0;
+			break;
+		case PTG_SUB:
+			if (!applyBinary(stack, "-", PRECEDENCE_ADD_SUB)) return void 0;
+			break;
+		case PTG_MUL:
+			if (!applyBinary(stack, "*", PRECEDENCE_MUL_DIV)) return void 0;
+			break;
+		case PTG_DIV:
+			if (!applyBinary(stack, "/", PRECEDENCE_MUL_DIV)) return void 0;
+			break;
+		case PTG_POWER:
+			if (!applyBinary(stack, "^", PRECEDENCE_POWER)) return void 0;
+			break;
+		case PTG_CONCAT:
+			if (!applyBinary(stack, "&", PRECEDENCE_CONCAT)) return void 0;
+			break;
+		case PTG_LT:
+			if (!applyBinary(stack, "<", PRECEDENCE_COMPARISON)) return void 0;
+			break;
+		case PTG_LE:
+			if (!applyBinary(stack, "<=", PRECEDENCE_COMPARISON)) return void 0;
+			break;
+		case PTG_EQ:
+			if (!applyBinary(stack, "=", PRECEDENCE_COMPARISON)) return void 0;
+			break;
+		case PTG_GE:
+			if (!applyBinary(stack, ">=", PRECEDENCE_COMPARISON)) return void 0;
+			break;
+		case PTG_GT:
+			if (!applyBinary(stack, ">", PRECEDENCE_COMPARISON)) return void 0;
+			break;
+		case PTG_NE:
+			if (!applyBinary(stack, "<>", PRECEDENCE_COMPARISON)) return void 0;
+			break;
+		case PTG_UPLUS:
+			if (!applyPrefix(stack, "+")) return void 0;
+			break;
+		case PTG_UMINUS:
+			if (!applyPrefix(stack, "-")) return void 0;
+			break;
+		case PTG_PERCENT:
+			if (!applyPercent(stack)) return void 0;
+			break;
+		case PTG_PAREN:
+			if (!applyParen(stack)) return void 0;
+			break;
+		case PTG_MISSARG:
+			pushAtomic(stack, "");
+			break;
+		case PTG_STR:
+			pushAtomic(stack, quoteStringLiteral(require_biff_strings.readShortXLUnicodeString(cursor)));
+			break;
+		case PTG_ERR: {
+			const text = require_biff_errors.errorTextOf(cursor.u8());
+			if (text === void 0) return void 0;
+			pushAtomic(stack, text);
+			break;
+		}
+		case PTG_BOOL:
+			pushAtomic(stack, cursor.u8() !== 0 ? "TRUE" : "FALSE");
+			break;
+		case PTG_INT:
+			pushAtomic(stack, String(cursor.u16()));
+			break;
+		case PTG_NUM:
+			pushAtomic(stack, String(cursor.f64()));
+			break;
+		case PTG_REF_REF:
+		case PTG_REF_VALUE:
+		case PTG_REF_ARRAY:
+			pushAtomic(stack, formatPoint(readLoc(cursor)));
+			break;
+		case PTG_AREA_REF:
+		case PTG_AREA_VALUE:
+		case PTG_AREA_ARRAY: {
+			const [start, end] = readArea(cursor);
+			pushAtomic(stack, `${formatPoint(start)}:${formatPoint(end)}`);
+			break;
+		}
+		case PTG_REF3D_REF:
+		case PTG_REF3D_VALUE:
+		case PTG_REF3D_ARRAY: {
+			const ixti = cursor.u16();
+			const point = readLoc(cursor);
+			const label = resolveSheetLabel(ixti, context);
+			if (label === void 0) return void 0;
+			pushAtomic(stack, `${label}${formatPoint(point)}`);
+			break;
+		}
+		case PTG_AREA3D_REF:
+		case PTG_AREA3D_VALUE:
+		case PTG_AREA3D_ARRAY: {
+			const ixti = cursor.u16();
+			const [start, end] = readArea(cursor);
+			const label = resolveSheetLabel(ixti, context);
+			if (label === void 0) return void 0;
+			pushAtomic(stack, `${label}${formatPoint(start)}:${formatPoint(end)}`);
+			break;
+		}
+		case PTG_FUNC_REF:
+		case PTG_FUNC_VALUE:
+		case PTG_FUNC_ARRAY: {
+			const iftab = cursor.u16();
+			const name = require_biff_ptg_functions.FTAB_NAMES.get(iftab);
+			const arity = require_biff_ptg_functions.FTAB_FIXED_ARITY.get(iftab);
+			if (name === void 0 || arity === void 0) return void 0;
+			if (!applyFunctionCall(stack, name, arity)) return void 0;
+			break;
+		}
+		case PTG_FUNCVAR_REF:
+		case PTG_FUNCVAR_VALUE:
+		case PTG_FUNCVAR_ARRAY: {
+			const cparams = cursor.u8();
+			const iftab = cursor.u16();
+			const name = require_biff_ptg_functions.FTAB_NAMES.get(iftab);
+			if (name === void 0) return void 0;
+			if (!applyFunctionCall(stack, name, cparams)) return void 0;
+			break;
+		}
+		case PTG_ATTR_OPCODE: {
+			const subtype = cursor.u8();
+			if (subtype === PTG_ATTR_CHOOSE) return;
+			cursor.skip(PTG_ATTR_TRAILING_BYTES);
+			if (subtype === PTG_ATTR_SUM) {
+				if (!applySum(stack)) return void 0;
+			} else if (subtype !== PTG_ATTR_SEMI && subtype !== PTG_ATTR_IF && subtype !== PTG_ATTR_GOTO && subtype !== PTG_ATTR_BAXCEL_A && subtype !== PTG_ATTR_BAXCEL_B && subtype !== PTG_ATTR_SPACE && subtype !== PTG_ATTR_SPACE_SEMI) return;
+			break;
+		}
+		default: return;
+	}
+	return stack.length === 1 ? stack[0]?.text : void 0;
+}
+//#endregion
+exports.parseFormulaText = parseFormulaText;

package/dist/biff/ptg.d.cts

@@ -0,0 +1,2 @@
+import { n as SheetRange, r as parseFormulaText, t as FormulaSheetContext } from "../ptg-B2K8t3js.cjs";
+export { FormulaSheetContext, SheetRange, parseFormulaText };

package/dist/biff/ptg.d.ts

@@ -0,0 +1,2 @@
+import { n as SheetRange, r as parseFormulaText, t as FormulaSheetContext } from "../ptg-B2K8t3js.js";
+export { FormulaSheetContext, SheetRange, parseFormulaText };