@poe-platform/safe-js 0.1.197 → 0.1.199

package/dist/safe-js/chunks/{chunk-7KLRGTR4.js → chunk-X5VIB5JV.js}

@@ -711,7 +711,7 @@ var RegexCompileGuard = class {
     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);
     }
@@ -728,7 +728,15 @@ var RegexCompileGuard = class {
   }
 };
 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) {
@@ -737,6 +745,8 @@ 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":
@@ -744,7 +754,7 @@ function measureNode(node) {
     case "characterClass": {
       let usage = 5 + node.items.length;
       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 : 4;
       }
       return usage;
     }
@@ -756,7 +766,7 @@ 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);
     case "lookahead":
     case "lookbehind":
       return 4 + measureNode(node.body);
@@ -2049,6 +2059,8 @@ function createIdentifier(token, name) {
 }
 
 // packages/safe-js/src/interp/regex/parse.ts
+var groupNameStart = /^[$_\p{ID_Start}]$/u;
+var groupNamePart = /^[$\u200c\u200d\p{ID_Continue}]$/u;
 function parseRegex(source, flags = "", compilation, valueUnits = 0) {
   const guard = new RegexCompileGuard(compilation);
   try {
@@ -2056,10 +2068,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);
     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 {
@@ -2067,15 +2080,19 @@ function parseRegex(source, flags = "", compilation, valueUnits = 0) {
   }
 }
 var RegexParser = class {
-  constructor(source, guard) {
+  constructor(source, guard, unicode) {
     this.source = source;
     this.guard = guard;
+    this.unicode = unicode;
   }
   source;
   guard;
+  unicode;
   captureCount = 0;
   cursor = 0;
   totalCaptureCount;
+  hasNamedCaptures = false;
+  namedGroups = /* @__PURE__ */ Object.create(null);
   get position() {
     return this.cursor;
   }
@@ -2091,6 +2108,7 @@ var RegexParser = class {
       }
       this.fail(`Unexpected character '${this.peek()}'`);
     }
+    if (this.unicode || Object.keys(this.namedGroups).length > 0) this.validateNamedGroups(body);
     return body;
   }
   parseAlternation() {
@@ -2132,7 +2150,7 @@ var RegexParser = class {
     if (quantifier === void 0) {
       return body;
     }
-    if (body.type === "anchor" || body.type === "wordBoundary" || body.type === "lookbehind") {
+    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() !== "?";
@@ -2143,7 +2161,7 @@ var RegexParser = class {
     return { type: "quantifier", body, ...quantifier, greedy };
   }
   parseAtom() {
-    const character = this.take();
+    const character = this.takeCharacter();
     switch (character) {
       case ".":
         this.guard.allocate(2);
@@ -2161,12 +2179,14 @@ var RegexParser = class {
       case "\\":
         return this.parseEscape(false, this.position - 1);
       default:
+        if (this.unicode && (character === "]" || character === "}")) this.fail("Invalid Unicode pattern character");
         this.guard.allocate(3 + character.length);
         return { type: "literal", value: character };
     }
   }
   parseGroup(start) {
     let capturing = true;
+    let name;
     let assertionNegated;
     let lookbehind = false;
     if (this.peek() === "?") {
@@ -2186,13 +2206,20 @@ var RegexParser = class {
         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 {
         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 {
@@ -2209,7 +2236,7 @@ var RegexParser = class {
       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 } };
   }
   parseCharacterClass(start) {
     const negated = this.peek() === "^";
@@ -2233,7 +2260,7 @@ var RegexParser = class {
         if (left.type !== "character" || right.type !== "character") {
           this.fail("Character class ranges require literal endpoints", rangePosition);
         }
-        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);
@@ -2262,13 +2289,22 @@ var RegexParser = class {
       this.fail("Unsupported character class escape", escapeStart);
     }
     this.guard.allocate(4);
-    return { type: "character", value: this.take() };
+    return { type: "character", value: this.takeCharacter() };
   }
   parseEscape(inCharacterClass, start) {
     if (this.atEnd()) {
       this.fail("Trailing escape", start);
     }
     const escaped = this.take();
+    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;
@@ -2284,6 +2320,8 @@ var RegexParser = class {
           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);
@@ -2294,7 +2332,24 @@ var RegexParser = class {
       return { type: "literal", value: String.fromCharCode(code) };
     }
     if (escaped === "p" || escaped === "P") {
-      this.fail("Unicode property escapes are not supported", start);
+      if (!this.unicode) this.fail("Unicode property escapes are not supported", start);
+      if (this.take() !== "{") this.fail("Invalid Unicode property escape", start);
+      const begin = this.position;
+      while (!this.atEnd() && this.peek() !== "}") {
+        const character = this.take();
+        if (!isDecimalDigit2(character) && !(character >= "a" && character <= "z") && !(character >= "A" && character <= "Z") && character !== "_" && character !== "=")
+          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(`\\p{${value}}`, "u");
+      } catch {
+        this.fail("Unknown Unicode property", start);
+      }
+      this.guard.array(1);
+      return { type: "characterClass", negated: false, items: [{ type: "property", value, negated: escaped === "P" }] };
     }
     if (escaped === "x") {
       this.guard.allocate(4);
@@ -2302,7 +2357,29 @@ var RegexParser = class {
     }
     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);
+      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 = {
@@ -2333,6 +2410,15 @@ var RegexParser = class {
       v: "\v",
       "0": "\0"
     };
+    if (escaped === "c" && this.unicode) {
+      const letter = this.take();
+      if (!(letter >= "a" && letter <= "z") && !(letter >= "A" && letter <= "Z"))
+        this.fail("Invalid control escape", start);
+      this.guard.allocate(4);
+      return { type: "literal", value: String.fromCharCode(letter.charCodeAt(0) % 32) };
+    }
+    if (this.unicode && controls[escaped] === void 0 && !"^$\\.*+?()[]{}|/".includes(escaped) && !(inCharacterClass && escaped === "-"))
+      this.fail("Invalid identity escape", start);
     this.guard.allocate(4);
     return { type: "literal", value: controls[escaped] ?? escaped };
   }
@@ -2358,10 +2444,62 @@ var RegexParser = class {
       else if (character === "\\") escaped = true;
       else if (character === "[") characterClass = true;
       else if (character === "]") characterClass = false;
-      else if (!characterClass && character === "(" && this.source[index + 1] !== "?") count++;
+      else if (!characterClass && character === "(") {
+        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 character = this.take();
+      if (character === "\\") {
+        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);
+          character = String.fromCodePoint(point);
+        } else character = this.parseHexEscape(4, "Unicode", start);
+      }
+      this.guard.allocate(character.length);
+      name += character;
+    }
+    if (this.take() !== ">" || name.length === 0) this.fail("Invalid group name", start);
+    let first = true;
+    for (const character of name) {
+      this.guard.work(1);
+      if (!(first ? groupNameStart : groupNamePart).test(character)) 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 children = 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 children) {
+      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 character = this.peek();
     if (character === "*") {
@@ -2433,6 +2571,12 @@ var RegexParser = class {
     this.position += 1;
     return character;
   }
+  takeCharacter() {
+    if (!this.unicode || this.atEnd()) return this.take();
+    const character = String.fromCodePoint(this.source.codePointAt(this.position));
+    this.position += character.length;
+    return character;
+  }
   atEnd() {
     return this.position >= this.source.length;
   }
@@ -2446,6 +2590,7 @@ function parseFlags(flags, guard) {
     hasIndices: false,
     global: false,
     sticky: false,
+    unicode: false,
     ignoreCase: false,
     multiline: false,
     dotAll: false
@@ -2456,7 +2601,8 @@ function parseFlags(flags, guard) {
     i: "ignoreCase",
     m: "multiline",
     s: "dotAll",
-    y: "sticky"
+    y: "sticky",
+    u: "unicode"
   };
   for (let position = 0; position < flags.length; position += 1) {
     guard.work(1);
@@ -9372,8 +9518,9 @@ 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, direction: 1, work: { steps: 0 } };
+  if (pattern.flags.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, pattern.flags.unicode)) {
+    const context = { input, flags: pattern.flags, groups: pattern.groups, direction: 1, work: { steps: 0 } };
     charge(context);
     const initialState = {
       position: attempt,
@@ -9381,7 +9528,7 @@ function matchRegexFrom(pattern, input, startIndex) {
     };
     const result = matchNode(pattern.body, initialState, context).next();
     if (!result.done) {
-      return toRegexMatch(input, attempt, result.value, pattern.flags.hasIndices);
+      return toRegexMatch(input, attempt, result.value, pattern.flags.hasIndices, pattern.groups);
     }
     if (pattern.flags.sticky) break;
   }
@@ -9389,35 +9536,50 @@ function matchRegexFrom(pattern, input, startIndex) {
 }
 function* matchNode(node, state, context) {
   charge(context);
-  const characterIndex = context.direction === 1 ? state.position : state.position - 1;
+  const character = readCharacter(context.input, state.position, context.direction, context.flags.unicode);
   switch (node.type) {
     case "empty":
       yield state;
       return;
     case "literal":
-      if (charactersEqual(context.input[characterIndex], node.value, context.flags.ignoreCase)) {
-        yield { ...state, position: state.position + context.direction };
+      if (charactersEqual(character, node.value, context.flags.ignoreCase, context.flags.unicode)) {
+        yield { ...state, position: state.position + context.direction * character.length };
       }
       return;
-    case "backreference": {
-      const capture = state.captures[node.index - 1];
+    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;
       }
-      const length = capture.end - capture.start;
-      const start = context.direction === 1 ? state.position : state.position - length;
-      if (start < 0 || start + length > context.input.length) return;
-      for (let offset = 0; offset < length; offset++) {
+      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);
-        if (!charactersEqual(context.input[start + offset], context.input[capture.start + offset], context.flags.ignoreCase)) return;
+        const expected = readCharacter(context.input, reference, context.direction, context.flags.unicode);
+        const actual = readCharacter(context.input, position, context.direction, context.flags.unicode);
+        if (!charactersEqual(actual, expected, context.flags.ignoreCase, context.flags.unicode)) return;
+        reference += context.direction * expected.length;
+        position += context.direction * actual.length;
       }
-      yield { ...state, position: state.position + context.direction * length };
+      yield { ...state, position };
       return;
     }
     case "dot":
-      if (characterIndex >= 0 && characterIndex < context.input.length && (context.flags.dotAll || !isLineTerminator(context.input[characterIndex]))) {
-        yield { ...state, position: state.position + context.direction };
+      if (character !== void 0 && (context.flags.dotAll || !isLineTerminator(character))) {
+        yield { ...state, position: state.position + context.direction * character.length };
       }
       return;
     case "anchor":
@@ -9426,17 +9588,16 @@ 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, context.flags.unicode);
+      const nextWord = state.position < context.input.length && matchesCharacterClassItem(context.input[state.position], { type: "kind", kind: "word", negated: false }, context.flags.ignoreCase, context.flags.unicode);
       if (previousWord !== nextWord !== node.negated) {
         yield state;
       }
       return;
     }
     case "characterClass": {
-      const character = context.input[characterIndex];
-      if (character !== void 0 && matchesCharacterClass(character, node.items, node.negated, context.flags.ignoreCase)) {
-        yield { ...state, position: state.position + context.direction };
+      if (character !== void 0 && matchesCharacterClass(character, node.items, node.negated, context)) {
+        yield { ...state, position: state.position + context.direction * character.length };
       }
       return;
     }
@@ -9519,11 +9680,27 @@ function matchesAnchor(kind, position, context) {
   }
   return position === context.input.length || context.flags.multiline && position < context.input.length && isLineTerminator(context.input[position]);
 }
-function matchesCharacterClass(character, items, negated, ignoreCase) {
-  const matched = items.some((item) => matchesCharacterClassItem(character, item, ignoreCase));
+function matchesCharacterClass(character, items, negated, context) {
+  const matched = items.some((item) => {
+    if (context.flags.unicode) charge(context);
+    return matchesCharacterClassItem(character, item, context.flags.ignoreCase, context.flags.unicode);
+  });
   return negated ? !matched : matched;
 }
-function matchesCharacterClassItem(character, item, ignoreCase) {
+function matchesCharacterClassItem(character, item, ignoreCase, unicode) {
+  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 ? "iu" : "u").test(character);
+  }
+  if (item.type === "property") return false;
   if (item.type === "character") {
     return charactersEqual(character, item.value, ignoreCase);
   }
@@ -9545,7 +9722,7 @@ function matchesCharacterClassItem(character, item, ignoreCase) {
   const matched = item.kind === "digit" ? isDigit(character) : item.kind === "word" ? isWordCharacter(character) : isSpaceCharacter(character);
   return item.negated ? !matched : matched;
 }
-function toRegexMatch(input, start, state, hasIndices) {
+function toRegexMatch(input, start, state, hasIndices, groups) {
   const match = {
     index: start,
     text: input.slice(start, state.position),
@@ -9556,6 +9733,15 @@ function toRegexMatch(input, start, state, hasIndices) {
   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) {
@@ -9600,9 +9786,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(character, ignoreCase) {
   if (!ignoreCase) {
     return character;
@@ -10178,7 +10375,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 cursor = regex.lastIndex;
@@ -10228,7 +10425,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)) {
       release();
       return await replaceRegex(value, regex, replacement, budget, callClosure, context);
     }
@@ -10443,7 +10640,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"));
         endedWithZeroWidthMatch = match.text.length === 0 && match.index === value.length;
         if (match.text.length === 0 && (match.index === copiedThrough || match.index === value.length))
           continue;
@@ -10618,7 +10815,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"));
   } while (all);
   return matches;
 }
@@ -16829,11 +17026,13 @@ function toMatchArray(match, input, budget) {
   }
   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: void 0 });
+    Object.assign(match.indices, { groups: match.indicesGroups });
     Object.assign(result, { indices: match.indices });
   }
   return result;
@@ -37182,4 +37381,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-7KLRGTR4.js.map
+//# sourceMappingURL=chunk-X5VIB5JV.js.map