@vue-jsx/runtime 3.3.0-beta.0

package/dist/jsx.js

@@ -0,0 +1 @@
+export {};

package/dist/props.d.ts

@@ -0,0 +1,34 @@
+import * as _$vue from "vue";
+
+//#region src/props.d.ts
+declare function getCurrentInstance(): _$vue.GenericComponentInstance | null;
+/**
+ * Returns the props of the current component instance.
+ *
+ * @example
+ * ```tsx
+ * import { useProps } from 'vue-jsx-vapor'
+ *
+ * defineComponent(({ foo = '' })=>{
+ *   const props = useProps() // { foo: '' }
+ * })
+ * ```
+ */
+declare function useProps(): {
+  [x: string]: unknown;
+};
+/**
+ * Returns the merged props and attrs of the current component.\
+ * Equivalent to `useProps()` + `useAttrs()`.
+ *
+ * @example
+ * ```tsx
+ * import { useFullProps } from 'vue-jsx-vapor'
+ *
+ * defineComponent((props) => {
+ *   const fullProps = useFullProps() // = useAttrs() + useProps()
+ * })
+ */
+declare function useFullProps(): {};
+//#endregion
+export { getCurrentInstance, useFullProps, useProps };

package/dist/props.js

@@ -0,0 +1,70 @@
+import * as Vue from "vue";
+import { computed, useAttrs } from "vue";
+//#region src/props.ts
+/* @__NO_SIDE_EFFECTS__ */
+function getCurrentInstance() {
+	return Vue.currentInstance || Vue.getCurrentInstance();
+}
+/**
+* Returns the props of the current component instance.
+*
+* @example
+* ```tsx
+* import { useProps } from 'vue-jsx-vapor'
+*
+* defineComponent(({ foo = '' })=>{
+*   const props = useProps() // { foo: '' }
+* })
+* ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function useProps() {
+	return (/* @__PURE__ */ getCurrentInstance()).props;
+}
+/**
+* Returns the merged props and attrs of the current component.\
+* Equivalent to `useProps()` + `useAttrs()`.
+*
+* @example
+* ```tsx
+* import { useFullProps } from 'vue-jsx-vapor'
+*
+* defineComponent((props) => {
+*   const fullProps = useFullProps() // = useAttrs() + useProps()
+* })
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function useFullProps() {
+	const attrs = useAttrs();
+	if (!(/* @__PURE__ */ getCurrentInstance()).type.props) return attrs;
+	const props = /* @__PURE__ */ useProps();
+	const fullProps = computed(() => ({
+		...props,
+		...attrs
+	}));
+	return new Proxy({}, {
+		get(_, p, receiver) {
+			return Reflect.get(fullProps.value, p, receiver);
+		},
+		set(_, p, v, r) {
+			return Reflect.set(fullProps.value, p, v, r);
+		},
+		deleteProperty(_, p) {
+			return Reflect.deleteProperty(fullProps.value, p);
+		},
+		has(_, p) {
+			return Reflect.has(fullProps.value, p);
+		},
+		ownKeys() {
+			return Object.keys(fullProps.value);
+		},
+		getOwnPropertyDescriptor() {
+			return {
+				enumerable: true,
+				configurable: true
+			};
+		}
+	});
+}
+//#endregion
+export { getCurrentInstance, useFullProps, useProps };

package/dist/raw.d.ts

@@ -0,0 +1,11 @@
+//#region src/raw.d.ts
+declare const propsHelperCode: string;
+declare const vdomHelperCode: string;
+declare const vaporHelperCode: string;
+declare const ssrHelperCode: string;
+declare const propsHelperId = "/vue-jsx-vapor/props";
+declare const vdomHelperId = "/vue-jsx-vapor/vdom";
+declare const vaporHelperId = "/vue-jsx-vapor/vapor";
+declare const ssrHelperId = "/vue-jsx-vapor/ssr";
+//#endregion
+export { propsHelperCode, propsHelperId, ssrHelperCode, ssrHelperId, vaporHelperCode, vaporHelperId, vdomHelperCode, vdomHelperId };

package/dist/raw.js

@@ -0,0 +1,23 @@
+//#region src/props.ts?raw
+var props_default = "import { computed, useAttrs } from \"vue\";\nimport * as Vue from \"vue\";\n// @__NO_SIDE_EFFECTS__\nexport function getCurrentInstance() {\n  return Vue.currentInstance || Vue.getCurrentInstance();\n}\n// @__NO_SIDE_EFFECTS__\nexport function useProps() {\n  const i = /* @__PURE__ */ getCurrentInstance();\n  return i.props;\n}\n// @__NO_SIDE_EFFECTS__\nexport function useFullProps() {\n  const attrs = useAttrs();\n  const i = /* @__PURE__ */ getCurrentInstance();\n  if (!i.type.props) {\n    return attrs;\n  }\n  const props = /* @__PURE__ */ useProps();\n  const fullProps = computed(() => ({ ...props, ...attrs }));\n  return new Proxy(\n    {},\n    {\n      get(_, p, receiver) {\n        return Reflect.get(fullProps.value, p, receiver);\n      },\n      set(_, p, v, r) {\n        return Reflect.set(fullProps.value, p, v, r);\n      },\n      deleteProperty(_, p) {\n        return Reflect.deleteProperty(fullProps.value, p);\n      },\n      has(_, p) {\n        return Reflect.has(fullProps.value, p);\n      },\n      ownKeys() {\n        return Object.keys(fullProps.value);\n      },\n      getOwnPropertyDescriptor() {\n        return {\n          enumerable: true,\n          configurable: true\n        };\n      }\n    }\n  );\n}\n";
+//#endregion
+//#region src/ssr.ts?raw
+var ssr_default = "import { useSSRContext } from \"vue\";\nexport function ssrRegisterHelper(comp, filename) {\n  if (typeof comp === \"function\") {\n    comp.__setup = () => {\n      const ssrContext = useSSRContext();\n      (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add(filename);\n    };\n  } else {\n    const setup = comp.setup;\n    comp.setup = (props, ctx) => {\n      const ssrContext = useSSRContext();\n      (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add(filename);\n      if (setup) {\n        return setup(props, ctx);\n      }\n    };\n  }\n}\n";
+//#endregion
+//#region src/vapor.ts?raw
+var vapor_default = "import {\n  EffectScope,\n  Fragment,\n  getCurrentInstance\n} from \"vue\";\nimport * as Vue from \"vue\";\n// @__NO_SIDE_EFFECTS__\nexport function defineVaporSSRComponent(comp, extraOptions) {\n  if (typeof comp === \"function\") {\n    return Object.assign({ name: comp.name }, extraOptions, {\n      setup(props, ctx) {\n        const result = comp(props, ctx);\n        return () => result;\n      },\n      __vapor: true\n    });\n  }\n  const setup = comp.setup;\n  if (setup) {\n    comp.setup = (props, ctx) => {\n      const result = setup(props, ctx);\n      return () => result;\n    };\n  }\n  comp.__vapor = true;\n  return comp;\n}\nexport const createComponent = (type, ...args) => {\n  if (type === Fragment) {\n    const slots = args[1];\n    return slots ? typeof slots === \"function\" ? slots() : typeof slots.default === \"function\" ? slots.default() : [] : [];\n  }\n  return Vue.createComponentWithFallback(\n    createProxyComponent(Vue.resolveDynamicComponent(type)),\n    ...args\n  );\n};\nconst proxyCache = /* @__PURE__ */ new WeakMap();\nexport function createProxyComponent(type, normalizeNode2) {\n  if (typeof type === \"function\") {\n    const existing = proxyCache.get(type);\n    if (existing) return existing;\n    const i = Vue.currentInstance || getCurrentInstance();\n    const proxy = new Proxy(type, {\n      apply(target, ctx, args) {\n        if (typeof target.__setup === \"function\") {\n          target.__setup.apply(ctx, args);\n        }\n        const node = Reflect.apply(target, ctx, args);\n        return normalizeNode2 ? normalizeNode2(node) : node;\n      },\n      get(target, p, receiver) {\n        if (i && i.appContext.vapor && p === \"__vapor\") {\n          return true;\n        }\n        return Reflect.get(target, p, receiver);\n      }\n    });\n    proxyCache.set(type, proxy);\n    return proxy;\n  }\n  return type;\n}\nexport function normalizeNode(node) {\n  if (node == null || typeof node === \"boolean\") {\n    return document.createComment(\"\");\n  } else if (Array.isArray(node) && node.length) {\n    return node.map(normalizeNode);\n  } else if (isBlock(node)) {\n    return node;\n  } else if (typeof node === \"function\") {\n    return resolveValues([node], void 0, true)[0];\n  } else {\n    return document.createTextNode(String(node));\n  }\n}\nexport function isBlock(val) {\n  return val instanceof Node || Array.isArray(val) || Vue.isVaporComponent(val) || Vue.isFragment(val);\n}\nfunction createFragment(nodes, anchor = document.createTextNode(\"\")) {\n  const frag = new Vue.VaporFragment(nodes);\n  frag.anchor = anchor;\n  return frag;\n}\nfunction normalizeBlock(node, anchor, processFunction = false) {\n  if (node instanceof Node || Vue.isFragment(node)) {\n    return node;\n  } else if (Vue.isVaporComponent(node)) {\n    return createFragment(node, anchor);\n  } else if (Array.isArray(node)) {\n    return createFragment(\n      node.map((i) => normalizeBlock(i, void 0, processFunction)),\n      anchor\n    );\n  } else if (processFunction && typeof node === \"function\") {\n    return resolveValues([node], anchor, true)[0];\n  } else {\n    const result = node == null || typeof node === \"boolean\" ? \"\" : String(node);\n    if (anchor) {\n      anchor.textContent = result;\n      return anchor;\n    } else {\n      return document.createTextNode(result);\n    }\n  }\n}\nfunction resolveValue(current, value, anchor, processFunction = false) {\n  anchor = anchor || (current instanceof Node && current.nodeType === 3 ? current : void 0);\n  const node = normalizeBlock(value, anchor, processFunction);\n  if (current) {\n    if (Vue.isFragment(current)) {\n      if (current.anchor && current.anchor.parentNode) {\n        Vue.remove(current.nodes, current.anchor.parentNode);\n        Vue.insert(node, current.anchor.parentNode, current.anchor);\n        if (!anchor) current.anchor.parentNode.removeChild(current.anchor);\n        if (current.scope) current.scope.stop();\n      }\n    } else if (current instanceof Node) {\n      if (current.nodeType === 3 && (!(node instanceof Node) || node.nodeType !== 3)) {\n        current.textContent = \"\";\n      }\n      if (Vue.isFragment(node) && current.parentNode) {\n        Vue.insert(node, current.parentNode, current);\n        if (!anchor || current.nodeType !== 3) {\n          current.parentNode.removeChild(current);\n        }\n      } else if (node instanceof Node) {\n        if (current.nodeType === 3 && node.nodeType === 3) {\n          current.textContent = node.textContent;\n          return current;\n        } else if (current.parentNode) {\n          current.parentNode.replaceChild(node, current);\n        }\n      }\n    }\n  }\n  return node;\n}\nfunction resolveValues(values = [], _anchor, processFunction = false) {\n  const nodes = [];\n  const scopes = [];\n  for (const [index, value] of values.entries()) {\n    const anchor = index === values.length - 1 ? _anchor : void 0;\n    if (typeof value === \"function\") {\n      Vue.renderEffect(() => {\n        if (scopes[index]) scopes[index].stop();\n        scopes[index] = new EffectScope();\n        nodes[index] = scopes[index].run(\n          () => resolveValue(nodes[index], value(), anchor, processFunction)\n        );\n      });\n    } else {\n      nodes[index] = resolveValue(nodes[index], value, anchor, processFunction);\n    }\n  }\n  return nodes;\n}\nexport function setNodes(anchor, ...values) {\n  const resolvedValues = resolveValues(values, anchor);\n  if (anchor.parentNode) Vue.insert(resolvedValues, anchor.parentNode, anchor);\n}\nexport function createNodes(...values) {\n  return resolveValues(values);\n}\nexport function normalizeVaporSlots(slots) {\n  if (typeof slots === \"function\") {\n    return { name: \"default\", fn: slots };\n  } else if (Object.prototype.toString.call(slots) === \"[object Object]\" && !isBlock(slots)) {\n    return Object.entries(slots).map(([name, fn]) => ({ name, fn }));\n  } else {\n    return {\n      name: \"default\",\n      fn: () => createNodes(slots)\n    };\n  }\n}\n// @__NO_SIDE_EFFECTS__\nexport function defineVaporComponent(comp, extraOptions) {\n  if (typeof comp === \"function\") {\n    return Object.assign({ name: comp.name }, extraOptions, {\n      setup: comp,\n      __vapor: true\n    });\n  }\n  comp.__vapor = true;\n  return comp;\n}\nexport const VaporFor = /* @__PURE__ */ defineVaporComponent(\n  (props, {\n    slots\n  }) => {\n    return Vue.createFor(\n      () => props.in,\n      (item, key, index) => {\n        return slots.default ? slots.default(\n          // @ts-ignore\n          props.getKey === void 0 ? item.value : item,\n          key,\n          index\n        ) : [];\n      },\n      props.getKey === void 0 ? (item) => item : props.getKey\n    );\n  },\n  { props: [\"in\", \"getKey\"] }\n);\n";
+//#endregion
+//#region src/vdom.ts?raw
+var vdom_default = "import {\n  defineComponent as __defineComponent,\n  normalizeClass as _normalizeClass,\n  cloneVNode,\n  Comment,\n  createBlock,\n  createElementBlock,\n  createElementVNode,\n  createVNode,\n  Fragment,\n  getCurrentInstance,\n  isVNode,\n  openBlock,\n  renderList,\n  Text,\n  withCtx\n} from \"vue\";\nconst cacheMap = /* @__PURE__ */ new WeakMap();\nexport function createVNodeCache(key) {\n  const i = getCurrentInstance();\n  if (i) {\n    if (!cacheMap.has(i)) cacheMap.set(i, {});\n    const caches = cacheMap.get(i);\n    return caches[key] || (caches[key] = []);\n  } else {\n    return [];\n  }\n}\nexport function normalizeVNode(value, flag = 1) {\n  let create = createVNode;\n  let isBlock = false;\n  if (typeof value === \"function\") {\n    isBlock = true;\n    openBlock();\n    create = createBlock;\n    value = value();\n  }\n  return isVNode(value) ? isBlock ? createBlock(cloneIfMounted(value)) : cloneIfMounted(value) : Array.isArray(value) ? isBlock ? createElementBlock(\n    Fragment,\n    null,\n    value.map((n) => normalizeVNode(() => n)),\n    -2\n  ) : createElementVNode(Fragment, null, value.slice()) : value == null || typeof value === \"boolean\" ? create(Comment) : create(Text, null, String(value), flag);\n}\nfunction cloneIfMounted(child) {\n  return child.el === null && child.patchFlag !== -1 || // @ts-ignore\n  child.memo ? child : cloneVNode(child);\n}\nconst normalizeSlotValue = (value) => Array.isArray(value) ? value.map((n) => normalizeVNode(n)) : [normalizeVNode(value)];\nexport const normalizeSlot = (rawSlot) => {\n  if (rawSlot._n) {\n    return rawSlot;\n  }\n  return withCtx((...args) => {\n    return normalizeSlotValue(rawSlot(...args));\n  });\n};\nexport const normalizeSlots = (slots) => {\n  return typeof slots === \"function\" || Object.prototype.toString.call(slots) === \"[object Object]\" && !isVNode(slots) ? slots : {\n    default: withCtx(() => [normalizeVNode(() => slots)])\n  };\n};\nexport const normalizeClass = (value) => _normalizeClass(value) || null;\nexport const defineComponent = __defineComponent;\nexport const For = defineComponent(\n  (props, {\n    slots\n  }) => {\n    const defaultSlot = slots.default;\n    return () => (openBlock(true), createElementBlock(\n      Fragment,\n      null,\n      renderList(props.in, (item, key, index) => {\n        const result = defaultSlot(item, key, index);\n        return Array.isArray(result) ? result.length === 1 ? result[0] : normalizeVNode(result) : result;\n      }),\n      128\n    ));\n  },\n  { props: [\"in\"] }\n);\n";
+//#endregion
+//#region src/raw.ts
+const propsHelperCode = props_default;
+const vdomHelperCode = vdom_default;
+const vaporHelperCode = vapor_default;
+const ssrHelperCode = ssr_default;
+const propsHelperId = "/vue-jsx-vapor/props";
+const vdomHelperId = "/vue-jsx-vapor/vdom";
+const vaporHelperId = "/vue-jsx-vapor/vapor";
+const ssrHelperId = "/vue-jsx-vapor/ssr";
+//#endregion
+export { propsHelperCode, propsHelperId, ssrHelperCode, ssrHelperId, vaporHelperCode, vaporHelperId, vdomHelperCode, vdomHelperId };

package/dist/ssr.d.ts

@@ -0,0 +1,6 @@
+import { ComponentOptions } from "vue";
+
+//#region src/ssr.d.ts
+declare function ssrRegisterHelper(comp: ComponentOptions, filename: string): void;
+//#endregion
+export { ssrRegisterHelper };

package/dist/ssr.js

@@ -0,0 +1,18 @@
+import { useSSRContext } from "vue";
+//#region src/ssr.ts
+function ssrRegisterHelper(comp, filename) {
+	if (typeof comp === "function") comp.__setup = () => {
+		const ssrContext = useSSRContext();
+		(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add(filename);
+	};
+	else {
+		const setup = comp.setup;
+		comp.setup = (props, ctx) => {
+			const ssrContext = useSSRContext();
+			(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add(filename);
+			if (setup) return setup(props, ctx);
+		};
+	}
+}
+//#endregion
+export { ssrRegisterHelper };

package/dist/types.d.ts

@@ -0,0 +1,34 @@
+import { Directive, EmitsOptions, EmitsToProps, Ref, SetupContext, SlotsType, VNode, VaporComponentInstance } from "vue";
+
+//#region src/types.d.ts
+declare module 'vue' {
+  interface VaporComponentInstance {
+    block: never;
+  }
+  interface RenderResultExtensions {
+    render: RenderResult;
+  }
+}
+type RenderResult<T = VaporComponentInstance['block']> = T | VNode | RenderResult[];
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+type IsKeyValues<T, K = string> = IfAny<T, false, T extends object ? (keyof T extends K ? true : false) : false>;
+type DirectiveArgs<T extends Directive> = T extends Directive<any, infer Value, infer Modifiers, infer Argument> ? Value | [Value] | [Value, Argument] | [Value, Array<Modifiers>] | [Value, Argument, Array<Modifiers>] : unknown;
+type NodeChildAtom<T> = T | VNode | string | number | boolean | null | undefined | void;
+type NodeArrayChildren<T> = Array<NodeArrayChildren<T> | NodeChildAtom<T>>;
+type NodeChild<T = VaporComponentInstance['block']> = NodeChildAtom<T> | NodeArrayChildren<T>;
+type NodeRef<T> = ((ref: T | null, refs: Record<string, any>) => void) | Ref | string;
+type ResolveSlots<Slots> = { readonly [Key in keyof Slots]?: Slots[Key] extends ((...args: infer Args) => VNode | VNode[]) ? (...args: Args) => NodeChild : Slots[Key] };
+type SlotsToProps<RawSlots extends SlotsType | Record<string, any> = Record<string, any>, Slots = ResolveSlots<RawSlots extends SlotsType ? SetupContext<EmitsOptions, RawSlots>['slots'] : RawSlots>> = string extends keyof Slots ? {} : [keyof Slots] extends [never] ? {} : {
+  readonly 'v-slots'?: ('default' extends keyof Slots ? Slots['default'] | Slots : Slots) | NoInfer<NodeChild>;
+};
+declare const exposedType: unique symbol;
+type ExtractExposed<Props, Default = never> = typeof exposedType extends keyof Props ? Exclude<Props[typeof exposedType], undefined> : Default;
+type ExposedToProps<T extends Record<string, any>> = string extends keyof T ? {} : [keyof T] extends [never] ? {} : {
+  readonly [exposedType]?: T;
+  readonly ref?: NodeRef<T>;
+};
+type EmitFnToProps<T, ExcludeKeys extends PropertyKey = ''> = T extends ((event: infer Event extends string, ...args: infer Args) => any) ? string extends Event ? {} : { readonly [K in Event as `on${Capitalize<K>}` extends ExcludeKeys ? never : `on${Capitalize<K>}`]?: (...args: Args) => any } : {};
+type SetupContextToProps<Emits extends EmitsOptions = {}, Slots extends SlotsType | Record<string, any> = {}, Exposed extends Record<string, any> = {}> = EmitsToProps<Emits> & SlotsToProps<Slots> & ExposedToProps<Exposed>;
+//#endregion
+export { DirectiveArgs, EmitFnToProps, ExposedToProps, ExtractExposed, IfAny, IsKeyValues, NodeArrayChildren, NodeChild, NodeRef, Prettify, RenderResult, SetupContextToProps, SlotsToProps };

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/vapor.d.ts

@@ -0,0 +1,111 @@
+import { EmitFnToProps, IsKeyValues, NodeChild, Prettify, SetupContextToProps } from "./types.js";
+import * as Vue from "vue";
+import { Block, ComponentObjectPropsOptions, ComponentTypeEmits, EmitFn, EmitsOptions, EmitsToProps, ExtractDefaultPropTypes, ExtractPropTypes, Fragment, ShallowRef, TypeEmitsToOptions, VaporComponent, VaporComponentInstance, VaporComponentOptions, VaporPublicProps, VaporRenderResult } from "vue";
+
+//#region src/vapor.d.ts
+declare function defineVaporSSRComponent(comp: VaporComponent, extraOptions: VaporComponent): VaporComponent;
+declare const createComponent: (type: VaporComponent | typeof Fragment | string, rawProps?: (Record<string, unknown> & {
+  $?: (Record<string, unknown> | (() => Record<string, unknown>))[];
+}) | null | undefined, rawSlots?: (Vue.VaporSlot | (Record<string, ((() => {
+  name: string;
+  fn: Vue.VaporSlot;
+  key?: unknown;
+} | {
+  name: string;
+  fn: Vue.VaporSlot;
+  key?: unknown;
+}[]) | {
+  [x: string]: Vue.VaporSlot;
+})[] | Vue.VaporSlot> & {
+  $?: ((() => {
+    name: string;
+    fn: Vue.VaporSlot;
+    key?: unknown;
+  } | {
+    name: string;
+    fn: Vue.VaporSlot;
+    key?: unknown;
+  }[]) | {
+    [x: string]: Vue.VaporSlot;
+  })[];
+})) | null | undefined, isSingleRoot?: boolean | undefined, once?: boolean | undefined, appContext?: Vue.GenericAppContext | undefined) => Block;
+declare function createProxyComponent(type: VaporComponent, normalizeNode?: (node: any) => Block): any;
+declare function normalizeNode(node: NodeChild): Block;
+declare function isBlock(val: NonNullable<unknown>): val is Block;
+declare function setNodes(anchor: Node, ...values: any[]): void;
+declare function createNodes(...values: any[]): Block[];
+declare function normalizeVaporSlots(slots: any): {
+  name: string;
+  fn: unknown;
+}[] | {
+  name: string;
+  fn: any;
+};
+type VaporComponentInstanceConstructor<T extends VaporComponentInstance> = {
+  __isFragment?: never;
+  __isTeleport?: never;
+  __isSuspense?: never;
+  new (...args: any[]): T;
+};
+type DefineVaporComponent<RuntimePropsOptions = {}, RuntimePropsKeys extends string = string, InferredProps = (string extends RuntimePropsKeys ? ComponentObjectPropsOptions extends RuntimePropsOptions ? {} : ExtractPropTypes<RuntimePropsOptions> : { [key in RuntimePropsKeys]?: any }), Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends Record<string, any> = Record<string, any>, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block, TypeRefs extends Record<string, unknown> = {}, MakeDefaultsOptional extends boolean = true, PublicProps = VaporPublicProps, ResolvedProps = Readonly<InferredProps> & EmitsToProps<Emits>, Defaults = ExtractDefaultPropTypes<RuntimePropsOptions>> = VaporComponentInstanceConstructor<VaporComponentInstance<MakeDefaultsOptional extends true ? keyof Defaults extends never ? Prettify<ResolvedProps> & PublicProps : Partial<Defaults> & Omit<Prettify<ResolvedProps> & PublicProps, keyof Defaults> : Prettify<ResolvedProps> & PublicProps, Emits, Slots, Exposed, TypeBlock, TypeRefs>> & VaporComponentOptions<RuntimePropsOptions | RuntimePropsKeys[], Emits, RuntimeEmitsKeys, Slots, Exposed>;
+type DefineVaporSetupFnComponent<Props extends Record<string, any> = {}, Emits extends EmitsOptions = {}, Slots extends Record<string, any> = Record<string, any>, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block, ResolvedProps extends Record<string, any> = Readonly<Props & VaporPublicProps> & SetupContextToProps<Emits, Slots, Exposed>> = new () => VaporComponentInstance<ResolvedProps, Emits, Slots, Exposed, TypeBlock>;
+declare function defineVaporComponent<Props extends Record<string, any>, Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends Record<string, any> = Record<string, any>, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block, Emit = EmitFn<Emits>>(setup: (this: void, props: Props, ctx: {
+  emit: Emit;
+  slots: Slots;
+  attrs: Record<string, any>;
+  expose: (exposed?: Exposed) => void;
+}) => VaporRenderResult<TypeBlock> | void, extraOptions?: VaporComponentOptions<(keyof NoInfer<Props>)[], Emits, RuntimeEmitsKeys, Slots, Exposed> & ThisType<void>): DefineVaporSetupFnComponent<Props & ([keyof Emits] extends [never] ? EmitFnToProps<Emit> : {}), Emits, Slots, Exposed, TypeBlock>;
+declare function defineVaporComponent<Props extends Record<string, any>, Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends Record<string, any> = Record<string, any>, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block, Emit = EmitFn<Emits>>(this: void, setup: (props: Props, ctx: {
+  emit: Emit;
+  slots: Slots;
+  attrs: Record<string, any>;
+  expose: (exposed?: Exposed) => void;
+}) => VaporRenderResult<TypeBlock> | void, extraOptions?: VaporComponentOptions<ComponentObjectPropsOptions<Props>, Emits, RuntimeEmitsKeys, Slots, Exposed> & ThisType<void>): DefineVaporSetupFnComponent<Props & ([keyof Emits] extends [never] ? EmitFnToProps<Emit> : {}), Emits, Slots, Exposed, TypeBlock>;
+declare function defineVaporComponent<TypeProps, RuntimePropsOptions extends ComponentObjectPropsOptions = ComponentObjectPropsOptions, RuntimePropsKeys extends string = string, TypeEmits extends ComponentTypeEmits = {}, RuntimeEmitsOptions extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends Record<string, any> = Record<string, any>, Exposed extends Record<string, any> = Record<string, any>, ResolvedEmits extends EmitsOptions = ({} extends RuntimeEmitsOptions ? TypeEmitsToOptions<TypeEmits> : RuntimeEmitsOptions), InferredProps = (IsKeyValues<TypeProps> extends true ? TypeProps : string extends RuntimePropsKeys ? ComponentObjectPropsOptions extends RuntimePropsOptions ? {} : ExtractPropTypes<RuntimePropsOptions> : { [key in RuntimePropsKeys]?: any }), TypeRefs extends Record<string, unknown> = {}, TypeBlock extends Block = Block>(options: VaporComponentOptions<RuntimePropsOptions | RuntimePropsKeys[], ResolvedEmits, RuntimeEmitsKeys, Slots, Exposed, TypeBlock, InferredProps> & {
+  [key: string]: any;
+  /**
+   * @private
+   */
+  __typeProps?: TypeProps;
+  /**
+   * @private
+   */
+  __typeEmits?: TypeEmits;
+  /**
+   * @private
+   */
+  __typeRefs?: TypeRefs;
+  /**
+   * @private
+   */
+  __typeEl?: TypeBlock;
+} & ThisType<void>): DefineVaporComponent<RuntimePropsOptions, RuntimePropsKeys, InferredProps, ResolvedEmits, RuntimeEmitsKeys, Slots, Block extends Exposed ? Record<string, any> : Exposed, TypeBlock, TypeRefs, unknown extends TypeProps ? true : false>;
+type ResolveItem<Item, GetKey> = GetKey extends undefined ? Item : ShallowRef<Item>;
+declare const VaporFor: new <T extends any[] | Record<any, any> | number | string | Set<any> | Map<any, any>, Item = (T extends number ? number : T extends string ? string : T extends any[] ? T[number] : T extends Iterable<infer T1> ? T1 : Record<any, any>), GetKeyDefault = (...args: string extends keyof Item ? [item: T[keyof T], key: keyof T, index: number] : [item: Item, index: number]) => any, GetKey extends GetKeyDefault | null | undefined = undefined>() => VaporComponentInstance<Readonly<{
+  in: T;
+  getKey?: GetKey extends undefined ? GetKeyDefault : GetKey;
+} & Vue.ReservedProps & Vue.AllowedComponentProps & Vue.ComponentCustomProps> & {} & {
+  readonly 'v-slots'?: {
+    readonly default?: ((...args: string extends keyof Item ? [item: ResolveItem<T[keyof T], GetKey>, key: ShallowRef<keyof T>, index: ShallowRef<number>] : [item: ResolveItem<Item, GetKey>, index: ShallowRef<number>]) => NodeChild) | undefined;
+  } | ((...args: string extends keyof Item ? [item: ResolveItem<T[keyof T], GetKey>, key: ShallowRef<keyof T>, index: ShallowRef<number>] : [item: ResolveItem<Item, GetKey>, index: ShallowRef<number>]) => NodeChild) | NoInfer<NodeChild<Block>> | undefined;
+}, {}, {
+  default: (...args: string extends keyof Item ? [item: ResolveItem<T[keyof T], GetKey>, key: ShallowRef<keyof T>, index: ShallowRef<number>] : [item: ResolveItem<Item, GetKey>, index: ShallowRef<number>]) => any;
+}, Record<string, any>, {
+  resetListeners?: (() => void)[];
+  onReset(fn: () => void): void;
+  $key?: any;
+  $transition?: Vue.VaporTransitionHooks | undefined;
+  nodes: Block[];
+  vnode?: Vue.VNode | null;
+  anchor?: Node;
+  isBlockValid?: (componentAsValid?: boolean) => boolean;
+  insert?: (parent: ParentNode, anchor: Node | null, parentSuspense?: Vue.SuspenseBoundary | null, transitionHooks?: Vue.TransitionHooks, moveType?: Vue.MoveType) => void;
+  remove?: (parent?: ParentNode, transitionHooks?: Vue.TransitionHooks) => void;
+  hydrate?(...args: any[]): void;
+  setRef?: (instance: VaporComponentInstance, ref: string | Vue.Ref<any, any> | ((ref: Element | VaporComponentInstance, refs: Record<string, any>) => void), refFor: boolean, refKey: string | undefined) => void;
+  onRemove?: (() => void)[];
+  onBeforeUpdate?: (() => void)[];
+  onUpdated?: ((nodes?: Block) => void)[];
+}, Record<string, any>>;
+//#endregion
+export { DefineVaporComponent, DefineVaporSetupFnComponent, VaporFor, createComponent, createNodes, createProxyComponent, defineVaporComponent, defineVaporSSRComponent, isBlock, normalizeNode, normalizeVaporSlots, setNodes };

package/dist/vapor.js

@@ -0,0 +1,154 @@
+import * as Vue from "vue";
+import { EffectScope, Fragment, getCurrentInstance } from "vue";
+//#region src/vapor.ts
+/* @__NO_SIDE_EFFECTS__ */
+function defineVaporSSRComponent(comp, extraOptions) {
+	if (typeof comp === "function") return Object.assign({ name: comp.name }, extraOptions, {
+		setup(props, ctx) {
+			const result = comp(props, ctx);
+			return () => result;
+		},
+		__vapor: true
+	});
+	const setup = comp.setup;
+	if (setup) comp.setup = (props, ctx) => {
+		const result = setup(props, ctx);
+		return () => result;
+	};
+	comp.__vapor = true;
+	return comp;
+}
+const createComponent = (type, ...args) => {
+	if (type === Fragment) {
+		const slots = args[1];
+		return slots ? typeof slots === "function" ? slots() : typeof slots.default === "function" ? slots.default() : [] : [];
+	}
+	return Vue.createComponentWithFallback(createProxyComponent(Vue.resolveDynamicComponent(type)), ...args);
+};
+const proxyCache = /* @__PURE__ */ new WeakMap();
+function createProxyComponent(type, normalizeNode) {
+	if (typeof type === "function") {
+		const existing = proxyCache.get(type);
+		if (existing) return existing;
+		const i = Vue.currentInstance || getCurrentInstance();
+		const proxy = new Proxy(type, {
+			apply(target, ctx, args) {
+				if (typeof target.__setup === "function") target.__setup.apply(ctx, args);
+				const node = Reflect.apply(target, ctx, args);
+				return normalizeNode ? normalizeNode(node) : node;
+			},
+			get(target, p, receiver) {
+				if (i && i.appContext.vapor && p === "__vapor") return true;
+				return Reflect.get(target, p, receiver);
+			}
+		});
+		proxyCache.set(type, proxy);
+		return proxy;
+	}
+	return type;
+}
+function normalizeNode(node) {
+	if (node == null || typeof node === "boolean") return document.createComment("");
+	else if (Array.isArray(node) && node.length) return node.map(normalizeNode);
+	else if (isBlock(node)) return node;
+	else if (typeof node === "function") return resolveValues([node], void 0, true)[0];
+	else return document.createTextNode(String(node));
+}
+function isBlock(val) {
+	return val instanceof Node || Array.isArray(val) || Vue.isVaporComponent(val) || Vue.isFragment(val);
+}
+function createFragment(nodes, anchor = document.createTextNode("")) {
+	const frag = new Vue.VaporFragment(nodes);
+	frag.anchor = anchor;
+	return frag;
+}
+function normalizeBlock(node, anchor, processFunction = false) {
+	if (node instanceof Node || Vue.isFragment(node)) return node;
+	else if (Vue.isVaporComponent(node)) return createFragment(node, anchor);
+	else if (Array.isArray(node)) return createFragment(node.map((i) => normalizeBlock(i, void 0, processFunction)), anchor);
+	else if (processFunction && typeof node === "function") return resolveValues([node], anchor, true)[0];
+	else {
+		const result = node == null || typeof node === "boolean" ? "" : String(node);
+		if (anchor) {
+			anchor.textContent = result;
+			return anchor;
+		} else return document.createTextNode(result);
+	}
+}
+function resolveValue(current, value, anchor, processFunction = false) {
+	anchor = anchor || (current instanceof Node && current.nodeType === 3 ? current : void 0);
+	const node = normalizeBlock(value, anchor, processFunction);
+	if (current) {
+		if (Vue.isFragment(current)) {
+			if (current.anchor && current.anchor.parentNode) {
+				Vue.remove(current.nodes, current.anchor.parentNode);
+				Vue.insert(node, current.anchor.parentNode, current.anchor);
+				if (!anchor) current.anchor.parentNode.removeChild(current.anchor);
+				if (current.scope) current.scope.stop();
+			}
+		} else if (current instanceof Node) {
+			if (current.nodeType === 3 && (!(node instanceof Node) || node.nodeType !== 3)) current.textContent = "";
+			if (Vue.isFragment(node) && current.parentNode) {
+				Vue.insert(node, current.parentNode, current);
+				if (!anchor || current.nodeType !== 3) current.parentNode.removeChild(current);
+			} else if (node instanceof Node) {
+				if (current.nodeType === 3 && node.nodeType === 3) {
+					current.textContent = node.textContent;
+					return current;
+				} else if (current.parentNode) current.parentNode.replaceChild(node, current);
+			}
+		}
+	}
+	return node;
+}
+function resolveValues(values = [], _anchor, processFunction = false) {
+	const nodes = [];
+	const scopes = [];
+	for (const [index, value] of values.entries()) {
+		const anchor = index === values.length - 1 ? _anchor : void 0;
+		if (typeof value === "function") Vue.renderEffect(() => {
+			if (scopes[index]) scopes[index].stop();
+			scopes[index] = new EffectScope();
+			nodes[index] = scopes[index].run(() => resolveValue(nodes[index], value(), anchor, processFunction));
+		});
+		else nodes[index] = resolveValue(nodes[index], value, anchor, processFunction);
+	}
+	return nodes;
+}
+function setNodes(anchor, ...values) {
+	const resolvedValues = resolveValues(values, anchor);
+	if (anchor.parentNode) Vue.insert(resolvedValues, anchor.parentNode, anchor);
+}
+function createNodes(...values) {
+	return resolveValues(values);
+}
+function normalizeVaporSlots(slots) {
+	if (typeof slots === "function") return {
+		name: "default",
+		fn: slots
+	};
+	else if (Object.prototype.toString.call(slots) === "[object Object]" && !isBlock(slots)) return Object.entries(slots).map(([name, fn]) => ({
+		name,
+		fn
+	}));
+	else return {
+		name: "default",
+		fn: () => createNodes(slots)
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function defineVaporComponent(comp, extraOptions) {
+	if (typeof comp === "function") return Object.assign({ name: comp.name }, extraOptions, {
+		setup: comp,
+		__vapor: true
+	});
+	comp.__vapor = true;
+	return comp;
+}
+const VaporFor = /* @__PURE__ */ defineVaporComponent((props, { slots }) => {
+	return Vue.createFor(() => props.in, (item, key, index) => {
+		return slots.default ? slots.default(props.getKey === void 0 ? item.value : item, key, index) : [];
+	}, props.getKey === void 0 ? (item) => item : props.getKey);
+}, { props: ["in", "getKey"] });
+//#endregion
+export { VaporFor, createComponent, createNodes, createProxyComponent, defineVaporComponent, defineVaporSSRComponent, isBlock, normalizeNode, normalizeVaporSlots, setNodes };

package/dist/vdom.d.ts

@@ -0,0 +1,77 @@
+import { EmitFnToProps, IsKeyValues, NodeChild, RenderResult, SetupContextToProps } from "./types.js";
+import * as _$vue from "vue";
+import { Component, ComponentInjectOptions, ComponentObjectPropsOptions, ComponentOptions, ComponentOptionsBase, ComponentOptionsMixin, ComponentPropsOptions, ComponentProvideOptions, ComponentPublicInstance, ComponentTypeEmits, ComputedOptions, CreateComponentPublicInstanceWithMixins, Directive, EmitFn, EmitsOptions, EmitsToProps, ExtractDefaultPropTypes, ExtractPropTypes, GlobalComponents, GlobalDirectives, MethodOptions, PublicProps, Slot, SlotsType, TypeEmitsToOptions, VNode, VNodeChild } from "vue";
+
+//#region src/vdom.d.ts
+declare function createVNodeCache(key: string): any;
+declare function normalizeVNode(value: VNodeChild | (() => VNodeChild), flag?: number): VNode;
+declare const normalizeSlot: (rawSlot: Function) => Slot;
+declare const normalizeSlots: (slots: any) => Record<string, any> | Function;
+declare const normalizeClass: (value: unknown) => string | null;
+type RenderFunction = () => RenderResult;
+type ComponentPublicInstanceConstructor<T extends ComponentPublicInstance<Props, RawBindings, D, C, M> = ComponentPublicInstance<any>, Props = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions> = {
+  __isFragment?: never;
+  __isTeleport?: never;
+  __isSuspense?: never;
+  new (...args: any[]): T;
+};
+type DefineComponent<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PP = PublicProps, Props = Readonly<PropsOrPropOptions extends ComponentPropsOptions ? ExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions> & EmitsToProps<E>, Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, MakeDefaultsOptional extends boolean = true, TypeRefs extends Record<string, unknown> = {}, TypeEl extends Element = any> = ComponentPublicInstanceConstructor<CreateComponentPublicInstanceWithMixins<Props, RawBindings, D, C, M, Mixin, Extends, E, PP, Defaults, MakeDefaultsOptional, {}, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, TypeRefs, TypeEl>> & ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, {}, string, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, Provide> & PP;
+type DefineSetupFnComponent<P extends Record<string, any>, E extends EmitsOptions = {}, S extends SlotsType = SlotsType, Exposed extends Record<string, any> = {}, Props = Readonly<P> & SetupContextToProps<E, S, Exposed>, PP = PublicProps> = new (props: Props & PP) => CreateComponentPublicInstanceWithMixins<Props, Exposed, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, E, PP, {}, false, {}, S, {}, {}, keyof Exposed & string>;
+declare function _defineComponent<Props extends Record<string, any>, Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends SlotsType | Record<string, any> = {}, Exposed extends Record<string, any> = {}, Emit = EmitFn<Emits>>(setup: (this: void, props: Props, ctx: {
+  emit: Emit;
+  slots: Slots;
+  attrs: Record<string, any>;
+  expose: (exposed?: Exposed) => void;
+}) => RenderFunction | Promise<RenderFunction>, options?: Omit<ComponentOptions, 'props' | 'emits' | 'slots'> & {
+  props?: (keyof NoInfer<Props>)[];
+  emits?: Emits | RuntimeEmitsKeys[];
+  slots?: Slots;
+}): DefineSetupFnComponent<Props & ([keyof Emits] extends [never] ? EmitFnToProps<Emit> : {}), Emits, Slots extends SlotsType ? Slots : SlotsType<Slots>, Exposed>;
+declare function _defineComponent<Props extends Record<string, any>, Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends SlotsType | Record<string, any> = {}, Exposed extends Record<string, any> = {}, Emit = EmitFn<Emits>>(setup: (this: void, props: Props, ctx: {
+  emit: Emit;
+  slots: Slots;
+  attrs: Record<string, any>;
+  expose: (exposed?: Exposed) => void;
+}) => RenderFunction | Promise<RenderFunction>, options?: Omit<ComponentOptions, 'props' | 'emits' | 'slots'> & {
+  props?: ComponentObjectPropsOptions<Props>;
+  emits?: Emits | RuntimeEmitsKeys[];
+  slots?: Slots;
+}): DefineSetupFnComponent<Props & ([keyof Emits] extends [never] ? EmitFnToProps<Emit> : {}), Emits, Slots extends SlotsType ? Slots : SlotsType<Slots>, Exposed>;
+declare function _defineComponent<TypeProps, RuntimePropsOptions extends ComponentObjectPropsOptions = ComponentObjectPropsOptions, RuntimePropsKeys extends string = string, TypeEmits extends ComponentTypeEmits = {}, RuntimeEmitsOptions extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Data = {}, SetupBindings = {}, Computed extends ComputedOptions = {}, Methods extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, InjectOptions extends ComponentInjectOptions = {}, InjectKeys extends string = string, Slots extends SlotsType = {}, LocalComponents extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, ResolvedEmits extends EmitsOptions = ({} extends RuntimeEmitsOptions ? TypeEmitsToOptions<TypeEmits> : RuntimeEmitsOptions), InferredProps = (IsKeyValues<TypeProps> extends true ? TypeProps : string extends RuntimePropsKeys ? ComponentObjectPropsOptions extends RuntimePropsOptions ? {} : ExtractPropTypes<RuntimePropsOptions> : { [key in RuntimePropsKeys]?: any }), TypeRefs extends Record<string, unknown> = {}, TypeEl extends Element = any>(options: {
+  props?: (RuntimePropsOptions & ThisType<void>) | RuntimePropsKeys[];
+  /**
+   * @private
+   */
+  __typeProps?: TypeProps;
+  /**
+   * @private
+   */
+  __typeEmits?: TypeEmits;
+  /**
+   * @private
+   */
+  __typeRefs?: TypeRefs;
+  /**
+   * @private
+   */
+  __typeEl?: TypeEl;
+} & ComponentOptionsBase<Readonly<InferredProps> & EmitsToProps<ResolvedEmits>, SetupBindings, Data, Computed, Methods, Mixin, Extends, RuntimeEmitsOptions, RuntimeEmitsKeys, {}, // Defaults
+InjectOptions, InjectKeys, Slots, LocalComponents, Directives, Exposed, Provide> & ThisType<CreateComponentPublicInstanceWithMixins<Readonly<InferredProps> & EmitsToProps<ResolvedEmits>, SetupBindings, Data, Computed, Methods, Mixin, Extends, ResolvedEmits, {}, {}, false, InjectOptions, Slots, LocalComponents, Directives, string>>): DefineComponent<InferredProps, SetupBindings, Data, Computed, Methods, Mixin, Extends, ResolvedEmits, RuntimeEmitsKeys, PublicProps, Readonly<InferredProps> & EmitsToProps<ResolvedEmits>, ExtractDefaultPropTypes<RuntimePropsOptions>, Slots, LocalComponents, Directives, Exposed, Provide, unknown extends TypeProps ? true : false, TypeRefs, TypeEl>;
+declare const defineComponent: typeof _defineComponent;
+declare const For: new <T extends any[] | Record<any, any> | number | string | Set<any> | Map<any, any>, Item = (T extends number ? number : T extends string ? string : T extends any[] ? T[number] : T extends Iterable<infer T1> ? T1 : Record<any, any>)>(props: Readonly<{
+  in: T;
+}> & {} & {
+  readonly 'v-slots'?: {
+    readonly default?: ((...args: string extends keyof Item ? [item: T[keyof T], key: keyof T, index: number] : [item: Item, index: number]) => NodeChild) | undefined;
+  } | ((...args: string extends keyof Item ? [item: T[keyof T], key: keyof T, index: number] : [item: Item, index: number]) => NodeChild) | NoInfer<NodeChild<_$vue.Block>> | undefined;
+} & _$vue.VNodeProps & _$vue.AllowedComponentProps & _$vue.ComponentCustomProps) => CreateComponentPublicInstanceWithMixins<Readonly<{
+  in: T;
+}> & {} & {
+  readonly 'v-slots'?: {
+    readonly default?: ((...args: string extends keyof Item ? [item: T[keyof T], key: keyof T, index: number] : [item: Item, index: number]) => NodeChild) | undefined;
+  } | ((...args: string extends keyof Item ? [item: T[keyof T], key: keyof T, index: number] : [item: Item, index: number]) => NodeChild) | NoInfer<NodeChild<_$vue.Block>> | undefined;
+}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, SlotsType<{
+  default: (...args: string extends keyof Item ? [item: T[keyof T], key: keyof T, index: number] : [item: Item, index: number]) => any;
+}>, {}, {}, never>;
+//#endregion
+export { DefineComponent, DefineSetupFnComponent, For, createVNodeCache, defineComponent, normalizeClass, normalizeSlot, normalizeSlots, normalizeVNode };

package/dist/vdom.js

@@ -0,0 +1,46 @@
+import { Comment, Fragment, Text, cloneVNode, createBlock, createElementBlock, createElementVNode, createVNode, defineComponent as defineComponent$1, getCurrentInstance, isVNode, normalizeClass as normalizeClass$1, openBlock, renderList, withCtx } from "vue";
+//#region src/vdom.ts
+const cacheMap = /* @__PURE__ */ new WeakMap();
+function createVNodeCache(key) {
+	const i = getCurrentInstance();
+	if (i) {
+		if (!cacheMap.has(i)) cacheMap.set(i, {});
+		const caches = cacheMap.get(i);
+		return caches[key] || (caches[key] = []);
+	} else return [];
+}
+function normalizeVNode(value, flag = 1) {
+	let create = createVNode;
+	let isBlock = false;
+	if (typeof value === "function") {
+		isBlock = true;
+		openBlock();
+		create = createBlock;
+		value = value();
+	}
+	return isVNode(value) ? isBlock ? createBlock(cloneIfMounted(value)) : cloneIfMounted(value) : Array.isArray(value) ? isBlock ? createElementBlock(Fragment, null, value.map((n) => normalizeVNode(() => n)), -2) : createElementVNode(Fragment, null, value.slice()) : value == null || typeof value === "boolean" ? create(Comment) : create(Text, null, String(value), flag);
+}
+function cloneIfMounted(child) {
+	return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
+}
+const normalizeSlotValue = (value) => Array.isArray(value) ? value.map((n) => normalizeVNode(n)) : [normalizeVNode(value)];
+const normalizeSlot = (rawSlot) => {
+	if (rawSlot._n) return rawSlot;
+	return withCtx((...args) => {
+		return normalizeSlotValue(rawSlot(...args));
+	});
+};
+const normalizeSlots = (slots) => {
+	return typeof slots === "function" || Object.prototype.toString.call(slots) === "[object Object]" && !isVNode(slots) ? slots : { default: withCtx(() => [normalizeVNode(() => slots)]) };
+};
+const normalizeClass = (value) => normalizeClass$1(value) || null;
+const defineComponent = defineComponent$1;
+const For = defineComponent((props, { slots }) => {
+	const defaultSlot = slots.default;
+	return () => (openBlock(true), createElementBlock(Fragment, null, renderList(props.in, (item, key, index) => {
+		const result = defaultSlot(item, key, index);
+		return Array.isArray(result) ? result.length === 1 ? result[0] : normalizeVNode(result) : result;
+	}), 128));
+}, { props: ["in"] });
+//#endregion
+export { For, createVNodeCache, defineComponent, normalizeClass, normalizeSlot, normalizeSlots, normalizeVNode };