@poe-platform/safe-js 0.1.199 → 0.1.200

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

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-X5VIB5JV.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-YWBUORD7.js.map
+//# sourceMappingURL=chunk-6HCV5BAA.js.map

package/dist/safe-js/chunks/{chunk-X5VIB5JV.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 : item.type === "property" ? 4 + item.value.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, parsedFlags.unicode);
+    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,14 +2082,16 @@ function parseRegex(source, flags = "", compilation, valueUnits = 0) {
   }
 }
 var RegexParser = class {
-  constructor(source, guard, unicode) {
+  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;
@@ -2239,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;
@@ -2291,6 +2296,95 @@ var RegexParser = class {
     this.guard.allocate(4);
     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()) {
       this.fail("Trailing escape", start);
@@ -2344,12 +2438,20 @@ var RegexParser = class {
       const value = this.source.slice(begin, this.position);
       if (this.take() !== "}") this.fail("Unterminated Unicode property escape", start);
       try {
-        new RegExp(`\\p{${value}}`, "u");
+        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" }] };
+      return { type: "characterClass", negated: false, items: [{ type: "property", value, negated: escaped === "P", ...strings ? { strings: true } : {} }] };
     }
     if (escaped === "x") {
       this.guard.allocate(4);
@@ -2417,7 +2519,7 @@ var RegexParser = class {
       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 === "-"))
+    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 };
@@ -2591,6 +2693,7 @@ function parseFlags(flags, guard) {
     global: false,
     sticky: false,
     unicode: false,
+    unicodeSets: false,
     ignoreCase: false,
     multiline: false,
     dotAll: false
@@ -2602,7 +2705,8 @@ function parseFlags(flags, guard) {
     m: "multiline",
     s: "dotAll",
     y: "sticky",
-    u: "unicode"
+    u: "unicode",
+    v: "unicodeSets"
   };
   for (let position = 0; position < flags.length; position += 1) {
     guard.work(1);
@@ -2616,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) {
@@ -9518,8 +9623,9 @@ function matchRegexFrom(pattern, input, startIndex) {
   if (startIndex > input.length) {
     return null;
   }
-  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 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 = {
@@ -9536,13 +9642,14 @@ function matchRegexFrom(pattern, input, startIndex) {
 }
 function* matchNode(node, state, context) {
   charge(context);
-  const character = readCharacter(context.input, state.position, context.direction, context.flags.unicode);
+  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(character, node.value, context.flags.ignoreCase, context.flags.unicode)) {
+      if (charactersEqual(character, node.value, context.flags.ignoreCase, unicode)) {
         yield { ...state, position: state.position + context.direction * character.length };
       }
       return;
@@ -9568,9 +9675,9 @@ function* matchNode(node, state, context) {
       const end = context.direction === 1 ? capture.end : capture.start;
       while (reference !== end) {
         charge(context);
-        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;
+        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;
       }
@@ -9588,14 +9695,22 @@ function* matchNode(node, state, context) {
       }
       return;
     case "wordBoundary": {
-      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);
+      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": {
+      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 };
       }
@@ -9687,7 +9802,8 @@ function matchesCharacterClass(character, items, negated, context) {
   });
   return negated ? !matched : matched;
 }
-function matchesCharacterClassItem(character, item, ignoreCase, unicode) {
+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;
@@ -9698,7 +9814,7 @@ function matchesCharacterClassItem(character, item, ignoreCase, unicode) {
       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);
+    return new RegExp(`^(?:${atom})$`, (ignoreCase ? "i" : "") + (unicodeSets ? "v" : "u")).test(character);
   }
   if (item.type === "property") return false;
   if (item.type === "character") {
@@ -9722,6 +9838,76 @@ function matchesCharacterClassItem(character, item, ignoreCase, unicode) {
   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,
@@ -10640,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 = advanceStringIndex(value, match.index, splitter.flags.includes("u"));
+        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;
@@ -10815,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 = advanceStringIndex(value, lastIndex, regex.flags.includes("u"));
+    if (all && match.text.length === 0) regex.lastIndex = lastIndex = advanceStringIndex(value, lastIndex, regex.flags.includes("u") || regex.flags.includes("v"));
   } while (all);
   return matches;
 }
@@ -37381,4 +37567,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-X5VIB5JV.js.map
+//# sourceMappingURL=chunk-OX7524JW.js.map