mirror of
https://github.com/SoPat712/A2ZSoftware.git
synced 2025-08-21 10:18:46 -04:00
1772 lines
49 KiB
JavaScript
1772 lines
49 KiB
JavaScript
import { o as object_prototype, a as array_prototype, g as get_descriptor, b as get_prototype_of, i as is_array, s as safe_equals, e as equals, c as is_extensible, r as run_all, d as index_of, f as define_property, h as array_from } from "./equality.js";
|
|
import { U as UNINITIALIZED, H as HYDRATION_ERROR, a as HYDRATION_START, b as HYDRATION_END, r as render, p as push$1, s as setContext, c as pop$1 } from "./index.js";
|
|
import "clsx";
|
|
const BROWSER = false;
|
|
let base = "";
|
|
let assets = base;
|
|
const app_dir = "_app";
|
|
const initial = { base, assets };
|
|
function override(paths) {
|
|
base = paths.base;
|
|
assets = paths.assets;
|
|
}
|
|
function reset() {
|
|
base = initial.base;
|
|
assets = initial.assets;
|
|
}
|
|
function set_assets(path) {
|
|
assets = initial.assets = path;
|
|
}
|
|
let public_env = {};
|
|
let safe_public_env = {};
|
|
function set_private_env(environment) {
|
|
}
|
|
function set_public_env(environment) {
|
|
public_env = environment;
|
|
}
|
|
function set_safe_public_env(environment) {
|
|
safe_public_env = environment;
|
|
}
|
|
const DERIVED = 1 << 1;
|
|
const EFFECT = 1 << 2;
|
|
const RENDER_EFFECT = 1 << 3;
|
|
const BLOCK_EFFECT = 1 << 4;
|
|
const BRANCH_EFFECT = 1 << 5;
|
|
const ROOT_EFFECT = 1 << 6;
|
|
const BOUNDARY_EFFECT = 1 << 7;
|
|
const UNOWNED = 1 << 8;
|
|
const DISCONNECTED = 1 << 9;
|
|
const CLEAN = 1 << 10;
|
|
const DIRTY = 1 << 11;
|
|
const MAYBE_DIRTY = 1 << 12;
|
|
const INERT = 1 << 13;
|
|
const DESTROYED = 1 << 14;
|
|
const EFFECT_RAN = 1 << 15;
|
|
const EFFECT_TRANSPARENT = 1 << 16;
|
|
const HEAD_EFFECT = 1 << 19;
|
|
const EFFECT_HAS_DERIVED = 1 << 20;
|
|
const EFFECT_IS_UPDATING = 1 << 21;
|
|
const STATE_SYMBOL = Symbol("$state");
|
|
const LEGACY_PROPS = Symbol("legacy props");
|
|
function effect_update_depth_exceeded() {
|
|
{
|
|
throw new Error(`https://svelte.dev/e/effect_update_depth_exceeded`);
|
|
}
|
|
}
|
|
function hydration_failed() {
|
|
{
|
|
throw new Error(`https://svelte.dev/e/hydration_failed`);
|
|
}
|
|
}
|
|
function state_descriptors_fixed() {
|
|
{
|
|
throw new Error(`https://svelte.dev/e/state_descriptors_fixed`);
|
|
}
|
|
}
|
|
function state_prototype_fixed() {
|
|
{
|
|
throw new Error(`https://svelte.dev/e/state_prototype_fixed`);
|
|
}
|
|
}
|
|
function state_unsafe_mutation() {
|
|
{
|
|
throw new Error(`https://svelte.dev/e/state_unsafe_mutation`);
|
|
}
|
|
}
|
|
let tracing_mode_flag = false;
|
|
let component_context = null;
|
|
function set_component_context(context) {
|
|
component_context = context;
|
|
}
|
|
function push(props, runes = false, fn) {
|
|
var ctx = component_context = {
|
|
p: component_context,
|
|
c: null,
|
|
d: false,
|
|
e: null,
|
|
m: false,
|
|
s: props,
|
|
x: null,
|
|
l: null
|
|
};
|
|
teardown(() => {
|
|
ctx.d = true;
|
|
});
|
|
}
|
|
function pop(component) {
|
|
const context_stack_item = component_context;
|
|
if (context_stack_item !== null) {
|
|
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;
|
|
context_stack_item.m = true;
|
|
}
|
|
return (
|
|
/** @type {T} */
|
|
{}
|
|
);
|
|
}
|
|
function is_runes() {
|
|
return true;
|
|
}
|
|
function proxy(value) {
|
|
if (typeof value !== "object" || value === null || STATE_SYMBOL in value) {
|
|
return value;
|
|
}
|
|
const prototype = get_prototype_of(value);
|
|
if (prototype !== object_prototype && prototype !== array_prototype) {
|
|
return value;
|
|
}
|
|
var sources = /* @__PURE__ */ new Map();
|
|
var is_proxied_array = is_array(value);
|
|
var version = /* @__PURE__ */ state(0);
|
|
var reaction = active_reaction;
|
|
var with_parent = (fn) => {
|
|
var previous_reaction = active_reaction;
|
|
set_active_reaction(reaction);
|
|
var result = fn();
|
|
set_active_reaction(previous_reaction);
|
|
return result;
|
|
};
|
|
if (is_proxied_array) {
|
|
sources.set("length", /* @__PURE__ */ state(
|
|
/** @type {any[]} */
|
|
value.length
|
|
));
|
|
}
|
|
return new Proxy(
|
|
/** @type {any} */
|
|
value,
|
|
{
|
|
defineProperty(_, prop, descriptor) {
|
|
if (!("value" in descriptor) || descriptor.configurable === false || descriptor.enumerable === false || descriptor.writable === false) {
|
|
state_descriptors_fixed();
|
|
}
|
|
var s = sources.get(prop);
|
|
if (s === void 0) {
|
|
s = with_parent(() => /* @__PURE__ */ state(descriptor.value));
|
|
sources.set(prop, s);
|
|
} else {
|
|
set(
|
|
s,
|
|
with_parent(() => proxy(descriptor.value))
|
|
);
|
|
}
|
|
return true;
|
|
},
|
|
deleteProperty(target, prop) {
|
|
var s = sources.get(prop);
|
|
if (s === void 0) {
|
|
if (prop in target) {
|
|
sources.set(
|
|
prop,
|
|
with_parent(() => /* @__PURE__ */ state(UNINITIALIZED))
|
|
);
|
|
}
|
|
} else {
|
|
if (is_proxied_array && typeof prop === "string") {
|
|
var ls = (
|
|
/** @type {Source<number>} */
|
|
sources.get("length")
|
|
);
|
|
var n = Number(prop);
|
|
if (Number.isInteger(n) && n < ls.v) {
|
|
set(ls, n);
|
|
}
|
|
}
|
|
set(s, UNINITIALIZED);
|
|
update_version(version);
|
|
}
|
|
return true;
|
|
},
|
|
get(target, prop, receiver) {
|
|
if (prop === STATE_SYMBOL) {
|
|
return value;
|
|
}
|
|
var s = sources.get(prop);
|
|
var exists = prop in target;
|
|
if (s === void 0 && (!exists || get_descriptor(target, prop)?.writable)) {
|
|
s = with_parent(() => /* @__PURE__ */ state(proxy(exists ? target[prop] : UNINITIALIZED)));
|
|
sources.set(prop, s);
|
|
}
|
|
if (s !== void 0) {
|
|
var v = get(s);
|
|
return v === UNINITIALIZED ? void 0 : v;
|
|
}
|
|
return Reflect.get(target, prop, receiver);
|
|
},
|
|
getOwnPropertyDescriptor(target, prop) {
|
|
var descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
|
|
if (descriptor && "value" in descriptor) {
|
|
var s = sources.get(prop);
|
|
if (s) descriptor.value = get(s);
|
|
} else if (descriptor === void 0) {
|
|
var source2 = sources.get(prop);
|
|
var value2 = source2?.v;
|
|
if (source2 !== void 0 && value2 !== UNINITIALIZED) {
|
|
return {
|
|
enumerable: true,
|
|
configurable: true,
|
|
value: value2,
|
|
writable: true
|
|
};
|
|
}
|
|
}
|
|
return descriptor;
|
|
},
|
|
has(target, prop) {
|
|
if (prop === STATE_SYMBOL) {
|
|
return true;
|
|
}
|
|
var s = sources.get(prop);
|
|
var has = s !== void 0 && s.v !== UNINITIALIZED || Reflect.has(target, prop);
|
|
if (s !== void 0 || active_effect !== null && (!has || get_descriptor(target, prop)?.writable)) {
|
|
if (s === void 0) {
|
|
s = with_parent(() => /* @__PURE__ */ state(has ? proxy(target[prop]) : UNINITIALIZED));
|
|
sources.set(prop, s);
|
|
}
|
|
var value2 = get(s);
|
|
if (value2 === UNINITIALIZED) {
|
|
return false;
|
|
}
|
|
}
|
|
return has;
|
|
},
|
|
set(target, prop, value2, receiver) {
|
|
var s = sources.get(prop);
|
|
var has = prop in target;
|
|
if (is_proxied_array && prop === "length") {
|
|
for (var i = value2; i < /** @type {Source<number>} */
|
|
s.v; i += 1) {
|
|
var other_s = sources.get(i + "");
|
|
if (other_s !== void 0) {
|
|
set(other_s, UNINITIALIZED);
|
|
} else if (i in target) {
|
|
other_s = with_parent(() => /* @__PURE__ */ state(UNINITIALIZED));
|
|
sources.set(i + "", other_s);
|
|
}
|
|
}
|
|
}
|
|
if (s === void 0) {
|
|
if (!has || get_descriptor(target, prop)?.writable) {
|
|
s = with_parent(() => /* @__PURE__ */ state(void 0));
|
|
set(
|
|
s,
|
|
with_parent(() => proxy(value2))
|
|
);
|
|
sources.set(prop, s);
|
|
}
|
|
} else {
|
|
has = s.v !== UNINITIALIZED;
|
|
set(
|
|
s,
|
|
with_parent(() => proxy(value2))
|
|
);
|
|
}
|
|
var descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
|
|
if (descriptor?.set) {
|
|
descriptor.set.call(receiver, value2);
|
|
}
|
|
if (!has) {
|
|
if (is_proxied_array && typeof prop === "string") {
|
|
var ls = (
|
|
/** @type {Source<number>} */
|
|
sources.get("length")
|
|
);
|
|
var n = Number(prop);
|
|
if (Number.isInteger(n) && n >= ls.v) {
|
|
set(ls, n + 1);
|
|
}
|
|
}
|
|
update_version(version);
|
|
}
|
|
return true;
|
|
},
|
|
ownKeys(target) {
|
|
get(version);
|
|
var own_keys = Reflect.ownKeys(target).filter((key2) => {
|
|
var source3 = sources.get(key2);
|
|
return source3 === void 0 || source3.v !== UNINITIALIZED;
|
|
});
|
|
for (var [key, source2] of sources) {
|
|
if (source2.v !== UNINITIALIZED && !(key in target)) {
|
|
own_keys.push(key);
|
|
}
|
|
}
|
|
return own_keys;
|
|
},
|
|
setPrototypeOf() {
|
|
state_prototype_fixed();
|
|
}
|
|
}
|
|
);
|
|
}
|
|
function update_version(signal, d = 1) {
|
|
set(signal, signal.v + d);
|
|
}
|
|
function destroy_derived_effects(derived) {
|
|
var effects = derived.effects;
|
|
if (effects !== null) {
|
|
derived.effects = null;
|
|
for (var i = 0; i < effects.length; i += 1) {
|
|
destroy_effect(
|
|
/** @type {Effect} */
|
|
effects[i]
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function get_derived_parent_effect(derived) {
|
|
var parent = derived.parent;
|
|
while (parent !== null) {
|
|
if ((parent.f & DERIVED) === 0) {
|
|
return (
|
|
/** @type {Effect} */
|
|
parent
|
|
);
|
|
}
|
|
parent = parent.parent;
|
|
}
|
|
return null;
|
|
}
|
|
function execute_derived(derived) {
|
|
var value;
|
|
var prev_active_effect = active_effect;
|
|
set_active_effect(get_derived_parent_effect(derived));
|
|
{
|
|
try {
|
|
destroy_derived_effects(derived);
|
|
value = update_reaction(derived);
|
|
} finally {
|
|
set_active_effect(prev_active_effect);
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
function update_derived(derived) {
|
|
var value = execute_derived(derived);
|
|
var status = (skip_reaction || (derived.f & UNOWNED) !== 0) && derived.deps !== null ? MAYBE_DIRTY : CLEAN;
|
|
set_signal_status(derived, status);
|
|
if (!derived.equals(value)) {
|
|
derived.v = value;
|
|
derived.wv = increment_write_version();
|
|
}
|
|
}
|
|
const old_values = /* @__PURE__ */ new Map();
|
|
function source(v, stack) {
|
|
var signal = {
|
|
f: 0,
|
|
// TODO ideally we could skip this altogether, but it causes type errors
|
|
v,
|
|
reactions: null,
|
|
equals,
|
|
rv: 0,
|
|
wv: 0
|
|
};
|
|
return signal;
|
|
}
|
|
// @__NO_SIDE_EFFECTS__
|
|
function state(v, stack) {
|
|
const s = source(v);
|
|
push_reaction_value(s);
|
|
return s;
|
|
}
|
|
// @__NO_SIDE_EFFECTS__
|
|
function mutable_source(initial_value, immutable = false) {
|
|
const s = source(initial_value);
|
|
if (!immutable) {
|
|
s.equals = safe_equals;
|
|
}
|
|
return s;
|
|
}
|
|
function set(source2, value, should_proxy = false) {
|
|
if (active_reaction !== null && !untracking && is_runes() && (active_reaction.f & (DERIVED | BLOCK_EFFECT)) !== 0 && !reaction_sources?.includes(source2)) {
|
|
state_unsafe_mutation();
|
|
}
|
|
let new_value = should_proxy ? proxy(value) : value;
|
|
return internal_set(source2, new_value);
|
|
}
|
|
function internal_set(source2, value) {
|
|
if (!source2.equals(value)) {
|
|
var old_value = source2.v;
|
|
if (is_destroying_effect) {
|
|
old_values.set(source2, value);
|
|
} else {
|
|
old_values.set(source2, old_value);
|
|
}
|
|
source2.v = value;
|
|
if ((source2.f & DERIVED) !== 0) {
|
|
if ((source2.f & DIRTY) !== 0) {
|
|
execute_derived(
|
|
/** @type {Derived} */
|
|
source2
|
|
);
|
|
}
|
|
set_signal_status(source2, (source2.f & UNOWNED) === 0 ? CLEAN : MAYBE_DIRTY);
|
|
}
|
|
source2.wv = increment_write_version();
|
|
mark_reactions(source2, DIRTY);
|
|
if (active_effect !== null && (active_effect.f & CLEAN) !== 0 && (active_effect.f & (BRANCH_EFFECT | ROOT_EFFECT)) === 0) {
|
|
if (untracked_writes === null) {
|
|
set_untracked_writes([source2]);
|
|
} else {
|
|
untracked_writes.push(source2);
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
function mark_reactions(signal, status) {
|
|
var reactions = signal.reactions;
|
|
if (reactions === null) return;
|
|
var length = reactions.length;
|
|
for (var i = 0; i < length; i++) {
|
|
var reaction = reactions[i];
|
|
var flags = reaction.f;
|
|
if ((flags & DIRTY) !== 0) 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
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function hydration_mismatch(location) {
|
|
{
|
|
console.warn(`https://svelte.dev/e/hydration_mismatch`);
|
|
}
|
|
}
|
|
let hydrating = false;
|
|
function set_hydrating(value) {
|
|
hydrating = value;
|
|
}
|
|
let 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} */
|
|
/* @__PURE__ */ get_next_sibling(hydrate_node)
|
|
);
|
|
}
|
|
var $window;
|
|
var first_child_getter;
|
|
var next_sibling_getter;
|
|
function init_operations() {
|
|
if ($window !== void 0) {
|
|
return;
|
|
}
|
|
$window = window;
|
|
var element_prototype = Element.prototype;
|
|
var node_prototype = Node.prototype;
|
|
var text_prototype = Text.prototype;
|
|
first_child_getter = get_descriptor(node_prototype, "firstChild").get;
|
|
next_sibling_getter = get_descriptor(node_prototype, "nextSibling").get;
|
|
if (is_extensible(element_prototype)) {
|
|
element_prototype.__click = void 0;
|
|
element_prototype.__className = void 0;
|
|
element_prototype.__attributes = null;
|
|
element_prototype.__style = void 0;
|
|
element_prototype.__e = void 0;
|
|
}
|
|
if (is_extensible(text_prototype)) {
|
|
text_prototype.__t = void 0;
|
|
}
|
|
}
|
|
function create_text(value = "") {
|
|
return document.createTextNode(value);
|
|
}
|
|
// @__NO_SIDE_EFFECTS__
|
|
function get_first_child(node) {
|
|
return 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 = "";
|
|
}
|
|
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, push2 = true) {
|
|
var parent = active_effect;
|
|
var effect2 = {
|
|
ctx: component_context,
|
|
deps: null,
|
|
nodes_start: null,
|
|
nodes_end: null,
|
|
f: type | DIRTY,
|
|
first: null,
|
|
fn,
|
|
last: null,
|
|
next: null,
|
|
parent,
|
|
prev: null,
|
|
teardown: null,
|
|
transitions: null,
|
|
wv: 0
|
|
};
|
|
if (sync) {
|
|
try {
|
|
update_effect(effect2);
|
|
effect2.f |= EFFECT_RAN;
|
|
} catch (e) {
|
|
destroy_effect(effect2);
|
|
throw e;
|
|
}
|
|
} 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 | BOUNDARY_EFFECT)) === 0;
|
|
if (!inert && push2) {
|
|
if (parent !== null) {
|
|
push_effect(effect2, parent);
|
|
}
|
|
if (active_reaction !== null && (active_reaction.f & DERIVED) !== 0) {
|
|
var derived = (
|
|
/** @type {Derived} */
|
|
active_reaction
|
|
);
|
|
(derived.effects ??= []).push(effect2);
|
|
}
|
|
}
|
|
return effect2;
|
|
}
|
|
function teardown(fn) {
|
|
const effect2 = create_effect(RENDER_EFFECT, null, false);
|
|
set_signal_status(effect2, CLEAN);
|
|
effect2.teardown = fn;
|
|
return effect2;
|
|
}
|
|
function component_root(fn) {
|
|
const effect2 = create_effect(ROOT_EFFECT, fn, true);
|
|
return (options2 = {}) => {
|
|
return new Promise((fulfil) => {
|
|
if (options2.outro) {
|
|
pause_effect(effect2, () => {
|
|
destroy_effect(effect2);
|
|
fulfil(void 0);
|
|
});
|
|
} else {
|
|
destroy_effect(effect2);
|
|
fulfil(void 0);
|
|
}
|
|
});
|
|
};
|
|
}
|
|
function effect(fn) {
|
|
return create_effect(EFFECT, fn, false);
|
|
}
|
|
function branch(fn, push2 = true) {
|
|
return create_effect(RENDER_EFFECT | BRANCH_EFFECT, fn, true, push2);
|
|
}
|
|
function execute_effect_teardown(effect2) {
|
|
var teardown2 = effect2.teardown;
|
|
if (teardown2 !== null) {
|
|
const previously_destroying_effect = is_destroying_effect;
|
|
const previous_reaction = active_reaction;
|
|
set_is_destroying_effect(true);
|
|
set_active_reaction(null);
|
|
try {
|
|
teardown2.call(null);
|
|
} finally {
|
|
set_is_destroying_effect(previously_destroying_effect);
|
|
set_active_reaction(previous_reaction);
|
|
}
|
|
}
|
|
}
|
|
function destroy_effect_children(signal, remove_dom = false) {
|
|
var effect2 = signal.first;
|
|
signal.first = signal.last = null;
|
|
while (effect2 !== null) {
|
|
var next = effect2.next;
|
|
if ((effect2.f & ROOT_EFFECT) !== 0) {
|
|
effect2.parent = null;
|
|
} else {
|
|
destroy_effect(effect2, remove_dom);
|
|
}
|
|
effect2 = next;
|
|
}
|
|
}
|
|
function destroy_block_effect_children(signal) {
|
|
var effect2 = signal.first;
|
|
while (effect2 !== null) {
|
|
var next = effect2.next;
|
|
if ((effect2.f & BRANCH_EFFECT) === 0) {
|
|
destroy_effect(effect2);
|
|
}
|
|
effect2 = next;
|
|
}
|
|
}
|
|
function destroy_effect(effect2, remove_dom = true) {
|
|
var removed = false;
|
|
if ((remove_dom || (effect2.f & HEAD_EFFECT) !== 0) && effect2.nodes_start !== null) {
|
|
var node = effect2.nodes_start;
|
|
var end = effect2.nodes_end;
|
|
while (node !== null) {
|
|
var next = node === end ? null : (
|
|
/** @type {TemplateNode} */
|
|
/* @__PURE__ */ get_next_sibling(node)
|
|
);
|
|
node.remove();
|
|
node = next;
|
|
}
|
|
removed = true;
|
|
}
|
|
destroy_effect_children(effect2, remove_dom && !removed);
|
|
remove_reactions(effect2, 0);
|
|
set_signal_status(effect2, DESTROYED);
|
|
var transitions = effect2.transitions;
|
|
if (transitions !== null) {
|
|
for (const transition of transitions) {
|
|
transition.stop();
|
|
}
|
|
}
|
|
execute_effect_teardown(effect2);
|
|
var parent = effect2.parent;
|
|
if (parent !== null && parent.first !== null) {
|
|
unlink_effect(effect2);
|
|
}
|
|
effect2.next = effect2.prev = effect2.teardown = effect2.ctx = effect2.deps = effect2.fn = effect2.nodes_start = effect2.nodes_end = null;
|
|
}
|
|
function unlink_effect(effect2) {
|
|
var parent = effect2.parent;
|
|
var prev = effect2.prev;
|
|
var next = effect2.next;
|
|
if (prev !== null) prev.next = next;
|
|
if (next !== null) next.prev = prev;
|
|
if (parent !== null) {
|
|
if (parent.first === effect2) parent.first = next;
|
|
if (parent.last === effect2) parent.last = prev;
|
|
}
|
|
}
|
|
function pause_effect(effect2, callback) {
|
|
var transitions = [];
|
|
pause_children(effect2, transitions, true);
|
|
run_out_transitions(transitions, () => {
|
|
destroy_effect(effect2);
|
|
if (callback) callback();
|
|
});
|
|
}
|
|
function run_out_transitions(transitions, fn) {
|
|
var remaining = transitions.length;
|
|
if (remaining > 0) {
|
|
var check = () => --remaining || fn();
|
|
for (var transition of transitions) {
|
|
transition.out(check);
|
|
}
|
|
} else {
|
|
fn();
|
|
}
|
|
}
|
|
function pause_children(effect2, transitions, local) {
|
|
if ((effect2.f & INERT) !== 0) return;
|
|
effect2.f ^= INERT;
|
|
if (effect2.transitions !== null) {
|
|
for (const transition of effect2.transitions) {
|
|
if (transition.is_global || local) {
|
|
transitions.push(transition);
|
|
}
|
|
}
|
|
}
|
|
var child = effect2.first;
|
|
while (child !== null) {
|
|
var sibling = child.next;
|
|
var transparent = (child.f & EFFECT_TRANSPARENT) !== 0 || (child.f & BRANCH_EFFECT) !== 0;
|
|
pause_children(child, transitions, transparent ? local : false);
|
|
child = sibling;
|
|
}
|
|
}
|
|
let micro_tasks = [];
|
|
let idle_tasks = [];
|
|
function run_micro_tasks() {
|
|
var tasks = micro_tasks;
|
|
micro_tasks = [];
|
|
run_all(tasks);
|
|
}
|
|
function run_idle_tasks() {
|
|
var tasks = idle_tasks;
|
|
idle_tasks = [];
|
|
run_all(tasks);
|
|
}
|
|
function flush_tasks() {
|
|
if (micro_tasks.length > 0) {
|
|
run_micro_tasks();
|
|
}
|
|
if (idle_tasks.length > 0) {
|
|
run_idle_tasks();
|
|
}
|
|
}
|
|
let is_throwing_error = false;
|
|
let is_flushing = false;
|
|
let last_scheduled_effect = null;
|
|
let is_updating_effect = false;
|
|
let is_destroying_effect = false;
|
|
function set_is_destroying_effect(value) {
|
|
is_destroying_effect = value;
|
|
}
|
|
let queued_root_effects = [];
|
|
let dev_effect_stack = [];
|
|
let active_reaction = null;
|
|
let untracking = false;
|
|
function set_active_reaction(reaction) {
|
|
active_reaction = reaction;
|
|
}
|
|
let active_effect = null;
|
|
function set_active_effect(effect2) {
|
|
active_effect = effect2;
|
|
}
|
|
let reaction_sources = null;
|
|
function set_reaction_sources(sources) {
|
|
reaction_sources = sources;
|
|
}
|
|
function push_reaction_value(value) {
|
|
if (active_reaction !== null && active_reaction.f & EFFECT_IS_UPDATING) {
|
|
if (reaction_sources === null) {
|
|
set_reaction_sources([value]);
|
|
} else {
|
|
reaction_sources.push(value);
|
|
}
|
|
}
|
|
}
|
|
let new_deps = null;
|
|
let skipped_deps = 0;
|
|
let untracked_writes = null;
|
|
function set_untracked_writes(value) {
|
|
untracked_writes = value;
|
|
}
|
|
let write_version = 1;
|
|
let read_version = 0;
|
|
let skip_reaction = false;
|
|
function increment_write_version() {
|
|
return ++write_version;
|
|
}
|
|
function check_dirtiness(reaction) {
|
|
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;
|
|
var dependency;
|
|
var is_disconnected = (flags & DISCONNECTED) !== 0;
|
|
var is_unowned_connected = is_unowned && active_effect !== null && !skip_reaction;
|
|
var length = dependencies.length;
|
|
if (is_disconnected || is_unowned_connected) {
|
|
var derived = (
|
|
/** @type {Derived} */
|
|
reaction
|
|
);
|
|
var parent = derived.parent;
|
|
for (i = 0; i < length; i++) {
|
|
dependency = dependencies[i];
|
|
if (is_disconnected || !dependency?.reactions?.includes(derived)) {
|
|
(dependency.reactions ??= []).push(derived);
|
|
}
|
|
}
|
|
if (is_disconnected) {
|
|
derived.f ^= DISCONNECTED;
|
|
}
|
|
if (is_unowned_connected && parent !== null && (parent.f & UNOWNED) === 0) {
|
|
derived.f ^= UNOWNED;
|
|
}
|
|
}
|
|
for (i = 0; i < length; i++) {
|
|
dependency = dependencies[i];
|
|
if (check_dirtiness(
|
|
/** @type {Derived} */
|
|
dependency
|
|
)) {
|
|
update_derived(
|
|
/** @type {Derived} */
|
|
dependency
|
|
);
|
|
}
|
|
if (dependency.wv > reaction.wv) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (!is_unowned || active_effect !== null && !skip_reaction) {
|
|
set_signal_status(reaction, CLEAN);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function propagate_error(error, effect2) {
|
|
var current = effect2;
|
|
while (current !== null) {
|
|
if ((current.f & BOUNDARY_EFFECT) !== 0) {
|
|
try {
|
|
current.fn(error);
|
|
return;
|
|
} catch {
|
|
current.f ^= BOUNDARY_EFFECT;
|
|
}
|
|
}
|
|
current = current.parent;
|
|
}
|
|
is_throwing_error = false;
|
|
throw error;
|
|
}
|
|
function should_rethrow_error(effect2) {
|
|
return (effect2.f & DESTROYED) === 0 && (effect2.parent === null || (effect2.parent.f & BOUNDARY_EFFECT) === 0);
|
|
}
|
|
function handle_error(error, effect2, previous_effect, component_context2) {
|
|
if (is_throwing_error) {
|
|
if (previous_effect === null) {
|
|
is_throwing_error = false;
|
|
}
|
|
if (should_rethrow_error(effect2)) {
|
|
throw error;
|
|
}
|
|
return;
|
|
}
|
|
if (previous_effect !== null) {
|
|
is_throwing_error = true;
|
|
}
|
|
{
|
|
propagate_error(error, effect2);
|
|
return;
|
|
}
|
|
}
|
|
function schedule_possible_effect_self_invalidation(signal, effect2, root2 = true) {
|
|
var reactions = signal.reactions;
|
|
if (reactions === null) return;
|
|
for (var i = 0; i < reactions.length; i++) {
|
|
var reaction = reactions[i];
|
|
if (reaction_sources?.includes(signal)) continue;
|
|
if ((reaction.f & DERIVED) !== 0) {
|
|
schedule_possible_effect_self_invalidation(
|
|
/** @type {Derived} */
|
|
reaction,
|
|
effect2,
|
|
false
|
|
);
|
|
} else if (effect2 === reaction) {
|
|
if (root2) {
|
|
set_signal_status(reaction, DIRTY);
|
|
} else if ((reaction.f & CLEAN) !== 0) {
|
|
set_signal_status(reaction, MAYBE_DIRTY);
|
|
}
|
|
schedule_effect(
|
|
/** @type {Effect} */
|
|
reaction
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function update_reaction(reaction) {
|
|
var 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 previous_reaction_sources = reaction_sources;
|
|
var previous_component_context = component_context;
|
|
var previous_untracking = untracking;
|
|
var flags = reaction.f;
|
|
new_deps = /** @type {null | Value[]} */
|
|
null;
|
|
skipped_deps = 0;
|
|
untracked_writes = null;
|
|
skip_reaction = (flags & UNOWNED) !== 0 && (untracking || !is_updating_effect || active_reaction === null);
|
|
active_reaction = (flags & (BRANCH_EFFECT | ROOT_EFFECT)) === 0 ? reaction : null;
|
|
reaction_sources = null;
|
|
set_component_context(reaction.ctx);
|
|
untracking = false;
|
|
read_version++;
|
|
reaction.f |= EFFECT_IS_UPDATING;
|
|
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++) {
|
|
(deps[i].reactions ??= []).push(reaction);
|
|
}
|
|
}
|
|
} else if (deps !== null && skipped_deps < deps.length) {
|
|
remove_reactions(reaction, skipped_deps);
|
|
deps.length = skipped_deps;
|
|
}
|
|
if (is_runes() && untracked_writes !== null && !untracking && deps !== null && (reaction.f & (DERIVED | MAYBE_DIRTY | DIRTY)) === 0) {
|
|
for (i = 0; i < /** @type {Source[]} */
|
|
untracked_writes.length; i++) {
|
|
schedule_possible_effect_self_invalidation(
|
|
untracked_writes[i],
|
|
/** @type {Effect} */
|
|
reaction
|
|
);
|
|
}
|
|
}
|
|
if (previous_reaction !== reaction) {
|
|
read_version++;
|
|
if (untracked_writes !== null) {
|
|
if (previous_untracked_writes === null) {
|
|
previous_untracked_writes = untracked_writes;
|
|
} else {
|
|
previous_untracked_writes.push(.../** @type {Source[]} */
|
|
untracked_writes);
|
|
}
|
|
}
|
|
}
|
|
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;
|
|
reaction_sources = previous_reaction_sources;
|
|
set_component_context(previous_component_context);
|
|
untracking = previous_untracking;
|
|
reaction.f ^= EFFECT_IS_UPDATING;
|
|
}
|
|
}
|
|
function remove_reaction(signal, dependency) {
|
|
let reactions = dependency.reactions;
|
|
if (reactions !== null) {
|
|
var index = index_of.call(reactions, signal);
|
|
if (index !== -1) {
|
|
var new_length = reactions.length - 1;
|
|
if (new_length === 0) {
|
|
reactions = dependency.reactions = null;
|
|
} else {
|
|
reactions[index] = reactions[new_length];
|
|
reactions.pop();
|
|
}
|
|
}
|
|
}
|
|
if (reactions === null && (dependency.f & DERIVED) !== 0 && // Destroying a child effect while updating a parent effect can cause a dependency to appear
|
|
// to be unused, when in fact it is used by the currently-updating parent. Checking `new_deps`
|
|
// allows us to skip the expensive work of disconnecting and immediately reconnecting it
|
|
(new_deps === null || !new_deps.includes(dependency))) {
|
|
set_signal_status(dependency, MAYBE_DIRTY);
|
|
if ((dependency.f & (UNOWNED | DISCONNECTED)) === 0) {
|
|
dependency.f ^= DISCONNECTED;
|
|
}
|
|
destroy_derived_effects(
|
|
/** @type {Derived} **/
|
|
dependency
|
|
);
|
|
remove_reactions(
|
|
/** @type {Derived} **/
|
|
dependency,
|
|
0
|
|
);
|
|
}
|
|
}
|
|
function remove_reactions(signal, start_index) {
|
|
var dependencies = signal.deps;
|
|
if (dependencies === null) return;
|
|
for (var i = start_index; i < dependencies.length; i++) {
|
|
remove_reaction(signal, dependencies[i]);
|
|
}
|
|
}
|
|
function update_effect(effect2) {
|
|
var flags = effect2.f;
|
|
if ((flags & DESTROYED) !== 0) {
|
|
return;
|
|
}
|
|
set_signal_status(effect2, CLEAN);
|
|
var previous_effect = active_effect;
|
|
var previous_component_context = component_context;
|
|
var was_updating_effect = is_updating_effect;
|
|
active_effect = effect2;
|
|
is_updating_effect = true;
|
|
try {
|
|
if ((flags & BLOCK_EFFECT) !== 0) {
|
|
destroy_block_effect_children(effect2);
|
|
} else {
|
|
destroy_effect_children(effect2);
|
|
}
|
|
execute_effect_teardown(effect2);
|
|
var teardown2 = update_reaction(effect2);
|
|
effect2.teardown = typeof teardown2 === "function" ? teardown2 : null;
|
|
effect2.wv = write_version;
|
|
var deps = effect2.deps;
|
|
var dep;
|
|
if (BROWSER && tracing_mode_flag && (effect2.f & DIRTY) !== 0 && deps !== null) ;
|
|
if (BROWSER) ;
|
|
} catch (error) {
|
|
handle_error(error, effect2, previous_effect, previous_component_context || effect2.ctx);
|
|
} finally {
|
|
is_updating_effect = was_updating_effect;
|
|
active_effect = previous_effect;
|
|
}
|
|
}
|
|
function infinite_loop_guard() {
|
|
try {
|
|
effect_update_depth_exceeded();
|
|
} catch (error) {
|
|
if (last_scheduled_effect !== null) {
|
|
{
|
|
handle_error(error, last_scheduled_effect, null);
|
|
}
|
|
} else {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
function flush_queued_root_effects() {
|
|
var was_updating_effect = is_updating_effect;
|
|
try {
|
|
var flush_count = 0;
|
|
is_updating_effect = true;
|
|
while (queued_root_effects.length > 0) {
|
|
if (flush_count++ > 1e3) {
|
|
infinite_loop_guard();
|
|
}
|
|
var root_effects = queued_root_effects;
|
|
var length = root_effects.length;
|
|
queued_root_effects = [];
|
|
for (var i = 0; i < length; i++) {
|
|
var collected_effects = process_effects(root_effects[i]);
|
|
flush_queued_effects(collected_effects);
|
|
}
|
|
old_values.clear();
|
|
}
|
|
} finally {
|
|
is_flushing = false;
|
|
is_updating_effect = was_updating_effect;
|
|
last_scheduled_effect = null;
|
|
}
|
|
}
|
|
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) {
|
|
try {
|
|
if (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;
|
|
}
|
|
}
|
|
}
|
|
} catch (error) {
|
|
handle_error(error, effect2, null, effect2.ctx);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function schedule_effect(signal) {
|
|
if (!is_flushing) {
|
|
is_flushing = true;
|
|
queueMicrotask(flush_queued_root_effects);
|
|
}
|
|
var effect2 = last_scheduled_effect = 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(root2) {
|
|
var effects = [];
|
|
var effect2 = root2;
|
|
while (effect2 !== null) {
|
|
var flags = effect2.f;
|
|
var is_branch = (flags & (BRANCH_EFFECT | ROOT_EFFECT)) !== 0;
|
|
var is_skippable_branch = is_branch && (flags & CLEAN) !== 0;
|
|
if (!is_skippable_branch && (flags & INERT) === 0) {
|
|
if ((flags & EFFECT) !== 0) {
|
|
effects.push(effect2);
|
|
} else if (is_branch) {
|
|
effect2.f ^= CLEAN;
|
|
} else {
|
|
var previous_active_reaction = active_reaction;
|
|
try {
|
|
active_reaction = effect2;
|
|
if (check_dirtiness(effect2)) {
|
|
update_effect(effect2);
|
|
}
|
|
} catch (error) {
|
|
handle_error(error, effect2, null, effect2.ctx);
|
|
} finally {
|
|
active_reaction = previous_active_reaction;
|
|
}
|
|
}
|
|
var child = effect2.first;
|
|
if (child !== null) {
|
|
effect2 = child;
|
|
continue;
|
|
}
|
|
}
|
|
var parent = effect2.parent;
|
|
effect2 = effect2.next;
|
|
while (effect2 === null && parent !== null) {
|
|
effect2 = parent.next;
|
|
parent = parent.parent;
|
|
}
|
|
}
|
|
return effects;
|
|
}
|
|
function flushSync(fn) {
|
|
var result;
|
|
flush_tasks();
|
|
while (queued_root_effects.length > 0) {
|
|
is_flushing = true;
|
|
flush_queued_root_effects();
|
|
flush_tasks();
|
|
}
|
|
return (
|
|
/** @type {T} */
|
|
result
|
|
);
|
|
}
|
|
function get(signal) {
|
|
var flags = signal.f;
|
|
var is_derived = (flags & DERIVED) !== 0;
|
|
if (active_reaction !== null && !untracking) {
|
|
if (!reaction_sources?.includes(signal)) {
|
|
var deps = active_reaction.deps;
|
|
if (signal.rv < read_version) {
|
|
signal.rv = read_version;
|
|
if (new_deps === null && deps !== null && deps[skipped_deps] === signal) {
|
|
skipped_deps++;
|
|
} else if (new_deps === null) {
|
|
new_deps = [signal];
|
|
} else if (!skip_reaction || !new_deps.includes(signal)) {
|
|
new_deps.push(signal);
|
|
}
|
|
}
|
|
}
|
|
} else if (is_derived && /** @type {Derived} */
|
|
signal.deps === null && /** @type {Derived} */
|
|
signal.effects === null) {
|
|
var derived = (
|
|
/** @type {Derived} */
|
|
signal
|
|
);
|
|
var parent = derived.parent;
|
|
if (parent !== null && (parent.f & UNOWNED) === 0) {
|
|
derived.f ^= UNOWNED;
|
|
}
|
|
}
|
|
if (is_derived) {
|
|
derived = /** @type {Derived} */
|
|
signal;
|
|
if (check_dirtiness(derived)) {
|
|
update_derived(derived);
|
|
}
|
|
}
|
|
if (is_destroying_effect && old_values.has(signal)) {
|
|
return old_values.get(signal);
|
|
}
|
|
return signal.v;
|
|
}
|
|
const STATUS_MASK = -7169;
|
|
function set_signal_status(signal, status) {
|
|
signal.f = signal.f & STATUS_MASK | status;
|
|
}
|
|
const PASSIVE_EVENTS = ["touchstart", "touchmove"];
|
|
function is_passive_event(name) {
|
|
return PASSIVE_EVENTS.includes(name);
|
|
}
|
|
const all_registered_events = /* @__PURE__ */ new Set();
|
|
const root_event_handles = /* @__PURE__ */ new Set();
|
|
function handle_event_propagation(event) {
|
|
var handler_element = this;
|
|
var owner_document = (
|
|
/** @type {Node} */
|
|
handler_element.ownerDocument
|
|
);
|
|
var event_name = event.type;
|
|
var path = event.composedPath?.() || [];
|
|
var current_target = (
|
|
/** @type {null | Element} */
|
|
path[0] || event.target
|
|
);
|
|
var path_idx = 0;
|
|
var handled_at = event.__root;
|
|
if (handled_at) {
|
|
var at_idx = path.indexOf(handled_at);
|
|
if (at_idx !== -1 && (handler_element === document || handler_element === /** @type {any} */
|
|
window)) {
|
|
event.__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] || event.target;
|
|
if (current_target === handler_element) return;
|
|
define_property(event, "currentTarget", {
|
|
configurable: true,
|
|
get() {
|
|
return current_target || owner_document;
|
|
}
|
|
});
|
|
var previous_reaction = active_reaction;
|
|
var previous_effect = active_effect;
|
|
set_active_reaction(null);
|
|
set_active_effect(null);
|
|
try {
|
|
var throw_error;
|
|
var other_errors = [];
|
|
while (current_target !== null) {
|
|
var parent_element = current_target.assignedSlot || current_target.parentNode || /** @type {any} */
|
|
current_target.host || null;
|
|
try {
|
|
var delegated = current_target["__" + event_name];
|
|
if (delegated != null && (!/** @type {any} */
|
|
current_target.disabled || // DOM could've been updated already by the time this is reached, so we check this as well
|
|
// -> the target could not have been disabled because it emits the event in the first place
|
|
event.target === current_target)) {
|
|
if (is_array(delegated)) {
|
|
var [fn, ...data] = delegated;
|
|
fn.apply(current_target, [event, ...data]);
|
|
} else {
|
|
delegated.call(current_target, event);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
if (throw_error) {
|
|
other_errors.push(error);
|
|
} else {
|
|
throw_error = error;
|
|
}
|
|
}
|
|
if (event.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 {
|
|
event.__root = handler_element;
|
|
delete event.currentTarget;
|
|
set_active_reaction(previous_reaction);
|
|
set_active_effect(previous_effect);
|
|
}
|
|
}
|
|
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 mount(component, options2) {
|
|
return _mount(component, options2);
|
|
}
|
|
function hydrate(component, options2) {
|
|
init_operations();
|
|
options2.intro = options2.intro ?? false;
|
|
const target = options2.target;
|
|
const was_hydrating = hydrating;
|
|
const previous_hydrate_node = hydrate_node;
|
|
try {
|
|
var anchor = (
|
|
/** @type {TemplateNode} */
|
|
/* @__PURE__ */ get_first_child(target)
|
|
);
|
|
while (anchor && (anchor.nodeType !== 8 || /** @type {Comment} */
|
|
anchor.data !== HYDRATION_START)) {
|
|
anchor = /** @type {TemplateNode} */
|
|
/* @__PURE__ */ get_next_sibling(anchor);
|
|
}
|
|
if (!anchor) {
|
|
throw HYDRATION_ERROR;
|
|
}
|
|
set_hydrating(true);
|
|
set_hydrate_node(
|
|
/** @type {Comment} */
|
|
anchor
|
|
);
|
|
hydrate_next();
|
|
const instance = _mount(component, { ...options2, 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 (options2.recover === false) {
|
|
hydration_failed();
|
|
}
|
|
init_operations();
|
|
clear_text_content(target);
|
|
set_hydrating(false);
|
|
return mount(component, options2);
|
|
}
|
|
throw error;
|
|
} finally {
|
|
set_hydrating(was_hydrating);
|
|
set_hydrate_node(previous_hydrate_node);
|
|
}
|
|
}
|
|
const document_listeners = /* @__PURE__ */ new Map();
|
|
function _mount(Component, { target, anchor, props = {}, events, context, intro = true }) {
|
|
init_operations();
|
|
var registered_events = /* @__PURE__ */ new Set();
|
|
var event_handle = (events2) => {
|
|
for (var i = 0; i < events2.length; i++) {
|
|
var event_name = events2[i];
|
|
if (registered_events.has(event_name)) continue;
|
|
registered_events.add(event_name);
|
|
var passive = is_passive_event(event_name);
|
|
target.addEventListener(event_name, handle_event_propagation, { passive });
|
|
var n = document_listeners.get(event_name);
|
|
if (n === void 0) {
|
|
document.addEventListener(event_name, handle_event_propagation, { passive });
|
|
document_listeners.set(event_name, 1);
|
|
} else {
|
|
document_listeners.set(event_name, n + 1);
|
|
}
|
|
}
|
|
};
|
|
event_handle(array_from(all_registered_events));
|
|
root_event_handles.add(event_handle);
|
|
var component = void 0;
|
|
var unmount2 = component_root(() => {
|
|
var anchor_node = anchor ?? target.appendChild(create_text());
|
|
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
|
|
);
|
|
}
|
|
component = Component(anchor_node, props) || {};
|
|
if (hydrating) {
|
|
active_effect.nodes_end = hydrate_node;
|
|
}
|
|
if (context) {
|
|
pop();
|
|
}
|
|
});
|
|
return () => {
|
|
for (var event_name of registered_events) {
|
|
target.removeEventListener(event_name, handle_event_propagation);
|
|
var n = (
|
|
/** @type {number} */
|
|
document_listeners.get(event_name)
|
|
);
|
|
if (--n === 0) {
|
|
document.removeEventListener(event_name, handle_event_propagation);
|
|
document_listeners.delete(event_name);
|
|
} else {
|
|
document_listeners.set(event_name, n);
|
|
}
|
|
}
|
|
root_event_handles.delete(event_handle);
|
|
if (anchor_node !== anchor) {
|
|
anchor_node.parentNode?.removeChild(anchor_node);
|
|
}
|
|
};
|
|
});
|
|
mounted_components.set(component, unmount2);
|
|
return component;
|
|
}
|
|
let mounted_components = /* @__PURE__ */ new WeakMap();
|
|
function unmount(component, options2) {
|
|
const fn = mounted_components.get(component);
|
|
if (fn) {
|
|
mounted_components.delete(component);
|
|
return fn(options2);
|
|
}
|
|
return Promise.resolve();
|
|
}
|
|
function asClassComponent$1(component) {
|
|
return class extends Svelte4Component {
|
|
/** @param {any} options */
|
|
constructor(options2) {
|
|
super({
|
|
component,
|
|
...options2
|
|
});
|
|
}
|
|
};
|
|
}
|
|
class Svelte4Component {
|
|
/** @type {any} */
|
|
#events;
|
|
/** @type {Record<string, any>} */
|
|
#instance;
|
|
/**
|
|
* @param {ComponentConstructorOptions & {
|
|
* component: any;
|
|
* }} options
|
|
*/
|
|
constructor(options2) {
|
|
var sources = /* @__PURE__ */ new Map();
|
|
var add_source = (key, value) => {
|
|
var s = /* @__PURE__ */ mutable_source(value);
|
|
sources.set(key, s);
|
|
return s;
|
|
};
|
|
const props = new Proxy(
|
|
{ ...options2.props || {}, $$events: {} },
|
|
{
|
|
get(target, prop) {
|
|
return get(sources.get(prop) ?? add_source(prop, Reflect.get(target, prop)));
|
|
},
|
|
has(target, prop) {
|
|
if (prop === LEGACY_PROPS) return true;
|
|
get(sources.get(prop) ?? add_source(prop, Reflect.get(target, prop)));
|
|
return Reflect.has(target, prop);
|
|
},
|
|
set(target, prop, value) {
|
|
set(sources.get(prop) ?? add_source(prop, value), value);
|
|
return Reflect.set(target, prop, value);
|
|
}
|
|
}
|
|
);
|
|
this.#instance = (options2.hydrate ? hydrate : mount)(options2.component, {
|
|
target: options2.target,
|
|
anchor: options2.anchor,
|
|
props,
|
|
context: options2.context,
|
|
intro: options2.intro ?? false,
|
|
recover: options2.recover
|
|
});
|
|
if (!options2?.props?.$$host || options2.sync === false) {
|
|
flushSync();
|
|
}
|
|
this.#events = props.$$events;
|
|
for (const key of Object.keys(this.#instance)) {
|
|
if (key === "$set" || key === "$destroy" || key === "$on") continue;
|
|
define_property(this, key, {
|
|
get() {
|
|
return this.#instance[key];
|
|
},
|
|
/** @param {any} value */
|
|
set(value) {
|
|
this.#instance[key] = value;
|
|
},
|
|
enumerable: true
|
|
});
|
|
}
|
|
this.#instance.$set = /** @param {Record<string, any>} next */
|
|
(next) => {
|
|
Object.assign(props, next);
|
|
};
|
|
this.#instance.$destroy = () => {
|
|
unmount(this.#instance);
|
|
};
|
|
}
|
|
/** @param {Record<string, any>} props */
|
|
$set(props) {
|
|
this.#instance.$set(props);
|
|
}
|
|
/**
|
|
* @param {string} event
|
|
* @param {(...args: any[]) => any} callback
|
|
* @returns {any}
|
|
*/
|
|
$on(event, callback) {
|
|
this.#events[event] = this.#events[event] || [];
|
|
const cb = (...args) => callback.call(this, ...args);
|
|
this.#events[event].push(cb);
|
|
return () => {
|
|
this.#events[event] = this.#events[event].filter(
|
|
/** @param {any} fn */
|
|
(fn) => fn !== cb
|
|
);
|
|
};
|
|
}
|
|
$destroy() {
|
|
this.#instance.$destroy();
|
|
}
|
|
}
|
|
let read_implementation = null;
|
|
function set_read_implementation(fn) {
|
|
read_implementation = fn;
|
|
}
|
|
function set_manifest(_) {
|
|
}
|
|
function asClassComponent(component) {
|
|
const component_constructor = asClassComponent$1(component);
|
|
const _render = (props, { context } = {}) => {
|
|
const result = render(component, { props, context });
|
|
return {
|
|
css: { code: "", map: null },
|
|
head: result.head,
|
|
html: result.body
|
|
};
|
|
};
|
|
component_constructor.render = _render;
|
|
return component_constructor;
|
|
}
|
|
let prerendering = false;
|
|
function set_building() {
|
|
}
|
|
function set_prerendering() {
|
|
prerendering = true;
|
|
}
|
|
function Root($$payload, $$props) {
|
|
push$1();
|
|
let {
|
|
stores,
|
|
page,
|
|
constructors,
|
|
components = [],
|
|
form,
|
|
data_0 = null,
|
|
data_1 = null
|
|
} = $$props;
|
|
{
|
|
setContext("__svelte__", stores);
|
|
}
|
|
{
|
|
stores.page.set(page);
|
|
}
|
|
const Pyramid_1 = constructors[1];
|
|
if (constructors[1]) {
|
|
$$payload.out += "<!--[-->";
|
|
const Pyramid_0 = constructors[0];
|
|
$$payload.out += `<!---->`;
|
|
Pyramid_0($$payload, {
|
|
data: data_0,
|
|
form,
|
|
children: ($$payload2) => {
|
|
$$payload2.out += `<!---->`;
|
|
Pyramid_1($$payload2, { data: data_1, form });
|
|
$$payload2.out += `<!---->`;
|
|
},
|
|
$$slots: { default: true }
|
|
});
|
|
$$payload.out += `<!---->`;
|
|
} else {
|
|
$$payload.out += "<!--[!-->";
|
|
const Pyramid_0 = constructors[0];
|
|
$$payload.out += `<!---->`;
|
|
Pyramid_0($$payload, { data: data_0, form });
|
|
$$payload.out += `<!---->`;
|
|
}
|
|
$$payload.out += `<!--]--> `;
|
|
{
|
|
$$payload.out += "<!--[!-->";
|
|
}
|
|
$$payload.out += `<!--]-->`;
|
|
pop$1();
|
|
}
|
|
const root = asClassComponent(Root);
|
|
const options = {
|
|
app_template_contains_nonce: false,
|
|
csp: { "mode": "auto", "directives": { "upgrade-insecure-requests": false, "block-all-mixed-content": false }, "reportOnly": { "upgrade-insecure-requests": false, "block-all-mixed-content": false } },
|
|
csrf_check_origin: true,
|
|
embedded: false,
|
|
env_public_prefix: "PUBLIC_",
|
|
env_private_prefix: "",
|
|
hash_routing: false,
|
|
hooks: null,
|
|
// added lazily, via `get_hooks`
|
|
preload_strategy: "modulepreload",
|
|
root,
|
|
service_worker: false,
|
|
templates: {
|
|
app: ({ head, body, assets: assets2, nonce, env }) => '<!doctype html>\n<html lang="en">\n <head>\n <meta charset="utf-8" />\n <link rel="icon" href="' + assets2 + '/favicon.png" />\n <meta name="viewport" content="width=device-width, initial-scale=1" />\n ' + head + '\n </head>\n <body data-sveltekit-preload-data="hover">\n <div style="display: contents">' + body + "</div>\n </body>\n</html>\n",
|
|
error: ({ status, message }) => '<!doctype html>\n<html lang="en">\n <head>\n <meta charset="utf-8" />\n <title>' + message + `</title>
|
|
|
|
<style>
|
|
body {
|
|
--bg: white;
|
|
--fg: #222;
|
|
--divider: #ccc;
|
|
background: var(--bg);
|
|
color: var(--fg);
|
|
font-family:
|
|
system-ui,
|
|
-apple-system,
|
|
BlinkMacSystemFont,
|
|
'Segoe UI',
|
|
Roboto,
|
|
Oxygen,
|
|
Ubuntu,
|
|
Cantarell,
|
|
'Open Sans',
|
|
'Helvetica Neue',
|
|
sans-serif;
|
|
display: flex;
|
|
align-items: center;
|
|
justify-content: center;
|
|
height: 100vh;
|
|
margin: 0;
|
|
}
|
|
|
|
.error {
|
|
display: flex;
|
|
align-items: center;
|
|
max-width: 32rem;
|
|
margin: 0 1rem;
|
|
}
|
|
|
|
.status {
|
|
font-weight: 200;
|
|
font-size: 3rem;
|
|
line-height: 1;
|
|
position: relative;
|
|
top: -0.05rem;
|
|
}
|
|
|
|
.message {
|
|
border-left: 1px solid var(--divider);
|
|
padding: 0 0 0 1rem;
|
|
margin: 0 0 0 1rem;
|
|
min-height: 2.5rem;
|
|
display: flex;
|
|
align-items: center;
|
|
}
|
|
|
|
.message h1 {
|
|
font-weight: 400;
|
|
font-size: 1em;
|
|
margin: 0;
|
|
}
|
|
|
|
@media (prefers-color-scheme: dark) {
|
|
body {
|
|
--bg: #222;
|
|
--fg: #ddd;
|
|
--divider: #666;
|
|
}
|
|
}
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<div class="error">
|
|
<span class="status">` + status + '</span>\n <div class="message">\n <h1>' + message + "</h1>\n </div>\n </div>\n </body>\n</html>\n"
|
|
},
|
|
version_hash: "1du9zss"
|
|
};
|
|
async function get_hooks() {
|
|
let handle;
|
|
let handleFetch;
|
|
let handleError;
|
|
let init;
|
|
let reroute;
|
|
let transport;
|
|
return {
|
|
handle,
|
|
handleFetch,
|
|
handleError,
|
|
init,
|
|
reroute,
|
|
transport
|
|
};
|
|
}
|
|
export {
|
|
BROWSER as B,
|
|
assets as a,
|
|
base as b,
|
|
app_dir as c,
|
|
read_implementation as d,
|
|
options as e,
|
|
set_private_env as f,
|
|
get_hooks as g,
|
|
prerendering as h,
|
|
set_public_env as i,
|
|
set_safe_public_env as j,
|
|
set_read_implementation as k,
|
|
set_assets as l,
|
|
set_building as m,
|
|
set_manifest as n,
|
|
override as o,
|
|
public_env as p,
|
|
set_prerendering as q,
|
|
reset as r,
|
|
safe_public_env as s
|
|
};
|