@poe-platform/safe-js 0.1.198 → 0.1.200

package/dist/safe-js/chunks/{chunk-4WIZV3GZ.js → chunk-6HCV5BAA.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-T43UKNMF.js";
+} from "./chunk-OX7524JW.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-4WIZV3GZ.js.map
+//# sourceMappingURL=chunk-6HCV5BAA.js.map

package/dist/safe-js/chunks/{chunk-T43UKNMF.js → chunk-OX7524JW.js}

@@ -753,8 +753,10 @@ function measureNode(node) {
       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((total, value) => total + 1 + value.length, 0) : 4;
       }
       return usage;
     }
@@ -2068,7 +2070,7 @@ 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 };
@@ -2080,12 +2082,16 @@ function parseRegex(source, flags = "", compilation, valueUnits = 0) {
   }
 }
 var 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;
@@ -2106,7 +2112,7 @@ var RegexParser = class {
       }
       this.fail(`Unexpected character '${this.peek()}'`);
     }
-    if (Object.keys(this.namedGroups).length > 0) this.validateNamedGroups(body);
+    if (this.unicode || Object.keys(this.namedGroups).length > 0) this.validateNamedGroups(body);
     return body;
   }
   parseAlternation() {
@@ -2148,7 +2154,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() !== "?";
@@ -2159,7 +2165,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);
@@ -2177,6 +2183,7 @@ 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 };
     }
@@ -2236,6 +2243,7 @@ var RegexParser = class {
     return { type: "group", capturing, index, body, ...name === void 0 ? {} : { name } };
   }
   parseCharacterClass(start) {
+    if (this.unicodeSets) return { type: "characterClass", ...this.parseUnicodeSet(start) };
     const negated = this.peek() === "^";
     if (negated) {
       this.position += 1;
@@ -2257,7 +2265,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);
@@ -2286,7 +2294,96 @@ 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() };
+  }
+  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 character = this.takeCharacter();
+    if (!character || "()[]{}/-|".includes(character) || "!#$%&*+,.:;<=>?@^`~".includes(character) && this.peek() === character)
+      this.fail("Invalid character in Unicode set", start);
+    return character;
   }
   parseEscape(inCharacterClass, start) {
     if (this.atEnd()) {
@@ -2295,7 +2392,7 @@ var RegexParser = class {
     const escaped = this.take();
     if (escaped === "k") {
       this.totalCaptureCount ??= this.countAllCaptures();
-      if (this.hasNamedCaptures) {
+      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);
@@ -2317,6 +2414,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);
@@ -2327,7 +2426,32 @@ 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(`\\${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);
@@ -2335,7 +2459,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 = {
@@ -2366,6 +2512,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.unicodeSets && "!#$%&+,.:;<=>?@`~".includes(escaped))))
+      this.fail("Invalid identity escape", start);
     this.guard.allocate(4);
     return { type: "literal", value: controls[escaped] ?? escaped };
   }
@@ -2518,6 +2673,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;
   }
@@ -2531,6 +2692,8 @@ function parseFlags(flags, guard) {
     hasIndices: false,
     global: false,
     sticky: false,
+    unicode: false,
+    unicodeSets: false,
     ignoreCase: false,
     multiline: false,
     dotAll: false
@@ -2541,7 +2704,9 @@ function parseFlags(flags, guard) {
     i: "ignoreCase",
     m: "multiline",
     s: "dotAll",
-    y: "sticky"
+    y: "sticky",
+    u: "unicode",
+    v: "unicodeSets"
   };
   for (let position = 0; position < flags.length; position += 1) {
     guard.work(1);
@@ -2555,6 +2720,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(character) {
@@ -9457,7 +9623,9 @@ function matchRegexFrom(pattern, input, startIndex) {
   if (startIndex > input.length) {
     return null;
   }
-  for (let attempt = startIndex; attempt <= input.length; attempt += 1) {
+  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 = {
@@ -9474,14 +9642,15 @@ function matchRegexFrom(pattern, input, startIndex) {
 }
 function* matchNode(node, state, context) {
   charge(context);
-  const characterIndex = context.direction === 1 ? state.position : state.position - 1;
+  const unicode = context.flags.unicode || context.flags.unicodeSets;
+  const character = readCharacter(context.input, state.position, context.direction, 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, unicode)) {
+        yield { ...state, position: state.position + context.direction * character.length };
       }
       return;
     case "backreference":
@@ -9501,19 +9670,23 @@ function* matchNode(node, state, context) {
         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, 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: 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":
@@ -9522,17 +9695,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 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 (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 (character !== void 0 && matchesCharacterClass(character, node.items, node.negated, context)) {
+        yield { ...state, position: state.position + context.direction * character.length };
       }
       return;
     }
@@ -9615,11 +9795,28 @@ 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, 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(character);
+  }
+  if (item.type === "property") return false;
   if (item.type === "character") {
     return charactersEqual(character, item.value, ignoreCase);
   }
@@ -9641,6 +9838,76 @@ 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 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 character = readCharacter(context.input, position, context.direction, true);
+    return new Set(character !== void 0 && !lengths.has(character.length) ? [character.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 cursor = 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, cursor, context.direction, true);
+        if (!charactersEqual(actual, expected, context.flags.ignoreCase, true)) break;
+        reference += context.direction * expected.length;
+        cursor += context.direction * actual.length;
+      }
+      if (reference === end) lengths.add(Math.abs(cursor - 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 cursor = context.direction === 1 ? consumed : longest.length - consumed;
+      consumed += readCharacter(longest, cursor, 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 character = readCharacter(context.input, position, context.direction, true);
+  if (character !== void 0 && matchesCharacterClassItem(character, item, context.flags.ignoreCase, true, true))
+    lengths.add(character.length);
+  return lengths;
+}
 function toRegexMatch(input, start, state, hasIndices, groups) {
   const match = {
     index: start,
@@ -9705,9 +9972,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;
@@ -10548,7 +10826,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;
@@ -10723,7 +11001,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;
 }
@@ -37289,4 +37567,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-T43UKNMF.js.map
+//# sourceMappingURL=chunk-OX7524JW.js.map