|
|
@@ -0,0 +1,928 @@
|
|
|
+import{s as e,u as t,av as n,n as r,p as o,d as a,X as s,m as c,af as l,B as i,h as u,i as f}from"./@vue-37836d09.js";
|
|
|
+/*!
|
|
|
+ * vue-router v4.5.0
|
|
|
+ * (c) 2024 Eduardo San Martin Morote
|
|
|
+ * @license MIT
|
|
|
+ */const p="undefined"!=typeof document;
|
|
|
+/**
|
|
|
+ * Allows differentiating lazy components from functional components and vue-class-component
|
|
|
+ * @internal
|
|
|
+ *
|
|
|
+ * @param component
|
|
|
+ */function h(e){return"object"==typeof e||"displayName"in e||"props"in e||"__vccOpts"in e}const d=Object.assign;function m(e,t){const n={};for(const r in t){const o=t[r];n[r]=v(o)?o.map(e):e(o)}return n}const g=()=>{},v=Array.isArray,y=/#/g,b=/&/g,w=/\//g,E=/=/g,R=/\?/g,k=/\+/g,O=/%5B/g,x=/%5D/g,P=/%5E/g,C=/%60/g,j=/%7B/g,$=/%7C/g,S=/%7D/g,A=/%20/g;
|
|
|
+/**
|
|
|
+ * Typesafe alternative to Array.isArray
|
|
|
+ * https://github.com/microsoft/TypeScript/pull/48228
|
|
|
+ */ // }
|
|
|
+/**
|
|
|
+ * Encode characters that need to be encoded on the path, search and hash
|
|
|
+ * sections of the URL.
|
|
|
+ *
|
|
|
+ * @internal
|
|
|
+ * @param text - string to encode
|
|
|
+ * @returns encoded string
|
|
|
+ */
|
|
|
+function q(e){return encodeURI(""+e).replace($,"|").replace(O,"[").replace(x,"]")}
|
|
|
+/**
|
|
|
+ * Encode characters that need to be encoded on the hash section of the URL.
|
|
|
+ *
|
|
|
+ * @param text - string to encode
|
|
|
+ * @returns encoded string
|
|
|
+ */
|
|
|
+/**
|
|
|
+ * Encode characters that need to be encoded query values on the query
|
|
|
+ * section of the URL.
|
|
|
+ *
|
|
|
+ * @param text - string to encode
|
|
|
+ * @returns encoded string
|
|
|
+ */
|
|
|
+function L(e){return q(e).replace(k,"%2B").replace(A,"+").replace(y,"%23").replace(b,"%26").replace(C,"`").replace(j,"{").replace(S,"}").replace(P,"^")}
|
|
|
+/**
|
|
|
+ * Like `encodeQueryValue` but also encodes the `=` character.
|
|
|
+ *
|
|
|
+ * @param text - string to encode
|
|
|
+ */
|
|
|
+/**
|
|
|
+ * Encode characters that need to be encoded on the path section of the URL as a
|
|
|
+ * param. This function encodes everything {@link encodePath} does plus the
|
|
|
+ * slash (`/`) character. If `text` is `null` or `undefined`, returns an empty
|
|
|
+ * string instead.
|
|
|
+ *
|
|
|
+ * @param text - string to encode
|
|
|
+ * @returns encoded string
|
|
|
+ */
|
|
|
+function M(e){return null==e?"":
|
|
|
+/**
|
|
|
+ * Encode characters that need to be encoded on the path section of the URL.
|
|
|
+ *
|
|
|
+ * @param text - string to encode
|
|
|
+ * @returns encoded string
|
|
|
+ */
|
|
|
+function(e){return q(e).replace(y,"%23").replace(R,"%3F")}(e).replace(w,"%2F")}
|
|
|
+/**
|
|
|
+ * Decode text using `decodeURIComponent`. Returns the original text if it
|
|
|
+ * fails.
|
|
|
+ *
|
|
|
+ * @param text - string to decode
|
|
|
+ * @returns decoded string
|
|
|
+ */function B(e){try{return decodeURIComponent(""+e)}catch(t){}return""+e}const G=/\/$/;
|
|
|
+/**
|
|
|
+ * Transforms a URI into a normalized history location
|
|
|
+ *
|
|
|
+ * @param parseQuery
|
|
|
+ * @param location - URI to normalize
|
|
|
+ * @param currentLocation - current absolute location. Allows resolving relative
|
|
|
+ * paths. Must start with `/`. Defaults to `/`
|
|
|
+ * @returns a normalized history location
|
|
|
+ */
|
|
|
+function _(e,t,n="/"){let r,o={},a="",s="";
|
|
|
+// Could use URL and URLSearchParams but IE 11 doesn't support it
|
|
|
+// TODO: move to new URL()
|
|
|
+const c=t.indexOf("#");let l=t.indexOf("?");
|
|
|
+// the hash appears before the search, so it's not part of the search string
|
|
|
+// empty path means a relative query or hash `?foo=f`, `#thing`
|
|
|
+return c<l&&c>=0&&(l=-1),l>-1&&(r=t.slice(0,l),a=t.slice(l+1,c>-1?c:t.length),o=e(a)),c>-1&&(r=r||t.slice(0,c),
|
|
|
+// keep the # character
|
|
|
+s=t.slice(c,t.length)),
|
|
|
+// no search and no query
|
|
|
+r=
|
|
|
+/**
|
|
|
+ * Resolves a relative path that starts with `.`.
|
|
|
+ *
|
|
|
+ * @param to - path location we are resolving
|
|
|
+ * @param from - currentLocation.path, should start with `/`
|
|
|
+ */
|
|
|
+function(e,t){if(e.startsWith("/"))return e;if(!e)return t;const n=t.split("/"),r=e.split("/"),o=r[r.length-1];
|
|
|
+// make . and ./ the same (../ === .., ../../ === ../..)
|
|
|
+// this is the same behavior as new URL()
|
|
|
+".."!==o&&"."!==o||r.push("");let a,s,c=n.length-1;for(a=0;a<r.length;a++)
|
|
|
+// we stay on the same position
|
|
|
+if(s=r[a],"."!==s){
|
|
|
+// go up in the from array
|
|
|
+if(".."!==s)break;
|
|
|
+// we can't go below zero, but we still need to increment toPosition
|
|
|
+c>1&&c--;
|
|
|
+// continue
|
|
|
+}return n.slice(0,c).join("/")+"/"+r.slice(a).join("/")}
|
|
|
+/**
|
|
|
+ * Initial route location where the router is. Can be used in navigation guards
|
|
|
+ * to differentiate the initial navigation.
|
|
|
+ *
|
|
|
+ * @example
|
|
|
+ * ```js
|
|
|
+ * import { START_LOCATION } from 'vue-router'
|
|
|
+ *
|
|
|
+ * router.beforeEach((to, from) => {
|
|
|
+ * if (from === START_LOCATION) {
|
|
|
+ * // initial navigation
|
|
|
+ * }
|
|
|
+ * })
|
|
|
+ * ```
|
|
|
+ */(null!=r?r:t,n),{fullPath:r+(a&&"?")+a+s,path:r,query:o,hash:B(s)}}
|
|
|
+/**
|
|
|
+ * Stringifies a URL object
|
|
|
+ *
|
|
|
+ * @param stringifyQuery
|
|
|
+ * @param location
|
|
|
+ */
|
|
|
+/**
|
|
|
+ * Strips off the base from the beginning of a location.pathname in a non-case-sensitive way.
|
|
|
+ *
|
|
|
+ * @param pathname - location.pathname
|
|
|
+ * @param base - base to strip off
|
|
|
+ */
|
|
|
+function I(e,t){
|
|
|
+// no base or base is not found at the beginning
|
|
|
+return t&&e.toLowerCase().startsWith(t.toLowerCase())?e.slice(t.length)||"/":e}
|
|
|
+/**
|
|
|
+ * Checks if two RouteLocation are equal. This means that both locations are
|
|
|
+ * pointing towards the same {@link RouteRecord} and that all `params`, `query`
|
|
|
+ * parameters and `hash` are the same
|
|
|
+ *
|
|
|
+ * @param stringifyQuery - A function that takes a query object of type LocationQueryRaw and returns a string representation of it.
|
|
|
+ * @param a - first {@link RouteLocation}
|
|
|
+ * @param b - second {@link RouteLocation}
|
|
|
+ */
|
|
|
+/**
|
|
|
+ * Check if two `RouteRecords` are equal. Takes into account aliases: they are
|
|
|
+ * considered equal to the `RouteRecord` they are aliasing.
|
|
|
+ *
|
|
|
+ * @param a - first {@link RouteRecord}
|
|
|
+ * @param b - second {@link RouteRecord}
|
|
|
+ */
|
|
|
+function T(e,t){
|
|
|
+// since the original record has an undefined value for aliasOf
|
|
|
+// but all aliases point to the original record, this will always compare
|
|
|
+// the original record
|
|
|
+return(e.aliasOf||e)===(t.aliasOf||t)}function W(e,t){if(Object.keys(e).length!==Object.keys(t).length)return!1;for(const n in e)if(!D(e[n],t[n]))return!1;return!0}function D(e,t){return v(e)?U(e,t):v(t)?U(t,e):e===t}
|
|
|
+/**
|
|
|
+ * Check if two arrays are the same or if an array with one single entry is the
|
|
|
+ * same as another primitive value. Used to check query and parameters
|
|
|
+ *
|
|
|
+ * @param a - array of values
|
|
|
+ * @param b - array of values or a single value
|
|
|
+ */function U(e,t){return v(t)?e.length===t.length&&e.every(((e,n)=>e===t[n])):1===e.length&&e[0]===t}const V={path:"/",
|
|
|
+// TODO: could we use a symbol in the future?
|
|
|
+name:void 0,params:{},query:{},hash:"",fullPath:"/",matched:[],meta:{},redirectedFrom:void 0};var F,z;
|
|
|
+// Generic utils
|
|
|
+/**
|
|
|
+ * Normalizes a base by removing any trailing slash and reading the base tag if
|
|
|
+ * present.
|
|
|
+ *
|
|
|
+ * @param base - base to normalize
|
|
|
+ */
|
|
|
+function K(e){if(!e)if(p){
|
|
|
+// respect <base> tag
|
|
|
+const t=document.querySelector("base");
|
|
|
+// strip full URL origin
|
|
|
+e=(e=t&&t.getAttribute("href")||"/").replace(/^\w+:\/\/[^\/]+/,"")}else e="/";
|
|
|
+// ensure leading slash when it was removed by the regex above avoid leading
|
|
|
+// slash with hash because the file could be read from the disk like file://
|
|
|
+// and the leading slash would cause problems
|
|
|
+// remove the trailing slash so all other method can just do `base + fullPath`
|
|
|
+// to build an href
|
|
|
+return"/"!==e[0]&&"#"!==e[0]&&(e="/"+e),e.replace(G,"")}
|
|
|
+// remove any character before the hash
|
|
|
+!function(e){e.pop="pop",e.push="push"}(F||(F={})),function(e){e.back="back",e.forward="forward",e.unknown=""}(z||(z={}));const H=/^[^#]+#/;function X(e,t){return e.replace(H,"#")+t}const Q=()=>({left:window.scrollX,top:window.scrollY});function Y(e){let t;if("el"in e){const n=e.el,r="string"==typeof n&&n.startsWith("#"),o="string"==typeof n?r?document.getElementById(n.slice(1)):document.querySelector(n):n;if(!o)return;t=function(e,t){const n=document.documentElement.getBoundingClientRect(),r=e.getBoundingClientRect();return{behavior:t.behavior,left:r.left-n.left-(t.left||0),top:r.top-n.top-(t.top||0)}}(o,e)}else t=e;"scrollBehavior"in document.documentElement.style?window.scrollTo(t):window.scrollTo(null!=t.left?t.left:window.scrollX,null!=t.top?t.top:window.scrollY)}function N(e,t){return(history.state?history.state.position-t:-1)+e}const Z=new Map;
|
|
|
+// TODO: RFC about how to save scroll position
|
|
|
+/**
|
|
|
+ * ScrollBehavior instance used by the router to compute and restore the scroll
|
|
|
+ * position when navigating.
|
|
|
+ */
|
|
|
+// export interface ScrollHandler<ScrollPositionEntry extends HistoryStateValue, ScrollPosition extends ScrollPositionEntry> {
|
|
|
+// // returns a scroll position that can be saved in history
|
|
|
+// compute(): ScrollPositionEntry
|
|
|
+// // can take an extended ScrollPositionEntry
|
|
|
+// scroll(position: ScrollPosition): void
|
|
|
+// }
|
|
|
+// export const scrollHandler: ScrollHandler<ScrollPosition> = {
|
|
|
+// compute: computeScroll,
|
|
|
+// scroll: scrollToPosition,
|
|
|
+// }
|
|
|
+let J=()=>location.protocol+"//"+location.host
|
|
|
+/**
|
|
|
+ * Creates a normalized history location from a window.location object
|
|
|
+ * @param base - The base path
|
|
|
+ * @param location - The window.location object
|
|
|
+ */;function ee(e,t){const{pathname:n,search:r,hash:o}=t,a=e.indexOf("#");
|
|
|
+// allows hash bases like #, /#, #/, #!, #!/, /#!/, or even /folder#end
|
|
|
+if(a>-1){let t=o.includes(e.slice(a))?e.slice(a).length:1,n=o.slice(t);
|
|
|
+// prepend the starting slash to hash so the url starts with /#
|
|
|
+return"/"!==n[0]&&(n="/"+n),I(n,"")}return I(n,e)+r+o}
|
|
|
+/**
|
|
|
+ * Creates a state object
|
|
|
+ */
|
|
|
+function te(e,t,n,r=!1,o=!1){return{back:e,current:t,forward:n,replaced:r,position:window.history.length,scroll:o?Q():null}}
|
|
|
+/**
|
|
|
+ * Creates an HTML5 history. Most common history for single page applications.
|
|
|
+ *
|
|
|
+ * @param base -
|
|
|
+ */
|
|
|
+function ne(e){const t=function(e){const{history:t,location:n}=window,r={value:ee(e,n)},o={value:t.state};
|
|
|
+// private variables
|
|
|
+function a(r,a,s){
|
|
|
+/**
|
|
|
+ * if a base tag is provided, and we are on a normal domain, we have to
|
|
|
+ * respect the provided `base` attribute because pushState() will use it and
|
|
|
+ * potentially erase anything before the `#` like at
|
|
|
+ * https://github.com/vuejs/router/issues/685 where a base of
|
|
|
+ * `/folder/#` but a base of `/` would erase the `/folder/` section. If
|
|
|
+ * there is no host, the `<base>` tag makes no sense and if there isn't a
|
|
|
+ * base tag we can just use everything after the `#`.
|
|
|
+ */
|
|
|
+const c=e.indexOf("#"),l=c>-1?(n.host&&document.querySelector("base")?e:e.slice(c))+r:J()+e+r;try{
|
|
|
+// BROWSER QUIRK
|
|
|
+// NOTE: Safari throws a SecurityError when calling this function 100 times in 30 seconds
|
|
|
+t[s?"replaceState":"pushState"](a,"",l),o.value=a}catch(i){
|
|
|
+// Force the navigation, this also resets the call count
|
|
|
+n[s?"replace":"assign"](l)}}
|
|
|
+// build current history entry as this is a fresh navigation
|
|
|
+return o.value||a(r.value,{back:null,current:r.value,forward:null,
|
|
|
+// the length is off by one, we need to decrease it
|
|
|
+position:t.length-1,replaced:!0,
|
|
|
+// don't add a scroll as the user may have an anchor, and we want
|
|
|
+// scrollBehavior to be triggered without a saved position
|
|
|
+scroll:null},!0),{location:r,state:o,push:function(e,n){
|
|
|
+// Add to current entry the information of where we are going
|
|
|
+// as well as saving the current position
|
|
|
+const s=d({},
|
|
|
+// use current history state to gracefully handle a wrong call to
|
|
|
+// history.replaceState
|
|
|
+// https://github.com/vuejs/router/issues/366
|
|
|
+o.value,t.state,{forward:e,scroll:Q()});a(s.current,s,!0),a(e,d({},te(r.value,e,null),{position:s.position+1},n),!1),r.value=e},replace:function(e,n){a(e,d({},t.state,te(o.value.back,
|
|
|
+// keep back and forward entries but override current position
|
|
|
+e,o.value.forward,!0),n,{position:o.value.position}),!0),r.value=e}}}(e=K(e)),n=function(e,t,n,r){let o=[],a=[],s=null;const c=({state:a})=>{const c=ee(e,location),l=n.value,i=t.value;let u=0;if(a){
|
|
|
+// ignore the popstate and reset the pauseState
|
|
|
+if(n.value=c,t.value=a,s&&s===l)return void(s=null);u=i?a.position-i.position:0}else r(c);
|
|
|
+// Here we could also revert the navigation by calling history.go(-delta)
|
|
|
+// this listener will have to be adapted to not trigger again and to wait for the url
|
|
|
+// to be updated before triggering the listeners. Some kind of validation function would also
|
|
|
+// need to be passed to the listeners so the navigation can be accepted
|
|
|
+// call all listeners
|
|
|
+o.forEach((e=>{e(n.value,l,{delta:u,type:F.pop,direction:u?u>0?z.forward:z.back:z.unknown})}))};function l(){const{history:e}=window;e.state&&e.replaceState(d({},e.state,{scroll:Q()}),"")}
|
|
|
+// set up the listeners and prepare teardown callbacks
|
|
|
+return window.addEventListener("popstate",c),
|
|
|
+// TODO: could we use 'pagehide' or 'visibilitychange' instead?
|
|
|
+// https://developer.chrome.com/blog/page-lifecycle-api/
|
|
|
+window.addEventListener("beforeunload",l,{passive:!0}),{pauseListeners:function(){s=n.value},listen:function(e){
|
|
|
+// set up the listener and prepare teardown callbacks
|
|
|
+o.push(e);const t=()=>{const t=o.indexOf(e);t>-1&&o.splice(t,1)};return a.push(t),t},destroy:function(){for(const e of a)e();a=[],window.removeEventListener("popstate",c),window.removeEventListener("beforeunload",l)}}}(e,t.state,t.location,t.replace);const r=d({
|
|
|
+// it's overridden right after
|
|
|
+location:"",base:e,go:function(e,t=!0){t||n.pauseListeners(),history.go(e)},createHref:X.bind(null,e)},t,n);return Object.defineProperty(r,"location",{enumerable:!0,get:()=>t.location.value}),Object.defineProperty(r,"state",{enumerable:!0,get:()=>t.state.value}),r}function re(e){return"string"==typeof e||"symbol"==typeof e}const oe=Symbol("");
|
|
|
+/**
|
|
|
+ * Enumeration with all possible types for navigation failures. Can be passed to
|
|
|
+ * {@link isNavigationFailure} to check for specific failures.
|
|
|
+ */var ae;
|
|
|
+/**
|
|
|
+ * Creates a typed NavigationFailure object.
|
|
|
+ * @internal
|
|
|
+ * @param type - NavigationFailureType
|
|
|
+ * @param params - { from, to }
|
|
|
+ */
|
|
|
+function se(e,t){return d(new Error,{type:e,[oe]:!0},t)}function ce(e,t){return e instanceof Error&&oe in e&&(null==t||!!(e.type&t))}
|
|
|
+// default pattern for a param: non-greedy everything but /
|
|
|
+!function(e){
|
|
|
+/**
|
|
|
+ * An aborted navigation is a navigation that failed because a navigation
|
|
|
+ * guard returned `false` or called `next(false)`
|
|
|
+ */
|
|
|
+e[e.aborted=4]="aborted",
|
|
|
+/**
|
|
|
+ * A cancelled navigation is a navigation that failed because a more recent
|
|
|
+ * navigation finished started (not necessarily finished).
|
|
|
+ */
|
|
|
+e[e.cancelled=8]="cancelled",
|
|
|
+/**
|
|
|
+ * A duplicated navigation is a navigation that failed because it was
|
|
|
+ * initiated while already being at the exact same location.
|
|
|
+ */
|
|
|
+e[e.duplicated=16]="duplicated"}(ae||(ae={}));const le="[^/]+?",ie={sensitive:!1,strict:!1,start:!0,end:!0},ue=/[.+*?^${}()[\]/\\]/g;
|
|
|
+/**
|
|
|
+ * Compares an array of numbers as used in PathParser.score and returns a
|
|
|
+ * number. This function can be used to `sort` an array
|
|
|
+ *
|
|
|
+ * @param a - first array of numbers
|
|
|
+ * @param b - second array of numbers
|
|
|
+ * @returns 0 if both are equal, < 0 if a should be sorted first, > 0 if b
|
|
|
+ * should be sorted first
|
|
|
+ */
|
|
|
+function fe(e,t){let n=0;for(;n<e.length&&n<t.length;){const r=t[n]-e[n];
|
|
|
+// only keep going if diff === 0
|
|
|
+if(r)return r;n++}
|
|
|
+// if the last subsegment was Static, the shorter segments should be sorted first
|
|
|
+// otherwise sort the longest segment first
|
|
|
+return e.length<t.length?1===e.length&&80/* PathScore.Segment */===e[0]?-1:1:e.length>t.length?1===t.length&&80/* PathScore.Segment */===t[0]?1:-1:0}
|
|
|
+/**
|
|
|
+ * Compare function that can be used with `sort` to sort an array of PathParser
|
|
|
+ *
|
|
|
+ * @param a - first PathParser
|
|
|
+ * @param b - second PathParser
|
|
|
+ * @returns 0 if both are equal, < 0 if a should be sorted first, > 0 if b
|
|
|
+ */function pe(e,t){let n=0;const r=e.score,o=t.score;for(;n<r.length&&n<o.length;){const e=fe(r[n],o[n]);
|
|
|
+// do not return if both are equal
|
|
|
+if(e)return e;n++}if(1===Math.abs(o.length-r.length)){if(he(r))return 1;if(he(o))return-1}
|
|
|
+// if a and b share the same score entries but b has more, sort b first
|
|
|
+return o.length-r.length;
|
|
|
+// this is the ternary version
|
|
|
+// return aScore.length < bScore.length
|
|
|
+// ? 1
|
|
|
+// : aScore.length > bScore.length
|
|
|
+// ? -1
|
|
|
+// : 0
|
|
|
+}
|
|
|
+/**
|
|
|
+ * This allows detecting splats at the end of a path: /home/:id(.*)*
|
|
|
+ *
|
|
|
+ * @param score - score to check
|
|
|
+ * @returns true if the last entry is negative
|
|
|
+ */function he(e){const t=e[e.length-1];return e.length>0&&t[t.length-1]<0}const de={type:0/* TokenType.Static */,value:""},me=/[a-zA-Z0-9_]/;function ge(e,t,n){const r=
|
|
|
+/**
|
|
|
+ * Creates a path parser from an array of Segments (a segment is an array of Tokens)
|
|
|
+ *
|
|
|
+ * @param segments - array of segments returned by tokenizePath
|
|
|
+ * @param extraOptions - optional options for the regexp
|
|
|
+ * @returns a PathParser
|
|
|
+ */
|
|
|
+function(e,t){const n=d({},ie,t),r=[];
|
|
|
+// the amount of scores is the same as the length of segments except for the root segment "/"
|
|
|
+// the regexp as a string
|
|
|
+let o=n.start?"^":"";
|
|
|
+// extracted keys
|
|
|
+const a=[];for(const l of e){
|
|
|
+// the root segment needs special treatment
|
|
|
+const e=l.length?[]:[90/* PathScore.Root */];
|
|
|
+// allow trailing slash
|
|
|
+n.strict&&!l.length&&(o+="/");for(let t=0;t<l.length;t++){const r=l[t];
|
|
|
+// resets the score if we are inside a sub-segment /:a-other-:b
|
|
|
+let s=40/* PathScore.Segment */+(n.sensitive?.25/* PathScore.BonusCaseSensitive */:0);if(0/* TokenType.Static */===r.type)
|
|
|
+// prepend the slash if we are starting a new segment
|
|
|
+t||(o+="/"),o+=r.value.replace(ue,"\\$&"),s+=40/* PathScore.Static */;else if(1/* TokenType.Param */===r.type){const{value:e,repeatable:n,optional:i,regexp:u}=r;a.push({name:e,repeatable:n,optional:i});const f=u||le;
|
|
|
+// the user provided a custom regexp /:id(\\d+)
|
|
|
+if(f!==le){s+=10/* PathScore.BonusCustomRegExp */;
|
|
|
+// make sure the regexp is valid before using it
|
|
|
+try{new RegExp(`(${f})`)}catch(c){throw new Error(`Invalid custom RegExp for param "${e}" (${f}): `+c.message)}}
|
|
|
+// when we repeat we must take care of the repeating leading slash
|
|
|
+let p=n?`((?:${f})(?:/(?:${f}))*)`:`(${f})`;
|
|
|
+// prepend the slash if we are starting a new segment
|
|
|
+t||(p=
|
|
|
+// avoid an optional / if there are more segments e.g. /:p?-static
|
|
|
+// or /:p?-:p2
|
|
|
+i&&l.length<2?`(?:/${p})`:"/"+p),i&&(p+="?"),o+=p,s+=20/* PathScore.Dynamic */,i&&(s+=-8/* PathScore.BonusOptional */),n&&(s+=-20/* PathScore.BonusRepeatable */),".*"===f&&(s+=-50/* PathScore.BonusWildcard */)}e.push(s)}
|
|
|
+// an empty array like /home/ -> [[{home}], []]
|
|
|
+// if (!segment.length) pattern += '/'
|
|
|
+r.push(e)}
|
|
|
+// only apply the strict bonus to the last score
|
|
|
+if(n.strict&&n.end){const e=r.length-1;r[e][r[e].length-1]+=.7000000000000001/* PathScore.BonusStrict */}
|
|
|
+// TODO: dev only warn double trailing slash
|
|
|
+n.strict||(o+="/?"),n.end?o+="$":n.strict&&!o.endsWith("/")&&(o+="(?:/|$)");const s=new RegExp(o,n.sensitive?"":"i");return{re:s,score:r,keys:a,parse:function(e){const t=e.match(s),n={};if(!t)return null;for(let r=1;r<t.length;r++){const e=t[r]||"",o=a[r-1];n[o.name]=e&&o.repeatable?e.split("/"):e}return n},stringify:function(t){let n="",r=!1;
|
|
|
+// for optional parameters to allow to be empty
|
|
|
+for(const o of e){r&&n.endsWith("/")||(n+="/"),r=!1;for(const e of o)if(0/* TokenType.Static */===e.type)n+=e.value;else if(1/* TokenType.Param */===e.type){const{value:a,repeatable:s,optional:c}=e,l=a in t?t[a]:"";if(v(l)&&!s)throw new Error(`Provided param "${a}" is an array but it is not repeatable (* or + modifiers)`);const i=v(l)?l.join("/"):l;if(!i){if(!c)throw new Error(`Missing required param "${a}"`);
|
|
|
+// if we have more than one optional param like /:a?-static we don't need to care about the optional param
|
|
|
+o.length<2&&(
|
|
|
+// remove the last slash as we could be at the end
|
|
|
+n.endsWith("/")?n=n.slice(0,-1):r=!0)}n+=i}}
|
|
|
+// avoid empty path when we have multiple optional params
|
|
|
+return n||"/"}}}(
|
|
|
+// After some profiling, the cache seems to be unnecessary because tokenizePath
|
|
|
+// (the slowest part of adding a route) is very fast
|
|
|
+// const tokenCache = new Map<string, Token[][]>()
|
|
|
+function(e){if(!e)return[[]];if("/"===e)return[[de]];if(!e.startsWith("/"))throw new Error(`Invalid path "${e}"`);
|
|
|
+// if (tokenCache.has(path)) return tokenCache.get(path)!
|
|
|
+function t(e){throw new Error(`ERR (${n})/"${i}": ${e}`)}let n=0/* TokenizerState.Static */,r=n;const o=[];
|
|
|
+// the segment will always be valid because we get into the initial state
|
|
|
+// with the leading /
|
|
|
+let a;function s(){a&&o.push(a),a=[]}
|
|
|
+// index on the path
|
|
|
+let c,l=0,i="",u="";
|
|
|
+// char at index
|
|
|
+function f(){i&&(0/* TokenizerState.Static */===n?a.push({type:0/* TokenType.Static */,value:i}):1/* TokenizerState.Param */===n||2/* TokenizerState.ParamRegExp */===n||3/* TokenizerState.ParamRegExpEnd */===n?(a.length>1&&("*"===c||"+"===c)&&t(`A repeatable param (${i}) must be alone in its segment. eg: '/:ids+.`),a.push({type:1/* TokenType.Param */,value:i,regexp:u,repeatable:"*"===c||"+"===c,optional:"*"===c||"?"===c})):t("Invalid state to consume buffer"),i="")}function p(){i+=c}for(;l<e.length;)if(c=e[l++],"\\"!==c||2/* TokenizerState.ParamRegExp */===n)switch(n){case 0/* TokenizerState.Static */:"/"===c?(i&&f(),s()):":"===c?(f(),n=1/* TokenizerState.Param */):p();break;case 4/* TokenizerState.EscapeNext */:p(),n=r;break;case 1/* TokenizerState.Param */:"("===c?n=2/* TokenizerState.ParamRegExp */:me.test(c)?p():(f(),n=0/* TokenizerState.Static */,
|
|
|
+// go back one character if we were not modifying
|
|
|
+"*"!==c&&"?"!==c&&"+"!==c&&l--);break;case 2/* TokenizerState.ParamRegExp */:
|
|
|
+// TODO: is it worth handling nested regexp? like :p(?:prefix_([^/]+)_suffix)
|
|
|
+// it already works by escaping the closing )
|
|
|
+// https://paths.esm.dev/?p=AAMeJbiAwQEcDKbAoAAkP60PG2R6QAvgNaA6AFACM2ABuQBB#
|
|
|
+// is this really something people need since you can also write
|
|
|
+// /prefix_:p()_suffix
|
|
|
+")"===c?
|
|
|
+// handle the escaped )
|
|
|
+"\\"==u[u.length-1]?u=u.slice(0,-1)+c:n=3/* TokenizerState.ParamRegExpEnd */:u+=c;break;case 3/* TokenizerState.ParamRegExpEnd */:
|
|
|
+// same as finalizing a param
|
|
|
+f(),n=0/* TokenizerState.Static */,
|
|
|
+// go back one character if we were not modifying
|
|
|
+"*"!==c&&"?"!==c&&"+"!==c&&l--,u="";break;default:t("Unknown state")}else r=n,n=4/* TokenizerState.EscapeNext */;
|
|
|
+// tokenCache.set(path, tokens)
|
|
|
+return 2/* TokenizerState.ParamRegExp */===n&&t(`Unfinished custom RegExp for param "${i}"`),f(),s(),o}(e.path),n),o=d(r,{record:e,parent:t,
|
|
|
+// these needs to be populated by the parent
|
|
|
+children:[],alias:[]});return t&&!o.record.aliasOf==!t.record.aliasOf&&t.children.push(o),o}
|
|
|
+/**
|
|
|
+ * Creates a Router Matcher.
|
|
|
+ *
|
|
|
+ * @internal
|
|
|
+ * @param routes - array of initial routes
|
|
|
+ * @param globalOptions - global route options
|
|
|
+ */function ve(e,t){
|
|
|
+// normalized ordered array of matchers
|
|
|
+const n=[],r=new Map;function o(e,n,r){
|
|
|
+// used later on to remove by name
|
|
|
+const c=!r,l=be(e);
|
|
|
+// we might be the child of an alias
|
|
|
+l.aliasOf=r&&r.record;const i=ke(t,e),u=[l];
|
|
|
+// generate an array of records to correctly handle aliases
|
|
|
+if("alias"in e){const t="string"==typeof e.alias?[e.alias]:e.alias;for(const e of t)u.push(
|
|
|
+// we need to normalize again to ensure the `mods` property
|
|
|
+// being non enumerable
|
|
|
+be(d({},l,{
|
|
|
+// this allows us to hold a copy of the `components` option
|
|
|
+// so that async components cache is hold on the original record
|
|
|
+components:r?r.record.components:l.components,path:e,
|
|
|
+// we might be the child of an alias
|
|
|
+aliasOf:r?r.record:l})))}let f,p;for(const t of u){const{path:u}=t;
|
|
|
+// Build up the path for nested routes if the child isn't an absolute
|
|
|
+// route. Only add the / delimiter if the child path isn't empty and if the
|
|
|
+// parent path doesn't have a trailing slash
|
|
|
+if(n&&"/"!==u[0]){const e=n.record.path,r="/"===e[e.length-1]?"":"/";t.path=n.record.path+(u&&r+u)}
|
|
|
+// create the object beforehand, so it can be passed to children
|
|
|
+if(f=ge(t,n,i),
|
|
|
+// if we are an alias we must tell the original record that we exist,
|
|
|
+// so we can be removed
|
|
|
+r?r.alias.push(f):(
|
|
|
+// otherwise, the first record is the original and others are aliases
|
|
|
+p=p||f,p!==f&&p.alias.push(f),
|
|
|
+// remove the route if named and only for the top record (avoid in nested calls)
|
|
|
+// this works because the original record is the first one
|
|
|
+c&&e.name&&!Ee(f)&&a(e.name)),
|
|
|
+// Avoid adding a record that doesn't display anything. This allows passing through records without a component to
|
|
|
+// not be reached and pass through the catch all route
|
|
|
+Oe(f)&&s(f),l.children){const e=l.children;for(let t=0;t<e.length;t++)o(e[t],f,r&&r.children[t])}
|
|
|
+// if there was no original record, then the first one was not an alias and all
|
|
|
+// other aliases (if any) need to reference this record when adding children
|
|
|
+r=r||f}return p?()=>{
|
|
|
+// since other matchers are aliases, they should be removed by the original matcher
|
|
|
+a(p)}:g}function a(e){if(re(e)){const t=r.get(e);t&&(r.delete(e),n.splice(n.indexOf(t),1),t.children.forEach(a),t.alias.forEach(a))}else{const t=n.indexOf(e);t>-1&&(n.splice(t,1),e.record.name&&r.delete(e.record.name),e.children.forEach(a),e.alias.forEach(a))}}function s(e){const t=
|
|
|
+/**
|
|
|
+ * Performs a binary search to find the correct insertion index for a new matcher.
|
|
|
+ *
|
|
|
+ * Matchers are primarily sorted by their score. If scores are tied then we also consider parent/child relationships,
|
|
|
+ * with descendants coming before ancestors. If there's still a tie, new routes are inserted after existing routes.
|
|
|
+ *
|
|
|
+ * @param matcher - new matcher to be inserted
|
|
|
+ * @param matchers - existing matchers
|
|
|
+ */
|
|
|
+function(e,t){
|
|
|
+// First phase: binary search based on score
|
|
|
+let n=0,r=t.length;for(;n!==r;){const o=n+r>>1;pe(e,t[o])<0?r=o:n=o+1}
|
|
|
+// Second phase: check for an ancestor with the same score
|
|
|
+const o=function(e){let t=e;for(;t=t.parent;)if(Oe(t)&&0===pe(e,t))return t;return}
|
|
|
+/**
|
|
|
+ * Checks if a matcher can be reachable. This means if it's possible to reach it as a route. For example, routes without
|
|
|
+ * a component, or name, or redirect, are just used to group other routes.
|
|
|
+ * @param matcher
|
|
|
+ * @param matcher.record record of the matcher
|
|
|
+ * @returns
|
|
|
+ */(e);o&&(r=t.lastIndexOf(o,r-1));return r}(e,n);n.splice(t,0,e),
|
|
|
+// only add the original record to the name map
|
|
|
+e.record.name&&!Ee(e)&&r.set(e.record.name,e)}return t=ke({strict:!1,end:!0,sensitive:!1},t),
|
|
|
+// add initial routes
|
|
|
+e.forEach((e=>o(e))),{addRoute:o,resolve:function(e,t){let o,a,s,c={};if("name"in e&&e.name){if(o=r.get(e.name),!o)throw se(1/* ErrorTypes.MATCHER_NOT_FOUND */,{location:e});s=o.record.name,c=d(
|
|
|
+// paramsFromLocation is a new object
|
|
|
+ye(t.params,
|
|
|
+// only keep params that exist in the resolved location
|
|
|
+// only keep optional params coming from a parent record
|
|
|
+o.keys.filter((e=>!e.optional)).concat(o.parent?o.parent.keys.filter((e=>e.optional)):[]).map((e=>e.name))),
|
|
|
+// discard any existing params in the current location that do not exist here
|
|
|
+// #1497 this ensures better active/exact matching
|
|
|
+e.params&&ye(e.params,o.keys.map((e=>e.name)))),
|
|
|
+// throws if cannot be stringified
|
|
|
+a=o.stringify(c)}else if(null!=e.path)
|
|
|
+// no need to resolve the path with the matcher as it was provided
|
|
|
+// this also allows the user to control the encoding
|
|
|
+a=e.path,o=n.find((e=>e.re.test(a))),
|
|
|
+// matcher should have a value after the loop
|
|
|
+o&&(
|
|
|
+// we know the matcher works because we tested the regexp
|
|
|
+c=o.parse(a),s=o.record.name);else{if(
|
|
|
+// match by name or path of current route
|
|
|
+o=t.name?r.get(t.name):n.find((e=>e.re.test(t.path))),!o)throw se(1/* ErrorTypes.MATCHER_NOT_FOUND */,{location:e,currentLocation:t});s=o.record.name,
|
|
|
+// since we are navigating to the same location, we don't need to pick the
|
|
|
+// params like when `name` is provided
|
|
|
+c=d({},t.params,e.params),a=o.stringify(c)}const l=[];let i=o;for(;i;)
|
|
|
+// reversed order so parents are at the beginning
|
|
|
+l.unshift(i.record),i=i.parent;return{name:s,path:a,params:c,matched:l,meta:Re(l)}},removeRoute:a,clearRoutes:function(){n.length=0,r.clear()},getRoutes:function(){return n},getRecordMatcher:function(e){return r.get(e)}}}function ye(e,t){const n={};for(const r of t)r in e&&(n[r]=e[r]);return n}
|
|
|
+/**
|
|
|
+ * Normalizes a RouteRecordRaw. Creates a copy
|
|
|
+ *
|
|
|
+ * @param record
|
|
|
+ * @returns the normalized version
|
|
|
+ */function be(e){const t={path:e.path,redirect:e.redirect,name:e.name,meta:e.meta||{},aliasOf:e.aliasOf,beforeEnter:e.beforeEnter,props:we(e),children:e.children||[],instances:{},leaveGuards:new Set,updateGuards:new Set,enterCallbacks:{},
|
|
|
+// must be declared afterwards
|
|
|
+// mods: {},
|
|
|
+components:"components"in e?e.components||null:e.component&&{default:e.component}};
|
|
|
+// mods contain modules and shouldn't be copied,
|
|
|
+// logged or anything. It's just used for internal
|
|
|
+// advanced use cases like data loaders
|
|
|
+return Object.defineProperty(t,"mods",{value:{}}),t}
|
|
|
+/**
|
|
|
+ * Normalize the optional `props` in a record to always be an object similar to
|
|
|
+ * components. Also accept a boolean for components.
|
|
|
+ * @param record
|
|
|
+ */function we(e){const t={},n=e.props||!1;
|
|
|
+// props does not exist on redirect records, but we can set false directly
|
|
|
+if("component"in e)t.default=n;else
|
|
|
+// NOTE: we could also allow a function to be applied to every component.
|
|
|
+// Would need user feedback for use cases
|
|
|
+for(const r in e.components)t[r]="object"==typeof n?n[r]:n;return t}
|
|
|
+/**
|
|
|
+ * Checks if a record or any of its parent is an alias
|
|
|
+ * @param record
|
|
|
+ */function Ee(e){for(;e;){if(e.record.aliasOf)return!0;e=e.parent}return!1}
|
|
|
+/**
|
|
|
+ * Merge meta fields of an array of records
|
|
|
+ *
|
|
|
+ * @param matched - array of matched records
|
|
|
+ */function Re(e){return e.reduce(((e,t)=>d(e,t.meta)),{})}function ke(e,t){const n={};for(const r in e)n[r]=r in t?t[r]:e[r];return n}function Oe({record:e}){return!!(e.name||e.components&&Object.keys(e.components).length||e.redirect)}
|
|
|
+/**
|
|
|
+ * Transforms a queryString into a {@link LocationQuery} object. Accept both, a
|
|
|
+ * version with the leading `?` and without Should work as URLSearchParams
|
|
|
+
|
|
|
+ * @internal
|
|
|
+ *
|
|
|
+ * @param search - search string to parse
|
|
|
+ * @returns a query object
|
|
|
+ */function xe(e){const t={};
|
|
|
+// avoid creating an object with an empty key and empty value
|
|
|
+// because of split('&')
|
|
|
+if(""===e||"?"===e)return t;const n=("?"===e[0]?e.slice(1):e).split("&");for(let r=0;r<n.length;++r){
|
|
|
+// pre decode the + into space
|
|
|
+const e=n[r].replace(k," "),o=e.indexOf("="),a=B(o<0?e:e.slice(0,o)),s=o<0?null:B(e.slice(o+1));
|
|
|
+// allow the = character
|
|
|
+if(a in t){
|
|
|
+// an extra variable for ts types
|
|
|
+let e=t[a];v(e)||(e=t[a]=[e]),e.push(s)}else t[a]=s}return t}
|
|
|
+/**
|
|
|
+ * Stringifies a {@link LocationQueryRaw} object. Like `URLSearchParams`, it
|
|
|
+ * doesn't prepend a `?`
|
|
|
+ *
|
|
|
+ * @internal
|
|
|
+ *
|
|
|
+ * @param query - query object to stringify
|
|
|
+ * @returns string version of the query without the leading `?`
|
|
|
+ */function Pe(e){let t="";for(let n in e){const r=e[n];if(n=L(n).replace(E,"%3D"),null==r){
|
|
|
+// only null adds the value
|
|
|
+void 0!==r&&(t+=(t.length?"&":"")+n);continue}
|
|
|
+// keep null values
|
|
|
+(v(r)?r.map((e=>e&&L(e))):[r&&L(r)]).forEach((e=>{
|
|
|
+// skip undefined values in arrays as if they were not present
|
|
|
+// smaller code than using filter
|
|
|
+void 0!==e&&(
|
|
|
+// only append & with non-empty search
|
|
|
+t+=(t.length?"&":"")+n,null!=e&&(t+="="+e))}))}return t}
|
|
|
+/**
|
|
|
+ * Transforms a {@link LocationQueryRaw} into a {@link LocationQuery} by casting
|
|
|
+ * numbers into strings, removing keys with an undefined value and replacing
|
|
|
+ * undefined with null in arrays
|
|
|
+ *
|
|
|
+ * @param query - query object to normalize
|
|
|
+ * @returns a normalized query object
|
|
|
+ */function Ce(e){const t={};for(const n in e){const r=e[n];void 0!==r&&(t[n]=v(r)?r.map((e=>null==e?null:""+e)):null==r?r:""+r)}return t}
|
|
|
+/**
|
|
|
+ * RouteRecord being rendered by the closest ancestor Router View. Used for
|
|
|
+ * `onBeforeRouteUpdate` and `onBeforeRouteLeave`. rvlm stands for Router View
|
|
|
+ * Location Matched
|
|
|
+ *
|
|
|
+ * @internal
|
|
|
+ */const je=Symbol(""),$e=Symbol(""),Se=Symbol(""),Ae=Symbol(""),qe=Symbol("");
|
|
|
+/**
|
|
|
+ * Allows overriding the router view depth to control which component in
|
|
|
+ * `matched` is rendered. rvd stands for Router View Depth
|
|
|
+ *
|
|
|
+ * @internal
|
|
|
+ */
|
|
|
+/**
|
|
|
+ * Create a list of callbacks that can be reset. Used to create before and after navigation guards list
|
|
|
+ */
|
|
|
+function Le(){let e=[];return{add:function(t){return e.push(t),()=>{const n=e.indexOf(t);n>-1&&e.splice(n,1)}},list:()=>e.slice(),reset:function(){e=[]}}}function Me(e,t,n,r,o,a=e=>e()){
|
|
|
+// keep a reference to the enterCallbackArray to prevent pushing callbacks if a new navigation took place
|
|
|
+const s=r&&(
|
|
|
+// name is defined if record is because of the function overload
|
|
|
+r.enterCallbacks[o]=r.enterCallbacks[o]||[]);return()=>new Promise(((c,l)=>{const i=e=>{var a;!1===e?l(se(4/* ErrorTypes.NAVIGATION_ABORTED */,{from:n,to:t})):e instanceof Error?l(e):"string"==typeof(a=e)||a&&"object"==typeof a?l(se(2/* ErrorTypes.NAVIGATION_GUARD_REDIRECT */,{from:t,to:e})):(s&&
|
|
|
+// since enterCallbackArray is truthy, both record and name also are
|
|
|
+r.enterCallbacks[o]===s&&"function"==typeof e&&s.push(e),c())},u=a((()=>e.call(r&&r.instances[o],t,n,i)));
|
|
|
+// wrapping with Promise.resolve allows it to work with both async and sync guards
|
|
|
+let f=Promise.resolve(u);e.length<3&&(f=f.then(i)),f.catch((e=>l(e)))}))}function Be(e,t,n,r,o=e=>e()){const a=[];for(const s of e)for(const e in s.components){let c=s.components[e];
|
|
|
+// skip update and leave guards if the route component is not mounted
|
|
|
+if("beforeRouteEnter"===t||s.instances[e])if(h(c)){
|
|
|
+// __vccOpts is added by vue-class-component and contain the regular options
|
|
|
+const l=(c.__vccOpts||c)[t];l&&a.push(Me(l,n,r,s,e,o))}else{
|
|
|
+// start requesting the chunk already
|
|
|
+let l=c();a.push((()=>l.then((a=>{if(!a)throw new Error(`Couldn't resolve component "${e}" at "${s.path}"`);const c=(l=a).__esModule||"Module"===l[Symbol.toStringTag]||
|
|
|
+// support CF with dynamic imports that do not
|
|
|
+// add the Module string tag
|
|
|
+l.default&&h(l.default)?a.default:a;
|
|
|
+// keep the resolved module for plugins like data loaders
|
|
|
+var l;s.mods[e]=a,
|
|
|
+// replace the function with the resolved component
|
|
|
+// cannot be null or undefined because we went into the for loop
|
|
|
+s.components[e]=c;
|
|
|
+// __vccOpts is added by vue-class-component and contain the regular options
|
|
|
+const i=(c.__vccOpts||c)[t];return i&&Me(i,n,r,s,e,o)()}))))}}return a}
|
|
|
+// TODO: we could allow currentRoute as a prop to expose `isActive` and
|
|
|
+// `isExactActive` behavior should go through an RFC
|
|
|
+/**
|
|
|
+ * Returns the internal behavior of a {@link RouterLink} without the rendering part.
|
|
|
+ *
|
|
|
+ * @param props - a `to` location and an optional `replace` flag
|
|
|
+ */function Ge(e){const n=o(Se),r=o(Ae),a=c((()=>{const r=t(e.to);return n.resolve(r)})),s=c((()=>{const{matched:e}=a.value,{length:t}=e,n=e[t-1],o=r.matched;if(!n||!o.length)return-1;const s=o.findIndex(T.bind(null,n));if(s>-1)return s;
|
|
|
+// possible parent record
|
|
|
+const c=Ie(e[t-2]);
|
|
|
+// we are dealing with nested routes
|
|
|
+return t>1&&
|
|
|
+// if the parent and matched route have the same path, this link is
|
|
|
+// referring to the empty child. Or we currently are on a different
|
|
|
+// child of the same parent
|
|
|
+Ie(n)===c&&
|
|
|
+// avoid comparing the child with its parent
|
|
|
+o[o.length-1].path!==c?o.findIndex(T.bind(null,e[t-2])):s})),l=c((()=>s.value>-1&&function(e,t){for(const n in t){const r=t[n],o=e[n];if("string"==typeof r){if(r!==o)return!1}else if(!v(o)||o.length!==r.length||r.some(((e,t)=>e!==o[t])))return!1}return!0}
|
|
|
+/**
|
|
|
+ * Get the original path value of a record by following its aliasOf
|
|
|
+ * @param record
|
|
|
+ */(r.params,a.value.params))),i=c((()=>s.value>-1&&s.value===r.matched.length-1&&W(r.params,a.value.params)));
|
|
|
+/**
|
|
|
+ * NOTE: update {@link _RouterLinkI}'s `$slots` type when updating this
|
|
|
+ */
|
|
|
+return{route:a,href:c((()=>a.value.href)),isActive:l,isExactActive:i,navigate:function(r={}){if(function(e){
|
|
|
+// don't redirect with control keys
|
|
|
+if(e.metaKey||e.altKey||e.ctrlKey||e.shiftKey)return;
|
|
|
+// don't redirect when preventDefault called
|
|
|
+if(e.defaultPrevented)return;
|
|
|
+// don't redirect on right click
|
|
|
+if(void 0!==e.button&&0!==e.button)return;
|
|
|
+// don't redirect if `target="_blank"`
|
|
|
+// @ts-expect-error getAttribute does exist
|
|
|
+if(e.currentTarget&&e.currentTarget.getAttribute){
|
|
|
+// @ts-expect-error getAttribute exists
|
|
|
+const t=e.currentTarget.getAttribute("target");if(/\b_blank\b/i.test(t))return}
|
|
|
+// this may be a Weex event which doesn't have this method
|
|
|
+e.preventDefault&&e.preventDefault();return!0}(r)){const r=n[t(e.replace)?"replace":"push"](t(e.to)).catch(g);return e.viewTransition&&"undefined"!=typeof document&&"startViewTransition"in document&&document.startViewTransition((()=>r)),r}return Promise.resolve()}}}const _e=a({name:"RouterLink",compatConfig:{MODE:3},props:{to:{type:[String,Object],required:!0},replace:Boolean,activeClass:String,
|
|
|
+// inactiveClass: String,
|
|
|
+exactActiveClass:String,custom:Boolean,ariaCurrentValue:{type:String,default:"page"}},useLink:Ge,setup(e,{slots:t}){const n=s(Ge(e)),{options:r}=o(Se),a=c((()=>({[Te(e.activeClass,r.linkActiveClass,"router-link-active")]:n.isActive,
|
|
|
+// [getLinkClass(
|
|
|
+// props.inactiveClass,
|
|
|
+// options.linkInactiveClass,
|
|
|
+// 'router-link-inactive'
|
|
|
+// )]: !link.isExactActive,
|
|
|
+[Te(e.exactActiveClass,r.linkExactActiveClass,"router-link-exact-active")]:n.isExactActive})));return()=>{const r=t.default&&(1===(o=t.default(n)).length?o[0]:o);var o;return e.custom?r:l("a",{"aria-current":n.isExactActive?e.ariaCurrentValue:null,href:n.href,
|
|
|
+// this would override user added attrs but Vue will still add
|
|
|
+// the listener, so we end up triggering both
|
|
|
+onClick:n.navigate,class:a.value},r)}}});
|
|
|
+// export the public type for h/tsx inference
|
|
|
+// also to avoid inline import() in generated d.ts files
|
|
|
+/**
|
|
|
+ * Component to render a link that triggers a navigation on click.
|
|
|
+ */function Ie(e){return e?e.aliasOf?e.aliasOf.path:e.path:""}
|
|
|
+/**
|
|
|
+ * Utility class to get the active class based on defaults.
|
|
|
+ * @param propClass
|
|
|
+ * @param globalClass
|
|
|
+ * @param defaultClass
|
|
|
+ */const Te=(e,t,n)=>null!=e?e:null!=t?t:n;function We(e,t){if(!e)return null;const n=e(t);return 1===n.length?n[0]:n}
|
|
|
+// export the public type for h/tsx inference
|
|
|
+// also to avoid inline import() in generated d.ts files
|
|
|
+/**
|
|
|
+ * Component to display the current route the user is at.
|
|
|
+ */const De=a({name:"RouterView",
|
|
|
+// #674 we manually inherit them
|
|
|
+inheritAttrs:!1,props:{name:{type:String,default:"default"},route:Object},
|
|
|
+// Better compat for @vue/compat users
|
|
|
+// https://github.com/vuejs/router/issues/1315
|
|
|
+compatConfig:{MODE:3},setup(e,{attrs:n,slots:r}){const a=o(qe),s=c((()=>e.route||a.value)),p=o($e,0),h=c((()=>{let e=t(p);const{matched:n}=s.value;let r;for(;(r=n[e])&&!r.components;)e++;return e})),m=c((()=>s.value.matched[h.value]));i($e,c((()=>h.value+1))),i(je,m),i(qe,s);const g=u();
|
|
|
+// watch at the same time the component instance, the route record we are
|
|
|
+// rendering, and the name
|
|
|
+return f((()=>[g.value,m.value,e.name]),(([e,t,n],[r,o,a])=>{
|
|
|
+// copy reused instances
|
|
|
+t&&(
|
|
|
+// this will update the instance for new instances as well as reused
|
|
|
+// instances when navigating to a new route
|
|
|
+t.instances[n]=e,
|
|
|
+// the component instance is reused for a different route or name, so
|
|
|
+// we copy any saved update or leave guards. With async setup, the
|
|
|
+// mounting component will mount before the matchedRoute changes,
|
|
|
+// making instance === oldInstance, so we check if guards have been
|
|
|
+// added before. This works because we remove guards when
|
|
|
+// unmounting/deactivating components
|
|
|
+o&&o!==t&&e&&e===r&&(t.leaveGuards.size||(t.leaveGuards=o.leaveGuards),t.updateGuards.size||(t.updateGuards=o.updateGuards))),
|
|
|
+// trigger beforeRouteEnter next callbacks
|
|
|
+!e||!t||
|
|
|
+// if there is no instance but to and from are the same this might be
|
|
|
+// the first visit
|
|
|
+o&&T(t,o)&&r||(t.enterCallbacks[n]||[]).forEach((t=>t(e)))}),{flush:"post"}),()=>{const t=s.value,o=e.name,a=m.value,c=a&&a.components[o];
|
|
|
+// we need the value at the time we render because when we unmount, we
|
|
|
+// navigated to a different location so the value is different
|
|
|
+if(!c)return We(r.default,{Component:c,route:t});
|
|
|
+// props from route configuration
|
|
|
+const i=a.props[o],u=i?!0===i?t.params:"function"==typeof i?i(t):i:null,f=l(c,d({},u,n,{onVnodeUnmounted:e=>{
|
|
|
+// remove the instance reference to prevent leak
|
|
|
+e.component.isUnmounted&&(a.instances[o]=null)},ref:g}));
|
|
|
+// pass the vnode to the slot as a prop.
|
|
|
+// h and <component :is="..."> both accept vnodes
|
|
|
+return We(r.default,{Component:f,route:t})||f}}});
|
|
|
+/**
|
|
|
+ * Creates a Router instance that can be used by a Vue app.
|
|
|
+ *
|
|
|
+ * @param options - {@link RouterOptions}
|
|
|
+ */function Ue(o){const a=ve(o.routes,o),s=o.parseQuery||xe,c=o.stringifyQuery||Pe,l=o.history,i=Le(),u=Le(),f=Le(),h=e(V);let y=V;
|
|
|
+// leave the scrollRestoration if no scrollBehavior is provided
|
|
|
+p&&o.scrollBehavior&&"scrollRestoration"in history&&(history.scrollRestoration="manual");const b=m.bind(null,(e=>""+e)),w=m.bind(null,M),E=
|
|
|
+// @ts-expect-error: intentionally avoid the type check
|
|
|
+m.bind(null,B);function R(e,t){if(
|
|
|
+// const resolve: Router['resolve'] = (rawLocation: RouteLocationRaw, currentLocation) => {
|
|
|
+// const objectLocation = routerLocationAsObject(rawLocation)
|
|
|
+// we create a copy to modify it later
|
|
|
+t=d({},t||h.value),"string"==typeof e){const n=_(s,e,t.path),r=a.resolve({path:n.path},t),o=l.createHref(n.fullPath);
|
|
|
+// locationNormalized is always a new object
|
|
|
+return d(n,r,{params:E(r.params),hash:B(n.hash),redirectedFrom:void 0,href:o})}let n;
|
|
|
+// path could be relative in object as well
|
|
|
+if(null!=e.path)n=d({},e,{path:_(s,e.path,t.path).path});else{
|
|
|
+// remove any nullish param
|
|
|
+const r=d({},e.params);for(const e in r)null==r[e]&&delete r[e];
|
|
|
+// pass encoded values to the matcher, so it can produce encoded path and fullPath
|
|
|
+n=d({},e,{params:w(r)}),
|
|
|
+// current location params are decoded, we need to encode them in case the
|
|
|
+// matcher merges the params
|
|
|
+t.params=w(t.params)}const r=a.resolve(n,t),o=e.hash||"";
|
|
|
+// the matcher might have merged current location params, so
|
|
|
+// we need to run the decoding again
|
|
|
+r.params=b(E(r.params));const i=function(e,t){const n=t.query?e(t.query):"";return t.path+(n&&"?")+n+(t.hash||"")}(c,d({},e,{hash:(u=o,q(u).replace(j,"{").replace(S,"}").replace(P,"^")),path:r.path}));var u;const f=l.createHref(i);return d({fullPath:i,
|
|
|
+// keep the hash encoded so fullPath is effectively path + encodedQuery +
|
|
|
+// hash
|
|
|
+hash:o,query:
|
|
|
+// if the user is using a custom query lib like qs, we might have
|
|
|
+// nested objects, so we keep the query as is, meaning it can contain
|
|
|
+// numbers at `$route.query`, but at the point, the user will have to
|
|
|
+// use their own type anyway.
|
|
|
+// https://github.com/vuejs/router/issues/328#issuecomment-649481567
|
|
|
+c===Pe?Ce(e.query):e.query||{}},r,{redirectedFrom:void 0,href:f})}function k(e){return"string"==typeof e?_(s,e,h.value.path):d({},e)}function O(e,t){if(y!==e)return se(8/* ErrorTypes.NAVIGATION_CANCELLED */,{from:t,to:e})}function x(e){return $(e)}function C(e){const t=e.matched[e.matched.length-1];if(t&&t.redirect){const{redirect:n}=t;let r="function"==typeof n?n(e):n;return"string"==typeof r&&(r=r.includes("?")||r.includes("#")?r=k(r):// force empty params
|
|
|
+{path:r},
|
|
|
+// @ts-expect-error: force empty params when a string is passed to let
|
|
|
+// the router parse them again
|
|
|
+r.params={}),d({query:e.query,hash:e.hash,
|
|
|
+// avoid transferring params if the redirect has a path
|
|
|
+params:null!=r.path?{}:e.params},r)}}function $(e,t){const n=y=R(e),r=h.value,o=e.state,a=e.force,s=!0===e.replace,l=C(n);if(l)return $(d(k(l),{state:"object"==typeof l?d({},o,l.state):o,force:a,replace:s}),
|
|
|
+// keep original redirectedFrom if it exists
|
|
|
+t||n);
|
|
|
+// if it was a redirect we already called `pushWithRedirect` above
|
|
|
+const i=n;let u;return i.redirectedFrom=t,!a&&function(e,t,n){const r=t.matched.length-1,o=n.matched.length-1;return r>-1&&r===o&&T(t.matched[r],n.matched[o])&&W(t.params,n.params)&&e(t.query)===e(n.query)&&t.hash===n.hash}(c,r,n)&&(u=se(16/* ErrorTypes.NAVIGATION_DUPLICATED */,{to:i,from:r}),
|
|
|
+// trigger scroll to allow scrolling to the same anchor
|
|
|
+te(r,r,
|
|
|
+// this is a push, the only way for it to be triggered from a
|
|
|
+// history.listen is with a redirect, which makes it become a push
|
|
|
+!0,
|
|
|
+// This cannot be the first navigation because the initial location
|
|
|
+// cannot be manually navigated to
|
|
|
+!1)),(u?Promise.resolve(u):G(i,r)).catch((e=>ce(e)?// navigation redirects still mark the router as ready
|
|
|
+ce(e,2/* ErrorTypes.NAVIGATION_GUARD_REDIRECT */)?e:ee(e):// reject any unknown error
|
|
|
+J(e,i,r))).then((e=>{if(e){if(ce(e,2/* ErrorTypes.NAVIGATION_GUARD_REDIRECT */))return $(
|
|
|
+// keep options
|
|
|
+d({
|
|
|
+// preserve an existing replacement but allow the redirect to override it
|
|
|
+replace:s},k(e.to),{state:"object"==typeof e.to?d({},o,e.to.state):o,force:a}),
|
|
|
+// preserve the original redirectedFrom if any
|
|
|
+t||i)}else
|
|
|
+// if we fail we don't finalize the navigation
|
|
|
+e=D(i,r,!0,s,o);return I(i,r,e),e}))}
|
|
|
+/**
|
|
|
+ * Helper to reject and skip all navigation guards if a new navigation happened
|
|
|
+ * @param to
|
|
|
+ * @param from
|
|
|
+ */function A(e,t){const n=O(e,t);return n?Promise.reject(n):Promise.resolve()}function L(e){const t=ae.values().next().value;
|
|
|
+// support Vue < 3.3
|
|
|
+return t&&"function"==typeof t.runWithContext?t.runWithContext(e):e()}
|
|
|
+// TODO: refactor the whole before guards by internally using router.beforeEach
|
|
|
+function G(e,t){let n;const[r,o,a]=function(e,t){const n=[],r=[],o=[],a=Math.max(t.matched.length,e.matched.length);for(let s=0;s<a;s++){const a=t.matched[s];a&&(e.matched.find((e=>T(e,a)))?r.push(a):n.push(a));const c=e.matched[s];c&&(
|
|
|
+// the type doesn't matter because we are comparing per reference
|
|
|
+t.matched.find((e=>T(e,c)))||o.push(c))}return[n,r,o]}
|
|
|
+/**
|
|
|
+ * Returns the router instance. Equivalent to using `$router` inside
|
|
|
+ * templates.
|
|
|
+ */(e,t);
|
|
|
+// all components here have been resolved once because we are leaving
|
|
|
+n=Be(r.reverse(),"beforeRouteLeave",e,t);
|
|
|
+// leavingRecords is already reversed
|
|
|
+for(const c of r)c.leaveGuards.forEach((r=>{n.push(Me(r,e,t))}));const s=A.bind(null,e,t);
|
|
|
+// run the queue of per route beforeRouteLeave guards
|
|
|
+return n.push(s),ie(n).then((()=>{
|
|
|
+// check global guards beforeEach
|
|
|
+n=[];for(const r of i.list())n.push(Me(r,e,t));return n.push(s),ie(n)})).then((()=>{
|
|
|
+// check in components beforeRouteUpdate
|
|
|
+n=Be(o,"beforeRouteUpdate",e,t);for(const r of o)r.updateGuards.forEach((r=>{n.push(Me(r,e,t))}));
|
|
|
+// run the queue of per route beforeEnter guards
|
|
|
+return n.push(s),ie(n)})).then((()=>{
|
|
|
+// check the route beforeEnter
|
|
|
+n=[];for(const r of a)
|
|
|
+// do not trigger beforeEnter on reused views
|
|
|
+if(r.beforeEnter)if(v(r.beforeEnter))for(const o of r.beforeEnter)n.push(Me(o,e,t));else n.push(Me(r.beforeEnter,e,t));
|
|
|
+// run the queue of per route beforeEnter guards
|
|
|
+return n.push(s),ie(n)})).then((()=>(
|
|
|
+// NOTE: at this point to.matched is normalized and does not contain any () => Promise<Component>
|
|
|
+// clear existing enterCallbacks, these are added by extractComponentsGuards
|
|
|
+e.matched.forEach((e=>e.enterCallbacks={})),
|
|
|
+// check in-component beforeRouteEnter
|
|
|
+n=Be(a,"beforeRouteEnter",e,t,L),n.push(s),ie(n)))).then((()=>{
|
|
|
+// check global guards beforeResolve
|
|
|
+n=[];for(const r of u.list())n.push(Me(r,e,t));return n.push(s),ie(n)})).catch((e=>ce(e,8/* ErrorTypes.NAVIGATION_CANCELLED */)?e:Promise.reject(e)))}function I(e,t,n){
|
|
|
+// navigation is confirmed, call afterGuards
|
|
|
+// TODO: wrap with error handlers
|
|
|
+f.list().forEach((r=>L((()=>r(e,t,n)))))}
|
|
|
+/**
|
|
|
+ * - Cleans up any navigation guards
|
|
|
+ * - Changes the url if necessary
|
|
|
+ * - Calls the scrollBehavior
|
|
|
+ */function D(e,t,n,r,o){
|
|
|
+// a more recent navigation took place
|
|
|
+const a=O(e,t);if(a)return a;
|
|
|
+// only consider as push if it's not the first navigation
|
|
|
+const s=t===V,c=p?history.state:{};
|
|
|
+// change URL only if the user did a push/replace and if it's not the initial navigation because
|
|
|
+// it's just reflecting the url
|
|
|
+n&&(
|
|
|
+// on the initial navigation, we want to reuse the scroll position from
|
|
|
+// history state if it exists
|
|
|
+r||s?l.replace(e.fullPath,d({scroll:s&&c&&c.scroll},o)):l.push(e.fullPath,o)),
|
|
|
+// accept current navigation
|
|
|
+h.value=e,te(e,t,n,s),ee()}let U;
|
|
|
+// attach listener to history to trigger navigations
|
|
|
+function z(){
|
|
|
+// avoid setting up listeners twice due to an invalid first navigation
|
|
|
+U||(U=l.listen(((e,t,n)=>{if(!le.listening)return;
|
|
|
+// cannot be a redirect route because it was in history
|
|
|
+const r=R(e),o=C(r);
|
|
|
+// due to dynamic routing, and to hash history with manual navigation
|
|
|
+// (manually changing the url or calling history.hash = '#/somewhere'),
|
|
|
+// there could be a redirect record in history
|
|
|
+if(o)return void $(d(o,{replace:!0,force:!0}),r).catch(g);y=r;const a=h.value;
|
|
|
+// TODO: should be moved to web history?
|
|
|
+var s,c;p&&(s=N(a.fullPath,n.delta),c=Q(),Z.set(s,c)),G(r,a).catch((e=>ce(e,12/* ErrorTypes.NAVIGATION_CANCELLED */)?e:ce(e,2/* ErrorTypes.NAVIGATION_GUARD_REDIRECT */)?(
|
|
|
+// Here we could call if (info.delta) routerHistory.go(-info.delta,
|
|
|
+// false) but this is bug prone as we have no way to wait the
|
|
|
+// navigation to be finished before calling pushWithRedirect. Using
|
|
|
+// a setTimeout of 16ms seems to work but there is no guarantee for
|
|
|
+// it to work on every browser. So instead we do not restore the
|
|
|
+// history entry and trigger a new navigation as requested by the
|
|
|
+// navigation guard.
|
|
|
+// the error is already handled by router.push we just want to avoid
|
|
|
+// logging the error
|
|
|
+$(d(k(e.to),{force:!0}),r).then((e=>{
|
|
|
+// manual change in hash history #916 ending up in the URL not
|
|
|
+// changing, but it was changed by the manual url change, so we
|
|
|
+// need to manually change it ourselves
|
|
|
+ce(e,20/* ErrorTypes.NAVIGATION_DUPLICATED */)&&!n.delta&&n.type===F.pop&&l.go(-1,!1)})).catch(g),Promise.reject()):(
|
|
|
+// do not restore history on unknown direction
|
|
|
+n.delta&&l.go(-n.delta,!1),J(e,r,a)))).then((e=>{
|
|
|
+// revert the navigation
|
|
|
+(e=e||D(
|
|
|
+// after navigation, all matched components are resolved
|
|
|
+r,a,!1))&&(n.delta&&
|
|
|
+// a new navigation has been triggered, so we do not want to revert, that will change the current history
|
|
|
+// entry while a different route is displayed
|
|
|
+!ce(e,8/* ErrorTypes.NAVIGATION_CANCELLED */)?l.go(-n.delta,!1):n.type===F.pop&&ce(e,20/* ErrorTypes.NAVIGATION_DUPLICATED */)&&
|
|
|
+// manual change in hash history #916
|
|
|
+// it's like a push but lacks the information of the direction
|
|
|
+l.go(-1,!1)),I(r,a,e)})).catch(g)})))}
|
|
|
+// Initialization and Errors
|
|
|
+let K,H=Le(),X=Le();
|
|
|
+/**
|
|
|
+ * Trigger errorListeners added via onError and throws the error as well
|
|
|
+ *
|
|
|
+ * @param error - error to throw
|
|
|
+ * @param to - location we were navigating to when the error happened
|
|
|
+ * @param from - location we were navigating from when the error happened
|
|
|
+ * @returns the error as a rejected promise
|
|
|
+ */
|
|
|
+function J(e,t,n){ee(e);const r=X.list();
|
|
|
+// reject the error no matter there were error listeners or not
|
|
|
+return r.length&&r.forEach((r=>r(e,t,n))),Promise.reject(e)}function ee(e){return K||(
|
|
|
+// still not ready if an error happened
|
|
|
+K=!e,z(),H.list().forEach((([t,n])=>e?n(e):t())),H.reset()),e}
|
|
|
+// Scroll behavior
|
|
|
+function te(e,t,n,a){const{scrollBehavior:s}=o;if(!p||!s)return Promise.resolve();const c=!n&&function(e){const t=Z.get(e);
|
|
|
+// consume it so it's not used again
|
|
|
+return Z.delete(e),t}(N(e.fullPath,0))||(a||!n)&&history.state&&history.state.scroll||null;return r().then((()=>s(e,t,c))).then((e=>e&&Y(e))).catch((n=>J(n,e,t)))}const ne=e=>l.go(e);let oe;const ae=new Set,le={currentRoute:h,listening:!0,addRoute:function(e,t){let n,r;return re(e)?(n=a.getRecordMatcher(e),r=t):r=e,a.addRoute(r,n)},removeRoute:function(e){const t=a.getRecordMatcher(e);t&&a.removeRoute(t)},clearRoutes:a.clearRoutes,hasRoute:function(e){return!!a.getRecordMatcher(e)},getRoutes:function(){return a.getRoutes().map((e=>e.record))},resolve:R,options:o,push:x,replace:function(e){return x(d(k(e),{replace:!0}))},go:ne,back:()=>ne(-1),forward:()=>ne(1),beforeEach:i.add,beforeResolve:u.add,afterEach:f.add,onError:X.add,isReady:function(){return K&&h.value!==V?Promise.resolve():new Promise(((e,t)=>{H.add([e,t])}))},install(e){e.component("RouterLink",_e),e.component("RouterView",De),e.config.globalProperties.$router=this,Object.defineProperty(e.config.globalProperties,"$route",{enumerable:!0,get:()=>t(h)}),
|
|
|
+// this initial navigation is only necessary on client, on server it doesn't
|
|
|
+// make sense because it will create an extra unnecessary navigation and could
|
|
|
+// lead to problems
|
|
|
+p&&
|
|
|
+// used for the initial navigation client side to avoid pushing
|
|
|
+// multiple times when the router is used in multiple apps
|
|
|
+!oe&&h.value===V&&(
|
|
|
+// see above
|
|
|
+oe=!0,x(l.location).catch((e=>{})));const r={};for(const t in V)Object.defineProperty(r,t,{get:()=>h.value[t],enumerable:!0});e.provide(Se,this),e.provide(Ae,n(r)),e.provide(qe,h);const o=e.unmount;ae.add(e),e.unmount=function(){ae.delete(e),
|
|
|
+// the router is not attached to an app anymore
|
|
|
+ae.size<1&&(
|
|
|
+// invalidate the current navigation
|
|
|
+y=V,U&&U(),U=null,h.value=V,oe=!1,K=!1),o()}}};
|
|
|
+// TODO: type this as NavigationGuardReturn or similar instead of any
|
|
|
+function ie(e){return e.reduce(((e,t)=>e.then((()=>L(t)))),Promise.resolve())}return le}function Ve(){return o(Se)}
|
|
|
+/**
|
|
|
+ * Returns the current route location. Equivalent to using `$route` inside
|
|
|
+ * templates.
|
|
|
+ */function Fe(e){return o(Ae)}export{ne as a,Fe as b,Ue as c,Ve as u};
|
|
|
+//# sourceMappingURL=vue-router-c7cbbcaa.js.map
|
yourname