vona-cli-set-api 1.0.498 → 1.1.3

package/cli/templates/create/project/cabloy-basic/boilerplate/src/suite/cabloy-basic/modules/basic-siteadmin/assets/site/ssr-cabloyBasicAdmin-5.0.0/client/assets/vue-C_EuNVEw.js

@@ -0,0 +1,13 @@
+import { n as __esmMin } from "./rolldown-runtime-CSj9S6Td.js";
+import { r as init_runtime_dom_esm_bundler } from "./vue-CsFxPVDb.js";
+//#region node_modules/.pnpm/vue@3.5.30_typescript@5.9.3/node_modules/vue/dist/vue.runtime.esm-bundler.js
+var init_vue_runtime_esm_bundler = __esmMin((() => {
+	init_runtime_dom_esm_bundler();
+}));
+//#endregion
+//#region node_modules/.pnpm/vue@3.5.30_typescript@5.9.3/node_modules/vue/jsx-runtime/index.mjs
+var init_jsx_runtime = __esmMin((() => {
+	init_vue_runtime_esm_bundler();
+}));
+//#endregion
+export { init_vue_runtime_esm_bundler as n, init_jsx_runtime as t };

package/cli/templates/create/project/cabloy-basic/boilerplate/src/suite/cabloy-basic/modules/basic-siteadmin/assets/site/ssr-cabloyBasicAdmin-5.0.0/client/assets/vue-CsFxPVDb.js

@@ -0,0 +1,591 @@
+import { n as __esmMin } from "./rolldown-runtime-CSj9S6Td.js";
+import { A as isObject, B as looseToNumber, C as init_shared_esm_bundler, E as isFunction, K as toNumber, L as isSpecialBooleanAttr, R as isString, S as includeBooleanAttr, T as isArray, _ as extend, h as capitalize, j as isOn, k as isModelListener, m as camelize, w as invokeArrayFns, x as hyphenate, z as isSymbol } from "./vue-BeTi6w4D.js";
+import { a as callWithAsyncErrorHandling, h as init_runtime_core_esm_bundler, n as BaseTransitionPropsValidators, p as h, s as createHydrationRenderer, t as BaseTransition } from "./vue-DeT-l8pH.js";
+//#region node_modules/.pnpm/@cabloy+vue-runtime-dom@3.5.13/node_modules/@cabloy/vue-runtime-dom/dist/runtime-dom.esm-bundler.js
+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, isCancelled) => {
+		el._enterCancelled = isCancelled;
+		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);
+			if (!el._enterCancelled) {
+				forceReflow();
+				addTransitionClass(el, leaveActiveClass);
+			} else {
+				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, void 0, true);
+			callHook(onEnterCancelled, [el]);
+		},
+		onAppearCancelled(el) {
+			finishEnter(el, true, void 0, 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) {
+	return toNumber(val);
+}
+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 != null) 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 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 (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, isBoolean = isSpecialBooleanAttr(key)) {
+	if (isSVG && key.startsWith("xlink:")) if (value == null) el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
+	else el.setAttributeNS(xlinkNS, key, value);
+	else if (value == null || isBoolean && !includeBooleanAttr(value)) el.removeAttribute(key);
+	else el.setAttribute(key, isBoolean ? "" : isSymbol(value) ? String(value) : value);
+}
+function patchDOMProp(el, key, value, parentComponent, attrName) {
+	if (key === "innerHTML" || key === "textContent") {
+		if (value != null) el[key] = key === "innerHTML" ? unsafeToTrustedHTML(value) : value;
+		return;
+	}
+	const tag = el.tagName;
+	if (key === "value" && tag !== "PROGRESS" && !tag.includes("-")) {
+		const oldValue = tag === "OPTION" ? el.getAttribute("value") || "" : el.value;
+		const newValue = value == null ? el.type === "checkbox" ? "on" : "" : String(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) {}
+	needRemove && el.removeAttribute(attrName || 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 = nextValue;
+	else {
+		const [name, options] = parseName(rawName);
+		if (nextValue) addEventListener(el, name, invokers[rawName] = createInvoker(nextValue, instance), 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;
+		}
+	}
+	return [name[2] === ":" ? name.slice(3) : hyphenate(name.slice(2)), 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 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 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 ensureHydrationRenderer() {
+	renderer = enabledHydration ? renderer : createHydrationRenderer(rendererOptions);
+	enabledHydration = true;
+	return renderer;
+}
+function resolveRootNamespace(container) {
+	if (container instanceof SVGElement) return "svg";
+	if (typeof MathMLElement === "function" && container instanceof MathMLElement) return "mathml";
+}
+function normalizeContainer(container) {
+	if (isString(container)) return document.querySelector(container);
+	return container;
+}
+var policy, tt, unsafeToTrustedHTML, svgNS, mathmlNS, doc, templateContainer, nodeOps, TRANSITION, ANIMATION, vtcKey, DOMTransitionPropsValidators, TransitionPropsValidators, decorate$1, Transition, callHook, hasExplicitCallback, endId, vShowOriginalDisplay, vShowHidden, CSS_VAR_TEXT, displayRE, importantRE, prefixes, prefixCache, xlinkNS, veiKey, optionsModifierRE, cachedNow, p, getNow, isNativeOn, patchProp, getModelAssigner, assignKey, vModelText, systemModifiers, modifierGuards, withModifiers, rendererOptions, renderer, enabledHydration, createSSRApp;
+var init_runtime_dom_esm_bundler = __esmMin((() => {
+	init_runtime_core_esm_bundler();
+	init_runtime_core_esm_bundler();
+	init_shared_esm_bundler();
+	policy = void 0;
+	tt = typeof window !== "undefined" && window.trustedTypes;
+	if (tt) try {
+		policy = /* @__PURE__ */ tt.createPolicy("vue", { createHTML: (val) => val });
+	} catch (e) {}
+	unsafeToTrustedHTML = policy ? (val) => policy.createHTML(val) : (val) => val;
+	svgNS = "http://www.w3.org/2000/svg";
+	mathmlNS = "http://www.w3.org/1998/Math/MathML";
+	doc = typeof document !== "undefined" ? document : null;
+	templateContainer = doc && /* @__PURE__ */ doc.createElement("template");
+	nodeOps = {
+		insert: (child, parent, anchor) => {
+			parent.insertBefore(child, anchor || null);
+		},
+		remove: (child) => {
+			const parent = child.parentNode;
+			if (parent) parent.removeChild(child);
+		},
+		createElement: (tag, namespace, is, props) => {
+			const el = namespace === "svg" ? doc.createElementNS(svgNS, tag) : namespace === "mathml" ? doc.createElementNS(mathmlNS, tag) : is ? doc.createElement(tag, { is }) : doc.createElement(tag);
+			if (tag === "select" && props && props.multiple != null) el.setAttribute("multiple", props.multiple);
+			return el;
+		},
+		createText: (text) => doc.createTextNode(text),
+		createComment: (text) => doc.createComment(text),
+		setText: (node, text) => {
+			node.nodeValue = text;
+		},
+		setElementText: (el, text) => {
+			el.textContent = text;
+		},
+		parentNode: (node) => node.parentNode,
+		nextSibling: (node) => node.nextSibling,
+		querySelector: (selector) => doc.querySelector(selector),
+		setScopeId(el, id) {
+			el.setAttribute(id, "");
+		},
+		insertStaticContent(content, parent, anchor, namespace, start, end) {
+			const before = anchor ? anchor.previousSibling : parent.lastChild;
+			if (start && (start === end || start.nextSibling)) while (true) {
+				parent.insertBefore(start.cloneNode(true), anchor);
+				if (start === end || !(start = start.nextSibling)) break;
+			}
+			else {
+				templateContainer.innerHTML = unsafeToTrustedHTML(namespace === "svg" ? `<svg>${content}</svg>` : namespace === "mathml" ? `<math>${content}</math>` : content);
+				const template = templateContainer.content;
+				if (namespace === "svg" || namespace === "mathml") {
+					const wrapper = template.firstChild;
+					while (wrapper.firstChild) template.appendChild(wrapper.firstChild);
+					template.removeChild(wrapper);
+				}
+				parent.insertBefore(template, anchor);
+			}
+			return [before ? before.nextSibling : parent.firstChild, anchor ? anchor.previousSibling : parent.lastChild];
+		}
+	};
+	TRANSITION = "transition";
+	ANIMATION = "animation";
+	vtcKey = Symbol("_vtc");
+	DOMTransitionPropsValidators = {
+		name: String,
+		type: String,
+		css: {
+			type: Boolean,
+			default: true
+		},
+		duration: [
+			String,
+			Number,
+			Object
+		],
+		enterFromClass: String,
+		enterActiveClass: String,
+		enterToClass: String,
+		appearFromClass: String,
+		appearActiveClass: String,
+		appearToClass: String,
+		leaveFromClass: String,
+		leaveActiveClass: String,
+		leaveToClass: String
+	};
+	TransitionPropsValidators = /* @__PURE__ */ extend({}, BaseTransitionPropsValidators, DOMTransitionPropsValidators);
+	decorate$1 = (t) => {
+		t.displayName = "Transition";
+		t.props = TransitionPropsValidators;
+		return t;
+	};
+	Transition = /* @__PURE__ */ decorate$1((props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots));
+	callHook = (hook, args = []) => {
+		if (isArray(hook)) hook.forEach((h2) => h2(...args));
+		else if (hook) hook(...args);
+	};
+	hasExplicitCallback = (hook) => {
+		return hook ? isArray(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;
+	};
+	endId = 0;
+	vShowOriginalDisplay = Symbol("_vod");
+	vShowHidden = Symbol("_vsh");
+	CSS_VAR_TEXT = Symbol("");
+	displayRE = /(^|;)\s*display\s*:/;
+	importantRE = /\s*!important$/;
+	prefixes = [
+		"Webkit",
+		"Moz",
+		"ms"
+	];
+	prefixCache = {};
+	xlinkNS = "http://www.w3.org/1999/xlink";
+	veiKey = Symbol("_vei");
+	optionsModifierRE = /(?:Once|Passive|Capture)$/;
+	cachedNow = 0;
+	p = /* @__PURE__ */ Promise.resolve();
+	getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = Date.now());
+	isNativeOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key.charCodeAt(2) > 96 && key.charCodeAt(2) < 123;
+	patchProp = (el, key, prevValue, nextValue, namespace, parentComponent) => {
+		const isSVG = namespace === "svg";
+		if (key === "class") patchClass(el, nextValue, isSVG);
+		else if (key === "style") patchStyle(el, prevValue, nextValue);
+		else if (isOn(key)) {
+			if (!isModelListener(key)) patchEvent(el, key, prevValue, nextValue, parentComponent);
+		} else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {
+			patchDOMProp(el, key, nextValue);
+			if (!el.tagName.includes("-") && (key === "value" || key === "checked" || key === "selected")) patchAttr(el, key, nextValue, isSVG, parentComponent, key !== "value");
+		} else if (el._isVueCE && (/[A-Z]/.test(key) || !isString(nextValue))) patchDOMProp(el, camelize(key), nextValue, parentComponent, key);
+		else {
+			if (key === "true-value") el._trueValue = nextValue;
+			else if (key === "false-value") el._falseValue = nextValue;
+			patchAttr(el, key, nextValue, isSVG);
+		}
+	};
+	getModelAssigner = (vnode) => {
+		const fn = vnode.props["onUpdate:modelValue"] || false;
+		return isArray(fn) ? (value) => invokeArrayFns(fn, value) : fn;
+	};
+	assignKey = Symbol("_assign");
+	vModelText = {
+		created(el, { modifiers: { lazy, trim, number } }, vnode) {
+			if (!vnode.props) return;
+			el[assignKey] = getModelAssigner(vnode);
+			const castToNumber = number || vnode.props && vnode.props.type === "number";
+			addEventListener(el, lazy ? "change" : "input", (e) => {
+				if (e.target.composing) return;
+				let domValue = el.value;
+				if (trim) domValue = domValue.trim();
+				if (castToNumber) domValue = looseToNumber(domValue);
+				el[assignKey](domValue);
+			});
+			if (trim) addEventListener(el, "change", () => {
+				el.value = el.value.trim();
+			});
+			if (!lazy) {
+				addEventListener(el, "compositionstart", onCompositionStart);
+				addEventListener(el, "compositionend", onCompositionEnd);
+				addEventListener(el, "change", onCompositionEnd);
+			}
+		},
+		mounted(el, { value }) {
+			el.value = value == null ? "" : value;
+		},
+		beforeUpdate(el, { value, oldValue, modifiers: { lazy, trim, number } }, vnode) {
+			if (!vnode.props) return;
+			el[assignKey] = getModelAssigner(vnode);
+			if (el.composing) return;
+			const elValue = (number || el.type === "number") && !/^0\d/.test(el.value) ? looseToNumber(el.value) : el.value;
+			const newValue = value == null ? "" : value;
+			if (elValue === newValue) return;
+			if (document.activeElement === el && el.type !== "range") {
+				if (lazy && value === oldValue) return;
+				if (trim && el.value.trim() === newValue) return;
+			}
+			el.value = newValue;
+		}
+	};
+	systemModifiers = [
+		"ctrl",
+		"shift",
+		"alt",
+		"meta"
+	];
+	modifierGuards = {
+		stop: (e) => e.stopPropagation(),
+		prevent: (e) => e.preventDefault(),
+		self: (e) => e.target !== e.currentTarget,
+		ctrl: (e) => !e.ctrlKey,
+		shift: (e) => !e.shiftKey,
+		alt: (e) => !e.altKey,
+		meta: (e) => !e.metaKey,
+		left: (e) => "button" in e && e.button !== 0,
+		middle: (e) => "button" in e && e.button !== 1,
+		right: (e) => "button" in e && e.button !== 2,
+		exact: (e, modifiers) => systemModifiers.some((m) => e[`${m}Key`] && !modifiers.includes(m))
+	};
+	withModifiers = (fn, modifiers) => {
+		const cache = fn._withMods || (fn._withMods = {});
+		const cacheKey = modifiers.join(".");
+		return cache[cacheKey] || (cache[cacheKey] = (event, ...args) => {
+			for (let i = 0; i < modifiers.length; i++) {
+				const guard = modifierGuards[modifiers[i]];
+				if (guard && guard(event, modifiers)) return;
+			}
+			return fn(event, ...args);
+		});
+	};
+	rendererOptions = /* @__PURE__ */ extend({ patchProp }, nodeOps);
+	enabledHydration = false;
+	createSSRApp = (...args) => {
+		const app = ensureHydrationRenderer().createApp(...args);
+		const { mount } = app;
+		app.mount = (containerOrSelector) => {
+			const container = normalizeContainer(containerOrSelector);
+			if (container) return mount(container, true, resolveRootNamespace(container));
+		};
+		return app;
+	};
+}));
+//#endregion
+export { withModifiers as a, vModelText as i, createSSRApp as n, init_runtime_dom_esm_bundler as r, Transition as t };