poe-code 14.0.39 → 14.0.41

package/dist/index.js

@@ -122866,10 +122866,7 @@ function rebasePosition(position, base) {
   };
 }
 function isLiteralPropertyKey(token) {
-  if (token.type === "numeric" || token.type === "string") {
-    return true;
-  }
-  return token.type === "keyword" && (token.value === "true" || token.value === "false" || token.value === "null" || token.value === "undefined");
+  return token.type === "numeric" || token.type === "string";
 }
 function isIdentifierLikeToken(token) {
   return token.type === "identifier" || token.type === "keyword" && token.value === "async";
@@ -123992,9 +123989,9 @@ var init_parser3 = __esm({
           };
         }
         const token = this.currentToken();
-        if (token.type === "identifier") {
+        if (token.type === "identifier" || token.type === "keyword") {
           this.index += 1;
-          const key3 = createIdentifier2(token);
+          const key3 = createIdentifierName(token);
           if (this.consumePunctuator(":") !== void 0) {
             const value2 = this.parseBindingElement();
             if (value2.type === "RestElement") {
@@ -124009,6 +124006,7 @@ var init_parser3 = __esm({
               span: createSpan2(key3.span.start, value2.span.end)
             };
           }
+          if (!isIdentifierLikeToken(token)) throw unexpectedTokenError(token);
           let value = key3;
           if (this.consumePunctuator("=") !== void 0) {
             const right = this.parseExpression().node;
@@ -124221,9 +124219,9 @@ var init_parser3 = __esm({
           };
         }
         const token = this.currentToken();
-        if (token.type === "identifier") {
+        if (token.type === "identifier" || token.type === "keyword") {
           this.index += 1;
-          const key3 = createIdentifier2(token);
+          const key3 = createIdentifierName(token);
           if (this.consumePunctuator(":") !== void 0) {
             const value2 = this.parseAssignmentPatternElement();
             if (value2.type === "RestElement") {
@@ -124238,6 +124236,7 @@ var init_parser3 = __esm({
               span: createSpan2(key3.span.start, value2.span.end)
             };
           }
+          if (!isIdentifierLikeToken(token)) throw unexpectedTokenError(token);
           let value = key3;
           if (this.consumePunctuator("=") !== void 0) {
             const right = this.parseAssignmentExpression().node;
@@ -124886,9 +124885,9 @@ var init_parser3 = __esm({
           };
         }
         const token = this.currentToken();
-        if (isIdentifierLikeToken(token) || token.type === "keyword" && this.peekToken(1).type === "punctuator" && this.peekToken(1).value === "(") {
+        if (token.type === "identifier" || token.type === "keyword") {
           this.index += 1;
-          const key3 = createIdentifier2(token);
+          const key3 = createIdentifierName(token);
           if (this.currentToken().type === "punctuator" && this.currentToken().value === "(") {
             const value2 = this.parseObjectMethod(asyncToken, key3.span.start);
             return {
@@ -124901,6 +124900,7 @@ var init_parser3 = __esm({
             };
           }
           if (this.consumePunctuator(":") === void 0) {
+            if (!isIdentifierLikeToken(token)) throw unexpectedTokenError(token);
             assertAllowedIdentifierReference(token);
             return {
               type: "Property",
@@ -145253,6 +145253,147 @@ var init_error = __esm({
   }
 });
 
+// packages/safe-js/src/interp/globals/object.ts
+function createObjectGlobal(methods, budget) {
+  const construct = ([value]) => {
+    if (value === null || value === void 0) {
+      budget.chargeDataUsage(1);
+      return /* @__PURE__ */ Object.create(null);
+    }
+    if (typeof value !== "object") throw new TypeError("Object primitive boxing is not supported.");
+    return value;
+  };
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "Object",
+    length: 1,
+    call: construct,
+    construct
+  });
+  const properties = materializeFunctionProperties(constructor);
+  const prototype = properties.prototype;
+  Object.defineProperty(properties, "prototype", { writable: false });
+  for (const [name, method] of Object.entries(methods)) {
+    Object.defineProperty(properties, name, { value: method, writable: true, configurable: true });
+  }
+  const prototypeMethods = {
+    toString: createSandboxClosure({
+      sandbox: true,
+      name: "toString",
+      length: 0,
+      call: (_args, context) => budget.allocateString(`[object ${typeTag(context?.thisValue)}]`)
+    }),
+    valueOf: createSandboxClosure({
+      sandbox: true,
+      name: "valueOf",
+      length: 0,
+      call: (_args, context) => {
+        const value = requireReceiver(context?.thisValue);
+        if (typeof value !== "object")
+          throw new TypeError("Object primitive boxing is not supported.");
+        return value;
+      }
+    }),
+    hasOwnProperty: createSandboxClosure({
+      sandbox: true,
+      name: "hasOwnProperty",
+      length: 1,
+      call: async ([key3], context) => hasOwnSandboxProperty(
+        requireReceiver(context?.thisValue),
+        await sandboxString(key3, budget, context),
+        false
+      )
+    }),
+    propertyIsEnumerable: createSandboxClosure({
+      sandbox: true,
+      name: "propertyIsEnumerable",
+      length: 1,
+      call: async ([key3], context) => hasOwnSandboxProperty(
+        requireReceiver(context?.thisValue),
+        await sandboxString(key3, budget, context),
+        true
+      )
+    }),
+    isPrototypeOf: createSandboxClosure({
+      sandbox: true,
+      name: "isPrototypeOf",
+      length: 1,
+      call: ([value], context) => {
+        if (typeof value !== "object" || value === null) return false;
+        const receiver = requireReceiver(context?.thisValue);
+        let depth = 0;
+        for (let current = getSandboxPrototype(value, budget); current !== null; current = getSandboxPrototype(current, budget)) {
+          budget.visitNode();
+          assertSandboxDataDepth(depth++);
+          if (current === receiver) return true;
+        }
+        return false;
+      }
+    })
+  };
+  for (const [name, method] of Object.entries(prototypeMethods)) {
+    Object.defineProperty(prototype, name, { value: method, writable: true, configurable: true });
+  }
+  markDescriptorObject(prototype);
+  installObjectPrototype(budget, prototype, constructor);
+  return constructor;
+}
+function requireReceiver(value) {
+  if (value === null || value === void 0)
+    throw new TypeError("Object method requires a non-null receiver.");
+  return value;
+}
+function hasOwnSandboxProperty(value, key3, enumerable) {
+  requireReceiver(value);
+  if (isGuestHostObject(value)) return hasHostObjectMember(value, key3, enumerable);
+  let properties;
+  if (isGuestClosure(value)) properties = materializeFunctionProperties(value);
+  else if (isSandboxClosure(value)) {
+    if (key3 === "length" || key3 === "name") return !enumerable;
+    properties = value.properties ?? /* @__PURE__ */ Object.create(null);
+  } else if (isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxGenerator(value))
+    return false;
+  else if (isSandboxRegex(value)) return key3 === "lastIndex" && !enumerable;
+  else properties = Object(value);
+  const descriptor = Object.getOwnPropertyDescriptor(properties, key3);
+  return descriptor !== void 0 && (!enumerable || descriptor.enumerable === true);
+}
+function typeTag(value) {
+  if (value === void 0) return "Undefined";
+  if (value === null) return "Null";
+  if (typeof value === "string") return "String";
+  if (typeof value === "number") return "Number";
+  if (typeof value === "boolean") return "Boolean";
+  if (isSandboxClosure(value)) {
+    while (value.boundTarget !== void 0) value = value.boundTarget;
+    return value.generator ? "GeneratorFunction" : value.async ? "AsyncFunction" : "Function";
+  }
+  if (Array.isArray(value)) return "Array";
+  if (isSandboxDate(value)) return "Date";
+  if (isSandboxErrorConstructorInstance(value, "Error")) return "Error";
+  if (isSandboxRegex(value)) return "RegExp";
+  if (isSandboxMap(value)) return "Map";
+  if (isSandboxSet(value)) return "Set";
+  if (isSandboxPromise(value)) return "Promise";
+  if (isSandboxGenerator(value)) return "Generator";
+  if (isFloat32Array(value)) return "Float32Array";
+  return "Object";
+}
+var init_object2 = __esm({
+  "packages/safe-js/src/interp/globals/object.ts"() {
+    "use strict";
+    init_graph_depth();
+    init_date();
+    init_exceptions();
+    init_float32();
+    init_host_capabilities();
+    init_object_model();
+    init_string_coercion();
+    init_values();
+  }
+});
+
 // packages/safe-js/src/interp/globals/collections.ts
 function createCollectionGlobals(options) {
   const mapConstructor = createSandboxClosure({
@@ -145866,6 +146007,7 @@ async function interpret(node, options = {}) {
       budget,
       callStack: [],
       onYield: options.onYield,
+      onSuspend: options.onSuspend,
       captureReplayState: options.captureReplayState,
       rootNode: node,
       scope,
@@ -146237,11 +146379,14 @@ async function evaluateBinaryExpression(node, context) {
   if (right.kind !== "normal") {
     return right;
   }
-  const value = node.operator === "in" && isGuestHostObject(right.value) ? hasHostObjectMember(right.value, await sandboxString(left.value, context.budget, {
-    stack: context.callStack,
-    thisValue: void 0,
-    invokeClosure: (closure, args, thisValue) => invokeSandboxClosure(closure, args, context, context.callStack, void 0, thisValue)
-  })) : applyBinaryOperator(node, left.value, right.value, context);
+  let leftValue = left.value;
+  if (node.operator === "in") {
+    if (typeof right.value !== "object" || right.value === null) {
+      throw new TypeError("Right-hand side of 'in' must be an object.");
+    }
+    leftValue = await toPropertyKey(leftValue, context);
+  }
+  const value = applyBinaryOperator(node, leftValue, right.value, context);
   return {
     kind: "normal",
     hasValue: true,
@@ -147949,9 +148094,44 @@ function applyBinaryOperator(node, left, right, context) {
       }
       return false;
     case "in":
-      throw createError("UNSUPPORTED_NODE", node, "Binary operator 'in' is not supported.");
+      return hasSandboxProperty(right, left, context);
   }
 }
+async function toPropertyKey(value, context) {
+  if (isPlainSandboxObject(value) && !isSandboxDate(value) && !isFloat32Array(value) && !isSandboxGenerator(value) && !isGuestHostObject(value)) {
+    for (const name of ["toString", "valueOf"]) {
+      const method = getMemberValue(value, name, context);
+      if (!isSandboxClosure(method)) continue;
+      const primitive = await invokeSandboxClosure(method, [], context, context.callStack, void 0, value);
+      if (primitive === null || typeof primitive !== "object") {
+        return context.budget.allocateString(String(primitive));
+      }
+    }
+    throw new TypeError("Cannot convert object to primitive value.");
+  }
+  return sandboxString(value, context.budget, {
+    stack: context.callStack,
+    thisValue: void 0,
+    invokeClosure: (closure, args, thisValue) => invokeSandboxClosure(closure, args, context, context.callStack, void 0, thisValue)
+  });
+}
+function hasSandboxProperty(value, key3, context) {
+  let current = value;
+  let depth = 0;
+  while (typeof current === "object" && current !== null) {
+    if (isGuestHostObject(current)) return hasHostObjectMember(current, key3);
+    if (hasOwnSandboxProperty(current, key3, false)) return true;
+    if (Array.isArray(current) || !isPlainSandboxObject(current) || isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current)) {
+      return getPropertyValue(current, key3, context) !== void 0;
+    }
+    current = getSandboxPrototype(current, context.budget);
+    if (current !== null) {
+      context.budget.visitNode();
+      assertSandboxDataDepth(++depth);
+    }
+  }
+  return false;
+}
 async function applyCompoundAssignmentOperator(operator, left, right, context) {
   left = await toNumericPrimitive(left, context);
   right = await toNumericPrimitive(right, context);
@@ -148507,6 +148687,7 @@ var init_interpreter = __esm({
     init_string();
     init_set();
     init_error();
+    init_object2();
     init_collections();
     init_float32array2();
     init_float32();
@@ -148638,44 +148819,51 @@ function createInterpretedClosure(node, context, evaluateNode3) {
       };
       if (!node.async)
         return executeClosure(node, args, callContext?.thisValue, invocationContext, evaluateNode3);
-      let completePrefix;
-      const synchronousPrefix = new Promise((resolve16) => {
-        completePrefix = resolve16;
-      });
-      const promise = new Promise((resolve16, reject) => {
-        runAsyncPrefix(async () => {
-          try {
-            const value = await executeClosure(
-              node,
-              args,
-              callContext?.thisValue,
-              { ...invocationContext, onSuspend: completePrefix },
-              evaluateNode3
-            );
-            resolve16(
-              isSandboxPromise(value) || getThenable(value) !== void 0 ? awaitSandboxValue(
-                createSandboxPromise(resolveSandboxValue(value, { budget: context.budget }), {
-                  trackReplay: false
-                }),
-                context.signal,
-                context.budget
-              ) : allocateProducedSandboxValue(value, context.budget)
-            );
-          } catch (error3) {
-            reject(error3);
-          } finally {
-            completePrefix();
-          }
-        }).catch((error3) => {
-          reject(error3);
-          completePrefix();
-        });
-      });
-      return createSandboxPromise(promise, { synchronousPrefix });
+      return executeAsyncFunction(
+        (onSuspend) => executeClosure(
+          node,
+          args,
+          callContext?.thisValue,
+          { ...invocationContext, onSuspend },
+          evaluateNode3
+        ),
+        context.budget,
+        context.signal
+      );
     }
   });
   return closure;
 }
+function executeAsyncFunction(execute2, budget, signal) {
+  let completePrefix;
+  const synchronousPrefix = new Promise((resolve16) => {
+    completePrefix = resolve16;
+  });
+  const promise = new Promise((resolve16, reject) => {
+    runAsyncPrefix(async () => {
+      try {
+        const value = await execute2(completePrefix);
+        resolve16(
+          isSandboxPromise(value) || getThenable(value) !== void 0 ? awaitSandboxValue(
+            createSandboxPromise(resolveSandboxValue(value, { budget }), {
+              trackReplay: false
+            }),
+            signal,
+            budget
+          ) : allocateProducedSandboxValue(value, budget)
+        );
+      } catch (error3) {
+        reject(error3);
+      } finally {
+        completePrefix();
+      }
+    }).catch((error3) => {
+      reject(error3);
+      completePrefix();
+    });
+  });
+  return createSandboxPromise(promise, { synchronousPrefix });
+}
 function createGeneratorClosure(node, context, evaluateNode3) {
   return createSandboxClosure({
     guest: true,
@@ -150388,147 +150576,6 @@ var init_misc = __esm({
   }
 });
 
-// packages/safe-js/src/interp/globals/object.ts
-function createObjectGlobal(methods, budget) {
-  const construct = ([value]) => {
-    if (value === null || value === void 0) {
-      budget.chargeDataUsage(1);
-      return /* @__PURE__ */ Object.create(null);
-    }
-    if (typeof value !== "object") throw new TypeError("Object primitive boxing is not supported.");
-    return value;
-  };
-  const constructor = createSandboxClosure({
-    guest: true,
-    sandbox: true,
-    name: "Object",
-    length: 1,
-    call: construct,
-    construct
-  });
-  const properties = materializeFunctionProperties(constructor);
-  const prototype = properties.prototype;
-  Object.defineProperty(properties, "prototype", { writable: false });
-  for (const [name, method] of Object.entries(methods)) {
-    Object.defineProperty(properties, name, { value: method, writable: true, configurable: true });
-  }
-  const prototypeMethods = {
-    toString: createSandboxClosure({
-      sandbox: true,
-      name: "toString",
-      length: 0,
-      call: (_args, context) => budget.allocateString(`[object ${typeTag(context?.thisValue)}]`)
-    }),
-    valueOf: createSandboxClosure({
-      sandbox: true,
-      name: "valueOf",
-      length: 0,
-      call: (_args, context) => {
-        const value = requireReceiver(context?.thisValue);
-        if (typeof value !== "object")
-          throw new TypeError("Object primitive boxing is not supported.");
-        return value;
-      }
-    }),
-    hasOwnProperty: createSandboxClosure({
-      sandbox: true,
-      name: "hasOwnProperty",
-      length: 1,
-      call: async ([key3], context) => hasOwnSandboxProperty(
-        requireReceiver(context?.thisValue),
-        await sandboxString(key3, budget, context),
-        false
-      )
-    }),
-    propertyIsEnumerable: createSandboxClosure({
-      sandbox: true,
-      name: "propertyIsEnumerable",
-      length: 1,
-      call: async ([key3], context) => hasOwnSandboxProperty(
-        requireReceiver(context?.thisValue),
-        await sandboxString(key3, budget, context),
-        true
-      )
-    }),
-    isPrototypeOf: createSandboxClosure({
-      sandbox: true,
-      name: "isPrototypeOf",
-      length: 1,
-      call: ([value], context) => {
-        if (typeof value !== "object" || value === null) return false;
-        const receiver = requireReceiver(context?.thisValue);
-        let depth = 0;
-        for (let current = getSandboxPrototype(value, budget); current !== null; current = getSandboxPrototype(current, budget)) {
-          budget.visitNode();
-          assertSandboxDataDepth(depth++);
-          if (current === receiver) return true;
-        }
-        return false;
-      }
-    })
-  };
-  for (const [name, method] of Object.entries(prototypeMethods)) {
-    Object.defineProperty(prototype, name, { value: method, writable: true, configurable: true });
-  }
-  markDescriptorObject(prototype);
-  installObjectPrototype(budget, prototype, constructor);
-  return constructor;
-}
-function requireReceiver(value) {
-  if (value === null || value === void 0)
-    throw new TypeError("Object method requires a non-null receiver.");
-  return value;
-}
-function hasOwnSandboxProperty(value, key3, enumerable) {
-  requireReceiver(value);
-  if (isGuestHostObject(value)) return hasHostObjectMember(value, key3, enumerable);
-  let properties;
-  if (isGuestClosure(value)) properties = materializeFunctionProperties(value);
-  else if (isSandboxClosure(value)) {
-    if (key3 === "length" || key3 === "name") return !enumerable;
-    properties = value.properties ?? /* @__PURE__ */ Object.create(null);
-  } else if (isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxGenerator(value))
-    return false;
-  else if (isSandboxRegex(value)) return key3 === "lastIndex" && !enumerable;
-  else properties = Object(value);
-  const descriptor = Object.getOwnPropertyDescriptor(properties, key3);
-  return descriptor !== void 0 && (!enumerable || descriptor.enumerable === true);
-}
-function typeTag(value) {
-  if (value === void 0) return "Undefined";
-  if (value === null) return "Null";
-  if (typeof value === "string") return "String";
-  if (typeof value === "number") return "Number";
-  if (typeof value === "boolean") return "Boolean";
-  if (isSandboxClosure(value)) {
-    while (value.boundTarget !== void 0) value = value.boundTarget;
-    return value.generator ? "GeneratorFunction" : value.async ? "AsyncFunction" : "Function";
-  }
-  if (Array.isArray(value)) return "Array";
-  if (isSandboxDate(value)) return "Date";
-  if (isSandboxErrorConstructorInstance(value, "Error")) return "Error";
-  if (isSandboxRegex(value)) return "RegExp";
-  if (isSandboxMap(value)) return "Map";
-  if (isSandboxSet(value)) return "Set";
-  if (isSandboxPromise(value)) return "Promise";
-  if (isSandboxGenerator(value)) return "Generator";
-  if (isFloat32Array(value)) return "Float32Array";
-  return "Object";
-}
-var init_object2 = __esm({
-  "packages/safe-js/src/interp/globals/object.ts"() {
-    "use strict";
-    init_graph_depth();
-    init_date();
-    init_exceptions();
-    init_float32();
-    init_host_capabilities();
-    init_object_model();
-    init_string_coercion();
-    init_values();
-  }
-});
-
 // packages/safe-js/src/interp/globals/object-array.ts
 function createObjectArrayGlobals(options) {
   return {