@juspay/shooter 1.9.1 → 1.9.3

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

@@ -1,4 +1,13 @@
 const browser = false;
+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 MAX_ARRAY_LEN = 2 ** 32 - 1;
+const MAX_ARRAY_INDEX = MAX_ARRAY_LEN - 1;
 const escaped = {
   "<": "\\u003C",
   "\\": "\\\\",
@@ -26,11 +35,9 @@ class DevalueError extends Error {
   }
 }
 function is_primitive(thing) {
-  return Object(thing) !== thing;
+  return thing === null || typeof thing !== "object" && typeof thing !== "function";
 }
-const object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(
-  Object.prototype
-).sort().join("\0");
+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;
@@ -87,22 +94,31 @@ 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 is_valid_array_index(s) {
+function is_valid_array_index(n) {
+  if (!Number.isInteger(n)) return false;
+  if (n < 0) return false;
+  if (n > MAX_ARRAY_INDEX) return false;
+  return true;
+}
+function is_valid_array_len(n) {
+  if (!Number.isInteger(n)) return false;
+  if (n < 0) return false;
+  if (n > MAX_ARRAY_LEN) return false;
+  return true;
+}
+function is_valid_array_index_string(s) {
   if (s.length === 0) return false;
   if (s.length > 1 && s.charCodeAt(0) === 48) return false;
   for (let i = 0; i < s.length; i++) {
     const c = s.charCodeAt(i);
     if (c < 48 || c > 57) return false;
   }
-  const n = +s;
-  if (n >= 2 ** 32 - 1) return false;
-  if (n < 0) return false;
-  return true;
+  return is_valid_array_index(+s);
 }
 function valid_array_indices(array) {
   const keys = Object.keys(array);
   for (var i = keys.length - 1; i >= 0; i--) {
-    if (is_valid_array_index(keys[i])) {
+    if (is_valid_array_index_string(keys[i])) {
       break;
     }
   }
@@ -157,9 +173,7 @@ function uneval(value, replacer) {
           break;
         case "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) : "..."})`);
             walk(value2);
             keys.pop();
           }
@@ -169,12 +183,14 @@ function uneval(value, replacer) {
         case "Uint8ClampedArray":
         case "Int16Array":
         case "Uint16Array":
+        case "Float16Array":
         case "Int32Array":
         case "Uint32Array":
         case "Float32Array":
         case "Float64Array":
         case "BigInt64Array":
         case "BigUint64Array":
+        case "DataView":
           walk(thing.buffer);
           return;
         case "ArrayBuffer":
@@ -190,20 +206,10 @@ function uneval(value, replacer) {
           return;
         default:
           if (!is_plain_object(thing)) {
-            throw new DevalueError(
-              `Cannot stringify arbitrary non-POJOs`,
-              keys,
-              thing,
-              value
-            );
+            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);
           }
           for (const key of Object.keys(thing)) {
             if (key === "__proto__") {
@@ -219,6 +225,8 @@ function uneval(value, replacer) {
             keys.pop();
           }
       }
+    } else if (typeof thing === "symbol") {
+      throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
     }
   }
   walk(value);
@@ -241,9 +249,11 @@ function uneval(value, replacer) {
       case "Number":
       case "String":
       case "Boolean":
+      case "BigInt":
         return `Object(${stringify2(thing.valueOf())})`;
       case "RegExp":
-        return `new RegExp(${stringify_string(thing.source)}, "${thing.flags}")`;
+        const { source: source2, flags } = thing;
+        return flags ? `new RegExp(${stringify_string(source2)},"${flags}")` : `new RegExp(${stringify_string(source2)})`;
       case "Date":
         return `new Date(${thing.getTime()})`;
       case "URL":
@@ -285,6 +295,7 @@ function uneval(value, replacer) {
       case "Uint8ClampedArray":
       case "Int16Array":
       case "Uint16Array":
+      case "Float16Array":
       case "Int32Array":
       case "Uint32Array":
       case "Float32Array":
@@ -292,20 +303,31 @@ function uneval(value, replacer) {
       case "BigInt64Array":
       case "BigUint64Array": {
         let str2 = `new ${type}`;
-        if (counts.get(thing.buffer) === 1) {
+        if (!names.has(thing.buffer)) {
           const array = new thing.constructor(thing.buffer);
           str2 += `([${array}])`;
         } else {
-          str2 += `([${stringify2(thing.buffer)}])`;
+          str2 += `(${stringify2(thing.buffer)})`;
         }
-        const a = thing.byteOffset;
-        const b = a + thing.byteLength;
-        if (a > 0 || b !== thing.buffer.byteLength) {
-          const m = +/(\d+)/.exec(type)[1] / 8;
-          str2 += `.subarray(${a / m},${b / m})`;
+        if (thing.byteLength !== thing.buffer.byteLength) {
+          const start = thing.byteOffset / thing.BYTES_PER_ELEMENT;
+          const end = start + thing.length;
+          str2 += `.subarray(${start},${end})`;
         }
         return str2;
       }
+      case "DataView": {
+        let str2 = `new DataView`;
+        if (!names.has(thing.buffer)) {
+          str2 += `(new Uint8Array([${new Uint8Array(thing.buffer)}]).buffer`;
+        } else {
+          str2 += `(${stringify2(thing.buffer)}`;
+        }
+        if (thing.byteLength !== thing.buffer.byteLength) {
+          str2 += `,${thing.startOffset},${thing.byteLength}`;
+        }
+        return str2 + ")";
+      }
       case "ArrayBuffer": {
         const ui8 = new Uint8Array(thing);
         return `new Uint8Array([${ui8.toString()}]).buffer`;
@@ -352,14 +374,23 @@ function uneval(value, replacer) {
         case "Number":
         case "String":
         case "Boolean":
+        case "BigInt":
           values.push(`Object(${stringify2(thing.valueOf())})`);
           break;
         case "RegExp":
-          values.push(thing.toString());
+          const { source: source2, flags } = thing;
+          const regexp = flags ? `new RegExp(${stringify_string(source2)},"${flags}")` : `new RegExp(${stringify_string(source2)})`;
+          values.push(regexp);
           break;
         case "Date":
           values.push(`new Date(${thing.getTime()})`);
           break;
+        case "URL":
+          values.push(`new URL(${stringify_string(thing.toString())})`);
+          break;
+        case "URLSearchParams":
+          values.push(`new URLSearchParams(${stringify_string(thing.toString())})`);
+          break;
         case "Array":
           values.push(`Array(${thing.length})`);
           thing.forEach((v, i) => {
@@ -378,26 +409,61 @@ function uneval(value, replacer) {
             `${name}.${Array.from(thing).map(([k, v]) => `set(${stringify2(k)}, ${stringify2(v)})`).join(".")}`
           );
           break;
+        case "Int8Array":
+        case "Uint8Array":
+        case "Uint8ClampedArray":
+        case "Int16Array":
+        case "Uint16Array":
+        case "Float16Array":
+        case "Int32Array":
+        case "Uint32Array":
+        case "Float32Array":
+        case "Float64Array":
+        case "BigInt64Array":
+        case "BigUint64Array": {
+          let str2 = `new ${type}`;
+          if (!names.has(thing.buffer)) {
+            const array = new thing.constructor(thing.buffer);
+            str2 += `([${array}])`;
+          } else {
+            str2 += `(${stringify2(thing.buffer)})`;
+          }
+          if (thing.byteLength !== thing.buffer.byteLength) {
+            const start = thing.byteOffset / thing.BYTES_PER_ELEMENT;
+            const end = start + thing.length;
+            str2 += `.subarray(${start},${end})`;
+          }
+          values.push(`{}`);
+          statements.push(`${name}=${str2}`);
+          break;
+        }
+        case "DataView": {
+          let str2 = `new DataView`;
+          if (!names.has(thing.buffer)) {
+            str2 += `(new Uint8Array([${new Uint8Array(thing.buffer)}]).buffer`;
+          } else {
+            str2 += `(${stringify2(thing.buffer)}`;
+          }
+          if (thing.byteLength !== thing.buffer.byteLength) {
+            str2 += `,${thing.byteOffset},${thing.byteLength}`;
+          }
+          str2 += ")";
+          values.push(`{}`);
+          statements.push(`${name}=${str2}`);
+          break;
+        }
         case "ArrayBuffer":
-          values.push(
-            `new Uint8Array([${new Uint8Array(thing).join(",")}]).buffer`
-          );
+          values.push(`new Uint8Array([${new Uint8Array(thing)}]).buffer`);
           break;
         default:
-          values.push(
-            Object.getPrototypeOf(thing) === null ? "Object.create(null)" : "{}"
-          );
+          values.push(Object.getPrototypeOf(thing) === null ? "Object.create(null)" : "{}");
           Object.keys(thing).forEach((key) => {
-            statements.push(
-              `${name}${safe_prop(key)}=${stringify2(thing[key])}`
-            );
+            statements.push(`${name}${safe_prop(key)}=${stringify2(thing[key])}`);
           });
       }
     });
     statements.push(`return ${str}`);
-    return `(function(${params.join(",")}){${statements.join(
-      ";"
-    )}}(${values.join(",")}))`;
+    return `(function(${params.join(",")}){${statements.join(";")}}(${values.join(",")}))`;
   } else {
     return str;
   }
@@ -423,12 +489,13 @@ function safe_prop(key) {
   return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? `.${key}` : `[${escape_unsafe_chars(JSON.stringify(key))}]`;
 }
 function stringify_primitive(thing) {
-  if (typeof thing === "string") return stringify_string(thing);
+  const type = typeof thing;
+  if (type === "string") return stringify_string(thing);
   if (thing === void 0) return "void 0";
   if (thing === 0 && 1 / thing < 0) return "-0";
   const str = String(thing);
-  if (typeof thing === "number") return str.replace(/^(-)?0\./, "$1.");
-  if (typeof thing === "bigint") return thing + "n";
+  if (type === "number") return str.replace(/^(-)?0\./, "$1.");
+  if (type === "bigint") return thing + "n";
   return str;
 }
 var is_array = Array.isArray;
@@ -494,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";
@@ -543,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) {
@@ -666,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;
@@ -678,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)
@@ -691,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
@@ -703,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>}
    */
-  #pending = /* @__PURE__ */ new Map();
+  #fork_commit_callbacks = /* @__PURE__ */ new Set();
+  /**
+   * The number of async effects that are currently in flight
+   */
+  #pending = 0;
   /**
    * Async effects that are currently in flight, _not_ inside a pending boundary
    * @type {Map<Effect, number>}
@@ -723,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>}
@@ -741,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;
@@ -775,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()) {
@@ -834,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
@@ -909,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
    */
@@ -921,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() {
@@ -942,6 +1130,7 @@ class Batch {
   }
   flush() {
     try {
+      if (browser) ;
       is_processing = true;
       current_batch = this;
       this.#process();
@@ -959,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) {
@@ -979,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) {
@@ -1001,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);
@@ -1026,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) {
@@ -1043,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();
+      }
     });
   }
   /**
@@ -1072,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;
@@ -1126,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;
@@ -1281,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;
@@ -1310,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;
@@ -1395,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} */
@@ -1437,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);
     }
   }
@@ -1457,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);
@@ -1689,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 = "") {
@@ -1762,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) {
@@ -1953,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;
   }
 }
@@ -2207,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);
   }
@@ -2597,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.
@@ -3039,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;
     });
@@ -3246,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));
@@ -3279,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(
@@ -3453,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;
@@ -3554,5 +3822,5 @@ function derived(fn) {
   };
 }
 
-export { handle_error as $, get_next_sibling as A, HYDRATION_ERROR as B, COMMENT_NODE as C, DevalueError as D, hydration_failed as E, clear_text_content as F, component_root as G, HYDRATION_START as H, create_text as I, array_from as J, is_passive_event as K, LEGACY_PROPS as L, set_active_reaction as M, set_active_effect as N, active_reaction as O, active_effect as P, setContext as Q, BOUNDARY_EFFECT as R, block as S, branch as T, queue_micro_task as U, pause_effect as V, current_batch as W, move_effect as X, defer_effect as Y, set_component_context as Z, Batch as _, is_plain_object as a, component_context as a0, internal_set as a1, destroy_effect as a2, invoke_error_boundary as a3, effect_tracking as a4, render_effect as a5, HYDRATION_END as a6, HYDRATION_START_ELSE as a7, svelte_boundary_reset_onerror as a8, source as a9, untrack as aa, increment as ab, HYDRATION_START_FAILED as ac, push$1 as ad, pop$1 as ae, EFFECT_TRANSPARENT as af, EFFECT_PRESERVED as ag, noop as ah, safe_not_equal as ai, attr as aj, bind_props as ak, spread_props as al, ssr_context as am, attr_style as an, clsx as ao, stringify_string as b, browser as c, stringify as d, enumerable_symbols as e, store_get as f, get_type as g, attr_class as h, is_primitive as i, unsubscribe_stores as j, head as k, escape_html as l, getContext as m, derived as n, ensure_array_like as o, set as p, get as q, render as r, stringify_key as s, flushSync as t, uneval as u, valid_array_indices as v, define_property as w, mutable_source as x, init_operations as y, get_first_child as z };
-//# sourceMappingURL=index-BHoOpAe1.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