@aopslabs/aops-server 0.2.7 → 0.2.9

package/build/server/chunks/{index.js-Lbn6Vjdj.js → index.js-B0n9KWWU.js}

@@ -227,14 +227,17 @@ function is_valid_array_index_string(s) {
   }
   return is_valid_array_index(+s);
 }
-function valid_array_indices(array) {
-  const keys = Object.keys(array);
+function array_index_cut(keys) {
   for (var i = keys.length - 1; i >= 0; i--) {
     if (is_valid_array_index_string(keys[i])) {
       break;
     }
   }
-  keys.length = i + 1;
+  return i + 1;
+}
+function valid_array_indices(array) {
+  const keys = Object.keys(array);
+  keys.length = array_index_cut(keys);
   return keys;
 }
 const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$";
@@ -285,6 +288,7 @@ function uneval(value, replacer) {
         case "Map":
           for (const [key, value2] of thing) {
             keys.push(`.get(${is_primitive(key) ? stringify_primitive$1(key) : "..."})`);
+            walk(key);
             walk(value2);
             keys.pop();
           }
@@ -392,7 +396,6 @@ function uneval(value, replacer) {
               return `Object.assign(Array(${thing.length}),{${entries}})`;
             }
             has_holes = true;
-            i -= 1;
           }
         }
         const tail = thing.length === 0 || thing.length - 1 in thing ? "" : ",";
@@ -415,8 +418,7 @@ function uneval(value, replacer) {
       case "BigUint64Array": {
         let str2 = `new ${type}`;
         if (!names.has(thing.buffer)) {
-          const array = new thing.constructor(thing.buffer);
-          str2 += `([${array}])`;
+          str2 += `([${stringify_typed_array_elements(new thing.constructor(thing.buffer))}])`;
         } else {
           str2 += `(${stringify(thing.buffer)})`;
         }
@@ -435,7 +437,7 @@ function uneval(value, replacer) {
           str2 += `(${stringify(thing.buffer)}`;
         }
         if (thing.byteLength !== thing.buffer.byteLength) {
-          str2 += `,${thing.startOffset},${thing.byteLength}`;
+          str2 += `,${thing.byteOffset},${thing.byteLength}`;
         }
         return str2 + ")";
       }
@@ -467,6 +469,7 @@ function uneval(value, replacer) {
     const params = [];
     const statements = [];
     const values = [];
+    const reconstructions = [];
     names.forEach((name, thing) => {
       params.push(name);
       if (custom.has(thing)) {
@@ -508,18 +511,20 @@ function uneval(value, replacer) {
             statements.push(`${name}[${i}]=${stringify(v)}`);
           });
           break;
-        case "Set":
+        case "Set": {
           values.push(`new Set`);
-          statements.push(
-            `${name}.${Array.from(thing).map((v) => `add(${stringify(v)})`).join(".")}`
-          );
+          const adds = Array.from(thing).map((v) => `.add(${stringify(v)})`);
+          if (adds.length > 0) statements.push(name + adds.join(""));
           break;
-        case "Map":
+        }
+        case "Map": {
           values.push(`new Map`);
-          statements.push(
-            `${name}.${Array.from(thing).map(([k, v]) => `set(${stringify(k)}, ${stringify(v)})`).join(".")}`
+          const sets = Array.from(thing).map(
+            ([k, v]) => `.set(${stringify(k)}, ${stringify(v)})`
           );
+          if (sets.length > 0) statements.push(name + sets.join(""));
           break;
+        }
         case "Int8Array":
         case "Uint8Array":
         case "Uint8ClampedArray":
@@ -534,8 +539,7 @@ function uneval(value, replacer) {
         case "BigUint64Array": {
           let str2 = `new ${type}`;
           if (!names.has(thing.buffer)) {
-            const array = new thing.constructor(thing.buffer);
-            str2 += `([${array}])`;
+            str2 += `([${stringify_typed_array_elements(new thing.constructor(thing.buffer))}])`;
           } else {
             str2 += `(${stringify(thing.buffer)})`;
           }
@@ -545,7 +549,7 @@ function uneval(value, replacer) {
             str2 += `.subarray(${start},${end})`;
           }
           values.push(`{}`);
-          statements.push(`${name}=${str2}`);
+          reconstructions.push(`${name}=${str2}`);
           break;
         }
         case "DataView": {
@@ -560,12 +564,22 @@ function uneval(value, replacer) {
           }
           str2 += ")";
           values.push(`{}`);
-          statements.push(`${name}=${str2}`);
+          reconstructions.push(`${name}=${str2}`);
           break;
         }
         case "ArrayBuffer":
           values.push(`new Uint8Array([${new Uint8Array(thing)}]).buffer`);
           break;
+        case "Temporal.Duration":
+        case "Temporal.Instant":
+        case "Temporal.PlainDate":
+        case "Temporal.PlainTime":
+        case "Temporal.PlainDateTime":
+        case "Temporal.PlainMonthDay":
+        case "Temporal.PlainYearMonth":
+        case "Temporal.ZonedDateTime":
+          values.push(`${type}.from(${stringify_string(thing.toString())})`);
+          break;
         default:
           values.push(Object.getPrototypeOf(thing) === null ? "Object.create(null)" : "{}");
           Object.keys(thing).forEach((key) => {
@@ -574,11 +588,18 @@ function uneval(value, replacer) {
       }
     });
     statements.push(`return ${str}`);
-    return `(function(${params.join(",")}){${statements.join(";")}}(${values.join(",")}))`;
+    const body = [...reconstructions, ...statements].join(";");
+    return `(function(${params.join(",")}){${body}}(${values.join(",")}))`;
   } else {
     return str;
   }
 }
+function stringify_typed_array_elements(array) {
+  if (array instanceof BigInt64Array || array instanceof BigUint64Array) {
+    return Array.from(array, (element) => `${element}n`).join(",");
+  }
+  return array.toString();
+}
 function get_name(num) {
   let name = "";
   do {
@@ -829,10 +850,92 @@ const native = typeof Uint8Array.fromBase64 === "function";
 const buffer = typeof process === "object" && process.versions?.node !== void 0;
 const encode64 = native ? encode_native : buffer ? encode_buffer : encode_legacy;
 const decode64 = native ? decode_native : buffer ? decode_buffer : decode_legacy;
-function parse(serialized, revivers) {
+function merge_operations(defaults, overrides) {
+  return defaults;
+}
+const NOT_PLAIN = Object.freeze({ kind: "not-plain" });
+const SYMBOL_KEYS = Object.freeze({ kind: "symbol-keys" });
+const stringify_operations = {
+  identify: (value) => value,
+  typeOf: (value) => value === null ? "null" : typeof value,
+  toPrimitive: (value) => value,
+  tagOf: (value) => get_type(value),
+  isThenable: (value) => typeof value.then === "function",
+  toPromise: (thenable) => Promise.resolve(thenable),
+  unbox: (boxed) => boxed.valueOf(),
+  toISOString: (date) => isNaN(date.getDate()) ? "" : date.toISOString(),
+  toStringValue: (value) => value.toString(),
+  regExpInfo: (regexp) => ({ source: regexp.source, flags: regexp.flags }),
+  valuesOf: (set) => set,
+  entriesOf: (map) => map,
+  viewInfo: (view) => ({
+    buffer: view.buffer,
+    byteOffset: view.byteOffset,
+    byteLength: view.byteLength,
+    length: view.length,
+    bufferByteLength: view.buffer.byteLength
+  }),
+  toArrayBuffer: (buffer2) => buffer2,
+  lengthOf: (array) => array.length,
+  hasOwn: (value, key) => Object.hasOwn(value, key),
+  indicesOf: (array) => valid_array_indices(array),
+  shapeOf: (value) => {
+    if (!is_plain_object(value)) return NOT_PLAIN;
+    if (enumerable_symbols(value).length > 0) return SYMBOL_KEYS;
+    return {
+      kind: Object.getPrototypeOf(value) === null ? "null-proto" : "plain",
+      keys: Object.keys(value)
+    };
+  },
+  get: (value, key) => value[key]
+};
+const default_stringify_operations = Object.freeze(stringify_operations);
+const parse_operations = {
+  fromPrimitive: (primitive) => primitive,
+  fromISOString: (iso) => new Date(iso),
+  fromStringValue: (tag, text2) => {
+    if (tag === "URL") return new URL(text2);
+    if (tag === "URLSearchParams") return new URLSearchParams(text2);
+    return Temporal[tag.slice(9)].from(text2);
+  },
+  fromArrayBuffer: (buffer2) => buffer2,
+  fromRegExpInfo: (source, flags) => new RegExp(source, flags),
+  fromViewInfo: (tag, buffer2, byteOffset, length) => {
+    const Constructor = (
+      /** @type {any} */
+      globalThis[tag]
+    );
+    return byteOffset !== void 0 ? new Constructor(buffer2, byteOffset, length) : new Constructor(buffer2);
+  },
+  box: (value) => Object(value),
+  createArray: (length) => new Array(length),
+  createSparseArray: (length) => {
+    const array = [];
+    array[MAX_ARRAY_INDEX] = void 0;
+    delete array[MAX_ARRAY_INDEX];
+    array.length = length;
+    return array;
+  },
+  createObject: () => ({}),
+  createNullPrototypeObject: () => /* @__PURE__ */ Object.create(null),
+  createSet: () => /* @__PURE__ */ new Set(),
+  createMap: () => /* @__PURE__ */ new Map(),
+  set: (target, key, value) => {
+    target[key] = value;
+  },
+  addValue: (set, value) => {
+    set.add(value);
+  },
+  addEntry: (map, key, value) => {
+    map.set(key, value);
+  }
+};
+const default_parse_operations = Object.freeze(parse_operations);
+function parse(serialized, revivers, options) {
   return unflatten(JSON.parse(serialized), revivers);
 }
-function unflatten(parsed, revivers) {
+function unflatten(parsed, revivers, options) {
+  const ops = merge_operations(default_parse_operations);
   if (typeof parsed === "number") return hydrate(parsed, true);
   if (!Array.isArray(parsed) || parsed.length === 0) {
     throw new Error("Invalid input");
@@ -844,18 +947,18 @@ function unflatten(parsed, revivers) {
   const hydrated = Array(values.length);
   let hydrating = null;
   function hydrate(index, standalone = false) {
-    if (index === UNDEFINED) return void 0;
-    if (index === NAN) return NaN;
-    if (index === POSITIVE_INFINITY) return Infinity;
-    if (index === NEGATIVE_INFINITY) return -Infinity;
-    if (index === NEGATIVE_ZERO) return -0;
+    if (index === UNDEFINED) return ops.fromPrimitive(void 0);
+    if (index === NAN) return ops.fromPrimitive(NaN);
+    if (index === POSITIVE_INFINITY) return ops.fromPrimitive(Infinity);
+    if (index === NEGATIVE_INFINITY) return ops.fromPrimitive(-Infinity);
+    if (index === NEGATIVE_ZERO) return ops.fromPrimitive(-0);
     if (standalone || typeof index !== "number") {
       throw new Error(`Invalid input`);
     }
     if (index in hydrated) return hydrated[index];
     const value = values[index];
     if (!value || typeof value !== "object") {
-      hydrated[index] = value;
+      hydrated[index] = ops.fromPrimitive(value);
     } else if (Array.isArray(value)) {
       if (typeof value[0] === "string") {
         const type = value[0];
@@ -865,6 +968,9 @@ function unflatten(parsed, revivers) {
           if (typeof i !== "number") {
             i = values.push(value[1]) - 1;
           }
+          if (Object.hasOwn(hydrated, i)) {
+            return hydrated[index] = reviver(hydrated[i]);
+          }
           hydrating ??= /* @__PURE__ */ new Set();
           if (hydrating.has(i)) {
             throw new Error("Invalid circular reference");
@@ -876,44 +982,44 @@ function unflatten(parsed, revivers) {
         }
         switch (type) {
           case "Date":
-            hydrated[index] = new Date(value[1]);
+            hydrated[index] = ops.fromISOString(value[1]);
             break;
           case "Set":
-            const set = /* @__PURE__ */ new Set();
+            const set = ops.createSet();
             hydrated[index] = set;
             for (let i = 1; i < value.length; i += 1) {
-              set.add(hydrate(value[i]));
+              ops.addValue(set, hydrate(value[i]));
             }
             break;
           case "Map":
-            const map = /* @__PURE__ */ new Map();
+            const map = ops.createMap();
             hydrated[index] = map;
             for (let i = 1; i < value.length; i += 2) {
-              map.set(hydrate(value[i]), hydrate(value[i + 1]));
+              ops.addEntry(map, hydrate(value[i]), hydrate(value[i + 1]));
             }
             break;
           case "RegExp":
-            hydrated[index] = new RegExp(value[1], value[2]);
+            hydrated[index] = ops.fromRegExpInfo(value[1], value[2]);
             break;
           case "Object": {
             const wrapped_index = value[1];
             if (typeof values[wrapped_index] === "object" && values[wrapped_index][0] !== "BigInt") {
               throw new Error("Invalid input");
             }
-            hydrated[index] = Object(hydrate(wrapped_index));
+            hydrated[index] = ops.box(hydrate(wrapped_index));
             break;
           }
           case "BigInt":
-            hydrated[index] = BigInt(value[1]);
+            hydrated[index] = ops.fromPrimitive(BigInt(value[1]));
             break;
           case "null":
-            const obj = /* @__PURE__ */ Object.create(null);
+            const obj = ops.createNullPrototypeObject();
             hydrated[index] = obj;
             for (let i = 1; i < value.length; i += 2) {
               if (value[i] === "__proto__") {
                 throw new Error("Cannot parse an object with a `__proto__` property");
               }
-              obj[value[i]] = hydrate(value[i + 1]);
+              ops.set(obj, value[i], hydrate(value[i + 1]));
             }
             break;
           case "Int8Array":
@@ -932,9 +1038,8 @@ function unflatten(parsed, revivers) {
             if (values[value[1]][0] !== "ArrayBuffer") {
               throw new Error("Invalid data");
             }
-            const TypedArrayConstructor = globalThis[type];
             const buffer2 = hydrate(value[1]);
-            hydrated[index] = value[2] !== void 0 ? new TypedArrayConstructor(buffer2, value[2], value[3]) : new TypedArrayConstructor(buffer2);
+            hydrated[index] = ops.fromViewInfo(type, buffer2, value[2], value[3]);
             break;
           }
           case "ArrayBuffer": {
@@ -942,10 +1047,11 @@ function unflatten(parsed, revivers) {
             if (typeof base64 !== "string") {
               throw new Error("Invalid ArrayBuffer encoding");
             }
-            const arraybuffer = decode64(base64);
-            hydrated[index] = arraybuffer;
+            hydrated[index] = ops.fromArrayBuffer(decode64(base64));
             break;
           }
+          case "URL":
+          case "URLSearchParams":
           case "Temporal.Duration":
           case "Temporal.Instant":
           case "Temporal.PlainDate":
@@ -954,18 +1060,7 @@ function unflatten(parsed, revivers) {
           case "Temporal.PlainMonthDay":
           case "Temporal.PlainYearMonth":
           case "Temporal.ZonedDateTime": {
-            const temporalName = type.slice(9);
-            hydrated[index] = Temporal[temporalName].from(value[1]);
-            break;
-          }
-          case "URL": {
-            const url = new URL(value[1]);
-            hydrated[index] = url;
-            break;
-          }
-          case "URLSearchParams": {
-            const url = new URLSearchParams(value[1]);
-            hydrated[index] = url;
+            hydrated[index] = ops.fromStringValue(type, value[1]);
             break;
           }
           default:
@@ -976,47 +1071,44 @@ function unflatten(parsed, revivers) {
         if (!is_valid_array_len(len)) {
           throw new Error("Invalid input");
         }
-        const array = [];
+        const array = ops.createSparseArray(len);
         hydrated[index] = array;
-        array[MAX_ARRAY_INDEX] = void 0;
-        delete array[MAX_ARRAY_INDEX];
         for (let i = 2; i < value.length; i += 2) {
           const idx = value[i];
           if (!is_valid_array_index(idx) || idx >= len) {
             throw new Error("Invalid input");
           }
-          array[idx] = hydrate(value[i + 1]);
+          ops.set(array, idx, hydrate(value[i + 1]));
         }
-        array.length = len;
       } else {
-        const array = new Array(value.length);
+        const array = ops.createArray(value.length);
         hydrated[index] = array;
         for (let i = 0; i < value.length; i += 1) {
           const n = value[i];
           if (n === HOLE) continue;
-          array[i] = hydrate(n);
+          ops.set(array, i, hydrate(n));
         }
       }
     } else {
-      const object = {};
+      const object = ops.createObject();
       hydrated[index] = object;
       for (const key of Object.keys(value)) {
         if (key === "__proto__") {
           throw new Error("Cannot parse an object with a `__proto__` property");
         }
-        const n = value[key];
-        object[key] = hydrate(n);
+        ops.set(object, key, hydrate(value[key]));
       }
     }
     return hydrated[index];
   }
   return hydrate(0);
 }
-function stringify$1(value, reducers) {
+function stringify$1(value, reducers, options) {
   const stringified = run(false, value, reducers);
   return typeof stringified === "string" ? stringified : `[${stringified.join(",")}]`;
 }
-function run(async, value, reducers) {
+function run(async, value, reducers, options) {
+  const ops = merge_operations(default_stringify_operations);
   const stringified = [];
   const indexes = /* @__PURE__ */ new Map();
   const custom = [];
@@ -1028,17 +1120,24 @@ function run(async, value, reducers) {
   const keys = [];
   let p = 0;
   function flatten(thing, index2) {
-    if (thing === void 0) return UNDEFINED;
-    if (Number.isNaN(thing)) return NAN;
-    if (thing === Infinity) return POSITIVE_INFINITY;
-    if (thing === -Infinity) return NEGATIVE_INFINITY;
-    if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO;
-    if (indexes.has(thing)) return (
+    const type = ops.typeOf(thing);
+    if (type === "undefined") return UNDEFINED;
+    let number;
+    if (type === "number") {
+      number = /** @type {number} */
+      ops.toPrimitive(thing);
+      if (Number.isNaN(number)) return NAN;
+      if (number === Infinity) return POSITIVE_INFINITY;
+      if (number === -Infinity) return NEGATIVE_INFINITY;
+      if (number === 0 && 1 / number < 0) return NEGATIVE_ZERO;
+    }
+    const id = ops.identify(thing);
+    if (indexes.has(id)) return (
       /** @type {number} */
-      indexes.get(thing)
+      indexes.get(id)
     );
     index2 ??= p++;
-    indexes.set(thing, index2);
+    indexes.set(id, index2);
     for (const { key, fn } of custom) {
       const value2 = fn(thing);
       if (value2) {
@@ -1046,15 +1145,15 @@ function run(async, value, reducers) {
         return index2;
       }
     }
-    if (typeof thing === "function") {
+    if (type === "function") {
       throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
-    } else if (typeof thing === "symbol") {
+    } else if (type === "symbol") {
       throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
     }
     let str = "";
-    if (is_primitive(thing)) {
-      str = stringify_primitive(thing);
-    } else if (typeof thing.then === "function") {
+    if (type !== "object") {
+      str = stringify_primitive(type === "number" ? number : ops.toPrimitive(thing));
+    } else if (ops.isThenable(thing)) {
       {
         throw new DevalueError(
           `Cannot stringify a Promise or thenable — use stringifyAsync instead`,
@@ -1064,54 +1163,51 @@ function run(async, value, reducers) {
         );
       }
     } else {
-      const type = get_type(thing);
-      switch (type) {
+      const tag = ops.tagOf(thing);
+      switch (tag) {
         case "Number":
         case "String":
         case "Boolean":
         case "BigInt":
-          str = `["Object",${flatten(thing.valueOf())}]`;
+          str = `["Object",${flatten(ops.unbox(thing))}]`;
           break;
         case "Date":
-          const valid = !isNaN(thing.getDate());
-          str = `["Date","${valid ? thing.toISOString() : ""}"]`;
+          str = `["Date","${ops.toISOString(thing)}"]`;
           break;
         case "URL":
-          str = `["URL",${stringify_string(thing.toString())}]`;
+          str = `["URL",${stringify_string(ops.toStringValue(thing))}]`;
           break;
         case "URLSearchParams":
-          str = `["URLSearchParams",${stringify_string(thing.toString())}]`;
+          str = `["URLSearchParams",${stringify_string(ops.toStringValue(thing))}]`;
           break;
         case "RegExp":
-          const { source, flags } = thing;
+          const { source, flags } = ops.regExpInfo(thing);
           str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
           break;
         case "Array": {
           let mostly_dense = false;
+          const length = ops.lengthOf(thing);
           str = "[";
-          for (let i = 0; i < thing.length; i += 1) {
+          for (let i = 0; i < length; i += 1) {
             if (i > 0) str += ",";
-            if (Object.hasOwn(thing, i)) {
+            if (ops.hasOwn(thing, i)) {
               keys.push(`[${i}]`);
-              str += flatten(thing[i]);
+              str += flatten(ops.get(thing, i));
               keys.pop();
             } else if (mostly_dense) {
               str += HOLE;
             } else {
-              const populated_keys = valid_array_indices(
-                /** @type {any[]} */
-                thing
-              );
+              const populated_keys = ops.indicesOf(thing);
               const population = populated_keys.length;
-              const d = String(thing.length).length;
-              const hole_cost = (thing.length - population) * 3;
+              const d = String(length).length;
+              const hole_cost = (length - population) * 3;
               const sparse_cost = 4 + d + population * (d + 1);
               if (hole_cost > sparse_cost) {
-                str = "[" + SPARSE + "," + thing.length;
+                str = "[" + SPARSE + "," + length;
                 for (let j = 0; j < populated_keys.length; j++) {
                   const key = populated_keys[j];
                   keys.push(`[${key}]`);
-                  str += "," + key + "," + flatten(thing[key]);
+                  str += "," + key + "," + flatten(ops.get(thing, key));
                   keys.pop();
                 }
                 break;
@@ -1126,15 +1222,19 @@ function run(async, value, reducers) {
         }
         case "Set":
           str = '["Set"';
-          for (const value2 of thing) {
+          for (const value2 of ops.valuesOf(thing)) {
             str += `,${flatten(value2)}`;
           }
           str += "]";
           break;
         case "Map":
           str = '["Map"';
-          for (const [key, value2] of thing) {
-            keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
+          for (const [key, value2] of ops.entriesOf(thing)) {
+            const key_type = ops.typeOf(key);
+            const key_is_primitive = key_type !== "object" && key_type !== "function" && key_type !== "symbol";
+            keys.push(
+              `.get(${key_is_primitive ? stringify_primitive(ops.toPrimitive(key)) : "..."})`
+            );
             str += `,${flatten(key)},${flatten(value2)}`;
             keys.pop();
           }
@@ -1151,19 +1251,26 @@ function run(async, value, reducers) {
         case "Float32Array":
         case "Float64Array":
         case "BigInt64Array":
-        case "BigUint64Array":
+        case "BigUint64Array": {
+          const info = ops.viewInfo(thing);
+          str = '["' + tag + '",' + flatten(info.buffer);
+          if (info.byteLength !== info.bufferByteLength) {
+            str += `,${info.byteOffset},${info.length}`;
+          }
+          str += "]";
+          break;
+        }
         case "DataView": {
-          const typedArray = thing;
-          str = '["' + type + '",' + flatten(typedArray.buffer);
-          if (typedArray.byteLength !== typedArray.buffer.byteLength) {
-            str += `,${typedArray.byteOffset},${typedArray.length}`;
+          const info = ops.viewInfo(thing);
+          str = '["' + tag + '",' + flatten(info.buffer);
+          if (info.byteLength !== info.bufferByteLength) {
+            str += `,${info.byteOffset},${info.byteLength}`;
           }
           str += "]";
           break;
         }
         case "ArrayBuffer": {
-          const arraybuffer = thing;
-          const base64 = encode64(arraybuffer);
+          const base64 = encode64(ops.toArrayBuffer(thing));
           str = `["ArrayBuffer","${base64}"]`;
           break;
         }
@@ -1175,18 +1282,19 @@ function run(async, value, reducers) {
         case "Temporal.PlainMonthDay":
         case "Temporal.PlainYearMonth":
         case "Temporal.ZonedDateTime":
-          str = `["${type}",${stringify_string(thing.toString())}]`;
+          str = `["${tag}",${stringify_string(ops.toStringValue(thing))}]`;
           break;
-        default:
-          if (!is_plain_object(thing)) {
+        default: {
+          const shape = ops.shapeOf(thing);
+          if (shape.kind === "not-plain") {
             throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
           }
-          if (enumerable_symbols(thing).length > 0) {
+          if (shape.kind === "symbol-keys") {
             throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
           }
-          if (Object.getPrototypeOf(thing) === null) {
+          if (shape.kind === "null-proto") {
             str = '["null"';
-            for (const key of Object.keys(thing)) {
+            for (const key of shape.keys) {
               if (key === "__proto__") {
                 throw new DevalueError(
                   `Cannot stringify objects with __proto__ keys`,
@@ -1196,14 +1304,14 @@ function run(async, value, reducers) {
                 );
               }
               keys.push(stringify_key(key));
-              str += `,${stringify_string(key)},${flatten(thing[key])}`;
+              str += `,${stringify_string(key)},${flatten(ops.get(thing, key))}`;
               keys.pop();
             }
             str += "]";
           } else {
             str = "{";
             let started = false;
-            for (const key of Object.keys(thing)) {
+            for (const key of shape.keys) {
               if (key === "__proto__") {
                 throw new DevalueError(
                   `Cannot stringify objects with __proto__ keys`,
@@ -1215,11 +1323,12 @@ function run(async, value, reducers) {
               if (started) str += ",";
               started = true;
               keys.push(stringify_key(key));
-              str += `${stringify_string(key)}:${flatten(thing[key])}`;
+              str += `${stringify_string(key)}:${flatten(ops.get(thing, key))}`;
               keys.pop();
             }
             str += "}";
           }
+        }
       }
     }
     stringified[index2] = str;
@@ -6575,7 +6684,7 @@ const options = {
     app: ({ head, body, assets, nonce, env }) => '<!doctype html>\n<html lang="en">\n  <head>\n    <meta charset="utf-8" />\n    <link rel="icon" href="' + assets + '/favicon.png" />\n    <meta name="viewport" content="width=device-width, initial-scale=1" />\n    ' + head + '\n  </head>\n  <body data-sveltekit-preload-data="hover">\n    <div style="display: contents">' + body + "</div>\n  </body>\n</html>\n",
     error
   },
-  version_hash: "1qv7ip"
+  version_hash: "axz9qz"
 };
 async function get_hooks() {
   let handle;
@@ -6583,7 +6692,7 @@ async function get_hooks() {
   let handleError;
   let handleValidationError;
   let init;
-  ({ handle, handleFetch, handleError, handleValidationError, init } = await import('./hooks.server-7hLyaH14.js'));
+  ({ handle, handleFetch, handleError, handleValidationError, init } = await import('./hooks.server-QpuxZ7sx.js'));
   let reroute;
   let transport;
   return {