Sid Gifari File Manager

Sid Gifari File Manager

🏠 Root / home2 / nuveprin / nomascuartosvacios.org / wp-content / plugins / wp-user-frontend / assets / vendor / vue-3 /

Editing: vue.global.js

/**
 * vue v3.4.19
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
var Vue = (function (exports) {
    'use strict';

function makeMap(str, expectsLowerCase) {
        const set = new Set(str.split(","));
        return expectsLowerCase ? (val) => set.has(val.toLowerCase()) : (val) => set.has(val);
    }

const PatchFlagNames = {
        [1]: `TEXT`,
        [2]: `CLASS`,
        [4]: `STYLE`,
        [8]: `PROPS`,
        [16]: `FULL_PROPS`,
        [32]: `NEED_HYDRATION`,
        [64]: `STABLE_FRAGMENT`,
        [128]: `KEYED_FRAGMENT`,
        [256]: `UNKEYED_FRAGMENT`,
        [512]: `NEED_PATCH`,
        [1024]: `DYNAMIC_SLOTS`,
        [2048]: `DEV_ROOT_FRAGMENT`,
        [-1]: `HOISTED`,
        [-2]: `BAIL`
    };

const slotFlagsText = {
        [1]: "STABLE",
        [2]: "DYNAMIC",
        [3]: "FORWARDED"
    };

const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error";
    const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);

const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot";
    const SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view";
    const MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics";
    const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
    const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
    const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
    const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
    const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);

function warn$2(msg, ...args) {
        console.warn(`[Vue warn] ${msg}`, ...args);
    }

let activeEffectScope;
    class EffectScope {
        constructor(detached = false) {
            this.detached = detached;
            /**
             * @internal
             */
            this._active = true;
            /**
             * @internal
             */
            this.effects = [];
            /**
             * @internal
             */
            this.cleanups = [];
            this.parent = activeEffectScope;
            if (!detached && activeEffectScope) {
                this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
                    this
                ) - 1;
            }
        }
        get active() {
            return this._active;
        }
        run(fn) {
            if (this._active) {
                const currentEffectScope = activeEffectScope;
                try {
                    activeEffectScope = this;
                    return fn();
                } finally {
                    activeEffectScope = currentEffectScope;
                }
            } else {
                warn$2(`cannot run an inactive effect scope.`);
            }
        }
        /**
         * This should only be called on non-detached scopes
         * @internal
         */
        on() {
            activeEffectScope = this;
        }
        /**
         * This should only be called on non-detached scopes
         * @internal
         */
        off() {
            activeEffectScope = this.parent;
        }
        stop(fromParent) {
            if (this._active) {
                let i, l;
                for (i = 0, l = this.effects.length; i < l; i++) {
                    this.effects[i].stop();
                }
                for (i = 0, l = this.cleanups.length; i < l; i++) {
                    this.cleanups[i]();
                }
                if (this.scopes) {
                    for (i = 0, l = this.scopes.length; i < l; i++) {
                        this.scopes[i].stop(true);
                    }
                }
                if (!this.detached && this.parent && !fromParent) {
                    const last = this.parent.scopes.pop();
                    if (last && last !== this) {
                        this.parent.scopes[this.index] = last;
                        last.index = this.index;
                    }
                }
                this.parent = void 0;
                this._active = false;
            }
        }
    }
    function effectScope(detached) {
        return new EffectScope(detached);
    }
    function recordEffectScope(effect, scope = activeEffectScope) {
        if (scope && scope.active) {
            scope.effects.push(effect);
        }
    }
    function getCurrentScope() {
        return activeEffectScope;
    }
    function onScopeDispose(fn) {
        if (activeEffectScope) {
            activeEffectScope.cleanups.push(fn);
        } else {
            warn$2(
                `onScopeDispose() is called when there is no active effect scope to be associated with.`
            );
        }
    }

let activeEffect;
    class ReactiveEffect {
        constructor(fn, trigger, scheduler, scope) {
            this.fn = fn;
            this.trigger = trigger;
            this.scheduler = scheduler;
            this.active = true;
            this.deps = [];
            /**
             * @internal
             */
            this._dirtyLevel = 4;
            /**
             * @internal
             */
            this._trackId = 0;
            /**
             * @internal
             */
            this._runnings = 0;
            /**
             * @internal
             */
            this._shouldSchedule = false;
            /**
             * @internal
             */
            this._depsLength = 0;
            recordEffectScope(this, scope);
        }
        get dirty() {
            if (this._dirtyLevel === 2 || this._dirtyLevel === 3) {
                this._dirtyLevel = 1;
                pauseTracking();
                for (let i = 0; i < this._depsLength; i++) {
                    const dep = this.deps[i];
                    if (dep.computed) {
                        triggerComputed(dep.computed);
                        if (this._dirtyLevel >= 4) {
                            break;
                        }
                    }
                }
                if (this._dirtyLevel === 1) {
                    this._dirtyLevel = 0;
                }
                resetTracking();
            }
            return this._dirtyLevel >= 4;
        }
        set dirty(v) {
            this._dirtyLevel = v ? 4 : 0;
        }
        run() {
            this._dirtyLevel = 0;
            if (!this.active) {
                return this.fn();
            }
            let lastShouldTrack = shouldTrack;
            let lastEffect = activeEffect;
            try {
                shouldTrack = true;
                activeEffect = this;
                this._runnings++;
                preCleanupEffect(this);
                return this.fn();
            } finally {
                postCleanupEffect(this);
                this._runnings--;
                activeEffect = lastEffect;
                shouldTrack = lastShouldTrack;
            }
        }
        stop() {
            var _a;
            if (this.active) {
                preCleanupEffect(this);
                postCleanupEffect(this);
                (_a = this.onStop) == null ? void 0 : _a.call(this);
                this.active = false;
            }
        }
    }
    function triggerComputed(computed) {
        return computed.value;
    }
    function preCleanupEffect(effect2) {
        effect2._trackId++;
        effect2._depsLength = 0;
    }
    function postCleanupEffect(effect2) {
        if (effect2.deps.length > effect2._depsLength) {
            for (let i = effect2._depsLength; i < effect2.deps.length; i++) {
                cleanupDepEffect(effect2.deps[i], effect2);
            }
            effect2.deps.length = effect2._depsLength;
        }
    }
    function cleanupDepEffect(dep, effect2) {
        const trackId = dep.get(effect2);
        if (trackId !== void 0 && effect2._trackId !== trackId) {
            dep.delete(effect2);
            if (dep.size === 0) {
                dep.cleanup();
            }
        }
    }
    function effect(fn, options) {
        if (fn.effect instanceof ReactiveEffect) {
            fn = fn.effect.fn;
        }
        const _effect = new ReactiveEffect(fn, NOOP, () => {
            if (_effect.dirty) {
                _effect.run();
            }
        });
        if (options) {
            extend(_effect, options);
            if (options.scope)
                recordEffectScope(_effect, options.scope);
        }
        if (!options || !options.lazy) {
            _effect.run();
        }
        const runner = _effect.run.bind(_effect);
        runner.effect = _effect;
        return runner;
    }
    function stop(runner) {
        runner.effect.stop();
    }
    let shouldTrack = true;
    let pauseScheduleStack = 0;
    const trackStack = [];
    function pauseTracking() {
        trackStack.push(shouldTrack);
        shouldTrack = false;
    }
    function resetTracking() {
        const last = trackStack.pop();
        shouldTrack = last === void 0 ? true : last;
    }
    function pauseScheduling() {
        pauseScheduleStack++;
    }
    function resetScheduling() {
        pauseScheduleStack--;
        while (!pauseScheduleStack && queueEffectSchedulers.length) {
            queueEffectSchedulers.shift()();
        }
    }
    function trackEffect(effect2, dep, debuggerEventExtraInfo) {
        var _a;
        if (dep.get(effect2) !== effect2._trackId) {
            dep.set(effect2, effect2._trackId);
            const oldDep = effect2.deps[effect2._depsLength];
            if (oldDep !== dep) {
                if (oldDep) {
                    cleanupDepEffect(oldDep, effect2);
                }
                effect2.deps[effect2._depsLength++] = dep;
            } else {
                effect2._depsLength++;
            }
            {
                (_a = effect2.onTrack) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));
            }
        }
    }
    const queueEffectSchedulers = [];
    function triggerEffects(dep, dirtyLevel, debuggerEventExtraInfo) {
        var _a;
        pauseScheduling();
        for (const effect2 of dep.keys()) {
            let tracking;
            if (effect2._dirtyLevel < dirtyLevel && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {
                effect2._shouldSchedule || (effect2._shouldSchedule = effect2._dirtyLevel === 0);
                effect2._dirtyLevel = dirtyLevel;
            }
            if (effect2._shouldSchedule && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {
                {
                    (_a = effect2.onTrigger) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));
                }
                effect2.trigger();
                if ((!effect2._runnings || effect2.allowRecurse) && effect2._dirtyLevel !== 2) {
                    effect2._shouldSchedule = false;
                    if (effect2.scheduler) {
                        queueEffectSchedulers.push(effect2.scheduler);
                    }
                }
            }
        }
        resetScheduling();
    }

const createDep = (cleanup, computed) => {
        const dep = /* @__PURE__ */ new Map();
        dep.cleanup = cleanup;
        dep.computed = computed;
        return dep;
    };

const TrackOpTypes = {
        "GET": "get",
        "HAS": "has",
        "ITERATE": "iterate"
    };
    const TriggerOpTypes = {
        "SET": "set",
        "ADD": "add",
        "DELETE": "delete",
        "CLEAR": "clear"
    };

let devtools$1;
    let buffer = [];
    let devtoolsNotInstalled = false;
    function emit$1(event, ...args) {
        if (devtools$1) {
            devtools$1.emit(event, ...args);
        } else if (!devtoolsNotInstalled) {
            buffer.push({ event, args });
        }
    }
    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
            !((_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;
                    devtoolsNotInstalled = true;
                    buffer = [];
                }
            }, 3e3);
        } else {
            devtoolsNotInstalled = true;
            buffer = [];
        }
    }
    function devtoolsInitApp(app, version) {
        emit$1("app:init" /* APP_INIT */, app, version, {
            Fragment,
            Text,
            Comment,
            Static
        });
    }
    function devtoolsUnmountApp(app) {
        emit$1("app:unmount" /* APP_UNMOUNT */, app);
    }
    const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook(
        "component:added" /* COMPONENT_ADDED */
    );
    const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */);
    const _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook(
        "component:removed" /* COMPONENT_REMOVED */
    );
    const devtoolsComponentRemoved = (component) => {
        if (devtools$1 && typeof devtools$1.cleanupBuffer === "function" && // remove the component if it wasn't buffered
            !devtools$1.cleanupBuffer(component)) {
            _devtoolsComponentRemoved(component);
        }
    };
    function createDevtoolsComponentHook(hook) {
        return (component) => {
            emit$1(
                hook,
                component.appContext.app,
                component.uid,
                component.parent ? component.parent.uid : void 0,
                component
            );
        };
    }
    const devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook(
        "perf:start" /* PERFORMANCE_START */
    );
    const devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook(
        "perf:end" /* PERFORMANCE_END */
    );
    function createDevtoolsPerformanceHook(hook) {
        return (component, type, time) => {
            emit$1(hook, component.appContext.app, component.uid, component, type, time);
        };
    }
    function devtoolsComponentEmit(component, event, params) {
        emit$1(
            "component:emit" /* COMPONENT_EMIT */,
            component.appContext.app,
            component,
            event,
            params
        );
    }

const ssrContextKey = Symbol.for("v-scx");
    const useSSRContext = () => {
        {
            warn$1(`useSSRContext() is not supported in the global build.`);
        }
    };

/*! #__NO_SIDE_EFFECTS__ */
    // @__NO_SIDE_EFFECTS__
    function defineComponent(options, extraOptions) {
        return isFunction(options) ? (
            // #8326: extend call and options.name access are considered side-effects
            // by Rollup, so we have to wrap it in a pure-annotated IIFE.
            /* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))()
        ) : options;
    }

let supported;
    let perf;
    function startMeasure(instance, type) {
        if (instance.appContext.config.performance && isSupported()) {
            perf.mark(`vue-${type}-${instance.uid}`);
        }
        {
            devtoolsPerfStart(instance, type, isSupported() ? perf.now() : Date.now());
        }
    }
    function endMeasure(instance, type) {
        if (instance.appContext.config.performance && isSupported()) {
            const startTag = `vue-${type}-${instance.uid}`;
            const endTag = startTag + `:end`;
            perf.mark(endTag);
            perf.measure(
                `<${formatComponentName(instance, instance.type)}> ${type}`,
                startTag,
                endTag
            );
            perf.clearMarks(startTag);
            perf.clearMarks(endTag);
        }
        {
            devtoolsPerfEnd(instance, type, isSupported() ? perf.now() : Date.now());
        }
    }
    function isSupported() {
        if (supported !== void 0) {
            return supported;
        }
        if (typeof window !== "undefined" && window.performance) {
            supported = true;
            perf = window.performance;
        } else {
            supported = false;
        }
        return supported;
    }

const computed = (getterOrOptions, debugOptions) => {
        return computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
    };

const version = "3.4.19";
    const warn = warn$1 ;
    const ErrorTypeStrings = ErrorTypeStrings$1 ;
    const devtools = devtools$1 ;
    const setDevtoolsHook = setDevtoolsHook$1 ;
    const ssrUtils = null;
    const resolveFilter = null;
    const compatUtils = null;
    const DeprecationTypes = null;

/*! #__NO_SIDE_EFFECTS__ */
    // @__NO_SIDE_EFFECTS__
    function defineCustomElement(options, hydrate2) {
        const Comp = defineComponent(options);
        class VueCustomElement extends VueElement {
            constructor(initialProps) {
                super(Comp, initialProps, hydrate2);
            }
        }
        VueCustomElement.def = Comp;
        return VueCustomElement;
    }
    /*! #__NO_SIDE_EFFECTS__ */
    const defineSSRCustomElement = /* @__NO_SIDE_EFFECTS__ */ (options) => {
        return /* @__PURE__ */ defineCustomElement(options, hydrate);
    };
    const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class {
    };
    class VueElement extends BaseClass {
        constructor(_def, _props = {}, hydrate2) {
            super();
            this._def = _def;
            this._props = _props;
            /**
             * @internal
             */
            this._instance = null;
            this._connected = false;
            this._resolved = false;
            this._numberProps = null;
            this._ob = null;
            if (this.shadowRoot && hydrate2) {
                hydrate2(this._createVNode(), this.shadowRoot);
            } else {
                if (this.shadowRoot) {
                    warn(
                        `Custom element has pre-rendered declarative shadow root but is not defined as hydratable. Use \`defineSSRCustomElement\`.`
                    );
                }
                this.attachShadow({ mode: "open" });
                if (!this._def.__asyncLoader) {
                    this._resolveProps(this._def);
                }
            }
        }
        connectedCallback() {
            this._connected = true;
            if (!this._instance) {
                if (this._resolved) {
                    this._update();
                } else {
                    this._resolveDef();
                }
            }
        }
        disconnectedCallback() {
            this._connected = false;
            if (this._ob) {
                this._ob.disconnect();
                this._ob = null;
            }
            nextTick(() => {
                if (!this._connected) {
                    render(null, this.shadowRoot);
                    this._instance = null;
                }
            });
        }
        /**
         * resolve inner component definition (handle possible async component)
         */
        _resolveDef() {
            this._resolved = true;
            for (let i = 0; i < this.attributes.length; i++) {
                this._setAttr(this.attributes[i].name);
            }
            this._ob = new MutationObserver((mutations) => {
                for (const m of mutations) {
                    this._setAttr(m.attributeName);
                }
            });
            this._ob.observe(this, { attributes: true });
            const resolve = (def, isAsync = false) => {
                const { props, styles } = def;
                let numberProps;
                if (props && !isArray(props)) {
                    for (const key in props) {
                        const opt = props[key];
                        if (opt === Number || opt && opt.type === Number) {
                            if (key in this._props) {
                                this._props[key] = toNumber(this._props[key]);
                            }
                            (numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[camelize(key)] = true;
                        }
                    }
                }
                this._numberProps = numberProps;
                if (isAsync) {
                    this._resolveProps(def);
                }
                this._applyStyles(styles);
                this._update();
            };
            const asyncDef = this._def.__asyncLoader;
            if (asyncDef) {
                asyncDef().then((def) => resolve(def, true));
            } else {
                resolve(this._def);
            }
        }
        _resolveProps(def) {
            const { props } = def;
            const declaredPropKeys = isArray(props) ? props : Object.keys(props || {});
            for (const key of Object.keys(this)) {
                if (key[0] !== "_" && declaredPropKeys.includes(key)) {
                    this._setProp(key, this[key], true, false);
                }
            }
            for (const key of declaredPropKeys.map(camelize)) {
                Object.defineProperty(this, key, {
                    get() {
                        return this._getProp(key);
                    },
                    set(val) {
                        this._setProp(key, val);
                    }
                });
            }
        }
        _setAttr(key) {
            let value = this.getAttribute(key);
            const camelKey = camelize(key);
            if (this._numberProps && this._numberProps[camelKey]) {
                value = toNumber(value);
            }
            this._setProp(camelKey, value, false);
        }
        /**
         * @internal
         */
        _getProp(key) {
            return this._props[key];
        }
        /**
         * @internal
         */
        _setProp(key, val, shouldReflect = true, shouldUpdate = true) {
            if (val !== this._props[key]) {
                this._props[key] = val;
                if (shouldUpdate && this._instance) {
                    this._update();
                }
                if (shouldReflect) {
                    if (val === true) {
                        this.setAttribute(hyphenate(key), "");
                    } else if (typeof val === "string" || typeof val === "number") {
                        this.setAttribute(hyphenate(key), val + "");
                    } else if (!val) {
                        this.removeAttribute(hyphenate(key));
                    }
                }
            }
        }
        _update() {
            render(this._createVNode(), this.shadowRoot);
        }
        _createVNode() {
            const vnode = createVNode(this._def, extend({}, this._props));
            if (!this._instance) {
                vnode.ce = (instance) => {
                    this._instance = instance;
                    instance.isCE = true;
                    {
                        instance.ceReload = (newStyles) => {
                            if (this._styles) {
                                this._styles.forEach((s) => this.shadowRoot.removeChild(s));
                                this._styles.length = 0;
                            }
                            this._applyStyles(newStyles);
                            this._instance = null;
                            this._update();
                        };
                    }
                    const dispatch = (event, args) => {
                        this.dispatchEvent(
                            new CustomEvent(event, {
                                detail: args
                            })
                        );
                    };
                    instance.emit = (event, ...args) => {
                        dispatch(event, args);
                        if (hyphenate(event) !== event) {
                            dispatch(hyphenate(event), args);
                        }
                    };
                    let parent = this;
                    while (parent = parent && (parent.parentNode || parent.host)) {
                        if (parent instanceof VueElement) {
                            instance.parent = parent._instance;
                            instance.provides = parent._instance.provides;
                            break;
                        }
                    }
                };
            }
            return vnode;
        }
        _applyStyles(styles) {
            if (styles) {
                styles.forEach((css) => {
                    const s = document.createElement("style");
                    s.textContent = css;
                    this.shadowRoot.appendChild(s);
                    {
                        (this._styles || (this._styles = [])).push(s);
                    }
                });
            }
        }
    }

function useCssModule(name = "$style") {
        {
            {
                warn(`useCssModule() is not supported in the global build.`);
            }
            return EMPTY_OBJ;
        }
    }

function initDev() {
        {
            {
                console.info(
                    `You are running a development build of Vue.
Make sure to use the production build (*.prod.js) when deploying for production.`
                );
            }
            initCustomFormatter();
        }
    }

const noopDirectiveTransform = () => ({ props: [] });

const V_MODEL_RADIO = Symbol(`vModelRadio` );
    const V_MODEL_CHECKBOX = Symbol(`vModelCheckbox` );
    const V_MODEL_TEXT = Symbol(`vModelText` );
    const V_MODEL_SELECT = Symbol(`vModelSelect` );
    const V_MODEL_DYNAMIC = Symbol(`vModelDynamic` );
    const V_ON_WITH_MODIFIERS = Symbol(`vOnModifiersGuard` );
    const V_ON_WITH_KEYS = Symbol(`vOnKeysGuard` );
    const V_SHOW = Symbol(`vShow` );
    const TRANSITION = Symbol(`Transition` );
    const TRANSITION_GROUP = Symbol(`TransitionGroup` );
    registerRuntimeHelpers({
        [V_MODEL_RADIO]: `vModelRadio`,
        [V_MODEL_CHECKBOX]: `vModelCheckbox`,
        [V_MODEL_TEXT]: `vModelText`,
        [V_MODEL_SELECT]: `vModelSelect`,
        [V_MODEL_DYNAMIC]: `vModelDynamic`,
        [V_ON_WITH_MODIFIERS]: `withModifiers`,
        [V_ON_WITH_KEYS]: `withKeys`,
        [V_SHOW]: `vShow`,
        [TRANSITION]: `Transition`,
        [TRANSITION_GROUP]: `TransitionGroup`
    });

let decoder;
    function decodeHtmlBrowser(raw, asAttr = false) {
        if (!decoder) {
            decoder = document.createElement("div");
        }
        if (asAttr) {
            decoder.innerHTML = `<div foo="${raw.replace(/"/g, "&quot;")}">`;
            return decoder.children[0].getAttribute("foo");
        } else {
            decoder.innerHTML = raw;
            return decoder.textContent;
        }
    }

function createDOMCompilerError(code, loc) {
        return createCompilerError(
            code,
            loc,
            DOMErrorMessages
        );
    }
    const DOMErrorMessages = {
        [53]: `v-html is missing expression.`,
        [54]: `v-html will override element children.`,
        [55]: `v-text is missing expression.`,
        [56]: `v-text will override element children.`,
        [57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
        [58]: `v-model argument is not supported on plain elements.`,
        [59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
        [60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
        [61]: `v-show is missing expression.`,
        [62]: `<Transition> expects exactly one child element or component.`,
        [63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
    };

const ignoreSideEffectTags = (node, context) => {
        if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
            context.onError(
                createDOMCompilerError(
                    63,
                    node.loc
                )
            );
            context.removeNode();
        }
    };

{
        initDev();
    }
    const compileCache = /* @__PURE__ */ new WeakMap();
    function getCache(options) {
        let c = compileCache.get(options != null ? options : EMPTY_OBJ);
        if (!c) {
            c = /* @__PURE__ */ Object.create(null);
            compileCache.set(options != null ? options : EMPTY_OBJ, c);
        }
        return c;
    }
    function compileToFunction(template, options) {
        if (!isString(template)) {
            if (template.nodeType) {
                template = template.innerHTML;
            } else {
                warn(`invalid template option: `, template);
                return NOOP;
            }
        }
        const key = template;
        const cache = getCache(options);
        const cached = cache[key];
        if (cached) {
            return cached;
        }
        if (template[0] === "#") {
            const el = document.querySelector(template);
            if (!el) {
                warn(`Template element not found or is empty: ${template}`);
            }
            template = el ? el.innerHTML : ``;
        }
        const opts = extend(
            {
                hoistStatic: true,
                onError: onError ,
                onWarn: (e) => onError(e, true)
            },
            options
        );
        if (!opts.isCustomElement && typeof customElements !== "undefined") {
            opts.isCustomElement = (tag) => !!customElements.get(tag);
        }
        const { code } = compile(template, opts);
        function onError(err, asWarning = false) {
            const message = asWarning ? err.message : `Template compilation error: ${err.message}`;
            const codeFrame = err.loc && generateCodeFrame(
                template,
                err.loc.start.offset,
                err.loc.end.offset
            );
            warn(codeFrame ? `${message}
${codeFrame}` : message);
        }
        const render = new Function(code)() ;
        render._rc = true;
        return cache[key] = render;
    }
    registerRuntimeCompiler(compileToFunction);

exports.BaseTransition = BaseTransition;
    exports.BaseTransitionPropsValidators = BaseTransitionPropsValidators;
    exports.Comment = Comment;
    exports.DeprecationTypes = DeprecationTypes;
    exports.EffectScope = EffectScope;
    exports.ErrorCodes = ErrorCodes;
    exports.ErrorTypeStrings = ErrorTypeStrings;
    exports.Fragment = Fragment;
    exports.KeepAlive = KeepAlive;
    exports.ReactiveEffect = ReactiveEffect;
    exports.Static = Static;
    exports.Suspense = Suspense;
    exports.Teleport = Teleport;
    exports.Text = Text;
    exports.TrackOpTypes = TrackOpTypes;
    exports.Transition = Transition;
    exports.TransitionGroup = TransitionGroup;
    exports.TriggerOpTypes = TriggerOpTypes;
    exports.VueElement = VueElement;
    exports.assertNumber = assertNumber;
    exports.callWithAsyncErrorHandling = callWithAsyncErrorHandling;
    exports.callWithErrorHandling = callWithErrorHandling;
    exports.camelize = camelize;
    exports.capitalize = capitalize;
    exports.cloneVNode = cloneVNode;
    exports.compatUtils = compatUtils;
    exports.compile = compileToFunction;
    exports.computed = computed;
    exports.createApp = createApp;
    exports.createBlock = createBlock;
    exports.createCommentVNode = createCommentVNode;
    exports.createElementBlock = createElementBlock;
    exports.createElementVNode = createBaseVNode;
    exports.createHydrationRenderer = createHydrationRenderer;
    exports.createPropsRestProxy = createPropsRestProxy;
    exports.createRenderer = createRenderer;
    exports.createSSRApp = createSSRApp;
    exports.createSlots = createSlots;
    exports.createStaticVNode = createStaticVNode;
    exports.createTextVNode = createTextVNode;
    exports.createVNode = createVNode;
    exports.customRef = customRef;
    exports.defineAsyncComponent = defineAsyncComponent;
    exports.defineComponent = defineComponent;
    exports.defineCustomElement = defineCustomElement;
    exports.defineEmits = defineEmits;
    exports.defineExpose = defineExpose;
    exports.defineModel = defineModel;
    exports.defineOptions = defineOptions;
    exports.defineProps = defineProps;
    exports.defineSSRCustomElement = defineSSRCustomElement;
    exports.defineSlots = defineSlots;
    exports.devtools = devtools;
    exports.effect = effect;
    exports.effectScope = effectScope;
    exports.getCurrentInstance = getCurrentInstance;
    exports.getCurrentScope = getCurrentScope;
    exports.getTransitionRawChildren = getTransitionRawChildren;
    exports.guardReactiveProps = guardReactiveProps;
    exports.h = h;
    exports.handleError = handleError;
    exports.hasInjectionContext = hasInjectionContext;
    exports.hydrate = hydrate;
    exports.initCustomFormatter = initCustomFormatter;
    exports.initDirectivesForSSR = initDirectivesForSSR;
    exports.inject = inject;
    exports.isMemoSame = isMemoSame;
    exports.isProxy = isProxy;
    exports.isReactive = isReactive;
    exports.isReadonly = isReadonly;
    exports.isRef = isRef;
    exports.isRuntimeOnly = isRuntimeOnly;
    exports.isShallow = isShallow;
    exports.isVNode = isVNode;
    exports.markRaw = markRaw;
    exports.mergeDefaults = mergeDefaults;
    exports.mergeModels = mergeModels;
    exports.mergeProps = mergeProps;
    exports.nextTick = nextTick;
    exports.normalizeClass = normalizeClass;
    exports.normalizeProps = normalizeProps;
    exports.normalizeStyle = normalizeStyle;
    exports.onActivated = onActivated;
    exports.onBeforeMount = onBeforeMount;
    exports.onBeforeUnmount = onBeforeUnmount;
    exports.onBeforeUpdate = onBeforeUpdate;
    exports.onDeactivated = onDeactivated;
    exports.onErrorCaptured = onErrorCaptured;
    exports.onMounted = onMounted;
    exports.onRenderTracked = onRenderTracked;
    exports.onRenderTriggered = onRenderTriggered;
    exports.onScopeDispose = onScopeDispose;
    exports.onServerPrefetch = onServerPrefetch;
    exports.onUnmounted = onUnmounted;
    exports.onUpdated = onUpdated;
    exports.openBlock = openBlock;
    exports.popScopeId = popScopeId;
    exports.provide = provide;
    exports.proxyRefs = proxyRefs;
    exports.pushScopeId = pushScopeId;
    exports.queuePostFlushCb = queuePostFlushCb;
    exports.reactive = reactive;
    exports.readonly = readonly;
    exports.ref = ref;
    exports.registerRuntimeCompiler = registerRuntimeCompiler;
    exports.render = render;
    exports.renderList = renderList;
    exports.renderSlot = renderSlot;
    exports.resolveComponent = resolveComponent;
    exports.resolveDirective = resolveDirective;
    exports.resolveDynamicComponent = resolveDynamicComponent;
    exports.resolveFilter = resolveFilter;
    exports.resolveTransitionHooks = resolveTransitionHooks;
    exports.setBlockTracking = setBlockTracking;
    exports.setDevtoolsHook = setDevtoolsHook;
    exports.setTransitionHooks = setTransitionHooks;
    exports.shallowReactive = shallowReactive;
    exports.shallowReadonly = shallowReadonly;
    exports.shallowRef = shallowRef;
    exports.ssrContextKey = ssrContextKey;
    exports.ssrUtils = ssrUtils;
    exports.stop = stop;
    exports.toDisplayString = toDisplayString;
    exports.toHandlerKey = toHandlerKey;
    exports.toHandlers = toHandlers;
    exports.toRaw = toRaw;
    exports.toRef = toRef;
    exports.toRefs = toRefs;
    exports.toValue = toValue;
    exports.transformVNodeArgs = transformVNodeArgs;
    exports.triggerRef = triggerRef;
    exports.unref = unref;
    exports.useAttrs = useAttrs;
    exports.useCssModule = useCssModule;
    exports.useCssVars = useCssVars;
    exports.useModel = useModel;
    exports.useSSRContext = useSSRContext;
    exports.useSlots = useSlots;
    exports.useTransitionState = useTransitionState;
    exports.vModelCheckbox = vModelCheckbox;
    exports.vModelDynamic = vModelDynamic;
    exports.vModelRadio = vModelRadio;
    exports.vModelSelect = vModelSelect;
    exports.vModelText = vModelText;
    exports.vShow = vShow;
    exports.version = version;
    exports.warn = warn;
    exports.watch = watch;
    exports.watchEffect = watchEffect;
    exports.watchPostEffect = watchPostEffect;
    exports.watchSyncEffect = watchSyncEffect;
    exports.withAsyncContext = withAsyncContext;
    exports.withCtx = withCtx;
    exports.withDefaults = withDefaults;
    exports.withDirectives = withDirectives;
    exports.withKeys = withKeys;
    exports.withMemo = withMemo;
    exports.withModifiers = withModifiers;
    exports.withScopeId = withScopeId;

return exports;

})({});