@vue-jsx-vapor/compiler 0.0.0

package/dist/index.js

@@ -0,0 +1,1439 @@
+// src/index.ts
+import { generate as generate2 } from "@vue/compiler-vapor";
+
+// src/compile.ts
+import {
+  ErrorCodes as ErrorCodes2,
+  createCompilerError as createCompilerError2,
+  defaultOnError as defaultOnError2
+} from "@vue/compiler-dom";
+import { extend as extend5, isString as isString2 } from "@vue/shared";
+import {
+  generate
+} from "@vue/compiler-vapor";
+import { parse } from "@babel/parser";
+
+// src/transform.ts
+import {
+  defaultOnError,
+  defaultOnWarn
+} from "@vue/compiler-dom";
+import { EMPTY_OBJ, NOOP, extend, isArray } from "@vue/shared";
+
+// src/transforms/utils.ts
+import {
+  DynamicFlag
+} from "@vue/compiler-vapor";
+import { createSimpleExpression as createSimpleExpression2 } from "@vue/compiler-dom";
+import {
+  arrowFunctionExpression,
+  callExpression,
+  jsxClosingFragment,
+  jsxExpressionContainer,
+  jsxFragment,
+  jsxOpeningFragment,
+  parenthesizedExpression
+} from "@babel/types";
+
+// src/utils.ts
+import { isGloballyAllowed, isString, makeMap } from "@vue/shared";
+import {
+  ElementTypes,
+  Namespaces,
+  NodeTypes,
+  createSimpleExpression,
+  isLiteralWhitelisted
+} from "@vue/compiler-dom";
+import { parseExpression } from "@babel/parser";
+var __BROWSER__ = false;
+function isConstantExpression(exp) {
+  return isLiteralWhitelisted(exp.content) || isGloballyAllowed(exp.content) || getLiteralExpressionValue(exp) !== null;
+}
+function getLiteralExpressionValue(exp) {
+  if (!__BROWSER__ && exp.ast) {
+    if (["StringLiteral", "NumericLiteral", "BigIntLiteral"].includes(
+      exp.ast.type
+    )) {
+      return exp.ast.value;
+    } else if (exp.ast.type === "TemplateLiteral" && exp.ast.expressions.length === 0) {
+      return exp.ast.quasis[0].value.cooked;
+    }
+  }
+  return exp.isStatic ? exp.content : null;
+}
+function resolveExpression(node, context) {
+  const isStatic = !!node && (node.type === "StringLiteral" || node.type === "JSXText" || node.type === "JSXIdentifier");
+  const source = !node ? "" : node.type === "JSXIdentifier" ? node.name : isStatic ? node.value : node.type === "JSXExpressionContainer" ? node.expression.type === "Identifier" ? node.expression.name : context.ir.source.slice(
+    node.expression.start,
+    node.expression.end
+  ) : context.ir.source.slice(node.start, node.end);
+  const location = node ? node.loc : null;
+  let ast = false;
+  if (!isStatic && context.options.prefixIdentifiers) {
+    ast = parseExpression(` ${source}`, {
+      sourceType: "module",
+      plugins: context.options.expressionPlugins
+    });
+  }
+  return resolveSimpleExpression(source, isStatic, location, ast);
+}
+function resolveSimpleExpression(source, isStatic, location, ast) {
+  const result = createSimpleExpression(
+    source,
+    isStatic,
+    resolveLocation(location, source)
+  );
+  result.ast = ast ?? null;
+  return result;
+}
+function resolveLocation(location, context) {
+  return location ? {
+    start: {
+      line: location.start.line,
+      column: location.start.column + 1,
+      offset: location.start.index
+    },
+    end: {
+      line: location.end.line,
+      column: location.end.column + 1,
+      offset: location.end.index
+    },
+    source: isString(context) ? context : context.ir.source.slice(location.start.index, location.end.index)
+  } : {
+    start: { line: 1, column: 1, offset: 0 },
+    end: { line: 1, column: 1, offset: 0 },
+    source: ""
+  };
+}
+function resolveValue(value, context) {
+  return value ? {
+    type: NodeTypes.TEXT,
+    content: value.type === "StringLiteral" ? value.value : value.type === "JSXExpressionContainer" ? context.ir.source.slice(
+      value.expression.start,
+      value.expression.end
+    ) : "",
+    loc: resolveLocation(value.loc, context)
+  } : void 0;
+}
+function resolveNode(node, context) {
+  const tag = node.openingElement.name.type === "JSXIdentifier" ? node.openingElement.name.name : "";
+  const loc = resolveLocation(node.loc, context);
+  const tagType = isJSXComponent(node) ? ElementTypes.COMPONENT : ElementTypes.ELEMENT;
+  const props = node.openingElement.attributes.reduce(
+    (result, attr) => {
+      if (attr.type === "JSXAttribute") {
+        if (tagType === ElementTypes.COMPONENT) {
+          result.push(resolveDirectiveNode(attr, context));
+        } else {
+          result.push({
+            type: NodeTypes.ATTRIBUTE,
+            name: `${attr.name.name}`,
+            nameLoc: resolveLocation(attr.name.loc, context),
+            value: resolveValue(attr.value, context),
+            loc: resolveLocation(attr.loc, context)
+          });
+        }
+      }
+      return result;
+    },
+    []
+  );
+  return {
+    type: NodeTypes.ELEMENT,
+    props,
+    children: node.children,
+    tag,
+    loc,
+    ns: Namespaces.HTML,
+    tagType,
+    isSelfClosing: !!node.selfClosing,
+    codegenNode: void 0
+  };
+}
+function resolveDirectiveNode(node, context) {
+  const { value, name } = node;
+  const nameString = name.type === "JSXIdentifier" ? name.name : "";
+  const argString = name.type === "JSXNamespacedName" ? name.namespace.name : "";
+  const arg = name.type === "JSXNamespacedName" ? resolveSimpleExpression(argString, true, name.namespace.loc) : void 0;
+  const exp = value ? resolveExpression(value, context) : void 0;
+  const [tag, ...modifiers] = argString.split("_");
+  return {
+    type: NodeTypes.DIRECTIVE,
+    name: nameString,
+    rawName: `${name}:${tag}`,
+    exp,
+    arg,
+    loc: resolveLocation(node.loc, context),
+    modifiers: modifiers.map((modifier) => createSimpleExpression(modifier))
+  };
+}
+var isHtmlTags = makeMap(
+  "a,abbr,address,area,article,aside,audio,b,base,bdi,bdo,blockquote,body,br,button,canvas,caption,cite,code,col,colgroup,data,datalist,dd,del,details,dfn,dialog,div,dl,dt,em,embed,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,i,iframe,img,input,ins,kbd,label,legend,li,link,main,map,mark,math,menu,menuitem,meta,meter,nav,noscript,object,ol,optgroup,option,output,p,param,picture,pre,progress,q,rb,rp,rt,rtc,ruby,s,samp,script,search,section,select,slot,small,source,span,strong,style,sub,summary,sup,svg,table,tbody,td,template,textarea,tfoot,th,thead,time,title,tr,track,u,ul,var,video,wbr"
+);
+var isSvgTags = makeMap(
+  "a,altGlyph,altGlyphDef,altGlyphItem,animate,animateColor,animateMotion,animateTransform,circle,clipPath,color-profile,cursor,defs,desc,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,font,font-face,font-face-format,font-face-name,font-face-src,font-face-uri,foreignObject,g,glyph,glyphRef,hkern,image,line,linearGradient,marker,mask,metadata,missing-glyph,mpath,path,pattern,polygon,polyline,radialGradient,rect,script,set,stop,style,svg,switch,symbol,text,textPath,title,tref,tspan,use,view,vkern"
+);
+function isJSXComponent(node) {
+  if (node.type !== "JSXElement") return false;
+  const { openingElement } = node;
+  if (openingElement.name.type === "JSXIdentifier") {
+    const name = openingElement.name.name;
+    return !isHtmlTags(name) && !isSvgTags(name);
+  } else {
+    return openingElement.name.type === "JSXMemberExpression";
+  }
+}
+function isMapCallExpression(node) {
+  return !!node && node.type === "CallExpression" && node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier" && node.callee.property.name === "map";
+}
+function findProp(expression, key) {
+  if (expression?.type === "JSXElement") {
+    for (const attr of expression.openingElement.attributes) {
+      if (attr.type === "JSXAttribute" && attr.name.name === key) {
+        return attr;
+      }
+    }
+  }
+}
+function getReturnExpression(node) {
+  if (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+    if (node.body.type !== "BlockStatement") {
+      return node.body;
+    } else {
+      for (const statement of node.body.body) {
+        if (statement.type === "ReturnStatement" && statement.argument)
+          return statement.argument;
+      }
+    }
+  }
+}
+function isJSXElement(node) {
+  return !!node && (node.type === "JSXElement" || node.type === "JSXFragment");
+}
+
+// src/transforms/utils.ts
+function newDynamic() {
+  return {
+    flags: DynamicFlag.REFERENCED,
+    children: []
+  };
+}
+function newBlock(node) {
+  return {
+    type: 1,
+    node,
+    dynamic: newDynamic(),
+    effect: [],
+    operation: [],
+    returns: []
+  };
+}
+function createBranch(node, context, isVFor) {
+  context.node = node = wrapFragment(node, isVFor);
+  const branch = newBlock(node);
+  const exitBlock = context.enterBlock(branch, isVFor);
+  context.reference();
+  return [branch, exitBlock];
+}
+function wrapFragment(node, isVFor) {
+  if (node.type === "JSXFragment") {
+    return node;
+  }
+  if (isVFor && (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression")) {
+    if (isJSXElement(node.body)) {
+      node = node.body;
+    } else if (node.body.type === "BlockStatement" && node.body.body[0].type === "ReturnStatement" && node.body.body[0].argument) {
+      node = node.body.body[0].argument;
+    } else {
+      node = {
+        ...callExpression(
+          parenthesizedExpression(arrowFunctionExpression([], node.body)),
+          []
+        ),
+        start: node.body.start,
+        end: node.body.end
+      };
+    }
+  }
+  return jsxFragment(jsxOpeningFragment(), jsxClosingFragment(), [
+    node.type === "JSXElement" ? node : jsxExpressionContainer(node)
+  ]);
+}
+var EMPTY_EXPRESSION = createSimpleExpression2("", true);
+
+// src/ir/component.ts
+var IRDynamicPropsKind = /* @__PURE__ */ ((IRDynamicPropsKind2) => {
+  IRDynamicPropsKind2[IRDynamicPropsKind2["EXPRESSION"] = 0] = "EXPRESSION";
+  IRDynamicPropsKind2[IRDynamicPropsKind2["ATTRIBUTE"] = 1] = "ATTRIBUTE";
+  return IRDynamicPropsKind2;
+})(IRDynamicPropsKind || {});
+var IRSlotType = /* @__PURE__ */ ((IRSlotType2) => {
+  IRSlotType2[IRSlotType2["STATIC"] = 0] = "STATIC";
+  IRSlotType2[IRSlotType2["DYNAMIC"] = 1] = "DYNAMIC";
+  IRSlotType2[IRSlotType2["LOOP"] = 2] = "LOOP";
+  IRSlotType2[IRSlotType2["CONDITIONAL"] = 3] = "CONDITIONAL";
+  IRSlotType2[IRSlotType2["EXPRESSION"] = 4] = "EXPRESSION";
+  return IRSlotType2;
+})(IRSlotType || {});
+
+// src/ir/index.ts
+var IRNodeTypes = /* @__PURE__ */ ((IRNodeTypes2) => {
+  IRNodeTypes2[IRNodeTypes2["ROOT"] = 0] = "ROOT";
+  IRNodeTypes2[IRNodeTypes2["BLOCK"] = 1] = "BLOCK";
+  IRNodeTypes2[IRNodeTypes2["SET_PROP"] = 2] = "SET_PROP";
+  IRNodeTypes2[IRNodeTypes2["SET_DYNAMIC_PROPS"] = 3] = "SET_DYNAMIC_PROPS";
+  IRNodeTypes2[IRNodeTypes2["SET_TEXT"] = 4] = "SET_TEXT";
+  IRNodeTypes2[IRNodeTypes2["SET_EVENT"] = 5] = "SET_EVENT";
+  IRNodeTypes2[IRNodeTypes2["SET_DYNAMIC_EVENTS"] = 6] = "SET_DYNAMIC_EVENTS";
+  IRNodeTypes2[IRNodeTypes2["SET_HTML"] = 7] = "SET_HTML";
+  IRNodeTypes2[IRNodeTypes2["SET_TEMPLATE_REF"] = 8] = "SET_TEMPLATE_REF";
+  IRNodeTypes2[IRNodeTypes2["SET_MODEL_VALUE"] = 9] = "SET_MODEL_VALUE";
+  IRNodeTypes2[IRNodeTypes2["INSERT_NODE"] = 10] = "INSERT_NODE";
+  IRNodeTypes2[IRNodeTypes2["PREPEND_NODE"] = 11] = "PREPEND_NODE";
+  IRNodeTypes2[IRNodeTypes2["CREATE_TEXT_NODE"] = 12] = "CREATE_TEXT_NODE";
+  IRNodeTypes2[IRNodeTypes2["CREATE_COMPONENT_NODE"] = 13] = "CREATE_COMPONENT_NODE";
+  IRNodeTypes2[IRNodeTypes2["SLOT_OUTLET_NODE"] = 14] = "SLOT_OUTLET_NODE";
+  IRNodeTypes2[IRNodeTypes2["WITH_DIRECTIVE"] = 15] = "WITH_DIRECTIVE";
+  IRNodeTypes2[IRNodeTypes2["DECLARE_OLD_REF"] = 16] = "DECLARE_OLD_REF";
+  IRNodeTypes2[IRNodeTypes2["IF"] = 17] = "IF";
+  IRNodeTypes2[IRNodeTypes2["FOR"] = 18] = "FOR";
+  return IRNodeTypes2;
+})(IRNodeTypes || {});
+var DynamicFlag2 = /* @__PURE__ */ ((DynamicFlag3) => {
+  DynamicFlag3[DynamicFlag3["NONE"] = 0] = "NONE";
+  DynamicFlag3[DynamicFlag3["REFERENCED"] = 1] = "REFERENCED";
+  DynamicFlag3[DynamicFlag3["NON_TEMPLATE"] = 2] = "NON_TEMPLATE";
+  DynamicFlag3[DynamicFlag3["INSERT"] = 4] = "INSERT";
+  return DynamicFlag3;
+})(DynamicFlag2 || {});
+
+// src/transform.ts
+var defaultOptions = {
+  filename: "",
+  prefixIdentifiers: false,
+  hoistStatic: false,
+  hmr: false,
+  cacheHandlers: false,
+  nodeTransforms: [],
+  directiveTransforms: {},
+  transformHoist: null,
+  isBuiltInComponent: NOOP,
+  isCustomElement: NOOP,
+  expressionPlugins: [],
+  scopeId: null,
+  slotted: true,
+  ssr: false,
+  inSSR: false,
+  ssrCssVars: ``,
+  bindingMetadata: EMPTY_OBJ,
+  inline: false,
+  isTS: false,
+  onError: defaultOnError,
+  onWarn: defaultOnWarn
+};
+var TransformContext = class _TransformContext {
+  constructor(ir, node, options = {}) {
+    this.ir = ir;
+    this.node = node;
+    this.parent = null;
+    this.index = 0;
+    this.block = this.ir.block;
+    this.template = "";
+    this.childrenTemplate = [];
+    this.dynamic = this.ir.block.dynamic;
+    this.inVOnce = false;
+    this.inVFor = 0;
+    this.comment = [];
+    this.component = this.ir.component;
+    this.directive = this.ir.directive;
+    this.slots = [];
+    this.globalId = 0;
+    this.increaseId = () => this.globalId++;
+    this.options = extend({}, defaultOptions, options);
+    this.root = this;
+  }
+  enterBlock(ir, isVFor = false) {
+    const { block, template, dynamic, childrenTemplate, slots } = this;
+    this.block = ir;
+    this.dynamic = ir.dynamic;
+    this.template = "";
+    this.childrenTemplate = [];
+    this.slots = [];
+    isVFor && this.inVFor++;
+    return () => {
+      this.registerTemplate();
+      this.block = block;
+      this.template = template;
+      this.dynamic = dynamic;
+      this.childrenTemplate = childrenTemplate;
+      this.slots = slots;
+      isVFor && this.inVFor--;
+    };
+  }
+  reference() {
+    if (this.dynamic.id !== void 0) return this.dynamic.id;
+    this.dynamic.flags |= 1 /* REFERENCED */;
+    return this.dynamic.id = this.increaseId();
+  }
+  pushTemplate(content) {
+    const existing = this.ir.template.indexOf(content);
+    if (existing !== -1) return existing;
+    this.ir.template.push(content);
+    return this.ir.template.length - 1;
+  }
+  registerTemplate() {
+    if (!this.template) return -1;
+    const id = this.pushTemplate(this.template);
+    return this.dynamic.template = id;
+  }
+  registerEffect(expressions, ...operations) {
+    expressions = expressions.filter((exp) => !isConstantExpression(exp));
+    if (this.inVOnce || expressions.length === 0) {
+      return this.registerOperation(...operations);
+    }
+    const existing = this.block.effect.find(
+      (e) => isSameExpression(e.expressions, expressions)
+    );
+    if (existing) {
+      existing.operations.push(...operations);
+    } else {
+      this.block.effect.push({
+        expressions,
+        operations
+      });
+    }
+    function isSameExpression(a, b) {
+      if (a.length !== b.length) return false;
+      return a.every((exp, i) => exp.content === b[i].content);
+    }
+  }
+  registerOperation(...node) {
+    this.block.operation.push(...node);
+  }
+  create(node, index) {
+    return Object.assign(Object.create(_TransformContext.prototype), this, {
+      node,
+      parent: this,
+      index,
+      template: "",
+      childrenTemplate: [],
+      dynamic: newDynamic()
+    });
+  }
+};
+function transform(node, options = {}) {
+  const ir = {
+    type: 0 /* ROOT */,
+    node,
+    source: node.source,
+    template: [],
+    component: /* @__PURE__ */ new Set(),
+    directive: /* @__PURE__ */ new Set(),
+    block: newBlock(node)
+  };
+  const context = new TransformContext(ir, node, options);
+  transformNode(context);
+  return ir;
+}
+function transformNode(context) {
+  let { node } = context;
+  const { nodeTransforms } = context.options;
+  const exitFns = [];
+  for (const nodeTransform of nodeTransforms) {
+    const onExit = nodeTransform(node, context);
+    if (onExit) {
+      if (isArray(onExit)) {
+        exitFns.push(...onExit);
+      } else {
+        exitFns.push(onExit);
+      }
+    }
+    if (!context.node) {
+      return;
+    } else {
+      node = context.node;
+    }
+  }
+  context.node = node;
+  let i = exitFns.length;
+  while (i--) {
+    exitFns[i]();
+  }
+  if (context.node.type === 0 /* ROOT */) {
+    context.registerTemplate();
+  }
+}
+
+// src/transforms/transformElement.ts
+import {
+  camelize,
+  capitalize,
+  extend as extend2,
+  isBuiltInDirective,
+  isVoidTag,
+  makeMap as makeMap2
+} from "@vue/shared";
+
+// src/html-nesting.ts
+function isValidHTMLNesting(parent, child) {
+  if (parent in onlyValidChildren) {
+    return onlyValidChildren[parent].has(child);
+  }
+  if (child in onlyValidParents) {
+    return onlyValidParents[child].has(parent);
+  }
+  if (parent in knownInvalidChildren && // check if the child is in the list of invalid children
+  // if so, return false
+  knownInvalidChildren[parent].has(child))
+    return false;
+  if (child in knownInvalidParents && // check if the parent is in the list of invalid parents
+  // if so, return false
+  knownInvalidParents[child].has(parent))
+    return false;
+  return true;
+}
+var headings = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
+var emptySet = /* @__PURE__ */ new Set([]);
+var onlyValidChildren = {
+  head: /* @__PURE__ */ new Set([
+    "base",
+    "basefront",
+    "bgsound",
+    "link",
+    "meta",
+    "title",
+    "noscript",
+    "noframes",
+    "style",
+    "script",
+    "template"
+  ]),
+  optgroup: /* @__PURE__ */ new Set(["option"]),
+  select: /* @__PURE__ */ new Set(["optgroup", "option"]),
+  math: /* @__PURE__ */ new Set(["mrow"]),
+  script: /* @__PURE__ */ new Set(),
+  // table
+  table: /* @__PURE__ */ new Set(["caption", "colgroup", "tbody", "tfoot", "thead"]),
+  tr: /* @__PURE__ */ new Set(["td", "th"]),
+  colgroup: /* @__PURE__ */ new Set(["col"]),
+  tbody: /* @__PURE__ */ new Set(["tr"]),
+  thead: /* @__PURE__ */ new Set(["tr"]),
+  tfoot: /* @__PURE__ */ new Set(["tr"]),
+  // these elements can not have any children elements
+  iframe: emptySet,
+  option: emptySet,
+  textarea: emptySet,
+  style: emptySet,
+  title: emptySet
+};
+var onlyValidParents = {
+  // sections
+  html: emptySet,
+  body: /* @__PURE__ */ new Set(["html"]),
+  head: /* @__PURE__ */ new Set(["html"]),
+  // table
+  td: /* @__PURE__ */ new Set(["tr"]),
+  colgroup: /* @__PURE__ */ new Set(["table"]),
+  caption: /* @__PURE__ */ new Set(["table"]),
+  tbody: /* @__PURE__ */ new Set(["table"]),
+  tfoot: /* @__PURE__ */ new Set(["table"]),
+  col: /* @__PURE__ */ new Set(["colgroup"]),
+  th: /* @__PURE__ */ new Set(["tr"]),
+  thead: /* @__PURE__ */ new Set(["table"]),
+  tr: /* @__PURE__ */ new Set(["tbody", "thead", "tfoot"]),
+  // data list
+  dd: /* @__PURE__ */ new Set(["dl", "div"]),
+  dt: /* @__PURE__ */ new Set(["dl", "div"]),
+  // other
+  figcaption: /* @__PURE__ */ new Set(["figure"]),
+  // li: new Set(["ul", "ol"]),
+  summary: /* @__PURE__ */ new Set(["details"]),
+  area: /* @__PURE__ */ new Set(["map"])
+};
+var knownInvalidChildren = {
+  p: /* @__PURE__ */ new Set([
+    "address",
+    "article",
+    "aside",
+    "blockquote",
+    "center",
+    "details",
+    "dialog",
+    "dir",
+    "div",
+    "dl",
+    "fieldset",
+    "figure",
+    "footer",
+    "form",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "header",
+    "hgroup",
+    "hr",
+    "li",
+    "main",
+    "nav",
+    "menu",
+    "ol",
+    "p",
+    "pre",
+    "section",
+    "table",
+    "ul"
+  ]),
+  svg: /* @__PURE__ */ new Set([
+    "b",
+    "blockquote",
+    "br",
+    "code",
+    "dd",
+    "div",
+    "dl",
+    "dt",
+    "em",
+    "embed",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "hr",
+    "i",
+    "img",
+    "li",
+    "menu",
+    "meta",
+    "ol",
+    "p",
+    "pre",
+    "ruby",
+    "s",
+    "small",
+    "span",
+    "strong",
+    "sub",
+    "sup",
+    "table",
+    "u",
+    "ul",
+    "var"
+  ])
+};
+var knownInvalidParents = {
+  a: /* @__PURE__ */ new Set(["a"]),
+  button: /* @__PURE__ */ new Set(["button"]),
+  dd: /* @__PURE__ */ new Set(["dd", "dt"]),
+  dt: /* @__PURE__ */ new Set(["dd", "dt"]),
+  form: /* @__PURE__ */ new Set(["form"]),
+  li: /* @__PURE__ */ new Set(["li"]),
+  h1: headings,
+  h2: headings,
+  h3: headings,
+  h4: headings,
+  h5: headings,
+  h6: headings
+};
+
+// src/transforms/transformElement.ts
+var isReservedProp = /* @__PURE__ */ makeMap2(
+  // the leading comma is intentional so empty string "" is also included
+  ",key,ref,ref_for,ref_key,"
+);
+var __BROWSER__2 = false;
+var isEventRegex = /^on[A-Z]/;
+var isDirectiveRegex = /^v-[a-z]/;
+var transformElement = (node, context) => {
+  return function postTransformElement() {
+    ;
+    ({ node } = context);
+    if (node.type !== "JSXElement") return;
+    const {
+      openingElement: { name }
+    } = node;
+    const tag = name.type === "JSXIdentifier" ? name.name : name.type === "JSXMemberExpression" ? context.ir.source.slice(name.start, name.end) : "";
+    const isComponent = isJSXComponent(node);
+    const propsResult = buildProps(
+      node,
+      context,
+      isComponent
+    );
+    (isComponent ? transformComponentElement : transformNativeElement)(
+      tag,
+      propsResult,
+      context
+    );
+  };
+};
+function transformComponentElement(tag, propsResult, context) {
+  let asset = true;
+  if (!__BROWSER__2) {
+    const fromSetup = resolveSetupReference(tag, context);
+    if (fromSetup) {
+      tag = fromSetup;
+      asset = false;
+    }
+    const dotIndex = tag.indexOf(".");
+    if (dotIndex > 0) {
+      const ns = resolveSetupReference(tag.slice(0, dotIndex), context);
+      if (ns) {
+        tag = ns + tag.slice(dotIndex);
+        asset = false;
+      }
+    }
+  }
+  if (asset) {
+    context.component.add(tag);
+  }
+  context.dynamic.flags |= 2 /* NON_TEMPLATE */ | 4 /* INSERT */;
+  const root = context.root === context.parent && context.parent.node.children.length === 1;
+  context.registerOperation({
+    type: 13 /* CREATE_COMPONENT_NODE */,
+    id: context.reference(),
+    tag,
+    props: propsResult[0] ? propsResult[1] : [propsResult[1]],
+    asset,
+    root,
+    slots: context.slots,
+    once: context.inVOnce
+  });
+  context.slots = [];
+}
+function resolveSetupReference(name, context) {
+  const bindings = context.options.bindingMetadata;
+  if (!context.options.prefixIdentifiers) return name;
+  if (!bindings || bindings.__isScriptSetup === false) {
+    return;
+  }
+  const camelName = camelize(name);
+  const PascalName = capitalize(camelName);
+  return bindings[name] ? name : bindings[camelName] ? camelName : bindings[PascalName] ? PascalName : void 0;
+}
+function transformNativeElement(tag, propsResult, context) {
+  const { scopeId } = context.options;
+  let template = "";
+  template += `<${tag}`;
+  if (scopeId) template += ` ${scopeId}`;
+  if (propsResult[0]) {
+    const [, dynamicArgs, expressions] = propsResult;
+    context.registerEffect(expressions, {
+      type: 3 /* SET_DYNAMIC_PROPS */,
+      element: context.reference(),
+      props: dynamicArgs
+    });
+  } else {
+    for (const prop of propsResult[1]) {
+      const { key, values } = prop;
+      if (key.isStatic && values.length === 1 && values[0].isStatic) {
+        template += ` ${key.content}`;
+        if (values[0].content) template += `="${values[0].content}"`;
+      } else {
+        context.registerEffect(values, {
+          type: 2 /* SET_PROP */,
+          element: context.reference(),
+          prop
+        });
+      }
+    }
+  }
+  template += `>${context.childrenTemplate.join("")}`;
+  if (!isVoidTag(tag)) {
+    template += `</${tag}>`;
+  }
+  if (context.parent && context.parent.node.type === "JSXElement" && context.parent.node.openingElement.name.type === "JSXIdentifier" && !isValidHTMLNesting(context.parent.node.openingElement.name.name, tag)) {
+    context.reference();
+    context.dynamic.template = context.pushTemplate(template);
+    context.dynamic.flags |= 4 /* INSERT */ | 2 /* NON_TEMPLATE */;
+  } else {
+    context.template += template;
+  }
+}
+function buildProps(node, context, isComponent) {
+  const props = node.openingElement.attributes;
+  if (props.length === 0) return [false, []];
+  const dynamicArgs = [];
+  const dynamicExpr = [];
+  let results = [];
+  function pushMergeArg() {
+    if (results.length) {
+      dynamicArgs.push(dedupeProperties(results));
+      results = [];
+    }
+  }
+  for (const prop of props) {
+    if (prop.type === "JSXSpreadAttribute" && prop.argument) {
+      const value = resolveExpression(prop.argument, context);
+      dynamicExpr.push(value);
+      pushMergeArg();
+      dynamicArgs.push({
+        kind: 0 /* EXPRESSION */,
+        value
+      });
+      continue;
+    }
+    const result = transformProp(prop, node, context);
+    if (result) {
+      dynamicExpr.push(result.key, result.value);
+      if (isComponent && !result.key.isStatic) {
+        pushMergeArg();
+        dynamicArgs.push(
+          extend2(resolveDirectiveResult(result), {
+            kind: 1 /* ATTRIBUTE */
+          })
+        );
+      } else {
+        results.push(result);
+      }
+    }
+  }
+  if (dynamicArgs.length || results.some(({ key }) => !key.isStatic)) {
+    pushMergeArg();
+    return [true, dynamicArgs, dynamicExpr];
+  }
+  const irProps = dedupeProperties(results);
+  return [false, irProps];
+}
+function transformProp(prop, node, context) {
+  if (prop.type === "JSXSpreadAttribute") return;
+  let name = prop.name.type === "JSXIdentifier" ? prop.name.name : prop.name.type === "JSXNamespacedName" ? prop.name.namespace.name : "";
+  if (!isDirectiveRegex.test(name) && (!prop.value || prop.value.type === "StringLiteral")) {
+    if (isReservedProp(name)) return;
+    return {
+      key: resolveSimpleExpression(name, true, prop.name.loc),
+      value: prop.value && prop.value.type === "StringLiteral" ? resolveSimpleExpression(prop.value.value, true, prop.value.loc) : EMPTY_EXPRESSION
+    };
+  }
+  name = isEventRegex.test(name) ? "on" : isDirectiveRegex.test(name) ? name.slice(2) : "bind";
+  const directiveTransform = context.options.directiveTransforms[name];
+  if (directiveTransform) {
+    return directiveTransform(prop, node, context);
+  }
+  if (!isBuiltInDirective(name)) {
+    const fromSetup = !__BROWSER__2 && resolveSetupReference(`v-${name}`, context);
+    if (fromSetup) {
+      name = fromSetup;
+    } else {
+      context.directive.add(name);
+    }
+  }
+}
+function dedupeProperties(results) {
+  const knownProps = /* @__PURE__ */ new Map();
+  const deduped = [];
+  for (const result of results) {
+    const prop = resolveDirectiveResult(result);
+    if (!prop.key.isStatic) {
+      deduped.push(prop);
+      continue;
+    }
+    const name = prop.key.content;
+    const existing = knownProps.get(name);
+    if (existing) {
+      if (name === "style" || name === "class") {
+        mergePropValues(existing, prop);
+      }
+    } else {
+      knownProps.set(name, prop);
+      deduped.push(prop);
+    }
+  }
+  return deduped;
+}
+function resolveDirectiveResult(prop) {
+  return extend2({}, prop, {
+    value: void 0,
+    values: [prop.value]
+  });
+}
+function mergePropValues(existing, incoming) {
+  const newValues = incoming.values;
+  existing.values.push(...newValues);
+}
+
+// src/transforms/transformChildren.ts
+var transformChildren = (node, context) => {
+  const isFragment = node.type === 0 /* ROOT */ || node.type === "JSXFragment" || isJSXComponent(node);
+  if (node.type !== "JSXElement" && !isFragment) return;
+  Array.from(node.children).forEach((child, index) => {
+    if (child.type === "JSXText" && !child.value.trim()) {
+      child.value = " ";
+      if (!index) {
+        node.children.splice(0, 1);
+      } else if (index === node.children.length) {
+        node.children.splice(-1, 1);
+      }
+    }
+  });
+  for (const [i, child] of node.children.entries()) {
+    const childContext = context.create(child, i);
+    transformNode(childContext);
+    if (isFragment) {
+      childContext.reference();
+      childContext.registerTemplate();
+      if (!(childContext.dynamic.flags & 2 /* NON_TEMPLATE */) || childContext.dynamic.flags & 4 /* INSERT */) {
+        context.block.returns.push(childContext.dynamic.id);
+      }
+    } else {
+      context.childrenTemplate.push(childContext.template);
+    }
+    context.dynamic.children[i] = childContext.dynamic;
+  }
+  if (!isFragment) {
+    processDynamicChildren(context);
+  }
+};
+function processDynamicChildren(context) {
+  let prevDynamics = [];
+  let hasStaticTemplate = false;
+  const children = context.dynamic.children;
+  for (const [index, child] of children.entries()) {
+    if (child.flags & 4 /* INSERT */) {
+      prevDynamics.push(child);
+    }
+    if (!(child.flags & 2 /* NON_TEMPLATE */)) {
+      if (prevDynamics.length) {
+        if (hasStaticTemplate) {
+          context.childrenTemplate[index - prevDynamics.length] = `<!>`;
+          prevDynamics[0].flags -= 2 /* NON_TEMPLATE */;
+          const anchor = prevDynamics[0].anchor = context.increaseId();
+          context.registerOperation({
+            type: 10 /* INSERT_NODE */,
+            elements: prevDynamics.map((child2) => child2.id),
+            parent: context.reference(),
+            anchor
+          });
+        } else {
+          context.registerOperation({
+            type: 11 /* PREPEND_NODE */,
+            elements: prevDynamics.map((child2) => child2.id),
+            parent: context.reference()
+          });
+        }
+        prevDynamics = [];
+      }
+      hasStaticTemplate = true;
+    }
+  }
+  if (prevDynamics.length) {
+    context.registerOperation({
+      type: 10 /* INSERT_NODE */,
+      elements: prevDynamics.map((child) => child.id),
+      parent: context.reference()
+    });
+  }
+}
+
+// src/transforms/transformTemplateRef.ts
+var transformTemplateRef = (node, context) => {
+  if (node.type !== "JSXElement") return;
+  const dir = findProp(node, "ref");
+  if (!dir?.value) return;
+  const value = resolveExpression(dir.value, context);
+  return () => {
+    const id = context.reference();
+    const effect = !isConstantExpression(value);
+    effect && context.registerOperation({
+      type: 16 /* DECLARE_OLD_REF */,
+      id
+    });
+    context.registerEffect([value], {
+      type: 8 /* SET_TEMPLATE_REF */,
+      element: id,
+      value,
+      refFor: !!context.inVFor,
+      effect
+    });
+  };
+};
+
+// src/transforms/vIf.ts
+function processConditionalExpression(node, context) {
+  const { test, consequent, alternate } = node;
+  context.dynamic.flags |= 2 /* NON_TEMPLATE */ | 4 /* INSERT */;
+  const id = context.reference();
+  const condition = resolveExpression(test, context);
+  const [branch, onExit] = createBranch(consequent, context);
+  const operation = {
+    type: 17 /* IF */,
+    id,
+    condition,
+    positive: branch,
+    once: context.inVOnce
+  };
+  return [
+    () => {
+      onExit();
+      context.registerOperation(operation);
+    },
+    () => {
+      const [branch2, onExit2] = createBranch(alternate, context);
+      operation.negative = branch2;
+      transformNode(context);
+      onExit2();
+    }
+  ];
+}
+function processLogicalExpression(node, context) {
+  const { left, right, operator } = node;
+  context.dynamic.flags |= 2 /* NON_TEMPLATE */;
+  context.dynamic.flags |= 4 /* INSERT */;
+  const id = context.reference();
+  const condition = resolveExpression(left, context);
+  const [branch, onExit] = createBranch(
+    operator === "&&" ? right : left,
+    context
+  );
+  const operation = {
+    type: 17 /* IF */,
+    id,
+    condition,
+    positive: branch,
+    once: context.inVOnce
+  };
+  return [
+    () => {
+      onExit();
+      context.registerOperation(operation);
+    },
+    () => {
+      const [branch2, onExit2] = createBranch(
+        operator === "&&" ? left : right,
+        context
+      );
+      operation.negative = branch2;
+      transformNode(context);
+      onExit2();
+    }
+  ];
+}
+
+// src/transforms/vFor.ts
+function processMapCallExpression(node, context) {
+  const {
+    callee,
+    arguments: [argument]
+  } = node;
+  if (!(argument.type === "FunctionExpression" || argument.type === "ArrowFunctionExpression") || callee?.type !== "MemberExpression")
+    return;
+  context.dynamic.flags |= 2 /* NON_TEMPLATE */ | 4 /* INSERT */;
+  const id = context.reference();
+  const [render, exitBlock] = createBranch(argument, context, true);
+  const source = resolveExpression(callee.object, context);
+  const value = argument.params[0] && resolveExpression(argument.params[0], context);
+  const key = argument.params[1] && resolveExpression(argument.params[1], context);
+  const index = argument.params[2] && resolveExpression(argument.params[2], context);
+  const returnExpression = getReturnExpression(argument);
+  const keyProp = findProp(returnExpression, "key");
+  const keyProperty = keyProp && resolveExpression(keyProp.value, context);
+  return () => {
+    exitBlock();
+    context.registerOperation({
+      type: 18 /* FOR */,
+      id,
+      source,
+      value,
+      key,
+      index,
+      keyProp: keyProperty,
+      render,
+      once: context.inVOnce
+    });
+  };
+}
+
+// src/transforms/transformText.ts
+var seen = /* @__PURE__ */ new WeakMap();
+var transformText = (node, context) => {
+  if (!seen.has(context.root)) seen.set(context.root, /* @__PURE__ */ new WeakSet());
+  if (seen.get(context.root).has(node)) {
+    context.dynamic.flags |= 2 /* NON_TEMPLATE */;
+    return;
+  }
+  if (node.type === "JSXElement" && !isJSXComponent(node) && isAllTextLike(node.children)) {
+    processTextLikeContainer(
+      node.children,
+      context
+    );
+  } else if (node.type === "JSXExpressionContainer") {
+    if (node.expression.type === "ConditionalExpression") {
+      return processConditionalExpression(node.expression, context);
+    } else if (node.expression.type === "LogicalExpression") {
+      return processLogicalExpression(node.expression, context);
+    } else if (node.expression.type === "CallExpression") {
+      if (isMapCallExpression(node.expression)) {
+        return processMapCallExpression(node.expression, context);
+      } else {
+        processCallExpression(node.expression, context);
+      }
+    } else {
+      processTextLike(context);
+    }
+  } else if (node.type === "JSXText") {
+    context.template += node.value;
+  }
+};
+function processTextLike(context) {
+  const nexts = context.parent.node.children?.slice(context.index);
+  const idx = nexts.findIndex((n) => !isTextLike(n));
+  const nodes = idx > -1 ? nexts.slice(0, idx) : nexts;
+  const id = context.reference();
+  const values = nodes.map((node) => createTextLikeExpression(node, context));
+  context.dynamic.flags |= 4 /* INSERT */ | 2 /* NON_TEMPLATE */;
+  context.registerOperation({
+    type: 12 /* CREATE_TEXT_NODE */,
+    id,
+    values,
+    effect: !values.every(isConstantExpression) && !context.inVOnce
+  });
+}
+function processTextLikeContainer(children, context) {
+  const values = children.map(
+    (child) => createTextLikeExpression(child, context)
+  );
+  const literals = values.map(getLiteralExpressionValue);
+  if (literals.every((l) => l != null)) {
+    context.childrenTemplate = literals.map((l) => String(l));
+  } else {
+    context.registerEffect(values, {
+      type: 4 /* SET_TEXT */,
+      element: context.reference(),
+      values
+    });
+  }
+}
+function createTextLikeExpression(node, context) {
+  seen.get(context.root).add(node);
+  return resolveExpression(node, context);
+}
+function isAllTextLike(children) {
+  return !!children.length && children.every(isTextLike) && // at least one an interpolation
+  children.some((n) => n.type === "JSXExpressionContainer");
+}
+function isTextLike(node) {
+  return node.type === "JSXExpressionContainer" && !(node.expression.type === "ConditionalExpression" || node.expression.type === "LogicalExpression") && node.expression.type !== "CallExpression" || node.type === "JSXText";
+}
+function processCallExpression(node, context) {
+  context.dynamic.flags |= 2 /* NON_TEMPLATE */ | 4 /* INSERT */;
+  const root = context.root === context.parent && context.parent.node.children.length === 1;
+  const tag = `() => ${context.ir.source.slice(node.start, node.end)}`;
+  context.registerOperation({
+    type: 13 /* CREATE_COMPONENT_NODE */,
+    id: context.reference(),
+    tag,
+    props: [],
+    asset: false,
+    root,
+    slots: context.slots,
+    once: context.inVOnce
+  });
+}
+
+// src/transforms/vBind.ts
+import { camelize as camelize2, extend as extend3 } from "@vue/shared";
+var transformVBind = (dir, node, context) => {
+  const { name, value, loc } = dir;
+  if (!loc || name.type === "JSXNamespacedName") return;
+  const [nameString, ...modifiers] = name.name.split("_");
+  const exp = resolveExpression(value, context);
+  let arg = resolveSimpleExpression(nameString, true, dir.name.loc);
+  if (arg.isStatic && isReservedProp(arg.content)) return;
+  let camel = false;
+  if (modifiers.includes("camel")) {
+    if (arg.isStatic) {
+      arg = extend3({}, arg, { content: camelize2(arg.content) });
+    } else {
+      camel = true;
+    }
+  }
+  return {
+    key: arg,
+    value: exp,
+    loc,
+    runtimeCamelize: camel,
+    modifier: modifiers.includes("prop") ? "." : modifiers.includes("attr") ? "^" : void 0
+  };
+};
+
+// src/transforms/vOn.ts
+import {
+  ErrorCodes,
+  createCompilerError,
+  createSimpleExpression as createSimpleExpression3,
+  resolveModifiers
+} from "@vue/compiler-dom";
+import { extend as extend4, makeMap as makeMap3 } from "@vue/shared";
+var delegatedEvents = /* @__PURE__ */ makeMap3(
+  "beforeinput,click,dblclick,contextmenu,focusin,focusout,input,keydown,keyup,mousedown,mousemove,mouseout,mouseover,mouseup,pointerdown,pointermove,pointerout,pointerover,pointerup,touchend,touchmove,touchstart"
+);
+var transformVOn = (dir, node, context) => {
+  const { name, loc, value } = dir;
+  if (name.type === "JSXNamespacedName") return;
+  const isComponent = isJSXComponent(node);
+  const [nameString, ...modifiers] = name.name.replace(/^on([A-Z])/, (_, $1) => $1.toLowerCase()).split("_");
+  if (!value && !modifiers.length) {
+    context.options.onError(
+      createCompilerError(
+        ErrorCodes.X_V_ON_NO_EXPRESSION,
+        resolveLocation(loc, context)
+      )
+    );
+  }
+  let arg = resolveSimpleExpression(nameString, true, dir.name.loc);
+  const exp = resolveExpression(dir.value, context);
+  const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(
+    arg.isStatic ? `on${nameString}` : arg,
+    modifiers.map((modifier) => createSimpleExpression3(modifier)),
+    null,
+    resolveLocation(loc, context)
+  );
+  let keyOverride;
+  const isStaticClick = arg.isStatic && arg.content.toLowerCase() === "click";
+  const delegate = arg.isStatic && !eventOptionModifiers.length && delegatedEvents(arg.content);
+  if (nonKeyModifiers.includes("middle")) {
+    if (keyOverride) {
+    }
+    if (isStaticClick) {
+      arg = extend4({}, arg, { content: "mouseup" });
+    } else if (!arg.isStatic) {
+      keyOverride = ["click", "mouseup"];
+    }
+  }
+  if (nonKeyModifiers.includes("right")) {
+    if (isStaticClick) {
+      arg = extend4({}, arg, { content: "contextmenu" });
+    } else if (!arg.isStatic) {
+      keyOverride = ["click", "contextmenu"];
+    }
+  }
+  if (isComponent) {
+    const handler = exp || EMPTY_EXPRESSION;
+    return {
+      key: arg,
+      value: handler,
+      handler: true
+    };
+  }
+  const operation = {
+    type: 5 /* SET_EVENT */,
+    element: context.reference(),
+    key: arg,
+    value: exp,
+    modifiers: {
+      keys: keyModifiers,
+      nonKeys: nonKeyModifiers,
+      options: eventOptionModifiers
+    },
+    keyOverride,
+    delegate,
+    effect: !arg.isStatic
+  };
+  context.registerEffect([arg], operation);
+};
+
+// src/transforms/vSlot.ts
+var transformVSlot = (node, context) => {
+  if (node.type !== "JSXElement") return;
+  if (!isJSXComponent(node)) return;
+  const { openingElement, children } = node;
+  const vSlotsIndex = openingElement.attributes.findIndex(
+    (attr) => attr.type === "JSXAttribute" && ["v-slots", "vSlots"].includes(attr.name.name.toString())
+  );
+  const vSlotsDir = openingElement.attributes[vSlotsIndex];
+  if (vSlotsDir && vSlotsDir.value?.type === "JSXExpressionContainer") {
+    node.openingElement.attributes.splice(vSlotsIndex, 1);
+    context.slots = [
+      {
+        slotType: 4 /* EXPRESSION */,
+        slots: resolveExpression(vSlotsDir.value.expression, context)
+      }
+    ];
+  }
+  if (children.length) {
+    return transformComponentSlot(node, context);
+  }
+};
+function transformComponentSlot(node, context) {
+  const { children } = node;
+  const nonWhitespaceChildren = children.filter(
+    () => isNonWhitespaceContent(node)
+  );
+  const [block, onExit] = createSlotBlock(node, context);
+  const { slots } = context;
+  return () => {
+    onExit();
+    if (nonWhitespaceChildren.length) {
+      registerSlot(slots, block);
+      context.slots = slots;
+    }
+  };
+}
+function ensureStaticSlots(slots) {
+  let lastSlots = slots.at(-1);
+  if (!slots.length || lastSlots.slotType !== 0 /* STATIC */) {
+    slots.push(
+      lastSlots = {
+        slotType: 0 /* STATIC */,
+        slots: {}
+      }
+    );
+  }
+  return lastSlots;
+}
+function registerSlot(slots, block) {
+  const staticSlots = ensureStaticSlots(slots);
+  staticSlots.slots.default = block;
+}
+function createSlotBlock(slotNode, context) {
+  const block = newBlock(slotNode);
+  const exitBlock = context.enterBlock(block);
+  return [block, exitBlock];
+}
+function isNonWhitespaceContent(node) {
+  if (node.type !== "JSXText") return true;
+  return !!node.value.trim();
+}
+
+// src/transforms/vModel.ts
+import { transformVModel as _transformVModel } from "@vue/compiler-vapor";
+var transformVModel = (dir, node, context) => {
+  return _transformVModel(
+    resolveDirectiveNode(dir, context),
+    resolveNode(node, context),
+    context
+  );
+};
+
+// src/transforms/vShow.ts
+import { transformVShow as _transformVShow } from "@vue/compiler-vapor";
+var transformVShow = (dir, node, context) => {
+  return _transformVShow(
+    resolveDirectiveNode(dir, context),
+    resolveNode(node, context),
+    context
+  );
+};
+
+// src/transforms/vHtml.ts
+import { transformVHtml as _transformVHtml } from "@vue/compiler-vapor";
+var transformVHtml = (dir, node, context) => {
+  return _transformVHtml(
+    resolveDirectiveNode(dir, context),
+    resolveNode(node, context),
+    context
+  );
+};
+
+// src/compile.ts
+function compile(source, options = {}) {
+  const onError = options.onError || defaultOnError2;
+  const isModuleMode = options.mode === "module";
+  const __BROWSER__3 = false;
+  if (__BROWSER__3) {
+    if (options.prefixIdentifiers === true) {
+      onError(createCompilerError2(ErrorCodes2.X_PREFIX_ID_NOT_SUPPORTED));
+    } else if (isModuleMode) {
+      onError(createCompilerError2(ErrorCodes2.X_MODULE_MODE_NOT_SUPPORTED));
+    }
+  }
+  const prefixIdentifiers = !__BROWSER__3 && options.prefixIdentifiers === true;
+  if (options.scopeId && !isModuleMode) {
+    onError(createCompilerError2(ErrorCodes2.X_SCOPE_ID_NOT_SUPPORTED));
+  }
+  const resolvedOptions = extend5({}, options, {
+    prefixIdentifiers,
+    expressionPlugins: options.expressionPlugins || ["jsx"]
+  });
+  if (!__BROWSER__3 && options.isTS) {
+    const { expressionPlugins } = resolvedOptions;
+    if (!expressionPlugins.includes("typescript")) {
+      resolvedOptions.expressionPlugins = [
+        ...expressionPlugins || [],
+        "typescript"
+      ];
+    }
+  }
+  const {
+    body: [statement]
+  } = isString2(source) ? parse(source, {
+    sourceType: "module",
+    plugins: resolvedOptions.expressionPlugins
+  }).program : source;
+  let children;
+  if (statement.type === "ExpressionStatement") {
+    children = statement.expression.type === "JSXFragment" ? statement.expression.children : statement.expression.type === "JSXElement" ? [statement.expression] : [];
+  }
+  const ast = {
+    type: 0 /* ROOT */,
+    children,
+    source: isString2(source) ? source : "",
+    // TODO
+    components: [],
+    directives: [],
+    helpers: /* @__PURE__ */ new Set(),
+    temps: 0
+  };
+  const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(prefixIdentifiers);
+  const ir = transform(
+    ast,
+    extend5({}, resolvedOptions, {
+      nodeTransforms: [
+        ...nodeTransforms,
+        ...options.nodeTransforms || []
+        // user transforms
+      ],
+      directiveTransforms: extend5(
+        {},
+        directiveTransforms,
+        options.directiveTransforms || {}
+        // user transforms
+      )
+    })
+  );
+  return generate(ir, resolvedOptions);
+}
+function getBaseTransformPreset(prefixIdentifiers) {
+  return [
+    [
+      transformTemplateRef,
+      transformText,
+      transformElement,
+      transformVSlot,
+      transformChildren
+    ],
+    {
+      bind: transformVBind,
+      on: transformVOn,
+      model: transformVModel,
+      show: transformVShow,
+      html: transformVHtml
+    }
+  ];
+}
+export {
+  DynamicFlag2 as DynamicFlag,
+  IRDynamicPropsKind,
+  IRNodeTypes,
+  IRSlotType,
+  TransformContext,
+  compile,
+  generate2 as generate,
+  resolveDirectiveNode,
+  resolveNode,
+  transform,
+  transformChildren,
+  transformElement,
+  transformNode,
+  transformTemplateRef,
+  transformText,
+  transformVBind,
+  transformVHtml,
+  transformVModel,
+  transformVOn,
+  transformVShow,
+  transformVSlot
+};