preprocess.js

function isDigit(ch) { return /[0-9]/.test(ch); }
function isAlpha(ch) { return /[A-Za-z_]/.test(ch); }

function tokenizeWithGroups(src) {
  let i = 0;
  const len = src.length;

  function skipSpaces() {
    while (i < len && /\s/.test(src[i])) i++;
  }

  function readNumber() {
    let start = i;
    while (i < len && /[0-9.]/.test(src[i])) i++;
    return { type: 'number', value: src.slice(start, i) };
  }

  function readIdent() {
    let start = i;
    while (i < len && /[A-Za-z0-9_]/.test(src[i])) i++;
    return { type: 'ident', value: src.slice(start, i) };
  }

  function parseGroup() {
    i++;
    const inner = [];
    while (i < len) {
      skipSpaces();
      if (i >= len) break;
      const ch = src[i];
      if (ch === ')') { i++; break; }
      if (ch === '(') {
        inner.push(parseGroup());
        continue;
      }
      if (isDigit(ch)) { inner.push(readNumber()); continue; }
      if (isAlpha(ch)) { inner.push(readIdent()); continue; }
      if ("+-*/^=,".includes(ch)) { inner.push({ type: 'op', value: ch }); i++; continue; }
      if (ch === '!') { inner.push({ type: 'op', value: '!' }); i++; continue; }
      inner.push({ type: 'op', value: ch }); i++;
    }
    return { type: 'group', value: inner };
  }

  const tokens = [];
  while (i < len) {
    skipSpaces();
    if (i >= len) break;
    const ch = src[i];
    if (ch === '(') { tokens.push(parseGroup()); continue; }
    if (isDigit(ch)) { tokens.push(readNumber()); continue; }
    if (isAlpha(ch)) { tokens.push(readIdent()); continue; }
    if ("+-*/^=,()".includes(ch)) { tokens.push({ type: 'op', value: ch }); i++; continue; }
    if (ch === '!') { tokens.push({ type: 'op', value: '!' }); i++; continue; }
    tokens.push({ type: 'op', value: ch });
    i++;
  }
  return tokens;
}

function isValueToken(t) {
  return !t || t.type === 'number' || t.type === 'ident' || t.type === 'group' || (t.type === 'op' && t.value === ')');
}

function stringifyTokens(tokens) {
  const out = [];
  for (let i = 0; i < tokens.length; i++) {
    const t = tokens[i];
    if (t.type === 'number' || t.type === 'ident') out.push(t.value);
    else if (t.type === 'op') out.push(t.value);
    else if (t.type === 'group') out.push('(' + stringifyTokens(t.value) + ')');
    else out.push(String(t.value));
  }
  return out.join('');
}

function factorial(n) {
  if (n < 0 || !Number.isInteger(n)) return null;
  let f = 1;
  for (let i = 2; i <= n; i++) f *= i;
  return f;
}

function tryEvaluateSimpleGroup(groupToken) {
  if (!groupToken || groupToken.type !== 'group') return null;
  const inner = groupToken.value;
  if (inner.length === 1 && inner[0].type === 'number') {
    return Number(inner[0].value);
  }
  return null;
}

function expandFactorials(tokens) {
  const out = [];
  for (let i = 0; i < tokens.length; i++) {
    const t = tokens[i];
    if (t.type === 'op' && t.value === '!') {
      if (out.length === 0) {
        out.push(t);
        continue;
      }
      const prev = out.pop();
      if (prev.type === 'number') {
        const n = Number(prev.value);
        const f = factorial(n);
        if (f !== null) { out.push({ type: 'number', value: String(f) }); continue; }
      }
      const ev = tryEvaluateSimpleGroup(prev);
      if (ev !== null) {
        const f = factorial(ev);
        if (f !== null) { out.push({ type: 'number', value: String(f) }); continue; }
      }
      out.push(prev);
      out.push(t);
      continue;
    }

    if (t.type === 'group') {
      out.push({ type: 'group', value: expandFactorials(t.value) });
      continue;
    }

    out.push(t);
  }
  return out;
}

function insertImplicitMultiplication(tokens) {
  const out = [];
  for (let i = 0; i < tokens.length; i++) {
    const cur = tokens[i];
    out.push(cur);
    const next = tokens[i+1];
    if (!next) continue;

    const curIsValue = (cur.type === 'number' || cur.type === 'ident' || cur.type === 'group' || (cur.type === 'op' && cur.value === ')'));
    const nextIsValue = (next.type === 'number' || next.type === 'ident' || next.type === 'group' || (next.type === 'op' && next.value === '('));

    if (curIsValue && nextIsValue) {
      out.push({ type: 'op', value: '*' });
    }
  }
  return out;
}

function preprocessExpression(src) {
  let tokens = tokenizeWithGroups(src);

  tokens = expandFactorials(tokens);

  tokens = insertImplicitMultiplication(tokens);

  return stringifyTokens(tokens);
}

export { preprocessExpression };