@poe-platform/safe-js 0.1.192 → 0.1.194

package/dist/safe-js/chunks/{chunk-Q6OWZDNT.js → chunk-CU4ESS5Q.js}

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

package/dist/safe-js/chunks/{chunk-SKWFZYFI.js → chunk-WRASETAY.js}

@@ -756,6 +756,8 @@ function measureNode(node) {
     }
     case "group":
       return 5 + measureNode(node.body);
+    case "lookahead":
+      return 4 + measureNode(node.body);
     case "quantifier":
       return (Object.hasOwn(node, "max") ? 6 : 5) + measureNode(node.body);
   }
@@ -2162,6 +2164,7 @@ var RegexParser = class {
   }
   parseGroup(start) {
     let capturing = true;
+    let lookahead;
     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));
@@ -2170,7 +2173,9 @@ var RegexParser = class {
         capturing = false;
         this.position += 2;
       } else if (extension.startsWith("?=") || extension.startsWith("?!")) {
-        this.fail("Lookahead is not supported", start);
+        capturing = false;
+        lookahead = extension.startsWith("?!");
+        this.position += 2;
       } else if (extension.startsWith("?<=") || extension.startsWith("?<!")) {
         this.fail("Lookbehind is not supported", start);
       } else if (extension.startsWith("?<")) {
@@ -2192,6 +2197,10 @@ var RegexParser = class {
       this.fail("Unterminated group", start);
     }
     this.position += 1;
+    if (lookahead !== void 0) {
+      this.guard.allocate(4);
+      return { type: "lookahead", negated: lookahead, body };
+    }
     this.guard.allocate(5);
     return { type: "group", capturing, index, body };
   }
@@ -2391,6 +2400,7 @@ var RegexParser = class {
 function parseFlags(flags, guard) {
   guard.allocate(10);
   const parsed = {
+    hasIndices: false,
     global: false,
     sticky: false,
     ignoreCase: false,
@@ -2398,6 +2408,7 @@ function parseFlags(flags, guard) {
     dotAll: false
   };
   const names = {
+    d: "hasIndices",
     g: "global",
     i: "ignoreCase",
     m: "multiline",
@@ -9317,7 +9328,7 @@ 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);
     }
     if (pattern.flags.sticky) break;
   }
@@ -9367,6 +9378,15 @@ function* matchNode(node, state, context) {
         yield* matchNode(alternative, cloneState(state), context);
       }
       return;
+    case "lookahead": {
+      const result = matchNode(node.body, cloneState(state), context).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)) {
         if (!node.capturing || node.index === void 0) {
@@ -9450,14 +9470,18 @@ 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) {
-  return {
+function toRegexMatch(input, start, state, hasIndices) {
+  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])];
+  }
+  return match;
 }
 function cloneState(state) {
   return { position: state.position, captures: state.captures.slice() };
@@ -9487,7 +9511,7 @@ function clearNodeCaptures(node, captures) {
     }
     return;
   }
-  if (node.type === "quantifier") {
+  if (node.type === "quantifier" || node.type === "lookahead") {
     clearNodeCaptures(node.body, captures);
   }
 }
@@ -10503,7 +10527,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")
@@ -16668,7 +16692,7 @@ async function callRegexMethod(target, methodName, args, budget, context) {
     cursor = target.lastIndex;
     const lastIndex = await sandboxNumber(cursor, budget, context);
     const match = executeRegex(target, input, lastIndex);
-    return toMatchArray(match, input);
+    return toMatchArray(match, input, budget);
   } finally {
     budget.setRetainedValues(retained, void 0);
   }
@@ -16724,12 +16748,19 @@ function executeRegex(target, input, lastIndex) {
   }
   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.indices !== void 0) {
+    budget?.allocateArrayLength(match.indices.length);
+    budget?.allocateArrayLength(2);
+    Object.assign(match.indices, { groups: void 0 });
+    Object.assign(result, { indices: match.indices });
+  }
   return result;
 }
 
@@ -16754,8 +16785,7 @@ function nextRegExpIterator(iterator, budget) {
     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);
@@ -37071,4 +37101,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-SKWFZYFI.js.map
+//# sourceMappingURL=chunk-WRASETAY.js.map