@poe-platform/safe-js 0.1.190 → 0.1.191

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

@@ -6723,9 +6723,13 @@ function isSandboxRegExpIterator(value) {
   return typeof value === "object" && value !== null && states2.has(value);
 }
 function restoreSandboxRegExpIterator(state, target = /* @__PURE__ */ Object.create(null)) {
+  if ((state.global !== void 0 || state.unicode !== void 0) && (typeof state.global !== "boolean" || typeof state.unicode !== "boolean"))
+    throw new TypeError("Invalid RegExp iterator modes.");
+  if (state.matcher !== void 0 && (state.matcher === null || typeof state.matcher !== "object"))
+    throw new TypeError("Invalid RegExp iterator matcher.");
   if (!state.exhausted && (state.matcher === void 0 || state.input === void 0))
     throw new TypeError("A live RegExp iterator requires its matcher and input.");
-  states2.set(target, state.exhausted ? { matcher: void 0, input: void 0, exhausted: true } : { ...state });
+  states2.set(target, state.exhausted ? { ...state, matcher: void 0, input: void 0, exhausted: true } : { ...state });
   return target;
 }
 function regexpIteratorState(value) {
@@ -7956,11 +7960,14 @@ function serializeHeapReference(value, path, state) {
     if (isSandboxRegExpIterator(value)) {
       const snapshot = regexpIteratorState(value);
       const matcher = snapshot.matcher;
+      const serializedMatcher = snapshot.global === void 0 && isSandboxRegex(matcher) ? { kind: "regex", source: matcher.source, flags: matcher.flags, lastIndex: Number(matcher.lastIndex) } : serializeDumpValue(matcher, `${path}.<matcher>`, state);
+      if (serializedMatcher === SKIP_VALUE) throw new TypeError("Unsupported RegExp iterator matcher in public dump.");
       const entries = /* @__PURE__ */ Object.create(null);
       state.heap[String(id)] = {
         kind: "regexp-iterator",
         exhausted: snapshot.exhausted,
-        matcher: matcher === void 0 ? { kind: "undefined" } : { kind: "regex", source: matcher.source, flags: matcher.flags, lastIndex: Number(matcher.lastIndex) },
+        matcher: serializedMatcher,
+        ...snapshot.global === void 0 ? {} : { global: snapshot.global, unicode: snapshot.unicode },
         input: snapshot.input ?? { kind: "undefined" },
         entries,
         symbolEntries: serializeSymbolProperties(value, (entry) => {
@@ -8442,6 +8449,8 @@ function validateHeapValue(value, path, state, heap) {
   }
   if (record2.kind === "set") requireArray(record2.values, `${path}.values`, state);
   if (record2.kind === "regexp-iterator") {
+    if ((record2.global !== void 0 || record2.unicode !== void 0) && (typeof record2.global !== "boolean" || typeof record2.unicode !== "boolean"))
+      fail("invalidValue", path, "invalid RegExp iterator modes");
     if (typeof record2.exhausted !== "boolean") fail("invalidValue", `${path}.exhausted`, "invalid iterator exhaustion");
     if (!Object.hasOwn(record2, "matcher") || !Object.hasOwn(record2, "input")) fail("invalidValue", path, "missing RegExp iterator state");
     requireRecord(record2.entries, `${path}.entries`);
@@ -16727,9 +16736,10 @@ function nextRegExpIterator(iterator, budget) {
   budget?.visitNode();
   if (state.exhausted) return { value: void 0, done: true };
   const matcher = state.matcher;
+  if (!isSandboxRegex(matcher)) throw new TypeError("Custom RegExp iterator execution requires a sandbox context.");
   const input = state.input;
   const match = executeRegex(matcher, input, Number(matcher.lastIndex));
-  if (match === null || !matcher.flags.includes("g")) {
+  if (match === null || !(state.global ?? matcher.flags.includes("g"))) {
     state.exhausted = true;
     state.matcher = void 0;
     state.input = void 0;
@@ -16737,13 +16747,54 @@ function nextRegExpIterator(iterator, budget) {
   if (match === null) return { value: void 0, done: true };
   if (!state.exhausted && match.text.length === 0) {
     const index = Number(matcher.lastIndex);
-    const unicode = matcher.flags.includes("u") || matcher.flags.includes("v");
+    const unicode = state.unicode ?? (matcher.flags.includes("u") || matcher.flags.includes("v"));
     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 };
 }
+async function nextObservableRegExpIterator(iterator, budget, context) {
+  const state = regexpIteratorState(iterator);
+  if (state.exhausted) return { value: void 0, done: true };
+  const matcher = state.matcher;
+  if (isSandboxRegex(matcher) && !hasRegexPropertyOverride(matcher, ["exec"], budget) && (matcher.lastIndex === null || typeof matcher.lastIndex !== "object"))
+    return nextRegExpIterator(iterator, budget);
+  const input = state.input;
+  let result;
+  let field;
+  const release = retainValues(budget, () => [iterator, matcher, input, result, field]);
+  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);
+  };
+  try {
+    budget.visitNode();
+    result = await regexExec(matcher, input, budget, context);
+    const global = state.global ?? (isSandboxRegex(matcher) && matcher.flags.includes("g"));
+    if (result === null || !global) {
+      state.exhausted = true;
+      state.matcher = void 0;
+      state.input = void 0;
+      return result === null ? { value: void 0, done: true } : { value: result, done: false };
+    }
+    field = await read(result, "0");
+    const text = await sandboxString(field, budget, context);
+    field = void 0;
+    if (text.length === 0) {
+      field = await read(matcher, "lastIndex");
+      const index = normalizeLastIndex(await sandboxNumber(field, budget, context));
+      field = void 0;
+      const unicode = state.unicode ?? (isSandboxRegex(matcher) && (matcher.flags.includes("u") || matcher.flags.includes("v")));
+      const point = input.codePointAt(index);
+      await setSandboxProperty(matcher, "lastIndex", index + (unicode && point !== void 0 && point > 65535 ? 2 : 1), budget, true, context);
+    }
+    return { value: result, done: false };
+  } finally {
+    release();
+  }
+}
 function getRegExpIteratorMember(property, budget) {
   if (property === Symbol.toStringTag) return "RegExp String Iterator";
   if (property === Symbol.iterator) return createSandboxClosure({
@@ -16759,7 +16810,7 @@ function getRegExpIteratorMember(property, budget) {
       const receiver = context?.thisValue;
       if (!isSandboxRegExpIterator(receiver))
         throw new TypeError("RegExp string iterator next requires a matching receiver.");
-      return nextRegExpIterator(receiver, budget);
+      return context === void 0 ? nextRegExpIterator(receiver, budget) : nextObservableRegExpIterator(receiver, budget, context);
     }
   });
 }
@@ -16947,8 +16998,11 @@ function getSandboxIterator(value, budget, context) {
   }
   if (isSandboxCollectionIterator(value))
     return { next: () => nextCollectionIterator(value, budget), snapshotIndex: () => 0 };
-  if (isSandboxRegExpIterator(value))
+  if (isSandboxRegExpIterator(value)) {
+    if (context !== void 0 && budget !== void 0)
+      return { asynchronous: true, next: () => nextObservableRegExpIterator(value, budget, context), snapshotIndex: () => 0 };
     return { next: () => nextRegExpIterator(value, budget), snapshotIndex: () => 0 };
+  }
   if (isGuestHostObject(value)) return getHostObjectIterator(value);
   if (isFloat32Array(value)) {
     return syncIterator(Float32Array.prototype.values.call(value));
@@ -17755,7 +17809,16 @@ function encodeReplayData(value, options = {}) {
       }
       let symbolIndex = 0;
       const symbolEntries = serializeSymbolProperties(entry, (value2) => encode(value2, depth + 1, [...path, { symbol: Math.floor(symbolIndex++ / 2) }]));
-      nodes[id] = { kind: "regexp-iterator", matcher: child(snapshot.matcher, "<matcher>"), input: child(snapshot.input, "<input>"), exhausted: snapshot.exhausted, properties, extensible: Object.isExtensible(entry), symbolEntries };
+      nodes[id] = {
+        kind: "regexp-iterator",
+        matcher: child(snapshot.matcher, "<matcher>"),
+        input: child(snapshot.input, "<input>"),
+        exhausted: snapshot.exhausted,
+        properties,
+        extensible: Object.isExtensible(entry),
+        symbolEntries,
+        ...snapshot.global === void 0 ? {} : { global: snapshot.global, unicode: snapshot.unicode }
+      };
     } else if (isSandboxCollectionIterator(entry)) {
       const snapshot = snapshotCollectionIterator(entry);
       const properties = /* @__PURE__ */ Object.create(null);
@@ -17953,9 +18016,15 @@ function decodeReplayData(input, options = {}, parent) {
         restored.set(id, result3);
         const matcher = child(own(node, "matcher"));
         const input2 = child(own(node, "input"));
-        if (matcher !== void 0 && !isSandboxRegex(matcher)) throw new TypeError("Invalid replay RegExp iterator matcher.");
+        if ((node.global !== void 0 || node.unicode !== void 0) && (typeof node.global !== "boolean" || typeof node.unicode !== "boolean")) throw new TypeError("Invalid replay RegExp iterator modes.");
+        if (matcher !== void 0 && (node.global === void 0 ? !isSandboxRegex(matcher) : matcher === null || typeof matcher !== "object")) throw new TypeError("Invalid replay RegExp iterator matcher.");
         if (input2 !== void 0 && typeof input2 !== "string") throw new TypeError("Invalid replay RegExp iterator input.");
-        restoreSandboxRegExpIterator({ matcher, input: input2, exhausted }, result3);
+        restoreSandboxRegExpIterator({
+          matcher,
+          input: input2,
+          exhausted,
+          ...node.global === void 0 ? {} : { global: node.global, unicode: node.unicode }
+        }, result3);
         defineProperties(result3, record(own(node, "properties")), child, node.symbolEntries);
         if (!node.extensible) Object.preventExtensions(result3);
         return result3;
@@ -21472,7 +21541,7 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
     const copy = restoreSandboxRegExpIterator({ matcher: void 0, input: void 0, exhausted: true });
     state.seen.set(value, copy);
     const matcher = copyToSandbox(snapshot.matcher, state, `${path}.<matcher>`, true, depth + 1);
-    if (matcher !== void 0 && !isSandboxRegex(matcher)) throw new TypeError("Invalid RegExp iterator matcher.");
+    if (matcher !== void 0 && (snapshot.global === void 0 ? !isSandboxRegex(matcher) : matcher === null || typeof matcher !== "object")) throw new TypeError("Invalid RegExp iterator matcher.");
     restoreSandboxRegExpIterator({ ...snapshot, matcher }, copy);
     for (const entry of getEnumerableObjectEntries(value, path)) {
       defineOwnDataProperty(copy, entry.key, copyToSandbox(entry.value, state, joinPath2(path, entry.key), true, depth + 1));
@@ -34453,6 +34522,15 @@ function createRegexGlobals(options) {
   };
   const constructor = createSandboxClosure({ guest: true, sandbox: true, name: "RegExp", length: 2, call: invoke(false), construct: invoke(true) });
   const prototype = /* @__PURE__ */ Object.create(null);
+  Object.defineProperty(materializeFunctionProperties(constructor), Symbol.species, {
+    get: accessorAdapter(createSandboxClosure({
+      sandbox: true,
+      name: "get [Symbol.species]",
+      length: 0,
+      call: (_args, context) => context?.thisValue
+    }), "get"),
+    configurable: true
+  });
   Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false });
   Object.defineProperty(prototype, "constructor", { value: constructor, writable: true, configurable: true });
   Object.defineProperty(prototype, Symbol.search, {
@@ -34495,6 +34573,62 @@ function createRegexGlobals(options) {
     writable: true,
     configurable: true
   });
+  Object.defineProperty(prototype, Symbol.matchAll, {
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "[Symbol.matchAll]",
+      length: 1,
+      call: async (args, context) => {
+        const target = context?.thisValue;
+        if (target === null || typeof target !== "object") throw new TypeError("RegExp matchAll requires an object receiver.");
+        let input = args[0];
+        let string;
+        let species;
+        let field;
+        let flags;
+        let matcher;
+        const release = retainValues(options.budget, () => [target, input, string, species, field, flags, matcher]);
+        const read = (value, key) => {
+          if (context?.getProperty !== void 0) return context.getProperty(value, key);
+          const descriptor = getSandboxPropertyDescriptor(value, key, options.budget);
+          return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, value, context);
+        };
+        try {
+          string = await sandboxString(input, options.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, options.budget, context);
+          field = void 0;
+          matcher = await invokeBuiltinClosure(species, [target, flags], options.budget, context, void 0, true);
+          field = await read(target, "lastIndex");
+          const cursor = normalizeLastIndex(await sandboxNumber(field, options.budget, context));
+          field = void 0;
+          await setSandboxProperty(matcher, "lastIndex", cursor, options.budget, true, context);
+          return restoreSandboxRegExpIterator({
+            matcher,
+            input: string,
+            exhausted: false,
+            global: flags.includes("g"),
+            unicode: flags.includes("u") || flags.includes("v")
+          });
+        } finally {
+          release();
+        }
+      }
+    }),
+    writable: true,
+    configurable: true
+  });
   for (const name of ["exec", "test", "toString"]) {
     Object.defineProperty(prototype, name, {
       value: createSandboxClosure({
@@ -36839,4 +36973,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-YEZOXLY4.js.map
+//# sourceMappingURL=chunk-DXCKCEDV.js.map