@poe-platform/safe-js 0.1.161 → 0.1.163

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

@@ -9070,221 +9070,6 @@ async function withRunResources(signal, execute) {
   return result;
 }
 
-// packages/safe-js/src/interp/patterns.ts
-async function bindPattern(pattern, value, target, scope, context) {
-  switch (pattern.type) {
-    case "Identifier":
-      bindIdentifier(pattern, value, target, scope);
-      return { ok: true };
-    case "MemberExpression":
-      if ("kind" in target) {
-        throw new TypeError("Destructuring declarations cannot bind to member expressions.");
-      }
-      return bindMemberExpression(pattern, value, scope, context);
-    case "AssignmentPattern":
-      return bindAssignmentPattern(pattern, value, target, scope, context);
-    case "ArrayPattern":
-      return bindArrayPattern(pattern, value, target, scope, context);
-    case "ObjectPattern":
-      return bindObjectPattern(pattern, value, target, scope, context);
-    case "RestElement":
-      return bindPattern(pattern.argument, value, target, scope, context);
-  }
-}
-function bindIdentifier(pattern, value, target, scope) {
-  if ("assign" in target || target.kind === "var" && target.initialize !== true) {
-    if ("assign" in target) {
-      const binding = scope.lookup(pattern.name);
-      if (!binding.found) {
-        throw new ReferenceError(`Cannot assign to undeclared binding '${pattern.name}'.`);
-      }
-      if (binding.kind === "const") {
-        throw new TypeError(`Cannot assign to const '${pattern.name}'`);
-      }
-    }
-    scope.assign(pattern.name, value);
-    return;
-  }
-  scope.declare(pattern.name, target.kind, value);
-}
-async function bindAssignmentPattern(pattern, value, target, scope, context) {
-  if (value !== void 0) {
-    return bindPattern(pattern.left, value, target, scope, context);
-  }
-  const defaultValue = await context.evaluate(
-    pattern.right,
-    pattern.left.type === "Identifier" ? pattern.left.name : void 0
-  );
-  if (defaultValue.kind !== "normal") {
-    return { ok: false, result: defaultValue };
-  }
-  return bindPattern(pattern.left, defaultValue.value, target, scope, context);
-}
-async function bindArrayPattern(pattern, value, target, scope, context) {
-  const iterator = isSandboxCollectionIterator(value) ? value : void 0;
-  const values = iterator === void 0 ? getArrayPatternValues(value) : void 0;
-  let cursor = 0;
-  let done = false;
-  const next = async () => {
-    if (iterator !== void 0) return nextCollectionIterator(iterator, context.budget);
-    if (done || cursor >= values.length) {
-      done = true;
-      return { done: true, value: void 0 };
-    }
-    return { done: false, value: await context.getProperty(values, cursor++) };
-  };
-  for (let index = 0; index < pattern.elements.length; index += 1) {
-    const element = pattern.elements[index];
-    if (element === null) {
-      await next();
-      continue;
-    }
-    let elementValue;
-    if (element.type === "RestElement") {
-      const rest = [];
-      for (let entry = await next(); !entry.done; entry = await next()) {
-        context.budget?.allocateArrayLength(rest.length + 1);
-        rest.push(entry.value);
-      }
-      elementValue = rest;
-    } else {
-      elementValue = (await next()).value;
-    }
-    const binding = await bindPattern(element, elementValue, target, scope, context);
-    if (!binding.ok) {
-      return binding;
-    }
-  }
-  return { ok: true };
-}
-async function bindObjectPattern(pattern, value, target, scope, context) {
-  if (typeof value !== "object" || value === null) {
-    throw new TypeError("Object destructuring declarations require a non-null object value.");
-  }
-  const excludedKeys = /* @__PURE__ */ new Set();
-  for (const property of pattern.properties) {
-    if (property.type === "RestElement") {
-      const binding2 = await bindPattern(
-        property,
-        await copyObjectRestValue(value, excludedKeys, context),
-        target,
-        scope,
-        context
-      );
-      if (!binding2.ok) {
-        return binding2;
-      }
-      continue;
-    }
-    const key = await evaluatePatternKey(property, context);
-    if (!key.ok) {
-      return key;
-    }
-    excludedKeys.add(typeof key.value === "symbol" ? key.value : String(key.value));
-    const binding = await bindPattern(
-      property.value,
-      await context.getProperty(value, key.value),
-      target,
-      scope,
-      context
-    );
-    if (!binding.ok) {
-      return binding;
-    }
-  }
-  return { ok: true };
-}
-async function bindMemberExpression(pattern, value, scope, context) {
-  const object = await context.evaluate(pattern.object);
-  if (object.kind !== "normal") {
-    return { ok: false, result: object };
-  }
-  const property = pattern.computed ? await context.evaluate(pattern.property) : { kind: "normal", value: getStaticPropertyName(pattern.property) };
-  if (property.kind !== "normal") {
-    return { ok: false, result: property };
-  }
-  if (object.value === null || object.value === void 0) {
-    throw new TypeError("Cannot assign properties of null or undefined.");
-  }
-  if (!isIndexableValue(object.value)) {
-    throw new TypeError("Assignment expressions require a sandbox object property.");
-  }
-  await context.setProperty(object.value, await context.toPropertyKey(property.value), value);
-  return { ok: true };
-}
-async function evaluatePatternKey(property, context) {
-  return property.computed ? evaluateProperty(property.key, context) : { ok: true, value: getStaticPropertyName(property.key) };
-}
-async function evaluateProperty(property, context) {
-  const result = await context.evaluate(property);
-  if (result.kind !== "normal") {
-    return { ok: false, result };
-  }
-  return { ok: true, value: await context.toPropertyKey(result.value) };
-}
-function getStaticPropertyName(property) {
-  if (property.type === "Identifier") {
-    return property.name;
-  }
-  if (property.type === "StringLiteral" || property.type === "NumericLiteral") {
-    return property.value;
-  }
-  throw new TypeError(`Unsupported static property node '${property.type}'.`);
-}
-function getArrayPatternValues(value) {
-  if (Array.isArray(value)) {
-    return value;
-  }
-  if (typeof value === "string") {
-    return Array.from(value);
-  }
-  if (isSandboxMap(value)) {
-    return Array.from(value.entries, ([key, entry]) => [key, entry]);
-  }
-  if (isSandboxSet(value)) {
-    return [...value.values];
-  }
-  if (isIterableValue(value)) {
-    throw new TypeError(
-      `Array destructuring declarations support only arrays and strings; received ${describeRuntimeValue(value)}.`
-    );
-  }
-  throw new TypeError("Array destructuring declarations require an array or string iterable.");
-}
-function isIterableValue(value) {
-  return typeof value === "object" && value !== null && Symbol.iterator in value && typeof value[Symbol.iterator] === "function";
-}
-function describeRuntimeValue(value) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  if (typeof value === "object") return value.constructor?.name ?? "Object";
-  return typeof value;
-}
-async function copyObjectRestValue(value, excludedKeys, context) {
-  const rest = /* @__PURE__ */ Object.create(null);
-  const release = context.budget === void 0 ? () => void 0 : retainValues(context.budget, () => [value, rest]);
-  try {
-    for (const key of ownEnumerableSandboxKeys(value, true)) {
-      if (excludedKeys.has(key) || !hasOwnSandboxProperty(value, key, true)) continue;
-      defineProperty(rest, key, await context.getProperty(value, key));
-    }
-    return rest;
-  } finally {
-    release();
-  }
-}
-function isIndexableValue(value) {
-  return typeof value === "object" && value !== null;
-}
-function defineProperty(target, key, value) {
-  Object.defineProperty(target, key, {
-    configurable: true,
-    enumerable: true,
-    value,
-    writable: true
-  });
-}
-
 // packages/safe-js/src/interp/jobs.ts
 import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
 var activeJob = new AsyncLocalStorage4();
@@ -9377,31 +9162,6 @@ async function suspendJob(pending) {
   }
 }
 
-// packages/safe-js/src/interp/var-hoist.ts
-function hoistVarDeclarations(node, scope) {
-  for (const declaration of hoistedVarDeclarations([node])) {
-    for (const declarator of declaration.declarations) {
-      for (const identifier of boundIdentifiers(declarator.id)) {
-        scope.declareVar(identifier.name);
-      }
-    }
-  }
-}
-
-// packages/safe-js/src/interp/data-checkpoint.ts
-function createDataCheckpoint(budget, context) {
-  let estimatedDataSize = 0;
-  return (value, growth = 0, force = false) => {
-    const limit = budget.limits.dataSize;
-    if (limit === void 0) return;
-    estimatedDataSize = Math.max(estimatedDataSize, budget.currentDataSize) + growth;
-    if (!force && estimatedDataSize <= limit) return;
-    if (context?.reconcileData !== void 0) context.reconcileData(value);
-    else reconcileCompiledValues(budget, [value], context?.compilation);
-    estimatedDataSize = budget.currentDataSize;
-  };
-}
-
 // packages/safe-js/src/interp/iteration.ts
 async function acquireSandboxIterator(value, budget, context, asyncProtocol = false, signal) {
   const key = asyncProtocol ? Symbol.asyncIterator : Symbol.iterator;
@@ -9715,33 +9475,276 @@ function syncIterator(iterator) {
   };
 }
 
-// packages/safe-js/src/interp/globals/numeric-parsers.ts
-function createNumericParsers(budget) {
-  return {
-    parseInt: createSandboxClosure({
-      sandbox: true,
-      name: "parseInt",
-      call: ([value, radix], context) => {
-        const parse2 = (text2) => {
-          const release = retainValues(budget, () => [text2]);
-          let convertedRadix;
-          try {
-            convertedRadix = sandboxNumber(radix, budget, context);
-          } catch (error) {
-            release();
-            throw error;
-          }
-          if (typeof convertedRadix === "number") {
-            try {
-              return globalThis.parseInt(text2, convertedRadix);
-            } finally {
-              release();
-            }
-          }
-          return convertedRadix.then((number) => globalThis.parseInt(text2, number)).finally(release);
-        };
-        const text = sandboxString(value, budget, context);
-        return typeof text === "string" ? parse2(text) : text.then(parse2);
+// packages/safe-js/src/interp/patterns.ts
+async function bindPattern(pattern, value, target, scope, context) {
+  switch (pattern.type) {
+    case "Identifier":
+      bindIdentifier(pattern, value, target, scope);
+      return { ok: true };
+    case "MemberExpression":
+      if ("kind" in target) {
+        throw new TypeError("Destructuring declarations cannot bind to member expressions.");
+      }
+      return bindMemberExpression(pattern, value, scope, context);
+    case "AssignmentPattern":
+      return bindAssignmentPattern(pattern, value, target, scope, context);
+    case "ArrayPattern":
+      return bindArrayPattern(pattern, value, target, scope, context);
+    case "ObjectPattern":
+      return bindObjectPattern(pattern, value, target, scope, context);
+    case "RestElement":
+      return bindPattern(pattern.argument, value, target, scope, context);
+  }
+}
+function bindIdentifier(pattern, value, target, scope) {
+  if ("assign" in target || target.kind === "var" && target.initialize !== true) {
+    if ("assign" in target) {
+      const binding = scope.lookup(pattern.name);
+      if (!binding.found) {
+        throw new ReferenceError(`Cannot assign to undeclared binding '${pattern.name}'.`);
+      }
+      if (binding.kind === "const") {
+        throw new TypeError(`Cannot assign to const '${pattern.name}'`);
+      }
+    }
+    scope.assign(pattern.name, value);
+    return;
+  }
+  scope.declare(pattern.name, target.kind, value);
+}
+async function bindAssignmentPattern(pattern, value, target, scope, context) {
+  if (value !== void 0) {
+    return bindPattern(pattern.left, value, target, scope, context);
+  }
+  const defaultValue = await context.evaluate(
+    pattern.right,
+    pattern.left.type === "Identifier" ? pattern.left.name : void 0
+  );
+  if (defaultValue.kind !== "normal") {
+    return { ok: false, result: defaultValue };
+  }
+  return bindPattern(pattern.left, defaultValue.value, target, scope, context);
+}
+async function bindArrayPattern(pattern, value, target, scope, context) {
+  const budget = context.budget ?? new Budget();
+  const iterator = await acquireSandboxIterator(
+    value,
+    budget,
+    context.callContext ?? {
+      stack: [],
+      thisValue: void 0,
+      getProperty: context.getProperty
+    }
+  );
+  if (iterator === void 0) throw new TypeError("Array destructuring requires an iterable.");
+  let done = false;
+  const next = async (readValue = true) => {
+    if (done) return { value: void 0 };
+    try {
+      const result = await iterator.next();
+      if (typeof result !== "object" && typeof result !== "function" || result === null)
+        throw new TypeError("Iterator result must be an object.");
+      done = Boolean((await readIteratorResult(iterator, result, "done")).value);
+      return done || !readValue ? { value: void 0 } : await readIteratorResult(iterator, result, "value");
+    } catch (error) {
+      done = true;
+      throw error;
+    }
+  };
+  let retained;
+  const release = retainValues(budget, () => [value, iterator.retainedValue, retained]);
+  try {
+    for (let index = 0; index < pattern.elements.length; index += 1) {
+      const element = pattern.elements[index];
+      if (element === null) {
+        await next(false);
+        continue;
+      }
+      let elementValue;
+      if (element.type === "RestElement") {
+        const rest = [];
+        retained = rest;
+        for (let entry = await next(); !done; entry = await next()) {
+          budget.allocateArrayLength(rest.length + 1);
+          rest.push(entry.value);
+        }
+        elementValue = rest;
+      } else {
+        elementValue = (await next()).value;
+      }
+      retained = elementValue;
+      const binding = await bindPattern(element, elementValue, target, scope, context);
+      if (!binding.ok) {
+        if (!done) {
+          done = true;
+          await closeIterator(iterator, binding.result.kind === "throw");
+        }
+        return binding;
+      }
+    }
+    if (!done) {
+      done = true;
+      await closeIterator(iterator);
+    }
+    return { ok: true };
+  } catch (error) {
+    if (!done && !isFatalSandboxError(error)) await closeIterator(iterator, true);
+    throw error;
+  } finally {
+    release();
+  }
+}
+async function bindObjectPattern(pattern, value, target, scope, context) {
+  if (typeof value !== "object" || value === null) {
+    throw new TypeError("Object destructuring declarations require a non-null object value.");
+  }
+  const excludedKeys = /* @__PURE__ */ new Set();
+  for (const property of pattern.properties) {
+    if (property.type === "RestElement") {
+      const binding2 = await bindPattern(
+        property,
+        await copyObjectRestValue(value, excludedKeys, context),
+        target,
+        scope,
+        context
+      );
+      if (!binding2.ok) {
+        return binding2;
+      }
+      continue;
+    }
+    const key = await evaluatePatternKey(property, context);
+    if (!key.ok) {
+      return key;
+    }
+    excludedKeys.add(typeof key.value === "symbol" ? key.value : String(key.value));
+    const binding = await bindPattern(
+      property.value,
+      await context.getProperty(value, key.value),
+      target,
+      scope,
+      context
+    );
+    if (!binding.ok) {
+      return binding;
+    }
+  }
+  return { ok: true };
+}
+async function bindMemberExpression(pattern, value, scope, context) {
+  const object = await context.evaluate(pattern.object);
+  if (object.kind !== "normal") {
+    return { ok: false, result: object };
+  }
+  const property = pattern.computed ? await context.evaluate(pattern.property) : { kind: "normal", value: getStaticPropertyName(pattern.property) };
+  if (property.kind !== "normal") {
+    return { ok: false, result: property };
+  }
+  if (object.value === null || object.value === void 0) {
+    throw new TypeError("Cannot assign properties of null or undefined.");
+  }
+  if (!isIndexableValue(object.value)) {
+    throw new TypeError("Assignment expressions require a sandbox object property.");
+  }
+  await context.setProperty(object.value, await context.toPropertyKey(property.value), value);
+  return { ok: true };
+}
+async function evaluatePatternKey(property, context) {
+  return property.computed ? evaluateProperty(property.key, context) : { ok: true, value: getStaticPropertyName(property.key) };
+}
+async function evaluateProperty(property, context) {
+  const result = await context.evaluate(property);
+  if (result.kind !== "normal") {
+    return { ok: false, result };
+  }
+  return { ok: true, value: await context.toPropertyKey(result.value) };
+}
+function getStaticPropertyName(property) {
+  if (property.type === "Identifier") {
+    return property.name;
+  }
+  if (property.type === "StringLiteral" || property.type === "NumericLiteral") {
+    return property.value;
+  }
+  throw new TypeError(`Unsupported static property node '${property.type}'.`);
+}
+async function copyObjectRestValue(value, excludedKeys, context) {
+  const rest = /* @__PURE__ */ Object.create(null);
+  const release = context.budget === void 0 ? () => void 0 : retainValues(context.budget, () => [value, rest]);
+  try {
+    for (const key of ownEnumerableSandboxKeys(value, true)) {
+      if (excludedKeys.has(key) || !hasOwnSandboxProperty(value, key, true)) continue;
+      defineProperty(rest, key, await context.getProperty(value, key));
+    }
+    return rest;
+  } finally {
+    release();
+  }
+}
+function isIndexableValue(value) {
+  return typeof value === "object" && value !== null;
+}
+function defineProperty(target, key, value) {
+  Object.defineProperty(target, key, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true
+  });
+}
+
+// packages/safe-js/src/interp/var-hoist.ts
+function hoistVarDeclarations(node, scope) {
+  for (const declaration of hoistedVarDeclarations([node])) {
+    for (const declarator of declaration.declarations) {
+      for (const identifier of boundIdentifiers(declarator.id)) {
+        scope.declareVar(identifier.name);
+      }
+    }
+  }
+}
+
+// packages/safe-js/src/interp/data-checkpoint.ts
+function createDataCheckpoint(budget, context) {
+  let estimatedDataSize = 0;
+  return (value, growth = 0, force = false) => {
+    const limit = budget.limits.dataSize;
+    if (limit === void 0) return;
+    estimatedDataSize = Math.max(estimatedDataSize, budget.currentDataSize) + growth;
+    if (!force && estimatedDataSize <= limit) return;
+    if (context?.reconcileData !== void 0) context.reconcileData(value);
+    else reconcileCompiledValues(budget, [value], context?.compilation);
+    estimatedDataSize = budget.currentDataSize;
+  };
+}
+
+// packages/safe-js/src/interp/globals/numeric-parsers.ts
+function createNumericParsers(budget) {
+  return {
+    parseInt: createSandboxClosure({
+      sandbox: true,
+      name: "parseInt",
+      call: ([value, radix], context) => {
+        const parse2 = (text2) => {
+          const release = retainValues(budget, () => [text2]);
+          let convertedRadix;
+          try {
+            convertedRadix = sandboxNumber(radix, budget, context);
+          } catch (error) {
+            release();
+            throw error;
+          }
+          if (typeof convertedRadix === "number") {
+            try {
+              return globalThis.parseInt(text2, convertedRadix);
+            } finally {
+              release();
+            }
+          }
+          return convertedRadix.then((number) => globalThis.parseInt(text2, number)).finally(release);
+        };
+        const text = sandboxString(value, budget, context);
+        return typeof text === "string" ? parse2(text) : text.then(parse2);
       }
     }),
     parseFloat: createSandboxClosure({
@@ -15492,6 +15495,7 @@ function createPatternContext(context, scope = context.scope, evaluate = evaluat
   const evaluationContext = { ...context, scope };
   return {
     budget: context.budget,
+    callContext: createCoercionContext(evaluationContext),
     evaluate: (node, inferredName) => evaluate(node, { ...evaluationContext, inferredName }),
     toPropertyKey: (value) => toPropertyKey(value, context.budget, createCoercionContext(evaluationContext)),
     getProperty: (value, key) => getPropertyValue(value, key, evaluationContext),
@@ -18641,7 +18645,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 +18731,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 +18748,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";
@@ -25161,584 +25179,239 @@ var AS010Scanner = class {
         return true;
       }
     }
-    return false;
-  }
-  resolveCandidate(name) {
-    for (let index = this.scopes.length - 1; index >= 0; index -= 1) {
-      const entry = this.scopes[index]?.get(name);
-      if (entry === void 0) {
-        continue;
-      }
-      return typeof entry === "object" && entry.kind === "candidate" ? entry : void 0;
-    }
-    return void 0;
-  }
-  collectModuleBindings(body) {
-    const scope = /* @__PURE__ */ new Map();
-    for (const statement of body) {
-      if (statement.type === "ImportDeclaration") {
-        this.mergeScope(scope, this.collectImportBindings(statement));
-        continue;
-      }
-      if (statement.type === "VariableDeclaration") {
-        this.mergeScope(scope, this.collectDeclarationBindings(statement));
-        continue;
-      }
-      if (statement.type === "ExportNamedDeclaration") {
-        this.mergeScope(scope, this.collectDeclarationBindings(statement.declaration));
-      }
-    }
-    return scope;
-  }
-  collectCandidates(body, scope) {
-    for (const statement of body) {
-      if (statement.type !== "VariableDeclaration" || statement.kind !== "let") {
-        continue;
-      }
-      for (const declarator of statement.declarations) {
-        if (declarator.id.type !== "Identifier") {
-          continue;
-        }
-        const hostCall = this.findHostCall(declarator.init);
-        if (hostCall === void 0 || !this.isHostCall(hostCall)) {
-          continue;
-        }
-        const candidate = {
-          kind: "candidate",
-          name: declarator.id.name,
-          reads: 0,
-          reassignments: 0,
-          span: declarator.id.span
-        };
-        this.candidates.push(candidate);
-        scope.set(candidate.name, candidate);
-      }
-    }
-  }
-  collectBlockBindings(body) {
-    const scope = /* @__PURE__ */ new Map();
-    for (const statement of body) {
-      if (statement.type === "VariableDeclaration") {
-        this.mergeScope(scope, this.collectDeclarationBindings(statement));
-      }
-    }
-    return scope;
-  }
-  collectParameterBindings(node) {
-    const scope = /* @__PURE__ */ new Map();
-    for (const parameter of node.params) {
-      this.collectBindingNamesFromElement(parameter, scope);
-    }
-    return scope;
-  }
-  collectDeclarationBindings(node) {
-    const scope = /* @__PURE__ */ new Map();
-    for (const declarator of node.declarations) {
-      this.collectBindingNamesFromPattern(declarator.id, scope);
-    }
-    return scope;
-  }
-  collectCatchBindings(node) {
-    const scope = /* @__PURE__ */ new Map();
-    if (node.param !== void 0) {
-      this.collectBindingNamesFromPattern(node.param, scope);
-    }
-    return scope;
-  }
-  collectImportBindings(node) {
-    const scope = /* @__PURE__ */ new Map();
-    for (const specifier of node.specifiers) {
-      scope.set(specifier.local.name, this.getImportBindingKind(specifier));
-    }
-    return scope;
-  }
-  getImportBindingKind(specifier) {
-    return specifier.type === "ImportNamespaceSpecifier" ? "namespace" : "import";
-  }
-  collectBindingNamesFromElement(node, scope) {
-    switch (node.type) {
-      case "AssignmentPattern":
-        this.collectBindingNamesFromPattern(node.left, scope);
-        return;
-      case "RestElement":
-        this.collectBindingNamesFromPattern(node.argument, scope);
-        return;
-      default:
-        this.collectBindingNamesFromPattern(node, scope);
-        return;
-    }
-  }
-  collectBindingNamesFromPattern(node, scope) {
-    switch (node.type) {
-      case "Identifier":
-        scope.set(node.name, "local");
-        return;
-      case "MemberExpression":
-        return;
-      case "ArrayPattern":
-        for (const element of node.elements) {
-          if (element !== null) {
-            this.collectBindingNamesFromElement(element, scope);
-          }
-        }
-        return;
-      case "ObjectPattern":
-        for (const property of node.properties) {
-          if (property.type === "RestElement") {
-            this.collectBindingNamesFromPattern(property.argument, scope);
-            continue;
-          }
-          this.collectBindingNamesFromElement(property.value, scope);
-        }
-        return;
-    }
-  }
-  collectPatternBindingNames(node) {
-    const names = [];
-    this.collectBindingNames(node, names);
-    return names;
-  }
-  collectBindingNames(node, names) {
-    switch (node.type) {
-      case "AssignmentPattern":
-        this.collectBindingNames(node.left, names);
-        return;
-      case "RestElement":
-        this.collectBindingNames(node.argument, names);
-        return;
-      case "Identifier":
-        names.push(node.name);
-        return;
-      case "MemberExpression":
-        return;
-      case "ArrayPattern":
-        for (const element of node.elements) {
-          if (element !== null) {
-            this.collectBindingNames(element, names);
-          }
-        }
-        return;
-      case "ObjectPattern":
-        for (const property of node.properties) {
-          this.collectBindingNames(
-            property.type === "RestElement" ? property.argument : property.value,
-            names
-          );
-        }
-        return;
-    }
-  }
-  resolveCandidates(names) {
-    return names.flatMap((name) => {
-      const candidate = this.resolveCandidate(name);
-      return candidate === void 0 ? [] : [candidate];
-    });
-  }
-  withIgnoredReads(candidates, visit) {
-    if (candidates.length === 0) {
-      visit();
-      return;
-    }
-    this.ignoredReads.push(new Set(candidates));
-    try {
-      visit();
-    } finally {
-      this.ignoredReads.pop();
-    }
-  }
-  withScope(scope, visit) {
-    this.scopes.push(scope);
-    try {
-      visit();
-    } finally {
-      this.scopes.pop();
-    }
-  }
-  mergeScope(target, source) {
-    for (const [name, binding] of source) {
-      target.set(name, binding);
-    }
-  }
-  findHostCall(node) {
-    if (node === void 0) {
-      return void 0;
-    }
-    if (node.type === "CallExpression") {
-      return node;
-    }
-    if (node.type === "AwaitExpression" && node.argument.type === "CallExpression") {
-      return node.argument;
-    }
-    return void 0;
-  }
-  isHostCall(node) {
-    const root = this.findRootIdentifier(node.callee);
-    if (root === void 0) {
-      return false;
-    }
-    for (let index = this.scopes.length - 1; index >= 0; index -= 1) {
-      const binding = this.scopes[index]?.get(root.name);
-      if (binding === void 0) {
-        continue;
-      }
-      return binding === "import" || binding === "namespace";
-    }
-    return false;
-  }
-  findRootIdentifier(node) {
-    switch (node.type) {
-      case "Identifier":
-        return node;
-      case "MemberExpression":
-        return this.findRootIdentifier(node.object);
-      default:
-        return void 0;
-    }
-  }
-};
-
-// 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 false;
+  }
+  resolveCandidate(name) {
+    for (let index = this.scopes.length - 1; index >= 0; index -= 1) {
+      const entry = this.scopes[index]?.get(name);
+      if (entry === void 0) {
+        continue;
       }
-      return;
+      return typeof entry === "object" && entry.kind === "candidate" ? entry : void 0;
     }
-    this.visitExpression(node.body);
+    return void 0;
   }
-  visitArrayExpression(node) {
-    for (const element of node.elements) {
-      if (element === null) {
+  collectModuleBindings(body) {
+    const scope = /* @__PURE__ */ new Map();
+    for (const statement of body) {
+      if (statement.type === "ImportDeclaration") {
+        this.mergeScope(scope, this.collectImportBindings(statement));
         continue;
       }
-      if (element.type === "SpreadElement") {
-        this.visitExpression(element.argument);
+      if (statement.type === "VariableDeclaration") {
+        this.mergeScope(scope, this.collectDeclarationBindings(statement));
         continue;
       }
-      this.visitExpression(element);
+      if (statement.type === "ExportNamedDeclaration") {
+        this.mergeScope(scope, this.collectDeclarationBindings(statement.declaration));
+      }
     }
+    return scope;
   }
-  visitObjectExpression(node) {
-    for (const property of node.properties) {
-      if (property.type === "SpreadElement") {
-        this.visitExpression(property.argument);
+  collectCandidates(body, scope) {
+    for (const statement of body) {
+      if (statement.type !== "VariableDeclaration" || statement.kind !== "let") {
         continue;
       }
-      this.visitProperty(property);
+      for (const declarator of statement.declarations) {
+        if (declarator.id.type !== "Identifier") {
+          continue;
+        }
+        const hostCall = this.findHostCall(declarator.init);
+        if (hostCall === void 0 || !this.isHostCall(hostCall)) {
+          continue;
+        }
+        const candidate = {
+          kind: "candidate",
+          name: declarator.id.name,
+          reads: 0,
+          reassignments: 0,
+          span: declarator.id.span
+        };
+        this.candidates.push(candidate);
+        scope.set(candidate.name, candidate);
+      }
     }
   }
-  visitProperty(node) {
-    if (node.computed) {
-      this.visitExpression(node.key);
+  collectBlockBindings(body) {
+    const scope = /* @__PURE__ */ new Map();
+    for (const statement of body) {
+      if (statement.type === "VariableDeclaration") {
+        this.mergeScope(scope, this.collectDeclarationBindings(statement));
+      }
     }
-    this.visitExpression(node.value);
-  }
-  visitUnaryExpression(node) {
-    this.visitExpression(node.argument);
-  }
-  visitBinaryLikeExpression(node) {
-    this.visitExpression(node.left);
-    this.visitExpression(node.right);
+    return scope;
   }
-  visitConditionalExpression(node) {
-    this.visitExpression(node.test);
-    this.visitExpression(node.consequent);
-    this.visitExpression(node.alternate);
+  collectParameterBindings(node) {
+    const scope = /* @__PURE__ */ new Map();
+    for (const parameter of node.params) {
+      this.collectBindingNamesFromElement(parameter, scope);
+    }
+    return scope;
   }
-  visitMemberExpression(node) {
-    this.visitExpression(node.object);
-    if (this.isForbiddenMemberProperty(node)) {
-      this.report(node.property.span);
+  collectDeclarationBindings(node) {
+    const scope = /* @__PURE__ */ new Map();
+    for (const declarator of node.declarations) {
+      this.collectBindingNamesFromPattern(declarator.id, scope);
     }
-    this.visitExpression(node.property);
+    return scope;
   }
-  visitAssignmentExpression(node) {
-    this.visitAssignmentTarget(node.left);
-    this.visitExpression(node.right);
+  collectCatchBindings(node) {
+    const scope = /* @__PURE__ */ new Map();
+    if (node.param !== void 0) {
+      this.collectBindingNamesFromPattern(node.param, scope);
+    }
+    return scope;
   }
-  visitCallExpression(node) {
-    this.visitExpression(node.callee);
-    for (const argument of node.arguments) {
-      if (argument.type === "SpreadElement") {
-        this.visitExpression(argument.argument);
-        continue;
-      }
-      this.visitExpression(argument);
+  collectImportBindings(node) {
+    const scope = /* @__PURE__ */ new Map();
+    for (const specifier of node.specifiers) {
+      scope.set(specifier.local.name, this.getImportBindingKind(specifier));
     }
+    return scope;
   }
-  visitTemplateLiteral(node) {
-    for (const expression of node.expressions) {
-      this.visitExpression(expression);
+  getImportBindingKind(specifier) {
+    return specifier.type === "ImportNamespaceSpecifier" ? "namespace" : "import";
+  }
+  collectBindingNamesFromElement(node, scope) {
+    switch (node.type) {
+      case "AssignmentPattern":
+        this.collectBindingNamesFromPattern(node.left, scope);
+        return;
+      case "RestElement":
+        this.collectBindingNamesFromPattern(node.argument, scope);
+        return;
+      default:
+        this.collectBindingNamesFromPattern(node, scope);
+        return;
     }
   }
-  visitAssignmentTarget(node) {
+  collectBindingNamesFromPattern(node, scope) {
     switch (node.type) {
       case "Identifier":
-      case "MetaProperty":
+        scope.set(node.name, "local");
         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);
+            this.collectBindingNamesFromElement(element, scope);
           }
         }
         return;
       case "ObjectPattern":
         for (const property of node.properties) {
           if (property.type === "RestElement") {
-            this.visitAssignmentTarget(property.argument);
+            this.collectBindingNamesFromPattern(property.argument, scope);
             continue;
           }
-          if (property.computed) {
-            this.visitExpression(property.key);
-          }
-          this.visitAssignmentTarget(property.value);
+          this.collectBindingNamesFromElement(property.value, scope);
         }
         return;
     }
   }
-  visitBindingTarget(node) {
+  collectPatternBindingNames(node) {
+    const names = [];
+    this.collectBindingNames(node, names);
+    return names;
+  }
+  collectBindingNames(node, names) {
     switch (node.type) {
       case "AssignmentPattern":
-        this.visitBindingTarget(node.left);
-        this.visitExpression(node.right);
+        this.collectBindingNames(node.left, names);
         return;
       case "RestElement":
-        this.visitBindingTarget(node.argument);
+        this.collectBindingNames(node.argument, names);
         return;
-      default:
-        this.visitAssignmentTarget(node);
+      case "Identifier":
+        names.push(node.name);
+        return;
+      case "MemberExpression":
+        return;
+      case "ArrayPattern":
+        for (const element of node.elements) {
+          if (element !== null) {
+            this.collectBindingNames(element, names);
+          }
+        }
+        return;
+      case "ObjectPattern":
+        for (const property of node.properties) {
+          this.collectBindingNames(
+            property.type === "RestElement" ? property.argument : property.value,
+            names
+          );
+        }
         return;
     }
   }
-  isForbiddenMemberProperty(node) {
-    if (!node.computed) {
-      return node.property.type === "Identifier" && FORBIDDEN_PROPERTY_NAMES.has(node.property.name);
+  resolveCandidates(names) {
+    return names.flatMap((name) => {
+      const candidate = this.resolveCandidate(name);
+      return candidate === void 0 ? [] : [candidate];
+    });
+  }
+  withIgnoredReads(candidates, visit) {
+    if (candidates.length === 0) {
+      visit();
+      return;
+    }
+    this.ignoredReads.push(new Set(candidates));
+    try {
+      visit();
+    } finally {
+      this.ignoredReads.pop();
+    }
+  }
+  withScope(scope, visit) {
+    this.scopes.push(scope);
+    try {
+      visit();
+    } finally {
+      this.scopes.pop();
     }
-    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
-    });
+  mergeScope(target, source) {
+    for (const [name, binding] of source) {
+      target.set(name, binding);
+    }
+  }
+  findHostCall(node) {
+    if (node === void 0) {
+      return void 0;
+    }
+    if (node.type === "CallExpression") {
+      return node;
+    }
+    if (node.type === "AwaitExpression" && node.argument.type === "CallExpression") {
+      return node.argument;
+    }
+    return void 0;
+  }
+  isHostCall(node) {
+    const root = this.findRootIdentifier(node.callee);
+    if (root === void 0) {
+      return false;
+    }
+    for (let index = this.scopes.length - 1; index >= 0; index -= 1) {
+      const binding = this.scopes[index]?.get(root.name);
+      if (binding === void 0) {
+        continue;
+      }
+      return binding === "import" || binding === "namespace";
+    }
+    return false;
+  }
+  findRootIdentifier(node) {
+    switch (node.type) {
+      case "Identifier":
+        return node;
+      case "MemberExpression":
+        return this.findRootIdentifier(node.object);
+      default:
+        return void 0;
+    }
   }
 };
 
@@ -26714,7 +26387,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 +26791,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 +31407,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 +31717,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 +32723,6 @@ var RULES = [
   AS_MISSING_ASYNC,
   AS009,
   AS010,
-  AS011,
   AS013,
   AS015,
   AS_IMPORT_CYCLE,
@@ -36214,4 +35886,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-AR5OJ6OJ.js.map
+//# sourceMappingURL=chunk-AW3IBVVD.js.map