diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..3c3629e
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+node_modules
diff --git a/WebPageTools.bsdesign b/UI/WebPageTools.bsdesign
similarity index 100%
rename from WebPageTools.bsdesign
rename to UI/WebPageTools.bsdesign
diff --git a/UIout/assets/css/Navbar-Right-Links-icons.css b/UI/assets/css/Navbar-Right-Links-icons.css
similarity index 100%
rename from UIout/assets/css/Navbar-Right-Links-icons.css
rename to UI/assets/css/Navbar-Right-Links-icons.css
diff --git a/UIout/assets/css/styles.min.css b/UI/assets/css/styles.min.css
similarity index 100%
rename from UIout/assets/css/styles.min.css
rename to UI/assets/css/styles.min.css
diff --git a/UIout/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459W1hyzbi.woff2 b/UI/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459W1hyzbi.woff2
similarity index 100%
rename from UIout/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459W1hyzbi.woff2
rename to UI/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459W1hyzbi.woff2
diff --git a/UIout/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WRhyzbi.woff2 b/UI/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WRhyzbi.woff2
similarity index 100%
rename from UIout/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WRhyzbi.woff2
rename to UI/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WRhyzbi.woff2
diff --git a/UIout/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WZhyzbi.woff2 b/UI/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WZhyzbi.woff2
similarity index 100%
rename from UIout/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WZhyzbi.woff2
rename to UI/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WZhyzbi.woff2
diff --git a/UIout/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wdhyzbi.woff2 b/UI/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wdhyzbi.woff2
similarity index 100%
rename from UIout/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wdhyzbi.woff2
rename to UI/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wdhyzbi.woff2
diff --git a/UIout/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wlhyw.woff2 b/UI/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wlhyw.woff2
similarity index 100%
rename from UIout/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wlhyw.woff2
rename to UI/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wlhyw.woff2
diff --git a/UIout/assets/img/logo.png b/UI/assets/img/logo.png
similarity index 100%
rename from UIout/assets/img/logo.png
rename to UI/assets/img/logo.png
diff --git a/UIout/assets/js/jquery.min.js b/UI/assets/js/jquery.min.js
similarity index 100%
rename from UIout/assets/js/jquery.min.js
rename to UI/assets/js/jquery.min.js
diff --git a/UIout/index.html b/UI/index.html
similarity index 100%
rename from UIout/index.html
rename to UI/index.html
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..f9ee70b
--- /dev/null
+++ b/index.html
@@ -0,0 +1,60 @@
+<<<<<<< HEAD
+
+
+
+
+
+
+
+
+
+
+
+
+ {{text}}
+
+
+
+=======
+
+
+
+
+
+ 飛翔小工具
+
+
+
+
+
+
+
+
+ 飛翔小工具
+
+
+
+>>>>>>> 5c8b0e3d501b28e74afee9c4c8e16825bf6c850e
diff --git a/v2/src/assets/js/jquery.min.js b/jquery.js
similarity index 100%
rename from v2/src/assets/js/jquery.min.js
rename to jquery.js
diff --git a/v2/src/assets/css/Navbar-Right-Links-icons.css b/lib/bootstrap/css/Navbar-Right-Links-icons.css
similarity index 100%
rename from v2/src/assets/css/Navbar-Right-Links-icons.css
rename to lib/bootstrap/css/Navbar-Right-Links-icons.css
diff --git a/UIout/assets/bootstrap/css/bootstrap.min.css b/lib/bootstrap/css/bootstrap.min.css
similarity index 100%
rename from UIout/assets/bootstrap/css/bootstrap.min.css
rename to lib/bootstrap/css/bootstrap.min.css
diff --git a/v2/src/assets/css/styles.min.css b/lib/bootstrap/css/styles.min.css
similarity index 100%
rename from v2/src/assets/css/styles.min.css
rename to lib/bootstrap/css/styles.min.css
diff --git a/v2/src/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459W1hyzbi.woff2 b/lib/bootstrap/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459W1hyzbi.woff2
similarity index 100%
rename from v2/src/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459W1hyzbi.woff2
rename to lib/bootstrap/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459W1hyzbi.woff2
diff --git a/v2/src/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WRhyzbi.woff2 b/lib/bootstrap/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WRhyzbi.woff2
similarity index 100%
rename from v2/src/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WRhyzbi.woff2
rename to lib/bootstrap/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WRhyzbi.woff2
diff --git a/v2/src/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WZhyzbi.woff2 b/lib/bootstrap/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WZhyzbi.woff2
similarity index 100%
rename from v2/src/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WZhyzbi.woff2
rename to lib/bootstrap/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459WZhyzbi.woff2
diff --git a/v2/src/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wdhyzbi.woff2 b/lib/bootstrap/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wdhyzbi.woff2
similarity index 100%
rename from v2/src/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wdhyzbi.woff2
rename to lib/bootstrap/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wdhyzbi.woff2
diff --git a/v2/src/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wlhyw.woff2 b/lib/bootstrap/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wlhyw.woff2
similarity index 100%
rename from v2/src/assets/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wlhyw.woff2
rename to lib/bootstrap/fonts/s/montserrat/v25/JTUSjIg1_i6t8kCHKm459Wlhyw.woff2
diff --git a/UIout/assets/bootstrap/js/bootstrap.min.js b/lib/bootstrap/js/bootstrap.min.js
similarity index 100%
rename from UIout/assets/bootstrap/js/bootstrap.min.js
rename to lib/bootstrap/js/bootstrap.min.js
diff --git a/lib/jquery.js b/lib/jquery.js
new file mode 100644
index 0000000..d25321a
--- /dev/null
+++ b/lib/jquery.js
@@ -0,0 +1,2 @@
+/*! jQuery v3.6.1 -ajax,-ajax/jsonp,-ajax/load,-ajax/script,-ajax/var/location,-ajax/var/nonce,-ajax/var/rquery,-ajax/xhr,-manipulation/_evalUrl,-deprecated/ajax-event-alias,-effects,-effects/Tween,-effects/animatedSelector | (c) OpenJS Foundation and other contributors | jquery.org/license */
+!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(g,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,v=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,y=n.hasOwnProperty,a=y.toString,l=a.call(Object),m={},b=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},x=function(e){return null!=e&&e===e.window},w=g.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function C(e,t,n){var r,i,o=(n=n||w).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function T(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.6.1 -ajax,-ajax/jsonp,-ajax/load,-ajax/script,-ajax/var/location,-ajax/var/nonce,-ajax/var/rquery,-ajax/xhr,-manipulation/_evalUrl,-deprecated/ajax-event-alias,-effects,-effects/Tween,-effects/animatedSelector",E=function(e,t){return new E.fn.init(e,t)};function d(e){var t=!!e&&"length"in e&&e.length,n=T(e);return!b(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0+~]|"+R+")"+R+"*"),U=new RegExp(R+"|>"),V=new RegExp(W),X=new RegExp("^"+B+"$"),Q={ID:new RegExp("^#("+B+")"),CLASS:new RegExp("^\\.("+B+")"),TAG:new RegExp("^("+B+"|[*])"),ATTR:new RegExp("^"+M),PSEUDO:new RegExp("^"+W),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+R+"*(even|odd|(([+-]|)(\\d*)n|)"+R+"*(?:([+-]|)"+R+"*(\\d+)|))"+R+"*\\)|)","i"),bool:new RegExp("^(?:"+I+")$","i"),needsContext:new RegExp("^"+R+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+R+"*((?:-\\d)?\\d*)"+R+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,G=/^(?:input|select|textarea|button)$/i,K=/^h\d$/i,J=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+R+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){C()},ae=xe(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{O.apply(t=P.call(d.childNodes),d.childNodes),t[d.childNodes.length].nodeType}catch(e){O={apply:t.length?function(e,t){q.apply(e,P.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,d=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==d&&9!==d&&11!==d)return n;if(!r&&(C(e),e=e||T,E)){if(11!==d&&(u=Z.exec(t)))if(i=u[1]){if(9===d){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return O.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&p.getElementsByClassName&&e.getElementsByClassName)return O.apply(n,e.getElementsByClassName(i)),n}if(p.qsa&&!k[t+" "]&&(!v||!v.test(t))&&(1!==d||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===d&&(U.test(t)||_.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&p.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=A)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+be(l[o]);c=l.join(",")}try{return O.apply(n,f.querySelectorAll(c)),n}catch(e){k(t,!0)}finally{s===A&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>x.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[A]=!0,e}function ce(e){var t=T.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)x.attrHandle[n[r]]=t}function de(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function pe(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in p=se.support={},i=se.isXML=function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},C=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:d;return r!=T&&9===r.nodeType&&r.documentElement&&(a=(T=r).documentElement,E=!i(T),d!=T&&(n=T.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),p.scope=ce(function(e){return a.appendChild(e).appendChild(T.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),p.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),p.getElementsByTagName=ce(function(e){return e.appendChild(T.createComment("")),!e.getElementsByTagName("*").length}),p.getElementsByClassName=J.test(T.getElementsByClassName),p.getById=ce(function(e){return a.appendChild(e).id=A,!T.getElementsByName||!T.getElementsByName(A).length}),p.getById?(x.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},x.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(x.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},x.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),x.find.TAG=p.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):p.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},x.find.CLASS=p.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(p.qsa=J.test(T.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML=" ",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+R+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+R+"*(?:value|"+I+")"),e.querySelectorAll("[id~="+A+"-]").length||v.push("~="),(t=T.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+R+"*name"+R+"*="+R+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+A+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML=" ";var t=T.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+R+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(p.matchesSelector=J.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){p.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",W)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=J.test(a.compareDocumentPosition),y=t||J.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},D=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!p.sortDetached&&t.compareDocumentPosition(e)===n?e==T||e.ownerDocument==d&&y(d,e)?-1:t==T||t.ownerDocument==d&&y(d,t)?1:u?H(u,e)-H(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==T?-1:t==T?1:i?-1:o?1:u?H(u,e)-H(u,t):0;if(i===o)return de(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?de(a[r],s[r]):a[r]==d?-1:s[r]==d?1:0}),T},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(C(e),p.matchesSelector&&E&&!k[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||p.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){k(t,!0)}return 0":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return Q.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&V.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+R+")"+e+"("+R+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function D(e,n,r){return b(n)?E.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?E.grep(e,function(e){return e===n!==r}):"string"!=typeof n?E.grep(e,function(e){return-1)[^>]*|#([\w-]+))$/;(E.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||L,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:j.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof E?t[0]:t,E.merge(this,E.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:w,!0)),k.test(r[1])&&E.isPlainObject(t))for(r in t)b(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=w.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):b(e)?void 0!==n.ready?n.ready(e):e(E):E.makeArray(e,this)}).prototype=E.fn,L=E(w);var q=/^(?:parents|prev(?:Until|All))/,O={children:!0,contents:!0,next:!0,prev:!0};function P(e,t){while((e=e[t])&&1!==e.nodeType);return e}E.fn.extend({has:function(e){var t=E(e,this),n=t.length;return this.filter(function(){for(var e=0;e\x20\t\r\n\f]*)/i,pe=/^$|^module$|\/(?:java|ecma)script/i;le=w.createDocumentFragment().appendChild(w.createElement("div")),(ce=w.createElement("input")).setAttribute("type","radio"),ce.setAttribute("checked","checked"),ce.setAttribute("name","t"),le.appendChild(ce),m.checkClone=le.cloneNode(!0).cloneNode(!0).lastChild.checked,le.innerHTML="",m.noCloneChecked=!!le.cloneNode(!0).lastChild.defaultValue,le.innerHTML=" ",m.option=!!le.lastChild;var he={thead:[1,""],col:[2,""],tr:[2,""],td:[3,""],_default:[0,"",""]};function ge(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&S(e,t)?E.merge([e],n):n}function ve(e,t){for(var n=0,r=e.length;n",""]);var ye=/<|?\w+;/;function me(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),d=[],p=0,h=e.length;p\s*$/g;function ke(e,t){return S(e,"table")&&S(11!==t.nodeType?t:t.firstChild,"tr")&&E(e).children("tbody")[0]||e}function De(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function Le(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function je(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n",2===ft.childNodes.length),E.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(m.createHTMLDocument?((r=(t=w.implementation.createHTMLDocument("")).createElement("base")).href=w.location.href,t.head.appendChild(r)):t=w),o=!n&&[],(i=k.exec(e))?[t.createElement(i[1])]:(i=me([e],t,o),o&&o.length&&E(o).remove(),E.merge([],i.childNodes)));var r,i,o},E.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=E.css(e,"position"),c=E(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=E.css(e,"top"),u=E.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),b(t)&&(t=t.call(e,n,E.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},E.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){E.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===E.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===E.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=E(e).offset()).top+=E.css(e,"borderTopWidth",!0),i.left+=E.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-E.css(r,"marginTop",!0),left:t.left-i.left-E.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===E.css(e,"position"))e=e.offsetParent;return e||re})}}),E.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;E.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),E.each(["top","left"],function(e,n){E.cssHooks[n]=$e(m.pixelPosition,function(e,t){if(t)return t=Fe(e,n),Pe.test(t)?E(e).position()[n]+"px":t})}),E.each({Height:"height",Width:"width"},function(a,s){E.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){E.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?E.css(e,t,i):E.style(e,t,n,i)},s,n?e:void 0,n)}})}),E.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),E.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){E.fn[n]=function(e,t){return 0 !!map[val.toLowerCase()] : val => !!map[val];
+ }
+
+ /**
+ * dev only flag -> name mapping
+ */
+ const PatchFlagNames = {
+ [1 /* PatchFlags.TEXT */]: `TEXT`,
+ [2 /* PatchFlags.CLASS */]: `CLASS`,
+ [4 /* PatchFlags.STYLE */]: `STYLE`,
+ [8 /* PatchFlags.PROPS */]: `PROPS`,
+ [16 /* PatchFlags.FULL_PROPS */]: `FULL_PROPS`,
+ [32 /* PatchFlags.HYDRATE_EVENTS */]: `HYDRATE_EVENTS`,
+ [64 /* PatchFlags.STABLE_FRAGMENT */]: `STABLE_FRAGMENT`,
+ [128 /* PatchFlags.KEYED_FRAGMENT */]: `KEYED_FRAGMENT`,
+ [256 /* PatchFlags.UNKEYED_FRAGMENT */]: `UNKEYED_FRAGMENT`,
+ [512 /* PatchFlags.NEED_PATCH */]: `NEED_PATCH`,
+ [1024 /* PatchFlags.DYNAMIC_SLOTS */]: `DYNAMIC_SLOTS`,
+ [2048 /* PatchFlags.DEV_ROOT_FRAGMENT */]: `DEV_ROOT_FRAGMENT`,
+ [-1 /* PatchFlags.HOISTED */]: `HOISTED`,
+ [-2 /* PatchFlags.BAIL */]: `BAIL`
+ };
+
+ /**
+ * Dev only
+ */
+ const slotFlagsText = {
+ [1 /* SlotFlags.STABLE */]: 'STABLE',
+ [2 /* SlotFlags.DYNAMIC */]: 'DYNAMIC',
+ [3 /* SlotFlags.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');
+ }
+
+ 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 = /:([^]+)/;
+ const styleCommentRE = /\/\*.*?\*\//gs;
+ function parseStringStyle(cssText) {
+ const ret = {};
+ cssText
+ .replace(styleCommentRE, '')
+ .split(listDelimiterRE)
+ .forEach(item => {
+ if (item) {
+ const tmp = item.split(propertyDelimiterRE);
+ tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
+ }
+ });
+ 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();
+ }
+ function normalizeProps(props) {
+ if (!props)
+ return null;
+ let { class: klass, style } = props;
+ if (klass && !isString(klass)) {
+ props.class = normalizeClass(klass);
+ }
+ if (style) {
+ props.style = normalizeStyle(style);
+ }
+ return props;
+ }
+
+ // 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);
+
+ /**
+ * 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`;
+ const isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);
+ /**
+ * Boolean attributes should be included if the value is truthy or ''.
+ * e.g. `` compiles to `{ multiple: '' }`
+ */
+ function includeBooleanAttr(value) {
+ return !!value || value === '';
+ }
+
+ function looseCompareArrays(a, b) {
+ if (a.length !== b.length)
+ return false;
+ let equal = true;
+ for (let i = 0; equal && i < a.length; i++) {
+ equal = looseEqual(a[i], b[i]);
+ }
+ return equal;
+ }
+ function looseEqual(a, b) {
+ if (a === b)
+ return true;
+ let aValidType = isDate(a);
+ let bValidType = isDate(b);
+ if (aValidType || bValidType) {
+ return aValidType && bValidType ? a.getTime() === b.getTime() : false;
+ }
+ aValidType = isSymbol(a);
+ bValidType = isSymbol(b);
+ if (aValidType || bValidType) {
+ return a === b;
+ }
+ aValidType = isArray(a);
+ bValidType = isArray(b);
+ if (aValidType || bValidType) {
+ return aValidType && bValidType ? looseCompareArrays(a, b) : false;
+ }
+ aValidType = isObject(a);
+ bValidType = isObject(b);
+ if (aValidType || bValidType) {
+ /* istanbul ignore if: this if will probably never be called */
+ if (!aValidType || !bValidType) {
+ return false;
+ }
+ const aKeysCount = Object.keys(a).length;
+ const bKeysCount = Object.keys(b).length;
+ if (aKeysCount !== bKeysCount) {
+ return false;
+ }
+ for (const key in a) {
+ const aHasKey = a.hasOwnProperty(key);
+ const bHasKey = b.hasOwnProperty(key);
+ if ((aHasKey && !bHasKey) ||
+ (!aHasKey && bHasKey) ||
+ !looseEqual(a[key], b[key])) {
+ return false;
+ }
+ }
+ }
+ return String(a) === String(b);
+ }
+ function looseIndexOf(arr, val) {
+ return arr.findIndex(item => looseEqual(item, val));
+ }
+
+ /**
+ * 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({})
+ ;
+ const EMPTY_ARR = Object.freeze([]) ;
+ const NOOP = () => { };
+ /**
+ * Always return false.
+ */
+ const NO = () => false;
+ const onRE = /^on[^a-z]/;
+ const isOn = (key) => onRE.test(key);
+ const isModelListener = (key) => key.startsWith('onUpdate:');
+ const extend = Object.assign;
+ const remove = (arr, el) => {
+ const i = arr.indexOf(el);
+ if (i > -1) {
+ arr.splice(i, 1);
+ }
+ };
+ 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 isDate = (val) => toTypeString(val) === '[object Date]';
+ 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 isPromise = (val) => {
+ return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+ };
+ const objectToString = Object.prototype.toString;
+ const toTypeString = (value) => objectToString.call(value);
+ const toRawType = (value) => {
+ // extract "RawType" from strings like "[object RawType]"
+ return toTypeString(value).slice(8, -1);
+ };
+ const isPlainObject = (val) => toTypeString(val) === '[object Object]';
+ const isIntegerKey = (key) => isString(key) &&
+ key !== 'NaN' &&
+ key[0] !== '-' &&
+ '' + parseInt(key, 10) === key;
+ 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)}` : ``);
+ // compare whether a value has changed, accounting for NaN.
+ const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+ const invokeArrayFns = (fns, arg) => {
+ for (let i = 0; i < fns.length; i++) {
+ fns[i](arg);
+ }
+ };
+ const def = (obj, key, value) => {
+ Object.defineProperty(obj, key, {
+ configurable: true,
+ enumerable: false,
+ value
+ });
+ };
+ const toNumber = (val) => {
+ const n = parseFloat(val);
+ return isNaN(n) ? val : n;
+ };
+ let _globalThis;
+ const getGlobalThis = () => {
+ return (_globalThis ||
+ (_globalThis =
+ typeof globalThis !== 'undefined'
+ ? globalThis
+ : typeof self !== 'undefined'
+ ? self
+ : typeof window !== 'undefined'
+ ? window
+ : typeof global !== 'undefined'
+ ? global
+ : {}));
+ };
+
+ function warn(msg, ...args) {
+ console.warn(`[Vue warn] ${msg}`, ...args);
+ }
+
+ let activeEffectScope;
+ class EffectScope {
+ constructor(detached = false) {
+ this.detached = detached;
+ /**
+ * @internal
+ */
+ this.active = true;
+ /**
+ * @internal
+ */
+ this.effects = [];
+ /**
+ * @internal
+ */
+ this.cleanups = [];
+ this.parent = activeEffectScope;
+ if (!detached && activeEffectScope) {
+ this.index =
+ (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
+ }
+ }
+ run(fn) {
+ if (this.active) {
+ const currentEffectScope = activeEffectScope;
+ try {
+ activeEffectScope = this;
+ return fn();
+ }
+ finally {
+ activeEffectScope = currentEffectScope;
+ }
+ }
+ else {
+ warn(`cannot run an inactive effect scope.`);
+ }
+ }
+ /**
+ * This should only be called on non-detached scopes
+ * @internal
+ */
+ on() {
+ activeEffectScope = this;
+ }
+ /**
+ * This should only be called on non-detached scopes
+ * @internal
+ */
+ off() {
+ activeEffectScope = this.parent;
+ }
+ stop(fromParent) {
+ if (this.active) {
+ let i, l;
+ for (i = 0, l = this.effects.length; i < l; i++) {
+ this.effects[i].stop();
+ }
+ for (i = 0, l = this.cleanups.length; i < l; i++) {
+ this.cleanups[i]();
+ }
+ if (this.scopes) {
+ for (i = 0, l = this.scopes.length; i < l; i++) {
+ this.scopes[i].stop(true);
+ }
+ }
+ // nested scope, dereference from parent to avoid memory leaks
+ if (!this.detached && this.parent && !fromParent) {
+ // optimized O(1) removal
+ const last = this.parent.scopes.pop();
+ if (last && last !== this) {
+ this.parent.scopes[this.index] = last;
+ last.index = this.index;
+ }
+ }
+ this.parent = undefined;
+ this.active = false;
+ }
+ }
+ }
+ function effectScope(detached) {
+ return new EffectScope(detached);
+ }
+ function recordEffectScope(effect, scope = activeEffectScope) {
+ if (scope && scope.active) {
+ scope.effects.push(effect);
+ }
+ }
+ function getCurrentScope() {
+ return activeEffectScope;
+ }
+ function onScopeDispose(fn) {
+ if (activeEffectScope) {
+ activeEffectScope.cleanups.push(fn);
+ }
+ else {
+ warn(`onScopeDispose() is called when there is no active effect scope` +
+ ` to be associated with.`);
+ }
+ }
+
+ const createDep = (effects) => {
+ const dep = new Set(effects);
+ dep.w = 0;
+ dep.n = 0;
+ return dep;
+ };
+ const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
+ const newTracked = (dep) => (dep.n & trackOpBit) > 0;
+ const initDepMarkers = ({ deps }) => {
+ if (deps.length) {
+ for (let i = 0; i < deps.length; i++) {
+ deps[i].w |= trackOpBit; // set was tracked
+ }
+ }
+ };
+ const finalizeDepMarkers = (effect) => {
+ const { deps } = effect;
+ if (deps.length) {
+ let ptr = 0;
+ for (let i = 0; i < deps.length; i++) {
+ const dep = deps[i];
+ if (wasTracked(dep) && !newTracked(dep)) {
+ dep.delete(effect);
+ }
+ else {
+ deps[ptr++] = dep;
+ }
+ // clear bits
+ dep.w &= ~trackOpBit;
+ dep.n &= ~trackOpBit;
+ }
+ deps.length = ptr;
+ }
+ };
+
+ const targetMap = new WeakMap();
+ // The number of effects currently being tracked recursively.
+ let effectTrackDepth = 0;
+ let trackOpBit = 1;
+ /**
+ * The bitwise track markers support at most 30 levels of recursion.
+ * This value is chosen to enable modern JS engines to use a SMI on all platforms.
+ * When recursion depth is greater, fall back to using a full cleanup.
+ */
+ const maxMarkerBits = 30;
+ let activeEffect;
+ const ITERATE_KEY = Symbol('iterate' );
+ const MAP_KEY_ITERATE_KEY = Symbol('Map key iterate' );
+ class ReactiveEffect {
+ constructor(fn, scheduler = null, scope) {
+ this.fn = fn;
+ this.scheduler = scheduler;
+ this.active = true;
+ this.deps = [];
+ this.parent = undefined;
+ recordEffectScope(this, scope);
+ }
+ run() {
+ if (!this.active) {
+ return this.fn();
+ }
+ let parent = activeEffect;
+ let lastShouldTrack = shouldTrack;
+ while (parent) {
+ if (parent === this) {
+ return;
+ }
+ parent = parent.parent;
+ }
+ try {
+ this.parent = activeEffect;
+ activeEffect = this;
+ shouldTrack = true;
+ trackOpBit = 1 << ++effectTrackDepth;
+ if (effectTrackDepth <= maxMarkerBits) {
+ initDepMarkers(this);
+ }
+ else {
+ cleanupEffect(this);
+ }
+ return this.fn();
+ }
+ finally {
+ if (effectTrackDepth <= maxMarkerBits) {
+ finalizeDepMarkers(this);
+ }
+ trackOpBit = 1 << --effectTrackDepth;
+ activeEffect = this.parent;
+ shouldTrack = lastShouldTrack;
+ this.parent = undefined;
+ if (this.deferStop) {
+ this.stop();
+ }
+ }
+ }
+ stop() {
+ // stopped while running itself - defer the cleanup
+ if (activeEffect === this) {
+ this.deferStop = true;
+ }
+ else if (this.active) {
+ cleanupEffect(this);
+ if (this.onStop) {
+ this.onStop();
+ }
+ this.active = false;
+ }
+ }
+ }
+ function cleanupEffect(effect) {
+ const { deps } = effect;
+ if (deps.length) {
+ for (let i = 0; i < deps.length; i++) {
+ deps[i].delete(effect);
+ }
+ deps.length = 0;
+ }
+ }
+ function effect(fn, options) {
+ if (fn.effect) {
+ fn = fn.effect.fn;
+ }
+ const _effect = new ReactiveEffect(fn);
+ if (options) {
+ extend(_effect, options);
+ if (options.scope)
+ recordEffectScope(_effect, options.scope);
+ }
+ if (!options || !options.lazy) {
+ _effect.run();
+ }
+ const runner = _effect.run.bind(_effect);
+ runner.effect = _effect;
+ return runner;
+ }
+ function stop(runner) {
+ runner.effect.stop();
+ }
+ let shouldTrack = true;
+ const trackStack = [];
+ function pauseTracking() {
+ trackStack.push(shouldTrack);
+ shouldTrack = false;
+ }
+ function resetTracking() {
+ const last = trackStack.pop();
+ shouldTrack = last === undefined ? true : last;
+ }
+ function track(target, type, key) {
+ if (shouldTrack && activeEffect) {
+ let depsMap = targetMap.get(target);
+ if (!depsMap) {
+ targetMap.set(target, (depsMap = new Map()));
+ }
+ let dep = depsMap.get(key);
+ if (!dep) {
+ depsMap.set(key, (dep = createDep()));
+ }
+ const eventInfo = { effect: activeEffect, target, type, key }
+ ;
+ trackEffects(dep, eventInfo);
+ }
+ }
+ function trackEffects(dep, debuggerEventExtraInfo) {
+ let shouldTrack = false;
+ if (effectTrackDepth <= maxMarkerBits) {
+ if (!newTracked(dep)) {
+ dep.n |= trackOpBit; // set newly tracked
+ shouldTrack = !wasTracked(dep);
+ }
+ }
+ else {
+ // Full cleanup mode.
+ shouldTrack = !dep.has(activeEffect);
+ }
+ if (shouldTrack) {
+ dep.add(activeEffect);
+ activeEffect.deps.push(dep);
+ if (activeEffect.onTrack) {
+ activeEffect.onTrack(Object.assign({ effect: activeEffect }, debuggerEventExtraInfo));
+ }
+ }
+ }
+ function trigger(target, type, key, newValue, oldValue, oldTarget) {
+ const depsMap = targetMap.get(target);
+ if (!depsMap) {
+ // never been tracked
+ return;
+ }
+ let deps = [];
+ if (type === "clear" /* TriggerOpTypes.CLEAR */) {
+ // collection being cleared
+ // trigger all effects for target
+ deps = [...depsMap.values()];
+ }
+ else if (key === 'length' && isArray(target)) {
+ const newLength = toNumber(newValue);
+ depsMap.forEach((dep, key) => {
+ if (key === 'length' || key >= newLength) {
+ deps.push(dep);
+ }
+ });
+ }
+ else {
+ // schedule runs for SET | ADD | DELETE
+ if (key !== void 0) {
+ deps.push(depsMap.get(key));
+ }
+ // also run for iteration key on ADD | DELETE | Map.SET
+ switch (type) {
+ case "add" /* TriggerOpTypes.ADD */:
+ if (!isArray(target)) {
+ deps.push(depsMap.get(ITERATE_KEY));
+ if (isMap(target)) {
+ deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+ }
+ }
+ else if (isIntegerKey(key)) {
+ // new index added to array -> length changes
+ deps.push(depsMap.get('length'));
+ }
+ break;
+ case "delete" /* TriggerOpTypes.DELETE */:
+ if (!isArray(target)) {
+ deps.push(depsMap.get(ITERATE_KEY));
+ if (isMap(target)) {
+ deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+ }
+ }
+ break;
+ case "set" /* TriggerOpTypes.SET */:
+ if (isMap(target)) {
+ deps.push(depsMap.get(ITERATE_KEY));
+ }
+ break;
+ }
+ }
+ const eventInfo = { target, type, key, newValue, oldValue, oldTarget }
+ ;
+ if (deps.length === 1) {
+ if (deps[0]) {
+ {
+ triggerEffects(deps[0], eventInfo);
+ }
+ }
+ }
+ else {
+ const effects = [];
+ for (const dep of deps) {
+ if (dep) {
+ effects.push(...dep);
+ }
+ }
+ {
+ triggerEffects(createDep(effects), eventInfo);
+ }
+ }
+ }
+ function triggerEffects(dep, debuggerEventExtraInfo) {
+ // spread into array for stabilization
+ const effects = isArray(dep) ? dep : [...dep];
+ for (const effect of effects) {
+ if (effect.computed) {
+ triggerEffect(effect, debuggerEventExtraInfo);
+ }
+ }
+ for (const effect of effects) {
+ if (!effect.computed) {
+ triggerEffect(effect, debuggerEventExtraInfo);
+ }
+ }
+ }
+ function triggerEffect(effect, debuggerEventExtraInfo) {
+ if (effect !== activeEffect || effect.allowRecurse) {
+ if (effect.onTrigger) {
+ effect.onTrigger(extend({ effect }, debuggerEventExtraInfo));
+ }
+ if (effect.scheduler) {
+ effect.scheduler();
+ }
+ else {
+ effect.run();
+ }
+ }
+ }
+
+ const isNonTrackableKeys = /*#__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`);
+ const builtInSymbols = new Set(
+ /*#__PURE__*/
+ Object.getOwnPropertyNames(Symbol)
+ // ios10.x Object.getOwnPropertyNames(Symbol) can enumerate 'arguments' and 'caller'
+ // but accessing them on Symbol leads to TypeError because Symbol is a strict mode
+ // function
+ .filter(key => key !== 'arguments' && key !== 'caller')
+ .map(key => Symbol[key])
+ .filter(isSymbol));
+ const get = /*#__PURE__*/ createGetter();
+ const shallowGet = /*#__PURE__*/ createGetter(false, true);
+ const readonlyGet = /*#__PURE__*/ createGetter(true);
+ const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);
+ const arrayInstrumentations = /*#__PURE__*/ createArrayInstrumentations();
+ function createArrayInstrumentations() {
+ const instrumentations = {};
+ ['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
+ instrumentations[key] = function (...args) {
+ const arr = toRaw(this);
+ for (let i = 0, l = this.length; i < l; i++) {
+ track(arr, "get" /* TrackOpTypes.GET */, i + '');
+ }
+ // we run the method using the original args first (which may be reactive)
+ const res = arr[key](...args);
+ if (res === -1 || res === false) {
+ // if that didn't work, run it again using raw values.
+ return arr[key](...args.map(toRaw));
+ }
+ else {
+ return res;
+ }
+ };
+ });
+ ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
+ instrumentations[key] = function (...args) {
+ pauseTracking();
+ const res = toRaw(this)[key].apply(this, args);
+ resetTracking();
+ return res;
+ };
+ });
+ return instrumentations;
+ }
+ function createGetter(isReadonly = false, shallow = false) {
+ return function get(target, key, receiver) {
+ if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) {
+ return !isReadonly;
+ }
+ else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) {
+ return isReadonly;
+ }
+ else if (key === "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */) {
+ return shallow;
+ }
+ else if (key === "__v_raw" /* ReactiveFlags.RAW */ &&
+ receiver ===
+ (isReadonly
+ ? shallow
+ ? shallowReadonlyMap
+ : readonlyMap
+ : shallow
+ ? shallowReactiveMap
+ : reactiveMap).get(target)) {
+ return target;
+ }
+ const targetIsArray = isArray(target);
+ if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
+ return Reflect.get(arrayInstrumentations, key, receiver);
+ }
+ const res = Reflect.get(target, key, receiver);
+ if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+ return res;
+ }
+ if (!isReadonly) {
+ track(target, "get" /* TrackOpTypes.GET */, key);
+ }
+ if (shallow) {
+ return res;
+ }
+ if (isRef(res)) {
+ // ref unwrapping - skip unwrap for Array + integer key.
+ return targetIsArray && isIntegerKey(key) ? res : res.value;
+ }
+ if (isObject(res)) {
+ // Convert returned value into a proxy as well. we do the isObject check
+ // here to avoid invalid value warning. Also need to lazy access readonly
+ // and reactive here to avoid circular dependency.
+ return isReadonly ? readonly(res) : reactive(res);
+ }
+ return res;
+ };
+ }
+ const set = /*#__PURE__*/ createSetter();
+ const shallowSet = /*#__PURE__*/ createSetter(true);
+ function createSetter(shallow = false) {
+ return function set(target, key, value, receiver) {
+ let oldValue = target[key];
+ if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
+ return false;
+ }
+ if (!shallow) {
+ if (!isShallow(value) && !isReadonly(value)) {
+ oldValue = toRaw(oldValue);
+ value = toRaw(value);
+ }
+ if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
+ oldValue.value = value;
+ return true;
+ }
+ }
+ const hadKey = isArray(target) && isIntegerKey(key)
+ ? Number(key) < target.length
+ : hasOwn(target, key);
+ const result = Reflect.set(target, key, value, receiver);
+ // don't trigger if target is something up in the prototype chain of original
+ if (target === toRaw(receiver)) {
+ if (!hadKey) {
+ trigger(target, "add" /* TriggerOpTypes.ADD */, key, value);
+ }
+ else if (hasChanged(value, oldValue)) {
+ trigger(target, "set" /* TriggerOpTypes.SET */, key, value, oldValue);
+ }
+ }
+ return result;
+ };
+ }
+ function deleteProperty(target, key) {
+ const hadKey = hasOwn(target, key);
+ const oldValue = target[key];
+ const result = Reflect.deleteProperty(target, key);
+ if (result && hadKey) {
+ trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined, oldValue);
+ }
+ return result;
+ }
+ function has(target, key) {
+ const result = Reflect.has(target, key);
+ if (!isSymbol(key) || !builtInSymbols.has(key)) {
+ track(target, "has" /* TrackOpTypes.HAS */, key);
+ }
+ return result;
+ }
+ function ownKeys(target) {
+ track(target, "iterate" /* TrackOpTypes.ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);
+ return Reflect.ownKeys(target);
+ }
+ const mutableHandlers = {
+ get,
+ set,
+ deleteProperty,
+ has,
+ ownKeys
+ };
+ const readonlyHandlers = {
+ get: readonlyGet,
+ set(target, key) {
+ {
+ warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
+ }
+ return true;
+ },
+ deleteProperty(target, key) {
+ {
+ warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
+ }
+ return true;
+ }
+ };
+ const shallowReactiveHandlers = /*#__PURE__*/ extend({}, mutableHandlers, {
+ get: shallowGet,
+ set: shallowSet
+ });
+ // Props handlers are special in the sense that it should not unwrap top-level
+ // refs (in order to allow refs to be explicitly passed down), but should
+ // retain the reactivity of the normal readonly object.
+ const shallowReadonlyHandlers = /*#__PURE__*/ extend({}, readonlyHandlers, {
+ get: shallowReadonlyGet
+ });
+
+ const toShallow = (value) => value;
+ const getProto = (v) => Reflect.getPrototypeOf(v);
+ function get$1(target, key, isReadonly = false, isShallow = false) {
+ // #1772: readonly(reactive(Map)) should return readonly + reactive version
+ // of the value
+ target = target["__v_raw" /* ReactiveFlags.RAW */];
+ const rawTarget = toRaw(target);
+ const rawKey = toRaw(key);
+ if (!isReadonly) {
+ if (key !== rawKey) {
+ track(rawTarget, "get" /* TrackOpTypes.GET */, key);
+ }
+ track(rawTarget, "get" /* TrackOpTypes.GET */, rawKey);
+ }
+ const { has } = getProto(rawTarget);
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+ if (has.call(rawTarget, key)) {
+ return wrap(target.get(key));
+ }
+ else if (has.call(rawTarget, rawKey)) {
+ return wrap(target.get(rawKey));
+ }
+ else if (target !== rawTarget) {
+ // #3602 readonly(reactive(Map))
+ // ensure that the nested reactive `Map` can do tracking for itself
+ target.get(key);
+ }
+ }
+ function has$1(key, isReadonly = false) {
+ const target = this["__v_raw" /* ReactiveFlags.RAW */];
+ const rawTarget = toRaw(target);
+ const rawKey = toRaw(key);
+ if (!isReadonly) {
+ if (key !== rawKey) {
+ track(rawTarget, "has" /* TrackOpTypes.HAS */, key);
+ }
+ track(rawTarget, "has" /* TrackOpTypes.HAS */, rawKey);
+ }
+ return key === rawKey
+ ? target.has(key)
+ : target.has(key) || target.has(rawKey);
+ }
+ function size(target, isReadonly = false) {
+ target = target["__v_raw" /* ReactiveFlags.RAW */];
+ !isReadonly && track(toRaw(target), "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY);
+ return Reflect.get(target, 'size', target);
+ }
+ function add(value) {
+ value = toRaw(value);
+ const target = toRaw(this);
+ const proto = getProto(target);
+ const hadKey = proto.has.call(target, value);
+ if (!hadKey) {
+ target.add(value);
+ trigger(target, "add" /* TriggerOpTypes.ADD */, value, value);
+ }
+ return this;
+ }
+ function set$1(key, value) {
+ value = toRaw(value);
+ const target = toRaw(this);
+ const { has, get } = getProto(target);
+ let hadKey = has.call(target, key);
+ if (!hadKey) {
+ key = toRaw(key);
+ hadKey = has.call(target, key);
+ }
+ else {
+ checkIdentityKeys(target, has, key);
+ }
+ const oldValue = get.call(target, key);
+ target.set(key, value);
+ if (!hadKey) {
+ trigger(target, "add" /* TriggerOpTypes.ADD */, key, value);
+ }
+ else if (hasChanged(value, oldValue)) {
+ trigger(target, "set" /* TriggerOpTypes.SET */, key, value, oldValue);
+ }
+ return this;
+ }
+ function deleteEntry(key) {
+ const target = toRaw(this);
+ const { has, get } = getProto(target);
+ let hadKey = has.call(target, key);
+ if (!hadKey) {
+ key = toRaw(key);
+ hadKey = has.call(target, key);
+ }
+ else {
+ checkIdentityKeys(target, has, key);
+ }
+ const oldValue = get ? get.call(target, key) : undefined;
+ // forward the operation before queueing reactions
+ const result = target.delete(key);
+ if (hadKey) {
+ trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined, oldValue);
+ }
+ return result;
+ }
+ function clear() {
+ const target = toRaw(this);
+ const hadItems = target.size !== 0;
+ const oldTarget = isMap(target)
+ ? new Map(target)
+ : new Set(target)
+ ;
+ // forward the operation before queueing reactions
+ const result = target.clear();
+ if (hadItems) {
+ trigger(target, "clear" /* TriggerOpTypes.CLEAR */, undefined, undefined, oldTarget);
+ }
+ return result;
+ }
+ function createForEach(isReadonly, isShallow) {
+ return function forEach(callback, thisArg) {
+ const observed = this;
+ const target = observed["__v_raw" /* ReactiveFlags.RAW */];
+ const rawTarget = toRaw(target);
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+ !isReadonly && track(rawTarget, "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY);
+ return target.forEach((value, key) => {
+ // important: make sure the callback is
+ // 1. invoked with the reactive map as `this` and 3rd arg
+ // 2. the value received should be a corresponding reactive/readonly.
+ return callback.call(thisArg, wrap(value), wrap(key), observed);
+ });
+ };
+ }
+ function createIterableMethod(method, isReadonly, isShallow) {
+ return function (...args) {
+ const target = this["__v_raw" /* ReactiveFlags.RAW */];
+ const rawTarget = toRaw(target);
+ const targetIsMap = isMap(rawTarget);
+ const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
+ const isKeyOnly = method === 'keys' && targetIsMap;
+ const innerIterator = target[method](...args);
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+ !isReadonly &&
+ track(rawTarget, "iterate" /* TrackOpTypes.ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
+ // return a wrapped iterator which returns observed versions of the
+ // values emitted from the real iterator
+ return {
+ // iterator protocol
+ next() {
+ const { value, done } = innerIterator.next();
+ return done
+ ? { value, done }
+ : {
+ value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+ done
+ };
+ },
+ // iterable protocol
+ [Symbol.iterator]() {
+ return this;
+ }
+ };
+ };
+ }
+ function createReadonlyMethod(type) {
+ return function (...args) {
+ {
+ const key = args[0] ? `on key "${args[0]}" ` : ``;
+ console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
+ }
+ return type === "delete" /* TriggerOpTypes.DELETE */ ? false : this;
+ };
+ }
+ function createInstrumentations() {
+ const mutableInstrumentations = {
+ get(key) {
+ return get$1(this, key);
+ },
+ get size() {
+ return size(this);
+ },
+ has: has$1,
+ add,
+ set: set$1,
+ delete: deleteEntry,
+ clear,
+ forEach: createForEach(false, false)
+ };
+ const shallowInstrumentations = {
+ get(key) {
+ return get$1(this, key, false, true);
+ },
+ get size() {
+ return size(this);
+ },
+ has: has$1,
+ add,
+ set: set$1,
+ delete: deleteEntry,
+ clear,
+ forEach: createForEach(false, true)
+ };
+ const readonlyInstrumentations = {
+ get(key) {
+ return get$1(this, key, true);
+ },
+ get size() {
+ return size(this, true);
+ },
+ has(key) {
+ return has$1.call(this, key, true);
+ },
+ add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */),
+ set: createReadonlyMethod("set" /* TriggerOpTypes.SET */),
+ delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */),
+ clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */),
+ forEach: createForEach(true, false)
+ };
+ const shallowReadonlyInstrumentations = {
+ get(key) {
+ return get$1(this, key, true, true);
+ },
+ get size() {
+ return size(this, true);
+ },
+ has(key) {
+ return has$1.call(this, key, true);
+ },
+ add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */),
+ set: createReadonlyMethod("set" /* TriggerOpTypes.SET */),
+ delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */),
+ clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */),
+ forEach: createForEach(true, true)
+ };
+ const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
+ iteratorMethods.forEach(method => {
+ mutableInstrumentations[method] = createIterableMethod(method, false, false);
+ readonlyInstrumentations[method] = createIterableMethod(method, true, false);
+ shallowInstrumentations[method] = createIterableMethod(method, false, true);
+ shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
+ });
+ return [
+ mutableInstrumentations,
+ readonlyInstrumentations,
+ shallowInstrumentations,
+ shallowReadonlyInstrumentations
+ ];
+ }
+ const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/ createInstrumentations();
+ function createInstrumentationGetter(isReadonly, shallow) {
+ const instrumentations = shallow
+ ? isReadonly
+ ? shallowReadonlyInstrumentations
+ : shallowInstrumentations
+ : isReadonly
+ ? readonlyInstrumentations
+ : mutableInstrumentations;
+ return (target, key, receiver) => {
+ if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) {
+ return !isReadonly;
+ }
+ else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) {
+ return isReadonly;
+ }
+ else if (key === "__v_raw" /* ReactiveFlags.RAW */) {
+ return target;
+ }
+ return Reflect.get(hasOwn(instrumentations, key) && key in target
+ ? instrumentations
+ : target, key, receiver);
+ };
+ }
+ const mutableCollectionHandlers = {
+ get: /*#__PURE__*/ createInstrumentationGetter(false, false)
+ };
+ const shallowCollectionHandlers = {
+ get: /*#__PURE__*/ createInstrumentationGetter(false, true)
+ };
+ const readonlyCollectionHandlers = {
+ get: /*#__PURE__*/ createInstrumentationGetter(true, false)
+ };
+ const shallowReadonlyCollectionHandlers = {
+ get: /*#__PURE__*/ createInstrumentationGetter(true, true)
+ };
+ function checkIdentityKeys(target, has, key) {
+ const rawKey = toRaw(key);
+ if (rawKey !== key && has.call(target, rawKey)) {
+ const type = toRawType(target);
+ console.warn(`Reactive ${type} contains both the raw and reactive ` +
+ `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +
+ `which can lead to inconsistencies. ` +
+ `Avoid differentiating between the raw and reactive versions ` +
+ `of an object and only use the reactive version if possible.`);
+ }
+ }
+
+ const reactiveMap = new WeakMap();
+ const shallowReactiveMap = new WeakMap();
+ const readonlyMap = new WeakMap();
+ const shallowReadonlyMap = new WeakMap();
+ function targetTypeMap(rawType) {
+ switch (rawType) {
+ case 'Object':
+ case 'Array':
+ return 1 /* TargetType.COMMON */;
+ case 'Map':
+ case 'Set':
+ case 'WeakMap':
+ case 'WeakSet':
+ return 2 /* TargetType.COLLECTION */;
+ default:
+ return 0 /* TargetType.INVALID */;
+ }
+ }
+ function getTargetType(value) {
+ return value["__v_skip" /* ReactiveFlags.SKIP */] || !Object.isExtensible(value)
+ ? 0 /* TargetType.INVALID */
+ : targetTypeMap(toRawType(value));
+ }
+ function reactive(target) {
+ // if trying to observe a readonly proxy, return the readonly version.
+ if (isReadonly(target)) {
+ return target;
+ }
+ return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
+ }
+ /**
+ * Return a shallowly-reactive copy of the original object, where only the root
+ * level properties are reactive. It also does not auto-unwrap refs (even at the
+ * root level).
+ */
+ function shallowReactive(target) {
+ return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
+ }
+ /**
+ * Creates a readonly copy of the original object. Note the returned copy is not
+ * made reactive, but `readonly` can be called on an already reactive object.
+ */
+ function readonly(target) {
+ return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
+ }
+ /**
+ * Returns a reactive-copy of the original object, where only the root level
+ * properties are readonly, and does NOT unwrap refs nor recursively convert
+ * returned properties.
+ * This is used for creating the props proxy object for stateful components.
+ */
+ function shallowReadonly(target) {
+ return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
+ }
+ function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
+ if (!isObject(target)) {
+ {
+ console.warn(`value cannot be made reactive: ${String(target)}`);
+ }
+ return target;
+ }
+ // target is already a Proxy, return it.
+ // exception: calling readonly() on a reactive object
+ if (target["__v_raw" /* ReactiveFlags.RAW */] &&
+ !(isReadonly && target["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */])) {
+ return target;
+ }
+ // target already has corresponding Proxy
+ const existingProxy = proxyMap.get(target);
+ if (existingProxy) {
+ return existingProxy;
+ }
+ // only specific value types can be observed.
+ const targetType = getTargetType(target);
+ if (targetType === 0 /* TargetType.INVALID */) {
+ return target;
+ }
+ const proxy = new Proxy(target, targetType === 2 /* TargetType.COLLECTION */ ? collectionHandlers : baseHandlers);
+ proxyMap.set(target, proxy);
+ return proxy;
+ }
+ function isReactive(value) {
+ if (isReadonly(value)) {
+ return isReactive(value["__v_raw" /* ReactiveFlags.RAW */]);
+ }
+ return !!(value && value["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */]);
+ }
+ function isReadonly(value) {
+ return !!(value && value["__v_isReadonly" /* ReactiveFlags.IS_READONLY */]);
+ }
+ function isShallow(value) {
+ return !!(value && value["__v_isShallow" /* ReactiveFlags.IS_SHALLOW */]);
+ }
+ function isProxy(value) {
+ return isReactive(value) || isReadonly(value);
+ }
+ function toRaw(observed) {
+ const raw = observed && observed["__v_raw" /* ReactiveFlags.RAW */];
+ return raw ? toRaw(raw) : observed;
+ }
+ function markRaw(value) {
+ def(value, "__v_skip" /* ReactiveFlags.SKIP */, true);
+ return value;
+ }
+ const toReactive = (value) => isObject(value) ? reactive(value) : value;
+ const toReadonly = (value) => isObject(value) ? readonly(value) : value;
+
+ function trackRefValue(ref) {
+ if (shouldTrack && activeEffect) {
+ ref = toRaw(ref);
+ {
+ trackEffects(ref.dep || (ref.dep = createDep()), {
+ target: ref,
+ type: "get" /* TrackOpTypes.GET */,
+ key: 'value'
+ });
+ }
+ }
+ }
+ function triggerRefValue(ref, newVal) {
+ ref = toRaw(ref);
+ if (ref.dep) {
+ {
+ triggerEffects(ref.dep, {
+ target: ref,
+ type: "set" /* TriggerOpTypes.SET */,
+ key: 'value',
+ newValue: newVal
+ });
+ }
+ }
+ }
+ function isRef(r) {
+ return !!(r && r.__v_isRef === true);
+ }
+ function ref(value) {
+ return createRef(value, false);
+ }
+ function shallowRef(value) {
+ return createRef(value, true);
+ }
+ function createRef(rawValue, shallow) {
+ if (isRef(rawValue)) {
+ return rawValue;
+ }
+ return new RefImpl(rawValue, shallow);
+ }
+ class RefImpl {
+ constructor(value, __v_isShallow) {
+ this.__v_isShallow = __v_isShallow;
+ this.dep = undefined;
+ this.__v_isRef = true;
+ this._rawValue = __v_isShallow ? value : toRaw(value);
+ this._value = __v_isShallow ? value : toReactive(value);
+ }
+ get value() {
+ trackRefValue(this);
+ return this._value;
+ }
+ set value(newVal) {
+ const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
+ newVal = useDirectValue ? newVal : toRaw(newVal);
+ if (hasChanged(newVal, this._rawValue)) {
+ this._rawValue = newVal;
+ this._value = useDirectValue ? newVal : toReactive(newVal);
+ triggerRefValue(this, newVal);
+ }
+ }
+ }
+ function triggerRef(ref) {
+ triggerRefValue(ref, ref.value );
+ }
+ function unref(ref) {
+ return isRef(ref) ? ref.value : ref;
+ }
+ const shallowUnwrapHandlers = {
+ get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
+ set: (target, key, value, receiver) => {
+ const oldValue = target[key];
+ if (isRef(oldValue) && !isRef(value)) {
+ oldValue.value = value;
+ return true;
+ }
+ else {
+ return Reflect.set(target, key, value, receiver);
+ }
+ }
+ };
+ function proxyRefs(objectWithRefs) {
+ return isReactive(objectWithRefs)
+ ? objectWithRefs
+ : new Proxy(objectWithRefs, shallowUnwrapHandlers);
+ }
+ class CustomRefImpl {
+ constructor(factory) {
+ this.dep = undefined;
+ this.__v_isRef = true;
+ const { get, set } = factory(() => trackRefValue(this), () => triggerRefValue(this));
+ this._get = get;
+ this._set = set;
+ }
+ get value() {
+ return this._get();
+ }
+ set value(newVal) {
+ this._set(newVal);
+ }
+ }
+ function customRef(factory) {
+ return new CustomRefImpl(factory);
+ }
+ function toRefs(object) {
+ if (!isProxy(object)) {
+ console.warn(`toRefs() expects a reactive object but received a plain one.`);
+ }
+ const ret = isArray(object) ? new Array(object.length) : {};
+ for (const key in object) {
+ ret[key] = toRef(object, key);
+ }
+ return ret;
+ }
+ class ObjectRefImpl {
+ constructor(_object, _key, _defaultValue) {
+ this._object = _object;
+ this._key = _key;
+ this._defaultValue = _defaultValue;
+ this.__v_isRef = true;
+ }
+ get value() {
+ const val = this._object[this._key];
+ return val === undefined ? this._defaultValue : val;
+ }
+ set value(newVal) {
+ this._object[this._key] = newVal;
+ }
+ }
+ function toRef(object, key, defaultValue) {
+ const val = object[key];
+ return isRef(val)
+ ? val
+ : new ObjectRefImpl(object, key, defaultValue);
+ }
+
+ var _a;
+ class ComputedRefImpl {
+ constructor(getter, _setter, isReadonly, isSSR) {
+ this._setter = _setter;
+ this.dep = undefined;
+ this.__v_isRef = true;
+ this[_a] = false;
+ this._dirty = true;
+ this.effect = new ReactiveEffect(getter, () => {
+ if (!this._dirty) {
+ this._dirty = true;
+ triggerRefValue(this);
+ }
+ });
+ this.effect.computed = this;
+ this.effect.active = this._cacheable = !isSSR;
+ this["__v_isReadonly" /* ReactiveFlags.IS_READONLY */] = isReadonly;
+ }
+ get value() {
+ // the computed ref may get wrapped by other proxies e.g. readonly() #3376
+ const self = toRaw(this);
+ trackRefValue(self);
+ if (self._dirty || !self._cacheable) {
+ self._dirty = false;
+ self._value = self.effect.run();
+ }
+ return self._value;
+ }
+ set value(newValue) {
+ this._setter(newValue);
+ }
+ }
+ _a = "__v_isReadonly" /* ReactiveFlags.IS_READONLY */;
+ function computed(getterOrOptions, debugOptions, isSSR = false) {
+ let getter;
+ let setter;
+ const onlyGetter = isFunction(getterOrOptions);
+ if (onlyGetter) {
+ getter = getterOrOptions;
+ setter = () => {
+ console.warn('Write operation failed: computed value is readonly');
+ }
+ ;
+ }
+ else {
+ getter = getterOrOptions.get;
+ setter = getterOrOptions.set;
+ }
+ const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
+ if (debugOptions && !isSSR) {
+ cRef.effect.onTrack = debugOptions.onTrack;
+ cRef.effect.onTrigger = debugOptions.onTrigger;
+ }
+ return cRef;
+ }
+
+ const stack = [];
+ function pushWarningContext(vnode) {
+ stack.push(vnode);
+ }
+ function popWarningContext() {
+ stack.pop();
+ }
+ function warn$1(msg, ...args) {
+ // avoid props formatting or warn handler tracking deps that might be mutated
+ // during patch, leading to infinite recursion.
+ pauseTracking();
+ const instance = stack.length ? stack[stack.length - 1].component : null;
+ const appWarnHandler = instance && instance.appContext.config.warnHandler;
+ const trace = getComponentTrace();
+ if (appWarnHandler) {
+ callWithErrorHandling(appWarnHandler, instance, 11 /* ErrorCodes.APP_WARN_HANDLER */, [
+ msg + args.join(''),
+ instance && instance.proxy,
+ trace
+ .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)
+ .join('\n'),
+ trace
+ ]);
+ }
+ else {
+ const warnArgs = [`[Vue warn]: ${msg}`, ...args];
+ /* istanbul ignore if */
+ if (trace.length &&
+ // avoid spamming console during tests
+ !false) {
+ warnArgs.push(`\n`, ...formatTrace(trace));
+ }
+ console.warn(...warnArgs);
+ }
+ resetTracking();
+ }
+ function getComponentTrace() {
+ let currentVNode = stack[stack.length - 1];
+ if (!currentVNode) {
+ return [];
+ }
+ // we can't just use the stack because it will be incomplete during updates
+ // that did not start from the root. Re-construct the parent chain using
+ // instance parent pointers.
+ const normalizedStack = [];
+ while (currentVNode) {
+ const last = normalizedStack[0];
+ if (last && last.vnode === currentVNode) {
+ last.recurseCount++;
+ }
+ else {
+ normalizedStack.push({
+ vnode: currentVNode,
+ recurseCount: 0
+ });
+ }
+ const parentInstance = currentVNode.component && currentVNode.component.parent;
+ currentVNode = parentInstance && parentInstance.vnode;
+ }
+ return normalizedStack;
+ }
+ /* istanbul ignore next */
+ function formatTrace(trace) {
+ const logs = [];
+ trace.forEach((entry, i) => {
+ logs.push(...(i === 0 ? [] : [`\n`]), ...formatTraceEntry(entry));
+ });
+ return logs;
+ }
+ function formatTraceEntry({ vnode, recurseCount }) {
+ const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
+ const isRoot = vnode.component ? vnode.component.parent == null : false;
+ const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;
+ const close = `>` + postfix;
+ return vnode.props
+ ? [open, ...formatProps(vnode.props), close]
+ : [open + close];
+ }
+ /* istanbul ignore next */
+ function formatProps(props) {
+ const res = [];
+ const keys = Object.keys(props);
+ keys.slice(0, 3).forEach(key => {
+ res.push(...formatProp(key, props[key]));
+ });
+ if (keys.length > 3) {
+ res.push(` ...`);
+ }
+ return res;
+ }
+ /* istanbul ignore next */
+ function formatProp(key, value, raw) {
+ if (isString(value)) {
+ value = JSON.stringify(value);
+ return raw ? value : [`${key}=${value}`];
+ }
+ else if (typeof value === 'number' ||
+ typeof value === 'boolean' ||
+ value == null) {
+ return raw ? value : [`${key}=${value}`];
+ }
+ else if (isRef(value)) {
+ value = formatProp(key, toRaw(value.value), true);
+ return raw ? value : [`${key}=Ref<`, value, `>`];
+ }
+ else if (isFunction(value)) {
+ return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+ }
+ else {
+ value = toRaw(value);
+ return raw ? value : [`${key}=`, value];
+ }
+ }
+
+ const ErrorTypeStrings = {
+ ["sp" /* LifecycleHooks.SERVER_PREFETCH */]: 'serverPrefetch hook',
+ ["bc" /* LifecycleHooks.BEFORE_CREATE */]: 'beforeCreate hook',
+ ["c" /* LifecycleHooks.CREATED */]: 'created hook',
+ ["bm" /* LifecycleHooks.BEFORE_MOUNT */]: 'beforeMount hook',
+ ["m" /* LifecycleHooks.MOUNTED */]: 'mounted hook',
+ ["bu" /* LifecycleHooks.BEFORE_UPDATE */]: 'beforeUpdate hook',
+ ["u" /* LifecycleHooks.UPDATED */]: 'updated',
+ ["bum" /* LifecycleHooks.BEFORE_UNMOUNT */]: 'beforeUnmount hook',
+ ["um" /* LifecycleHooks.UNMOUNTED */]: 'unmounted hook',
+ ["a" /* LifecycleHooks.ACTIVATED */]: 'activated hook',
+ ["da" /* LifecycleHooks.DEACTIVATED */]: 'deactivated hook',
+ ["ec" /* LifecycleHooks.ERROR_CAPTURED */]: 'errorCaptured hook',
+ ["rtc" /* LifecycleHooks.RENDER_TRACKED */]: 'renderTracked hook',
+ ["rtg" /* LifecycleHooks.RENDER_TRIGGERED */]: 'renderTriggered hook',
+ [0 /* ErrorCodes.SETUP_FUNCTION */]: 'setup function',
+ [1 /* ErrorCodes.RENDER_FUNCTION */]: 'render function',
+ [2 /* ErrorCodes.WATCH_GETTER */]: 'watcher getter',
+ [3 /* ErrorCodes.WATCH_CALLBACK */]: 'watcher callback',
+ [4 /* ErrorCodes.WATCH_CLEANUP */]: 'watcher cleanup function',
+ [5 /* ErrorCodes.NATIVE_EVENT_HANDLER */]: 'native event handler',
+ [6 /* ErrorCodes.COMPONENT_EVENT_HANDLER */]: 'component event handler',
+ [7 /* ErrorCodes.VNODE_HOOK */]: 'vnode hook',
+ [8 /* ErrorCodes.DIRECTIVE_HOOK */]: 'directive hook',
+ [9 /* ErrorCodes.TRANSITION_HOOK */]: 'transition hook',
+ [10 /* ErrorCodes.APP_ERROR_HANDLER */]: 'app errorHandler',
+ [11 /* ErrorCodes.APP_WARN_HANDLER */]: 'app warnHandler',
+ [12 /* ErrorCodes.FUNCTION_REF */]: 'ref function',
+ [13 /* ErrorCodes.ASYNC_COMPONENT_LOADER */]: 'async component loader',
+ [14 /* ErrorCodes.SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +
+ 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core'
+ };
+ function callWithErrorHandling(fn, instance, type, args) {
+ let res;
+ try {
+ res = args ? fn(...args) : fn();
+ }
+ catch (err) {
+ handleError(err, instance, type);
+ }
+ return res;
+ }
+ function callWithAsyncErrorHandling(fn, instance, type, args) {
+ if (isFunction(fn)) {
+ const res = callWithErrorHandling(fn, instance, type, args);
+ if (res && isPromise(res)) {
+ res.catch(err => {
+ handleError(err, instance, type);
+ });
+ }
+ return res;
+ }
+ const values = [];
+ for (let i = 0; i < fn.length; i++) {
+ values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
+ }
+ return values;
+ }
+ function handleError(err, instance, type, throwInDev = true) {
+ const contextVNode = instance ? instance.vnode : null;
+ if (instance) {
+ let cur = instance.parent;
+ // the exposed instance is the render proxy to keep it consistent with 2.x
+ const exposedInstance = instance.proxy;
+ // in production the hook receives only the error code
+ const errorInfo = ErrorTypeStrings[type] ;
+ while (cur) {
+ const errorCapturedHooks = cur.ec;
+ if (errorCapturedHooks) {
+ for (let i = 0; i < errorCapturedHooks.length; i++) {
+ if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
+ return;
+ }
+ }
+ }
+ cur = cur.parent;
+ }
+ // app-level handling
+ const appErrorHandler = instance.appContext.config.errorHandler;
+ if (appErrorHandler) {
+ callWithErrorHandling(appErrorHandler, null, 10 /* ErrorCodes.APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);
+ return;
+ }
+ }
+ logError(err, type, contextVNode, throwInDev);
+ }
+ function logError(err, type, contextVNode, throwInDev = true) {
+ {
+ const info = ErrorTypeStrings[type];
+ if (contextVNode) {
+ pushWarningContext(contextVNode);
+ }
+ warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+ if (contextVNode) {
+ popWarningContext();
+ }
+ // crash in dev by default so it's more noticeable
+ if (throwInDev) {
+ throw err;
+ }
+ else {
+ console.error(err);
+ }
+ }
+ }
+
+ let isFlushing = false;
+ let isFlushPending = false;
+ const queue = [];
+ let flushIndex = 0;
+ const pendingPostFlushCbs = [];
+ let activePostFlushCbs = null;
+ let postFlushIndex = 0;
+ const resolvedPromise = /*#__PURE__*/ Promise.resolve();
+ let currentFlushPromise = null;
+ const RECURSION_LIMIT = 100;
+ function nextTick(fn) {
+ const p = currentFlushPromise || resolvedPromise;
+ return fn ? p.then(this ? fn.bind(this) : fn) : p;
+ }
+ // #2768
+ // Use binary-search to find a suitable position in the queue,
+ // so that the queue maintains the increasing order of job's id,
+ // which can prevent the job from being skipped and also can avoid repeated patching.
+ function findInsertionIndex(id) {
+ // the start index should be `flushIndex + 1`
+ let start = flushIndex + 1;
+ let end = queue.length;
+ while (start < end) {
+ const middle = (start + end) >>> 1;
+ const middleJobId = getId(queue[middle]);
+ middleJobId < id ? (start = middle + 1) : (end = middle);
+ }
+ return start;
+ }
+ function queueJob(job) {
+ // the dedupe search uses the startIndex argument of Array.includes()
+ // by default the search index includes the current job that is being run
+ // so it cannot recursively trigger itself again.
+ // if the job is a watch() callback, the search will start with a +1 index to
+ // allow it recursively trigger itself - it is the user's responsibility to
+ // ensure it doesn't end up in an infinite loop.
+ if (!queue.length ||
+ !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) {
+ if (job.id == null) {
+ queue.push(job);
+ }
+ else {
+ queue.splice(findInsertionIndex(job.id), 0, job);
+ }
+ queueFlush();
+ }
+ }
+ function queueFlush() {
+ if (!isFlushing && !isFlushPending) {
+ isFlushPending = true;
+ currentFlushPromise = resolvedPromise.then(flushJobs);
+ }
+ }
+ function invalidateJob(job) {
+ const i = queue.indexOf(job);
+ if (i > flushIndex) {
+ queue.splice(i, 1);
+ }
+ }
+ function queuePostFlushCb(cb) {
+ if (!isArray(cb)) {
+ if (!activePostFlushCbs ||
+ !activePostFlushCbs.includes(cb, cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex)) {
+ pendingPostFlushCbs.push(cb);
+ }
+ }
+ else {
+ // if cb is an array, it is a component lifecycle hook which can only be
+ // triggered by a job, which is already deduped in the main queue, so
+ // we can skip duplicate check here to improve perf
+ pendingPostFlushCbs.push(...cb);
+ }
+ queueFlush();
+ }
+ function flushPreFlushCbs(seen,
+ // if currently flushing, skip the current job itself
+ i = isFlushing ? flushIndex + 1 : 0) {
+ {
+ seen = seen || new Map();
+ }
+ for (; i < queue.length; i++) {
+ const cb = queue[i];
+ if (cb && cb.pre) {
+ if (checkRecursiveUpdates(seen, cb)) {
+ continue;
+ }
+ queue.splice(i, 1);
+ i--;
+ cb();
+ }
+ }
+ }
+ function flushPostFlushCbs(seen) {
+ if (pendingPostFlushCbs.length) {
+ const deduped = [...new Set(pendingPostFlushCbs)];
+ pendingPostFlushCbs.length = 0;
+ // #1947 already has active queue, nested flushPostFlushCbs call
+ if (activePostFlushCbs) {
+ activePostFlushCbs.push(...deduped);
+ return;
+ }
+ activePostFlushCbs = deduped;
+ {
+ seen = seen || new Map();
+ }
+ activePostFlushCbs.sort((a, b) => getId(a) - getId(b));
+ for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
+ if (checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) {
+ continue;
+ }
+ activePostFlushCbs[postFlushIndex]();
+ }
+ activePostFlushCbs = null;
+ postFlushIndex = 0;
+ }
+ }
+ const getId = (job) => job.id == null ? Infinity : job.id;
+ const comparator = (a, b) => {
+ const diff = getId(a) - getId(b);
+ if (diff === 0) {
+ if (a.pre && !b.pre)
+ return -1;
+ if (b.pre && !a.pre)
+ return 1;
+ }
+ return diff;
+ };
+ function flushJobs(seen) {
+ isFlushPending = false;
+ isFlushing = true;
+ {
+ seen = seen || new Map();
+ }
+ // Sort queue before flush.
+ // This ensures that:
+ // 1. Components are updated from parent to child. (because parent is always
+ // created before the child so its render effect will have smaller
+ // priority number)
+ // 2. If a component is unmounted during a parent component's update,
+ // its update can be skipped.
+ queue.sort(comparator);
+ // conditional usage of checkRecursiveUpdate must be determined out of
+ // try ... catch block since Rollup by default de-optimizes treeshaking
+ // inside try-catch. This can leave all warning code unshaked. Although
+ // they would get eventually shaken by a minifier like terser, some minifiers
+ // would fail to do that (e.g. https://github.com/evanw/esbuild/issues/1610)
+ const check = (job) => checkRecursiveUpdates(seen, job)
+ ;
+ try {
+ for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
+ const job = queue[flushIndex];
+ if (job && job.active !== false) {
+ if (true && check(job)) {
+ continue;
+ }
+ // console.log(`running:`, job.id)
+ callWithErrorHandling(job, null, 14 /* ErrorCodes.SCHEDULER */);
+ }
+ }
+ }
+ finally {
+ flushIndex = 0;
+ queue.length = 0;
+ flushPostFlushCbs(seen);
+ isFlushing = false;
+ currentFlushPromise = null;
+ // some postFlushCb queued jobs!
+ // keep flushing until it drains.
+ if (queue.length || pendingPostFlushCbs.length) {
+ flushJobs(seen);
+ }
+ }
+ }
+ function checkRecursiveUpdates(seen, fn) {
+ if (!seen.has(fn)) {
+ seen.set(fn, 1);
+ }
+ else {
+ const count = seen.get(fn);
+ if (count > RECURSION_LIMIT) {
+ const instance = fn.ownerInstance;
+ const componentName = instance && getComponentName(instance.type);
+ warn$1(`Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. ` +
+ `This means you have a reactive effect that is mutating its own ` +
+ `dependencies and thus recursively triggering itself. Possible sources ` +
+ `include component template, render function, updated hook or ` +
+ `watcher source function.`);
+ return true;
+ }
+ else {
+ seen.set(fn, count + 1);
+ }
+ }
+ }
+
+ /* eslint-disable no-restricted-globals */
+ let isHmrUpdating = false;
+ const hmrDirtyComponents = new Set();
+ // Expose the HMR runtime on the global object
+ // This makes it entirely tree-shakable without polluting the exports and makes
+ // it easier to be used in toolings like vue-loader
+ // Note: for a component to be eligible for HMR it also needs the __hmrId option
+ // to be set so that its instances can be registered / removed.
+ {
+ getGlobalThis().__VUE_HMR_RUNTIME__ = {
+ createRecord: tryWrap(createRecord),
+ rerender: tryWrap(rerender),
+ reload: tryWrap(reload)
+ };
+ }
+ const map = new Map();
+ function registerHMR(instance) {
+ const id = instance.type.__hmrId;
+ let record = map.get(id);
+ if (!record) {
+ createRecord(id, instance.type);
+ record = map.get(id);
+ }
+ record.instances.add(instance);
+ }
+ function unregisterHMR(instance) {
+ map.get(instance.type.__hmrId).instances.delete(instance);
+ }
+ function createRecord(id, initialDef) {
+ if (map.has(id)) {
+ return false;
+ }
+ map.set(id, {
+ initialDef: normalizeClassComponent(initialDef),
+ instances: new Set()
+ });
+ return true;
+ }
+ function normalizeClassComponent(component) {
+ return isClassComponent(component) ? component.__vccOpts : component;
+ }
+ function rerender(id, newRender) {
+ const record = map.get(id);
+ if (!record) {
+ return;
+ }
+ // update initial record (for not-yet-rendered component)
+ record.initialDef.render = newRender;
+ [...record.instances].forEach(instance => {
+ if (newRender) {
+ instance.render = newRender;
+ normalizeClassComponent(instance.type).render = newRender;
+ }
+ instance.renderCache = [];
+ // this flag forces child components with slot content to update
+ isHmrUpdating = true;
+ instance.update();
+ isHmrUpdating = false;
+ });
+ }
+ function reload(id, newComp) {
+ const record = map.get(id);
+ if (!record)
+ return;
+ newComp = normalizeClassComponent(newComp);
+ // update initial def (for not-yet-rendered components)
+ updateComponentDef(record.initialDef, newComp);
+ // create a snapshot which avoids the set being mutated during updates
+ const instances = [...record.instances];
+ for (const instance of instances) {
+ const oldComp = normalizeClassComponent(instance.type);
+ if (!hmrDirtyComponents.has(oldComp)) {
+ // 1. Update existing comp definition to match new one
+ if (oldComp !== record.initialDef) {
+ updateComponentDef(oldComp, newComp);
+ }
+ // 2. mark definition dirty. This forces the renderer to replace the
+ // component on patch.
+ hmrDirtyComponents.add(oldComp);
+ }
+ // 3. invalidate options resolution cache
+ instance.appContext.optionsCache.delete(instance.type);
+ // 4. actually update
+ if (instance.ceReload) {
+ // custom element
+ hmrDirtyComponents.add(oldComp);
+ instance.ceReload(newComp.styles);
+ hmrDirtyComponents.delete(oldComp);
+ }
+ else if (instance.parent) {
+ // 4. Force the parent instance to re-render. This will cause all updated
+ // components to be unmounted and re-mounted. Queue the update so that we
+ // don't end up forcing the same parent to re-render multiple times.
+ queueJob(instance.parent.update);
+ }
+ else if (instance.appContext.reload) {
+ // root instance mounted via createApp() has a reload method
+ instance.appContext.reload();
+ }
+ else if (typeof window !== 'undefined') {
+ // root instance inside tree created via raw render(). Force reload.
+ window.location.reload();
+ }
+ else {
+ console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');
+ }
+ }
+ // 5. make sure to cleanup dirty hmr components after update
+ queuePostFlushCb(() => {
+ for (const instance of instances) {
+ hmrDirtyComponents.delete(normalizeClassComponent(instance.type));
+ }
+ });
+ }
+ function updateComponentDef(oldComp, newComp) {
+ extend(oldComp, newComp);
+ for (const key in oldComp) {
+ if (key !== '__file' && !(key in newComp)) {
+ delete oldComp[key];
+ }
+ }
+ }
+ function tryWrap(fn) {
+ return (id, arg) => {
+ try {
+ return fn(id, arg);
+ }
+ catch (e) {
+ console.error(e);
+ console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +
+ `Full reload required.`);
+ }
+ };
+ }
+
+ let buffer = [];
+ let devtoolsNotInstalled = false;
+ function emit(event, ...args) {
+ if (exports.devtools) {
+ exports.devtools.emit(event, ...args);
+ }
+ else if (!devtoolsNotInstalled) {
+ buffer.push({ event, args });
+ }
+ }
+ function setDevtoolsHook(hook, target) {
+ var _a, _b;
+ exports.devtools = hook;
+ if (exports.devtools) {
+ exports.devtools.enabled = true;
+ buffer.forEach(({ event, args }) => exports.devtools.emit(event, ...args));
+ buffer = [];
+ }
+ else if (
+ // handle late devtools injection - only do this if we are in an actual
+ // browser environment to avoid the timer handle stalling test runner exit
+ // (#4815)
+ typeof window !== 'undefined' &&
+ // some envs mock window but not fully
+ window.HTMLElement &&
+ // also exclude jsdom
+ !((_b = (_a = window.navigator) === null || _a === void 0 ? void 0 : _a.userAgent) === null || _b === void 0 ? void 0 : _b.includes('jsdom'))) {
+ const replay = (target.__VUE_DEVTOOLS_HOOK_REPLAY__ =
+ target.__VUE_DEVTOOLS_HOOK_REPLAY__ || []);
+ replay.push((newHook) => {
+ setDevtoolsHook(newHook, target);
+ });
+ // clear buffer after 3s - the user probably doesn't have devtools installed
+ // at all, and keeping the buffer will cause memory leaks (#4738)
+ setTimeout(() => {
+ if (!exports.devtools) {
+ target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
+ devtoolsNotInstalled = true;
+ buffer = [];
+ }
+ }, 3000);
+ }
+ else {
+ // non-browser env, assume not installed
+ devtoolsNotInstalled = true;
+ buffer = [];
+ }
+ }
+ function devtoolsInitApp(app, version) {
+ emit("app:init" /* DevtoolsHooks.APP_INIT */, app, version, {
+ Fragment,
+ Text,
+ Comment,
+ Static
+ });
+ }
+ function devtoolsUnmountApp(app) {
+ emit("app:unmount" /* DevtoolsHooks.APP_UNMOUNT */, app);
+ }
+ const devtoolsComponentAdded = /*#__PURE__*/ createDevtoolsComponentHook("component:added" /* DevtoolsHooks.COMPONENT_ADDED */);
+ const devtoolsComponentUpdated =
+ /*#__PURE__*/ createDevtoolsComponentHook("component:updated" /* DevtoolsHooks.COMPONENT_UPDATED */);
+ const _devtoolsComponentRemoved = /*#__PURE__*/ createDevtoolsComponentHook("component:removed" /* DevtoolsHooks.COMPONENT_REMOVED */);
+ const devtoolsComponentRemoved = (component) => {
+ if (exports.devtools &&
+ typeof exports.devtools.cleanupBuffer === 'function' &&
+ // remove the component if it wasn't buffered
+ !exports.devtools.cleanupBuffer(component)) {
+ _devtoolsComponentRemoved(component);
+ }
+ };
+ function createDevtoolsComponentHook(hook) {
+ return (component) => {
+ emit(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : undefined, component);
+ };
+ }
+ const devtoolsPerfStart = /*#__PURE__*/ createDevtoolsPerformanceHook("perf:start" /* DevtoolsHooks.PERFORMANCE_START */);
+ const devtoolsPerfEnd = /*#__PURE__*/ createDevtoolsPerformanceHook("perf:end" /* DevtoolsHooks.PERFORMANCE_END */);
+ function createDevtoolsPerformanceHook(hook) {
+ return (component, type, time) => {
+ emit(hook, component.appContext.app, component.uid, component, type, time);
+ };
+ }
+ function devtoolsComponentEmit(component, event, params) {
+ emit("component:emit" /* DevtoolsHooks.COMPONENT_EMIT */, component.appContext.app, component, event, params);
+ }
+
+ function emit$1(instance, event, ...rawArgs) {
+ if (instance.isUnmounted)
+ return;
+ const props = instance.vnode.props || EMPTY_OBJ;
+ {
+ const { emitsOptions, propsOptions: [propsOptions] } = instance;
+ if (emitsOptions) {
+ if (!(event in emitsOptions) &&
+ !(false )) {
+ if (!propsOptions || !(toHandlerKey(event) in propsOptions)) {
+ warn$1(`Component emitted event "${event}" but it is neither declared in ` +
+ `the emits option nor as an "${toHandlerKey(event)}" prop.`);
+ }
+ }
+ else {
+ const validator = emitsOptions[event];
+ if (isFunction(validator)) {
+ const isValid = validator(...rawArgs);
+ if (!isValid) {
+ warn$1(`Invalid event arguments: event validation failed for event "${event}".`);
+ }
+ }
+ }
+ }
+ }
+ let args = rawArgs;
+ const isModelListener = event.startsWith('update:');
+ // for v-model update:xxx events, apply modifiers on args
+ const modelArg = isModelListener && event.slice(7);
+ if (modelArg && modelArg in props) {
+ const modifiersKey = `${modelArg === 'modelValue' ? 'model' : modelArg}Modifiers`;
+ const { number, trim } = props[modifiersKey] || EMPTY_OBJ;
+ if (trim) {
+ args = rawArgs.map(a => (isString(a) ? a.trim() : a));
+ }
+ if (number) {
+ args = rawArgs.map(toNumber);
+ }
+ }
+ {
+ devtoolsComponentEmit(instance, event, args);
+ }
+ {
+ const lowerCaseEvent = event.toLowerCase();
+ if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) {
+ warn$1(`Event "${lowerCaseEvent}" is emitted in component ` +
+ `${formatComponentName(instance, instance.type)} but the handler is registered for "${event}". ` +
+ `Note that HTML attributes are case-insensitive and you cannot use ` +
+ `v-on to listen to camelCase events when using in-DOM templates. ` +
+ `You should probably use "${hyphenate(event)}" instead of "${event}".`);
+ }
+ }
+ let handlerName;
+ let handler = props[(handlerName = toHandlerKey(event))] ||
+ // also try camelCase event handler (#2249)
+ props[(handlerName = toHandlerKey(camelize(event)))];
+ // for v-model update:xxx events, also trigger kebab-case equivalent
+ // for props passed via kebab-case
+ if (!handler && isModelListener) {
+ handler = props[(handlerName = toHandlerKey(hyphenate(event)))];
+ }
+ if (handler) {
+ callWithAsyncErrorHandling(handler, instance, 6 /* ErrorCodes.COMPONENT_EVENT_HANDLER */, args);
+ }
+ const onceHandler = props[handlerName + `Once`];
+ if (onceHandler) {
+ if (!instance.emitted) {
+ instance.emitted = {};
+ }
+ else if (instance.emitted[handlerName]) {
+ return;
+ }
+ instance.emitted[handlerName] = true;
+ callWithAsyncErrorHandling(onceHandler, instance, 6 /* ErrorCodes.COMPONENT_EVENT_HANDLER */, args);
+ }
+ }
+ function normalizeEmitsOptions(comp, appContext, asMixin = false) {
+ const cache = appContext.emitsCache;
+ const cached = cache.get(comp);
+ if (cached !== undefined) {
+ return cached;
+ }
+ const raw = comp.emits;
+ let normalized = {};
+ // apply mixin/extends props
+ let hasExtends = false;
+ if (!isFunction(comp)) {
+ const extendEmits = (raw) => {
+ const normalizedFromExtend = normalizeEmitsOptions(raw, appContext, true);
+ if (normalizedFromExtend) {
+ hasExtends = true;
+ extend(normalized, normalizedFromExtend);
+ }
+ };
+ if (!asMixin && appContext.mixins.length) {
+ appContext.mixins.forEach(extendEmits);
+ }
+ if (comp.extends) {
+ extendEmits(comp.extends);
+ }
+ if (comp.mixins) {
+ comp.mixins.forEach(extendEmits);
+ }
+ }
+ if (!raw && !hasExtends) {
+ if (isObject(comp)) {
+ cache.set(comp, null);
+ }
+ return null;
+ }
+ if (isArray(raw)) {
+ raw.forEach(key => (normalized[key] = null));
+ }
+ else {
+ extend(normalized, raw);
+ }
+ if (isObject(comp)) {
+ cache.set(comp, normalized);
+ }
+ return normalized;
+ }
+ // Check if an incoming prop key is a declared emit event listener.
+ // e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are
+ // both considered matched listeners.
+ function isEmitListener(options, key) {
+ if (!options || !isOn(key)) {
+ return false;
+ }
+ key = key.slice(2).replace(/Once$/, '');
+ return (hasOwn(options, key[0].toLowerCase() + key.slice(1)) ||
+ hasOwn(options, hyphenate(key)) ||
+ hasOwn(options, key));
+ }
+
+ /**
+ * mark the current rendering instance for asset resolution (e.g.
+ * resolveComponent, resolveDirective) during render
+ */
+ let currentRenderingInstance = null;
+ let currentScopeId = null;
+ /**
+ * Note: rendering calls maybe nested. The function returns the parent rendering
+ * instance if present, which should be restored after the render is done:
+ *
+ * ```js
+ * const prev = setCurrentRenderingInstance(i)
+ * // ...render
+ * setCurrentRenderingInstance(prev)
+ * ```
+ */
+ function setCurrentRenderingInstance(instance) {
+ const prev = currentRenderingInstance;
+ currentRenderingInstance = instance;
+ currentScopeId = (instance && instance.type.__scopeId) || null;
+ return prev;
+ }
+ /**
+ * Set scope id when creating hoisted vnodes.
+ * @private compiler helper
+ */
+ function pushScopeId(id) {
+ currentScopeId = id;
+ }
+ /**
+ * Technically we no longer need this after 3.0.8 but we need to keep the same
+ * API for backwards compat w/ code generated by compilers.
+ * @private
+ */
+ function popScopeId() {
+ currentScopeId = null;
+ }
+ /**
+ * Only for backwards compat
+ * @private
+ */
+ const withScopeId = (_id) => withCtx;
+ /**
+ * Wrap a slot function to memoize current rendering instance
+ * @private compiler helper
+ */
+ function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot // false only
+ ) {
+ if (!ctx)
+ return fn;
+ // already normalized
+ if (fn._n) {
+ return fn;
+ }
+ const renderFnWithContext = (...args) => {
+ // If a user calls a compiled slot inside a template expression (#1745), it
+ // can mess up block tracking, so by default we disable block tracking and
+ // force bail out when invoking a compiled slot (indicated by the ._d flag).
+ // This isn't necessary if rendering a compiled ``, so we flip the
+ // ._d flag off when invoking the wrapped fn inside `renderSlot`.
+ if (renderFnWithContext._d) {
+ setBlockTracking(-1);
+ }
+ const prevInstance = setCurrentRenderingInstance(ctx);
+ let res;
+ try {
+ res = fn(...args);
+ }
+ finally {
+ setCurrentRenderingInstance(prevInstance);
+ if (renderFnWithContext._d) {
+ setBlockTracking(1);
+ }
+ }
+ {
+ devtoolsComponentUpdated(ctx);
+ }
+ return res;
+ };
+ // mark normalized to avoid duplicated wrapping
+ renderFnWithContext._n = true;
+ // mark this as compiled by default
+ // this is used in vnode.ts -> normalizeChildren() to set the slot
+ // rendering flag.
+ renderFnWithContext._c = true;
+ // disable block tracking by default
+ renderFnWithContext._d = true;
+ return renderFnWithContext;
+ }
+
+ /**
+ * dev only flag to track whether $attrs was used during render.
+ * If $attrs was used during render then the warning for failed attrs
+ * fallthrough can be suppressed.
+ */
+ let accessedAttrs = false;
+ function markAttrsAccessed() {
+ accessedAttrs = true;
+ }
+ function renderComponentRoot(instance) {
+ const { type: Component, vnode, proxy, withProxy, props, propsOptions: [propsOptions], slots, attrs, emit, render, renderCache, data, setupState, ctx, inheritAttrs } = instance;
+ let result;
+ let fallthroughAttrs;
+ const prev = setCurrentRenderingInstance(instance);
+ {
+ accessedAttrs = false;
+ }
+ try {
+ if (vnode.shapeFlag & 4 /* ShapeFlags.STATEFUL_COMPONENT */) {
+ // withProxy is a proxy with a different `has` trap only for
+ // runtime-compiled render functions using `with` block.
+ const proxyToUse = withProxy || proxy;
+ result = normalizeVNode(render.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx));
+ fallthroughAttrs = attrs;
+ }
+ else {
+ // functional
+ const render = Component;
+ // in dev, mark attrs accessed if optional props (attrs === props)
+ if (true && attrs === props) {
+ markAttrsAccessed();
+ }
+ result = normalizeVNode(render.length > 1
+ ? render(props, true
+ ? {
+ get attrs() {
+ markAttrsAccessed();
+ return attrs;
+ },
+ slots,
+ emit
+ }
+ : { attrs, slots, emit })
+ : render(props, null /* we know it doesn't need it */));
+ fallthroughAttrs = Component.props
+ ? attrs
+ : getFunctionalFallthrough(attrs);
+ }
+ }
+ catch (err) {
+ blockStack.length = 0;
+ handleError(err, instance, 1 /* ErrorCodes.RENDER_FUNCTION */);
+ result = createVNode(Comment);
+ }
+ // attr merging
+ // in dev mode, comments are preserved, and it's possible for a template
+ // to have comments along side the root element which makes it a fragment
+ let root = result;
+ let setRoot = undefined;
+ if (result.patchFlag > 0 &&
+ result.patchFlag & 2048 /* PatchFlags.DEV_ROOT_FRAGMENT */) {
+ [root, setRoot] = getChildRoot(result);
+ }
+ if (fallthroughAttrs && inheritAttrs !== false) {
+ const keys = Object.keys(fallthroughAttrs);
+ const { shapeFlag } = root;
+ if (keys.length) {
+ if (shapeFlag & (1 /* ShapeFlags.ELEMENT */ | 6 /* ShapeFlags.COMPONENT */)) {
+ if (propsOptions && keys.some(isModelListener)) {
+ // If a v-model listener (onUpdate:xxx) has a corresponding declared
+ // prop, it indicates this component expects to handle v-model and
+ // it should not fallthrough.
+ // related: #1543, #1643, #1989
+ fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions);
+ }
+ root = cloneVNode(root, fallthroughAttrs);
+ }
+ else if (!accessedAttrs && root.type !== Comment) {
+ const allAttrs = Object.keys(attrs);
+ const eventAttrs = [];
+ const extraAttrs = [];
+ for (let i = 0, l = allAttrs.length; i < l; i++) {
+ const key = allAttrs[i];
+ if (isOn(key)) {
+ // ignore v-model handlers when they fail to fallthrough
+ if (!isModelListener(key)) {
+ // remove `on`, lowercase first letter to reflect event casing
+ // accurately
+ eventAttrs.push(key[2].toLowerCase() + key.slice(3));
+ }
+ }
+ else {
+ extraAttrs.push(key);
+ }
+ }
+ if (extraAttrs.length) {
+ warn$1(`Extraneous non-props attributes (` +
+ `${extraAttrs.join(', ')}) ` +
+ `were passed to component but could not be automatically inherited ` +
+ `because component renders fragment or text root nodes.`);
+ }
+ if (eventAttrs.length) {
+ warn$1(`Extraneous non-emits event listeners (` +
+ `${eventAttrs.join(', ')}) ` +
+ `were passed to component but could not be automatically inherited ` +
+ `because component renders fragment or text root nodes. ` +
+ `If the listener is intended to be a component custom event listener only, ` +
+ `declare it using the "emits" option.`);
+ }
+ }
+ }
+ }
+ // inherit directives
+ if (vnode.dirs) {
+ if (!isElementRoot(root)) {
+ warn$1(`Runtime directive used on component with non-element root node. ` +
+ `The directives will not function as intended.`);
+ }
+ // clone before mutating since the root may be a hoisted vnode
+ root = cloneVNode(root);
+ root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
+ }
+ // inherit transition data
+ if (vnode.transition) {
+ if (!isElementRoot(root)) {
+ warn$1(`Component inside renders non-element root node ` +
+ `that cannot be animated.`);
+ }
+ root.transition = vnode.transition;
+ }
+ if (setRoot) {
+ setRoot(root);
+ }
+ else {
+ result = root;
+ }
+ setCurrentRenderingInstance(prev);
+ return result;
+ }
+ /**
+ * dev only
+ * In dev mode, template root level comments are rendered, which turns the
+ * template into a fragment root, but we need to locate the single element
+ * root for attrs and scope id processing.
+ */
+ const getChildRoot = (vnode) => {
+ const rawChildren = vnode.children;
+ const dynamicChildren = vnode.dynamicChildren;
+ const childRoot = filterSingleRoot(rawChildren);
+ if (!childRoot) {
+ return [vnode, undefined];
+ }
+ const index = rawChildren.indexOf(childRoot);
+ const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;
+ const setRoot = (updatedRoot) => {
+ rawChildren[index] = updatedRoot;
+ if (dynamicChildren) {
+ if (dynamicIndex > -1) {
+ dynamicChildren[dynamicIndex] = updatedRoot;
+ }
+ else if (updatedRoot.patchFlag > 0) {
+ vnode.dynamicChildren = [...dynamicChildren, updatedRoot];
+ }
+ }
+ };
+ return [normalizeVNode(childRoot), setRoot];
+ };
+ function filterSingleRoot(children) {
+ let singleRoot;
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ if (isVNode(child)) {
+ // ignore user comment
+ if (child.type !== Comment || child.children === 'v-if') {
+ if (singleRoot) {
+ // has more than 1 non-comment child, return now
+ return;
+ }
+ else {
+ singleRoot = child;
+ }
+ }
+ }
+ else {
+ return;
+ }
+ }
+ return singleRoot;
+ }
+ const getFunctionalFallthrough = (attrs) => {
+ let res;
+ for (const key in attrs) {
+ if (key === 'class' || key === 'style' || isOn(key)) {
+ (res || (res = {}))[key] = attrs[key];
+ }
+ }
+ return res;
+ };
+ const filterModelListeners = (attrs, props) => {
+ const res = {};
+ for (const key in attrs) {
+ if (!isModelListener(key) || !(key.slice(9) in props)) {
+ res[key] = attrs[key];
+ }
+ }
+ return res;
+ };
+ const isElementRoot = (vnode) => {
+ return (vnode.shapeFlag & (6 /* ShapeFlags.COMPONENT */ | 1 /* ShapeFlags.ELEMENT */) ||
+ vnode.type === Comment // potential v-if branch switch
+ );
+ };
+ function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
+ const { props: prevProps, children: prevChildren, component } = prevVNode;
+ const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
+ const emits = component.emitsOptions;
+ // Parent component's render function was hot-updated. Since this may have
+ // caused the child component's slots content to have changed, we need to
+ // force the child to update as well.
+ if ((prevChildren || nextChildren) && isHmrUpdating) {
+ return true;
+ }
+ // force child update for runtime directive or transition on component vnode.
+ if (nextVNode.dirs || nextVNode.transition) {
+ return true;
+ }
+ if (optimized && patchFlag >= 0) {
+ if (patchFlag & 1024 /* PatchFlags.DYNAMIC_SLOTS */) {
+ // slot content that references values that might have changed,
+ // e.g. in a v-for
+ return true;
+ }
+ if (patchFlag & 16 /* PatchFlags.FULL_PROPS */) {
+ if (!prevProps) {
+ return !!nextProps;
+ }
+ // presence of this flag indicates props are always non-null
+ return hasPropsChanged(prevProps, nextProps, emits);
+ }
+ else if (patchFlag & 8 /* PatchFlags.PROPS */) {
+ const dynamicProps = nextVNode.dynamicProps;
+ for (let i = 0; i < dynamicProps.length; i++) {
+ const key = dynamicProps[i];
+ if (nextProps[key] !== prevProps[key] &&
+ !isEmitListener(emits, key)) {
+ return true;
+ }
+ }
+ }
+ }
+ else {
+ // this path is only taken by manually written render functions
+ // so presence of any children leads to a forced update
+ if (prevChildren || nextChildren) {
+ if (!nextChildren || !nextChildren.$stable) {
+ return true;
+ }
+ }
+ if (prevProps === nextProps) {
+ return false;
+ }
+ if (!prevProps) {
+ return !!nextProps;
+ }
+ if (!nextProps) {
+ return true;
+ }
+ return hasPropsChanged(prevProps, nextProps, emits);
+ }
+ return false;
+ }
+ function hasPropsChanged(prevProps, nextProps, emitsOptions) {
+ const nextKeys = Object.keys(nextProps);
+ if (nextKeys.length !== Object.keys(prevProps).length) {
+ return true;
+ }
+ for (let i = 0; i < nextKeys.length; i++) {
+ const key = nextKeys[i];
+ if (nextProps[key] !== prevProps[key] &&
+ !isEmitListener(emitsOptions, key)) {
+ return true;
+ }
+ }
+ return false;
+ }
+ function updateHOCHostEl({ vnode, parent }, el // HostNode
+ ) {
+ while (parent && parent.subTree === vnode) {
+ (vnode = parent.vnode).el = el;
+ parent = parent.parent;
+ }
+ }
+
+ const isSuspense = (type) => type.__isSuspense;
+ // Suspense exposes a component-like API, and is treated like a component
+ // in the compiler, but internally it's a special built-in type that hooks
+ // directly into the renderer.
+ const SuspenseImpl = {
+ name: 'Suspense',
+ // In order to make Suspense tree-shakable, we need to avoid importing it
+ // directly in the renderer. The renderer checks for the __isSuspense flag
+ // on a vnode's type and calls the `process` method, passing in renderer
+ // internals.
+ __isSuspense: true,
+ process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized,
+ // platform-specific impl passed from renderer
+ rendererInternals) {
+ if (n1 == null) {
+ mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals);
+ }
+ else {
+ patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, rendererInternals);
+ }
+ },
+ hydrate: hydrateSuspense,
+ create: createSuspenseBoundary,
+ normalize: normalizeSuspenseChildren
+ };
+ // Force-casted public typing for h and TSX props inference
+ const Suspense = (SuspenseImpl
+ );
+ function triggerEvent(vnode, name) {
+ const eventListener = vnode.props && vnode.props[name];
+ if (isFunction(eventListener)) {
+ eventListener();
+ }
+ }
+ function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) {
+ const { p: patch, o: { createElement } } = rendererInternals;
+ const hiddenContainer = createElement('div');
+ const suspense = (vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals));
+ // start mounting the content subtree in an off-dom container
+ patch(null, (suspense.pendingBranch = vnode.ssContent), hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds);
+ // now check if we have encountered any async deps
+ if (suspense.deps > 0) {
+ // has async
+ // invoke @fallback event
+ triggerEvent(vnode, 'onPending');
+ triggerEvent(vnode, 'onFallback');
+ // mount the fallback tree
+ patch(null, vnode.ssFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context
+ isSVG, slotScopeIds);
+ setActiveBranch(suspense, vnode.ssFallback);
+ }
+ else {
+ // Suspense has no async deps. Just resolve.
+ suspense.resolve();
+ }
+ }
+ function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) {
+ const suspense = (n2.suspense = n1.suspense);
+ suspense.vnode = n2;
+ n2.el = n1.el;
+ const newBranch = n2.ssContent;
+ const newFallback = n2.ssFallback;
+ const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;
+ if (pendingBranch) {
+ suspense.pendingBranch = newBranch;
+ if (isSameVNodeType(newBranch, pendingBranch)) {
+ // same root type but content may have changed.
+ patch(pendingBranch, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized);
+ if (suspense.deps <= 0) {
+ suspense.resolve();
+ }
+ else if (isInFallback) {
+ patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context
+ isSVG, slotScopeIds, optimized);
+ setActiveBranch(suspense, newFallback);
+ }
+ }
+ else {
+ // toggled before pending tree is resolved
+ suspense.pendingId++;
+ if (isHydrating) {
+ // if toggled before hydration is finished, the current DOM tree is
+ // no longer valid. set it as the active branch so it will be unmounted
+ // when resolved
+ suspense.isHydrating = false;
+ suspense.activeBranch = pendingBranch;
+ }
+ else {
+ unmount(pendingBranch, parentComponent, suspense);
+ }
+ // increment pending ID. this is used to invalidate async callbacks
+ // reset suspense state
+ suspense.deps = 0;
+ // discard effects from pending branch
+ suspense.effects.length = 0;
+ // discard previous container
+ suspense.hiddenContainer = createElement('div');
+ if (isInFallback) {
+ // already in fallback state
+ patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized);
+ if (suspense.deps <= 0) {
+ suspense.resolve();
+ }
+ else {
+ patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context
+ isSVG, slotScopeIds, optimized);
+ setActiveBranch(suspense, newFallback);
+ }
+ }
+ else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
+ // toggled "back" to current active branch
+ patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized);
+ // force resolve
+ suspense.resolve(true);
+ }
+ else {
+ // switched to a 3rd branch
+ patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized);
+ if (suspense.deps <= 0) {
+ suspense.resolve();
+ }
+ }
+ }
+ }
+ else {
+ if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
+ // root did not change, just normal patch
+ patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized);
+ setActiveBranch(suspense, newBranch);
+ }
+ else {
+ // root node toggled
+ // invoke @pending event
+ triggerEvent(n2, 'onPending');
+ // mount pending branch in off-dom container
+ suspense.pendingBranch = newBranch;
+ suspense.pendingId++;
+ patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized);
+ if (suspense.deps <= 0) {
+ // incoming branch has no async deps, resolve now.
+ suspense.resolve();
+ }
+ else {
+ const { timeout, pendingId } = suspense;
+ if (timeout > 0) {
+ setTimeout(() => {
+ if (suspense.pendingId === pendingId) {
+ suspense.fallback(newFallback);
+ }
+ }, timeout);
+ }
+ else if (timeout === 0) {
+ suspense.fallback(newFallback);
+ }
+ }
+ }
+ }
+ }
+ let hasWarned = false;
+ function createSuspenseBoundary(vnode, parent, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
+ /* istanbul ignore if */
+ if (!hasWarned) {
+ hasWarned = true;
+ // @ts-ignore `console.info` cannot be null error
+ console[console.info ? 'info' : 'log'](` is an experimental feature and its API will likely change.`);
+ }
+ const { p: patch, m: move, um: unmount, n: next, o: { parentNode, remove } } = rendererInternals;
+ const timeout = toNumber(vnode.props && vnode.props.timeout);
+ const suspense = {
+ vnode,
+ parent,
+ parentComponent,
+ isSVG,
+ container,
+ hiddenContainer,
+ anchor,
+ deps: 0,
+ pendingId: 0,
+ timeout: typeof timeout === 'number' ? timeout : -1,
+ activeBranch: null,
+ pendingBranch: null,
+ isInFallback: true,
+ isHydrating,
+ isUnmounted: false,
+ effects: [],
+ resolve(resume = false) {
+ {
+ if (!resume && !suspense.pendingBranch) {
+ throw new Error(`suspense.resolve() is called without a pending branch.`);
+ }
+ if (suspense.isUnmounted) {
+ throw new Error(`suspense.resolve() is called on an already unmounted suspense boundary.`);
+ }
+ }
+ const { vnode, activeBranch, pendingBranch, pendingId, effects, parentComponent, container } = suspense;
+ if (suspense.isHydrating) {
+ suspense.isHydrating = false;
+ }
+ else if (!resume) {
+ const delayEnter = activeBranch &&
+ pendingBranch.transition &&
+ pendingBranch.transition.mode === 'out-in';
+ if (delayEnter) {
+ activeBranch.transition.afterLeave = () => {
+ if (pendingId === suspense.pendingId) {
+ move(pendingBranch, container, anchor, 0 /* MoveType.ENTER */);
+ }
+ };
+ }
+ // this is initial anchor on mount
+ let { anchor } = suspense;
+ // unmount current active tree
+ if (activeBranch) {
+ // if the fallback tree was mounted, it may have been moved
+ // as part of a parent suspense. get the latest anchor for insertion
+ anchor = next(activeBranch);
+ unmount(activeBranch, parentComponent, suspense, true);
+ }
+ if (!delayEnter) {
+ // move content from off-dom container to actual container
+ move(pendingBranch, container, anchor, 0 /* MoveType.ENTER */);
+ }
+ }
+ setActiveBranch(suspense, pendingBranch);
+ suspense.pendingBranch = null;
+ suspense.isInFallback = false;
+ // flush buffered effects
+ // check if there is a pending parent suspense
+ let parent = suspense.parent;
+ let hasUnresolvedAncestor = false;
+ while (parent) {
+ if (parent.pendingBranch) {
+ // found a pending parent suspense, merge buffered post jobs
+ // into that parent
+ parent.effects.push(...effects);
+ hasUnresolvedAncestor = true;
+ break;
+ }
+ parent = parent.parent;
+ }
+ // no pending parent suspense, flush all jobs
+ if (!hasUnresolvedAncestor) {
+ queuePostFlushCb(effects);
+ }
+ suspense.effects = [];
+ // invoke @resolve event
+ triggerEvent(vnode, 'onResolve');
+ },
+ fallback(fallbackVNode) {
+ if (!suspense.pendingBranch) {
+ return;
+ }
+ const { vnode, activeBranch, parentComponent, container, isSVG } = suspense;
+ // invoke @fallback event
+ triggerEvent(vnode, 'onFallback');
+ const anchor = next(activeBranch);
+ const mountFallback = () => {
+ if (!suspense.isInFallback) {
+ return;
+ }
+ // mount the fallback tree
+ patch(null, fallbackVNode, container, anchor, parentComponent, null, // fallback tree will not have suspense context
+ isSVG, slotScopeIds, optimized);
+ setActiveBranch(suspense, fallbackVNode);
+ };
+ const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === 'out-in';
+ if (delayEnter) {
+ activeBranch.transition.afterLeave = mountFallback;
+ }
+ suspense.isInFallback = true;
+ // unmount current active branch
+ unmount(activeBranch, parentComponent, null, // no suspense so unmount hooks fire now
+ true // shouldRemove
+ );
+ if (!delayEnter) {
+ mountFallback();
+ }
+ },
+ move(container, anchor, type) {
+ suspense.activeBranch &&
+ move(suspense.activeBranch, container, anchor, type);
+ suspense.container = container;
+ },
+ next() {
+ return suspense.activeBranch && next(suspense.activeBranch);
+ },
+ registerDep(instance, setupRenderEffect) {
+ const isInPendingSuspense = !!suspense.pendingBranch;
+ if (isInPendingSuspense) {
+ suspense.deps++;
+ }
+ const hydratedEl = instance.vnode.el;
+ instance
+ .asyncDep.catch(err => {
+ handleError(err, instance, 0 /* ErrorCodes.SETUP_FUNCTION */);
+ })
+ .then(asyncSetupResult => {
+ // retry when the setup() promise resolves.
+ // component may have been unmounted before resolve.
+ if (instance.isUnmounted ||
+ suspense.isUnmounted ||
+ suspense.pendingId !== instance.suspenseId) {
+ return;
+ }
+ // retry from this component
+ instance.asyncResolved = true;
+ const { vnode } = instance;
+ {
+ pushWarningContext(vnode);
+ }
+ handleSetupResult(instance, asyncSetupResult, false);
+ if (hydratedEl) {
+ // vnode may have been replaced if an update happened before the
+ // async dep is resolved.
+ vnode.el = hydratedEl;
+ }
+ const placeholder = !hydratedEl && instance.subTree.el;
+ setupRenderEffect(instance, vnode,
+ // component may have been moved before resolve.
+ // if this is not a hydration, instance.subTree will be the comment
+ // placeholder.
+ parentNode(hydratedEl || instance.subTree.el),
+ // anchor will not be used if this is hydration, so only need to
+ // consider the comment placeholder case.
+ hydratedEl ? null : next(instance.subTree), suspense, isSVG, optimized);
+ if (placeholder) {
+ remove(placeholder);
+ }
+ updateHOCHostEl(instance, vnode.el);
+ {
+ popWarningContext();
+ }
+ // only decrease deps count if suspense is not already resolved
+ if (isInPendingSuspense && --suspense.deps === 0) {
+ suspense.resolve();
+ }
+ });
+ },
+ unmount(parentSuspense, doRemove) {
+ suspense.isUnmounted = true;
+ if (suspense.activeBranch) {
+ unmount(suspense.activeBranch, parentComponent, parentSuspense, doRemove);
+ }
+ if (suspense.pendingBranch) {
+ unmount(suspense.pendingBranch, parentComponent, parentSuspense, doRemove);
+ }
+ }
+ };
+ return suspense;
+ }
+ function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals, hydrateNode) {
+ /* eslint-disable no-restricted-globals */
+ const suspense = (vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, node.parentNode, document.createElement('div'), null, isSVG, slotScopeIds, optimized, rendererInternals, true /* hydrating */));
+ // there are two possible scenarios for server-rendered suspense:
+ // - success: ssr content should be fully resolved
+ // - failure: ssr content should be the fallback branch.
+ // however, on the client we don't really know if it has failed or not
+ // attempt to hydrate the DOM assuming it has succeeded, but we still
+ // need to construct a suspense boundary first
+ const result = hydrateNode(node, (suspense.pendingBranch = vnode.ssContent), parentComponent, suspense, slotScopeIds, optimized);
+ if (suspense.deps === 0) {
+ suspense.resolve();
+ }
+ return result;
+ /* eslint-enable no-restricted-globals */
+ }
+ function normalizeSuspenseChildren(vnode) {
+ const { shapeFlag, children } = vnode;
+ const isSlotChildren = shapeFlag & 32 /* ShapeFlags.SLOTS_CHILDREN */;
+ vnode.ssContent = normalizeSuspenseSlot(isSlotChildren ? children.default : children);
+ vnode.ssFallback = isSlotChildren
+ ? normalizeSuspenseSlot(children.fallback)
+ : createVNode(Comment);
+ }
+ function normalizeSuspenseSlot(s) {
+ let block;
+ if (isFunction(s)) {
+ const trackBlock = isBlockTreeEnabled && s._c;
+ if (trackBlock) {
+ // disableTracking: false
+ // allow block tracking for compiled slots
+ // (see ./componentRenderContext.ts)
+ s._d = false;
+ openBlock();
+ }
+ s = s();
+ if (trackBlock) {
+ s._d = true;
+ block = currentBlock;
+ closeBlock();
+ }
+ }
+ if (isArray(s)) {
+ const singleChild = filterSingleRoot(s);
+ if (!singleChild) {
+ warn$1(` slots expect a single root node.`);
+ }
+ s = singleChild;
+ }
+ s = normalizeVNode(s);
+ if (block && !s.dynamicChildren) {
+ s.dynamicChildren = block.filter(c => c !== s);
+ }
+ return s;
+ }
+ function queueEffectWithSuspense(fn, suspense) {
+ if (suspense && suspense.pendingBranch) {
+ if (isArray(fn)) {
+ suspense.effects.push(...fn);
+ }
+ else {
+ suspense.effects.push(fn);
+ }
+ }
+ else {
+ queuePostFlushCb(fn);
+ }
+ }
+ function setActiveBranch(suspense, branch) {
+ suspense.activeBranch = branch;
+ const { vnode, parentComponent } = suspense;
+ const el = (vnode.el = branch.el);
+ // in case suspense is the root node of a component,
+ // recursively update the HOC el
+ if (parentComponent && parentComponent.subTree === vnode) {
+ parentComponent.vnode.el = el;
+ updateHOCHostEl(parentComponent, el);
+ }
+ }
+
+ function provide(key, value) {
+ if (!currentInstance) {
+ {
+ warn$1(`provide() can only be used inside setup().`);
+ }
+ }
+ else {
+ let provides = currentInstance.provides;
+ // by default an instance inherits its parent's provides object
+ // but when it needs to provide values of its own, it creates its
+ // own provides object using parent provides object as prototype.
+ // this way in `inject` we can simply look up injections from direct
+ // parent and let the prototype chain do the work.
+ const parentProvides = currentInstance.parent && currentInstance.parent.provides;
+ if (parentProvides === provides) {
+ provides = currentInstance.provides = Object.create(parentProvides);
+ }
+ // TS doesn't allow symbol as index type
+ provides[key] = value;
+ }
+ }
+ function inject(key, defaultValue, treatDefaultAsFactory = false) {
+ // fallback to `currentRenderingInstance` so that this can be called in
+ // a functional component
+ const instance = currentInstance || currentRenderingInstance;
+ if (instance) {
+ // #2400
+ // to support `app.use` plugins,
+ // fallback to appContext's `provides` if the instance is at root
+ const provides = instance.parent == null
+ ? instance.vnode.appContext && instance.vnode.appContext.provides
+ : instance.parent.provides;
+ if (provides && key in provides) {
+ // TS doesn't allow symbol as index type
+ return provides[key];
+ }
+ else if (arguments.length > 1) {
+ return treatDefaultAsFactory && isFunction(defaultValue)
+ ? defaultValue.call(instance.proxy)
+ : defaultValue;
+ }
+ else {
+ warn$1(`injection "${String(key)}" not found.`);
+ }
+ }
+ else {
+ warn$1(`inject() can only be used inside setup() or functional components.`);
+ }
+ }
+
+ // Simple effect.
+ function watchEffect(effect, options) {
+ return doWatch(effect, null, options);
+ }
+ function watchPostEffect(effect, options) {
+ return doWatch(effect, null, (Object.assign(Object.assign({}, options), { flush: 'post' }) ));
+ }
+ function watchSyncEffect(effect, options) {
+ return doWatch(effect, null, (Object.assign(Object.assign({}, options), { flush: 'sync' }) ));
+ }
+ // initial value for watchers to trigger on undefined initial values
+ const INITIAL_WATCHER_VALUE = {};
+ // implementation
+ function watch(source, cb, options) {
+ if (!isFunction(cb)) {
+ warn$1(`\`watch(fn, options?)\` signature has been moved to a separate API. ` +
+ `Use \`watchEffect(fn, options?)\` instead. \`watch\` now only ` +
+ `supports \`watch(source, cb, options?) signature.`);
+ }
+ return doWatch(source, cb, options);
+ }
+ function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ) {
+ if (!cb) {
+ if (immediate !== undefined) {
+ warn$1(`watch() "immediate" option is only respected when using the ` +
+ `watch(source, callback, options?) signature.`);
+ }
+ if (deep !== undefined) {
+ warn$1(`watch() "deep" option is only respected when using the ` +
+ `watch(source, callback, options?) signature.`);
+ }
+ }
+ const warnInvalidSource = (s) => {
+ warn$1(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +
+ `a reactive object, or an array of these types.`);
+ };
+ const instance = currentInstance;
+ let getter;
+ let forceTrigger = false;
+ let isMultiSource = false;
+ if (isRef(source)) {
+ getter = () => source.value;
+ forceTrigger = isShallow(source);
+ }
+ else if (isReactive(source)) {
+ getter = () => source;
+ deep = true;
+ }
+ else if (isArray(source)) {
+ isMultiSource = true;
+ forceTrigger = source.some(s => isReactive(s) || isShallow(s));
+ getter = () => source.map(s => {
+ if (isRef(s)) {
+ return s.value;
+ }
+ else if (isReactive(s)) {
+ return traverse(s);
+ }
+ else if (isFunction(s)) {
+ return callWithErrorHandling(s, instance, 2 /* ErrorCodes.WATCH_GETTER */);
+ }
+ else {
+ warnInvalidSource(s);
+ }
+ });
+ }
+ else if (isFunction(source)) {
+ if (cb) {
+ // getter with cb
+ getter = () => callWithErrorHandling(source, instance, 2 /* ErrorCodes.WATCH_GETTER */);
+ }
+ else {
+ // no cb -> simple effect
+ getter = () => {
+ if (instance && instance.isUnmounted) {
+ return;
+ }
+ if (cleanup) {
+ cleanup();
+ }
+ return callWithAsyncErrorHandling(source, instance, 3 /* ErrorCodes.WATCH_CALLBACK */, [onCleanup]);
+ };
+ }
+ }
+ else {
+ getter = NOOP;
+ warnInvalidSource(source);
+ }
+ if (cb && deep) {
+ const baseGetter = getter;
+ getter = () => traverse(baseGetter());
+ }
+ let cleanup;
+ let onCleanup = (fn) => {
+ cleanup = effect.onStop = () => {
+ callWithErrorHandling(fn, instance, 4 /* ErrorCodes.WATCH_CLEANUP */);
+ };
+ };
+ let oldValue = isMultiSource
+ ? new Array(source.length).fill(INITIAL_WATCHER_VALUE)
+ : INITIAL_WATCHER_VALUE;
+ const job = () => {
+ if (!effect.active) {
+ return;
+ }
+ if (cb) {
+ // watch(source, cb)
+ const newValue = effect.run();
+ if (deep ||
+ forceTrigger ||
+ (isMultiSource
+ ? newValue.some((v, i) => hasChanged(v, oldValue[i]))
+ : hasChanged(newValue, oldValue)) ||
+ (false )) {
+ // cleanup before running cb again
+ if (cleanup) {
+ cleanup();
+ }
+ callWithAsyncErrorHandling(cb, instance, 3 /* ErrorCodes.WATCH_CALLBACK */, [
+ newValue,
+ // pass undefined as the old value when it's changed for the first time
+ oldValue === INITIAL_WATCHER_VALUE
+ ? undefined
+ : (isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE)
+ ? []
+ : oldValue,
+ onCleanup
+ ]);
+ oldValue = newValue;
+ }
+ }
+ else {
+ // watchEffect
+ effect.run();
+ }
+ };
+ // important: mark the job as a watcher callback so that scheduler knows
+ // it is allowed to self-trigger (#1727)
+ job.allowRecurse = !!cb;
+ let scheduler;
+ if (flush === 'sync') {
+ scheduler = job; // the scheduler function gets called directly
+ }
+ else if (flush === 'post') {
+ scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
+ }
+ else {
+ // default: 'pre'
+ job.pre = true;
+ if (instance)
+ job.id = instance.uid;
+ scheduler = () => queueJob(job);
+ }
+ const effect = new ReactiveEffect(getter, scheduler);
+ {
+ effect.onTrack = onTrack;
+ effect.onTrigger = onTrigger;
+ }
+ // initial run
+ if (cb) {
+ if (immediate) {
+ job();
+ }
+ else {
+ oldValue = effect.run();
+ }
+ }
+ else if (flush === 'post') {
+ queuePostRenderEffect(effect.run.bind(effect), instance && instance.suspense);
+ }
+ else {
+ effect.run();
+ }
+ const unwatch = () => {
+ effect.stop();
+ if (instance && instance.scope) {
+ remove(instance.scope.effects, effect);
+ }
+ };
+ return unwatch;
+ }
+ // this.$watch
+ function instanceWatch(source, value, options) {
+ const publicThis = this.proxy;
+ const getter = isString(source)
+ ? source.includes('.')
+ ? createPathGetter(publicThis, source)
+ : () => publicThis[source]
+ : source.bind(publicThis, publicThis);
+ let cb;
+ if (isFunction(value)) {
+ cb = value;
+ }
+ else {
+ cb = value.handler;
+ options = value;
+ }
+ const cur = currentInstance;
+ setCurrentInstance(this);
+ const res = doWatch(getter, cb.bind(publicThis), options);
+ if (cur) {
+ setCurrentInstance(cur);
+ }
+ else {
+ unsetCurrentInstance();
+ }
+ return res;
+ }
+ function createPathGetter(ctx, path) {
+ const segments = path.split('.');
+ return () => {
+ let cur = ctx;
+ for (let i = 0; i < segments.length && cur; i++) {
+ cur = cur[segments[i]];
+ }
+ return cur;
+ };
+ }
+ function traverse(value, seen) {
+ if (!isObject(value) || value["__v_skip" /* ReactiveFlags.SKIP */]) {
+ return value;
+ }
+ seen = seen || new Set();
+ if (seen.has(value)) {
+ return value;
+ }
+ seen.add(value);
+ if (isRef(value)) {
+ traverse(value.value, seen);
+ }
+ else if (isArray(value)) {
+ for (let i = 0; i < value.length; i++) {
+ traverse(value[i], seen);
+ }
+ }
+ else if (isSet(value) || isMap(value)) {
+ value.forEach((v) => {
+ traverse(v, seen);
+ });
+ }
+ else if (isPlainObject(value)) {
+ for (const key in value) {
+ traverse(value[key], seen);
+ }
+ }
+ return value;
+ }
+
+ function useTransitionState() {
+ const state = {
+ isMounted: false,
+ isLeaving: false,
+ isUnmounting: false,
+ leavingVNodes: new Map()
+ };
+ onMounted(() => {
+ state.isMounted = true;
+ });
+ onBeforeUnmount(() => {
+ state.isUnmounting = true;
+ });
+ return state;
+ }
+ const TransitionHookValidator = [Function, Array];
+ const BaseTransitionImpl = {
+ name: `BaseTransition`,
+ props: {
+ mode: String,
+ appear: Boolean,
+ persisted: Boolean,
+ // enter
+ onBeforeEnter: TransitionHookValidator,
+ onEnter: TransitionHookValidator,
+ onAfterEnter: TransitionHookValidator,
+ onEnterCancelled: TransitionHookValidator,
+ // leave
+ onBeforeLeave: TransitionHookValidator,
+ onLeave: TransitionHookValidator,
+ onAfterLeave: TransitionHookValidator,
+ onLeaveCancelled: TransitionHookValidator,
+ // appear
+ onBeforeAppear: TransitionHookValidator,
+ onAppear: TransitionHookValidator,
+ onAfterAppear: TransitionHookValidator,
+ onAppearCancelled: TransitionHookValidator
+ },
+ setup(props, { slots }) {
+ const instance = getCurrentInstance();
+ const state = useTransitionState();
+ let prevTransitionKey;
+ return () => {
+ const children = slots.default && getTransitionRawChildren(slots.default(), true);
+ if (!children || !children.length) {
+ return;
+ }
+ let child = children[0];
+ if (children.length > 1) {
+ let hasFound = false;
+ // locate first non-comment child
+ for (const c of children) {
+ if (c.type !== Comment) {
+ if (hasFound) {
+ // warn more than one non-comment child
+ warn$1(' can only be used on a single element or component. ' +
+ 'Use for lists.');
+ break;
+ }
+ child = c;
+ hasFound = true;
+ }
+ }
+ }
+ // there's no need to track reactivity for these props so use the raw
+ // props for a bit better perf
+ const rawProps = toRaw(props);
+ const { mode } = rawProps;
+ // check mode
+ if (mode &&
+ mode !== 'in-out' &&
+ mode !== 'out-in' &&
+ mode !== 'default') {
+ warn$1(`invalid mode: ${mode}`);
+ }
+ if (state.isLeaving) {
+ return emptyPlaceholder(child);
+ }
+ // in the case of , we need to
+ // compare the type of the kept-alive children.
+ const innerChild = getKeepAliveChild(child);
+ if (!innerChild) {
+ return emptyPlaceholder(child);
+ }
+ const enterHooks = resolveTransitionHooks(innerChild, rawProps, state, instance);
+ setTransitionHooks(innerChild, enterHooks);
+ const oldChild = instance.subTree;
+ const oldInnerChild = oldChild && getKeepAliveChild(oldChild);
+ let transitionKeyChanged = false;
+ const { getTransitionKey } = innerChild.type;
+ if (getTransitionKey) {
+ const key = getTransitionKey();
+ if (prevTransitionKey === undefined) {
+ prevTransitionKey = key;
+ }
+ else if (key !== prevTransitionKey) {
+ prevTransitionKey = key;
+ transitionKeyChanged = true;
+ }
+ }
+ // handle mode
+ if (oldInnerChild &&
+ oldInnerChild.type !== Comment &&
+ (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) {
+ const leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance);
+ // update old tree's hooks in case of dynamic transition
+ setTransitionHooks(oldInnerChild, leavingHooks);
+ // switching between different views
+ if (mode === 'out-in') {
+ state.isLeaving = true;
+ // return placeholder node and queue update when leave finishes
+ leavingHooks.afterLeave = () => {
+ state.isLeaving = false;
+ // #6835
+ // it also needs to be updated when active is undefined
+ if (instance.update.active !== false) {
+ instance.update();
+ }
+ };
+ return emptyPlaceholder(child);
+ }
+ else if (mode === 'in-out' && innerChild.type !== Comment) {
+ leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
+ const leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild);
+ leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
+ // early removal callback
+ el._leaveCb = () => {
+ earlyRemove();
+ el._leaveCb = undefined;
+ delete enterHooks.delayedLeave;
+ };
+ enterHooks.delayedLeave = delayedLeave;
+ };
+ }
+ }
+ return child;
+ };
+ }
+ };
+ // export the public type for h/tsx inference
+ // also to avoid inline import() in generated d.ts files
+ const BaseTransition = BaseTransitionImpl;
+ function getLeavingNodesForType(state, vnode) {
+ const { leavingVNodes } = state;
+ let leavingVNodesCache = leavingVNodes.get(vnode.type);
+ if (!leavingVNodesCache) {
+ leavingVNodesCache = Object.create(null);
+ leavingVNodes.set(vnode.type, leavingVNodesCache);
+ }
+ return leavingVNodesCache;
+ }
+ // The transition hooks are attached to the vnode as vnode.transition
+ // and will be called at appropriate timing in the renderer.
+ function resolveTransitionHooks(vnode, props, state, instance) {
+ const { appear, mode, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled } = props;
+ const key = String(vnode.key);
+ const leavingVNodesCache = getLeavingNodesForType(state, vnode);
+ const callHook = (hook, args) => {
+ hook &&
+ callWithAsyncErrorHandling(hook, instance, 9 /* ErrorCodes.TRANSITION_HOOK */, args);
+ };
+ const callAsyncHook = (hook, args) => {
+ const done = args[1];
+ callHook(hook, args);
+ if (isArray(hook)) {
+ if (hook.every(hook => hook.length <= 1))
+ done();
+ }
+ else if (hook.length <= 1) {
+ done();
+ }
+ };
+ const hooks = {
+ mode,
+ persisted,
+ beforeEnter(el) {
+ let hook = onBeforeEnter;
+ if (!state.isMounted) {
+ if (appear) {
+ hook = onBeforeAppear || onBeforeEnter;
+ }
+ else {
+ return;
+ }
+ }
+ // for same element (v-show)
+ if (el._leaveCb) {
+ el._leaveCb(true /* cancelled */);
+ }
+ // for toggled element with same key (v-if)
+ const leavingVNode = leavingVNodesCache[key];
+ if (leavingVNode &&
+ isSameVNodeType(vnode, leavingVNode) &&
+ leavingVNode.el._leaveCb) {
+ // force early removal (not cancelled)
+ leavingVNode.el._leaveCb();
+ }
+ callHook(hook, [el]);
+ },
+ enter(el) {
+ let hook = onEnter;
+ let afterHook = onAfterEnter;
+ let cancelHook = onEnterCancelled;
+ if (!state.isMounted) {
+ if (appear) {
+ hook = onAppear || onEnter;
+ afterHook = onAfterAppear || onAfterEnter;
+ cancelHook = onAppearCancelled || onEnterCancelled;
+ }
+ else {
+ return;
+ }
+ }
+ let called = false;
+ const done = (el._enterCb = (cancelled) => {
+ if (called)
+ return;
+ called = true;
+ if (cancelled) {
+ callHook(cancelHook, [el]);
+ }
+ else {
+ callHook(afterHook, [el]);
+ }
+ if (hooks.delayedLeave) {
+ hooks.delayedLeave();
+ }
+ el._enterCb = undefined;
+ });
+ if (hook) {
+ callAsyncHook(hook, [el, done]);
+ }
+ else {
+ done();
+ }
+ },
+ leave(el, remove) {
+ const key = String(vnode.key);
+ if (el._enterCb) {
+ el._enterCb(true /* cancelled */);
+ }
+ if (state.isUnmounting) {
+ return remove();
+ }
+ callHook(onBeforeLeave, [el]);
+ let called = false;
+ const done = (el._leaveCb = (cancelled) => {
+ if (called)
+ return;
+ called = true;
+ remove();
+ if (cancelled) {
+ callHook(onLeaveCancelled, [el]);
+ }
+ else {
+ callHook(onAfterLeave, [el]);
+ }
+ el._leaveCb = undefined;
+ if (leavingVNodesCache[key] === vnode) {
+ delete leavingVNodesCache[key];
+ }
+ });
+ leavingVNodesCache[key] = vnode;
+ if (onLeave) {
+ callAsyncHook(onLeave, [el, done]);
+ }
+ else {
+ done();
+ }
+ },
+ clone(vnode) {
+ return resolveTransitionHooks(vnode, props, state, instance);
+ }
+ };
+ return hooks;
+ }
+ // the placeholder really only handles one special case: KeepAlive
+ // in the case of a KeepAlive in a leave phase we need to return a KeepAlive
+ // placeholder with empty content to avoid the KeepAlive instance from being
+ // unmounted.
+ function emptyPlaceholder(vnode) {
+ if (isKeepAlive(vnode)) {
+ vnode = cloneVNode(vnode);
+ vnode.children = null;
+ return vnode;
+ }
+ }
+ function getKeepAliveChild(vnode) {
+ return isKeepAlive(vnode)
+ ? vnode.children
+ ? vnode.children[0]
+ : undefined
+ : vnode;
+ }
+ function setTransitionHooks(vnode, hooks) {
+ if (vnode.shapeFlag & 6 /* ShapeFlags.COMPONENT */ && vnode.component) {
+ setTransitionHooks(vnode.component.subTree, hooks);
+ }
+ else if (vnode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */) {
+ vnode.ssContent.transition = hooks.clone(vnode.ssContent);
+ vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
+ }
+ else {
+ vnode.transition = hooks;
+ }
+ }
+ function getTransitionRawChildren(children, keepComment = false, parentKey) {
+ let ret = [];
+ let keyedFragmentCount = 0;
+ for (let i = 0; i < children.length; i++) {
+ let child = children[i];
+ // #5360 inherit parent key in case of
+ const key = parentKey == null
+ ? child.key
+ : String(parentKey) + String(child.key != null ? child.key : i);
+ // handle fragment children case, e.g. v-for
+ if (child.type === Fragment) {
+ if (child.patchFlag & 128 /* PatchFlags.KEYED_FRAGMENT */)
+ keyedFragmentCount++;
+ ret = ret.concat(getTransitionRawChildren(child.children, keepComment, key));
+ }
+ // comment placeholders should be skipped, e.g. v-if
+ else if (keepComment || child.type !== Comment) {
+ ret.push(key != null ? cloneVNode(child, { key }) : child);
+ }
+ }
+ // #1126 if a transition children list contains multiple sub fragments, these
+ // fragments will be merged into a flat children array. Since each v-for
+ // fragment may contain different static bindings inside, we need to de-op
+ // these children to force full diffs to ensure correct behavior.
+ if (keyedFragmentCount > 1) {
+ for (let i = 0; i < ret.length; i++) {
+ ret[i].patchFlag = -2 /* PatchFlags.BAIL */;
+ }
+ }
+ return ret;
+ }
+
+ // implementation, close to no-op
+ function defineComponent(options) {
+ return isFunction(options) ? { setup: options, name: options.name } : options;
+ }
+
+ const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
+ function defineAsyncComponent(source) {
+ if (isFunction(source)) {
+ source = { loader: source };
+ }
+ const { loader, loadingComponent, errorComponent, delay = 200, timeout, // undefined = never times out
+ suspensible = true, onError: userOnError } = source;
+ let pendingRequest = null;
+ let resolvedComp;
+ let retries = 0;
+ const retry = () => {
+ retries++;
+ pendingRequest = null;
+ return load();
+ };
+ const load = () => {
+ let thisRequest;
+ return (pendingRequest ||
+ (thisRequest = pendingRequest =
+ loader()
+ .catch(err => {
+ err = err instanceof Error ? err : new Error(String(err));
+ if (userOnError) {
+ return new Promise((resolve, reject) => {
+ const userRetry = () => resolve(retry());
+ const userFail = () => reject(err);
+ userOnError(err, userRetry, userFail, retries + 1);
+ });
+ }
+ else {
+ throw err;
+ }
+ })
+ .then((comp) => {
+ if (thisRequest !== pendingRequest && pendingRequest) {
+ return pendingRequest;
+ }
+ if (!comp) {
+ warn$1(`Async component loader resolved to undefined. ` +
+ `If you are using retry(), make sure to return its return value.`);
+ }
+ // interop module default
+ if (comp &&
+ (comp.__esModule || comp[Symbol.toStringTag] === 'Module')) {
+ comp = comp.default;
+ }
+ if (comp && !isObject(comp) && !isFunction(comp)) {
+ throw new Error(`Invalid async component load result: ${comp}`);
+ }
+ resolvedComp = comp;
+ return comp;
+ })));
+ };
+ return defineComponent({
+ name: 'AsyncComponentWrapper',
+ __asyncLoader: load,
+ get __asyncResolved() {
+ return resolvedComp;
+ },
+ setup() {
+ const instance = currentInstance;
+ // already resolved
+ if (resolvedComp) {
+ return () => createInnerComp(resolvedComp, instance);
+ }
+ const onError = (err) => {
+ pendingRequest = null;
+ handleError(err, instance, 13 /* ErrorCodes.ASYNC_COMPONENT_LOADER */, !errorComponent /* do not throw in dev if user provided error component */);
+ };
+ // suspense-controlled or SSR.
+ if ((suspensible && instance.suspense) ||
+ (false )) {
+ return load()
+ .then(comp => {
+ return () => createInnerComp(comp, instance);
+ })
+ .catch(err => {
+ onError(err);
+ return () => errorComponent
+ ? createVNode(errorComponent, {
+ error: err
+ })
+ : null;
+ });
+ }
+ const loaded = ref(false);
+ const error = ref();
+ const delayed = ref(!!delay);
+ if (delay) {
+ setTimeout(() => {
+ delayed.value = false;
+ }, delay);
+ }
+ if (timeout != null) {
+ setTimeout(() => {
+ if (!loaded.value && !error.value) {
+ const err = new Error(`Async component timed out after ${timeout}ms.`);
+ onError(err);
+ error.value = err;
+ }
+ }, timeout);
+ }
+ load()
+ .then(() => {
+ loaded.value = true;
+ if (instance.parent && isKeepAlive(instance.parent.vnode)) {
+ // parent is keep-alive, force update so the loaded component's
+ // name is taken into account
+ queueJob(instance.parent.update);
+ }
+ })
+ .catch(err => {
+ onError(err);
+ error.value = err;
+ });
+ return () => {
+ if (loaded.value && resolvedComp) {
+ return createInnerComp(resolvedComp, instance);
+ }
+ else if (error.value && errorComponent) {
+ return createVNode(errorComponent, {
+ error: error.value
+ });
+ }
+ else if (loadingComponent && !delayed.value) {
+ return createVNode(loadingComponent);
+ }
+ };
+ }
+ });
+ }
+ function createInnerComp(comp, parent) {
+ const { ref, props, children, ce } = parent.vnode;
+ const vnode = createVNode(comp, props, children);
+ // ensure inner component inherits the async wrapper's ref owner
+ vnode.ref = ref;
+ // pass the custom element callback on to the inner comp
+ // and remove it from the async wrapper
+ vnode.ce = ce;
+ delete parent.vnode.ce;
+ return vnode;
+ }
+
+ const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
+ const KeepAliveImpl = {
+ name: `KeepAlive`,
+ // Marker for special handling inside the renderer. We are not using a ===
+ // check directly on KeepAlive in the renderer, because importing it directly
+ // would prevent it from being tree-shaken.
+ __isKeepAlive: true,
+ props: {
+ include: [String, RegExp, Array],
+ exclude: [String, RegExp, Array],
+ max: [String, Number]
+ },
+ setup(props, { slots }) {
+ const instance = getCurrentInstance();
+ // KeepAlive communicates with the instantiated renderer via the
+ // ctx where the renderer passes in its internals,
+ // and the KeepAlive instance exposes activate/deactivate implementations.
+ // The whole point of this is to avoid importing KeepAlive directly in the
+ // renderer to facilitate tree-shaking.
+ const sharedContext = instance.ctx;
+ const cache = new Map();
+ const keys = new Set();
+ let current = null;
+ {
+ instance.__v_cache = cache;
+ }
+ const parentSuspense = instance.suspense;
+ const { renderer: { p: patch, m: move, um: _unmount, o: { createElement } } } = sharedContext;
+ const storageContainer = createElement('div');
+ sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => {
+ const instance = vnode.component;
+ move(vnode, container, anchor, 0 /* MoveType.ENTER */, parentSuspense);
+ // in case props have changed
+ patch(instance.vnode, vnode, container, anchor, instance, parentSuspense, isSVG, vnode.slotScopeIds, optimized);
+ queuePostRenderEffect(() => {
+ instance.isDeactivated = false;
+ if (instance.a) {
+ invokeArrayFns(instance.a);
+ }
+ const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
+ if (vnodeHook) {
+ invokeVNodeHook(vnodeHook, instance.parent, vnode);
+ }
+ }, parentSuspense);
+ {
+ // Update components tree
+ devtoolsComponentAdded(instance);
+ }
+ };
+ sharedContext.deactivate = (vnode) => {
+ const instance = vnode.component;
+ move(vnode, storageContainer, null, 1 /* MoveType.LEAVE */, parentSuspense);
+ queuePostRenderEffect(() => {
+ if (instance.da) {
+ invokeArrayFns(instance.da);
+ }
+ const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
+ if (vnodeHook) {
+ invokeVNodeHook(vnodeHook, instance.parent, vnode);
+ }
+ instance.isDeactivated = true;
+ }, parentSuspense);
+ {
+ // Update components tree
+ devtoolsComponentAdded(instance);
+ }
+ };
+ function unmount(vnode) {
+ // reset the shapeFlag so it can be properly unmounted
+ resetShapeFlag(vnode);
+ _unmount(vnode, instance, parentSuspense, true);
+ }
+ function pruneCache(filter) {
+ cache.forEach((vnode, key) => {
+ const name = getComponentName(vnode.type);
+ if (name && (!filter || !filter(name))) {
+ pruneCacheEntry(key);
+ }
+ });
+ }
+ function pruneCacheEntry(key) {
+ const cached = cache.get(key);
+ if (!current || cached.type !== current.type) {
+ unmount(cached);
+ }
+ else if (current) {
+ // current active instance should no longer be kept-alive.
+ // we can't unmount it now but it might be later, so reset its flag now.
+ resetShapeFlag(current);
+ }
+ cache.delete(key);
+ keys.delete(key);
+ }
+ // prune cache on include/exclude prop change
+ watch(() => [props.include, props.exclude], ([include, exclude]) => {
+ include && pruneCache(name => matches(include, name));
+ exclude && pruneCache(name => !matches(exclude, name));
+ },
+ // prune post-render after `current` has been updated
+ { flush: 'post', deep: true });
+ // cache sub tree after render
+ let pendingCacheKey = null;
+ const cacheSubtree = () => {
+ // fix #1621, the pendingCacheKey could be 0
+ if (pendingCacheKey != null) {
+ cache.set(pendingCacheKey, getInnerChild(instance.subTree));
+ }
+ };
+ onMounted(cacheSubtree);
+ onUpdated(cacheSubtree);
+ onBeforeUnmount(() => {
+ cache.forEach(cached => {
+ const { subTree, suspense } = instance;
+ const vnode = getInnerChild(subTree);
+ if (cached.type === vnode.type) {
+ // current instance will be unmounted as part of keep-alive's unmount
+ resetShapeFlag(vnode);
+ // but invoke its deactivated hook here
+ const da = vnode.component.da;
+ da && queuePostRenderEffect(da, suspense);
+ return;
+ }
+ unmount(cached);
+ });
+ });
+ return () => {
+ pendingCacheKey = null;
+ if (!slots.default) {
+ return null;
+ }
+ const children = slots.default();
+ const rawVNode = children[0];
+ if (children.length > 1) {
+ {
+ warn$1(`KeepAlive should contain exactly one component child.`);
+ }
+ current = null;
+ return children;
+ }
+ else if (!isVNode(rawVNode) ||
+ (!(rawVNode.shapeFlag & 4 /* ShapeFlags.STATEFUL_COMPONENT */) &&
+ !(rawVNode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */))) {
+ current = null;
+ return rawVNode;
+ }
+ let vnode = getInnerChild(rawVNode);
+ const comp = vnode.type;
+ // for async components, name check should be based in its loaded
+ // inner component if available
+ const name = getComponentName(isAsyncWrapper(vnode)
+ ? vnode.type.__asyncResolved || {}
+ : comp);
+ const { include, exclude, max } = props;
+ if ((include && (!name || !matches(include, name))) ||
+ (exclude && name && matches(exclude, name))) {
+ current = vnode;
+ return rawVNode;
+ }
+ const key = vnode.key == null ? comp : vnode.key;
+ const cachedVNode = cache.get(key);
+ // clone vnode if it's reused because we are going to mutate it
+ if (vnode.el) {
+ vnode = cloneVNode(vnode);
+ if (rawVNode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */) {
+ rawVNode.ssContent = vnode;
+ }
+ }
+ // #1513 it's possible for the returned vnode to be cloned due to attr
+ // fallthrough or scopeId, so the vnode here may not be the final vnode
+ // that is mounted. Instead of caching it directly, we store the pending
+ // key and cache `instance.subTree` (the normalized vnode) in
+ // beforeMount/beforeUpdate hooks.
+ pendingCacheKey = key;
+ if (cachedVNode) {
+ // copy over mounted state
+ vnode.el = cachedVNode.el;
+ vnode.component = cachedVNode.component;
+ if (vnode.transition) {
+ // recursively update transition hooks on subTree
+ setTransitionHooks(vnode, vnode.transition);
+ }
+ // avoid vnode being mounted as fresh
+ vnode.shapeFlag |= 512 /* ShapeFlags.COMPONENT_KEPT_ALIVE */;
+ // make this key the freshest
+ keys.delete(key);
+ keys.add(key);
+ }
+ else {
+ keys.add(key);
+ // prune oldest entry
+ if (max && keys.size > parseInt(max, 10)) {
+ pruneCacheEntry(keys.values().next().value);
+ }
+ }
+ // avoid vnode being unmounted
+ vnode.shapeFlag |= 256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */;
+ current = vnode;
+ return isSuspense(rawVNode.type) ? rawVNode : vnode;
+ };
+ }
+ };
+ // export the public type for h/tsx inference
+ // also to avoid inline import() in generated d.ts files
+ const KeepAlive = KeepAliveImpl;
+ function matches(pattern, name) {
+ if (isArray(pattern)) {
+ return pattern.some((p) => matches(p, name));
+ }
+ else if (isString(pattern)) {
+ return pattern.split(',').includes(name);
+ }
+ else if (pattern.test) {
+ return pattern.test(name);
+ }
+ /* istanbul ignore next */
+ return false;
+ }
+ function onActivated(hook, target) {
+ registerKeepAliveHook(hook, "a" /* LifecycleHooks.ACTIVATED */, target);
+ }
+ function onDeactivated(hook, target) {
+ registerKeepAliveHook(hook, "da" /* LifecycleHooks.DEACTIVATED */, target);
+ }
+ function registerKeepAliveHook(hook, type, target = currentInstance) {
+ // cache the deactivate branch check wrapper for injected hooks so the same
+ // hook can be properly deduped by the scheduler. "__wdc" stands for "with
+ // deactivation check".
+ const wrappedHook = hook.__wdc ||
+ (hook.__wdc = () => {
+ // only fire the hook if the target instance is NOT in a deactivated branch.
+ let current = target;
+ while (current) {
+ if (current.isDeactivated) {
+ return;
+ }
+ current = current.parent;
+ }
+ return hook();
+ });
+ injectHook(type, wrappedHook, target);
+ // In addition to registering it on the target instance, we walk up the parent
+ // chain and register it on all ancestor instances that are keep-alive roots.
+ // This avoids the need to walk the entire component tree when invoking these
+ // hooks, and more importantly, avoids the need to track child components in
+ // arrays.
+ if (target) {
+ let current = target.parent;
+ while (current && current.parent) {
+ if (isKeepAlive(current.parent.vnode)) {
+ injectToKeepAliveRoot(wrappedHook, type, target, current);
+ }
+ current = current.parent;
+ }
+ }
+ }
+ function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
+ // injectHook wraps the original for error handling, so make sure to remove
+ // the wrapped version.
+ const injected = injectHook(type, hook, keepAliveRoot, true /* prepend */);
+ onUnmounted(() => {
+ remove(keepAliveRoot[type], injected);
+ }, target);
+ }
+ function resetShapeFlag(vnode) {
+ // bitwise operations to remove keep alive flags
+ vnode.shapeFlag &= ~256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */;
+ vnode.shapeFlag &= ~512 /* ShapeFlags.COMPONENT_KEPT_ALIVE */;
+ }
+ function getInnerChild(vnode) {
+ return vnode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */ ? vnode.ssContent : vnode;
+ }
+
+ function injectHook(type, hook, target = currentInstance, prepend = false) {
+ if (target) {
+ const hooks = target[type] || (target[type] = []);
+ // cache the error handling wrapper for injected hooks so the same hook
+ // can be properly deduped by the scheduler. "__weh" stands for "with error
+ // handling".
+ const wrappedHook = hook.__weh ||
+ (hook.__weh = (...args) => {
+ if (target.isUnmounted) {
+ return;
+ }
+ // disable tracking inside all lifecycle hooks
+ // since they can potentially be called inside effects.
+ pauseTracking();
+ // Set currentInstance during hook invocation.
+ // This assumes the hook does not synchronously trigger other hooks, which
+ // can only be false when the user does something really funky.
+ setCurrentInstance(target);
+ const res = callWithAsyncErrorHandling(hook, target, type, args);
+ unsetCurrentInstance();
+ resetTracking();
+ return res;
+ });
+ if (prepend) {
+ hooks.unshift(wrappedHook);
+ }
+ else {
+ hooks.push(wrappedHook);
+ }
+ return wrappedHook;
+ }
+ else {
+ const apiName = toHandlerKey(ErrorTypeStrings[type].replace(/ hook$/, ''));
+ warn$1(`${apiName} is called when there is no active component instance to be ` +
+ `associated with. ` +
+ `Lifecycle injection APIs can only be used during execution of setup().` +
+ (` If you are using async setup(), make sure to register lifecycle ` +
+ `hooks before the first await statement.`
+ ));
+ }
+ }
+ const createHook = (lifecycle) => (hook, target = currentInstance) =>
+ // post-create lifecycle registrations are noops during SSR (except for serverPrefetch)
+ (!isInSSRComponentSetup || lifecycle === "sp" /* LifecycleHooks.SERVER_PREFETCH */) &&
+ injectHook(lifecycle, (...args) => hook(...args), target);
+ const onBeforeMount = createHook("bm" /* LifecycleHooks.BEFORE_MOUNT */);
+ const onMounted = createHook("m" /* LifecycleHooks.MOUNTED */);
+ const onBeforeUpdate = createHook("bu" /* LifecycleHooks.BEFORE_UPDATE */);
+ const onUpdated = createHook("u" /* LifecycleHooks.UPDATED */);
+ const onBeforeUnmount = createHook("bum" /* LifecycleHooks.BEFORE_UNMOUNT */);
+ const onUnmounted = createHook("um" /* LifecycleHooks.UNMOUNTED */);
+ const onServerPrefetch = createHook("sp" /* LifecycleHooks.SERVER_PREFETCH */);
+ const onRenderTriggered = createHook("rtg" /* LifecycleHooks.RENDER_TRIGGERED */);
+ const onRenderTracked = createHook("rtc" /* LifecycleHooks.RENDER_TRACKED */);
+ function onErrorCaptured(hook, target = currentInstance) {
+ injectHook("ec" /* LifecycleHooks.ERROR_CAPTURED */, hook, target);
+ }
+
+ /**
+ Runtime helper for applying directives to a vnode. Example usage:
+
+ const comp = resolveComponent('comp')
+ const foo = resolveDirective('foo')
+ const bar = resolveDirective('bar')
+
+ return withDirectives(h(comp), [
+ [foo, this.x],
+ [bar, this.y]
+ ])
+ */
+ function validateDirectiveName(name) {
+ if (isBuiltInDirective(name)) {
+ warn$1('Do not use built-in directive ids as custom directive id: ' + name);
+ }
+ }
+ /**
+ * Adds directives to a VNode.
+ */
+ function withDirectives(vnode, directives) {
+ const internalInstance = currentRenderingInstance;
+ if (internalInstance === null) {
+ warn$1(`withDirectives can only be used inside render functions.`);
+ return vnode;
+ }
+ const instance = getExposeProxy(internalInstance) ||
+ internalInstance.proxy;
+ const bindings = vnode.dirs || (vnode.dirs = []);
+ for (let i = 0; i < directives.length; i++) {
+ let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
+ if (dir) {
+ if (isFunction(dir)) {
+ dir = {
+ mounted: dir,
+ updated: dir
+ };
+ }
+ if (dir.deep) {
+ traverse(value);
+ }
+ bindings.push({
+ dir,
+ instance,
+ value,
+ oldValue: void 0,
+ arg,
+ modifiers
+ });
+ }
+ }
+ return vnode;
+ }
+ function invokeDirectiveHook(vnode, prevVNode, instance, name) {
+ const bindings = vnode.dirs;
+ const oldBindings = prevVNode && prevVNode.dirs;
+ for (let i = 0; i < bindings.length; i++) {
+ const binding = bindings[i];
+ if (oldBindings) {
+ binding.oldValue = oldBindings[i].value;
+ }
+ let hook = binding.dir[name];
+ if (hook) {
+ // disable tracking inside all lifecycle hooks
+ // since they can potentially be called inside effects.
+ pauseTracking();
+ callWithAsyncErrorHandling(hook, instance, 8 /* ErrorCodes.DIRECTIVE_HOOK */, [
+ vnode.el,
+ binding,
+ vnode,
+ prevVNode
+ ]);
+ resetTracking();
+ }
+ }
+ }
+
+ const COMPONENTS = 'components';
+ const DIRECTIVES = 'directives';
+ /**
+ * @private
+ */
+ function resolveComponent(name, maybeSelfReference) {
+ return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
+ }
+ const NULL_DYNAMIC_COMPONENT = Symbol();
+ /**
+ * @private
+ */
+ function resolveDynamicComponent(component) {
+ if (isString(component)) {
+ return resolveAsset(COMPONENTS, component, false) || component;
+ }
+ else {
+ // invalid types will fallthrough to createVNode and raise warning
+ return (component || NULL_DYNAMIC_COMPONENT);
+ }
+ }
+ /**
+ * @private
+ */
+ function resolveDirective(name) {
+ return resolveAsset(DIRECTIVES, name);
+ }
+ // implementation
+ function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
+ const instance = currentRenderingInstance || currentInstance;
+ if (instance) {
+ const Component = instance.type;
+ // explicit self name has highest priority
+ if (type === COMPONENTS) {
+ const selfName = getComponentName(Component, false /* do not include inferred name to avoid breaking existing code */);
+ if (selfName &&
+ (selfName === name ||
+ selfName === camelize(name) ||
+ selfName === capitalize(camelize(name)))) {
+ return Component;
+ }
+ }
+ const res =
+ // local registration
+ // check instance[type] first which is resolved for options API
+ resolve(instance[type] || Component[type], name) ||
+ // global registration
+ resolve(instance.appContext[type], name);
+ if (!res && maybeSelfReference) {
+ // fallback to implicit self-reference
+ return Component;
+ }
+ if (warnMissing && !res) {
+ const extra = type === COMPONENTS
+ ? `\nIf this is a native custom element, make sure to exclude it from ` +
+ `component resolution via compilerOptions.isCustomElement.`
+ : ``;
+ warn$1(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`);
+ }
+ return res;
+ }
+ else {
+ warn$1(`resolve${capitalize(type.slice(0, -1))} ` +
+ `can only be used in render() or setup().`);
+ }
+ }
+ function resolve(registry, name) {
+ return (registry &&
+ (registry[name] ||
+ registry[camelize(name)] ||
+ registry[capitalize(camelize(name))]));
+ }
+
+ /**
+ * Actual implementation
+ */
+ function renderList(source, renderItem, cache, index) {
+ let ret;
+ const cached = (cache && cache[index]);
+ if (isArray(source) || isString(source)) {
+ ret = new Array(source.length);
+ for (let i = 0, l = source.length; i < l; i++) {
+ ret[i] = renderItem(source[i], i, undefined, cached && cached[i]);
+ }
+ }
+ else if (typeof source === 'number') {
+ if (!Number.isInteger(source)) {
+ warn$1(`The v-for range expect an integer value but got ${source}.`);
+ }
+ ret = new Array(source);
+ for (let i = 0; i < source; i++) {
+ ret[i] = renderItem(i + 1, i, undefined, cached && cached[i]);
+ }
+ }
+ else if (isObject(source)) {
+ if (source[Symbol.iterator]) {
+ ret = Array.from(source, (item, i) => renderItem(item, i, undefined, cached && cached[i]));
+ }
+ else {
+ const keys = Object.keys(source);
+ ret = new Array(keys.length);
+ for (let i = 0, l = keys.length; i < l; i++) {
+ const key = keys[i];
+ ret[i] = renderItem(source[key], key, i, cached && cached[i]);
+ }
+ }
+ }
+ else {
+ ret = [];
+ }
+ if (cache) {
+ cache[index] = ret;
+ }
+ return ret;
+ }
+
+ /**
+ * Compiler runtime helper for creating dynamic slots object
+ * @private
+ */
+ function createSlots(slots, dynamicSlots) {
+ for (let i = 0; i < dynamicSlots.length; i++) {
+ const slot = dynamicSlots[i];
+ // array of dynamic slot generated by
+ if (isArray(slot)) {
+ for (let j = 0; j < slot.length; j++) {
+ slots[slot[j].name] = slot[j].fn;
+ }
+ }
+ else if (slot) {
+ // conditional single slot generated by
+ slots[slot.name] = slot.key
+ ? (...args) => {
+ const res = slot.fn(...args);
+ // attach branch key so each conditional branch is considered a
+ // different fragment
+ if (res)
+ res.key = slot.key;
+ return res;
+ }
+ : slot.fn;
+ }
+ }
+ return slots;
+ }
+
+ /**
+ * Compiler runtime helper for rendering ` `
+ * @private
+ */
+ function renderSlot(slots, name, props = {},
+ // this is not a user-facing function, so the fallback is always generated by
+ // the compiler and guaranteed to be a function returning an array
+ fallback, noSlotted) {
+ if (currentRenderingInstance.isCE ||
+ (currentRenderingInstance.parent &&
+ isAsyncWrapper(currentRenderingInstance.parent) &&
+ currentRenderingInstance.parent.isCE)) {
+ if (name !== 'default')
+ props.name = name;
+ return createVNode('slot', props, fallback && fallback());
+ }
+ let slot = slots[name];
+ if (slot && slot.length > 1) {
+ warn$1(`SSR-optimized slot function detected in a non-SSR-optimized render ` +
+ `function. You need to mark this component with $dynamic-slots in the ` +
+ `parent template.`);
+ slot = () => [];
+ }
+ // a compiled slot disables block tracking by default to avoid manual
+ // invocation interfering with template-based block tracking, but in
+ // `renderSlot` we can be sure that it's template-based so we can force
+ // enable it.
+ if (slot && slot._c) {
+ slot._d = false;
+ }
+ openBlock();
+ const validSlotContent = slot && ensureValidVNode(slot(props));
+ const rendered = createBlock(Fragment, {
+ key: props.key ||
+ // slot content array of a dynamic conditional slot may have a branch
+ // key attached in the `createSlots` helper, respect that
+ (validSlotContent && validSlotContent.key) ||
+ `_${name}`
+ }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 /* SlotFlags.STABLE */
+ ? 64 /* PatchFlags.STABLE_FRAGMENT */
+ : -2 /* PatchFlags.BAIL */);
+ if (!noSlotted && rendered.scopeId) {
+ rendered.slotScopeIds = [rendered.scopeId + '-s'];
+ }
+ if (slot && slot._c) {
+ slot._d = true;
+ }
+ return rendered;
+ }
+ function ensureValidVNode(vnodes) {
+ return vnodes.some(child => {
+ if (!isVNode(child))
+ return true;
+ if (child.type === Comment)
+ return false;
+ if (child.type === Fragment &&
+ !ensureValidVNode(child.children))
+ return false;
+ return true;
+ })
+ ? vnodes
+ : null;
+ }
+
+ /**
+ * For prefixing keys in v-on="obj" with "on"
+ * @private
+ */
+ function toHandlers(obj, preserveCaseIfNecessary) {
+ const ret = {};
+ if (!isObject(obj)) {
+ warn$1(`v-on with no argument expects an object value.`);
+ return ret;
+ }
+ for (const key in obj) {
+ ret[preserveCaseIfNecessary && /[A-Z]/.test(key)
+ ? `on:${key}`
+ : toHandlerKey(key)] = obj[key];
+ }
+ return ret;
+ }
+
+ /**
+ * #2437 In Vue 3, functional components do not have a public instance proxy but
+ * they exist in the internal parent chain. For code that relies on traversing
+ * public $parent chains, skip functional ones and go to the parent instead.
+ */
+ const getPublicInstance = (i) => {
+ if (!i)
+ return null;
+ if (isStatefulComponent(i))
+ return getExposeProxy(i) || i.proxy;
+ return getPublicInstance(i.parent);
+ };
+ const publicPropertiesMap =
+ // Move PURE marker to new line to workaround compiler discarding it
+ // due to type annotation
+ /*#__PURE__*/ extend(Object.create(null), {
+ $: i => i,
+ $el: i => i.vnode.el,
+ $data: i => i.data,
+ $props: i => (shallowReadonly(i.props) ),
+ $attrs: i => (shallowReadonly(i.attrs) ),
+ $slots: i => (shallowReadonly(i.slots) ),
+ $refs: i => (shallowReadonly(i.refs) ),
+ $parent: i => getPublicInstance(i.parent),
+ $root: i => getPublicInstance(i.root),
+ $emit: i => i.emit,
+ $options: i => (resolveMergedOptions(i) ),
+ $forceUpdate: i => i.f || (i.f = () => queueJob(i.update)),
+ $nextTick: i => i.n || (i.n = nextTick.bind(i.proxy)),
+ $watch: i => (instanceWatch.bind(i) )
+ });
+ const isReservedPrefix = (key) => key === '_' || key === '$';
+ const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
+ const PublicInstanceProxyHandlers = {
+ get({ _: instance }, key) {
+ const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
+ // for internal formatters to know that this is a Vue instance
+ if (key === '__isVue') {
+ return true;
+ }
+ // data / props / ctx
+ // This getter gets called for every property access on the render context
+ // during render and is a major hotspot. The most expensive part of this
+ // is the multiple hasOwn() calls. It's much faster to do a simple property
+ // access on a plain object, so we use an accessCache object (with null
+ // prototype) to memoize what access type a key corresponds to.
+ let normalizedProps;
+ if (key[0] !== '$') {
+ const n = accessCache[key];
+ if (n !== undefined) {
+ switch (n) {
+ case 1 /* AccessTypes.SETUP */:
+ return setupState[key];
+ case 2 /* AccessTypes.DATA */:
+ return data[key];
+ case 4 /* AccessTypes.CONTEXT */:
+ return ctx[key];
+ case 3 /* AccessTypes.PROPS */:
+ return props[key];
+ // default: just fallthrough
+ }
+ }
+ else if (hasSetupBinding(setupState, key)) {
+ accessCache[key] = 1 /* AccessTypes.SETUP */;
+ return setupState[key];
+ }
+ else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+ accessCache[key] = 2 /* AccessTypes.DATA */;
+ return data[key];
+ }
+ else if (
+ // only cache other properties when instance has declared (thus stable)
+ // props
+ (normalizedProps = instance.propsOptions[0]) &&
+ hasOwn(normalizedProps, key)) {
+ accessCache[key] = 3 /* AccessTypes.PROPS */;
+ return props[key];
+ }
+ else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+ accessCache[key] = 4 /* AccessTypes.CONTEXT */;
+ return ctx[key];
+ }
+ else if (shouldCacheAccess) {
+ accessCache[key] = 0 /* AccessTypes.OTHER */;
+ }
+ }
+ const publicGetter = publicPropertiesMap[key];
+ let cssModule, globalProperties;
+ // public $xxx properties
+ if (publicGetter) {
+ if (key === '$attrs') {
+ track(instance, "get" /* TrackOpTypes.GET */, key);
+ markAttrsAccessed();
+ }
+ return publicGetter(instance);
+ }
+ else if (
+ // css module (injected by vue-loader)
+ (cssModule = type.__cssModules) &&
+ (cssModule = cssModule[key])) {
+ return cssModule;
+ }
+ else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+ // user may set custom properties to `this` that start with `$`
+ accessCache[key] = 4 /* AccessTypes.CONTEXT */;
+ return ctx[key];
+ }
+ else if (
+ // global properties
+ ((globalProperties = appContext.config.globalProperties),
+ hasOwn(globalProperties, key))) {
+ {
+ return globalProperties[key];
+ }
+ }
+ else if (currentRenderingInstance &&
+ (!isString(key) ||
+ // #1091 avoid internal isRef/isVNode checks on component instance leading
+ // to infinite warning loop
+ key.indexOf('__v') !== 0)) {
+ if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn(data, key)) {
+ warn$1(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +
+ `character ("$" or "_") and is not proxied on the render context.`);
+ }
+ else if (instance === currentRenderingInstance) {
+ warn$1(`Property ${JSON.stringify(key)} was accessed during render ` +
+ `but is not defined on instance.`);
+ }
+ }
+ },
+ set({ _: instance }, key, value) {
+ const { data, setupState, ctx } = instance;
+ if (hasSetupBinding(setupState, key)) {
+ setupState[key] = value;
+ return true;
+ }
+ else if (setupState.__isScriptSetup &&
+ hasOwn(setupState, key)) {
+ warn$1(`Cannot mutate