poe-code 14.0.39 → 14.0.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "14.0.39",
+  "version": "14.0.41",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",

package/packages/safe-js/dist/chunks/{chunk-CSC4EXIV.js → chunk-5J6BX3HD.js}

@@ -3554,9 +3554,9 @@ var Parser = class {
       };
     }
     const token = this.currentToken();
-    if (token.type === "identifier") {
+    if (token.type === "identifier" || token.type === "keyword") {
       this.index += 1;
-      const key = createIdentifier2(token);
+      const key = createIdentifierName(token);
       if (this.consumePunctuator(":") !== void 0) {
         const value2 = this.parseBindingElement();
         if (value2.type === "RestElement") {
@@ -3571,6 +3571,7 @@ var Parser = class {
           span: createSpan2(key.span.start, value2.span.end)
         };
       }
+      if (!isIdentifierLikeToken(token)) throw unexpectedTokenError(token);
       let value = key;
       if (this.consumePunctuator("=") !== void 0) {
         const right = this.parseExpression().node;
@@ -3783,9 +3784,9 @@ var Parser = class {
       };
     }
     const token = this.currentToken();
-    if (token.type === "identifier") {
+    if (token.type === "identifier" || token.type === "keyword") {
       this.index += 1;
-      const key = createIdentifier2(token);
+      const key = createIdentifierName(token);
       if (this.consumePunctuator(":") !== void 0) {
         const value2 = this.parseAssignmentPatternElement();
         if (value2.type === "RestElement") {
@@ -3800,6 +3801,7 @@ var Parser = class {
           span: createSpan2(key.span.start, value2.span.end)
         };
       }
+      if (!isIdentifierLikeToken(token)) throw unexpectedTokenError(token);
       let value = key;
       if (this.consumePunctuator("=") !== void 0) {
         const right = this.parseAssignmentExpression().node;
@@ -4448,9 +4450,9 @@ var Parser = class {
       };
     }
     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 key = createIdentifier2(token);
+      const key = createIdentifierName(token);
       if (this.currentToken().type === "punctuator" && this.currentToken().value === "(") {
         const value2 = this.parseObjectMethod(asyncToken, key.span.start);
         return {
@@ -4463,6 +4465,7 @@ var Parser = class {
         };
       }
       if (this.consumePunctuator(":") === void 0) {
+        if (!isIdentifierLikeToken(token)) throw unexpectedTokenError(token);
         assertAllowedIdentifierReference(token);
         return {
           type: "Property",
@@ -5874,10 +5877,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";
@@ -25081,6 +25081,134 @@ function isObjectLike(value) {
   return typeof value === "object" && value !== null;
 }
 
+// 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 ([key], context) => hasOwnSandboxProperty(
+        requireReceiver(context?.thisValue),
+        await sandboxString(key, budget, context),
+        false
+      )
+    }),
+    propertyIsEnumerable: createSandboxClosure({
+      sandbox: true,
+      name: "propertyIsEnumerable",
+      length: 1,
+      call: async ([key], context) => hasOwnSandboxProperty(
+        requireReceiver(context?.thisValue),
+        await sandboxString(key, 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, key, enumerable) {
+  requireReceiver(value);
+  if (isGuestHostObject(value)) return hasHostObjectMember(value, key, enumerable);
+  let properties;
+  if (isGuestClosure(value)) properties = materializeFunctionProperties(value);
+  else if (isSandboxClosure(value)) {
+    if (key === "length" || key === "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 key === "lastIndex" && !enumerable;
+  else properties = Object(value);
+  const descriptor = Object.getOwnPropertyDescriptor(properties, key);
+  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";
+}
+
 // packages/safe-js/src/interp/globals/collections.ts
 var mapConstructors = /* @__PURE__ */ new WeakSet();
 var setConstructors = /* @__PURE__ */ new WeakSet();
@@ -25712,6 +25840,7 @@ async function interpret(node, options = {}) {
       budget,
       callStack: [],
       onYield: options.onYield,
+      onSuspend: options.onSuspend,
       captureReplayState: options.captureReplayState,
       rootNode: node,
       scope,
@@ -26083,11 +26212,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,
@@ -27795,8 +27927,43 @@ 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, key, context) {
+  let current = value;
+  let depth = 0;
+  while (typeof current === "object" && current !== null) {
+    if (isGuestHostObject(current)) return hasHostObjectMember(current, key);
+    if (hasOwnSandboxProperty(current, key, false)) return true;
+    if (Array.isArray(current) || !isPlainSandboxObject(current) || isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current)) {
+      return getPropertyValue(current, key, 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);
@@ -28393,44 +28560,51 @@ function createInterpretedClosure(node, context, evaluateNode2) {
       };
       if (!node.async)
         return executeClosure(node, args, callContext?.thisValue, invocationContext, evaluateNode2);
-      let completePrefix;
-      const synchronousPrefix = new Promise((resolve) => {
-        completePrefix = resolve;
-      });
-      const promise = new Promise((resolve, reject) => {
-        runAsyncPrefix(async () => {
-          try {
-            const value = await executeClosure(
-              node,
-              args,
-              callContext?.thisValue,
-              { ...invocationContext, onSuspend: completePrefix },
-              evaluateNode2
-            );
-            resolve(
-              isSandboxPromise(value) || getThenable(value) !== void 0 ? awaitSandboxValue(
-                createSandboxPromise(resolveSandboxValue(value, { budget: context.budget }), {
-                  trackReplay: false
-                }),
-                context.signal,
-                context.budget
-              ) : allocateProducedSandboxValue(value, context.budget)
-            );
-          } catch (error) {
-            reject(error);
-          } finally {
-            completePrefix();
-          }
-        }).catch((error) => {
-          reject(error);
-          completePrefix();
-        });
-      });
-      return createSandboxPromise(promise, { synchronousPrefix });
+      return executeAsyncFunction(
+        (onSuspend) => executeClosure(
+          node,
+          args,
+          callContext?.thisValue,
+          { ...invocationContext, onSuspend },
+          evaluateNode2
+        ),
+        context.budget,
+        context.signal
+      );
     }
   });
   return closure;
 }
+function executeAsyncFunction(execute, budget, signal) {
+  let completePrefix;
+  const synchronousPrefix = new Promise((resolve) => {
+    completePrefix = resolve;
+  });
+  const promise = new Promise((resolve, reject) => {
+    runAsyncPrefix(async () => {
+      try {
+        const value = await execute(completePrefix);
+        resolve(
+          isSandboxPromise(value) || getThenable(value) !== void 0 ? awaitSandboxValue(
+            createSandboxPromise(resolveSandboxValue(value, { budget }), {
+              trackReplay: false
+            }),
+            signal,
+            budget
+          ) : allocateProducedSandboxValue(value, budget)
+        );
+      } catch (error) {
+        reject(error);
+      } finally {
+        completePrefix();
+      }
+    }).catch((error) => {
+      reject(error);
+      completePrefix();
+    });
+  });
+  return createSandboxPromise(promise, { synchronousPrefix });
+}
 function createGeneratorClosure(node, context, evaluateNode2) {
   return createSandboxClosure({
     guest: true,
@@ -30094,134 +30268,6 @@ function assertStructuredCloneable(value, seen) {
   }
 }
 
-// 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 ([key], context) => hasOwnSandboxProperty(
-        requireReceiver(context?.thisValue),
-        await sandboxString(key, budget, context),
-        false
-      )
-    }),
-    propertyIsEnumerable: createSandboxClosure({
-      sandbox: true,
-      name: "propertyIsEnumerable",
-      length: 1,
-      call: async ([key], context) => hasOwnSandboxProperty(
-        requireReceiver(context?.thisValue),
-        await sandboxString(key, 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, key, enumerable) {
-  requireReceiver(value);
-  if (isGuestHostObject(value)) return hasHostObjectMember(value, key, enumerable);
-  let properties;
-  if (isGuestClosure(value)) properties = materializeFunctionProperties(value);
-  else if (isSandboxClosure(value)) {
-    if (key === "length" || key === "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 key === "lastIndex" && !enumerable;
-  else properties = Object(value);
-  const descriptor = Object.getOwnPropertyDescriptor(properties, key);
-  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";
-}
-
 // packages/safe-js/src/interp/globals/object-array.ts
 function createObjectArrayGlobals(options) {
   return {
@@ -32772,4 +32818,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-CSC4EXIV.js.map
+//# sourceMappingURL=chunk-5J6BX3HD.js.map