@mxtommy/kip 3.9.0-beta.2 → 3.9.0-beta.21

package/public/chunk-YZXYVP72.js

@@ -0,0 +1,4934 @@
+import {
+  DomSanitizer
+} from "./chunk-UQYTD5AC.js";
+import {
+  ApplicationRef,
+  CdkScrollableModule,
+  ChangeDetectionStrategy,
+  ChangeDetectorRef,
+  Component,
+  ContentChild,
+  ContentChildren,
+  DOCUMENT,
+  DOWN_ARROW,
+  Directionality,
+  Directive,
+  DomPortalOutlet,
+  ENTER,
+  ESCAPE,
+  ElementRef,
+  EventEmitter,
+  FocusKeyManager,
+  FocusMonitor,
+  HttpClient,
+  Inject,
+  Injectable,
+  InjectionToken,
+  Injector,
+  Input,
+  LEFT_ARROW,
+  MatCommonModule,
+  MatRipple,
+  MatRippleModule,
+  NgModule,
+  NgZone,
+  Optional,
+  Output,
+  OverlayConfig,
+  OverlayModule,
+  PLATFORM_ID,
+  Pipe,
+  QueryList,
+  RIGHT_ARROW,
+  Renderer2,
+  SPACE,
+  ScrollDispatcher,
+  SecurityContext,
+  Subject,
+  Subscription,
+  TemplatePortal,
+  TemplateRef,
+  UP_ARROW,
+  ViewChild,
+  ViewContainerRef,
+  ViewEncapsulation,
+  ViewportRuler,
+  _CdkPrivateStyleLoader,
+  _IdGenerator,
+  _StructuralStylesLoader,
+  __async,
+  __spreadProps,
+  __spreadValues,
+  _animationsDisabled,
+  _getEventTarget,
+  _getShadowRoot,
+  afterNextRender,
+  booleanAttribute,
+  computed,
+  createFlexibleConnectedPositionStrategy,
+  createOverlayRef,
+  createRepositionScrollStrategy,
+  distinctUntilChanged,
+  filter,
+  first,
+  hasModifierKey,
+  inject,
+  isFakeMousedownFromScreenReader,
+  isFakeTouchstartFromScreenReader,
+  isPlatformBrowser,
+  map,
+  mapTo,
+  merge,
+  of,
+  setClassMetadata,
+  shareReplay,
+  skipWhile,
+  startWith,
+  switchMap,
+  take,
+  takeUntil,
+  timer,
+  toSignal,
+  ɵɵInheritDefinitionFeature,
+  ɵɵNgOnChangesFeature,
+  ɵɵProvidersFeature,
+  ɵɵadvance,
+  ɵɵattribute,
+  ɵɵclassMap,
+  ɵɵclassProp,
+  ɵɵconditional,
+  ɵɵconditionalCreate,
+  ɵɵcontentQuery,
+  ɵɵdefineComponent,
+  ɵɵdefineDirective,
+  ɵɵdefineInjectable,
+  ɵɵdefineInjector,
+  ɵɵdefineNgModule,
+  ɵɵdefinePipe,
+  ɵɵdirectiveInject,
+  ɵɵdomElementEnd,
+  ɵɵdomElementStart,
+  ɵɵdomListener,
+  ɵɵdomProperty,
+  ɵɵdomTemplate,
+  ɵɵelement,
+  ɵɵelementEnd,
+  ɵɵelementStart,
+  ɵɵgetCurrentView,
+  ɵɵinject,
+  ɵɵinvalidFactory,
+  ɵɵlistener,
+  ɵɵloadQuery,
+  ɵɵnamespaceSVG,
+  ɵɵnextContext,
+  ɵɵprojection,
+  ɵɵprojectionDef,
+  ɵɵproperty,
+  ɵɵqueryRefresh,
+  ɵɵresetView,
+  ɵɵrestoreView,
+  ɵɵtext,
+  ɵɵtextInterpolate,
+  ɵɵviewQuery
+} from "./chunk-SDOP6T56.js";
+
+// node_modules/marked/lib/marked.esm.js
+function _getDefaults() {
+  return {
+    async: false,
+    breaks: false,
+    extensions: null,
+    gfm: true,
+    hooks: null,
+    pedantic: false,
+    renderer: null,
+    silent: false,
+    tokenizer: null,
+    walkTokens: null
+  };
+}
+var _defaults = _getDefaults();
+function changeDefaults(newDefaults) {
+  _defaults = newDefaults;
+}
+var noopTest = { exec: () => null };
+function edit(regex, opt = "") {
+  let source = typeof regex === "string" ? regex : regex.source;
+  const obj = {
+    replace: (name, val) => {
+      let valSource = typeof val === "string" ? val : val.source;
+      valSource = valSource.replace(other.caret, "$1");
+      source = source.replace(name, valSource);
+      return obj;
+    },
+    getRegex: () => {
+      return new RegExp(source, opt);
+    }
+  };
+  return obj;
+}
+var other = {
+  codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm,
+  outputLinkReplace: /\\([\[\]])/g,
+  indentCodeCompensation: /^(\s+)(?:```)/,
+  beginningSpace: /^\s+/,
+  endingHash: /#$/,
+  startingSpaceChar: /^ /,
+  endingSpaceChar: / $/,
+  nonSpaceChar: /[^ ]/,
+  newLineCharGlobal: /\n/g,
+  tabCharGlobal: /\t/g,
+  multipleSpaceGlobal: /\s+/g,
+  blankLine: /^[ \t]*$/,
+  doubleBlankLine: /\n[ \t]*\n[ \t]*$/,
+  blockquoteStart: /^ {0,3}>/,
+  blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g,
+  blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm,
+  listReplaceTabs: /^\t+/,
+  listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g,
+  listIsTask: /^\[[ xX]\] /,
+  listReplaceTask: /^\[[ xX]\] +/,
+  anyLine: /\n.*\n/,
+  hrefBrackets: /^<(.*)>$/,
+  tableDelimiter: /[:|]/,
+  tableAlignChars: /^\||\| *$/g,
+  tableRowBlankLine: /\n[ \t]*$/,
+  tableAlignRight: /^ *-+: *$/,
+  tableAlignCenter: /^ *:-+: *$/,
+  tableAlignLeft: /^ *:-+ *$/,
+  startATag: /^<a /i,
+  endATag: /^<\/a>/i,
+  startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i,
+  endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i,
+  startAngleBracket: /^</,
+  endAngleBracket: />$/,
+  pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/,
+  unicodeAlphaNumeric: /[\p{L}\p{N}]/u,
+  escapeTest: /[&<>"']/,
+  escapeReplace: /[&<>"']/g,
+  escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/,
+  escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g,
+  unescapeTest: /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig,
+  caret: /(^|[^\[])\^/g,
+  percentDecode: /%25/g,
+  findPipe: /\|/g,
+  splitPipe: / \|/,
+  slashPipe: /\\\|/g,
+  carriageReturn: /\r\n|\r/g,
+  spaceLine: /^ +$/gm,
+  notSpaceStart: /^\S*/,
+  endingNewline: /\n$/,
+  listItemRegex: (bull) => new RegExp(`^( {0,3}${bull})((?:[	 ][^\\n]*)?(?:\\n|$))`),
+  nextBulletRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`),
+  hrRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`),
+  fencesBeginRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`),
+  headingBeginRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`),
+  htmlBeginRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}<(?:[a-z].*>|!--)`, "i")
+};
+var newline = /^(?:[ \t]*(?:\n|$))+/;
+var blockCode = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/;
+var fences = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
+var hr = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
+var heading = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
+var bullet = /(?:[*+-]|\d{1,9}[.)])/;
+var lheadingCore = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/;
+var lheading = edit(lheadingCore).replace(/bull/g, bullet).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/\|table/g, "").getRegex();
+var lheadingGfm = edit(lheadingCore).replace(/bull/g, bullet).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex();
+var _paragraph = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/;
+var blockText = /^[^\n]+/;
+var _blockLabel = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
+var def = edit(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", _blockLabel).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
+var list = edit(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, bullet).getRegex();
+var _tag = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
+var _comment = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
+var html = edit(
+  "^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$))",
+  "i"
+).replace("comment", _comment).replace("tag", _tag).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+var paragraph = edit(_paragraph).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
+var blockquote = edit(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", paragraph).getRegex();
+var blockNormal = {
+  blockquote,
+  code: blockCode,
+  def,
+  fences,
+  heading,
+  hr,
+  html,
+  lheading,
+  list,
+  newline,
+  paragraph,
+  table: noopTest,
+  text: blockText
+};
+var gfmTable = edit(
+  "^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)"
+).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3}	)[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
+var blockGfm = __spreadProps(__spreadValues({}, blockNormal), {
+  lheading: lheadingGfm,
+  table: gfmTable,
+  paragraph: edit(_paragraph).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", gfmTable).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex()
+});
+var blockPedantic = __spreadProps(__spreadValues({}, blockNormal), {
+  html: edit(
+    `^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`
+  ).replace("comment", _comment).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),
+  def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
+  heading: /^(#{1,6})(.*)(?:\n+|$)/,
+  fences: noopTest,
+  // fences not supported
+  lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
+  paragraph: edit(_paragraph).replace("hr", hr).replace("heading", " *#{1,6} *[^\n]").replace("lheading", lheading).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex()
+});
+var escape = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
+var inlineCode = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
+var br = /^( {2,}|\\)\n(?!\s*$)/;
+var inlineText = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
+var _punctuation = /[\p{P}\p{S}]/u;
+var _punctuationOrSpace = /[\s\p{P}\p{S}]/u;
+var _notPunctuationOrSpace = /[^\s\p{P}\p{S}]/u;
+var punctuation = edit(/^((?![*_])punctSpace)/, "u").replace(/punctSpace/g, _punctuationOrSpace).getRegex();
+var _punctuationGfmStrongEm = /(?!~)[\p{P}\p{S}]/u;
+var _punctuationOrSpaceGfmStrongEm = /(?!~)[\s\p{P}\p{S}]/u;
+var _notPunctuationOrSpaceGfmStrongEm = /(?:[^\s\p{P}\p{S}]|~)/u;
+var blockSkip = /\[[^[\]]*?\]\((?:\\.|[^\\\(\)]|\((?:\\.|[^\\\(\)])*\))*\)|`[^`]*?`|<[^<>]*?>/g;
+var emStrongLDelimCore = /^(?:\*+(?:((?!\*)punct)|[^\s*]))|^_+(?:((?!_)punct)|([^\s_]))/;
+var emStrongLDelim = edit(emStrongLDelimCore, "u").replace(/punct/g, _punctuation).getRegex();
+var emStrongLDelimGfm = edit(emStrongLDelimCore, "u").replace(/punct/g, _punctuationGfmStrongEm).getRegex();
+var emStrongRDelimAstCore = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)";
+var emStrongRDelimAst = edit(emStrongRDelimAstCore, "gu").replace(/notPunctSpace/g, _notPunctuationOrSpace).replace(/punctSpace/g, _punctuationOrSpace).replace(/punct/g, _punctuation).getRegex();
+var emStrongRDelimAstGfm = edit(emStrongRDelimAstCore, "gu").replace(/notPunctSpace/g, _notPunctuationOrSpaceGfmStrongEm).replace(/punctSpace/g, _punctuationOrSpaceGfmStrongEm).replace(/punct/g, _punctuationGfmStrongEm).getRegex();
+var emStrongRDelimUnd = edit(
+  "^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)",
+  "gu"
+).replace(/notPunctSpace/g, _notPunctuationOrSpace).replace(/punctSpace/g, _punctuationOrSpace).replace(/punct/g, _punctuation).getRegex();
+var anyPunctuation = edit(/\\(punct)/, "gu").replace(/punct/g, _punctuation).getRegex();
+var autolink = edit(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex();
+var _inlineComment = edit(_comment).replace("(?:-->|$)", "-->").getRegex();
+var tag = edit(
+  "^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>"
+).replace("comment", _inlineComment).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
+var _inlineLabel = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
+var link = edit(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]*(?:\n[ \t]*)?)(title))?\s*\)/).replace("label", _inlineLabel).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
+var reflink = edit(/^!?\[(label)\]\[(ref)\]/).replace("label", _inlineLabel).replace("ref", _blockLabel).getRegex();
+var nolink = edit(/^!?\[(ref)\](?:\[\])?/).replace("ref", _blockLabel).getRegex();
+var reflinkSearch = edit("reflink|nolink(?!\\()", "g").replace("reflink", reflink).replace("nolink", nolink).getRegex();
+var inlineNormal = {
+  _backpedal: noopTest,
+  // only used for GFM url
+  anyPunctuation,
+  autolink,
+  blockSkip,
+  br,
+  code: inlineCode,
+  del: noopTest,
+  emStrongLDelim,
+  emStrongRDelimAst,
+  emStrongRDelimUnd,
+  escape,
+  link,
+  nolink,
+  punctuation,
+  reflink,
+  reflinkSearch,
+  tag,
+  text: inlineText,
+  url: noopTest
+};
+var inlinePedantic = __spreadProps(__spreadValues({}, inlineNormal), {
+  link: edit(/^!?\[(label)\]\((.*?)\)/).replace("label", _inlineLabel).getRegex(),
+  reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", _inlineLabel).getRegex()
+});
+var inlineGfm = __spreadProps(__spreadValues({}, inlineNormal), {
+  emStrongRDelimAst: emStrongRDelimAstGfm,
+  emStrongLDelim: emStrongLDelimGfm,
+  url: edit(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, "i").replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(),
+  _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,
+  del: /^(~~?)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/,
+  text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/
+});
+var inlineBreaks = __spreadProps(__spreadValues({}, inlineGfm), {
+  br: edit(br).replace("{2,}", "*").getRegex(),
+  text: edit(inlineGfm.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex()
+});
+var block = {
+  normal: blockNormal,
+  gfm: blockGfm,
+  pedantic: blockPedantic
+};
+var inline = {
+  normal: inlineNormal,
+  gfm: inlineGfm,
+  breaks: inlineBreaks,
+  pedantic: inlinePedantic
+};
+var escapeReplacements = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+var getEscapeReplacement = (ch) => escapeReplacements[ch];
+function escape2(html2, encode) {
+  if (encode) {
+    if (other.escapeTest.test(html2)) {
+      return html2.replace(other.escapeReplace, getEscapeReplacement);
+    }
+  } else {
+    if (other.escapeTestNoEncode.test(html2)) {
+      return html2.replace(other.escapeReplaceNoEncode, getEscapeReplacement);
+    }
+  }
+  return html2;
+}
+function cleanUrl(href) {
+  try {
+    href = encodeURI(href).replace(other.percentDecode, "%");
+  } catch {
+    return null;
+  }
+  return href;
+}
+function splitCells(tableRow, count) {
+  const row = tableRow.replace(other.findPipe, (match, offset, str) => {
+    let escaped = false;
+    let curr = offset;
+    while (--curr >= 0 && str[curr] === "\\") escaped = !escaped;
+    if (escaped) {
+      return "|";
+    } else {
+      return " |";
+    }
+  }), cells = row.split(other.splitPipe);
+  let i = 0;
+  if (!cells[0].trim()) {
+    cells.shift();
+  }
+  if (cells.length > 0 && !cells.at(-1)?.trim()) {
+    cells.pop();
+  }
+  if (count) {
+    if (cells.length > count) {
+      cells.splice(count);
+    } else {
+      while (cells.length < count) cells.push("");
+    }
+  }
+  for (; i < cells.length; i++) {
+    cells[i] = cells[i].trim().replace(other.slashPipe, "|");
+  }
+  return cells;
+}
+function rtrim(str, c, invert) {
+  const l = str.length;
+  if (l === 0) {
+    return "";
+  }
+  let suffLen = 0;
+  while (suffLen < l) {
+    const currChar = str.charAt(l - suffLen - 1);
+    if (currChar === c && !invert) {
+      suffLen++;
+    } else if (currChar !== c && invert) {
+      suffLen++;
+    } else {
+      break;
+    }
+  }
+  return str.slice(0, l - suffLen);
+}
+function findClosingBracket(str, b) {
+  if (str.indexOf(b[1]) === -1) {
+    return -1;
+  }
+  let level = 0;
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === "\\") {
+      i++;
+    } else if (str[i] === b[0]) {
+      level++;
+    } else if (str[i] === b[1]) {
+      level--;
+      if (level < 0) {
+        return i;
+      }
+    }
+  }
+  if (level > 0) {
+    return -2;
+  }
+  return -1;
+}
+function outputLink(cap, link2, raw, lexer2, rules) {
+  const href = link2.href;
+  const title = link2.title || null;
+  const text = cap[1].replace(rules.other.outputLinkReplace, "$1");
+  lexer2.state.inLink = true;
+  const token = {
+    type: cap[0].charAt(0) === "!" ? "image" : "link",
+    raw,
+    href,
+    title,
+    text,
+    tokens: lexer2.inlineTokens(text)
+  };
+  lexer2.state.inLink = false;
+  return token;
+}
+function indentCodeCompensation(raw, text, rules) {
+  const matchIndentToCode = raw.match(rules.other.indentCodeCompensation);
+  if (matchIndentToCode === null) {
+    return text;
+  }
+  const indentToCode = matchIndentToCode[1];
+  return text.split("\n").map((node) => {
+    const matchIndentInNode = node.match(rules.other.beginningSpace);
+    if (matchIndentInNode === null) {
+      return node;
+    }
+    const [indentInNode] = matchIndentInNode;
+    if (indentInNode.length >= indentToCode.length) {
+      return node.slice(indentToCode.length);
+    }
+    return node;
+  }).join("\n");
+}
+var _Tokenizer = class {
+  options;
+  rules;
+  // set by the lexer
+  lexer;
+  // set by the lexer
+  constructor(options2) {
+    this.options = options2 || _defaults;
+  }
+  space(src) {
+    const cap = this.rules.block.newline.exec(src);
+    if (cap && cap[0].length > 0) {
+      return {
+        type: "space",
+        raw: cap[0]
+      };
+    }
+  }
+  code(src) {
+    const cap = this.rules.block.code.exec(src);
+    if (cap) {
+      const text = cap[0].replace(this.rules.other.codeRemoveIndent, "");
+      return {
+        type: "code",
+        raw: cap[0],
+        codeBlockStyle: "indented",
+        text: !this.options.pedantic ? rtrim(text, "\n") : text
+      };
+    }
+  }
+  fences(src) {
+    const cap = this.rules.block.fences.exec(src);
+    if (cap) {
+      const raw = cap[0];
+      const text = indentCodeCompensation(raw, cap[3] || "", this.rules);
+      return {
+        type: "code",
+        raw,
+        lang: cap[2] ? cap[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : cap[2],
+        text
+      };
+    }
+  }
+  heading(src) {
+    const cap = this.rules.block.heading.exec(src);
+    if (cap) {
+      let text = cap[2].trim();
+      if (this.rules.other.endingHash.test(text)) {
+        const trimmed = rtrim(text, "#");
+        if (this.options.pedantic) {
+          text = trimmed.trim();
+        } else if (!trimmed || this.rules.other.endingSpaceChar.test(trimmed)) {
+          text = trimmed.trim();
+        }
+      }
+      return {
+        type: "heading",
+        raw: cap[0],
+        depth: cap[1].length,
+        text,
+        tokens: this.lexer.inline(text)
+      };
+    }
+  }
+  hr(src) {
+    const cap = this.rules.block.hr.exec(src);
+    if (cap) {
+      return {
+        type: "hr",
+        raw: rtrim(cap[0], "\n")
+      };
+    }
+  }
+  blockquote(src) {
+    const cap = this.rules.block.blockquote.exec(src);
+    if (cap) {
+      let lines = rtrim(cap[0], "\n").split("\n");
+      let raw = "";
+      let text = "";
+      const tokens = [];
+      while (lines.length > 0) {
+        let inBlockquote = false;
+        const currentLines = [];
+        let i;
+        for (i = 0; i < lines.length; i++) {
+          if (this.rules.other.blockquoteStart.test(lines[i])) {
+            currentLines.push(lines[i]);
+            inBlockquote = true;
+          } else if (!inBlockquote) {
+            currentLines.push(lines[i]);
+          } else {
+            break;
+          }
+        }
+        lines = lines.slice(i);
+        const currentRaw = currentLines.join("\n");
+        const currentText = currentRaw.replace(this.rules.other.blockquoteSetextReplace, "\n    $1").replace(this.rules.other.blockquoteSetextReplace2, "");
+        raw = raw ? `${raw}
+${currentRaw}` : currentRaw;
+        text = text ? `${text}
+${currentText}` : currentText;
+        const top = this.lexer.state.top;
+        this.lexer.state.top = true;
+        this.lexer.blockTokens(currentText, tokens, true);
+        this.lexer.state.top = top;
+        if (lines.length === 0) {
+          break;
+        }
+        const lastToken = tokens.at(-1);
+        if (lastToken?.type === "code") {
+          break;
+        } else if (lastToken?.type === "blockquote") {
+          const oldToken = lastToken;
+          const newText = oldToken.raw + "\n" + lines.join("\n");
+          const newToken = this.blockquote(newText);
+          tokens[tokens.length - 1] = newToken;
+          raw = raw.substring(0, raw.length - oldToken.raw.length) + newToken.raw;
+          text = text.substring(0, text.length - oldToken.text.length) + newToken.text;
+          break;
+        } else if (lastToken?.type === "list") {
+          const oldToken = lastToken;
+          const newText = oldToken.raw + "\n" + lines.join("\n");
+          const newToken = this.list(newText);
+          tokens[tokens.length - 1] = newToken;
+          raw = raw.substring(0, raw.length - lastToken.raw.length) + newToken.raw;
+          text = text.substring(0, text.length - oldToken.raw.length) + newToken.raw;
+          lines = newText.substring(tokens.at(-1).raw.length).split("\n");
+          continue;
+        }
+      }
+      return {
+        type: "blockquote",
+        raw,
+        tokens,
+        text
+      };
+    }
+  }
+  list(src) {
+    let cap = this.rules.block.list.exec(src);
+    if (cap) {
+      let bull = cap[1].trim();
+      const isordered = bull.length > 1;
+      const list2 = {
+        type: "list",
+        raw: "",
+        ordered: isordered,
+        start: isordered ? +bull.slice(0, -1) : "",
+        loose: false,
+        items: []
+      };
+      bull = isordered ? `\\d{1,9}\\${bull.slice(-1)}` : `\\${bull}`;
+      if (this.options.pedantic) {
+        bull = isordered ? bull : "[*+-]";
+      }
+      const itemRegex = this.rules.other.listItemRegex(bull);
+      let endsWithBlankLine = false;
+      while (src) {
+        let endEarly = false;
+        let raw = "";
+        let itemContents = "";
+        if (!(cap = itemRegex.exec(src))) {
+          break;
+        }
+        if (this.rules.block.hr.test(src)) {
+          break;
+        }
+        raw = cap[0];
+        src = src.substring(raw.length);
+        let line = cap[2].split("\n", 1)[0].replace(this.rules.other.listReplaceTabs, (t) => " ".repeat(3 * t.length));
+        let nextLine = src.split("\n", 1)[0];
+        let blankLine = !line.trim();
+        let indent = 0;
+        if (this.options.pedantic) {
+          indent = 2;
+          itemContents = line.trimStart();
+        } else if (blankLine) {
+          indent = cap[1].length + 1;
+        } else {
+          indent = cap[2].search(this.rules.other.nonSpaceChar);
+          indent = indent > 4 ? 1 : indent;
+          itemContents = line.slice(indent);
+          indent += cap[1].length;
+        }
+        if (blankLine && this.rules.other.blankLine.test(nextLine)) {
+          raw += nextLine + "\n";
+          src = src.substring(nextLine.length + 1);
+          endEarly = true;
+        }
+        if (!endEarly) {
+          const nextBulletRegex = this.rules.other.nextBulletRegex(indent);
+          const hrRegex = this.rules.other.hrRegex(indent);
+          const fencesBeginRegex = this.rules.other.fencesBeginRegex(indent);
+          const headingBeginRegex = this.rules.other.headingBeginRegex(indent);
+          const htmlBeginRegex = this.rules.other.htmlBeginRegex(indent);
+          while (src) {
+            const rawLine = src.split("\n", 1)[0];
+            let nextLineWithoutTabs;
+            nextLine = rawLine;
+            if (this.options.pedantic) {
+              nextLine = nextLine.replace(this.rules.other.listReplaceNesting, "  ");
+              nextLineWithoutTabs = nextLine;
+            } else {
+              nextLineWithoutTabs = nextLine.replace(this.rules.other.tabCharGlobal, "    ");
+            }
+            if (fencesBeginRegex.test(nextLine)) {
+              break;
+            }
+            if (headingBeginRegex.test(nextLine)) {
+              break;
+            }
+            if (htmlBeginRegex.test(nextLine)) {
+              break;
+            }
+            if (nextBulletRegex.test(nextLine)) {
+              break;
+            }
+            if (hrRegex.test(nextLine)) {
+              break;
+            }
+            if (nextLineWithoutTabs.search(this.rules.other.nonSpaceChar) >= indent || !nextLine.trim()) {
+              itemContents += "\n" + nextLineWithoutTabs.slice(indent);
+            } else {
+              if (blankLine) {
+                break;
+              }
+              if (line.replace(this.rules.other.tabCharGlobal, "    ").search(this.rules.other.nonSpaceChar) >= 4) {
+                break;
+              }
+              if (fencesBeginRegex.test(line)) {
+                break;
+              }
+              if (headingBeginRegex.test(line)) {
+                break;
+              }
+              if (hrRegex.test(line)) {
+                break;
+              }
+              itemContents += "\n" + nextLine;
+            }
+            if (!blankLine && !nextLine.trim()) {
+              blankLine = true;
+            }
+            raw += rawLine + "\n";
+            src = src.substring(rawLine.length + 1);
+            line = nextLineWithoutTabs.slice(indent);
+          }
+        }
+        if (!list2.loose) {
+          if (endsWithBlankLine) {
+            list2.loose = true;
+          } else if (this.rules.other.doubleBlankLine.test(raw)) {
+            endsWithBlankLine = true;
+          }
+        }
+        let istask = null;
+        let ischecked;
+        if (this.options.gfm) {
+          istask = this.rules.other.listIsTask.exec(itemContents);
+          if (istask) {
+            ischecked = istask[0] !== "[ ] ";
+            itemContents = itemContents.replace(this.rules.other.listReplaceTask, "");
+          }
+        }
+        list2.items.push({
+          type: "list_item",
+          raw,
+          task: !!istask,
+          checked: ischecked,
+          loose: false,
+          text: itemContents,
+          tokens: []
+        });
+        list2.raw += raw;
+      }
+      const lastItem = list2.items.at(-1);
+      if (lastItem) {
+        lastItem.raw = lastItem.raw.trimEnd();
+        lastItem.text = lastItem.text.trimEnd();
+      } else {
+        return;
+      }
+      list2.raw = list2.raw.trimEnd();
+      for (let i = 0; i < list2.items.length; i++) {
+        this.lexer.state.top = false;
+        list2.items[i].tokens = this.lexer.blockTokens(list2.items[i].text, []);
+        if (!list2.loose) {
+          const spacers = list2.items[i].tokens.filter((t) => t.type === "space");
+          const hasMultipleLineBreaks = spacers.length > 0 && spacers.some((t) => this.rules.other.anyLine.test(t.raw));
+          list2.loose = hasMultipleLineBreaks;
+        }
+      }
+      if (list2.loose) {
+        for (let i = 0; i < list2.items.length; i++) {
+          list2.items[i].loose = true;
+        }
+      }
+      return list2;
+    }
+  }
+  html(src) {
+    const cap = this.rules.block.html.exec(src);
+    if (cap) {
+      const token = {
+        type: "html",
+        block: true,
+        raw: cap[0],
+        pre: cap[1] === "pre" || cap[1] === "script" || cap[1] === "style",
+        text: cap[0]
+      };
+      return token;
+    }
+  }
+  def(src) {
+    const cap = this.rules.block.def.exec(src);
+    if (cap) {
+      const tag2 = cap[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, " ");
+      const href = cap[2] ? cap[2].replace(this.rules.other.hrefBrackets, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "";
+      const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : cap[3];
+      return {
+        type: "def",
+        tag: tag2,
+        raw: cap[0],
+        href,
+        title
+      };
+    }
+  }
+  table(src) {
+    const cap = this.rules.block.table.exec(src);
+    if (!cap) {
+      return;
+    }
+    if (!this.rules.other.tableDelimiter.test(cap[2])) {
+      return;
+    }
+    const headers = splitCells(cap[1]);
+    const aligns = cap[2].replace(this.rules.other.tableAlignChars, "").split("|");
+    const rows = cap[3]?.trim() ? cap[3].replace(this.rules.other.tableRowBlankLine, "").split("\n") : [];
+    const item = {
+      type: "table",
+      raw: cap[0],
+      header: [],
+      align: [],
+      rows: []
+    };
+    if (headers.length !== aligns.length) {
+      return;
+    }
+    for (const align of aligns) {
+      if (this.rules.other.tableAlignRight.test(align)) {
+        item.align.push("right");
+      } else if (this.rules.other.tableAlignCenter.test(align)) {
+        item.align.push("center");
+      } else if (this.rules.other.tableAlignLeft.test(align)) {
+        item.align.push("left");
+      } else {
+        item.align.push(null);
+      }
+    }
+    for (let i = 0; i < headers.length; i++) {
+      item.header.push({
+        text: headers[i],
+        tokens: this.lexer.inline(headers[i]),
+        header: true,
+        align: item.align[i]
+      });
+    }
+    for (const row of rows) {
+      item.rows.push(splitCells(row, item.header.length).map((cell, i) => {
+        return {
+          text: cell,
+          tokens: this.lexer.inline(cell),
+          header: false,
+          align: item.align[i]
+        };
+      }));
+    }
+    return item;
+  }
+  lheading(src) {
+    const cap = this.rules.block.lheading.exec(src);
+    if (cap) {
+      return {
+        type: "heading",
+        raw: cap[0],
+        depth: cap[2].charAt(0) === "=" ? 1 : 2,
+        text: cap[1],
+        tokens: this.lexer.inline(cap[1])
+      };
+    }
+  }
+  paragraph(src) {
+    const cap = this.rules.block.paragraph.exec(src);
+    if (cap) {
+      const text = cap[1].charAt(cap[1].length - 1) === "\n" ? cap[1].slice(0, -1) : cap[1];
+      return {
+        type: "paragraph",
+        raw: cap[0],
+        text,
+        tokens: this.lexer.inline(text)
+      };
+    }
+  }
+  text(src) {
+    const cap = this.rules.block.text.exec(src);
+    if (cap) {
+      return {
+        type: "text",
+        raw: cap[0],
+        text: cap[0],
+        tokens: this.lexer.inline(cap[0])
+      };
+    }
+  }
+  escape(src) {
+    const cap = this.rules.inline.escape.exec(src);
+    if (cap) {
+      return {
+        type: "escape",
+        raw: cap[0],
+        text: cap[1]
+      };
+    }
+  }
+  tag(src) {
+    const cap = this.rules.inline.tag.exec(src);
+    if (cap) {
+      if (!this.lexer.state.inLink && this.rules.other.startATag.test(cap[0])) {
+        this.lexer.state.inLink = true;
+      } else if (this.lexer.state.inLink && this.rules.other.endATag.test(cap[0])) {
+        this.lexer.state.inLink = false;
+      }
+      if (!this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(cap[0])) {
+        this.lexer.state.inRawBlock = true;
+      } else if (this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(cap[0])) {
+        this.lexer.state.inRawBlock = false;
+      }
+      return {
+        type: "html",
+        raw: cap[0],
+        inLink: this.lexer.state.inLink,
+        inRawBlock: this.lexer.state.inRawBlock,
+        block: false,
+        text: cap[0]
+      };
+    }
+  }
+  link(src) {
+    const cap = this.rules.inline.link.exec(src);
+    if (cap) {
+      const trimmedUrl = cap[2].trim();
+      if (!this.options.pedantic && this.rules.other.startAngleBracket.test(trimmedUrl)) {
+        if (!this.rules.other.endAngleBracket.test(trimmedUrl)) {
+          return;
+        }
+        const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), "\\");
+        if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {
+          return;
+        }
+      } else {
+        const lastParenIndex = findClosingBracket(cap[2], "()");
+        if (lastParenIndex === -2) {
+          return;
+        }
+        if (lastParenIndex > -1) {
+          const start = cap[0].indexOf("!") === 0 ? 5 : 4;
+          const linkLen = start + cap[1].length + lastParenIndex;
+          cap[2] = cap[2].substring(0, lastParenIndex);
+          cap[0] = cap[0].substring(0, linkLen).trim();
+          cap[3] = "";
+        }
+      }
+      let href = cap[2];
+      let title = "";
+      if (this.options.pedantic) {
+        const link2 = this.rules.other.pedanticHrefTitle.exec(href);
+        if (link2) {
+          href = link2[1];
+          title = link2[3];
+        }
+      } else {
+        title = cap[3] ? cap[3].slice(1, -1) : "";
+      }
+      href = href.trim();
+      if (this.rules.other.startAngleBracket.test(href)) {
+        if (this.options.pedantic && !this.rules.other.endAngleBracket.test(trimmedUrl)) {
+          href = href.slice(1);
+        } else {
+          href = href.slice(1, -1);
+        }
+      }
+      return outputLink(cap, {
+        href: href ? href.replace(this.rules.inline.anyPunctuation, "$1") : href,
+        title: title ? title.replace(this.rules.inline.anyPunctuation, "$1") : title
+      }, cap[0], this.lexer, this.rules);
+    }
+  }
+  reflink(src, links) {
+    let cap;
+    if ((cap = this.rules.inline.reflink.exec(src)) || (cap = this.rules.inline.nolink.exec(src))) {
+      const linkString = (cap[2] || cap[1]).replace(this.rules.other.multipleSpaceGlobal, " ");
+      const link2 = links[linkString.toLowerCase()];
+      if (!link2) {
+        const text = cap[0].charAt(0);
+        return {
+          type: "text",
+          raw: text,
+          text
+        };
+      }
+      return outputLink(cap, link2, cap[0], this.lexer, this.rules);
+    }
+  }
+  emStrong(src, maskedSrc, prevChar = "") {
+    let match = this.rules.inline.emStrongLDelim.exec(src);
+    if (!match) return;
+    if (match[3] && prevChar.match(this.rules.other.unicodeAlphaNumeric)) return;
+    const nextChar = match[1] || match[2] || "";
+    if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {
+      const lLength = [...match[0]].length - 1;
+      let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;
+      const endReg = match[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
+      endReg.lastIndex = 0;
+      maskedSrc = maskedSrc.slice(-1 * src.length + lLength);
+      while ((match = endReg.exec(maskedSrc)) != null) {
+        rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
+        if (!rDelim) continue;
+        rLength = [...rDelim].length;
+        if (match[3] || match[4]) {
+          delimTotal += rLength;
+          continue;
+        } else if (match[5] || match[6]) {
+          if (lLength % 3 && !((lLength + rLength) % 3)) {
+            midDelimTotal += rLength;
+            continue;
+          }
+        }
+        delimTotal -= rLength;
+        if (delimTotal > 0) continue;
+        rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
+        const lastCharLength = [...match[0]][0].length;
+        const raw = src.slice(0, lLength + match.index + lastCharLength + rLength);
+        if (Math.min(lLength, rLength) % 2) {
+          const text2 = raw.slice(1, -1);
+          return {
+            type: "em",
+            raw,
+            text: text2,
+            tokens: this.lexer.inlineTokens(text2)
+          };
+        }
+        const text = raw.slice(2, -2);
+        return {
+          type: "strong",
+          raw,
+          text,
+          tokens: this.lexer.inlineTokens(text)
+        };
+      }
+    }
+  }
+  codespan(src) {
+    const cap = this.rules.inline.code.exec(src);
+    if (cap) {
+      let text = cap[2].replace(this.rules.other.newLineCharGlobal, " ");
+      const hasNonSpaceChars = this.rules.other.nonSpaceChar.test(text);
+      const hasSpaceCharsOnBothEnds = this.rules.other.startingSpaceChar.test(text) && this.rules.other.endingSpaceChar.test(text);
+      if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
+        text = text.substring(1, text.length - 1);
+      }
+      return {
+        type: "codespan",
+        raw: cap[0],
+        text
+      };
+    }
+  }
+  br(src) {
+    const cap = this.rules.inline.br.exec(src);
+    if (cap) {
+      return {
+        type: "br",
+        raw: cap[0]
+      };
+    }
+  }
+  del(src) {
+    const cap = this.rules.inline.del.exec(src);
+    if (cap) {
+      return {
+        type: "del",
+        raw: cap[0],
+        text: cap[2],
+        tokens: this.lexer.inlineTokens(cap[2])
+      };
+    }
+  }
+  autolink(src) {
+    const cap = this.rules.inline.autolink.exec(src);
+    if (cap) {
+      let text, href;
+      if (cap[2] === "@") {
+        text = cap[1];
+        href = "mailto:" + text;
+      } else {
+        text = cap[1];
+        href = text;
+      }
+      return {
+        type: "link",
+        raw: cap[0],
+        text,
+        href,
+        tokens: [
+          {
+            type: "text",
+            raw: text,
+            text
+          }
+        ]
+      };
+    }
+  }
+  url(src) {
+    let cap;
+    if (cap = this.rules.inline.url.exec(src)) {
+      let text, href;
+      if (cap[2] === "@") {
+        text = cap[0];
+        href = "mailto:" + text;
+      } else {
+        let prevCapZero;
+        do {
+          prevCapZero = cap[0];
+          cap[0] = this.rules.inline._backpedal.exec(cap[0])?.[0] ?? "";
+        } while (prevCapZero !== cap[0]);
+        text = cap[0];
+        if (cap[1] === "www.") {
+          href = "http://" + cap[0];
+        } else {
+          href = cap[0];
+        }
+      }
+      return {
+        type: "link",
+        raw: cap[0],
+        text,
+        href,
+        tokens: [
+          {
+            type: "text",
+            raw: text,
+            text
+          }
+        ]
+      };
+    }
+  }
+  inlineText(src) {
+    const cap = this.rules.inline.text.exec(src);
+    if (cap) {
+      const escaped = this.lexer.state.inRawBlock;
+      return {
+        type: "text",
+        raw: cap[0],
+        text: cap[0],
+        escaped
+      };
+    }
+  }
+};
+var _Lexer = class __Lexer {
+  tokens;
+  options;
+  state;
+  tokenizer;
+  inlineQueue;
+  constructor(options2) {
+    this.tokens = [];
+    this.tokens.links = /* @__PURE__ */ Object.create(null);
+    this.options = options2 || _defaults;
+    this.options.tokenizer = this.options.tokenizer || new _Tokenizer();
+    this.tokenizer = this.options.tokenizer;
+    this.tokenizer.options = this.options;
+    this.tokenizer.lexer = this;
+    this.inlineQueue = [];
+    this.state = {
+      inLink: false,
+      inRawBlock: false,
+      top: true
+    };
+    const rules = {
+      other,
+      block: block.normal,
+      inline: inline.normal
+    };
+    if (this.options.pedantic) {
+      rules.block = block.pedantic;
+      rules.inline = inline.pedantic;
+    } else if (this.options.gfm) {
+      rules.block = block.gfm;
+      if (this.options.breaks) {
+        rules.inline = inline.breaks;
+      } else {
+        rules.inline = inline.gfm;
+      }
+    }
+    this.tokenizer.rules = rules;
+  }
+  /**
+   * Expose Rules
+   */
+  static get rules() {
+    return {
+      block,
+      inline
+    };
+  }
+  /**
+   * Static Lex Method
+   */
+  static lex(src, options2) {
+    const lexer2 = new __Lexer(options2);
+    return lexer2.lex(src);
+  }
+  /**
+   * Static Lex Inline Method
+   */
+  static lexInline(src, options2) {
+    const lexer2 = new __Lexer(options2);
+    return lexer2.inlineTokens(src);
+  }
+  /**
+   * Preprocessing
+   */
+  lex(src) {
+    src = src.replace(other.carriageReturn, "\n");
+    this.blockTokens(src, this.tokens);
+    for (let i = 0; i < this.inlineQueue.length; i++) {
+      const next = this.inlineQueue[i];
+      this.inlineTokens(next.src, next.tokens);
+    }
+    this.inlineQueue = [];
+    return this.tokens;
+  }
+  blockTokens(src, tokens = [], lastParagraphClipped = false) {
+    if (this.options.pedantic) {
+      src = src.replace(other.tabCharGlobal, "    ").replace(other.spaceLine, "");
+    }
+    while (src) {
+      let token;
+      if (this.options.extensions?.block?.some((extTokenizer) => {
+        if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
+          src = src.substring(token.raw.length);
+          tokens.push(token);
+          return true;
+        }
+        return false;
+      })) {
+        continue;
+      }
+      if (token = this.tokenizer.space(src)) {
+        src = src.substring(token.raw.length);
+        const lastToken = tokens.at(-1);
+        if (token.raw.length === 1 && lastToken !== void 0) {
+          lastToken.raw += "\n";
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (token = this.tokenizer.code(src)) {
+        src = src.substring(token.raw.length);
+        const lastToken = tokens.at(-1);
+        if (lastToken?.type === "paragraph" || lastToken?.type === "text") {
+          lastToken.raw += "\n" + token.raw;
+          lastToken.text += "\n" + token.text;
+          this.inlineQueue.at(-1).src = lastToken.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (token = this.tokenizer.fences(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.heading(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.hr(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.blockquote(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.list(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.html(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.def(src)) {
+        src = src.substring(token.raw.length);
+        const lastToken = tokens.at(-1);
+        if (lastToken?.type === "paragraph" || lastToken?.type === "text") {
+          lastToken.raw += "\n" + token.raw;
+          lastToken.text += "\n" + token.raw;
+          this.inlineQueue.at(-1).src = lastToken.text;
+        } else if (!this.tokens.links[token.tag]) {
+          this.tokens.links[token.tag] = {
+            href: token.href,
+            title: token.title
+          };
+        }
+        continue;
+      }
+      if (token = this.tokenizer.table(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.lheading(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      let cutSrc = src;
+      if (this.options.extensions?.startBlock) {
+        let startIndex = Infinity;
+        const tempSrc = src.slice(1);
+        let tempStart;
+        this.options.extensions.startBlock.forEach((getStartIndex) => {
+          tempStart = getStartIndex.call({ lexer: this }, tempSrc);
+          if (typeof tempStart === "number" && tempStart >= 0) {
+            startIndex = Math.min(startIndex, tempStart);
+          }
+        });
+        if (startIndex < Infinity && startIndex >= 0) {
+          cutSrc = src.substring(0, startIndex + 1);
+        }
+      }
+      if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) {
+        const lastToken = tokens.at(-1);
+        if (lastParagraphClipped && lastToken?.type === "paragraph") {
+          lastToken.raw += "\n" + token.raw;
+          lastToken.text += "\n" + token.text;
+          this.inlineQueue.pop();
+          this.inlineQueue.at(-1).src = lastToken.text;
+        } else {
+          tokens.push(token);
+        }
+        lastParagraphClipped = cutSrc.length !== src.length;
+        src = src.substring(token.raw.length);
+        continue;
+      }
+      if (token = this.tokenizer.text(src)) {
+        src = src.substring(token.raw.length);
+        const lastToken = tokens.at(-1);
+        if (lastToken?.type === "text") {
+          lastToken.raw += "\n" + token.raw;
+          lastToken.text += "\n" + token.text;
+          this.inlineQueue.pop();
+          this.inlineQueue.at(-1).src = lastToken.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (src) {
+        const errMsg = "Infinite loop on byte: " + src.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(errMsg);
+          break;
+        } else {
+          throw new Error(errMsg);
+        }
+      }
+    }
+    this.state.top = true;
+    return tokens;
+  }
+  inline(src, tokens = []) {
+    this.inlineQueue.push({ src, tokens });
+    return tokens;
+  }
+  /**
+   * Lexing/Compiling
+   */
+  inlineTokens(src, tokens = []) {
+    let maskedSrc = src;
+    let match = null;
+    if (this.tokens.links) {
+      const links = Object.keys(this.tokens.links);
+      if (links.length > 0) {
+        while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) {
+          if (links.includes(match[0].slice(match[0].lastIndexOf("[") + 1, -1))) {
+            maskedSrc = maskedSrc.slice(0, match.index) + "[" + "a".repeat(match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);
+          }
+        }
+      }
+    }
+    while ((match = this.tokenizer.rules.inline.anyPunctuation.exec(maskedSrc)) != null) {
+      maskedSrc = maskedSrc.slice(0, match.index) + "++" + maskedSrc.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
+    }
+    while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {
+      maskedSrc = maskedSrc.slice(0, match.index) + "[" + "a".repeat(match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
+    }
+    let keepPrevChar = false;
+    let prevChar = "";
+    while (src) {
+      if (!keepPrevChar) {
+        prevChar = "";
+      }
+      keepPrevChar = false;
+      let token;
+      if (this.options.extensions?.inline?.some((extTokenizer) => {
+        if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
+          src = src.substring(token.raw.length);
+          tokens.push(token);
+          return true;
+        }
+        return false;
+      })) {
+        continue;
+      }
+      if (token = this.tokenizer.escape(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.tag(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.link(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.reflink(src, this.tokens.links)) {
+        src = src.substring(token.raw.length);
+        const lastToken = tokens.at(-1);
+        if (token.type === "text" && lastToken?.type === "text") {
+          lastToken.raw += token.raw;
+          lastToken.text += token.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.codespan(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.br(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.del(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.autolink(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (!this.state.inLink && (token = this.tokenizer.url(src))) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      let cutSrc = src;
+      if (this.options.extensions?.startInline) {
+        let startIndex = Infinity;
+        const tempSrc = src.slice(1);
+        let tempStart;
+        this.options.extensions.startInline.forEach((getStartIndex) => {
+          tempStart = getStartIndex.call({ lexer: this }, tempSrc);
+          if (typeof tempStart === "number" && tempStart >= 0) {
+            startIndex = Math.min(startIndex, tempStart);
+          }
+        });
+        if (startIndex < Infinity && startIndex >= 0) {
+          cutSrc = src.substring(0, startIndex + 1);
+        }
+      }
+      if (token = this.tokenizer.inlineText(cutSrc)) {
+        src = src.substring(token.raw.length);
+        if (token.raw.slice(-1) !== "_") {
+          prevChar = token.raw.slice(-1);
+        }
+        keepPrevChar = true;
+        const lastToken = tokens.at(-1);
+        if (lastToken?.type === "text") {
+          lastToken.raw += token.raw;
+          lastToken.text += token.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (src) {
+        const errMsg = "Infinite loop on byte: " + src.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(errMsg);
+          break;
+        } else {
+          throw new Error(errMsg);
+        }
+      }
+    }
+    return tokens;
+  }
+};
+var _Renderer = class {
+  options;
+  parser;
+  // set by the parser
+  constructor(options2) {
+    this.options = options2 || _defaults;
+  }
+  space(token) {
+    return "";
+  }
+  code({ text, lang, escaped }) {
+    const langString = (lang || "").match(other.notSpaceStart)?.[0];
+    const code = text.replace(other.endingNewline, "") + "\n";
+    if (!langString) {
+      return "<pre><code>" + (escaped ? code : escape2(code, true)) + "</code></pre>\n";
+    }
+    return '<pre><code class="language-' + escape2(langString) + '">' + (escaped ? code : escape2(code, true)) + "</code></pre>\n";
+  }
+  blockquote({ tokens }) {
+    const body = this.parser.parse(tokens);
+    return `<blockquote>
+${body}</blockquote>
+`;
+  }
+  html({ text }) {
+    return text;
+  }
+  heading({ tokens, depth }) {
+    return `<h${depth}>${this.parser.parseInline(tokens)}</h${depth}>
+`;
+  }
+  hr(token) {
+    return "<hr>\n";
+  }
+  list(token) {
+    const ordered = token.ordered;
+    const start = token.start;
+    let body = "";
+    for (let j = 0; j < token.items.length; j++) {
+      const item = token.items[j];
+      body += this.listitem(item);
+    }
+    const type = ordered ? "ol" : "ul";
+    const startAttr = ordered && start !== 1 ? ' start="' + start + '"' : "";
+    return "<" + type + startAttr + ">\n" + body + "</" + type + ">\n";
+  }
+  listitem(item) {
+    let itemBody = "";
+    if (item.task) {
+      const checkbox = this.checkbox({ checked: !!item.checked });
+      if (item.loose) {
+        if (item.tokens[0]?.type === "paragraph") {
+          item.tokens[0].text = checkbox + " " + item.tokens[0].text;
+          if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === "text") {
+            item.tokens[0].tokens[0].text = checkbox + " " + escape2(item.tokens[0].tokens[0].text);
+            item.tokens[0].tokens[0].escaped = true;
+          }
+        } else {
+          item.tokens.unshift({
+            type: "text",
+            raw: checkbox + " ",
+            text: checkbox + " ",
+            escaped: true
+          });
+        }
+      } else {
+        itemBody += checkbox + " ";
+      }
+    }
+    itemBody += this.parser.parse(item.tokens, !!item.loose);
+    return `<li>${itemBody}</li>
+`;
+  }
+  checkbox({ checked }) {
+    return "<input " + (checked ? 'checked="" ' : "") + 'disabled="" type="checkbox">';
+  }
+  paragraph({ tokens }) {
+    return `<p>${this.parser.parseInline(tokens)}</p>
+`;
+  }
+  table(token) {
+    let header = "";
+    let cell = "";
+    for (let j = 0; j < token.header.length; j++) {
+      cell += this.tablecell(token.header[j]);
+    }
+    header += this.tablerow({ text: cell });
+    let body = "";
+    for (let j = 0; j < token.rows.length; j++) {
+      const row = token.rows[j];
+      cell = "";
+      for (let k = 0; k < row.length; k++) {
+        cell += this.tablecell(row[k]);
+      }
+      body += this.tablerow({ text: cell });
+    }
+    if (body) body = `<tbody>${body}</tbody>`;
+    return "<table>\n<thead>\n" + header + "</thead>\n" + body + "</table>\n";
+  }
+  tablerow({ text }) {
+    return `<tr>
+${text}</tr>
+`;
+  }
+  tablecell(token) {
+    const content = this.parser.parseInline(token.tokens);
+    const type = token.header ? "th" : "td";
+    const tag2 = token.align ? `<${type} align="${token.align}">` : `<${type}>`;
+    return tag2 + content + `</${type}>
+`;
+  }
+  /**
+   * span level renderer
+   */
+  strong({ tokens }) {
+    return `<strong>${this.parser.parseInline(tokens)}</strong>`;
+  }
+  em({ tokens }) {
+    return `<em>${this.parser.parseInline(tokens)}</em>`;
+  }
+  codespan({ text }) {
+    return `<code>${escape2(text, true)}</code>`;
+  }
+  br(token) {
+    return "<br>";
+  }
+  del({ tokens }) {
+    return `<del>${this.parser.parseInline(tokens)}</del>`;
+  }
+  link({ href, title, tokens }) {
+    const text = this.parser.parseInline(tokens);
+    const cleanHref = cleanUrl(href);
+    if (cleanHref === null) {
+      return text;
+    }
+    href = cleanHref;
+    let out = '<a href="' + href + '"';
+    if (title) {
+      out += ' title="' + escape2(title) + '"';
+    }
+    out += ">" + text + "</a>";
+    return out;
+  }
+  image({ href, title, text, tokens }) {
+    if (tokens) {
+      text = this.parser.parseInline(tokens, this.parser.textRenderer);
+    }
+    const cleanHref = cleanUrl(href);
+    if (cleanHref === null) {
+      return escape2(text);
+    }
+    href = cleanHref;
+    let out = `<img src="${href}" alt="${text}"`;
+    if (title) {
+      out += ` title="${escape2(title)}"`;
+    }
+    out += ">";
+    return out;
+  }
+  text(token) {
+    return "tokens" in token && token.tokens ? this.parser.parseInline(token.tokens) : "escaped" in token && token.escaped ? token.text : escape2(token.text);
+  }
+};
+var _TextRenderer = class {
+  // no need for block level renderers
+  strong({ text }) {
+    return text;
+  }
+  em({ text }) {
+    return text;
+  }
+  codespan({ text }) {
+    return text;
+  }
+  del({ text }) {
+    return text;
+  }
+  html({ text }) {
+    return text;
+  }
+  text({ text }) {
+    return text;
+  }
+  link({ text }) {
+    return "" + text;
+  }
+  image({ text }) {
+    return "" + text;
+  }
+  br() {
+    return "";
+  }
+};
+var _Parser = class __Parser {
+  options;
+  renderer;
+  textRenderer;
+  constructor(options2) {
+    this.options = options2 || _defaults;
+    this.options.renderer = this.options.renderer || new _Renderer();
+    this.renderer = this.options.renderer;
+    this.renderer.options = this.options;
+    this.renderer.parser = this;
+    this.textRenderer = new _TextRenderer();
+  }
+  /**
+   * Static Parse Method
+   */
+  static parse(tokens, options2) {
+    const parser2 = new __Parser(options2);
+    return parser2.parse(tokens);
+  }
+  /**
+   * Static Parse Inline Method
+   */
+  static parseInline(tokens, options2) {
+    const parser2 = new __Parser(options2);
+    return parser2.parseInline(tokens);
+  }
+  /**
+   * Parse Loop
+   */
+  parse(tokens, top = true) {
+    let out = "";
+    for (let i = 0; i < tokens.length; i++) {
+      const anyToken = tokens[i];
+      if (this.options.extensions?.renderers?.[anyToken.type]) {
+        const genericToken = anyToken;
+        const ret = this.options.extensions.renderers[genericToken.type].call({ parser: this }, genericToken);
+        if (ret !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "paragraph", "text"].includes(genericToken.type)) {
+          out += ret || "";
+          continue;
+        }
+      }
+      const token = anyToken;
+      switch (token.type) {
+        case "space": {
+          out += this.renderer.space(token);
+          continue;
+        }
+        case "hr": {
+          out += this.renderer.hr(token);
+          continue;
+        }
+        case "heading": {
+          out += this.renderer.heading(token);
+          continue;
+        }
+        case "code": {
+          out += this.renderer.code(token);
+          continue;
+        }
+        case "table": {
+          out += this.renderer.table(token);
+          continue;
+        }
+        case "blockquote": {
+          out += this.renderer.blockquote(token);
+          continue;
+        }
+        case "list": {
+          out += this.renderer.list(token);
+          continue;
+        }
+        case "html": {
+          out += this.renderer.html(token);
+          continue;
+        }
+        case "paragraph": {
+          out += this.renderer.paragraph(token);
+          continue;
+        }
+        case "text": {
+          let textToken = token;
+          let body = this.renderer.text(textToken);
+          while (i + 1 < tokens.length && tokens[i + 1].type === "text") {
+            textToken = tokens[++i];
+            body += "\n" + this.renderer.text(textToken);
+          }
+          if (top) {
+            out += this.renderer.paragraph({
+              type: "paragraph",
+              raw: body,
+              text: body,
+              tokens: [{ type: "text", raw: body, text: body, escaped: true }]
+            });
+          } else {
+            out += body;
+          }
+          continue;
+        }
+        default: {
+          const errMsg = 'Token with "' + token.type + '" type was not found.';
+          if (this.options.silent) {
+            console.error(errMsg);
+            return "";
+          } else {
+            throw new Error(errMsg);
+          }
+        }
+      }
+    }
+    return out;
+  }
+  /**
+   * Parse Inline Tokens
+   */
+  parseInline(tokens, renderer = this.renderer) {
+    let out = "";
+    for (let i = 0; i < tokens.length; i++) {
+      const anyToken = tokens[i];
+      if (this.options.extensions?.renderers?.[anyToken.type]) {
+        const ret = this.options.extensions.renderers[anyToken.type].call({ parser: this }, anyToken);
+        if (ret !== false || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(anyToken.type)) {
+          out += ret || "";
+          continue;
+        }
+      }
+      const token = anyToken;
+      switch (token.type) {
+        case "escape": {
+          out += renderer.text(token);
+          break;
+        }
+        case "html": {
+          out += renderer.html(token);
+          break;
+        }
+        case "link": {
+          out += renderer.link(token);
+          break;
+        }
+        case "image": {
+          out += renderer.image(token);
+          break;
+        }
+        case "strong": {
+          out += renderer.strong(token);
+          break;
+        }
+        case "em": {
+          out += renderer.em(token);
+          break;
+        }
+        case "codespan": {
+          out += renderer.codespan(token);
+          break;
+        }
+        case "br": {
+          out += renderer.br(token);
+          break;
+        }
+        case "del": {
+          out += renderer.del(token);
+          break;
+        }
+        case "text": {
+          out += renderer.text(token);
+          break;
+        }
+        default: {
+          const errMsg = 'Token with "' + token.type + '" type was not found.';
+          if (this.options.silent) {
+            console.error(errMsg);
+            return "";
+          } else {
+            throw new Error(errMsg);
+          }
+        }
+      }
+    }
+    return out;
+  }
+};
+var _Hooks = class {
+  options;
+  block;
+  constructor(options2) {
+    this.options = options2 || _defaults;
+  }
+  static passThroughHooks = /* @__PURE__ */ new Set([
+    "preprocess",
+    "postprocess",
+    "processAllTokens"
+  ]);
+  /**
+   * Process markdown before marked
+   */
+  preprocess(markdown) {
+    return markdown;
+  }
+  /**
+   * Process HTML after marked is finished
+   */
+  postprocess(html2) {
+    return html2;
+  }
+  /**
+   * Process all tokens before walk tokens
+   */
+  processAllTokens(tokens) {
+    return tokens;
+  }
+  /**
+   * Provide function to tokenize markdown
+   */
+  provideLexer() {
+    return this.block ? _Lexer.lex : _Lexer.lexInline;
+  }
+  /**
+   * Provide function to parse tokens
+   */
+  provideParser() {
+    return this.block ? _Parser.parse : _Parser.parseInline;
+  }
+};
+var Marked = class {
+  defaults = _getDefaults();
+  options = this.setOptions;
+  parse = this.parseMarkdown(true);
+  parseInline = this.parseMarkdown(false);
+  Parser = _Parser;
+  Renderer = _Renderer;
+  TextRenderer = _TextRenderer;
+  Lexer = _Lexer;
+  Tokenizer = _Tokenizer;
+  Hooks = _Hooks;
+  constructor(...args) {
+    this.use(...args);
+  }
+  /**
+   * Run callback for every token
+   */
+  walkTokens(tokens, callback) {
+    let values = [];
+    for (const token of tokens) {
+      values = values.concat(callback.call(this, token));
+      switch (token.type) {
+        case "table": {
+          const tableToken = token;
+          for (const cell of tableToken.header) {
+            values = values.concat(this.walkTokens(cell.tokens, callback));
+          }
+          for (const row of tableToken.rows) {
+            for (const cell of row) {
+              values = values.concat(this.walkTokens(cell.tokens, callback));
+            }
+          }
+          break;
+        }
+        case "list": {
+          const listToken = token;
+          values = values.concat(this.walkTokens(listToken.items, callback));
+          break;
+        }
+        default: {
+          const genericToken = token;
+          if (this.defaults.extensions?.childTokens?.[genericToken.type]) {
+            this.defaults.extensions.childTokens[genericToken.type].forEach((childTokens) => {
+              const tokens2 = genericToken[childTokens].flat(Infinity);
+              values = values.concat(this.walkTokens(tokens2, callback));
+            });
+          } else if (genericToken.tokens) {
+            values = values.concat(this.walkTokens(genericToken.tokens, callback));
+          }
+        }
+      }
+    }
+    return values;
+  }
+  use(...args) {
+    const extensions = this.defaults.extensions || { renderers: {}, childTokens: {} };
+    args.forEach((pack) => {
+      const opts = __spreadValues({}, pack);
+      opts.async = this.defaults.async || opts.async || false;
+      if (pack.extensions) {
+        pack.extensions.forEach((ext) => {
+          if (!ext.name) {
+            throw new Error("extension name required");
+          }
+          if ("renderer" in ext) {
+            const prevRenderer = extensions.renderers[ext.name];
+            if (prevRenderer) {
+              extensions.renderers[ext.name] = function(...args2) {
+                let ret = ext.renderer.apply(this, args2);
+                if (ret === false) {
+                  ret = prevRenderer.apply(this, args2);
+                }
+                return ret;
+              };
+            } else {
+              extensions.renderers[ext.name] = ext.renderer;
+            }
+          }
+          if ("tokenizer" in ext) {
+            if (!ext.level || ext.level !== "block" && ext.level !== "inline") {
+              throw new Error("extension level must be 'block' or 'inline'");
+            }
+            const extLevel = extensions[ext.level];
+            if (extLevel) {
+              extLevel.unshift(ext.tokenizer);
+            } else {
+              extensions[ext.level] = [ext.tokenizer];
+            }
+            if (ext.start) {
+              if (ext.level === "block") {
+                if (extensions.startBlock) {
+                  extensions.startBlock.push(ext.start);
+                } else {
+                  extensions.startBlock = [ext.start];
+                }
+              } else if (ext.level === "inline") {
+                if (extensions.startInline) {
+                  extensions.startInline.push(ext.start);
+                } else {
+                  extensions.startInline = [ext.start];
+                }
+              }
+            }
+          }
+          if ("childTokens" in ext && ext.childTokens) {
+            extensions.childTokens[ext.name] = ext.childTokens;
+          }
+        });
+        opts.extensions = extensions;
+      }
+      if (pack.renderer) {
+        const renderer = this.defaults.renderer || new _Renderer(this.defaults);
+        for (const prop in pack.renderer) {
+          if (!(prop in renderer)) {
+            throw new Error(`renderer '${prop}' does not exist`);
+          }
+          if (["options", "parser"].includes(prop)) {
+            continue;
+          }
+          const rendererProp = prop;
+          const rendererFunc = pack.renderer[rendererProp];
+          const prevRenderer = renderer[rendererProp];
+          renderer[rendererProp] = (...args2) => {
+            let ret = rendererFunc.apply(renderer, args2);
+            if (ret === false) {
+              ret = prevRenderer.apply(renderer, args2);
+            }
+            return ret || "";
+          };
+        }
+        opts.renderer = renderer;
+      }
+      if (pack.tokenizer) {
+        const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);
+        for (const prop in pack.tokenizer) {
+          if (!(prop in tokenizer)) {
+            throw new Error(`tokenizer '${prop}' does not exist`);
+          }
+          if (["options", "rules", "lexer"].includes(prop)) {
+            continue;
+          }
+          const tokenizerProp = prop;
+          const tokenizerFunc = pack.tokenizer[tokenizerProp];
+          const prevTokenizer = tokenizer[tokenizerProp];
+          tokenizer[tokenizerProp] = (...args2) => {
+            let ret = tokenizerFunc.apply(tokenizer, args2);
+            if (ret === false) {
+              ret = prevTokenizer.apply(tokenizer, args2);
+            }
+            return ret;
+          };
+        }
+        opts.tokenizer = tokenizer;
+      }
+      if (pack.hooks) {
+        const hooks = this.defaults.hooks || new _Hooks();
+        for (const prop in pack.hooks) {
+          if (!(prop in hooks)) {
+            throw new Error(`hook '${prop}' does not exist`);
+          }
+          if (["options", "block"].includes(prop)) {
+            continue;
+          }
+          const hooksProp = prop;
+          const hooksFunc = pack.hooks[hooksProp];
+          const prevHook = hooks[hooksProp];
+          if (_Hooks.passThroughHooks.has(prop)) {
+            hooks[hooksProp] = (arg) => {
+              if (this.defaults.async) {
+                return Promise.resolve(hooksFunc.call(hooks, arg)).then((ret2) => {
+                  return prevHook.call(hooks, ret2);
+                });
+              }
+              const ret = hooksFunc.call(hooks, arg);
+              return prevHook.call(hooks, ret);
+            };
+          } else {
+            hooks[hooksProp] = (...args2) => {
+              let ret = hooksFunc.apply(hooks, args2);
+              if (ret === false) {
+                ret = prevHook.apply(hooks, args2);
+              }
+              return ret;
+            };
+          }
+        }
+        opts.hooks = hooks;
+      }
+      if (pack.walkTokens) {
+        const walkTokens2 = this.defaults.walkTokens;
+        const packWalktokens = pack.walkTokens;
+        opts.walkTokens = function(token) {
+          let values = [];
+          values.push(packWalktokens.call(this, token));
+          if (walkTokens2) {
+            values = values.concat(walkTokens2.call(this, token));
+          }
+          return values;
+        };
+      }
+      this.defaults = __spreadValues(__spreadValues({}, this.defaults), opts);
+    });
+    return this;
+  }
+  setOptions(opt) {
+    this.defaults = __spreadValues(__spreadValues({}, this.defaults), opt);
+    return this;
+  }
+  lexer(src, options2) {
+    return _Lexer.lex(src, options2 ?? this.defaults);
+  }
+  parser(tokens, options2) {
+    return _Parser.parse(tokens, options2 ?? this.defaults);
+  }
+  parseMarkdown(blockType) {
+    const parse2 = (src, options2) => {
+      const origOpt = __spreadValues({}, options2);
+      const opt = __spreadValues(__spreadValues({}, this.defaults), origOpt);
+      const throwError = this.onError(!!opt.silent, !!opt.async);
+      if (this.defaults.async === true && origOpt.async === false) {
+        return throwError(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));
+      }
+      if (typeof src === "undefined" || src === null) {
+        return throwError(new Error("marked(): input parameter is undefined or null"));
+      }
+      if (typeof src !== "string") {
+        return throwError(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(src) + ", string expected"));
+      }
+      if (opt.hooks) {
+        opt.hooks.options = opt;
+        opt.hooks.block = blockType;
+      }
+      const lexer2 = opt.hooks ? opt.hooks.provideLexer() : blockType ? _Lexer.lex : _Lexer.lexInline;
+      const parser2 = opt.hooks ? opt.hooks.provideParser() : blockType ? _Parser.parse : _Parser.parseInline;
+      if (opt.async) {
+        return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src).then((src2) => lexer2(src2, opt)).then((tokens) => opt.hooks ? opt.hooks.processAllTokens(tokens) : tokens).then((tokens) => opt.walkTokens ? Promise.all(this.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens).then((tokens) => parser2(tokens, opt)).then((html2) => opt.hooks ? opt.hooks.postprocess(html2) : html2).catch(throwError);
+      }
+      try {
+        if (opt.hooks) {
+          src = opt.hooks.preprocess(src);
+        }
+        let tokens = lexer2(src, opt);
+        if (opt.hooks) {
+          tokens = opt.hooks.processAllTokens(tokens);
+        }
+        if (opt.walkTokens) {
+          this.walkTokens(tokens, opt.walkTokens);
+        }
+        let html2 = parser2(tokens, opt);
+        if (opt.hooks) {
+          html2 = opt.hooks.postprocess(html2);
+        }
+        return html2;
+      } catch (e) {
+        return throwError(e);
+      }
+    };
+    return parse2;
+  }
+  onError(silent, async) {
+    return (e) => {
+      e.message += "\nPlease report this to https://github.com/markedjs/marked.";
+      if (silent) {
+        const msg = "<p>An error occurred:</p><pre>" + escape2(e.message + "", true) + "</pre>";
+        if (async) {
+          return Promise.resolve(msg);
+        }
+        return msg;
+      }
+      if (async) {
+        return Promise.reject(e);
+      }
+      throw e;
+    };
+  }
+};
+var markedInstance = new Marked();
+function marked(src, opt) {
+  return markedInstance.parse(src, opt);
+}
+marked.options = marked.setOptions = function(options2) {
+  markedInstance.setOptions(options2);
+  marked.defaults = markedInstance.defaults;
+  changeDefaults(marked.defaults);
+  return marked;
+};
+marked.getDefaults = _getDefaults;
+marked.defaults = _defaults;
+marked.use = function(...args) {
+  markedInstance.use(...args);
+  marked.defaults = markedInstance.defaults;
+  changeDefaults(marked.defaults);
+  return marked;
+};
+marked.walkTokens = function(tokens, callback) {
+  return markedInstance.walkTokens(tokens, callback);
+};
+marked.parseInline = markedInstance.parseInline;
+marked.Parser = _Parser;
+marked.parser = _Parser.parse;
+marked.Renderer = _Renderer;
+marked.TextRenderer = _TextRenderer;
+marked.Lexer = _Lexer;
+marked.lexer = _Lexer.lex;
+marked.Tokenizer = _Tokenizer;
+marked.Hooks = _Hooks;
+marked.parse = marked;
+var options = marked.options;
+var setOptions = marked.setOptions;
+var use = marked.use;
+var walkTokens = marked.walkTokens;
+var parseInline = marked.parseInline;
+var parser = _Parser.parse;
+var lexer = _Lexer.lex;
+
+// node_modules/ngx-markdown/fesm2022/ngx-markdown.mjs
+var _c0 = ["*"];
+var BUTTON_TEXT_COPY = "Copy";
+var BUTTON_TEXT_COPIED = "Copied";
+var _ClipboardButtonComponent = class _ClipboardButtonComponent {
+  constructor() {
+    this._buttonClick$ = new Subject();
+    this.copied = toSignal(this._buttonClick$.pipe(switchMap(() => merge(of(true), timer(3e3).pipe(mapTo(false)))), distinctUntilChanged(), shareReplay(1)));
+    this.copiedText = computed(() => this.copied() ? BUTTON_TEXT_COPIED : BUTTON_TEXT_COPY);
+  }
+  onCopyToClipboardClick() {
+    this._buttonClick$.next();
+  }
+};
+_ClipboardButtonComponent.\u0275fac = function ClipboardButtonComponent_Factory(__ngFactoryType__) {
+  return new (__ngFactoryType__ || _ClipboardButtonComponent)();
+};
+_ClipboardButtonComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({
+  type: _ClipboardButtonComponent,
+  selectors: [["markdown-clipboard"]],
+  decls: 2,
+  vars: 3,
+  consts: [[1, "markdown-clipboard-button", 3, "click"]],
+  template: function ClipboardButtonComponent_Template(rf, ctx) {
+    if (rf & 1) {
+      \u0275\u0275domElementStart(0, "button", 0);
+      \u0275\u0275domListener("click", function ClipboardButtonComponent_Template_button_click_0_listener() {
+        return ctx.onCopyToClipboardClick();
+      });
+      \u0275\u0275text(1);
+      \u0275\u0275domElementEnd();
+    }
+    if (rf & 2) {
+      \u0275\u0275classProp("copied", ctx.copied());
+      \u0275\u0275advance();
+      \u0275\u0275textInterpolate(ctx.copiedText());
+    }
+  },
+  encapsulation: 2,
+  changeDetection: 0
+});
+var ClipboardButtonComponent = _ClipboardButtonComponent;
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ClipboardButtonComponent, [{
+    type: Component,
+    args: [{
+      selector: "markdown-clipboard",
+      template: `
+    <button
+      class="markdown-clipboard-button"
+      [class.copied]="copied()"
+      (click)="onCopyToClipboardClick()"
+    >{{ copiedText() }}</button>
+  `,
+      changeDetection: ChangeDetectionStrategy.OnPush
+    }]
+  }], null, null);
+})();
+var CLIPBOARD_OPTIONS = new InjectionToken("CLIPBOARD_OPTIONS");
+var _LanguagePipe = class _LanguagePipe {
+  transform(value, language) {
+    if (value == null) {
+      value = "";
+    }
+    if (language == null) {
+      language = "";
+    }
+    if (typeof value !== "string") {
+      console.error(`LanguagePipe has been invoked with an invalid value type [${typeof value}]`);
+      return value;
+    }
+    if (typeof language !== "string") {
+      console.error(`LanguagePipe has been invoked with an invalid parameter [${typeof language}]`);
+      return value;
+    }
+    return "```" + language + "\n" + value + "\n```";
+  }
+};
+_LanguagePipe.\u0275fac = function LanguagePipe_Factory(__ngFactoryType__) {
+  return new (__ngFactoryType__ || _LanguagePipe)();
+};
+_LanguagePipe.\u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
+  name: "language",
+  type: _LanguagePipe,
+  pure: true
+});
+var LanguagePipe = _LanguagePipe;
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(LanguagePipe, [{
+    type: Pipe,
+    args: [{
+      name: "language"
+    }]
+  }], null, null);
+})();
+var PrismPlugin;
+(function(PrismPlugin2) {
+  PrismPlugin2["CommandLine"] = "command-line";
+  PrismPlugin2["LineHighlight"] = "line-highlight";
+  PrismPlugin2["LineNumbers"] = "line-numbers";
+})(PrismPlugin || (PrismPlugin = {}));
+var MARKED_EXTENSIONS = new InjectionToken("MARKED_EXTENSIONS");
+var MARKED_OPTIONS = new InjectionToken("MARKED_OPTIONS");
+var MERMAID_OPTIONS = new InjectionToken("MERMAID_OPTIONS");
+var errorJoyPixelsNotLoaded = "[ngx-markdown] When using the `emoji` attribute you *have to* include Emoji-Toolkit files to `angular.json` or use imports. See README for more information";
+var errorKatexNotLoaded = "[ngx-markdown] When using the `katex` attribute you *have to* include KaTeX files to `angular.json` or use imports. See README for more information";
+var errorMermaidNotLoaded = "[ngx-markdown] When using the `mermaid` attribute you *have to* include Mermaid files to `angular.json` or use imports. See README for more information";
+var errorClipboardNotLoaded = "[ngx-markdown] When using the `clipboard` attribute you *have to* include Clipboard files to `angular.json` or use imports. See README for more information";
+var errorClipboardViewContainerRequired = "[ngx-markdown] When using the `clipboard` attribute you *have to* provide the `viewContainerRef` parameter to `MarkdownService.render()` function";
+var errorSrcWithoutHttpClient = "[ngx-markdown] When using the `src` attribute you *have to* pass the `HttpClient` as a parameter of the `forRoot` method. See README for more information";
+var SECURITY_CONTEXT = new InjectionToken("SECURITY_CONTEXT");
+var _MarkdownService = class _MarkdownService {
+  get options() {
+    return this._options;
+  }
+  set options(value) {
+    this._options = __spreadValues(__spreadValues({}, this.DEFAULT_MARKED_OPTIONS), value);
+  }
+  get renderer() {
+    return this.options.renderer;
+  }
+  set renderer(value) {
+    this.options.renderer = value;
+  }
+  constructor(clipboardOptions, extensions, options2, mermaidOptions, platform, securityContext, http, sanitizer) {
+    this.clipboardOptions = clipboardOptions;
+    this.extensions = extensions;
+    this.mermaidOptions = mermaidOptions;
+    this.platform = platform;
+    this.securityContext = securityContext;
+    this.http = http;
+    this.sanitizer = sanitizer;
+    this.DEFAULT_MARKED_OPTIONS = {
+      renderer: new _Renderer()
+    };
+    this.DEFAULT_KATEX_OPTIONS = {
+      delimiters: [{
+        left: "$$",
+        right: "$$",
+        display: true
+      }, {
+        left: "$",
+        right: "$",
+        display: false
+      }, {
+        left: "\\(",
+        right: "\\)",
+        display: false
+      }, {
+        left: "\\begin{equation}",
+        right: "\\end{equation}",
+        display: true
+      }, {
+        left: "\\begin{align}",
+        right: "\\end{align}",
+        display: true
+      }, {
+        left: "\\begin{alignat}",
+        right: "\\end{alignat}",
+        display: true
+      }, {
+        left: "\\begin{gather}",
+        right: "\\end{gather}",
+        display: true
+      }, {
+        left: "\\begin{CD}",
+        right: "\\end{CD}",
+        display: true
+      }, {
+        left: "\\[",
+        right: "\\]",
+        display: true
+      }]
+    };
+    this.DEFAULT_MERMAID_OPTIONS = {
+      startOnLoad: false
+    };
+    this.DEFAULT_CLIPBOARD_OPTIONS = {
+      buttonComponent: void 0
+    };
+    this.DEFAULT_PARSE_OPTIONS = {
+      decodeHtml: false,
+      inline: false,
+      emoji: false,
+      mermaid: false,
+      markedOptions: void 0,
+      disableSanitizer: false
+    };
+    this.DEFAULT_RENDER_OPTIONS = {
+      clipboard: false,
+      clipboardOptions: void 0,
+      katex: false,
+      katexOptions: void 0,
+      mermaid: false,
+      mermaidOptions: void 0
+    };
+    this._reload$ = new Subject();
+    this.reload$ = this._reload$.asObservable();
+    this.options = options2;
+  }
+  parse(markdown, parseOptions = this.DEFAULT_PARSE_OPTIONS) {
+    const {
+      decodeHtml,
+      inline: inline2,
+      emoji,
+      mermaid: mermaid2,
+      disableSanitizer
+    } = parseOptions;
+    const markedOptions = __spreadValues(__spreadValues({}, this.options), parseOptions.markedOptions);
+    const renderer = markedOptions.renderer || this.renderer || new _Renderer();
+    if (this.extensions) {
+      this.renderer = this.extendsRendererForExtensions(renderer);
+    }
+    if (mermaid2) {
+      this.renderer = this.extendsRendererForMermaid(renderer);
+    }
+    const trimmed = this.trimIndentation(markdown);
+    const decoded = decodeHtml ? this.decodeHtml(trimmed) : trimmed;
+    const emojified = emoji ? this.parseEmoji(decoded) : decoded;
+    const marked2 = this.parseMarked(emojified, markedOptions, inline2);
+    const sanitized = disableSanitizer ? marked2 : this.sanitizer.sanitize(this.securityContext, marked2);
+    return sanitized || "";
+  }
+  render(element, options2 = this.DEFAULT_RENDER_OPTIONS, viewContainerRef) {
+    const {
+      clipboard,
+      clipboardOptions,
+      katex: katex2,
+      katexOptions,
+      mermaid: mermaid2,
+      mermaidOptions
+    } = options2;
+    if (katex2) {
+      this.renderKatex(element, __spreadValues(__spreadValues({}, this.DEFAULT_KATEX_OPTIONS), katexOptions));
+    }
+    if (mermaid2) {
+      this.renderMermaid(element, __spreadValues(__spreadValues(__spreadValues({}, this.DEFAULT_MERMAID_OPTIONS), this.mermaidOptions), mermaidOptions));
+    }
+    if (clipboard) {
+      this.renderClipboard(element, viewContainerRef, __spreadValues(__spreadValues(__spreadValues({}, this.DEFAULT_CLIPBOARD_OPTIONS), this.clipboardOptions), clipboardOptions));
+    }
+    this.highlight(element);
+  }
+  reload() {
+    this._reload$.next();
+  }
+  getSource(src) {
+    if (!this.http) {
+      throw new Error(errorSrcWithoutHttpClient);
+    }
+    return this.http.get(src, {
+      responseType: "text"
+    }).pipe(map((markdown) => this.handleExtension(src, markdown)));
+  }
+  highlight(element) {
+    if (!isPlatformBrowser(this.platform)) {
+      return;
+    }
+    if (typeof Prism === "undefined" || typeof Prism.highlightAllUnder === "undefined") {
+      return;
+    }
+    if (!element) {
+      element = document;
+    }
+    const noLanguageElements = element.querySelectorAll('pre code:not([class*="language-"])');
+    Array.prototype.forEach.call(noLanguageElements, (x) => x.classList.add("language-none"));
+    Prism.highlightAllUnder(element);
+  }
+  decodeHtml(html2) {
+    if (!isPlatformBrowser(this.platform)) {
+      return html2;
+    }
+    const textarea = document.createElement("textarea");
+    textarea.innerHTML = html2;
+    return textarea.value;
+  }
+  extendsRendererForExtensions(renderer) {
+    const extendedRenderer = renderer;
+    if (extendedRenderer.\u0275NgxMarkdownRendererExtendedForExtensions === true) {
+      return renderer;
+    }
+    if (this.extensions?.length > 0) {
+      marked.use(...this.extensions);
+    }
+    extendedRenderer.\u0275NgxMarkdownRendererExtendedForExtensions = true;
+    return renderer;
+  }
+  extendsRendererForMermaid(renderer) {
+    const extendedRenderer = renderer;
+    if (extendedRenderer.\u0275NgxMarkdownRendererExtendedForMermaid === true) {
+      return renderer;
+    }
+    const defaultCode = renderer.code;
+    renderer.code = (token) => {
+      return token.lang === "mermaid" ? `<div class="mermaid">${token.text}</div>` : defaultCode(token);
+    };
+    extendedRenderer.\u0275NgxMarkdownRendererExtendedForMermaid = true;
+    return renderer;
+  }
+  handleExtension(src, markdown) {
+    const urlProtocolIndex = src.lastIndexOf("://");
+    const urlWithoutProtocol = urlProtocolIndex > -1 ? src.substring(urlProtocolIndex + 4) : src;
+    const lastSlashIndex = urlWithoutProtocol.lastIndexOf("/");
+    const lastUrlSegment = lastSlashIndex > -1 ? urlWithoutProtocol.substring(lastSlashIndex + 1).split("?")[0] : "";
+    const lastDotIndex = lastUrlSegment.lastIndexOf(".");
+    const extension = lastDotIndex > -1 ? lastUrlSegment.substring(lastDotIndex + 1) : "";
+    return !!extension && extension !== "md" ? "```" + extension + "\n" + markdown + "\n```" : markdown;
+  }
+  parseMarked(html2, markedOptions, inline2 = false) {
+    if (markedOptions.renderer) {
+      const renderer = __spreadValues({}, markedOptions.renderer);
+      delete renderer.\u0275NgxMarkdownRendererExtendedForExtensions;
+      delete renderer.\u0275NgxMarkdownRendererExtendedForMermaid;
+      delete markedOptions.renderer;
+      marked.use({
+        renderer
+      });
+    }
+    return inline2 ? marked.parseInline(html2, markedOptions) : marked.parse(html2, markedOptions);
+  }
+  parseEmoji(html2) {
+    if (!isPlatformBrowser(this.platform)) {
+      return html2;
+    }
+    if (typeof joypixels === "undefined" || typeof joypixels.shortnameToUnicode === "undefined") {
+      throw new Error(errorJoyPixelsNotLoaded);
+    }
+    return joypixels.shortnameToUnicode(html2);
+  }
+  renderKatex(element, options2) {
+    if (!isPlatformBrowser(this.platform)) {
+      return;
+    }
+    if (typeof katex === "undefined" || typeof renderMathInElement === "undefined") {
+      throw new Error(errorKatexNotLoaded);
+    }
+    renderMathInElement(element, options2);
+  }
+  renderClipboard(element, viewContainerRef, options2) {
+    if (!isPlatformBrowser(this.platform)) {
+      return;
+    }
+    if (typeof ClipboardJS === "undefined") {
+      throw new Error(errorClipboardNotLoaded);
+    }
+    if (!viewContainerRef) {
+      throw new Error(errorClipboardViewContainerRequired);
+    }
+    const {
+      buttonComponent,
+      buttonTemplate
+    } = options2;
+    const preElements = element.querySelectorAll("pre");
+    for (let i = 0; i < preElements.length; i++) {
+      const preElement = preElements.item(i);
+      const preWrapperElement = document.createElement("div");
+      preWrapperElement.style.position = "relative";
+      preElement.parentNode.insertBefore(preWrapperElement, preElement);
+      preWrapperElement.appendChild(preElement);
+      const toolbarWrapperElement = document.createElement("div");
+      toolbarWrapperElement.classList.add("markdown-clipboard-toolbar");
+      toolbarWrapperElement.style.position = "absolute";
+      toolbarWrapperElement.style.top = ".5em";
+      toolbarWrapperElement.style.right = ".5em";
+      toolbarWrapperElement.style.zIndex = "1";
+      preWrapperElement.insertAdjacentElement("beforeend", toolbarWrapperElement);
+      preWrapperElement.onmouseenter = () => toolbarWrapperElement.classList.add("hover");
+      preWrapperElement.onmouseleave = () => toolbarWrapperElement.classList.remove("hover");
+      let embeddedViewRef;
+      if (buttonComponent) {
+        const componentRef = viewContainerRef.createComponent(buttonComponent);
+        embeddedViewRef = componentRef.hostView;
+        componentRef.changeDetectorRef.markForCheck();
+      } else if (buttonTemplate) {
+        embeddedViewRef = viewContainerRef.createEmbeddedView(buttonTemplate);
+      } else {
+        const componentRef = viewContainerRef.createComponent(ClipboardButtonComponent);
+        embeddedViewRef = componentRef.hostView;
+        componentRef.changeDetectorRef.markForCheck();
+      }
+      let clipboardInstance;
+      embeddedViewRef.rootNodes.forEach((node) => {
+        toolbarWrapperElement.appendChild(node);
+        clipboardInstance = new ClipboardJS(node, {
+          text: () => preElement.innerText
+        });
+      });
+      embeddedViewRef.onDestroy(() => clipboardInstance.destroy());
+    }
+  }
+  renderMermaid(element, options2 = this.DEFAULT_MERMAID_OPTIONS) {
+    if (!isPlatformBrowser(this.platform)) {
+      return;
+    }
+    if (typeof mermaid === "undefined" || typeof mermaid.initialize === "undefined") {
+      throw new Error(errorMermaidNotLoaded);
+    }
+    const mermaidElements = element.querySelectorAll(".mermaid");
+    if (mermaidElements.length === 0) {
+      return;
+    }
+    mermaid.initialize(options2);
+    mermaid.run({
+      nodes: mermaidElements
+    });
+  }
+  trimIndentation(markdown) {
+    if (!markdown) {
+      return "";
+    }
+    let indentStart;
+    return markdown.split("\n").map((line) => {
+      let lineIdentStart = indentStart;
+      if (line.length > 0) {
+        lineIdentStart = isNaN(lineIdentStart) ? line.search(/\S|$/) : Math.min(line.search(/\S|$/), lineIdentStart);
+      }
+      if (isNaN(indentStart)) {
+        indentStart = lineIdentStart;
+      }
+      return lineIdentStart ? line.substring(lineIdentStart) : line;
+    }).join("\n");
+  }
+};
+_MarkdownService.\u0275fac = function MarkdownService_Factory(__ngFactoryType__) {
+  return new (__ngFactoryType__ || _MarkdownService)(\u0275\u0275inject(CLIPBOARD_OPTIONS, 8), \u0275\u0275inject(MARKED_EXTENSIONS, 8), \u0275\u0275inject(MARKED_OPTIONS, 8), \u0275\u0275inject(MERMAID_OPTIONS, 8), \u0275\u0275inject(PLATFORM_ID), \u0275\u0275inject(SECURITY_CONTEXT), \u0275\u0275inject(HttpClient, 8), \u0275\u0275inject(DomSanitizer));
+};
+_MarkdownService.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+  token: _MarkdownService,
+  factory: _MarkdownService.\u0275fac
+});
+var MarkdownService = _MarkdownService;
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MarkdownService, [{
+    type: Injectable
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [CLIPBOARD_OPTIONS]
+    }, {
+      type: Optional
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [MARKED_EXTENSIONS]
+    }, {
+      type: Optional
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [MARKED_OPTIONS]
+    }, {
+      type: Optional
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [MERMAID_OPTIONS]
+    }, {
+      type: Optional
+    }]
+  }, {
+    type: Object,
+    decorators: [{
+      type: Inject,
+      args: [PLATFORM_ID]
+    }]
+  }, {
+    type: SecurityContext,
+    decorators: [{
+      type: Inject,
+      args: [SECURITY_CONTEXT]
+    }]
+  }, {
+    type: HttpClient,
+    decorators: [{
+      type: Optional
+    }]
+  }, {
+    type: DomSanitizer
+  }], null);
+})();
+var _MarkdownComponent = class _MarkdownComponent {
+  get disableSanitizer() {
+    return this._disableSanitizer;
+  }
+  set disableSanitizer(value) {
+    this._disableSanitizer = this.coerceBooleanProperty(value);
+  }
+  get inline() {
+    return this._inline;
+  }
+  set inline(value) {
+    this._inline = this.coerceBooleanProperty(value);
+  }
+  // Plugin - clipboard
+  get clipboard() {
+    return this._clipboard;
+  }
+  set clipboard(value) {
+    this._clipboard = this.coerceBooleanProperty(value);
+  }
+  // Plugin - emoji
+  get emoji() {
+    return this._emoji;
+  }
+  set emoji(value) {
+    this._emoji = this.coerceBooleanProperty(value);
+  }
+  // Plugin - katex
+  get katex() {
+    return this._katex;
+  }
+  set katex(value) {
+    this._katex = this.coerceBooleanProperty(value);
+  }
+  // Plugin - mermaid
+  get mermaid() {
+    return this._mermaid;
+  }
+  set mermaid(value) {
+    this._mermaid = this.coerceBooleanProperty(value);
+  }
+  // Plugin - lineHighlight
+  get lineHighlight() {
+    return this._lineHighlight;
+  }
+  set lineHighlight(value) {
+    this._lineHighlight = this.coerceBooleanProperty(value);
+  }
+  // Plugin - lineNumbers
+  get lineNumbers() {
+    return this._lineNumbers;
+  }
+  set lineNumbers(value) {
+    this._lineNumbers = this.coerceBooleanProperty(value);
+  }
+  // Plugin - commandLine
+  get commandLine() {
+    return this._commandLine;
+  }
+  set commandLine(value) {
+    this._commandLine = this.coerceBooleanProperty(value);
+  }
+  constructor(element, markdownService, viewContainerRef) {
+    this.element = element;
+    this.markdownService = markdownService;
+    this.viewContainerRef = viewContainerRef;
+    this.error = new EventEmitter();
+    this.load = new EventEmitter();
+    this.ready = new EventEmitter();
+    this._clipboard = false;
+    this._commandLine = false;
+    this._disableSanitizer = false;
+    this._emoji = false;
+    this._inline = false;
+    this._katex = false;
+    this._lineHighlight = false;
+    this._lineNumbers = false;
+    this._mermaid = false;
+    this.destroyed$ = new Subject();
+  }
+  ngOnChanges() {
+    this.loadContent();
+  }
+  loadContent() {
+    if (this.data != null) {
+      this.handleData();
+      return;
+    }
+    if (this.src != null) {
+      this.handleSrc();
+      return;
+    }
+  }
+  ngAfterViewInit() {
+    if (!this.data && !this.src) {
+      this.handleTransclusion();
+    }
+    this.markdownService.reload$.pipe(takeUntil(this.destroyed$)).subscribe(() => this.loadContent());
+  }
+  ngOnDestroy() {
+    this.destroyed$.next();
+    this.destroyed$.complete();
+  }
+  render(markdown, decodeHtml = false) {
+    return __async(this, null, function* () {
+      const parsedOptions = {
+        decodeHtml,
+        inline: this.inline,
+        emoji: this.emoji,
+        mermaid: this.mermaid,
+        disableSanitizer: this.disableSanitizer
+      };
+      const renderOptions = {
+        clipboard: this.clipboard,
+        clipboardOptions: this.getClipboardOptions(),
+        katex: this.katex,
+        katexOptions: this.katexOptions,
+        mermaid: this.mermaid,
+        mermaidOptions: this.mermaidOptions
+      };
+      const parsed = yield this.markdownService.parse(markdown, parsedOptions);
+      this.element.nativeElement.innerHTML = parsed;
+      this.handlePlugins();
+      this.markdownService.render(this.element.nativeElement, renderOptions, this.viewContainerRef);
+      this.ready.emit();
+    });
+  }
+  coerceBooleanProperty(value) {
+    return value != null && `${String(value)}` !== "false";
+  }
+  getClipboardOptions() {
+    if (this.clipboardButtonComponent || this.clipboardButtonTemplate) {
+      return {
+        buttonComponent: this.clipboardButtonComponent,
+        buttonTemplate: this.clipboardButtonTemplate
+      };
+    }
+    return void 0;
+  }
+  handleData() {
+    this.render(this.data);
+  }
+  handleSrc() {
+    this.markdownService.getSource(this.src).subscribe({
+      next: (markdown) => {
+        this.render(markdown).then(() => {
+          this.load.emit(markdown);
+        });
+      },
+      error: (error) => this.error.emit(error)
+    });
+  }
+  handleTransclusion() {
+    this.render(this.element.nativeElement.innerHTML, true);
+  }
+  handlePlugins() {
+    if (this.commandLine) {
+      this.setPluginClass(this.element.nativeElement, PrismPlugin.CommandLine);
+      this.setPluginOptions(this.element.nativeElement, {
+        dataFilterOutput: this.filterOutput,
+        dataHost: this.host,
+        dataPrompt: this.prompt,
+        dataOutput: this.output,
+        dataUser: this.user
+      });
+    }
+    if (this.lineHighlight) {
+      this.setPluginOptions(this.element.nativeElement, {
+        dataLine: this.line,
+        dataLineOffset: this.lineOffset
+      });
+    }
+    if (this.lineNumbers) {
+      this.setPluginClass(this.element.nativeElement, PrismPlugin.LineNumbers);
+      this.setPluginOptions(this.element.nativeElement, {
+        dataStart: this.start
+      });
+    }
+  }
+  setPluginClass(element, plugin) {
+    const preElements = element.querySelectorAll("pre");
+    for (let i = 0; i < preElements.length; i++) {
+      const classes = plugin instanceof Array ? plugin : [plugin];
+      preElements.item(i).classList.add(...classes);
+    }
+  }
+  setPluginOptions(element, options2) {
+    const preElements = element.querySelectorAll("pre");
+    for (let i = 0; i < preElements.length; i++) {
+      Object.keys(options2).forEach((option) => {
+        const attributeValue = options2[option];
+        if (attributeValue) {
+          const attributeName = this.toLispCase(option);
+          preElements.item(i).setAttribute(attributeName, attributeValue.toString());
+        }
+      });
+    }
+  }
+  toLispCase(value) {
+    const upperChars = value.match(/([A-Z])/g);
+    if (!upperChars) {
+      return value;
+    }
+    let str = value.toString();
+    for (let i = 0, n = upperChars.length; i < n; i++) {
+      str = str.replace(new RegExp(upperChars[i]), "-" + upperChars[i].toLowerCase());
+    }
+    if (str.slice(0, 1) === "-") {
+      str = str.slice(1);
+    }
+    return str;
+  }
+};
+_MarkdownComponent.\u0275fac = function MarkdownComponent_Factory(__ngFactoryType__) {
+  return new (__ngFactoryType__ || _MarkdownComponent)(\u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(MarkdownService), \u0275\u0275directiveInject(ViewContainerRef));
+};
+_MarkdownComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({
+  type: _MarkdownComponent,
+  selectors: [["markdown"], ["", "markdown", ""]],
+  inputs: {
+    data: "data",
+    src: "src",
+    disableSanitizer: "disableSanitizer",
+    inline: "inline",
+    clipboard: "clipboard",
+    clipboardButtonComponent: "clipboardButtonComponent",
+    clipboardButtonTemplate: "clipboardButtonTemplate",
+    emoji: "emoji",
+    katex: "katex",
+    katexOptions: "katexOptions",
+    mermaid: "mermaid",
+    mermaidOptions: "mermaidOptions",
+    lineHighlight: "lineHighlight",
+    line: "line",
+    lineOffset: "lineOffset",
+    lineNumbers: "lineNumbers",
+    start: "start",
+    commandLine: "commandLine",
+    filterOutput: "filterOutput",
+    host: "host",
+    prompt: "prompt",
+    output: "output",
+    user: "user"
+  },
+  outputs: {
+    error: "error",
+    load: "load",
+    ready: "ready"
+  },
+  features: [\u0275\u0275NgOnChangesFeature],
+  ngContentSelectors: _c0,
+  decls: 1,
+  vars: 0,
+  template: function MarkdownComponent_Template(rf, ctx) {
+    if (rf & 1) {
+      \u0275\u0275projectionDef();
+      \u0275\u0275projection(0);
+    }
+  },
+  encapsulation: 2
+});
+var MarkdownComponent = _MarkdownComponent;
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MarkdownComponent, [{
+    type: Component,
+    args: [{
+      // eslint-disable-next-line @angular-eslint/component-selector
+      selector: "markdown, [markdown]",
+      template: "<ng-content></ng-content>"
+    }]
+  }], () => [{
+    type: ElementRef
+  }, {
+    type: MarkdownService
+  }, {
+    type: ViewContainerRef
+  }], {
+    data: [{
+      type: Input
+    }],
+    src: [{
+      type: Input
+    }],
+    disableSanitizer: [{
+      type: Input
+    }],
+    inline: [{
+      type: Input
+    }],
+    clipboard: [{
+      type: Input
+    }],
+    clipboardButtonComponent: [{
+      type: Input
+    }],
+    clipboardButtonTemplate: [{
+      type: Input
+    }],
+    emoji: [{
+      type: Input
+    }],
+    katex: [{
+      type: Input
+    }],
+    katexOptions: [{
+      type: Input
+    }],
+    mermaid: [{
+      type: Input
+    }],
+    mermaidOptions: [{
+      type: Input
+    }],
+    lineHighlight: [{
+      type: Input
+    }],
+    line: [{
+      type: Input
+    }],
+    lineOffset: [{
+      type: Input
+    }],
+    lineNumbers: [{
+      type: Input
+    }],
+    start: [{
+      type: Input
+    }],
+    commandLine: [{
+      type: Input
+    }],
+    filterOutput: [{
+      type: Input
+    }],
+    host: [{
+      type: Input
+    }],
+    prompt: [{
+      type: Input
+    }],
+    output: [{
+      type: Input
+    }],
+    user: [{
+      type: Input
+    }],
+    error: [{
+      type: Output
+    }],
+    load: [{
+      type: Output
+    }],
+    ready: [{
+      type: Output
+    }]
+  });
+})();
+var _MarkdownPipe = class _MarkdownPipe {
+  constructor(domSanitizer, elementRef, markdownService, viewContainerRef, zone) {
+    this.domSanitizer = domSanitizer;
+    this.elementRef = elementRef;
+    this.markdownService = markdownService;
+    this.viewContainerRef = viewContainerRef;
+    this.zone = zone;
+  }
+  transform(value, options2) {
+    return __async(this, null, function* () {
+      if (value == null) {
+        return "";
+      }
+      if (typeof value !== "string") {
+        console.error(`MarkdownPipe has been invoked with an invalid value type [${typeof value}]`);
+        return value;
+      }
+      const markdown = yield this.markdownService.parse(value, options2);
+      this.zone.onStable.pipe(first()).subscribe(() => this.markdownService.render(this.elementRef.nativeElement, options2, this.viewContainerRef));
+      return this.domSanitizer.bypassSecurityTrustHtml(markdown);
+    });
+  }
+};
+_MarkdownPipe.\u0275fac = function MarkdownPipe_Factory(__ngFactoryType__) {
+  return new (__ngFactoryType__ || _MarkdownPipe)(\u0275\u0275directiveInject(DomSanitizer, 16), \u0275\u0275directiveInject(ElementRef, 16), \u0275\u0275directiveInject(MarkdownService, 16), \u0275\u0275directiveInject(ViewContainerRef, 16), \u0275\u0275directiveInject(NgZone, 16));
+};
+_MarkdownPipe.\u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
+  name: "markdown",
+  type: _MarkdownPipe,
+  pure: true
+});
+var MarkdownPipe = _MarkdownPipe;
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MarkdownPipe, [{
+    type: Pipe,
+    args: [{
+      name: "markdown"
+    }]
+  }], () => [{
+    type: DomSanitizer
+  }, {
+    type: ElementRef
+  }, {
+    type: MarkdownService
+  }, {
+    type: ViewContainerRef
+  }, {
+    type: NgZone
+  }], null);
+})();
+function provideMarkdown(markdownModuleConfig) {
+  return [MarkdownService, markdownModuleConfig?.loader ?? [], markdownModuleConfig?.clipboardOptions ?? [], markdownModuleConfig?.markedOptions ?? [], markdownModuleConfig?.mermaidOptions ?? [], markdownModuleConfig?.markedExtensions ?? [], {
+    provide: SECURITY_CONTEXT,
+    useValue: markdownModuleConfig?.sanitize ?? SecurityContext.HTML
+  }];
+}
+var sharedDeclarations = [ClipboardButtonComponent, LanguagePipe, MarkdownComponent, MarkdownPipe];
+var _MarkdownModule = class _MarkdownModule {
+  static forRoot(markdownModuleConfig) {
+    return {
+      ngModule: _MarkdownModule,
+      providers: [provideMarkdown(markdownModuleConfig)]
+    };
+  }
+  static forChild() {
+    return {
+      ngModule: _MarkdownModule
+    };
+  }
+};
+_MarkdownModule.\u0275fac = function MarkdownModule_Factory(__ngFactoryType__) {
+  return new (__ngFactoryType__ || _MarkdownModule)();
+};
+_MarkdownModule.\u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
+  type: _MarkdownModule,
+  imports: [ClipboardButtonComponent, LanguagePipe, MarkdownComponent, MarkdownPipe],
+  exports: [ClipboardButtonComponent, LanguagePipe, MarkdownComponent, MarkdownPipe]
+});
+_MarkdownModule.\u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({});
+var MarkdownModule = _MarkdownModule;
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MarkdownModule, [{
+    type: NgModule,
+    args: [{
+      imports: sharedDeclarations,
+      exports: sharedDeclarations
+    }]
+  }], null, null);
+})();
+
+// node_modules/@angular/material/fesm2022/menu.mjs
+var _c02 = ["mat-menu-item", ""];
+var _c1 = [[["mat-icon"], ["", "matMenuItemIcon", ""]], "*"];
+var _c2 = ["mat-icon, [matMenuItemIcon]", "*"];
+function MatMenuItem_Conditional_4_Template(rf, ctx) {
+  if (rf & 1) {
+    \u0275\u0275namespaceSVG();
+    \u0275\u0275elementStart(0, "svg", 2);
+    \u0275\u0275element(1, "polygon", 3);
+    \u0275\u0275elementEnd();
+  }
+}
+var _c3 = ["*"];
+function MatMenu_ng_template_0_Template(rf, ctx) {
+  if (rf & 1) {
+    const _r1 = \u0275\u0275getCurrentView();
+    \u0275\u0275domElementStart(0, "div", 0);
+    \u0275\u0275domListener("click", function MatMenu_ng_template_0_Template_div_click_0_listener() {
+      \u0275\u0275restoreView(_r1);
+      const ctx_r1 = \u0275\u0275nextContext();
+      return \u0275\u0275resetView(ctx_r1.closed.emit("click"));
+    })("animationstart", function MatMenu_ng_template_0_Template_div_animationstart_0_listener($event) {
+      \u0275\u0275restoreView(_r1);
+      const ctx_r1 = \u0275\u0275nextContext();
+      return \u0275\u0275resetView(ctx_r1._onAnimationStart($event.animationName));
+    })("animationend", function MatMenu_ng_template_0_Template_div_animationend_0_listener($event) {
+      \u0275\u0275restoreView(_r1);
+      const ctx_r1 = \u0275\u0275nextContext();
+      return \u0275\u0275resetView(ctx_r1._onAnimationDone($event.animationName));
+    })("animationcancel", function MatMenu_ng_template_0_Template_div_animationcancel_0_listener($event) {
+      \u0275\u0275restoreView(_r1);
+      const ctx_r1 = \u0275\u0275nextContext();
+      return \u0275\u0275resetView(ctx_r1._onAnimationDone($event.animationName));
+    });
+    \u0275\u0275domElementStart(1, "div", 1);
+    \u0275\u0275projection(2);
+    \u0275\u0275domElementEnd()();
+  }
+  if (rf & 2) {
+    const ctx_r1 = \u0275\u0275nextContext();
+    \u0275\u0275classMap(ctx_r1._classList);
+    \u0275\u0275classProp("mat-menu-panel-animations-disabled", ctx_r1._animationsDisabled)("mat-menu-panel-exit-animation", ctx_r1._panelAnimationState === "void")("mat-menu-panel-animating", ctx_r1._isAnimating);
+    \u0275\u0275domProperty("id", ctx_r1.panelId);
+    \u0275\u0275attribute("aria-label", ctx_r1.ariaLabel || null)("aria-labelledby", ctx_r1.ariaLabelledby || null)("aria-describedby", ctx_r1.ariaDescribedby || null);
+  }
+}
+var MAT_MENU_PANEL = new InjectionToken("MAT_MENU_PANEL");
+var MatMenuItem = class _MatMenuItem {
+  _elementRef = inject(ElementRef);
+  _document = inject(DOCUMENT);
+  _focusMonitor = inject(FocusMonitor);
+  _parentMenu = inject(MAT_MENU_PANEL, {
+    optional: true
+  });
+  _changeDetectorRef = inject(ChangeDetectorRef);
+  /** ARIA role for the menu item. */
+  role = "menuitem";
+  /** Whether the menu item is disabled. */
+  disabled = false;
+  /** Whether ripples are disabled on the menu item. */
+  disableRipple = false;
+  /** Stream that emits when the menu item is hovered. */
+  _hovered = new Subject();
+  /** Stream that emits when the menu item is focused. */
+  _focused = new Subject();
+  /** Whether the menu item is highlighted. */
+  _highlighted = false;
+  /** Whether the menu item acts as a trigger for a sub-menu. */
+  _triggersSubmenu = false;
+  constructor() {
+    inject(_CdkPrivateStyleLoader).load(_StructuralStylesLoader);
+    this._parentMenu?.addItem?.(this);
+  }
+  /** Focuses the menu item. */
+  focus(origin, options2) {
+    if (this._focusMonitor && origin) {
+      this._focusMonitor.focusVia(this._getHostElement(), origin, options2);
+    } else {
+      this._getHostElement().focus(options2);
+    }
+    this._focused.next(this);
+  }
+  ngAfterViewInit() {
+    if (this._focusMonitor) {
+      this._focusMonitor.monitor(this._elementRef, false);
+    }
+  }
+  ngOnDestroy() {
+    if (this._focusMonitor) {
+      this._focusMonitor.stopMonitoring(this._elementRef);
+    }
+    if (this._parentMenu && this._parentMenu.removeItem) {
+      this._parentMenu.removeItem(this);
+    }
+    this._hovered.complete();
+    this._focused.complete();
+  }
+  /** Used to set the `tabindex`. */
+  _getTabIndex() {
+    return this.disabled ? "-1" : "0";
+  }
+  /** Returns the host DOM element. */
+  _getHostElement() {
+    return this._elementRef.nativeElement;
+  }
+  /** Prevents the default element actions if it is disabled. */
+  _checkDisabled(event) {
+    if (this.disabled) {
+      event.preventDefault();
+      event.stopPropagation();
+    }
+  }
+  /** Emits to the hover stream. */
+  _handleMouseEnter() {
+    this._hovered.next(this);
+  }
+  /** Gets the label to be used when determining whether the option should be focused. */
+  getLabel() {
+    const clone = this._elementRef.nativeElement.cloneNode(true);
+    const icons = clone.querySelectorAll("mat-icon, .material-icons");
+    for (let i = 0; i < icons.length; i++) {
+      icons[i].remove();
+    }
+    return clone.textContent?.trim() || "";
+  }
+  _setHighlighted(isHighlighted) {
+    this._highlighted = isHighlighted;
+    this._changeDetectorRef.markForCheck();
+  }
+  _setTriggersSubmenu(triggersSubmenu) {
+    this._triggersSubmenu = triggersSubmenu;
+    this._changeDetectorRef.markForCheck();
+  }
+  _hasFocus() {
+    return this._document && this._document.activeElement === this._getHostElement();
+  }
+  static \u0275fac = function MatMenuItem_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _MatMenuItem)();
+  };
+  static \u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({
+    type: _MatMenuItem,
+    selectors: [["", "mat-menu-item", ""]],
+    hostAttrs: [1, "mat-mdc-menu-item", "mat-focus-indicator"],
+    hostVars: 8,
+    hostBindings: function MatMenuItem_HostBindings(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275listener("click", function MatMenuItem_click_HostBindingHandler($event) {
+          return ctx._checkDisabled($event);
+        })("mouseenter", function MatMenuItem_mouseenter_HostBindingHandler() {
+          return ctx._handleMouseEnter();
+        });
+      }
+      if (rf & 2) {
+        \u0275\u0275attribute("role", ctx.role)("tabindex", ctx._getTabIndex())("aria-disabled", ctx.disabled)("disabled", ctx.disabled || null);
+        \u0275\u0275classProp("mat-mdc-menu-item-highlighted", ctx._highlighted)("mat-mdc-menu-item-submenu-trigger", ctx._triggersSubmenu);
+      }
+    },
+    inputs: {
+      role: "role",
+      disabled: [2, "disabled", "disabled", booleanAttribute],
+      disableRipple: [2, "disableRipple", "disableRipple", booleanAttribute]
+    },
+    exportAs: ["matMenuItem"],
+    attrs: _c02,
+    ngContentSelectors: _c2,
+    decls: 5,
+    vars: 3,
+    consts: [[1, "mat-mdc-menu-item-text"], ["matRipple", "", 1, "mat-mdc-menu-ripple", 3, "matRippleDisabled", "matRippleTrigger"], ["viewBox", "0 0 5 10", "focusable", "false", "aria-hidden", "true", 1, "mat-mdc-menu-submenu-icon"], ["points", "0,0 5,5 0,10"]],
+    template: function MatMenuItem_Template(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275projectionDef(_c1);
+        \u0275\u0275projection(0);
+        \u0275\u0275elementStart(1, "span", 0);
+        \u0275\u0275projection(2, 1);
+        \u0275\u0275elementEnd();
+        \u0275\u0275element(3, "div", 1);
+        \u0275\u0275conditionalCreate(4, MatMenuItem_Conditional_4_Template, 2, 0, ":svg:svg", 2);
+      }
+      if (rf & 2) {
+        \u0275\u0275advance(3);
+        \u0275\u0275property("matRippleDisabled", ctx.disableRipple || ctx.disabled)("matRippleTrigger", ctx._getHostElement());
+        \u0275\u0275advance();
+        \u0275\u0275conditional(ctx._triggersSubmenu ? 4 : -1);
+      }
+    },
+    dependencies: [MatRipple],
+    encapsulation: 2,
+    changeDetection: 0
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MatMenuItem, [{
+    type: Component,
+    args: [{
+      selector: "[mat-menu-item]",
+      exportAs: "matMenuItem",
+      host: {
+        "[attr.role]": "role",
+        "class": "mat-mdc-menu-item mat-focus-indicator",
+        "[class.mat-mdc-menu-item-highlighted]": "_highlighted",
+        "[class.mat-mdc-menu-item-submenu-trigger]": "_triggersSubmenu",
+        "[attr.tabindex]": "_getTabIndex()",
+        "[attr.aria-disabled]": "disabled",
+        "[attr.disabled]": "disabled || null",
+        "(click)": "_checkDisabled($event)",
+        "(mouseenter)": "_handleMouseEnter()"
+      },
+      changeDetection: ChangeDetectionStrategy.OnPush,
+      encapsulation: ViewEncapsulation.None,
+      imports: [MatRipple],
+      template: '<ng-content select="mat-icon, [matMenuItemIcon]"></ng-content>\n<span class="mat-mdc-menu-item-text"><ng-content></ng-content></span>\n<div class="mat-mdc-menu-ripple" matRipple\n     [matRippleDisabled]="disableRipple || disabled"\n     [matRippleTrigger]="_getHostElement()">\n</div>\n\n@if (_triggersSubmenu) {\n     <svg\n       class="mat-mdc-menu-submenu-icon"\n       viewBox="0 0 5 10"\n       focusable="false"\n       aria-hidden="true"><polygon points="0,0 5,5 0,10"/></svg>\n}\n'
+    }]
+  }], () => [], {
+    role: [{
+      type: Input
+    }],
+    disabled: [{
+      type: Input,
+      args: [{
+        transform: booleanAttribute
+      }]
+    }],
+    disableRipple: [{
+      type: Input,
+      args: [{
+        transform: booleanAttribute
+      }]
+    }]
+  });
+})();
+function throwMatMenuInvalidPositionX() {
+  throw Error(`xPosition value must be either 'before' or after'.
+      Example: <mat-menu xPosition="before" #menu="matMenu"></mat-menu>`);
+}
+function throwMatMenuInvalidPositionY() {
+  throw Error(`yPosition value must be either 'above' or below'.
+      Example: <mat-menu yPosition="above" #menu="matMenu"></mat-menu>`);
+}
+function throwMatMenuRecursiveError() {
+  throw Error(`matMenuTriggerFor: menu cannot contain its own trigger. Assign a menu that is not a parent of the trigger or move the trigger outside of the menu.`);
+}
+var MAT_MENU_CONTENT = new InjectionToken("MatMenuContent");
+var MatMenuContent = class _MatMenuContent {
+  _template = inject(TemplateRef);
+  _appRef = inject(ApplicationRef);
+  _injector = inject(Injector);
+  _viewContainerRef = inject(ViewContainerRef);
+  _document = inject(DOCUMENT);
+  _changeDetectorRef = inject(ChangeDetectorRef);
+  _portal;
+  _outlet;
+  /** Emits when the menu content has been attached. */
+  _attached = new Subject();
+  constructor() {
+  }
+  /**
+   * Attaches the content with a particular context.
+   * @docs-private
+   */
+  attach(context = {}) {
+    if (!this._portal) {
+      this._portal = new TemplatePortal(this._template, this._viewContainerRef);
+    }
+    this.detach();
+    if (!this._outlet) {
+      this._outlet = new DomPortalOutlet(this._document.createElement("div"), this._appRef, this._injector);
+    }
+    const element = this._template.elementRef.nativeElement;
+    element.parentNode.insertBefore(this._outlet.outletElement, element);
+    this._changeDetectorRef.markForCheck();
+    this._portal.attach(this._outlet, context);
+    this._attached.next();
+  }
+  /**
+   * Detaches the content.
+   * @docs-private
+   */
+  detach() {
+    if (this._portal?.isAttached) {
+      this._portal.detach();
+    }
+  }
+  ngOnDestroy() {
+    this.detach();
+    this._outlet?.dispose();
+  }
+  static \u0275fac = function MatMenuContent_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _MatMenuContent)();
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _MatMenuContent,
+    selectors: [["ng-template", "matMenuContent", ""]],
+    features: [\u0275\u0275ProvidersFeature([{
+      provide: MAT_MENU_CONTENT,
+      useExisting: _MatMenuContent
+    }])]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MatMenuContent, [{
+    type: Directive,
+    args: [{
+      selector: "ng-template[matMenuContent]",
+      providers: [{
+        provide: MAT_MENU_CONTENT,
+        useExisting: MatMenuContent
+      }]
+    }]
+  }], () => [], null);
+})();
+var MAT_MENU_DEFAULT_OPTIONS = new InjectionToken("mat-menu-default-options", {
+  providedIn: "root",
+  factory: MAT_MENU_DEFAULT_OPTIONS_FACTORY
+});
+function MAT_MENU_DEFAULT_OPTIONS_FACTORY() {
+  return {
+    overlapTrigger: false,
+    xPosition: "after",
+    yPosition: "below",
+    backdropClass: "cdk-overlay-transparent-backdrop"
+  };
+}
+var ENTER_ANIMATION = "_mat-menu-enter";
+var EXIT_ANIMATION = "_mat-menu-exit";
+var MatMenu = class _MatMenu {
+  _elementRef = inject(ElementRef);
+  _changeDetectorRef = inject(ChangeDetectorRef);
+  _injector = inject(Injector);
+  _keyManager;
+  _xPosition;
+  _yPosition;
+  _firstItemFocusRef;
+  _exitFallbackTimeout;
+  /** Whether animations are currently disabled. */
+  _animationsDisabled = _animationsDisabled();
+  /** All items inside the menu. Includes items nested inside another menu. */
+  _allItems;
+  /** Only the direct descendant menu items. */
+  _directDescendantItems = new QueryList();
+  /** Classes to be applied to the menu panel. */
+  _classList = {};
+  /** Current state of the panel animation. */
+  _panelAnimationState = "void";
+  /** Emits whenever an animation on the menu completes. */
+  _animationDone = new Subject();
+  /** Whether the menu is animating. */
+  _isAnimating = false;
+  /** Parent menu of the current menu panel. */
+  parentMenu;
+  /** Layout direction of the menu. */
+  direction;
+  /** Class or list of classes to be added to the overlay panel. */
+  overlayPanelClass;
+  /** Class to be added to the backdrop element. */
+  backdropClass;
+  /** aria-label for the menu panel. */
+  ariaLabel;
+  /** aria-labelledby for the menu panel. */
+  ariaLabelledby;
+  /** aria-describedby for the menu panel. */
+  ariaDescribedby;
+  /** Position of the menu in the X axis. */
+  get xPosition() {
+    return this._xPosition;
+  }
+  set xPosition(value) {
+    if (value !== "before" && value !== "after" && (typeof ngDevMode === "undefined" || ngDevMode)) {
+      throwMatMenuInvalidPositionX();
+    }
+    this._xPosition = value;
+    this.setPositionClasses();
+  }
+  /** Position of the menu in the Y axis. */
+  get yPosition() {
+    return this._yPosition;
+  }
+  set yPosition(value) {
+    if (value !== "above" && value !== "below" && (typeof ngDevMode === "undefined" || ngDevMode)) {
+      throwMatMenuInvalidPositionY();
+    }
+    this._yPosition = value;
+    this.setPositionClasses();
+  }
+  /** @docs-private */
+  templateRef;
+  /**
+   * List of the items inside of a menu.
+   * @deprecated
+   * @breaking-change 8.0.0
+   */
+  items;
+  /**
+   * Menu content that will be rendered lazily.
+   * @docs-private
+   */
+  lazyContent;
+  /** Whether the menu should overlap its trigger. */
+  overlapTrigger;
+  /** Whether the menu has a backdrop. */
+  hasBackdrop;
+  /**
+   * This method takes classes set on the host mat-menu element and applies them on the
+   * menu template that displays in the overlay container.  Otherwise, it's difficult
+   * to style the containing menu from outside the component.
+   * @param classes list of class names
+   */
+  set panelClass(classes) {
+    const previousPanelClass = this._previousPanelClass;
+    const newClassList = __spreadValues({}, this._classList);
+    if (previousPanelClass && previousPanelClass.length) {
+      previousPanelClass.split(" ").forEach((className) => {
+        newClassList[className] = false;
+      });
+    }
+    this._previousPanelClass = classes;
+    if (classes && classes.length) {
+      classes.split(" ").forEach((className) => {
+        newClassList[className] = true;
+      });
+      this._elementRef.nativeElement.className = "";
+    }
+    this._classList = newClassList;
+  }
+  _previousPanelClass;
+  /**
+   * This method takes classes set on the host mat-menu element and applies them on the
+   * menu template that displays in the overlay container.  Otherwise, it's difficult
+   * to style the containing menu from outside the component.
+   * @deprecated Use `panelClass` instead.
+   * @breaking-change 8.0.0
+   */
+  get classList() {
+    return this.panelClass;
+  }
+  set classList(classes) {
+    this.panelClass = classes;
+  }
+  /** Event emitted when the menu is closed. */
+  closed = new EventEmitter();
+  /**
+   * Event emitted when the menu is closed.
+   * @deprecated Switch to `closed` instead
+   * @breaking-change 8.0.0
+   */
+  close = this.closed;
+  panelId = inject(_IdGenerator).getId("mat-menu-panel-");
+  constructor() {
+    const defaultOptions = inject(MAT_MENU_DEFAULT_OPTIONS);
+    this.overlayPanelClass = defaultOptions.overlayPanelClass || "";
+    this._xPosition = defaultOptions.xPosition;
+    this._yPosition = defaultOptions.yPosition;
+    this.backdropClass = defaultOptions.backdropClass;
+    this.overlapTrigger = defaultOptions.overlapTrigger;
+    this.hasBackdrop = defaultOptions.hasBackdrop;
+  }
+  ngOnInit() {
+    this.setPositionClasses();
+  }
+  ngAfterContentInit() {
+    this._updateDirectDescendants();
+    this._keyManager = new FocusKeyManager(this._directDescendantItems).withWrap().withTypeAhead().withHomeAndEnd();
+    this._keyManager.tabOut.subscribe(() => this.closed.emit("tab"));
+    this._directDescendantItems.changes.pipe(startWith(this._directDescendantItems), switchMap((items) => merge(...items.map((item) => item._focused)))).subscribe((focusedItem) => this._keyManager.updateActiveItem(focusedItem));
+    this._directDescendantItems.changes.subscribe((itemsList) => {
+      const manager = this._keyManager;
+      if (this._panelAnimationState === "enter" && manager.activeItem?._hasFocus()) {
+        const items = itemsList.toArray();
+        const index = Math.max(0, Math.min(items.length - 1, manager.activeItemIndex || 0));
+        if (items[index] && !items[index].disabled) {
+          manager.setActiveItem(index);
+        } else {
+          manager.setNextItemActive();
+        }
+      }
+    });
+  }
+  ngOnDestroy() {
+    this._keyManager?.destroy();
+    this._directDescendantItems.destroy();
+    this.closed.complete();
+    this._firstItemFocusRef?.destroy();
+    clearTimeout(this._exitFallbackTimeout);
+  }
+  /** Stream that emits whenever the hovered menu item changes. */
+  _hovered() {
+    const itemChanges = this._directDescendantItems.changes;
+    return itemChanges.pipe(startWith(this._directDescendantItems), switchMap((items) => merge(...items.map((item) => item._hovered))));
+  }
+  /*
+   * Registers a menu item with the menu.
+   * @docs-private
+   * @deprecated No longer being used. To be removed.
+   * @breaking-change 9.0.0
+   */
+  addItem(_item) {
+  }
+  /**
+   * Removes an item from the menu.
+   * @docs-private
+   * @deprecated No longer being used. To be removed.
+   * @breaking-change 9.0.0
+   */
+  removeItem(_item) {
+  }
+  /** Handle a keyboard event from the menu, delegating to the appropriate action. */
+  _handleKeydown(event) {
+    const keyCode = event.keyCode;
+    const manager = this._keyManager;
+    switch (keyCode) {
+      case ESCAPE:
+        if (!hasModifierKey(event)) {
+          event.preventDefault();
+          this.closed.emit("keydown");
+        }
+        break;
+      case LEFT_ARROW:
+        if (this.parentMenu && this.direction === "ltr") {
+          this.closed.emit("keydown");
+        }
+        break;
+      case RIGHT_ARROW:
+        if (this.parentMenu && this.direction === "rtl") {
+          this.closed.emit("keydown");
+        }
+        break;
+      default:
+        if (keyCode === UP_ARROW || keyCode === DOWN_ARROW) {
+          manager.setFocusOrigin("keyboard");
+        }
+        manager.onKeydown(event);
+        return;
+    }
+  }
+  /**
+   * Focus the first item in the menu.
+   * @param origin Action from which the focus originated. Used to set the correct styling.
+   */
+  focusFirstItem(origin = "program") {
+    this._firstItemFocusRef?.destroy();
+    this._firstItemFocusRef = afterNextRender(() => {
+      const menuPanel = this._resolvePanel();
+      if (!menuPanel || !menuPanel.contains(document.activeElement)) {
+        const manager = this._keyManager;
+        manager.setFocusOrigin(origin).setFirstItemActive();
+        if (!manager.activeItem && menuPanel) {
+          menuPanel.focus();
+        }
+      }
+    }, {
+      injector: this._injector
+    });
+  }
+  /**
+   * Resets the active item in the menu. This is used when the menu is opened, allowing
+   * the user to start from the first option when pressing the down arrow.
+   */
+  resetActiveItem() {
+    this._keyManager.setActiveItem(-1);
+  }
+  /**
+   * @deprecated No longer used and will be removed.
+   * @breaking-change 21.0.0
+   */
+  setElevation(_depth) {
+  }
+  /**
+   * Adds classes to the menu panel based on its position. Can be used by
+   * consumers to add specific styling based on the position.
+   * @param posX Position of the menu along the x axis.
+   * @param posY Position of the menu along the y axis.
+   * @docs-private
+   */
+  setPositionClasses(posX = this.xPosition, posY = this.yPosition) {
+    this._classList = __spreadProps(__spreadValues({}, this._classList), {
+      ["mat-menu-before"]: posX === "before",
+      ["mat-menu-after"]: posX === "after",
+      ["mat-menu-above"]: posY === "above",
+      ["mat-menu-below"]: posY === "below"
+    });
+    this._changeDetectorRef.markForCheck();
+  }
+  /** Callback that is invoked when the panel animation completes. */
+  _onAnimationDone(state) {
+    const isExit = state === EXIT_ANIMATION;
+    if (isExit || state === ENTER_ANIMATION) {
+      if (isExit) {
+        clearTimeout(this._exitFallbackTimeout);
+        this._exitFallbackTimeout = void 0;
+      }
+      this._animationDone.next(isExit ? "void" : "enter");
+      this._isAnimating = false;
+    }
+  }
+  _onAnimationStart(state) {
+    if (state === ENTER_ANIMATION || state === EXIT_ANIMATION) {
+      this._isAnimating = true;
+    }
+  }
+  _setIsOpen(isOpen) {
+    this._panelAnimationState = isOpen ? "enter" : "void";
+    if (isOpen) {
+      if (this._keyManager.activeItemIndex === 0) {
+        const menuPanel = this._resolvePanel();
+        if (menuPanel) {
+          menuPanel.scrollTop = 0;
+        }
+      }
+    } else if (!this._animationsDisabled) {
+      this._exitFallbackTimeout = setTimeout(() => this._onAnimationDone(EXIT_ANIMATION), 200);
+    }
+    if (this._animationsDisabled) {
+      setTimeout(() => {
+        this._onAnimationDone(isOpen ? ENTER_ANIMATION : EXIT_ANIMATION);
+      });
+    }
+    this._changeDetectorRef.markForCheck();
+  }
+  /**
+   * Sets up a stream that will keep track of any newly-added menu items and will update the list
+   * of direct descendants. We collect the descendants this way, because `_allItems` can include
+   * items that are part of child menus, and using a custom way of registering items is unreliable
+   * when it comes to maintaining the item order.
+   */
+  _updateDirectDescendants() {
+    this._allItems.changes.pipe(startWith(this._allItems)).subscribe((items) => {
+      this._directDescendantItems.reset(items.filter((item) => item._parentMenu === this));
+      this._directDescendantItems.notifyOnChanges();
+    });
+  }
+  /** Gets the menu panel DOM node. */
+  _resolvePanel() {
+    let menuPanel = null;
+    if (this._directDescendantItems.length) {
+      menuPanel = this._directDescendantItems.first._getHostElement().closest('[role="menu"]');
+    }
+    return menuPanel;
+  }
+  static \u0275fac = function MatMenu_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _MatMenu)();
+  };
+  static \u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({
+    type: _MatMenu,
+    selectors: [["mat-menu"]],
+    contentQueries: function MatMenu_ContentQueries(rf, ctx, dirIndex) {
+      if (rf & 1) {
+        \u0275\u0275contentQuery(dirIndex, MAT_MENU_CONTENT, 5);
+        \u0275\u0275contentQuery(dirIndex, MatMenuItem, 5);
+        \u0275\u0275contentQuery(dirIndex, MatMenuItem, 4);
+      }
+      if (rf & 2) {
+        let _t;
+        \u0275\u0275queryRefresh(_t = \u0275\u0275loadQuery()) && (ctx.lazyContent = _t.first);
+        \u0275\u0275queryRefresh(_t = \u0275\u0275loadQuery()) && (ctx._allItems = _t);
+        \u0275\u0275queryRefresh(_t = \u0275\u0275loadQuery()) && (ctx.items = _t);
+      }
+    },
+    viewQuery: function MatMenu_Query(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275viewQuery(TemplateRef, 5);
+      }
+      if (rf & 2) {
+        let _t;
+        \u0275\u0275queryRefresh(_t = \u0275\u0275loadQuery()) && (ctx.templateRef = _t.first);
+      }
+    },
+    hostVars: 3,
+    hostBindings: function MatMenu_HostBindings(rf, ctx) {
+      if (rf & 2) {
+        \u0275\u0275attribute("aria-label", null)("aria-labelledby", null)("aria-describedby", null);
+      }
+    },
+    inputs: {
+      backdropClass: "backdropClass",
+      ariaLabel: [0, "aria-label", "ariaLabel"],
+      ariaLabelledby: [0, "aria-labelledby", "ariaLabelledby"],
+      ariaDescribedby: [0, "aria-describedby", "ariaDescribedby"],
+      xPosition: "xPosition",
+      yPosition: "yPosition",
+      overlapTrigger: [2, "overlapTrigger", "overlapTrigger", booleanAttribute],
+      hasBackdrop: [2, "hasBackdrop", "hasBackdrop", (value) => value == null ? null : booleanAttribute(value)],
+      panelClass: [0, "class", "panelClass"],
+      classList: "classList"
+    },
+    outputs: {
+      closed: "closed",
+      close: "close"
+    },
+    exportAs: ["matMenu"],
+    features: [\u0275\u0275ProvidersFeature([{
+      provide: MAT_MENU_PANEL,
+      useExisting: _MatMenu
+    }])],
+    ngContentSelectors: _c3,
+    decls: 1,
+    vars: 0,
+    consts: [["tabindex", "-1", "role", "menu", 1, "mat-mdc-menu-panel", 3, "click", "animationstart", "animationend", "animationcancel", "id"], [1, "mat-mdc-menu-content"]],
+    template: function MatMenu_Template(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275projectionDef();
+        \u0275\u0275domTemplate(0, MatMenu_ng_template_0_Template, 3, 12, "ng-template");
+      }
+    },
+    styles: ['mat-menu{display:none}.mat-mdc-menu-content{margin:0;padding:8px 0;outline:0}.mat-mdc-menu-content,.mat-mdc-menu-content .mat-mdc-menu-item .mat-mdc-menu-item-text{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;flex:1;white-space:normal;font-family:var(--mat-menu-item-label-text-font, var(--mat-sys-label-large-font));line-height:var(--mat-menu-item-label-text-line-height, var(--mat-sys-label-large-line-height));font-size:var(--mat-menu-item-label-text-size, var(--mat-sys-label-large-size));letter-spacing:var(--mat-menu-item-label-text-tracking, var(--mat-sys-label-large-tracking));font-weight:var(--mat-menu-item-label-text-weight, var(--mat-sys-label-large-weight))}@keyframes _mat-menu-enter{from{opacity:0;transform:scale(0.8)}to{opacity:1;transform:none}}@keyframes _mat-menu-exit{from{opacity:1}to{opacity:0}}.mat-mdc-menu-panel{min-width:112px;max-width:280px;overflow:auto;box-sizing:border-box;outline:0;animation:_mat-menu-enter 120ms cubic-bezier(0, 0, 0.2, 1);border-radius:var(--mat-menu-container-shape, var(--mat-sys-corner-extra-small));background-color:var(--mat-menu-container-color, var(--mat-sys-surface-container));box-shadow:var(--mat-menu-container-elevation-shadow, 0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12));will-change:transform,opacity}.mat-mdc-menu-panel.mat-menu-panel-exit-animation{animation:_mat-menu-exit 100ms 25ms linear forwards}.mat-mdc-menu-panel.mat-menu-panel-animations-disabled{animation:none}.mat-mdc-menu-panel.mat-menu-panel-animating{pointer-events:none}.mat-mdc-menu-panel.mat-menu-panel-animating:has(.mat-mdc-menu-content:empty){display:none}@media(forced-colors: active){.mat-mdc-menu-panel{outline:solid 1px}}.mat-mdc-menu-panel .mat-divider{color:var(--mat-menu-divider-color, var(--mat-sys-surface-variant));margin-bottom:var(--mat-menu-divider-bottom-spacing, 8px);margin-top:var(--mat-menu-divider-top-spacing, 8px)}.mat-mdc-menu-item{display:flex;position:relative;align-items:center;justify-content:flex-start;overflow:hidden;padding:0;cursor:pointer;width:100%;text-align:left;box-sizing:border-box;color:inherit;font-size:inherit;background:none;text-decoration:none;margin:0;min-height:48px;padding-left:var(--mat-menu-item-leading-spacing, 12px);padding-right:var(--mat-menu-item-trailing-spacing, 12px);-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-menu-item::-moz-focus-inner{border:0}[dir=rtl] .mat-mdc-menu-item{padding-left:var(--mat-menu-item-trailing-spacing, 12px);padding-right:var(--mat-menu-item-leading-spacing, 12px)}.mat-mdc-menu-item:has(.material-icons,mat-icon,[matButtonIcon]){padding-left:var(--mat-menu-item-with-icon-leading-spacing, 12px);padding-right:var(--mat-menu-item-with-icon-trailing-spacing, 12px)}[dir=rtl] .mat-mdc-menu-item:has(.material-icons,mat-icon,[matButtonIcon]){padding-left:var(--mat-menu-item-with-icon-trailing-spacing, 12px);padding-right:var(--mat-menu-item-with-icon-leading-spacing, 12px)}.mat-mdc-menu-item,.mat-mdc-menu-item:visited,.mat-mdc-menu-item:link{color:var(--mat-menu-item-label-text-color, var(--mat-sys-on-surface))}.mat-mdc-menu-item .mat-icon-no-color,.mat-mdc-menu-item .mat-mdc-menu-submenu-icon{color:var(--mat-menu-item-icon-color, var(--mat-sys-on-surface-variant))}.mat-mdc-menu-item[disabled]{cursor:default;opacity:.38}.mat-mdc-menu-item[disabled]::after{display:block;position:absolute;content:"";top:0;left:0;bottom:0;right:0}.mat-mdc-menu-item:focus{outline:0}.mat-mdc-menu-item .mat-icon{flex-shrink:0;margin-right:var(--mat-menu-item-spacing, 12px);height:var(--mat-menu-item-icon-size, 24px);width:var(--mat-menu-item-icon-size, 24px)}[dir=rtl] .mat-mdc-menu-item{text-align:right}[dir=rtl] .mat-mdc-menu-item .mat-icon{margin-right:0;margin-left:var(--mat-menu-item-spacing, 12px)}.mat-mdc-menu-item:not([disabled]):hover{background-color:var(--mat-menu-item-hover-state-layer-color, color-mix(in srgb, var(--mat-sys-on-surface) calc(var(--mat-sys-hover-state-layer-opacity) * 100%), transparent))}.mat-mdc-menu-item:not([disabled]).cdk-program-focused,.mat-mdc-menu-item:not([disabled]).cdk-keyboard-focused,.mat-mdc-menu-item:not([disabled]).mat-mdc-menu-item-highlighted{background-color:var(--mat-menu-item-focus-state-layer-color, color-mix(in srgb, var(--mat-sys-on-surface) calc(var(--mat-sys-focus-state-layer-opacity) * 100%), transparent))}@media(forced-colors: active){.mat-mdc-menu-item{margin-top:1px}}.mat-mdc-menu-submenu-icon{width:var(--mat-menu-item-icon-size, 24px);height:10px;fill:currentColor;padding-left:var(--mat-menu-item-spacing, 12px)}[dir=rtl] .mat-mdc-menu-submenu-icon{padding-right:var(--mat-menu-item-spacing, 12px);padding-left:0}[dir=rtl] .mat-mdc-menu-submenu-icon polygon{transform:scaleX(-1);transform-origin:center}@media(forced-colors: active){.mat-mdc-menu-submenu-icon{fill:CanvasText}}.mat-mdc-menu-item .mat-mdc-menu-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}\n'],
+    encapsulation: 2,
+    changeDetection: 0
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MatMenu, [{
+    type: Component,
+    args: [{
+      selector: "mat-menu",
+      changeDetection: ChangeDetectionStrategy.OnPush,
+      encapsulation: ViewEncapsulation.None,
+      exportAs: "matMenu",
+      host: {
+        "[attr.aria-label]": "null",
+        "[attr.aria-labelledby]": "null",
+        "[attr.aria-describedby]": "null"
+      },
+      providers: [{
+        provide: MAT_MENU_PANEL,
+        useExisting: MatMenu
+      }],
+      template: `<ng-template>
+  <div
+    class="mat-mdc-menu-panel"
+    [id]="panelId"
+    [class]="_classList"
+    [class.mat-menu-panel-animations-disabled]="_animationsDisabled"
+    [class.mat-menu-panel-exit-animation]="_panelAnimationState === 'void'"
+    [class.mat-menu-panel-animating]="_isAnimating"
+    (click)="closed.emit('click')"
+    tabindex="-1"
+    role="menu"
+    (animationstart)="_onAnimationStart($event.animationName)"
+    (animationend)="_onAnimationDone($event.animationName)"
+    (animationcancel)="_onAnimationDone($event.animationName)"
+    [attr.aria-label]="ariaLabel || null"
+    [attr.aria-labelledby]="ariaLabelledby || null"
+    [attr.aria-describedby]="ariaDescribedby || null">
+    <div class="mat-mdc-menu-content">
+      <ng-content></ng-content>
+    </div>
+  </div>
+</ng-template>
+`,
+      styles: ['mat-menu{display:none}.mat-mdc-menu-content{margin:0;padding:8px 0;outline:0}.mat-mdc-menu-content,.mat-mdc-menu-content .mat-mdc-menu-item .mat-mdc-menu-item-text{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;flex:1;white-space:normal;font-family:var(--mat-menu-item-label-text-font, var(--mat-sys-label-large-font));line-height:var(--mat-menu-item-label-text-line-height, var(--mat-sys-label-large-line-height));font-size:var(--mat-menu-item-label-text-size, var(--mat-sys-label-large-size));letter-spacing:var(--mat-menu-item-label-text-tracking, var(--mat-sys-label-large-tracking));font-weight:var(--mat-menu-item-label-text-weight, var(--mat-sys-label-large-weight))}@keyframes _mat-menu-enter{from{opacity:0;transform:scale(0.8)}to{opacity:1;transform:none}}@keyframes _mat-menu-exit{from{opacity:1}to{opacity:0}}.mat-mdc-menu-panel{min-width:112px;max-width:280px;overflow:auto;box-sizing:border-box;outline:0;animation:_mat-menu-enter 120ms cubic-bezier(0, 0, 0.2, 1);border-radius:var(--mat-menu-container-shape, var(--mat-sys-corner-extra-small));background-color:var(--mat-menu-container-color, var(--mat-sys-surface-container));box-shadow:var(--mat-menu-container-elevation-shadow, 0px 3px 1px -2px rgba(0, 0, 0, 0.2), 0px 2px 2px 0px rgba(0, 0, 0, 0.14), 0px 1px 5px 0px rgba(0, 0, 0, 0.12));will-change:transform,opacity}.mat-mdc-menu-panel.mat-menu-panel-exit-animation{animation:_mat-menu-exit 100ms 25ms linear forwards}.mat-mdc-menu-panel.mat-menu-panel-animations-disabled{animation:none}.mat-mdc-menu-panel.mat-menu-panel-animating{pointer-events:none}.mat-mdc-menu-panel.mat-menu-panel-animating:has(.mat-mdc-menu-content:empty){display:none}@media(forced-colors: active){.mat-mdc-menu-panel{outline:solid 1px}}.mat-mdc-menu-panel .mat-divider{color:var(--mat-menu-divider-color, var(--mat-sys-surface-variant));margin-bottom:var(--mat-menu-divider-bottom-spacing, 8px);margin-top:var(--mat-menu-divider-top-spacing, 8px)}.mat-mdc-menu-item{display:flex;position:relative;align-items:center;justify-content:flex-start;overflow:hidden;padding:0;cursor:pointer;width:100%;text-align:left;box-sizing:border-box;color:inherit;font-size:inherit;background:none;text-decoration:none;margin:0;min-height:48px;padding-left:var(--mat-menu-item-leading-spacing, 12px);padding-right:var(--mat-menu-item-trailing-spacing, 12px);-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-mdc-menu-item::-moz-focus-inner{border:0}[dir=rtl] .mat-mdc-menu-item{padding-left:var(--mat-menu-item-trailing-spacing, 12px);padding-right:var(--mat-menu-item-leading-spacing, 12px)}.mat-mdc-menu-item:has(.material-icons,mat-icon,[matButtonIcon]){padding-left:var(--mat-menu-item-with-icon-leading-spacing, 12px);padding-right:var(--mat-menu-item-with-icon-trailing-spacing, 12px)}[dir=rtl] .mat-mdc-menu-item:has(.material-icons,mat-icon,[matButtonIcon]){padding-left:var(--mat-menu-item-with-icon-trailing-spacing, 12px);padding-right:var(--mat-menu-item-with-icon-leading-spacing, 12px)}.mat-mdc-menu-item,.mat-mdc-menu-item:visited,.mat-mdc-menu-item:link{color:var(--mat-menu-item-label-text-color, var(--mat-sys-on-surface))}.mat-mdc-menu-item .mat-icon-no-color,.mat-mdc-menu-item .mat-mdc-menu-submenu-icon{color:var(--mat-menu-item-icon-color, var(--mat-sys-on-surface-variant))}.mat-mdc-menu-item[disabled]{cursor:default;opacity:.38}.mat-mdc-menu-item[disabled]::after{display:block;position:absolute;content:"";top:0;left:0;bottom:0;right:0}.mat-mdc-menu-item:focus{outline:0}.mat-mdc-menu-item .mat-icon{flex-shrink:0;margin-right:var(--mat-menu-item-spacing, 12px);height:var(--mat-menu-item-icon-size, 24px);width:var(--mat-menu-item-icon-size, 24px)}[dir=rtl] .mat-mdc-menu-item{text-align:right}[dir=rtl] .mat-mdc-menu-item .mat-icon{margin-right:0;margin-left:var(--mat-menu-item-spacing, 12px)}.mat-mdc-menu-item:not([disabled]):hover{background-color:var(--mat-menu-item-hover-state-layer-color, color-mix(in srgb, var(--mat-sys-on-surface) calc(var(--mat-sys-hover-state-layer-opacity) * 100%), transparent))}.mat-mdc-menu-item:not([disabled]).cdk-program-focused,.mat-mdc-menu-item:not([disabled]).cdk-keyboard-focused,.mat-mdc-menu-item:not([disabled]).mat-mdc-menu-item-highlighted{background-color:var(--mat-menu-item-focus-state-layer-color, color-mix(in srgb, var(--mat-sys-on-surface) calc(var(--mat-sys-focus-state-layer-opacity) * 100%), transparent))}@media(forced-colors: active){.mat-mdc-menu-item{margin-top:1px}}.mat-mdc-menu-submenu-icon{width:var(--mat-menu-item-icon-size, 24px);height:10px;fill:currentColor;padding-left:var(--mat-menu-item-spacing, 12px)}[dir=rtl] .mat-mdc-menu-submenu-icon{padding-right:var(--mat-menu-item-spacing, 12px);padding-left:0}[dir=rtl] .mat-mdc-menu-submenu-icon polygon{transform:scaleX(-1);transform-origin:center}@media(forced-colors: active){.mat-mdc-menu-submenu-icon{fill:CanvasText}}.mat-mdc-menu-item .mat-mdc-menu-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}\n']
+    }]
+  }], () => [], {
+    _allItems: [{
+      type: ContentChildren,
+      args: [MatMenuItem, {
+        descendants: true
+      }]
+    }],
+    backdropClass: [{
+      type: Input
+    }],
+    ariaLabel: [{
+      type: Input,
+      args: ["aria-label"]
+    }],
+    ariaLabelledby: [{
+      type: Input,
+      args: ["aria-labelledby"]
+    }],
+    ariaDescribedby: [{
+      type: Input,
+      args: ["aria-describedby"]
+    }],
+    xPosition: [{
+      type: Input
+    }],
+    yPosition: [{
+      type: Input
+    }],
+    templateRef: [{
+      type: ViewChild,
+      args: [TemplateRef]
+    }],
+    items: [{
+      type: ContentChildren,
+      args: [MatMenuItem, {
+        descendants: false
+      }]
+    }],
+    lazyContent: [{
+      type: ContentChild,
+      args: [MAT_MENU_CONTENT]
+    }],
+    overlapTrigger: [{
+      type: Input,
+      args: [{
+        transform: booleanAttribute
+      }]
+    }],
+    hasBackdrop: [{
+      type: Input,
+      args: [{
+        transform: (value) => value == null ? null : booleanAttribute(value)
+      }]
+    }],
+    panelClass: [{
+      type: Input,
+      args: ["class"]
+    }],
+    classList: [{
+      type: Input
+    }],
+    closed: [{
+      type: Output
+    }],
+    close: [{
+      type: Output
+    }]
+  });
+})();
+var MAT_MENU_SCROLL_STRATEGY = new InjectionToken("mat-menu-scroll-strategy", {
+  providedIn: "root",
+  factory: () => {
+    const injector = inject(Injector);
+    return () => createRepositionScrollStrategy(injector);
+  }
+});
+function MAT_MENU_SCROLL_STRATEGY_FACTORY(_overlay) {
+  const injector = inject(Injector);
+  return () => createRepositionScrollStrategy(injector);
+}
+var MAT_MENU_SCROLL_STRATEGY_FACTORY_PROVIDER = {
+  provide: MAT_MENU_SCROLL_STRATEGY,
+  deps: [],
+  useFactory: MAT_MENU_SCROLL_STRATEGY_FACTORY
+};
+var PANELS_TO_TRIGGERS = /* @__PURE__ */ new WeakMap();
+var MatMenuTriggerBase = class _MatMenuTriggerBase {
+  _canHaveBackdrop;
+  _element = inject(ElementRef);
+  _viewContainerRef = inject(ViewContainerRef);
+  _menuItemInstance = inject(MatMenuItem, {
+    optional: true,
+    self: true
+  });
+  _dir = inject(Directionality, {
+    optional: true
+  });
+  _focusMonitor = inject(FocusMonitor);
+  _ngZone = inject(NgZone);
+  _injector = inject(Injector);
+  _scrollStrategy = inject(MAT_MENU_SCROLL_STRATEGY);
+  _changeDetectorRef = inject(ChangeDetectorRef);
+  _animationsDisabled = _animationsDisabled();
+  _portal;
+  _overlayRef = null;
+  _menuOpen = false;
+  _closingActionsSubscription = Subscription.EMPTY;
+  _menuCloseSubscription = Subscription.EMPTY;
+  _pendingRemoval;
+  /**
+   * We're specifically looking for a `MatMenu` here since the generic `MatMenuPanel`
+   * interface lacks some functionality around nested menus and animations.
+   */
+  _parentMaterialMenu;
+  /**
+   * Cached value of the padding of the parent menu panel.
+   * Used to offset sub-menus to compensate for the padding.
+   */
+  _parentInnerPadding;
+  // Tracking input type is necessary so it's possible to only auto-focus
+  // the first item of the list when the menu is opened via the keyboard
+  _openedBy = void 0;
+  /** Menu currently assigned to the trigger. */
+  get _menu() {
+    return this._menuInternal;
+  }
+  set _menu(menu) {
+    if (menu === this._menuInternal) {
+      return;
+    }
+    this._menuInternal = menu;
+    this._menuCloseSubscription.unsubscribe();
+    if (menu) {
+      if (menu === this._parentMaterialMenu && (typeof ngDevMode === "undefined" || ngDevMode)) {
+        throwMatMenuRecursiveError();
+      }
+      this._menuCloseSubscription = menu.close.subscribe((reason) => {
+        this._destroyMenu(reason);
+        if ((reason === "click" || reason === "tab") && this._parentMaterialMenu) {
+          this._parentMaterialMenu.closed.emit(reason);
+        }
+      });
+    }
+    this._menuItemInstance?._setTriggersSubmenu(this._triggersSubmenu());
+  }
+  _menuInternal;
+  constructor(_canHaveBackdrop) {
+    this._canHaveBackdrop = _canHaveBackdrop;
+    const parentMenu = inject(MAT_MENU_PANEL, {
+      optional: true
+    });
+    this._parentMaterialMenu = parentMenu instanceof MatMenu ? parentMenu : void 0;
+  }
+  ngOnDestroy() {
+    if (this._menu && this._ownsMenu(this._menu)) {
+      PANELS_TO_TRIGGERS.delete(this._menu);
+    }
+    this._pendingRemoval?.unsubscribe();
+    this._menuCloseSubscription.unsubscribe();
+    this._closingActionsSubscription.unsubscribe();
+    if (this._overlayRef) {
+      this._overlayRef.dispose();
+      this._overlayRef = null;
+    }
+  }
+  /** Whether the menu is open. */
+  get menuOpen() {
+    return this._menuOpen;
+  }
+  /** The text direction of the containing app. */
+  get dir() {
+    return this._dir && this._dir.value === "rtl" ? "rtl" : "ltr";
+  }
+  /** Whether the menu triggers a sub-menu or a top-level one. */
+  _triggersSubmenu() {
+    return !!(this._menuItemInstance && this._parentMaterialMenu && this._menu);
+  }
+  _closeMenu() {
+    this._menu?.close.emit();
+  }
+  /** Internal method to open menu providing option to auto focus on first item. */
+  _openMenu(autoFocus) {
+    const menu = this._menu;
+    if (this._menuOpen || !menu) {
+      return;
+    }
+    this._pendingRemoval?.unsubscribe();
+    const previousTrigger = PANELS_TO_TRIGGERS.get(menu);
+    PANELS_TO_TRIGGERS.set(menu, this);
+    if (previousTrigger && previousTrigger !== this) {
+      previousTrigger._closeMenu();
+    }
+    const overlayRef = this._createOverlay(menu);
+    const overlayConfig = overlayRef.getConfig();
+    const positionStrategy = overlayConfig.positionStrategy;
+    this._setPosition(menu, positionStrategy);
+    if (this._canHaveBackdrop) {
+      overlayConfig.hasBackdrop = menu.hasBackdrop == null ? !this._triggersSubmenu() : menu.hasBackdrop;
+    } else {
+      overlayConfig.hasBackdrop = false;
+    }
+    if (!overlayRef.hasAttached()) {
+      overlayRef.attach(this._getPortal(menu));
+      menu.lazyContent?.attach(this.menuData);
+    }
+    this._closingActionsSubscription = this._menuClosingActions().subscribe(() => this._closeMenu());
+    menu.parentMenu = this._triggersSubmenu() ? this._parentMaterialMenu : void 0;
+    menu.direction = this.dir;
+    if (autoFocus) {
+      menu.focusFirstItem(this._openedBy || "program");
+    }
+    this._setIsMenuOpen(true);
+    if (menu instanceof MatMenu) {
+      menu._setIsOpen(true);
+      menu._directDescendantItems.changes.pipe(takeUntil(menu.close)).subscribe(() => {
+        positionStrategy.withLockedPosition(false).reapplyLastPosition();
+        positionStrategy.withLockedPosition(true);
+      });
+    }
+  }
+  /**
+   * Focuses the menu trigger.
+   * @param origin Source of the menu trigger's focus.
+   */
+  focus(origin, options2) {
+    if (this._focusMonitor && origin) {
+      this._focusMonitor.focusVia(this._element, origin, options2);
+    } else {
+      this._element.nativeElement.focus(options2);
+    }
+  }
+  /** Closes the menu and does the necessary cleanup. */
+  _destroyMenu(reason) {
+    const overlayRef = this._overlayRef;
+    const menu = this._menu;
+    if (!overlayRef || !this.menuOpen) {
+      return;
+    }
+    this._closingActionsSubscription.unsubscribe();
+    this._pendingRemoval?.unsubscribe();
+    if (menu instanceof MatMenu && this._ownsMenu(menu)) {
+      this._pendingRemoval = menu._animationDone.pipe(take(1)).subscribe(() => {
+        overlayRef.detach();
+        menu.lazyContent?.detach();
+      });
+      menu._setIsOpen(false);
+    } else {
+      overlayRef.detach();
+      menu?.lazyContent?.detach();
+    }
+    if (menu && this._ownsMenu(menu)) {
+      PANELS_TO_TRIGGERS.delete(menu);
+    }
+    if (this.restoreFocus && (reason === "keydown" || !this._openedBy || !this._triggersSubmenu())) {
+      this.focus(this._openedBy);
+    }
+    this._openedBy = void 0;
+    this._setIsMenuOpen(false);
+  }
+  // set state rather than toggle to support triggers sharing a menu
+  _setIsMenuOpen(isOpen) {
+    if (isOpen !== this._menuOpen) {
+      this._menuOpen = isOpen;
+      this._menuOpen ? this.menuOpened.emit() : this.menuClosed.emit();
+      if (this._triggersSubmenu()) {
+        this._menuItemInstance._setHighlighted(isOpen);
+      }
+      this._changeDetectorRef.markForCheck();
+    }
+  }
+  /**
+   * This method creates the overlay from the provided menu's template and saves its
+   * OverlayRef so that it can be attached to the DOM when openMenu is called.
+   */
+  _createOverlay(menu) {
+    if (!this._overlayRef) {
+      const config = this._getOverlayConfig(menu);
+      this._subscribeToPositions(menu, config.positionStrategy);
+      this._overlayRef = createOverlayRef(this._injector, config);
+      this._overlayRef.keydownEvents().subscribe((event) => {
+        if (this._menu instanceof MatMenu) {
+          this._menu._handleKeydown(event);
+        }
+      });
+    }
+    return this._overlayRef;
+  }
+  /**
+   * This method builds the configuration object needed to create the overlay, the OverlayState.
+   * @returns OverlayConfig
+   */
+  _getOverlayConfig(menu) {
+    return new OverlayConfig({
+      positionStrategy: createFlexibleConnectedPositionStrategy(this._injector, this._getOverlayOrigin()).withLockedPosition().withGrowAfterOpen().withTransformOriginOn(".mat-menu-panel, .mat-mdc-menu-panel"),
+      backdropClass: menu.backdropClass || "cdk-overlay-transparent-backdrop",
+      panelClass: menu.overlayPanelClass,
+      scrollStrategy: this._scrollStrategy(),
+      direction: this._dir || "ltr",
+      disableAnimations: this._animationsDisabled
+    });
+  }
+  /**
+   * Listens to changes in the position of the overlay and sets the correct classes
+   * on the menu based on the new position. This ensures the animation origin is always
+   * correct, even if a fallback position is used for the overlay.
+   */
+  _subscribeToPositions(menu, position) {
+    if (menu.setPositionClasses) {
+      position.positionChanges.subscribe((change) => {
+        this._ngZone.run(() => {
+          const posX = change.connectionPair.overlayX === "start" ? "after" : "before";
+          const posY = change.connectionPair.overlayY === "top" ? "below" : "above";
+          menu.setPositionClasses(posX, posY);
+        });
+      });
+    }
+  }
+  /**
+   * Sets the appropriate positions on a position strategy
+   * so the overlay connects with the trigger correctly.
+   * @param positionStrategy Strategy whose position to update.
+   */
+  _setPosition(menu, positionStrategy) {
+    let [originX, originFallbackX] = menu.xPosition === "before" ? ["end", "start"] : ["start", "end"];
+    let [overlayY, overlayFallbackY] = menu.yPosition === "above" ? ["bottom", "top"] : ["top", "bottom"];
+    let [originY, originFallbackY] = [overlayY, overlayFallbackY];
+    let [overlayX, overlayFallbackX] = [originX, originFallbackX];
+    let offsetY = 0;
+    if (this._triggersSubmenu()) {
+      overlayFallbackX = originX = menu.xPosition === "before" ? "start" : "end";
+      originFallbackX = overlayX = originX === "end" ? "start" : "end";
+      if (this._parentMaterialMenu) {
+        if (this._parentInnerPadding == null) {
+          const firstItem = this._parentMaterialMenu.items.first;
+          this._parentInnerPadding = firstItem ? firstItem._getHostElement().offsetTop : 0;
+        }
+        offsetY = overlayY === "bottom" ? this._parentInnerPadding : -this._parentInnerPadding;
+      }
+    } else if (!menu.overlapTrigger) {
+      originY = overlayY === "top" ? "bottom" : "top";
+      originFallbackY = overlayFallbackY === "top" ? "bottom" : "top";
+    }
+    positionStrategy.withPositions([{
+      originX,
+      originY,
+      overlayX,
+      overlayY,
+      offsetY
+    }, {
+      originX: originFallbackX,
+      originY,
+      overlayX: overlayFallbackX,
+      overlayY,
+      offsetY
+    }, {
+      originX,
+      originY: originFallbackY,
+      overlayX,
+      overlayY: overlayFallbackY,
+      offsetY: -offsetY
+    }, {
+      originX: originFallbackX,
+      originY: originFallbackY,
+      overlayX: overlayFallbackX,
+      overlayY: overlayFallbackY,
+      offsetY: -offsetY
+    }]);
+  }
+  /** Returns a stream that emits whenever an action that should close the menu occurs. */
+  _menuClosingActions() {
+    const outsideClicks = this._getOutsideClickStream(this._overlayRef);
+    const detachments = this._overlayRef.detachments();
+    const parentClose = this._parentMaterialMenu ? this._parentMaterialMenu.closed : of();
+    const hover = this._parentMaterialMenu ? this._parentMaterialMenu._hovered().pipe(filter((active) => this._menuOpen && active !== this._menuItemInstance)) : of();
+    return merge(outsideClicks, parentClose, hover, detachments);
+  }
+  /** Gets the portal that should be attached to the overlay. */
+  _getPortal(menu) {
+    if (!this._portal || this._portal.templateRef !== menu.templateRef) {
+      this._portal = new TemplatePortal(menu.templateRef, this._viewContainerRef);
+    }
+    return this._portal;
+  }
+  /**
+   * Determines whether the trigger owns a specific menu panel, at the current point in time.
+   * This allows us to distinguish the case where the same panel is passed into multiple triggers
+   * and multiple are open at a time.
+   */
+  _ownsMenu(menu) {
+    return PANELS_TO_TRIGGERS.get(menu) === this;
+  }
+  static \u0275fac = function MatMenuTriggerBase_Factory(__ngFactoryType__) {
+    \u0275\u0275invalidFactory();
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _MatMenuTriggerBase
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MatMenuTriggerBase, [{
+    type: Directive
+  }], () => [{
+    type: void 0
+  }], null);
+})();
+var MatMenuTrigger = class _MatMenuTrigger extends MatMenuTriggerBase {
+  _cleanupTouchstart;
+  _hoverSubscription = Subscription.EMPTY;
+  /**
+   * @deprecated
+   * @breaking-change 8.0.0
+   */
+  get _deprecatedMatMenuTriggerFor() {
+    return this.menu;
+  }
+  set _deprecatedMatMenuTriggerFor(v) {
+    this.menu = v;
+  }
+  /** References the menu instance that the trigger is associated with. */
+  get menu() {
+    return this._menu;
+  }
+  set menu(menu) {
+    this._menu = menu;
+  }
+  /** Data to be passed along to any lazily-rendered content. */
+  menuData;
+  /**
+   * Whether focus should be restored when the menu is closed.
+   * Note that disabling this option can have accessibility implications
+   * and it's up to you to manage focus, if you decide to turn it off.
+   */
+  restoreFocus = true;
+  /** Event emitted when the associated menu is opened. */
+  menuOpened = new EventEmitter();
+  /**
+   * Event emitted when the associated menu is opened.
+   * @deprecated Switch to `menuOpened` instead
+   * @breaking-change 8.0.0
+   */
+  // tslint:disable-next-line:no-output-on-prefix
+  onMenuOpen = this.menuOpened;
+  /** Event emitted when the associated menu is closed. */
+  menuClosed = new EventEmitter();
+  /**
+   * Event emitted when the associated menu is closed.
+   * @deprecated Switch to `menuClosed` instead
+   * @breaking-change 8.0.0
+   */
+  // tslint:disable-next-line:no-output-on-prefix
+  onMenuClose = this.menuClosed;
+  constructor() {
+    super(true);
+    const renderer = inject(Renderer2);
+    this._cleanupTouchstart = renderer.listen(this._element.nativeElement, "touchstart", (event) => {
+      if (!isFakeTouchstartFromScreenReader(event)) {
+        this._openedBy = "touch";
+      }
+    }, {
+      passive: true
+    });
+  }
+  /** Whether the menu triggers a sub-menu or a top-level one. */
+  triggersSubmenu() {
+    return super._triggersSubmenu();
+  }
+  /** Toggles the menu between the open and closed states. */
+  toggleMenu() {
+    return this.menuOpen ? this.closeMenu() : this.openMenu();
+  }
+  /** Opens the menu. */
+  openMenu() {
+    this._openMenu(true);
+  }
+  /** Closes the menu. */
+  closeMenu() {
+    this._closeMenu();
+  }
+  /**
+   * Updates the position of the menu to ensure that it fits all options within the viewport.
+   */
+  updatePosition() {
+    this._overlayRef?.updatePosition();
+  }
+  ngAfterContentInit() {
+    this._handleHover();
+  }
+  ngOnDestroy() {
+    super.ngOnDestroy();
+    this._cleanupTouchstart();
+    this._hoverSubscription.unsubscribe();
+  }
+  _getOverlayOrigin() {
+    return this._element;
+  }
+  _getOutsideClickStream(overlayRef) {
+    return overlayRef.backdropClick();
+  }
+  /** Handles mouse presses on the trigger. */
+  _handleMousedown(event) {
+    if (!isFakeMousedownFromScreenReader(event)) {
+      this._openedBy = event.button === 0 ? "mouse" : void 0;
+      if (this.triggersSubmenu()) {
+        event.preventDefault();
+      }
+    }
+  }
+  /** Handles key presses on the trigger. */
+  _handleKeydown(event) {
+    const keyCode = event.keyCode;
+    if (keyCode === ENTER || keyCode === SPACE) {
+      this._openedBy = "keyboard";
+    }
+    if (this.triggersSubmenu() && (keyCode === RIGHT_ARROW && this.dir === "ltr" || keyCode === LEFT_ARROW && this.dir === "rtl")) {
+      this._openedBy = "keyboard";
+      this.openMenu();
+    }
+  }
+  /** Handles click events on the trigger. */
+  _handleClick(event) {
+    if (this.triggersSubmenu()) {
+      event.stopPropagation();
+      this.openMenu();
+    } else {
+      this.toggleMenu();
+    }
+  }
+  /** Handles the cases where the user hovers over the trigger. */
+  _handleHover() {
+    if (this.triggersSubmenu() && this._parentMaterialMenu) {
+      this._hoverSubscription = this._parentMaterialMenu._hovered().subscribe((active) => {
+        if (active === this._menuItemInstance && !active.disabled) {
+          this._openedBy = "mouse";
+          this._openMenu(false);
+        }
+      });
+    }
+  }
+  static \u0275fac = function MatMenuTrigger_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _MatMenuTrigger)();
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _MatMenuTrigger,
+    selectors: [["", "mat-menu-trigger-for", ""], ["", "matMenuTriggerFor", ""]],
+    hostAttrs: [1, "mat-mdc-menu-trigger"],
+    hostVars: 3,
+    hostBindings: function MatMenuTrigger_HostBindings(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275listener("click", function MatMenuTrigger_click_HostBindingHandler($event) {
+          return ctx._handleClick($event);
+        })("mousedown", function MatMenuTrigger_mousedown_HostBindingHandler($event) {
+          return ctx._handleMousedown($event);
+        })("keydown", function MatMenuTrigger_keydown_HostBindingHandler($event) {
+          return ctx._handleKeydown($event);
+        });
+      }
+      if (rf & 2) {
+        \u0275\u0275attribute("aria-haspopup", ctx.menu ? "menu" : null)("aria-expanded", ctx.menuOpen)("aria-controls", ctx.menuOpen ? ctx.menu == null ? null : ctx.menu.panelId : null);
+      }
+    },
+    inputs: {
+      _deprecatedMatMenuTriggerFor: [0, "mat-menu-trigger-for", "_deprecatedMatMenuTriggerFor"],
+      menu: [0, "matMenuTriggerFor", "menu"],
+      menuData: [0, "matMenuTriggerData", "menuData"],
+      restoreFocus: [0, "matMenuTriggerRestoreFocus", "restoreFocus"]
+    },
+    outputs: {
+      menuOpened: "menuOpened",
+      onMenuOpen: "onMenuOpen",
+      menuClosed: "menuClosed",
+      onMenuClose: "onMenuClose"
+    },
+    exportAs: ["matMenuTrigger"],
+    features: [\u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MatMenuTrigger, [{
+    type: Directive,
+    args: [{
+      selector: "[mat-menu-trigger-for], [matMenuTriggerFor]",
+      host: {
+        "class": "mat-mdc-menu-trigger",
+        "[attr.aria-haspopup]": 'menu ? "menu" : null',
+        "[attr.aria-expanded]": "menuOpen",
+        "[attr.aria-controls]": "menuOpen ? menu?.panelId : null",
+        "(click)": "_handleClick($event)",
+        "(mousedown)": "_handleMousedown($event)",
+        "(keydown)": "_handleKeydown($event)"
+      },
+      exportAs: "matMenuTrigger"
+    }]
+  }], () => [], {
+    _deprecatedMatMenuTriggerFor: [{
+      type: Input,
+      args: ["mat-menu-trigger-for"]
+    }],
+    menu: [{
+      type: Input,
+      args: ["matMenuTriggerFor"]
+    }],
+    menuData: [{
+      type: Input,
+      args: ["matMenuTriggerData"]
+    }],
+    restoreFocus: [{
+      type: Input,
+      args: ["matMenuTriggerRestoreFocus"]
+    }],
+    menuOpened: [{
+      type: Output
+    }],
+    onMenuOpen: [{
+      type: Output
+    }],
+    menuClosed: [{
+      type: Output
+    }],
+    onMenuClose: [{
+      type: Output
+    }]
+  });
+})();
+var MatContextMenuTrigger = class _MatContextMenuTrigger extends MatMenuTriggerBase {
+  _point = {
+    x: 0,
+    y: 0,
+    initialX: 0,
+    initialY: 0,
+    initialScrollX: 0,
+    initialScrollY: 0
+  };
+  _triggerPressedControl = false;
+  _rootNode;
+  _document = inject(DOCUMENT);
+  _viewportRuler = inject(ViewportRuler);
+  _scrollDispatcher = inject(ScrollDispatcher);
+  _scrollSubscription;
+  /** References the menu instance that the trigger is associated with. */
+  get menu() {
+    return this._menu;
+  }
+  set menu(menu) {
+    this._menu = menu;
+  }
+  /** Data to be passed along to any lazily-rendered content. */
+  menuData;
+  /**
+   * Whether focus should be restored when the menu is closed.
+   * Note that disabling this option can have accessibility implications
+   * and it's up to you to manage focus, if you decide to turn it off.
+   */
+  restoreFocus = true;
+  /** Whether the context menu is disabled. */
+  disabled = false;
+  /** Event emitted when the associated menu is opened. */
+  menuOpened = new EventEmitter();
+  /** Event emitted when the associated menu is closed. */
+  menuClosed = new EventEmitter();
+  constructor() {
+    super(false);
+  }
+  ngOnDestroy() {
+    super.ngOnDestroy();
+    this._scrollSubscription?.unsubscribe();
+  }
+  /** Handler for `contextmenu` events. */
+  _handleContextMenuEvent(event) {
+    if (!this.disabled) {
+      event.preventDefault();
+      if (this.menuOpen) {
+        this._initializePoint(event.clientX, event.clientY);
+        this._updatePosition();
+      } else {
+        this._openContextMenu(event);
+      }
+    }
+  }
+  _destroyMenu(reason) {
+    super._destroyMenu(reason);
+    this._scrollSubscription?.unsubscribe();
+  }
+  _getOverlayOrigin() {
+    return this._point;
+  }
+  _getOutsideClickStream(overlayRef) {
+    return overlayRef.outsidePointerEvents().pipe(skipWhile((event, index) => {
+      if (event.type === "contextmenu") {
+        return this._isWithinMenuOrTrigger(_getEventTarget(event));
+      } else if (event.type === "auxclick") {
+        if (index === 0) {
+          return true;
+        }
+        this._rootNode ??= _getShadowRoot(this._element.nativeElement) || this._document;
+        return this._isWithinMenuOrTrigger(this._rootNode.elementFromPoint(event.clientX, event.clientY));
+      }
+      return this._triggerPressedControl && index === 0 && event.ctrlKey;
+    }));
+  }
+  /** Checks whether an element is within the trigger or the opened overlay. */
+  _isWithinMenuOrTrigger(target) {
+    if (!target) {
+      return false;
+    }
+    const element = this._element.nativeElement;
+    if (target === element || element.contains(target)) {
+      return true;
+    }
+    const overlay = this._overlayRef?.hostElement;
+    return overlay === target || !!overlay?.contains(target);
+  }
+  /** Opens the context menu. */
+  _openContextMenu(event) {
+    if (event.button === 2) {
+      this._openedBy = "mouse";
+    } else {
+      this._openedBy = event.button === 0 ? "keyboard" : void 0;
+    }
+    this._initializePoint(event.clientX, event.clientY);
+    this._triggerPressedControl = event.ctrlKey;
+    super._openMenu(true);
+    this._scrollSubscription?.unsubscribe();
+    this._scrollSubscription = this._scrollDispatcher.scrolled(0).subscribe(() => {
+      const position = this._viewportRuler.getViewportScrollPosition();
+      const point = this._point;
+      point.y = point.initialY + (point.initialScrollY - position.top);
+      point.x = point.initialX + (point.initialScrollX - position.left);
+      this._updatePosition();
+    });
+  }
+  /** Initializes the point representing the origin relative to which the menu will be rendered. */
+  _initializePoint(x, y) {
+    const scrollPosition = this._viewportRuler.getViewportScrollPosition();
+    const point = this._point;
+    point.x = point.initialX = x;
+    point.y = point.initialY = y;
+    point.initialScrollX = scrollPosition.left;
+    point.initialScrollY = scrollPosition.top;
+  }
+  /** Refreshes the position of the overlay. */
+  _updatePosition() {
+    const overlayRef = this._overlayRef;
+    if (overlayRef) {
+      const positionStrategy = overlayRef.getConfig().positionStrategy;
+      positionStrategy.setOrigin(this._point);
+      overlayRef.updatePosition();
+    }
+  }
+  static \u0275fac = function MatContextMenuTrigger_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _MatContextMenuTrigger)();
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _MatContextMenuTrigger,
+    selectors: [["", "matContextMenuTriggerFor", ""]],
+    hostAttrs: [1, "mat-context-menu-trigger"],
+    hostVars: 3,
+    hostBindings: function MatContextMenuTrigger_HostBindings(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275listener("contextmenu", function MatContextMenuTrigger_contextmenu_HostBindingHandler($event) {
+          return ctx._handleContextMenuEvent($event);
+        });
+      }
+      if (rf & 2) {
+        \u0275\u0275attribute("aria-controls", ctx.menuOpen ? ctx.menu == null ? null : ctx.menu.panelId : null);
+        \u0275\u0275classProp("mat-context-menu-trigger-disabled", ctx.disabled);
+      }
+    },
+    inputs: {
+      menu: [0, "matContextMenuTriggerFor", "menu"],
+      menuData: [0, "matContextMenuTriggerData", "menuData"],
+      restoreFocus: [0, "matContextMenuTriggerRestoreFocus", "restoreFocus"],
+      disabled: [2, "matContextMenuTriggerDisabled", "disabled", booleanAttribute]
+    },
+    outputs: {
+      menuOpened: "menuOpened",
+      menuClosed: "menuClosed"
+    },
+    exportAs: ["matContextMenuTrigger"],
+    features: [\u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MatContextMenuTrigger, [{
+    type: Directive,
+    args: [{
+      selector: "[matContextMenuTriggerFor]",
+      host: {
+        "class": "mat-context-menu-trigger",
+        "[class.mat-context-menu-trigger-disabled]": "disabled",
+        "[attr.aria-controls]": "menuOpen ? menu?.panelId : null",
+        "(contextmenu)": "_handleContextMenuEvent($event)"
+      },
+      exportAs: "matContextMenuTrigger"
+    }]
+  }], () => [], {
+    menu: [{
+      type: Input,
+      args: [{
+        alias: "matContextMenuTriggerFor",
+        required: true
+      }]
+    }],
+    menuData: [{
+      type: Input,
+      args: ["matContextMenuTriggerData"]
+    }],
+    restoreFocus: [{
+      type: Input,
+      args: ["matContextMenuTriggerRestoreFocus"]
+    }],
+    disabled: [{
+      type: Input,
+      args: [{
+        alias: "matContextMenuTriggerDisabled",
+        transform: booleanAttribute
+      }]
+    }],
+    menuOpened: [{
+      type: Output
+    }],
+    menuClosed: [{
+      type: Output
+    }]
+  });
+})();
+var MatMenuModule = class _MatMenuModule {
+  static \u0275fac = function MatMenuModule_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _MatMenuModule)();
+  };
+  static \u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
+    type: _MatMenuModule,
+    imports: [MatRippleModule, MatCommonModule, OverlayModule, MatMenu, MatMenuItem, MatMenuContent, MatMenuTrigger, MatContextMenuTrigger],
+    exports: [CdkScrollableModule, MatMenu, MatCommonModule, MatMenuItem, MatMenuContent, MatMenuTrigger, MatContextMenuTrigger]
+  });
+  static \u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
+    providers: [MAT_MENU_SCROLL_STRATEGY_FACTORY_PROVIDER],
+    imports: [MatRippleModule, MatCommonModule, OverlayModule, CdkScrollableModule, MatCommonModule]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MatMenuModule, [{
+    type: NgModule,
+    args: [{
+      imports: [MatRippleModule, MatCommonModule, OverlayModule, MatMenu, MatMenuItem, MatMenuContent, MatMenuTrigger, MatContextMenuTrigger],
+      exports: [CdkScrollableModule, MatMenu, MatCommonModule, MatMenuItem, MatMenuContent, MatMenuTrigger, MatContextMenuTrigger],
+      providers: [MAT_MENU_SCROLL_STRATEGY_FACTORY_PROVIDER]
+    }]
+  }], null, null);
+})();
+var matMenuAnimations = {
+  // Represents:
+  // trigger('transformMenu', [
+  //   state(
+  //     'void',
+  //     style({
+  //       opacity: 0,
+  //       transform: 'scale(0.8)',
+  //     }),
+  //   ),
+  //   transition(
+  //     'void => enter',
+  //     animate(
+  //       '120ms cubic-bezier(0, 0, 0.2, 1)',
+  //       style({
+  //         opacity: 1,
+  //         transform: 'scale(1)',
+  //       }),
+  //     ),
+  //   ),
+  //   transition('* => void', animate('100ms 25ms linear', style({opacity: 0}))),
+  // ])
+  /**
+   * This animation controls the menu panel's entry and exit from the page.
+   *
+   * When the menu panel is added to the DOM, it scales in and fades in its border.
+   *
+   * When the menu panel is removed from the DOM, it simply fades out after a brief
+   * delay to display the ripple.
+   */
+  transformMenu: {
+    type: 7,
+    name: "transformMenu",
+    definitions: [{
+      type: 0,
+      name: "void",
+      styles: {
+        type: 6,
+        styles: {
+          opacity: 0,
+          transform: "scale(0.8)"
+        },
+        offset: null
+      }
+    }, {
+      type: 1,
+      expr: "void => enter",
+      animation: {
+        type: 4,
+        styles: {
+          type: 6,
+          styles: {
+            opacity: 1,
+            transform: "scale(1)"
+          },
+          offset: null
+        },
+        timings: "120ms cubic-bezier(0, 0, 0.2, 1)"
+      },
+      options: null
+    }, {
+      type: 1,
+      expr: "* => void",
+      animation: {
+        type: 4,
+        styles: {
+          type: 6,
+          styles: {
+            opacity: 0
+          },
+          offset: null
+        },
+        timings: "100ms 25ms linear"
+      },
+      options: null
+    }],
+    options: {}
+  },
+  // Represents:
+  // trigger('fadeInItems', [
+  //   // TODO(crisbeto): this is inside the `transformMenu`
+  //   // now. Remove next time we do breaking changes.
+  //   state('showing', style({opacity: 1})),
+  //   transition('void => *', [
+  //     style({opacity: 0}),
+  //     animate('400ms 100ms cubic-bezier(0.55, 0, 0.55, 0.2)'),
+  //   ]),
+  // ])
+  /**
+   * This animation fades in the background color and content of the menu panel
+   * after its containing element is scaled in.
+   */
+  fadeInItems: {
+    type: 7,
+    name: "fadeInItems",
+    definitions: [{
+      type: 0,
+      name: "showing",
+      styles: {
+        type: 6,
+        styles: {
+          opacity: 1
+        },
+        offset: null
+      }
+    }, {
+      type: 1,
+      expr: "void => *",
+      animation: [{
+        type: 6,
+        styles: {
+          opacity: 0
+        },
+        offset: null
+      }, {
+        type: 4,
+        styles: null,
+        timings: "400ms 100ms cubic-bezier(0.55, 0, 0.55, 0.2)"
+      }],
+      options: null
+    }],
+    options: {}
+  }
+};
+var fadeInItems = matMenuAnimations.fadeInItems;
+var transformMenu = matMenuAnimations.transformMenu;
+
+export {
+  MarkdownComponent,
+  provideMarkdown,
+  MatMenuItem,
+  MatMenuContent,
+  MatMenu,
+  MatMenuTrigger,
+  MatMenuModule
+};
+//# sourceMappingURL=chunk-YZXYVP72.js.map