@vue/compiler-vapor 0.0.0

package/dist/compiler-vapor.cjs.js

@@ -0,0 +1,3751 @@
+/**
+* @vue/compiler-vapor v3.5.13
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var compilerDom = require('@vue/compiler-dom');
+var shared = require('@vue/shared');
+var sourceMapJs = require('source-map-js');
+var estreeWalker = require('estree-walker');
+var parser = require('@babel/parser');
+
+const newDynamic = () => ({
+  flags: 1,
+  children: []
+});
+const newBlock = (node) => ({
+  type: 1,
+  node,
+  dynamic: newDynamic(),
+  effect: [],
+  operation: [],
+  returns: [],
+  expressions: []
+});
+function wrapTemplate(node, dirs) {
+  if (node.tagType === 3) {
+    return node;
+  }
+  const reserved = [];
+  const pass = [];
+  node.props.forEach((prop) => {
+    if (prop.type === 7 && dirs.includes(prop.name)) {
+      reserved.push(prop);
+    } else {
+      pass.push(prop);
+    }
+  });
+  return shared.extend({}, node, {
+    type: 1,
+    tag: "template",
+    props: reserved,
+    tagType: 3,
+    children: [shared.extend({}, node, { props: pass })]
+  });
+}
+const EMPTY_EXPRESSION = compilerDom.createSimpleExpression(
+  "",
+  true
+);
+
+const findProp = compilerDom.findProp;
+const findDir = compilerDom.findDir;
+function propToExpression(prop) {
+  return prop.type === 6 ? prop.value ? compilerDom.createSimpleExpression(prop.value.content, true, prop.value.loc) : EMPTY_EXPRESSION : prop.exp;
+}
+function isConstantExpression(exp) {
+  return compilerDom.isLiteralWhitelisted(exp.content) || shared.isGloballyAllowed(exp.content) || getLiteralExpressionValue(exp) !== null;
+}
+function resolveExpression(exp) {
+  if (!exp.isStatic) {
+    const value = getLiteralExpressionValue(exp);
+    if (value !== null) {
+      return compilerDom.createSimpleExpression("" + value, true, exp.loc);
+    }
+  }
+  return exp;
+}
+function getLiteralExpressionValue(exp) {
+  if (exp.ast) {
+    if (exp.ast.type === "StringLiteral") {
+      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;
+}
+
+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 = shared.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 !== undefined) return this.dynamic.id;
+    this.dynamic.flags |= 1;
+    return this.dynamic.id = this.increaseId();
+  }
+  pushTemplate(content) {
+    const existing = this.ir.template.findIndex(
+      (template) => template === 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 || isStaticExpression(this.root, expressions)) {
+      return this.registerOperation(...operations);
+    }
+    this.block.expressions.push(...expressions);
+    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()
+    });
+  }
+}
+const defaultOptions = {
+  filename: "",
+  prefixIdentifiers: true,
+  hoistStatic: false,
+  hmr: false,
+  cacheHandlers: false,
+  nodeTransforms: [],
+  directiveTransforms: {},
+  transformHoist: null,
+  isBuiltInComponent: shared.NOOP,
+  isCustomElement: shared.NOOP,
+  expressionPlugins: [],
+  scopeId: null,
+  slotted: true,
+  ssr: false,
+  inSSR: false,
+  ssrCssVars: ``,
+  bindingMetadata: shared.EMPTY_OBJ,
+  inline: false,
+  isTS: false,
+  onError: compilerDom.defaultOnError,
+  onWarn: compilerDom.defaultOnWarn
+};
+function transform(node, options = {}) {
+  const ir = {
+    type: 0,
+    node,
+    source: node.source,
+    template: [],
+    component: /* @__PURE__ */ new Set(),
+    directive: /* @__PURE__ */ new Set(),
+    block: newBlock(node),
+    hasTemplateRef: false
+  };
+  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 (shared.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) {
+    context.registerTemplate();
+  }
+}
+function createStructuralDirectiveTransform(name, fn) {
+  const matches = (n) => shared.isString(name) ? n === name : name.includes(n);
+  return (node, context) => {
+    if (node.type === 1) {
+      const { props } = node;
+      if (node.tagType === 3 && props.some(compilerDom.isVSlot)) {
+        return;
+      }
+      const exitFns = [];
+      for (const prop of props) {
+        if (prop.type === 7 && matches(prop.name)) {
+          const onExit = fn(
+            node,
+            prop,
+            context
+          );
+          if (onExit) exitFns.push(onExit);
+        }
+      }
+      return exitFns;
+    }
+  };
+}
+function isStaticExpression(context, expressions) {
+  const {
+    options: { bindingMetadata }
+  } = context;
+  const isLiteralConst = (name) => bindingMetadata[name] === "literal-const";
+  return expressions.every((node) => {
+    if (node.ast) {
+      return compilerDom.isConstantNode(node.ast, isLiteralConst);
+    } else if (node.ast === null) {
+      return isLiteralConst(node.content);
+    }
+  });
+}
+
+const NEWLINE = Symbol(`newline` );
+const LF = Symbol(`line feed` );
+const INDENT_START = Symbol(`indent start` );
+const INDENT_END = Symbol(`indent end` );
+function buildCodeFragment(...frag) {
+  const push = frag.push.bind(frag);
+  const unshift = frag.unshift.bind(frag);
+  return [frag, push, unshift];
+}
+function genMulti([left, right, seg, placeholder], ...frags) {
+  if (placeholder) {
+    while (frags.length > 0 && !frags[frags.length - 1]) {
+      frags.pop();
+    }
+    frags = frags.map((frag2) => frag2 || placeholder);
+  } else {
+    frags = frags.filter(Boolean);
+  }
+  const frag = [];
+  push(left);
+  for (let [i, fn] of frags.entries()) {
+    push(fn);
+    if (i < frags.length - 1) push(seg);
+  }
+  push(right);
+  return frag;
+  function push(fn) {
+    if (!shared.isArray(fn)) fn = [fn];
+    frag.push(...fn);
+  }
+}
+const DELIMITERS_ARRAY = ["[", "]", ", "];
+const DELIMITERS_ARRAY_NEWLINE = [
+  ["[", INDENT_START, NEWLINE],
+  [INDENT_END, NEWLINE, "]"],
+  [", ", NEWLINE]
+];
+const DELIMITERS_OBJECT = ["{ ", " }", ", "];
+const DELIMITERS_OBJECT_NEWLINE = [
+  ["{", INDENT_START, NEWLINE],
+  [INDENT_END, NEWLINE, "}"],
+  [", ", NEWLINE]
+];
+function genCall(name, ...frags) {
+  const hasPlaceholder = shared.isArray(name);
+  const fnName = hasPlaceholder ? name[0] : name;
+  const placeholder = hasPlaceholder ? name[1] : "null";
+  return [fnName, ...genMulti(["(", ")", ", ", placeholder], ...frags)];
+}
+function codeFragmentToString(code, context) {
+  const {
+    options: { filename, sourceMap }
+  } = context;
+  let map;
+  if (sourceMap) {
+    map = new sourceMapJs.SourceMapGenerator();
+    map.setSourceContent(filename, context.ir.source);
+    map._sources.add(filename);
+  }
+  let codegen = "";
+  const pos = { line: 1, column: 1, offset: 0 };
+  let indentLevel = 0;
+  for (let frag of code) {
+    if (!frag) continue;
+    if (frag === NEWLINE) {
+      frag = [`
+${`  `.repeat(indentLevel)}`, 0];
+    } else if (frag === INDENT_START) {
+      indentLevel++;
+      continue;
+    } else if (frag === INDENT_END) {
+      indentLevel--;
+      continue;
+    } else if (frag === LF) {
+      pos.line++;
+      pos.column = 0;
+      pos.offset++;
+      continue;
+    }
+    if (shared.isString(frag)) frag = [frag];
+    let [code2, newlineIndex = -2, loc, name] = frag;
+    codegen += code2;
+    if (map) {
+      if (loc) addMapping(loc.start, name);
+      if (newlineIndex === -3) {
+        compilerDom.advancePositionWithMutation(pos, code2);
+      } else {
+        pos.offset += code2.length;
+        if (newlineIndex === -2) {
+          pos.column += code2.length;
+        } else {
+          if (newlineIndex === -1) {
+            newlineIndex = code2.length - 1;
+          }
+          pos.line++;
+          pos.column = code2.length - newlineIndex;
+        }
+      }
+      if (loc && loc !== compilerDom.locStub) {
+        addMapping(loc.end);
+      }
+    }
+  }
+  return [codegen, map];
+  function addMapping(loc, name = null) {
+    const { _names, _mappings } = map;
+    if (name !== null && !_names.has(name)) _names.add(name);
+    _mappings.add({
+      originalLine: loc.line,
+      originalColumn: loc.column - 1,
+      // source-map column is 0 based
+      generatedLine: pos.line,
+      generatedColumn: pos.column - 1,
+      source: filename,
+      name
+    });
+  }
+}
+
+function genInsertNode({ parent, elements, anchor }, { helper }) {
+  let element = elements.map((el) => `n${el}`).join(", ");
+  if (elements.length > 1) element = `[${element}]`;
+  return [
+    NEWLINE,
+    ...genCall(
+      helper("insert"),
+      element,
+      `n${parent}`,
+      anchor === undefined ? undefined : `n${anchor}`
+    )
+  ];
+}
+function genPrependNode(oper, { helper }) {
+  return [
+    NEWLINE,
+    ...genCall(
+      helper("prepend"),
+      `n${oper.parent}`,
+      ...oper.elements.map((el) => `n${el}`)
+    )
+  ];
+}
+
+function genExpression(node, context, assignment) {
+  const { content, ast, isStatic, loc } = node;
+  if (isStatic) {
+    return [[JSON.stringify(content), -2, loc]];
+  }
+  if (!node.content.trim() || // there was a parsing error
+  ast === false || isConstantExpression(node)) {
+    return [[content, -2, loc], assignment && ` = ${assignment}`];
+  }
+  if (ast === null) {
+    return genIdentifier(content, context, loc, assignment);
+  }
+  const ids = [];
+  const parentStackMap = /* @__PURE__ */ new Map();
+  const parentStack = [];
+  compilerDom.walkIdentifiers(
+    ast,
+    (id) => {
+      ids.push(id);
+      parentStackMap.set(id, parentStack.slice());
+    },
+    false,
+    parentStack
+  );
+  let hasMemberExpression = false;
+  if (ids.length) {
+    const [frag, push] = buildCodeFragment();
+    ids.sort((a, b) => a.start - b.start).forEach((id, i) => {
+      const start = id.start - 1;
+      const end = id.end - 1;
+      const last = ids[i - 1];
+      const leadingText = content.slice(last ? last.end - 1 : 0, start);
+      if (leadingText.length) push([leadingText, -3]);
+      const source = content.slice(start, end);
+      const parentStack2 = parentStackMap.get(id);
+      const parent = parentStack2[parentStack2.length - 1];
+      hasMemberExpression || (hasMemberExpression = parent && (parent.type === "MemberExpression" || parent.type === "OptionalMemberExpression"));
+      push(
+        ...genIdentifier(
+          source,
+          context,
+          {
+            start: compilerDom.advancePositionWithClone(node.loc.start, source, start),
+            end: compilerDom.advancePositionWithClone(node.loc.start, source, end),
+            source
+          },
+          hasMemberExpression ? undefined : assignment,
+          id,
+          parent,
+          parentStack2
+        )
+      );
+      if (i === ids.length - 1 && end < content.length) {
+        push([content.slice(end), -3]);
+      }
+    });
+    if (assignment && hasMemberExpression) {
+      push(` = ${assignment}`);
+    }
+    return frag;
+  } else {
+    return [[content, -3, loc]];
+  }
+}
+function genIdentifier(raw, context, loc, assignment, id, parent, parentStack) {
+  const { options, helper, identifiers } = context;
+  const { inline, bindingMetadata } = options;
+  let name = raw;
+  const idMap = identifiers[raw];
+  if (idMap && idMap.length) {
+    const replacement = idMap[0];
+    if (shared.isString(replacement)) {
+      return [[replacement, -2, loc]];
+    } else {
+      return genExpression(replacement, context, assignment);
+    }
+  }
+  let prefix;
+  if (compilerDom.isStaticProperty(parent) && parent.shorthand) {
+    prefix = `${raw}: `;
+  }
+  const type = bindingMetadata && bindingMetadata[raw];
+  if (inline) {
+    switch (type) {
+      case "setup-let":
+        name = raw = assignment ? `_isRef(${raw}) ? (${raw}.value = ${assignment}) : (${raw} = ${assignment})` : unref();
+        break;
+      case "setup-ref":
+        name = raw = withAssignment(`${raw}.value`);
+        break;
+      case "setup-maybe-ref":
+        const isDestructureAssignment = parent && compilerDom.isInDestructureAssignment(parent, parentStack || []);
+        const isAssignmentLVal = parent && parent.type === "AssignmentExpression" && parent.left === id;
+        const isUpdateArg = parent && parent.type === "UpdateExpression" && parent.argument === id;
+        raw = isAssignmentLVal || isUpdateArg || isDestructureAssignment ? name = `${raw}.value` : assignment ? `${helper("isRef")}(${raw}) ? (${raw}.value = ${assignment}) : null` : unref();
+        break;
+      case "props":
+        raw = shared.genPropsAccessExp(raw);
+        break;
+      case "props-aliased":
+        raw = shared.genPropsAccessExp(bindingMetadata.__propsAliases[raw]);
+        break;
+      default:
+        raw = withAssignment(raw);
+    }
+  } else {
+    if (canPrefix(raw)) {
+      if (type === "props-aliased") {
+        raw = `$props['${bindingMetadata.__propsAliases[raw]}']`;
+      } else {
+        raw = `${type === "props" ? "$props" : "_ctx"}.${raw}`;
+      }
+    }
+    raw = withAssignment(raw);
+  }
+  return [prefix, [raw, -2, loc, name]];
+  function withAssignment(s) {
+    return assignment ? `${s} = ${assignment}` : s;
+  }
+  function unref() {
+    return `${helper("unref")}(${raw})`;
+  }
+}
+function canPrefix(name) {
+  if (shared.isGloballyAllowed(name)) {
+    return false;
+  }
+  if (
+    // special case for webpack compilation
+    name === "require" || name === "$props" || name === "$emit" || name === "$attrs" || name === "$slots"
+  )
+    return false;
+  return true;
+}
+function processExpressions(context, expressions) {
+  const { seenVariable, variableToExpMap, expToVariableMap, seenIdentifier } = analyzeExpressions(expressions);
+  const varDeclarations = processRepeatedVariables(
+    context,
+    seenVariable,
+    variableToExpMap,
+    expToVariableMap,
+    seenIdentifier
+  );
+  const expDeclarations = processRepeatedExpressions(
+    context,
+    expressions,
+    varDeclarations
+  );
+  return genDeclarations([...varDeclarations, ...expDeclarations], context);
+}
+function analyzeExpressions(expressions) {
+  const seenVariable = /* @__PURE__ */ Object.create(null);
+  const variableToExpMap = /* @__PURE__ */ new Map();
+  const expToVariableMap = /* @__PURE__ */ new Map();
+  const seenIdentifier = /* @__PURE__ */ new Set();
+  const registerVariable = (name, exp, isIdentifier) => {
+    if (isIdentifier) seenIdentifier.add(name);
+    seenVariable[name] = (seenVariable[name] || 0) + 1;
+    variableToExpMap.set(
+      name,
+      (variableToExpMap.get(name) || /* @__PURE__ */ new Set()).add(exp)
+    );
+    expToVariableMap.set(exp, (expToVariableMap.get(exp) || []).concat(name));
+  };
+  for (const exp of expressions) {
+    if (!exp.ast) {
+      exp.ast === null && registerVariable(exp.content, exp, true);
+      continue;
+    }
+    estreeWalker.walk(exp.ast, {
+      enter(currentNode) {
+        if (currentNode.type === "MemberExpression") {
+          const memberExp = extractMemberExpression(
+            currentNode,
+            (name) => {
+              registerVariable(name, exp, true);
+            }
+          );
+          registerVariable(memberExp, exp, false);
+          return this.skip();
+        }
+        if (currentNode.type === "Identifier") {
+          registerVariable(currentNode.name, exp, true);
+        }
+      }
+    });
+  }
+  return { seenVariable, seenIdentifier, variableToExpMap, expToVariableMap };
+}
+function processRepeatedVariables(context, seenVariable, variableToExpMap, expToVariableMap, seenIdentifier) {
+  const declarations = [];
+  for (const [name, exps] of variableToExpMap) {
+    if (seenVariable[name] > 1 && exps.size > 0) {
+      const isIdentifier = seenIdentifier.has(name);
+      const varName = isIdentifier ? name : genVarName(name);
+      const replaceRE = new RegExp(escapeRegExp(name), "g");
+      exps.forEach((node) => {
+        if (node.ast) {
+          node.content = node.content.replace(replaceRE, varName);
+          node.ast = parseExp(context, node.content);
+        }
+      });
+      if (!declarations.some((d) => d.name === varName) && (!isIdentifier || shouldDeclareVariable(name, expToVariableMap, exps))) {
+        declarations.push({
+          name: varName,
+          isIdentifier,
+          value: shared.extend(
+            { ast: isIdentifier ? null : parseExp(context, name) },
+            compilerDom.createSimpleExpression(name)
+          ),
+          rawName: name,
+          exps,
+          seenCount: seenVariable[name]
+        });
+      }
+    }
+  }
+  return declarations;
+}
+function shouldDeclareVariable(name, expToVariableMap, exps) {
+  const vars = Array.from(exps, (exp) => expToVariableMap.get(exp));
+  if (vars.every((v) => v.length === 1)) {
+    return true;
+  }
+  if (vars.some((v) => v.filter((e) => e === name).length > 1)) {
+    return true;
+  }
+  const first = vars[0];
+  if (vars.some((v) => v.length !== first.length)) {
+    if (vars.some(
+      (v) => v.length > first.length && v.every((e) => first.includes(e))
+    ) || vars.some((v) => first.length > v.length && first.every((e) => v.includes(e)))) {
+      return false;
+    }
+    return true;
+  }
+  if (vars.some((v) => v.some((e) => first.includes(e)))) {
+    return false;
+  }
+  return true;
+}
+function processRepeatedExpressions(context, expressions, varDeclarations) {
+  const declarations = [];
+  const seenExp = expressions.reduce(
+    (acc, exp) => {
+      if (exp.ast && exp.ast.type !== "Identifier") {
+        acc[exp.content] = (acc[exp.content] || 0) + 1;
+      }
+      return acc;
+    },
+    /* @__PURE__ */ Object.create(null)
+  );
+  Object.entries(seenExp).forEach(([content, count]) => {
+    if (count > 1) {
+      const varName = genVarName(content);
+      if (!declarations.some((d) => d.name === varName)) {
+        const delVars = {};
+        for (let i = varDeclarations.length - 1; i >= 0; i--) {
+          const item = varDeclarations[i];
+          if (!item.exps || !item.seenCount) continue;
+          const shouldRemove = [...item.exps].every(
+            (node) => node.content === content && item.seenCount === count
+          );
+          if (shouldRemove) {
+            delVars[item.name] = item.rawName;
+            varDeclarations.splice(i, 1);
+          }
+        }
+        const value = shared.extend(
+          {},
+          expressions.find((exp) => exp.content === content)
+        );
+        Object.keys(delVars).forEach((name) => {
+          value.content = value.content.replace(name, delVars[name]);
+          if (value.ast) value.ast = parseExp(context, value.content);
+        });
+        declarations.push({
+          name: varName,
+          value
+        });
+      }
+      expressions.forEach((exp) => {
+        if (exp.content === content) {
+          exp.content = varName;
+          exp.ast = null;
+        } else if (exp.content.includes(content)) {
+          exp.content = exp.content.replace(
+            new RegExp(escapeRegExp(content), "g"),
+            varName
+          );
+          exp.ast = parseExp(context, exp.content);
+        }
+      });
+    }
+  });
+  return declarations;
+}
+function genDeclarations(declarations, context) {
+  const [frag, push] = buildCodeFragment();
+  const ids = /* @__PURE__ */ Object.create(null);
+  declarations.forEach(({ name, isIdentifier, value }) => {
+    if (isIdentifier) {
+      const varName = ids[name] = `_${name}`;
+      push(`const ${varName} = `, ...genExpression(value, context), NEWLINE);
+    }
+  });
+  declarations.forEach(({ name, isIdentifier, value }) => {
+    if (!isIdentifier) {
+      const varName = ids[name] = `_${name}`;
+      push(
+        `const ${varName} = `,
+        ...context.withId(() => genExpression(value, context), ids),
+        NEWLINE
+      );
+    }
+  });
+  return { ids, frag };
+}
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseExp(context, content) {
+  const plugins = context.options.expressionPlugins;
+  const options = {
+    plugins: plugins ? [...plugins, "typescript"] : ["typescript"]
+  };
+  return parser.parseExpression(`(${content})`, options);
+}
+function genVarName(exp) {
+  return `${exp.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/_+$/, "")}`;
+}
+function extractMemberExpression(exp, onIdentifier) {
+  if (!exp) return "";
+  switch (exp.type) {
+    case "Identifier":
+      onIdentifier(exp.name);
+      return exp.name;
+    case "StringLiteral":
+      return exp.extra ? exp.extra.raw : exp.value;
+    case "NumericLiteral":
+      return exp.value.toString();
+    case "BinaryExpression":
+      return `${extractMemberExpression(exp.left, onIdentifier)} ${exp.operator} ${extractMemberExpression(exp.right, onIdentifier)}`;
+    case "CallExpression":
+      return `${extractMemberExpression(exp.callee, onIdentifier)}(${exp.arguments.map((arg) => extractMemberExpression(arg, onIdentifier)).join(", ")})`;
+    case "MemberExpression":
+      const object = extractMemberExpression(exp.object, onIdentifier);
+      const prop = exp.computed ? `[${extractMemberExpression(exp.property, onIdentifier)}]` : `.${extractMemberExpression(exp.property, shared.NOOP)}`;
+      return `${object}${prop}`;
+    default:
+      return "";
+  }
+}
+
+function genSetEvent(oper, context) {
+  const { helper } = context;
+  const { element, key, keyOverride, value, modifiers, delegate, effect } = oper;
+  const name = genName();
+  const handler = genEventHandler(context, value, modifiers);
+  const eventOptions = genEventOptions();
+  if (delegate) {
+    context.delegates.add(key.content);
+  }
+  return [
+    NEWLINE,
+    ...genCall(
+      helper(delegate ? "delegate" : "on"),
+      `n${element}`,
+      name,
+      handler,
+      eventOptions
+    )
+  ];
+  function genName() {
+    const expr = genExpression(key, context);
+    if (keyOverride) {
+      const find = JSON.stringify(keyOverride[0]);
+      const replacement = JSON.stringify(keyOverride[1]);
+      const wrapped = ["(", ...expr, ")"];
+      return [...wrapped, ` === ${find} ? ${replacement} : `, ...wrapped];
+    } else {
+      return genExpression(key, context);
+    }
+  }
+  function genEventOptions() {
+    let { options } = modifiers;
+    if (!options.length && !effect) return;
+    return genMulti(
+      DELIMITERS_OBJECT_NEWLINE,
+      effect && ["effect: true"],
+      ...options.map((option) => [`${option}: true`])
+    );
+  }
+}
+function genSetDynamicEvents(oper, context) {
+  const { helper } = context;
+  return [
+    NEWLINE,
+    ...genCall(
+      helper("setDynamicEvents"),
+      `n${oper.element}`,
+      genExpression(oper.event, context)
+    )
+  ];
+}
+function genEventHandler(context, value, modifiers = { nonKeys: [], keys: [] }, needWrap = true) {
+  let handlerExp = [`() => {}`];
+  if (value && value.content.trim()) {
+    const isMemberExp = compilerDom.isMemberExpression(value, context.options);
+    const isInlineStatement = !(isMemberExp || compilerDom.isFnExpression(value, context.options));
+    if (isInlineStatement) {
+      const expr = context.withId(() => genExpression(value, context), {
+        $event: null
+      });
+      const hasMultipleStatements = value.content.includes(`;`);
+      handlerExp = [
+        "$event => ",
+        hasMultipleStatements ? "{" : "(",
+        ...expr,
+        hasMultipleStatements ? "}" : ")"
+      ];
+    } else {
+      handlerExp = [...genExpression(value, context)];
+    }
+  }
+  const { keys, nonKeys } = modifiers;
+  if (nonKeys.length)
+    handlerExp = genWithModifiers(context, handlerExp, nonKeys);
+  if (keys.length) handlerExp = genWithKeys(context, handlerExp, keys);
+  if (needWrap) handlerExp.unshift(`() => `);
+  return handlerExp;
+}
+function genWithModifiers(context, handler, nonKeys) {
+  return genCall(
+    context.helper("withModifiers"),
+    handler,
+    JSON.stringify(nonKeys)
+  );
+}
+function genWithKeys(context, handler, keys) {
+  return genCall(context.helper("withKeys"), handler, JSON.stringify(keys));
+}
+
+function genFor(oper, context) {
+  const { helper } = context;
+  const { source, value, key, index, render, keyProp, once, id, component } = oper;
+  let rawValue = null;
+  const rawKey = key && key.content;
+  const rawIndex = index && index.content;
+  const sourceExpr = ["() => (", ...genExpression(source, context), ")"];
+  const idToPathMap = parseValueDestructure();
+  const [depth, exitScope] = context.enterScope();
+  const idMap = {};
+  const itemVar = `_for_item${depth}`;
+  idMap[itemVar] = null;
+  idToPathMap.forEach((pathInfo, id2) => {
+    let path = `${itemVar}.value${pathInfo ? pathInfo.path : ""}`;
+    if (pathInfo) {
+      if (pathInfo.helper) {
+        idMap[pathInfo.helper] = null;
+        path = `${pathInfo.helper}(${path}, ${pathInfo.helperArgs})`;
+      }
+      if (pathInfo.dynamic) {
+        const node = idMap[id2] = compilerDom.createSimpleExpression(path);
+        const plugins = context.options.expressionPlugins;
+        node.ast = parser.parseExpression(`(${path})`, {
+          plugins: plugins ? [...plugins, "typescript"] : ["typescript"]
+        });
+      } else {
+        idMap[id2] = path;
+      }
+    } else {
+      idMap[id2] = path;
+    }
+  });
+  const args = [itemVar];
+  if (rawKey) {
+    const keyVar = `_for_key${depth}`;
+    args.push(`, ${keyVar}`);
+    idMap[rawKey] = `${keyVar}.value`;
+    idMap[keyVar] = null;
+  }
+  if (rawIndex) {
+    const indexVar = `_for_index${depth}`;
+    args.push(`, ${indexVar}`);
+    idMap[rawIndex] = `${indexVar}.value`;
+    idMap[indexVar] = null;
+  }
+  const blockFn = context.withId(() => genBlock(render, context, args), idMap);
+  exitScope();
+  return [
+    NEWLINE,
+    `const n${id} = `,
+    ...genCall(
+      helper("createFor"),
+      sourceExpr,
+      blockFn,
+      genCallback(keyProp),
+      component && "true",
+      once && "true"
+      // todo: hydrationNode
+    )
+  ];
+  function parseValueDestructure() {
+    const map = /* @__PURE__ */ new Map();
+    if (value) {
+      rawValue = value && value.content;
+      if (value.ast) {
+        compilerDom.walkIdentifiers(
+          value.ast,
+          (id2, _, parentStack, ___, isLocal) => {
+            if (isLocal) {
+              let path = "";
+              let isDynamic = false;
+              let helper2;
+              let helperArgs;
+              for (let i = 0; i < parentStack.length; i++) {
+                const parent = parentStack[i];
+                const child = parentStack[i + 1] || id2;
+                if (parent.type === "ObjectProperty" && parent.value === child) {
+                  if (parent.key.type === "StringLiteral") {
+                    path += `[${JSON.stringify(parent.key.value)}]`;
+                  } else if (parent.computed) {
+                    isDynamic = true;
+                    path += `[${value.content.slice(
+                      parent.key.start - 1,
+                      parent.key.end - 1
+                    )}]`;
+                  } else {
+                    path += `.${parent.key.name}`;
+                  }
+                } else if (parent.type === "ArrayPattern") {
+                  const index2 = parent.elements.indexOf(child);
+                  if (child.type === "RestElement") {
+                    path += `.slice(${index2})`;
+                  } else {
+                    path += `[${index2}]`;
+                  }
+                } else if (parent.type === "ObjectPattern" && child.type === "RestElement") {
+                  helper2 = context.helper("getRestElement");
+                  helperArgs = "[" + parent.properties.filter((p) => p.type === "ObjectProperty").map((p) => {
+                    if (p.key.type === "StringLiteral") {
+                      return JSON.stringify(p.key.value);
+                    } else if (p.computed) {
+                      isDynamic = true;
+                      return value.content.slice(
+                        p.key.start - 1,
+                        p.key.end - 1
+                      );
+                    } else {
+                      return JSON.stringify(p.key.name);
+                    }
+                  }).join(", ") + "]";
+                }
+                if (child.type === "AssignmentPattern" && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) {
+                  isDynamic = true;
+                  helper2 = context.helper("getDefaultValue");
+                  helperArgs = value.content.slice(
+                    child.right.start - 1,
+                    child.right.end - 1
+                  );
+                }
+              }
+              map.set(id2.name, { path, dynamic: isDynamic, helper: helper2, helperArgs });
+            }
+          },
+          true
+        );
+      } else {
+        map.set(rawValue, null);
+      }
+    }
+    return map;
+  }
+  function genCallback(expr) {
+    if (!expr) return false;
+    const res = context.withId(
+      () => genExpression(expr, context),
+      genSimpleIdMap()
+    );
+    return [
+      ...genMulti(
+        ["(", ")", ", "],
+        rawValue ? rawValue : rawKey || rawIndex ? "_" : undefined,
+        rawKey ? rawKey : rawIndex ? "__" : undefined,
+        rawIndex
+      ),
+      " => (",
+      ...res,
+      ")"
+    ];
+  }
+  function genSimpleIdMap() {
+    const idMap2 = {};
+    if (rawKey) idMap2[rawKey] = null;
+    if (rawIndex) idMap2[rawIndex] = null;
+    idToPathMap.forEach((_, id2) => idMap2[id2] = null);
+    return idMap2;
+  }
+}
+
+function genSetHtml(oper, context) {
+  const { helper } = context;
+  const { value, element } = oper;
+  return [
+    NEWLINE,
+    ...genCall(helper("setHtml"), `n${element}`, genExpression(value, context))
+  ];
+}
+
+function genIf(oper, context, isNested = false) {
+  const { helper } = context;
+  const { condition, positive, negative, once } = oper;
+  const [frag, push] = buildCodeFragment();
+  const conditionExpr = [
+    "() => (",
+    ...genExpression(condition, context),
+    ")"
+  ];
+  let positiveArg = genBlock(positive, context);
+  let negativeArg = false;
+  if (negative) {
+    if (negative.type === 1) {
+      negativeArg = genBlock(negative, context);
+    } else {
+      negativeArg = ["() => ", ...genIf(negative, context, true)];
+    }
+  }
+  if (!isNested) push(NEWLINE, `const n${oper.id} = `);
+  push(
+    ...genCall(
+      helper("createIf"),
+      conditionExpr,
+      positiveArg,
+      negativeArg,
+      once && "true"
+    )
+  );
+  return frag;
+}
+
+const locStub = {
+  start: { line: 1, column: 1, offset: 0 },
+  end: { line: 1, column: 1, offset: 0 },
+  source: ""
+};
+function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) {
+  return {
+    type: 4,
+    loc,
+    content,
+    isStatic,
+    constType: isStatic ? 3 : constType
+  };
+}
+
+function createCompilerError(code, loc, messages, additionalMessage) {
+  const msg = (errorMessages)[code] + (``) ;
+  const error = new SyntaxError(String(msg));
+  error.code = code;
+  error.loc = loc;
+  return error;
+}
+const errorMessages = {
+  // parse errors
+  [0]: "Illegal comment.",
+  [1]: "CDATA section is allowed only in XML context.",
+  [2]: "Duplicate attribute.",
+  [3]: "End tag cannot have attributes.",
+  [4]: "Illegal '/' in tags.",
+  [5]: "Unexpected EOF in tag.",
+  [6]: "Unexpected EOF in CDATA section.",
+  [7]: "Unexpected EOF in comment.",
+  [8]: "Unexpected EOF in script.",
+  [9]: "Unexpected EOF in tag.",
+  [10]: "Incorrectly closed comment.",
+  [11]: "Incorrectly opened comment.",
+  [12]: "Illegal tag name. Use '&lt;' to print '<'.",
+  [13]: "Attribute value was expected.",
+  [14]: "End tag name was expected.",
+  [15]: "Whitespace was expected.",
+  [16]: "Unexpected '<!--' in comment.",
+  [17]: `Attribute name cannot contain U+0022 ("), U+0027 ('), and U+003C (<).`,
+  [18]: "Unquoted attribute value cannot contain U+0022 (\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).",
+  [19]: "Attribute name cannot start with '='.",
+  [21]: "'<?' is allowed only in XML context.",
+  [20]: `Unexpected null character.`,
+  [22]: "Illegal '/' in tags.",
+  // Vue-specific parse errors
+  [23]: "Invalid end tag.",
+  [24]: "Element is missing end tag.",
+  [25]: "Interpolation end sign was not found.",
+  [27]: "End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.",
+  [26]: "Legal directive name was expected.",
+  // transform errors
+  [28]: `v-if/v-else-if is missing expression.`,
+  [29]: `v-if/else branches must use unique keys.`,
+  [30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,
+  [31]: `v-for is missing expression.`,
+  [32]: `v-for has invalid expression.`,
+  [33]: `<template v-for> key should be placed on the <template> tag.`,
+  [34]: `v-bind is missing expression.`,
+  [52]: `v-bind with same-name shorthand only allows static argument.`,
+  [35]: `v-on is missing expression.`,
+  [36]: `Unexpected custom directive on <slot> outlet.`,
+  [37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`,
+  [38]: `Duplicate slot names found. `,
+  [39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`,
+  [40]: `v-slot can only be used on components or <template> tags.`,
+  [41]: `v-model is missing expression.`,
+  [42]: `v-model value must be a valid JavaScript member expression.`,
+  [43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,
+  [44]: `v-model cannot be used on a prop, because local prop bindings are not writable.
+Use a v-bind binding combined with a v-on listener that emits update:x event instead.`,
+  [45]: `Error parsing JavaScript expression: `,
+  [46]: `<KeepAlive> expects exactly one child component.`,
+  [51]: `@vnode-* hooks in templates are no longer supported. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support has been removed in 3.4.`,
+  // generic errors
+  [47]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
+  [48]: `ES module mode is not supported in this build of compiler.`,
+  [49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
+  [50]: `"scopeId" option is only supported in module mode.`,
+  // just to fulfill types
+  [53]: ``
+};
+
+function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */ Object.create(null)) {
+  const rootExp = root.type === "Program" ? root.body[0].type === "ExpressionStatement" && root.body[0].expression : root;
+  estreeWalker.walk(root, {
+    enter(node, parent) {
+      parent && parentStack.push(parent);
+      if (parent && parent.type.startsWith("TS") && !TS_NODE_TYPES.includes(parent.type)) {
+        return this.skip();
+      }
+      if (node.type === "Identifier") {
+        const isLocal = !!knownIds[node.name];
+        const isRefed = isReferencedIdentifier(node, parent, parentStack);
+        if (includeAll || isRefed && !isLocal) {
+          onIdentifier(node, parent, parentStack, isRefed, isLocal);
+        }
+      } else if (node.type === "ObjectProperty" && // eslint-disable-next-line no-restricted-syntax
+      (parent == null ? undefined : parent.type) === "ObjectPattern") {
+        node.inPattern = true;
+      } else if (isFunctionType(node)) {
+        if (node.scopeIds) {
+          node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
+        } else {
+          walkFunctionParams(
+            node,
+            (id) => markScopeIdentifier(node, id, knownIds)
+          );
+        }
+      } else if (node.type === "BlockStatement") {
+        if (node.scopeIds) {
+          node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
+        } else {
+          walkBlockDeclarations(
+            node,
+            (id) => markScopeIdentifier(node, id, knownIds)
+          );
+        }
+      } else if (node.type === "CatchClause" && node.param) {
+        for (const id of extractIdentifiers(node.param)) {
+          markScopeIdentifier(node, id, knownIds);
+        }
+      } else if (isForStatement(node)) {
+        walkForStatement(
+          node,
+          false,
+          (id) => markScopeIdentifier(node, id, knownIds)
+        );
+      }
+    },
+    leave(node, parent) {
+      parent && parentStack.pop();
+      if (node !== rootExp && node.scopeIds) {
+        for (const id of node.scopeIds) {
+          knownIds[id]--;
+          if (knownIds[id] === 0) {
+            delete knownIds[id];
+          }
+        }
+      }
+    }
+  });
+}
+function isReferencedIdentifier(id, parent, parentStack) {
+  if (!parent) {
+    return true;
+  }
+  if (id.name === "arguments") {
+    return false;
+  }
+  if (isReferenced(id, parent)) {
+    return true;
+  }
+  switch (parent.type) {
+    case "AssignmentExpression":
+    case "AssignmentPattern":
+      return true;
+    case "ObjectPattern":
+    case "ArrayPattern":
+      return isInDestructureAssignment(parent, parentStack);
+  }
+  return false;
+}
+function isInDestructureAssignment(parent, parentStack) {
+  if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) {
+    let i = parentStack.length;
+    while (i--) {
+      const p = parentStack[i];
+      if (p.type === "AssignmentExpression") {
+        return true;
+      } else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) {
+        break;
+      }
+    }
+  }
+  return false;
+}
+function walkFunctionParams(node, onIdent) {
+  for (const p of node.params) {
+    for (const id of extractIdentifiers(p)) {
+      onIdent(id);
+    }
+  }
+}
+function walkBlockDeclarations(block, onIdent) {
+  for (const stmt of block.body) {
+    if (stmt.type === "VariableDeclaration") {
+      if (stmt.declare) continue;
+      for (const decl of stmt.declarations) {
+        for (const id of extractIdentifiers(decl.id)) {
+          onIdent(id);
+        }
+      }
+    } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
+      if (stmt.declare || !stmt.id) continue;
+      onIdent(stmt.id);
+    } else if (isForStatement(stmt)) {
+      walkForStatement(stmt, true, onIdent);
+    }
+  }
+}
+function isForStatement(stmt) {
+  return stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement";
+}
+function walkForStatement(stmt, isVar, onIdent) {
+  const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
+  if (variable && variable.type === "VariableDeclaration" && (variable.kind === "var" ? isVar : !isVar)) {
+    for (const decl of variable.declarations) {
+      for (const id of extractIdentifiers(decl.id)) {
+        onIdent(id);
+      }
+    }
+  }
+}
+function extractIdentifiers(param, nodes = []) {
+  switch (param.type) {
+    case "Identifier":
+      nodes.push(param);
+      break;
+    case "MemberExpression":
+      let object = param;
+      while (object.type === "MemberExpression") {
+        object = object.object;
+      }
+      nodes.push(object);
+      break;
+    case "ObjectPattern":
+      for (const prop of param.properties) {
+        if (prop.type === "RestElement") {
+          extractIdentifiers(prop.argument, nodes);
+        } else {
+          extractIdentifiers(prop.value, nodes);
+        }
+      }
+      break;
+    case "ArrayPattern":
+      param.elements.forEach((element) => {
+        if (element) extractIdentifiers(element, nodes);
+      });
+      break;
+    case "RestElement":
+      extractIdentifiers(param.argument, nodes);
+      break;
+    case "AssignmentPattern":
+      extractIdentifiers(param.left, nodes);
+      break;
+  }
+  return nodes;
+}
+function markKnownIds(name, knownIds) {
+  if (name in knownIds) {
+    knownIds[name]++;
+  } else {
+    knownIds[name] = 1;
+  }
+}
+function markScopeIdentifier(node, child, knownIds) {
+  const { name } = child;
+  if (node.scopeIds && node.scopeIds.has(name)) {
+    return;
+  }
+  markKnownIds(name, knownIds);
+  (node.scopeIds || (node.scopeIds = /* @__PURE__ */ new Set())).add(name);
+}
+const isFunctionType = (node) => {
+  return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
+};
+function isReferenced(node, parent, grandparent) {
+  switch (parent.type) {
+    // yes: PARENT[NODE]
+    // yes: NODE.child
+    // no: parent.NODE
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      if (parent.property === node) {
+        return !!parent.computed;
+      }
+      return parent.object === node;
+    case "JSXMemberExpression":
+      return parent.object === node;
+    // no: let NODE = init;
+    // yes: let id = NODE;
+    case "VariableDeclarator":
+      return parent.init === node;
+    // yes: () => NODE
+    // no: (NODE) => {}
+    case "ArrowFunctionExpression":
+      return parent.body === node;
+    // no: class { #NODE; }
+    // no: class { get #NODE() {} }
+    // no: class { #NODE() {} }
+    // no: class { fn() { return this.#NODE; } }
+    case "PrivateName":
+      return false;
+    // no: class { NODE() {} }
+    // yes: class { [NODE]() {} }
+    // no: class { foo(NODE) {} }
+    case "ClassMethod":
+    case "ClassPrivateMethod":
+    case "ObjectMethod":
+      if (parent.key === node) {
+        return !!parent.computed;
+      }
+      return false;
+    // yes: { [NODE]: "" }
+    // no: { NODE: "" }
+    // depends: { NODE }
+    // depends: { key: NODE }
+    case "ObjectProperty":
+      if (parent.key === node) {
+        return !!parent.computed;
+      }
+      return true;
+    // no: class { NODE = value; }
+    // yes: class { [NODE] = value; }
+    // yes: class { key = NODE; }
+    case "ClassProperty":
+      if (parent.key === node) {
+        return !!parent.computed;
+      }
+      return true;
+    case "ClassPrivateProperty":
+      return parent.key !== node;
+    // no: class NODE {}
+    // yes: class Foo extends NODE {}
+    case "ClassDeclaration":
+    case "ClassExpression":
+      return parent.superClass === node;
+    // yes: left = NODE;
+    // no: NODE = right;
+    case "AssignmentExpression":
+      return parent.right === node;
+    // no: [NODE = foo] = [];
+    // yes: [foo = NODE] = [];
+    case "AssignmentPattern":
+      return parent.right === node;
+    // no: NODE: for (;;) {}
+    case "LabeledStatement":
+      return false;
+    // no: try {} catch (NODE) {}
+    case "CatchClause":
+      return false;
+    // no: function foo(...NODE) {}
+    case "RestElement":
+      return false;
+    case "BreakStatement":
+    case "ContinueStatement":
+      return false;
+    // no: function NODE() {}
+    // no: function foo(NODE) {}
+    case "FunctionDeclaration":
+    case "FunctionExpression":
+      return false;
+    // no: export NODE from "foo";
+    // no: export * as NODE from "foo";
+    case "ExportNamespaceSpecifier":
+    case "ExportDefaultSpecifier":
+      return false;
+    // no: export { foo as NODE };
+    // yes: export { NODE as foo };
+    // no: export { NODE as foo } from "foo";
+    case "ExportSpecifier":
+      return parent.local === node;
+    // no: import NODE from "foo";
+    // no: import * as NODE from "foo";
+    // no: import { NODE as foo } from "foo";
+    // no: import { foo as NODE } from "foo";
+    // no: import NODE from "bar";
+    case "ImportDefaultSpecifier":
+    case "ImportNamespaceSpecifier":
+    case "ImportSpecifier":
+      return false;
+    // no: import "foo" assert { NODE: "json" }
+    case "ImportAttribute":
+      return false;
+    // no: <div NODE="foo" />
+    case "JSXAttribute":
+      return false;
+    // no: [NODE] = [];
+    // no: ({ NODE }) = [];
+    case "ObjectPattern":
+    case "ArrayPattern":
+      return false;
+    // no: new.NODE
+    // no: NODE.target
+    case "MetaProperty":
+      return false;
+    // yes: type X = { someProperty: NODE }
+    // no: type X = { NODE: OtherType }
+    case "ObjectTypeProperty":
+      return parent.key !== node;
+    // yes: enum X { Foo = NODE }
+    // no: enum X { NODE }
+    case "TSEnumMember":
+      return parent.id !== node;
+    // yes: { [NODE]: value }
+    // no: { NODE: value }
+    case "TSPropertySignature":
+      if (parent.key === node) {
+        return !!parent.computed;
+      }
+      return true;
+  }
+  return true;
+}
+const TS_NODE_TYPES = [
+  "TSAsExpression",
+  // foo as number
+  "TSTypeAssertion",
+  // (<number>foo)
+  "TSNonNullExpression",
+  // foo!
+  "TSInstantiationExpression",
+  // foo<string>
+  "TSSatisfiesExpression"
+  // foo satisfies T
+];
+function unwrapTSNode(node) {
+  if (TS_NODE_TYPES.includes(node.type)) {
+    return unwrapTSNode(node.expression);
+  } else {
+    return node;
+  }
+}
+
+const isStaticExp = (p) => p.type === 4 && p.isStatic;
+const nonIdentifierRE = /^\d|[^\$\w\xA0-\uFFFF]/;
+const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
+const getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source;
+const isMemberExpressionNode = (exp, context) => {
+  try {
+    let ret = exp.ast || parser.parseExpression(getExpSource(exp), {
+      plugins: context.expressionPlugins ? [...context.expressionPlugins, "typescript"] : ["typescript"]
+    });
+    ret = unwrapTSNode(ret);
+    return ret.type === "MemberExpression" || ret.type === "OptionalMemberExpression" || ret.type === "Identifier" && ret.name !== "undefined";
+  } catch (e) {
+    return false;
+  }
+};
+const isMemberExpression = isMemberExpressionNode;
+function isStaticArgOf(arg, name) {
+  return !!(arg && isStaticExp(arg) && arg.content === name);
+}
+function isVSlot(p) {
+  return p.type === 7 && p.name === "slot";
+}
+function isTemplateNode(node) {
+  return node.type === 1 && node.tagType === 3;
+}
+function toValidAssetId(name, type) {
+  return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
+    return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
+  })}`;
+}
+
+const helpers = {
+  setText: { name: "setText" },
+  setHtml: { name: "setHtml" },
+  setClass: { name: "setClass" },
+  setStyle: { name: "setStyle" },
+  setValue: { name: "setValue" },
+  setAttr: { name: "setAttr", needKey: true },
+  setProp: { name: "setProp", needKey: true },
+  setDOMProp: { name: "setDOMProp", needKey: true },
+  setDynamicProps: { name: "setDynamicProps" }
+};
+function genSetProp(oper, context) {
+  const { helper } = context;
+  const {
+    prop: { key, values, modifier },
+    tag
+  } = oper;
+  const resolvedHelper = getRuntimeHelper(tag, key.content, modifier);
+  const propValue = genPropValue(values, context);
+  return [
+    NEWLINE,
+    ...genCall(
+      [helper(resolvedHelper.name), null],
+      `n${oper.element}`,
+      resolvedHelper.needKey ? genExpression(key, context) : false,
+      propValue
+    )
+  ];
+}
+function genDynamicProps$1(oper, context) {
+  const { helper } = context;
+  const values = oper.props.map(
+    (props) => Array.isArray(props) ? genLiteralObjectProps(props, context) : props.kind === 1 ? genLiteralObjectProps([props], context) : genExpression(props.value, context)
+  );
+  return [
+    NEWLINE,
+    ...genCall(
+      helper("setDynamicProps"),
+      `n${oper.element}`,
+      genMulti(DELIMITERS_ARRAY, ...values),
+      oper.root && "true"
+    )
+  ];
+}
+function genLiteralObjectProps(props, context) {
+  return genMulti(
+    DELIMITERS_OBJECT,
+    ...props.map((prop) => [
+      ...genPropKey(prop, context),
+      `: `,
+      ...genPropValue(prop.values, context)
+    ])
+  );
+}
+function genPropKey({ key: node, modifier, runtimeCamelize, handler, handlerModifiers }, context) {
+  const { helper } = context;
+  const handlerModifierPostfix = handlerModifiers ? handlerModifiers.map(shared.capitalize).join("") : "";
+  if (node.isStatic) {
+    const keyName = (handler ? shared.toHandlerKey(node.content) : node.content) + handlerModifierPostfix;
+    return [
+      [
+        isSimpleIdentifier(keyName) ? keyName : JSON.stringify(keyName),
+        -2,
+        node.loc
+      ]
+    ];
+  }
+  let key = genExpression(node, context);
+  if (runtimeCamelize) {
+    key = genCall(helper("camelize"), key);
+  }
+  if (handler) {
+    key = genCall(helper("toHandlerKey"), key);
+  }
+  return [
+    "[",
+    modifier && `${JSON.stringify(modifier)} + `,
+    ...key,
+    handlerModifierPostfix ? ` + ${JSON.stringify(handlerModifierPostfix)}` : undefined,
+    "]"
+  ];
+}
+function genPropValue(values, context) {
+  if (values.length === 1) {
+    return genExpression(values[0], context);
+  }
+  return genMulti(
+    DELIMITERS_ARRAY,
+    ...values.map((expr) => genExpression(expr, context))
+  );
+}
+function getRuntimeHelper(tag, key, modifier) {
+  const tagName = tag.toUpperCase();
+  if (modifier) {
+    if (modifier === ".") {
+      return getSpecialHelper(key, tagName) || helpers.setDOMProp;
+    } else {
+      return helpers.setAttr;
+    }
+  }
+  const helper = getSpecialHelper(key, tagName);
+  if (helper) {
+    return helper;
+  }
+  if (/aria[A-Z]/.test(key)) {
+    return helpers.setDOMProp;
+  }
+  if (shared.isSVGTag(tag)) {
+    return helpers.setAttr;
+  }
+  if (shared.shouldSetAsAttr(tagName, key) || key.includes("-")) {
+    return helpers.setAttr;
+  }
+  return helpers.setProp;
+}
+function getSpecialHelper(keyName, tagName) {
+  if (keyName === "value" && shared.canSetValueDirectly(tagName)) {
+    return helpers.setValue;
+  } else if (keyName === "class") {
+    return helpers.setClass;
+  } else if (keyName === "style") {
+    return helpers.setStyle;
+  } else if (keyName === "innerHTML") {
+    return helpers.setHtml;
+  } else if (keyName === "textContent") {
+    return helpers.setText;
+  }
+}
+
+const setTemplateRefIdent = `_setTemplateRef`;
+function genSetTemplateRef(oper, context) {
+  return [
+    NEWLINE,
+    oper.effect && `r${oper.element} = `,
+    ...genCall(
+      setTemplateRefIdent,
+      // will be generated in root scope
+      `n${oper.element}`,
+      genExpression(oper.value, context),
+      oper.effect ? `r${oper.element}` : oper.refFor ? "void 0" : undefined,
+      oper.refFor && "true"
+    )
+  ];
+}
+function genDeclareOldRef(oper) {
+  return [NEWLINE, `let r${oper.id}`];
+}
+
+function genSetText(oper, context) {
+  const { helper } = context;
+  const { element, values } = oper;
+  const texts = values.map((value) => genExpression(value, context));
+  return [NEWLINE, ...genCall(helper("setText"), `n${element}`, ...texts)];
+}
+function genCreateTextNode(oper, context) {
+  const { helper } = context;
+  const { id, values, effect } = oper;
+  return [
+    NEWLINE,
+    `const n${id} = `,
+    ...genCall(helper("createTextNode"), [
+      effect && "() => ",
+      ...genMulti(
+        DELIMITERS_ARRAY,
+        ...values.map((value) => genExpression(value, context))
+      )
+    ])
+  ];
+}
+
+function genVShow(oper, context) {
+  return [
+    NEWLINE,
+    ...genCall(context.helper("applyVShow"), `n${oper.element}`, [
+      `() => (`,
+      ...genExpression(oper.dir.exp, context),
+      `)`
+    ])
+  ];
+}
+
+const helperMap = {
+  text: "applyTextModel",
+  radio: "applyRadioModel",
+  checkbox: "applyCheckboxModel",
+  select: "applySelectModel",
+  dynamic: "applyDynamicModel"
+};
+function genVModel(oper, context) {
+  const {
+    modelType,
+    element,
+    dir: { exp, modifiers }
+  } = oper;
+  return [
+    NEWLINE,
+    ...genCall(
+      context.helper(helperMap[modelType]),
+      `n${element}`,
+      // getter
+      [`() => (`, ...genExpression(exp, context), `)`],
+      // setter
+      genModelHandler(exp, context),
+      // modifiers
+      modifiers.length ? `{ ${modifiers.map((e) => e.content + ": true").join(",")} }` : undefined
+    )
+  ];
+}
+function genModelHandler(exp, context) {
+  return [
+    `${context.options.isTS ? `(_value: any)` : `_value`} => (`,
+    ...genExpression(exp, context, "_value"),
+    ")"
+  ];
+}
+
+function genBuiltinDirective(oper, context) {
+  switch (oper.name) {
+    case "show":
+      return genVShow(oper, context);
+    case "model":
+      return genVModel(oper, context);
+    default:
+      return [];
+  }
+}
+function genDirectivesForElement(id, context) {
+  const dirs = filterCustomDirectives(id, context.block.operation);
+  return dirs.length ? genCustomDirectives(dirs, context) : [];
+}
+function genCustomDirectives(opers, context) {
+  const { helper } = context;
+  const element = `n${opers[0].element}`;
+  const directiveItems = opers.map(genDirectiveItem);
+  const directives = genMulti(DELIMITERS_ARRAY, ...directiveItems);
+  return [
+    NEWLINE,
+    // @ts-expect-error
+    ...genCall(helper("withVaporDirectives"), element, directives)
+  ];
+  function genDirectiveItem({
+    dir,
+    name,
+    asset
+  }) {
+    const directiveVar = asset ? compilerDom.toValidAssetId(name, "directive") : genExpression(
+      shared.extend(compilerDom.createSimpleExpression(name, false), { ast: null }),
+      context
+    );
+    const value = dir.exp && ["() => ", ...genExpression(dir.exp, context)];
+    const argument = dir.arg && genExpression(dir.arg, context);
+    const modifiers = !!dir.modifiers.length && [
+      "{ ",
+      genDirectiveModifiers(dir.modifiers.map((m) => m.content)),
+      " }"
+    ];
+    return genMulti(
+      DELIMITERS_ARRAY.concat("void 0"),
+      directiveVar,
+      value,
+      argument,
+      modifiers
+    );
+  }
+}
+function genDirectiveModifiers(modifiers) {
+  return modifiers.map(
+    (value) => `${compilerDom.isSimpleIdentifier(value) ? value : JSON.stringify(value)}: true`
+  ).join(", ");
+}
+function filterCustomDirectives(id, operations) {
+  return operations.filter(
+    (oper) => oper.type === 14 && oper.element === id && !oper.builtin
+  );
+}
+
+function genCreateComponent(operation, context) {
+  const { helper } = context;
+  const tag = genTag();
+  const { root, props, slots, once } = operation;
+  const rawSlots = genRawSlots(slots, context);
+  const [ids, handlers] = processInlineHandlers(props, context);
+  const rawProps = context.withId(() => genRawProps(props, context), ids);
+  const inlineHandlers = handlers.reduce(
+    (acc, { name, value }) => {
+      const handler = genEventHandler(context, value, undefined, false);
+      return [...acc, `const ${name} = `, ...handler, NEWLINE];
+    },
+    []
+  );
+  return [
+    NEWLINE,
+    ...inlineHandlers,
+    `const n${operation.id} = `,
+    ...genCall(
+      operation.dynamic && !operation.dynamic.isStatic ? helper("createDynamicComponent") : operation.asset ? helper("createComponentWithFallback") : helper("createComponent"),
+      tag,
+      rawProps,
+      rawSlots,
+      root ? "true" : false,
+      once && "true"
+    ),
+    ...genDirectivesForElement(operation.id, context)
+  ];
+  function genTag() {
+    if (operation.dynamic) {
+      if (operation.dynamic.isStatic) {
+        return genCall(
+          helper("resolveDynamicComponent"),
+          genExpression(operation.dynamic, context)
+        );
+      } else {
+        return ["() => (", ...genExpression(operation.dynamic, context), ")"];
+      }
+    } else if (operation.asset) {
+      return toValidAssetId(operation.tag, "component");
+    } else {
+      return genExpression(
+        shared.extend(createSimpleExpression(operation.tag, false), { ast: null }),
+        context
+      );
+    }
+  }
+}
+function getUniqueHandlerName(context, name) {
+  const { seenInlineHandlerNames } = context;
+  const count = seenInlineHandlerNames[name] || 0;
+  seenInlineHandlerNames[name] = count + 1;
+  return count === 0 ? name : `${name}${count}`;
+}
+function processInlineHandlers(props, context) {
+  const ids = /* @__PURE__ */ Object.create(null);
+  const handlers = [];
+  const staticProps = props[0];
+  if (shared.isArray(staticProps)) {
+    for (let i = 0; i < staticProps.length; i++) {
+      const prop = staticProps[i];
+      if (!prop.handler) continue;
+      prop.values.forEach((value, i2) => {
+        const isMemberExp = isMemberExpression(value, context.options);
+        if (!isMemberExp) {
+          const name = getUniqueHandlerName(context, `_on_${prop.key.content}`);
+          handlers.push({ name, value });
+          ids[name] = null;
+          prop.values[i2] = shared.extend({ ast: null }, createSimpleExpression(name));
+        }
+      });
+    }
+  }
+  return [ids, handlers];
+}
+function genRawProps(props, context) {
+  const staticProps = props[0];
+  if (shared.isArray(staticProps)) {
+    if (!staticProps.length && props.length === 1) {
+      return;
+    }
+    return genStaticProps(
+      staticProps,
+      context,
+      genDynamicProps(props.slice(1), context)
+    );
+  } else if (props.length) {
+    return genStaticProps([], context, genDynamicProps(props, context));
+  }
+}
+function genStaticProps(props, context, dynamicProps) {
+  const args = props.map((prop) => genProp(prop, context, true));
+  if (dynamicProps) {
+    args.push([`$: `, ...dynamicProps]);
+  }
+  return genMulti(
+    args.length > 1 ? DELIMITERS_OBJECT_NEWLINE : DELIMITERS_OBJECT,
+    ...args
+  );
+}
+function genDynamicProps(props, context) {
+  const { helper } = context;
+  const frags = [];
+  for (const p of props) {
+    let expr;
+    if (shared.isArray(p)) {
+      if (p.length) {
+        frags.push(genStaticProps(p, context));
+      }
+      continue;
+    } else {
+      if (p.kind === 1)
+        expr = genMulti(DELIMITERS_OBJECT, genProp(p, context));
+      else {
+        expr = genExpression(p.value, context);
+        if (p.handler) expr = genCall(helper("toHandlers"), expr);
+      }
+    }
+    frags.push(["() => (", ...expr, ")"]);
+  }
+  if (frags.length) {
+    return genMulti(DELIMITERS_ARRAY_NEWLINE, ...frags);
+  }
+}
+function genProp(prop, context, isStatic) {
+  const values = genPropValue(prop.values, context);
+  return [
+    ...genPropKey(prop, context),
+    ": ",
+    ...prop.handler ? genEventHandler(context, prop.values[0]) : isStatic ? ["() => (", ...values, ")"] : values,
+    ...prop.model ? [...genModelEvent(prop, context), ...genModelModifiers(prop, context)] : []
+  ];
+}
+function genModelEvent(prop, context) {
+  const name = prop.key.isStatic ? [JSON.stringify(`onUpdate:${shared.camelize(prop.key.content)}`)] : ['["onUpdate:" + ', ...genExpression(prop.key, context), "]"];
+  const handler = genModelHandler(prop.values[0], context);
+  return [",", NEWLINE, ...name, ": () => ", ...handler];
+}
+function genModelModifiers(prop, context) {
+  const { key, modelModifiers } = prop;
+  if (!modelModifiers || !modelModifiers.length) return [];
+  const modifiersKey = key.isStatic ? key.content === "modelValue" ? [`modelModifiers`] : [`${key.content}Modifiers`] : ["[", ...genExpression(key, context), ' + "Modifiers"]'];
+  const modifiersVal = genDirectiveModifiers(modelModifiers);
+  return [",", NEWLINE, ...modifiersKey, `: () => ({ ${modifiersVal} })`];
+}
+function genRawSlots(slots, context) {
+  if (!slots.length) return;
+  const staticSlots = slots[0];
+  if (staticSlots.slotType === 0) {
+    return genStaticSlots(
+      staticSlots,
+      context,
+      slots.length > 1 ? slots.slice(1) : undefined
+    );
+  } else {
+    return genStaticSlots(
+      { slotType: 0, slots: {} },
+      context,
+      slots
+    );
+  }
+}
+function genStaticSlots({ slots }, context, dynamicSlots) {
+  const args = Object.keys(slots).map((name) => [
+    `${JSON.stringify(name)}: `,
+    ...genSlotBlockWithProps(slots[name], context)
+  ]);
+  if (dynamicSlots) {
+    args.push([`$: `, ...genDynamicSlots(dynamicSlots, context)]);
+  }
+  return genMulti(DELIMITERS_OBJECT_NEWLINE, ...args);
+}
+function genDynamicSlots(slots, context) {
+  return genMulti(
+    DELIMITERS_ARRAY_NEWLINE,
+    ...slots.map(
+      (slot) => slot.slotType === 0 ? genStaticSlots(slot, context) : slot.slotType === 4 ? slot.slots.content : genDynamicSlot(slot, context, true)
+    )
+  );
+}
+function genDynamicSlot(slot, context, withFunction = false) {
+  let frag;
+  switch (slot.slotType) {
+    case 1:
+      frag = genBasicDynamicSlot(slot, context);
+      break;
+    case 2:
+      frag = genLoopSlot(slot, context);
+      break;
+    case 3:
+      frag = genConditionalSlot(slot, context);
+      break;
+  }
+  return withFunction ? ["() => (", ...frag, ")"] : frag;
+}
+function genBasicDynamicSlot(slot, context) {
+  const { name, fn } = slot;
+  return genMulti(
+    DELIMITERS_OBJECT_NEWLINE,
+    ["name: ", ...genExpression(name, context)],
+    ["fn: ", ...genSlotBlockWithProps(fn, context)]
+  );
+}
+function genLoopSlot(slot, context) {
+  const { name, fn, loop } = slot;
+  const { value, key, index, source } = loop;
+  const rawValue = value && value.content;
+  const rawKey = key && key.content;
+  const rawIndex = index && index.content;
+  const idMap = {};
+  if (rawValue) idMap[rawValue] = rawValue;
+  if (rawKey) idMap[rawKey] = rawKey;
+  if (rawIndex) idMap[rawIndex] = rawIndex;
+  const slotExpr = genMulti(
+    DELIMITERS_OBJECT_NEWLINE,
+    ["name: ", ...context.withId(() => genExpression(name, context), idMap)],
+    [
+      "fn: ",
+      ...context.withId(() => genSlotBlockWithProps(fn, context), idMap)
+    ]
+  );
+  return [
+    ...genCall(
+      context.helper("createForSlots"),
+      genExpression(source, context),
+      [
+        ...genMulti(
+          ["(", ")", ", "],
+          rawValue ? rawValue : rawKey || rawIndex ? "_" : undefined,
+          rawKey ? rawKey : rawIndex ? "__" : undefined,
+          rawIndex
+        ),
+        " => (",
+        ...slotExpr,
+        ")"
+      ]
+    )
+  ];
+}
+function genConditionalSlot(slot, context) {
+  const { condition, positive, negative } = slot;
+  return [
+    ...genExpression(condition, context),
+    INDENT_START,
+    NEWLINE,
+    "? ",
+    ...genDynamicSlot(positive, context),
+    NEWLINE,
+    ": ",
+    ...negative ? [...genDynamicSlot(negative, context)] : ["void 0"],
+    INDENT_END
+  ];
+}
+function genSlotBlockWithProps(oper, context) {
+  let isDestructureAssignment = false;
+  let rawProps;
+  let propsName;
+  let exitScope;
+  let depth;
+  const { props } = oper;
+  const idsOfProps = /* @__PURE__ */ new Set();
+  if (props) {
+    rawProps = props.content;
+    if (isDestructureAssignment = !!props.ast) {
+      [depth, exitScope] = context.enterScope();
+      propsName = `_slotProps${depth}`;
+      walkIdentifiers(
+        props.ast,
+        (id, _, __, ___, isLocal) => {
+          if (isLocal) idsOfProps.add(id.name);
+        },
+        true
+      );
+    } else {
+      idsOfProps.add(propsName = rawProps);
+    }
+  }
+  const idMap = {};
+  idsOfProps.forEach(
+    (id) => idMap[id] = isDestructureAssignment ? `${propsName}[${JSON.stringify(id)}]` : null
+  );
+  const blockFn = context.withId(
+    () => genBlock(oper, context, [propsName]),
+    idMap
+  );
+  exitScope && exitScope();
+  return blockFn;
+}
+
+function genSlotOutlet(oper, context) {
+  const { helper } = context;
+  const { id, name, fallback } = oper;
+  const [frag, push] = buildCodeFragment();
+  const nameExpr = name.isStatic ? genExpression(name, context) : ["() => (", ...genExpression(name, context), ")"];
+  let fallbackArg;
+  if (fallback) {
+    fallbackArg = genBlock(fallback, context);
+  }
+  push(
+    NEWLINE,
+    `const n${id} = `,
+    ...genCall(
+      helper("createSlot"),
+      nameExpr,
+      genRawProps(oper.props, context) || "null",
+      fallbackArg
+    )
+  );
+  return frag;
+}
+
+function genOperations(opers, context) {
+  const [frag, push] = buildCodeFragment();
+  for (const operation of opers) {
+    push(...genOperation(operation, context));
+  }
+  return frag;
+}
+function genOperation(oper, context) {
+  switch (oper.type) {
+    case 2:
+      return genSetProp(oper, context);
+    case 3:
+      return genDynamicProps$1(oper, context);
+    case 4:
+      return genSetText(oper, context);
+    case 5:
+      return genSetEvent(oper, context);
+    case 6:
+      return genSetDynamicEvents(oper, context);
+    case 7:
+      return genSetHtml(oper, context);
+    case 8:
+      return genSetTemplateRef(oper, context);
+    case 11:
+      return genCreateTextNode(oper, context);
+    case 9:
+      return genInsertNode(oper, context);
+    case 10:
+      return genPrependNode(oper, context);
+    case 16:
+      return genIf(oper, context);
+    case 17:
+      return genFor(oper, context);
+    case 12:
+      return genCreateComponent(oper, context);
+    case 15:
+      return genDeclareOldRef(oper);
+    case 13:
+      return genSlotOutlet(oper, context);
+    case 14:
+      return genBuiltinDirective(oper, context);
+    default:
+      const exhaustiveCheck = oper;
+      throw new Error(
+        `Unhandled operation type in genOperation: ${exhaustiveCheck}`
+      );
+  }
+}
+function genEffects(effects, context) {
+  const {
+    helper,
+    block: { expressions }
+  } = context;
+  const [frag, push, unshift] = buildCodeFragment();
+  let operationsCount = 0;
+  const { ids, frag: declarationFrags } = processExpressions(
+    context,
+    expressions
+  );
+  push(...declarationFrags);
+  for (let i = 0; i < effects.length; i++) {
+    const effect = effects[i];
+    operationsCount += effect.operations.length;
+    const frags = context.withId(() => genEffect(effect, context), ids);
+    i > 0 && push(NEWLINE);
+    if (frag[frag.length - 1] === ")" && frags[0] === "(") {
+      push(";");
+    }
+    push(...frags);
+  }
+  const newLineCount = frag.filter((frag2) => frag2 === NEWLINE).length;
+  if (newLineCount > 1 || operationsCount > 1 || declarationFrags.length > 0) {
+    unshift(`{`, INDENT_START, NEWLINE);
+    push(INDENT_END, NEWLINE, "}");
+  }
+  if (effects.length) {
+    unshift(NEWLINE, `${helper("renderEffect")}(() => `);
+    push(`)`);
+  }
+  return frag;
+}
+function genEffect({ operations }, context) {
+  const [frag, push] = buildCodeFragment();
+  const operationsExps = genOperations(operations, context);
+  const newlineCount = operationsExps.filter((frag2) => frag2 === NEWLINE).length;
+  if (newlineCount > 1) {
+    push(...operationsExps);
+  } else {
+    push(...operationsExps.filter((frag2) => frag2 !== NEWLINE));
+  }
+  return frag;
+}
+
+function genTemplates(templates, rootIndex, { helper }) {
+  return templates.map(
+    (template, i) => `const t${i} = ${helper("template")}(${JSON.stringify(
+      template
+    )}${i === rootIndex ? ", true" : ""})
+`
+  ).join("");
+}
+function genChildren(dynamic, context, from, paths = []) {
+  const { helper } = context;
+  const [frag, push] = buildCodeFragment();
+  let offset = 0;
+  const { children, id, template } = dynamic;
+  if (id !== undefined && template !== undefined) {
+    push(NEWLINE, `const n${id} = t${template}()`);
+    push(...genDirectivesForElement(id, context));
+  }
+  let prev;
+  for (const [index, child] of children.entries()) {
+    if (child.flags & 2) {
+      offset--;
+    }
+    const id2 = child.flags & 1 ? child.flags & 4 ? child.anchor : child.id : undefined;
+    const elementIndex = Number(index) + offset;
+    const newPaths = [...paths, elementIndex];
+    if (id2 === undefined) {
+      push(...genChildren(child, context, from, newPaths));
+      continue;
+    }
+    push(NEWLINE, `const n${id2} = `);
+    if (prev) {
+      const offset2 = elementIndex - prev[1];
+      if (offset2 === 1) {
+        push(`n${prev[0]}.nextSibling`);
+      } else {
+        push(...genCall(helper("next"), `n${prev[0]}`, String(offset2)));
+      }
+    } else {
+      if (newPaths.length === 1 && newPaths[0] === 0) {
+        push(`n${from}.firstChild`);
+      } else {
+        push(
+          ...genCall(helper("children"), `n${from}`, ...newPaths.map(String))
+        );
+      }
+    }
+    push(...genDirectivesForElement(id2, context));
+    prev = [id2, elementIndex];
+    push(...genChildren(child, context, id2, []));
+  }
+  return frag;
+}
+
+function genBlock(oper, context, args = [], root, customReturns) {
+  return [
+    "(",
+    ...args,
+    ") => {",
+    INDENT_START,
+    ...genBlockContent(oper, context, root),
+    INDENT_END,
+    NEWLINE,
+    "}"
+  ];
+}
+function genBlockContent(block, context, root, customReturns) {
+  const [frag, push] = buildCodeFragment();
+  const { dynamic, effect, operation, returns } = block;
+  const resetBlock = context.enterBlock(block);
+  if (root) {
+    genResolveAssets("component", "resolveComponent");
+    genResolveAssets("directive", "resolveDirective");
+  }
+  for (const child of dynamic.children) {
+    push(...genChildren(child, context, child.id));
+  }
+  push(...genOperations(operation, context));
+  push(...genEffects(effect, context));
+  push(NEWLINE, `return `);
+  const returnNodes = returns.map((n) => `n${n}`);
+  const returnsCode = returnNodes.length > 1 ? genMulti(DELIMITERS_ARRAY, ...returnNodes) : [returnNodes[0] || "null"];
+  push(...returnsCode);
+  resetBlock();
+  return frag;
+  function genResolveAssets(kind, helper) {
+    for (const name of context.ir[kind]) {
+      push(
+        NEWLINE,
+        `const ${compilerDom.toValidAssetId(name, kind)} = `,
+        ...genCall(context.helper(helper), JSON.stringify(name))
+      );
+    }
+  }
+}
+
+class CodegenContext {
+  constructor(ir, options) {
+    this.ir = ir;
+    this.helpers = /* @__PURE__ */ new Set([]);
+    this.helper = (name) => {
+      this.helpers.add(name);
+      return `_${name}`;
+    };
+    this.delegates = /* @__PURE__ */ new Set();
+    this.identifiers = /* @__PURE__ */ Object.create(null);
+    this.seenInlineHandlerNames = /* @__PURE__ */ Object.create(null);
+    this.scopeLevel = 0;
+    const defaultOptions = {
+      mode: "module",
+      prefixIdentifiers: true,
+      sourceMap: false,
+      filename: `template.vue.html`,
+      scopeId: null,
+      runtimeGlobalName: `Vue`,
+      runtimeModuleName: `vue`,
+      ssrRuntimeModuleName: "vue/server-renderer",
+      ssr: false,
+      isTS: false,
+      inSSR: false,
+      inline: false,
+      bindingMetadata: {},
+      expressionPlugins: []
+    };
+    this.options = shared.extend(defaultOptions, options);
+    this.block = ir.block;
+  }
+  withId(fn, map) {
+    const { identifiers } = this;
+    const ids = Object.keys(map);
+    for (const id of ids) {
+      identifiers[id] || (identifiers[id] = []);
+      identifiers[id].unshift(map[id] || id);
+    }
+    const ret = fn();
+    ids.forEach((id) => shared.remove(identifiers[id], map[id] || id));
+    return ret;
+  }
+  enterBlock(block) {
+    const parent = this.block;
+    this.block = block;
+    return () => this.block = parent;
+  }
+  enterScope() {
+    return [this.scopeLevel++, () => this.scopeLevel--];
+  }
+}
+function generate(ir, options = {}) {
+  const [frag, push] = buildCodeFragment();
+  const context = new CodegenContext(ir, options);
+  const { helpers } = context;
+  const { inline, bindingMetadata } = options;
+  const functionName = "render";
+  const args = ["_ctx"];
+  if (bindingMetadata && !inline) {
+    args.push("$props", "$emit", "$attrs", "$slots");
+  }
+  const signature = (options.isTS ? args.map((arg) => `${arg}: any`) : args).join(
+    ", "
+  );
+  if (!inline) {
+    push(NEWLINE, `export function ${functionName}(${signature}) {`);
+  }
+  push(INDENT_START);
+  if (ir.hasTemplateRef) {
+    push(
+      NEWLINE,
+      `const ${setTemplateRefIdent} = ${context.helper("createTemplateRefSetter")}()`
+    );
+  }
+  push(...genBlockContent(ir.block, context, true));
+  push(INDENT_END, NEWLINE);
+  if (!inline) {
+    push("}");
+  }
+  const delegates = genDelegates(context);
+  const templates = genTemplates(ir.template, ir.rootTemplateIndex, context);
+  const imports = genHelperImports(context);
+  const preamble = imports + templates + delegates;
+  const newlineCount = [...preamble].filter((c) => c === "\n").length;
+  if (newlineCount && !inline) {
+    frag.unshift(...new Array(newlineCount).fill(LF));
+  }
+  let [code, map] = codeFragmentToString(frag, context);
+  if (!inline) {
+    code = preamble + code;
+  }
+  return {
+    code,
+    ast: ir,
+    preamble,
+    map: map && map.toJSON(),
+    helpers
+  };
+}
+function genDelegates({ delegates, helper }) {
+  return delegates.size ? genCall(
+    helper("delegateEvents"),
+    ...Array.from(delegates).map((v) => `"${v}"`)
+  ).join("") + "\n" : "";
+}
+function genHelperImports({ helpers, helper, options }) {
+  let imports = "";
+  if (helpers.size) {
+    imports += `import { ${[...helpers].map((h) => `${h} as _${h}`).join(", ")} } from '${options.runtimeModuleName}';
+`;
+  }
+  return imports;
+}
+
+const transformChildren = (node, context) => {
+  const isFragment = node.type === 0 || node.type === 1 && (node.tagType === 3 || node.tagType === 1);
+  if (!isFragment && node.type !== 1) return;
+  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) || childContext.dynamic.flags & 4) {
+        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) {
+      prevDynamics.push(child);
+    }
+    if (!(child.flags & 2)) {
+      if (prevDynamics.length) {
+        if (hasStaticTemplate) {
+          context.childrenTemplate[index - prevDynamics.length] = `<!>`;
+          prevDynamics[0].flags -= 2;
+          const anchor = prevDynamics[0].anchor = context.increaseId();
+          context.registerOperation({
+            type: 9,
+            elements: prevDynamics.map((child2) => child2.id),
+            parent: context.reference(),
+            anchor
+          });
+        } else {
+          context.registerOperation({
+            type: 10,
+            elements: prevDynamics.map((child2) => child2.id),
+            parent: context.reference()
+          });
+        }
+        prevDynamics = [];
+      }
+      hasStaticTemplate = true;
+    }
+  }
+  if (prevDynamics.length) {
+    context.registerOperation({
+      type: 9,
+      elements: prevDynamics.map((child) => child.id),
+      parent: context.reference()
+    });
+  }
+}
+
+const transformVOnce = (node, context) => {
+  if (
+    // !context.inSSR &&
+    node.type === 1 && compilerDom.findDir(node, "once", true)
+  ) {
+    context.inVOnce = true;
+  }
+};
+
+const isReservedProp = /* @__PURE__ */ shared.makeMap(
+  // the leading comma is intentional so empty string "" is also included
+  ",key,ref,ref_for,ref_key,"
+);
+const transformElement = (node, context) => {
+  return function postTransformElement() {
+    ({ node } = context);
+    if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1)))
+      return;
+    const isComponent = node.tagType === 1;
+    const isDynamicComponent = isComponentTag(node.tag);
+    const propsResult = buildProps(
+      node,
+      context,
+      isComponent,
+      isDynamicComponent
+    );
+    let { parent } = context;
+    while (parent && parent.parent && parent.node.type === 1 && parent.node.tagType === 3) {
+      parent = parent.parent;
+    }
+    const singleRoot = context.root === parent && parent.node.children.filter((child) => child.type !== 3).length === 1;
+    (isComponent ? transformComponentElement : transformNativeElement)(
+      node,
+      propsResult,
+      singleRoot,
+      context,
+      isDynamicComponent
+    );
+  };
+};
+function transformComponentElement(node, propsResult, singleRoot, context, isDynamicComponent) {
+  const dynamicComponent = isDynamicComponent ? resolveDynamicComponent(node) : undefined;
+  let { tag } = node;
+  let asset = true;
+  if (!dynamicComponent) {
+    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 | 4;
+  context.registerOperation({
+    type: 12,
+    id: context.reference(),
+    tag,
+    props: propsResult[0] ? propsResult[1] : [propsResult[1]],
+    asset,
+    root: singleRoot,
+    slots: [...context.slots],
+    once: context.inVOnce,
+    dynamic: dynamicComponent
+  });
+  context.slots = [];
+}
+function resolveDynamicComponent(node) {
+  const isProp = findProp(
+    node,
+    "is",
+    false,
+    true
+    /* allow empty */
+  );
+  if (!isProp) return;
+  if (isProp.type === 6) {
+    return isProp.value && compilerDom.createSimpleExpression(isProp.value.content, true);
+  } else {
+    return isProp.exp || // #10469 handle :is shorthand
+    shared.extend(compilerDom.createSimpleExpression(`is`, false, isProp.arg.loc), {
+      ast: null
+    });
+  }
+}
+function resolveSetupReference(name, context) {
+  const bindings = context.options.bindingMetadata;
+  if (!bindings || bindings.__isScriptSetup === false) {
+    return;
+  }
+  const camelName = shared.camelize(name);
+  const PascalName = shared.capitalize(camelName);
+  return bindings[name] ? name : bindings[camelName] ? camelName : bindings[PascalName] ? PascalName : undefined;
+}
+function transformNativeElement(node, propsResult, singleRoot, context) {
+  const { tag } = node;
+  const { scopeId } = context.options;
+  let template = "";
+  template += `<${tag}`;
+  if (scopeId) template += ` ${scopeId}`;
+  const dynamicProps = [];
+  if (propsResult[0]) {
+    const [, dynamicArgs, expressions] = propsResult;
+    context.registerEffect(expressions, {
+      type: 3,
+      element: context.reference(),
+      props: dynamicArgs,
+      root: singleRoot
+    });
+  } 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 {
+        dynamicProps.push(key.content);
+        context.registerEffect(values, {
+          type: 2,
+          element: context.reference(),
+          prop,
+          root: singleRoot,
+          tag
+        });
+      }
+    }
+  }
+  template += `>` + context.childrenTemplate.join("");
+  if (!shared.isVoidTag(tag)) {
+    template += `</${tag}>`;
+  }
+  if (singleRoot) {
+    context.ir.rootTemplateIndex = context.ir.template.length;
+  }
+  if (context.parent && context.parent.node.type === 1 && !compilerDom.isValidHTMLNesting(context.parent.node.tag, tag)) {
+    context.reference();
+    context.dynamic.template = context.pushTemplate(template);
+    context.dynamic.flags |= 4 | 2;
+  } else {
+    context.template += template;
+  }
+}
+function buildProps(node, context, isComponent, isDynamicComponent) {
+  const props = node.props;
+  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 === 7 && !prop.arg) {
+      if (prop.name === "bind") {
+        if (prop.exp) {
+          dynamicExpr.push(prop.exp);
+          pushMergeArg();
+          dynamicArgs.push({
+            kind: 0,
+            value: prop.exp
+          });
+        } else {
+          context.options.onError(
+            compilerDom.createCompilerError(34, prop.loc)
+          );
+        }
+        continue;
+      } else if (prop.name === "on") {
+        if (prop.exp) {
+          if (isComponent) {
+            dynamicExpr.push(prop.exp);
+            pushMergeArg();
+            dynamicArgs.push({
+              kind: 0,
+              value: prop.exp,
+              handler: true
+            });
+          } else {
+            context.registerEffect(
+              [prop.exp],
+              {
+                type: 6,
+                element: context.reference(),
+                event: prop.exp
+              }
+            );
+          }
+        } else {
+          context.options.onError(
+            compilerDom.createCompilerError(35, prop.loc)
+          );
+        }
+        continue;
+      }
+    }
+    if (isDynamicComponent && prop.type === 6 && prop.name === "is" || prop.type === 7 && prop.name === "bind" && compilerDom.isStaticArgOf(prop.arg, "is")) {
+      continue;
+    }
+    const result = transformProp(prop, node, context);
+    if (result) {
+      dynamicExpr.push(result.key, result.value);
+      if (isComponent && !result.key.isStatic) {
+        pushMergeArg();
+        dynamicArgs.push(
+          shared.extend(resolveDirectiveResult(result), {
+            kind: 1
+          })
+        );
+      } 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) {
+  let { name } = prop;
+  if (prop.type === 6) {
+    if (isReservedProp(name)) return;
+    return {
+      key: compilerDom.createSimpleExpression(prop.name, true, prop.nameLoc),
+      value: prop.value ? compilerDom.createSimpleExpression(prop.value.content, true, prop.value.loc) : EMPTY_EXPRESSION
+    };
+  }
+  const directiveTransform = context.options.directiveTransforms[name];
+  if (directiveTransform) {
+    return directiveTransform(prop, node, context);
+  }
+  if (!shared.isBuiltInDirective(name)) {
+    const fromSetup = resolveSetupReference(`v-${name}`, context);
+    if (fromSetup) {
+      name = fromSetup;
+    } else {
+      context.directive.add(name);
+    }
+    context.registerOperation({
+      type: 14,
+      element: context.reference(),
+      dir: prop,
+      name,
+      asset: !fromSetup
+    });
+  }
+}
+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 shared.extend({}, prop, {
+    value: undefined,
+    values: [prop.value]
+  });
+}
+function mergePropValues(existing, incoming) {
+  const newValues = incoming.values;
+  existing.values.push(...newValues);
+}
+function isComponentTag(tag) {
+  return tag === "component" || tag === "Component";
+}
+
+const transformVHtml = (dir, node, context) => {
+  let { exp, loc } = dir;
+  if (!exp) {
+    context.options.onError(
+      compilerDom.createDOMCompilerError(53, loc)
+    );
+    exp = EMPTY_EXPRESSION;
+  }
+  if (node.children.length) {
+    context.options.onError(
+      compilerDom.createDOMCompilerError(54, loc)
+    );
+    context.childrenTemplate.length = 0;
+  }
+  context.registerEffect([exp], {
+    type: 7,
+    element: context.reference(),
+    value: exp
+  });
+};
+
+const transformVText = (dir, node, context) => {
+  let { exp, loc } = dir;
+  if (!exp) {
+    context.options.onError(
+      compilerDom.createDOMCompilerError(55, loc)
+    );
+    exp = EMPTY_EXPRESSION;
+  }
+  if (node.children.length) {
+    context.options.onError(
+      compilerDom.createDOMCompilerError(56, loc)
+    );
+    context.childrenTemplate.length = 0;
+  }
+  const literal = getLiteralExpressionValue(exp);
+  if (literal != null) {
+    context.childrenTemplate = [String(literal)];
+  } else {
+    context.registerEffect([exp], {
+      type: 4,
+      element: context.reference(),
+      values: [exp]
+    });
+  }
+};
+
+function normalizeBindShorthand(arg, context) {
+  if (arg.type !== 4 || !arg.isStatic) {
+    context.options.onError(
+      compilerDom.createCompilerError(
+        52,
+        arg.loc
+      )
+    );
+    return compilerDom.createSimpleExpression("", true, arg.loc);
+  }
+  const propName = shared.camelize(arg.content);
+  const exp = compilerDom.createSimpleExpression(propName, false, arg.loc);
+  exp.ast = null;
+  return exp;
+}
+const transformVBind = (dir, node, context) => {
+  const { loc, modifiers } = dir;
+  let { exp } = dir;
+  let arg = dir.arg;
+  const modifiersString = modifiers.map((s) => s.content);
+  if (!exp) exp = normalizeBindShorthand(arg, context);
+  if (!exp.content.trim()) {
+    context.options.onError(
+      compilerDom.createCompilerError(34, loc)
+    );
+    exp = compilerDom.createSimpleExpression("", true, loc);
+  }
+  exp = resolveExpression(exp);
+  arg = resolveExpression(arg);
+  if (arg.isStatic && isReservedProp(arg.content)) return;
+  let camel = false;
+  if (modifiersString.includes("camel")) {
+    if (arg.isStatic) {
+      arg = shared.extend({}, arg, { content: shared.camelize(arg.content) });
+    } else {
+      camel = true;
+    }
+  }
+  return {
+    key: arg,
+    value: exp,
+    loc,
+    runtimeCamelize: camel,
+    modifier: modifiersString.includes("prop") ? "." : modifiersString.includes("attr") ? "^" : undefined
+  };
+};
+
+const delegatedEvents = /* @__PURE__ */ shared.makeMap(
+  "beforeinput,click,dblclick,contextmenu,focusin,focusout,input,keydown,keyup,mousedown,mousemove,mouseout,mouseover,mouseup,pointerdown,pointermove,pointerout,pointerover,pointerup,touchend,touchmove,touchstart"
+);
+const transformVOn = (dir, node, context) => {
+  let { arg, exp, loc, modifiers } = dir;
+  const isComponent = node.tagType === 1;
+  const isSlotOutlet = node.tag === "slot";
+  if (!exp && !modifiers.length) {
+    context.options.onError(
+      compilerDom.createCompilerError(35, loc)
+    );
+  }
+  arg = resolveExpression(arg);
+  const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = compilerDom.resolveModifiers(
+    arg.isStatic ? `on${arg.content}` : arg,
+    modifiers,
+    null,
+    loc
+  );
+  let keyOverride;
+  const isStaticClick = arg.isStatic && arg.content.toLowerCase() === "click";
+  const delegate = arg.isStatic && !eventOptionModifiers.length && delegatedEvents(arg.content);
+  if (nonKeyModifiers.includes("middle")) {
+    if (isStaticClick) {
+      arg = shared.extend({}, arg, { content: "mouseup" });
+    } else if (!arg.isStatic) {
+      keyOverride = ["click", "mouseup"];
+    }
+  }
+  if (nonKeyModifiers.includes("right")) {
+    if (isStaticClick) {
+      arg = shared.extend({}, arg, { content: "contextmenu" });
+    } else if (!arg.isStatic) {
+      keyOverride = ["click", "contextmenu"];
+    }
+  }
+  if (isComponent || isSlotOutlet) {
+    const handler = exp || EMPTY_EXPRESSION;
+    return {
+      key: arg,
+      value: handler,
+      handler: true,
+      handlerModifiers: eventOptionModifiers
+    };
+  }
+  const operation = {
+    type: 5,
+    element: context.reference(),
+    key: arg,
+    value: exp,
+    modifiers: {
+      keys: keyModifiers,
+      nonKeys: nonKeyModifiers,
+      options: eventOptionModifiers
+    },
+    keyOverride,
+    delegate,
+    effect: !arg.isStatic
+  };
+  context.registerEffect([arg], operation);
+};
+
+const transformVShow = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.options.onError(
+      compilerDom.createDOMCompilerError(61, loc)
+    );
+    return;
+  }
+  if (node.tagType === 2) {
+    context.options.onError(
+      compilerDom.createCompilerError(
+        36,
+        loc
+      )
+    );
+    return;
+  }
+  context.registerOperation({
+    type: 14,
+    element: context.reference(),
+    dir,
+    name: "show",
+    builtin: true
+  });
+};
+
+const transformTemplateRef = (node, context) => {
+  if (node.type !== 1) return;
+  const dir = findProp(node, "ref", false, true);
+  if (!dir) return;
+  context.ir.hasTemplateRef = true;
+  let value;
+  if (dir.type === 7) {
+    value = dir.exp || normalizeBindShorthand(dir.arg, context);
+  } else {
+    value = dir.value ? compilerDom.createSimpleExpression(dir.value.content, true, dir.value.loc) : EMPTY_EXPRESSION;
+  }
+  return () => {
+    const id = context.reference();
+    const effect = !isConstantExpression(value);
+    effect && context.registerOperation({
+      type: 15,
+      id
+    });
+    context.registerEffect([value], {
+      type: 8,
+      element: id,
+      value,
+      refFor: !!context.inVFor,
+      effect
+    });
+  };
+};
+
+const seen = /* @__PURE__ */ new WeakMap();
+const 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;
+    return;
+  }
+  if (node.type === 1 && node.tagType === 0 && isAllTextLike(node.children)) {
+    processTextLikeContainer(
+      node.children,
+      context
+    );
+  } else if (node.type === 5) {
+    processTextLike(context);
+  } else if (node.type === 2) {
+    context.template += node.content;
+  }
+};
+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 | 2;
+  context.registerOperation({
+    type: 11,
+    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,
+      element: context.reference(),
+      values
+    });
+  }
+}
+function createTextLikeExpression(node, context) {
+  seen.get(context.root).add(node);
+  if (node.type === 2) {
+    return compilerDom.createSimpleExpression(node.content, true, node.loc);
+  } else {
+    return node.content;
+  }
+}
+function isAllTextLike(children) {
+  return !!children.length && children.every(isTextLike) && // at least one an interpolation
+  children.some((n) => n.type === 5);
+}
+function isTextLike(node) {
+  return node.type === 5 || node.type === 2;
+}
+
+const transformVModel = (dir, node, context) => {
+  const { exp, arg } = dir;
+  if (!exp) {
+    context.options.onError(
+      compilerDom.createCompilerError(41, dir.loc)
+    );
+    return;
+  }
+  const rawExp = exp.loc.source;
+  const bindingType = context.options.bindingMetadata[rawExp];
+  if (bindingType === "props" || bindingType === "props-aliased") {
+    context.options.onError(
+      compilerDom.createCompilerError(44, exp.loc)
+    );
+    return;
+  }
+  const expString = exp.content;
+  const maybeRef = context.options.inline && (bindingType === "setup-let" || bindingType === "setup-ref" || bindingType === "setup-maybe-ref");
+  if (!expString.trim() || !compilerDom.isMemberExpression(exp, context.options) && !maybeRef) {
+    context.options.onError(
+      compilerDom.createCompilerError(42, exp.loc)
+    );
+    return;
+  }
+  const isComponent = node.tagType === 1;
+  if (isComponent) {
+    return {
+      key: arg ? arg : compilerDom.createSimpleExpression("modelValue", true),
+      value: exp,
+      model: true,
+      modelModifiers: dir.modifiers.map((m) => m.content)
+    };
+  }
+  if (dir.arg)
+    context.options.onError(
+      compilerDom.createDOMCompilerError(
+        58,
+        dir.arg.loc
+      )
+    );
+  const { tag } = node;
+  const isCustomElement = context.options.isCustomElement(tag);
+  let modelType = "text";
+  if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
+    if (tag === "input" || isCustomElement) {
+      const type = compilerDom.findProp(node, "type");
+      if (type) {
+        if (type.type === 7) {
+          modelType = "dynamic";
+        } else if (type.value) {
+          switch (type.value.content) {
+            case "radio":
+              modelType = "radio";
+              break;
+            case "checkbox":
+              modelType = "checkbox";
+              break;
+            case "file":
+              modelType = undefined;
+              context.options.onError(
+                compilerDom.createDOMCompilerError(
+                  59,
+                  dir.loc
+                )
+              );
+              break;
+            default:
+              checkDuplicatedValue();
+              break;
+          }
+        }
+      } else if (compilerDom.hasDynamicKeyVBind(node)) {
+        modelType = "dynamic";
+      } else {
+        checkDuplicatedValue();
+      }
+    } else if (tag === "select") {
+      modelType = "select";
+    } else {
+      checkDuplicatedValue();
+    }
+  } else {
+    context.options.onError(
+      compilerDom.createDOMCompilerError(
+        57,
+        dir.loc
+      )
+    );
+  }
+  if (modelType)
+    context.registerOperation({
+      type: 14,
+      element: context.reference(),
+      dir,
+      name: "model",
+      modelType,
+      builtin: true
+    });
+  function checkDuplicatedValue() {
+    const value = compilerDom.findDir(node, "bind");
+    if (value && compilerDom.isStaticArgOf(value.arg, "value")) {
+      context.options.onError(
+        compilerDom.createDOMCompilerError(
+          60,
+          value.loc
+        )
+      );
+    }
+  }
+};
+
+const transformComment = (node, context) => {
+  if (node.type !== 3) return;
+  if (getSiblingIf(context)) {
+    context.comment.push(node);
+    context.dynamic.flags |= 2;
+  } else {
+    context.template += `<!--${node.content}-->`;
+  }
+};
+function getSiblingIf(context, reverse) {
+  const parent = context.parent;
+  if (!parent) return;
+  const siblings = parent.node.children;
+  let sibling;
+  let i = siblings.indexOf(context.node);
+  while (reverse ? --i >= 0 : ++i < siblings.length) {
+    sibling = siblings[i];
+    if (!isCommentLike(sibling)) {
+      break;
+    }
+  }
+  if (sibling && sibling.type === 1 && sibling.props.some(
+    ({ type, name }) => type === 7 && ["else-if", reverse ? "if" : "else"].includes(name)
+  )) {
+    return sibling;
+  }
+}
+function isCommentLike(node) {
+  return node.type === 3 || node.type === 2 && !node.content.trim().length;
+}
+
+const transformVIf = createStructuralDirectiveTransform(
+  ["if", "else", "else-if"],
+  processIf
+);
+function processIf(node, dir, context) {
+  if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) {
+    const loc = dir.exp ? dir.exp.loc : node.loc;
+    context.options.onError(
+      compilerDom.createCompilerError(28, dir.loc)
+    );
+    dir.exp = compilerDom.createSimpleExpression(`true`, false, loc);
+  }
+  context.dynamic.flags |= 2;
+  if (dir.name === "if") {
+    const id = context.reference();
+    context.dynamic.flags |= 4;
+    const [branch, onExit] = createIfBranch(node, context);
+    return () => {
+      onExit();
+      context.registerOperation({
+        type: 16,
+        id,
+        condition: dir.exp,
+        positive: branch,
+        once: context.inVOnce
+      });
+    };
+  } else {
+    const siblingIf = getSiblingIf(context, true);
+    const { operation } = context.block;
+    let lastIfNode = operation[operation.length - 1];
+    if (
+      // check if v-if is the sibling node
+      !siblingIf || // check if IfNode is the last operation and get the root IfNode
+      !lastIfNode || lastIfNode.type !== 16
+    ) {
+      context.options.onError(
+        compilerDom.createCompilerError(30, node.loc)
+      );
+      return;
+    }
+    while (lastIfNode.negative && lastIfNode.negative.type === 16) {
+      lastIfNode = lastIfNode.negative;
+    }
+    if (dir.name === "else-if" && lastIfNode.negative) {
+      context.options.onError(
+        compilerDom.createCompilerError(30, node.loc)
+      );
+    }
+    if (context.root.comment.length) {
+      node = wrapTemplate(node, ["else-if", "else"]);
+      context.node = node = shared.extend({}, node, {
+        children: [...context.comment, ...node.children]
+      });
+    }
+    context.root.comment = [];
+    const [branch, onExit] = createIfBranch(node, context);
+    if (dir.name === "else") {
+      lastIfNode.negative = branch;
+    } else {
+      lastIfNode.negative = {
+        type: 16,
+        id: -1,
+        condition: dir.exp,
+        positive: branch,
+        once: context.inVOnce
+      };
+    }
+    return () => onExit();
+  }
+}
+function createIfBranch(node, context) {
+  context.node = node = wrapTemplate(node, ["if", "else-if", "else"]);
+  const branch = newBlock(node);
+  const exitBlock = context.enterBlock(branch);
+  context.reference();
+  return [branch, exitBlock];
+}
+
+const transformVFor = createStructuralDirectiveTransform(
+  "for",
+  processFor
+);
+function processFor(node, dir, context) {
+  if (!dir.exp) {
+    context.options.onError(
+      compilerDom.createCompilerError(31, dir.loc)
+    );
+    return;
+  }
+  const parseResult = dir.forParseResult;
+  if (!parseResult) {
+    context.options.onError(
+      compilerDom.createCompilerError(32, dir.loc)
+    );
+    return;
+  }
+  const { source, value, key, index } = parseResult;
+  const keyProp = findProp(node, "key");
+  const keyProperty = keyProp && propToExpression(keyProp);
+  const isComponent = node.tagType === 1;
+  context.node = node = wrapTemplate(node, ["for"]);
+  context.dynamic.flags |= 2 | 4;
+  const id = context.reference();
+  const render = newBlock(node);
+  const exitBlock = context.enterBlock(render, true);
+  context.reference();
+  return () => {
+    exitBlock();
+    context.registerOperation({
+      type: 17,
+      id,
+      source,
+      value,
+      key,
+      index,
+      keyProp: keyProperty,
+      render,
+      once: context.inVOnce,
+      component: isComponent
+    });
+  };
+}
+
+const transformSlotOutlet = (node, context) => {
+  if (node.type !== 1 || node.tag !== "slot") {
+    return;
+  }
+  const id = context.reference();
+  context.dynamic.flags |= 4 | 2;
+  const [fallback, exitBlock] = createFallback(
+    node,
+    context
+  );
+  let slotName;
+  const slotProps = [];
+  for (const prop of node.props) {
+    if (prop.type === 6) {
+      if (prop.value) {
+        if (prop.name === "name") {
+          slotName = createSimpleExpression(prop.value.content, true, prop.loc);
+        } else {
+          slotProps.push(shared.extend({}, prop, { name: shared.camelize(prop.name) }));
+        }
+      }
+    } else if (prop.name === "bind" && isStaticArgOf(prop.arg, "name")) {
+      if (prop.exp) {
+        slotName = prop.exp;
+      } else {
+        slotName = createSimpleExpression(
+          shared.camelize(prop.arg.content),
+          false,
+          prop.arg.loc
+        );
+        slotName.ast = null;
+      }
+    } else {
+      let slotProp = prop;
+      if (slotProp.name === "bind" && slotProp.arg && isStaticExp(slotProp.arg)) {
+        slotProp = shared.extend({}, prop, {
+          arg: shared.extend({}, slotProp.arg, {
+            content: shared.camelize(slotProp.arg.content)
+          })
+        });
+      }
+      slotProps.push(slotProp);
+    }
+  }
+  slotName || (slotName = createSimpleExpression("default", true));
+  let irProps = [];
+  if (slotProps.length) {
+    const [isDynamic, props] = buildProps(
+      shared.extend({}, node, { props: slotProps }),
+      context,
+      true
+    );
+    irProps = isDynamic ? props : [props];
+    const runtimeDirective = context.block.operation.find(
+      (oper) => oper.type === 14 && oper.element === id
+    );
+    if (runtimeDirective) {
+      context.options.onError(
+        createCompilerError(
+          36,
+          runtimeDirective.dir.loc
+        )
+      );
+    }
+  }
+  return () => {
+    exitBlock && exitBlock();
+    context.registerOperation({
+      type: 13,
+      id,
+      name: slotName,
+      props: irProps,
+      fallback
+    });
+  };
+};
+function createFallback(node, context) {
+  if (!node.children.length) {
+    return [];
+  }
+  context.node = node = shared.extend({}, node, {
+    type: 1,
+    tag: "template",
+    props: [],
+    tagType: 3,
+    children: node.children
+  });
+  const fallback = newBlock(node);
+  const exitBlock = context.enterBlock(fallback);
+  context.reference();
+  return [fallback, exitBlock];
+}
+
+const transformVSlot = (node, context) => {
+  if (node.type !== 1) return;
+  const dir = findDir(node, "slot", true);
+  const { tagType, children } = node;
+  const { parent } = context;
+  const isComponent = tagType === 1;
+  const isSlotTemplate = isTemplateNode(node) && parent && parent.node.type === 1 && parent.node.tagType === 1;
+  if (isComponent && children.length) {
+    return transformComponentSlot(
+      node,
+      dir,
+      context
+    );
+  } else if (isSlotTemplate && dir) {
+    return transformTemplateSlot(
+      node,
+      dir,
+      context
+    );
+  } else if (!isComponent && dir) {
+    context.options.onError(
+      createCompilerError(40, dir.loc)
+    );
+  }
+};
+function transformComponentSlot(node, dir, context) {
+  const { children } = node;
+  const arg = dir && dir.arg;
+  const nonSlotTemplateChildren = children.filter(
+    (n) => isNonWhitespaceContent(node) && !(n.type === 1 && n.props.some(isVSlot))
+  );
+  const [block, onExit] = createSlotBlock(node, dir, context);
+  const { slots } = context;
+  return () => {
+    onExit();
+    const hasOtherSlots = !!slots.length;
+    if (dir && hasOtherSlots) {
+      context.options.onError(
+        createCompilerError(37, dir.loc)
+      );
+      return;
+    }
+    if (nonSlotTemplateChildren.length) {
+      if (hasStaticSlot(slots, "default")) {
+        context.options.onError(
+          createCompilerError(
+            39,
+            nonSlotTemplateChildren[0].loc
+          )
+        );
+      } else {
+        registerSlot(slots, arg, block);
+        context.slots = slots;
+      }
+    } else if (hasOtherSlots) {
+      context.slots = slots;
+    }
+  };
+}
+function transformTemplateSlot(node, dir, context) {
+  context.dynamic.flags |= 2;
+  const arg = dir.arg && resolveExpression(dir.arg);
+  const vFor = findDir(node, "for");
+  const vIf = findDir(node, "if");
+  const vElse = findDir(
+    node,
+    /^else(-if)?$/,
+    true
+    /* allowEmpty */
+  );
+  const { slots } = context;
+  const [block, onExit] = createSlotBlock(node, dir, context);
+  if (!vFor && !vIf && !vElse) {
+    const slotName = arg ? arg.isStatic && arg.content : "default";
+    if (slotName && hasStaticSlot(slots, slotName)) {
+      context.options.onError(
+        createCompilerError(38, dir.loc)
+      );
+    } else {
+      registerSlot(slots, arg, block);
+    }
+  } else if (vIf) {
+    registerDynamicSlot(slots, {
+      slotType: 3,
+      condition: vIf.exp,
+      positive: {
+        slotType: 1,
+        name: arg,
+        fn: block
+      }
+    });
+  } else if (vElse) {
+    const vIfSlot = slots[slots.length - 1];
+    if (vIfSlot.slotType === 3) {
+      let ifNode = vIfSlot;
+      while (ifNode.negative && ifNode.negative.slotType === 3)
+        ifNode = ifNode.negative;
+      const negative = vElse.exp ? {
+        slotType: 3,
+        condition: vElse.exp,
+        positive: {
+          slotType: 1,
+          name: arg,
+          fn: block
+        }
+      } : {
+        slotType: 1,
+        name: arg,
+        fn: block
+      };
+      ifNode.negative = negative;
+    } else {
+      context.options.onError(
+        createCompilerError(30, vElse.loc)
+      );
+    }
+  } else if (vFor) {
+    if (vFor.forParseResult) {
+      registerDynamicSlot(slots, {
+        slotType: 2,
+        name: arg,
+        fn: block,
+        loop: vFor.forParseResult
+      });
+    } else {
+      context.options.onError(
+        createCompilerError(32, vFor.loc)
+      );
+    }
+  }
+  return onExit;
+}
+function ensureStaticSlots(slots) {
+  let lastSlots = slots[slots.length - 1];
+  if (!slots.length || lastSlots.slotType !== 0) {
+    slots.push(
+      lastSlots = {
+        slotType: 0,
+        slots: {}
+      }
+    );
+  }
+  return lastSlots.slots;
+}
+function registerSlot(slots, name, block) {
+  const isStatic = !name || name.isStatic;
+  if (isStatic) {
+    const staticSlots = ensureStaticSlots(slots);
+    staticSlots[name ? name.content : "default"] = block;
+  } else {
+    slots.push({
+      slotType: 1,
+      name,
+      fn: block
+    });
+  }
+}
+function registerDynamicSlot(allSlots, dynamic) {
+  allSlots.push(dynamic);
+}
+function hasStaticSlot(slots, name) {
+  return slots.some((slot) => {
+    if (slot.slotType === 0) return !!slot.slots[name];
+  });
+}
+function createSlotBlock(slotNode, dir, context) {
+  const block = newBlock(slotNode);
+  block.props = dir && dir.exp;
+  const exitBlock = context.enterBlock(block);
+  return [block, exitBlock];
+}
+function isNonWhitespaceContent(node) {
+  if (node.type !== 2) return true;
+  return !!node.content.trim();
+}
+
+function compile(source, options = {}) {
+  const resolvedOptions = shared.extend({}, options);
+  const ast = shared.isString(source) ? compilerDom.parse(source, resolvedOptions) : source;
+  const [nodeTransforms, directiveTransforms] = getBaseTransformPreset();
+  if (options.isTS) {
+    const { expressionPlugins } = options;
+    if (!expressionPlugins || !expressionPlugins.includes("typescript")) {
+      resolvedOptions.expressionPlugins = [
+        ...expressionPlugins || [],
+        "typescript"
+      ];
+    }
+  }
+  const ir = transform(
+    ast,
+    shared.extend({}, resolvedOptions, {
+      nodeTransforms: [
+        ...nodeTransforms,
+        ...options.nodeTransforms || []
+        // user transforms
+      ],
+      directiveTransforms: shared.extend(
+        {},
+        directiveTransforms,
+        options.directiveTransforms || {}
+        // user transforms
+      )
+    })
+  );
+  return generate(ir, resolvedOptions);
+}
+function getBaseTransformPreset() {
+  return [
+    [
+      transformVOnce,
+      transformVIf,
+      transformVFor,
+      transformSlotOutlet,
+      transformTemplateRef,
+      transformText,
+      transformElement,
+      transformVSlot,
+      transformComment,
+      transformChildren
+    ],
+    {
+      bind: transformVBind,
+      on: transformVOn,
+      html: transformVHtml,
+      text: transformVText,
+      show: transformVShow,
+      model: transformVModel
+    }
+  ];
+}
+
+const IRDynamicPropsKind = {
+  "EXPRESSION": 0,
+  "0": "EXPRESSION",
+  "ATTRIBUTE": 1,
+  "1": "ATTRIBUTE"
+};
+const IRSlotType = {
+  "STATIC": 0,
+  "0": "STATIC",
+  "DYNAMIC": 1,
+  "1": "DYNAMIC",
+  "LOOP": 2,
+  "2": "LOOP",
+  "CONDITIONAL": 3,
+  "3": "CONDITIONAL",
+  "EXPRESSION": 4,
+  "4": "EXPRESSION"
+};
+
+const IRNodeTypes = {
+  "ROOT": 0,
+  "0": "ROOT",
+  "BLOCK": 1,
+  "1": "BLOCK",
+  "SET_PROP": 2,
+  "2": "SET_PROP",
+  "SET_DYNAMIC_PROPS": 3,
+  "3": "SET_DYNAMIC_PROPS",
+  "SET_TEXT": 4,
+  "4": "SET_TEXT",
+  "SET_EVENT": 5,
+  "5": "SET_EVENT",
+  "SET_DYNAMIC_EVENTS": 6,
+  "6": "SET_DYNAMIC_EVENTS",
+  "SET_HTML": 7,
+  "7": "SET_HTML",
+  "SET_TEMPLATE_REF": 8,
+  "8": "SET_TEMPLATE_REF",
+  "INSERT_NODE": 9,
+  "9": "INSERT_NODE",
+  "PREPEND_NODE": 10,
+  "10": "PREPEND_NODE",
+  "CREATE_TEXT_NODE": 11,
+  "11": "CREATE_TEXT_NODE",
+  "CREATE_COMPONENT_NODE": 12,
+  "12": "CREATE_COMPONENT_NODE",
+  "SLOT_OUTLET_NODE": 13,
+  "13": "SLOT_OUTLET_NODE",
+  "DIRECTIVE": 14,
+  "14": "DIRECTIVE",
+  "DECLARE_OLD_REF": 15,
+  "15": "DECLARE_OLD_REF",
+  "IF": 16,
+  "16": "IF",
+  "FOR": 17,
+  "17": "FOR"
+};
+const DynamicFlag = {
+  "NONE": 0,
+  "0": "NONE",
+  "REFERENCED": 1,
+  "1": "REFERENCED",
+  "NON_TEMPLATE": 2,
+  "2": "NON_TEMPLATE",
+  "INSERT": 4,
+  "4": "INSERT"
+};
+
+function createVaporCompilerError(code, loc) {
+  return compilerDom.createCompilerError(
+    code,
+    loc,
+    VaporErrorMessages
+  );
+}
+const VaporErrorCodes = {
+  "X_V_PLACEHOLDER": 100,
+  "100": "X_V_PLACEHOLDER",
+  "__EXTEND_POINT__": 101,
+  "101": "__EXTEND_POINT__"
+};
+const VaporErrorMessages = {
+  [100]: `[placeholder]`,
+  // just to fulfill types
+  [101]: ``
+};
+
+exports.parse = compilerDom.parse;
+exports.CodegenContext = CodegenContext;
+exports.DynamicFlag = DynamicFlag;
+exports.IRDynamicPropsKind = IRDynamicPropsKind;
+exports.IRNodeTypes = IRNodeTypes;
+exports.IRSlotType = IRSlotType;
+exports.VaporErrorCodes = VaporErrorCodes;
+exports.VaporErrorMessages = VaporErrorMessages;
+exports.buildCodeFragment = buildCodeFragment;
+exports.codeFragmentToString = codeFragmentToString;
+exports.compile = compile;
+exports.createStructuralDirectiveTransform = createStructuralDirectiveTransform;
+exports.createVaporCompilerError = createVaporCompilerError;
+exports.genCall = genCall;
+exports.genMulti = genMulti;
+exports.generate = generate;
+exports.transform = transform;
+exports.transformChildren = transformChildren;
+exports.transformComment = transformComment;
+exports.transformElement = transformElement;
+exports.transformSlotOutlet = transformSlotOutlet;
+exports.transformTemplateRef = transformTemplateRef;
+exports.transformText = transformText;
+exports.transformVBind = transformVBind;
+exports.transformVFor = transformVFor;
+exports.transformVHtml = transformVHtml;
+exports.transformVIf = transformVIf;
+exports.transformVModel = transformVModel;
+exports.transformVOn = transformVOn;
+exports.transformVOnce = transformVOnce;
+exports.transformVShow = transformVShow;
+exports.transformVSlot = transformVSlot;
+exports.transformVText = transformVText;
+exports.wrapTemplate = wrapTemplate;