@glasnost-ui/svelte
Version:
Svelte components for Glasnost UI with liquid glass aesthetics
1,692 lines • 97.4 kB
JavaScript
"use strict";
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 _a, _current, _previous, _callbacks, _pending, _deferred, _neutered, _async_effects, _boundary_async_effects, _render_effects, _effects, _block_effects, _Batch_instances, process_fn, traverse_effect_tree_fn, commit_fn;
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const svelte = require("svelte");
const PUBLIC_VERSION = "5";
if (typeof window !== "undefined") {
((_a = window.__svelte ?? (window.__svelte = {})).v ?? (_a.v = /* @__PURE__ */ new Set())).add(PUBLIC_VERSION);
}
let legacy_mode_flag = false;
let tracing_mode_flag = false;
function enable_legacy_mode_flag() {
legacy_mode_flag = true;
}
enable_legacy_mode_flag();
const PROPS_IS_IMMUTABLE = 1;
const PROPS_IS_RUNES = 1 << 1;
const PROPS_IS_UPDATED = 1 << 2;
const PROPS_IS_BINDABLE = 1 << 3;
const PROPS_IS_LAZY_INITIAL = 1 << 4;
const UNINITIALIZED = Symbol();
const NAMESPACE_HTML = "http://www.w3.org/1999/xhtml";
const DEV = false;
var is_array = Array.isArray;
var index_of = Array.prototype.indexOf;
var define_property = Object.defineProperty;
var get_descriptor = Object.getOwnPropertyDescriptor;
var get_descriptors = Object.getOwnPropertyDescriptors;
var object_prototype = Object.prototype;
var array_prototype = Array.prototype;
var get_prototype_of = Object.getPrototypeOf;
function run(fn) {
return fn();
}
function run_all(arr) {
for (var i = 0; i < arr.length; i++) {
arr[i]();
}
}
function deferred() {
var resolve;
var reject;
var promise = new Promise((res, rej) => {
resolve = res;
reject = rej;
});
return { promise, resolve, reject };
}
const DERIVED = 1 << 1;
const EFFECT = 1 << 2;
const RENDER_EFFECT = 1 << 3;
const 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 INSPECT_EFFECT = 1 << 17;
const HEAD_EFFECT = 1 << 18;
const EFFECT_PRESERVED = 1 << 19;
const USER_EFFECT = 1 << 20;
const REACTION_IS_UPDATING = 1 << 21;
const ASYNC = 1 << 22;
const ERROR_VALUE = 1 << 23;
const STATE_SYMBOL = Symbol("$state");
const LEGACY_PROPS = Symbol("legacy props");
const LOADING_ATTR_SYMBOL = Symbol("");
const STALE_REACTION = new class StaleReactionError extends Error {
constructor() {
super(...arguments);
__publicField(this, "name", "StaleReactionError");
__publicField(this, "message", "The reaction that called `getAbortSignal()` was re-run or destroyed");
}
}();
function await_outside_boundary() {
{
throw new Error(`https://svelte.dev/e/await_outside_boundary`);
}
}
function async_derived_orphan() {
{
throw new Error(`https://svelte.dev/e/async_derived_orphan`);
}
}
function effect_in_teardown(rune) {
{
throw new Error(`https://svelte.dev/e/effect_in_teardown`);
}
}
function effect_in_unowned_derived() {
{
throw new Error(`https://svelte.dev/e/effect_in_unowned_derived`);
}
}
function effect_orphan(rune) {
{
throw new Error(`https://svelte.dev/e/effect_orphan`);
}
}
function effect_update_depth_exceeded() {
{
throw new Error(`https://svelte.dev/e/effect_update_depth_exceeded`);
}
}
function props_invalid_value(key) {
{
throw new Error(`https://svelte.dev/e/props_invalid_value`);
}
}
function state_descriptors_fixed() {
{
throw new Error(`https://svelte.dev/e/state_descriptors_fixed`);
}
}
function state_prototype_fixed() {
{
throw new Error(`https://svelte.dev/e/state_prototype_fixed`);
}
}
function state_unsafe_mutation() {
{
throw new Error(`https://svelte.dev/e/state_unsafe_mutation`);
}
}
function equals(value) {
return value === this.v;
}
function safe_not_equal(a, b) {
return a != a ? b == b : a !== b || a !== null && typeof a === "object" || typeof a === "function";
}
function safe_equals(value) {
return !safe_not_equal(value, this.v);
}
let component_context = null;
function set_component_context(context) {
component_context = context;
}
function push(props, runes = false, fn) {
component_context = {
p: component_context,
c: null,
e: null,
s: props,
x: null,
l: legacy_mode_flag && !runes ? { s: null, u: null, $: [] } : null
};
}
function pop(component) {
var context = (
/** @type {ComponentContext} */
component_context
);
var effects = context.e;
if (effects !== null) {
context.e = null;
for (var fn of effects) {
create_user_effect(fn);
}
}
component_context = context.p;
return (
/** @type {T} */
{}
);
}
function is_runes() {
return !legacy_mode_flag || component_context !== null && component_context.l === null;
}
const adjustments = /* @__PURE__ */ new WeakMap();
function handle_error(error) {
var effect = active_effect;
if (effect === null) {
active_reaction.f |= ERROR_VALUE;
return error;
}
if ((effect.f & EFFECT_RAN) === 0) {
if ((effect.f & BOUNDARY_EFFECT) === 0) {
if (!effect.parent && error instanceof Error) {
apply_adjustments(error);
}
throw error;
}
effect.b.error(error);
} else {
invoke_error_boundary(error, effect);
}
}
function invoke_error_boundary(error, effect) {
while (effect !== null) {
if ((effect.f & BOUNDARY_EFFECT) !== 0) {
try {
effect.b.error(error);
return;
} catch {
}
}
effect = effect.parent;
}
if (error instanceof Error) {
apply_adjustments(error);
}
throw error;
}
function apply_adjustments(error) {
const adjusted = adjustments.get(error);
if (adjusted) {
define_property(error, "message", {
value: adjusted.message
});
define_property(error, "stack", {
value: adjusted.stack
});
}
}
let micro_tasks = [];
function run_micro_tasks() {
var tasks = micro_tasks;
micro_tasks = [];
run_all(tasks);
}
function queue_micro_task(fn) {
if (micro_tasks.length === 0) {
queueMicrotask(run_micro_tasks);
}
micro_tasks.push(fn);
}
function get_pending_boundary() {
var boundary = (
/** @type {Effect} */
active_effect.b
);
while (boundary !== null && !boundary.has_pending_snippet()) {
boundary = boundary.parent;
}
if (boundary === null) {
await_outside_boundary();
}
return boundary;
}
// @__NO_SIDE_EFFECTS__
function derived(fn) {
var flags = DERIVED | DIRTY;
var parent_derived = active_reaction !== null && (active_reaction.f & DERIVED) !== 0 ? (
/** @type {Derived} */
active_reaction
) : null;
if (active_effect === null || parent_derived !== null && (parent_derived.f & UNOWNED) !== 0) {
flags |= UNOWNED;
} else {
active_effect.f |= EFFECT_PRESERVED;
}
const signal = {
ctx: component_context,
deps: null,
effects: null,
equals,
f: flags,
fn,
reactions: null,
rv: 0,
v: (
/** @type {V} */
UNINITIALIZED
),
wv: 0,
parent: parent_derived ?? active_effect,
ac: null
};
return signal;
}
// @__NO_SIDE_EFFECTS__
function async_derived(fn, location) {
let parent = (
/** @type {Effect | null} */
active_effect
);
if (parent === null) {
async_derived_orphan();
}
var boundary = (
/** @type {Boundary} */
parent.b
);
var promise = (
/** @type {Promise<V>} */
/** @type {unknown} */
void 0
);
var signal = source(
/** @type {V} */
UNINITIALIZED
);
var prev = null;
var should_suspend = !active_reaction;
async_effect(() => {
try {
var p = fn();
} catch (error) {
p = Promise.reject(error);
}
var r2 = () => p;
promise = (prev == null ? void 0 : prev.then(r2, r2)) ?? Promise.resolve(p);
prev = promise;
var batch = (
/** @type {Batch} */
current_batch
);
var pending = boundary.pending;
if (should_suspend) {
boundary.update_pending_count(1);
if (!pending) batch.increment();
}
const handler = (value, error = void 0) => {
prev = null;
if (!pending) batch.activate();
if (error) {
if (error !== STALE_REACTION) {
signal.f |= ERROR_VALUE;
internal_set(signal, error);
}
} else {
if ((signal.f & ERROR_VALUE) !== 0) {
signal.f ^= ERROR_VALUE;
}
internal_set(signal, value);
}
if (should_suspend) {
boundary.update_pending_count(-1);
if (!pending) batch.decrement();
}
unset_context();
};
promise.then(handler, (e) => handler(null, e || "unknown"));
if (batch) {
return () => {
queueMicrotask(() => batch.neuter());
};
}
});
return new Promise((fulfil) => {
function next(p) {
function go() {
if (p === promise) {
fulfil(signal);
} else {
next(promise);
}
}
p.then(go, go);
}
next(promise);
});
}
// @__NO_SIDE_EFFECTS__
function derived_safe_equal(fn) {
const signal = /* @__PURE__ */ derived(fn);
signal.equals = safe_equals;
return signal;
}
function destroy_derived_effects(derived2) {
var effects = derived2.effects;
if (effects !== null) {
derived2.effects = null;
for (var i = 0; i < effects.length; i += 1) {
destroy_effect(
/** @type {Effect} */
effects[i]
);
}
}
}
function get_derived_parent_effect(derived2) {
var parent = derived2.parent;
while (parent !== null) {
if ((parent.f & DERIVED) === 0) {
return (
/** @type {Effect} */
parent
);
}
parent = parent.parent;
}
return null;
}
function execute_derived(derived2) {
var value;
var prev_active_effect = active_effect;
set_active_effect(get_derived_parent_effect(derived2));
{
try {
destroy_derived_effects(derived2);
value = update_reaction(derived2);
} finally {
set_active_effect(prev_active_effect);
}
}
return value;
}
function update_derived(derived2) {
var value = execute_derived(derived2);
if (!derived2.equals(value)) {
derived2.v = value;
derived2.wv = increment_write_version();
}
if (is_destroying_effect) return;
if (batch_deriveds !== null) {
batch_deriveds.set(derived2, derived2.v);
} else {
var status = (skip_reaction || (derived2.f & UNOWNED) !== 0) && derived2.deps !== null ? MAYBE_DIRTY : CLEAN;
set_signal_status(derived2, status);
}
}
function flatten(sync, async, fn) {
const d = is_runes() ? derived : derived_safe_equal;
if (async.length === 0) {
fn(sync.map(d));
return;
}
var batch = current_batch;
var parent = (
/** @type {Effect} */
active_effect
);
var restore = capture();
var boundary = get_pending_boundary();
Promise.all(async.map((expression) => /* @__PURE__ */ async_derived(expression))).then((result) => {
batch == null ? void 0 : batch.activate();
restore();
try {
fn([...sync.map(d), ...result]);
} catch (error) {
if ((parent.f & DESTROYED) === 0) {
invoke_error_boundary(error, parent);
}
}
batch == null ? void 0 : batch.deactivate();
unset_context();
}).catch((error) => {
boundary.error(error);
});
}
function capture() {
var previous_effect = active_effect;
var previous_reaction = active_reaction;
var previous_component_context = component_context;
return function restore() {
set_active_effect(previous_effect);
set_active_reaction(previous_reaction);
set_component_context(previous_component_context);
};
}
function unset_context() {
set_active_effect(null);
set_active_reaction(null);
set_component_context(null);
}
const batches = /* @__PURE__ */ new Set();
let current_batch = null;
let batch_deriveds = null;
let dev_effect_stack = [];
let queued_root_effects = [];
let last_scheduled_effect = null;
let is_flushing = false;
const _Batch = class _Batch {
constructor() {
__privateAdd(this, _Batch_instances);
/**
* The current values of any sources that are updated in this batch
* They keys of this map are identical to `this.#previous`
* @type {Map<Source, any>}
*/
__privateAdd(this, _current, /* @__PURE__ */ new Map());
/**
* The values of any sources that are updated in this batch _before_ those updates took place.
* They keys of this map are identical to `this.#current`
* @type {Map<Source, any>}
*/
__privateAdd(this, _previous, /* @__PURE__ */ new Map());
/**
* When the batch is committed (and the DOM is updated), we need to remove old branches
* and append new ones by calling the functions added inside (if/each/key/etc) blocks
* @type {Set<() => void>}
*/
__privateAdd(this, _callbacks, /* @__PURE__ */ new Set());
/**
* The number of async effects that are currently in flight
*/
__privateAdd(this, _pending, 0);
/**
* A deferred that resolves when the batch is committed, used with `settled()`
* TODO replace with Promise.withResolvers once supported widely enough
* @type {{ promise: Promise<void>, resolve: (value?: any) => void, reject: (reason: unknown) => void } | null}
*/
__privateAdd(this, _deferred, null);
/**
* True if an async effect inside this batch resolved and
* its parent branch was already deleted
*/
__privateAdd(this, _neutered, false);
/**
* Async effects (created inside `async_derived`) encountered during processing.
* These run after the rest of the batch has updated, since they should
* always have the latest values
* @type {Effect[]}
*/
__privateAdd(this, _async_effects, []);
/**
* The same as `#async_effects`, but for effects inside a newly-created
* `<svelte:boundary>` — these do not prevent the batch from committing
* @type {Effect[]}
*/
__privateAdd(this, _boundary_async_effects, []);
/**
* Template effects and `$effect.pre` effects, which run when
* a batch is committed
* @type {Effect[]}
*/
__privateAdd(this, _render_effects, []);
/**
* The same as `#render_effects`, but for `$effect` (which runs after)
* @type {Effect[]}
*/
__privateAdd(this, _effects, []);
/**
* Block effects, which may need to re-run on subsequent flushes
* in order to update internal sources (e.g. each block items)
* @type {Effect[]}
*/
__privateAdd(this, _block_effects, []);
/**
* A set of branches that still exist, but will be destroyed when this batch
* is committed — we skip over these during `process`
* @type {Set<Effect>}
*/
__publicField(this, "skipped_effects", /* @__PURE__ */ new Set());
}
/**
* Associate a change to a given source with the current
* batch, noting its previous and current values
* @param {Source} source
* @param {any} value
*/
capture(source2, value) {
if (!__privateGet(this, _previous).has(source2)) {
__privateGet(this, _previous).set(source2, value);
}
__privateGet(this, _current).set(source2, source2.v);
}
activate() {
current_batch = this;
}
deactivate() {
current_batch = null;
}
neuter() {
__privateSet(this, _neutered, true);
}
flush() {
if (queued_root_effects.length > 0) {
this.flush_effects();
} else {
__privateMethod(this, _Batch_instances, commit_fn).call(this);
}
if (current_batch !== this) {
return;
}
if (__privateGet(this, _pending) === 0) {
batches.delete(this);
}
current_batch = null;
}
flush_effects() {
var was_updating_effect = is_updating_effect;
is_flushing = true;
try {
var flush_count = 0;
set_is_updating_effect(true);
while (queued_root_effects.length > 0) {
if (flush_count++ > 1e3) {
infinite_loop_guard();
}
__privateMethod(this, _Batch_instances, process_fn).call(this, queued_root_effects);
old_values.clear();
}
} finally {
is_flushing = false;
set_is_updating_effect(was_updating_effect);
last_scheduled_effect = null;
}
}
increment() {
__privateSet(this, _pending, __privateGet(this, _pending) + 1);
}
decrement() {
__privateSet(this, _pending, __privateGet(this, _pending) - 1);
if (__privateGet(this, _pending) === 0) {
for (const e of __privateGet(this, _render_effects)) {
set_signal_status(e, DIRTY);
schedule_effect(e);
}
for (const e of __privateGet(this, _effects)) {
set_signal_status(e, DIRTY);
schedule_effect(e);
}
for (const e of __privateGet(this, _block_effects)) {
set_signal_status(e, DIRTY);
schedule_effect(e);
}
__privateSet(this, _render_effects, []);
__privateSet(this, _effects, []);
this.flush();
}
}
/** @param {() => void} fn */
add_callback(fn) {
__privateGet(this, _callbacks).add(fn);
}
settled() {
return (__privateGet(this, _deferred) ?? __privateSet(this, _deferred, deferred())).promise;
}
static ensure() {
if (current_batch === null) {
const batch = current_batch = new _Batch();
batches.add(current_batch);
queueMicrotask(() => {
if (current_batch !== batch) {
return;
}
batch.flush();
});
}
return current_batch;
}
};
_current = new WeakMap();
_previous = new WeakMap();
_callbacks = new WeakMap();
_pending = new WeakMap();
_deferred = new WeakMap();
_neutered = new WeakMap();
_async_effects = new WeakMap();
_boundary_async_effects = new WeakMap();
_render_effects = new WeakMap();
_effects = new WeakMap();
_block_effects = new WeakMap();
_Batch_instances = new WeakSet();
/**
*
* @param {Effect[]} root_effects
*/
process_fn = function(root_effects) {
var _a2;
queued_root_effects = [];
var current_values = null;
if (batches.size > 1) {
current_values = /* @__PURE__ */ new Map();
batch_deriveds = /* @__PURE__ */ new Map();
for (const [source2, current] of __privateGet(this, _current)) {
current_values.set(source2, { v: source2.v, wv: source2.wv });
source2.v = current;
}
for (const batch of batches) {
if (batch === this) continue;
for (const [source2, previous] of __privateGet(batch, _previous)) {
if (!current_values.has(source2)) {
current_values.set(source2, { v: source2.v, wv: source2.wv });
source2.v = previous;
}
}
}
}
for (const root2 of root_effects) {
__privateMethod(this, _Batch_instances, traverse_effect_tree_fn).call(this, root2);
}
if (__privateGet(this, _async_effects).length === 0 && __privateGet(this, _pending) === 0) {
var render_effects = __privateGet(this, _render_effects);
var effects = __privateGet(this, _effects);
__privateSet(this, _render_effects, []);
__privateSet(this, _effects, []);
__privateSet(this, _block_effects, []);
__privateMethod(this, _Batch_instances, commit_fn).call(this);
flush_queued_effects(render_effects);
flush_queued_effects(effects);
(_a2 = __privateGet(this, _deferred)) == null ? void 0 : _a2.resolve();
} else {
for (const e of __privateGet(this, _render_effects)) set_signal_status(e, CLEAN);
for (const e of __privateGet(this, _effects)) set_signal_status(e, CLEAN);
for (const e of __privateGet(this, _block_effects)) set_signal_status(e, CLEAN);
}
if (current_values) {
for (const [source2, { v, wv }] of current_values) {
if (source2.wv <= wv) {
source2.v = v;
}
}
batch_deriveds = null;
}
for (const effect of __privateGet(this, _async_effects)) {
update_effect(effect);
}
for (const effect of __privateGet(this, _boundary_async_effects)) {
update_effect(effect);
}
__privateSet(this, _async_effects, []);
__privateSet(this, _boundary_async_effects, []);
};
/**
* Traverse the effect tree, executing effects or stashing
* them for later execution as appropriate
* @param {Effect} root
*/
traverse_effect_tree_fn = function(root2) {
var _a2;
root2.f ^= CLEAN;
var effect = root2.first;
while (effect !== null) {
var flags = effect.f;
var is_branch = (flags & (BRANCH_EFFECT | ROOT_EFFECT)) !== 0;
var is_skippable_branch = is_branch && (flags & CLEAN) !== 0;
var skip = is_skippable_branch || (flags & INERT) !== 0 || this.skipped_effects.has(effect);
if (!skip && effect.fn !== null) {
if (is_branch) {
effect.f ^= CLEAN;
} else if ((flags & EFFECT) !== 0) {
__privateGet(this, _effects).push(effect);
} else if (is_dirty(effect)) {
if ((flags & ASYNC) !== 0) {
var effects = ((_a2 = effect.b) == null ? void 0 : _a2.pending) ? __privateGet(this, _boundary_async_effects) : __privateGet(this, _async_effects);
effects.push(effect);
} else {
if ((effect.f & BLOCK_EFFECT) !== 0) __privateGet(this, _block_effects).push(effect);
update_effect(effect);
}
}
var child2 = effect.first;
if (child2 !== null) {
effect = child2;
continue;
}
}
var parent = effect.parent;
effect = effect.next;
while (effect === null && parent !== null) {
effect = parent.next;
parent = parent.parent;
}
}
};
/**
* Append and remove branches to/from the DOM
*/
commit_fn = function() {
if (!__privateGet(this, _neutered)) {
for (const fn of __privateGet(this, _callbacks)) {
fn();
}
}
__privateGet(this, _callbacks).clear();
};
let Batch = _Batch;
function infinite_loop_guard() {
try {
effect_update_depth_exceeded();
} catch (error) {
if (last_scheduled_effect !== null) {
{
invoke_error_boundary(error, last_scheduled_effect);
}
} else {
throw error;
}
}
}
function flush_queued_effects(effects) {
var length = effects.length;
if (length === 0) return;
for (var i = 0; i < length; i++) {
var effect = effects[i];
if ((effect.f & (DESTROYED | INERT)) === 0) {
if (is_dirty(effect)) {
var wv = write_version;
update_effect(effect);
if (effect.deps === null && effect.first === null && effect.nodes_start === null) {
if (effect.teardown === null) {
unlink_effect(effect);
} else {
effect.fn = null;
}
}
if (write_version > wv && (effect.f & USER_EFFECT) !== 0) {
break;
}
}
}
}
for (; i < length; i += 1) {
schedule_effect(effects[i]);
}
}
function schedule_effect(signal) {
var effect = last_scheduled_effect = signal;
while (effect.parent !== null) {
effect = effect.parent;
var flags = effect.f;
if (is_flushing && effect === active_effect && (flags & BLOCK_EFFECT) !== 0) {
return;
}
if ((flags & (ROOT_EFFECT | BRANCH_EFFECT)) !== 0) {
if ((flags & CLEAN) === 0) return;
effect.f ^= CLEAN;
}
}
queued_root_effects.push(effect);
}
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, trackable = true) {
var _a2;
const s = source(initial_value);
if (!immutable) {
s.equals = safe_equals;
}
if (legacy_mode_flag && trackable && component_context !== null && component_context.l !== null) {
((_a2 = component_context.l).s ?? (_a2.s = [])).push(s);
}
return s;
}
function set(source2, value, should_proxy = false) {
if (active_reaction !== null && // since we are untracking the function inside `$inspect.with` we need to add this check
// to ensure we error if state is set inside an inspect effect
(!untracking || (active_reaction.f & INSPECT_EFFECT) !== 0) && is_runes() && (active_reaction.f & (DERIVED | BLOCK_EFFECT | ASYNC | INSPECT_EFFECT)) !== 0 && !(current_sources == null ? void 0 : current_sources.includes(source2))) {
state_unsafe_mutation();
}
let new_value = should_proxy ? proxy(value) : value;
return internal_set(source2, new_value);
}
function internal_set(source2, value) {
if (!source2.equals(value)) {
var old_value = source2.v;
if (is_destroying_effect) {
old_values.set(source2, value);
} else {
old_values.set(source2, old_value);
}
source2.v = value;
const batch = Batch.ensure();
batch.capture(source2, old_value);
if ((source2.f & DERIVED) !== 0) {
if ((source2.f & DIRTY) !== 0) {
execute_derived(
/** @type {Derived} */
source2
);
}
set_signal_status(source2, (source2.f & UNOWNED) === 0 ? CLEAN : MAYBE_DIRTY);
}
source2.wv = increment_write_version();
mark_reactions(source2, DIRTY);
if (is_runes() && 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 increment(source2) {
set(source2, source2.v + 1);
}
function mark_reactions(signal, status) {
var reactions = signal.reactions;
if (reactions === null) return;
var runes = is_runes();
var length = reactions.length;
for (var i = 0; i < length; i++) {
var reaction = reactions[i];
var flags = reaction.f;
if ((flags & DIRTY) !== 0) continue;
if (!runes && reaction === active_effect) continue;
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 proxy(value) {
if (typeof value !== "object" || value === null || STATE_SYMBOL in value) {
return value;
}
const prototype = get_prototype_of(value);
if (prototype !== object_prototype && prototype !== array_prototype) {
return value;
}
var sources = /* @__PURE__ */ new Map();
var is_proxied_array = is_array(value);
var version = /* @__PURE__ */ state(0);
var parent_version = update_version;
var with_parent = (fn) => {
if (update_version === parent_version) {
return fn();
}
var reaction = active_reaction;
var version2 = update_version;
set_active_reaction(null);
set_update_version(parent_version);
var result = fn();
set_active_reaction(reaction);
set_update_version(version2);
return result;
};
if (is_proxied_array) {
sources.set("length", /* @__PURE__ */ state(
/** @type {any[]} */
value.length
));
}
return new Proxy(
/** @type {any} */
value,
{
defineProperty(_, prop2, descriptor) {
if (!("value" in descriptor) || descriptor.configurable === false || descriptor.enumerable === false || descriptor.writable === false) {
state_descriptors_fixed();
}
var s = sources.get(prop2);
if (s === void 0) {
s = with_parent(() => {
var s2 = /* @__PURE__ */ state(descriptor.value);
sources.set(prop2, s2);
return s2;
});
} else {
set(s, descriptor.value, true);
}
return true;
},
deleteProperty(target, prop2) {
var s = sources.get(prop2);
if (s === void 0) {
if (prop2 in target) {
const s2 = with_parent(() => /* @__PURE__ */ state(UNINITIALIZED));
sources.set(prop2, s2);
increment(version);
}
} else {
if (is_proxied_array && typeof prop2 === "string") {
var ls = (
/** @type {Source<number>} */
sources.get("length")
);
var n = Number(prop2);
if (Number.isInteger(n) && n < ls.v) {
set(ls, n);
}
}
set(s, UNINITIALIZED);
increment(version);
}
return true;
},
get(target, prop2, receiver) {
var _a2;
if (prop2 === STATE_SYMBOL) {
return value;
}
var s = sources.get(prop2);
var exists = prop2 in target;
if (s === void 0 && (!exists || ((_a2 = get_descriptor(target, prop2)) == null ? void 0 : _a2.writable))) {
s = with_parent(() => {
var p = proxy(exists ? target[prop2] : UNINITIALIZED);
var s2 = /* @__PURE__ */ state(p);
return s2;
});
sources.set(prop2, s);
}
if (s !== void 0) {
var v = get(s);
return v === UNINITIALIZED ? void 0 : v;
}
return Reflect.get(target, prop2, receiver);
},
getOwnPropertyDescriptor(target, prop2) {
var descriptor = Reflect.getOwnPropertyDescriptor(target, prop2);
if (descriptor && "value" in descriptor) {
var s = sources.get(prop2);
if (s) descriptor.value = get(s);
} else if (descriptor === void 0) {
var source2 = sources.get(prop2);
var value2 = source2 == null ? void 0 : source2.v;
if (source2 !== void 0 && value2 !== UNINITIALIZED) {
return {
enumerable: true,
configurable: true,
value: value2,
writable: true
};
}
}
return descriptor;
},
has(target, prop2) {
var _a2;
if (prop2 === STATE_SYMBOL) {
return true;
}
var s = sources.get(prop2);
var has = s !== void 0 && s.v !== UNINITIALIZED || Reflect.has(target, prop2);
if (s !== void 0 || active_effect !== null && (!has || ((_a2 = get_descriptor(target, prop2)) == null ? void 0 : _a2.writable))) {
if (s === void 0) {
s = with_parent(() => {
var p = has ? proxy(target[prop2]) : UNINITIALIZED;
var s2 = /* @__PURE__ */ state(p);
return s2;
});
sources.set(prop2, s);
}
var value2 = get(s);
if (value2 === UNINITIALIZED) {
return false;
}
}
return has;
},
set(target, prop2, value2, receiver) {
var _a2;
var s = sources.get(prop2);
var has = prop2 in target;
if (is_proxied_array && prop2 === "length") {
for (var i = value2; i < /** @type {Source<number>} */
s.v; i += 1) {
var other_s = sources.get(i + "");
if (other_s !== void 0) {
set(other_s, UNINITIALIZED);
} else if (i in target) {
other_s = with_parent(() => /* @__PURE__ */ state(UNINITIALIZED));
sources.set(i + "", other_s);
}
}
}
if (s === void 0) {
if (!has || ((_a2 = get_descriptor(target, prop2)) == null ? void 0 : _a2.writable)) {
s = with_parent(() => /* @__PURE__ */ state(void 0));
set(s, proxy(value2));
sources.set(prop2, s);
}
} else {
has = s.v !== UNINITIALIZED;
var p = with_parent(() => proxy(value2));
set(s, p);
}
var descriptor = Reflect.getOwnPropertyDescriptor(target, prop2);
if (descriptor == null ? void 0 : descriptor.set) {
descriptor.set.call(receiver, value2);
}
if (!has) {
if (is_proxied_array && typeof prop2 === "string") {
var ls = (
/** @type {Source<number>} */
sources.get("length")
);
var n = Number(prop2);
if (Number.isInteger(n) && n >= ls.v) {
set(ls, n + 1);
}
}
increment(version);
}
return true;
},
ownKeys(target) {
get(version);
var own_keys = Reflect.ownKeys(target).filter((key2) => {
var source3 = sources.get(key2);
return source3 === void 0 || source3.v !== UNINITIALIZED;
});
for (var [key, source2] of sources) {
if (source2.v !== UNINITIALIZED && !(key in target)) {
own_keys.push(key);
}
}
return own_keys;
},
setPrototypeOf() {
state_prototype_fixed();
}
}
);
}
var first_child_getter;
var next_sibling_getter;
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 child(node, is_text) {
{
return /* @__PURE__ */ get_first_child(node);
}
}
function first_child(fragment, is_text) {
{
var first = (
/** @type {DocumentFragment} */
/* @__PURE__ */ get_first_child(
/** @type {Node} */
fragment
)
);
if (first instanceof Comment && first.data === "") return /* @__PURE__ */ get_next_sibling(first);
return first;
}
}
function sibling(node, count = 1, is_text = false) {
let next_sibling = node;
while (count--) {
next_sibling = /** @type {TemplateNode} */
/* @__PURE__ */ get_next_sibling(next_sibling);
}
{
return next_sibling;
}
}
function should_defer_append() {
return false;
}
function validate_effect(rune) {
if (active_effect === null && active_reaction === null) {
effect_orphan();
}
if (active_reaction !== null && (active_reaction.f & UNOWNED) !== 0 && active_effect === null) {
effect_in_unowned_derived();
}
if (is_destroying_effect) {
effect_in_teardown();
}
}
function push_effect(effect, parent_effect) {
var parent_last = parent_effect.last;
if (parent_last === null) {
parent_effect.last = parent_effect.first = effect;
} else {
parent_last.next = effect;
effect.prev = parent_last;
parent_effect.last = effect;
}
}
function create_effect(type, fn, sync, push2 = true) {
var parent = active_effect;
if (parent !== null && (parent.f & INERT) !== 0) {
type |= INERT;
}
var effect = {
ctx: component_context,
deps: null,
nodes_start: null,
nodes_end: null,
f: type | DIRTY,
first: null,
fn,
last: null,
next: null,
parent,
b: parent && parent.b,
prev: null,
teardown: null,
transitions: null,
wv: 0,
ac: null
};
if (sync) {
try {
update_effect(effect);
effect.f |= EFFECT_RAN;
} catch (e) {
destroy_effect(effect);
throw e;
}
} else if (fn !== null) {
schedule_effect(effect);
}
var inert = sync && effect.deps === null && effect.first === null && effect.nodes_start === null && effect.teardown === null && (effect.f & EFFECT_PRESERVED) === 0;
if (!inert && push2) {
if (parent !== null) {
push_effect(effect, parent);
}
if (active_reaction !== null && (active_reaction.f & DERIVED) !== 0) {
var derived2 = (
/** @type {Derived} */
active_reaction
);
(derived2.effects ?? (derived2.effects = [])).push(effect);
}
}
return effect;
}
function teardown(fn) {
const effect = create_effect(RENDER_EFFECT, null, false);
set_signal_status(effect, CLEAN);
effect.teardown = fn;
return effect;
}
function user_effect(fn) {
validate_effect();
var flags = (
/** @type {Effect} */
active_effect.f
);
var defer = !active_reaction && (flags & BRANCH_EFFECT) !== 0 && (flags & EFFECT_RAN) === 0;
if (defer) {
var context = (
/** @type {ComponentContext} */
component_context
);
(context.e ?? (context.e = [])).push(fn);
} else {
return create_user_effect(fn);
}
}
function create_user_effect(fn) {
return create_effect(EFFECT | USER_EFFECT, fn, false);
}
function user_pre_effect(fn) {
validate_effect();
return create_effect(RENDER_EFFECT | USER_EFFECT, fn, true);
}
function legacy_pre_effect(deps, fn) {
var context = (
/** @type {ComponentContextLegacy} */
component_context
);
var token = { effect: null, ran: false, deps };
context.l.$.push(token);
token.effect = render_effect(() => {
deps();
if (token.ran) return;
token.ran = true;
untrack(fn);
});
}
function legacy_pre_effect_reset() {
var context = (
/** @type {ComponentContextLegacy} */
component_context
);
render_effect(() => {
for (var token of context.l.$) {
token.deps();
var effect = token.effect;
if ((effect.f & CLEAN) !== 0) {
set_signal_status(effect, MAYBE_DIRTY);
}
if (is_dirty(effect)) {
update_effect(effect);
}
token.ran = false;
}
});
}
function async_effect(fn) {
return create_effect(ASYNC | EFFECT_PRESERVED, fn, true);
}
function render_effect(fn, flags = 0) {
return create_effect(RENDER_EFFECT | flags, fn, true);
}
function template_effect(fn, sync = [], async = []) {
flatten(sync, async, (values) => {
create_effect(RENDER_EFFECT, () => fn(...values.map(get)), true);
});
}
function block(fn, flags = 0) {
var effect = create_effect(BLOCK_EFFECT | flags, fn, true);
return effect;
}
function branch(fn, push2 = true) {
return create_effect(BRANCH_EFFECT, fn, true, push2);
}
function execute_effect_teardown(effect) {
var teardown2 = effect.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 _a2;
var effect = signal.first;
signal.first = signal.last = null;
while (effect !== null) {
(_a2 = effect.ac) == null ? void 0 : _a2.abort(STALE_REACTION);
var next = effect.next;
if ((effect.f & ROOT_EFFECT) !== 0) {
effect.parent = null;
} else {
destroy_effect(effect, remove_dom);
}
effect = next;
}
}
function destroy_block_effect_children(signal) {
var effect = signal.first;
while (effect !== null) {
var next = effect.next;
if ((effect.f & BRANCH_EFFECT) === 0) {
destroy_effect(effect);
}
effect = next;
}
}
function destroy_effect(effect, remove_dom = true) {
var removed = false;
if ((remove_dom || (effect.f & HEAD_EFFECT) !== 0) && effect.nodes_start !== null && effect.nodes_end !== null) {
remove_effect_dom(
effect.nodes_start,
/** @type {TemplateNode} */
effect.nodes_end
);
removed = true;
}
destroy_effect_children(effect, remove_dom && !removed);
remove_reactions(effect, 0);
set_signal_status(effect, DESTROYED);
var transitions = effect.transitions;
if (transitions !== null) {
for (const transition of transitions) {
transition.stop();
}
}
execute_effect_teardown(effect);
var parent = effect.parent;
if (parent !== null && parent.first !== null) {
unlink_effect(effect);
}
effect.next = effect.prev = effect.teardown = effect.ctx = effect.deps = effect.fn = effect.nodes_start = effect.nodes_end = effect.ac = null;
}
function remove_effect_dom(node, end) {
while (node !== null) {
var next = node === end ? null : (
/** @type {TemplateNode} */
/* @__PURE__ */ get_next_sibling(node)
);
node.remove();
node = next;
}
}
function unlink_effect(effect) {
var parent = effect.parent;
var prev = effect.prev;
var next = effect.next;
if (prev !== null) prev.next = next;
if (next !== null) next.prev = prev;
if (parent !== null) {
if (parent.first === effect) parent.first = next;
if (parent.last === effect) parent.last = prev;
}
}
function pause_effect(effect, callback) {
var transitions = [];
pause_children(effect, transitions, true);
run_out_transitions(transitions, () => {
destroy_effect(effect);
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(effect, transitions, local) {
if ((effect.f & INERT) !== 0) return;
effect.f ^= INERT;
if (effect.transitions !== null) {
for (const transition of effect.transitions) {
if (transition.is_global || local) {
transitions.push(transition);
}
}
}
var child2 = effect.first;
while (child2 !== null) {
var sibling2 = child2.next;
var transparent = (child2.f & EFFECT_TRANSPARENT) !== 0 || (child2.f & BRANCH_EFFECT) !== 0;
pause_children(child2, transitions, transparent ? local : false);
child2 = sibling2;
}
}
function resume_effect(effect) {
resume_children(effect, true);
}
function resume_children(effect, local) {
if ((effect.f & INERT) === 0) return;
effect.f ^= INERT;
if ((effect.f & CLEAN) === 0) {
set_signal_status(effect, DIRTY);
schedule_effect(effect);
}
var child2 = effect.first;
while (child2 !== null) {
var sibling2 = child2.next;
var transparent = (child2.f & EFFECT_TRANSPARENT) !== 0 || (child2.f & BRANCH_EFFECT) !== 0;
resume_children(child2, transparent ? local : false);
child2 = sibling2;
}
if (effect.transitions !== null) {
for (const transition of effect.transitions) {
if (transition.is_global || local) {
transition.in();
}
}
}
}
let is_updating_effect = false;
function set_is_updating_effect(value) {
is_updating_effect = value;
}
let is_destroying_effect = false;
function set_is_destroying_effect(value) {
is_destroying_effect = value;
}
let active_reaction = null;
let untracking = false;
function set_active_reaction(reaction) {
active_reaction = reaction;
}
let active_effect = null;
function set_active_effect(effect) {
active_effect = effect;
}
let current_sources = null;
function push_reaction_value(value) {
if (active_reaction !== null && true) {
if (current_sources === null) {
current_sources = [value];
} else {
current_sources.push(value);
}
}
}
let new_deps = null;
let skipped_deps = 0;
let untracked_writes = null;
function set_untracked_writes(value) {
untracked_writes = value;
}
let write_version = 1;
let read_version = 0;
let update_version = read_version;
function set_update_version(value) {
update_version = value;
}
let skip_reaction = false;
function increment_write_version() {
return ++write_version;
}
function is_dirty(reaction) {
var _a2;
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) && (active_effect === null || (active_effect.f & DESTROYED) === 0)) {
var derived2 = (
/** @type {Derived} */
reaction
);
var parent = derived2.parent;
for (i = 0; i < length; i++) {
dependency = dependencies[i];
if (is_disconnected || !((_a2 = dependency == null ? void 0 : dependency.reactions) == null ? void 0 : _a2.includes(derived2))) {
(dependency.reactions ?? (dependency.reactions = [])).push(derived2);
}
}
if (is_disconnected) {
derived2.f ^= DISCONNECTED;
}
if (is_unowned_connected && parent !== null && (parent.f & UNOWNED) === 0) {
derived2.f ^= UNOWNED;
}
}
for (i = 0; i < length; i++) {
dependency = dependencies[i];
if (is_dirty(
/** @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 schedule_possible_effect_self_invalidation(signal, effect, root2 = true) {
var reactions = signal.reactions;
if (reactions === null) return;
if (current_sources == null ? void 0 : current_sources.includes(signal)) {
return;
}
for (var i = 0; i < reactions.length; i++) {
var reaction = reactions[i];
if ((reaction.f & DERIVED) !== 0) {
schedule_possible_effect_self_invalidation(
/** @type {Derived} */
reaction,
effect,
false
);
} else if (effect === reaction) {
if (root2) {
set_signal_status(reaction, DIRTY);
} else if ((reaction.f & CLEAN) !== 0) {
set_signal_status(reaction, MAYBE_DIRTY);
}
schedule_effect(
/** @type {Effect} */
reaction
);
}
}
}
function update_reaction(reaction) {
var _a2;
var previous_deps = new_deps;
var previous_skipped_deps = skipped_deps;
var previous_untracked_writes = untracked_writes;
var previous_reaction = active_reaction;
var previous_skip_reaction = skip_reaction;
var previous_sources = current_sources;
var previous_component_context = component_context;
var previous_untracking = untracking;
var previous_update_version = update_version;
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;
current_sources = null;
set_component_context(reaction.ctx);
untracking = false;
update_version = ++read_version;
if (reaction.ac !== null) {
reaction.ac.abort(STALE_REACTION);
reaction.ac = null;
}
try {
reaction.f |= REACTION_IS_UPDATING;
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 || // Deriveds that already have reactions can cleanup, so we still add them as reactions
(flags & DERIVED) !== 0 && /** @type {import('#client').Derived} */
reaction.reactions !== null) {
for (i = skipped_deps; i < deps.length; i++) {
((_a2 = deps[i]).reactions ?? (_a2.reactions = [])).push(reaction);
}
}
} else if (deps !== null && skipped_deps < deps.length) {
remove_reactions(reaction, skipped_deps);
deps.length = skipped_deps;
}
if (is_runes() && untracked_writes !== null && !untracking && deps !== null && (reaction.f & (DERIVED | MAYBE_DIRTY | DIRTY)) === 0) {
for (i = 0; i < /** @type {Source[]} */
untracked_writes.length; i++) {
schedule_possible_effect_self_invalidation(
untracked_writes[i],
/** @type {Effect} */
reaction
);
}
}
if (previous_reaction !== null && previous_reaction !== reaction) {
read_version++;
if (untracked_writes !== null) {
if (previous_untracked_writes === null) {
previous_untracked_writes = untracked_writes;
} else {
previous_untracked_writes.push(.../** @type {Source[]} */
untracked_writes);
}
}
}
if ((reaction.f & ERROR_VALUE) !== 0) {
reaction.f ^= ERROR_VALUE;
}
return result;
} catch (error) {
return handle_error(error);
} finally {
reaction.f ^= REACTION_IS_UPDATING;
new_deps = previou