houdini-svelte 0.0.0-20240519095346 → 0.0.0-20240522222314

package/build/plugin-cjs/index.js

@@ -154654,1197 +154654,799 @@ function apply_mutations(node, mutations) {
   return obj;
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/errors.js
-var CompileError = class extends Error {
-  name = "CompileError";
-  filename = void 0;
-  position = void 0;
-  start = void 0;
-  end = void 0;
-  constructor(code, message, position) {
-    super(message);
-    this.code = code;
-    this.position = position;
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/patterns.js
+var regex_whitespace = /\s/;
+var regex_whitespaces = /\s+/;
+var regex_starts_with_newline = /^\r?\n/;
+var regex_starts_with_whitespaces = /^[ \t\r\n]+/;
+var regex_ends_with_whitespaces = /[ \t\r\n]+$/;
+var regex_not_whitespace = /[^ \t\r\n]/;
+var regex_whitespaces_strict = /[ \t\n\r\f]+/g;
+var regex_only_whitespaces = /^[ \t\n\r\f]+$/;
+var regex_not_newline_characters = /[^\n]/g;
+var regex_is_valid_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
+var regex_invalid_identifier_chars = /(^[^a-zA-Z_$]|[^a-zA-Z0-9_$])/g;
+var regex_starts_with_vowel = /^[aeiou]/;
+var regex_heading_tags = /^h[1-6]$/;
+var regex_illegal_attribute_character = /(^[0-9-.])|[\^$@%&#?!|()[\]{}^*+~;]/;
+
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/utils/fuzzymatch.js
+function fuzzymatch(name, names) {
+  if (names.length === 0)
+    return null;
+  const set2 = new FuzzySet(names);
+  const matches = set2.get(name);
+  return matches && matches[0][0] > 0.7 ? matches[0][1] : null;
+}
+var GRAM_SIZE_LOWER = 2;
+var GRAM_SIZE_UPPER = 3;
+function _distance(str1, str2) {
+  if (str1 === null && str2 === null) {
+    throw "Trying to compare two null values";
   }
-  toString() {
-    let out = `${this.name}: ${this.message}`;
-    out += `
-(${this.code})`;
-    if (this.filename) {
-      out += `
-${this.filename}`;
-      if (this.start) {
-        out += `${this.start.line}:${this.start.column}`;
+  if (str1 === null || str2 === null)
+    return 0;
+  str1 = String(str1);
+  str2 = String(str2);
+  const distance = levenshtein(str1, str2);
+  return 1 - distance / Math.max(str1.length, str2.length);
+}
+function levenshtein(str1, str2) {
+  const current2 = [];
+  let prev = 0;
+  let value = 0;
+  for (let i3 = 0; i3 <= str2.length; i3++) {
+    for (let j = 0; j <= str1.length; j++) {
+      if (i3 && j) {
+        if (str1.charAt(j - 1) === str2.charAt(i3 - 1)) {
+          value = prev;
+        } else {
+          value = Math.min(current2[j], current2[j - 1], prev) + 1;
+        }
+      } else {
+        value = i3 + j;
       }
+      prev = current2[j];
+      current2[j] = value;
     }
-    return out;
   }
-};
-function e3(node, code, message) {
-  const start = typeof node === "number" ? node : node?.start;
-  const end = typeof node === "number" ? node : node?.end;
-  throw new CompileError(code, message, start !== void 0 && end !== void 0 ? [start, end] : void 0);
+  return current2.pop();
 }
-function options_invalid_value(node, details) {
-  e3(node, "options_invalid_value", `Invalid compiler option: ${details}`);
+var non_word_regex = /[^\w, ]+/;
+function iterate_grams(value, gram_size = 2) {
+  const simplified = "-" + value.toLowerCase().replace(non_word_regex, "") + "-";
+  const len_diff = gram_size - simplified.length;
+  const results = [];
+  if (len_diff > 0) {
+    for (let i3 = 0; i3 < len_diff; ++i3) {
+      value += "-";
+    }
+  }
+  for (let i3 = 0; i3 < simplified.length - gram_size + 1; ++i3) {
+    results.push(simplified.slice(i3, i3 + gram_size));
+  }
+  return results;
 }
-function options_removed(node, details) {
-  e3(node, "options_removed", `Invalid compiler option: ${details}`);
+function gram_counter(value, gram_size = 2) {
+  const result = {};
+  const grams = iterate_grams(value, gram_size);
+  let i3 = 0;
+  for (i3; i3 < grams.length; ++i3) {
+    if (grams[i3] in result) {
+      result[grams[i3]] += 1;
+    } else {
+      result[grams[i3]] = 1;
+    }
+  }
+  return result;
 }
-function options_unrecognised(node, keypath) {
-  e3(node, "options_unrecognised", `Unrecognised compiler option ${keypath}`);
+function sort_descending(a2, b2) {
+  return b2[0] - a2[0];
 }
-function bindable_invalid_location(node) {
-  e3(node, "bindable_invalid_location", "`$bindable()` can only be used inside a `$props()` declaration");
+var FuzzySet = class {
+  exact_set = {};
+  match_dict = {};
+  items = {};
+  constructor(arr) {
+    for (let i3 = GRAM_SIZE_LOWER; i3 < GRAM_SIZE_UPPER + 1; ++i3) {
+      this.items[i3] = [];
+    }
+    for (let i3 = 0; i3 < arr.length; ++i3) {
+      this.add(arr[i3]);
+    }
+  }
+  add(value) {
+    const normalized_value = value.toLowerCase();
+    if (normalized_value in this.exact_set) {
+      return false;
+    }
+    let i3 = GRAM_SIZE_LOWER;
+    for (i3; i3 < GRAM_SIZE_UPPER + 1; ++i3) {
+      this._add(value, i3);
+    }
+  }
+  _add(value, gram_size) {
+    const normalized_value = value.toLowerCase();
+    const items = this.items[gram_size] || [];
+    const index = items.length;
+    items.push(0);
+    const gram_counts = gram_counter(normalized_value, gram_size);
+    let sum_of_square_gram_counts = 0;
+    let gram;
+    let gram_count;
+    for (gram in gram_counts) {
+      gram_count = gram_counts[gram];
+      sum_of_square_gram_counts += Math.pow(gram_count, 2);
+      if (gram in this.match_dict) {
+        this.match_dict[gram].push([index, gram_count]);
+      } else {
+        this.match_dict[gram] = [[index, gram_count]];
+      }
+    }
+    const vector_normal = Math.sqrt(sum_of_square_gram_counts);
+    items[index] = [vector_normal, normalized_value];
+    this.items[gram_size] = items;
+    this.exact_set[normalized_value] = value;
+  }
+  get(value) {
+    const normalized_value = value.toLowerCase();
+    const result = this.exact_set[normalized_value];
+    if (result) {
+      return [[1, result]];
+    }
+    for (let gram_size = GRAM_SIZE_UPPER; gram_size >= GRAM_SIZE_LOWER; --gram_size) {
+      const results = this.__get(value, gram_size);
+      if (results.length > 0)
+        return results;
+    }
+    return null;
+  }
+  __get(value, gram_size) {
+    const normalized_value = value.toLowerCase();
+    const matches = {};
+    const gram_counts = gram_counter(normalized_value, gram_size);
+    const items = this.items[gram_size];
+    let sum_of_square_gram_counts = 0;
+    let gram;
+    let gram_count;
+    let i3;
+    let index;
+    let other_gram_count;
+    for (gram in gram_counts) {
+      gram_count = gram_counts[gram];
+      sum_of_square_gram_counts += Math.pow(gram_count, 2);
+      if (gram in this.match_dict) {
+        for (i3 = 0; i3 < this.match_dict[gram].length; ++i3) {
+          index = this.match_dict[gram][i3][0];
+          other_gram_count = this.match_dict[gram][i3][1];
+          if (index in matches) {
+            matches[index] += gram_count * other_gram_count;
+          } else {
+            matches[index] = gram_count * other_gram_count;
+          }
+        }
+      }
+    }
+    const vector_normal = Math.sqrt(sum_of_square_gram_counts);
+    let results = [];
+    let match_score;
+    for (const match_index in matches) {
+      match_score = matches[match_index];
+      results.push([match_score / (vector_normal * items[match_index][0]), items[match_index][1]]);
+    }
+    results.sort(sort_descending);
+    let new_results = [];
+    const end_index = Math.min(50, results.length);
+    for (let i4 = 0; i4 < end_index; ++i4) {
+      new_results.push([_distance(results[i4][1], normalized_value), results[i4][1]]);
+    }
+    results = new_results;
+    results.sort(sort_descending);
+    new_results = [];
+    for (let i4 = 0; i4 < results.length; ++i4) {
+      if (results[i4][0] === results[0][0]) {
+        new_results.push([results[i4][0], this.exact_set[results[i4][1]]]);
+      }
+    }
+    return new_results;
+  }
+};
+
+// ../../node_modules/.pnpm/locate-character@3.0.0/node_modules/locate-character/src/index.js
+function rangeContains(range, index) {
+  return range.start <= index && index < range.end;
 }
-function constant_assignment(node, thing) {
-  e3(node, "constant_assignment", `Cannot assign to ${thing}`);
+function getLocator(source, options = {}) {
+  const { offsetLine = 0, offsetColumn = 0 } = options;
+  let start = 0;
+  const ranges = source.split("\n").map((line, i4) => {
+    const end = start + line.length + 1;
+    const range = { start, end, line: i4 };
+    start = end;
+    return range;
+  });
+  let i3 = 0;
+  function locator2(search, index) {
+    if (typeof search === "string") {
+      search = source.indexOf(search, index ?? 0);
+    }
+    if (search === -1)
+      return void 0;
+    let range = ranges[i3];
+    const d2 = search >= range.end ? 1 : -1;
+    while (range) {
+      if (rangeContains(range, search)) {
+        return {
+          line: offsetLine + range.line,
+          column: offsetColumn + search - range.start,
+          character: search
+        };
+      }
+      i3 += d2;
+      range = ranges[i3];
+    }
+  }
+  return locator2;
 }
-function constant_binding(node, thing) {
-  e3(node, "constant_binding", `Cannot bind to ${thing}`);
-}
-function declaration_duplicate_module_import(node) {
-  e3(node, "declaration_duplicate_module_import", 'Cannot declare same variable name which is imported inside `<script context="module">`');
+
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/state.js
+var warnings = [];
+var filename;
+var locator = getLocator("", { offsetLine: 1 });
+var ignore_stack = [];
+function reset3(source, options) {
+  const root_dir = options.rootDir?.replace(/\\/g, "/");
+  filename = options.filename?.replace(/\\/g, "/");
+  if (typeof filename === "string" && typeof root_dir === "string" && filename.startsWith(root_dir)) {
+    filename = filename.replace(root_dir, "").replace(/^[/\\]/, "");
+  }
+  locator = getLocator(source, { offsetLine: 1 });
+  warnings = [];
+  ignore_stack = [];
 }
-function derived_invalid_export(node) {
-  e3(node, "derived_invalid_export", "Cannot export derived state from a module. To expose the current derived value, export a function returning its value");
+
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/warnings.js
+function w(node, code, message) {
+  if (ignore_stack.at(-1)?.has(code))
+    return;
+  warnings.push({
+    code,
+    message,
+    filename,
+    start: node?.start !== void 0 ? locator(node.start) : void 0,
+    end: node?.end !== void 0 ? locator(node.end) : void 0
+  });
 }
-function each_item_invalid_assignment(node) {
-  e3(node, "each_item_invalid_assignment", "Cannot reassign or bind to each block argument in runes mode. Use the array and index variables instead (e.g. `array[i] = value` instead of `entry = value`)");
+var codes = [
+  "a11y_accesskey",
+  "a11y_aria_activedescendant_has_tabindex",
+  "a11y_aria_attributes",
+  "a11y_autocomplete_valid",
+  "a11y_autofocus",
+  "a11y_click_events_have_key_events",
+  "a11y_distracting_elements",
+  "a11y_figcaption_index",
+  "a11y_figcaption_parent",
+  "a11y_hidden",
+  "a11y_img_redundant_alt",
+  "a11y_incorrect_aria_attribute_type",
+  "a11y_incorrect_aria_attribute_type_boolean",
+  "a11y_incorrect_aria_attribute_type_id",
+  "a11y_incorrect_aria_attribute_type_idlist",
+  "a11y_incorrect_aria_attribute_type_integer",
+  "a11y_incorrect_aria_attribute_type_token",
+  "a11y_incorrect_aria_attribute_type_tokenlist",
+  "a11y_incorrect_aria_attribute_type_tristate",
+  "a11y_interactive_supports_focus",
+  "a11y_invalid_attribute",
+  "a11y_label_has_associated_control",
+  "a11y_media_has_caption",
+  "a11y_misplaced_role",
+  "a11y_misplaced_scope",
+  "a11y_missing_attribute",
+  "a11y_missing_content",
+  "a11y_mouse_events_have_key_events",
+  "a11y_no_abstract_role",
+  "a11y_no_interactive_element_to_noninteractive_role",
+  "a11y_no_noninteractive_element_interactions",
+  "a11y_no_noninteractive_element_to_interactive_role",
+  "a11y_no_noninteractive_tabindex",
+  "a11y_no_redundant_roles",
+  "a11y_no_static_element_interactions",
+  "a11y_positive_tabindex",
+  "a11y_role_has_required_aria_props",
+  "a11y_role_supports_aria_props",
+  "a11y_role_supports_aria_props_implicit",
+  "a11y_unknown_aria_attribute",
+  "a11y_unknown_role",
+  "legacy_code",
+  "unknown_code",
+  "options_deprecated_accessors",
+  "options_deprecated_immutable",
+  "options_missing_custom_element",
+  "options_removed_enable_sourcemap",
+  "options_removed_hydratable",
+  "options_removed_loop_guard_timeout",
+  "options_renamed_ssr_dom",
+  "derived_iife",
+  "export_let_unused",
+  "non_reactive_update",
+  "perf_avoid_inline_class",
+  "perf_avoid_nested_class",
+  "reactive_declaration_invalid_placement",
+  "reactive_declaration_module_script",
+  "state_referenced_locally",
+  "store_rune_conflict",
+  "css_unused_selector",
+  "attribute_avoid_is",
+  "attribute_global_event_reference",
+  "attribute_illegal_colon",
+  "attribute_invalid_property_name",
+  "bind_invalid_each_rest",
+  "block_empty",
+  "component_name_lowercase",
+  "element_invalid_self_closing_tag",
+  "event_directive_deprecated",
+  "slot_element_deprecated",
+  "svelte_element_invalid_this"
+];
+function a11y_accesskey(node) {
+  w(node, "a11y_accesskey", "Avoid using accesskey");
 }
-function effect_invalid_placement(node) {
-  e3(node, "effect_invalid_placement", "`$effect()` can only be used as an expression statement");
+function a11y_aria_activedescendant_has_tabindex(node) {
+  w(node, "a11y_aria_activedescendant_has_tabindex", "An element with an aria-activedescendant attribute should have a tabindex value");
 }
-function host_invalid_placement(node) {
-  e3(node, "host_invalid_placement", "`$host()` can only be used inside custom element component instances");
+function a11y_aria_attributes(node, name) {
+  w(node, "a11y_aria_attributes", `\`<${name}>\` should not have aria-* attributes`);
 }
-function legacy_export_invalid(node) {
-  e3(node, "legacy_export_invalid", "Cannot use `export let` in runes mode \u2014 use `$props()` instead");
+function a11y_autocomplete_valid(node, value, type) {
+  w(node, "a11y_autocomplete_valid", `'${value}' is an invalid value for 'autocomplete' on \`<input type="${type}">\``);
 }
-function legacy_reactive_statement_invalid(node) {
-  e3(node, "legacy_reactive_statement_invalid", "`$:` is not allowed in runes mode, use `$derived` or `$effect` instead");
+function a11y_autofocus(node) {
+  w(node, "a11y_autofocus", "Avoid using autofocus");
 }
-function module_illegal_default_export(node) {
-  e3(node, "module_illegal_default_export", "A component cannot have a default export");
+function a11y_click_events_have_key_events(node) {
+  w(node, "a11y_click_events_have_key_events", 'Visible, non-interactive elements with a click event must be accompanied by a keyboard event handler. Consider whether an interactive element such as `<button type="button">` or `<a>` might be more appropriate. See https://svelte.dev/docs/accessibility-warnings#a11y-click-events-have-key-events for more details');
 }
-function props_duplicate(node) {
-  e3(node, "props_duplicate", "Cannot use `$props()` more than once");
+function a11y_distracting_elements(node, name) {
+  w(node, "a11y_distracting_elements", `Avoid \`<${name}>\` elements`);
 }
-function props_invalid_identifier(node) {
-  e3(node, "props_invalid_identifier", "`$props()` can only be used with an object destructuring pattern");
+function a11y_figcaption_index(node) {
+  w(node, "a11y_figcaption_index", "`<figcaption>` must be first or last child of `<figure>`");
 }
-function props_invalid_pattern(node) {
-  e3(node, "props_invalid_pattern", "`$props()` assignment must not contain nested properties or computed keys");
+function a11y_figcaption_parent(node) {
+  w(node, "a11y_figcaption_parent", "`<figcaption>` must be an immediate child of `<figure>`");
 }
-function props_invalid_placement(node) {
-  e3(node, "props_invalid_placement", "`$props()` can only be used at the top level of components as a variable declaration initializer");
+function a11y_hidden(node, name) {
+  w(node, "a11y_hidden", `\`<${name}>\` element should not be hidden`);
 }
-function rune_invalid_arguments(node, rune) {
-  e3(node, "rune_invalid_arguments", `\`${rune}\` cannot be called with arguments`);
+function a11y_img_redundant_alt(node) {
+  w(node, "a11y_img_redundant_alt", "Screenreaders already announce `<img>` elements as an image");
 }
-function rune_invalid_arguments_length(node, rune, args) {
-  e3(node, "rune_invalid_arguments_length", `\`${rune}\` must be called with ${args}`);
+function a11y_incorrect_aria_attribute_type(node, attribute, type) {
+  w(node, "a11y_incorrect_aria_attribute_type", `The value of '${attribute}' must be a ${type}`);
 }
-function rune_invalid_computed_property(node) {
-  e3(node, "rune_invalid_computed_property", "Cannot access a computed property of a rune");
+function a11y_incorrect_aria_attribute_type_boolean(node, attribute) {
+  w(node, "a11y_incorrect_aria_attribute_type_boolean", `The value of '${attribute}' must be either 'true' or 'false'. It cannot be empty`);
 }
-function rune_invalid_name(node, name) {
-  e3(node, "rune_invalid_name", `\`${name}\` is not a valid rune`);
+function a11y_incorrect_aria_attribute_type_idlist(node, attribute) {
+  w(node, "a11y_incorrect_aria_attribute_type_idlist", `The value of '${attribute}' must be a space-separated list of strings that represent DOM element IDs`);
 }
-function rune_invalid_usage(node, rune) {
-  e3(node, "rune_invalid_usage", `Cannot use \`${rune}\` rune in non-runes mode`);
+function a11y_incorrect_aria_attribute_type_integer(node, attribute) {
+  w(node, "a11y_incorrect_aria_attribute_type_integer", `The value of '${attribute}' must be an integer`);
 }
-function rune_missing_parentheses(node) {
-  e3(node, "rune_missing_parentheses", "Cannot use rune without parentheses");
+function a11y_incorrect_aria_attribute_type_token(node, attribute, values) {
+  w(node, "a11y_incorrect_aria_attribute_type_token", `The value of '${attribute}' must be exactly one of ${values}`);
 }
-function runes_mode_invalid_import(node, name) {
-  e3(node, "runes_mode_invalid_import", `${name} cannot be used in runes mode`);
+function a11y_incorrect_aria_attribute_type_tokenlist(node, attribute, values) {
+  w(node, "a11y_incorrect_aria_attribute_type_tokenlist", `The value of '${attribute}' must be a space-separated list of one or more of ${values}`);
 }
-function snippet_parameter_assignment(node) {
-  e3(node, "snippet_parameter_assignment", "Cannot reassign or bind to snippet parameter");
+function a11y_incorrect_aria_attribute_type_tristate(node, attribute) {
+  w(node, "a11y_incorrect_aria_attribute_type_tristate", `The value of '${attribute}' must be exactly one of true, false, or mixed`);
 }
-function state_invalid_export(node) {
-  e3(node, "state_invalid_export", "Cannot export state from a module if it is reassigned. Either export a function returning the state value or only mutate the state value's properties");
+function a11y_interactive_supports_focus(node, role) {
+  w(node, "a11y_interactive_supports_focus", `Elements with the '${role}' interactive role must have a tabindex value`);
 }
-function state_invalid_placement(node, rune) {
-  e3(node, "state_invalid_placement", `\`${rune}(...)\` can only be used as a variable declaration initializer or a class field`);
+function a11y_invalid_attribute(node, href_value, href_attribute) {
+  w(node, "a11y_invalid_attribute", `'${href_value}' is not a valid ${href_attribute} attribute`);
 }
-function css_empty_declaration(node) {
-  e3(node, "css_empty_declaration", "Declaration cannot be empty");
+function a11y_label_has_associated_control(node) {
+  w(node, "a11y_label_has_associated_control", "A form label must be associated with a control");
 }
-function css_expected_identifier(node) {
-  e3(node, "css_expected_identifier", "Expected a valid CSS identifier");
+function a11y_media_has_caption(node) {
+  w(node, "a11y_media_has_caption", '`<video>` elements must have a `<track kind="captions">`');
 }
-function css_global_block_invalid_combinator(node, name) {
-  e3(node, "css_global_block_invalid_combinator", `A :global {...} block cannot follow a ${name} combinator`);
+function a11y_misplaced_role(node, name) {
+  w(node, "a11y_misplaced_role", `\`<${name}>\` should not have role attribute`);
 }
-function css_global_block_invalid_declaration(node) {
-  e3(node, "css_global_block_invalid_declaration", "A :global {...} block can only contain rules, not declarations");
+function a11y_misplaced_scope(node) {
+  w(node, "a11y_misplaced_scope", "The scope attribute should only be used with `<th>` elements");
 }
-function css_global_block_invalid_list(node) {
-  e3(node, "css_global_block_invalid_list", "A :global {...} block cannot be part of a selector list with more than one item");
+function a11y_missing_attribute(node, name, article, sequence3) {
+  w(node, "a11y_missing_attribute", `\`<${name}>\` element should have ${article} ${sequence3} attribute`);
 }
-function css_global_block_invalid_modifier(node) {
-  e3(node, "css_global_block_invalid_modifier", "A :global {...} block cannot modify an existing selector");
+function a11y_missing_content(node, name) {
+  w(node, "a11y_missing_content", `\`<${name}>\` element should have child content`);
 }
-function css_global_invalid_placement(node) {
-  e3(node, "css_global_invalid_placement", ":global(...) can be at the start or end of a selector sequence, but not in the middle");
+function a11y_mouse_events_have_key_events(node, event, accompanied_by) {
+  w(node, "a11y_mouse_events_have_key_events", `'${event}' event must be accompanied by '${accompanied_by}' event`);
 }
-function css_global_invalid_selector(node) {
-  e3(node, "css_global_invalid_selector", ":global(...) must contain exactly one selector");
+function a11y_no_abstract_role(node, role) {
+  w(node, "a11y_no_abstract_role", `Abstract role '${role}' is forbidden`);
 }
-function css_global_invalid_selector_list(node) {
-  e3(node, "css_global_invalid_selector_list", ":global(...) must not contain type or universal selectors when used in a compound selector");
+function a11y_no_interactive_element_to_noninteractive_role(node, element, role) {
+  w(node, "a11y_no_interactive_element_to_noninteractive_role", `\`<${element}>\` cannot have role '${role}'`);
 }
-function css_nesting_selector_invalid_placement(node) {
-  e3(node, "css_nesting_selector_invalid_placement", "Nesting selectors can only be used inside a rule");
+function a11y_no_noninteractive_element_interactions(node, element) {
+  w(node, "a11y_no_noninteractive_element_interactions", `Non-interactive element \`<${element}>\` should not be assigned mouse or keyboard event listeners`);
 }
-function css_selector_invalid(node) {
-  e3(node, "css_selector_invalid", "Invalid selector");
+function a11y_no_noninteractive_element_to_interactive_role(node, element, role) {
+  w(node, "a11y_no_noninteractive_element_to_interactive_role", `Non-interactive element \`<${element}>\` cannot have interactive role '${role}'`);
 }
-function css_type_selector_invalid_placement(node) {
-  e3(node, "css_type_selector_invalid_placement", ":global(...) must not be followed with a type selector");
+function a11y_no_noninteractive_tabindex(node) {
+  w(node, "a11y_no_noninteractive_tabindex", "noninteractive element cannot have nonnegative tabIndex value");
 }
-function animation_duplicate(node) {
-  e3(node, "animation_duplicate", "An element can only have one 'animate' directive");
+function a11y_no_redundant_roles(node, role) {
+  w(node, "a11y_no_redundant_roles", `Redundant role '${role}'`);
 }
-function animation_invalid_placement(node) {
-  e3(node, "animation_invalid_placement", "An element that uses the `animate:` directive must be the only child of a keyed `{#each ...}` block");
+function a11y_no_static_element_interactions(node, element, handler) {
+  w(node, "a11y_no_static_element_interactions", `\`<${element}>\` with a ${handler} handler must have an ARIA role`);
 }
-function animation_missing_key(node) {
-  e3(node, "animation_missing_key", "An element that uses the `animate:` directive must be the only child of a keyed `{#each ...}` block. Did you forget to add a key to your each block?");
+function a11y_positive_tabindex(node) {
+  w(node, "a11y_positive_tabindex", "Avoid tabindex values above zero");
 }
-function attribute_contenteditable_dynamic(node) {
-  e3(node, "attribute_contenteditable_dynamic", "'contenteditable' attribute cannot be dynamic if element uses two-way binding");
+function a11y_role_has_required_aria_props(node, role, props) {
+  w(node, "a11y_role_has_required_aria_props", `Elements with the ARIA role "${role}" must have the following attributes defined: ${props}`);
 }
-function attribute_contenteditable_missing(node) {
-  e3(node, "attribute_contenteditable_missing", "'contenteditable' attribute is required for textContent, innerHTML and innerText two-way bindings");
+function a11y_role_supports_aria_props(node, attribute, role) {
+  w(node, "a11y_role_supports_aria_props", `The attribute '${attribute}' is not supported by the role '${role}'`);
 }
-function attribute_duplicate(node) {
-  e3(node, "attribute_duplicate", "Attributes need to be unique");
+function a11y_role_supports_aria_props_implicit(node, attribute, role, name) {
+  w(node, "a11y_role_supports_aria_props_implicit", `The attribute '${attribute}' is not supported by the role '${role}'. This role is implicit on the element \`<${name}>\``);
 }
-function attribute_empty_shorthand(node) {
-  e3(node, "attribute_empty_shorthand", "Attribute shorthand cannot be empty");
+function a11y_unknown_aria_attribute(node, attribute, suggestion) {
+  w(node, "a11y_unknown_aria_attribute", suggestion ? `Unknown aria attribute 'aria-${attribute}'. Did you mean '${suggestion}'?` : `Unknown aria attribute 'aria-${attribute}'`);
 }
-function attribute_invalid_event_handler(node) {
-  e3(node, "attribute_invalid_event_handler", "Event attribute must be a JavaScript expression, not a string");
+function a11y_unknown_role(node, role, suggestion) {
+  w(node, "a11y_unknown_role", suggestion ? `Unknown role '${role}'. Did you mean '${suggestion}'?` : `Unknown role '${role}'`);
 }
-function attribute_invalid_multiple(node) {
-  e3(node, "attribute_invalid_multiple", "'multiple' attribute must be static if select uses two-way binding");
+function legacy_code(node, code, suggestion) {
+  w(node, "legacy_code", `\`${code}\` is no longer valid \u2014 please use \`${suggestion}\` instead`);
 }
-function attribute_invalid_name(node, name) {
-  e3(node, "attribute_invalid_name", `'${name}' is not a valid attribute name`);
-}
-function attribute_invalid_sequence_expression(node) {
-  e3(node, "attribute_invalid_sequence_expression", "Sequence expressions are not allowed as attribute/directive values in runes mode, unless wrapped in parentheses");
-}
-function attribute_invalid_type(node) {
-  e3(node, "attribute_invalid_type", "'type' attribute must be a static text value if input uses two-way binding");
-}
-function bind_invalid_expression(node) {
-  e3(node, "bind_invalid_expression", "Can only bind to an Identifier or MemberExpression");
-}
-function bind_invalid_name(node, name, explanation) {
-  e3(node, "bind_invalid_name", explanation ? `\`bind:${name}\` is not a valid binding. ${explanation}` : `\`bind:${name}\` is not a valid binding`);
-}
-function bind_invalid_target(node, name, elements) {
-  e3(node, "bind_invalid_target", `\`bind:${name}\` can only be used with ${elements}`);
-}
-function bind_invalid_value(node) {
-  e3(node, "bind_invalid_value", "Can only bind to state or props");
-}
-function block_duplicate_clause(node, name) {
-  e3(node, "block_duplicate_clause", `${name} cannot appear more than once within a block`);
-}
-function block_invalid_continuation_placement(node) {
-  e3(node, "block_invalid_continuation_placement", "{:...} block is invalid at this position (did you forget to close the preceeding element or block?)");
-}
-function block_invalid_elseif(node) {
-  e3(node, "block_invalid_elseif", "'elseif' should be 'else if'");
-}
-function block_invalid_placement(node, name, location) {
-  e3(node, "block_invalid_placement", `{#${name} ...} block cannot be ${location}`);
-}
-function block_unclosed(node) {
-  e3(node, "block_unclosed", "Block was left open");
-}
-function block_unexpected_close(node) {
-  e3(node, "block_unexpected_close", "Unexpected block closing tag");
-}
-function component_invalid_directive(node) {
-  e3(node, "component_invalid_directive", "This type of directive is not valid on components");
-}
-function const_tag_invalid_expression(node) {
-  e3(node, "const_tag_invalid_expression", "{@const ...} must consist of a single variable declaration");
-}
-function const_tag_invalid_placement(node) {
-  e3(node, "const_tag_invalid_placement", "`{@const}` must be the immediate child of `{#snippet}`, `{#if}`, `{:else if}`, `{:else}`, `{#each}`, `{:then}`, `{:catch}`, `<svelte:fragment>` or `<Component>`");
-}
-function debug_tag_invalid_arguments(node) {
-  e3(node, "debug_tag_invalid_arguments", "{@debug ...} arguments must be identifiers, not arbitrary expressions");
-}
-function directive_invalid_value(node) {
-  e3(node, "directive_invalid_value", "Directive value must be a JavaScript expression enclosed in curly braces");
-}
-function directive_missing_name(node, type) {
-  e3(node, "directive_missing_name", `\`${type}\` name cannot be empty`);
-}
-function element_invalid_closing_tag(node, name) {
-  e3(node, "element_invalid_closing_tag", `\`</${name}>\` attempted to close an element that was not open`);
-}
-function element_invalid_closing_tag_autoclosed(node, name, reason) {
-  e3(node, "element_invalid_closing_tag_autoclosed", `\`</${name}>\` attempted to close element that was already automatically closed by \`<${reason}>\` (cannot nest \`<${reason}>\` inside \`<${name}>\`)`);
-}
-function element_invalid_tag_name(node) {
-  e3(node, "element_invalid_tag_name", "Expected valid tag name");
-}
-function element_unclosed(node, name) {
-  e3(node, "element_unclosed", `\`<${name}>\` was left open`);
-}
-function event_handler_invalid_component_modifier(node) {
-  e3(node, "event_handler_invalid_component_modifier", "Event modifiers other than 'once' can only be used on DOM elements");
-}
-function event_handler_invalid_modifier(node, list3) {
-  e3(node, "event_handler_invalid_modifier", `Valid event modifiers are ${list3}`);
-}
-function event_handler_invalid_modifier_combination(node, modifier1, modifier2) {
-  e3(node, "event_handler_invalid_modifier_combination", `The '${modifier1}' and '${modifier2}' modifiers cannot be used together`);
-}
-function expected_attribute_value(node) {
-  e3(node, "expected_attribute_value", "Expected attribute value");
-}
-function expected_block_type(node) {
-  e3(node, "expected_block_type", "Expected 'if', 'each', 'await', 'key' or 'snippet'");
-}
-function expected_identifier(node) {
-  e3(node, "expected_identifier", "Expected an identifier");
-}
-function expected_pattern(node) {
-  e3(node, "expected_pattern", "Expected identifier or destructure pattern");
-}
-function expected_token(node, token) {
-  e3(node, "expected_token", `Expected token ${token}`);
-}
-function expected_whitespace(node) {
-  e3(node, "expected_whitespace", "Expected whitespace");
+function unknown_code(node, code, suggestion) {
+  w(node, "unknown_code", suggestion ? `\`${code}\` is not a recognised code (did you mean \`${suggestion}\`?)` : `\`${code}\` is not a recognised code`);
 }
-function js_parse_error(node, message) {
-  e3(node, "js_parse_error", `${message}`);
+function options_deprecated_accessors(node) {
+  w(node, "options_deprecated_accessors", "The `accessors` option has been deprecated. It will have no effect in runes mode");
 }
-function let_directive_invalid_placement(node) {
-  e3(node, "let_directive_invalid_placement", "`let:` directive at invalid position");
+function options_deprecated_immutable(node) {
+  w(node, "options_deprecated_immutable", "The `immutable` option has been deprecated. It will have no effect in runes mode");
 }
-function node_invalid_placement(node, thing, parent2) {
-  e3(node, "node_invalid_placement", `${thing} is invalid inside <${parent2}>`);
+function options_removed_enable_sourcemap(node) {
+  w(node, "options_removed_enable_sourcemap", "The `enableSourcemap` option has been removed. Source maps are always generated now, and tooling can choose to ignore them");
 }
-function render_tag_invalid_call_expression(node) {
-  e3(node, "render_tag_invalid_call_expression", "Calling a snippet function using apply, bind or call is not allowed");
+function options_removed_hydratable(node) {
+  w(node, "options_removed_hydratable", "The `hydratable` option has been removed. Svelte components are always hydratable now");
 }
-function render_tag_invalid_expression(node) {
-  e3(node, "render_tag_invalid_expression", "`{@render ...}` tags can only contain call expressions");
+function options_removed_loop_guard_timeout(node) {
+  w(node, "options_removed_loop_guard_timeout", "The `loopGuardTimeout` option has been removed");
 }
-function render_tag_invalid_spread_argument(node) {
-  e3(node, "render_tag_invalid_spread_argument", "cannot use spread arguments in `{@render ...}` tags");
+function options_renamed_ssr_dom(node) {
+  w(node, "options_renamed_ssr_dom", '`generate: "dom"` and `generate: "ssr"` options have been renamed to "client" and "server" respectively');
 }
-function script_duplicate(node) {
-  e3(node, "script_duplicate", 'A component can have a single top-level `<script>` element and/or a single top-level `<script context="module">` element');
+function derived_iife(node) {
+  w(node, "derived_iife", "Use `$derived.by(() => {...})` instead of `$derived((() => {...})())`");
 }
-function script_invalid_context(node) {
-  e3(node, "script_invalid_context", 'If the context attribute is supplied, its value must be "module"');
+function perf_avoid_inline_class(node) {
+  w(node, "perf_avoid_inline_class", "Avoid 'new class' \u2014 instead, declare the class at the top level scope");
 }
-function slot_attribute_duplicate(node, name, component) {
-  e3(node, "slot_attribute_duplicate", `Duplicate slot name '${name}' in <${component}>`);
+function perf_avoid_nested_class(node) {
+  w(node, "perf_avoid_nested_class", "Avoid declaring classes below the top level scope");
 }
-function slot_attribute_invalid(node) {
-  e3(node, "slot_attribute_invalid", "slot attribute must be a static value");
+function reactive_declaration_invalid_placement(node) {
+  w(node, "reactive_declaration_invalid_placement", "Reactive declarations only exist at the top level of the instance script");
 }
-function slot_attribute_invalid_placement(node) {
-  e3(node, "slot_attribute_invalid_placement", "Element with a slot='...' attribute must be a child of a component or a descendant of a custom element");
+function attribute_avoid_is(node) {
+  w(node, "attribute_avoid_is", 'The "is" attribute is not supported cross-browser and should be avoided');
 }
-function slot_default_duplicate(node) {
-  e3(node, "slot_default_duplicate", 'Found default slot content alongside an explicit slot="default"');
+function attribute_global_event_reference(node, name) {
+  w(node, "attribute_global_event_reference", `You are referencing \`globalThis.${name}\`. Did you forget to declare a variable with that name?`);
 }
-function slot_element_invalid_attribute(node) {
-  e3(node, "slot_element_invalid_attribute", "`<slot>` can only receive attributes and (optionally) let directives");
+function attribute_illegal_colon(node) {
+  w(node, "attribute_illegal_colon", "Attributes should not contain ':' characters to prevent ambiguity with Svelte directives");
 }
-function slot_element_invalid_name(node) {
-  e3(node, "slot_element_invalid_name", "slot attribute must be a static value");
+function attribute_invalid_property_name(node, wrong, right) {
+  w(node, "attribute_invalid_property_name", `'${wrong}' is not a valid HTML attribute. Did you mean '${right}'?`);
 }
-function slot_element_invalid_name_default(node) {
-  e3(node, "slot_element_invalid_name_default", "`default` is a reserved word \u2014 it cannot be used as a slot name");
+function bind_invalid_each_rest(node, name) {
+  w(node, "bind_invalid_each_rest", `The rest operator (...) will create a new object and binding '${name}' with the original object will not work`);
 }
-function snippet_conflict(node) {
-  e3(node, "snippet_conflict", "Cannot use explicit children snippet at the same time as implicit children content. Remove either the non-whitespace content or the children snippet block");
+function block_empty(node) {
+  w(node, "block_empty", "Empty block");
 }
-function style_directive_invalid_modifier(node) {
-  e3(node, "style_directive_invalid_modifier", "`style:` directive can only use the `important` modifier");
+function component_name_lowercase(node, name) {
+  w(node, "component_name_lowercase", `\`<${name}>\` will be treated as an HTML element unless it begins with a capital letter`);
 }
-function style_duplicate(node) {
-  e3(node, "style_duplicate", "A component can have a single top-level `<style>` element");
+function element_invalid_self_closing_tag(node, name) {
+  w(node, "element_invalid_self_closing_tag", `Self-closing HTML tags for non-void elements are ambiguous \u2014 use \`<${name} ...></${name}>\` rather than \`<${name} ... />\``);
 }
-function svelte_component_invalid_this(node) {
-  e3(node, "svelte_component_invalid_this", "Invalid component definition \u2014 must be an `{expression}`");
+function event_directive_deprecated(node, name) {
+  w(node, "event_directive_deprecated", `Using \`on:${name}\` to listen to the ${name} event is deprecated. Use the event attribute \`on${name}\` instead`);
 }
-function svelte_component_missing_this(node) {
-  e3(node, "svelte_component_missing_this", "`<svelte:component>` must have a 'this' attribute");
+function slot_element_deprecated(node) {
+  w(node, "slot_element_deprecated", "Using `<slot>` to render parent content is deprecated. Use `{@render ...}` tags instead");
 }
 function svelte_element_invalid_this(node) {
-  e3(node, "svelte_element_invalid_this", "Invalid element definition \u2014 must be an `{expression}`");
-}
-function svelte_element_missing_this(node) {
-  e3(node, "svelte_element_missing_this", "`<svelte:element>` must have a 'this' attribute");
-}
-function svelte_fragment_invalid_attribute(node) {
-  e3(node, "svelte_fragment_invalid_attribute", "`<svelte:fragment>` can only have a slot attribute and (optionally) a let: directive");
-}
-function svelte_fragment_invalid_placement(node) {
-  e3(node, "svelte_fragment_invalid_placement", "`<svelte:fragment>` must be the direct child of a component");
-}
-function svelte_head_illegal_attribute(node) {
-  e3(node, "svelte_head_illegal_attribute", "`<svelte:head>` cannot have attributes nor directives");
-}
-function svelte_meta_duplicate(node, name) {
-  e3(node, "svelte_meta_duplicate", `A component can only have one \`<${name}>\` element`);
-}
-function svelte_meta_invalid_content(node, name) {
-  e3(node, "svelte_meta_invalid_content", `<${name}> cannot have children`);
+  w(node, "svelte_element_invalid_this", "`this` should be an `{expression}`. Using a string attribute value will cause an error in future versions of Svelte");
 }
-function svelte_meta_invalid_placement(node, name) {
-  e3(node, "svelte_meta_invalid_placement", `\`<${name}>\` tags cannot be inside elements or blocks`);
-}
-function svelte_meta_invalid_tag(node, list3) {
-  e3(node, "svelte_meta_invalid_tag", `Valid \`<svelte:...>\` tag names are ${list3}`);
+
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/utils/extract_svelte_ignore.js
+var regex_svelte_ignore = /^\s*svelte-ignore\s/;
+var replacements = {
+  "non-top-level-reactive-declaration": "reactive_declaration_invalid_placement",
+  "module-script-reactive-declaration": "reactive_declaration_module_script",
+  "empty-block": "block_empty",
+  "avoid-is": "attribute_avoid_is",
+  "invalid-html-attribute": "attribute_invalid_property_name",
+  "a11y-structure": "a11y_figcaption_parent",
+  "illegal-attribute-character": "attribute_illegal_colon",
+  "invalid-rest-eachblock-binding": "bind_invalid_each_rest"
+};
+function extract_svelte_ignore(offset2, text2, runes) {
+  const match = regex_svelte_ignore.exec(text2);
+  if (!match)
+    return [];
+  let length = match[0].length;
+  offset2 += length;
+  const ignores = [];
+  if (runes) {
+    for (const match2 of text2.slice(length).matchAll(/([\w$-]+)(,)?/gm)) {
+      const code = match2[1];
+      if (codes.includes(code)) {
+        ignores.push(code);
+      } else {
+        const replacement = replacements[code] ?? code.replace(/-/g, "_");
+        const start = offset2 + match2.index;
+        const end = start + code.length;
+        if (codes.includes(replacement)) {
+          legacy_code({ start, end }, code, replacement);
+        } else {
+          const suggestion = fuzzymatch(code, codes);
+          unknown_code({ start, end }, code, suggestion);
+        }
+      }
+      if (!match2[2]) {
+        break;
+      }
+    }
+  } else {
+    for (const match2 of text2.slice(length).matchAll(/[\w$-]+/gm)) {
+      const code = match2[0];
+      ignores.push(code);
+      if (!codes.includes(code)) {
+        const replacement = replacements[code] ?? code.replace(/-/g, "_");
+        if (codes.includes(replacement)) {
+          ignores.push(replacement);
+        }
+      }
+    }
+  }
+  return ignores;
 }
-function svelte_options_deprecated_tag(node) {
-  e3(node, "svelte_options_deprecated_tag", '"tag" option is deprecated \u2014 use "customElement" instead');
+
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/legacy.js
+function remove_surrounding_whitespace_nodes(nodes) {
+  const first = nodes.at(0);
+  const last = nodes.at(-1);
+  if (first?.type === "Text") {
+    if (!regex_not_whitespace.test(first.data)) {
+      nodes.shift();
+    } else {
+      first.data = first.data.replace(regex_starts_with_whitespaces, "");
+    }
+  }
+  if (last?.type === "Text") {
+    if (!regex_not_whitespace.test(last.data)) {
+      nodes.pop();
+    } else {
+      last.data = last.data.replace(regex_ends_with_whitespaces, "");
+    }
+  }
 }
-function svelte_options_invalid_attribute(node) {
-  e3(node, "svelte_options_invalid_attribute", "`<svelte:options>` can only receive static attributes");
-}
-function svelte_options_invalid_attribute_value(node, list3) {
-  e3(node, "svelte_options_invalid_attribute_value", `Valid values are ${list3}`);
-}
-function svelte_options_invalid_customelement(node) {
-  e3(node, "svelte_options_invalid_customelement", '"customElement" must be a string literal defining a valid custom element name or an object of the form { tag: string; shadow?: "open" | "none"; props?: { [key: string]: { attribute?: string; reflect?: boolean; type: .. } } }');
-}
-function svelte_options_invalid_customelement_props(node) {
-  e3(node, "svelte_options_invalid_customelement_props", '"props" must be a statically analyzable object literal of the form "{ [key: string]: { attribute?: string; reflect?: boolean; type?: "String" | "Boolean" | "Number" | "Array" | "Object" }"');
-}
-function svelte_options_invalid_customelement_shadow(node) {
-  e3(node, "svelte_options_invalid_customelement_shadow", '"shadow" must be either "open" or "none"');
-}
-function svelte_options_invalid_tagname(node) {
-  e3(node, "svelte_options_invalid_tagname", 'Tag name must be two or more words joined by the "-" character');
-}
-function svelte_options_unknown_attribute(node, name) {
-  e3(node, "svelte_options_unknown_attribute", `\`<svelte:options>\` unknown attribute '${name}'`);
-}
-function svelte_self_invalid_placement(node) {
-  e3(node, "svelte_self_invalid_placement", "`<svelte:self>` components can only exist inside `{#if}` blocks, `{#each}` blocks, `{#snippet}` blocks or slots passed to components");
-}
-function tag_invalid_placement(node, name, location) {
-  e3(node, "tag_invalid_placement", `{@${name} ...} tag cannot be ${location}`);
-}
-function textarea_invalid_content(node) {
-  e3(node, "textarea_invalid_content", "A `<textarea>` can have either a value attribute or (equivalently) child content, but not both");
-}
-function title_illegal_attribute(node) {
-  e3(node, "title_illegal_attribute", "`<title>` cannot have attributes nor directives");
-}
-function title_invalid_content(node) {
-  e3(node, "title_invalid_content", "`<title>` can only contain text and {tags}");
-}
-function transition_conflict(node, type, existing) {
-  e3(node, "transition_conflict", `Cannot use \`${type}:\` alongside existing \`${existing}:\` directive`);
-}
-function transition_duplicate(node, type) {
-  e3(node, "transition_duplicate", `Cannot use multiple \`${type}:\` directives on a single element`);
-}
-function unexpected_eof(node) {
-  e3(node, "unexpected_eof", "Unexpected end of input");
-}
-function unexpected_reserved_word(node, word) {
-  e3(node, "unexpected_reserved_word", `'${word}' is a reserved word in JavaScript and cannot be used here`);
-}
-function void_element_invalid_content(node) {
-  e3(node, "void_element_invalid_content", "Void elements cannot have children or closing tags");
-}
-
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/patterns.js
-var regex_whitespace = /\s/;
-var regex_whitespaces = /\s+/;
-var regex_starts_with_newline = /^\r?\n/;
-var regex_starts_with_whitespaces = /^[ \t\r\n]+/;
-var regex_ends_with_whitespaces = /[ \t\r\n]+$/;
-var regex_not_whitespace = /[^ \t\r\n]/;
-var regex_whitespaces_strict = /[ \t\n\r\f]+/g;
-var regex_only_whitespaces = /^[ \t\n\r\f]+$/;
-var regex_not_newline_characters = /[^\n]/g;
-var regex_is_valid_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
-var regex_invalid_identifier_chars = /(^[^a-zA-Z_$]|[^a-zA-Z0-9_$])/g;
-var regex_starts_with_vowel = /^[aeiou]/;
-var regex_heading_tags = /^h[1-6]$/;
-var regex_illegal_attribute_character = /(^[0-9-.])|[\^$@%&#?!|()[\]{}^*+~;]/;
-
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/utils/fuzzymatch.js
-function fuzzymatch(name, names) {
-  if (names.length === 0)
-    return null;
-  const set2 = new FuzzySet(names);
-  const matches = set2.get(name);
-  return matches && matches[0][0] > 0.7 ? matches[0][1] : null;
-}
-var GRAM_SIZE_LOWER = 2;
-var GRAM_SIZE_UPPER = 3;
-function _distance(str1, str2) {
-  if (str1 === null && str2 === null) {
-    throw "Trying to compare two null values";
-  }
-  if (str1 === null || str2 === null)
-    return 0;
-  str1 = String(str1);
-  str2 = String(str2);
-  const distance = levenshtein(str1, str2);
-  return 1 - distance / Math.max(str1.length, str2.length);
-}
-function levenshtein(str1, str2) {
-  const current2 = [];
-  let prev = 0;
-  let value = 0;
-  for (let i3 = 0; i3 <= str2.length; i3++) {
-    for (let j = 0; j <= str1.length; j++) {
-      if (i3 && j) {
-        if (str1.charAt(j - 1) === str2.charAt(i3 - 1)) {
-          value = prev;
-        } else {
-          value = Math.min(current2[j], current2[j - 1], prev) + 1;
+function convert(source, ast) {
+  const root = ast;
+  return walk2(root, null, {
+    _(node, { next: next2 }) {
+      delete node.parent;
+      delete node.metadata;
+      next2();
+    },
+    Root(node, { visit: visit24 }) {
+      const { instance, module: module2, options } = node;
+      if (options?.__raw__) {
+        let idx = node.fragment.nodes.findIndex((node2) => options.end <= node2.start);
+        if (idx === -1) {
+          idx = node.fragment.nodes.length;
         }
-      } else {
-        value = i3 + j;
+        delete options.__raw__.parent;
+        node.fragment.nodes.splice(idx, 0, options.__raw__);
       }
-      prev = current2[j];
-      current2[j] = value;
-    }
-  }
-  return current2.pop();
-}
-var non_word_regex = /[^\w, ]+/;
-function iterate_grams(value, gram_size = 2) {
-  const simplified = "-" + value.toLowerCase().replace(non_word_regex, "") + "-";
-  const len_diff = gram_size - simplified.length;
-  const results = [];
-  if (len_diff > 0) {
-    for (let i3 = 0; i3 < len_diff; ++i3) {
-      value += "-";
-    }
-  }
-  for (let i3 = 0; i3 < simplified.length - gram_size + 1; ++i3) {
-    results.push(simplified.slice(i3, i3 + gram_size));
-  }
-  return results;
-}
-function gram_counter(value, gram_size = 2) {
-  const result = {};
-  const grams = iterate_grams(value, gram_size);
-  let i3 = 0;
-  for (i3; i3 < grams.length; ++i3) {
-    if (grams[i3] in result) {
-      result[grams[i3]] += 1;
-    } else {
-      result[grams[i3]] = 1;
-    }
-  }
-  return result;
-}
-function sort_descending(a2, b2) {
-  return b2[0] - a2[0];
-}
-var FuzzySet = class {
-  exact_set = {};
-  match_dict = {};
-  items = {};
-  constructor(arr) {
-    for (let i3 = GRAM_SIZE_LOWER; i3 < GRAM_SIZE_UPPER + 1; ++i3) {
-      this.items[i3] = [];
-    }
-    for (let i3 = 0; i3 < arr.length; ++i3) {
-      this.add(arr[i3]);
-    }
-  }
-  add(value) {
-    const normalized_value = value.toLowerCase();
-    if (normalized_value in this.exact_set) {
-      return false;
-    }
-    let i3 = GRAM_SIZE_LOWER;
-    for (i3; i3 < GRAM_SIZE_UPPER + 1; ++i3) {
-      this._add(value, i3);
-    }
-  }
-  _add(value, gram_size) {
-    const normalized_value = value.toLowerCase();
-    const items = this.items[gram_size] || [];
-    const index = items.length;
-    items.push(0);
-    const gram_counts = gram_counter(normalized_value, gram_size);
-    let sum_of_square_gram_counts = 0;
-    let gram;
-    let gram_count;
-    for (gram in gram_counts) {
-      gram_count = gram_counts[gram];
-      sum_of_square_gram_counts += Math.pow(gram_count, 2);
-      if (gram in this.match_dict) {
-        this.match_dict[gram].push([index, gram_count]);
-      } else {
-        this.match_dict[gram] = [[index, gram_count]];
+      let start = null;
+      let end = null;
+      if (node.fragment.nodes.length > 0) {
+        const first = node.fragment.nodes.at(0);
+        const last = node.fragment.nodes.at(-1);
+        start = first.start;
+        end = last.end;
+        while (/\s/.test(source[start]))
+          start += 1;
+        while (/\s/.test(source[end - 1]))
+          end -= 1;
       }
-    }
-    const vector_normal = Math.sqrt(sum_of_square_gram_counts);
-    items[index] = [vector_normal, normalized_value];
-    this.items[gram_size] = items;
-    this.exact_set[normalized_value] = value;
-  }
-  get(value) {
-    const normalized_value = value.toLowerCase();
-    const result = this.exact_set[normalized_value];
-    if (result) {
-      return [[1, result]];
-    }
-    for (let gram_size = GRAM_SIZE_UPPER; gram_size >= GRAM_SIZE_LOWER; --gram_size) {
-      const results = this.__get(value, gram_size);
-      if (results.length > 0)
-        return results;
-    }
-    return null;
-  }
-  __get(value, gram_size) {
-    const normalized_value = value.toLowerCase();
-    const matches = {};
-    const gram_counts = gram_counter(normalized_value, gram_size);
-    const items = this.items[gram_size];
-    let sum_of_square_gram_counts = 0;
-    let gram;
-    let gram_count;
-    let i3;
-    let index;
-    let other_gram_count;
-    for (gram in gram_counts) {
-      gram_count = gram_counts[gram];
-      sum_of_square_gram_counts += Math.pow(gram_count, 2);
-      if (gram in this.match_dict) {
-        for (i3 = 0; i3 < this.match_dict[gram].length; ++i3) {
-          index = this.match_dict[gram][i3][0];
-          other_gram_count = this.match_dict[gram][i3][1];
-          if (index in matches) {
-            matches[index] += gram_count * other_gram_count;
-          } else {
-            matches[index] = gram_count * other_gram_count;
-          }
-        }
+      if (instance) {
+        delete instance.parent;
+        delete instance.attributes;
       }
-    }
-    const vector_normal = Math.sqrt(sum_of_square_gram_counts);
-    let results = [];
-    let match_score;
-    for (const match_index in matches) {
-      match_score = matches[match_index];
-      results.push([match_score / (vector_normal * items[match_index][0]), items[match_index][1]]);
-    }
-    results.sort(sort_descending);
-    let new_results = [];
-    const end_index = Math.min(50, results.length);
-    for (let i4 = 0; i4 < end_index; ++i4) {
-      new_results.push([_distance(results[i4][1], normalized_value), results[i4][1]]);
-    }
-    results = new_results;
-    results.sort(sort_descending);
-    new_results = [];
-    for (let i4 = 0; i4 < results.length; ++i4) {
-      if (results[i4][0] === results[0][0]) {
-        new_results.push([results[i4][0], this.exact_set[results[i4][1]]]);
+      if (module2) {
+        delete module2.parent;
+        delete module2.attributes;
       }
-    }
-    return new_results;
-  }
-};
-
-// ../../node_modules/.pnpm/locate-character@3.0.0/node_modules/locate-character/src/index.js
-function rangeContains(range, index) {
-  return range.start <= index && index < range.end;
-}
-function getLocator(source, options = {}) {
-  const { offsetLine = 0, offsetColumn = 0 } = options;
-  let start = 0;
-  const ranges = source.split("\n").map((line, i4) => {
-    const end = start + line.length + 1;
-    const range = { start, end, line: i4 };
-    start = end;
-    return range;
-  });
-  let i3 = 0;
-  function locator2(search, index) {
-    if (typeof search === "string") {
-      search = source.indexOf(search, index ?? 0);
-    }
-    if (search === -1)
-      return void 0;
-    let range = ranges[i3];
-    const d2 = search >= range.end ? 1 : -1;
-    while (range) {
-      if (rangeContains(range, search)) {
-        return {
-          line: offsetLine + range.line,
-          column: offsetColumn + search - range.start,
-          character: search
-        };
-      }
-      i3 += d2;
-      range = ranges[i3];
-    }
-  }
-  return locator2;
-}
-
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/state.js
-var warnings = [];
-var filename;
-var locator = getLocator("", { offsetLine: 1 });
-var ignore_stack = [];
-function reset3(options) {
-  filename = options.filename;
-  locator = getLocator(options.source, { offsetLine: 1 });
-  warnings = [];
-  ignore_stack = [];
-}
-
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/warnings.js
-function w(node, code, message) {
-  if (ignore_stack.at(-1)?.has(code))
-    return;
-  warnings.push({
-    code,
-    message,
-    filename,
-    start: node?.start !== void 0 ? locator(node.start) : void 0,
-    end: node?.end !== void 0 ? locator(node.end) : void 0
-  });
-}
-var codes = [
-  "a11y_accesskey",
-  "a11y_aria_activedescendant_has_tabindex",
-  "a11y_aria_attributes",
-  "a11y_autocomplete_valid",
-  "a11y_autofocus",
-  "a11y_click_events_have_key_events",
-  "a11y_distracting_elements",
-  "a11y_figcaption_index",
-  "a11y_figcaption_parent",
-  "a11y_hidden",
-  "a11y_img_redundant_alt",
-  "a11y_incorrect_aria_attribute_type",
-  "a11y_incorrect_aria_attribute_type_boolean",
-  "a11y_incorrect_aria_attribute_type_id",
-  "a11y_incorrect_aria_attribute_type_idlist",
-  "a11y_incorrect_aria_attribute_type_integer",
-  "a11y_incorrect_aria_attribute_type_token",
-  "a11y_incorrect_aria_attribute_type_tokenlist",
-  "a11y_incorrect_aria_attribute_type_tristate",
-  "a11y_interactive_supports_focus",
-  "a11y_invalid_attribute",
-  "a11y_label_has_associated_control",
-  "a11y_media_has_caption",
-  "a11y_misplaced_role",
-  "a11y_misplaced_scope",
-  "a11y_missing_attribute",
-  "a11y_missing_content",
-  "a11y_mouse_events_have_key_events",
-  "a11y_no_abstract_role",
-  "a11y_no_interactive_element_to_noninteractive_role",
-  "a11y_no_noninteractive_element_interactions",
-  "a11y_no_noninteractive_element_to_interactive_role",
-  "a11y_no_noninteractive_tabindex",
-  "a11y_no_redundant_roles",
-  "a11y_no_static_element_interactions",
-  "a11y_positive_tabindex",
-  "a11y_role_has_required_aria_props",
-  "a11y_role_supports_aria_props",
-  "a11y_role_supports_aria_props_implicit",
-  "a11y_unknown_aria_attribute",
-  "a11y_unknown_role",
-  "legacy_code",
-  "unknown_code",
-  "options_deprecated_accessors",
-  "options_deprecated_immutable",
-  "options_missing_custom_element",
-  "options_removed_enable_sourcemap",
-  "options_removed_hydratable",
-  "options_removed_loop_guard_timeout",
-  "options_renamed_ssr_dom",
-  "derived_iife",
-  "export_let_unused",
-  "non_reactive_update",
-  "perf_avoid_inline_class",
-  "perf_avoid_nested_class",
-  "reactive_declaration_invalid_placement",
-  "reactive_declaration_module_script",
-  "state_referenced_locally",
-  "store_rune_conflict",
-  "css_unused_selector",
-  "attribute_avoid_is",
-  "attribute_global_event_reference",
-  "attribute_illegal_colon",
-  "attribute_invalid_property_name",
-  "bind_invalid_each_rest",
-  "block_empty",
-  "component_name_lowercase",
-  "element_invalid_self_closing_tag",
-  "event_directive_deprecated",
-  "slot_element_deprecated"
-];
-function a11y_accesskey(node) {
-  w(node, "a11y_accesskey", "Avoid using accesskey");
-}
-function a11y_aria_activedescendant_has_tabindex(node) {
-  w(node, "a11y_aria_activedescendant_has_tabindex", "An element with an aria-activedescendant attribute should have a tabindex value");
-}
-function a11y_aria_attributes(node, name) {
-  w(node, "a11y_aria_attributes", `\`<${name}>\` should not have aria-* attributes`);
-}
-function a11y_autocomplete_valid(node, value, type) {
-  w(node, "a11y_autocomplete_valid", `'${value}' is an invalid value for 'autocomplete' on \`<input type="${type}">\``);
-}
-function a11y_autofocus(node) {
-  w(node, "a11y_autofocus", "Avoid using autofocus");
-}
-function a11y_click_events_have_key_events(node) {
-  w(node, "a11y_click_events_have_key_events", 'Visible, non-interactive elements with a click event must be accompanied by a keyboard event handler. Consider whether an interactive element such as `<button type="button">` or `<a>` might be more appropriate. See https://svelte.dev/docs/accessibility-warnings#a11y-click-events-have-key-events for more details.');
-}
-function a11y_distracting_elements(node, name) {
-  w(node, "a11y_distracting_elements", `Avoid \`<${name}>\` elements`);
-}
-function a11y_figcaption_index(node) {
-  w(node, "a11y_figcaption_index", "`<figcaption>` must be first or last child of `<figure>`");
-}
-function a11y_figcaption_parent(node) {
-  w(node, "a11y_figcaption_parent", "`<figcaption>` must be an immediate child of `<figure>`");
-}
-function a11y_hidden(node, name) {
-  w(node, "a11y_hidden", `\`<${name}>\` element should not be hidden`);
-}
-function a11y_img_redundant_alt(node) {
-  w(node, "a11y_img_redundant_alt", "Screenreaders already announce `<img>` elements as an image.");
-}
-function a11y_incorrect_aria_attribute_type(node, attribute, type) {
-  w(node, "a11y_incorrect_aria_attribute_type", `The value of '${attribute}' must be a ${type}`);
-}
-function a11y_incorrect_aria_attribute_type_boolean(node, attribute) {
-  w(node, "a11y_incorrect_aria_attribute_type_boolean", `The value of '${attribute}' must be either 'true' or 'false'. It cannot be empty`);
-}
-function a11y_incorrect_aria_attribute_type_idlist(node, attribute) {
-  w(node, "a11y_incorrect_aria_attribute_type_idlist", `The value of '${attribute}' must be a space-separated list of strings that represent DOM element IDs`);
-}
-function a11y_incorrect_aria_attribute_type_integer(node, attribute) {
-  w(node, "a11y_incorrect_aria_attribute_type_integer", `The value of '${attribute}' must be an integer`);
-}
-function a11y_incorrect_aria_attribute_type_token(node, attribute, values) {
-  w(node, "a11y_incorrect_aria_attribute_type_token", `The value of '${attribute}' must be exactly one of ${values}`);
-}
-function a11y_incorrect_aria_attribute_type_tokenlist(node, attribute, values) {
-  w(node, "a11y_incorrect_aria_attribute_type_tokenlist", `The value of '${attribute}' must be a space-separated list of one or more of ${values}`);
-}
-function a11y_incorrect_aria_attribute_type_tristate(node, attribute) {
-  w(node, "a11y_incorrect_aria_attribute_type_tristate", `The value of '${attribute}' must be exactly one of true, false, or mixed`);
-}
-function a11y_interactive_supports_focus(node, role) {
-  w(node, "a11y_interactive_supports_focus", `Elements with the '${role}' interactive role must have a tabindex value.`);
-}
-function a11y_invalid_attribute(node, href_value, href_attribute) {
-  w(node, "a11y_invalid_attribute", `'${href_value}' is not a valid ${href_attribute} attribute`);
-}
-function a11y_label_has_associated_control(node) {
-  w(node, "a11y_label_has_associated_control", "A form label must be associated with a control.");
-}
-function a11y_media_has_caption(node) {
-  w(node, "a11y_media_has_caption", '`<video>` elements must have a `<track kind="captions">`');
-}
-function a11y_misplaced_role(node, name) {
-  w(node, "a11y_misplaced_role", `\`<${name}>\` should not have role attribute`);
-}
-function a11y_misplaced_scope(node) {
-  w(node, "a11y_misplaced_scope", "The scope attribute should only be used with `<th>` elements");
-}
-function a11y_missing_attribute(node, name, article, sequence3) {
-  w(node, "a11y_missing_attribute", `\`<${name}>\` element should have ${article} ${sequence3} attribute`);
-}
-function a11y_missing_content(node, name) {
-  w(node, "a11y_missing_content", `\`<${name}>\` element should have child content`);
-}
-function a11y_mouse_events_have_key_events(node, event, accompanied_by) {
-  w(node, "a11y_mouse_events_have_key_events", `'${event}' event must be accompanied by '${accompanied_by}' event`);
-}
-function a11y_no_abstract_role(node, role) {
-  w(node, "a11y_no_abstract_role", `Abstract role '${role}' is forbidden`);
-}
-function a11y_no_interactive_element_to_noninteractive_role(node, element, role) {
-  w(node, "a11y_no_interactive_element_to_noninteractive_role", `\`<${element}>\` cannot have role '${role}'`);
-}
-function a11y_no_noninteractive_element_interactions(node, element) {
-  w(node, "a11y_no_noninteractive_element_interactions", `Non-interactive element \`<${element}>\` should not be assigned mouse or keyboard event listeners.`);
-}
-function a11y_no_noninteractive_element_to_interactive_role(node, element, role) {
-  w(node, "a11y_no_noninteractive_element_to_interactive_role", `Non-interactive element \`<${element}>\` cannot have interactive role '${role}'`);
-}
-function a11y_no_noninteractive_tabindex(node) {
-  w(node, "a11y_no_noninteractive_tabindex", "noninteractive element cannot have nonnegative tabIndex value");
-}
-function a11y_no_redundant_roles(node, role) {
-  w(node, "a11y_no_redundant_roles", `Redundant role '${role}'`);
-}
-function a11y_no_static_element_interactions(node, element, handler) {
-  w(node, "a11y_no_static_element_interactions", `\`<${element}>\` with a ${handler} handler must have an ARIA role`);
-}
-function a11y_positive_tabindex(node) {
-  w(node, "a11y_positive_tabindex", "Avoid tabindex values above zero");
-}
-function a11y_role_has_required_aria_props(node, role, props) {
-  w(node, "a11y_role_has_required_aria_props", `Elements with the ARIA role "${role}" must have the following attributes defined: ${props}`);
-}
-function a11y_role_supports_aria_props(node, attribute, role) {
-  w(node, "a11y_role_supports_aria_props", `The attribute '${attribute}' is not supported by the role '${role}'`);
-}
-function a11y_role_supports_aria_props_implicit(node, attribute, role, name) {
-  w(node, "a11y_role_supports_aria_props_implicit", `The attribute '${attribute}' is not supported by the role '${role}'. This role is implicit on the element \`<${name}>\``);
-}
-function a11y_unknown_aria_attribute(node, attribute, suggestion) {
-  w(node, "a11y_unknown_aria_attribute", suggestion ? `Unknown aria attribute 'aria-${attribute}'. Did you mean '${suggestion}'?` : `Unknown aria attribute 'aria-${attribute}'`);
-}
-function a11y_unknown_role(node, role, suggestion) {
-  w(node, "a11y_unknown_role", suggestion ? `Unknown role '${role}'. Did you mean '${suggestion}'?` : `Unknown role '${role}'`);
-}
-function legacy_code(node, code, suggestion) {
-  w(node, "legacy_code", `\`${code}\` is no longer valid \u2014 please use \`${suggestion}\` instead`);
-}
-function unknown_code(node, code, suggestion) {
-  w(node, "unknown_code", suggestion ? `\`${code}\` is not a recognised code (did you mean \`${suggestion}\`?)` : `\`${code}\` is not a recognised code`);
-}
-function options_deprecated_accessors(node) {
-  w(node, "options_deprecated_accessors", "The `accessors` option has been deprecated. It will have no effect in runes mode");
-}
-function options_deprecated_immutable(node) {
-  w(node, "options_deprecated_immutable", "The `immutable` option has been deprecated. It will have no effect in runes mode");
-}
-function options_removed_enable_sourcemap(node) {
-  w(node, "options_removed_enable_sourcemap", "The `enableSourcemap` option has been removed. Source maps are always generated now, and tooling can choose to ignore them");
-}
-function options_removed_hydratable(node) {
-  w(node, "options_removed_hydratable", "The `hydratable` option has been removed. Svelte components are always hydratable now");
-}
-function options_removed_loop_guard_timeout(node) {
-  w(node, "options_removed_loop_guard_timeout", "The `loopGuardTimeout` option has been removed");
-}
-function options_renamed_ssr_dom(node) {
-  w(node, "options_renamed_ssr_dom", '`generate: "dom"` and `generate: "ssr"` options have been renamed to "client" and "server" respectively');
-}
-function derived_iife(node) {
-  w(node, "derived_iife", "Use `$derived.by(() => {...})` instead of `$derived((() => {...})())`");
-}
-function perf_avoid_inline_class(node) {
-  w(node, "perf_avoid_inline_class", "Avoid 'new class' \u2014 instead, declare the class at the top level scope");
-}
-function perf_avoid_nested_class(node) {
-  w(node, "perf_avoid_nested_class", "Avoid declaring classes below the top level scope");
-}
-function reactive_declaration_invalid_placement(node) {
-  w(node, "reactive_declaration_invalid_placement", "Reactive declarations only exist at the top level of the instance script");
-}
-function attribute_avoid_is(node) {
-  w(node, "attribute_avoid_is", 'The "is" attribute is not supported cross-browser and should be avoided');
-}
-function attribute_global_event_reference(node, name) {
-  w(node, "attribute_global_event_reference", `You are referencing \`globalThis.${name}\`. Did you forget to declare a variable with that name?`);
-}
-function attribute_illegal_colon(node) {
-  w(node, "attribute_illegal_colon", "Attributes should not contain ':' characters to prevent ambiguity with Svelte directives");
-}
-function attribute_invalid_property_name(node, wrong, right) {
-  w(node, "attribute_invalid_property_name", `'${wrong}' is not a valid HTML attribute. Did you mean '${right}'?`);
-}
-function bind_invalid_each_rest(node, name) {
-  w(node, "bind_invalid_each_rest", `The rest operator (...) will create a new object and binding '${name}' with the original object will not work`);
-}
-function block_empty(node) {
-  w(node, "block_empty", "Empty block");
-}
-function component_name_lowercase(node, name) {
-  w(node, "component_name_lowercase", `\`<${name}>\` will be treated as an HTML element unless it begins with a capital letter`);
-}
-function element_invalid_self_closing_tag(node, name) {
-  w(node, "element_invalid_self_closing_tag", `Self-closing HTML tags for non-void elements are ambiguous \u2014 use \`<${name} ...></${name}>\` rather than \`<${name} ... />\``);
-}
-function event_directive_deprecated(node, name) {
-  w(node, "event_directive_deprecated", `Using \`on:${name}\` to listen to the ${name} event is deprecated. Use the event attribute \`on${name}\` instead.`);
-}
-function slot_element_deprecated(node) {
-  w(node, "slot_element_deprecated", "Using `<slot>` to render parent content is deprecated. Use `{@render ...}` tags instead.");
-}
-
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/utils/extract_svelte_ignore.js
-var regex_svelte_ignore = /^\s*svelte-ignore\s/;
-var replacements = {
-  "non-top-level-reactive-declaration": "reactive_declaration_invalid_placement",
-  "module-script-reactive-declaration": "reactive_declaration_module_script",
-  "empty-block": "block_empty",
-  "avoid-is": "attribute_avoid_is",
-  "invalid-html-attribute": "attribute_invalid_property_name",
-  "a11y-structure": "a11y_figcaption_parent",
-  "illegal-attribute-character": "attribute_illegal_colon",
-  "invalid-rest-eachblock-binding": "bind_invalid_each_rest"
-};
-function extract_svelte_ignore(offset2, text2, runes) {
-  const match = regex_svelte_ignore.exec(text2);
-  if (!match)
-    return [];
-  let length = match[0].length;
-  offset2 += length;
-  const ignores = [];
-  for (const match2 of text2.slice(length).matchAll(/([\w$-]+)(,)?/gm)) {
-    const code = match2[1];
-    ignores.push(code);
-    if (!codes.includes(code)) {
-      const replacement = replacements[code] ?? code.replace(/-/g, "_");
-      if (runes) {
-        const start = offset2 + match2.index;
-        const end = start + code.length;
-        if (codes.includes(replacement)) {
-          legacy_code({ start, end }, code, replacement);
-        } else {
-          const suggestion = fuzzymatch(code, codes);
-          unknown_code({ start, end }, code, suggestion);
-        }
-      } else if (codes.includes(replacement)) {
-        ignores.push(replacement);
-      }
-    }
-    if (!match2[2]) {
-      break;
-    }
-  }
-  return ignores;
-}
-
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/legacy.js
-function remove_surrounding_whitespace_nodes(nodes) {
-  const first = nodes.at(0);
-  const last = nodes.at(-1);
-  if (first?.type === "Text") {
-    if (!regex_not_whitespace.test(first.data)) {
-      nodes.shift();
-    } else {
-      first.data = first.data.replace(regex_starts_with_whitespaces, "");
-    }
-  }
-  if (last?.type === "Text") {
-    if (!regex_not_whitespace.test(last.data)) {
-      nodes.pop();
-    } else {
-      last.data = last.data.replace(regex_ends_with_whitespaces, "");
-    }
-  }
-}
-function convert(source, ast) {
-  const root = ast;
-  return walk2(root, null, {
-    _(node, { next: next2 }) {
-      delete node.parent;
-      delete node.metadata;
-      next2();
-    },
-    Root(node, { visit: visit24 }) {
-      const { instance, module: module2, options } = node;
-      if (options?.__raw__) {
-        let idx = node.fragment.nodes.findIndex((node2) => options.end <= node2.start);
-        if (idx === -1) {
-          idx = node.fragment.nodes.length;
-        }
-        delete options.__raw__.parent;
-        node.fragment.nodes.splice(idx, 0, options.__raw__);
-      }
-      let start = null;
-      let end = null;
-      if (node.fragment.nodes.length > 0) {
-        const first = node.fragment.nodes.at(0);
-        const last = node.fragment.nodes.at(-1);
-        start = first.start;
-        end = last.end;
-        while (/\s/.test(source[start]))
-          start += 1;
-        while (/\s/.test(source[end - 1]))
-          end -= 1;
-      }
-      if (instance) {
-        delete instance.parent;
-        delete instance.attributes;
-      }
-      if (module2) {
-        delete module2.parent;
-        delete module2.attributes;
-      }
-      return {
-        html: {
-          type: "Fragment",
-          start,
-          end,
-          children: node.fragment.nodes.map((child) => visit24(child))
-        },
-        instance,
-        module: module2,
-        css: ast.css ? visit24(ast.css) : void 0
-      };
-    },
-    AnimateDirective(node) {
-      return { ...node, type: "Animation" };
-    },
-    AwaitBlock(node, { visit: visit24 }) {
-      let pendingblock = {
-        type: "PendingBlock",
-        start: null,
-        end: null,
-        children: node.pending?.nodes.map((child) => visit24(child)) ?? [],
-        skip: true
-      };
-      let thenblock = {
-        type: "ThenBlock",
-        start: null,
-        end: null,
-        children: node.then?.nodes.map((child) => visit24(child)) ?? [],
-        skip: true
-      };
-      let catchblock = {
-        type: "CatchBlock",
-        start: null,
-        end: null,
-        children: node.catch?.nodes.map((child) => visit24(child)) ?? [],
-        skip: true
-      };
-      if (node.pending) {
-        const first = node.pending.nodes.at(0);
-        const last = node.pending.nodes.at(-1);
-        pendingblock.start = first?.start ?? source.indexOf("}", node.expression.end) + 1;
-        pendingblock.end = last?.end ?? pendingblock.start;
-        pendingblock.skip = false;
-      }
-      if (node.then) {
-        const first = node.then.nodes.at(0);
-        const last = node.then.nodes.at(-1);
-        thenblock.start = pendingblock.end ?? first?.start ?? source.indexOf("}", node.expression.end) + 1;
-        thenblock.end = last?.end ?? source.lastIndexOf("}", pendingblock.end ?? node.expression.end) + 1;
-        thenblock.skip = false;
-      }
-      if (node.catch) {
-        const first = node.catch.nodes.at(0);
-        const last = node.catch.nodes.at(-1);
-        catchblock.start = thenblock.end ?? pendingblock.end ?? first?.start ?? source.indexOf("}", node.expression.end) + 1;
-        catchblock.end = last?.end ?? source.lastIndexOf("}", thenblock.end ?? pendingblock.end ?? node.expression.end) + 1;
-        catchblock.skip = false;
-      }
-      return {
-        type: "AwaitBlock",
-        start: node.start,
-        end: node.end,
-        expression: node.expression,
-        value: node.value,
-        error: node.error,
-        pending: pendingblock,
-        then: thenblock,
-        catch: catchblock
-      };
-    },
-    BindDirective(node) {
-      return { ...node, type: "Binding" };
-    },
-    ClassDirective(node) {
-      return { ...node, type: "Class" };
-    },
-    Comment(node) {
-      return {
-        ...node,
-        ignores: extract_svelte_ignore(node.start, node.data, false)
-      };
-    },
-    ComplexSelector(node) {
-      const children = [];
-      for (const child of node.children) {
-        if (child.combinator) {
-          children.push(child.combinator);
-        }
-        children.push(...child.selectors);
-      }
-      return {
-        type: "Selector",
-        start: node.start,
-        end: node.end,
-        children
-      };
-    },
-    Component(node, { visit: visit24 }) {
-      return {
-        type: "InlineComponent",
-        start: node.start,
-        end: node.end,
-        name: node.name,
-        attributes: node.attributes.map(
-          (child) => visit24(child)
-        ),
-        children: node.fragment.nodes.map(
-          (child) => visit24(child)
-        )
-      };
-    },
-    ConstTag(node) {
-      if (node.expression !== void 0) {
-        return node;
-      }
-      const modern_node = node;
-      const { id: left } = { ...modern_node.declaration.declarations[0] };
-      delete left.typeAnnotation;
-      return {
-        type: "ConstTag",
-        start: modern_node.start,
-        end: node.end,
-        expression: {
-          type: "AssignmentExpression",
-          start: (modern_node.declaration.start ?? 0) + "const ".length,
-          end: modern_node.declaration.end ?? 0,
-          operator: "=",
-          left,
-          right: modern_node.declaration.declarations[0].init
-        }
-      };
-    },
-    KeyBlock(node, { visit: visit24 }) {
-      remove_surrounding_whitespace_nodes(node.fragment.nodes);
-      return {
-        type: "KeyBlock",
-        start: node.start,
-        end: node.end,
-        expression: node.expression,
-        children: node.fragment.nodes.map(
-          (child) => visit24(child)
-        )
-      };
-    },
-    EachBlock(node, { visit: visit24 }) {
-      let elseblock = void 0;
-      if (node.fallback) {
-        const first = node.fallback.nodes.at(0);
-        const end = source.lastIndexOf("{", node.end - 1);
-        const start = first?.start ?? end;
-        remove_surrounding_whitespace_nodes(node.fallback.nodes);
-        elseblock = {
-          type: "ElseBlock",
-          start,
-          end,
-          children: node.fallback.nodes.map((child) => visit24(child))
+      return {
+        html: {
+          type: "Fragment",
+          start,
+          end,
+          children: node.fragment.nodes.map((child) => visit24(child))
+        },
+        instance,
+        module: module2,
+        css: ast.css ? visit24(ast.css) : void 0
+      };
+    },
+    AnimateDirective(node) {
+      return { ...node, type: "Animation" };
+    },
+    AwaitBlock(node, { visit: visit24 }) {
+      let pendingblock = {
+        type: "PendingBlock",
+        start: null,
+        end: null,
+        children: node.pending?.nodes.map((child) => visit24(child)) ?? [],
+        skip: true
+      };
+      let thenblock = {
+        type: "ThenBlock",
+        start: null,
+        end: null,
+        children: node.then?.nodes.map((child) => visit24(child)) ?? [],
+        skip: true
+      };
+      let catchblock = {
+        type: "CatchBlock",
+        start: null,
+        end: null,
+        children: node.catch?.nodes.map((child) => visit24(child)) ?? [],
+        skip: true
+      };
+      if (node.pending) {
+        const first = node.pending.nodes.at(0);
+        const last = node.pending.nodes.at(-1);
+        pendingblock.start = first?.start ?? source.indexOf("}", node.expression.end) + 1;
+        pendingblock.end = last?.end ?? pendingblock.start;
+        pendingblock.skip = false;
+      }
+      if (node.then) {
+        const first = node.then.nodes.at(0);
+        const last = node.then.nodes.at(-1);
+        thenblock.start = pendingblock.end ?? first?.start ?? source.indexOf("}", node.expression.end) + 1;
+        thenblock.end = last?.end ?? source.lastIndexOf("}", pendingblock.end ?? node.expression.end) + 1;
+        thenblock.skip = false;
+      }
+      if (node.catch) {
+        const first = node.catch.nodes.at(0);
+        const last = node.catch.nodes.at(-1);
+        catchblock.start = thenblock.end ?? pendingblock.end ?? first?.start ?? source.indexOf("}", node.expression.end) + 1;
+        catchblock.end = last?.end ?? source.lastIndexOf("}", thenblock.end ?? pendingblock.end ?? node.expression.end) + 1;
+        catchblock.skip = false;
+      }
+      return {
+        type: "AwaitBlock",
+        start: node.start,
+        end: node.end,
+        expression: node.expression,
+        value: node.value,
+        error: node.error,
+        pending: pendingblock,
+        then: thenblock,
+        catch: catchblock
+      };
+    },
+    BindDirective(node) {
+      return { ...node, type: "Binding" };
+    },
+    ClassDirective(node) {
+      return { ...node, type: "Class" };
+    },
+    Comment(node) {
+      return {
+        ...node,
+        ignores: extract_svelte_ignore(node.start, node.data, false)
+      };
+    },
+    ComplexSelector(node) {
+      const children = [];
+      for (const child of node.children) {
+        if (child.combinator) {
+          children.push(child.combinator);
+        }
+        children.push(...child.selectors);
+      }
+      return {
+        type: "Selector",
+        start: node.start,
+        end: node.end,
+        children
+      };
+    },
+    Component(node, { visit: visit24 }) {
+      return {
+        type: "InlineComponent",
+        start: node.start,
+        end: node.end,
+        name: node.name,
+        attributes: node.attributes.map(
+          (child) => visit24(child)
+        ),
+        children: node.fragment.nodes.map(
+          (child) => visit24(child)
+        )
+      };
+    },
+    ConstTag(node) {
+      if (node.expression !== void 0) {
+        return node;
+      }
+      const modern_node = node;
+      const { id: left } = { ...modern_node.declaration.declarations[0] };
+      delete left.typeAnnotation;
+      return {
+        type: "ConstTag",
+        start: modern_node.start,
+        end: node.end,
+        expression: {
+          type: "AssignmentExpression",
+          start: (modern_node.declaration.start ?? 0) + "const ".length,
+          end: modern_node.declaration.end ?? 0,
+          operator: "=",
+          left,
+          right: modern_node.declaration.declarations[0].init
+        }
+      };
+    },
+    KeyBlock(node, { visit: visit24 }) {
+      remove_surrounding_whitespace_nodes(node.fragment.nodes);
+      return {
+        type: "KeyBlock",
+        start: node.start,
+        end: node.end,
+        expression: node.expression,
+        children: node.fragment.nodes.map(
+          (child) => visit24(child)
+        )
+      };
+    },
+    EachBlock(node, { visit: visit24 }) {
+      let elseblock = void 0;
+      if (node.fallback) {
+        const first = node.fallback.nodes.at(0);
+        const end = source.lastIndexOf("{", node.end - 1);
+        const start = first?.start ?? end;
+        remove_surrounding_whitespace_nodes(node.fallback.nodes);
+        elseblock = {
+          type: "ElseBlock",
+          start,
+          end,
+          children: node.fallback.nodes.map((child) => visit24(child))
         };
       }
       remove_surrounding_whitespace_nodes(node.body.nodes);
@@ -163288,165 +162890,588 @@ function D(e4) {
     return z;
   };
 }
-
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/acorn.js
-var ParserWithTS = Parser.extend(D({ allowSatisfies: true }));
-function parse14(source, typescript) {
-  const parser = typescript ? ParserWithTS : Parser;
-  const { onComment, add_comments } = get_comment_handlers(source);
-  const ast = parser.parse(source, {
-    onComment,
-    sourceType: "module",
-    ecmaVersion: 13,
-    locations: true
-  });
-  if (typescript)
-    amend(source, ast);
-  add_comments(ast);
-  return ast;
+
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/acorn.js
+var ParserWithTS = Parser.extend(D({ allowSatisfies: true }));
+function parse14(source, typescript) {
+  const parser = typescript ? ParserWithTS : Parser;
+  const { onComment, add_comments } = get_comment_handlers(source);
+  const ast = parser.parse(source, {
+    onComment,
+    sourceType: "module",
+    ecmaVersion: 13,
+    locations: true
+  });
+  if (typescript)
+    amend(source, ast);
+  add_comments(ast);
+  return ast;
+}
+function parse_expression_at(source, typescript, index) {
+  const parser = typescript ? ParserWithTS : Parser;
+  const { onComment, add_comments } = get_comment_handlers(source);
+  const ast = parser.parseExpressionAt(source, index, {
+    onComment,
+    sourceType: "module",
+    ecmaVersion: 13,
+    locations: true
+  });
+  if (typescript)
+    amend(source, ast);
+  add_comments(ast);
+  return ast;
+}
+function get_comment_handlers(source) {
+  const comments = [];
+  return {
+    onComment: (block4, value, start, end) => {
+      if (block4 && /\n/.test(value)) {
+        let a2 = start;
+        while (a2 > 0 && source[a2 - 1] !== "\n")
+          a2 -= 1;
+        let b2 = a2;
+        while (/[ \t]/.test(source[b2]))
+          b2 += 1;
+        const indentation = source.slice(a2, b2);
+        value = value.replace(new RegExp(`^${indentation}`, "gm"), "");
+      }
+      comments.push({ type: block4 ? "Block" : "Line", value, start, end });
+    },
+    add_comments(ast) {
+      if (comments.length === 0)
+        return;
+      walk2(ast, null, {
+        _(node, { next: next2 }) {
+          let comment;
+          while (comments[0] && comments[0].start < node.start) {
+            comment = comments.shift();
+            (node.leadingComments ||= []).push(comment);
+          }
+          next2();
+          if (comments[0]) {
+            const slice = source.slice(node.end, comments[0].start);
+            if (/^[,) \t]*$/.test(slice)) {
+              node.trailingComments = [comments.shift()];
+            }
+          }
+        }
+      });
+    }
+  };
+}
+function amend(source, node) {
+  return walk2(node, null, {
+    _(node2, context) {
+      delete node2.loc.start.index;
+      delete node2.loc.end.index;
+      if (node2.typeAnnotation && node2.end === void 0) {
+        let end = node2.typeAnnotation.start;
+        while (/\s/.test(source[end - 1]))
+          end -= 1;
+        node2.end = end;
+      }
+      context.next();
+    }
+  });
+}
+
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/utils/names.js
+var reserved = [
+  "arguments",
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "eval",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "interface",
+  "let",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "static",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield"
+];
+var void_element_names = [
+  "area",
+  "base",
+  "br",
+  "col",
+  "command",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "keygen",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+function is_void(name) {
+  return void_element_names.includes(name) || name.toLowerCase() === "!doctype";
+}
+
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/errors.js
+var CompileError = class extends Error {
+  name = "CompileError";
+  filename = filename;
+  position = void 0;
+  start = void 0;
+  end = void 0;
+  constructor(code, message, position) {
+    super(message);
+    this.code = code;
+    this.position = position;
+    if (position) {
+      this.start = locator(position[0]);
+      this.end = locator(position[1]);
+    }
+  }
+  toString() {
+    let out = `${this.name}: ${this.message}`;
+    out += `
+(${this.code})`;
+    if (this.filename) {
+      out += `
+${this.filename}`;
+      if (this.start) {
+        out += `${this.start.line}:${this.start.column}`;
+      }
+    }
+    return out;
+  }
+};
+function e3(node, code, message) {
+  const start = typeof node === "number" ? node : node?.start;
+  const end = typeof node === "number" ? node : node?.end;
+  throw new CompileError(code, message, start !== void 0 && end !== void 0 ? [start, end] : void 0);
+}
+function options_invalid_value(node, details) {
+  e3(node, "options_invalid_value", `Invalid compiler option: ${details}`);
+}
+function options_removed(node, details) {
+  e3(node, "options_removed", `Invalid compiler option: ${details}`);
+}
+function options_unrecognised(node, keypath) {
+  e3(node, "options_unrecognised", `Unrecognised compiler option ${keypath}`);
+}
+function bindable_invalid_location(node) {
+  e3(node, "bindable_invalid_location", "`$bindable()` can only be used inside a `$props()` declaration");
+}
+function constant_assignment(node, thing) {
+  e3(node, "constant_assignment", `Cannot assign to ${thing}`);
+}
+function constant_binding(node, thing) {
+  e3(node, "constant_binding", `Cannot bind to ${thing}`);
+}
+function declaration_duplicate_module_import(node) {
+  e3(node, "declaration_duplicate_module_import", 'Cannot declare same variable name which is imported inside `<script context="module">`');
+}
+function derived_invalid_export(node) {
+  e3(node, "derived_invalid_export", "Cannot export derived state from a module. To expose the current derived value, export a function returning its value");
+}
+function each_item_invalid_assignment(node) {
+  e3(node, "each_item_invalid_assignment", "Cannot reassign or bind to each block argument in runes mode. Use the array and index variables instead (e.g. `array[i] = value` instead of `entry = value`)");
+}
+function effect_invalid_placement(node) {
+  e3(node, "effect_invalid_placement", "`$effect()` can only be used as an expression statement");
+}
+function host_invalid_placement(node) {
+  e3(node, "host_invalid_placement", "`$host()` can only be used inside custom element component instances");
+}
+function import_svelte_internal_forbidden(node) {
+  e3(node, "import_svelte_internal_forbidden", "Imports of `svelte/internal/*` are forbidden. It contains private runtime code which is subject to change without notice. If you're importing from `svelte/internal/*` to work around a limitation of Svelte, please open an issue at https://github.com/sveltejs/svelte and explain your use case");
+}
+function legacy_export_invalid(node) {
+  e3(node, "legacy_export_invalid", "Cannot use `export let` in runes mode \u2014 use `$props()` instead");
+}
+function legacy_reactive_statement_invalid(node) {
+  e3(node, "legacy_reactive_statement_invalid", "`$:` is not allowed in runes mode, use `$derived` or `$effect` instead");
+}
+function module_illegal_default_export(node) {
+  e3(node, "module_illegal_default_export", "A component cannot have a default export");
+}
+function props_duplicate(node) {
+  e3(node, "props_duplicate", "Cannot use `$props()` more than once");
+}
+function props_invalid_identifier(node) {
+  e3(node, "props_invalid_identifier", "`$props()` can only be used with an object destructuring pattern");
+}
+function props_invalid_pattern(node) {
+  e3(node, "props_invalid_pattern", "`$props()` assignment must not contain nested properties or computed keys");
+}
+function props_invalid_placement(node) {
+  e3(node, "props_invalid_placement", "`$props()` can only be used at the top level of components as a variable declaration initializer");
+}
+function rune_invalid_arguments(node, rune) {
+  e3(node, "rune_invalid_arguments", `\`${rune}\` cannot be called with arguments`);
+}
+function rune_invalid_arguments_length(node, rune, args) {
+  e3(node, "rune_invalid_arguments_length", `\`${rune}\` must be called with ${args}`);
+}
+function rune_invalid_computed_property(node) {
+  e3(node, "rune_invalid_computed_property", "Cannot access a computed property of a rune");
+}
+function rune_invalid_name(node, name) {
+  e3(node, "rune_invalid_name", `\`${name}\` is not a valid rune`);
+}
+function rune_invalid_usage(node, rune) {
+  e3(node, "rune_invalid_usage", `Cannot use \`${rune}\` rune in non-runes mode`);
+}
+function rune_missing_parentheses(node) {
+  e3(node, "rune_missing_parentheses", "Cannot use rune without parentheses");
+}
+function runes_mode_invalid_import(node, name) {
+  e3(node, "runes_mode_invalid_import", `${name} cannot be used in runes mode`);
+}
+function snippet_parameter_assignment(node) {
+  e3(node, "snippet_parameter_assignment", "Cannot reassign or bind to snippet parameter");
+}
+function state_invalid_export(node) {
+  e3(node, "state_invalid_export", "Cannot export state from a module if it is reassigned. Either export a function returning the state value or only mutate the state value's properties");
+}
+function state_invalid_placement(node, rune) {
+  e3(node, "state_invalid_placement", `\`${rune}(...)\` can only be used as a variable declaration initializer or a class field`);
+}
+function css_empty_declaration(node) {
+  e3(node, "css_empty_declaration", "Declaration cannot be empty");
+}
+function css_expected_identifier(node) {
+  e3(node, "css_expected_identifier", "Expected a valid CSS identifier");
+}
+function css_global_block_invalid_combinator(node, name) {
+  e3(node, "css_global_block_invalid_combinator", `A :global {...} block cannot follow a ${name} combinator`);
+}
+function css_global_block_invalid_declaration(node) {
+  e3(node, "css_global_block_invalid_declaration", "A :global {...} block can only contain rules, not declarations");
+}
+function css_global_block_invalid_list(node) {
+  e3(node, "css_global_block_invalid_list", "A :global {...} block cannot be part of a selector list with more than one item");
+}
+function css_global_block_invalid_modifier(node) {
+  e3(node, "css_global_block_invalid_modifier", "A :global {...} block cannot modify an existing selector");
+}
+function css_global_invalid_placement(node) {
+  e3(node, "css_global_invalid_placement", ":global(...) can be at the start or end of a selector sequence, but not in the middle");
+}
+function css_global_invalid_selector(node) {
+  e3(node, "css_global_invalid_selector", ":global(...) must contain exactly one selector");
+}
+function css_global_invalid_selector_list(node) {
+  e3(node, "css_global_invalid_selector_list", ":global(...) must not contain type or universal selectors when used in a compound selector");
+}
+function css_nesting_selector_invalid_placement(node) {
+  e3(node, "css_nesting_selector_invalid_placement", "Nesting selectors can only be used inside a rule");
+}
+function css_selector_invalid(node) {
+  e3(node, "css_selector_invalid", "Invalid selector");
+}
+function css_type_selector_invalid_placement(node) {
+  e3(node, "css_type_selector_invalid_placement", ":global(...) must not be followed with a type selector");
+}
+function animation_duplicate(node) {
+  e3(node, "animation_duplicate", "An element can only have one 'animate' directive");
+}
+function animation_invalid_placement(node) {
+  e3(node, "animation_invalid_placement", "An element that uses the `animate:` directive must be the only child of a keyed `{#each ...}` block");
+}
+function animation_missing_key(node) {
+  e3(node, "animation_missing_key", "An element that uses the `animate:` directive must be the only child of a keyed `{#each ...}` block. Did you forget to add a key to your each block?");
+}
+function attribute_contenteditable_dynamic(node) {
+  e3(node, "attribute_contenteditable_dynamic", "'contenteditable' attribute cannot be dynamic if element uses two-way binding");
+}
+function attribute_contenteditable_missing(node) {
+  e3(node, "attribute_contenteditable_missing", "'contenteditable' attribute is required for textContent, innerHTML and innerText two-way bindings");
+}
+function attribute_duplicate(node) {
+  e3(node, "attribute_duplicate", "Attributes need to be unique");
+}
+function attribute_empty_shorthand(node) {
+  e3(node, "attribute_empty_shorthand", "Attribute shorthand cannot be empty");
+}
+function attribute_invalid_event_handler(node) {
+  e3(node, "attribute_invalid_event_handler", "Event attribute must be a JavaScript expression, not a string");
 }
-function parse_expression_at(source, typescript, index) {
-  const parser = typescript ? ParserWithTS : Parser;
-  const { onComment, add_comments } = get_comment_handlers(source);
-  const ast = parser.parseExpressionAt(source, index, {
-    onComment,
-    sourceType: "module",
-    ecmaVersion: 13,
-    locations: true
-  });
-  if (typescript)
-    amend(source, ast);
-  add_comments(ast);
-  return ast;
+function attribute_invalid_multiple(node) {
+  e3(node, "attribute_invalid_multiple", "'multiple' attribute must be static if select uses two-way binding");
+}
+function attribute_invalid_name(node, name) {
+  e3(node, "attribute_invalid_name", `'${name}' is not a valid attribute name`);
+}
+function attribute_invalid_sequence_expression(node) {
+  e3(node, "attribute_invalid_sequence_expression", "Sequence expressions are not allowed as attribute/directive values in runes mode, unless wrapped in parentheses");
+}
+function attribute_invalid_type(node) {
+  e3(node, "attribute_invalid_type", "'type' attribute must be a static text value if input uses two-way binding");
+}
+function bind_invalid_expression(node) {
+  e3(node, "bind_invalid_expression", "Can only bind to an Identifier or MemberExpression");
+}
+function bind_invalid_name(node, name, explanation) {
+  e3(node, "bind_invalid_name", explanation ? `\`bind:${name}\` is not a valid binding. ${explanation}` : `\`bind:${name}\` is not a valid binding`);
+}
+function bind_invalid_target(node, name, elements) {
+  e3(node, "bind_invalid_target", `\`bind:${name}\` can only be used with ${elements}`);
+}
+function bind_invalid_value(node) {
+  e3(node, "bind_invalid_value", "Can only bind to state or props");
+}
+function block_duplicate_clause(node, name) {
+  e3(node, "block_duplicate_clause", `${name} cannot appear more than once within a block`);
+}
+function block_invalid_continuation_placement(node) {
+  e3(node, "block_invalid_continuation_placement", "{:...} block is invalid at this position (did you forget to close the preceeding element or block?)");
+}
+function block_invalid_elseif(node) {
+  e3(node, "block_invalid_elseif", "'elseif' should be 'else if'");
+}
+function block_invalid_placement(node, name, location) {
+  e3(node, "block_invalid_placement", `{#${name} ...} block cannot be ${location}`);
+}
+function block_unclosed(node) {
+  e3(node, "block_unclosed", "Block was left open");
+}
+function block_unexpected_close(node) {
+  e3(node, "block_unexpected_close", "Unexpected block closing tag");
+}
+function component_invalid_directive(node) {
+  e3(node, "component_invalid_directive", "This type of directive is not valid on components");
+}
+function const_tag_invalid_expression(node) {
+  e3(node, "const_tag_invalid_expression", "{@const ...} must consist of a single variable declaration");
+}
+function const_tag_invalid_placement(node) {
+  e3(node, "const_tag_invalid_placement", "`{@const}` must be the immediate child of `{#snippet}`, `{#if}`, `{:else if}`, `{:else}`, `{#each}`, `{:then}`, `{:catch}`, `<svelte:fragment>` or `<Component>`");
+}
+function debug_tag_invalid_arguments(node) {
+  e3(node, "debug_tag_invalid_arguments", "{@debug ...} arguments must be identifiers, not arbitrary expressions");
+}
+function directive_invalid_value(node) {
+  e3(node, "directive_invalid_value", "Directive value must be a JavaScript expression enclosed in curly braces");
+}
+function directive_missing_name(node, type) {
+  e3(node, "directive_missing_name", `\`${type}\` name cannot be empty`);
+}
+function element_invalid_closing_tag(node, name) {
+  e3(node, "element_invalid_closing_tag", `\`</${name}>\` attempted to close an element that was not open`);
+}
+function element_invalid_closing_tag_autoclosed(node, name, reason) {
+  e3(node, "element_invalid_closing_tag_autoclosed", `\`</${name}>\` attempted to close element that was already automatically closed by \`<${reason}>\` (cannot nest \`<${reason}>\` inside \`<${name}>\`)`);
+}
+function element_invalid_tag_name(node) {
+  e3(node, "element_invalid_tag_name", "Expected valid tag name");
+}
+function element_unclosed(node, name) {
+  e3(node, "element_unclosed", `\`<${name}>\` was left open`);
+}
+function event_handler_invalid_component_modifier(node) {
+  e3(node, "event_handler_invalid_component_modifier", "Event modifiers other than 'once' can only be used on DOM elements");
+}
+function event_handler_invalid_modifier(node, list3) {
+  e3(node, "event_handler_invalid_modifier", `Valid event modifiers are ${list3}`);
+}
+function event_handler_invalid_modifier_combination(node, modifier1, modifier2) {
+  e3(node, "event_handler_invalid_modifier_combination", `The '${modifier1}' and '${modifier2}' modifiers cannot be used together`);
+}
+function expected_attribute_value(node) {
+  e3(node, "expected_attribute_value", "Expected attribute value");
+}
+function expected_block_type(node) {
+  e3(node, "expected_block_type", "Expected 'if', 'each', 'await', 'key' or 'snippet'");
+}
+function expected_identifier(node) {
+  e3(node, "expected_identifier", "Expected an identifier");
+}
+function expected_pattern(node) {
+  e3(node, "expected_pattern", "Expected identifier or destructure pattern");
+}
+function expected_token(node, token) {
+  e3(node, "expected_token", `Expected token ${token}`);
+}
+function expected_whitespace(node) {
+  e3(node, "expected_whitespace", "Expected whitespace");
+}
+function js_parse_error(node, message) {
+  e3(node, "js_parse_error", `${message}`);
+}
+function let_directive_invalid_placement(node) {
+  e3(node, "let_directive_invalid_placement", "`let:` directive at invalid position");
+}
+function node_invalid_placement(node, thing, parent2) {
+  e3(node, "node_invalid_placement", `${thing} is invalid inside <${parent2}>`);
+}
+function render_tag_invalid_call_expression(node) {
+  e3(node, "render_tag_invalid_call_expression", "Calling a snippet function using apply, bind or call is not allowed");
+}
+function render_tag_invalid_expression(node) {
+  e3(node, "render_tag_invalid_expression", "`{@render ...}` tags can only contain call expressions");
+}
+function render_tag_invalid_spread_argument(node) {
+  e3(node, "render_tag_invalid_spread_argument", "cannot use spread arguments in `{@render ...}` tags");
+}
+function script_duplicate(node) {
+  e3(node, "script_duplicate", 'A component can have a single top-level `<script>` element and/or a single top-level `<script context="module">` element');
+}
+function script_invalid_context(node) {
+  e3(node, "script_invalid_context", 'If the context attribute is supplied, its value must be "module"');
+}
+function slot_attribute_duplicate(node, name, component) {
+  e3(node, "slot_attribute_duplicate", `Duplicate slot name '${name}' in <${component}>`);
+}
+function slot_attribute_invalid(node) {
+  e3(node, "slot_attribute_invalid", "slot attribute must be a static value");
+}
+function slot_attribute_invalid_placement(node) {
+  e3(node, "slot_attribute_invalid_placement", "Element with a slot='...' attribute must be a child of a component or a descendant of a custom element");
+}
+function slot_default_duplicate(node) {
+  e3(node, "slot_default_duplicate", 'Found default slot content alongside an explicit slot="default"');
+}
+function slot_element_invalid_attribute(node) {
+  e3(node, "slot_element_invalid_attribute", "`<slot>` can only receive attributes and (optionally) let directives");
+}
+function slot_element_invalid_name(node) {
+  e3(node, "slot_element_invalid_name", "slot attribute must be a static value");
+}
+function slot_element_invalid_name_default(node) {
+  e3(node, "slot_element_invalid_name_default", "`default` is a reserved word \u2014 it cannot be used as a slot name");
+}
+function snippet_conflict(node) {
+  e3(node, "snippet_conflict", "Cannot use explicit children snippet at the same time as implicit children content. Remove either the non-whitespace content or the children snippet block");
+}
+function snippet_shadowing_prop(node, prop2) {
+  e3(node, "snippet_shadowing_prop", `This snippet is shadowing the prop \`${prop2}\` with the same name`);
+}
+function style_directive_invalid_modifier(node) {
+  e3(node, "style_directive_invalid_modifier", "`style:` directive can only use the `important` modifier");
+}
+function style_duplicate(node) {
+  e3(node, "style_duplicate", "A component can have a single top-level `<style>` element");
+}
+function svelte_component_invalid_this(node) {
+  e3(node, "svelte_component_invalid_this", "Invalid component definition \u2014 must be an `{expression}`");
+}
+function svelte_component_missing_this(node) {
+  e3(node, "svelte_component_missing_this", "`<svelte:component>` must have a 'this' attribute");
+}
+function svelte_element_missing_this(node) {
+  e3(node, "svelte_element_missing_this", "`<svelte:element>` must have a 'this' attribute with a value");
+}
+function svelte_fragment_invalid_attribute(node) {
+  e3(node, "svelte_fragment_invalid_attribute", "`<svelte:fragment>` can only have a slot attribute and (optionally) a let: directive");
+}
+function svelte_fragment_invalid_placement(node) {
+  e3(node, "svelte_fragment_invalid_placement", "`<svelte:fragment>` must be the direct child of a component");
+}
+function svelte_head_illegal_attribute(node) {
+  e3(node, "svelte_head_illegal_attribute", "`<svelte:head>` cannot have attributes nor directives");
+}
+function svelte_meta_duplicate(node, name) {
+  e3(node, "svelte_meta_duplicate", `A component can only have one \`<${name}>\` element`);
+}
+function svelte_meta_invalid_content(node, name) {
+  e3(node, "svelte_meta_invalid_content", `<${name}> cannot have children`);
+}
+function svelte_meta_invalid_placement(node, name) {
+  e3(node, "svelte_meta_invalid_placement", `\`<${name}>\` tags cannot be inside elements or blocks`);
+}
+function svelte_meta_invalid_tag(node, list3) {
+  e3(node, "svelte_meta_invalid_tag", `Valid \`<svelte:...>\` tag names are ${list3}`);
+}
+function svelte_options_deprecated_tag(node) {
+  e3(node, "svelte_options_deprecated_tag", '"tag" option is deprecated \u2014 use "customElement" instead');
+}
+function svelte_options_invalid_attribute(node) {
+  e3(node, "svelte_options_invalid_attribute", "`<svelte:options>` can only receive static attributes");
+}
+function svelte_options_invalid_attribute_value(node, list3) {
+  e3(node, "svelte_options_invalid_attribute_value", `Valid values are ${list3}`);
+}
+function svelte_options_invalid_customelement(node) {
+  e3(node, "svelte_options_invalid_customelement", '"customElement" must be a string literal defining a valid custom element name or an object of the form { tag: string; shadow?: "open" | "none"; props?: { [key: string]: { attribute?: string; reflect?: boolean; type: .. } } }');
+}
+function svelte_options_invalid_customelement_props(node) {
+  e3(node, "svelte_options_invalid_customelement_props", '"props" must be a statically analyzable object literal of the form "{ [key: string]: { attribute?: string; reflect?: boolean; type?: "String" | "Boolean" | "Number" | "Array" | "Object" }"');
+}
+function svelte_options_invalid_customelement_shadow(node) {
+  e3(node, "svelte_options_invalid_customelement_shadow", '"shadow" must be either "open" or "none"');
+}
+function svelte_options_invalid_tagname(node) {
+  e3(node, "svelte_options_invalid_tagname", 'Tag name must be two or more words joined by the "-" character');
+}
+function svelte_options_unknown_attribute(node, name) {
+  e3(node, "svelte_options_unknown_attribute", `\`<svelte:options>\` unknown attribute '${name}'`);
+}
+function svelte_self_invalid_placement(node) {
+  e3(node, "svelte_self_invalid_placement", "`<svelte:self>` components can only exist inside `{#if}` blocks, `{#each}` blocks, `{#snippet}` blocks or slots passed to components");
+}
+function tag_invalid_placement(node, name, location) {
+  e3(node, "tag_invalid_placement", `{@${name} ...} tag cannot be ${location}`);
+}
+function textarea_invalid_content(node) {
+  e3(node, "textarea_invalid_content", "A `<textarea>` can have either a value attribute or (equivalently) child content, but not both");
+}
+function title_illegal_attribute(node) {
+  e3(node, "title_illegal_attribute", "`<title>` cannot have attributes nor directives");
+}
+function title_invalid_content(node) {
+  e3(node, "title_invalid_content", "`<title>` can only contain text and {tags}");
+}
+function transition_conflict(node, type, existing) {
+  e3(node, "transition_conflict", `Cannot use \`${type}:\` alongside existing \`${existing}:\` directive`);
+}
+function transition_duplicate(node, type) {
+  e3(node, "transition_duplicate", `Cannot use multiple \`${type}:\` directives on a single element`);
 }
-function get_comment_handlers(source) {
-  const comments = [];
-  return {
-    onComment: (block4, value, start, end) => {
-      if (block4 && /\n/.test(value)) {
-        let a2 = start;
-        while (a2 > 0 && source[a2 - 1] !== "\n")
-          a2 -= 1;
-        let b2 = a2;
-        while (/[ \t]/.test(source[b2]))
-          b2 += 1;
-        const indentation = source.slice(a2, b2);
-        value = value.replace(new RegExp(`^${indentation}`, "gm"), "");
-      }
-      comments.push({ type: block4 ? "Block" : "Line", value, start, end });
-    },
-    add_comments(ast) {
-      if (comments.length === 0)
-        return;
-      walk2(ast, null, {
-        _(node, { next: next2 }) {
-          let comment;
-          while (comments[0] && comments[0].start < node.start) {
-            comment = comments.shift();
-            (node.leadingComments ||= []).push(comment);
-          }
-          next2();
-          if (comments[0]) {
-            const slice = source.slice(node.end, comments[0].start);
-            if (/^[,) \t]*$/.test(slice)) {
-              node.trailingComments = [comments.shift()];
-            }
-          }
-        }
-      });
-    }
-  };
+function unexpected_eof(node) {
+  e3(node, "unexpected_eof", "Unexpected end of input");
 }
-function amend(source, node) {
-  return walk2(node, null, {
-    _(node2, context) {
-      delete node2.loc.start.index;
-      delete node2.loc.end.index;
-      if (node2.typeAnnotation && node2.end === void 0) {
-        let end = node2.typeAnnotation.start;
-        while (/\s/.test(source[end - 1]))
-          end -= 1;
-        node2.end = end;
-      }
-      context.next();
-    }
-  });
+function unexpected_reserved_word(node, word) {
+  e3(node, "unexpected_reserved_word", `'${word}' is a reserved word in JavaScript and cannot be used here`);
 }
-
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/utils/names.js
-var reserved = [
-  "arguments",
-  "await",
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "enum",
-  "eval",
-  "export",
-  "extends",
-  "false",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "implements",
-  "import",
-  "in",
-  "instanceof",
-  "interface",
-  "let",
-  "new",
-  "null",
-  "package",
-  "private",
-  "protected",
-  "public",
-  "return",
-  "static",
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-  "yield"
-];
-var void_element_names = [
-  "area",
-  "base",
-  "br",
-  "col",
-  "command",
-  "embed",
-  "hr",
-  "img",
-  "input",
-  "keygen",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
-];
-function is_void(name) {
-  return void_element_names.includes(name) || name.toLowerCase() === "!doctype";
+function void_element_invalid_content(node) {
+  e3(node, "void_element_invalid_content", "Void elements cannot have children or closing tags");
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/read/expression.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/read/expression.js
 function read_expression(parser) {
   try {
     const node = parse_expression_at(parser.template, parser.ts, parser.index);
@@ -163472,7 +163497,7 @@ function read_expression(parser) {
   }
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/read/script.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/read/script.js
 var regex_closing_script_tag = /<\/script\s*>/;
 var regex_starts_with_closing_script_tag = /^<\/script\s*>/;
 function get_context(attributes) {
@@ -163516,7 +163541,7 @@ function read_script(parser, start, attributes) {
   };
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/read/style.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/read/style.js
 var REGEX_MATCHER = /^[~^$*|]?=/;
 var REGEX_CLOSING_BRACKET = /[\s\]]/;
 var REGEX_ATTRIBUTE_FLAGS = /^[a-zA-Z]+/;
@@ -163604,7 +163629,7 @@ function read_selector_list(parser, inside_pseudo_class = false) {
   while (parser.index < parser.template.length) {
     children.push(read_selector(parser, inside_pseudo_class));
     const end = parser.index;
-    parser.allow_whitespace();
+    allow_comment_or_whitespace(parser);
     if (inside_pseudo_class ? parser.match(")") : parser.match("{")) {
       return {
         type: "SelectorList",
@@ -163746,7 +163771,7 @@ function read_selector(parser, inside_pseudo_class = false) {
       });
     }
     const index = parser.index;
-    parser.allow_whitespace();
+    allow_comment_or_whitespace(parser);
     if (parser.match(",") || (inside_pseudo_class ? parser.match(")") : parser.match("{"))) {
       parser.index = index;
       relative_selector.end = index;
@@ -163952,7 +163977,7 @@ function allow_comment_or_whitespace(parser) {
   }
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/constants.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/constants.js
 var EACH_ITEM_REACTIVE = 1;
 var EACH_INDEX_REACTIVE = 1 << 1;
 var EACH_KEYED = 1 << 2;
@@ -163971,6 +163996,8 @@ var TEMPLATE_USE_IMPORT_NODE = 1 << 1;
 var HYDRATION_START = "[";
 var HYDRATION_END = "]";
 var HYDRATION_END_ELSE = `${HYDRATION_END}!`;
+var ELEMENT_IS_NAMESPACED = 1;
+var ELEMENT_PRESERVE_ATTRIBUTE_CASE = 1 << 1;
 var UNINITIALIZED = Symbol();
 var AttributeAliases = {
   formnovalidate: "formNoValidate",
@@ -164104,7 +164131,7 @@ function is_tag_valid_with_parent(tag2, parent_tag) {
   return true;
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/utils/entities.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/utils/entities.js
 var entities_default = {
   "CounterClockwiseContourIntegral;": 8755,
   "ClockwiseContourIntegral;": 8754,
@@ -166339,7 +166366,7 @@ var entities_default = {
   lt: 60
 };
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/utils/html.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/utils/html.js
 var windows_1252 = [
   8364,
   129,
@@ -166470,7 +166497,7 @@ function closing_tag_omitted(current2, next2) {
   return false;
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/utils/create.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/utils/create.js
 function create_fragment(transparent = false) {
   return {
     type: "Fragment",
@@ -166479,7 +166506,7 @@ function create_fragment(transparent = false) {
   };
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/nodes.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/nodes.js
 var element_nodes = [
   "SvelteElement",
   "RegularElement",
@@ -166493,7 +166520,7 @@ function is_element_node(node) {
   return element_nodes.includes(node.type);
 }
 function is_custom_element_node(node) {
-  return node.name.includes("-");
+  return node.type === "RegularElement" && node.name.includes("-");
 }
 function create_attribute(name, start, end, value) {
   return {
@@ -166510,7 +166537,7 @@ function create_attribute(name, start, end, value) {
   };
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/state/element.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/state/element.js
 var valid_tag_name = /^\!?[a-zA-Z]{1,}:?[a-zA-Z0-9\-]*/;
 var regex_starts_with_invalid_attr_value = /^(\/>|[\s"'=<>`])/;
 var root_only_meta_tags = /* @__PURE__ */ new Map([
@@ -166657,7 +166684,7 @@ function tag(parser) {
   while (attribute = read(parser)) {
     if (attribute.type === "Attribute" || attribute.type === "BindDirective") {
       if (unique_names.includes(attribute.name)) {
-        attribute_duplicate(attribute.start);
+        attribute_duplicate(attribute);
       } else if (attribute.name !== "this") {
         unique_names.push(attribute.name);
       }
@@ -166686,11 +166713,23 @@ function tag(parser) {
       svelte_element_missing_this(start);
     }
     const definition = element.attributes.splice(index, 1)[0];
-    if (definition.value === true || definition.value.length !== 1) {
-      svelte_element_invalid_this(definition.start);
+    if (definition.value === true) {
+      svelte_element_missing_this(definition);
     }
     const chunk = definition.value[0];
-    element.tag = chunk.type === "Text" ? { type: "Literal", value: chunk.data, raw: `'${chunk.raw}'` } : chunk.expression;
+    if (definition.value.length !== 1 || chunk.type !== "ExpressionTag") {
+      chunk.type;
+      svelte_element_invalid_this(definition);
+      element.tag = chunk.type === "Text" ? {
+        type: "Literal",
+        value: chunk.data,
+        raw: `'${chunk.raw}'`,
+        start: chunk.start,
+        end: chunk.end
+      } : chunk.expression;
+    } else {
+      element.tag = chunk.expression;
+    }
   }
   if (is_top_level_script_or_style) {
     parser.eat(">", true);
@@ -167083,7 +167122,7 @@ function read_sequence(parser, done, location) {
   unexpected_eof(parser.template.length);
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/utils/full_char_code_at.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/utils/full_char_code_at.js
 function full_char_code_at(str, i3) {
   const code = str.charCodeAt(i3);
   if (code <= 55295 || code >= 57344)
@@ -167092,7 +167131,7 @@ function full_char_code_at(str, i3) {
   return (code << 10) + next2 - 56613888;
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/utils/bracket.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/utils/bracket.js
 var SQUARE_BRACKET_OPEN = "[".charCodeAt(0);
 var SQUARE_BRACKET_CLOSE = "]".charCodeAt(0);
 var CURLY_BRACKET_OPEN = "{".charCodeAt(0);
@@ -167115,7 +167154,7 @@ function get_bracket_close(open2) {
   }
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/read/context.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/read/context.js
 function read_pattern(parser, optional_allowed = false) {
   const start = parser.index;
   let i3 = parser.index;
@@ -167204,7 +167243,7 @@ function read_type_annotation(parser, optional_allowed = false) {
   };
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/state/tag.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/state/tag.js
 var regex_whitespace_with_closing_curly_brace = /^\s*}/;
 function mustache(parser) {
   const start = parser.index;
@@ -167644,7 +167683,7 @@ function special(parser) {
   }
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/state/text.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/state/text.js
 function text(parser) {
   const start = parser.index;
   let data2 = "";
@@ -167660,7 +167699,7 @@ function text(parser) {
   });
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/state/fragment.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/state/fragment.js
 function fragment(parser) {
   if (parser.match("<")) {
     return tag;
@@ -167671,7 +167710,7 @@ function fragment(parser) {
   return text;
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/read/options.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/read/options.js
 var regex_valid_tag_name = /^[a-zA-Z][a-zA-Z0-9]*-[a-zA-Z0-9-]+$/;
 function read_options(node) {
   const component_options = {
@@ -167846,7 +167885,7 @@ function validate_tag(attribute, tag2) {
   }
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/1-parse/index.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/1-parse/index.js
 var regex_position_indicator = / \(\d+:\d+\)$/;
 var regex_lang_attribute = /<!--[^]*?-->|<script\s+(?:[^>]*|(?:[^=>'"/]+=(?:"[^"]*"|'[^']*'|[^>\s]+)\s+)*)lang=(["'])?([^"' >]+)\1[^>]*>/g;
 var Parser3 = class {
@@ -168030,12 +168069,12 @@ function parse15(template2) {
   return parser.root;
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/utils/sanitize_template_string.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/utils/sanitize_template_string.js
 function sanitize_template_string(str) {
   return str.replace(/(`|\${|\\)/g, "\\$1");
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/utils/builders.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/utils/builders.js
 function array(elements = []) {
   return { type: "ArrayExpression", elements };
 }
@@ -168307,7 +168346,7 @@ function is_reference(node, parent2) {
   return false;
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/utils/ast.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/utils/ast.js
 function object2(expression) {
   while (expression.type === "MemberExpression") {
     expression = expression.object;
@@ -168578,7 +168617,7 @@ function is_expression_async(expression) {
   }
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/constants.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/constants.js
 var DOMProperties = [
   ...Object.values(AttributeAliases),
   "value",
@@ -168608,6 +168647,7 @@ var Runes = [
   "$state",
   "$state.frozen",
   "$state.snapshot",
+  "$state.is",
   "$props",
   "$bindable",
   "$derived",
@@ -168622,6 +168662,17 @@ var Runes = [
 ];
 var WhitespaceInsensitiveAttributes = ["class", "style"];
 var ContentEditableBindings = ["textContent", "innerHTML", "innerText"];
+var LoadErrorElements = [
+  "body",
+  "embed",
+  "iframe",
+  "img",
+  "link",
+  "object",
+  "script",
+  "style",
+  "track"
+];
 var SVGElements = [
   "altGlyph",
   "altGlyphDef",
@@ -168722,7 +168773,7 @@ var EventModifiers = [
   "trusted"
 ];
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/scope.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/scope.js
 function get_rune(node, scope) {
   if (!node)
     return null;
@@ -168753,7 +168804,7 @@ function get_rune(node, scope) {
   return joined;
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/visitors.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/visitors.js
 var overrides = {
   visit() {
     throw new Error("Cannot call visit() during analysis");
@@ -168800,7 +168851,7 @@ function merge(...tasks) {
   return combined;
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/bindings.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/bindings.js
 var binding_properties = {
   currentTime: {
     valid_elements: ["audio", "video"],
@@ -168916,28 +168967,36 @@ var binding_properties = {
     omit_in_ssr: true
   },
   clientWidth: {
-    omit_in_ssr: true
+    omit_in_ssr: true,
+    invalid_elements: ["svelte:window", "svelte:document"]
   },
   clientHeight: {
-    omit_in_ssr: true
+    omit_in_ssr: true,
+    invalid_elements: ["svelte:window", "svelte:document"]
   },
   offsetWidth: {
-    omit_in_ssr: true
+    omit_in_ssr: true,
+    invalid_elements: ["svelte:window", "svelte:document"]
   },
   offsetHeight: {
-    omit_in_ssr: true
+    omit_in_ssr: true,
+    invalid_elements: ["svelte:window", "svelte:document"]
   },
   contentRect: {
-    omit_in_ssr: true
+    omit_in_ssr: true,
+    invalid_elements: ["svelte:window", "svelte:document"]
   },
   contentBoxSize: {
-    omit_in_ssr: true
+    omit_in_ssr: true,
+    invalid_elements: ["svelte:window", "svelte:document"]
   },
   borderBoxSize: {
-    omit_in_ssr: true
+    omit_in_ssr: true,
+    invalid_elements: ["svelte:window", "svelte:document"]
   },
   devicePixelContentBoxSize: {
-    omit_in_ssr: true
+    omit_in_ssr: true,
+    invalid_elements: ["svelte:window", "svelte:document"]
   },
   indeterminate: {
     event: "change",
@@ -168954,9 +169013,15 @@ var binding_properties = {
   this: {
     omit_in_ssr: true
   },
-  innerText: {},
-  innerHTML: {},
-  textContent: {},
+  innerText: {
+    invalid_elements: ["svelte:window", "svelte:document"]
+  },
+  innerHTML: {
+    invalid_elements: ["svelte:window", "svelte:document"]
+  },
+  textContent: {
+    invalid_elements: ["svelte:window", "svelte:document"]
+  },
   open: {
     event: "toggle",
     type: "set",
@@ -168971,11 +169036,11 @@ var binding_properties = {
   }
 };
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/2-analyze/a11y.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/2-analyze/a11y.js
 var import_aria_query = __toESM(require_lib8(), 1);
 var import_axobject_query = __toESM(require_lib9(), 1);
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/utils/string.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/utils/string.js
 function list(strings, conjunction = "or") {
   if (strings.length === 1)
     return strings[0];
@@ -168984,7 +169049,7 @@ function list(strings, conjunction = "or") {
   return `${strings.slice(0, -1).join(", ")} ${conjunction} ${strings[strings.length - 1]}`;
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/2-analyze/a11y.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/2-analyze/a11y.js
 var aria_roles = import_aria_query.roles.keys();
 var abstract_roles = aria_roles.filter((role) => import_aria_query.roles.get(role)?.abstract);
 var non_abstract_roles = aria_roles.filter((name) => !abstract_roles.includes(name));
@@ -169806,7 +169871,7 @@ var a11y_validators = {
   }
 };
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/2-analyze/validation.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/2-analyze/validation.js
 function validate_component(node, context) {
   for (const attribute of node.attributes) {
     if (attribute.type !== "Attribute" && attribute.type !== "SpreadAttribute" && attribute.type !== "LetDirective" && attribute.type !== "OnDirective" && attribute.type !== "BindDirective") {
@@ -170043,6 +170108,16 @@ var validation = {
             property.valid_elements.map((valid_element) => `<${valid_element}>`).join(", ")
           );
         }
+        if (property.invalid_elements && property.invalid_elements.includes(parent2.name)) {
+          const valid_bindings = Object.entries(binding_properties).filter(([_, binding_property]) => {
+            return binding_property.valid_elements?.includes(parent2.name) || !binding_property.valid_elements && !binding_property.invalid_elements?.includes(parent2.name);
+          }).map(([property_name]) => property_name);
+          bind_invalid_name(
+            node,
+            node.name,
+            `Possible bindings for <${parent2.name}> are ${valid_bindings.join(", ")}`
+          );
+        }
         if (parent2.name === "input" && node.name !== "this") {
           const type = parent2.attributes.find((a2) => a2.type === "Attribute" && a2.name === "type");
           if (type && !is_text_attribute(type)) {
@@ -170174,16 +170249,6 @@ var validation = {
     if (callee.type === "MemberExpression" && callee.property.type === "Identifier" && ["bind", "apply", "call"].includes(callee.property.name)) {
       render_tag_invalid_call_expression(node);
     }
-    const is_inside_textarea = context.path.find((n2) => {
-      return n2.type === "SvelteElement" && n2.name === "svelte:element" && n2.tag.type === "Literal" && n2.tag.value === "textarea";
-    });
-    if (is_inside_textarea) {
-      tag_invalid_placement(
-        node,
-        'inside <textarea> or <svelte:element this="textarea">',
-        "render"
-      );
-    }
   },
   IfBlock(node, context) {
     validate_block_not_empty(node.consequent, context);
@@ -170204,12 +170269,17 @@ var validation = {
   SnippetBlock(node, context) {
     validate_block_not_empty(node.body, context);
     context.next({ ...context.state, parent_element: null });
-    if (node.expression.name !== "children")
-      return;
     const { path: path3 } = context;
     const parent2 = path3.at(-2);
     if (!parent2)
       return;
+    if (parent2.type === "Component" && parent2.attributes.some(
+      (attribute) => (attribute.type === "Attribute" || attribute.type === "BindDirective") && attribute.name === node.expression.name
+    )) {
+      snippet_shadowing_prop(node, node.expression.name);
+    }
+    if (node.expression.name !== "children")
+      return;
     if (parent2.type === "Component" || parent2.type === "SvelteComponent" || parent2.type === "SvelteSelf") {
       if (parent2.fragment.nodes.some(
         (node2) => node2.type !== "SnippetBlock" && (node2.type !== "Text" || node2.data.trim())
@@ -170401,6 +170471,11 @@ function validate_call_expression(node, scope, path3) {
       rune_invalid_arguments_length(node, rune, "exactly one argument");
     }
   }
+  if (rune === "$state.is") {
+    if (node.arguments.length !== 2) {
+      rune_invalid_arguments_length(node, rune, "exactly two arguments");
+    }
+  }
 }
 function ensure_no_module_import_conflict(node, state) {
   const ids = extract_identifiers(node.id);
@@ -170411,6 +170486,11 @@ function ensure_no_module_import_conflict(node, state) {
   }
 }
 var validation_runes_js = {
+  ImportDeclaration(node) {
+    if (typeof node.source.value === "string" && node.source.value.startsWith("svelte/internal")) {
+      import_svelte_internal_forbidden(node);
+    }
+  },
   ExportSpecifier(node, { state }) {
     validate_export(node, state.scope, node.local.name);
   },
@@ -170533,6 +170613,11 @@ function validate_assignment(node, argument, state) {
   }
 }
 var validation_runes = merge(validation, a11y_validators, {
+  ImportDeclaration(node) {
+    if (typeof node.source.value === "string" && node.source.value.startsWith("svelte/internal")) {
+      import_svelte_internal_forbidden(node);
+    }
+  },
   Identifier(node, { path: path3, state }) {
     let i3 = path3.length;
     let parent2 = path3[--i3];
@@ -170664,7 +170749,7 @@ var validation_runes = merge(validation, a11y_validators, {
   NewExpression: validation_runes_js.NewExpression
 });
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/3-transform/client/utils.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/3-transform/client/utils.js
 function get_assignment_value(node, { state, visit: visit24 }) {
   if (node.left.type === "Identifier") {
     const operator = node.operator;
@@ -171025,14 +171110,14 @@ function with_loc(target, source) {
   return target;
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/css.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/css.js
 var regex_css_browser_prefix = /^-((webkit)|(moz)|(o)|(ms))-/;
 function remove_css_prefix(name) {
   return name.replace(regex_css_browser_prefix, "");
 }
 var is_keyframes_node = (node) => remove_css_prefix(node.name) === "keyframes";
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/2-analyze/css/css-analyze.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/2-analyze/css/css-analyze.js
 function is_global(relative_selector) {
   const first = relative_selector.selectors[0];
   return first.type === "PseudoClassSelector" && first.name === "global" && relative_selector.selectors.every(
@@ -172223,7 +172308,7 @@ if (typeof window !== "undefined" && typeof window.btoa === "function") {
   btoa2 = (str) => Buffer.from(str, "utf-8").toString("base64");
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/3-transform/utils.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/3-transform/utils.js
 function is_hoistable_function(node) {
   if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration") {
     return node.metadata?.hoistable === true;
@@ -172380,7 +172465,7 @@ function transform_inspect_rune(node, context) {
   }
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/escaping.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/escaping.js
 var ATTR_REGEX = /[&"<]/g;
 var CONTENT_REGEX = /[&<]/g;
 function escape_html(value, is_attr) {
@@ -172398,12 +172483,12 @@ function escape_html(value, is_attr) {
   return escaped + str.substring(last);
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/internal/server/hydration.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/internal/server/hydration.js
 var BLOCK_OPEN = `<!--${HYDRATION_START}-->`;
 var BLOCK_CLOSE = `<!--${HYDRATION_END}-->`;
 var BLOCK_CLOSE_ELSE = `<!--${HYDRATION_END_ELSE}-->`;
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/3-transform/server/transform-server.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/3-transform/server/transform-server.js
 var block_open = t_string(`<!--${HYDRATION_START}-->`);
 var block_close = t_string(`<!--${HYDRATION_END}-->`);
 function t_string(value) {
@@ -172750,6 +172835,12 @@ var javascript_visitors_runes = {
     if (rune === "$state.snapshot") {
       return context.visit(node.arguments[0]);
     }
+    if (rune === "$state.is") {
+      return call(
+        "Object.is",
+        context.visit(node.arguments[0])
+      );
+    }
     if (rune === "$inspect" || rune === "$inspect().with") {
       return transform_inspect_rune(node, context);
     }
@@ -172810,52 +172901,50 @@ function serialize_attribute_value(attribute_value, context, trim_whitespace = f
   return template(quasis, expressions);
 }
 function serialize_element_spread_attributes(element, attributes, style_directives, class_directives, context) {
-  const values = [];
-  for (const attribute of attributes) {
-    if (attribute.type === "Attribute") {
-      const name = get_attribute_name(element, attribute, context);
-      const value = serialize_attribute_value(
-        attribute.value,
-        context,
-        WhitespaceInsensitiveAttributes.includes(name)
-      );
-      values.push(object([prop("init", literal2(name), value)]));
-    } else {
-      values.push(context.visit(attribute));
+  let classes;
+  let styles;
+  let flags = 0;
+  if (class_directives.length > 0 || context.state.analysis.css.hash) {
+    const properties = class_directives.map(
+      (directive) => init(
+        directive.name,
+        directive.expression.type === "Identifier" && directive.expression.name === directive.name ? id(directive.name) : context.visit(directive.expression)
+      )
+    );
+    if (context.state.analysis.css.hash) {
+      properties.unshift(init(context.state.analysis.css.hash, literal2(true)));
     }
+    classes = object(properties);
   }
-  const lowercase_attributes = element.metadata.svg || element.metadata.mathml || element.type === "RegularElement" && is_custom_element_node(element) ? false_instance : true_instance;
-  const is_html = element.metadata.svg || element.metadata.mathml ? false_instance : true_instance;
-  const args = [
-    array(values),
-    lowercase_attributes,
-    is_html,
-    literal2(context.state.analysis.css.hash)
-  ];
-  if (style_directives.length > 0 || class_directives.length > 0) {
-    const styles = style_directives.map(
+  if (style_directives.length > 0) {
+    const properties = style_directives.map(
       (directive) => init(
         directive.name,
         directive.value === true ? id(directive.name) : serialize_attribute_value(directive.value, context, true)
       )
     );
-    const expressions = class_directives.map(
-      (directive) => conditional(directive.expression, literal2(directive.name), literal2(""))
-    );
-    const classes = expressions.length ? call(
-      member(
-        call(member(array(expressions), id("filter")), id("Boolean")),
-        id("join")
-      ),
-      literal2(" ")
-    ) : literal2("");
-    args.push(
-      object([
-        init("styles", styles.length === 0 ? literal2(null) : object(styles)),
-        init("classes", classes)
-      ])
-    );
+    styles = object(properties);
   }
+  if (element.metadata.svg || element.metadata.mathml) {
+    flags |= ELEMENT_IS_NAMESPACED | ELEMENT_PRESERVE_ATTRIBUTE_CASE;
+  } else if (is_custom_element_node(element)) {
+    flags |= ELEMENT_PRESERVE_ATTRIBUTE_CASE;
+  }
+  const object4 = object(
+    attributes.map((attribute) => {
+      if (attribute.type === "Attribute") {
+        const name = get_attribute_name(element, attribute, context);
+        const value = serialize_attribute_value(
+          attribute.value,
+          context,
+          WhitespaceInsensitiveAttributes.includes(name)
+        );
+        return prop("init", key(name), value);
+      }
+      return spread(context.visit(attribute));
+    })
+  );
+  const args = [object4, classes, styles, flags ? literal2(flags) : void 0];
   context.state.template.push(t_expression(call("$.spread_attributes", ...args)));
 }
 function serialize_inline_component(node, component_name, context) {
@@ -172864,6 +172953,7 @@ function serialize_inline_component(node, component_name, context) {
   const lets = [];
   const children = {};
   let slot_scope_applies_to_itself = false;
+  let has_children_prop = false;
   function push_prop(prop2) {
     const current2 = props_and_spreads.at(-1);
     const current_is_props = Array.isArray(current2);
@@ -172887,6 +172977,9 @@ function serialize_inline_component(node, component_name, context) {
       if (attribute.name === "slot") {
         slot_scope_applies_to_itself = true;
       }
+      if (attribute.name === "children") {
+        has_children_prop = true;
+      }
       const value = serialize_attribute_value(attribute.value, context, false, true);
       push_prop(prop("init", key(attribute.name), value));
     } else if (attribute.type === "BindDirective" && attribute.name !== "this") {
@@ -172939,7 +173032,7 @@ function serialize_inline_component(node, component_name, context) {
       [id("$$payload"), id("$$slotProps")],
       block3([...slot_name === "default" && !slot_scope_applies_to_itself ? lets : [], ...body])
     );
-    if (slot_name === "default") {
+    if (slot_name === "default" && !has_children_prop) {
       push_prop(
         prop(
           "init",
@@ -172947,6 +173040,7 @@ function serialize_inline_component(node, component_name, context) {
           context.state.options.dev ? call("$.add_snippet_symbol", slot_fn) : slot_fn
         )
       );
+      serialized_slots.push(init("default", true_instance));
     } else {
       const slot = prop("init", literal2(slot_name), slot_fn);
       serialized_slots.push(slot);
@@ -173089,8 +173183,19 @@ var template_visitors = {
       inner_context.visit(node2, state);
     }
     if (context.state.options.dev) {
+      const location = locator(node.start);
       context.state.template.push(
-        t_statement(stmt(call("$.push_element", literal2(node.name), id("$$payload"))))
+        t_statement(
+          stmt(
+            call(
+              "$.push_element",
+              id("$$payload"),
+              literal2(node.name),
+              literal2(location.line),
+              literal2(location.column)
+            )
+          )
+        )
       );
     }
     process_children(trimmed, node, inner_context);
@@ -173388,7 +173493,7 @@ var template_visitors = {
     const props = [];
     const spreads = [];
     const lets = [];
-    let expression = member_id("$$props.children");
+    let expression = call("$.default_slot", id("$$props"));
     for (const attribute of node.attributes) {
       if (attribute.type === "SpreadAttribute") {
         spreads.push(context.visit(attribute));
@@ -173434,14 +173539,26 @@ function serialize_element_attributes(node, context) {
   let has_spread = false;
   let class_attribute_idx = -1;
   let style_attribute_idx = -1;
+  let events_to_capture = /* @__PURE__ */ new Set();
   for (const attribute of node.attributes) {
     if (attribute.type === "Attribute") {
-      if (attribute.name === "value" && node.name === "textarea") {
-        if (attribute.value !== true && attribute.value[0].type === "Text" && regex_starts_with_newline.test(attribute.value[0].data)) {
-          attribute.value[0].data = "\n" + attribute.value[0].data;
+      if (attribute.name === "value") {
+        if (node.name === "textarea") {
+          if (attribute.value !== true && attribute.value[0].type === "Text" && regex_starts_with_newline.test(attribute.value[0].data)) {
+            attribute.value[0].data = "\n" + attribute.value[0].data;
+          }
+          content = {
+            escape: true,
+            expression: serialize_attribute_value(attribute.value, context)
+          };
+        } else if (node.name !== "select") {
+          attributes.push(attribute);
+        }
+      } else if (is_event_attribute(attribute)) {
+        if ((attribute.name === "onload" || attribute.name === "onerror") && LoadErrorElements.includes(node.name)) {
+          events_to_capture.add(attribute.name);
         }
-        content = { escape: true, expression: serialize_attribute_value(attribute.value, context) };
-      } else if (!is_event_attribute(attribute)) {
+      } else {
         if (attribute.name === "class") {
           class_attribute_idx = attributes.length;
         } else if (attribute.name === "style") {
@@ -173521,6 +173638,15 @@ function serialize_element_attributes(node, context) {
     } else if (attribute.type === "SpreadAttribute") {
       attributes.push(attribute);
       has_spread = true;
+      if (LoadErrorElements.includes(node.name)) {
+        events_to_capture.add("onload");
+        events_to_capture.add("onerror");
+      }
+    } else if (attribute.type === "UseDirective") {
+      if (LoadErrorElements.includes(node.name)) {
+        events_to_capture.add("onload");
+        events_to_capture.add("onerror");
+      }
     } else if (attribute.type === "ClassDirective") {
       class_directives.push(attribute);
     } else if (attribute.type === "StyleDirective") {
@@ -173589,6 +173715,11 @@ function serialize_element_attributes(node, context) {
       );
     }
   }
+  if (events_to_capture.size !== 0) {
+    for (const event of events_to_capture) {
+      context.state.template.push(t_string(` ${event}="this.__e=event"`));
+    }
+  }
   return content;
 }
 function serialize_class_directives(class_directives, class_attribute) {
@@ -173654,13 +173785,13 @@ function serialize_style_directives(style_directives, style_attribute, context)
   }
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/utils/assert.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/utils/assert.js
 function equal(actual, expected) {
   if (actual !== expected)
     throw new Error("Assertion failed");
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/javascript-runes.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/javascript-runes.js
 var javascript_visitors_runes2 = {
   ClassBody(node, { state, visit: visit24 }) {
     const public_state = /* @__PURE__ */ new Map();
@@ -173792,7 +173923,7 @@ var javascript_visitors_runes2 = {
     for (const declarator2 of node.declarations) {
       const init2 = declarator2.init;
       const rune = get_rune(init2, state.scope);
-      if (!rune || rune === "$effect.active" || rune === "$effect.root" || rune === "$inspect" || rune === "$state.snapshot") {
+      if (!rune || rune === "$effect.active" || rune === "$effect.root" || rune === "$inspect" || rune === "$state.snapshot" || rune === "$state.is") {
         if (init2 != null && is_hoistable_function(init2)) {
           const hoistable_function = visit24(init2);
           state.hoisted.push(
@@ -173960,6 +174091,13 @@ var javascript_visitors_runes2 = {
         context.visit(node.arguments[0])
       );
     }
+    if (rune === "$state.is") {
+      return call(
+        "$.is",
+        context.visit(node.arguments[0]),
+        context.visit(node.arguments[1])
+      );
+    }
     if (rune === "$effect.root") {
       const args = node.arguments.map((arg) => context.visit(arg));
       return call("$.effect_root", ...args);
@@ -173968,6 +174106,28 @@ var javascript_visitors_runes2 = {
       return transform_inspect_rune(node, context);
     }
     context.next();
+  },
+  BinaryExpression(node, { state, visit: visit24, next: next2 }) {
+    const operator = node.operator;
+    if (state.options.dev) {
+      if (operator === "===" || operator === "!==") {
+        return call(
+          "$.strict_equals",
+          visit24(node.left),
+          visit24(node.right),
+          operator === "!==" && literal2(false)
+        );
+      }
+      if (operator === "==" || operator === "!=") {
+        return call(
+          "$.equals",
+          visit24(node.left),
+          visit24(node.right),
+          operator === "!=" && literal2(false)
+        );
+      }
+    }
+    next2();
   }
 };
 function get_name(node) {
@@ -173978,7 +174138,7 @@ function get_name(node) {
   }
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/template.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/template.js
 function get_attribute_name2(element, attribute, context) {
   let name = attribute.name;
   if (!element.metadata.svg && !element.metadata.mathml && context.state.metadata.namespace !== "foreign") {
@@ -174251,6 +174411,10 @@ function serialize_element_attribute_update_assignment(element, node_id, attribu
         value
       )
     );
+  } else if (name === "value") {
+    update2 = stmt(call("$.set_value", node_id, value));
+  } else if (name === "checked") {
+    update2 = stmt(call("$.set_checked", node_id, value));
   } else if (DOMProperties.includes(name)) {
     update2 = stmt(assignment("=", member(node_id, id(name)), value));
   } else {
@@ -174327,6 +174491,9 @@ function serialize_update_assignment(state, id2, init2, value, update2) {
 function collect_parent_each_blocks(context) {
   return context.path.filter((node) => node.type === "EachBlock");
 }
+function create_derived(state, arg) {
+  return call(state.analysis.runes ? "$.derived" : "$.derived_safe_equal", arg);
+}
 function serialize_inline_component2(node, component_name, context) {
   const props_and_spreads = [];
   const lets = [];
@@ -174336,6 +174503,7 @@ function serialize_inline_component2(node, component_name, context) {
   let bind_this = null;
   const binding_initializers = [];
   let slot_scope_applies_to_itself = false;
+  let has_children_prop = false;
   function push_prop(prop2) {
     const current2 = props_and_spreads.at(-1);
     const current_is_props = Array.isArray(current2);
@@ -174378,6 +174546,9 @@ function serialize_inline_component2(node, component_name, context) {
       if (attribute.name === "slot") {
         slot_scope_applies_to_itself = true;
       }
+      if (attribute.name === "children") {
+        has_children_prop = true;
+      }
       const [, value] = serialize_attribute_value2(attribute.value, context);
       if (attribute.metadata.dynamic) {
         let arg = value;
@@ -174386,7 +174557,7 @@ function serialize_inline_component2(node, component_name, context) {
         });
         if (should_wrap_in_derived) {
           const id2 = id(context.state.scope.generate(attribute.name));
-          context.state.init.push(var_builder(id2, call("$.derived", thunk(value))));
+          context.state.init.push(var_builder(id2, create_derived(context.state, thunk(value))));
           arg = call("$.get", id2);
         }
         push_prop(get(attribute.name, [return_builder(arg)]));
@@ -174455,10 +174626,11 @@ function serialize_inline_component2(node, component_name, context) {
       [id("$$anchor"), id("$$slotProps")],
       block3([...slot_name === "default" && !slot_scope_applies_to_itself ? lets : [], ...body])
     );
-    if (slot_name === "default") {
+    if (slot_name === "default" && !has_children_prop) {
       push_prop(
         init("children", context.state.options.dev ? call("$.wrap_snippet", slot_fn) : slot_fn)
       );
+      serialized_slots.push(init(slot_name, true_instance));
     } else {
       serialized_slots.push(init(slot_name, slot_fn));
     }
@@ -174967,8 +175139,8 @@ function serialize_template_literal(values, visit24, state) {
         state.init.push(
           const_builder(
             id2,
-            call(
-              state.analysis.runes ? "$.derived" : "$.derived_safe_equal",
+            create_derived(
+              state,
               thunk(visit24(node.expression))
             )
           )
@@ -175010,8 +175182,8 @@ var template_visitors2 = {
       state.init.push(
         const_builder(
           declaration2.id,
-          call(
-            state.analysis.runes ? "$.derived" : "$.derived_safe_equal",
+          create_derived(
+            state,
             thunk(visit24(declaration2.init))
           )
         )
@@ -175036,9 +175208,7 @@ var template_visitors2 = {
           return_builder(object(identifiers.map((node2) => prop("init", node2, node2))))
         ])
       );
-      state.init.push(
-        const_builder(tmp, call(state.analysis.runes ? "$.derived" : "$.derived_safe_equal", fn))
-      );
+      state.init.push(const_builder(tmp, create_derived(state, fn)));
       if (state.options.dev) {
         state.init.push(stmt(call("$.get", tmp)));
       }
@@ -175174,6 +175344,7 @@ var template_visitors2 = {
     let is_content_editable = false;
     let has_content_editable_binding = false;
     let img_might_be_lazy = false;
+    let might_need_event_replaying = false;
     if (is_custom_element) {
       metadata.context.template_needs_import_node = true;
     }
@@ -175193,6 +175364,9 @@ var template_visitors2 = {
         attributes.push(attribute);
         needs_input_reset = true;
         needs_content_reset = true;
+        if (LoadErrorElements.includes(node.name)) {
+          might_need_event_replaying = true;
+        }
       } else if (attribute.type === "ClassDirective") {
         class_directives.push(attribute);
       } else if (attribute.type === "StyleDirective") {
@@ -175211,6 +175385,8 @@ var template_visitors2 = {
           } else if (attribute.name === "innerHTML" || attribute.name === "innerText" || attribute.name === "textContent") {
             has_content_editable_binding = true;
           }
+        } else if (attribute.type === "UseDirective" && LoadErrorElements.includes(node.name)) {
+          might_need_event_replaying = true;
         }
         context.visit(attribute);
       }
@@ -175224,7 +175400,7 @@ var template_visitors2 = {
     if (is_content_editable && has_content_editable_binding) {
       child_metadata.bound_contenteditable = true;
     }
-    if (needs_input_reset && (node.name === "input" || node.name === "select")) {
+    if (needs_input_reset && node.name === "input") {
       context.state.init.push(stmt(call("$.remove_input_attr_defaults", context.state.node)));
     }
     if (needs_content_reset && node.name === "textarea") {
@@ -175251,6 +175427,9 @@ var template_visitors2 = {
     } else {
       for (const attribute of attributes) {
         if (is_event_attribute(attribute)) {
+          if ((attribute.name === "onload" || attribute.name === "onerror") && LoadErrorElements.includes(node.name)) {
+            might_need_event_replaying = true;
+          }
           serialize_event_attribute(attribute, context);
           continue;
         }
@@ -175278,6 +175457,9 @@ var template_visitors2 = {
     }
     serialize_class_directives2(class_directives, node_id, context, is_attributes_reactive);
     serialize_style_directives2(style_directives, node_id, context, is_attributes_reactive);
+    if (might_need_event_replaying) {
+      context.state.after_update.push(stmt(call("$.replay_events", node_id)));
+    }
     context.state.template.push(">");
     const child_locations = [];
     const state = {
@@ -175950,10 +176132,7 @@ var template_visitors2 = {
       const name = node.expression === null ? node.name : node.expression.name;
       return const_builder(
         name,
-        call(
-          state.analysis.runes ? "$.derived" : "$.derived_safe_equal",
-          thunk(member(id("$$slotProps"), id(node.name)))
-        )
+        create_derived(state, thunk(member(id("$$slotProps"), id(node.name))))
       );
     }
   },
@@ -176018,7 +176197,7 @@ var template_visitors2 = {
       [id("$$anchor")],
       block3(create_block2(node, "fallback", node.fragment.nodes, context))
     );
-    const expression = is_default ? member(id("$$props"), id("children")) : member(member(id("$$props"), id("$$slots")), name, true, true);
+    const expression = is_default ? call("$.default_slot", id("$$props")) : member(member(id("$$props"), id("$$slots")), name, true, true);
     const slot = call("$.slot", context.state.node, expression, props_expression, fallback);
     context.state.init.push(stmt(slot));
   },
@@ -177068,14 +177247,14 @@ function remapping(input, loader, options) {
   return new SourceMap(traceMappings(tree), opts);
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/utils/push_array.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/utils/push_array.js
 function push_array(array2, items) {
   for (let i3 = 0; i3 < items.length; i3++) {
     array2.push(items[i3]);
   }
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/utils/mapped_code.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/utils/mapped_code.js
 function last_line_length(s3) {
   return s3.length - s3.lastIndexOf("\n") - 1;
 }
@@ -177307,9 +177486,10 @@ function get_basename(filename2) {
   return filename2.split(/[/\\]/).pop();
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/validate-options.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/validate-options.js
 var common = {
   filename: string(void 0),
+  rootDir: string(typeof process !== "undefined" ? process.cwd?.() : void 0),
   dev: boolean(false),
   generate: validator("client", (input, keypath) => {
     if (input === "dom" || input === "ssr") {
@@ -177480,7 +177660,7 @@ function throw_error2(msg) {
   options_invalid_value(null, msg);
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/preprocess/decode_sourcemap.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/preprocess/decode_sourcemap.js
 function decoded_sourcemap_from_generator(generator) {
   let previous_generated_line = 1;
   const converted_mappings = [[]];
@@ -177537,7 +177717,7 @@ function decode_map(processed) {
   return decoded_map;
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/preprocess/replace_in_code.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/preprocess/replace_in_code.js
 function slice_source(code_slice, offset2, { file_basename, filename: filename2, get_location }) {
   return {
     source: code_slice,
@@ -177580,7 +177760,7 @@ async function replace_in_code(regex, get_replacement, location) {
   return perform_replacements(replacements2, location);
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/preprocess/index.js
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/preprocess/index.js
 var PreprocessResult = class {
   source;
   filename;
@@ -177763,29 +177943,11 @@ async function preprocess(source, preprocessor, options) {
   return result.to_processed();
 }
 
-// ../../node_modules/.pnpm/svelte@5.0.0-next.133/node_modules/svelte/src/compiler/index.js
-function handle_compile_error(error, filename2, source) {
-  error.filename = filename2;
-  if (error.position) {
-    const start = locator(error.position[0]);
-    const end = locator(error.position[1]);
-    error.start = start;
-    error.end = end;
-  }
-  throw error;
-}
-function parse16(source, options = {}) {
-  reset3({ source, filename: options.filename });
-  let ast;
-  try {
-    ast = parse15(source);
-  } catch (e4) {
-    if (e4 instanceof CompileError) {
-      handle_compile_error(e4, options.filename, source);
-    }
-    throw e4;
-  }
-  return to_public_ast(source, ast, options.modern);
+// ../../node_modules/.pnpm/svelte@5.0.0-next.138/node_modules/svelte/src/compiler/index.js
+function parse16(source, { filename: filename2, rootDir, modern } = {}) {
+  reset3(source, { filename: filename2, rootDir });
+  const ast = parse15(source);
+  return to_public_ast(source, ast, modern);
 }
 function to_public_ast(source, ast, modern) {
   if (modern) {
@@ -177822,6 +177984,7 @@ var svelteRunes = [
   "$state",
   "$state.frozen",
   "$state.snapshot",
+  "$state.is",
   "$props",
   "$bindable",
   "$derived",