{"version":3,"file":"webpack.vendors-7436985f.0755679dbae8622919e3.js","mappings":"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QAAS,QACVyC,SAAQ,SAAUzC,GAClB,OAAO2B,EAAUU,gBAAgBrC,EAAK,GAAIA,EAAK,GACjD,IAKA,CAEE,YACA,SACA,SACA,MACA,WACA,UACA,OACA,YACA,QACA,YACA,QACA,QACA,QACA,QACA,UACA,SACA,OACA,OACA,UACA,QACA,WACA,MACA,WACA,cACA,QACA,SACA,WACA,YACA,MACA,SACA,YACA,YACA,YACA,WACA,WACA,MACA,UACA,UACA,WACA,WACA,eACA,SACA,SACA,YACA,WACA,YACA,cACA,QACA,UACA,QACA,SACA,aACA,YACA,WACA,OACA,QACA,OACA,QACA,QACA,MACA,QACA,OACA,OACA,YACA,OACA,WACA,SACA,SACA,YACA,WACA,OACA,WACA,OACA,SACA,WACA,SACA,SACA,WACA,SACA,WACA,UACA,QACA,QACA,SACA,UACA,iBACA,QACA,OACA,SACA,UACA,UACA,aACA,WACA,MACA,eAEA,gBACA,SACA,SACA,YACA,WACA,QACA,WACAyC,QAAQd,EAAUW,oBAEbX,CACT,CAhfqBA,gCCFrB,SAASe,EAAiBC,EAASC,GAHnC,IAAkBC,EAKhB,OADAF,EAHoB,iBADJE,EAIGF,IAHmB,OAANE,EAGFF,EAA0BG,OAAOC,OAAO,MAC/D,IAAIC,MAAML,EAAS,CACxBM,IAAG,CAACC,EAAQC,EAAKC,IACH,QAARD,EACKE,QAAQJ,IAAIC,EAAQC,EAAKC,GAC3BC,QAAQJ,IAAIC,EAAQC,EAAKC,IAAaC,QAAQJ,IAAIL,EAAgBO,EAAKC,IAGpF,CAwBA,SAASE,EAAaC,GAAO,QAAEC,EAAO,WAAEC,EAAU,IAAEN,EAAG,MAAEO,IACvD,IACE,MAAMC,EAAyB,MAAXH,OAAkB,EAASA,EAAQI,QAAQT,GAC3DQ,GACFJ,EAAMM,OAAqB,MAAdJ,OAAqB,EAASA,EAAWK,YAAYH,GACtE,CAAE,MAAOI,GACHL,GACFM,QAAQD,MAAMA,EAClB,CACF,CACA,SAASE,EAAaC,GAAO,QAAEV,EAAO,WAAEC,EAAU,IAAEN,EAAG,MAAEgB,EAAK,MAAET,IAC9D,I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","sources":["webpack://thoughtleaderscentral/./node_modules/pluralize/pluralize.js","webpack://thoughtleaderscentral/./node_modules/pinia-plugin-persistedstate/dist/index.mjs","webpack://thoughtleaderscentral/./node_modules/pinia/node_modules/vue-demi/lib/index.mjs","webpack://thoughtleaderscentral/./node_modules/pinia/dist/pinia.mjs"],"sourcesContent":["/* global define */\n\n(function (root, pluralize) {\n  /* istanbul ignore else */\n  if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') {\n    // Node.\n    module.exports = pluralize();\n  } else if (typeof define === 'function' && define.amd) {\n    // AMD, registers as an anonymous module.\n    define(function () {\n      return pluralize();\n    });\n  } else {\n    // Browser global.\n    root.pluralize = pluralize();\n  }\n})(this, function () {\n  // Rule storage - pluralize and singularize need to be run sequentially,\n  // while other rules can be optimized using an object for instant lookups.\n  var pluralRules = [];\n  var singularRules = [];\n  var uncountables = {};\n  var irregularPlurals = {};\n  var irregularSingles = {};\n\n  /**\n   * Sanitize a pluralization rule to a usable regular expression.\n   *\n   * @param  {(RegExp|string)} rule\n   * @return {RegExp}\n   */\n  function sanitizeRule (rule) {\n    if (typeof rule === 'string') {\n      return new RegExp('^' + rule + '$', 'i');\n    }\n\n    return rule;\n  }\n\n  /**\n   * Pass in a word token to produce a function that can replicate the case on\n   * another word.\n   *\n   * @param  {string}   word\n   * @param  {string}   token\n   * @return {Function}\n   */\n  function restoreCase (word, token) {\n    // Tokens are an exact match.\n    if (word === token) return token;\n\n    // Lower cased words. E.g. \"hello\".\n    if (word === word.toLowerCase()) return token.toLowerCase();\n\n    // Upper cased words. E.g. \"WHISKY\".\n    if (word === word.toUpperCase()) return token.toUpperCase();\n\n    // Title cased words. E.g. \"Title\".\n    if (word[0] === word[0].toUpperCase()) {\n      return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();\n    }\n\n    // Lower cased words. E.g. \"test\".\n    return token.toLowerCase();\n  }\n\n  /**\n   * Interpolate a regexp string.\n   *\n   * @param  {string} str\n   * @param  {Array}  args\n   * @return {string}\n   */\n  function interpolate (str, args) {\n    return str.replace(/\\$(\\d{1,2})/g, function (match, index) {\n      return args[index] || '';\n    });\n  }\n\n  /**\n   * Replace a word using a rule.\n   *\n   * @param  {string} word\n   * @param  {Array}  rule\n   * @return {string}\n   */\n  function replace (word, rule) {\n    return word.replace(rule[0], function (match, index) {\n      var result = interpolate(rule[1], arguments);\n\n      if (match === '') {\n        return restoreCase(word[index - 1], result);\n      }\n\n      return restoreCase(match, result);\n    });\n  }\n\n  /**\n   * Sanitize a word by passing in the word and sanitization rules.\n   *\n   * @param  {string}   token\n   * @param  {string}   word\n   * @param  {Array}    rules\n   * @return {string}\n   */\n  function sanitizeWord (token, word, rules) {\n    // Empty string or doesn't need fixing.\n    if (!token.length || uncountables.hasOwnProperty(token)) {\n      return word;\n    }\n\n    var len = rules.length;\n\n    // Iterate over the sanitization rules and use the first one to match.\n    while (len--) {\n      var rule = rules[len];\n\n      if (rule[0].test(word)) return replace(word, rule);\n    }\n\n    return word;\n  }\n\n  /**\n   * Replace a word with the updated word.\n   *\n   * @param  {Object}   replaceMap\n   * @param  {Object}   keepMap\n   * @param  {Array}    rules\n   * @return {Function}\n   */\n  function replaceWord (replaceMap, keepMap, rules) {\n    return function (word) {\n      // Get the correct token and case restoration functions.\n      var token = word.toLowerCase();\n\n      // Check against the keep object map.\n      if (keepMap.hasOwnProperty(token)) {\n        return restoreCase(word, token);\n      }\n\n      // Check against the replacement map for a direct word replacement.\n      if (replaceMap.hasOwnProperty(token)) {\n        return restoreCase(word, replaceMap[token]);\n      }\n\n      // Run all the rules against the word.\n      return sanitizeWord(token, word, rules);\n    };\n  }\n\n  /**\n   * Check if a word is part of the map.\n   */\n  function checkWord (replaceMap, keepMap, rules, bool) {\n    return function (word) {\n      var token = word.toLowerCase();\n\n      if (keepMap.hasOwnProperty(token)) return true;\n      if (replaceMap.hasOwnProperty(token)) return false;\n\n      return sanitizeWord(token, token, rules) === token;\n    };\n  }\n\n  /**\n   * Pluralize or singularize a word based on the passed in count.\n   *\n   * @param  {string}  word      The word to pluralize\n   * @param  {number}  count     How many of the word exist\n   * @param  {boolean} inclusive Whether to prefix with the number (e.g. 3 ducks)\n   * @return {string}\n   */\n  function pluralize (word, count, inclusive) {\n    var pluralized = count === 1\n      ? pluralize.singular(word) : pluralize.plural(word);\n\n    return (inclusive ? count + ' ' : '') + pluralized;\n  }\n\n  /**\n   * Pluralize a word.\n   *\n   * @type {Function}\n   */\n  pluralize.plural = replaceWord(\n    irregularSingles, irregularPlurals, pluralRules\n  );\n\n  /**\n   * Check if a word is plural.\n   *\n   * @type {Function}\n   */\n  pluralize.isPlural = checkWord(\n    irregularSingles, irregularPlurals, pluralRules\n  );\n\n  /**\n   * Singularize a word.\n   *\n   * @type {Function}\n   */\n  pluralize.singular = replaceWord(\n    irregularPlurals, irregularSingles, singularRules\n  );\n\n  /**\n   * Check if a word is singular.\n   *\n   * @type {Function}\n   */\n  pluralize.isSingular = checkWord(\n    irregularPlurals, irregularSingles, singularRules\n  );\n\n  /**\n   * Add a pluralization rule to the collection.\n   *\n   * @param {(string|RegExp)} rule\n   * @param {string}          replacement\n   */\n  pluralize.addPluralRule = function (rule, replacement) {\n    pluralRules.push([sanitizeRule(rule), replacement]);\n  };\n\n  /**\n   * Add a singularization rule to the collection.\n   *\n   * @param {(string|RegExp)} rule\n   * @param {string}          replacement\n   */\n  pluralize.addSingularRule = function (rule, replacement) {\n    singularRules.push([sanitizeRule(rule), replacement]);\n  };\n\n  /**\n   * Add an uncountable word rule.\n   *\n   * @param {(string|RegExp)} word\n   */\n  pluralize.addUncountableRule = function (word) {\n    if (typeof word === 'string') {\n      uncountables[word.toLowerCase()] = true;\n      return;\n    }\n\n    // Set singular and plural references for the word.\n    pluralize.addPluralRule(word, '$0');\n    pluralize.addSingularRule(word, '$0');\n  };\n\n  /**\n   * Add an irregular word definition.\n   *\n   * @param {string} single\n   * @param {string} plural\n   */\n  pluralize.addIrregularRule = function (single, plural) {\n    plural = plural.toLowerCase();\n    single = single.toLowerCase();\n\n    irregularSingles[single] = plural;\n    irregularPlurals[plural] = single;\n  };\n\n  /**\n   * Irregular rules.\n   */\n  [\n    // Pronouns.\n    ['I', 'we'],\n    ['me', 'us'],\n    ['he', 'they'],\n    ['she', 'they'],\n    ['them', 'them'],\n    ['myself', 'ourselves'],\n    ['yourself', 'yourselves'],\n    ['itself', 'themselves'],\n    ['herself', 'themselves'],\n    ['himself', 'themselves'],\n    ['themself', 'themselves'],\n    ['is', 'are'],\n    ['was', 'were'],\n    ['has', 'have'],\n    ['this', 'these'],\n    ['that', 'those'],\n    // Words ending in with a consonant and `o`.\n    ['echo', 'echoes'],\n    ['dingo', 'dingoes'],\n    ['volcano', 'volcanoes'],\n    ['tornado', 'tornadoes'],\n    ['torpedo', 'torpedoes'],\n    // Ends with `us`.\n    ['genus', 'genera'],\n    ['viscus', 'viscera'],\n    // Ends with `ma`.\n    ['stigma', 'stigmata'],\n    ['stoma', 'stomata'],\n    ['dogma', 'dogmata'],\n    ['lemma', 'lemmata'],\n    ['schema', 'schemata'],\n    ['anathema', 'anathemata'],\n    // Other irregular rules.\n    ['ox', 'oxen'],\n    ['axe', 'axes'],\n    ['die', 'dice'],\n    ['yes', 'yeses'],\n    ['foot', 'feet'],\n    ['eave', 'eaves'],\n    ['goose', 'geese'],\n    ['tooth', 'teeth'],\n    ['quiz', 'quizzes'],\n    ['human', 'humans'],\n    ['proof', 'proofs'],\n    ['carve', 'carves'],\n    ['valve', 'valves'],\n    ['looey', 'looies'],\n    ['thief', 'thieves'],\n    ['groove', 'grooves'],\n    ['pickaxe', 'pickaxes'],\n    ['passerby', 'passersby']\n  ].forEach(function (rule) {\n    return pluralize.addIrregularRule(rule[0], rule[1]);\n  });\n\n  /**\n   * Pluralization rules.\n   */\n  [\n    [/s?$/i, 's'],\n    [/[^\\u0000-\\u007F]$/i, '$0'],\n    [/([^aeiou]ese)$/i, '$1'],\n    [/(ax|test)is$/i, '$1es'],\n    [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, '$1es'],\n    [/(e[mn]u)s?$/i, '$1s'],\n    [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, '$1'],\n    [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1i'],\n    [/(alumn|alg|vertebr)(?:a|ae)$/i, '$1ae'],\n    [/(seraph|cherub)(?:im)?$/i, '$1im'],\n    [/(her|at|gr)o$/i, '$1oes'],\n    [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, '$1a'],\n    [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, '$1a'],\n    [/sis$/i, 'ses'],\n    [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, '$1$2ves'],\n    [/([^aeiouy]|qu)y$/i, '$1ies'],\n    [/([^ch][ieo][ln])ey$/i, '$1ies'],\n    [/(x|ch|ss|sh|zz)$/i, '$1es'],\n    [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, '$1ices'],\n    [/\\b((?:tit)?m|l)(?:ice|ouse)$/i, '$1ice'],\n    [/(pe)(?:rson|ople)$/i, '$1ople'],\n    [/(child)(?:ren)?$/i, '$1ren'],\n    [/eaux$/i, '$0'],\n    [/m[ae]n$/i, 'men'],\n    ['thou', 'you']\n  ].forEach(function (rule) {\n    return pluralize.addPluralRule(rule[0], rule[1]);\n  });\n\n  /**\n   * Singularization rules.\n   */\n  [\n    [/s$/i, ''],\n    [/(ss)$/i, '$1'],\n    [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\\w]|^)li)ves$/i, '$1fe'],\n    [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, '$1f'],\n    [/ies$/i, 'y'],\n    [/\\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, '$1ie'],\n    [/\\b(mon|smil)ies$/i, '$1ey'],\n    [/\\b((?:tit)?m|l)ice$/i, '$1ouse'],\n    [/(seraph|cherub)im$/i, '$1'],\n    [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, '$1'],\n    [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, '$1sis'],\n    [/(movie|twelve|abuse|e[mn]u)s$/i, '$1'],\n    [/(test)(?:is|es)$/i, '$1is'],\n    [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1us'],\n    [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, '$1um'],\n    [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, '$1on'],\n    [/(alumn|alg|vertebr)ae$/i, '$1a'],\n    [/(cod|mur|sil|vert|ind)ices$/i, '$1ex'],\n    [/(matr|append)ices$/i, '$1ix'],\n    [/(pe)(rson|ople)$/i, '$1rson'],\n    [/(child)ren$/i, '$1'],\n    [/(eau)x?$/i, '$1'],\n    [/men$/i, 'man']\n  ].forEach(function (rule) {\n    return pluralize.addSingularRule(rule[0], rule[1]);\n  });\n\n  /**\n   * Uncountable rules.\n   */\n  [\n    // Singular words with no plurals.\n    'adulthood',\n    'advice',\n    'agenda',\n    'aid',\n    'aircraft',\n    'alcohol',\n    'ammo',\n    'analytics',\n    'anime',\n    'athletics',\n    'audio',\n    'bison',\n    'blood',\n    'bream',\n    'buffalo',\n    'butter',\n    'carp',\n    'cash',\n    'chassis',\n    'chess',\n    'clothing',\n    'cod',\n    'commerce',\n    'cooperation',\n    'corps',\n    'debris',\n    'diabetes',\n    'digestion',\n    'elk',\n    'energy',\n    'equipment',\n    'excretion',\n    'expertise',\n    'firmware',\n    'flounder',\n    'fun',\n    'gallows',\n    'garbage',\n    'graffiti',\n    'hardware',\n    'headquarters',\n    'health',\n    'herpes',\n    'highjinks',\n    'homework',\n    'housework',\n    'information',\n    'jeans',\n    'justice',\n    'kudos',\n    'labour',\n    'literature',\n    'machinery',\n    'mackerel',\n    'mail',\n    'media',\n    'mews',\n    'moose',\n    'music',\n    'mud',\n    'manga',\n    'news',\n    'only',\n    'personnel',\n    'pike',\n    'plankton',\n    'pliers',\n    'police',\n    'pollution',\n    'premises',\n    'rain',\n    'research',\n    'rice',\n    'salmon',\n    'scissors',\n    'series',\n    'sewage',\n    'shambles',\n    'shrimp',\n    'software',\n    'species',\n    'staff',\n    'swine',\n    'tennis',\n    'traffic',\n    'transportation',\n    'trout',\n    'tuna',\n    'wealth',\n    'welfare',\n    'whiting',\n    'wildebeest',\n    'wildlife',\n    'you',\n    /pok[eé]mon$/i,\n    // Regexes.\n    /[^aeiou]ese$/i, // \"chinese\", \"japanese\"\n    /deer$/i, // \"deer\", \"reindeer\"\n    /fish$/i, // \"fish\", \"blowfish\", \"angelfish\"\n    /measles$/i,\n    /o[iu]s$/i, // \"carnivorous\"\n    /pox$/i, // \"chickpox\", \"smallpox\"\n    /sheep$/i\n  ].forEach(pluralize.addUncountableRule);\n\n  return pluralize;\n});\n","// src/normalize.ts\nfunction isObject(v) {\n  return typeof v === \"object\" && v !== null;\n}\nfunction normalizeOptions(options, factoryOptions) {\n  options = isObject(options) ? options : /* @__PURE__ */ Object.create(null);\n  return new Proxy(options, {\n    get(target, key, receiver) {\n      if (key === \"key\")\n        return Reflect.get(target, key, receiver);\n      return Reflect.get(target, key, receiver) || Reflect.get(factoryOptions, key, receiver);\n    }\n  });\n}\n\n// src/pick.ts\nfunction get(state, path) {\n  return path.reduce((obj, p) => {\n    return obj == null ? void 0 : obj[p];\n  }, state);\n}\nfunction set(state, path, val) {\n  return path.slice(0, -1).reduce((obj, p) => {\n    if (/^(__proto__)$/.test(p))\n      return {};\n    else\n      return obj[p] = obj[p] || {};\n  }, state)[path[path.length - 1]] = val, state;\n}\nfunction pick(baseState, paths) {\n  return paths.reduce((substate, path) => {\n    const pathArray = path.split(\".\");\n    return set(substate, pathArray, get(baseState, pathArray));\n  }, {});\n}\n\n// src/plugin.ts\nfunction hydrateStore(store, { storage, serializer, key, debug }) {\n  try {\n    const fromStorage = storage == null ? void 0 : storage.getItem(key);\n    if (fromStorage)\n      store.$patch(serializer == null ? void 0 : serializer.deserialize(fromStorage));\n  } catch (error) {\n    if (debug)\n      console.error(error);\n  }\n}\nfunction persistState(state, { storage, serializer, key, paths, debug }) {\n  try {\n    const toStore = Array.isArray(paths) ? pick(state, paths) : state;\n    storage.setItem(key, serializer.serialize(toStore));\n  } catch (error) {\n    if (debug)\n      console.error(error);\n  }\n}\nfunction createPersistedState(factoryOptions = {}) {\n  return (context) => {\n    const { auto = false } = factoryOptions;\n    const {\n      options: { persist = auto },\n      store,\n      pinia\n    } = context;\n    if (!persist)\n      return;\n    if (!(store.$id in pinia.state.value)) {\n      const original_store = pinia._s.get(store.$id.replace(\"__hot:\", \"\"));\n      if (original_store)\n        Promise.resolve().then(() => original_store.$persist());\n      return;\n    }\n    const persistences = (Array.isArray(persist) ? persist.map((p) => normalizeOptions(p, factoryOptions)) : [normalizeOptions(persist, factoryOptions)]).map(\n      ({\n        storage = localStorage,\n        beforeRestore = null,\n        afterRestore = null,\n        serializer = {\n          serialize: JSON.stringify,\n          deserialize: JSON.parse\n        },\n        key = store.$id,\n        paths = null,\n        debug = false\n      }) => {\n        var _a;\n        return {\n          storage,\n          beforeRestore,\n          afterRestore,\n          serializer,\n          key: ((_a = factoryOptions.key) != null ? _a : (k) => k)(typeof key == \"string\" ? key : key(store.$id)),\n          paths,\n          debug\n        };\n      }\n    );\n    store.$persist = () => {\n      persistences.forEach((persistence) => {\n        persistState(store.$state, persistence);\n      });\n    };\n    store.$hydrate = ({ runHooks = true } = {}) => {\n      persistences.forEach((persistence) => {\n        const { beforeRestore, afterRestore } = persistence;\n        if (runHooks)\n          beforeRestore == null ? void 0 : beforeRestore(context);\n        hydrateStore(store, persistence);\n        if (runHooks)\n          afterRestore == null ? void 0 : afterRestore(context);\n      });\n    };\n    persistences.forEach((persistence) => {\n      const { beforeRestore, afterRestore } = persistence;\n      beforeRestore == null ? void 0 : beforeRestore(context);\n      hydrateStore(store, persistence);\n      afterRestore == null ? void 0 : afterRestore(context);\n      store.$subscribe(\n        (_mutation, state) => {\n          persistState(state, persistence);\n        },\n        {\n          detached: true\n        }\n      );\n    });\n  };\n}\n\n// src/index.ts\nvar src_default = createPersistedState();\nexport {\n  createPersistedState,\n  src_default as default\n};\n","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","/*!\n * pinia v2.1.6\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        if (storeState) {\n            Object.assign(storeState, 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 = pinia._e.run(() => {\n        scope = effectScope();\n        return runWithContext(() => scope.run(setup));\n    });\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. Did you forget to install pinia?\\n` +\n                `\\tconst pinia = createPinia()\\n` +\n                `\\tapp.use(pinia)\\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"],"names":["module","exports","pluralRules","singularRules","uncountables","irregularPlurals","irregularSingles","sanitizeRule","rule","RegExp","restoreCase","word","token","toLowerCase","toUpperCase","charAt","substr","replace","match","index","str","args","result","arguments","sanitizeWord","rules","length","hasOwnProperty","len","test","replaceWord","replaceMap","keepMap","checkWord","bool","pluralize","count","inclusive","singular","plural","isPlural","isSingular","addPluralRule","replacement","push","addSingularRule","addUncountableRule","addIrregularRule","single","forEach","normalizeOptions","options","factoryOptions","v","Object","create","Proxy","get","target","key","receiver","Reflect","hydrateStore","store","storage","serializer","debug","fromStorage","getItem","$patch","deserialize","error","console","persistState","state","paths","toStore","Array","isArray","baseState","reduce","substate","path","pathArray","split","val","slice","obj","p","set","pick","setItem","serialize","src_default","context","auto","persist","pinia","$id","value","original_store","_s","Promise","resolve","then","$persist","persistences","map","localStorage","beforeRestore","afterRestore","JSON","stringify","parse","_a","k","persistence","$state","$hydrate","runHooks","$subscribe","_mutation","detached","createPersistedState","Math","max","splice","activePinia","setActivePinia","piniaSymbol","Symbol","isPlainObject","o","prototype","toString","call","toJSON","MutationType","IS_CLIENT","window","USE_DEVTOOLS","_global","self","global","globalThis","HTMLElement","download","url","name","opts","xhr","XMLHttpRequest","open","responseType","onload","saveAs","response","onerror","send","corsEnabled","e","status","click","node","dispatchEvent","MouseEvent","evt","document","createEvent","initMouseEvent","_navigator","navigator","userAgent","isMacOSWebView","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","Error","assign","readAsDataURL","toastMessage","message","piniaMessage","__VUE_DEVTOOLS_TOAST__","warn","log","isPinia","checkClipboardAccess","checkNotFocusedError","includes","fileInput","loadStoresState","storeState","formatDisplay","display","_custom","PINIA_ROOT_LABEL","PINIA_ROOT_ID","formatStoreForInspectorTree","id","label","formatEventData","events","data","event","keys","operations","oldValue","newValue","operation","formatMutationType","direct","patchFunction","patchObject","isTimelineActive","componentStateTypes","MUTATIONS_LAYER_ID","INSPECTOR_ID","assign$1","getStoreType","registerPiniaDevtools","app","logo","packageName","homepage","api","now","addTimelineLayer","color","addInspector","icon","treeFilterPlaceholder","actions","action","async","clipboard","writeText","actionGlobalCopyState","tooltip","readText","actionGlobalPasteState","sendInspectorTree","sendInspectorState","actionGlobalSaveState","accept","reject","onchange","files","file","item","text","oncancel","actionGlobalOpenStateFile","nodeActions","nodeId","$reset","on","inspectComponent","payload","ctx","proxy","componentInstance","_pStores","piniaStores","values","instanceData","editable","_isOptionsAPI","_getters","getters","getInspectorTree","inspectorId","stores","concat","from","rootNodes","filter","getInspectorState","inspectedStore","storeNames","storeMap","storeId","getterName","_customProperties","size","customProperties","formatStoreForInspectorState","editInspectorState","unshift","has","editComponentState","startsWith","activeAction","runningActionId","patchActionForGrouping","actionNames","wrapWithProxy","storeActions","actionName","_actionId","trackedStore","retValue","apply","undefined","devtoolsPlugin","originalHotUpdate","_hotUpdate","newStore","this","_hmrPayload","settings","logStoreChanges","defaultValue","bind","Date","$onAction","after","onError","groupId","addTimelineEvent","layerId","time","subtitle","logType","notifyComponentUpdate","deep","eventData","flush","hotUpdate","info","$dispose","getSettings","addStoreToDevtools","createPinia","scope","run","_p","toBeInstalled","install","provide","config","globalProperties","$pinia","plugin","use","_e","Map","noop","addSubscription","subscriptions","callback","onCleanup","removeSubscription","idx","indexOf","triggerSubscriptions","fallbackRunWithContext","fn","mergeReactiveObjects","patchToApply","Set","add","subPatch","targetValue","skipHydrateSymbol","skipHydrateMap","WeakMap","createSetupStore","setup","hot","isOptionsStore","optionsForPlugin","$subscribeOptions","isListening","isSyncListening","debuggerEvents","actionSubscriptions","initialState","hotState","activeListener","partialStateOrMutator","subscriptionMutation","myListenerId","newState","wrapAction","afterCallbackList","onErrorCallbackList","ret","catch","partialStore","stopWatcher","stop","delete","_r","runWithContext","setupStore","prop","effect","actionValue","defineProperty","nonEnumerable","writable","configurable","enumerable","extender","extensions","hydrate","defineStore","idOrOptions","setupOptions","isSetupStore","useStore","hasContext","localState","computedGetters","createOptionsStore","mapState","keysOrMapper","reduced","storeKey","mapActions","mapWritableState"],"sourceRoot":""}