@poe-platform/safe-js 0.1.191 → 0.1.192

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

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-DXCKCEDV.js";
+} from "./chunk-SKWFZYFI.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-Q6OWZDNT.js.map

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

@@ -2392,6 +2392,7 @@ function parseFlags(flags, guard) {
   guard.allocate(10);
   const parsed = {
     global: false,
+    sticky: false,
     ignoreCase: false,
     multiline: false,
     dotAll: false
@@ -2400,7 +2401,8 @@ function parseFlags(flags, guard) {
     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 +9301,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) {
@@ -9317,6 +9319,7 @@ function matchRegexFrom(pattern, input, startIndex) {
     if (!result.done) {
       return toRegexMatch(input, attempt, result.value);
     }
+    if (pattern.flags.sticky) break;
   }
   return null;
 }
@@ -16716,7 +16719,7 @@ 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;
@@ -34457,6 +34460,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 +34716,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 +37071,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-DXCKCEDV.js.map
+//# sourceMappingURL=chunk-SKWFZYFI.js.map