heroshot 0.0.2-alpha.1 → 0.0.2-alpha.2

package/toolbar/dist/toolbar.js

@@ -0,0 +1,4019 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+(function(exports) {
+  "use strict";
+  var _commit_callbacks, _discard_callbacks, _pending, _blocking_pending, _deferred, _dirty_effects, _maybe_dirty_effects, _Batch_instances, traverse_effect_tree_fn, defer_effects_fn, clear_marked_fn, resolve_fn, commit_fn, _pending2, _anchor, _hydrate_open, _props, _children, _effect, _main_effect, _pending_effect, _failed_effect, _offscreen_fragment, _pending_anchor, _local_pending_count, _pending_count, _is_creating_fallback, _effect_pending, _effect_pending_subscriber, _Boundary_instances, hydrate_resolved_content_fn, hydrate_pending_content_fn, get_anchor_fn, run_fn, show_pending_snippet_fn, update_pending_count_fn, _batches, _onscreen, _offscreen, _outroing, _transition, _commit, _discard, _a;
+  const DEV = false;
+  var is_array = Array.isArray;
+  var index_of = Array.prototype.indexOf;
+  var array_from = Array.from;
+  var define_property = Object.defineProperty;
+  var get_descriptor = Object.getOwnPropertyDescriptor;
+  var object_prototype = Object.prototype;
+  var array_prototype = Array.prototype;
+  var get_prototype_of = Object.getPrototypeOf;
+  var is_extensible = Object.isExtensible;
+  function run_all(arr) {
+    for (var i = 0; i < arr.length; i++) {
+      arr[i]();
+    }
+  }
+  function deferred() {
+    var resolve;
+    var reject;
+    var promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return { promise, resolve, reject };
+  }
+  const DERIVED = 1 << 1;
+  const EFFECT = 1 << 2;
+  const RENDER_EFFECT = 1 << 3;
+  const MANAGED_EFFECT = 1 << 24;
+  const BLOCK_EFFECT = 1 << 4;
+  const BRANCH_EFFECT = 1 << 5;
+  const ROOT_EFFECT = 1 << 6;
+  const BOUNDARY_EFFECT = 1 << 7;
+  const CONNECTED = 1 << 9;
+  const CLEAN = 1 << 10;
+  const DIRTY = 1 << 11;
+  const MAYBE_DIRTY = 1 << 12;
+  const INERT = 1 << 13;
+  const DESTROYED = 1 << 14;
+  const EFFECT_RAN = 1 << 15;
+  const EFFECT_TRANSPARENT = 1 << 16;
+  const EAGER_EFFECT = 1 << 17;
+  const HEAD_EFFECT = 1 << 18;
+  const EFFECT_PRESERVED = 1 << 19;
+  const USER_EFFECT = 1 << 20;
+  const EFFECT_OFFSCREEN = 1 << 25;
+  const WAS_MARKED = 1 << 15;
+  const REACTION_IS_UPDATING = 1 << 21;
+  const ASYNC = 1 << 22;
+  const ERROR_VALUE = 1 << 23;
+  const STATE_SYMBOL = Symbol("$state");
+  const STALE_REACTION = new class StaleReactionError extends Error {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "name", "StaleReactionError");
+      __publicField(this, "message", "The reaction that called `getAbortSignal()` was re-run or destroyed");
+    }
+  }();
+  function async_derived_orphan() {
+    {
+      throw new Error(`https://svelte.dev/e/async_derived_orphan`);
+    }
+  }
+  function effect_in_teardown(rune) {
+    {
+      throw new Error(`https://svelte.dev/e/effect_in_teardown`);
+    }
+  }
+  function effect_in_unowned_derived() {
+    {
+      throw new Error(`https://svelte.dev/e/effect_in_unowned_derived`);
+    }
+  }
+  function effect_orphan(rune) {
+    {
+      throw new Error(`https://svelte.dev/e/effect_orphan`);
+    }
+  }
+  function effect_update_depth_exceeded() {
+    {
+      throw new Error(`https://svelte.dev/e/effect_update_depth_exceeded`);
+    }
+  }
+  function state_descriptors_fixed() {
+    {
+      throw new Error(`https://svelte.dev/e/state_descriptors_fixed`);
+    }
+  }
+  function state_prototype_fixed() {
+    {
+      throw new Error(`https://svelte.dev/e/state_prototype_fixed`);
+    }
+  }
+  function state_unsafe_mutation() {
+    {
+      throw new Error(`https://svelte.dev/e/state_unsafe_mutation`);
+    }
+  }
+  function svelte_boundary_reset_onerror() {
+    {
+      throw new Error(`https://svelte.dev/e/svelte_boundary_reset_onerror`);
+    }
+  }
+  const EACH_ITEM_REACTIVE = 1;
+  const EACH_INDEX_REACTIVE = 1 << 1;
+  const EACH_ITEM_IMMUTABLE = 1 << 4;
+  const TEMPLATE_FRAGMENT = 1;
+  const TEMPLATE_USE_IMPORT_NODE = 1 << 1;
+  const UNINITIALIZED = Symbol();
+  function svelte_boundary_reset_noop() {
+    {
+      console.warn(`https://svelte.dev/e/svelte_boundary_reset_noop`);
+    }
+  }
+  function equals(value) {
+    return value === this.v;
+  }
+  function safe_not_equal(a, b) {
+    return a != a ? b == b : a !== b || a !== null && typeof a === "object" || typeof a === "function";
+  }
+  function safe_equals(value) {
+    return !safe_not_equal(value, this.v);
+  }
+  let tracing_mode_flag = false;
+  let component_context = null;
+  function set_component_context(context) {
+    component_context = context;
+  }
+  function push(props, runes = false, fn) {
+    component_context = {
+      p: component_context,
+      i: false,
+      c: null,
+      e: null,
+      s: props,
+      x: null,
+      l: null
+    };
+  }
+  function pop(component) {
+    var context = (
+      /** @type {ComponentContext} */
+      component_context
+    );
+    var effects = context.e;
+    if (effects !== null) {
+      context.e = null;
+      for (var fn of effects) {
+        create_user_effect(fn);
+      }
+    }
+    context.i = true;
+    component_context = context.p;
+    return (
+      /** @type {T} */
+      {}
+    );
+  }
+  function is_runes() {
+    return true;
+  }
+  let micro_tasks = [];
+  function run_micro_tasks() {
+    var tasks = micro_tasks;
+    micro_tasks = [];
+    run_all(tasks);
+  }
+  function queue_micro_task(fn) {
+    if (micro_tasks.length === 0 && !is_flushing_sync) {
+      var tasks = micro_tasks;
+      queueMicrotask(() => {
+        if (tasks === micro_tasks) run_micro_tasks();
+      });
+    }
+    micro_tasks.push(fn);
+  }
+  function flush_tasks() {
+    while (micro_tasks.length > 0) {
+      run_micro_tasks();
+    }
+  }
+  function handle_error(error) {
+    var effect2 = active_effect;
+    if (effect2 === null) {
+      active_reaction.f |= ERROR_VALUE;
+      return error;
+    }
+    if ((effect2.f & EFFECT_RAN) === 0) {
+      if ((effect2.f & BOUNDARY_EFFECT) === 0) {
+        throw error;
+      }
+      effect2.b.error(error);
+    } else {
+      invoke_error_boundary(error, effect2);
+    }
+  }
+  function invoke_error_boundary(error, effect2) {
+    while (effect2 !== null) {
+      if ((effect2.f & BOUNDARY_EFFECT) !== 0) {
+        try {
+          effect2.b.error(error);
+          return;
+        } catch (e) {
+          error = e;
+        }
+      }
+      effect2 = effect2.parent;
+    }
+    throw error;
+  }
+  const batches = /* @__PURE__ */ new Set();
+  let current_batch = null;
+  let previous_batch = null;
+  let batch_values = null;
+  let queued_root_effects = [];
+  let last_scheduled_effect = null;
+  let is_flushing = false;
+  let is_flushing_sync = false;
+  const _Batch = class _Batch {
+    constructor() {
+      __privateAdd(this, _Batch_instances);
+      __publicField(this, "committed", false);
+      /**
+       * The current values of any sources that are updated in this batch
+       * They keys of this map are identical to `this.#previous`
+       * @type {Map<Source, any>}
+       */
+      __publicField(this, "current", /* @__PURE__ */ new Map());
+      /**
+       * The values of any sources that are updated in this batch _before_ those updates took place.
+       * They keys of this map are identical to `this.#current`
+       * @type {Map<Source, any>}
+       */
+      __publicField(this, "previous", /* @__PURE__ */ new Map());
+      /**
+       * 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
+       * @type {Set<() => void>}
+       */
+      __privateAdd(this, _commit_callbacks, /* @__PURE__ */ new Set());
+      /**
+       * If a fork is discarded, we need to destroy any effects that are no longer needed
+       * @type {Set<(batch: Batch) => void>}
+       */
+      __privateAdd(this, _discard_callbacks, /* @__PURE__ */ new Set());
+      /**
+       * The number of async effects that are currently in flight
+       */
+      __privateAdd(this, _pending, 0);
+      /**
+       * The number of async effects that are currently in flight, _not_ inside a pending boundary
+       */
+      __privateAdd(this, _blocking_pending, 0);
+      /**
+       * A deferred that resolves when the batch is committed, used with `settled()`
+       * TODO replace with Promise.withResolvers once supported widely enough
+       * @type {{ promise: Promise<void>, resolve: (value?: any) => void, reject: (reason: unknown) => void } | null}
+       */
+      __privateAdd(this, _deferred, null);
+      /**
+       * Deferred effects (which run after async work has completed) that are DIRTY
+       * @type {Set<Effect>}
+       */
+      __privateAdd(this, _dirty_effects, /* @__PURE__ */ new Set());
+      /**
+       * Deferred effects that are MAYBE_DIRTY
+       * @type {Set<Effect>}
+       */
+      __privateAdd(this, _maybe_dirty_effects, /* @__PURE__ */ new Set());
+      /**
+       * A set of branches that still exist, but will be destroyed when this batch
+       * is committed — we skip over these during `process`
+       * @type {Set<Effect>}
+       */
+      __publicField(this, "skipped_effects", /* @__PURE__ */ new Set());
+      __publicField(this, "is_fork", false);
+    }
+    is_deferred() {
+      return this.is_fork || __privateGet(this, _blocking_pending) > 0;
+    }
+    /**
+     *
+     * @param {Effect[]} root_effects
+     */
+    process(root_effects) {
+      var _a2;
+      queued_root_effects = [];
+      previous_batch = null;
+      this.apply();
+      var target = {
+        parent: null,
+        effect: null,
+        effects: [],
+        render_effects: []
+      };
+      for (const root2 of root_effects) {
+        __privateMethod(this, _Batch_instances, traverse_effect_tree_fn).call(this, root2, target);
+      }
+      if (!this.is_fork) {
+        __privateMethod(this, _Batch_instances, resolve_fn).call(this);
+      }
+      if (this.is_deferred()) {
+        __privateMethod(this, _Batch_instances, defer_effects_fn).call(this, target.effects);
+        __privateMethod(this, _Batch_instances, defer_effects_fn).call(this, target.render_effects);
+      } else {
+        previous_batch = this;
+        current_batch = null;
+        flush_queued_effects(target.render_effects);
+        flush_queued_effects(target.effects);
+        previous_batch = null;
+        (_a2 = __privateGet(this, _deferred)) == null ? void 0 : _a2.resolve();
+      }
+      batch_values = null;
+    }
+    /**
+     * Associate a change to a given source with the current
+     * batch, noting its previous and current values
+     * @param {Source} source
+     * @param {any} value
+     */
+    capture(source2, value) {
+      if (!this.previous.has(source2)) {
+        this.previous.set(source2, value);
+      }
+      if ((source2.f & ERROR_VALUE) === 0) {
+        this.current.set(source2, source2.v);
+        batch_values == null ? void 0 : batch_values.set(source2, source2.v);
+      }
+    }
+    activate() {
+      current_batch = this;
+      this.apply();
+    }
+    deactivate() {
+      if (current_batch !== this) return;
+      current_batch = null;
+      batch_values = null;
+    }
+    flush() {
+      this.activate();
+      if (queued_root_effects.length > 0) {
+        flush_effects();
+        if (current_batch !== null && current_batch !== this) {
+          return;
+        }
+      } else if (__privateGet(this, _pending) === 0) {
+        this.process([]);
+      }
+      this.deactivate();
+    }
+    discard() {
+      for (const fn of __privateGet(this, _discard_callbacks)) fn(this);
+      __privateGet(this, _discard_callbacks).clear();
+    }
+    /**
+     *
+     * @param {boolean} blocking
+     */
+    increment(blocking) {
+      __privateSet(this, _pending, __privateGet(this, _pending) + 1);
+      if (blocking) __privateSet(this, _blocking_pending, __privateGet(this, _blocking_pending) + 1);
+    }
+    /**
+     *
+     * @param {boolean} blocking
+     */
+    decrement(blocking) {
+      __privateSet(this, _pending, __privateGet(this, _pending) - 1);
+      if (blocking) __privateSet(this, _blocking_pending, __privateGet(this, _blocking_pending) - 1);
+      this.revive();
+    }
+    revive() {
+      for (const e of __privateGet(this, _dirty_effects)) {
+        __privateGet(this, _maybe_dirty_effects).delete(e);
+        set_signal_status(e, DIRTY);
+        schedule_effect(e);
+      }
+      for (const e of __privateGet(this, _maybe_dirty_effects)) {
+        set_signal_status(e, MAYBE_DIRTY);
+        schedule_effect(e);
+      }
+      this.flush();
+    }
+    /** @param {() => void} fn */
+    oncommit(fn) {
+      __privateGet(this, _commit_callbacks).add(fn);
+    }
+    /** @param {(batch: Batch) => void} fn */
+    ondiscard(fn) {
+      __privateGet(this, _discard_callbacks).add(fn);
+    }
+    settled() {
+      return (__privateGet(this, _deferred) ?? __privateSet(this, _deferred, deferred())).promise;
+    }
+    static ensure() {
+      if (current_batch === null) {
+        const batch = current_batch = new _Batch();
+        batches.add(current_batch);
+        if (!is_flushing_sync) {
+          _Batch.enqueue(() => {
+            if (current_batch !== batch) {
+              return;
+            }
+            batch.flush();
+          });
+        }
+      }
+      return current_batch;
+    }
+    /** @param {() => void} task */
+    static enqueue(task) {
+      queue_micro_task(task);
+    }
+    apply() {
+      return;
+    }
+  };
+  _commit_callbacks = new WeakMap();
+  _discard_callbacks = new WeakMap();
+  _pending = new WeakMap();
+  _blocking_pending = new WeakMap();
+  _deferred = new WeakMap();
+  _dirty_effects = new WeakMap();
+  _maybe_dirty_effects = new WeakMap();
+  _Batch_instances = new WeakSet();
+  /**
+   * Traverse the effect tree, executing effects or stashing
+   * them for later execution as appropriate
+   * @param {Effect} root
+   * @param {EffectTarget} target
+   */
+  traverse_effect_tree_fn = function(root2, target) {
+    var _a2;
+    root2.f ^= CLEAN;
+    var effect2 = root2.first;
+    while (effect2 !== null) {
+      var flags2 = effect2.f;
+      var is_branch = (flags2 & (BRANCH_EFFECT | ROOT_EFFECT)) !== 0;
+      var is_skippable_branch = is_branch && (flags2 & CLEAN) !== 0;
+      var skip = is_skippable_branch || (flags2 & INERT) !== 0 || this.skipped_effects.has(effect2);
+      if ((effect2.f & BOUNDARY_EFFECT) !== 0 && ((_a2 = effect2.b) == null ? void 0 : _a2.is_pending())) {
+        target = {
+          parent: target,
+          effect: effect2,
+          effects: [],
+          render_effects: []
+        };
+      }
+      if (!skip && effect2.fn !== null) {
+        if (is_branch) {
+          effect2.f ^= CLEAN;
+        } else if ((flags2 & EFFECT) !== 0) {
+          target.effects.push(effect2);
+        } else if (is_dirty(effect2)) {
+          if ((effect2.f & BLOCK_EFFECT) !== 0) __privateGet(this, _dirty_effects).add(effect2);
+          update_effect(effect2);
+        }
+        var child2 = effect2.first;
+        if (child2 !== null) {
+          effect2 = child2;
+          continue;
+        }
+      }
+      var parent = effect2.parent;
+      effect2 = effect2.next;
+      while (effect2 === null && parent !== null) {
+        if (parent === target.effect) {
+          __privateMethod(this, _Batch_instances, defer_effects_fn).call(this, target.effects);
+          __privateMethod(this, _Batch_instances, defer_effects_fn).call(this, target.render_effects);
+          target = /** @type {EffectTarget} */
+          target.parent;
+        }
+        effect2 = parent.next;
+        parent = parent.parent;
+      }
+    }
+  };
+  /**
+   * @param {Effect[]} effects
+   */
+  defer_effects_fn = function(effects) {
+    for (const e of effects) {
+      if ((e.f & DIRTY) !== 0) {
+        __privateGet(this, _dirty_effects).add(e);
+      } else if ((e.f & MAYBE_DIRTY) !== 0) {
+        __privateGet(this, _maybe_dirty_effects).add(e);
+      }
+      __privateMethod(this, _Batch_instances, clear_marked_fn).call(this, e.deps);
+      set_signal_status(e, CLEAN);
+    }
+  };
+  /**
+   * @param {Value[] | null} deps
+   */
+  clear_marked_fn = function(deps) {
+    if (deps === null) return;
+    for (const dep of deps) {
+      if ((dep.f & DERIVED) === 0 || (dep.f & WAS_MARKED) === 0) {
+        continue;
+      }
+      dep.f ^= WAS_MARKED;
+      __privateMethod(this, _Batch_instances, clear_marked_fn).call(
+        this,
+        /** @type {Derived} */
+        dep.deps
+      );
+    }
+  };
+  resolve_fn = function() {
+    if (__privateGet(this, _blocking_pending) === 0) {
+      for (const fn of __privateGet(this, _commit_callbacks)) fn();
+      __privateGet(this, _commit_callbacks).clear();
+    }
+    if (__privateGet(this, _pending) === 0) {
+      __privateMethod(this, _Batch_instances, commit_fn).call(this);
+    }
+  };
+  commit_fn = function() {
+    var _a2;
+    if (batches.size > 1) {
+      this.previous.clear();
+      var previous_batch_values = batch_values;
+      var is_earlier = true;
+      var dummy_target = {
+        parent: null,
+        effect: null,
+        effects: [],
+        render_effects: []
+      };
+      for (const batch of batches) {
+        if (batch === this) {
+          is_earlier = false;
+          continue;
+        }
+        const sources = [];
+        for (const [source2, value] of this.current) {
+          if (batch.current.has(source2)) {
+            if (is_earlier && value !== batch.current.get(source2)) {
+              batch.current.set(source2, value);
+            } else {
+              continue;
+            }
+          }
+          sources.push(source2);
+        }
+        if (sources.length === 0) {
+          continue;
+        }
+        const others = [...batch.current.keys()].filter((s) => !this.current.has(s));
+        if (others.length > 0) {
+          var prev_queued_root_effects = queued_root_effects;
+          queued_root_effects = [];
+          const marked = /* @__PURE__ */ new Set();
+          const checked = /* @__PURE__ */ new Map();
+          for (const source2 of sources) {
+            mark_effects(source2, others, marked, checked);
+          }
+          if (queued_root_effects.length > 0) {
+            current_batch = batch;
+            batch.apply();
+            for (const root2 of queued_root_effects) {
+              __privateMethod(_a2 = batch, _Batch_instances, traverse_effect_tree_fn).call(_a2, root2, dummy_target);
+            }
+            batch.deactivate();
+          }
+          queued_root_effects = prev_queued_root_effects;
+        }
+      }
+      current_batch = null;
+      batch_values = previous_batch_values;
+    }
+    this.committed = true;
+    batches.delete(this);
+  };
+  let Batch = _Batch;
+  function flushSync(fn) {
+    var was_flushing_sync = is_flushing_sync;
+    is_flushing_sync = true;
+    try {
+      var result;
+      if (fn) ;
+      while (true) {
+        flush_tasks();
+        if (queued_root_effects.length === 0) {
+          current_batch == null ? void 0 : current_batch.flush();
+          if (queued_root_effects.length === 0) {
+            last_scheduled_effect = null;
+            return (
+              /** @type {T} */
+              result
+            );
+          }
+        }
+        flush_effects();
+      }
+    } finally {
+      is_flushing_sync = was_flushing_sync;
+    }
+  }
+  function flush_effects() {
+    var was_updating_effect = is_updating_effect;
+    is_flushing = true;
+    var source_stacks = null;
+    try {
+      var flush_count = 0;
+      set_is_updating_effect(true);
+      while (queued_root_effects.length > 0) {
+        var batch = Batch.ensure();
+        if (flush_count++ > 1e3) {
+          var updates, entry;
+          if (DEV) ;
+          infinite_loop_guard();
+        }
+        batch.process(queued_root_effects);
+        old_values.clear();
+        if (DEV) ;
+      }
+    } finally {
+      is_flushing = false;
+      set_is_updating_effect(was_updating_effect);
+      last_scheduled_effect = null;
+    }
+  }
+  function infinite_loop_guard() {
+    try {
+      effect_update_depth_exceeded();
+    } catch (error) {
+      invoke_error_boundary(error, last_scheduled_effect);
+    }
+  }
+  let eager_block_effects = null;
+  function flush_queued_effects(effects) {
+    var length = effects.length;
+    if (length === 0) return;
+    var i = 0;
+    while (i < length) {
+      var effect2 = effects[i++];
+      if ((effect2.f & (DESTROYED | INERT)) === 0 && is_dirty(effect2)) {
+        eager_block_effects = /* @__PURE__ */ new Set();
+        update_effect(effect2);
+        if (effect2.deps === null && effect2.first === null && effect2.nodes === null) {
+          if (effect2.teardown === null && effect2.ac === null) {
+            unlink_effect(effect2);
+          } else {
+            effect2.fn = null;
+          }
+        }
+        if ((eager_block_effects == null ? void 0 : eager_block_effects.size) > 0) {
+          old_values.clear();
+          for (const e of eager_block_effects) {
+            if ((e.f & (DESTROYED | INERT)) !== 0) continue;
+            const ordered_effects = [e];
+            let ancestor = e.parent;
+            while (ancestor !== null) {
+              if (eager_block_effects.has(ancestor)) {
+                eager_block_effects.delete(ancestor);
+                ordered_effects.push(ancestor);
+              }
+              ancestor = ancestor.parent;
+            }
+            for (let j = ordered_effects.length - 1; j >= 0; j--) {
+              const e2 = ordered_effects[j];
+              if ((e2.f & (DESTROYED | INERT)) !== 0) continue;
+              update_effect(e2);
+            }
+          }
+          eager_block_effects.clear();
+        }
+      }
+    }
+    eager_block_effects = null;
+  }
+  function mark_effects(value, sources, marked, checked) {
+    if (marked.has(value)) return;
+    marked.add(value);
+    if (value.reactions !== null) {
+      for (const reaction of value.reactions) {
+        const flags2 = reaction.f;
+        if ((flags2 & DERIVED) !== 0) {
+          mark_effects(
+            /** @type {Derived} */
+            reaction,
+            sources,
+            marked,
+            checked
+          );
+        } else if ((flags2 & (ASYNC | BLOCK_EFFECT)) !== 0 && (flags2 & DIRTY) === 0 && depends_on(reaction, sources, checked)) {
+          set_signal_status(reaction, DIRTY);
+          schedule_effect(
+            /** @type {Effect} */
+            reaction
+          );
+        }
+      }
+    }
+  }
+  function depends_on(reaction, sources, checked) {
+    const depends = checked.get(reaction);
+    if (depends !== void 0) return depends;
+    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,
+          checked
+        )) {
+          checked.set(
+            /** @type {Derived} */
+            dep,
+            true
+          );
+          return true;
+        }
+      }
+    }
+    checked.set(reaction, false);
+    return false;
+  }
+  function schedule_effect(signal) {
+    var effect2 = last_scheduled_effect = signal;
+    while (effect2.parent !== null) {
+      effect2 = effect2.parent;
+      var flags2 = effect2.f;
+      if (is_flushing && effect2 === active_effect && (flags2 & BLOCK_EFFECT) !== 0 && (flags2 & HEAD_EFFECT) === 0) {
+        return;
+      }
+      if ((flags2 & (ROOT_EFFECT | BRANCH_EFFECT)) !== 0) {
+        if ((flags2 & CLEAN) === 0) return;
+        effect2.f ^= CLEAN;
+      }
+    }
+    queued_root_effects.push(effect2);
+  }
+  function createSubscriber(start) {
+    let subscribers = 0;
+    let version = source(0);
+    let stop;
+    return () => {
+      if (effect_tracking()) {
+        get(version);
+        render_effect(() => {
+          if (subscribers === 0) {
+            stop = untrack(() => start(() => increment(version)));
+          }
+          subscribers += 1;
+          return () => {
+            queue_micro_task(() => {
+              subscribers -= 1;
+              if (subscribers === 0) {
+                stop == null ? void 0 : stop();
+                stop = void 0;
+                increment(version);
+              }
+            });
+          };
+        });
+      }
+    };
+  }
+  var flags = EFFECT_TRANSPARENT | EFFECT_PRESERVED | BOUNDARY_EFFECT;
+  function boundary(node, props, children) {
+    new Boundary(node, props, children);
+  }
+  class Boundary {
+    /**
+     * @param {TemplateNode} node
+     * @param {BoundaryProps} props
+     * @param {((anchor: Node) => void)} children
+     */
+    constructor(node, props, children) {
+      __privateAdd(this, _Boundary_instances);
+      /** @type {Boundary | null} */
+      __publicField(this, "parent");
+      __privateAdd(this, _pending2, false);
+      /** @type {TemplateNode} */
+      __privateAdd(this, _anchor);
+      /** @type {TemplateNode | null} */
+      __privateAdd(this, _hydrate_open, null);
+      /** @type {BoundaryProps} */
+      __privateAdd(this, _props);
+      /** @type {((anchor: Node) => void)} */
+      __privateAdd(this, _children);
+      /** @type {Effect} */
+      __privateAdd(this, _effect);
+      /** @type {Effect | null} */
+      __privateAdd(this, _main_effect, null);
+      /** @type {Effect | null} */
+      __privateAdd(this, _pending_effect, null);
+      /** @type {Effect | null} */
+      __privateAdd(this, _failed_effect, null);
+      /** @type {DocumentFragment | null} */
+      __privateAdd(this, _offscreen_fragment, null);
+      /** @type {TemplateNode | null} */
+      __privateAdd(this, _pending_anchor, null);
+      __privateAdd(this, _local_pending_count, 0);
+      __privateAdd(this, _pending_count, 0);
+      __privateAdd(this, _is_creating_fallback, false);
+      /**
+       * A source containing the number of pending async deriveds/expressions.
+       * Only created if `$effect.pending()` is used inside the boundary,
+       * otherwise updating the source results in needless `Batch.ensure()`
+       * calls followed by no-op flushes
+       * @type {Source<number> | null}
+       */
+      __privateAdd(this, _effect_pending, null);
+      __privateAdd(this, _effect_pending_subscriber, createSubscriber(() => {
+        __privateSet(this, _effect_pending, source(__privateGet(this, _local_pending_count)));
+        return () => {
+          __privateSet(this, _effect_pending, null);
+        };
+      }));
+      __privateSet(this, _anchor, node);
+      __privateSet(this, _props, props);
+      __privateSet(this, _children, children);
+      this.parent = /** @type {Effect} */
+      active_effect.b;
+      __privateSet(this, _pending2, !!__privateGet(this, _props).pending);
+      __privateSet(this, _effect, block(() => {
+        active_effect.b = this;
+        {
+          var anchor = __privateMethod(this, _Boundary_instances, get_anchor_fn).call(this);
+          try {
+            __privateSet(this, _main_effect, branch(() => children(anchor)));
+          } catch (error) {
+            this.error(error);
+          }
+          if (__privateGet(this, _pending_count) > 0) {
+            __privateMethod(this, _Boundary_instances, show_pending_snippet_fn).call(this);
+          } else {
+            __privateSet(this, _pending2, false);
+          }
+        }
+        return () => {
+          var _a2;
+          (_a2 = __privateGet(this, _pending_anchor)) == null ? void 0 : _a2.remove();
+        };
+      }, flags));
+    }
+    /**
+     * Returns `true` if the effect exists inside a boundary whose pending snippet is shown
+     * @returns {boolean}
+     */
+    is_pending() {
+      return __privateGet(this, _pending2) || !!this.parent && this.parent.is_pending();
+    }
+    has_pending_snippet() {
+      return !!__privateGet(this, _props).pending;
+    }
+    /**
+     * Update the source that powers `$effect.pending()` inside this boundary,
+     * and controls when the current `pending` snippet (if any) is removed.
+     * Do not call from inside the class
+     * @param {1 | -1} d
+     */
+    update_pending_count(d) {
+      __privateMethod(this, _Boundary_instances, update_pending_count_fn).call(this, d);
+      __privateSet(this, _local_pending_count, __privateGet(this, _local_pending_count) + d);
+      if (__privateGet(this, _effect_pending)) {
+        internal_set(__privateGet(this, _effect_pending), __privateGet(this, _local_pending_count));
+      }
+    }
+    get_effect_pending() {
+      __privateGet(this, _effect_pending_subscriber).call(this);
+      return get(
+        /** @type {Source<number>} */
+        __privateGet(this, _effect_pending)
+      );
+    }
+    /** @param {unknown} error */
+    error(error) {
+      var onerror = __privateGet(this, _props).onerror;
+      let failed = __privateGet(this, _props).failed;
+      if (__privateGet(this, _is_creating_fallback) || !onerror && !failed) {
+        throw error;
+      }
+      if (__privateGet(this, _main_effect)) {
+        destroy_effect(__privateGet(this, _main_effect));
+        __privateSet(this, _main_effect, null);
+      }
+      if (__privateGet(this, _pending_effect)) {
+        destroy_effect(__privateGet(this, _pending_effect));
+        __privateSet(this, _pending_effect, null);
+      }
+      if (__privateGet(this, _failed_effect)) {
+        destroy_effect(__privateGet(this, _failed_effect));
+        __privateSet(this, _failed_effect, null);
+      }
+      var did_reset = false;
+      var calling_on_error = false;
+      const reset = () => {
+        if (did_reset) {
+          svelte_boundary_reset_noop();
+          return;
+        }
+        did_reset = true;
+        if (calling_on_error) {
+          svelte_boundary_reset_onerror();
+        }
+        Batch.ensure();
+        __privateSet(this, _local_pending_count, 0);
+        if (__privateGet(this, _failed_effect) !== null) {
+          pause_effect(__privateGet(this, _failed_effect), () => {
+            __privateSet(this, _failed_effect, null);
+          });
+        }
+        __privateSet(this, _pending2, this.has_pending_snippet());
+        __privateSet(this, _main_effect, __privateMethod(this, _Boundary_instances, run_fn).call(this, () => {
+          __privateSet(this, _is_creating_fallback, false);
+          return branch(() => __privateGet(this, _children).call(this, __privateGet(this, _anchor)));
+        }));
+        if (__privateGet(this, _pending_count) > 0) {
+          __privateMethod(this, _Boundary_instances, show_pending_snippet_fn).call(this);
+        } else {
+          __privateSet(this, _pending2, false);
+        }
+      };
+      var previous_reaction = active_reaction;
+      try {
+        set_active_reaction(null);
+        calling_on_error = true;
+        onerror == null ? void 0 : onerror(error, reset);
+        calling_on_error = false;
+      } catch (error2) {
+        invoke_error_boundary(error2, __privateGet(this, _effect) && __privateGet(this, _effect).parent);
+      } finally {
+        set_active_reaction(previous_reaction);
+      }
+      if (failed) {
+        queue_micro_task(() => {
+          __privateSet(this, _failed_effect, __privateMethod(this, _Boundary_instances, run_fn).call(this, () => {
+            Batch.ensure();
+            __privateSet(this, _is_creating_fallback, true);
+            try {
+              return branch(() => {
+                failed(
+                  __privateGet(this, _anchor),
+                  () => error,
+                  () => reset
+                );
+              });
+            } catch (error2) {
+              invoke_error_boundary(
+                error2,
+                /** @type {Effect} */
+                __privateGet(this, _effect).parent
+              );
+              return null;
+            } finally {
+              __privateSet(this, _is_creating_fallback, false);
+            }
+          }));
+        });
+      }
+    }
+  }
+  _pending2 = new WeakMap();
+  _anchor = new WeakMap();
+  _hydrate_open = new WeakMap();
+  _props = new WeakMap();
+  _children = new WeakMap();
+  _effect = new WeakMap();
+  _main_effect = new WeakMap();
+  _pending_effect = new WeakMap();
+  _failed_effect = new WeakMap();
+  _offscreen_fragment = new WeakMap();
+  _pending_anchor = new WeakMap();
+  _local_pending_count = new WeakMap();
+  _pending_count = new WeakMap();
+  _is_creating_fallback = new WeakMap();
+  _effect_pending = new WeakMap();
+  _effect_pending_subscriber = new WeakMap();
+  _Boundary_instances = new WeakSet();
+  hydrate_resolved_content_fn = function() {
+    try {
+      __privateSet(this, _main_effect, branch(() => __privateGet(this, _children).call(this, __privateGet(this, _anchor))));
+    } catch (error) {
+      this.error(error);
+    }
+    __privateSet(this, _pending2, false);
+  };
+  hydrate_pending_content_fn = function() {
+    const pending = __privateGet(this, _props).pending;
+    if (!pending) {
+      return;
+    }
+    __privateSet(this, _pending_effect, branch(() => pending(__privateGet(this, _anchor))));
+    Batch.enqueue(() => {
+      var anchor = __privateMethod(this, _Boundary_instances, get_anchor_fn).call(this);
+      __privateSet(this, _main_effect, __privateMethod(this, _Boundary_instances, run_fn).call(this, () => {
+        Batch.ensure();
+        return branch(() => __privateGet(this, _children).call(this, anchor));
+      }));
+      if (__privateGet(this, _pending_count) > 0) {
+        __privateMethod(this, _Boundary_instances, show_pending_snippet_fn).call(this);
+      } else {
+        pause_effect(
+          /** @type {Effect} */
+          __privateGet(this, _pending_effect),
+          () => {
+            __privateSet(this, _pending_effect, null);
+          }
+        );
+        __privateSet(this, _pending2, false);
+      }
+    });
+  };
+  get_anchor_fn = function() {
+    var anchor = __privateGet(this, _anchor);
+    if (__privateGet(this, _pending2)) {
+      __privateSet(this, _pending_anchor, create_text());
+      __privateGet(this, _anchor).before(__privateGet(this, _pending_anchor));
+      anchor = __privateGet(this, _pending_anchor);
+    }
+    return anchor;
+  };
+  /**
+   * @param {() => Effect | null} fn
+   */
+  run_fn = function(fn) {
+    var previous_effect = active_effect;
+    var previous_reaction = active_reaction;
+    var previous_ctx = component_context;
+    set_active_effect(__privateGet(this, _effect));
+    set_active_reaction(__privateGet(this, _effect));
+    set_component_context(__privateGet(this, _effect).ctx);
+    try {
+      return fn();
+    } catch (e) {
+      handle_error(e);
+      return null;
+    } finally {
+      set_active_effect(previous_effect);
+      set_active_reaction(previous_reaction);
+      set_component_context(previous_ctx);
+    }
+  };
+  show_pending_snippet_fn = function() {
+    const pending = (
+      /** @type {(anchor: Node) => void} */
+      __privateGet(this, _props).pending
+    );
+    if (__privateGet(this, _main_effect) !== null) {
+      __privateSet(this, _offscreen_fragment, document.createDocumentFragment());
+      __privateGet(this, _offscreen_fragment).append(
+        /** @type {TemplateNode} */
+        __privateGet(this, _pending_anchor)
+      );
+      move_effect(__privateGet(this, _main_effect), __privateGet(this, _offscreen_fragment));
+    }
+    if (__privateGet(this, _pending_effect) === null) {
+      __privateSet(this, _pending_effect, branch(() => pending(__privateGet(this, _anchor))));
+    }
+  };
+  /**
+   * Updates the pending count associated with the currently visible pending snippet,
+   * if any, such that we can replace the snippet with content once work is done
+   * @param {1 | -1} d
+   */
+  update_pending_count_fn = function(d) {
+    var _a2;
+    if (!this.has_pending_snippet()) {
+      if (this.parent) {
+        __privateMethod(_a2 = this.parent, _Boundary_instances, update_pending_count_fn).call(_a2, d);
+      }
+      return;
+    }
+    __privateSet(this, _pending_count, __privateGet(this, _pending_count) + d);
+    if (__privateGet(this, _pending_count) === 0) {
+      __privateSet(this, _pending2, false);
+      if (__privateGet(this, _pending_effect)) {
+        pause_effect(__privateGet(this, _pending_effect), () => {
+          __privateSet(this, _pending_effect, null);
+        });
+      }
+      if (__privateGet(this, _offscreen_fragment)) {
+        __privateGet(this, _anchor).before(__privateGet(this, _offscreen_fragment));
+        __privateSet(this, _offscreen_fragment, null);
+      }
+    }
+  };
+  function flatten(blockers, sync, async, fn) {
+    const d = derived;
+    if (async.length === 0 && blockers.length === 0) {
+      fn(sync.map(d));
+      return;
+    }
+    var batch = current_batch;
+    var parent = (
+      /** @type {Effect} */
+      active_effect
+    );
+    var restore = capture();
+    function run() {
+      Promise.all(async.map((expression) => /* @__PURE__ */ async_derived(expression))).then((result) => {
+        restore();
+        try {
+          fn([...sync.map(d), ...result]);
+        } catch (error) {
+          if ((parent.f & DESTROYED) === 0) {
+            invoke_error_boundary(error, parent);
+          }
+        }
+        batch == null ? void 0 : batch.deactivate();
+        unset_context();
+      }).catch((error) => {
+        invoke_error_boundary(error, parent);
+      });
+    }
+    if (blockers.length > 0) {
+      Promise.all(blockers).then(() => {
+        restore();
+        try {
+          return run();
+        } finally {
+          batch == null ? void 0 : batch.deactivate();
+          unset_context();
+        }
+      });
+    } else {
+      run();
+    }
+  }
+  function capture() {
+    var previous_effect = active_effect;
+    var previous_reaction = active_reaction;
+    var previous_component_context = component_context;
+    var previous_batch2 = current_batch;
+    return function restore(activate_batch = true) {
+      set_active_effect(previous_effect);
+      set_active_reaction(previous_reaction);
+      set_component_context(previous_component_context);
+      if (activate_batch) previous_batch2 == null ? void 0 : previous_batch2.activate();
+    };
+  }
+  function unset_context() {
+    set_active_effect(null);
+    set_active_reaction(null);
+    set_component_context(null);
+  }
+  // @__NO_SIDE_EFFECTS__
+  function derived(fn) {
+    var flags2 = DERIVED | DIRTY;
+    var parent_derived = active_reaction !== null && (active_reaction.f & DERIVED) !== 0 ? (
+      /** @type {Derived} */
+      active_reaction
+    ) : null;
+    if (active_effect !== null) {
+      active_effect.f |= EFFECT_PRESERVED;
+    }
+    const signal = {
+      ctx: component_context,
+      deps: null,
+      effects: null,
+      equals,
+      f: flags2,
+      fn,
+      reactions: null,
+      rv: 0,
+      v: (
+        /** @type {V} */
+        UNINITIALIZED
+      ),
+      wv: 0,
+      parent: parent_derived ?? active_effect,
+      ac: null
+    };
+    return signal;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function async_derived(fn, location) {
+    let parent = (
+      /** @type {Effect | null} */
+      active_effect
+    );
+    if (parent === null) {
+      async_derived_orphan();
+    }
+    var boundary2 = (
+      /** @type {Boundary} */
+      parent.b
+    );
+    var promise = (
+      /** @type {Promise<V>} */
+      /** @type {unknown} */
+      void 0
+    );
+    var signal = source(
+      /** @type {V} */
+      UNINITIALIZED
+    );
+    var should_suspend = !active_reaction;
+    var deferreds = /* @__PURE__ */ new Map();
+    async_effect(() => {
+      var _a2;
+      var d = deferred();
+      promise = d.promise;
+      try {
+        Promise.resolve(fn()).then(d.resolve, d.reject).then(() => {
+          if (batch === current_batch && batch.committed) {
+            batch.deactivate();
+          }
+          unset_context();
+        });
+      } catch (error) {
+        d.reject(error);
+        unset_context();
+      }
+      var batch = (
+        /** @type {Batch} */
+        current_batch
+      );
+      if (should_suspend) {
+        var blocking = !boundary2.is_pending();
+        boundary2.update_pending_count(1);
+        batch.increment(blocking);
+        (_a2 = deferreds.get(batch)) == null ? void 0 : _a2.reject(STALE_REACTION);
+        deferreds.delete(batch);
+        deferreds.set(batch, d);
+      }
+      const handler = (value, error = void 0) => {
+        batch.activate();
+        if (error) {
+          if (error !== STALE_REACTION) {
+            signal.f |= ERROR_VALUE;
+            internal_set(signal, error);
+          }
+        } else {
+          if ((signal.f & ERROR_VALUE) !== 0) {
+            signal.f ^= ERROR_VALUE;
+          }
+          internal_set(signal, value);
+          for (const [b, d2] of deferreds) {
+            deferreds.delete(b);
+            if (b === batch) break;
+            d2.reject(STALE_REACTION);
+          }
+        }
+        if (should_suspend) {
+          boundary2.update_pending_count(-1);
+          batch.decrement(blocking);
+        }
+      };
+      d.promise.then(handler, (e) => handler(null, e || "unknown"));
+    });
+    teardown(() => {
+      for (const d of deferreds.values()) {
+        d.reject(STALE_REACTION);
+      }
+    });
+    return new Promise((fulfil) => {
+      function next(p) {
+        function go() {
+          if (p === promise) {
+            fulfil(signal);
+          } else {
+            next(promise);
+          }
+        }
+        p.then(go, go);
+      }
+      next(promise);
+    });
+  }
+  // @__NO_SIDE_EFFECTS__
+  function user_derived(fn) {
+    const d = /* @__PURE__ */ derived(fn);
+    push_reaction_value(d);
+    return d;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function derived_safe_equal(fn) {
+    const signal = /* @__PURE__ */ derived(fn);
+    signal.equals = safe_equals;
+    return signal;
+  }
+  function destroy_derived_effects(derived2) {
+    var effects = derived2.effects;
+    if (effects !== null) {
+      derived2.effects = null;
+      for (var i = 0; i < effects.length; i += 1) {
+        destroy_effect(
+          /** @type {Effect} */
+          effects[i]
+        );
+      }
+    }
+  }
+  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));
+    {
+      try {
+        derived2.f &= ~WAS_MARKED;
+        destroy_derived_effects(derived2);
+        value = update_reaction(derived2);
+      } finally {
+        set_active_effect(prev_active_effect);
+      }
+    }
+    return value;
+  }
+  function update_derived(derived2) {
+    var value = execute_derived(derived2);
+    if (!derived2.equals(value)) {
+      if (!(current_batch == null ? void 0 : current_batch.is_fork)) {
+        derived2.v = value;
+      }
+      derived2.wv = increment_write_version();
+    }
+    if (is_destroying_effect) {
+      return;
+    }
+    if (batch_values !== null) {
+      if (effect_tracking() || (current_batch == null ? void 0 : current_batch.is_fork)) {
+        batch_values.set(derived2, value);
+      }
+    } else {
+      var status = (derived2.f & CONNECTED) === 0 ? MAYBE_DIRTY : CLEAN;
+      set_signal_status(derived2, status);
+    }
+  }
+  let eager_effects = /* @__PURE__ */ new Set();
+  const old_values = /* @__PURE__ */ new Map();
+  let eager_effects_deferred = false;
+  function source(v, stack) {
+    var signal = {
+      f: 0,
+      // TODO ideally we could skip this altogether, but it causes type errors
+      v,
+      reactions: null,
+      equals,
+      rv: 0,
+      wv: 0
+    };
+    return signal;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function state(v, stack) {
+    const s = source(v);
+    push_reaction_value(s);
+    return s;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function mutable_source(initial_value, immutable = false, trackable = true) {
+    const s = source(initial_value);
+    if (!immutable) {
+      s.equals = safe_equals;
+    }
+    return s;
+  }
+  function set(source2, value, should_proxy = false) {
+    if (active_reaction !== null && // since we are untracking the function inside `$inspect.with` we need to add this check
+    // to ensure we error if state is set inside an inspect effect
+    (!untracking || (active_reaction.f & EAGER_EFFECT) !== 0) && is_runes() && (active_reaction.f & (DERIVED | BLOCK_EFFECT | ASYNC | EAGER_EFFECT)) !== 0 && !(current_sources == null ? void 0 : current_sources.includes(source2))) {
+      state_unsafe_mutation();
+    }
+    let new_value = should_proxy ? proxy(value) : value;
+    return internal_set(source2, new_value);
+  }
+  function internal_set(source2, value) {
+    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;
+      var batch = Batch.ensure();
+      batch.capture(source2, old_value);
+      if ((source2.f & DERIVED) !== 0) {
+        if ((source2.f & DIRTY) !== 0) {
+          execute_derived(
+            /** @type {Derived} */
+            source2
+          );
+        }
+        set_signal_status(source2, (source2.f & CONNECTED) !== 0 ? CLEAN : MAYBE_DIRTY);
+      }
+      source2.wv = increment_write_version();
+      mark_reactions(source2, DIRTY);
+      if (active_effect !== null && (active_effect.f & CLEAN) !== 0 && (active_effect.f & (BRANCH_EFFECT | ROOT_EFFECT)) === 0) {
+        if (untracked_writes === null) {
+          set_untracked_writes([source2]);
+        } else {
+          untracked_writes.push(source2);
+        }
+      }
+      if (!batch.is_fork && eager_effects.size > 0 && !eager_effects_deferred) {
+        flush_eager_effects();
+      }
+    }
+    return value;
+  }
+  function flush_eager_effects() {
+    eager_effects_deferred = false;
+    var prev_is_updating_effect = is_updating_effect;
+    set_is_updating_effect(true);
+    const inspects = Array.from(eager_effects);
+    try {
+      for (const effect2 of inspects) {
+        if ((effect2.f & CLEAN) !== 0) {
+          set_signal_status(effect2, MAYBE_DIRTY);
+        }
+        if (is_dirty(effect2)) {
+          update_effect(effect2);
+        }
+      }
+    } finally {
+      set_is_updating_effect(prev_is_updating_effect);
+    }
+    eager_effects.clear();
+  }
+  function increment(source2) {
+    set(source2, source2.v + 1);
+  }
+  function mark_reactions(signal, status) {
+    var reactions = signal.reactions;
+    if (reactions === null) return;
+    var length = reactions.length;
+    for (var i = 0; i < length; i++) {
+      var reaction = reactions[i];
+      var flags2 = reaction.f;
+      var not_dirty = (flags2 & DIRTY) === 0;
+      if (not_dirty) {
+        set_signal_status(reaction, status);
+      }
+      if ((flags2 & DERIVED) !== 0) {
+        var derived2 = (
+          /** @type {Derived} */
+          reaction
+        );
+        batch_values == null ? void 0 : batch_values.delete(derived2);
+        if ((flags2 & WAS_MARKED) === 0) {
+          if (flags2 & CONNECTED) {
+            reaction.f |= WAS_MARKED;
+          }
+          mark_reactions(derived2, MAYBE_DIRTY);
+        }
+      } else if (not_dirty) {
+        if ((flags2 & BLOCK_EFFECT) !== 0 && eager_block_effects !== null) {
+          eager_block_effects.add(
+            /** @type {Effect} */
+            reaction
+          );
+        }
+        schedule_effect(
+          /** @type {Effect} */
+          reaction
+        );
+      }
+    }
+  }
+  function proxy(value) {
+    if (typeof value !== "object" || value === null || STATE_SYMBOL in value) {
+      return value;
+    }
+    const prototype = get_prototype_of(value);
+    if (prototype !== object_prototype && prototype !== array_prototype) {
+      return value;
+    }
+    var sources = /* @__PURE__ */ new Map();
+    var is_proxied_array = is_array(value);
+    var version = /* @__PURE__ */ state(0);
+    var parent_version = update_version;
+    var with_parent = (fn) => {
+      if (update_version === parent_version) {
+        return fn();
+      }
+      var reaction = active_reaction;
+      var version2 = update_version;
+      set_active_reaction(null);
+      set_update_version(parent_version);
+      var result = fn();
+      set_active_reaction(reaction);
+      set_update_version(version2);
+      return result;
+    };
+    if (is_proxied_array) {
+      sources.set("length", /* @__PURE__ */ state(
+        /** @type {any[]} */
+        value.length
+      ));
+    }
+    return new Proxy(
+      /** @type {any} */
+      value,
+      {
+        defineProperty(_, prop, descriptor) {
+          if (!("value" in descriptor) || descriptor.configurable === false || descriptor.enumerable === false || descriptor.writable === false) {
+            state_descriptors_fixed();
+          }
+          var s = sources.get(prop);
+          if (s === void 0) {
+            s = with_parent(() => {
+              var s2 = /* @__PURE__ */ state(descriptor.value);
+              sources.set(prop, s2);
+              return s2;
+            });
+          } else {
+            set(s, descriptor.value, true);
+          }
+          return true;
+        },
+        deleteProperty(target, prop) {
+          var s = sources.get(prop);
+          if (s === void 0) {
+            if (prop in target) {
+              const s2 = with_parent(() => /* @__PURE__ */ state(UNINITIALIZED));
+              sources.set(prop, s2);
+              increment(version);
+            }
+          } else {
+            set(s, UNINITIALIZED);
+            increment(version);
+          }
+          return true;
+        },
+        get(target, prop, receiver) {
+          var _a2;
+          if (prop === STATE_SYMBOL) {
+            return value;
+          }
+          var s = sources.get(prop);
+          var exists = prop in target;
+          if (s === void 0 && (!exists || ((_a2 = get_descriptor(target, prop)) == null ? void 0 : _a2.writable))) {
+            s = with_parent(() => {
+              var p = proxy(exists ? target[prop] : UNINITIALIZED);
+              var s2 = /* @__PURE__ */ state(p);
+              return s2;
+            });
+            sources.set(prop, s);
+          }
+          if (s !== void 0) {
+            var v = get(s);
+            return v === UNINITIALIZED ? void 0 : v;
+          }
+          return Reflect.get(target, prop, receiver);
+        },
+        getOwnPropertyDescriptor(target, prop) {
+          var descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+          if (descriptor && "value" in descriptor) {
+            var s = sources.get(prop);
+            if (s) descriptor.value = get(s);
+          } else if (descriptor === void 0) {
+            var source2 = sources.get(prop);
+            var value2 = source2 == null ? void 0 : source2.v;
+            if (source2 !== void 0 && value2 !== UNINITIALIZED) {
+              return {
+                enumerable: true,
+                configurable: true,
+                value: value2,
+                writable: true
+              };
+            }
+          }
+          return descriptor;
+        },
+        has(target, prop) {
+          var _a2;
+          if (prop === STATE_SYMBOL) {
+            return true;
+          }
+          var s = sources.get(prop);
+          var has = s !== void 0 && s.v !== UNINITIALIZED || Reflect.has(target, prop);
+          if (s !== void 0 || active_effect !== null && (!has || ((_a2 = get_descriptor(target, prop)) == null ? void 0 : _a2.writable))) {
+            if (s === void 0) {
+              s = with_parent(() => {
+                var p = has ? proxy(target[prop]) : UNINITIALIZED;
+                var s2 = /* @__PURE__ */ state(p);
+                return s2;
+              });
+              sources.set(prop, s);
+            }
+            var value2 = get(s);
+            if (value2 === UNINITIALIZED) {
+              return false;
+            }
+          }
+          return has;
+        },
+        set(target, prop, value2, receiver) {
+          var _a2;
+          var s = sources.get(prop);
+          var has = prop in target;
+          if (is_proxied_array && prop === "length") {
+            for (var i = value2; i < /** @type {Source<number>} */
+            s.v; i += 1) {
+              var other_s = sources.get(i + "");
+              if (other_s !== void 0) {
+                set(other_s, UNINITIALIZED);
+              } else if (i in target) {
+                other_s = with_parent(() => /* @__PURE__ */ state(UNINITIALIZED));
+                sources.set(i + "", other_s);
+              }
+            }
+          }
+          if (s === void 0) {
+            if (!has || ((_a2 = get_descriptor(target, prop)) == null ? void 0 : _a2.writable)) {
+              s = with_parent(() => /* @__PURE__ */ state(void 0));
+              set(s, proxy(value2));
+              sources.set(prop, s);
+            }
+          } else {
+            has = s.v !== UNINITIALIZED;
+            var p = with_parent(() => proxy(value2));
+            set(s, p);
+          }
+          var descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+          if (descriptor == null ? void 0 : descriptor.set) {
+            descriptor.set.call(receiver, value2);
+          }
+          if (!has) {
+            if (is_proxied_array && typeof prop === "string") {
+              var ls = (
+                /** @type {Source<number>} */
+                sources.get("length")
+              );
+              var n = Number(prop);
+              if (Number.isInteger(n) && n >= ls.v) {
+                set(ls, n + 1);
+              }
+            }
+            increment(version);
+          }
+          return true;
+        },
+        ownKeys(target) {
+          get(version);
+          var own_keys = Reflect.ownKeys(target).filter((key2) => {
+            var source3 = sources.get(key2);
+            return source3 === void 0 || source3.v !== UNINITIALIZED;
+          });
+          for (var [key, source2] of sources) {
+            if (source2.v !== UNINITIALIZED && !(key in target)) {
+              own_keys.push(key);
+            }
+          }
+          return own_keys;
+        },
+        setPrototypeOf() {
+          state_prototype_fixed();
+        }
+      }
+    );
+  }
+  var $window;
+  var $document;
+  var is_firefox;
+  var first_child_getter;
+  var next_sibling_getter;
+  function init_operations() {
+    if ($window !== void 0) {
+      return;
+    }
+    $window = window;
+    $document = document;
+    is_firefox = /Firefox/.test(navigator.userAgent);
+    var element_prototype = Element.prototype;
+    var node_prototype = Node.prototype;
+    var text_prototype = Text.prototype;
+    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.__e = void 0;
+    }
+    if (is_extensible(text_prototype)) {
+      text_prototype.__t = void 0;
+    }
+  }
+  function create_text(value = "") {
+    return document.createTextNode(value);
+  }
+  // @__NO_SIDE_EFFECTS__
+  function get_first_child(node) {
+    return (
+      /** @type {TemplateNode | null} */
+      first_child_getter.call(node)
+    );
+  }
+  // @__NO_SIDE_EFFECTS__
+  function get_next_sibling(node) {
+    return (
+      /** @type {TemplateNode | null} */
+      next_sibling_getter.call(node)
+    );
+  }
+  function child(node, is_text) {
+    {
+      return /* @__PURE__ */ get_first_child(node);
+    }
+  }
+  function first_child(node, is_text = false) {
+    {
+      var first = /* @__PURE__ */ get_first_child(node);
+      if (first instanceof Comment && first.data === "") return /* @__PURE__ */ get_next_sibling(first);
+      return first;
+    }
+  }
+  function sibling(node, count = 1, is_text = false) {
+    let next_sibling = node;
+    while (count--) {
+      next_sibling = /** @type {TemplateNode} */
+      /* @__PURE__ */ get_next_sibling(next_sibling);
+    }
+    {
+      return next_sibling;
+    }
+  }
+  function clear_text_content(node) {
+    node.textContent = "";
+  }
+  function should_defer_append() {
+    return false;
+  }
+  let listening_to_form_reset = false;
+  function add_form_reset_listener() {
+    if (!listening_to_form_reset) {
+      listening_to_form_reset = true;
+      document.addEventListener(
+        "reset",
+        (evt) => {
+          Promise.resolve().then(() => {
+            var _a2;
+            if (!evt.defaultPrevented) {
+              for (
+                const e of
+                /**@type {HTMLFormElement} */
+                evt.target.elements
+              ) {
+                (_a2 = e.__on_r) == null ? void 0 : _a2.call(e);
+              }
+            }
+          });
+        },
+        // In the capture phase to guarantee we get noticed of it (no possibility of stopPropagation)
+        { capture: true }
+      );
+    }
+  }
+  function without_reactive_context(fn) {
+    var previous_reaction = active_reaction;
+    var previous_effect = active_effect;
+    set_active_reaction(null);
+    set_active_effect(null);
+    try {
+      return fn();
+    } finally {
+      set_active_reaction(previous_reaction);
+      set_active_effect(previous_effect);
+    }
+  }
+  function listen_to_event_and_reset_event(element, event2, handler, on_reset = handler) {
+    element.addEventListener(event2, () => without_reactive_context(handler));
+    const prev = element.__on_r;
+    if (prev) {
+      element.__on_r = () => {
+        prev();
+        on_reset(true);
+      };
+    } else {
+      element.__on_r = () => on_reset(true);
+    }
+    add_form_reset_listener();
+  }
+  function validate_effect(rune) {
+    if (active_effect === null) {
+      if (active_reaction === null) {
+        effect_orphan();
+      }
+      effect_in_unowned_derived();
+    }
+    if (is_destroying_effect) {
+      effect_in_teardown();
+    }
+  }
+  function push_effect(effect2, parent_effect) {
+    var parent_last = parent_effect.last;
+    if (parent_last === null) {
+      parent_effect.last = parent_effect.first = effect2;
+    } else {
+      parent_last.next = effect2;
+      effect2.prev = parent_last;
+      parent_effect.last = effect2;
+    }
+  }
+  function create_effect(type, fn, sync) {
+    var parent = active_effect;
+    if (parent !== null && (parent.f & INERT) !== 0) {
+      type |= INERT;
+    }
+    var effect2 = {
+      ctx: component_context,
+      deps: null,
+      nodes: null,
+      f: type | DIRTY | CONNECTED,
+      first: null,
+      fn,
+      last: null,
+      next: null,
+      parent,
+      b: parent && parent.b,
+      prev: null,
+      teardown: null,
+      wv: 0,
+      ac: null
+    };
+    if (sync) {
+      try {
+        update_effect(effect2);
+        effect2.f |= EFFECT_RAN;
+      } catch (e2) {
+        destroy_effect(effect2);
+        throw e2;
+      }
+    } else if (fn !== null) {
+      schedule_effect(effect2);
+    }
+    var e = effect2;
+    if (sync && e.deps === null && e.teardown === null && e.nodes === null && e.first === e.last && // either `null`, or a singular child
+    (e.f & EFFECT_PRESERVED) === 0) {
+      e = e.first;
+      if ((type & BLOCK_EFFECT) !== 0 && (type & EFFECT_TRANSPARENT) !== 0 && e !== null) {
+        e.f |= EFFECT_TRANSPARENT;
+      }
+    }
+    if (e !== null) {
+      e.parent = parent;
+      if (parent !== null) {
+        push_effect(e, parent);
+      }
+      if (active_reaction !== null && (active_reaction.f & DERIVED) !== 0 && (type & ROOT_EFFECT) === 0) {
+        var derived2 = (
+          /** @type {Derived} */
+          active_reaction
+        );
+        (derived2.effects ?? (derived2.effects = [])).push(e);
+      }
+    }
+    return effect2;
+  }
+  function effect_tracking() {
+    return active_reaction !== null && !untracking;
+  }
+  function teardown(fn) {
+    const effect2 = create_effect(RENDER_EFFECT, null, false);
+    set_signal_status(effect2, CLEAN);
+    effect2.teardown = fn;
+    return effect2;
+  }
+  function user_effect(fn) {
+    validate_effect();
+    var flags2 = (
+      /** @type {Effect} */
+      active_effect.f
+    );
+    var defer = !active_reaction && (flags2 & BRANCH_EFFECT) !== 0 && (flags2 & EFFECT_RAN) === 0;
+    if (defer) {
+      var context = (
+        /** @type {ComponentContext} */
+        component_context
+      );
+      (context.e ?? (context.e = [])).push(fn);
+    } else {
+      return create_user_effect(fn);
+    }
+  }
+  function create_user_effect(fn) {
+    return create_effect(EFFECT | USER_EFFECT, fn, false);
+  }
+  function component_root(fn) {
+    Batch.ensure();
+    const effect2 = create_effect(ROOT_EFFECT | EFFECT_PRESERVED, fn, true);
+    return (options = {}) => {
+      return new Promise((fulfil) => {
+        if (options.outro) {
+          pause_effect(effect2, () => {
+            destroy_effect(effect2);
+            fulfil(void 0);
+          });
+        } else {
+          destroy_effect(effect2);
+          fulfil(void 0);
+        }
+      });
+    };
+  }
+  function effect(fn) {
+    return create_effect(EFFECT, fn, false);
+  }
+  function async_effect(fn) {
+    return create_effect(ASYNC | EFFECT_PRESERVED, fn, true);
+  }
+  function render_effect(fn, flags2 = 0) {
+    return create_effect(RENDER_EFFECT | flags2, fn, true);
+  }
+  function template_effect(fn, sync = [], async = [], blockers = []) {
+    flatten(blockers, sync, async, (values) => {
+      create_effect(RENDER_EFFECT, () => fn(...values.map(get)), true);
+    });
+  }
+  function block(fn, flags2 = 0) {
+    var effect2 = create_effect(BLOCK_EFFECT | flags2, fn, true);
+    return effect2;
+  }
+  function branch(fn) {
+    return create_effect(BRANCH_EFFECT | EFFECT_PRESERVED, fn, true);
+  }
+  function execute_effect_teardown(effect2) {
+    var teardown2 = effect2.teardown;
+    if (teardown2 !== null) {
+      const previously_destroying_effect = is_destroying_effect;
+      const previous_reaction = active_reaction;
+      set_is_destroying_effect(true);
+      set_active_reaction(null);
+      try {
+        teardown2.call(null);
+      } finally {
+        set_is_destroying_effect(previously_destroying_effect);
+        set_active_reaction(previous_reaction);
+      }
+    }
+  }
+  function destroy_effect_children(signal, remove_dom = false) {
+    var effect2 = signal.first;
+    signal.first = signal.last = null;
+    while (effect2 !== null) {
+      const controller = effect2.ac;
+      if (controller !== null) {
+        without_reactive_context(() => {
+          controller.abort(STALE_REACTION);
+        });
+      }
+      var next = effect2.next;
+      if ((effect2.f & ROOT_EFFECT) !== 0) {
+        effect2.parent = null;
+      } else {
+        destroy_effect(effect2, remove_dom);
+      }
+      effect2 = next;
+    }
+  }
+  function destroy_block_effect_children(signal) {
+    var effect2 = signal.first;
+    while (effect2 !== null) {
+      var next = effect2.next;
+      if ((effect2.f & BRANCH_EFFECT) === 0) {
+        destroy_effect(effect2);
+      }
+      effect2 = next;
+    }
+  }
+  function destroy_effect(effect2, remove_dom = true) {
+    var removed = false;
+    if ((remove_dom || (effect2.f & HEAD_EFFECT) !== 0) && effect2.nodes !== null && effect2.nodes.end !== null) {
+      remove_effect_dom(
+        effect2.nodes.start,
+        /** @type {TemplateNode} */
+        effect2.nodes.end
+      );
+      removed = true;
+    }
+    destroy_effect_children(effect2, remove_dom && !removed);
+    remove_reactions(effect2, 0);
+    set_signal_status(effect2, DESTROYED);
+    var transitions = effect2.nodes && effect2.nodes.t;
+    if (transitions !== null) {
+      for (const transition of transitions) {
+        transition.stop();
+      }
+    }
+    execute_effect_teardown(effect2);
+    var parent = effect2.parent;
+    if (parent !== null && parent.first !== null) {
+      unlink_effect(effect2);
+    }
+    effect2.next = effect2.prev = effect2.teardown = effect2.ctx = effect2.deps = effect2.fn = effect2.nodes = effect2.ac = null;
+  }
+  function remove_effect_dom(node, end) {
+    while (node !== null) {
+      var next = node === end ? null : /* @__PURE__ */ get_next_sibling(node);
+      node.remove();
+      node = next;
+    }
+  }
+  function unlink_effect(effect2) {
+    var parent = effect2.parent;
+    var prev = effect2.prev;
+    var next = effect2.next;
+    if (prev !== null) prev.next = next;
+    if (next !== null) next.prev = prev;
+    if (parent !== null) {
+      if (parent.first === effect2) parent.first = next;
+      if (parent.last === effect2) parent.last = prev;
+    }
+  }
+  function pause_effect(effect2, callback, destroy = true) {
+    var transitions = [];
+    pause_children(effect2, transitions, true);
+    var fn = () => {
+      if (destroy) destroy_effect(effect2);
+      if (callback) callback();
+    };
+    var remaining = transitions.length;
+    if (remaining > 0) {
+      var check = () => --remaining || fn();
+      for (var transition of transitions) {
+        transition.out(check);
+      }
+    } else {
+      fn();
+    }
+  }
+  function pause_children(effect2, transitions, local) {
+    if ((effect2.f & INERT) !== 0) return;
+    effect2.f ^= INERT;
+    var t = effect2.nodes && effect2.nodes.t;
+    if (t !== null) {
+      for (const transition of t) {
+        if (transition.is_global || local) {
+          transitions.push(transition);
+        }
+      }
+    }
+    var child2 = effect2.first;
+    while (child2 !== null) {
+      var sibling2 = child2.next;
+      var transparent = (child2.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.
+      (child2.f & BRANCH_EFFECT) !== 0 && (effect2.f & BLOCK_EFFECT) !== 0;
+      pause_children(child2, transitions, transparent ? local : false);
+      child2 = sibling2;
+    }
+  }
+  function resume_effect(effect2) {
+    resume_children(effect2, true);
+  }
+  function resume_children(effect2, local) {
+    if ((effect2.f & INERT) === 0) return;
+    effect2.f ^= INERT;
+    if ((effect2.f & CLEAN) === 0) {
+      set_signal_status(effect2, DIRTY);
+      schedule_effect(effect2);
+    }
+    var child2 = effect2.first;
+    while (child2 !== null) {
+      var sibling2 = child2.next;
+      var transparent = (child2.f & EFFECT_TRANSPARENT) !== 0 || (child2.f & BRANCH_EFFECT) !== 0;
+      resume_children(child2, transparent ? local : false);
+      child2 = sibling2;
+    }
+    var t = effect2.nodes && effect2.nodes.t;
+    if (t !== null) {
+      for (const transition of t) {
+        if (transition.is_global || local) {
+          transition.in();
+        }
+      }
+    }
+  }
+  function move_effect(effect2, fragment) {
+    if (!effect2.nodes) return;
+    var node = effect2.nodes.start;
+    var end = effect2.nodes.end;
+    while (node !== null) {
+      var next = node === end ? null : /* @__PURE__ */ get_next_sibling(node);
+      fragment.append(node);
+      node = next;
+    }
+  }
+  let is_updating_effect = false;
+  function set_is_updating_effect(value) {
+    is_updating_effect = value;
+  }
+  let is_destroying_effect = false;
+  function set_is_destroying_effect(value) {
+    is_destroying_effect = value;
+  }
+  let active_reaction = null;
+  let untracking = false;
+  function set_active_reaction(reaction) {
+    active_reaction = reaction;
+  }
+  let active_effect = null;
+  function set_active_effect(effect2) {
+    active_effect = effect2;
+  }
+  let current_sources = null;
+  function push_reaction_value(value) {
+    if (active_reaction !== null && true) {
+      if (current_sources === null) {
+        current_sources = [value];
+      } else {
+        current_sources.push(value);
+      }
+    }
+  }
+  let new_deps = null;
+  let skipped_deps = 0;
+  let untracked_writes = null;
+  function set_untracked_writes(value) {
+    untracked_writes = value;
+  }
+  let write_version = 1;
+  let read_version = 0;
+  let update_version = read_version;
+  function set_update_version(value) {
+    update_version = value;
+  }
+  function increment_write_version() {
+    return ++write_version;
+  }
+  function is_dirty(reaction) {
+    var flags2 = reaction.f;
+    if ((flags2 & DIRTY) !== 0) {
+      return true;
+    }
+    if (flags2 & DERIVED) {
+      reaction.f &= ~WAS_MARKED;
+    }
+    if ((flags2 & MAYBE_DIRTY) !== 0) {
+      var dependencies = reaction.deps;
+      if (dependencies !== null) {
+        var length = dependencies.length;
+        for (var i = 0; i < length; i++) {
+          var dependency = dependencies[i];
+          if (is_dirty(
+            /** @type {Derived} */
+            dependency
+          )) {
+            update_derived(
+              /** @type {Derived} */
+              dependency
+            );
+          }
+          if (dependency.wv > reaction.wv) {
+            return true;
+          }
+        }
+      }
+      if ((flags2 & CONNECTED) !== 0 && // During time traveling we don't want to reset the status so that
+      // traversal of the graph in the other batches still happens
+      batch_values === null) {
+        set_signal_status(reaction, CLEAN);
+      }
+    }
+    return false;
+  }
+  function schedule_possible_effect_self_invalidation(signal, effect2, root2 = true) {
+    var reactions = signal.reactions;
+    if (reactions === null) return;
+    if (current_sources == null ? void 0 : current_sources.includes(signal)) {
+      return;
+    }
+    for (var i = 0; i < reactions.length; i++) {
+      var reaction = reactions[i];
+      if ((reaction.f & DERIVED) !== 0) {
+        schedule_possible_effect_self_invalidation(
+          /** @type {Derived} */
+          reaction,
+          effect2,
+          false
+        );
+      } else if (effect2 === reaction) {
+        if (root2) {
+          set_signal_status(reaction, DIRTY);
+        } else if ((reaction.f & CLEAN) !== 0) {
+          set_signal_status(reaction, MAYBE_DIRTY);
+        }
+        schedule_effect(
+          /** @type {Effect} */
+          reaction
+        );
+      }
+    }
+  }
+  function update_reaction(reaction) {
+    var _a2;
+    var previous_deps = new_deps;
+    var previous_skipped_deps = skipped_deps;
+    var previous_untracked_writes = untracked_writes;
+    var previous_reaction = active_reaction;
+    var previous_sources = current_sources;
+    var previous_component_context = component_context;
+    var previous_untracking = untracking;
+    var previous_update_version = update_version;
+    var flags2 = reaction.f;
+    new_deps = /** @type {null | Value[]} */
+    null;
+    skipped_deps = 0;
+    untracked_writes = null;
+    active_reaction = (flags2 & (BRANCH_EFFECT | ROOT_EFFECT)) === 0 ? reaction : null;
+    current_sources = null;
+    set_component_context(reaction.ctx);
+    untracking = false;
+    update_version = ++read_version;
+    if (reaction.ac !== null) {
+      without_reactive_context(() => {
+        reaction.ac.abort(STALE_REACTION);
+      });
+      reaction.ac = null;
+    }
+    try {
+      reaction.f |= REACTION_IS_UPDATING;
+      var fn = (
+        /** @type {Function} */
+        reaction.fn
+      );
+      var result = fn();
+      var deps = reaction.deps;
+      if (new_deps !== null) {
+        var i;
+        remove_reactions(reaction, skipped_deps);
+        if (deps !== null && skipped_deps > 0) {
+          deps.length = skipped_deps + new_deps.length;
+          for (i = 0; i < new_deps.length; i++) {
+            deps[skipped_deps + i] = new_deps[i];
+          }
+        } else {
+          reaction.deps = deps = new_deps;
+        }
+        if (effect_tracking() && (reaction.f & CONNECTED) !== 0) {
+          for (i = skipped_deps; i < deps.length; i++) {
+            ((_a2 = deps[i]).reactions ?? (_a2.reactions = [])).push(reaction);
+          }
+        }
+      } else if (deps !== null && skipped_deps < deps.length) {
+        remove_reactions(reaction, skipped_deps);
+        deps.length = skipped_deps;
+      }
+      if (is_runes() && untracked_writes !== null && !untracking && deps !== null && (reaction.f & (DERIVED | MAYBE_DIRTY | DIRTY)) === 0) {
+        for (i = 0; i < /** @type {Source[]} */
+        untracked_writes.length; i++) {
+          schedule_possible_effect_self_invalidation(
+            untracked_writes[i],
+            /** @type {Effect} */
+            reaction
+          );
+        }
+      }
+      if (previous_reaction !== null && previous_reaction !== reaction) {
+        read_version++;
+        if (untracked_writes !== null) {
+          if (previous_untracked_writes === null) {
+            previous_untracked_writes = untracked_writes;
+          } else {
+            previous_untracked_writes.push(.../** @type {Source[]} */
+            untracked_writes);
+          }
+        }
+      }
+      if ((reaction.f & ERROR_VALUE) !== 0) {
+        reaction.f ^= ERROR_VALUE;
+      }
+      return result;
+    } catch (error) {
+      return handle_error(error);
+    } finally {
+      reaction.f ^= REACTION_IS_UPDATING;
+      new_deps = previous_deps;
+      skipped_deps = previous_skipped_deps;
+      untracked_writes = previous_untracked_writes;
+      active_reaction = previous_reaction;
+      current_sources = previous_sources;
+      set_component_context(previous_component_context);
+      untracking = previous_untracking;
+      update_version = previous_update_version;
+    }
+  }
+  function remove_reaction(signal, dependency) {
+    let reactions = dependency.reactions;
+    if (reactions !== null) {
+      var index = index_of.call(reactions, signal);
+      if (index !== -1) {
+        var new_length = reactions.length - 1;
+        if (new_length === 0) {
+          reactions = dependency.reactions = null;
+        } else {
+          reactions[index] = reactions[new_length];
+          reactions.pop();
+        }
+      }
+    }
+    if (reactions === null && (dependency.f & DERIVED) !== 0 && // Destroying a child effect while updating a parent effect can cause a dependency to appear
+    // to be unused, when in fact it is used by the currently-updating parent. Checking `new_deps`
+    // allows us to skip the expensive work of disconnecting and immediately reconnecting it
+    (new_deps === null || !new_deps.includes(dependency))) {
+      set_signal_status(dependency, MAYBE_DIRTY);
+      if ((dependency.f & CONNECTED) !== 0) {
+        dependency.f ^= CONNECTED;
+        dependency.f &= ~WAS_MARKED;
+      }
+      destroy_derived_effects(
+        /** @type {Derived} **/
+        dependency
+      );
+      remove_reactions(
+        /** @type {Derived} **/
+        dependency,
+        0
+      );
+    }
+  }
+  function remove_reactions(signal, start_index) {
+    var dependencies = signal.deps;
+    if (dependencies === null) return;
+    for (var i = start_index; i < dependencies.length; i++) {
+      remove_reaction(signal, dependencies[i]);
+    }
+  }
+  function update_effect(effect2) {
+    var flags2 = effect2.f;
+    if ((flags2 & DESTROYED) !== 0) {
+      return;
+    }
+    set_signal_status(effect2, CLEAN);
+    var previous_effect = active_effect;
+    var was_updating_effect = is_updating_effect;
+    active_effect = effect2;
+    is_updating_effect = true;
+    try {
+      if ((flags2 & (BLOCK_EFFECT | MANAGED_EFFECT)) !== 0) {
+        destroy_block_effect_children(effect2);
+      } else {
+        destroy_effect_children(effect2);
+      }
+      execute_effect_teardown(effect2);
+      var teardown2 = update_reaction(effect2);
+      effect2.teardown = typeof teardown2 === "function" ? teardown2 : null;
+      effect2.wv = write_version;
+      var dep;
+      if (DEV && tracing_mode_flag && (effect2.f & DIRTY) !== 0 && effect2.deps !== null) ;
+    } finally {
+      is_updating_effect = was_updating_effect;
+      active_effect = previous_effect;
+    }
+  }
+  async function tick() {
+    await Promise.resolve();
+    flushSync();
+  }
+  function get(signal) {
+    var flags2 = signal.f;
+    var is_derived = (flags2 & DERIVED) !== 0;
+    if (active_reaction !== null && !untracking) {
+      var destroyed = active_effect !== null && (active_effect.f & DESTROYED) !== 0;
+      if (!destroyed && !(current_sources == null ? void 0 : current_sources.includes(signal))) {
+        var deps = active_reaction.deps;
+        if ((active_reaction.f & REACTION_IS_UPDATING) !== 0) {
+          if (signal.rv < read_version) {
+            signal.rv = read_version;
+            if (new_deps === null && deps !== null && deps[skipped_deps] === signal) {
+              skipped_deps++;
+            } else if (new_deps === null) {
+              new_deps = [signal];
+            } else if (!new_deps.includes(signal)) {
+              new_deps.push(signal);
+            }
+          }
+        } else {
+          (active_reaction.deps ?? (active_reaction.deps = [])).push(signal);
+          var reactions = signal.reactions;
+          if (reactions === null) {
+            signal.reactions = [active_reaction];
+          } else if (!reactions.includes(active_reaction)) {
+            reactions.push(active_reaction);
+          }
+        }
+      }
+    }
+    if (is_destroying_effect) {
+      if (old_values.has(signal)) {
+        return old_values.get(signal);
+      }
+      if (is_derived) {
+        var derived2 = (
+          /** @type {Derived} */
+          signal
+        );
+        var value = derived2.v;
+        if ((derived2.f & CLEAN) === 0 && derived2.reactions !== null || depends_on_old_values(derived2)) {
+          value = execute_derived(derived2);
+        }
+        old_values.set(derived2, value);
+        return value;
+      }
+    } else if (is_derived && (!(batch_values == null ? void 0 : batch_values.has(signal)) || (current_batch == null ? void 0 : current_batch.is_fork) && !effect_tracking())) {
+      derived2 = /** @type {Derived} */
+      signal;
+      if (is_dirty(derived2)) {
+        update_derived(derived2);
+      }
+      if (is_updating_effect && effect_tracking() && (derived2.f & CONNECTED) === 0) {
+        reconnect(derived2);
+      }
+    }
+    if (batch_values == null ? void 0 : batch_values.has(signal)) {
+      return batch_values.get(signal);
+    }
+    if ((signal.f & ERROR_VALUE) !== 0) {
+      throw signal.v;
+    }
+    return signal.v;
+  }
+  function reconnect(derived2) {
+    if (derived2.deps === null) return;
+    derived2.f ^= CONNECTED;
+    for (const dep of derived2.deps) {
+      (dep.reactions ?? (dep.reactions = [])).push(derived2);
+      if ((dep.f & DERIVED) !== 0 && (dep.f & CONNECTED) === 0) {
+        reconnect(
+          /** @type {Derived} */
+          dep
+        );
+      }
+    }
+  }
+  function depends_on_old_values(derived2) {
+    if (derived2.v === UNINITIALIZED) return true;
+    if (derived2.deps === null) return false;
+    for (const dep of derived2.deps) {
+      if (old_values.has(dep)) {
+        return true;
+      }
+      if ((dep.f & DERIVED) !== 0 && depends_on_old_values(
+        /** @type {Derived} */
+        dep
+      )) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function untrack(fn) {
+    var previous_untracking = untracking;
+    try {
+      untracking = true;
+      return fn();
+    } finally {
+      untracking = previous_untracking;
+    }
+  }
+  const STATUS_MASK = -7169;
+  function set_signal_status(signal, status) {
+    signal.f = signal.f & STATUS_MASK | status;
+  }
+  const PASSIVE_EVENTS = ["touchstart", "touchmove"];
+  function is_passive_event(name) {
+    return PASSIVE_EVENTS.includes(name);
+  }
+  const all_registered_events = /* @__PURE__ */ new Set();
+  const root_event_handles = /* @__PURE__ */ new Set();
+  function create_event(event_name, dom, handler, options = {}) {
+    function target_handler(event2) {
+      if (!options.capture) {
+        handle_event_propagation.call(dom, event2);
+      }
+      if (!event2.cancelBubble) {
+        return without_reactive_context(() => {
+          return handler == null ? void 0 : handler.call(this, event2);
+        });
+      }
+    }
+    if (event_name.startsWith("pointer") || event_name.startsWith("touch") || event_name === "wheel") {
+      queue_micro_task(() => {
+        dom.addEventListener(event_name, target_handler, options);
+      });
+    } else {
+      dom.addEventListener(event_name, target_handler, options);
+    }
+    return target_handler;
+  }
+  function event(event_name, dom, handler, capture2, passive) {
+    var options = { capture: capture2, passive };
+    var target_handler = create_event(event_name, dom, handler, options);
+    if (dom === document.body || // @ts-ignore
+    dom === window || // @ts-ignore
+    dom === document || // Firefox has quirky behavior, it can happen that we still get "canplay" events when the element is already removed
+    dom instanceof HTMLMediaElement) {
+      teardown(() => {
+        dom.removeEventListener(event_name, target_handler, options);
+      });
+    }
+  }
+  function delegate(events) {
+    for (var i = 0; i < events.length; i++) {
+      all_registered_events.add(events[i]);
+    }
+    for (var fn of root_event_handles) {
+      fn(events);
+    }
+  }
+  let last_propagated_event = null;
+  function handle_event_propagation(event2) {
+    var _a2;
+    var handler_element = this;
+    var owner_document = (
+      /** @type {Node} */
+      handler_element.ownerDocument
+    );
+    var event_name = event2.type;
+    var path = ((_a2 = event2.composedPath) == null ? void 0 : _a2.call(event2)) || [];
+    var current_target = (
+      /** @type {null | Element} */
+      path[0] || event2.target
+    );
+    last_propagated_event = event2;
+    var path_idx = 0;
+    var handled_at = last_propagated_event === event2 && event2.__root;
+    if (handled_at) {
+      var at_idx = path.indexOf(handled_at);
+      if (at_idx !== -1 && (handler_element === document || handler_element === /** @type {any} */
+      window)) {
+        event2.__root = handler_element;
+        return;
+      }
+      var handler_idx = path.indexOf(handler_element);
+      if (handler_idx === -1) {
+        return;
+      }
+      if (at_idx <= handler_idx) {
+        path_idx = at_idx;
+      }
+    }
+    current_target = /** @type {Element} */
+    path[path_idx] || event2.target;
+    if (current_target === handler_element) return;
+    define_property(event2, "currentTarget", {
+      configurable: true,
+      get() {
+        return current_target || owner_document;
+      }
+    });
+    var previous_reaction = active_reaction;
+    var previous_effect = active_effect;
+    set_active_reaction(null);
+    set_active_effect(null);
+    try {
+      var throw_error;
+      var other_errors = [];
+      while (current_target !== null) {
+        var parent_element = current_target.assignedSlot || current_target.parentNode || /** @type {any} */
+        current_target.host || null;
+        try {
+          var delegated = current_target["__" + event_name];
+          if (delegated != null && (!/** @type {any} */
+          current_target.disabled || // DOM could've been updated already by the time this is reached, so we check this as well
+          // -> the target could not have been disabled because it emits the event in the first place
+          event2.target === current_target)) {
+            delegated.call(current_target, event2);
+          }
+        } catch (error) {
+          if (throw_error) {
+            other_errors.push(error);
+          } else {
+            throw_error = error;
+          }
+        }
+        if (event2.cancelBubble || parent_element === handler_element || parent_element === null) {
+          break;
+        }
+        current_target = parent_element;
+      }
+      if (throw_error) {
+        for (let error of other_errors) {
+          queueMicrotask(() => {
+            throw error;
+          });
+        }
+        throw throw_error;
+      }
+    } finally {
+      event2.__root = handler_element;
+      delete event2.currentTarget;
+      set_active_reaction(previous_reaction);
+      set_active_effect(previous_effect);
+    }
+  }
+  function create_fragment_from_html(html) {
+    var elem = document.createElement("template");
+    elem.innerHTML = html.replaceAll("<!>", "<!---->");
+    return elem.content;
+  }
+  function assign_nodes(start, end) {
+    var effect2 = (
+      /** @type {Effect} */
+      active_effect
+    );
+    if (effect2.nodes === null) {
+      effect2.nodes = { start, end, a: null, t: null };
+    }
+  }
+  // @__NO_SIDE_EFFECTS__
+  function from_html(content, flags2) {
+    var is_fragment = (flags2 & TEMPLATE_FRAGMENT) !== 0;
+    var use_import_node = (flags2 & TEMPLATE_USE_IMPORT_NODE) !== 0;
+    var node;
+    var has_start = !content.startsWith("<!>");
+    return () => {
+      if (node === void 0) {
+        node = create_fragment_from_html(has_start ? content : "<!>" + content);
+        if (!is_fragment) node = /** @type {TemplateNode} */
+        /* @__PURE__ */ get_first_child(node);
+      }
+      var clone = (
+        /** @type {TemplateNode} */
+        use_import_node || is_firefox ? document.importNode(node, true) : node.cloneNode(true)
+      );
+      if (is_fragment) {
+        var start = (
+          /** @type {TemplateNode} */
+          /* @__PURE__ */ get_first_child(clone)
+        );
+        var end = (
+          /** @type {TemplateNode} */
+          clone.lastChild
+        );
+        assign_nodes(start, end);
+      } else {
+        assign_nodes(clone, clone);
+      }
+      return clone;
+    };
+  }
+  function append(anchor, dom) {
+    if (anchor === null) {
+      return;
+    }
+    anchor.before(
+      /** @type {Node} */
+      dom
+    );
+  }
+  function set_text(text, value) {
+    var str = value == null ? "" : typeof value === "object" ? value + "" : value;
+    if (str !== (text.__t ?? (text.__t = text.nodeValue))) {
+      text.__t = str;
+      text.nodeValue = str + "";
+    }
+  }
+  function mount(component, options) {
+    return _mount(component, options);
+  }
+  const document_listeners = /* @__PURE__ */ new Map();
+  function _mount(Component, { target, anchor, props = {}, events, context, intro = true }) {
+    init_operations();
+    var registered_events = /* @__PURE__ */ new Set();
+    var event_handle = (events2) => {
+      for (var i = 0; i < events2.length; i++) {
+        var event_name = events2[i];
+        if (registered_events.has(event_name)) continue;
+        registered_events.add(event_name);
+        var passive = is_passive_event(event_name);
+        target.addEventListener(event_name, handle_event_propagation, { passive });
+        var n = document_listeners.get(event_name);
+        if (n === void 0) {
+          document.addEventListener(event_name, handle_event_propagation, { passive });
+          document_listeners.set(event_name, 1);
+        } else {
+          document_listeners.set(event_name, n + 1);
+        }
+      }
+    };
+    event_handle(array_from(all_registered_events));
+    root_event_handles.add(event_handle);
+    var component = void 0;
+    var unmount2 = component_root(() => {
+      var anchor_node = anchor ?? target.appendChild(create_text());
+      boundary(
+        /** @type {TemplateNode} */
+        anchor_node,
+        {
+          pending: () => {
+          }
+        },
+        (anchor_node2) => {
+          if (context) {
+            push({});
+            var ctx = (
+              /** @type {ComponentContext} */
+              component_context
+            );
+            ctx.c = context;
+          }
+          if (events) {
+            props.$$events = events;
+          }
+          component = Component(anchor_node2, props) || {};
+          if (context) {
+            pop();
+          }
+        }
+      );
+      return () => {
+        var _a2;
+        for (var event_name of registered_events) {
+          target.removeEventListener(event_name, handle_event_propagation);
+          var n = (
+            /** @type {number} */
+            document_listeners.get(event_name)
+          );
+          if (--n === 0) {
+            document.removeEventListener(event_name, handle_event_propagation);
+            document_listeners.delete(event_name);
+          } else {
+            document_listeners.set(event_name, n);
+          }
+        }
+        root_event_handles.delete(event_handle);
+        if (anchor_node !== anchor) {
+          (_a2 = anchor_node.parentNode) == null ? void 0 : _a2.removeChild(anchor_node);
+        }
+      };
+    });
+    mounted_components.set(component, unmount2);
+    return component;
+  }
+  let mounted_components = /* @__PURE__ */ new WeakMap();
+  function unmount(component, options) {
+    const fn = mounted_components.get(component);
+    if (fn) {
+      mounted_components.delete(component);
+      return fn(options);
+    }
+    return Promise.resolve();
+  }
+  class BranchManager {
+    /**
+     * @param {TemplateNode} anchor
+     * @param {boolean} transition
+     */
+    constructor(anchor, transition = true) {
+      /** @type {TemplateNode} */
+      __publicField(this, "anchor");
+      /** @type {Map<Batch, Key>} */
+      __privateAdd(this, _batches, /* @__PURE__ */ new Map());
+      /**
+       * Map of keys to effects that are currently rendered in the DOM.
+       * These effects are visible and actively part of the document tree.
+       * Example:
+       * ```
+       * {#if condition}
+       * 	foo
+       * {:else}
+       * 	bar
+       * {/if}
+       * ```
+       * Can result in the entries `true->Effect` and `false->Effect`
+       * @type {Map<Key, Effect>}
+       */
+      __privateAdd(this, _onscreen, /* @__PURE__ */ new Map());
+      /**
+       * Similar to #onscreen with respect to the keys, but contains branches that are not yet
+       * in the DOM, because their insertion is deferred.
+       * @type {Map<Key, Branch>}
+       */
+      __privateAdd(this, _offscreen, /* @__PURE__ */ new Map());
+      /**
+       * Keys of effects that are currently outroing
+       * @type {Set<Key>}
+       */
+      __privateAdd(this, _outroing, /* @__PURE__ */ new Set());
+      /**
+       * Whether to pause (i.e. outro) on change, or destroy immediately.
+       * This is necessary for `<svelte:element>`
+       */
+      __privateAdd(this, _transition, true);
+      __privateAdd(this, _commit, () => {
+        var batch = (
+          /** @type {Batch} */
+          current_batch
+        );
+        if (!__privateGet(this, _batches).has(batch)) return;
+        var key = (
+          /** @type {Key} */
+          __privateGet(this, _batches).get(batch)
+        );
+        var onscreen = __privateGet(this, _onscreen).get(key);
+        if (onscreen) {
+          resume_effect(onscreen);
+          __privateGet(this, _outroing).delete(key);
+        } else {
+          var offscreen = __privateGet(this, _offscreen).get(key);
+          if (offscreen) {
+            __privateGet(this, _onscreen).set(key, offscreen.effect);
+            __privateGet(this, _offscreen).delete(key);
+            offscreen.fragment.lastChild.remove();
+            this.anchor.before(offscreen.fragment);
+            onscreen = offscreen.effect;
+          }
+        }
+        for (const [b, k] of __privateGet(this, _batches)) {
+          __privateGet(this, _batches).delete(b);
+          if (b === batch) {
+            break;
+          }
+          const offscreen2 = __privateGet(this, _offscreen).get(k);
+          if (offscreen2) {
+            destroy_effect(offscreen2.effect);
+            __privateGet(this, _offscreen).delete(k);
+          }
+        }
+        for (const [k, effect2] of __privateGet(this, _onscreen)) {
+          if (k === key || __privateGet(this, _outroing).has(k)) continue;
+          const on_destroy = () => {
+            const keys = Array.from(__privateGet(this, _batches).values());
+            if (keys.includes(k)) {
+              var fragment = document.createDocumentFragment();
+              move_effect(effect2, fragment);
+              fragment.append(create_text());
+              __privateGet(this, _offscreen).set(k, { effect: effect2, fragment });
+            } else {
+              destroy_effect(effect2);
+            }
+            __privateGet(this, _outroing).delete(k);
+            __privateGet(this, _onscreen).delete(k);
+          };
+          if (__privateGet(this, _transition) || !onscreen) {
+            __privateGet(this, _outroing).add(k);
+            pause_effect(effect2, on_destroy, false);
+          } else {
+            on_destroy();
+          }
+        }
+      });
+      /**
+       * @param {Batch} batch
+       */
+      __privateAdd(this, _discard, (batch) => {
+        __privateGet(this, _batches).delete(batch);
+        const keys = Array.from(__privateGet(this, _batches).values());
+        for (const [k, branch2] of __privateGet(this, _offscreen)) {
+          if (!keys.includes(k)) {
+            destroy_effect(branch2.effect);
+            __privateGet(this, _offscreen).delete(k);
+          }
+        }
+      });
+      this.anchor = anchor;
+      __privateSet(this, _transition, transition);
+    }
+    /**
+     *
+     * @param {any} key
+     * @param {null | ((target: TemplateNode) => void)} fn
+     */
+    ensure(key, fn) {
+      var batch = (
+        /** @type {Batch} */
+        current_batch
+      );
+      var defer = should_defer_append();
+      if (fn && !__privateGet(this, _onscreen).has(key) && !__privateGet(this, _offscreen).has(key)) {
+        if (defer) {
+          var fragment = document.createDocumentFragment();
+          var target = create_text();
+          fragment.append(target);
+          __privateGet(this, _offscreen).set(key, {
+            effect: branch(() => fn(target)),
+            fragment
+          });
+        } else {
+          __privateGet(this, _onscreen).set(
+            key,
+            branch(() => fn(this.anchor))
+          );
+        }
+      }
+      __privateGet(this, _batches).set(batch, key);
+      if (defer) {
+        for (const [k, effect2] of __privateGet(this, _onscreen)) {
+          if (k === key) {
+            batch.skipped_effects.delete(effect2);
+          } else {
+            batch.skipped_effects.add(effect2);
+          }
+        }
+        for (const [k, branch2] of __privateGet(this, _offscreen)) {
+          if (k === key) {
+            batch.skipped_effects.delete(branch2.effect);
+          } else {
+            batch.skipped_effects.add(branch2.effect);
+          }
+        }
+        batch.oncommit(__privateGet(this, _commit));
+        batch.ondiscard(__privateGet(this, _discard));
+      } else {
+        __privateGet(this, _commit).call(this);
+      }
+    }
+  }
+  _batches = new WeakMap();
+  _onscreen = new WeakMap();
+  _offscreen = new WeakMap();
+  _outroing = new WeakMap();
+  _transition = new WeakMap();
+  _commit = new WeakMap();
+  _discard = new WeakMap();
+  function if_block(node, fn, elseif = false) {
+    var branches = new BranchManager(node);
+    var flags2 = elseif ? EFFECT_TRANSPARENT : 0;
+    function update_branch(condition, fn2) {
+      branches.ensure(condition, fn2);
+    }
+    block(() => {
+      var has_branch = false;
+      fn((fn2, flag = true) => {
+        has_branch = true;
+        update_branch(flag, fn2);
+      });
+      if (!has_branch) {
+        update_branch(false, null);
+      }
+    }, flags2);
+  }
+  function pause_effects(state2, to_destroy, controlled_anchor) {
+    var transitions = [];
+    var length = to_destroy.length;
+    var group;
+    var remaining = to_destroy.length;
+    for (var i = 0; i < length; i++) {
+      let effect2 = to_destroy[i];
+      pause_effect(
+        effect2,
+        () => {
+          if (group) {
+            group.pending.delete(effect2);
+            group.done.add(effect2);
+            if (group.pending.size === 0) {
+              var groups = (
+                /** @type {Set<EachOutroGroup>} */
+                state2.outrogroups
+              );
+              destroy_effects(array_from(group.done));
+              groups.delete(group);
+              if (groups.size === 0) {
+                state2.outrogroups = null;
+              }
+            }
+          } else {
+            remaining -= 1;
+          }
+        },
+        false
+      );
+    }
+    if (remaining === 0) {
+      var fast_path = transitions.length === 0 && controlled_anchor !== null;
+      if (fast_path) {
+        var anchor = (
+          /** @type {Element} */
+          controlled_anchor
+        );
+        var parent_node = (
+          /** @type {Element} */
+          anchor.parentNode
+        );
+        clear_text_content(parent_node);
+        parent_node.append(anchor);
+        state2.items.clear();
+      }
+      destroy_effects(to_destroy, !fast_path);
+    } else {
+      group = {
+        pending: new Set(to_destroy),
+        done: /* @__PURE__ */ new Set()
+      };
+      (state2.outrogroups ?? (state2.outrogroups = /* @__PURE__ */ new Set())).add(group);
+    }
+  }
+  function destroy_effects(to_destroy, remove_dom = true) {
+    for (var i = 0; i < to_destroy.length; i++) {
+      destroy_effect(to_destroy[i], remove_dom);
+    }
+  }
+  var offscreen_anchor;
+  function each(node, flags2, get_collection, get_key, render_fn, fallback_fn = null) {
+    var anchor = node;
+    var items = /* @__PURE__ */ new Map();
+    {
+      var parent_node = (
+        /** @type {Element} */
+        node
+      );
+      anchor = parent_node.appendChild(create_text());
+    }
+    var fallback = null;
+    var each_array = /* @__PURE__ */ derived_safe_equal(() => {
+      var collection = get_collection();
+      return is_array(collection) ? collection : collection == null ? [] : array_from(collection);
+    });
+    var array;
+    var first_run = true;
+    function commit() {
+      state2.fallback = fallback;
+      reconcile(state2, array, anchor, flags2, get_key);
+      if (fallback !== null) {
+        if (array.length === 0) {
+          if ((fallback.f & EFFECT_OFFSCREEN) === 0) {
+            resume_effect(fallback);
+          } else {
+            fallback.f ^= EFFECT_OFFSCREEN;
+            move(fallback, null, anchor);
+          }
+        } else {
+          pause_effect(fallback, () => {
+            fallback = null;
+          });
+        }
+      }
+    }
+    var effect2 = block(() => {
+      array = /** @type {V[]} */
+      get(each_array);
+      var length = array.length;
+      var keys = /* @__PURE__ */ new Set();
+      var batch = (
+        /** @type {Batch} */
+        current_batch
+      );
+      var defer = should_defer_append();
+      for (var index = 0; index < length; index += 1) {
+        var value = array[index];
+        var key = get_key(value, index);
+        var item = first_run ? null : items.get(key);
+        if (item) {
+          if (item.v) internal_set(item.v, value);
+          if (item.i) internal_set(item.i, index);
+          if (defer) {
+            batch.skipped_effects.delete(item.e);
+          }
+        } else {
+          item = create_item(
+            items,
+            first_run ? anchor : offscreen_anchor ?? (offscreen_anchor = create_text()),
+            value,
+            key,
+            index,
+            render_fn,
+            flags2,
+            get_collection
+          );
+          if (!first_run) {
+            item.e.f |= EFFECT_OFFSCREEN;
+          }
+          items.set(key, item);
+        }
+        keys.add(key);
+      }
+      if (length === 0 && fallback_fn && !fallback) {
+        if (first_run) {
+          fallback = branch(() => fallback_fn(anchor));
+        } else {
+          fallback = branch(() => fallback_fn(offscreen_anchor ?? (offscreen_anchor = create_text())));
+          fallback.f |= EFFECT_OFFSCREEN;
+        }
+      }
+      if (!first_run) {
+        if (defer) {
+          for (const [key2, item2] of items) {
+            if (!keys.has(key2)) {
+              batch.skipped_effects.add(item2.e);
+            }
+          }
+          batch.oncommit(commit);
+          batch.ondiscard(() => {
+          });
+        } else {
+          commit();
+        }
+      }
+      get(each_array);
+    });
+    var state2 = { effect: effect2, items, outrogroups: null, fallback };
+    first_run = false;
+  }
+  function reconcile(state2, array, anchor, flags2, get_key) {
+    var _a2;
+    var length = array.length;
+    var items = state2.items;
+    var current = state2.effect.first;
+    var seen;
+    var prev = null;
+    var matched = [];
+    var stashed = [];
+    var value;
+    var key;
+    var effect2;
+    var i;
+    for (i = 0; i < length; i += 1) {
+      value = array[i];
+      key = get_key(value, i);
+      effect2 = /** @type {EachItem} */
+      items.get(key).e;
+      if (state2.outrogroups !== null) {
+        for (const group of state2.outrogroups) {
+          group.pending.delete(effect2);
+          group.done.delete(effect2);
+        }
+      }
+      if ((effect2.f & EFFECT_OFFSCREEN) !== 0) {
+        effect2.f ^= EFFECT_OFFSCREEN;
+        if (effect2 === current) {
+          move(effect2, null, anchor);
+        } else {
+          var next = prev ? prev.next : current;
+          if (effect2 === state2.effect.last) {
+            state2.effect.last = effect2.prev;
+          }
+          if (effect2.prev) effect2.prev.next = effect2.next;
+          if (effect2.next) effect2.next.prev = effect2.prev;
+          link(state2, prev, effect2);
+          link(state2, effect2, next);
+          move(effect2, next, anchor);
+          prev = effect2;
+          matched = [];
+          stashed = [];
+          current = prev.next;
+          continue;
+        }
+      }
+      if ((effect2.f & INERT) !== 0) {
+        resume_effect(effect2);
+      }
+      if (effect2 !== current) {
+        if (seen !== void 0 && seen.has(effect2)) {
+          if (matched.length < stashed.length) {
+            var start = stashed[0];
+            var j;
+            prev = start.prev;
+            var a = matched[0];
+            var b = matched[matched.length - 1];
+            for (j = 0; j < matched.length; j += 1) {
+              move(matched[j], start, anchor);
+            }
+            for (j = 0; j < stashed.length; j += 1) {
+              seen.delete(stashed[j]);
+            }
+            link(state2, a.prev, b.next);
+            link(state2, prev, a);
+            link(state2, b, start);
+            current = start;
+            prev = b;
+            i -= 1;
+            matched = [];
+            stashed = [];
+          } else {
+            seen.delete(effect2);
+            move(effect2, current, anchor);
+            link(state2, effect2.prev, effect2.next);
+            link(state2, effect2, prev === null ? state2.effect.first : prev.next);
+            link(state2, prev, effect2);
+            prev = effect2;
+          }
+          continue;
+        }
+        matched = [];
+        stashed = [];
+        while (current !== null && current !== effect2) {
+          (seen ?? (seen = /* @__PURE__ */ new Set())).add(current);
+          stashed.push(current);
+          current = current.next;
+        }
+        if (current === null) {
+          continue;
+        }
+      }
+      if ((effect2.f & EFFECT_OFFSCREEN) === 0) {
+        matched.push(effect2);
+      }
+      prev = effect2;
+      current = effect2.next;
+    }
+    if (state2.outrogroups !== null) {
+      for (const group of state2.outrogroups) {
+        if (group.pending.size === 0) {
+          destroy_effects(array_from(group.done));
+          (_a2 = state2.outrogroups) == null ? void 0 : _a2.delete(group);
+        }
+      }
+      if (state2.outrogroups.size === 0) {
+        state2.outrogroups = null;
+      }
+    }
+    if (current !== null || seen !== void 0) {
+      var to_destroy = [];
+      if (seen !== void 0) {
+        for (effect2 of seen) {
+          if ((effect2.f & INERT) === 0) {
+            to_destroy.push(effect2);
+          }
+        }
+      }
+      while (current !== null) {
+        if ((current.f & INERT) === 0 && current !== state2.fallback) {
+          to_destroy.push(current);
+        }
+        current = current.next;
+      }
+      var destroy_length = to_destroy.length;
+      if (destroy_length > 0) {
+        var controlled_anchor = length === 0 ? anchor : null;
+        pause_effects(state2, to_destroy, controlled_anchor);
+      }
+    }
+  }
+  function create_item(items, anchor, value, key, index, render_fn, flags2, get_collection) {
+    var v = (flags2 & EACH_ITEM_REACTIVE) !== 0 ? (flags2 & EACH_ITEM_IMMUTABLE) === 0 ? /* @__PURE__ */ mutable_source(value, false, false) : source(value) : null;
+    var i = (flags2 & EACH_INDEX_REACTIVE) !== 0 ? source(index) : null;
+    return {
+      v,
+      i,
+      e: branch(() => {
+        render_fn(anchor, v ?? value, i ?? index, get_collection);
+        return () => {
+          items.delete(key);
+        };
+      })
+    };
+  }
+  function move(effect2, next, anchor) {
+    if (!effect2.nodes) return;
+    var node = effect2.nodes.start;
+    var end = effect2.nodes.end;
+    var dest = next && (next.f & EFFECT_OFFSCREEN) === 0 ? (
+      /** @type {EffectNodes} */
+      next.nodes.start
+    ) : anchor;
+    while (node !== null) {
+      var next_node = (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ get_next_sibling(node)
+      );
+      dest.before(node);
+      if (node === end) {
+        return;
+      }
+      node = next_node;
+    }
+  }
+  function link(state2, prev, next) {
+    if (prev === null) {
+      state2.effect.first = next;
+    } else {
+      prev.next = next;
+    }
+    if (next === null) {
+      state2.effect.last = prev;
+    } else {
+      next.prev = prev;
+    }
+  }
+  function append_styles(anchor, css) {
+    effect(() => {
+      var root2 = anchor.getRootNode();
+      var target = (
+        /** @type {ShadowRoot} */
+        root2.host ? (
+          /** @type {ShadowRoot} */
+          root2
+        ) : (
+          /** @type {Document} */
+          root2.head ?? /** @type {Document} */
+          root2.ownerDocument.head
+        )
+      );
+      if (!target.querySelector("#" + css.hash)) {
+        const style = document.createElement("style");
+        style.id = css.hash;
+        style.textContent = css.code;
+        target.appendChild(style);
+      }
+    });
+  }
+  const whitespace = [..." 	\n\r\f \v\uFEFF"];
+  function to_class(value, hash, directives) {
+    var classname = value == null ? "" : "" + value;
+    if (directives) {
+      for (var key in directives) {
+        if (directives[key]) {
+          classname = classname ? classname + " " + key : key;
+        } else if (classname.length) {
+          var len = key.length;
+          var a = 0;
+          while ((a = classname.indexOf(key, a)) >= 0) {
+            var b = a + len;
+            if ((a === 0 || whitespace.includes(classname[a - 1])) && (b === classname.length || whitespace.includes(classname[b]))) {
+              classname = (a === 0 ? "" : classname.substring(0, a)) + classname.substring(b + 1);
+            } else {
+              a = b;
+            }
+          }
+        }
+      }
+    }
+    return classname === "" ? null : classname;
+  }
+  function to_style(value, styles) {
+    return value == null ? null : String(value);
+  }
+  function set_class(dom, is_html, value, hash, prev_classes, next_classes) {
+    var prev = dom.__className;
+    if (prev !== value || prev === void 0) {
+      var next_class_name = to_class(value, hash, next_classes);
+      {
+        if (next_class_name == null) {
+          dom.removeAttribute("class");
+        } else {
+          dom.className = next_class_name;
+        }
+      }
+      dom.__className = value;
+    } else if (next_classes && prev_classes !== next_classes) {
+      for (var key in next_classes) {
+        var is_present = !!next_classes[key];
+        if (prev_classes == null || is_present !== !!prev_classes[key]) {
+          dom.classList.toggle(key, is_present);
+        }
+      }
+    }
+    return next_classes;
+  }
+  function set_style(dom, value, prev_styles, next_styles) {
+    var prev = dom.__style;
+    if (prev !== value) {
+      var next_style_attr = to_style(value);
+      {
+        if (next_style_attr == null) {
+          dom.removeAttribute("style");
+        } else {
+          dom.style.cssText = next_style_attr;
+        }
+      }
+      dom.__style = value;
+    }
+    return next_styles;
+  }
+  function bind_value(input, get2, set2 = get2) {
+    var batches2 = /* @__PURE__ */ new WeakSet();
+    listen_to_event_and_reset_event(input, "input", async (is_reset) => {
+      var value = is_reset ? input.defaultValue : input.value;
+      value = is_numberlike_input(input) ? to_number(value) : value;
+      set2(value);
+      if (current_batch !== null) {
+        batches2.add(current_batch);
+      }
+      await tick();
+      if (value !== (value = get2())) {
+        var start = input.selectionStart;
+        var end = input.selectionEnd;
+        var length = input.value.length;
+        input.value = value ?? "";
+        if (end !== null) {
+          var new_length = input.value.length;
+          if (start === end && end === length && new_length > length) {
+            input.selectionStart = new_length;
+            input.selectionEnd = new_length;
+          } else {
+            input.selectionStart = start;
+            input.selectionEnd = Math.min(end, new_length);
+          }
+        }
+      }
+    });
+    if (
+      // If we are hydrating and the value has since changed,
+      // then use the updated value from the input instead.
+      // If defaultValue is set, then value == defaultValue
+      // TODO Svelte 6: remove input.value check and set to empty string?
+      untrack(get2) == null && input.value
+    ) {
+      set2(is_numberlike_input(input) ? to_number(input.value) : input.value);
+      if (current_batch !== null) {
+        batches2.add(current_batch);
+      }
+    }
+    render_effect(() => {
+      var value = get2();
+      if (input === document.activeElement) {
+        var batch = (
+          /** @type {Batch} */
+          previous_batch ?? current_batch
+        );
+        if (batches2.has(batch)) {
+          return;
+        }
+      }
+      if (is_numberlike_input(input) && value === to_number(input.value)) {
+        return;
+      }
+      if (input.type === "date" && !value && !input.value) {
+        return;
+      }
+      if (value !== input.value) {
+        input.value = value ?? "";
+      }
+    });
+  }
+  function is_numberlike_input(input) {
+    var type = input.type;
+    return type === "number" || type === "range";
+  }
+  function to_number(value) {
+    return value === "" ? null : +value;
+  }
+  function is_bound_this(bound_value, element_or_component) {
+    return bound_value === element_or_component || (bound_value == null ? void 0 : bound_value[STATE_SYMBOL]) === element_or_component;
+  }
+  function bind_this(element_or_component = {}, update, get_value, get_parts) {
+    effect(() => {
+      var old_parts;
+      var parts;
+      render_effect(() => {
+        old_parts = parts;
+        parts = [];
+        untrack(() => {
+          if (element_or_component !== get_value(...parts)) {
+            update(element_or_component, ...parts);
+            if (old_parts && is_bound_this(get_value(...old_parts), element_or_component)) {
+              update(null, ...old_parts);
+            }
+          }
+        });
+      });
+      return () => {
+        queue_micro_task(() => {
+          if (parts && is_bound_this(get_value(...parts), element_or_component)) {
+            update(null, ...parts);
+          }
+        });
+      };
+    });
+    return element_or_component;
+  }
+  const PUBLIC_VERSION = "5";
+  if (typeof window !== "undefined") {
+    ((_a = window.__svelte ?? (window.__svelte = {})).v ?? (_a.v = /* @__PURE__ */ new Set())).add(PUBLIC_VERSION);
+  }
+  function deepElementFromPoint(x, y) {
+    let element = document.elementFromPoint(x, y);
+    if (!element) return null;
+    while (element == null ? void 0 : element.shadowRoot) {
+      const inner = element.shadowRoot.elementFromPoint(x, y);
+      if (!inner || inner === element) break;
+      element = inner;
+    }
+    return element;
+  }
+  function getSelector(element) {
+    const elementRoot = element.getRootNode();
+    if (element.id && !element.id.startsWith("heroshot") && !(elementRoot instanceof ShadowRoot)) {
+      return `#${element.id}`;
+    }
+    const path = [];
+    let current = element;
+    for (let depth = 0; (current == null ? void 0 : current.nodeType) === Node.ELEMENT_NODE && depth < 20; depth++) {
+      const root2 = current.getRootNode();
+      const isInShadow = root2 instanceof ShadowRoot;
+      const parent = current.parentElement;
+      let selector = current.tagName.toLowerCase();
+      if (current.id && !current.id.startsWith("heroshot")) {
+        selector = `#${current.id}`;
+        if (!isInShadow) {
+          path.unshift(selector);
+          break;
+        }
+      } else {
+        if (current.className && typeof current.className === "string") {
+          const classes = current.className.trim().split(/\s+/).filter((cls) => cls && !cls.startsWith("heroshot"));
+          if (classes.length > 0) {
+            selector += "." + classes.slice(0, 2).join(".");
+          }
+        }
+      }
+      const siblingContainer = parent ?? (root2 instanceof ShadowRoot ? root2 : null);
+      if (siblingContainer) {
+        const currentTagName = current.tagName;
+        const siblings = [...siblingContainer.children].filter(
+          (child2) => child2.tagName === currentTagName
+        );
+        if (siblings.length > 1) {
+          const index = siblings.indexOf(current) + 1;
+          selector += `:nth-of-type(${index})`;
+        }
+      }
+      path.unshift(selector);
+      if (parent) {
+        current = parent;
+      } else if (root2 instanceof ShadowRoot) {
+        path.unshift(">>>");
+        current = root2.host;
+      } else {
+        current = null;
+      }
+    }
+    return path.join(" > ").replaceAll("> >>> >", " >>> ");
+  }
+  var root_1$1 = /* @__PURE__ */ from_html(`<p class="empty svelte-1tkp9dc">No screenshots added yet. Click the crosshair to pick an element.</p>`);
+  var root_3$1 = /* @__PURE__ */ from_html(`<li class="list-item svelte-1tkp9dc"><button class="item-info svelte-1tkp9dc" title="Navigate to this element"><span class="item-name svelte-1tkp9dc"> </span> <span class="item-selector svelte-1tkp9dc"> </span></button> <button class="remove-btn svelte-1tkp9dc" title="Remove screenshot"><svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="3 6 5 6 21 6"></polyline><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"></path></svg></button></li>`);
+  var root_2$1 = /* @__PURE__ */ from_html(`<ul class="list svelte-1tkp9dc"></ul>`);
+  var root$1 = /* @__PURE__ */ from_html(`<div class="backdrop svelte-1tkp9dc" role="presentation"><div class="dialog svelte-1tkp9dc" role="dialog" aria-modal="true" aria-labelledby="dialog-title" tabindex="0"><div class="header svelte-1tkp9dc"><h3 id="dialog-title" class="svelte-1tkp9dc"> </h3> <button class="close-btn svelte-1tkp9dc" title="Close"><svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg></button></div> <div class="content svelte-1tkp9dc"><!></div></div></div>`);
+  const $$css$2 = {
+    hash: "svelte-1tkp9dc",
+    code: ".backdrop.svelte-1tkp9dc {position:fixed;inset:0;background:rgba(0, 0, 0, 0.6);display:flex;align-items:center;justify-content:center;z-index:2147483647;}.dialog.svelte-1tkp9dc {background:#1a1a2e;border-radius:12px;min-width:500px;max-width:90vw;max-height:80vh;box-shadow:0 8px 32px rgba(0, 0, 0, 0.4);font-family:-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;color:#fff;display:flex;flex-direction:column;}.header.svelte-1tkp9dc {display:flex;align-items:center;justify-content:space-between;padding:20px 24px;border-bottom:1px solid #2d2d44;}h3.svelte-1tkp9dc {margin:0;font-size:18px;font-weight:600;}.close-btn.svelte-1tkp9dc {width:32px;height:32px;border:none;border-radius:6px;background:transparent;color:#aaa;cursor:pointer;display:flex;align-items:center;justify-content:center;transition:all 0.2s;}.close-btn.svelte-1tkp9dc:hover {background:#2d2d44;color:#fff;}.content.svelte-1tkp9dc {padding:16px 24px 24px;overflow-y:auto;flex:1;}.empty.svelte-1tkp9dc {color:#666;text-align:center;padding:32px 0;margin:0;}.list.svelte-1tkp9dc {list-style:none;margin:0;padding:0;display:flex;flex-direction:column;gap:8px;}.list-item.svelte-1tkp9dc {display:flex;align-items:center;gap:12px;padding:12px 16px;background:#2d2d44;border-radius:8px;transition:background 0.2s;}.list-item.svelte-1tkp9dc:hover {background:#3d3d5c;}.item-info.svelte-1tkp9dc {flex:1;min-width:0;display:flex;flex-direction:column;align-items:flex-start;gap:4px;background:transparent;border:none;padding:0;cursor:pointer;text-align:left;}.item-info.svelte-1tkp9dc:hover .item-name:where(.svelte-1tkp9dc) {color:#3b82f6;}.item-name.svelte-1tkp9dc {font-weight:600;color:#fff;}.item-selector.svelte-1tkp9dc {font-family:monospace;font-size:12px;color:#888;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}.remove-btn.svelte-1tkp9dc {width:32px;height:32px;border:none;border-radius:6px;background:transparent;color:#666;cursor:pointer;display:flex;align-items:center;justify-content:center;transition:all 0.2s;flex-shrink:0;}.remove-btn.svelte-1tkp9dc:hover {background:#ef4444;color:#fff;}"
+  };
+  function ListDialog($$anchor, $$props) {
+    push($$props, true);
+    append_styles($$anchor, $$css$2);
+    function stopKeyboardEvent(event2) {
+      event2.stopPropagation();
+      if (event2.key === "Escape") {
+        $$props.onClose();
+      }
+    }
+    var div = root$1();
+    div.__click = function(...$$args) {
+      var _a2;
+      (_a2 = $$props.onClose) == null ? void 0 : _a2.apply(this, $$args);
+    };
+    div.__keydown = stopKeyboardEvent;
+    div.__keyup = (event2) => event2.stopPropagation();
+    var div_1 = child(div);
+    div_1.__click = (event2) => event2.stopPropagation();
+    div_1.__keydown = stopKeyboardEvent;
+    div_1.__keyup = (event2) => event2.stopPropagation();
+    var div_2 = child(div_1);
+    var h3 = child(div_2);
+    var text = child(h3);
+    var button = sibling(h3, 2);
+    button.__click = function(...$$args) {
+      var _a2;
+      (_a2 = $$props.onClose) == null ? void 0 : _a2.apply(this, $$args);
+    };
+    var div_3 = sibling(div_2, 2);
+    var node = child(div_3);
+    {
+      var consequent = ($$anchor2) => {
+        var p = root_1$1();
+        append($$anchor2, p);
+      };
+      var alternate = ($$anchor2) => {
+        var ul = root_2$1();
+        each(ul, 21, () => $$props.screenshots, (screenshot) => screenshot.id, ($$anchor3, screenshot) => {
+          var li = root_3$1();
+          var button_1 = child(li);
+          button_1.__click = () => $$props.onSelect(get(screenshot));
+          var span = child(button_1);
+          var text_1 = child(span);
+          var span_1 = sibling(span, 2);
+          var text_2 = child(span_1);
+          var button_2 = sibling(button_1, 2);
+          button_2.__click = () => $$props.onRemove(get(screenshot).id);
+          template_effect(() => {
+            set_text(text_1, get(screenshot).name);
+            set_text(text_2, get(screenshot).selector);
+          });
+          append($$anchor3, li);
+        });
+        append($$anchor2, ul);
+      };
+      if_block(node, ($$render) => {
+        if ($$props.screenshots.length === 0) $$render(consequent);
+        else $$render(alternate, false);
+      });
+    }
+    template_effect(() => set_text(text, `Screenshots (${$$props.screenshots.length ?? ""})`));
+    event("keypress", div, (event2) => event2.stopPropagation());
+    event("keypress", div_1, (event2) => event2.stopPropagation());
+    append($$anchor, div);
+    pop();
+  }
+  delegate(["click", "keydown", "keyup"]);
+  var root = /* @__PURE__ */ from_html(`<div class="backdrop svelte-1eaujs8" role="presentation"><div class="modal svelte-1eaujs8" role="dialog" aria-modal="true" aria-labelledby="modal-title" tabindex="0"><h3 id="modal-title" class="svelte-1eaujs8">Name this screenshot</h3> <p class="selector-preview svelte-1eaujs8"> </p> <form><input type="text" placeholder="e.g., hero-section, login-button" class="input svelte-1eaujs8"/> <div class="actions svelte-1eaujs8"><button type="button" class="btn-secondary svelte-1eaujs8">Cancel</button> <button type="submit" class="btn-primary svelte-1eaujs8">Save</button></div></form></div></div>`);
+  const $$css$1 = {
+    hash: "svelte-1eaujs8",
+    code: ".backdrop.svelte-1eaujs8 {position:fixed;inset:0;background:rgba(0, 0, 0, 0.6);display:flex;align-items:center;justify-content:center;z-index:2147483647;}.modal.svelte-1eaujs8 {background:#1a1a2e;border-radius:12px;padding:24px;min-width:400px;max-width:90vw;box-shadow:0 8px 32px rgba(0, 0, 0, 0.4);font-family:-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;color:#fff;}h3.svelte-1eaujs8 {margin:0 0 12px;font-size:18px;font-weight:600;}.selector-preview.svelte-1eaujs8 {margin:0 0 20px;padding:8px 12px;background:#2d2d44;border-radius:6px;font-family:monospace;font-size:12px;color:#aaa;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}.input.svelte-1eaujs8 {width:100%;padding:12px;border:2px solid #3d3d5c;border-radius:6px;background:#2d2d44;color:#fff;font-size:14px;outline:none;box-sizing:border-box;transition:border-color 0.2s;}.input.svelte-1eaujs8:focus {border-color:#3b82f6;}.input.svelte-1eaujs8::placeholder {color:#666;}.actions.svelte-1eaujs8 {display:flex;gap:12px;justify-content:flex-end;margin-top:20px;}.btn-primary.svelte-1eaujs8,\n  .btn-secondary.svelte-1eaujs8 {padding:10px 20px;border:none;border-radius:6px;font-size:14px;font-weight:600;cursor:pointer;transition:all 0.2s;}.btn-primary.svelte-1eaujs8 {background:#22c55e;color:#fff;}.btn-primary.svelte-1eaujs8:hover:not(:disabled) {background:#16a34a;}.btn-primary.svelte-1eaujs8:disabled {background:#3d3d5c;color:#666;cursor:not-allowed;}.btn-secondary.svelte-1eaujs8 {background:#3d3d5c;color:#fff;}.btn-secondary.svelte-1eaujs8:hover {background:#4d4d6c;}"
+  };
+  function NameModal($$anchor, $$props) {
+    push($$props, true);
+    append_styles($$anchor, $$css$1);
+    let name = /* @__PURE__ */ state("");
+    let inputElement = /* @__PURE__ */ state(null);
+    user_effect(() => {
+      if (get(inputElement)) {
+        get(inputElement).focus();
+      }
+    });
+    function handleSubmit(event2) {
+      event2.preventDefault();
+      const trimmedName = get(name).trim();
+      if (trimmedName) {
+        $$props.onSave(trimmedName);
+      }
+    }
+    function stopKeyboardEvent(event2) {
+      event2.stopPropagation();
+      if (event2.key === "Escape") {
+        $$props.onCancel();
+      }
+    }
+    var div = root();
+    div.__click = function(...$$args) {
+      var _a2;
+      (_a2 = $$props.onCancel) == null ? void 0 : _a2.apply(this, $$args);
+    };
+    div.__keydown = stopKeyboardEvent;
+    div.__keyup = (event2) => event2.stopPropagation();
+    var div_1 = child(div);
+    div_1.__click = (event2) => event2.stopPropagation();
+    div_1.__keydown = stopKeyboardEvent;
+    div_1.__keyup = (event2) => event2.stopPropagation();
+    var p = sibling(child(div_1), 2);
+    var text = child(p);
+    var form = sibling(p, 2);
+    var input = child(form);
+    bind_this(input, ($$value) => set(inputElement, $$value), () => get(inputElement));
+    var div_2 = sibling(input, 2);
+    var button = child(div_2);
+    button.__click = function(...$$args) {
+      var _a2;
+      (_a2 = $$props.onCancel) == null ? void 0 : _a2.apply(this, $$args);
+    };
+    var button_1 = sibling(button, 2);
+    template_effect(
+      ($0) => {
+        set_text(text, $$props.selector);
+        button_1.disabled = $0;
+      },
+      [() => !get(name).trim()]
+    );
+    event("keypress", div, (event2) => event2.stopPropagation());
+    event("keypress", div_1, (event2) => event2.stopPropagation());
+    event("submit", form, handleSubmit);
+    bind_value(input, () => get(name), ($$value) => set(name, $$value));
+    append($$anchor, div);
+    pop();
+  }
+  delegate(["click", "keydown", "keyup"]);
+  var root_2 = /* @__PURE__ */ from_html(`<span class="badge svelte-1xm8gof"> </span>`);
+  var root_3 = /* @__PURE__ */ from_html(`<div class="overlay svelte-1xm8gof"><div class="overlay-dark svelte-1xm8gof"></div> <div class="overlay-dark svelte-1xm8gof"></div> <div class="overlay-dark svelte-1xm8gof"></div> <div class="overlay-dark svelte-1xm8gof"></div> <div class="highlight svelte-1xm8gof"></div></div>`);
+  var root_1 = /* @__PURE__ */ from_html(`<div class="toolbar svelte-1xm8gof"><button title="Pick element"><svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" class="svelte-1xm8gof"><circle cx="12" cy="12" r="10" class="svelte-1xm8gof"></circle><circle cx="12" cy="12" r="3" class="svelte-1xm8gof"></circle><line x1="12" y1="2" x2="12" y2="6" class="svelte-1xm8gof"></line><line x1="12" y1="18" x2="12" y2="22" class="svelte-1xm8gof"></line><line x1="2" y1="12" x2="6" y2="12" class="svelte-1xm8gof"></line><line x1="18" y1="12" x2="22" y2="12" class="svelte-1xm8gof"></line></svg></button> <span class="status svelte-1xm8gof"> </span> <button title="View screenshots"><svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" class="svelte-1xm8gof"><line x1="8" y1="6" x2="21" y2="6" class="svelte-1xm8gof"></line><line x1="8" y1="12" x2="21" y2="12" class="svelte-1xm8gof"></line><line x1="8" y1="18" x2="21" y2="18" class="svelte-1xm8gof"></line><line x1="3" y1="6" x2="3.01" y2="6" class="svelte-1xm8gof"></line><line x1="3" y1="12" x2="3.01" y2="12" class="svelte-1xm8gof"></line><line x1="3" y1="18" x2="3.01" y2="18" class="svelte-1xm8gof"></line></svg> <!></button> <button class="done-btn svelte-1xm8gof" title="Done - save and close">Done</button></div> <!> <!> <!>`, 1);
+  const $$css = {
+    hash: "svelte-1xm8gof",
+    code: "\n  /*\n   * Styles are encapsulated via Shadow DOM (see main.ts).\n   * No !important needed - host page CSS cannot leak in.\n   */.toolbar.svelte-1xm8gof {position:fixed;bottom:20px;left:50%;transform:translateX(-50%);z-index:2147483647;background:#1a1a2e;border-radius:8px;padding:8px 16px;display:flex;align-items:center;gap:12px;font-family:-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;font-size:13px;color:#fff;box-shadow:0 4px 20px rgba(0, 0, 0, 0.3);user-select:none;}.picker-btn.svelte-1xm8gof,\n  .list-btn.svelte-1xm8gof {width:36px;height:36px;border:2px solid transparent;border-radius:6px;background:#2d2d44;color:#fff;cursor:pointer;display:flex;align-items:center;justify-content:center;transition:all 0.2s;position:relative;}.picker-btn.svelte-1xm8gof:hover,\n  .list-btn.svelte-1xm8gof:hover {background:#3d3d5c;}.picker-btn.active.svelte-1xm8gof {background:#22c55e;border-color:#16a34a;color:#fff;\n    animation: svelte-1xm8gof-pulse 1s infinite;}\n\n  @keyframes svelte-1xm8gof-pulse {\n    0%, 100% { box-shadow: 0 0 0 0 rgba(34, 197, 94, 0.7); }\n    50% { box-shadow: 0 0 0 8px rgba(34, 197, 94, 0); }\n  }.list-btn.has-items.svelte-1xm8gof {background:#3b82f6;}.badge.svelte-1xm8gof {position:absolute;top:-6px;right:-6px;background:#ef4444;color:#fff;font-size:10px;font-weight:bold;min-width:16px;height:16px;border-radius:8px;display:flex;align-items:center;justify-content:center;padding:0 4px;}.status.svelte-1xm8gof {color:#aaa;max-width:400px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}.done-btn.svelte-1xm8gof {padding:8px 16px;border:none;border-radius:6px;background:#22c55e;color:#fff;font-weight:600;cursor:pointer;transition:all 0.2s;}.done-btn.svelte-1xm8gof:hover {background:#16a34a;}.overlay.svelte-1xm8gof {position:fixed;top:0;left:0;width:100vw;height:100vh;z-index:2147483646;pointer-events:none;}.overlay-dark.svelte-1xm8gof {position:fixed;background:rgba(0, 0, 0, 0.5);pointer-events:none;}.highlight.svelte-1xm8gof {position:fixed;border:3px solid #22c55e;background:rgba(34, 197, 94, 0.1);pointer-events:none;box-sizing:border-box;}"
+  };
+  function Toolbar($$anchor, $$props) {
+    push($$props, true);
+    append_styles($$anchor, $$css);
+    function emit(event2) {
+      var _a2;
+      (_a2 = globalThis.__heroshot) == null ? void 0 : _a2.emit(event2);
+    }
+    let isPickerActive = /* @__PURE__ */ state(false);
+    let isHighlighting = /* @__PURE__ */ state(
+      false
+      // True when showing highlight from job
+    );
+    let currentElement = /* @__PURE__ */ state(null);
+    let statusText = /* @__PURE__ */ state("Click crosshair to pick element");
+    let screenshots = /* @__PURE__ */ state(proxy([...$$props.initialScreenshots ?? []]));
+    let pendingPick = /* @__PURE__ */ state(null);
+    let showNameModal = /* @__PURE__ */ state(false);
+    let showListDialog = /* @__PURE__ */ state(false);
+    let scrollY = /* @__PURE__ */ state(proxy(globalThis.scrollY ?? 0));
+    let scrollX = /* @__PURE__ */ state(proxy(globalThis.scrollX ?? 0));
+    let screenshotCount = /* @__PURE__ */ user_derived(() => get(screenshots).length);
+    let showOverlay = /* @__PURE__ */ user_derived(() => (get(isPickerActive) || get(isHighlighting)) && get(overlayRects) !== null);
+    function togglePicker() {
+      set(isPickerActive, !get(isPickerActive));
+      set(isHighlighting, false);
+      if (get(isPickerActive)) {
+        set(statusText, "Hover over element, click to select");
+        document.body.style.cursor = "crosshair";
+      } else {
+        set(statusText, "Click crosshair to pick element");
+        document.body.style.cursor = "";
+        set(currentElement, null);
+      }
+    }
+    function handleMouseMove(event2) {
+      if (!get(isPickerActive)) return;
+      const element = deepElementFromPoint(event2.clientX, event2.clientY);
+      if (element && !element.closest("#heroshot-root") && !element.closest("#heroshot-overlay")) {
+        set(currentElement, element, true);
+        const selector = getSelector(element);
+        set(statusText, selector, true);
+      }
+    }
+    function handleClick(event2) {
+      if (!get(isPickerActive)) return;
+      const { target } = event2;
+      if (target instanceof Element && target.closest("#heroshot-root")) {
+        return;
+      }
+      event2.preventDefault();
+      event2.stopPropagation();
+      if (get(currentElement)) {
+        const selector = getSelector(get(currentElement));
+        const { href } = globalThis.location;
+        set(pendingPick, { url: href, selector }, true);
+        set(showNameModal, true);
+        set(isPickerActive, false);
+        document.body.style.cursor = "";
+      }
+    }
+    function handleKeyDown(event2) {
+      if (event2.key === "Escape") {
+        if (get(showNameModal)) {
+          set(showNameModal, false);
+          set(pendingPick, null);
+        } else if (get(showListDialog)) {
+          set(showListDialog, false);
+        } else if (get(isPickerActive)) {
+          togglePicker();
+        } else if (get(isHighlighting)) {
+          set(isHighlighting, false);
+          set(currentElement, null);
+          set(statusText, "Click crosshair to pick element");
+        }
+      }
+    }
+    function handleNameSave(name) {
+      if (!get(pendingPick)) return;
+      const screenshotData = {
+        id: generateUid(),
+        name,
+        url: get(pendingPick).url,
+        selector: get(pendingPick).selector
+      };
+      set(screenshots, [...get(screenshots), screenshotData], true);
+      emit({ type: "screenshot-added", data: screenshotData });
+      set(showNameModal, false);
+      set(pendingPick, null);
+      set(currentElement, null);
+      set(statusText, "Click crosshair to pick element");
+    }
+    function handleNameCancel() {
+      set(showNameModal, false);
+      set(pendingPick, null);
+      set(currentElement, null);
+      set(statusText, "Click crosshair to pick element");
+    }
+    function handleRemoveScreenshot(id) {
+      set(screenshots, get(screenshots).filter((s) => s.id !== id), true);
+      emit({ type: "screenshot-removed", id });
+    }
+    function handleSelectScreenshot(screenshot) {
+      set(showListDialog, false);
+      emit({
+        type: "screenshot-selected",
+        id: screenshot.id,
+        url: screenshot.url,
+        selector: screenshot.selector
+      });
+    }
+    function querySelectorPiercing(selector) {
+      const parts = selector.split(">>>").map((s) => s.trim());
+      let current = document;
+      for (const part of parts) {
+        if (!part) continue;
+        const root2 = current instanceof Element ? current.shadowRoot ?? current : current;
+        const found = root2.querySelector(part);
+        if (!found) {
+          return null;
+        }
+        current = found;
+      }
+      return current instanceof Element ? current : null;
+    }
+    function highlightElement(selector, attempt = 1) {
+      const maxAttempts = 5;
+      const element = selector.includes(">>>") ? querySelectorPiercing(selector) : document.querySelector(selector);
+      if (element) {
+        set(currentElement, element, true);
+        set(isHighlighting, true);
+        set(statusText, selector, true);
+        element.scrollIntoView({ behavior: "smooth", block: "center" });
+        emit({ type: "job-complete" });
+      } else if (attempt < maxAttempts) {
+        set(statusText, `Looking for element... (attempt ${attempt}/${maxAttempts})`);
+        globalThis.setTimeout(() => highlightElement(selector, attempt + 1), 1e3);
+      } else {
+        set(statusText, `Element not found: ${selector}`);
+        emit({ type: "job-complete" });
+      }
+    }
+    function executePendingJob(job) {
+      highlightElement(job.selector);
+    }
+    function isToolbarJob(value) {
+      return typeof value === "object" && value !== null && "type" in value && "selector" in value;
+    }
+    function handleNewJob(event2) {
+      if (event2 instanceof CustomEvent && isToolbarJob(event2.detail)) {
+        executePendingJob(event2.detail);
+      }
+    }
+    user_effect(() => {
+      const job = $$props.pendingJob;
+      if (job) {
+        globalThis.setTimeout(() => executePendingJob(job), 100);
+      }
+    });
+    user_effect(() => {
+      globalThis.addEventListener("heroshot-job", handleNewJob);
+      return () => globalThis.removeEventListener("heroshot-job", handleNewJob);
+    });
+    function handleDone() {
+      emit({ type: "done" });
+    }
+    function generateUid() {
+      return Math.random().toString(36).slice(2, 10);
+    }
+    function handleScroll() {
+      set(scrollY, globalThis.scrollY, true);
+      set(scrollX, globalThis.scrollX, true);
+    }
+    function getOverlayRects(element, _scrollX, _scrollY) {
+      if (!element) return null;
+      const rect = element.getBoundingClientRect();
+      const { innerWidth, innerHeight } = globalThis;
+      return {
+        top: { top: 0, left: 0, width: innerWidth, height: rect.top },
+        bottom: {
+          top: rect.bottom,
+          left: 0,
+          width: innerWidth,
+          height: innerHeight - rect.bottom
+        },
+        left: {
+          top: rect.top,
+          left: 0,
+          width: rect.left,
+          height: rect.height
+        },
+        right: {
+          top: rect.top,
+          left: rect.right,
+          width: innerWidth - rect.right,
+          height: rect.height
+        },
+        highlight: {
+          top: rect.top,
+          left: rect.left,
+          width: rect.width,
+          height: rect.height
+        }
+      };
+    }
+    let overlayRects = /* @__PURE__ */ user_derived(() => getOverlayRects(get(currentElement), get(scrollX), get(scrollY)));
+    var fragment = root_1();
+    event("scroll", $window, handleScroll);
+    event("mousemove", $document, handleMouseMove);
+    event("click", $document, handleClick);
+    event("keydown", $document, handleKeyDown);
+    var div = first_child(fragment);
+    var button = child(div);
+    let classes;
+    button.__click = togglePicker;
+    var span = sibling(button, 2);
+    var text = child(span);
+    var button_1 = sibling(span, 2);
+    let classes_1;
+    button_1.__click = () => set(showListDialog, true);
+    var node = sibling(child(button_1), 2);
+    {
+      var consequent = ($$anchor2) => {
+        var span_1 = root_2();
+        var text_1 = child(span_1);
+        template_effect(() => set_text(text_1, get(screenshotCount)));
+        append($$anchor2, span_1);
+      };
+      if_block(node, ($$render) => {
+        if (get(screenshotCount) > 0) $$render(consequent);
+      });
+    }
+    var button_2 = sibling(button_1, 2);
+    button_2.__click = handleDone;
+    var node_1 = sibling(div, 2);
+    {
+      var consequent_1 = ($$anchor2) => {
+        var div_1 = root_3();
+        var div_2 = child(div_1);
+        var div_3 = sibling(div_2, 2);
+        var div_4 = sibling(div_3, 2);
+        var div_5 = sibling(div_4, 2);
+        var div_6 = sibling(div_5, 2);
+        template_effect(() => {
+          set_style(div_2, `top:${get(overlayRects).top.top ?? ""}px;left:${get(overlayRects).top.left ?? ""}px;width:${get(overlayRects).top.width ?? ""}px;height:${get(overlayRects).top.height ?? ""}px;`);
+          set_style(div_3, `top:${get(overlayRects).bottom.top ?? ""}px;left:${get(overlayRects).bottom.left ?? ""}px;width:${get(overlayRects).bottom.width ?? ""}px;height:${get(overlayRects).bottom.height ?? ""}px;`);
+          set_style(div_4, `top:${get(overlayRects).left.top ?? ""}px;left:${get(overlayRects).left.left ?? ""}px;width:${get(overlayRects).left.width ?? ""}px;height:${get(overlayRects).left.height ?? ""}px;`);
+          set_style(div_5, `top:${get(overlayRects).right.top ?? ""}px;left:${get(overlayRects).right.left ?? ""}px;width:${get(overlayRects).right.width ?? ""}px;height:${get(overlayRects).right.height ?? ""}px;`);
+          set_style(div_6, `top:${get(overlayRects).highlight.top ?? ""}px;left:${get(overlayRects).highlight.left ?? ""}px;width:${get(overlayRects).highlight.width ?? ""}px;height:${get(overlayRects).highlight.height ?? ""}px;`);
+        });
+        append($$anchor2, div_1);
+      };
+      if_block(node_1, ($$render) => {
+        if (get(showOverlay) && get(overlayRects)) $$render(consequent_1);
+      });
+    }
+    var node_2 = sibling(node_1, 2);
+    {
+      var consequent_2 = ($$anchor2) => {
+        NameModal($$anchor2, {
+          get selector() {
+            return get(pendingPick).selector;
+          },
+          onSave: handleNameSave,
+          onCancel: handleNameCancel
+        });
+      };
+      if_block(node_2, ($$render) => {
+        if (get(showNameModal) && get(pendingPick)) $$render(consequent_2);
+      });
+    }
+    var node_3 = sibling(node_2, 2);
+    {
+      var consequent_3 = ($$anchor2) => {
+        ListDialog($$anchor2, {
+          get screenshots() {
+            return get(screenshots);
+          },
+          onSelect: handleSelectScreenshot,
+          onRemove: handleRemoveScreenshot,
+          onClose: () => set(showListDialog, false)
+        });
+      };
+      if_block(node_3, ($$render) => {
+        if (get(showListDialog)) $$render(consequent_3);
+      });
+    }
+    template_effect(() => {
+      classes = set_class(button, 1, "picker-btn svelte-1xm8gof", null, classes, { active: get(isPickerActive) });
+      set_text(text, get(statusText));
+      classes_1 = set_class(button_1, 1, "list-btn svelte-1xm8gof", null, classes_1, { "has-items": get(screenshotCount) > 0 });
+    });
+    append($$anchor, fragment);
+    pop();
+  }
+  delegate(["click"]);
+  function initToolbar() {
+    if (!globalThis.__heroshot) {
+      globalThis.__heroshot = {
+        initialized: false,
+        screenshots: [],
+        pendingJob: null,
+        emit: () => {
+        }
+      };
+    }
+    if (globalThis.__heroshot.initialized) {
+      return null;
+    }
+    globalThis.__heroshot.initialized = true;
+    const host = document.createElement("div");
+    host.id = "heroshot-root";
+    document.body.append(host);
+    const shadow = host.attachShadow({ mode: "closed" });
+    let component;
+    try {
+      component = mount(Toolbar, {
+        target: shadow,
+        props: {
+          initialScreenshots: [...globalThis.__heroshot.screenshots],
+          pendingJob: globalThis.__heroshot.pendingJob
+        }
+      });
+    } catch {
+      return null;
+    }
+    function cleanup() {
+      void unmount(component);
+      host.remove();
+      if (globalThis.__heroshot) {
+        globalThis.__heroshot.initialized = false;
+      }
+    }
+    return cleanup;
+  }
+  initToolbar();
+  exports.initToolbar = initToolbar;
+  Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+})(this.HeroshotToolbar = this.HeroshotToolbar || {});