{"version":3,"file":"ArrowRight-CLsEMAPw.chunk.mjs","sources":["../node_modules/unist-builder/lib/index.js","../node_modules/unist-util-is/lib/index.js","../node_modules/unist-util-visit-parents/lib/index.js","../node_modules/@nextcloud/vue/dist/chunks/autolink-_k1FETYm.mjs","../node_modules/vue-material-design-icons/ArrowRight.vue"],"sourcesContent":["/**\n * @typedef {import('unist').Node} Node\n */\n\n/**\n * @typedef {Array<Node> | string} ChildrenOrValue\n *   List to use as `children` or value to use as `value`.\n *\n * @typedef {Record<string, unknown>} Props\n *   Other fields to add to the node.\n */\n\n/**\n * Build a node.\n *\n * @template {string} T\n * @template {Props} P\n * @template {Array<Node>} C\n *\n * @overload\n * @param {T} type\n * @returns {{type: T}}\n *\n * @overload\n * @param {T} type\n * @param {P} props\n * @returns {{type: T} & P}\n *\n * @overload\n * @param {T} type\n * @param {string} value\n * @returns {{type: T, value: string}}\n *\n * @overload\n * @param {T} type\n * @param {P} props\n * @param {string} value\n * @returns {{type: T, value: string} & P}\n *\n * @overload\n * @param {T} type\n * @param {C} children\n * @returns {{type: T, children: C}}\n *\n * @overload\n * @param {T} type\n * @param {P} props\n * @param {C} children\n * @returns {{type: T, children: C} & P}\n *\n * @param {string} type\n *   Node type.\n * @param {ChildrenOrValue | Props | null | undefined} [props]\n *   Fields assigned to node (default: `undefined`).\n * @param {ChildrenOrValue | null | undefined} [value]\n *   Children of node or value of `node` (cast to string).\n * @returns {Node}\n *   Built node.\n */\nexport function u(type, props, value) {\n  /** @type {Node} */\n  const node = {type: String(type)}\n\n  if (\n    (value === undefined || value === null) &&\n    (typeof props === 'string' || Array.isArray(props))\n  ) {\n    value = props\n  } else {\n    Object.assign(node, props)\n  }\n\n  if (Array.isArray(value)) {\n    // @ts-expect-error: create a parent.\n    node.children = value\n  } else if (value !== undefined && value !== null) {\n    // @ts-expect-error: create a literal.\n    node.value = String(value)\n  }\n\n  return node\n}\n","/**\n * @import {Node, Parent} from 'unist'\n */\n\n/**\n * @template Fn\n * @template Fallback\n * @typedef {Fn extends (value: any) => value is infer Thing ? Thing : Fallback} Predicate\n */\n\n/**\n * @callback Check\n *   Check that an arbitrary value is a node.\n * @param {unknown} this\n *   The given context.\n * @param {unknown} [node]\n *   Anything (typically a node).\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean}\n *   Whether this is a node and passes a test.\n *\n * @typedef {Record<string, unknown> | Node} Props\n *   Object to check for equivalence.\n *\n *   Note: `Node` is included as it is common but is not indexable.\n *\n * @typedef {Array<Props | TestFunction | string> | ReadonlyArray<Props | TestFunction | string> | Props | TestFunction | string | null | undefined} Test\n *   Check for an arbitrary node.\n *\n * @callback TestFunction\n *   Check if a node passes a test.\n * @param {unknown} this\n *   The given context.\n * @param {Node} node\n *   A node.\n * @param {number | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean | undefined | void}\n *   Whether this node passes the test.\n *\n *   Note: `void` is included until TS sees no return as `undefined`.\n */\n\n/**\n * Check if `node` is a `Node` and whether it passes the given test.\n *\n * @param {unknown} node\n *   Thing to check, typically `Node`.\n * @param {Test} test\n *   A check for a specific node.\n * @param {number | null | undefined} index\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} parent\n *   The node’s parent.\n * @param {unknown} context\n *   Context object (`this`) to pass to `test` functions.\n * @returns {boolean}\n *   Whether `node` is a node and passes a test.\n */\nexport const is =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends ReadonlyArray<string>>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition[number]}) &\n   *   (<Condition extends Array<string>>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition[number]}) &\n   *   (<Condition extends string>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((node?: null | undefined) => false) &\n   *   ((node: unknown, test?: null | undefined, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((node: unknown, test?: Test, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * @param {unknown} [node]\n     * @param {Test} [test]\n     * @param {number | null | undefined} [index]\n     * @param {Parent | null | undefined} [parent]\n     * @param {unknown} [context]\n     * @returns {boolean}\n     */\n    // eslint-disable-next-line max-params\n    function (node, test, index, parent, context) {\n      const check = convert(test)\n\n      if (\n        index !== undefined &&\n        index !== null &&\n        (typeof index !== 'number' ||\n          index < 0 ||\n          index === Number.POSITIVE_INFINITY)\n      ) {\n        throw new Error('Expected positive finite index')\n      }\n\n      if (\n        parent !== undefined &&\n        parent !== null &&\n        (!is(parent) || !parent.children)\n      ) {\n        throw new Error('Expected parent node')\n      }\n\n      if (\n        (parent === undefined || parent === null) !==\n        (index === undefined || index === null)\n      ) {\n        throw new Error('Expected both parent and index')\n      }\n\n      return looksLikeANode(node)\n        ? check.call(context, node, index, parent)\n        : false\n    }\n  )\n\n/**\n * Generate an assertion from a test.\n *\n * Useful if you’re going to test many nodes, for example when creating a\n * utility where something else passes a compatible test.\n *\n * The created function is a bit faster because it expects valid input only:\n * a `node`, `index`, and `parent`.\n *\n * @param {Test} test\n *   *   when nullish, checks if `node` is a `Node`.\n *   *   when `string`, works like passing `(node) => node.type === test`.\n *   *   when `function` checks if function passed the node is true.\n *   *   when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n *   *   when `array`, checks if any one of the subtests pass.\n * @returns {Check}\n *   An assertion.\n */\nexport const convert =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((test?: Test) => Check)\n   * )}\n   */\n  (\n    /**\n     * @param {Test} [test]\n     * @returns {Check}\n     */\n    function (test) {\n      if (test === null || test === undefined) {\n        return ok\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      if (typeof test === 'object') {\n        return Array.isArray(test)\n          ? anyFactory(test)\n          : // Cast because `ReadonlyArray` goes into the above but `isArray`\n            // narrows to `Array`.\n            propertiesFactory(/** @type {Props} */ (test))\n      }\n\n      if (typeof test === 'string') {\n        return typeFactory(test)\n      }\n\n      throw new Error('Expected function, string, or object as test')\n    }\n  )\n\n/**\n * @param {Array<Props | TestFunction | string>} tests\n * @returns {Check}\n */\nfunction anyFactory(tests) {\n  /** @type {Array<Check>} */\n  const checks = []\n  let index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index])\n  }\n\n  return castFactory(any)\n\n  /**\n   * @this {unknown}\n   * @type {TestFunction}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, parameters)) return true\n    }\n\n    return false\n  }\n}\n\n/**\n * Turn an object into a test for a node with a certain fields.\n *\n * @param {Props} check\n * @returns {Check}\n */\nfunction propertiesFactory(check) {\n  const checkAsRecord = /** @type {Record<string, unknown>} */ (check)\n\n  return castFactory(all)\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function all(node) {\n    const nodeAsRecord = /** @type {Record<string, unknown>} */ (\n      /** @type {unknown} */ (node)\n    )\n\n    /** @type {string} */\n    let key\n\n    for (key in check) {\n      if (nodeAsRecord[key] !== checkAsRecord[key]) return false\n    }\n\n    return true\n  }\n}\n\n/**\n * Turn a string into a test for a node with a certain type.\n *\n * @param {string} check\n * @returns {Check}\n */\nfunction typeFactory(check) {\n  return castFactory(type)\n\n  /**\n   * @param {Node} node\n   */\n  function type(node) {\n    return node && node.type === check\n  }\n}\n\n/**\n * Turn a custom test into a test for a node that passes that test.\n *\n * @param {TestFunction} testFunction\n * @returns {Check}\n */\nfunction castFactory(testFunction) {\n  return check\n\n  /**\n   * @this {unknown}\n   * @type {Check}\n   */\n  function check(value, index, parent) {\n    return Boolean(\n      looksLikeANode(value) &&\n        testFunction.call(\n          this,\n          value,\n          typeof index === 'number' ? index : undefined,\n          parent || undefined\n        )\n    )\n  }\n}\n\nfunction ok() {\n  return true\n}\n\n/**\n * @param {unknown} value\n * @returns {value is Node}\n */\nfunction looksLikeANode(value) {\n  return value !== null && typeof value === 'object' && 'type' in value\n}\n","/**\n * @import {Node as UnistNode, Parent as UnistParent} from 'unist'\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends ReadonlyArray<infer T>\n *   ? MatchesOne<Value, T>\n *   : Check extends Array<infer T>\n *   ? MatchesOne<Value, T>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {InternalAncestor<InclusiveDescendant<Tree>, Child>} Ancestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {'skip' | boolean} Action\n *   Union of the action types.\n *\n * @typedef {number} Index\n *   Move to the sibling at `index` next (after node itself is completely\n *   traversed).\n *\n *   Useful if mutating the tree, such as removing the node the visitor is\n *   currently on, or any of its previous siblings.\n *   Results less than 0 or greater than or equal to `children.length` stop\n *   traversing the parent.\n *\n * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple\n *   List with one or two values, the first an action, the second an index.\n *\n * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult\n *   Any value that can be returned from a visitor.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform the parent of node (the last of `ancestors`).\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of an ancestor still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Array<VisitedParents>} ancestors\n *   Ancestors of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [VisitedParents=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parents`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Tree type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {convert} from 'unist-util-is'\nimport {color} from 'unist-util-visit-parents/do-not-use-color'\n\n/** @type {Readonly<ActionTuple>} */\nconst empty = []\n\n/**\n * Continue traversing as normal.\n */\nexport const CONTINUE = true\n\n/**\n * Stop traversing immediately.\n */\nexport const EXIT = false\n\n/**\n * Do not traverse this node’s children.\n */\nexport const SKIP = 'skip'\n\n/**\n * Visit nodes, with ancestral information.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} test\n *   `unist-util-is`-compatible test\n * @param {Visitor | boolean | null | undefined} [visitor]\n *   Handle each node.\n * @param {boolean | null | undefined} [reverse]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visitParents(tree, test, visitor, reverse) {\n  /** @type {Test} */\n  let check\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    // @ts-expect-error no visitor given, so `visitor` is test.\n    visitor = test\n  } else {\n    // @ts-expect-error visitor given, so `test` isn’t a visitor.\n    check = test\n  }\n\n  const is = convert(check)\n  const step = reverse ? -1 : 1\n\n  factory(tree, undefined, [])()\n\n  /**\n   * @param {UnistNode} node\n   * @param {number | undefined} index\n   * @param {Array<UnistParent>} parents\n   */\n  function factory(node, index, parents) {\n    const value = /** @type {Record<string, unknown>} */ (\n      node && typeof node === 'object' ? node : {}\n    )\n\n    if (typeof value.type === 'string') {\n      const name =\n        // `hast`\n        typeof value.tagName === 'string'\n          ? value.tagName\n          : // `xast`\n            typeof value.name === 'string'\n            ? value.name\n            : undefined\n\n      Object.defineProperty(visit, 'name', {\n        value:\n          'node (' + color(node.type + (name ? '<' + name + '>' : '')) + ')'\n      })\n    }\n\n    return visit\n\n    function visit() {\n      /** @type {Readonly<ActionTuple>} */\n      let result = empty\n      /** @type {Readonly<ActionTuple>} */\n      let subresult\n      /** @type {number} */\n      let offset\n      /** @type {Array<UnistParent>} */\n      let grandparents\n\n      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {\n        // @ts-expect-error: `visitor` is now a visitor.\n        result = toResult(visitor(node, parents))\n\n        if (result[0] === EXIT) {\n          return result\n        }\n      }\n\n      if ('children' in node && node.children) {\n        const nodeAsParent = /** @type {UnistParent} */ (node)\n\n        if (nodeAsParent.children && result[0] !== SKIP) {\n          offset = (reverse ? nodeAsParent.children.length : -1) + step\n          grandparents = parents.concat(nodeAsParent)\n\n          while (offset > -1 && offset < nodeAsParent.children.length) {\n            const child = nodeAsParent.children[offset]\n\n            subresult = factory(child, offset, grandparents)()\n\n            if (subresult[0] === EXIT) {\n              return subresult\n            }\n\n            offset =\n              typeof subresult[1] === 'number' ? subresult[1] : offset + step\n          }\n        }\n      }\n\n      return result\n    }\n  }\n}\n\n/**\n * Turn a return value into a clean result.\n *\n * @param {VisitorResult} value\n *   Valid return values from visitors.\n * @returns {Readonly<ActionTuple>}\n *   Clean result.\n */\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return value === null || value === undefined ? empty : [value]\n}\n","import '../assets/autolink-C_iad4O_.css';\nimport { getBaseUrl, getRootUrl } from \"@nextcloud/router\";\nimport { u } from \"unist-builder\";\nimport { visitParents, SKIP } from \"unist-util-visit-parents\";\nimport { defineComponent, openBlock, createElementBlock, normalizeClass, renderSlot, createTextVNode, toDisplayString } from \"vue\";\nimport { _ as _export_sfc } from \"./_plugin-vue_export-helper-1tPrXgE0.mjs\";\nimport { l as logger } from \"./logger-D3RVzcfQ.mjs\";\nconst _hoisted_1 = [\"href\"];\nconst _sfc_main = /* @__PURE__ */ defineComponent({\n  __name: \"NcRichTextExternalLink\",\n  props: {\n    href: {},\n    decorateExternal: { type: Boolean, default: false }\n  },\n  setup(__props) {\n    return (_ctx, _cache) => {\n      return openBlock(), createElementBlock(\"a\", {\n        href: _ctx.href,\n        rel: \"noopener noreferrer\",\n        target: \"_blank\",\n        class: normalizeClass([_ctx.$style.externalLink, {\n          [_ctx.$style.externalLink_decorated]: _ctx.decorateExternal\n        }])\n      }, [\n        renderSlot(_ctx.$slots, \"default\", {}, () => [\n          createTextVNode(toDisplayString(_ctx.href), 1)\n        ])\n      ], 10, _hoisted_1);\n    };\n  }\n});\nconst externalLink = \"_externalLink_ASIsx\";\nconst externalLink_decorated = \"_externalLink_decorated_97QHT\";\nconst style0 = {\n  \"material-design-icon\": \"_material-design-icon_M3MSE\",\n  externalLink,\n  externalLink_decorated\n};\nconst cssModules = {\n  \"$style\": style0\n};\nconst NcRichTextExternalLink = /* @__PURE__ */ _export_sfc(_sfc_main, [[\"__cssModules\", cssModules]]);\n/*!\n * SPDX-FileCopyrightText: 2022 Nextcloud GmbH and Nextcloud contributors\n * SPDX-License-Identifier: AGPL-3.0-or-later\n */\nconst URL_PATTERN = /(\\s|^)(https?:\\/\\/)([-A-Z0-9+_.]+(?::[0-9]+)?(?:\\/[-A-Z0-9+&@#%?=~_|!:,.;()]*)*)(\\s|$)/ig;\nconst URL_PATTERN_AUTOLINK = /(\\s|\\(|^)((https?:\\/\\/)([-A-Z0-9+_.]+[-A-Z0-9]+(?::[0-9]+)?(?:\\/[-A-Z0-9+&@#%?=~_|!:,.;()]*)*))(?=\\s|\\)|$)/ig;\nfunction remarkAutolink({ autolink, useMarkdown, useExtendedMarkdown }) {\n  return function(tree) {\n    if (useExtendedMarkdown || !useMarkdown || !autolink) {\n      return;\n    }\n    visitParents(tree, (node) => node.type === \"text\", (node, ancestors) => {\n      if (ancestors.some((ancestor) => ancestor.type === \"link\" || ancestor.type === \"linkReference\")) {\n        return;\n      }\n      const parent = ancestors.at(-1);\n      const index = parent.children.indexOf(node) ?? 0;\n      const parsed = parseUrl(node.value);\n      const parsedNodes = typeof parsed === \"string\" ? [u(\"text\", parsed)] : parsed.map((n) => {\n        if (typeof n === \"string\") {\n          return u(\"text\", n);\n        }\n        return u(\"link\", {\n          url: n.props.href\n        }, [u(\"text\", n.props.href)]);\n      }).filter((x) => x).flat();\n      parent.children.splice(index, 1, ...parsedNodes);\n      return [SKIP, index + parsedNodes.length];\n    });\n  };\n}\nfunction parseUrl(text) {\n  let match = URL_PATTERN_AUTOLINK.exec(text);\n  const list = [];\n  let start = 0;\n  while (match !== null) {\n    let href = match[2];\n    let textAfter;\n    let textBefore = text.substring(start, match.index + match[1].length);\n    if (href[0] === \" \") {\n      textBefore += href[0];\n      href = href.substring(1).trim();\n    }\n    const lastChar = href[href.length - 1];\n    if (lastChar === \".\" || lastChar === \",\" || lastChar === \";\" || match[0][0] === \"(\" && lastChar === \")\") {\n      href = href.substring(0, href.length - 1);\n      textAfter = lastChar;\n    }\n    list.push(textBefore);\n    list.push({ component: NcRichTextExternalLink, props: { href: href.trim(), decorateExternal: true } });\n    if (textAfter) {\n      list.push(textAfter);\n    }\n    start = match.index + match[0].length;\n    match = URL_PATTERN_AUTOLINK.exec(text);\n  }\n  list.push(text.substring(start));\n  const joinedText = list.map((item) => typeof item === \"string\" ? item : item.props.href).join(\"\");\n  if (text === joinedText) {\n    return list;\n  }\n  logger.error(\"[NcRichText] Failed to reassemble the chunked text: \" + text);\n  return text;\n}\nfunction getRoute(router, url) {\n  const removePrefix = (str, prefix) => str.startsWith(prefix) ? str.slice(prefix.length) : str;\n  const removePrefixes = (str, ...prefixes) => prefixes.reduce((acc, prefix) => removePrefix(acc, prefix), str);\n  if (!router) {\n    return null;\n  }\n  const isAbsoluteURL = /^https?:\\/\\//.test(url);\n  const isNonHttpLink = /^[a-z][a-z0-9+.-]*:.+/.test(url);\n  if (!isAbsoluteURL && isNonHttpLink) {\n    return null;\n  }\n  if (isAbsoluteURL && !url.startsWith(getBaseUrl())) {\n    return null;\n  }\n  if (!isAbsoluteURL && !url.startsWith(\"/\")) {\n    return null;\n  }\n  const relativeUrl = isAbsoluteURL ? removePrefixes(url, getBaseUrl(), \"/index.php\") : url;\n  const relativeRouterBase = removePrefixes(router.options.history.base, getRootUrl(), \"/index.php\");\n  const potentialRouterPath = removePrefixes(relativeUrl, relativeRouterBase) || \"/\";\n  const route = router.resolve(potentialRouterPath);\n  if (!route.matched.length) {\n    return null;\n  }\n  return route.fullPath;\n}\nexport {\n  NcRichTextExternalLink as N,\n  URL_PATTERN as U,\n  getRoute as g,\n  parseUrl as p,\n  remarkAutolink as r\n};\n//# sourceMappingURL=autolink-_k1FETYm.mjs.map\n","<template>\n  <span v-bind=\"$attrs\"\n        :aria-hidden=\"title ? null : 'true'\"\n        :aria-label=\"title\"\n        class=\"material-design-icon arrow-right-icon\"\n        role=\"img\"\n        @click=\"$emit('click', $event)\">\n    <svg :fill=\"fillColor\"\n         class=\"material-design-icon__svg\"\n         :width=\"size\"\n         :height=\"size\"\n         viewBox=\"0 0 24 24\">\n      <path d=\"M4,11V13H16L10.5,18.5L11.92,19.92L19.84,12L11.92,4.08L10.5,5.5L16,11H4Z\">\n        <title v-if=\"title\">{{ title }}</title>\n      </path>\n    </svg>\n  </span>\n</template>\n\n<script>\nexport default {\n  name: \"ArrowRightIcon\",\n  emits: ['click'],\n  props: {\n    title: {\n      type: String,\n    },\n    fillColor: {\n      type: String,\n      default: \"currentColor\"\n    },\n    size: {\n      type: Number,\n      default: 24\n    }\n  }\n}\n</script>"],"names":["u","type","props","value","node","convert","test","ok","castFactory","anyFactory","propertiesFactory","typeFactory","tests","checks","index","any","parameters","check","checkAsRecord","all","nodeAsRecord","key","testFunction","parent","looksLikeANode","empty","CONTINUE","EXIT","SKIP","visitParents","tree","visitor","reverse","is","step","factory","parents","name","visit","result","subresult","offset","grandparents","toResult","nodeAsParent","child","_hoisted_1","_sfc_main","defineComponent","__props","_ctx","_cache","openBlock","createElementBlock","normalizeClass","renderSlot","createTextVNode","toDisplayString","externalLink","externalLink_decorated","style0","cssModules","NcRichTextExternalLink","_export_sfc","URL_PATTERN","URL_PATTERN_AUTOLINK","remarkAutolink","autolink","useMarkdown","useExtendedMarkdown","ancestors","ancestor","parsed","parseUrl","parsedNodes","n","x","text","match","list","start","href","textAfter","textBefore","lastChar","joinedText","item","logger","getRoute","router","url","removePrefix","str","prefix","removePrefixes","prefixes","acc","isAbsoluteURL","isNonHttpLink","getBaseUrl","relativeUrl","relativeRouterBase","getRootUrl","potentialRouterPath","route","_hoisted_3","_createElementBlock","_mergeProps","$props","$event","_createElementVNode","_openBlock"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4]}