@poe-platform/safe-js 0.1.195 → 0.1.197

package/dist/safe-js/chunks/{chunk-37QJBJ72.js → chunk-7KLRGTR4.js}

@@ -739,6 +739,7 @@ function measureNode(node) {
       return 3 + node.value.length;
     case "anchor":
     case "wordBoundary":
+    case "backreference":
       return 3;
     case "characterClass": {
       let usage = 5 + node.items.length;
@@ -2074,6 +2075,7 @@ var RegexParser = class {
   guard;
   captureCount = 0;
   cursor = 0;
+  totalCaptureCount;
   get position() {
     return this.cursor;
   }
@@ -2267,8 +2269,29 @@ var RegexParser = class {
       this.fail("Trailing escape", start);
     }
     const escaped = this.take();
-    if (escaped >= "1" && escaped <= "9") {
-      this.fail("Backreferences are not supported", start);
+    if (isDecimalDigit2(escaped)) {
+      if (!inCharacterClass && escaped !== "0") {
+        let end = this.position;
+        let index = Number(escaped);
+        while (isDecimalDigit2(this.source[end] ?? "")) {
+          this.guard.work(1);
+          index = index * 10 + Number(this.source[end++]);
+        }
+        this.totalCaptureCount ??= this.countAllCaptures();
+        if (index <= this.totalCaptureCount) {
+          this.position = end;
+          this.guard.allocate(3);
+          return { type: "backreference", index };
+        }
+      }
+      this.guard.allocate(4);
+      if (escaped === "8" || escaped === "9") return { type: "literal", value: escaped };
+      let code = Number(escaped);
+      const maximum = escaped <= "3" ? 3 : 2;
+      for (let digits = 1; digits < maximum && this.peek() >= "0" && this.peek() <= "7"; digits++) {
+        code = code * 8 + Number(this.take());
+      }
+      return { type: "literal", value: String.fromCharCode(code) };
     }
     if (escaped === "p" || escaped === "P") {
       this.fail("Unicode property escapes are not supported", start);
@@ -2324,6 +2347,21 @@ var RegexParser = class {
     this.position = end;
     return String.fromCharCode(Number.parseInt(digits, 16));
   }
+  countAllCaptures() {
+    let count = 0;
+    let escaped = false;
+    let characterClass = false;
+    for (let index = 0; index < this.source.length; index++) {
+      this.guard.work(1);
+      const character = this.source[index];
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === "[") characterClass = true;
+      else if (character === "]") characterClass = false;
+      else if (!characterClass && character === "(" && this.source[index + 1] !== "?") count++;
+    }
+    return count;
+  }
   parseQuantifier() {
     const character = this.peek();
     if (character === "*") {
@@ -7656,6 +7694,9 @@ function getSandboxPrototype(value, budget) {
 function hasExplicitSandboxPrototype(value) {
   return prototypes.has(value);
 }
+function hasNullObjectPrototype(value) {
+  return prototypes.get(value) === null && !Array.isArray(value) && !isSandboxClosure(value) && !isSandboxRegex(value);
+}
 function getSandboxPropertyDescriptor(value, key, budget) {
   const hostProperties = isSandboxClosure(value) ? value.properties : void 0;
   if (isSandboxClosure(value) && !isGuestClosure(value))
@@ -7737,7 +7778,7 @@ function hasGuestObjectState(value) {
   const intrinsicUnchanged = intrinsicConstructors.get(value);
   if (intrinsicUnchanged !== void 0) return !intrinsicUnchanged();
   if (isLiveCapability(value)) return true;
-  if (functionProperties.has(value) || prototypes.has(value)) return true;
+  if (functionProperties.has(value) || prototypes.has(value) && !hasNullObjectPrototype(value)) return true;
   if (isSandboxBox(value) || isSandboxDate(value)) return false;
   return descriptorObjects.has(value) && Object.values(Object.getOwnPropertyDescriptors(value)).some(
     (descriptor) => !descriptor.enumerable || !descriptor.configurable || !descriptor.writable
@@ -8058,6 +8099,7 @@ function serializeHeapReference(value, path, state) {
       });
       state.heap[String(id)] = {
         kind: "object",
+        ...hasNullObjectPrototype(value) ? { sandboxNullPrototype: true } : {},
         entries: serializeObjectEntries(value, path, state),
         ...symbolEntries.length === 0 ? {} : { symbolEntries },
         ...errorType === void 0 ? {} : { errorType }
@@ -8091,7 +8133,7 @@ function indexHeapContainers(snapshot) {
   const heapIds = /* @__PURE__ */ new Map();
   let nextId = 1;
   for (const [value, stat2] of stats.entries()) {
-    if (stat2.count > 1 || stat2.cyclic || ownSerializableSymbolKeys(value).length > 0 || isSandboxBox(value) || isSandboxRegExpIterator(value) || isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxDate(value) || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
+    if (stat2.count > 1 || stat2.cyclic || hasNullObjectPrototype(value) || ownSerializableSymbolKeys(value).length > 0 || isSandboxBox(value) || isSandboxRegExpIterator(value) || isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxDate(value) || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
       heapIds.set(value, nextId);
       nextId += 1;
     }
@@ -8277,6 +8319,8 @@ function validateDumpHeap(root, state) {
       continue;
     }
     if (entry.kind === "object") {
+      if (Object.hasOwn(entry, "sandboxNullPrototype") && entry.sandboxNullPrototype !== true)
+        fail("invalidValue", `${path}.sandboxNullPrototype`, "invalid object prototype");
       requireRecord(entry.entries, `${path}.entries`);
       continue;
     }
@@ -8397,7 +8441,11 @@ function validateTaggedValue(record2, path, state) {
       return;
     case "array":
     case "arguments":
+      return;
     case "object":
+      if (Object.hasOwn(record2, "sandboxNullPrototype") && record2.sandboxNullPrototype !== true)
+        fail("invalidValue", `${path}.sandboxNullPrototype`, "invalid object prototype");
+      return;
     case "map":
     case "set":
     case "collection-iterator":
@@ -9351,6 +9399,22 @@ function* matchNode(node, state, context) {
         yield { ...state, position: state.position + context.direction };
       }
       return;
+    case "backreference": {
+      const capture = state.captures[node.index - 1];
+      if (capture === void 0) {
+        yield state;
+        return;
+      }
+      const length = capture.end - capture.start;
+      const start = context.direction === 1 ? state.position : state.position - length;
+      if (start < 0 || start + length > context.input.length) return;
+      for (let offset = 0; offset < length; offset++) {
+        charge(context);
+        if (!charactersEqual(context.input[start + offset], context.input[capture.start + offset], context.flags.ignoreCase)) return;
+      }
+      yield { ...state, position: state.position + context.direction * length };
+      return;
+    }
     case "dot":
       if (characterIndex >= 0 && characterIndex < context.input.length && (context.flags.dotAll || !isLineTerminator(context.input[characterIndex]))) {
         yield { ...state, position: state.position + context.direction };
@@ -17916,6 +17980,7 @@ function encodeReplayData(value, options = {}) {
       nodes[id] = {
         kind: Array.isArray(entry) ? "array" : "object",
         nullPrototype: prototype === null,
+        ...hasNullObjectPrototype(entry) ? { sandboxNullPrototype: true } : {},
         ...errorType === void 0 ? {} : { errorType },
         extensible: Object.isExtensible(entry),
         properties,
@@ -18138,6 +18203,10 @@ function decodeReplayData(input, options = {}, parent) {
         throw new TypeError("Invalid replay object metadata.");
       }
       const result2 = kind === "array" ? [] : Object.create(node.nullPrototype ? null : Object.prototype);
+      if (Object.hasOwn(node, "sandboxNullPrototype")) {
+        if (kind !== "object" || node.sandboxNullPrototype !== true) throw new TypeError("Invalid replay object prototype.");
+        setSandboxPrototype(result2, null);
+      }
       if (Object.hasOwn(node, "errorType")) {
         sandboxErrorTypes.set(result2, node.errorType);
       }
@@ -21773,6 +21842,7 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
     const copy = createPlainObject(
       !cloneSandboxCollections || Object.getPrototypeOf(value) === null
     );
+    if (!state.structuredClone && hasNullObjectPrototype(value)) setSandboxPrototype(copy, null);
     state.seen.set(value, copy);
     const errorType = sandboxErrorTypes.get(value);
     if (errorType !== void 0) sandboxErrorTypes.set(copy, errorType);
@@ -21984,7 +22054,7 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
     if (existing !== void 0) {
       return existing;
     }
-    const copy = createPlainObject(Object.getPrototypeOf(value) === null);
+    const copy = createPlainObject(hasNullObjectPrototype(value) || Object.getPrototypeOf(value) === null);
     state.seen.set(value, copy);
     for (const entry of getEnumerableObjectEntries(value, path)) {
       defineOwnDataProperty(
@@ -37112,4 +37182,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-37QJBJ72.js.map
+//# sourceMappingURL=chunk-7KLRGTR4.js.map