signalk-ais-target-prioritizer/plugin/index.cjs

Plots and priorizes AIS targets according to guard and CPA criteria.

"use strict";

require("@signalk/server-api");

var fs = require("node:fs");

var path = require("node:path");

require("partysocket");

var destination = require("@turf/destination");

var promises = require("node:stream/promises");

var tar = require("tar");

var node_stream = require("node:stream");

function _interopDefault(e) {
    return e && e.__esModule ? e : {
        default: e
    };
}

var fs__default = _interopDefault(fs);

var path__default = _interopDefault(path);

var destination__default = _interopDefault(destination);

const UNINITIALIZED = Symbol("uninitialized");

var DEV = false;

var is_array = Array.isArray;

var index_of = Array.prototype.indexOf;

var includes = Array.prototype.includes;

var get_descriptor = Object.getOwnPropertyDescriptor;

var object_prototype = Object.prototype;

var array_prototype = Array.prototype;

var get_prototype_of = Object.getPrototypeOf;

const noop = () => {};

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: promise,
        resolve: resolve,
        reject: reject
    };
}

const DERIVED = 1 << 1;

const EFFECT = 1 << 2;

const RENDER_EFFECT = 1 << 3;

const MANAGED_EFFECT = 1 << 24;

const BLOCK_EFFECT = 1 << 4;

const BRANCH_EFFECT = 1 << 5;

const ROOT_EFFECT = 1 << 6;

const BOUNDARY_EFFECT = 1 << 7;

const CONNECTED = 1 << 9;

const CLEAN = 1 << 10;

const DIRTY = 1 << 11;

const MAYBE_DIRTY = 1 << 12;

const INERT = 1 << 13;

const DESTROYED = 1 << 14;

const REACTION_RAN = 1 << 15;

const DESTROYING = 1 << 25;

const EAGER_EFFECT = 1 << 17;

const HEAD_EFFECT = 1 << 18;

const EFFECT_PRESERVED = 1 << 19;

const WAS_MARKED = 1 << 16;

const REACTION_IS_UPDATING = 1 << 21;

const ASYNC = 1 << 22;

const ERROR_VALUE = 1 << 23;

const STATE_SYMBOL = Symbol("$state");

const STALE_REACTION = new class extends Error {
    name="StaleReactionError";
    message="The reaction that called `getAbortSignal()` was re-run or destroyed";
};

function effect_update_depth_exceeded() {
    throw new Error(`https://svelte.dev/e/effect_update_depth_exceeded`);
}

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 derived_inert() {
    console.warn(`https://svelte.dev/e/derived_inert`);
}

function equals(value) {
    return value === this.v;
}

let tracing_mode_flag = false;

const empty = [];

function snapshot(value, skip_warning = false, no_tojson = false) {
    return clone(value, new Map, "", empty, null, no_tojson);
}

function clone(value, cloned, path, paths, original = null, no_tojson = false) {
    if (typeof value === "object" && value !== null) {
        var unwrapped = cloned.get(value);
        if (unwrapped !== void 0) return unwrapped;
        if (value instanceof Map) return new Map(value);
        if (value instanceof Set) return new Set(value);
        if (is_array(value)) {
            var copy = Array(value.length);
            cloned.set(value, copy);
            if (original !== null) cloned.set(original, copy);
            for (var i = 0; i < value.length; i += 1) {
                var element = value[i];
                if (i in value) copy[i] = clone(element, cloned, path, paths, null, no_tojson);
            }
            return copy;
        }
        if (get_prototype_of(value) === object_prototype) {
            copy = {};
            cloned.set(value, copy);
            if (original !== null) cloned.set(original, copy);
            for (var key of Object.keys(value)) copy[key] = clone(value[key], cloned, path, paths, null, no_tojson);
            return copy;
        }
        if (value instanceof Date) return structuredClone(value);
        if (typeof value.toJSON === "function" && !no_tojson) return clone(value.toJSON(), cloned, path, paths, value);
    }
    if (value instanceof EventTarget) return value;
    try {
        return structuredClone(value);
    } catch (e) {
        return value;
    }
}

let component_context = null;

function set_component_context(context) {
    component_context = context;
}

function is_runes() {
    return true;
}

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 && true) {
        var tasks = micro_tasks;
        queueMicrotask(() => {
            if (tasks === micro_tasks) run_micro_tasks();
        });
    }
    micro_tasks.push(fn);
}

function handle_error(error) {
    var effect = active_effect;
    if (effect === null) {
        active_reaction.f |= ERROR_VALUE;
        return error;
    }
    if ((effect.f & REACTION_RAN) === 0 && (effect.f & EFFECT) === 0) throw error;
    invoke_error_boundary(error, effect);
}

function invoke_error_boundary(error, effect) {
    if (effect !== null && (effect.f & DESTROYED) !== 0) return;
    while (effect !== null) {
        if ((effect.f & BOUNDARY_EFFECT) !== 0) {
            if ((effect.f & REACTION_RAN) === 0) throw error;
            try {
                effect.b.error(error);
                return;
            } catch (e) {
                error = e;
            }
        }
        effect = effect.parent;
    }
    throw error;
}

const STATUS_MASK = -7169;

function set_signal_status(signal, status) {
    signal.f = signal.f & STATUS_MASK | status;
}

function update_derived_status(derived) {
    if ((derived.f & CONNECTED) !== 0 || derived.deps === null) set_signal_status(derived, CLEAN); else set_signal_status(derived, MAYBE_DIRTY);
}

function clear_marked(deps) {
    if (deps === null) return;
    for (const dep of deps) {
        if ((dep.f & DERIVED) === 0 || (dep.f & WAS_MARKED) === 0) continue;
        dep.f ^= WAS_MARKED;
        clear_marked(dep.deps);
    }
}

function defer_effect(effect, dirty_effects, maybe_dirty_effects) {
    if ((effect.f & DIRTY) !== 0) dirty_effects.add(effect); else if ((effect.f & MAYBE_DIRTY) !== 0) maybe_dirty_effects.add(effect);
    clear_marked(effect.deps);
    set_signal_status(effect, CLEAN);
}

function without_reactive_context(fn) {
    var previous_reaction = active_reaction;
    var previous_effect = active_effect;
    set_active_reaction(null);
    set_active_effect(null);
    try {
        return fn();
    } finally {
        set_active_reaction(previous_reaction);
        set_active_effect(previous_effect);
    }
}

function derived(fn) {
    var flags = DERIVED | DIRTY;
    if (active_effect !== null) active_effect.f |= EFFECT_PRESERVED;
    const signal = {
        ctx: component_context,
        deps: null,
        effects: null,
        equals: equals,
        f: flags,
        fn: fn,
        reactions: null,
        rv: 0,
        v: UNINITIALIZED,
        wv: 0,
        parent: active_effect,
        ac: null
    };
    return signal;
}

const OBSOLETE = Symbol("obsolete");

function user_derived(fn) {
    const d = derived(fn);
    push_reaction_value(d);
    return 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(effects[i]);
    }
}

function execute_derived(derived) {
    var value;
    var prev_active_effect = active_effect;
    var parent = derived.parent;
    if (!is_destroying_effect && parent !== null && derived.v !== UNINITIALIZED && (parent.f & (DESTROYED | INERT)) !== 0) {
        derived_inert();
        return derived.v;
    }
    set_active_effect(parent);
    try {
        derived.f &= ~WAS_MARKED;
        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);
    if (!derived.equals(value)) {
        derived.wv = increment_write_version();
        if (!current_batch?.is_fork || derived.deps === null) {
            if (current_batch !== null) {
                current_batch.capture(derived, value, true);
                previous_batch?.capture(derived, value, true);
            } else derived.v = value;
            if (derived.deps === null) {
                set_signal_status(derived, CLEAN);
                return;
            }
        }
    }
    if (is_destroying_effect) return;
    if (batch_values !== null) {
        if (effect_tracking() || current_batch?.is_fork) batch_values.set(derived, value);
    } else update_derived_status(derived);
}

function freeze_derived_effects(derived) {
    if (derived.effects === null) return;
    for (const e of derived.effects) if (e.teardown || e.ac) {
        e.teardown?.();
        if (e.ac !== null) without_reactive_context(() => {
            e.ac.abort(STALE_REACTION);
            e.ac = null;
        });
        if (e.fn !== null) e.teardown = noop;
        remove_reactions(e, 0);
        destroy_effect_children(e);
    }
}

function unfreeze_derived_effects(derived) {
    if (derived.effects === null) return;
    for (const e of derived.effects) if (e.teardown && e.fn !== null) update_effect(e);
}

let first_batch = null;

let last_batch = null;

let current_batch = null;

let previous_batch = null;

let batch_values = null;

let last_scheduled_effect = null;

let is_processing = false;

let collected_effects = null;

let legacy_updates = null;

var flush_count = 0;

new Set;

let uid = 1;

class Batch {
    id=uid++;
    #started=false;
    linked=true;
    #prev=null;
    #next=null;
    async_deriveds=new Map;
    current=new Map;
    previous=new Map;
    #commit_callbacks=new Set;
    #discard_callbacks=new Set;
    #pending=0;
    #blocking_pending=new Map;
    #deferred=null;
    #roots=[];
    #new_effects=[];
    #dirty_effects=new Set;
    #maybe_dirty_effects=new Set;
    #skipped_branches=new Map;
    #unskipped_branches=new Set;
    is_fork=false;
    #decrement_queued=false;
    constructor() {
        if (last_batch === null) first_batch = last_batch = this; else {
            last_batch.#next = this;
            this.#prev = last_batch;
        }
        last_batch = this;
    }
    #is_deferred() {
        if (this.is_fork) return true;
        for (const effect of this.#blocking_pending.keys()) {
            var e = effect;
            var skipped = false;
            while (e.parent !== null) {
                if (this.#skipped_branches.has(e)) {
                    skipped = true;
                    break;
                }
                e = e.parent;
            }
            if (!skipped) return true;
        }
        return false;
    }
    skip_effect(effect) {
        if (!this.#skipped_branches.has(effect)) this.#skipped_branches.set(effect, {
            d: [],
            m: []
        });
        this.#unskipped_branches.delete(effect);
    }
    unskip_effect(effect, callback = e => this.schedule(e)) {
        var tracked = this.#skipped_branches.get(effect);
        if (tracked) {
            this.#skipped_branches.delete(effect);
            for (var e of tracked.d) {
                set_signal_status(e, DIRTY);
                callback(e);
            }
            for (e of tracked.m) {
                set_signal_status(e, MAYBE_DIRTY);
                callback(e);
            }
        }
        this.#unskipped_branches.add(effect);
    }
    #process() {
        this.#started = true;
        if (flush_count++ > 1e3) {
            this.#unlink();
            infinite_loop_guard();
        }
        for (const e of this.#dirty_effects) {
            this.#maybe_dirty_effects.delete(e);
            set_signal_status(e, DIRTY);
            this.schedule(e);
        }
        for (const e of this.#maybe_dirty_effects) {
            set_signal_status(e, MAYBE_DIRTY);
            this.schedule(e);
        }
        const roots = this.#roots;
        this.#roots = [];
        this.apply();
        var effects = collected_effects = [];
        var render_effects = [];
        var updates = legacy_updates = [];
        for (const root of roots) try {
            this.#traverse(root, effects, render_effects);
        } catch (e) {
            reset_all(root);
            if (!this.#is_deferred()) this.discard();
            throw e;
        }
        current_batch = null;
        if (updates.length > 0) {
            var batch = Batch.ensure();
            for (const e of updates) batch.schedule(e);
        }
        collected_effects = null;
        legacy_updates = null;
        if (this.#is_deferred()) {
            this.#defer_effects(render_effects);
            this.#defer_effects(effects);
            for (const [e, t] of this.#skipped_branches) reset_branch(e, t);
            if (updates.length > 0) current_batch.#process();
            return;
        }
        const earlier_batch = this.#find_earlier_batch();
        if (earlier_batch) {
            this.#defer_effects(render_effects);
            this.#defer_effects(effects);
            earlier_batch.#merge(this);
            return;
        }
        this.#dirty_effects.clear();
        this.#maybe_dirty_effects.clear();
        for (const fn of this.#commit_callbacks) fn(this);
        this.#commit_callbacks.clear();
        previous_batch = this;
        flush_queued_effects(render_effects);
        flush_queued_effects(effects);
        previous_batch = null;
        this.#deferred?.resolve();
        var next_batch = current_batch;
        if (this.#pending === 0 && (this.#roots.length === 0 || next_batch !== null)) this.#unlink();
        if (this.#roots.length > 0) if (next_batch !== null) {
            const batch = next_batch;
            batch.#roots.push(...this.#roots.filter(r => !batch.#roots.includes(r)));
        } else next_batch = this;
        if (next_batch !== null) next_batch.#process();
    }
    #traverse(root, effects, render_effects) {
        root.f ^= CLEAN;
        var effect = root.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_branches.has(effect);
            if (!skip && effect.fn !== null) {
                if (is_branch) effect.f ^= CLEAN; else if ((flags & EFFECT) !== 0) effects.push(effect); else if (is_dirty(effect)) {
                    if ((flags & BLOCK_EFFECT) !== 0) this.#maybe_dirty_effects.add(effect);
                    update_effect(effect);
                }
                var child = effect.first;
                if (child !== null) {
                    effect = child;
                    continue;
                }
            }
            while (effect !== null) {
                var next = effect.next;
                if (next !== null) {
                    effect = next;
                    break;
                }
                effect = effect.parent;
            }
        }
    }
    #find_earlier_batch() {
        var batch = this.#prev;
        while (batch !== null) {
            if (!batch.is_fork) for (const [value, [, is_derived]] of this.current) if (batch.current.has(value) && !is_derived) return batch;
            batch = batch.#prev;
        }
        return null;
    }
    #merge(batch) {
        for (const [source, value] of batch.current) {
            if (!this.previous.has(source) && batch.previous.has(source)) this.previous.set(source, batch.previous.get(source));
            this.current.set(source, value);
        }
        for (const [effect, deferred] of batch.async_deriveds) {
            const d = this.async_deriveds.get(effect);
            if (d) deferred.promise.then(d.resolve).catch(d.reject);
        }
        batch.async_deriveds.clear();
        this.transfer_effects(batch.#dirty_effects, batch.#maybe_dirty_effects);
        const mark = value => {
            var reactions = value.reactions;
            if (reactions === null) return;
            if ((value.f & DERIVED) !== 0 && (value.f & (DIRTY | MAYBE_DIRTY)) === 0) return;
            for (const reaction of reactions) {
                var flags = reaction.f;
                if ((flags & DERIVED) !== 0) mark(reaction); else {
                    var effect = reaction;
                    if (flags & (ASYNC | BLOCK_EFFECT) && !this.async_deriveds.has(effect)) {
                        this.#maybe_dirty_effects.delete(effect);
                        set_signal_status(effect, DIRTY);
                        this.schedule(effect);
                    }
                }
            }
        };
        for (const source of this.current.keys()) mark(source);
        this.oncommit(() => batch.discard());
        batch.#unlink();
        current_batch = this;
        this.#process();
    }
    #defer_effects(effects) {
        for (var i = 0; i < effects.length; i += 1) defer_effect(effects[i], this.#dirty_effects, this.#maybe_dirty_effects);
    }
    capture(source, value, is_derived = false) {
        if (source.v !== UNINITIALIZED && !this.previous.has(source)) this.previous.set(source, source.v);
        if ((source.f & ERROR_VALUE) === 0) {
            this.current.set(source, [ value, is_derived ]);
            batch_values?.set(source, value);
        }
        if (!this.is_fork) source.v = value;
    }
    activate() {
        current_batch = this;
    }
    deactivate() {
        current_batch = null;
        batch_values = null;
    }
    flush() {
        try {
            if (DEV) ;
            is_processing = true;
            current_batch = this;
            this.#process();
        } finally {
            flush_count = 0;
            last_scheduled_effect = null;
            collected_effects = null;
            legacy_updates = null;
            is_processing = false;
            current_batch = null;
            batch_values = null;
            old_values.clear();
        }
    }
    discard() {
        for (const fn of this.#discard_callbacks) fn(this);
        this.#discard_callbacks.clear();
        for (const deferred of this.async_deriveds.values()) deferred.reject(OBSOLETE);
        this.#unlink();
        this.#deferred?.resolve();
    }
    register_created_effect(effect) {
        this.#new_effects.push(effect);
    }
    #commit() {
        for (let batch = first_batch; batch !== null; batch = batch.#next) {
            var is_earlier = batch.id < this.id;
            var sources = [];
            for (const [source, [value, is_derived]] of this.current) {
                if (batch.current.has(source)) {
                    var batch_value = batch.current.get(source)[0];
                    if (is_earlier && value !== batch_value) batch.current.set(source, [ value, is_derived ]); else continue;
                }
                sources.push(source);
            }
            if (is_earlier) for (const [effect, deferred] of this.async_deriveds) {
                const d = batch.async_deriveds.get(effect);
                if (d) deferred.promise.then(d.resolve).catch(d.reject);
            }
            var current = [ ...batch.current.keys() ].filter(source => !batch.current.get(source)[1]);
            if (!batch.#started || current.length === 0) continue;
            var others = current.filter(source => !this.current.has(source));
            if (others.length === 0) {
                if (is_earlier) batch.discard();
            } else if (sources.length > 0) {
                if (is_earlier) for (const unskipped of this.#unskipped_branches) batch.unskip_effect(unskipped, e => {
                    if ((e.f & (BLOCK_EFFECT | ASYNC)) !== 0) batch.schedule(e); else batch.#defer_effects([ e ]);
                });
                batch.activate();
                var marked = new Set;
                var checked = new Map;
                for (var source of sources) mark_effects(source, others, marked, checked);
                checked = new Map;
                var current_unequal = [ ...batch.current ].filter(([c, v1]) => {
                    const v2 = this.current.get(c);
                    if (!v2) return true;
                    return v2[0] !== v1[0] || v2[1] !== v1[1];
                }).map(([c]) => c);
                if (current_unequal.length > 0) for (const effect of this.#new_effects) if ((effect.f & (DESTROYED | INERT | EAGER_EFFECT)) === 0 && depends_on(effect, current_unequal, checked)) if ((effect.f & (ASYNC | BLOCK_EFFECT)) !== 0) {
                    set_signal_status(effect, DIRTY);
                    batch.schedule(effect);
                } else batch.#dirty_effects.add(effect);
                if (batch.#roots.length > 0 && !batch.#decrement_queued) {
                    batch.apply();
                    for (var root of batch.#roots) batch.#traverse(root, [], []);
                    batch.#roots = [];
                }
                batch.deactivate();
            }
        }
    }
    increment(blocking, effect) {
        this.#pending += 1;
        if (blocking) {
            let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;
            this.#blocking_pending.set(effect, blocking_pending_count + 1);
        }
    }
    decrement(blocking, effect) {
        this.#pending -= 1;
        if (blocking) {
            let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;
            if (blocking_pending_count === 1) this.#blocking_pending.delete(effect); else this.#blocking_pending.set(effect, blocking_pending_count - 1);
        }
        if (this.#decrement_queued) return;
        this.#decrement_queued = true;
        queue_micro_task(() => {
            this.#decrement_queued = false;
            if (this.linked) this.flush();
        });
    }
    transfer_effects(dirty_effects, maybe_dirty_effects) {
        for (const e of dirty_effects) this.#dirty_effects.add(e);
        for (const e of maybe_dirty_effects) this.#maybe_dirty_effects.add(e);
        dirty_effects.clear();
        maybe_dirty_effects.clear();
    }
    oncommit(fn) {
        this.#commit_callbacks.add(fn);
    }
    ondiscard(fn) {
        this.#discard_callbacks.add(fn);
    }
    settled() {
        return (this.#deferred ??= deferred()).promise;
    }
    static ensure() {
        if (current_batch === null) {
            const batch = current_batch = new Batch;
            if (!is_processing && true) queue_micro_task(() => {
                if (!batch.#started) batch.flush();
            });
        }
        return current_batch;
    }
    apply() {
        batch_values = null;
        return;
    }
    schedule(effect) {
        last_scheduled_effect = effect;
        if (effect.b?.is_pending && (effect.f & (EFFECT | RENDER_EFFECT | MANAGED_EFFECT)) !== 0 && (effect.f & REACTION_RAN) === 0) {
            effect.b.defer_effect(effect);
            return;
        }
        var e = effect;
        while (e.parent !== null) {
            e = e.parent;
            var flags = e.f;
            if (collected_effects !== null && e === active_effect) if ((active_reaction === null || (active_reaction.f & DERIVED) === 0) && true) return;
            if ((flags & (ROOT_EFFECT | BRANCH_EFFECT)) !== 0) {
                if ((flags & CLEAN) === 0) return;
                e.f ^= CLEAN;
            }
        }
        this.#roots.push(e);
    }
    #unlink() {
        if (!this.linked) return;
        var prev = this.#prev;
        var next = this.#next;
        if (prev === null) first_batch = next; else prev.#next = next;
        if (next === null) last_batch = prev; else next.#prev = prev;
        this.linked = false;
    }
}

function infinite_loop_guard() {
    try {
        effect_update_depth_exceeded();
    } catch (error) {
        invoke_error_boundary(error, last_scheduled_effect);
    }
}

let eager_block_effects = null;

function flush_queued_effects(effects) {
    var length = effects.length;
    if (length === 0) return;
    var i = 0;
    while (i < length) {
        var effect = effects[i++];
        if ((effect.f & (DESTROYED | INERT)) === 0 && is_dirty(effect)) {
            eager_block_effects = new Set;
            update_effect(effect);
            if (effect.deps === null && effect.first === null && effect.nodes === null && effect.teardown === null && effect.ac === null) unlink_effect(effect);
            if (eager_block_effects?.size > 0) {
                old_values.clear();
                for (const e of eager_block_effects) {
                    if ((e.f & (DESTROYED | INERT)) !== 0) continue;
                    const ordered_effects = [ e ];
                    let ancestor = e.parent;
                    while (ancestor !== null) {
                        if (eager_block_effects.has(ancestor)) {
                            eager_block_effects.delete(ancestor);
                            ordered_effects.push(ancestor);
                        }
                        ancestor = ancestor.parent;
                    }
                    for (let j = ordered_effects.length - 1; j >= 0; j--) {
                        const e = ordered_effects[j];
                        if ((e.f & (DESTROYED | INERT)) !== 0) continue;
                        update_effect(e);
                    }
                }
                eager_block_effects.clear();
            }
        }
    }
    eager_block_effects = null;
}

function mark_effects(value, sources, marked, checked) {
    if (marked.has(value)) return;
    marked.add(value);
    if (value.reactions !== null) for (const reaction of value.reactions) {
        const flags = reaction.f;
        if ((flags & DERIVED) !== 0) mark_effects(reaction, sources, marked, checked); else if ((flags & (ASYNC | BLOCK_EFFECT)) !== 0 && (flags & DIRTY) === 0 && depends_on(reaction, sources, checked)) {
            set_signal_status(reaction, DIRTY);
            schedule_effect(reaction);
        }
    }
}

function depends_on(reaction, sources, checked) {
    const depends = checked.get(reaction);
    if (depends !== void 0) return depends;
    if (reaction.deps !== null) for (const dep of reaction.deps) {
        if (includes.call(sources, dep)) return true;
        if ((dep.f & DERIVED) !== 0 && depends_on(dep, sources, checked)) {
            checked.set(dep, true);
            return true;
        }
    }
    checked.set(reaction, false);
    return false;
}

function schedule_effect(effect) {
    current_batch.schedule(effect);
}

function reset_branch(effect, tracked) {
    if ((effect.f & BRANCH_EFFECT) !== 0 && (effect.f & CLEAN) !== 0) return;
    if ((effect.f & DIRTY) !== 0) tracked.d.push(effect); else if ((effect.f & MAYBE_DIRTY) !== 0) tracked.m.push(effect);
    set_signal_status(effect, CLEAN);
    var e = effect.first;
    while (e !== null) {
        reset_branch(e, tracked);
        e = e.next;
    }
}

function reset_all(effect) {
    set_signal_status(effect, CLEAN);
    var e = effect.first;
    while (e !== null) {
        reset_all(e);
        e = e.next;
    }
}

let eager_effects = new Set;

const old_values = new Map;

let eager_effects_deferred = false;

function source(v, stack) {
    var signal = {
        f: 0,
        v: v,
        reactions: null,
        equals: equals,
        rv: 0,
        wv: 0
    };
    return signal;
}

function state(v, stack) {
    const s = source(v);
    push_reaction_value(s);
    return s;
}

function set(source, value, should_proxy = false) {
    if (active_reaction !== null && (!untracking || (active_reaction.f & EAGER_EFFECT) !== 0) && is_runes() && (active_reaction.f & (DERIVED | BLOCK_EFFECT | ASYNC | EAGER_EFFECT)) !== 0 && (current_sources === null || !current_sources.has(source))) state_unsafe_mutation();
    let new_value = should_proxy ? proxy(value) : value;
    return internal_set(source, new_value, legacy_updates);
}

function internal_set(source, value, updated_during_traversal = null) {
    if (!source.equals(value)) {
        old_values.set(source, is_destroying_effect ? value : source.v);
        var batch = Batch.ensure();
        batch.capture(source, value);
        if ((source.f & DERIVED) !== 0) {
            const derived = source;
            if ((source.f & DIRTY) !== 0) execute_derived(derived);
            if (batch_values === null) update_derived_status(derived);
        }
        source.wv = increment_write_version();
        mark_reactions(source, DIRTY, updated_during_traversal);
        if (active_effect !== null && (active_effect.f & CLEAN) !== 0 && (active_effect.f & (BRANCH_EFFECT | ROOT_EFFECT)) === 0) if (untracked_writes === null) set_untracked_writes([ source ]); else untracked_writes.push(source);
        if (!batch.is_fork && eager_effects.size > 0 && !eager_effects_deferred) flush_eager_effects();
    }
    return value;
}

function flush_eager_effects() {
    eager_effects_deferred = false;
    for (const effect of eager_effects) {
        if ((effect.f & CLEAN) !== 0) set_signal_status(effect, MAYBE_DIRTY);
        let dirty;
        try {
            dirty = is_dirty(effect);
        } catch {
            dirty = true;
        }
        if (dirty) update_effect(effect);
    }
    eager_effects.clear();
}

function increment(source) {
    set(source, source.v + 1);
}

function mark_reactions(signal, status, updated_during_traversal) {
    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;
        var not_dirty = (flags & DIRTY) === 0;
        if (not_dirty) set_signal_status(reaction, status);
        if ((flags & EAGER_EFFECT) !== 0) eager_effects.add(reaction); else if ((flags & DERIVED) !== 0) {
            var derived = reaction;
            batch_values?.delete(derived);
            if ((flags & WAS_MARKED) === 0) {
                if (flags & CONNECTED && (active_effect === null || (active_effect.f & REACTION_IS_UPDATING) === 0)) reaction.f |= WAS_MARKED;
                mark_reactions(derived, MAYBE_DIRTY, updated_during_traversal);
            }
        } else if (not_dirty) {
            var effect = reaction;
            if ((flags & BLOCK_EFFECT) !== 0 && eager_block_effects !== null) eager_block_effects.add(effect);
            if (updated_during_traversal !== null) updated_during_traversal.push(effect); else schedule_effect(effect);
        }
    }
}

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 = new Map;
    var is_proxied_array = is_array(value);
    var version = state(0);
    var parent_version = update_version;
    var with_parent = fn => {
        if (update_version === parent_version) return fn();
        var reaction = active_reaction;
        var version = update_version;
        set_active_reaction(null);
        set_update_version(parent_version);
        var result = fn();
        set_active_reaction(reaction);
        set_update_version(version);
        return result;
    };
    if (is_proxied_array) sources.set("length", state(value.length));
    return new Proxy(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) with_parent(() => {
                var s = state(descriptor.value);
                sources.set(prop, s);
                return s;
            }); else set(s, descriptor.value, true);
            return true;
        },
        deleteProperty(target, prop) {
            var s = sources.get(prop);
            if (s === void 0) {
                if (prop in target) {
                    const s = with_parent(() => state(UNINITIALIZED));
                    sources.set(prop, s);
                    increment(version);
                }
            } else {
                set(s, UNINITIALIZED);
                increment(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(() => {
                    var p = proxy(exists ? target[prop] : UNINITIALIZED);
                    var s = state(p);
                    return s;
                });
                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 source = sources.get(prop);
                var value = source?.v;
                if (source !== void 0 && value !== UNINITIALIZED) return {
                    enumerable: true,
                    configurable: true,
                    value: value,
                    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(() => {
                        var p = has ? proxy(target[prop]) : UNINITIALIZED;
                        var s = state(p);
                        return s;
                    });
                    sources.set(prop, s);
                }
                var value = get(s);
                if (value === UNINITIALIZED) return false;
            }
            return has;
        },
        set(target, prop, value, receiver) {
            var s = sources.get(prop);
            var has = prop in target;
            if (is_proxied_array && prop === "length") for (var i = value; i < 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(() => state(UNINITIALIZED));
                    sources.set(i + "", other_s);
                }
            }
            if (s === void 0) {
                if (!has || get_descriptor(target, prop)?.writable) {
                    s = with_parent(() => state(void 0));
                    set(s, proxy(value));
                    sources.set(prop, s);
                }
            } else {
                has = s.v !== UNINITIALIZED;
                var p = with_parent(() => proxy(value));
                set(s, p);
            }
            var descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
            if (descriptor?.set) descriptor.set.call(receiver, value);
            if (!has) {
                if (is_proxied_array && typeof prop === "string") {
                    var ls = sources.get("length");
                    var n = Number(prop);
                    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(key => {
                var source = sources.get(key);
                return source === void 0 || source.v !== UNINITIALIZED;
            });
            for (var [key, source] of sources) if (source.v !== UNINITIALIZED && !(key in target)) own_keys.push(key);
            return own_keys;
        },
        setPrototypeOf() {
            state_prototype_fixed();
        }
    });
}

var next_sibling_getter;

function get_next_sibling(node) {
    return next_sibling_getter.call(node);
}

function effect_tracking() {
    return active_reaction !== null && !untracking;
}

function execute_effect_teardown(effect) {
    var teardown = effect.teardown;
    if (teardown !== null) {
        const previously_destroying_effect = is_destroying_effect;
        const previous_reaction = active_reaction;
        set_is_destroying_effect(true);
        set_active_reaction(null);
        try {
            teardown.call(null);
        } finally {
            set_is_destroying_effect(previously_destroying_effect);
            set_active_reaction(previous_reaction);
        }
    }
}

function destroy_effect_children(signal, remove_dom = false) {
    var effect = signal.first;
    signal.first = signal.last = null;
    while (effect !== null) {
        const controller = effect.ac;
        if (controller !== null) without_reactive_context(() => {
            controller.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 !== null && effect.nodes.end !== null) {
        remove_effect_dom(effect.nodes.start, effect.nodes.end);
        removed = true;
    }
    effect.f |= DESTROYING;
    destroy_effect_children(effect, remove_dom && !removed);
    remove_reactions(effect, 0);
    var transitions = effect.nodes && effect.nodes.t;
    if (transitions !== null) for (const transition of transitions) transition.stop();
    execute_effect_teardown(effect);
    effect.f ^= DESTROYING;
    effect.f |= DESTROYED;
    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 = effect.ac = effect.b = null;
}

function remove_effect_dom(node, end) {
    while (node !== null) {
        var next = node === end ? null : 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;
    }
}

let is_updating_effect = false;

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) (current_sources ??= new Set).add(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;
}

function increment_write_version() {
    return ++write_version;
}

function is_dirty(reaction) {
    var flags = reaction.f;
    if ((flags & DIRTY) !== 0) return true;
    if (flags & DERIVED) reaction.f &= ~WAS_MARKED;
    if ((flags & MAYBE_DIRTY) !== 0) {
        var dependencies = reaction.deps;
        var length = dependencies.length;
        for (var i = 0; i < length; i++) {
            var dependency = dependencies[i];
            if (is_dirty(dependency)) update_derived(dependency);
            if (dependency.wv > reaction.wv) return true;
        }
        if ((flags & CONNECTED) !== 0 && batch_values === null) set_signal_status(reaction, CLEAN);
    }
    return false;
}

function schedule_possible_effect_self_invalidation(signal, effect, root = true) {
    var reactions = signal.reactions;
    if (reactions === null) return;
    if (current_sources !== null && current_sources.has(signal)) return;
    for (var i = 0; i < reactions.length; i++) {
        var reaction = reactions[i];
        if ((reaction.f & DERIVED) !== 0) schedule_possible_effect_self_invalidation(reaction, effect, false); else if (effect === reaction) {
            if (root) set_signal_status(reaction, DIRTY); else if ((reaction.f & CLEAN) !== 0) set_signal_status(reaction, MAYBE_DIRTY);
            schedule_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_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 = null;
    skipped_deps = 0;
    untracked_writes = 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) {
        without_reactive_context(() => {
            reaction.ac.abort(STALE_REACTION);
        });
        reaction.ac = null;
    }
    try {
        reaction.f |= REACTION_IS_UPDATING;
        var fn = reaction.fn;
        var result = fn();
        reaction.f |= REACTION_RAN;
        var deps = reaction.deps;
        var is_fork = current_batch?.is_fork;
        if (new_deps !== null) {
            var i;
            if (!is_fork) 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 (effect_tracking() && (reaction.f & CONNECTED) !== 0) for (i = skipped_deps; i < deps.length; i++) (deps[i].reactions ??= []).push(reaction);
        } else if (!is_fork && 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 < untracked_writes.length; i++) schedule_possible_effect_self_invalidation(untracked_writes[i], reaction);
        if (previous_reaction !== null && previous_reaction !== reaction) {
            read_version++;
            if (previous_reaction.deps !== null) for (let i = 0; i < previous_skipped_deps; i += 1) previous_reaction.deps[i].rv = read_version;
            if (previous_deps !== null) for (const dep of previous_deps) dep.rv = read_version;
            if (untracked_writes !== null) if (previous_untracked_writes === null) previous_untracked_writes = untracked_writes; else previous_untracked_writes.push(...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 = previous_deps;
        skipped_deps = previous_skipped_deps;
        untracked_writes = previous_untracked_writes;
        active_reaction = previous_reaction;
        current_sources = previous_sources;
        set_component_context(previous_component_context);
        untracking = previous_untracking;
        update_version = previous_update_version;
    }
}

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 && (new_deps === null || !includes.call(new_deps, dependency))) {
        var derived = dependency;
        if ((derived.f & CONNECTED) !== 0) {
            derived.f ^= CONNECTED;
            derived.f &= ~WAS_MARKED;
        }
        if (derived.v !== UNINITIALIZED) update_derived_status(derived);
        if (derived.ac !== null) without_reactive_context(() => {
            derived.ac.abort(STALE_REACTION);
            derived.ac = null;
            set_signal_status(derived, DIRTY);
        });
        freeze_derived_effects(derived);
        remove_reactions(derived, 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(effect) {
    var flags = effect.f;
    if ((flags & DESTROYED) !== 0) return;
    set_signal_status(effect, CLEAN);
    var previous_effect = active_effect;
    var was_updating_effect = is_updating_effect;
    active_effect = effect;
    is_updating_effect = (flags & (BRANCH_EFFECT | ROOT_EFFECT)) === 0;
    try {
        if ((flags & (BLOCK_EFFECT | MANAGED_EFFECT)) !== 0) destroy_block_effect_children(effect); else destroy_effect_children(effect);
        execute_effect_teardown(effect);
        var teardown = update_reaction(effect);
        effect.teardown = typeof teardown === "function" ? teardown : null;
        effect.wv = write_version;
        if (DEV && tracing_mode_flag && (effect.f & DIRTY) !== 0 && effect.deps !== null) ;
    } finally {
        is_updating_effect = was_updating_effect;
        active_effect = previous_effect;
    }
}

function get(signal) {
    var flags = signal.f;
    var is_derived = (flags & DERIVED) !== 0;
    if (active_reaction !== null && !untracking) {
        var destroyed = active_effect !== null && (active_effect.f & DESTROYED) !== 0;
        if (!destroyed && (current_sources === null || !current_sources.has(signal))) {
            var deps = active_reaction.deps;
            if ((active_reaction.f & REACTION_IS_UPDATING) !== 0) {
                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 new_deps.push(signal);
                }
            } else {
                active_reaction.deps ??= [];
                if (!includes.call(active_reaction.deps, signal)) active_reaction.deps.push(signal);
                var reactions = signal.reactions;
                if (reactions === null) signal.reactions = [ active_reaction ]; else if (!includes.call(reactions, active_reaction)) reactions.push(active_reaction);
            }
        }
    }
    if (is_destroying_effect && old_values.has(signal)) return old_values.get(signal);
    if (is_derived) {
        var derived = signal;
        if (is_destroying_effect) {
            var value = derived.v;
            if ((derived.f & CLEAN) === 0 && derived.reactions !== null || depends_on_old_values(derived)) value = execute_derived(derived);
            old_values.set(derived, value);
            return value;
        }
        var should_connect = (derived.f & CONNECTED) === 0 && !untracking && active_reaction !== null && (is_updating_effect || (active_reaction.f & CONNECTED) !== 0);
        var is_new = (derived.f & REACTION_RAN) === 0;
        if (is_dirty(derived)) {
            if (should_connect) derived.f |= CONNECTED;
            update_derived(derived);
        }
        if (should_connect && !is_new) {
            unfreeze_derived_effects(derived);
            reconnect(derived);
        }
    }
    if (batch_values?.has(signal)) return batch_values.get(signal);
    if ((signal.f & ERROR_VALUE) !== 0) throw signal.v;
    return signal.v;
}

function reconnect(derived) {
    derived.f |= CONNECTED;
    if (derived.deps === null) return;
    for (const dep of derived.deps) {
        (dep.reactions ??= []).push(derived);
        if ((dep.f & DERIVED) !== 0 && (dep.f & CONNECTED) === 0) {
            unfreeze_derived_effects(dep);
            reconnect(dep);
        }
    }
}

function depends_on_old_values(derived) {
    if (derived.v === UNINITIALIZ