@pubinfo/devtools 2.2.0-beta.2 → 2.2.0-beta.4

package/dist/client/assets/runtime-dom.esm-bundler-CEsf3eAe.js

@@ -0,0 +1,719 @@
+import { C as nextTick, Tt as toNumber, _t as isSymbol, at as extend, bt as looseToNumber, ct as invokeArrayFns, dt as isModelListener, f as createRenderer, ft as isObject, gt as isString, ht as isSpecialBooleanAttr, it as capitalize, lt as isArray, mt as isSet, n as BaseTransitionPropsValidators, o as callWithAsyncErrorHandling, ot as hyphenate, pt as isOn, rt as camelize, st as includeBooleanAttr, t as BaseTransition, ut as isFunction, vt as looseEqual, y as h, yt as looseIndexOf } from "./runtime-core.esm-bundler-CsZVtwV7.js";
+//#region ../../node_modules/.pnpm/@vue+runtime-dom@3.5.28/node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js
+/**
+* @vue/runtime-dom v3.5.28
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+var policy = void 0;
+var tt = typeof window !== "undefined" && window.trustedTypes;
+if (tt) try {
+	policy = /* @__PURE__ */ tt.createPolicy("vue", { createHTML: (val) => val });
+} catch (e) {}
+var unsafeToTrustedHTML = policy ? (val) => policy.createHTML(val) : (val) => val;
+var svgNS = "http://www.w3.org/2000/svg";
+var mathmlNS = "http://www.w3.org/1998/Math/MathML";
+var doc = typeof document !== "undefined" ? document : null;
+var templateContainer = doc && /* @__PURE__ */ doc.createElement("template");
+var 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];
+	}
+};
+var TRANSITION = "transition";
+var ANIMATION = "animation";
+var vtcKey = /* @__PURE__ */ Symbol("_vtc");
+var 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
+};
+var TransitionPropsValidators = /* @__PURE__ */ extend({}, BaseTransitionPropsValidators, DOMTransitionPropsValidators);
+var decorate$1 = (t) => {
+	t.displayName = "Transition";
+	t.props = TransitionPropsValidators;
+	return t;
+};
+var Transition = /* @__PURE__ */ decorate$1((props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots));
+var callHook = (hook, args = []) => {
+	if (isArray(hook)) hook.forEach((h2) => h2(...args));
+	else if (hook) hook(...args);
+};
+var hasExplicitCallback = (hook) => {
+	return hook ? isArray(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;
+};
+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(el);
+				addTransitionClass(el, leaveActiveClass);
+			} else {
+				addTransitionClass(el, leaveActiveClass);
+				forceReflow(el);
+			}
+			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);
+	});
+}
+var endId = 0;
+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(el) {
+	return (el ? el.ownerDocument : 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;
+}
+var vShowOriginalDisplay = /* @__PURE__ */ Symbol("_vod");
+var vShowHidden = /* @__PURE__ */ Symbol("_vsh");
+var CSS_VAR_TEXT = /* @__PURE__ */ Symbol("");
+var displayRE = /(?:^|;)\s*display\s*:/;
+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";
+	}
+}
+var importantRE = /\s*!important$/;
+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;
+		}
+	}
+}
+var prefixes = [
+	"Webkit",
+	"Moz",
+	"ms"
+];
+var prefixCache = {};
+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;
+}
+var xlinkNS = "http://www.w3.org/1999/xlink";
+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);
+}
+var veiKey = /* @__PURE__ */ Symbol("_vei");
+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;
+		}
+	}
+}
+var optionsModifierRE = /(?:Once|Passive|Capture)$/;
+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];
+}
+var cachedNow = 0;
+var p = /* @__PURE__ */ Promise.resolve();
+var getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = Date.now());
+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;
+}
+var isNativeOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key.charCodeAt(2) > 96 && key.charCodeAt(2) < 123;
+var 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);
+	}
+};
+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" || key === "autocorrect") return false;
+	if (key === "sandbox" && el.tagName === "IFRAME") 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;
+}
+var getModelAssigner = (vnode) => {
+	const fn = vnode.props["onUpdate:modelValue"] || false;
+	return isArray(fn) ? (value) => invokeArrayFns(fn, value) : fn;
+};
+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"));
+	}
+}
+var assignKey = /* @__PURE__ */ Symbol("_assign");
+function castValue(value, trim, number) {
+	if (trim) value = value.trim();
+	if (number) value = looseToNumber(value);
+	return value;
+}
+var vModelText = {
+	created(el, { modifiers: { lazy, trim, number } }, vnode) {
+		el[assignKey] = getModelAssigner(vnode);
+		const castToNumber = number || vnode.props && vnode.props.type === "number";
+		addEventListener(el, lazy ? "change" : "input", (e) => {
+			if (e.target.composing) return;
+			el[assignKey](castValue(el.value, trim, castToNumber));
+		});
+		if (trim || castToNumber) addEventListener(el, "change", () => {
+			el.value = castValue(el.value, trim, castToNumber);
+		});
+		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) {
+		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;
+	}
+};
+var vModelCheckbox = {
+	deep: true,
+	created(el, _, vnode) {
+		el[assignKey] = getModelAssigner(vnode);
+		addEventListener(el, "change", () => {
+			const modelValue = el._modelValue;
+			const elementValue = getValue(el);
+			const checked = el.checked;
+			const assign = el[assignKey];
+			if (isArray(modelValue)) {
+				const index = looseIndexOf(modelValue, elementValue);
+				const found = index !== -1;
+				if (checked && !found) assign(modelValue.concat(elementValue));
+				else if (!checked && found) {
+					const filtered = [...modelValue];
+					filtered.splice(index, 1);
+					assign(filtered);
+				}
+			} else if (isSet(modelValue)) {
+				const cloned = new Set(modelValue);
+				if (checked) cloned.add(elementValue);
+				else cloned.delete(elementValue);
+				assign(cloned);
+			} else assign(getCheckboxValue(el, checked));
+		});
+	},
+	mounted: setChecked,
+	beforeUpdate(el, binding, vnode) {
+		el[assignKey] = getModelAssigner(vnode);
+		setChecked(el, binding, vnode);
+	}
+};
+function setChecked(el, { value, oldValue }, vnode) {
+	el._modelValue = value;
+	let checked;
+	if (isArray(value)) checked = looseIndexOf(value, vnode.props.value) > -1;
+	else if (isSet(value)) checked = value.has(vnode.props.value);
+	else {
+		if (value === oldValue) return;
+		checked = looseEqual(value, getCheckboxValue(el, true));
+	}
+	if (el.checked !== checked) el.checked = checked;
+}
+var vModelRadio = {
+	created(el, { value }, vnode) {
+		el.checked = looseEqual(value, vnode.props.value);
+		el[assignKey] = getModelAssigner(vnode);
+		addEventListener(el, "change", () => {
+			el[assignKey](getValue(el));
+		});
+	},
+	beforeUpdate(el, { value, oldValue }, vnode) {
+		el[assignKey] = getModelAssigner(vnode);
+		if (value !== oldValue) el.checked = looseEqual(value, vnode.props.value);
+	}
+};
+var vModelSelect = {
+	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);
+	},
+	mounted(el, { value }) {
+		setSelected(el, value);
+	},
+	beforeUpdate(el, _binding, vnode) {
+		el[assignKey] = getModelAssigner(vnode);
+	},
+	updated(el, { value }) {
+		if (!el._assigning) setSelected(el, value);
+	}
+};
+function setSelected(el, value) {
+	const isMultiple = el.multiple;
+	const isArrayValue = isArray(value);
+	if (isMultiple && !isArrayValue && !isSet(value)) return;
+	for (let i = 0, l = el.options.length; i < l; i++) {
+		const option = el.options[i];
+		const optionValue = getValue(option);
+		if (isMultiple) if (isArrayValue) {
+			const optionType = typeof optionValue;
+			if (optionType === "string" || optionType === "number") option.selected = value.some((v) => String(v) === String(optionValue));
+			else option.selected = looseIndexOf(value, optionValue) > -1;
+		} else option.selected = value.has(optionValue);
+		else if (looseEqual(getValue(option), value)) {
+			if (el.selectedIndex !== i) el.selectedIndex = i;
+			return;
+		}
+	}
+	if (!isMultiple && el.selectedIndex !== -1) el.selectedIndex = -1;
+}
+function getValue(el) {
+	return "_value" in el ? el._value : el.value;
+}
+function getCheckboxValue(el, checked) {
+	const key = checked ? "_trueValue" : "_falseValue";
+	return key in el ? el[key] : checked;
+}
+var vModelDynamic = {
+	created(el, binding, vnode) {
+		callModelHook(el, binding, vnode, null, "created");
+	},
+	mounted(el, binding, vnode) {
+		callModelHook(el, binding, vnode, null, "mounted");
+	},
+	beforeUpdate(el, binding, vnode, prevVNode) {
+		callModelHook(el, binding, vnode, prevVNode, "beforeUpdate");
+	},
+	updated(el, binding, vnode, prevVNode) {
+		callModelHook(el, binding, vnode, prevVNode, "updated");
+	}
+};
+function resolveDynamicModel(tagName, type) {
+	switch (tagName) {
+		case "SELECT": return vModelSelect;
+		case "TEXTAREA": return vModelText;
+		default: switch (type) {
+			case "checkbox": return vModelCheckbox;
+			case "radio": return vModelRadio;
+			default: return vModelText;
+		}
+	}
+}
+function callModelHook(el, binding, vnode, prevVNode, hook) {
+	const fn = resolveDynamicModel(el.tagName, vnode.props && vnode.props.type)[hook];
+	fn && fn(el, binding, vnode, prevVNode);
+}
+var keyNames = {
+	esc: "escape",
+	space: " ",
+	up: "arrow-up",
+	left: "arrow-left",
+	right: "arrow-right",
+	down: "arrow-down",
+	delete: "backspace"
+};
+var withKeys = (fn, modifiers) => {
+	const cache = fn._withKeys || (fn._withKeys = {});
+	const cacheKey = modifiers.join(".");
+	return cache[cacheKey] || (cache[cacheKey] = ((event) => {
+		if (!("key" in event)) return;
+		const eventKey = hyphenate(event.key);
+		if (modifiers.some((k) => k === eventKey || keyNames[k] === eventKey)) return fn(event);
+	}));
+};
+var rendererOptions = /* @__PURE__ */ extend({ patchProp }, nodeOps);
+var renderer;
+function ensureRenderer() {
+	return renderer || (renderer = createRenderer(rendererOptions));
+}
+var createApp = ((...args) => {
+	const app = ensureRenderer().createApp(...args);
+	const { mount } = app;
+	app.mount = (containerOrSelector) => {
+		const container = normalizeContainer(containerOrSelector);
+		if (!container) return;
+		const component = app._component;
+		if (!isFunction(component) && !component.render && !component.template) component.template = container.innerHTML;
+		if (container.nodeType === 1) container.textContent = "";
+		const proxy = mount(container, false, resolveRootNamespace(container));
+		if (container instanceof Element) {
+			container.removeAttribute("v-cloak");
+			container.setAttribute("data-v-app", "");
+		}
+		return proxy;
+	};
+	return app;
+});
+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;
+}
+//#endregion
+export { vModelRadio as a, withKeys as c, vModelDynamic as i, createApp as n, vModelSelect as o, vModelCheckbox as r, vModelText as s, Transition as t };