Perf: cache newline offsets in Source for O(log n) loc conversion

hbsPosFor() and charPosFor() were doing a fresh indexOf('\n') scan of
the source on every call, making each lookup O(lines_until_offset).
These are called once per AST node loc by the ASTv2 normalize pass, so
total cost was effectively O(n²) in template size.

CPU profile of a full precompile() showed hbsPosFor dominating at ~28%
of self-time, scattered across many call sites.

Fix: precompute an array of newline offsets on first use, binary-search
it for conversions. O(log n) per call, O(n) to build once per source.

Impact (Node 24, warmed JIT, full precompile()):
  real-world template (1494 chars):  1.34ms -> 1.24ms
  large template (3520 chars):       4.53ms -> 3.06ms  (32%% faster)

The normalize phase specifically (ASTv1 -> ASTv2) drops from ~1.72ms
to ~0.43ms on the large template — a 4x speedup in that phase.

All tests pass.

Author: johanrd

packages/@glimmer/syntax/lib/source/source.ts

@@ -12,11 +12,15 @@ export class Source {
     return new Source(source, options.meta?.moduleName);
   }
 
+  /** Char offset of each `\n` in the source. */
+  readonly #newlineOffsets: readonly number[];
+
   constructor(
     readonly source: string,
     readonly module = 'an unknown module'
   ) {
     setLocalDebugType('syntax:source', this);
+    this.#newlineOffsets = computeNewlineOffsets(source);
   }
 
   /**
@@ -42,66 +46,55 @@ export class Source {
   }
 
   hbsPosFor(offset: number): Nullable<SourcePosition> {
-    let seenLines = 0;
-    let seenChars = 0;
-
-    if (offset > this.source.length) {
-      return null;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    while (true) {
-      let nextLine = this.source.indexOf('\n', seenChars);
+    if (offset > this.source.length) return null;
+    const lineIdx = lowerBound(this.#newlineOffsets, offset);
+    return { line: lineIdx + 1, column: offset - this.#lineStartFor(lineIdx) };
+  }
 
-      if (offset <= nextLine || nextLine === -1) {
-        return {
-          line: seenLines + 1,
-          column: offset - seenChars,
-        };
-      } else {
-        seenLines += 1;
-        seenChars = nextLine + 1;
+  charPosFor({ line, column }: SourcePosition): number | null {
+    const lineIdx = line - 1;
+    const lineStart = this.#lineStartFor(lineIdx);
+    const nextNl = this.#newlineOffsets[lineIdx];
+    const lineEnd = nextNl ?? this.source.length;
+    const target = lineStart + column;
+
+    if (target <= lineEnd) {
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (DEBUG) {
+        const roundTrip = this.hbsPosFor(target);
+        localAssert(roundTrip !== null, `the returned offset failed to round-trip`);
+        localAssert(roundTrip.line === line, `line round-trip mismatch`);
+        localAssert(roundTrip.column === column, `column round-trip mismatch`);
       }
+      return target;
     }
+    return lineEnd;
   }
 
-  charPosFor(position: SourcePosition): number | null {
-    let { line, column } = position;
-    let sourceString = this.source;
-    let sourceLength = sourceString.length;
-    let seenLines = 0;
-    let seenChars = 0;
-
-    while (seenChars < sourceLength) {
-      let nextLine = this.source.indexOf('\n', seenChars);
-      if (nextLine === -1) nextLine = this.source.length;
-
-      if (seenLines === line - 1) {
-        if (seenChars + column > nextLine) return nextLine;
-
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        if (DEBUG) {
-          let roundTrip = this.hbsPosFor(seenChars + column);
-          localAssert(roundTrip !== null, `the returned offset failed to round-trip`);
-          localAssert(
-            roundTrip.line === line,
-            `the round-tripped line didn't match the original line`
-          );
-          localAssert(
-            roundTrip.column === column,
-            `the round-tripped column didn't match the original column`
-          );
-        }
+  #lineStartFor(lineIdx: number): number {
+    if (lineIdx === 0) return 0;
+    const prevNl = this.#newlineOffsets[lineIdx - 1];
+    return prevNl === undefined ? 0 : prevNl + 1;
+  }
+}
 
-        return seenChars + column;
-      } else if (nextLine === -1) {
-        return 0;
-      } else {
-        seenLines += 1;
-        seenChars = nextLine + 1;
-      }
-    }
+function computeNewlineOffsets(source: string): number[] {
+  const offsets: number[] = [];
+  for (let i = source.indexOf('\n'); i !== -1; i = source.indexOf('\n', i + 1)) {
+    offsets.push(i);
+  }
+  return offsets;
+}
 
-    return sourceLength;
+/** Lower-bound binary search: smallest i with arr[i] >= target, else arr.length. */
+function lowerBound(arr: readonly number[], target: number): number {
+  let lo = 0;
+  let hi = arr.length;
+  while (lo < hi) {
+    const mid = (lo + hi) >>> 1;
+    // mid is in [lo, hi) so always a valid index.
+    if ((arr[mid] as number) < target) lo = mid + 1;
+    else hi = mid;
   }
+  return lo;
 }