Function parseDSLGroup

src/compute-engine/numerics/unit-data.ts:534–598

* Parse a DSL group, which may contain parenthesized sub-expressions. * Handles `(m*s^2)` by stripping outer parens and recursing. * * A single pass finds both the first top-level `/` and all top-level `*` * split points. `/` binds more loosely than `*`, so if a slash is found * the string is

(s: string)

 * Flatten a compound unit expression into a map from unit symbol to its
 * summed exponent.
 *
 * - `string` → add `exp` to the symbol's running total.
 * - `["Multiply", ...]` → recurse each child with the same exponent.
 * - `["Divide", a, b]` → recurse `a` with `+exp`, `b` with `−exp`.
 * - `["Power", base, n]` (n a number) → recurse `base` with `exp·n`.
 *
 * Returns `null` on any other shape (the caller then leaves the unit
 * untouched).  Because same-symbol exponents are summed, `in¹·in⁻¹` cancels
 * exactly, with no floating-point scale involved.
 */
export function flattenUnitFactors(
  expr: UnitExpression
): Map<string, number> | null {
  const factors = new Map<string, number>();

  function walk(e: UnitExpression, exp: number): boolean {
    if (typeof e === 'string') {
      factors.set(e, (factors.get(e) ?? 0) + exp);
      return true;
    }
    if (!Array.isArray(e) || e.length < 2) return false;
    const op = e[0];
    if (op === 'Multiply') {
      for (let i = 1; i < e.length; i++) if (!walk(e[i], exp)) return false;
      return true;
    }
    if (op === 'Divide') {
      if (e.length !== 3) return false;
      return walk(e[1], exp) && walk(e[2], -exp);
    }
    if (op === 'Power') {
      if (e.length !== 3) return false;
      const n = e[2];
      if (typeof n !== 'number') return false;
      return walk(e[1], exp * n);
    }
    return false;
  }

  if (!walk(expr, 1)) return null;
  return factors;
}

/**
 * Cancel repeated unit factors that share a physical dimension.
 *
 * Zero-exponent entries are dropped.  The remaining symbols are grouped by
 * their dimension vector.  For each group with MIXED-SIGN exponents (genuine
 * cancellation potential, e.g. `m` and `in` with `+1`/`−1`), the member with
 * the largest scale is chosen as the representative (same convention as
 * `quantityAdd`); every other member `s` with exponent `e` folds into the
 * representative (`magnitudeScale *= (scale_s / scale_rep) ** e`, and `e` is
 * added to the representative's exponent).  The representative itself is
 * dropped if its summed exponent reaches 0.  Groups whose exponents are all
 * the same sign are left untouched (so `in·ft` area survives as written).
 *
 * Offsets (degC/degF) are intentionally ignored, consistent with
 * `getExpressionScale`/`convertCompoundUnit` in compound contexts.