mongoku 2.0.4 → 2.1.1

package/build/server/index.js

@@ -1,10 +1,13 @@
 import { j as json, t as text, R as Redirect, S as SvelteKitError, H as HttpError, e as error, A as ActionFailure } from './chunks/index-Djsj11qr.js';
 import { w as with_request_store } from './chunks/event-DVH-6ISX.js';
-import { r as render, e as experimental_async_ssr, L as LEGACY_PROPS, U as UNOWNED, E as ERROR_VALUE, C as COMMENT_NODE, H as HYDRATION_START, a as HYDRATION_ERROR, S as STATE_SYMBOL, b as UNINITIALIZED, D as DERIVED, c as DIRTY, d as CLEAN, M as MAYBE_DIRTY, f as DISCONNECTED, I as INERT, g as EFFECT, R as RENDER_EFFECT, A as ASYNC, B as BLOCK_EFFECT, i as is_passive_event, h as BRANCH_EFFECT, j as ROOT_EFFECT, k as DESTROYED, l as REACTION_IS_UPDATING, m as EFFECT_RAN, n as EFFECT_PRESERVED, o as HEAD_EFFECT, p as BOUNDARY_EFFECT, q as EFFECT_TRANSPARENT, s as INSPECT_EFFECT, t as STALE_REACTION, u as HYDRATION_END, v as HYDRATION_START_ELSE, w as USER_EFFECT, x as base, y as app_dir, z as exec, F as assets, G as relative, J as override, K as reset } from './chunks/routing-DcR4fCSD.js';
-import { t as text_decoder, b as base64_decode, a as text_encoder, g as get_relative_path, c as base64_encode } from './chunks/utils-DGYJFmnf.js';
+import { b as base, a as app_dir, e as exec, c as assets, d as relative, o as override, f as reset } from './chunks/routing-e10vGH37.js';
+import { T as TRAILING_SLASH_PARAM, I as INVALIDATED_PARAM, c as create_remote_cache_key, i as is_primitive, g as get_type, p as parse_remote_arg, a as stringify, b as stringify$1, D as DevalueError, d as is_plain_object, e as enumerable_symbols, f as stringify_key, h as stringify_string, j as escaped } from './chunks/shared-Buki-xt5.js';
 import { d as decode_pathname, a as decode_params, n as normalize_path, b as disable_search, v as validate_layout_server_exports, c as validate_layout_exports, e as validate_page_server_exports, f as validate_page_exports, r as resolve, m as make_trackable } from './chunks/exports-Cv9LZeD1.js';
-import { s as safe_equals, e as equals, r as readable, w as writable } from './chunks/index-EKt9-9bV.js';
-import { a as async_mode_flag, d as define_property, o as object_prototype, b as array_prototype, g as get_descriptor, i as is_extensible, c as array_from, e as get_prototype_of, f as is_array, h as deferred, n as noop, r as run_all, t as tracing_mode_flag, j as index_of, s as setContext } from './chunks/async-BfR0vYHo.js';
+import { c as text_encoder, g as get_relative_path, a as base64_encode, t as text_decoder } from './chunks/utils-kjxf7BZO.js';
+import { s as safe_equals, e as equals, r as readable, w as writable } from './chunks/index-DFXVwu6p.js';
+import { r as render, L as LEGACY_PROPS, U as UNOWNED, E as ERROR_VALUE, C as COMMENT_NODE, H as HYDRATION_START, i as HYDRATION_ERROR, S as STATE_SYMBOL, j as UNINITIALIZED, D as DERIVED, k as DIRTY, l as CLEAN, M as MAYBE_DIRTY, m as DISCONNECTED, I as INERT, n as EFFECT, R as RENDER_EFFECT, B as BLOCK_EFFECT, o as is_passive_event, p as BRANCH_EFFECT, q as ROOT_EFFECT, t as DESTROYED, A as ASYNC, u as REACTION_IS_UPDATING, v as EFFECT_RAN, w as EFFECT_PRESERVED, x as HEAD_EFFECT, y as BOUNDARY_EFFECT, z as EFFECT_TRANSPARENT, F as INSPECT_EFFECT, G as STALE_REACTION, J as HYDRATION_END, K as HYDRATION_START_ELSE, N as USER_EFFECT } from './chunks/index2-DBFlGzWV.js';
+import { d as define_property, o as object_prototype, c as array_prototype, f as get_descriptor, h as is_extensible, j as array_from, k as get_prototype_of, l as is_array, m as deferred, r as run_all, q as index_of, t as setContext } from './chunks/context-C22hLSHK.js';
+import { a as async_mode_flag, t as tracing_mode_flag } from './chunks/async-lVJA8xJZ.js';
 
 const DEV = false;
 
@@ -24,502 +27,6 @@ function merge_tracing(event_like, current) {
 	};
 }
 
-const escaped = {
-  "<": "\\u003C",
-  "\\": "\\\\",
-  "\b": "\\b",
-  "\f": "\\f",
-  "\n": "\\n",
-  "\r": "\\r",
-  "	": "\\t",
-  "\u2028": "\\u2028",
-  "\u2029": "\\u2029"
-};
-class DevalueError extends Error {
-  /**
-   * @param {string} message
-   * @param {string[]} keys
-   */
-  constructor(message, keys) {
-    super(message);
-    this.name = "DevalueError";
-    this.path = keys.join("");
-  }
-}
-function is_primitive(thing) {
-  return Object(thing) !== thing;
-}
-const object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(
-  Object.prototype
-).sort().join("\0");
-function is_plain_object(thing) {
-  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 get_type(thing) {
-  return Object.prototype.toString.call(thing).slice(8, -1);
-}
-function get_escaped_char(char) {
-  switch (char) {
-    case '"':
-      return '\\"';
-    case "<":
-      return "\\u003C";
-    case "\\":
-      return "\\\\";
-    case "\n":
-      return "\\n";
-    case "\r":
-      return "\\r";
-    case "	":
-      return "\\t";
-    case "\b":
-      return "\\b";
-    case "\f":
-      return "\\f";
-    case "\u2028":
-      return "\\u2028";
-    case "\u2029":
-      return "\\u2029";
-    default:
-      return char < " " ? `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}` : "";
-  }
-}
-function stringify_string(str) {
-  let result = "";
-  let last_pos = 0;
-  const len = str.length;
-  for (let i = 0; i < len; i += 1) {
-    const char = str[i];
-    const replacement = get_escaped_char(char);
-    if (replacement) {
-      result += str.slice(last_pos, i) + replacement;
-      last_pos = i + 1;
-    }
-  }
-  return `"${last_pos === 0 ? str : result + str.slice(last_pos)}"`;
-}
-function enumerable_symbols(object) {
-  return Object.getOwnPropertySymbols(object).filter(
-    (symbol) => Object.getOwnPropertyDescriptor(object, symbol).enumerable
-  );
-}
-const is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
-function stringify_key(key) {
-  return is_identifier.test(key) ? "." + key : "[" + JSON.stringify(key) + "]";
-}
-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 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;
-}
-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);
-  }
-  return output;
-}
-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]];
-      }
-    }
-  }
-  return out;
-}
-const UNDEFINED = -1;
-const HOLE = -2;
-const NAN = -3;
-const POSITIVE_INFINITY = -4;
-const NEGATIVE_INFINITY = -5;
-const NEGATIVE_ZERO = -6;
-function parse(serialized, revivers) {
-  return unflatten(JSON.parse(serialized), revivers);
-}
-function unflatten(parsed, revivers) {
-  if (typeof parsed === "number") return hydrate(parsed, true);
-  if (!Array.isArray(parsed) || parsed.length === 0) {
-    throw new Error("Invalid input");
-  }
-  const values = (
-    /** @type {any[]} */
-    parsed
-  );
-  const hydrated = Array(values.length);
-  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 (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;
-    } else if (Array.isArray(value)) {
-      if (typeof value[0] === "string") {
-        const type = value[0];
-        const reviver = revivers?.[type];
-        if (reviver) {
-          return hydrated[index] = reviver(hydrate(value[1]));
-        }
-        switch (type) {
-          case "Date":
-            hydrated[index] = new Date(value[1]);
-            break;
-          case "Set":
-            const set = /* @__PURE__ */ new Set();
-            hydrated[index] = set;
-            for (let i = 1; i < value.length; i += 1) {
-              set.add(hydrate(value[i]));
-            }
-            break;
-          case "Map":
-            const map = /* @__PURE__ */ new Map();
-            hydrated[index] = map;
-            for (let i = 1; i < value.length; i += 2) {
-              map.set(hydrate(value[i]), hydrate(value[i + 1]));
-            }
-            break;
-          case "RegExp":
-            hydrated[index] = new RegExp(value[1], value[2]);
-            break;
-          case "Object":
-            hydrated[index] = Object(value[1]);
-            break;
-          case "BigInt":
-            hydrated[index] = BigInt(value[1]);
-            break;
-          case "null":
-            const obj = /* @__PURE__ */ Object.create(null);
-            hydrated[index] = obj;
-            for (let i = 1; i < value.length; i += 2) {
-              obj[value[i]] = hydrate(value[i + 1]);
-            }
-            break;
-          case "Int8Array":
-          case "Uint8Array":
-          case "Uint8ClampedArray":
-          case "Int16Array":
-          case "Uint16Array":
-          case "Int32Array":
-          case "Uint32Array":
-          case "Float32Array":
-          case "Float64Array":
-          case "BigInt64Array":
-          case "BigUint64Array": {
-            const TypedArrayConstructor = globalThis[type];
-            const typedArray = new TypedArrayConstructor(hydrate(value[1]));
-            hydrated[index] = value[2] !== void 0 ? typedArray.subarray(value[2], value[3]) : typedArray;
-            break;
-          }
-          case "ArrayBuffer": {
-            const base64 = value[1];
-            const arraybuffer = decode64(base64);
-            hydrated[index] = arraybuffer;
-            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": {
-            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;
-            break;
-          }
-          default:
-            throw new Error(`Unknown type ${type}`);
-        }
-      } else {
-        const array = new Array(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);
-        }
-      }
-    } else {
-      const object = {};
-      hydrated[index] = object;
-      for (const key in value) {
-        if (key === "__proto__") {
-          throw new Error("Cannot parse an object with a `__proto__` property");
-        }
-        const n = value[key];
-        object[key] = hydrate(n);
-      }
-    }
-    return hydrated[index];
-  }
-  return hydrate(0);
-}
-function stringify$1(value, reducers) {
-  const stringified = [];
-  const indexes = /* @__PURE__ */ new Map();
-  const custom = [];
-  if (reducers) {
-    for (const key of Object.getOwnPropertyNames(reducers)) {
-      custom.push({ key, fn: reducers[key] });
-    }
-  }
-  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;
-    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++;
-    indexes.set(thing, index2);
-    for (const { key, fn } of custom) {
-      const value2 = fn(thing);
-      if (value2) {
-        stringified[index2] = `["${key}",${flatten(value2)}]`;
-        return index2;
-      }
-    }
-    let str = "";
-    if (is_primitive(thing)) {
-      str = stringify_primitive$1(thing);
-    } else {
-      const type = get_type(thing);
-      switch (type) {
-        case "Number":
-        case "String":
-        case "Boolean":
-          str = `["Object",${stringify_primitive$1(thing)}]`;
-          break;
-        case "BigInt":
-          str = `["BigInt",${thing}]`;
-          break;
-        case "Date":
-          const valid = !isNaN(thing.getDate());
-          str = `["Date","${valid ? thing.toISOString() : ""}"]`;
-          break;
-        case "URL":
-          str = `["URL",${stringify_string(thing.toString())}]`;
-          break;
-        case "URLSearchParams":
-          str = `["URLSearchParams",${stringify_string(thing.toString())}]`;
-          break;
-        case "RegExp":
-          const { source, flags } = thing;
-          str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
-          break;
-        case "Array":
-          str = "[";
-          for (let i = 0; i < thing.length; i += 1) {
-            if (i > 0) str += ",";
-            if (i in thing) {
-              keys.push(`[${i}]`);
-              str += flatten(thing[i]);
-              keys.pop();
-            } else {
-              str += HOLE;
-            }
-          }
-          str += "]";
-          break;
-        case "Set":
-          str = '["Set"';
-          for (const value2 of thing) {
-            str += `,${flatten(value2)}`;
-          }
-          str += "]";
-          break;
-        case "Map":
-          str = '["Map"';
-          for (const [key, value2] of thing) {
-            keys.push(
-              `.get(${is_primitive(key) ? stringify_primitive$1(key) : "..."})`
-            );
-            str += `,${flatten(key)},${flatten(value2)}`;
-            keys.pop();
-          }
-          str += "]";
-          break;
-        case "Int8Array":
-        case "Uint8Array":
-        case "Uint8ClampedArray":
-        case "Int16Array":
-        case "Uint16Array":
-        case "Int32Array":
-        case "Uint32Array":
-        case "Float32Array":
-        case "Float64Array":
-        case "BigInt64Array":
-        case "BigUint64Array": {
-          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}`;
-          }
-          str += "]";
-          break;
-        }
-        case "ArrayBuffer": {
-          const arraybuffer = thing;
-          const base64 = encode64(arraybuffer);
-          str = `["ArrayBuffer","${base64}"]`;
-          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":
-          str = `["${type}",${stringify_string(thing.toString())}]`;
-          break;
-        default:
-          if (!is_plain_object(thing)) {
-            throw new DevalueError(
-              `Cannot stringify arbitrary non-POJOs`,
-              keys
-            );
-          }
-          if (enumerable_symbols(thing).length > 0) {
-            throw new DevalueError(
-              `Cannot stringify POJOs with symbolic keys`,
-              keys
-            );
-          }
-          if (Object.getPrototypeOf(thing) === null) {
-            str = '["null"';
-            for (const key in thing) {
-              keys.push(stringify_key(key));
-              str += `,${stringify_string(key)},${flatten(thing[key])}`;
-              keys.pop();
-            }
-            str += "]";
-          } else {
-            str = "{";
-            let started = false;
-            for (const key in thing) {
-              if (started) str += ",";
-              started = true;
-              keys.push(stringify_key(key));
-              str += `${stringify_string(key)}:${flatten(thing[key])}`;
-              keys.pop();
-            }
-            str += "}";
-          }
-      }
-    }
-    stringified[index2] = str;
-    return index2;
-  }
-  const index = flatten(value);
-  if (index < 0) return `${index}`;
-  return `[${stringified.join(",")}]`;
-}
-function stringify_primitive$1(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 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 parse_remote_arg(string, transport) {
-  if (!string) return void 0;
-  const json_string = text_decoder.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);
-}
-function create_remote_cache_key(id, payload) {
-  return id + "/" + payload;
-}
-
 let public_env = {};
 function set_private_env(environment) {
 }
@@ -728,7 +235,7 @@ function apply_adjustments(error) {
 }
 const batches = /* @__PURE__ */ new Set();
 let current_batch = null;
-let batch_deriveds = null;
+let batch_values = null;
 let effect_pending_updates = /* @__PURE__ */ new Set();
 let queued_root_effects = [];
 let last_scheduled_effect = null;
@@ -763,12 +270,6 @@ class Batch {
    * @type {{ promise: Promise<void>, resolve: (value?: any) => void, reject: (reason: unknown) => void } | null}
    */
   #deferred = null;
-  /**
-   * Async effects inside a newly-created `<svelte:boundary>`
-   * — these do not prevent the batch from committing
-   * @type {Effect[]}
-   */
-  #boundary_async_effects = [];
   /**
    * Template effects and `$effect.pre` effects, which run when
    * a batch is committed
@@ -808,11 +309,12 @@ class Batch {
    */
   process(root_effects) {
     queued_root_effects = [];
-    var revert = Batch.apply(this);
+    this.apply();
     for (const root2 of root_effects) {
       this.#traverse_effect_tree(root2);
     }
     if (this.#pending === 0) {
+      var previous_batch_sources = batch_values;
       this.#commit();
       var render_effects = this.#render_effects;
       var effects = this.#effects;
@@ -820,6 +322,7 @@ class Batch {
       this.#effects = [];
       this.#block_effects = [];
       current_batch = null;
+      batch_values = previous_batch_sources;
       flush_queued_effects(render_effects);
       flush_queued_effects(effects);
       this.#deferred?.resolve();
@@ -828,11 +331,7 @@ class Batch {
       this.#defer_effects(this.#effects);
       this.#defer_effects(this.#block_effects);
     }
-    revert();
-    for (const effect of this.#boundary_async_effects) {
-      update_effect(effect);
-    }
-    this.#boundary_async_effects = [];
+    batch_values = null;
   }
   /**
    * Traverse the effect tree, executing effects or stashing
@@ -854,13 +353,9 @@ class Batch {
           this.#effects.push(effect);
         } else if (async_mode_flag && (flags2 & RENDER_EFFECT) !== 0) {
           this.#render_effects.push(effect);
-        } else if ((flags2 & CLEAN) === 0) {
-          if ((flags2 & ASYNC) !== 0 && effect.b?.is_pending()) {
-            this.#boundary_async_effects.push(effect);
-          } else if (is_dirty(effect)) {
-            if ((effect.f & BLOCK_EFFECT) !== 0) this.#block_effects.push(effect);
-            update_effect(effect);
-          }
+        } else if (is_dirty(effect)) {
+          if ((effect.f & BLOCK_EFFECT) !== 0) this.#block_effects.push(effect);
+          update_effect(effect);
         }
         var child = effect.first;
         if (child !== null) {
@@ -898,12 +393,14 @@ class Batch {
       this.#previous.set(source2, value);
     }
     this.current.set(source2, source2.v);
+    batch_values?.set(source2, source2.v);
   }
   activate() {
     current_batch = this;
   }
   deactivate() {
     current_batch = null;
+    batch_values = null;
   }
   flush() {
     if (queued_root_effects.length > 0) {
@@ -940,24 +437,34 @@ class Batch {
           is_earlier = false;
           continue;
         }
+        const sources = [];
         for (const [source2, value] of this.current) {
           if (batch.current.has(source2)) {
-            if (is_earlier) {
+            if (is_earlier && value !== batch.current.get(source2)) {
               batch.current.set(source2, value);
             } else {
               continue;
             }
           }
-          mark_effects(source2);
+          sources.push(source2);
         }
-        if (queued_root_effects.length > 0) {
-          current_batch = batch;
-          const revert = Batch.apply(batch);
-          for (const root2 of queued_root_effects) {
-            batch.#traverse_effect_tree(root2);
+        if (sources.length === 0) {
+          continue;
+        }
+        const others = [...batch.current.keys()].filter((s) => !this.current.has(s));
+        if (others.length > 0) {
+          for (const source2 of sources) {
+            mark_effects(source2, others);
+          }
+          if (queued_root_effects.length > 0) {
+            current_batch = batch;
+            batch.apply();
+            for (const root2 of queued_root_effects) {
+              batch.#traverse_effect_tree(root2);
+            }
+            queued_root_effects = [];
+            batch.deactivate();
           }
-          queued_root_effects = [];
-          revert();
         }
       }
       current_batch = null;
@@ -1005,36 +512,17 @@ class Batch {
   static enqueue(task) {
     queue_micro_task(task);
   }
-  /**
-   * @param {Batch} current_batch
-   */
-  static apply(current_batch2) {
-    if (!async_mode_flag || batches.size === 1) {
-      return noop;
-    }
-    var current_values = /* @__PURE__ */ new Map();
-    batch_deriveds = /* @__PURE__ */ new Map();
-    for (const [source2, current] of current_batch2.current) {
-      current_values.set(source2, { v: source2.v, wv: source2.wv });
-      source2.v = current;
-    }
+  apply() {
+    if (!async_mode_flag || batches.size === 1) return;
+    batch_values = new Map(this.current);
     for (const batch of batches) {
-      if (batch === current_batch2) continue;
+      if (batch === this) continue;
       for (const [source2, previous] of batch.#previous) {
-        if (!current_values.has(source2)) {
-          current_values.set(source2, { v: source2.v, wv: source2.wv });
-          source2.v = previous;
+        if (!batch_values.has(source2)) {
+          batch_values.set(source2, previous);
         }
       }
     }
-    return () => {
-      for (const [source2, { v, wv }] of current_values) {
-        if (source2.wv <= wv) {
-          source2.v = v;
-        }
-      }
-      batch_deriveds = null;
-    };
   }
 }
 function flushSync(fn) {
@@ -1121,16 +609,17 @@ function flush_queued_effects(effects) {
   }
   eager_block_effects = null;
 }
-function mark_effects(value) {
+function mark_effects(value, sources) {
   if (value.reactions !== null) {
     for (const reaction of value.reactions) {
       const flags2 = reaction.f;
       if ((flags2 & DERIVED) !== 0) {
         mark_effects(
           /** @type {Derived} */
-          reaction
+          reaction,
+          sources
         );
-      } else if ((flags2 & (ASYNC | BLOCK_EFFECT)) !== 0) {
+      } else if ((flags2 & (ASYNC | BLOCK_EFFECT)) !== 0 && depends_on(reaction, sources)) {
         set_signal_status(reaction, DIRTY);
         schedule_effect(
           /** @type {Effect} */
@@ -1140,6 +629,23 @@ function mark_effects(value) {
     }
   }
 }
+function depends_on(reaction, sources) {
+  if (reaction.deps !== null) {
+    for (const dep of reaction.deps) {
+      if (sources.includes(dep)) {
+        return true;
+      }
+      if ((dep.f & DERIVED) !== 0 && depends_on(
+        /** @type {Derived} */
+        dep,
+        sources
+      )) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 function schedule_effect(signal) {
   var effect = last_scheduled_effect = signal;
   while (effect.parent !== null) {
@@ -1491,18 +997,6 @@ class Boundary {
     }
   }
 }
-function move_effect(effect, fragment) {
-  var node = effect.nodes_start;
-  var end = effect.nodes_end;
-  while (node !== null) {
-    var next2 = node === end ? null : (
-      /** @type {TemplateNode} */
-      /* @__PURE__ */ get_next_sibling(node)
-    );
-    fragment.append(node);
-    node = next2;
-  }
-}
 function destroy_derived_effects(derived) {
   var effects = derived.effects;
   if (effects !== null) {
@@ -1551,8 +1045,8 @@ function update_derived(derived) {
   if (is_destroying_effect) {
     return;
   }
-  if (batch_deriveds !== null) {
-    batch_deriveds.set(derived, derived.v);
+  if (batch_values !== null) {
+    batch_values.set(derived, derived.v);
   } else {
     var status = (skip_reaction || (derived.f & UNOWNED) !== 0) && derived.deps !== null ? MAYBE_DIRTY : CLEAN;
     set_signal_status(derived, status);
@@ -2092,11 +1586,11 @@ function unlink_effect(effect) {
     if (parent.last === effect) parent.last = prev;
   }
 }
-function pause_effect(effect, callback) {
+function pause_effect(effect, callback, destroy = true) {
   var transitions = [];
   pause_children(effect, transitions, true);
   run_out_transitions(transitions, () => {
-    destroy_effect(effect);
+    if (destroy) destroy_effect(effect);
     if (callback) callback();
   });
 }
@@ -2129,6 +1623,18 @@ function pause_children(effect, transitions, local) {
     child = sibling;
   }
 }
+function move_effect(effect, fragment) {
+  var node = effect.nodes_start;
+  var end = effect.nodes_end;
+  while (node !== null) {
+    var next2 = node === end ? null : (
+      /** @type {TemplateNode} */
+      /* @__PURE__ */ get_next_sibling(node)
+    );
+    fragment.append(node);
+    node = next2;
+  }
+}
 let is_updating_effect = false;
 function set_is_updating_effect(value) {
   is_updating_effect = value;
@@ -2476,13 +1982,16 @@ function get(signal) {
   } else if (is_derived) {
     derived = /** @type {Derived} */
     signal;
-    if (batch_deriveds?.has(derived)) {
-      return batch_deriveds.get(derived);
+    if (batch_values?.has(derived)) {
+      return batch_values.get(derived);
     }
     if (is_dirty(derived)) {
       update_derived(derived);
     }
   }
+  if (batch_values?.has(signal)) {
+    return batch_values.get(signal);
+  }
   if ((signal.f & ERROR_VALUE) !== 0) {
     throw signal.v;
   }
@@ -2902,7 +2411,6 @@ function asClassComponent(component) {
            */
           value: (onfulfilled, onrejected) => {
             if (!async_mode_flag) {
-              experimental_async_ssr();
               const user_result = onfulfilled({
                 css: munged.css,
                 head: munged.head,
@@ -2935,7 +2443,11 @@ function Root($$renderer, $$props) {
       components = [],
       form,
       data_0 = null,
-      data_1 = null
+      data_1 = null,
+      data_2 = null,
+      data_3 = null,
+      data_4 = null,
+      data_5 = null
     } = $$props;
     {
       setContext("__svelte__", stores);
@@ -2943,7 +2455,7 @@ function Root($$renderer, $$props) {
     {
       stores.page.set(page);
     }
-    const Pyramid_1 = constructors[1];
+    const Pyramid_5 = constructors[5];
     if (constructors[1]) {
       $$renderer2.push("<!--[-->");
       const Pyramid_0 = constructors[0];
@@ -2953,9 +2465,93 @@ function Root($$renderer, $$props) {
         form,
         params: page.params,
         children: ($$renderer3) => {
-          $$renderer3.push(`<!---->`);
-          Pyramid_1($$renderer3, { data: data_1, form, params: page.params });
-          $$renderer3.push(`<!---->`);
+          if (constructors[2]) {
+            $$renderer3.push("<!--[-->");
+            const Pyramid_1 = constructors[1];
+            $$renderer3.push(`<!---->`);
+            Pyramid_1($$renderer3, {
+              data: data_1,
+              form,
+              params: page.params,
+              children: ($$renderer4) => {
+                if (constructors[3]) {
+                  $$renderer4.push("<!--[-->");
+                  const Pyramid_2 = constructors[2];
+                  $$renderer4.push(`<!---->`);
+                  Pyramid_2($$renderer4, {
+                    data: data_2,
+                    form,
+                    params: page.params,
+                    children: ($$renderer5) => {
+                      if (constructors[4]) {
+                        $$renderer5.push("<!--[-->");
+                        const Pyramid_3 = constructors[3];
+                        $$renderer5.push(`<!---->`);
+                        Pyramid_3($$renderer5, {
+                          data: data_3,
+                          form,
+                          params: page.params,
+                          children: ($$renderer6) => {
+                            if (constructors[5]) {
+                              $$renderer6.push("<!--[-->");
+                              const Pyramid_4 = constructors[4];
+                              $$renderer6.push(`<!---->`);
+                              Pyramid_4($$renderer6, {
+                                data: data_4,
+                                form,
+                                params: page.params,
+                                children: ($$renderer7) => {
+                                  $$renderer7.push(`<!---->`);
+                                  Pyramid_5($$renderer7, { data: data_5, form, params: page.params });
+                                  $$renderer7.push(`<!---->`);
+                                },
+                                $$slots: { default: true }
+                              });
+                              $$renderer6.push(`<!---->`);
+                            } else {
+                              $$renderer6.push("<!--[!-->");
+                              const Pyramid_4 = constructors[4];
+                              $$renderer6.push(`<!---->`);
+                              Pyramid_4($$renderer6, { data: data_4, form, params: page.params });
+                              $$renderer6.push(`<!---->`);
+                            }
+                            $$renderer6.push(`<!--]-->`);
+                          },
+                          $$slots: { default: true }
+                        });
+                        $$renderer5.push(`<!---->`);
+                      } else {
+                        $$renderer5.push("<!--[!-->");
+                        const Pyramid_3 = constructors[3];
+                        $$renderer5.push(`<!---->`);
+                        Pyramid_3($$renderer5, { data: data_3, form, params: page.params });
+                        $$renderer5.push(`<!---->`);
+                      }
+                      $$renderer5.push(`<!--]-->`);
+                    },
+                    $$slots: { default: true }
+                  });
+                  $$renderer4.push(`<!---->`);
+                } else {
+                  $$renderer4.push("<!--[!-->");
+                  const Pyramid_2 = constructors[2];
+                  $$renderer4.push(`<!---->`);
+                  Pyramid_2($$renderer4, { data: data_2, form, params: page.params });
+                  $$renderer4.push(`<!---->`);
+                }
+                $$renderer4.push(`<!--]-->`);
+              },
+              $$slots: { default: true }
+            });
+            $$renderer3.push(`<!---->`);
+          } else {
+            $$renderer3.push("<!--[!-->");
+            const Pyramid_1 = constructors[1];
+            $$renderer3.push(`<!---->`);
+            Pyramid_1($$renderer3, { data: data_1, form, params: page.params });
+            $$renderer3.push(`<!---->`);
+          }
+          $$renderer3.push(`<!--]-->`);
         },
         $$slots: { default: true }
       });
@@ -2992,7 +2588,7 @@ const options = {
   service_worker: false,
   service_worker_options: void 0,
   templates: {
-    app: ({ head, body, assets, nonce, env }) => '<!doctype html>\n<html lang="en">\n	<head>\n		<meta charset="utf-8" />\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",
+    app: ({ head, body, assets, nonce, env }) => '<!doctype html>\n<html lang="en">\n	<head>\n		<meta charset="utf-8" />\n		<meta name="viewport" content="width=device-width, initial-scale=1" />\n		<script>\n			// Immediately set theme to prevent flash\n			(function () {\n				const theme = localStorage.getItem("theme") || "dark";\n				let actualTheme;\n\n				if (theme === "system") {\n					actualTheme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";\n				} else {\n					actualTheme = theme;\n				}\n\n				document.documentElement.setAttribute("data-theme", actualTheme);\n			})();\n		<\/script>\n		' + head + '\n	</head>\n	<body data-sveltekit-preload-data="hover">\n		<div style="display: contents">' + body + "</div>\n	</body>\n</html>\n",
     error: ({ status, message }) => '<!doctype html>\n<html lang="en">\n	<head>\n		<meta charset="utf-8" />\n		<title>' + message + `</title>
 
 		<style>
@@ -3064,7 +2660,7 @@ const options = {
 		<div class="error">
 			<span class="status">` + status + '</span>\n			<div class="message">\n				<h1>' + message + "</h1>\n			</div>\n		</div>\n	</body>\n</html>\n"
   },
-  version_hash: "9v9im3"
+  version_hash: "1ox5bkv"
 };
 async function get_hooks() {
   let handle;
@@ -3072,7 +2668,7 @@ async function get_hooks() {
   let handleError;
   let handleValidationError;
   let init;
-  ({ handle, handleFetch, handleError, handleValidationError, init } = await import('./chunks/hooks.server-_TKfdzGA.js'));
+  ({ handle, handleFetch, handleError, handleValidationError, init } = await import('./chunks/hooks.server-CagAPNr2.js'));
   let reroute;
   let transport;
   return {
@@ -3986,46 +3582,29 @@ function try_serialize(data, fn, route_id) {
     throw error2;
   }
 }
-function defer() {
-  let fulfil;
-  let reject;
-  const promise = new Promise((f, r) => {
-    fulfil = f;
-    reject = r;
-  });
-  return { promise, fulfil, reject };
-}
 function create_async_iterator() {
-  let count = 0;
-  const deferred = [defer()];
+  let resolved = -1;
+  let returned = -1;
+  const deferred = [];
   return {
     iterate: (transform = (x) => x) => {
       return {
         [Symbol.asyncIterator]() {
           return {
             next: async () => {
-              const next = await deferred[0].promise;
-              if (!next.done) {
-                deferred.shift();
-                return { value: transform(next.value), done: false };
-              }
-              return next;
+              const next = deferred[++returned];
+              if (!next) return { value: null, done: true };
+              const value = await next.promise;
+              return { value: transform(value), done: false };
             }
           };
         }
       };
     },
     add: (promise) => {
-      count += 1;
+      deferred.push(with_resolvers());
       void promise.then((value) => {
-        deferred[deferred.length - 1].fulfil({
-          value,
-          done: false
-        });
-        deferred.push(defer());
-        if (--count === 0) {
-          deferred[deferred.length - 1].fulfil({ done: true });
-        }
+        deferred[++resolved].resolve(value);
       });
     }
   };