}
+// TODO: can we change these to numbers?
+/**
+ * Possible types for SubscriptionCallback
+ */
+exports.MutationType = void 0;
+(function (MutationType) {
+ /**
+ * Direct mutation of the state:
+ *
+ * - `store.name = 'new name'`
+ * - `store.$state.name = 'new name'`
+ * - `store.list.push('new item')`
+ */
+ MutationType["direct"] = "direct";
+ /**
+ * Mutated the state with `$patch` and an object
+ *
+ * - `store.$patch({ name: 'newName' })`
+ */
+ MutationType["patchObject"] = "patch object";
+ /**
+ * Mutated the state with `$patch` and a function
+ *
+ * - `store.$patch(state => state.name = 'newName')`
+ */
+ MutationType["patchFunction"] = "patch function";
+ // maybe reset? for $state = {} and $reset
+})(exports.MutationType || (exports.MutationType = {}));
+
+const IS_CLIENT = typeof window !== 'undefined';
+
+/**
+ * Creates a Pinia instance to be used by the application
+ */
+function createPinia() {
+ const scope = vueDemi.effectScope(true);
+ // NOTE: here we could check the window object for a state and directly set it
+ // if there is anything like it with Vue 3 SSR
+ const state = scope.run(() => vueDemi.ref({}));
+ let _p = [];
+ // plugins added before calling app.use(pinia)
+ let toBeInstalled = [];
+ const pinia = vueDemi.markRaw({
+ install(app) {
+ // this allows calling useStore() outside of a component setup after
+ // installing pinia's plugin
+ setActivePinia(pinia);
+ if (!vueDemi.isVue2) {
+ pinia._a = app;
+ app.provide(piniaSymbol, pinia);
+ app.config.globalProperties.$pinia = pinia;
+ toBeInstalled.forEach((plugin) => _p.push(plugin));
+ toBeInstalled = [];
+ }
+ },
+ use(plugin) {
+ if (!this._a && !vueDemi.isVue2) {
+ toBeInstalled.push(plugin);
+ }
+ else {
+ _p.push(plugin);
+ }
+ return this;
+ },
+ _p,
+ // it's actually undefined here
+ // @ts-expect-error
+ _a: null,
+ _e: scope,
+ _s: new Map(),
+ state,
+ });
+ return pinia;
+}
+
+/**
+ * Creates an _accept_ function to pass to `import.meta.hot` in Vite applications.
+ *
+ * @example
+ * ```js
+ * const useUser = defineStore(...)
+ * if (import.meta.hot) {
+ * import.meta.hot.accept(acceptHMRUpdate(useUser, import.meta.hot))
+ * }
+ * ```
+ *
+ * @param initialUseStore - return of the defineStore to hot update
+ * @param hot - `import.meta.hot`
+ */
+function acceptHMRUpdate(initialUseStore, hot) {
+ // strip as much as possible from iife.prod
+ {
+ return () => { };
+ }
+}
+
+const noop = () => { };
+function addSubscription(subscriptions, callback, detached, onCleanup = noop) {
+ subscriptions.push(callback);
+ const removeSubscription = () => {
+ const idx = subscriptions.indexOf(callback);
+ if (idx > -1) {
+ subscriptions.splice(idx, 1);
+ onCleanup();
+ }
+ };
+ if (!detached && vueDemi.getCurrentScope()) {
+ vueDemi.onScopeDispose(removeSubscription);
+ }
+ return removeSubscription;
+}
+function triggerSubscriptions(subscriptions, ...args) {
+ subscriptions.slice().forEach((callback) => {
+ callback(...args);
+ });
+}
+
+const fallbackRunWithContext = (fn) => fn();
+function mergeReactiveObjects(target, patchToApply) {
+ // Handle Map instances
+ if (target instanceof Map && patchToApply instanceof Map) {
+ patchToApply.forEach((value, key) => target.set(key, value));
+ }
+ // Handle Set instances
+ if (target instanceof Set && patchToApply instanceof Set) {
+ patchToApply.forEach(target.add, target);
+ }
+ // no need to go through symbols because they cannot be serialized anyway
+ for (const key in patchToApply) {
+ if (!patchToApply.hasOwnProperty(key))
+ continue;
+ const subPatch = patchToApply[key];
+ const targetValue = target[key];
+ if (isPlainObject(targetValue) &&
+ isPlainObject(subPatch) &&
+ target.hasOwnProperty(key) &&
+ !vueDemi.isRef(subPatch) &&
+ !vueDemi.isReactive(subPatch)) {
+ // NOTE: here I wanted to warn about inconsistent types but it's not possible because in setup stores one might
+ // start the value of a property as a certain type e.g. a Map, and then for some reason, during SSR, change that
+ // to `undefined`. When trying to hydrate, we want to override the Map with `undefined`.
+ target[key] = mergeReactiveObjects(targetValue, subPatch);
+ }
+ else {
+ // @ts-expect-error: subPatch is a valid value
+ target[key] = subPatch;
+ }
+ }
+ return target;
+}
+const skipHydrateSymbol = /* istanbul ignore next */ Symbol();
+const skipHydrateMap = /*#__PURE__*/ new WeakMap();
+/**
+ * Tells Pinia to skip the hydration process of a given object. This is useful in setup stores (only) when you return a
+ * stateful object in the store but it isn't really state. e.g. returning a router instance in a setup store.
+ *
+ * @param obj - target object
+ * @returns obj
+ */
+function skipHydrate(obj) {
+ return vueDemi.isVue2
+ ? // in @vue/composition-api, the refs are sealed so defineProperty doesn't work...
+ /* istanbul ignore next */ skipHydrateMap.set(obj, 1) && obj
+ : Object.defineProperty(obj, skipHydrateSymbol, {});
+}
+/**
+ * Returns whether a value should be hydrated
+ *
+ * @param obj - target variable
+ * @returns true if `obj` should be hydrated
+ */
+function shouldHydrate(obj) {
+ return vueDemi.isVue2
+ ? /* istanbul ignore next */ !skipHydrateMap.has(obj)
+ : !isPlainObject(obj) || !obj.hasOwnProperty(skipHydrateSymbol);
+}
+const { assign } = Object;
+function isComputed(o) {
+ return !!(vueDemi.isRef(o) && o.effect);
+}
+function createOptionsStore(id, options, pinia, hot) {
+ const { state, actions, getters } = options;
+ const initialState = pinia.state.value[id];
+ let store;
+ function setup() {
+ if (!initialState && (!false )) {
+ /* istanbul ignore if */
+ if (vueDemi.isVue2) {
+ vueDemi.set(pinia.state.value, id, state ? state() : {});
+ }
+ else {
+ pinia.state.value[id] = state ? state() : {};
+ }
+ }
+ // avoid creating a state in pinia.state.value
+ const localState = vueDemi.toRefs(pinia.state.value[id]);
+ return assign(localState, actions, Object.keys(getters || {}).reduce((computedGetters, name) => {
+ computedGetters[name] = vueDemi.markRaw(vueDemi.computed(() => {
+ setActivePinia(pinia);
+ // it was created just before
+ const store = pinia._s.get(id);
+ // allow cross using stores
+ /* istanbul ignore next */
+ if (vueDemi.isVue2 && !store._r)
+ return;
+ // @ts-expect-error
+ // return getters![name].call(context, context)
+ // TODO: avoid reading the getter while assigning with a global variable
+ return getters[name].call(store, store);
+ }));
+ return computedGetters;
+ }, {}));
+ }
+ store = createSetupStore(id, setup, options, pinia, hot, true);
+ return store;
+}
+function createSetupStore($id, setup, options = {}, pinia, hot, isOptionsStore) {
+ let scope;
+ const optionsForPlugin = assign({ actions: {} }, options);
+ // watcher options for $subscribe
+ const $subscribeOptions = {
+ deep: true,
+ // flush: 'post',
+ };
+ // internal state
+ let isListening; // set to true at the end
+ let isSyncListening; // set to true at the end
+ let subscriptions = [];
+ let actionSubscriptions = [];
+ let debuggerEvents;
+ const initialState = pinia.state.value[$id];
+ // avoid setting the state for option stores if it is set
+ // by the setup
+ if (!isOptionsStore && !initialState && (!false )) {
+ /* istanbul ignore if */
+ if (vueDemi.isVue2) {
+ vueDemi.set(pinia.state.value, $id, {});
+ }
+ else {
+ pinia.state.value[$id] = {};
+ }
+ }
+ vueDemi.ref({});
+ // avoid triggering too many listeners
+ // https://github.com/vuejs/pinia/issues/1129
+ let activeListener;
+ function $patch(partialStateOrMutator) {
+ let subscriptionMutation;
+ isListening = isSyncListening = false;
+ if (typeof partialStateOrMutator === 'function') {
+ partialStateOrMutator(pinia.state.value[$id]);
+ subscriptionMutation = {
+ type: exports.MutationType.patchFunction,
+ storeId: $id,
+ events: debuggerEvents,
+ };
+ }
+ else {
+ mergeReactiveObjects(pinia.state.value[$id], partialStateOrMutator);
+ subscriptionMutation = {
+ type: exports.MutationType.patchObject,
+ payload: partialStateOrMutator,
+ storeId: $id,
+ events: debuggerEvents,
+ };
+ }
+ const myListenerId = (activeListener = Symbol());
+ vueDemi.nextTick().then(() => {
+ if (activeListener === myListenerId) {
+ isListening = true;
+ }
+ });
+ isSyncListening = true;
+ // because we paused the watcher, we need to manually call the subscriptions
+ triggerSubscriptions(subscriptions, subscriptionMutation, pinia.state.value[$id]);
+ }
+ const $reset = isOptionsStore
+ ? function $reset() {
+ const { state } = options;
+ const newState = state ? state() : {};
+ // we use a patch to group all changes into one single subscription
+ this.$patch(($state) => {
+ assign($state, newState);
+ });
+ }
+ : /* istanbul ignore next */
+ noop;
+ function $dispose() {
+ scope.stop();
+ subscriptions = [];
+ actionSubscriptions = [];
+ pinia._s.delete($id);
+ }
+ /**
+ * Wraps an action to handle subscriptions.
+ *
+ * @param name - name of the action
+ * @param action - action to wrap
+ * @returns a wrapped action to handle subscriptions
+ */
+ function wrapAction(name, action) {
+ return function () {
+ setActivePinia(pinia);
+ const args = Array.from(arguments);
+ const afterCallbackList = [];
+ const onErrorCallbackList = [];
+ function after(callback) {
+ afterCallbackList.push(callback);
+ }
+ function onError(callback) {
+ onErrorCallbackList.push(callback);
+ }
+ // @ts-expect-error
+ triggerSubscriptions(actionSubscriptions, {
+ args,
+ name,
+ store,
+ after,
+ onError,
+ });
+ let ret;
+ try {
+ ret = action.apply(this && this.$id === $id ? this : store, args);
+ // handle sync errors
+ }
+ catch (error) {
+ triggerSubscriptions(onErrorCallbackList, error);
+ throw error;
+ }
+ if (ret instanceof Promise) {
+ return ret
+ .then((value) => {
+ triggerSubscriptions(afterCallbackList, value);
+ return value;
+ })
+ .catch((error) => {
+ triggerSubscriptions(onErrorCallbackList, error);
+ return Promise.reject(error);
+ });
+ }
+ // trigger after callbacks
+ triggerSubscriptions(afterCallbackList, ret);
+ return ret;
+ };
+ }
+ const partialStore = {
+ _p: pinia,
+ // _s: scope,
+ $id,
+ $onAction: addSubscription.bind(null, actionSubscriptions),
+ $patch,
+ $reset,
+ $subscribe(callback, options = {}) {
+ const removeSubscription = addSubscription(subscriptions, callback, options.detached, () => stopWatcher());
+ const stopWatcher = scope.run(() => vueDemi.watch(() => pinia.state.value[$id], (state) => {
+ if (options.flush === 'sync' ? isSyncListening : isListening) {
+ callback({
+ storeId: $id,
+ type: exports.MutationType.direct,
+ events: debuggerEvents,
+ }, state);
+ }
+ }, assign({}, $subscribeOptions, options)));
+ return removeSubscription;
+ },
+ $dispose,
+ };
+ /* istanbul ignore if */
+ if (vueDemi.isVue2) {
+ // start as non ready
+ partialStore._r = false;
+ }
+ const store = vueDemi.reactive(partialStore);
+ // store the partial store now so the setup of stores can instantiate each other before they are finished without
+ // creating infinite loops.
+ pinia._s.set($id, store);
+ const runWithContext = (pinia._a && pinia._a.runWithContext) || fallbackRunWithContext;
+ // TODO: idea create skipSerialize that marks properties as non serializable and they are skipped
+ const setupStore = runWithContext(() => pinia._e.run(() => (scope = vueDemi.effectScope()).run(setup)));
+ // overwrite existing actions to support $onAction
+ for (const key in setupStore) {
+ const prop = setupStore[key];
+ if ((vueDemi.isRef(prop) && !isComputed(prop)) || vueDemi.isReactive(prop)) {
+ // mark it as a piece of state to be serialized
+ if (!isOptionsStore) {
+ // in setup stores we must hydrate the state and sync pinia state tree with the refs the user just created
+ if (initialState && shouldHydrate(prop)) {
+ if (vueDemi.isRef(prop)) {
+ prop.value = initialState[key];
+ }
+ else {
+ // probably a reactive object, lets recursively assign
+ // @ts-expect-error: prop is unknown
+ mergeReactiveObjects(prop, initialState[key]);
+ }
+ }
+ // transfer the ref to the pinia state to keep everything in sync
+ /* istanbul ignore if */
+ if (vueDemi.isVue2) {
+ vueDemi.set(pinia.state.value[$id], key, prop);
+ }
+ else {
+ pinia.state.value[$id][key] = prop;
+ }
+ }
+ // action
+ }
+ else if (typeof prop === 'function') {
+ // @ts-expect-error: we are overriding the function we avoid wrapping if
+ const actionValue = wrapAction(key, prop);
+ // this a hot module replacement store because the hotUpdate method needs
+ // to do it with the right context
+ /* istanbul ignore if */
+ if (vueDemi.isVue2) {
+ vueDemi.set(setupStore, key, actionValue);
+ }
+ else {
+ // @ts-expect-error
+ setupStore[key] = actionValue;
+ }
+ // list actions so they can be used in plugins
+ // @ts-expect-error
+ optionsForPlugin.actions[key] = prop;
+ }
+ else ;
+ }
+ // add the state, getters, and action properties
+ /* istanbul ignore if */
+ if (vueDemi.isVue2) {
+ Object.keys(setupStore).forEach((key) => {
+ vueDemi.set(store, key, setupStore[key]);
+ });
+ }
+ else {
+ assign(store, setupStore);
+ // allows retrieving reactive objects with `storeToRefs()`. Must be called after assigning to the reactive object.
+ // Make `storeToRefs()` work with `reactive()` #799
+ assign(vueDemi.toRaw(store), setupStore);
+ }
+ // use this instead of a computed with setter to be able to create it anywhere
+ // without linking the computed lifespan to wherever the store is first
+ // created.
+ Object.defineProperty(store, '$state', {
+ get: () => (pinia.state.value[$id]),
+ set: (state) => {
+ $patch(($state) => {
+ assign($state, state);
+ });
+ },
+ });
+ /* istanbul ignore if */
+ if (vueDemi.isVue2) {
+ // mark the store as ready before plugins
+ store._r = true;
+ }
+ // apply all plugins
+ pinia._p.forEach((extender) => {
+ /* istanbul ignore else */
+ {
+ assign(store, scope.run(() => extender({
+ store,
+ app: pinia._a,
+ pinia,
+ options: optionsForPlugin,
+ })));
+ }
+ });
+ // only apply hydrate to option stores with an initial state in pinia
+ if (initialState &&
+ isOptionsStore &&
+ options.hydrate) {
+ options.hydrate(store.$state, initialState);
+ }
+ isListening = true;
+ isSyncListening = true;
+ return store;
+}
+function defineStore(
+// TODO: add proper types from above
+idOrOptions, setup, setupOptions) {
+ let id;
+ let options;
+ const isSetupStore = typeof setup === 'function';
+ if (typeof idOrOptions === 'string') {
+ id = idOrOptions;
+ // the option store setup will contain the actual options in this case
+ options = isSetupStore ? setupOptions : setup;
+ }
+ else {
+ options = idOrOptions;
+ id = idOrOptions.id;
+ }
+ function useStore(pinia, hot) {
+ const hasContext = vueDemi.hasInjectionContext();
+ pinia =
+ // in test mode, ignore the argument provided as we can always retrieve a
+ // pinia instance with getActivePinia()
+ ((process.env.NODE_ENV === 'test') && activePinia && activePinia._testing ? null : pinia) ||
+ (hasContext ? vueDemi.inject(piniaSymbol, null) : null);
+ if (pinia)
+ setActivePinia(pinia);
+ pinia = activePinia;
+ if (!pinia._s.has(id)) {
+ // creating the store registers it in `pinia._s`
+ if (isSetupStore) {
+ createSetupStore(id, setup, options, pinia);
+ }
+ else {
+ createOptionsStore(id, options, pinia);
+ }
+ }
+ const store = pinia._s.get(id);
+ // StoreGeneric cannot be casted towards Store
+ return store;
+ }
+ useStore.$id = id;
+ return useStore;
+}
+
+let mapStoreSuffix = 'Store';
+/**
+ * Changes the suffix added by `mapStores()`. Can be set to an empty string.
+ * Defaults to `"Store"`. Make sure to extend the MapStoresCustomization
+ * interface if you are using TypeScript.
+ *
+ * @param suffix - new suffix
+ */
+function setMapStoreSuffix(suffix // could be 'Store' but that would be annoying for JS
+) {
+ mapStoreSuffix = suffix;
+}
+/**
+ * Allows using stores without the composition API (`setup()`) by generating an
+ * object to be spread in the `computed` field of a component. It accepts a list
+ * of store definitions.
+ *
+ * @example
+ * ```js
+ * export default {
+ * computed: {
+ * // other computed properties
+ * ...mapStores(useUserStore, useCartStore)
+ * },
+ *
+ * created() {
+ * this.userStore // store with id "user"
+ * this.cartStore // store with id "cart"
+ * }
+ * }
+ * ```
+ *
+ * @param stores - list of stores to map to an object
+ */
+function mapStores(...stores) {
+ return stores.reduce((reduced, useStore) => {
+ // @ts-expect-error: $id is added by defineStore
+ reduced[useStore.$id + mapStoreSuffix] = function () {
+ return useStore(this.$pinia);
+ };
+ return reduced;
+ }, {});
+}
+/**
+ * Allows using state and getters from one store without using the composition
+ * API (`setup()`) by generating an object to be spread in the `computed` field
+ * of a component.
+ *
+ * @param useStore - store to map from
+ * @param keysOrMapper - array or object
+ */
+function mapState(useStore, keysOrMapper) {
+ return Array.isArray(keysOrMapper)
+ ? keysOrMapper.reduce((reduced, key) => {
+ reduced[key] = function () {
+ return useStore(this.$pinia)[key];
+ };
+ return reduced;
+ }, {})
+ : Object.keys(keysOrMapper).reduce((reduced, key) => {
+ // @ts-expect-error
+ reduced[key] = function () {
+ const store = useStore(this.$pinia);
+ const storeKey = keysOrMapper[key];
+ // for some reason TS is unable to infer the type of storeKey to be a
+ // function
+ return typeof storeKey === 'function'
+ ? storeKey.call(this, store)
+ : store[storeKey];
+ };
+ return reduced;
+ }, {});
+}
+/**
+ * Alias for `mapState()`. You should use `mapState()` instead.
+ * @deprecated use `mapState()` instead.
+ */
+const mapGetters = mapState;
+/**
+ * Allows directly using actions from your store without using the composition
+ * API (`setup()`) by generating an object to be spread in the `methods` field
+ * of a component.
+ *
+ * @param useStore - store to map from
+ * @param keysOrMapper - array or object
+ */
+function mapActions(useStore, keysOrMapper) {
+ return Array.isArray(keysOrMapper)
+ ? keysOrMapper.reduce((reduced, key) => {
+ // @ts-expect-error
+ reduced[key] = function (...args) {
+ return useStore(this.$pinia)[key](...args);
+ };
+ return reduced;
+ }, {})
+ : Object.keys(keysOrMapper).reduce((reduced, key) => {
+ // @ts-expect-error
+ reduced[key] = function (...args) {
+ return useStore(this.$pinia)[keysOrMapper[key]](...args);
+ };
+ return reduced;
+ }, {});
+}
+/**
+ * Allows using state and getters from one store without using the composition
+ * API (`setup()`) by generating an object to be spread in the `computed` field
+ * of a component.
+ *
+ * @param useStore - store to map from
+ * @param keysOrMapper - array or object
+ */
+function mapWritableState(useStore, keysOrMapper) {
+ return Array.isArray(keysOrMapper)
+ ? keysOrMapper.reduce((reduced, key) => {
+ // @ts-ignore
+ reduced[key] = {
+ get() {
+ return useStore(this.$pinia)[key];
+ },
+ set(value) {
+ // it's easier to type it here as any
+ return (useStore(this.$pinia)[key] = value);
+ },
+ };
+ return reduced;
+ }, {})
+ : Object.keys(keysOrMapper).reduce((reduced, key) => {
+ // @ts-ignore
+ reduced[key] = {
+ get() {
+ return useStore(this.$pinia)[keysOrMapper[key]];
+ },
+ set(value) {
+ // it's easier to type it here as any
+ return (useStore(this.$pinia)[keysOrMapper[key]] = value);
+ },
+ };
+ return reduced;
+ }, {});
+}
+
+/**
+ * Creates an object of references with all the state, getters, and plugin-added
+ * state properties of the store. Similar to `toRefs()` but specifically
+ * designed for Pinia stores so methods and non reactive properties are
+ * completely ignored.
+ *
+ * @param store - store to extract the refs from
+ */
+function storeToRefs(store) {
+ // See https://github.com/vuejs/pinia/issues/852
+ // It's easier to just use toRefs() even if it includes more stuff
+ if (vueDemi.isVue2) {
+ // @ts-expect-error: toRefs include methods and others
+ return vueDemi.toRefs(store);
+ }
+ else {
+ store = vueDemi.toRaw(store);
+ const refs = {};
+ for (const key in store) {
+ const value = store[key];
+ if (vueDemi.isRef(value) || vueDemi.isReactive(value)) {
+ // @ts-expect-error: the key is state or getter
+ refs[key] =
+ // ---
+ vueDemi.toRef(store, key);
+ }
+ }
+ return refs;
+ }
+}
+
+/**
+ * Vue 2 Plugin that must be installed for pinia to work. Note **you don't need
+ * this plugin if you are using Nuxt.js**. Use the `buildModule` instead:
+ * https://pinia.vuejs.org/ssr/nuxt.html.
+ *
+ * @example
+ * ```js
+ * import Vue from 'vue'
+ * import { PiniaVuePlugin, createPinia } from 'pinia'
+ *
+ * Vue.use(PiniaVuePlugin)
+ * const pinia = createPinia()
+ *
+ * new Vue({
+ * el: '#app',
+ * // ...
+ * pinia,
+ * })
+ * ```
+ *
+ * @param _Vue - `Vue` imported from 'vue'.
+ */
+const PiniaVuePlugin = function (_Vue) {
+ // Equivalent of
+ // app.config.globalProperties.$pinia = pinia
+ _Vue.mixin({
+ beforeCreate() {
+ const options = this.$options;
+ if (options.pinia) {
+ const pinia = options.pinia;
+ // HACK: taken from provide(): https://github.com/vuejs/composition-api/blob/main/src/apis/inject.ts#L31
+ /* istanbul ignore else */
+ if (!this._provided) {
+ const provideCache = {};
+ Object.defineProperty(this, '_provided', {
+ get: () => provideCache,
+ set: (v) => Object.assign(provideCache, v),
+ });
+ }
+ this._provided[piniaSymbol] = pinia;
+ // propagate the pinia instance in an SSR friendly way
+ // avoid adding it to nuxt twice
+ /* istanbul ignore else */
+ if (!this.$pinia) {
+ this.$pinia = pinia;
+ }
+ pinia._a = this;
+ if (IS_CLIENT) {
+ // this allows calling useStore() outside of a component setup after
+ // installing pinia's plugin
+ setActivePinia(pinia);
+ }
+ }
+ else if (!this.$pinia && options.parent && options.parent.$pinia) {
+ this.$pinia = options.parent.$pinia;
+ }
+ },
+ destroyed() {
+ delete this._pStores;
+ },
+ });
+};
+
+exports.PiniaVuePlugin = PiniaVuePlugin;
+exports.acceptHMRUpdate = acceptHMRUpdate;
+exports.createPinia = createPinia;
+exports.defineStore = defineStore;
+exports.getActivePinia = getActivePinia;
+exports.mapActions = mapActions;
+exports.mapGetters = mapGetters;
+exports.mapState = mapState;
+exports.mapStores = mapStores;
+exports.mapWritableState = mapWritableState;
+exports.setActivePinia = setActivePinia;
+exports.setMapStoreSuffix = setMapStoreSuffix;
+exports.skipHydrate = skipHydrate;
+exports.storeToRefs = storeToRefs;
diff --git a/node_modules/pinia/index.cjs b/node_modules/pinia/index.cjs
new file mode 100644
index 0000000..9fc1f5c
--- /dev/null
+++ b/node_modules/pinia/index.cjs
@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+ module.exports = require('./dist/pinia.prod.cjs')
+} else {
+ module.exports = require('./dist/pinia.cjs')
+}
diff --git a/node_modules/pinia/index.js b/node_modules/pinia/index.js
new file mode 100644
index 0000000..9fc1f5c
--- /dev/null
+++ b/node_modules/pinia/index.js
@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+ module.exports = require('./dist/pinia.prod.cjs')
+} else {
+ module.exports = require('./dist/pinia.cjs')
+}
diff --git a/node_modules/pinia/package.json b/node_modules/pinia/package.json
new file mode 100644
index 0000000..4568c40
--- /dev/null
+++ b/node_modules/pinia/package.json
@@ -0,0 +1,100 @@
+{
+ "name": "pinia",
+ "version": "2.1.7",
+ "description": "Intuitive, type safe and flexible Store for Vue",
+ "main": "index.js",
+ "module": "dist/pinia.mjs",
+ "unpkg": "dist/pinia.iife.js",
+ "jsdelivr": "dist/pinia.iife.js",
+ "types": "dist/pinia.d.ts",
+ "exports": {
+ ".": {
+ "types": "./dist/pinia.d.ts",
+ "node": {
+ "import": {
+ "production": "./dist/pinia.prod.cjs",
+ "development": "./dist/pinia.mjs",
+ "default": "./dist/pinia.mjs"
+ },
+ "require": {
+ "production": "./dist/pinia.prod.cjs",
+ "development": "./dist/pinia.cjs",
+ "default": "./index.js"
+ }
+ },
+ "import": "./dist/pinia.mjs",
+ "require": "./index.js"
+ },
+ "./package.json": "./package.json",
+ "./dist/*": "./dist/*"
+ },
+ "sideEffects": false,
+ "author": {
+ "name": "Eduardo San Martin Morote",
+ "email": "posva13@gmail.com"
+ },
+ "funding": "https://github.com/sponsors/posva",
+ "files": [
+ "dist/*.js",
+ "dist/*.mjs",
+ "dist/*.cjs",
+ "dist/pinia.d.ts",
+ "index.js",
+ "index.cjs",
+ "LICENSE",
+ "README.md"
+ ],
+ "keywords": [
+ "vue",
+ "vuex",
+ "store",
+ "pinia",
+ "piña",
+ "pigna",
+ "composition",
+ "api",
+ "setup",
+ "typed",
+ "typescript",
+ "ts",
+ "type",
+ "safe"
+ ],
+ "license": "MIT",
+ "devDependencies": {
+ "@microsoft/api-extractor": "7.34.4",
+ "@vue/test-utils": "^2.4.0"
+ },
+ "dependencies": {
+ "@vue/devtools-api": "^6.5.0",
+ "vue-demi": ">=0.14.5"
+ },
+ "peerDependencies": {
+ "@vue/composition-api": "^1.4.0",
+ "typescript": ">=4.4.4",
+ "vue": "^2.6.14 || ^3.3.0"
+ },
+ "peerDependenciesMeta": {
+ "typescript": {
+ "optional": true
+ },
+ "@vue/composition-api": {
+ "optional": true
+ }
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/vuejs/pinia.git"
+ },
+ "bugs": {
+ "url": "https://github.com/vuejs/pinia/issues"
+ },
+ "homepage": "https://github.com/vuejs/pinia#readme",
+ "scripts": {
+ "build": "rimraf dist && rollup -c ../../rollup.config.mjs --environment TARGET:pinia",
+ "build:dts": "api-extractor run --local --verbose && tail -n +3 ./src/globalExtensions.ts >> dist/pinia.d.ts",
+ "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s --commit-path . -l pinia -r 1",
+ "test:dts": "tsc -p ./test-dts/tsconfig.json",
+ "test": "yarn run build && yarn run build:dts && yarn test:dts"
+ }
+}
\ No newline at end of file
diff --git a/node_modules/vue-demi/LICENSE b/node_modules/vue-demi/LICENSE
new file mode 100644
index 0000000..894ffaf
--- /dev/null
+++ b/node_modules/vue-demi/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-present, Anthony Fu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/node_modules/vue-demi/README.md b/node_modules/vue-demi/README.md
new file mode 100644
index 0000000..f941590
--- /dev/null
+++ b/node_modules/vue-demi/README.md
@@ -0,0 +1,229 @@
+
+
+
+
+
+
+
+Vue Demi (half in French) is a developing utility
allows you to write Universal Vue Libraries for Vue 2 & 3
+See more details in this blog post
+
+
+
+
+
+
+## Strategies
+
+- `<=2.6`: exports from `vue` + `@vue/composition-api` with plugin auto installing.
+- `2.7`: exports from `vue` (Composition API is built-in in Vue 2.7).
+- `>=3.0`: exports from `vue`, with polyfill of Vue 2's `set` and `del` API.
+
+## Usage
+
+Install this as your plugin's dependency:
+
+```bash
+npm i vue-demi
+# or
+yarn add vue-demi
+# or
+pnpm i vue-demi
+```
+
+Add `vue` and `@vue/composition-api` to your plugin's peer dependencies to specify what versions you support.
+
+```jsonc
+{
+ "dependencies": {
+ "vue-demi": "latest"
+ },
+ "peerDependencies": {
+ "@vue/composition-api": "^1.0.0-rc.1",
+ "vue": "^2.0.0 || >=3.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@vue/composition-api": {
+ "optional": true
+ }
+ },
+ "devDependencies": {
+ "vue": "^3.0.0" // or "^2.6.0" base on your preferred working environment
+ },
+}
+```
+
+Import everything related to Vue from it, it will redirect to `vue@2` + `@vue/composition-api` or `vue@3` based on users' environments.
+
+```ts
+import { ref, reactive, defineComponent } from 'vue-demi'
+```
+
+Publish your plugin and all is done!
+
+> When using with [Vite](https://vitejs.dev), you will need to opt-out the pre-bundling to get `vue-demi` work properly by
+> ```js
+> // vite.config.js
+> export default defineConfig({
+> optimizeDeps: {
+> exclude: ['vue-demi']
+> }
+> })
+> ```
+
+### Extra APIs
+
+`Vue Demi` provides extra APIs to help distinguish users' environments and to do some version-specific logic.
+
+### `isVue2` `isVue3`
+
+```ts
+import { isVue2, isVue3 } from 'vue-demi'
+
+if (isVue2) {
+ // Vue 2 only
+} else {
+ // Vue 3 only
+}
+```
+
+### `Vue2`
+
+To avoid bringing in all the tree-shakable modules, we provide a `Vue2` export to support access to Vue 2's global API. (See [#41](https://github.com/vueuse/vue-demi/issues/41).)
+
+```ts
+import { Vue2 } from 'vue-demi'
+
+if (Vue2) {
+ Vue2.config.ignoredElements.push('x-foo')
+}
+```
+
+### `install()`
+
+Composition API in Vue 2 is provided as a plugin and needs to be installed on the Vue instance before using. Normally, `vue-demi` will try to install it automatically. For some usages where you might need to ensure the plugin gets installed correctly, the `install()` API is exposed to as a safe version of `Vue.use(CompositionAPI)`. `install()` in the Vue 3 environment will be an empty function (no-op).
+
+```ts
+import { install } from 'vue-demi'
+
+install()
+```
+
+## CLI
+
+### Manually Switch Versions
+
+To explicitly switch the redirecting version, you can use these commands in your project's root.
+
+```bash
+npx vue-demi-switch 2
+# or
+npx vue-demi-switch 3
+```
+
+### Package Aliasing
+
+If you would like to import `vue` under an alias, you can use the following command
+
+```bash
+npx vue-demi-switch 2 vue2
+# or
+npx vue-demi-switch 3 vue3
+```
+
+Then `vue-demi` will redirect APIs from the alias name you specified, for example:
+
+```ts
+import * as Vue from 'vue3'
+
+var isVue2 = false
+var isVue3 = true
+var Vue2 = undefined
+
+export * from 'vue3'
+export {
+ Vue,
+ Vue2,
+ isVue2,
+ isVue3,
+}
+```
+
+### Auto Fix
+
+If the `postinstall` hook doesn't get triggered or you have updated the Vue version, try to run the following command to resolve the redirecting.
+
+```bash
+npx vue-demi-fix
+```
+
+### Isomorphic Testings
+
+You can support testing for both versions by adding npm alias in your dev dependencies. For example:
+
+```json
+{
+ "scripts": {
+ "test:2": "vue-demi-switch 2 vue2 && jest",
+ "test:3": "vue-demi-switch 3 && jest",
+ },
+ "devDependencies": {
+ "vue": "^3.0.0",
+ "vue2": "npm:vue@2"
+ },
+}
+```
+
+or
+
+```json
+{
+ "scripts": {
+ "test:2": "vue-demi-switch 2 && jest",
+ "test:3": "vue-demi-switch 3 vue3 && jest",
+ },
+ "devDependencies": {
+ "vue": "^2.6.0",
+ "vue3": "npm:vue@3"
+ },
+}
+```
+
+## Examples
+
+See [examples](./examples).
+
+## Who is using this?
+
+- [VueUse](https://github.com/vueuse/vueuse) - Collection of Composition API utils
+- [@vue/apollo-composable](https://github.com/vuejs/vue-apollo/tree/v4/packages/vue-apollo-composable) - Apollo GraphQL functions for Vue Composition API
+- [vuelidate](https://github.com/vuelidate/vuelidate) - Simple, lightweight model-based validation
+- [vue-composition-test-utils](https://github.com/ariesjia/vue-composition-test-utils) - Simple vue composition api unit test utilities
+- [vue-use-stripe](https://github.com/frandiox/vue-use-stripe) - Stripe Elements wrapper for Vue.js
+- [@opd/g2plot-vue](https://github.com/open-data-plan/g2plot-vue) - G2plot for vue
+- [vue-echarts](https://github.com/ecomfe/vue-echarts) - Vue.js component for Apache ECharts.
+- [fluent-vue](https://github.com/Demivan/fluent-vue) - Vue.js integration for [Fluent.js](https://github.com/projectfluent/fluent.js) - JavaScript implementation of [Project Fluent](https://projectfluent.org)
+- [vue-datatable-url-sync](https://github.com/socotecio/vue-datatable-url-sync) - Synchronize datatable options and filters with the url to keep user preference even after refresh or navigation
+- [vue-insta-stories](https://github.com/UnevenSoftware/vue-insta-stories) - Instagram stories in your vue projects.
+- [vue-tiny-validate](https://github.com/FrontLabsOfficial/vue-tiny-validate) - Tiny Vue Validate Composition
+- [v-perfect-signature](https://github.com/wobsoriano/v-perfect-signature) - Pressure-sensitive signature drawing for Vue 2 and 3
+- [vue-winbox](https://github.com/wobsoriano/vue-winbox) - A wrapper component for WinBox.js that adds the ability to mount Vue components.
+- [vue-word-highlighter](https://github.com/kawamataryo/vue-word-highlighter) - The word highlighter library for Vue 2 and Vue 3
+- [vue-chart-3](https://github.com/victorgarciaesgi/vue-chart-3) - Vue.js component for Chart.js
+- [json-editor-vue](https://github.com/cloydlau/json-editor-vue) - JSON editor & viewer for Vue 2 and 3.
+- [kidar-echarts](https://github.com/kidarjs/kidar-echarts) - A simpler echarts component for Vue 2 and 3.
+- [vue3-sketch-ruler](https://github.com/kakajun/vue3-sketch-ruler) - The zoom operation used for page presentation for Vue 2 and 3( Replace render function with template )
+- [vue-rough-notation](https://github.com/Leecason/vue-rough-notation) - RoughNotation wrapper component for Vue 2 and 3.
+- [vue-request](https://github.com/AttoJS/vue-request) - Vue composition API for data fetching, supports SWR, polling, error retry, cache request, pagination, etc.
+- [vue3-lazyload](https://github.com/murongg/vue3-lazyload) - A vue3.x image lazyload plugin.
+- [vue-codemirror6](https://github.com/logue/vue-codemirror6) - CodeMirror6 component for Vue2 and 3.
+- [@tanstack/vue-query](https://github.com/TanStack/query) - TanStack Query for Vue.
+> open a PR to add your library ;)
+
+## Underhood
+
+See [the blog post](https://antfu.me/posts/make-libraries-working-with-vue-2-and-3/#-introducing-vue-demi).
+
+## License
+
+MIT License © 2020 [Anthony Fu](https://github.com/antfu)
diff --git a/node_modules/vue-demi/bin/vue-demi-fix.js b/node_modules/vue-demi/bin/vue-demi-fix.js
new file mode 100644
index 0000000..684a621
--- /dev/null
+++ b/node_modules/vue-demi/bin/vue-demi-fix.js
@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+'use strict'
+require('../scripts/postinstall')
diff --git a/node_modules/vue-demi/bin/vue-demi-switch.js b/node_modules/vue-demi/bin/vue-demi-switch.js
new file mode 100644
index 0000000..360eada
--- /dev/null
+++ b/node_modules/vue-demi/bin/vue-demi-switch.js
@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+'use strict'
+require('../scripts/switch-cli')
diff --git a/node_modules/vue-demi/lib/index.cjs b/node_modules/vue-demi/lib/index.cjs
new file mode 100644
index 0000000..c3d298e
--- /dev/null
+++ b/node_modules/vue-demi/lib/index.cjs
@@ -0,0 +1,34 @@
+var Vue = require('vue')
+var VueCompositionAPI = require('@vue/composition-api')
+
+function install(_vue) {
+ var vueLib = _vue || Vue
+ if (vueLib && 'default' in vueLib) {
+ vueLib = vueLib.default
+ }
+
+ if (vueLib && !vueLib['__composition_api_installed__']) {
+ if (VueCompositionAPI && 'default' in VueCompositionAPI)
+ vueLib.use(VueCompositionAPI.default)
+ else if (VueCompositionAPI)
+ vueLib.use(VueCompositionAPI)
+ }
+}
+
+install(Vue)
+
+Object.keys(VueCompositionAPI).forEach(function(key) {
+ exports[key] = VueCompositionAPI[key]
+})
+
+exports.Vue = Vue
+exports.Vue2 = Vue
+exports.isVue2 = true
+exports.isVue3 = false
+exports.install = install
+exports.version = Vue.version
+
+// Not implemented https://github.com/vuejs/core/pull/8111, falls back to getCurrentInstance()
+exports.hasInjectionContext = function () {
+ return !!VueCompositionAPI.getCurrentInstance()
+}
diff --git a/node_modules/vue-demi/lib/index.d.ts b/node_modules/vue-demi/lib/index.d.ts
new file mode 100644
index 0000000..bbdcbc5
--- /dev/null
+++ b/node_modules/vue-demi/lib/index.d.ts
@@ -0,0 +1,33 @@
+import Vue from 'vue'
+import type { PluginFunction, PluginObject } from 'vue'
+declare const isVue2: boolean
+declare const isVue3: boolean
+declare const Vue2: typeof Vue | undefined
+declare const version: string
+declare const install: (vue?: typeof Vue) => void
+/**
+ * @deprecated To avoid bringing in all the tree-shakable modules, this API has been deprecated. Use `Vue2` or named exports instead.
+ * Refer to https://github.com/vueuse/vue-demi/issues/41
+ */
+declare const V: typeof Vue
+
+/**
+ * DebuggerEvent is a Vue 3 development only feature. This type cannot exist in Vue 2.
+ */
+export declare type DebuggerEvent = never
+
+// accept no generic because Vue 3 doesn't accept any
+// https://github.com/vuejs/vue-next/pull/2758/
+export declare type Plugin = PluginObject | PluginFunction
+export type { VNode } from 'vue'
+export * from '@vue/composition-api'
+export {
+ V as Vue,
+ Vue2,
+ isVue2,
+ isVue3,
+ version,
+ install,
+}
+
+export declare function hasInjectionContext(): boolean
diff --git a/node_modules/vue-demi/lib/index.iife.js b/node_modules/vue-demi/lib/index.iife.js
new file mode 100644
index 0000000..796c91f
--- /dev/null
+++ b/node_modules/vue-demi/lib/index.iife.js
@@ -0,0 +1,119 @@
+var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
+ if (VueDemi.install) {
+ return VueDemi
+ }
+ if (!Vue) {
+ console.error('[vue-demi] no Vue instance found, please be sure to import `vue` before `vue-demi`.')
+ return VueDemi
+ }
+
+ // Vue 2.7
+ if (Vue.version.slice(0, 4) === '2.7.') {
+ for (var key in Vue) {
+ VueDemi[key] = Vue[key]
+ }
+ VueDemi.isVue2 = true
+ VueDemi.isVue3 = false
+ VueDemi.install = function () {}
+ VueDemi.Vue = Vue
+ VueDemi.Vue2 = Vue
+ VueDemi.version = Vue.version
+ VueDemi.warn = Vue.util.warn
+ VueDemi.hasInjectionContext = function() {
+ return !!VueDemi.getCurrentInstance()
+ }
+ function createApp(rootComponent, rootProps) {
+ var vm
+ var provide = {}
+ var app = {
+ config: Vue.config,
+ use: Vue.use.bind(Vue),
+ mixin: Vue.mixin.bind(Vue),
+ component: Vue.component.bind(Vue),
+ provide: function (key, value) {
+ provide[key] = value
+ return this
+ },
+ directive: function (name, dir) {
+ if (dir) {
+ Vue.directive(name, dir)
+ return app
+ } else {
+ return Vue.directive(name)
+ }
+ },
+ mount: function (el, hydrating) {
+ if (!vm) {
+ vm = new Vue(Object.assign({ propsData: rootProps }, rootComponent, { provide: Object.assign(provide, rootComponent.provide) }))
+ vm.$mount(el, hydrating)
+ return vm
+ } else {
+ return vm
+ }
+ },
+ unmount: function () {
+ if (vm) {
+ vm.$destroy()
+ vm = undefined
+ }
+ },
+ }
+ return app
+ }
+ VueDemi.createApp = createApp
+ }
+ // Vue 2.6.x
+ else if (Vue.version.slice(0, 2) === '2.') {
+ if (VueCompositionAPI) {
+ for (var key in VueCompositionAPI) {
+ VueDemi[key] = VueCompositionAPI[key]
+ }
+ VueDemi.isVue2 = true
+ VueDemi.isVue3 = false
+ VueDemi.install = function () {}
+ VueDemi.Vue = Vue
+ VueDemi.Vue2 = Vue
+ VueDemi.version = Vue.version
+ VueDemi.hasInjectionContext = function() {
+ return !!VueDemi.getCurrentInstance()
+ }
+ } else {
+ console.error('[vue-demi] no VueCompositionAPI instance found, please be sure to import `@vue/composition-api` before `vue-demi`.')
+ }
+ }
+ // Vue 3
+ else if (Vue.version.slice(0, 2) === '3.') {
+ for (var key in Vue) {
+ VueDemi[key] = Vue[key]
+ }
+ VueDemi.isVue2 = false
+ VueDemi.isVue3 = true
+ VueDemi.install = function () {}
+ VueDemi.Vue = Vue
+ VueDemi.Vue2 = undefined
+ VueDemi.version = Vue.version
+ VueDemi.set = function (target, key, val) {
+ if (Array.isArray(target)) {
+ target.length = Math.max(target.length, key)
+ target.splice(key, 1, val)
+ return val
+ }
+ target[key] = val
+ return val
+ }
+ VueDemi.del = function (target, key) {
+ if (Array.isArray(target)) {
+ target.splice(key, 1)
+ return
+ }
+ delete target[key]
+ }
+ } else {
+ console.error('[vue-demi] Vue version ' + Vue.version + ' is unsupported.')
+ }
+ return VueDemi
+})(
+ ((globalThis || self).VueDemi = (globalThis || self).VueDemi || (typeof VueDemi !== 'undefined' ? VueDemi : {})),
+ (globalThis || self).Vue || (typeof Vue !== 'undefined' ? Vue : undefined),
+ (globalThis || self).VueCompositionAPI || (typeof VueCompositionAPI !== 'undefined' ? VueCompositionAPI : undefined)
+);
diff --git a/node_modules/vue-demi/lib/index.mjs b/node_modules/vue-demi/lib/index.mjs
new file mode 100644
index 0000000..2c18122
--- /dev/null
+++ b/node_modules/vue-demi/lib/index.mjs
@@ -0,0 +1,49 @@
+import Vue from 'vue'
+import VueCompositionAPI, { getCurrentInstance } from '@vue/composition-api/dist/vue-composition-api.mjs'
+
+function install(_vue) {
+ _vue = _vue || Vue
+ if (_vue && !_vue['__composition_api_installed__'])
+ _vue.use(VueCompositionAPI)
+}
+
+install(Vue)
+
+var isVue2 = true
+var isVue3 = false
+var Vue2 = Vue
+var version = Vue.version
+
+/**VCA-EXPORTS**/
+export * from '@vue/composition-api/dist/vue-composition-api.mjs'
+/**VCA-EXPORTS**/
+
+export {
+ Vue,
+ Vue2,
+ isVue2,
+ isVue3,
+ version,
+ install,
+}
+
+
+// Vue 3 components mock
+function createMockComponent(name) {
+ return {
+ setup() {
+ throw new Error('[vue-demi] ' + name + ' is not supported in Vue 2. It\'s provided to avoid compiler errors.')
+ }
+ }
+}
+export var Fragment = /*#__PURE__*/ createMockComponent('Fragment')
+export var Transition = /*#__PURE__*/ createMockComponent('Transition')
+export var TransitionGroup = /*#__PURE__*/ createMockComponent('TransitionGroup')
+export var Teleport = /*#__PURE__*/ createMockComponent('Teleport')
+export var Suspense = /*#__PURE__*/ createMockComponent('Suspense')
+export var KeepAlive = /*#__PURE__*/ createMockComponent('KeepAlive')
+
+// Not implemented https://github.com/vuejs/core/pull/8111, falls back to getCurrentInstance()
+export function hasInjectionContext() {
+ return !!getCurrentInstance()
+}
diff --git a/node_modules/vue-demi/lib/v2.7/index.cjs b/node_modules/vue-demi/lib/v2.7/index.cjs
new file mode 100644
index 0000000..8fa3b68
--- /dev/null
+++ b/node_modules/vue-demi/lib/v2.7/index.cjs
@@ -0,0 +1,60 @@
+var VueModule = require('vue')
+
+// get the real Vue https://github.com/vueuse/vue-demi/issues/192
+var Vue = VueModule.default || VueModule
+
+exports.Vue = Vue
+exports.Vue2 = Vue
+exports.isVue2 = true
+exports.isVue3 = false
+exports.install = function () {}
+exports.warn = Vue.util.warn
+
+// createApp polyfill
+exports.createApp = function (rootComponent, rootProps) {
+ var vm
+ var provide = {}
+ var app = {
+ config: Vue.config,
+ use: Vue.use.bind(Vue),
+ mixin: Vue.mixin.bind(Vue),
+ component: Vue.component.bind(Vue),
+ provide: function (key, value) {
+ provide[key] = value
+ return this
+ },
+ directive: function (name, dir) {
+ if (dir) {
+ Vue.directive(name, dir)
+ return app
+ } else {
+ return Vue.directive(name)
+ }
+ },
+ mount: function (el, hydrating) {
+ if (!vm) {
+ vm = new Vue(Object.assign({ propsData: rootProps }, rootComponent, { provide: Object.assign(provide, rootComponent.provide) }))
+ vm.$mount(el, hydrating)
+ return vm
+ } else {
+ return vm
+ }
+ },
+ unmount: function () {
+ if (vm) {
+ vm.$destroy()
+ vm = undefined
+ }
+ },
+ }
+ return app
+}
+
+Object.keys(VueModule).forEach(function (key) {
+ exports[key] = VueModule[key]
+})
+
+// Not implemented https://github.com/vuejs/core/pull/8111, falls back to getCurrentInstance()
+exports.hasInjectionContext = function() {
+ return !!VueModule.getCurrentInstance()
+}
\ No newline at end of file
diff --git a/node_modules/vue-demi/lib/v2.7/index.d.ts b/node_modules/vue-demi/lib/v2.7/index.d.ts
new file mode 100644
index 0000000..827c7b2
--- /dev/null
+++ b/node_modules/vue-demi/lib/v2.7/index.d.ts
@@ -0,0 +1,38 @@
+import Vue from 'vue'
+import type { PluginFunction, PluginObject, VueConstructor, Directive, InjectionKey, Component } from 'vue'
+
+declare const isVue2: boolean
+declare const isVue3: boolean
+declare const Vue2: typeof Vue | undefined
+declare const version: string
+declare const install: (vue?: typeof Vue) => void
+export declare function warn(msg: string, vm?: Component | null): void
+/**
+ * @deprecated To avoid bringing in all the tree-shakable modules, this API has been deprecated. Use `Vue2` or named exports instead.
+ * Refer to https://github.com/vueuse/vue-demi/issues/41
+ */
+declare const V: typeof Vue
+
+// accept no generic because Vue 3 doesn't accept any
+// https://github.com/vuejs/vue-next/pull/2758/
+export declare type Plugin = PluginObject | PluginFunction
+export type { VNode } from 'vue'
+export * from 'vue'
+export { V as Vue, Vue2, isVue2, isVue3, version, install }
+
+// #region createApp polyfill
+export interface App {
+ config: VueConstructor['config']
+ use: VueConstructor['use']
+ mixin: VueConstructor['mixin']
+ component: VueConstructor['component']
+ directive(name: string): Directive | undefined
+ directive(name: string, directive: Directive): this
+ provide
+
+