{"version":3,"file":"js/95106-d7aecd18c372feda97e6.chunk.js","mappings":"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","sources":["webpack://cms-web/./node_modules/pinia/node_modules/vue-demi/lib/index.mjs","webpack://cms-web/./node_modules/@vue/devtools-api/lib/esm/env.js","webpack://cms-web/./node_modules/@vue/devtools-api/lib/esm/const.js","webpack://cms-web/./node_modules/@vue/devtools-api/lib/esm/time.js","webpack://cms-web/./node_modules/pinia/dist/pinia.mjs","webpack://cms-web/./node_modules/@vue/devtools-api/lib/esm/proxy.js","webpack://cms-web/./node_modules/@vue/devtools-api/lib/esm/index.js"],"sourcesContent":["import * as Vue from 'vue'\n\nvar isVue2 = false\nvar isVue3 = true\nvar Vue2 = undefined\n\nfunction install() {}\n\nexport function set(target, key, val) {\n  if (Array.isArray(target)) {\n    target.length = Math.max(target.length, key)\n    target.splice(key, 1, val)\n    return val\n  }\n  target[key] = val\n  return val\n}\n\nexport function del(target, key) {\n  if (Array.isArray(target)) {\n    target.splice(key, 1)\n    return\n  }\n  delete target[key]\n}\n\nexport * from 'vue'\nexport {\n  Vue,\n  Vue2,\n  isVue2,\n  isVue3,\n  install,\n}\n","export function getDevtoolsGlobalHook() {\n    return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__;\n}\nexport function getTarget() {\n    // @ts-expect-error navigator and windows are not available in all environments\n    return (typeof navigator !== 'undefined' && typeof window !== 'undefined')\n        ? window\n        : typeof globalThis !== 'undefined'\n            ? globalThis\n            : {};\n}\nexport const isProxyAvailable = typeof Proxy === 'function';\n","export const HOOK_SETUP = 'devtools-plugin:setup';\nexport const HOOK_PLUGIN_SETTINGS_SET = 'plugin:settings:set';\n","let supported;\nlet perf;\nexport function isPerformanceSupported() {\n    var _a;\n    if (supported !== undefined) {\n        return supported;\n    }\n    if (typeof window !== 'undefined' && window.performance) {\n        supported = true;\n        perf = window.performance;\n    }\n    else if (typeof globalThis !== 'undefined' && ((_a = globalThis.perf_hooks) === null || _a === void 0 ? void 0 : _a.performance)) {\n        supported = true;\n        perf = globalThis.perf_hooks.performance;\n    }\n    else {\n        supported = false;\n    }\n    return supported;\n}\nexport function now() {\n    return isPerformanceSupported() ? perf.now() : Date.now();\n}\n","/*!\n * pinia v2.1.7\n * (c) 2023 Eduardo San Martin Morote\n * @license MIT\n */\nimport { hasInjectionContext, inject, toRaw, watch, unref, markRaw, effectScope, ref, isVue2, isRef, isReactive, set, getCurrentScope, onScopeDispose, getCurrentInstance, reactive, toRef, del, nextTick, computed, toRefs } from 'vue-demi';\nimport { setupDevtoolsPlugin } from '@vue/devtools-api';\n\n/**\n * setActivePinia must be called to handle SSR at the top of functions like\n * `fetch`, `setup`, `serverPrefetch` and others\n */\nlet activePinia;\n/**\n * Sets or unsets the active pinia. Used in SSR and internally when calling\n * actions and getters\n *\n * @param pinia - Pinia instance\n */\n// @ts-expect-error: cannot constrain the type of the return\nconst setActivePinia = (pinia) => (activePinia = pinia);\n/**\n * Get the currently active pinia if there is any.\n */\nconst getActivePinia = () => (hasInjectionContext() && inject(piniaSymbol)) || activePinia;\nconst piniaSymbol = ((process.env.NODE_ENV !== 'production') ? Symbol('pinia') : /* istanbul ignore next */ Symbol());\n\nfunction isPlainObject(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\no) {\n    return (o &&\n        typeof o === 'object' &&\n        Object.prototype.toString.call(o) === '[object Object]' &&\n        typeof o.toJSON !== 'function');\n}\n// type DeepReadonly<T> = { readonly [P in keyof T]: DeepReadonly<T[P]> }\n// TODO: can we change these to numbers?\n/**\n * Possible types for SubscriptionCallback\n */\nvar MutationType;\n(function (MutationType) {\n    /**\n     * Direct mutation of the state:\n     *\n     * - `store.name = 'new name'`\n     * - `store.$state.name = 'new name'`\n     * - `store.list.push('new item')`\n     */\n    MutationType[\"direct\"] = \"direct\";\n    /**\n     * Mutated the state with `$patch` and an object\n     *\n     * - `store.$patch({ name: 'newName' })`\n     */\n    MutationType[\"patchObject\"] = \"patch object\";\n    /**\n     * Mutated the state with `$patch` and a function\n     *\n     * - `store.$patch(state => state.name = 'newName')`\n     */\n    MutationType[\"patchFunction\"] = \"patch function\";\n    // maybe reset? for $state = {} and $reset\n})(MutationType || (MutationType = {}));\n\nconst IS_CLIENT = typeof window !== 'undefined';\n/**\n * Should we add the devtools plugins.\n * - only if dev mode or forced through the prod devtools flag\n * - not in test\n * - only if window exists (could change in the future)\n */\nconst USE_DEVTOOLS = ((process.env.NODE_ENV !== 'production') || (typeof __VUE_PROD_DEVTOOLS__ !== 'undefined' && __VUE_PROD_DEVTOOLS__)) && !(process.env.NODE_ENV === 'test') && IS_CLIENT;\n\n/*\n * FileSaver.js A saveAs() FileSaver implementation.\n *\n * Originally by Eli Grey, adapted as an ESM module by Eduardo San Martin\n * Morote.\n *\n * License : MIT\n */\n// The one and only way of getting global scope in all environments\n// https://stackoverflow.com/q/3277182/1008999\nconst _global = /*#__PURE__*/ (() => typeof window === 'object' && window.window === window\n    ? window\n    : typeof self === 'object' && self.self === self\n        ? self\n        : typeof global === 'object' && global.global === global\n            ? global\n            : typeof globalThis === 'object'\n                ? globalThis\n                : { HTMLElement: null })();\nfunction bom(blob, { autoBom = false } = {}) {\n    // prepend BOM for UTF-8 XML and text/* types (including HTML)\n    // note: your browser will automatically convert UTF-16 U+FEFF to EF BB BF\n    if (autoBom &&\n        /^\\s*(?:text\\/\\S*|application\\/xml|\\S*\\/\\S*\\+xml)\\s*;.*charset\\s*=\\s*utf-8/i.test(blob.type)) {\n        return new Blob([String.fromCharCode(0xfeff), blob], { type: blob.type });\n    }\n    return blob;\n}\nfunction download(url, name, opts) {\n    const xhr = new XMLHttpRequest();\n    xhr.open('GET', url);\n    xhr.responseType = 'blob';\n    xhr.onload = function () {\n        saveAs(xhr.response, name, opts);\n    };\n    xhr.onerror = function () {\n        console.error('could not download file');\n    };\n    xhr.send();\n}\nfunction corsEnabled(url) {\n    const xhr = new XMLHttpRequest();\n    // use sync to avoid popup blocker\n    xhr.open('HEAD', url, false);\n    try {\n        xhr.send();\n    }\n    catch (e) { }\n    return xhr.status >= 200 && xhr.status <= 299;\n}\n// `a.click()` doesn't work for all browsers (#465)\nfunction click(node) {\n    try {\n        node.dispatchEvent(new MouseEvent('click'));\n    }\n    catch (e) {\n        const evt = document.createEvent('MouseEvents');\n        evt.initMouseEvent('click', true, true, window, 0, 0, 0, 80, 20, false, false, false, false, 0, null);\n        node.dispatchEvent(evt);\n    }\n}\nconst _navigator = \n typeof navigator === 'object' ? navigator : { userAgent: '' };\n// Detect WebView inside a native macOS app by ruling out all browsers\n// We just need to check for 'Safari' because all other browsers (besides Firefox) include that too\n// https://www.whatismybrowser.com/guides/the-latest-user-agent/macos\nconst isMacOSWebView = /*#__PURE__*/ (() => /Macintosh/.test(_navigator.userAgent) &&\n    /AppleWebKit/.test(_navigator.userAgent) &&\n    !/Safari/.test(_navigator.userAgent))();\nconst saveAs = !IS_CLIENT\n    ? () => { } // noop\n    : // Use download attribute first if possible (#193 Lumia mobile) unless this is a macOS WebView or mini program\n        typeof HTMLAnchorElement !== 'undefined' &&\n            'download' in HTMLAnchorElement.prototype &&\n            !isMacOSWebView\n            ? downloadSaveAs\n            : // Use msSaveOrOpenBlob as a second approach\n                'msSaveOrOpenBlob' in _navigator\n                    ? msSaveAs\n                    : // Fallback to using FileReader and a popup\n                        fileSaverSaveAs;\nfunction downloadSaveAs(blob, name = 'download', opts) {\n    const a = document.createElement('a');\n    a.download = name;\n    a.rel = 'noopener'; // tabnabbing\n    // TODO: detect chrome extensions & packaged apps\n    // a.target = '_blank'\n    if (typeof blob === 'string') {\n        // Support regular links\n        a.href = blob;\n        if (a.origin !== location.origin) {\n            if (corsEnabled(a.href)) {\n                download(blob, name, opts);\n            }\n            else {\n                a.target = '_blank';\n                click(a);\n            }\n        }\n        else {\n            click(a);\n        }\n    }\n    else {\n        // Support blobs\n        a.href = URL.createObjectURL(blob);\n        setTimeout(function () {\n            URL.revokeObjectURL(a.href);\n        }, 4e4); // 40s\n        setTimeout(function () {\n            click(a);\n        }, 0);\n    }\n}\nfunction msSaveAs(blob, name = 'download', opts) {\n    if (typeof blob === 'string') {\n        if (corsEnabled(blob)) {\n            download(blob, name, opts);\n        }\n        else {\n            const a = document.createElement('a');\n            a.href = blob;\n            a.target = '_blank';\n            setTimeout(function () {\n                click(a);\n            });\n        }\n    }\n    else {\n        // @ts-ignore: works on windows\n        navigator.msSaveOrOpenBlob(bom(blob, opts), name);\n    }\n}\nfunction fileSaverSaveAs(blob, name, opts, popup) {\n    // Open a popup immediately do go around popup blocker\n    // Mostly only available on user interaction and the fileReader is async so...\n    popup = popup || open('', '_blank');\n    if (popup) {\n        popup.document.title = popup.document.body.innerText = 'downloading...';\n    }\n    if (typeof blob === 'string')\n        return download(blob, name, opts);\n    const force = blob.type === 'application/octet-stream';\n    const isSafari = /constructor/i.test(String(_global.HTMLElement)) || 'safari' in _global;\n    const isChromeIOS = /CriOS\\/[\\d]+/.test(navigator.userAgent);\n    if ((isChromeIOS || (force && isSafari) || isMacOSWebView) &&\n        typeof FileReader !== 'undefined') {\n        // Safari doesn't allow downloading of blob URLs\n        const reader = new FileReader();\n        reader.onloadend = function () {\n            let url = reader.result;\n            if (typeof url !== 'string') {\n                popup = null;\n                throw new Error('Wrong reader.result type');\n            }\n            url = isChromeIOS\n                ? url\n                : url.replace(/^data:[^;]*;/, 'data:attachment/file;');\n            if (popup) {\n                popup.location.href = url;\n            }\n            else {\n                location.assign(url);\n            }\n            popup = null; // reverse-tabnabbing #460\n        };\n        reader.readAsDataURL(blob);\n    }\n    else {\n        const url = URL.createObjectURL(blob);\n        if (popup)\n            popup.location.assign(url);\n        else\n            location.href = url;\n        popup = null; // reverse-tabnabbing #460\n        setTimeout(function () {\n            URL.revokeObjectURL(url);\n        }, 4e4); // 40s\n    }\n}\n\n/**\n * Shows a toast or console.log\n *\n * @param message - message to log\n * @param type - different color of the tooltip\n */\nfunction toastMessage(message, type) {\n    const piniaMessage = '🍍 ' + message;\n    if (typeof __VUE_DEVTOOLS_TOAST__ === 'function') {\n        // No longer available :(\n        __VUE_DEVTOOLS_TOAST__(piniaMessage, type);\n    }\n    else if (type === 'error') {\n        console.error(piniaMessage);\n    }\n    else if (type === 'warn') {\n        console.warn(piniaMessage);\n    }\n    else {\n        console.log(piniaMessage);\n    }\n}\nfunction isPinia(o) {\n    return '_a' in o && 'install' in o;\n}\n\n/**\n * This file contain devtools actions, they are not Pinia actions.\n */\n// ---\nfunction checkClipboardAccess() {\n    if (!('clipboard' in navigator)) {\n        toastMessage(`Your browser doesn't support the Clipboard API`, 'error');\n        return true;\n    }\n}\nfunction checkNotFocusedError(error) {\n    if (error instanceof Error &&\n        error.message.toLowerCase().includes('document is not focused')) {\n        toastMessage('You need to activate the \"Emulate a focused page\" setting in the \"Rendering\" panel of devtools.', 'warn');\n        return true;\n    }\n    return false;\n}\nasync function actionGlobalCopyState(pinia) {\n    if (checkClipboardAccess())\n        return;\n    try {\n        await navigator.clipboard.writeText(JSON.stringify(pinia.state.value));\n        toastMessage('Global state copied to clipboard.');\n    }\n    catch (error) {\n        if (checkNotFocusedError(error))\n            return;\n        toastMessage(`Failed to serialize the state. Check the console for more details.`, 'error');\n        console.error(error);\n    }\n}\nasync function actionGlobalPasteState(pinia) {\n    if (checkClipboardAccess())\n        return;\n    try {\n        loadStoresState(pinia, JSON.parse(await navigator.clipboard.readText()));\n        toastMessage('Global state pasted from clipboard.');\n    }\n    catch (error) {\n        if (checkNotFocusedError(error))\n            return;\n        toastMessage(`Failed to deserialize the state from clipboard. Check the console for more details.`, 'error');\n        console.error(error);\n    }\n}\nasync function actionGlobalSaveState(pinia) {\n    try {\n        saveAs(new Blob([JSON.stringify(pinia.state.value)], {\n            type: 'text/plain;charset=utf-8',\n        }), 'pinia-state.json');\n    }\n    catch (error) {\n        toastMessage(`Failed to export the state as JSON. Check the console for more details.`, 'error');\n        console.error(error);\n    }\n}\nlet fileInput;\nfunction getFileOpener() {\n    if (!fileInput) {\n        fileInput = document.createElement('input');\n        fileInput.type = 'file';\n        fileInput.accept = '.json';\n    }\n    function openFile() {\n        return new Promise((resolve, reject) => {\n            fileInput.onchange = async () => {\n                const files = fileInput.files;\n                if (!files)\n                    return resolve(null);\n                const file = files.item(0);\n                if (!file)\n                    return resolve(null);\n                return resolve({ text: await file.text(), file });\n            };\n            // @ts-ignore: TODO: changed from 4.3 to 4.4\n            fileInput.oncancel = () => resolve(null);\n            fileInput.onerror = reject;\n            fileInput.click();\n        });\n    }\n    return openFile;\n}\nasync function actionGlobalOpenStateFile(pinia) {\n    try {\n        const open = getFileOpener();\n        const result = await open();\n        if (!result)\n            return;\n        const { text, file } = result;\n        loadStoresState(pinia, JSON.parse(text));\n        toastMessage(`Global state imported from \"${file.name}\".`);\n    }\n    catch (error) {\n        toastMessage(`Failed to import the state from JSON. Check the console for more details.`, 'error');\n        console.error(error);\n    }\n}\nfunction loadStoresState(pinia, state) {\n    for (const key in state) {\n        const storeState = pinia.state.value[key];\n        // store is already instantiated, patch it\n        if (storeState) {\n            Object.assign(storeState, state[key]);\n        }\n        else {\n            // store is not instantiated, set the initial state\n            pinia.state.value[key] = state[key];\n        }\n    }\n}\n\nfunction formatDisplay(display) {\n    return {\n        _custom: {\n            display,\n        },\n    };\n}\nconst PINIA_ROOT_LABEL = '🍍 Pinia (root)';\nconst PINIA_ROOT_ID = '_root';\nfunction formatStoreForInspectorTree(store) {\n    return isPinia(store)\n        ? {\n            id: PINIA_ROOT_ID,\n            label: PINIA_ROOT_LABEL,\n        }\n        : {\n            id: store.$id,\n            label: store.$id,\n        };\n}\nfunction formatStoreForInspectorState(store) {\n    if (isPinia(store)) {\n        const storeNames = Array.from(store._s.keys());\n        const storeMap = store._s;\n        const state = {\n            state: storeNames.map((storeId) => ({\n                editable: true,\n                key: storeId,\n                value: store.state.value[storeId],\n            })),\n            getters: storeNames\n                .filter((id) => storeMap.get(id)._getters)\n                .map((id) => {\n                const store = storeMap.get(id);\n                return {\n                    editable: false,\n                    key: id,\n                    value: store._getters.reduce((getters, key) => {\n                        getters[key] = store[key];\n                        return getters;\n                    }, {}),\n                };\n            }),\n        };\n        return state;\n    }\n    const state = {\n        state: Object.keys(store.$state).map((key) => ({\n            editable: true,\n            key,\n            value: store.$state[key],\n        })),\n    };\n    // avoid adding empty getters\n    if (store._getters && store._getters.length) {\n        state.getters = store._getters.map((getterName) => ({\n            editable: false,\n            key: getterName,\n            value: store[getterName],\n        }));\n    }\n    if (store._customProperties.size) {\n        state.customProperties = Array.from(store._customProperties).map((key) => ({\n            editable: true,\n            key,\n            value: store[key],\n        }));\n    }\n    return state;\n}\nfunction formatEventData(events) {\n    if (!events)\n        return {};\n    if (Array.isArray(events)) {\n        // TODO: handle add and delete for arrays and objects\n        return events.reduce((data, event) => {\n            data.keys.push(event.key);\n            data.operations.push(event.type);\n            data.oldValue[event.key] = event.oldValue;\n            data.newValue[event.key] = event.newValue;\n            return data;\n        }, {\n            oldValue: {},\n            keys: [],\n            operations: [],\n            newValue: {},\n        });\n    }\n    else {\n        return {\n            operation: formatDisplay(events.type),\n            key: formatDisplay(events.key),\n            oldValue: events.oldValue,\n            newValue: events.newValue,\n        };\n    }\n}\nfunction formatMutationType(type) {\n    switch (type) {\n        case MutationType.direct:\n            return 'mutation';\n        case MutationType.patchFunction:\n            return '$patch';\n        case MutationType.patchObject:\n            return '$patch';\n        default:\n            return 'unknown';\n    }\n}\n\n// timeline can be paused when directly changing the state\nlet isTimelineActive = true;\nconst componentStateTypes = [];\nconst MUTATIONS_LAYER_ID = 'pinia:mutations';\nconst INSPECTOR_ID = 'pinia';\nconst { assign: assign$1 } = Object;\n/**\n * Gets the displayed name of a store in devtools\n *\n * @param id - id of the store\n * @returns a formatted string\n */\nconst getStoreType = (id) => '🍍 ' + id;\n/**\n * Add the pinia plugin without any store. Allows displaying a Pinia plugin tab\n * as soon as it is added to the application.\n *\n * @param app - Vue application\n * @param pinia - pinia instance\n */\nfunction registerPiniaDevtools(app, pinia) {\n    setupDevtoolsPlugin({\n        id: 'dev.esm.pinia',\n        label: 'Pinia 🍍',\n        logo: 'https://pinia.vuejs.org/logo.svg',\n        packageName: 'pinia',\n        homepage: 'https://pinia.vuejs.org',\n        componentStateTypes,\n        app,\n    }, (api) => {\n        if (typeof api.now !== 'function') {\n            toastMessage('You seem to be using an outdated version of Vue Devtools. Are you still using the Beta release instead of the stable one? You can find the links at https://devtools.vuejs.org/guide/installation.html.');\n        }\n        api.addTimelineLayer({\n            id: MUTATIONS_LAYER_ID,\n            label: `Pinia 🍍`,\n            color: 0xe5df88,\n        });\n        api.addInspector({\n            id: INSPECTOR_ID,\n            label: 'Pinia 🍍',\n            icon: 'storage',\n            treeFilterPlaceholder: 'Search stores',\n            actions: [\n                {\n                    icon: 'content_copy',\n                    action: () => {\n                        actionGlobalCopyState(pinia);\n                    },\n                    tooltip: 'Serialize and copy the state',\n                },\n                {\n                    icon: 'content_paste',\n                    action: async () => {\n                        await actionGlobalPasteState(pinia);\n                        api.sendInspectorTree(INSPECTOR_ID);\n                        api.sendInspectorState(INSPECTOR_ID);\n                    },\n                    tooltip: 'Replace the state with the content of your clipboard',\n                },\n                {\n                    icon: 'save',\n                    action: () => {\n                        actionGlobalSaveState(pinia);\n                    },\n                    tooltip: 'Save the state as a JSON file',\n                },\n                {\n                    icon: 'folder_open',\n                    action: async () => {\n                        await actionGlobalOpenStateFile(pinia);\n                        api.sendInspectorTree(INSPECTOR_ID);\n                        api.sendInspectorState(INSPECTOR_ID);\n                    },\n                    tooltip: 'Import the state from a JSON file',\n                },\n            ],\n            nodeActions: [\n                {\n                    icon: 'restore',\n                    tooltip: 'Reset the state (with \"$reset\")',\n                    action: (nodeId) => {\n                        const store = pinia._s.get(nodeId);\n                        if (!store) {\n                            toastMessage(`Cannot reset \"${nodeId}\" store because it wasn't found.`, 'warn');\n                        }\n                        else if (typeof store.$reset !== 'function') {\n                            toastMessage(`Cannot reset \"${nodeId}\" store because it doesn't have a \"$reset\" method implemented.`, 'warn');\n                        }\n                        else {\n                            store.$reset();\n                            toastMessage(`Store \"${nodeId}\" reset.`);\n                        }\n                    },\n                },\n            ],\n        });\n        api.on.inspectComponent((payload, ctx) => {\n            const proxy = (payload.componentInstance &&\n                payload.componentInstance.proxy);\n            if (proxy && proxy._pStores) {\n                const piniaStores = payload.componentInstance.proxy._pStores;\n                Object.values(piniaStores).forEach((store) => {\n                    payload.instanceData.state.push({\n                        type: getStoreType(store.$id),\n                        key: 'state',\n                        editable: true,\n                        value: store._isOptionsAPI\n                            ? {\n                                _custom: {\n                                    value: toRaw(store.$state),\n                                    actions: [\n                                        {\n                                            icon: 'restore',\n                                            tooltip: 'Reset the state of this store',\n                                            action: () => store.$reset(),\n                                        },\n                                    ],\n                                },\n                            }\n                            : // NOTE: workaround to unwrap transferred refs\n                                Object.keys(store.$state).reduce((state, key) => {\n                                    state[key] = store.$state[key];\n                                    return state;\n                                }, {}),\n                    });\n                    if (store._getters && store._getters.length) {\n                        payload.instanceData.state.push({\n                            type: getStoreType(store.$id),\n                            key: 'getters',\n                            editable: false,\n                            value: store._getters.reduce((getters, key) => {\n                                try {\n                                    getters[key] = store[key];\n                                }\n                                catch (error) {\n                                    // @ts-expect-error: we just want to show it in devtools\n                                    getters[key] = error;\n                                }\n                                return getters;\n                            }, {}),\n                        });\n                    }\n                });\n            }\n        });\n        api.on.getInspectorTree((payload) => {\n            if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {\n                let stores = [pinia];\n                stores = stores.concat(Array.from(pinia._s.values()));\n                payload.rootNodes = (payload.filter\n                    ? stores.filter((store) => '$id' in store\n                        ? store.$id\n                            .toLowerCase()\n                            .includes(payload.filter.toLowerCase())\n                        : PINIA_ROOT_LABEL.toLowerCase().includes(payload.filter.toLowerCase()))\n                    : stores).map(formatStoreForInspectorTree);\n            }\n        });\n        api.on.getInspectorState((payload) => {\n            if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {\n                const inspectedStore = payload.nodeId === PINIA_ROOT_ID\n                    ? pinia\n                    : pinia._s.get(payload.nodeId);\n                if (!inspectedStore) {\n                    // this could be the selected store restored for a different project\n                    // so it's better not to say anything here\n                    return;\n                }\n                if (inspectedStore) {\n                    payload.state = formatStoreForInspectorState(inspectedStore);\n                }\n            }\n        });\n        api.on.editInspectorState((payload, ctx) => {\n            if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {\n                const inspectedStore = payload.nodeId === PINIA_ROOT_ID\n                    ? pinia\n                    : pinia._s.get(payload.nodeId);\n                if (!inspectedStore) {\n                    return toastMessage(`store \"${payload.nodeId}\" not found`, 'error');\n                }\n                const { path } = payload;\n                if (!isPinia(inspectedStore)) {\n                    // access only the state\n                    if (path.length !== 1 ||\n                        !inspectedStore._customProperties.has(path[0]) ||\n                        path[0] in inspectedStore.$state) {\n                        path.unshift('$state');\n                    }\n                }\n                else {\n                    // Root access, we can omit the `.value` because the devtools API does it for us\n                    path.unshift('state');\n                }\n                isTimelineActive = false;\n                payload.set(inspectedStore, path, payload.state.value);\n                isTimelineActive = true;\n            }\n        });\n        api.on.editComponentState((payload) => {\n            if (payload.type.startsWith('🍍')) {\n                const storeId = payload.type.replace(/^🍍\\s*/, '');\n                const store = pinia._s.get(storeId);\n                if (!store) {\n                    return toastMessage(`store \"${storeId}\" not found`, 'error');\n                }\n                const { path } = payload;\n                if (path[0] !== 'state') {\n                    return toastMessage(`Invalid path for store \"${storeId}\":\\n${path}\\nOnly state can be modified.`);\n                }\n                // rewrite the first entry to be able to directly set the state as\n                // well as any other path\n                path[0] = '$state';\n                isTimelineActive = false;\n                payload.set(store, path, payload.state.value);\n                isTimelineActive = true;\n            }\n        });\n    });\n}\nfunction addStoreToDevtools(app, store) {\n    if (!componentStateTypes.includes(getStoreType(store.$id))) {\n        componentStateTypes.push(getStoreType(store.$id));\n    }\n    setupDevtoolsPlugin({\n        id: 'dev.esm.pinia',\n        label: 'Pinia 🍍',\n        logo: 'https://pinia.vuejs.org/logo.svg',\n        packageName: 'pinia',\n        homepage: 'https://pinia.vuejs.org',\n        componentStateTypes,\n        app,\n        settings: {\n            logStoreChanges: {\n                label: 'Notify about new/deleted stores',\n                type: 'boolean',\n                defaultValue: true,\n            },\n            // useEmojis: {\n            //   label: 'Use emojis in messages ⚡️',\n            //   type: 'boolean',\n            //   defaultValue: true,\n            // },\n        },\n    }, (api) => {\n        // gracefully handle errors\n        const now = typeof api.now === 'function' ? api.now.bind(api) : Date.now;\n        store.$onAction(({ after, onError, name, args }) => {\n            const groupId = runningActionId++;\n            api.addTimelineEvent({\n                layerId: MUTATIONS_LAYER_ID,\n                event: {\n                    time: now(),\n                    title: '🛫 ' + name,\n                    subtitle: 'start',\n                    data: {\n                        store: formatDisplay(store.$id),\n                        action: formatDisplay(name),\n                        args,\n                    },\n                    groupId,\n                },\n            });\n            after((result) => {\n                activeAction = undefined;\n                api.addTimelineEvent({\n                    layerId: MUTATIONS_LAYER_ID,\n                    event: {\n                        time: now(),\n                        title: '🛬 ' + name,\n                        subtitle: 'end',\n                        data: {\n                            store: formatDisplay(store.$id),\n                            action: formatDisplay(name),\n                            args,\n                            result,\n                        },\n                        groupId,\n                    },\n                });\n            });\n            onError((error) => {\n                activeAction = undefined;\n                api.addTimelineEvent({\n                    layerId: MUTATIONS_LAYER_ID,\n                    event: {\n                        time: now(),\n                        logType: 'error',\n                        title: '💥 ' + name,\n                        subtitle: 'end',\n                        data: {\n                            store: formatDisplay(store.$id),\n                            action: formatDisplay(name),\n                            args,\n                            error,\n                        },\n                        groupId,\n                    },\n                });\n            });\n        }, true);\n        store._customProperties.forEach((name) => {\n            watch(() => unref(store[name]), (newValue, oldValue) => {\n                api.notifyComponentUpdate();\n                api.sendInspectorState(INSPECTOR_ID);\n                if (isTimelineActive) {\n                    api.addTimelineEvent({\n                        layerId: MUTATIONS_LAYER_ID,\n                        event: {\n                            time: now(),\n                            title: 'Change',\n                            subtitle: name,\n                            data: {\n                                newValue,\n                                oldValue,\n                            },\n                            groupId: activeAction,\n                        },\n                    });\n                }\n            }, { deep: true });\n        });\n        store.$subscribe(({ events, type }, state) => {\n            api.notifyComponentUpdate();\n            api.sendInspectorState(INSPECTOR_ID);\n            if (!isTimelineActive)\n                return;\n            // rootStore.state[store.id] = state\n            const eventData = {\n                time: now(),\n                title: formatMutationType(type),\n                data: assign$1({ store: formatDisplay(store.$id) }, formatEventData(events)),\n                groupId: activeAction,\n            };\n            if (type === MutationType.patchFunction) {\n                eventData.subtitle = '⤵️';\n            }\n            else if (type === MutationType.patchObject) {\n                eventData.subtitle = '🧩';\n            }\n            else if (events && !Array.isArray(events)) {\n                eventData.subtitle = events.type;\n            }\n            if (events) {\n                eventData.data['rawEvent(s)'] = {\n                    _custom: {\n                        display: 'DebuggerEvent',\n                        type: 'object',\n                        tooltip: 'raw DebuggerEvent[]',\n                        value: events,\n                    },\n                };\n            }\n            api.addTimelineEvent({\n                layerId: MUTATIONS_LAYER_ID,\n                event: eventData,\n            });\n        }, { detached: true, flush: 'sync' });\n        const hotUpdate = store._hotUpdate;\n        store._hotUpdate = markRaw((newStore) => {\n            hotUpdate(newStore);\n            api.addTimelineEvent({\n                layerId: MUTATIONS_LAYER_ID,\n                event: {\n                    time: now(),\n                    title: '🔥 ' + store.$id,\n                    subtitle: 'HMR update',\n                    data: {\n                        store: formatDisplay(store.$id),\n                        info: formatDisplay(`HMR update`),\n                    },\n                },\n            });\n            // update the devtools too\n            api.notifyComponentUpdate();\n            api.sendInspectorTree(INSPECTOR_ID);\n            api.sendInspectorState(INSPECTOR_ID);\n        });\n        const { $dispose } = store;\n        store.$dispose = () => {\n            $dispose();\n            api.notifyComponentUpdate();\n            api.sendInspectorTree(INSPECTOR_ID);\n            api.sendInspectorState(INSPECTOR_ID);\n            api.getSettings().logStoreChanges &&\n                toastMessage(`Disposed \"${store.$id}\" store 🗑`);\n        };\n        // trigger an update so it can display new registered stores\n        api.notifyComponentUpdate();\n        api.sendInspectorTree(INSPECTOR_ID);\n        api.sendInspectorState(INSPECTOR_ID);\n        api.getSettings().logStoreChanges &&\n            toastMessage(`\"${store.$id}\" store installed 🆕`);\n    });\n}\nlet runningActionId = 0;\nlet activeAction;\n/**\n * Patches a store to enable action grouping in devtools by wrapping the store with a Proxy that is passed as the\n * context of all actions, allowing us to set `runningAction` on each access and effectively associating any state\n * mutation to the action.\n *\n * @param store - store to patch\n * @param actionNames - list of actionst to patch\n */\nfunction patchActionForGrouping(store, actionNames, wrapWithProxy) {\n    // original actions of the store as they are given by pinia. We are going to override them\n    const actions = actionNames.reduce((storeActions, actionName) => {\n        // use toRaw to avoid tracking #541\n        storeActions[actionName] = toRaw(store)[actionName];\n        return storeActions;\n    }, {});\n    for (const actionName in actions) {\n        store[actionName] = function () {\n            // the running action id is incremented in a before action hook\n            const _actionId = runningActionId;\n            const trackedStore = wrapWithProxy\n                ? new Proxy(store, {\n                    get(...args) {\n                        activeAction = _actionId;\n                        return Reflect.get(...args);\n                    },\n                    set(...args) {\n                        activeAction = _actionId;\n                        return Reflect.set(...args);\n                    },\n                })\n                : store;\n            // For Setup Stores we need https://github.com/tc39/proposal-async-context\n            activeAction = _actionId;\n            const retValue = actions[actionName].apply(trackedStore, arguments);\n            // this is safer as async actions in Setup Stores would associate mutations done outside of the action\n            activeAction = undefined;\n            return retValue;\n        };\n    }\n}\n/**\n * pinia.use(devtoolsPlugin)\n */\nfunction devtoolsPlugin({ app, store, options }) {\n    // HMR module\n    if (store.$id.startsWith('__hot:')) {\n        return;\n    }\n    // detect option api vs setup api\n    store._isOptionsAPI = !!options.state;\n    patchActionForGrouping(store, Object.keys(options.actions), store._isOptionsAPI);\n    // Upgrade the HMR to also update the new actions\n    const originalHotUpdate = store._hotUpdate;\n    toRaw(store)._hotUpdate = function (newStore) {\n        originalHotUpdate.apply(this, arguments);\n        patchActionForGrouping(store, Object.keys(newStore._hmrPayload.actions), !!store._isOptionsAPI);\n    };\n    addStoreToDevtools(app, \n    // FIXME: is there a way to allow the assignment from Store<Id, S, G, A> to StoreGeneric?\n    store);\n}\n\n/**\n * Creates a Pinia instance to be used by the application\n */\nfunction createPinia() {\n    const scope = effectScope(true);\n    // NOTE: here we could check the window object for a state and directly set it\n    // if there is anything like it with Vue 3 SSR\n    const state = scope.run(() => ref({}));\n    let _p = [];\n    // plugins added before calling app.use(pinia)\n    let toBeInstalled = [];\n    const pinia = markRaw({\n        install(app) {\n            // this allows calling useStore() outside of a component setup after\n            // installing pinia's plugin\n            setActivePinia(pinia);\n            if (!isVue2) {\n                pinia._a = app;\n                app.provide(piniaSymbol, pinia);\n                app.config.globalProperties.$pinia = pinia;\n                /* istanbul ignore else */\n                if (USE_DEVTOOLS) {\n                    registerPiniaDevtools(app, pinia);\n                }\n                toBeInstalled.forEach((plugin) => _p.push(plugin));\n                toBeInstalled = [];\n            }\n        },\n        use(plugin) {\n            if (!this._a && !isVue2) {\n                toBeInstalled.push(plugin);\n            }\n            else {\n                _p.push(plugin);\n            }\n            return this;\n        },\n        _p,\n        // it's actually undefined here\n        // @ts-expect-error\n        _a: null,\n        _e: scope,\n        _s: new Map(),\n        state,\n    });\n    // pinia devtools rely on dev only features so they cannot be forced unless\n    // the dev build of Vue is used. Avoid old browsers like IE11.\n    if (USE_DEVTOOLS && typeof Proxy !== 'undefined') {\n        pinia.use(devtoolsPlugin);\n    }\n    return pinia;\n}\n\n/**\n * Checks if a function is a `StoreDefinition`.\n *\n * @param fn - object to test\n * @returns true if `fn` is a StoreDefinition\n */\nconst isUseStore = (fn) => {\n    return typeof fn === 'function' && typeof fn.$id === 'string';\n};\n/**\n * Mutates in place `newState` with `oldState` to _hot update_ it. It will\n * remove any key not existing in `newState` and recursively merge plain\n * objects.\n *\n * @param newState - new state object to be patched\n * @param oldState - old state that should be used to patch newState\n * @returns - newState\n */\nfunction patchObject(newState, oldState) {\n    // no need to go through symbols because they cannot be serialized anyway\n    for (const key in oldState) {\n        const subPatch = oldState[key];\n        // skip the whole sub tree\n        if (!(key in newState)) {\n            continue;\n        }\n        const targetValue = newState[key];\n        if (isPlainObject(targetValue) &&\n            isPlainObject(subPatch) &&\n            !isRef(subPatch) &&\n            !isReactive(subPatch)) {\n            newState[key] = patchObject(targetValue, subPatch);\n        }\n        else {\n            // objects are either a bit more complex (e.g. refs) or primitives, so we\n            // just set the whole thing\n            if (isVue2) {\n                set(newState, key, subPatch);\n            }\n            else {\n                newState[key] = subPatch;\n            }\n        }\n    }\n    return newState;\n}\n/**\n * Creates an _accept_ function to pass to `import.meta.hot` in Vite applications.\n *\n * @example\n * ```js\n * const useUser = defineStore(...)\n * if (import.meta.hot) {\n *   import.meta.hot.accept(acceptHMRUpdate(useUser, import.meta.hot))\n * }\n * ```\n *\n * @param initialUseStore - return of the defineStore to hot update\n * @param hot - `import.meta.hot`\n */\nfunction acceptHMRUpdate(initialUseStore, hot) {\n    // strip as much as possible from iife.prod\n    if (!(process.env.NODE_ENV !== 'production')) {\n        return () => { };\n    }\n    return (newModule) => {\n        const pinia = hot.data.pinia || initialUseStore._pinia;\n        if (!pinia) {\n            // this store is still not used\n            return;\n        }\n        // preserve the pinia instance across loads\n        hot.data.pinia = pinia;\n        // console.log('got data', newStore)\n        for (const exportName in newModule) {\n            const useStore = newModule[exportName];\n            // console.log('checking for', exportName)\n            if (isUseStore(useStore) && pinia._s.has(useStore.$id)) {\n                // console.log('Accepting update for', useStore.$id)\n                const id = useStore.$id;\n                if (id !== initialUseStore.$id) {\n                    console.warn(`The id of the store changed from \"${initialUseStore.$id}\" to \"${id}\". Reloading.`);\n                    // return import.meta.hot.invalidate()\n                    return hot.invalidate();\n                }\n                const existingStore = pinia._s.get(id);\n                if (!existingStore) {\n                    console.log(`[Pinia]: skipping hmr because store doesn't exist yet`);\n                    return;\n                }\n                useStore(pinia, existingStore);\n            }\n        }\n    };\n}\n\nconst noop = () => { };\nfunction addSubscription(subscriptions, callback, detached, onCleanup = noop) {\n    subscriptions.push(callback);\n    const removeSubscription = () => {\n        const idx = subscriptions.indexOf(callback);\n        if (idx > -1) {\n            subscriptions.splice(idx, 1);\n            onCleanup();\n        }\n    };\n    if (!detached && getCurrentScope()) {\n        onScopeDispose(removeSubscription);\n    }\n    return removeSubscription;\n}\nfunction triggerSubscriptions(subscriptions, ...args) {\n    subscriptions.slice().forEach((callback) => {\n        callback(...args);\n    });\n}\n\nconst fallbackRunWithContext = (fn) => fn();\nfunction mergeReactiveObjects(target, patchToApply) {\n    // Handle Map instances\n    if (target instanceof Map && patchToApply instanceof Map) {\n        patchToApply.forEach((value, key) => target.set(key, value));\n    }\n    // Handle Set instances\n    if (target instanceof Set && patchToApply instanceof Set) {\n        patchToApply.forEach(target.add, target);\n    }\n    // no need to go through symbols because they cannot be serialized anyway\n    for (const key in patchToApply) {\n        if (!patchToApply.hasOwnProperty(key))\n            continue;\n        const subPatch = patchToApply[key];\n        const targetValue = target[key];\n        if (isPlainObject(targetValue) &&\n            isPlainObject(subPatch) &&\n            target.hasOwnProperty(key) &&\n            !isRef(subPatch) &&\n            !isReactive(subPatch)) {\n            // NOTE: here I wanted to warn about inconsistent types but it's not possible because in setup stores one might\n            // start the value of a property as a certain type e.g. a Map, and then for some reason, during SSR, change that\n            // to `undefined`. When trying to hydrate, we want to override the Map with `undefined`.\n            target[key] = mergeReactiveObjects(targetValue, subPatch);\n        }\n        else {\n            // @ts-expect-error: subPatch is a valid value\n            target[key] = subPatch;\n        }\n    }\n    return target;\n}\nconst skipHydrateSymbol = (process.env.NODE_ENV !== 'production')\n    ? Symbol('pinia:skipHydration')\n    : /* istanbul ignore next */ Symbol();\nconst skipHydrateMap = /*#__PURE__*/ new WeakMap();\n/**\n * Tells Pinia to skip the hydration process of a given object. This is useful in setup stores (only) when you return a\n * stateful object in the store but it isn't really state. e.g. returning a router instance in a setup store.\n *\n * @param obj - target object\n * @returns obj\n */\nfunction skipHydrate(obj) {\n    return isVue2\n        ? // in @vue/composition-api, the refs are sealed so defineProperty doesn't work...\n            /* istanbul ignore next */ skipHydrateMap.set(obj, 1) && obj\n        : Object.defineProperty(obj, skipHydrateSymbol, {});\n}\n/**\n * Returns whether a value should be hydrated\n *\n * @param obj - target variable\n * @returns true if `obj` should be hydrated\n */\nfunction shouldHydrate(obj) {\n    return isVue2\n        ? /* istanbul ignore next */ !skipHydrateMap.has(obj)\n        : !isPlainObject(obj) || !obj.hasOwnProperty(skipHydrateSymbol);\n}\nconst { assign } = Object;\nfunction isComputed(o) {\n    return !!(isRef(o) && o.effect);\n}\nfunction createOptionsStore(id, options, pinia, hot) {\n    const { state, actions, getters } = options;\n    const initialState = pinia.state.value[id];\n    let store;\n    function setup() {\n        if (!initialState && (!(process.env.NODE_ENV !== 'production') || !hot)) {\n            /* istanbul ignore if */\n            if (isVue2) {\n                set(pinia.state.value, id, state ? state() : {});\n            }\n            else {\n                pinia.state.value[id] = state ? state() : {};\n            }\n        }\n        // avoid creating a state in pinia.state.value\n        const localState = (process.env.NODE_ENV !== 'production') && hot\n            ? // use ref() to unwrap refs inside state TODO: check if this is still necessary\n                toRefs(ref(state ? state() : {}).value)\n            : toRefs(pinia.state.value[id]);\n        return assign(localState, actions, Object.keys(getters || {}).reduce((computedGetters, name) => {\n            if ((process.env.NODE_ENV !== 'production') && name in localState) {\n                console.warn(`[🍍]: A getter cannot have the same name as another state property. Rename one of them. Found with \"${name}\" in store \"${id}\".`);\n            }\n            computedGetters[name] = markRaw(computed(() => {\n                setActivePinia(pinia);\n                // it was created just before\n                const store = pinia._s.get(id);\n                // allow cross using stores\n                /* istanbul ignore next */\n                if (isVue2 && !store._r)\n                    return;\n                // @ts-expect-error\n                // return getters![name].call(context, context)\n                // TODO: avoid reading the getter while assigning with a global variable\n                return getters[name].call(store, store);\n            }));\n            return computedGetters;\n        }, {}));\n    }\n    store = createSetupStore(id, setup, options, pinia, hot, true);\n    return store;\n}\nfunction createSetupStore($id, setup, options = {}, pinia, hot, isOptionsStore) {\n    let scope;\n    const optionsForPlugin = assign({ actions: {} }, options);\n    /* istanbul ignore if */\n    if ((process.env.NODE_ENV !== 'production') && !pinia._e.active) {\n        throw new Error('Pinia destroyed');\n    }\n    // watcher options for $subscribe\n    const $subscribeOptions = {\n        deep: true,\n        // flush: 'post',\n    };\n    /* istanbul ignore else */\n    if ((process.env.NODE_ENV !== 'production') && !isVue2) {\n        $subscribeOptions.onTrigger = (event) => {\n            /* istanbul ignore else */\n            if (isListening) {\n                debuggerEvents = event;\n                // avoid triggering this while the store is being built and the state is being set in pinia\n            }\n            else if (isListening == false && !store._hotUpdating) {\n                // let patch send all the events together later\n                /* istanbul ignore else */\n                if (Array.isArray(debuggerEvents)) {\n                    debuggerEvents.push(event);\n                }\n                else {\n                    console.error('🍍 debuggerEvents should be an array. This is most likely an internal Pinia bug.');\n                }\n            }\n        };\n    }\n    // internal state\n    let isListening; // set to true at the end\n    let isSyncListening; // set to true at the end\n    let subscriptions = [];\n    let actionSubscriptions = [];\n    let debuggerEvents;\n    const initialState = pinia.state.value[$id];\n    // avoid setting the state for option stores if it is set\n    // by the setup\n    if (!isOptionsStore && !initialState && (!(process.env.NODE_ENV !== 'production') || !hot)) {\n        /* istanbul ignore if */\n        if (isVue2) {\n            set(pinia.state.value, $id, {});\n        }\n        else {\n            pinia.state.value[$id] = {};\n        }\n    }\n    const hotState = ref({});\n    // avoid triggering too many listeners\n    // https://github.com/vuejs/pinia/issues/1129\n    let activeListener;\n    function $patch(partialStateOrMutator) {\n        let subscriptionMutation;\n        isListening = isSyncListening = false;\n        // reset the debugger events since patches are sync\n        /* istanbul ignore else */\n        if ((process.env.NODE_ENV !== 'production')) {\n            debuggerEvents = [];\n        }\n        if (typeof partialStateOrMutator === 'function') {\n            partialStateOrMutator(pinia.state.value[$id]);\n            subscriptionMutation = {\n                type: MutationType.patchFunction,\n                storeId: $id,\n                events: debuggerEvents,\n            };\n        }\n        else {\n            mergeReactiveObjects(pinia.state.value[$id], partialStateOrMutator);\n            subscriptionMutation = {\n                type: MutationType.patchObject,\n                payload: partialStateOrMutator,\n                storeId: $id,\n                events: debuggerEvents,\n            };\n        }\n        const myListenerId = (activeListener = Symbol());\n        nextTick().then(() => {\n            if (activeListener === myListenerId) {\n                isListening = true;\n            }\n        });\n        isSyncListening = true;\n        // because we paused the watcher, we need to manually call the subscriptions\n        triggerSubscriptions(subscriptions, subscriptionMutation, pinia.state.value[$id]);\n    }\n    const $reset = isOptionsStore\n        ? function $reset() {\n            const { state } = options;\n            const newState = state ? state() : {};\n            // we use a patch to group all changes into one single subscription\n            this.$patch(($state) => {\n                assign($state, newState);\n            });\n        }\n        : /* istanbul ignore next */\n            (process.env.NODE_ENV !== 'production')\n                ? () => {\n                    throw new Error(`🍍: Store \"${$id}\" is built using the setup syntax and does not implement $reset().`);\n                }\n                : noop;\n    function $dispose() {\n        scope.stop();\n        subscriptions = [];\n        actionSubscriptions = [];\n        pinia._s.delete($id);\n    }\n    /**\n     * Wraps an action to handle subscriptions.\n     *\n     * @param name - name of the action\n     * @param action - action to wrap\n     * @returns a wrapped action to handle subscriptions\n     */\n    function wrapAction(name, action) {\n        return function () {\n            setActivePinia(pinia);\n            const args = Array.from(arguments);\n            const afterCallbackList = [];\n            const onErrorCallbackList = [];\n            function after(callback) {\n                afterCallbackList.push(callback);\n            }\n            function onError(callback) {\n                onErrorCallbackList.push(callback);\n            }\n            // @ts-expect-error\n            triggerSubscriptions(actionSubscriptions, {\n                args,\n                name,\n                store,\n                after,\n                onError,\n            });\n            let ret;\n            try {\n                ret = action.apply(this && this.$id === $id ? this : store, args);\n                // handle sync errors\n            }\n            catch (error) {\n                triggerSubscriptions(onErrorCallbackList, error);\n                throw error;\n            }\n            if (ret instanceof Promise) {\n                return ret\n                    .then((value) => {\n                    triggerSubscriptions(afterCallbackList, value);\n                    return value;\n                })\n                    .catch((error) => {\n                    triggerSubscriptions(onErrorCallbackList, error);\n                    return Promise.reject(error);\n                });\n            }\n            // trigger after callbacks\n            triggerSubscriptions(afterCallbackList, ret);\n            return ret;\n        };\n    }\n    const _hmrPayload = /*#__PURE__*/ markRaw({\n        actions: {},\n        getters: {},\n        state: [],\n        hotState,\n    });\n    const partialStore = {\n        _p: pinia,\n        // _s: scope,\n        $id,\n        $onAction: addSubscription.bind(null, actionSubscriptions),\n        $patch,\n        $reset,\n        $subscribe(callback, options = {}) {\n            const removeSubscription = addSubscription(subscriptions, callback, options.detached, () => stopWatcher());\n            const stopWatcher = scope.run(() => watch(() => pinia.state.value[$id], (state) => {\n                if (options.flush === 'sync' ? isSyncListening : isListening) {\n                    callback({\n                        storeId: $id,\n                        type: MutationType.direct,\n                        events: debuggerEvents,\n                    }, state);\n                }\n            }, assign({}, $subscribeOptions, options)));\n            return removeSubscription;\n        },\n        $dispose,\n    };\n    /* istanbul ignore if */\n    if (isVue2) {\n        // start as non ready\n        partialStore._r = false;\n    }\n    const store = reactive((process.env.NODE_ENV !== 'production') || USE_DEVTOOLS\n        ? assign({\n            _hmrPayload,\n            _customProperties: markRaw(new Set()), // devtools custom properties\n        }, partialStore\n        // must be added later\n        // setupStore\n        )\n        : partialStore);\n    // store the partial store now so the setup of stores can instantiate each other before they are finished without\n    // creating infinite loops.\n    pinia._s.set($id, store);\n    const runWithContext = (pinia._a && pinia._a.runWithContext) || fallbackRunWithContext;\n    // TODO: idea create skipSerialize that marks properties as non serializable and they are skipped\n    const setupStore = runWithContext(() => pinia._e.run(() => (scope = effectScope()).run(setup)));\n    // overwrite existing actions to support $onAction\n    for (const key in setupStore) {\n        const prop = setupStore[key];\n        if ((isRef(prop) && !isComputed(prop)) || isReactive(prop)) {\n            // mark it as a piece of state to be serialized\n            if ((process.env.NODE_ENV !== 'production') && hot) {\n                set(hotState.value, key, toRef(setupStore, key));\n                // createOptionStore directly sets the state in pinia.state.value so we\n                // can just skip that\n            }\n            else if (!isOptionsStore) {\n                // in setup stores we must hydrate the state and sync pinia state tree with the refs the user just created\n                if (initialState && shouldHydrate(prop)) {\n                    if (isRef(prop)) {\n                        prop.value = initialState[key];\n                    }\n                    else {\n                        // probably a reactive object, lets recursively assign\n                        // @ts-expect-error: prop is unknown\n                        mergeReactiveObjects(prop, initialState[key]);\n                    }\n                }\n                // transfer the ref to the pinia state to keep everything in sync\n                /* istanbul ignore if */\n                if (isVue2) {\n                    set(pinia.state.value[$id], key, prop);\n                }\n                else {\n                    pinia.state.value[$id][key] = prop;\n                }\n            }\n            /* istanbul ignore else */\n            if ((process.env.NODE_ENV !== 'production')) {\n                _hmrPayload.state.push(key);\n            }\n            // action\n        }\n        else if (typeof prop === 'function') {\n            // @ts-expect-error: we are overriding the function we avoid wrapping if\n            const actionValue = (process.env.NODE_ENV !== 'production') && hot ? prop : wrapAction(key, prop);\n            // this a hot module replacement store because the hotUpdate method needs\n            // to do it with the right context\n            /* istanbul ignore if */\n            if (isVue2) {\n                set(setupStore, key, actionValue);\n            }\n            else {\n                // @ts-expect-error\n                setupStore[key] = actionValue;\n            }\n            /* istanbul ignore else */\n            if ((process.env.NODE_ENV !== 'production')) {\n                _hmrPayload.actions[key] = prop;\n            }\n            // list actions so they can be used in plugins\n            // @ts-expect-error\n            optionsForPlugin.actions[key] = prop;\n        }\n        else if ((process.env.NODE_ENV !== 'production')) {\n            // add getters for devtools\n            if (isComputed(prop)) {\n                _hmrPayload.getters[key] = isOptionsStore\n                    ? // @ts-expect-error\n                        options.getters[key]\n                    : prop;\n                if (IS_CLIENT) {\n                    const getters = setupStore._getters ||\n                        // @ts-expect-error: same\n                        (setupStore._getters = markRaw([]));\n                    getters.push(key);\n                }\n            }\n        }\n    }\n    // add the state, getters, and action properties\n    /* istanbul ignore if */\n    if (isVue2) {\n        Object.keys(setupStore).forEach((key) => {\n            set(store, key, setupStore[key]);\n        });\n    }\n    else {\n        assign(store, setupStore);\n        // allows retrieving reactive objects with `storeToRefs()`. Must be called after assigning to the reactive object.\n        // Make `storeToRefs()` work with `reactive()` #799\n        assign(toRaw(store), setupStore);\n    }\n    // use this instead of a computed with setter to be able to create it anywhere\n    // without linking the computed lifespan to wherever the store is first\n    // created.\n    Object.defineProperty(store, '$state', {\n        get: () => ((process.env.NODE_ENV !== 'production') && hot ? hotState.value : pinia.state.value[$id]),\n        set: (state) => {\n            /* istanbul ignore if */\n            if ((process.env.NODE_ENV !== 'production') && hot) {\n                throw new Error('cannot set hotState');\n            }\n            $patch(($state) => {\n                assign($state, state);\n            });\n        },\n    });\n    // add the hotUpdate before plugins to allow them to override it\n    /* istanbul ignore else */\n    if ((process.env.NODE_ENV !== 'production')) {\n        store._hotUpdate = markRaw((newStore) => {\n            store._hotUpdating = true;\n            newStore._hmrPayload.state.forEach((stateKey) => {\n                if (stateKey in store.$state) {\n                    const newStateTarget = newStore.$state[stateKey];\n                    const oldStateSource = store.$state[stateKey];\n                    if (typeof newStateTarget === 'object' &&\n                        isPlainObject(newStateTarget) &&\n                        isPlainObject(oldStateSource)) {\n                        patchObject(newStateTarget, oldStateSource);\n                    }\n                    else {\n                        // transfer the ref\n                        newStore.$state[stateKey] = oldStateSource;\n                    }\n                }\n                // patch direct access properties to allow store.stateProperty to work as\n                // store.$state.stateProperty\n                set(store, stateKey, toRef(newStore.$state, stateKey));\n            });\n            // remove deleted state properties\n            Object.keys(store.$state).forEach((stateKey) => {\n                if (!(stateKey in newStore.$state)) {\n                    del(store, stateKey);\n                }\n            });\n            // avoid devtools logging this as a mutation\n            isListening = false;\n            isSyncListening = false;\n            pinia.state.value[$id] = toRef(newStore._hmrPayload, 'hotState');\n            isSyncListening = true;\n            nextTick().then(() => {\n                isListening = true;\n            });\n            for (const actionName in newStore._hmrPayload.actions) {\n                const action = newStore[actionName];\n                set(store, actionName, wrapAction(actionName, action));\n            }\n            // TODO: does this work in both setup and option store?\n            for (const getterName in newStore._hmrPayload.getters) {\n                const getter = newStore._hmrPayload.getters[getterName];\n                const getterValue = isOptionsStore\n                    ? // special handling of options api\n                        computed(() => {\n                            setActivePinia(pinia);\n                            return getter.call(store, store);\n                        })\n                    : getter;\n                set(store, getterName, getterValue);\n            }\n            // remove deleted getters\n            Object.keys(store._hmrPayload.getters).forEach((key) => {\n                if (!(key in newStore._hmrPayload.getters)) {\n                    del(store, key);\n                }\n            });\n            // remove old actions\n            Object.keys(store._hmrPayload.actions).forEach((key) => {\n                if (!(key in newStore._hmrPayload.actions)) {\n                    del(store, key);\n                }\n            });\n            // update the values used in devtools and to allow deleting new properties later on\n            store._hmrPayload = newStore._hmrPayload;\n            store._getters = newStore._getters;\n            store._hotUpdating = false;\n        });\n    }\n    if (USE_DEVTOOLS) {\n        const nonEnumerable = {\n            writable: true,\n            configurable: true,\n            // avoid warning on devtools trying to display this property\n            enumerable: false,\n        };\n        ['_p', '_hmrPayload', '_getters', '_customProperties'].forEach((p) => {\n            Object.defineProperty(store, p, assign({ value: store[p] }, nonEnumerable));\n        });\n    }\n    /* istanbul ignore if */\n    if (isVue2) {\n        // mark the store as ready before plugins\n        store._r = true;\n    }\n    // apply all plugins\n    pinia._p.forEach((extender) => {\n        /* istanbul ignore else */\n        if (USE_DEVTOOLS) {\n            const extensions = scope.run(() => extender({\n                store,\n                app: pinia._a,\n                pinia,\n                options: optionsForPlugin,\n            }));\n            Object.keys(extensions || {}).forEach((key) => store._customProperties.add(key));\n            assign(store, extensions);\n        }\n        else {\n            assign(store, scope.run(() => extender({\n                store,\n                app: pinia._a,\n                pinia,\n                options: optionsForPlugin,\n            })));\n        }\n    });\n    if ((process.env.NODE_ENV !== 'production') &&\n        store.$state &&\n        typeof store.$state === 'object' &&\n        typeof store.$state.constructor === 'function' &&\n        !store.$state.constructor.toString().includes('[native code]')) {\n        console.warn(`[🍍]: The \"state\" must be a plain object. It cannot be\\n` +\n            `\\tstate: () => new MyClass()\\n` +\n            `Found in store \"${store.$id}\".`);\n    }\n    // only apply hydrate to option stores with an initial state in pinia\n    if (initialState &&\n        isOptionsStore &&\n        options.hydrate) {\n        options.hydrate(store.$state, initialState);\n    }\n    isListening = true;\n    isSyncListening = true;\n    return store;\n}\nfunction defineStore(\n// TODO: add proper types from above\nidOrOptions, setup, setupOptions) {\n    let id;\n    let options;\n    const isSetupStore = typeof setup === 'function';\n    if (typeof idOrOptions === 'string') {\n        id = idOrOptions;\n        // the option store setup will contain the actual options in this case\n        options = isSetupStore ? setupOptions : setup;\n    }\n    else {\n        options = idOrOptions;\n        id = idOrOptions.id;\n        if ((process.env.NODE_ENV !== 'production') && typeof id !== 'string') {\n            throw new Error(`[🍍]: \"defineStore()\" must be passed a store id as its first argument.`);\n        }\n    }\n    function useStore(pinia, hot) {\n        const hasContext = hasInjectionContext();\n        pinia =\n            // in test mode, ignore the argument provided as we can always retrieve a\n            // pinia instance with getActivePinia()\n            ((process.env.NODE_ENV === 'test') && activePinia && activePinia._testing ? null : pinia) ||\n                (hasContext ? inject(piniaSymbol, null) : null);\n        if (pinia)\n            setActivePinia(pinia);\n        if ((process.env.NODE_ENV !== 'production') && !activePinia) {\n            throw new Error(`[🍍]: \"getActivePinia()\" was called but there was no active Pinia. Are you trying to use a store before calling \"app.use(pinia)\"?\\n` +\n                `See https://pinia.vuejs.org/core-concepts/outside-component-usage.html for help.\\n` +\n                `This will fail in production.`);\n        }\n        pinia = activePinia;\n        if (!pinia._s.has(id)) {\n            // creating the store registers it in `pinia._s`\n            if (isSetupStore) {\n                createSetupStore(id, setup, options, pinia);\n            }\n            else {\n                createOptionsStore(id, options, pinia);\n            }\n            /* istanbul ignore else */\n            if ((process.env.NODE_ENV !== 'production')) {\n                // @ts-expect-error: not the right inferred type\n                useStore._pinia = pinia;\n            }\n        }\n        const store = pinia._s.get(id);\n        if ((process.env.NODE_ENV !== 'production') && hot) {\n            const hotId = '__hot:' + id;\n            const newStore = isSetupStore\n                ? createSetupStore(hotId, setup, options, pinia, true)\n                : createOptionsStore(hotId, assign({}, options), pinia, true);\n            hot._hotUpdate(newStore);\n            // cleanup the state properties and the store from the cache\n            delete pinia.state.value[hotId];\n            pinia._s.delete(hotId);\n        }\n        if ((process.env.NODE_ENV !== 'production') && IS_CLIENT) {\n            const currentInstance = getCurrentInstance();\n            // save stores in instances to access them devtools\n            if (currentInstance &&\n                currentInstance.proxy &&\n                // avoid adding stores that are just built for hot module replacement\n                !hot) {\n                const vm = currentInstance.proxy;\n                const cache = '_pStores' in vm ? vm._pStores : (vm._pStores = {});\n                cache[id] = store;\n            }\n        }\n        // StoreGeneric cannot be casted towards Store\n        return store;\n    }\n    useStore.$id = id;\n    return useStore;\n}\n\nlet mapStoreSuffix = 'Store';\n/**\n * Changes the suffix added by `mapStores()`. Can be set to an empty string.\n * Defaults to `\"Store\"`. Make sure to extend the MapStoresCustomization\n * interface if you are using TypeScript.\n *\n * @param suffix - new suffix\n */\nfunction setMapStoreSuffix(suffix // could be 'Store' but that would be annoying for JS\n) {\n    mapStoreSuffix = suffix;\n}\n/**\n * Allows using stores without the composition API (`setup()`) by generating an\n * object to be spread in the `computed` field of a component. It accepts a list\n * of store definitions.\n *\n * @example\n * ```js\n * export default {\n *   computed: {\n *     // other computed properties\n *     ...mapStores(useUserStore, useCartStore)\n *   },\n *\n *   created() {\n *     this.userStore // store with id \"user\"\n *     this.cartStore // store with id \"cart\"\n *   }\n * }\n * ```\n *\n * @param stores - list of stores to map to an object\n */\nfunction mapStores(...stores) {\n    if ((process.env.NODE_ENV !== 'production') && Array.isArray(stores[0])) {\n        console.warn(`[🍍]: Directly pass all stores to \"mapStores()\" without putting them in an array:\\n` +\n            `Replace\\n` +\n            `\\tmapStores([useAuthStore, useCartStore])\\n` +\n            `with\\n` +\n            `\\tmapStores(useAuthStore, useCartStore)\\n` +\n            `This will fail in production if not fixed.`);\n        stores = stores[0];\n    }\n    return stores.reduce((reduced, useStore) => {\n        // @ts-expect-error: $id is added by defineStore\n        reduced[useStore.$id + mapStoreSuffix] = function () {\n            return useStore(this.$pinia);\n        };\n        return reduced;\n    }, {});\n}\n/**\n * Allows using state and getters from one store without using the composition\n * API (`setup()`) by generating an object to be spread in the `computed` field\n * of a component.\n *\n * @param useStore - store to map from\n * @param keysOrMapper - array or object\n */\nfunction mapState(useStore, keysOrMapper) {\n    return Array.isArray(keysOrMapper)\n        ? keysOrMapper.reduce((reduced, key) => {\n            reduced[key] = function () {\n                return useStore(this.$pinia)[key];\n            };\n            return reduced;\n        }, {})\n        : Object.keys(keysOrMapper).reduce((reduced, key) => {\n            // @ts-expect-error\n            reduced[key] = function () {\n                const store = useStore(this.$pinia);\n                const storeKey = keysOrMapper[key];\n                // for some reason TS is unable to infer the type of storeKey to be a\n                // function\n                return typeof storeKey === 'function'\n                    ? storeKey.call(this, store)\n                    : store[storeKey];\n            };\n            return reduced;\n        }, {});\n}\n/**\n * Alias for `mapState()`. You should use `mapState()` instead.\n * @deprecated use `mapState()` instead.\n */\nconst mapGetters = mapState;\n/**\n * Allows directly using actions from your store without using the composition\n * API (`setup()`) by generating an object to be spread in the `methods` field\n * of a component.\n *\n * @param useStore - store to map from\n * @param keysOrMapper - array or object\n */\nfunction mapActions(useStore, keysOrMapper) {\n    return Array.isArray(keysOrMapper)\n        ? keysOrMapper.reduce((reduced, key) => {\n            // @ts-expect-error\n            reduced[key] = function (...args) {\n                return useStore(this.$pinia)[key](...args);\n            };\n            return reduced;\n        }, {})\n        : Object.keys(keysOrMapper).reduce((reduced, key) => {\n            // @ts-expect-error\n            reduced[key] = function (...args) {\n                return useStore(this.$pinia)[keysOrMapper[key]](...args);\n            };\n            return reduced;\n        }, {});\n}\n/**\n * Allows using state and getters from one store without using the composition\n * API (`setup()`) by generating an object to be spread in the `computed` field\n * of a component.\n *\n * @param useStore - store to map from\n * @param keysOrMapper - array or object\n */\nfunction mapWritableState(useStore, keysOrMapper) {\n    return Array.isArray(keysOrMapper)\n        ? keysOrMapper.reduce((reduced, key) => {\n            // @ts-ignore\n            reduced[key] = {\n                get() {\n                    return useStore(this.$pinia)[key];\n                },\n                set(value) {\n                    // it's easier to type it here as any\n                    return (useStore(this.$pinia)[key] = value);\n                },\n            };\n            return reduced;\n        }, {})\n        : Object.keys(keysOrMapper).reduce((reduced, key) => {\n            // @ts-ignore\n            reduced[key] = {\n                get() {\n                    return useStore(this.$pinia)[keysOrMapper[key]];\n                },\n                set(value) {\n                    // it's easier to type it here as any\n                    return (useStore(this.$pinia)[keysOrMapper[key]] = value);\n                },\n            };\n            return reduced;\n        }, {});\n}\n\n/**\n * Creates an object of references with all the state, getters, and plugin-added\n * state properties of the store. Similar to `toRefs()` but specifically\n * designed for Pinia stores so methods and non reactive properties are\n * completely ignored.\n *\n * @param store - store to extract the refs from\n */\nfunction storeToRefs(store) {\n    // See https://github.com/vuejs/pinia/issues/852\n    // It's easier to just use toRefs() even if it includes more stuff\n    if (isVue2) {\n        // @ts-expect-error: toRefs include methods and others\n        return toRefs(store);\n    }\n    else {\n        store = toRaw(store);\n        const refs = {};\n        for (const key in store) {\n            const value = store[key];\n            if (isRef(value) || isReactive(value)) {\n                // @ts-expect-error: the key is state or getter\n                refs[key] =\n                    // ---\n                    toRef(store, key);\n            }\n        }\n        return refs;\n    }\n}\n\n/**\n * Vue 2 Plugin that must be installed for pinia to work. Note **you don't need\n * this plugin if you are using Nuxt.js**. Use the `buildModule` instead:\n * https://pinia.vuejs.org/ssr/nuxt.html.\n *\n * @example\n * ```js\n * import Vue from 'vue'\n * import { PiniaVuePlugin, createPinia } from 'pinia'\n *\n * Vue.use(PiniaVuePlugin)\n * const pinia = createPinia()\n *\n * new Vue({\n *   el: '#app',\n *   // ...\n *   pinia,\n * })\n * ```\n *\n * @param _Vue - `Vue` imported from 'vue'.\n */\nconst PiniaVuePlugin = function (_Vue) {\n    // Equivalent of\n    // app.config.globalProperties.$pinia = pinia\n    _Vue.mixin({\n        beforeCreate() {\n            const options = this.$options;\n            if (options.pinia) {\n                const pinia = options.pinia;\n                // HACK: taken from provide(): https://github.com/vuejs/composition-api/blob/main/src/apis/inject.ts#L31\n                /* istanbul ignore else */\n                if (!this._provided) {\n                    const provideCache = {};\n                    Object.defineProperty(this, '_provided', {\n                        get: () => provideCache,\n                        set: (v) => Object.assign(provideCache, v),\n                    });\n                }\n                this._provided[piniaSymbol] = pinia;\n                // propagate the pinia instance in an SSR friendly way\n                // avoid adding it to nuxt twice\n                /* istanbul ignore else */\n                if (!this.$pinia) {\n                    this.$pinia = pinia;\n                }\n                pinia._a = this;\n                if (IS_CLIENT) {\n                    // this allows calling useStore() outside of a component setup after\n                    // installing pinia's plugin\n                    setActivePinia(pinia);\n                }\n                if (USE_DEVTOOLS) {\n                    registerPiniaDevtools(pinia._a, pinia);\n                }\n            }\n            else if (!this.$pinia && options.parent && options.parent.$pinia) {\n                this.$pinia = options.parent.$pinia;\n            }\n        },\n        destroyed() {\n            delete this._pStores;\n        },\n    });\n};\n\nexport { MutationType, PiniaVuePlugin, acceptHMRUpdate, createPinia, defineStore, getActivePinia, mapActions, mapGetters, mapState, mapStores, mapWritableState, setActivePinia, setMapStoreSuffix, skipHydrate, storeToRefs };\n","import { HOOK_PLUGIN_SETTINGS_SET } from './const.js';\nimport { now } from './time.js';\nexport class ApiProxy {\n    constructor(plugin, hook) {\n        this.target = null;\n        this.targetQueue = [];\n        this.onQueue = [];\n        this.plugin = plugin;\n        this.hook = hook;\n        const defaultSettings = {};\n        if (plugin.settings) {\n            for (const id in plugin.settings) {\n                const item = plugin.settings[id];\n                defaultSettings[id] = item.defaultValue;\n            }\n        }\n        const localSettingsSaveId = `__vue-devtools-plugin-settings__${plugin.id}`;\n        let currentSettings = Object.assign({}, defaultSettings);\n        try {\n            const raw = localStorage.getItem(localSettingsSaveId);\n            const data = JSON.parse(raw);\n            Object.assign(currentSettings, data);\n        }\n        catch (e) {\n            // noop\n        }\n        this.fallbacks = {\n            getSettings() {\n                return currentSettings;\n            },\n            setSettings(value) {\n                try {\n                    localStorage.setItem(localSettingsSaveId, JSON.stringify(value));\n                }\n                catch (e) {\n                    // noop\n                }\n                currentSettings = value;\n            },\n            now() {\n                return now();\n            },\n        };\n        if (hook) {\n            hook.on(HOOK_PLUGIN_SETTINGS_SET, (pluginId, value) => {\n                if (pluginId === this.plugin.id) {\n                    this.fallbacks.setSettings(value);\n                }\n            });\n        }\n        this.proxiedOn = new Proxy({}, {\n            get: (_target, prop) => {\n                if (this.target) {\n                    return this.target.on[prop];\n                }\n                else {\n                    return (...args) => {\n                        this.onQueue.push({\n                            method: prop,\n                            args,\n                        });\n                    };\n                }\n            },\n        });\n        this.proxiedTarget = new Proxy({}, {\n            get: (_target, prop) => {\n                if (this.target) {\n                    return this.target[prop];\n                }\n                else if (prop === 'on') {\n                    return this.proxiedOn;\n                }\n                else if (Object.keys(this.fallbacks).includes(prop)) {\n                    return (...args) => {\n                        this.targetQueue.push({\n                            method: prop,\n                            args,\n                            resolve: () => { },\n                        });\n                        return this.fallbacks[prop](...args);\n                    };\n                }\n                else {\n                    return (...args) => {\n                        return new Promise((resolve) => {\n                            this.targetQueue.push({\n                                method: prop,\n                                args,\n                                resolve,\n                            });\n                        });\n                    };\n                }\n            },\n        });\n    }\n    async setRealTarget(target) {\n        this.target = target;\n        for (const item of this.onQueue) {\n            this.target.on[item.method](...item.args);\n        }\n        for (const item of this.targetQueue) {\n            item.resolve(await this.target[item.method](...item.args));\n        }\n    }\n}\n","import { getDevtoolsGlobalHook, getTarget, isProxyAvailable } from './env.js';\nimport { HOOK_SETUP } from './const.js';\nimport { ApiProxy } from './proxy.js';\nexport * from './api/index.js';\nexport * from './plugin.js';\nexport * from './time.js';\nexport function setupDevtoolsPlugin(pluginDescriptor, setupFn) {\n    const descriptor = pluginDescriptor;\n    const target = getTarget();\n    const hook = getDevtoolsGlobalHook();\n    const enableProxy = isProxyAvailable && descriptor.enableEarlyProxy;\n    if (hook && (target.__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__ || !enableProxy)) {\n        hook.emit(HOOK_SETUP, pluginDescriptor, setupFn);\n    }\n    else {\n        const proxy = enableProxy ? new ApiProxy(descriptor, hook) : null;\n        const list = target.__VUE_DEVTOOLS_PLUGINS__ = target.__VUE_DEVTOOLS_PLUGINS__ || [];\n        list.push({\n            pluginDescriptor: descriptor,\n            setupFn,\n            proxy,\n        });\n        if (proxy) {\n            setupFn(proxy.proxiedTarget);\n        }\n    }\n}\n"],"names":["target","key","val","Array","isArray","length","Math","max","splice","getTarget","navigator","window","globalThis","isProxyAvailable","Proxy","HOOK_SETUP","supported","perf","activePinia","now","undefined","performance","_a","perf_hooks","Date","ApiProxy","constructor","plugin","hook","_this","this","targetQueue","onQueue","defaultSettings","settings","id","item","defaultValue","localSettingsSaveId","currentSettings","Object","assign","raw","localStorage","getItem","data","JSON","parse","e","fallbacks","getSettings","setSettings","value","setItem","stringify","on","pluginId","proxiedOn","get","_target","prop","_len","arguments","args","_key","push","method","proxiedTarget","keys","includes","_len2","_key2","resolve","_len3","_key3","Promise","setRealTarget","setupDevtoolsPlugin","pluginDescriptor","setupFn","descriptor","__VUE_DEVTOOLS_GLOBAL_HOOK__","enableProxy","enableEarlyProxy","__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__","proxy","__VUE_DEVTOOLS_PLUGINS__","emit","setActivePinia","pinia","getActivePinia","hasInjectionContext","inject","piniaSymbol","Symbol","isPlainObject","o","prototype","toString","call","toJSON","MutationType","IS_CLIENT","USE_DEVTOOLS","_global","self","global","HTMLElement","download","url","name","opts","xhr","XMLHttpRequest","open","responseType","onload","saveAs","response","onerror","console","error","send","corsEnabled","status","click","node","dispatchEvent","MouseEvent","evt","document","createEvent","initMouseEvent","_navigator","userAgent","isMacOSWebView","test","HTMLAnchorElement","blob","a","createElement","rel","href","origin","location","URL","createObjectURL","setTimeout","revokeObjectURL","msSaveOrOpenBlob","autoBom","type","Blob","String","fromCharCode","bom","popup","title","body","innerText","force","isSafari","isChromeIOS","FileReader","reader","onloadend","result","Error","replace","readAsDataURL","toastMessage","message","piniaMessage","__VUE_DEVTOOLS_TOAST__","warn","log","isPinia","checkClipboardAccess","checkNotFocusedError","toLowerCase","fileInput","async","actionGlobalOpenStateFile","accept","reject","onchange","files","file","text","oncancel","loadStoresState","state","storeState","formatDisplay","display","_custom","PINIA_ROOT_LABEL","PINIA_ROOT_ID","formatStoreForInspectorTree","store","label","$id","formatEventData","events","reduce","event","operations","oldValue","newValue","operation","formatMutationType","direct","patchFunction","patchObject","isTimelineActive","componentStateTypes","MUTATIONS_LAYER_ID","INSPECTOR_ID","assign$1","getStoreType","registerPiniaDevtools","app","logo","packageName","homepage","api","addTimelineLayer","color","addInspector","icon","treeFilterPlaceholder","actions","action","clipboard","writeText","actionGlobalCopyState","tooltip","readText","actionGlobalPasteState","sendInspectorTree","sendInspectorState","actionGlobalSaveState","nodeActions","nodeId","_s","$reset","inspectComponent","payload","ctx","componentInstance","_pStores","piniaStores","values","forEach","instanceData","editable","_isOptionsAPI","toRaw","$state","_getters","getters","getInspectorTree","inspectorId","stores","concat","from","rootNodes","filter","map","getInspectorState","inspectedStore","storeNames","storeMap","storeId","getterName","_customProperties","size","customProperties","formatStoreForInspectorState","editInspectorState","path","unshift","has","set","editComponentState","startsWith","activeAction","runningActionId","patchActionForGrouping","actionNames","wrapWithProxy","storeActions","actionName","_actionId","trackedStore","Reflect","retValue","apply","devtoolsPlugin","options","originalHotUpdate","_hotUpdate","newStore","_hmrPayload","logStoreChanges","bind","$onAction","after","onError","groupId","addTimelineEvent","layerId","time","subtitle","logType","watch","unref","notifyComponentUpdate","deep","$subscribe","eventData","detached","flush","hotUpdate","markRaw","info","$dispose","addStoreToDevtools","createPinia","scope","effectScope","run","ref","_p","toBeInstalled","install","provide","config","globalProperties","$pinia","use","_e","Map","acceptHMRUpdate","initialUseStore","hot","noop","addSubscription","subscriptions","callback","onCleanup","removeSubscription","idx","indexOf","getCurrentScope","onScopeDispose","triggerSubscriptions","slice","fallbackRunWithContext","fn","mergeReactiveObjects","patchToApply","Set","add","hasOwnProperty","subPatch","targetValue","isRef","isReactive","skipHydrateSymbol","skipHydrateMap","WeakMap","skipHydrate","obj","defineProperty","createSetupStore","setup","isOptionsStore","optionsForPlugin","$subscribeOptions","isListening","isSyncListening","debuggerEvents","actionSubscriptions","initialState","hotState","activeListener","$patch","partialStateOrMutator","subscriptionMutation","myListenerId","nextTick","then","newState","wrapAction","afterCallbackList","onErrorCallbackList","ret","catch","partialStore","stopWatcher","stop","delete","_r","reactive","setupStore","runWithContext","effect","actionValue","nonEnumerable","writable","configurable","enumerable","p","extender","extensions","hydrate","defineStore","idOrOptions","setupOptions","isSetupStore","useStore","hasContext","localState","toRefs","computedGetters","computed","createOptionsStore","mapStoreSuffix","setMapStoreSuffix","suffix","mapStores","reduced","mapState","keysOrMapper","storeKey","mapGetters","mapActions","mapWritableState","storeToRefs","refs","toRef","PiniaVuePlugin","_Vue","mixin","beforeCreate","$options","_provided","provideCache","v","parent","destroyed"],"sourceRoot":""}