diff --git a/.pnpm-store/v3/files/00/26f39796b1675e13ffccdc0da8b12f5dd0a009655a6d707fa61d9d107ab2e415849eb9ff7a51cb02b0e0dbb970ad7a554ed2b4ee50dfd472e7da1a86a82e69 b/.pnpm-store/v3/files/00/26f39796b1675e13ffccdc0da8b12f5dd0a009655a6d707fa61d9d107ab2e415849eb9ff7a51cb02b0e0dbb970ad7a554ed2b4ee50dfd472e7da1a86a82e69 new file mode 100644 index 0000000000000000000000000000000000000000..9868b9aee8cf0e142f699c1fea0e7eaddd789d93 --- /dev/null +++ b/.pnpm-store/v3/files/00/26f39796b1675e13ffccdc0da8b12f5dd0a009655a6d707fa61d9d107ab2e415849eb9ff7a51cb02b0e0dbb970ad7a554ed2b4ee50dfd472e7da1a86a82e69 @@ -0,0 +1,3 @@ +require('../modules/es7.weak-map.of'); +require('../modules/es7.weak-map.from'); +module.exports = require('../modules/_core').WeakMap; diff --git a/.pnpm-store/v3/files/00/28a6a148d4b793a3e24dcf50a4d1ebd7ce966bebfd353f6a831252976647d6fbd564ecd8c0e0b8a992c6e2c6823fb56131c27bf2b392d24d46e79492945447 b/.pnpm-store/v3/files/00/28a6a148d4b793a3e24dcf50a4d1ebd7ce966bebfd353f6a831252976647d6fbd564ecd8c0e0b8a992c6e2c6823fb56131c27bf2b392d24d46e79492945447 new file mode 100644 index 0000000000000000000000000000000000000000..3a13d81f3736ee8ca352a80222f6d0bd63ec9a13 --- /dev/null +++ b/.pnpm-store/v3/files/00/28a6a148d4b793a3e24dcf50a4d1ebd7ce966bebfd353f6a831252976647d6fbd564ecd8c0e0b8a992c6e2c6823fb56131c27bf2b392d24d46e79492945447 @@ -0,0 +1,49403 @@ +/** + * 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 rollup can tree-shake them if necessary. + */ +function makeMap(str, expectsLowerCase) { + const map = Object.create(null); + const list = str.split(','); + for (let i = 0; i < list.length; i++) { + map[list[i]] = true; + } + return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val]; +} + +/** + * dev only flag -> name mapping + */ +const PatchFlagNames = { + [1 /* TEXT */]: `TEXT`, + [2 /* CLASS */]: `CLASS`, + [4 /* STYLE */]: `STYLE`, + [8 /* PROPS */]: `PROPS`, + [16 /* FULL_PROPS */]: `FULL_PROPS`, + [32 /* HYDRATE_EVENTS */]: `HYDRATE_EVENTS`, + [64 /* STABLE_FRAGMENT */]: `STABLE_FRAGMENT`, + [128 /* KEYED_FRAGMENT */]: `KEYED_FRAGMENT`, + [256 /* UNKEYED_FRAGMENT */]: `UNKEYED_FRAGMENT`, + [512 /* NEED_PATCH */]: `NEED_PATCH`, + [1024 /* DYNAMIC_SLOTS */]: `DYNAMIC_SLOTS`, + [2048 /* DEV_ROOT_FRAGMENT */]: `DEV_ROOT_FRAGMENT`, + [-1 /* HOISTED */]: `HOISTED`, + [-2 /* BAIL */]: `BAIL` +}; + +/** + * Dev only + */ +const slotFlagsText = { + [1 /* STABLE */]: 'STABLE', + [2 /* DYNAMIC */]: 'DYNAMIC', + [3 /* FORWARDED */]: 'FORWARDED' +}; + +const GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' + + 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' + + 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt'; +const isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED); + +const range = 2; +function generateCodeFrame(source, start = 0, end = source.length) { + // Split the content into individual lines but capture the newline sequence + // that separated each line. This is important because the actual sequence is + // needed to properly take into account the full line length for offset + // comparison + let lines = source.split(/(\r?\n)/); + // Separate the lines and newline sequences into separate arrays for easier referencing + 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) { + // push underline + 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'); +} + +/** + * On the client we only need to offer special cases for boolean attributes that + * have different names from their corresponding dom properties: + * - itemscope -> N/A + * - allowfullscreen -> allowFullscreen + * - formnovalidate -> formNoValidate + * - ismap -> isMap + * - nomodule -> noModule + * - novalidate -> noValidate + * - readonly -> readOnly + */ +const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`; +/** + * The full list is needed during SSR to produce the correct initial markup. + */ +const isBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs + + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,` + + `loop,open,required,reversed,scoped,seamless,` + + `checked,muted,multiple,selected`); +const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; +const attrValidationCache = {}; +function isSSRSafeAttrName(name) { + if (attrValidationCache.hasOwnProperty(name)) { + return attrValidationCache[name]; + } + const isUnsafe = unsafeAttrCharRE.test(name); + if (isUnsafe) { + console.error(`unsafe attribute name: ${name}`); + } + return (attrValidationCache[name] = !isUnsafe); +} +const propsToAttrMap = { + acceptCharset: 'accept-charset', + className: 'class', + htmlFor: 'for', + httpEquiv: 'http-equiv' +}; +/** + * CSS properties that accept plain numbers + */ +const isNoUnitNumericStyleProp = /*#__PURE__*/ makeMap(`animation-iteration-count,border-image-outset,border-image-slice,` + + `border-image-width,box-flex,box-flex-group,box-ordinal-group,column-count,` + + `columns,flex,flex-grow,flex-positive,flex-shrink,flex-negative,flex-order,` + + `grid-row,grid-row-end,grid-row-span,grid-row-start,grid-column,` + + `grid-column-end,grid-column-span,grid-column-start,font-weight,line-clamp,` + + `line-height,opacity,order,orphans,tab-size,widows,z-index,zoom,` + + // SVG + `fill-opacity,flood-opacity,stop-opacity,stroke-dasharray,stroke-dashoffset,` + + `stroke-miterlimit,stroke-opacity,stroke-width`); +/** + * Known attributes, this is used for stringification of runtime static nodes + * so that we don't stringify bindings that cannot be set from HTML. + * Don't also forget to allow `data-*` and `aria-*`! + * Generated from https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes + */ +const isKnownHtmlAttr = /*#__PURE__*/ makeMap(`accept,accept-charset,accesskey,action,align,allow,alt,async,` + + `autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,` + + `border,buffered,capture,challenge,charset,checked,cite,class,code,` + + `codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,` + + `coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,` + + `disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,` + + `formaction,formenctype,formmethod,formnovalidate,formtarget,headers,` + + `height,hidden,high,href,hreflang,http-equiv,icon,id,importance,integrity,` + + `ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,` + + `manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,` + + `open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,` + + `referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,` + + `selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,` + + `start,step,style,summary,tabindex,target,title,translate,type,usemap,` + + `value,width,wrap`); +/** + * Generated from https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute + */ +const isKnownSvgAttr = /*#__PURE__*/ makeMap(`xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,` + + `arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,` + + `baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,` + + `clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,` + + `color-interpolation-filters,color-profile,color-rendering,` + + `contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,` + + `descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,` + + `dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,` + + `fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,` + + `font-family,font-size,font-size-adjust,font-stretch,font-style,` + + `font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,` + + `glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,` + + `gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,` + + `horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,` + + `k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,` + + `lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,` + + `marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,` + + `mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,` + + `name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,` + + `overflow,overline-position,overline-thickness,panose-1,paint-order,path,` + + `pathLength,patternContentUnits,patternTransform,patternUnits,ping,` + + `pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,` + + `preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,` + + `rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,` + + `restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,` + + `specularConstant,specularExponent,speed,spreadMethod,startOffset,` + + `stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,` + + `strikethrough-position,strikethrough-thickness,string,stroke,` + + `stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,` + + `stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,` + + `systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,` + + `text-decoration,text-rendering,textLength,to,transform,transform-origin,` + + `type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,` + + `unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,` + + `v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,` + + `vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,` + + `writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,` + + `xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xml:base,xml:lang,` + + `xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`); + +function normalizeStyle(value) { + if (isArray(value)) { + const res = {}; + for (let i = 0; i < value.length; i++) { + const item = value[i]; + const normalized = isString(item) + ? parseStringStyle(item) + : normalizeStyle(item); + if (normalized) { + for (const key in normalized) { + res[key] = normalized[key]; + } + } + } + return res; + } + else if (isString(value)) { + return value; + } + else if (isObject(value)) { + return value; + } +} +const listDelimiterRE = /;(?![^(]*\))/g; +const propertyDelimiterRE = /:(.+)/; +function parseStringStyle(cssText) { + const ret = {}; + cssText.split(listDelimiterRE).forEach(item => { + if (item) { + const tmp = item.split(propertyDelimiterRE); + tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); + } + }); + return ret; +} +function stringifyStyle(styles) { + let ret = ''; + if (!styles || isString(styles)) { + return ret; + } + for (const key in styles) { + const value = styles[key]; + const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key); + if (isString(value) || + (typeof value === 'number' && isNoUnitNumericStyleProp(normalizedKey))) { + // only render valid values + ret += `${normalizedKey}:${value};`; + } + } + return ret; +} +function normalizeClass(value) { + let res = ''; + if (isString(value)) { + res = value; + } + else if (isArray(value)) { + for (let i = 0; i < value.length; i++) { + const normalized = normalizeClass(value[i]); + if (normalized) { + res += normalized + ' '; + } + } + } + else if (isObject(value)) { + for (const name in value) { + if (value[name]) { + res += name + ' '; + } + } + } + return res.trim(); +} + +// These tag configs are shared between compiler-dom and runtime-dom, so they +// https://developer.mozilla.org/en-US/docs/Web/HTML/Element +const HTML_TAGS = 'html,body,base,head,link,meta,style,title,address,article,aside,footer,' + + 'header,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'; +// https://developer.mozilla.org/en-US/docs/Web/SVG/Element +const SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' + + 'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' + + 'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' + + 'feDistanceLight,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 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 `true` flag. + */ +const isHTMLTag = /*#__PURE__*/ makeMap(HTML_TAGS); +/** + * Compiler only. + * Do NOT use in runtime code paths unless behind `true` flag. + */ +const isSVGTag = /*#__PURE__*/ makeMap(SVG_TAGS); +/** + * Compiler only. + * Do NOT use in runtime code paths unless behind `true` flag. + */ +const isVoidTag = /*#__PURE__*/ makeMap(VOID_TAGS); + +const escapeRE = /["'&<>]/; +function escapeHtml(string) { + const str = '' + string; + const match = escapeRE.exec(str); + if (!match) { + return str; + } + let html = ''; + let escaped; + let index; + let lastIndex = 0; + for (index = match.index; index < str.length; index++) { + switch (str.charCodeAt(index)) { + case 34: // " + escaped = '"'; + break; + case 38: // & + escaped = '&'; + break; + case 39: // ' + escaped = '''; + break; + case 60: // < + escaped = '<'; + break; + case 62: // > + escaped = '>'; + break; + default: + continue; + } + if (lastIndex !== index) { + html += str.slice(lastIndex, index); + } + lastIndex = index + 1; + html += escaped; + } + return lastIndex !== index ? html + str.slice(lastIndex, index) : html; +} + +/** + * For converting {{ interpolation }} values to displayed strings. + * @private + */ +const toDisplayString = (val) => { + return isString(val) + ? val + : val == null + ? '' + : isArray(val) || + (isObject(val) && + (val.toString === objectToString || !isFunction(val.toString))) + ? JSON.stringify(val, replacer, 2) + : String(val); +}; +const replacer = (_key, val) => { + // can't use isRef here since @vue/shared has no deps + if (val && val.__v_isRef) { + return replacer(_key, val.value); + } + else if (isMap(val)) { + return { + [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val]) => { + entries[`${key} =>`] = val; + return entries; + }, {}) + }; + } + else if (isSet(val)) { + return { + [`Set(${val.size})`]: [...val.values()] + }; + } + else if (isObject(val) && !isArray(val) && !isPlainObject(val)) { + return String(val); + } + return val; +}; + +const EMPTY_OBJ = Object.freeze({}) + ; +Object.freeze([]) ; +const NOOP = () => { }; +/** + * Always return false. + */ +const NO = () => false; +const onRE = /^on[^a-z]/; +const isOn = (key) => onRE.test(key); +const extend = Object.assign; +const hasOwnProperty = Object.prototype.hasOwnProperty; +const hasOwn = (val, key) => hasOwnProperty.call(val, key); +const isArray = Array.isArray; +const isMap = (val) => toTypeString(val) === '[object Map]'; +const isSet = (val) => toTypeString(val) === '[object Set]'; +const isFunction = (val) => typeof val === 'function'; +const isString = (val) => typeof val === 'string'; +const isSymbol = (val) => typeof val === 'symbol'; +const isObject = (val) => val !== null && typeof val === 'object'; +const objectToString = Object.prototype.toString; +const toTypeString = (value) => objectToString.call(value); +const isPlainObject = (val) => toTypeString(val) === '[object Object]'; +const isReservedProp = /*#__PURE__*/ makeMap( +// the leading comma is intentional so empty string "" is also included +',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) => { + const hit = cache[str]; + return hit || (cache[str] = fn(str)); + }); +}; +const camelizeRE = /-(\w)/g; +/** + * @private + */ +const camelize = cacheStringFunction((str) => { + return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : '')); +}); +const hyphenateRE = /\B([A-Z])/g; +/** + * @private + */ +const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, '-$1').toLowerCase()); +/** + * @private + */ +const capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1)); +/** + * @private + */ +const toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``); +const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/; +function genPropsAccessExp(name) { + return identRE.test(name) + ? `__props.${name}` + : `__props[${JSON.stringify(name)}]`; +} + +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 errorMessages = { + // parse errors + [0 /* ABRUPT_CLOSING_OF_EMPTY_COMMENT */]: 'Illegal comment.', + [1 /* CDATA_IN_HTML_CONTENT */]: 'CDATA section is allowed only in XML context.', + [2 /* DUPLICATE_ATTRIBUTE */]: 'Duplicate attribute.', + [3 /* END_TAG_WITH_ATTRIBUTES */]: 'End tag cannot have attributes.', + [4 /* END_TAG_WITH_TRAILING_SOLIDUS */]: "Illegal '/' in tags.", + [5 /* EOF_BEFORE_TAG_NAME */]: 'Unexpected EOF in tag.', + [6 /* EOF_IN_CDATA */]: 'Unexpected EOF in CDATA section.', + [7 /* EOF_IN_COMMENT */]: 'Unexpected EOF in comment.', + [8 /* EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT */]: 'Unexpected EOF in script.', + [9 /* EOF_IN_TAG */]: 'Unexpected EOF in tag.', + [10 /* INCORRECTLY_CLOSED_COMMENT */]: 'Incorrectly closed comment.', + [11 /* INCORRECTLY_OPENED_COMMENT */]: 'Incorrectly opened comment.', + [12 /* INVALID_FIRST_CHARACTER_OF_TAG_NAME */]: "Illegal tag name. Use '<' to print '<'.", + [13 /* MISSING_ATTRIBUTE_VALUE */]: 'Attribute value was expected.', + [14 /* MISSING_END_TAG_NAME */]: 'End tag name was expected.', + [15 /* MISSING_WHITESPACE_BETWEEN_ATTRIBUTES */]: 'Whitespace was expected.', + [16 /* NESTED_COMMENT */]: "Unexpected ' isRef(x) ? x.value = y : x = y + const { right: rVal, operator } = parent; + const rExp = rawExp.slice(rVal.start - 1, rVal.end - 1); + const rExpString = stringifyExpression(processExpression(createSimpleExpression(rExp, false), context, false, false, knownIds)); + return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore\n` : ``} ? ${raw}.value ${operator} ${rExpString} : ${raw}`; + } + else if (isUpdateArg) { + // make id replace parent in the code range so the raw update operator + // is removed + id.start = parent.start; + id.end = parent.end; + const { prefix: isPrefix, operator } = parent; + const prefix = isPrefix ? operator : ``; + const postfix = isPrefix ? `` : operator; + // let binding. + // x++ --> isRef(a) ? a.value++ : a++ + return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore\n` : ``} ? ${prefix}${raw}.value${postfix} : ${prefix}${raw}${postfix}`; + } + else if (isDestructureAssignment) { + // TODO + // let binding in a destructure assignment - it's very tricky to + // handle both possible cases here without altering the original + // structure of the code, so we just assume it's not a ref here + // for now + return raw; + } + else { + return `${context.helperString(UNREF)}(${raw})`; + } + } + else if (type === "props" /* PROPS */) { + // use __props which is generated by compileScript so in ts mode + // it gets correct type + return genPropsAccessExp(raw); + } + else if (type === "props-aliased" /* PROPS_ALIASED */) { + // prop with a different local alias (from defineProps() destructure) + return genPropsAccessExp(bindingMetadata.__propsAliases[raw]); + } + } + else { + if (type && type.startsWith('setup')) { + // setup bindings in non-inline mode + return `$setup.${raw}`; + } + else if (type === "props-aliased" /* PROPS_ALIASED */) { + return `$props['${bindingMetadata.__propsAliases[raw]}']`; + } + else if (type) { + return `$${type}.${raw}`; + } + } + // fallback to ctx + return `_ctx.${raw}`; + }; + // fast path if expression is a simple identifier. + const rawExp = node.content; + // bail constant on parens (function invocation) and dot (member access) + const bailConstant = rawExp.indexOf(`(`) > -1 || rawExp.indexOf('.') > 0; + if (isSimpleIdentifier(rawExp)) { + const isScopeVarReference = context.identifiers[rawExp]; + const isAllowedGlobal = isGloballyWhitelisted(rawExp); + const isLiteral = isLiteralWhitelisted(rawExp); + if (!asParams && !isScopeVarReference && !isAllowedGlobal && !isLiteral) { + // const bindings exposed from setup can be skipped for patching but + // cannot be hoisted to module scope + if (bindingMetadata[node.content] === "setup-const" /* SETUP_CONST */) { + node.constType = 1 /* CAN_SKIP_PATCH */; + } + node.content = rewriteIdentifier(rawExp); + } + else if (!isScopeVarReference) { + if (isLiteral) { + node.constType = 3 /* CAN_STRINGIFY */; + } + else { + node.constType = 2 /* CAN_HOIST */; + } + } + return node; + } + let ast; + // exp needs to be parsed differently: + // 1. Multiple inline statements (v-on, with presence of `;`): parse as raw + // exp, but make sure to pad with spaces for consistent ranges + // 2. Expressions: wrap with parens (for e.g. object expressions) + // 3. Function arguments (v-for, v-slot): place in a function argument position + const source = asRawStatements + ? ` ${rawExp} ` + : `(${rawExp})${asParams ? `=>{}` : ``}`; + try { + ast = parse_1(source, { + plugins: context.expressionPlugins + }).program; + } + catch (e) { + context.onError(createCompilerError(44 /* X_INVALID_EXPRESSION */, node.loc, undefined, e.message)); + return node; + } + const ids = []; + const parentStack = []; + const knownIds = Object.create(context.identifiers); + walkIdentifiers(ast, (node, parent, _, isReferenced, isLocal) => { + if (isStaticPropertyKey(node, parent)) { + return; + } + const needPrefix = isReferenced && canPrefix(node); + if (needPrefix && !isLocal) { + if (isStaticProperty(parent) && parent.shorthand) { + node.prefix = `${node.name}: `; + } + node.name = rewriteIdentifier(node.name, parent, node); + ids.push(node); + } + else { + // The identifier is considered constant unless it's pointing to a + // local scope variable (a v-for alias, or a v-slot prop) + if (!(needPrefix && isLocal) && !bailConstant) { + node.isConstant = true; + } + // also generate sub-expressions for other identifiers for better + // source map support. (except for property keys which are static) + ids.push(node); + } + }, true, // invoke on ALL identifiers + parentStack, knownIds); + // We break up the compound expression into an array of strings and sub + // expressions (for identifiers that have been prefixed). In codegen, if + // an ExpressionNode has the `.children` property, it will be used instead of + // `.content`. + const children = []; + ids.sort((a, b) => a.start - b.start); + ids.forEach((id, i) => { + // range is offset by -1 due to the wrapping parens when parsed + const start = id.start - 1; + const end = id.end - 1; + const last = ids[i - 1]; + const leadingText = rawExp.slice(last ? last.end - 1 : 0, start); + if (leadingText.length || id.prefix) { + children.push(leadingText + (id.prefix || ``)); + } + const source = rawExp.slice(start, end); + children.push(createSimpleExpression(id.name, false, { + source, + start: advancePositionWithClone(node.loc.start, source, start), + end: advancePositionWithClone(node.loc.start, source, end) + }, id.isConstant ? 3 /* CAN_STRINGIFY */ : 0 /* NOT_CONSTANT */)); + if (i === ids.length - 1 && end < rawExp.length) { + children.push(rawExp.slice(end)); + } + }); + let ret; + if (children.length) { + ret = createCompoundExpression(children, node.loc); + } + else { + ret = node; + ret.constType = bailConstant + ? 0 /* NOT_CONSTANT */ + : 3 /* CAN_STRINGIFY */; + } + ret.identifiers = Object.keys(knownIds); + return ret; +} +function canPrefix(id) { + // skip whitelisted globals + if (isGloballyWhitelisted(id.name)) { + return false; + } + // special case for webpack compilation + if (id.name === 'require') { + return false; + } + return true; +} +function stringifyExpression(exp) { + if (isString(exp)) { + return exp; + } + else if (exp.type === 4 /* SIMPLE_EXPRESSION */) { + return exp.content; + } + else { + return exp.children + .map(stringifyExpression) + .join(''); + } +} + +const transformIf = createStructuralDirectiveTransform(/^(if|else|else-if)$/, (node, dir, context) => { + return processIf(node, dir, context, (ifNode, branch, isRoot) => { + // #1587: We need to dynamically increment the key based on the current + // node's sibling nodes, since chained v-if/else branches are + // rendered at the same depth + 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 /* IF */) { + key += sibling.branches.length; + } + } + // Exit callback. Complete the codegenNode when all children have been + // transformed. + return () => { + if (isRoot) { + ifNode.codegenNode = createCodegenNodeForBranch(branch, key, context); + } + else { + // attach this branch's codegen node to the v-if root. + const parentCondition = getParentCondition(ifNode.codegenNode); + parentCondition.alternate = createCodegenNodeForBranch(branch, key + ifNode.branches.length - 1, context); + } + }; + }); +}); +// target-agnostic transform used for both Client and SSR +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 /* X_V_IF_NO_EXPRESSION */, dir.loc)); + dir.exp = createSimpleExpression(`true`, false, loc); + } + if (context.prefixIdentifiers && dir.exp) { + // dir.exp can only be simple expression because vIf transform is applied + // before expression transform. + dir.exp = processExpression(dir.exp, context); + } + if (dir.name === 'if') { + const branch = createIfBranch(node, dir); + const ifNode = { + type: 9 /* IF */, + loc: node.loc, + branches: [branch] + }; + context.replaceNode(ifNode); + if (processCodegen) { + return processCodegen(ifNode, branch, true); + } + } + else { + // locate the adjacent v-if + const siblings = context.parent.children; + const comments = []; + let i = siblings.indexOf(node); + while (i-- >= -1) { + const sibling = siblings[i]; + if (sibling && sibling.type === 3 /* COMMENT */) { + context.removeNode(sibling); + comments.unshift(sibling); + continue; + } + if (sibling && + sibling.type === 2 /* TEXT */ && + !sibling.content.trim().length) { + context.removeNode(sibling); + continue; + } + if (sibling && sibling.type === 9 /* IF */) { + // Check if v-else was followed by v-else-if + if (dir.name === 'else-if' && + sibling.branches[sibling.branches.length - 1].condition === undefined) { + context.onError(createCompilerError(30 /* X_V_ELSE_NO_ADJACENT_IF */, node.loc)); + } + // move the node to the if node's branches + context.removeNode(); + const branch = createIfBranch(node, dir); + if (comments.length && + // #3619 ignore comments if the v-if is direct child of + !(context.parent && + context.parent.type === 1 /* ELEMENT */ && + isBuiltInType(context.parent.tag, 'transition'))) { + branch.children = [...comments, ...branch.children]; + } + // check if user is forcing same key on different branches + { + const key = branch.userKey; + if (key) { + sibling.branches.forEach(({ userKey }) => { + if (isSameKey(userKey, key)) { + context.onError(createCompilerError(29 /* X_V_IF_SAME_KEY */, branch.userKey.loc)); + } + }); + } + } + sibling.branches.push(branch); + const onExit = processCodegen && processCodegen(sibling, branch, false); + // since the branch was removed, it will not be traversed. + // make sure to traverse here. + traverseNode(branch, context); + // call on exit + if (onExit) + onExit(); + // make sure to reset currentNode after traversal to indicate this + // node has been removed. + context.currentNode = null; + } + else { + context.onError(createCompilerError(30 /* X_V_ELSE_NO_ADJACENT_IF */, node.loc)); + } + break; + } + } +} +function createIfBranch(node, dir) { + const isTemplateIf = node.tagType === 3 /* TEMPLATE */; + return { + type: 10 /* IF_BRANCH */, + loc: node.loc, + condition: dir.name === 'else' ? undefined : 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), + // make sure to pass in asBlock: true so that the comment node call + // closes the current block. + 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 /* CAN_HOIST */)); + const { children } = branch; + const firstChild = children[0]; + const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1 /* ELEMENT */; + if (needFragmentWrapper) { + if (children.length === 1 && firstChild.type === 11 /* FOR */) { + // optimize away nested fragments when child is a ForNode + const vnodeCall = firstChild.codegenNode; + injectProp(vnodeCall, keyProperty, context); + return vnodeCall; + } + else { + let patchFlag = 64 /* STABLE_FRAGMENT */; + let patchFlagText = PatchFlagNames[64 /* STABLE_FRAGMENT */]; + // check if the fragment actually contains a single valid child with + // the rest being comments + if (!branch.isTemplateIf && + children.filter(c => c.type !== 3 /* COMMENT */).length === 1) { + patchFlag |= 2048 /* DEV_ROOT_FRAGMENT */; + patchFlagText += `, ${PatchFlagNames[2048 /* DEV_ROOT_FRAGMENT */]}`; + } + return createVNodeCall(context, helper(FRAGMENT), createObjectExpression([keyProperty]), children, patchFlag + (` /* ${patchFlagText} */` ), undefined, undefined, true, false, false /* isComponent */, branch.loc); + } + } + else { + const ret = firstChild.codegenNode; + const vnodeCall = getMemoedVNodeCall(ret); + // Change createVNode to createBlock. + if (vnodeCall.type === 13 /* VNODE_CALL */) { + makeBlock(vnodeCall, context); + } + // inject branch key + injectProp(vnodeCall, keyProperty, context); + return ret; + } +} +function isSameKey(a, b) { + if (!a || a.type !== b.type) { + return false; + } + if (a.type === 6 /* ATTRIBUTE */) { + if (a.value.content !== b.value.content) { + return false; + } + } + else { + // directive + const exp = a.exp; + const branchExp = b.exp; + if (exp.type !== branchExp.type) { + return false; + } + if (exp.type !== 4 /* SIMPLE_EXPRESSION */ || + exp.isStatic !== branchExp.isStatic || + exp.content !== branchExp.content) { + return false; + } + } + return true; +} +function getParentCondition(node) { + while (true) { + if (node.type === 19 /* JS_CONDITIONAL_EXPRESSION */) { + if (node.alternate.type === 19 /* JS_CONDITIONAL_EXPRESSION */) { + node = node.alternate; + } + else { + return node; + } + } + else if (node.type === 20 /* JS_CACHE_EXPRESSION */) { + node = node.value; + } + } +} + +const transformFor = createStructuralDirectiveTransform('for', (node, dir, context) => { + const { helper, removeHelper } = context; + return processFor(node, dir, context, forNode => { + // create the loop render function expression now, and add the + // iterator on exit after all children have been traversed + const renderExp = createCallExpression(helper(RENDER_LIST), [ + forNode.source + ]); + const isTemplate = isTemplateNode(node); + const memo = findDir(node, 'memo'); + const keyProp = findProp(node, `key`); + const keyExp = keyProp && + (keyProp.type === 6 /* ATTRIBUTE */ + ? createSimpleExpression(keyProp.value.content, true) + : keyProp.exp); + const keyProperty = keyProp ? createObjectProperty(`key`, keyExp) : null; + if (isTemplate) { + // #2085 / #5288 process :key and v-memo expressions need to be + // processed on `