poe-code 14.0.74 → 14.0.76

package/dist/index.js

@@ -120228,7 +120228,15 @@ var init_budget2 = __esm({
 
 // packages/safe-js/src/interp/regex/compile-guard.ts
 function regexCompiledData(pattern) {
-  return compiledData.get(pattern) ?? { units: 10 + pattern.source.length + measureNode(pattern.body) };
+  return compiledData.get(pattern) ?? { units: measurePattern(pattern) };
+}
+function measurePattern(pattern) {
+  let units = 10 + pattern.source.length + measureNode(pattern.body);
+  if (pattern.groups !== void 0) {
+    units += 1;
+    for (const [name, indices] of Object.entries(pattern.groups)) units += name.length + 2 + indices.length;
+  }
+  return units;
 }
 function measureNode(node) {
   switch (node.type) {
@@ -120237,13 +120245,18 @@ function measureNode(node) {
       return 2;
     case "literal":
       return 3 + node.value.length;
+    case "namedBackreference":
+      return 3 + node.name.length;
     case "anchor":
     case "wordBoundary":
+    case "backreference":
       return 3;
     case "characterClass": {
       let usage = 5 + node.items.length;
+      if (node.operation !== void 0) usage += 1 + node.operation.length;
+      if (node.strings !== void 0) usage += 1;
       for (const item of node.items) {
-        usage += item.type === "character" ? 3 + item.value.length : item.type === "range" ? 4 + item.from.length + item.to.length : 4;
+        usage += item.type === "character" ? 3 + item.value.length : item.type === "range" ? 4 + item.from.length + item.to.length : item.type === "property" ? 4 + item.value.length + (item.strings === void 0 ? 0 : 1) : item.type === "set" ? 3 + measureNode({ type: "characterClass", ...item.value }) : item.type === "strings" ? 4 + item.values.reduce((total2, value) => total2 + 1 + value.length, 0) : 4;
       }
       return usage;
     }
@@ -120255,7 +120268,10 @@ function measureNode(node) {
       return usage;
     }
     case "group":
-      return 5 + measureNode(node.body);
+      return 5 + measureNode(node.body) + (node.name === void 0 ? 0 : 1 + node.name.length) + (node.modifiers === void 0 ? 0 : 2 + Object.keys(node.modifiers).length);
+    case "lookahead":
+    case "lookbehind":
+      return 4 + measureNode(node.body);
     case "quantifier":
       return (Object.hasOwn(node, "max") ? 6 : 5) + measureNode(node.body);
   }
@@ -120374,7 +120390,7 @@ var init_compile_guard = __esm({
         this.work(flags.length);
       }
       retain(pattern, valueUnits = 0) {
-        const units = 10 + pattern.source.length + measureNode(pattern.body);
+        const units = measurePattern(pattern);
         if (this.ticket !== void 0) {
           this.ticket.owner.budget.resizeCompileTicket(this.ticket, units + valueUnits);
         }
@@ -120962,7 +120978,7 @@ var init_tokenizer2 = __esm({
             this.advance();
             this.advance();
             this.consumeDigitsForBase(isHexDigit, "hexadecimal");
-            this.rejectBigIntSuffix();
+            if (this.currentChar() === "n") this.advance();
             this.rejectInvalidNumericLiteralContinuation();
             return this.source.slice(start.offset, this.index);
           }
@@ -120970,7 +120986,7 @@ var init_tokenizer2 = __esm({
             this.advance();
             this.advance();
             this.consumeDigitsForBase(isBinaryDigit, "binary");
-            this.rejectBigIntSuffix();
+            if (this.currentChar() === "n") this.advance();
             this.rejectInvalidNumericLiteralContinuation();
             return this.source.slice(start.offset, this.index);
           }
@@ -120978,7 +120994,7 @@ var init_tokenizer2 = __esm({
             this.advance();
             this.advance();
             this.consumeDigitsForBase(isOctalDigit, "octal");
-            this.rejectBigIntSuffix();
+            if (this.currentChar() === "n") this.advance();
             this.rejectInvalidNumericLiteralContinuation();
             return this.source.slice(start.offset, this.index);
           }
@@ -120992,6 +121008,11 @@ var init_tokenizer2 = __esm({
           }
         }
         this.consumeDecimalDigits();
+        if (this.currentChar() === "n") {
+          this.advance();
+          this.rejectInvalidNumericLiteralContinuation();
+          return this.source.slice(start.offset, this.index);
+        }
         if (this.currentChar() === "." && (this.peekChar(1) !== "." || this.peekChar(2) !== ".")) {
           this.advance();
           this.consumeOptionalDecimalDigits();
@@ -121090,7 +121111,7 @@ var init_tokenizer2 = __esm({
       }
       rejectBigIntSuffix() {
         if (this.currentChar() === "n") {
-          this.syntaxError("BigInt not supported", this.position());
+          this.syntaxError("BigInt literals cannot contain a fraction or exponent", this.position());
         }
       }
       rejectInvalidNumericLiteralContinuation() {
@@ -121719,10 +121740,11 @@ function parseRegex(source, flags = "", compilation, valueUnits = 0) {
     guard.checkLength(flags.length, true);
     guard.allocate(5 + valueUnits);
     const parsedFlags = parseFlags(flags, guard);
-    const parser = new RegexParser(source, guard);
+    const parser = new RegexParser(source, guard, parsedFlags.unicode || parsedFlags.unicodeSets, parsedFlags.unicodeSets);
     const body = parser.parse();
     guard.allocate(5 + source.length);
     const pattern = { source, flags: parsedFlags, captureCount: parser.captureCount, body };
+    if (Object.keys(parser.namedGroups).length > 0) pattern.groups = parser.namedGroups;
     guard.retain(pattern, valueUnits);
     return pattern;
   } finally {
@@ -121732,16 +121754,24 @@ function parseRegex(source, flags = "", compilation, valueUnits = 0) {
 function parseFlags(flags, guard) {
   guard.allocate(10);
   const parsed = {
+    hasIndices: false,
     global: false,
+    sticky: false,
+    unicode: false,
+    unicodeSets: false,
     ignoreCase: false,
     multiline: false,
     dotAll: false
   };
   const names = {
+    d: "hasIndices",
     g: "global",
     i: "ignoreCase",
     m: "multiline",
-    s: "dotAll"
+    s: "dotAll",
+    y: "sticky",
+    u: "unicode",
+    v: "unicodeSets"
   };
   for (let position = 0; position < flags.length; position += 1) {
     guard.work(1);
@@ -121755,6 +121785,7 @@ function parseFlags(flags, guard) {
     }
     parsed[name] = true;
   }
+  if (parsed.unicode && parsed.unicodeSets) throw new SyntaxError("Unicode flags u and v cannot be combined");
   return parsed;
 }
 function isDecimalDigit2(character2) {
@@ -121768,20 +121799,29 @@ function allHexDigits(value) {
   }
   return true;
 }
-var RegexParser;
+var groupNameStart, groupNamePart, RegexParser;
 var init_parse5 = __esm({
   "packages/safe-js/src/interp/regex/parse.ts"() {
     "use strict";
     init_compile_guard();
+    groupNameStart = /^[$_\p{ID_Start}]$/u;
+    groupNamePart = /^[$\u200c\u200d\p{ID_Continue}]$/u;
     RegexParser = class {
-      constructor(source, guard) {
+      constructor(source, guard, unicode, unicodeSets) {
         this.source = source;
         this.guard = guard;
+        this.unicode = unicode;
+        this.unicodeSets = unicodeSets;
       }
       source;
       guard;
+      unicode;
+      unicodeSets;
       captureCount = 0;
       cursor = 0;
+      totalCaptureCount;
+      hasNamedCaptures = false;
+      namedGroups = /* @__PURE__ */ Object.create(null);
       get position() {
         return this.cursor;
       }
@@ -121797,6 +121837,7 @@ var init_parse5 = __esm({
           }
           this.fail(`Unexpected character '${this.peek()}'`);
         }
+        if (this.unicode || Object.keys(this.namedGroups).length > 0) this.validateNamedGroups(body);
         return body;
       }
       parseAlternation() {
@@ -121830,15 +121871,20 @@ var init_parse5 = __esm({
       parseQuantifiedAtom() {
         const quantifierStart = this.position;
         const current = this.peek();
-        if (current === "*" || current === "+" || current === "?" || current === "{") {
+        if (current === "*" || current === "+" || current === "?" || current === "{" && this.unicode) {
           this.fail("Nothing to repeat", quantifierStart);
         }
+        if (current === "{") {
+          const quantifier2 = this.parseQuantifier();
+          this.position = quantifierStart;
+          if (quantifier2 !== void 0) this.fail("Nothing to repeat", quantifierStart);
+        }
         const body = this.parseAtom();
         const quantifier = this.parseQuantifier();
         if (quantifier === void 0) {
           return body;
         }
-        if (body.type === "anchor" || body.type === "wordBoundary") {
+        if (body.type === "anchor" || body.type === "wordBoundary" || body.type === "lookbehind" || this.unicode && body.type === "lookahead") {
           this.fail("Invalid quantifier target", quantifierStart);
         }
         const greedy = this.peek() !== "?";
@@ -121849,7 +121895,7 @@ var init_parse5 = __esm({
         return { type: "quantifier", body, ...quantifier, greedy };
       }
       parseAtom() {
-        const character2 = this.take();
+        const character2 = this.takeCharacter();
         switch (character2) {
           case ".":
             this.guard.allocate(2);
@@ -121867,12 +121913,17 @@ var init_parse5 = __esm({
           case "\\":
             return this.parseEscape(false, this.position - 1);
           default:
+            if (this.unicode && (character2 === "]" || character2 === "}")) this.fail("Invalid Unicode pattern character");
             this.guard.allocate(3 + character2.length);
             return { type: "literal", value: character2 };
         }
       }
       parseGroup(start) {
         let capturing = true;
+        let name;
+        let modifiers;
+        let assertionNegated;
+        let lookbehind = false;
         if (this.peek() === "?") {
           this.guard.allocate(Math.min(3, this.source.length - this.position));
           this.guard.work(Math.min(3, this.source.length - this.position));
@@ -121881,17 +121932,33 @@ var init_parse5 = __esm({
             capturing = false;
             this.position += 2;
           } else if (extension.startsWith("?=") || extension.startsWith("?!")) {
-            this.fail("Lookahead is not supported", start);
+            capturing = false;
+            assertionNegated = extension.startsWith("?!");
+            this.position += 2;
           } else if (extension.startsWith("?<=") || extension.startsWith("?<!")) {
-            this.fail("Lookbehind is not supported", start);
+            capturing = false;
+            assertionNegated = extension.startsWith("?<!");
+            lookbehind = true;
+            this.position += 3;
           } else if (extension.startsWith("?<")) {
-            this.fail("Named groups are not supported", start);
+            this.position += 2;
+            name = this.parseGroupName(start);
+          } else if ("ims-".includes(extension[1] ?? "") && extension.length > 1) {
+            capturing = false;
+            this.position++;
+            modifiers = this.parseModifiers(start);
           } else {
             this.fail("Unsupported group construct", start);
           }
         }
         if (capturing) this.guard.allocate(1);
         const index = capturing ? ++this.captureCount : void 0;
+        if (name !== void 0) {
+          this.guard.allocate(name.length + 2);
+          const indices = this.namedGroups[name] ??= [];
+          this.guard.array(indices.length + 1);
+          indices.push(index);
+        }
         this.guard.enterGroup();
         let body;
         try {
@@ -121903,10 +121970,40 @@ var init_parse5 = __esm({
           this.fail("Unterminated group", start);
         }
         this.position += 1;
+        if (assertionNegated !== void 0) {
+          this.guard.allocate(4);
+          return { type: lookbehind ? "lookbehind" : "lookahead", negated: assertionNegated, body };
+        }
         this.guard.allocate(5);
-        return { type: "group", capturing, index, body };
+        return {
+          type: "group",
+          capturing,
+          index,
+          body,
+          ...name === void 0 ? {} : { name },
+          ...modifiers === void 0 ? {} : { modifiers }
+        };
+      }
+      parseModifiers(start) {
+        this.guard.allocate(2);
+        const modifiers = {};
+        let enabled = true;
+        while (!this.atEnd() && this.peek() !== ":") {
+          const flag = this.take();
+          if (flag === "-" && enabled) {
+            enabled = false;
+            continue;
+          }
+          const name = flag === "i" ? "ignoreCase" : flag === "m" ? "multiline" : flag === "s" ? "dotAll" : void 0;
+          if (name === void 0 || Object.hasOwn(modifiers, name)) this.fail("Invalid regex modifiers", start);
+          this.guard.allocate(1);
+          modifiers[name] = enabled;
+        }
+        if (this.take() !== ":" || Object.keys(modifiers).length === 0) this.fail("Invalid regex modifiers", start);
+        return modifiers;
       }
       parseCharacterClass(start) {
+        if (this.unicodeSets) return { type: "characterClass", ...this.parseUnicodeSet(start) };
         const negated = this.peek() === "^";
         if (negated) {
           this.position += 1;
@@ -121926,9 +122023,13 @@ var init_parse5 = __esm({
             this.position += 1;
             const right = this.parseClassItem(start);
             if (left.type !== "character" || right.type !== "character") {
-              this.fail("Character class ranges require literal endpoints", rangePosition);
+              if (this.unicode) this.fail("Character class ranges require literal endpoints", rangePosition);
+              this.guard.array(items.length + 3);
+              this.guard.allocate(4);
+              items.push(left, { type: "character", value: "-" }, right);
+              continue;
             }
-            if (left.value.charCodeAt(0) > right.value.charCodeAt(0)) {
+            if (left.value.codePointAt(0) > right.value.codePointAt(0)) {
               this.fail("Character class range is out of order", rangePosition);
             }
             this.guard.allocate(4 + left.value.length + right.value.length);
@@ -121957,26 +122058,193 @@ var init_parse5 = __esm({
           this.fail("Unsupported character class escape", escapeStart);
         }
         this.guard.allocate(4);
-        return { type: "character", value: this.take() };
+        return { type: "character", value: this.takeCharacter() };
+      }
+      parseUnicodeSet(start) {
+        this.guard.enterGroup();
+        try {
+          const negated = this.peek() === "^";
+          if (negated) this.position++;
+          this.guard.allocate(5);
+          const items = [];
+          let operation;
+          while (!this.atEnd() && this.peek() !== "]") {
+            this.guard.array(items.length + 1);
+            let item = this.parseUnicodeSetItem(start);
+            if (this.peek() === "-" && this.source[this.position + 1] !== "-") {
+              this.position++;
+              const right = this.parseUnicodeSetItem(start);
+              if (item.type !== "character" || right.type !== "character") this.fail("Invalid set range", start);
+              if (item.value.codePointAt(0) > right.value.codePointAt(0)) this.fail("Set range is out of order", start);
+              this.guard.allocate(4 + item.value.length + right.value.length);
+              item = { type: "range", from: item.value, to: right.value };
+            }
+            if (operation !== void 0 && item.type === "range") this.fail("Set operations require nested ranges", start);
+            items.push(item);
+            const operator = this.source.slice(this.position, this.position + 2);
+            if (operator === "&&" || operator === "--") {
+              const next = operator === "&&" ? "intersection" : "subtraction";
+              if (operation === void 0 && (items.length !== 1 || item.type === "range") || operation !== void 0 && operation !== next) this.fail("Mixed set operations", start);
+              if (operation === void 0) this.guard.allocate(1 + next.length);
+              operation = next;
+              this.position += 2;
+              if (this.peek() === "]" || this.atEnd()) this.fail("Missing set operand", start);
+            } else if (operation !== void 0 && this.peek() !== "]") this.fail("Missing set operator", start);
+          }
+          if (this.take() !== "]") this.fail("Unterminated character set", start);
+          const mayContainStrings = (item) => {
+            if (item.type === "set") return item.value.strings === true;
+            if (item.type === "property") return item.strings === true;
+            if (item.type === "strings") return item.values.some((value) => value.length !== ((value.codePointAt(0) ?? 0) > 65535 ? 2 : 1));
+            return false;
+          };
+          const strings = operation === "intersection" ? items.every(mayContainStrings) : operation === "subtraction" ? mayContainStrings(items[0]) : items.some(mayContainStrings);
+          if (negated && strings) this.fail("Cannot complement a set containing strings", start);
+          if (strings) this.guard.allocate(1);
+          return { negated, items, ...operation === void 0 ? {} : { operation }, ...strings ? { strings: true } : {} };
+        } finally {
+          this.guard.leaveGroup();
+        }
+      }
+      parseUnicodeSetItem(start) {
+        if (this.peek() === "[") {
+          this.position++;
+          this.guard.allocate(3);
+          return { type: "set", value: this.parseUnicodeSet(start) };
+        }
+        if (this.source.startsWith("\\q{", this.position)) {
+          this.position += 3;
+          this.guard.allocate(4);
+          const values = [];
+          let value2 = "";
+          while (!this.atEnd()) {
+            if (this.peek() === "|" || this.peek() === "}") {
+              this.guard.array(values.length + 1);
+              this.guard.allocate(1);
+              values.push(value2);
+              value2 = "";
+              if (this.take() === "}") return { type: "strings", values };
+            } else {
+              const item = this.parseSetCharacter(start);
+              this.guard.allocate(item.length);
+              value2 += item;
+            }
+          }
+          this.fail("Unterminated class string", start);
+        }
+        if (this.peek() === "\\") return this.parseClassItem(start);
+        const value = this.parseSetCharacter(start);
+        this.guard.allocate(3 + value.length);
+        return { type: "character", value };
+      }
+      parseSetCharacter(start) {
+        if (this.peek() === "\\") {
+          this.position++;
+          const node = this.parseEscape(true, start);
+          if (node.type !== "literal") this.fail("Class strings require literal characters", start);
+          return node.value;
+        }
+        const character2 = this.takeCharacter();
+        if (!character2 || "()[]{}/-|".includes(character2) || "!#$%&*+,.:;<=>?@^`~".includes(character2) && this.peek() === character2)
+          this.fail("Invalid character in Unicode set", start);
+        return character2;
       }
       parseEscape(inCharacterClass, start) {
         if (this.atEnd()) {
           this.fail("Trailing escape", start);
         }
         const escaped = this.take();
-        if (escaped >= "1" && escaped <= "9") {
-          this.fail("Backreferences are not supported", start);
-        }
-        if (escaped === "p" || escaped === "P") {
-          this.fail("Unicode property escapes are not supported", start);
+        if (escaped === "k") {
+          this.totalCaptureCount ??= this.countAllCaptures();
+          if (this.unicode || this.hasNamedCaptures) {
+            if (inCharacterClass || this.take() !== "<") this.fail("Invalid named backreference", start);
+            const name = this.parseGroupName(start);
+            this.guard.allocate(3 + name.length);
+            return { type: "namedBackreference", name };
+          }
+        }
+        if (isDecimalDigit2(escaped)) {
+          if (!inCharacterClass && escaped !== "0") {
+            let end = this.position;
+            let index = Number(escaped);
+            while (isDecimalDigit2(this.source[end] ?? "")) {
+              this.guard.work(1);
+              index = index * 10 + Number(this.source[end++]);
+            }
+            this.totalCaptureCount ??= this.countAllCaptures();
+            if (index <= this.totalCaptureCount) {
+              this.position = end;
+              this.guard.allocate(3);
+              return { type: "backreference", index };
+            }
+          }
+          if (this.unicode && (escaped !== "0" || isDecimalDigit2(this.peek())))
+            this.fail("Invalid decimal escape", start);
+          this.guard.allocate(4);
+          if (escaped === "8" || escaped === "9") return { type: "literal", value: escaped };
+          let code = Number(escaped);
+          const maximum = escaped <= "3" ? 3 : 2;
+          for (let digits = 1; digits < maximum && this.peek() >= "0" && this.peek() <= "7"; digits++) {
+            code = code * 8 + Number(this.take());
+          }
+          return { type: "literal", value: String.fromCharCode(code) };
+        }
+        if (this.unicode && (escaped === "p" || escaped === "P")) {
+          if (this.take() !== "{") this.fail("Invalid Unicode property escape", start);
+          const begin = this.position;
+          while (!this.atEnd() && this.peek() !== "}") {
+            const character2 = this.take();
+            if (!isDecimalDigit2(character2) && !(character2 >= "a" && character2 <= "z") && !(character2 >= "A" && character2 <= "Z") && character2 !== "_" && character2 !== "=")
+              this.fail("Invalid Unicode property escape", start);
+          }
+          this.guard.allocate(this.position - begin + 9);
+          const value = this.source.slice(begin, this.position);
+          if (this.take() !== "}") this.fail("Unterminated Unicode property escape", start);
+          try {
+            new RegExp(`\\${escaped}{${value}}`, this.unicodeSets ? "v" : "u");
+          } catch {
+            this.fail("Unknown Unicode property", start);
+          }
+          let strings = false;
+          if (this.unicodeSets) {
+            try {
+              new RegExp(`\\p{${value}}`, "u");
+            } catch {
+              strings = true;
+            }
+          }
+          this.guard.array(1);
+          return { type: "characterClass", negated: false, items: [{ type: "property", value, negated: escaped === "P", ...strings ? { strings: true } : {} }] };
         }
         if (escaped === "x") {
           this.guard.allocate(4);
-          return { type: "literal", value: this.parseHexEscape(2, "hexadecimal", start) };
+          return { type: "literal", value: this.parseHexEscape(2, "hexadecimal", start, this.unicode ? void 0 : "x") };
         }
         if (escaped === "u") {
           this.guard.allocate(4);
-          return { type: "literal", value: this.parseHexEscape(4, "Unicode", start) };
+          if (this.unicode && this.peek() === "{") {
+            this.position++;
+            const begin = this.position;
+            while (!this.atEnd() && this.peek() !== "}") this.position++;
+            this.guard.allocate(this.position - begin);
+            const digits = this.source.slice(begin, this.position);
+            const point = Number.parseInt(digits, 16);
+            if (this.take() !== "}" || digits.length === 0 || !allHexDigits(digits) || point > 1114111)
+              this.fail("Invalid Unicode escape", start);
+            return { type: "literal", value: String.fromCodePoint(point) };
+          }
+          let value = this.parseHexEscape(4, "Unicode", start, this.unicode ? void 0 : "u");
+          if (this.unicode && value.charCodeAt(0) >= 55296 && value.charCodeAt(0) <= 56319 && this.source.startsWith("\\u", this.position)) {
+            const digits = this.source.slice(this.position + 2, this.position + 6);
+            const point = Number.parseInt(digits, 16);
+            this.guard.work(digits.length);
+            this.guard.allocate(digits.length);
+            if (digits.length === 4 && allHexDigits(digits) && point >= 56320 && point <= 57343) {
+              value += String.fromCharCode(point);
+              this.position += 6;
+            }
+          }
+          return { type: "literal", value };
         }
         this.guard.allocate(25);
         const kinds = {
@@ -122007,20 +122275,101 @@ var init_parse5 = __esm({
           v: "\v",
           "0": "\0"
         };
+        if (escaped === "c") {
+          const letter = this.peek();
+          this.guard.allocate(4);
+          if (letter >= "a" && letter <= "z" || letter >= "A" && letter <= "Z" || !this.unicode && inCharacterClass && (isDecimalDigit2(letter) || letter === "_")) {
+            this.position++;
+            return { type: "literal", value: String.fromCharCode(letter.charCodeAt(0) % 32) };
+          }
+          if (this.unicode) this.fail("Invalid control escape", start);
+          this.position--;
+          return { type: "literal", value: "\\" };
+        }
+        if (this.unicode && controls[escaped] === void 0 && !"^$\\.*+?()[]{}|/".includes(escaped) && !(inCharacterClass && (escaped === "-" || this.unicodeSets && "!#$%&+,.:;<=>?@`~".includes(escaped))))
+          this.fail("Invalid identity escape", start);
         this.guard.allocate(4);
         return { type: "literal", value: controls[escaped] ?? escaped };
       }
-      parseHexEscape(length, name, start) {
+      parseHexEscape(length, name, start, identity) {
         const end = this.position + length;
         this.guard.allocate(Math.min(length, this.source.length - this.position));
         this.guard.work(Math.min(length, this.source.length - this.position));
         const digits = this.source.slice(this.position, end);
         if (digits.length !== length || !allHexDigits(digits)) {
+          if (identity !== void 0) return identity;
           this.fail(`Invalid ${name} escape`, start);
         }
         this.position = end;
         return String.fromCharCode(Number.parseInt(digits, 16));
       }
+      countAllCaptures() {
+        let count = 0;
+        let escaped = false;
+        let characterClass = false;
+        for (let index = 0; index < this.source.length; index++) {
+          this.guard.work(1);
+          const character2 = this.source[index];
+          if (escaped) escaped = false;
+          else if (character2 === "\\") escaped = true;
+          else if (character2 === "[") characterClass = true;
+          else if (character2 === "]") characterClass = false;
+          else if (!characterClass && character2 === "(") {
+            const named = this.source[index + 1] === "?" && this.source[index + 2] === "<" && this.source[index + 3] !== "=" && this.source[index + 3] !== "!";
+            if (named) this.hasNamedCaptures = true;
+            if (named || this.source[index + 1] !== "?") count++;
+          }
+        }
+        return count;
+      }
+      parseGroupName(start) {
+        let name = "";
+        while (!this.atEnd() && this.peek() !== ">") {
+          let character2 = this.take();
+          if (character2 === "\\") {
+            if (this.take() !== "u") this.fail("Invalid group name escape", start);
+            if (this.peek() === "{") {
+              this.position++;
+              const begin = this.position;
+              while (!this.atEnd() && this.peek() !== "}") this.position++;
+              this.guard.allocate(this.position - begin);
+              const digits = this.source.slice(begin, this.position);
+              const point = Number.parseInt(digits, 16);
+              if (this.take() !== "}" || digits.length === 0 || !allHexDigits(digits) || point > 1114111)
+                this.fail("Invalid group name escape", start);
+              character2 = String.fromCodePoint(point);
+            } else character2 = this.parseHexEscape(4, "Unicode", start);
+          }
+          this.guard.allocate(character2.length);
+          name += character2;
+        }
+        if (this.take() !== ">" || name.length === 0) this.fail("Invalid group name", start);
+        let first = true;
+        for (const character2 of name) {
+          this.guard.work(1);
+          if (!(first ? groupNameStart : groupNamePart).test(character2)) this.fail("Invalid group name", start);
+          first = false;
+        }
+        return name;
+      }
+      validateNamedGroups(node) {
+        this.guard.work(1);
+        this.guard.allocate(1);
+        const names = /* @__PURE__ */ new Set();
+        if (node.type === "namedBackreference" && !Object.hasOwn(this.namedGroups, node.name))
+          this.fail("Unknown named backreference");
+        if (node.type === "group" && node.name !== void 0) names.add(node.name);
+        const children2 = node.type === "sequence" ? node.elements : node.type === "alternation" ? node.alternatives : node.type === "group" || node.type === "quantifier" || node.type === "lookahead" || node.type === "lookbehind" ? [node.body] : [];
+        for (const child of children2) {
+          for (const name of this.validateNamedGroups(child)) {
+            this.guard.work(1);
+            if (names.has(name) && node.type !== "alternation") this.fail("Duplicate capture group name");
+            this.guard.allocate(1);
+            names.add(name);
+          }
+        }
+        return names;
+      }
       parseQuantifier() {
         const character2 = this.peek();
         if (character2 === "*") {
@@ -122050,18 +122399,29 @@ var init_parse5 = __esm({
         }
         if (this.peek() === "}") {
           this.position += 1;
+          if (!Number.isSafeInteger(min)) this.fail("Quantifier is too large", start);
           this.guard.allocate(3);
           return { min, max: min };
         }
         if (this.peek() !== ",") {
+          if (!this.unicode) {
+            this.position = start;
+            return void 0;
+          }
           this.fail("Invalid quantifier", start);
         }
         this.position += 1;
         const max = this.parseDecimal();
         if (this.peek() !== "}") {
+          if (!this.unicode) {
+            this.position = start;
+            return void 0;
+          }
           this.fail("Unterminated quantifier", start);
         }
         this.position += 1;
+        if (!Number.isSafeInteger(min) || max !== void 0 && !Number.isSafeInteger(max))
+          this.fail("Quantifier is too large", start);
         if (max !== void 0 && min > max) {
           this.fail("Quantifier range is out of order", start);
         }
@@ -122078,11 +122438,7 @@ var init_parse5 = __esm({
         }
         this.guard.allocate(this.position - start);
         this.guard.work(this.position - start);
-        const value = Number(this.source.slice(start, this.position));
-        if (!Number.isSafeInteger(value)) {
-          this.fail("Quantifier is too large", start);
-        }
-        return value;
+        return Number(this.source.slice(start, this.position));
       }
       peek() {
         return this.source[this.position] ?? "";
@@ -122092,6 +122448,12 @@ var init_parse5 = __esm({
         this.position += 1;
         return character2;
       }
+      takeCharacter() {
+        if (!this.unicode || this.atEnd()) return this.take();
+        const character2 = String.fromCodePoint(this.source.codePointAt(this.position));
+        this.position += character2.length;
+        return character2;
+      }
       atEnd() {
         return this.position >= this.source.length;
       }
@@ -122299,6 +122661,7 @@ function findImportMetaAssignmentInNode(node) {
     case "BooleanLiteral":
     case "NullLiteral":
     case "NumericLiteral":
+    case "BigIntLiteral":
     case "StringLiteral":
     case "ThisExpression":
     case "RegexLiteral":
@@ -122377,6 +122740,12 @@ function isYieldArgumentTerminator(value) {
   return value === ";" || value === "}" || value === ")" || value === "]" || value === ",";
 }
 function createNumericLiteral(token) {
+  if (token.value.endsWith("n")) return {
+    type: "BigIntLiteral",
+    raw: token.value,
+    value: token.value.slice(0, -1).replaceAll("_", ""),
+    span: createTokenSpan(token)
+  };
   return {
     type: "NumericLiteral",
     raw: token.value,
@@ -125962,6 +126331,23 @@ var init_hash = __esm({
   }
 });
 
+// packages/safe-js/src/snapshot/bigint.ts
+function validateBigIntData(value) {
+  if (typeof value !== "string" || value.length === 0) throw new TypeError("Invalid BigInt snapshot value.");
+  if (value === "0") return;
+  const start = value[0] === "-" ? 1 : 0;
+  if (start === value.length || value[start] === "0") throw new TypeError("Invalid BigInt snapshot value.");
+  for (let index = start; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code < 48 || code > 57) throw new TypeError("Invalid BigInt snapshot value.");
+  }
+}
+var init_bigint = __esm({
+  "packages/safe-js/src/snapshot/bigint.ts"() {
+    "use strict";
+  }
+});
+
 // packages/safe-js/src/observability/otel.ts
 function bindOtelSpan(value, span) {
   spanByAsyncValue.set(value, span);
@@ -126228,9 +126614,13 @@ function isSandboxRegExpIterator(value) {
   return typeof value === "object" && value !== null && states2.has(value);
 }
 function restoreSandboxRegExpIterator(state, target = /* @__PURE__ */ Object.create(null)) {
+  if ((state.global !== void 0 || state.unicode !== void 0) && (typeof state.global !== "boolean" || typeof state.unicode !== "boolean"))
+    throw new TypeError("Invalid RegExp iterator modes.");
+  if (state.matcher !== void 0 && (state.matcher === null || typeof state.matcher !== "object"))
+    throw new TypeError("Invalid RegExp iterator matcher.");
   if (!state.exhausted && (state.matcher === void 0 || state.input === void 0))
     throw new TypeError("A live RegExp iterator requires its matcher and input.");
-  states2.set(target, state.exhausted ? { matcher: void 0, input: void 0, exhausted: true } : { ...state });
+  states2.set(target, state.exhausted ? { ...state, matcher: void 0, input: void 0, exhausted: true } : { ...state });
   return target;
 }
 function regexpIteratorState(value) {
@@ -126389,10 +126779,11 @@ function nativeBoxedValue(value) {
   if (types2.isStringObject(value)) return Reflect.apply(stringValue2, value, []);
   if (types2.isBooleanObject(value)) return Reflect.apply(booleanValue, value, []);
   if (types2.isSymbolObject(value)) return Reflect.apply(symbolValue, value, []);
+  if (types2.isBigIntObject(value)) return Reflect.apply(bigintValue, value, []);
   return void 0;
 }
 function createSandboxBox(value) {
-  if (typeof value !== "number" && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "symbol")
+  if (typeof value !== "number" && typeof value !== "bigint" && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "symbol")
     throw new TypeError("Invalid boxed primitive payload.");
   const box = Object(value);
   Object.setPrototypeOf(box, null);
@@ -126423,7 +126814,7 @@ function boxedDataProperties(value, includeSymbols = false) {
     return !(Number.isInteger(index) && index >= 0 && index < primitive.length && String(index) === key3);
   });
 }
-var boxes, numberValue2, stringValue2, booleanValue, symbolValue;
+var boxes, numberValue2, stringValue2, booleanValue, symbolValue, bigintValue;
 var init_boxed = __esm({
   "packages/safe-js/src/interp/boxed.ts"() {
     "use strict";
@@ -126432,6 +126823,7 @@ var init_boxed = __esm({
     stringValue2 = String.prototype.valueOf;
     booleanValue = Boolean.prototype.valueOf;
     symbolValue = Symbol.prototype.valueOf;
+    bigintValue = BigInt.prototype.valueOf;
   }
 });
 
@@ -127671,6 +128063,9 @@ function getSandboxPrototype(value, budget) {
 function hasExplicitSandboxPrototype(value) {
   return prototypes.has(value);
 }
+function hasNullObjectPrototype(value) {
+  return prototypes.get(value) === null && !Array.isArray(value) && !isSandboxClosure(value) && !isSandboxRegex(value);
+}
 function getSandboxPropertyDescriptor(value, key3, budget) {
   const hostProperties = isSandboxClosure(value) ? value.properties : void 0;
   if (isSandboxClosure(value) && !isGuestClosure(value))
@@ -127752,7 +128147,7 @@ function hasGuestObjectState(value) {
   const intrinsicUnchanged = intrinsicConstructors.get(value);
   if (intrinsicUnchanged !== void 0) return !intrinsicUnchanged();
   if (isLiveCapability(value)) return true;
-  if (functionProperties.has(value) || prototypes.has(value)) return true;
+  if (functionProperties.has(value) || prototypes.has(value) && !hasNullObjectPrototype(value)) return true;
   if (isSandboxBox(value) || isSandboxDate(value)) return false;
   return descriptorObjects.has(value) && Object.values(Object.getOwnPropertyDescriptors(value)).some(
     (descriptor) => !descriptor.enumerable || !descriptor.configurable || !descriptor.writable
@@ -127974,6 +128369,7 @@ function encodeReplayData(value, options = {}) {
     if (depth > MAX_DATA_DEPTH) throw new TypeError("Replay data exceeds the nesting limit.");
     if (entry === null || typeof entry === "boolean" || typeof entry === "string") return entry;
     if (entry === void 0) return { tag: "undefined" };
+    if (typeof entry === "bigint") return { tag: "bigint", value: String(entry) };
     if (typeof entry === "symbol") {
       let id2 = symbols2.get(entry);
       if (id2 === void 0) {
@@ -128070,7 +128466,16 @@ function encodeReplayData(value, options = {}) {
       }
       let symbolIndex = 0;
       const symbolEntries = serializeSymbolProperties(entry, (value2) => encode(value2, depth + 1, [...path193, { symbol: Math.floor(symbolIndex++ / 2) }]));
-      nodes[id] = { kind: "regexp-iterator", matcher: child(snapshot2.matcher, "<matcher>"), input: child(snapshot2.input, "<input>"), exhausted: snapshot2.exhausted, properties, extensible: Object.isExtensible(entry), symbolEntries };
+      nodes[id] = {
+        kind: "regexp-iterator",
+        matcher: child(snapshot2.matcher, "<matcher>"),
+        input: child(snapshot2.input, "<input>"),
+        exhausted: snapshot2.exhausted,
+        properties,
+        extensible: Object.isExtensible(entry),
+        symbolEntries,
+        ...snapshot2.global === void 0 ? {} : { global: snapshot2.global, unicode: snapshot2.unicode }
+      };
     } else if (isSandboxCollectionIterator(entry)) {
       const snapshot2 = snapshotCollectionIterator(entry);
       const properties = /* @__PURE__ */ Object.create(null);
@@ -128124,6 +128529,7 @@ function encodeReplayData(value, options = {}) {
       nodes[id] = {
         kind: Array.isArray(entry) ? "array" : "object",
         nullPrototype: prototype === null,
+        ...hasNullObjectPrototype(entry) ? { sandboxNullPrototype: true } : {},
         ...errorType === void 0 ? {} : { errorType },
         extensible: Object.isExtensible(entry),
         properties,
@@ -128166,6 +128572,11 @@ function decodeReplayData(input, options = {}, parent) {
         return capability;
       }
       if (own(atom, "tag") === "undefined") return void 0;
+      if (own(atom, "tag") === "bigint") {
+        const value = own(atom, "value");
+        validateBigIntData(value);
+        return BigInt(value);
+      }
       if (atom.tag === "number") {
         switch (own(atom, "value")) {
           case "NaN":
@@ -128235,7 +128646,7 @@ function decodeReplayData(input, options = {}, parent) {
         const payload = own(node, "value");
         const payloadRecord = payload !== null && typeof payload === "object" ? record(payload) : void 0;
         const symbolReference = payloadRecord !== void 0 && own(payloadRecord, "tag") === "ref" && Number.isSafeInteger(payloadRecord.id) && Number(payloadRecord.id) >= 0 && Number(payloadRecord.id) < nodes.length && own(record(nodes[Number(payloadRecord.id)]), "kind") === "symbol";
-        if (typeof payload !== "number" && typeof payload !== "string" && typeof payload !== "boolean" && !symbolReference && (payload === null || typeof payload !== "object" || own(record(payload), "tag") !== "number"))
+        if (typeof payload !== "number" && typeof payload !== "string" && typeof payload !== "boolean" && !symbolReference && (payload === null || typeof payload !== "object" || !["number", "bigint"].includes(String(own(record(payload), "tag")))))
           throw new TypeError("Invalid boxed primitive payload.");
         const result3 = createSandboxBox(child(payload));
         restored.set(id, result3);
@@ -128268,9 +128679,15 @@ function decodeReplayData(input, options = {}, parent) {
         restored.set(id, result3);
         const matcher = child(own(node, "matcher"));
         const input2 = child(own(node, "input"));
-        if (matcher !== void 0 && !isSandboxRegex(matcher)) throw new TypeError("Invalid replay RegExp iterator matcher.");
+        if ((node.global !== void 0 || node.unicode !== void 0) && (typeof node.global !== "boolean" || typeof node.unicode !== "boolean")) throw new TypeError("Invalid replay RegExp iterator modes.");
+        if (matcher !== void 0 && (node.global === void 0 ? !isSandboxRegex(matcher) : matcher === null || typeof matcher !== "object")) throw new TypeError("Invalid replay RegExp iterator matcher.");
         if (input2 !== void 0 && typeof input2 !== "string") throw new TypeError("Invalid replay RegExp iterator input.");
-        restoreSandboxRegExpIterator({ matcher, input: input2, exhausted }, result3);
+        restoreSandboxRegExpIterator({
+          matcher,
+          input: input2,
+          exhausted,
+          ...node.global === void 0 ? {} : { global: node.global, unicode: node.unicode }
+        }, result3);
         defineProperties(result3, record(own(node, "properties")), child, node.symbolEntries);
         if (!node.extensible) Object.preventExtensions(result3);
         return result3;
@@ -128340,6 +128757,10 @@ function decodeReplayData(input, options = {}, parent) {
         throw new TypeError("Invalid replay object metadata.");
       }
       const result2 = kind === "array" ? [] : Object.create(node.nullPrototype ? null : Object.prototype);
+      if (Object.hasOwn(node, "sandboxNullPrototype")) {
+        if (kind !== "object" || node.sandboxNullPrototype !== true) throw new TypeError("Invalid replay object prototype.");
+        setSandboxPrototype(result2, null);
+      }
       if (Object.hasOwn(node, "errorType")) {
         sandboxErrorTypes.set(result2, node.errorType);
       }
@@ -128405,6 +128826,7 @@ var init_replay_data = __esm({
   "packages/safe-js/src/snapshot/replay-data.ts"() {
     "use strict";
     init_graph_depth();
+    init_bigint();
     init_regexp_properties2();
     init_symbols2();
     init_symbols3();
@@ -129345,15 +129767,17 @@ var init_resources = __esm({
 
 // packages/safe-js/src/interp/regex/engine.ts
 function matchRegex(pattern, input, lastIndex = 0) {
-  const startIndex = pattern.flags.global ? normalizeLastIndex(lastIndex) : 0;
+  const startIndex = pattern.flags.global || pattern.flags.sticky ? normalizeLastIndex(lastIndex) : 0;
   return matchRegexFrom(pattern, input, startIndex);
 }
 function matchRegexFrom(pattern, input, startIndex) {
   if (startIndex > input.length) {
     return null;
   }
-  for (let attempt = startIndex; attempt <= input.length; attempt += 1) {
-    const context = { input, flags: pattern.flags, steps: 0 };
+  const unicode = pattern.flags.unicode || pattern.flags.unicodeSets;
+  if (unicode && startIndex > 0 && startIndex < input.length && input.charCodeAt(startIndex) >= 56320 && input.charCodeAt(startIndex) <= 57343 && input.charCodeAt(startIndex - 1) >= 55296 && input.charCodeAt(startIndex - 1) <= 56319) startIndex--;
+  for (let attempt = startIndex; attempt <= input.length; attempt = advanceStringIndex(input, attempt, unicode)) {
+    const context = { input, flags: pattern.flags, groups: pattern.groups, direction: 1, work: { steps: 0 } };
     charge(context);
     const initialState = {
       position: attempt,
@@ -129361,25 +129785,59 @@ function matchRegexFrom(pattern, input, startIndex) {
     };
     const result = matchNode(pattern.body, initialState, context).next();
     if (!result.done) {
-      return toRegexMatch(input, attempt, result.value);
+      return toRegexMatch(input, attempt, result.value, pattern.flags.hasIndices, pattern.groups);
     }
+    if (pattern.flags.sticky) break;
   }
   return null;
 }
 function* matchNode(node, state, context) {
   charge(context);
+  const unicode = context.flags.unicode || context.flags.unicodeSets;
+  const character2 = readCharacter(context.input, state.position, context.direction, unicode);
   switch (node.type) {
     case "empty":
       yield state;
       return;
     case "literal":
-      if (charactersEqual(context.input[state.position], node.value, context.flags.ignoreCase)) {
-        yield { ...state, position: state.position + 1 };
+      if (charactersEqual(character2, node.value, context.flags.ignoreCase, unicode)) {
+        yield { ...state, position: state.position + context.direction * character2.length };
+      }
+      return;
+    case "backreference":
+    case "namedBackreference": {
+      let capture;
+      if (node.type === "backreference") capture = state.captures[node.index - 1];
+      else {
+        for (const index of context.groups?.[node.name] ?? []) {
+          charge(context);
+          if (state.captures[index - 1] !== void 0) {
+            capture = state.captures[index - 1];
+            break;
+          }
+        }
+      }
+      if (capture === void 0) {
+        yield state;
+        return;
       }
+      let position = state.position;
+      let reference = context.direction === 1 ? capture.start : capture.end;
+      const end = context.direction === 1 ? capture.end : capture.start;
+      while (reference !== end) {
+        charge(context);
+        const expected = readCharacter(context.input, reference, context.direction, unicode);
+        const actual = readCharacter(context.input, position, context.direction, unicode);
+        if (!charactersEqual(actual, expected, context.flags.ignoreCase, unicode)) return;
+        reference += context.direction * expected.length;
+        position += context.direction * actual.length;
+      }
+      yield { ...state, position };
       return;
+    }
     case "dot":
-      if (state.position < context.input.length && (context.flags.dotAll || !isLineTerminator(context.input[state.position]))) {
-        yield { ...state, position: state.position + 1 };
+      if (character2 !== void 0 && (context.flags.dotAll || !isLineTerminator(character2))) {
+        yield { ...state, position: state.position + context.direction * character2.length };
       }
       return;
     case "anchor":
@@ -129388,17 +129846,24 @@ function* matchNode(node, state, context) {
       }
       return;
     case "wordBoundary": {
-      const previousWord = state.position > 0 && isWordCharacter(context.input[state.position - 1]);
-      const nextWord = state.position < context.input.length && isWordCharacter(context.input[state.position]);
+      const previousWord = state.position > 0 && matchesCharacterClassItem(context.input[state.position - 1], { type: "kind", kind: "word", negated: false }, context.flags.ignoreCase, unicode);
+      const nextWord = state.position < context.input.length && matchesCharacterClassItem(context.input[state.position], { type: "kind", kind: "word", negated: false }, context.flags.ignoreCase, unicode);
       if (previousWord !== nextWord !== node.negated) {
         yield state;
       }
       return;
     }
     case "characterClass": {
-      const character2 = context.input[state.position];
-      if (character2 !== void 0 && matchesCharacterClass(character2, node.items, node.negated, context.flags.ignoreCase)) {
-        yield { ...state, position: state.position + 1 };
+      if (context.flags.unicodeSets) {
+        const lengths = [...matchUnicodeSet(node, state.position, context)].sort((a, b) => b - a);
+        for (const length of lengths) {
+          charge(context);
+          yield { ...state, position: state.position + context.direction * length };
+        }
+        return;
+      }
+      if (character2 !== void 0 && matchesCharacterClass(character2, node.items, node.negated, context)) {
+        yield { ...state, position: state.position + context.direction * character2.length };
       }
       return;
     }
@@ -129410,14 +129875,30 @@ function* matchNode(node, state, context) {
         yield* matchNode(alternative, cloneState(state), context);
       }
       return;
+    case "lookahead":
+    case "lookbehind": {
+      const result = matchNode(node.body, cloneState(state), {
+        ...context,
+        direction: node.type === "lookbehind" ? -1 : 1
+      }).next();
+      if (node.negated) {
+        if (result.done) yield state;
+      } else if (!result.done) {
+        yield { position: state.position, captures: result.value.captures };
+      }
+      return;
+    }
     case "group":
-      for (const result of matchNode(node.body, cloneState(state), context)) {
+      for (const result of matchNode(node.body, cloneState(state), node.modifiers === void 0 ? context : {
+        ...context,
+        flags: { ...context.flags, ...node.modifiers }
+      })) {
         if (!node.capturing || node.index === void 0) {
           yield result;
           continue;
         }
         const captures = result.captures.slice();
-        captures[node.index - 1] = { start: state.position, end: result.position };
+        captures[node.index - 1] = { start: Math.min(state.position, result.position), end: Math.max(state.position, result.position) };
         yield { position: result.position, captures };
       }
       return;
@@ -129431,7 +129912,8 @@ function* matchSequence(elements, index, state, context) {
     yield state;
     return;
   }
-  for (const result of matchNode(elements[index], state, context)) {
+  const element = elements[context.direction === 1 ? index : elements.length - 1 - index];
+  for (const result of matchNode(element, state, context)) {
     yield* matchSequence(elements, index + 1, result, context);
   }
 }
@@ -129467,11 +129949,28 @@ function matchesAnchor(kind, position, context) {
   }
   return position === context.input.length || context.flags.multiline && position < context.input.length && isLineTerminator(context.input[position]);
 }
-function matchesCharacterClass(character2, items, negated, ignoreCase) {
-  const matched = items.some((item) => matchesCharacterClassItem(character2, item, ignoreCase));
+function matchesCharacterClass(character2, items, negated, context) {
+  const matched = items.some((item) => {
+    if (context.flags.unicode) charge(context);
+    return matchesCharacterClassItem(character2, item, context.flags.ignoreCase, context.flags.unicode);
+  });
   return negated ? !matched : matched;
 }
-function matchesCharacterClassItem(character2, item, ignoreCase) {
+function matchesCharacterClassItem(character2, item, ignoreCase, unicode, unicodeSets = false) {
+  if (item.type === "strings" || item.type === "set") return false;
+  if (unicode) {
+    const hex = (value) => `\\u{${value.codePointAt(0).toString(16)}}`;
+    let atom;
+    if (item.type === "character") atom = hex(item.value);
+    else if (item.type === "range") atom = `[${hex(item.from)}-${hex(item.to)}]`;
+    else if (item.type === "property") atom = `\\${item.negated ? "P" : "p"}{${item.value}}`;
+    else {
+      const kind = item.kind === "digit" ? "d" : item.kind === "word" ? "w" : "s";
+      atom = `\\${item.negated ? kind.toUpperCase() : kind}`;
+    }
+    return new RegExp(`^(?:${atom})$`, (ignoreCase ? "i" : "") + (unicodeSets ? "v" : "u")).test(character2);
+  }
+  if (item.type === "property") return false;
   if (item.type === "character") {
     return charactersEqual(character2, item.value, ignoreCase);
   }
@@ -129485,22 +129984,102 @@ function matchesCharacterClassItem(character2, item, ignoreCase) {
     if (!ignoreCase) {
       return false;
     }
-    const foldedCandidate = foldCharacter(character2, true).charCodeAt(0);
-    const foldedFrom = foldCharacter(item.from, true).charCodeAt(0);
-    const foldedTo = foldCharacter(item.to, true).charCodeAt(0);
-    return foldedCandidate >= foldedFrom && foldedCandidate <= foldedTo;
+    return new RegExp(`^[\\u${from.toString(16).padStart(4, "0")}-\\u${to.toString(16).padStart(4, "0")}]$`, "i").test(character2);
   }
   const matched = item.kind === "digit" ? isDigit5(character2) : item.kind === "word" ? isWordCharacter(character2) : isSpaceCharacter(character2);
   return item.negated ? !matched : matched;
 }
-function toRegexMatch(input, start, state) {
-  return {
+function matchUnicodeSet(set, position, context) {
+  charge(context);
+  let lengths = /* @__PURE__ */ new Set();
+  for (let index = 0; index < set.items.length; index++) {
+    const next = matchUnicodeSetItem(set.items[index], position, context);
+    if (index === 0) lengths = next;
+    else if (set.operation === void 0) {
+      for (const length of next) {
+        charge(context);
+        lengths.add(length);
+      }
+    } else {
+      for (const length of lengths) {
+        charge(context);
+        if (set.operation === "intersection" ? !next.has(length) : next.has(length)) lengths.delete(length);
+      }
+    }
+  }
+  if (set.negated) {
+    const character2 = readCharacter(context.input, position, context.direction, true);
+    return new Set(character2 !== void 0 && !lengths.has(character2.length) ? [character2.length] : []);
+  }
+  return lengths;
+}
+function matchUnicodeSetItem(item, position, context) {
+  charge(context);
+  if (item.type === "set") return matchUnicodeSet(item.value, position, context);
+  const lengths = /* @__PURE__ */ new Set();
+  if (item.type === "strings") {
+    for (const value of item.values) {
+      charge(context);
+      let reference = context.direction === 1 ? 0 : value.length;
+      let cursor2 = position;
+      const end = context.direction === 1 ? value.length : 0;
+      while (reference !== end) {
+        charge(context);
+        const expected = readCharacter(value, reference, context.direction, true);
+        const actual = readCharacter(context.input, cursor2, context.direction, true);
+        if (!charactersEqual(actual, expected, context.flags.ignoreCase, true)) break;
+        reference += context.direction * expected.length;
+        cursor2 += context.direction * actual.length;
+      }
+      if (reference === end) lengths.add(Math.abs(cursor2 - position));
+    }
+    return lengths;
+  }
+  if (item.type === "property" && item.strings) {
+    const atom = `\\p{${item.value}}`;
+    const flags = (context.flags.ignoreCase ? "i" : "") + "v";
+    const matcher = new RegExp(context.direction === 1 ? atom : `(?<=(${atom}))`, flags + "y");
+    matcher.lastIndex = position;
+    const match = matcher.exec(context.input);
+    if (match === null) return lengths;
+    const longest = context.direction === 1 ? match[0] : match[1];
+    const member = new RegExp(`^(?:${atom})$`, flags);
+    let consumed = 0;
+    while (consumed < longest.length) {
+      charge(context);
+      const cursor2 = context.direction === 1 ? consumed : longest.length - consumed;
+      consumed += readCharacter(longest, cursor2, context.direction, true).length;
+      const candidate = context.direction === 1 ? longest.slice(0, consumed) : longest.slice(longest.length - consumed);
+      if (member.test(candidate)) lengths.add(consumed);
+    }
+    return lengths;
+  }
+  const character2 = readCharacter(context.input, position, context.direction, true);
+  if (character2 !== void 0 && matchesCharacterClassItem(character2, item, context.flags.ignoreCase, true, true))
+    lengths.add(character2.length);
+  return lengths;
+}
+function toRegexMatch(input, start, state, hasIndices, groups) {
+  const match = {
     index: start,
     text: input.slice(start, state.position),
     captures: state.captures.map(
       (capture) => capture === void 0 ? void 0 : input.slice(capture.start, capture.end)
     )
   };
+  if (hasIndices) {
+    match.indices = [[start, state.position], ...state.captures.map((capture) => capture === void 0 ? void 0 : [capture.start, capture.end])];
+  }
+  if (groups !== void 0) {
+    match.groups = /* @__PURE__ */ Object.create(null);
+    if (hasIndices) match.indicesGroups = /* @__PURE__ */ Object.create(null);
+    for (const [name, indices] of Object.entries(groups)) {
+      const index = indices.find((index2) => state.captures[index2 - 1] !== void 0);
+      match.groups[name] = index === void 0 ? void 0 : match.captures[index - 1];
+      if (match.indicesGroups !== void 0) match.indicesGroups[name] = index === void 0 ? void 0 : match.indices[index];
+    }
+  }
+  return match;
 }
 function cloneState(state) {
   return { position: state.position, captures: state.captures.slice() };
@@ -129530,13 +130109,13 @@ function clearNodeCaptures(node, captures) {
     }
     return;
   }
-  if (node.type === "quantifier") {
+  if (node.type === "quantifier" || node.type === "lookahead" || node.type === "lookbehind") {
     clearNodeCaptures(node.body, captures);
   }
 }
 function charge(context) {
-  context.steps += 1;
-  allocateRegexSteps(context.steps);
+  context.work.steps += 1;
+  allocateRegexSteps(context.work.steps);
 }
 function normalizeLastIndex(lastIndex) {
   if (Number.isNaN(lastIndex) || lastIndex <= 0) {
@@ -129544,9 +130123,20 @@ function normalizeLastIndex(lastIndex) {
   }
   return Math.min(Math.floor(lastIndex), Number.MAX_SAFE_INTEGER);
 }
-function charactersEqual(left, right, ignoreCase) {
+function charactersEqual(left, right, ignoreCase, unicode = false) {
+  if (unicode && ignoreCase && left !== void 0)
+    return new RegExp(`^\\u{${right.codePointAt(0).toString(16)}}$`, "iu").test(left);
   return left !== void 0 && foldCharacter(left, ignoreCase) === foldCharacter(right, ignoreCase);
 }
+function advanceStringIndex(input, index, unicode) {
+  return index + (unicode && (input.codePointAt(index) ?? 0) > 65535 ? 2 : 1);
+}
+function readCharacter(input, position, direction, unicode) {
+  let index = direction === 1 ? position : position - 1;
+  if (index < 0 || index >= input.length) return void 0;
+  if (unicode && direction === -1 && index > 0 && input.charCodeAt(index) >= 56320 && input.charCodeAt(index) <= 57343 && input.charCodeAt(index - 1) >= 55296 && input.charCodeAt(index - 1) <= 56319) index--;
+  return unicode ? String.fromCodePoint(input.codePointAt(index)) : input[index];
+}
 function foldCharacter(character2, ignoreCase) {
   if (!ignoreCase) {
     return character2;
@@ -129579,6 +130169,75 @@ var init_engine2 = __esm({
   }
 });
 
+// packages/safe-js/src/interp/bigint-operators.ts
+function bigIntOperation(operator, left, right, budget) {
+  if (operator === ">>>") throw new TypeError("BigInts have no unsigned right shift.");
+  if ((operator === "/" || operator === "%") && right === 0n) throw new RangeError("Division by zero.");
+  if (operator === "**" && right < 0n) throw new RangeError("BigInt exponent must be nonnegative.");
+  const leftSize = left.toString(16).length;
+  const rightSize = right.toString(16).length;
+  budget.visitNode(leftSize + rightSize);
+  let size = Math.max(leftSize, rightSize) + 1;
+  let work = leftSize + rightSize;
+  if (operator === "*") {
+    size = leftSize + rightSize;
+    work = leftSize * rightSize;
+  } else if (operator === "/" || operator === "%") {
+    size = leftSize;
+    work = leftSize * rightSize;
+  } else if (operator === "**") {
+    if (right === 0n) return 1n;
+    if (left === 0n || left === 1n) return left;
+    if (left === -1n) return right % 2n === 0n ? 1n : -1n;
+    size = leftSize * Number(right);
+    work = size * size;
+  } else if (operator === "<<" || operator === ">>") {
+    if (left === 0n) return 0n;
+    const shift = operator === "<<" ? right : -right;
+    size = shift > 0n ? leftSize + Math.ceil(Number(shift) / 4) : leftSize;
+    work = size + rightSize;
+  }
+  if (!Number.isSafeInteger(size) || !Number.isSafeInteger(work))
+    throw new SandboxError({ budget: "dataSize", current: Infinity, limit: Number.MAX_SAFE_INTEGER });
+  budget.visitNode(work);
+  const allocation = {};
+  budget.setRetainedDataUsage(allocation, size);
+  try {
+    switch (operator) {
+      case "+":
+        return left + right;
+      case "-":
+        return left - right;
+      case "*":
+        return left * right;
+      case "/":
+        return left / right;
+      case "%":
+        return left % right;
+      case "**":
+        return left ** right;
+      case "&":
+        return left & right;
+      case "|":
+        return left | right;
+      case "^":
+        return left ^ right;
+      case "<<":
+        return left << right;
+      case ">>":
+        return left >> right;
+    }
+  } finally {
+    budget.setRetainedDataUsage(allocation, 0);
+  }
+}
+var init_bigint_operators = __esm({
+  "packages/safe-js/src/interp/bigint-operators.ts"() {
+    "use strict";
+    init_budget2();
+  }
+});
+
 // packages/safe-js/src/interp/jobs.ts
 import { AsyncLocalStorage as AsyncLocalStorage7 } from "node:async_hooks";
 function runPromiseJob(task) {
@@ -129768,7 +130427,7 @@ function callNumberMethod(value, methodName, args, budget, context) {
   if (argument !== null && typeof argument === "object") {
     return formatObjectArgument(value, methodName, argument, budget, context);
   }
-  return formatNumber3(value, methodName, argument === void 0 ? void 0 : Number(argument), budget);
+  return formatNumber3(value, methodName, argument === void 0 ? void 0 : +argument, budget);
 }
 async function formatObjectArgument(value, methodName, argument, budget, context) {
   const retainedArgument = {};
@@ -130124,7 +130783,7 @@ function callReplaceLikeMethod(value, methodName, args, budget, callClosure, use
   );
 }
 async function replaceRegex(value, regex, replacement, budget, callClosure, context) {
-  if (hasRegexPropertyOverride(regex, ["exec", "flags", ...Object.keys(regexFlagProperties)], budget))
+  if (getSandboxRegexPattern(regex).groups !== void 0 || hasRegexPropertyOverride(regex, ["exec", "flags", ...Object.keys(regexFlagProperties)], budget))
     return regexReplace(value, regex, replacement, budget, callClosure, context);
   if (regex.flags.includes("g")) regex.lastIndex = 0;
   const cursor2 = regex.lastIndex;
@@ -130174,7 +130833,7 @@ async function regexReplace(input, regex, replacementInput, budget, callClosure,
     input = void 0;
     replacement = isSandboxClosure(replacementInput) ? replacementInput : await sandboxString(replacementInput, budget, context);
     replacementInput = void 0;
-    if (isSandboxRegex(regex) && !hasRegexPropertyOverride(regex, ["exec", "flags", ...Object.keys(regexFlagProperties)], budget)) {
+    if (isSandboxRegex(regex) && getSandboxRegexPattern(regex).groups === void 0 && !hasRegexPropertyOverride(regex, ["exec", "flags", ...Object.keys(regexFlagProperties)], budget)) {
       release2();
       return await replaceRegex(value, regex, replacement, budget, callClosure, context);
     }
@@ -130389,7 +131048,7 @@ function splitNormalized(value, separator, limit, budget, parent) {
       while (result2.length < limit) {
         const match = executeRegex(splitter, value, Number(splitter.lastIndex));
         if (match === null) break;
-        if (match.text.length === 0) splitter.lastIndex = match.index + 1;
+        if (match.text.length === 0) splitter.lastIndex = advanceStringIndex(value, match.index, splitter.flags.includes("u") || splitter.flags.includes("v"));
         endedWithZeroWidthMatch = match.text.length === 0 && match.index === value.length;
         if (match.text.length === 0 && (match.index === copiedThrough || match.index === value.length))
           continue;
@@ -130548,7 +131207,7 @@ function callMatchLikeMethod(value, methodName, args, compilation, lastIndex) {
     return match?.index ?? -1;
   }
   if (methodName === "match" && !regex.flags.includes("g"))
-    return toMatchArray(executeRegex(regex, value, lastIndex ?? Number(regex.lastIndex)), value);
+    return toMatchArray(executeRegex(regex, value, lastIndex ?? Number(regex.lastIndex)), value, compilation.owner?.budget);
   if (methodName === "match") regex.lastIndex = 0;
   const matcher = methodName === "matchAll" ? createSandboxRegex(regex.source, regex.flags, normalizeLastIndex(lastIndex ?? Number(regex.lastIndex)), compilation) : regex;
   if (methodName === "matchAll")
@@ -130564,7 +131223,7 @@ function collectRegexMatches(regex, value, all, budget, lastIndex = 0) {
     budget?.allocateArrayLength(matches.length + 1);
     matches.push(match);
     lastIndex = match.index + match.text.length;
-    if (all && match.text.length === 0) regex.lastIndex = ++lastIndex;
+    if (all && match.text.length === 0) regex.lastIndex = lastIndex = advanceStringIndex(value, lastIndex, regex.flags.includes("u") || regex.flags.includes("v"));
   } while (all);
   return matches;
 }
@@ -130573,10 +131232,10 @@ function splitString(value, separator, limit) {
   return split.call(value, separator, limit);
 }
 function asNumber(value) {
-  return Number(value);
+  return +value;
 }
 function asNumberOrUndefined(value) {
-  return value === void 0 ? void 0 : Number(value);
+  return value === void 0 ? void 0 : +value;
 }
 function asStringOrUndefined(value) {
   return value === void 0 ? void 0 : String(value);
@@ -130987,7 +131646,7 @@ function createObjectArrayGlobals(options) {
     ),
     Number: createPrimitiveConstructor(
       {
-        call: (args, context) => sandboxNumber(args.length === 0 ? 0 : args[0], options.budget, context),
+        call: (args, context) => sandboxNumber(args.length === 0 ? 0 : args[0], options.budget, context, true),
         name: "Number",
         properties: {
           isFinite: createSandboxClosure({
@@ -135540,8 +136199,9 @@ async function evaluateIdentifierUpdateExpression(node, context) {
       )
     };
   }
-  const current = toNumber(await toNumericPrimitive(binding.value, context));
-  const next = node.operator === "++" ? current + 1 : current - 1;
+  const primitive = await toNumericPrimitive(binding.value, context);
+  const current = typeof primitive === "bigint" ? primitive : toNumber(primitive);
+  const next = typeof current === "bigint" ? bigIntOperation(node.operator === "++" ? "+" : "-", current, 1n, context.budget) : node.operator === "++" ? current + 1 : current - 1;
   context.scope.assign(node.argument.name, next);
   return {
     kind: "normal",
@@ -135558,10 +136218,9 @@ async function evaluateMemberUpdateExpression(node, context) {
       throw new TypeError("Cannot update properties of null or undefined.");
     }
     const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
-    const current = toNumber(
-      await toNumericPrimitive(await getPropertyValue(member.object, property, context, member.superReceiver === void 0 ? member.object : member.superReceiver.value), context)
-    );
-    const next = node.operator === "++" ? current + 1 : current - 1;
+    const primitive = await toNumericPrimitive(await getPropertyValue(member.object, property, context, member.superReceiver === void 0 ? member.object : member.superReceiver.value), context);
+    const current = typeof primitive === "bigint" ? primitive : toNumber(primitive);
+    const next = typeof current === "bigint" ? bigIntOperation(node.operator === "++" ? "+" : "-", current, 1n, context.budget) : node.operator === "++" ? current + 1 : current - 1;
     if (member.superReceiver === void 0) await setSandboxProperty(member.object, property, next, context.budget, true, createCoercionContext(context));
     else await setSuperProperty(member.object, member.superReceiver.value, property, next, context);
     return {
@@ -135595,7 +136254,7 @@ function getPropertyValue(target, property, context, receiver = target) {
   if (descriptor !== void 0)
     return readPropertyDescriptor(descriptor, receiver, createCoercionContext(context), true);
   if (isSandboxRegExpIterator(target)) return getRegExpIteratorMember(property, context.budget);
-  if (typeof target === "symbol") {
+  if (typeof target === "symbol" || typeof target === "bigint") {
     const prototype = getBoxedPrototype(target, context.budget);
     return prototype === void 0 ? void 0 : getPropertyValue(prototype, property, context, receiver);
   }
@@ -135776,6 +136435,7 @@ async function evaluateObjectPropertyKey(node, context) {
   return evaluateMemberProperty(node.key, context);
 }
 function getStaticPropertyName(node) {
+  if (node.type === "BigIntLiteral") return BigInt(node.value).toString();
   if (node.type === "Identifier") {
     return node.name;
   }
@@ -135809,7 +136469,7 @@ async function evaluateMemberCallExpression(node, context) {
       return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
     if (Array.isArray(member.object) && hasExplicitSandboxPrototype(member.object))
       return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
-    if ((typeof member.object === "string" || typeof member.object === "number" || typeof member.object === "boolean" || typeof member.object === "symbol") && getBoxedPrototype(member.object, context.budget) !== void 0) {
+    if ((typeof member.object === "string" || typeof member.object === "number" || typeof member.object === "bigint" || typeof member.object === "boolean" || typeof member.object === "symbol") && getBoxedPrototype(member.object, context.budget) !== void 0) {
       if (isDefaultBoxedMethod(member.object, member.property, context.budget)) {
         if (typeof member.object === "string" && isStringMethodName(member.property))
           return evaluateStringMethodCall(node, member.object, member.property, context);
@@ -136059,10 +136719,14 @@ async function applyUnaryOperator(operator, value, context) {
       return void 0;
     case "+":
       return toNumber(await toNumericPrimitive(value, context));
-    case "-":
-      return -toNumber(await toNumericPrimitive(value, context));
-    case "~":
-      return ~toNumber(await toNumericPrimitive(value, context));
+    case "-": {
+      const primitive = await toNumericPrimitive(value, context);
+      return typeof primitive === "bigint" ? bigIntOperation("-", 0n, primitive, context.budget) : -toNumber(primitive);
+    }
+    case "~": {
+      const primitive = await toNumericPrimitive(value, context);
+      return typeof primitive === "bigint" ? bigIntOperation("^", primitive, -1n, context.budget) : ~toNumber(primitive);
+    }
   }
 }
 function describeTypeofValue(value) {
@@ -136078,6 +136742,10 @@ function isTruthy(value) {
   return Boolean(value);
 }
 function applyBinaryOperator(node, left, right, context) {
+  if ((typeof left === "bigint" || typeof right === "bigint") && ["-", "*", "/", "%", "**", "&", "|", "^", "<<", ">>", ">>>"].includes(node.operator)) {
+    if (typeof left !== "bigint" || typeof right !== "bigint") throw new TypeError("Cannot mix BigInt and other numeric types.");
+    return bigIntOperation(node.operator, left, right, context.budget);
+  }
   switch (node.operator) {
     case "+":
       return applyAdditionOperator(left, right, context);
@@ -136196,6 +136864,10 @@ async function applyCompoundAssignmentOperator(operator, left, right, context) {
     left = await toNumericPrimitive(left, context, operator === "+=" ? "default" : "number");
     if (convertingObject) convertedLeft = left;
     right = await toNumericPrimitive(right, context, operator === "+=" ? "default" : "number");
+    if (operator !== "+=" && (typeof left === "bigint" || typeof right === "bigint")) {
+      if (typeof left !== "bigint" || typeof right !== "bigint") throw new TypeError("Cannot mix BigInt and other numeric types.");
+      return bigIntOperation(operator.slice(0, -1), left, right, context.budget);
+    }
     switch (operator) {
       case "+=":
         return applyAdditionOperator(left, right, context);
@@ -136232,6 +136904,10 @@ function applyAdditionOperator(left, right, context) {
   if (typeof leftPrimitive === "string" || typeof rightPrimitive === "string") {
     return context.budget.allocateString(toString(leftPrimitive) + toString(rightPrimitive));
   }
+  if (typeof leftPrimitive === "bigint" || typeof rightPrimitive === "bigint") {
+    if (typeof leftPrimitive !== "bigint" || typeof rightPrimitive !== "bigint") throw new TypeError("Cannot mix BigInt and other numeric types.");
+    return bigIntOperation("+", leftPrimitive, rightPrimitive, context.budget);
+  }
   return toNumber(leftPrimitive) + toNumber(rightPrimitive);
 }
 function compareRelational(left, right, operator) {
@@ -136249,8 +136925,9 @@ function compareRelational(left, right, operator) {
         return leftPrimitive >= rightPrimitive;
     }
   }
-  const leftNumber = toNumber(leftPrimitive);
-  const rightNumber = toNumber(rightPrimitive);
+  const hasBigInt = typeof leftPrimitive === "bigint" || typeof rightPrimitive === "bigint";
+  const leftNumber = typeof leftPrimitive === "bigint" || hasBigInt && typeof leftPrimitive === "string" ? leftPrimitive : toNumber(leftPrimitive);
+  const rightNumber = typeof rightPrimitive === "bigint" || hasBigInt && typeof rightPrimitive === "string" ? rightPrimitive : toNumber(rightPrimitive);
   switch (operator) {
     case "<":
       return leftNumber < rightNumber;
@@ -136263,6 +136940,7 @@ function compareRelational(left, right, operator) {
   }
 }
 function isLooselyEqual(left, right) {
+  if (typeof left === "bigint" || typeof right === "bigint") return left == right;
   const leftType = getCoercionType(left);
   const rightType = getCoercionType(right);
   if (leftType === rightType) {
@@ -136295,6 +136973,7 @@ function isPrimitiveCoercionType(type) {
   return type !== "object";
 }
 function getCoercionType(value) {
+  if (typeof value === "bigint") return "bigint";
   if (typeof value === "symbol") return "symbol";
   if (value === null) {
     return "null";
@@ -136328,6 +137007,7 @@ async function toNumericPrimitive(value, context, hint = "number") {
   throw new TypeError("Expected a sandbox value.");
 }
 function toNumber(value) {
+  if (typeof value === "bigint") throw new TypeError("Cannot convert a BigInt value to a number");
   if (typeof value === "symbol") throw new TypeError("Cannot convert a Symbol value to a number");
   if (isSandboxDate(value)) return dateTime(value);
   if (typeof value === "number") {
@@ -136747,6 +137427,7 @@ var init_interpreter = __esm({
   "packages/safe-js/src/interp/interpreter.ts"() {
     "use strict";
     init_promise_replay();
+    init_bigint_operators();
     init_accessors();
     init_host_capabilities();
     init_property_key();
@@ -136800,6 +137481,16 @@ var init_interpreter = __esm({
       ArrowFunctionExpression: evaluateArrowFunction,
       AwaitExpression: evaluateAwait,
       BinaryExpression: evaluateBinaryExpression,
+      BigIntLiteral: async (node, context) => {
+        const allocation = {};
+        context.budget.visitNode(node.value.length);
+        context.budget.setRetainedDataUsage(allocation, node.value.length);
+        try {
+          return { kind: "normal", hasValue: true, value: BigInt(node.value) };
+        } finally {
+          context.budget.setRetainedDataUsage(allocation, 0);
+        }
+      },
       BlockStatement: evaluateBlockStatement,
       BooleanLiteral: evaluatePrimitiveLiteral,
       CallExpression: evaluateCallExpression,
@@ -136968,7 +137659,7 @@ async function callRegexMethod(target, methodName, args, budget, context) {
     cursor2 = target.lastIndex;
     const lastIndex = await sandboxNumber(cursor2, budget, context);
     const match = executeRegex(target, input, lastIndex);
-    return toMatchArray(match, input);
+    return toMatchArray(match, input, budget);
   } finally {
     budget.setRetainedValues(retained, void 0);
   }
@@ -137019,17 +137710,26 @@ async function regexToString(target, budget, context) {
 function executeRegex(target, input, lastIndex) {
   const pattern = getSandboxRegexPattern(target);
   const match = matchRegex(pattern, input, lastIndex);
-  if (pattern.flags.global) {
+  if (pattern.flags.global || pattern.flags.sticky) {
     target.lastIndex = match === null ? 0 : match.index + match.text.length;
   }
   return match;
 }
-function toMatchArray(match, input) {
+function toMatchArray(match, input, budget) {
   if (match === null) {
     return null;
   }
+  budget?.allocateArrayLength(match.captures.length + 1);
   const result = [match.text, ...match.captures];
-  Object.assign(result, { index: match.index, input, groups: void 0 });
+  if (match.groups !== void 0) setSandboxPrototype(match.groups, null, budget);
+  if (match.indicesGroups !== void 0) setSandboxPrototype(match.indicesGroups, null, budget);
+  Object.assign(result, { index: match.index, input, groups: match.groups });
+  if (match.indices !== void 0) {
+    budget?.allocateArrayLength(match.indices.length);
+    budget?.allocateArrayLength(2);
+    Object.assign(match.indices, { groups: match.indicesGroups });
+    Object.assign(result, { indices: match.indices });
+  }
   return result;
 }
 var regexMethodNames, regexFlagProperties;
@@ -137064,9 +137764,10 @@ function nextRegExpIterator(iterator, budget) {
   budget?.visitNode();
   if (state.exhausted) return { value: void 0, done: true };
   const matcher = state.matcher;
+  if (!isSandboxRegex(matcher)) throw new TypeError("Custom RegExp iterator execution requires a sandbox context.");
   const input = state.input;
   const match = executeRegex(matcher, input, Number(matcher.lastIndex));
-  if (match === null || !matcher.flags.includes("g")) {
+  if (match === null || !(state.global ?? matcher.flags.includes("g"))) {
     state.exhausted = true;
     state.matcher = void 0;
     state.input = void 0;
@@ -137074,12 +137775,52 @@ function nextRegExpIterator(iterator, budget) {
   if (match === null) return { value: void 0, done: true };
   if (!state.exhausted && match.text.length === 0) {
     const index = Number(matcher.lastIndex);
-    const unicode = matcher.flags.includes("u") || matcher.flags.includes("v");
+    const unicode = state.unicode ?? (matcher.flags.includes("u") || matcher.flags.includes("v"));
     const codePoint = input.codePointAt(index);
     matcher.lastIndex = index + (unicode && codePoint !== void 0 && codePoint > 65535 ? 2 : 1);
   }
-  budget?.allocateArrayLength(match.captures.length + 1);
-  return { value: toMatchArray(match, input), done: false };
+  return { value: toMatchArray(match, input, budget), done: false };
+}
+async function nextObservableRegExpIterator(iterator, budget, context) {
+  const state = regexpIteratorState(iterator);
+  if (state.exhausted) return { value: void 0, done: true };
+  const matcher = state.matcher;
+  if (isSandboxRegex(matcher) && !hasRegexPropertyOverride(matcher, ["exec"], budget) && (matcher.lastIndex === null || typeof matcher.lastIndex !== "object"))
+    return nextRegExpIterator(iterator, budget);
+  const input = state.input;
+  let result;
+  let field;
+  const release2 = retainValues(budget, () => [iterator, matcher, input, result, field]);
+  const read = (value, key3) => {
+    if (context.getProperty !== void 0) return context.getProperty(value, key3);
+    const descriptor = getSandboxPropertyDescriptor(value, key3, budget);
+    return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, value, context);
+  };
+  try {
+    budget.visitNode();
+    result = await regexExec(matcher, input, budget, context);
+    const global2 = state.global ?? (isSandboxRegex(matcher) && matcher.flags.includes("g"));
+    if (result === null || !global2) {
+      state.exhausted = true;
+      state.matcher = void 0;
+      state.input = void 0;
+      return result === null ? { value: void 0, done: true } : { value: result, done: false };
+    }
+    field = await read(result, "0");
+    const text5 = await sandboxString(field, budget, context);
+    field = void 0;
+    if (text5.length === 0) {
+      field = await read(matcher, "lastIndex");
+      const index = normalizeLastIndex(await sandboxNumber(field, budget, context));
+      field = void 0;
+      const unicode = state.unicode ?? (isSandboxRegex(matcher) && (matcher.flags.includes("u") || matcher.flags.includes("v")));
+      const point = input.codePointAt(index);
+      await setSandboxProperty(matcher, "lastIndex", index + (unicode && point !== void 0 && point > 65535 ? 2 : 1), budget, true, context);
+    }
+    return { value: result, done: false };
+  } finally {
+    release2();
+  }
 }
 function getRegExpIteratorMember(property, budget) {
   if (property === Symbol.toStringTag) return "RegExp String Iterator";
@@ -137096,7 +137837,7 @@ function getRegExpIteratorMember(property, budget) {
       const receiver = context?.thisValue;
       if (!isSandboxRegExpIterator(receiver))
         throw new TypeError("RegExp string iterator next requires a matching receiver.");
-      return nextRegExpIterator(receiver, budget);
+      return context === void 0 ? nextRegExpIterator(receiver, budget) : nextObservableRegExpIterator(receiver, budget, context);
     }
   });
 }
@@ -137106,6 +137847,12 @@ var init_regexp_iterator2 = __esm({
     init_regexp_iterator();
     init_values();
     init_regex();
+    init_object_model();
+    init_accessors();
+    init_interpreter();
+    init_string_coercion();
+    init_engine2();
+    init_resources();
   }
 });
 
@@ -137292,8 +138039,11 @@ function getSandboxIterator(value, budget, context) {
   }
   if (isSandboxCollectionIterator(value))
     return { next: () => nextCollectionIterator(value, budget), snapshotIndex: () => 0 };
-  if (isSandboxRegExpIterator(value))
+  if (isSandboxRegExpIterator(value)) {
+    if (context !== void 0 && budget !== void 0)
+      return { asynchronous: true, next: () => nextObservableRegExpIterator(value, budget, context), snapshotIndex: () => 0 };
     return { next: () => nextRegExpIterator(value, budget), snapshotIndex: () => 0 };
+  }
   if (isGuestHostObject(value)) return getHostObjectIterator(value);
   if (isFloat32Array(value)) {
     return syncIterator(Float32Array.prototype.values.call(value));
@@ -138606,7 +139356,7 @@ function wrapSandboxClosureForHost(closure, stackFrames, budget, compileOwner, c
   return wrapped;
 }
 function isSandboxLikeValue(value) {
-  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
     return true;
   }
   if (isSandboxClosure(value) || isSandboxPromise(value)) {
@@ -138671,7 +139421,7 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path193) {
     if (options.realm === void 0 || options.errorData || options.hostCalls !== void 0) throw new TypeError("Live capabilities are not portable replay or error data.");
     return importHostCapability(value, options.realm.owner);
   }
-  if (value === null || value === void 0 || typeof value === "number" || typeof value === "boolean") {
+  if (value === null || value === void 0 || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
     return value;
   }
   if (typeof value === "string") {
@@ -139194,12 +139944,16 @@ var init_date2 = __esm({
 });
 
 // packages/safe-js/src/interp/string-coercion.ts
-function sandboxNumber(value, budget, context) {
+function sandboxNumber(value, budget, context, allowBigInt = false) {
+  const convert = (primitive) => {
+    if (typeof primitive === "bigint" && !allowBigInt) throw new TypeError("Cannot convert a BigInt value to a number");
+    return Number(primitive);
+  };
   if (value === null || typeof value !== "object") {
     if (typeof value === "function") throw new TypeError("Expected a sandbox value.");
-    return Number(value);
+    return convert(value);
   }
-  return objectToPrimitive(value, budget, context, /* @__PURE__ */ new Set(), "number").then(Number);
+  return objectToPrimitive(value, budget, context, /* @__PURE__ */ new Set(), "number").then(convert);
 }
 function sandboxString(value, budget, context, joining = /* @__PURE__ */ new Set()) {
   if (typeof value === "symbol") throw new TypeError("Cannot convert a Symbol value to a string");
@@ -141292,6 +142046,10 @@ function measureSandboxData(values, options = {}) {
   const seenSymbols = /* @__PURE__ */ new Set();
   let usage = 0;
   const visit = (value, depth = 0) => {
+    if (typeof value === "bigint") {
+      usage += value.toString(16).length;
+      return;
+    }
     if (typeof value === "symbol") {
       if (!seenSymbols.has(value)) {
         seenSymbols.add(value);
@@ -141550,7 +142308,7 @@ function copyToSandbox(value, state, path193 = "<root>", cloneSandboxCollections
     const copy = restoreSandboxRegExpIterator({ matcher: void 0, input: void 0, exhausted: true });
     state.seen.set(value, copy);
     const matcher = copyToSandbox(snapshot2.matcher, state, `${path193}.<matcher>`, true, depth + 1);
-    if (matcher !== void 0 && !isSandboxRegex(matcher)) throw new TypeError("Invalid RegExp iterator matcher.");
+    if (matcher !== void 0 && (snapshot2.global === void 0 ? !isSandboxRegex(matcher) : matcher === null || typeof matcher !== "object")) throw new TypeError("Invalid RegExp iterator matcher.");
     restoreSandboxRegExpIterator({ ...snapshot2, matcher }, copy);
     for (const entry of getEnumerableObjectEntries(value, path193)) {
       defineOwnDataProperty(copy, entry.key, copyToSandbox(entry.value, state, joinPath2(path193, entry.key), true, depth + 1));
@@ -141738,6 +142496,7 @@ function copyToSandbox(value, state, path193 = "<root>", cloneSandboxCollections
     const copy = createPlainObject(
       !cloneSandboxCollections || Object.getPrototypeOf(value) === null
     );
+    if (!state.structuredClone && hasNullObjectPrototype(value)) setSandboxPrototype(copy, null);
     state.seen.set(value, copy);
     const errorType = sandboxErrorTypes.get(value);
     if (errorType !== void 0) sandboxErrorTypes.set(copy, errorType);
@@ -141949,7 +142708,7 @@ function copyFromSandbox(value, state, path193 = "<root>", options, depth = 0) {
     if (existing !== void 0) {
       return existing;
     }
-    const copy = createPlainObject(Object.getPrototypeOf(value) === null);
+    const copy = createPlainObject(hasNullObjectPrototype(value) || Object.getPrototypeOf(value) === null);
     state.seen.set(value, copy);
     for (const entry of getEnumerableObjectEntries(value, path193)) {
       defineOwnDataProperty(
@@ -141963,7 +142722,7 @@ function copyFromSandbox(value, state, path193 = "<root>", options, depth = 0) {
   throw new TypeError(`Unsupported sandbox value at ${path193}: ${describeValue2(value)}`);
 }
 function isSandboxPrimitive(value) {
-  return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "symbol";
+  return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || typeof value === "symbol";
 }
 function isHostPromise(value) {
   return value instanceof Promise;
@@ -142326,6 +143085,7 @@ function createDumpFile(snapshot2) {
   return dumped;
 }
 function serializeDumpValue(value, path193, state) {
+  if (typeof value === "bigint") return { kind: "bigint", value: String(value) };
   if (typeof value === "symbol") return serializeSymbol(value, state.heapIds, state.heap);
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
@@ -142372,11 +143132,14 @@ function serializeHeapReference(value, path193, state) {
     if (isSandboxRegExpIterator(value)) {
       const snapshot2 = regexpIteratorState(value);
       const matcher = snapshot2.matcher;
+      const serializedMatcher = snapshot2.global === void 0 && isSandboxRegex(matcher) ? { kind: "regex", source: matcher.source, flags: matcher.flags, lastIndex: Number(matcher.lastIndex) } : serializeDumpValue(matcher, `${path193}.<matcher>`, state);
+      if (serializedMatcher === SKIP_VALUE) throw new TypeError("Unsupported RegExp iterator matcher in public dump.");
       const entries = /* @__PURE__ */ Object.create(null);
       state.heap[String(id)] = {
         kind: "regexp-iterator",
         exhausted: snapshot2.exhausted,
-        matcher: matcher === void 0 ? { kind: "undefined" } : { kind: "regex", source: matcher.source, flags: matcher.flags, lastIndex: Number(matcher.lastIndex) },
+        matcher: serializedMatcher,
+        ...snapshot2.global === void 0 ? {} : { global: snapshot2.global, unicode: snapshot2.unicode },
         input: snapshot2.input ?? { kind: "undefined" },
         entries,
         symbolEntries: serializeSymbolProperties(value, (entry) => {
@@ -142449,6 +143212,7 @@ function serializeHeapReference(value, path193, state) {
       });
       state.heap[String(id)] = {
         kind: "object",
+        ...hasNullObjectPrototype(value) ? { sandboxNullPrototype: true } : {},
         entries: serializeObjectEntries(value, path193, state),
         ...symbolEntries.length === 0 ? {} : { symbolEntries },
         ...errorType === void 0 ? {} : { errorType }
@@ -142482,7 +143246,7 @@ function indexHeapContainers(snapshot2) {
   const heapIds = /* @__PURE__ */ new Map();
   let nextId = 1;
   for (const [value, stat35] of stats2.entries()) {
-    if (stat35.count > 1 || stat35.cyclic || ownSerializableSymbolKeys(value).length > 0 || isSandboxBox(value) || isSandboxRegExpIterator(value) || isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxDate(value) || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
+    if (stat35.count > 1 || stat35.cyclic || hasNullObjectPrototype(value) || ownSerializableSymbolKeys(value).length > 0 || isSandboxBox(value) || isSandboxRegExpIterator(value) || isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxDate(value) || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
       heapIds.set(value, nextId);
       nextId += 1;
     }
@@ -142664,6 +143428,8 @@ function validateDumpHeap(root, state) {
       continue;
     }
     if (entry.kind === "object") {
+      if (Object.hasOwn(entry, "sandboxNullPrototype") && entry.sandboxNullPrototype !== true)
+        fail2("invalidValue", `${path193}.sandboxNullPrototype`, "invalid object prototype");
       requireRecord3(entry.entries, `${path193}.entries`);
       continue;
     }
@@ -142747,6 +143513,14 @@ function validateValue(value, path193, depth, state) {
 }
 function validateTaggedValue(record2, path193, state) {
   switch (record2.kind) {
+    case "bigint":
+      requireString2(record2.value, `${path193}.value`, state.limits);
+      try {
+        validateBigIntData(record2.value);
+      } catch {
+        fail2("invalidValue", `${path193}.value`, "invalid BigInt value");
+      }
+      return;
     case "undefined":
       return;
     case "number":
@@ -142784,7 +143558,11 @@ function validateTaggedValue(record2, path193, state) {
       return;
     case "array":
     case "arguments":
+      return;
     case "object":
+      if (Object.hasOwn(record2, "sandboxNullPrototype") && record2.sandboxNullPrototype !== true)
+        fail2("invalidValue", `${path193}.sandboxNullPrototype`, "invalid object prototype");
+      return;
     case "map":
     case "set":
     case "collection-iterator":
@@ -142854,6 +143632,8 @@ function validateHeapValue(value, path193, state, heap) {
   }
   if (record2.kind === "set") requireArray(record2.values, `${path193}.values`, state);
   if (record2.kind === "regexp-iterator") {
+    if ((record2.global !== void 0 || record2.unicode !== void 0) && (typeof record2.global !== "boolean" || typeof record2.unicode !== "boolean"))
+      fail2("invalidValue", path193, "invalid RegExp iterator modes");
     if (typeof record2.exhausted !== "boolean") fail2("invalidValue", `${path193}.exhausted`, "invalid iterator exhaustion");
     if (!Object.hasOwn(record2, "matcher") || !Object.hasOwn(record2, "input")) fail2("invalidValue", path193, "missing RegExp iterator state");
     requireRecord3(record2.entries, `${path193}.entries`);
@@ -142907,6 +143687,14 @@ function validateBoxedRecord(record2, path193, heap) {
   const value = record2.value;
   if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") return;
   const number = requireRecord3(value, `${path193}.value`);
+  if (number.kind === "bigint") {
+    try {
+      validateBigIntData(number.value);
+    } catch {
+      fail2("invalidValue", `${path193}.value`, "invalid boxed BigInt payload");
+    }
+    return;
+  }
   if (number.kind === "ref") {
     const id = requireSafeInteger(number.id, `${path193}.value.id`, 1);
     const target = requireRecord3(heap[String(id)], `${path193}.value`);
@@ -143153,6 +143941,7 @@ var init_validation = __esm({
   "packages/safe-js/src/snapshot/validation.ts"() {
     "use strict";
     init_shape();
+    init_bigint();
     init_regexp_properties2();
     init_symbols2();
     init_dump_format();
@@ -144066,6 +144855,7 @@ var init_known_globals = __esm({
       "AggregateError",
       "Array",
       "Boolean",
+      "BigInt",
       "Date",
       "Error",
       "Infinity",
@@ -147310,6 +148100,7 @@ function expressionContainsAwait(node) {
     case "MetaProperty":
     case "NullLiteral":
     case "NumericLiteral":
+    case "BigIntLiteral":
     case "RegexLiteral":
     case "StringLiteral":
     case "ThisExpression":
@@ -147593,6 +148384,7 @@ var init_AS_async_not_needed = __esm({
           case "MetaProperty":
           case "NullLiteral":
           case "NumericLiteral":
+          case "BigIntLiteral":
           case "RegexLiteral":
           case "StringLiteral":
           case "UndefinedLiteral":
@@ -151072,6 +151864,7 @@ function expressionContainsAwait2(node) {
     case "MetaProperty":
     case "NullLiteral":
     case "NumericLiteral":
+    case "BigIntLiteral":
     case "RegexLiteral":
     case "StringLiteral":
     case "ThisExpression":
@@ -151343,6 +152136,7 @@ var init_AS_missing_async = __esm({
           case "MetaProperty":
           case "NullLiteral":
           case "NumericLiteral":
+          case "BigIntLiteral":
           case "RegexLiteral":
           case "StringLiteral":
           case "UndefinedLiteral":
@@ -154726,29 +155520,53 @@ function createConsoleJsonGlobals(options) {
   };
 }
 async function stringifyJson4(value, replacer, indent, budget, context) {
-  if (replacer !== void 0 && replacer !== null && !isSandboxClosure(replacer)) {
-    throw new TypeError(
-      "JSON.stringify(value, replacer, indent) only supports function, null, or undefined replacers."
-    );
-  }
-  if (indent !== void 0 && typeof indent !== "number" && typeof indent !== "string") {
-    throw new TypeError(
-      "JSON.stringify(value, replacer, indent) requires indent to be a string, number, or undefined."
-    );
-  }
-  const holder = {};
-  defineDataProperty9(holder, "", value);
-  const output = await stringifyProperty("", holder, {
-    budget,
-    context,
-    gap: normalizeStringifyGap(indent),
-    replacer: isSandboxClosure(replacer) ? replacer : void 0,
-    stack: []
-  });
-  if (output === void 0) {
-    return void 0;
+  const allocation = {};
+  let propertyList;
+  const release2 = retainValues(budget, () => [value, replacer, indent]);
+  try {
+    if (Array.isArray(replacer)) {
+      propertyList = [];
+      const seen = /* @__PURE__ */ new Set();
+      let size = 0;
+      const state = { budget, context, gap: "", stack: [] };
+      const length = replacer.length;
+      for (let index = 0; index < length; index++) {
+        budget.visitNode();
+        const entry = await getStringifyProperty(replacer, String(index), state);
+        const primitive = isSandboxBox(entry) ? boxedValue(entry) : entry;
+        if (typeof primitive !== "string" && typeof primitive !== "number") continue;
+        const key3 = await sandboxString(entry, budget, context);
+        if (seen.has(key3)) continue;
+        budget.allocateArrayLength(propertyList.length + 1);
+        size += key3.length + 2;
+        budget.setRetainedDataUsage(allocation, size);
+        propertyList.push(key3);
+        seen.add(key3);
+      }
+    }
+    if (isSandboxBox(indent)) {
+      const primitive = boxedValue(indent);
+      if (typeof primitive === "number") indent = await sandboxNumber(indent, budget, context);
+      else if (typeof primitive === "string") indent = await sandboxString(indent, budget, context);
+    }
+    const holder = {};
+    defineDataProperty9(holder, "", value);
+    const output = await stringifyProperty("", holder, {
+      budget,
+      context,
+      gap: normalizeStringifyGap(indent),
+      replacer: isSandboxClosure(replacer) ? replacer : void 0,
+      propertyList,
+      stack: []
+    });
+    if (output === void 0) {
+      return void 0;
+    }
+    return budget.allocateString(output);
+  } finally {
+    budget.setRetainedDataUsage(allocation, 0);
+    release2();
   }
-  return budget.allocateString(output);
 }
 async function stringifyProperty(key3, holder, state, indent = "") {
   let value = await getStringifyProperty(holder, key3, state);
@@ -154756,7 +155574,7 @@ async function stringifyProperty(key3, holder, state, indent = "") {
   try {
     if (isSandboxDate(value) && getSandboxPropertyDescriptor(value, "toJSON", state.budget) === void 0) {
       value = await dateToJSON(value, state.budget, state.context);
-    } else if (isStringifyContainer(value)) {
+    } else if (typeof value === "bigint" || isSandboxClosure(value) || isStringifyContainer(value)) {
       const toJSON = await getStringifyProperty(value, "toJSON", state);
       if (isSandboxClosure(toJSON)) {
         value = await callStringifyClosure(toJSON, [key3], value, state);
@@ -154838,7 +155656,7 @@ async function stringifyObject(value, state, indent) {
   const release2 = retainValues(state.budget, () => entries);
   try {
     const nextIndent = indent + state.gap;
-    for (const key3 of Object.keys(value)) {
+    for (const key3 of state.propertyList ?? Object.keys(value)) {
       const serialized = await stringifyProperty(key3, value, state, nextIndent);
       if (serialized !== void 0) {
         entries.push(`${quoteJsonString(key3)}:${state.gap === "" ? "" : " "}${serialized}`);
@@ -154901,19 +155719,17 @@ function isStringifyObject(value) {
   return isStringifyContainer(value) && !Array.isArray(value);
 }
 function toSandboxValue(value) {
-  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || isSandboxClosure(value) || isSandboxPromise(value) || Array.isArray(value) || isStringifyContainer(value)) {
+  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "symbol" || typeof value === "boolean" || isSandboxClosure(value) || isSandboxPromise(value) || Array.isArray(value) || isStringifyContainer(value)) {
     return value;
   }
-  if (typeof value === "bigint") {
-    throw new TypeError("Do not know how to serialize a BigInt.");
-  }
   throw new TypeError(
     `JSON.stringify(value) produced an unsupported value of type ${typeof value}.`
   );
 }
 function getStringifyProperty(target, key3, state) {
   if (state.context?.getProperty !== void 0) return state.context.getProperty(target, key3);
-  const descriptor = getSandboxPropertyDescriptor(target, key3, state.budget);
+  const object = typeof target === "bigint" ? getBoxedPrototype(target, state.budget) : target;
+  const descriptor = object === void 0 ? void 0 : getSandboxPropertyDescriptor(object, key3, state.budget);
   return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, target, state.context);
 }
 function copyJsonToSandbox(value, budget) {
@@ -155079,6 +155895,104 @@ var init_math = __esm({
   }
 });
 
+// packages/safe-js/src/interp/methods/regex-split.ts
+async function regexSplit(target, input, limit, constructor, budget, context) {
+  if (target === null || typeof target !== "object") throw new TypeError("RegExp split requires an object receiver.");
+  let string;
+  let species;
+  let field;
+  let flags;
+  let matcher;
+  let match;
+  const result = [];
+  const release2 = retainValues(budget, () => [target, input, limit, string, species, field, flags, matcher, match, result]);
+  const read = (value, key3) => {
+    if (context?.getProperty !== void 0) return context.getProperty(value, key3);
+    const descriptor = getSandboxPropertyDescriptor(value, key3, budget);
+    return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, value, context);
+  };
+  const append = (value) => {
+    budget.allocateArrayLength(result.length + 1);
+    result.push(value);
+  };
+  try {
+    string = await sandboxString(input, budget, context);
+    input = void 0;
+    field = await read(target, "constructor");
+    species = constructor;
+    if (field !== void 0) {
+      if (field === null || typeof field !== "object") throw new TypeError("Invalid RegExp species constructor.");
+      species = await read(field, Symbol.species);
+      if (species === null || species === void 0) species = constructor;
+    }
+    field = void 0;
+    if (!isSandboxClosure(species) || species.construct === void 0) throw new TypeError("RegExp species must be a constructor.");
+    field = await read(target, "flags");
+    flags = await sandboxString(field, budget, context);
+    field = void 0;
+    const unicode = flags.includes("u") || flags.includes("v");
+    if (!flags.includes("y")) flags = budget.allocateString(flags + "y");
+    matcher = await invokeBuiltinClosure(species, [target, flags], budget, context, void 0, true);
+    const maximum = limit === void 0 ? 2 ** 32 - 1 : await sandboxNumber(limit, budget, context) >>> 0;
+    limit = void 0;
+    if (maximum === 0) return result;
+    if (string.length === 0) {
+      match = await regexExec(matcher, string, budget, context);
+      if (match === null) append(string);
+      return result;
+    }
+    let end = 0;
+    let index = 0;
+    while (index < string.length) {
+      budget.visitNode();
+      match = void 0;
+      await setSandboxProperty(matcher, "lastIndex", index, budget, true, context);
+      match = await regexExec(matcher, string, budget, context);
+      if (match !== null) {
+        field = await read(matcher, "lastIndex");
+        const next = Math.min(normalizeLastIndex(await sandboxNumber(field, budget, context)), string.length);
+        field = void 0;
+        if (next !== end) {
+          append(budget.allocateString(string.slice(end, index)));
+          if (result.length === maximum) return result;
+          end = next;
+          field = await read(match, "length");
+          const length = normalizeLastIndex(await sandboxNumber(field, budget, context));
+          field = void 0;
+          for (let capture = 1; capture < length; capture++) {
+            budget.visitNode();
+            field = await read(match, String(capture));
+            append(field);
+            field = void 0;
+            if (result.length === maximum) return result;
+          }
+          index = end;
+          continue;
+        }
+      }
+      index += unicode && (string.codePointAt(index) ?? 0) > 65535 ? 2 : 1;
+    }
+    append(budget.allocateString(string.slice(end)));
+    return result;
+  } finally {
+    release2();
+  }
+}
+var init_regex_split = __esm({
+  "packages/safe-js/src/interp/methods/regex-split.ts"() {
+    "use strict";
+    init_values();
+    init_object_model();
+    init_accessors();
+    init_builtin_call();
+    init_interpreter();
+    init_string_coercion();
+    init_engine2();
+    init_resources();
+    init_regex();
+  }
+});
+
 // packages/safe-js/src/interp/globals/regex.ts
 function createRegexGlobals(options) {
   const invoke2 = (construct) => async (args, context) => {
@@ -155143,7 +156057,55 @@ function createRegexGlobals(options) {
     }
   };
   const constructor = createSandboxClosure({ guest: true, sandbox: true, name: "RegExp", length: 2, call: invoke2(false), construct: invoke2(true) });
+  Object.defineProperty(materializeFunctionProperties(constructor), "escape", {
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "escape",
+      length: 1,
+      call: (args) => {
+        const input = args[0];
+        if (typeof input !== "string") throw new TypeError("RegExp.escape requires a string.");
+        const allocation = {};
+        let escaped = "";
+        try {
+          for (const character2 of input) {
+            options.budget.visitNode();
+            const point = character2.codePointAt(0);
+            let part = character2;
+            if (escaped.length === 0 && (point >= 48 && point <= 57 || point >= 65 && point <= 90 || point >= 97 && point <= 122)) {
+              part = `\\x${point.toString(16)}`;
+            } else if ("^$\\.*+?()[]{}|/".includes(character2)) {
+              part = "\\" + character2;
+            } else {
+              const control2 = "\f\n\r	\v".indexOf(character2);
+              if (control2 !== -1) part = "\\" + "fnrtv"[control2];
+              else if (",-=<>#&!%:;@~'`\"".includes(character2) || character2.trim() === "" || point >= 55296 && point <= 57343) {
+                part = point <= 255 ? `\\x${point.toString(16).padStart(2, "0")}` : `\\u${point.toString(16).padStart(4, "0")}`;
+              }
+            }
+            options.budget.setRetainedDataUsage(allocation, escaped.length + part.length);
+            escaped = options.budget.allocateString(escaped + part);
+          }
+          return escaped;
+        } finally {
+          options.budget.setRetainedDataUsage(allocation, 0);
+        }
+      }
+    }),
+    writable: true,
+    configurable: true
+  });
   const prototype = /* @__PURE__ */ Object.create(null);
+  Object.defineProperty(materializeFunctionProperties(constructor), Symbol.species, {
+    get: accessorAdapter(createSandboxClosure({
+      sandbox: true,
+      name: "get [Symbol.species]",
+      length: 0,
+      call: (_args, context) => context?.thisValue
+    }), "get"),
+    configurable: true
+  });
   Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false });
   Object.defineProperty(prototype, "constructor", { value: constructor, writable: true, configurable: true });
   Object.defineProperty(prototype, Symbol.search, {
@@ -155186,6 +156148,73 @@ function createRegexGlobals(options) {
     writable: true,
     configurable: true
   });
+  Object.defineProperty(prototype, Symbol.matchAll, {
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "[Symbol.matchAll]",
+      length: 1,
+      call: async (args, context) => {
+        const target = context?.thisValue;
+        if (target === null || typeof target !== "object") throw new TypeError("RegExp matchAll requires an object receiver.");
+        let input = args[0];
+        let string;
+        let species;
+        let field;
+        let flags;
+        let matcher;
+        const release2 = retainValues(options.budget, () => [target, input, string, species, field, flags, matcher]);
+        const read = (value, key3) => {
+          if (context?.getProperty !== void 0) return context.getProperty(value, key3);
+          const descriptor = getSandboxPropertyDescriptor(value, key3, options.budget);
+          return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, value, context);
+        };
+        try {
+          string = await sandboxString(input, options.budget, context);
+          input = void 0;
+          field = await read(target, "constructor");
+          species = constructor;
+          if (field !== void 0) {
+            if (field === null || typeof field !== "object") throw new TypeError("Invalid RegExp species constructor.");
+            species = await read(field, Symbol.species);
+            if (species === null || species === void 0) species = constructor;
+          }
+          field = void 0;
+          if (!isSandboxClosure(species) || species.construct === void 0) throw new TypeError("RegExp species must be a constructor.");
+          field = await read(target, "flags");
+          flags = await sandboxString(field, options.budget, context);
+          field = void 0;
+          matcher = await invokeBuiltinClosure(species, [target, flags], options.budget, context, void 0, true);
+          field = await read(target, "lastIndex");
+          const cursor2 = normalizeLastIndex(await sandboxNumber(field, options.budget, context));
+          field = void 0;
+          await setSandboxProperty(matcher, "lastIndex", cursor2, options.budget, true, context);
+          return restoreSandboxRegExpIterator({
+            matcher,
+            input: string,
+            exhausted: false,
+            global: flags.includes("g"),
+            unicode: flags.includes("u") || flags.includes("v")
+          });
+        } finally {
+          release2();
+        }
+      }
+    }),
+    writable: true,
+    configurable: true
+  });
+  Object.defineProperty(prototype, Symbol.split, {
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "[Symbol.split]",
+      length: 2,
+      call: (args, context) => regexSplit(context?.thisValue, args[0], args[1], constructor, options.budget, context)
+    }),
+    writable: true,
+    configurable: true
+  });
   for (const name of ["exec", "test", "toString"]) {
     Object.defineProperty(prototype, name, {
       value: createSandboxClosure({
@@ -155231,6 +156260,11 @@ var init_regex2 = __esm({
     init_regex();
     init_string();
     init_builtin_call();
+    init_regexp_iterator();
+    init_engine2();
+    init_resources();
+    init_interpreter();
+    init_regex_split();
   }
 });
 
@@ -155434,6 +156468,109 @@ var init_symbol = __esm({
   }
 });
 
+// packages/safe-js/src/interp/globals/bigint.ts
+function createBigIntGlobal(budget) {
+  const convert = async (value, context, allowNumber = false) => {
+    const primitive = value !== null && typeof value === "object" ? await objectToPrimitive(value, budget, context, /* @__PURE__ */ new Set(), "number") : value;
+    if (typeof primitive === "bigint") return primitive;
+    if (typeof primitive !== "string" && typeof primitive !== "boolean" && !(allowNumber && typeof primitive === "number"))
+      throw new TypeError("Cannot convert value to BigInt.");
+    const size = typeof primitive === "string" ? primitive.length : 256;
+    budget.visitNode(size);
+    const allocation = {};
+    budget.setRetainedDataUsage(allocation, size);
+    try {
+      return BigInt(primitive);
+    } finally {
+      budget.setRetainedDataUsage(allocation, 0);
+    }
+  };
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "BigInt",
+    length: 1,
+    call: ([value], context) => convert(value, context, true)
+  });
+  const prototype = /* @__PURE__ */ Object.create(null);
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    valueOf: {
+      value: createSandboxClosure({
+        sandbox: true,
+        name: "valueOf",
+        length: 0,
+        call: (_args, context) => primitiveReceiver(context?.thisValue, "bigint")
+      }),
+      writable: true,
+      configurable: true
+    },
+    toString: {
+      value: createSandboxClosure({
+        sandbox: true,
+        name: "toString",
+        length: 1,
+        call: async ([radix], context) => {
+          const value = primitiveReceiver(context?.thisValue, "bigint");
+          const base = radix === void 0 ? 10 : await sandboxNumber(radix, budget, context);
+          const allocation = {};
+          const size = value.toString(16).length * 4;
+          budget.visitNode(size);
+          budget.setRetainedDataUsage(allocation, size);
+          try {
+            return budget.allocateString(value.toString(base));
+          } finally {
+            budget.setRetainedDataUsage(allocation, 0);
+          }
+        }
+      }),
+      writable: true,
+      configurable: true
+    },
+    [Symbol.toStringTag]: { value: "BigInt", configurable: true }
+  });
+  const properties = materializeFunctionProperties(constructor);
+  Object.defineProperty(properties, "prototype", { value: prototype });
+  for (const name of ["asIntN", "asUintN"]) {
+    Object.defineProperty(properties, name, {
+      writable: true,
+      configurable: true,
+      value: createSandboxClosure({
+        sandbox: true,
+        name,
+        length: 2,
+        call: async ([bits, input], context) => {
+          const number = await sandboxNumber(bits, budget, context);
+          const width = Number.isNaN(number) ? 0 : Math.trunc(number);
+          if (width < 0 || !Number.isSafeInteger(width)) throw new RangeError("Invalid BigInt width.");
+          const value = await convert(input, context);
+          const size = value.toString(16).length;
+          budget.visitNode(size);
+          if (width >= size * 4 + 1 && (name === "asIntN" || value >= 0n)) return value;
+          const allocation = {};
+          budget.setRetainedDataUsage(allocation, Math.ceil(width / 4) + 1);
+          try {
+            return BigInt[name](width, value);
+          } finally {
+            budget.setRetainedDataUsage(allocation, 0);
+          }
+        }
+      })
+    });
+  }
+  installBoxedPrototype(budget, prototype, constructor, "bigint");
+  return constructor;
+}
+var init_bigint2 = __esm({
+  "packages/safe-js/src/interp/globals/bigint.ts"() {
+    "use strict";
+    init_boxed();
+    init_object_model();
+    init_string_coercion();
+    init_values();
+  }
+});
+
 // packages/safe-js/src/interp/globals.ts
 function createBuiltinBindings(options) {
   return {
@@ -155442,6 +156579,7 @@ function createBuiltinBindings(options) {
     Float32Array: createFloat32ArrayGlobal(options.budget),
     Date: createDateGlobal(options),
     Symbol: createSymbolGlobal(options.budget),
+    BigInt: createBigIntGlobal(options.budget),
     ...createErrorGlobals(options),
     ...createMathGlobals({ random: options.random }),
     ...createObjectArrayGlobals(options),
@@ -155464,6 +156602,7 @@ var init_globals = __esm({
     init_promise();
     init_date2();
     init_symbol();
+    init_bigint2();
   }
 });