/** * @vue/compiler-dom v3.6.0-rc.10 * (c) 2018-present Yuxi (Evan) You and Vue contributors * @license MIT **/ //#region packages/shared/src/makeMap.ts /** * Make a map and return a function for checking if a key * is in that map. * IMPORTANT: all calls of this function must be prefixed with * \/\*#\_\_PURE\_\_\*\/ * So that they can be tree-shaken if necessary. */ /*@__NO_SIDE_EFFECTS__*/ function makeMap(str) { const map = Object.create(null); for (const key of str.split(",")) map[key] = 1; return (val) => val in map; } //#endregion //#region packages/shared/src/general.ts const EMPTY_OBJ = Object.freeze({}); Object.freeze([]); const NOOP = () => {}; /** * Always return false. */ const NO = () => false; const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && (key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97); const extend = Object.assign; const isArray = Array.isArray; const isString = (val) => typeof val === "string"; const isSymbol = (val) => typeof val === "symbol"; const isObject = (val) => val !== null && typeof val === "object"; const isReservedProp = /*@__PURE__*/ makeMap(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"); const isBuiltInDirective = /*@__PURE__*/ makeMap("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"); const cacheStringFunction = (fn) => { const cache = Object.create(null); return ((str) => { return cache[str] || (cache[str] = fn(str)); }); }; const camelizeRE = /-(\w)/g; const camelizeReplacer = (_, c) => c ? c.toUpperCase() : ""; /** * @private */ const camelize = cacheStringFunction((str) => str.replace(camelizeRE, camelizeReplacer)); /** * @private */ const capitalize = cacheStringFunction((str) => { return str.charAt(0).toUpperCase() + str.slice(1); }); /** * @private */ const toHandlerKey = cacheStringFunction((str) => { return str ? `on${capitalize(str)}` : ``; }); /** * #13070 When v-model and v-model:model directives are used together, * they will generate the same modelModifiers prop, * so a `$` suffix is added to avoid conflicts. * @private */ const getModifierPropName = (name) => { return `${name === "modelValue" || name === "model-value" ? "model" : name}Modifiers${name === "model" ? "$" : ""}`; }; //#endregion //#region packages/shared/src/patchFlags.ts /** * dev only flag -> name mapping */ const PatchFlagNames = { [1]: `TEXT`, [2]: `CLASS`, [4]: `STYLE`, [8]: `PROPS`, [16]: `FULL_PROPS`, [32]: `NEED_HYDRATION`, [64]: `STABLE_FRAGMENT`, [128]: `KEYED_FRAGMENT`, [256]: `UNKEYED_FRAGMENT`, [512]: `NEED_PATCH`, [1024]: `DYNAMIC_SLOTS`, [2048]: `DEV_ROOT_FRAGMENT`, [-1]: `CACHED`, [-2]: `BAIL` }; //#endregion //#region packages/shared/src/slotFlags.ts /** * Dev only */ const slotFlagsText = { [1]: "STABLE", [2]: "DYNAMIC", [3]: "FORWARDED" }; //#endregion //#region packages/shared/src/codeframe.ts const range = 2; function generateCodeFrame(source, start = 0, end = source.length) { start = Math.max(0, Math.min(start, source.length)); end = Math.max(0, Math.min(end, source.length)); if (start > end) return ""; let lines = source.split(/(\r?\n)/); const newlineSequences = lines.filter((_, idx) => idx % 2 === 1); lines = lines.filter((_, idx) => idx % 2 === 0); let count = 0; const res = []; for (let i = 0; i < lines.length; i++) { count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0); if (count >= start) { for (let j = i - range; j <= i + range || end > count; j++) { if (j < 0 || j >= lines.length) continue; const line = j + 1; res.push(`${line}${" ".repeat(Math.max(3 - String(line).length, 0))}| ${lines[j]}`); const lineLength = lines[j].length; const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0; if (j === i) { const pad = start - (count - (lineLength + newLineSeqLength)); const length = Math.max(1, end > count ? lineLength - pad : end - start); res.push(` | ` + " ".repeat(pad) + "^".repeat(length)); } else if (j > i) { if (end > count) { const length = Math.max(Math.min(end - count, lineLength), 1); res.push(` | ` + "^".repeat(length)); } count += lineLength + newLineSeqLength; } } break; } } return res.join("\n"); } //#endregion //#region packages/shared/src/normalizeProp.ts const listDelimiterRE = /;(?![^(]*\))/g; const propertyDelimiterRE = /:([^]+)/; const styleCommentRE = /"(?:[^"\\]|\\[^])*"|'(?:[^'\\]|\\[^])*'|\\[^]|\/\*[^]*?\*\//g; function parseStringStyle(cssText) { const ret = {}; cssText.replace(styleCommentRE, (match) => match.startsWith("/*") ? "" : match).split(listDelimiterRE).forEach((item) => { if (item) { const tmp = item.split(propertyDelimiterRE); tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); } }); return ret; } //#endregion //#region packages/shared/src/domTagConfig.ts const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot"; const SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view"; const MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics"; const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr"; /** * Compiler only. * Do NOT use in runtime code paths unless behind `__DEV__` flag. */ const isHTMLTag = /*@__PURE__*/ makeMap(HTML_TAGS); /** * Compiler only. * Do NOT use in runtime code paths unless behind `__DEV__` flag. */ const isSVGTag = /*@__PURE__*/ makeMap(SVG_TAGS); /** * Compiler only. * Do NOT use in runtime code paths unless behind `__DEV__` flag. */ const isMathMLTag = /*@__PURE__*/ makeMap(MATH_TAGS); /** * Compiler only. * Do NOT use in runtime code paths unless behind `__DEV__` flag. */ const isVoidTag = /*@__PURE__*/ makeMap(VOID_TAGS); //#endregion //#region packages/compiler-core/src/runtimeHelpers.ts const FRAGMENT = Symbol(`Fragment`); const TELEPORT = Symbol(`Teleport`); const SUSPENSE = Symbol(`Suspense`); const KEEP_ALIVE = Symbol(`KeepAlive`); const BASE_TRANSITION = Symbol(`BaseTransition`); const OPEN_BLOCK = Symbol(`openBlock`); const CREATE_BLOCK = Symbol(`createBlock`); const CREATE_ELEMENT_BLOCK = Symbol(`createElementBlock`); const CREATE_VNODE = Symbol(`createVNode`); const CREATE_ELEMENT_VNODE = Symbol(`createElementVNode`); const CREATE_COMMENT = Symbol(`createCommentVNode`); const CREATE_TEXT = Symbol(`createTextVNode`); const CREATE_STATIC = Symbol(`createStaticVNode`); const RESOLVE_COMPONENT = Symbol(`resolveComponent`); const RESOLVE_DYNAMIC_COMPONENT = Symbol(`resolveDynamicComponent`); const RESOLVE_DIRECTIVE = Symbol(`resolveDirective`); const RESOLVE_FILTER = Symbol(`resolveFilter`); const WITH_DIRECTIVES = Symbol(`withDirectives`); const RENDER_LIST = Symbol(`renderList`); const RENDER_SLOT = Symbol(`renderSlot`); const CREATE_SLOTS = Symbol(`createSlots`); const TO_DISPLAY_STRING = Symbol(`toDisplayString`); const MERGE_PROPS = Symbol(`mergeProps`); const NORMALIZE_CLASS = Symbol(`normalizeClass`); const NORMALIZE_STYLE = Symbol(`normalizeStyle`); const NORMALIZE_PROPS = Symbol(`normalizeProps`); const GUARD_REACTIVE_PROPS = Symbol(`guardReactiveProps`); const TO_HANDLERS = Symbol(`toHandlers`); const CAMELIZE = Symbol(`camelize`); const CAPITALIZE = Symbol(`capitalize`); const TO_HANDLER_KEY = Symbol(`toHandlerKey`); const SET_BLOCK_TRACKING = Symbol(`setBlockTracking`); /** * @deprecated no longer needed in 3.5+ because we no longer hoist element nodes * but kept for backwards compat */ const PUSH_SCOPE_ID = Symbol(`pushScopeId`); /** * @deprecated kept for backwards compat */ const POP_SCOPE_ID = Symbol(`popScopeId`); const WITH_CTX = Symbol(`withCtx`); const UNREF = Symbol(`unref`); const IS_REF = Symbol(`isRef`); const WITH_MEMO = Symbol(`withMemo`); const IS_MEMO_SAME = Symbol(`isMemoSame`); const 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` }; function registerRuntimeHelpers(helpers) { Object.getOwnPropertySymbols(helpers).forEach((s) => { helperNameMap[s] = helpers[s]; }); } //#endregion //#region packages/compiler-core/src/ast.ts const 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" }; const ElementTypes = { "ELEMENT": 0, "0": "ELEMENT", "COMPONENT": 1, "1": "COMPONENT", "SLOT": 2, "2": "SLOT", "TEMPLATE": 3, "3": "TEMPLATE" }; /** * Static types have several levels. * Higher levels implies lower levels. e.g. a node that can be stringified * can always be hoisted and skipped for patch. */ const 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" }; const locStub = { start: { line: 1, column: 1, offset: 0 }, end: { line: 1, column: 1, offset: 0 }, source: "" }; 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 = false, loc = locStub) { if (context) { if (isBlock) { context.helper(OPEN_BLOCK); context.helper(getVNodeBlockHelper(context.inSSR, isComponent)); } else context.helper(getVNodeHelper(context.inSSR, isComponent)); if (directives) context.helper(WITH_DIRECTIVES); } return { type: 13, tag, props, children, patchFlag, dynamicProps, directives, isBlock, disableTracking, isComponent, 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) { return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE; } function getVNodeBlockHelper(ssr, isComponent) { return ssr || isComponent ? 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)); } } //#endregion //#region packages/compiler-core/src/tokenizer.ts const defaultDelimitersOpen = new Uint8Array([123, 123]); const defaultDelimitersClose = new Uint8Array([125, 125]); /** * HTML only allows ASCII alpha characters (a-z and A-Z) at the beginning of a * tag name. */ 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; } /** * Sequences used to match longer strings. * * We don't have `Script`, `Style`, or `Title` here. Instead, we re-use the *End * sequences with an increased offset. */ const 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 ]) }; var Tokenizer = class { get inSFCRoot() { return this.mode === 2 && this.stack.length === 0; } constructor(stack, cbs) { this.stack = stack; this.cbs = cbs; this.state = 1; this.buffer = ""; this.sectionStart = 0; this.index = 0; this.entityStart = 0; this.baseState = 1; this.inRCDATA = false; this.inXML = false; this.inVPre = false; this.newlines = []; this.mode = 0; this.delimiterOpen = defaultDelimitersOpen; this.delimiterClose = defaultDelimitersClose; this.delimiterIndex = -1; this.currentSequence = void 0; this.sequenceIndex = 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; const length = this.newlines.length; let j = -1; if (length > 100) { let l = -1; let r = length; while (l + 1 < r) { const m = l + r >>> 1; this.newlines[m] < index ? l = m : r = m; } j = l; } else for (let i = length - 1; i >= 0; i--) if (index > this.newlines[i]) { j = i; break; } if (j >= 0) { line = j + 2; column = index - this.newlines[j]; } 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 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.cbs.onerr(14, this.index); 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; if (this.peek() !== 62) this.cbs.onerr(22, this.index); } else if (c === 60 && this.peek() === 47) { this.cbs.onopentagend(this.index); this.state = 5; this.sectionStart = this.index; } else if (!isWhitespace(c)) { if (c === 61) this.cbs.onerr(19, this.index); 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); } else if (c === 34 || c === 39 || c === 60) this.cbs.onerr(17, this.index); } 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); this.cbs.onerr(27, this.index); } } 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 === 34 || 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.state !== 33) 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(); } 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) {} }; //#endregion //#region packages/compiler-core/src/compat/compatConfig.ts const 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" }; const 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` } }; 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) { const enabled = isCompatEnabled(key, context); if (enabled) warnDeprecation(key, context, loc, ...args); return enabled; } 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 ? `\n Details: ${link}` : ``}`; const err = new SyntaxError(msg); err.code = key; if (loc) err.loc = loc; context.onWarn(err); } //#endregion //#region packages/compiler-core/src/errors.ts function defaultOnError(error) { throw error; } function defaultOnWarn(msg) { console.warn(`[Vue warn] ${msg.message}`); } function createCompilerError(code, loc, messages, additionalMessage) { const msg = (messages || errorMessages)[code] + (additionalMessage || ``); const error = new SyntaxError(String(msg)); error.code = code; error.loc = loc; return error; } const 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_V_MODEL_ON_CONST": 45, "45": "X_V_MODEL_ON_CONST", "X_INVALID_EXPRESSION": 46, "46": "X_INVALID_EXPRESSION", "X_KEEP_ALIVE_INVALID_CHILDREN": 47, "47": "X_KEEP_ALIVE_INVALID_CHILDREN", "X_PREFIX_ID_NOT_SUPPORTED": 48, "48": "X_PREFIX_ID_NOT_SUPPORTED", "X_MODULE_MODE_NOT_SUPPORTED": 49, "49": "X_MODULE_MODE_NOT_SUPPORTED", "X_CACHE_HANDLER_NOT_SUPPORTED": 50, "50": "X_CACHE_HANDLER_NOT_SUPPORTED", "X_SCOPE_ID_NOT_SUPPORTED": 51, "51": "X_SCOPE_ID_NOT_SUPPORTED", "X_VNODE_HOOKS": 52, "52": "X_VNODE_HOOKS", "X_V_BIND_INVALID_SAME_NAME_ARGUMENT": 53, "53": "X_V_BIND_INVALID_SAME_NAME_ARGUMENT", "__EXTEND_POINT__": 54, "54": "__EXTEND_POINT__" }; const 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.`, [53]: `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.\nUse a v-bind binding combined with a v-on listener that emits update:x event instead.`, [45]: `v-model cannot be used on a const binding because it is not writable.`, [46]: `Error parsing JavaScript expression: `, [47]: `<KeepAlive> expects exactly one child component.`, [52]: `@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.`, [48]: `"prefixIdentifiers" option is not supported in this build of compiler.`, [49]: `ES module mode is not supported in this build of compiler.`, [50]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`, [51]: `"scopeId" option is only supported in module mode.`, [54]: `` }; //#endregion //#region packages/compiler-core/src/babelUtils.ts /** * Return value indicates whether the AST walked can be a constant */ function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = 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) { const body = block.type === "SwitchCase" ? block.consequent : block.body; for (const stmt of 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); else if (stmt.type === "SwitchStatement") walkSwitchStatement(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 walkSwitchStatement(stmt, isVar, onIdent) { for (const cs of stmt.cases) { for (const stmt of cs.consequent) if (stmt.type === "VariableDeclaration" && (stmt.kind === "var" ? isVar : !isVar)) for (const decl of stmt.declarations) for (const id of extractIdentifiers(decl.id)) onIdent(id); walkBlockDeclarations(cs, onIdent); } } 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); } return nodes; } const isFunctionType = (node) => { return /Function(?:Expression|Declaration)$|Method$/.test(node.type); }; const isStaticProperty = (node) => !!node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed; const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node; const TS_NODE_TYPES = [ "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression", "TSInstantiationExpression", "TSSatisfiesExpression" ]; function unwrapTSNode(node) { if (TS_NODE_TYPES.includes(node.type)) return unwrapTSNode(node.expression); else return node; } function isStaticNode(node) { node = unwrapTSNode(node); switch (node.type) { case "UnaryExpression": return isStaticNode(node.argument); case "LogicalExpression": case "BinaryExpression": return isStaticNode(node.left) && isStaticNode(node.right); case "ConditionalExpression": return isStaticNode(node.test) && isStaticNode(node.consequent) && isStaticNode(node.alternate); case "SequenceExpression": case "TemplateLiteral": return node.expressions.every((expr) => isStaticNode(expr)); case "ParenthesizedExpression": return isStaticNode(node.expression); case "StringLiteral": case "NumericLiteral": case "BooleanLiteral": case "NullLiteral": case "BigIntLiteral": return true; } return false; } function isConstantNode(node, bindings) { if (isStaticNode(node)) return true; node = unwrapTSNode(node); switch (node.type) { case "Identifier": return bindings[node.name] === "literal-const"; case "RegExpLiteral": return true; case "ObjectExpression": return node.properties.every((prop) => { if (prop.type === "ObjectMethod") return false; if (prop.type === "SpreadElement") return isConstantNode(prop.argument, bindings); return (!prop.computed || isConstantNode(prop.key, bindings)) && isConstantNode(prop.value, bindings); }); case "ArrayExpression": return node.elements.every((element) => { if (element === null) return true; if (element.type === "SpreadElement") return isConstantNode(element.argument, bindings); return isConstantNode(element, bindings); }); } return false; } //#endregion //#region packages/compiler-core/src/utils.ts const isStaticExp = (p) => p.type === 4 && p.isStatic; 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; } } const nonIdentifierRE = /^$|^\d|[^\$\w\xA0-\uFFFF]/; const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name); const MemberExpLexState = { "inMemberExp": 0, "0": "inMemberExp", "inBrackets": 1, "1": "inBrackets", "inParens": 2, "2": "inParens", "inString": 3, "3": "inString" }; const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/; const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/; const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g; const getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source; /** * Simple lexer to check if an expression is a member expression. This is * lax and only checks validity at the root level (i.e. does not validate exps * inside square brackets), but it's ok since these are only used on template * expressions and false positives are invalid expressions in the first place. */ const 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; } } } return !currentOpenBracketCount && !currentOpenParensCount; }; const isMemberExpressionNode = NOOP; const isMemberExpression = isMemberExpressionBrowser; const fnExpRE = /^\s*(?:async\s*)?(?:\([^)]*?\)|[\w$_]+)\s*(?::[^=]+)?=>|^\s*(?:async\s+)?function(?:\s+[\w$]+)?\s*\(/; const isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp)); const isFnExpressionNode = NOOP; const isFnExpression = isFnExpressionBrowser; 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) { /* v8 ignore next 3 */ if (!condition) throw new Error(msg || `unexpected compiler condition`); } /** find directive */ 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(node) { return node.type === 5 || node.type === 2; } function isVPre(p) { return p.type === 7 && p.name === "pre"; } 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; } const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]); 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) { if (node.type !== 13 && injectSlotKey(node, prop)) return; let propsWithInjection; /** * 1. mergeProps(...) * 2. toHandlers(...) * 3. normalizeProps(...) * 4. normalizeProps(guardReactiveProps(...)) * * we need to get the real props before normalization */ 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 injectSlotKey(node, prop) { var _node$arguments, _node$arguments2, _node$arguments3; if (prop.key.type !== 4 || prop.key.content !== "key") return false; const props = node.arguments[2]; if (props && !isString(props)) { const [unnormalizedProps] = getUnnormalizedProps(props); if (unnormalizedProps && !isString(unnormalizedProps) && unnormalizedProps.type === 15 && hasProp(prop, unnormalizedProps)) return true; } (_node$arguments = node.arguments)[2] || (_node$arguments[2] = "{}"); (_node$arguments2 = node.arguments)[3] || (_node$arguments2[3] = "undefined"); (_node$arguments3 = node.arguments)[4] || (_node$arguments3[4] = "undefined"); node.arguments[5] = prop.value; return true; } 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 filterNonCommentChildren(node) { return node.children.filter((n) => !isCommentOrWhitespace(n)); } function hasSingleChild(node) { return filterNonCommentChildren(node).length === 1; } function isSingleIfBlock(parent) { let hasEncounteredIf = false; for (const c of filterNonCommentChildren(parent)) if (c.type === 9 || c.type === 1 && findDir(c, "if")) { if (hasEncounteredIf) return false; hasEncounteredIf = true; } else if (!hasEncounteredIf || !(c.type === 1 && findDir(c, /^else(-if)?$/, true))) return false; return true; } const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/; function isAllWhitespace(str) { for (let i = 0; i < str.length; i++) if (!isWhitespace(str.charCodeAt(i))) return false; return true; } function isWhitespaceText(node) { return node.type === 2 && isAllWhitespace(node.content) || node.type === 12 && isWhitespaceText(node.content); } function isCommentOrWhitespace(node) { return node.type === 3 || isWhitespaceText(node); } //#endregion //#region packages/compiler-core/src/parser.ts const defaultParserOptions = { parseMode: "base", ns: 0, delimiters: [`{{`, `}}`], getNamespace: () => 0, isVoidTag: NO, isPreTag: NO, isIgnoreNewlineTag: NO, isCustomElement: NO, onError: defaultOnError, onWarn: defaultOnWarn, comments: true, prefixIdentifiers: false }; let currentOptions = defaultParserOptions; let currentRoot = null; let currentInput = ""; let currentOpenTag = null; let currentProp = null; let currentAttrValue = ""; let currentAttrStartIndex = -1; let currentAttrEndIndex = -1; let inPre = 0; let inVPre = false; let currentVPreBoundary = null; const stack = []; const 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 && !isVPre(currentProp)) { 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 && !isVPre(currentProp)) { 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.arg.loc.source)) { 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; if (tokenizer.state !== 1) switch (tokenizer.state) { case 5: case 8: emitError(5, end); break; case 3: case 4: emitError(25, tokenizer.sectionStart); break; case 28: if (tokenizer.currentSequence === Sequences.CdataEnd) emitError(6, end); else emitError(7, end); break; case 6: case 7: case 9: case 11: case 12: case 13: case 14: case 15: case 16: case 17: case 18: case 19: case 20: case 21: emitError(9, end); } 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] ? stack[0].ns : currentOptions.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); } }); const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/; const stripParensRE = /^\(|\)$/g; 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 (isCompatEnabled("COMPILER_V_IF_V_FOR_PRECEDENCE", currentOptions)) { let hasIf = false; let hasFor = false; for (let i = 0; i < props.length; i++) { const p = props[i]; if (p.type === 7) { if (p.name === "if") hasIf = true; else if (p.name === "for") hasFor = true; } if (hasIf && hasFor) { warnDeprecation("COMPILER_V_IF_V_FOR_PRECEDENCE", currentOptions, el.loc); break; } } } if (!tokenizer.inSFCRoot && isCompatEnabled("COMPILER_NATIVE_TEMPLATE", currentOptions) && el.tag === "template" && !isFragmentTemplate(el)) { warnDeprecation("COMPILER_NATIVE_TEMPLATE", currentOptions, el.loc); 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; } const specialTemplateDir = /* @__PURE__ */ new Set([ "if", "else", "else-if", "for", "slot" ]); 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; } const windowsNewlineRE = /\r\n/g; function condenseWhitespace(nodes) { 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 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]; } if (!currentOptions.decodeEntities) throw new Error(`[@vue/compiler-core] decodeEntities option is required in browser builds.`); 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; } //#endregion //#region packages/compiler-core/src/transforms/cacheStatic.ts function cacheStatic(root, context) { walk(root, void 0, context, !!getSingleElementRoot(root)); } function getSingleElementRoot(root) { const children = root.children.filter((x) => x.type !== 3); return children.length === 1 && children[0].type === 1 && !isSlotOutlet(children[0]) ? children[0] : null; } 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) { if (child.codegenNode.type === 14 && child.codegenNode.arguments.length > 0) child.codegenNode.arguments.push(`-1 /* ${PatchFlagNames[-1]} */`); toCache.push(child); continue; } } if (child.type === 1) { const isComponent = child.tagType === 1; if (isComponent) context.scopes.vSlot++; walk(child, node, context, false, inFor); if (isComponent) context.scopes.vSlot--; } else if (child.type === 11) walk(child, node, context, child.children.length === 1, true); else if (child.type === 9) for (let i = 0; i < child.branches.length; i++) walk(child.branches[i], node, context, child.branches[i].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); exp.needArraySpread = true; return exp; } function getSlotNode(node, name) { if (node.children && !isArray(node.children) && node.children.type === 15) { const slot = node.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 returnType = 3; const generatedPropsType = getGeneratedPropsConstantType(node, context); if (generatedPropsType === 0) { constantCache.set(node, 0); return 0; } if (generatedPropsType < returnType) returnType = 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 < returnType) returnType = childType; } if (returnType > 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 < returnType) returnType = 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, returnType); return returnType; } 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; } } const allowHoistedHelperSet = /* @__PURE__ */ new Set([ NORMALIZE_CLASS, NORMALIZE_STYLE, NORMALIZE_PROPS, GUARD_REACTIVE_PROPS ]); 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; } //#endregion //#region packages/compiler-core/src/transform.ts function getSelfName(filename) { const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/); return nameMatch ? capitalize(camelize(nameMatch[1])) : null; } 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 context = { filename, selfName: getSelfName(filename), 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(), vForMemoKeyedNodes: /* @__PURE__ */ new WeakSet(), temps: 0, identifiers: Object.create(null), identifierScopes: 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) { if (!context.currentNode) throw new Error(`Node being replaced is already removed.`); if (!context.parent) throw new Error(`Cannot replace root node.`); /* v8 ignore stop */ context.parent.children[context.childIndex] = context.currentNode = node; }, removeNode(node) { /* v8 ignore next 3 */ if (!context.parent) throw new Error(`Cannot remove root node.`); const list = context.parent.children; const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1; /* v8 ignore next 3 */ if (removalIndex < 0) throw new Error(`node being removed is not a child of current parent`); 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, type = "local") {}, removeIdentifiers(exp) {}, isSlotScopeIdentifier(name) { const scopes = context.identifierScopes[name]; return scopes ? scopes[scopes.length - 1] === "slot" : false; }, 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 singleElementRootChild = getSingleElementRoot(root); if (singleElementRootChild && singleElementRootChild.codegenNode) { const codegenNode = singleElementRootChild.codegenNode; if (codegenNode.type === 13) convertToBlock(codegenNode, context); root.codegenNode = codegenNode; } else root.codegenNode = children[0]; } else if (children.length > 1) { let patchFlag = 64; if (children.filter((c) => c.type !== 3).length === 1) patchFlag |= 2048; root.codegenNode = createVNodeCall(context, helper(FRAGMENT), void 0, root.children, patchFlag, 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 i = 0; i < nodeTransforms.length; i++) { const onExit = nodeTransforms[i](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 i = 0; i < node.branches.length; i++) traverseNode(node.branches[i], context); break; case 10: case 11: case 1: case 0: traverseChildren(node, context); } 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; } }; } //#endregion //#region packages/compiler-core/src/codegen.ts const PURE_ANNOTATION = `/*@__PURE__*/`; const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`; const NewlineType = { "Start": 0, "0": "Start", "End": -1, "-1": "End", "None": -2, "-2": "None", "Unknown": -3, "-3": "Unknown" }; 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\n`, -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(`\n`, 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, helpers: ast.helpers }; } 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}\n`, -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\n`, -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 isText$1(n) { return isString(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8; } function genNodeListAsArray(nodes, context) { const multilines = nodes.length > 3 || nodes.some((n) => isArray(n) || !isText$1(n)); 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: assert(node.codegenNode != null, "Codegen node is missing for element/if/for node. Apply appropriate transforms first."); 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; /* v8 ignore start */ case 10: break; default: assert(false, `unhandled codegen node type: ${node.type}`); return node; } } 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 } = node; let patchFlagString; if (patchFlag) { if (patchFlag < 0) patchFlagString = patchFlag + ` /* ${PatchFlagNames[patchFlag]} */`; else patchFlagString = patchFlag + ` /* ${Object.keys(PatchFlagNames).map(Number).filter((n) => n > 0 && patchFlag & n).map((n) => PatchFlagNames[n]).join(`, `)} */`; } 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) : getVNodeHelper(context.inSSR, isComponent)) + `(`, -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 || properties.some((p) => p.value.type !== 4); 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(`)]`); } //#endregion //#region packages/compiler-core/src/validateExpression.ts const prohibitedKeywordRE = new RegExp("\\b" + "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") + "\\b"); const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g; /** * Validate a non-prefixed expression. * This is only called when using the in-browser runtime compiler since it * doesn't prefix expressions. */ function validateBrowserExpression(node, context, asParams = false, asRawStatements = false) { const exp = node.content; if (!exp.trim()) return; try { new Function(asRawStatements ? ` ${exp} ` : `return ${asParams ? `(${exp}) => {}` : `(${exp})`}`); } catch (e) { let message = e.message; const keywordMatch = exp.replace(stripStringRE, "").match(prohibitedKeywordRE); if (keywordMatch) message = `avoid using JavaScript keyword as property name: "${keywordMatch[0]}"`; context.onError(createCompilerError(46, node.loc, void 0, message)); } } //#endregion //#region packages/compiler-core/src/transforms/transformExpression.ts const isLiteralWhitelisted = /*@__PURE__*/ makeMap("true,false,null,this"); const 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 && context.vForMemoKeyedNodes.has(node) && 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); } } } }; function processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) { validateBrowserExpression(node, context, asParams, asRawStatements); 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(""); } //#endregion //#region packages/compiler-core/src/transforms/vIf.ts const 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); } }; }); }); 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.exp) validateBrowserExpression(dir.exp, context); 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; const comments = []; let i = siblings.indexOf(node); while (i-- >= -1) { const sibling = siblings[i]; if (sibling && isCommentOrWhitespace(sibling)) { context.removeNode(sibling); if (sibling.type === 3) comments.unshift(sibling); continue; } if (sibling && sibling.type === 9) { if ((dir.name === "else-if" || dir.name === "else") && sibling.branches[sibling.branches.length - 1].condition === void 0) context.onError(createCompilerError(30, node.loc)); context.removeNode(); const branch = createIfBranch(node, dir); if (comments.length && !(context.parent && context.parent.type === 1 && (context.parent.tag === "transition" || context.parent.tag === "Transition"))) branch.children = [...comments, ...branch.children]; { const key = branch.userKey; if (key) sibling.branches.forEach(({ userKey }) => { if (isSameKey(userKey, key)) context.onError(createCompilerError(29, branch.userKey.loc)); }); } 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), ["\"v-if\"", "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 { let patchFlag = 64; if (!branch.isTemplateIf && children.filter((c) => c.type !== 3).length === 1) patchFlag |= 2048; return createVNodeCall(context, helper(FRAGMENT), createObjectExpression([keyProperty]), children, patchFlag, 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 isSameKey(a, b) { if (!a || a.type !== b.type) return false; if (a.type === 6) { if (a.value.content !== b.value.content) return false; } else { const exp = a.exp; const branchExp = b.exp; if (exp.type !== branchExp.type) return false; if (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) return false; } return true; } 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; } //#endregion //#region packages/compiler-core/src/transforms/vFor.ts const 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); keyProp && keyProp.type; let keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp); const keyProperty = 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; if (isTemplate) node.children.some((c) => { if (c.type === 1) { const key = findProp(c, "key"); if (key) { context.onError(createCompilerError(33, key.loc)); return true; } } }); 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); const shouldUseBlock = !isStableFragment || childBlock.isBlockRequired === true; if (childBlock.isBlock !== shouldUseBlock) { if (childBlock.isBlock) { removeHelper(OPEN_BLOCK); removeHelper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent)); } else removeHelper(getVNodeHelper(context.inSSR, childBlock.isComponent)); } childBlock.isBlock = shouldUseBlock; if (childBlock.isBlock) { helper(OPEN_BLOCK); helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent)); } else { helper(getVNodeHelper(context.inSSR, childBlock.isComponent)); if (childBlock.needsPatch) { var _childBlock$patchFlag; childBlock.patchFlag = ((_childBlock$patchFlag = childBlock.patchFlag) !== null && _childBlock$patchFlag !== void 0 ? _childBlock$patchFlag : 0) | 512; } } } if (memo) { const loop = createFunctionExpression(createForLoopParams(forNode.parseResult, [createSimpleExpression(`_cached`)])); loop.body = createBlockStatement([ createCompoundExpression([ `const _memo = (`, memo.exp, `)` ]), createCompoundExpression([ `if (_cached && _cached.el`, ...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)); }; }); }); 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; validateBrowserExpression(result.source, context); if (result.key) validateBrowserExpression(result.key, context, true); if (result.index) validateBrowserExpression(result.index, context, true); if (result.value) validateBrowserExpression(result.value, context, true); 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, i) => arg || createSimpleExpression(`_`.repeat(i + 1), false)); } //#endregion //#region packages/compiler-core/src/transforms/vSlot.ts const defaultFallback = createSimpleExpression(`undefined`, false); const 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--; }; } } }; const 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); }; } } }; const buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression(props, children, false, true, children.length ? children[0].loc : loc); 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 (!isCommentOrWhitespace(prev)) 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, children) => { const fn = buildSlotFn(props, void 0, children, loc); if (context.compatConfig) fn.isNonScopedSlot = true; return createObjectProperty(`default`, fn); }; if (!hasTemplateSlots) slotsProperties.push(buildDefaultSlotProperty(void 0, children)); else if (implicitDefaultChildren.length && !implicitDefaultChildren.every(isWhitespaceText)) { 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 + ` /* ${slotFlagsText[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; } } return false; } //#endregion //#region packages/compiler-core/src/transforms/transformElement.ts const directiveImportMap = /* @__PURE__ */ new WeakMap(); const 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 = node.tagType === 1; let vnodeTag = isComponent ? 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 needsPatch = false; let isBlockRequired = false; let shouldUseBlock = isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && (tag === "svg" || tag === "foreignObject" || tag === "math"); if (props.length > 0) { const propsBuildResult = buildProps(node, context, void 0, isComponent, isDynamicComponent); vnodeProps = propsBuildResult.props; patchFlag = propsBuildResult.patchFlag; dynamicPropNames = propsBuildResult.dynamicPropNames; needsPatch = propsBuildResult.needsPatch; isBlockRequired = propsBuildResult.isBlockRequired; 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 (node.children.length > 1) context.onError(createCompilerError(47, { start: node.children[0].loc.start, end: node.children[node.children.length - 1].loc.end, source: "" })); } if (isComponent && 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); const vnodeCall = node.codegenNode = createVNodeCall(context, vnodeTag, vnodeProps, vnodeChildren, patchFlag === 0 ? void 0 : patchFlag, vnodeDynamicProps, vnodeDirectives, !!shouldUseBlock, false, isComponent, node.loc); needsPatch = needsPatch && (patchFlag === 0 || patchFlag === 32); if (needsPatch) vnodeCall.needsPatch = true; if (isBlockRequired) vnodeCall.isBlockRequired = true; }; }; 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, isDynamicComponent, ssr = false) { const { tag, loc: elementLoc, children } = node; let properties = []; const mergeArgs = []; const runtimeDirectives = []; const hasChildren = children.length > 0; let shouldUseBlock = false; let isBlockRequired = 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 || isDynamicComponent) && name.toLowerCase() !== "onclick" && name !== "onUpdate:modelValue" && !isReservedProp(name)) hasHydrationEventBinding = true; if (isEventHandler && isReservedProp(name)) hasVnodeHook = true; if (name === "ref") hasRef = 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 === "class") hasClassBinding = true; else if (name === "style") hasStyleBinding = true; else if (name !== "ref" && name !== "key" && !dynamicPropNames.includes(name)) dynamicPropNames.push(name); if (isComponent && (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) 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")) shouldUseBlock = true; if (isVOn && hasChildren && arg && isStaticExp(arg) && camelize(arg.content) === "vue:beforeUpdate") { shouldUseBlock = true; isBlockRequired = true; } if (isVBind && isStaticArgOf(arg, "ref")) pushRefVForMarker(); if (!arg && (isVBind || isVOn)) { hasDynamicKeys = true; if (exp) { if (isVBind) { pushMergeArg(); if (mergeArgs.some((arg) => { if (arg.type === 15) return arg.properties.some(({ key }) => { if (key.type !== 4 || !key.isStatic) return true; return key.content !== "class" && key.content !== "style" && !isOn(key.content); }); else return true; })) checkCompatEnabled("COMPILER_V_BIND_OBJECT_ORDER", context, loc); if (isCompatEnabled("COMPILER_V_BIND_OBJECT_ORDER", context)) { mergeArgs.unshift(exp); continue; } pushRefVForMarker(); pushMergeArg(); mergeArgs.push(exp); } else pushMergeArg({ type: 14, loc, callee: context.helper(TO_HANDLERS), arguments: isComponent ? [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, needRuntime } = directiveTransform(prop, node, context); !ssr && props.forEach(analyzePatchFlag); if (isVOn && arg && !isStaticExp(arg)) pushMergeArg(createObjectExpression(props, elementLoc)); else properties.push(...props); if (needRuntime) { runtimeDirectives.push(prop); if (isSymbol(needRuntime)) directiveImportMap.set(prop, needRuntime); } } else if (!isBuiltInDirective(name)) { runtimeDirectives.push(prop); if (hasChildren) { shouldUseBlock = true; isBlockRequired = 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) patchFlag |= 2; if (hasStyleBinding && !isComponent) patchFlag |= 4; if (dynamicPropNames.length) patchFlag |= 8; if (hasHydrationEventBinding) patchFlag |= 32; } const needsPatch = (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0); if (!shouldUseBlock && needsPatch) 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])]); } return { props: propsExpression, directives: runtimeDirectives, patchFlag, dynamicPropNames, shouldUseBlock, needsPatch, isBlockRequired }; } 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"; } //#endregion //#region packages/compiler-core/src/transforms/transformSlotOutlet.ts const 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); } }; 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 }; } //#endregion //#region packages/compiler-core/src/transforms/vOn.ts const 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("vnode")) context.onError(createCompilerError(52, arg.loc)); 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, context); const isInlineStatement = !(isMemberExp || isFnExpression(exp, context)); const hasMultipleStatements = exp.content.includes(`;`); validateBrowserExpression(exp, context, false, hasMultipleStatements); 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; }; //#endregion //#region packages/compiler-core/src/transforms/vBind.ts const 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 (arg.type !== 4) { arg.children.unshift(`(`); arg.children.push(`) || ""`); } else if (!arg.isStatic) arg.content = 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)] }; }; const 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(`)`); } }; //#endregion //#region packages/compiler-core/src/transforms/transformText.ts const 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(child)) { hasText = true; for (let j = i + 1; j < children.length; j++) { const next = children[j]; if (isText(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(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 /* ${PatchFlagNames[1]} */`); children[i] = { type: 12, content: child, loc: child.loc, codegenNode: createCallExpression(context.helper(CREATE_TEXT), callArgs) }; } } }; }; //#endregion //#region packages/compiler-core/src/transforms/vOnce.ts const seen$1 = /* @__PURE__ */ new WeakSet(); const 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); }; } }; //#endregion //#region packages/compiler-core/src/transforms/vModel.ts const 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 (bindingType === "literal-const" || bindingType === "setup-const") { context.onError(createCompilerError(45, exp.loc)); return createTransformProps(); } if (!expString.trim() || !isMemberExpression(exp, context) && 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) ? getModifierPropName(arg.content) : createCompoundExpression([arg, " + \"Modifiers\""]) : `modelModifiers`; props.push(createObjectProperty(modifiersKey, createSimpleExpression(`{ ${modifiers} }`, false, dir.loc, 2))); } return createTransformProps(props); }; function createTransformProps(props = []) { return { props }; } //#endregion //#region packages/compiler-core/src/compat/transformFilter.ts const validDivisionCharRE = /[\w).+\-_$\]]/; const 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); }); }; 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(child, 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--; } 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) { warnDeprecation("COMPILER_FILTERS", context, node.loc); 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}`; } } //#endregion //#region packages/compiler-core/src/transforms/vMemo.ts const seen = /* @__PURE__ */ new WeakSet(); const transformMemo = (node, context) => { if (node.type === 1) { const dir = findDir(node, "memo"); if (!dir || seen.has(node) || context.inSSR) 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); } }; } }; //#endregion //#region packages/compiler-core/src/transforms/transformVBindShorthand.ts const transformVBindShorthand = (node, context) => { if (node.type === 1) { for (const prop of node.props) if (prop.type === 7 && prop.name === "bind" && (!prop.exp || prop.exp.type === 4 && !prop.exp.content.trim()) && prop.arg) { const arg = prop.arg; if (arg.type !== 4 || !arg.isStatic) { context.onError(createCompilerError(53, arg.loc)); prop.exp = createSimpleExpression("", true, arg.loc); } else { const propName = camelize(arg.content); if (validFirstIdentCharRE.test(propName[0]) || propName[0] === "-") prop.exp = createSimpleExpression(propName, false, arg.loc); } } } }; //#endregion //#region packages/compiler-core/src/compile.ts function getBaseTransformPreset(prefixIdentifiers) { return [[ transformVBindShorthand, transformOnce, transformIf, transformMemo, transformFor, ...[transformFilter], ...[transformExpression], 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(48)); else if (isModuleMode) onError(createCompilerError(49)); /* v8 ignore stop */ const prefixIdentifiers = false; if (options.cacheHandlers) onError(createCompilerError(50)); if (options.scopeId && !isModuleMode) onError(createCompilerError(51)); const resolvedOptions = extend({}, options, { prefixIdentifiers }); const ast = isString(source) ? baseParse(source, resolvedOptions) : source; const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(prefixIdentifiers); transform(ast, extend({}, resolvedOptions, { nodeTransforms: [...nodeTransforms, ...options.nodeTransforms || []], directiveTransforms: extend({}, directiveTransforms, options.directiveTransforms || {}) })); return generate(ast, resolvedOptions); } //#endregion //#region packages/compiler-core/src/options.ts const 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" }; //#endregion //#region packages/compiler-core/src/transforms/noopDirectiveTransform.ts const noopDirectiveTransform = () => ({ props: [] }); //#endregion //#region packages/compiler-dom/src/runtimeHelpers.ts const V_MODEL_RADIO = Symbol(`vModelRadio`); const V_MODEL_CHECKBOX = Symbol(`vModelCheckbox`); const V_MODEL_TEXT = Symbol(`vModelText`); const V_MODEL_SELECT = Symbol(`vModelSelect`); const V_MODEL_DYNAMIC = Symbol(`vModelDynamic`); const V_ON_WITH_MODIFIERS = Symbol(`vOnModifiersGuard`); const V_ON_WITH_KEYS = Symbol(`vOnKeysGuard`); const V_SHOW = Symbol(`vShow`); const TRANSITION = Symbol(`Transition`); const TRANSITION_GROUP = Symbol(`TransitionGroup`); 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` }); //#endregion //#region packages/compiler-dom/src/decodeHtmlBrowser.ts let decoder; 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; } } //#endregion //#region packages/compiler-dom/src/parserOptions.ts const 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 (isSVGTag(tag)) 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 (isSVGTag(tag)) return 1; if (isMathMLTag(tag)) return 2; } return ns; } }; //#endregion //#region packages/compiler-dom/src/transforms/transformStyle.ts const 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 }; }); }; const parseInlineCSS = (cssText, loc) => { const normalized = parseStringStyle(cssText); return createSimpleExpression(JSON.stringify(normalized), false, loc, 3); }; //#endregion //#region packages/compiler-dom/src/errors.ts function createDOMCompilerError(code, loc) { return createCompilerError(code, loc, DOMErrorMessages); } const DOMErrorCodes = { "X_V_HTML_NO_EXPRESSION": 54, "54": "X_V_HTML_NO_EXPRESSION", "X_V_HTML_WITH_CHILDREN": 55, "55": "X_V_HTML_WITH_CHILDREN", "X_V_TEXT_NO_EXPRESSION": 56, "56": "X_V_TEXT_NO_EXPRESSION", "X_V_TEXT_WITH_CHILDREN": 57, "57": "X_V_TEXT_WITH_CHILDREN", "X_V_MODEL_ON_INVALID_ELEMENT": 58, "58": "X_V_MODEL_ON_INVALID_ELEMENT", "X_V_MODEL_ARG_ON_ELEMENT": 59, "59": "X_V_MODEL_ARG_ON_ELEMENT", "X_V_MODEL_ON_FILE_INPUT_ELEMENT": 60, "60": "X_V_MODEL_ON_FILE_INPUT_ELEMENT", "X_V_MODEL_UNNECESSARY_VALUE": 61, "61": "X_V_MODEL_UNNECESSARY_VALUE", "X_V_SHOW_NO_EXPRESSION": 62, "62": "X_V_SHOW_NO_EXPRESSION", "X_TRANSITION_INVALID_CHILDREN": 63, "63": "X_TRANSITION_INVALID_CHILDREN", "X_IGNORED_SIDE_EFFECT_TAG": 64, "64": "X_IGNORED_SIDE_EFFECT_TAG", "__EXTEND_POINT__": 65, "65": "__EXTEND_POINT__" }; const DOMErrorMessages = { [54]: `v-html is missing expression.`, [55]: `v-html will override element children.`, [56]: `v-text is missing expression.`, [57]: `v-text will override element children.`, [58]: `v-model can only be used on <input>, <textarea> and <select> elements.`, [59]: `v-model argument is not supported on plain elements.`, [60]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`, [61]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`, [62]: `v-show is missing expression.`, [63]: `<Transition> expects exactly one child element or component.`, [64]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`, [65]: `` }; //#endregion //#region packages/compiler-dom/src/transforms/vHtml.ts const transformVHtml = (dir, node, context) => { const { exp, loc } = dir; if (!exp) context.onError(createDOMCompilerError(54, loc)); if (node.children.length) { context.onError(createDOMCompilerError(55, loc)); node.children.length = 0; } return { props: [createObjectProperty(createSimpleExpression(`innerHTML`, true, loc), exp || createSimpleExpression("", true))] }; }; //#endregion //#region packages/compiler-dom/src/transforms/vText.ts const transformVText = (dir, node, context) => { const { exp, loc } = dir; if (!exp) context.onError(createDOMCompilerError(56, loc)); if (node.children.length) { context.onError(createDOMCompilerError(57, 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))] }; }; //#endregion //#region packages/compiler-dom/src/transforms/vModel.ts const 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(59, dir.arg.loc)); function checkDuplicatedValue() { const value = findDir(node, "bind"); if (value && isStaticArgOf(value.arg, "value")) context.onError(createDOMCompilerError(61, value.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(60, dir.loc)); break; default: checkDuplicatedValue(); } } else if (hasDynamicKeyVBind(node)) directiveToUse = V_MODEL_DYNAMIC; else checkDuplicatedValue(); } else if (tag === "select") directiveToUse = V_MODEL_SELECT; else checkDuplicatedValue(); if (!isInvalidType) baseResult.needRuntime = context.helper(directiveToUse); } else context.onError(createDOMCompilerError(58, dir.loc)); baseResult.props = baseResult.props.filter((p) => !(p.key.type === 4 && p.key.content === "modelValue")); return baseResult; }; //#endregion //#region packages/compiler-dom/src/transforms/vOn.ts const isEventOptionModifier = /*@__PURE__*/ makeMap(`passive,once,capture`); const isNonKeyModifier = /*@__PURE__*/ makeMap("stop,prevent,self,ctrl,shift,alt,meta,exact,middle"); const maybeKeyModifier = /*@__PURE__*/ makeMap("left,right"); const isKeyboardEvent = /*@__PURE__*/ makeMap(`onkeyup,onkeydown,onkeypress`); const 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 === "delegate") { if (context) { const error = /* @__PURE__ */ new SyntaxError(`.delegate modifier is only supported in Vapor components.`); error.loc = modifiers[i].loc; context.onWarn(error); } continue; } if (modifier === "native" && context && checkCompatEnabled("COMPILER_V_ON_NATIVE", context, loc)) eventOptionModifiers.push(modifier); else if (isEventOptionModifier(modifier)) eventOptionModifiers.push(modifier); else { const keyString = isString(key) ? key : isStaticExp(key) ? key.content : null; if (maybeKeyModifier(modifier)) { if (keyString) { if (isKeyboardEvent(keyString.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 }; }; const transformClick = (key, event) => { return isStaticExp(key) && key.content.toLowerCase() === "onclick" ? createSimpleExpression(event, true) : key.type !== 4 ? createCompoundExpression([ `(`, key, `) === "onClick" ? "${event}" : (`, key, `)` ]) : key; }; const 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)] }; }); }; //#endregion //#region packages/compiler-dom/src/transforms/vShow.ts const transformShow = (dir, node, context) => { const { exp, loc } = dir; if (!exp) context.onError(createDOMCompilerError(62, loc)); return { props: [], needRuntime: context.helper(V_SHOW) }; }; //#endregion //#region packages/compiler-dom/src/transforms/Transition.ts const transformTransition = (node, context) => { if (node.type === 1 && node.tagType === 1) { if (context.isBuiltInComponent(node.tag) === TRANSITION) return postTransformTransition(node, context.onError); } }; function postTransformTransition(node, onError, hasMultipleChildren = defaultHasMultipleChildren) { return () => { if (!node.children.length) return; if (hasMultipleChildren(node)) onError(createDOMCompilerError(63, { start: node.children[0].loc.start, end: node.children[node.children.length - 1].loc.end, source: "" })); const child = node.children[0]; if (child.type === 1 && !findDir(child, "if")) { for (const p of child.props) if (p.type === 7 && p.name === "show") node.props.push({ type: 6, name: "persisted", nameLoc: node.loc, value: void 0, loc: node.loc }); } }; } function defaultHasMultipleChildren(node) { const children = node.children = node.children.filter((c) => !isCommentOrWhitespace(c)); const child = children[0]; return children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(defaultHasMultipleChildren); } //#endregion //#region packages/compiler-dom/src/transforms/ignoreSideEffectTags.ts const ignoreSideEffectTags = (node, context) => { if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) { context.onError(createDOMCompilerError(64, node.loc)); context.removeNode(); } }; //#endregion //#region packages/compiler-dom/src/htmlNesting.ts /** * Copied from https://github.com/MananTank/validate-html-nesting * with ISC license * * To avoid runtime dependency on validate-html-nesting * This file should not change very often in the original repo * but we may need to keep it up-to-date from time to time. */ /** * returns true if given parent-child nesting is valid HTML */ function isValidHTMLNesting(parent, child) { if (parent === "template") return true; if (parent in onlyValidChildren) return onlyValidChildren[parent].has(child); if (child in onlyValidParents) return onlyValidParents[child].has(parent); if (parent in knownInvalidChildren) { if (knownInvalidChildren[parent].has(child)) return false; } if (child in knownInvalidParents) { if (knownInvalidParents[child].has(parent)) return false; } return true; } const headings = /* @__PURE__ */ new Set([ "h1", "h2", "h3", "h4", "h5", "h6" ]); const emptySet = /* @__PURE__ */ new Set([]); /** * maps element to set of elements that can be it's children, no other */ const onlyValidChildren = { head: /* @__PURE__ */ new Set([ "base", "basefront", "bgsound", "link", "meta", "title", "noscript", "noframes", "style", "script", "template" ]), optgroup: /* @__PURE__ */ new Set(["option"]), select: /* @__PURE__ */ new Set([ "optgroup", "option", "hr" ]), table: /* @__PURE__ */ new Set([ "caption", "colgroup", "tbody", "tfoot", "thead" ]), tr: /* @__PURE__ */ new Set(["td", "th"]), colgroup: /* @__PURE__ */ new Set(["col"]), tbody: /* @__PURE__ */ new Set(["tr"]), thead: /* @__PURE__ */ new Set(["tr"]), tfoot: /* @__PURE__ */ new Set(["tr"]), script: emptySet, iframe: emptySet, option: emptySet, textarea: emptySet, style: emptySet, title: emptySet }; /** maps elements to set of elements which can be it's parent, no other */ const onlyValidParents = { html: emptySet, body: /* @__PURE__ */ new Set(["html"]), head: /* @__PURE__ */ new Set(["html"]), td: /* @__PURE__ */ new Set(["tr"]), colgroup: /* @__PURE__ */ new Set(["table"]), caption: /* @__PURE__ */ new Set(["table"]), tbody: /* @__PURE__ */ new Set(["table"]), tfoot: /* @__PURE__ */ new Set(["table"]), col: /* @__PURE__ */ new Set(["colgroup"]), th: /* @__PURE__ */ new Set(["tr"]), thead: /* @__PURE__ */ new Set(["table"]), tr: /* @__PURE__ */ new Set([ "tbody", "thead", "tfoot" ]), dd: /* @__PURE__ */ new Set(["dl", "div"]), dt: /* @__PURE__ */ new Set(["dl", "div"]), figcaption: /* @__PURE__ */ new Set(["figure"]), summary: /* @__PURE__ */ new Set(["details"]), area: /* @__PURE__ */ new Set(["map"]) }; /** maps element to set of elements that can not be it's children, others can */ const knownInvalidChildren = { p: /* @__PURE__ */ new Set([ "address", "article", "aside", "blockquote", "center", "details", "dialog", "dir", "div", "dl", "fieldset", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hgroup", "hr", "li", "main", "nav", "menu", "ol", "p", "pre", "section", "table", "ul" ]), svg: /* @__PURE__ */ new Set([ "b", "blockquote", "br", "code", "dd", "div", "dl", "dt", "em", "embed", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "i", "img", "li", "menu", "meta", "ol", "p", "pre", "ruby", "s", "small", "span", "strong", "sub", "sup", "table", "u", "ul", "var" ]) }; /** maps element to set of elements that can not be it's parent, others can */ const knownInvalidParents = { a: /* @__PURE__ */ new Set(["a"]), button: /* @__PURE__ */ new Set(["button"]), dd: /* @__PURE__ */ new Set(["dd", "dt"]), dt: /* @__PURE__ */ new Set(["dd", "dt"]), form: /* @__PURE__ */ new Set(["form"]), li: /* @__PURE__ */ new Set(["li"]), h1: headings, h2: headings, h3: headings, h4: headings, h5: headings, h6: headings }; //#endregion //#region packages/compiler-dom/src/transforms/validateHtmlNesting.ts const validateHtmlNesting = (node, context) => { if (node.type === 1 && node.tagType === 0 && context.parent && context.parent.type === 1 && context.parent.tagType === 0 && !isValidHTMLNesting(context.parent.tag, node.tag)) { const error = /* @__PURE__ */ new SyntaxError(`<${node.tag}> cannot be child of <${context.parent.tag}>, according to HTML specifications. This can cause hydration errors or potentially disrupt future functionality.`); error.loc = node.loc; context.onWarn(error); } }; //#endregion //#region packages/compiler-dom/src/index.ts const DOMNodeTransforms = [transformStyle, ...[transformTransition, validateHtmlNesting]]; const DOMDirectiveTransforms = { cloak: noopDirectiveTransform, html: transformVHtml, text: transformVText, model: transformModel$1, on: transformOn$1, show: transformShow }; 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)); } //#endregion export { BASE_TRANSITION, BindingTypes, CAMELIZE, CAPITALIZE, CREATE_BLOCK, CREATE_COMMENT, CREATE_ELEMENT_BLOCK, CREATE_ELEMENT_VNODE, CREATE_SLOTS, CREATE_STATIC, CREATE_TEXT, CREATE_VNODE, CompilerDeprecationTypes, ConstantTypes, DOMDirectiveTransforms, DOMErrorCodes, DOMErrorMessages, DOMNodeTransforms, ElementTypes, ErrorCodes, FRAGMENT, GUARD_REACTIVE_PROPS, IS_MEMO_SAME, IS_REF, KEEP_ALIVE, MERGE_PROPS, MemberExpLexState, NORMALIZE_CLASS, NORMALIZE_PROPS, NORMALIZE_STYLE, NewlineType, NodeTypes, OPEN_BLOCK, POP_SCOPE_ID, PUSH_SCOPE_ID, RENDER_LIST, RENDER_SLOT, RESOLVE_COMPONENT, RESOLVE_DIRECTIVE, RESOLVE_DYNAMIC_COMPONENT, RESOLVE_FILTER, SET_BLOCK_TRACKING, SUSPENSE, TELEPORT, TO_DISPLAY_STRING, TO_HANDLERS, TO_HANDLER_KEY, TRANSITION, TRANSITION_GROUP, TS_NODE_TYPES, UNREF, V_MODEL_CHECKBOX, V_MODEL_DYNAMIC, V_MODEL_RADIO, V_MODEL_SELECT, V_MODEL_TEXT, V_ON_WITH_KEYS, V_ON_WITH_MODIFIERS, V_SHOW, WITH_CTX, WITH_DIRECTIVES, WITH_MEMO, advancePositionWithClone, advancePositionWithMutation, assert, baseCompile, baseParse, buildDirectiveArgs, buildProps, buildSlots, checkCompatEnabled, compile, convertToBlock, createArrayExpression, createAssignmentExpression, createBlockStatement, createCacheExpression, createCallExpression, createCompilerError, createCompoundExpression, createConditionalExpression, createDOMCompilerError, createForLoopParams, createFunctionExpression, createIfStatement, createInterpolation, createObjectExpression, createObjectProperty, createReturnStatement, createRoot, createSequenceExpression, createSimpleExpression, createStructuralDirectiveTransform, createTemplateLiteral, createTransformContext, createVNodeCall, defaultOnError, defaultOnWarn, errorMessages, extractIdentifiers, filterNonCommentChildren, findDir, findProp, forAliasRE, generate, generateCodeFrame, getBaseTransformPreset, getConstantType, getMemoedVNodeCall, getSelfName, getVNodeBlockHelper, getVNodeHelper, hasDynamicKeyVBind, hasScopeRef, hasSingleChild, helperNameMap, injectProp, isAllWhitespace, isCommentOrWhitespace, isConstantNode, isCoreComponent, isFnExpression, isFnExpressionBrowser, isFnExpressionNode, isFunctionType, isInDestructureAssignment, isInNewExpression, isKeyboardEvent, isLiteralWhitelisted, isMemberExpression, isMemberExpressionBrowser, isMemberExpressionNode, isReferencedIdentifier, isSimpleIdentifier, isSingleIfBlock, isSlotOutlet, isStaticArgOf, isStaticExp, isStaticNode, isStaticProperty, isStaticPropertyKey, isTemplateNode, isText, isVPre, isVSlot, isValidHTMLNesting, isWhitespaceText, locStub, noopDirectiveTransform, parse, parserOptions, postTransformTransition, processExpression, processFor, processIf, processSlotOutlet, registerRuntimeHelpers, resolveComponentType, resolveModifiers, stringifyExpression, toValidAssetId, trackSlotScopes, trackVForSlotScopes, transform, transformBind, transformElement, transformExpression, transformModel, transformOn, transformStyle, transformVBindShorthand, traverseNode, unwrapTSNode, validFirstIdentCharRE, walkBlockDeclarations, walkFunctionParams, walkIdentifiers, warnDeprecation };