@samline/notify 1.0.2 → 2.0.0

package/dist/vue.mjs

@@ -1,2211 +0,0 @@
-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$1 = cacheStringFunction((str)=>{
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-const toHandlerKey = cacheStringFunction((str)=>{
-    const s = str ? `on${capitalize$1(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$1(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);
-}
-
-const ICONS = {
-    success: '<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polyline points="20 6 9 17 4 12"/></svg>',
-    error: '<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M18 6 6 18"/><path d="m6 6 12 12"/></svg>',
-    warning: '<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="12" r="10"/><line x1="12" y1="8" x2="12" y2="12"/><line x1="12" y1="16" x2="12.01" y2="16"/></svg>',
-    info: '<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="12" r="10"/><path d="m4.93 4.93 4.24 4.24"/><path d="m14.83 9.17 4.24-4.24"/><path d="m14.83 14.83 4.24 4.24"/><path d="m9.17 14.83-4.24 4.24"/><circle cx="12" cy="12" r="4"/></svg>',
-    loading: '<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" data-notify-icon="spin" aria-hidden="true"><path d="M21 12a9 9 0 1 1-6.219-8.56"/></svg>',
-    action: '<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M5 12h14"/><path d="m12 5 7 7-7 7"/></svg>'
-};
-const EXIT_MS = 600;
-function capitalize(s) {
-    return s ? s.charAt(0).toUpperCase() + s.slice(1) : "";
-}
-let viewport = null;
-const toastEls = new Map();
-function getOrCreateViewport(position) {
-    if (!viewport) {
-        viewport = document.createElement("div");
-        viewport.setAttribute("data-notify-viewport", "");
-        viewport.setAttribute("data-position", position);
-        viewport.setAttribute("data-theme", "light");
-        document.body.appendChild(viewport);
-    }
-    return viewport;
-}
-function buildToastEl(toast) {
-    const state = toast.type || "success";
-    const btn = document.createElement("button");
-    btn.type = "button";
-    btn.setAttribute("data-notify-toast", "");
-    btn.setAttribute("data-state", state);
-    btn.setAttribute("data-ready", "false");
-    btn.setAttribute("data-exiting", "false");
-    const card = document.createElement("div");
-    card.setAttribute("data-notify-card", "");
-    const header = document.createElement("div");
-    header.setAttribute("data-notify-header", "");
-    const badge = document.createElement("div");
-    badge.setAttribute("data-notify-badge", "");
-    badge.setAttribute("data-state", state);
-    badge.innerHTML = ICONS[state] || ICONS.success;
-    const titleEl = document.createElement("span");
-    titleEl.setAttribute("data-notify-title", "");
-    titleEl.setAttribute("data-state", state);
-    titleEl.textContent = toast.title || capitalize(state);
-    header.appendChild(badge);
-    header.appendChild(titleEl);
-    card.appendChild(header);
-    if (toast.description || toast.button) {
-        const content = document.createElement("div");
-        content.setAttribute("data-notify-content", "");
-        content.setAttribute("data-visible", "true");
-        if (toast.description) {
-            const desc = document.createElement("div");
-            desc.setAttribute("data-notify-description", "");
-            desc.textContent = toast.description;
-            content.appendChild(desc);
-        }
-        if (toast.button) {
-            const actionBtn = document.createElement("button");
-            actionBtn.setAttribute("data-notify-button", "");
-            actionBtn.setAttribute("data-state", state);
-            actionBtn.textContent = toast.button.title;
-            actionBtn.addEventListener("click", (e)=>{
-                var _toast_button;
-                e.stopPropagation();
-                (_toast_button = toast.button) == null ? void 0 : _toast_button.onClick();
-                notifyCore.dismiss(toast.id);
-            });
-            content.appendChild(actionBtn);
-        }
-        card.appendChild(content);
-    }
-    btn.appendChild(card);
-    btn.addEventListener("click", ()=>notifyCore.dismiss(toast.id));
-    requestAnimationFrame(()=>{
-        requestAnimationFrame(()=>{
-            btn.setAttribute("data-ready", "true");
-        });
-    });
-    return btn;
-}
-function updateToastEl(el, toast) {
-    const state = toast.type || "success";
-    el.setAttribute("data-state", state);
-    if (toast.exiting) {
-        el.setAttribute("data-exiting", "true");
-    }
-}
-function renderNotifyToasts(options = {}) {
-    var _options_position;
-    const position = (_options_position = options.position) != null ? _options_position : "top-right";
-    const vp = getOrCreateViewport(position);
-    return notifyCore.subscribe((toasts)=>{
-        const liveIds = new Set(toasts.map((t)=>t.id));
-        for (const [id, el] of toastEls){
-            if (!liveIds.has(id)) {
-                el.setAttribute("data-exiting", "true");
-                setTimeout(()=>{
-                    el.remove();
-                    toastEls.delete(id);
-                }, EXIT_MS);
-            }
-        }
-        for (const toast of toasts){
-            if (toastEls.has(toast.id)) {
-                updateToastEl(toastEls.get(toast.id), toast);
-            } else {
-                const el = buildToastEl(toast);
-                toastEls.set(toast.id, el);
-                vp.appendChild(el);
-            }
-        }
-    });
-}
-
-export { renderNotifyToasts, showNotifyToast, useNotifyToasts };