@rowsncolumns/fast-formula-parser 6.2.32 → 6.2.34

package/dist/cjs/index.js

@@ -3223,12 +3223,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) {
@@ -41824,7 +41827,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;
 });
 
@@ -41852,11 +41867,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;
@@ -45757,6 +45790,7 @@ exports.MAX_COLUMN = MAX_COLUMN;
 exports.MAX_ROW = MAX_ROW;
 exports.ReversedTypes = ReversedTypes;
 exports.Types = Types;
+exports.UnknownChar = UnknownChar;
 exports.WildCard = WildCard;
 exports.allTokens = allTokens;
 exports.default = FormulaParser;