Packages
live_svelte
0.16.0
0.18.0
0.18.0-rc0
0.17.4
0.17.3
0.17.2
0.17.1
0.17.0
0.16.0
0.15.0
0.15.0-rc.6
0.15.0-rc.5
0.15.0-rc.4
0.15.0-rc.3
0.15.0-rc.2
0.15.0-rc.1
0.14.1
0.14.0
0.13.3
0.13.3-rc.1
0.13.2
0.13.1
0.13.0
0.12.0
0.11.0
0.10.2
0.10.1
0.10.0
0.9.0
0.9.0-rc2
0.9.0-rc1
0.9.0-rc0
0.8.0
0.7.1
0.7.0
0.6.0
0.5.1
0.5.0
0.5.0-rc0
0.4.2
0.4.2-rc0
0.4.1
0.4.1-rc0
0.4.0
0.3.5
0.3.5-rc1
0.3.5-rc0
0.3.4
0.3.3
0.3.2
0.3.1
0.3.0
0.3.0-rc1
0.3.0-rc0
0.2.0
0.2.0-rc1
0.2.0-rc0
0.1.0
0.1.0-rc5
0.1.0-rc4
0.1.0-rc3
0.1.0-rc2
0.1.0-rc1
0.1.0-rc0
E2E reactivity for Svelte and LiveView
Current section
Files
Jump to
Current section
Files
priv/static/test
(() => {
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __typeError = (msg) => {
throw TypeError(msg);
};
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop2 in b || (b = {}))
if (__hasOwnProp.call(b, prop2))
__defNormalProp(a, prop2, b[prop2]);
if (__getOwnPropSymbols)
for (var prop2 of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop2))
__defNormalProp(a, prop2, b[prop2]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
// js/live_svelte/utils.js
function normalizeComponents(components) {
if (!Array.isArray(components.default) || !Array.isArray(components.filenames)) return components;
const normalized = {};
for (const [index2, module] of components.default.entries()) {
const Component = module.default;
const name = components.filenames[index2].replace("../svelte/", "").replace(".svelte", "");
normalized[name] = Component;
}
return normalized;
}
// node_modules/svelte/src/constants.js
var EACH_INDEX_REACTIVE = 1 << 1;
var EACH_IS_CONTROLLED = 1 << 2;
var EACH_IS_ANIMATED = 1 << 3;
var EACH_ITEM_IMMUTABLE = 1 << 4;
var PROPS_IS_RUNES = 1 << 1;
var PROPS_IS_UPDATED = 1 << 2;
var PROPS_IS_BINDABLE = 1 << 3;
var PROPS_IS_LAZY_INITIAL = 1 << 4;
var TRANSITION_OUT = 1 << 1;
var TRANSITION_GLOBAL = 1 << 2;
var TEMPLATE_USE_IMPORT_NODE = 1 << 1;
var HYDRATION_START = "[";
var HYDRATION_START_ELSE = "[!";
var HYDRATION_END = "]";
var HYDRATION_ERROR = {};
var ELEMENT_PRESERVE_ATTRIBUTE_CASE = 1 << 1;
var UNINITIALIZED = Symbol();
var FILENAME = Symbol("filename");
var HMR = Symbol("hmr");
// node_modules/svelte/src/internal/shared/utils.js
var is_array = Array.isArray;
var array_from = Array.from;
var object_keys = Object.keys;
var define_property = Object.defineProperty;
var get_descriptor = Object.getOwnPropertyDescriptor;
var object_prototype = Object.prototype;
var array_prototype = Array.prototype;
function run_all(arr) {
for (var i = 0; i < arr.length; i++) {
arr[i]();
}
}
// node_modules/esm-env/browser.js
var DEV = false;
// node_modules/svelte/src/internal/client/constants.js
var DERIVED = 1 << 1;
var EFFECT = 1 << 2;
var RENDER_EFFECT = 1 << 3;
var BLOCK_EFFECT = 1 << 4;
var BRANCH_EFFECT = 1 << 5;
var ROOT_EFFECT = 1 << 6;
var UNOWNED = 1 << 7;
var DISCONNECTED = 1 << 8;
var CLEAN = 1 << 9;
var DIRTY = 1 << 10;
var MAYBE_DIRTY = 1 << 11;
var INERT = 1 << 12;
var DESTROYED = 1 << 13;
var EFFECT_RAN = 1 << 14;
var EFFECT_TRANSPARENT = 1 << 15;
var LEGACY_DERIVED_PROP = 1 << 16;
var INSPECT_EFFECT = 1 << 17;
var HEAD_EFFECT = 1 << 18;
var EFFECT_HAS_DERIVED = 1 << 19;
var STATE_SYMBOL = Symbol("$state");
var STATE_SYMBOL_METADATA = Symbol("$state metadata");
var LOADING_ATTR_SYMBOL = Symbol("");
// node_modules/svelte/src/internal/client/reactivity/equality.js
function equals(value) {
return value === this.v;
}
function safe_not_equal(a, b) {
return a != a ? b == b : a !== b || a !== null && typeof a === "object" || typeof a === "function";
}
function safe_equals(value) {
return !safe_not_equal(value, this.v);
}
// node_modules/svelte/src/internal/client/errors.js
function derived_references_self() {
if (DEV) {
const error = new Error(`derived_references_self
A derived value cannot reference itself recursively`);
error.name = "Svelte error";
throw error;
} else {
throw new Error("derived_references_self");
}
}
function effect_update_depth_exceeded() {
if (DEV) {
const error = new Error(`effect_update_depth_exceeded
Maximum update depth exceeded. This can happen when a reactive block or effect repeatedly sets a new value. Svelte limits the number of nested updates to prevent infinite loops`);
error.name = "Svelte error";
throw error;
} else {
throw new Error("effect_update_depth_exceeded");
}
}
function hydration_failed() {
if (DEV) {
const error = new Error(`hydration_failed
Failed to hydrate the application`);
error.name = "Svelte error";
throw error;
} else {
throw new Error("hydration_failed");
}
}
function rune_outside_svelte(rune) {
if (DEV) {
const error = new Error(`rune_outside_svelte
The \`${rune}\` rune is only available inside \`.svelte\` and \`.svelte.js/ts\` files`);
error.name = "Svelte error";
throw error;
} else {
throw new Error("rune_outside_svelte");
}
}
function state_unsafe_local_read() {
if (DEV) {
const error = new Error(`state_unsafe_local_read
Reading state that was created inside the same derived is forbidden. Consider using \`untrack\` to read locally created state`);
error.name = "Svelte error";
throw error;
} else {
throw new Error("state_unsafe_local_read");
}
}
function state_unsafe_mutation() {
if (DEV) {
const error = new Error(`state_unsafe_mutation
Updating state inside a derived or a template expression is forbidden. If the value should not be reactive, declare it without \`$state\``);
error.name = "Svelte error";
throw error;
} else {
throw new Error("state_unsafe_mutation");
}
}
// node_modules/svelte/src/internal/flags/index.js
var legacy_mode_flag = false;
// node_modules/svelte/src/internal/client/reactivity/sources.js
var inspect_effects = /* @__PURE__ */ new Set();
function set_inspect_effects(v) {
inspect_effects = v;
}
function source(v) {
return {
f: 0,
// TODO ideally we could skip this altogether, but it causes type errors
v,
reactions: null,
equals,
version: 0
};
}
// @__NO_SIDE_EFFECTS__
function mutable_source(initial_value, immutable = false) {
var _a, _b;
const s = source(initial_value);
if (!immutable) {
s.equals = safe_equals;
}
if (legacy_mode_flag && component_context !== null && component_context.l !== null) {
((_b = (_a = component_context.l).s) != null ? _b : _a.s = []).push(s);
}
return s;
}
function set(source2, value) {
if (active_reaction !== null && is_runes() && (active_reaction.f & (DERIVED | BLOCK_EFFECT)) !== 0 && // If the source was created locally within the current derived, then
// we allow the mutation.
(derived_sources === null || !derived_sources.includes(source2))) {
state_unsafe_mutation();
}
return internal_set(source2, value);
}
function internal_set(source2, value) {
if (!source2.equals(value)) {
source2.v = value;
source2.version = increment_version();
mark_reactions(source2, DIRTY);
if (is_runes() && active_effect !== null && (active_effect.f & CLEAN) !== 0 && (active_effect.f & BRANCH_EFFECT) === 0) {
if (new_deps !== null && new_deps.includes(source2)) {
set_signal_status(active_effect, DIRTY);
schedule_effect(active_effect);
} else {
if (untracked_writes === null) {
set_untracked_writes([source2]);
} else {
untracked_writes.push(source2);
}
}
}
if (DEV && inspect_effects.size > 0) {
const inspects = Array.from(inspect_effects);
var previously_flushing_effect = is_flushing_effect;
set_is_flushing_effect(true);
try {
for (const effect2 of inspects) {
if ((effect2.f & CLEAN) !== 0) {
set_signal_status(effect2, MAYBE_DIRTY);
}
if (check_dirtiness(effect2)) {
update_effect(effect2);
}
}
} finally {
set_is_flushing_effect(previously_flushing_effect);
}
inspect_effects.clear();
}
}
return value;
}
function mark_reactions(signal, status) {
var reactions = signal.reactions;
if (reactions === null) return;
var runes = is_runes();
var length = reactions.length;
for (var i = 0; i < length; i++) {
var reaction = reactions[i];
var flags = reaction.f;
if ((flags & DIRTY) !== 0) continue;
if (!runes && reaction === active_effect) continue;
if (DEV && (flags & INSPECT_EFFECT) !== 0) {
inspect_effects.add(reaction);
continue;
}
set_signal_status(reaction, status);
if ((flags & (CLEAN | UNOWNED)) !== 0) {
if ((flags & DERIVED) !== 0) {
mark_reactions(
/** @type {Derived} */
reaction,
MAYBE_DIRTY
);
} else {
schedule_effect(
/** @type {Effect} */
reaction
);
}
}
}
}
// node_modules/svelte/src/internal/client/warnings.js
var bold = "font-weight: bold";
var normal = "font-weight: normal";
function hydration_mismatch(location) {
if (DEV) {
console.warn(`%c[svelte] hydration_mismatch
%c${location ? `Hydration failed because the initial UI does not match what was rendered on the server. The error occurred near ${location}` : "Hydration failed because the initial UI does not match what was rendered on the server"}`, bold, normal);
} else {
console.warn("hydration_mismatch");
}
}
function lifecycle_double_unmount() {
if (DEV) {
console.warn(`%c[svelte] lifecycle_double_unmount
%cTried to unmount a component that was not mounted`, bold, normal);
} else {
console.warn("lifecycle_double_unmount");
}
}
function state_proxy_equality_mismatch(operator) {
if (DEV) {
console.warn(`%c[svelte] state_proxy_equality_mismatch
%cReactive \`$state(...)\` proxies and the values they proxy have different identities. Because of this, comparisons with \`${operator}\` will produce unexpected results`, bold, normal);
} else {
console.warn("state_proxy_equality_mismatch");
}
}
// node_modules/svelte/src/internal/client/dom/hydration.js
var hydrating = false;
function set_hydrating(value) {
hydrating = value;
}
var hydrate_node;
function set_hydrate_node(node) {
if (node === null) {
hydration_mismatch();
throw HYDRATION_ERROR;
}
return hydrate_node = node;
}
function hydrate_next() {
return set_hydrate_node(
/** @type {TemplateNode} */
get_next_sibling(hydrate_node)
);
}
// node_modules/svelte/src/internal/client/dev/ownership.js
var ADD_OWNER = Symbol("ADD_OWNER");
// node_modules/svelte/src/internal/client/proxy.js
function get_proxied_value(value) {
if (value !== null && typeof value === "object" && STATE_SYMBOL in value) {
return value[STATE_SYMBOL];
}
return value;
}
// node_modules/svelte/src/internal/client/dev/equality.js
function init_array_prototype_warnings() {
const array_prototype2 = Array.prototype;
const cleanup = Array.__svelte_cleanup;
if (cleanup) {
cleanup();
}
const { indexOf, lastIndexOf, includes } = array_prototype2;
array_prototype2.indexOf = function(item, from_index) {
const index2 = indexOf.call(this, item, from_index);
if (index2 === -1) {
const test = indexOf.call(get_proxied_value(this), get_proxied_value(item), from_index);
if (test !== -1) {
state_proxy_equality_mismatch("array.indexOf(...)");
}
}
return index2;
};
array_prototype2.lastIndexOf = function(item, from_index) {
const index2 = lastIndexOf.call(this, item, from_index != null ? from_index : this.length - 1);
if (index2 === -1) {
const test = lastIndexOf.call(
get_proxied_value(this),
get_proxied_value(item),
from_index != null ? from_index : this.length - 1
);
if (test !== -1) {
state_proxy_equality_mismatch("array.lastIndexOf(...)");
}
}
return index2;
};
array_prototype2.includes = function(item, from_index) {
const has = includes.call(this, item, from_index);
if (!has) {
const test = includes.call(get_proxied_value(this), get_proxied_value(item), from_index);
if (test) {
state_proxy_equality_mismatch("array.includes(...)");
}
}
return has;
};
Array.__svelte_cleanup = () => {
array_prototype2.indexOf = indexOf;
array_prototype2.lastIndexOf = lastIndexOf;
array_prototype2.includes = includes;
};
}
// node_modules/svelte/src/internal/client/dom/operations.js
var $window;
var $document;
var first_child_getter;
var next_sibling_getter;
function init_operations() {
if ($window !== void 0) {
return;
}
$window = window;
$document = document;
var element_prototype = Element.prototype;
var node_prototype = Node.prototype;
first_child_getter = get_descriptor(node_prototype, "firstChild").get;
next_sibling_getter = get_descriptor(node_prototype, "nextSibling").get;
element_prototype.__click = void 0;
element_prototype.__className = "";
element_prototype.__attributes = null;
element_prototype.__styles = null;
element_prototype.__e = void 0;
Text.prototype.__t = void 0;
if (DEV) {
element_prototype.__svelte_meta = null;
init_array_prototype_warnings();
}
}
function create_text(value = "") {
return document.createTextNode(value);
}
// @__NO_SIDE_EFFECTS__
function get_first_child(node) {
return first_child_getter.call(node);
}
// @__NO_SIDE_EFFECTS__
function get_next_sibling(node) {
return next_sibling_getter.call(node);
}
function clear_text_content(node) {
node.textContent = "";
}
// node_modules/svelte/src/internal/client/reactivity/deriveds.js
function destroy_derived_children(derived2) {
var children = derived2.children;
if (children !== null) {
derived2.children = null;
for (var i = 0; i < children.length; i += 1) {
var child2 = children[i];
if ((child2.f & DERIVED) !== 0) {
destroy_derived(
/** @type {Derived} */
child2
);
} else {
destroy_effect(
/** @type {Effect} */
child2
);
}
}
}
}
var stack = [];
function execute_derived(derived2) {
var value;
var prev_active_effect = active_effect;
set_active_effect(derived2.parent);
if (DEV) {
let prev_inspect_effects = inspect_effects;
set_inspect_effects(/* @__PURE__ */ new Set());
try {
if (stack.includes(derived2)) {
derived_references_self();
}
stack.push(derived2);
destroy_derived_children(derived2);
value = update_reaction(derived2);
} finally {
set_active_effect(prev_active_effect);
set_inspect_effects(prev_inspect_effects);
stack.pop();
}
} else {
try {
destroy_derived_children(derived2);
value = update_reaction(derived2);
} finally {
set_active_effect(prev_active_effect);
}
}
return value;
}
function update_derived(derived2) {
var value = execute_derived(derived2);
var status = (skip_reaction || (derived2.f & UNOWNED) !== 0) && derived2.deps !== null ? MAYBE_DIRTY : CLEAN;
set_signal_status(derived2, status);
if (!derived2.equals(value)) {
derived2.v = value;
derived2.version = increment_version();
}
}
function destroy_derived(signal) {
destroy_derived_children(signal);
remove_reactions(signal, 0);
set_signal_status(signal, DESTROYED);
signal.v = signal.children = signal.deps = signal.ctx = signal.reactions = null;
}
// node_modules/svelte/src/internal/client/reactivity/effects.js
function push_effect(effect2, parent_effect) {
var parent_last = parent_effect.last;
if (parent_last === null) {
parent_effect.last = parent_effect.first = effect2;
} else {
parent_last.next = effect2;
effect2.prev = parent_last;
parent_effect.last = effect2;
}
}
function create_effect(type, fn, sync, push3 = true) {
var _a;
var is_root = (type & ROOT_EFFECT) !== 0;
var parent_effect = active_effect;
if (DEV) {
while (parent_effect !== null && (parent_effect.f & INSPECT_EFFECT) !== 0) {
parent_effect = parent_effect.parent;
}
}
var effect2 = {
ctx: component_context,
deps: null,
deriveds: null,
nodes_start: null,
nodes_end: null,
f: type | DIRTY,
first: null,
fn,
last: null,
next: null,
parent: is_root ? null : parent_effect,
prev: null,
teardown: null,
transitions: null,
version: 0
};
if (DEV) {
effect2.component_function = dev_current_component_function;
}
if (sync) {
var previously_flushing_effect = is_flushing_effect;
try {
set_is_flushing_effect(true);
update_effect(effect2);
effect2.f |= EFFECT_RAN;
} catch (e) {
destroy_effect(effect2);
throw e;
} finally {
set_is_flushing_effect(previously_flushing_effect);
}
} else if (fn !== null) {
schedule_effect(effect2);
}
var inert = sync && effect2.deps === null && effect2.first === null && effect2.nodes_start === null && effect2.teardown === null && (effect2.f & EFFECT_HAS_DERIVED) === 0;
if (!inert && !is_root && push3) {
if (parent_effect !== null) {
push_effect(effect2, parent_effect);
}
if (active_reaction !== null && (active_reaction.f & DERIVED) !== 0) {
var derived2 = (
/** @type {Derived} */
active_reaction
);
((_a = derived2.children) != null ? _a : derived2.children = []).push(effect2);
}
}
return effect2;
}
function effect_root(fn) {
const effect2 = create_effect(ROOT_EFFECT, fn, true);
return () => {
destroy_effect(effect2);
};
}
function effect(fn) {
return create_effect(EFFECT, fn, false);
}
function render_effect(fn) {
return create_effect(RENDER_EFFECT, fn, true);
}
function branch(fn, push3 = true) {
return create_effect(RENDER_EFFECT | BRANCH_EFFECT, fn, true, push3);
}
function execute_effect_teardown(effect2) {
var teardown2 = effect2.teardown;
if (teardown2 !== null) {
const previously_destroying_effect = is_destroying_effect;
const previous_reaction = active_reaction;
set_is_destroying_effect(true);
set_active_reaction(null);
try {
teardown2.call(null);
} finally {
set_is_destroying_effect(previously_destroying_effect);
set_active_reaction(previous_reaction);
}
}
}
function destroy_effect_deriveds(signal) {
var deriveds = signal.deriveds;
if (deriveds !== null) {
signal.deriveds = null;
for (var i = 0; i < deriveds.length; i += 1) {
destroy_derived(deriveds[i]);
}
}
}
function destroy_effect_children(signal, remove_dom = false) {
var effect2 = signal.first;
signal.first = signal.last = null;
while (effect2 !== null) {
var next2 = effect2.next;
destroy_effect(effect2, remove_dom);
effect2 = next2;
}
}
function destroy_block_effect_children(signal) {
var effect2 = signal.first;
while (effect2 !== null) {
var next2 = effect2.next;
if ((effect2.f & BRANCH_EFFECT) === 0) {
destroy_effect(effect2);
}
effect2 = next2;
}
}
function destroy_effect(effect2, remove_dom = true) {
var removed = false;
if ((remove_dom || (effect2.f & HEAD_EFFECT) !== 0) && effect2.nodes_start !== null) {
var node = effect2.nodes_start;
var end = effect2.nodes_end;
while (node !== null) {
var next2 = node === end ? null : (
/** @type {TemplateNode} */
get_next_sibling(node)
);
node.remove();
node = next2;
}
removed = true;
}
destroy_effect_children(effect2, remove_dom && !removed);
destroy_effect_deriveds(effect2);
remove_reactions(effect2, 0);
set_signal_status(effect2, DESTROYED);
var transitions = effect2.transitions;
if (transitions !== null) {
for (const transition2 of transitions) {
transition2.stop();
}
}
execute_effect_teardown(effect2);
var parent2 = effect2.parent;
if (parent2 !== null && parent2.first !== null) {
unlink_effect(effect2);
}
if (DEV) {
effect2.component_function = null;
}
effect2.next = effect2.prev = effect2.teardown = effect2.ctx = effect2.deps = effect2.parent = effect2.fn = effect2.nodes_start = effect2.nodes_end = null;
}
function unlink_effect(effect2) {
var parent2 = effect2.parent;
var prev = effect2.prev;
var next2 = effect2.next;
if (prev !== null) prev.next = next2;
if (next2 !== null) next2.prev = prev;
if (parent2 !== null) {
if (parent2.first === effect2) parent2.first = next2;
if (parent2.last === effect2) parent2.last = prev;
}
}
// node_modules/svelte/src/internal/client/dom/task.js
var is_micro_task_queued = false;
var is_idle_task_queued = false;
var current_queued_micro_tasks = [];
var current_queued_idle_tasks = [];
function process_micro_tasks() {
is_micro_task_queued = false;
const tasks = current_queued_micro_tasks.slice();
current_queued_micro_tasks = [];
run_all(tasks);
}
function process_idle_tasks() {
is_idle_task_queued = false;
const tasks = current_queued_idle_tasks.slice();
current_queued_idle_tasks = [];
run_all(tasks);
}
function flush_tasks() {
if (is_micro_task_queued) {
process_micro_tasks();
}
if (is_idle_task_queued) {
process_idle_tasks();
}
}
// node_modules/svelte/src/internal/client/runtime.js
var FLUSH_MICROTASK = 0;
var FLUSH_SYNC = 1;
var handled_errors = /* @__PURE__ */ new WeakSet();
var scheduler_mode = FLUSH_MICROTASK;
var is_micro_task_queued2 = false;
var is_flushing_effect = false;
var is_destroying_effect = false;
function set_is_flushing_effect(value) {
is_flushing_effect = value;
}
function set_is_destroying_effect(value) {
is_destroying_effect = value;
}
var queued_root_effects = [];
var flush_count = 0;
var dev_effect_stack = [];
var active_reaction = null;
function set_active_reaction(reaction) {
active_reaction = reaction;
}
var active_effect = null;
function set_active_effect(effect2) {
active_effect = effect2;
}
var derived_sources = null;
var new_deps = null;
var skipped_deps = 0;
var untracked_writes = null;
function set_untracked_writes(value) {
untracked_writes = value;
}
var current_version = 0;
var skip_reaction = false;
var is_signals_recorded = false;
var captured_signals = /* @__PURE__ */ new Set();
var component_context = null;
var dev_current_component_function = null;
function increment_version() {
return ++current_version;
}
function is_runes() {
return !legacy_mode_flag || component_context !== null && component_context.l === null;
}
function check_dirtiness(reaction) {
var _a, _b, _c, _d;
var flags = reaction.f;
if ((flags & DIRTY) !== 0) {
return true;
}
if ((flags & MAYBE_DIRTY) !== 0) {
var dependencies = reaction.deps;
var is_unowned = (flags & UNOWNED) !== 0;
if (dependencies !== null) {
var i;
if ((flags & DISCONNECTED) !== 0) {
for (i = 0; i < dependencies.length; i++) {
((_b = (_a = dependencies[i]).reactions) != null ? _b : _a.reactions = []).push(reaction);
}
reaction.f ^= DISCONNECTED;
}
for (i = 0; i < dependencies.length; i++) {
var dependency = dependencies[i];
if (check_dirtiness(
/** @type {Derived} */
dependency
)) {
update_derived(
/** @type {Derived} */
dependency
);
}
if (is_unowned && active_effect !== null && !skip_reaction && !((_c = dependency == null ? void 0 : dependency.reactions) == null ? void 0 : _c.includes(reaction))) {
((_d = dependency.reactions) != null ? _d : dependency.reactions = []).push(reaction);
}
if (dependency.version > reaction.version) {
return true;
}
}
}
if (!is_unowned) {
set_signal_status(reaction, CLEAN);
}
}
return false;
}
function handle_error(error, effect2, component_context2) {
var _a, _b;
if (!DEV || handled_errors.has(error) || component_context2 === null) {
throw error;
}
const component_stack = [];
const effect_name = (_a = effect2.fn) == null ? void 0 : _a.name;
if (effect_name) {
component_stack.push(effect_name);
}
let current_context = component_context2;
while (current_context !== null) {
if (DEV) {
var filename = (_b = current_context.function) == null ? void 0 : _b[FILENAME];
if (filename) {
const file = filename.split("/").pop();
component_stack.push(file);
}
}
current_context = current_context.p;
}
const indent = /Firefox/.test(navigator.userAgent) ? " " : " ";
define_property(error, "message", {
value: error.message + `
${component_stack.map((name) => `
${indent}in ${name}`).join("")}
`
});
const stack2 = error.stack;
if (stack2) {
const lines = stack2.split("\n");
const new_lines = [];
for (let i = 0; i < lines.length; i++) {
const line = lines[i];
if (line.includes("svelte/src/internal")) {
continue;
}
new_lines.push(line);
}
define_property(error, "stack", {
value: error.stack + new_lines.join("\n")
});
}
handled_errors.add(error);
throw error;
}
function update_reaction(reaction) {
var _a, _b;
var previous_deps = new_deps;
var previous_skipped_deps = skipped_deps;
var previous_untracked_writes = untracked_writes;
var previous_reaction = active_reaction;
var previous_skip_reaction = skip_reaction;
var prev_derived_sources = derived_sources;
var previous_component_context = component_context;
var flags = reaction.f;
new_deps = /** @type {null | Value[]} */
null;
skipped_deps = 0;
untracked_writes = null;
active_reaction = (flags & (BRANCH_EFFECT | ROOT_EFFECT)) === 0 ? reaction : null;
skip_reaction = !is_flushing_effect && (flags & UNOWNED) !== 0;
derived_sources = null;
component_context = reaction.ctx;
try {
var result = (
/** @type {Function} */
(0, reaction.fn)()
);
var deps = reaction.deps;
if (new_deps !== null) {
var i;
remove_reactions(reaction, skipped_deps);
if (deps !== null && skipped_deps > 0) {
deps.length = skipped_deps + new_deps.length;
for (i = 0; i < new_deps.length; i++) {
deps[skipped_deps + i] = new_deps[i];
}
} else {
reaction.deps = deps = new_deps;
}
if (!skip_reaction) {
for (i = skipped_deps; i < deps.length; i++) {
((_b = (_a = deps[i]).reactions) != null ? _b : _a.reactions = []).push(reaction);
}
}
} else if (deps !== null && skipped_deps < deps.length) {
remove_reactions(reaction, skipped_deps);
deps.length = skipped_deps;
}
return result;
} finally {
new_deps = previous_deps;
skipped_deps = previous_skipped_deps;
untracked_writes = previous_untracked_writes;
active_reaction = previous_reaction;
skip_reaction = previous_skip_reaction;
derived_sources = prev_derived_sources;
component_context = previous_component_context;
}
}
function remove_reaction(signal, dependency) {
let reactions = dependency.reactions;
if (reactions !== null) {
var index2 = reactions.indexOf(signal);
if (index2 !== -1) {
var new_length = reactions.length - 1;
if (new_length === 0) {
reactions = dependency.reactions = null;
} else {
reactions[index2] = reactions[new_length];
reactions.pop();
}
}
}
if (reactions === null && (dependency.f & DERIVED) !== 0 && // Destroying a child effect while updating a parent effect can cause a dependency to appear
// to be unused, when in fact it is used by the currently-updating parent. Checking `new_deps`
// allows us to skip the expensive work of disconnecting and immediately reconnecting it
(new_deps === null || !new_deps.includes(dependency))) {
set_signal_status(dependency, MAYBE_DIRTY);
if ((dependency.f & (UNOWNED | DISCONNECTED)) === 0) {
dependency.f ^= DISCONNECTED;
}
remove_reactions(
/** @type {Derived} **/
dependency,
0
);
}
}
function remove_reactions(signal, start_index) {
var dependencies = signal.deps;
if (dependencies === null) return;
for (var i = start_index; i < dependencies.length; i++) {
remove_reaction(signal, dependencies[i]);
}
}
function update_effect(effect2) {
var flags = effect2.f;
if ((flags & DESTROYED) !== 0) {
return;
}
set_signal_status(effect2, CLEAN);
var previous_effect = active_effect;
var previous_component_context = component_context;
active_effect = effect2;
if (DEV) {
var previous_component_fn = dev_current_component_function;
dev_current_component_function = effect2.component_function;
}
try {
if ((flags & BLOCK_EFFECT) !== 0) {
destroy_block_effect_children(effect2);
} else {
destroy_effect_children(effect2);
}
destroy_effect_deriveds(effect2);
execute_effect_teardown(effect2);
var teardown2 = update_reaction(effect2);
effect2.teardown = typeof teardown2 === "function" ? teardown2 : null;
effect2.version = current_version;
if (DEV) {
dev_effect_stack.push(effect2);
}
} catch (error) {
handle_error(
/** @type {Error} */
error,
effect2,
previous_component_context
);
} finally {
active_effect = previous_effect;
if (DEV) {
dev_current_component_function = previous_component_fn;
}
}
}
function infinite_loop_guard() {
if (flush_count > 1e3) {
flush_count = 0;
if (DEV) {
try {
effect_update_depth_exceeded();
} catch (error) {
define_property(error, "stack", {
value: ""
});
console.error(
"Last ten effects were: ",
dev_effect_stack.slice(-10).map((d) => d.fn)
);
dev_effect_stack = [];
throw error;
}
} else {
effect_update_depth_exceeded();
}
}
flush_count++;
}
function flush_queued_root_effects(root_effects) {
var length = root_effects.length;
if (length === 0) {
return;
}
infinite_loop_guard();
var previously_flushing_effect = is_flushing_effect;
is_flushing_effect = true;
try {
for (var i = 0; i < length; i++) {
var effect2 = root_effects[i];
if ((effect2.f & CLEAN) === 0) {
effect2.f ^= CLEAN;
}
var collected_effects = [];
process_effects(effect2, collected_effects);
flush_queued_effects(collected_effects);
}
} finally {
is_flushing_effect = previously_flushing_effect;
}
}
function flush_queued_effects(effects) {
var length = effects.length;
if (length === 0) return;
for (var i = 0; i < length; i++) {
var effect2 = effects[i];
if ((effect2.f & (DESTROYED | INERT)) === 0 && check_dirtiness(effect2)) {
update_effect(effect2);
if (effect2.deps === null && effect2.first === null && effect2.nodes_start === null) {
if (effect2.teardown === null) {
unlink_effect(effect2);
} else {
effect2.fn = null;
}
}
}
}
}
function process_deferred() {
is_micro_task_queued2 = false;
if (flush_count > 1001) {
return;
}
const previous_queued_root_effects = queued_root_effects;
queued_root_effects = [];
flush_queued_root_effects(previous_queued_root_effects);
if (!is_micro_task_queued2) {
flush_count = 0;
if (DEV) {
dev_effect_stack = [];
}
}
}
function schedule_effect(signal) {
if (scheduler_mode === FLUSH_MICROTASK) {
if (!is_micro_task_queued2) {
is_micro_task_queued2 = true;
queueMicrotask(process_deferred);
}
}
var effect2 = signal;
while (effect2.parent !== null) {
effect2 = effect2.parent;
var flags = effect2.f;
if ((flags & (ROOT_EFFECT | BRANCH_EFFECT)) !== 0) {
if ((flags & CLEAN) === 0) return;
effect2.f ^= CLEAN;
}
}
queued_root_effects.push(effect2);
}
function process_effects(effect2, collected_effects) {
var current_effect = effect2.first;
var effects = [];
main_loop: while (current_effect !== null) {
var flags = current_effect.f;
var is_branch = (flags & BRANCH_EFFECT) !== 0;
var is_skippable_branch = is_branch && (flags & CLEAN) !== 0;
if (!is_skippable_branch && (flags & INERT) === 0) {
if ((flags & RENDER_EFFECT) !== 0) {
if (is_branch) {
current_effect.f ^= CLEAN;
} else if (check_dirtiness(current_effect)) {
update_effect(current_effect);
}
var child2 = current_effect.first;
if (child2 !== null) {
current_effect = child2;
continue;
}
} else if ((flags & EFFECT) !== 0) {
effects.push(current_effect);
}
}
var sibling2 = current_effect.next;
if (sibling2 === null) {
let parent2 = current_effect.parent;
while (parent2 !== null) {
if (effect2 === parent2) {
break main_loop;
}
var parent_sibling = parent2.next;
if (parent_sibling !== null) {
current_effect = parent_sibling;
continue main_loop;
}
parent2 = parent2.parent;
}
}
current_effect = sibling2;
}
for (var i = 0; i < effects.length; i++) {
child2 = effects[i];
collected_effects.push(child2);
process_effects(child2, collected_effects);
}
}
function flush_sync(fn) {
var previous_scheduler_mode = scheduler_mode;
var previous_queued_root_effects = queued_root_effects;
try {
infinite_loop_guard();
const root_effects = [];
scheduler_mode = FLUSH_SYNC;
queued_root_effects = root_effects;
is_micro_task_queued2 = false;
flush_queued_root_effects(previous_queued_root_effects);
var result = fn == null ? void 0 : fn();
flush_tasks();
if (queued_root_effects.length > 0 || root_effects.length > 0) {
flush_sync();
}
flush_count = 0;
if (DEV) {
dev_effect_stack = [];
}
return result;
} finally {
scheduler_mode = previous_scheduler_mode;
queued_root_effects = previous_queued_root_effects;
}
}
function get(signal) {
var _a, _b;
var flags = signal.f;
var is_derived = (flags & DERIVED) !== 0;
if (is_derived && (flags & DESTROYED) !== 0) {
var value = execute_derived(
/** @type {Derived} */
signal
);
destroy_derived(
/** @type {Derived} */
signal
);
return value;
}
if (is_signals_recorded) {
captured_signals.add(signal);
}
if (active_reaction !== null) {
if (derived_sources !== null && derived_sources.includes(signal)) {
state_unsafe_local_read();
}
var deps = active_reaction.deps;
if (new_deps === null && deps !== null && deps[skipped_deps] === signal) {
skipped_deps++;
} else if (new_deps === null) {
new_deps = [signal];
} else {
new_deps.push(signal);
}
if (untracked_writes !== null && active_effect !== null && (active_effect.f & CLEAN) !== 0 && (active_effect.f & BRANCH_EFFECT) === 0 && untracked_writes.includes(signal)) {
set_signal_status(active_effect, DIRTY);
schedule_effect(active_effect);
}
} else if (is_derived && /** @type {Derived} */
signal.deps === null) {
var derived2 = (
/** @type {Derived} */
signal
);
var parent2 = derived2.parent;
if (parent2 !== null && !((_a = parent2.deriveds) == null ? void 0 : _a.includes(derived2))) {
((_b = parent2.deriveds) != null ? _b : parent2.deriveds = []).push(derived2);
}
}
if (is_derived) {
derived2 = /** @type {Derived} */
signal;
if (check_dirtiness(derived2)) {
update_derived(derived2);
}
}
return signal.v;
}
var STATUS_MASK = ~(DIRTY | MAYBE_DIRTY | CLEAN);
function set_signal_status(signal, status) {
signal.f = signal.f & STATUS_MASK | status;
}
function push(props, runes = false, fn) {
component_context = {
p: component_context,
c: null,
e: null,
m: false,
s: props,
x: null,
l: null
};
if (legacy_mode_flag && !runes) {
component_context.l = {
s: null,
u: null,
r1: [],
r2: source(false)
};
}
if (DEV) {
component_context.function = fn;
dev_current_component_function = fn;
}
}
function pop(component2) {
var _a, _b;
const context_stack_item = component_context;
if (context_stack_item !== null) {
if (component2 !== void 0) {
context_stack_item.x = component2;
}
const component_effects = context_stack_item.e;
if (component_effects !== null) {
var previous_effect = active_effect;
var previous_reaction = active_reaction;
context_stack_item.e = null;
try {
for (var i = 0; i < component_effects.length; i++) {
var component_effect = component_effects[i];
set_active_effect(component_effect.effect);
set_active_reaction(component_effect.reaction);
effect(component_effect.fn);
}
} finally {
set_active_effect(previous_effect);
set_active_reaction(previous_reaction);
}
}
component_context = context_stack_item.p;
if (DEV) {
dev_current_component_function = (_b = (_a = context_stack_item.p) == null ? void 0 : _a.function) != null ? _b : null;
}
context_stack_item.m = true;
}
return component2 || /** @type {T} */
{};
}
if (DEV) {
let throw_rune_error = function(rune) {
if (!(rune in globalThis)) {
let value;
Object.defineProperty(globalThis, rune, {
configurable: true,
// eslint-disable-next-line getter-return
get: () => {
if (value !== void 0) {
return value;
}
rune_outside_svelte(rune);
},
set: (v) => {
value = v;
}
});
}
};
throw_rune_error("$state");
throw_rune_error("$effect");
throw_rune_error("$derived");
throw_rune_error("$inspect");
throw_rune_error("$props");
throw_rune_error("$bindable");
}
// node_modules/svelte/src/internal/client/dom/elements/events.js
var all_registered_events = /* @__PURE__ */ new Set();
var root_event_handles = /* @__PURE__ */ new Set();
function handle_event_propagation(event2) {
var _a;
var handler_element = this;
var owner_document = (
/** @type {Node} */
handler_element.ownerDocument
);
var event_name = event2.type;
var path = ((_a = event2.composedPath) == null ? void 0 : _a.call(event2)) || [];
var current_target = (
/** @type {null | Element} */
path[0] || event2.target
);
var path_idx = 0;
var handled_at = event2.__root;
if (handled_at) {
var at_idx = path.indexOf(handled_at);
if (at_idx !== -1 && (handler_element === document || handler_element === /** @type {any} */
window)) {
event2.__root = handler_element;
return;
}
var handler_idx = path.indexOf(handler_element);
if (handler_idx === -1) {
return;
}
if (at_idx <= handler_idx) {
path_idx = at_idx;
}
}
current_target = /** @type {Element} */
path[path_idx] || event2.target;
if (current_target === handler_element) return;
define_property(event2, "currentTarget", {
configurable: true,
get() {
return current_target || owner_document;
}
});
var previous_reaction = active_reaction;
var previous_effect = active_effect;
set_active_reaction(null);
set_active_effect(null);
try {
var throw_error;
var other_errors = [];
while (current_target !== null) {
var parent_element = current_target.assignedSlot || current_target.parentNode || /** @type {any} */
current_target.host || null;
try {
var delegated = current_target["__" + event_name];
if (delegated !== void 0 && !/** @type {any} */
current_target.disabled) {
if (is_array(delegated)) {
var [fn, ...data] = delegated;
fn.apply(current_target, [event2, ...data]);
} else {
delegated.call(current_target, event2);
}
}
} catch (error) {
if (throw_error) {
other_errors.push(error);
} else {
throw_error = error;
}
}
if (event2.cancelBubble || parent_element === handler_element || parent_element === null) {
break;
}
current_target = parent_element;
}
if (throw_error) {
for (let error of other_errors) {
queueMicrotask(() => {
throw error;
});
}
throw throw_error;
}
} finally {
event2.__root = handler_element;
delete event2.currentTarget;
set_active_reaction(previous_reaction);
set_active_effect(previous_effect);
}
}
// node_modules/svelte/src/internal/client/dom/blocks/svelte-head.js
var head_anchor;
function reset_head_anchor() {
head_anchor = void 0;
}
// node_modules/svelte/src/internal/client/dom/template.js
function assign_nodes(start, end) {
var effect2 = (
/** @type {Effect} */
active_effect
);
if (effect2.nodes_start === null) {
effect2.nodes_start = start;
effect2.nodes_end = end;
}
}
function append(anchor, dom) {
if (hydrating) {
active_effect.nodes_end = hydrate_node;
hydrate_next();
return;
}
if (anchor === null) {
return;
}
anchor.before(
/** @type {Node} */
dom
);
}
// node_modules/svelte/src/utils.js
var DOM_BOOLEAN_ATTRIBUTES = [
"allowfullscreen",
"async",
"autofocus",
"autoplay",
"checked",
"controls",
"default",
"disabled",
"formnovalidate",
"hidden",
"indeterminate",
"ismap",
"loop",
"multiple",
"muted",
"nomodule",
"novalidate",
"open",
"playsinline",
"readonly",
"required",
"reversed",
"seamless",
"selected",
"webkitdirectory"
];
var DOM_PROPERTIES = [
...DOM_BOOLEAN_ATTRIBUTES,
"formNoValidate",
"isMap",
"noModule",
"playsInline",
"readOnly",
"value",
"inert",
"volume"
];
var PASSIVE_EVENTS = ["touchstart", "touchmove"];
function is_passive_event(name) {
return PASSIVE_EVENTS.includes(name);
}
// node_modules/svelte/src/internal/client/render.js
var should_intro = true;
function mount(component2, options) {
return _mount(component2, options);
}
function hydrate(component2, options) {
var _a;
init_operations();
options.intro = (_a = options.intro) != null ? _a : false;
const target = options.target;
const was_hydrating = hydrating;
const previous_hydrate_node = hydrate_node;
try {
var anchor = (
/** @type {TemplateNode} */
get_first_child(target)
);
while (anchor && (anchor.nodeType !== 8 || /** @type {Comment} */
anchor.data !== HYDRATION_START)) {
anchor = /** @type {TemplateNode} */
get_next_sibling(anchor);
}
if (!anchor) {
throw HYDRATION_ERROR;
}
set_hydrating(true);
set_hydrate_node(
/** @type {Comment} */
anchor
);
hydrate_next();
const instance = _mount(component2, __spreadProps(__spreadValues({}, options), { anchor }));
if (hydrate_node === null || hydrate_node.nodeType !== 8 || /** @type {Comment} */
hydrate_node.data !== HYDRATION_END) {
hydration_mismatch();
throw HYDRATION_ERROR;
}
set_hydrating(false);
return (
/** @type {Exports} */
instance
);
} catch (error) {
if (error === HYDRATION_ERROR) {
if (options.recover === false) {
hydration_failed();
}
init_operations();
clear_text_content(target);
set_hydrating(false);
return mount(component2, options);
}
throw error;
} finally {
set_hydrating(was_hydrating);
set_hydrate_node(previous_hydrate_node);
reset_head_anchor();
}
}
var document_listeners = /* @__PURE__ */ new Map();
function _mount(Component, { target, anchor, props = {}, events, context, intro = true }) {
init_operations();
var registered_events = /* @__PURE__ */ new Set();
var event_handle = (events2) => {
for (var i = 0; i < events2.length; i++) {
var event_name = events2[i];
if (registered_events.has(event_name)) continue;
registered_events.add(event_name);
var passive2 = is_passive_event(event_name);
target.addEventListener(event_name, handle_event_propagation, { passive: passive2 });
var n = document_listeners.get(event_name);
if (n === void 0) {
document.addEventListener(event_name, handle_event_propagation, { passive: passive2 });
document_listeners.set(event_name, 1);
} else {
document_listeners.set(event_name, n + 1);
}
}
};
event_handle(array_from(all_registered_events));
root_event_handles.add(event_handle);
var component2 = void 0;
var unmount2 = effect_root(() => {
var anchor_node = anchor != null ? anchor : target.appendChild(create_text());
branch(() => {
if (context) {
push({});
var ctx = (
/** @type {ComponentContext} */
component_context
);
ctx.c = context;
}
if (events) {
props.$$events = events;
}
if (hydrating) {
assign_nodes(
/** @type {TemplateNode} */
anchor_node,
null
);
}
should_intro = intro;
component2 = Component(anchor_node, props) || {};
should_intro = true;
if (hydrating) {
active_effect.nodes_end = hydrate_node;
}
if (context) {
pop();
}
});
return () => {
var _a;
for (var event_name of registered_events) {
target.removeEventListener(event_name, handle_event_propagation);
var n = (
/** @type {number} */
document_listeners.get(event_name)
);
if (--n === 0) {
document.removeEventListener(event_name, handle_event_propagation);
document_listeners.delete(event_name);
} else {
document_listeners.set(event_name, n);
}
}
root_event_handles.delete(event_handle);
mounted_components.delete(component2);
if (anchor_node !== anchor) {
(_a = anchor_node.parentNode) == null ? void 0 : _a.removeChild(anchor_node);
}
};
});
mounted_components.set(component2, unmount2);
return component2;
}
var mounted_components = /* @__PURE__ */ new WeakMap();
function unmount(component2) {
const fn = mounted_components.get(component2);
if (fn) {
fn();
} else if (DEV) {
lifecycle_double_unmount();
}
}
// node_modules/svelte/src/legacy/legacy-client.js
function createClassComponent(options) {
return new Svelte4Component(options);
}
var _events, _instance;
var Svelte4Component = class {
/**
* @param {ComponentConstructorOptions & {
* component: any;
* }} options
*/
constructor(options) {
/** @type {any} */
__privateAdd(this, _events);
/** @type {Record<string, any>} */
__privateAdd(this, _instance);
var _a, _b;
var sources = /* @__PURE__ */ new Map();
var add_source = (key, value) => {
var s = mutable_source(value);
sources.set(key, s);
return s;
};
const props = new Proxy(
__spreadProps(__spreadValues({}, options.props || {}), { $$events: {} }),
{
get(target, prop2) {
var _a2;
return get((_a2 = sources.get(prop2)) != null ? _a2 : add_source(prop2, Reflect.get(target, prop2)));
},
has(target, prop2) {
var _a2;
get((_a2 = sources.get(prop2)) != null ? _a2 : add_source(prop2, Reflect.get(target, prop2)));
return Reflect.has(target, prop2);
},
set(target, prop2, value) {
var _a2;
set((_a2 = sources.get(prop2)) != null ? _a2 : add_source(prop2, value), value);
return Reflect.set(target, prop2, value);
}
}
);
__privateSet(this, _instance, (options.hydrate ? hydrate : mount)(options.component, {
target: options.target,
anchor: options.anchor,
props,
context: options.context,
intro: (_a = options.intro) != null ? _a : false,
recover: options.recover
}));
if (!((_b = options == null ? void 0 : options.props) == null ? void 0 : _b.$$host) || options.sync === false) {
flush_sync();
}
__privateSet(this, _events, props.$$events);
for (const key of Object.keys(__privateGet(this, _instance))) {
if (key === "$set" || key === "$destroy" || key === "$on") continue;
define_property(this, key, {
get() {
return __privateGet(this, _instance)[key];
},
/** @param {any} value */
set(value) {
__privateGet(this, _instance)[key] = value;
},
enumerable: true
});
}
__privateGet(this, _instance).$set = /** @param {Record<string, any>} next */
(next2) => {
Object.assign(props, next2);
};
__privateGet(this, _instance).$destroy = () => {
unmount(__privateGet(this, _instance));
};
}
/** @param {Record<string, any>} props */
$set(props) {
__privateGet(this, _instance).$set(props);
}
/**
* @param {string} event
* @param {(...args: any[]) => any} callback
* @returns {any}
*/
$on(event2, callback) {
__privateGet(this, _events)[event2] = __privateGet(this, _events)[event2] || [];
const cb = (...args) => callback.call(this, ...args);
__privateGet(this, _events)[event2].push(cb);
return () => {
__privateGet(this, _events)[event2] = __privateGet(this, _events)[event2].filter(
/** @param {any} fn */
(fn) => fn !== cb
);
};
}
$destroy() {
__privateGet(this, _instance).$destroy();
}
};
_events = new WeakMap();
_instance = new WeakMap();
// node_modules/svelte/src/internal/client/dom/elements/custom-element.js
var SvelteElement;
if (typeof HTMLElement === "function") {
SvelteElement = class extends HTMLElement {
/**
* @param {*} $$componentCtor
* @param {*} $$slots
* @param {*} use_shadow_dom
*/
constructor($$componentCtor, $$slots, use_shadow_dom) {
super();
/** The Svelte component constructor */
__publicField(this, "$$ctor");
/** Slots */
__publicField(this, "$$s");
/** @type {any} The Svelte component instance */
__publicField(this, "$$c");
/** Whether or not the custom element is connected */
__publicField(this, "$$cn", false);
/** @type {Record<string, any>} Component props data */
__publicField(this, "$$d", {});
/** `true` if currently in the process of reflecting component props back to attributes */
__publicField(this, "$$r", false);
/** @type {Record<string, CustomElementPropDefinition>} Props definition (name, reflected, type etc) */
__publicField(this, "$$p_d", {});
/** @type {Record<string, EventListenerOrEventListenerObject[]>} Event listeners */
__publicField(this, "$$l", {});
/** @type {Map<EventListenerOrEventListenerObject, Function>} Event listener unsubscribe functions */
__publicField(this, "$$l_u", /* @__PURE__ */ new Map());
/** @type {any} The managed render effect for reflecting attributes */
__publicField(this, "$$me");
this.$$ctor = $$componentCtor;
this.$$s = $$slots;
if (use_shadow_dom) {
this.attachShadow({ mode: "open" });
}
}
/**
* @param {string} type
* @param {EventListenerOrEventListenerObject} listener
* @param {boolean | AddEventListenerOptions} [options]
*/
addEventListener(type, listener, options) {
this.$$l[type] = this.$$l[type] || [];
this.$$l[type].push(listener);
if (this.$$c) {
const unsub = this.$$c.$on(type, listener);
this.$$l_u.set(listener, unsub);
}
super.addEventListener(type, listener, options);
}
/**
* @param {string} type
* @param {EventListenerOrEventListenerObject} listener
* @param {boolean | AddEventListenerOptions} [options]
*/
removeEventListener(type, listener, options) {
super.removeEventListener(type, listener, options);
if (this.$$c) {
const unsub = this.$$l_u.get(listener);
if (unsub) {
unsub();
this.$$l_u.delete(listener);
}
}
}
async connectedCallback() {
this.$$cn = true;
if (!this.$$c) {
let create_slot = function(name) {
return (anchor) => {
const slot2 = document.createElement("slot");
if (name !== "default") slot2.name = name;
append(anchor, slot2);
};
};
await Promise.resolve();
if (!this.$$cn || this.$$c) {
return;
}
const $$slots = {};
const existing_slots = get_custom_elements_slots(this);
for (const name of this.$$s) {
if (name in existing_slots) {
if (name === "default" && !this.$$d.children) {
this.$$d.children = create_slot(name);
$$slots.default = true;
} else {
$$slots[name] = create_slot(name);
}
}
}
for (const attribute of this.attributes) {
const name = this.$$g_p(attribute.name);
if (!(name in this.$$d)) {
this.$$d[name] = get_custom_element_value(name, attribute.value, this.$$p_d, "toProp");
}
}
for (const key in this.$$p_d) {
if (!(key in this.$$d) && this[key] !== void 0) {
this.$$d[key] = this[key];
delete this[key];
}
}
this.$$c = createClassComponent({
component: this.$$ctor,
target: this.shadowRoot || this,
props: __spreadProps(__spreadValues({}, this.$$d), {
$$slots,
$$host: this
})
});
this.$$me = effect_root(() => {
render_effect(() => {
var _a;
this.$$r = true;
for (const key of object_keys(this.$$c)) {
if (!((_a = this.$$p_d[key]) == null ? void 0 : _a.reflect)) continue;
this.$$d[key] = this.$$c[key];
const attribute_value = get_custom_element_value(
key,
this.$$d[key],
this.$$p_d,
"toAttribute"
);
if (attribute_value == null) {
this.removeAttribute(this.$$p_d[key].attribute || key);
} else {
this.setAttribute(this.$$p_d[key].attribute || key, attribute_value);
}
}
this.$$r = false;
});
});
for (const type in this.$$l) {
for (const listener of this.$$l[type]) {
const unsub = this.$$c.$on(type, listener);
this.$$l_u.set(listener, unsub);
}
}
this.$$l = {};
}
}
// We don't need this when working within Svelte code, but for compatibility of people using this outside of Svelte
// and setting attributes through setAttribute etc, this is helpful
/**
* @param {string} attr
* @param {string} _oldValue
* @param {string} newValue
*/
attributeChangedCallback(attr, _oldValue, newValue) {
var _a;
if (this.$$r) return;
attr = this.$$g_p(attr);
this.$$d[attr] = get_custom_element_value(attr, newValue, this.$$p_d, "toProp");
(_a = this.$$c) == null ? void 0 : _a.$set({ [attr]: this.$$d[attr] });
}
disconnectedCallback() {
this.$$cn = false;
Promise.resolve().then(() => {
if (!this.$$cn && this.$$c) {
this.$$c.$destroy();
this.$$me();
this.$$c = void 0;
}
});
}
/**
* @param {string} attribute_name
*/
$$g_p(attribute_name) {
return object_keys(this.$$p_d).find(
(key) => this.$$p_d[key].attribute === attribute_name || !this.$$p_d[key].attribute && key.toLowerCase() === attribute_name
) || attribute_name;
}
};
}
function get_custom_element_value(prop2, value, props_definition, transform) {
var _a;
const type = (_a = props_definition[prop2]) == null ? void 0 : _a.type;
value = type === "Boolean" && typeof value !== "boolean" ? value != null : value;
if (!transform || !props_definition[prop2]) {
return value;
} else if (transform === "toAttribute") {
switch (type) {
case "Object":
case "Array":
return value == null ? null : JSON.stringify(value);
case "Boolean":
return value ? "" : null;
case "Number":
return value == null ? null : value;
default:
return value;
}
} else {
switch (type) {
case "Object":
case "Array":
return value && JSON.parse(value);
case "Boolean":
return value;
// conversion already handled above
case "Number":
return value != null ? +value : value;
default:
return value;
}
}
}
function get_custom_elements_slots(element2) {
const result = {};
element2.childNodes.forEach((node) => {
result[
/** @type {Element} node */
node.slot || "default"
] = true;
});
return result;
}
// node_modules/svelte/src/internal/server/context.js
var current_component = null;
function push2(fn) {
current_component = { p: current_component, c: null, d: null };
if (DEV) {
current_component.function = fn;
}
}
function pop2() {
var component2 = (
/** @type {Component} */
current_component
);
var ondestroy = component2.d;
if (ondestroy) {
on_destroy.push(...ondestroy);
}
current_component = component2.p;
}
// node_modules/svelte/src/internal/server/hydration.js
var BLOCK_OPEN = `<!--${HYDRATION_START}-->`;
var BLOCK_OPEN_ELSE = `<!--${HYDRATION_START_ELSE}-->`;
var BLOCK_CLOSE = `<!--${HYDRATION_END}-->`;
// node_modules/svelte/src/html-tree-validation.js
var autoclosing_children = {
// based on http://developers.whatwg.org/syntax.html#syntax-tag-omission
li: { direct: ["li"] },
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dt#technical_summary
dt: { descendant: ["dt", "dd"], reset_by: ["dl"] },
dd: { descendant: ["dt", "dd"], reset_by: ["dl"] },
p: {
descendant: [
"address",
"article",
"aside",
"blockquote",
"div",
"dl",
"fieldset",
"footer",
"form",
"h1",
"h2",
"h3",
"h4",
"h5",
"h6",
"header",
"hgroup",
"hr",
"main",
"menu",
"nav",
"ol",
"p",
"pre",
"section",
"table",
"ul"
]
},
rt: { descendant: ["rt", "rp"] },
rp: { descendant: ["rt", "rp"] },
optgroup: { descendant: ["optgroup"] },
option: { descendant: ["option", "optgroup"] },
thead: { direct: ["tbody", "tfoot"] },
tbody: { direct: ["tbody", "tfoot"] },
tfoot: { direct: ["tbody"] },
tr: { direct: ["tr", "tbody"] },
td: { direct: ["td", "th", "tr"] },
th: { direct: ["td", "th", "tr"] }
};
var disallowed_children = __spreadProps(__spreadValues({}, autoclosing_children), {
optgroup: { only: ["option", "#text"] },
// Strictly speaking, seeing an <option> doesn't mean we're in a <select>, but we assume it here
option: { only: ["#text"] },
form: { descendant: ["form"] },
a: { descendant: ["a"] },
button: { descendant: ["button"] },
h1: { descendant: ["h1", "h2", "h3", "h4", "h5", "h6"] },
h2: { descendant: ["h1", "h2", "h3", "h4", "h5", "h6"] },
h3: { descendant: ["h1", "h2", "h3", "h4", "h5", "h6"] },
h4: { descendant: ["h1", "h2", "h3", "h4", "h5", "h6"] },
h5: { descendant: ["h1", "h2", "h3", "h4", "h5", "h6"] },
h6: { descendant: ["h1", "h2", "h3", "h4", "h5", "h6"] },
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inselect
select: { only: ["option", "optgroup", "#text", "hr", "script", "template"] },
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption
// No special behavior since these rules fall back to "in body" mode for
// all except special table nodes which cause bad parsing behavior anyway.
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd
tr: { only: ["th", "td", "style", "script", "template"] },
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intbody
tbody: { only: ["tr", "style", "script", "template"] },
thead: { only: ["tr", "style", "script", "template"] },
tfoot: { only: ["tr", "style", "script", "template"] },
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incolgroup
colgroup: { only: ["col", "template"] },
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intable
table: {
only: ["caption", "colgroup", "tbody", "thead", "tfoot", "style", "script", "template"]
},
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inhead
head: {
only: [
"base",
"basefont",
"bgsound",
"link",
"meta",
"title",
"noscript",
"noframes",
"style",
"script",
"template"
]
},
// https://html.spec.whatwg.org/multipage/semantics.html#the-html-element
html: { only: ["head", "body", "frameset"] },
frameset: { only: ["frame"] },
"#document": { only: ["html"] }
});
// node_modules/svelte/src/internal/server/dev.js
var parent = null;
function reset_elements() {
let old_parent = parent;
parent = null;
return () => {
parent = old_parent;
};
}
// node_modules/svelte/src/internal/server/index.js
var on_destroy = [];
function render(component2, options = {}) {
var _a;
const payload = { out: "", css: /* @__PURE__ */ new Set(), head: { title: "", out: "" } };
const prev_on_destroy = on_destroy;
on_destroy = [];
payload.out += BLOCK_OPEN;
let reset_reset_element;
if (DEV) {
reset_reset_element = reset_elements();
}
if (options.context) {
push2();
current_component.c = options.context;
}
component2(payload, (_a = options.props) != null ? _a : {}, {}, {});
if (options.context) {
pop2();
}
if (reset_reset_element) {
reset_reset_element();
}
payload.out += BLOCK_CLOSE;
for (const cleanup of on_destroy) cleanup();
on_destroy = prev_on_destroy;
let head2 = payload.head.out + payload.head.title;
for (const { hash: hash2, code } of payload.css) {
head2 += `<style id="${hash2}">${code}</style>`;
}
return {
head: head2,
html: payload.out,
body: payload.out
};
}
// js/live_svelte/render.js
function getRender(components) {
components = normalizeComponents(components);
return function r(name, props, slots) {
const Component = components[name];
return render(Component, { props });
};
}
// js/live_svelte/hooks.svelte.js
function getAttributeJson(ref, attributeName) {
const data = ref.el.getAttribute(attributeName);
return data ? JSON.parse(data) : {};
}
function detach(node) {
var _a;
(_a = node.parentNode) == null ? void 0 : _a.removeChild(node);
}
function insert(target, node, anchor) {
target.insertBefore(node, anchor || null);
}
function noop2() {
}
function getSlots(ref) {
const slots = {};
for (const slotName in getAttributeJson(ref, "data-slots")) {
const slot2 = () => {
return {
getElement() {
const base64 = getAttributeJson(ref, "data-slots")[slotName];
const element2 = document.createElement("div");
element2.innerHTML = atob(base64).trim();
return element2;
},
update() {
detach(this.savedElement);
this.savedElement = this.getElement();
insert(this.savedTarget, this.savedElement, this.savedAnchor);
},
c: noop2,
m(target, anchor) {
this.savedTarget = target;
this.savedAnchor = anchor;
this.savedElement = this.getElement();
insert(this.savedTarget, this.savedElement, this.savedAnchor);
},
d(detaching) {
if (detaching) detach(this.savedElement);
},
l: noop2
};
};
slots[slotName] = [slot2];
}
return slots;
}
function getLiveJsonProps(ref) {
const json = getAttributeJson(ref, "data-live-json");
if (!Array.isArray(json)) return json;
const liveJsonData = {};
for (const liveJsonVariable of json) {
const data = window[liveJsonVariable];
if (data) liveJsonData[liveJsonVariable] = data;
}
return liveJsonData;
}
function getProps(ref) {
return __spreadProps(__spreadValues(__spreadValues({}, getAttributeJson(ref, "data-props")), getLiveJsonProps(ref)), {
live: ref,
$$slots: getSlots(ref),
$$scope: {}
});
}
function getHooks(components) {
components = normalizeComponents(components);
const props = 1;
const SvelteHook = {
mounted() {
console.log("mounting");
const componentName = this.el.getAttribute("data-name");
if (!componentName) {
throw new Error("Component name must be provided");
}
console.log("mounting 2");
const Component = components[componentName];
if (!Component) {
throw new Error(`Unable to find ${componentName} component.`);
}
console.log("mounting 3");
for (const liveJsonElement of Object.keys(getAttributeJson(this, "data-live-json"))) {
window.addEventListener(`${liveJsonElement}_initialized`, (event2) => this._instance.$set(getProps(this)), false);
window.addEventListener(`${liveJsonElement}_patched`, (event2) => this._instance.$set(getProps(this)), false);
}
console.log("mounting 4");
const app = createClassComponent({ component: Component, target: this.el });
},
updated() {
console.log("Updated");
},
destroyed() {
console.log("Destroyed");
if (this._instance) {
window.addEventListener("phx:page-loading-stop", () => unmount(this._instance), { once: true });
}
}
};
return { SvelteHook };
}
})();