@poe-platform/safe-js 0.1.721 → 0.1.722

package/dist/safe-js/chunks/{chunk-ILYJBA2D.js → chunk-RYVHEOHM.js}

@@ -157,12 +157,11 @@ function releaseTemplateObjects(budget) {
 }
 
 // packages/safe-js/src/interp/budget.ts
-var REGEX_STEP_LIMIT = 2e3;
 var REGEX_COMPILE_LIMITS = Object.freeze({
-  sourceLength: 4096,
-  flagsLength: 8,
-  depth: 64,
-  allocations: 16384
+  sourceLength: Infinity,
+  flagsLength: Infinity,
+  depth: Infinity,
+  allocations: Infinity
 });
 var DEADLINE_CHECK_INTERVAL = 1024;
 var SandboxError = class extends Error {
@@ -204,6 +203,8 @@ var BudgetAccounting = class {
   allChecksSuspended = 0;
   deadlineChecksSuspended = 0;
   visitsUntilDeadlineCheck = DEADLINE_CHECK_INTERVAL;
+  pendingDeadlines;
+  earliestPendingDeadline;
   retainedDataSize = 0;
   retainedData = /* @__PURE__ */ new Map();
   retainedValueSources = /* @__PURE__ */ new Map();
@@ -214,6 +215,8 @@ var BudgetAccounting = class {
   provisionalScopes = 0;
   compileTickets = /* @__PURE__ */ new Map();
   completedCompileTickets = /* @__PURE__ */ new Set();
+  reconciliationHolds = 0;
+  deferredCompileDiscards = /* @__PURE__ */ new Set();
   realmViews;
   constructor(options = {}) {
     this.deadline = normalizeDeadline(options.deadline);
@@ -221,6 +224,12 @@ var BudgetAccounting = class {
       maxSteps: normalizeLimit("maxSteps", options.maxSteps),
       maxCallDepth: normalizeLimit("maxCallDepth", options.maxCallDepth),
       stringLength: normalizeLimit("stringLength", options.stringLength),
+      ...options.regexSourceLength === void 0 ? {} : {
+        regexSourceLength: normalizeRegexLimit("regexSourceLength", options.regexSourceLength)
+      },
+      ...options.regexCompileAllocations === void 0 ? {} : {
+        regexCompileAllocations: normalizeRegexLimit("regexCompileAllocations", options.regexCompileAllocations)
+      },
       arrayLength: normalizeLimit("arrayLength", options.arrayLength),
       dataSize: normalizeLimit("dataSize", options.dataSize)
     });
@@ -269,6 +278,36 @@ var Budget = class _Budget {
   set currentCallDepth(value) {
     this.accounting.currentCallDepth = value;
   }
+  // Pending host operations keep their elapsed deadline active during sampled
+  // synchronous work. Linked private records need no observable native hooks.
+  acquireDeadline(deadline, onExceeded) {
+    if (!Number.isFinite(deadline)) throw new TypeError("Deadline must be a finite timestamp.");
+    const accounting = this.accounting;
+    const pending = {
+      deadline,
+      onExceeded,
+      next: accounting.pendingDeadlines,
+      active: true
+    };
+    if (pending.next !== void 0) pending.next.previous = pending;
+    accounting.pendingDeadlines = pending;
+    if (accounting.earliestPendingDeadline === void 0 || pending.deadline < accounting.earliestPendingDeadline.deadline)
+      accounting.earliestPendingDeadline = pending;
+    return () => {
+      if (!pending.active) return;
+      pending.active = false;
+      if (pending.previous === void 0) accounting.pendingDeadlines = pending.next;
+      else pending.previous.next = pending.next;
+      if (pending.next !== void 0) pending.next.previous = pending.previous;
+      pending.previous = pending.next = void 0;
+      pending.onExceeded = void 0;
+      if (accounting.earliestPendingDeadline !== pending) return;
+      accounting.earliestPendingDeadline = void 0;
+      for (let next = accounting.pendingDeadlines; next !== void 0; next = next.next)
+        if (accounting.earliestPendingDeadline === void 0 || next.deadline < accounting.earliestPendingDeadline.deadline)
+          accounting.earliestPendingDeadline = next;
+    };
+  }
   forkRealm() {
     const view = new _Budget();
     view.accounting = this.accounting;
@@ -311,14 +350,17 @@ var Budget = class _Budget {
     }
   }
   allocateString(value) {
-    if (this.accounting.allChecksSuspended === 0 && this.accounting.limits.stringLength !== void 0 && value.length > this.accounting.limits.stringLength) {
+    this.allocateStringLength(value.length);
+    return value;
+  }
+  allocateStringLength(length) {
+    if (this.accounting.allChecksSuspended === 0 && this.accounting.limits.stringLength !== void 0 && length > this.accounting.limits.stringLength) {
       throw new SandboxError({
         budget: "stringLength",
-        current: value.length,
+        current: length,
         limit: this.accounting.limits.stringLength
       });
     }
-    return value;
   }
   allocateArrayLength(length) {
     if (this.accounting.allChecksSuspended === 0 && this.accounting.limits.arrayLength !== void 0 && length > this.accounting.limits.arrayLength) {
@@ -333,7 +375,8 @@ var Budget = class _Budget {
     this.allocateArrayLength(count);
   }
   reconcileDataUsage(usage) {
-    const total = usage + this.accounting.retainedDataSize;
+    const measured = usage + this.accounting.retainedDataSize;
+    const total = this.reconciliationDeferred ? Math.max(measured, this.accounting.currentDataSize) : measured;
     this.checkDataUsage(total);
     this.accounting.currentDataSize = total;
     this.accounting.peakDataSize = Math.max(this.accounting.peakDataSize, total);
@@ -355,6 +398,23 @@ var Budget = class _Budget {
     if (values === void 0) this.accounting.retainedValueSources.delete(owner);
     else this.accounting.retainedValueSources.set(owner, values);
   }
+  get reconciliationDeferred() {
+    return this.accounting.reconciliationHolds > 0;
+  }
+  deferReconciliation() {
+    this.accounting.reconciliationHolds++;
+    const generation = this.accounting.compileGeneration;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      if (generation !== this.accounting.compileGeneration) return;
+      if (--this.accounting.reconciliationHolds !== 0) return;
+      for (const ticket of this.accounting.deferredCompileDiscards)
+        this.accounting.completedCompileTickets.add(ticket);
+      this.accounting.deferredCompileDiscards.clear();
+    };
+  }
   *retainedValues() {
     for (const values of this.accounting.retainedValueSources.values()) {
       const retained = values();
@@ -395,6 +455,7 @@ var Budget = class _Budget {
     if (ticket.owner.generation !== this.accounting.compileGeneration || !this.accounting.compileTickets.has(ticket)) {
       throw new SandboxError("reentry");
     }
+    if (this.reconciliationDeferred) usage = Math.max(usage, this.compileTicketUsage(ticket));
     this.setRetainedDataUsage(ticket, usage);
     this.accounting.compileTickets.set(ticket, usage);
   }
@@ -402,6 +463,10 @@ var Budget = class _Budget {
     if (ticket.owner.generation !== this.accounting.compileGeneration) return;
     const usage = this.accounting.compileTickets.get(ticket);
     if (usage === void 0) return;
+    if (this.reconciliationDeferred) {
+      this.accounting.deferredCompileDiscards.add(ticket);
+      return;
+    }
     this.accounting.compileTickets.delete(ticket);
     this.accounting.completedCompileTickets.delete(ticket);
     this.accounting.retainedData.delete(ticket);
@@ -409,6 +474,19 @@ var Budget = class _Budget {
     this.accounting.currentDataSize -= usage;
   }
   reconcileCompileData(usage, included, transferred = included, retainedOwner, complete = false) {
+    if (this.reconciliationDeferred) {
+      if (retainedOwner !== void 0) this.setRetainedDataUsage(retainedOwner, usage);
+      else {
+        let includedUsage2 = 0;
+        for (const ticket of included) includedUsage2 += this.compileTicketUsage(ticket);
+        const measured2 = usage + this.accounting.retainedDataSize - includedUsage2;
+        const total2 = Math.max(measured2, this.accounting.currentDataSize);
+        this.checkDataUsage(total2);
+        this.accounting.currentDataSize = total2;
+        this.accounting.peakDataSize = Math.max(this.accounting.peakDataSize, total2);
+      }
+      return /* @__PURE__ */ new Set();
+    }
     let includedUsage = 0;
     let transferredUsage = 0;
     let discardedUsage = 0;
@@ -472,8 +550,10 @@ var Budget = class _Budget {
       released = true;
       if (generation !== this.accounting.compileGeneration) return;
       this.accounting.provisionalScopes -= 1;
-      if (!commit)
-        this.accounting.currentDataSize = previous + this.accounting.retainedDataSize - previousRetained;
+      if (!commit) {
+        const restored = previous + this.accounting.retainedDataSize - previousRetained;
+        this.accounting.currentDataSize = this.reconciliationDeferred ? Math.max(restored, this.accounting.currentDataSize) : restored;
+      }
     };
   }
   enterCall() {
@@ -495,6 +575,8 @@ var Budget = class _Budget {
     this.accounting.provisionalScopes = 0;
     this.accounting.compileTickets.clear();
     this.accounting.completedCompileTickets.clear();
+    this.accounting.reconciliationHolds = 0;
+    this.accounting.deferredCompileDiscards.clear();
     this.accounting.stepsUsed = 0;
     this.accounting.peakCallDepth = 0;
     this.accounting.currentCallDepth = 0;
@@ -530,18 +612,26 @@ var Budget = class _Budget {
     };
   }
   checkDeadline() {
-    if (this.accounting.allChecksSuspended > 0 || this.accounting.deadlineChecksSuspended > 0 || this.accounting.deadline === void 0) {
+    const pending = this.accounting.earliestPendingDeadline;
+    const deadline = this.accounting.deadline === void 0 ? pending?.deadline : Math.min(this.accounting.deadline, pending?.deadline ?? Infinity);
+    if (this.accounting.allChecksSuspended > 0 || this.accounting.deadlineChecksSuspended > 0 || deadline === void 0) {
       return;
     }
     const now = Date.now();
-    if (now <= this.accounting.deadline) {
+    if (now <= deadline) {
       return;
     }
-    throw new SandboxError({
+    const reason = new SandboxError({
       budget: "deadline",
       current: now,
-      limit: this.accounting.deadline
+      limit: deadline
     });
+    if (pending?.deadline === deadline) {
+      const notify = pending.onExceeded;
+      pending.onExceeded = void 0;
+      notify?.(reason);
+    }
+    throw reason;
   }
   checkDataUsage(usage) {
     if (this.accounting.allChecksSuspended === 0 && this.accounting.limits.dataSize !== void 0 && usage > this.accounting.limits.dataSize) {
@@ -553,7 +643,7 @@ var Budget = class _Budget {
     }
   }
   checkSampledDeadline(units) {
-    if (this.accounting.allChecksSuspended > 0 || this.accounting.deadlineChecksSuspended > 0 || this.accounting.deadline === void 0) {
+    if (this.accounting.allChecksSuspended > 0 || this.accounting.deadlineChecksSuspended > 0 || this.accounting.deadline === void 0 && this.accounting.earliestPendingDeadline === void 0) {
       return;
     }
     this.accounting.visitsUntilDeadlineCheck -= units;
@@ -586,14 +676,6 @@ var Budget = class _Budget {
     };
   }
 };
-function allocateRegexSteps(steps) {
-  if (!Number.isInteger(steps) || steps < 0) {
-    throw new Error("steps must be a non-negative integer.");
-  }
-  if (steps > REGEX_STEP_LIMIT) {
-    throw new SandboxError({ budget: "steps", current: steps, limit: REGEX_STEP_LIMIT });
-  }
-}
 function normalizeDeadline(deadline) {
   if (deadline === void 0) {
     return void 0;
@@ -609,6 +691,12 @@ function normalizeLimit(name, value) {
   }
   return value;
 }
+function normalizeRegexLimit(name, value) {
+  if (value === void 0) return void 0;
+  if (!Number.isSafeInteger(value) || value < 1)
+    throw new RangeError(`${name} must be a positive safe integer.`);
+  return value;
+}
 
 // packages/safe-js/src/interp/regex/compile-guard.ts
 var compiledData = /* @__PURE__ */ new WeakMap();
@@ -649,7 +737,7 @@ var RegexCompileGuard = class {
   ticket;
   retained = false;
   checkLength(length, flags = false) {
-    const hard = flags ? REGEX_COMPILE_LIMITS.flagsLength : REGEX_COMPILE_LIMITS.sourceLength;
+    const hard = flags ? REGEX_COMPILE_LIMITS.flagsLength : this.scope?.owner?.budget.limits.regexSourceLength ?? REGEX_COMPILE_LIMITS.sourceLength;
     const limit = Math.min(hard, this.scope?.owner?.budget.limits.stringLength ?? hard);
     if (length > limit) throw new SandboxError({ budget: "stringLength", current: length, limit });
   }
@@ -660,11 +748,12 @@ var RegexCompileGuard = class {
   }
   allocate(units) {
     const next = this.allocations + units;
-    if (next > REGEX_COMPILE_LIMITS.allocations) {
+    const limit = this.scope?.owner?.budget.limits.regexCompileAllocations ?? REGEX_COMPILE_LIMITS.allocations;
+    if (next > limit) {
       throw new SandboxError({
         budget: "dataSize",
         current: next,
-        limit: REGEX_COMPILE_LIMITS.allocations
+        limit
       });
     }
     this.work(units);
@@ -977,6 +1066,753 @@ function findNumberEnd(value, startIndex) {
   return index;
 }
 
+// packages/safe-js/src/parse/compact-spans.ts
+var positionOwners = /* @__PURE__ */ new WeakMap();
+var getOwner = WeakMap.prototype.get.bind(positionOwners);
+var setOwner = WeakMap.prototype.set.bind(positionOwners);
+var cacheSize = 514;
+var writableSpan = /* @__PURE__ */ Symbol("compiler span writability");
+var CompactSourcePositions = class {
+  sourceLength;
+  lines = [0];
+  positions = /* @__PURE__ */ new Map();
+  makeSpan;
+  constructor(source) {
+    this.sourceLength = source.length;
+    for (let offset = 0; offset < source.length; offset++) {
+      const code = source.charCodeAt(offset);
+      if (code === 13 && source.charCodeAt(offset + 1) === 10) offset++;
+      if (code === 10 || code === 13 || code === 8232 || code === 8233)
+        this.lines.push(offset + 1);
+    }
+    const owner = this;
+    class Span {
+      #start;
+      #end;
+      constructor(start, end) {
+        this.#start = start;
+        this.#end = end;
+        Object.defineProperties(this, descriptors);
+      }
+      get start() {
+        return typeof this.#start === "number" ? owner.position(this.#start) : this.#start.assigned;
+      }
+      set start(value) {
+        if (Object.isFrozen(this)) throw new TypeError("Cannot assign to a frozen source span.");
+        this.#start = getOwner(value) === owner ? value.offset : { assigned: value };
+      }
+      get end() {
+        return typeof this.#end === "number" ? owner.position(this.#end) : this.#end.assigned;
+      }
+      set end(value) {
+        if (Object.isFrozen(this)) throw new TypeError("Cannot assign to a frozen source span.");
+        this.#end = getOwner(value) === owner ? value.offset : { assigned: value };
+      }
+    }
+    const descriptors = {
+      start: {
+        ...Object.getOwnPropertyDescriptor(Span.prototype, "start"),
+        enumerable: true
+      },
+      end: {
+        ...Object.getOwnPropertyDescriptor(Span.prototype, "end"),
+        enumerable: true
+      },
+      // Sealed accessor-only objects otherwise report as frozen. This private
+      // data field preserves the distinction for the mutable endpoint setters.
+      [writableSpan]: { value: true, writable: true, configurable: true }
+    };
+    delete Span.prototype.start;
+    delete Span.prototype.end;
+    this.makeSpan = (start, end) => new Span(start, end);
+  }
+  position(offset) {
+    this.assertOffset(offset);
+    const cached = this.positions.get(offset);
+    if (cached !== void 0) return cached;
+    let low = 0, high = this.lines.length;
+    while (low + 1 < high) {
+      const middle = low + Math.floor((high - low) / 2);
+      if (this.lines[middle] <= offset) low = middle;
+      else high = middle;
+    }
+    const position = Object.freeze({
+      line: low + 1,
+      column: offset - this.lines[low] + 1,
+      offset
+    });
+    setOwner(position, this);
+    if (this.positions.size === cacheSize)
+      this.positions.delete(this.positions.keys().next().value);
+    this.positions.set(offset, position);
+    return position;
+  }
+  span(start, end) {
+    this.assertOffset(start);
+    this.assertOffset(end);
+    return this.makeSpan(start, end);
+  }
+  compatiblePosition(position) {
+    if (!Number.isSafeInteger(position.offset) || position.offset < 0 || position.offset > this.sourceLength)
+      return void 0;
+    const point = this.position(position.offset);
+    return point.line === position.line && point.column === position.column ? point : void 0;
+  }
+  assertOffset(offset) {
+    if (!Number.isSafeInteger(offset) || offset < 0 || offset > this.sourceLength)
+      throw new RangeError("Source coordinate offset is outside its source.");
+  }
+};
+function compactDerivedPosition(base, position) {
+  return getOwner(base)?.compatiblePosition(position);
+}
+function compactSourceSpan(start, end) {
+  const owner = getOwner(start);
+  return owner !== void 0 && getOwner(end) === owner ? owner.span(start.offset, end.offset) : void 0;
+}
+
+// packages/safe-js/src/parse/function-source.ts
+var functionSources = /* @__PURE__ */ new WeakMap();
+var templateSources = /* @__PURE__ */ new WeakMap();
+var functionStrictness = /* @__PURE__ */ new WeakMap();
+var evalFunctionDeclarations = /* @__PURE__ */ new WeakSet();
+var dynamicSourceRecords = /* @__PURE__ */ new WeakSet();
+var dynamicNodeSources = /* @__PURE__ */ new WeakMap();
+var dynamicValueSources = /* @__PURE__ */ new WeakMap();
+
+// packages/safe-js/src/parse/compact-module-ast.ts
+var chunkLength = 65536;
+var scalarMask = 268435455;
+var handles = /* @__PURE__ */ new WeakMap();
+var mutableRecord = /* @__PURE__ */ Symbol("compiler record writability");
+var recordToken = /* @__PURE__ */ Symbol("compiler traversal authority");
+var defineCompilerProperty = Reflect.defineProperty;
+var NativeRowMap = Map;
+var nativeIndexMap = {
+  get: Function.prototype.call.bind(Map.prototype.get),
+  has: Function.prototype.call.bind(Map.prototype.has),
+  set: Function.prototype.call.bind(Map.prototype.set),
+  delete: Function.prototype.call.bind(Map.prototype.delete),
+  clear: Function.prototype.call.bind(Map.prototype.clear),
+  keys: Function.prototype.call.bind(Map.prototype.keys),
+  size: Function.prototype.call.bind(
+    Object.getOwnPropertyDescriptor(Map.prototype, "size").get
+  )
+};
+var CodeRecord = class {
+  constructor(token, owner, row) {
+    this.owner = owner;
+    this.row = row;
+    if (token !== recordToken) throw new TypeError("Foreign compiler traversal authority.");
+    Object.freeze(this);
+  }
+  owner;
+  row;
+  #brand = true;
+  static authentic(value) {
+    return #brand in value && value.#brand;
+  }
+};
+function record(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  return CodeRecord.authentic(value) ? value : handles.get(value);
+}
+var CompactModuleAst = class {
+  constructor(source) {
+    this.source = source;
+    this.positions = new CompactSourcePositions(source);
+    this.maxWords = Math.min(scalarMask - 1, Math.max(1024, source.length * 24 + 1024));
+  }
+  source;
+  chunks = [];
+  shapes = [];
+  shapeIDs = /* @__PURE__ */ new Map();
+  strings = [];
+  stringIDs = /* @__PURE__ */ new Map();
+  numbers = [];
+  cache = /* @__PURE__ */ new Map();
+  boundaries = /* @__PURE__ */ new Set();
+  persistentBoundaries = /* @__PURE__ */ new Set();
+  overrides = /* @__PURE__ */ new WeakMap();
+  finished = false;
+  positions;
+  maxWords;
+  used = 0;
+  bodies = 0;
+  dynamicSource;
+  statistics() {
+    return {
+      words: this.used,
+      bufferBytes: this.chunks.reduce((sum, c) => sum + c.byteLength, 0),
+      bodies: this.bodies,
+      materializedRecords: this.cache.size,
+      strings: this.strings.length
+    };
+  }
+  finish() {
+    this.finished = true;
+    if (this.chunks.length) {
+      const last = this.chunks.length - 1;
+      this.chunks[last] = this.chunks[last].slice(0, (this.used - 1) % chunkLength + 1);
+    }
+    this.stringIDs.clear();
+    this.shapeIDs.clear();
+    this.persistentBoundaries.clear();
+  }
+  /** Retirement consumes unobserved parser arrays after syntax validation. */
+  pack(root, body = true, retire = false, persistent = true) {
+    if (this.finished) throw new TypeError("Compiler body storage is finished.");
+    const seen = /* @__PURE__ */ new WeakMap();
+    const pending = [];
+    const encode = (value) => {
+      if (value === null || typeof value !== "object") return this.scalar(value);
+      const existing = record(value);
+      if (existing?.owner === this) {
+        if (retire && !this.overrides.has(value)) {
+          this.cache.delete(existing.row);
+          if (!this.persistentBoundaries.has(existing.row)) this.boundaries.delete(existing.row);
+        }
+        return existing.row + 1;
+      }
+      const previous = seen.get(value);
+      if (previous !== void 0) return previous + 1;
+      let kind, row, values = [];
+      const array = Array.isArray(value);
+      const keys = array ? [] : Object.keys(value).filter((key) => key !== "nodeId");
+      if (array) {
+        kind = 0;
+        row = this.reserve(2 + value.length);
+        values = value;
+        this.write(row, kind);
+        this.write(row + 1, value.length);
+      } else if (keys.length === 2 && keys[0] === "start" && keys[1] === "end") {
+        const span = value, start = span.start, end = span.end;
+        const startPoint = this.positions.compatiblePosition(start);
+        const endPoint = this.positions.compatiblePosition(end);
+        if (startPoint && endPoint) {
+          kind = 1;
+          row = this.reserve(3);
+          this.write(row, kind);
+          this.write(row + 1, start.offset);
+          this.write(row + 2, end.offset);
+        } else {
+          kind = 2;
+          row = this.reserve(7);
+          this.write(row, kind);
+          [start.line, start.column, start.offset, end.line, end.column, end.offset].forEach(
+            (n, i) => this.write(row + 1 + i, n)
+          );
+        }
+      } else {
+        values = keys.map((key2) => value[key2]);
+        if ("nodeId" in value || typeof value.type === "string" && "span" in value) {
+          keys.push("@id");
+          values.push(value.nodeId);
+          const metadata = functionSources.get(value);
+          if (metadata) {
+            if (metadata.text !== this.source)
+              throw new TypeError("Foreign compiler function source.");
+            keys.push("@start", "@end", "@strict");
+            values.push(
+              metadata.start,
+              metadata.end,
+              functionStrictness.get(value)
+            );
+          }
+          const template = templateSources.get(value);
+          if (template !== void 0) {
+            if (template !== this.source) throw new TypeError("Foreign compiler template source.");
+            keys.push("@template");
+            values.push(true);
+          }
+        }
+        const key = JSON.stringify(keys);
+        let shape = this.shapeIDs.get(key);
+        if (shape === void 0) {
+          shape = this.shapes.length;
+          this.shapes.push(this.shape(keys));
+          this.shapeIDs.set(key, shape);
+        }
+        kind = shape + 3;
+        row = this.reserve(1 + values.length);
+        this.write(row, kind);
+      }
+      seen.set(value, row);
+      if (value.type === "VariableDeclarator") {
+        this.boundaries.add(row);
+        this.persistentBoundaries.add(row);
+      }
+      if (kind === 0 || kind >= 3) {
+        const type = value.type;
+        const bodyIndex = [
+          "FunctionDeclaration",
+          "FunctionExpression",
+          "ArrowFunctionExpression"
+        ].includes(String(type)) ? keys.indexOf("body") : -1;
+        pending.push({
+          row,
+          kind,
+          values,
+          index: 0,
+          bodyIndex: bodyIndex >= 0 ? bodyIndex : void 0
+        });
+      }
+      return row + 1;
+    };
+    const reference = encode(root);
+    while (pending.length) {
+      const frame = pending[pending.length - 1];
+      if (frame.index === frame.values.length) {
+        pending.pop();
+        continue;
+      }
+      const index = frame.index++;
+      const child = encode(frame.values[index]);
+      if (retire && frame.kind === 0)
+        defineCompilerProperty(frame.values, index, { value: void 0 });
+      this.write(frame.row + (frame.kind === 0 ? 2 : 1) + index, child);
+      if (index === frame.bodyIndex && child >>> 28 === 0) {
+        this.boundaries.add(child - 1);
+        this.persistentBoundaries.add(child - 1);
+      }
+    }
+    this.boundaries.add(reference - 1);
+    if (persistent) this.persistentBoundaries.add(reference - 1);
+    if (body) this.bodies++;
+    return this.decode(reference);
+  }
+  /** Install source metadata and index numeric rows without publishing every node. */
+  dynamicNodes(root, source) {
+    if (!this.finished) throw new TypeError("Unfinished compiler storage.");
+    if (source.body !== this.source) throw new TypeError("Foreign compiler dynamic source text.");
+    if (this.dynamicSource && this.dynamicSource !== source)
+      throw new TypeError("Foreign compiler dynamic source owner.");
+    this.dynamicSource = source;
+    const rows = new NativeRowMap(), seen = /* @__PURE__ */ new Set(), pending = [root];
+    while (pending.length) {
+      const row = pending.pop();
+      if (seen.has(row)) continue;
+      seen.add(row);
+      const kind = this.read(row);
+      if (kind === 0) {
+        for (let i = 0, n = this.read(row + 1); i < n; i++) {
+          const ref = this.read(row + 2 + i);
+          if (ref >>> 28 === 0) pending.push((ref & scalarMask) - 1);
+        }
+      } else if (kind >= 3) {
+        const keys = this.shapes[kind - 3].keys;
+        const idIndex = keys.indexOf("@id"), typeIndex = keys.indexOf("type");
+        if (idIndex >= 0 && typeIndex >= 0) {
+          const id = this.decode(this.read(row + 1 + idIndex));
+          const type = this.decode(this.read(row + 1 + typeIndex));
+          if (typeof id === "number" && type !== "Module") nativeIndexMap.set(rows, id, row);
+        }
+        for (let i = 0; i < keys.length; i++) {
+          if (keys[i].startsWith("@")) continue;
+          const ref = this.read(row + 1 + i);
+          if (ref >>> 28 === 0) pending.push((ref & scalarMask) - 1);
+        }
+      }
+    }
+    for (const node of this.cache.values()) {
+      const id = node.nodeId;
+      if (typeof id === "number" && nativeIndexMap.has(rows, id))
+        dynamicNodeSources.set(node, source);
+    }
+    return new CompactNodeIndex(recordToken, rows, (row) => this.object(row));
+  }
+  scalar(value) {
+    if (value === void 0) return 268435456;
+    if (value === null) return 536870912;
+    if (typeof value === "boolean") return 805306368 + (value ? 1 : 0);
+    if (typeof value === "string") {
+      let id = this.stringIDs.get(value);
+      if (id === void 0) {
+        id = this.strings.length;
+        this.strings.push(value);
+        this.stringIDs.set(value, id);
+      }
+      return 1073741824 + id;
+    }
+    if (typeof value === "number") {
+      if (Number.isInteger(value) && !Object.is(value, -0) && Math.abs(value) <= scalarMask)
+        return (value < 0 ? 1610612736 : 1342177280) + Math.abs(value);
+      const id = this.numbers.length;
+      this.numbers.push(value);
+      return 1879048192 + id;
+    }
+    throw new TypeError("Unsupported compiler scalar.");
+  }
+  reserve(length) {
+    const row = this.used, next = row + length;
+    if (next > this.maxWords)
+      throw new SandboxError({
+        budget: "dataSize",
+        current: next,
+        limit: this.maxWords
+      });
+    this.used = next;
+    this.write(next - 1, 0);
+    return row;
+  }
+  read(index) {
+    return this.chunks[Math.floor(index / chunkLength)][index % chunkLength];
+  }
+  write(index, value) {
+    const chunk = Math.floor(index / chunkLength);
+    this.chunks[chunk] ??= new Uint32Array(chunkLength);
+    this.chunks[chunk][index % chunkLength] = value;
+  }
+  decode(reference, raw = false) {
+    const tag = reference >>> 28, payload = reference & scalarMask;
+    switch (tag) {
+      case 0:
+        return raw ? new CodeRecord(recordToken, this, payload - 1) : this.object(payload - 1);
+      case 1:
+        return void 0;
+      case 2:
+        return null;
+      case 3:
+        return payload !== 0;
+      case 4:
+        return this.strings[payload];
+      case 5:
+        return payload;
+      case 6:
+        return -payload;
+      case 7:
+        return this.numbers[payload];
+      default:
+        throw new TypeError("Invalid compiler reference.");
+    }
+  }
+  shape(keys) {
+    const descriptors = {};
+    const owner = this;
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (key === "@id") {
+        descriptors.nodeId = {
+          value: void 0,
+          writable: true,
+          enumerable: false,
+          configurable: true
+        };
+        continue;
+      }
+      if (key.startsWith("@")) continue;
+      const name = key;
+      descriptors[name] = {
+        enumerable: key !== "@id",
+        configurable: true,
+        get() {
+          const handle = handles.get(this);
+          if (handle?.owner !== owner || owner.shapes[owner.read(handle.row) - 3]?.descriptors !== descriptors)
+            throw new TypeError("Foreign compiler record receiver.");
+          const assigned = owner.overrides.get(this);
+          return assigned?.has(name) ? assigned.get(name) : owner.decode(owner.read(handle.row + 1 + i));
+        },
+        set(value) {
+          const handle = handles.get(this);
+          if (handle?.owner !== owner || owner.shapes[owner.read(handle.row) - 3]?.descriptors !== descriptors)
+            throw new TypeError("Foreign compiler record receiver.");
+          if (Object.isFrozen(this))
+            throw new TypeError("Cannot assign to a frozen compiler record.");
+          let assigned = owner.overrides.get(this);
+          if (!assigned) {
+            assigned = /* @__PURE__ */ new Map();
+            owner.overrides.set(this, assigned);
+          }
+          assigned.set(name, value);
+        }
+      };
+    }
+    descriptors[mutableRecord] = {
+      value: true,
+      writable: true,
+      configurable: true
+    };
+    function CompilerRecord() {
+      Object.defineProperties(this, descriptors);
+    }
+    CompilerRecord.prototype = Object.prototype;
+    return {
+      keys,
+      descriptors,
+      create: () => Reflect.construct(CompilerRecord, [])
+    };
+  }
+  attachMetadata(output, row, shape) {
+    const metadata = (name) => {
+      const index = shape.keys.indexOf(name);
+      return index < 0 ? void 0 : this.decode(this.read(row + 1 + index));
+    };
+    const id = metadata("@id");
+    if (id !== void 0 && this.dynamicSource && shape.keys.includes("type")) {
+      const type = metadata("type");
+      if (type !== "Module") dynamicNodeSources.set(output, this.dynamicSource);
+    }
+    if (id !== void 0)
+      Object.defineProperty(output, "nodeId", {
+        value: id,
+        writable: true,
+        enumerable: false,
+        configurable: true
+      });
+    const start = metadata("@start");
+    if (start !== void 0) {
+      functionSources.set(output, {
+        text: this.source,
+        start,
+        end: metadata("@end")
+      });
+      const strict = metadata("@strict");
+      if (strict !== void 0)
+        functionStrictness.set(
+          output,
+          strict
+        );
+    }
+    if (metadata("@template") === true)
+      templateSources.set(output, this.source);
+  }
+  object(row) {
+    const cached = this.cache.get(row);
+    if (cached !== void 0) return cached;
+    const tasks = [];
+    const make = (index) => {
+      const cached2 = this.cache.get(index);
+      if (cached2) return cached2;
+      const kind = this.read(index);
+      let output2;
+      if (kind === 0) {
+        const array = [];
+        array.length = this.read(index + 1);
+        output2 = array;
+        tasks.push({ row: index, kind, output: output2 });
+      } else if (kind === 1)
+        output2 = this.positions.span(this.read(index + 1), this.read(index + 2));
+      else if (kind === 2)
+        output2 = {
+          start: {
+            line: this.read(index + 1),
+            column: this.read(index + 2),
+            offset: this.read(index + 3)
+          },
+          end: {
+            line: this.read(index + 4),
+            column: this.read(index + 5),
+            offset: this.read(index + 6)
+          }
+        };
+      else {
+        const shape = this.shapes[kind - 3];
+        if (this.boundaries.has(index)) {
+          output2 = shape.create();
+          handles.set(output2, new CodeRecord(recordToken, this, index));
+          this.attachMetadata(output2, index, shape);
+        } else {
+          output2 = {};
+          tasks.push({ row: index, kind, output: output2 });
+        }
+      }
+      this.cache.set(index, output2);
+      if (!this.finished) handles.set(output2, new CodeRecord(recordToken, this, index));
+      return output2;
+    };
+    const value = (ref) => ref >>> 28 === 0 ? make((ref & scalarMask) - 1) : this.decode(ref);
+    const output = make(row);
+    while (tasks.length) {
+      const { row: index, kind, output: target } = tasks.pop();
+      if (kind === 0) {
+        const array = target;
+        for (let i = 0; i < array.length; i++) array[i] = value(this.read(index + 2 + i));
+      } else {
+        const shape = this.shapes[kind - 3];
+        for (let i = 0; i < shape.keys.length; i++) {
+          const key = shape.keys[i];
+          if (!key.startsWith("@"))
+            Object.defineProperty(target, key, {
+              value: value(this.read(index + 1 + i)),
+              writable: true,
+              enumerable: true,
+              configurable: true
+            });
+        }
+        this.attachMetadata(target, index, shape);
+      }
+    }
+    return output;
+  }
+  // Compiler passes use these private-owner records, not the decoded AST cache.
+  isArray(row) {
+    return this.read(row) === 0;
+  }
+  *entries(row) {
+    const kind = this.read(row), cached = this.cache.get(row);
+    if (cached) {
+      for (const key of Object.keys(cached)) yield [key, this.field(row, key)];
+      return;
+    }
+    if (kind === 0) {
+      for (let i = 0, n = this.read(row + 1); i < n; i++)
+        yield [String(i), this.decode(this.read(row + 2 + i), true)];
+    } else if (kind === 1) {
+      yield ["start", this.positions.position(this.read(row + 1))];
+      yield ["end", this.positions.position(this.read(row + 2))];
+    } else if (kind === 2) {
+      yield [
+        "start",
+        {
+          line: this.read(row + 1),
+          column: this.read(row + 2),
+          offset: this.read(row + 3)
+        }
+      ];
+      yield [
+        "end",
+        {
+          line: this.read(row + 4),
+          column: this.read(row + 5),
+          offset: this.read(row + 6)
+        }
+      ];
+    } else if (kind >= 3) {
+      const keys = this.shapes[kind - 3].keys;
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (!key.startsWith("@")) yield [key, this.decode(this.read(row + 1 + i), true)];
+      }
+    }
+  }
+  field(row, key) {
+    const kind = this.read(row), cached = this.cache.get(row);
+    if (cached) {
+      const descriptor = Object.getOwnPropertyDescriptor(cached, key);
+      if (!descriptor) return void 0;
+      if ("value" in descriptor) return descriptor.value;
+      const assigned = this.overrides.get(cached);
+      if (assigned?.has(key)) return assigned.get(key);
+      if (kind < 3) return Reflect.get(cached, key);
+      if (descriptor.get !== this.shapes[kind - 3].descriptors[key]?.get)
+        return Reflect.get(cached, key);
+    }
+    if (kind < 3) return void 0;
+    const keys = this.shapes[kind - 3].keys, index = keys.indexOf(key === "nodeId" ? "@id" : key);
+    return index < 0 ? void 0 : this.decode(this.read(row + 1 + index), true);
+  }
+  assignId(row, id) {
+    const keys = this.shapes[this.read(row) - 3].keys, index = keys.indexOf("@id");
+    if (index < 0) throw new TypeError("Compiler record is not an AST node.");
+    this.write(row + 1 + index, this.scalar(id));
+    const cached = this.cache.get(row);
+    if (cached)
+      Object.defineProperty(cached, "nodeId", {
+        value: id,
+        writable: true,
+        enumerable: false,
+        configurable: true
+      });
+  }
+  offsets(row) {
+    const span = this.field(row, "span");
+    if (!(span instanceof CodeRecord)) return void 0;
+    const kind = this.read(span.row);
+    return kind === 1 ? [this.read(span.row + 1), this.read(span.row + 2)] : kind === 2 ? [this.read(span.row + 3), this.read(span.row + 6)] : void 0;
+  }
+};
+function compilerField(value, key) {
+  const handle = record(value);
+  return handle ? handle.owner.field(handle.row, key) : value !== null && typeof value === "object" ? value[key] : void 0;
+}
+function compilerIsArray(value) {
+  const handle = record(value);
+  return handle ? handle.owner.isArray(handle.row) : Array.isArray(value);
+}
+function* compilerEntries(value) {
+  const handle = record(value);
+  if (handle) yield* handle.owner.entries(handle.row);
+  else yield* Object.entries(value);
+}
+function* compilerElements(value) {
+  if (value === null || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    yield* value;
+    return;
+  }
+  for (const [, child] of compilerEntries(value)) yield child;
+}
+function compilerAssignId(value, id) {
+  const handle = record(value);
+  if (handle) handle.owner.assignId(handle.row, id);
+  else
+    Object.defineProperty(value, "nodeId", {
+      value: id,
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+}
+function compilerOffsets(value) {
+  const handle = record(value);
+  if (handle) return handle.owner.offsets(handle.row);
+  const span = compilerField(value, "span");
+  return span ? [span.start.offset, span.end.offset] : void 0;
+}
+var CompactNodeIndex = class extends Map {
+  #rows;
+  #decode;
+  constructor(token, rows, decode) {
+    super();
+    if (token !== recordToken) throw new TypeError("Foreign compiler index authority.");
+    this.#rows = rows;
+    this.#decode = decode;
+  }
+  get size() {
+    return nativeIndexMap.size(this.#rows);
+  }
+  has(key) {
+    return nativeIndexMap.has(this.#rows, key);
+  }
+  get(key) {
+    if (nativeIndexMap.has(this, key)) return nativeIndexMap.get(this, key);
+    const row = nativeIndexMap.get(this.#rows, key);
+    return row === void 0 ? void 0 : this.#decode(row);
+  }
+  set(key, value) {
+    if (!nativeIndexMap.has(this.#rows, key)) nativeIndexMap.set(this.#rows, key, -1);
+    nativeIndexMap.set(this, key, value);
+    return this;
+  }
+  delete(key) {
+    nativeIndexMap.delete(this, key);
+    return nativeIndexMap.delete(this.#rows, key);
+  }
+  clear() {
+    nativeIndexMap.clear(this);
+    nativeIndexMap.clear(this.#rows);
+  }
+  keys() {
+    return nativeIndexMap.keys(this.#rows);
+  }
+  *values() {
+    for (const key of this.keys()) yield this.get(key);
+  }
+  *entries() {
+    for (const key of this.keys()) yield [key, this.get(key)];
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  forEach(callback, thisArg) {
+    for (const [key, value] of this) callback.call(thisArg, value, key, this);
+  }
+};
+function compactDynamicNodes(root, source) {
+  const handle = record(root);
+  return handle?.owner.dynamicNodes(handle.row, source);
+}
+
 // packages/safe-js/src/parse/bindings.ts
 function getFunctionLength(params) {
   const firstOptional = params.findIndex(
@@ -1072,66 +1908,169 @@ function* hoistedVarDeclarations(nodes) {
 
 // packages/safe-js/src/parse/private-names.ts
 function validatePrivateNames(root, inheritedNames) {
-  const pending = [{
-    value: root,
-    scope: inheritedNames === void 0 ? void 0 : { names: new Set(inheritedNames) }
-  }];
+  const pending = [
+    {
+      value: root,
+      scope: inheritedNames === void 0 ? void 0 : { names: new Set(inheritedNames) }
+    }
+  ];
   while (pending.length > 0) {
     const { value, scope, declaration } = pending.pop();
     if (value === null || typeof value !== "object") continue;
-    if (Array.isArray(value)) {
-      for (const entry of value) pending.push({ value: entry, scope });
+    if (compilerIsArray(value)) {
+      for (const entry of compilerElements(value)) pending.push({ value: entry, scope });
       continue;
     }
-    const node = value;
-    if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
-      const klass = value;
-      pending.push({ value: klass.superClass, scope });
+    const type = compilerField(value, "type");
+    if (type === "ClassDeclaration" || type === "ClassExpression") {
+      pending.push({ value: compilerField(value, "superClass"), scope });
       const inner = { names: /* @__PURE__ */ new Set(), parent: scope };
       const declarations = /* @__PURE__ */ new Map();
-      for (const element of klass.body.body) {
-        if (element.type === "StaticBlock" || element.key.type !== "PrivateIdentifier") continue;
-        const name = element.key.name;
+      const body = compilerField(value, "body");
+      for (const element of compilerElements(compilerField(body, "body"))) {
+        const key = compilerField(element, "key");
+        if (compilerField(element, "type") === "StaticBlock" || compilerField(key, "type") !== "PrivateIdentifier")
+          continue;
+        const name = compilerField(key, "name");
         if (name === "constructor") throw new Error("Private name #constructor is forbidden.");
-        const kind = element.type === "MethodDefinition" ? element.kind : "field";
+        const kind = compilerField(element, "type") === "MethodDefinition" ? compilerField(element, "kind") : "field";
+        const isStatic = compilerField(element, "static");
         const previous = declarations.get(name);
-        if (previous !== void 0 && !(previous.static === element.static && (previous.kind === "get" && kind === "set" || previous.kind === "set" && kind === "get")))
+        if (previous !== void 0 && !(previous.static === isStatic && (previous.kind === "get" && kind === "set" || previous.kind === "set" && kind === "get")))
           throw new Error(`Duplicate private name #${name}.`);
-        declarations.set(name, { kind: previous === void 0 ? kind : "pair", static: element.static });
+        declarations.set(name, {
+          kind: previous === void 0 ? kind : "pair",
+          static: isStatic
+        });
         inner.names.add(name);
       }
-      pending.push({ value: klass.body, scope: inner });
+      pending.push({ value: body, scope: inner });
       continue;
     }
-    if (node.type === "PrivateIdentifier") {
+    if (type === "PrivateIdentifier") {
       if (declaration) continue;
+      const name = String(compilerField(value, "name"));
       let owner = scope;
-      while (owner !== void 0 && !owner.names.has(String(node.name))) owner = owner.parent;
-      if (owner === void 0) throw new Error(`Undeclared private name #${String(node.name)}.`);
+      while (owner !== void 0 && !owner.names.has(name)) owner = owner.parent;
+      if (owner === void 0) throw new Error(`Undeclared private name #${name}.`);
       continue;
     }
-    if (node.type === "MemberExpression") {
-      const property = node.property;
-      if (property.type === "PrivateIdentifier" && node.object.type === "Super")
+    if (type === "MemberExpression") {
+      const property = compilerField(value, "property");
+      if (compilerField(property, "type") === "PrivateIdentifier" && compilerField(compilerField(value, "object"), "type") === "Super")
         throw new Error("super cannot access a private name.");
     }
-    if (node.type === "UnaryExpression" && node.operator === "delete") {
-      const argument = node.argument;
-      if (argument.type === "MemberExpression" && argument.property.type === "PrivateIdentifier")
+    if (type === "UnaryExpression" && compilerField(value, "operator") === "delete") {
+      const argument = compilerField(value, "argument");
+      if (compilerField(argument, "type") === "MemberExpression" && compilerField(compilerField(argument, "property"), "type") === "PrivateIdentifier")
         throw new Error("Private elements cannot be deleted.");
     }
-    for (const [key, child] of Object.entries(node)) {
+    for (const [key, child] of compilerEntries(value)) {
       if (key === "span") continue;
       pending.push({
         value: child,
         scope,
-        declaration: key === "key" && (node.type === "MethodDefinition" || node.type === "PropertyDefinition")
+        declaration: key === "key" && (type === "MethodDefinition" || type === "PropertyDefinition")
       });
     }
   }
 }
 
+// packages/safe-js/src/parse/compact-tokens.ts
+var types = [
+  "identifier",
+  "private-identifier",
+  "keyword",
+  "escaped-keyword",
+  "numeric",
+  "regex",
+  "string",
+  "template",
+  "punctuator",
+  "eof"
+];
+var stride = 3;
+var legacyEscape = 256;
+var tokenCacheSize = 256;
+var CompactTokens = class {
+  constructor(sourcePositions) {
+    this.sourcePositions = sourcePositions;
+  }
+  sourcePositions;
+  rows = new Uint32Array(1024 * stride);
+  values = [];
+  templates = /* @__PURE__ */ new Map();
+  tokens = /* @__PURE__ */ new Map();
+  last;
+  // Only indexing, iteration, length, push and at are used by the lexer/parser.
+  // Historical tokens are materialized on demand in a bounded cache.
+  indexed = new Proxy([], {
+    get: (target, key, receiver) => {
+      if (key === "length") return this.values.length;
+      if (key === "push") return this.push;
+      const index = arrayIndex(key);
+      return index === void 0 ? Reflect.get(target, key, receiver) : this.get(index);
+    },
+    set: () => {
+      throw new TypeError("Compiler token rows cannot be reassigned.");
+    }
+  });
+  finish() {
+    this.rows = this.rows.slice(0, this.values.length * stride);
+    if (this.last) {
+      this.last.start = this.sourcePositions.position(this.last.start.offset);
+      this.last.end = this.sourcePositions.position(this.last.end.offset);
+    }
+    return this.indexed;
+  }
+  push = (token) => {
+    if (this.last !== void 0) {
+      const previous = this.values.length - 1;
+      if (this.last.legacyEscape) this.rows[previous * stride + 2] |= legacyEscape;
+      if (this.last.templateExpressions !== void 0)
+        this.templates.set(previous, this.last.templateExpressions);
+    }
+    const index = this.values.length;
+    const base = index * stride;
+    if (base + stride > this.rows.length) {
+      const rows = new Uint32Array(this.rows.length * 2);
+      rows.set(this.rows);
+      this.rows = rows;
+    }
+    this.rows.set([token.start.offset, token.end.offset, types.indexOf(token.type)], base);
+    this.values.push(token.value);
+    this.last = token;
+    return index + 1;
+  };
+  get(index) {
+    if (index >= this.values.length) return void 0;
+    if (index === this.values.length - 1) return this.last;
+    const cached = this.tokens.get(index);
+    if (cached !== void 0) return cached;
+    const base = index * stride;
+    const bits = this.rows[base + 2];
+    const token = {
+      type: types[bits & 255],
+      value: this.values[index],
+      start: this.sourcePositions.position(this.rows[base]),
+      end: this.sourcePositions.position(this.rows[base + 1])
+    };
+    if (bits & legacyEscape) token.legacyEscape = true;
+    const expressions = this.templates.get(index);
+    if (expressions !== void 0) token.templateExpressions = expressions;
+    if (this.tokens.size === tokenCacheSize) this.tokens.delete(this.tokens.keys().next().value);
+    this.tokens.set(index, token);
+    return token;
+  }
+};
+function arrayIndex(key) {
+  if (typeof key !== "string") return void 0;
+  const index = Number(key);
+  return Number.isSafeInteger(index) && index >= 0 && String(index) === key ? index : void 0;
+}
+
 // packages/safe-js/src/parse/tokenizer.ts
+var freezePosition = Object.freeze;
 var KEYWORDS = /* @__PURE__ */ new Set([
   "class",
   "extends",
@@ -1239,26 +2178,33 @@ function tokenize(source, options = {}) {
   const lexer = new Lexer(source, options);
   return lexer.tokenize();
 }
+function tokenizeCompact(source, options, positions) {
+  const tokens = new CompactTokens(positions);
+  new Lexer(source, { ...options, sharedPositions: true }, tokens.indexed).tokenize();
+  return tokens.finish();
+}
 function collectComments(source) {
   const comments = [];
   tokenize(source, { allowRegexLiterals: true, statementList: true, comments });
   return comments;
 }
 var Lexer = class {
-  constructor(source, options) {
+  constructor(source, options, tokens = []) {
     this.source = source;
     this.options = options;
+    this.tokens = tokens;
   }
   source;
   options;
+  tokens;
   index = 0;
   line = 1;
   column = 1;
-  tokens = [];
   groupingState = { stack: [], classHeads: [], tokenCount: 0 };
   lastClosedStatementBoundary = false;
   legacyStringEscape = false;
   lineHasToken = false;
+  lastPosition;
   tokenize() {
     while (!this.isAtEnd()) {
       this.skipTrivia();
@@ -2032,11 +2978,15 @@ var Lexer = class {
     return this.index >= this.source.length;
   }
   position() {
-    return {
+    if (this.options.sharedPositions && this.lastPosition?.offset === this.index)
+      return this.lastPosition;
+    const position = {
       line: this.line,
       column: this.column,
       offset: this.index
     };
+    if (!this.options.sharedPositions) return position;
+    return this.lastPosition = freezePosition(position);
   }
   advance() {
     if (this.isAtEnd()) {
@@ -2337,15 +3287,39 @@ function compareBySourceOrder(left, right) {
 function isAstNode(value) {
   return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string" && "span" in value && typeof value.span?.start.offset === "number" && typeof value.span?.end.offset === "number";
 }
-
-// packages/safe-js/src/parse/function-source.ts
-var functionSources = /* @__PURE__ */ new WeakMap();
-var templateSources = /* @__PURE__ */ new WeakMap();
-var functionStrictness = /* @__PURE__ */ new WeakMap();
-var evalFunctionDeclarations = /* @__PURE__ */ new WeakSet();
-var dynamicSourceRecords = /* @__PURE__ */ new WeakSet();
-var dynamicNodeSources = /* @__PURE__ */ new WeakMap();
-var dynamicValueSources = /* @__PURE__ */ new WeakMap();
+function assignCompactIds(root) {
+  const stack = [root];
+  let nextId = 0;
+  const isNode = (value) => value !== null && typeof value === "object" && typeof compilerField(value, "type") === "string" && compilerOffsets(value) !== void 0;
+  while (stack.length) {
+    const node = stack.pop();
+    if (!isNode(node) || compilerField(node, "nodeId") !== void 0) continue;
+    compilerAssignId(node, nextId++);
+    const type = compilerField(node, "type");
+    const children = [];
+    const add = (value) => {
+      if (isNode(value)) children.push(value);
+      else if (compilerIsArray(value)) {
+        for (const child of compilerElements(value))
+          if (isNode(child)) children.push(child);
+      }
+    };
+    if (type === "UnaryExpression") add(compilerField(node, "argument"));
+    else if (type === "ExpressionStatement")
+      add(compilerField(node, "expression"));
+    else if (type === "Module") add(compilerField(node, "body"));
+    else {
+      for (const [key, child] of compilerEntries(node))
+        if (key !== "nodeId" && key !== "span" && key !== "type") add(child);
+      children.sort((left, right) => {
+        const a = compilerOffsets(left), b = compilerOffsets(right);
+        return a[0] - b[0] || a[1] - b[1];
+      });
+    }
+    for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]);
+  }
+  return root;
+}
 
 // packages/safe-js/src/parse/syntax-diagnostic.ts
 var syntaxDiagnostics = /* @__PURE__ */ new WeakMap();
@@ -3142,6 +4116,7 @@ function allHexDigits(value) {
 }
 
 // packages/safe-js/src/parse/parser.ts
+var isFrozenPosition = Object.isFrozen;
 var MAX_CONDITIONAL_EXPRESSION_DEPTH = 256;
 var MAX_IF_STATEMENT_DEPTH = 2048;
 var STRICT_BINDING_NAMES = /* @__PURE__ */ new Set(["eval", "arguments", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"]);
@@ -3232,7 +4207,7 @@ function parseModule(source, filename = "<input>", owner) {
     compilation.dispose();
   }
 }
-function parseSourceModule(source, filename = "<input>", owner) {
+function parseSourceModule(source, filename = "<input>", owner, options = {}) {
   const compilation = new CompileScope(owner);
   const syntax = { imports: [], exports: [], moduleRequests: [] };
   let parser;
@@ -3241,8 +4216,10 @@ function parseSourceModule(source, filename = "<input>", owner) {
     if (limit !== void 0 && source.length > limit)
       throw new SandboxError({ budget: "stringLength", current: source.length, limit });
     owner?.budget.visitNode(source.length);
+    const tokenOptions = { allowRegexLiterals: true, statementList: true, compilation, sharedPositions: options.sharedPositions };
+    const tokens = options.compactAst ? tokenizeCompact(source, tokenOptions, new CompactSourcePositions(source)) : tokenize(source, tokenOptions);
     parser = new Parser(
-      tokenize(source, { allowRegexLiterals: true, statementList: true, compilation }),
+      tokens,
       source,
       compilation,
       "top-level",
@@ -3256,7 +4233,10 @@ function parseSourceModule(source, filename = "<input>", owner) {
       true,
       syntax
     );
-    const module = assignIds(parser.parseModule());
+    if (options.compactAst) parser.enableCompactAst();
+    const parsed = parser.parseModule();
+    parser.finishAstStorage();
+    const module = (options.compactAst ? assignCompactIds : assignIds)(parsed);
     if (source.includes("#")) validatePrivateNames(module);
     let hasTLA = false;
     const pending = [module];
@@ -3264,9 +4244,10 @@ function parseSourceModule(source, filename = "<input>", owner) {
       const node = pending.pop();
       if (node === null || typeof node !== "object") continue;
       owner?.budget.visitNode();
-      if ("type" in node && ["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"].includes(String(node.type))) continue;
-      if ("type" in node && (node.type === "AwaitExpression" || "await" in node && node.await === true || node.type === "VariableDeclaration" && "disposal" in node && node.disposal === "async")) hasTLA = true;
-      pending.push(...Object.values(node));
+      const type = compilerField(node, "type");
+      if (["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"].includes(String(type))) continue;
+      if (type !== void 0 && (type === "AwaitExpression" || compilerField(node, "await") === true || type === "VariableDeclaration" && compilerField(node, "disposal") === "async")) hasTLA = true;
+      for (const child of compilerElements(node)) pending.push(child);
     }
     return { ...syntax, module, hasTLA, requests: [...new Set(syntax.moduleRequests.map((request) => request.specifier))] };
   } catch (error) {
@@ -3280,7 +4261,7 @@ function parseSourceModule(source, filename = "<input>", owner) {
     compilation.dispose();
   }
 }
-function parseExecutableModule(source, filename = "<input>", owner) {
+function parseExecutableModule(source, filename = "<input>", owner, importSpecifiers) {
   const compilation = new CompileScope(owner);
   try {
     const result = assignIds(
@@ -3289,7 +4270,10 @@ function parseExecutableModule(source, filename = "<input>", owner) {
         source,
         compilation,
         "top-level",
-        { ...ordinaryFunctionContext, newTarget: false, requireAsyncAwait: true }
+        { ...ordinaryFunctionContext, newTarget: false, requireAsyncAwait: true },
+        true,
+        void 0,
+        new Set(importSpecifiers)
       ).parseModule()
     );
     throwIfImportMetaAssignment(result);
@@ -3307,7 +4291,7 @@ function parseExecutableModule(source, filename = "<input>", owner) {
     compilation.dispose();
   }
 }
-function parseEvalScript(source, context = {}, owner, filename = "<eval>") {
+function parseEvalScript(source, context = {}, owner, filename = "<eval>", options = {}) {
   const compilation = new CompileScope(owner);
   try {
     const limit = owner?.budget.limits.stringLength;
@@ -3315,14 +4299,16 @@ function parseEvalScript(source, context = {}, owner, filename = "<eval>") {
       throw new SandboxError({ budget: "stringLength", current: source.length, limit });
     if (owner !== void 0) for (let index = 0; index < source.length; index++) owner.budget.visitNode();
     const grammar = { await: false, yield: false, strict: context.strict === true };
-    const parser = new Parser(tokenize(source, {
+    const tokenOptions = {
       allowRegexLiterals: true,
       statementList: true,
       allowLegacyNumbers: true,
       allowLegacyEscapes: true,
       allowHtmlComments: true,
       compilation
-    }), source, compilation, "normal", {
+    };
+    const tokens = options.compactAst ? tokenizeCompact(source, tokenOptions, new CompactSourcePositions(source)) : tokenize(source, tokenOptions);
+    const parser = new Parser(tokens, source, compilation, "normal", {
       grammar,
       newTarget: context.newTarget === true,
       superProperty: context.superProperty === true,
@@ -3332,7 +4318,10 @@ function parseEvalScript(source, context = {}, owner, filename = "<eval>") {
       await: false,
       strictAwait: true
     }, false);
-    const node = assignIds(parser.parseScript());
+    if (options.compactAst) parser.enableCompactAst();
+    const parsed = parser.parseScript();
+    parser.finishAstStorage();
+    const node = (options.compactAst ? assignCompactIds : assignIds)(parsed);
     if (source.includes("#")) validatePrivateNames(node, context.privateNames);
     for (const statement of node.body) {
       if (statement.type === "FunctionDeclaration") evalFunctionDeclarations.add(statement);
@@ -3394,7 +4383,7 @@ var ordinaryFunctionContext = {
   await: true
 };
 var Parser = class {
-  constructor(tokens, source, compilation, functionContext = "top-level", lexicalContext = { ...ordinaryFunctionContext, newTarget: false }, allowImportMeta = true, moduleSyntax) {
+  constructor(tokens, source, compilation, functionContext = "top-level", lexicalContext = { ...ordinaryFunctionContext, newTarget: false }, allowImportMeta = true, moduleSyntax, importSpecifiers) {
     this.tokens = tokens;
     this.source = source;
     this.compilation = compilation;
@@ -3402,6 +4391,7 @@ var Parser = class {
     this.lexicalContext = lexicalContext;
     this.allowImportMeta = allowImportMeta;
     this.moduleSyntax = moduleSyntax;
+    this.importSpecifiers = importSpecifiers;
     this.functionScopes.add(this.scopes[0]);
   }
   tokens;
@@ -3411,6 +4401,7 @@ var Parser = class {
   lexicalContext;
   allowImportMeta;
   moduleSyntax;
+  importSpecifiers;
   index = 0;
   allowIn = true;
   breakableDepth = 0;
@@ -3425,6 +4416,14 @@ var Parser = class {
   varNames = /* @__PURE__ */ new WeakMap();
   sourceExportNames = /* @__PURE__ */ new Set();
   sourceLocalExports = /* @__PURE__ */ new Map();
+  astStorage;
+  enableCompactAst() {
+    if (this.astStorage) throw new TypeError("Compiler body storage is already enabled.");
+    this.astStorage = new CompactModuleAst(this.source);
+  }
+  finishAstStorage() {
+    this.astStorage?.finish();
+  }
   get position() {
     return (this.tokens[this.index] ?? this.tokens[this.tokens.length - 1]).start;
   }
@@ -3438,6 +4437,8 @@ var Parser = class {
       start: node.span.start.offset,
       end: node.span.end.offset
     });
+    if (this.astStorage && node.type !== "ClassDeclaration" && node.type !== "ClassExpression" && node.body.span.end.offset - node.body.span.start.offset >= 512)
+      node.body = this.astStorage.pack(node.body, true, true);
     return node;
   }
   parseDynamicParameters() {
@@ -3475,7 +4476,8 @@ var Parser = class {
         }
         if (this.isExportToken(token)) {
           const statement2 = this.parseSourceExport();
-          if (statement2 !== void 0) body.push(statement2);
+          if (statement2 !== void 0)
+            body.push(this.astStorage?.pack(statement2, false, true) ?? statement2);
           continue;
         }
       }
@@ -3484,26 +4486,29 @@ var Parser = class {
       while (statement.type !== "EmptyStatement" && this.consumePunctuator(";") !== void 0) {
         continue;
       }
+      if (this.astStorage) body[body.length - 1] = this.astStorage.pack(statement, false, true);
     }
     for (const [name, identifier] of this.sourceLocalExports) {
       if (!this.scopes[0].has(name) && !this.varNames.get(this.scopes[0])?.has(name))
         throw new Error(`Export '${name}' is not defined at line ${identifier.span.start.line}, column ${identifier.span.start.column}.`);
     }
     const end = this.currentToken().end;
-    return {
+    const module = {
       type: "Module",
       body,
       span: createSpan2(body[0]?.span.start ?? end, body[body.length - 1]?.span.end ?? end)
     };
+    return this.astStorage?.pack(module, false, true) ?? module;
   }
   parseScript() {
     const body = this.parseStatementList(void 0, true);
     const end = this.currentToken().end;
-    return {
+    const module = {
       type: "Module",
       body,
       span: createSpan2(body[0]?.span.start ?? end, body[body.length - 1]?.span.end ?? end)
     };
+    return this.astStorage?.pack(module, false, true) ?? module;
   }
   parseExpressionOnly() {
     const expression = this.parseExpression({ allowSequence: true }).node;
@@ -3786,6 +4791,8 @@ var Parser = class {
       while (statement.type !== "EmptyStatement" && this.consumePunctuator(";") !== void 0) {
         if (++semicolons > 1) directivePrologue = false;
       }
+      if (start === void 0 && this.astStorage)
+        body[body.length - 1] = this.astStorage.pack(statement, false, true);
     }
     return body;
   }
@@ -4478,7 +5485,7 @@ var Parser = class {
     }
     this.index += 1;
     const source = createStringLiteral(sourceToken);
-    assertBareImportSpecifier(source);
+    if (!this.importSpecifiers?.has(source.value)) assertBareImportSpecifier(source);
     return {
       type: "ImportDeclaration",
       specifiers,
@@ -7389,14 +8396,16 @@ function positionWithinRaw(base, raw, index) {
     }
     column += 1;
   }
-  return { line, column, offset };
+  const position = { line, column, offset };
+  return compactDerivedPosition(base, position) ?? position;
 }
 function rebasePosition(position, base) {
-  return {
+  const rebased = {
     line: base.line + position.line - 1,
     column: position.line === 1 ? base.column + position.column - 1 : position.column,
     offset: base.offset + position.offset
   };
+  return compactDerivedPosition(base, rebased) ?? rebased;
 }
 function isLiteralPropertyKey(token) {
   return token.type === "numeric" || token.type === "string";
@@ -7416,9 +8425,9 @@ function assertAllowedIdentifierReference(token, strict) {
   }
 }
 function createSpan2(start, end) {
-  return {
-    start: { ...start },
-    end: { ...end }
+  return compactSourceSpan(start, end) ?? {
+    start: isFrozenPosition(start) ? start : { ...start },
+    end: isFrozenPosition(end) ? end : { ...end }
   };
 }
 function hasLineBreakBetween(left, right) {
@@ -7575,10 +8584,6 @@ var numericTypedArrayConstructors = {
 };
 
 export {
-  getFunctionLength,
-  boundIdentifiers,
-  containsParameterExpression,
-  hoistedVarDeclarations,
   internalSymbols,
   sandboxErrorNames,
   sandboxErrorTypes,
@@ -7596,18 +8601,22 @@ export {
   SandboxError,
   isFatalSandboxError,
   Budget,
-  allocateRegexSteps,
-  CompileScope,
-  RegexCompileGuard,
-  regexCompiledData,
-  tokenize,
-  collectComments,
   functionSources,
   functionStrictness,
   evalFunctionDeclarations,
   dynamicSourceRecords,
   dynamicNodeSources,
   dynamicValueSources,
+  compactDynamicNodes,
+  getFunctionLength,
+  boundIdentifiers,
+  containsParameterExpression,
+  hoistedVarDeclarations,
+  CompileScope,
+  RegexCompileGuard,
+  regexCompiledData,
+  tokenize,
+  collectComments,
   splitSourceLines,
   ParseError,
   formatParseError,
@@ -7636,4 +8645,4 @@ export {
   Float16Array2 as Float16Array,
   numericTypedArrayConstructors
 };
-//# sourceMappingURL=chunk-ILYJBA2D.js.map
+//# sourceMappingURL=chunk-RYVHEOHM.js.map