{"version":3,"sources":["jsdelivr-header.js","/npm/@cinformatique/state@2.1.12-beta.1/index.js"],"names":[],"mappings":"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","file":"/npm/@cinformatique/state@2.1.12-beta.1/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@cinformatique/state@2.1.12-beta.1/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 hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction isArray(obj) {\n    return Array.isArray(obj);\n}\nfunction isString(obj) {\n    return typeof obj === 'string';\n}\nfunction isObject(obj) {\n    return !!obj && typeof obj === 'object' && !isArray(obj);\n}\nfunction isFunction(obj) {\n    return typeof obj === 'function';\n}\nfunction isPrimitive(arg) {\n    const type = typeof arg;\n    return arg !== undefined && (isDate(arg) || (type !== 'object' && type !== 'function'));\n}\nfunction isDate(obj) {\n    return obj instanceof Date;\n}\nfunction isSymbol(obj) {\n    return typeof obj === 'symbol';\n}\nfunction isBoolean(obj) {\n    return typeof obj === 'boolean';\n}\nfunction isPromise(obj) {\n    return obj instanceof Promise;\n}\nfunction isEmpty(obj) {\n    // Looping and returning false on the first property is faster than Object.keys(obj).length === 0\n    // https://jsbench.me/qfkqv692c8\n    if (!obj)\n        return false;\n    if (isArray(obj))\n        return obj.length === 0;\n    for (const key in obj) {\n        if (hasOwnProperty.call(obj, key)) {\n            return false;\n        }\n    }\n    return true;\n}\nconst setPrimitives = new Set(['boolean', 'string', 'number']);\n/** @internal */\nfunction isActualPrimitive(arg) {\n    return setPrimitives.has(typeof arg);\n}\n/** @internal */\nfunction isChildNodeValue(node) {\n    return !!node.parent;\n}\n\nconst symbolToPrimitive = Symbol.toPrimitive;\nconst symbolGetNode = Symbol('getNode');\nconst symbolDelete = /* @__PURE__ */ Symbol('delete');\nconst symbolOpaque = Symbol('opaque');\nconst optimized = Symbol('optimized');\n// TODOV3 Remove these\nconst extraPrimitiveActivators = new Map();\nconst extraPrimitiveProps = new Map();\nconst globalState = {\n    isLoadingLocal: false,\n    isLoadingRemote: false,\n    isMerging: false,\n};\nfunction checkActivate(node) {\n    var _a;\n    const root = node.root;\n    (_a = root.activate) === null || _a === void 0 ? void 0 : _a.call(root);\n    if (root.toActivate) {\n        root.toActivate.forEach(checkActivate);\n        delete root.toActivate;\n    }\n}\nfunction getNode(obs) {\n    return obs && obs[symbolGetNode];\n}\nfunction setNodeValue(node, newValue) {\n    var _a;\n    const parentNode = (_a = node.parent) !== null && _a !== void 0 ? _a : node;\n    const key = node.parent ? node.key : '_';\n    const isDelete = newValue === symbolDelete;\n    if (isDelete)\n        newValue = undefined;\n    // Get the value of the parent\n    // const parentValue = isRoot ? node.root : ensureNodeValue(node);\n    const parentValue = node.parent ? ensureNodeValue(parentNode) : parentNode.root;\n    // Save the previous value first\n    const prevValue = parentValue[key];\n    const isFunc = isFunction(newValue);\n    // Compute newValue if newValue is a function or an observable\n    newValue =\n        !parentNode.isAssigning && isFunc\n            ? newValue(prevValue)\n            : isObject(newValue) && (newValue === null || newValue === void 0 ? void 0 : newValue[symbolGetNode])\n                ? newValue.peek()\n                : newValue;\n    try {\n        parentNode.isSetting = (parentNode.isSetting || 0) + 1;\n        // Save the new value\n        if (isDelete) {\n            delete parentValue[key];\n        }\n        else {\n            parentValue[key] = newValue;\n        }\n    }\n    finally {\n        parentNode.isSetting--;\n    }\n    if (parentNode.root.locked && parentNode.root.set) {\n        parentNode.root.set(parentNode.root._);\n    }\n    return { prevValue, newValue, parentValue };\n}\nconst arrNodeKeys = [];\nfunction getNodeValue(node) {\n    let count = 0;\n    let n = node;\n    while (isChildNodeValue(n)) {\n        arrNodeKeys[count++] = n.key;\n        n = n.parent;\n    }\n    let child = node.root._;\n    for (let i = count - 1; child && i >= 0; i--) {\n        const key = arrNodeKeys[i];\n        child = key !== 'size' && (child instanceof Map || child instanceof WeakMap) ? child.get(key) : child[key];\n    }\n    return child;\n}\nfunction getChildNode(node, key) {\n    var _a;\n    // Get the child by key\n    let child = (_a = node.children) === null || _a === void 0 ? void 0 : _a.get(key);\n    // Create the child node if it doesn't already exist\n    if (!child) {\n        child = {\n            root: node.root,\n            parent: node,\n            key,\n            lazy: true,\n        };\n        if (!node.children) {\n            node.children = new Map();\n        }\n        node.children.set(key, child);\n    }\n    return child;\n}\nfunction ensureNodeValue(node) {\n    let value = getNodeValue(node);\n    if (!value) {\n        if (isChildNodeValue(node)) {\n            const parent = ensureNodeValue(node.parent);\n            value = parent[node.key] = {};\n        }\n        else {\n            value = node.root._ = {};\n        }\n    }\n    return value;\n}\nfunction findIDKey(obj, node) {\n    let idKey = isObject(obj)\n        ? 'id' in obj\n            ? 'id'\n            : 'key' in obj\n                ? 'key'\n                : '_id' in obj\n                    ? '_id'\n                    : '__id' in obj\n                        ? '__id'\n                        : undefined\n        : undefined;\n    if (!idKey && node.parent) {\n        const keyExtractor = getNodeValue(node.parent)[node.key + '_keyExtractor'];\n        if (keyExtractor && isFunction(keyExtractor)) {\n            idKey = keyExtractor;\n        }\n    }\n    return idKey;\n}\nfunction extractFunction(node, key, fnOrComputed, computedChildNode) {\n    if (!node.functions) {\n        node.functions = new Map();\n    }\n    node.functions.set(key, fnOrComputed);\n    if (computedChildNode) {\n        computedChildNode.parentOther = getChildNode(node, key);\n        if (!node.root.toActivate) {\n            node.root.toActivate = [];\n        }\n        node.root.toActivate.push(computedChildNode);\n    }\n}\n\nfunction isObservable(obs) {\n    return obs && !!obs[symbolGetNode];\n}\nfunction isEvent(obs) {\n    var _a;\n    return obs && ((_a = obs[symbolGetNode]) === null || _a === void 0 ? void 0 : _a.isEvent);\n}\nfunction computeSelector(selector, e, retainObservable) {\n    let c = selector;\n    if (isFunction(c)) {\n        c = e ? c(e) : c();\n    }\n    return isObservable(c) && !retainObservable ? c.get() : c;\n}\nfunction getObservableIndex(obs) {\n    const node = getNode(obs);\n    const n = +node.key;\n    return n - n < 1 ? +n : -1;\n}\nfunction opaqueObject(value) {\n    if (value) {\n        value[symbolOpaque] = true;\n    }\n    return value;\n}\nfunction lockObservable(obs, value) {\n    var _a;\n    const root = (_a = getNode(obs)) === null || _a === void 0 ? void 0 : _a.root;\n    if (root) {\n        root.locked = value;\n    }\n}\nfunction setAtPath(obj, path, pathTypes, value, fullObj, restore) {\n    let o = obj;\n    let oFull = fullObj;\n    if (path.length > 0) {\n        for (let i = 0; i < path.length; i++) {\n            const p = path[i];\n            if (i === path.length - 1) {\n                // Don't set if the value is the same. This prevents creating a new key\n                // when setting undefined on an object without this key\n                if (o[p] !== value) {\n                    o[p] = value;\n                }\n            }\n            else if (o[p] === symbolDelete) {\n                // If this was previously deleted, restore it\n                if (oFull) {\n                    o[p] = oFull[p];\n                    restore === null || restore === void 0 ? void 0 : restore(path.slice(0, i + 1), o[p]);\n                }\n                break;\n            }\n            else if (o[p] === undefined || o[p] === null) {\n                o[p] = initializePathType(pathTypes[i]);\n            }\n            o = o[p];\n            if (oFull) {\n                oFull = oFull[p];\n            }\n        }\n    }\n    else {\n        obj = value;\n    }\n    return obj;\n}\nfunction setInObservableAtPath(obs, path, pathTypes, value, mode) {\n    let o = obs;\n    let v = value;\n    for (let i = 0; i < path.length; i++) {\n        const p = path[i];\n        if (!o.peek()[p]) {\n            o[p].set(initializePathType(pathTypes[i]));\n        }\n        o = o[p];\n        v = v[p];\n    }\n    if (v === symbolDelete) {\n        o.delete();\n    }\n    // Assign if possible, or set otherwise\n    else if (mode === 'assign' && o.assign && isObject(o.peek())) {\n        o.assign(v);\n    }\n    else {\n        o.set(v);\n    }\n}\nfunction mergeIntoObservable(target, ...sources) {\n    beginBatch();\n    globalState.isMerging = true;\n    for (let i = 0; i < sources.length; i++) {\n        target = _mergeIntoObservable(target, sources[i]);\n    }\n    globalState.isMerging = false;\n    endBatch();\n    return target;\n}\nfunction _mergeIntoObservable(target, source) {\n    var _a;\n    const needsSet = isObservable(target);\n    const targetValue = needsSet ? target.peek() : target;\n    const isTargetArr = isArray(targetValue);\n    const isTargetObj = !isTargetArr && isObject(targetValue);\n    if ((isTargetObj && isObject(source) && !isEmpty(targetValue)) ||\n        (isTargetArr && isArray(source) && targetValue.length > 0)) {\n        const keys = Object.keys(source);\n        for (let i = 0; i < keys.length; i++) {\n            const key = keys[i];\n            const sourceValue = source[key];\n            if (sourceValue === symbolDelete) {\n                needsSet && ((_a = target[key]) === null || _a === void 0 ? void 0 : _a.delete) ? target[key].delete() : delete target[key];\n            }\n            else {\n                const isObj = isObject(sourceValue);\n                const isArr = !isObj && isArray(sourceValue);\n                const targetChild = target[key];\n                if ((isObj || isArr) && targetChild && (needsSet || !isEmpty(targetChild))) {\n                    if (!needsSet && (!targetChild || (isObj ? !isObject(targetChild) : !isArray(targetChild)))) {\n                        target[key] = sourceValue;\n                    }\n                    else {\n                        _mergeIntoObservable(targetChild, sourceValue);\n                    }\n                }\n                else {\n                    needsSet\n                        ? targetChild.set(sourceValue)\n                        : (target[key] = sourceValue);\n                }\n            }\n        }\n    }\n    else if (source !== undefined) {\n        needsSet ? target.set(source) : (target = source);\n    }\n    return target;\n}\nfunction constructObjectWithPath(path, pathTypes, value) {\n    let out;\n    if (path.length > 0) {\n        let o = (out = {});\n        for (let i = 0; i < path.length; i++) {\n            const p = path[i];\n            o[p] = i === path.length - 1 ? value : initializePathType(pathTypes[i]);\n            o = o[p];\n        }\n    }\n    else {\n        out = value;\n    }\n    return out;\n}\nfunction deconstructObjectWithPath(path, pathTypes, value) {\n    let o = value;\n    for (let i = 0; i < path.length; i++) {\n        const p = path[i];\n        o = o ? o[p] : initializePathType(pathTypes[i]);\n    }\n    return o;\n}\nfunction isObservableValueReady(value) {\n    return !!value && ((!isObject(value) && !isArray(value)) || !isEmpty(value));\n}\nfunction setSilently(obs, newValue) {\n    const node = getNode(obs);\n    return setNodeValue(node, newValue).newValue;\n}\nfunction getPathType(value) {\n    return isArray(value) ? 'array' : value instanceof Map ? 'map' : value instanceof Set ? 'set' : 'object';\n}\nfunction initializePathType(pathType) {\n    switch (pathType) {\n        case 'array':\n            return [];\n        case 'object':\n            return {};\n        case 'map':\n            return new Map();\n        case 'set':\n            return new Set();\n    }\n}\nfunction replacer(_, value) {\n    if (value instanceof Map) {\n        return {\n            __LSType: 'Map',\n            value: Array.from(value.entries()), // or with spread: value: [...value]\n        };\n    }\n    else if (value instanceof Set) {\n        return {\n            __LSType: 'Set',\n            value: Array.from(value), // or with spread: value: [...value]\n        };\n    }\n    else {\n        return value;\n    }\n}\nfunction reviver(_, value) {\n    if (typeof value === 'object' && value) {\n        if (value.__LSType === 'Map') {\n            return new Map(value.value);\n        }\n        else if (value.__LSType === 'Set') {\n            return new Set(value.value);\n        }\n    }\n    return value;\n}\nfunction safeStringify(value) {\n    return JSON.stringify(value, replacer);\n}\nfunction safeParse(value) {\n    return JSON.parse(value, reviver);\n}\nfunction clone(value) {\n    return safeParse(safeStringify(value));\n}\n\nlet timeout;\nlet numInBatch = 0;\nlet isRunningBatch = false;\nlet didDelayEndBatch = false;\nlet _afterBatch = [];\nlet _queuedBatches = [];\nlet _batchMap = new Map();\nfunction onActionTimeout() {\n    if (_batchMap.size > 0) {\n        if (process.env.NODE_ENV === 'development') {\n            console.error('Forcibly completing observableBatcher because end() was never called. This may be due to an uncaught error between begin() and end().');\n        }\n        endBatch(/*force*/ true);\n    }\n}\nfunction isArraySubset(mainArr, subsetArr) {\n    for (let i = 0; i < mainArr.length; i++) {\n        if (mainArr[i] !== subsetArr[i]) {\n            return false;\n        }\n    }\n    return true;\n}\nfunction createPreviousHandlerInner(value, changes) {\n    // Clones the current state and inject the previous data at the changed path\n    let cloned = value ? clone(value) : {};\n    for (let i = 0; i < changes.length; i++) {\n        const { path, prevAtPath } = changes[i];\n        let o = cloned;\n        if (path.length > 0) {\n            let i;\n            for (i = 0; i < path.length - 1; i++) {\n                o = o[path[i]];\n            }\n            const key = path[i];\n            if (o instanceof Map) {\n                o.set(key, prevAtPath);\n            }\n            else {\n                o[key] = prevAtPath;\n            }\n        }\n        else {\n            cloned = prevAtPath;\n        }\n    }\n    return cloned;\n}\nfunction createPreviousHandler(value, changes) {\n    // Create a function that generates the previous state\n    // We don't want to always do this because cloning is expensive\n    // so it's better to run on demand.\n    return function () {\n        return createPreviousHandlerInner(value, changes);\n    };\n}\nfunction notify(node, value, prev, level, whenOptimizedOnlyIf) {\n    // Run immediate listeners if there are any\n    const changesInBatch = new Map();\n    computeChangesRecursive(changesInBatch, node, value, [], [], value, prev, \n    /*immediate*/ true, level, whenOptimizedOnlyIf);\n    batchNotifyChanges(changesInBatch, /*immediate*/ true);\n    // Update the current batch\n    const existing = _batchMap.get(node);\n    if (existing) {\n        existing.value = value;\n        // TODO: level, whenOptimizedOnlyIf\n    }\n    else {\n        _batchMap.set(node, { value, prev, level, whenOptimizedOnlyIf });\n    }\n    // If not in a batch run it immediately\n    if (numInBatch <= 0) {\n        runBatch();\n    }\n}\nfunction computeChangesAtNode(changesInBatch, node, value, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf) {\n    // If there are listeners at this node compute the changes that need to be run\n    if (immediate ? node.listenersImmediate : node.listeners) {\n        const change = {\n            path,\n            pathTypes,\n            valueAtPath,\n            prevAtPath,\n        };\n        const changeInBatch = changesInBatch.get(node);\n        // If the node itself has been changed then we can ignore all the child changes\n        if (changeInBatch && path.length > 0) {\n            const { changes } = changeInBatch;\n            if (!isArraySubset(changes[0].path, change.path)) {\n                changes.push(change);\n            }\n        }\n        else {\n            changesInBatch.set(node, {\n                level,\n                value,\n                whenOptimizedOnlyIf,\n                changes: [change],\n            });\n        }\n    }\n}\nfunction computeChangesRecursive(changesInBatch, node, value, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf) {\n    // Do the compute at this node\n    computeChangesAtNode(changesInBatch, node, value, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf);\n    if (node.linkedFromNodes) {\n        for (const linkedFromNode of node.linkedFromNodes) {\n            computeChangesAtNode(changesInBatch, linkedFromNode, value, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf);\n        }\n    }\n    // If not root notify up through parents\n    if (node.parent) {\n        const parent = node.parent;\n        if (parent) {\n            const parentValue = getNodeValue(parent);\n            computeChangesRecursive(changesInBatch, parent, parentValue, [node.key].concat(path), [getPathType(value)].concat(pathTypes), valueAtPath, prevAtPath, immediate, level + 1, whenOptimizedOnlyIf);\n        }\n    }\n}\nfunction batchNotifyChanges(changesInBatch, immediate) {\n    const listenersNotified = new Set();\n    // For each change in the batch, notify all of the listeners\n    changesInBatch.forEach(({ changes, level, value, whenOptimizedOnlyIf }, node) => {\n        const listeners = immediate ? node.listenersImmediate : node.listeners;\n        if (listeners) {\n            let listenerParams;\n            // Need to convert to an array here instead of using a for...of loop because listeners can change while iterating\n            const arr = Array.from(listeners);\n            for (let i = 0; i < arr.length; i++) {\n                const listenerFn = arr[i];\n                const { track, noArgs, listener } = listenerFn;\n                if (!listenersNotified.has(listener)) {\n                    const ok = track === true ? level <= 0 : track === optimized ? whenOptimizedOnlyIf && level <= 0 : true;\n                    // Notify if listener is not shallow or if this is the first level\n                    if (ok) {\n                        // Create listenerParams if not already created\n                        if (!noArgs && !listenerParams) {\n                            listenerParams = {\n                                value,\n                                getPrevious: createPreviousHandler(value, changes),\n                                changes,\n                            };\n                        }\n                        if (!track) {\n                            listenersNotified.add(listener);\n                        }\n                        listener(listenerParams);\n                    }\n                }\n            }\n        }\n    });\n}\nfunction runBatch() {\n    // Save batch locally and reset _batchMap first because a new batch could begin while looping over callbacks.\n    // This can happen with observableComputed for example.\n    const map = _batchMap;\n    _batchMap = new Map();\n    const changesInBatch = new Map();\n    // First compute all of the changes at each node. It's important to do this first before\n    // running all the notifications because createPreviousHandler depends on knowing\n    // all of the changes happening at the node.\n    map.forEach(({ value, prev, level, whenOptimizedOnlyIf }, node) => {\n        computeChangesRecursive(changesInBatch, node, value, [], [], value, prev, false, level, whenOptimizedOnlyIf);\n    });\n    // Once all changes are computed, notify all listeners for each node with the computed changes.\n    batchNotifyChanges(changesInBatch, false);\n}\nfunction batch(fn, onComplete) {\n    if (onComplete) {\n        // If there's an onComplete we need a batch that's fully isolated from others to ensure it wraps only the given changes.\n        // So if already batching, push this batch onto a queue and run it after the current batch is fully done.\n        if (isRunningBatch) {\n            _queuedBatches.push([fn, onComplete]);\n            return;\n        }\n        else {\n            _afterBatch.push(onComplete);\n        }\n    }\n    beginBatch();\n    try {\n        fn();\n    }\n    finally {\n        endBatch();\n    }\n}\nfunction beginBatch() {\n    numInBatch++;\n    if (!timeout) {\n        timeout = setTimeout(onActionTimeout, 0);\n    }\n}\nfunction endBatch(force) {\n    numInBatch--;\n    if (numInBatch <= 0 || force) {\n        if (isRunningBatch) {\n            // Don't want to run multiple endBatches recursively, so just note that an endBatch\n            // was delayed so that the top level endBatch will run endBatch again after it's done.\n            didDelayEndBatch = true;\n        }\n        else {\n            if (timeout) {\n                clearTimeout(timeout);\n                timeout = undefined;\n            }\n            numInBatch = 0;\n            // Save batch locally and reset _batch first because a new batch could begin while looping over callbacks.\n            // This can happen with observableComputed for example.\n            const after = _afterBatch;\n            if (after.length) {\n                _afterBatch = [];\n            }\n            isRunningBatch = true;\n            runBatch();\n            isRunningBatch = false;\n            // Run after functions at the end of this batch before running the next batch.\n            // This needs to run before the delayed endBatch because the after functions need\n            // to run before any side effects of the batch\n            for (let i = 0; i < after.length; i++) {\n                after[i]();\n            }\n            // If an endBatch was delayed run it now\n            if (didDelayEndBatch) {\n                didDelayEndBatch = false;\n                endBatch(true);\n            }\n            const queued = _queuedBatches;\n            if (queued.length) {\n                _queuedBatches = [];\n                for (let i = 0; i < queued.length; i++) {\n                    const [fn, onComplete] = queued[i];\n                    batch(fn, onComplete);\n                }\n            }\n        }\n    }\n}\n\nfunction createObservable(value, makePrimitive, createObject, createPrimitive) {\n    const valueIsPromise = isPromise(value);\n    const root = {\n        _: value,\n    };\n    const node = {\n        root,\n        lazy: true,\n    };\n    const prim = makePrimitive || isActualPrimitive(value);\n    const obs = prim\n        ? new createPrimitive(node)\n        : createObject(node);\n    if (valueIsPromise) {\n        extractPromise(node, value);\n    }\n    return obs;\n}\n\nfunction onChange(node, callback, options = {}) {\n    const { initial, immediate, noArgs } = options;\n    const { trackingType } = options;\n    let listeners = immediate ? node.listenersImmediate : node.listeners;\n    if (!listeners) {\n        listeners = new Set();\n        if (immediate) {\n            node.listenersImmediate = listeners;\n        }\n        else {\n            node.listeners = listeners;\n        }\n    }\n    checkActivate(node);\n    const listener = {\n        listener: callback,\n        track: trackingType,\n        noArgs,\n    };\n    listeners.add(listener);\n    if (initial) {\n        const value = getNodeValue(node);\n        callback({\n            value,\n            changes: [\n                {\n                    path: [],\n                    pathTypes: [],\n                    prevAtPath: value,\n                    valueAtPath: value,\n                },\n            ],\n            getPrevious: () => undefined,\n        });\n    }\n    return () => listeners.delete(listener);\n}\n\nlet trackCount = 0;\nconst trackingQueue = [];\nconst tracking = {\n    current: undefined,\n};\nfunction beginTracking() {\n    // Keep a copy of the previous tracking context so it can be restored\n    // when this context is complete\n    trackingQueue.push(tracking.current);\n    trackCount++;\n    tracking.current = {};\n}\nfunction endTracking() {\n    // Restore the previous tracking context\n    trackCount--;\n    if (trackCount < 0) {\n        trackCount = 0;\n    }\n    tracking.current = trackingQueue.pop();\n}\nfunction updateTracking(node, track) {\n    if (trackCount) {\n        const tracker = tracking.current;\n        if (tracker) {\n            if (!tracker.nodes) {\n                tracker.nodes = new Map();\n            }\n            const existing = tracker.nodes.get(node);\n            if (existing) {\n                existing.track = existing.track || track;\n                existing.num++;\n            }\n            else {\n                tracker.nodes.set(node, { node, track, num: 1 });\n            }\n        }\n    }\n}\n\nconst ArrayModifiers = new Set([\n    'copyWithin',\n    'fill',\n    'from',\n    'pop',\n    'push',\n    'reverse',\n    'shift',\n    'sort',\n    'splice',\n    'unshift',\n]);\nconst ArrayLoopers = new Set([\n    'every',\n    'filter',\n    'find',\n    'findIndex',\n    'forEach',\n    'join',\n    'map',\n    'some',\n]);\nconst ArrayLoopersReturn = new Set(['filter', 'find']);\nconst observableProperties = new Map();\nconst observableFns = new Map([\n    ['get', get],\n    ['set', set],\n    ['peek', peek],\n    ['onChange', onChange],\n    ['assign', assign],\n    ['delete', deleteFn],\n    ['toggle', toggle],\n]);\nif (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {\n    // eslint-disable-next-line no-var\n    var __devUpdateNodes = new Set();\n}\nfunction collectionSetter(node, target, prop, ...args) {\n    var _a;\n    const prevValue = (isArray(target) && target.slice()) || target;\n    const ret = target[prop].apply(target, args);\n    if (node) {\n        const hasParent = isChildNodeValue(node);\n        const key = hasParent ? node.key : '_';\n        const parentValue = hasParent ? getNodeValue(node.parent) : node.root;\n        // Set the object to the previous value first\n        parentValue[key] = prevValue;\n        // Then set with the new value so it notifies with the correct prevValue\n        setKey((_a = node.parent) !== null && _a !== void 0 ? _a : node, key, target);\n    }\n    // Return the original value\n    return ret;\n}\nfunction getKeys(obj, isArr, isMap) {\n    return isArr ? undefined : obj ? (isMap ? Array.from(obj.keys()) : Object.keys(obj)) : [];\n}\nfunction updateNodes(parent, obj, prevValue) {\n    var _a, _b;\n    if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') &&\n        typeof __devUpdateNodes !== 'undefined' &&\n        isObject(obj)) {\n        if (__devUpdateNodes.has(obj)) {\n            console.error('[legend-state] Circular reference detected in object. You may want to use opaqueObject to stop traversing child nodes.', obj);\n            return false;\n        }\n        __devUpdateNodes.add(obj);\n    }\n    if ((isObject(obj) && obj[symbolOpaque]) ||\n        (isObject(prevValue) && prevValue[symbolOpaque])) {\n        const isDiff = obj !== prevValue;\n        if (isDiff) {\n            if (parent.listeners || parent.listenersImmediate) {\n                notify(parent, obj, prevValue, 0);\n            }\n        }\n        if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') &&\n            typeof __devUpdateNodes !== 'undefined' &&\n            obj !== undefined) {\n            __devUpdateNodes.delete(obj);\n        }\n        return isDiff;\n    }\n    const isArr = isArray(obj);\n    let prevChildrenById;\n    let moved;\n    const isMap = obj instanceof Map;\n    const keys = getKeys(obj, isArr, isMap);\n    const keysPrev = getKeys(prevValue, isArr, isMap);\n    const length = ((_a = (keys || obj)) === null || _a === void 0 ? void 0 : _a.length) || 0;\n    const lengthPrev = ((_b = (keysPrev || prevValue)) === null || _b === void 0 ? void 0 : _b.length) || 0;\n    let idField;\n    let isIdFieldFunction;\n    let hasADiff = false;\n    let retValue;\n    if (isArr && isArray(prevValue)) {\n        // Construct a map of previous indices for computing move\n        if (prevValue.length > 0) {\n            const firstPrevValue = prevValue[0];\n            if (firstPrevValue !== undefined) {\n                idField = findIDKey(firstPrevValue, parent);\n                if (idField) {\n                    isIdFieldFunction = isFunction(idField);\n                    prevChildrenById = new Map();\n                    moved = [];\n                    const keysSeen = process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test'\n                        ? new Set()\n                        : undefined;\n                    if (parent.children) {\n                        for (let i = 0; i < prevValue.length; i++) {\n                            const p = prevValue[i];\n                            if (p) {\n                                const child = parent.children.get(i + '');\n                                if (child) {\n                                    const key = isIdFieldFunction\n                                        ? idField(p)\n                                        : p[idField];\n                                    if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {\n                                        if (keysSeen.has(key)) {\n                                            console.warn(`[legend-state] Warning: Multiple elements in array have the same ID. Key field: ${idField}, Array:`, prevValue);\n                                        }\n                                        keysSeen.add(key);\n                                    }\n                                    prevChildrenById.set(key, child);\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n        }\n    }\n    else if (prevValue && (!obj || isObject(obj))) {\n        // For keys that have been removed from object, notify and update children recursively\n        const lengthPrev = keysPrev.length;\n        for (let i = 0; i < lengthPrev; i++) {\n            const key = keysPrev[i];\n            if (!keys.includes(key)) {\n                hasADiff = true;\n                const child = getChildNode(parent, key);\n                const prev = isMap ? prevValue.get(key) : prevValue[key];\n                if (prev !== undefined) {\n                    if (!isPrimitive(prev)) {\n                        updateNodes(child, undefined, prev);\n                    }\n                    if (child.listeners || child.listenersImmediate) {\n                        notify(child, undefined, prev, 0);\n                    }\n                }\n            }\n        }\n    }\n    if (obj && !isPrimitive(obj)) {\n        hasADiff = hasADiff || length !== lengthPrev;\n        const isArrDiff = hasADiff;\n        let didMove = false;\n        for (let i = 0; i < length; i++) {\n            const key = isArr ? i + '' : keys[i];\n            const value = isMap ? obj.get(key) : obj[key];\n            const prev = isMap ? prevValue === null || prevValue === void 0 ? void 0 : prevValue.get(key) : prevValue === null || prevValue === void 0 ? void 0 : prevValue[key];\n            let isDiff = value !== prev;\n            if (isDiff) {\n                const id = idField && value\n                    ? isIdFieldFunction\n                        ? idField(value)\n                        : value[idField]\n                    : undefined;\n                let child = getChildNode(parent, key);\n                // Detect moves within an array. Need to move the original proxy to the new position to keep\n                // the proxy stable, so that listeners to this node will be unaffected by the array shift.\n                if (isArr && id !== undefined) {\n                    // Find the previous position of this element in the array\n                    const prevChild = id !== undefined ? prevChildrenById === null || prevChildrenById === void 0 ? void 0 : prevChildrenById.get(id) : undefined;\n                    if (!prevChild) {\n                        // This id was not in the array before so it does not need to notify children\n                        isDiff = false;\n                        hasADiff = true;\n                    }\n                    else if (prevChild !== undefined && prevChild.key !== key) {\n                        const valuePrevChild = prevValue[prevChild.key];\n                        // If array length changed then move the original node to the current position.\n                        // That should be faster than notifying every single element that\n                        // it's in a new position.\n                        if (isArrDiff) {\n                            child = prevChild;\n                            parent.children.delete(child.key);\n                            child.key = key;\n                            moved.push([key, child]);\n                        }\n                        didMove = true;\n                        // And check for diff against the previous value in the previous position\n                        isDiff = valuePrevChild !== value;\n                    }\n                }\n                if (isDiff) {\n                    // Array has a new / modified element\n                    // If object iterate through its children\n                    if (isPrimitive(value)) {\n                        hasADiff = true;\n                    }\n                    else {\n                        // Always need to updateNodes so we notify through all children\n                        const updatedNodes = updateNodes(child, value, prev);\n                        hasADiff = hasADiff || updatedNodes;\n                    }\n                }\n                if (isDiff || !isArrDiff) {\n                    // Notify for this child if this element is different and it has listeners\n                    // Or if the position changed in an array whose length did not change\n                    // But do not notify child if the parent is an array with changing length -\n                    // the array's listener will cover it\n                    if (child.listeners || child.listenersImmediate) {\n                        notify(child, value, prev, 0, !isArrDiff);\n                    }\n                }\n            }\n        }\n        if (moved) {\n            for (let i = 0; i < moved.length; i++) {\n                const [key, child] = moved[i];\n                parent.children.set(key, child);\n            }\n        }\n        // The full array does not need to re-render if the length is the same\n        // So don't notify shallow listeners\n        retValue = hasADiff || didMove;\n    }\n    else if (prevValue !== undefined) {\n        // If value got set to undefined, it has a diff\n        retValue = true;\n    }\n    if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') &&\n        typeof __devUpdateNodes !== 'undefined' &&\n        obj !== undefined) {\n        __devUpdateNodes.delete(obj);\n    }\n    return retValue !== null && retValue !== void 0 ? retValue : false;\n}\nfunction getProxy(node, p) {\n    // Get the child node if p prop\n    if (p !== undefined)\n        node = getChildNode(node, p);\n    // Create a proxy if not already cached and return it\n    return (node.proxy || (node.proxy = new Proxy(node, proxyHandler)));\n}\nconst proxyHandler = {\n    get(node, p, receiver) {\n        var _a;\n        if (p === symbolToPrimitive) {\n            throw new Error(process.env.NODE_ENV === 'development'\n                ? '[legend-state] observable should not be used as a primitive. You may have forgotten to use .get() or .peek() to get the value of the observable.'\n                : '[legend-state] observable is not a primitive.');\n        }\n        if (p === symbolGetNode) {\n            return node;\n        }\n        const value = peek(node);\n        // If this node is linked to another observable then forward to the target's handler.\n        // The exception is onChange because it needs to listen to this node for changes.\n        // This needs to be below peek because it activates there.\n        if (node.linkedToNode && p !== 'onChange') {\n            return proxyHandler.get(node.linkedToNode, p, receiver);\n        }\n        if (value instanceof Map || value instanceof WeakMap || value instanceof Set || value instanceof WeakSet) {\n            const ret = handlerMapSet(node, p, value);\n            if (ret !== undefined) {\n                return ret;\n            }\n        }\n        const fn = observableFns.get(p);\n        // If this is an observable function, call it\n        if (fn) {\n            return function (a, b, c) {\n                const l = arguments.length;\n                // Array call and apply are slow so micro-optimize this hot path.\n                // The observable functions depends on the number of arguments so we have to\n                // call it with the correct arguments, not just undefined\n                switch (l) {\n                    case 0:\n                        return fn(node);\n                    case 1:\n                        return fn(node, a);\n                    case 2:\n                        return fn(node, a, b);\n                    default:\n                        return fn(node, a, b, c);\n                }\n            };\n        }\n        if (node.isComputed) {\n            if (node.proxyFn && !fn) {\n                return node.proxyFn(p);\n            }\n            else {\n                checkActivate(node);\n            }\n        }\n        const property = observableProperties.get(p);\n        if (property) {\n            return property.get(node);\n        }\n        // TODOV3 Remove this\n        const isValuePrimitive = isPrimitive(value);\n        // If accessing a key that doesn't already exist, and this node has been activated with extra keys\n        // then return the values that were set. This is used by enableLegendStateReact for example.\n        if (value === undefined || value === null || isValuePrimitive) {\n            if (extraPrimitiveProps.size && (node.isActivatedPrimitive || extraPrimitiveActivators.has(p))) {\n                node.isActivatedPrimitive = true;\n                const vPrim = extraPrimitiveProps.get(p);\n                if (vPrim !== undefined) {\n                    return isFunction(vPrim) ? vPrim(getProxy(node)) : vPrim;\n                }\n            }\n        }\n        // /TODOV3 Remove this\n        const vProp = value === null || value === void 0 ? void 0 : value[p];\n        if (isObject(value) && value[symbolOpaque]) {\n            return vProp;\n        }\n        // Handle function calls\n        if (isFunction(vProp)) {\n            if (isArray(value)) {\n                if (ArrayModifiers.has(p)) {\n                    // Call the wrapped modifier function\n                    return (...args) => collectionSetter(node, value, p, ...args);\n                }\n                else if (ArrayLoopers.has(p)) {\n                    // Update that this node was accessed for observers\n                    updateTracking(node);\n                    return function (cbOrig, thisArg) {\n                        // If callback needs to run on the observable proxies, use a wrapped callback\n                        function cbWrapped(_, index, array) {\n                            return cbOrig(getProxy(node, index + ''), index, array);\n                        }\n                        // If return value needs to be observable proxies, use our own looping logic and return the proxy when found\n                        if (ArrayLoopersReturn.has(p)) {\n                            const isFind = p === 'find';\n                            const out = [];\n                            for (let i = 0; i < value.length; i++) {\n                                if (cbWrapped(value[i], i, value)) {\n                                    const proxy = getProxy(node, i + '');\n                                    if (isFind) {\n                                        return proxy;\n                                    }\n                                    else {\n                                        out.push(proxy);\n                                    }\n                                }\n                            }\n                            return isFind ? undefined : out;\n                        }\n                        else {\n                            return value[p](cbWrapped, thisArg);\n                        }\n                    };\n                }\n            }\n            // Return the function bound to the value\n            return vProp.bind(value);\n        }\n        // Accessing primitive returns the raw value\n        if (isPrimitive(vProp)) {\n            // Update that this primitive node was accessed for observers\n            if (isArray(value) && p === 'length') {\n                updateTracking(node, true);\n                // } else if (!isPrimitive(value)) {\n                //     updateTracking(getChildNode(node, p));\n                return vProp;\n            }\n        }\n        const fnOrComputed = (_a = node.functions) === null || _a === void 0 ? void 0 : _a.get(p);\n        if (fnOrComputed) {\n            return fnOrComputed;\n        }\n        // TODOV3: Remove \"state\"\n        if (vProp === undefined && (p === 'state' || p === '_state') && node.state) {\n            return node.state;\n        }\n        // Return an observable proxy to the property\n        return getProxy(node, p);\n    },\n    // Forward all proxy properties to the target's value\n    getPrototypeOf(node) {\n        const value = getNodeValue(node);\n        return value !== null && typeof value === 'object' ? Reflect.getPrototypeOf(value) : null;\n    },\n    ownKeys(node) {\n        const value = getNodeValue(node);\n        if (isPrimitive(value))\n            return [];\n        const keys = value ? Reflect.ownKeys(value) : [];\n        // Update that this node was accessed for observers\n        updateTracking(node, true);\n        // This is required to fix this error:\n        // TypeError: 'getOwnPropertyDescriptor' on proxy: trap reported non-configurability for\n        // property 'length' which is either non-existent or configurable in the proxy node\n        if (isArray(value) && keys[keys.length - 1] === 'length') {\n            keys.splice(keys.length - 1, 1);\n        }\n        return keys;\n    },\n    getOwnPropertyDescriptor(node, prop) {\n        const value = getNodeValue(node);\n        return !isPrimitive(value) ? Reflect.getOwnPropertyDescriptor(value, prop) : undefined;\n    },\n    set(node, prop, value) {\n        // If this assignment comes from within an observable function it's allowed\n        if (node.isSetting) {\n            return Reflect.set(node, prop, value);\n        }\n        if (node.isAssigning) {\n            setKey(node, prop, value);\n            return true;\n        }\n        const property = observableProperties.get(prop);\n        if (property) {\n            property.set(node, value);\n            return true;\n        }\n        if (process.env.NODE_ENV === 'development') {\n            console.warn('[legend-state]: Error: Cannot set a value directly:', prop, value);\n        }\n        return false;\n    },\n    deleteProperty(node, prop) {\n        // If this delete comes from within an observable function it's allowed\n        if (node.isSetting) {\n            return Reflect.deleteProperty(node, prop);\n        }\n        else {\n            if (process.env.NODE_ENV === 'development') {\n                console.warn('[legend-state]: Error: Cannot delete a value directly:', prop);\n            }\n            return false;\n        }\n    },\n    has(node, prop) {\n        const value = getNodeValue(node);\n        return Reflect.has(value, prop);\n    },\n};\nfunction set(node, newValue) {\n    if (node.parent) {\n        return setKey(node.parent, node.key, newValue);\n    }\n    else {\n        return setKey(node, '_', newValue);\n    }\n}\nfunction toggle(node) {\n    const value = getNodeValue(node);\n    if (value === undefined || isBoolean(value)) {\n        set(node, !value);\n        return !value;\n    }\n    else if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {\n        throw new Error('[legend-state] Cannot toggle a non-boolean value');\n    }\n}\nfunction setKey(node, key, newValue, level) {\n    if (process.env.NODE_ENV === 'development') {\n        if (typeof HTMLElement !== 'undefined' && newValue instanceof HTMLElement) {\n            console.warn(`[legend-state] Set an HTMLElement into state. You probably don't want to do that.`);\n        }\n    }\n    if (node.root.locked && !node.root.set) {\n        // This happens when modifying a locked observable such as a computed.\n        // If merging this could be happening deep in a hierarchy so we don't want to throw errors so we'll just do nothing.\n        // This could happen during persistence local load for example.\n        if (globalState.isMerging) {\n            return;\n        }\n        else {\n            throw new Error(process.env.NODE_ENV === 'development'\n                ? '[legend-state] Cannot modify an observable while it is locked. Please make sure that you unlock the observable before making changes.'\n                : '[legend-state] Modified locked observable');\n        }\n    }\n    const isRoot = !node.parent && key === '_';\n    // Get the child node for updating and notifying\n    const childNode = isRoot ? node : getChildNode(node, key);\n    // Set the raw value on the parent object\n    const { newValue: savedValue, prevValue, parentValue } = setNodeValue(childNode, newValue);\n    const isFunc = isFunction(savedValue);\n    const isPrim = isPrimitive(savedValue) || savedValue instanceof Date;\n    if (savedValue !== prevValue) {\n        updateNodesAndNotify(node, savedValue, prevValue, childNode, isPrim, isRoot, level);\n    }\n    extractFunctionOrComputed(node, parentValue, key, savedValue);\n    return isFunc ? savedValue : isRoot ? getProxy(node) : getProxy(node, key);\n}\nfunction assign(node, value) {\n    const proxy = getProxy(node);\n    beginBatch();\n    if (isPrimitive(node.root._)) {\n        node.root._ = {};\n    }\n    // Set inAssign to allow setting on safe observables\n    node.isAssigning = (node.isAssigning || 0) + 1;\n    try {\n        Object.assign(proxy, value);\n    }\n    finally {\n        node.isAssigning--;\n    }\n    endBatch();\n    return proxy;\n}\nfunction deleteFn(node, key) {\n    // If called without a key, delete by key from the parent node\n    if (key === undefined && isChildNodeValue(node)) {\n        key = node.key;\n        node = node.parent;\n    }\n    setKey(node, key !== null && key !== void 0 ? key : '_', symbolDelete, /*level*/ -1);\n}\nfunction handlerMapSet(node, p, value) {\n    const vProp = value === null || value === void 0 ? void 0 : value[p];\n    if (p === 'size') {\n        return getProxy(node, p);\n    }\n    else if (isFunction(vProp)) {\n        return function (a, b, c) {\n            const l = arguments.length;\n            const valueMap = value;\n            if (p === 'get') {\n                if (l > 0 && typeof a !== 'boolean' && a !== optimized) {\n                    return getProxy(node, a);\n                }\n            }\n            else if (p === 'set') {\n                if (l === 2) {\n                    const prev = valueMap.get(a);\n                    const ret = valueMap.set(a, b);\n                    if (prev !== b) {\n                        updateNodesAndNotify(getChildNode(node, a), b, prev);\n                    }\n                    return ret;\n                }\n            }\n            else if (p === 'delete') {\n                if (l > 0) {\n                    // Support Set by just returning a if it doesn't have get, meaning it's not a Map\n                    const prev = value.get ? valueMap.get(a) : a;\n                    const ret = value.delete(a);\n                    if (ret) {\n                        updateNodesAndNotify(getChildNode(node, a), undefined, prev);\n                    }\n                    return ret;\n                }\n            }\n            else if (p === 'clear') {\n                const prev = new Map(valueMap);\n                const size = valueMap.size;\n                valueMap.clear();\n                if (size) {\n                    updateNodesAndNotify(node, value, prev);\n                }\n                return;\n            }\n            else if (p === 'add') {\n                const prev = new Set(value);\n                const ret = value.add(a);\n                if (!value.has(p)) {\n                    notify(node, ret, prev, 0);\n                }\n                return ret;\n            }\n            // TODO: This is duplicated from proxy handler, how to dedupe with best performance?\n            const fn = observableFns.get(p);\n            if (fn) {\n                // Array call and apply are slow so micro-optimize this hot path.\n                // The observable functions depends on the number of arguments so we have to\n                // call it with the correct arguments, not just undefined\n                switch (l) {\n                    case 0:\n                        return fn(node);\n                    case 1:\n                        return fn(node, a);\n                    case 2:\n                        return fn(node, a, b);\n                    default:\n                        return fn(node, a, b, c);\n                }\n            }\n            else {\n                return value[p](a, b);\n            }\n        };\n    }\n}\nfunction updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRoot, level) {\n    if (!childNode)\n        childNode = node;\n    // Make sure we don't call too many listeners for ever property set\n    beginBatch();\n    if (isPrim === undefined) {\n        isPrim = isPrimitive(newValue);\n    }\n    let hasADiff = isPrim;\n    let whenOptimizedOnlyIf = false;\n    // If new value is an object or array update notify down the tree\n    if (!isPrim || (prevValue && !isPrimitive(prevValue))) {\n        if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') &&\n            typeof __devUpdateNodes !== 'undefined') {\n            __devUpdateNodes.clear();\n        }\n        hasADiff = updateNodes(childNode, newValue, prevValue);\n        if (isArray(newValue)) {\n            whenOptimizedOnlyIf = (newValue === null || newValue === void 0 ? void 0 : newValue.length) !== (prevValue === null || prevValue === void 0 ? void 0 : prevValue.length);\n        }\n    }\n    if (isPrim || !newValue || (isEmpty(newValue) && !isEmpty(prevValue)) ? newValue !== prevValue : hasADiff) {\n        // Notify for this element if something inside it has changed\n        notify(isPrim && isRoot ? node : childNode, newValue, prevValue, (level !== null && level !== void 0 ? level : prevValue === undefined) ? -1 : hasADiff ? 0 : 1, whenOptimizedOnlyIf);\n    }\n    endBatch();\n}\nfunction extractPromise(node, value) {\n    if (!node.state) {\n        node.state = createObservable({\n            isLoaded: false,\n        }, false, getProxy);\n    }\n    value\n        .then((value) => {\n        set(node, value);\n        node.state.isLoaded.set(true);\n    })\n        .catch((error) => {\n        node.state.error.set(error);\n    });\n}\nfunction extractFunctionOrComputed(node, obj, k, v) {\n    if (isPromise(v)) {\n        extractPromise(getChildNode(node, k), v);\n    }\n    else if (typeof v === 'function') {\n        extractFunction(node, k, v);\n    }\n    else if (typeof v == 'object' && v !== null && v !== undefined) {\n        const childNode = getNode(v);\n        if (childNode === null || childNode === void 0 ? void 0 : childNode.isComputed) {\n            extractFunction(node, k, v, childNode);\n            delete obj[k];\n        }\n        else {\n            return true;\n        }\n    }\n}\nfunction get(node, options) {\n    const track = options ? (isObject(options) ? options.shallow : options) : undefined;\n    // Track by default\n    updateTracking(node, track);\n    return peek(node);\n}\nfunction peek(node) {\n    const value = getNodeValue(node);\n    // If node is not yet lazily computed go do that\n    if (node.lazy) {\n        delete node.lazy;\n        for (const key in value) {\n            if (hasOwnProperty.call(value, key)) {\n                extractFunctionOrComputed(node, value, key, value[key]);\n            }\n        }\n    }\n    // Check if computed needs to activate\n    checkActivate(node);\n    return value;\n}\n\nconst fns = ['get', 'set', 'peek', 'onChange', 'toggle'];\nfunction ObservablePrimitiveClass(node) {\n    this._node = node;\n    // Bind to this\n    for (let i = 0; i < fns.length; i++) {\n        const key = fns[i];\n        this[key] = this[key].bind(this);\n    }\n}\n// Add observable functions to prototype\nfunction proto(key, fn) {\n    ObservablePrimitiveClass.prototype[key] = function (...args) {\n        return fn.call(this, this._node, ...args);\n    };\n}\nproto('peek', peek);\nproto('get', get);\nproto('set', set);\nproto('onChange', onChange);\n// Getters\nObject.defineProperty(ObservablePrimitiveClass.prototype, symbolGetNode, {\n    configurable: true,\n    get() {\n        return this._node;\n    },\n});\nObservablePrimitiveClass.prototype.toggle = function () {\n    const value = this.peek();\n    if (value === undefined || isBoolean(value)) {\n        this.set(!value);\n    }\n    else if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {\n        throw new Error('[legend-state] Cannot toggle a non-boolean value');\n    }\n    return !value;\n};\nObservablePrimitiveClass.prototype.delete = function () {\n    this.set(undefined);\n    return this;\n};\n\nfunction observable(value) {\n    return createObservable(value, false, getProxy, ObservablePrimitiveClass);\n}\nfunction observablePrimitive(value) {\n    return createObservable(value, true, getProxy, ObservablePrimitiveClass);\n}\n\nfunction setupTracking(nodes, update, noArgs, immediate) {\n    let listeners = [];\n    // Listen to tracked nodes\n    nodes === null || nodes === void 0 ? void 0 : nodes.forEach((tracked) => {\n        const { node, track } = tracked;\n        listeners.push(onChange(node, update, { trackingType: track, immediate, noArgs }));\n    });\n    return () => {\n        if (listeners) {\n            for (let i = 0; i < listeners.length; i++) {\n                listeners[i]();\n            }\n            listeners = undefined;\n        }\n    };\n}\n\nfunction trackSelector(selector, update, observeEvent, observeOptions, createResubscribe) {\n    var _a;\n    let dispose;\n    let resubscribe;\n    let updateFn = update;\n    beginTracking();\n    const value = selector ? computeSelector(selector, observeEvent, observeOptions === null || observeOptions === void 0 ? void 0 : observeOptions.fromComputed) : selector;\n    const tracker = tracking.current;\n    const nodes = tracker.nodes;\n    endTracking();\n    if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') && tracker && nodes) {\n        (_a = tracker.traceListeners) === null || _a === void 0 ? void 0 : _a.call(tracker, nodes);\n        if (tracker.traceUpdates) {\n            updateFn = tracker.traceUpdates(update);\n        }\n        // Clear tracing so it doesn't leak to other components\n        tracker.traceListeners = undefined;\n        tracker.traceUpdates = undefined;\n    }\n    if (!(observeEvent === null || observeEvent === void 0 ? void 0 : observeEvent.cancel)) {\n        // Do tracing if it was requested\n        // useSyncExternalStore doesn't subscribe until after the component mount.\n        // We want to subscribe immediately so we don't miss any updates\n        dispose = setupTracking(nodes, updateFn, false, observeOptions === null || observeOptions === void 0 ? void 0 : observeOptions.immediate);\n        if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {\n            resubscribe = createResubscribe\n                ? () => {\n                    dispose === null || dispose === void 0 ? void 0 : dispose();\n                    dispose = setupTracking(nodes, updateFn);\n                    return dispose;\n                }\n                : undefined;\n        }\n    }\n    return { value, dispose, resubscribe };\n}\n\nfunction observe(selectorOrRun, reactionOrOptions, options) {\n    let reaction;\n    if (isFunction(reactionOrOptions)) {\n        reaction = reactionOrOptions;\n    }\n    else {\n        options = reactionOrOptions;\n    }\n    let dispose;\n    const e = { num: 0 };\n    // Wrap it in a function so it doesn't pass all the arguments to run()\n    const update = function () {\n        if (e.onCleanup) {\n            e.onCleanup();\n            e.onCleanup = undefined;\n        }\n        // Run in a batch so changes don't happen until we're done tracking here\n        beginBatch();\n        // Run the function/selector\n        delete e.value;\n        // Dispose listeners from previous run\n        dispose === null || dispose === void 0 ? void 0 : dispose();\n        const { dispose: _dispose, value } = trackSelector(selectorOrRun, update, e, options);\n        dispose = _dispose;\n        e.value = value;\n        if (e.onCleanupReaction) {\n            e.onCleanupReaction();\n            e.onCleanupReaction = undefined;\n        }\n        endBatch();\n        // Call the reaction if there is one and the value changed\n        if (reaction &&\n            (e.num > 0 || !isEvent(selectorOrRun)) &&\n            (e.previous !== e.value || (options === null || options === void 0 ? void 0 : options.fromComputed) || typeof e.value === 'object')) {\n            reaction(e);\n        }\n        // Update the previous value\n        e.previous = e.value;\n        // Increment the counter\n        e.num++;\n    };\n    update();\n    // Return function calling dispose because dispose may be changed in update()\n    return () => {\n        var _a, _b;\n        (_a = e.onCleanup) === null || _a === void 0 ? void 0 : _a.call(e);\n        e.onCleanup = undefined;\n        (_b = e.onCleanupReaction) === null || _b === void 0 ? void 0 : _b.call(e);\n        e.onCleanupReaction = undefined;\n        dispose === null || dispose === void 0 ? void 0 : dispose();\n    };\n}\n\nfunction computed(compute, set$1) {\n    // Create an observable for this computed variable\n    const obs = observable();\n    lockObservable(obs, true);\n    const node = getNode(obs);\n    node.isComputed = true;\n    let isSetAfterActivated = false;\n    const setInner = function (val) {\n        const prevNode = node.linkedToNode;\n        // If it was previously linked to a node remove self\n        // from its linkedFromNodes\n        if (prevNode) {\n            prevNode.linkedFromNodes.delete(node);\n            node.linkedToNode = undefined;\n        }\n        const { parentOther } = node;\n        if (isObservable(val)) {\n            // If the computed is a proxy to another observable\n            // link it to the target observable\n            const linkedNode = getNode(val);\n            node.linkedToNode = linkedNode;\n            if (!linkedNode.linkedFromNodes) {\n                linkedNode.linkedFromNodes = new Set();\n            }\n            linkedNode.linkedFromNodes.add(node);\n            if (node.parentOther) {\n                onChange(linkedNode, ({ value }) => {\n                    setNodeValue(node.parentOther, value);\n                }, { initial: true });\n            }\n            // If the target observable is different then notify for the change\n            if (prevNode) {\n                const value = getNodeValue(linkedNode);\n                const prevValue = getNodeValue(prevNode);\n                notify(node, value, prevValue, 0);\n            }\n        }\n        else if (val !== obs.peek()) {\n            // Unlock computed node before setting the value\n            lockObservable(obs, false);\n            const setter = isSetAfterActivated ? set : setNodeValue;\n            // Update the computed value\n            setter(node, val);\n            // If the computed is a child of an observable set the value on it\n            if (parentOther) {\n                let didUnlock = false;\n                if (parentOther.root.locked) {\n                    parentOther.root.locked = false;\n                    didUnlock = true;\n                }\n                setter(parentOther, val);\n                if (didUnlock) {\n                    parentOther.root.locked = true;\n                }\n            }\n            // Re-lock the computed node\n            lockObservable(obs, true);\n        }\n        else if (parentOther) {\n            setNodeValue(parentOther, val);\n        }\n        isSetAfterActivated = true;\n    };\n    // Lazily activate the observable when get is called\n    node.root.activate = () => {\n        node.root.activate = undefined;\n        observe(compute, ({ value }) => {\n            if (isPromise(value)) {\n                value.then((v) => setInner(v));\n            }\n            else {\n                setInner(value);\n            }\n        }, { immediate: true, fromComputed: true });\n    };\n    if (set$1) {\n        node.root.set = (value) => {\n            batch(() => set$1(value));\n        };\n    }\n    return obs;\n}\n\nfunction configureLegendState({ observableFunctions, observableProperties: observableProperties$1, }) {\n    if (observableFunctions) {\n        for (const key in observableFunctions) {\n            const fn = observableFunctions[key];\n            observableFns.set(key, fn);\n            ObservablePrimitiveClass.prototype[key] = function (...args) {\n                return fn.call(this, this._node, ...args);\n            };\n        }\n    }\n    if (observableProperties$1) {\n        for (const key in observableProperties$1) {\n            const fns = observableProperties$1[key];\n            observableProperties.set(key, fns);\n            Object.defineProperty(ObservablePrimitiveClass.prototype, key, {\n                configurable: true,\n                get() {\n                    return fns.get.call(this, this._node);\n                },\n                set(value) {\n                    return fns.set.call(this, this._node, value);\n                },\n            });\n        }\n    }\n}\n\nfunction event() {\n    // event simply wraps around a number observable\n    // which increments its value to dispatch change events\n    const obs = observable(0);\n    const node = getNode(obs);\n    node.isEvent = true;\n    return {\n        fire: function () {\n            // Notify increments the value so that the observable changes\n            obs.set((v) => v + 1);\n        },\n        on: function (cb) {\n            return obs.onChange(cb);\n        },\n        get: function () {\n            // Return the value so that when will be truthy\n            return obs.get();\n        },\n        // @ts-expect-error eslint doesn't like adding symbols to the object but this does work\n        [symbolGetNode]: node,\n    };\n}\n\nfunction proxy(get, set) {\n    // Create an observable for this computed variable\n    const obs = observable({});\n    lockObservable(obs, true);\n    const mapTargets = new Map();\n    const node = getNode(obs);\n    node.isComputed = true;\n    node.proxyFn = (key) => {\n        let target = mapTargets.get(key);\n        if (!target) {\n            // Note: Coercing typescript to allow undefined for set in computed because we don't want the public interface to allow undefined\n            target = computed(() => get(key), (set ? (value) => set(key, value) : undefined));\n            mapTargets.set(key, target);\n            extractFunction(node, key, target, getNode(target));\n            if (node.parentOther) {\n                onChange(getNode(target), ({ value, getPrevious }) => {\n                    const previous = getPrevious();\n                    // Set the raw value on the proxy's parent\n                    setNodeValue(node.parentOther, node.root._);\n                    // Notify the proxy\n                    notify(getChildNode(node, key), value, previous, 0);\n                });\n            }\n        }\n        return target;\n    };\n    return obs;\n}\n\nfunction _when(predicate, effect, checkReady) {\n    // If predicate is a regular Promise skip all the observable stuff\n    if (isPromise(predicate)) {\n        return effect ? predicate.then(effect) : predicate;\n    }\n    let value;\n    // Create a wrapping fn that calls the effect if predicate returns true\n    function run(e) {\n        const ret = computeSelector(predicate);\n        if (!isPromise(ret) && (checkReady ? isObservableValueReady(ret) : ret)) {\n            value = ret;\n            // Set cancel so that observe does not track anymore\n            e.cancel = true;\n        }\n        return value;\n    }\n    function doEffect() {\n        // If value is truthy then run the effect\n        effect === null || effect === void 0 ? void 0 : effect(value);\n    }\n    // Run in an observe\n    observe(run, doEffect);\n    // If first run resulted in a truthy value just return it.\n    // It will have set e.cancel so no need to dispose\n    if (isPromise(value)) {\n        return effect ? value.then(effect) : value;\n    }\n    else if (value !== undefined) {\n        return Promise.resolve(value);\n    }\n    else {\n        // Wrap it in a promise\n        const promise = new Promise((resolve) => {\n            if (effect) {\n                const originalEffect = effect;\n                effect = (value) => {\n                    const effectValue = originalEffect(value);\n                    resolve(effectValue);\n                };\n            }\n            else {\n                effect = resolve;\n            }\n        });\n        return promise;\n    }\n}\nfunction when(predicate, effect) {\n    return _when(predicate, effect, false);\n}\nfunction whenReady(predicate, effect) {\n    return _when(predicate, effect, true);\n}\n\nconst internal = {\n    clone,\n    ensureNodeValue,\n    findIDKey,\n    get,\n    getNode,\n    getPathType,\n    getProxy,\n    globalState,\n    initializePathType,\n    observableFns,\n    optimized,\n    peek,\n    safeParse,\n    safeStringify,\n    set,\n    setAtPath,\n    setNodeValue,\n    symbolDelete,\n};\n\nexports.ObservablePrimitiveClass = ObservablePrimitiveClass;\nexports.batch = batch;\nexports.beginBatch = beginBatch;\nexports.beginTracking = beginTracking;\nexports.checkActivate = checkActivate;\nexports.computeSelector = computeSelector;\nexports.computed = computed;\nexports.configureLegendState = configureLegendState;\nexports.constructObjectWithPath = constructObjectWithPath;\nexports.deconstructObjectWithPath = deconstructObjectWithPath;\nexports.endBatch = endBatch;\nexports.endTracking = endTracking;\nexports.event = event;\nexports.extraPrimitiveActivators = extraPrimitiveActivators;\nexports.extraPrimitiveProps = extraPrimitiveProps;\nexports.findIDKey = findIDKey;\nexports.getNode = getNode;\nexports.getNodeValue = getNodeValue;\nexports.getObservableIndex = getObservableIndex;\nexports.hasOwnProperty = hasOwnProperty;\nexports.internal = internal;\nexports.isArray = isArray;\nexports.isBoolean = isBoolean;\nexports.isEmpty = isEmpty;\nexports.isFunction = isFunction;\nexports.isObject = isObject;\nexports.isObservable = isObservable;\nexports.isObservableValueReady = isObservableValueReady;\nexports.isPrimitive = isPrimitive;\nexports.isPromise = isPromise;\nexports.isString = isString;\nexports.isSymbol = isSymbol;\nexports.lockObservable = lockObservable;\nexports.mergeIntoObservable = mergeIntoObservable;\nexports.observable = observable;\nexports.observablePrimitive = observablePrimitive;\nexports.observe = observe;\nexports.opaqueObject = opaqueObject;\nexports.optimized = optimized;\nexports.proxy = proxy;\nexports.setAtPath = setAtPath;\nexports.setInObservableAtPath = setInObservableAtPath;\nexports.setSilently = setSilently;\nexports.setupTracking = setupTracking;\nexports.symbolDelete = symbolDelete;\nexports.trackSelector = trackSelector;\nexports.tracking = tracking;\nexports.updateTracking = updateTracking;\nexports.when = when;\nexports.whenReady = whenReady;\n\n"]}