{"version":3,"sources":["jsdelivr-header.js","/npm/spred@0.34.0/dist/index.js"],"names":[],"mappings":"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","file":"/npm/spred@0.34.0/dist/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.37.0.\n * Original file: /npm/spred@0.34.0/dist/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","'use strict';\n\nconst DEFAULT_CONFIG = {\n    logException: /* istanbul ignore next */ (e) => console.error(e),\n};\nconst config = Object.assign({}, DEFAULT_CONFIG);\nfunction configure(configUpdate) {\n    Object.assign(config, configUpdate || DEFAULT_CONFIG);\n}\n\nconst ERROR_NAME = '[SPRED ERROR]';\nclass CircularDependencyError extends Error {\n    constructor() {\n        super();\n        this.name = ERROR_NAME;\n        this.message = 'Circular dependency detected';\n    }\n}\n\nconst NOOP_FN = () => { };\nconst TRACKING = 1 << 0;\nconst NOTIFIED = 1 << 1;\nconst CHANGED = 1 << 2;\nconst ACTIVATING = 1 << 3;\nconst FORCED = 1 << 4;\nconst HAS_EXCEPTION = 1 << 5;\nconst FREEZED = 1 << 6;\n\nlet computing = null;\nlet scope = null;\nlet node = null;\nlet batchLevel = 0;\nlet shouldLink = false;\nlet providers = [];\nlet consumers = [];\nlet notifications = [];\nlet version = 1;\nfunction Signal(compute, options) {\n    const parent = computing || scope;\n    this._value = undefined;\n    this._nextValue = undefined;\n    this._compute = compute;\n    this._flags = 0;\n    this._subs = 0;\n    this._version = 0;\n    this._firstSource = null;\n    this._lastSource = null;\n    this._firstTarget = null;\n    this._lastTarget = null;\n    if (options) {\n        for (let key in options) {\n            this[key] = options[key];\n        }\n    }\n    if (parent)\n        createChildNode(parent, this);\n}\nSignal.prototype.get = get;\nSignal.prototype.subscribe = subscribe;\nSignal.prototype.equals = Object.is;\nfunction WritableSignal(value, options) {\n    Signal.call(this, undefined, options);\n    this._value = value;\n    this._nextValue = value;\n}\nWritableSignal.prototype = new Signal();\nWritableSignal.prototype.constructor = WritableSignal;\nWritableSignal.prototype.set = set;\nWritableSignal.prototype.update = update;\nfunction isolate(fn, args) {\n    const prevComputing = computing;\n    const prevScope = scope;\n    const prevShouldLink = shouldLink;\n    let result;\n    if (computing)\n        scope = computing;\n    shouldLink = false;\n    computing = null;\n    if (args)\n        result = fn(...args);\n    else\n        result = fn();\n    computing = prevComputing;\n    scope = prevScope;\n    shouldLink = prevShouldLink;\n    return result;\n}\nfunction collect(fn) {\n    const prevComputing = computing;\n    const prevScope = scope;\n    const prevShouldLink = shouldLink;\n    const fakeState = {};\n    shouldLink = false;\n    scope = fakeState;\n    computing = null;\n    fn();\n    computing = prevComputing;\n    scope = prevScope;\n    shouldLink = prevShouldLink;\n    return () => cleanupChildren(fakeState);\n}\n/**\n * Commits all writable signal updates inside the passed function as a single transaction.\n * @param fn The function with updates.\n */\nfunction batch(fn) {\n    const wrapper = config._notificationWrapper;\n    ++batchLevel;\n    fn();\n    --batchLevel;\n    if (wrapper)\n        wrapper(recalc);\n    else\n        recalc();\n}\nfunction set(value) {\n    const wrapper = config._notificationWrapper;\n    if (arguments.length) {\n        this._nextValue = value;\n    }\n    else {\n        this._flags |= FORCED;\n    }\n    providers.push(this);\n    if (wrapper)\n        wrapper(recalc);\n    else\n        recalc();\n    return this._nextValue;\n}\nfunction update(updateFn) {\n    return this.set(updateFn(this._nextValue));\n}\nfunction notify(state) {\n    state._flags |= NOTIFIED;\n    if (typeof state._nextValue === 'object' &&\n        state._nextValue &&\n        state._nextValue.shit) ;\n    if (state._subs)\n        consumers.push(state);\n    for (let node = state._firstTarget; node !== null; node = node.next) {\n        if (typeof node.value === 'object' && !(node.value._flags & NOTIFIED)) {\n            notify(node.value);\n        }\n    }\n}\nfunction subscribe(subscriber, exec = true) {\n    const prevShouldLink = shouldLink;\n    const runSubscriber = () => {\n        batch(() => {\n            try {\n                subscriber(value, true);\n            }\n            catch (e) {\n                config.logException(e);\n            }\n        });\n    };\n    if (!(this._flags & FREEZED) && !this._firstTarget) {\n        shouldLink = true;\n        this._flags |= ACTIVATING;\n    }\n    const value = this.get(false);\n    shouldLink = prevShouldLink;\n    this._flags &= ~ACTIVATING;\n    if (this._flags & FREEZED) {\n        if (exec)\n            isolate(runSubscriber);\n        return NOOP_FN;\n    }\n    let node = createTargetNode(this, subscriber, null);\n    ++this._subs;\n    if (exec)\n        isolate(runSubscriber);\n    const dispose = () => {\n        if (!node)\n            return;\n        removeTargetNode(this, node);\n        --this._subs;\n        node = null;\n    };\n    const parent = computing || scope;\n    if (parent)\n        createChildNode(parent, dispose);\n    return dispose;\n}\nfunction recalc() {\n    if (!providers.length || batchLevel)\n        return;\n    const q = providers;\n    const prevShouldLink = shouldLink;\n    providers = [];\n    consumers = [];\n    shouldLink = true;\n    ++version;\n    ++batchLevel;\n    for (let state of q) {\n        if (state._flags & FORCED ||\n            (state._nextValue !== undefined &&\n                !state.equals(state._nextValue, state._value))) {\n            notify(state);\n        }\n    }\n    for (let state of consumers) {\n        if (state._subs)\n            state.get();\n    }\n    shouldLink = prevShouldLink;\n    for (let i = 0; i < notifications.length; i += 2) {\n        try {\n            notifications[i](notifications[i + 1]);\n        }\n        catch (e) {\n            config.logException(e);\n        }\n    }\n    notifications = [];\n    --batchLevel;\n    recalc();\n}\nfunction get(trackDependency = true) {\n    if (this._compute) {\n        if (this._flags & FREEZED)\n            return this._value;\n        if (this._flags & TRACKING) {\n            throw new CircularDependencyError();\n        }\n    }\n    if (this._version !== version) {\n        const sourcesChanged = checkSources(this);\n        this._flags &= ~CHANGED;\n        if (this._compute && sourcesChanged)\n            compute(this);\n        if (this._flags & HAS_EXCEPTION) {\n            if (this._subs || this._flags & ACTIVATING)\n                config.logException(this._exception);\n        }\n        else if (this._flags & FORCED ||\n            (sourcesChanged &&\n                this._nextValue !== undefined &&\n                !this.equals(this._nextValue, this._value))) {\n            if (this.onUpdate)\n                this.onUpdate(this._nextValue, this._value);\n            this._value = this._nextValue;\n            this._flags |= CHANGED;\n            if (this._subs) {\n                for (let node = this._firstTarget; node !== null; node = node.next) {\n                    if (typeof node.value === 'function')\n                        notifications.push(node.value, this._value);\n                }\n            }\n        }\n    }\n    this._version = version;\n    this._flags &= ~NOTIFIED;\n    this._flags &= ~FORCED;\n    if (computing && trackDependency) {\n        if (this._flags & HAS_EXCEPTION && !(computing._flags & HAS_EXCEPTION)) {\n            computing._exception = this._exception;\n            computing._flags |= HAS_EXCEPTION;\n        }\n        if (node) {\n            if (node.value !== this) {\n                if (node.link)\n                    removeTargetNode(node.value, node.link);\n                node.value = this;\n                if (shouldLink)\n                    createTargetNode(this, computing, node);\n                else\n                    node.link = null;\n            }\n            node = node.next;\n        }\n        else {\n            const n = createSourceNode(this, computing);\n            if (shouldLink)\n                createTargetNode(this, computing, n);\n        }\n    }\n    return this._value;\n}\nfunction checkSources(state) {\n    if (state._firstSource) {\n        let sameSources = true;\n        let hasException = false;\n        for (let node = state._firstSource; node !== null; node = node.next) {\n            const source = node.value;\n            if (!(state._flags & NOTIFIED) && source._version !== state._version) {\n                sameSources = false;\n                break;\n            }\n            source.get(false);\n            if (source._flags & HAS_EXCEPTION) {\n                hasException = true;\n                state._flags |= HAS_EXCEPTION;\n                state._exception = source._exception;\n                break;\n            }\n            else if (source._flags & CHANGED) {\n                sameSources = false;\n                break;\n            }\n        }\n        if (sameSources && !hasException) {\n            return false;\n        }\n    }\n    return true;\n}\nfunction compute(state) {\n    const scheduled = !!(state._flags & NOTIFIED);\n    const prevComputing = computing;\n    const prevNode = node;\n    computing = state;\n    node = state._firstSource;\n    state._flags |= TRACKING;\n    state._flags &= ~HAS_EXCEPTION;\n    try {\n        if (state._firstChild)\n            cleanupChildren(state);\n        state._nextValue = state._compute(state._value, scheduled);\n    }\n    catch (e) {\n        state._exception = e;\n        state._flags |= HAS_EXCEPTION;\n    }\n    if (state._flags & HAS_EXCEPTION) {\n        if (state.catch) {\n            try {\n                state._nextValue = state.catch(state._exception, state._value);\n                state._flags &= ~HAS_EXCEPTION;\n                state._exception = undefined;\n            }\n            catch (e) {\n                state._exception = e;\n            }\n        }\n        if (state._flags & HAS_EXCEPTION && state.onException) {\n            state.onException(state._exception);\n        }\n    }\n    while (node) {\n        removeSourceNode(state, node);\n        node = node.next;\n    }\n    if (!state._firstSource)\n        state._flags |= FREEZED;\n    state._flags &= ~TRACKING;\n    computing = prevComputing;\n    node = prevNode;\n}\nfunction cleanupChildren(state) {\n    for (let node = state._firstChild; node; node = node.next) {\n        if (typeof node.value === 'function')\n            node.value();\n        else\n            cleanupChildren(node.value);\n    }\n    state._firstChild = null;\n    state._lastChild = null;\n}\nfunction createSourceNode(source, target) {\n    const node = {\n        value: source,\n        prev: target._lastSource,\n        next: null,\n        link: null,\n    };\n    if (!target._lastSource) {\n        target._firstSource = node;\n    }\n    else {\n        target._lastSource.next = node;\n    }\n    target._lastSource = node;\n    return node;\n}\nfunction removeSourceNode(state, node) {\n    if (state._firstSource === node)\n        state._firstSource = node.next;\n    if (state._lastSource === node)\n        state._lastSource = node.prev;\n    if (node.prev)\n        node.prev.next = node.next;\n    if (node.next)\n        node.next.prev = node.prev;\n    if (node.link) {\n        removeTargetNode(node.value, node.link);\n        node.link = null;\n    }\n}\nfunction createTargetNode(source, target, sourceNode) {\n    const node = {\n        value: target,\n        prev: source._lastTarget,\n        next: null,\n    };\n    if (source._lastTarget) {\n        source._lastTarget.next = node;\n    }\n    else {\n        source._firstTarget = node;\n        linkDependencies(source);\n        if (source.onActivate)\n            source.onActivate(source._value);\n    }\n    source._lastTarget = node;\n    if (sourceNode)\n        sourceNode.link = node;\n    return node;\n}\nfunction removeTargetNode(state, node) {\n    if (state._firstTarget === node)\n        state._firstTarget = node.next;\n    if (state._lastTarget === node)\n        state._lastTarget = node.prev;\n    if (node.prev)\n        node.prev.next = node.next;\n    if (node.next)\n        node.next.prev = node.prev;\n    if (!state._firstTarget) {\n        unlinkDependencies(state);\n        if (state.onDeactivate)\n            state.onDeactivate(state._value);\n    }\n}\nfunction createChildNode(parent, child) {\n    const node = {\n        value: child,\n        prev: parent._lastChild || null,\n        next: null,\n    };\n    if (parent._lastChild) {\n        parent._lastChild.next = node;\n    }\n    else {\n        parent._firstChild = node;\n    }\n    parent._lastChild = node;\n    return node;\n}\nfunction linkDependencies(state) {\n    for (let node = state._firstSource; node !== null; node = node.next) {\n        if (!node.link) {\n            createTargetNode(node.value, state, node);\n            linkDependencies(node.value);\n        }\n    }\n}\nfunction unlinkDependencies(state) {\n    state._flags &= ~NOTIFIED;\n    for (let node = state._firstSource; node !== null; node = node.next) {\n        if (node.link) {\n            removeTargetNode(node.value, node.link);\n            node.link = null;\n        }\n    }\n}\n\nfunction writable(value, options) {\n    return new WritableSignal(value, options);\n}\n\n/**\n * Creates a signal that automatically calculates its value from other signals.\n * @param compute The function that calculates the signal value and returns it.\n * @param options Signal options.\n * @returns Computed signal.\n */\nfunction computed(compute, options) {\n    return new Signal(compute, options);\n}\n\n/**\n * Subscribes the function to updates of the signal value.\n * @param signal Signal.\n * @param subscriber Function that listens to the signal updates.\n * @returns Unsubscribe function.\n */\nfunction on(signal, subscriber) {\n    return signal.subscribe(subscriber, false);\n}\n\nfunction signal(value, options) {\n    if (typeof value === 'function')\n        return new Signal(value, options);\n    return new WritableSignal(value, options);\n}\n\n/**\n * Calls the passed function immediately and every time the signals it depends on are updated.\n * @param fn A function to watch for.\n * @returns Stop watching function.\n */\nfunction effect(fn) {\n    return computed(fn).subscribe(NOOP_FN);\n}\n\nfunction isSignal(value) {\n    return value instanceof Signal;\n}\nfunction isWritableSignal(value) {\n    return value instanceof WritableSignal;\n}\nfunction getValue(value) {\n    return isSignal(value) ? value.get() : value;\n}\nfunction sampleValue(value) {\n    return isSignal(value) ? value.get(false) : value;\n}\n\nexports.batch = batch;\nexports.collect = collect;\nexports.computed = computed;\nexports.configure = configure;\nexports.effect = effect;\nexports.getValue = getValue;\nexports.isSignal = isSignal;\nexports.isWritableSignal = isWritableSignal;\nexports.isolate = isolate;\nexports.on = on;\nexports.sampleValue = sampleValue;\nexports.signal = signal;\nexports.writable = writable;\n"]}