mongoku 2.8.1-compat → 2.9.0-compat

package/build/server/chunks/{shared-BqTYMAzZ.js → shared-DlqhoNLb.js}

@@ -1,88 +1,58 @@
-import { H as HttpError, j as json, t as text, S as SvelteKitError } from './index-wpIsICWW.js';
-import { w as with_request_store, D as DevalueError, l as is_primitive, m as get_type, n as is_plain_object, o as enumerable_symbols, p as stringify_key, q as stringify_string, v as valid_array_indices } from './url-hmE1zcJ6.js';
-import { t as text_decoder, b as base64_decode, a as base64_encode } from './utils2-kjxf7BZO.js';
+import { H as HttpError, j as json, t as text, S as SvelteKitError } from './index-NcxaM188.js';
+import { w as with_request_store, U as UNDEFINED, N as NAN, P as POSITIVE_INFINITY, l as NEGATIVE_INFINITY, m as NEGATIVE_ZERO, S as SPARSE, n as is_valid_array_len, M as MAX_ARRAY_INDEX, o as is_valid_array_index, H as HOLE, D as DevalueError, p as is_primitive, q as get_type, r as is_plain_object$1, t as enumerable_symbols, u as stringify_key, v as stringify_string, x as valid_array_indices, y as experimental_async_required, z as get_render_context, A as uneval, B as hydratable_serialization_failed } from './root-otUAnOAR.js';
+import { b as base64_decode, t as text_encoder, a as base64_encode } from './utils-BQzn9ikS.js';
+import { a as async_mode_flag } from './async-DUoD1OpG.js';
 
+function noop() {
+}
+function once(fn) {
+  let done = false;
+  let result;
+  return () => {
+    if (done) return result;
+    done = true;
+    return result = fn();
+  };
+}
 const SVELTE_KIT_ASSETS = "/_svelte_kit_assets";
 const ENDPOINT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
 const MUTATIVE_METHODS = ["POST", "PUT", "PATCH", "DELETE"];
 const PAGE_METHODS = ["GET", "POST", "HEAD"];
-function encode64(arraybuffer) {
-  const dv = new DataView(arraybuffer);
-  let binaryString = "";
-  for (let i = 0; i < arraybuffer.byteLength; i++) {
-    binaryString += String.fromCharCode(dv.getUint8(i));
-  }
-  return binaryToAscii(binaryString);
+function encode_native(array_buffer) {
+  return new Uint8Array(array_buffer).toBase64();
 }
-function decode64(string) {
-  const binaryString = asciiToBinary(string);
-  const arraybuffer = new ArrayBuffer(binaryString.length);
-  const dv = new DataView(arraybuffer);
-  for (let i = 0; i < arraybuffer.byteLength; i++) {
-    dv.setUint8(i, binaryString.charCodeAt(i));
-  }
-  return arraybuffer;
+function decode_native(base64) {
+  return Uint8Array.fromBase64(base64).buffer;
 }
-const KEY_STRING = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-function asciiToBinary(data) {
-  if (data.length % 4 === 0) {
-    data = data.replace(/==?$/, "");
-  }
-  let output = "";
-  let buffer = 0;
-  let accumulatedBits = 0;
-  for (let i = 0; i < data.length; i++) {
-    buffer <<= 6;
-    buffer |= KEY_STRING.indexOf(data[i]);
-    accumulatedBits += 6;
-    if (accumulatedBits === 24) {
-      output += String.fromCharCode((buffer & 16711680) >> 16);
-      output += String.fromCharCode((buffer & 65280) >> 8);
-      output += String.fromCharCode(buffer & 255);
-      buffer = accumulatedBits = 0;
-    }
-  }
-  if (accumulatedBits === 12) {
-    buffer >>= 4;
-    output += String.fromCharCode(buffer);
-  } else if (accumulatedBits === 18) {
-    buffer >>= 2;
-    output += String.fromCharCode((buffer & 65280) >> 8);
-    output += String.fromCharCode(buffer & 255);
+function encode_buffer(array_buffer) {
+  return Buffer.from(array_buffer).toString("base64");
+}
+function decode_buffer(base64) {
+  return Uint8Array.from(Buffer.from(base64, "base64")).buffer;
+}
+function encode_legacy(array_buffer) {
+  const array = new Uint8Array(array_buffer);
+  let binary = "";
+  const chunk_size = 32768;
+  for (let i = 0; i < array.length; i += chunk_size) {
+    const chunk = array.subarray(i, i + chunk_size);
+    binary += String.fromCharCode.apply(null, chunk);
   }
-  return output;
+  return btoa(binary);
 }
-function binaryToAscii(str) {
-  let out = "";
-  for (let i = 0; i < str.length; i += 3) {
-    const groupsOfSix = [void 0, void 0, void 0, void 0];
-    groupsOfSix[0] = str.charCodeAt(i) >> 2;
-    groupsOfSix[1] = (str.charCodeAt(i) & 3) << 4;
-    if (str.length > i + 1) {
-      groupsOfSix[1] |= str.charCodeAt(i + 1) >> 4;
-      groupsOfSix[2] = (str.charCodeAt(i + 1) & 15) << 2;
-    }
-    if (str.length > i + 2) {
-      groupsOfSix[2] |= str.charCodeAt(i + 2) >> 6;
-      groupsOfSix[3] = str.charCodeAt(i + 2) & 63;
-    }
-    for (let j = 0; j < groupsOfSix.length; j++) {
-      if (typeof groupsOfSix[j] === "undefined") {
-        out += "=";
-      } else {
-        out += KEY_STRING[groupsOfSix[j]];
-      }
-    }
+function decode_legacy(base64) {
+  const binary_string = atob(base64);
+  const len = binary_string.length;
+  const array = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    array[i] = binary_string.charCodeAt(i);
   }
-  return out;
+  return array.buffer;
 }
-const UNDEFINED = -1;
-const HOLE = -2;
-const NAN = -3;
-const POSITIVE_INFINITY = -4;
-const NEGATIVE_INFINITY = -5;
-const NEGATIVE_ZERO = -6;
-const SPARSE = -7;
+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) {
   return unflatten(JSON.parse(serialized), revivers);
 }
@@ -149,9 +119,14 @@ function unflatten(parsed, revivers) {
           case "RegExp":
             hydrated[index] = new RegExp(value[1], value[2]);
             break;
-          case "Object":
-            hydrated[index] = Object(value[1]);
+          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));
             break;
+          }
           case "BigInt":
             hydrated[index] = BigInt(value[1]);
             break;
@@ -159,6 +134,9 @@ function unflatten(parsed, revivers) {
             const obj = /* @__PURE__ */ Object.create(null);
             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]);
             }
             break;
@@ -167,19 +145,20 @@ function unflatten(parsed, revivers) {
           case "Uint8ClampedArray":
           case "Int16Array":
           case "Uint16Array":
+          case "Float16Array":
           case "Int32Array":
           case "Uint32Array":
           case "Float32Array":
           case "Float64Array":
           case "BigInt64Array":
-          case "BigUint64Array": {
+          case "BigUint64Array":
+          case "DataView": {
             if (values[value[1]][0] !== "ArrayBuffer") {
               throw new Error("Invalid data");
             }
             const TypedArrayConstructor = globalThis[type];
-            const buffer = hydrate(value[1]);
-            const typedArray = new TypedArrayConstructor(buffer);
-            hydrated[index] = value[2] !== void 0 ? typedArray.subarray(value[2], value[3]) : typedArray;
+            const buffer2 = hydrate(value[1]);
+            hydrated[index] = value[2] !== void 0 ? new TypedArrayConstructor(buffer2, value[2], value[3]) : new TypedArrayConstructor(buffer2);
             break;
           }
           case "ArrayBuffer": {
@@ -218,12 +197,21 @@ function unflatten(parsed, revivers) {
         }
       } else if (value[0] === SPARSE) {
         const len = value[1];
-        const array = new Array(len);
+        if (!is_valid_array_len(len)) {
+          throw new Error("Invalid input");
+        }
+        const array = [];
         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]);
         }
+        array.length = len;
       } else {
         const array = new Array(value.length);
         hydrated[index] = array;
@@ -249,6 +237,10 @@ function unflatten(parsed, revivers) {
   return hydrate(0);
 }
 function stringify$1(value, reducers) {
+  const stringified = run(false, value, reducers);
+  return typeof stringified === "string" ? stringified : `[${stringified.join(",")}]`;
+}
+function run(async, value, reducers) {
   const stringified = [];
   const indexes = /* @__PURE__ */ new Map();
   const custom = [];
@@ -259,14 +251,17 @@ function stringify$1(value, reducers) {
   }
   const keys = [];
   let p = 0;
-  function flatten(thing) {
+  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 indexes.get(thing);
-    const index2 = p++;
+    if (indexes.has(thing)) return (
+      /** @type {number} */
+      indexes.get(thing)
+    );
+    index2 ??= p++;
     indexes.set(thing, index2);
     for (const { key, fn } of custom) {
       const value2 = fn(thing);
@@ -277,20 +272,29 @@ function stringify$1(value, reducers) {
     }
     if (typeof thing === "function") {
       throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+    } else if (typeof thing === "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") {
+      {
+        throw new DevalueError(
+          `Cannot stringify a Promise or thenable — use stringifyAsync instead`,
+          keys,
+          thing,
+          value
+        );
+      }
     } else {
       const type = get_type(thing);
       switch (type) {
         case "Number":
         case "String":
         case "Boolean":
-          str = `["Object",${stringify_primitive(thing)}]`;
-          break;
         case "BigInt":
-          str = `["BigInt",${thing}]`;
+          str = `["Object",${flatten(thing.valueOf())}]`;
           break;
         case "Date":
           const valid = !isNaN(thing.getDate());
@@ -354,9 +358,7 @@ function stringify$1(value, reducers) {
         case "Map":
           str = '["Map"';
           for (const [key, value2] of thing) {
-            keys.push(
-              `.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`
-            );
+            keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
             str += `,${flatten(key)},${flatten(value2)}`;
             keys.pop();
           }
@@ -367,19 +369,18 @@ function stringify$1(value, reducers) {
         case "Uint8ClampedArray":
         case "Int16Array":
         case "Uint16Array":
+        case "Float16Array":
         case "Int32Array":
         case "Uint32Array":
         case "Float32Array":
         case "Float64Array":
         case "BigInt64Array":
-        case "BigUint64Array": {
+        case "BigUint64Array":
+        case "DataView": {
           const typedArray = thing;
           str = '["' + type + '",' + flatten(typedArray.buffer);
-          const a = thing.byteOffset;
-          const b = a + thing.byteLength;
-          if (a > 0 || b !== typedArray.buffer.byteLength) {
-            const m = +/(\d+)/.exec(type)[1] / 8;
-            str += `,${a / m},${b / m}`;
+          if (typedArray.byteLength !== typedArray.buffer.byteLength) {
+            str += `,${typedArray.byteOffset},${typedArray.length}`;
           }
           str += "]";
           break;
@@ -401,21 +402,11 @@ function stringify$1(value, reducers) {
           str = `["${type}",${stringify_string(thing.toString())}]`;
           break;
         default:
-          if (!is_plain_object(thing)) {
-            throw new DevalueError(
-              `Cannot stringify arbitrary non-POJOs`,
-              keys,
-              thing,
-              value
-            );
+          if (!is_plain_object$1(thing)) {
+            throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
           }
           if (enumerable_symbols(thing).length > 0) {
-            throw new DevalueError(
-              `Cannot stringify POJOs with symbolic keys`,
-              keys,
-              thing,
-              value
-            );
+            throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
           }
           if (Object.getPrototypeOf(thing) === null) {
             str = '["null"';
@@ -460,17 +451,17 @@ function stringify$1(value, reducers) {
   }
   const index = flatten(value);
   if (index < 0) return `${index}`;
-  return `[${stringified.join(",")}]`;
+  return stringified;
 }
 function stringify_primitive(thing) {
   const type = typeof thing;
   if (type === "string") return stringify_string(thing);
-  if (thing instanceof String) return stringify_string(thing.toString());
   if (thing === void 0) return UNDEFINED.toString();
   if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO.toString();
   if (type === "bigint") return `["BigInt","${thing}"]`;
   return String(thing);
 }
+const decoder = new TextDecoder();
 function set_nested_value(object, path_string, value) {
   if (path_string.startsWith("n:")) {
     path_string = path_string.slice(2);
@@ -562,13 +553,13 @@ async function deserialize_binary_form(request) {
       chunks2.push(chunk);
       cursor += chunk.byteLength;
     }
-    const buffer = new Uint8Array(length);
+    const buffer2 = new Uint8Array(length);
     cursor = 0;
     for (const chunk of chunks2) {
-      buffer.set(chunk, cursor);
+      buffer2.set(chunk, cursor);
       cursor += chunk.byteLength;
     }
-    return buffer;
+    return buffer2;
   }
   const header = await get_buffer(0, HEADER_BYTES);
   if (!header) throw deserialize_error("too short");
@@ -591,7 +582,7 @@ async function deserialize_binary_form(request) {
   if (file_offsets_length > 0) {
     const file_offsets_buffer = await get_buffer(HEADER_BYTES + data_length, file_offsets_length);
     if (!file_offsets_buffer) throw deserialize_error("file offset table too short");
-    const parsed_offsets = JSON.parse(text_decoder.decode(file_offsets_buffer));
+    const parsed_offsets = JSON.parse(decoder.decode(file_offsets_buffer));
     if (!Array.isArray(parsed_offsets) || parsed_offsets.some((n) => typeof n !== "number" || !Number.isInteger(n) || n < 0)) {
       throw deserialize_error("invalid file offset table");
     }
@@ -600,7 +591,7 @@ async function deserialize_binary_form(request) {
     files_start_offset = HEADER_BYTES + data_length + file_offsets_length;
   }
   const file_spans = [];
-  const [data, meta] = parse(text_decoder.decode(data_buffer), {
+  const [data, meta] = parse(decoder.decode(data_buffer), {
     File: ([name, type, size, last_modified, index]) => {
       if (typeof name !== "string" || typeof type !== "string" || typeof size !== "number" || typeof last_modified !== "number" || typeof index !== "number") {
         throw deserialize_error("invalid file metadata");
@@ -756,7 +747,7 @@ class LazyFile {
     });
   }
   async text() {
-    return text_decoder.decode(await this.arrayBuffer());
+    return decoder.decode(await this.arrayBuffer());
   }
 }
 const path_regex = /^[a-zA-Z_$]\w*(\.[a-zA-Z_$]\w*|\[\d+\])*$/;
@@ -779,8 +770,8 @@ function deep_set(object, keys, value) {
     const key = keys[i];
     check_prototype_pollution(key);
     const is_array = /^\d+$/.test(keys[i + 1]);
-    const exists = Object.hasOwn(current, key);
-    const inner = current[key];
+    const inner = Object.hasOwn(current, key) ? current[key] : void 0;
+    const exists = inner != null;
     if (exists && is_array !== Array.isArray(inner)) {
       throw new Error(`Invalid array key ${keys[i + 1]}`);
     }
@@ -998,30 +989,233 @@ function get_node_type(node_id) {
   const dot_parts = filename.split(".");
   return dot_parts.slice(0, -1).join(".");
 }
+function hydratable(key, fn) {
+  if (!async_mode_flag) {
+    experimental_async_required();
+  }
+  const { hydratable: hydratable2 } = get_render_context();
+  let entry = hydratable2.lookup.get(key);
+  if (entry !== void 0) {
+    return (
+      /** @type {T} */
+      entry.value
+    );
+  }
+  const value = fn();
+  entry = encode(key, value, hydratable2.unresolved_promises);
+  hydratable2.lookup.set(key, entry);
+  return value;
+}
+function encode(key, value, unresolved) {
+  const entry = { value, serialized: "" };
+  let uid = 1;
+  entry.serialized = uneval(entry.value, (value2, uneval2) => {
+    if (is_promise(value2)) {
+      const placeholder = `"${uid++}"`;
+      const p = value2.then((v) => {
+        entry.serialized = entry.serialized.replace(
+          placeholder,
+          // use the function form here to prevent any string replacement characters from being interpreted
+          // in `v`, as it's potentially user-controlled and therefore potentially malicious.
+          // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement
+          () => `r(${uneval2(v)})`
+        );
+      }).catch(
+        (devalue_error) => hydratable_serialization_failed(
+          key,
+          serialization_stack(entry.stack, devalue_error?.stack)
+        )
+      );
+      unresolved?.set(p, key);
+      p.catch(() => {
+      }).finally(() => unresolved?.delete(p));
+      (entry.promises ??= []).push(p);
+      return placeholder;
+    }
+  });
+  return entry;
+}
+function is_promise(value) {
+  return Object.prototype.toString.call(value) === "[object Promise]";
+}
+function serialization_stack(root_stack, uneval_stack) {
+  let out = "";
+  if (root_stack) {
+    out += root_stack + "\n";
+  }
+  if (uneval_stack) {
+    out += "Caused by:\n" + uneval_stack + "\n";
+  }
+  return out || "<missing stack trace>";
+}
 const INVALIDATED_PARAM = "x-sveltekit-invalidated";
 const TRAILING_SLASH_PARAM = "x-sveltekit-trailing-slash";
 function stringify(data, transport) {
   const encoders = Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.encode]));
   return stringify$1(data, encoders);
 }
-function stringify_remote_arg(value, transport) {
+const object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
+function is_plain_object(thing) {
+  if (typeof thing !== "object" || thing === null) return false;
+  const proto = Object.getPrototypeOf(thing);
+  return proto === Object.prototype || proto === null || Object.getPrototypeOf(proto) === null || Object.getOwnPropertyNames(proto).sort().join("\0") === object_proto_names;
+}
+function to_sorted(value, clones) {
+  const clone = Object.getPrototypeOf(value) === null ? /* @__PURE__ */ Object.create(null) : {};
+  clones.set(value, clone);
+  Object.defineProperty(clone, remote_arg_marker, { value: true });
+  for (const key of Object.keys(value).sort()) {
+    const property = value[key];
+    Object.defineProperty(clone, key, {
+      value: clones.get(property) ?? property,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  }
+  return clone;
+}
+const remote_object = "__skrao";
+const remote_map = "__skram";
+const remote_set = "__skras";
+const remote_regex_guard = "__skrag";
+const remote_arg_marker = Symbol(remote_object);
+function create_remote_arg_reducers(transport, sort, remote_arg_clones) {
+  const remote_fns_reducers = {
+    [remote_regex_guard]: (
+      /** @type {(value: unknown) => void} */
+      (value) => {
+        if (value instanceof RegExp) {
+          throw new Error("Regular expressions are not valid remote function arguments");
+        }
+      }
+    )
+  };
+  if (sort) {
+    remote_fns_reducers[remote_map] = (value) => {
+      if (!(value instanceof Map)) {
+        return;
+      }
+      const entries = [];
+      for (const [key, val] of value) {
+        entries.push([stringify2(key), stringify2(val)]);
+      }
+      return entries.sort(([a1, a2], [b1, b2]) => {
+        if (a1 < b1) return -1;
+        if (a1 > b1) return 1;
+        if (a2 < b2) return -1;
+        if (a2 > b2) return 1;
+        return 0;
+      });
+    };
+    remote_fns_reducers[remote_set] = (value) => {
+      if (!(value instanceof Set)) {
+        return;
+      }
+      const items = [];
+      for (const item of value) {
+        items.push(stringify2(item));
+      }
+      items.sort();
+      return items;
+    };
+    remote_fns_reducers[remote_object] = (value) => {
+      if (!is_plain_object(value)) {
+        return;
+      }
+      if (Object.hasOwn(value, remote_arg_marker)) {
+        return;
+      }
+      if (remote_arg_clones.has(value)) {
+        return remote_arg_clones.get(value);
+      }
+      return to_sorted(value, remote_arg_clones);
+    };
+  }
+  const user_reducers = Object.fromEntries(
+    Object.entries(transport).map(([k, v]) => [k, v.encode])
+  );
+  const all_reducers = { ...user_reducers, ...remote_fns_reducers };
+  const stringify2 = (value) => stringify$1(value, all_reducers);
+  return all_reducers;
+}
+function create_remote_arg_revivers(transport) {
+  const remote_fns_revivers = {
+    /** @type {(value: unknown) => unknown} */
+    [remote_object]: (value) => value,
+    /** @type {(value: unknown) => Map<unknown, unknown>} */
+    [remote_map]: (value) => {
+      if (!Array.isArray(value)) {
+        throw new Error("Invalid data for Map reviver");
+      }
+      const map = /* @__PURE__ */ new Map();
+      for (const item of value) {
+        if (!Array.isArray(item) || item.length !== 2 || typeof item[0] !== "string" || typeof item[1] !== "string") {
+          throw new Error("Invalid data for Map reviver");
+        }
+        const [key, val] = item;
+        map.set(parse$1(key), parse$1(val));
+      }
+      return map;
+    },
+    /** @type {(value: unknown) => Set<unknown>} */
+    [remote_set]: (value) => {
+      if (!Array.isArray(value)) {
+        throw new Error("Invalid data for Set reviver");
+      }
+      const set = /* @__PURE__ */ new Set();
+      for (const item of value) {
+        if (typeof item !== "string") {
+          throw new Error("Invalid data for Set reviver");
+        }
+        set.add(parse$1(item));
+      }
+      return set;
+    }
+  };
+  const user_revivers = Object.fromEntries(
+    Object.entries(transport).map(([k, v]) => [k, v.decode])
+  );
+  const all_revivers = { ...user_revivers, ...remote_fns_revivers };
+  const parse$1 = (data) => parse(data, all_revivers);
+  return all_revivers;
+}
+function stringify_remote_arg(value, transport, sort = true) {
   if (value === void 0) return "";
-  const json_string = stringify(value, transport);
-  const bytes = new TextEncoder().encode(json_string);
+  const json_string = stringify$1(
+    value,
+    create_remote_arg_reducers(transport, sort, /* @__PURE__ */ new Map())
+  );
+  const bytes = text_encoder.encode(json_string);
   return base64_encode(bytes).replaceAll("=", "").replaceAll("+", "-").replaceAll("/", "_");
 }
 function parse_remote_arg(string, transport) {
   if (!string) return void 0;
-  const json_string = text_decoder.decode(
+  const json_string = new TextDecoder().decode(
     // no need to add back `=` characters, atob can handle it
     base64_decode(string.replaceAll("-", "+").replaceAll("_", "/"))
   );
-  const decoders = Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.decode]));
-  return parse(json_string, decoders);
+  return parse(json_string, create_remote_arg_revivers(transport));
 }
 function create_remote_key(id, payload) {
   return id + "/" + payload;
 }
+function split_remote_key(key) {
+  const i = key.lastIndexOf("/");
+  if (i === -1) {
+    throw new Error(`Invalid remote key: ${key}`);
+  }
+  return {
+    id: key.slice(0, i),
+    payload: key.slice(i + 1)
+  };
+}
+function unfriendly_hydratable(key, fn) {
+  if (!hydratable) {
+    throw new Error("Remote functions require Svelte 5.44.0 or later");
+  }
+  return hydratable(key, fn);
+}
 
-export { ENDPOINT_METHODS as E, INVALIDATED_PARAM as I, MUTATIVE_METHODS as M, PAGE_METHODS as P, SVELTE_KIT_ASSETS as S, TRAILING_SLASH_PARAM as T, handle_fatal_error as a, clarify_devalue_error as b, create_remote_key as c, handle_error_and_jsonify as d, get_status as e, format_server_error as f, get_global_name as g, has_prerendered_path as h, is_form_content_type as i, normalize_error as j, static_error_page as k, stringify as l, method_not_allowed as m, negotiate as n, deserialize_binary_form as o, parse_remote_arg as p, get_node_type as q, redirect_response as r, serialize_uses as s, stringify$1 as t, escape_html as u, stringify_remote_arg as v };
-//# sourceMappingURL=shared-BqTYMAzZ.js.map
+export { ENDPOINT_METHODS as E, INVALIDATED_PARAM as I, MUTATIVE_METHODS as M, PAGE_METHODS as P, SVELTE_KIT_ASSETS as S, TRAILING_SLASH_PARAM as T, handle_fatal_error as a, negotiate as b, create_remote_key as c, clarify_devalue_error as d, handle_error_and_jsonify as e, format_server_error as f, get_global_name as g, has_prerendered_path as h, is_form_content_type as i, get_status as j, normalize_error as k, static_error_page as l, method_not_allowed as m, noop as n, once as o, parse_remote_arg as p, stringify as q, redirect_response as r, serialize_uses as s, deserialize_binary_form as t, get_node_type as u, stringify$1 as v, escape_html as w, split_remote_key as x, stringify_remote_arg as y, unfriendly_hydratable as z };
+//# sourceMappingURL=shared-DlqhoNLb.js.map