@nextcloud/vue 8.11.2 → 8.12.0

package/dist/chunks/referencePickerModal-CFPdv-m1.mjs

@@ -0,0 +1,3469 @@
+import '../assets/referencePickerModal-BaGbKZky.css';
+import { e as hasFullWidth, i as isWidgetRegistered, h as hasInteractiveView, a as renderWidget, f as destroyWidget, d as isCustomPickerElementRegistered, g as destroyCustomPickerElement, c as renderCustomPickerElement, j as getCustomPickerElementSize } from "./index-BwyQ2N-M.mjs";
+import { n as normalizeComponent } from "./_plugin-vue2_normalizer-D637Qkok.mjs";
+import { r as register, P as t20, a as t, Q as t7, R as t38, S as t34, T as t21, u as t36, U as t27, E as t16, V as t11 } from "./_l10n-hRR5zBTZ.mjs";
+import axios from "@nextcloud/axios";
+import { loadState } from "@nextcloud/initial-state";
+import { imagePath, generateOcsUrl } from "@nextcloud/router";
+import NcEmptyContent from "../Components/NcEmptyContent.mjs";
+import { N as NcHighlight } from "./index-DYccGIvD.mjs";
+import { N as NcSelect } from "./NcSelect-CNm4fmR6.mjs";
+import { useElementSize, useIntersectionObserver } from "@vueuse/core";
+import Vue, { ref, nextTick } from "vue";
+import { g as getRoute } from "./autolink-DA7VzS8Y.mjs";
+import NcButton from "../Components/NcButton.mjs";
+import NcLoadingIcon from "../Components/NcLoadingIcon.mjs";
+import { N as NcTextField } from "./NcTextField-BmaDUUfq.mjs";
+import { D as DotsHorizontal } from "./DotsHorizontal-C0STD_HU.mjs";
+import NcModal from "../Components/NcModal.mjs";
+import { emit } from "@nextcloud/event-bus";
+import { A as ArrowLeft } from "./ArrowLeft-B9iGweTd.mjs";
+import { C as Close } from "./Close-1V1F2F-M.mjs";
+/*!
+  * vue-router v3.6.5
+  * (c) 2022 Evan You
+  * @license MIT
+  */
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error("[vue-router] " + message);
+  }
+}
+function warn(condition, message) {
+  if (!condition) {
+    typeof console !== "undefined" && console.warn("[vue-router] " + message);
+  }
+}
+function extend(a, b) {
+  for (var key in b) {
+    a[key] = b[key];
+  }
+  return a;
+}
+var encodeReserveRE = /[!'()*]/g;
+var encodeReserveReplacer = function(c) {
+  return "%" + c.charCodeAt(0).toString(16);
+};
+var commaRE = /%2C/g;
+var encode = function(str) {
+  return encodeURIComponent(str).replace(encodeReserveRE, encodeReserveReplacer).replace(commaRE, ",");
+};
+function decode(str) {
+  try {
+    return decodeURIComponent(str);
+  } catch (err) {
+    if (process.env.NODE_ENV !== "production") {
+      warn(false, 'Error decoding "' + str + '". Leaving it intact.');
+    }
+  }
+  return str;
+}
+function resolveQuery(query, extraQuery, _parseQuery) {
+  if (extraQuery === void 0)
+    extraQuery = {};
+  var parse2 = _parseQuery || parseQuery;
+  var parsedQuery;
+  try {
+    parsedQuery = parse2(query || "");
+  } catch (e) {
+    process.env.NODE_ENV !== "production" && warn(false, e.message);
+    parsedQuery = {};
+  }
+  for (var key in extraQuery) {
+    var value = extraQuery[key];
+    parsedQuery[key] = Array.isArray(value) ? value.map(castQueryParamValue) : castQueryParamValue(value);
+  }
+  return parsedQuery;
+}
+var castQueryParamValue = function(value) {
+  return value == null || typeof value === "object" ? value : String(value);
+};
+function parseQuery(query) {
+  var res = {};
+  query = query.trim().replace(/^(\?|#|&)/, "");
+  if (!query) {
+    return res;
+  }
+  query.split("&").forEach(function(param) {
+    var parts = param.replace(/\+/g, " ").split("=");
+    var key = decode(parts.shift());
+    var val = parts.length > 0 ? decode(parts.join("=")) : null;
+    if (res[key] === void 0) {
+      res[key] = val;
+    } else if (Array.isArray(res[key])) {
+      res[key].push(val);
+    } else {
+      res[key] = [res[key], val];
+    }
+  });
+  return res;
+}
+function stringifyQuery(obj) {
+  var res = obj ? Object.keys(obj).map(function(key) {
+    var val = obj[key];
+    if (val === void 0) {
+      return "";
+    }
+    if (val === null) {
+      return encode(key);
+    }
+    if (Array.isArray(val)) {
+      var result = [];
+      val.forEach(function(val2) {
+        if (val2 === void 0) {
+          return;
+        }
+        if (val2 === null) {
+          result.push(encode(key));
+        } else {
+          result.push(encode(key) + "=" + encode(val2));
+        }
+      });
+      return result.join("&");
+    }
+    return encode(key) + "=" + encode(val);
+  }).filter(function(x) {
+    return x.length > 0;
+  }).join("&") : null;
+  return res ? "?" + res : "";
+}
+var trailingSlashRE = /\/?$/;
+function createRoute(record, location, redirectedFrom, router) {
+  var stringifyQuery2 = router && router.options.stringifyQuery;
+  var query = location.query || {};
+  try {
+    query = clone(query);
+  } catch (e) {
+  }
+  var route = {
+    name: location.name || record && record.name,
+    meta: record && record.meta || {},
+    path: location.path || "/",
+    hash: location.hash || "",
+    query,
+    params: location.params || {},
+    fullPath: getFullPath(location, stringifyQuery2),
+    matched: record ? formatMatch(record) : []
+  };
+  if (redirectedFrom) {
+    route.redirectedFrom = getFullPath(redirectedFrom, stringifyQuery2);
+  }
+  return Object.freeze(route);
+}
+function clone(value) {
+  if (Array.isArray(value)) {
+    return value.map(clone);
+  } else if (value && typeof value === "object") {
+    var res = {};
+    for (var key in value) {
+      res[key] = clone(value[key]);
+    }
+    return res;
+  } else {
+    return value;
+  }
+}
+var START = createRoute(null, {
+  path: "/"
+});
+function formatMatch(record) {
+  var res = [];
+  while (record) {
+    res.unshift(record);
+    record = record.parent;
+  }
+  return res;
+}
+function getFullPath(ref2, _stringifyQuery) {
+  var path = ref2.path;
+  var query = ref2.query;
+  if (query === void 0)
+    query = {};
+  var hash = ref2.hash;
+  if (hash === void 0)
+    hash = "";
+  var stringify = _stringifyQuery || stringifyQuery;
+  return (path || "/") + stringify(query) + hash;
+}
+function isSameRoute(a, b, onlyPath) {
+  if (b === START) {
+    return a === b;
+  } else if (!b) {
+    return false;
+  } else if (a.path && b.path) {
+    return a.path.replace(trailingSlashRE, "") === b.path.replace(trailingSlashRE, "") && (onlyPath || a.hash === b.hash && isObjectEqual(a.query, b.query));
+  } else if (a.name && b.name) {
+    return a.name === b.name && (onlyPath || a.hash === b.hash && isObjectEqual(a.query, b.query) && isObjectEqual(a.params, b.params));
+  } else {
+    return false;
+  }
+}
+function isObjectEqual(a, b) {
+  if (a === void 0)
+    a = {};
+  if (b === void 0)
+    b = {};
+  if (!a || !b) {
+    return a === b;
+  }
+  var aKeys = Object.keys(a).sort();
+  var bKeys = Object.keys(b).sort();
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  return aKeys.every(function(key, i) {
+    var aVal = a[key];
+    var bKey = bKeys[i];
+    if (bKey !== key) {
+      return false;
+    }
+    var bVal = b[key];
+    if (aVal == null || bVal == null) {
+      return aVal === bVal;
+    }
+    if (typeof aVal === "object" && typeof bVal === "object") {
+      return isObjectEqual(aVal, bVal);
+    }
+    return String(aVal) === String(bVal);
+  });
+}
+function isIncludedRoute(current, target) {
+  return current.path.replace(trailingSlashRE, "/").indexOf(
+    target.path.replace(trailingSlashRE, "/")
+  ) === 0 && (!target.hash || current.hash === target.hash) && queryIncludes(current.query, target.query);
+}
+function queryIncludes(current, target) {
+  for (var key in target) {
+    if (!(key in current)) {
+      return false;
+    }
+  }
+  return true;
+}
+function handleRouteEntered(route) {
+  for (var i = 0; i < route.matched.length; i++) {
+    var record = route.matched[i];
+    for (var name in record.instances) {
+      var instance = record.instances[name];
+      var cbs = record.enteredCbs[name];
+      if (!instance || !cbs) {
+        continue;
+      }
+      delete record.enteredCbs[name];
+      for (var i$1 = 0; i$1 < cbs.length; i$1++) {
+        if (!instance._isBeingDestroyed) {
+          cbs[i$1](instance);
+        }
+      }
+    }
+  }
+}
+var View = {
+  name: "RouterView",
+  functional: true,
+  props: {
+    name: {
+      type: String,
+      default: "default"
+    }
+  },
+  render: function render(_, ref2) {
+    var props = ref2.props;
+    var children = ref2.children;
+    var parent = ref2.parent;
+    var data = ref2.data;
+    data.routerView = true;
+    var h = parent.$createElement;
+    var name = props.name;
+    var route = parent.$route;
+    var cache = parent._routerViewCache || (parent._routerViewCache = {});
+    var depth = 0;
+    var inactive = false;
+    while (parent && parent._routerRoot !== parent) {
+      var vnodeData = parent.$vnode ? parent.$vnode.data : {};
+      if (vnodeData.routerView) {
+        depth++;
+      }
+      if (vnodeData.keepAlive && parent._directInactive && parent._inactive) {
+        inactive = true;
+      }
+      parent = parent.$parent;
+    }
+    data.routerViewDepth = depth;
+    if (inactive) {
+      var cachedData = cache[name];
+      var cachedComponent = cachedData && cachedData.component;
+      if (cachedComponent) {
+        if (cachedData.configProps) {
+          fillPropsinData(cachedComponent, data, cachedData.route, cachedData.configProps);
+        }
+        return h(cachedComponent, data, children);
+      } else {
+        return h();
+      }
+    }
+    var matched = route.matched[depth];
+    var component = matched && matched.components[name];
+    if (!matched || !component) {
+      cache[name] = null;
+      return h();
+    }
+    cache[name] = { component };
+    data.registerRouteInstance = function(vm, val) {
+      var current = matched.instances[name];
+      if (val && current !== vm || !val && current === vm) {
+        matched.instances[name] = val;
+      }
+    };
+    (data.hook || (data.hook = {})).prepatch = function(_2, vnode) {
+      matched.instances[name] = vnode.componentInstance;
+    };
+    data.hook.init = function(vnode) {
+      if (vnode.data.keepAlive && vnode.componentInstance && vnode.componentInstance !== matched.instances[name]) {
+        matched.instances[name] = vnode.componentInstance;
+      }
+      handleRouteEntered(route);
+    };
+    var configProps = matched.props && matched.props[name];
+    if (configProps) {
+      extend(cache[name], {
+        route,
+        configProps
+      });
+      fillPropsinData(component, data, route, configProps);
+    }
+    return h(component, data, children);
+  }
+};
+function fillPropsinData(component, data, route, configProps) {
+  var propsToPass = data.props = resolveProps(route, configProps);
+  if (propsToPass) {
+    propsToPass = data.props = extend({}, propsToPass);
+    var attrs = data.attrs = data.attrs || {};
+    for (var key in propsToPass) {
+      if (!component.props || !(key in component.props)) {
+        attrs[key] = propsToPass[key];
+        delete propsToPass[key];
+      }
+    }
+  }
+}
+function resolveProps(route, config) {
+  switch (typeof config) {
+    case "undefined":
+      return;
+    case "object":
+      return config;
+    case "function":
+      return config(route);
+    case "boolean":
+      return config ? route.params : void 0;
+    default:
+      if (process.env.NODE_ENV !== "production") {
+        warn(
+          false,
+          'props in "' + route.path + '" is a ' + typeof config + ", expecting an object, function or boolean."
+        );
+      }
+  }
+}
+function resolvePath(relative, base, append) {
+  var firstChar = relative.charAt(0);
+  if (firstChar === "/") {
+    return relative;
+  }
+  if (firstChar === "?" || firstChar === "#") {
+    return base + relative;
+  }
+  var stack = base.split("/");
+  if (!append || !stack[stack.length - 1]) {
+    stack.pop();
+  }
+  var segments = relative.replace(/^\//, "").split("/");
+  for (var i = 0; i < segments.length; i++) {
+    var segment = segments[i];
+    if (segment === "..") {
+      stack.pop();
+    } else if (segment !== ".") {
+      stack.push(segment);
+    }
+  }
+  if (stack[0] !== "") {
+    stack.unshift("");
+  }
+  return stack.join("/");
+}
+function parsePath(path) {
+  var hash = "";
+  var query = "";
+  var hashIndex = path.indexOf("#");
+  if (hashIndex >= 0) {
+    hash = path.slice(hashIndex);
+    path = path.slice(0, hashIndex);
+  }
+  var queryIndex = path.indexOf("?");
+  if (queryIndex >= 0) {
+    query = path.slice(queryIndex + 1);
+    path = path.slice(0, queryIndex);
+  }
+  return {
+    path,
+    query,
+    hash
+  };
+}
+function cleanPath(path) {
+  return path.replace(/\/(?:\s*\/)+/g, "/");
+}
+var isarray = Array.isArray || function(arr) {
+  return Object.prototype.toString.call(arr) == "[object Array]";
+};
+var pathToRegexp_1 = pathToRegexp;
+var parse_1 = parse;
+var compile_1 = compile;
+var tokensToFunction_1 = tokensToFunction;
+var tokensToRegExp_1 = tokensToRegExp;
+var PATH_REGEXP = new RegExp([
+  // Match escaped characters that would otherwise appear in future matches.
+  // This allows the user to escape special characters that won't transform.
+  "(\\\\.)",
+  // Match Express-style parameters and un-named parameters with a prefix
+  // and optional suffixes. Matches appear as:
+  //
+  // "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?", undefined]
+  // "/route(\\d+)"  => [undefined, undefined, undefined, "\d+", undefined, undefined]
+  // "/*"            => ["/", undefined, undefined, undefined, undefined, "*"]
+  "([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\\*))"
+].join("|"), "g");
+function parse(str, options) {
+  var tokens = [];
+  var key = 0;
+  var index = 0;
+  var path = "";
+  var defaultDelimiter = options && options.delimiter || "/";
+  var res;
+  while ((res = PATH_REGEXP.exec(str)) != null) {
+    var m = res[0];
+    var escaped = res[1];
+    var offset = res.index;
+    path += str.slice(index, offset);
+    index = offset + m.length;
+    if (escaped) {
+      path += escaped[1];
+      continue;
+    }
+    var next = str[index];
+    var prefix = res[2];
+    var name = res[3];
+    var capture = res[4];
+    var group = res[5];
+    var modifier = res[6];
+    var asterisk = res[7];
+    if (path) {
+      tokens.push(path);
+      path = "";
+    }
+    var partial = prefix != null && next != null && next !== prefix;
+    var repeat = modifier === "+" || modifier === "*";
+    var optional = modifier === "?" || modifier === "*";
+    var delimiter = res[2] || defaultDelimiter;
+    var pattern = capture || group;
+    tokens.push({
+      name: name || key++,
+      prefix: prefix || "",
+      delimiter,
+      optional,
+      repeat,
+      partial,
+      asterisk: !!asterisk,
+      pattern: pattern ? escapeGroup(pattern) : asterisk ? ".*" : "[^" + escapeString(delimiter) + "]+?"
+    });
+  }
+  if (index < str.length) {
+    path += str.substr(index);
+  }
+  if (path) {
+    tokens.push(path);
+  }
+  return tokens;
+}
+function compile(str, options) {
+  return tokensToFunction(parse(str, options), options);
+}
+function encodeURIComponentPretty(str) {
+  return encodeURI(str).replace(/[\/?#]/g, function(c) {
+    return "%" + c.charCodeAt(0).toString(16).toUpperCase();
+  });
+}
+function encodeAsterisk(str) {
+  return encodeURI(str).replace(/[?#]/g, function(c) {
+    return "%" + c.charCodeAt(0).toString(16).toUpperCase();
+  });
+}
+function tokensToFunction(tokens, options) {
+  var matches = new Array(tokens.length);
+  for (var i = 0; i < tokens.length; i++) {
+    if (typeof tokens[i] === "object") {
+      matches[i] = new RegExp("^(?:" + tokens[i].pattern + ")$", flags(options));
+    }
+  }
+  return function(obj, opts) {
+    var path = "";
+    var data = obj || {};
+    var options2 = opts || {};
+    var encode2 = options2.pretty ? encodeURIComponentPretty : encodeURIComponent;
+    for (var i2 = 0; i2 < tokens.length; i2++) {
+      var token = tokens[i2];
+      if (typeof token === "string") {
+        path += token;
+        continue;
+      }
+      var value = data[token.name];
+      var segment;
+      if (value == null) {
+        if (token.optional) {
+          if (token.partial) {
+            path += token.prefix;
+          }
+          continue;
+        } else {
+          throw new TypeError('Expected "' + token.name + '" to be defined');
+        }
+      }
+      if (isarray(value)) {
+        if (!token.repeat) {
+          throw new TypeError('Expected "' + token.name + '" to not repeat, but received `' + JSON.stringify(value) + "`");
+        }
+        if (value.length === 0) {
+          if (token.optional) {
+            continue;
+          } else {
+            throw new TypeError('Expected "' + token.name + '" to not be empty');
+          }
+        }
+        for (var j = 0; j < value.length; j++) {
+          segment = encode2(value[j]);
+          if (!matches[i2].test(segment)) {
+            throw new TypeError('Expected all "' + token.name + '" to match "' + token.pattern + '", but received `' + JSON.stringify(segment) + "`");
+          }
+          path += (j === 0 ? token.prefix : token.delimiter) + segment;
+        }
+        continue;
+      }
+      segment = token.asterisk ? encodeAsterisk(value) : encode2(value);
+      if (!matches[i2].test(segment)) {
+        throw new TypeError('Expected "' + token.name + '" to match "' + token.pattern + '", but received "' + segment + '"');
+      }
+      path += token.prefix + segment;
+    }
+    return path;
+  };
+}
+function escapeString(str) {
+  return str.replace(/([.+*?=^!:${}()[\]|\/\\])/g, "\\$1");
+}
+function escapeGroup(group) {
+  return group.replace(/([=!:$\/()])/g, "\\$1");
+}
+function attachKeys(re, keys) {
+  re.keys = keys;
+  return re;
+}
+function flags(options) {
+  return options && options.sensitive ? "" : "i";
+}
+function regexpToRegexp(path, keys) {
+  var groups = path.source.match(/\((?!\?)/g);
+  if (groups) {
+    for (var i = 0; i < groups.length; i++) {
+      keys.push({
+        name: i,
+        prefix: null,
+        delimiter: null,
+        optional: false,
+        repeat: false,
+        partial: false,
+        asterisk: false,
+        pattern: null
+      });
+    }
+  }
+  return attachKeys(path, keys);
+}
+function arrayToRegexp(path, keys, options) {
+  var parts = [];
+  for (var i = 0; i < path.length; i++) {
+    parts.push(pathToRegexp(path[i], keys, options).source);
+  }
+  var regexp = new RegExp("(?:" + parts.join("|") + ")", flags(options));
+  return attachKeys(regexp, keys);
+}
+function stringToRegexp(path, keys, options) {
+  return tokensToRegExp(parse(path, options), keys, options);
+}
+function tokensToRegExp(tokens, keys, options) {
+  if (!isarray(keys)) {
+    options = /** @type {!Object} */
+    keys || options;
+    keys = [];
+  }
+  options = options || {};
+  var strict = options.strict;
+  var end = options.end !== false;
+  var route = "";
+  for (var i = 0; i < tokens.length; i++) {
+    var token = tokens[i];
+    if (typeof token === "string") {
+      route += escapeString(token);
+    } else {
+      var prefix = escapeString(token.prefix);
+      var capture = "(?:" + token.pattern + ")";
+      keys.push(token);
+      if (token.repeat) {
+        capture += "(?:" + prefix + capture + ")*";
+      }
+      if (token.optional) {
+        if (!token.partial) {
+          capture = "(?:" + prefix + "(" + capture + "))?";
+        } else {
+          capture = prefix + "(" + capture + ")?";
+        }
+      } else {
+        capture = prefix + "(" + capture + ")";
+      }
+      route += capture;
+    }
+  }
+  var delimiter = escapeString(options.delimiter || "/");
+  var endsWithDelimiter = route.slice(-delimiter.length) === delimiter;
+  if (!strict) {
+    route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + "(?:" + delimiter + "(?=$))?";
+  }
+  if (end) {
+    route += "$";
+  } else {
+    route += strict && endsWithDelimiter ? "" : "(?=" + delimiter + "|$)";
+  }
+  return attachKeys(new RegExp("^" + route, flags(options)), keys);
+}
+function pathToRegexp(path, keys, options) {
+  if (!isarray(keys)) {
+    options = /** @type {!Object} */
+    keys || options;
+    keys = [];
+  }
+  options = options || {};
+  if (path instanceof RegExp) {
+    return regexpToRegexp(
+      path,
+      /** @type {!Array} */
+      keys
+    );
+  }
+  if (isarray(path)) {
+    return arrayToRegexp(
+      /** @type {!Array} */
+      path,
+      /** @type {!Array} */
+      keys,
+      options
+    );
+  }
+  return stringToRegexp(
+    /** @type {string} */
+    path,
+    /** @type {!Array} */
+    keys,
+    options
+  );
+}
+pathToRegexp_1.parse = parse_1;
+pathToRegexp_1.compile = compile_1;
+pathToRegexp_1.tokensToFunction = tokensToFunction_1;
+pathToRegexp_1.tokensToRegExp = tokensToRegExp_1;
+var regexpCompileCache = /* @__PURE__ */ Object.create(null);
+function fillParams(path, params, routeMsg) {
+  params = params || {};
+  try {
+    var filler = regexpCompileCache[path] || (regexpCompileCache[path] = pathToRegexp_1.compile(path));
+    if (typeof params.pathMatch === "string") {
+      params[0] = params.pathMatch;
+    }
+    return filler(params, { pretty: true });
+  } catch (e) {
+    if (process.env.NODE_ENV !== "production") {
+      warn(typeof params.pathMatch === "string", "missing param for " + routeMsg + ": " + e.message);
+    }
+    return "";
+  } finally {
+    delete params[0];
+  }
+}
+function normalizeLocation(raw, current, append, router) {
+  var next = typeof raw === "string" ? { path: raw } : raw;
+  if (next._normalized) {
+    return next;
+  } else if (next.name) {
+    next = extend({}, raw);
+    var params = next.params;
+    if (params && typeof params === "object") {
+      next.params = extend({}, params);
+    }
+    return next;
+  }
+  if (!next.path && next.params && current) {
+    next = extend({}, next);
+    next._normalized = true;
+    var params$1 = extend(extend({}, current.params), next.params);
+    if (current.name) {
+      next.name = current.name;
+      next.params = params$1;
+    } else if (current.matched.length) {
+      var rawPath = current.matched[current.matched.length - 1].path;
+      next.path = fillParams(rawPath, params$1, "path " + current.path);
+    } else if (process.env.NODE_ENV !== "production") {
+      warn(false, "relative params navigation requires a current route.");
+    }
+    return next;
+  }
+  var parsedPath = parsePath(next.path || "");
+  var basePath = current && current.path || "/";
+  var path = parsedPath.path ? resolvePath(parsedPath.path, basePath, append || next.append) : basePath;
+  var query = resolveQuery(
+    parsedPath.query,
+    next.query,
+    router && router.options.parseQuery
+  );
+  var hash = next.hash || parsedPath.hash;
+  if (hash && hash.charAt(0) !== "#") {
+    hash = "#" + hash;
+  }
+  return {
+    _normalized: true,
+    path,
+    query,
+    hash
+  };
+}
+var toTypes = [String, Object];
+var eventTypes = [String, Array];
+var noop = function() {
+};
+var warnedCustomSlot;
+var warnedTagProp;
+var warnedEventProp;
+var Link = {
+  name: "RouterLink",
+  props: {
+    to: {
+      type: toTypes,
+      required: true
+    },
+    tag: {
+      type: String,
+      default: "a"
+    },
+    custom: Boolean,
+    exact: Boolean,
+    exactPath: Boolean,
+    append: Boolean,
+    replace: Boolean,
+    activeClass: String,
+    exactActiveClass: String,
+    ariaCurrentValue: {
+      type: String,
+      default: "page"
+    },
+    event: {
+      type: eventTypes,
+      default: "click"
+    }
+  },
+  render: function render2(h) {
+    var this$1$1 = this;
+    var router = this.$router;
+    var current = this.$route;
+    var ref2 = router.resolve(
+      this.to,
+      current,
+      this.append
+    );
+    var location = ref2.location;
+    var route = ref2.route;
+    var href = ref2.href;
+    var classes = {};
+    var globalActiveClass = router.options.linkActiveClass;
+    var globalExactActiveClass = router.options.linkExactActiveClass;
+    var activeClassFallback = globalActiveClass == null ? "router-link-active" : globalActiveClass;
+    var exactActiveClassFallback = globalExactActiveClass == null ? "router-link-exact-active" : globalExactActiveClass;
+    var activeClass = this.activeClass == null ? activeClassFallback : this.activeClass;
+    var exactActiveClass = this.exactActiveClass == null ? exactActiveClassFallback : this.exactActiveClass;
+    var compareTarget = route.redirectedFrom ? createRoute(null, normalizeLocation(route.redirectedFrom), null, router) : route;
+    classes[exactActiveClass] = isSameRoute(current, compareTarget, this.exactPath);
+    classes[activeClass] = this.exact || this.exactPath ? classes[exactActiveClass] : isIncludedRoute(current, compareTarget);
+    var ariaCurrentValue = classes[exactActiveClass] ? this.ariaCurrentValue : null;
+    var handler = function(e) {
+      if (guardEvent(e)) {
+        if (this$1$1.replace) {
+          router.replace(location, noop);
+        } else {
+          router.push(location, noop);
+        }
+      }
+    };
+    var on = { click: guardEvent };
+    if (Array.isArray(this.event)) {
+      this.event.forEach(function(e) {
+        on[e] = handler;
+      });
+    } else {
+      on[this.event] = handler;
+    }
+    var data = { class: classes };
+    var scopedSlot = !this.$scopedSlots.$hasNormal && this.$scopedSlots.default && this.$scopedSlots.default({
+      href,
+      route,
+      navigate: handler,
+      isActive: classes[activeClass],
+      isExactActive: classes[exactActiveClass]
+    });
+    if (scopedSlot) {
+      if (process.env.NODE_ENV !== "production" && !this.custom) {
+        !warnedCustomSlot && warn(false, 'In Vue Router 4, the v-slot API will by default wrap its content with an <a> element. Use the custom prop to remove this warning:\n<router-link v-slot="{ navigate, href }" custom></router-link>\n');
+        warnedCustomSlot = true;
+      }
+      if (scopedSlot.length === 1) {
+        return scopedSlot[0];
+      } else if (scopedSlot.length > 1 || !scopedSlot.length) {
+        if (process.env.NODE_ENV !== "production") {
+          warn(
+            false,
+            '<router-link> with to="' + this.to + "\" is trying to use a scoped slot but it didn't provide exactly one child. Wrapping the content with a span element."
+          );
+        }
+        return scopedSlot.length === 0 ? h() : h("span", {}, scopedSlot);
+      }
+    }
+    if (process.env.NODE_ENV !== "production") {
+      if ("tag" in this.$options.propsData && !warnedTagProp) {
+        warn(
+          false,
+          "<router-link>'s tag prop is deprecated and has been removed in Vue Router 4. Use the v-slot API to remove this warning: https://next.router.vuejs.org/guide/migration/#removal-of-event-and-tag-props-in-router-link."
+        );
+        warnedTagProp = true;
+      }
+      if ("event" in this.$options.propsData && !warnedEventProp) {
+        warn(
+          false,
+          "<router-link>'s event prop is deprecated and has been removed in Vue Router 4. Use the v-slot API to remove this warning: https://next.router.vuejs.org/guide/migration/#removal-of-event-and-tag-props-in-router-link."
+        );
+        warnedEventProp = true;
+      }
+    }
+    if (this.tag === "a") {
+      data.on = on;
+      data.attrs = { href, "aria-current": ariaCurrentValue };
+    } else {
+      var a = findAnchor(this.$slots.default);
+      if (a) {
+        a.isStatic = false;
+        var aData = a.data = extend({}, a.data);
+        aData.on = aData.on || {};
+        for (var event in aData.on) {
+          var handler$1 = aData.on[event];
+          if (event in on) {
+            aData.on[event] = Array.isArray(handler$1) ? handler$1 : [handler$1];
+          }
+        }
+        for (var event$1 in on) {
+          if (event$1 in aData.on) {
+            aData.on[event$1].push(on[event$1]);
+          } else {
+            aData.on[event$1] = handler;
+          }
+        }
+        var aAttrs = a.data.attrs = extend({}, a.data.attrs);
+        aAttrs.href = href;
+        aAttrs["aria-current"] = ariaCurrentValue;
+      } else {
+        data.on = on;
+      }
+    }
+    return h(this.tag, data, this.$slots.default);
+  }
+};
+function guardEvent(e) {
+  if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) {
+    return;
+  }
+  if (e.defaultPrevented) {
+    return;
+  }
+  if (e.button !== void 0 && e.button !== 0) {
+    return;
+  }
+  if (e.currentTarget && e.currentTarget.getAttribute) {
+    var target = e.currentTarget.getAttribute("target");
+    if (/\b_blank\b/i.test(target)) {
+      return;
+    }
+  }
+  if (e.preventDefault) {
+    e.preventDefault();
+  }
+  return true;
+}
+function findAnchor(children) {
+  if (children) {
+    var child;
+    for (var i = 0; i < children.length; i++) {
+      child = children[i];
+      if (child.tag === "a") {
+        return child;
+      }
+      if (child.children && (child = findAnchor(child.children))) {
+        return child;
+      }
+    }
+  }
+}
+var _Vue;
+function install(Vue2) {
+  if (install.installed && _Vue === Vue2) {
+    return;
+  }
+  install.installed = true;
+  _Vue = Vue2;
+  var isDef = function(v) {
+    return v !== void 0;
+  };
+  var registerInstance = function(vm, callVal) {
+    var i = vm.$options._parentVnode;
+    if (isDef(i) && isDef(i = i.data) && isDef(i = i.registerRouteInstance)) {
+      i(vm, callVal);
+    }
+  };
+  Vue2.mixin({
+    beforeCreate: function beforeCreate() {
+      if (isDef(this.$options.router)) {
+        this._routerRoot = this;
+        this._router = this.$options.router;
+        this._router.init(this);
+        Vue2.util.defineReactive(this, "_route", this._router.history.current);
+      } else {
+        this._routerRoot = this.$parent && this.$parent._routerRoot || this;
+      }
+      registerInstance(this, this);
+    },
+    destroyed: function destroyed() {
+      registerInstance(this);
+    }
+  });
+  Object.defineProperty(Vue2.prototype, "$router", {
+    get: function get() {
+      return this._routerRoot._router;
+    }
+  });
+  Object.defineProperty(Vue2.prototype, "$route", {
+    get: function get() {
+      return this._routerRoot._route;
+    }
+  });
+  Vue2.component("RouterView", View);
+  Vue2.component("RouterLink", Link);
+  var strats = Vue2.config.optionMergeStrategies;
+  strats.beforeRouteEnter = strats.beforeRouteLeave = strats.beforeRouteUpdate = strats.created;
+}
+var inBrowser = typeof window !== "undefined";
+function createRouteMap(routes, oldPathList, oldPathMap, oldNameMap, parentRoute) {
+  var pathList = oldPathList || [];
+  var pathMap = oldPathMap || /* @__PURE__ */ Object.create(null);
+  var nameMap = oldNameMap || /* @__PURE__ */ Object.create(null);
+  routes.forEach(function(route) {
+    addRouteRecord(pathList, pathMap, nameMap, route, parentRoute);
+  });
+  for (var i = 0, l = pathList.length; i < l; i++) {
+    if (pathList[i] === "*") {
+      pathList.push(pathList.splice(i, 1)[0]);
+      l--;
+      i--;
+    }
+  }
+  if (process.env.NODE_ENV === "development") {
+    var found = pathList.filter(function(path) {
+      return path && path.charAt(0) !== "*" && path.charAt(0) !== "/";
+    });
+    if (found.length > 0) {
+      var pathNames = found.map(function(path) {
+        return "- " + path;
+      }).join("\n");
+      warn(false, "Non-nested routes must include a leading slash character. Fix the following routes: \n" + pathNames);
+    }
+  }
+  return {
+    pathList,
+    pathMap,
+    nameMap
+  };
+}
+function addRouteRecord(pathList, pathMap, nameMap, route, parent, matchAs) {
+  var path = route.path;
+  var name = route.name;
+  if (process.env.NODE_ENV !== "production") {
+    assert(path != null, '"path" is required in a route configuration.');
+    assert(
+      typeof route.component !== "string",
+      'route config "component" for path: ' + String(
+        path || name
+      ) + " cannot be a string id. Use an actual component instead."
+    );
+    warn(
+      // eslint-disable-next-line no-control-regex
+      !/[^\u0000-\u007F]+/.test(path),
+      'Route with path "' + path + '" contains unencoded characters, make sure your path is correctly encoded before passing it to the router. Use encodeURI to encode static segments of your path.'
+    );
+  }
+  var pathToRegexpOptions = route.pathToRegexpOptions || {};
+  var normalizedPath = normalizePath(path, parent, pathToRegexpOptions.strict);
+  if (typeof route.caseSensitive === "boolean") {
+    pathToRegexpOptions.sensitive = route.caseSensitive;
+  }
+  var record = {
+    path: normalizedPath,
+    regex: compileRouteRegex(normalizedPath, pathToRegexpOptions),
+    components: route.components || { default: route.component },
+    alias: route.alias ? typeof route.alias === "string" ? [route.alias] : route.alias : [],
+    instances: {},
+    enteredCbs: {},
+    name,
+    parent,
+    matchAs,
+    redirect: route.redirect,
+    beforeEnter: route.beforeEnter,
+    meta: route.meta || {},
+    props: route.props == null ? {} : route.components ? route.props : { default: route.props }
+  };
+  if (route.children) {
+    if (process.env.NODE_ENV !== "production") {
+      if (route.name && !route.redirect && route.children.some(function(child) {
+        return /^\/?$/.test(child.path);
+      })) {
+        warn(
+          false,
+          "Named Route '" + route.name + "' has a default child route. When navigating to this named route (:to=\"{name: '" + route.name + "'}\"), the default child route will not be rendered. Remove the name from this route and use the name of the default child route for named links instead."
+        );
+      }
+    }
+    route.children.forEach(function(child) {
+      var childMatchAs = matchAs ? cleanPath(matchAs + "/" + child.path) : void 0;
+      addRouteRecord(pathList, pathMap, nameMap, child, record, childMatchAs);
+    });
+  }
+  if (!pathMap[record.path]) {
+    pathList.push(record.path);
+    pathMap[record.path] = record;
+  }
+  if (route.alias !== void 0) {
+    var aliases = Array.isArray(route.alias) ? route.alias : [route.alias];
+    for (var i = 0; i < aliases.length; ++i) {
+      var alias = aliases[i];
+      if (process.env.NODE_ENV !== "production" && alias === path) {
+        warn(
+          false,
+          'Found an alias with the same value as the path: "' + path + '". You have to remove that alias. It will be ignored in development.'
+        );
+        continue;
+      }
+      var aliasRoute = {
+        path: alias,
+        children: route.children
+      };
+      addRouteRecord(
+        pathList,
+        pathMap,
+        nameMap,
+        aliasRoute,
+        parent,
+        record.path || "/"
+        // matchAs
+      );
+    }
+  }
+  if (name) {
+    if (!nameMap[name]) {
+      nameMap[name] = record;
+    } else if (process.env.NODE_ENV !== "production" && !matchAs) {
+      warn(
+        false,
+        'Duplicate named routes definition: { name: "' + name + '", path: "' + record.path + '" }'
+      );
+    }
+  }
+}
+function compileRouteRegex(path, pathToRegexpOptions) {
+  var regex = pathToRegexp_1(path, [], pathToRegexpOptions);
+  if (process.env.NODE_ENV !== "production") {
+    var keys = /* @__PURE__ */ Object.create(null);
+    regex.keys.forEach(function(key) {
+      warn(
+        !keys[key.name],
+        'Duplicate param keys in route with path: "' + path + '"'
+      );
+      keys[key.name] = true;
+    });
+  }
+  return regex;
+}
+function normalizePath(path, parent, strict) {
+  if (!strict) {
+    path = path.replace(/\/$/, "");
+  }
+  if (path[0] === "/") {
+    return path;
+  }
+  if (parent == null) {
+    return path;
+  }
+  return cleanPath(parent.path + "/" + path);
+}
+function createMatcher(routes, router) {
+  var ref2 = createRouteMap(routes);
+  var pathList = ref2.pathList;
+  var pathMap = ref2.pathMap;
+  var nameMap = ref2.nameMap;
+  function addRoutes2(routes2) {
+    createRouteMap(routes2, pathList, pathMap, nameMap);
+  }
+  function addRoute2(parentOrRoute, route) {
+    var parent = typeof parentOrRoute !== "object" ? nameMap[parentOrRoute] : void 0;
+    createRouteMap([route || parentOrRoute], pathList, pathMap, nameMap, parent);
+    if (parent && parent.alias.length) {
+      createRouteMap(
+        // $flow-disable-line route is defined if parent is
+        parent.alias.map(function(alias2) {
+          return { path: alias2, children: [route] };
+        }),
+        pathList,
+        pathMap,
+        nameMap,
+        parent
+      );
+    }
+  }
+  function getRoutes2() {
+    return pathList.map(function(path) {
+      return pathMap[path];
+    });
+  }
+  function match2(raw, currentRoute, redirectedFrom) {
+    var location = normalizeLocation(raw, currentRoute, false, router);
+    var name = location.name;
+    if (name) {
+      var record = nameMap[name];
+      if (process.env.NODE_ENV !== "production") {
+        warn(record, "Route with name '" + name + "' does not exist");
+      }
+      if (!record) {
+        return _createRoute(null, location);
+      }
+      var paramNames = record.regex.keys.filter(function(key2) {
+        return !key2.optional;
+      }).map(function(key2) {
+        return key2.name;
+      });
+      if (typeof location.params !== "object") {
+        location.params = {};
+      }
+      if (currentRoute && typeof currentRoute.params === "object") {
+        for (var key in currentRoute.params) {
+          if (!(key in location.params) && paramNames.indexOf(key) > -1) {
+            location.params[key] = currentRoute.params[key];
+          }
+        }
+      }
+      location.path = fillParams(record.path, location.params, 'named route "' + name + '"');
+      return _createRoute(record, location, redirectedFrom);
+    } else if (location.path) {
+      location.params = {};
+      for (var i = 0; i < pathList.length; i++) {
+        var path = pathList[i];
+        var record$1 = pathMap[path];
+        if (matchRoute(record$1.regex, location.path, location.params)) {
+          return _createRoute(record$1, location, redirectedFrom);
+        }
+      }
+    }
+    return _createRoute(null, location);
+  }
+  function redirect(record, location) {
+    var originalRedirect = record.redirect;
+    var redirect2 = typeof originalRedirect === "function" ? originalRedirect(createRoute(record, location, null, router)) : originalRedirect;
+    if (typeof redirect2 === "string") {
+      redirect2 = { path: redirect2 };
+    }
+    if (!redirect2 || typeof redirect2 !== "object") {
+      if (process.env.NODE_ENV !== "production") {
+        warn(
+          false,
+          "invalid redirect option: " + JSON.stringify(redirect2)
+        );
+      }
+      return _createRoute(null, location);
+    }
+    var re = redirect2;
+    var name = re.name;
+    var path = re.path;
+    var query = location.query;
+    var hash = location.hash;
+    var params = location.params;
+    query = re.hasOwnProperty("query") ? re.query : query;
+    hash = re.hasOwnProperty("hash") ? re.hash : hash;
+    params = re.hasOwnProperty("params") ? re.params : params;
+    if (name) {
+      var targetRecord = nameMap[name];
+      if (process.env.NODE_ENV !== "production") {
+        assert(targetRecord, 'redirect failed: named route "' + name + '" not found.');
+      }
+      return match2({
+        _normalized: true,
+        name,
+        query,
+        hash,
+        params
+      }, void 0, location);
+    } else if (path) {
+      var rawPath = resolveRecordPath(path, record);
+      var resolvedPath = fillParams(rawPath, params, 'redirect route with path "' + rawPath + '"');
+      return match2({
+        _normalized: true,
+        path: resolvedPath,
+        query,
+        hash
+      }, void 0, location);
+    } else {
+      if (process.env.NODE_ENV !== "production") {
+        warn(false, "invalid redirect option: " + JSON.stringify(redirect2));
+      }
+      return _createRoute(null, location);
+    }
+  }
+  function alias(record, location, matchAs) {
+    var aliasedPath = fillParams(matchAs, location.params, 'aliased route with path "' + matchAs + '"');
+    var aliasedMatch = match2({
+      _normalized: true,
+      path: aliasedPath
+    });
+    if (aliasedMatch) {
+      var matched = aliasedMatch.matched;
+      var aliasedRecord = matched[matched.length - 1];
+      location.params = aliasedMatch.params;
+      return _createRoute(aliasedRecord, location);
+    }
+    return _createRoute(null, location);
+  }
+  function _createRoute(record, location, redirectedFrom) {
+    if (record && record.redirect) {
+      return redirect(record, redirectedFrom || location);
+    }
+    if (record && record.matchAs) {
+      return alias(record, location, record.matchAs);
+    }
+    return createRoute(record, location, redirectedFrom, router);
+  }
+  return {
+    match: match2,
+    addRoute: addRoute2,
+    getRoutes: getRoutes2,
+    addRoutes: addRoutes2
+  };
+}
+function matchRoute(regex, path, params) {
+  var m = path.match(regex);
+  if (!m) {
+    return false;
+  } else if (!params) {
+    return true;
+  }
+  for (var i = 1, len = m.length; i < len; ++i) {
+    var key = regex.keys[i - 1];
+    if (key) {
+      params[key.name || "pathMatch"] = typeof m[i] === "string" ? decode(m[i]) : m[i];
+    }
+  }
+  return true;
+}
+function resolveRecordPath(path, record) {
+  return resolvePath(path, record.parent ? record.parent.path : "/", true);
+}
+var Time = inBrowser && window.performance && window.performance.now ? window.performance : Date;
+function genStateKey() {
+  return Time.now().toFixed(3);
+}
+var _key = genStateKey();
+function getStateKey() {
+  return _key;
+}
+function setStateKey(key) {
+  return _key = key;
+}
+var positionStore = /* @__PURE__ */ Object.create(null);
+function setupScroll() {
+  if ("scrollRestoration" in window.history) {
+    window.history.scrollRestoration = "manual";
+  }
+  var protocolAndPath = window.location.protocol + "//" + window.location.host;
+  var absolutePath = window.location.href.replace(protocolAndPath, "");
+  var stateCopy = extend({}, window.history.state);
+  stateCopy.key = getStateKey();
+  window.history.replaceState(stateCopy, "", absolutePath);
+  window.addEventListener("popstate", handlePopState);
+  return function() {
+    window.removeEventListener("popstate", handlePopState);
+  };
+}
+function handleScroll(router, to, from, isPop) {
+  if (!router.app) {
+    return;
+  }
+  var behavior = router.options.scrollBehavior;
+  if (!behavior) {
+    return;
+  }
+  if (process.env.NODE_ENV !== "production") {
+    assert(typeof behavior === "function", "scrollBehavior must be a function");
+  }
+  router.app.$nextTick(function() {
+    var position = getScrollPosition();
+    var shouldScroll = behavior.call(
+      router,
+      to,
+      from,
+      isPop ? position : null
+    );
+    if (!shouldScroll) {
+      return;
+    }
+    if (typeof shouldScroll.then === "function") {
+      shouldScroll.then(function(shouldScroll2) {
+        scrollToPosition(shouldScroll2, position);
+      }).catch(function(err) {
+        if (process.env.NODE_ENV !== "production") {
+          assert(false, err.toString());
+        }
+      });
+    } else {
+      scrollToPosition(shouldScroll, position);
+    }
+  });
+}
+function saveScrollPosition() {
+  var key = getStateKey();
+  if (key) {
+    positionStore[key] = {
+      x: window.pageXOffset,
+      y: window.pageYOffset
+    };
+  }
+}
+function handlePopState(e) {
+  saveScrollPosition();
+  if (e.state && e.state.key) {
+    setStateKey(e.state.key);
+  }
+}
+function getScrollPosition() {
+  var key = getStateKey();
+  if (key) {
+    return positionStore[key];
+  }
+}
+function getElementPosition(el, offset) {
+  var docEl = document.documentElement;
+  var docRect = docEl.getBoundingClientRect();
+  var elRect = el.getBoundingClientRect();
+  return {
+    x: elRect.left - docRect.left - offset.x,
+    y: elRect.top - docRect.top - offset.y
+  };
+}
+function isValidPosition(obj) {
+  return isNumber(obj.x) || isNumber(obj.y);
+}
+function normalizePosition(obj) {
+  return {
+    x: isNumber(obj.x) ? obj.x : window.pageXOffset,
+    y: isNumber(obj.y) ? obj.y : window.pageYOffset
+  };
+}
+function normalizeOffset(obj) {
+  return {
+    x: isNumber(obj.x) ? obj.x : 0,
+    y: isNumber(obj.y) ? obj.y : 0
+  };
+}
+function isNumber(v) {
+  return typeof v === "number";
+}
+var hashStartsWithNumberRE = /^#\d/;
+function scrollToPosition(shouldScroll, position) {
+  var isObject = typeof shouldScroll === "object";
+  if (isObject && typeof shouldScroll.selector === "string") {
+    var el = hashStartsWithNumberRE.test(shouldScroll.selector) ? document.getElementById(shouldScroll.selector.slice(1)) : document.querySelector(shouldScroll.selector);
+    if (el) {
+      var offset = shouldScroll.offset && typeof shouldScroll.offset === "object" ? shouldScroll.offset : {};
+      offset = normalizeOffset(offset);
+      position = getElementPosition(el, offset);
+    } else if (isValidPosition(shouldScroll)) {
+      position = normalizePosition(shouldScroll);
+    }
+  } else if (isObject && isValidPosition(shouldScroll)) {
+    position = normalizePosition(shouldScroll);
+  }
+  if (position) {
+    if ("scrollBehavior" in document.documentElement.style) {
+      window.scrollTo({
+        left: position.x,
+        top: position.y,
+        // $flow-disable-line
+        behavior: shouldScroll.behavior
+      });
+    } else {
+      window.scrollTo(position.x, position.y);
+    }
+  }
+}
+var supportsPushState = inBrowser && function() {
+  var ua = window.navigator.userAgent;
+  if ((ua.indexOf("Android 2.") !== -1 || ua.indexOf("Android 4.0") !== -1) && ua.indexOf("Mobile Safari") !== -1 && ua.indexOf("Chrome") === -1 && ua.indexOf("Windows Phone") === -1) {
+    return false;
+  }
+  return window.history && typeof window.history.pushState === "function";
+}();
+function pushState(url, replace2) {
+  saveScrollPosition();
+  var history = window.history;
+  try {
+    if (replace2) {
+      var stateCopy = extend({}, history.state);
+      stateCopy.key = getStateKey();
+      history.replaceState(stateCopy, "", url);
+    } else {
+      history.pushState({ key: setStateKey(genStateKey()) }, "", url);
+    }
+  } catch (e) {
+    window.location[replace2 ? "replace" : "assign"](url);
+  }
+}
+function replaceState(url) {
+  pushState(url, true);
+}
+var NavigationFailureType = {
+  redirected: 2,
+  aborted: 4,
+  cancelled: 8,
+  duplicated: 16
+};
+function createNavigationRedirectedError(from, to) {
+  return createRouterError(
+    from,
+    to,
+    NavigationFailureType.redirected,
+    'Redirected when going from "' + from.fullPath + '" to "' + stringifyRoute(
+      to
+    ) + '" via a navigation guard.'
+  );
+}
+function createNavigationDuplicatedError(from, to) {
+  var error = createRouterError(
+    from,
+    to,
+    NavigationFailureType.duplicated,
+    'Avoided redundant navigation to current location: "' + from.fullPath + '".'
+  );
+  error.name = "NavigationDuplicated";
+  return error;
+}
+function createNavigationCancelledError(from, to) {
+  return createRouterError(
+    from,
+    to,
+    NavigationFailureType.cancelled,
+    'Navigation cancelled from "' + from.fullPath + '" to "' + to.fullPath + '" with a new navigation.'
+  );
+}
+function createNavigationAbortedError(from, to) {
+  return createRouterError(
+    from,
+    to,
+    NavigationFailureType.aborted,
+    'Navigation aborted from "' + from.fullPath + '" to "' + to.fullPath + '" via a navigation guard.'
+  );
+}
+function createRouterError(from, to, type, message) {
+  var error = new Error(message);
+  error._isRouter = true;
+  error.from = from;
+  error.to = to;
+  error.type = type;
+  return error;
+}
+var propertiesToLog = ["params", "query", "hash"];
+function stringifyRoute(to) {
+  if (typeof to === "string") {
+    return to;
+  }
+  if ("path" in to) {
+    return to.path;
+  }
+  var location = {};
+  propertiesToLog.forEach(function(key) {
+    if (key in to) {
+      location[key] = to[key];
+    }
+  });
+  return JSON.stringify(location, null, 2);
+}
+function isError(err) {
+  return Object.prototype.toString.call(err).indexOf("Error") > -1;
+}
+function isNavigationFailure(err, errorType) {
+  return isError(err) && err._isRouter && (errorType == null || err.type === errorType);
+}
+function runQueue(queue, fn, cb) {
+  var step = function(index) {
+    if (index >= queue.length) {
+      cb();
+    } else {
+      if (queue[index]) {
+        fn(queue[index], function() {
+          step(index + 1);
+        });
+      } else {
+        step(index + 1);
+      }
+    }
+  };
+  step(0);
+}
+function resolveAsyncComponents(matched) {
+  return function(to, from, next) {
+    var hasAsync = false;
+    var pending = 0;
+    var error = null;
+    flatMapComponents(matched, function(def, _, match2, key) {
+      if (typeof def === "function" && def.cid === void 0) {
+        hasAsync = true;
+        pending++;
+        var resolve2 = once(function(resolvedDef) {
+          if (isESModule(resolvedDef)) {
+            resolvedDef = resolvedDef.default;
+          }
+          def.resolved = typeof resolvedDef === "function" ? resolvedDef : _Vue.extend(resolvedDef);
+          match2.components[key] = resolvedDef;
+          pending--;
+          if (pending <= 0) {
+            next();
+          }
+        });
+        var reject = once(function(reason) {
+          var msg = "Failed to resolve async component " + key + ": " + reason;
+          process.env.NODE_ENV !== "production" && warn(false, msg);
+          if (!error) {
+            error = isError(reason) ? reason : new Error(msg);
+            next(error);
+          }
+        });
+        var res;
+        try {
+          res = def(resolve2, reject);
+        } catch (e) {
+          reject(e);
+        }
+        if (res) {
+          if (typeof res.then === "function") {
+            res.then(resolve2, reject);
+          } else {
+            var comp = res.component;
+            if (comp && typeof comp.then === "function") {
+              comp.then(resolve2, reject);
+            }
+          }
+        }
+      }
+    });
+    if (!hasAsync) {
+      next();
+    }
+  };
+}
+function flatMapComponents(matched, fn) {
+  return flatten(matched.map(function(m) {
+    return Object.keys(m.components).map(function(key) {
+      return fn(
+        m.components[key],
+        m.instances[key],
+        m,
+        key
+      );
+    });
+  }));
+}
+function flatten(arr) {
+  return Array.prototype.concat.apply([], arr);
+}
+var hasSymbol = typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol";
+function isESModule(obj) {
+  return obj.__esModule || hasSymbol && obj[Symbol.toStringTag] === "Module";
+}
+function once(fn) {
+  var called = false;
+  return function() {
+    var args = [], len = arguments.length;
+    while (len--)
+      args[len] = arguments[len];
+    if (called) {
+      return;
+    }
+    called = true;
+    return fn.apply(this, args);
+  };
+}
+var History = function History2(router, base) {
+  this.router = router;
+  this.base = normalizeBase(base);
+  this.current = START;
+  this.pending = null;
+  this.ready = false;
+  this.readyCbs = [];
+  this.readyErrorCbs = [];
+  this.errorCbs = [];
+  this.listeners = [];
+};
+History.prototype.listen = function listen(cb) {
+  this.cb = cb;
+};
+History.prototype.onReady = function onReady(cb, errorCb) {
+  if (this.ready) {
+    cb();
+  } else {
+    this.readyCbs.push(cb);
+    if (errorCb) {
+      this.readyErrorCbs.push(errorCb);
+    }
+  }
+};
+History.prototype.onError = function onError(errorCb) {
+  this.errorCbs.push(errorCb);
+};
+History.prototype.transitionTo = function transitionTo(location, onComplete, onAbort) {
+  var this$1$1 = this;
+  var route;
+  try {
+    route = this.router.match(location, this.current);
+  } catch (e) {
+    this.errorCbs.forEach(function(cb) {
+      cb(e);
+    });
+    throw e;
+  }
+  var prev = this.current;
+  this.confirmTransition(
+    route,
+    function() {
+      this$1$1.updateRoute(route);
+      onComplete && onComplete(route);
+      this$1$1.ensureURL();
+      this$1$1.router.afterHooks.forEach(function(hook) {
+        hook && hook(route, prev);
+      });
+      if (!this$1$1.ready) {
+        this$1$1.ready = true;
+        this$1$1.readyCbs.forEach(function(cb) {
+          cb(route);
+        });
+      }
+    },
+    function(err) {
+      if (onAbort) {
+        onAbort(err);
+      }
+      if (err && !this$1$1.ready) {
+        if (!isNavigationFailure(err, NavigationFailureType.redirected) || prev !== START) {
+          this$1$1.ready = true;
+          this$1$1.readyErrorCbs.forEach(function(cb) {
+            cb(err);
+          });
+        }
+      }
+    }
+  );
+};
+History.prototype.confirmTransition = function confirmTransition(route, onComplete, onAbort) {
+  var this$1$1 = this;
+  var current = this.current;
+  this.pending = route;
+  var abort = function(err) {
+    if (!isNavigationFailure(err) && isError(err)) {
+      if (this$1$1.errorCbs.length) {
+        this$1$1.errorCbs.forEach(function(cb) {
+          cb(err);
+        });
+      } else {
+        if (process.env.NODE_ENV !== "production") {
+          warn(false, "uncaught error during route navigation:");
+        }
+        console.error(err);
+      }
+    }
+    onAbort && onAbort(err);
+  };
+  var lastRouteIndex = route.matched.length - 1;
+  var lastCurrentIndex = current.matched.length - 1;
+  if (isSameRoute(route, current) && // in the case the route map has been dynamically appended to
+  lastRouteIndex === lastCurrentIndex && route.matched[lastRouteIndex] === current.matched[lastCurrentIndex]) {
+    this.ensureURL();
+    if (route.hash) {
+      handleScroll(this.router, current, route, false);
+    }
+    return abort(createNavigationDuplicatedError(current, route));
+  }
+  var ref2 = resolveQueue(
+    this.current.matched,
+    route.matched
+  );
+  var updated = ref2.updated;
+  var deactivated = ref2.deactivated;
+  var activated = ref2.activated;
+  var queue = [].concat(
+    // in-component leave guards
+    extractLeaveGuards(deactivated),
+    // global before hooks
+    this.router.beforeHooks,
+    // in-component update hooks
+    extractUpdateHooks(updated),
+    // in-config enter guards
+    activated.map(function(m) {
+      return m.beforeEnter;
+    }),
+    // async components
+    resolveAsyncComponents(activated)
+  );
+  var iterator = function(hook, next) {
+    if (this$1$1.pending !== route) {
+      return abort(createNavigationCancelledError(current, route));
+    }
+    try {
+      hook(route, current, function(to) {
+        if (to === false) {
+          this$1$1.ensureURL(true);
+          abort(createNavigationAbortedError(current, route));
+        } else if (isError(to)) {
+          this$1$1.ensureURL(true);
+          abort(to);
+        } else if (typeof to === "string" || typeof to === "object" && (typeof to.path === "string" || typeof to.name === "string")) {
+          abort(createNavigationRedirectedError(current, route));
+          if (typeof to === "object" && to.replace) {
+            this$1$1.replace(to);
+          } else {
+            this$1$1.push(to);
+          }
+        } else {
+          next(to);
+        }
+      });
+    } catch (e) {
+      abort(e);
+    }
+  };
+  runQueue(queue, iterator, function() {
+    var enterGuards = extractEnterGuards(activated);
+    var queue2 = enterGuards.concat(this$1$1.router.resolveHooks);
+    runQueue(queue2, iterator, function() {
+      if (this$1$1.pending !== route) {
+        return abort(createNavigationCancelledError(current, route));
+      }
+      this$1$1.pending = null;
+      onComplete(route);
+      if (this$1$1.router.app) {
+        this$1$1.router.app.$nextTick(function() {
+          handleRouteEntered(route);
+        });
+      }
+    });
+  });
+};
+History.prototype.updateRoute = function updateRoute(route) {
+  this.current = route;
+  this.cb && this.cb(route);
+};
+History.prototype.setupListeners = function setupListeners() {
+};
+History.prototype.teardown = function teardown() {
+  this.listeners.forEach(function(cleanupListener) {
+    cleanupListener();
+  });
+  this.listeners = [];
+  this.current = START;
+  this.pending = null;
+};
+function normalizeBase(base) {
+  if (!base) {
+    if (inBrowser) {
+      var baseEl = document.querySelector("base");
+      base = baseEl && baseEl.getAttribute("href") || "/";
+      base = base.replace(/^https?:\/\/[^\/]+/, "");
+    } else {
+      base = "/";
+    }
+  }
+  if (base.charAt(0) !== "/") {
+    base = "/" + base;
+  }
+  return base.replace(/\/$/, "");
+}
+function resolveQueue(current, next) {
+  var i;
+  var max = Math.max(current.length, next.length);
+  for (i = 0; i < max; i++) {
+    if (current[i] !== next[i]) {
+      break;
+    }
+  }
+  return {
+    updated: next.slice(0, i),
+    activated: next.slice(i),
+    deactivated: current.slice(i)
+  };
+}
+function extractGuards(records, name, bind, reverse) {
+  var guards = flatMapComponents(records, function(def, instance, match2, key) {
+    var guard = extractGuard(def, name);
+    if (guard) {
+      return Array.isArray(guard) ? guard.map(function(guard2) {
+        return bind(guard2, instance, match2, key);
+      }) : bind(guard, instance, match2, key);
+    }
+  });
+  return flatten(reverse ? guards.reverse() : guards);
+}
+function extractGuard(def, key) {
+  if (typeof def !== "function") {
+    def = _Vue.extend(def);
+  }
+  return def.options[key];
+}
+function extractLeaveGuards(deactivated) {
+  return extractGuards(deactivated, "beforeRouteLeave", bindGuard, true);
+}
+function extractUpdateHooks(updated) {
+  return extractGuards(updated, "beforeRouteUpdate", bindGuard);
+}
+function bindGuard(guard, instance) {
+  if (instance) {
+    return function boundRouteGuard() {
+      return guard.apply(instance, arguments);
+    };
+  }
+}
+function extractEnterGuards(activated) {
+  return extractGuards(
+    activated,
+    "beforeRouteEnter",
+    function(guard, _, match2, key) {
+      return bindEnterGuard(guard, match2, key);
+    }
+  );
+}
+function bindEnterGuard(guard, match2, key) {
+  return function routeEnterGuard(to, from, next) {
+    return guard(to, from, function(cb) {
+      if (typeof cb === "function") {
+        if (!match2.enteredCbs[key]) {
+          match2.enteredCbs[key] = [];
+        }
+        match2.enteredCbs[key].push(cb);
+      }
+      next(cb);
+    });
+  };
+}
+var HTML5History = /* @__PURE__ */ function(History3) {
+  function HTML5History2(router, base) {
+    History3.call(this, router, base);
+    this._startLocation = getLocation(this.base);
+  }
+  if (History3)
+    HTML5History2.__proto__ = History3;
+  HTML5History2.prototype = Object.create(History3 && History3.prototype);
+  HTML5History2.prototype.constructor = HTML5History2;
+  HTML5History2.prototype.setupListeners = function setupListeners2() {
+    var this$1$1 = this;
+    if (this.listeners.length > 0) {
+      return;
+    }
+    var router = this.router;
+    var expectScroll = router.options.scrollBehavior;
+    var supportsScroll = supportsPushState && expectScroll;
+    if (supportsScroll) {
+      this.listeners.push(setupScroll());
+    }
+    var handleRoutingEvent = function() {
+      var current = this$1$1.current;
+      var location = getLocation(this$1$1.base);
+      if (this$1$1.current === START && location === this$1$1._startLocation) {
+        return;
+      }
+      this$1$1.transitionTo(location, function(route) {
+        if (supportsScroll) {
+          handleScroll(router, route, current, true);
+        }
+      });
+    };
+    window.addEventListener("popstate", handleRoutingEvent);
+    this.listeners.push(function() {
+      window.removeEventListener("popstate", handleRoutingEvent);
+    });
+  };
+  HTML5History2.prototype.go = function go2(n) {
+    window.history.go(n);
+  };
+  HTML5History2.prototype.push = function push2(location, onComplete, onAbort) {
+    var this$1$1 = this;
+    var ref2 = this;
+    var fromRoute = ref2.current;
+    this.transitionTo(location, function(route) {
+      pushState(cleanPath(this$1$1.base + route.fullPath));
+      handleScroll(this$1$1.router, route, fromRoute, false);
+      onComplete && onComplete(route);
+    }, onAbort);
+  };
+  HTML5History2.prototype.replace = function replace2(location, onComplete, onAbort) {
+    var this$1$1 = this;
+    var ref2 = this;
+    var fromRoute = ref2.current;
+    this.transitionTo(location, function(route) {
+      replaceState(cleanPath(this$1$1.base + route.fullPath));
+      handleScroll(this$1$1.router, route, fromRoute, false);
+      onComplete && onComplete(route);
+    }, onAbort);
+  };
+  HTML5History2.prototype.ensureURL = function ensureURL(push2) {
+    if (getLocation(this.base) !== this.current.fullPath) {
+      var current = cleanPath(this.base + this.current.fullPath);
+      push2 ? pushState(current) : replaceState(current);
+    }
+  };
+  HTML5History2.prototype.getCurrentLocation = function getCurrentLocation() {
+    return getLocation(this.base);
+  };
+  return HTML5History2;
+}(History);
+function getLocation(base) {
+  var path = window.location.pathname;
+  var pathLowerCase = path.toLowerCase();
+  var baseLowerCase = base.toLowerCase();
+  if (base && (pathLowerCase === baseLowerCase || pathLowerCase.indexOf(cleanPath(baseLowerCase + "/")) === 0)) {
+    path = path.slice(base.length);
+  }
+  return (path || "/") + window.location.search + window.location.hash;
+}
+var HashHistory = /* @__PURE__ */ function(History3) {
+  function HashHistory2(router, base, fallback) {
+    History3.call(this, router, base);
+    if (fallback && checkFallback(this.base)) {
+      return;
+    }
+    ensureSlash();
+  }
+  if (History3)
+    HashHistory2.__proto__ = History3;
+  HashHistory2.prototype = Object.create(History3 && History3.prototype);
+  HashHistory2.prototype.constructor = HashHistory2;
+  HashHistory2.prototype.setupListeners = function setupListeners2() {
+    var this$1$1 = this;
+    if (this.listeners.length > 0) {
+      return;
+    }
+    var router = this.router;
+    var expectScroll = router.options.scrollBehavior;
+    var supportsScroll = supportsPushState && expectScroll;
+    if (supportsScroll) {
+      this.listeners.push(setupScroll());
+    }
+    var handleRoutingEvent = function() {
+      var current = this$1$1.current;
+      if (!ensureSlash()) {
+        return;
+      }
+      this$1$1.transitionTo(getHash(), function(route) {
+        if (supportsScroll) {
+          handleScroll(this$1$1.router, route, current, true);
+        }
+        if (!supportsPushState) {
+          replaceHash(route.fullPath);
+        }
+      });
+    };
+    var eventType = supportsPushState ? "popstate" : "hashchange";
+    window.addEventListener(
+      eventType,
+      handleRoutingEvent
+    );
+    this.listeners.push(function() {
+      window.removeEventListener(eventType, handleRoutingEvent);
+    });
+  };
+  HashHistory2.prototype.push = function push2(location, onComplete, onAbort) {
+    var this$1$1 = this;
+    var ref2 = this;
+    var fromRoute = ref2.current;
+    this.transitionTo(
+      location,
+      function(route) {
+        pushHash(route.fullPath);
+        handleScroll(this$1$1.router, route, fromRoute, false);
+        onComplete && onComplete(route);
+      },
+      onAbort
+    );
+  };
+  HashHistory2.prototype.replace = function replace2(location, onComplete, onAbort) {
+    var this$1$1 = this;
+    var ref2 = this;
+    var fromRoute = ref2.current;
+    this.transitionTo(
+      location,
+      function(route) {
+        replaceHash(route.fullPath);
+        handleScroll(this$1$1.router, route, fromRoute, false);
+        onComplete && onComplete(route);
+      },
+      onAbort
+    );
+  };
+  HashHistory2.prototype.go = function go2(n) {
+    window.history.go(n);
+  };
+  HashHistory2.prototype.ensureURL = function ensureURL(push2) {
+    var current = this.current.fullPath;
+    if (getHash() !== current) {
+      push2 ? pushHash(current) : replaceHash(current);
+    }
+  };
+  HashHistory2.prototype.getCurrentLocation = function getCurrentLocation() {
+    return getHash();
+  };
+  return HashHistory2;
+}(History);
+function checkFallback(base) {
+  var location = getLocation(base);
+  if (!/^\/#/.test(location)) {
+    window.location.replace(cleanPath(base + "/#" + location));
+    return true;
+  }
+}
+function ensureSlash() {
+  var path = getHash();
+  if (path.charAt(0) === "/") {
+    return true;
+  }
+  replaceHash("/" + path);
+  return false;
+}
+function getHash() {
+  var href = window.location.href;
+  var index = href.indexOf("#");
+  if (index < 0) {
+    return "";
+  }
+  href = href.slice(index + 1);
+  return href;
+}
+function getUrl(path) {
+  var href = window.location.href;
+  var i = href.indexOf("#");
+  var base = i >= 0 ? href.slice(0, i) : href;
+  return base + "#" + path;
+}
+function pushHash(path) {
+  if (supportsPushState) {
+    pushState(getUrl(path));
+  } else {
+    window.location.hash = path;
+  }
+}
+function replaceHash(path) {
+  if (supportsPushState) {
+    replaceState(getUrl(path));
+  } else {
+    window.location.replace(getUrl(path));
+  }
+}
+var AbstractHistory = /* @__PURE__ */ function(History3) {
+  function AbstractHistory2(router, base) {
+    History3.call(this, router, base);
+    this.stack = [];
+    this.index = -1;
+  }
+  if (History3)
+    AbstractHistory2.__proto__ = History3;
+  AbstractHistory2.prototype = Object.create(History3 && History3.prototype);
+  AbstractHistory2.prototype.constructor = AbstractHistory2;
+  AbstractHistory2.prototype.push = function push2(location, onComplete, onAbort) {
+    var this$1$1 = this;
+    this.transitionTo(
+      location,
+      function(route) {
+        this$1$1.stack = this$1$1.stack.slice(0, this$1$1.index + 1).concat(route);
+        this$1$1.index++;
+        onComplete && onComplete(route);
+      },
+      onAbort
+    );
+  };
+  AbstractHistory2.prototype.replace = function replace2(location, onComplete, onAbort) {
+    var this$1$1 = this;
+    this.transitionTo(
+      location,
+      function(route) {
+        this$1$1.stack = this$1$1.stack.slice(0, this$1$1.index).concat(route);
+        onComplete && onComplete(route);
+      },
+      onAbort
+    );
+  };
+  AbstractHistory2.prototype.go = function go2(n) {
+    var this$1$1 = this;
+    var targetIndex = this.index + n;
+    if (targetIndex < 0 || targetIndex >= this.stack.length) {
+      return;
+    }
+    var route = this.stack[targetIndex];
+    this.confirmTransition(
+      route,
+      function() {
+        var prev = this$1$1.current;
+        this$1$1.index = targetIndex;
+        this$1$1.updateRoute(route);
+        this$1$1.router.afterHooks.forEach(function(hook) {
+          hook && hook(route, prev);
+        });
+      },
+      function(err) {
+        if (isNavigationFailure(err, NavigationFailureType.duplicated)) {
+          this$1$1.index = targetIndex;
+        }
+      }
+    );
+  };
+  AbstractHistory2.prototype.getCurrentLocation = function getCurrentLocation() {
+    var current = this.stack[this.stack.length - 1];
+    return current ? current.fullPath : "/";
+  };
+  AbstractHistory2.prototype.ensureURL = function ensureURL() {
+  };
+  return AbstractHistory2;
+}(History);
+var VueRouter = function VueRouter2(options) {
+  if (options === void 0)
+    options = {};
+  if (process.env.NODE_ENV !== "production") {
+    warn(this instanceof VueRouter2, "Router must be called with the new operator.");
+  }
+  this.app = null;
+  this.apps = [];
+  this.options = options;
+  this.beforeHooks = [];
+  this.resolveHooks = [];
+  this.afterHooks = [];
+  this.matcher = createMatcher(options.routes || [], this);
+  var mode = options.mode || "hash";
+  this.fallback = mode === "history" && !supportsPushState && options.fallback !== false;
+  if (this.fallback) {
+    mode = "hash";
+  }
+  if (!inBrowser) {
+    mode = "abstract";
+  }
+  this.mode = mode;
+  switch (mode) {
+    case "history":
+      this.history = new HTML5History(this, options.base);
+      break;
+    case "hash":
+      this.history = new HashHistory(this, options.base, this.fallback);
+      break;
+    case "abstract":
+      this.history = new AbstractHistory(this, options.base);
+      break;
+    default:
+      if (process.env.NODE_ENV !== "production") {
+        assert(false, "invalid mode: " + mode);
+      }
+  }
+};
+var prototypeAccessors = { currentRoute: { configurable: true } };
+VueRouter.prototype.match = function match(raw, current, redirectedFrom) {
+  return this.matcher.match(raw, current, redirectedFrom);
+};
+prototypeAccessors.currentRoute.get = function() {
+  return this.history && this.history.current;
+};
+VueRouter.prototype.init = function init(app) {
+  var this$1$1 = this;
+  process.env.NODE_ENV !== "production" && assert(
+    install.installed,
+    "not installed. Make sure to call `Vue.use(VueRouter)` before creating root instance."
+  );
+  this.apps.push(app);
+  app.$once("hook:destroyed", function() {
+    var index = this$1$1.apps.indexOf(app);
+    if (index > -1) {
+      this$1$1.apps.splice(index, 1);
+    }
+    if (this$1$1.app === app) {
+      this$1$1.app = this$1$1.apps[0] || null;
+    }
+    if (!this$1$1.app) {
+      this$1$1.history.teardown();
+    }
+  });
+  if (this.app) {
+    return;
+  }
+  this.app = app;
+  var history = this.history;
+  if (history instanceof HTML5History || history instanceof HashHistory) {
+    var handleInitialScroll = function(routeOrError) {
+      var from = history.current;
+      var expectScroll = this$1$1.options.scrollBehavior;
+      var supportsScroll = supportsPushState && expectScroll;
+      if (supportsScroll && "fullPath" in routeOrError) {
+        handleScroll(this$1$1, routeOrError, from, false);
+      }
+    };
+    var setupListeners2 = function(routeOrError) {
+      history.setupListeners();
+      handleInitialScroll(routeOrError);
+    };
+    history.transitionTo(
+      history.getCurrentLocation(),
+      setupListeners2,
+      setupListeners2
+    );
+  }
+  history.listen(function(route) {
+    this$1$1.apps.forEach(function(app2) {
+      app2._route = route;
+    });
+  });
+};
+VueRouter.prototype.beforeEach = function beforeEach(fn) {
+  return registerHook(this.beforeHooks, fn);
+};
+VueRouter.prototype.beforeResolve = function beforeResolve(fn) {
+  return registerHook(this.resolveHooks, fn);
+};
+VueRouter.prototype.afterEach = function afterEach(fn) {
+  return registerHook(this.afterHooks, fn);
+};
+VueRouter.prototype.onReady = function onReady2(cb, errorCb) {
+  this.history.onReady(cb, errorCb);
+};
+VueRouter.prototype.onError = function onError2(errorCb) {
+  this.history.onError(errorCb);
+};
+VueRouter.prototype.push = function push(location, onComplete, onAbort) {
+  var this$1$1 = this;
+  if (!onComplete && !onAbort && typeof Promise !== "undefined") {
+    return new Promise(function(resolve2, reject) {
+      this$1$1.history.push(location, resolve2, reject);
+    });
+  } else {
+    this.history.push(location, onComplete, onAbort);
+  }
+};
+VueRouter.prototype.replace = function replace(location, onComplete, onAbort) {
+  var this$1$1 = this;
+  if (!onComplete && !onAbort && typeof Promise !== "undefined") {
+    return new Promise(function(resolve2, reject) {
+      this$1$1.history.replace(location, resolve2, reject);
+    });
+  } else {
+    this.history.replace(location, onComplete, onAbort);
+  }
+};
+VueRouter.prototype.go = function go(n) {
+  this.history.go(n);
+};
+VueRouter.prototype.back = function back() {
+  this.go(-1);
+};
+VueRouter.prototype.forward = function forward() {
+  this.go(1);
+};
+VueRouter.prototype.getMatchedComponents = function getMatchedComponents(to) {
+  var route = to ? to.matched ? to : this.resolve(to).route : this.currentRoute;
+  if (!route) {
+    return [];
+  }
+  return [].concat.apply(
+    [],
+    route.matched.map(function(m) {
+      return Object.keys(m.components).map(function(key) {
+        return m.components[key];
+      });
+    })
+  );
+};
+VueRouter.prototype.resolve = function resolve(to, current, append) {
+  current = current || this.history.current;
+  var location = normalizeLocation(to, current, append, this);
+  var route = this.match(location, current);
+  var fullPath = route.redirectedFrom || route.fullPath;
+  var base = this.history.base;
+  var href = createHref(base, fullPath, this.mode);
+  return {
+    location,
+    route,
+    href,
+    // for backwards compat
+    normalizedTo: location,
+    resolved: route
+  };
+};
+VueRouter.prototype.getRoutes = function getRoutes() {
+  return this.matcher.getRoutes();
+};
+VueRouter.prototype.addRoute = function addRoute(parentOrRoute, route) {
+  this.matcher.addRoute(parentOrRoute, route);
+  if (this.history.current !== START) {
+    this.history.transitionTo(this.history.getCurrentLocation());
+  }
+};
+VueRouter.prototype.addRoutes = function addRoutes(routes) {
+  if (process.env.NODE_ENV !== "production") {
+    warn(false, "router.addRoutes() is deprecated and has been removed in Vue Router 4. Use router.addRoute() instead.");
+  }
+  this.matcher.addRoutes(routes);
+  if (this.history.current !== START) {
+    this.history.transitionTo(this.history.getCurrentLocation());
+  }
+};
+Object.defineProperties(VueRouter.prototype, prototypeAccessors);
+function registerHook(list, fn) {
+  list.push(fn);
+  return function() {
+    var i = list.indexOf(fn);
+    if (i > -1) {
+      list.splice(i, 1);
+    }
+  };
+}
+function createHref(base, fullPath, mode) {
+  var path = mode === "hash" ? "#" + fullPath : fullPath;
+  return base ? cleanPath(base + "/" + path) : path;
+}
+VueRouter.install = install;
+VueRouter.version = "3.6.5";
+VueRouter.isNavigationFailure = isNavigationFailure;
+VueRouter.NavigationFailureType = NavigationFailureType;
+VueRouter.START_LOCATION = START;
+if (inBrowser && window.Vue) {
+  window.Vue.use(VueRouter);
+}
+register(t20);
+const IDLE_TIMEOUT = 3 * 60 * 1e3;
+const _sfc_main$8 = {
+  name: "NcReferenceWidget",
+  components: {
+    NcButton
+  },
+  props: {
+    reference: {
+      type: Object,
+      required: true
+    },
+    interactive: {
+      type: Boolean,
+      default: true
+    },
+    interactiveOptIn: {
+      type: Boolean,
+      default: false
+    }
+  },
+  setup() {
+    const isVisible = ref(false);
+    const widgetRoot = ref();
+    const { width } = useElementSize(widgetRoot);
+    useIntersectionObserver(widgetRoot, () => {
+      nextTick(() => {
+        var _a, _b;
+        isVisible.value = (_b = (_a = widgetRoot.value) == null ? void 0 : _a.isIntersecting) != null ? _b : false;
+      });
+    });
+    return {
+      width,
+      isVisible,
+      widgetRoot
+    };
+  },
+  data() {
+    return {
+      showInteractive: false,
+      rendered: false,
+      idleTimeout: null
+    };
+  },
+  computed: {
+    isInteractive() {
+      return !this.interactiveOptIn && this.interactive || this.showInteractive;
+    },
+    hasFullWidth() {
+      return hasFullWidth(this.reference.richObjectType);
+    },
+    hasCustomWidget() {
+      return isWidgetRegistered(this.reference.richObjectType);
+    },
+    hasInteractiveView() {
+      return isWidgetRegistered(this.reference.richObjectType) && hasInteractiveView(this.reference.richObjectType);
+    },
+    noAccess() {
+      return this.reference && !this.reference.accessible;
+    },
+    descriptionStyle() {
+      if (this.numberOfLines === 0) {
+        return {
+          display: "none"
+        };
+      }
+      const lineClamp = this.numberOfLines;
+      return {
+        lineClamp,
+        webkitLineClamp: lineClamp
+      };
+    },
+    numberOfLines() {
+      const lineCountOffsets = [450, 550, 650, Infinity];
+      return lineCountOffsets.findIndex((max) => this.width < max);
+    },
+    compactLink() {
+      const link = this.reference.openGraphObject.link;
+      if (!link) {
+        return "";
+      }
+      if (link.startsWith("https://")) {
+        return link.substring(8);
+      }
+      if (link.startsWith("http://")) {
+        return link.substring(7);
+      }
+      return link;
+    },
+    route() {
+      return getRoute(this.$router, this.reference.openGraphObject.link);
+    },
+    referenceWidgetLinkComponent() {
+      return this.route ? Link : "a";
+    },
+    referenceWidgetLinkProps() {
+      return this.route ? { to: this.route } : { href: this.reference.openGraphObject.link, target: "_blank" };
+    }
+  },
+  watch: {
+    isVisible: {
+      handler(val) {
+        if (!val) {
+          this.idleTimeout = setTimeout(() => {
+            if (!this.isVisible) {
+              this.destroyWidget();
+            }
+          }, IDLE_TIMEOUT);
+          return;
+        }
+        if (this.idleTimeout) {
+          clearTimeout(this.idleTimeout);
+          this.idleTimeout = null;
+        }
+        if (!this.rendered) {
+          this.renderWidget();
+        }
+      },
+      immediate: true
+    }
+  },
+  beforeDestroy() {
+    this.destroyWidget();
+  },
+  methods: {
+    t,
+    enableInteractive() {
+      this.showInteractive = true;
+      this.renderWidget();
+    },
+    renderWidget() {
+      var _a;
+      if (!this.$refs.customWidget) {
+        return;
+      }
+      if (((_a = this == null ? void 0 : this.reference) == null ? void 0 : _a.richObjectType) === "open-graph") {
+        return;
+      }
+      this.$refs.customWidget.innerHTML = "";
+      const widget = document.createElement("div");
+      this.$refs.customWidget.appendChild(widget);
+      this.$nextTick(() => {
+        renderWidget(widget, {
+          ...this.reference,
+          interactive: this.isInteractive
+        });
+        this.rendered = true;
+      });
+    },
+    destroyWidget() {
+      if (this.rendered) {
+        destroyWidget(this.reference.richObjectType, this.$el);
+        this.rendered = false;
+      }
+    }
+  }
+};
+var _sfc_render$8 = function render3() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("div", { ref: "widgetRoot", class: { "toggle-interactive": _vm.hasInteractiveView && !_vm.isInteractive } }, [_vm.reference && _vm.hasCustomWidget ? _c("div", { ref: "customWidget", staticClass: "widget-custom", class: { "full-width": _vm.hasFullWidth } }) : !_vm.noAccess && _vm.reference && _vm.reference.openGraphObject && !_vm.hasCustomWidget ? _c(_vm.referenceWidgetLinkComponent, _vm._b({ tag: "component", staticClass: "widget-default", attrs: { "rel": "noopener noreferrer" } }, "component", _vm.referenceWidgetLinkProps, false), [_vm.reference.openGraphObject.thumb ? _c("img", { staticClass: "widget-default--image", attrs: { "src": _vm.reference.openGraphObject.thumb } }) : _vm._e(), _c("div", { staticClass: "widget-default--details" }, [_c("p", { staticClass: "widget-default--name" }, [_vm._v(" " + _vm._s(_vm.reference.openGraphObject.name) + " ")]), _c("p", { staticClass: "widget-default--description", style: _vm.descriptionStyle }, [_vm._v(" " + _vm._s(_vm.reference.openGraphObject.description) + " ")]), _c("p", { staticClass: "widget-default--link" }, [_vm._v(" " + _vm._s(_vm.compactLink) + " ")])])]) : _vm._e(), _vm.interactiveOptIn && _vm.hasInteractiveView && !_vm.isInteractive ? _c("NcButton", { staticClass: "toggle-interactive--button", on: { "click": _vm.enableInteractive } }, [_vm._v(" " + _vm._s(_vm.t("Enable interactive view")) + " ")]) : _vm._e()], 1);
+};
+var _sfc_staticRenderFns$8 = [];
+var __component__$8 = /* @__PURE__ */ normalizeComponent(
+  _sfc_main$8,
+  _sfc_render$8,
+  _sfc_staticRenderFns$8,
+  false,
+  null,
+  "48a2ac1d",
+  null,
+  null
+);
+const NcReferenceWidget = __component__$8.exports;
+const _sfc_main$7 = {
+  name: "NcCustomPickerElement",
+  props: {
+    /**
+     * The reference provider
+     */
+    provider: {
+      type: Object,
+      required: true
+    }
+  },
+  emits: [
+    "cancel",
+    "submit"
+  ],
+  data() {
+    return {
+      isRegistered: isCustomPickerElementRegistered(this.provider.id),
+      renderResult: null
+    };
+  },
+  mounted() {
+    if (this.isRegistered) {
+      this.renderElement();
+    }
+  },
+  beforeDestroy() {
+    if (this.isRegistered) {
+      destroyCustomPickerElement(this.provider.id, this.$el, this.renderResult);
+    }
+  },
+  methods: {
+    renderElement() {
+      if (this.$refs.domElement) {
+        this.$refs.domElement.innerHTML = "";
+      }
+      const renderFunctionResult = renderCustomPickerElement(this.$refs.domElement, { providerId: this.provider.id, accessible: false });
+      Promise.resolve(renderFunctionResult).then((result) => {
+        var _a, _b;
+        this.renderResult = result;
+        if (((_a = this.renderResult.object) == null ? void 0 : _a._isVue) && ((_b = this.renderResult.object) == null ? void 0 : _b.$on)) {
+          this.renderResult.object.$on("submit", this.onSubmit);
+          this.renderResult.object.$on("cancel", this.onCancel);
+        }
+        this.renderResult.element.addEventListener("submit", (e) => {
+          this.onSubmit(e.detail);
+        });
+        this.renderResult.element.addEventListener("cancel", this.onCancel);
+      });
+    },
+    onSubmit(value) {
+      this.$emit("submit", value);
+    },
+    onCancel() {
+      this.$emit("cancel");
+    }
+  }
+};
+var _sfc_render$7 = function render4() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("div", { ref: "domElement" });
+};
+var _sfc_staticRenderFns$7 = [];
+var __component__$7 = /* @__PURE__ */ normalizeComponent(
+  _sfc_main$7,
+  _sfc_render$7,
+  _sfc_staticRenderFns$7,
+  false,
+  null,
+  "25f1cef8",
+  null,
+  null
+);
+const NcCustomPickerElement = __component__$7.exports;
+register(t7);
+const anyLinkProviderId = "any-link";
+const anyLinkProvider = {
+  id: anyLinkProviderId,
+  title: t("Any link"),
+  icon_url: imagePath("core", "filetypes/link.svg")
+};
+if (!window._vue_richtext_reference_providers) {
+  window._vue_richtext_reference_providers = loadState("core", "reference-provider-list", []);
+}
+if (!window._vue_richtext_reference_provider_timestamps) {
+  window._vue_richtext_reference_provider_timestamps = loadState("core", "reference-provider-timestamps", {});
+}
+function getProvider(providerId) {
+  if (providerId === anyLinkProviderId) {
+    return anyLinkProvider;
+  }
+  return getProviders().find((p) => p.id === providerId);
+}
+function getProviders() {
+  return window._vue_richtext_reference_providers.filter((p) => {
+    const keep = !!p.search_providers_ids && p.search_providers_ids.length > 0 || isCustomPickerElementRegistered(p.id);
+    if (!keep) {
+      console.debug("[smart picker]", p.id, "reference provider is discoverable but does not have any related search provider or custom picker component registered");
+    }
+    return keep;
+  });
+}
+function sortProviders(providerList) {
+  const timestamps = window._vue_richtext_reference_provider_timestamps;
+  return providerList.sort((a, b) => {
+    return a.order === b.order ? 0 : a.order > b.order ? 1 : -1;
+  }).sort((a, b) => {
+    const ta = timestamps[a.id];
+    const tb = timestamps[b.id];
+    return ta === tb ? 0 : tb === void 0 ? -1 : ta === void 0 ? 1 : ta > tb ? -1 : 1;
+  });
+}
+function searchProvider(query, limit = null) {
+  const providers = getProviders();
+  const escapedQuery = query.replace(/[/\-\\^$*+?.()|[\]{}]/g, "\\$&");
+  const regexp = new RegExp(escapedQuery, "i");
+  const sortedProviders = sortProviders(providers);
+  const filteredSortedProviders = sortedProviders.filter((p) => {
+    return p.title.match(regexp);
+  });
+  const searchResult = limit ? filteredSortedProviders.slice(0, limit) : filteredSortedProviders;
+  if (query === "" || searchResult.length === 0) {
+    searchResult.push(anyLinkProvider);
+  }
+  return searchResult;
+}
+function touchProvider(providerId) {
+  const timestamp = Math.floor(Date.now() / 1e3);
+  const params = {
+    timestamp
+  };
+  const url = generateOcsUrl("references/provider/{providerId}", { providerId });
+  axios.put(url, params).then((response) => {
+    window._vue_richtext_reference_provider_timestamps[providerId] = timestamp;
+  });
+}
+let mytimer = 0;
+function delay(callback, ms) {
+  return function() {
+    const context = this;
+    const args = arguments;
+    clearTimeout(mytimer);
+    mytimer = setTimeout(function() {
+      callback.apply(context, args);
+    }, ms || 0);
+  };
+}
+function isUrl(str) {
+  try {
+    return Boolean(new URL(str));
+  } catch (error) {
+    return false;
+  }
+}
+register(t34, t38);
+const _sfc_main$6 = {
+  name: "LinkVariantIcon",
+  emits: ["click"],
+  props: {
+    title: {
+      type: String
+    },
+    fillColor: {
+      type: String,
+      default: "currentColor"
+    },
+    size: {
+      type: Number,
+      default: 24
+    }
+  }
+};
+var _sfc_render$6 = function render5() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("span", _vm._b({ staticClass: "material-design-icon link-variant-icon", attrs: { "aria-hidden": _vm.title ? null : true, "aria-label": _vm.title, "role": "img" }, on: { "click": function($event) {
+    return _vm.$emit("click", $event);
+  } } }, "span", _vm.$attrs, false), [_c("svg", { staticClass: "material-design-icon__svg", attrs: { "fill": _vm.fillColor, "width": _vm.size, "height": _vm.size, "viewBox": "0 0 24 24" } }, [_c("path", { attrs: { "d": "M10.59,13.41C11,13.8 11,14.44 10.59,14.83C10.2,15.22 9.56,15.22 9.17,14.83C7.22,12.88 7.22,9.71 9.17,7.76V7.76L12.71,4.22C14.66,2.27 17.83,2.27 19.78,4.22C21.73,6.17 21.73,9.34 19.78,11.29L18.29,12.78C18.3,11.96 18.17,11.14 17.89,10.36L18.36,9.88C19.54,8.71 19.54,6.81 18.36,5.64C17.19,4.46 15.29,4.46 14.12,5.64L10.59,9.17C9.41,10.34 9.41,12.24 10.59,13.41M13.41,9.17C13.8,8.78 14.44,8.78 14.83,9.17C16.78,11.12 16.78,14.29 14.83,16.24V16.24L11.29,19.78C9.34,21.73 6.17,21.73 4.22,19.78C2.27,17.83 2.27,14.66 4.22,12.71L5.71,11.22C5.7,12.04 5.83,12.86 6.11,13.65L5.64,14.12C4.46,15.29 4.46,17.19 5.64,18.36C6.81,19.54 8.71,19.54 9.88,18.36L13.41,14.83C14.59,13.66 14.59,11.76 13.41,10.59C13,10.2 13,9.56 13.41,9.17Z" } }, [_vm.title ? _c("title", [_vm._v(_vm._s(_vm.title))]) : _vm._e()])])]);
+};
+var _sfc_staticRenderFns$6 = [];
+var __component__$6 = /* @__PURE__ */ normalizeComponent(
+  _sfc_main$6,
+  _sfc_render$6,
+  _sfc_staticRenderFns$6,
+  false,
+  null,
+  null,
+  null,
+  null
+);
+const LinkVariantIcon = __component__$6.exports;
+const _sfc_main$5 = {
+  name: "NcProviderList",
+  components: {
+    NcSelect,
+    NcHighlight,
+    NcEmptyContent,
+    LinkVariantIcon
+  },
+  emits: [
+    "select-provider",
+    "submit"
+  ],
+  data() {
+    return {
+      selectedProvider: null,
+      query: "",
+      multiselectPlaceholder: t("Select provider"),
+      providerIconAlt: t("Provider icon")
+    };
+  },
+  computed: {
+    options() {
+      const result = [];
+      if (this.query !== "" && isUrl(this.query)) {
+        result.push({
+          id: this.query,
+          title: this.query,
+          isLink: true
+        });
+      }
+      result.push(...searchProvider(this.query));
+      return result;
+    }
+  },
+  methods: {
+    focus() {
+      setTimeout(() => {
+        var _a, _b, _c;
+        (_c = (_b = (_a = this.$refs["provider-select"]) == null ? void 0 : _a.$el) == null ? void 0 : _b.querySelector("#provider-select-input")) == null ? void 0 : _c.focus();
+      }, 300);
+    },
+    onProviderSelected(p) {
+      if (p !== null) {
+        if (p.isLink) {
+          this.$emit("submit", p.title);
+        } else {
+          this.$emit("select-provider", p);
+        }
+        this.selectedProvider = null;
+      }
+    },
+    onSearch(query, loading) {
+      this.query = query;
+    }
+  }
+};
+var _sfc_render$5 = function render6() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("div", { staticClass: "provider-list" }, [_c("NcSelect", { ref: "provider-select", staticClass: "provider-list--select", attrs: { "input-id": "provider-select-input", "label": "title", "placeholder": _vm.multiselectPlaceholder, "options": _vm.options, "append-to-body": false, "clear-search-on-select": true, "clear-search-on-blur": () => false, "filterable": false }, on: { "search": _vm.onSearch, "input": _vm.onProviderSelected }, scopedSlots: _vm._u([{ key: "option", fn: function(option) {
+    return [option.isLink ? _c("div", { staticClass: "provider" }, [_c("LinkVariantIcon", { staticClass: "link-icon", attrs: { "size": 20 } }), _c("span", [_vm._v(_vm._s(option.title))])], 1) : _c("div", { staticClass: "provider" }, [_c("img", { staticClass: "provider-icon", attrs: { "src": option.icon_url, "alt": _vm.providerIconAlt } }), _c("NcHighlight", { staticClass: "option-text", attrs: { "search": _vm.query, "text": option.title } })], 1)];
+  } }]), model: { value: _vm.selectedProvider, callback: function($$v) {
+    _vm.selectedProvider = $$v;
+  }, expression: "selectedProvider" } }), _c("NcEmptyContent", { staticClass: "provider-list--empty-content", scopedSlots: _vm._u([{ key: "icon", fn: function() {
+    return [_c("LinkVariantIcon")];
+  }, proxy: true }]) })], 1);
+};
+var _sfc_staticRenderFns$5 = [];
+var __component__$5 = /* @__PURE__ */ normalizeComponent(
+  _sfc_main$5,
+  _sfc_render$5,
+  _sfc_staticRenderFns$5,
+  false,
+  null,
+  "e880790e",
+  null,
+  null
+);
+const NcProviderList = __component__$5.exports;
+register(t21);
+const _sfc_main$4 = {
+  name: "NcRawLinkInput",
+  components: {
+    LinkVariantIcon,
+    NcEmptyContent,
+    NcLoadingIcon,
+    NcReferenceWidget,
+    NcTextField
+  },
+  props: {
+    /**
+     * The reference provider
+     */
+    provider: {
+      type: Object,
+      required: true
+    }
+  },
+  emits: [
+    "submit"
+  ],
+  data() {
+    return {
+      inputValue: "",
+      loading: false,
+      reference: null,
+      abortController: null,
+      inputPlaceholder: t("Enter link")
+    };
+  },
+  computed: {
+    isLinkValid() {
+      return isUrl(this.inputValue);
+    }
+  },
+  methods: {
+    focus() {
+      var _a;
+      (_a = this.$refs["url-input"].$el.getElementsByTagName("input")[0]) == null ? void 0 : _a.focus();
+    },
+    onSubmit(e) {
+      const value = e.target.value;
+      if (this.isLinkValid) {
+        this.$emit("submit", value);
+      }
+    },
+    onClear() {
+      this.inputValue = "";
+      this.reference = null;
+    },
+    onInput() {
+      this.reference = null;
+      if (this.abortController) {
+        this.abortController.abort();
+      }
+      if (this.isLinkValid) {
+        delay(() => {
+          this.updateReference();
+        }, 500)();
+      }
+    },
+    updateReference() {
+      this.loading = true;
+      this.abortController = new AbortController();
+      axios.get(generateOcsUrl("references/resolve", 2) + "?reference=" + encodeURIComponent(this.inputValue), {
+        signal: this.abortController.signal
+      }).then((response) => {
+        this.reference = response.data.ocs.data.references[this.inputValue];
+      }).catch((error) => {
+        console.error(error);
+      }).then(() => {
+        this.loading = false;
+      });
+    }
+  }
+};
+var _sfc_render$4 = function render7() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("div", { staticClass: "raw-link" }, [_c("div", { staticClass: "input-wrapper" }, [_c("NcTextField", { ref: "url-input", attrs: { "value": _vm.inputValue, "show-trailing-button": _vm.inputValue !== "", "label": _vm.inputPlaceholder }, on: { "update:value": [function($event) {
+    _vm.inputValue = $event;
+  }, _vm.onInput], "trailing-button-click": _vm.onClear }, nativeOn: { "keyup": function($event) {
+    if (!$event.type.indexOf("key") && _vm._k($event.keyCode, "enter", 13, $event.key, "Enter"))
+      return null;
+    return _vm.onSubmit.apply(null, arguments);
+  } } }, [_vm.loading ? _c("NcLoadingIcon", { attrs: { "size": 16 } }) : _c("LinkVariantIcon", { attrs: { "size": 16 } })], 1)], 1), _vm.reference !== null ? _c("NcReferenceWidget", { staticClass: "reference-widget", attrs: { "reference": _vm.reference } }) : _c("NcEmptyContent", { staticClass: "raw-link--empty-content", scopedSlots: _vm._u([{ key: "icon", fn: function() {
+    return [_vm.provider.icon_url ? _c("img", { staticClass: "provider-icon", attrs: { "src": _vm.provider.icon_url } }) : _c("LinkVariantIcon")];
+  }, proxy: true }]) })], 1);
+};
+var _sfc_staticRenderFns$4 = [];
+var __component__$4 = /* @__PURE__ */ normalizeComponent(
+  _sfc_main$4,
+  _sfc_render$4,
+  _sfc_staticRenderFns$4,
+  false,
+  null,
+  "d0ba247a",
+  null,
+  null
+);
+const NcRawLinkInput = __component__$4.exports;
+const _sfc_main$3 = {
+  name: "NcSearchResult",
+  components: {
+    NcHighlight
+  },
+  props: {
+    /**
+     * Unified search result entry
+     */
+    entry: {
+      type: Object,
+      required: true
+    },
+    /**
+     * The query that led to getting this result
+     * Used to highlight the entry text
+     */
+    query: {
+      type: String,
+      required: true
+    }
+  }
+};
+var _sfc_render$3 = function render8() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("div", { staticClass: "result" }, [_vm.entry.icon ? _c("div", { staticClass: "result--icon-class", class: { [_vm.entry.icon]: true, rounded: _vm.entry.rounded } }) : _c("img", { staticClass: "result--image", class: { rounded: _vm.entry.rounded }, attrs: { "src": _vm.entry.thumbnailUrl } }), _c("div", { staticClass: "result--content" }, [_c("span", { staticClass: "result--content--name" }, [_c("NcHighlight", { attrs: { "search": _vm.query, "text": _vm.entry.title } })], 1), _c("span", { staticClass: "result--content--subline" }, [_c("NcHighlight", { attrs: { "search": _vm.query, "text": _vm.entry.subline } })], 1)])]);
+};
+var _sfc_staticRenderFns$3 = [];
+var __component__$3 = /* @__PURE__ */ normalizeComponent(
+  _sfc_main$3,
+  _sfc_render$3,
+  _sfc_staticRenderFns$3,
+  false,
+  null,
+  "7a394a58",
+  null,
+  null
+);
+const NcSearchResult = __component__$3.exports;
+register(t27, t34, t36);
+const LIMIT = 5;
+const _sfc_main$2 = {
+  name: "NcSearch",
+  components: {
+    LinkVariantIcon,
+    DotsHorizontalIcon: DotsHorizontal,
+    NcEmptyContent,
+    NcSelect,
+    NcSearchResult
+  },
+  props: {
+    /**
+     * The selected reference provider
+     */
+    provider: {
+      type: Object,
+      required: true
+    },
+    showEmptyContent: {
+      type: Boolean,
+      default: true
+    },
+    searchPlaceholder: {
+      type: String,
+      default: null
+    }
+  },
+  emits: [
+    "submit"
+  ],
+  data() {
+    return {
+      searchQuery: "",
+      selectedResult: null,
+      resultsBySearchProvider: {},
+      searching: false,
+      searchingMoreOf: null,
+      abortController: null,
+      noOptionsText: t("Start typing to search"),
+      providerIconAlt: t("Provider icon")
+    };
+  },
+  computed: {
+    mySearchPlaceholder() {
+      return this.searchPlaceholder || t("Search");
+    },
+    searchProviderIds() {
+      return this.provider.search_providers_ids;
+    },
+    options() {
+      if (this.searchQuery === "") {
+        return [];
+      }
+      const options = [];
+      if (isUrl(this.searchQuery)) {
+        options.push(this.rawLinkEntry);
+      }
+      options.push(...this.formattedSearchResults);
+      return options;
+    },
+    rawLinkEntry() {
+      return {
+        id: "rawLinkEntry",
+        resourceUrl: this.searchQuery,
+        isRawLink: true
+      };
+    },
+    formattedSearchResults() {
+      const results = [];
+      this.searchProviderIds.forEach((pid) => {
+        if (this.resultsBySearchProvider[pid].entries.length > 0) {
+          if (this.searchProviderIds.length > 1 || this.resultsBySearchProvider[pid].entries.length > 1) {
+            results.push({
+              id: "groupTitle-" + pid,
+              name: this.resultsBySearchProvider[pid].name,
+              isCustomGroupTitle: true,
+              providerId: pid
+            });
+          }
+          const providerEntriesWithId = this.resultsBySearchProvider[pid].entries.map((entry, index) => {
+            return {
+              id: "provider-" + pid + "-entry-" + index,
+              ...entry
+            };
+          });
+          results.push(...providerEntriesWithId);
+          if (this.resultsBySearchProvider[pid].isPaginated) {
+            results.push({
+              id: "moreOf-" + pid,
+              name: this.resultsBySearchProvider[pid].name,
+              isMore: true,
+              providerId: pid,
+              isLoading: this.searchingMoreOf === pid
+            });
+          }
+        }
+      });
+      return results;
+    }
+  },
+  mounted() {
+    this.resetResults();
+  },
+  beforeDestroy() {
+    this.cancelSearchRequests();
+  },
+  methods: {
+    t,
+    resetResults() {
+      const resultsBySearchProvider = {};
+      this.searchProviderIds.forEach((pid) => {
+        resultsBySearchProvider[pid] = {
+          entries: []
+        };
+      });
+      this.resultsBySearchProvider = resultsBySearchProvider;
+    },
+    focus() {
+      setTimeout(() => {
+        var _a, _b, _c;
+        (_c = (_b = (_a = this.$refs["search-select"]) == null ? void 0 : _a.$el) == null ? void 0 : _b.querySelector("#search-select-input")) == null ? void 0 : _c.focus();
+      }, 300);
+    },
+    cancelSearchRequests() {
+      if (this.abortController) {
+        this.abortController.abort();
+      }
+    },
+    onSearchInput(query, loading) {
+      this.searchQuery = query;
+      delay(() => {
+        this.updateSearch();
+      }, 500)();
+    },
+    onSelectResultSelected(item) {
+      if (item !== null) {
+        if (item.resourceUrl) {
+          this.cancelSearchRequests();
+          this.$emit("submit", item.resourceUrl);
+        } else if (item.isMore) {
+          this.searchMoreOf(item.providerId).then(() => {
+            this.selectedResult = null;
+          });
+        }
+      }
+    },
+    searchMoreOf(searchProviderId) {
+      this.searchingMoreOf = searchProviderId;
+      this.cancelSearchRequests();
+      return this.searchProviders(searchProviderId);
+    },
+    updateSearch() {
+      this.cancelSearchRequests();
+      this.resetResults();
+      if (this.searchQuery === "") {
+        this.searching = false;
+        return;
+      }
+      return this.searchProviders();
+    },
+    searchProviders(searchProviderId = null) {
+      var _a, _b;
+      this.abortController = new AbortController();
+      this.searching = true;
+      const searchPromises = searchProviderId === null ? [...this.searchProviderIds].map((pid) => {
+        return this.searchOneProvider(pid);
+      }) : [this.searchOneProvider(searchProviderId, (_b = (_a = this.resultsBySearchProvider[searchProviderId]) == null ? void 0 : _a.cursor) != null ? _b : null)];
+      return Promise.allSettled(searchPromises).then((promises) => {
+        const isOneCanceled = !!promises.find((p) => {
+          return p.status === "rejected" && (p.reason.name === "CanceledError" || p.reason.code === "ERR_CANCELED");
+        });
+        if (!isOneCanceled) {
+          this.searching = false;
+          this.searchingMoreOf = null;
+        }
+      });
+    },
+    searchOneProvider(providerId, cursor = null) {
+      const url = cursor === null ? generateOcsUrl("search/providers/{providerId}/search?term={term}&limit={limit}", { providerId, term: this.searchQuery, limit: LIMIT }) : generateOcsUrl("search/providers/{providerId}/search?term={term}&limit={limit}&cursor={cursor}", { providerId, term: this.searchQuery, limit: LIMIT, cursor });
+      return axios.get(url, {
+        signal: this.abortController.signal
+      }).then((response) => {
+        const data = response.data.ocs.data;
+        this.resultsBySearchProvider[providerId].name = data.name;
+        this.resultsBySearchProvider[providerId].cursor = data.cursor;
+        this.resultsBySearchProvider[providerId].isPaginated = data.isPaginated;
+        this.resultsBySearchProvider[providerId].entries.push(...data.entries);
+      });
+    }
+  }
+};
+var _sfc_render$2 = function render9() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("div", { staticClass: "smart-picker-search", class: { "with-empty-content": _vm.showEmptyContent } }, [_c("NcSelect", { ref: "search-select", staticClass: "smart-picker-search--select", attrs: { "input-id": "search-select-input", "label": "name", "placeholder": _vm.mySearchPlaceholder, "options": _vm.options, "append-to-body": false, "close-on-select": false, "clear-search-on-select": false, "clear-search-on-blur": () => false, "reset-focus-on-options-change": false, "filterable": false, "autoscroll": true, "reset-on-options-change": false, "loading": _vm.searching }, on: { "search": _vm.onSearchInput, "input": _vm.onSelectResultSelected }, scopedSlots: _vm._u([{ key: "option", fn: function(option) {
+    return [option.isRawLink ? _c("div", { staticClass: "custom-option" }, [_c("LinkVariantIcon", { staticClass: "option-simple-icon", attrs: { "size": 20 } }), _c("span", { staticClass: "option-text" }, [_vm._v(" " + _vm._s(_vm.t("Raw link {options}", { options: option.resourceUrl })) + " ")])], 1) : option.resourceUrl ? _c("NcSearchResult", { staticClass: "search-result", attrs: { "entry": option, "query": _vm.searchQuery } }) : option.isCustomGroupTitle ? _c("span", { staticClass: "custom-option group-name" }, [_vm.provider.icon_url ? _c("img", { staticClass: "provider-icon group-name-icon", attrs: { "src": _vm.provider.icon_url } }) : _vm._e(), _c("span", { staticClass: "option-text" }, [_c("strong", [_vm._v(_vm._s(option.name))])])]) : option.isMore ? _c("span", { class: { "custom-option": true } }, [option.isLoading ? _c("span", { staticClass: "option-simple-icon icon-loading-small" }) : _c("DotsHorizontalIcon", { staticClass: "option-simple-icon", attrs: { "size": 20 } }), _c("span", { staticClass: "option-text" }, [_vm._v(" " + _vm._s(_vm.t('Load more "{options}"', { options: option.name })) + " ")])], 1) : _vm._e()];
+  } }, { key: "no-options", fn: function() {
+    return [_vm._v(" " + _vm._s(_vm.noOptionsText) + " ")];
+  }, proxy: true }]), model: { value: _vm.selectedResult, callback: function($$v) {
+    _vm.selectedResult = $$v;
+  }, expression: "selectedResult" } }), _vm.showEmptyContent ? _c("NcEmptyContent", { staticClass: "smart-picker-search--empty-content", scopedSlots: _vm._u([{ key: "icon", fn: function() {
+    return [_vm.provider.icon_url ? _c("img", { staticClass: "provider-icon", attrs: { "alt": _vm.providerIconAlt, "src": _vm.provider.icon_url } }) : _c("LinkVariantIcon")];
+  }, proxy: true }], null, false, 2922132592) }) : _vm._e()], 1);
+};
+var _sfc_staticRenderFns$2 = [];
+var __component__$2 = /* @__PURE__ */ normalizeComponent(
+  _sfc_main$2,
+  _sfc_render$2,
+  _sfc_staticRenderFns$2,
+  false,
+  null,
+  "97d196f0",
+  null,
+  null
+);
+const NcSearch = __component__$2.exports;
+const MODES = {
+  providerList: 1,
+  standardLinkInput: 2,
+  searchInput: 3,
+  customElement: 4
+};
+const _sfc_main$1 = {
+  name: "NcReferencePicker",
+  components: {
+    NcCustomPickerElement,
+    NcProviderList,
+    NcRawLinkInput,
+    NcSearch
+  },
+  props: {
+    /**
+     * Provider to select on creation
+     * Default: null. Show the provider list
+     */
+    initialProvider: {
+      type: Object,
+      default: () => null
+    },
+    /**
+     * Optional width in pixels
+     * Default: 100%
+     */
+    width: {
+      type: Number,
+      default: null
+    },
+    /**
+     * Focus on the provider list select input on creation
+     * Default: true
+     */
+    focusOnCreate: {
+      type: Boolean,
+      default: true
+    }
+  },
+  emits: [
+    "cancel",
+    "cancel-raw-link",
+    "cancel-search",
+    "provider-selected",
+    "submit"
+  ],
+  data() {
+    return {
+      MODES,
+      selectedProvider: this.initialProvider
+    };
+  },
+  computed: {
+    mode() {
+      return this.selectedProvider === null ? MODES.providerList : isCustomPickerElementRegistered(this.selectedProvider.id) ? MODES.customElement : this.selectedProvider.search_providers_ids ? MODES.searchInput : MODES.standardLinkInput;
+    },
+    pickerWrapperStyle() {
+      return {
+        width: this.width ? this.width + "px" : void 0
+      };
+    }
+  },
+  mounted() {
+    if (this.focusOnCreate) {
+      if (this.initialProvider) {
+        setTimeout(() => {
+          var _a;
+          (_a = this.$refs["url-input"]) == null ? void 0 : _a.focus();
+        }, 300);
+      } else {
+        this.$nextTick(() => {
+          var _a;
+          (_a = this.$refs["provider-list"]) == null ? void 0 : _a.focus();
+        });
+      }
+    }
+  },
+  methods: {
+    onEscapePressed() {
+      if (this.selectedProvider !== null) {
+        this.deselectProvider();
+      } else {
+        this.cancelProviderSelection();
+      }
+    },
+    onProviderSelected(provider) {
+      this.selectedProvider = provider;
+      this.$emit("provider-selected", provider);
+      this.$nextTick(() => {
+        var _a;
+        (_a = this.$refs["url-input"]) == null ? void 0 : _a.focus();
+      });
+    },
+    cancelCustomElement() {
+      this.deselectProvider();
+    },
+    cancelSearch() {
+      var _a;
+      this.$emit("cancel-search", (_a = this.selectedProvider) == null ? void 0 : _a.title);
+      this.deselectProvider();
+    },
+    cancelRawLinkInput() {
+      var _a;
+      this.$emit("cancel-raw-link", (_a = this.selectedProvider) == null ? void 0 : _a.title);
+      this.deselectProvider();
+    },
+    cancelProviderSelection() {
+      this.$emit("cancel");
+    },
+    submitLink(link) {
+      if (this.selectedProvider !== null) {
+        touchProvider(this.selectedProvider.id);
+      }
+      this.$emit("submit", link);
+      this.deselectProvider();
+    },
+    deselectProvider() {
+      this.selectedProvider = null;
+      this.$emit("provider-selected", null);
+      setTimeout(() => {
+        var _a;
+        (_a = this.$refs["provider-list"]) == null ? void 0 : _a.focus();
+      }, 300);
+    }
+  }
+};
+var _sfc_render$1 = function render10() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("div", { staticClass: "reference-picker", style: _vm.pickerWrapperStyle, attrs: { "tabindex": "-1" }, on: { "keydown": function($event) {
+    if (!$event.type.indexOf("key") && _vm._k($event.keyCode, "esc", 27, $event.key, ["Esc", "Escape"]))
+      return null;
+    $event.stopPropagation();
+    $event.preventDefault();
+    return _vm.onEscapePressed.apply(null, arguments);
+  } } }, [_vm.mode === _vm.MODES.providerList ? _c("NcProviderList", { ref: "provider-list", on: { "select-provider": _vm.onProviderSelected, "submit": _vm.submitLink, "cancel": _vm.cancelProviderSelection } }) : _vm.mode === _vm.MODES.standardLinkInput ? _c("NcRawLinkInput", { ref: "url-input", attrs: { "provider": _vm.selectedProvider }, on: { "submit": _vm.submitLink, "cancel": _vm.cancelRawLinkInput } }) : _vm.mode === _vm.MODES.searchInput ? _c("NcSearch", { ref: "url-input", attrs: { "provider": _vm.selectedProvider }, on: { "cancel": _vm.cancelSearch, "submit": _vm.submitLink } }) : _vm.mode === _vm.MODES.customElement ? _c("div", { staticClass: "custom-element-wrapper" }, [_c("NcCustomPickerElement", { attrs: { "provider": _vm.selectedProvider }, on: { "submit": _vm.submitLink, "cancel": _vm.cancelCustomElement } })], 1) : _vm._e()], 1);
+};
+var _sfc_staticRenderFns$1 = [];
+var __component__$1 = /* @__PURE__ */ normalizeComponent(
+  _sfc_main$1,
+  _sfc_render$1,
+  _sfc_staticRenderFns$1,
+  false,
+  null,
+  "12c38c93",
+  null,
+  null
+);
+const NcReferencePicker = __component__$1.exports;
+register(t11, t16);
+const _sfc_main = {
+  name: "NcReferencePickerModal",
+  components: {
+    NcReferencePicker,
+    NcModal,
+    NcButton,
+    ArrowLeftIcon: ArrowLeft,
+    CloseIcon: Close
+  },
+  props: {
+    /**
+     * Provider to select on creation
+     * Show the provider list if no initial one is provided
+     */
+    initialProvider: {
+      type: Object,
+      default: () => null
+    },
+    /**
+     * Focus on the input item on create
+     */
+    focusOnCreate: {
+      type: Boolean,
+      default: true
+    },
+    /**
+     * If true, add the modal content to the Viewer trap elements via the event-bus
+     */
+    isInsideViewer: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: [
+    "cancel",
+    "submit"
+  ],
+  data() {
+    return {
+      show: true,
+      selectedProvider: this.initialProvider,
+      backButtonTitle: t("Back to provider selection"),
+      closeButtonTitle: t("Close"),
+      closeButtonLabel: t("Close Smart Picker")
+    };
+  },
+  computed: {
+    isProviderSelected() {
+      return this.selectedProvider !== null;
+    },
+    showBackButton() {
+      return this.initialProvider === null && this.isProviderSelected;
+    },
+    modalSize() {
+      var _a;
+      return this.isProviderSelected && isCustomPickerElementRegistered(this.selectedProvider.id) ? (_a = getCustomPickerElementSize(this.selectedProvider.id)) != null ? _a : "large" : "normal";
+    },
+    showModalName() {
+      return !this.isProviderSelected || !isCustomPickerElementRegistered(this.selectedProvider.id);
+    },
+    modalName() {
+      return this.isProviderSelected ? this.selectedProvider.title : t("Smart Picker");
+    }
+  },
+  mounted() {
+    if (this.isInsideViewer) {
+      const elem = this.$refs.modal_content;
+      emit("viewer:trapElements:changed", elem);
+    }
+  },
+  methods: {
+    onCancel() {
+      this.show = false;
+      this.$emit("cancel");
+    },
+    onSubmit(value) {
+      this.show = false;
+      this.$emit("submit", value);
+    },
+    onProviderSelect(provider) {
+      this.selectedProvider = provider;
+      if (provider === null && this.initialProvider !== null) {
+        this.onCancel();
+      }
+    },
+    onBackClicked() {
+      this.$refs.referencePicker.deselectProvider();
+    }
+  }
+};
+var _sfc_render = function render11() {
+  var _vm = this, _c = _vm._self._c;
+  return _vm.show ? _c("NcModal", { staticClass: "reference-picker-modal", attrs: { "size": _vm.modalSize, "can-close": false }, on: { "close": _vm.onCancel } }, [_c("div", { ref: "modal_content", staticClass: "reference-picker-modal--content" }, [_vm.showBackButton ? _c("NcButton", { staticClass: "back-button", attrs: { "aria-label": _vm.backButtonTitle, "title": _vm.backButtonTitle }, on: { "click": _vm.onBackClicked }, scopedSlots: _vm._u([{ key: "icon", fn: function() {
+    return [_c("ArrowLeftIcon")];
+  }, proxy: true }], null, false, 3001860362) }) : _vm._e(), _c("NcButton", { staticClass: "close-button", attrs: { "aria-label": _vm.closeButtonLabel, "title": _vm.closeButtonTitle, "type": "tertiary" }, on: { "click": _vm.onCancel }, scopedSlots: _vm._u([{ key: "icon", fn: function() {
+    return [_c("CloseIcon")];
+  }, proxy: true }], null, false, 2491825086) }), _vm.showModalName ? _c("h2", [_vm._v(" " + _vm._s(_vm.modalName) + " ")]) : _vm._e(), _c("NcReferencePicker", { ref: "referencePicker", attrs: { "initial-provider": _vm.initialProvider, "focus-on-create": _vm.focusOnCreate }, on: { "provider-selected": _vm.onProviderSelect, "submit": _vm.onSubmit, "cancel": _vm.onCancel } })], 1)]) : _vm._e();
+};
+var _sfc_staticRenderFns = [];
+var __component__ = /* @__PURE__ */ normalizeComponent(
+  _sfc_main,
+  _sfc_render,
+  _sfc_staticRenderFns,
+  false,
+  null,
+  "ab09ebaa",
+  null,
+  null
+);
+const NcReferencePickerModal = __component__.exports;
+async function getLinkWithPicker(providerId = null, isInsideViewer = void 0) {
+  return await new Promise((resolve2, reject) => {
+    var _a;
+    const modalId = "referencePickerModal";
+    const modalElement = document.createElement("div");
+    modalElement.id = modalId;
+    document.body.append(modalElement);
+    const initialProvider = providerId === null ? null : (_a = getProvider(providerId)) != null ? _a : null;
+    const View2 = Vue.extend(NcReferencePickerModal);
+    const view = new View2({
+      propsData: {
+        initialProvider,
+        isInsideViewer
+      }
+    }).$mount(modalElement);
+    view.$on("cancel", () => {
+      view.$destroy();
+      reject(new Error("User cancellation"));
+    });
+    view.$on("submit", (link) => {
+      view.$destroy();
+      resolve2(link);
+    });
+  });
+}
+export {
+  Link as L,
+  NcReferenceWidget as N,
+  anyLinkProviderId as a,
+  getProvider as b,
+  getProviders as c,
+  searchProvider as d,
+  NcReferencePicker as e,
+  NcReferencePickerModal as f,
+  getLinkWithPicker as g,
+  NcSearch as h,
+  sortProviders as s
+};