@samline/notify 0.2.7 → 1.0.0

package/dist/vue.mjs

@@ -0,0 +1,2096 @@
+import { _ as _extends } from './cc-he3fHS3P.mjs';
+
+/**
+* @vue/shared v3.5.31
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/ // @__NO_SIDE_EFFECTS__
+function makeMap(str) {
+    const map = /* @__PURE__ */ Object.create(null);
+    for (const key of str.split(","))map[key] = 1;
+    return (val)=>val in map;
+}
+const EMPTY_OBJ = !!(process.env.NODE_ENV !== "production") ? Object.freeze({}) : {};
+!!(process.env.NODE_ENV !== "production") ? Object.freeze([]) : [];
+const NOOP = ()=>{};
+const isOn = (key)=>key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
+    (key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
+const isModelListener = (key)=>key.startsWith("onUpdate:");
+const extend = Object.assign;
+const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+const hasOwn = (val, key)=>hasOwnProperty$1.call(val, key);
+const isArray = Array.isArray;
+const isMap = (val)=>toTypeString(val) === "[object Map]";
+const isFunction = (val)=>typeof val === "function";
+const isString = (val)=>typeof val === "string";
+const isSymbol = (val)=>typeof val === "symbol";
+const isObject = (val)=>val !== null && typeof val === "object";
+const isPromise = (val)=>{
+    return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value)=>objectToString.call(value);
+const toRawType = (value)=>{
+    return toTypeString(value).slice(8, -1);
+};
+const isIntegerKey = (key)=>isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+const cacheStringFunction = (fn)=>{
+    const cache = /* @__PURE__ */ Object.create(null);
+    return (str)=>{
+        const hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
+};
+const capitalize = cacheStringFunction((str)=>{
+    return str.charAt(0).toUpperCase() + str.slice(1);
+});
+const toHandlerKey = cacheStringFunction((str)=>{
+    const s = str ? `on${capitalize(str)}` : ``;
+    return s;
+});
+const hasChanged = (value, oldValue)=>!Object.is(value, oldValue);
+let _globalThis;
+const getGlobalThis = ()=>{
+    return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
+};
+function normalizeStyle(value) {
+    if (isArray(value)) {
+        const res = {};
+        for(let i = 0; i < value.length; i++){
+            const item = value[i];
+            const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
+            if (normalized) {
+                for(const key in normalized){
+                    res[key] = normalized[key];
+                }
+            }
+        }
+        return res;
+    } else if (isString(value) || isObject(value)) {
+        return value;
+    }
+}
+const listDelimiterRE = /;(?![^(]*\))/g;
+const propertyDelimiterRE = /:([^]+)/;
+const styleCommentRE = /\/\*[^]*?\*\//g;
+function parseStringStyle(cssText) {
+    const ret = {};
+    cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item)=>{
+        if (item) {
+            const tmp = item.split(propertyDelimiterRE);
+            tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return ret;
+}
+function normalizeClass(value) {
+    let res = "";
+    if (isString(value)) {
+        res = value;
+    } else if (isArray(value)) {
+        for(let i = 0; i < value.length; i++){
+            const normalized = normalizeClass(value[i]);
+            if (normalized) {
+                res += normalized + " ";
+            }
+        }
+    } else if (isObject(value)) {
+        for(const name in value){
+            if (value[name]) {
+                res += name + " ";
+            }
+        }
+    }
+    return res.trim();
+}
+
+function warn(msg, ...args) {
+    console.warn(`[Vue warn] ${msg}`, ...args);
+}
+let batchDepth = 0;
+let batchedSub;
+function startBatch() {
+    batchDepth++;
+}
+function endBatch() {
+    if (--batchDepth > 0) {
+        return;
+    }
+    let error;
+    while(batchedSub){
+        let e = batchedSub;
+        batchedSub = void 0;
+        while(e){
+            const next = e.next;
+            e.next = void 0;
+            e.flags &= -9;
+            if (e.flags & 1) {
+                try {
+                    ;
+                    e.trigger();
+                } catch (err) {
+                    if (!error) error = err;
+                }
+            }
+            e = next;
+        }
+    }
+    if (error) throw error;
+}
+class Dep {
+    track(debugInfo) {
+        {
+            return;
+        }
+    }
+    trigger(debugInfo) {
+        this.version++;
+        this.notify(debugInfo);
+    }
+    notify(debugInfo) {
+        startBatch();
+        try {
+            if (!!(process.env.NODE_ENV !== "production")) {
+                for(let head = this.subsHead; head; head = head.nextSub){
+                    if (head.sub.onTrigger && !(head.sub.flags & 8)) {
+                        head.sub.onTrigger(extend({
+                            effect: head.sub
+                        }, debugInfo));
+                    }
+                }
+            }
+            for(let link = this.subs; link; link = link.prevSub){
+                if (link.sub.notify()) {
+                    ;
+                    link.sub.dep.notify();
+                }
+            }
+        } finally{
+            endBatch();
+        }
+    }
+    // TODO isolatedDeclarations "__v_skip"
+    constructor(computed){
+        this.computed = computed;
+        this.version = 0;
+        /**
+     * Link between this dep and the current active effect
+     */ this.activeLink = void 0;
+        /**
+     * Doubly linked list representing the subscribing effects (tail)
+     */ this.subs = void 0;
+        /**
+     * For object property deps cleanup
+     */ this.map = void 0;
+        this.key = void 0;
+        /**
+     * Subscriber counter
+     */ this.sc = 0;
+        /**
+     * @internal
+     */ this.__v_skip = true;
+        if (!!(process.env.NODE_ENV !== "production")) {
+            this.subsHead = void 0;
+        }
+    }
+}
+const targetMap = /* @__PURE__ */ new WeakMap();
+const ITERATE_KEY = /* @__PURE__ */ Symbol(!!(process.env.NODE_ENV !== "production") ? "Object iterate" : "");
+const MAP_KEY_ITERATE_KEY = /* @__PURE__ */ Symbol(!!(process.env.NODE_ENV !== "production") ? "Map keys iterate" : "");
+const ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol(!!(process.env.NODE_ENV !== "production") ? "Array iterate" : "");
+function track(target, type, key) {
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+    const depsMap = targetMap.get(target);
+    if (!depsMap) {
+        return;
+    }
+    const run = (dep)=>{
+        if (dep) {
+            if (!!(process.env.NODE_ENV !== "production")) {
+                dep.trigger({
+                    target,
+                    type,
+                    key,
+                    newValue,
+                    oldValue,
+                    oldTarget
+                });
+            } else {
+                dep.trigger();
+            }
+        }
+    };
+    startBatch();
+    if (type === "clear") {
+        depsMap.forEach(run);
+    } else {
+        const targetIsArray = isArray(target);
+        const isArrayIndex = targetIsArray && isIntegerKey(key);
+        if (targetIsArray && key === "length") {
+            const newLength = Number(newValue);
+            depsMap.forEach((dep, key2)=>{
+                if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
+                    run(dep);
+                }
+            });
+        } else {
+            if (key !== void 0 || depsMap.has(void 0)) {
+                run(depsMap.get(key));
+            }
+            if (isArrayIndex) {
+                run(depsMap.get(ARRAY_ITERATE_KEY));
+            }
+            switch(type){
+                case "add":
+                    if (!targetIsArray) {
+                        run(depsMap.get(ITERATE_KEY));
+                        if (isMap(target)) {
+                            run(depsMap.get(MAP_KEY_ITERATE_KEY));
+                        }
+                    } else if (isArrayIndex) {
+                        run(depsMap.get("length"));
+                    }
+                    break;
+                case "delete":
+                    if (!targetIsArray) {
+                        run(depsMap.get(ITERATE_KEY));
+                        if (isMap(target)) {
+                            run(depsMap.get(MAP_KEY_ITERATE_KEY));
+                        }
+                    }
+                    break;
+                case "set":
+                    if (isMap(target)) {
+                        run(depsMap.get(ITERATE_KEY));
+                    }
+                    break;
+            }
+        }
+    }
+    endBatch();
+}
+function reactiveReadArray(array) {
+    const raw = toRaw(array);
+    if (raw === array) return raw;
+    return isShallow(array) ? raw : raw.map(toReactive);
+}
+function shallowReadArray(arr) {
+    track(arr = toRaw(arr));
+    return arr;
+}
+function toWrapped(target, item) {
+    if (isReadonly(target)) {
+        return isReactive(target) ? toReadonly(toReactive(item)) : toReadonly(item);
+    }
+    return toReactive(item);
+}
+const arrayInstrumentations = {
+    __proto__: null,
+    [Symbol.iterator] () {
+        return iterator(this, Symbol.iterator, (item)=>toWrapped(this, item));
+    },
+    concat (...args) {
+        return reactiveReadArray(this).concat(...args.map((x)=>isArray(x) ? reactiveReadArray(x) : x));
+    },
+    entries () {
+        return iterator(this, "entries", (value)=>{
+            value[1] = toWrapped(this, value[1]);
+            return value;
+        });
+    },
+    every (fn, thisArg) {
+        return apply(this, "every", fn, thisArg, void 0, arguments);
+    },
+    filter (fn, thisArg) {
+        return apply(this, "filter", fn, thisArg, (v)=>v.map((item)=>toWrapped(this, item)), arguments);
+    },
+    find (fn, thisArg) {
+        return apply(this, "find", fn, thisArg, (item)=>toWrapped(this, item), arguments);
+    },
+    findIndex (fn, thisArg) {
+        return apply(this, "findIndex", fn, thisArg, void 0, arguments);
+    },
+    findLast (fn, thisArg) {
+        return apply(this, "findLast", fn, thisArg, (item)=>toWrapped(this, item), arguments);
+    },
+    findLastIndex (fn, thisArg) {
+        return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
+    },
+    // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
+    forEach (fn, thisArg) {
+        return apply(this, "forEach", fn, thisArg, void 0, arguments);
+    },
+    includes (...args) {
+        return searchProxy(this, "includes", args);
+    },
+    indexOf (...args) {
+        return searchProxy(this, "indexOf", args);
+    },
+    join (separator) {
+        return reactiveReadArray(this).join(separator);
+    },
+    // keys() iterator only reads `length`, no optimization required
+    lastIndexOf (...args) {
+        return searchProxy(this, "lastIndexOf", args);
+    },
+    map (fn, thisArg) {
+        return apply(this, "map", fn, thisArg, void 0, arguments);
+    },
+    pop () {
+        return noTracking(this, "pop");
+    },
+    push (...args) {
+        return noTracking(this, "push", args);
+    },
+    reduce (fn, ...args) {
+        return reduce(this, "reduce", fn, args);
+    },
+    reduceRight (fn, ...args) {
+        return reduce(this, "reduceRight", fn, args);
+    },
+    shift () {
+        return noTracking(this, "shift");
+    },
+    // slice could use ARRAY_ITERATE but also seems to beg for range tracking
+    some (fn, thisArg) {
+        return apply(this, "some", fn, thisArg, void 0, arguments);
+    },
+    splice (...args) {
+        return noTracking(this, "splice", args);
+    },
+    toReversed () {
+        return reactiveReadArray(this).toReversed();
+    },
+    toSorted (comparer) {
+        return reactiveReadArray(this).toSorted(comparer);
+    },
+    toSpliced (...args) {
+        return reactiveReadArray(this).toSpliced(...args);
+    },
+    unshift (...args) {
+        return noTracking(this, "unshift", args);
+    },
+    values () {
+        return iterator(this, "values", (item)=>toWrapped(this, item));
+    }
+};
+function iterator(self, method, wrapValue) {
+    const arr = shallowReadArray(self);
+    const iter = arr[method]();
+    if (arr !== self && !isShallow(self)) {
+        iter._next = iter.next;
+        iter.next = ()=>{
+            const result = iter._next();
+            if (!result.done) {
+                result.value = wrapValue(result.value);
+            }
+            return result;
+        };
+    }
+    return iter;
+}
+const arrayProto = Array.prototype;
+function apply(self, method, fn, thisArg, wrappedRetFn, args) {
+    const arr = shallowReadArray(self);
+    const needsWrap = arr !== self && !isShallow(self);
+    const methodFn = arr[method];
+    if (methodFn !== arrayProto[method]) {
+        const result2 = methodFn.apply(self, args);
+        return needsWrap ? toReactive(result2) : result2;
+    }
+    let wrappedFn = fn;
+    if (arr !== self) {
+        if (needsWrap) {
+            wrappedFn = function(item, index) {
+                return fn.call(this, toWrapped(self, item), index, self);
+            };
+        } else if (fn.length > 2) {
+            wrappedFn = function(item, index) {
+                return fn.call(this, item, index, self);
+            };
+        }
+    }
+    const result = methodFn.call(arr, wrappedFn, thisArg);
+    return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
+}
+function reduce(self, method, fn, args) {
+    const arr = shallowReadArray(self);
+    const needsWrap = arr !== self && !isShallow(self);
+    let wrappedFn = fn;
+    let wrapInitialAccumulator = false;
+    if (arr !== self) {
+        if (needsWrap) {
+            wrapInitialAccumulator = args.length === 0;
+            wrappedFn = function(acc, item, index) {
+                if (wrapInitialAccumulator) {
+                    wrapInitialAccumulator = false;
+                    acc = toWrapped(self, acc);
+                }
+                return fn.call(this, acc, toWrapped(self, item), index, self);
+            };
+        } else if (fn.length > 3) {
+            wrappedFn = function(acc, item, index) {
+                return fn.call(this, acc, item, index, self);
+            };
+        }
+    }
+    const result = arr[method](wrappedFn, ...args);
+    return wrapInitialAccumulator ? toWrapped(self, result) : result;
+}
+function searchProxy(self, method, args) {
+    const arr = toRaw(self);
+    const res = arr[method](...args);
+    if ((res === -1 || res === false) && isProxy(args[0])) {
+        args[0] = toRaw(args[0]);
+        return arr[method](...args);
+    }
+    return res;
+}
+function noTracking(self, method, args = []) {
+    startBatch();
+    const res = toRaw(self)[method].apply(self, args);
+    endBatch();
+    return res;
+}
+const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
+const builtInSymbols = new Set(/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key)=>key !== "arguments" && key !== "caller").map((key)=>Symbol[key]).filter(isSymbol));
+function hasOwnProperty(key) {
+    if (!isSymbol(key)) key = String(key);
+    const obj = toRaw(this);
+    return obj.hasOwnProperty(key);
+}
+class BaseReactiveHandler {
+    get(target, key, receiver) {
+        if (key === "__v_skip") return target["__v_skip"];
+        const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
+        if (key === "__v_isReactive") {
+            return !isReadonly2;
+        } else if (key === "__v_isReadonly") {
+            return isReadonly2;
+        } else if (key === "__v_isShallow") {
+            return isShallow2;
+        } else if (key === "__v_raw") {
+            if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
+            // this means the receiver is a user proxy of the reactive proxy
+            Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
+                return target;
+            }
+            return;
+        }
+        const targetIsArray = isArray(target);
+        if (!isReadonly2) {
+            let fn;
+            if (targetIsArray && (fn = arrayInstrumentations[key])) {
+                return fn;
+            }
+            if (key === "hasOwnProperty") {
+                return hasOwnProperty;
+            }
+        }
+        const res = Reflect.get(target, key, // if this is a proxy wrapping a ref, return methods using the raw ref
+        // as receiver so that we don't have to call `toRaw` on the ref in all
+        // its class methods
+        isRef(target) ? target : receiver);
+        if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+            return res;
+        }
+        if (isShallow2) {
+            return res;
+        }
+        if (isRef(res)) {
+            const value = targetIsArray && isIntegerKey(key) ? res : res.value;
+            return isReadonly2 && isObject(value) ? readonly(value) : value;
+        }
+        if (isObject(res)) {
+            return isReadonly2 ? readonly(res) : reactive(res);
+        }
+        return res;
+    }
+    constructor(_isReadonly = false, _isShallow = false){
+        this._isReadonly = _isReadonly;
+        this._isShallow = _isShallow;
+    }
+}
+class MutableReactiveHandler extends BaseReactiveHandler {
+    set(target, key, value, receiver) {
+        let oldValue = target[key];
+        const isArrayWithIntegerKey = isArray(target) && isIntegerKey(key);
+        if (!this._isShallow) {
+            const isOldValueReadonly = isReadonly(oldValue);
+            if (!isShallow(value) && !isReadonly(value)) {
+                oldValue = toRaw(oldValue);
+                value = toRaw(value);
+            }
+            if (!isArrayWithIntegerKey && isRef(oldValue) && !isRef(value)) {
+                if (isOldValueReadonly) {
+                    if (!!(process.env.NODE_ENV !== "production")) {
+                        warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target[key]);
+                    }
+                    return true;
+                } else {
+                    oldValue.value = value;
+                    return true;
+                }
+            }
+        }
+        const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : hasOwn(target, key);
+        const result = Reflect.set(target, key, value, isRef(target) ? target : receiver);
+        if (target === toRaw(receiver)) {
+            if (!hadKey) {
+                trigger(target, "add", key, value);
+            } else if (hasChanged(value, oldValue)) {
+                trigger(target, "set", key, value, oldValue);
+            }
+        }
+        return result;
+    }
+    deleteProperty(target, key) {
+        const hadKey = hasOwn(target, key);
+        const oldValue = target[key];
+        const result = Reflect.deleteProperty(target, key);
+        if (result && hadKey) {
+            trigger(target, "delete", key, void 0, oldValue);
+        }
+        return result;
+    }
+    has(target, key) {
+        const result = Reflect.has(target, key);
+        if (!isSymbol(key) || !builtInSymbols.has(key)) ;
+        return result;
+    }
+    ownKeys(target) {
+        return Reflect.ownKeys(target);
+    }
+    constructor(isShallow2 = false){
+        super(false, isShallow2);
+    }
+}
+class ReadonlyReactiveHandler extends BaseReactiveHandler {
+    set(target, key) {
+        if (!!(process.env.NODE_ENV !== "production")) {
+            warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
+        }
+        return true;
+    }
+    deleteProperty(target, key) {
+        if (!!(process.env.NODE_ENV !== "production")) {
+            warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
+        }
+        return true;
+    }
+    constructor(isShallow2 = false){
+        super(true, isShallow2);
+    }
+}
+const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
+const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
+const toShallow = (value)=>value;
+const getProto = (v)=>Reflect.getPrototypeOf(v);
+function createIterableMethod(method, isReadonly2, isShallow2) {
+    return function(...args) {
+        const target = this["__v_raw"];
+        const rawTarget = toRaw(target);
+        const targetIsMap = isMap(rawTarget);
+        const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+        const innerIterator = target[method](...args);
+        const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+        return extend(// inheriting all iterator properties
+        Object.create(innerIterator), {
+            // iterator protocol
+            next () {
+                const { value, done } = innerIterator.next();
+                return done ? {
+                    value,
+                    done
+                } : {
+                    value: isPair ? [
+                        wrap(value[0]),
+                        wrap(value[1])
+                    ] : wrap(value),
+                    done
+                };
+            }
+        });
+    };
+}
+function createReadonlyMethod(type) {
+    return function(...args) {
+        if (!!(process.env.NODE_ENV !== "production")) {
+            const key = args[0] ? `on key "${args[0]}" ` : ``;
+            warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
+        }
+        return type === "delete" ? false : type === "clear" ? void 0 : this;
+    };
+}
+function createInstrumentations(readonly, shallow) {
+    const instrumentations = {
+        get (key) {
+            const target = this["__v_raw"];
+            const rawTarget = toRaw(target);
+            const rawKey = toRaw(key);
+            const { has } = getProto(rawTarget);
+            const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
+            if (has.call(rawTarget, key)) {
+                return wrap(target.get(key));
+            } else if (has.call(rawTarget, rawKey)) {
+                return wrap(target.get(rawKey));
+            } else if (target !== rawTarget) {
+                target.get(key);
+            }
+        },
+        get size () {
+            const target = this["__v_raw"];
+            return target.size;
+        },
+        has (key) {
+            const target = this["__v_raw"];
+            const rawKey = toRaw(key);
+            return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+        },
+        forEach (callback, thisArg) {
+            const observed = this;
+            const target = observed["__v_raw"];
+            const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
+            return target.forEach((value, key)=>{
+                return callback.call(thisArg, wrap(value), wrap(key), observed);
+            });
+        }
+    };
+    extend(instrumentations, readonly ? {
+        add: createReadonlyMethod("add"),
+        set: createReadonlyMethod("set"),
+        delete: createReadonlyMethod("delete"),
+        clear: createReadonlyMethod("clear")
+    } : {
+        add (value) {
+            const target = toRaw(this);
+            const proto = getProto(target);
+            const rawValue = toRaw(value);
+            const valueToAdd = !shallow && !isShallow(value) && !isReadonly(value) ? rawValue : value;
+            const hadKey = proto.has.call(target, valueToAdd) || hasChanged(value, valueToAdd) && proto.has.call(target, value) || hasChanged(rawValue, valueToAdd) && proto.has.call(target, rawValue);
+            if (!hadKey) {
+                target.add(valueToAdd);
+                trigger(target, "add", valueToAdd, valueToAdd);
+            }
+            return this;
+        },
+        set (key, value) {
+            if (!shallow && !isShallow(value) && !isReadonly(value)) {
+                value = toRaw(value);
+            }
+            const target = toRaw(this);
+            const { has, get } = getProto(target);
+            let hadKey = has.call(target, key);
+            if (!hadKey) {
+                key = toRaw(key);
+                hadKey = has.call(target, key);
+            } else if (!!(process.env.NODE_ENV !== "production")) {
+                checkIdentityKeys(target, has, key);
+            }
+            const oldValue = get.call(target, key);
+            target.set(key, value);
+            if (!hadKey) {
+                trigger(target, "add", key, value);
+            } else if (hasChanged(value, oldValue)) {
+                trigger(target, "set", key, value, oldValue);
+            }
+            return this;
+        },
+        delete (key) {
+            const target = toRaw(this);
+            const { has, get } = getProto(target);
+            let hadKey = has.call(target, key);
+            if (!hadKey) {
+                key = toRaw(key);
+                hadKey = has.call(target, key);
+            } else if (!!(process.env.NODE_ENV !== "production")) {
+                checkIdentityKeys(target, has, key);
+            }
+            const oldValue = get ? get.call(target, key) : void 0;
+            const result = target.delete(key);
+            if (hadKey) {
+                trigger(target, "delete", key, void 0, oldValue);
+            }
+            return result;
+        },
+        clear () {
+            const target = toRaw(this);
+            const hadItems = target.size !== 0;
+            const oldTarget = !!(process.env.NODE_ENV !== "production") ? isMap(target) ? new Map(target) : new Set(target) : void 0;
+            const result = target.clear();
+            if (hadItems) {
+                trigger(target, "clear", void 0, void 0, oldTarget);
+            }
+            return result;
+        }
+    });
+    const iteratorMethods = [
+        "keys",
+        "values",
+        "entries",
+        Symbol.iterator
+    ];
+    iteratorMethods.forEach((method)=>{
+        instrumentations[method] = createIterableMethod(method, readonly, shallow);
+    });
+    return instrumentations;
+}
+function createInstrumentationGetter(isReadonly2, shallow) {
+    const instrumentations = createInstrumentations(isReadonly2, shallow);
+    return (target, key, receiver)=>{
+        if (key === "__v_isReactive") {
+            return !isReadonly2;
+        } else if (key === "__v_isReadonly") {
+            return isReadonly2;
+        } else if (key === "__v_raw") {
+            return target;
+        }
+        return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
+    };
+}
+const mutableCollectionHandlers = {
+    get: /* @__PURE__ */ createInstrumentationGetter(false, false)
+};
+const readonlyCollectionHandlers = {
+    get: /* @__PURE__ */ createInstrumentationGetter(true, false)
+};
+function checkIdentityKeys(target, has, key) {
+    const rawKey = toRaw(key);
+    if (rawKey !== key && has.call(target, rawKey)) {
+        const type = toRawType(target);
+        warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`);
+    }
+}
+const reactiveMap = /* @__PURE__ */ new WeakMap();
+const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+const readonlyMap = /* @__PURE__ */ new WeakMap();
+const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
+function targetTypeMap(rawType) {
+    switch(rawType){
+        case "Object":
+        case "Array":
+            return 1 /* COMMON */ ;
+        case "Map":
+        case "Set":
+        case "WeakMap":
+        case "WeakSet":
+            return 2 /* COLLECTION */ ;
+        default:
+            return 0 /* INVALID */ ;
+    }
+}
+function getTargetType(value) {
+    return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */  : targetTypeMap(toRawType(value));
+}
+// @__NO_SIDE_EFFECTS__
+function reactive(target) {
+    if (/* @__PURE__ */ isReadonly(target)) {
+        return target;
+    }
+    return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
+}
+// @__NO_SIDE_EFFECTS__
+function readonly(target) {
+    return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
+}
+function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+    if (!isObject(target)) {
+        if (!!(process.env.NODE_ENV !== "production")) {
+            warn(`value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(target)}`);
+        }
+        return target;
+    }
+    if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
+        return target;
+    }
+    const targetType = getTargetType(target);
+    if (targetType === 0 /* INVALID */ ) {
+        return target;
+    }
+    const existingProxy = proxyMap.get(target);
+    if (existingProxy) {
+        return existingProxy;
+    }
+    const proxy = new Proxy(target, targetType === 2 /* COLLECTION */  ? collectionHandlers : baseHandlers);
+    proxyMap.set(target, proxy);
+    return proxy;
+}
+// @__NO_SIDE_EFFECTS__
+function isReactive(value) {
+    if (/* @__PURE__ */ isReadonly(value)) {
+        return /* @__PURE__ */ isReactive(value["__v_raw"]);
+    }
+    return !!(value && value["__v_isReactive"]);
+}
+// @__NO_SIDE_EFFECTS__
+function isReadonly(value) {
+    return !!(value && value["__v_isReadonly"]);
+}
+// @__NO_SIDE_EFFECTS__
+function isShallow(value) {
+    return !!(value && value["__v_isShallow"]);
+}
+// @__NO_SIDE_EFFECTS__
+function isProxy(value) {
+    return value ? !!value["__v_raw"] : false;
+}
+// @__NO_SIDE_EFFECTS__
+function toRaw(observed) {
+    const raw = observed && observed["__v_raw"];
+    return raw ? /* @__PURE__ */ toRaw(raw) : observed;
+}
+const toReactive = (value)=>isObject(value) ? /* @__PURE__ */ reactive(value) : value;
+const toReadonly = (value)=>isObject(value) ? /* @__PURE__ */ readonly(value) : value;
+// @__NO_SIDE_EFFECTS__
+function isRef(r) {
+    return r ? r["__v_isRef"] === true : false;
+}
+// @__NO_SIDE_EFFECTS__
+function ref(value) {
+    return createRef(value, false);
+}
+function createRef(rawValue, shallow) {
+    if (/* @__PURE__ */ isRef(rawValue)) {
+        return rawValue;
+    }
+    return new RefImpl(rawValue, shallow);
+}
+class RefImpl {
+    get value() {
+        if (!!(process.env.NODE_ENV !== "production")) {
+            this.dep.track({
+                target: this,
+                type: "get",
+                key: "value"
+            });
+        } else {
+            this.dep.track();
+        }
+        return this._value;
+    }
+    set value(newValue) {
+        const oldValue = this._rawValue;
+        const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
+        newValue = useDirectValue ? newValue : toRaw(newValue);
+        if (hasChanged(newValue, oldValue)) {
+            this._rawValue = newValue;
+            this._value = useDirectValue ? newValue : toReactive(newValue);
+            if (!!(process.env.NODE_ENV !== "production")) {
+                this.dep.trigger({
+                    target: this,
+                    type: "set",
+                    key: "value",
+                    newValue,
+                    oldValue
+                });
+            } else {
+                this.dep.trigger();
+            }
+        }
+    }
+    constructor(value, isShallow2){
+        this.dep = new Dep();
+        this["__v_isRef"] = true;
+        this["__v_isShallow"] = false;
+        this._rawValue = isShallow2 ? value : toRaw(value);
+        this._value = isShallow2 ? value : toReactive(value);
+        this["__v_isShallow"] = isShallow2;
+    }
+}
+
+const stack = [];
+function pushWarningContext(vnode) {
+    stack.push(vnode);
+}
+function popWarningContext() {
+    stack.pop();
+}
+let isWarning = false;
+function warn$1(msg, ...args) {
+    if (isWarning) return;
+    isWarning = true;
+    const instance = stack.length ? stack[stack.length - 1].component : null;
+    const appWarnHandler = instance && instance.appContext.config.warnHandler;
+    const trace = getComponentTrace();
+    if (appWarnHandler) {
+        callWithErrorHandling(appWarnHandler, instance, 11, [
+            // eslint-disable-next-line no-restricted-syntax
+            msg + args.map((a)=>{
+                var _a, _b;
+                return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
+            }).join(""),
+            instance && instance.proxy,
+            trace.map(({ vnode })=>`at <${formatComponentName(instance, vnode.type)}>`).join("\n"),
+            trace
+        ]);
+    } else {
+        const warnArgs = [
+            `[Vue warn]: ${msg}`,
+            ...args
+        ];
+        if (trace.length && // avoid spamming console during tests
+        true) {
+            warnArgs.push(`
+`, ...formatTrace(trace));
+        }
+        console.warn(...warnArgs);
+    }
+    isWarning = false;
+}
+function getComponentTrace() {
+    let currentVNode = stack[stack.length - 1];
+    if (!currentVNode) {
+        return [];
+    }
+    const normalizedStack = [];
+    while(currentVNode){
+        const last = normalizedStack[0];
+        if (last && last.vnode === currentVNode) {
+            last.recurseCount++;
+        } else {
+            normalizedStack.push({
+                vnode: currentVNode,
+                recurseCount: 0
+            });
+        }
+        const parentInstance = currentVNode.component && currentVNode.component.parent;
+        currentVNode = parentInstance && parentInstance.vnode;
+    }
+    return normalizedStack;
+}
+function formatTrace(trace) {
+    const logs = [];
+    trace.forEach((entry, i)=>{
+        logs.push(...i === 0 ? [] : [
+            `
+`
+        ], ...formatTraceEntry(entry));
+    });
+    return logs;
+}
+function formatTraceEntry({ vnode, recurseCount }) {
+    const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
+    const isRoot = vnode.component ? vnode.component.parent == null : false;
+    const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;
+    const close = `>` + postfix;
+    return vnode.props ? [
+        open,
+        ...formatProps(vnode.props),
+        close
+    ] : [
+        open + close
+    ];
+}
+function formatProps(props) {
+    const res = [];
+    const keys = Object.keys(props);
+    keys.slice(0, 3).forEach((key)=>{
+        res.push(...formatProp(key, props[key]));
+    });
+    if (keys.length > 3) {
+        res.push(` ...`);
+    }
+    return res;
+}
+function formatProp(key, value, raw) {
+    if (isString(value)) {
+        value = JSON.stringify(value);
+        return raw ? value : [
+            `${key}=${value}`
+        ];
+    } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
+        return raw ? value : [
+            `${key}=${value}`
+        ];
+    } else if (isRef(value)) {
+        value = formatProp(key, toRaw(value.value), true);
+        return raw ? value : [
+            `${key}=Ref<`,
+            value,
+            `>`
+        ];
+    } else if (isFunction(value)) {
+        return [
+            `${key}=fn${value.name ? `<${value.name}>` : ``}`
+        ];
+    } else {
+        value = toRaw(value);
+        return raw ? value : [
+            `${key}=`,
+            value
+        ];
+    }
+}
+const ErrorTypeStrings$1 = {
+    ["sp"]: "serverPrefetch hook",
+    ["bc"]: "beforeCreate hook",
+    ["c"]: "created hook",
+    ["bm"]: "beforeMount hook",
+    ["m"]: "mounted hook",
+    ["bu"]: "beforeUpdate hook",
+    ["u"]: "updated",
+    ["bum"]: "beforeUnmount hook",
+    ["um"]: "unmounted hook",
+    ["a"]: "activated hook",
+    ["da"]: "deactivated hook",
+    ["ec"]: "errorCaptured hook",
+    ["rtc"]: "renderTracked hook",
+    ["rtg"]: "renderTriggered hook",
+    [0]: "setup function",
+    [1]: "render function",
+    [2]: "watcher getter",
+    [3]: "watcher callback",
+    [4]: "watcher cleanup function",
+    [5]: "native event handler",
+    [6]: "component event handler",
+    [7]: "vnode hook",
+    [8]: "directive hook",
+    [9]: "transition hook",
+    [10]: "app errorHandler",
+    [11]: "app warnHandler",
+    [12]: "ref function",
+    [13]: "async component loader",
+    [14]: "scheduler flush",
+    [15]: "component update",
+    [16]: "app unmount cleanup function"
+};
+function callWithErrorHandling(fn, instance, type, args) {
+    try {
+        return args ? fn(...args) : fn();
+    } catch (err) {
+        handleError(err, instance, type);
+    }
+}
+function callWithAsyncErrorHandling(fn, instance, type, args) {
+    if (isFunction(fn)) {
+        const res = callWithErrorHandling(fn, instance, type, args);
+        if (res && isPromise(res)) {
+            res.catch((err)=>{
+                handleError(err, instance, type);
+            });
+        }
+        return res;
+    }
+    if (isArray(fn)) {
+        const values = [];
+        for(let i = 0; i < fn.length; i++){
+            values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
+        }
+        return values;
+    } else if (!!(process.env.NODE_ENV !== "production")) {
+        warn$1(`Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}`);
+    }
+}
+function handleError(err, instance, type, throwInDev = true) {
+    const contextVNode = instance ? instance.vnode : null;
+    const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
+    if (instance) {
+        let cur = instance.parent;
+        const exposedInstance = instance.proxy;
+        const errorInfo = !!(process.env.NODE_ENV !== "production") ? ErrorTypeStrings$1[type] : `https://vuejs.org/error-reference/#runtime-${type}`;
+        while(cur){
+            const errorCapturedHooks = cur.ec;
+            if (errorCapturedHooks) {
+                for(let i = 0; i < errorCapturedHooks.length; i++){
+                    if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
+                        return;
+                    }
+                }
+            }
+            cur = cur.parent;
+        }
+        if (errorHandler) {
+            callWithErrorHandling(errorHandler, null, 10, [
+                err,
+                exposedInstance,
+                errorInfo
+            ]);
+            return;
+        }
+    }
+    logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
+}
+function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
+    if (!!(process.env.NODE_ENV !== "production")) {
+        const info = ErrorTypeStrings$1[type];
+        if (contextVNode) {
+            pushWarningContext(contextVNode);
+        }
+        warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+        if (contextVNode) {
+            popWarningContext();
+        }
+        if (throwInDev) {
+            throw err;
+        } else {
+            console.error(err);
+        }
+    } else if (throwInProd) {
+        throw err;
+    } else {
+        console.error(err);
+    }
+}
+const queue = [];
+let flushIndex = -1;
+const pendingPostFlushCbs = [];
+let activePostFlushCbs = null;
+let postFlushIndex = 0;
+const resolvedPromise = /* @__PURE__ */ Promise.resolve();
+let currentFlushPromise = null;
+const RECURSION_LIMIT = 100;
+function findInsertionIndex(id) {
+    let start = flushIndex + 1;
+    let end = queue.length;
+    while(start < end){
+        const middle = start + end >>> 1;
+        const middleJob = queue[middle];
+        const middleJobId = getId(middleJob);
+        if (middleJobId < id || middleJobId === id && middleJob.flags & 2) {
+            start = middle + 1;
+        } else {
+            end = middle;
+        }
+    }
+    return start;
+}
+function queueJob(job) {
+    if (!(job.flags & 1)) {
+        const jobId = getId(job);
+        const lastJob = queue[queue.length - 1];
+        if (!lastJob || // fast path when the job id is larger than the tail
+        !(job.flags & 2) && jobId >= getId(lastJob)) {
+            queue.push(job);
+        } else {
+            queue.splice(findInsertionIndex(jobId), 0, job);
+        }
+        job.flags |= 1;
+        queueFlush();
+    }
+}
+function queueFlush() {
+    if (!currentFlushPromise) {
+        currentFlushPromise = resolvedPromise.then(flushJobs);
+    }
+}
+function queuePostFlushCb(cb) {
+    if (!isArray(cb)) {
+        if (activePostFlushCbs && cb.id === -1) {
+            activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
+        } else if (!(cb.flags & 1)) {
+            pendingPostFlushCbs.push(cb);
+            cb.flags |= 1;
+        }
+    } else {
+        pendingPostFlushCbs.push(...cb);
+    }
+    queueFlush();
+}
+function flushPostFlushCbs(seen) {
+    if (pendingPostFlushCbs.length) {
+        const deduped = [
+            ...new Set(pendingPostFlushCbs)
+        ].sort((a, b)=>getId(a) - getId(b));
+        pendingPostFlushCbs.length = 0;
+        if (activePostFlushCbs) {
+            activePostFlushCbs.push(...deduped);
+            return;
+        }
+        activePostFlushCbs = deduped;
+        if (!!(process.env.NODE_ENV !== "production")) {
+            seen = seen || /* @__PURE__ */ new Map();
+        }
+        for(postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++){
+            const cb = activePostFlushCbs[postFlushIndex];
+            if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates(seen, cb)) {
+                continue;
+            }
+            if (cb.flags & 4) {
+                cb.flags &= -2;
+            }
+            if (!(cb.flags & 8)) cb();
+            cb.flags &= -2;
+        }
+        activePostFlushCbs = null;
+        postFlushIndex = 0;
+    }
+}
+const getId = (job)=>job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
+function flushJobs(seen) {
+    if (!!(process.env.NODE_ENV !== "production")) {
+        seen = seen || /* @__PURE__ */ new Map();
+    }
+    const check = !!(process.env.NODE_ENV !== "production") ? (job)=>checkRecursiveUpdates(seen, job) : NOOP;
+    try {
+        for(flushIndex = 0; flushIndex < queue.length; flushIndex++){
+            const job = queue[flushIndex];
+            if (job && !(job.flags & 8)) {
+                if (!!(process.env.NODE_ENV !== "production") && check(job)) {
+                    continue;
+                }
+                if (job.flags & 4) {
+                    job.flags &= ~1;
+                }
+                callWithErrorHandling(job, job.i, job.i ? 15 : 14);
+                if (!(job.flags & 4)) {
+                    job.flags &= ~1;
+                }
+            }
+        }
+    } finally{
+        for(; flushIndex < queue.length; flushIndex++){
+            const job = queue[flushIndex];
+            if (job) {
+                job.flags &= -2;
+            }
+        }
+        flushIndex = -1;
+        queue.length = 0;
+        flushPostFlushCbs(seen);
+        currentFlushPromise = null;
+        if (queue.length || pendingPostFlushCbs.length) {
+            flushJobs(seen);
+        }
+    }
+}
+function checkRecursiveUpdates(seen, fn) {
+    const count = seen.get(fn) || 0;
+    if (count > RECURSION_LIMIT) {
+        const instance = fn.i;
+        const componentName = instance && getComponentName(instance.type);
+        handleError(`Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`, null, 10);
+        return true;
+    }
+    seen.set(fn, count + 1);
+    return false;
+}
+const hmrDirtyComponents = /* @__PURE__ */ new Map();
+if (!!(process.env.NODE_ENV !== "production")) {
+    getGlobalThis().__VUE_HMR_RUNTIME__ = {
+        createRecord: tryWrap(createRecord),
+        rerender: tryWrap(rerender),
+        reload: tryWrap(reload)
+    };
+}
+const map = /* @__PURE__ */ new Map();
+function createRecord(id, initialDef) {
+    if (map.has(id)) {
+        return false;
+    }
+    map.set(id, {
+        initialDef: normalizeClassComponent(initialDef),
+        instances: /* @__PURE__ */ new Set()
+    });
+    return true;
+}
+function normalizeClassComponent(component) {
+    return isClassComponent(component) ? component.__vccOpts : component;
+}
+function rerender(id, newRender) {
+    const record = map.get(id);
+    if (!record) {
+        return;
+    }
+    record.initialDef.render = newRender;
+    [
+        ...record.instances
+    ].forEach((instance)=>{
+        if (newRender) {
+            instance.render = newRender;
+            normalizeClassComponent(instance.type).render = newRender;
+        }
+        instance.renderCache = [];
+        if (!(instance.job.flags & 8)) {
+            instance.update();
+        }
+    });
+}
+function reload(id, newComp) {
+    const record = map.get(id);
+    if (!record) return;
+    newComp = normalizeClassComponent(newComp);
+    updateComponentDef(record.initialDef, newComp);
+    const instances = [
+        ...record.instances
+    ];
+    for(let i = 0; i < instances.length; i++){
+        const instance = instances[i];
+        const oldComp = normalizeClassComponent(instance.type);
+        let dirtyInstances = hmrDirtyComponents.get(oldComp);
+        if (!dirtyInstances) {
+            if (oldComp !== record.initialDef) {
+                updateComponentDef(oldComp, newComp);
+            }
+            hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());
+        }
+        dirtyInstances.add(instance);
+        instance.appContext.propsCache.delete(instance.type);
+        instance.appContext.emitsCache.delete(instance.type);
+        instance.appContext.optionsCache.delete(instance.type);
+        if (instance.ceReload) {
+            dirtyInstances.add(instance);
+            instance.ceReload(newComp.styles);
+            dirtyInstances.delete(instance);
+        } else if (instance.parent) {
+            queueJob(()=>{
+                if (!(instance.job.flags & 8)) {
+                    instance.parent.update();
+                    dirtyInstances.delete(instance);
+                }
+            });
+        } else if (instance.appContext.reload) {
+            instance.appContext.reload();
+        } else if (typeof window !== "undefined") {
+            window.location.reload();
+        } else {
+            console.warn("[HMR] Root or manually mounted instance modified. Full reload required.");
+        }
+        if (instance.root.ce && instance !== instance.root) {
+            instance.root.ce._removeChildStyle(oldComp);
+        }
+    }
+    queuePostFlushCb(()=>{
+        hmrDirtyComponents.clear();
+    });
+}
+function updateComponentDef(oldComp, newComp) {
+    extend(oldComp, newComp);
+    for(const key in oldComp){
+        if (key !== "__file" && !(key in newComp)) {
+            delete oldComp[key];
+        }
+    }
+}
+function tryWrap(fn) {
+    return (id, arg)=>{
+        try {
+            return fn(id, arg);
+        } catch (e) {
+            console.error(e);
+            console.warn(`[HMR] Something went wrong during Vue component hot-reload. Full reload required.`);
+        }
+    };
+}
+let devtools$1;
+let buffer = [];
+function setDevtoolsHook$1(hook, target) {
+    var _a, _b;
+    devtools$1 = hook;
+    if (devtools$1) {
+        devtools$1.enabled = true;
+        buffer.forEach(({ event, args })=>devtools$1.emit(event, ...args));
+        buffer = [];
+    } else if (// handle late devtools injection - only do this if we are in an actual
+    // browser environment to avoid the timer handle stalling test runner exit
+    // (#4815)
+    typeof window !== "undefined" && // some envs mock window but not fully
+    window.HTMLElement && // also exclude jsdom
+    // eslint-disable-next-line no-restricted-syntax
+    !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))) {
+        const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
+        replay.push((newHook)=>{
+            setDevtoolsHook$1(newHook, target);
+        });
+        setTimeout(()=>{
+            if (!devtools$1) {
+                target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
+                buffer = [];
+            }
+        }, 3e3);
+    } else {
+        buffer = [];
+    }
+}
+let currentRenderingInstance = null;
+let currentScopeId = null;
+const isTeleport = (type)=>type.__isTeleport;
+function setTransitionHooks(vnode, hooks) {
+    if (vnode.shapeFlag & 6 && vnode.component) {
+        vnode.transition = hooks;
+        setTransitionHooks(vnode.component.subTree, hooks);
+    } else if (vnode.shapeFlag & 128) {
+        vnode.ssContent.transition = hooks.clone(vnode.ssContent);
+        vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
+    } else {
+        vnode.transition = hooks;
+    }
+}
+getGlobalThis().requestIdleCallback || ((cb)=>setTimeout(cb, 1));
+getGlobalThis().cancelIdleCallback || ((id)=>clearTimeout(id));
+function injectHook(type, hook, target = currentInstance, prepend = false) {
+    if (target) {
+        const hooks = target[type] || (target[type] = []);
+        const wrappedHook = hook.__weh || (hook.__weh = (...args)=>{
+            const reset = setCurrentInstance(target);
+            const res = callWithAsyncErrorHandling(hook, target, type, args);
+            reset();
+            return res;
+        });
+        if (prepend) {
+            hooks.unshift(wrappedHook);
+        } else {
+            hooks.push(wrappedHook);
+        }
+        return wrappedHook;
+    } else if (!!(process.env.NODE_ENV !== "production")) {
+        const apiName = toHandlerKey(ErrorTypeStrings$1[type].replace(/ hook$/, ""));
+        warn$1(`${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup().` + ` If you are using async setup(), make sure to register lifecycle hooks before the first await statement.`);
+    }
+}
+const createHook = (lifecycle)=>(hook, target = currentInstance)=>{
+        if (!isInSSRComponentSetup || lifecycle === "sp") {
+            injectHook(lifecycle, (...args)=>hook(...args), target);
+        }
+    };
+const onUnmounted = createHook("um");
+const NULL_DYNAMIC_COMPONENT = /* @__PURE__ */ Symbol.for("v-ndc");
+const PublicInstanceProxyHandlers = {
+    };
+if (!!(process.env.NODE_ENV !== "production") && true) {
+    PublicInstanceProxyHandlers.ownKeys = (target)=>{
+        warn$1(`Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead.`);
+        return Reflect.ownKeys(target);
+    };
+}
+const internalObjectProto = {};
+const isInternalObject = (obj)=>Object.getPrototypeOf(obj) === internalObjectProto;
+const isSuspense = (type)=>type.__isSuspense;
+const Fragment = /* @__PURE__ */ Symbol.for("v-fgt");
+const Text = /* @__PURE__ */ Symbol.for("v-txt");
+const Comment = /* @__PURE__ */ Symbol.for("v-cmt");
+function isVNode(value) {
+    return value ? value.__v_isVNode === true : false;
+}
+const createVNodeWithArgsTransform = (...args)=>{
+    return _createVNode(...args);
+};
+const normalizeKey = ({ key })=>key != null ? key : null;
+const normalizeRef = ({ ref, ref_key, ref_for })=>{
+    if (typeof ref === "number") {
+        ref = "" + ref;
+    }
+    return ref != null ? isString(ref) || isRef(ref) || isFunction(ref) ? {
+        i: currentRenderingInstance,
+        r: ref,
+        k: ref_key,
+        f: !!ref_for
+    } : ref : null;
+};
+function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
+    const vnode = {
+        __v_isVNode: true,
+        __v_skip: true,
+        type,
+        props,
+        key: props && normalizeKey(props),
+        ref: props && normalizeRef(props),
+        scopeId: currentScopeId,
+        slotScopeIds: null,
+        children,
+        component: null,
+        suspense: null,
+        ssContent: null,
+        ssFallback: null,
+        dirs: null,
+        transition: null,
+        el: null,
+        anchor: null,
+        target: null,
+        targetStart: null,
+        targetAnchor: null,
+        staticCount: 0,
+        shapeFlag,
+        patchFlag,
+        dynamicProps,
+        dynamicChildren: null,
+        appContext: null,
+        ctx: currentRenderingInstance
+    };
+    if (needFullChildrenNormalization) {
+        normalizeChildren(vnode, children);
+        if (shapeFlag & 128) {
+            type.normalize(vnode);
+        }
+    } else if (children) {
+        vnode.shapeFlag |= isString(children) ? 8 : 16;
+    }
+    if (!!(process.env.NODE_ENV !== "production") && vnode.key !== vnode.key) {
+        warn$1(`VNode created with invalid key (NaN). VNode type:`, vnode.type);
+    }
+    return vnode;
+}
+const createVNode = !!(process.env.NODE_ENV !== "production") ? createVNodeWithArgsTransform : _createVNode;
+function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
+    if (!type || type === NULL_DYNAMIC_COMPONENT) {
+        if (!!(process.env.NODE_ENV !== "production") && !type) {
+            warn$1(`Invalid vnode type when creating vnode: ${type}.`);
+        }
+        type = Comment;
+    }
+    if (isVNode(type)) {
+        const cloned = cloneVNode(type, props, true);
+        if (children) {
+            normalizeChildren(cloned, children);
+        }
+        cloned.patchFlag = -2;
+        return cloned;
+    }
+    if (isClassComponent(type)) {
+        type = type.__vccOpts;
+    }
+    if (props) {
+        props = guardReactiveProps(props);
+        let { class: klass, style } = props;
+        if (klass && !isString(klass)) {
+            props.class = normalizeClass(klass);
+        }
+        if (isObject(style)) {
+            if (isProxy(style) && !isArray(style)) {
+                style = extend({}, style);
+            }
+            props.style = normalizeStyle(style);
+        }
+    }
+    const shapeFlag = isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject(type) ? 4 : isFunction(type) ? 2 : 0;
+    if (!!(process.env.NODE_ENV !== "production") && shapeFlag & 4 && isProxy(type)) {
+        type = toRaw(type);
+        warn$1(`Vue received a Component that was made a reactive object. This can lead to unnecessary performance overhead and should be avoided by marking the component with \`markRaw\` or using \`shallowRef\` instead of \`ref\`.`, `
+Component that was made reactive: `, type);
+    }
+    return createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, isBlockNode, true);
+}
+function guardReactiveProps(props) {
+    if (!props) return null;
+    return isProxy(props) || isInternalObject(props) ? extend({}, props) : props;
+}
+function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
+    const { props, ref, patchFlag, children, transition } = vnode;
+    const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
+    const cloned = {
+        __v_isVNode: true,
+        __v_skip: true,
+        type: vnode.type,
+        props: mergedProps,
+        key: mergedProps && normalizeKey(mergedProps),
+        ref: extraProps && extraProps.ref ? // #2078 in the case of <component :is="vnode" ref="extra"/>
+        // if the vnode itself already has a ref, cloneVNode will need to merge
+        // the refs so the single vnode can be set on multiple refs
+        mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [
+            ref,
+            normalizeRef(extraProps)
+        ] : normalizeRef(extraProps) : ref,
+        scopeId: vnode.scopeId,
+        slotScopeIds: vnode.slotScopeIds,
+        children: !!(process.env.NODE_ENV !== "production") && patchFlag === -1 && isArray(children) ? children.map(deepCloneVNode) : children,
+        target: vnode.target,
+        targetStart: vnode.targetStart,
+        targetAnchor: vnode.targetAnchor,
+        staticCount: vnode.staticCount,
+        shapeFlag: vnode.shapeFlag,
+        // if the vnode is cloned with extra props, we can no longer assume its
+        // existing patch flag to be reliable and need to add the FULL_PROPS flag.
+        // note: preserve flag for fragments since they use the flag for children
+        // fast paths only.
+        patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
+        dynamicProps: vnode.dynamicProps,
+        dynamicChildren: vnode.dynamicChildren,
+        appContext: vnode.appContext,
+        dirs: vnode.dirs,
+        transition,
+        // These should technically only be non-null on mounted VNodes. However,
+        // they *should* be copied for kept-alive vnodes. So we just always copy
+        // them since them being non-null during a mount doesn't affect the logic as
+        // they will simply be overwritten.
+        component: vnode.component,
+        suspense: vnode.suspense,
+        ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
+        ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
+        placeholder: vnode.placeholder,
+        el: vnode.el,
+        anchor: vnode.anchor,
+        ctx: vnode.ctx,
+        ce: vnode.ce
+    };
+    if (transition && cloneTransition) {
+        setTransitionHooks(cloned, transition.clone(cloned));
+    }
+    return cloned;
+}
+function deepCloneVNode(vnode) {
+    const cloned = cloneVNode(vnode);
+    if (isArray(vnode.children)) {
+        cloned.children = vnode.children.map(deepCloneVNode);
+    }
+    return cloned;
+}
+function createTextVNode(text = " ", flag = 0) {
+    return createVNode(Text, null, text, flag);
+}
+function normalizeChildren(vnode, children) {
+    let type = 0;
+    const { shapeFlag } = vnode;
+    if (children == null) {
+        children = null;
+    } else if (isArray(children)) {
+        type = 16;
+    } else if (typeof children === "object") {
+        if (shapeFlag & (1 | 64)) {
+            const slot = children.default;
+            if (slot) {
+                slot._c && (slot._d = false);
+                normalizeChildren(vnode, slot());
+                slot._c && (slot._d = true);
+            }
+            return;
+        } else {
+            type = 32;
+            const slotFlag = children._;
+            if (!slotFlag && !isInternalObject(children)) {
+                children._ctx = currentRenderingInstance;
+            }
+        }
+    } else if (isFunction(children)) {
+        children = {
+            default: children,
+            _ctx: currentRenderingInstance
+        };
+        type = 32;
+    } else {
+        children = String(children);
+        if (shapeFlag & 64) {
+            type = 16;
+            children = [
+                createTextVNode(children)
+            ];
+        } else {
+            type = 8;
+        }
+    }
+    vnode.children = children;
+    vnode.shapeFlag |= type;
+}
+function mergeProps(...args) {
+    const ret = {};
+    for(let i = 0; i < args.length; i++){
+        const toMerge = args[i];
+        for(const key in toMerge){
+            if (key === "class") {
+                if (ret.class !== toMerge.class) {
+                    ret.class = normalizeClass([
+                        ret.class,
+                        toMerge.class
+                    ]);
+                }
+            } else if (key === "style") {
+                ret.style = normalizeStyle([
+                    ret.style,
+                    toMerge.style
+                ]);
+            } else if (isOn(key)) {
+                const existing = ret[key];
+                const incoming = toMerge[key];
+                if (incoming && existing !== incoming && !(isArray(existing) && existing.includes(incoming))) {
+                    ret[key] = existing ? [].concat(existing, incoming) : incoming;
+                } else if (incoming == null && existing == null && // mergeProps({ 'onUpdate:modelValue': undefined }) should not retain
+                // the model listener.
+                !isModelListener(key)) {
+                    ret[key] = incoming;
+                }
+            } else if (key !== "") {
+                ret[key] = toMerge[key];
+            }
+        }
+    }
+    return ret;
+}
+let currentInstance = null;
+const getCurrentInstance = ()=>currentInstance || currentRenderingInstance;
+let internalSetCurrentInstance;
+{
+    const g = getGlobalThis();
+    const registerGlobalSetter = (key, setter)=>{
+        let setters;
+        if (!(setters = g[key])) setters = g[key] = [];
+        setters.push(setter);
+        return (v1)=>{
+            if (setters.length > 1) setters.forEach((set)=>set(v1));
+            else setters[0](v1);
+        };
+    };
+    internalSetCurrentInstance = registerGlobalSetter(`__VUE_INSTANCE_SETTERS__`, (v1)=>currentInstance = v1);
+    registerGlobalSetter(`__VUE_SSR_SETTERS__`, (v1)=>isInSSRComponentSetup = v1);
+}const setCurrentInstance = (instance)=>{
+    const prev = currentInstance;
+    internalSetCurrentInstance(instance);
+    instance.scope.on();
+    return ()=>{
+        instance.scope.off();
+        internalSetCurrentInstance(prev);
+    };
+};
+let isInSSRComponentSetup = false;
+!!(process.env.NODE_ENV !== "production") ? {
+    } : {
+    };
+const classifyRE = /(?:^|[-_])\w/g;
+const classify = (str)=>str.replace(classifyRE, (c)=>c.toUpperCase()).replace(/[-_]/g, "");
+function getComponentName(Component, includeInferred = true) {
+    return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
+}
+function formatComponentName(instance, Component, isRoot = false) {
+    let name = getComponentName(Component);
+    if (!name && Component.__file) {
+        const match = Component.__file.match(/([^/\\]+)\.\w+$/);
+        if (match) {
+            name = match[1];
+        }
+    }
+    if (!name && instance) {
+        const inferFromRegistry = (registry)=>{
+            for(const key in registry){
+                if (registry[key] === Component) {
+                    return key;
+                }
+            }
+        };
+        name = inferFromRegistry(instance.components) || instance.parent && inferFromRegistry(instance.parent.type.components) || inferFromRegistry(instance.appContext.components);
+    }
+    return name ? classify(name) : isRoot ? `App` : `Anonymous`;
+}
+function isClassComponent(value) {
+    return isFunction(value) && "__vccOpts" in value;
+}
+function initCustomFormatter() {
+    if (!!!(process.env.NODE_ENV !== "production") || typeof window === "undefined") {
+        return;
+    }
+    const vueStyle = {
+        style: "color:#3ba776"
+    };
+    const numberStyle = {
+        style: "color:#1677ff"
+    };
+    const stringStyle = {
+        style: "color:#f5222d"
+    };
+    const keywordStyle = {
+        style: "color:#eb2f96"
+    };
+    const formatter = {
+        __vue_custom_formatter: true,
+        header (obj) {
+            if (!isObject(obj)) {
+                return null;
+            }
+            if (obj.__isVue) {
+                return [
+                    "div",
+                    vueStyle,
+                    `VueInstance`
+                ];
+            } else if (isRef(obj)) {
+                const value = obj.value;
+                return [
+                    "div",
+                    {},
+                    [
+                        "span",
+                        vueStyle,
+                        genRefFlag(obj)
+                    ],
+                    "<",
+                    formatValue(value),
+                    `>`
+                ];
+            } else if (isReactive(obj)) {
+                return [
+                    "div",
+                    {},
+                    [
+                        "span",
+                        vueStyle,
+                        isShallow(obj) ? "ShallowReactive" : "Reactive"
+                    ],
+                    "<",
+                    formatValue(obj),
+                    `>${isReadonly(obj) ? ` (readonly)` : ``}`
+                ];
+            } else if (isReadonly(obj)) {
+                return [
+                    "div",
+                    {},
+                    [
+                        "span",
+                        vueStyle,
+                        isShallow(obj) ? "ShallowReadonly" : "Readonly"
+                    ],
+                    "<",
+                    formatValue(obj),
+                    ">"
+                ];
+            }
+            return null;
+        },
+        hasBody (obj) {
+            return obj && obj.__isVue;
+        },
+        body (obj) {
+            if (obj && obj.__isVue) {
+                return [
+                    "div",
+                    {},
+                    ...formatInstance(obj.$)
+                ];
+            }
+        }
+    };
+    function formatInstance(instance) {
+        const blocks = [];
+        if (instance.type.props && instance.props) {
+            blocks.push(createInstanceBlock("props", toRaw(instance.props)));
+        }
+        if (instance.setupState !== EMPTY_OBJ) {
+            blocks.push(createInstanceBlock("setup", instance.setupState));
+        }
+        if (instance.data !== EMPTY_OBJ) {
+            blocks.push(createInstanceBlock("data", toRaw(instance.data)));
+        }
+        const computed = extractKeys(instance, "computed");
+        if (computed) {
+            blocks.push(createInstanceBlock("computed", computed));
+        }
+        const injected = extractKeys(instance, "inject");
+        if (injected) {
+            blocks.push(createInstanceBlock("injected", injected));
+        }
+        blocks.push([
+            "div",
+            {},
+            [
+                "span",
+                {
+                    style: keywordStyle.style + ";opacity:0.66"
+                },
+                "$ (internal): "
+            ],
+            [
+                "object",
+                {
+                    object: instance
+                }
+            ]
+        ]);
+        return blocks;
+    }
+    function createInstanceBlock(type, target) {
+        target = extend({}, target);
+        if (!Object.keys(target).length) {
+            return [
+                "span",
+                {}
+            ];
+        }
+        return [
+            "div",
+            {
+                style: "line-height:1.25em;margin-bottom:0.6em"
+            },
+            [
+                "div",
+                {
+                    style: "color:#476582"
+                },
+                type
+            ],
+            [
+                "div",
+                {
+                    style: "padding-left:1.25em"
+                },
+                ...Object.keys(target).map((key)=>{
+                    return [
+                        "div",
+                        {},
+                        [
+                            "span",
+                            keywordStyle,
+                            key + ": "
+                        ],
+                        formatValue(target[key], false)
+                    ];
+                })
+            ]
+        ];
+    }
+    function formatValue(v1, asRaw = true) {
+        if (typeof v1 === "number") {
+            return [
+                "span",
+                numberStyle,
+                v1
+            ];
+        } else if (typeof v1 === "string") {
+            return [
+                "span",
+                stringStyle,
+                JSON.stringify(v1)
+            ];
+        } else if (typeof v1 === "boolean") {
+            return [
+                "span",
+                keywordStyle,
+                v1
+            ];
+        } else if (isObject(v1)) {
+            return [
+                "object",
+                {
+                    object: asRaw ? toRaw(v1) : v1
+                }
+            ];
+        } else {
+            return [
+                "span",
+                stringStyle,
+                String(v1)
+            ];
+        }
+    }
+    function extractKeys(instance, type) {
+        const Comp = instance.type;
+        if (isFunction(Comp)) {
+            return;
+        }
+        const extracted = {};
+        for(const key in instance.ctx){
+            if (isKeyOfType(Comp, key, type)) {
+                extracted[key] = instance.ctx[key];
+            }
+        }
+        return extracted;
+    }
+    function isKeyOfType(Comp, key, type) {
+        const opts = Comp[type];
+        if (isArray(opts) && opts.includes(key) || isObject(opts) && key in opts) {
+            return true;
+        }
+        if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {
+            return true;
+        }
+        if (Comp.mixins && Comp.mixins.some((m)=>isKeyOfType(m, key, type))) {
+            return true;
+        }
+    }
+    function genRefFlag(v1) {
+        if (isShallow(v1)) {
+            return `ShallowRef`;
+        }
+        if (v1.effect) {
+            return `ComputedRef`;
+        }
+        return `Ref`;
+    }
+    if (window.devtoolsFormatters) {
+        window.devtoolsFormatters.push(formatter);
+    } else {
+        window.devtoolsFormatters = [
+            formatter
+        ];
+    }
+}
+!!(process.env.NODE_ENV !== "production") ? warn$1 : NOOP;
+!!(process.env.NODE_ENV !== "production") || true ? devtools$1 : void 0;
+!!(process.env.NODE_ENV !== "production") || true ? setDevtoolsHook$1 : NOOP;
+
+function initDev() {
+    {
+        initCustomFormatter();
+    }
+}
+if (!!(process.env.NODE_ENV !== "production")) {
+    initDev();
+}
+
+// Notify logic (no React dependencies)
+// Provides toast management and utilities for VanillaJS, Vue, Svelte, etc.
+class NotifyCore {
+    generateId() {
+        return `${++this.idCounter}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    }
+    subscribe(fn) {
+        this.listeners.add(fn);
+        fn(this.toasts);
+        return ()=>this.listeners.delete(fn);
+    }
+    emit() {
+        for (const fn of this.listeners)fn(this.toasts);
+    }
+    update(fn) {
+        this.toasts = fn(this.toasts);
+        this.emit();
+    }
+    dismiss(id) {
+        const item = this.toasts.find((t)=>t.id === id);
+        if (!item || item.exiting) return;
+        this.update((prev)=>prev.map((t)=>t.id === id ? _extends({}, t, {
+                    exiting: true
+                }) : t));
+        setTimeout(()=>this.update((prev)=>prev.filter((t)=>t.id !== id)), 600);
+    }
+    show(opts) {
+        var _ref, _ref1, _opts_type;
+        // Use a unique identifier based on options (e.g., the title or a generated key)
+        // If not provided, use a default one
+        const id = opts.title ? `notify-${opts.title}` : "notify-default";
+        const prevItem = this.toasts.find((t)=>t.id === id);
+        const instanceId = (_ref = prevItem == null ? void 0 : prevItem.instanceId) != null ? _ref : this.generateId();
+        // Set the state correctly
+        const state = (_ref1 = (_opts_type = opts.type) != null ? _opts_type : prevItem == null ? void 0 : prevItem.type) != null ? _ref1 : "success";
+        const item = _extends({}, prevItem, opts, {
+            id,
+            instanceId,
+            type: state
+        });
+        this.update((prev)=>{
+            const filtered = prev.filter((t)=>t.id !== id);
+            return [
+                ...filtered,
+                item
+            ];
+        });
+        return id;
+    }
+    getToasts() {
+        return this.toasts;
+    }
+    constructor(){
+        this.toasts = [];
+        this.listeners = new Set();
+        this.position = "top-right";
+        this.options = undefined;
+        this.idCounter = 0;
+    }
+}
+// Global instance for multiplatform usage
+const notifyCore = new NotifyCore();
+
+// Vue wrapper for Notify
+// Provides a composable and basic component for Vue 3
+function useNotifyToasts() {
+    const toasts = ref(notifyCore.getToasts());
+    const unsub = notifyCore.subscribe((t)=>toasts.value = t);
+    // In tests the composable can run outside a component setup function.
+    // Register lifecycle cleanup only when there is an active Vue instance.
+    if (getCurrentInstance()) {
+        onUnmounted(unsub);
+    }
+    return {
+        toasts
+    };
+}
+function showNotifyToast(options) {
+    return notifyCore.show(options);
+}
+
+export { showNotifyToast, useNotifyToasts };