fix: additional parsing cases

Author: arnog

src/compute-engine/latex-syntax/parse.ts

@@ -1578,6 +1578,34 @@ export class _Parser implements Parser {
 
     this.skipSpace();
 
+    // Check for optional subscript: log_2(x) or log_{10}(x)
+    let subscript: MathJsonExpression | null = null;
+    if (this.peek === '_') {
+      const underIndex = this.index;
+      this.index++; // skip '_'
+      subscript = this.parseGroup();
+      if (subscript === null) {
+        // Try bare digits/letters: _2, _10, _b
+        const subStart = this.index;
+        if (!this.atEnd && /^[a-zA-Z]$/.test(this.peek)) {
+          subscript = this.peek;
+          this.index++;
+        } else {
+          let digits = '';
+          while (!this.atEnd && /^[0-9]$/.test(this.peek)) {
+            digits += this.peek;
+            this.index++;
+          }
+          if (digits) subscript = parseInt(digits);
+        }
+        if (subscript === null) {
+          this.index = start;
+          return null;
+        }
+      }
+      this.skipSpace();
+    }
+
     // Check for optional exponent: sin^2(x) or sin^{10}(x)
     let exponent: MathJsonExpression | null = null;
     if (this.peek === '^') {
@@ -1699,7 +1727,17 @@ export class _Parser implements Parser {
       return exponent !== null ? ['Power', result, exponent] : result;
     }
 
-    const result: MathJsonExpression = [fnName, ...args];
+    // Special case: log with subscript base (matches \log_b behavior)
+    // log_2(x) -> ['Lb', x], log_10(x) -> ['Log', x], log_b(x) -> ['Log', x, b]
+    let result: MathJsonExpression;
+    if (name === 'log' && subscript !== null) {
+      if (subscript === 2) result = ['Lb', ...args];
+      else if (subscript === 10) result = ['Log', ...args];
+      else result = ['Log', args[0], subscript];
+    } else {
+      result = [fnName, ...args];
+    }
+
     return exponent !== null ? ['Power', result, exponent] : result;
   }
 

src/compute-engine/latex-syntax/tokenizer.ts

@@ -19,6 +19,8 @@ const UNICODE_SUPERSCRIPT_MAP: Record<string, string> = {
   '\u2078': '8', // ⁸
   '\u2079': '9', // ⁹
   '\u207B': '-', // ⁻
+  '\u2071': 'i', // ⁱ
+  '\u207F': 'n', // ⁿ
 };
 
 const UNICODE_SUBSCRIPT_MAP: Record<string, string> = {
@@ -72,8 +74,8 @@ class Tokenizer {
     s = s.replace(/\u2212/g, '-');
 
     // Replace Unicode superscript sequences with ^{...}
-    // Handles: ⁰¹²³⁴⁵⁶⁷⁸⁹ and ⁻ (superscript minus)
-    s = s.replace(/[⁰¹²³⁴⁵⁶⁷⁸⁹⁻]+/g, (m) => {
+    // Handles: ⁰¹²³⁴⁵⁶⁷⁸⁹⁻ⁱⁿ
+    s = s.replace(/[⁰¹²³⁴⁵⁶⁷⁸⁹⁻ⁱⁿ]+/g, (m) => {
       const digits = Array.from(m)
         .map((c) => UNICODE_SUPERSCRIPT_MAP[c])
         .join('');

test/compute-engine/latex-syntax/parsing.test.ts

@@ -454,4 +454,125 @@ describe('NON-STRICT MODE (Math-ASCII/Typst-like syntax)', () => {
       `);
     });
   });
+
+  describe('Bare function exponents', () => {
+    test('sin^2(x)', () => {
+      expect(ce.parse('sin^2(x)', { strict: false })).toMatchInlineSnapshot(
+        `["Square", ["Sin", "x"]]`
+      );
+    });
+
+    test('cos^{10}(x)', () => {
+      expect(
+        ce.parse('cos^{10}(x)', { strict: false })
+      ).toMatchInlineSnapshot(`["Power", ["Cos", "x"], 10]`);
+    });
+
+    test('tan^-1(x)', () => {
+      expect(ce.parse('tan^-1(x)', { strict: false })).toMatchInlineSnapshot(
+        `["Divide", 1, ["Tan", "x"]]`
+      );
+    });
+
+    test('sin^2(x) + cos^2(x) identity', () => {
+      const a = ce.parse('sin^2(x) + cos^2(x)', { strict: false });
+      expect(a.isEqual(1)).toBe(true);
+    });
+  });
+
+  describe('Bare log with subscript', () => {
+    test('log_2(x) → base 2', () => {
+      expect(ce.parse('log_2(x)', { strict: false })).toMatchInlineSnapshot(
+        `["Log", "x", 2]`
+      );
+    });
+
+    test('log_{10}(x) → base 10 (default)', () => {
+      expect(
+        ce.parse('log_{10}(x)', { strict: false })
+      ).toMatchInlineSnapshot(`["Log", "x"]`);
+    });
+
+    test('log_3(x) → base 3', () => {
+      expect(ce.parse('log_3(x)', { strict: false })).toMatchInlineSnapshot(
+        `["Log", "x", 3]`
+      );
+    });
+
+    test('log_b(x) → variable base', () => {
+      expect(ce.parse('log_b(x)', { strict: false })).toMatchInlineSnapshot(
+        `["Log", "x", "b"]`
+      );
+    });
+  });
+
+  describe('Unicode superscripts', () => {
+    test('x² → Power', () => {
+      expect(ce.parse('x²')).toMatchInlineSnapshot(`["Square", "x"]`);
+    });
+
+    test('x²³ → multi-digit exponent', () => {
+      expect(ce.parse('x²³')).toMatchInlineSnapshot(
+        `["Power", "x", 23]`
+      );
+    });
+
+    test('x⁻² → negative exponent', () => {
+      expect(ce.parse('x⁻²')).toMatchInlineSnapshot(
+        `["Divide", 1, ["Square", "x"]]`
+      );
+    });
+
+    test('xⁿ → letter superscript', () => {
+      expect(ce.parse('xⁿ')).toMatchInlineSnapshot(
+        `["Power", "x", "n"]`
+      );
+    });
+
+    test('2ⁿ → numeric base with letter exponent', () => {
+      expect(ce.parse('2ⁿ')).toMatchInlineSnapshot(
+        `["Power", 2, "n"]`
+      );
+    });
+
+    test('\\sin²(x) → trig with Unicode exponent', () => {
+      expect(ce.parse('\\sin²(x)')).toMatchInlineSnapshot(
+        `["Square", ["Sin", "x"]]`
+      );
+    });
+
+    test('sin²(x) bare + Unicode', () => {
+      expect(ce.parse('sin²(x)', { strict: false })).toMatchInlineSnapshot(
+        `["Square", ["Sin", "x"]]`
+      );
+    });
+  });
+
+  describe('Unicode subscripts', () => {
+    test('x₁ → subscript', () => {
+      expect(ce.parse('x₁')).toMatchInlineSnapshot(`x_1`);
+    });
+
+    test('x₁₂ → multi-digit subscript', () => {
+      expect(ce.parse('x₁₂')).toMatchInlineSnapshot(`x_12`);
+    });
+
+    test('x₁² → subscript + superscript', () => {
+      expect(ce.parse('x₁²')).toMatchInlineSnapshot(
+        `["Square", "x_1"]`
+      );
+    });
+
+    test('log₂(x) → Unicode subscript on bare log', () => {
+      expect(ce.parse('log₂(x)', { strict: false })).toMatchInlineSnapshot(
+        `["Log", "x", 2]`
+      );
+    });
+
+    test('log₁₀(x) → Unicode subscript base 10', () => {
+      expect(
+        ce.parse('log₁₀(x)', { strict: false })
+      ).toMatchInlineSnapshot(`["Log", "x"]`);
+    });
+  });
 });