@cloudflare/vitest-pool-workers 0.12.19 → 0.12.21

package/dist/pool/index.mjs

@@ -1241,20 +1241,24 @@ function nanoid(size = 21) {
   return id;
 }
 
-// ../../node_modules/.pnpm/devalue@5.3.2/node_modules/devalue/index.js
+// ../../node_modules/.pnpm/devalue@5.6.3/node_modules/devalue/index.js
 init_define_VITEST_POOL_WORKERS_DEFINE_BUILTIN_MODULES();
 
-// ../../node_modules/.pnpm/devalue@5.3.2/node_modules/devalue/src/utils.js
+// ../../node_modules/.pnpm/devalue@5.6.3/node_modules/devalue/src/utils.js
 init_define_VITEST_POOL_WORKERS_DEFINE_BUILTIN_MODULES();
 var DevalueError = class extends Error {
   /**
    * @param {string} message
    * @param {string[]} keys
+   * @param {any} [value] - The value that failed to be serialized
+   * @param {any} [root] - The root value being serialized
    */
-  constructor(message, keys) {
+  constructor(message, keys, value, root) {
     super(message);
     this.name = "DevalueError";
     this.path = keys.join("");
+    this.value = value;
+    this.root = root;
   }
 };
 function is_primitive(thing) {
@@ -1319,11 +1323,33 @@ var is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
 function stringify_key(key) {
   return is_identifier.test(key) ? "." + key : "[" + JSON.stringify(key) + "]";
 }
+function is_valid_array_index(s) {
+  if (s.length === 0) return false;
+  if (s.length > 1 && s.charCodeAt(0) === 48) return false;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 48 || c > 57) return false;
+  }
+  const n = +s;
+  if (n >= 2 ** 32 - 1) return false;
+  if (n < 0) return false;
+  return true;
+}
+function valid_array_indices(array) {
+  const keys = Object.keys(array);
+  for (var i = keys.length - 1; i >= 0; i--) {
+    if (is_valid_array_index(keys[i])) {
+      break;
+    }
+  }
+  keys.length = i + 1;
+  return keys;
+}
 
-// ../../node_modules/.pnpm/devalue@5.3.2/node_modules/devalue/src/parse.js
+// ../../node_modules/.pnpm/devalue@5.6.3/node_modules/devalue/src/parse.js
 init_define_VITEST_POOL_WORKERS_DEFINE_BUILTIN_MODULES();
 
-// ../../node_modules/.pnpm/devalue@5.3.2/node_modules/devalue/src/base64.js
+// ../../node_modules/.pnpm/devalue@5.6.3/node_modules/devalue/src/base64.js
 init_define_VITEST_POOL_WORKERS_DEFINE_BUILTIN_MODULES();
 function encode64(arraybuffer) {
   const dv = new DataView(arraybuffer);
@@ -1396,7 +1422,7 @@ function binaryToAscii(str) {
   return out;
 }
 
-// ../../node_modules/.pnpm/devalue@5.3.2/node_modules/devalue/src/constants.js
+// ../../node_modules/.pnpm/devalue@5.6.3/node_modules/devalue/src/constants.js
 init_define_VITEST_POOL_WORKERS_DEFINE_BUILTIN_MODULES();
 var UNDEFINED = -1;
 var HOLE = -2;
@@ -1404,8 +1430,9 @@ var NAN = -3;
 var POSITIVE_INFINITY = -4;
 var NEGATIVE_INFINITY = -5;
 var NEGATIVE_ZERO = -6;
+var SPARSE = -7;
 
-// ../../node_modules/.pnpm/devalue@5.3.2/node_modules/devalue/src/parse.js
+// ../../node_modules/.pnpm/devalue@5.6.3/node_modules/devalue/src/parse.js
 function parse(serialized, revivers) {
   return unflatten(JSON.parse(serialized), revivers);
 }
@@ -1419,6 +1446,7 @@ function unflatten(parsed, revivers) {
     parsed
   );
   const hydrated = Array(values.length);
+  let hydrating = null;
   function hydrate(index, standalone = false) {
     if (index === UNDEFINED) return void 0;
     if (index === NAN) return NaN;
@@ -1435,9 +1463,20 @@ function unflatten(parsed, revivers) {
     } else if (Array.isArray(value)) {
       if (typeof value[0] === "string") {
         const type = value[0];
-        const reviver = revivers?.[type];
+        const reviver = revivers && Object.hasOwn(revivers, type) ? revivers[type] : void 0;
         if (reviver) {
-          return hydrated[index] = reviver(hydrate(value[1]));
+          let i = value[1];
+          if (typeof i !== "number") {
+            i = values.push(value[1]) - 1;
+          }
+          hydrating ??= /* @__PURE__ */ new Set();
+          if (hydrating.has(i)) {
+            throw new Error("Invalid circular reference");
+          }
+          hydrating.add(i);
+          hydrated[index] = reviver(hydrate(i));
+          hydrating.delete(i);
+          return hydrated[index];
         }
         switch (type) {
           case "Date":
@@ -1484,13 +1523,20 @@ function unflatten(parsed, revivers) {
           case "Float64Array":
           case "BigInt64Array":
           case "BigUint64Array": {
+            if (values[value[1]][0] !== "ArrayBuffer") {
+              throw new Error("Invalid data");
+            }
             const TypedArrayConstructor = globalThis[type];
-            const typedArray = new TypedArrayConstructor(hydrate(value[1]));
+            const buffer = hydrate(value[1]);
+            const typedArray = new TypedArrayConstructor(buffer);
             hydrated[index] = value[2] !== void 0 ? typedArray.subarray(value[2], value[3]) : typedArray;
             break;
           }
           case "ArrayBuffer": {
             const base64 = value[1];
+            if (typeof base64 !== "string") {
+              throw new Error("Invalid ArrayBuffer encoding");
+            }
             const arraybuffer = decode64(base64);
             hydrated[index] = arraybuffer;
             break;
@@ -1520,6 +1566,14 @@ function unflatten(parsed, revivers) {
           default:
             throw new Error(`Unknown type ${type}`);
         }
+      } else if (value[0] === SPARSE) {
+        const len = value[1];
+        const array = new Array(len);
+        hydrated[index] = array;
+        for (let i = 2; i < value.length; i += 2) {
+          const idx = value[i];
+          array[idx] = hydrate(value[i + 1]);
+        }
       } else {
         const array = new Array(value.length);
         hydrated[index] = array;
@@ -1532,7 +1586,7 @@ function unflatten(parsed, revivers) {
     } else {
       const object = {};
       hydrated[index] = object;
-      for (const key in value) {
+      for (const key of Object.keys(value)) {
         if (key === "__proto__") {
           throw new Error("Cannot parse an object with a `__proto__` property");
         }
@@ -1545,7 +1599,7 @@ function unflatten(parsed, revivers) {
   return hydrate(0);
 }
 
-// ../../node_modules/.pnpm/devalue@5.3.2/node_modules/devalue/src/stringify.js
+// ../../node_modules/.pnpm/devalue@5.6.3/node_modules/devalue/src/stringify.js
 init_define_VITEST_POOL_WORKERS_DEFINE_BUILTIN_MODULES();
 function stringify(value, reducers) {
   const stringified = [];
@@ -1559,9 +1613,6 @@ function stringify(value, reducers) {
   const keys = [];
   let p = 0;
   function flatten(thing) {
-    if (typeof thing === "function") {
-      throw new DevalueError(`Cannot stringify a function`, keys);
-    }
     if (thing === void 0) return UNDEFINED;
     if (Number.isNaN(thing)) return NAN;
     if (thing === Infinity) return POSITIVE_INFINITY;
@@ -1577,6 +1628,9 @@ function stringify(value, reducers) {
         return index2;
       }
     }
+    if (typeof thing === "function") {
+      throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+    }
     let str = "";
     if (is_primitive(thing)) {
       str = stringify_primitive(thing);
@@ -1605,20 +1659,44 @@ function stringify(value, reducers) {
           const { source, flags } = thing;
           str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
           break;
-        case "Array":
+        case "Array": {
+          let mostly_dense = false;
           str = "[";
           for (let i = 0; i < thing.length; i += 1) {
             if (i > 0) str += ",";
-            if (i in thing) {
+            if (Object.hasOwn(thing, i)) {
               keys.push(`[${i}]`);
               str += flatten(thing[i]);
               keys.pop();
-            } else {
+            } else if (mostly_dense) {
               str += HOLE;
+            } else {
+              const populated_keys = valid_array_indices(
+                /** @type {any[]} */
+                thing
+              );
+              const population = populated_keys.length;
+              const d = String(thing.length).length;
+              const hole_cost = (thing.length - population) * 3;
+              const sparse_cost = 4 + d + population * (d + 1);
+              if (hole_cost > sparse_cost) {
+                str = "[" + SPARSE + "," + thing.length;
+                for (let j = 0; j < populated_keys.length; j++) {
+                  const key = populated_keys[j];
+                  keys.push(`[${key}]`);
+                  str += "," + key + "," + flatten(thing[key]);
+                  keys.pop();
+                }
+                break;
+              } else {
+                mostly_dense = true;
+                str += HOLE;
+              }
             }
           }
           str += "]";
           break;
+        }
         case "Set":
           str = '["Set"';
           for (const value2 of thing) {
@@ -1679,18 +1757,30 @@ function stringify(value, reducers) {
           if (!is_plain_object(thing)) {
             throw new DevalueError(
               `Cannot stringify arbitrary non-POJOs`,
-              keys
+              keys,
+              thing,
+              value
             );
           }
           if (enumerable_symbols(thing).length > 0) {
             throw new DevalueError(
               `Cannot stringify POJOs with symbolic keys`,
-              keys
+              keys,
+              thing,
+              value
             );
           }
           if (Object.getPrototypeOf(thing) === null) {
             str = '["null"';
-            for (const key in thing) {
+            for (const key of Object.keys(thing)) {
+              if (key === "__proto__") {
+                throw new DevalueError(
+                  `Cannot stringify objects with __proto__ keys`,
+                  keys,
+                  thing,
+                  value
+                );
+              }
               keys.push(stringify_key(key));
               str += `,${stringify_string(key)},${flatten(thing[key])}`;
               keys.pop();
@@ -1699,7 +1789,15 @@ function stringify(value, reducers) {
           } else {
             str = "{";
             let started = false;
-            for (const key in thing) {
+            for (const key of Object.keys(thing)) {
+              if (key === "__proto__") {
+                throw new DevalueError(
+                  `Cannot stringify objects with __proto__ keys`,
+                  keys,
+                  thing,
+                  value
+                );
+              }
               if (started) str += ",";
               started = true;
               keys.push(stringify_key(key));