perf(lexer): reduce per-parse allocations (#131)

Small modules allocate six 1024-element stacks per parse despite bounded
nesting. Their entries contain only numbers and class flags, so resetting
the cursors preserves per-call state.

For `exports.name = 1; module.exports.second = 2;`, JavaScript CPU time falls
from 3.76us to 0.43us. The Wasm wrapper falls from 0.401us to 0.370us on
the same input.

Measured on Node v22.23.3 with V8 12.4.254.21-node.57. Comparisons use
50,000 warm-up iterations and seven rotating trials of 100,000 parses,
with the fastest and slowest trials removed.

Author: BridgeAR

lexer.js

@@ -1,13 +1,13 @@
 let source, pos, end;
 const STACK_DEPTH = 2048;
+const templateStack = new Array(1024);
+const openTokenPosStack = new Array(1024);
+const openClassPosStack = new Array(1024);
 let openTokenDepth,
   templateDepth,
   lastTokenPos,
   lastSlashWasDivision,
-  templateStack,
   templateStackDepth,
-  openTokenPosStack,
-  openClassPosStack,
   nextBraceIsClass,
   starExportMap,
   lastStarExportSpecifier,
@@ -20,10 +20,7 @@ function resetState () {
   templateDepth = -1;
   lastTokenPos = -1;
   lastSlashWasDivision = false;
-  templateStack = new Array(1024);
   templateStackDepth = 0;
-  openTokenPosStack = new Array(1024);
-  openClassPosStack = new Array(1024);
   nextBraceIsClass = false;
   starExportMap = Object.create(null);
   lastStarExportSpecifier = null;

src/lexer.js

@@ -3,23 +3,30 @@ let wasm;
 const isLE = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
 const hasBuffer = typeof Buffer !== 'undefined';
 
+/**
+ * @param {string} source
+ * @param {string} [name]
+ */
 export function parse (source, name = '@') {
   if (!wasm)
     initSync();
 
   const len = source.length + 1;
 
   // need 2 bytes per code point plus analysis space so we double again
-  const extraMem = (wasm.__heap_base.value || wasm.__heap_base) + len * 4 - wasm.memory.buffer.byteLength;
-  if (extraMem > 0)
+  let memory = wasm.memory.buffer;
+  const extraMem = (wasm.__heap_base.value || wasm.__heap_base) + len * 4 - memory.byteLength;
+  if (extraMem > 0) {
     wasm.memory.grow(Math.ceil(extraMem / 65536));
+    memory = wasm.memory.buffer;
+  }
 
   const addr = wasm.sa(len);
   // Buffer setup is slower than the loop for short sources.
   if (source.length >= 64 && hasBuffer)
-    Buffer.from(wasm.memory.buffer, addr, (len - 1) * 2).write(source, 'utf16le');
+    Buffer.from(memory, addr, (len - 1) * 2).write(source, 'utf16le');
   else
-    (isLE ? copyLE : copyBE)(source, new Uint16Array(wasm.memory.buffer, addr, len));
+    (isLE ? copyLE : copyBE)(source, new Uint16Array(memory, addr, len));
 
   const err_code = wasm.parseCJS(addr, source.length, 0, 0, 0);
 
@@ -31,18 +38,20 @@ export function parse (source, name = '@') {
     throw err;
   }
 
-  let exports = new Set(), reexports = new Set(), unsafeGetters = new Set();
+  let exports = new Set(), reexports = new Set(), unsafeGetters;
 
   while (wasm.rre()) {
     const reexptStr = decode(source.slice(wasm.res(), wasm.ree()));
     if (reexptStr)
       reexports.add(reexptStr);
   }
-  while (wasm.ru())
+  while (wasm.ru()) {
+    if (!unsafeGetters) unsafeGetters = new Set();
     unsafeGetters.add(decode(source.slice(wasm.us(), wasm.ue())));
+  }
   while (wasm.re()) {
     let exptStr = decode(source.slice(wasm.es(), wasm.ee()));
-    if (exptStr !== undefined && !unsafeGetters.has(exptStr))
+    if (exptStr !== undefined && (!unsafeGetters || !unsafeGetters.has(exptStr)))
       exports.add(exptStr);
   }
 
@@ -242,6 +251,10 @@ function readHex (char) {
 
 
 
+/**
+ * @param {string} src
+ * @param {Uint16Array} outBuf16
+ */
 function copyBE (src, outBuf16) {
   const len = src.length;
   let i = 0;
@@ -251,6 +264,10 @@ function copyBE (src, outBuf16) {
   }
 }
 
+/**
+ * @param {string} src
+ * @param {Uint16Array} outBuf16
+ */
 function copyLE (src, outBuf16) {
   const len = src.length;
   let i = 0;

test/_unit.js

@@ -20,6 +20,50 @@ async function loadParser () {
 suite('Lexer', () => {
   suiteSetup(async () => await loadParser());
 
+  test('Repeated parsing preserves scanner state and earlier results', () => {
+    const first = parse("exports.first = 1; __exportStar(require('first'));");
+    const nested = '('.repeat(1536) + '0' + ')'.repeat(1536) + '; exports.deep = 1;';
+    for (let i = 0; i < 3; i++) {
+      assert.deepStrictEqual(parse(nested), { exports: ['deep'], reexports: [] });
+      assert.deepStrictEqual(parse('class C {} /exports.fake/.test("x"); exports.regex = 1;'),
+        { exports: ['regex'], reexports: [] });
+      assert.deepStrictEqual(parse('const value = `${`${1}`}`; exports.template = value;'),
+        { exports: ['template'], reexports: [] });
+      assert.throws(() => parse('class C { method () { return "unfinished'),
+        process.env.WASM || process.env.WASM_SYNC ? /^Error: Parse error @/ : /^Error: Unterminated string\./);
+      assert.deepStrictEqual(parse('const value = {} / 2; exports.after = value;'),
+        { exports: ['after'], reexports: [] });
+    }
+    assert.deepStrictEqual(first, { exports: ['first'], reexports: ['first'] });
+  });
+
+  test('Unsafe getter filtering remains local to each parse', () => {
+    const source = `
+      exports.hidden = 1;
+      Object.defineProperty(exports, 'hidden', { enumerable: true, get () { return effect(); } });
+      Object.defineProperty(exports, 'other', { enumerable: true, get () { return effect(); } });
+      exports.visible = 1;
+      exports['\\u0076isible'] = 2;
+      exports.other = 1;
+    `;
+    for (let i = 0; i < 3; i++) {
+      assert.deepStrictEqual(parse('exports.hidden = 1; exports.other = 1;'),
+        { exports: ['hidden', 'other'], reexports: [] });
+      assert.deepStrictEqual(parse(source), { exports: ['visible'], reexports: [] });
+      assert.deepStrictEqual(parse(''), { exports: [], reexports: [] });
+    }
+  });
+
+  test('Large source copies remain correct across repeated parses', () => {
+    const large = '/*' + ' '.repeat(1024 * 1024) + '*/ exports["caf\\u00e9"] = 1;';
+    const first = parse('exports.first = 1;');
+    for (let i = 0; i < 3; i++) {
+      assert.deepStrictEqual(parse(large), { exports: ['café'], reexports: [] });
+      assert.deepStrictEqual(parse('exports.small = 1;'), { exports: ['small'], reexports: [] });
+    }
+    assert.deepStrictEqual(first, { exports: ['first'], reexports: [] });
+  });
+
   test('automatic Wasm initialization', async () => {
     const lexer = await import('../dist/lexer.mjs?automatic-initialization');