@juspay/shooter 1.9.2 → 1.9.3

package/build/server/chunks/{index-Ce_T9BSa.js → index-DMikC9Qy.js}

@@ -561,6 +561,10 @@ const ASYNC = 1 << 22;
 const ERROR_VALUE = 1 << 23;
 const STATE_SYMBOL = /* @__PURE__ */ Symbol("$state");
 const LEGACY_PROPS = /* @__PURE__ */ Symbol("legacy props");
+const ATTRIBUTES_CACHE = /* @__PURE__ */ Symbol("attributes");
+const CLASS_CACHE = /* @__PURE__ */ Symbol("class");
+const STYLE_CACHE = /* @__PURE__ */ Symbol("style");
+const TEXT_CACHE = /* @__PURE__ */ Symbol("text");
 const STALE_REACTION = new class StaleReactionError extends Error {
   name = "StaleReactionError";
   message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
@@ -610,6 +614,21 @@ const ELEMENT_IS_NAMESPACED = 1;
 const ELEMENT_PRESERVE_ATTRIBUTE_CASE = 1 << 1;
 const ELEMENT_IS_INPUT = 1 << 2;
 const UNINITIALIZED = /* @__PURE__ */ Symbol();
+function derived_inert() {
+  {
+    console.warn(`https://svelte.dev/e/derived_inert`);
+  }
+}
+function hydration_mismatch(location) {
+  {
+    console.warn(`https://svelte.dev/e/hydration_mismatch`);
+  }
+}
+function svelte_boundary_reset_noop() {
+  {
+    console.warn(`https://svelte.dev/e/svelte_boundary_reset_noop`);
+  }
+}
 let tracing_mode_flag = false;
 let component_context = null;
 function set_component_context(context) {
@@ -733,8 +752,10 @@ function defer_effect(effect, dirty_effects, maybe_dirty_effects) {
   clear_marked(effect.deps);
   set_signal_status(effect, CLEAN);
 }
-const batches = /* @__PURE__ */ new Set();
+let first_batch = null;
+let last_batch = null;
 let current_batch = null;
+let previous_batch = null;
 let batch_values = null;
 let last_scheduled_effect = null;
 let is_flushing_sync = false;
@@ -745,6 +766,15 @@ var flush_count = 0;
 let uid = 1;
 class Batch {
   id = uid++;
+  /** True as soon as `#process` was called */
+  #started = false;
+  linked = true;
+  /** @type {Batch | null} */
+  #prev = null;
+  /** @type {Batch | null} */
+  #next = null;
+  /** @type {Map<Effect, ReturnType<typeof deferred<any>>>} */
+  async_deriveds = /* @__PURE__ */ new Map();
   /**
    * The current values of any signals that are updated in this batch.
    * Tuple format: [value, is_derived] (note: is_derived is false for deriveds, too, if they were overridden via assignment)
@@ -758,6 +788,12 @@ class Batch {
    * @type {Map<Value, any>}
    */
   previous = /* @__PURE__ */ new Map();
+  /**
+   * Async effects which this batch doesn't take into account anymore when calculating blockers,
+   * as it has a value for it already.
+   * @type {Set<Effect>}
+   */
+  unblocked = /* @__PURE__ */ new Set();
   /**
    * When the batch is committed (and the DOM is updated), we need to remove old branches
    * and append new ones by calling the functions added inside (if/each/key/etc) blocks
@@ -770,10 +806,14 @@ class Batch {
    */
   #discard_callbacks = /* @__PURE__ */ new Set();
   /**
-   * Async effects that are currently in flight
-   * @type {Map<Effect, number>}
+   * Callbacks that should run only when a fork is committed.
+   * @type {Set<(batch: Batch) => void>}
+   */
+  #fork_commit_callbacks = /* @__PURE__ */ new Set();
+  /**
+   * The number of async effects that are currently in flight
    */
-  #pending = /* @__PURE__ */ new Map();
+  #pending = 0;
   /**
    * Async effects that are currently in flight, _not_ inside a pending boundary
    * @type {Map<Effect, number>}
@@ -790,6 +830,11 @@ class Batch {
    * @type {Effect[]}
    */
   #roots = [];
+  /**
+   * Effects created while this batch was active.
+   * @type {Effect[]}
+   */
+  #new_effects = [];
   /**
    * Deferred effects (which run after async work has completed) that are DIRTY
    * @type {Set<Effect>}
@@ -808,28 +853,27 @@ class Batch {
    * @type {Map<Effect, { d: Effect[], m: Effect[] }>}
    */
   #skipped_branches = /* @__PURE__ */ new Map();
+  /**
+   * Inverse of #skipped_branches which we need to tell prior batches to unskip them when committing
+   * @type {Set<Effect>}
+   */
+  #unskipped_branches = /* @__PURE__ */ new Set();
   is_fork = false;
   #decrement_queued = false;
-  /** @type {Set<Batch>} */
-  #blockers = /* @__PURE__ */ new Set();
   #is_deferred() {
-    return this.is_fork || this.#blocking_pending.size > 0;
-  }
-  #is_blocked() {
-    for (const batch of this.#blockers) {
-      for (const effect of batch.#blocking_pending.keys()) {
-        var skipped = false;
-        var e = effect;
-        while (e.parent !== null) {
-          if (this.#skipped_branches.has(e)) {
-            skipped = true;
-            break;
-          }
-          e = e.parent;
-        }
-        if (!skipped) {
-          return true;
+    if (this.is_fork) return true;
+    for (const effect of this.#blocking_pending.keys()) {
+      var e = effect;
+      var skipped = false;
+      while (e.parent !== null) {
+        if (this.#skipped_branches.has(e)) {
+          skipped = true;
+          break;
         }
+        e = e.parent;
+      }
+      if (!skipped) {
+        return true;
       }
     }
     return false;
@@ -842,29 +886,33 @@ class Batch {
     if (!this.#skipped_branches.has(effect)) {
       this.#skipped_branches.set(effect, { d: [], m: [] });
     }
+    this.#unskipped_branches.delete(effect);
   }
   /**
    * Remove an effect from the #skipped_branches map and reschedule
    * any tracked dirty/maybe_dirty child effects
    * @param {Effect} effect
+   * @param {(e: Effect) => void} callback
    */
-  unskip_effect(effect) {
+  unskip_effect(effect, callback = (e) => this.schedule(e)) {
     var tracked = this.#skipped_branches.get(effect);
     if (tracked) {
       this.#skipped_branches.delete(effect);
       for (var e of tracked.d) {
         set_signal_status(e, DIRTY);
-        this.schedule(e);
+        callback(e);
       }
       for (e of tracked.m) {
         set_signal_status(e, MAYBE_DIRTY);
-        this.schedule(e);
+        callback(e);
       }
     }
+    this.#unskipped_branches.add(effect);
   }
   #process() {
+    this.#started = true;
     if (flush_count++ > 1e3) {
-      batches.delete(this);
+      this.#unlink();
       infinite_loop_guard();
     }
     if (!this.#is_deferred()) {
@@ -901,40 +949,51 @@ class Batch {
     }
     collected_effects = null;
     legacy_updates = null;
-    if (this.#is_deferred() || this.#is_blocked()) {
+    if (this.#is_deferred()) {
       this.#defer_effects(render_effects);
       this.#defer_effects(effects);
       for (const [e, t] of this.#skipped_branches) {
         reset_branch(e, t);
       }
-    } else {
-      if (this.#pending.size === 0) {
-        batches.delete(this);
+      if (updates.length > 0) {
+        /** @type {unknown} */
+        current_batch.#process();
       }
-      this.#dirty_effects.clear();
-      this.#maybe_dirty_effects.clear();
-      for (const fn of this.#commit_callbacks) fn(this);
-      this.#commit_callbacks.clear();
-      flush_queued_effects(render_effects);
-      flush_queued_effects(effects);
-      this.#deferred?.resolve();
+      return;
+    }
+    const earlier_batch = this.#find_earlier_batch();
+    if (earlier_batch) {
+      earlier_batch.#merge(this);
+      return;
     }
+    this.#dirty_effects.clear();
+    this.#maybe_dirty_effects.clear();
+    for (const fn of this.#commit_callbacks) fn(this);
+    this.#commit_callbacks.clear();
+    previous_batch = this;
+    flush_queued_effects(render_effects);
+    flush_queued_effects(effects);
+    previous_batch = null;
+    this.#deferred?.resolve();
     var next_batch = (
       /** @type {Batch | null} */
       /** @type {unknown} */
       current_batch
     );
+    if (this.linked && this.#pending === 0) {
+      this.#unlink();
+    }
     if (this.#roots.length > 0) {
-      const batch2 = next_batch ??= this;
+      if (next_batch === null) {
+        next_batch = this;
+        this.#link();
+      }
+      const batch2 = next_batch;
       batch2.#roots.push(...this.#roots.filter((r2) => !batch2.#roots.includes(r2)));
     }
     if (next_batch !== null) {
-      batches.add(next_batch);
       next_batch.#process();
     }
-    if (!batches.has(this)) {
-      this.#commit();
-    }
   }
   /**
    * Traverse the effect tree, executing effects or stashing
@@ -976,6 +1035,65 @@ class Batch {
       }
     }
   }
+  #find_earlier_batch() {
+    var batch = this.#prev;
+    while (batch !== null) {
+      if (!batch.is_fork) {
+        for (const [value, [, is_derived]] of this.current) {
+          if (batch.current.has(value) && !is_derived) {
+            return batch;
+          }
+        }
+      }
+      batch = batch.#prev;
+    }
+    return null;
+  }
+  /**
+   * @param {Batch} batch
+   */
+  #merge(batch) {
+    for (const [source2, value] of batch.current) {
+      if (!this.previous.has(source2) && batch.previous.has(source2)) {
+        this.previous.set(source2, batch.previous.get(source2));
+      }
+      this.current.set(source2, value);
+    }
+    for (const [effect, deferred2] of batch.async_deriveds) {
+      const d = this.async_deriveds.get(effect);
+      if (d) deferred2.promise.then(d.resolve);
+    }
+    const mark = (value) => {
+      var reactions = value.reactions;
+      if (reactions === null) return;
+      for (const reaction of reactions) {
+        var flags = reaction.f;
+        if ((flags & DERIVED) !== 0) {
+          mark(
+            /** @type {Derived} */
+            reaction
+          );
+        } else {
+          var effect = (
+            /** @type {Effect} */
+            reaction
+          );
+          if (flags & (ASYNC | BLOCK_EFFECT) && !this.async_deriveds.has(effect)) {
+            this.#maybe_dirty_effects.delete(effect);
+            set_signal_status(effect, DIRTY);
+            this.schedule(effect);
+          }
+        }
+      }
+    };
+    for (const source2 of this.current.keys()) {
+      mark(source2);
+    }
+    this.oncommit(() => batch.discard());
+    batch.#unlink();
+    current_batch = this;
+    this.#process();
+  }
   /**
    * @param {Effect[]} effects
    */
@@ -988,16 +1106,19 @@ class Batch {
    * Associate a change to a given source with the current
    * batch, noting its previous and current values
    * @param {Value} source
-   * @param {any} old_value
+   * @param {any} value
    * @param {boolean} [is_derived]
    */
-  capture(source2, old_value, is_derived = false) {
-    if (old_value !== UNINITIALIZED && !this.previous.has(source2)) {
-      this.previous.set(source2, old_value);
+  capture(source2, value, is_derived = false) {
+    if (source2.v !== UNINITIALIZED && !this.previous.has(source2)) {
+      this.previous.set(source2, source2.v);
     }
     if ((source2.f & ERROR_VALUE) === 0) {
-      this.current.set(source2, [source2.v, is_derived]);
-      batch_values?.set(source2, source2.v);
+      this.current.set(source2, [value, is_derived]);
+      batch_values?.set(source2, value);
+    }
+    if (!this.is_fork) {
+      source2.v = value;
     }
   }
   activate() {
@@ -1009,6 +1130,7 @@ class Batch {
   }
   flush() {
     try {
+      if (browser) ;
       is_processing = true;
       current_batch = this;
       this.#process();
@@ -1026,10 +1148,18 @@ class Batch {
   discard() {
     for (const fn of this.#discard_callbacks) fn(this);
     this.#discard_callbacks.clear();
-    batches.delete(this);
+    this.#fork_commit_callbacks.clear();
+    this.#unlink();
+  }
+  /**
+   * @param {Effect} effect
+   */
+  register_created_effect(effect) {
+    this.#new_effects.push(effect);
   }
   #commit() {
-    for (const batch of batches) {
+    this.#unlink();
+    for (let batch = first_batch; batch !== null; batch = batch.#next) {
       var is_earlier = batch.id < this.id;
       var sources = [];
       for (const [source3, [value, is_derived]] of this.current) {
@@ -1046,18 +1176,55 @@ class Batch {
         }
         sources.push(source3);
       }
+      if (is_earlier) {
+        for (const [effect, deferred2] of this.async_deriveds) {
+          const d = batch.async_deriveds.get(effect);
+          if (d) deferred2.promise.then(d.resolve);
+        }
+      }
+      if (!batch.#started) continue;
       var others = [...batch.current.keys()].filter((s) => !this.current.has(s));
       if (others.length === 0) {
         if (is_earlier) {
           batch.discard();
         }
       } else if (sources.length > 0) {
+        if (is_earlier) {
+          for (const unskipped of this.#unskipped_branches) {
+            batch.unskip_effect(unskipped, (e) => {
+              if ((e.f & (BLOCK_EFFECT | ASYNC)) !== 0) {
+                batch.schedule(e);
+              } else {
+                batch.#defer_effects([e]);
+              }
+            });
+          }
+        }
         batch.activate();
         var marked = /* @__PURE__ */ new Set();
         var checked = /* @__PURE__ */ new Map();
         for (var source2 of sources) {
           mark_effects(source2, others, marked, checked);
         }
+        checked = /* @__PURE__ */ new Map();
+        var current_unequal = [...batch.current.keys()].filter(
+          (c) => this.current.has(c) ? (
+            /** @type {[any, boolean]} */
+            this.current.get(c)[0] !== c.v
+          ) : true
+        );
+        if (current_unequal.length > 0) {
+          for (const effect of this.#new_effects) {
+            if ((effect.f & (DESTROYED | INERT | EAGER_EFFECT)) === 0 && depends_on(effect, current_unequal, checked)) {
+              if ((effect.f & (ASYNC | BLOCK_EFFECT)) !== 0) {
+                set_signal_status(effect, DIRTY);
+                batch.schedule(effect);
+              } else {
+                batch.#dirty_effects.add(effect);
+              }
+            }
+          }
+        }
         if (batch.#roots.length > 0) {
           batch.apply();
           for (var root of batch.#roots) {
@@ -1068,23 +1235,13 @@ class Batch {
         batch.deactivate();
       }
     }
-    for (const batch of batches) {
-      if (batch.#blockers.has(this)) {
-        batch.#blockers.delete(this);
-        if (batch.#blockers.size === 0 && !batch.#is_deferred()) {
-          batch.activate();
-          batch.#process();
-        }
-      }
-    }
   }
   /**
    * @param {boolean} blocking
    * @param {Effect} effect
    */
   increment(blocking, effect) {
-    let pending_count = this.#pending.get(effect) ?? 0;
-    this.#pending.set(effect, pending_count + 1);
+    this.#pending += 1;
     if (blocking) {
       let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;
       this.#blocking_pending.set(effect, blocking_pending_count + 1);
@@ -1093,15 +1250,9 @@ class Batch {
   /**
    * @param {boolean} blocking
    * @param {Effect} effect
-   * @param {boolean} skip - whether to skip updates (because this is triggered by a stale reaction)
    */
-  decrement(blocking, effect, skip) {
-    let pending_count = this.#pending.get(effect) ?? 0;
-    if (pending_count === 1) {
-      this.#pending.delete(effect);
-    } else {
-      this.#pending.set(effect, pending_count - 1);
-    }
+  decrement(blocking, effect) {
+    this.#pending -= 1;
     if (blocking) {
       let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;
       if (blocking_pending_count === 1) {
@@ -1110,11 +1261,13 @@ class Batch {
         this.#blocking_pending.set(effect, blocking_pending_count - 1);
       }
     }
-    if (this.#decrement_queued || skip) return;
+    if (this.#decrement_queued) return;
     this.#decrement_queued = true;
     queue_micro_task(() => {
       this.#decrement_queued = false;
-      this.flush();
+      if (this.linked) {
+        this.flush();
+      }
     });
   }
   /**
@@ -1139,22 +1292,27 @@ class Batch {
   ondiscard(fn) {
     this.#discard_callbacks.add(fn);
   }
+  /** @param {(batch: Batch) => void} fn */
+  on_fork_commit(fn) {
+    this.#fork_commit_callbacks.add(fn);
+  }
+  run_fork_commit_callbacks() {
+    for (const fn of this.#fork_commit_callbacks) fn(this);
+    this.#fork_commit_callbacks.clear();
+  }
   settled() {
     return (this.#deferred ??= deferred()).promise;
   }
   static ensure() {
     if (current_batch === null) {
       const batch = current_batch = new Batch();
-      if (!is_processing) {
-        batches.add(current_batch);
-        if (!is_flushing_sync) {
-          queue_micro_task(() => {
-            if (current_batch !== batch) {
-              return;
-            }
+      batch.#link();
+      if (!is_processing && !is_flushing_sync) {
+        queue_micro_task(() => {
+          if (!batch.#started) {
             batch.flush();
-          });
-        }
+          }
+        });
       }
     }
     return current_batch;
@@ -1193,6 +1351,30 @@ class Batch {
     }
     this.#roots.push(e);
   }
+  #link() {
+    if (last_batch === null) {
+      first_batch = last_batch = this;
+    } else {
+      last_batch.#next = this;
+      this.#prev = last_batch;
+    }
+    last_batch = this;
+  }
+  #unlink() {
+    var prev = this.#prev;
+    var next = this.#next;
+    if (prev === null) {
+      first_batch = next;
+    } else {
+      prev.#next = next;
+    }
+    if (next === null) {
+      last_batch = prev;
+    } else {
+      next.#prev = prev;
+    }
+    this.linked = false;
+  }
 }
 function flushSync(fn) {
   var was_flushing_sync = is_flushing_sync;
@@ -1348,23 +1530,15 @@ function destroy_derived_effects(derived2) {
     }
   }
 }
-function get_derived_parent_effect(derived2) {
-  var parent = derived2.parent;
-  while (parent !== null) {
-    if ((parent.f & DERIVED) === 0) {
-      return (parent.f & DESTROYED) === 0 ? (
-        /** @type {Effect} */
-        parent
-      ) : null;
-    }
-    parent = parent.parent;
-  }
-  return null;
-}
 function execute_derived(derived2) {
   var value;
   var prev_active_effect = active_effect;
-  set_active_effect(get_derived_parent_effect(derived2));
+  var parent = derived2.parent;
+  if (!is_destroying_effect && parent !== null && (parent.f & (DESTROYED | INERT)) !== 0) {
+    derived_inert();
+    return derived2.v;
+  }
+  set_active_effect(parent);
   {
     try {
       derived2.f &= ~WAS_MARKED;
@@ -1377,13 +1551,16 @@ function execute_derived(derived2) {
   return value;
 }
 function update_derived(derived2) {
-  var old_value = derived2.v;
   var value = execute_derived(derived2);
   if (!derived2.equals(value)) {
     derived2.wv = increment_write_version();
     if (!current_batch?.is_fork || derived2.deps === null) {
-      derived2.v = value;
-      current_batch?.capture(derived2, old_value, true);
+      if (current_batch !== null) {
+        current_batch.capture(derived2, value, true);
+        previous_batch?.capture(derived2, value, true);
+      } else {
+        derived2.v = value;
+      }
       if (derived2.deps === null) {
         set_signal_status(derived2, CLEAN);
         return;
@@ -1462,15 +1639,9 @@ function set(source2, value, should_proxy = false) {
 }
 function internal_set(source2, value, updated_during_traversal = null) {
   if (!source2.equals(value)) {
-    var old_value = source2.v;
-    if (is_destroying_effect) {
-      old_values.set(source2, value);
-    } else {
-      old_values.set(source2, old_value);
-    }
-    source2.v = value;
+    old_values.set(source2, is_destroying_effect ? value : source2.v);
     var batch = Batch.ensure();
-    batch.capture(source2, old_value);
+    batch.capture(source2, value);
     if ((source2.f & DERIVED) !== 0) {
       const derived2 = (
         /** @type {Derived} */
@@ -1504,7 +1675,13 @@ function flush_eager_effects() {
     if ((effect.f & CLEAN) !== 0) {
       set_signal_status(effect, MAYBE_DIRTY);
     }
-    if (is_dirty(effect)) {
+    let dirty;
+    try {
+      dirty = is_dirty(effect);
+    } catch {
+      dirty = true;
+    }
+    if (dirty) {
       update_effect(effect);
     }
   }
@@ -1524,14 +1701,19 @@ function mark_reactions(signal, status, updated_during_traversal) {
     if (not_dirty) {
       set_signal_status(reaction, status);
     }
-    if ((flags & DERIVED) !== 0) {
+    if ((flags & EAGER_EFFECT) !== 0) {
+      eager_effects.add(
+        /** @type {Effect} */
+        reaction
+      );
+    } else if ((flags & DERIVED) !== 0) {
       var derived2 = (
         /** @type {Derived} */
         reaction
       );
       batch_values?.delete(derived2);
       if ((flags & WAS_MARKED) === 0) {
-        if (flags & CONNECTED) {
+        if (flags & CONNECTED && (active_effect === null || (active_effect.f & REACTION_IS_UPDATING) === 0)) {
           reaction.f |= WAS_MARKED;
         }
         mark_reactions(derived2, MAYBE_DIRTY, updated_during_traversal);
@@ -1756,14 +1938,13 @@ function init_operations() {
   first_child_getter = get_descriptor(node_prototype, "firstChild").get;
   next_sibling_getter = get_descriptor(node_prototype, "nextSibling").get;
   if (is_extensible(element_prototype)) {
-    element_prototype.__click = void 0;
-    element_prototype.__className = void 0;
-    element_prototype.__attributes = null;
-    element_prototype.__style = void 0;
+    element_prototype[CLASS_CACHE] = void 0;
+    element_prototype[ATTRIBUTES_CACHE] = null;
+    element_prototype[STYLE_CACHE] = void 0;
     element_prototype.__e = void 0;
   }
   if (is_extensible(text_prototype)) {
-    text_prototype.__t = void 0;
+    text_prototype[TEXT_CACHE] = void 0;
   }
 }
 function create_text(value = "") {
@@ -1829,6 +2010,7 @@ function create_effect(type, fn) {
     wv: 0,
     ac: null
   };
+  current_batch?.register_created_effect(effect);
   var e = effect;
   if ((type & EFFECT) !== 0) {
     if (collected_effects !== null) {
@@ -2020,11 +2202,13 @@ function pause_children(effect, transitions, local) {
   var child = effect.first;
   while (child !== null) {
     var sibling = child.next;
-    var transparent = (child.f & EFFECT_TRANSPARENT) !== 0 || // If this is a branch effect without a block effect parent,
-    // it means the parent block effect was pruned. In that case,
-    // transparency information was transferred to the branch effect.
-    (child.f & BRANCH_EFFECT) !== 0 && (effect.f & BLOCK_EFFECT) !== 0;
-    pause_children(child, transitions, transparent ? local : false);
+    if ((child.f & ROOT_EFFECT) === 0) {
+      var transparent = (child.f & EFFECT_TRANSPARENT) !== 0 || // If this is a branch effect without a block effect parent,
+      // it means the parent block effect was pruned. In that case,
+      // transparency information was transferred to the branch effect.
+      (child.f & BRANCH_EFFECT) !== 0 && (effect.f & BLOCK_EFFECT) !== 0;
+      pause_children(child, transitions, transparent ? local : false);
+    }
     child = sibling;
   }
 }
@@ -2274,7 +2458,9 @@ function remove_reaction(signal, dependency) {
       derived2.f ^= CONNECTED;
       derived2.f &= ~WAS_MARKED;
     }
-    update_derived_status(derived2);
+    if (derived2.v !== UNINITIALIZED) {
+      update_derived_status(derived2);
+    }
     freeze_derived_effects(derived2);
     remove_reactions(derived2, 0);
   }
@@ -2664,6 +2850,13 @@ https://svelte.dev/e/invalid_csp`);
   error.name = "Svelte error";
   throw error;
 }
+function invalid_id_prefix() {
+  const error = new Error(`invalid_id_prefix
+The \`idPrefix\` option cannot include \`--\`.
+https://svelte.dev/e/invalid_id_prefix`);
+  error.name = "Svelte error";
+  throw error;
+}
 function server_context_required() {
   const error = new Error(`server_context_required
 Could not resolve \`render\` context.
@@ -3106,9 +3299,11 @@ class Renderer {
       );
     }
     this.local = other.local;
-    this.#out = other.#out.map((item) => {
-      if (item instanceof Renderer) {
-        item.subsume(item);
+    this.#out = other.#out.map((item, i) => {
+      const current = this.#out[i];
+      if (current instanceof Renderer && item instanceof Renderer) {
+        current.subsume(item);
+        return current;
       }
       return item;
     });
@@ -3313,7 +3508,10 @@ class Renderer {
           } catch (error) {
             const { context, failed, transformError } = item.#boundary;
             set_ssr_context(context);
-            let transformed = await transformError(error);
+            let promise = transformError(error);
+            set_ssr_context(null);
+            let transformed = await promise;
+            set_ssr_context(context);
             const failed_renderer = new Renderer(item.global, item);
             failed_renderer.type = item.type;
             failed_renderer.#out.push(Renderer.#serialize_failed_boundary(transformed));
@@ -3346,6 +3544,9 @@ class Renderer {
    * @returns {Renderer}
    */
   static #open_render(mode, component, options) {
+    if (options.idPrefix?.includes("--")) {
+      invalid_id_prefix();
+    }
     var previous_context = ssr_context;
     try {
       const renderer = new Renderer(
@@ -3520,7 +3721,7 @@ function attributes(attrs, css_hash, classes, styles, flags = 0) {
   for (name of Object.keys(attrs)) {
     if (typeof attrs[name] === "function") continue;
     if (name[0] === "$" && name[1] === "$") continue;
-    if (INVALID_ATTR_NAME_CHAR_REGEX.test(name)) continue;
+    if (name === "" || INVALID_ATTR_NAME_CHAR_REGEX.test(name)) continue;
     var value = attrs[name];
     var lower = name.toLowerCase();
     if (lowercase) name = lower;
@@ -3621,5 +3822,5 @@ function derived(fn) {
   };
 }
 
-export { BOUNDARY_EFFECT as $, define_property as A, mutable_source as B, init_operations as C, DevalueError as D, get_first_child as E, COMMENT_NODE as F, HYDRATION_START as G, HOLE as H, get_next_sibling as I, HYDRATION_ERROR as J, hydration_failed as K, LEGACY_PROPS as L, MAX_ARRAY_INDEX as M, NAN as N, clear_text_content as O, POSITIVE_INFINITY as P, component_root as Q, create_text as R, SPARSE as S, array_from as T, UNDEFINED as U, is_passive_event as V, set_active_reaction as W, set_active_effect as X, active_reaction as Y, active_effect as Z, setContext as _, NEGATIVE_INFINITY as a, block as a0, branch as a1, queue_micro_task as a2, pause_effect as a3, current_batch as a4, move_effect as a5, defer_effect as a6, set_component_context as a7, Batch as a8, handle_error as a9, component_context as aa, internal_set as ab, destroy_effect as ac, invoke_error_boundary as ad, effect_tracking as ae, render_effect as af, HYDRATION_END as ag, HYDRATION_START_ELSE as ah, svelte_boundary_reset_onerror as ai, source as aj, untrack as ak, increment as al, HYDRATION_START_FAILED as am, push$1 as an, pop$1 as ao, EFFECT_TRANSPARENT as ap, EFFECT_PRESERVED as aq, noop as ar, safe_not_equal as as, attr as at, bind_props as au, spread_props as av, ssr_context as aw, attr_style as ax, clsx as ay, NEGATIVE_ZERO as b, is_valid_array_index as c, is_primitive as d, is_plain_object as e, enumerable_symbols as f, get_type as g, stringify_string as h, is_valid_array_len as i, browser as j, stringify as k, store_get as l, attr_class as m, unsubscribe_stores as n, head as o, escape_html as p, getContext as q, derived as r, stringify_key as s, ensure_array_like as t, uneval as u, valid_array_indices as v, render as w, set as x, get as y, flushSync as z };
-//# sourceMappingURL=index-Ce_T9BSa.js.map
+export { setContext as $, define_property as A, mutable_source as B, init_operations as C, DevalueError as D, get_first_child as E, COMMENT_NODE as F, HYDRATION_START as G, HOLE as H, get_next_sibling as I, HYDRATION_ERROR as J, hydration_failed as K, LEGACY_PROPS as L, MAX_ARRAY_INDEX as M, NAN as N, clear_text_content as O, POSITIVE_INFINITY as P, hydration_mismatch as Q, component_root as R, SPARSE as S, create_text as T, UNDEFINED as U, array_from as V, is_passive_event as W, set_active_reaction as X, set_active_effect as Y, active_reaction as Z, active_effect as _, NEGATIVE_INFINITY as a, BOUNDARY_EFFECT as a0, block as a1, branch as a2, queue_micro_task as a3, pause_effect as a4, current_batch as a5, move_effect as a6, defer_effect as a7, set_component_context as a8, Batch as a9, clsx as aA, handle_error as aa, component_context as ab, internal_set as ac, destroy_effect as ad, invoke_error_boundary as ae, effect_tracking as af, render_effect as ag, HYDRATION_END as ah, HYDRATION_START_ELSE as ai, svelte_boundary_reset_onerror as aj, source as ak, untrack as al, increment as am, HYDRATION_START_FAILED as an, svelte_boundary_reset_noop as ao, push$1 as ap, pop$1 as aq, EFFECT_TRANSPARENT as ar, EFFECT_PRESERVED as as, noop as at, safe_not_equal as au, attr as av, bind_props as aw, spread_props as ax, ssr_context as ay, attr_style as az, NEGATIVE_ZERO as b, is_valid_array_index as c, is_primitive as d, is_plain_object as e, enumerable_symbols as f, get_type as g, stringify_string as h, is_valid_array_len as i, browser as j, stringify as k, store_get as l, attr_class as m, unsubscribe_stores as n, head as o, escape_html as p, getContext as q, derived as r, stringify_key as s, ensure_array_like as t, uneval as u, valid_array_indices as v, render as w, set as x, get as y, flushSync as z };
+//# sourceMappingURL=index-DMikC9Qy.js.map