@poe-platform/safe-js 0.1.191 → 0.1.193

package/dist/safe-js/chunks/{chunk-YGFHNJKK.js → chunk-2N7Z7ETR.js}

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

package/dist/safe-js/chunks/{chunk-DXCKCEDV.js → chunk-IBLBXKUC.js}

@@ -2391,16 +2391,20 @@ var RegexParser = class {
 function parseFlags(flags, guard) {
   guard.allocate(10);
   const parsed = {
+    hasIndices: false,
     global: false,
+    sticky: false,
     ignoreCase: false,
     multiline: false,
     dotAll: false
   };
   const names = {
+    d: "hasIndices",
     g: "global",
     i: "ignoreCase",
     m: "multiline",
-    s: "dotAll"
+    s: "dotAll",
+    y: "sticky"
   };
   for (let position = 0; position < flags.length; position += 1) {
     guard.work(1);
@@ -9299,7 +9303,7 @@ async function withRunResources(signal, execute) {
 
 // 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) {
@@ -9315,8 +9319,9 @@ 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;
   }
   return null;
 }
@@ -9447,14 +9452,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() };
@@ -10500,7 +10509,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")
@@ -16665,7 +16674,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);
   }
@@ -16716,17 +16725,24 @@ 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.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;
 }
 
@@ -16751,8 +16767,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);
@@ -34457,6 +34472,90 @@ function defineDataProperty2(target, key, value) {
   });
 }
 
+// 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 release = retainValues(budget, () => [target, input, limit, string, species, field, flags, matcher, match, result]);
+  const read = (value, key) => {
+    if (context?.getProperty !== void 0) return context.getProperty(value, key);
+    const descriptor = getSandboxPropertyDescriptor(value, key, 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 {
+    release();
+  }
+}
+
 // packages/safe-js/src/interp/globals/regex.ts
 function createRegexGlobals(options) {
   const invoke = (construct) => async (args, context) => {
@@ -34629,6 +34728,17 @@ function createRegexGlobals(options) {
     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({
@@ -36973,4 +37083,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-DXCKCEDV.js.map
+//# sourceMappingURL=chunk-IBLBXKUC.js.map