playlight-sdk
Version:
The SDK for Playlight - a discovery platform, built into your own game.
1,440 lines • 175 kB
JavaScript
var __defProp = Object.defineProperty;
var __typeError = (msg) => {
throw TypeError(msg);
};
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
var _e2, _t2, _n, _ResizeObserverSingleton_instances, r_fn, _a, _PlayLightAPI_instances, s_fn, _b, _PlaylightSDK_instances, i_fn, _c;
const e = false;
var t = Array.isArray, n = Array.prototype.indexOf, s = Array.from, i = Object.defineProperty, o = Object.getOwnPropertyDescriptor, a = Object.getOwnPropertyDescriptors, l = Object.prototype, c = Array.prototype, u = Object.getPrototypeOf, d = Object.isExtensible;
function is_function(e2) {
return "function" == typeof e2;
}
const noop = () => {
};
function run(e2) {
return e2();
}
function run_all(e2) {
for (var t2 = 0; t2 < e2.length; t2++) e2[t2]();
}
const f = 32, p = 64, g = 128, _ = 256, v = 512, h = 1024, m = 2048, b = 4096, y = 8192, $ = 16384, w = 65536, x = 1 << 20, k = 1 << 21, C = Symbol("$state"), S = Symbol("legacy props"), M = Symbol("");
function equals(e2) {
return e2 === this.v;
}
function safe_not_equal(e2, t2) {
return e2 != e2 ? t2 == t2 : e2 !== t2 || null !== e2 && "object" == typeof e2 || "function" == typeof e2;
}
function safe_equals(e2) {
return !safe_not_equal(e2, this.v);
}
let T = false;
const I = Symbol();
function lifecycle_outside_component(e2) {
throw new Error("https://svelte.dev/e/lifecycle_outside_component");
}
let O = null;
function set_component_context(e2) {
O = e2;
}
function push(e2, t2 = false, n2) {
var s2 = O = {
p: O,
c: null,
d: false,
e: null,
m: false,
s: e2,
x: null,
l: null
};
T && !t2 && (O.l = {
s: null,
u: null,
r1: [],
r2: source(false)
}), teardown(() => {
s2.d = true;
});
}
function pop(e2) {
const t2 = O;
if (null !== t2) {
const e3 = t2.e;
if (null !== e3) {
var n2 = V, s2 = R;
t2.e = null;
try {
for (var i2 = 0; i2 < e3.length; i2++) {
var o2 = e3[i2];
set_active_effect(o2.effect), set_active_reaction(o2.reaction), effect(o2.fn);
}
} finally {
set_active_effect(n2), set_active_reaction(s2);
}
}
O = t2.p, t2.m = true;
}
return {};
}
function is_runes() {
return !T || null !== O && null === O.l;
}
function proxy(e2, n2) {
if ("object" != typeof e2 || null === e2 || C in e2) return e2;
const s2 = u(e2);
if (s2 !== l && s2 !== c) return e2;
var i2 = /* @__PURE__ */ new Map(), a2 = t(e2), d2 = state(0), f2 = R, with_parent = (e3) => {
var t2, n3 = R;
return set_active_reaction(f2), t2 = e3(), set_active_reaction(n3), t2;
};
return a2 && // We need to create the length source eagerly to ensure that
// mutations to the array are properly synced with our proxy
i2.set("length", state(
/** @type {any[]} */
e2.length
)), new Proxy(
/** @type {any} */
e2,
{
defineProperty(e3, t2, n3) {
"value" in n3 && false !== n3.configurable && false !== n3.enumerable && false !== n3.writable || // we disallow non-basic descriptors, because unless they are applied to the
// target object — which we avoid, so that state can be forked — we will run
// afoul of the various invariants
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/getOwnPropertyDescriptor#invariants
/**
* Property descriptors defined on `$state` objects must contain `value` and always be `enumerable`, `configurable` and `writable`.
* @returns {never}
*/
function state_descriptors_fixed() {
throw new Error("https://svelte.dev/e/state_descriptors_fixed");
}();
var s3 = i2.get(t2);
return void 0 === s3 ? (s3 = with_parent(() => state(n3.value)), i2.set(t2, s3)) : set(s3, with_parent(() => proxy(n3.value))), true;
},
deleteProperty(e3, t2) {
var n3 = i2.get(t2);
if (void 0 === n3) t2 in e3 && i2.set(t2, with_parent(() => state(I)));
else {
if (a2 && "string" == typeof t2) {
var s3 = (
/** @type {Source<number>} */
i2.get("length")
), o2 = Number(t2);
Number.isInteger(o2) && o2 < s3.v && set(s3, o2);
}
set(n3, I), update_version(d2);
}
return true;
},
get(t2, n3, s3) {
var _a2;
if (n3 === C) return e2;
var a3 = i2.get(n3), l2 = n3 in t2;
if (
// create a source, but only if it's an own property and not a prototype property
void 0 !== a3 || l2 && !((_a2 = o(t2, n3)) == null ? void 0 : _a2.writable) || (a3 = with_parent(() => state(proxy(l2 ? t2[n3] : I))), i2.set(n3, a3)), void 0 !== a3
) {
var c2 = get$1(a3);
return c2 === I ? void 0 : c2;
}
return Reflect.get(t2, n3, s3);
},
getOwnPropertyDescriptor(e3, t2) {
var n3 = Reflect.getOwnPropertyDescriptor(e3, t2);
if (n3 && "value" in n3) {
var s3 = i2.get(t2);
s3 && (n3.value = get$1(s3));
} else if (void 0 === n3) {
var o2 = i2.get(t2), a3 = o2 == null ? void 0 : o2.v;
if (void 0 !== o2 && a3 !== I) return {
enumerable: true,
configurable: true,
value: a3,
writable: true
};
}
return n3;
},
has(e3, t2) {
var _a2;
if (t2 === C) return true;
var n3 = i2.get(t2), s3 = void 0 !== n3 && n3.v !== I || Reflect.has(e3, t2);
if ((void 0 !== n3 || null !== V && (!s3 || ((_a2 = o(e3, t2)) == null ? void 0 : _a2.writable))) && (void 0 === n3 && (n3 = with_parent(() => state(s3 ? proxy(e3[t2]) : I)), i2.set(t2, n3)), get$1(n3) === I)) return false;
return s3;
},
set(e3, t2, n3, s3) {
var _a2;
var l2 = i2.get(t2), c2 = t2 in e3;
if (a2 && "length" === t2) for (var u2 = n3; u2 < /** @type {Source<number>} */
l2.v; u2 += 1) {
var f3 = i2.get(u2 + "");
void 0 !== f3 ? set(f3, I) : u2 in e3 && // If the item exists in the original, we need to create a uninitialized source,
// else a later read of the property would result in a source being created with
// the value of the original item at that index.
(f3 = with_parent(() => state(I)), i2.set(u2 + "", f3));
}
void 0 === l2 ? c2 && !((_a2 = o(e3, t2)) == null ? void 0 : _a2.writable) || (set(l2 = with_parent(() => state(void 0)), with_parent(() => proxy(n3))), i2.set(t2, l2)) : (c2 = l2.v !== I, set(l2, with_parent(() => proxy(n3))));
var p2 = Reflect.getOwnPropertyDescriptor(e3, t2);
if ((p2 == null ? void 0 : p2.set) && p2.set.call(s3, n3), !c2) {
if (a2 && "string" == typeof t2) {
var g2 = (
/** @type {Source<number>} */
i2.get("length")
), _2 = Number(t2);
Number.isInteger(_2) && _2 >= g2.v && set(g2, _2 + 1);
}
update_version(d2);
}
return true;
},
ownKeys(e3) {
get$1(d2);
var t2 = Reflect.ownKeys(e3).filter((e4) => {
var t3 = i2.get(e4);
return void 0 === t3 || t3.v !== I;
});
for (var [n3, s3] of i2) s3.v === I || n3 in e3 || t2.push(n3);
return t2;
},
setPrototypeOf() {
!function state_prototype_fixed() {
throw new Error("https://svelte.dev/e/state_prototype_fixed");
}();
}
}
);
}
function update_version(e2, t2 = 1) {
set(e2, e2.v + t2);
}
const q = /* @__PURE__ */ new Map();
function source(e2, t2) {
return {
f: 0,
// TODO ideally we could skip this altogether, but it causes type errors
v: e2,
reactions: null,
equals,
rv: 0,
wv: 0
};
}
function state(e2, t2) {
const n2 = source(e2);
return push_reaction_value(n2), n2;
}
// @__NO_SIDE_EFFECTS__
function mutable_source(e2, t2 = false) {
var _a2;
const n2 = source(e2);
return t2 || (n2.equals = safe_equals), // bind the signal to the component context, in case we need to
// track updates to trigger beforeUpdate/afterUpdate callbacks
T && null !== O && null !== O.l && ((_a2 = O.l).s ?? (_a2.s = [])).push(n2), n2;
}
function set(e2, t2, n2 = false) {
return null !== R && !U && is_runes() && 18 & R.f && !(K == null ? void 0 : K.includes(e2)) && function state_unsafe_mutation() {
throw new Error("https://svelte.dev/e/state_unsafe_mutation");
}(), internal_set(e2, n2 ? proxy(t2) : t2);
}
function internal_set(e2, t2) {
if (!e2.equals(t2)) {
var n2 = e2.v;
F ? q.set(e2, t2) : q.set(e2, n2), e2.v = t2, e2.wv = increment_write_version(), mark_reactions(e2, m), // It's possible that the current reaction might not have up-to-date dependencies
// whilst it's actively running. So in the case of ensuring it registers the reaction
// properly for itself, we need to ensure the current effect actually gets
// scheduled. i.e: `$effect(() => x++)`
is_runes() && null !== V && V.f & h && !(96 & V.f) && (null === J ? (
/** @param {null | Source[]} value */
function set_untracked_writes(e3) {
J = e3;
}([e2])
) : J.push(e2));
}
return t2;
}
function update(e2, t2 = 1) {
var n2 = get$1(e2), s2 = 1 === t2 ? n2++ : n2--;
return set(e2, n2), s2;
}
function mark_reactions(e2, t2) {
var n2 = e2.reactions;
if (null !== n2) for (var s2 = is_runes(), i2 = n2.length, o2 = 0; o2 < i2; o2++) {
var a2 = n2[o2], l2 = a2.f;
l2 & m || // In legacy mode, skip the current effect to prevent infinite loops
(s2 || a2 !== V) && (set_signal_status(a2, t2), // If the signal a) was previously clean or b) is an unowned derived, then mark it
1280 & l2 && (2 & l2 ? mark_reactions(
/** @type {Derived} */
a2,
b
) : schedule_effect(
/** @type {Effect} */
a2
)));
}
}
var P, z, W, j, D;
function create_text(e2 = "") {
return document.createTextNode(e2);
}
// @__NO_SIDE_EFFECTS__
function get_first_child(e2) {
return j.call(e2);
}
// @__NO_SIDE_EFFECTS__
function get_next_sibling(e2) {
return D.call(e2);
}
function child(e2, t2) {
return /* @__PURE__ */ get_first_child(e2);
}
function first_child(e2, t2) {
var n2 = (
/** @type {DocumentFragment} */
/* @__PURE__ */ get_first_child(
/** @type {Node} */
e2
)
);
return n2 instanceof Comment && "" === n2.data ? /* @__PURE__ */ get_next_sibling(n2) : n2;
}
function sibling(e2, t2 = 1, n2 = false) {
let s2 = e2;
for (; t2--; ) s2 = /** @type {TemplateNode} */
/* @__PURE__ */ get_next_sibling(s2);
return s2;
}
// @__NO_SIDE_EFFECTS__
function derived(e2) {
var t2 = 2050, n2 = null !== R && 2 & R.f ? (
/** @type {Derived} */
R
) : null;
null === V || null !== n2 && n2.f & _ ? t2 |= _ : (
// Since deriveds are evaluated lazily, any effects created inside them are
// created too late to ensure that the parent effect is added to the tree
V.f |= x
);
return {
ctx: O,
deps: null,
effects: null,
equals,
f: t2,
fn: e2,
reactions: null,
rv: 0,
v: (
/** @type {V} */
null
),
wv: 0,
parent: n2 ?? V
};
}
function user_derived(e2) {
const t2 = /* @__PURE__ */ derived(e2);
return push_reaction_value(t2), t2;
}
// @__NO_SIDE_EFFECTS__
function derived_safe_equal(e2) {
const t2 = /* @__PURE__ */ derived(e2);
return t2.equals = safe_equals, t2;
}
function destroy_derived_effects(e2) {
var t2 = e2.effects;
if (null !== t2) {
e2.effects = null;
for (var n2 = 0; n2 < t2.length; n2 += 1) destroy_effect(
/** @type {Effect} */
t2[n2]
);
}
}
function update_derived(e2) {
var t2 = (
/**
* @template T
* @param {Derived} derived
* @returns {T}
*/
function execute_derived(e3) {
var t3, n2 = V;
set_active_effect(function get_derived_parent_effect(e4) {
for (var t4 = e4.parent; null !== t4; ) {
if (!(2 & t4.f))
return t4;
t4 = t4.parent;
}
return null;
}(e3));
try {
destroy_derived_effects(e3), t3 = update_reaction(e3);
} finally {
set_active_effect(n2);
}
return t3;
}(e2)
);
set_signal_status(e2, (te || e2.f & _) && null !== e2.deps ? b : h), e2.equals(t2) || (e2.v = t2, e2.wv = increment_write_version());
}
function validate_effect(e2) {
null === V && null === R && /**
* `%rune%` can only be used inside an effect (e.g. during component initialisation)
* @param {string} rune
* @returns {never}
*/
function effect_orphan(e3) {
throw new Error("https://svelte.dev/e/effect_orphan");
}(), null !== R && R.f & _ && null === V && /**
* Effect cannot be created inside a `$derived` value that was not itself created inside an effect
* @returns {never}
*/
function effect_in_unowned_derived() {
throw new Error("https://svelte.dev/e/effect_in_unowned_derived");
}(), F && function effect_in_teardown(e3) {
throw new Error("https://svelte.dev/e/effect_in_teardown");
}();
}
function create_effect(e2, t2, n2, s2 = true) {
var i2 = V, o2 = {
ctx: O,
deps: null,
nodes_start: null,
nodes_end: null,
f: e2 | m,
first: null,
fn: t2,
last: null,
next: null,
parent: i2,
prev: null,
teardown: null,
transitions: null,
wv: 0
};
if (n2) try {
update_effect(o2), o2.f |= 32768;
} catch (e3) {
throw destroy_effect(o2), e3;
}
else null !== t2 && schedule_effect(o2);
if (!(n2 && null === o2.deps && null === o2.first && null === o2.nodes_start && null === o2.teardown && !(1048704 & o2.f)) && s2 && (null !== i2 && function push_effect(e3, t3) {
var n3 = t3.last;
null === n3 ? t3.last = t3.first = e3 : (n3.next = e3, e3.prev = n3, t3.last = e3);
}(o2, i2), null !== R && 2 & R.f)) {
var a2 = (
/** @type {Derived} */
R
);
(a2.effects ?? (a2.effects = [])).push(o2);
}
return o2;
}
function teardown(e2) {
const t2 = create_effect(8, null, false);
return set_signal_status(t2, h), t2.teardown = e2, t2;
}
function user_effect(e2) {
if (validate_effect(), !(null !== V && !!(V.f & f) && null !== O && !O.m)) return effect(e2);
var t2 = (
/** @type {ComponentContext} */
O
);
(t2.e ?? (t2.e = [])).push({
fn: e2,
effect: V,
reaction: R
});
}
function effect(e2) {
return create_effect(4, e2, false);
}
function legacy_pre_effect(e2, t2) {
var n2 = (
/** @type {ComponentContextLegacy} */
O
), s2 = {
effect: null,
ran: false
};
n2.l.r1.push(s2), s2.effect = render_effect(() => {
e2(), // If this legacy pre effect has already run before the end of the reset, then
// bail out to emulate the same behavior.
s2.ran || (s2.ran = true, set(n2.l.r2, true), untrack(t2));
});
}
function legacy_pre_effect_reset() {
var e2 = (
/** @type {ComponentContextLegacy} */
O
);
render_effect(() => {
if (get$1(e2.l.r2)) {
for (var t2 of e2.l.r1) {
var n2 = t2.effect;
n2.f & h && set_signal_status(n2, b), check_dirtiness(n2) && update_effect(n2), t2.ran = false;
}
e2.l.r2.v = false;
}
});
}
function render_effect(e2) {
return create_effect(8, e2, true);
}
function template_effect(e2, t2 = [], n2 = derived) {
const s2 = t2.map(n2);
return block(() => e2(...s2.map(get$1)));
}
function block(e2, t2 = 0) {
return create_effect(24 | t2, e2, true);
}
function branch(e2, t2 = true) {
return create_effect(40, e2, true, t2);
}
function execute_effect_teardown(e2) {
var t2 = e2.teardown;
if (null !== t2) {
const e3 = F, n2 = R;
set_is_destroying_effect(true), set_active_reaction(null);
try {
t2.call(null);
} finally {
set_is_destroying_effect(e3), set_active_reaction(n2);
}
}
}
function destroy_effect_children(e2, t2 = false) {
var n2 = e2.first;
for (e2.first = e2.last = null; null !== n2; ) {
var s2 = n2.next;
n2.f & p ? (
// this is now an independent root
n2.parent = null
) : destroy_effect(n2, t2), n2 = s2;
}
}
function destroy_effect(e2, t2 = true) {
var n2 = false;
if ((t2 || 524288 & e2.f) && null !== e2.nodes_start) {
for (var s2 = e2.nodes_start, i2 = e2.nodes_end; null !== s2; ) {
var o2 = s2 === i2 ? null : (
/** @type {TemplateNode} */
/* @__PURE__ */ get_next_sibling(s2)
);
s2.remove(), s2 = o2;
}
n2 = true;
}
destroy_effect_children(e2, t2 && !n2), remove_reactions(e2, 0), set_signal_status(e2, $);
var a2 = e2.transitions;
if (null !== a2) for (const e3 of a2) e3.stop();
execute_effect_teardown(e2);
var l2 = e2.parent;
null !== l2 && null !== l2.first && unlink_effect(e2), // `first` and `child` are nulled out in destroy_effect_children
// we don't null out `parent` so that error propagation can work correctly
e2.next = e2.prev = e2.teardown = e2.ctx = e2.deps = e2.fn = e2.nodes_start = e2.nodes_end = null;
}
function unlink_effect(e2) {
var t2 = e2.parent, n2 = e2.prev, s2 = e2.next;
null !== n2 && (n2.next = s2), null !== s2 && (s2.prev = n2), null !== t2 && (t2.first === e2 && (t2.first = s2), t2.last === e2 && (t2.last = n2));
}
function pause_effect(e2, t2) {
var n2 = [];
pause_children(e2, n2, true), run_out_transitions(n2, () => {
destroy_effect(e2), t2 && t2();
});
}
function run_out_transitions(e2, t2) {
var n2 = e2.length;
if (n2 > 0) {
var check = () => --n2 || t2();
for (var s2 of e2) s2.out(check);
} else t2();
}
function pause_children(e2, t2, n2) {
if (!(e2.f & y)) {
if (e2.f ^= y, null !== e2.transitions) for (const s3 of e2.transitions) (s3.is_global || n2) && t2.push(s3);
for (var s2 = e2.first; null !== s2; ) {
var i2 = s2.next;
pause_children(s2, t2, !!(!!(s2.f & w) || !!(s2.f & f)) && n2), s2 = i2;
}
}
}
function resume_effect(e2) {
resume_children(e2, true);
}
function resume_children(e2, t2) {
if (e2.f & y) {
e2.f ^= y, // Ensure the effect is marked as clean again so that any dirty child
// effects can schedule themselves for execution
e2.f & h || (e2.f ^= h), // If a dependency of this effect changed while it was paused,
// schedule the effect to update
check_dirtiness(e2) && (set_signal_status(e2, m), schedule_effect(e2));
for (var n2 = e2.first; null !== n2; ) {
var s2 = n2.next;
resume_children(n2, !!(!!(n2.f & w) || !!(n2.f & f)) && t2), n2 = s2;
}
if (null !== e2.transitions) for (const n3 of e2.transitions) (n3.is_global || t2) && n3.in();
}
}
let N = [], B = [];
function run_micro_tasks() {
var e2 = N;
N = [], run_all(e2);
}
function queue_micro_task(e2) {
0 === N.length && queueMicrotask(run_micro_tasks), N.push(e2);
}
function flush_tasks() {
N.length > 0 && run_micro_tasks(), B.length > 0 && function run_idle_tasks() {
var e2 = B;
B = [], run_all(e2);
}();
}
let E = false, A = false, L = null, G = false, F = false;
function set_is_destroying_effect(e2) {
F = e2;
}
let H = [], R = null, U = false;
function set_active_reaction(e2) {
R = e2;
}
let V = null;
function set_active_effect(e2) {
V = e2;
}
let K = null;
function push_reaction_value(e2) {
null !== R && R.f & k && (null === K ? function set_reaction_sources(e3) {
K = e3;
}([e2]) : K.push(e2));
}
let Y = null, Z = 0, J = null;
let Q = 1, ee = 0, te = false;
function increment_write_version() {
return ++Q;
}
function check_dirtiness(e2) {
var _a2;
var t2 = e2.f;
if (t2 & m) return true;
if (t2 & b) {
var n2 = e2.deps, s2 = !!(t2 & _);
if (null !== n2) {
var i2, o2, a2 = !!(t2 & v), l2 = s2 && null !== V && !te, c2 = n2.length;
if (a2 || l2) {
var u2 = (
/** @type {Derived} */
e2
), d2 = u2.parent;
for (i2 = 0; i2 < c2; i2++) o2 = n2[i2], // We always re-add all reactions (even duplicates) if the derived was
// previously disconnected, however we don't if it was unowned as we
// de-duplicate dependencies in that case
!a2 && ((_a2 = o2 == null ? void 0 : o2.reactions) == null ? void 0 : _a2.includes(u2)) || (o2.reactions ?? (o2.reactions = [])).push(u2);
a2 && (u2.f ^= v), // If the unowned derived is now fully connected to the graph again (it's unowned and reconnected, has a parent
// and the parent is not unowned), then we can mark it as connected again, removing the need for the unowned
// flag
!l2 || null === d2 || d2.f & _ || (u2.f ^= _);
}
for (i2 = 0; i2 < c2; i2++) if (check_dirtiness(o2 = n2[i2]) && update_derived(
/** @type {Derived} */
o2
), o2.wv > e2.wv) return true;
}
s2 && (null === V || te) || set_signal_status(e2, h);
}
return false;
}
function handle_error(e2, t2, n2, s2) {
if (E) {
if (null === n2 && (E = false), /**
* @param {Effect} effect
*/
function should_rethrow_error(e3) {
return !(e3.f & $ || null !== e3.parent && e3.parent.f & g);
}(t2)) throw e2;
} else null !== n2 && (E = true), function propagate_error(e3, t3) {
for (var n3 = t3; null !== n3; ) {
if (n3.f & g) try {
return void n3.fn(e3);
} catch {
n3.f ^= g;
}
n3 = n3.parent;
}
throw E = false, e3;
}(e2, t2);
}
function schedule_possible_effect_self_invalidation(e2, t2, n2 = true) {
var s2 = e2.reactions;
if (null !== s2) for (var i2 = 0; i2 < s2.length; i2++) {
var o2 = s2[i2];
(K == null ? void 0 : K.includes(e2)) || (2 & o2.f ? schedule_possible_effect_self_invalidation(
/** @type {Derived} */
o2,
t2,
false
) : t2 === o2 && (n2 ? set_signal_status(o2, m) : o2.f & h && set_signal_status(o2, b), schedule_effect(
/** @type {Effect} */
o2
)));
}
}
function update_reaction(e2) {
var _a2;
var t2 = Y, n2 = Z, s2 = J, i2 = R, o2 = te, a2 = K, l2 = O, c2 = U, u2 = e2.f;
Y = /** @type {null | Value[]} */
null, Z = 0, J = null, te = !!(u2 & _) && (U || !G || null === R), R = 96 & u2 ? null : e2, K = null, set_component_context(e2.ctx), U = false, ee++, e2.f |= k;
try {
var d2 = (
/** @type {Function} */
/** @type {Function} */
(0, e2.fn)()
), f2 = e2.deps;
if (null !== Y) {
var p2;
if (remove_reactions(e2, Z), null !== f2 && Z > 0) for (f2.length = Z + Y.length, p2 = 0; p2 < Y.length; p2++) f2[Z + p2] = Y[p2];
else e2.deps = f2 = Y;
if (!te) for (p2 = Z; p2 < f2.length; p2++) ((_a2 = f2[p2]).reactions ?? (_a2.reactions = [])).push(e2);
} else null !== f2 && Z < f2.length && (remove_reactions(e2, Z), f2.length = Z);
if (is_runes() && null !== J && !U && null !== f2 && !(6146 & e2.f)) for (p2 = 0; p2 < /** @type {Source[]} */
J.length; p2++) schedule_possible_effect_self_invalidation(
J[p2],
/** @type {Effect} */
e2
);
return null !== i2 && (ee++, null !== J && (null === s2 ? s2 = J : s2.push(.../** @type {Source[]} */
J))), d2;
} finally {
Y = t2, Z = n2, J = s2, R = i2, te = o2, K = a2, set_component_context(l2), U = c2, e2.f ^= k;
}
}
function remove_reaction(e2, t2) {
let s2 = t2.reactions;
if (null !== s2) {
var i2 = n.call(s2, e2);
if (-1 !== i2) {
var o2 = s2.length - 1;
0 === o2 ? s2 = t2.reactions = null : (
// Swap with last element and then remove.
(s2[i2] = s2[o2], s2.pop())
);
}
}
null === s2 && 2 & t2.f && // 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
(null === Y || !Y.includes(t2)) && (set_signal_status(t2, b), // If we are working with a derived that is owned by an effect, then mark it as being
// disconnected.
768 & t2.f || (t2.f ^= v), // Disconnect any reactions owned by this reaction
destroy_derived_effects(
/** @type {Derived} **/
t2
), remove_reactions(
/** @type {Derived} **/
t2,
0
));
}
function remove_reactions(e2, t2) {
var n2 = e2.deps;
if (null !== n2) for (var s2 = t2; s2 < n2.length; s2++) remove_reaction(e2, n2[s2]);
}
function update_effect(t2) {
var n2 = t2.f;
if (!(n2 & $)) {
set_signal_status(t2, h);
var s2 = V, i2 = O, o2 = G;
V = t2, G = true;
try {
16 & n2 ? function destroy_block_effect_children(e2) {
for (var t3 = e2.first; null !== t3; ) {
var n3 = t3.next;
t3.f & f || destroy_effect(t3), t3 = n3;
}
}(t2) : destroy_effect_children(t2), execute_effect_teardown(t2);
var a2 = update_reaction(t2);
t2.teardown = "function" == typeof a2 ? a2 : null, t2.wv = Q;
t2.deps;
e;
} catch (e2) {
handle_error(e2, t2, s2, i2 || t2.ctx);
} finally {
G = o2, V = s2;
}
}
}
function infinite_loop_guard() {
try {
!function effect_update_depth_exceeded() {
throw new Error("https://svelte.dev/e/effect_update_depth_exceeded");
}();
} catch (e2) {
if (null === L) throw e2;
handle_error(e2, L, null);
}
}
function flush_queued_root_effects() {
var e2 = G;
try {
var t2 = 0;
for (G = true; H.length > 0; ) {
t2++ > 1e3 && infinite_loop_guard();
var n2 = H, s2 = n2.length;
H = [];
for (var i2 = 0; i2 < s2; i2++) {
flush_queued_effects(process_effects(n2[i2]));
}
}
} finally {
A = false, G = e2, L = null, q.clear();
}
}
function flush_queued_effects(e2) {
var t2 = e2.length;
if (0 !== t2) for (var n2 = 0; n2 < t2; n2++) {
var s2 = e2[n2];
if (!(24576 & s2.f)) try {
check_dirtiness(s2) && (update_effect(s2), // Effects with no dependencies or teardown do not get added to the effect tree.
// Deferred effects (e.g. `$effect(...)`) _are_ added to the tree because we
// don't know if we need to keep them until they are executed. Doing the check
// here (rather than in `update_effect`) allows us to skip the work for
// immediate effects.
null === s2.deps && null === s2.first && null === s2.nodes_start && (null === s2.teardown ? (
// remove this effect from the graph
unlink_effect(s2)
) : (
// keep the effect in the graph, but free up some memory
s2.fn = null
)));
} catch (e3) {
handle_error(e3, s2, null, s2.ctx);
}
}
}
function schedule_effect(e2) {
A || (A = true, queueMicrotask(flush_queued_root_effects));
for (var t2 = L = e2; null !== t2.parent; ) {
var n2 = (t2 = t2.parent).f;
if (96 & n2) {
if (!(n2 & h)) return;
t2.f ^= h;
}
}
H.push(t2);
}
function process_effects(e2) {
for (var t2 = [], n2 = e2; null !== n2; ) {
var s2 = n2.f, i2 = !!(96 & s2);
if (!(i2 && !!(s2 & h) || s2 & y)) {
if (4 & s2) t2.push(n2);
else if (i2) n2.f ^= h;
else {
var o2 = R;
try {
R = n2, check_dirtiness(n2) && update_effect(n2);
} catch (e3) {
handle_error(e3, n2, null, n2.ctx);
} finally {
R = o2;
}
}
var a2 = n2.first;
if (null !== a2) {
n2 = a2;
continue;
}
}
var l2 = n2.parent;
for (n2 = n2.next; null === n2 && null !== l2; ) n2 = l2.next, l2 = l2.parent;
}
return t2;
}
async function tick() {
await Promise.resolve(), // By calling flushSync we guarantee that any pending state changes are applied after one tick.
// TODO look into whether we can make flushing subsequent updates synchronously in the future.
function flushSync(e2) {
for (flush_tasks(); H.length > 0; ) A = true, flush_queued_root_effects(), flush_tasks();
}();
}
function get$1(e2) {
var t2 = !!(2 & e2.f);
if (null === R || U) {
if (t2 && /** @type {Derived} */
null === e2.deps && /** @type {Derived} */
null === e2.effects) {
var n2 = (
/** @type {Derived} */
e2
), s2 = n2.parent;
null === s2 || s2.f & _ || // If the derived is owned by another derived then mark it as unowned
// as the derived value might have been referenced in a different context
// since and thus its parent might not be its true owner anymore
(n2.f ^= _);
}
} else if (!(K == null ? void 0 : K.includes(e2))) {
var i2 = R.deps;
e2.rv < ee && (e2.rv = ee, // If the signal is accessing the same dependencies in the same
// order as it did last time, increment `skipped_deps`
// rather than updating `new_deps`, which creates GC cost
null === Y && null !== i2 && i2[Z] === e2 ? Z++ : null === Y ? Y = [e2] : te && Y.includes(e2) || // Normally we can push duplicated dependencies to `new_deps`, but if we're inside
// an unowned derived because skip_reaction is true, then we need to ensure that
// we don't have duplicates
Y.push(e2));
}
return t2 && check_dirtiness(n2 = /** @type {Derived} */
e2) && update_derived(n2), F && q.has(e2) ? q.get(e2) : e2.v;
}
function untrack(e2) {
var t2 = U;
try {
return U = true, e2();
} finally {
U = t2;
}
}
const ne = -7169;
function set_signal_status(e2, t2) {
e2.f = e2.f & ne | t2;
}
function deep_read_state(e2) {
if ("object" == typeof e2 && e2 && !(e2 instanceof EventTarget)) {
if (C in e2) deep_read(e2);
else if (!Array.isArray(e2)) for (let t2 in e2) {
const n2 = e2[t2];
"object" == typeof n2 && n2 && C in n2 && deep_read(n2);
}
}
}
function deep_read(e2, t2 = /* @__PURE__ */ new Set()) {
if (!("object" != typeof e2 || null === e2 || e2 instanceof EventTarget || t2.has(e2))) {
t2.add(e2), // When working with a possible SvelteDate, this
// will ensure we capture changes to it.
e2 instanceof Date && e2.getTime();
for (let n3 in e2) try {
deep_read(e2[n3], t2);
} catch (e3) {
}
const n2 = u(e2);
if (n2 !== Object.prototype && n2 !== Array.prototype && n2 !== Map.prototype && n2 !== Set.prototype && n2 !== Date.prototype) {
const t3 = a(n2);
for (let n3 in t3) {
const s2 = t3[n3].get;
if (s2) try {
s2.call(e2);
} catch (e3) {
}
}
}
}
}
function is_capture_event(e2) {
return e2.endsWith("capture") && "gotpointercapture" !== e2 && "lostpointercapture" !== e2;
}
const re = ["beforeinput", "click", "change", "dblclick", "contextmenu", "focusin", "focusout", "input", "keydown", "keyup", "mousedown", "mousemove", "mouseout", "mouseover", "mouseup", "pointerdown", "pointermove", "pointerout", "pointerover", "pointerup", "touchend", "touchmove", "touchstart"];
function is_delegated(e2) {
return re.includes(e2);
}
const se = {
// no `class: 'className'` because we handle that separately
formnovalidate: "formNoValidate",
ismap: "isMap",
nomodule: "noModule",
playsinline: "playsInline",
readonly: "readOnly",
defaultvalue: "defaultValue",
defaultchecked: "defaultChecked",
srcobject: "srcObject",
novalidate: "noValidate",
allowfullscreen: "allowFullscreen",
disablepictureinpicture: "disablePictureInPicture",
disableremoteplayback: "disableRemotePlayback"
};
function normalize_attribute(e2) {
return e2 = e2.toLowerCase(), se[e2] ?? e2;
}
const ie = ["touchstart", "touchmove"];
function is_passive_event(e2) {
return ie.includes(e2);
}
function autofocus(e2, t2) {
if (t2) {
const t3 = document.body;
e2.autofocus = true, queue_micro_task(() => {
document.activeElement === t3 && e2.focus();
});
}
}
let oe = false;
function without_reactive_context(e2) {
var t2 = R, n2 = V;
set_active_reaction(null), set_active_effect(null);
try {
return e2();
} finally {
set_active_reaction(t2), set_active_effect(n2);
}
}
function listen_to_event_and_reset_event(e2, t2, n2, s2 = n2) {
e2.addEventListener(t2, () => without_reactive_context(n2));
const i2 = e2.__on_r;
e2.__on_r = i2 ? () => {
i2(), s2(true);
} : () => s2(true), function add_form_reset_listener() {
oe || (oe = true, document.addEventListener(
"reset",
(e3) => {
Promise.resolve().then(() => {
var _a2;
if (!e3.defaultPrevented) for (
const t3 of
/**@type {HTMLFormElement} */
e3.target.elements
)
(_a2 = t3.__on_r) == null ? void 0 : _a2.call(t3);
});
},
// In the capture phase to guarantee we get noticed of it (no possiblity of stopPropagation)
{
capture: true
}
));
}();
}
const ae = /* @__PURE__ */ new Set(), le = /* @__PURE__ */ new Set();
function create_event(e2, t2, n2, s2 = {}) {
function target_handler(e3) {
if (s2.capture || // Only call in the bubble phase, else delegated events would be called before the capturing events
handle_event_propagation.call(t2, e3), !e3.cancelBubble) return without_reactive_context(() => n2 == null ? void 0 : n2.call(this, e3));
}
return e2.startsWith("pointer") || e2.startsWith("touch") || "wheel" === e2 ? queue_micro_task(() => {
t2.addEventListener(e2, target_handler, s2);
}) : t2.addEventListener(e2, target_handler, s2), target_handler;
}
function event(e2, t2, n2, s2, i2) {
var o2 = {
capture: s2,
passive: i2
}, a2 = create_event(e2, t2, n2, o2);
t2 !== document.body && t2 !== window && t2 !== document || teardown(() => {
t2.removeEventListener(e2, a2, o2);
});
}
function delegate(e2) {
for (var t2 = 0; t2 < e2.length; t2++) ae.add(e2[t2]);
for (var n2 of le) n2(e2);
}
function handle_event_propagation(e2) {
var _a2;
var n2 = this, s2 = (
/** @type {Node} */
n2.ownerDocument
), o2 = e2.type, a2 = ((_a2 = e2.composedPath) == null ? void 0 : _a2.call(e2)) || [], l2 = (
/** @type {null | Element} */
a2[0] || e2.target
), c2 = 0, u2 = e2.__root;
if (u2) {
var d2 = a2.indexOf(u2);
if (-1 !== d2 && (n2 === document || n2 === /** @type {any} */
window))
return void (e2.__root = n2);
var f2 = a2.indexOf(n2);
if (-1 === f2)
return;
d2 <= f2 && (c2 = d2);
}
if ((l2 = /** @type {Element} */
a2[c2] || e2.target) !== n2) {
i(e2, "currentTarget", {
configurable: true,
get: () => l2 || s2
});
var p2 = R, g2 = V;
set_active_reaction(null), set_active_effect(null);
try {
for (var _2, v2 = []; null !== l2; ) {
var h2 = l2.assignedSlot || l2.parentNode || /** @type {any} */
l2.host || null;
try {
var m2 = l2["__" + o2];
if (null != m2 && (!/** @type {any} */
l2.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
e2.target === l2)) if (t(m2)) {
var [b2, ...y2] = m2;
b2.apply(l2, [e2, ...y2]);
} else m2.call(l2, e2);
} catch (e3) {
_2 ? v2.push(e3) : _2 = e3;
}
if (e2.cancelBubble || h2 === n2 || null === h2) break;
l2 = h2;
}
if (_2) {
for (let e3 of v2)
queueMicrotask(() => {
throw e3;
});
throw _2;
}
} finally {
e2.__root = n2, // @ts-ignore remove proxy on currentTarget
delete e2.currentTarget, set_active_reaction(p2), set_active_effect(g2);
}
}
}
function create_fragment_from_html(e2) {
var t2 = document.createElement("template");
return t2.innerHTML = e2, t2.content;
}
function assign_nodes(e2, t2) {
var n2 = (
/** @type {Effect} */
V
);
null === n2.nodes_start && (n2.nodes_start = e2, n2.nodes_end = t2);
}
// @__NO_SIDE_EFFECTS__
function template(e2, t2) {
var n2, s2 = !!(1 & t2), i2 = !!(2 & t2), o2 = !e2.startsWith("<!>");
return () => {
void 0 === n2 && (n2 = create_fragment_from_html(o2 ? e2 : "<!>" + e2), s2 || (n2 = /** @type {Node} */
/* @__PURE__ */ get_first_child(n2)));
var t3 = (
/** @type {TemplateNode} */
i2 || W ? document.importNode(n2, true) : n2.cloneNode(true)
);
s2 ? assign_nodes(
/** @type {TemplateNode} */
/* @__PURE__ */ get_first_child(t3),
/** @type {TemplateNode} */
t3.lastChild
) : assign_nodes(t3, t3);
return t3;
};
}
// @__NO_SIDE_EFFECTS__
function ns_template(e2, t2, n2 = "svg") {
var s2, i2 = `<${n2}>${!e2.startsWith("<!>") ? e2 : "<!>" + e2}</${n2}>`;
return () => {
if (!s2) {
var e3 = (
/** @type {Element} */
/* @__PURE__ */ get_first_child(
/** @type {DocumentFragment} */
create_fragment_from_html(i2)
)
);
s2 = /** @type {Element} */
/* @__PURE__ */ get_first_child(e3);
}
var t3 = (
/** @type {TemplateNode} */
s2.cloneNode(true)
);
return assign_nodes(t3, t3), t3;
};
}
function text(e2 = "") {
var t2 = create_text(e2 + "");
return assign_nodes(t2, t2), t2;
}
function comment() {
var e2 = document.createDocumentFragment(), t2 = document.createComment(""), n2 = create_text();
return e2.append(t2, n2), assign_nodes(t2, n2), e2;
}
function append(e2, t2) {
null !== e2 && e2.before(
/** @type {Node} */
t2
);
}
let ce = true;
function set_should_intro(e2) {
ce = e2;
}
function set_text(e2, t2) {
var n2 = null == t2 ? "" : "object" == typeof t2 ? t2 + "" : t2;
n2 !== (e2.__t ?? (e2.__t = e2.nodeValue)) && // @ts-expect-error
(e2.__t = n2, e2.nodeValue = n2 + "");
}
function mount(e2, t2) {
return function _mount(e3, { target: t3, anchor: n2, props: i2 = {}, events: a2, context: l2, intro: c2 = true }) {
!/**
* Initialize these lazily to avoid issues when using the runtime in a server context
* where these globals are not available while avoiding a separate server entry point
*/
function init_operations() {
if (void 0 === P) {
P = window, z = document, W = /Firefox/.test(navigator.userAgent);
var e4 = Element.prototype, t4 = Node.prototype, n3 = Text.prototype;
j = o(t4, "firstChild").get, // @ts-ignore
D = o(t4, "nextSibling").get, d(e4) && // the following assignments improve perf of lookups on DOM nodes
// @ts-expect-error
(e4.__click = void 0, // @ts-expect-error
e4.__className = void 0, // @ts-expect-error
e4.__attributes = null, // @ts-expect-error
e4.__style = void 0, // @ts-expect-error
e4.__e = void 0), d(n3) && // @ts-expect-error
(n3.__t = void 0);
}
}();
var u2 = /* @__PURE__ */ new Set(), event_handle = (e4) => {
for (var n3 = 0; n3 < e4.length; n3++) {
var s2 = e4[n3];
if (!u2.has(s2)) {
u2.add(s2);
var i3 = is_passive_event(s2);
t3.addEventListener(s2, handle_event_propagation, {
passive: i3
});
var o2 = ue.get(s2);
void 0 === o2 ? (
// The document listener ensures we catch events that originate from elements that were
// manually moved outside of the container (e.g. via manual portals).
(document.addEventListener(s2, handle_event_propagation, {
passive: i3
}), ue.set(s2, 1))
) : ue.set(s2, o2 + 1);
}
}
};
event_handle(s(ae)), le.add(event_handle);
var f2 = void 0, g2 = (
/**
* An effect root whose children can transition out
* @param {() => void} fn
* @returns {(options?: { outro?: boolean }) => Promise<void>}
*/
function component_root(e4) {
const t4 = create_effect(p, e4, true);
return (e5 = {}) => new Promise((n3) => {
e5.outro ? pause_effect(t4, () => {
destroy_effect(t4), n3(void 0);
}) : (destroy_effect(t4), n3(void 0));
});
}(() => {
var s2 = n2 ?? t3.appendChild(create_text());
return branch(() => {
l2 && (push({}), /** @type {ComponentContext} */
O.c = l2);
a2 && // We can't spread the object or else we'd lose the state proxy stuff, if it is one
/** @type {any} */
(i2.$$events = a2), ce = c2, // @ts-expect-error the public typings are not what the actual function looks like
f2 = e3(s2, i2) || {}, ce = true, l2 && pop();
}), () => {
var _a2;
for (var e4 of u2) {
t3.removeEventListener(e4, handle_event_propagation);
var i3 = (
/** @type {number} */
ue.get(e4)
);
0 == --i3 ? (document.removeEventListener(e4, handle_event_propagation), ue.delete(e4)) : ue.set(e4, i3);
}
le.delete(event_handle), s2 !== n2 && ((_a2 = s2.parentNode) == null ? void 0 : _a2.removeChild(s2));
};
})
);
return de.set(f2, g2), f2;
}(e2, t2);
}
const ue = /* @__PURE__ */ new Map();
let de = /* @__PURE__ */ new WeakMap();
function if_block(e2, t2, [n2, s2] = [0, 0]) {
var i2 = e2, o2 = null, a2 = null, l2 = I, c2 = false;
const set_branch = (e3, t3 = true) => {
c2 = true, update_branch(t3, e3);
}, update_branch = (e3, t3) => {
l2 !== (l2 = e3) && (l2 ? (o2 ? resume_effect(o2) : t3 && (o2 = branch(() => t3(i2))), a2 && pause_effect(a2, () => {
a2 = null;
})) : (a2 ? resume_effect(a2) : t3 && (a2 = branch(() => t3(i2, [n2 + 1, s2]))), o2 && pause_effect(o2, () => {
o2 = null;
})));
};
block(() => {
c2 = false, t2(set_branch), c2 || update_branch(null, null);
}, n2 > 0 ? w : 0);
}
let fe = null;
function set_current_each_item(e2) {
fe = e2;
}
function index(e2, t2) {
return t2;
}
function each(e2, n2, i2, o2, a2, l2 = null) {
var c2 = e2, u2 = {
flags: n2,
items: /* @__PURE__ */ new Map(),
first: null
};
!(4 & n2) || (c2 = /** @type {Element} */
e2.appendChild(create_text()));
var d2 = null, f2 = false, p2 = /* @__PURE__ */ derived_safe_equal(() => {
var e3 = i2();
return t(e3) ? e3 : null == e3 ? [] : s(e3);
});
block(() => {
var e3 = get$1(p2), t2 = e3.length;
f2 && 0 === t2 || (f2 = 0 === t2, /**
* Add, remove, or reorder items output by an each block as its input changes
* @template V
* @param {Array<V>} array
* @param {EachState} state
* @param {Element | Comment | Text} anchor
* @param {(anchor: Node, item: MaybeSource<V>, index: number | Source<number>, collection: () => V[]) => void} render_fn
* @param {number} flags
* @param {(value: V, index: number) => any} get_key
* @param {() => V[]} get_collection
* @returns {void}
*/
function reconcile(e4, t3, n3, i3, o3, a3, l3) {
var _a2, _b2, _c2, _d;
var c3, u3, d3, f3, p3, g2, _2 = !!(8 & o3), v2 = !!(3 & o3), h2 = e4.length, m2 = t3.items, b2 = t3.first, $2 = b2, w2 = null, x2 = [], k2 = [];
if (_2) for (g2 = 0; g2 < h2; g2 += 1) f3 = a3(d3 = e4[g2], g2), void 0 !== (p3 = m2.get(f3)) && ((_a2 = p3.a) == null ? void 0 : _a2.measure(), (u3 ?? (u3 = /* @__PURE__ */ new Set())).add(p3));
for (g2 = 0; g2 < h2; g2 += 1) if (f3 = a3(d3 = e4[g2], g2), void 0 !== (p3 = m2.get(f3))) {
if (v2 && update_item(p3, d3, g2, o3), p3.e.f & y && (resume_effect(p3.e), _2 && ((_b2 = p3.a) == null ? void 0 : _b2.unfix(), (u3 ?? (u3 = /* @__PURE__ */ new Set())).delete(p3))), p3 !== $2) {
if (void 0 !== c3 && c3.has(p3)) {
if (x2.length < k2.length) {
var C2, S2 = k2[0];
w2 = S2.prev;
var M2 = x2[0], T2 = x2[x2.length - 1];
for (C2 = 0; C2 < x2.length; C2 += 1) move(x2[C2], S2, n3);
for (C2 = 0; C2 < k2.length; C2 += 1) c3.delete(k2[C2]);
link(t3, M2.prev, T2.next), link(t3, w2, M2), link(t3, T2, S2), $2 = S2, w2 = T2, g2 -= 1, x2 = [], k2 = [];
} else
c3.delete(p3), move(p3, $2, n3), link(t3, p3.prev, p3.next), link(t3, p3, null === w2 ? t3.first : w2.next), link(t3, w2, p3), w2 = p3;
continue;
}
for (x2 = [], k2 = []; null !== $2 && $2.k !== f3; )
$2.e.f & y || (c3 ?? (c3 = /* @__PURE__ */ new Set())).add($2), k2.push($2), $2 = $2.next;
if (null === $2) continue;
p3 = $2;
}
x2.push(p3), w2 = p3, $2 = p3.next;
} else {
w2 = create_item($2 ? (
/** @type {TemplateNode} */
$2.e.nodes_start
) : n3, t3, w2, null === w2 ? t3.first : w2.next, d3, f3, g2, i3, o3, l3), m2.set(f3, w2), x2 = [], k2 = [], $2 = w2.next;
}
if (null !== $2 || void 0 !== c3) {
for (var I2 = void 0 === c3 ? [] : s(c3); null !== $2; )
$2.e.f & y || I2.push($2), $2 = $2.next;
var O2 = I2.length;
if (O2 > 0) {
var q2 = 4 & o3 && 0 === h2 ? n3 : null;
if (_2) {
for (g2 = 0; g2 < O2; g2 += 1) (_c2 = I2[g2].a) == null ? void 0 : _c2.measure();
for (g2 = 0; g2 < O2; g2 += 1) (_d = I2[g2].a) == null ? void 0 : _d.fix();
}
!function pause_effects(e5, t4, n4, s2) {
for (var i4 = [], o4 = t4.length, a4 = 0; a4 < o4; a4++) pause_children(t4[a4].e, i4, true);
var l4 = o4 > 0 && 0 === i4.length && null !== n4;
if (l4) {
var c4 = (
/** @type {Element} */
/** @type {Element} */
n4.parentNode
);
!function clear_text_content(e6) {
e6.textContent = "";
}(c4), c4.append(
/** @type {Element} */
n4
), s2.clear(), link(e5, t4[0].prev, t4[o4 - 1].next);
}
run_out_transitions(i4, () => {
for (var n5 = 0; n5 < o4; n5++) {
var i5 = t4[n5];
l4 || (s2.delete(i5.k), link(e5, i5.prev, i5.next)), destroy_effect(i5.e, !l4);
}
});
}(t3, I2, q2, m2);
}
}
_2 && queue_micro_task(() => {
var _a3;
if (void 0 !== u3) for (p3 of u3) (_a3 = p3.a) == null ? void 0 : _a3.apply();
});
V.first = t3.first && t3.first.e, /** @type {Effect} */
V.last = w2 && w2.e;
}(e3, u2, c2, a2, n2, o2, i2), null !== l2 && (0 === t2 ? d2 ? resume_effect(d2) : d2 = branch(() => l2(c2)) : null !== d2 && pause_effect(d2, () => {
d2 = null;
})), // When we mount the each block for the first time, the collection won't be
// connected to this effect as the effect hasn't finished running yet and its deps
// won't be assigned. However, it's possible that when reconciling the each block
// that a mutation occurred and it's made the collection MAYBE_DIRTY, so reading the
// collection again can provide consistency to the reactive graph again as the deriveds
// will now be `CLEAN`.
get$1(p2));
});
}
function update_item(e2, t2, n2, s2) {
1 & s2 && internal_set(e2.v, t2), 2 & s2 ? internal_set(
/** @type {Value<number>} */
e2.i,
n2
) : e2.i = n2;
}
function create_item(e2, t2, n2, s2, i2, o2, a2, l2, c2, u2) {
var d2 = fe, f2 = !!(1 & c2) ? !(16 & c2) ? /* @__PURE__ */ mutable_source(i2) : source(i2) : i2, p2 = 2 & c2 ? source(a2) : a2, g2 = {
i: p2,
v: f2,
k: o2,
a: null,
// @ts-expect-error
e: null,
prev: n2,
next: s2
};
fe = g2;
try {
return g2.e = branch(() => l2(e2, f2, p2, u2), false), g2.e.prev = n2 && n2.e, g2.e.next = s2 && s2.e, null === n2 ? t2.first = g2 : (n2.next = g2, n2.e.next = g2.e), null !== s2 && (s2.prev = g2, s2.e.prev = g2.e), g2;
} finally {
fe = d2;
}
}
function move(e2, t2, n2) {
for (var s2 = e2.next ? (
/** @type {TemplateNode} */
e2.next.e.nodes_start
) : n2, i2 = t2 ? (
/** @type {TemplateNode} */
t2.e.nodes_start
) : n2, o2 = (
/** @type {TemplateNode} */
e2.e.nodes_start
); o2 !== s2; ) {
var a2 = (
/** @type {TemplateNode} */
/* @__PURE__ */ get_next_sibling(o2)
);
i2.before(o2), o2 = a2;
}
}
function link(e2, t2, n2) {
null === t2 ? e2.first = n2 : (t2.next = n2, t2.e.next = n2 && n2.e), null !== n2 && (n2.prev = t2, n2.e.prev = t2 && t2.e);
}
function slot(e2, t2, n2, s2, i2) {
var _a2;
var o2 = (_a2 = t2.$$slots) == null ? void 0 : _a2[n2], a2 = false;
true === o2 && (o2 = t2["default" === n2 ? "children" : n2], a2 = true), void 0 === o2 ? null !== i2 && i2(e2) : o2(e2, a2 ? () => s2 : s2);
}
function component(e2, t2, n2) {
var s2, i2, o2 = e2;
block(() => {
s2 !== (s2 = t2()) && (i2 && (pause_effect(i2), i2 = null), s2 && (i2 = branch(() => n2(o2, s2))));
}, w);
}
function r(e2) {
var t2, n2, s2 = "";
if ("string" == typeof e2 || "number" == typeof e2) s2 += e2;
else if