@poe-platform/safe-js 0.1.161 → 0.1.162

package/dist/safe-js/chunks/{chunk-AR5OJ6OJ.js → chunk-56XYHJCY.js}

@@ -18641,7 +18641,18 @@ function createObjectGlobal(methods, budget) {
       sandbox: true,
       name: "toString",
       length: 0,
-      call: (_args, context) => budget.allocateString(`[object ${typeTag(context?.thisValue)}]`)
+      call: (_args, context) => {
+        const receiver = context?.thisValue;
+        if (receiver === void 0 || receiver === null)
+          return budget.allocateString(`[object ${typeTag(receiver)}]`);
+        const object = construct([receiver]);
+        const descriptor = isGuestHostObject(object) ? void 0 : getSandboxPropertyDescriptor(object, Symbol.toStringTag, budget);
+        const fallback = typeTag(object, descriptor !== void 0 || hasExplicitSandboxPrototype(object));
+        const finish = (tag2) => budget.allocateString(`[object ${typeof tag2 === "string" ? tag2 : fallback}]`);
+        if (descriptor === void 0) return finish(void 0);
+        const tag = readPropertyDescriptor(descriptor, object, context, true);
+        return tag instanceof Promise ? tag.then(finish) : finish(tag);
+      }
     }),
     valueOf: createSandboxClosure({
       sandbox: true,
@@ -18716,14 +18727,16 @@ function hasOwnSandboxProperty(value, key, enumerable) {
   const descriptor = Object.getOwnPropertyDescriptor(properties, key);
   return descriptor !== void 0 && (!enumerable || descriptor.enumerable === true);
 }
-function typeTag(value) {
+function typeTag(value, builtinOnly = false) {
   if (isSandboxBox(value)) value = boxedValue(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 (isSandboxArguments(value)) return "Arguments";
   if (isSandboxClosure(value)) {
+    if (builtinOnly) return "Function";
     while (value.boundTarget !== void 0) value = value.boundTarget;
     return value.generator ? "GeneratorFunction" : value.async ? "AsyncFunction" : "Function";
   }
@@ -18731,6 +18744,7 @@ function typeTag(value) {
   if (isSandboxDate(value)) return "Date";
   if (isSandboxErrorConstructorInstance(value, "Error")) return "Error";
   if (isSandboxRegex(value)) return "RegExp";
+  if (builtinOnly) return "Object";
   if (isSandboxMap(value)) return "Map";
   if (isSandboxSet(value)) return "Set";
   if (isSandboxCollectionIterator(value)) return collectionIteratorState(value).collectionKind === "map" ? "Map Iterator" : "Set Iterator";
@@ -25397,351 +25411,6 @@ var AS010Scanner = class {
   }
 };
 
-// packages/safe-js/src/lint/rules/AS011.ts
-var FORBIDDEN_PROPERTY_NAMES = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
-var MESSAGE2 = "Property access to '__proto__', 'prototype', and 'constructor' is not allowed.";
-function AS011(source, options = {}) {
-  return new AS011Scanner(options.filename ?? "<input>").scan(source);
-}
-var AS011Scanner = class {
-  constructor(filename) {
-    this.filename = filename;
-  }
-  filename;
-  diagnostics = [];
-  scan(source) {
-    this.visitModule(parseModule(source, this.filename));
-    return this.diagnostics;
-  }
-  visitModule(node) {
-    for (const statement of node.body) {
-      this.visitStatement(statement);
-    }
-  }
-  visitStatement(node) {
-    if (node.type === "ClassDeclaration") {
-      visitClassElements(node, (expression) => this.visitExpression(expression), (statement) => this.visitStatement(statement));
-      return;
-    }
-    switch (node.type) {
-      case "FunctionDeclaration":
-        this.visitArrowFunction(node);
-        return;
-      case "BlockStatement":
-        for (const statement of node.body) {
-          this.visitStatement(statement);
-        }
-        return;
-      case "ExpressionStatement":
-        this.visitExpression(node.expression);
-        return;
-      case "IfStatement":
-        this.visitIfStatement(node);
-        return;
-      case "ForStatement":
-        this.visitForStatement(node);
-        return;
-      case "ForInStatement":
-      case "ForOfStatement":
-        this.visitForOfStatement(node);
-        return;
-      case "WhileStatement":
-      case "DoWhileStatement":
-        this.visitExpression(node.test);
-        this.visitStatement(node.body);
-        return;
-      case "TryStatement":
-        this.visitTryStatement(node);
-        return;
-      case "VariableDeclaration":
-        this.visitVariableDeclaration(node);
-        return;
-      case "ReturnStatement":
-        this.visitReturnStatement(node);
-        return;
-      case "ThrowStatement":
-        this.visitThrowStatement(node);
-        return;
-      case "ExportNamedDeclaration":
-        this.visitVariableDeclaration(node.declaration);
-        return;
-      case "ExportDefaultDeclaration":
-        if (node.declaration.type === "ClassDeclaration" || node.declaration.type === "FunctionDeclaration") this.visitStatement(node.declaration);
-        else this.visitExpression(node.declaration);
-        return;
-      case "ImportDeclaration":
-      case "BreakStatement":
-      case "ContinueStatement":
-        return;
-    }
-  }
-  visitIfStatement(node) {
-    this.visitExpression(node.test);
-    this.visitStatement(node.consequent);
-    if (node.alternate !== void 0) {
-      this.visitStatement(node.alternate);
-    }
-  }
-  visitForStatement(node) {
-    if (node.init !== void 0) {
-      if (node.init.type === "VariableDeclaration") {
-        this.visitVariableDeclaration(node.init);
-      } else {
-        this.visitExpression(node.init);
-      }
-    }
-    if (node.test !== void 0) {
-      this.visitExpression(node.test);
-    }
-    if (node.update !== void 0) {
-      this.visitExpression(node.update);
-    }
-    this.visitStatement(node.body);
-  }
-  visitForOfStatement(node) {
-    if (node.left.type === "VariableDeclaration") {
-      this.visitVariableDeclaration(node.left);
-    } else {
-      this.visitAssignmentTarget(node.left);
-    }
-    this.visitExpression(node.right);
-    this.visitStatement(node.body);
-  }
-  visitTryStatement(node) {
-    this.visitStatement(node.block);
-    if (node.handler !== void 0) {
-      this.visitCatchClause(node.handler);
-    }
-    if (node.finalizer !== void 0) {
-      this.visitStatement(node.finalizer);
-    }
-  }
-  visitCatchClause(node) {
-    if (node.param !== void 0) {
-      this.visitAssignmentTarget(node.param);
-    }
-    this.visitStatement(node.body);
-  }
-  visitVariableDeclaration(node) {
-    for (const declarator of node.declarations) {
-      this.visitVariableDeclarator(declarator);
-    }
-  }
-  visitVariableDeclarator(node) {
-    this.visitBindingTarget(node.id);
-    if (node.init !== void 0) {
-      this.visitExpression(node.init);
-    }
-  }
-  visitReturnStatement(node) {
-    if (node.argument !== void 0) {
-      this.visitExpression(node.argument);
-    }
-  }
-  visitThrowStatement(node) {
-    this.visitExpression(node.argument);
-  }
-  visitExpression(node) {
-    if (node.type === "ClassExpression") {
-      visitClassElements(node, (expression) => this.visitExpression(expression), (statement) => this.visitStatement(statement));
-      return;
-    }
-    switch (node.type) {
-      case "YieldExpression":
-        if (node.argument !== void 0) {
-          this.visitExpression(node.argument);
-        }
-        return;
-      case "FunctionExpression":
-      case "ArrowFunctionExpression":
-        this.visitArrowFunction(node);
-        return;
-      case "AwaitExpression":
-        this.visitExpression(node.argument);
-        return;
-      case "ArrayExpression":
-        this.visitArrayExpression(node);
-        return;
-      case "ObjectExpression":
-        this.visitObjectExpression(node);
-        return;
-      case "UnaryExpression":
-        this.visitUnaryExpression(node);
-        return;
-      case "BinaryExpression":
-      case "LogicalExpression":
-        this.visitBinaryLikeExpression(node);
-        return;
-      case "ConditionalExpression":
-        this.visitConditionalExpression(node);
-        return;
-      case "MemberExpression":
-        this.visitMemberExpression(node);
-        return;
-      case "AssignmentExpression":
-        this.visitAssignmentExpression(node);
-        return;
-      case "CallExpression":
-        this.visitCallExpression(node);
-        return;
-      case "TemplateLiteral":
-        this.visitTemplateLiteral(node);
-        return;
-      case "Identifier":
-      case "BooleanLiteral":
-      case "NullLiteral":
-      case "NumericLiteral":
-      case "StringLiteral":
-      case "UndefinedLiteral":
-        return;
-    }
-  }
-  visitArrowFunction(node) {
-    for (const parameter of node.params) {
-      this.visitBindingTarget(parameter);
-    }
-    if (node.body.type === "BlockStatement") {
-      for (const statement of node.body.body) {
-        this.visitStatement(statement);
-      }
-      return;
-    }
-    this.visitExpression(node.body);
-  }
-  visitArrayExpression(node) {
-    for (const element of node.elements) {
-      if (element === null) {
-        continue;
-      }
-      if (element.type === "SpreadElement") {
-        this.visitExpression(element.argument);
-        continue;
-      }
-      this.visitExpression(element);
-    }
-  }
-  visitObjectExpression(node) {
-    for (const property of node.properties) {
-      if (property.type === "SpreadElement") {
-        this.visitExpression(property.argument);
-        continue;
-      }
-      this.visitProperty(property);
-    }
-  }
-  visitProperty(node) {
-    if (node.computed) {
-      this.visitExpression(node.key);
-    }
-    this.visitExpression(node.value);
-  }
-  visitUnaryExpression(node) {
-    this.visitExpression(node.argument);
-  }
-  visitBinaryLikeExpression(node) {
-    this.visitExpression(node.left);
-    this.visitExpression(node.right);
-  }
-  visitConditionalExpression(node) {
-    this.visitExpression(node.test);
-    this.visitExpression(node.consequent);
-    this.visitExpression(node.alternate);
-  }
-  visitMemberExpression(node) {
-    this.visitExpression(node.object);
-    if (this.isForbiddenMemberProperty(node)) {
-      this.report(node.property.span);
-    }
-    this.visitExpression(node.property);
-  }
-  visitAssignmentExpression(node) {
-    this.visitAssignmentTarget(node.left);
-    this.visitExpression(node.right);
-  }
-  visitCallExpression(node) {
-    this.visitExpression(node.callee);
-    for (const argument of node.arguments) {
-      if (argument.type === "SpreadElement") {
-        this.visitExpression(argument.argument);
-        continue;
-      }
-      this.visitExpression(argument);
-    }
-  }
-  visitTemplateLiteral(node) {
-    for (const expression of node.expressions) {
-      this.visitExpression(expression);
-    }
-  }
-  visitAssignmentTarget(node) {
-    switch (node.type) {
-      case "Identifier":
-      case "MetaProperty":
-        return;
-      case "MemberExpression":
-        this.visitMemberExpression(node);
-        return;
-      case "AssignmentPattern":
-        this.visitAssignmentTarget(node.left);
-        this.visitExpression(node.right);
-        return;
-      case "RestElement":
-        this.visitAssignmentTarget(node.argument);
-        return;
-      case "ArrayPattern":
-        for (const element of node.elements) {
-          if (element !== null) {
-            this.visitAssignmentTarget(element);
-          }
-        }
-        return;
-      case "ObjectPattern":
-        for (const property of node.properties) {
-          if (property.type === "RestElement") {
-            this.visitAssignmentTarget(property.argument);
-            continue;
-          }
-          if (property.computed) {
-            this.visitExpression(property.key);
-          }
-          this.visitAssignmentTarget(property.value);
-        }
-        return;
-    }
-  }
-  visitBindingTarget(node) {
-    switch (node.type) {
-      case "AssignmentPattern":
-        this.visitBindingTarget(node.left);
-        this.visitExpression(node.right);
-        return;
-      case "RestElement":
-        this.visitBindingTarget(node.argument);
-        return;
-      default:
-        this.visitAssignmentTarget(node);
-        return;
-    }
-  }
-  isForbiddenMemberProperty(node) {
-    if (!node.computed) {
-      return node.property.type === "Identifier" && FORBIDDEN_PROPERTY_NAMES.has(node.property.name);
-    }
-    return node.property.type === "StringLiteral" && FORBIDDEN_PROPERTY_NAMES.has(node.property.value);
-  }
-  report(span) {
-    this.diagnostics.push({
-      code: "AS011",
-      severity: "error",
-      message: MESSAGE2,
-      filename: this.filename,
-      line: span.start.line,
-      column: span.start.column,
-      span
-    });
-  }
-};
-
 // packages/safe-js/src/lint/rules/AS013.ts
 function AS013(source, options = {}) {
   const filename = options.filename ?? "<input>";
@@ -26714,7 +26383,7 @@ function patternTargetContainsAwait(node) {
 }
 
 // packages/safe-js/src/lint/rules/AS-destructure-null-default.ts
-var MESSAGE3 = "Destructuring default values only apply to undefined, not null.";
+var MESSAGE2 = "Destructuring default values only apply to undefined, not null.";
 var HINT = "Handle null explicitly before destructuring or use ?? after binding.";
 function AS_DESTRUCTURE_NULL_DEFAULT(source, options = {}) {
   return new ASDestructureNullDefaultScanner(options.filename ?? "<input>").scan(source);
@@ -27118,7 +26787,7 @@ var ASDestructureNullDefaultScanner = class {
     this.diagnostics.push({
       code: "AS-DESTRUCTURE-NULL-DEFAULT",
       severity: "warning",
-      message: MESSAGE3,
+      message: MESSAGE2,
       filename: this.filename,
       line: span.start.line,
       column: span.start.column,
@@ -31734,7 +31403,7 @@ var ASShadowGlobalScanner = class {
 };
 
 // packages/safe-js/src/lint/rules/AS-unbounded-loop.ts
-var MESSAGE4 = "Unbounded loop or generator source has no static exit with break, return, or throw.";
+var MESSAGE3 = "Unbounded loop or generator source has no static exit with break, return, or throw.";
 function AS_UNBOUNDED_LOOP(source, options = {}) {
   return new ASUnboundedLoopScanner(options.filename ?? "<input>").scan(source);
 }
@@ -32044,7 +31713,7 @@ var ASUnboundedLoopScanner = class {
     this.diagnostics.push({
       code: "AS-UNBOUNDED-LOOP",
       severity: "warning",
-      message: MESSAGE4,
+      message: MESSAGE3,
       filename: this.filename,
       line: node.span.start.line,
       column: node.span.start.column,
@@ -33050,7 +32719,6 @@ var RULES = [
   AS_MISSING_ASYNC,
   AS009,
   AS010,
-  AS011,
   AS013,
   AS015,
   AS_IMPORT_CYCLE,
@@ -36214,4 +35882,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-AR5OJ6OJ.js.map
+//# sourceMappingURL=chunk-56XYHJCY.js.map