n8n-editor-ui
Version:
Workflow Editor UI for n8n
4,579 lines • 200 kB
JavaScript
;
(function () {
System.register(["./chunk-legacy-Re9CbdfL.js", "./vue.runtime.esm-bundler-legacy--Sn1h8On.js"], function (_export, _context) {
"use strict";
var __toCommonJS, __esm, __export, __commonJS, NOOP, EMPTY_OBJ, generateCodeFrame, shared_esm_bundler_exports, capitalize, camelize, extend, makeMap, init_runtime_dom_esm_bundler, isObject, isReservedProp, isVoidTag, isSymbol, isOn, isString, isArray, isHTMLTag, isSVGTag, NO, isBuiltInDirective, runtime_dom_esm_bundler_exports, isMathMLTag, init_shared_esm_bundler, toHandlerKey, parseStringStyle, FRAGMENT, TELEPORT, SUSPENSE, KEEP_ALIVE, BASE_TRANSITION, OPEN_BLOCK, CREATE_BLOCK, CREATE_ELEMENT_BLOCK, CREATE_VNODE, CREATE_ELEMENT_VNODE, CREATE_COMMENT, CREATE_TEXT, CREATE_STATIC, RESOLVE_COMPONENT, RESOLVE_DYNAMIC_COMPONENT, RESOLVE_DIRECTIVE, RESOLVE_FILTER, WITH_DIRECTIVES, RENDER_LIST, RENDER_SLOT, CREATE_SLOTS, TO_DISPLAY_STRING, MERGE_PROPS, NORMALIZE_CLASS, NORMALIZE_STYLE, NORMALIZE_PROPS, GUARD_REACTIVE_PROPS, TO_HANDLERS, CAMELIZE, CAPITALIZE, TO_HANDLER_KEY, SET_BLOCK_TRACKING, PUSH_SCOPE_ID, POP_SCOPE_ID, WITH_CTX, UNREF, IS_REF, WITH_MEMO, IS_MEMO_SAME, helperNameMap, Namespaces, NodeTypes, ElementTypes, ConstantTypes, locStub, defaultDelimitersOpen, defaultDelimitersClose, Sequences, Tokenizer, CompilerDeprecationTypes, deprecationData, ErrorCodes, errorMessages, isFunctionType, isStaticProperty, isStaticPropertyKey, TS_NODE_TYPES, isStaticExp, nonIdentifierRE, isSimpleIdentifier, validFirstIdentCharRE, validIdentCharRE, whitespaceRE, getExpSource, isMemberExpressionBrowser, isMemberExpressionNode, isMemberExpression, fnExpRE, isFnExpressionBrowser, isFnExpressionNode, isFnExpression, propsHelperSet, forAliasRE, defaultParserOptions, currentOptions, currentRoot, currentInput, currentOpenTag, currentProp, currentAttrValue, currentAttrStartIndex, currentAttrEndIndex, inPre, inVPre, currentVPreBoundary, stack, tokenizer, forIteratorRE, stripParensRE, specialTemplateDir, windowsNewlineRE, allowHoistedHelperSet, PURE_ANNOTATION, aliasHelper, transformExpression, transformIf, transformBind, transformBindShorthand, injectPrefix, transformFor, defaultFallback, trackSlotScopes, trackVForSlotScopes, buildClientSlotFn, directiveImportMap, transformElement, transformSlotOutlet, transformOn, transformText, seen$1, transformOnce, transformModel, validDivisionCharRE, transformFilter, seen, transformMemo, BindingTypes, noopDirectiveTransform, init_compiler_core_esm_bundler, compiler_dom_esm_bundler_exports, V_MODEL_RADIO, V_MODEL_CHECKBOX, V_MODEL_TEXT, V_MODEL_SELECT, V_MODEL_DYNAMIC, V_ON_WITH_MODIFIERS, V_ON_WITH_KEYS, V_SHOW, TRANSITION, TRANSITION_GROUP, decoder, parserOptions, transformStyle, parseInlineCSS, DOMErrorCodes, DOMErrorMessages, transformVHtml, transformVText, transformModel$1, isEventOptionModifier, isNonKeyModifier, maybeKeyModifier, isKeyboardEvent, resolveModifiers, transformClick, transformOn$1, transformShow, ignoreSideEffectTags, DOMNodeTransforms, DOMDirectiveTransforms, init_compiler_dom_esm_bundler, require_vue_cjs_prod, require_vue;
//#region ../../../node_modules/.pnpm/@vue+compiler-core@3.5.13/node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js
function registerRuntimeHelpers(helpers) {
Object.getOwnPropertySymbols(helpers).forEach(s => {
helperNameMap[s] = helpers[s];
});
}
function createRoot(children, source = "") {
return {
type: 0,
source,
children,
helpers: /* @__PURE__ */new Set(),
components: [],
directives: [],
hoists: [],
imports: [],
cached: [],
temps: 0,
codegenNode: void 0,
loc: locStub
};
}
function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent$1 = false, loc = locStub) {
if (context) {
if (isBlock) {
context.helper(OPEN_BLOCK);
context.helper(getVNodeBlockHelper(context.inSSR, isComponent$1));
} else context.helper(getVNodeHelper(context.inSSR, isComponent$1));
if (directives) context.helper(WITH_DIRECTIVES);
}
return {
type: 13,
tag,
props,
children,
patchFlag,
dynamicProps,
directives,
isBlock,
disableTracking,
isComponent: isComponent$1,
loc
};
}
function createArrayExpression(elements, loc = locStub) {
return {
type: 17,
loc,
elements
};
}
function createObjectExpression(properties, loc = locStub) {
return {
type: 15,
loc,
properties
};
}
function createObjectProperty(key, value) {
return {
type: 16,
loc: locStub,
key: isString(key) ? createSimpleExpression(key, true) : key,
value
};
}
function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) {
return {
type: 4,
loc,
content,
isStatic,
constType: isStatic ? 3 : constType
};
}
function createInterpolation(content, loc) {
return {
type: 5,
loc,
content: isString(content) ? createSimpleExpression(content, false, loc) : content
};
}
function createCompoundExpression(children, loc = locStub) {
return {
type: 8,
loc,
children
};
}
function createCallExpression(callee, args = [], loc = locStub) {
return {
type: 14,
loc,
callee,
arguments: args
};
}
function createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) {
return {
type: 18,
params,
returns,
newline,
isSlot,
loc
};
}
function createConditionalExpression(test, consequent, alternate, newline = true) {
return {
type: 19,
test,
consequent,
alternate,
newline,
loc: locStub
};
}
function createCacheExpression(index, value, needPauseTracking = false, inVOnce = false) {
return {
type: 20,
index,
value,
needPauseTracking,
inVOnce,
needArraySpread: false,
loc: locStub
};
}
function createBlockStatement(body) {
return {
type: 21,
body,
loc: locStub
};
}
function createTemplateLiteral(elements) {
return {
type: 22,
elements,
loc: locStub
};
}
function createIfStatement(test, consequent, alternate) {
return {
type: 23,
test,
consequent,
alternate,
loc: locStub
};
}
function createAssignmentExpression(left, right) {
return {
type: 24,
left,
right,
loc: locStub
};
}
function createSequenceExpression(expressions) {
return {
type: 25,
expressions,
loc: locStub
};
}
function createReturnStatement(returns) {
return {
type: 26,
returns,
loc: locStub
};
}
function getVNodeHelper(ssr, isComponent$1) {
return ssr || isComponent$1 ? CREATE_VNODE : CREATE_ELEMENT_VNODE;
}
function getVNodeBlockHelper(ssr, isComponent$1) {
return ssr || isComponent$1 ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK;
}
function convertToBlock(node, {
helper,
removeHelper,
inSSR
}) {
if (!node.isBlock) {
node.isBlock = true;
removeHelper(getVNodeHelper(inSSR, node.isComponent));
helper(OPEN_BLOCK);
helper(getVNodeBlockHelper(inSSR, node.isComponent));
}
}
function isTagStartChar(c) {
return c >= 97 && c <= 122 || c >= 65 && c <= 90;
}
function isWhitespace(c) {
return c === 32 || c === 10 || c === 9 || c === 12 || c === 13;
}
function isEndOfTagSection(c) {
return c === 47 || c === 62 || isWhitespace(c);
}
function toCharCodes(str) {
const ret = new Uint8Array(str.length);
for (let i = 0; i < str.length; i++) ret[i] = str.charCodeAt(i);
return ret;
}
function getCompatValue(key, {
compatConfig
}) {
const value = compatConfig && compatConfig[key];
if (key === "MODE") return value || 3;else return value;
}
function isCompatEnabled(key, context) {
const mode = getCompatValue("MODE", context);
const value = getCompatValue(key, context);
return mode === 3 ? value === true : value !== false;
}
function checkCompatEnabled(key, context, loc, ...args) {
return isCompatEnabled(key, context);
}
function warnDeprecation(key, context, loc, ...args) {
if (getCompatValue(key, context) === "suppress-warning") return;
const {
message,
link
} = deprecationData[key];
const msg = `(deprecation ${key}) ${typeof message === "function" ? message(...args) : message}${link ? `
Details: ${link}` : ``}`;
const err = new SyntaxError(msg);
err.code = key;
if (loc) err.loc = loc;
context.onWarn(err);
}
function defaultOnError(error) {
throw error;
}
function defaultOnWarn(msg) {}
function createCompilerError(code, loc, messages, additionalMessage) {
const msg = `https://vuejs.org/error-reference/#compiler-${code}`;
const error = new SyntaxError(String(msg));
error.code = code;
error.loc = loc;
return error;
}
function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */Object.create(null)) {}
function isReferencedIdentifier(id, 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 isInNewExpression(parentStack) {
let i = parentStack.length;
while (i--) {
const p = parentStack[i];
if (p.type === "NewExpression") return true;else if (p.type !== "MemberExpression") 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 unwrapTSNode(node) {
if (TS_NODE_TYPES.includes(node.type)) return unwrapTSNode(node.expression);else return node;
}
function isCoreComponent(tag) {
switch (tag) {
case "Teleport":
case "teleport":
return TELEPORT;
case "Suspense":
case "suspense":
return SUSPENSE;
case "KeepAlive":
case "keep-alive":
return KEEP_ALIVE;
case "BaseTransition":
case "base-transition":
return BASE_TRANSITION;
}
}
function advancePositionWithClone(pos, source, numberOfCharacters = source.length) {
return advancePositionWithMutation({
offset: pos.offset,
line: pos.line,
column: pos.column
}, source, numberOfCharacters);
}
function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {
let linesCount = 0;
let lastNewLinePos = -1;
for (let i = 0; i < numberOfCharacters; i++) if (source.charCodeAt(i) === 10) {
linesCount++;
lastNewLinePos = i;
}
pos.offset += numberOfCharacters;
pos.line += linesCount;
pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos;
return pos;
}
function assert(condition, msg) {
if (!condition) throw new Error(msg || `unexpected compiler condition`);
}
function findDir(node, name, allowEmpty = false) {
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 7 && (allowEmpty || p.exp) && (isString(name) ? p.name === name : name.test(p.name))) return p;
}
}
function findProp(node, name, dynamicOnly = false, allowEmpty = false) {
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 6) {
if (dynamicOnly) continue;
if (p.name === name && (p.value || allowEmpty)) return p;
} else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) return p;
}
}
function isStaticArgOf(arg, name) {
return !!(arg && isStaticExp(arg) && arg.content === name);
}
function hasDynamicKeyVBind(node) {
return node.props.some(p => p.type === 7 && p.name === "bind" && (!p.arg || p.arg.type !== 4 || !p.arg.isStatic));
}
function isText$1(node) {
return node.type === 5 || node.type === 2;
}
function isVSlot(p) {
return p.type === 7 && p.name === "slot";
}
function isTemplateNode(node) {
return node.type === 1 && node.tagType === 3;
}
function isSlotOutlet(node) {
return node.type === 1 && node.tagType === 2;
}
function getUnnormalizedProps(props, callPath = []) {
if (props && !isString(props) && props.type === 14) {
const callee = props.callee;
if (!isString(callee) && propsHelperSet.has(callee)) return getUnnormalizedProps(props.arguments[0], callPath.concat(props));
}
return [props, callPath];
}
function injectProp(node, prop, context) {
let propsWithInjection;
let props = node.type === 13 ? node.props : node.arguments[2];
let callPath = [];
let parentCall;
if (props && !isString(props) && props.type === 14) {
const ret = getUnnormalizedProps(props);
props = ret[0];
callPath = ret[1];
parentCall = callPath[callPath.length - 1];
}
if (props == null || isString(props)) propsWithInjection = createObjectExpression([prop]);else if (props.type === 14) {
const first = props.arguments[0];
if (!isString(first) && first.type === 15) {
if (!hasProp(prop, first)) first.properties.unshift(prop);
} else if (props.callee === TO_HANDLERS) propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [createObjectExpression([prop]), props]);else props.arguments.unshift(createObjectExpression([prop]));
!propsWithInjection && (propsWithInjection = props);
} else if (props.type === 15) {
if (!hasProp(prop, props)) props.properties.unshift(prop);
propsWithInjection = props;
} else {
propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [createObjectExpression([prop]), props]);
if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) parentCall = callPath[callPath.length - 2];
}
if (node.type === 13) {
if (parentCall) parentCall.arguments[0] = propsWithInjection;else node.props = propsWithInjection;
} else if (parentCall) parentCall.arguments[0] = propsWithInjection;else node.arguments[2] = propsWithInjection;
}
function hasProp(prop, props) {
let result = false;
if (prop.key.type === 4) {
const propKeyName = prop.key.content;
result = props.properties.some(p => p.key.type === 4 && p.key.content === propKeyName);
}
return result;
}
function toValidAssetId(name, type) {
return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
})}`;
}
function hasScopeRef(node, ids) {
if (!node || Object.keys(ids).length === 0) return false;
switch (node.type) {
case 1:
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 7 && (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) return true;
}
return node.children.some(c => hasScopeRef(c, ids));
case 11:
if (hasScopeRef(node.source, ids)) return true;
return node.children.some(c => hasScopeRef(c, ids));
case 9:
return node.branches.some(b => hasScopeRef(b, ids));
case 10:
if (hasScopeRef(node.condition, ids)) return true;
return node.children.some(c => hasScopeRef(c, ids));
case 4:
return !node.isStatic && isSimpleIdentifier(node.content) && !!ids[node.content];
case 8:
return node.children.some(c => isObject(c) && hasScopeRef(c, ids));
case 5:
case 12:
return hasScopeRef(node.content, ids);
case 2:
case 3:
case 20:
return false;
default:
return false;
}
}
function getMemoedVNodeCall(node) {
if (node.type === 14 && node.callee === WITH_MEMO) return node.arguments[1].returns;else return node;
}
function parseForExpression(input) {
const loc = input.loc;
const exp = input.content;
const inMatch = exp.match(forAliasRE);
if (!inMatch) return;
const [, LHS, RHS] = inMatch;
const createAliasExpression = (content, offset, asParam = false) => {
const start = loc.start.offset + offset;
return createExp(content, false, getLoc(start, start + content.length), 0, asParam ? 1 : 0);
};
const result = {
source: createAliasExpression(RHS.trim(), exp.indexOf(RHS, LHS.length)),
value: void 0,
key: void 0,
index: void 0,
finalized: false
};
let valueContent = LHS.trim().replace(stripParensRE, "").trim();
const trimmedOffset = LHS.indexOf(valueContent);
const iteratorMatch = valueContent.match(forIteratorRE);
if (iteratorMatch) {
valueContent = valueContent.replace(forIteratorRE, "").trim();
const keyContent = iteratorMatch[1].trim();
let keyOffset;
if (keyContent) {
keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
result.key = createAliasExpression(keyContent, keyOffset, true);
}
if (iteratorMatch[2]) {
const indexContent = iteratorMatch[2].trim();
if (indexContent) result.index = createAliasExpression(indexContent, exp.indexOf(indexContent, result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length), true);
}
}
if (valueContent) result.value = createAliasExpression(valueContent, trimmedOffset, true);
return result;
}
function getSlice(start, end) {
return currentInput.slice(start, end);
}
function endOpenTag(end) {
if (tokenizer.inSFCRoot) currentOpenTag.innerLoc = getLoc(end + 1, end + 1);
addNode(currentOpenTag);
const {
tag,
ns
} = currentOpenTag;
if (ns === 0 && currentOptions.isPreTag(tag)) inPre++;
if (currentOptions.isVoidTag(tag)) onCloseTag(currentOpenTag, end);else {
stack.unshift(currentOpenTag);
if (ns === 1 || ns === 2) tokenizer.inXML = true;
}
currentOpenTag = null;
}
function onText(content, start, end) {
{
const tag = stack[0] && stack[0].tag;
if (tag !== "script" && tag !== "style" && content.includes("&")) content = currentOptions.decodeEntities(content, false);
}
const parent = stack[0] || currentRoot;
const lastNode = parent.children[parent.children.length - 1];
if (lastNode && lastNode.type === 2) {
lastNode.content += content;
setLocEnd(lastNode.loc, end);
} else parent.children.push({
type: 2,
content,
loc: getLoc(start, end)
});
}
function onCloseTag(el, end, isImplied = false) {
if (isImplied) setLocEnd(el.loc, backTrack(end, 60));else setLocEnd(el.loc, lookAhead(end, 62) + 1);
if (tokenizer.inSFCRoot) {
if (el.children.length) el.innerLoc.end = extend({}, el.children[el.children.length - 1].loc.end);else el.innerLoc.end = extend({}, el.innerLoc.start);
el.innerLoc.source = getSlice(el.innerLoc.start.offset, el.innerLoc.end.offset);
}
const {
tag,
ns,
children
} = el;
if (!inVPre) {
if (tag === "slot") el.tagType = 2;else if (isFragmentTemplate(el)) el.tagType = 3;else if (isComponent(el)) el.tagType = 1;
}
if (!tokenizer.inRCDATA) el.children = condenseWhitespace(children);
if (ns === 0 && currentOptions.isIgnoreNewlineTag(tag)) {
const first = children[0];
if (first && first.type === 2) first.content = first.content.replace(/^\r?\n/, "");
}
if (ns === 0 && currentOptions.isPreTag(tag)) inPre--;
if (currentVPreBoundary === el) {
inVPre = tokenizer.inVPre = false;
currentVPreBoundary = null;
}
if (tokenizer.inXML && (stack[0] ? stack[0].ns : currentOptions.ns) === 0) tokenizer.inXML = false;
{
const props = el.props;
if (!tokenizer.inSFCRoot && isCompatEnabled("COMPILER_NATIVE_TEMPLATE", currentOptions) && el.tag === "template" && !isFragmentTemplate(el)) {
const parent = stack[0] || currentRoot;
const index = parent.children.indexOf(el);
parent.children.splice(index, 1, ...el.children);
}
const inlineTemplateProp = props.find(p => p.type === 6 && p.name === "inline-template");
if (inlineTemplateProp && checkCompatEnabled("COMPILER_INLINE_TEMPLATE", currentOptions, inlineTemplateProp.loc) && el.children.length) inlineTemplateProp.value = {
type: 2,
content: getSlice(el.children[0].loc.start.offset, el.children[el.children.length - 1].loc.end.offset),
loc: inlineTemplateProp.loc
};
}
}
function lookAhead(index, c) {
let i = index;
while (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1) i++;
return i;
}
function backTrack(index, c) {
let i = index;
while (currentInput.charCodeAt(i) !== c && i >= 0) i--;
return i;
}
function isFragmentTemplate({
tag,
props
}) {
if (tag === "template") {
for (let i = 0; i < props.length; i++) if (props[i].type === 7 && specialTemplateDir.has(props[i].name)) return true;
}
return false;
}
function isComponent({
tag,
props
}) {
if (currentOptions.isCustomElement(tag)) return false;
if (tag === "component" || isUpperCase(tag.charCodeAt(0)) || isCoreComponent(tag) || currentOptions.isBuiltInComponent && currentOptions.isBuiltInComponent(tag) || currentOptions.isNativeTag && !currentOptions.isNativeTag(tag)) return true;
for (let i = 0; i < props.length; i++) {
const p = props[i];
if (p.type === 6) {
if (p.name === "is" && p.value) {
if (p.value.content.startsWith("vue:")) return true;else if (checkCompatEnabled("COMPILER_IS_ON_ELEMENT", currentOptions, p.loc)) return true;
}
} else if (p.name === "bind" && isStaticArgOf(p.arg, "is") && checkCompatEnabled("COMPILER_IS_ON_ELEMENT", currentOptions, p.loc)) return true;
}
return false;
}
function isUpperCase(c) {
return c > 64 && c < 91;
}
function condenseWhitespace(nodes, tag) {
const shouldCondense = currentOptions.whitespace !== "preserve";
let removedWhitespace = false;
for (let i = 0; i < nodes.length; i++) {
const node = nodes[i];
if (node.type === 2) if (!inPre) {
if (isAllWhitespace(node.content)) {
const prev = nodes[i - 1] && nodes[i - 1].type;
const next = nodes[i + 1] && nodes[i + 1].type;
if (!prev || !next || shouldCondense && (prev === 3 && (next === 3 || next === 1) || prev === 1 && (next === 3 || next === 1 && hasNewlineChar(node.content)))) {
removedWhitespace = true;
nodes[i] = null;
} else node.content = " ";
} else if (shouldCondense) node.content = condense(node.content);
} else node.content = node.content.replace(windowsNewlineRE, "\n");
}
return removedWhitespace ? nodes.filter(Boolean) : nodes;
}
function isAllWhitespace(str) {
for (let i = 0; i < str.length; i++) if (!isWhitespace(str.charCodeAt(i))) return false;
return true;
}
function hasNewlineChar(str) {
for (let i = 0; i < str.length; i++) {
const c = str.charCodeAt(i);
if (c === 10 || c === 13) return true;
}
return false;
}
function condense(str) {
let ret = "";
let prevCharIsWhitespace = false;
for (let i = 0; i < str.length; i++) if (isWhitespace(str.charCodeAt(i))) {
if (!prevCharIsWhitespace) {
ret += " ";
prevCharIsWhitespace = true;
}
} else {
ret += str[i];
prevCharIsWhitespace = false;
}
return ret;
}
function addNode(node) {
(stack[0] || currentRoot).children.push(node);
}
function getLoc(start, end) {
return {
start: tokenizer.getPos(start),
end: end == null ? end : tokenizer.getPos(end),
source: end == null ? end : getSlice(start, end)
};
}
function cloneLoc(loc) {
return getLoc(loc.start.offset, loc.end.offset);
}
function setLocEnd(loc, end) {
loc.end = tokenizer.getPos(end);
loc.source = getSlice(loc.start.offset, end);
}
function dirToAttr(dir) {
const attr = {
type: 6,
name: dir.rawName,
nameLoc: getLoc(dir.loc.start.offset, dir.loc.start.offset + dir.rawName.length),
value: void 0,
loc: dir.loc
};
if (dir.exp) {
const loc = dir.exp.loc;
if (loc.end.offset < dir.loc.end.offset) {
loc.start.offset--;
loc.start.column--;
loc.end.offset++;
loc.end.column++;
}
attr.value = {
type: 2,
content: dir.exp.content,
loc
};
}
return attr;
}
function createExp(content, isStatic = false, loc, constType = 0, parseMode = 0) {
return createSimpleExpression(content, isStatic, loc, constType);
}
function emitError(code, index, message) {
currentOptions.onError(createCompilerError(code, getLoc(index, index), void 0, message));
}
function reset() {
tokenizer.reset();
currentOpenTag = null;
currentProp = null;
currentAttrValue = "";
currentAttrStartIndex = -1;
currentAttrEndIndex = -1;
stack.length = 0;
}
function baseParse(input, options) {
reset();
currentInput = input;
currentOptions = extend({}, defaultParserOptions);
if (options) {
let key;
for (key in options) if (options[key] != null) currentOptions[key] = options[key];
}
tokenizer.mode = currentOptions.parseMode === "html" ? 1 : currentOptions.parseMode === "sfc" ? 2 : 0;
tokenizer.inXML = currentOptions.ns === 1 || currentOptions.ns === 2;
const delimiters = options && options.delimiters;
if (delimiters) {
tokenizer.delimiterOpen = toCharCodes(delimiters[0]);
tokenizer.delimiterClose = toCharCodes(delimiters[1]);
}
const root = currentRoot = createRoot([], input);
tokenizer.parse(currentInput);
root.loc = getLoc(0, input.length);
root.children = condenseWhitespace(root.children);
currentRoot = null;
return root;
}
function cacheStatic(root, context) {
walk(root, void 0, context, isSingleElementRoot(root, root.children[0]));
}
function isSingleElementRoot(root, child) {
const {
children
} = root;
return children.length === 1 && child.type === 1 && !isSlotOutlet(child);
}
function walk(node, parent, context, doNotHoistNode = false, inFor = false) {
const {
children
} = node;
const toCache = [];
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (child.type === 1 && child.tagType === 0) {
const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
if (constantType > 0) {
if (constantType >= 2) {
child.codegenNode.patchFlag = -1;
toCache.push(child);
continue;
}
} else {
const codegenNode = child.codegenNode;
if (codegenNode.type === 13) {
const flag = codegenNode.patchFlag;
if ((flag === void 0 || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) {
const props = getNodeProps(child);
if (props) codegenNode.props = context.hoist(props);
}
if (codegenNode.dynamicProps) codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps);
}
}
} else if (child.type === 12) {
if ((doNotHoistNode ? 0 : getConstantType(child, context)) >= 2) {
toCache.push(child);
continue;
}
}
if (child.type === 1) {
const isComponent$1 = child.tagType === 1;
if (isComponent$1) context.scopes.vSlot++;
walk(child, node, context, false, inFor);
if (isComponent$1) context.scopes.vSlot--;
} else if (child.type === 11) walk(child, node, context, child.children.length === 1, true);else if (child.type === 9) for (let i2 = 0; i2 < child.branches.length; i2++) walk(child.branches[i2], node, context, child.branches[i2].children.length === 1, inFor);
}
let cachedAsArray = false;
if (toCache.length === children.length && node.type === 1) {
if (node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && isArray(node.codegenNode.children)) {
node.codegenNode.children = getCacheExpression(createArrayExpression(node.codegenNode.children));
cachedAsArray = true;
} else if (node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && !isArray(node.codegenNode.children) && node.codegenNode.children.type === 15) {
const slot = getSlotNode(node.codegenNode, "default");
if (slot) {
slot.returns = getCacheExpression(createArrayExpression(slot.returns));
cachedAsArray = true;
}
} else if (node.tagType === 3 && parent && parent.type === 1 && parent.tagType === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 15) {
const slotName = findDir(node, "slot", true);
const slot = slotName && slotName.arg && getSlotNode(parent.codegenNode, slotName.arg);
if (slot) {
slot.returns = getCacheExpression(createArrayExpression(slot.returns));
cachedAsArray = true;
}
}
}
if (!cachedAsArray) for (const child of toCache) child.codegenNode = context.cache(child.codegenNode);
function getCacheExpression(value) {
const exp = context.cache(value);
if (inFor && context.hmr) exp.needArraySpread = true;
return exp;
}
function getSlotNode(node2, name) {
if (node2.children && !isArray(node2.children) && node2.children.type === 15) {
const slot = node2.children.properties.find(p => p.key === name || p.key.content === name);
return slot && slot.value;
}
}
if (toCache.length && context.transformHoist) context.transformHoist(children, context, node);
}
function getConstantType(node, context) {
const {
constantCache
} = context;
switch (node.type) {
case 1:
if (node.tagType !== 0) return 0;
const cached = constantCache.get(node);
if (cached !== void 0) return cached;
const codegenNode = node.codegenNode;
if (codegenNode.type !== 13) return 0;
if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject" && node.tag !== "math") return 0;
if (codegenNode.patchFlag === void 0) {
let returnType2 = 3;
const generatedPropsType = getGeneratedPropsConstantType(node, context);
if (generatedPropsType === 0) {
constantCache.set(node, 0);
return 0;
}
if (generatedPropsType < returnType2) returnType2 = generatedPropsType;
for (let i = 0; i < node.children.length; i++) {
const childType = getConstantType(node.children[i], context);
if (childType === 0) {
constantCache.set(node, 0);
return 0;
}
if (childType < returnType2) returnType2 = childType;
}
if (returnType2 > 1) for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 7 && p.name === "bind" && p.exp) {
const expType = getConstantType(p.exp, context);
if (expType === 0) {
constantCache.set(node, 0);
return 0;
}
if (expType < returnType2) returnType2 = expType;
}
}
if (codegenNode.isBlock) {
for (let i = 0; i < node.props.length; i++) if (node.props[i].type === 7) {
constantCache.set(node, 0);
return 0;
}
context.removeHelper(OPEN_BLOCK);
context.removeHelper(getVNodeBlockHelper(context.inSSR, codegenNode.isComponent));
codegenNode.isBlock = false;
context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent));
}
constantCache.set(node, returnType2);
return returnType2;
} else {
constantCache.set(node, 0);
return 0;
}
case 2:
case 3:
return 3;
case 9:
case 11:
case 10:
return 0;
case 5:
case 12:
return getConstantType(node.content, context);
case 4:
return node.constType;
case 8:
let returnType = 3;
for (let i = 0; i < node.children.length; i++) {
const child = node.children[i];
if (isString(child) || isSymbol(child)) continue;
const childType = getConstantType(child, context);
if (childType === 0) return 0;else if (childType < returnType) returnType = childType;
}
return returnType;
case 20:
return 2;
default:
return 0;
}
}
function getConstantTypeOfHelperCall(value, context) {
if (value.type === 14 && !isString(value.callee) && allowHoistedHelperSet.has(value.callee)) {
const arg = value.arguments[0];
if (arg.type === 4) return getConstantType(arg, context);else if (arg.type === 14) return getConstantTypeOfHelperCall(arg, context);
}
return 0;
}
function getGeneratedPropsConstantType(node, context) {
let returnType = 3;
const props = getNodeProps(node);
if (props && props.type === 15) {
const {
properties
} = props;
for (let i = 0; i < properties.length; i++) {
const {
key,
value
} = properties[i];
const keyType = getConstantType(key, context);
if (keyType === 0) return keyType;
if (keyType < returnType) returnType = keyType;
let valueType;
if (value.type === 4) valueType = getConstantType(value, context);else if (value.type === 14) valueType = getConstantTypeOfHelperCall(value, context);else valueType = 0;
if (valueType === 0) return valueType;
if (valueType < returnType) returnType = valueType;
}
}
return returnType;
}
function getNodeProps(node) {
const codegenNode = node.codegenNode;
if (codegenNode.type === 13) return codegenNode.props;
}
function createTransformContext(root, {
filename = "",
prefixIdentifiers = false,
hoistStatic = false,
hmr = false,
cacheHandlers = false,
nodeTransforms = [],
directiveTransforms = {},
transformHoist = null,
isBuiltInComponent = NOOP,
isCustomElement = NOOP,
expressionPlugins = [],
scopeId = null,
slotted = true,
ssr = false,
inSSR = false,
ssrCssVars = ``,
bindingMetadata = EMPTY_OBJ,
inline = false,
isTS = false,
onError = defaultOnError,
onWarn = defaultOnWarn,
compatConfig
}) {
const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/);
const context = {
filename,
selfName: nameMatch && capitalize(camelize(nameMatch[1])),
prefixIdentifiers,
hoistStatic,
hmr,
cacheHandlers,
nodeTransforms,
directiveTransforms,
transformHoist,
isBuiltInComponent,
isCustomElement,
expressionPlugins,
scopeId,
slotted,
ssr,
inSSR,
ssrCssVars,
bindingMetadata,
inline,
isTS,
onError,
onWarn,
compatConfig,
root,
helpers: /* @__PURE__ */new Map(),
components: /* @__PURE__ */new Set(),
directives: /* @__PURE__ */new Set(),
hoists: [],
imports: [],
cached: [],
constantCache: /* @__PURE__ */new WeakMap(),
temps: 0,
identifiers: /* @__PURE__ */Object.create(null),
scopes: {
vFor: 0,
vSlot: 0,
vPre: 0,
vOnce: 0
},
parent: null,
grandParent: null,
currentNode: root,
childIndex: 0,
inVOnce: false,
helper(name) {
const count = context.helpers.get(name) || 0;
context.helpers.set(name, count + 1);
return name;
},
removeHelper(name) {
const count = context.helpers.get(name);
if (count) {
const currentCount = count - 1;
if (!currentCount) context.helpers.delete(name);else context.helpers.set(name, currentCount);
}
},
helperString(name) {
return `_${helperNameMap[context.helper(name)]}`;
},
replaceNode(node) {
context.parent.children[context.childIndex] = context.currentNode = node;
},
removeNode(node) {
const list = context.parent.children;
const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1;
if (!node || node === context.currentNode) {
context.currentNode = null;
context.onNodeRemoved();
} else if (context.childIndex > removalIndex) {
context.childIndex--;
context.onNodeRemoved();
}
context.parent.children.splice(removalIndex, 1);
},
onNodeRemoved: NOOP,
addIdentifiers(exp) {},
removeIdentifiers(exp) {},
hoist(exp) {
if (isString(exp)) exp = createSimpleExpression(exp);
context.hoists.push(exp);
const identifier = createSimpleExpression(`_hoisted_${context.hoists.length}`, false, exp.loc, 2);
identifier.hoisted = exp;
return identifier;
},
cache(exp, isVNode = false, inVOnce = false) {
const cacheExp = createCacheExpression(context.cached.length, exp, isVNode, inVOnce);
context.cached.push(cacheExp);
return cacheExp;
}
};
context.filters = /* @__PURE__ */new Set();
return context;
}
function transform(root, options) {
const context = createTransformContext(root, options);
traverseNode(root, context);
if (options.hoistStatic) cacheStatic(root, context);
if (!options.ssr) createRootCodegen(root, context);
root.helpers = /* @__PURE__ */new Set([...context.helpers.keys()]);
root.components = [...context.components];
root.directives = [...context.directives];
root.imports = context.imports;
root.hoists = context.hoists;
root.temps = context.temps;
root.cached = context.cached;
root.transformed = true;
root.filters = [...context.filters];
}
function createRootCodegen(root, context) {
const {
helper
} = context;
const {
children
} = root;
if (children.length === 1) {
const child = children[0];
if (isSingleElementRoot(root, child) && child.codegenNode) {
const codegenNode = child.codegenNode;
if (codegenNode.type === 13) convertToBlock(codegenNode, context);
root.codegenNode = codegenNode;
} else root.codegenNode = child;
} else if (children.length > 1) root.codegenNode = createVNodeCall(context, helper(FRAGMENT), void 0, root.children, 64, void 0, void 0, true, void 0, false);
}
function traverseChildren(parent, context) {
let i = 0;
const nodeRemoved = () => {
i--;
};
for (; i < parent.children.length; i++) {
const child = parent.children[i];
if (isString(child)) continue;
context.grandParent = context.parent;
context.parent = parent;
context.childIndex = i;
context.onNodeRemoved = nodeRemoved;
traverseNode(child, context);
}
}
function traverseNode(node, context) {
context.currentNode = node;
const {
nodeTransforms
} = context;
const exitFns = [];
for (let i2 = 0; i2 < nodeTransforms.length; i2++) {
const onExit = nodeTransforms[i2](node, context);
if (onExit) if (isArray(onExit)) exitFns.push(...onExit);else exitFns.push(onExit);
if (!context.currentNode) return;else node = context.currentNode;
}
switch (node.type) {
case 3:
if (!context.ssr) context.helper(CREATE_COMMENT);
break;
case 5:
if (!context.ssr) context.helper(TO_DISPLAY_STRING);
break;
case 9:
for (let i2 = 0; i2 < node.branches.length; i2++) traverseNode(node.branches[i2], context);
break;
case 10:
case 11:
case 1:
case 0:
traverseChildren(node, context);
break;
}
context.currentNode = node;
let i = exitFns.length;
while (i--) exitFns[i]();
}
function createStructuralDirectiveTransform(name, fn) {
const matches = isString(name) ? n => n === name : n => name.test(n);
return (node, context) => {
if (node.type === 1) {
const {
props
} = node;
if (node.tagType === 3 && props.some(isVSlot)) return;
const exitFns = [];
for (let i = 0; i < props.length; i++) {
const prop = props[i];
if (prop.type === 7 && matches(prop.name)) {
props.splice(i, 1);
i--;
const onExit = fn(node, prop, context);
if (onExit) exitFns.push(onExit);
}
}
return exitFns;
}
};
}
function createCodegenContext(ast, {
mode = "function",
prefixIdentifiers = mode === "module",
sourceMap = false,
filename = `template.vue.html`,
scopeId = null,
optimizeImports = false,
runtimeGlobalName = `Vue`,
runtimeModuleName = `vue`,
ssrRuntimeModuleName = "vue/server-renderer",
ssr = false,
isTS = false,
inSSR = false
}) {
const context = {
mode,
prefixIdentifiers,
sourceMap,
filename,
scopeId,
optimizeImports,
runtimeGlobalName,
runtimeModuleName,
ssrRuntimeModuleName,
ssr,
isTS,
inSSR,
source: ast.source,
code: ``,
column: 1,
line: 1,
offset: 0,
indentLevel: 0,
pure: false,
map: void 0,
helper(key) {
return `_${helperNameMap[key]}`;
},
push(code, newlineIndex = -2, node) {
context.code += code;
},
indent() {
newline(++context.indentLevel);
},
deindent(withoutNewLine = false) {
if (withoutNewLine) --context.indentLevel;else newline(--context.indentLevel);
},
newline() {
newline(context.indentLevel);
}
};
function newline(n) {
context.push("\n" + ` `.repeat(n), 0);
}
return context;
}
function generate(ast, options = {}) {
const context = createCodegenContext(ast, options);
if (options.onContextCreated) options.onContextCreated(context);
const {
mode,
push,
prefixIdentifiers,
indent,
deindent,
newline,
scopeId,
ssr
} = context;
const helpers = Array.from(ast.helpers);
const hasHelpers = helpers.length > 0;
const useWithBlock = !prefixIdentifiers && mode !== "module";
genFunctionPreamble(ast, context);
push(`function ${ssr ? `ssrRender` : `render`}(${(ssr ? ["_ctx", "_push", "_parent", "_attrs"] : ["_ctx", "_cache"]).join(", ")}) {`);
indent();
if (useWithBlock) {
push(`with (_ctx) {`);
indent();
if (hasHelpers) {
push(`const { ${helpers.map(aliasHelper).join(", ")} } = _Vue
`, -1);
newline();
}
}
if (ast.components.length) {
genAssets(ast.components, "component", context);
if (ast.directives.length || ast.temps > 0) newline();
}
if (ast.directives.length) {
genAssets(ast.directives, "directive", context);
if (ast.temps > 0) newline();
}
if (ast.filters && ast.filters.length) {
newline();
genAssets(ast.filters, "filter", context);
newline();
}
if (ast.temps > 0) {
push(`let `);
for (let i = 0; i < ast.temps; i++) push(`${i > 0 ? `, ` : ``}_temp${i}`);
}
if (ast.components.length || ast.directives.length || ast.temps) {
push(`
`, 0);
newline();
}
if (!ssr) push(`return `);
if (ast.codegenNode) genNode(ast.codegenNode, context);else push(`null`);
if (useWithBlock) {
deindent();
push(`}`);
}
deindent();
push(`}`);
return {
ast,
code: context.code,
preamble: ``,
map: context.map ? context.map.toJSON() : void 0
};
}
function genFunctionPreamble(ast, context) {
const {
ssr,
prefixIdentifiers,
push,
newline,
runtimeModuleName,
runtimeGlobalName,
ssrRuntimeModuleName
} = context;
const VueBinding = runtimeGlobalName;
const helpers = Array.from(ast.helpers);
if (helpers.length > 0) {
push(`const _Vue = ${VueBinding}
`, -1);
if (ast.hoists.length) push(`const { ${[CREATE_VNODE, CREATE_ELEMENT_VNODE, CREATE_COMMENT, CREATE_TEXT, CREATE_STATIC].filter(helper => helpers.includes(helper)).map(aliasHelper).join(", ")} } = _Vue
`, -1);
}
genHoists(ast.hoists, context);
newline();
push(`return `);
}
function genAssets(assets, type, {
helper,
push,
newline,
isTS
}) {
const resolver = helper(type === "filter" ? RESOLVE_FILTER : type === "component" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE);
for (let i = 0; i < assets.length; i++) {
let id = assets[i];
const maybeSelfReference = id.endsWith("__self");
if (maybeSelfReference) id = id.slice(0, -6);
push(`const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}`);
if (i < assets.length - 1) newline();
}
}
function genHoists(hoists, context) {
if (!hoists.length) return;
context.pure = true;
const {
push,
newline
} = context;
newline();
for (let i = 0; i < hoists.length; i++) {
const exp = hoists[i];
if (exp) {
push(`const _hoisted_${i + 1} = `);
genNode(exp, context);
newline();
}
}
context.pure = false;
}
function genNodeListAsArray(nodes, context) {
const multilines = nodes.length > 3 || false;
context.push(`[`);
multilines && context.indent();
genNodeList(nodes, context, multilines);
multilines && context.deindent();
context.push(`]`);
}
function genNodeList(nodes, context, multilines = false, comma = true) {
const {
push,
newline
} = context;
for (let i = 0; i < nodes.length; i++) {
const node = nodes[i];
if (isString(node)) push(node, -3);else if (isArray(node)) genNodeListAsArray(node, context);else genNode(node, context);
if (i < nodes.length - 1) if (multilines) {
comma && push(",");
newline();
} else comma && push(", ");
}
}
function genNode(node, context) {
if (isString(node)) {
context.push(node, -3);
return;
}
if (isSymbol(node)) {
context.push(context.helper(node));
return;
}
switch (node.type) {
case 1:
case 9:
case 11:
genNode(node.codegenNode, context);
break;
case 2:
genText(node, context);
break;
case 4:
genExpression(node, context);
break;
case 5:
genInterpolation(node, context);
break;
case 12:
genNode(node.codegenNode, context);
break;
case 8:
genCompoundExpression(node, context);
break;
case 3:
genComment(node, context);
break;
case 13:
genVNodeCall(node, context);
break;
case 14:
genCallExpression(node, context);
break;
case 15:
genObjectExpression(node, context);
break;
case 17:
genArrayExpression(node, context);
break;
case 18:
genFunctionExpression(node, context);
break;
case 19:
genConditionalExpression(node, context);
break;
case 20:
genCacheExpression(node, context);
break;
case 21:
genNodeList(node.body, context, true, false);
break;
case 22:
break;
case 23:
break;
case 24:
break;
case 25:
break;
case 26:
break;
case 10:
break;
default:
}
}
function genText(node, context) {
context.push(JSON.stringify(node.content), -3, node);
}
function genExpression(node, context) {
const {
content,
isStatic
} = node;
context.push(isStatic ? JSON.stringify(content) : content, -3, node);
}
function genInterpolation(node, context) {
const {
push,
helper,
pure
} = context;
if (pure) push(PURE_ANNOTATION);
push(`${helper(TO_DISPLAY_STRING)}(`);
genNode(node.content, context);
push(`)`);
}
function genCompoundExpression(node, context) {
for (let i = 0; i < node.children.length; i++) {
const child = node.children[i];
if (isString(child)) context.push(child, -3);else genNode(child, context);
}
}
function genExpressionAsPropertyKey(node, context) {
const {
push
} = context;
if (node.type === 8) {
push(`[`);
genCompoundExpression(node, context);
push(`]`);
} else if (node.isStatic) push(isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content), -2, node);else push(`[${node.content}]`, -3, node);
}
function genComment(node, context) {
const {
push,
helper,
pure
} = context;
if (pure) push(PURE_ANNOTATION);
push(`${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`, -3, node);
}
function genVNodeCall(node, context) {
const {
push,
helper,
pure
} = context;
const {
tag,
props,
children,
patchFlag,
dynamicProps,
directives,
isBlock,
disableTracking,
isComponent: isComponent$1
} = node;
let patchFlagString;
if (patchFlag) patchFlagString = String(patchFlag);
if (directives) push(helper(WITH_DIRECTIVES) + `(`);
if (isBlock) push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `);
if (pure) push(PURE_ANNOTATION);
push(helper(isBlock ? getVNodeBlockHelper(context.inSSR, isComponent$1) : getVNodeHelper(context.inSSR, isComponent$1)) + `(`, -2, node);
genNodeList(genNullableArgs([tag, props, children, patchFlagString, dynamicProps]), context);
push(`)`);
if (isBlock) push(`)`);
if (directives) {
push(`, `);
genNode(directives, context);
push(`)`);
}
}
function genNullableArgs(args) {
let i = args.length;
while (i--) if (args[i] != null) break;
return args.slice(0, i + 1).map(arg => arg || `null`);
}
function genCallExpression(node, context) {
const {
push,
helper,
pure
} = context;
const callee = isString(node.callee) ? node.callee : helper(node.callee);
if (pure) push(PURE_ANNOTATION);
push(callee + `(`, -2, node);
genNodeList(node.arguments, context);
push(`)`);
}
function genObjectExpression(node, context) {
const {
push,
indent,
deindent,
newline
} = context;
const {
properties
} = node;
if (!properties.length) {
push(`{}`, -2, node);
return;
}
const multilines = properties.length > 1 || false;
push(multilines ? `{` : `{ `);
multilines && indent();
for (let i = 0; i < properties.length; i++) {
const {
key,
value
} = properties[i];
genExpressionAsPropertyKey(key, context);
push(`: `);
genNode(value, context);
if (i < properties.length - 1) {
push(`,`);
newline();
}
}
multilines && deindent();
push(multilines ? `}` : ` }`);
}
function genArrayExpression(node, context) {
genNodeListAsArray(node.elements, context);
}
function genFunctionExpression(node, context) {
const {
push,
indent,
deindent
} = context;
const {
params,
returns,
body,
newline,
isSlot
} = node;
if (isSlot) push(`_${helperNameMap[WITH_CTX]}(`);
push(`(`, -2, node);
if (isArray(params)) genNodeList(params, context);else if (params) genNode(params, context);
push(`) => `);
if (newline || body) {
push(`{`);
indent();
}
if (returns) {
if (newline) push(`return `);
if (isArray(returns)) genNodeListAsArray(returns, context);else genNode(returns, context);
} else if (body) genNode(body, context);
if (newline || body) {
deindent();
push(`}`);
}
if (isSlot) {
if (node.isNonScopedSlot) push(`, undefined, true`);
push(`)`);
}
}
function genConditionalExpression(node, context) {
const {
test,
consequent,
alternate,
newline: needNewline
} = node;
const {
push,
indent,
deindent,
newline
} = context;
if (test.type === 4) {
const needsParens = !isSimpleIdentifier(test.content);
needsParens && push(`(`);
genExpression(test, context);
needsParens && push(`)`);
} else {
push(`(`);
genNode(test, context);
push(`)`);
}
needNewline && indent();
context.indentLevel++;
needNewline || push(` `);
push(`? `);
genNode(consequent, context);
context.indentLevel--;
needNewline && newline();
needNewline || push(` `);
push(`: `);
const isNested = alternate.type === 19;
if (!isNested) context.indentLevel++;
genNode(alternate, context);
if (!isNested) context.indentLevel--;
needNewline && deindent(true);
}
function genCacheExpression(node, context) {
const {
push,
helper,
indent,
deindent,
newline
} = context;
const {
needPauseTracking,
needArraySpread
} = node;
if (needArraySpread) push(`[...(`);
push(`_cache[${node.index}] || (`);
if (needPauseTracking) {
indent();
push(`${helper(SET_BLOCK_TRACKING)}(-1`);
if (node.inVOnce) push(`, true`);
push(`),`);
newline();
push(`(`);
}
push(`_cache[${node.index}] = `);
genNode(node.value, context);
if (needPauseTracking) {
push(`).cacheIndex = ${node.index},`);
newline();
push(`${helper(SET_BLOCK_TRACKING)}(1),`);
newline();
push(`_cache[${node.index}]`);
deindent();
}
push(`)`);
if (needArraySpread) push(`)]`);
}
function processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) {
return node;
}
function stringifyExpression(exp) {
if (isString(exp)) return exp;else if (exp.type === 4) return exp.content;else return exp.children.map(stringifyExpression).join("");
}
function processIf(node, dir, context, processCodegen) {
if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) {
const loc = dir.exp ? dir.exp.loc : node.loc;
context.onError(createCompilerError(28, dir.loc));
dir.exp = createSimpleExpression(`true`, false, loc);
}
if (dir.name === "if") {
const branch = createIfBranch(node, dir);
const ifNode = {
type: 9,
loc: cloneLoc(node.loc),
branches: [branch]
};
context.replaceNode(ifNode);
if (processCodegen) return processCodegen(ifNode, branch, true);
} else {
const siblings = context.parent.children;
let i = siblings.indexOf(node);
while (i-- >= -1) {
const sibling = siblings[i];
if (sibling && sibling.type === 3) {
context.removeNode(sibling);
continue;
}
if (sibling && sibling.type === 2 && !sibling.content.trim().length) {
context.removeNode(sibling);
continue;
}
if (sibling && sibling.type === 9) {
if (dir.name === "else-if" && sibling.branches[sibling.branches.length - 1].condition === void 0) context.onError(createCompilerError(30, node.loc));
context.removeNode();
const branch = createIfBranch(node, dir);
sibling.branches.push(branch);
const onExit = processCodegen && processCodegen(sibling, branch, false);
traverseNode(branch, context);
if (onExit) onExit();
context.currentNode = null;
} else context.onError(createCompilerError(30, node.loc));
break;
}
}
}
function createIfBranch(node, dir) {
const isTemplateIf = node.tagType === 3;
return {
type: 10,
loc: node.loc,
condition: dir.name === "else" ? void 0 : dir.exp,
children: isTemplateIf && !findDir(node, "for") ? node.children : [node],
userKey: findProp(node, `key`),
isTemplateIf
};
}
function createCodegenNodeForBranch(branch, keyIndex, context) {
if (branch.condition) return createConditionalExpression(branch.condition, createChildrenCodegenNode(branch, keyIndex, context), createCallExpression(context.helper(CREATE_COMMENT), ["\"\"", "true"]));else return createChildrenCodegenNode(branch, keyIndex, context);
}
function createChildrenCodegenNode(branch, keyIndex, context) {
const {
helper
} = context;
const keyProperty = createObjectProperty(`key`, createSimpleExpression(`${keyIndex}`, false, locStub, 2));
const {
children
} = branch;
const firstChild = children[0];
if (children.length !== 1 || firstChild.type !== 1) {
if (children.length === 1 && firstChild.type === 11) {
const vnodeCall = firstChild.codegenNode;
injectProp(vnodeCall, keyProperty, context);
return vnodeCall;
} else return createVNodeCall(context, helper(FRAGMENT), createObjectExpression([keyProperty]), children, 64, void 0, void 0, true, false, false, branch.loc);
} else {
const ret = firstChild.codegenNode;
const vnodeCall = getMemoedVNodeCall(ret);
if (vnodeCall.type === 13) convertToBlock(vnodeCall, context);
injectProp(vnodeCall, keyProperty, context);
return ret;
}
}
function getParentCondition(node) {
while (true) if (node.type === 19) {
if (node.alternate.type === 19) node = node.alternate;else return node;
} else if (node.type === 20) node = node.value;
}
function processFor(node, dir, context, processCodegen) {
if (!dir.exp) {
context.onError(createCompilerError(31, dir.loc));
return;
}
const parseResult = dir.forParseResult;
if (!parseResult) {
context.onError(createCompilerError(32, dir.loc));
return;
}
finalizeForParseResult(parseResult, context);
const {
addIdentifiers,
removeIdentifiers,
scopes
} = context;
const {
source,
value,
key,
index
} = parseResult;
const forNode = {
type: 11,
loc: dir.loc,
source,
valueAlias: value,
keyAlias: key,
objectIndexAlias: index,
parseResult,
children: isTemplateNode(node) ? node.children : [node]
};
context.replaceNode(forNode);
scopes.vFor++;
const onExit = processCodegen && processCodegen(forNode);
return () => {
scopes.vFor--;
if (onExit) onExit();
};
}
function finalizeForParseResult(result, context) {
if (result.finalized) return;
result.finalized = true;
}
function createForLoopParams({
value,
key,
index
}, memoArgs = []) {
return createParamsList([value, key, index, ...memoArgs]);
}
function createParamsList(args) {
let i = args.length;
while (i--) if (args[i]) break;
return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false));
}
function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
context.helper(WITH_CTX);
const {
children,
loc
} = node;
const slotsProperties = [];
const dynamicSlots = [];
let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;
const onComponentSlot = findDir(node, "slot", true);
if (onComponentSlot) {
const {
arg,
exp
} = onComponentSlot;
if (arg && !isStaticExp(arg)) hasDynamicSlots = true;
slotsProperties.push(createObjectProperty(arg || createSimpleExpression("default", true), buildSlotFn(exp, void 0, children, loc)));
}
let hasTemplateSlots = false;
let hasNamedDefaultSlot = false;
const implicitDefaultChildren = [];
const seenSlotNames = /* @__PURE__ */new Set();
let conditionalBranchIndex = 0;
for (let i = 0; i < children.length; i++) {
const slotElement = children[i];
let slotDir;
if (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, "slot", true))) {
if (slotElement.type !== 3) implicitDefaultChildren.push(slotElement);
continue;
}
if (onComponentSlot) {
context.onError(createCompilerError(37, slotDir.loc));
break;
}
hasTemplateSlots = true;
const {
children: slotChildren,
loc: slotLoc
} = slotElement;
const {
arg: slotName = createSimpleExpression(`default`, true),
exp: slotProps,
loc: dirLoc
} = slotDir;
let staticSlotName;
if (isStaticExp(slotName)) staticSlotName = slotName ? slotName.content : `default`;else hasDynamicSlots = true;
const vFor = findDir(slotElement, "for");
const slotFunction = buildSlotFn(slotProps, vFor, slotChildren, slotLoc);
let vIf;
let vElse;
if (vIf = findDir(slotElement, "if")) {
hasDynamicSlots = true;
dynamicSlots.push(createConditionalExpression(vIf.exp, buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++), defaultFallback));
} else if (vElse = findDir(slotElement, /^else(-if)?$/, true)) {
let j = i;
let prev;
while (j--) {
prev = children[j];
if (prev.type !== 3) break;
}
if (prev && isTemplateNode(prev) && findDir(prev, /^(else-)?if$/)) {
let conditional = dynamicSlots[dynamicSlots.length - 1];
while (conditional.alternate.type === 19) conditional = conditional.alternate;
conditional.alternate = vElse.exp ? createConditionalExpression(vElse.exp, buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++), defaultFallback) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++);
} else context.onError(createCompilerError(30, vElse.loc));
} else if (vFor) {
hasDynamicSlots = true;
const parseResult = vFor.forParseResult;
if (parseResult) {
finalizeForParseResult(parseResult, context);
dynamicSlots.push(createCallExpression(context.helper(RENDER_LIST), [parseResult.source, createFunctionExpression(createForLoopParams(parseResult), buildDynamicSlot(slotName, slotFunction), true)]));
} else context.onError(createCompilerError(32, vFor.loc));
} else {
if (staticSlotName) {
if (seenSlotNames.has(staticSlotName)) {
context.onError(createCompilerError(38, dirLoc));
continue;
}
seenSlotNames.add(staticSlotName);
if (staticSlotName === "default") hasNamedDefaultSlot = true;
}
slotsProperties.push(createObjectProperty(slotName, slotFunction));
}
}
if (!onComponentSlot) {
const buildDefaultSlotProperty = (props, children2) => {
const fn = buildSlotFn(props, void 0, children2, loc);
if (context.compatConfig) fn.isNonScopedSlot = true;
return createObjectProperty(`default`, fn);
};
if (!hasTemplateSlots) slotsProperties.push(buildDefaultSlotProperty(void 0, children));else if (implicitDefaultChildren.length && implicitDefaultChildren.some(node2 => isNonWhitespaceContent(node2))) if (hasNamedDefaultSlot) context.onError(createCompilerError(39, implicitDefaultChildren[0].loc));else slotsProperties.push(buildDefaultSlotProperty(void 0, implicitDefaultChildren));
}
const slotFlag = hasDynamicSlots ? 2 : hasForwardedSlots(node.children) ? 3 : 1;
let slots = createObjectExpression(slotsProperties.concat(createObjectProperty(`_`, createSimpleExpression(slotFlag + ``, false))), loc);
if (dynamicSlots.length) slots = createCallExpression(context.helper(CREATE_SLOTS), [slots, createArrayExpression(dynamicSlots)]);
return {
slots,
hasDynamicSlots
};
}
function buildDynamicSlot(name, fn, index) {
const props = [createObjectProperty(`name`, name), createObjectProperty(`fn`, fn)];
if (index != null) props.push(createObjectProperty(`key`, createSimpleExpression(String(index), true)));
return createObjectExpression(props);
}
function hasForwardedSlots(children) {
for (let i = 0; i < children.length; i++) {
const child = children[i];
switch (child.type) {
case 1:
if (child.tagType === 2 || hasForwardedSlots(child.children)) return true;
break;
case 9:
if (hasForwardedSlots(child.branches)) return true;
break;
case 10:
case 11:
if (hasForwardedSlots(child.children)) return true;
break;
}
}
return false;
}
function isNonWhitespaceContent(node) {
if (node.type !== 2 && node.type !== 12) return true;
return node.type === 2 ? !!node.content.trim() : isNonWhitespaceContent(node.content);
}
function resolveComponentType(node, context, ssr = false) {
let {
tag
} = node;
const isExplicitDynamic = isComponentTag(tag);
const isProp = findProp(node, "is", false, true);
if (isProp) {
if (isExplicitDynamic || isCompatEnabled("COMPILER_IS_ON_ELEMENT", context)) {
let exp;
if (isProp.type === 6) exp = isProp.value && createSimpleExpression(isProp.value.content, true);else {
exp = isProp.exp;
if (!exp) exp = createSimpleExpression(`is`, false, isProp.arg.loc);
}
if (exp) return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [exp]);
} else if (isProp.type === 6 && isProp.value.content.startsWith("vue:")) tag = isProp.value.content.slice(4);
}
const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);
if (builtIn) {
if (!ssr) context.helper(builtIn);
return builtIn;
}
context.helper(RESOLVE_COMPONENT);
context.components.add(tag);
return toValidAssetId(tag, `component`);
}
function buildProps(node, context, props = node.props, isComponent$1, isDynamicComponent, ssr = false) {
const {
tag,
loc: elementLoc,
children
} = node;
let properties = [];
const mergeArgs = [];
const runtimeDirectives = [];
const hasChildren = children.length > 0;
let shouldUseBlock = false;
let patchFlag = 0;
let hasRef = false;
let hasClassBinding = false;
let hasStyleBinding = false;
let hasHydrationEventBinding = false;
let hasDynamicKeys = false;
let hasVnodeHook = false;
const dynamicPropNames = [];
const pushMergeArg = arg => {
if (properties.length) {
mergeArgs.push(createObjectExpression(dedupeProperties(properties), elementLoc));
properties = [];
}
if (arg) mergeArgs.push(arg);
};
const pushRefVForMarker = () => {
if (context.scopes.vFor > 0) properties.push(createObjectProperty(createSimpleExpression("ref_for", true), createSimpleExpression("true")));
};
const analyzePatchFlag = ({
key,
value
}) => {
if (isStaticExp(key)) {
const name = key.content;
const isEventHandler = isOn(name);
if (isEventHandler && (!isComponent$1 || isDynamicComponent) && name.toLowerCase() !== "onclick" && name !== "onUpdate:modelValue" && !isReservedProp(name)) hasHydrationEventBinding = true;
if (isEventHandler && isReservedProp(name)) hasVnodeHook = true;
if (isEventHandler && value.type === 14) value = value.arguments[0];
if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) return;
if (name === "ref") hasRef = true;else if (name === "class") hasClassBinding = true;else if (name === "style") hasStyleBinding = true;else if (name !== "key" && !dynamicPropNames.includes(name)) dynamicPropNames.push(name);
if (isComponent$1 && (name === "class" || name === "style") && !dynamicPropNames.includes(name)) dynamicPropNames.push(name);
} else hasDynamicKeys = true;
};
for (let i = 0; i < props.length; i++) {
const prop = props[i];
if (prop.type === 6) {
const {
loc,
name,
nameLoc,
value
} = prop;
let isStatic = true;
if (name === "ref") {
hasRef = true;
pushRefVForMarker();
}
if (name === "is" && (isComponentTag(tag) || value && value.content.startsWith("vue:") || isCompatEnabled("COMPILER_IS_ON_ELEMENT", context))) continue;
properties.push(createObjectProperty(createSimpleExpression(name, true, nameLoc), createSimpleExpression(value ? value.content : "", isStatic, value ? value.loc : loc)));
} else {
const {
name,
arg,
exp,
loc,
modifiers
} = prop;
const isVBind = name === "bind";
const isVOn = name === "on";
if (name === "slot") {
if (!isComponent$1) context.onError(createCompilerError(40, loc));
continue;
}
if (name === "once" || name === "memo") continue;
if (name === "is" || isVBind && isStaticArgOf(arg, "is") && (isComponentTag(tag) || isCompatEnabled("COMPILER_IS_ON_ELEMENT", context))) continue;
if (isVOn && ssr) continue;
if (isVBind && isStaticArgOf(arg, "key") || isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update")) shouldUseBlock = true;
if (isVBind && isStaticArgOf(arg, "ref")) pushRefVForMarker();
if (!arg && (isVBind || isVOn)) {
hasDynamicKeys = true;
if (exp) {
if (isVBind) {
pushRefVForMarker();
pushMergeArg();
if (isCompatEnabled("COMPILER_V_BIND_OBJECT_ORDER", context)) {
mergeArgs.unshift(exp);
continue;
}
mergeArgs.push(exp);
} else pushMergeArg({
type: 14,
loc,
callee: context.helper(TO_HANDLERS),
arguments: isComponent$1 ? [exp] : [exp, `true`]
});
} else context.onError(createCompilerError(isVBind ? 34 : 35, loc));
continue;
}
if (isVBind && modifiers.some(mod => mod.content === "prop")) patchFlag |= 32;
const directiveTransform = context.directiveTransforms[name];
if (directiveTransform) {
const {
props: props2,
needRuntime
} = directiveTransform(prop, node, context);
!ssr && props2.forEach(analyzePatchFlag);
if (isVOn && arg && !isStaticExp(arg)) pushMergeArg(createObjectExpression(props2, elementLoc));else properties.push(...props2);
if (needRuntime) {
runtimeDirectives.push(prop);
if (isSymbol(needRuntime)) directiveImportMap.set(prop, needRuntime);
}
} else if (!isBuiltInDirective(name)) {
runtimeDirectives.push(prop);
if (hasChildren) shouldUseBlock = true;
}
}
}
let propsExpression = void 0;
if (mergeArgs.length) {
pushMergeArg();
if (mergeArgs.length > 1) propsExpression = createCallExpression(context.helper(MERGE_PROPS), mergeArgs, elementLoc);else propsExpression = mergeArgs[0];
} else if (properties.length) propsExpression = createObjectExpression(dedupeProperties(properties), elementLoc);
if (hasDynamicKeys) patchFlag |= 16;else {
if (hasClassBinding && !isComponent$1) patchFlag |= 2;
if (hasStyleBinding && !isComponent$1) patchFlag |= 4;
if (dynamicPropNames.length) patchFlag |= 8;
if (hasHydrationEventBinding) patchFlag |= 32;
}
if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) patchFlag |= 512;
if (!context.inSSR && propsExpression) switch (propsExpression.type) {
case 15:
let classKeyIndex = -1;
let styleKeyIndex = -1;
let hasDynamicKey = false;
for (let i = 0; i < propsExpression.properties.length; i++) {
const key = propsExpression.properties[i].key;
if (isStaticExp(key)) {
if (key.content === "class") classKeyIndex = i;else if (key.content === "style") styleKeyIndex = i;
} else if (!key.isHandlerKey) hasDynamicKey = true;
}
const classProp = propsExpression.properties[classKeyIndex];
const styleProp = propsExpression.properties[styleKeyIndex];
if (!hasDynamicKey) {
if (classProp && !isStaticExp(classProp.value)) classProp.value = createCallExpression(context.helper(NORMALIZE_CLASS), [classProp.value]);
if (styleProp && (hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || styleProp.value.type === 17)) styleProp.value = createCallExpression(context.helper(NORMALIZE_STYLE), [styleProp.value]);
} else propsExpression = createCallExpression(context.helper(NORMALIZE_PROPS), [propsExpression]);
break;
case 14:
break;
default:
propsExpression = createCallExpression(context.helper(NORMALIZE_PROPS), [createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [propsExpression])]);
break;
}
return {
props: propsExpression,
directives: runtimeDirectives,
patchFlag,
dynamicPropNames,
shouldUseBlock
};
}
function dedupeProperties(properties) {
const knownProps = /* @__PURE__ */new Map();
const deduped = [];
for (let i = 0; i < properties.length; i++) {
const prop = properties[i];
if (prop.key.type === 8 || !prop.key.isStatic) {
deduped.push(prop);
continue;
}
const name = prop.key.content;
const existing = knownProps.get(name);
if (existing) {
if (name === "style" || name === "class" || isOn(name)) mergeAsArray(existing, prop);
} else {
knownProps.set(name, prop);
deduped.push(prop);
}
}
return deduped;
}
function mergeAsArray(existing, incoming) {
if (existing.value.type === 17) existing.value.elements.push(incoming.value);else existing.value = createArrayExpression([existing.value, incoming.value], existing.loc);
}
function buildDirectiveArgs(dir, context) {
const dirArgs = [];
const runtime = directiveImportMap.get(dir);
if (runtime) dirArgs.push(context.helperString(runtime));else {
context.helper(RESOLVE_DIRECTIVE);
context.directives.add(dir.name);
dirArgs.push(toValidAssetId(dir.name, `directive`));
}
const {
loc
} = dir;
if (dir.exp) dirArgs.push(dir.exp);
if (dir.arg) {
if (!dir.exp) dirArgs.push(`void 0`);
dirArgs.push(dir.arg);
}
if (Object.keys(dir.modifiers).length) {
if (!dir.arg) {
if (!dir.exp) dirArgs.push(`void 0`);
dirArgs.push(`void 0`);
}
const trueExpression = createSimpleExpression(`true`, false, loc);
dirArgs.push(createObjectExpression(dir.modifiers.map(modifier => createObjectProperty(modifier, trueExpression)), loc));
}
return createArrayExpression(dirArgs, dir.loc);
}
function stringifyDynamicPropNames(props) {
let propsNamesString = `[`;
for (let i = 0, l = props.length; i < l; i++) {
propsNamesString += JSON.stringify(props[i]);
if (i < l - 1) propsNamesString += ", ";
}
return propsNamesString + `]`;
}
function isComponentTag(tag) {
return tag === "component" || tag === "Component";
}
function processSlotOutlet(node, context) {
let slotName = `"default"`;
let slotProps = void 0;
const nonNameProps = [];
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 6) {
if (p.value) if (p.name === "name") slotName = JSON.stringify(p.value.content);else {
p.name = camelize(p.name);
nonNameProps.push(p);
}
} else if (p.name === "bind" && isStaticArgOf(p.arg, "name")) {
if (p.exp) slotName = p.exp;else if (p.arg && p.arg.type === 4) slotName = p.exp = createSimpleExpression(camelize(p.arg.content), false, p.arg.loc);
} else {
if (p.name === "bind" && p.arg && isStaticExp(p.arg)) p.arg.content = camelize(p.arg.content);
nonNameProps.push(p);
}
}
if (nonNameProps.length > 0) {
const {
props,
directives
} = buildProps(node, context, nonNameProps, false, false);
slotProps = props;
if (directives.length) context.onError(createCompilerError(36, directives[0].loc));
}
return {
slotName,
slotProps
};
}
function createTransformProps(props = []) {
return {
props
};
}
function rewriteFilter(node, context) {
if (node.type === 4) parseFilter(node, context);else for (let i = 0; i < node.children.length; i++) {
const child = node.children[i];
if (typeof child !== "object") continue;
if (child.type === 4) parseFilter(child, context);else if (child.type === 8) rewriteFilter(node, context);else if (child.type === 5) rewriteFilter(child.content, context);
}
}
function parseFilter(node, context) {
const exp = node.content;
let inSingle = false;
let inDouble = false;
let inTemplateString = false;
let inRegex = false;
let curly = 0;
let square = 0;
let paren = 0;
let lastFilterIndex = 0;
let c,
prev,
i,
expression,
filters = [];
for (i = 0; i < exp.length; i++) {
prev = c;
c = exp.charCodeAt(i);
if (inSingle) {
if (c === 39 && prev !== 92) inSingle = false;
} else if (inDouble) {
if (c === 34 && prev !== 92) inDouble = false;
} else if (inTemplateString) {
if (c === 96 && prev !== 92) inTemplateString = false;
} else if (inRegex) {
if (c === 47 && prev !== 92) inRegex = false;
} else if (c === 124 && exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) {
if (expression === void 0) {
lastFilterIndex = i + 1;
expression = exp.slice(0, i).trim();
} else pushFilter();
} else {
switch (c) {
case 34:
inDouble = true;
break;
case 39:
inSingle = true;
break;
case 96:
inTemplateString = true;
break;
case 40:
paren++;
break;
case 41:
paren--;
break;
case 91:
square++;
break;
case 93:
square--;
break;
case 123:
curly++;
break;
case 125:
curly--;
break;
}
if (c === 47) {
let j = i - 1;
let p;
for (; j >= 0; j--) {
p = exp.charAt(j);
if (p !== " ") break;
}
if (!p || !validDivisionCharRE.test(p)) inRegex = true;
}
}
}
if (expression === void 0) expression = exp.slice(0, i).trim();else if (lastFilterIndex !== 0) pushFilter();
function pushFilter() {
filters.push(exp.slice(lastFilterIndex, i).trim());
lastFilterIndex = i + 1;
}
if (filters.length) {
for (i = 0; i < filters.length; i++) expression = wrapFilter(expression, filters[i], context);
node.content = expression;
node.ast = void 0;
}
}
function wrapFilter(exp, filter, context) {
context.helper(RESOLVE_FILTER);
const i = filter.indexOf("(");
if (i < 0) {
context.filters.add(filter);
return `${toValidAssetId(filter, "filter")}(${exp})`;
} else {
const name = filter.slice(0, i);
const args = filter.slice(i + 1);
context.filters.add(name);
return `${toValidAssetId(name, "filter")}(${exp}${args !== ")" ? "," + args : args}`;
}
}
function getBaseTransformPreset(prefixIdentifiers) {
return [[transformOnce, transformIf, transformMemo, transformFor, ...[transformFilter], ...[], transformSlotOutlet, transformElement, trackSlotScopes, transformText], {
on: transformOn,
bind: transformBind,
model: transformModel
}];
}
function baseCompile(source, options = {}) {
const onError = options.onError || defaultOnError;
const isModuleMode = options.mode === "module";
if (options.prefixIdentifiers === true) onError(createCompilerError(47));else if (isModuleMode) onError(createCompilerError(48));
const prefixIdentifiers = false;
if (options.cacheHandlers) onError(createCompilerError(49));
if (options.scopeId && !isModuleMode) onError(createCompilerError(50));
const resolvedOptions = extend({}, options, {
prefixIdentifiers
});
const ast = isString(source) ? baseParse(source, resolvedOptions) : source;
const [nodeTransforms, directiveTransforms] = getBaseTransformPreset();
transform(ast, extend({}, resolvedOptions, {
nodeTransforms: [...nodeTransforms, ...(options.nodeTransforms || [])],
directiveTransforms: extend({}, directiveTransforms, options.directiveTransforms || {})
}));
return generate(ast, resolvedOptions);
}
function decodeHtmlBrowser(raw, asAttr = false) {
if (!decoder) decoder = document.createElement("div");
if (asAttr) {
decoder.innerHTML = `<div foo="${raw.replace(/"/g, """)}">`;
return decoder.children[0].getAttribute("foo");
} else {
decoder.innerHTML = raw;
return decoder.textContent;
}
}
function createDOMCompilerError(code, loc) {
return createCompilerError(code, loc, void 0);
}
function compile(src, options = {}) {
return baseCompile(src, extend({}, parserOptions, options, {
nodeTransforms: [ignoreSideEffectTags, ...DOMNodeTransforms, ...(options.nodeTransforms || [])],
directiveTransforms: extend({}, DOMDirectiveTransforms, options.directiveTransforms || {}),
transformHoist: null
}));
}
function parse(template, options = {}) {
return baseParse(template, extend({}, parserOptions, options));
}
return {
setters: [function (_chunkLegacy001Js) {
__toCommonJS = _chunkLegacy001Js.a;
__esm = _chunkLegacy001Js.n;
__export = _chunkLegacy001Js.r;
__commonJS = _chunkLegacy001Js.t;
}, function (_vueRuntimeEsmBundlerLegacy003Js) {
NOOP = _vueRuntimeEsmBundlerLegacy003Js.Jt;
EMPTY_OBJ = _vueRuntimeEsmBundlerLegacy003Js.Kt;
generateCodeFrame = _vueRuntimeEsmBundlerLegacy003Js.Qt;
shared_esm_bundler_exports = _vueRuntimeEsmBundlerLegacy003Js.Sn;
capitalize = _vueRuntimeEsmBundlerLegacy003Js.Xt;
camelize = _vueRuntimeEsmBundlerLegacy003Js.Yt;
extend = _vueRuntimeEsmBundlerLegacy003Js.Zt;
makeMap = _vueRuntimeEsmBundlerLegacy003Js._n;
init_runtime_dom_esm_bundler = _vueRuntimeEsmBundlerLegacy003Js.a;
isObject = _vueRuntimeEsmBundlerLegacy003Js.cn;
isReservedProp = _vueRuntimeEsmBundlerLegacy003Js.fn;
isVoidTag = _vueRuntimeEsmBundlerLegacy003Js.gn;
isSymbol = _vueRuntimeEsmBundlerLegacy003Js.hn;
isOn = _vueRuntimeEsmBundlerLegacy003Js.ln;
isString = _vueRuntimeEsmBundlerLegacy003Js.mn;
isArray = _vueRuntimeEsmBundlerLegacy003Js.nn;
isHTMLTag = _vueRuntimeEsmBundlerLegacy003Js.on;
isSVGTag = _vueRuntimeEsmBundlerLegacy003Js.pn;
NO = _vueRuntimeEsmBundlerLegacy003Js.qt;
isBuiltInDirective = _vueRuntimeEsmBundlerLegacy003Js.rn;
runtime_dom_esm_bundler_exports = _vueRuntimeEsmBundlerLegacy003Js.s;
isMathMLTag = _vueRuntimeEsmBundlerLegacy003Js.sn;
init_shared_esm_bundler = _vueRuntimeEsmBundlerLegacy003Js.tn;
toHandlerKey = _vueRuntimeEsmBundlerLegacy003Js.wn;
parseStringStyle = _vueRuntimeEsmBundlerLegacy003Js.xn;
}],
execute: function () {
init_compiler_core_esm_bundler = __esm({
"../../../node_modules/.pnpm/@vue+compiler-core@3.5.13/node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js": () => {
init_shared_esm_bundler();
FRAGMENT = Symbol(``);
TELEPORT = Symbol(``);
SUSPENSE = Symbol(``);
KEEP_ALIVE = Symbol(``);
BASE_TRANSITION = Symbol(``);
OPEN_BLOCK = Symbol(``);
CREATE_BLOCK = Symbol(``);
CREATE_ELEMENT_BLOCK = Symbol(``);
CREATE_VNODE = Symbol(``);
CREATE_ELEMENT_VNODE = Symbol(``);
CREATE_COMMENT = Symbol(``);
CREATE_TEXT = Symbol(``);
CREATE_STATIC = Symbol(``);
RESOLVE_COMPONENT = Symbol(``);
RESOLVE_DYNAMIC_COMPONENT = Symbol(``);
RESOLVE_DIRECTIVE = Symbol(``);
RESOLVE_FILTER = Symbol(``);
WITH_DIRECTIVES = Symbol(``);
RENDER_LIST = Symbol(``);
RENDER_SLOT = Symbol(``);
CREATE_SLOTS = Symbol(``);
TO_DISPLAY_STRING = Symbol(``);
MERGE_PROPS = Symbol(``);
NORMALIZE_CLASS = Symbol(``);
NORMALIZE_STYLE = Symbol(``);
NORMALIZE_PROPS = Symbol(``);
GUARD_REACTIVE_PROPS = Symbol(``);
TO_HANDLERS = Symbol(``);
CAMELIZE = Symbol(``);
CAPITALIZE = Symbol(``);
TO_HANDLER_KEY = Symbol(``);
SET_BLOCK_TRACKING = Symbol(``);
PUSH_SCOPE_ID = Symbol(``);
POP_SCOPE_ID = Symbol(``);
WITH_CTX = Symbol(``);
UNREF = Symbol(``);
IS_REF = Symbol(``);
WITH_MEMO = Symbol(``);
IS_MEMO_SAME = Symbol(``);
helperNameMap = {
[FRAGMENT]: `Fragment`,
[TELEPORT]: `Teleport`,
[SUSPENSE]: `Suspense`,
[KEEP_ALIVE]: `KeepAlive`,
[BASE_TRANSITION]: `BaseTransition`,
[OPEN_BLOCK]: `openBlock`,
[CREATE_BLOCK]: `createBlock`,
[CREATE_ELEMENT_BLOCK]: `createElementBlock`,
[CREATE_VNODE]: `createVNode`,
[CREATE_ELEMENT_VNODE]: `createElementVNode`,
[CREATE_COMMENT]: `createCommentVNode`,
[CREATE_TEXT]: `createTextVNode`,
[CREATE_STATIC]: `createStaticVNode`,
[RESOLVE_COMPONENT]: `resolveComponent`,
[RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`,
[RESOLVE_DIRECTIVE]: `resolveDirective`,
[RESOLVE_FILTER]: `resolveFilter`,
[WITH_DIRECTIVES]: `withDirectives`,
[RENDER_LIST]: `renderList`,
[RENDER_SLOT]: `renderSlot`,
[CREATE_SLOTS]: `createSlots`,
[TO_DISPLAY_STRING]: `toDisplayString`,
[MERGE_PROPS]: `mergeProps`,
[NORMALIZE_CLASS]: `normalizeClass`,
[NORMALIZE_STYLE]: `normalizeStyle`,
[NORMALIZE_PROPS]: `normalizeProps`,
[GUARD_REACTIVE_PROPS]: `guardReactiveProps`,
[TO_HANDLERS]: `toHandlers`,
[CAMELIZE]: `camelize`,
[CAPITALIZE]: `capitalize`,
[TO_HANDLER_KEY]: `toHandlerKey`,
[SET_BLOCK_TRACKING]: `setBlockTracking`,
[PUSH_SCOPE_ID]: `pushScopeId`,
[POP_SCOPE_ID]: `popScopeId`,
[WITH_CTX]: `withCtx`,
[UNREF]: `unref`,
[IS_REF]: `isRef`,
[WITH_MEMO]: `withMemo`,
[IS_MEMO_SAME]: `isMemoSame`
};
Namespaces = {
"HTML": 0,
"0": "HTML",
"SVG": 1,
"1": "SVG",
"MATH_ML": 2,
"2": "MATH_ML"
};
NodeTypes = {
"ROOT": 0,
"0": "ROOT",
"ELEMENT": 1,
"1": "ELEMENT",
"TEXT": 2,
"2": "TEXT",
"COMMENT": 3,
"3": "COMMENT",
"SIMPLE_EXPRESSION": 4,
"4": "SIMPLE_EXPRESSION",
"INTERPOLATION": 5,
"5": "INTERPOLATION",
"ATTRIBUTE": 6,
"6": "ATTRIBUTE",
"DIRECTIVE": 7,
"7": "DIRECTIVE",
"COMPOUND_EXPRESSION": 8,
"8": "COMPOUND_EXPRESSION",
"IF": 9,
"9": "IF",
"IF_BRANCH": 10,
"10": "IF_BRANCH",
"FOR": 11,
"11": "FOR",
"TEXT_CALL": 12,
"12": "TEXT_CALL",
"VNODE_CALL": 13,
"13": "VNODE_CALL",
"JS_CALL_EXPRESSION": 14,
"14": "JS_CALL_EXPRESSION",
"JS_OBJECT_EXPRESSION": 15,
"15": "JS_OBJECT_EXPRESSION",
"JS_PROPERTY": 16,
"16": "JS_PROPERTY",
"JS_ARRAY_EXPRESSION": 17,
"17": "JS_ARRAY_EXPRESSION",
"JS_FUNCTION_EXPRESSION": 18,
"18": "JS_FUNCTION_EXPRESSION",
"JS_CONDITIONAL_EXPRESSION": 19,
"19": "JS_CONDITIONAL_EXPRESSION",
"JS_CACHE_EXPRESSION": 20,
"20": "JS_CACHE_EXPRESSION",
"JS_BLOCK_STATEMENT": 21,
"21": "JS_BLOCK_STATEMENT",
"JS_TEMPLATE_LITERAL": 22,
"22": "JS_TEMPLATE_LITERAL",
"JS_IF_STATEMENT": 23,
"23": "JS_IF_STATEMENT",
"JS_ASSIGNMENT_EXPRESSION": 24,
"24": "JS_ASSIGNMENT_EXPRESSION",
"JS_SEQUENCE_EXPRESSION": 25,
"25": "JS_SEQUENCE_EXPRESSION",
"JS_RETURN_STATEMENT": 26,
"26": "JS_RETURN_STATEMENT"
};
ElementTypes = {
"ELEMENT": 0,
"0": "ELEMENT",
"COMPONENT": 1,
"1": "COMPONENT",
"SLOT": 2,
"2": "SLOT",
"TEMPLATE": 3,
"3": "TEMPLATE"
};
ConstantTypes = {
"NOT_CONSTANT": 0,
"0": "NOT_CONSTANT",
"CAN_SKIP_PATCH": 1,
"1": "CAN_SKIP_PATCH",
"CAN_CACHE": 2,
"2": "CAN_CACHE",
"CAN_STRINGIFY": 3,
"3": "CAN_STRINGIFY"
};
locStub = {
start: {
line: 1,
column: 1,
offset: 0
},
end: {
line: 1,
column: 1,
offset: 0
},
source: ""
};
defaultDelimitersOpen = new Uint8Array([123, 123]);
defaultDelimitersClose = new Uint8Array([125, 125]);
Sequences = {
Cdata: new Uint8Array([67, 68, 65, 84, 65, 91]),
CdataEnd: new Uint8Array([93, 93, 62]),
CommentEnd: new Uint8Array([45, 45, 62]),
ScriptEnd: new Uint8Array([60, 47, 115, 99, 114, 105, 112, 116]),
StyleEnd: new Uint8Array([60, 47, 115, 116, 121, 108, 101]),
TitleEnd: new Uint8Array([60, 47, 116, 105, 116, 108, 101]),
TextareaEnd: new Uint8Array([60, 47, 116, 101, 120, 116, 97, 114, 101, 97])
};
Tokenizer = class {
constructor(stack$1, cbs) {
this.stack = stack$1;
this.cbs = cbs;
/** The current state the tokenizer is in. */
this.state = 1;
/** The read buffer. */
this.buffer = "";
/** The beginning of the section that is currently being read. */
this.sectionStart = 0;
/** The index within the buffer that we are currently looking at. */
this.index = 0;
/** The start of the last entity. */
this.entityStart = 0;
/** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */
this.baseState = 1;
/** For special parsing behavior inside of script and style tags. */
this.inRCDATA = false;
/** For disabling RCDATA tags handling */
this.inXML = false;
/** For disabling interpolation parsing in v-pre */
this.inVPre = false;
/** Record newline positions for fast line / column calculation */
this.newlines = [];
this.mode = 0;
this.delimiterOpen = defaultDelimitersOpen;
this.delimiterClose = defaultDelimitersClose;
this.delimiterIndex = -1;
this.currentSequence = void 0;
this.sequenceIndex = 0;
}
get inSFCRoot() {
return this.mode === 2 && this.stack.length === 0;
}
reset() {
this.state = 1;
this.mode = 0;
this.buffer = "";
this.sectionStart = 0;
this.index = 0;
this.baseState = 1;
this.inRCDATA = false;
this.currentSequence = void 0;
this.newlines.length = 0;
this.delimiterOpen = defaultDelimitersOpen;
this.delimiterClose = defaultDelimitersClose;
}
/**
* Generate Position object with line / column information using recorded
* newline positions. We know the index is always going to be an already
* processed index, so all the newlines up to this index should have been
* recorded.
*/
getPos(index) {
let line = 1;
let column = index + 1;
for (let i = this.newlines.length - 1; i >= 0; i--) {
const newlineIndex = this.newlines[i];
if (index > newlineIndex) {
line = i + 2;
column = index - newlineIndex;
break;
}
}
return {
column,
line,
offset: index
};
}
peek() {
return this.buffer.charCodeAt(this.index + 1);
}
stateText(c) {
if (c === 60) {
if (this.index > this.sectionStart) this.cbs.ontext(this.sectionStart, this.index);
this.state = 5;
this.sectionStart = this.index;
} else if (!this.inVPre && c === this.delimiterOpen[0]) {
this.state = 2;
this.delimiterIndex = 0;
this.stateInterpolationOpen(c);
}
}
stateInterpolationOpen(c) {
if (c === this.delimiterOpen[this.delimiterIndex]) {
if (this.delimiterIndex === this.delimiterOpen.length - 1) {
const start = this.index + 1 - this.delimiterOpen.length;
if (start > this.sectionStart) this.cbs.ontext(this.sectionStart, start);
this.state = 3;
this.sectionStart = start;
} else this.delimiterIndex++;
} else if (this.inRCDATA) {
this.state = 32;
this.stateInRCDATA(c);
} else {
this.state = 1;
this.stateText(c);
}
}
stateInterpolation(c) {
if (c === this.delimiterClose[0]) {
this.state = 4;
this.delimiterIndex = 0;
this.stateInterpolationClose(c);
}
}
stateInterpolationClose(c) {
if (c === this.delimiterClose[this.delimiterIndex]) {
if (this.delimiterIndex === this.delimiterClose.length - 1) {
this.cbs.oninterpolation(this.sectionStart, this.index + 1);
if (this.inRCDATA) this.state = 32;else this.state = 1;
this.sectionStart = this.index + 1;
} else this.delimiterIndex++;
} else {
this.state = 3;
this.stateInterpolation(c);
}
}
stateSpecialStartSequence(c) {
const isEnd = this.sequenceIndex === this.currentSequence.length;
if (!(isEnd ? isEndOfTagSection(c) : (c | 32) === this.currentSequence[this.sequenceIndex])) this.inRCDATA = false;else if (!isEnd) {
this.sequenceIndex++;
return;
}
this.sequenceIndex = 0;
this.state = 6;
this.stateInTagName(c);
}
/** Look for an end tag. For <title> and <textarea>, also decode entities. */
stateInRCDATA(c) {
if (this.sequenceIndex === this.currentSequence.length) {
if (c === 62 || isWhitespace(c)) {
const endOfText = this.index - this.currentSequence.length;
if (this.sectionStart < endOfText) {
const actualIndex = this.index;
this.index = endOfText;
this.cbs.ontext(this.sectionStart, endOfText);
this.index = actualIndex;
}
this.sectionStart = endOfText + 2;
this.stateInClosingTagName(c);
this.inRCDATA = false;
return;
}
this.sequenceIndex = 0;
}
if ((c | 32) === this.currentSequence[this.sequenceIndex]) this.sequenceIndex += 1;else if (this.sequenceIndex === 0) {
if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) {
if (!this.inVPre && c === this.delimiterOpen[0]) {
this.state = 2;
this.delimiterIndex = 0;
this.stateInterpolationOpen(c);
}
} else if (this.fastForwardTo(60)) this.sequenceIndex = 1;
} else this.sequenceIndex = Number(c === 60);
}
stateCDATASequence(c) {
if (c === Sequences.Cdata[this.sequenceIndex]) {
if (++this.sequenceIndex === Sequences.Cdata.length) {
this.state = 28;
this.currentSequence = Sequences.CdataEnd;
this.sequenceIndex = 0;
this.sectionStart = this.index + 1;
}
} else {
this.sequenceIndex = 0;
this.state = 23;
this.stateInDeclaration(c);
}
}
/**
* When we wait for one specific character, we can speed things up
* by skipping through the buffer until we find it.
*
* @returns Whether the character was found.
*/
fastForwardTo(c) {
while (++this.index < this.buffer.length) {
const cc = this.buffer.charCodeAt(this.index);
if (cc === 10) this.newlines.push(this.index);
if (cc === c) return true;
}
this.index = this.buffer.length - 1;
return false;
}
/**
* Comments and CDATA end with `-->` and `]]>`.
*
* Their common qualities are:
* - Their end sequences have a distinct character they start with.
* - That character is then repeated, so we have to check multiple repeats.
* - All characters but the start character of the sequence can be skipped.
*/
stateInCommentLike(c) {
if (c === this.currentSequence[this.sequenceIndex]) {
if (++this.sequenceIndex === this.currentSequence.length) {
if (this.currentSequence === Sequences.CdataEnd) this.cbs.oncdata(this.sectionStart, this.index - 2);else this.cbs.oncomment(this.sectionStart, this.index - 2);
this.sequenceIndex = 0;
this.sectionStart = this.index + 1;
this.state = 1;
}
} else if (this.sequenceIndex === 0) {
if (this.fastForwardTo(this.currentSequence[0])) this.sequenceIndex = 1;
} else if (c !== this.currentSequence[this.sequenceIndex - 1]) this.sequenceIndex = 0;
}
startSpecial(sequence, offset) {
this.enterRCDATA(sequence, offset);
this.state = 31;
}
enterRCDATA(sequence, offset) {
this.inRCDATA = true;
this.currentSequence = sequence;
this.sequenceIndex = offset;
}
stateBeforeTagName(c) {
if (c === 33) {
this.state = 22;
this.sectionStart = this.index + 1;
} else if (c === 63) {
this.state = 24;
this.sectionStart = this.index + 1;
} else if (isTagStartChar(c)) {
this.sectionStart = this.index;
if (this.mode === 0) this.state = 6;else if (this.inSFCRoot) this.state = 34;else if (!this.inXML) {
if (c === 116) this.state = 30;else this.state = c === 115 ? 29 : 6;
} else this.state = 6;
} else if (c === 47) this.state = 8;else {
this.state = 1;
this.stateText(c);
}
}
stateInTagName(c) {
if (isEndOfTagSection(c)) this.handleTagName(c);
}
stateInSFCRootTagName(c) {
if (isEndOfTagSection(c)) {
const tag = this.buffer.slice(this.sectionStart, this.index);
if (tag !== "template") this.enterRCDATA(toCharCodes(`</` + tag), 0);
this.handleTagName(c);
}
}
handleTagName(c) {
this.cbs.onopentagname(this.sectionStart, this.index);
this.sectionStart = -1;
this.state = 11;
this.stateBeforeAttrName(c);
}
stateBeforeClosingTagName(c) {
if (isWhitespace(c)) ;else if (c === 62) {
this.state = 1;
this.sectionStart = this.index + 1;
} else {
this.state = isTagStartChar(c) ? 9 : 27;
this.sectionStart = this.index;
}
}
stateInClosingTagName(c) {
if (c === 62 || isWhitespace(c)) {
this.cbs.onclosetag(this.sectionStart, this.index);
this.sectionStart = -1;
this.state = 10;
this.stateAfterClosingTagName(c);
}
}
stateAfterClosingTagName(c) {
if (c === 62) {
this.state = 1;
this.sectionStart = this.index + 1;
}
}
stateBeforeAttrName(c) {
if (c === 62) {
this.cbs.onopentagend(this.index);
if (this.inRCDATA) this.state = 32;else this.state = 1;
this.sectionStart = this.index + 1;
} else if (c === 47) this.state = 7;else if (c === 60 && this.peek() === 47) {
this.cbs.onopentagend(this.index);
this.state = 5;
this.sectionStart = this.index;
} else if (!isWhitespace(c)) this.handleAttrStart(c);
}
handleAttrStart(c) {
if (c === 118 && this.peek() === 45) {
this.state = 13;
this.sectionStart = this.index;
} else if (c === 46 || c === 58 || c === 64 || c === 35) {
this.cbs.ondirname(this.index, this.index + 1);
this.state = 14;
this.sectionStart = this.index + 1;
} else {
this.state = 12;
this.sectionStart = this.index;
}
}
stateInSelfClosingTag(c) {
if (c === 62) {
this.cbs.onselfclosingtag(this.index);
this.state = 1;
this.sectionStart = this.index + 1;
this.inRCDATA = false;
} else if (!isWhitespace(c)) {
this.state = 11;
this.stateBeforeAttrName(c);
}
}
stateInAttrName(c) {
if (c === 61 || isEndOfTagSection(c)) {
this.cbs.onattribname(this.sectionStart, this.index);
this.handleAttrNameEnd(c);
}
}
stateInDirName(c) {
if (c === 61 || isEndOfTagSection(c)) {
this.cbs.ondirname(this.sectionStart, this.index);
this.handleAttrNameEnd(c);
} else if (c === 58) {
this.cbs.ondirname(this.sectionStart, this.index);
this.state = 14;
this.sectionStart = this.index + 1;
} else if (c === 46) {
this.cbs.ondirname(this.sectionStart, this.index);
this.state = 16;
this.sectionStart = this.index + 1;
}
}
stateInDirArg(c) {
if (c === 61 || isEndOfTagSection(c)) {
this.cbs.ondirarg(this.sectionStart, this.index);
this.handleAttrNameEnd(c);
} else if (c === 91) this.state = 15;else if (c === 46) {
this.cbs.ondirarg(this.sectionStart, this.index);
this.state = 16;
this.sectionStart = this.index + 1;
}
}
stateInDynamicDirArg(c) {
if (c === 93) this.state = 14;else if (c === 61 || isEndOfTagSection(c)) {
this.cbs.ondirarg(this.sectionStart, this.index + 1);
this.handleAttrNameEnd(c);
}
}
stateInDirModifier(c) {
if (c === 61 || isEndOfTagSection(c)) {
this.cbs.ondirmodifier(this.sectionStart, this.index);
this.handleAttrNameEnd(c);
} else if (c === 46) {
this.cbs.ondirmodifier(this.sectionStart, this.index);
this.sectionStart = this.index + 1;
}
}
handleAttrNameEnd(c) {
this.sectionStart = this.index;
this.state = 17;
this.cbs.onattribnameend(this.index);
this.stateAfterAttrName(c);
}
stateAfterAttrName(c) {
if (c === 61) this.state = 18;else if (c === 47 || c === 62) {
this.cbs.onattribend(0, this.sectionStart);
this.sectionStart = -1;
this.state = 11;
this.stateBeforeAttrName(c);
} else if (!isWhitespace(c)) {
this.cbs.onattribend(0, this.sectionStart);
this.handleAttrStart(c);
}
}
stateBeforeAttrValue(c) {
if (c === 34) {
this.state = 19;
this.sectionStart = this.index + 1;
} else if (c === 39) {
this.state = 20;
this.sectionStart = this.index + 1;
} else if (!isWhitespace(c)) {
this.sectionStart = this.index;
this.state = 21;
this.stateInAttrValueNoQuotes(c);
}
}
handleInAttrValue(c, quote) {
if (c === quote || this.fastForwardTo(quote)) {
this.cbs.onattribdata(this.sectionStart, this.index);
this.sectionStart = -1;
this.cbs.onattribend(quote === 34 ? 3 : 2, this.index + 1);
this.state = 11;
}
}
stateInAttrValueDoubleQuotes(c) {
this.handleInAttrValue(c, 34);
}
stateInAttrValueSingleQuotes(c) {
this.handleInAttrValue(c, 39);
}
stateInAttrValueNoQuotes(c) {
if (isWhitespace(c) || c === 62) {
this.cbs.onattribdata(this.sectionStart, this.index);
this.sectionStart = -1;
this.cbs.onattribend(1, this.index);
this.state = 11;
this.stateBeforeAttrName(c);
} else if (c === 39 || c === 60 || c === 61 || c === 96) this.cbs.onerr(18, this.index);
}
stateBeforeDeclaration(c) {
if (c === 91) {
this.state = 26;
this.sequenceIndex = 0;
} else this.state = c === 45 ? 25 : 23;
}
stateInDeclaration(c) {
if (c === 62 || this.fastForwardTo(62)) {
this.state = 1;
this.sectionStart = this.index + 1;
}
}
stateInProcessingInstruction(c) {
if (c === 62 || this.fastForwardTo(62)) {
this.cbs.onprocessinginstruction(this.sectionStart, this.index);
this.state = 1;
this.sectionStart = this.index + 1;
}
}
stateBeforeComment(c) {
if (c === 45) {
this.state = 28;
this.currentSequence = Sequences.CommentEnd;
this.sequenceIndex = 2;
this.sectionStart = this.index + 1;
} else this.state = 23;
}
stateInSpecialComment(c) {
if (c === 62 || this.fastForwardTo(62)) {
this.cbs.oncomment(this.sectionStart, this.index);
this.state = 1;
this.sectionStart = this.index + 1;
}
}
stateBeforeSpecialS(c) {
if (c === Sequences.ScriptEnd[3]) this.startSpecial(Sequences.ScriptEnd, 4);else if (c === Sequences.StyleEnd[3]) this.startSpecial(Sequences.StyleEnd, 4);else {
this.state = 6;
this.stateInTagName(c);
}
}
stateBeforeSpecialT(c) {
if (c === Sequences.TitleEnd[3]) this.startSpecial(Sequences.TitleEnd, 4);else if (c === Sequences.TextareaEnd[3]) this.startSpecial(Sequences.TextareaEnd, 4);else {
this.state = 6;
this.stateInTagName(c);
}
}
startEntity() {}
stateInEntity() {}
/**
* Iterates through the buffer, calling the function corresponding to the current state.
*
* States that are more likely to be hit are higher up, as a performance improvement.
*/
parse(input) {
this.buffer = input;
while (this.index < this.buffer.length) {
const c = this.buffer.charCodeAt(this.index);
if (c === 10) this.newlines.push(this.index);
switch (this.state) {
case 1:
this.stateText(c);
break;
case 2:
this.stateInterpolationOpen(c);
break;
case 3:
this.stateInterpolation(c);
break;
case 4:
this.stateInterpolationClose(c);
break;
case 31:
this.stateSpecialStartSequence(c);
break;
case 32:
this.stateInRCDATA(c);
break;
case 26:
this.stateCDATASequence(c);
break;
case 19:
this.stateInAttrValueDoubleQuotes(c);
break;
case 12:
this.stateInAttrName(c);
break;
case 13:
this.stateInDirName(c);
break;
case 14:
this.stateInDirArg(c);
break;
case 15:
this.stateInDynamicDirArg(c);
break;
case 16:
this.stateInDirModifier(c);
break;
case 28:
this.stateInCommentLike(c);
break;
case 27:
this.stateInSpecialComment(c);
break;
case 11:
this.stateBeforeAttrName(c);
break;
case 6:
this.stateInTagName(c);
break;
case 34:
this.stateInSFCRootTagName(c);
break;
case 9:
this.stateInClosingTagName(c);
break;
case 5:
this.stateBeforeTagName(c);
break;
case 17:
this.stateAfterAttrName(c);
break;
case 20:
this.stateInAttrValueSingleQuotes(c);
break;
case 18:
this.stateBeforeAttrValue(c);
break;
case 8:
this.stateBeforeClosingTagName(c);
break;
case 10:
this.stateAfterClosingTagName(c);
break;
case 29:
this.stateBeforeSpecialS(c);
break;
case 30:
this.stateBeforeSpecialT(c);
break;
case 21:
this.stateInAttrValueNoQuotes(c);
break;
case 7:
this.stateInSelfClosingTag(c);
break;
case 23:
this.stateInDeclaration(c);
break;
case 22:
this.stateBeforeDeclaration(c);
break;
case 25:
this.stateBeforeComment(c);
break;
case 24:
this.stateInProcessingInstruction(c);
break;
case 33:
this.stateInEntity();
break;
}
this.index++;
}
this.cleanup();
this.finish();
}
/**
* Remove data that has already been consumed from the buffer.
*/
cleanup() {
if (this.sectionStart !== this.index) {
if (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) {
this.cbs.ontext(this.sectionStart, this.index);
this.sectionStart = this.index;
} else if (this.state === 19 || this.state === 20 || this.state === 21) {
this.cbs.onattribdata(this.sectionStart, this.index);
this.sectionStart = this.index;
}
}
}
finish() {
this.handleTrailingData();
this.cbs.onend();
}
/** Handle any trailing data. */
handleTrailingData() {
const endIndex = this.buffer.length;
if (this.sectionStart >= endIndex) return;
if (this.state === 28) {
if (this.currentSequence === Sequences.CdataEnd) this.cbs.oncdata(this.sectionStart, endIndex);else this.cbs.oncomment(this.sectionStart, endIndex);
} else if (this.state === 6 || this.state === 11 || this.state === 18 || this.state === 17 || this.state === 12 || this.state === 13 || this.state === 14 || this.state === 15 || this.state === 16 || this.state === 20 || this.state === 19 || this.state === 21 || this.state === 9) ;else this.cbs.ontext(this.sectionStart, endIndex);
}
emitCodePoint(cp, consumed) {}
};
CompilerDeprecationTypes = {
"COMPILER_IS_ON_ELEMENT": "COMPILER_IS_ON_ELEMENT",
"COMPILER_V_BIND_SYNC": "COMPILER_V_BIND_SYNC",
"COMPILER_V_BIND_OBJECT_ORDER": "COMPILER_V_BIND_OBJECT_ORDER",
"COMPILER_V_ON_NATIVE": "COMPILER_V_ON_NATIVE",
"COMPILER_V_IF_V_FOR_PRECEDENCE": "COMPILER_V_IF_V_FOR_PRECEDENCE",
"COMPILER_NATIVE_TEMPLATE": "COMPILER_NATIVE_TEMPLATE",
"COMPILER_INLINE_TEMPLATE": "COMPILER_INLINE_TEMPLATE",
"COMPILER_FILTERS": "COMPILER_FILTERS"
};
deprecationData = {
["COMPILER_IS_ON_ELEMENT"]: {
message: `Platform-native elements with "is" prop will no longer be treated as components in Vue 3 unless the "is" value is explicitly prefixed with "vue:".`,
link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html`
},
["COMPILER_V_BIND_SYNC"]: {
message: key => `.sync modifier for v-bind has been removed. Use v-model with argument instead. \`v-bind:${key}.sync\` should be changed to \`v-model:${key}\`.`,
link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html`
},
["COMPILER_V_BIND_OBJECT_ORDER"]: {
message: `v-bind="obj" usage is now order sensitive and behaves like JavaScript object spread: it will now overwrite an existing non-mergeable attribute that appears before v-bind in the case of conflict. To retain 2.x behavior, move v-bind to make it the first attribute. You can also suppress this warning if the usage is intended.`,
link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html`
},
["COMPILER_V_ON_NATIVE"]: {
message: `.native modifier for v-on has been removed as is no longer necessary.`,
link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html`
},
["COMPILER_V_IF_V_FOR_PRECEDENCE"]: {
message: `v-if / v-for precedence when used on the same element has changed in Vue 3: v-if now takes higher precedence and will no longer have access to v-for scope variables. It is best to avoid the ambiguity with <template> tags or use a computed property that filters v-for data source.`,
link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html`
},
["COMPILER_NATIVE_TEMPLATE"]: {
message: `<template> with no special directives will render as a native template element instead of its inner content in Vue 3.`
},
["COMPILER_INLINE_TEMPLATE"]: {
message: `"inline-template" has been removed in Vue 3.`,
link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html`
},
["COMPILER_FILTERS"]: {
message: `filters have been removed in Vue 3. The "|" symbol will be treated as native JavaScript bitwise OR operator. Use method calls or computed properties instead.`,
link: `https://v3-migration.vuejs.org/breaking-changes/filters.html`
}
};
ErrorCodes = {
"ABRUPT_CLOSING_OF_EMPTY_COMMENT": 0,
"0": "ABRUPT_CLOSING_OF_EMPTY_COMMENT",
"CDATA_IN_HTML_CONTENT": 1,
"1": "CDATA_IN_HTML_CONTENT",
"DUPLICATE_ATTRIBUTE": 2,
"2": "DUPLICATE_ATTRIBUTE",
"END_TAG_WITH_ATTRIBUTES": 3,
"3": "END_TAG_WITH_ATTRIBUTES",
"END_TAG_WITH_TRAILING_SOLIDUS": 4,
"4": "END_TAG_WITH_TRAILING_SOLIDUS",
"EOF_BEFORE_TAG_NAME": 5,
"5": "EOF_BEFORE_TAG_NAME",
"EOF_IN_CDATA": 6,
"6": "EOF_IN_CDATA",
"EOF_IN_COMMENT": 7,
"7": "EOF_IN_COMMENT",
"EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT": 8,
"8": "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT",
"EOF_IN_TAG": 9,
"9": "EOF_IN_TAG",
"INCORRECTLY_CLOSED_COMMENT": 10,
"10": "INCORRECTLY_CLOSED_COMMENT",
"INCORRECTLY_OPENED_COMMENT": 11,
"11": "INCORRECTLY_OPENED_COMMENT",
"INVALID_FIRST_CHARACTER_OF_TAG_NAME": 12,
"12": "INVALID_FIRST_CHARACTER_OF_TAG_NAME",
"MISSING_ATTRIBUTE_VALUE": 13,
"13": "MISSING_ATTRIBUTE_VALUE",
"MISSING_END_TAG_NAME": 14,
"14": "MISSING_END_TAG_NAME",
"MISSING_WHITESPACE_BETWEEN_ATTRIBUTES": 15,
"15": "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES",
"NESTED_COMMENT": 16,
"16": "NESTED_COMMENT",
"UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME": 17,
"17": "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME",
"UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE": 18,
"18": "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE",
"UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME": 19,
"19": "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME",
"UNEXPECTED_NULL_CHARACTER": 20,
"20": "UNEXPECTED_NULL_CHARACTER",
"UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME": 21,
"21": "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME",
"UNEXPECTED_SOLIDUS_IN_TAG": 22,
"22": "UNEXPECTED_SOLIDUS_IN_TAG",
"X_INVALID_END_TAG": 23,
"23": "X_INVALID_END_TAG",
"X_MISSING_END_TAG": 24,
"24": "X_MISSING_END_TAG",
"X_MISSING_INTERPOLATION_END": 25,
"25": "X_MISSING_INTERPOLATION_END",
"X_MISSING_DIRECTIVE_NAME": 26,
"26": "X_MISSING_DIRECTIVE_NAME",
"X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END": 27,
"27": "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END",
"X_V_IF_NO_EXPRESSION": 28,
"28": "X_V_IF_NO_EXPRESSION",
"X_V_IF_SAME_KEY": 29,
"29": "X_V_IF_SAME_KEY",
"X_V_ELSE_NO_ADJACENT_IF": 30,
"30": "X_V_ELSE_NO_ADJACENT_IF",
"X_V_FOR_NO_EXPRESSION": 31,
"31": "X_V_FOR_NO_EXPRESSION",
"X_V_FOR_MALFORMED_EXPRESSION": 32,
"32": "X_V_FOR_MALFORMED_EXPRESSION",
"X_V_FOR_TEMPLATE_KEY_PLACEMENT": 33,
"33": "X_V_FOR_TEMPLATE_KEY_PLACEMENT",
"X_V_BIND_NO_EXPRESSION": 34,
"34": "X_V_BIND_NO_EXPRESSION",
"X_V_ON_NO_EXPRESSION": 35,
"35": "X_V_ON_NO_EXPRESSION",
"X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET": 36,
"36": "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET",
"X_V_SLOT_MIXED_SLOT_USAGE": 37,
"37": "X_V_SLOT_MIXED_SLOT_USAGE",
"X_V_SLOT_DUPLICATE_SLOT_NAMES": 38,
"38": "X_V_SLOT_DUPLICATE_SLOT_NAMES",
"X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN": 39,
"39": "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN",
"X_V_SLOT_MISPLACED": 40,
"40": "X_V_SLOT_MISPLACED",
"X_V_MODEL_NO_EXPRESSION": 41,
"41": "X_V_MODEL_NO_EXPRESSION",
"X_V_MODEL_MALFORMED_EXPRESSION": 42,
"42": "X_V_MODEL_MALFORMED_EXPRESSION",
"X_V_MODEL_ON_SCOPE_VARIABLE": 43,
"43": "X_V_MODEL_ON_SCOPE_VARIABLE",
"X_V_MODEL_ON_PROPS": 44,
"44": "X_V_MODEL_ON_PROPS",
"X_INVALID_EXPRESSION": 45,
"45": "X_INVALID_EXPRESSION",
"X_KEEP_ALIVE_INVALID_CHILDREN": 46,
"46": "X_KEEP_ALIVE_INVALID_CHILDREN",
"X_PREFIX_ID_NOT_SUPPORTED": 47,
"47": "X_PREFIX_ID_NOT_SUPPORTED",
"X_MODULE_MODE_NOT_SUPPORTED": 48,
"48": "X_MODULE_MODE_NOT_SUPPORTED",
"X_CACHE_HANDLER_NOT_SUPPORTED": 49,
"49": "X_CACHE_HANDLER_NOT_SUPPORTED",
"X_SCOPE_ID_NOT_SUPPORTED": 50,
"50": "X_SCOPE_ID_NOT_SUPPORTED",
"X_VNODE_HOOKS": 51,
"51": "X_VNODE_HOOKS",
"X_V_BIND_INVALID_SAME_NAME_ARGUMENT": 52,
"52": "X_V_BIND_INVALID_SAME_NAME_ARGUMENT",
"__EXTEND_POINT__": 53,
"53": "__EXTEND_POINT__"
};
errorMessages = {
[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 '<' 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.",
[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.",
[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.`,
[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.`,
[53]: ``
};
isFunctionType = node => {
return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
};
isStaticProperty = node => node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed;
isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
TS_NODE_TYPES = ["TSAsExpression", "TSTypeAssertion", "TSNonNullExpression", "TSInstantiationExpression", "TSSatisfiesExpression"];
isStaticExp = p => p.type === 4 && p.isStatic;
nonIdentifierRE = /^\d|[^\$\w\xA0-\uFFFF]/;
isSimpleIdentifier = name => !nonIdentifierRE.test(name);
validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
getExpSource = exp => exp.type === 4 ? exp.content : exp.loc.source;
isMemberExpressionBrowser = exp => {
const path = getExpSource(exp).trim().replace(whitespaceRE, s => s.trim());
let state = 0;
let stateStack = [];
let currentOpenBracketCount = 0;
let currentOpenParensCount = 0;
let currentStringType = null;
for (let i = 0; i < path.length; i++) {
const char = path.charAt(i);
switch (state) {
case 0:
if (char === "[") {
stateStack.push(state);
state = 1;
currentOpenBracketCount++;
} else if (char === "(") {
stateStack.push(state);
state = 2;
currentOpenParensCount++;
} else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) return false;
break;
case 1:
if (char === `'` || char === `"` || char === "`") {
stateStack.push(state);
state = 3;
currentStringType = char;
} else if (char === `[`) currentOpenBracketCount++;else if (char === `]`) {
if (! --currentOpenBracketCount) state = stateStack.pop();
}
break;
case 2:
if (char === `'` || char === `"` || char === "`") {
stateStack.push(state);
state = 3;
currentStringType = char;
} else if (char === `(`) currentOpenParensCount++;else if (char === `)`) {
if (i === path.length - 1) return false;
if (! --currentOpenParensCount) state = stateStack.pop();
}
break;
case 3:
if (char === currentStringType) {
state = stateStack.pop();
currentStringType = null;
}
break;
}
}
return !currentOpenBracketCount && !currentOpenParensCount;
};
isMemberExpressionNode = NOOP;
isMemberExpression = isMemberExpressionBrowser;
fnExpRE = /^\s*(async\s*)?(\([^)]*?\)|[\w$_]+)\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
isFnExpressionBrowser = exp => fnExpRE.test(getExpSource(exp));
isFnExpressionNode = NOOP;
isFnExpression = isFnExpressionBrowser;
propsHelperSet = /* @__PURE__ */new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;
defaultParserOptions = {
parseMode: "base",
ns: 0,
delimiters: [`{{`, `}}`],
getNamespace: () => 0,
isVoidTag: NO,
isPreTag: NO,
isIgnoreNewlineTag: NO,
isCustomElement: NO,
onError: defaultOnError,
onWarn: defaultOnWarn,
comments: false,
prefixIdentifiers: false
};
currentOptions = defaultParserOptions;
currentRoot = null;
currentInput = "";
currentOpenTag = null;
currentProp = null;
currentAttrValue = "";
currentAttrStartIndex = -1;
currentAttrEndIndex = -1;
inPre = 0;
inVPre = false;
currentVPreBoundary = null;
stack = [];
tokenizer = new Tokenizer(stack, {
onerr: emitError,
ontext(start, end) {
onText(getSlice(start, end), start, end);
},
ontextentity(char, start, end) {
onText(char, start, end);
},
oninterpolation(start, end) {
if (inVPre) return onText(getSlice(start, end), start, end);
let innerStart = start + tokenizer.delimiterOpen.length;
let innerEnd = end - tokenizer.delimiterClose.length;
while (isWhitespace(currentInput.charCodeAt(innerStart))) innerStart++;
while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) innerEnd--;
let exp = getSlice(innerStart, innerEnd);
if (exp.includes("&")) exp = currentOptions.decodeEntities(exp, false);
addNode({
type: 5,
content: createExp(exp, false, getLoc(innerStart, innerEnd)),
loc: getLoc(start, end)
});
},
onopentagname(start, end) {
const name = getSlice(start, end);
currentOpenTag = {
type: 1,
tag: name,
ns: currentOptions.getNamespace(name, stack[0], currentOptions.ns),
tagType: 0,
props: [],
children: [],
loc: getLoc(start - 1, end),
codegenNode: void 0
};
},
onopentagend(end) {
endOpenTag(end);
},
onclosetag(start, end) {
const name = getSlice(start, end);
if (!currentOptions.isVoidTag(name)) {
let found = false;
for (let i = 0; i < stack.length; i++) if (stack[i].tag.toLowerCase() === name.toLowerCase()) {
found = true;
if (i > 0) emitError(24, stack[0].loc.start.offset);
for (let j = 0; j <= i; j++) onCloseTag(stack.shift(), end, j < i);
break;
}
if (!found) emitError(23, backTrack(start, 60));
}
},
onselfclosingtag(end) {
const name = currentOpenTag.tag;
currentOpenTag.isSelfClosing = true;
endOpenTag(end);
if (stack[0] && stack[0].tag === name) onCloseTag(stack.shift(), end);
},
onattribname(start, end) {
currentProp = {
type: 6,
name: getSlice(start, end),
nameLoc: getLoc(start, end),
value: void 0,
loc: getLoc(start)
};
},
ondirname(start, end) {
const raw = getSlice(start, end);
const name = raw === "." || raw === ":" ? "bind" : raw === "@" ? "on" : raw === "#" ? "slot" : raw.slice(2);
if (!inVPre && name === "") emitError(26, start);
if (inVPre || name === "") currentProp = {
type: 6,
name: raw,
nameLoc: getLoc(start, end),
value: void 0,
loc: getLoc(start)
};else {
currentProp = {
type: 7,
name,
rawName: raw,
exp: void 0,
arg: void 0,
modifiers: raw === "." ? [createSimpleExpression("prop")] : [],
loc: getLoc(start)
};
if (name === "pre") {
inVPre = tokenizer.inVPre = true;
currentVPreBoundary = currentOpenTag;
const props = currentOpenTag.props;
for (let i = 0; i < props.length; i++) if (props[i].type === 7) props[i] = dirToAttr(props[i]);
}
}
},
ondirarg(start, end) {
if (start === end) return;
const arg = getSlice(start, end);
if (inVPre) {
currentProp.name += arg;
setLocEnd(currentProp.nameLoc, end);
} else {
const isStatic = arg[0] !== `[`;
currentProp.arg = createExp(isStatic ? arg : arg.slice(1, -1), isStatic, getLoc(start, end), isStatic ? 3 : 0);
}
},
ondirmodifier(start, end) {
const mod = getSlice(start, end);
if (inVPre) {
currentProp.name += "." + mod;
setLocEnd(currentProp.nameLoc, end);
} else if (currentProp.name === "slot") {
const arg = currentProp.arg;
if (arg) {
arg.content += "." + mod;
setLocEnd(arg.loc, end);
}
} else {
const exp = createSimpleExpression(mod, true, getLoc(start, end));
currentProp.modifiers.push(exp);
}
},
onattribdata(start, end) {
currentAttrValue += getSlice(start, end);
if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
currentAttrEndIndex = end;
},
onattribentity(char, start, end) {
currentAttrValue += char;
if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
currentAttrEndIndex = end;
},
onattribnameend(end) {
const start = currentProp.loc.start.offset;
const name = getSlice(start, end);
if (currentProp.type === 7) currentProp.rawName = name;
if (currentOpenTag.props.some(p => (p.type === 7 ? p.rawName : p.name) === name)) emitError(2, start);
},
onattribend(quote, end) {
if (currentOpenTag && currentProp) {
setLocEnd(currentProp.loc, end);
if (quote !== 0) {
if (currentAttrValue.includes("&")) currentAttrValue = currentOptions.decodeEntities(currentAttrValue, true);
if (currentProp.type === 6) {
if (currentProp.name === "class") currentAttrValue = condense(currentAttrValue).trim();
if (quote === 1 && !currentAttrValue) emitError(13, end);
currentProp.value = {
type: 2,
content: currentAttrValue,
loc: quote === 1 ? getLoc(currentAttrStartIndex, currentAttrEndIndex) : getLoc(currentAttrStartIndex - 1, currentAttrEndIndex + 1)
};
if (tokenizer.inSFCRoot && currentOpenTag.tag === "template" && currentProp.name === "lang" && currentAttrValue && currentAttrValue !== "html") tokenizer.enterRCDATA(toCharCodes(`</template`), 0);
} else {
currentProp.exp = createExp(currentAttrValue, false, getLoc(currentAttrStartIndex, currentAttrEndIndex), 0, 0);
if (currentProp.name === "for") currentProp.forParseResult = parseForExpression(currentProp.exp);
let syncIndex = -1;
if (currentProp.name === "bind" && (syncIndex = currentProp.modifiers.findIndex(mod => mod.content === "sync")) > -1 && checkCompatEnabled("COMPILER_V_BIND_SYNC", currentOptions, currentProp.loc, currentProp.rawName)) {
currentProp.name = "model";
currentProp.modifiers.splice(syncIndex, 1);
}
}
}
if (currentProp.type !== 7 || currentProp.name !== "pre") currentOpenTag.props.push(currentProp);
}
currentAttrValue = "";
currentAttrStartIndex = currentAttrEndIndex = -1;
},
oncomment(start, end) {
if (currentOptions.comments) addNode({
type: 3,
content: getSlice(start, end),
loc: getLoc(start - 4, end + 3)
});
},
onend() {
const end = currentInput.length;
for (let index = 0; index < stack.length; index++) {
onCloseTag(stack[index], end - 1);
emitError(24, stack[index].loc.start.offset);
}
},
oncdata(start, end) {
if (stack[0].ns !== 0) onText(getSlice(start, end), start, end);else emitError(1, start - 9);
},
onprocessinginstruction(start) {
if ((stack[0] ? stack[0].ns : currentOptions.ns) === 0) emitError(21, start - 1);
}
});
forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
stripParensRE = /^\(|\)$/g;
specialTemplateDir = /* @__PURE__ */new Set(["if", "else", "else-if", "for", "slot"]);
windowsNewlineRE = /\r\n/g;
allowHoistedHelperSet = /* @__PURE__ */new Set([NORMALIZE_CLASS, NORMALIZE_STYLE, NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
PURE_ANNOTATION = `/*@__PURE__*/`;
aliasHelper = s => `${helperNameMap[s]}: _${helperNameMap[s]}`;
"" + "arguments,await,break,case,catch,class,const,continue,debugger,default,delete,do,else,export,extends,finally,for,function,if,import,let,new,return,super,switch,throw,try,var,void,while,with,yield".split(",").join("\\b|\\b");
transformExpression = (node, context) => {
if (node.type === 5) node.content = processExpression(node.content, context);else if (node.type === 1) {
const memo = findDir(node, "memo");
for (let i = 0; i < node.props.length; i++) {
const dir = node.props[i];
if (dir.type === 7 && dir.name !== "for") {
const exp = dir.exp;
const arg = dir.arg;
if (exp && exp.type === 4 && !(dir.name === "on" && arg) && !(memo && arg && arg.type === 4 && arg.content === "key")) dir.exp = processExpression(exp, context, dir.name === "slot");
if (arg && arg.type === 4 && !arg.isStatic) dir.arg = processExpression(arg, context);
}
}
}
};
transformIf = createStructuralDirectiveTransform(/^(if|else|else-if)$/, (node, dir, context) => {
return processIf(node, dir, context, (ifNode, branch, isRoot) => {
const siblings = context.parent.children;
let i = siblings.indexOf(ifNode);
let key = 0;
while (i-- >= 0) {
const sibling = siblings[i];
if (sibling && sibling.type === 9) key += sibling.branches.length;
}
return () => {
if (isRoot) ifNode.codegenNode = createCodegenNodeForBranch(branch, key, context);else {
const parentCondition = getParentCondition(ifNode.codegenNode);
parentCondition.alternate = createCodegenNodeForBranch(branch, key + ifNode.branches.length - 1, context);
}
};
});
});
transformBind = (dir, _node, context) => {
const {
modifiers,
loc
} = dir;
const arg = dir.arg;
let {
exp
} = dir;
if (exp && exp.type === 4 && !exp.content.trim()) exp = void 0;
if (!exp) {
if (arg.type !== 4 || !arg.isStatic) {
context.onError(createCompilerError(52, arg.loc));
return {
props: [createObjectProperty(arg, createSimpleExpression("", true, loc))]
};
}
transformBindShorthand(dir);
exp = dir.exp;
}
if (arg.type !== 4) {
arg.children.unshift(`(`);
arg.children.push(`) || ""`);
} else if (!arg.isStatic) arg.content = `${arg.content} || ""`;
if (modifiers.some(mod => mod.content === "camel")) if (arg.type === 4) {
if (arg.isStatic) arg.content = camelize(arg.content);else arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
} else {
arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
arg.children.push(`)`);
}
if (!context.inSSR) {
if (modifiers.some(mod => mod.content === "prop")) injectPrefix(arg, ".");
if (modifiers.some(mod => mod.content === "attr")) injectPrefix(arg, "^");
}
return {
props: [createObjectProperty(arg, exp)]
};
};
transformBindShorthand = (dir, context) => {
const arg = dir.arg;
dir.exp = createSimpleExpression(camelize(arg.content), false, arg.loc);
};
injectPrefix = (arg, prefix) => {
if (arg.type === 4) {
if (arg.isStatic) arg.content = prefix + arg.content;else arg.content = `\`${prefix}\${${arg.content}}\``;
} else {
arg.children.unshift(`'${prefix}' + (`);
arg.children.push(`)`);
}
};
transformFor = createStructuralDirectiveTransform("for", (node, dir, context) => {
const {
helper,
removeHelper
} = context;
return processFor(node, dir, context, forNode => {
const renderExp = createCallExpression(helper(RENDER_LIST), [forNode.source]);
const isTemplate = isTemplateNode(node);
const memo = findDir(node, "memo");
const keyProp = findProp(node, `key`, false, true);
if (keyProp && keyProp.type === 7 && !keyProp.exp) transformBindShorthand(keyProp);
let keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp);
const keyProperty = keyProp && keyExp ? createObjectProperty(`key`, keyExp) : null;
const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0;
const fragmentFlag = isStableFragment ? 64 : keyProp ? 128 : 256;
forNode.codegenNode = createVNodeCall(context, helper(FRAGMENT), void 0, renderExp, fragmentFlag, void 0, void 0, true, !isStableFragment, false, node.loc);
return () => {
let childBlock;
const {
children
} = forNode;
const needFragmentWrapper = children.length !== 1 || children[0].type !== 1;
const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null;
if (slotOutlet) {
childBlock = slotOutlet.codegenNode;
if (isTemplate && keyProperty) injectProp(childBlock, keyProperty, context);
} else if (needFragmentWrapper) childBlock = createVNodeCall(context, helper(FRAGMENT), keyProperty ? createObjectExpression([keyProperty]) : void 0, node.children, 64, void 0, void 0, true, void 0, false);else {
childBlock = children[0].codegenNode;
if (isTemplate && keyProperty) injectProp(childBlock, keyProperty, context);
if (childBlock.isBlock !== !isStableFragment) if (childBlock.isBlock) {
removeHelper(OPEN_BLOCK);
removeHelper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
} else removeHelper(getVNodeHelper(context.inSSR, childBlock.isComponent));
childBlock.isBlock = !isStableFragment;
if (childBlock.isBlock) {
helper(OPEN_BLOCK);
helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
} else helper(getVNodeHelper(context.inSSR, childBlock.isComponent));
}
if (memo) {
const loop = createFunctionExpression(createForLoopParams(forNode.parseResult, [createSimpleExpression(`_cached`)]));
loop.body = createBlockStatement([createCompoundExpression([`const _memo = (`, memo.exp, `)`]), createCompoundExpression([`if (_cached`, ...(keyExp ? [` && _cached.key === `, keyExp] : []), ` && ${context.helperString(IS_MEMO_SAME)}(_cached, _memo)) return _cached`]), createCompoundExpression([`const _item = `, childBlock]), createSimpleExpression(`_item.memo = _memo`), createSimpleExpression(`return _item`)]);
renderExp.arguments.push(loop, createSimpleExpression(`_cache`), createSimpleExpression(String(context.cached.length)));
context.cached.push(null);
} else renderExp.arguments.push(createFunctionExpression(createForLoopParams(forNode.parseResult), childBlock, true));
};
});
});
defaultFallback = createSimpleExpression(`undefined`, false);
trackSlotScopes = (node, context) => {
if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) {
const vSlot = findDir(node, "slot");
if (vSlot) {
vSlot.exp;
context.scopes.vSlot++;
return () => {
context.scopes.vSlot--;
};
}
}
};
trackVForSlotScopes = (node, context) => {
let vFor;
if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir(node, "for"))) {
const result = vFor.forParseResult;
if (result) {
finalizeForParseResult(result, context);
const {
value,
key,
index
} = result;
const {
addIdentifiers,
removeIdentifiers
} = context;
value && addIdentifiers(value);
key && addIdentifiers(key);
index && addIdentifiers(index);
return () => {
value && removeIdentifiers(value);
key && removeIdentifiers(key);
index && removeIdentifiers(index);
};
}
}
};
buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression(props, children, false, true, children.length ? children[0].loc : loc);
directiveImportMap = /* @__PURE__ */new WeakMap();
transformElement = (node, context) => {
return function postTransformElement() {
node = context.currentNode;
if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) return;
const {
tag,
props
} = node;
const isComponent$1 = node.tagType === 1;
let vnodeTag = isComponent$1 ? resolveComponentType(node, context) : `"${tag}"`;
const isDynamicComponent = isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;
let vnodeProps;
let vnodeChildren;
let patchFlag = 0;
let vnodeDynamicProps;
let dynamicPropNames;
let vnodeDirectives;
let shouldUseBlock = isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent$1 && (tag === "svg" || tag === "foreignObject" || tag === "math");
if (props.length > 0) {
const propsBuildResult = buildProps(node, context, void 0, isComponent$1, isDynamicComponent);
vnodeProps = propsBuildResult.props;
patchFlag = propsBuildResult.patchFlag;
dynamicPropNames = propsBuildResult.dynamicPropNames;
const directives = propsBuildResult.directives;
vnodeDirectives = directives && directives.length ? createArrayExpression(directives.map(dir => buildDirectiveArgs(dir, context))) : void 0;
if (propsBuildResult.shouldUseBlock) shouldUseBlock = true;
}
if (node.children.length > 0) {
if (vnodeTag === KEEP_ALIVE) {
shouldUseBlock = true;
patchFlag |= 1024;
}
if (isComponent$1 && vnodeTag !== TELEPORT && vnodeTag !== KEEP_ALIVE) {
const {
slots,
hasDynamicSlots
} = buildSlots(node, context);
vnodeChildren = slots;
if (hasDynamicSlots) patchFlag |= 1024;
} else if (node.children.length === 1 && vnodeTag !== TELEPORT) {
const child = node.children[0];
const type = child.type;
const hasDynamicTextChild = type === 5 || type === 8;
if (hasDynamicTextChild && getConstantType(child, context) === 0) patchFlag |= 1;
if (hasDynamicTextChild || type === 2) vnodeChildren = child;else vnodeChildren = node.children;
} else vnodeChildren = node.children;
}
if (dynamicPropNames && dynamicPropNames.length) vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
node.codegenNode = createVNodeCall(context, vnodeTag, vnodeProps, vnodeChildren, patchFlag === 0 ? void 0 : patchFlag, vnodeDynamicProps, vnodeDirectives, !!shouldUseBlock, false, isComponent$1, node.loc);
};
};
transformSlotOutlet = (node, context) => {
if (isSlotOutlet(node)) {
const {
children,
loc
} = node;
const {
slotName,
slotProps
} = processSlotOutlet(node, context);
const slotArgs = [context.prefixIdentifiers ? `_ctx.$slots` : `$slots`, slotName, "{}", "undefined", "true"];
let expectedLen = 2;
if (slotProps) {
slotArgs[2] = slotProps;
expectedLen = 3;
}
if (children.length) {
slotArgs[3] = createFunctionExpression([], children, false, false, loc);
expectedLen = 4;
}
if (context.scopeId && !context.slotted) expectedLen = 5;
slotArgs.splice(expectedLen);
node.codegenNode = createCallExpression(context.helper(RENDER_SLOT), slotArgs, loc);
}
};
transformOn = (dir, node, context, augmentor) => {
const {
loc,
modifiers,
arg
} = dir;
if (!dir.exp && !modifiers.length) context.onError(createCompilerError(35, loc));
let eventName;
if (arg.type === 4) {
if (arg.isStatic) {
let rawName = arg.content;
if (rawName.startsWith("vue:")) rawName = `vnode-${rawName.slice(4)}`;
eventName = createSimpleExpression(node.tagType !== 0 || rawName.startsWith("vnode") || !/[A-Z]/.test(rawName) ? toHandlerKey(camelize(rawName)) : `on:${rawName}`, true, arg.loc);
} else eventName = createCompoundExpression([`${context.helperString(TO_HANDLER_KEY)}(`, arg, `)`]);
} else {
eventName = arg;
eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`);
eventName.children.push(`)`);
}
let exp = dir.exp;
if (exp && !exp.content.trim()) exp = void 0;
let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;
if (exp) {
const isMemberExp = isMemberExpression(exp);
const isInlineStatement = !(isMemberExp || isFnExpression(exp));
const hasMultipleStatements = exp.content.includes(`;`);
if (isInlineStatement || shouldCache && isMemberExp) exp = createCompoundExpression([`${isInlineStatement ? `$event` : `(...args)`} => ${hasMultipleStatements ? `{` : `(`}`, exp, hasMultipleStatements ? `}` : `)`]);
}
let ret = {
props: [createObjectProperty(eventName, exp || createSimpleExpression(`() => {}`, false, loc))]
};
if (augmentor) ret = augmentor(ret);
if (shouldCache) ret.props[0].value = context.cache(ret.props[0].value);
ret.props.forEach(p => p.key.isHandlerKey = true);
return ret;
};
transformText = (node, context) => {
if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) return () => {
const children = node.children;
let currentContainer = void 0;
let hasText = false;
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (isText$1(child)) {
hasText = true;
for (let j = i + 1; j < children.length; j++) {
const next = children[j];
if (isText$1(next)) {
if (!currentContainer) currentContainer = children[i] = createCompoundExpression([child], child.loc);
currentContainer.children.push(` + `, next);
children.splice(j, 1);
j--;
} else {
currentContainer = void 0;
break;
}
}
}
}
if (!hasText || children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && !node.props.find(p => p.type === 7 && !context.directiveTransforms[p.name]) && !(node.tag === "template"))) return;
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (isText$1(child) || child.type === 8) {
const callArgs = [];
if (child.type !== 2 || child.content !== " ") callArgs.push(child);
if (!context.ssr && getConstantType(child, context) === 0) callArgs.push("1");
children[i] = {
type: 12,
content: child,
loc: child.loc,
codegenNode: createCallExpression(context.helper(CREATE_TEXT), callArgs)
};
}
}
};
};
seen$1 = /* @__PURE__ */new WeakSet();
transformOnce = (node, context) => {
if (node.type === 1 && findDir(node, "once", true)) {
if (seen$1.has(node) || context.inVOnce || context.inSSR) return;
seen$1.add(node);
context.inVOnce = true;
context.helper(SET_BLOCK_TRACKING);
return () => {
context.inVOnce = false;
const cur = context.currentNode;
if (cur.codegenNode) cur.codegenNode = context.cache(cur.codegenNode, true, true);
};
}
};
transformModel = (dir, node, context) => {
const {
exp,
arg
} = dir;
if (!exp) {
context.onError(createCompilerError(41, dir.loc));
return createTransformProps();
}
const rawExp = exp.loc.source.trim();
const expString = exp.type === 4 ? exp.content : rawExp;
const bindingType = context.bindingMetadata[rawExp];
if (bindingType === "props" || bindingType === "props-aliased") {
context.onError(createCompilerError(44, exp.loc));
return createTransformProps();
}
if (!expString.trim() || !isMemberExpression(exp) && true) {
context.onError(createCompilerError(42, exp.loc));
return createTransformProps();
}
const propName = arg ? arg : createSimpleExpression("modelValue", true);
const eventName = arg ? isStaticExp(arg) ? `onUpdate:${camelize(arg.content)}` : createCompoundExpression(["\"onUpdate:\" + ", arg]) : `onUpdate:modelValue`;
let assignmentExp;
assignmentExp = createCompoundExpression([`${context.isTS ? `($event: any)` : `$event`} => ((`, exp, `) = $event)`]);
const props = [createObjectProperty(propName, dir.exp), createObjectProperty(eventName, assignmentExp)];
if (dir.modifiers.length && node.tagType === 1) {
const modifiers = dir.modifiers.map(m => m.content).map(m => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `);
const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, " + \"Modifiers\""]) : `modelModifiers`;
props.push(createObjectProperty(modifiersKey, createSimpleExpression(`{ ${modifiers} }`, false, dir.loc, 2)));
}
return createTransformProps(props);
};
validDivisionCharRE = /[\w).+\-_$\]]/;
transformFilter = (node, context) => {
if (!isCompatEnabled("COMPILER_FILTERS", context)) return;
if (node.type === 5) rewriteFilter(node.content, context);else if (node.type === 1) node.props.forEach(prop => {
if (prop.type === 7 && prop.name !== "for" && prop.exp) rewriteFilter(prop.exp, context);
});
};
seen = /* @__PURE__ */new WeakSet();
transformMemo = (node, context) => {
if (node.type === 1) {
const dir = findDir(node, "memo");
if (!dir || seen.has(node)) return;
seen.add(node);
return () => {
const codegenNode = node.codegenNode || context.currentNode.codegenNode;
if (codegenNode && codegenNode.type === 13) {
if (node.tagType !== 1) convertToBlock(codegenNode, context);
node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [dir.exp, createFunctionExpression(void 0, codegenNode), `_cache`, String(context.cached.length)]);
context.cached.push(null);
}
};
}
};
BindingTypes = {
"DATA": "data",
"PROPS": "props",
"PROPS_ALIASED": "props-aliased",
"SETUP_LET": "setup-let",
"SETUP_CONST": "setup-const",
"SETUP_REACTIVE_CONST": "setup-reactive-const",
"SETUP_MAYBE_REF": "setup-maybe-ref",
"SETUP_REF": "setup-ref",
"OPTIONS": "options",
"LITERAL_CONST": "literal-const"
};
noopDirectiveTransform = () => ({
props: []
});
}
}); //#endregion
//#region ../../../node_modules/.pnpm/@vue+compiler-dom@3.5.13/node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js
compiler_dom_esm_bundler_exports = /* @__PURE__ */__export({
BASE_TRANSITION: () => BASE_TRANSITION,
BindingTypes: () => BindingTypes,
CAMELIZE: () => CAMELIZE,
CAPITALIZE: () => CAPITALIZE,
CREATE_BLOCK: () => CREATE_BLOCK,
CREATE_COMMENT: () => CREATE_COMMENT,
CREATE_ELEMENT_BLOCK: () => CREATE_ELEMENT_BLOCK,
CREATE_ELEMENT_VNODE: () => CREATE_ELEMENT_VNODE,
CREATE_SLOTS: () => CREATE_SLOTS,
CREATE_STATIC: () => CREATE_STATIC,
CREATE_TEXT: () => CREATE_TEXT,
CREATE_VNODE: () => CREATE_VNODE,
CompilerDeprecationTypes: () => CompilerDeprecationTypes,
ConstantTypes: () => ConstantTypes,
DOMDirectiveTransforms: () => DOMDirectiveTransforms,
DOMErrorCodes: () => DOMErrorCodes,
DOMErrorMessages: () => DOMErrorMessages,
DOMNodeTransforms: () => DOMNodeTransforms,
ElementTypes: () => ElementTypes,
ErrorCodes: () => ErrorCodes,
FRAGMENT: () => FRAGMENT,
GUARD_REACTIVE_PROPS: () => GUARD_REACTIVE_PROPS,
IS_MEMO_SAME: () => IS_MEMO_SAME,
IS_REF: () => IS_REF,
KEEP_ALIVE: () => KEEP_ALIVE,
MERGE_PROPS: () => MERGE_PROPS,
NORMALIZE_CLASS: () => NORMALIZE_CLASS,
NORMALIZE_PROPS: () => NORMALIZE_PROPS,
NORMALIZE_STYLE: () => NORMALIZE_STYLE,
Namespaces: () => Namespaces,
NodeTypes: () => NodeTypes,
OPEN_BLOCK: () => OPEN_BLOCK,
POP_SCOPE_ID: () => POP_SCOPE_ID,
PUSH_SCOPE_ID: () => PUSH_SCOPE_ID,
RENDER_LIST: () => RENDER_LIST,
RENDER_SLOT: () => RENDER_SLOT,
RESOLVE_COMPONENT: () => RESOLVE_COMPONENT,
RESOLVE_DIRECTIVE: () => RESOLVE_DIRECTIVE,
RESOLVE_DYNAMIC_COMPONENT: () => RESOLVE_DYNAMIC_COMPONENT,
RESOLVE_FILTER: () => RESOLVE_FILTER,
SET_BLOCK_TRACKING: () => SET_BLOCK_TRACKING,
SUSPENSE: () => SUSPENSE,
TELEPORT: () => TELEPORT,
TO_DISPLAY_STRING: () => TO_DISPLAY_STRING,
TO_HANDLERS: () => TO_HANDLERS,
TO_HANDLER_KEY: () => TO_HANDLER_KEY,
TRANSITION: () => TRANSITION,
TRANSITION_GROUP: () => TRANSITION_GROUP,
TS_NODE_TYPES: () => TS_NODE_TYPES,
UNREF: () => UNREF,
V_MODEL_CHECKBOX: () => V_MODEL_CHECKBOX,
V_MODEL_DYNAMIC: () => V_MODEL_DYNAMIC,
V_MODEL_RADIO: () => V_MODEL_RADIO,
V_MODEL_SELECT: () => V_MODEL_SELECT,
V_MODEL_TEXT: () => V_MODEL_TEXT,
V_ON_WITH_KEYS: () => V_ON_WITH_KEYS,
V_ON_WITH_MODIFIERS: () => V_ON_WITH_MODIFIERS,
V_SHOW: () => V_SHOW,
WITH_CTX: () => WITH_CTX,
WITH_DIRECTIVES: () => WITH_DIRECTIVES,
WITH_MEMO: () => WITH_MEMO,
advancePositionWithClone: () => advancePositionWithClone,
advancePositionWithMutation: () => advancePositionWithMutation,
assert: () => assert,
baseCompile: () => baseCompile,
baseParse: () => baseParse,
buildDirectiveArgs: () => buildDirectiveArgs,
buildProps: () => buildProps,
buildSlots: () => buildSlots,
checkCompatEnabled: () => checkCompatEnabled,
compile: () => compile,
convertToBlock: () => convertToBlock,
createArrayExpression: () => createArrayExpression,
createAssignmentExpression: () => createAssignmentExpression,
createBlockStatement: () => createBlockStatement,
createCacheExpression: () => createCacheExpression,
createCallExpression: () => createCallExpression,
createCompilerError: () => createCompilerError,
createCompoundExpression: () => createCompoundExpression,
createConditionalExpression: () => createConditionalExpression,
createDOMCompilerError: () => createDOMCompilerError,
createForLoopParams: () => createForLoopParams,
createFunctionExpression: () => createFunctionExpression,
createIfStatement: () => createIfStatement,
createInterpolation: () => createInterpolation,
createObjectExpression: () => createObjectExpression,
createObjectProperty: () => createObjectProperty,
createReturnStatement: () => createReturnStatement,
createRoot: () => createRoot,
createSequenceExpression: () => createSequenceExpression,
createSimpleExpression: () => createSimpleExpression,
createStructuralDirectiveTransform: () => createStructuralDirectiveTransform,
createTemplateLiteral: () => createTemplateLiteral,
createTransformContext: () => createTransformContext,
createVNodeCall: () => createVNodeCall,
errorMessages: () => errorMessages,
extractIdentifiers: () => extractIdentifiers,
findDir: () => findDir,
findProp: () => findProp,
forAliasRE: () => forAliasRE,
generate: () => generate,
generateCodeFrame: () => generateCodeFrame,
getBaseTransformPreset: () => getBaseTransformPreset,
getConstantType: () => getConstantType,
getMemoedVNodeCall: () => getMemoedVNodeCall,
getVNodeBlockHelper: () => getVNodeBlockHelper,
getVNodeHelper: () => getVNodeHelper,
hasDynamicKeyVBind: () => hasDynamicKeyVBind,
hasScopeRef: () => hasScopeRef,
helperNameMap: () => helperNameMap,
injectProp: () => injectProp,
isCoreComponent: () => isCoreComponent,
isFnExpression: () => isFnExpression,
isFnExpressionBrowser: () => isFnExpressionBrowser,
isFnExpressionNode: () => isFnExpressionNode,
isFunctionType: () => isFunctionType,
isInDestructureAssignment: () => isInDestructureAssignment,
isInNewExpression: () => isInNewExpression,
isMemberExpression: () => isMemberExpression,
isMemberExpressionBrowser: () => isMemberExpressionBrowser,
isMemberExpressionNode: () => isMemberExpressionNode,
isReferencedIdentifier: () => isReferencedIdentifier,
isSimpleIdentifier: () => isSimpleIdentifier,
isSlotOutlet: () => isSlotOutlet,
isStaticArgOf: () => isStaticArgOf,
isStaticExp: () => isStaticExp,
isStaticProperty: () => isStaticProperty,
isStaticPropertyKey: () => isStaticPropertyKey,
isTemplateNode: () => isTemplateNode,
isText: () => isText$1,
isVSlot: () => isVSlot,
locStub: () => locStub,
noopDirectiveTransform: () => noopDirectiveTransform,
parse: () => parse,
parserOptions: () => parserOptions,
processExpression: () => processExpression,
processFor: () => processFor,
processIf: () => processIf,
processSlotOutlet: () => processSlotOutlet,
registerRuntimeHelpers: () => registerRuntimeHelpers,
resolveComponentType: () => resolveComponentType,
stringifyExpression: () => stringifyExpression,
toValidAssetId: () => toValidAssetId,
trackSlotScopes: () => trackSlotScopes,
trackVForSlotScopes: () => trackVForSlotScopes,
transform: () => transform,
transformBind: () => transformBind,
transformElement: () => transformElement,
transformExpression: () => transformExpression,
transformModel: () => transformModel,
transformOn: () => transformOn,
transformStyle: () => transformStyle,
traverseNode: () => traverseNode,
unwrapTSNode: () => unwrapTSNode,
walkBlockDeclarations: () => walkBlockDeclarations,
walkFunctionParams: () => walkFunctionParams,
walkIdentifiers: () => walkIdentifiers,
warnDeprecation: () => warnDeprecation
});
init_compiler_dom_esm_bundler = __esm({
"../../../node_modules/.pnpm/@vue+compiler-dom@3.5.13/node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js": () => {
init_compiler_core_esm_bundler();
init_compiler_core_esm_bundler();
init_shared_esm_bundler();
V_MODEL_RADIO = Symbol(``);
V_MODEL_CHECKBOX = Symbol(``);
V_MODEL_TEXT = Symbol(``);
V_MODEL_SELECT = Symbol(``);
V_MODEL_DYNAMIC = Symbol(``);
V_ON_WITH_MODIFIERS = Symbol(``);
V_ON_WITH_KEYS = Symbol(``);
V_SHOW = Symbol(``);
TRANSITION = Symbol(``);
TRANSITION_GROUP = Symbol(``);
registerRuntimeHelpers({
[V_MODEL_RADIO]: `vModelRadio`,
[V_MODEL_CHECKBOX]: `vModelCheckbox`,
[V_MODEL_TEXT]: `vModelText`,
[V_MODEL_SELECT]: `vModelSelect`,
[V_MODEL_DYNAMIC]: `vModelDynamic`,
[V_ON_WITH_MODIFIERS]: `withModifiers`,
[V_ON_WITH_KEYS]: `withKeys`,
[V_SHOW]: `vShow`,
[TRANSITION]: `Transition`,
[TRANSITION_GROUP]: `TransitionGroup`
});
;
parserOptions = {
parseMode: "html",
isVoidTag,
isNativeTag: tag => isHTMLTag(tag) || isSVGTag(tag) || isMathMLTag(tag),
isPreTag: tag => tag === "pre",
isIgnoreNewlineTag: tag => tag === "pre" || tag === "textarea",
decodeEntities: decodeHtmlBrowser,
isBuiltInComponent: tag => {
if (tag === "Transition" || tag === "transition") return TRANSITION;else if (tag === "TransitionGroup" || tag === "transition-group") return TRANSITION_GROUP;
},
getNamespace(tag, parent, rootNamespace) {
let ns = parent ? parent.ns : rootNamespace;
if (parent && ns === 2) {
if (parent.tag === "annotation-xml") {
if (tag === "svg") return 1;
if (parent.props.some(a => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml"))) ns = 0;
} else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") ns = 0;
} else if (parent && ns === 1) {
if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") ns = 0;
}
if (ns === 0) {
if (tag === "svg") return 1;
if (tag === "math") return 2;
}
return ns;
}
};
transformStyle = node => {
if (node.type === 1) node.props.forEach((p, i) => {
if (p.type === 6 && p.name === "style" && p.value) node.props[i] = {
type: 7,
name: `bind`,
arg: createSimpleExpression(`style`, true, p.loc),
exp: parseInlineCSS(p.value.content, p.loc),
modifiers: [],
loc: p.loc
};
});
};
parseInlineCSS = (cssText, loc) => {
const normalized = parseStringStyle(cssText);
return createSimpleExpression(JSON.stringify(normalized), false, loc, 3);
};
DOMErrorCodes = {
"X_V_HTML_NO_EXPRESSION": 53,
"53": "X_V_HTML_NO_EXPRESSION",
"X_V_HTML_WITH_CHILDREN": 54,
"54": "X_V_HTML_WITH_CHILDREN",
"X_V_TEXT_NO_EXPRESSION": 55,
"55": "X_V_TEXT_NO_EXPRESSION",
"X_V_TEXT_WITH_CHILDREN": 56,
"56": "X_V_TEXT_WITH_CHILDREN",
"X_V_MODEL_ON_INVALID_ELEMENT": 57,
"57": "X_V_MODEL_ON_INVALID_ELEMENT",
"X_V_MODEL_ARG_ON_ELEMENT": 58,
"58": "X_V_MODEL_ARG_ON_ELEMENT",
"X_V_MODEL_ON_FILE_INPUT_ELEMENT": 59,
"59": "X_V_MODEL_ON_FILE_INPUT_ELEMENT",
"X_V_MODEL_UNNECESSARY_VALUE": 60,
"60": "X_V_MODEL_UNNECESSARY_VALUE",
"X_V_SHOW_NO_EXPRESSION": 61,
"61": "X_V_SHOW_NO_EXPRESSION",
"X_TRANSITION_INVALID_CHILDREN": 62,
"62": "X_TRANSITION_INVALID_CHILDREN",
"X_IGNORED_SIDE_EFFECT_TAG": 63,
"63": "X_IGNORED_SIDE_EFFECT_TAG",
"__EXTEND_POINT__": 64,
"64": "__EXTEND_POINT__"
};
DOMErrorMessages = {
[53]: `v-html is missing expression.`,
[54]: `v-html will override element children.`,
[55]: `v-text is missing expression.`,
[56]: `v-text will override element children.`,
[57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
[58]: `v-model argument is not supported on plain elements.`,
[59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
[60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
[61]: `v-show is missing expression.`,
[62]: `<Transition> expects exactly one child element or component.`,
[63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
};
transformVHtml = (dir, node, context) => {
const {
exp,
loc
} = dir;
if (!exp) context.onError(createDOMCompilerError(53, loc));
if (node.children.length) {
context.onError(createDOMCompilerError(54, loc));
node.children.length = 0;
}
return {
props: [createObjectProperty(createSimpleExpression(`innerHTML`, true, loc), exp || createSimpleExpression("", true))]
};
};
transformVText = (dir, node, context) => {
const {
exp,
loc
} = dir;
if (!exp) context.onError(createDOMCompilerError(55, loc));
if (node.children.length) {
context.onError(createDOMCompilerError(56, loc));
node.children.length = 0;
}
return {
props: [createObjectProperty(createSimpleExpression(`textContent`, true), exp ? getConstantType(exp, context) > 0 ? exp : createCallExpression(context.helperString(TO_DISPLAY_STRING), [exp], loc) : createSimpleExpression("", true))]
};
};
transformModel$1 = (dir, node, context) => {
const baseResult = transformModel(dir, node, context);
if (!baseResult.props.length || node.tagType === 1) return baseResult;
if (dir.arg) context.onError(createDOMCompilerError(58, dir.arg.loc));
const {
tag
} = node;
const isCustomElement = context.isCustomElement(tag);
if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
let directiveToUse = V_MODEL_TEXT;
let isInvalidType = false;
if (tag === "input" || isCustomElement) {
const type = findProp(node, `type`);
if (type) {
if (type.type === 7) directiveToUse = V_MODEL_DYNAMIC;else if (type.value) switch (type.value.content) {
case "radio":
directiveToUse = V_MODEL_RADIO;
break;
case "checkbox":
directiveToUse = V_MODEL_CHECKBOX;
break;
case "file":
isInvalidType = true;
context.onError(createDOMCompilerError(59, dir.loc));
break;
default:
break;
}
} else if (hasDynamicKeyVBind(node)) directiveToUse = V_MODEL_DYNAMIC;
} else if (tag === "select") directiveToUse = V_MODEL_SELECT;
if (!isInvalidType) baseResult.needRuntime = context.helper(directiveToUse);
} else context.onError(createDOMCompilerError(57, dir.loc));
baseResult.props = baseResult.props.filter(p => !(p.key.type === 4 && p.key.content === "modelValue"));
return baseResult;
};
isEventOptionModifier = /* @__PURE__ */makeMap(`passive,once,capture`);
isNonKeyModifier = /* @__PURE__ */makeMap(`stop,prevent,self,ctrl,shift,alt,meta,exact,middle`);
maybeKeyModifier = /* @__PURE__ */makeMap("left,right");
isKeyboardEvent = /* @__PURE__ */makeMap(`onkeyup,onkeydown,onkeypress`);
resolveModifiers = (key, modifiers, context, loc) => {
const keyModifiers = [];
const nonKeyModifiers = [];
const eventOptionModifiers = [];
for (let i = 0; i < modifiers.length; i++) {
const modifier = modifiers[i].content;
if (modifier === "native" && checkCompatEnabled("COMPILER_V_ON_NATIVE", context, loc)) eventOptionModifiers.push(modifier);else if (isEventOptionModifier(modifier)) eventOptionModifiers.push(modifier);else if (maybeKeyModifier(modifier)) {
if (isStaticExp(key)) {
if (isKeyboardEvent(key.content.toLowerCase())) keyModifiers.push(modifier);else nonKeyModifiers.push(modifier);
} else {
keyModifiers.push(modifier);
nonKeyModifiers.push(modifier);
}
} else if (isNonKeyModifier(modifier)) nonKeyModifiers.push(modifier);else keyModifiers.push(modifier);
}
return {
keyModifiers,
nonKeyModifiers,
eventOptionModifiers
};
};
transformClick = (key, event) => {
return isStaticExp(key) && key.content.toLowerCase() === "onclick" ? createSimpleExpression(event, true) : key.type !== 4 ? createCompoundExpression([`(`, key, `) === "onClick" ? "${event}" : (`, key, `)`]) : key;
};
transformOn$1 = (dir, node, context) => {
return transformOn(dir, node, context, baseResult => {
const {
modifiers
} = dir;
if (!modifiers.length) return baseResult;
let {
key,
value: handlerExp
} = baseResult.props[0];
const {
keyModifiers,
nonKeyModifiers,
eventOptionModifiers
} = resolveModifiers(key, modifiers, context, dir.loc);
if (nonKeyModifiers.includes("right")) key = transformClick(key, `onContextmenu`);
if (nonKeyModifiers.includes("middle")) key = transformClick(key, `onMouseup`);
if (nonKeyModifiers.length) handlerExp = createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [handlerExp, JSON.stringify(nonKeyModifiers)]);
if (keyModifiers.length && (!isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) handlerExp = createCallExpression(context.helper(V_ON_WITH_KEYS), [handlerExp, JSON.stringify(keyModifiers)]);
if (eventOptionModifiers.length) {
const modifierPostfix = eventOptionModifiers.map(capitalize).join("");
key = isStaticExp(key) ? createSimpleExpression(`${key.content}${modifierPostfix}`, true) : createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
}
return {
props: [createObjectProperty(key, handlerExp)]
};
});
};
transformShow = (dir, node, context) => {
const {
exp,
loc
} = dir;
if (!exp) context.onError(createDOMCompilerError(61, loc));
return {
props: [],
needRuntime: context.helper(V_SHOW)
};
};
ignoreSideEffectTags = (node, context) => {
if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) context.removeNode();
};
DOMNodeTransforms = [transformStyle, ...[]];
DOMDirectiveTransforms = {
cloak: noopDirectiveTransform,
html: transformVHtml,
text: transformVText,
model: transformModel$1,
on: transformOn$1,
show: transformShow
};
}
}); //#endregion
//#region ../../../node_modules/.pnpm/vue@3.5.13_typescript@5.9.2/node_modules/vue/dist/vue.cjs.prod.js
require_vue_cjs_prod = /* @__PURE__ */__commonJS({
"../../../node_modules/.pnpm/vue@3.5.13_typescript@5.9.2/node_modules/vue/dist/vue.cjs.prod.js": exports => {
Object.defineProperty(exports, "__esModule", {
value: true
});
var compilerDom = (init_compiler_dom_esm_bundler(), __toCommonJS(compiler_dom_esm_bundler_exports));
var runtimeDom = (init_runtime_dom_esm_bundler(), __toCommonJS(runtime_dom_esm_bundler_exports));
var shared = (init_shared_esm_bundler(), __toCommonJS(shared_esm_bundler_exports));
function _interopNamespaceDefault(e) {
var n = Object.create(null);
if (e) for (var k in e) n[k] = e[k];
n.default = e;
return Object.freeze(n);
}
var runtimeDom__namespace = /* @__PURE__ */_interopNamespaceDefault(runtimeDom);
var compileCache = /* @__PURE__ */Object.create(null);
function compileToFunction(template, options) {
if (!shared.isString(template)) if (template.nodeType) template = template.innerHTML;else return shared.NOOP;
const key = shared.genCacheKey(template, options);
const cached = compileCache[key];
if (cached) return cached;
if (template[0] === "#") {
const el = document.querySelector(template);
template = el ? el.innerHTML : ``;
}
const opts = shared.extend({
hoistStatic: true,
onError: void 0,
onWarn: shared.NOOP
}, options);
if (!opts.isCustomElement && typeof customElements !== "undefined") opts.isCustomElement = tag => !!customElements.get(tag);
const {
code
} = compilerDom.compile(template, opts);
const render = new Function("Vue", code)(runtimeDom__namespace);
render._rc = true;
return compileCache[key] = render;
}
runtimeDom.registerRuntimeCompiler(compileToFunction);
exports.compile = compileToFunction;
Object.keys(runtimeDom).forEach(function (k) {
if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = runtimeDom[k];
});
}
}); //#endregion
//#region ../../../node_modules/.pnpm/vue@3.5.13_typescript@5.9.2/node_modules/vue/index.js
_export("t", require_vue = /* @__PURE__ */__commonJS({
"../../../node_modules/.pnpm/vue@3.5.13_typescript@5.9.2/node_modules/vue/index.js": (exports, module) => {
module.exports = require_vue_cjs_prod();
}
})); //#endregion
}
};
});
})();