@poe-platform/safe-js 0.1.307 → 0.1.309

package/dist/safe-js/chunks/{chunk-V6LQP64H.js → chunk-A5S5VD23.js}

@@ -6835,13 +6835,20 @@ function float32Storage(value) {
     byteLength: Reflect.apply(bufferLength, buffer, [])
   };
 }
+function float32Properties(value) {
+  const properties = [];
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key === "string" && isFloat32Index(key)) continue;
+    properties.push([key, Object.getOwnPropertyDescriptor(value, key)]);
+  }
+  return properties;
+}
 function float32DataProperties(value) {
   if (Object.getOwnPropertySymbols(value).length > 0)
     throw new TypeError("Float32Array symbol properties are not supported.");
   const properties = [];
-  for (const key of Object.getOwnPropertyNames(value)) {
-    if (isFloat32Index(key)) continue;
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  for (const [key, descriptor] of float32Properties(value)) {
+    if (typeof key !== "string") throw new TypeError("Float32Array symbol properties are not supported.");
     if (!("value" in descriptor))
       throw new TypeError(`Float32Array accessor property '${key}' is not supported.`);
     properties.push([key, descriptor]);
@@ -7865,6 +7872,9 @@ function namedKeys(state) {
 // packages/safe-js/src/interp/error-prototypes.ts
 var errorPrototypes = /* @__PURE__ */ new WeakMap();
 
+// packages/safe-js/src/interp/float32-prototypes.ts
+var float32Prototypes = /* @__PURE__ */ new WeakMap();
+
 // packages/safe-js/src/interp/object-model.ts
 var guestClosures = /* @__PURE__ */ new WeakSet();
 var functionProperties = /* @__PURE__ */ new WeakMap();
@@ -8090,11 +8100,13 @@ function releaseObjectPrototype(budget) {
   functionPrototypes.delete(budget);
   generatorPrototypes.delete(budget);
   errorPrototypes.delete(budget);
+  float32Prototypes.delete(budget);
   initialRegexDescriptors.delete(budget);
   intrinsicPrototypes.delete(budget);
 }
 function getSandboxPrototype(value, budget) {
   if (prototypes.has(value)) return prototypes.get(value) ?? null;
+  if (isFloat32Array(value)) return budget === void 0 ? null : float32Prototypes.get(budget) ?? null;
   const errorType = sandboxErrorTypes.get(value);
   if (budget !== void 0 && errorType !== void 0) {
     const prototype = errorPrototypes.get(budget)?.get(errorType);
@@ -8127,6 +8139,8 @@ function getSandboxPropertyDescriptor(value, key, budget) {
   let current = value;
   let depth = 0;
   while (typeof current === "object" && current !== null && (Array.isArray(current) || isSandboxGenerator(current) || isSandboxDate(current) || isSandboxPromise(current) || isSandboxRegex(current) || isSandboxMap(current) || isSandboxSet(current) || isPrototypeRecord(current))) {
+    if (isFloat32Array(current) && typeof key !== "symbol" && isFloat32Index(String(key)))
+      return Object.getOwnPropertyDescriptor(current, key);
     const properties = isSandboxGenerator(current) ? getGeneratorProperties(current) : isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? key === "prototype" && current.construct !== void 0 && current.boundTarget === void 0 ? materializeFunctionProperties(current) : getGuestFunctionProperties(current) : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
     if (properties === void 0 && isGuestClosure(current) && (key === "name" || key === "length"))
       return {
@@ -8149,6 +8163,8 @@ function getSandboxDataProperty(value, key, budget) {
   let current = value;
   let depth = 0;
   while (typeof current === "object" && current !== null) {
+    if (isFloat32Array(current) && typeof key !== "symbol" && isFloat32Index(String(key)))
+      return Object.getOwnPropertyDescriptor(current, key)?.value;
     if (isGuestHostObject(current)) return typeof key === "symbol" ? void 0 : getHostObjectMember(current, String(key));
     if (isSandboxRegex(current)) return Object.getOwnPropertyDescriptor(getRegexProperties(current), key)?.value;
     if (isSandboxPromise(current)) return Object.getOwnPropertyDescriptor(getPromiseProperties(current), key)?.value;
@@ -8200,6 +8216,7 @@ function setSandboxPrototype(value, prototype, budget) {
   prototypes.set(value, prototype);
 }
 function isPrototypeRecord(value) {
+  if (isFloat32Array(value)) return true;
   if (isGuestClosure(value)) return true;
   if (isGuestHostObject(value)) return false;
   if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxMap(value) || isSandboxPromise(value) || isSandboxRegex(value) || isSandboxSet(value))
@@ -8219,7 +8236,7 @@ function hasGuestObjectState(value) {
   if (isLiveCapability(value)) return true;
   if (functionProperties.has(value) || prototypes.has(value) && !hasNullObjectPrototype(value)) return true;
   if (isSandboxBox(value) || isSandboxDate(value)) return false;
-  return descriptorObjects.has(value) && Object.values(Object.getOwnPropertyDescriptors(value)).some(
+  return descriptorObjects.has(value) && (isFloat32Array(value) ? float32Properties(value).map(([, descriptor]) => descriptor) : Object.values(Object.getOwnPropertyDescriptors(value))).some(
     (descriptor) => !descriptor.enumerable || !descriptor.configurable || !descriptor.writable
   );
 }
@@ -9535,7 +9552,7 @@ async function readIteratorResult(iterator, result, property) {
 }
 function getSandboxAsyncIterator(value, budget, context, signal) {
   if (isSandboxGenerator(value) && value.async) {
-    return hasExplicitSandboxPrototype(value) ? context?.getProperty === void 0 ? generatorProtocolAdapter(value, budget, context, true, signal) : void 0 : { ...generatorObjectIterator(value, budget, context), asyncProtocol: true };
+    return hasExplicitSandboxPrototype(value) ? context?.getProperty === void 0 ? guestProtocolAdapter(value, budget, context, true, signal) : void 0 : { ...generatorObjectIterator(value, budget, context), asyncProtocol: true };
   }
   if (value !== null && (typeof value === "object" || typeof value === "function") && !isGuestHostObject(value)) {
     const method = value[Symbol.asyncIterator];
@@ -9682,11 +9699,15 @@ function getSandboxIterator(value, budget, context) {
   }
   if (isGuestHostObject(value)) return getHostObjectIterator(value);
   if (isFloat32Array(value)) {
+    if (hasExplicitSandboxPrototype(value) || budget !== void 0 && float32Prototypes.has(budget)) {
+      if (getSandboxPropertyDescriptor(value, Symbol.iterator, budget) === void 0) return void 0;
+      return guestProtocolAdapter(value, budget ?? new Budget(), context, false);
+    }
     return syncIterator(Float32Array.prototype.values.call(value));
   }
   if (isSandboxGenerator(value)) {
     if (value.async) return void 0;
-    if (hasExplicitSandboxPrototype(value)) return context?.getProperty === void 0 ? generatorProtocolAdapter(value, budget ?? new Budget(), context, false) : void 0;
+    if (hasExplicitSandboxPrototype(value)) return context?.getProperty === void 0 ? guestProtocolAdapter(value, budget ?? new Budget(), context, false) : void 0;
     return generatorObjectIterator(value, budget, context);
   }
   if (typeof value === "string") {
@@ -9764,7 +9785,7 @@ function collectionIterator(collection, value) {
   return adapter;
 }
 var asyncGeneratorRequests = /* @__PURE__ */ new WeakMap();
-function generatorProtocolAdapter(value, budget, context, asyncProtocol, signal) {
+function guestProtocolAdapter(value, budget, context, asyncProtocol, signal) {
   const bridge = {
     ...context,
     stack: context?.stack ?? [],
@@ -9778,7 +9799,7 @@ function generatorProtocolAdapter(value, budget, context, asyncProtocol, signal)
   let resolved;
   let pending;
   const initialize = () => pending ??= acquireSandboxIterator(value, budget, bridge, asyncProtocol, signal).then((iterator) => {
-    if (iterator === void 0) throw new TypeError("Generator does not provide an iterator protocol.");
+    if (iterator === void 0) throw new TypeError("Value does not provide an iterator protocol.");
     return resolved = iterator;
   });
   return {
@@ -13649,8 +13670,8 @@ async function definePropertiesFromObject(target, descriptors2, budget, context)
 }
 function defineDataProperty(target, key, descriptor, budget) {
   budget.visitNode();
-  if (isFloat32Array(target))
-    throw new TypeError("Typed array property descriptors are not supported.");
+  if (isFloat32Array(target) && typeof key !== "symbol" && isFloat32Index(String(key)) && "value" in descriptor)
+    descriptor = { ...descriptor, value: float32Number(descriptor.value) };
   const properties = objectProperties(target, true);
   if (Array.isArray(properties)) {
     if (key === "length" && "value" in descriptor)
@@ -14485,8 +14506,9 @@ async function callSetMethod(target, methodName, args, options, stack = []) {
 
 // packages/safe-js/src/interp/globals/float32array.ts
 var constructors = /* @__PURE__ */ new WeakSet();
-function createFloat32ArrayGlobal(budget) {
+function createFloat32ArrayGlobal(budget, nativePrototype = false) {
   const constructor = createSandboxClosure({
+    guest: nativePrototype,
     sandbox: true,
     name: "Float32Array",
     length: 3,
@@ -14494,32 +14516,184 @@ function createFloat32ArrayGlobal(budget) {
     call: () => {
       throw new TypeError("Constructor Float32Array requires 'new'.");
     },
-    construct: ([source]) => {
-      if (Array.isArray(source) || isFloat32Array(source)) {
-        const length2 = isFloat32Array(source) ? float32Storage(source).length : source.length;
-        checkFloat32Allocation(length2, budget);
-        if (isFloat32Array(source)) return new Float32Array(source);
-        const result = new Float32Array(length2);
-        for (let index = 0; index < length2; index += 1) {
-          budget.visitNode();
-          const descriptor = Object.getOwnPropertyDescriptor(source, index);
-          if (descriptor !== void 0 && !("value" in descriptor))
-            throw new TypeError("Float32Array input accessors are not supported.");
-          result[index] = float32Number(descriptor?.value);
+    construct: (args, context) => {
+      if (!nativePrototype) return allocateFloat32Array(args[0], budget);
+      return (async () => {
+        const newTarget = context?.newTarget ?? constructor;
+        const candidate = context?.getProperty === void 0 ? getSandboxDataProperty(newTarget, "prototype", budget) : await context.getProperty(newTarget, "prototype");
+        const prototype = candidate !== null && typeof candidate === "object" ? candidate : float32Prototypes.get(budget);
+        const release = retainValues(budget, () => [prototype, ...args]);
+        try {
+          const result = allocateFloat32Array(args[0], budget);
+          setSandboxPrototype(result, prototype, budget);
+          return result;
+        } finally {
+          release();
         }
-        return result;
-      }
-      const number = float32Number(source);
-      const length = Number.isNaN(number) ? 0 : Math.trunc(number);
-      if (length < 0 || !Number.isSafeInteger(length))
-        throw new RangeError("Invalid typed array length.");
-      checkFloat32Allocation(length, budget);
-      return new Float32Array(length);
+      })();
     }
   });
   constructors.add(constructor);
   return constructor;
 }
+function allocateFloat32Array(source, budget) {
+  if (Array.isArray(source) || isFloat32Array(source)) {
+    const length2 = isFloat32Array(source) ? float32Storage(source).length : source.length;
+    checkFloat32Allocation(length2, budget);
+    if (isFloat32Array(source)) return new Float32Array(source);
+    const result = new Float32Array(length2);
+    for (let index = 0; index < length2; index += 1) {
+      budget.visitNode();
+      const descriptor = Object.getOwnPropertyDescriptor(source, index);
+      if (descriptor !== void 0 && !("value" in descriptor))
+        throw new TypeError("Float32Array input accessors are not supported.");
+      result[index] = float32Number(descriptor?.value);
+    }
+    return result;
+  }
+  const number = float32Number(source);
+  const length = Number.isNaN(number) ? 0 : Math.trunc(number);
+  if (length < 0 || !Number.isSafeInteger(length))
+    throw new RangeError("Invalid typed array length.");
+  checkFloat32Allocation(length, budget);
+  return new Float32Array(length);
+}
+function createFloat32ArrayPrototypes(budget, constructor) {
+  const prototype = /* @__PURE__ */ Object.create(null);
+  const shared = /* @__PURE__ */ Object.create(null);
+  const abstractCall = () => {
+    throw new TypeError("Abstract TypedArray constructor cannot be called.");
+  };
+  const typedArray = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "TypedArray",
+    length: 0,
+    call: abstractCall,
+    construct: abstractCall
+  });
+  Object.defineProperty(materializeFunctionProperties(typedArray), "prototype", { value: shared, writable: false });
+  Object.defineProperty(materializeFunctionProperties(typedArray), "of", {
+    writable: true,
+    configurable: true,
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "of",
+      length: 0,
+      call: async (args, context) => {
+        const target = context?.thisValue;
+        if (!isSandboxClosure(target) || target.construct === void 0)
+          throw new TypeError("TypedArray.of requires a constructor receiver.");
+        let result;
+        const release = retainValues(budget, () => [target, result, ...args]);
+        try {
+          result = await invokeBuiltinClosure(target, [args.length], budget, context, void 0, true);
+          if (!isFloat32Array(result) || float32Storage(result).length < args.length)
+            throw new TypeError("TypedArray.of constructor must return sufficient typed storage.");
+          for (let index = 0; index < args.length; index++) {
+            budget.visitNode();
+            result[index] = await sandboxNumber(args[index], budget, context);
+          }
+          return result;
+        } finally {
+          release();
+        }
+      }
+    })
+  });
+  Object.defineProperties(materializeFunctionProperties(constructor), {
+    prototype: { value: prototype, writable: false },
+    BYTES_PER_ELEMENT: { value: 4, writable: false, enumerable: false, configurable: false }
+  });
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    BYTES_PER_ELEMENT: { value: 4 }
+  });
+  Object.defineProperty(shared, "constructor", { value: typedArray, writable: true, configurable: true });
+  setSandboxPrototype(constructor, typedArray);
+  setSandboxPrototype(prototype, shared);
+  setSandboxPrototype(shared, getSandboxPrototype(/* @__PURE__ */ Object.create(null), budget));
+  const getters = [];
+  for (const key of ["length", "byteLength", "byteOffset"]) {
+    const getter = createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: `get ${key}`,
+      length: 0,
+      call: (_args, context) => {
+        if (!isFloat32Array(context?.thisValue)) throw new TypeError(`TypedArray ${key} requires a typed array receiver.`);
+        const storage = float32Storage(context.thisValue);
+        return key === "byteLength" ? storage.length * 4 : storage[key];
+      }
+    });
+    getters.push(getter);
+    Object.defineProperty(shared, key, { get: accessorAdapter(getter, "get"), configurable: true });
+  }
+  for (const key of ["set", "slice", "subarray"])
+    Object.defineProperty(shared, key, { value: getFloat32Member(new Float32Array(0), key, budget), writable: true, configurable: true });
+  const arrayPrototype = resolveIntrinsicIdentity(budget, '["Array","prototype"]');
+  Object.defineProperty(shared, "toString", { value: getSandboxDataProperty(arrayPrototype, "toString", budget), writable: true, configurable: true });
+  Object.defineProperty(shared, "join", {
+    writable: true,
+    configurable: true,
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "join",
+      length: 1,
+      call: async (args, context) => {
+        if (!isFloat32Array(context?.thisValue)) throw new TypeError("TypedArray join requires a typed array receiver.");
+        const receiver = context.thisValue;
+        const length = float32Storage(receiver).length;
+        let separator = ",";
+        let text = "";
+        const release = retainValues(budget, () => [receiver, separator, text, ...args]);
+        try {
+          if (args[0] !== void 0) separator = await sandboxString(args[0], budget, context);
+          for (let index = 0; index < length; index++) {
+            budget.visitNode();
+            text = budget.allocateString(text + (index === 0 ? "" : separator) + String(receiver[index]));
+          }
+          return text;
+        } finally {
+          release();
+        }
+      }
+    })
+  });
+  const tagGetter = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "get [Symbol.toStringTag]",
+    length: 0,
+    call: (_args, context) => isFloat32Array(context?.thisValue) ? "Float32Array" : void 0
+  });
+  getters.push(tagGetter);
+  Object.defineProperty(shared, Symbol.toStringTag, { get: accessorAdapter(tagGetter, "get"), configurable: true });
+  for (const key of ["values", "keys", "entries"]) {
+    const method = getSandboxDataProperty(arrayPrototype, key, budget);
+    const closure = createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: key,
+      length: 0,
+      call: (args, context) => {
+        if (!isFloat32Array(context?.thisValue)) throw new TypeError(`TypedArray ${key} requires a typed array receiver.`);
+        return invokeBuiltinClosure(method, args, budget, context, context.thisValue);
+      }
+    });
+    Object.defineProperty(shared, key, { value: closure, writable: true, configurable: true });
+    if (key === "values") Object.defineProperty(shared, Symbol.iterator, { value: closure, writable: true, configurable: true });
+  }
+  float32Prototypes.set(budget, prototype);
+  registerBuiltinIdentities(budget, { Float32Array: constructor, "%TypedArray%": typedArray });
+  registerIntrinsicFunction(budget, constructor);
+  registerIntrinsicFunction(budget, typedArray);
+  registerIntrinsicObject(budget, prototype);
+  registerIntrinsicObject(budget, shared);
+  for (const getter of getters) registerIntrinsicFunction(budget, getter);
+}
 function isFloat32ArrayConstructor(value) {
   return typeof value === "object" && value !== null && constructors.has(value);
 }
@@ -14530,6 +14704,7 @@ function getFloat32Member(value, property, budget) {
     if (!("value" in descriptor)) throw new TypeError("Float32Array accessors are not supported.");
     return descriptor.value;
   }
+  if (float32Prototypes.has(budget)) return void 0;
   const storage = float32Storage(value);
   if (key === "length") return storage.length;
   if (key === "byteLength") return storage.length * 4;
@@ -14537,6 +14712,7 @@ function getFloat32Member(value, property, budget) {
   if (key === "BYTES_PER_ELEMENT") return 4;
   if (!["set", "slice", "subarray"].includes(key)) return void 0;
   return createSandboxClosure({
+    guest: true,
     sandbox: true,
     name: key,
     length: key === "set" ? 1 : 2,
@@ -14584,17 +14760,18 @@ function getFloat32Member(value, property, budget) {
     }
   });
 }
-function setFloat32Member(value, property, entry) {
-  const key = String(property);
-  if (isFloat32Index(key)) {
+function setFloat32Member(value, property, entry, budget) {
+  const key = typeof property === "symbol" ? property : String(property);
+  if (typeof key !== "symbol" && isFloat32Index(key)) {
     Reflect.set(value, key, float32Number(entry));
     return;
   }
   const descriptor = Object.getOwnPropertyDescriptor(value, key);
-  if (descriptor === void 0 && ["length", "byteLength", "byteOffset", "buffer", "BYTES_PER_ELEMENT"].includes(key))
-    throw new TypeError(`Cannot assign to read only property '${key}'.`);
-  if (descriptor !== void 0 && (!("value" in descriptor) || !descriptor.writable))
-    throw new TypeError(`Cannot assign to read only property '${key}'.`);
+  const inherited = descriptor ?? (budget === void 0 ? void 0 : getSandboxPropertyDescriptor(value, key, budget));
+  if (descriptor === void 0 && typeof key === "string" && (budget === void 0 || !float32Prototypes.has(budget)) && ["length", "byteLength", "byteOffset", "buffer", "BYTES_PER_ELEMENT"].includes(key))
+    throw new TypeError(`Cannot assign to read only property '${String(key)}'.`);
+  if (inherited !== void 0 && (!("value" in inherited) || !inherited.writable))
+    throw new TypeError(`Cannot assign to read only property '${String(key)}'.`);
   Object.defineProperty(
     value,
     key,
@@ -14766,7 +14943,7 @@ async function ordinaryHasInstance(value, constructor, budget, context) {
     budget.visitNode();
     return evaluateInstanceof(value, constructor.boundTarget, budget, context);
   }
-  if (isFloat32ArrayConstructor(constructor)) return isFloat32Array(value);
+  if (isFloat32ArrayConstructor(constructor) && !isGuestClosure(constructor)) return isFloat32Array(value);
   if ((!isGuestClosure(constructor) || value !== null && typeof value === "object" && !hasExplicitSandboxPrototype(value)) && isSandboxErrorConstructorInstance2(value, constructor)) return true;
   if (!isGuestClosure(constructor) || typeof value !== "object" || value === null) return false;
   const prototype = await readInstanceProperty(constructor, "prototype", budget, context);
@@ -17406,7 +17583,7 @@ async function evaluateMemberCallExpression(node, context) {
     if (isFloat32Array(member.object)) {
       return evaluateResolvedCallExpression(
         node,
-        getFloat32Member(member.object, member.property, context.budget),
+        await getPropertyValue(member.object, member.property, context),
         context,
         member.object
       );
@@ -17943,8 +18120,7 @@ function setSandboxProperty(target, property, value, budget, checkInherited = tr
   if (isSandboxGenerator(target)) target = getGeneratorProperties(target);
   if (isSandboxMap(target) || isSandboxSet(target)) target = getCollectionProperties(target);
   if (isFloat32Array(target)) {
-    if (typeof property === "symbol") throw new TypeError("Typed array symbol properties are not yet supported.");
-    setFloat32Member(target, property, value);
+    setFloat32Member(target, property, value, budget);
     return;
   }
   if (isSandboxRegex(target)) {
@@ -24518,7 +24694,7 @@ function createBuiltinBindings(options) {
   const bindings = {
     ...createConsoleJsonGlobals(options),
     ...createCollectionGlobals(options),
-    Float32Array: createFloat32ArrayGlobal(options.budget),
+    Float32Array: createFloat32ArrayGlobal(options.budget, options.float32Prototypes !== false),
     Date: createDateGlobal(options),
     Symbol: createSymbolGlobal(options.budget),
     BigInt: createBigIntGlobal(options.budget),
@@ -24531,6 +24707,7 @@ function createBuiltinBindings(options) {
     ...createRegexGlobals(options)
   };
   createFunctionPrototype(options.budget, options.functionHasInstance);
+  if (options.float32Prototypes !== false) createFloat32ArrayPrototypes(options.budget, bindings.Float32Array);
   if (options.errorPrototypes !== false) createErrorPrototypes(options.budget, bindings);
   createGeneratorPrototypes(options.budget);
   registerBuiltinIdentities(options.budget, bindings);
@@ -25263,6 +25440,10 @@ function validateDumpHeap(root, state) {
     if (entry.kind === "float32array") {
       validateFloat32Storage(entry);
       requireRecord(entry.entries, `${path}.entries`);
+      if (Object.hasOwn(entry, "state")) {
+        if (Object.keys(entry.entries).length !== 0) fail("invalidValue", path, "ambiguous Float32Array property state");
+        validateGuestHeapNode({ kind: "guest-object", state: entry.state }, heap, state.limits.maxEntries);
+      }
       continue;
     }
     if (entry.kind === "arguments") {
@@ -25491,6 +25672,10 @@ function validateHeapValue(value, path, state, heap) {
   if (record4.kind === "float32array") {
     validateFloat32Storage(record4);
     requireRecord(record4.entries, `${path}.entries`);
+    if (Object.hasOwn(record4, "state")) {
+      if (Object.keys(record4.entries).length !== 0) fail("invalidValue", path, "ambiguous Float32Array property state");
+      validateGuestHeapNode({ kind: "guest-object", state: record4.state }, heap, state.limits.maxEntries);
+    }
   }
   if (record4.kind === "map") {
     const entries = requireArray(record4.entries, `${path}.entries`, state);
@@ -26485,9 +26670,12 @@ function measureSandboxData(values, options = {}) {
         seen.add(storage.buffer);
         usage += storage.byteLength;
       }
-      for (const [key, descriptor] of float32DataProperties(value)) {
-        usage += key.length + 1;
-        visit(descriptor.value, depth + 1);
+      for (const [key, descriptor] of float32Properties(value)) {
+        usage += 1;
+        if (typeof key === "string") usage += key.length;
+        else visit(key, depth + 1);
+        if ("value" in descriptor) visit(descriptor.value, depth + 1);
+        else for (const closure of retainedAccessorClosures(descriptor)) visit(closure, depth + 1);
       }
       return;
     }
@@ -41448,4 +41636,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-V6LQP64H.js.map
+//# sourceMappingURL=chunk-A5S5VD23.js.map