@rowsncolumns/fast-formula-parser 6.2.33 → 6.2.35

package/dist/esm/index.js

@@ -3219,12 +3219,15 @@ const IndexedColors = Object.freeze([
 
 const isSingleSectionElapsedTimePattern = (pattern) => !pattern.includes(";") &&
     /\[(?:h+|m+|s+)\]/i.test(pattern.replace(/\[\$[^\]]+\]/g, ""));
+const localeForPattern = (pattern, locale) => {
+    return locale;
+};
 const ssfFormat = (pattern, value, locale) => {
     try {
         const isNegativeElapsedTime = typeof value === "number" &&
             value < 0 &&
             isSingleSectionElapsedTimePattern(pattern);
-        const formatted = format(pattern, isNegativeElapsedTime ? Math.abs(value) : value, { locale });
+        const formatted = format(pattern, isNegativeElapsedTime ? Math.abs(value) : value, { locale: localeForPattern(pattern, locale) });
         return isNegativeElapsedTime ? `-${formatted}` : formatted;
     }
     catch (err) {
@@ -41820,7 +41823,19 @@ const allTokens = [
 
 const SelectLexer = new Lexer(allTokens, { ensureOptimizations: true });
 
-allTokens.forEach((tokenType) => {
+// Catch-all for characters no other token matches. Spelled out as a code-unit
+// range because Chevrotain's first-char optimisation mis-analyses `[\s\S]`
+// (it never matches) and refuses to optimise the complement set `[^]`.
+const UnknownChar = createToken({
+  name: "UnknownChar",
+  pattern: /[\u0000-\uFFFF]/,
+});
+
+const tolerantTokens = [...allTokens, UnknownChar];
+
+const TolerantLexer = new Lexer(tolerantTokens, { ensureOptimizations: true });
+
+tolerantTokens.forEach((tokenType) => {
   tokenVocabulary$1[tokenType.name] = tokenType;
 });
 
@@ -41848,11 +41863,29 @@ function lex(inputText) {
 /**
  * Tolerant lexer that returns partial tokens even when errors occur.
  * Useful for incomplete formulas (e.g., '=SUM(') without throwing.
+ *
+ * Every character the formula grammar has no token for (e.g. a bare `\`)
+ * is lexed as an `UnknownChar` token instead of being dropped by Chevrotain's
+ * error recovery, which never advances its column counter over the dropped
+ * characters. Unknown characters stay in `tokens` as first-class tokens with
+ * native positions and are additionally reported in `errors` (Chevrotain's
+ * `ILexingError` shape) so callers can still detect them.
  */
 function tolerantLex(inputText) {
-  const lexingResult = SelectLexer.tokenize(inputText);
-  // Do not throw on errors; callers can inspect lexingResult.errors if needed.
-  return lexingResult;
+  const lexingResult = TolerantLexer.tokenize(inputText);
+  const errors = [];
+  for (const token of lexingResult.tokens) {
+    if (token.tokenType === UnknownChar) {
+      errors.push({
+        offset: token.startOffset,
+        line: token.startLine,
+        column: token.startColumn,
+        length: 1,
+        message: `unexpected character: ->${token.image}<- at offset: ${token.startOffset}, skipped 1 characters.`,
+      });
+    }
+  }
+  return { tokens: lexingResult.tokens, groups: lexingResult.groups, errors };
 }
 
 const tokenVocabulary = tokenVocabulary$1;
@@ -45495,6 +45528,17 @@ class DepParser {
     if (fnName === "OFFSET") {
       return this.handleOffset(args);
     }
+    // ADDRESS is pure and is the idiomatic way to build INDIRECT's
+    // target. Folding it here lets handleIndirect register the real
+    // precedent edge (`INDIRECT(ADDRESS(1,3,1,1,"Source"))` →
+    // Source!$C$1), so the calc engine orders the INDIRECT cell after
+    // the chain it reads instead of evaluating it against stale values.
+    if (fnName === "ADDRESS") {
+      const folded = this.foldAddress(args);
+      if (folded !== undefined) {
+        return { value: folded };
+      }
+    }
     // Phase 7 LAMBDA: __RNC_LAMBDA__("params", "body") is the
     // preprocessor's runtime lambda constructor. The body is a string
     // literal that may contain cell refs — recurse the dep parser on
@@ -45561,6 +45605,31 @@ class DepParser {
     }
   }
 
+  /**
+   * Evaluate ADDRESS(...) when every argument is a literal scalar.
+   * Returns undefined when an argument is a reference or another
+   * function's placeholder result (the dep parser does not evaluate
+   * those), or when ADDRESS itself would error.
+   */
+  foldAddress(args = []) {
+    if (!args.length || args.length > 5) return undefined;
+    const scalars = [];
+    for (const arg of args) {
+      if (arg == null) {
+        scalars.push(undefined);
+        continue;
+      }
+      if (typeof arg === "object") return undefined;
+      scalars.push(arg);
+    }
+    try {
+      const address = ReferenceFunctions.ADDRESS(...scalars);
+      return typeof address === "string" ? address : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
   handleIndirect(args = []) {
     const refText = this.extractScalar(args[0]);
     if (typeof refText !== "string") {
@@ -45743,5 +45812,5 @@ class DepParser {
 // Export a Set of implemented function names for O(1) lookup
 const implementedFunctionNames = FormulaParser.getImplementedFunctionNames();
 
-export { Address, Criteria, DepParser, Factorials, FormulaError, FormulaHelpers, MAX_COLUMN, MAX_ROW, ReversedTypes, Types, WildCard, allTokens, FormulaParser as default, implementedFunctionNames, lex, noop, tokenVocabulary$1 as tokenVocabulary, tolerantLex };
+export { Address, Criteria, DepParser, Factorials, FormulaError, FormulaHelpers, MAX_COLUMN, MAX_ROW, ReversedTypes, Types, UnknownChar, WildCard, allTokens, FormulaParser as default, implementedFunctionNames, lex, noop, tokenVocabulary$1 as tokenVocabulary, tolerantLex };
 //# sourceMappingURL=index.js.map