@inkandswitch/patchwork-pkg-base 0.0.86 → 0.0.88

package/packages/file/dist/typescript-language-server-oTU8pKzb.js

@@ -0,0 +1,3408 @@
+var wt = Object.defineProperty;
+var vt = (n, e, t) => e in n ? wt(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var w = (n, e, t) => vt(n, typeof e != "symbol" ? e + "" : e, t);
+import { showPanel as Ke, EditorView as le, Decoration as N, hoverTooltip as Ue, WidgetType as yt, keymap as We, ViewPlugin as ke, showDialog as xe, getDialog as St, showTooltip as Ct } from "@codemirror/view";
+import { StateEffect as I, StateField as be, Facet as Qe, combineConfig as Rt, RangeSetBuilder as Tt, ChangeSet as ue, MapMode as ze, EditorState as Pt, Prec as $t } from "@codemirror/state";
+import { indentUnit as At, getIndentUnit as _t, language as we, highlightingFor as Je } from "@codemirror/language";
+import { c as D, a as Ee, s as Dt, i as zt, h as Xe } from "./tool-B3O4i8l2.js";
+function ve() {
+  return {
+    async: !1,
+    breaks: !1,
+    extensions: null,
+    gfm: !0,
+    hooks: null,
+    pedantic: !1,
+    renderer: null,
+    silent: !1,
+    tokenizer: null,
+    walkTokens: null
+  };
+}
+var O = ve();
+function Ye(n) {
+  O = n;
+}
+var G = { exec: () => null };
+function x(n, e = "") {
+  let t = typeof n == "string" ? n : n.source;
+  const i = {
+    replace: (r, s) => {
+      let o = typeof s == "string" ? s : s.source;
+      return o = o.replace(R.caret, "$1"), t = t.replace(r, o), i;
+    },
+    getRegex: () => new RegExp(t, e)
+  };
+  return i;
+}
+var R = {
+  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: (n) => new RegExp(`^( {0,3}${n})((?:[	 ][^\\n]*)?(?:\\n|$))`),
+  nextBulletRegex: (n) => new RegExp(`^ {0,${Math.min(3, n - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`),
+  hrRegex: (n) => new RegExp(`^ {0,${Math.min(3, n - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`),
+  fencesBeginRegex: (n) => new RegExp(`^ {0,${Math.min(3, n - 1)}}(?:\`\`\`|~~~)`),
+  headingBeginRegex: (n) => new RegExp(`^ {0,${Math.min(3, n - 1)}}#`),
+  htmlBeginRegex: (n) => new RegExp(`^ {0,${Math.min(3, n - 1)}}<(?:[a-z].*>|!--)`, "i")
+}, Et = /^(?:[ \t]*(?:\n|$))+/, Lt = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/, qt = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/, W = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/, It = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/, ye = /(?:[*+-]|\d{1,9}[.)])/, et = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/, tt = x(et).replace(/bull/g, ye).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(), Mt = x(et).replace(/bull/g, ye).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(), Se = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/, Ft = /^[^\n]+/, Ce = /(?!\s*\])(?:\\.|[^\[\]\\])+/, Bt = x(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", Ce).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(), Ot = x(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, ye).getRegex(), oe = "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", Re = /<!--(?:-?>|[\s\S]*?(?:-->|$))/, Ht = x(
+  "^ {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", Re).replace("tag", oe).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(), nt = x(Se).replace("hr", W).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", oe).getRegex(), Nt = x(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", nt).getRegex(), Te = {
+  blockquote: Nt,
+  code: Lt,
+  def: Bt,
+  fences: qt,
+  heading: It,
+  hr: W,
+  html: Ht,
+  lheading: tt,
+  list: Ot,
+  newline: Et,
+  paragraph: nt,
+  table: G,
+  text: Ft
+}, Le = x(
+  "^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)"
+).replace("hr", W).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", oe).getRegex(), jt = {
+  ...Te,
+  lheading: Mt,
+  table: Le,
+  paragraph: x(Se).replace("hr", W).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", Le).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", oe).getRegex()
+}, Zt = {
+  ...Te,
+  html: x(
+    `^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`
+  ).replace("comment", Re).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: G,
+  // fences not supported
+  lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
+  paragraph: x(Se).replace("hr", W).replace("heading", ` *#{1,6} *[^
+]`).replace("lheading", tt).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex()
+}, Vt = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/, Gt = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/, it = /^( {2,}|\\)\n(?!\s*$)/, Kt = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/, ae = /[\p{P}\p{S}]/u, Pe = /[\s\p{P}\p{S}]/u, rt = /[^\s\p{P}\p{S}]/u, Ut = x(/^((?![*_])punctSpace)/, "u").replace(/punctSpace/g, Pe).getRegex(), st = /(?!~)[\p{P}\p{S}]/u, Wt = /(?!~)[\s\p{P}\p{S}]/u, Qt = /(?:[^\s\p{P}\p{S}]|~)/u, Jt = /\[[^[\]]*?\]\((?:\\.|[^\\\(\)]|\((?:\\.|[^\\\(\)])*\))*\)|`[^`]*?`|<[^<>]*?>/g, lt = /^(?:\*+(?:((?!\*)punct)|[^\s*]))|^_+(?:((?!_)punct)|([^\s_]))/, Xt = x(lt, "u").replace(/punct/g, ae).getRegex(), Yt = x(lt, "u").replace(/punct/g, st).getRegex(), ot = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)", en = x(ot, "gu").replace(/notPunctSpace/g, rt).replace(/punctSpace/g, Pe).replace(/punct/g, ae).getRegex(), tn = x(ot, "gu").replace(/notPunctSpace/g, Qt).replace(/punctSpace/g, Wt).replace(/punct/g, st).getRegex(), nn = x(
+  "^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)",
+  "gu"
+).replace(/notPunctSpace/g, rt).replace(/punctSpace/g, Pe).replace(/punct/g, ae).getRegex(), rn = x(/\\(punct)/, "gu").replace(/punct/g, ae).getRegex(), sn = x(/^<(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(), ln = x(Re).replace("(?:-->|$)", "-->").getRegex(), on = x(
+  "^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", ln).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(), te = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/, an = x(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]*(?:\n[ \t]*)?)(title))?\s*\)/).replace("label", te).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(), at = x(/^!?\[(label)\]\[(ref)\]/).replace("label", te).replace("ref", Ce).getRegex(), ct = x(/^!?\[(ref)\](?:\[\])?/).replace("ref", Ce).getRegex(), cn = x("reflink|nolink(?!\\()", "g").replace("reflink", at).replace("nolink", ct).getRegex(), $e = {
+  _backpedal: G,
+  // only used for GFM url
+  anyPunctuation: rn,
+  autolink: sn,
+  blockSkip: Jt,
+  br: it,
+  code: Gt,
+  del: G,
+  emStrongLDelim: Xt,
+  emStrongRDelimAst: en,
+  emStrongRDelimUnd: nn,
+  escape: Vt,
+  link: an,
+  nolink: ct,
+  punctuation: Ut,
+  reflink: at,
+  reflinkSearch: cn,
+  tag: on,
+  text: Kt,
+  url: G
+}, un = {
+  ...$e,
+  link: x(/^!?\[(label)\]\((.*?)\)/).replace("label", te).getRegex(),
+  reflink: x(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", te).getRegex()
+}, pe = {
+  ...$e,
+  emStrongRDelimAst: tn,
+  emStrongLDelim: Yt,
+  url: x(/^((?: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.!#$%&'*+\/=?_`{\|}~-]+@)))/
+}, pn = {
+  ...pe,
+  br: x(it).replace("{2,}", "*").getRegex(),
+  text: x(pe.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex()
+}, Q = {
+  normal: Te,
+  gfm: jt,
+  pedantic: Zt
+}, Z = {
+  normal: $e,
+  gfm: pe,
+  breaks: pn,
+  pedantic: un
+}, hn = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+}, qe = (n) => hn[n];
+function _(n, e) {
+  if (e) {
+    if (R.escapeTest.test(n))
+      return n.replace(R.escapeReplace, qe);
+  } else if (R.escapeTestNoEncode.test(n))
+    return n.replace(R.escapeReplaceNoEncode, qe);
+  return n;
+}
+function Ie(n) {
+  try {
+    n = encodeURI(n).replace(R.percentDecode, "%");
+  } catch {
+    return null;
+  }
+  return n;
+}
+function Me(n, e) {
+  var s;
+  const t = n.replace(R.findPipe, (o, l, u) => {
+    let a = !1, c = l;
+    for (; --c >= 0 && u[c] === "\\"; ) a = !a;
+    return a ? "|" : " |";
+  }), i = t.split(R.splitPipe);
+  let r = 0;
+  if (i[0].trim() || i.shift(), i.length > 0 && !((s = i.at(-1)) != null && s.trim()) && i.pop(), e)
+    if (i.length > e)
+      i.splice(e);
+    else
+      for (; i.length < e; ) i.push("");
+  for (; r < i.length; r++)
+    i[r] = i[r].trim().replace(R.slashPipe, "|");
+  return i;
+}
+function V(n, e, t) {
+  const i = n.length;
+  if (i === 0)
+    return "";
+  let r = 0;
+  for (; r < i && n.charAt(i - r - 1) === e; )
+    r++;
+  return n.slice(0, i - r);
+}
+function fn(n, e) {
+  if (n.indexOf(e[1]) === -1)
+    return -1;
+  let t = 0;
+  for (let i = 0; i < n.length; i++)
+    if (n[i] === "\\")
+      i++;
+    else if (n[i] === e[0])
+      t++;
+    else if (n[i] === e[1] && (t--, t < 0))
+      return i;
+  return t > 0 ? -2 : -1;
+}
+function Fe(n, e, t, i, r) {
+  const s = e.href, o = e.title || null, l = n[1].replace(r.other.outputLinkReplace, "$1");
+  i.state.inLink = !0;
+  const u = {
+    type: n[0].charAt(0) === "!" ? "image" : "link",
+    raw: t,
+    href: s,
+    title: o,
+    text: l,
+    tokens: i.inlineTokens(l)
+  };
+  return i.state.inLink = !1, u;
+}
+function dn(n, e, t) {
+  const i = n.match(t.other.indentCodeCompensation);
+  if (i === null)
+    return e;
+  const r = i[1];
+  return e.split(`
+`).map((s) => {
+    const o = s.match(t.other.beginningSpace);
+    if (o === null)
+      return s;
+    const [l] = o;
+    return l.length >= r.length ? s.slice(r.length) : s;
+  }).join(`
+`);
+}
+var ne = class {
+  // set by the lexer
+  constructor(n) {
+    w(this, "options");
+    w(this, "rules");
+    // set by the lexer
+    w(this, "lexer");
+    this.options = n || O;
+  }
+  space(n) {
+    const e = this.rules.block.newline.exec(n);
+    if (e && e[0].length > 0)
+      return {
+        type: "space",
+        raw: e[0]
+      };
+  }
+  code(n) {
+    const e = this.rules.block.code.exec(n);
+    if (e) {
+      const t = e[0].replace(this.rules.other.codeRemoveIndent, "");
+      return {
+        type: "code",
+        raw: e[0],
+        codeBlockStyle: "indented",
+        text: this.options.pedantic ? t : V(t, `
+`)
+      };
+    }
+  }
+  fences(n) {
+    const e = this.rules.block.fences.exec(n);
+    if (e) {
+      const t = e[0], i = dn(t, e[3] || "", this.rules);
+      return {
+        type: "code",
+        raw: t,
+        lang: e[2] ? e[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : e[2],
+        text: i
+      };
+    }
+  }
+  heading(n) {
+    const e = this.rules.block.heading.exec(n);
+    if (e) {
+      let t = e[2].trim();
+      if (this.rules.other.endingHash.test(t)) {
+        const i = V(t, "#");
+        (this.options.pedantic || !i || this.rules.other.endingSpaceChar.test(i)) && (t = i.trim());
+      }
+      return {
+        type: "heading",
+        raw: e[0],
+        depth: e[1].length,
+        text: t,
+        tokens: this.lexer.inline(t)
+      };
+    }
+  }
+  hr(n) {
+    const e = this.rules.block.hr.exec(n);
+    if (e)
+      return {
+        type: "hr",
+        raw: V(e[0], `
+`)
+      };
+  }
+  blockquote(n) {
+    const e = this.rules.block.blockquote.exec(n);
+    if (e) {
+      let t = V(e[0], `
+`).split(`
+`), i = "", r = "";
+      const s = [];
+      for (; t.length > 0; ) {
+        let o = !1;
+        const l = [];
+        let u;
+        for (u = 0; u < t.length; u++)
+          if (this.rules.other.blockquoteStart.test(t[u]))
+            l.push(t[u]), o = !0;
+          else if (!o)
+            l.push(t[u]);
+          else
+            break;
+        t = t.slice(u);
+        const a = l.join(`
+`), c = a.replace(this.rules.other.blockquoteSetextReplace, `
+    $1`).replace(this.rules.other.blockquoteSetextReplace2, "");
+        i = i ? `${i}
+${a}` : a, r = r ? `${r}
+${c}` : c;
+        const d = this.lexer.state.top;
+        if (this.lexer.state.top = !0, this.lexer.blockTokens(c, s, !0), this.lexer.state.top = d, t.length === 0)
+          break;
+        const p = s.at(-1);
+        if ((p == null ? void 0 : p.type) === "code")
+          break;
+        if ((p == null ? void 0 : p.type) === "blockquote") {
+          const h = p, f = h.raw + `
+` + t.join(`
+`), g = this.blockquote(f);
+          s[s.length - 1] = g, i = i.substring(0, i.length - h.raw.length) + g.raw, r = r.substring(0, r.length - h.text.length) + g.text;
+          break;
+        } else if ((p == null ? void 0 : p.type) === "list") {
+          const h = p, f = h.raw + `
+` + t.join(`
+`), g = this.list(f);
+          s[s.length - 1] = g, i = i.substring(0, i.length - p.raw.length) + g.raw, r = r.substring(0, r.length - h.raw.length) + g.raw, t = f.substring(s.at(-1).raw.length).split(`
+`);
+          continue;
+        }
+      }
+      return {
+        type: "blockquote",
+        raw: i,
+        tokens: s,
+        text: r
+      };
+    }
+  }
+  list(n) {
+    let e = this.rules.block.list.exec(n);
+    if (e) {
+      let t = e[1].trim();
+      const i = t.length > 1, r = {
+        type: "list",
+        raw: "",
+        ordered: i,
+        start: i ? +t.slice(0, -1) : "",
+        loose: !1,
+        items: []
+      };
+      t = i ? `\\d{1,9}\\${t.slice(-1)}` : `\\${t}`, this.options.pedantic && (t = i ? t : "[*+-]");
+      const s = this.rules.other.listItemRegex(t);
+      let o = !1;
+      for (; n; ) {
+        let u = !1, a = "", c = "";
+        if (!(e = s.exec(n)) || this.rules.block.hr.test(n))
+          break;
+        a = e[0], n = n.substring(a.length);
+        let d = e[2].split(`
+`, 1)[0].replace(this.rules.other.listReplaceTabs, (y) => " ".repeat(3 * y.length)), p = n.split(`
+`, 1)[0], h = !d.trim(), f = 0;
+        if (this.options.pedantic ? (f = 2, c = d.trimStart()) : h ? f = e[1].length + 1 : (f = e[2].search(this.rules.other.nonSpaceChar), f = f > 4 ? 1 : f, c = d.slice(f), f += e[1].length), h && this.rules.other.blankLine.test(p) && (a += p + `
+`, n = n.substring(p.length + 1), u = !0), !u) {
+          const y = this.rules.other.nextBulletRegex(f), S = this.rules.other.hrRegex(f), m = this.rules.other.fencesBeginRegex(f), v = this.rules.other.headingBeginRegex(f), T = this.rules.other.htmlBeginRegex(f);
+          for (; n; ) {
+            const P = n.split(`
+`, 1)[0];
+            let $;
+            if (p = P, this.options.pedantic ? (p = p.replace(this.rules.other.listReplaceNesting, "  "), $ = p) : $ = p.replace(this.rules.other.tabCharGlobal, "    "), m.test(p) || v.test(p) || T.test(p) || y.test(p) || S.test(p))
+              break;
+            if ($.search(this.rules.other.nonSpaceChar) >= f || !p.trim())
+              c += `
+` + $.slice(f);
+            else {
+              if (h || d.replace(this.rules.other.tabCharGlobal, "    ").search(this.rules.other.nonSpaceChar) >= 4 || m.test(d) || v.test(d) || S.test(d))
+                break;
+              c += `
+` + p;
+            }
+            !h && !p.trim() && (h = !0), a += P + `
+`, n = n.substring(P.length + 1), d = $.slice(f);
+          }
+        }
+        r.loose || (o ? r.loose = !0 : this.rules.other.doubleBlankLine.test(a) && (o = !0));
+        let g = null, k;
+        this.options.gfm && (g = this.rules.other.listIsTask.exec(c), g && (k = g[0] !== "[ ] ", c = c.replace(this.rules.other.listReplaceTask, ""))), r.items.push({
+          type: "list_item",
+          raw: a,
+          task: !!g,
+          checked: k,
+          loose: !1,
+          text: c,
+          tokens: []
+        }), r.raw += a;
+      }
+      const l = r.items.at(-1);
+      if (l)
+        l.raw = l.raw.trimEnd(), l.text = l.text.trimEnd();
+      else
+        return;
+      r.raw = r.raw.trimEnd();
+      for (let u = 0; u < r.items.length; u++)
+        if (this.lexer.state.top = !1, r.items[u].tokens = this.lexer.blockTokens(r.items[u].text, []), !r.loose) {
+          const a = r.items[u].tokens.filter((d) => d.type === "space"), c = a.length > 0 && a.some((d) => this.rules.other.anyLine.test(d.raw));
+          r.loose = c;
+        }
+      if (r.loose)
+        for (let u = 0; u < r.items.length; u++)
+          r.items[u].loose = !0;
+      return r;
+    }
+  }
+  html(n) {
+    const e = this.rules.block.html.exec(n);
+    if (e)
+      return {
+        type: "html",
+        block: !0,
+        raw: e[0],
+        pre: e[1] === "pre" || e[1] === "script" || e[1] === "style",
+        text: e[0]
+      };
+  }
+  def(n) {
+    const e = this.rules.block.def.exec(n);
+    if (e) {
+      const t = e[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, " "), i = e[2] ? e[2].replace(this.rules.other.hrefBrackets, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "", r = e[3] ? e[3].substring(1, e[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : e[3];
+      return {
+        type: "def",
+        tag: t,
+        raw: e[0],
+        href: i,
+        title: r
+      };
+    }
+  }
+  table(n) {
+    var o;
+    const e = this.rules.block.table.exec(n);
+    if (!e || !this.rules.other.tableDelimiter.test(e[2]))
+      return;
+    const t = Me(e[1]), i = e[2].replace(this.rules.other.tableAlignChars, "").split("|"), r = (o = e[3]) != null && o.trim() ? e[3].replace(this.rules.other.tableRowBlankLine, "").split(`
+`) : [], s = {
+      type: "table",
+      raw: e[0],
+      header: [],
+      align: [],
+      rows: []
+    };
+    if (t.length === i.length) {
+      for (const l of i)
+        this.rules.other.tableAlignRight.test(l) ? s.align.push("right") : this.rules.other.tableAlignCenter.test(l) ? s.align.push("center") : this.rules.other.tableAlignLeft.test(l) ? s.align.push("left") : s.align.push(null);
+      for (let l = 0; l < t.length; l++)
+        s.header.push({
+          text: t[l],
+          tokens: this.lexer.inline(t[l]),
+          header: !0,
+          align: s.align[l]
+        });
+      for (const l of r)
+        s.rows.push(Me(l, s.header.length).map((u, a) => ({
+          text: u,
+          tokens: this.lexer.inline(u),
+          header: !1,
+          align: s.align[a]
+        })));
+      return s;
+    }
+  }
+  lheading(n) {
+    const e = this.rules.block.lheading.exec(n);
+    if (e)
+      return {
+        type: "heading",
+        raw: e[0],
+        depth: e[2].charAt(0) === "=" ? 1 : 2,
+        text: e[1],
+        tokens: this.lexer.inline(e[1])
+      };
+  }
+  paragraph(n) {
+    const e = this.rules.block.paragraph.exec(n);
+    if (e) {
+      const t = e[1].charAt(e[1].length - 1) === `
+` ? e[1].slice(0, -1) : e[1];
+      return {
+        type: "paragraph",
+        raw: e[0],
+        text: t,
+        tokens: this.lexer.inline(t)
+      };
+    }
+  }
+  text(n) {
+    const e = this.rules.block.text.exec(n);
+    if (e)
+      return {
+        type: "text",
+        raw: e[0],
+        text: e[0],
+        tokens: this.lexer.inline(e[0])
+      };
+  }
+  escape(n) {
+    const e = this.rules.inline.escape.exec(n);
+    if (e)
+      return {
+        type: "escape",
+        raw: e[0],
+        text: e[1]
+      };
+  }
+  tag(n) {
+    const e = this.rules.inline.tag.exec(n);
+    if (e)
+      return !this.lexer.state.inLink && this.rules.other.startATag.test(e[0]) ? this.lexer.state.inLink = !0 : this.lexer.state.inLink && this.rules.other.endATag.test(e[0]) && (this.lexer.state.inLink = !1), !this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(e[0]) ? this.lexer.state.inRawBlock = !0 : this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(e[0]) && (this.lexer.state.inRawBlock = !1), {
+        type: "html",
+        raw: e[0],
+        inLink: this.lexer.state.inLink,
+        inRawBlock: this.lexer.state.inRawBlock,
+        block: !1,
+        text: e[0]
+      };
+  }
+  link(n) {
+    const e = this.rules.inline.link.exec(n);
+    if (e) {
+      const t = e[2].trim();
+      if (!this.options.pedantic && this.rules.other.startAngleBracket.test(t)) {
+        if (!this.rules.other.endAngleBracket.test(t))
+          return;
+        const s = V(t.slice(0, -1), "\\");
+        if ((t.length - s.length) % 2 === 0)
+          return;
+      } else {
+        const s = fn(e[2], "()");
+        if (s === -2)
+          return;
+        if (s > -1) {
+          const l = (e[0].indexOf("!") === 0 ? 5 : 4) + e[1].length + s;
+          e[2] = e[2].substring(0, s), e[0] = e[0].substring(0, l).trim(), e[3] = "";
+        }
+      }
+      let i = e[2], r = "";
+      if (this.options.pedantic) {
+        const s = this.rules.other.pedanticHrefTitle.exec(i);
+        s && (i = s[1], r = s[3]);
+      } else
+        r = e[3] ? e[3].slice(1, -1) : "";
+      return i = i.trim(), this.rules.other.startAngleBracket.test(i) && (this.options.pedantic && !this.rules.other.endAngleBracket.test(t) ? i = i.slice(1) : i = i.slice(1, -1)), Fe(e, {
+        href: i && i.replace(this.rules.inline.anyPunctuation, "$1"),
+        title: r && r.replace(this.rules.inline.anyPunctuation, "$1")
+      }, e[0], this.lexer, this.rules);
+    }
+  }
+  reflink(n, e) {
+    let t;
+    if ((t = this.rules.inline.reflink.exec(n)) || (t = this.rules.inline.nolink.exec(n))) {
+      const i = (t[2] || t[1]).replace(this.rules.other.multipleSpaceGlobal, " "), r = e[i.toLowerCase()];
+      if (!r) {
+        const s = t[0].charAt(0);
+        return {
+          type: "text",
+          raw: s,
+          text: s
+        };
+      }
+      return Fe(t, r, t[0], this.lexer, this.rules);
+    }
+  }
+  emStrong(n, e, t = "") {
+    let i = this.rules.inline.emStrongLDelim.exec(n);
+    if (!i || i[3] && t.match(this.rules.other.unicodeAlphaNumeric)) return;
+    if (!(i[1] || i[2] || "") || !t || this.rules.inline.punctuation.exec(t)) {
+      const s = [...i[0]].length - 1;
+      let o, l, u = s, a = 0;
+      const c = i[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
+      for (c.lastIndex = 0, e = e.slice(-1 * n.length + s); (i = c.exec(e)) != null; ) {
+        if (o = i[1] || i[2] || i[3] || i[4] || i[5] || i[6], !o) continue;
+        if (l = [...o].length, i[3] || i[4]) {
+          u += l;
+          continue;
+        } else if ((i[5] || i[6]) && s % 3 && !((s + l) % 3)) {
+          a += l;
+          continue;
+        }
+        if (u -= l, u > 0) continue;
+        l = Math.min(l, l + u + a);
+        const d = [...i[0]][0].length, p = n.slice(0, s + i.index + d + l);
+        if (Math.min(s, l) % 2) {
+          const f = p.slice(1, -1);
+          return {
+            type: "em",
+            raw: p,
+            text: f,
+            tokens: this.lexer.inlineTokens(f)
+          };
+        }
+        const h = p.slice(2, -2);
+        return {
+          type: "strong",
+          raw: p,
+          text: h,
+          tokens: this.lexer.inlineTokens(h)
+        };
+      }
+    }
+  }
+  codespan(n) {
+    const e = this.rules.inline.code.exec(n);
+    if (e) {
+      let t = e[2].replace(this.rules.other.newLineCharGlobal, " ");
+      const i = this.rules.other.nonSpaceChar.test(t), r = this.rules.other.startingSpaceChar.test(t) && this.rules.other.endingSpaceChar.test(t);
+      return i && r && (t = t.substring(1, t.length - 1)), {
+        type: "codespan",
+        raw: e[0],
+        text: t
+      };
+    }
+  }
+  br(n) {
+    const e = this.rules.inline.br.exec(n);
+    if (e)
+      return {
+        type: "br",
+        raw: e[0]
+      };
+  }
+  del(n) {
+    const e = this.rules.inline.del.exec(n);
+    if (e)
+      return {
+        type: "del",
+        raw: e[0],
+        text: e[2],
+        tokens: this.lexer.inlineTokens(e[2])
+      };
+  }
+  autolink(n) {
+    const e = this.rules.inline.autolink.exec(n);
+    if (e) {
+      let t, i;
+      return e[2] === "@" ? (t = e[1], i = "mailto:" + t) : (t = e[1], i = t), {
+        type: "link",
+        raw: e[0],
+        text: t,
+        href: i,
+        tokens: [
+          {
+            type: "text",
+            raw: t,
+            text: t
+          }
+        ]
+      };
+    }
+  }
+  url(n) {
+    var t;
+    let e;
+    if (e = this.rules.inline.url.exec(n)) {
+      let i, r;
+      if (e[2] === "@")
+        i = e[0], r = "mailto:" + i;
+      else {
+        let s;
+        do
+          s = e[0], e[0] = ((t = this.rules.inline._backpedal.exec(e[0])) == null ? void 0 : t[0]) ?? "";
+        while (s !== e[0]);
+        i = e[0], e[1] === "www." ? r = "http://" + e[0] : r = e[0];
+      }
+      return {
+        type: "link",
+        raw: e[0],
+        text: i,
+        href: r,
+        tokens: [
+          {
+            type: "text",
+            raw: i,
+            text: i
+          }
+        ]
+      };
+    }
+  }
+  inlineText(n) {
+    const e = this.rules.inline.text.exec(n);
+    if (e) {
+      const t = this.lexer.state.inRawBlock;
+      return {
+        type: "text",
+        raw: e[0],
+        text: e[0],
+        escaped: t
+      };
+    }
+  }
+}, z = class he {
+  constructor(e) {
+    w(this, "tokens");
+    w(this, "options");
+    w(this, "state");
+    w(this, "tokenizer");
+    w(this, "inlineQueue");
+    this.tokens = [], this.tokens.links = /* @__PURE__ */ Object.create(null), this.options = e || O, this.options.tokenizer = this.options.tokenizer || new ne(), this.tokenizer = this.options.tokenizer, this.tokenizer.options = this.options, this.tokenizer.lexer = this, this.inlineQueue = [], this.state = {
+      inLink: !1,
+      inRawBlock: !1,
+      top: !0
+    };
+    const t = {
+      other: R,
+      block: Q.normal,
+      inline: Z.normal
+    };
+    this.options.pedantic ? (t.block = Q.pedantic, t.inline = Z.pedantic) : this.options.gfm && (t.block = Q.gfm, this.options.breaks ? t.inline = Z.breaks : t.inline = Z.gfm), this.tokenizer.rules = t;
+  }
+  /**
+   * Expose Rules
+   */
+  static get rules() {
+    return {
+      block: Q,
+      inline: Z
+    };
+  }
+  /**
+   * Static Lex Method
+   */
+  static lex(e, t) {
+    return new he(t).lex(e);
+  }
+  /**
+   * Static Lex Inline Method
+   */
+  static lexInline(e, t) {
+    return new he(t).inlineTokens(e);
+  }
+  /**
+   * Preprocessing
+   */
+  lex(e) {
+    e = e.replace(R.carriageReturn, `
+`), this.blockTokens(e, this.tokens);
+    for (let t = 0; t < this.inlineQueue.length; t++) {
+      const i = this.inlineQueue[t];
+      this.inlineTokens(i.src, i.tokens);
+    }
+    return this.inlineQueue = [], this.tokens;
+  }
+  blockTokens(e, t = [], i = !1) {
+    var r, s, o;
+    for (this.options.pedantic && (e = e.replace(R.tabCharGlobal, "    ").replace(R.spaceLine, "")); e; ) {
+      let l;
+      if ((s = (r = this.options.extensions) == null ? void 0 : r.block) != null && s.some((a) => (l = a.call({ lexer: this }, e, t)) ? (e = e.substring(l.raw.length), t.push(l), !0) : !1))
+        continue;
+      if (l = this.tokenizer.space(e)) {
+        e = e.substring(l.raw.length);
+        const a = t.at(-1);
+        l.raw.length === 1 && a !== void 0 ? a.raw += `
+` : t.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.code(e)) {
+        e = e.substring(l.raw.length);
+        const a = t.at(-1);
+        (a == null ? void 0 : a.type) === "paragraph" || (a == null ? void 0 : a.type) === "text" ? (a.raw += `
+` + l.raw, a.text += `
+` + l.text, this.inlineQueue.at(-1).src = a.text) : t.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.fences(e)) {
+        e = e.substring(l.raw.length), t.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.heading(e)) {
+        e = e.substring(l.raw.length), t.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.hr(e)) {
+        e = e.substring(l.raw.length), t.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.blockquote(e)) {
+        e = e.substring(l.raw.length), t.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.list(e)) {
+        e = e.substring(l.raw.length), t.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.html(e)) {
+        e = e.substring(l.raw.length), t.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.def(e)) {
+        e = e.substring(l.raw.length);
+        const a = t.at(-1);
+        (a == null ? void 0 : a.type) === "paragraph" || (a == null ? void 0 : a.type) === "text" ? (a.raw += `
+` + l.raw, a.text += `
+` + l.raw, this.inlineQueue.at(-1).src = a.text) : this.tokens.links[l.tag] || (this.tokens.links[l.tag] = {
+          href: l.href,
+          title: l.title
+        });
+        continue;
+      }
+      if (l = this.tokenizer.table(e)) {
+        e = e.substring(l.raw.length), t.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.lheading(e)) {
+        e = e.substring(l.raw.length), t.push(l);
+        continue;
+      }
+      let u = e;
+      if ((o = this.options.extensions) != null && o.startBlock) {
+        let a = 1 / 0;
+        const c = e.slice(1);
+        let d;
+        this.options.extensions.startBlock.forEach((p) => {
+          d = p.call({ lexer: this }, c), typeof d == "number" && d >= 0 && (a = Math.min(a, d));
+        }), a < 1 / 0 && a >= 0 && (u = e.substring(0, a + 1));
+      }
+      if (this.state.top && (l = this.tokenizer.paragraph(u))) {
+        const a = t.at(-1);
+        i && (a == null ? void 0 : a.type) === "paragraph" ? (a.raw += `
+` + l.raw, a.text += `
+` + l.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = a.text) : t.push(l), i = u.length !== e.length, e = e.substring(l.raw.length);
+        continue;
+      }
+      if (l = this.tokenizer.text(e)) {
+        e = e.substring(l.raw.length);
+        const a = t.at(-1);
+        (a == null ? void 0 : a.type) === "text" ? (a.raw += `
+` + l.raw, a.text += `
+` + l.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = a.text) : t.push(l);
+        continue;
+      }
+      if (e) {
+        const a = "Infinite loop on byte: " + e.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(a);
+          break;
+        } else
+          throw new Error(a);
+      }
+    }
+    return this.state.top = !0, t;
+  }
+  inline(e, t = []) {
+    return this.inlineQueue.push({ src: e, tokens: t }), t;
+  }
+  /**
+   * Lexing/Compiling
+   */
+  inlineTokens(e, t = []) {
+    var l, u, a;
+    let i = e, r = null;
+    if (this.tokens.links) {
+      const c = Object.keys(this.tokens.links);
+      if (c.length > 0)
+        for (; (r = this.tokenizer.rules.inline.reflinkSearch.exec(i)) != null; )
+          c.includes(r[0].slice(r[0].lastIndexOf("[") + 1, -1)) && (i = i.slice(0, r.index) + "[" + "a".repeat(r[0].length - 2) + "]" + i.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex));
+    }
+    for (; (r = this.tokenizer.rules.inline.anyPunctuation.exec(i)) != null; )
+      i = i.slice(0, r.index) + "++" + i.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
+    for (; (r = this.tokenizer.rules.inline.blockSkip.exec(i)) != null; )
+      i = i.slice(0, r.index) + "[" + "a".repeat(r[0].length - 2) + "]" + i.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
+    let s = !1, o = "";
+    for (; e; ) {
+      s || (o = ""), s = !1;
+      let c;
+      if ((u = (l = this.options.extensions) == null ? void 0 : l.inline) != null && u.some((p) => (c = p.call({ lexer: this }, e, t)) ? (e = e.substring(c.raw.length), t.push(c), !0) : !1))
+        continue;
+      if (c = this.tokenizer.escape(e)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.tag(e)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.link(e)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.reflink(e, this.tokens.links)) {
+        e = e.substring(c.raw.length);
+        const p = t.at(-1);
+        c.type === "text" && (p == null ? void 0 : p.type) === "text" ? (p.raw += c.raw, p.text += c.text) : t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.emStrong(e, i, o)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.codespan(e)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.br(e)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.del(e)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.autolink(e)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (!this.state.inLink && (c = this.tokenizer.url(e))) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      let d = e;
+      if ((a = this.options.extensions) != null && a.startInline) {
+        let p = 1 / 0;
+        const h = e.slice(1);
+        let f;
+        this.options.extensions.startInline.forEach((g) => {
+          f = g.call({ lexer: this }, h), typeof f == "number" && f >= 0 && (p = Math.min(p, f));
+        }), p < 1 / 0 && p >= 0 && (d = e.substring(0, p + 1));
+      }
+      if (c = this.tokenizer.inlineText(d)) {
+        e = e.substring(c.raw.length), c.raw.slice(-1) !== "_" && (o = c.raw.slice(-1)), s = !0;
+        const p = t.at(-1);
+        (p == null ? void 0 : p.type) === "text" ? (p.raw += c.raw, p.text += c.text) : t.push(c);
+        continue;
+      }
+      if (e) {
+        const p = "Infinite loop on byte: " + e.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(p);
+          break;
+        } else
+          throw new Error(p);
+      }
+    }
+    return t;
+  }
+}, ie = class {
+  // set by the parser
+  constructor(n) {
+    w(this, "options");
+    w(this, "parser");
+    this.options = n || O;
+  }
+  space(n) {
+    return "";
+  }
+  code({ text: n, lang: e, escaped: t }) {
+    var s;
+    const i = (s = (e || "").match(R.notSpaceStart)) == null ? void 0 : s[0], r = n.replace(R.endingNewline, "") + `
+`;
+    return i ? '<pre><code class="language-' + _(i) + '">' + (t ? r : _(r, !0)) + `</code></pre>
+` : "<pre><code>" + (t ? r : _(r, !0)) + `</code></pre>
+`;
+  }
+  blockquote({ tokens: n }) {
+    return `<blockquote>
+${this.parser.parse(n)}</blockquote>
+`;
+  }
+  html({ text: n }) {
+    return n;
+  }
+  heading({ tokens: n, depth: e }) {
+    return `<h${e}>${this.parser.parseInline(n)}</h${e}>
+`;
+  }
+  hr(n) {
+    return `<hr>
+`;
+  }
+  list(n) {
+    const e = n.ordered, t = n.start;
+    let i = "";
+    for (let o = 0; o < n.items.length; o++) {
+      const l = n.items[o];
+      i += this.listitem(l);
+    }
+    const r = e ? "ol" : "ul", s = e && t !== 1 ? ' start="' + t + '"' : "";
+    return "<" + r + s + `>
+` + i + "</" + r + `>
+`;
+  }
+  listitem(n) {
+    var t;
+    let e = "";
+    if (n.task) {
+      const i = this.checkbox({ checked: !!n.checked });
+      n.loose ? ((t = n.tokens[0]) == null ? void 0 : t.type) === "paragraph" ? (n.tokens[0].text = i + " " + n.tokens[0].text, n.tokens[0].tokens && n.tokens[0].tokens.length > 0 && n.tokens[0].tokens[0].type === "text" && (n.tokens[0].tokens[0].text = i + " " + _(n.tokens[0].tokens[0].text), n.tokens[0].tokens[0].escaped = !0)) : n.tokens.unshift({
+        type: "text",
+        raw: i + " ",
+        text: i + " ",
+        escaped: !0
+      }) : e += i + " ";
+    }
+    return e += this.parser.parse(n.tokens, !!n.loose), `<li>${e}</li>
+`;
+  }
+  checkbox({ checked: n }) {
+    return "<input " + (n ? 'checked="" ' : "") + 'disabled="" type="checkbox">';
+  }
+  paragraph({ tokens: n }) {
+    return `<p>${this.parser.parseInline(n)}</p>
+`;
+  }
+  table(n) {
+    let e = "", t = "";
+    for (let r = 0; r < n.header.length; r++)
+      t += this.tablecell(n.header[r]);
+    e += this.tablerow({ text: t });
+    let i = "";
+    for (let r = 0; r < n.rows.length; r++) {
+      const s = n.rows[r];
+      t = "";
+      for (let o = 0; o < s.length; o++)
+        t += this.tablecell(s[o]);
+      i += this.tablerow({ text: t });
+    }
+    return i && (i = `<tbody>${i}</tbody>`), `<table>
+<thead>
+` + e + `</thead>
+` + i + `</table>
+`;
+  }
+  tablerow({ text: n }) {
+    return `<tr>
+${n}</tr>
+`;
+  }
+  tablecell(n) {
+    const e = this.parser.parseInline(n.tokens), t = n.header ? "th" : "td";
+    return (n.align ? `<${t} align="${n.align}">` : `<${t}>`) + e + `</${t}>
+`;
+  }
+  /**
+   * span level renderer
+   */
+  strong({ tokens: n }) {
+    return `<strong>${this.parser.parseInline(n)}</strong>`;
+  }
+  em({ tokens: n }) {
+    return `<em>${this.parser.parseInline(n)}</em>`;
+  }
+  codespan({ text: n }) {
+    return `<code>${_(n, !0)}</code>`;
+  }
+  br(n) {
+    return "<br>";
+  }
+  del({ tokens: n }) {
+    return `<del>${this.parser.parseInline(n)}</del>`;
+  }
+  link({ href: n, title: e, tokens: t }) {
+    const i = this.parser.parseInline(t), r = Ie(n);
+    if (r === null)
+      return i;
+    n = r;
+    let s = '<a href="' + n + '"';
+    return e && (s += ' title="' + _(e) + '"'), s += ">" + i + "</a>", s;
+  }
+  image({ href: n, title: e, text: t, tokens: i }) {
+    i && (t = this.parser.parseInline(i, this.parser.textRenderer));
+    const r = Ie(n);
+    if (r === null)
+      return _(t);
+    n = r;
+    let s = `<img src="${n}" alt="${t}"`;
+    return e && (s += ` title="${_(e)}"`), s += ">", s;
+  }
+  text(n) {
+    return "tokens" in n && n.tokens ? this.parser.parseInline(n.tokens) : "escaped" in n && n.escaped ? n.text : _(n.text);
+  }
+}, Ae = class {
+  // no need for block level renderers
+  strong({ text: n }) {
+    return n;
+  }
+  em({ text: n }) {
+    return n;
+  }
+  codespan({ text: n }) {
+    return n;
+  }
+  del({ text: n }) {
+    return n;
+  }
+  html({ text: n }) {
+    return n;
+  }
+  text({ text: n }) {
+    return n;
+  }
+  link({ text: n }) {
+    return "" + n;
+  }
+  image({ text: n }) {
+    return "" + n;
+  }
+  br() {
+    return "";
+  }
+}, E = class fe {
+  constructor(e) {
+    w(this, "options");
+    w(this, "renderer");
+    w(this, "textRenderer");
+    this.options = e || O, this.options.renderer = this.options.renderer || new ie(), this.renderer = this.options.renderer, this.renderer.options = this.options, this.renderer.parser = this, this.textRenderer = new Ae();
+  }
+  /**
+   * Static Parse Method
+   */
+  static parse(e, t) {
+    return new fe(t).parse(e);
+  }
+  /**
+   * Static Parse Inline Method
+   */
+  static parseInline(e, t) {
+    return new fe(t).parseInline(e);
+  }
+  /**
+   * Parse Loop
+   */
+  parse(e, t = !0) {
+    var r, s;
+    let i = "";
+    for (let o = 0; o < e.length; o++) {
+      const l = e[o];
+      if ((s = (r = this.options.extensions) == null ? void 0 : r.renderers) != null && s[l.type]) {
+        const a = l, c = this.options.extensions.renderers[a.type].call({ parser: this }, a);
+        if (c !== !1 || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "paragraph", "text"].includes(a.type)) {
+          i += c || "";
+          continue;
+        }
+      }
+      const u = l;
+      switch (u.type) {
+        case "space": {
+          i += this.renderer.space(u);
+          continue;
+        }
+        case "hr": {
+          i += this.renderer.hr(u);
+          continue;
+        }
+        case "heading": {
+          i += this.renderer.heading(u);
+          continue;
+        }
+        case "code": {
+          i += this.renderer.code(u);
+          continue;
+        }
+        case "table": {
+          i += this.renderer.table(u);
+          continue;
+        }
+        case "blockquote": {
+          i += this.renderer.blockquote(u);
+          continue;
+        }
+        case "list": {
+          i += this.renderer.list(u);
+          continue;
+        }
+        case "html": {
+          i += this.renderer.html(u);
+          continue;
+        }
+        case "paragraph": {
+          i += this.renderer.paragraph(u);
+          continue;
+        }
+        case "text": {
+          let a = u, c = this.renderer.text(a);
+          for (; o + 1 < e.length && e[o + 1].type === "text"; )
+            a = e[++o], c += `
+` + this.renderer.text(a);
+          t ? i += this.renderer.paragraph({
+            type: "paragraph",
+            raw: c,
+            text: c,
+            tokens: [{ type: "text", raw: c, text: c, escaped: !0 }]
+          }) : i += c;
+          continue;
+        }
+        default: {
+          const a = 'Token with "' + u.type + '" type was not found.';
+          if (this.options.silent)
+            return console.error(a), "";
+          throw new Error(a);
+        }
+      }
+    }
+    return i;
+  }
+  /**
+   * Parse Inline Tokens
+   */
+  parseInline(e, t = this.renderer) {
+    var r, s;
+    let i = "";
+    for (let o = 0; o < e.length; o++) {
+      const l = e[o];
+      if ((s = (r = this.options.extensions) == null ? void 0 : r.renderers) != null && s[l.type]) {
+        const a = this.options.extensions.renderers[l.type].call({ parser: this }, l);
+        if (a !== !1 || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(l.type)) {
+          i += a || "";
+          continue;
+        }
+      }
+      const u = l;
+      switch (u.type) {
+        case "escape": {
+          i += t.text(u);
+          break;
+        }
+        case "html": {
+          i += t.html(u);
+          break;
+        }
+        case "link": {
+          i += t.link(u);
+          break;
+        }
+        case "image": {
+          i += t.image(u);
+          break;
+        }
+        case "strong": {
+          i += t.strong(u);
+          break;
+        }
+        case "em": {
+          i += t.em(u);
+          break;
+        }
+        case "codespan": {
+          i += t.codespan(u);
+          break;
+        }
+        case "br": {
+          i += t.br(u);
+          break;
+        }
+        case "del": {
+          i += t.del(u);
+          break;
+        }
+        case "text": {
+          i += t.text(u);
+          break;
+        }
+        default: {
+          const a = 'Token with "' + u.type + '" type was not found.';
+          if (this.options.silent)
+            return console.error(a), "";
+          throw new Error(a);
+        }
+      }
+    }
+    return i;
+  }
+}, ce, Y = (ce = class {
+  constructor(n) {
+    w(this, "options");
+    w(this, "block");
+    this.options = n || O;
+  }
+  /**
+   * Process markdown before marked
+   */
+  preprocess(n) {
+    return n;
+  }
+  /**
+   * Process HTML after marked is finished
+   */
+  postprocess(n) {
+    return n;
+  }
+  /**
+   * Process all tokens before walk tokens
+   */
+  processAllTokens(n) {
+    return n;
+  }
+  /**
+   * Provide function to tokenize markdown
+   */
+  provideLexer() {
+    return this.block ? z.lex : z.lexInline;
+  }
+  /**
+   * Provide function to parse tokens
+   */
+  provideParser() {
+    return this.block ? E.parse : E.parseInline;
+  }
+}, w(ce, "passThroughHooks", /* @__PURE__ */ new Set([
+  "preprocess",
+  "postprocess",
+  "processAllTokens"
+])), ce), ut = class {
+  constructor(...n) {
+    w(this, "defaults", ve());
+    w(this, "options", this.setOptions);
+    w(this, "parse", this.parseMarkdown(!0));
+    w(this, "parseInline", this.parseMarkdown(!1));
+    w(this, "Parser", E);
+    w(this, "Renderer", ie);
+    w(this, "TextRenderer", Ae);
+    w(this, "Lexer", z);
+    w(this, "Tokenizer", ne);
+    w(this, "Hooks", Y);
+    this.use(...n);
+  }
+  /**
+   * Run callback for every token
+   */
+  walkTokens(n, e) {
+    var i, r;
+    let t = [];
+    for (const s of n)
+      switch (t = t.concat(e.call(this, s)), s.type) {
+        case "table": {
+          const o = s;
+          for (const l of o.header)
+            t = t.concat(this.walkTokens(l.tokens, e));
+          for (const l of o.rows)
+            for (const u of l)
+              t = t.concat(this.walkTokens(u.tokens, e));
+          break;
+        }
+        case "list": {
+          const o = s;
+          t = t.concat(this.walkTokens(o.items, e));
+          break;
+        }
+        default: {
+          const o = s;
+          (r = (i = this.defaults.extensions) == null ? void 0 : i.childTokens) != null && r[o.type] ? this.defaults.extensions.childTokens[o.type].forEach((l) => {
+            const u = o[l].flat(1 / 0);
+            t = t.concat(this.walkTokens(u, e));
+          }) : o.tokens && (t = t.concat(this.walkTokens(o.tokens, e)));
+        }
+      }
+    return t;
+  }
+  use(...n) {
+    const e = this.defaults.extensions || { renderers: {}, childTokens: {} };
+    return n.forEach((t) => {
+      const i = { ...t };
+      if (i.async = this.defaults.async || i.async || !1, t.extensions && (t.extensions.forEach((r) => {
+        if (!r.name)
+          throw new Error("extension name required");
+        if ("renderer" in r) {
+          const s = e.renderers[r.name];
+          s ? e.renderers[r.name] = function(...o) {
+            let l = r.renderer.apply(this, o);
+            return l === !1 && (l = s.apply(this, o)), l;
+          } : e.renderers[r.name] = r.renderer;
+        }
+        if ("tokenizer" in r) {
+          if (!r.level || r.level !== "block" && r.level !== "inline")
+            throw new Error("extension level must be 'block' or 'inline'");
+          const s = e[r.level];
+          s ? s.unshift(r.tokenizer) : e[r.level] = [r.tokenizer], r.start && (r.level === "block" ? e.startBlock ? e.startBlock.push(r.start) : e.startBlock = [r.start] : r.level === "inline" && (e.startInline ? e.startInline.push(r.start) : e.startInline = [r.start]));
+        }
+        "childTokens" in r && r.childTokens && (e.childTokens[r.name] = r.childTokens);
+      }), i.extensions = e), t.renderer) {
+        const r = this.defaults.renderer || new ie(this.defaults);
+        for (const s in t.renderer) {
+          if (!(s in r))
+            throw new Error(`renderer '${s}' does not exist`);
+          if (["options", "parser"].includes(s))
+            continue;
+          const o = s, l = t.renderer[o], u = r[o];
+          r[o] = (...a) => {
+            let c = l.apply(r, a);
+            return c === !1 && (c = u.apply(r, a)), c || "";
+          };
+        }
+        i.renderer = r;
+      }
+      if (t.tokenizer) {
+        const r = this.defaults.tokenizer || new ne(this.defaults);
+        for (const s in t.tokenizer) {
+          if (!(s in r))
+            throw new Error(`tokenizer '${s}' does not exist`);
+          if (["options", "rules", "lexer"].includes(s))
+            continue;
+          const o = s, l = t.tokenizer[o], u = r[o];
+          r[o] = (...a) => {
+            let c = l.apply(r, a);
+            return c === !1 && (c = u.apply(r, a)), c;
+          };
+        }
+        i.tokenizer = r;
+      }
+      if (t.hooks) {
+        const r = this.defaults.hooks || new Y();
+        for (const s in t.hooks) {
+          if (!(s in r))
+            throw new Error(`hook '${s}' does not exist`);
+          if (["options", "block"].includes(s))
+            continue;
+          const o = s, l = t.hooks[o], u = r[o];
+          Y.passThroughHooks.has(s) ? r[o] = (a) => {
+            if (this.defaults.async)
+              return Promise.resolve(l.call(r, a)).then((d) => u.call(r, d));
+            const c = l.call(r, a);
+            return u.call(r, c);
+          } : r[o] = (...a) => {
+            let c = l.apply(r, a);
+            return c === !1 && (c = u.apply(r, a)), c;
+          };
+        }
+        i.hooks = r;
+      }
+      if (t.walkTokens) {
+        const r = this.defaults.walkTokens, s = t.walkTokens;
+        i.walkTokens = function(o) {
+          let l = [];
+          return l.push(s.call(this, o)), r && (l = l.concat(r.call(this, o))), l;
+        };
+      }
+      this.defaults = { ...this.defaults, ...i };
+    }), this;
+  }
+  setOptions(n) {
+    return this.defaults = { ...this.defaults, ...n }, this;
+  }
+  lexer(n, e) {
+    return z.lex(n, e ?? this.defaults);
+  }
+  parser(n, e) {
+    return E.parse(n, e ?? this.defaults);
+  }
+  parseMarkdown(n) {
+    return (t, i) => {
+      const r = { ...i }, s = { ...this.defaults, ...r }, o = this.onError(!!s.silent, !!s.async);
+      if (this.defaults.async === !0 && r.async === !1)
+        return o(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 t > "u" || t === null)
+        return o(new Error("marked(): input parameter is undefined or null"));
+      if (typeof t != "string")
+        return o(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(t) + ", string expected"));
+      s.hooks && (s.hooks.options = s, s.hooks.block = n);
+      const l = s.hooks ? s.hooks.provideLexer() : n ? z.lex : z.lexInline, u = s.hooks ? s.hooks.provideParser() : n ? E.parse : E.parseInline;
+      if (s.async)
+        return Promise.resolve(s.hooks ? s.hooks.preprocess(t) : t).then((a) => l(a, s)).then((a) => s.hooks ? s.hooks.processAllTokens(a) : a).then((a) => s.walkTokens ? Promise.all(this.walkTokens(a, s.walkTokens)).then(() => a) : a).then((a) => u(a, s)).then((a) => s.hooks ? s.hooks.postprocess(a) : a).catch(o);
+      try {
+        s.hooks && (t = s.hooks.preprocess(t));
+        let a = l(t, s);
+        s.hooks && (a = s.hooks.processAllTokens(a)), s.walkTokens && this.walkTokens(a, s.walkTokens);
+        let c = u(a, s);
+        return s.hooks && (c = s.hooks.postprocess(c)), c;
+      } catch (a) {
+        return o(a);
+      }
+    };
+  }
+  onError(n, e) {
+    return (t) => {
+      if (t.message += `
+Please report this to https://github.com/markedjs/marked.`, n) {
+        const i = "<p>An error occurred:</p><pre>" + _(t.message + "", !0) + "</pre>";
+        return e ? Promise.resolve(i) : i;
+      }
+      if (e)
+        return Promise.reject(t);
+      throw t;
+    };
+  }
+}, B = new ut();
+function b(n, e) {
+  return B.parse(n, e);
+}
+b.options = b.setOptions = function(n) {
+  return B.setOptions(n), b.defaults = B.defaults, Ye(b.defaults), b;
+};
+b.getDefaults = ve;
+b.defaults = O;
+b.use = function(...n) {
+  return B.use(...n), b.defaults = B.defaults, Ye(b.defaults), b;
+};
+b.walkTokens = function(n, e) {
+  return B.walkTokens(n, e);
+};
+b.parseInline = B.parseInline;
+b.Parser = E;
+b.parser = E.parse;
+b.Renderer = ie;
+b.TextRenderer = Ae;
+b.Lexer = z;
+b.lexer = z.lex;
+b.Tokenizer = ne;
+b.Hooks = Y;
+b.parse = b;
+b.options;
+b.setOptions;
+b.use;
+b.walkTokens;
+b.parseInline;
+E.parse;
+z.lex;
+class Be {
+  constructor(e, t, i) {
+    this.from = e, this.to = t, this.diagnostic = i;
+  }
+}
+class F {
+  constructor(e, t, i) {
+    this.diagnostics = e, this.panel = t, this.selected = i;
+  }
+  static init(e, t, i) {
+    let r = i.facet(K).markerFilter;
+    r && (e = r(e, i));
+    let s = e.slice().sort((h, f) => h.from - f.from || h.to - f.to), o = new Tt(), l = [], u = 0, a = i.doc.iter(), c = 0, d = i.doc.length;
+    for (let h = 0; ; ) {
+      let f = h == s.length ? null : s[h];
+      if (!f && !l.length)
+        break;
+      let g, k;
+      if (l.length)
+        g = u, k = l.reduce((m, v) => Math.min(m, v.to), f && f.from > g ? f.from : 1e8);
+      else {
+        if (g = f.from, g > d)
+          break;
+        k = f.to, l.push(f), h++;
+      }
+      for (; h < s.length; ) {
+        let m = s[h];
+        if (m.from == g && (m.to > m.from || m.to == g))
+          l.push(m), h++, k = Math.min(m.to, k);
+        else {
+          k = Math.min(m.from, k);
+          break;
+        }
+      }
+      k = Math.min(k, d);
+      let y = !1;
+      if (l.some((m) => m.from == g && (m.to == k || k == d)) && (y = g == k, !y && k - g < 10)) {
+        let m = g - (c + a.value.length);
+        m > 0 && (a.next(m), c = g);
+        for (let v = g; ; ) {
+          if (v >= k) {
+            y = !0;
+            break;
+          }
+          if (!a.lineBreak && c + a.value.length > v)
+            break;
+          v = c + a.value.length, c += a.value.length, a.next();
+        }
+      }
+      let S = Rn(l);
+      if (y)
+        o.add(g, g, N.widget({
+          widget: new vn(S),
+          diagnostics: l.slice()
+        }));
+      else {
+        let m = l.reduce((v, T) => T.markClass ? v + " " + T.markClass : v, "");
+        o.add(g, k, N.mark({
+          class: "cm-lintRange cm-lintRange-" + S + m,
+          diagnostics: l.slice(),
+          inclusiveEnd: l.some((v) => v.to > k)
+        }));
+      }
+      if (u = k, u == d)
+        break;
+      for (let m = 0; m < l.length; m++)
+        l[m].to <= u && l.splice(m--, 1);
+    }
+    let p = o.finish();
+    return new F(p, t, j(p));
+  }
+}
+function j(n, e = null, t = 0) {
+  let i = null;
+  return n.between(t, 1e9, (r, s, { spec: o }) => {
+    if (!(e && o.diagnostics.indexOf(e) < 0))
+      if (!i)
+        i = new Be(r, s, e || o.diagnostics[0]);
+      else {
+        if (o.diagnostics.indexOf(i.diagnostic) < 0)
+          return !1;
+        i = new Be(i.from, s, i.diagnostic);
+      }
+  }), i;
+}
+function gn(n, e) {
+  let t = e.pos, i = e.end || t, r = n.state.facet(K).hideOn(n, t, i);
+  if (r != null)
+    return r;
+  let s = n.startState.doc.lineAt(e.pos);
+  return !!(n.effects.some((o) => o.is(_e)) || n.changes.touchesRange(s.from, Math.max(s.to, i)));
+}
+function mn(n, e) {
+  return n.field(A, !1) ? e : e.concat(I.appendConfig.of(Pn));
+}
+function kn(n, e) {
+  return {
+    effects: mn(n, [_e.of(e)])
+  };
+}
+const _e = /* @__PURE__ */ I.define(), pt = /* @__PURE__ */ I.define(), ht = /* @__PURE__ */ I.define(), A = /* @__PURE__ */ be.define({
+  create() {
+    return new F(N.none, null, null);
+  },
+  update(n, e) {
+    if (e.docChanged && n.diagnostics.size) {
+      let t = n.diagnostics.map(e.changes), i = null, r = n.panel;
+      if (n.selected) {
+        let s = e.changes.mapPos(n.selected.from, 1);
+        i = j(t, n.selected.diagnostic, s) || j(t, null, s);
+      }
+      !t.size && r && e.state.facet(K).autoPanel && (r = null), n = new F(t, r, i);
+    }
+    for (let t of e.effects)
+      if (t.is(_e)) {
+        let i = e.state.facet(K).autoPanel ? t.value.length ? re.open : null : n.panel;
+        n = F.init(t.value, i, e.state);
+      } else t.is(pt) ? n = new F(n.diagnostics, t.value ? re.open : null, n.selected) : t.is(ht) && (n = new F(n.diagnostics, n.panel, t.value));
+    return n;
+  },
+  provide: (n) => [
+    Ke.from(n, (e) => e.panel),
+    le.decorations.from(n, (e) => e.diagnostics)
+  ]
+}), xn = /* @__PURE__ */ N.mark({ class: "cm-lintRange cm-lintRange-active" });
+function bn(n, e, t) {
+  let { diagnostics: i } = n.state.field(A), r, s = -1, o = -1;
+  i.between(e - (t < 0 ? 1 : 0), e + (t > 0 ? 1 : 0), (u, a, { spec: c }) => {
+    if (e >= u && e <= a && (u == a || (e > u || t > 0) && (e < a || t < 0)))
+      return r = c.diagnostics, s = u, o = a, !1;
+  });
+  let l = n.state.facet(K).tooltipFilter;
+  return r && l && (r = l(r, n.state)), r ? {
+    pos: s,
+    end: o,
+    above: !0,
+    create() {
+      return { dom: wn(n, r) };
+    }
+  } : null;
+}
+function wn(n, e) {
+  return D("ul", { class: "cm-tooltip-lint" }, e.map((t) => dt(n, t, !1)));
+}
+const Oe = (n) => {
+  let e = n.state.field(A, !1);
+  return !e || !e.panel ? !1 : (n.dispatch({ effects: pt.of(!1) }), !0);
+}, K = /* @__PURE__ */ Qe.define({
+  combine(n) {
+    return {
+      sources: n.map((e) => e.source).filter((e) => e != null),
+      ...Rt(n.map((e) => e.config), {
+        delay: 750,
+        markerFilter: null,
+        tooltipFilter: null,
+        needsRefresh: null,
+        hideOn: () => null
+      }, {
+        delay: Math.max,
+        markerFilter: He,
+        tooltipFilter: He,
+        needsRefresh: (e, t) => e ? t ? (i) => e(i) || t(i) : e : t,
+        hideOn: (e, t) => e ? t ? (i, r, s) => e(i, r, s) || t(i, r, s) : e : t,
+        autoPanel: (e, t) => e || t
+      })
+    };
+  }
+});
+function He(n, e) {
+  return n ? e ? (t, i) => e(n(t, i), i) : n : e;
+}
+function ft(n) {
+  let e = [];
+  if (n)
+    e: for (let { name: t } of n) {
+      for (let i = 0; i < t.length; i++) {
+        let r = t[i];
+        if (/[a-zA-Z]/.test(r) && !e.some((s) => s.toLowerCase() == r.toLowerCase())) {
+          e.push(r);
+          continue e;
+        }
+      }
+      e.push("");
+    }
+  return e;
+}
+function dt(n, e, t) {
+  var i;
+  let r = t ? ft(e.actions) : [];
+  return D("li", { class: "cm-diagnostic cm-diagnostic-" + e.severity }, D("span", { class: "cm-diagnosticText" }, e.renderMessage ? e.renderMessage(n) : e.message), (i = e.actions) === null || i === void 0 ? void 0 : i.map((s, o) => {
+    let l = !1, u = (h) => {
+      if (h.preventDefault(), l)
+        return;
+      l = !0;
+      let f = j(n.state.field(A).diagnostics, e);
+      f && s.apply(n, f.from, f.to);
+    }, { name: a } = s, c = r[o] ? a.indexOf(r[o]) : -1, d = c < 0 ? a : [
+      a.slice(0, c),
+      D("u", a.slice(c, c + 1)),
+      a.slice(c + 1)
+    ], p = s.markClass ? " " + s.markClass : "";
+    return D("button", {
+      type: "button",
+      class: "cm-diagnosticAction" + p,
+      onclick: u,
+      onmousedown: u,
+      "aria-label": ` Action: ${a}${c < 0 ? "" : ` (access key "${r[o]})"`}.`
+    }, d);
+  }), e.source && D("div", { class: "cm-diagnosticSource" }, e.source));
+}
+class vn extends yt {
+  constructor(e) {
+    super(), this.sev = e;
+  }
+  eq(e) {
+    return e.sev == this.sev;
+  }
+  toDOM() {
+    return D("span", { class: "cm-lintPoint cm-lintPoint-" + this.sev });
+  }
+}
+class Ne {
+  constructor(e, t) {
+    this.diagnostic = t, this.id = "item_" + Math.floor(Math.random() * 4294967295).toString(16), this.dom = dt(e, t, !0), this.dom.id = this.id, this.dom.setAttribute("role", "option");
+  }
+}
+class re {
+  constructor(e) {
+    this.view = e, this.items = [];
+    let t = (r) => {
+      if (!(r.ctrlKey || r.altKey || r.metaKey)) {
+        if (r.keyCode == 27)
+          Oe(this.view), this.view.focus();
+        else if (r.keyCode == 38 || r.keyCode == 33)
+          this.moveSelection((this.selectedIndex - 1 + this.items.length) % this.items.length);
+        else if (r.keyCode == 40 || r.keyCode == 34)
+          this.moveSelection((this.selectedIndex + 1) % this.items.length);
+        else if (r.keyCode == 36)
+          this.moveSelection(0);
+        else if (r.keyCode == 35)
+          this.moveSelection(this.items.length - 1);
+        else if (r.keyCode == 13)
+          this.view.focus();
+        else if (r.keyCode >= 65 && r.keyCode <= 90 && this.selectedIndex >= 0) {
+          let { diagnostic: s } = this.items[this.selectedIndex], o = ft(s.actions);
+          for (let l = 0; l < o.length; l++)
+            if (o[l].toUpperCase().charCodeAt(0) == r.keyCode) {
+              let u = j(this.view.state.field(A).diagnostics, s);
+              u && s.actions[l].apply(e, u.from, u.to);
+            }
+        } else
+          return;
+        r.preventDefault();
+      }
+    }, i = (r) => {
+      for (let s = 0; s < this.items.length; s++)
+        this.items[s].dom.contains(r.target) && this.moveSelection(s);
+    };
+    this.list = D("ul", {
+      tabIndex: 0,
+      role: "listbox",
+      "aria-label": this.view.state.phrase("Diagnostics"),
+      onkeydown: t,
+      onclick: i
+    }), this.dom = D("div", { class: "cm-panel-lint" }, this.list, D("button", {
+      type: "button",
+      name: "close",
+      "aria-label": this.view.state.phrase("close"),
+      onclick: () => Oe(this.view)
+    }, "×")), this.update();
+  }
+  get selectedIndex() {
+    let e = this.view.state.field(A).selected;
+    if (!e)
+      return -1;
+    for (let t = 0; t < this.items.length; t++)
+      if (this.items[t].diagnostic == e.diagnostic)
+        return t;
+    return -1;
+  }
+  update() {
+    let { diagnostics: e, selected: t } = this.view.state.field(A), i = 0, r = !1, s = null, o = /* @__PURE__ */ new Set();
+    for (e.between(0, this.view.state.doc.length, (l, u, { spec: a }) => {
+      for (let c of a.diagnostics) {
+        if (o.has(c))
+          continue;
+        o.add(c);
+        let d = -1, p;
+        for (let h = i; h < this.items.length; h++)
+          if (this.items[h].diagnostic == c) {
+            d = h;
+            break;
+          }
+        d < 0 ? (p = new Ne(this.view, c), this.items.splice(i, 0, p), r = !0) : (p = this.items[d], d > i && (this.items.splice(i, d - i), r = !0)), t && p.diagnostic == t.diagnostic ? p.dom.hasAttribute("aria-selected") || (p.dom.setAttribute("aria-selected", "true"), s = p) : p.dom.hasAttribute("aria-selected") && p.dom.removeAttribute("aria-selected"), i++;
+      }
+    }); i < this.items.length && !(this.items.length == 1 && this.items[0].diagnostic.from < 0); )
+      r = !0, this.items.pop();
+    this.items.length == 0 && (this.items.push(new Ne(this.view, {
+      from: -1,
+      to: -1,
+      severity: "info",
+      message: this.view.state.phrase("No diagnostics")
+    })), r = !0), s ? (this.list.setAttribute("aria-activedescendant", s.id), this.view.requestMeasure({
+      key: this,
+      read: () => ({ sel: s.dom.getBoundingClientRect(), panel: this.list.getBoundingClientRect() }),
+      write: ({ sel: l, panel: u }) => {
+        let a = u.height / this.list.offsetHeight;
+        l.top < u.top ? this.list.scrollTop -= (u.top - l.top) / a : l.bottom > u.bottom && (this.list.scrollTop += (l.bottom - u.bottom) / a);
+      }
+    })) : this.selectedIndex < 0 && this.list.removeAttribute("aria-activedescendant"), r && this.sync();
+  }
+  sync() {
+    let e = this.list.firstChild;
+    function t() {
+      let i = e;
+      e = i.nextSibling, i.remove();
+    }
+    for (let i of this.items)
+      if (i.dom.parentNode == this.list) {
+        for (; e != i.dom; )
+          t();
+        e = i.dom.nextSibling;
+      } else
+        this.list.insertBefore(i.dom, e);
+    for (; e; )
+      t();
+  }
+  moveSelection(e) {
+    if (this.selectedIndex < 0)
+      return;
+    let t = this.view.state.field(A), i = j(t.diagnostics, this.items[e].diagnostic);
+    i && this.view.dispatch({
+      selection: { anchor: i.from, head: i.to },
+      scrollIntoView: !0,
+      effects: ht.of(i)
+    });
+  }
+  static open(e) {
+    return new re(e);
+  }
+}
+function yn(n, e = 'viewBox="0 0 40 40"') {
+  return `url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" ${e}>${encodeURIComponent(n)}</svg>')`;
+}
+function J(n) {
+  return yn(`<path d="m0 2.5 l2 -1.5 l1 0 l2 1.5 l1 0" stroke="${n}" fill="none" stroke-width=".7"/>`, 'width="6" height="3"');
+}
+const Sn = /* @__PURE__ */ le.baseTheme({
+  ".cm-diagnostic": {
+    padding: "3px 6px 3px 8px",
+    marginLeft: "-1px",
+    display: "block",
+    whiteSpace: "pre-wrap"
+  },
+  ".cm-diagnostic-error": { borderLeft: "5px solid #d11" },
+  ".cm-diagnostic-warning": { borderLeft: "5px solid orange" },
+  ".cm-diagnostic-info": { borderLeft: "5px solid #999" },
+  ".cm-diagnostic-hint": { borderLeft: "5px solid #66d" },
+  ".cm-diagnosticAction": {
+    font: "inherit",
+    border: "none",
+    padding: "2px 4px",
+    backgroundColor: "#444",
+    color: "white",
+    borderRadius: "3px",
+    marginLeft: "8px",
+    cursor: "pointer"
+  },
+  ".cm-diagnosticSource": {
+    fontSize: "70%",
+    opacity: 0.7
+  },
+  ".cm-lintRange": {
+    backgroundPosition: "left bottom",
+    backgroundRepeat: "repeat-x",
+    paddingBottom: "0.7px"
+  },
+  ".cm-lintRange-error": { backgroundImage: /* @__PURE__ */ J("#f11") },
+  ".cm-lintRange-warning": { backgroundImage: /* @__PURE__ */ J("orange") },
+  ".cm-lintRange-info": { backgroundImage: /* @__PURE__ */ J("#999") },
+  ".cm-lintRange-hint": { backgroundImage: /* @__PURE__ */ J("#66d") },
+  ".cm-lintRange-active": { backgroundColor: "#ffdd9980" },
+  ".cm-tooltip-lint": {
+    padding: 0,
+    margin: 0
+  },
+  ".cm-lintPoint": {
+    position: "relative",
+    "&:after": {
+      content: '""',
+      position: "absolute",
+      bottom: 0,
+      left: "-2px",
+      borderLeft: "3px solid transparent",
+      borderRight: "3px solid transparent",
+      borderBottom: "4px solid #d11"
+    }
+  },
+  ".cm-lintPoint-warning": {
+    "&:after": { borderBottomColor: "orange" }
+  },
+  ".cm-lintPoint-info": {
+    "&:after": { borderBottomColor: "#999" }
+  },
+  ".cm-lintPoint-hint": {
+    "&:after": { borderBottomColor: "#66d" }
+  },
+  ".cm-panel.cm-panel-lint": {
+    position: "relative",
+    "& ul": {
+      maxHeight: "100px",
+      overflowY: "auto",
+      "& [aria-selected]": {
+        backgroundColor: "#ddd",
+        "& u": { textDecoration: "underline" }
+      },
+      "&:focus [aria-selected]": {
+        background_fallback: "#bdf",
+        backgroundColor: "Highlight",
+        color_fallback: "white",
+        color: "HighlightText"
+      },
+      "& u": { textDecoration: "none" },
+      padding: 0,
+      margin: 0
+    },
+    "& [name=close]": {
+      position: "absolute",
+      top: "0",
+      right: "2px",
+      background: "inherit",
+      border: "none",
+      font: "inherit",
+      padding: 0,
+      margin: 0
+    }
+  },
+  "&dark .cm-lintRange-active": { backgroundColor: "#86714a80" },
+  "&dark .cm-panel.cm-panel-lint ul": {
+    "& [aria-selected]": {
+      backgroundColor: "#2e343e"
+    }
+  }
+});
+function Cn(n) {
+  return n == "error" ? 4 : n == "warning" ? 3 : n == "info" ? 2 : 1;
+}
+function Rn(n) {
+  let e = "hint", t = 1;
+  for (let i of n) {
+    let r = Cn(i.severity);
+    r > t && (t = r, e = i.severity);
+  }
+  return e;
+}
+const Tn = /* @__PURE__ */ Ue(bn, { hideOn: gn }), Pn = [
+  A,
+  /* @__PURE__ */ le.decorations.compute([A], (n) => {
+    let { selected: e, panel: t } = n.field(A);
+    return !e || !t || e.from == e.to ? N.none : N.set([
+      xn.range(e.from, e.to)
+    ]);
+  }),
+  Tn,
+  Sn
+];
+let L = null;
+function $n(n, e, t) {
+  let i = L;
+  try {
+    return L = { view: n, language: e }, t();
+  } finally {
+    L = i;
+  }
+}
+const An = /* @__PURE__ */ new ut({
+  walkTokens(n) {
+    if (!L || n.type != "code")
+      return;
+    let e = L.language && L.language(n.lang);
+    if (!e) {
+      let r = L.view.state.facet(we);
+      r && r.name == n.lang && (e = r);
+    }
+    if (!e)
+      return;
+    let t = { style: (r) => Je(L.view.state, r) }, i = "";
+    Xe(n.text, e.parser.parse(n.text), t, (r, s) => {
+      i += s ? `<span class="${s}">${H(r)}</span>` : H(r);
+    }, () => {
+      i += "<br>";
+    }), n.escaped = !0, n.text = i;
+  }
+});
+function H(n) {
+  return n.replace(/[\n<&]/g, (e) => e == `
+` ? "<br>" : e == "<" ? "&lt;" : "&amp;");
+}
+function _n(n, e) {
+  let t = e, i = n;
+  return typeof i != "string" && (t = i.kind, i = i.value), t == "plaintext" ? H(i) : An.parse(i, { async: !1 });
+}
+function de(n, e) {
+  let t = n.lineAt(e);
+  return { line: t.number - 1, character: e - t.from };
+}
+function se(n, e) {
+  return n.line(e.line + 1).from + e.character;
+}
+function je(n, e) {
+  if (e.line < 0 || e.line >= n.lines)
+    return null;
+  let t = n.line(e.line + 1);
+  return e.character < 0 || e.character > t.length ? null : t.from + e.character;
+}
+class C {
+  /**
+  @internal
+  */
+  constructor(e, { client: t, uri: i, languageID: r }) {
+    if (this.view = e, this.client = t, this.uri = i, !r) {
+      let s = e.state.facet(we);
+      r = s ? s.name : "";
+    }
+    t.workspace.openFile(i, r, e), this.syncedDoc = e.state.doc, this.unsyncedChanges = ue.empty(e.state.doc.length);
+  }
+  /**
+  Render a doc string from the server to HTML.
+  */
+  docToHTML(e, t = "plaintext") {
+    let i = $n(this.view, this.client.config.highlightLanguage, () => _n(e, t));
+    return this.client.config.sanitizeHTML ? this.client.config.sanitizeHTML(i) : i;
+  }
+  /**
+  Convert a CodeMirror document offset into an LSP `{line,
+  character}` object. Defaults to using the view's current
+  document, but can be given another one.
+  */
+  toPosition(e, t = this.view.state.doc) {
+    return de(t, e);
+  }
+  /**
+  Convert an LSP `{line, character}` object to a CodeMirror
+  document offset.
+  */
+  fromPosition(e, t = this.view.state.doc) {
+    return se(t, e);
+  }
+  /**
+  Display an error in this plugin's editor.
+  */
+  reportError(e, t) {
+    xe(this.view, {
+      label: this.view.state.phrase(e) + ": " + (t.message || t),
+      class: "cm-lsp-message cm-lsp-message-error",
+      top: !0
+    });
+  }
+  /**
+  Reset the [unsynced
+  changes](https://codemirror.net/6/docs/ref/#lsp-client.LSPPlugin.unsyncedChanges). Should probably
+  only be called by a [workspace](https://codemirror.net/6/docs/ref/#lsp-client.Workspace).
+  */
+  clear() {
+    this.syncedDoc = this.view.state.doc, this.unsyncedChanges = ue.empty(this.view.state.doc.length);
+  }
+  /**
+  @internal
+  */
+  update(e) {
+    e.docChanged && (this.unsyncedChanges = this.unsyncedChanges.compose(e.changes));
+  }
+  /**
+  @internal
+  */
+  destroy() {
+    this.client.workspace.closeFile(this.uri, this.view);
+  }
+  /**
+  Get the LSP plugin associated with an editor, if any.
+  */
+  static get(e) {
+    return e.plugin(gt);
+  }
+  /**
+  Deprecated. Use
+  [`LSPClient.plugin`](https://codemirror.net/6/docs/ref/#lsp-client.LSPClient.plugin) instead.
+  */
+  static create(e, t, i) {
+    return e.plugin(t, i);
+  }
+}
+const gt = /* @__PURE__ */ ke.fromClass(C);
+class Dn {
+  /**
+  The constructor, as called by the client when creating a
+  workspace.
+  */
+  constructor(e) {
+    this.client = e;
+  }
+  /**
+  Find the open file with the given URI, if it exists. The default
+  implementation just looks it up in `this.files`.
+  */
+  getFile(e) {
+    return this.files.find((t) => t.uri == e) || null;
+  }
+  /**
+  Called to request that the workspace open a file. The default
+  implementation simply returns the file if it is open, null
+  otherwise.
+  */
+  requestFile(e) {
+    return Promise.resolve(this.getFile(e));
+  }
+  /**
+  Called when the client for this workspace is connected. The
+  default implementation calls
+  [`LSPClient.didOpen`](https://codemirror.net/6/docs/ref/#lsp-client.LSPClient.didOpen) on all open
+  files.
+  */
+  connected() {
+    for (let e of this.files)
+      this.client.didOpen(e);
+  }
+  /**
+  Called when the client for this workspace is disconnected. The
+  default implementation does nothing.
+  */
+  disconnected() {
+  }
+  /**
+  Called when a server-initiated change to a file is applied. The
+  default implementation simply dispatches the update to the
+  file's view, if the file is open and has a view.
+  */
+  updateFile(e, t) {
+    var i;
+    let r = this.getFile(e);
+    r && ((i = r.getView()) === null || i === void 0 || i.dispatch(t));
+  }
+  /**
+  When the client needs to put a file other than the one loaded in
+  the current editor in front of the user, for example in
+  [`jumpToDefinition`](https://codemirror.net/6/docs/ref/#lsp-client.jumpToDefinition), it will call
+  this function. It should make sure to create or find an editor
+  with the file and make it visible to the user, or return null if
+  this isn't possible.
+  */
+  displayFile(e) {
+    let t = this.getFile(e);
+    return Promise.resolve(t ? t.getView() : null);
+  }
+}
+class zn {
+  constructor(e, t, i, r, s) {
+    this.uri = e, this.languageId = t, this.version = i, this.doc = r, this.view = s;
+  }
+  getView() {
+    return this.view;
+  }
+}
+class En extends Dn {
+  constructor() {
+    super(...arguments), this.files = [], this.fileVersions = /* @__PURE__ */ Object.create(null);
+  }
+  nextFileVersion(e) {
+    var t;
+    return this.fileVersions[e] = ((t = this.fileVersions[e]) !== null && t !== void 0 ? t : -1) + 1;
+  }
+  syncFiles() {
+    let e = [];
+    for (let t of this.files) {
+      let i = C.get(t.view);
+      if (!i)
+        continue;
+      let r = i.unsyncedChanges;
+      r.empty || (e.push({ changes: r, file: t, prevDoc: t.doc }), t.doc = t.view.state.doc, t.version = this.nextFileVersion(t.uri), i.clear());
+    }
+    return e;
+  }
+  openFile(e, t, i) {
+    if (this.getFile(e))
+      throw new Error("Default workspace implementation doesn't support multiple views on the same file");
+    let r = new zn(e, t, this.nextFileVersion(e), i.state.doc, i);
+    this.files.push(r), this.client.didOpen(r);
+  }
+  closeFile(e) {
+    let t = this.getFile(e);
+    t && (this.files = this.files.filter((i) => i != t), this.client.didClose(e));
+  }
+}
+const Ln = /* @__PURE__ */ le.baseTheme({
+  ".cm-lsp-documentation": {
+    padding: "0 7px",
+    "& p, & pre": {
+      margin: "2px 0"
+    }
+  },
+  ".cm-lsp-signature-tooltip": {
+    padding: "2px 6px",
+    borderRadius: "2.5px",
+    position: "relative",
+    maxWidth: "30em",
+    maxHeight: "10em",
+    overflowY: "scroll",
+    "& .cm-lsp-documentation": {
+      padding: "0",
+      fontSize: "80%"
+    },
+    "& .cm-lsp-signature-num": {
+      fontFamily: "monospace",
+      position: "absolute",
+      left: "2px",
+      top: "4px",
+      fontSize: "70%",
+      lineHeight: "1.3"
+    },
+    "& .cm-lsp-signature": {
+      fontFamily: "monospace",
+      textIndent: "1em hanging"
+    },
+    "& .cm-lsp-active-parameter": {
+      fontWeight: "bold"
+    }
+  },
+  ".cm-lsp-signature-multiple": {
+    paddingLeft: "1.5em"
+  },
+  ".cm-panel.cm-lsp-rename-panel": {
+    padding: "2px 6px 4px",
+    position: "relative",
+    "& label": { fontSize: "80%" },
+    "& [name=close]": {
+      position: "absolute",
+      top: "0",
+      bottom: "0",
+      right: "4px",
+      backgroundColor: "inherit",
+      border: "none",
+      font: "inherit",
+      padding: "0"
+    }
+  },
+  ".cm-lsp-message button[type=submit]": {
+    display: "block"
+  },
+  ".cm-lsp-reference-panel": {
+    fontFamily: "monospace",
+    whiteSpace: "pre",
+    padding: "3px 6px",
+    maxHeight: "120px",
+    overflow: "auto",
+    "& .cm-lsp-reference-file": {
+      fontWeight: "bold"
+    },
+    "& .cm-lsp-reference": {
+      cursor: "pointer",
+      "&[aria-selected]": {
+        backgroundColor: "#0077ee44"
+      }
+    },
+    "& .cm-lsp-reference-line": {
+      opacity: "0.7"
+    }
+  }
+});
+class qn {
+  constructor(e, t, i) {
+    this.id = e, this.params = t, this.timeout = i, this.promise = new Promise((r, s) => {
+      this.resolve = r, this.reject = s;
+    });
+  }
+}
+const In = {
+  general: {
+    markdown: {
+      parser: "marked"
+    }
+  },
+  textDocument: {
+    completion: {
+      completionItem: {
+        snippetSupport: !0,
+        documentationFormat: ["markdown", "plaintext"],
+        insertReplaceSupport: !1
+      },
+      completionList: {
+        itemDefaults: ["commitCharacters", "editRange", "insertTextFormat"]
+      },
+      completionItemKind: { valueSet: [] },
+      contextSupport: !0
+    },
+    hover: {
+      contentFormat: ["markdown", "plaintext"]
+    },
+    formatting: {},
+    rename: {},
+    signatureHelp: {
+      contextSupport: !0,
+      signatureInformation: {
+        documentationFormat: ["markdown", "plaintext"],
+        parameterInformation: { labelOffsetSupport: !0 },
+        activeParameterSupport: !0
+      }
+    },
+    definition: {},
+    declaration: {},
+    implementation: {},
+    typeDefinition: {},
+    references: {},
+    diagnostic: {}
+  },
+  window: {
+    showMessage: {}
+  }
+};
+class Mn {
+  /**
+  @internal
+  */
+  constructor(e) {
+    this.client = e, this.mappings = /* @__PURE__ */ new Map(), this.startDocs = /* @__PURE__ */ new Map();
+    for (let t of e.workspace.files)
+      this.mappings.set(t.uri, ue.empty(t.doc.length)), this.startDocs.set(t.uri, t.doc);
+  }
+  /**
+  @internal
+  */
+  addChanges(e, t) {
+    let i = this.mappings.get(e);
+    i && this.mappings.set(e, i.composeDesc(t));
+  }
+  /**
+  Get the changes made to the document with the given URI since
+  the mapping was created. Returns null for documents that aren't
+  open.
+  */
+  getMapping(e) {
+    let t = this.mappings.get(e);
+    if (!t)
+      return null;
+    let i = this.client.workspace.getFile(e), r = i == null ? void 0 : i.getView(), s = r && C.get(r);
+    return s ? t.composeDesc(s.unsyncedChanges) : t;
+  }
+  mapPos(e, t, i = -1, r = ze.Simple) {
+    let s = this.getMapping(e);
+    return s ? s.mapPos(t, i, r) : t;
+  }
+  mapPosition(e, t, i = -1, r = ze.Simple) {
+    let s = this.startDocs.get(e);
+    if (!s)
+      throw new Error("Cannot map from a file that's not in the workspace");
+    let o = se(s, t), l = this.getMapping(e);
+    return l ? l.mapPos(o, i, r) : o;
+  }
+  /**
+  Disconnect this mapping from the client so that it will no
+  longer be notified of new changes. You must make sure to call
+  this on every mapping you create, except when you use
+  [`withMapping`](https://codemirror.net/6/docs/ref/#lsp-client.LSPClient.withMapping), which will
+  automatically schedule a disconnect when the given promise
+  resolves or aborts.
+  */
+  destroy() {
+    this.client.activeMappings = this.client.activeMappings.filter((e) => e != this);
+  }
+}
+const Fn = {
+  "window/logMessage": (n, e) => {
+    e.type == 1 ? console.error("[lsp] " + e.message) : e.type == 2 && console.warn("[lsp] " + e.message);
+  },
+  "window/showMessage": (n, e) => {
+    if (e.type > 3)
+      return;
+    let t;
+    for (let i of n.workspace.files)
+      if (t = i.getView())
+        break;
+    t && xe(t, {
+      label: e.message,
+      class: "cm-lsp-message cm-lsp-message-" + (e.type == 1 ? "error" : e.type == 2 ? "warning" : "info"),
+      top: !0
+    });
+  }
+};
+class Bn {
+  /**
+  Create a client object.
+  */
+  constructor(e = {}) {
+    var t;
+    if (this.config = e, this.transport = null, this.nextReqID = 0, this.requests = [], this.activeMappings = [], this.serverCapabilities = null, this.supportSync = -1, this.extensions = [], this.receiveMessage = this.receiveMessage.bind(this), this.initializing = new Promise((i, r) => this.init = { resolve: i, reject: r }), this.timeout = (t = e.timeout) !== null && t !== void 0 ? t : 3e3, this.workspace = e.workspace ? e.workspace(this) : new En(this), e.extensions)
+      for (let i of e.extensions)
+        Array.isArray(i) || i.extension ? this.extensions.push(i) : i.editorExtension && this.extensions.push(i.editorExtension);
+  }
+  /**
+  Whether this client is connected (has a transport).
+  */
+  get connected() {
+    return !!this.transport;
+  }
+  /**
+  Connect this client to a server over the given transport. Will
+  immediately start the initialization exchange with the server,
+  and resolve `this.initializing` (which it also returns) when
+  successful.
+  */
+  connect(e) {
+    this.transport && this.transport.unsubscribe(this.receiveMessage), this.transport = e, e.subscribe(this.receiveMessage);
+    let t = In;
+    if (this.config.extensions)
+      for (let i of this.config.extensions) {
+        let { clientCapabilities: r } = i;
+        r && (t = mt(t, r));
+      }
+    return this.requestInner("initialize", {
+      processId: null,
+      clientInfo: { name: "@codemirror/lsp-client" },
+      rootUri: this.config.rootUri || null,
+      initializationOptions: this.config.initializationOptions,
+      capabilities: t
+    }).promise.then((i) => {
+      var r;
+      this.serverCapabilities = i.capabilities;
+      let s = i.capabilities.textDocumentSync;
+      this.supportSync = s == null ? 0 : typeof s == "number" ? s : (r = s.change) !== null && r !== void 0 ? r : 0, e.send(JSON.stringify({ jsonrpc: "2.0", method: "initialized", params: {} })), this.init.resolve(null);
+    }, this.init.reject), this.workspace.connected(), this;
+  }
+  /**
+  Disconnect the client from the server.
+  */
+  disconnect() {
+    this.transport && this.transport.unsubscribe(this.receiveMessage), this.serverCapabilities = null, this.initializing = new Promise((e, t) => this.init = { resolve: e, reject: t }), this.workspace.disconnected();
+  }
+  /**
+  Create a plugin for this client, to add to an editor
+  configuration. This extension is necessary to use LSP-related
+  functionality exported by this package. The returned extension
+  will include the editor
+  extensions included in this client's
+  [configuration](https://codemirror.net/6/docs/ref/#lsp-client.LSPClientConfig.extensions).
+  
+  Creating an editor with this plugin will cause
+  [`openFile`](https://codemirror.net/6/docs/ref/#lsp-client.Workspace.openFile) to be called on the
+  workspace.
+  
+  By default, the language ID given to the server for this file is
+  derived from the editor's language configuration via
+  [`Language.name`](https://codemirror.net/6/docs/ref/#language.Language.name). You can pass in
+  a specific ID as a third parameter.
+  */
+  plugin(e, t) {
+    return [
+      gt.of({ client: this, uri: e, languageID: t }),
+      Ln,
+      this.extensions
+    ];
+  }
+  /**
+  Send a `textDocument/didOpen` notification to the server.
+  */
+  didOpen(e) {
+    this.notification("textDocument/didOpen", {
+      textDocument: {
+        uri: e.uri,
+        languageId: e.languageId,
+        text: e.doc.toString(),
+        version: e.version
+      }
+    });
+  }
+  /**
+  Send a `textDocument/didClose` notification to the server.
+  */
+  didClose(e) {
+    this.notification("textDocument/didClose", { textDocument: { uri: e } });
+  }
+  receiveMessage(e) {
+    var t;
+    const i = JSON.parse(e);
+    if ("id" in i && !("method" in i)) {
+      let r = this.requests.findIndex((s) => s.id == i.id);
+      if (r < 0)
+        console.warn(`[lsp] Received a response for non-existent request ${i.id}`);
+      else {
+        let s = this.requests[r];
+        clearTimeout(s.timeout), this.requests.splice(r, 1), i.error ? s.reject(i.error) : s.resolve(i.result);
+      }
+    } else if ("id" in i) {
+      let r = {
+        jsonrpc: "2.0",
+        id: i.id,
+        error: { code: -32601, message: "Method not implemented" }
+      };
+      this.transport.send(JSON.stringify(r));
+    } else {
+      let r = (t = this.config.notificationHandlers) === null || t === void 0 ? void 0 : t[i.method];
+      if (r && r(this, i.params))
+        return;
+      if (this.config.extensions)
+        for (let o of this.config.extensions) {
+          let { notificationHandlers: l } = o, u = l == null ? void 0 : l[i.method];
+          if (u && u(this, i.params))
+            return;
+        }
+      let s = Fn[i.method];
+      s ? s(this, i.params) : this.config.unhandledNotification && this.config.unhandledNotification(this, i.method, i.params);
+    }
+  }
+  /**
+  Make a request to the server. Returns a promise that resolves to
+  the response or rejects with a failure message. You'll probably
+  want to use types from the `vscode-languageserver-protocol`
+  package for the type parameters.
+  
+  The caller is responsible for
+  [synchronizing](https://codemirror.net/6/docs/ref/#lsp-client.LSPClient.sync) state before the
+  request and correctly handling state drift caused by local
+  changes that happend during the request.
+  */
+  request(e, t) {
+    return this.transport ? this.initializing.then(() => this.requestInner(e, t).promise) : Promise.reject(new Error("Client not connected"));
+  }
+  requestInner(e, t, i = !1) {
+    let r = ++this.nextReqID, s = {
+      jsonrpc: "2.0",
+      id: r,
+      method: e,
+      params: t
+    }, o = new qn(r, t, setTimeout(() => this.timeoutRequest(o), this.timeout));
+    this.requests.push(o);
+    try {
+      this.transport.send(JSON.stringify(s));
+    } catch (l) {
+      o.reject(l);
+    }
+    return o;
+  }
+  /**
+  Send a notification to the server.
+  */
+  notification(e, t) {
+    this.transport && this.initializing.then(() => {
+      let i = {
+        jsonrpc: "2.0",
+        method: e,
+        params: t
+      };
+      this.transport.send(JSON.stringify(i));
+    });
+  }
+  /**
+  Cancel the in-progress request with the given parameter value
+  (which is compared by identity).
+  */
+  cancelRequest(e) {
+    let t = this.requests.find((i) => i.params === e);
+    t && this.notification("$/cancelRequest", { id: t.id });
+  }
+  /**
+  @internal
+  */
+  hasCapability(e) {
+    return this.serverCapabilities ? !!this.serverCapabilities[e] : null;
+  }
+  /**
+  Create a [workspace mapping](https://codemirror.net/6/docs/ref/#lsp-client.WorkspaceMapping) that
+  tracks changes to files in this client's workspace, relative to
+  the moment where it was created. Make sure you call
+  [`destroy`](https://codemirror.net/6/docs/ref/#lsp-client.WorkspaceMapping.destroy) on the mapping
+  when you're done with it.
+  */
+  workspaceMapping() {
+    let e = new Mn(this);
+    return this.activeMappings.push(e), e;
+  }
+  /**
+  Run the given promise with a [workspace
+  mapping](https://codemirror.net/6/docs/ref/#lsp-client.WorkspaceMapping) active. Automatically
+  release the mapping when the promise resolves or rejects.
+  */
+  withMapping(e) {
+    let t = this.workspaceMapping();
+    return e(t).finally(() => t.destroy());
+  }
+  /**
+  Push any [pending changes](https://codemirror.net/6/docs/ref/#lsp-client.Workspace.syncFiles) in
+  the open files to the server. You'll want to call this before
+  most types of requests, to make sure the server isn't working
+  with outdated information.
+  */
+  sync() {
+    for (let { file: e, changes: t, prevDoc: i } of this.workspace.syncFiles()) {
+      for (let r of this.activeMappings)
+        r.addChanges(e.uri, t);
+      this.supportSync && this.notification("textDocument/didChange", {
+        textDocument: { uri: e.uri, version: e.version },
+        contentChanges: On(
+          e,
+          i,
+          t,
+          this.supportSync == 2
+          /* Incremental */
+        )
+      });
+    }
+  }
+  timeoutRequest(e) {
+    let t = this.requests.indexOf(e);
+    t > -1 && (e.reject(new Error("Request timed out")), this.requests.splice(t, 1));
+  }
+}
+function On(n, e, t, i) {
+  if (!i || n.doc.length < 1024)
+    return [{ text: n.doc.toString() }];
+  let r = [];
+  return t.iterChanges((s, o, l, u, a) => {
+    r.push({
+      range: { start: de(e, s), end: de(e, o) },
+      text: a.toString()
+    });
+  }), r.reverse();
+}
+function mt(n, e) {
+  if (e == null)
+    return n;
+  if (typeof n != "object" || typeof e != "object")
+    return e;
+  let t = {}, i = Object.keys(n), r = Object.keys(e);
+  for (let s of i)
+    t[s] = r.indexOf(s) > -1 ? mt(n[s], e[s]) : n[s];
+  for (let s of r)
+    i.indexOf(s) < 0 && (t[s] = e[s]);
+  return t;
+}
+function Hn(n) {
+  return n.replace(/\\([$}\\])|\$(\d+)/g, (e, t, i) => t || `\${${i}}`);
+}
+function Nn(n = {}) {
+  let e;
+  if (n.override)
+    e = [Ee({ override: [Ze] })];
+  else {
+    let t = [{ autocomplete: Ze }];
+    e = [Ee(), Pt.languageData.of(() => t)];
+  }
+  return n.validFor && e.push(kt.of({ validFor: n.validFor })), e;
+}
+const kt = /* @__PURE__ */ Qe.define({
+  combine: (n) => n.length ? n[0] : { validFor: null }
+});
+function jn(n, e, t, i) {
+  if (n.client.hasCapability("completionProvider") === !1)
+    return Promise.resolve(null);
+  n.client.sync();
+  let r = {
+    position: n.toPosition(e),
+    textDocument: { uri: n.uri },
+    context: t
+  };
+  return i && i.addEventListener("abort", () => n.client.cancelRequest(r)), n.client.request("textDocument/completion", r);
+}
+function Zn(n) {
+  var e;
+  let t = Math.ceil(n.length / 50), i = [];
+  for (let r = 0; r < n.length; r += t) {
+    let s = n[r], o = ((e = s.textEdit) === null || e === void 0 ? void 0 : e.newText) || s.textEditText || s.insertText || s.label;
+    if (!/^\w/.test(o)) {
+      let l = /^[^\w]*/.exec(o)[0];
+      i.indexOf(l) < 0 && i.push(l);
+    }
+  }
+  return i.length ? new RegExp("^(?:" + i.map(RegExp.escape || ((r) => r.replace(/[^\w\s]/g, "\\$&"))).join("|") + ")?\\w*$") : /^\w*$/;
+}
+function Vn(n, e) {
+  var t, i;
+  let r = (i = (t = n.client.serverCapabilities) === null || t === void 0 ? void 0 : t.completionProvider) === null || i === void 0 ? void 0 : i.triggerCharacters;
+  return r && r.indexOf(e) > -1 ? "triggerCharacter" : /[a-zA-Z_]/.test(e) ? "identifier" : null;
+}
+function xt(n, e) {
+  return (t, i) => {
+    n = n ? n.composeDesc(i) : i;
+    let r = t.options.slice();
+    for (let { index: s, edits: o, text: l } of e)
+      r[s] = { ...r[s], apply: bt(o, l, n) };
+    return {
+      ...t,
+      options: r,
+      map: xt(n, e)
+    };
+  };
+}
+function bt(n, e, t) {
+  return (i, r, s, o) => {
+    let l = zt(i.state, e, s, o), u = [];
+    for (let { from: a, to: c, text: d } of n) {
+      if (t) {
+        if (t.touchesRange(a, c))
+          continue;
+        let p = c - a;
+        a = t.mapPos(a, 1), c = a + p;
+      }
+      u.push({ from: a, to: c, insert: d });
+    }
+    i.dispatch(l, { changes: u });
+  };
+}
+const Ze = (n) => {
+  const e = n.view && C.get(n.view);
+  if (!e)
+    return null;
+  let t = n.state.sliceDoc(n.pos - 1, n.pos), i = n.explicit ? "invoked" : Vn(e, t);
+  if (!i)
+    return null;
+  let r = i == "triggerCharacter" ? { triggerKind: 2, triggerCharacter: t } : {
+    triggerKind: 1
+    /* Invoked */
+  };
+  return jn(e, n.pos, r, n).then((s) => {
+    var o, l;
+    if (!s)
+      return null;
+    Array.isArray(s) && (s = { items: s });
+    let { from: u, to: a } = Gn(n, s), c = (o = s.itemDefaults) === null || o === void 0 ? void 0 : o.commitCharacters, d = n.state.facet(kt), p = [];
+    return {
+      from: u,
+      to: a,
+      options: s.items.map((h, f) => {
+        var g, k, y;
+        let S = ((g = h.textEdit) === null || g === void 0 ? void 0 : g.newText) || h.textEditText || h.insertText || h.label, m = {
+          label: h.filterText || h.label,
+          displayLabel: h.label,
+          type: h.kind && Un[h.kind]
+        }, v = (k = h.insertTextFormat) !== null && k !== void 0 ? k : (y = s.itemDefaults) === null || y === void 0 ? void 0 : y.insertTextFormat;
+        if (h.commitCharacters && h.commitCharacters != c && (m.commitCharacters = h.commitCharacters), h.detail && (m.detail = h.detail), h.sortText && (m.sortText = h.sortText), v == 2)
+          m.apply = (T, P, $, M) => Dt(Hn(S))(T, P, $, M);
+        else if (h.additionalTextEdits) {
+          let T = [];
+          for (let P of h.additionalTextEdits) {
+            let $ = je(n.state.doc, P.range.start), M = je(n.state.doc, P.range.end);
+            $ != null && M != null && T.push({ from: $, to: M, text: P.newText });
+          }
+          p.push({ index: f, text: S, edits: T }), m.apply = bt(T, S, null);
+        } else m.label != S && (m.apply = S);
+        return h.documentation && (m.info = () => Kn(e, h.documentation)), m;
+      }),
+      commitCharacters: c,
+      validFor: s.isIncomplete ? void 0 : (l = d.validFor) !== null && l !== void 0 ? l : Zn(s.items),
+      map: p.length ? xt(null, p) : void 0
+    };
+  }, (s) => {
+    if ("code" in s && s.code == -32800)
+      return null;
+    throw s;
+  });
+};
+function Gn(n, e) {
+  var t;
+  if (!e.items.length)
+    return { from: n.pos, to: n.pos };
+  let i = (t = e.itemDefaults) === null || t === void 0 ? void 0 : t.editRange, r = e.items[0], s = i ? "insert" in i ? i.insert : i : r.textEdit ? "range" in r.textEdit ? r.textEdit.range : r.textEdit.insert : null;
+  if (!s)
+    return n.state.wordAt(n.pos) || { from: n.pos, to: n.pos };
+  let o = n.state.doc.lineAt(n.pos);
+  return { from: o.from + s.start.character, to: o.from + s.end.character };
+}
+function Kn(n, e) {
+  let t = document.createElement("div");
+  return t.className = "cm-lsp-documentation cm-lsp-completion-documentation", t.innerHTML = n.docToHTML(e), t;
+}
+const Un = {
+  1: "text",
+  // Text
+  2: "method",
+  // Method
+  3: "function",
+  // Function
+  4: "class",
+  // Constructor
+  5: "property",
+  // Field
+  6: "variable",
+  // Variable
+  7: "class",
+  // Class
+  8: "interface",
+  // Interface
+  9: "namespace",
+  // Module
+  10: "property",
+  // Property
+  11: "keyword",
+  // Unit
+  12: "constant",
+  // Value
+  13: "constant",
+  // Enum
+  14: "keyword",
+  // Keyword
+  16: "constant",
+  // Color
+  20: "constant",
+  // EnumMember
+  21: "constant",
+  // Constant
+  22: "class",
+  // Struct
+  25: "type"
+  // TypeParameter
+};
+function Wn(n = {}) {
+  return Ue(Jn, {
+    hideOn: (e) => e.docChanged,
+    hoverTime: n.hoverTime
+  });
+}
+function Qn(n, e) {
+  return n.client.hasCapability("hoverProvider") === !1 ? Promise.resolve(null) : (n.client.sync(), n.client.request("textDocument/hover", {
+    position: n.toPosition(e),
+    textDocument: { uri: n.uri }
+  }));
+}
+function Jn(n, e) {
+  const t = C.get(n);
+  return t ? Qn(t, e).then((i) => i ? {
+    pos: i.range ? se(n.state.doc, i.range.start) : e,
+    end: i.range ? se(n.state.doc, i.range.end) : e,
+    create() {
+      let r = document.createElement("div");
+      return r.className = "cm-lsp-hover-tooltip cm-lsp-documentation", r.innerHTML = Xn(t, i.contents), { dom: r };
+    },
+    above: !0
+  } : null) : Promise.resolve(null);
+}
+function Xn(n, e) {
+  return Array.isArray(e) ? e.map((t) => Ve(n, t)).join("<br>") : typeof e == "string" || typeof e == "object" && "language" in e ? Ve(n, e) : n.docToHTML(e);
+}
+function Ve(n, e) {
+  if (typeof e == "string")
+    return n.docToHTML(e, "markdown");
+  let { language: t, value: i } = e, r = n.client.config.highlightLanguage && n.client.config.highlightLanguage(t || "");
+  if (!r) {
+    let o = n.view.state.facet(we);
+    o && (!t || o.name == t) && (r = o);
+  }
+  if (!r)
+    return H(i);
+  let s = "";
+  return Xe(i, r.parser.parse(i), { style: (o) => Je(n.view.state, o) }, (o, l) => {
+    s += l ? `<span class="${l}">${H(o)}</span>` : H(o);
+  }, () => {
+    s += "<br>";
+  }), s;
+}
+function Yn(n, e) {
+  return n.client.request("textDocument/formatting", {
+    options: e,
+    textDocument: { uri: n.uri }
+  });
+}
+const ei = (n) => {
+  const e = C.get(n);
+  return e ? (e.client.sync(), e.client.withMapping((t) => Yn(e, {
+    tabSize: _t(n.state),
+    insertSpaces: n.state.facet(At).indexOf("	") < 0
+  }).then((i) => {
+    if (!i)
+      return;
+    let r = t.getMapping(e.uri), s = [];
+    for (let o of i) {
+      let l = t.mapPosition(e.uri, o.range.start), u = t.mapPosition(e.uri, o.range.end);
+      if (r) {
+        if (r.touchesRange(l, u))
+          return;
+        l = r.mapPos(l, 1), u = r.mapPos(u, -1);
+      }
+      s.push({ from: l, to: u, insert: o.newText });
+    }
+    n.dispatch({
+      changes: s,
+      userEvent: "format"
+    });
+  }, (i) => {
+    e.reportError("Formatting request failed", i);
+  })), !0) : !1;
+}, ti = [
+  { key: "Shift-Alt-f", run: ei, preventDefault: !0 }
+];
+function ni(n, e, t) {
+  return n.client.request("textDocument/rename", {
+    newName: t,
+    position: n.toPosition(e),
+    textDocument: { uri: n.uri }
+  });
+}
+const ii = (n) => {
+  let e = n.state.wordAt(n.state.selection.main.head), t = C.get(n);
+  if (!e || !t || t.client.hasCapability("renameProvider") === !1)
+    return !1;
+  const i = n.state.sliceDoc(e.from, e.to);
+  let r = St(n, "cm-lsp-rename-panel");
+  if (r) {
+    let s = r.dom.querySelector("[name=name]");
+    s.value = i, s.select();
+  } else {
+    let { close: s, result: o } = xe(n, {
+      label: n.state.phrase("New name"),
+      input: { name: "name", value: i },
+      focus: !0,
+      submitLabel: n.state.phrase("rename"),
+      class: "cm-lsp-rename-panel"
+    });
+    o.then((l) => {
+      n.dispatch({ effects: s }), l && ri(n, l.elements.namedItem("name").value);
+    });
+  }
+  return !0;
+};
+function ri(n, e) {
+  const t = C.get(n), i = n.state.wordAt(n.state.selection.main.head);
+  if (!t || !i)
+    return !1;
+  t.client.sync(), t.client.withMapping((r) => ni(t, i.from, e).then((s) => {
+    if (s)
+      for (let o in s.changes) {
+        let l = s.changes[o], u = t.client.workspace.getFile(o);
+        !l.length || !u || t.client.workspace.updateFile(o, {
+          changes: l.map((a) => ({
+            from: r.mapPosition(o, a.range.start),
+            to: r.mapPosition(o, a.range.end),
+            insert: a.newText
+          })),
+          userEvent: "rename"
+        });
+      }
+  }, (s) => {
+    t.reportError("Rename request failed", s);
+  }));
+}
+const si = [
+  { key: "F2", run: ii, preventDefault: !0 }
+];
+function li(n, e, t) {
+  return n.client.hasCapability("signatureHelpProvider") === !1 ? Promise.resolve(null) : (n.client.sync(), n.client.request("textDocument/signatureHelp", {
+    context: t,
+    position: n.toPosition(e),
+    textDocument: { uri: n.uri }
+  }));
+}
+const ee = /* @__PURE__ */ ke.fromClass(class {
+  constructor() {
+    this.activeRequest = null, this.delayedRequest = 0;
+  }
+  update(n) {
+    var e;
+    this.activeRequest && (n.selectionSet ? (this.activeRequest.drop = !0, this.activeRequest = null) : n.docChanged && (this.activeRequest.pos = n.changes.mapPos(this.activeRequest.pos)));
+    const t = C.get(n.view);
+    if (!t)
+      return;
+    const i = n.view.state.field(q);
+    let r = "";
+    if (n.docChanged && n.transactions.some((s) => s.isUserEvent("input.type"))) {
+      const s = (e = t.client.serverCapabilities) === null || e === void 0 ? void 0 : e.signatureHelpProvider, o = ((s == null ? void 0 : s.triggerCharacters) || []).concat(i && (s == null ? void 0 : s.retriggerCharacters) || []);
+      o && n.changes.iterChanges((l, u, a, c, d) => {
+        let p = d.toString();
+        if (p)
+          for (let h of o)
+            p.indexOf(h) > -1 && (r = h);
+      });
+    }
+    r ? this.startRequest(t, {
+      triggerKind: 2,
+      isRetrigger: !!i,
+      triggerCharacter: r,
+      activeSignatureHelp: i ? i.data : void 0
+    }) : i && n.selectionSet && (this.delayedRequest && clearTimeout(this.delayedRequest), this.delayedRequest = setTimeout(() => {
+      this.startRequest(t, {
+        triggerKind: 3,
+        isRetrigger: !0,
+        activeSignatureHelp: i.data
+      });
+    }, 250));
+  }
+  startRequest(n, e) {
+    this.delayedRequest && clearTimeout(this.delayedRequest);
+    let { view: t } = n, i = t.state.selection.main.head;
+    this.activeRequest && (this.activeRequest.drop = !0);
+    let r = this.activeRequest = { pos: i, drop: !1 };
+    li(n, i, e).then((s) => {
+      var o;
+      if (!r.drop)
+        if (s && s.signatures.length) {
+          let l = t.state.field(q), u = l && oi(l.data, s), a = u && e.triggerKind == 3 ? l.active : (o = s.activeSignature) !== null && o !== void 0 ? o : 0;
+          if (u && ai(l.data, s, a))
+            return;
+          t.dispatch({ effects: U.of({
+            data: s,
+            active: a,
+            pos: u ? l.tooltip.pos : r.pos
+          }) });
+        } else t.state.field(q) && t.dispatch({ effects: U.of(null) });
+    }, e.triggerKind == 1 ? (s) => n.reportError("Signature request failed", s) : void 0);
+  }
+  destroy() {
+    this.delayedRequest && clearTimeout(this.delayedRequest), this.activeRequest && (this.activeRequest.drop = !0);
+  }
+});
+function oi(n, e) {
+  return n.signatures.length != e.signatures.length ? !1 : n.signatures.every((t, i) => t.label == e.signatures[i].label);
+}
+function ai(n, e, t) {
+  var i, r;
+  return ((i = n.signatures[t].activeParameter) !== null && i !== void 0 ? i : n.activeParameter) == ((r = e.signatures[t].activeParameter) !== null && r !== void 0 ? r : e.activeParameter);
+}
+class Ge {
+  constructor(e, t, i) {
+    this.data = e, this.active = t, this.tooltip = i;
+  }
+}
+const q = /* @__PURE__ */ be.define({
+  create() {
+    return null;
+  },
+  update(n, e) {
+    for (let t of e.effects)
+      if (t.is(U))
+        return t.value ? new Ge(t.value.data, t.value.active, ci(t.value.data, t.value.active, t.value.pos)) : null;
+    return n && e.docChanged ? new Ge(n.data, n.active, { ...n.tooltip, pos: e.changes.mapPos(n.tooltip.pos) }) : n;
+  },
+  provide: (n) => Ct.from(n, (e) => e && e.tooltip)
+}), U = /* @__PURE__ */ I.define();
+function ci(n, e, t) {
+  return {
+    pos: t,
+    above: !0,
+    create: (i) => ui(i, n, e)
+  };
+}
+function ui(n, e, t) {
+  var i;
+  let r = document.createElement("div");
+  if (r.className = "cm-lsp-signature-tooltip", e.signatures.length > 1) {
+    r.classList.add("cm-lsp-signature-multiple");
+    let d = r.appendChild(document.createElement("div"));
+    d.className = "cm-lsp-signature-num", d.textContent = `${t + 1}/${e.signatures.length}`;
+  }
+  let s = e.signatures[t], o = r.appendChild(document.createElement("div"));
+  o.className = "cm-lsp-signature";
+  let l = 0, u = 0, a = (i = s.activeParameter) !== null && i !== void 0 ? i : e.activeParameter, c = a != null && s.parameters ? s.parameters[a] : null;
+  if (c && Array.isArray(c.label))
+    [l, u] = c.label;
+  else if (c) {
+    let d = s.label.indexOf(c.label);
+    d > -1 && (l = d, u = d + c.label.length);
+  }
+  if (u) {
+    o.appendChild(document.createTextNode(s.label.slice(0, l)));
+    let d = o.appendChild(document.createElement("span"));
+    d.className = "cm-lsp-active-parameter", d.textContent = s.label.slice(l, u), o.appendChild(document.createTextNode(s.label.slice(u)));
+  } else
+    o.textContent = s.label;
+  if (s.documentation) {
+    let d = C.get(n);
+    if (d) {
+      let p = r.appendChild(document.createElement("div"));
+      p.className = "cm-lsp-signature-documentation cm-lsp-documentation", p.innerHTML = d.docToHTML(s.documentation);
+    }
+  }
+  return { dom: r };
+}
+const pi = (n) => {
+  let e = n.plugin(ee);
+  e || (n.dispatch({ effects: I.appendConfig.of([q, ee]) }), e = n.plugin(ee));
+  let t = n.state.field(q);
+  if (!e || t === void 0)
+    return !1;
+  let i = C.get(n);
+  return i ? (e.startRequest(i, {
+    triggerKind: 1,
+    activeSignatureHelp: t ? t.data : void 0,
+    isRetrigger: !!t
+  }), !0) : !1;
+}, hi = (n) => {
+  let e = n.state.field(q);
+  return e ? (e.active < e.data.signatures.length - 1 && n.dispatch({ effects: U.of({ data: e.data, active: e.active + 1, pos: e.tooltip.pos }) }), !0) : !1;
+}, fi = (n) => {
+  let e = n.state.field(q);
+  return e ? (e.active > 0 && n.dispatch({ effects: U.of({ data: e.data, active: e.active - 1, pos: e.tooltip.pos }) }), !0) : !1;
+}, di = [
+  { key: "Mod-Shift-Space", run: pi },
+  { key: "Mod-Shift-ArrowUp", run: fi },
+  { key: "Mod-Shift-ArrowDown", run: hi }
+];
+function gi(n = {}) {
+  return [
+    q,
+    ee,
+    n.keymap === !1 ? [] : $t.high(We.of(di))
+  ];
+}
+function mi(n, e) {
+  return n.client.request("textDocument/definition", {
+    textDocument: { uri: n.uri },
+    position: n.toPosition(e)
+  });
+}
+function ki(n, e) {
+  const t = C.get(n);
+  return !t || t.client.hasCapability(e.capability) === !1 ? !1 : (t.client.sync(), t.client.withMapping((i) => e.get(t, n.state.selection.main.head).then((r) => {
+    let s = Array.isArray(r) ? r[0] : r;
+    if (s)
+      return (s.uri == t.uri ? Promise.resolve(n) : t.client.workspace.displayFile(s.uri)).then((o) => {
+        if (!o)
+          return;
+        let l = i.getMapping(s.uri) ? i.mapPosition(s.uri, s.range.start) : t.fromPosition(s.range.start, o.state.doc);
+        o.dispatch({ selection: { anchor: l }, scrollIntoView: !0, userEvent: "select.definition" });
+      });
+  }, (r) => t.reportError("Find definition failed", r))), !0);
+}
+const xi = (n) => ki(n, {
+  get: mi,
+  capability: "definitionProvider"
+}), bi = [
+  { key: "F12", run: xi, preventDefault: !0 }
+];
+function wi(n, e) {
+  return n.client.request("textDocument/references", {
+    textDocument: { uri: n.uri },
+    position: n.toPosition(e),
+    context: { includeDeclaration: !0 }
+  });
+}
+const vi = (n) => {
+  const e = C.get(n);
+  if (!e || e.client.hasCapability("referencesProvider") === !1)
+    return !1;
+  e.client.sync();
+  let t = e.client.workspaceMapping(), i = !1;
+  return wi(e, n.state.selection.main.head).then((r) => {
+    if (r)
+      return Promise.all(r.map((s) => e.client.workspace.requestFile(s.uri).then((o) => o ? { file: o, range: s.range } : null))).then((s) => {
+        let o = s.filter((l) => l);
+        o.length && (yi(e.view, o, t), i = !0);
+      });
+  }, (r) => e.reportError("Finding references failed", r)).finally(() => {
+    i || t.destroy();
+  }), !0;
+}, ge = (n) => n.state.field(me, !1) ? (n.dispatch({ effects: De.of(null) }), !0) : !1, me = /* @__PURE__ */ be.define({
+  create() {
+    return null;
+  },
+  update(n, e) {
+    for (let t of e.effects)
+      if (t.is(De))
+        return t.value;
+    return n;
+  },
+  provide: (n) => Ke.from(n)
+}), De = /* @__PURE__ */ I.define();
+function yi(n, e, t) {
+  let i = Si(e, t), r = n.state.field(me, !1) === void 0 ? I.appendConfig.of(me.init(() => i)) : De.of(i);
+  n.dispatch({ effects: r });
+}
+function Si(n, e) {
+  let t = !1;
+  return setTimeout(() => {
+    t || e.destroy();
+  }, 500), (i) => {
+    t = !0;
+    let r = Ci(n.map((h) => h.file.uri)), s = document.createElement("div"), o = null;
+    s.className = "cm-lsp-reference-panel", s.tabIndex = 0, s.role = "listbox", s.setAttribute("aria-label", i.state.phrase("Reference list"));
+    let l = [];
+    for (let { file: h, range: f } of n) {
+      let g = h.uri.slice(r);
+      if (g != o) {
+        o = g;
+        let M = s.appendChild(document.createElement("div"));
+        M.className = "cm-lsp-reference-file", M.textContent = g;
+      }
+      let k = s.appendChild(document.createElement("div"));
+      k.className = "cm-lsp-reference", k.role = "option";
+      let y = e.mapPosition(h.uri, f.start, 1), S = e.mapPosition(h.uri, f.end, -1), m = h.getView(), v = (m ? m.state.doc : h.doc).lineAt(y), T = k.appendChild(document.createElement("span"));
+      T.className = "cm-lsp-reference-line", T.textContent = (v.number + ": ").padStart(5, " ");
+      let P = v.text.slice(Math.max(0, y - v.from - 50), y - v.from);
+      P && k.appendChild(document.createTextNode(P)), k.appendChild(document.createElement("strong")).textContent = v.text.slice(y - v.from, S - v.from);
+      let $ = v.text.slice(S - v.from, Math.min(v.length, 100 - P.length));
+      $ && k.appendChild(document.createTextNode($)), l.length || k.setAttribute("aria-selected", "true"), l.push(k);
+    }
+    function u() {
+      for (let h = 0; h < l.length; h++)
+        if (l[h].hasAttribute("aria-selected"))
+          return h;
+      return 0;
+    }
+    function a(h) {
+      for (let f = 0; f < l.length; f++)
+        f == h ? l[f].setAttribute("aria-selected", "true") : l[f].removeAttribute("aria-selected");
+    }
+    function c(h) {
+      let { file: f, range: g } = n[h], k = C.get(i);
+      k && Promise.resolve(f.uri == k.uri ? i : k.client.workspace.displayFile(f.uri)).then((y) => {
+        if (!y)
+          return;
+        let S = e.mapPosition(f.uri, g.start, 1);
+        y.focus(), y.dispatch({
+          selection: { anchor: S },
+          scrollIntoView: !0
+        });
+      });
+    }
+    s.addEventListener("keydown", (h) => {
+      if (h.keyCode == 27)
+        ge(i), i.focus();
+      else if (h.keyCode == 38 || h.keyCode == 33)
+        a((u() - 1 + n.length) % n.length);
+      else if (h.keyCode == 40 || h.keyCode == 34)
+        a((u() + 1) % n.length);
+      else if (h.keyCode == 36)
+        a(0);
+      else if (h.keyCode == 35)
+        a(l.length - 1);
+      else if (h.keyCode == 13 || h.keyCode == 10)
+        c(u());
+      else
+        return;
+      h.preventDefault();
+    }), s.addEventListener("click", (h) => {
+      for (let f = 0; f < l.length; f++)
+        l[f].contains(h.target) && (a(f), c(f), h.preventDefault());
+    });
+    let d = document.createElement("div");
+    d.appendChild(s);
+    let p = d.appendChild(document.createElement("button"));
+    return p.className = "cm-dialog-close", p.textContent = "×", p.addEventListener("click", () => ge(i)), p.setAttribute("aria-label", i.state.phrase("close")), {
+      dom: d,
+      destroy: () => e.destroy(),
+      mount: () => s.focus()
+    };
+  };
+}
+function Ci(n) {
+  let e = n[0], t = e.length;
+  for (let i = 1; i < n.length; i++) {
+    let r = n[i], s = 0;
+    for (let o = Math.min(t, r.length); s < o && e[s] == r[s]; s++)
+      ;
+    t = s;
+  }
+  for (; t && e[t - 1] != "/"; )
+    t--;
+  return t;
+}
+const Ri = [
+  { key: "Shift-F12", run: vi, preventDefault: !0 },
+  { key: "Escape", run: ge }
+];
+function Ti(n) {
+  return n == 1 ? "error" : n == 2 ? "warning" : n == 3 ? "info" : "hint";
+}
+const Pi = /* @__PURE__ */ ke.fromClass(class {
+  constructor() {
+    this.pending = -1;
+  }
+  update(n) {
+    n.docChanged && (this.pending > -1 && clearTimeout(this.pending), this.pending = setTimeout(() => {
+      this.pending = -1;
+      let e = C.get(n.view);
+      e && e.client.sync();
+    }, 500));
+  }
+  destroy() {
+    this.pending > -1 && clearTimeout(this.pending);
+  }
+});
+function $i() {
+  return {
+    clientCapabilities: { textDocument: { publishDiagnostics: { versionSupport: !0 } } },
+    notificationHandlers: {
+      "textDocument/publishDiagnostics": (n, e) => {
+        let t = n.workspace.getFile(e.uri);
+        if (!t || e.version != null && e.version != t.version)
+          return !1;
+        const i = t.getView(), r = i && C.get(i);
+        return !i || !r ? !1 : (i.dispatch(kn(i.state, e.diagnostics.map((s) => {
+          var o;
+          return {
+            from: r.unsyncedChanges.mapPos(r.fromPosition(s.range.start, r.syncedDoc)),
+            to: r.unsyncedChanges.mapPos(r.fromPosition(s.range.end, r.syncedDoc)),
+            severity: Ti((o = s.severity) !== null && o !== void 0 ? o : 1),
+            message: s.message
+          };
+        }))), !0);
+      }
+    },
+    editorExtension: Pi
+  };
+}
+function Ai() {
+  return [
+    Nn(),
+    Wn(),
+    We.of([...ti, ...si, ...bi, ...Ri]),
+    gi(),
+    $i()
+  ];
+}
+let X;
+function qi() {
+  if (X) return X;
+  const n = new Worker(new URL(
+    /* @vite-ignore */
+    "/assets/tsgo-worker-BDQ8_wHH.js",
+    import.meta.url
+  ), {
+    type: "module"
+  }), e = /* @__PURE__ */ new Set();
+  n.onmessage = (i) => {
+    var r, s;
+    if (typeof ((r = i.data) == null ? void 0 : r.lsp) == "string")
+      for (const o of e) o(i.data.lsp);
+    else (s = i.data) != null && s.failed && console.error("TypeScript language server didn't start:", i.data.failed);
+  }, n.onerror = (i) => {
+    console.error("TypeScript language server worker:", i.message);
+  };
+  const t = {
+    send: (i) => n.postMessage({ lsp: i }),
+    subscribe: (i) => e.add(i),
+    unsubscribe: (i) => e.delete(i)
+  };
+  return X = new Bn({
+    rootUri: "file:///",
+    timeout: 3e4,
+    extensions: Ai()
+  }).connect(t), X;
+}
+export {
+  qi as typescriptLanguageServer
+};
+//# sourceMappingURL=typescript-language-server-oTU8pKzb.js.map