import { BaseTransition, BaseTransitionPropsValidators, Comment, DeprecationTypes, EffectScope, ErrorCodes, ErrorTypeStrings, Fragment, KeepAlive, ReactiveEffect, Static, Suspense, Teleport, Text, TrackOpTypes, TriggerOpTypes, assertNumber, callWithAsyncErrorHandling, callWithErrorHandling, cloneVNode, compatUtils, computed, createBaseVNode, createBlock, createCommentVNode, createElementBlock, createHydrationRenderer, createPropsRestProxy, createRenderer, createSlots, createStaticVNode, createTextVNode, createVNode, customRef, defineAsyncComponent, defineComponent, defineEmits, defineExpose, defineModel, defineOptions, defineProps, defineSlots, devtools, effect, effectScope, getCurrentInstance, getCurrentScope, getTransitionRawChildren, guardReactiveProps, h, handleError, hasInjectionContext, initCustomFormatter, init_runtime_core_esm_bundler, inject, isMemoSame, isProxy, isReactive, isReadonly, isRef, isRuntimeOnly, isShallow, isVNode, markRaw, mergeDefaults, mergeModels, mergeProps, nextTick, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onScopeDispose, onServerPrefetch, onUnmounted, onUpdated, openBlock, popScopeId, provide, proxyRefs, pushScopeId, queuePostFlushCb, reactive, readonly, ref, registerRuntimeCompiler, renderList, renderSlot, resolveComponent, resolveDirective, resolveDynamicComponent, resolveFilter, resolveTransitionHooks, setBlockTracking, setDevtoolsHook, setTransitionHooks, shallowReactive, shallowReadonly, shallowRef, ssrContextKey, ssrUtils, stop, toHandlers, toRaw, toRef, toRefs, toValue, transformVNodeArgs, triggerRef, unref, useAttrs, useModel, useSSRContext, useSlots, useTransitionState, version, warn, watch, watchEffect, watchPostEffect, watchSyncEffect, withAsyncContext, withCtx, withDefaults, withDirectives, withMemo, withScopeId } from "./chunk-YVHZHMSQ.js"; import { EMPTY_OBJ, NOOP, camelize, capitalize, extend, hyphenate, includeBooleanAttr, init_shared_esm_bundler, invokeArrayFns, isArray, isFunction, isHTMLTag, isMathMLTag, isModelListener, isObject, isOn, isSVGTag, isSet, isSpecialBooleanAttr, isString, looseEqual, looseIndexOf, looseToNumber, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey, toNumber } from "./chunk-VNBICN6T.js"; import { __esm, __export } from "./chunk-2LSFTFF7.js"; // node_modules/.pnpm/@vue+runtime-dom@3.4.27/node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js var runtime_dom_esm_bundler_exports = {}; __export(runtime_dom_esm_bundler_exports, { BaseTransition: () => BaseTransition, BaseTransitionPropsValidators: () => BaseTransitionPropsValidators, Comment: () => Comment, DeprecationTypes: () => DeprecationTypes, EffectScope: () => EffectScope, ErrorCodes: () => ErrorCodes, ErrorTypeStrings: () => ErrorTypeStrings, Fragment: () => Fragment, KeepAlive: () => KeepAlive, ReactiveEffect: () => ReactiveEffect, Static: () => Static, Suspense: () => Suspense, Teleport: () => Teleport, Text: () => Text, TrackOpTypes: () => TrackOpTypes, Transition: () => Transition, TransitionGroup: () => TransitionGroup, TriggerOpTypes: () => TriggerOpTypes, VueElement: () => VueElement, assertNumber: () => assertNumber, callWithAsyncErrorHandling: () => callWithAsyncErrorHandling, callWithErrorHandling: () => callWithErrorHandling, camelize: () => camelize, capitalize: () => capitalize, cloneVNode: () => cloneVNode, compatUtils: () => compatUtils, computed: () => computed, createApp: () => createApp, createBlock: () => createBlock, createCommentVNode: () => createCommentVNode, createElementBlock: () => createElementBlock, createElementVNode: () => createBaseVNode, createHydrationRenderer: () => createHydrationRenderer, createPropsRestProxy: () => createPropsRestProxy, createRenderer: () => createRenderer, createSSRApp: () => createSSRApp, createSlots: () => createSlots, createStaticVNode: () => createStaticVNode, createTextVNode: () => createTextVNode, createVNode: () => createVNode, customRef: () => customRef, defineAsyncComponent: () => defineAsyncComponent, defineComponent: () => defineComponent, defineCustomElement: () => defineCustomElement, defineEmits: () => defineEmits, defineExpose: () => defineExpose, defineModel: () => defineModel, defineOptions: () => defineOptions, defineProps: () => defineProps, defineSSRCustomElement: () => defineSSRCustomElement, defineSlots: () => defineSlots, devtools: () => devtools, effect: () => effect, effectScope: () => effectScope, getCurrentInstance: () => getCurrentInstance, getCurrentScope: () => getCurrentScope, getTransitionRawChildren: () => getTransitionRawChildren, guardReactiveProps: () => guardReactiveProps, h: () => h, handleError: () => handleError, hasInjectionContext: () => hasInjectionContext, hydrate: () => hydrate, initCustomFormatter: () => initCustomFormatter, initDirectivesForSSR: () => initDirectivesForSSR, inject: () => inject, isMemoSame: () => isMemoSame, isProxy: () => isProxy, isReactive: () => isReactive, isReadonly: () => isReadonly, isRef: () => isRef, isRuntimeOnly: () => isRuntimeOnly, isShallow: () => isShallow, isVNode: () => isVNode, markRaw: () => markRaw, mergeDefaults: () => mergeDefaults, mergeModels: () => mergeModels, mergeProps: () => mergeProps, nextTick: () => nextTick, normalizeClass: () => normalizeClass, normalizeProps: () => normalizeProps, normalizeStyle: () => normalizeStyle, onActivated: () => onActivated, onBeforeMount: () => onBeforeMount, onBeforeUnmount: () => onBeforeUnmount, onBeforeUpdate: () => onBeforeUpdate, onDeactivated: () => onDeactivated, onErrorCaptured: () => onErrorCaptured, onMounted: () => onMounted, onRenderTracked: () => onRenderTracked, onRenderTriggered: () => onRenderTriggered, onScopeDispose: () => onScopeDispose, onServerPrefetch: () => onServerPrefetch, onUnmounted: () => onUnmounted, onUpdated: () => onUpdated, openBlock: () => openBlock, popScopeId: () => popScopeId, provide: () => provide, proxyRefs: () => proxyRefs, pushScopeId: () => pushScopeId, queuePostFlushCb: () => queuePostFlushCb, reactive: () => reactive, readonly: () => readonly, ref: () => ref, registerRuntimeCompiler: () => registerRuntimeCompiler, render: () => render, renderList: () => renderList, renderSlot: () => renderSlot, resolveComponent: () => resolveComponent, resolveDirective: () => resolveDirective, resolveDynamicComponent: () => resolveDynamicComponent, resolveFilter: () => resolveFilter, resolveTransitionHooks: () => resolveTransitionHooks, setBlockTracking: () => setBlockTracking, setDevtoolsHook: () => setDevtoolsHook, setTransitionHooks: () => setTransitionHooks, shallowReactive: () => shallowReactive, shallowReadonly: () => shallowReadonly, shallowRef: () => shallowRef, ssrContextKey: () => ssrContextKey, ssrUtils: () => ssrUtils, stop: () => stop, toDisplayString: () => toDisplayString, toHandlerKey: () => toHandlerKey, toHandlers: () => toHandlers, toRaw: () => toRaw, toRef: () => toRef, toRefs: () => toRefs, toValue: () => toValue, transformVNodeArgs: () => transformVNodeArgs, triggerRef: () => triggerRef, unref: () => unref, useAttrs: () => useAttrs, useCssModule: () => useCssModule, useCssVars: () => useCssVars, useModel: () => useModel, useSSRContext: () => useSSRContext, useSlots: () => useSlots, useTransitionState: () => useTransitionState, vModelCheckbox: () => vModelCheckbox, vModelDynamic: () => vModelDynamic, vModelRadio: () => vModelRadio, vModelSelect: () => vModelSelect, vModelText: () => vModelText, vShow: () => vShow, version: () => version, warn: () => warn, watch: () => watch, watchEffect: () => watchEffect, watchPostEffect: () => watchPostEffect, watchSyncEffect: () => watchSyncEffect, withAsyncContext: () => withAsyncContext, withCtx: () => withCtx, withDefaults: () => withDefaults, withDirectives: () => withDirectives, withKeys: () => withKeys, withMemo: () => withMemo, withModifiers: () => withModifiers, withScopeId: () => withScopeId }); function resolveTransitionProps(rawProps) { const baseProps = {}; for (const key in rawProps) { if (!(key in DOMTransitionPropsValidators)) { baseProps[key] = rawProps[key]; } } if (rawProps.css === false) { return baseProps; } const { name = "v", type, duration, enterFromClass = `${name}-enter-from`, enterActiveClass = `${name}-enter-active`, enterToClass = `${name}-enter-to`, appearFromClass = enterFromClass, appearActiveClass = enterActiveClass, appearToClass = enterToClass, leaveFromClass = `${name}-leave-from`, leaveActiveClass = `${name}-leave-active`, leaveToClass = `${name}-leave-to` } = rawProps; const durations = normalizeDuration(duration); const enterDuration = durations && durations[0]; const leaveDuration = durations && durations[1]; const { onBeforeEnter, onEnter, onEnterCancelled, onLeave, onLeaveCancelled, onBeforeAppear = onBeforeEnter, onAppear = onEnter, onAppearCancelled = onEnterCancelled } = baseProps; const finishEnter = (el, isAppear, done) => { removeTransitionClass(el, isAppear ? appearToClass : enterToClass); removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass); done && done(); }; const finishLeave = (el, done) => { el._isLeaving = false; removeTransitionClass(el, leaveFromClass); removeTransitionClass(el, leaveToClass); removeTransitionClass(el, leaveActiveClass); done && done(); }; const makeEnterHook = (isAppear) => { return (el, done) => { const hook = isAppear ? onAppear : onEnter; const resolve = () => finishEnter(el, isAppear, done); callHook(hook, [el, resolve]); nextFrame(() => { removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass); addTransitionClass(el, isAppear ? appearToClass : enterToClass); if (!hasExplicitCallback(hook)) { whenTransitionEnds(el, type, enterDuration, resolve); } }); }; }; return extend(baseProps, { onBeforeEnter(el) { callHook(onBeforeEnter, [el]); addTransitionClass(el, enterFromClass); addTransitionClass(el, enterActiveClass); }, onBeforeAppear(el) { callHook(onBeforeAppear, [el]); addTransitionClass(el, appearFromClass); addTransitionClass(el, appearActiveClass); }, onEnter: makeEnterHook(false), onAppear: makeEnterHook(true), onLeave(el, done) { el._isLeaving = true; const resolve = () => finishLeave(el, done); addTransitionClass(el, leaveFromClass); addTransitionClass(el, leaveActiveClass); forceReflow(); nextFrame(() => { if (!el._isLeaving) { return; } removeTransitionClass(el, leaveFromClass); addTransitionClass(el, leaveToClass); if (!hasExplicitCallback(onLeave)) { whenTransitionEnds(el, type, leaveDuration, resolve); } }); callHook(onLeave, [el, resolve]); }, onEnterCancelled(el) { finishEnter(el, false); callHook(onEnterCancelled, [el]); }, onAppearCancelled(el) { finishEnter(el, true); callHook(onAppearCancelled, [el]); }, onLeaveCancelled(el) { finishLeave(el); callHook(onLeaveCancelled, [el]); } }); } function normalizeDuration(duration) { if (duration == null) { return null; } else if (isObject(duration)) { return [NumberOf(duration.enter), NumberOf(duration.leave)]; } else { const n = NumberOf(duration); return [n, n]; } } function NumberOf(val) { const res = toNumber(val); if (true) { assertNumber(res, " explicit duration"); } return res; } function addTransitionClass(el, cls) { cls.split(/\s+/).forEach((c) => c && el.classList.add(c)); (el[vtcKey] || (el[vtcKey] = /* @__PURE__ */ new Set())).add(cls); } function removeTransitionClass(el, cls) { cls.split(/\s+/).forEach((c) => c && el.classList.remove(c)); const _vtc = el[vtcKey]; if (_vtc) { _vtc.delete(cls); if (!_vtc.size) { el[vtcKey] = void 0; } } } function nextFrame(cb) { requestAnimationFrame(() => { requestAnimationFrame(cb); }); } function whenTransitionEnds(el, expectedType, explicitTimeout, resolve) { const id = el._endId = ++endId; const resolveIfNotStale = () => { if (id === el._endId) { resolve(); } }; if (explicitTimeout) { return setTimeout(resolveIfNotStale, explicitTimeout); } const { type, timeout, propCount } = getTransitionInfo(el, expectedType); if (!type) { return resolve(); } const endEvent = type + "end"; let ended = 0; const end = () => { el.removeEventListener(endEvent, onEnd); resolveIfNotStale(); }; const onEnd = (e) => { if (e.target === el && ++ended >= propCount) { end(); } }; setTimeout(() => { if (ended < propCount) { end(); } }, timeout + 1); el.addEventListener(endEvent, onEnd); } function getTransitionInfo(el, expectedType) { const styles = window.getComputedStyle(el); const getStyleProperties = (key) => (styles[key] || "").split(", "); const transitionDelays = getStyleProperties(`${TRANSITION}Delay`); const transitionDurations = getStyleProperties(`${TRANSITION}Duration`); const transitionTimeout = getTimeout(transitionDelays, transitionDurations); const animationDelays = getStyleProperties(`${ANIMATION}Delay`); const animationDurations = getStyleProperties(`${ANIMATION}Duration`); const animationTimeout = getTimeout(animationDelays, animationDurations); let type = null; let timeout = 0; let propCount = 0; if (expectedType === TRANSITION) { if (transitionTimeout > 0) { type = TRANSITION; timeout = transitionTimeout; propCount = transitionDurations.length; } } else if (expectedType === ANIMATION) { if (animationTimeout > 0) { type = ANIMATION; timeout = animationTimeout; propCount = animationDurations.length; } } else { timeout = Math.max(transitionTimeout, animationTimeout); type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null; propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0; } const hasTransform = type === TRANSITION && /\b(transform|all)(,|$)/.test( getStyleProperties(`${TRANSITION}Property`).toString() ); return { type, timeout, propCount, hasTransform }; } function getTimeout(delays, durations) { while (delays.length < durations.length) { delays = delays.concat(delays); } return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i]))); } function toMs(s) { if (s === "auto") return 0; return Number(s.slice(0, -1).replace(",", ".")) * 1e3; } function forceReflow() { return document.body.offsetHeight; } function patchClass(el, value, isSVG) { const transitionClasses = el[vtcKey]; if (transitionClasses) { value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" "); } if (value == null) { el.removeAttribute("class"); } else if (isSVG) { el.setAttribute("class", value); } else { el.className = value; } } function setDisplay(el, value) { el.style.display = value ? el[vShowOriginalDisplay] : "none"; el[vShowHidden] = !value; } function initVShowForSSR() { vShow.getSSRProps = ({ value }) => { if (!value) { return { style: { display: "none" } }; } }; } function useCssVars(getter) { const instance = getCurrentInstance(); if (!instance) { warn(`useCssVars is called without current active component instance.`); return; } const updateTeleports = instance.ut = (vars = getter(instance.proxy)) => { Array.from( document.querySelectorAll(`[data-v-owner="${instance.uid}"]`) ).forEach((node) => setVarsOnNode(node, vars)); }; if (true) { instance.getCssVars = () => getter(instance.proxy); } const setVars = () => { const vars = getter(instance.proxy); setVarsOnVNode(instance.subTree, vars); updateTeleports(vars); }; onMounted(() => { watchPostEffect(setVars); const ob = new MutationObserver(setVars); ob.observe(instance.subTree.el.parentNode, { childList: true }); onUnmounted(() => ob.disconnect()); }); } function setVarsOnVNode(vnode, vars) { if (vnode.shapeFlag & 128) { const suspense = vnode.suspense; vnode = suspense.activeBranch; if (suspense.pendingBranch && !suspense.isHydrating) { suspense.effects.push(() => { setVarsOnVNode(suspense.activeBranch, vars); }); } } while (vnode.component) { vnode = vnode.component.subTree; } if (vnode.shapeFlag & 1 && vnode.el) { setVarsOnNode(vnode.el, vars); } else if (vnode.type === Fragment) { vnode.children.forEach((c) => setVarsOnVNode(c, vars)); } else if (vnode.type === Static) { let { el, anchor } = vnode; while (el) { setVarsOnNode(el, vars); if (el === anchor) break; el = el.nextSibling; } } } function setVarsOnNode(el, vars) { if (el.nodeType === 1) { const style = el.style; let cssText = ""; for (const key in vars) { style.setProperty(`--${key}`, vars[key]); cssText += `--${key}: ${vars[key]};`; } style[CSS_VAR_TEXT] = cssText; } } function patchStyle(el, prev, next) { const style = el.style; const isCssString = isString(next); let hasControlledDisplay = false; if (next && !isCssString) { if (prev) { if (!isString(prev)) { for (const key in prev) { if (next[key] == null) { setStyle(style, key, ""); } } } else { for (const prevStyle of prev.split(";")) { const key = prevStyle.slice(0, prevStyle.indexOf(":")).trim(); if (next[key] == null) { setStyle(style, key, ""); } } } } for (const key in next) { if (key === "display") { hasControlledDisplay = true; } setStyle(style, key, next[key]); } } else { if (isCssString) { if (prev !== next) { const cssVarText = style[CSS_VAR_TEXT]; if (cssVarText) { next += ";" + cssVarText; } style.cssText = next; hasControlledDisplay = displayRE.test(next); } } else if (prev) { el.removeAttribute("style"); } } if (vShowOriginalDisplay in el) { el[vShowOriginalDisplay] = hasControlledDisplay ? style.display : ""; if (el[vShowHidden]) { style.display = "none"; } } } function setStyle(style, name, val) { if (isArray(val)) { val.forEach((v) => setStyle(style, name, v)); } else { if (val == null) val = ""; if (true) { if (semicolonRE.test(val)) { warn( `Unexpected semicolon at the end of '${name}' style value: '${val}'` ); } } if (name.startsWith("--")) { style.setProperty(name, val); } else { const prefixed = autoPrefix(style, name); if (importantRE.test(val)) { style.setProperty( hyphenate(prefixed), val.replace(importantRE, ""), "important" ); } else { style[prefixed] = val; } } } } function autoPrefix(style, rawName) { const cached = prefixCache[rawName]; if (cached) { return cached; } let name = camelize(rawName); if (name !== "filter" && name in style) { return prefixCache[rawName] = name; } name = capitalize(name); for (let i = 0; i < prefixes.length; i++) { const prefixed = prefixes[i] + name; if (prefixed in style) { return prefixCache[rawName] = prefixed; } } return rawName; } function patchAttr(el, key, value, isSVG, instance) { if (isSVG && key.startsWith("xlink:")) { if (value == null) { el.removeAttributeNS(xlinkNS, key.slice(6, key.length)); } else { el.setAttributeNS(xlinkNS, key, value); } } else { const isBoolean = isSpecialBooleanAttr(key); if (value == null || isBoolean && !includeBooleanAttr(value)) { el.removeAttribute(key); } else { el.setAttribute(key, isBoolean ? "" : value); } } } function patchDOMProp(el, key, value, prevChildren, parentComponent, parentSuspense, unmountChildren) { if (key === "innerHTML" || key === "textContent") { if (prevChildren) { unmountChildren(prevChildren, parentComponent, parentSuspense); } el[key] = value == null ? "" : value; return; } const tag = el.tagName; if (key === "value" && tag !== "PROGRESS" && // custom elements may use _value internally !tag.includes("-")) { const oldValue = tag === "OPTION" ? el.getAttribute("value") || "" : el.value; const newValue = value == null ? "" : value; if (oldValue !== newValue || !("_value" in el)) { el.value = newValue; } if (value == null) { el.removeAttribute(key); } el._value = value; return; } let needRemove = false; if (value === "" || value == null) { const type = typeof el[key]; if (type === "boolean") { value = includeBooleanAttr(value); } else if (value == null && type === "string") { value = ""; needRemove = true; } else if (type === "number") { value = 0; needRemove = true; } } try { el[key] = value; } catch (e) { if (!needRemove) { warn( `Failed setting prop "${key}" on <${tag.toLowerCase()}>: value ${value} is invalid.`, e ); } } needRemove && el.removeAttribute(key); } function addEventListener(el, event, handler, options) { el.addEventListener(event, handler, options); } function removeEventListener(el, event, handler, options) { el.removeEventListener(event, handler, options); } function patchEvent(el, rawName, prevValue, nextValue, instance = null) { const invokers = el[veiKey] || (el[veiKey] = {}); const existingInvoker = invokers[rawName]; if (nextValue && existingInvoker) { existingInvoker.value = true ? sanitizeEventValue(nextValue, rawName) : nextValue; } else { const [name, options] = parseName(rawName); if (nextValue) { const invoker = invokers[rawName] = createInvoker( true ? sanitizeEventValue(nextValue, rawName) : nextValue, instance ); addEventListener(el, name, invoker, options); } else if (existingInvoker) { removeEventListener(el, name, existingInvoker, options); invokers[rawName] = void 0; } } } function parseName(name) { let options; if (optionsModifierRE.test(name)) { options = {}; let m; while (m = name.match(optionsModifierRE)) { name = name.slice(0, name.length - m[0].length); options[m[0].toLowerCase()] = true; } } const event = name[2] === ":" ? name.slice(3) : hyphenate(name.slice(2)); return [event, options]; } function createInvoker(initialValue, instance) { const invoker = (e) => { if (!e._vts) { e._vts = Date.now(); } else if (e._vts <= invoker.attached) { return; } callWithAsyncErrorHandling( patchStopImmediatePropagation(e, invoker.value), instance, 5, [e] ); }; invoker.value = initialValue; invoker.attached = getNow(); return invoker; } function sanitizeEventValue(value, propName) { if (isFunction(value) || isArray(value)) { return value; } warn( `Wrong type passed as event handler to ${propName} - did you forget @ or : in front of your prop? Expected function or array of functions, received type ${typeof value}.` ); return NOOP; } function patchStopImmediatePropagation(e, value) { if (isArray(value)) { const originalStop = e.stopImmediatePropagation; e.stopImmediatePropagation = () => { originalStop.call(e); e._stopped = true; }; return value.map( (fn) => (e2) => !e2._stopped && fn && fn(e2) ); } else { return value; } } function shouldSetAsProp(el, key, value, isSVG) { if (isSVG) { if (key === "innerHTML" || key === "textContent") { return true; } if (key in el && isNativeOn(key) && isFunction(value)) { return true; } return false; } if (key === "spellcheck" || key === "draggable" || key === "translate") { return false; } if (key === "form") { return false; } if (key === "list" && el.tagName === "INPUT") { return false; } if (key === "type" && el.tagName === "TEXTAREA") { return false; } if (key === "width" || key === "height") { const tag = el.tagName; if (tag === "IMG" || tag === "VIDEO" || tag === "CANVAS" || tag === "SOURCE") { return false; } } if (isNativeOn(key) && isString(value)) { return false; } return key in el; } function defineCustomElement(options, hydrate2) { const Comp = defineComponent(options); class VueCustomElement extends VueElement { constructor(initialProps) { super(Comp, initialProps, hydrate2); } } VueCustomElement.def = Comp; return VueCustomElement; } function useCssModule(name = "$style") { { const instance = getCurrentInstance(); if (!instance) { warn(`useCssModule must be called inside setup()`); return EMPTY_OBJ; } const modules = instance.type.__cssModules; if (!modules) { warn(`Current instance does not have CSS modules injected.`); return EMPTY_OBJ; } const mod = modules[name]; if (!mod) { warn(`Current instance does not have CSS module named "${name}".`); return EMPTY_OBJ; } return mod; } } function callPendingCbs(c) { const el = c.el; if (el[moveCbKey]) { el[moveCbKey](); } if (el[enterCbKey]) { el[enterCbKey](); } } function recordPosition(c) { newPositionMap.set(c, c.el.getBoundingClientRect()); } function applyTranslation(c) { const oldPos = positionMap.get(c); const newPos = newPositionMap.get(c); const dx = oldPos.left - newPos.left; const dy = oldPos.top - newPos.top; if (dx || dy) { const s = c.el.style; s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`; s.transitionDuration = "0s"; return c; } } function hasCSSTransform(el, root, moveClass) { const clone = el.cloneNode(); const _vtc = el[vtcKey]; if (_vtc) { _vtc.forEach((cls) => { cls.split(/\s+/).forEach((c) => c && clone.classList.remove(c)); }); } moveClass.split(/\s+/).forEach((c) => c && clone.classList.add(c)); clone.style.display = "none"; const container = root.nodeType === 1 ? root : root.parentNode; container.appendChild(clone); const { hasTransform } = getTransitionInfo(clone); container.removeChild(clone); return hasTransform; } function onCompositionStart(e) { e.target.composing = true; } function onCompositionEnd(e) { const target = e.target; if (target.composing) { target.composing = false; target.dispatchEvent(new Event("input")); } } function setChecked(el, { value, oldValue }, vnode) { el._modelValue = value; if (isArray(value)) { el.checked = looseIndexOf(value, vnode.props.value) > -1; } else if (isSet(value)) { el.checked = value.has(vnode.props.value); } else if (value !== oldValue) { el.checked = looseEqual(value, getCheckboxValue(el, true)); } } function setSelected(el, value, number) { const isMultiple = el.multiple; const isArrayValue = isArray(value); if (isMultiple && !isArrayValue && !isSet(value)) { warn( ` value need to be deep traversed deep: true, created(el, { value, modifiers: { number } }, vnode) { const isSetModel = isSet(value); addEventListener(el, "change", () => { const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map( (o) => number ? looseToNumber(getValue(o)) : getValue(o) ); el[assignKey]( el.multiple ? isSetModel ? new Set(selectedVal) : selectedVal : selectedVal[0] ); el._assigning = true; nextTick(() => { el._assigning = false; }); }); el[assignKey] = getModelAssigner(vnode); }, // set value in mounted & updated because