npm - @vue/runtime-dom - Versions diffs - 3.6.0-beta.3 → 3.6.0-beta.5 - Mend

@vue/runtime-dom 3.6.0-beta.3 → 3.6.0-beta.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/runtime-dom.cjs.js +1316 -1717
package/dist/runtime-dom.cjs.prod.js +1227 -1574
package/dist/runtime-dom.d.ts +1285 -1276
package/dist/runtime-dom.esm-browser.js +8687 -12174
package/dist/runtime-dom.esm-browser.prod.js +7 -6
package/dist/runtime-dom.esm-bundler.js +1388 -1783
package/dist/runtime-dom.global.js +9939 -13323
package/dist/runtime-dom.global.prod.js +7 -6
package/package.json +4 -4

package/dist/runtime-dom.cjs.prod.js CHANGED Viewed

@@ -1,1774 +1,1424 @@
 /**
-* @vue/runtime-dom v3.6.0-beta.3
-* (c) 2018-present Yuxi (Evan) You and Vue contributors
-* @license MIT
-**/
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-var runtimeCore = require('@vue/runtime-core');
-var shared = require('@vue/shared');
+  * @vue/runtime-dom v3.6.0-beta.5
+  * (c) 2018-present Yuxi (Evan) You and Vue contributors
+  * @license MIT
+  **/
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+let _vue_runtime_core = require("@vue/runtime-core");
+let _vue_shared = require("@vue/shared");
+//#region packages/runtime-dom/src/nodeOps.ts
 let policy = void 0;
 const tt = typeof window !== "undefined" && window.trustedTypes;
-if (tt) {
-  try {
-    policy = /* @__PURE__ */ tt.createPolicy("vue", {
-      createHTML: (val) => val
-    });
-  } catch (e) {
-  }
-}
+if (tt) try {
+	policy = /* @__PURE__ */ tt.createPolicy("vue", { createHTML: (val) => val });
+} catch (e) {}
 const unsafeToTrustedHTML = policy ? (val) => policy.createHTML(val) : (val) => val;
 const svgNS = "http://www.w3.org/2000/svg";
 const mathmlNS = "http://www.w3.org/1998/Math/MathML";
 const doc = typeof document !== "undefined" ? document : null;
 const templateContainer = doc && /* @__PURE__ */ doc.createElement("template");
 const 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, "");
-  },
-  // __UNSAFE__
-  // Reason: innerHTML.
-  // Static content here can only come from compiled templates.
-  // As long as the user only uses trusted templates, this is safe.
-  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 [
-      // first
-      before ? before.nextSibling : parent.firstChild,
-      // last
-      anchor ? anchor.previousSibling : parent.lastChild
-    ];
-  }
+	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];
+	}
 };
+//#endregion
+//#region packages/runtime-dom/src/components/Transition.ts
 const TRANSITION = "transition";
 const ANIMATION = "animation";
-const vtcKey = /* @__PURE__ */ Symbol("_vtc");
+const vtcKey = Symbol("_vtc");
 const 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
+	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
 };
-const TransitionPropsValidators = /* @__PURE__ */ shared.extend(
-  {},
-  runtimeCore.BaseTransitionPropsValidators,
-  DOMTransitionPropsValidators
-);
+const TransitionPropsValidators = /* @__PURE__ */ (0, _vue_shared.extend)({}, _vue_runtime_core.BaseTransitionPropsValidators, DOMTransitionPropsValidators);
+/**
+* Wrap logic that attaches extra properties to Transition in a function
+* so that it can be annotated as pure
+*/
 const decorate$1 = (t) => {
-  t.displayName = "Transition";
-  t.props = TransitionPropsValidators;
-  return t;
+	t.displayName = "Transition";
+	t.props = TransitionPropsValidators;
+	return t;
 };
-const Transition = /* @__PURE__ */ decorate$1(
-  (props, { slots }) => runtimeCore.h(runtimeCore.BaseTransition, resolveTransitionProps(props), slots)
-);
+/**
+* DOM Transition is a higher-order-component based on the platform-agnostic
+* base Transition component, with DOM-specific logic.
+*/
+const Transition = /* @__PURE__ */ decorate$1((props, { slots }) => (0, _vue_runtime_core.h)(_vue_runtime_core.BaseTransition, resolveTransitionProps(props), slots));
+/**
+* #3227 Incoming hooks may be merged into arrays when wrapping Transition
+* with custom HOCs.
+*/
 const callHook = (hook, args = []) => {
-  if (shared.isArray(hook)) {
-    hook.forEach((h2) => h2(...args));
-  } else if (hook) {
-    hook(...args);
-  }
+	if ((0, _vue_shared.isArray)(hook)) hook.forEach((h) => h(...args));
+	else if (hook) hook(...args);
 };
+/**
+* Check if a hook expects a callback (2nd arg), which means the user
+* intends to explicitly control the end of the transition.
+*/
 const hasExplicitCallback = (hook) => {
-  return hook ? shared.isArray(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;
+	return hook ? (0, _vue_shared.isArray)(hook) ? hook.some((h) => h.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 shared.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]);
-    }
-  });
+	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 (0, _vue_shared.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 (shared.isObject(duration)) {
-    return [NumberOf(duration.enter), NumberOf(duration.leave)];
-  } else {
-    const n = NumberOf(duration);
-    return [n, n];
-  }
+	if (duration == null) return null;
+	else if ((0, _vue_shared.isObject)(duration)) return [NumberOf(duration.enter), NumberOf(duration.leave)];
+	else {
+		const n = NumberOf(duration);
+		return [n, n];
+	}
 }
 function NumberOf(val) {
-  const res = shared.toNumber(val);
-  return res;
+	return (0, _vue_shared.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);
+	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;
-    }
-  }
+	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);
-  });
+	requestAnimationFrame(() => {
+		requestAnimationFrame(cb);
+	});
 }
 let 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);
+	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
-  };
+	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])));
+	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;
+	if (s === "auto") return 0;
+	return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
 }
 function forceReflow(el) {
-  const targetDocument = el ? el.ownerDocument : document;
-  return targetDocument.body.offsetHeight;
+	return (el ? el.ownerDocument : document).body.offsetHeight;
 }
+//#endregion
+//#region packages/runtime-dom/src/modules/class.ts
 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;
-  }
+	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;
 }
-const vShowOriginalDisplay = /* @__PURE__ */ Symbol("_vod");
-const vShowHidden = /* @__PURE__ */ Symbol("_vsh");
+//#endregion
+//#region packages/runtime-dom/src/directives/vShow.ts
+const vShowOriginalDisplay = Symbol("_vod");
+const vShowHidden = Symbol("_vsh");
 const vShow = {
-  // used for prop mismatch check during hydration
-  name: "show",
-  beforeMount(el, { value }, { transition }) {
-    el[vShowOriginalDisplay] = el.style.display === "none" ? "" : el.style.display;
-    if (transition && value) {
-      transition.beforeEnter(el);
-    } else {
-      setDisplay(el, value);
-    }
-  },
-  mounted(el, { value }, { transition }) {
-    if (transition && value) {
-      transition.enter(el);
-    }
-  },
-  updated(el, { value, oldValue }, { transition }) {
-    if (!value === !oldValue) return;
-    if (transition) {
-      if (value) {
-        transition.beforeEnter(el);
-        setDisplay(el, true);
-        transition.enter(el);
-      } else {
-        transition.leave(el, () => {
-          setDisplay(el, false);
-        });
-      }
-    } else {
-      setDisplay(el, value);
-    }
-  },
-  beforeUnmount(el, { value }) {
-    setDisplay(el, value);
-  }
+	name: "show",
+	beforeMount(el, { value }, { transition }) {
+		el[vShowOriginalDisplay] = el.style.display === "none" ? "" : el.style.display;
+		if (transition && value) transition.beforeEnter(el);
+		else setDisplay(el, value);
+	},
+	mounted(el, { value }, { transition }) {
+		if (transition && value) transition.enter(el);
+	},
+	updated(el, { value, oldValue }, { transition }) {
+		if (!value === !oldValue) return;
+		if (transition) if (value) {
+			transition.beforeEnter(el);
+			setDisplay(el, true);
+			transition.enter(el);
+		} else transition.leave(el, () => {
+			setDisplay(el, false);
+		});
+		else setDisplay(el, value);
+	},
+	beforeUnmount(el, { value }) {
+		setDisplay(el, value);
+	}
 };
 function setDisplay(el, value) {
-  el.style.display = value ? el[vShowOriginalDisplay] : "none";
-  el[vShowHidden] = !value;
+	el.style.display = value ? el[vShowOriginalDisplay] : "none";
+	el[vShowHidden] = !value;
 }
 function initVShowForSSR() {
-  vShow.getSSRProps = ({ value }) => {
-    if (!value) {
-      return { style: { display: "none" } };
-    }
-  };
+	vShow.getSSRProps = ({ value }) => {
+		if (!value) return { style: { display: "none" } };
+	};
 }
-const CSS_VAR_TEXT = /* @__PURE__ */ Symbol("");
-function useCssVars(getter) {
-  return;
-}
+//#endregion
+//#region packages/runtime-dom/src/helpers/useCssVars.ts
+const CSS_VAR_TEXT = Symbol("");
+/**
+* Runtime helper for SFC's CSS variable injection feature.
+* @private
+*/
+function useCssVars(getter) {}
+//#endregion
+//#region packages/runtime-dom/src/modules/style.ts
 const displayRE = /(?:^|;)\s*display\s*:/;
 function patchStyle(el, prev, next) {
-  const style = el.style;
-  const isCssString = shared.isString(next);
-  let hasControlledDisplay = false;
-  if (next && !isCssString) {
-    if (prev) {
-      if (!shared.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";
-    }
-  }
+	const style = el.style;
+	const isCssString = (0, _vue_shared.isString)(next);
+	let hasControlledDisplay = false;
+	if (next && !isCssString) {
+		if (prev) if (!(0, _vue_shared.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";
+	}
 }
 const importantRE = /\s*!important$/;
 function setStyle(style, name, rawVal) {
-  if (shared.isArray(rawVal)) {
-    rawVal.forEach((v) => setStyle(style, name, v));
-  } else {
-    const val = rawVal == null ? "" : String(rawVal);
-    if (name.startsWith("--")) {
-      style.setProperty(name, val);
-    } else {
-      const prefixed = autoPrefix(style, name);
-      if (importantRE.test(val)) {
-        style.setProperty(
-          shared.hyphenate(prefixed),
-          val.replace(importantRE, ""),
-          "important"
-        );
-      } else {
-        style[prefixed] = val;
-      }
-    }
-  }
+	if ((0, _vue_shared.isArray)(rawVal)) rawVal.forEach((v) => setStyle(style, name, v));
+	else {
+		const val = rawVal == null ? "" : String(rawVal);
+		if (name.startsWith("--")) style.setProperty(name, val);
+		else {
+			const prefixed = autoPrefix(style, name);
+			if (importantRE.test(val)) style.setProperty((0, _vue_shared.hyphenate)(prefixed), val.replace(importantRE, ""), "important");
+			else style[prefixed] = val;
+		}
+	}
 }
-const prefixes = ["Webkit", "Moz", "ms"];
+const prefixes = [
+	"Webkit",
+	"Moz",
+	"ms"
+];
 const prefixCache = {};
 function autoPrefix(style, rawName) {
-  const cached = prefixCache[rawName];
-  if (cached) {
-    return cached;
-  }
-  let name = runtimeCore.camelize(rawName);
-  if (name !== "filter" && name in style) {
-    return prefixCache[rawName] = name;
-  }
-  name = shared.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;
+	const cached = prefixCache[rawName];
+	if (cached) return cached;
+	let name = (0, _vue_runtime_core.camelize)(rawName);
+	if (name !== "filter" && name in style) return prefixCache[rawName] = name;
+	name = (0, _vue_shared.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;
 }
+//#endregion
+//#region packages/runtime-dom/src/modules/attrs.ts
 const xlinkNS = "http://www.w3.org/1999/xlink";
-function patchAttr(el, key, value, isSVG, instance, isBoolean = shared.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 && !shared.includeBooleanAttr(value)) {
-      el.removeAttribute(key);
-    } else {
-      el.setAttribute(
-        key,
-        isBoolean ? "" : shared.isSymbol(value) ? String(value) : value
-      );
-    }
-  }
+function patchAttr(el, key, value, isSVG, instance, isBoolean = (0, _vue_shared.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 && !(0, _vue_shared.includeBooleanAttr)(value)) el.removeAttribute(key);
+	else el.setAttribute(key, isBoolean ? "" : (0, _vue_shared.isSymbol)(value) ? String(value) : value);
 }
+//#endregion
+//#region packages/runtime-dom/src/modules/props.ts
 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" && shared.canSetValueDirectly(tag)) {
-    const oldValue = tag === "OPTION" ? el.getAttribute("value") || "" : el.value;
-    const newValue = value == null ? (
-      // #11647: value should be set as empty string for null and undefined,
-      // but <input type="checkbox"> should be set as 'on'.
-      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 = shared.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);
+	if (key === "innerHTML" || key === "textContent") {
+		if (value != null) el[key] = key === "innerHTML" ? unsafeToTrustedHTML(value) : value;
+		return;
+	}
+	const tag = el.tagName;
+	if (key === "value" && (0, _vue_shared.canSetValueDirectly)(tag)) {
+		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 = (0, _vue_shared.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);
 }
+//#endregion
+//#region packages/runtime-dom/src/modules/events.ts
 function addEventListener(el, event, handler, options) {
-  el.addEventListener(event, handler, options);
+	el.addEventListener(event, handler, options);
 }
 function removeEventListener(el, event, handler, options) {
-  el.removeEventListener(event, handler, options);
+	el.removeEventListener(event, handler, options);
 }
-const veiKey = /* @__PURE__ */ Symbol("_vei");
+const veiKey = 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) {
-      const invoker = invokers[rawName] = createInvoker(
-        nextValue,
-        instance
-      );
-      addEventListener(el, name, invoker, options);
-    } else if (existingInvoker) {
-      removeEventListener(el, name, existingInvoker, options);
-      invokers[rawName] = void 0;
-    }
-  }
+	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;
+		}
+	}
 }
 const 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;
-    }
-  }
-  const event = name[2] === ":" ? name.slice(3) : shared.hyphenate(name.slice(2));
-  return [event, options];
+	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) : (0, _vue_shared.hyphenate)(name.slice(2)), options];
 }
 let cachedNow = 0;
 const p = /* @__PURE__ */ Promise.resolve();
 const 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;
-    }
-    runtimeCore.callWithAsyncErrorHandling(
-      patchStopImmediatePropagation(e, invoker.value),
-      instance,
-      5,
-      [e]
-    );
-  };
-  invoker.value = initialValue;
-  invoker.attached = getNow();
-  return invoker;
+	const invoker = (e) => {
+		if (!e._vts) e._vts = Date.now();
+		else if (e._vts <= invoker.attached) return;
+		(0, _vue_runtime_core.callWithAsyncErrorHandling)(patchStopImmediatePropagation(e, invoker.value), instance, 5, [e]);
+	};
+	invoker.value = initialValue;
+	invoker.attached = getNow();
+	return invoker;
 }
 function patchStopImmediatePropagation(e, value) {
-  if (shared.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;
-  }
+	if ((0, _vue_shared.isArray)(value)) {
+		const originalStop = e.stopImmediatePropagation;
+		e.stopImmediatePropagation = () => {
+			originalStop.call(e);
+			e._stopped = true;
+		};
+		return value.map((fn) => (e) => !e._stopped && fn && fn(e));
+	} else return value;
 }
+//#endregion
+//#region packages/runtime-dom/src/patchProp.ts
 const 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 (shared.isOn(key)) {
-    if (!shared.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 (
-    // #11081 force set props for possible async custom element
-    el._isVueCE && (/[A-Z]/.test(key) || !shared.isString(nextValue))
-  ) {
-    patchDOMProp(el, shared.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);
-  }
+	const isSVG = namespace === "svg";
+	if (key === "class") patchClass(el, nextValue, isSVG);
+	else if (key === "style") patchStyle(el, prevValue, nextValue);
+	else if ((0, _vue_shared.isOn)(key)) {
+		if (!(0, _vue_shared.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, parentComponent);
+		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) || !(0, _vue_shared.isString)(nextValue))) patchDOMProp(el, (0, _vue_shared.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, parentComponent);
+	}
 };
 function shouldSetAsProp(el, key, value, isSVG) {
-  if (isSVG) {
-    if (key === "innerHTML" || key === "textContent") {
-      return true;
-    }
-    if (key in el && shared.isNativeOn(key) && shared.isFunction(value)) {
-      return true;
-    }
-    return false;
-  }
-  if (shared.shouldSetAsAttr(el.tagName, key)) {
-    return false;
-  }
-  if (shared.isNativeOn(key) && shared.isString(value)) {
-    return false;
-  }
-  return key in el;
+	if (isSVG) {
+		if (key === "innerHTML" || key === "textContent") return true;
+		if (key in el && (0, _vue_shared.isNativeOn)(key) && (0, _vue_shared.isFunction)(value)) return true;
+		return false;
+	}
+	if ((0, _vue_shared.shouldSetAsAttr)(el.tagName, key)) return false;
+	if ((0, _vue_shared.isNativeOn)(key) && (0, _vue_shared.isString)(value)) return false;
+	return key in el;
 }
+//#endregion
+//#region packages/runtime-dom/src/apiCustomElement.ts
 const REMOVAL = {};
-// @__NO_SIDE_EFFECTS__
+/* @__NO_SIDE_EFFECTS__ */
 function defineCustomElement(options, extraOptions, _createApp) {
-  let Comp = runtimeCore.defineComponent(options, extraOptions);
-  if (shared.isPlainObject(Comp)) Comp = shared.extend({}, Comp, extraOptions);
-  class VueCustomElement extends VueElement {
-    constructor(initialProps) {
-      super(Comp, initialProps, _createApp);
-    }
-  }
-  VueCustomElement.def = Comp;
-  return VueCustomElement;
+	let Comp = (0, _vue_runtime_core.defineComponent)(options, extraOptions);
+	if ((0, _vue_shared.isPlainObject)(Comp)) Comp = (0, _vue_shared.extend)({}, Comp, extraOptions);
+	class VueCustomElement extends VueElement {
+		constructor(initialProps) {
+			super(Comp, initialProps, _createApp);
+		}
+	}
+	VueCustomElement.def = Comp;
+	return VueCustomElement;
 }
-const defineSSRCustomElement = (/* @__NO_SIDE_EFFECTS__ */ (options, extraOptions) => {
-  return /* @__PURE__ */ defineCustomElement(options, extraOptions, createSSRApp);
+const defineSSRCustomElement = ((options, extraOptions) => {
+	return /* @__PURE__ */ defineCustomElement(options, extraOptions, createSSRApp);
 });
-const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class {
+const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class {};
+var VueElementBase = class VueElementBase extends BaseClass {
+	constructor(def, props = {}, createAppFn) {
+		super();
+		this._isVueCE = true;
+		this._instance = null;
+		this._app = null;
+		this._connected = false;
+		this._resolved = false;
+		this._numberProps = null;
+		this._styleChildren = /* @__PURE__ */ new WeakSet();
+		this._patching = false;
+		this._dirty = false;
+		this._ob = null;
+		this._def = def;
+		this._props = props;
+		this._createApp = createAppFn;
+		this._nonce = def.nonce;
+		if (this._needsHydration()) this._root = this.shadowRoot;
+		else if (def.shadowRoot !== false) {
+			this.attachShadow((0, _vue_shared.extend)({}, def.shadowRootOptions, { mode: "open" }));
+			this._root = this.shadowRoot;
+		} else this._root = this;
+	}
+	connectedCallback() {
+		if (!this.isConnected) return;
+		if (!this.shadowRoot && !this._resolved) this._parseSlots();
+		this._connected = true;
+		let parent = this;
+		while (parent = parent && (parent.parentNode || parent.host)) if (parent instanceof VueElementBase) {
+			this._parent = parent;
+			break;
+		}
+		if (!this._instance) if (this._resolved) this._mountComponent(this._def);
+		else if (parent && parent._pendingResolve) this._pendingResolve = parent._pendingResolve.then(() => {
+			this._pendingResolve = void 0;
+			this._resolveDef();
+		});
+		else this._resolveDef();
+	}
+	disconnectedCallback() {
+		this._connected = false;
+		(0, _vue_runtime_core.nextTick)(() => {
+			if (!this._connected) {
+				if (this._ob) {
+					this._ob.disconnect();
+					this._ob = null;
+				}
+				this._unmount();
+				if (this._teleportTargets) {
+					this._teleportTargets.clear();
+					this._teleportTargets = void 0;
+				}
+			}
+		});
+	}
+	_setParent(parent = this._parent) {
+		if (parent && this._instance) {
+			this._instance.parent = parent._instance;
+			this._inheritParentContext(parent);
+		}
+	}
+	_inheritParentContext(parent = this._parent) {
+		if (parent && this._app) Object.setPrototypeOf(this._app._context.provides, parent._instance.provides);
+	}
+	_processMutations(mutations) {
+		for (const m of mutations) this._setAttr(m.attributeName);
+	}
+	/**
+	* resolve inner component definition (handle possible async component)
+	*/
+	_resolveDef() {
+		if (this._pendingResolve) return;
+		for (let i = 0; i < this.attributes.length; i++) this._setAttr(this.attributes[i].name);
+		this._ob = new MutationObserver(this._processMutations.bind(this));
+		this._ob.observe(this, { attributes: true });
+		const resolve = (def) => {
+			this._resolved = true;
+			this._pendingResolve = void 0;
+			const { props, styles } = def;
+			let numberProps;
+			if (props && !(0, _vue_shared.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] = (0, _vue_shared.toNumber)(this._props[key]);
+					(numberProps || (numberProps = Object.create(null)))[(0, _vue_shared.camelize)(key)] = true;
+				}
+			}
+			this._numberProps = numberProps;
+			this._resolveProps(def);
+			if (this.shadowRoot) this._applyStyles(styles);
+			this._mountComponent(def);
+		};
+		const asyncDef = this._def.__asyncLoader;
+		if (asyncDef) {
+			const { configureApp } = this._def;
+			this._pendingResolve = asyncDef().then((def) => {
+				def.configureApp = configureApp;
+				this._def = def;
+				resolve(def);
+			});
+		} else resolve(this._def);
+	}
+	_mountComponent(def) {
+		this._mount(def);
+		this._processExposed();
+	}
+	_processExposed() {
+		const exposed = this._instance && this._instance.exposed;
+		if (!exposed) return;
+		for (const key in exposed) if (!(0, _vue_shared.hasOwn)(this, key)) Object.defineProperty(this, key, { get: () => (0, _vue_runtime_core.unref)(exposed[key]) });
+	}
+	_processInstance() {
+		this._instance.ce = this;
+		this._instance.isCE = true;
+		const dispatch = (event, args) => {
+			this.dispatchEvent(new CustomEvent(event, (0, _vue_shared.isPlainObject)(args[0]) ? (0, _vue_shared.extend)({ detail: args }, args[0]) : { detail: args }));
+		};
+		this._instance.emit = (event, ...args) => {
+			dispatch(event, args);
+			if ((0, _vue_shared.hyphenate)(event) !== event) dispatch((0, _vue_shared.hyphenate)(event), args);
+		};
+		this._setParent();
+	}
+	_resolveProps(def) {
+		const { props } = def;
+		const declaredPropKeys = (0, _vue_shared.isArray)(props) ? props : Object.keys(props || {});
+		for (const key of Object.keys(this)) if (key[0] !== "_" && declaredPropKeys.includes(key)) this._setProp(key, this[key]);
+		for (const key of declaredPropKeys.map(_vue_shared.camelize)) Object.defineProperty(this, key, {
+			get() {
+				return this._getProp(key);
+			},
+			set(val) {
+				this._setProp(key, val, true, !this._patching);
+			}
+		});
+	}
+	_setAttr(key) {
+		if (key.startsWith("data-v-")) return;
+		const has = this.hasAttribute(key);
+		let value = has ? this.getAttribute(key) : REMOVAL;
+		const camelKey = (0, _vue_shared.camelize)(key);
+		if (has && this._numberProps && this._numberProps[camelKey]) value = (0, _vue_shared.toNumber)(value);
+		this._setProp(camelKey, value, false, true);
+	}
+	/**
+	* @internal
+	*/
+	_getProp(key) {
+		return this._props[key];
+	}
+	/**
+	* @internal
+	*/
+	_setProp(key, val, shouldReflect = true, shouldUpdate = false) {
+		if (val !== this._props[key]) {
+			this._dirty = true;
+			if (val === REMOVAL) delete this._props[key];
+			else {
+				this._props[key] = val;
+				if (key === "key" && this._app && this._app._ceVNode) this._app._ceVNode.key = val;
+			}
+			if (shouldUpdate && this._instance) this._update();
+			if (shouldReflect) {
+				const ob = this._ob;
+				if (ob) {
+					this._processMutations(ob.takeRecords());
+					ob.disconnect();
+				}
+				if (val === true) this.setAttribute((0, _vue_shared.hyphenate)(key), "");
+				else if (typeof val === "string" || typeof val === "number") this.setAttribute((0, _vue_shared.hyphenate)(key), val + "");
+				else if (!val) this.removeAttribute((0, _vue_shared.hyphenate)(key));
+				ob && ob.observe(this, { attributes: true });
+			}
+		}
+	}
+	_applyStyles(styles, owner) {
+		if (!styles) return;
+		if (owner) {
+			if (owner === this._def || this._styleChildren.has(owner)) return;
+			this._styleChildren.add(owner);
+		}
+		const nonce = this._nonce;
+		for (let i = styles.length - 1; i >= 0; i--) {
+			const s = document.createElement("style");
+			if (nonce) s.setAttribute("nonce", nonce);
+			s.textContent = styles[i];
+			this.shadowRoot.prepend(s);
+		}
+	}
+	/**
+	* Only called when shadowRoot is false
+	*/
+	_parseSlots() {
+		const slots = this._slots = {};
+		let n;
+		while (n = this.firstChild) {
+			const slotName = n.nodeType === 1 && n.getAttribute("slot") || "default";
+			(slots[slotName] || (slots[slotName] = [])).push(n);
+			this.removeChild(n);
+		}
+	}
+	/**
+	* Only called when shadowRoot is false
+	*/
+	_renderSlots() {
+		const outlets = this._getSlots();
+		const scopeId = this._instance.type.__scopeId;
+		const slotReplacements = /* @__PURE__ */ new Map();
+		for (let i = 0; i < outlets.length; i++) {
+			const o = outlets[i];
+			const slotName = o.getAttribute("name") || "default";
+			const content = this._slots[slotName];
+			const parent = o.parentNode;
+			const replacementNodes = [];
+			if (content) for (const n of content) {
+				if (scopeId && n.nodeType === 1) {
+					const id = scopeId + "-s";
+					const walker = document.createTreeWalker(n, 1);
+					n.setAttribute(id, "");
+					let child;
+					while (child = walker.nextNode()) child.setAttribute(id, "");
+				}
+				parent.insertBefore(n, o);
+				replacementNodes.push(n);
+			}
+			else while (o.firstChild) {
+				const child = o.firstChild;
+				parent.insertBefore(child, o);
+				replacementNodes.push(child);
+			}
+			parent.removeChild(o);
+			slotReplacements.set(o, replacementNodes);
+		}
+		this._updateSlotNodes(slotReplacements);
+	}
+	/**
+	* @internal
+	*/
+	_getSlots() {
+		const roots = [this];
+		if (this._teleportTargets) roots.push(...this._teleportTargets);
+		const slots = /* @__PURE__ */ new Set();
+		for (const root of roots) {
+			const found = root.querySelectorAll("slot");
+			for (let i = 0; i < found.length; i++) slots.add(found[i]);
+		}
+		return Array.from(slots);
+	}
+	/**
+	* @internal
+	*/
+	_injectChildStyle(comp) {
+		this._applyStyles(comp.styles, comp);
+	}
+	/**
+	* @internal
+	*/
+	_beginPatch() {
+		this._patching = true;
+		this._dirty = false;
+	}
+	/**
+	* @internal
+	*/
+	_endPatch() {
+		this._patching = false;
+		if (this._dirty && this._instance) this._update();
+	}
+	/**
+	* @internal
+	*/
+	_hasShadowRoot() {
+		return this._def.shadowRoot !== false;
+	}
+	/**
+	* @internal
+	*/
+	_removeChildStyle(comp) {}
+};
+var VueElement = class extends VueElementBase {
+	constructor(def, props = {}, createAppFn = createApp) {
+		super(def, props, createAppFn);
+	}
+	_needsHydration() {
+		if (this.shadowRoot && this._createApp !== createApp) return true;
+		return false;
+	}
+	_mount(def) {
+		this._app = this._createApp(def);
+		this._inheritParentContext();
+		if (def.configureApp) def.configureApp(this._app);
+		this._app._ceVNode = this._createVNode();
+		this._app.mount(this._root);
+	}
+	_update() {
+		if (!this._app) return;
+		const vnode = this._createVNode();
+		vnode.appContext = this._app._context;
+		render(vnode, this._root);
+	}
+	_unmount() {
+		if (this._app) this._app.unmount();
+		if (this._instance && this._instance.ce) this._instance.ce = void 0;
+		this._app = this._instance = null;
+	}
+	/**
+	* Only called when shadowRoot is false
+	*/
+	_updateSlotNodes(replacements) {}
+	_createVNode() {
+		const baseProps = {};
+		if (!this.shadowRoot) baseProps.onVnodeMounted = baseProps.onVnodeUpdated = this._renderSlots.bind(this);
+		const vnode = (0, _vue_runtime_core.createVNode)(this._def, (0, _vue_shared.extend)(baseProps, this._props));
+		if (!this._instance) vnode.ce = (instance) => {
+			this._instance = instance;
+			this._processInstance();
+		};
+		return vnode;
+	}
 };
-class VueElementBase extends BaseClass {
-  constructor(def, props = {}, createAppFn) {
-    super();
-    this._isVueCE = true;
-    /**
-     * @internal
-     */
-    this._instance = null;
-    /**
-     * @internal
-     */
-    this._app = null;
-    this._connected = false;
-    this._resolved = false;
-    this._numberProps = null;
-    this._styleChildren = /* @__PURE__ */ new WeakSet();
-    this._patching = false;
-    this._dirty = false;
-    this._ob = null;
-    this._def = def;
-    this._props = props;
-    this._createApp = createAppFn;
-    this._nonce = def.nonce;
-    if (this._needsHydration()) {
-      this._root = this.shadowRoot;
-    } else {
-      if (def.shadowRoot !== false) {
-        this.attachShadow(
-          shared.extend({}, def.shadowRootOptions, {
-            mode: "open"
-          })
-        );
-        this._root = this.shadowRoot;
-      } else {
-        this._root = this;
-      }
-    }
-  }
-  connectedCallback() {
-    if (!this.isConnected) return;
-    if (!this.shadowRoot && !this._resolved) {
-      this._parseSlots();
-    }
-    this._connected = true;
-    let parent = this;
-    while (parent = parent && (parent.parentNode || parent.host)) {
-      if (parent instanceof VueElementBase) {
-        this._parent = parent;
-        break;
-      }
-    }
-    if (!this._instance) {
-      if (this._resolved) {
-        this._mountComponent(this._def);
-      } else {
-        if (parent && parent._pendingResolve) {
-          this._pendingResolve = parent._pendingResolve.then(() => {
-            this._pendingResolve = void 0;
-            this._resolveDef();
-          });
-        } else {
-          this._resolveDef();
-        }
-      }
-    }
-  }
-  disconnectedCallback() {
-    this._connected = false;
-    runtimeCore.nextTick(() => {
-      if (!this._connected) {
-        if (this._ob) {
-          this._ob.disconnect();
-          this._ob = null;
-        }
-        this._unmount();
-        if (this._teleportTargets) {
-          this._teleportTargets.clear();
-          this._teleportTargets = void 0;
-        }
-      }
-    });
-  }
-  _setParent(parent = this._parent) {
-    if (parent && this._instance) {
-      this._instance.parent = parent._instance;
-      this._inheritParentContext(parent);
-    }
-  }
-  _inheritParentContext(parent = this._parent) {
-    if (parent && this._app) {
-      Object.setPrototypeOf(
-        this._app._context.provides,
-        parent._instance.provides
-      );
-    }
-  }
-  _processMutations(mutations) {
-    for (const m of mutations) {
-      this._setAttr(m.attributeName);
-    }
-  }
-  /**
-   * resolve inner component definition (handle possible async component)
-   */
-  _resolveDef() {
-    if (this._pendingResolve) {
-      return;
-    }
-    for (let i = 0; i < this.attributes.length; i++) {
-      this._setAttr(this.attributes[i].name);
-    }
-    this._ob = new MutationObserver(this._processMutations.bind(this));
-    this._ob.observe(this, { attributes: true });
-    const resolve = (def) => {
-      this._resolved = true;
-      this._pendingResolve = void 0;
-      const { props, styles } = def;
-      let numberProps;
-      if (props && !shared.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] = shared.toNumber(this._props[key]);
-            }
-            (numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[shared.camelize(key)] = true;
-          }
-        }
-      }
-      this._numberProps = numberProps;
-      this._resolveProps(def);
-      if (this.shadowRoot) {
-        this._applyStyles(styles);
-      }
-      this._mountComponent(def);
-    };
-    const asyncDef = this._def.__asyncLoader;
-    if (asyncDef) {
-      const { configureApp } = this._def;
-      this._pendingResolve = asyncDef().then((def) => {
-        def.configureApp = configureApp;
-        this._def = def;
-        resolve(def);
-      });
-    } else {
-      resolve(this._def);
-    }
-  }
-  _mountComponent(def) {
-    this._mount(def);
-    this._processExposed();
-  }
-  _processExposed() {
-    const exposed = this._instance && this._instance.exposed;
-    if (!exposed) return;
-    for (const key in exposed) {
-      if (!shared.hasOwn(this, key)) {
-        Object.defineProperty(this, key, {
-          // unwrap ref to be consistent with public instance behavior
-          get: () => runtimeCore.unref(exposed[key])
-        });
-      }
-    }
-  }
-  _processInstance() {
-    this._instance.ce = this;
-    this._instance.isCE = true;
-    const dispatch = (event, args) => {
-      this.dispatchEvent(
-        new CustomEvent(
-          event,
-          shared.isPlainObject(args[0]) ? shared.extend({ detail: args }, args[0]) : { detail: args }
-        )
-      );
-    };
-    this._instance.emit = (event, ...args) => {
-      dispatch(event, args);
-      if (shared.hyphenate(event) !== event) {
-        dispatch(shared.hyphenate(event), args);
-      }
-    };
-    this._setParent();
-  }
-  _resolveProps(def) {
-    const { props } = def;
-    const declaredPropKeys = shared.isArray(props) ? props : Object.keys(props || {});
-    for (const key of Object.keys(this)) {
-      if (key[0] !== "_" && declaredPropKeys.includes(key)) {
-        this._setProp(key, this[key]);
-      }
-    }
-    for (const key of declaredPropKeys.map(shared.camelize)) {
-      Object.defineProperty(this, key, {
-        get() {
-          return this._getProp(key);
-        },
-        set(val) {
-          this._setProp(key, val, true, !this._patching);
-        }
-      });
-    }
-  }
-  _setAttr(key) {
-    if (key.startsWith("data-v-")) return;
-    const has = this.hasAttribute(key);
-    let value = has ? this.getAttribute(key) : REMOVAL;
-    const camelKey = shared.camelize(key);
-    if (has && this._numberProps && this._numberProps[camelKey]) {
-      value = shared.toNumber(value);
-    }
-    this._setProp(camelKey, value, false, true);
-  }
-  /**
-   * @internal
-   */
-  _getProp(key) {
-    return this._props[key];
-  }
-  /**
-   * @internal
-   */
-  _setProp(key, val, shouldReflect = true, shouldUpdate = false) {
-    if (val !== this._props[key]) {
-      this._dirty = true;
-      if (val === REMOVAL) {
-        delete this._props[key];
-      } else {
-        this._props[key] = val;
-        if (key === "key" && this._app && this._app._ceVNode) {
-          this._app._ceVNode.key = val;
-        }
-      }
-      if (shouldUpdate && this._instance) {
-        this._update();
-      }
-      if (shouldReflect) {
-        const ob = this._ob;
-        if (ob) {
-          this._processMutations(ob.takeRecords());
-          ob.disconnect();
-        }
-        if (val === true) {
-          this.setAttribute(shared.hyphenate(key), "");
-        } else if (typeof val === "string" || typeof val === "number") {
-          this.setAttribute(shared.hyphenate(key), val + "");
-        } else if (!val) {
-          this.removeAttribute(shared.hyphenate(key));
-        }
-        ob && ob.observe(this, { attributes: true });
-      }
-    }
-  }
-  _applyStyles(styles, owner) {
-    if (!styles) return;
-    if (owner) {
-      if (owner === this._def || this._styleChildren.has(owner)) {
-        return;
-      }
-      this._styleChildren.add(owner);
-    }
-    const nonce = this._nonce;
-    for (let i = styles.length - 1; i >= 0; i--) {
-      const s = document.createElement("style");
-      if (nonce) s.setAttribute("nonce", nonce);
-      s.textContent = styles[i];
-      this.shadowRoot.prepend(s);
-    }
-  }
-  /**
-   * Only called when shadowRoot is false
-   */
-  _parseSlots() {
-    const slots = this._slots = {};
-    let n;
-    while (n = this.firstChild) {
-      const slotName = n.nodeType === 1 && n.getAttribute("slot") || "default";
-      (slots[slotName] || (slots[slotName] = [])).push(n);
-      this.removeChild(n);
-    }
-  }
-  /**
-   * Only called when shadowRoot is false
-   */
-  _renderSlots() {
-    const outlets = this._getSlots();
-    const scopeId = this._instance.type.__scopeId;
-    const slotReplacements = /* @__PURE__ */ new Map();
-    for (let i = 0; i < outlets.length; i++) {
-      const o = outlets[i];
-      const slotName = o.getAttribute("name") || "default";
-      const content = this._slots[slotName];
-      const parent = o.parentNode;
-      const replacementNodes = [];
-      if (content) {
-        for (const n of content) {
-          if (scopeId && n.nodeType === 1) {
-            const id = scopeId + "-s";
-            const walker = document.createTreeWalker(n, 1);
-            n.setAttribute(id, "");
-            let child;
-            while (child = walker.nextNode()) {
-              child.setAttribute(id, "");
-            }
-          }
-          parent.insertBefore(n, o);
-          replacementNodes.push(n);
-        }
-      } else {
-        while (o.firstChild) {
-          const child = o.firstChild;
-          parent.insertBefore(child, o);
-          replacementNodes.push(child);
-        }
-      }
-      parent.removeChild(o);
-      slotReplacements.set(o, replacementNodes);
-    }
-    this._updateSlotNodes(slotReplacements);
-  }
-  /**
-   * @internal
-   */
-  _getSlots() {
-    const roots = [this];
-    if (this._teleportTargets) {
-      roots.push(...this._teleportTargets);
-    }
-    const slots = /* @__PURE__ */ new Set();
-    for (const root of roots) {
-      const found = root.querySelectorAll("slot");
-      for (let i = 0; i < found.length; i++) {
-        slots.add(found[i]);
-      }
-    }
-    return Array.from(slots);
-  }
-  /**
-   * @internal
-   */
-  _injectChildStyle(comp) {
-    this._applyStyles(comp.styles, comp);
-  }
-  /**
-   * @internal
-   */
-  _beginPatch() {
-    this._patching = true;
-    this._dirty = false;
-  }
-  /**
-   * @internal
-   */
-  _endPatch() {
-    this._patching = false;
-    if (this._dirty && this._instance) {
-      this._update();
-    }
-  }
-  /**
-   * @internal
-   */
-  _removeChildStyle(comp) {
-  }
-}
-class VueElement extends VueElementBase {
-  constructor(def, props = {}, createAppFn = createApp) {
-    super(def, props, createAppFn);
-  }
-  _needsHydration() {
-    if (this.shadowRoot && this._createApp !== createApp) {
-      return true;
-    }
-    return false;
-  }
-  _mount(def) {
-    this._app = this._createApp(def);
-    this._inheritParentContext();
-    if (def.configureApp) {
-      def.configureApp(this._app);
-    }
-    this._app._ceVNode = this._createVNode();
-    this._app.mount(this._root);
-  }
-  _update() {
-    if (!this._app) return;
-    const vnode = this._createVNode();
-    vnode.appContext = this._app._context;
-    render(vnode, this._root);
-  }
-  _unmount() {
-    if (this._app) {
-      this._app.unmount();
-    }
-    if (this._instance && this._instance.ce) {
-      this._instance.ce = void 0;
-    }
-    this._app = this._instance = null;
-  }
-  /**
-   * Only called when shadowRoot is false
-   */
-  _updateSlotNodes(replacements) {
-  }
-  _createVNode() {
-    const baseProps = {};
-    if (!this.shadowRoot) {
-      baseProps.onVnodeMounted = baseProps.onVnodeUpdated = this._renderSlots.bind(this);
-    }
-    const vnode = runtimeCore.createVNode(this._def, shared.extend(baseProps, this._props));
-    if (!this._instance) {
-      vnode.ce = (instance) => {
-        this._instance = instance;
-        this._processInstance();
-      };
-    }
-    return vnode;
-  }
-}
 function useHost(caller) {
-  const { hasInstance, value } = runtimeCore.useInstanceOption("ce", true);
-  const el = value;
-  if (el) {
-    return el;
-  }
-  return null;
+	const { hasInstance, value } = (0, _vue_runtime_core.useInstanceOption)("ce", true);
+	const el = value;
+	if (el) return el;
+	return null;
 }
+/**
+* Retrieve the shadowRoot of the current custom element. Only usable in setup()
+* of a `defineCustomElement` component.
+*/
 function useShadowRoot() {
-  const el = useHost();
-  return el && el.shadowRoot;
+	const el = useHost();
+	return el && el.shadowRoot;
 }
+//#endregion
+//#region packages/runtime-dom/src/helpers/useCssModule.ts
 function useCssModule(name = "$style") {
-  {
-    const { hasInstance, value: type } = runtimeCore.useInstanceOption("type", true);
-    if (!hasInstance) {
-      return shared.EMPTY_OBJ;
-    }
-    const modules = type.__cssModules;
-    if (!modules) {
-      return shared.EMPTY_OBJ;
-    }
-    const mod = modules[name];
-    if (!mod) {
-      return shared.EMPTY_OBJ;
-    }
-    return mod;
-  }
+	{
+		const { hasInstance, value: type } = (0, _vue_runtime_core.useInstanceOption)("type", true);
+		if (!hasInstance) return _vue_shared.EMPTY_OBJ;
+		const modules = type.__cssModules;
+		if (!modules) return _vue_shared.EMPTY_OBJ;
+		const mod = modules[name];
+		if (!mod) return _vue_shared.EMPTY_OBJ;
+		return mod;
+	}
 }
+//#endregion
+//#region packages/runtime-dom/src/components/TransitionGroup.ts
 const positionMap = /* @__PURE__ */ new WeakMap();
 const newPositionMap = /* @__PURE__ */ new WeakMap();
-const moveCbKey = /* @__PURE__ */ Symbol("_moveCb");
-const enterCbKey = /* @__PURE__ */ Symbol("_enterCb");
+const moveCbKey = Symbol("_moveCb");
+const enterCbKey = Symbol("_enterCb");
+/**
+* Wrap logic that modifies TransitionGroup properties in a function
+* so that it can be annotated as pure
+*/
 const decorate = (t) => {
-  delete t.props.mode;
-  return t;
+	delete t.props.mode;
+	return t;
 };
 const TransitionGroupImpl = /* @__PURE__ */ decorate({
-  name: "TransitionGroup",
-  props: /* @__PURE__ */ shared.extend({}, TransitionPropsValidators, {
-    tag: String,
-    moveClass: String
-  }),
-  setup(props, { slots }) {
-    const instance = runtimeCore.getCurrentInstance();
-    const state = runtimeCore.useTransitionState();
-    let prevChildren;
-    let children;
-    runtimeCore.onUpdated(() => {
-      if (!prevChildren.length) {
-        return;
-      }
-      const moveClass = props.moveClass || `${props.name || "v"}-move`;
-      if (!hasCSSTransform(
-        prevChildren[0].el,
-        instance.vnode.el,
-        moveClass
-      )) {
-        prevChildren = [];
-        return;
-      }
-      prevChildren.forEach((vnode) => callPendingCbs(vnode.el));
-      prevChildren.forEach(recordPosition);
-      const movedChildren = prevChildren.filter(applyTranslation);
-      forceReflow(instance.vnode.el);
-      movedChildren.forEach((c) => {
-        const el = c.el;
-        handleMovedChildren(el, moveClass);
-      });
-      prevChildren = [];
-    });
-    return () => {
-      const rawProps = runtimeCore.toRaw(props);
-      const cssTransitionProps = resolveTransitionProps(rawProps);
-      let tag = rawProps.tag || runtimeCore.Fragment;
-      prevChildren = [];
-      if (children) {
-        for (let i = 0; i < children.length; i++) {
-          const child = children[i];
-          if (child.el && child.el instanceof Element) {
-            prevChildren.push(child);
-            runtimeCore.setTransitionHooks(
-              child,
-              runtimeCore.resolveTransitionHooks(
-                child,
-                cssTransitionProps,
-                state,
-                instance
-              )
-            );
-            positionMap.set(child, {
-              left: child.el.offsetLeft,
-              top: child.el.offsetTop
-            });
-          }
-        }
-      }
-      children = slots.default ? runtimeCore.getTransitionRawChildren(slots.default()) : [];
-      for (let i = 0; i < children.length; i++) {
-        const child = children[i];
-        if (child.key != null) {
-          runtimeCore.setTransitionHooks(
-            child,
-            runtimeCore.resolveTransitionHooks(child, cssTransitionProps, state, instance)
-          );
-        }
-      }
-      return runtimeCore.createVNode(tag, null, children);
-    };
-  }
+	name: "TransitionGroup",
+	props: /* @__PURE__ */ (0, _vue_shared.extend)({}, TransitionPropsValidators, {
+		tag: String,
+		moveClass: String
+	}),
+	setup(props, { slots }) {
+		const instance = (0, _vue_runtime_core.getCurrentInstance)();
+		const state = (0, _vue_runtime_core.useTransitionState)();
+		let prevChildren;
+		let children;
+		(0, _vue_runtime_core.onUpdated)(() => {
+			if (!prevChildren.length) return;
+			const moveClass = props.moveClass || `${props.name || "v"}-move`;
+			if (!hasCSSTransform(prevChildren[0].el, instance.vnode.el, moveClass)) {
+				prevChildren = [];
+				return;
+			}
+			prevChildren.forEach((vnode) => callPendingCbs(vnode.el));
+			prevChildren.forEach(recordPosition);
+			const movedChildren = prevChildren.filter(applyTranslation);
+			forceReflow(instance.vnode.el);
+			movedChildren.forEach((c) => {
+				const el = c.el;
+				handleMovedChildren(el, moveClass);
+			});
+			prevChildren = [];
+		});
+		return () => {
+			const rawProps = (0, _vue_runtime_core.toRaw)(props);
+			const cssTransitionProps = resolveTransitionProps(rawProps);
+			let tag = rawProps.tag || _vue_runtime_core.Fragment;
+			prevChildren = [];
+			if (children) for (let i = 0; i < children.length; i++) {
+				const child = children[i];
+				if (child.el && child.el instanceof Element) {
+					prevChildren.push(child);
+					(0, _vue_runtime_core.setTransitionHooks)(child, (0, _vue_runtime_core.resolveTransitionHooks)(child, cssTransitionProps, state, instance));
+					positionMap.set(child, {
+						left: child.el.offsetLeft,
+						top: child.el.offsetTop
+					});
+				}
+			}
+			children = slots.default ? (0, _vue_runtime_core.getTransitionRawChildren)(slots.default()) : [];
+			for (let i = 0; i < children.length; i++) {
+				const child = children[i];
+				if (child.key != null) (0, _vue_runtime_core.setTransitionHooks)(child, (0, _vue_runtime_core.resolveTransitionHooks)(child, cssTransitionProps, state, instance));
+			}
+			return (0, _vue_runtime_core.createVNode)(tag, null, children);
+		};
+	}
 });
 const TransitionGroup = TransitionGroupImpl;
 function callPendingCbs(el) {
-  if (el[moveCbKey]) {
-    el[moveCbKey]();
-  }
-  if (el[enterCbKey]) {
-    el[enterCbKey]();
-  }
+	if (el[moveCbKey]) el[moveCbKey]();
+	if (el[enterCbKey]) el[enterCbKey]();
 }
 function recordPosition(c) {
-  newPositionMap.set(c, {
-    left: c.el.offsetLeft,
-    top: c.el.offsetTop
-  });
+	newPositionMap.set(c, {
+		left: c.el.offsetLeft,
+		top: c.el.offsetTop
+	});
 }
 function applyTranslation(c) {
-  if (baseApplyTranslation(
-    positionMap.get(c),
-    newPositionMap.get(c),
-    c.el
-  )) {
-    return c;
-  }
+	if (baseApplyTranslation(positionMap.get(c), newPositionMap.get(c), c.el)) return c;
 }
 function baseApplyTranslation(oldPos, newPos, el) {
-  const dx = oldPos.left - newPos.left;
-  const dy = oldPos.top - newPos.top;
-  if (dx || dy) {
-    const s = el.style;
-    s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;
-    s.transitionDuration = "0s";
-    return true;
-  }
-  return false;
+	const dx = oldPos.left - newPos.left;
+	const dy = oldPos.top - newPos.top;
+	if (dx || dy) {
+		const s = el.style;
+		s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;
+		s.transitionDuration = "0s";
+		return true;
+	}
+	return false;
 }
 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;
+	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;
 }
 const handleMovedChildren = (el, moveClass) => {
-  const style = el.style;
-  addTransitionClass(el, moveClass);
-  style.transform = style.webkitTransform = style.transitionDuration = "";
-  const cb = el[moveCbKey] = (e) => {
-    if (e && e.target !== el) {
-      return;
-    }
-    if (!e || e.propertyName.endsWith("transform")) {
-      el.removeEventListener("transitionend", cb);
-      el[moveCbKey] = null;
-      removeTransitionClass(el, moveClass);
-    }
-  };
-  el.addEventListener("transitionend", cb);
+	const style = el.style;
+	addTransitionClass(el, moveClass);
+	style.transform = style.webkitTransform = style.transitionDuration = "";
+	const cb = el[moveCbKey] = (e) => {
+		if (e && e.target !== el) return;
+		if (!e || e.propertyName.endsWith("transform")) {
+			el.removeEventListener("transitionend", cb);
+			el[moveCbKey] = null;
+			removeTransitionClass(el, moveClass);
+		}
+	};
+	el.addEventListener("transitionend", cb);
 };
+//#endregion
+//#region packages/runtime-dom/src/directives/vModel.ts
 const getModelAssigner = (vnode) => {
-  const fn = vnode.props["onUpdate:modelValue"] || false;
-  return shared.isArray(fn) ? (value) => shared.invokeArrayFns(fn, value) : fn;
+	const fn = vnode.props["onUpdate:modelValue"] || false;
+	return (0, _vue_shared.isArray)(fn) ? (value) => (0, _vue_shared.invokeArrayFns)(fn, value) : fn;
 };
 function onCompositionStart(e) {
-  e.target.composing = true;
+	e.target.composing = true;
 }
 function onCompositionEnd(e) {
-  const target = e.target;
-  if (target.composing) {
-    target.composing = false;
-    target.dispatchEvent(new Event("input"));
-  }
+	const target = e.target;
+	if (target.composing) {
+		target.composing = false;
+		target.dispatchEvent(new Event("input"));
+	}
 }
-const assignKey = /* @__PURE__ */ Symbol("_assign");
+const assignKey = Symbol("_assign");
 const vModelText = {
-  created(el, { modifiers: { lazy, trim, number } }, vnode) {
-    el[assignKey] = getModelAssigner(vnode);
-    vModelTextInit(
-      el,
-      trim,
-      number || !!(vnode.props && vnode.props.type === "number"),
-      lazy
-    );
-  },
-  // set value on mounted so it's after min/max for type="range"
-  mounted(el, { value }) {
-    el.value = value == null ? "" : value;
-  },
-  beforeUpdate(el, { value, oldValue, modifiers: { lazy, trim, number } }, vnode) {
-    el[assignKey] = getModelAssigner(vnode);
-    vModelTextUpdate(el, oldValue, value, trim, number, lazy);
-  }
+	created(el, { modifiers: { lazy, trim, number } }, vnode) {
+		el[assignKey] = getModelAssigner(vnode);
+		vModelTextInit(el, trim, number || !!(vnode.props && vnode.props.type === "number"), lazy);
+	},
+	mounted(el, { value }) {
+		el.value = value == null ? "" : value;
+	},
+	beforeUpdate(el, { value, oldValue, modifiers: { lazy, trim, number } }, vnode) {
+		el[assignKey] = getModelAssigner(vnode);
+		vModelTextUpdate(el, oldValue, value, trim, number, lazy);
+	}
 };
 function castValue(value, trim, number) {
-  if (trim) value = value.trim();
-  if (number) value = shared.looseToNumber(value);
-  return value;
+	if (trim) value = value.trim();
+	if (number) value = (0, _vue_shared.looseToNumber)(value);
+	return value;
 }
+/**
+* @internal
+*/
 const vModelTextInit = (el, trim, number, lazy, set) => {
-  addEventListener(el, lazy ? "change" : "input", (e) => {
-    if (e.target.composing) return;
-    (0, el[assignKey])(
-      castValue(el.value, trim, number || el.type === "number")
-    );
-  });
-  if (trim || number) {
-    addEventListener(el, "change", () => {
-      el.value = castValue(el.value, trim, number || el.type === "number");
-    });
-  }
-  if (!lazy) {
-    addEventListener(el, "compositionstart", onCompositionStart);
-    addEventListener(el, "compositionend", onCompositionEnd);
-    addEventListener(el, "change", onCompositionEnd);
-  }
+	addEventListener(el, lazy ? "change" : "input", (e) => {
+		if (e.target.composing) return;
+		(set || el[assignKey])(castValue(el.value, trim, number || el.type === "number"));
+	});
+	if (trim || number) addEventListener(el, "change", () => {
+		el.value = castValue(el.value, trim, number || el.type === "number");
+	});
+	if (!lazy) {
+		addEventListener(el, "compositionstart", onCompositionStart);
+		addEventListener(el, "compositionend", onCompositionEnd);
+		addEventListener(el, "change", onCompositionEnd);
+	}
 };
+/**
+* @internal
+*/
 const vModelTextUpdate = (el, oldValue, value, trim, number, lazy) => {
-  if (el.composing) return;
-  const elValue = (number || el.type === "number") && !/^0\d/.test(el.value) ? shared.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;
+	if (el.composing) return;
+	const elValue = (number || el.type === "number") && !/^0\d/.test(el.value) ? (0, _vue_shared.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;
 };
 const vModelCheckbox = {
-  // #4096 array checkboxes need to be deep traversed
-  deep: true,
-  created(el, _, vnode) {
-    el[assignKey] = getModelAssigner(vnode);
-    vModelCheckboxInit(el);
-  },
-  // set initial checked on mount to wait for true-value/false-value
-  mounted(el, binding, vnode) {
-    vModelCheckboxUpdate(
-      el,
-      binding.oldValue,
-      binding.value,
-      vnode.props.value
-    );
-  },
-  beforeUpdate(el, binding, vnode) {
-    el[assignKey] = getModelAssigner(vnode);
-    vModelCheckboxUpdate(
-      el,
-      binding.oldValue,
-      binding.value,
-      vnode.props.value
-    );
-  }
+	deep: true,
+	created(el, _, vnode) {
+		el[assignKey] = getModelAssigner(vnode);
+		vModelCheckboxInit(el);
+	},
+	mounted(el, binding, vnode) {
+		vModelCheckboxUpdate(el, binding.oldValue, binding.value, vnode.props.value);
+	},
+	beforeUpdate(el, binding, vnode) {
+		el[assignKey] = getModelAssigner(vnode);
+		vModelCheckboxUpdate(el, binding.oldValue, binding.value, vnode.props.value);
+	}
 };
+/**
+* @internal
+*/
 const vModelCheckboxInit = (el, set) => {
-  addEventListener(el, "change", () => {
-    const assign = el[assignKey];
-    const modelValue = el._modelValue;
-    const elementValue = getValue(el);
-    const checked = el.checked;
-    if (shared.isArray(modelValue)) {
-      const index = shared.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 (shared.isSet(modelValue)) {
-      const cloned = new Set(modelValue);
-      if (checked) {
-        cloned.add(elementValue);
-      } else {
-        cloned.delete(elementValue);
-      }
-      assign(cloned);
-    } else {
-      assign(getCheckboxValue(el, checked));
-    }
-  });
+	addEventListener(el, "change", () => {
+		const assign = set || el[assignKey];
+		const modelValue = el._modelValue;
+		const elementValue = getValue(el);
+		const checked = el.checked;
+		if ((0, _vue_shared.isArray)(modelValue)) {
+			const index = (0, _vue_shared.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 ((0, _vue_shared.isSet)(modelValue)) {
+			const cloned = new Set(modelValue);
+			if (checked) cloned.add(elementValue);
+			else cloned.delete(elementValue);
+			assign(cloned);
+		} else assign(getCheckboxValue(el, checked));
+	});
 };
+/**
+* @internal
+*/
 const vModelCheckboxUpdate = (el, oldValue, value, rawValue = getValue(el)) => {
-  el._modelValue = value;
-  let checked;
-  if (shared.isArray(value)) {
-    checked = shared.looseIndexOf(value, rawValue) > -1;
-  } else if (shared.isSet(value)) {
-    checked = value.has(rawValue);
-  } else {
-    if (value === oldValue) return;
-    checked = shared.looseEqual(value, getCheckboxValue(el, true));
-  }
-  if (el.checked !== checked) {
-    el.checked = checked;
-  }
+	el._modelValue = value;
+	let checked;
+	if ((0, _vue_shared.isArray)(value)) checked = (0, _vue_shared.looseIndexOf)(value, rawValue) > -1;
+	else if ((0, _vue_shared.isSet)(value)) checked = value.has(rawValue);
+	else {
+		if (value === oldValue) return;
+		checked = (0, _vue_shared.looseEqual)(value, getCheckboxValue(el, true));
+	}
+	if (el.checked !== checked) el.checked = checked;
 };
 const vModelRadio = {
-  created(el, { value }, vnode) {
-    el.checked = shared.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 = shared.looseEqual(value, vnode.props.value);
-    }
-  }
+	created(el, { value }, vnode) {
+		el.checked = (0, _vue_shared.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 = (0, _vue_shared.looseEqual)(value, vnode.props.value);
+	}
 };
 const vModelSelect = {
-  // <select multiple> value need to be deep traversed
-  deep: true,
-  created(el, { value, modifiers: { number } }, vnode) {
-    vModelSelectInit(el, value, number);
-    el[assignKey] = getModelAssigner(vnode);
-  },
-  // set value in mounted & updated because <select> relies on its children
-  // <option>s.
-  mounted(el, { value }) {
-    vModelSetSelected(el, value);
-  },
-  beforeUpdate(el, _binding, vnode) {
-    el[assignKey] = getModelAssigner(vnode);
-  },
-  updated(el, { value }) {
-    vModelSetSelected(el, value);
-  }
+	deep: true,
+	created(el, { value, modifiers: { number } }, vnode) {
+		vModelSelectInit(el, value, number);
+		el[assignKey] = getModelAssigner(vnode);
+	},
+	mounted(el, { value }) {
+		vModelSetSelected(el, value);
+	},
+	beforeUpdate(el, _binding, vnode) {
+		el[assignKey] = getModelAssigner(vnode);
+	},
+	updated(el, { value }) {
+		vModelSetSelected(el, value);
+	}
 };
+/**
+* @internal
+*/
 const vModelSelectInit = (el, value, number, set) => {
-  const isSetModel = shared.isSet(value);
-  addEventListener(el, "change", () => {
-    const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map(
-      (o) => number ? shared.looseToNumber(getValue(o)) : getValue(o)
-    );
-    (0, el[assignKey])(
-      el.multiple ? isSetModel ? new Set(selectedVal) : selectedVal : selectedVal[0]
-    );
-    el._assigning = true;
-    runtimeCore.nextTick(() => {
-      el._assigning = false;
-    });
-  });
+	const isSetModel = (0, _vue_shared.isSet)(value);
+	addEventListener(el, "change", () => {
+		const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map((o) => number ? (0, _vue_shared.looseToNumber)(getValue(o)) : getValue(o));
+		(set || el[assignKey])(el.multiple ? isSetModel ? new Set(selectedVal) : selectedVal : selectedVal[0]);
+		el._assigning = true;
+		(0, _vue_runtime_core.nextTick)(() => {
+			el._assigning = false;
+		});
+	});
 };
+/**
+* @internal
+*/
 const vModelSetSelected = (el, value) => {
-  if (el._assigning) return;
-  const isMultiple = el.multiple;
-  const isArrayValue = shared.isArray(value);
-  if (isMultiple && !isArrayValue && !shared.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 = shared.looseIndexOf(value, optionValue) > -1;
-        }
-      } else {
-        option.selected = value.has(optionValue);
-      }
-    } else if (shared.looseEqual(getValue(option), value)) {
-      if (el.selectedIndex !== i) el.selectedIndex = i;
-      return;
-    }
-  }
-  if (!isMultiple && el.selectedIndex !== -1) {
-    el.selectedIndex = -1;
-  }
+	if (el._assigning) return;
+	const isMultiple = el.multiple;
+	const isArrayValue = (0, _vue_shared.isArray)(value);
+	if (isMultiple && !isArrayValue && !(0, _vue_shared.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 = (0, _vue_shared.looseIndexOf)(value, optionValue) > -1;
+		} else option.selected = value.has(optionValue);
+		else if ((0, _vue_shared.looseEqual)(getValue(option), value)) {
+			if (el.selectedIndex !== i) el.selectedIndex = i;
+			return;
+		}
+	}
+	if (!isMultiple && el.selectedIndex !== -1) el.selectedIndex = -1;
 };
+/**
+* @internal retrieve raw value set via :value bindings
+*/
 function getValue(el) {
-  return "_value" in el ? el._value : el.value;
+	return "_value" in el ? el._value : el.value;
 }
 function getCheckboxValue(el, checked) {
-  const key = checked ? "_trueValue" : "_falseValue";
-  if (key in el) {
-    return el[key];
-  }
-  const attr = checked ? "true-value" : "false-value";
-  if (el.hasAttribute(attr)) {
-    return el.getAttribute(attr);
-  }
-  return checked;
+	const key = checked ? "_trueValue" : "_falseValue";
+	if (key in el) return el[key];
+	const attr = checked ? "true-value" : "false-value";
+	if (el.hasAttribute(attr)) return el.getAttribute(attr);
+	return checked;
 }
 const 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");
-  }
+	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;
-      }
-  }
+	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 modelToUse = resolveDynamicModel(
-    el.tagName,
-    vnode.props && vnode.props.type
-  );
-  const fn = modelToUse[hook];
-  fn && fn(el, binding, vnode, prevVNode);
+	const fn = resolveDynamicModel(el.tagName, vnode.props && vnode.props.type)[hook];
+	fn && fn(el, binding, vnode, prevVNode);
 }
 function initVModelForSSR() {
-  vModelText.getSSRProps = ({ value }) => ({ value });
-  vModelRadio.getSSRProps = ({ value }, vnode) => {
-    if (vnode.props && shared.looseEqual(vnode.props.value, value)) {
-      return { checked: true };
-    }
-  };
-  vModelCheckbox.getSSRProps = ({ value }, vnode) => {
-    if (shared.isArray(value)) {
-      if (vnode.props && shared.looseIndexOf(value, vnode.props.value) > -1) {
-        return { checked: true };
-      }
-    } else if (shared.isSet(value)) {
-      if (vnode.props && value.has(vnode.props.value)) {
-        return { checked: true };
-      }
-    } else if (value) {
-      return { checked: true };
-    }
-  };
-  vModelDynamic.getSSRProps = (binding, vnode) => {
-    if (typeof vnode.type !== "string") {
-      return;
-    }
-    const modelToUse = resolveDynamicModel(
-      // resolveDynamicModel expects an uppercase tag name, but vnode.type is lowercase
-      vnode.type.toUpperCase(),
-      vnode.props && vnode.props.type
-    );
-    if (modelToUse.getSSRProps) {
-      return modelToUse.getSSRProps(binding, vnode);
-    }
-  };
+	vModelText.getSSRProps = ({ value }) => ({ value });
+	vModelRadio.getSSRProps = ({ value }, vnode) => {
+		if (vnode.props && (0, _vue_shared.looseEqual)(vnode.props.value, value)) return { checked: true };
+	};
+	vModelCheckbox.getSSRProps = ({ value }, vnode) => {
+		if ((0, _vue_shared.isArray)(value)) {
+			if (vnode.props && (0, _vue_shared.looseIndexOf)(value, vnode.props.value) > -1) return { checked: true };
+		} else if ((0, _vue_shared.isSet)(value)) {
+			if (vnode.props && value.has(vnode.props.value)) return { checked: true };
+		} else if (value) return { checked: true };
+	};
+	vModelDynamic.getSSRProps = (binding, vnode) => {
+		if (typeof vnode.type !== "string") return;
+		const modelToUse = resolveDynamicModel(vnode.type.toUpperCase(), vnode.props && vnode.props.type);
+		if (modelToUse.getSSRProps) return modelToUse.getSSRProps(binding, vnode);
+	};
 }
-const systemModifiers = ["ctrl", "shift", "alt", "meta"];
+//#endregion
+//#region packages/runtime-dom/src/directives/vOn.ts
+const systemModifiers = [
+	"ctrl",
+	"shift",
+	"alt",
+	"meta"
+];
 const 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))
+	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))
 };
+/**
+* @private
+*/
 const 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);
-  }));
+	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);
+	}));
 };
 const keyNames = {
-  esc: "escape",
-  space: " ",
-  up: "arrow-up",
-  left: "arrow-left",
-  right: "arrow-right",
-  down: "arrow-down",
-  delete: "backspace"
+	esc: "escape",
+	space: " ",
+	up: "arrow-up",
+	left: "arrow-left",
+	right: "arrow-right",
+	down: "arrow-down",
+	delete: "backspace"
 };
+/**
+* @private
+*/
 const 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 = shared.hyphenate(event.key);
-    if (modifiers.some(
-      (k) => k === eventKey || keyNames[k] === eventKey
-    )) {
-      return fn(event);
-    }
-  }));
+	const cache = fn._withKeys || (fn._withKeys = {});
+	const cacheKey = modifiers.join(".");
+	return cache[cacheKey] || (cache[cacheKey] = ((event) => {
+		if (!("key" in event)) return;
+		const eventKey = (0, _vue_shared.hyphenate)(event.key);
+		if (modifiers.some((k) => k === eventKey || keyNames[k] === eventKey)) return fn(event);
+	}));
 };
-const rendererOptions = /* @__PURE__ */ shared.extend({ patchProp }, nodeOps);
+//#endregion
+//#region packages/runtime-dom/src/index.ts
+const rendererOptions = /* @__PURE__ */ (0, _vue_shared.extend)({ patchProp }, nodeOps);
 let renderer;
 let enabledHydration = false;
 function ensureRenderer() {
-  return renderer || (renderer = runtimeCore.createRenderer(rendererOptions));
+	return renderer || (renderer = (0, _vue_runtime_core.createRenderer)(rendererOptions));
 }
 function ensureHydrationRenderer() {
-  renderer = enabledHydration ? renderer : runtimeCore.createHydrationRenderer(rendererOptions);
-  enabledHydration = true;
-  return renderer;
+	renderer = enabledHydration ? renderer : (0, _vue_runtime_core.createHydrationRenderer)(rendererOptions);
+	enabledHydration = true;
+	return renderer;
 }
 const render = ((...args) => {
-  ensureRenderer().render(...args);
+	ensureRenderer().render(...args);
 });
 const hydrate = ((...args) => {
-  ensureHydrationRenderer().hydrate(...args);
+	ensureHydrationRenderer().hydrate(...args);
 });
 const 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 (!shared.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;
+	const app = ensureRenderer().createApp(...args);
+	const { mount } = app;
+	app.mount = (containerOrSelector) => {
+		const container = normalizeContainer(containerOrSelector);
+		if (!container) return;
+		const component = app._component;
+		if (!(0, _vue_shared.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;
 });
 const 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;
+	(0, _vue_runtime_core.setIsHydratingEnabled)(true);
+	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;
 });
 function resolveRootNamespace(container) {
-  if (container instanceof SVGElement) {
-    return "svg";
-  }
-  if (typeof MathMLElement === "function" && container instanceof MathMLElement) {
-    return "mathml";
-  }
+	if (container instanceof SVGElement) return "svg";
+	if (typeof MathMLElement === "function" && container instanceof MathMLElement) return "mathml";
 }
+/**
+* @internal
+*/
 function normalizeContainer(container) {
-  if (shared.isString(container)) {
-    const res = document.querySelector(container);
-    return res;
-  }
-  return container;
+	if ((0, _vue_shared.isString)(container)) return document.querySelector(container);
+	return container;
 }
 let ssrDirectiveInitialized = false;
+/**
+* @internal
+*/
 const initDirectivesForSSR = () => {
-  if (!ssrDirectiveInitialized) {
-    ssrDirectiveInitialized = true;
-    initVModelForSSR();
-    initVShowForSSR();
-  }
-} ;
+	if (!ssrDirectiveInitialized) {
+		ssrDirectiveInitialized = true;
+		initVModelForSSR();
+		initVShowForSSR();
+	}
+};
+//#endregion
 exports.Transition = Transition;
 exports.TransitionGroup = TransitionGroup;
 exports.VueElement = VueElement;
@@ -1794,6 +1444,9 @@ exports.vModelText = vModelText;
 exports.vShow = vShow;
 exports.withKeys = withKeys;
 exports.withModifiers = withModifiers;
-Object.keys(runtimeCore).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = runtimeCore[k];
+Object.keys(_vue_runtime_core).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return _vue_runtime_core[k]; }
+  });
 });