@vue/runtime-vapor 0.0.0

package/dist/runtime-vapor.esm-bundler.js

@@ -0,0 +1,1707 @@
+/**
+* @vue/runtime-vapor v3.5.13
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+import { warn, queueJob, currentInstance as currentInstance$1, startMeasure, simpleSetCurrentInstance as simpleSetCurrentInstance$1, queuePostFlushCb, patchStyle, mergeProps, shouldSetAsProp, baseEmit, baseNormalizePropsOptions, pushWarningContext, validateProps, popWarningContext, isEmitListener, resolvePropValue, callWithErrorHandling, registerHMR, endMeasure, nextUid, EffectScope as EffectScope$1, expose, unregisterHMR, initFeatureFlags, setDevtoolsHook, createAppAPI, normalizeContainer, flushOnAppMount, resolveDynamicComponent, vShowOriginalDisplay, vShowHidden, vModelTextInit, onMounted, vModelCheckboxInit, vModelSelectInit, vModelTextUpdate, vModelCheckboxUpdate, vModelGetValue, vModelSetSelected, shallowRef as shallowRef$1 } from '@vue/runtime-dom';
+import { invokeArrayFns, remove as remove$1, normalizeClass, normalizeStyle, isString, parseStringStyle, toDisplayString, isOn, canSetValueDirectly, isArray, EMPTY_OBJ, hasOwn, isFunction, EMPTY_ARR, camelize, NO, YES, getGlobalThis, isObject, getSequence, looseEqual } from '@vue/shared';
+import { getCurrentScope, ReactiveEffect, onEffectCleanup, onScopeDispose, pauseTracking, EffectScope, resetTracking, proxyRefs, markRaw, unref, isReactive, isShallow, shallowReadArray, toReactive, shallowRef, isRef, traverse } from '@vue/reactivity';
+
+function renderEffect(fn, noLifecycle = false) {
+  const instance = currentInstance$1;
+  const scope = getCurrentScope();
+  if (!!(process.env.NODE_ENV !== "production") && true && !isVaporComponent(instance)) {
+    warn("renderEffect called without active vapor instance.");
+  }
+  const hasUpdateHooks = instance && (instance.bu || instance.u);
+  const renderEffectFn = noLifecycle ? fn : () => {
+    if (!!(process.env.NODE_ENV !== "production") && instance) {
+      startMeasure(instance, `renderEffect`);
+    }
+    const prev = currentInstance$1;
+    simpleSetCurrentInstance$1(instance);
+    if (scope) scope.on();
+    if (hasUpdateHooks && instance.isMounted && !instance.isUpdating) {
+      instance.isUpdating = true;
+      instance.bu && invokeArrayFns(instance.bu);
+      fn();
+      queuePostFlushCb(() => {
+        instance.isUpdating = false;
+        instance.u && invokeArrayFns(instance.u);
+      });
+    } else {
+      fn();
+    }
+    if (scope) scope.off();
+    simpleSetCurrentInstance$1(prev, instance);
+    if (!!(process.env.NODE_ENV !== "production") && instance) {
+      startMeasure(instance, `renderEffect`);
+    }
+  };
+  const effect = new ReactiveEffect(renderEffectFn);
+  const job = () => effect.dirty && effect.run();
+  if (instance) {
+    if (!!(process.env.NODE_ENV !== "production")) {
+      effect.onTrack = instance.rtc ? (e) => invokeArrayFns(instance.rtc, e) : undefined;
+      effect.onTrigger = instance.rtg ? (e) => invokeArrayFns(instance.rtg, e) : undefined;
+    }
+    job.i = instance;
+    job.id = instance.uid;
+  }
+  effect.scheduler = () => queueJob(job);
+  effect.run();
+}
+
+function addEventListener(el, event, handler, options) {
+  el.addEventListener(event, handler, options);
+  return () => el.removeEventListener(event, handler, options);
+}
+function on(el, event, handlerGetter, options = {}) {
+  const handler = eventHandler(handlerGetter);
+  let cleanupEvent;
+  queuePostFlushCb(() => {
+    cleanupEvent = addEventListener(el, event, handler, options);
+  });
+  if (options.effect) {
+    onEffectCleanup(cleanup);
+  } else if (getCurrentScope()) {
+    onScopeDispose(cleanup);
+  }
+  function cleanup() {
+    cleanupEvent && cleanupEvent();
+  }
+}
+function delegate(el, event, handlerGetter) {
+  const handler = eventHandler(handlerGetter);
+  handler.delegate = true;
+  const cacheKey = `$evt${event}`;
+  const handlers = el[cacheKey] || (el[cacheKey] = []);
+  handlers.push(handler);
+  onScopeDispose(() => remove$1(handlers, handler));
+}
+function eventHandler(getter) {
+  return (...args) => {
+    let handler = getter();
+    if (!handler) return;
+    handler && handler(...args);
+  };
+}
+const delegatedEvents = /* @__PURE__ */ Object.create(null);
+const delegateEvents = (...names) => {
+  for (const name of names) {
+    if (!delegatedEvents[name]) {
+      delegatedEvents[name] = true;
+      document.addEventListener(name, delegatedEventHandler);
+    }
+  }
+};
+const delegatedEventHandler = (e) => {
+  let node = e.composedPath && e.composedPath()[0] || e.target;
+  if (e.target !== node) {
+    Object.defineProperty(e, "target", {
+      configurable: true,
+      value: node
+    });
+  }
+  Object.defineProperty(e, "currentTarget", {
+    configurable: true,
+    get() {
+      return node || document;
+    }
+  });
+  while (node !== null) {
+    const handlers = node[`$evt${e.type}`];
+    if (handlers) {
+      for (const handler of handlers) {
+        if (handler.delegate && !node.disabled) {
+          handler(e);
+          if (e.cancelBubble) return;
+        }
+      }
+    }
+    node = node.host && node.host !== node && node.host instanceof Node ? node.host : node.parentNode;
+  }
+};
+function setDynamicEvents(el, events) {
+  for (const name in events) {
+    on(el, name, () => events[name], { effect: true });
+  }
+}
+
+const hasFallthroughKey = (key) => currentInstance$1.hasFallthrough && key in currentInstance$1.attrs;
+function setProp(el, key, value) {
+  if (key in el) {
+    setDOMProp(el, key, value);
+  } else {
+    setAttr(el, key, value);
+  }
+}
+function setAttr(el, key, value) {
+  if (!isApplyingFallthroughProps && el.$root && hasFallthroughKey(key)) {
+    return;
+  }
+  if (key === "true-value") {
+    el._trueValue = value;
+  } else if (key === "false-value") {
+    el._falseValue = value;
+  }
+  if (value !== el[`$${key}`]) {
+    el[`$${key}`] = value;
+    if (value != null) {
+      el.setAttribute(key, value);
+    } else {
+      el.removeAttribute(key);
+    }
+  }
+}
+function setDOMProp(el, key, value) {
+  if (!isApplyingFallthroughProps && el.$root && hasFallthroughKey(key)) {
+    return;
+  }
+  const prev = el[key];
+  if (value === prev) {
+    return;
+  }
+  let needRemove = false;
+  if (value === "" || value == null) {
+    const type = typeof prev;
+    if (value == null && type === "string") {
+      value = "";
+      needRemove = true;
+    } else if (type === "number") {
+      value = 0;
+      needRemove = true;
+    }
+  }
+  try {
+    el[key] = value;
+  } catch (e) {
+    if (!!(process.env.NODE_ENV !== "production") && !needRemove) {
+      warn(
+        `Failed setting prop "${key}" on <${el.tagName.toLowerCase()}>: value ${value} is invalid.`,
+        e
+      );
+    }
+  }
+  needRemove && el.removeAttribute(key);
+}
+function setClass(el, value) {
+  if (el.$root) {
+    setClassIncremental(el, value);
+  } else if ((value = normalizeClass(value)) !== el.$cls) {
+    el.className = el.$cls = value;
+  }
+}
+function setClassIncremental(el, value) {
+  const cacheKey = `$clsi${isApplyingFallthroughProps ? "$" : ""}`;
+  const prev = el[cacheKey];
+  if ((value = el[cacheKey] = normalizeClass(value)) !== prev) {
+    const nextList = value.split(/\s+/);
+    el.classList.add(...nextList);
+    if (prev) {
+      for (const cls of prev.split(/\s+/)) {
+        if (!nextList.includes(cls)) el.classList.remove(cls);
+      }
+    }
+  }
+}
+function setStyle(el, value) {
+  if (el.$root) {
+    setStyleIncremental(el, value);
+  } else {
+    const prev = el.$sty;
+    value = el.$sty = normalizeStyle(value);
+    patchStyle(el, prev, value);
+  }
+}
+function setStyleIncremental(el, value) {
+  const cacheKey = `$styi${isApplyingFallthroughProps ? "$" : ""}`;
+  const prev = el[cacheKey];
+  value = el[cacheKey] = isString(value) ? parseStringStyle(value) : normalizeStyle(value);
+  patchStyle(el, prev, value);
+  return value;
+}
+function setValue(el, value) {
+  if (!isApplyingFallthroughProps && el.$root && hasFallthroughKey("value")) {
+    return;
+  }
+  el._value = value;
+  const oldValue = el.tagName === "OPTION" ? el.getAttribute("value") : el.value;
+  const newValue = value == null ? "" : value;
+  if (oldValue !== newValue) {
+    el.value = newValue;
+  }
+  if (value == null) {
+    el.removeAttribute("value");
+  }
+}
+function setText(el, ...values) {
+  const value = values.length > 1 ? values.map(toDisplayString).join("") : toDisplayString(values[0]);
+  if (el.$txt !== value) {
+    el.textContent = el.$txt = value;
+  }
+}
+function setHtml(el, value) {
+  value = value == null ? "" : value;
+  if (el.$html !== value) {
+    el.innerHTML = el.$html = value;
+  }
+}
+function setDynamicProps(el, args) {
+  const props = args.length > 1 ? mergeProps(...args) : args[0];
+  const cacheKey = `$dprops${isApplyingFallthroughProps ? "$" : ""}`;
+  const prevKeys = el[cacheKey];
+  if (prevKeys) {
+    for (const key of prevKeys) {
+      if (!(key in props)) {
+        setDynamicProp(el, key, null);
+      }
+    }
+  }
+  for (const key of el[cacheKey] = Object.keys(props)) {
+    setDynamicProp(el, key, props[key]);
+  }
+}
+function setDynamicProp(el, key, value) {
+  const isSVG = false;
+  if (key === "class") {
+    setClass(el, value);
+  } else if (key === "style") {
+    setStyle(el, value);
+  } else if (isOn(key)) {
+    on(el, key[2].toLowerCase() + key.slice(3), () => value, { effect: true });
+  } else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, value, isSVG)) {
+    if (key === "innerHTML") {
+      setHtml(el, value);
+    } else if (key === "textContent") {
+      setText(el, value);
+    } else if (key === "value" && canSetValueDirectly(el.tagName)) {
+      setValue(el, value);
+    } else {
+      setDOMProp(el, key, value);
+    }
+  } else {
+    setAttr(el, key, value);
+  }
+  return value;
+}
+
+function createTextNode(values) {
+  const node = document.createTextNode("");
+  if (values) {
+    if (isArray(values)) {
+      setText(node, ...values);
+    } else {
+      renderEffect(() => setText(node, ...values()));
+    }
+  }
+  return node;
+}
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function createComment(data) {
+  return document.createComment(data);
+}
+
+class Fragment {
+  constructor(nodes) {
+    this.nodes = nodes;
+  }
+}
+class DynamicFragment extends Fragment {
+  constructor(anchorLabel) {
+    super([]);
+    this.anchor = !!(process.env.NODE_ENV !== "production") && anchorLabel ? createComment(anchorLabel) : document.createTextNode("");
+  }
+  update(render, key = render) {
+    if (key === this.current) {
+      return;
+    }
+    this.current = key;
+    pauseTracking();
+    const parent = this.anchor.parentNode;
+    if (this.scope) {
+      this.scope.stop();
+      parent && remove(this.nodes, parent);
+    }
+    if (render) {
+      this.scope = new EffectScope();
+      this.nodes = this.scope.run(render) || [];
+      if (parent) insert(this.nodes, parent, this.anchor);
+    } else {
+      this.scope = undefined;
+      this.nodes = [];
+    }
+    if (this.fallback && !isValidBlock(this.nodes)) {
+      parent && remove(this.nodes, parent);
+      this.nodes = (this.scope || (this.scope = new EffectScope())).run(this.fallback) || [];
+      parent && insert(this.nodes, parent, this.anchor);
+    }
+    resetTracking();
+  }
+}
+function isFragment(val) {
+  return val instanceof Fragment;
+}
+function isBlock(val) {
+  return val instanceof Node || isArray(val) || isVaporComponent(val) || isFragment(val);
+}
+function isValidBlock(block) {
+  if (block instanceof Node) {
+    return !(block instanceof Comment);
+  } else if (isVaporComponent(block)) {
+    return isValidBlock(block.block);
+  } else if (isArray(block)) {
+    return block.length > 0 && block.every(isValidBlock);
+  } else {
+    return isValidBlock(block.nodes);
+  }
+}
+function insert(block, parent, anchor = null) {
+  anchor = anchor === 0 ? parent.firstChild : anchor;
+  if (block instanceof Node) {
+    parent.insertBefore(block, anchor);
+  } else if (isVaporComponent(block)) {
+    mountComponent(block, parent, anchor);
+  } else if (isArray(block)) {
+    for (let i = 0; i < block.length; i++) {
+      insert(block[i], parent, anchor);
+    }
+  } else {
+    insert(block.nodes, parent, anchor);
+    if (block.anchor) insert(block.anchor, parent, anchor);
+  }
+}
+function prepend(parent, ...blocks) {
+  let i = blocks.length;
+  while (i--) insert(blocks[i], parent, 0);
+}
+let parentsWithUnmountedChildren = null;
+function remove(block, parent) {
+  const isRoot = !parentsWithUnmountedChildren;
+  if (isRoot) {
+    parentsWithUnmountedChildren = /* @__PURE__ */ new Set();
+  }
+  if (block instanceof Node) {
+    parent.removeChild(block);
+  } else if (isVaporComponent(block)) {
+    unmountComponent(block, parent);
+  } else if (isArray(block)) {
+    for (let i = 0; i < block.length; i++) {
+      remove(block[i], parent);
+    }
+  } else {
+    remove(block.nodes, parent);
+    if (block.anchor) remove(block.anchor, parent);
+    if (block.scope) {
+      block.scope.stop();
+    }
+  }
+  if (isRoot) {
+    for (const i of parentsWithUnmountedChildren) {
+      i.children = i.children.filter((n) => !n.isUnmounted);
+    }
+    parentsWithUnmountedChildren = null;
+  }
+}
+function normalizeBlock(block) {
+  if (!!!(process.env.NODE_ENV !== "production") && true) {
+    throw new Error(
+      "normalizeBlock should not be used in production code paths"
+    );
+  }
+  const nodes = [];
+  if (block instanceof Node) {
+    nodes.push(block);
+  } else if (isArray(block)) {
+    block.forEach((child) => nodes.push(...normalizeBlock(child)));
+  } else if (isVaporComponent(block)) {
+    nodes.push(...normalizeBlock(block.block));
+  } else {
+    nodes.push(...normalizeBlock(block.nodes));
+    block.anchor && nodes.push(block.anchor);
+  }
+  return nodes;
+}
+
+function normalizeEmitsOptions(comp) {
+  const cached = comp.__emitsOptions;
+  if (cached) return cached;
+  const raw = comp.emits;
+  if (!raw) return null;
+  let normalized;
+  if (isArray(raw)) {
+    normalized = {};
+    for (const key of raw) normalized[key] = null;
+  } else {
+    normalized = raw;
+  }
+  return comp.__emitsOptions = normalized;
+}
+function emit(instance, event, ...rawArgs) {
+  baseEmit(
+    instance,
+    instance.rawProps || EMPTY_OBJ,
+    propGetter,
+    event,
+    ...rawArgs
+  );
+}
+function propGetter(rawProps, key) {
+  const dynamicSources = rawProps.$;
+  if (dynamicSources) {
+    let i = dynamicSources.length;
+    while (i--) {
+      const source = resolveSource(dynamicSources[i]);
+      if (hasOwn(source, key)) return resolveSource(source[key]);
+    }
+  }
+  return rawProps[key] && resolveSource(rawProps[key]);
+}
+
+function resolveSource(source) {
+  return isFunction(source) ? source() : source;
+}
+function getPropsProxyHandlers(comp) {
+  if (comp.__propsHandlers) {
+    return comp.__propsHandlers;
+  }
+  const propsOptions = normalizePropsOptions(comp)[0];
+  const emitsOptions = normalizeEmitsOptions(comp);
+  const isProp = propsOptions ? (key) => isString(key) && hasOwn(propsOptions, camelize(key)) : NO;
+  const isAttr = propsOptions ? (key) => key !== "$" && !isProp(key) && !isEmitListener(emitsOptions, key) : YES;
+  const getProp = (instance, key) => {
+    if (!isProp(key)) return;
+    const rawProps = instance.rawProps;
+    const dynamicSources = rawProps.$;
+    if (dynamicSources) {
+      let i = dynamicSources.length;
+      let source, isDynamic, rawKey;
+      while (i--) {
+        source = dynamicSources[i];
+        isDynamic = isFunction(source);
+        source = isDynamic ? source() : source;
+        for (rawKey in source) {
+          if (camelize(rawKey) === key) {
+            return resolvePropValue(
+              propsOptions,
+              key,
+              isDynamic ? source[rawKey] : source[rawKey](),
+              instance,
+              resolveDefault
+            );
+          }
+        }
+      }
+    }
+    for (const rawKey in rawProps) {
+      if (camelize(rawKey) === key) {
+        return resolvePropValue(
+          propsOptions,
+          key,
+          rawProps[rawKey](),
+          instance,
+          resolveDefault
+        );
+      }
+    }
+    return resolvePropValue(
+      propsOptions,
+      key,
+      undefined,
+      instance,
+      resolveDefault,
+      true
+    );
+  };
+  const propsHandlers = propsOptions ? {
+    get: (target, key) => getProp(target, key),
+    has: (_, key) => isProp(key),
+    ownKeys: () => Object.keys(propsOptions),
+    getOwnPropertyDescriptor(target, key) {
+      if (isProp(key)) {
+        return {
+          configurable: true,
+          enumerable: true,
+          get: () => getProp(target, key)
+        };
+      }
+    }
+  } : null;
+  if (!!(process.env.NODE_ENV !== "production") && propsOptions) {
+    Object.assign(propsHandlers, {
+      set: propsSetDevTrap,
+      deleteProperty: propsDeleteDevTrap
+    });
+  }
+  const getAttr = (target, key) => {
+    if (!isProp(key) && !isEmitListener(emitsOptions, key)) {
+      return getAttrFromRawProps(target, key);
+    }
+  };
+  const hasAttr = (target, key) => {
+    if (isAttr(key)) {
+      return hasAttrFromRawProps(target, key);
+    } else {
+      return false;
+    }
+  };
+  const attrsHandlers = {
+    get: (target, key) => getAttr(target.rawProps, key),
+    has: (target, key) => hasAttr(target.rawProps, key),
+    ownKeys: (target) => getKeysFromRawProps(target.rawProps).filter(isAttr),
+    getOwnPropertyDescriptor(target, key) {
+      if (hasAttr(target.rawProps, key)) {
+        return {
+          configurable: true,
+          enumerable: true,
+          get: () => getAttr(target.rawProps, key)
+        };
+      }
+    }
+  };
+  if (!!(process.env.NODE_ENV !== "production")) {
+    Object.assign(attrsHandlers, {
+      set: propsSetDevTrap,
+      deleteProperty: propsDeleteDevTrap
+    });
+  }
+  return comp.__propsHandlers = [propsHandlers, attrsHandlers];
+}
+function getAttrFromRawProps(rawProps, key) {
+  if (key === "$") return;
+  const merged = key === "class" || key === "style" ? [] : undefined;
+  const dynamicSources = rawProps.$;
+  if (dynamicSources) {
+    let i = dynamicSources.length;
+    let source, isDynamic;
+    while (i--) {
+      source = dynamicSources[i];
+      isDynamic = isFunction(source);
+      source = isDynamic ? source() : source;
+      if (hasOwn(source, key)) {
+        const value = isDynamic ? source[key] : source[key]();
+        if (merged) {
+          merged.push(value);
+        } else {
+          return value;
+        }
+      }
+    }
+  }
+  if (hasOwn(rawProps, key)) {
+    if (merged) {
+      merged.push(rawProps[key]());
+    } else {
+      return rawProps[key]();
+    }
+  }
+  return merged;
+}
+function hasAttrFromRawProps(rawProps, key) {
+  if (key === "$") return false;
+  const dynamicSources = rawProps.$;
+  if (dynamicSources) {
+    let i = dynamicSources.length;
+    while (i--) {
+      if (hasOwn(resolveSource(dynamicSources[i]), key)) {
+        return true;
+      }
+    }
+  }
+  return hasOwn(rawProps, key);
+}
+function getKeysFromRawProps(rawProps) {
+  const keys = [];
+  for (const key in rawProps) {
+    if (key !== "$") keys.push(key);
+  }
+  const dynamicSources = rawProps.$;
+  if (dynamicSources) {
+    let i = dynamicSources.length;
+    let source;
+    while (i--) {
+      source = resolveSource(dynamicSources[i]);
+      for (const key in source) {
+        keys.push(key);
+      }
+    }
+  }
+  return Array.from(new Set(keys));
+}
+function normalizePropsOptions(comp) {
+  const cached = comp.__propsOptions;
+  if (cached) return cached;
+  const raw = comp.props;
+  if (!raw) return EMPTY_ARR;
+  const normalized = {};
+  const needCastKeys = [];
+  baseNormalizePropsOptions(raw, normalized, needCastKeys);
+  return comp.__propsOptions = [normalized, needCastKeys];
+}
+function resolveDefault(factory, instance) {
+  const prev = currentInstance$1;
+  simpleSetCurrentInstance$1(instance);
+  const res = factory.call(null, instance.props);
+  simpleSetCurrentInstance$1(prev, instance);
+  return res;
+}
+function hasFallthroughAttrs(comp, rawProps) {
+  if (rawProps) {
+    if (rawProps.$ || !comp.props) {
+      return true;
+    } else {
+      const propsOptions = normalizePropsOptions(comp)[0];
+      for (const key in rawProps) {
+        if (!hasOwn(propsOptions, camelize(key))) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function setupPropsValidation(instance) {
+  const rawProps = instance.rawProps;
+  if (!rawProps) return;
+  renderEffect(
+    () => {
+      pushWarningContext(instance);
+      validateProps(
+        resolveDynamicProps(rawProps),
+        instance.props,
+        normalizePropsOptions(instance.type)[0]
+      );
+      popWarningContext();
+    },
+    true
+    /* noLifecycle */
+  );
+}
+function resolveDynamicProps(props) {
+  const mergedRawProps = {};
+  for (const key in props) {
+    if (key !== "$") {
+      mergedRawProps[key] = props[key]();
+    }
+  }
+  if (props.$) {
+    for (const source of props.$) {
+      const isDynamic = isFunction(source);
+      const resolved = isDynamic ? source() : source;
+      for (const key in resolved) {
+        const value = isDynamic ? resolved[key] : resolved[key]();
+        if (key === "class" || key === "style") {
+          const existing = mergedRawProps[key];
+          if (isArray(existing)) {
+            existing.push(value);
+          } else {
+            mergedRawProps[key] = [existing, value];
+          }
+        } else {
+          mergedRawProps[key] = value;
+        }
+      }
+    }
+  }
+  return mergedRawProps;
+}
+function propsSetDevTrap(_, key) {
+  warn(
+    `Attempt to mutate prop ${JSON.stringify(key)} failed. Props are readonly.`
+  );
+  return true;
+}
+function propsDeleteDevTrap(_, key) {
+  warn(
+    `Attempt to delete prop ${JSON.stringify(key)} failed. Props are readonly.`
+  );
+  return true;
+}
+
+let currentInstance = null;
+{
+  const g = getGlobalThis();
+  const registerGlobalSetter = (key, setter) => {
+    let setters;
+    if (!(setters = g[key])) setters = g[key] = [];
+    setters.push(setter);
+    return (v) => {
+      if (setters.length > 1) setters.forEach((set) => set(v));
+      else setters[0](v);
+    };
+  };
+  registerGlobalSetter(
+    `__VUE_INSTANCE_SETTERS__`,
+    (v) => currentInstance = v
+  );
+  registerGlobalSetter(
+    `__VUE_SSR_SETTERS__`,
+    (v) => v
+  );
+}
+const simpleSetCurrentInstance = (i, unset) => {
+  currentInstance = i;
+  if (unset) {
+    unset.scope.off();
+  } else if (i) {
+    i.scope.on();
+  }
+};
+
+const dynamicSlotsProxyHandlers = {
+  get: getSlot,
+  has: (target, key) => !!getSlot(target, key),
+  getOwnPropertyDescriptor(target, key) {
+    const slot = getSlot(target, key);
+    if (slot) {
+      return {
+        configurable: true,
+        enumerable: true,
+        value: slot
+      };
+    }
+  },
+  ownKeys(target) {
+    let keys = Object.keys(target);
+    const dynamicSources = target.$;
+    if (dynamicSources) {
+      keys = keys.filter((k) => k !== "$");
+      for (const source of dynamicSources) {
+        if (isFunction(source)) {
+          const slot = source();
+          if (isArray(slot)) {
+            for (const s of slot) keys.push(String(s.name));
+          } else {
+            keys.push(String(slot.name));
+          }
+        } else {
+          keys.push(...Object.keys(source));
+        }
+      }
+    }
+    return keys;
+  },
+  set: NO,
+  deleteProperty: NO
+};
+function getSlot(target, key) {
+  if (key === "$") return;
+  const dynamicSources = target.$;
+  if (dynamicSources) {
+    let i = dynamicSources.length;
+    let source;
+    while (i--) {
+      source = dynamicSources[i];
+      if (isFunction(source)) {
+        const slot = source();
+        if (slot) {
+          if (isArray(slot)) {
+            for (const s of slot) {
+              if (String(s.name) === key) return s.fn;
+            }
+          } else if (String(slot.name) === key) {
+            return slot.fn;
+          }
+        }
+      } else if (hasOwn(source, key)) {
+        return source[key];
+      }
+    }
+  }
+  if (hasOwn(target, key)) {
+    return target[key];
+  }
+}
+const dynamicSlotsPropsProxyHandlers = {
+  get: getAttrFromRawProps,
+  has: hasAttrFromRawProps,
+  ownKeys: getKeysFromRawProps,
+  getOwnPropertyDescriptor(target, key) {
+    if (hasAttrFromRawProps(target, key)) {
+      return {
+        configurable: true,
+        enumerable: true,
+        get: () => getAttrFromRawProps(target, key)
+      };
+    }
+  }
+};
+function createSlot(name, rawProps, fallback) {
+  const instance = currentInstance;
+  const rawSlots = instance.rawSlots;
+  const isDynamicName = isFunction(name);
+  const fragment = !!(process.env.NODE_ENV !== "production") ? new DynamicFragment("slot") : new DynamicFragment();
+  const slotProps = rawProps ? new Proxy(rawProps, dynamicSlotsPropsProxyHandlers) : EMPTY_OBJ;
+  const renderSlot = () => {
+    const slot = getSlot(rawSlots, isFunction(name) ? name() : name);
+    if (slot) {
+      fragment.update(
+        slot._bound || (slot._bound = () => {
+          const slotContent = slot(slotProps);
+          if (slotContent instanceof DynamicFragment) {
+            slotContent.fallback = fallback;
+          }
+          return slotContent;
+        })
+      );
+    } else {
+      fragment.update(fallback);
+    }
+  };
+  if (isDynamicName || rawSlots.$) {
+    renderEffect(renderSlot);
+  } else {
+    renderSlot();
+  }
+  return fragment;
+}
+
+function hmrRerender(instance) {
+  const normalized = normalizeBlock(instance.block);
+  const parent = normalized[0].parentNode;
+  const anchor = normalized[normalized.length - 1].nextSibling;
+  remove(instance.block, parent);
+  const prev = currentInstance;
+  simpleSetCurrentInstance(instance);
+  devRender(instance);
+  simpleSetCurrentInstance(prev, instance);
+  insert(instance.block, parent, anchor);
+}
+function hmrReload(instance, newComp) {
+  const normalized = normalizeBlock(instance.block);
+  const parent = normalized[0].parentNode;
+  const anchor = normalized[normalized.length - 1].nextSibling;
+  unmountComponent(instance, parent);
+  const prev = currentInstance;
+  simpleSetCurrentInstance(instance.parent);
+  const newInstance = createComponent(
+    newComp,
+    instance.rawProps,
+    instance.rawSlots,
+    instance.isSingleRoot
+  );
+  simpleSetCurrentInstance(prev, instance.parent);
+  mountComponent(newInstance, parent, anchor);
+}
+
+function createComponent(component, rawProps, rawSlots, isSingleRoot, appContext) {
+  if (isSingleRoot && component.inheritAttrs !== false && isVaporComponent(currentInstance$1) && currentInstance$1.hasFallthrough) {
+    const attrs = currentInstance$1.attrs;
+    if (rawProps) {
+      (rawProps.$ || (rawProps.$ = [])).push(
+        () => attrs
+      );
+    } else {
+      rawProps = { $: [() => attrs] };
+    }
+  }
+  const instance = new VaporComponentInstance(
+    component,
+    rawProps,
+    rawSlots,
+    appContext
+  );
+  if (!!(process.env.NODE_ENV !== "production")) {
+    pushWarningContext(instance);
+    startMeasure(instance, `init`);
+  }
+  const prev = currentInstance$1;
+  simpleSetCurrentInstance$1(instance);
+  pauseTracking();
+  if (!!(process.env.NODE_ENV !== "production")) {
+    setupPropsValidation(instance);
+  }
+  const setupFn = isFunction(component) ? component : component.setup;
+  const setupResult = setupFn ? callWithErrorHandling(setupFn, instance, 0, [
+    instance.props,
+    instance
+  ]) || EMPTY_OBJ : EMPTY_OBJ;
+  if (!!(process.env.NODE_ENV !== "production") && !isBlock(setupResult)) {
+    if (isFunction(component)) {
+      warn(`Functional vapor component must return a block directly.`);
+      instance.block = [];
+    } else if (!component.render) {
+      warn(
+        `Vapor component setup() returned non-block value, and has no render function.`
+      );
+      instance.block = [];
+    } else {
+      instance.devtoolsRawSetupState = setupResult;
+      instance.setupState = proxyRefs(setupResult);
+      devRender(instance);
+      if (component.__hmrId) {
+        registerHMR(instance);
+        instance.isSingleRoot = isSingleRoot;
+        instance.hmrRerender = hmrRerender.bind(null, instance);
+        instance.hmrReload = hmrReload.bind(null, instance);
+      }
+    }
+  } else {
+    if (!setupFn && component.render) {
+      instance.block = callWithErrorHandling(
+        component.render,
+        instance,
+        1
+      );
+    } else {
+      instance.block = setupResult;
+    }
+  }
+  if (instance.hasFallthrough && component.inheritAttrs !== false && instance.block instanceof Element && Object.keys(instance.attrs).length) {
+    renderEffect(() => {
+      isApplyingFallthroughProps = true;
+      setDynamicProps(instance.block, [instance.attrs]);
+      isApplyingFallthroughProps = false;
+    });
+  }
+  resetTracking();
+  simpleSetCurrentInstance$1(prev, instance);
+  if (!!(process.env.NODE_ENV !== "production")) {
+    popWarningContext();
+    endMeasure(instance, "init");
+  }
+  return instance;
+}
+let isApplyingFallthroughProps = false;
+function devRender(instance) {
+  instance.block = callWithErrorHandling(
+    instance.type.render,
+    instance,
+    1,
+    [
+      instance.setupState,
+      instance.props,
+      instance.emit,
+      instance.attrs,
+      instance.slots
+    ]
+  ) || [];
+}
+const emptyContext = {
+  app: null,
+  config: {},
+  provides: /* @__PURE__ */ Object.create(null)
+};
+class VaporComponentInstance {
+  constructor(comp, rawProps, rawSlots, appContext) {
+    this.vapor = true;
+    this.uid = nextUid();
+    this.type = comp;
+    this.parent = currentInstance$1;
+    this.children = [];
+    if (currentInstance$1) {
+      if (isVaporComponent(currentInstance$1)) {
+        currentInstance$1.children.push(this);
+      }
+      this.appContext = currentInstance$1.appContext;
+      this.provides = currentInstance$1.provides;
+      this.ids = currentInstance$1.ids;
+    } else {
+      this.appContext = appContext || emptyContext;
+      this.provides = Object.create(this.appContext.provides);
+      this.ids = ["", 0, 0];
+    }
+    this.block = null;
+    this.scope = new EffectScope$1(true);
+    this.emit = emit.bind(null, this);
+    this.expose = expose.bind(null, this);
+    this.refs = EMPTY_OBJ;
+    this.emitted = this.exposed = this.exposeProxy = this.propsDefaults = this.suspense = null;
+    this.isMounted = this.isUnmounted = this.isUpdating = this.isDeactivated = false;
+    this.rawProps = rawProps || EMPTY_OBJ;
+    this.hasFallthrough = hasFallthroughAttrs(comp, rawProps);
+    if (rawProps || comp.props) {
+      const [propsHandlers, attrsHandlers] = getPropsProxyHandlers(comp);
+      this.attrs = new Proxy(this, attrsHandlers);
+      this.props = comp.props ? new Proxy(this, propsHandlers) : isFunction(comp) ? this.attrs : EMPTY_OBJ;
+    } else {
+      this.props = this.attrs = EMPTY_OBJ;
+    }
+    this.rawSlots = rawSlots || EMPTY_OBJ;
+    this.slots = rawSlots ? rawSlots.$ ? new Proxy(rawSlots, dynamicSlotsProxyHandlers) : rawSlots : EMPTY_OBJ;
+    if (!!(process.env.NODE_ENV !== "production")) {
+      this.propsOptions = normalizePropsOptions(comp);
+      this.emitsOptions = normalizeEmitsOptions(comp);
+    }
+  }
+  /**
+   * Expose `getKeysFromRawProps` on the instance so it can be used in code
+   * paths where it's needed, e.g. `useModel`
+   */
+  rawKeys() {
+    return getKeysFromRawProps(this.rawProps);
+  }
+}
+function isVaporComponent(value) {
+  return value instanceof VaporComponentInstance;
+}
+function createComponentWithFallback(comp, rawProps, rawSlots, isSingleRoot) {
+  if (!isString(comp)) {
+    return createComponent(comp, rawProps, rawSlots, isSingleRoot);
+  }
+  const el = document.createElement(comp);
+  el.$root = isSingleRoot;
+  if (rawProps) {
+    renderEffect(() => {
+      setDynamicProps(el, [resolveDynamicProps(rawProps)]);
+    });
+  }
+  if (rawSlots) {
+    if (rawSlots.$) ; else {
+      insert(getSlot(rawSlots, "default")(), el);
+    }
+  }
+  return el;
+}
+function mountComponent(instance, parent, anchor) {
+  if (!!(process.env.NODE_ENV !== "production")) {
+    startMeasure(instance, `mount`);
+  }
+  if (!instance.isMounted) {
+    if (instance.bm) invokeArrayFns(instance.bm);
+    insert(instance.block, parent, anchor);
+    if (instance.m) queuePostFlushCb(() => invokeArrayFns(instance.m));
+    instance.isMounted = true;
+  } else {
+    insert(instance.block, parent, anchor);
+  }
+  if (!!(process.env.NODE_ENV !== "production")) {
+    endMeasure(instance, `mount`);
+  }
+}
+function unmountComponent(instance, parentNode) {
+  if (instance.isMounted && !instance.isUnmounted) {
+    if (!!(process.env.NODE_ENV !== "production") && instance.type.__hmrId) {
+      unregisterHMR(instance);
+    }
+    if (instance.bum) {
+      invokeArrayFns(instance.bum);
+    }
+    instance.scope.stop();
+    for (const c of instance.children) {
+      unmountComponent(c);
+    }
+    instance.children = EMPTY_ARR;
+    if (parentNode) {
+      remove(instance.block, parentNode);
+      const parentInstance = instance.parent;
+      instance.parent = null;
+      if (isVaporComponent(parentInstance)) {
+        if (parentsWithUnmountedChildren) {
+          parentsWithUnmountedChildren.add(parentInstance);
+        } else {
+          remove$1(parentInstance.children, instance);
+        }
+      }
+    }
+    if (instance.um) {
+      queuePostFlushCb(() => invokeArrayFns(instance.um));
+    }
+    instance.isUnmounted = true;
+  } else if (parentNode) {
+    remove(instance.block, parentNode);
+  }
+}
+function getExposed(instance) {
+  if (instance.exposed) {
+    return instance.exposeProxy || (instance.exposeProxy = new Proxy(markRaw(instance.exposed), {
+      get: (target, key) => unref(target[key])
+    }));
+  }
+}
+
+let _createApp;
+const mountApp = (app, container) => {
+  if (container.nodeType === 1) {
+    container.textContent = "";
+  }
+  const instance = createComponent(
+    app._component,
+    app._props,
+    null,
+    false,
+    app._context
+  );
+  mountComponent(instance, container);
+  flushOnAppMount();
+  return instance;
+};
+const unmountApp = (app) => {
+  unmountComponent(app._instance, app._container);
+};
+const createVaporApp = (comp, props) => {
+  {
+    initFeatureFlags();
+  }
+  const target = getGlobalThis();
+  target.__VUE__ = true;
+  if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
+    setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__, target);
+  }
+  if (!_createApp) _createApp = createAppAPI(mountApp, unmountApp, getExposed);
+  const app = _createApp(comp, props);
+  if (!!(process.env.NODE_ENV !== "production")) {
+    app.config.globalProperties = new Proxy(
+      {},
+      {
+        set() {
+          warn(`app.config.globalProperties is not supported in vapor mode.`);
+          return false;
+        }
+      }
+    );
+  }
+  const mount = app.mount;
+  app.mount = (container, ...args) => {
+    container = normalizeContainer(container);
+    return mount(container, ...args);
+  };
+  return app;
+};
+
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function defineVaporComponent(comp) {
+  comp.__vapor = true;
+  return comp;
+}
+
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function template(html, root) {
+  let node;
+  const create = () => {
+    const t = document.createElement("template");
+    t.innerHTML = html;
+    return t.content.firstChild;
+  };
+  return () => {
+    const ret = (node || (node = create())).cloneNode(true);
+    if (root) ret.$root = true;
+    return ret;
+  };
+}
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function children(node, ...paths) {
+  for (const idx of paths) {
+    node = idx === 0 ? node.firstChild : idx === 1 ? node.firstChild.nextSibling : node.childNodes[idx];
+  }
+  return node;
+}
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function next(node, offset) {
+  for (let i = 0; i < offset; i++) {
+    node = node.nextSibling;
+  }
+  return node;
+}
+
+function createIf(condition, b1, b2, once) {
+  const frag = !!(process.env.NODE_ENV !== "production") ? new DynamicFragment("if") : new DynamicFragment();
+  if (once) {
+    frag.update(condition() ? b1 : b2);
+  } else {
+    renderEffect(() => frag.update(condition() ? b1 : b2));
+  }
+  return frag;
+}
+
+class ForBlock extends Fragment {
+  constructor(nodes, scope, item, key, index, renderKey) {
+    super(nodes);
+    this.scope = scope;
+    this.itemRef = item;
+    this.keyRef = key;
+    this.indexRef = index;
+    this.key = renderKey;
+  }
+}
+/*! #__NO_SIDE_EFFECTS__ */
+const createFor = /* @__NO_SIDE_EFFECTS__ */ (src, renderItem, getKey, isComponent = false, once) => {
+  let isMounted = false;
+  let oldBlocks = [];
+  let newBlocks;
+  let parent;
+  const parentAnchor = !!(process.env.NODE_ENV !== "production") ? createComment("for") : createTextNode();
+  const ref = new Fragment(oldBlocks);
+  const instance = currentInstance$1;
+  if (!!(process.env.NODE_ENV !== "production") && !instance) {
+    warn("createFor() can only be used inside setup()");
+  }
+  const renderList = () => {
+    const source = normalizeSource(src());
+    const newLength = source.values.length;
+    const oldLength = oldBlocks.length;
+    newBlocks = new Array(newLength);
+    if (!isMounted) {
+      isMounted = true;
+      for (let i = 0; i < newLength; i++) {
+        mount(source, i);
+      }
+    } else {
+      parent = parent || parentAnchor.parentNode;
+      if (!oldLength) {
+        for (let i = 0; i < newLength; i++) {
+          mount(source, i);
+        }
+      } else if (!newLength) {
+        for (let i = 0; i < oldLength; i++) {
+          unmount(oldBlocks[i]);
+        }
+      } else if (!getKey) {
+        const commonLength = Math.min(newLength, oldLength);
+        for (let i = 0; i < commonLength; i++) {
+          update(newBlocks[i] = oldBlocks[i], getItem(source, i)[0]);
+        }
+        for (let i = oldLength; i < newLength; i++) {
+          mount(source, i);
+        }
+        for (let i = newLength; i < oldLength; i++) {
+          unmount(oldBlocks[i]);
+        }
+      } else {
+        let i = 0;
+        let e1 = oldLength - 1;
+        let e2 = newLength - 1;
+        while (i <= e1 && i <= e2) {
+          if (tryPatchIndex(source, i)) {
+            i++;
+          } else {
+            break;
+          }
+        }
+        while (i <= e1 && i <= e2) {
+          if (tryPatchIndex(source, i)) {
+            e1--;
+            e2--;
+          } else {
+            break;
+          }
+        }
+        if (i > e1) {
+          if (i <= e2) {
+            const nextPos = e2 + 1;
+            const anchor = nextPos < newLength ? normalizeAnchor(newBlocks[nextPos].nodes) : parentAnchor;
+            while (i <= e2) {
+              mount(source, i, anchor);
+              i++;
+            }
+          }
+        } else if (i > e2) {
+          while (i <= e1) {
+            unmount(oldBlocks[i]);
+            i++;
+          }
+        } else {
+          const s1 = i;
+          const s2 = i;
+          const keyToNewIndexMap = /* @__PURE__ */ new Map();
+          for (i = s2; i <= e2; i++) {
+            keyToNewIndexMap.set(getKey(...getItem(source, i)), i);
+          }
+          let j;
+          let patched = 0;
+          const toBePatched = e2 - s2 + 1;
+          let moved = false;
+          let maxNewIndexSoFar = 0;
+          const newIndexToOldIndexMap = new Array(toBePatched).fill(0);
+          for (i = s1; i <= e1; i++) {
+            const prevBlock = oldBlocks[i];
+            if (patched >= toBePatched) {
+              unmount(prevBlock);
+            } else {
+              const newIndex = keyToNewIndexMap.get(prevBlock.key);
+              if (newIndex == null) {
+                unmount(prevBlock);
+              } else {
+                newIndexToOldIndexMap[newIndex - s2] = i + 1;
+                if (newIndex >= maxNewIndexSoFar) {
+                  maxNewIndexSoFar = newIndex;
+                } else {
+                  moved = true;
+                }
+                update(
+                  newBlocks[newIndex] = prevBlock,
+                  ...getItem(source, newIndex)
+                );
+                patched++;
+              }
+            }
+          }
+          const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : [];
+          j = increasingNewIndexSequence.length - 1;
+          for (i = toBePatched - 1; i >= 0; i--) {
+            const nextIndex = s2 + i;
+            const anchor = nextIndex + 1 < newLength ? normalizeAnchor(newBlocks[nextIndex + 1].nodes) : parentAnchor;
+            if (newIndexToOldIndexMap[i] === 0) {
+              mount(source, nextIndex, anchor);
+            } else if (moved) {
+              if (j < 0 || i !== increasingNewIndexSequence[j]) {
+                insert(newBlocks[nextIndex].nodes, parent, anchor);
+              } else {
+                j--;
+              }
+            }
+          }
+        }
+      }
+    }
+    ref.nodes = [oldBlocks = newBlocks];
+    if (parentAnchor) {
+      ref.nodes.push(parentAnchor);
+    }
+  };
+  const needKey = renderItem.length > 1;
+  const needIndex = renderItem.length > 2;
+  const mount = (source, idx, anchor = parentAnchor) => {
+    const [item, key, index] = getItem(source, idx);
+    const itemRef = shallowRef(item);
+    const keyRef = needKey ? shallowRef(key) : undefined;
+    const indexRef = needIndex ? shallowRef(index) : undefined;
+    let nodes;
+    let scope;
+    if (isComponent) {
+      nodes = renderItem(itemRef, keyRef, indexRef);
+    } else {
+      scope = new EffectScope();
+      nodes = scope.run(
+        () => renderItem(itemRef, keyRef, indexRef)
+      );
+    }
+    const block = newBlocks[idx] = new ForBlock(
+      nodes,
+      scope,
+      itemRef,
+      keyRef,
+      indexRef,
+      getKey && getKey(item, key, index)
+    );
+    if (parent) insert(block.nodes, parent, anchor);
+    return block;
+  };
+  const tryPatchIndex = (source, idx) => {
+    const block = oldBlocks[idx];
+    const [item, key, index] = getItem(source, idx);
+    if (block.key === getKey(item, key, index)) {
+      update(newBlocks[idx] = block, item);
+      return true;
+    }
+  };
+  const update = ({ itemRef, keyRef, indexRef }, newItem, newKey, newIndex) => {
+    if (newIndex !== itemRef.value) {
+      itemRef.value = newItem;
+    }
+    if (keyRef && newKey !== undefined && newKey !== keyRef.value) {
+      keyRef.value = newKey;
+    }
+    if (indexRef && newIndex !== undefined && newIndex !== indexRef.value) {
+      indexRef.value = newIndex;
+    }
+  };
+  const unmount = ({ nodes, scope }) => {
+    remove(nodes, parent);
+    scope && scope.stop();
+  };
+  once ? renderList() : renderEffect(renderList);
+  return ref;
+};
+function createForSlots(rawSource, getSlot) {
+  const source = normalizeSource(rawSource);
+  const sourceLength = source.values.length;
+  const slots = new Array(sourceLength);
+  for (let i = 0; i < sourceLength; i++) {
+    slots[i] = getSlot(...getItem(source, i));
+  }
+  return slots;
+}
+function normalizeSource(source) {
+  let values = source;
+  let needsWrap = false;
+  let keys;
+  if (isArray(source)) {
+    if (isReactive(source)) {
+      needsWrap = !isShallow(source);
+      values = shallowReadArray(source);
+    }
+  } else if (isString(source)) {
+    values = source.split("");
+  } else if (typeof source === "number") {
+    if (!!(process.env.NODE_ENV !== "production") && !Number.isInteger(source)) {
+      warn(`The v-for range expect an integer value but got ${source}.`);
+    }
+    values = new Array(source);
+    for (let i = 0; i < source; i++) values[i] = i + 1;
+  } else if (isObject(source)) {
+    if (source[Symbol.iterator]) {
+      values = Array.from(source);
+    } else {
+      keys = Object.keys(source);
+      values = new Array(keys.length);
+      for (let i = 0, l = keys.length; i < l; i++) {
+        values[i] = source[keys[i]];
+      }
+    }
+  }
+  return { values, needsWrap, keys };
+}
+function getItem({ keys, values, needsWrap }, idx) {
+  const value = needsWrap ? toReactive(values[idx]) : values[idx];
+  if (keys) {
+    return [value, keys[idx], idx];
+  } else {
+    return [value, idx, undefined];
+  }
+}
+function normalizeAnchor(node) {
+  if (node instanceof Node) {
+    return node;
+  } else if (isArray(node)) {
+    return normalizeAnchor(node[0]);
+  } else if (isVaporComponent(node)) {
+    return normalizeAnchor(node.block);
+  } else {
+    return normalizeAnchor(node.nodes);
+  }
+}
+function getRestElement(val, keys) {
+  const res = {};
+  for (const key in val) {
+    if (!keys.includes(key)) res[key] = val[key];
+  }
+  return res;
+}
+function getDefaultValue(val, defaultVal) {
+  return val === undefined ? defaultVal : val;
+}
+
+function createTemplateRefSetter() {
+  const instance = currentInstance$1;
+  return (...args) => setRef(instance, ...args);
+}
+function setRef(instance, el, ref, oldRef, refFor = false) {
+  if (!instance || instance.isUnmounted) return;
+  const setupState = !!(process.env.NODE_ENV !== "production") ? instance.setupState || {} : null;
+  const refValue = isVaporComponent(el) ? getExposed(el) || el : el;
+  const refs = instance.refs === EMPTY_OBJ ? instance.refs = {} : instance.refs;
+  if (oldRef != null && oldRef !== ref) {
+    if (isString(oldRef)) {
+      refs[oldRef] = null;
+      if (!!(process.env.NODE_ENV !== "production") && hasOwn(setupState, oldRef)) {
+        setupState[oldRef] = null;
+      }
+    } else if (isRef(oldRef)) {
+      oldRef.value = null;
+    }
+  }
+  if (isFunction(ref)) {
+    const invokeRefSetter = (value) => {
+      callWithErrorHandling(ref, currentInstance$1, 12, [
+        value,
+        refs
+      ]);
+    };
+    invokeRefSetter(refValue);
+    onScopeDispose(() => invokeRefSetter());
+  } else {
+    const _isString = isString(ref);
+    const _isRef = isRef(ref);
+    let existing;
+    if (_isString || _isRef) {
+      const doSet = () => {
+        if (refFor) {
+          existing = _isString ? !!(process.env.NODE_ENV !== "production") && hasOwn(setupState, ref) ? setupState[ref] : refs[ref] : ref.value;
+          if (!isArray(existing)) {
+            existing = [refValue];
+            if (_isString) {
+              refs[ref] = existing;
+              if (!!(process.env.NODE_ENV !== "production") && hasOwn(setupState, ref)) {
+                setupState[ref] = refs[ref];
+                existing = setupState[ref];
+              }
+            } else {
+              ref.value = existing;
+            }
+          } else if (!existing.includes(refValue)) {
+            existing.push(refValue);
+          }
+        } else if (_isString) {
+          refs[ref] = refValue;
+          if (!!(process.env.NODE_ENV !== "production") && hasOwn(setupState, ref)) {
+            setupState[ref] = refValue;
+          }
+        } else if (_isRef) {
+          ref.value = refValue;
+        } else if (!!(process.env.NODE_ENV !== "production")) {
+          warn("Invalid template ref type:", ref, `(${typeof ref})`);
+        }
+      };
+      doSet.id = -1;
+      queuePostFlushCb(doSet);
+      onScopeDispose(() => {
+        queuePostFlushCb(() => {
+          if (isArray(existing)) {
+            remove$1(existing, refValue);
+          } else if (_isString) {
+            refs[ref] = null;
+            if (!!(process.env.NODE_ENV !== "production") && hasOwn(setupState, ref)) {
+              setupState[ref] = null;
+            }
+          } else if (_isRef) {
+            ref.value = null;
+          }
+        });
+      });
+    } else if (!!(process.env.NODE_ENV !== "production")) {
+      warn("Invalid template ref type:", ref, `(${typeof ref})`);
+    }
+  }
+  return ref;
+}
+
+function createDynamicComponent(getter, rawProps, rawSlots, isSingleRoot) {
+  const frag = !!(process.env.NODE_ENV !== "production") ? new DynamicFragment("dynamic-component") : new DynamicFragment();
+  renderEffect(() => {
+    const value = getter();
+    frag.update(
+      () => createComponentWithFallback(
+        resolveDynamicComponent(value),
+        rawProps,
+        rawSlots,
+        isSingleRoot
+      ),
+      value
+    );
+  });
+  return frag;
+}
+
+function applyVShow(target, source) {
+  if (isVaporComponent(target)) {
+    return applyVShow(target.block, source);
+  }
+  if (isArray(target) && target.length === 1) {
+    return applyVShow(target[0], source);
+  }
+  if (target instanceof DynamicFragment) {
+    const update = target.update;
+    target.update = (render, key) => {
+      update.call(target, render, key);
+      setDisplay(target, source());
+    };
+  }
+  renderEffect(() => setDisplay(target, source()));
+}
+function setDisplay(target, value) {
+  if (isVaporComponent(target)) {
+    return setDisplay(target, value);
+  }
+  if (isArray(target) && target.length === 1) {
+    return setDisplay(target[0], value);
+  }
+  if (target instanceof DynamicFragment) {
+    return setDisplay(target.nodes, value);
+  }
+  if (target instanceof Element) {
+    const el = target;
+    if (!(vShowOriginalDisplay in el)) {
+      el[vShowOriginalDisplay] = el.style.display === "none" ? "" : el.style.display;
+    }
+    el.style.display = value ? el[vShowOriginalDisplay] : "none";
+    el[vShowHidden] = !value;
+  } else if (!!(process.env.NODE_ENV !== "production")) {
+    warn(
+      `v-show used on component with non-single-element root node and will be ignored.`
+    );
+  }
+}
+
+const applyTextModel = (el, get, set, { trim, number, lazy } = {}) => {
+  vModelTextInit(el, trim, number, lazy, set);
+  onMounted(() => {
+    let value;
+    renderEffect(() => {
+      vModelTextUpdate(el, value, value = get(), trim, number, lazy);
+    });
+  });
+};
+const applyCheckboxModel = (el, get, set) => {
+  vModelCheckboxInit(el, set);
+  onMounted(() => {
+    let value;
+    renderEffect(() => {
+      vModelCheckboxUpdate(
+        el,
+        value,
+        // #4096 array checkboxes need to be deep traversed
+        traverse(value = get())
+      );
+    });
+  });
+};
+const applyRadioModel = (el, get, set) => {
+  addEventListener(el, "change", () => set(vModelGetValue(el)));
+  onMounted(() => {
+    let value;
+    renderEffect(() => {
+      if (value !== (value = get())) {
+        el.checked = looseEqual(value, vModelGetValue(el));
+      }
+    });
+  });
+};
+const applySelectModel = (el, get, set, modifiers) => {
+  vModelSelectInit(el, get(), modifiers && modifiers.number, set);
+  onMounted(() => {
+    renderEffect(() => vModelSetSelected(el, traverse(get())));
+  });
+};
+const applyDynamicModel = (el, get, set, modifiers) => {
+  let apply = applyTextModel;
+  if (el.tagName === "SELECT") {
+    apply = applySelectModel;
+  } else if (el.tagName === "TEXTAREA") {
+    apply = applyTextModel;
+  } else if (el.type === "checkbox") {
+    apply = applyCheckboxModel;
+  } else if (el.type === "radio") {
+    apply = applyRadioModel;
+  }
+  apply(el, get, set, modifiers);
+};
+
+const vaporInVDOMInterface = {
+  mount(vnode, container, anchor, parentComponent) {
+    const selfAnchor = vnode.anchor = document.createComment("vapor");
+    container.insertBefore(selfAnchor, anchor);
+    const prev = currentInstance$1;
+    simpleSetCurrentInstance$1(parentComponent);
+    const propsRef = shallowRef$1(vnode.props);
+    const instance = vnode.component = createComponent(vnode.type, {
+      $: [() => propsRef.value]
+    });
+    instance.rawPropsRef = propsRef;
+    mountComponent(instance, container, selfAnchor);
+    simpleSetCurrentInstance$1(prev);
+    return instance;
+  },
+  update(n1, n2) {
+    n2.component = n1.component;
+    n2.component.rawPropsRef.value = n2.props;
+  },
+  unmount(vnode, doRemove) {
+    const container = doRemove ? vnode.anchor.parentNode : undefined;
+    unmountComponent(vnode.component, container);
+  },
+  move(vnode, container, anchor) {
+    insert(vnode.component, container, anchor);
+    insert(vnode.anchor, container, anchor);
+  }
+};
+const vaporInteropPlugin = (app) => {
+  app.config.vapor = vaporInVDOMInterface;
+};
+
+export { applyCheckboxModel, applyDynamicModel, applyRadioModel, applySelectModel, applyTextModel, applyVShow, children, createComponent, createComponentWithFallback, createDynamicComponent, createFor, createForSlots, createIf, createSlot, createTemplateRefSetter, createTextNode, createVaporApp, defineVaporComponent, delegate, delegateEvents, getDefaultValue, getRestElement, insert, mountComponent, next, on, prepend, remove, renderEffect, setAttr, setClass, setDOMProp, setDynamicEvents, setDynamicProps, setHtml, setProp, setStyle, setText, setValue, template, unmountComponent, vaporInteropPlugin };