@onereach/ui-components 3.1.0-beta.2483.0 → 3.1.0-beta.2496.0

package/dist/bundled/v2/OrCode-e1d5b058.js

@@ -0,0 +1,4420 @@
+import { E as EditorView, a as EditorSelection, P as Prec, k as keymap, b as EditorState } from './index-606dc30d.js';
+import { C as ContextTracker, E as ExternalTokenizer, s as styleTags, L as LRParser, t as tags$1, p as parseMixed, a as LanguageSupport, b as syntaxTree, c as LRLanguage, i as indentNodeProp, d as continuedIndent, f as foldNodeProp, e as foldInside, j as javascriptLanguage, g as javascript, N as NodeType, h as NodeProp, k as NodeSet, P as Parser, T as Tag, l as Tree, m as Language, n as defineLanguageFacet, o as languageDataProp, q as LanguageDescription, r as ParseContext, H as HighlightStyle, u as syntaxHighlighting, v as basicSetup, w as indentWithTab } from './index-dbb62f5c.js';
+import { useElementHover } from '@vueuse/core';
+import './index-fa6eb4ca.js';
+import { O as OrTeleport } from './OrTeleport.vue2-90147f16.js';
+import { O as OrIconButton } from './OrIconButton-e28d129f.js';
+import { O as OrModal } from './OrModal-d1cb603e.js';
+import { O as OrError } from './OrError-29f0ce95.js';
+import { O as OrHint } from './OrHint-664117aa.js';
+import { O as OrLabel } from './OrLabel-f19ccb5f.js';
+import { defineComponent, ref } from '@vue/composition-api/dist/vue-composition-api.mjs';
+import { s as styleInject } from './style-inject.es-4c6f2515.js';
+import { n as normalizeComponent } from './normalize-component-6e8e3d80.js';
+
+var OrCodeLanguages;
+(function (OrCodeLanguages) {
+  OrCodeLanguages["JS"] = "javascript";
+  OrCodeLanguages["TS"] = "typescript";
+  OrCodeLanguages["CSS"] = "css";
+  OrCodeLanguages["HTML"] = "html";
+  OrCodeLanguages["JSON"] = "json";
+  OrCodeLanguages["MD"] = "markdown";
+})(OrCodeLanguages || (OrCodeLanguages = {}));
+
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+const scriptText = 54,
+  StartCloseScriptTag = 1,
+  styleText = 55,
+  StartCloseStyleTag = 2,
+  textareaText = 56,
+  StartCloseTextareaTag = 3,
+  StartTag = 4,
+  StartScriptTag = 5,
+  StartStyleTag = 6,
+  StartTextareaTag = 7,
+  StartSelfClosingTag = 8,
+  StartCloseTag = 9,
+  NoMatchStartCloseTag = 10,
+  MismatchedStartCloseTag = 11,
+  missingCloseTag = 57,
+  IncompleteCloseTag = 12,
+  commentContent$1 = 58,
+  Element$1 = 18,
+  TagName = 20,
+  Attribute = 21,
+  AttributeName = 22,
+  AttributeValue = 24,
+  UnquotedAttributeValue = 25,
+  ScriptText = 27,
+  StyleText = 30,
+  TextareaText = 33,
+  OpenTag = 35,
+  CloseTag = 36,
+  Dialect_noMatch = 0;
+
+/* Hand-written tokenizers for HTML. */
+
+const selfClosers = {
+  area: true,
+  base: true,
+  br: true,
+  col: true,
+  command: true,
+  embed: true,
+  frame: true,
+  hr: true,
+  img: true,
+  input: true,
+  keygen: true,
+  link: true,
+  meta: true,
+  param: true,
+  source: true,
+  track: true,
+  wbr: true,
+  menuitem: true
+};
+const implicitlyClosed = {
+  dd: true,
+  li: true,
+  optgroup: true,
+  option: true,
+  p: true,
+  rp: true,
+  rt: true,
+  tbody: true,
+  td: true,
+  tfoot: true,
+  th: true,
+  tr: true
+};
+const closeOnOpen = {
+  dd: {
+    dd: true,
+    dt: true
+  },
+  dt: {
+    dd: true,
+    dt: true
+  },
+  li: {
+    li: true
+  },
+  option: {
+    option: true,
+    optgroup: true
+  },
+  optgroup: {
+    optgroup: true
+  },
+  p: {
+    address: true,
+    article: true,
+    aside: true,
+    blockquote: true,
+    dir: true,
+    div: true,
+    dl: true,
+    fieldset: true,
+    footer: true,
+    form: true,
+    h1: true,
+    h2: true,
+    h3: true,
+    h4: true,
+    h5: true,
+    h6: true,
+    header: true,
+    hgroup: true,
+    hr: true,
+    menu: true,
+    nav: true,
+    ol: true,
+    p: true,
+    pre: true,
+    section: true,
+    table: true,
+    ul: true
+  },
+  rp: {
+    rp: true,
+    rt: true
+  },
+  rt: {
+    rp: true,
+    rt: true
+  },
+  tbody: {
+    tbody: true,
+    tfoot: true
+  },
+  td: {
+    td: true,
+    th: true
+  },
+  tfoot: {
+    tbody: true
+  },
+  th: {
+    td: true,
+    th: true
+  },
+  thead: {
+    tbody: true,
+    tfoot: true
+  },
+  tr: {
+    tr: true
+  }
+};
+function nameChar(ch) {
+  return ch == 45 || ch == 46 || ch == 58 || ch >= 65 && ch <= 90 || ch == 95 || ch >= 97 && ch <= 122 || ch >= 161;
+}
+function isSpace(ch) {
+  return ch == 9 || ch == 10 || ch == 13 || ch == 32;
+}
+let cachedName = null,
+  cachedInput = null,
+  cachedPos = 0;
+function tagNameAfter(input, offset) {
+  let pos = input.pos + offset;
+  if (cachedPos == pos && cachedInput == input) return cachedName;
+  let next = input.peek(offset);
+  while (isSpace(next)) next = input.peek(++offset);
+  let name = "";
+  for (;;) {
+    if (!nameChar(next)) break;
+    name += String.fromCharCode(next);
+    next = input.peek(++offset);
+  }
+  // Undefined to signal there's a <? or <!, null for just missing
+  cachedInput = input;
+  cachedPos = pos;
+  return cachedName = name ? name.toLowerCase() : next == question || next == bang ? undefined : null;
+}
+const lessThan = 60,
+  greaterThan = 62,
+  slash = 47,
+  question = 63,
+  bang = 33,
+  dash$1 = 45;
+function ElementContext(name, parent) {
+  this.name = name;
+  this.parent = parent;
+  this.hash = parent ? parent.hash : 0;
+  for (let i = 0; i < name.length; i++) this.hash += (this.hash << 4) + name.charCodeAt(i) + (name.charCodeAt(i) << 8);
+}
+const startTagTerms = [StartTag, StartSelfClosingTag, StartScriptTag, StartStyleTag, StartTextareaTag];
+const elementContext = new ContextTracker({
+  start: null,
+  shift(context, term, stack, input) {
+    return startTagTerms.indexOf(term) > -1 ? new ElementContext(tagNameAfter(input, 1) || "", context) : context;
+  },
+  reduce(context, term) {
+    return term == Element$1 && context ? context.parent : context;
+  },
+  reuse(context, node, stack, input) {
+    let type = node.type.id;
+    return type == StartTag || type == OpenTag ? new ElementContext(tagNameAfter(input, 1) || "", context) : context;
+  },
+  hash(context) {
+    return context ? context.hash : 0;
+  },
+  strict: false
+});
+const tagStart = new ExternalTokenizer((input, stack) => {
+  if (input.next != lessThan) {
+    // End of file, close any open tags
+    if (input.next < 0 && stack.context) input.acceptToken(missingCloseTag);
+    return;
+  }
+  input.advance();
+  let close = input.next == slash;
+  if (close) input.advance();
+  let name = tagNameAfter(input, 0);
+  if (name === undefined) return;
+  if (!name) return input.acceptToken(close ? IncompleteCloseTag : StartTag);
+  let parent = stack.context ? stack.context.name : null;
+  if (close) {
+    if (name == parent) return input.acceptToken(StartCloseTag);
+    if (parent && implicitlyClosed[parent]) return input.acceptToken(missingCloseTag, -2);
+    if (stack.dialectEnabled(Dialect_noMatch)) return input.acceptToken(NoMatchStartCloseTag);
+    for (let cx = stack.context; cx; cx = cx.parent) if (cx.name == name) return;
+    input.acceptToken(MismatchedStartCloseTag);
+  } else {
+    if (name == "script") return input.acceptToken(StartScriptTag);
+    if (name == "style") return input.acceptToken(StartStyleTag);
+    if (name == "textarea") return input.acceptToken(StartTextareaTag);
+    if (selfClosers.hasOwnProperty(name)) return input.acceptToken(StartSelfClosingTag);
+    if (parent && closeOnOpen[parent] && closeOnOpen[parent][name]) input.acceptToken(missingCloseTag, -1);else input.acceptToken(StartTag);
+  }
+}, {
+  contextual: true
+});
+const commentContent = new ExternalTokenizer(input => {
+  for (let dashes = 0, i = 0;; i++) {
+    if (input.next < 0) {
+      if (i) input.acceptToken(commentContent$1);
+      break;
+    }
+    if (input.next == dash$1) {
+      dashes++;
+    } else if (input.next == greaterThan && dashes >= 2) {
+      if (i > 3) input.acceptToken(commentContent$1, -2);
+      break;
+    } else {
+      dashes = 0;
+    }
+    input.advance();
+  }
+});
+function contentTokenizer(tag, textToken, endToken) {
+  let lastState = 2 + tag.length;
+  return new ExternalTokenizer(input => {
+    // state means:
+    // - 0 nothing matched
+    // - 1 '<' matched
+    // - 2 '</' + possibly whitespace matched
+    // - 3-(1+tag.length) part of the tag matched
+    // - lastState whole tag + possibly whitespace matched
+    for (let state = 0, matchedLen = 0, i = 0;; i++) {
+      if (input.next < 0) {
+        if (i) input.acceptToken(textToken);
+        break;
+      }
+      if (state == 0 && input.next == lessThan || state == 1 && input.next == slash || state >= 2 && state < lastState && input.next == tag.charCodeAt(state - 2)) {
+        state++;
+        matchedLen++;
+      } else if ((state == 2 || state == lastState) && isSpace(input.next)) {
+        matchedLen++;
+      } else if (state == lastState && input.next == greaterThan) {
+        if (i > matchedLen) input.acceptToken(textToken, -matchedLen);else input.acceptToken(endToken, -(matchedLen - 2));
+        break;
+      } else if ((input.next == 10 /* '\n' */ || input.next == 13 /* '\r' */) && i) {
+        input.acceptToken(textToken, 1);
+        break;
+      } else {
+        state = matchedLen = 0;
+      }
+      input.advance();
+    }
+  });
+}
+const scriptTokens = contentTokenizer("script", scriptText, StartCloseScriptTag);
+const styleTokens = contentTokenizer("style", styleText, StartCloseStyleTag);
+const textareaTokens = contentTokenizer("textarea", textareaText, StartCloseTextareaTag);
+const htmlHighlighting = styleTags({
+  "Text RawText": tags$1.content,
+  "StartTag StartCloseTag SelfClosingEndTag EndTag": tags$1.angleBracket,
+  TagName: tags$1.tagName,
+  "MismatchedCloseTag/TagName": [tags$1.tagName, tags$1.invalid],
+  AttributeName: tags$1.attributeName,
+  "AttributeValue UnquotedAttributeValue": tags$1.attributeValue,
+  Is: tags$1.definitionOperator,
+  "EntityReference CharacterReference": tags$1.character,
+  Comment: tags$1.blockComment,
+  ProcessingInst: tags$1.processingInstruction,
+  DoctypeDecl: tags$1.documentMeta
+});
+
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+const parser$3 = LRParser.deserialize({
+  version: 14,
+  states: ",xOVOxOOO!WQ!bO'#CoO!]Q!bO'#CyO!bQ!bO'#C|O!gQ!bO'#DPO!lQ!bO'#DRO!qOXO'#CnO!|OYO'#CnO#XO[O'#CnO$eOxO'#CnOOOW'#Cn'#CnO$lO!rO'#DTO$tQ!bO'#DVO$yQ!bO'#DWOOOW'#Dk'#DkOOOW'#DY'#DYQVOxOOO%OQ#tO,59ZO%WQ#tO,59eO%`Q#tO,59hO%hQ#tO,59kO%sQ#tO,59mOOOX'#D^'#D^O%{OXO'#CwO&WOXO,59YOOOY'#D_'#D_O&`OYO'#CzO&kOYO,59YOOO['#D`'#D`O&sO[O'#C}O'OO[O,59YOOOW'#Da'#DaO'WOxO,59YO'_Q!bO'#DQOOOW,59Y,59YOOO`'#Db'#DbO'dO!rO,59oOOOW,59o,59oO'lQ!bO,59qO'qQ!bO,59rOOOW-E7W-E7WO'vQ#tO'#CqOOQO'#DZ'#DZO(UQ#tO1G.uOOOX1G.u1G.uO(^Q#tO1G/POOOY1G/P1G/PO(fQ#tO1G/SOOO[1G/S1G/SO(nQ#tO1G/VOOOW1G/V1G/VOOOW1G/X1G/XO(yQ#tO1G/XOOOX-E7[-E7[O)RQ!bO'#CxOOOW1G.t1G.tOOOY-E7]-E7]O)WQ!bO'#C{OOO[-E7^-E7^O)]Q!bO'#DOOOOW-E7_-E7_O)bQ!bO,59lOOO`-E7`-E7`OOOW1G/Z1G/ZOOOW1G/]1G/]OOOW1G/^1G/^O)gQ&jO,59]OOQO-E7X-E7XOOOX7+$a7+$aOOOY7+$k7+$kOOO[7+$n7+$nOOOW7+$q7+$qOOOW7+$s7+$sO)rQ!bO,59dO)wQ!bO,59gO)|Q!bO,59jOOOW1G/W1G/WO*RO,UO'#CtO*dO7[O'#CtOOQO1G.w1G.wOOOW1G/O1G/OOOOW1G/R1G/ROOOW1G/U1G/UOOOO'#D['#D[O*uO,UO,59`OOQO,59`,59`OOOO'#D]'#D]O+WO7[O,59`OOOO-E7Y-E7YOOQO1G.z1G.zOOOO-E7Z-E7Z",
+  stateData: "+u~O!^OS~OSSOTPOUQOVROWTOY]OZ[O[^O^^O_^O`^Oa^Ox^O{_O!dZO~OdaO~OdbO~OdcO~OddO~OdeO~O!WfOPkP!ZkP~O!XiOQnP!ZnP~O!YlORqP!ZqP~OSSOTPOUQOVROWTOXqOY]OZ[O[^O^^O_^O`^Oa^Ox^O!dZO~O!ZrO~P#dO![sO!euO~OdvO~OdwO~OfyOj|O~OfyOj!OO~OfyOj!QO~OfyOj!SOv!TO~OfyOj!TO~O!WfOPkX!ZkX~OP!WO!Z!XO~O!XiOQnX!ZnX~OQ!ZO!Z!XO~O!YlORqX!ZqX~OR!]O!Z!XO~O!Z!XO~P#dOd!_O~O![sO!e!aO~Oj!bO~Oj!cO~Og!dOfeXjeXveX~OfyOj!fO~OfyOj!gO~OfyOj!hO~OfyOj!iOv!jO~OfyOj!jO~Od!kO~Od!lO~Od!mO~Oj!nO~Oi!qO!`!oO!b!pO~Oj!rO~Oj!sO~Oj!tO~O_!uO`!uOa!uO!`!wO!a!uO~O_!xO`!xOa!xO!b!wO!c!xO~O_!uO`!uOa!uO!`!{O!a!uO~O_!xO`!xOa!xO!b!{O!c!xO~Ov~vj`!dx{_a_~",
+  goto: "%p!`PPPPPPPPPPPPPPPPPP!a!gP!mPP!yPP!|#P#S#Y#]#`#f#i#l#r#xP!aP!a!aP$O$U$l$r$x%O%U%[%bPPPPPPPP%hX^OX`pXUOX`pezabcde{}!P!R!UR!q!dRhUR!XhXVOX`pRkVR!XkXWOX`pRnWR!XnXXOX`pQrXR!XpXYOX`pQ`ORx`Q{aQ}bQ!PcQ!RdQ!UeZ!e{}!P!R!UQ!v!oR!z!vQ!y!pR!|!yQgUR!VgQjVR!YjQmWR![mQpXR!^pQtZR!`tS_O`ToXp",
+  nodeNames: "⚠ StartCloseTag StartCloseTag StartCloseTag StartTag StartTag StartTag StartTag StartTag StartCloseTag StartCloseTag StartCloseTag IncompleteCloseTag Document Text EntityReference CharacterReference InvalidEntity Element OpenTag TagName Attribute AttributeName Is AttributeValue UnquotedAttributeValue EndTag ScriptText CloseTag OpenTag StyleText CloseTag OpenTag TextareaText CloseTag OpenTag CloseTag SelfClosingTag SelfClosingEndTag Comment ProcessingInst MismatchedCloseTag CloseTag DoctypeDecl",
+  maxTerm: 67,
+  context: elementContext,
+  nodeProps: [["closedBy", -10, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, "EndTag", 4, "EndTag SelfClosingEndTag", -4, 19, 29, 32, 35, "CloseTag"], ["group", -9, 12, 15, 16, 17, 18, 39, 40, 41, 42, "Entity", 14, "Entity TextContent", -3, 27, 30, 33, "TextContent Entity"], ["openedBy", 26, "StartTag StartCloseTag", -4, 28, 31, 34, 36, "OpenTag", 38, "StartTag"]],
+  propSources: [htmlHighlighting],
+  skippedNodes: [0],
+  repeatNodeCount: 9,
+  tokenData: "#(r!aR!YOX$qXY,QYZ,QZ[$q[]&X]^,Q^p$qpq,Qqr-_rs4ysv-_vw5iwxJ^x}-_}!OKP!O!P-_!P!Q!!O!Q![-_![!]!$c!]!^-_!^!_!(k!_!`#'S!`!a#'z!a!c-_!c!}!$c!}#R-_#R#S!$c#S#T3V#T#o!$c#o#s-_#s$f$q$f%W-_%W%o!$c%o%p-_%p&a!$c&a&b-_&b1p!$c1p4U-_4U4d!$c4d4e-_4e$IS!$c$IS$I`-_$I`$Ib!$c$Ib$Kh-_$Kh%#t!$c%#t&/x-_&/x&Et!$c&Et&FV-_&FV;'S!$c;'S;:j!(e;:j;=`4s<%l?&r-_?&r?Ah!$c?Ah?BY$q?BY?Mn!$c?MnO$q!Z$|c^PiW!a`!cpOX$qXZ&XZ[$q[^&X^p$qpq&Xqr$qrs&}sv$qvw+Pwx(tx!^$q!^!_*V!_!a&X!a#S$q#S#T&X#T;'S$q;'S;=`+z<%lO$q!R&bX^P!a`!cpOr&Xrs&}sv&Xwx(tx!^&X!^!_*V!_;'S&X;'S;=`*y<%lO&Xq'UV^P!cpOv&}wx'kx!^&}!^!_(V!_;'S&};'S;=`(n<%lO&}P'pT^POv'kw!^'k!_;'S'k;'S;=`(P<%lO'kP(SP;=`<%l'kp([S!cpOv(Vx;'S(V;'S;=`(h<%lO(Vp(kP;=`<%l(Vq(qP;=`<%l&}a({W^P!a`Or(trs'ksv(tw!^(t!^!_)e!_;'S(t;'S;=`*P<%lO(t`)jT!a`Or)esv)ew;'S)e;'S;=`)y<%lO)e`)|P;=`<%l)ea*SP;=`<%l(t!Q*^V!a`!cpOr*Vrs(Vsv*Vwx)ex;'S*V;'S;=`*s<%lO*V!Q*vP;=`<%l*V!R*|P;=`<%l&XW+UYiWOX+PZ[+P^p+Pqr+Psw+Px!^+P!a#S+P#T;'S+P;'S;=`+t<%lO+PW+wP;=`<%l+P!Z+}P;=`<%l$q!a,]`^P!a`!cp!^^OX&XXY,QYZ,QZ]&X]^,Q^p&Xpq,Qqr&Xrs&}sv&Xwx(tx!^&X!^!_*V!_;'S&X;'S;=`*y<%lO&X!_-ljfS^PiW!a`!cpOX$qXZ&XZ[$q[^&X^p$qpq&Xqr-_rs&}sv-_vw/^wx(tx!P-_!P!Q$q!Q!^-_!^!_1n!_!a&X!a#S-_#S#T3V#T#s-_#s$f$q$f;'S-_;'S;=`4s<%l?Ah-_?Ah?BY$q?BY?Mn-_?MnO$q[/ecfSiWOX+PZ[+P^p+Pqr/^sw/^x!P/^!P!Q+P!Q!^/^!^!_0p!a#S/^#S#T0p#T#s/^#s$f+P$f;'S/^;'S;=`1h<%l?Ah/^?Ah?BY+P?BY?Mn/^?MnO+PS0uXfSqr0psw0px!P0p!Q!_0p!a#s0p$f;'S0p;'S;=`1b<%l?Ah0p?BY?Mn0pS1eP;=`<%l0p[1kP;=`<%l/^!U1wbfS!a`!cpOq*Vqr1nrs(Vsv1nvw0pwx)ex!P1n!P!Q*V!Q!_1n!_!a*V!a#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!U3SP;=`<%l1n!V3bcfS^P!a`!cpOq&Xqr3Vrs&}sv3Vvw0pwx(tx!P3V!P!Q&X!Q!^3V!^!_1n!_!a&X!a#s3V#s$f&X$f;'S3V;'S;=`4m<%l?Ah3V?Ah?BY&X?BY?Mn3V?MnO&X!V4pP;=`<%l3V!_4vP;=`<%l-_!Z5SV!`h^P!cpOv&}wx'kx!^&}!^!_(V!_;'S&};'S;=`(n<%lO&}!_5rjfSiWa!ROX7dXZ8qZ[7d[^8q^p7dqr:crs8qst@Ttw:cwx8qx!P:c!P!Q7d!Q!]:c!]!^/^!^!_=p!_!a8q!a#S:c#S#T=p#T#s:c#s$f7d$f;'S:c;'S;=`?}<%l?Ah:c?Ah?BY7d?BY?Mn:c?MnO7d!Z7ibiWOX7dXZ8qZ[7d[^8q^p7dqr7drs8qst+Ptw7dwx8qx!]7d!]!^9f!^!a8q!a#S7d#S#T8q#T;'S7d;'S;=`:]<%lO7d!R8tVOp8qqs8qt!]8q!]!^9Z!^;'S8q;'S;=`9`<%lO8q!R9`O_!R!R9cP;=`<%l8q!Z9mYiW_!ROX+PZ[+P^p+Pqr+Psw+Px!^+P!a#S+P#T;'S+P;'S;=`+t<%lO+P!Z:`P;=`<%l7d!_:jjfSiWOX7dXZ8qZ[7d[^8q^p7dqr:crs8qst/^tw:cwx8qx!P:c!P!Q7d!Q!]:c!]!^<[!^!_=p!_!a8q!a#S:c#S#T=p#T#s:c#s$f7d$f;'S:c;'S;=`?}<%l?Ah:c?Ah?BY7d?BY?Mn:c?MnO7d!_<ecfSiW_!ROX+PZ[+P^p+Pqr/^sw/^x!P/^!P!Q+P!Q!^/^!^!_0p!a#S/^#S#T0p#T#s/^#s$f+P$f;'S/^;'S;=`1h<%l?Ah/^?Ah?BY+P?BY?Mn/^?MnO+P!V=udfSOp8qqr=prs8qst0ptw=pwx8qx!P=p!P!Q8q!Q!]=p!]!^?T!^!_=p!_!a8q!a#s=p#s$f8q$f;'S=p;'S;=`?w<%l?Ah=p?Ah?BY8q?BY?Mn=p?MnO8q!V?[XfS_!Rqr0psw0px!P0p!Q!_0p!a#s0p$f;'S0p;'S;=`1b<%l?Ah0p?BY?Mn0p!V?zP;=`<%l=p!_@QP;=`<%l:c!_@[ifSiWOXAyXZCTZ[Ay[^CT^pAyqrDrrsCTswDrwxCTx!PDr!P!QAy!Q!]Dr!]!^/^!^!_G|!_!aCT!a#SDr#S#TG|#T#sDr#s$fAy$f;'SDr;'S;=`JW<%l?AhDr?Ah?BYAy?BY?MnDr?MnOAy!ZBOaiWOXAyXZCTZ[Ay[^CT^pAyqrAyrsCTswAywxCTx!]Ay!]!^Cu!^!aCT!a#SAy#S#TCT#T;'SAy;'S;=`Dl<%lOAy!RCWUOpCTq!]CT!]!^Cj!^;'SCT;'S;=`Co<%lOCT!RCoO`!R!RCrP;=`<%lCT!ZC|YiW`!ROX+PZ[+P^p+Pqr+Psw+Px!^+P!a#S+P#T;'S+P;'S;=`+t<%lO+P!ZDoP;=`<%lAy!_DyifSiWOXAyXZCTZ[Ay[^CT^pAyqrDrrsCTswDrwxCTx!PDr!P!QAy!Q!]Dr!]!^Fh!^!_G|!_!aCT!a#SDr#S#TG|#T#sDr#s$fAy$f;'SDr;'S;=`JW<%l?AhDr?Ah?BYAy?BY?MnDr?MnOAy!_FqcfSiW`!ROX+PZ[+P^p+Pqr/^sw/^x!P/^!P!Q+P!Q!^/^!^!_0p!a#S/^#S#T0p#T#s/^#s$f+P$f;'S/^;'S;=`1h<%l?Ah/^?Ah?BY+P?BY?Mn/^?MnO+P!VHRcfSOpCTqrG|rsCTswG|wxCTx!PG|!P!QCT!Q!]G|!]!^I^!^!_G|!_!aCT!a#sG|#s$fCT$f;'SG|;'S;=`JQ<%l?AhG|?Ah?BYCT?BY?MnG|?MnOCT!VIeXfS`!Rqr0psw0px!P0p!Q!_0p!a#s0p$f;'S0p;'S;=`1b<%l?Ah0p?BY?Mn0p!VJTP;=`<%lG|!_JZP;=`<%lDr!ZJgW!bx^P!a`Or(trs'ksv(tw!^(t!^!_)e!_;'S(t;'S;=`*P<%lO(t!aK^lfS^PiW!a`!cpOX$qXZ&XZ[$q[^&X^p$qpq&Xqr-_rs&}sv-_vw/^wx(tx}-_}!OMU!O!P-_!P!Q$q!Q!^-_!^!_1n!_!a&X!a#S-_#S#T3V#T#s-_#s$f$q$f;'S-_;'S;=`4s<%l?Ah-_?Ah?BY$q?BY?Mn-_?MnO$q!aMckfS^PiW!a`!cpOX$qXZ&XZ[$q[^&X^p$qpq&Xqr-_rs&}sv-_vw/^wx(tx!P-_!P!Q$q!Q!^-_!^!_1n!_!`&X!`!a! W!a#S-_#S#T3V#T#s-_#s$f$q$f;'S-_;'S;=`4s<%l?Ah-_?Ah?BY$q?BY?Mn-_?MnO$q!T! cX^P!a`!cp!eQOr&Xrs&}sv&Xwx(tx!^&X!^!_*V!_;'S&X;'S;=`*y<%lO&X!a!!Zd^PiW!a`!cpOX$qXZ&XZ[$q[^&X^p$qpq&Xqr$qrs&}sv$qvw+Pwx(tx!^$q!^!_*V!_!`&X!`!a!#i!a#S$q#S#T&X#T;'S$q;'S;=`+z<%lO$q!X!#vX^P!a`!cpvSjUOr&Xrs&}sv&Xwx(tx!^&X!^!_*V!_;'S&X;'S;=`*y<%lO&X!a!$r!ZfSdQ^PiW!a`!cpOX$qXZ&XZ[$q[^&X^p$qpq&Xqr-_rs&}sv-_vw/^wx(tx}-_}!O!$c!O!P!$c!P!Q$q!Q![!$c![!]!$c!]!^-_!^!_1n!_!a&X!a!c-_!c!}!$c!}#R-_#R#S!$c#S#T3V#T#o!$c#o#s-_#s$f$q$f$}-_$}%O!$c%O%W-_%W%o!$c%o%p-_%p&a!$c&a&b-_&b1p!$c1p4U!$c4U4d!$c4d4e-_4e$IS!$c$IS$I`-_$I`$Ib!$c$Ib$Je-_$Je$Jg!$c$Jg$Kh-_$Kh%#t!$c%#t&/x-_&/x&Et!$c&Et&FV-_&FV;'S!$c;'S;:j!(e;:j;=`4s<%l?&r-_?&r?Ah!$c?Ah?BY$q?BY?Mn!$c?MnO$q!a!(hP;=`<%l!$c!V!(tcfS!a`!cpOq*Vqr!*Prs(Vsv1nvw0pwx)ex!P1n!P!Q*V!Q!_1n!_!a*V!a!b!H^!b#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!*YhfS!a`!cpOq*Vqr1nrs(Vsv1nvw0pwx)ex}1n}!O!+t!O!P1n!P!Q*V!Q!_1n!_!a*V!a!f1n!f!g!.p!g#W1n#W#X!?^#X#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!+}dfS!a`!cpOq*Vqr1nrs(Vsv1nvw0pwx)ex}1n}!O!-]!O!P1n!P!Q*V!Q!_1n!_!a*V!a#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!-hbfS!a`!cp!dPOq*Vqr1nrs(Vsv1nvw0pwx)ex!P1n!P!Q*V!Q!_1n!_!a*V!a#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!.ydfS!a`!cpOq*Vqr1nrs(Vsv1nvw0pwx)ex!P1n!P!Q*V!Q!_1n!_!a*V!a!q1n!q!r!0X!r#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!0bdfS!a`!cpOq*Vqr1nrs(Vsv1nvw0pwx)ex!P1n!P!Q*V!Q!_1n!_!a*V!a!e1n!e!f!1p!f#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!1ydfS!a`!cpOq*Vqr1nrs(Vsv1nvw0pwx)ex!P1n!P!Q*V!Q!_1n!_!a*V!a!v1n!v!w!3X!w#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!3bdfS!a`!cpOq*Vqr1nrs(Vsv1nvw0pwx)ex!P1n!P!Q*V!Q!_1n!_!a*V!a!{1n!{!|!4p!|#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!4ydfS!a`!cpOq*Vqr1nrs(Vsv1nvw0pwx)ex!P1n!P!Q*V!Q!_1n!_!a*V!a!r1n!r!s!6X!s#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!6bdfS!a`!cpOq*Vqr1nrs(Vsv1nvw0pwx)ex!P1n!P!Q*V!Q!_1n!_!a*V!a!g1n!g!h!7p!h#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!7ycfS!a`!cpOq!9Uqr!7prs!9{sv!7pvw!=swx!;ox!P!7p!P!Q!9U!Q!_!7p!_!`!9U!`!a!<}!a#s!7p#s$f!9U$f;'S!7p;'S;=`!?W<%l?Ah!7p?Ah?BY!9U?BY?Mn!7p?MnO!9U!R!9]Y!a`!cpOr!9Urs!9{sv!9Uvw!:gwx!;ox!`!9U!`!a!<}!a;'S!9U;'S;=`!=m<%lO!9Uq!:QV!cpOv!9{vx!:gx!`!9{!`!a!;U!a;'S!9{;'S;=`!;i<%lO!9{P!:jTO!`!:g!`!a!:y!a;'S!:g;'S;=`!;O<%lO!:gP!;OO{PP!;RP;=`<%l!:gq!;]S!cp{POv(Vx;'S(V;'S;=`(h<%lO(Vq!;lP;=`<%l!9{a!;tX!a`Or!;ors!:gsv!;ovw!:gw!`!;o!`!a!<a!a;'S!;o;'S;=`!<w<%lO!;oa!<hT!a`{POr)esv)ew;'S)e;'S;=`)y<%lO)ea!<zP;=`<%l!;o!R!=WV!a`!cp{POr*Vrs(Vsv*Vwx)ex;'S*V;'S;=`*s<%lO*V!R!=pP;=`<%l!9UT!=xbfSOq!:gqr!=srs!:gsw!=swx!:gx!P!=s!P!Q!:g!Q!_!=s!_!`!:g!`!a!:y!a#s!=s#s$f!:g$f;'S!=s;'S;=`!?Q<%l?Ah!=s?Ah?BY!:g?BY?Mn!=s?MnO!:gT!?TP;=`<%l!=s!V!?ZP;=`<%l!7p!V!?gdfS!a`!cpOq*Vqr1nrs(Vsv1nvw0pwx)ex!P1n!P!Q*V!Q!_1n!_!a*V!a#c1n#c#d!@u#d#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!AOdfS!a`!cpOq*Vqr1nrs(Vsv1nvw0pwx)ex!P1n!P!Q*V!Q!_1n!_!a*V!a#V1n#V#W!B^#W#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!BgdfS!a`!cpOq*Vqr1nrs(Vsv1nvw0pwx)ex!P1n!P!Q*V!Q!_1n!_!a*V!a#h1n#h#i!Cu#i#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!DOdfS!a`!cpOq*Vqr1nrs(Vsv1nvw0pwx)ex!P1n!P!Q*V!Q!_1n!_!a*V!a#m1n#m#n!E^#n#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!EgdfS!a`!cpOq*Vqr1nrs(Vsv1nvw0pwx)ex!P1n!P!Q*V!Q!_1n!_!a*V!a#d1n#d#e!Fu#e#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!GOdfS!a`!cpOq*Vqr1nrs(Vsv1nvw0pwx)ex!P1n!P!Q*V!Q!_1n!_!a*V!a#X1n#X#Y!7p#Y#s1n#s$f*V$f;'S1n;'S;=`3P<%l?Ah1n?Ah?BY*V?BY?Mn1n?MnO*V!V!HgcfS!a`!cpOq!Irqr!H^rs!Jisv!H^vw#!vwx!MZx!P!H^!P!Q!Ir!Q!_!H^!_!a!Ir!a!b#%h!b#s!H^#s$f!Ir$f;'S!H^;'S;=`#&|<%l?Ah!H^?Ah?BY!Ir?BY?Mn!H^?MnO!Ir!R!IyY!a`!cpOr!Irrs!Jisv!Irvw!KTwx!MZx!a!Ir!a!b# Z!b;'S!Ir;'S;=`#!p<%lO!Irq!JnV!cpOv!Jivx!KTx!a!Ji!a!b!LU!b;'S!Ji;'S;=`!MT<%lO!JiP!KWTO!a!KT!a!b!Kg!b;'S!KT;'S;=`!LO<%lO!KTP!KjTO!`!KT!`!a!Ky!a;'S!KT;'S;=`!LO<%lO!KTP!LOOxPP!LRP;=`<%l!KTq!LZV!cpOv!Jivx!KTx!`!Ji!`!a!Lp!a;'S!Ji;'S;=`!MT<%lO!Jiq!LwS!cpxPOv(Vx;'S(V;'S;=`(h<%lO(Vq!MWP;=`<%l!Jia!M`X!a`Or!MZrs!KTsv!MZvw!KTw!a!MZ!a!b!M{!b;'S!MZ;'S;=`# T<%lO!MZa!NQX!a`Or!MZrs!KTsv!MZvw!KTw!`!MZ!`!a!Nm!a;'S!MZ;'S;=`# T<%lO!MZa!NtT!a`xPOr)esv)ew;'S)e;'S;=`)y<%lO)ea# WP;=`<%l!MZ!R# bY!a`!cpOr!Irrs!Jisv!Irvw!KTwx!MZx!`!Ir!`!a#!Q!a;'S!Ir;'S;=`#!p<%lO!Ir!R#!ZV!a`!cpxPOr*Vrs(Vsv*Vwx)ex;'S*V;'S;=`*s<%lO*V!R#!sP;=`<%l!IrT#!{bfSOq!KTqr#!vrs!KTsw#!vwx!KTx!P#!v!P!Q!KT!Q!_#!v!_!a!KT!a!b#$T!b#s#!v#s$f!KT$f;'S#!v;'S;=`#%b<%l?Ah#!v?Ah?BY!KT?BY?Mn#!v?MnO!KTT#$YbfSOq!KTqr#!vrs!KTsw#!vwx!KTx!P#!v!P!Q!KT!Q!_#!v!_!`!KT!`!a!Ky!a#s#!v#s$f!KT$f;'S#!v;'S;=`#%b<%l?Ah#!v?Ah?BY!KT?BY?Mn#!v?MnO!KTT#%eP;=`<%l#!v!V#%qcfS!a`!cpOq!Irqr!H^rs!Jisv!H^vw#!vwx!MZx!P!H^!P!Q!Ir!Q!_!H^!_!`!Ir!`!a#!Q!a#s!H^#s$f!Ir$f;'S!H^;'S;=`#&|<%l?Ah!H^?Ah?BY!Ir?BY?Mn!H^?MnO!Ir!V#'PP;=`<%l!H^!V#'_XgS^P!a`!cpOr&Xrs&}sv&Xwx(tx!^&X!^!_*V!_;'S&X;'S;=`*y<%lO&X!X#(VX^P!a`!cpjUOr&Xrs&}sv&Xwx(tx!^&X!^!_*V!_;'S&X;'S;=`*y<%lO&X",
+  tokenizers: [scriptTokens, styleTokens, textareaTokens, tagStart, commentContent, 0, 1, 2, 3, 4, 5],
+  topRules: {
+    "Document": [0, 13]
+  },
+  dialects: {
+    noMatch: 0,
+    selfClosing: 485
+  },
+  tokenPrec: 487
+});
+function getAttrs(openTag, input) {
+  let attrs = Object.create(null);
+  for (let att of openTag.getChildren(Attribute)) {
+    let name = att.getChild(AttributeName),
+      value = att.getChild(AttributeValue) || att.getChild(UnquotedAttributeValue);
+    if (name) attrs[input.read(name.from, name.to)] = !value ? "" : value.type.id == AttributeValue ? input.read(value.from + 1, value.to - 1) : input.read(value.from, value.to);
+  }
+  return attrs;
+}
+function findTagName(openTag, input) {
+  let tagNameNode = openTag.getChild(TagName);
+  return tagNameNode ? input.read(tagNameNode.from, tagNameNode.to) : " ";
+}
+function maybeNest(node, input, tags) {
+  let attrs;
+  for (let tag of tags) {
+    if (!tag.attrs || tag.attrs(attrs || (attrs = getAttrs(node.node.parent.firstChild, input)))) return {
+      parser: tag.parser
+    };
+  }
+  return null;
+}
+
+// tags?: {
+//   tag: string,
+//   attrs?: ({[attr: string]: string}) => boolean,
+//   parser: Parser
+// }[]
+// attributes?: {
+//   name: string,
+//   tagName?: string,
+//   parser: Parser
+// }[]
+
+function configureNesting(tags = [], attributes = []) {
+  let script = [],
+    style = [],
+    textarea = [],
+    other = [];
+  for (let tag of tags) {
+    let array = tag.tag == "script" ? script : tag.tag == "style" ? style : tag.tag == "textarea" ? textarea : other;
+    array.push(tag);
+  }
+  let attrs = attributes.length ? Object.create(null) : null;
+  for (let attr of attributes) (attrs[attr.name] || (attrs[attr.name] = [])).push(attr);
+  return parseMixed((node, input) => {
+    let id = node.type.id;
+    if (id == ScriptText) return maybeNest(node, input, script);
+    if (id == StyleText) return maybeNest(node, input, style);
+    if (id == TextareaText) return maybeNest(node, input, textarea);
+    if (id == OpenTag && other.length) {
+      let n = node.node,
+        tagName = findTagName(n, input),
+        attrs;
+      for (let tag of other) {
+        if (tag.tag == tagName && (!tag.attrs || tag.attrs(attrs || (attrs = getAttrs(n, input))))) {
+          let close = n.parent.lastChild;
+          return {
+            parser: tag.parser,
+            overlay: [{
+              from: node.to,
+              to: close.type.id == CloseTag ? close.from : n.parent.to
+            }]
+          };
+        }
+      }
+    }
+    if (attrs && id == Attribute) {
+      let n = node.node,
+        nameNode;
+      if (nameNode = n.firstChild) {
+        let matches = attrs[input.read(nameNode.from, nameNode.to)];
+        if (matches) for (let attr of matches) {
+          if (attr.tagName && attr.tagName != findTagName(n.parent, input)) continue;
+          let value = n.lastChild;
+          if (value.type.id == AttributeValue) return {
+            parser: attr.parser,
+            overlay: [{
+              from: value.from + 1,
+              to: value.to - 1
+            }]
+          };else if (value.type.id == UnquotedAttributeValue) return {
+            parser: attr.parser,
+            overlay: [{
+              from: value.from,
+              to: value.to
+            }]
+          };
+        }
+      }
+    }
+    return null;
+  });
+}
+
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+const descendantOp = 94,
+  Unit = 1,
+  callee = 95,
+  identifier$2 = 96,
+  VariableName = 2;
+
+/* Hand-written tokenizers for CSS tokens that can't be
+   expressed by Lezer's built-in tokenizer. */
+
+const space$1 = [9, 10, 11, 12, 13, 32, 133, 160, 5760, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8232, 8233, 8239, 8287, 12288];
+const colon = 58,
+  parenL = 40,
+  underscore = 95,
+  bracketL = 91,
+  dash = 45,
+  period = 46,
+  hash = 35,
+  percent = 37;
+function isAlpha(ch) {
+  return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || ch >= 161;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+const identifiers = new ExternalTokenizer((input, stack) => {
+  for (let inside = false, dashes = 0, i = 0;; i++) {
+    let {
+      next
+    } = input;
+    if (isAlpha(next) || next == dash || next == underscore || inside && isDigit(next)) {
+      if (!inside && (next != dash || i > 0)) inside = true;
+      if (dashes === i && next == dash) dashes++;
+      input.advance();
+    } else {
+      if (inside) input.acceptToken(next == parenL ? callee : dashes == 2 && stack.canShift(VariableName) ? VariableName : identifier$2);
+      break;
+    }
+  }
+});
+const descendant = new ExternalTokenizer(input => {
+  if (space$1.includes(input.peek(-1))) {
+    let {
+      next
+    } = input;
+    if (isAlpha(next) || next == underscore || next == hash || next == period || next == bracketL || next == colon || next == dash) input.acceptToken(descendantOp);
+  }
+});
+const unitToken = new ExternalTokenizer(input => {
+  if (!space$1.includes(input.peek(-1))) {
+    let {
+      next
+    } = input;
+    if (next == percent) {
+      input.advance();
+      input.acceptToken(Unit);
+    }
+    if (isAlpha(next)) {
+      do {
+        input.advance();
+      } while (isAlpha(input.next));
+      input.acceptToken(Unit);
+    }
+  }
+});
+const cssHighlighting = styleTags({
+  "AtKeyword import charset namespace keyframes media supports": tags$1.definitionKeyword,
+  "from to selector": tags$1.keyword,
+  NamespaceName: tags$1.namespace,
+  KeyframeName: tags$1.labelName,
+  TagName: tags$1.tagName,
+  ClassName: tags$1.className,
+  PseudoClassName: tags$1.constant(tags$1.className),
+  IdName: tags$1.labelName,
+  "FeatureName PropertyName": tags$1.propertyName,
+  AttributeName: tags$1.attributeName,
+  NumberLiteral: tags$1.number,
+  KeywordQuery: tags$1.keyword,
+  UnaryQueryOp: tags$1.operatorKeyword,
+  "CallTag ValueName": tags$1.atom,
+  VariableName: tags$1.variableName,
+  Callee: tags$1.operatorKeyword,
+  Unit: tags$1.unit,
+  "UniversalSelector NestingSelector": tags$1.definitionOperator,
+  MatchOp: tags$1.compareOperator,
+  "ChildOp SiblingOp, LogicOp": tags$1.logicOperator,
+  BinOp: tags$1.arithmeticOperator,
+  Important: tags$1.modifier,
+  Comment: tags$1.blockComment,
+  ParenthesizedContent: tags$1.special(tags$1.name),
+  ColorLiteral: tags$1.color,
+  StringLiteral: tags$1.string,
+  ":": tags$1.punctuation,
+  "PseudoOp #": tags$1.derefOperator,
+  "; ,": tags$1.separator,
+  "( )": tags$1.paren,
+  "[ ]": tags$1.squareBracket,
+  "{ }": tags$1.brace
+});
+
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+const spec_callee = {
+  __proto__: null,
+  lang: 32,
+  "nth-child": 32,
+  "nth-last-child": 32,
+  "nth-of-type": 32,
+  "nth-last-of-type": 32,
+  dir: 32,
+  "host-context": 32,
+  url: 60,
+  "url-prefix": 60,
+  domain: 60,
+  regexp: 60,
+  selector: 134
+};
+const spec_AtKeyword = {
+  __proto__: null,
+  "@import": 114,
+  "@media": 138,
+  "@charset": 142,
+  "@namespace": 146,
+  "@keyframes": 152,
+  "@supports": 164
+};
+const spec_identifier = {
+  __proto__: null,
+  not: 128,
+  only: 128,
+  from: 158,
+  to: 160
+};
+const parser$2 = LRParser.deserialize({
+  version: 14,
+  states: "7WQYQ[OOO#_Q[OOOOQP'#Cd'#CdOOQP'#Cc'#CcO#fQ[O'#CfO$YQXO'#CaO$aQ[O'#ChO$lQ[O'#DPO$qQ[O'#DTOOQP'#Ed'#EdO$vQdO'#DeO%bQ[O'#DrO$vQdO'#DtO%sQ[O'#DvO&OQ[O'#DyO&TQ[O'#EPO&cQ[O'#EROOQS'#Ec'#EcOOQS'#ET'#ETQYQ[OOO&jQXO'#CdO'_QWO'#DaO'dQWO'#EjO'oQ[O'#EjQOQWOOOOQP'#Cg'#CgOOQP,59Q,59QO#fQ[O,59QO'yQ[O'#EWO(eQWO,58{O(mQ[O,59SO$lQ[O,59kO$qQ[O,59oO'yQ[O,59sO'yQ[O,59uO'yQ[O,59vO(xQ[O'#D`OOQS,58{,58{OOQP'#Ck'#CkOOQO'#C}'#C}OOQP,59S,59SO)PQWO,59SO)UQWO,59SOOQP'#DR'#DROOQP,59k,59kOOQO'#DV'#DVO)ZQ`O,59oOOQS'#Cp'#CpO$vQdO'#CqO)cQvO'#CsO*pQtO,5:POOQO'#Cx'#CxO)UQWO'#CwO+UQWO'#CyOOQS'#Eg'#EgOOQO'#Dh'#DhO+ZQ[O'#DoO+iQWO'#EkO&TQ[O'#DmO+wQWO'#DpOOQO'#El'#ElO(hQWO,5:^O+|QpO,5:`OOQS'#Dx'#DxO,UQWO,5:bO,ZQ[O,5:bOOQO'#D{'#D{O,cQWO,5:eO,hQWO,5:kO,pQWO,5:mOOQS-E8R-E8RO$vQdO,59{O,xQ[O'#EYO-VQWO,5;UO-VQWO,5;UOOQP1G.l1G.lO-|QXO,5:rOOQO-E8U-E8UOOQS1G.g1G.gOOQP1G.n1G.nO)PQWO1G.nO)UQWO1G.nOOQP1G/V1G/VO.ZQ`O1G/ZO.tQXO1G/_O/[QXO1G/aO/rQXO1G/bO0YQWO,59zO0_Q[O'#DOO0fQdO'#CoOOQP1G/Z1G/ZO$vQdO1G/ZO0mQpO,59]OOQS,59_,59_O$vQdO,59aO0uQWO1G/kOOQS,59c,59cO0zQ!bO,59eO1SQWO'#DhO1_QWO,5:TO1dQWO,5:ZO&TQ[O,5:VO&TQ[O'#EZO1lQWO,5;VO1wQWO,5:XO'yQ[O,5:[OOQS1G/x1G/xOOQS1G/z1G/zOOQS1G/|1G/|O2YQWO1G/|O2_QdO'#D|OOQS1G0P1G0POOQS1G0V1G0VOOQS1G0X1G0XO2mQtO1G/gOOQO,5:t,5:tO3TQ[O,5:tOOQO-E8W-E8WO3bQWO1G0pOOQP7+$Y7+$YOOQP7+$u7+$uO$vQdO7+$uOOQS1G/f1G/fO3mQXO'#EiO3tQWO,59jO3yQtO'#EUO4nQdO'#EfO4xQWO,59ZO4}QpO7+$uOOQS1G.w1G.wOOQS1G.{1G.{OOQS7+%V7+%VO5VQWO1G/PO$vQdO1G/oOOQO1G/u1G/uOOQO1G/q1G/qO5[QWO,5:uOOQO-E8X-E8XO5jQXO1G/vOOQS7+%h7+%hO5qQYO'#CsO(hQWO'#E[O5yQdO,5:hOOQS,5:h,5:hO6XQtO'#EXO$vQdO'#EXO7VQdO7+%ROOQO7+%R7+%ROOQO1G0`1G0`O7jQpO<<HaO7rQWO,5;TOOQP1G/U1G/UOOQS-E8S-E8SO$vQdO'#EVO7zQWO,5;QOOQT1G.u1G.uOOQP<<Ha<<HaOOQS7+$k7+$kO8SQdO7+%ZOOQO7+%b7+%bOOQS,5:v,5:vOOQS-E8Y-E8YOOQS1G0S1G0SO8ZQtO,5:sOOQS-E8V-E8VOOQO<<Hm<<HmOOQPAN={AN={O9XQdO,5:qOOQO-E8T-E8TOOQO<<Hu<<Hu",
+  stateData: "9i~O#UOSROS~OUXOXXO]UO^UOtVOxWO!Y`O!ZYO!gZO!i[O!k]O!n^O!t_O#SQO#XSO~OQeOUXOXXO]UO^UOtVOxWO!Y`O!ZYO!gZO!i[O!k]O!n^O!t_O#SdO#XSO~O#P#^P~P!ZO#SiO~O]nO^nOplOtoOxpO|qO!PsO#QrO#XkO~O!RtO~P#kO`zO#RwO#SvO~O#S{O~O#S}O~OQ!WOb!QOf!WOh!WOn!VO#R!TO#S!PO#[!RO~Ob!YO!b![O!e!]O#S!XO!R#_P~Oh!bOn!VO#S!aO~O#S!dO~Ob!YO!b![O!e!]O#S!XO~O!W#_P~P%bO]WX]!UX^WXpWXtWXxWX|WX!PWX!RWX#QWX#XWX~O]!iO~O!W!jO#P#^X!Q#^X~O#P#^X!Q#^X~P!ZOUXOXXO]UO^UOtVOxWO#SQO#XSO~OplO!RtO~O`!sO#RwO#SvO~O!Q#^P~P!ZOb!zO~Ob!{O~Ov!|Oz!}O~OP#PObgXjgX!WgX!bgX!egX#SgXagXQgXfgXhgXngXpgX!VgX#PgX#RgX#[gXvgX!QgX~Ob!YOj#QO!b![O!e!]O#S!XO!W#_P~Ob#TO~Ob!YO!b![O!e!]O#S#UO~Op#YO!`#XO!R#_X!W#_X~Ob#]O~Oj#QO!W#_O~O!W#`O~Oh#aOn!VO~O!R#bO~O!RtO!`#XO~O!RtO!W#eO~O!W!|X#P!|X!Q!|X~P!ZO!W!jO#P#^a!Q#^a~O]nO^nOtoOxpO|qO!PsO#QrO#XkO~Op!za!R!zaa!za~P-bOv#lOz#mO~O]nO^nOtoOxpO#XkO~Op{i|{i!P{i!R{i#Q{ia{i~P.cOp}i|}i!P}i!R}i#Q}ia}i~P.cOp!Oi|!Oi!P!Oi!R!Oi#Q!Oia!Oi~P.cO!Q#nO~Oa#]P~P'yOa#YP~P$vOa#uOj#QO~O!W#wO~Oh#xOo#xO~O]!^Xa![X!`![X~O]#yO~Oa#zO!`#XO~Op#YO!R#_a!W#_a~O!`#XOp!aa!R!aa!W!aaa!aa~O!W$PO~O!Q$TO!q$RO!r$RO#[$QO~Oj#QOp$VO!V$XO!W!Ti#P!Ti!Q!Ti~P$vO!W!|a#P!|a!Q!|a~P!ZO!W!jO#P#^i!Q#^i~Oa#]X~P#kOa$]O~Oj#QOQ!xXa!xXb!xXf!xXh!xXn!xXp!xX#R!xX#S!xX#[!xX~Op$_Oa#YX~P$vOa$aO~Oj#QOv$bO~Oa$cO~O!`#XOp!}a!R!}a!W!}a~Oa$eO~P-bOP#PO!RgX~O!Q$hO!q$RO!r$RO#[$QO~Oj#QOQ!{Xb!{Xf!{Xh!{Xn!{Xp!{X!V!{X!W!{X#P!{X#R!{X#S!{X#[!{X!Q!{X~Op$VO!V$kO!W!Tq#P!Tq!Q!Tq~P$vOj#QOv$lO~OplOa#]a~Op$_Oa#Ya~Oa$oO~P$vOj#QOQ!{ab!{af!{ah!{an!{ap!{a!V!{a!W!{a#P!{a#R!{a#S!{a#[!{a!Q!{a~Oa!yap!ya~P$vOo#[j!Pj~",
+  goto: ",`#aPPPPP#bP#k#zP#k$Z#kPP$aPPP$g$p$pP%SP$pP$p%j%|PPP&f&l#kP&rP#kP&xP#kP#k#kPPP'O'b'oPP#bPP'v'v(Q'vP'vP'v'vP#bP#bP#bP(T#bP(W(ZPP#bP#bP(^(m({)R)])c)m)sPPPPPP)y*SP*o*rP+h+k+q+z_aOPcgt!j#hkXOPcglqrst!j!z#]#hkROPcglqrst!j!z#]#hQjSR!mkQxUR!qnQ!qzQ#S!UR#k!sq!WY[!Q!i!{!}#Q#f#m#r#y$V$W$_$d$mp!WY[!Q!i!{!}#Q#f#m#r#y$V$W$_$d$mT$R#b$Sq!UY[!Q!i!{!}#Q#f#m#r#y$V$W$_$d$mp!WY[!Q!i!{!}#Q#f#m#r#y$V$W$_$d$mQ!b]R#a!cQyUR!rnQ!qyR#k!rQ|VR!toQ!OWR!upQuTQ!pmQ#^!_Q#d!fQ#e!gR$f$RSfPtQ!lgQ#g!jR$Y#hZePgt!j#ha!^Z_`!S!Y![#X#YR#V!YR!c]R!e^R#c!eQcOSgPtU!hcg#hR#h!jQ#r!{U$^#r$d$mQ$d#yR$m$_Q$`#rR$n$`QmTS!om$[R$[#oQ$W#fR$j$WQ!kfS#i!k#jR#j!lQ#Z!ZR#}#ZQ$S#bR$g$S_bOPcgt!j#h^TOPcgt!j#hQ!nlQ!vqQ!wrQ!xsQ#o!zR$O#]R#s!{Q!SYQ!`[Q#O!QQ#f!i[#q!{#r#y$_$d$mQ#t!}Q#v#QS$U#f$WQ$Z#mR$i$VR#p!zQhPR!ytQ!_ZQ!g`R#R!SU!ZZ`!SQ!f_Q#W!YQ#[![Q#{#XR#|#Y",
+  nodeNames: "⚠ Unit VariableName Comment StyleSheet RuleSet UniversalSelector TagSelector TagName NestingSelector ClassSelector ClassName PseudoClassSelector : :: PseudoClassName PseudoClassName ) ( ArgList ValueName ParenthesizedValue ColorLiteral NumberLiteral StringLiteral BinaryExpression BinOp CallExpression Callee CallLiteral CallTag ParenthesizedContent , PseudoClassName ArgList IdSelector # IdName ] AttributeSelector [ AttributeName MatchOp ChildSelector ChildOp DescendantSelector SiblingSelector SiblingOp } { Block Declaration PropertyName Important ; ImportStatement AtKeyword import KeywordQuery FeatureQuery FeatureName BinaryQuery LogicOp UnaryQuery UnaryQueryOp ParenthesizedQuery SelectorQuery selector MediaStatement media CharsetStatement charset NamespaceStatement namespace NamespaceName KeyframesStatement keyframes KeyframeName KeyframeList from to SupportsStatement supports AtRule Styles",
+  maxTerm: 108,
+  nodeProps: [["openedBy", 17, "(", 48, "{"], ["closedBy", 18, ")", 49, "}"]],
+  propSources: [cssHighlighting],
+  skippedNodes: [0, 3],
+  repeatNodeCount: 8,
+  tokenData: "Lq~R!^OX$}X^%u^p$}pq%uqr)Xrs.Rst/utu6duv$}vw7^wx7oxy9^yz9oz{9t{|:_|}?Q}!O?c!O!P@Q!P!Q@i!Q![Cu![!]Dp!]!^El!^!_$}!_!`E}!`!aF`!a!b$}!b!cG[!c!}$}!}#OHt#O#P$}#P#QIV#Q#R6d#R#T$}#T#UIh#U#c$}#c#dJy#d#o$}#o#pK`#p#q6d#q#rKq#r#sLS#s#y$}#y#z%u#z$f$}$f$g%u$g#BY$}#BY#BZ%u#BZ$IS$}$IS$I_%u$I_$I|$}$I|$JO%u$JO$JT$}$JT$JU%u$JU$KV$}$KV$KW%u$KW&FU$}&FU&FV%u&FV;'S$};'S;=`Lk<%lO$}W%QSOy%^z;'S%^;'S;=`%o<%lO%^W%cSoWOy%^z;'S%^;'S;=`%o<%lO%^W%rP;=`<%l%^~%zh#U~OX%^X^'f^p%^pq'fqy%^z#y%^#y#z'f#z$f%^$f$g'f$g#BY%^#BY#BZ'f#BZ$IS%^$IS$I_'f$I_$I|%^$I|$JO'f$JO$JT%^$JT$JU'f$JU$KV%^$KV$KW'f$KW&FU%^&FU&FV'f&FV;'S%^;'S;=`%o<%lO%^~'mh#U~oWOX%^X^'f^p%^pq'fqy%^z#y%^#y#z'f#z$f%^$f$g'f$g#BY%^#BY#BZ'f#BZ$IS%^$IS$I_'f$I_$I|%^$I|$JO'f$JO$JT%^$JT$JU'f$JU$KV%^$KV$KW'f$KW&FU%^&FU&FV'f&FV;'S%^;'S;=`%o<%lO%^^)[UOy%^z#]%^#]#^)n#^;'S%^;'S;=`%o<%lO%^^)sUoWOy%^z#a%^#a#b*V#b;'S%^;'S;=`%o<%lO%^^*[UoWOy%^z#d%^#d#e*n#e;'S%^;'S;=`%o<%lO%^^*sUoWOy%^z#c%^#c#d+V#d;'S%^;'S;=`%o<%lO%^^+[UoWOy%^z#f%^#f#g+n#g;'S%^;'S;=`%o<%lO%^^+sUoWOy%^z#h%^#h#i,V#i;'S%^;'S;=`%o<%lO%^^,[UoWOy%^z#T%^#T#U,n#U;'S%^;'S;=`%o<%lO%^^,sUoWOy%^z#b%^#b#c-V#c;'S%^;'S;=`%o<%lO%^^-[UoWOy%^z#h%^#h#i-n#i;'S%^;'S;=`%o<%lO%^^-uS!VUoWOy%^z;'S%^;'S;=`%o<%lO%^~.UWOY.RZr.Rrs.ns#O.R#O#P.s#P;'S.R;'S;=`/o<%lO.R~.sOh~~.vRO;'S.R;'S;=`/P;=`O.R~/SXOY.RZr.Rrs.ns#O.R#O#P.s#P;'S.R;'S;=`/o;=`<%l.R<%lO.R~/rP;=`<%l.R_/zYtPOy%^z!Q%^!Q![0j![!c%^!c!i0j!i#T%^#T#Z0j#Z;'S%^;'S;=`%o<%lO%^^0oYoWOy%^z!Q%^!Q![1_![!c%^!c!i1_!i#T%^#T#Z1_#Z;'S%^;'S;=`%o<%lO%^^1dYoWOy%^z!Q%^!Q![2S![!c%^!c!i2S!i#T%^#T#Z2S#Z;'S%^;'S;=`%o<%lO%^^2ZYfUoWOy%^z!Q%^!Q![2y![!c%^!c!i2y!i#T%^#T#Z2y#Z;'S%^;'S;=`%o<%lO%^^3QYfUoWOy%^z!Q%^!Q![3p![!c%^!c!i3p!i#T%^#T#Z3p#Z;'S%^;'S;=`%o<%lO%^^3uYoWOy%^z!Q%^!Q![4e![!c%^!c!i4e!i#T%^#T#Z4e#Z;'S%^;'S;=`%o<%lO%^^4lYfUoWOy%^z!Q%^!Q![5[![!c%^!c!i5[!i#T%^#T#Z5[#Z;'S%^;'S;=`%o<%lO%^^5aYoWOy%^z!Q%^!Q![6P![!c%^!c!i6P!i#T%^#T#Z6P#Z;'S%^;'S;=`%o<%lO%^^6WSfUoWOy%^z;'S%^;'S;=`%o<%lO%^Y6gUOy%^z!_%^!_!`6y!`;'S%^;'S;=`%o<%lO%^Y7QSzQoWOy%^z;'S%^;'S;=`%o<%lO%^X7cSXPOy%^z;'S%^;'S;=`%o<%lO%^~7rWOY7oZw7owx.nx#O7o#O#P8[#P;'S7o;'S;=`9W<%lO7o~8_RO;'S7o;'S;=`8h;=`O7o~8kXOY7oZw7owx.nx#O7o#O#P8[#P;'S7o;'S;=`9W;=`<%l7o<%lO7o~9ZP;=`<%l7o_9cSbVOy%^z;'S%^;'S;=`%o<%lO%^~9tOa~_9{UUPjSOy%^z!_%^!_!`6y!`;'S%^;'S;=`%o<%lO%^_:fWjS!PPOy%^z!O%^!O!P;O!P!Q%^!Q![>T![;'S%^;'S;=`%o<%lO%^^;TUoWOy%^z!Q%^!Q![;g![;'S%^;'S;=`%o<%lO%^^;nYoW#[UOy%^z!Q%^!Q![;g![!g%^!g!h<^!h#X%^#X#Y<^#Y;'S%^;'S;=`%o<%lO%^^<cYoWOy%^z{%^{|=R|}%^}!O=R!O!Q%^!Q![=j![;'S%^;'S;=`%o<%lO%^^=WUoWOy%^z!Q%^!Q![=j![;'S%^;'S;=`%o<%lO%^^=qUoW#[UOy%^z!Q%^!Q![=j![;'S%^;'S;=`%o<%lO%^^>[[oW#[UOy%^z!O%^!O!P;g!P!Q%^!Q![>T![!g%^!g!h<^!h#X%^#X#Y<^#Y;'S%^;'S;=`%o<%lO%^_?VSpVOy%^z;'S%^;'S;=`%o<%lO%^^?hWjSOy%^z!O%^!O!P;O!P!Q%^!Q![>T![;'S%^;'S;=`%o<%lO%^_@VU#XPOy%^z!Q%^!Q![;g![;'S%^;'S;=`%o<%lO%^~@nTjSOy%^z{@}{;'S%^;'S;=`%o<%lO%^~ASUoWOy@}yzAfz{Bm{;'S@};'S;=`Co<%lO@}~AiTOzAfz{Ax{;'SAf;'S;=`Bg<%lOAf~A{VOzAfz{Ax{!PAf!P!QBb!Q;'SAf;'S;=`Bg<%lOAf~BgOR~~BjP;=`<%lAf~BrWoWOy@}yzAfz{Bm{!P@}!P!QC[!Q;'S@};'S;=`Co<%lO@}~CcSoWR~Oy%^z;'S%^;'S;=`%o<%lO%^~CrP;=`<%l@}^Cz[#[UOy%^z!O%^!O!P;g!P!Q%^!Q![>T![!g%^!g!h<^!h#X%^#X#Y<^#Y;'S%^;'S;=`%o<%lO%^XDuU]POy%^z![%^![!]EX!];'S%^;'S;=`%o<%lO%^XE`S^PoWOy%^z;'S%^;'S;=`%o<%lO%^_EqS!WVOy%^z;'S%^;'S;=`%o<%lO%^YFSSzQOy%^z;'S%^;'S;=`%o<%lO%^XFeU|POy%^z!`%^!`!aFw!a;'S%^;'S;=`%o<%lO%^XGOS|PoWOy%^z;'S%^;'S;=`%o<%lO%^XG_WOy%^z!c%^!c!}Gw!}#T%^#T#oGw#o;'S%^;'S;=`%o<%lO%^XHO[!YPoWOy%^z}%^}!OGw!O!Q%^!Q![Gw![!c%^!c!}Gw!}#T%^#T#oGw#o;'S%^;'S;=`%o<%lO%^XHySxPOy%^z;'S%^;'S;=`%o<%lO%^^I[SvUOy%^z;'S%^;'S;=`%o<%lO%^XIkUOy%^z#b%^#b#cI}#c;'S%^;'S;=`%o<%lO%^XJSUoWOy%^z#W%^#W#XJf#X;'S%^;'S;=`%o<%lO%^XJmS!`PoWOy%^z;'S%^;'S;=`%o<%lO%^XJ|UOy%^z#f%^#f#gJf#g;'S%^;'S;=`%o<%lO%^XKeS!RPOy%^z;'S%^;'S;=`%o<%lO%^_KvS!QVOy%^z;'S%^;'S;=`%o<%lO%^ZLXU!PPOy%^z!_%^!_!`6y!`;'S%^;'S;=`%o<%lO%^WLnP;=`<%l$}",
+  tokenizers: [descendant, unitToken, identifiers, 0, 1, 2, 3],
+  topRules: {
+    "StyleSheet": [0, 4],
+    "Styles": [1, 84]
+  },
+  specialized: [{
+    term: 95,
+    get: value => spec_callee[value] || -1
+  }, {
+    term: 56,
+    get: value => spec_AtKeyword[value] || -1
+  }, {
+    term: 96,
+    get: value => spec_identifier[value] || -1
+  }],
+  tokenPrec: 1123
+});
+
+let _properties = null;
+function properties() {
+  if (!_properties && typeof document == "object" && document.body) {
+    let names = [];
+    for (let prop in document.body.style) {
+      if (!/[A-Z]|^-|^(item|length)$/.test(prop)) names.push(prop);
+    }
+    _properties = names.sort().map(name => ({
+      type: "property",
+      label: name
+    }));
+  }
+  return _properties || [];
+}
+const pseudoClasses = /*@__PURE__*/["active", "after", "before", "checked", "default", "disabled", "empty", "enabled", "first-child", "first-letter", "first-line", "first-of-type", "focus", "hover", "in-range", "indeterminate", "invalid", "lang", "last-child", "last-of-type", "link", "not", "nth-child", "nth-last-child", "nth-last-of-type", "nth-of-type", "only-of-type", "only-child", "optional", "out-of-range", "placeholder", "read-only", "read-write", "required", "root", "selection", "target", "valid", "visited"].map(name => ({
+  type: "class",
+  label: name
+}));
+const values = /*@__PURE__*/["above", "absolute", "activeborder", "additive", "activecaption", "after-white-space", "ahead", "alias", "all", "all-scroll", "alphabetic", "alternate", "always", "antialiased", "appworkspace", "asterisks", "attr", "auto", "auto-flow", "avoid", "avoid-column", "avoid-page", "avoid-region", "axis-pan", "background", "backwards", "baseline", "below", "bidi-override", "blink", "block", "block-axis", "bold", "bolder", "border", "border-box", "both", "bottom", "break", "break-all", "break-word", "bullets", "button", "button-bevel", "buttonface", "buttonhighlight", "buttonshadow", "buttontext", "calc", "capitalize", "caps-lock-indicator", "caption", "captiontext", "caret", "cell", "center", "checkbox", "circle", "cjk-decimal", "clear", "clip", "close-quote", "col-resize", "collapse", "color", "color-burn", "color-dodge", "column", "column-reverse", "compact", "condensed", "contain", "content", "contents", "content-box", "context-menu", "continuous", "copy", "counter", "counters", "cover", "crop", "cross", "crosshair", "currentcolor", "cursive", "cyclic", "darken", "dashed", "decimal", "decimal-leading-zero", "default", "default-button", "dense", "destination-atop", "destination-in", "destination-out", "destination-over", "difference", "disc", "discard", "disclosure-closed", "disclosure-open", "document", "dot-dash", "dot-dot-dash", "dotted", "double", "down", "e-resize", "ease", "ease-in", "ease-in-out", "ease-out", "element", "ellipse", "ellipsis", "embed", "end", "ethiopic-abegede-gez", "ethiopic-halehame-aa-er", "ethiopic-halehame-gez", "ew-resize", "exclusion", "expanded", "extends", "extra-condensed", "extra-expanded", "fantasy", "fast", "fill", "fill-box", "fixed", "flat", "flex", "flex-end", "flex-start", "footnotes", "forwards", "from", "geometricPrecision", "graytext", "grid", "groove", "hand", "hard-light", "help", "hidden", "hide", "higher", "highlight", "highlighttext", "horizontal", "hsl", "hsla", "hue", "icon", "ignore", "inactiveborder", "inactivecaption", "inactivecaptiontext", "infinite", "infobackground", "infotext", "inherit", "initial", "inline", "inline-axis", "inline-block", "inline-flex", "inline-grid", "inline-table", "inset", "inside", "intrinsic", "invert", "italic", "justify", "keep-all", "landscape", "large", "larger", "left", "level", "lighter", "lighten", "line-through", "linear", "linear-gradient", "lines", "list-item", "listbox", "listitem", "local", "logical", "loud", "lower", "lower-hexadecimal", "lower-latin", "lower-norwegian", "lowercase", "ltr", "luminosity", "manipulation", "match", "matrix", "matrix3d", "medium", "menu", "menutext", "message-box", "middle", "min-intrinsic", "mix", "monospace", "move", "multiple", "multiple_mask_images", "multiply", "n-resize", "narrower", "ne-resize", "nesw-resize", "no-close-quote", "no-drop", "no-open-quote", "no-repeat", "none", "normal", "not-allowed", "nowrap", "ns-resize", "numbers", "numeric", "nw-resize", "nwse-resize", "oblique", "opacity", "open-quote", "optimizeLegibility", "optimizeSpeed", "outset", "outside", "outside-shape", "overlay", "overline", "padding", "padding-box", "painted", "page", "paused", "perspective", "pinch-zoom", "plus-darker", "plus-lighter", "pointer", "polygon", "portrait", "pre", "pre-line", "pre-wrap", "preserve-3d", "progress", "push-button", "radial-gradient", "radio", "read-only", "read-write", "read-write-plaintext-only", "rectangle", "region", "relative", "repeat", "repeating-linear-gradient", "repeating-radial-gradient", "repeat-x", "repeat-y", "reset", "reverse", "rgb", "rgba", "ridge", "right", "rotate", "rotate3d", "rotateX", "rotateY", "rotateZ", "round", "row", "row-resize", "row-reverse", "rtl", "run-in", "running", "s-resize", "sans-serif", "saturation", "scale", "scale3d", "scaleX", "scaleY", "scaleZ", "screen", "scroll", "scrollbar", "scroll-position", "se-resize", "self-start", "self-end", "semi-condensed", "semi-expanded", "separate", "serif", "show", "single", "skew", "skewX", "skewY", "skip-white-space", "slide", "slider-horizontal", "slider-vertical", "sliderthumb-horizontal", "sliderthumb-vertical", "slow", "small", "small-caps", "small-caption", "smaller", "soft-light", "solid", "source-atop", "source-in", "source-out", "source-over", "space", "space-around", "space-between", "space-evenly", "spell-out", "square", "start", "static", "status-bar", "stretch", "stroke", "stroke-box", "sub", "subpixel-antialiased", "svg_masks", "super", "sw-resize", "symbolic", "symbols", "system-ui", "table", "table-caption", "table-cell", "table-column", "table-column-group", "table-footer-group", "table-header-group", "table-row", "table-row-group", "text", "text-bottom", "text-top", "textarea", "textfield", "thick", "thin", "threeddarkshadow", "threedface", "threedhighlight", "threedlightshadow", "threedshadow", "to", "top", "transform", "translate", "translate3d", "translateX", "translateY", "translateZ", "transparent", "ultra-condensed", "ultra-expanded", "underline", "unidirectional-pan", "unset", "up", "upper-latin", "uppercase", "url", "var", "vertical", "vertical-text", "view-box", "visible", "visibleFill", "visiblePainted", "visibleStroke", "visual", "w-resize", "wait", "wave", "wider", "window", "windowframe", "windowtext", "words", "wrap", "wrap-reverse", "x-large", "x-small", "xor", "xx-large", "xx-small"].map(name => ({
+  type: "keyword",
+  label: name
+})).concat( /*@__PURE__*/["aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige", "bisque", "black", "blanchedalmond", "blue", "blueviolet", "brown", "burlywood", "cadetblue", "chartreuse", "chocolate", "coral", "cornflowerblue", "cornsilk", "crimson", "cyan", "darkblue", "darkcyan", "darkgoldenrod", "darkgray", "darkgreen", "darkkhaki", "darkmagenta", "darkolivegreen", "darkorange", "darkorchid", "darkred", "darksalmon", "darkseagreen", "darkslateblue", "darkslategray", "darkturquoise", "darkviolet", "deeppink", "deepskyblue", "dimgray", "dodgerblue", "firebrick", "floralwhite", "forestgreen", "fuchsia", "gainsboro", "ghostwhite", "gold", "goldenrod", "gray", "grey", "green", "greenyellow", "honeydew", "hotpink", "indianred", "indigo", "ivory", "khaki", "lavender", "lavenderblush", "lawngreen", "lemonchiffon", "lightblue", "lightcoral", "lightcyan", "lightgoldenrodyellow", "lightgray", "lightgreen", "lightpink", "lightsalmon", "lightseagreen", "lightskyblue", "lightslategray", "lightsteelblue", "lightyellow", "lime", "limegreen", "linen", "magenta", "maroon", "mediumaquamarine", "mediumblue", "mediumorchid", "mediumpurple", "mediumseagreen", "mediumslateblue", "mediumspringgreen", "mediumturquoise", "mediumvioletred", "midnightblue", "mintcream", "mistyrose", "moccasin", "navajowhite", "navy", "oldlace", "olive", "olivedrab", "orange", "orangered", "orchid", "palegoldenrod", "palegreen", "paleturquoise", "palevioletred", "papayawhip", "peachpuff", "peru", "pink", "plum", "powderblue", "purple", "rebeccapurple", "red", "rosybrown", "royalblue", "saddlebrown", "salmon", "sandybrown", "seagreen", "seashell", "sienna", "silver", "skyblue", "slateblue", "slategray", "snow", "springgreen", "steelblue", "tan", "teal", "thistle", "tomato", "turquoise", "violet", "wheat", "white", "whitesmoke", "yellow", "yellowgreen"].map(name => ({
+  type: "constant",
+  label: name
+})));
+const tags = /*@__PURE__*/["a", "abbr", "address", "article", "aside", "b", "bdi", "bdo", "blockquote", "body", "br", "button", "canvas", "caption", "cite", "code", "col", "colgroup", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt", "em", "figcaption", "figure", "footer", "form", "header", "hgroup", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "html", "i", "iframe", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "meter", "nav", "ol", "output", "p", "pre", "ruby", "section", "select", "small", "source", "span", "strong", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "tr", "u", "ul"].map(name => ({
+  type: "type",
+  label: name
+}));
+const identifier$1 = /^[\w-]*/;
+/**
+CSS property and value keyword completion source.
+*/
+const cssCompletionSource = context => {
+  let {
+      state,
+      pos
+    } = context,
+    node = syntaxTree(state).resolveInner(pos, -1);
+  if (node.name == "PropertyName") return {
+    from: node.from,
+    options: properties(),
+    validFor: identifier$1
+  };
+  if (node.name == "ValueName") return {
+    from: node.from,
+    options: values,
+    validFor: identifier$1
+  };
+  if (node.name == "PseudoClassName") return {
+    from: node.from,
+    options: pseudoClasses,
+    validFor: identifier$1
+  };
+  if (node.name == "TagName") {
+    for (let {
+      parent
+    } = node; parent; parent = parent.parent) if (parent.name == "Block") return {
+      from: node.from,
+      options: properties(),
+      validFor: identifier$1
+    };
+    return {
+      from: node.from,
+      options: tags,
+      validFor: identifier$1
+    };
+  }
+  if (!context.explicit) return null;
+  let above = node.resolve(pos),
+    before = above.childBefore(pos);
+  if (before && before.name == ":" && above.name == "PseudoClassSelector") return {
+    from: pos,
+    options: pseudoClasses,
+    validFor: identifier$1
+  };
+  if (before && before.name == ":" && above.name == "Declaration" || above.name == "ArgList") return {
+    from: pos,
+    options: values,
+    validFor: identifier$1
+  };
+  if (above.name == "Block") return {
+    from: pos,
+    options: properties(),
+    validFor: identifier$1
+  };
+  return null;
+};
+
+/**
+A language provider based on the [Lezer CSS
+parser](https://github.com/lezer-parser/css), extended with
+highlighting and indentation information.
+*/
+const cssLanguage = /*@__PURE__*/LRLanguage.define({
+  parser: /*@__PURE__*/parser$2.configure({
+    props: [/*@__PURE__*/indentNodeProp.add({
+      Declaration: /*@__PURE__*/continuedIndent()
+    }), /*@__PURE__*/foldNodeProp.add({
+      Block: foldInside
+    })]
+  }),
+  languageData: {
+    commentTokens: {
+      block: {
+        open: "/*",
+        close: "*/"
+      }
+    },
+    indentOnInput: /^\s*\}$/,
+    wordChars: "-"
+  }
+});
+/**
+Language support for CSS.
+*/
+function css() {
+  return new LanguageSupport(cssLanguage, cssLanguage.data.of({
+    autocomplete: cssCompletionSource
+  }));
+}
+
+const Targets = ["_blank", "_self", "_top", "_parent"];
+const Charsets = ["ascii", "utf-8", "utf-16", "latin1", "latin1"];
+const Methods = ["get", "post", "put", "delete"];
+const Encs = ["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"];
+const Bool = ["true", "false"];
+const S = {}; // Empty tag spec
+const Tags = {
+  a: {
+    attrs: {
+      href: null,
+      ping: null,
+      type: null,
+      media: null,
+      target: Targets,
+      hreflang: null
+    }
+  },
+  abbr: S,
+  acronym: S,
+  address: S,
+  applet: S,
+  area: {
+    attrs: {
+      alt: null,
+      coords: null,
+      href: null,
+      target: null,
+      ping: null,
+      media: null,
+      hreflang: null,
+      type: null,
+      shape: ["default", "rect", "circle", "poly"]
+    }
+  },
+  article: S,
+  aside: S,
+  audio: {
+    attrs: {
+      src: null,
+      mediagroup: null,
+      crossorigin: ["anonymous", "use-credentials"],
+      preload: ["none", "metadata", "auto"],
+      autoplay: ["autoplay"],
+      loop: ["loop"],
+      controls: ["controls"]
+    }
+  },
+  b: S,
+  base: {
+    attrs: {
+      href: null,
+      target: Targets
+    }
+  },
+  basefont: S,
+  bdi: S,
+  bdo: S,
+  big: S,
+  blockquote: {
+    attrs: {
+      cite: null
+    }
+  },
+  body: S,
+  br: S,
+  button: {
+    attrs: {
+      form: null,
+      formaction: null,
+      name: null,
+      value: null,
+      autofocus: ["autofocus"],
+      disabled: ["autofocus"],
+      formenctype: Encs,
+      formmethod: Methods,
+      formnovalidate: ["novalidate"],
+      formtarget: Targets,
+      type: ["submit", "reset", "button"]
+    }
+  },
+  canvas: {
+    attrs: {
+      width: null,
+      height: null
+    }
+  },
+  caption: S,
+  center: S,
+  cite: S,
+  code: S,
+  col: {
+    attrs: {
+      span: null
+    }
+  },
+  colgroup: {
+    attrs: {
+      span: null
+    }
+  },
+  command: {
+    attrs: {
+      type: ["command", "checkbox", "radio"],
+      label: null,
+      icon: null,
+      radiogroup: null,
+      command: null,
+      title: null,
+      disabled: ["disabled"],
+      checked: ["checked"]
+    }
+  },
+  data: {
+    attrs: {
+      value: null
+    }
+  },
+  datagrid: {
+    attrs: {
+      disabled: ["disabled"],
+      multiple: ["multiple"]
+    }
+  },
+  datalist: {
+    attrs: {
+      data: null
+    }
+  },
+  dd: S,
+  del: {
+    attrs: {
+      cite: null,
+      datetime: null
+    }
+  },
+  details: {
+    attrs: {
+      open: ["open"]
+    }
+  },
+  dfn: S,
+  dir: S,
+  div: S,
+  dl: S,
+  dt: S,
+  em: S,
+  embed: {
+    attrs: {
+      src: null,
+      type: null,
+      width: null,
+      height: null
+    }
+  },
+  eventsource: {
+    attrs: {
+      src: null
+    }
+  },
+  fieldset: {
+    attrs: {
+      disabled: ["disabled"],
+      form: null,
+      name: null
+    }
+  },
+  figcaption: S,
+  figure: S,
+  font: S,
+  footer: S,
+  form: {
+    attrs: {
+      action: null,
+      name: null,
+      "accept-charset": Charsets,
+      autocomplete: ["on", "off"],
+      enctype: Encs,
+      method: Methods,
+      novalidate: ["novalidate"],
+      target: Targets
+    }
+  },
+  frame: S,
+  frameset: S,
+  h1: S,
+  h2: S,
+  h3: S,
+  h4: S,
+  h5: S,
+  h6: S,
+  head: {
+    children: ["title", "base", "link", "style", "meta", "script", "noscript", "command"]
+  },
+  header: S,
+  hgroup: S,
+  hr: S,
+  html: {
+    attrs: {
+      manifest: null
+    }
+  },
+  i: S,
+  iframe: {
+    attrs: {
+      src: null,
+      srcdoc: null,
+      name: null,
+      width: null,
+      height: null,
+      sandbox: ["allow-top-navigation", "allow-same-origin", "allow-forms", "allow-scripts"],
+      seamless: ["seamless"]
+    }
+  },
+  img: {
+    attrs: {
+      alt: null,
+      src: null,
+      ismap: null,
+      usemap: null,
+      width: null,
+      height: null,
+      crossorigin: ["anonymous", "use-credentials"]
+    }
+  },
+  input: {
+    attrs: {
+      alt: null,
+      dirname: null,
+      form: null,
+      formaction: null,
+      height: null,
+      list: null,
+      max: null,
+      maxlength: null,
+      min: null,
+      name: null,
+      pattern: null,
+      placeholder: null,
+      size: null,
+      src: null,
+      step: null,
+      value: null,
+      width: null,
+      accept: ["audio/*", "video/*", "image/*"],
+      autocomplete: ["on", "off"],
+      autofocus: ["autofocus"],
+      checked: ["checked"],
+      disabled: ["disabled"],
+      formenctype: Encs,
+      formmethod: Methods,
+      formnovalidate: ["novalidate"],
+      formtarget: Targets,
+      multiple: ["multiple"],
+      readonly: ["readonly"],
+      required: ["required"],
+      type: ["hidden", "text", "search", "tel", "url", "email", "password", "datetime", "date", "month", "week", "time", "datetime-local", "number", "range", "color", "checkbox", "radio", "file", "submit", "image", "reset", "button"]
+    }
+  },
+  ins: {
+    attrs: {
+      cite: null,
+      datetime: null
+    }
+  },
+  kbd: S,
+  keygen: {
+    attrs: {
+      challenge: null,
+      form: null,
+      name: null,
+      autofocus: ["autofocus"],
+      disabled: ["disabled"],
+      keytype: ["RSA"]
+    }
+  },
+  label: {
+    attrs: {
+      for: null,
+      form: null
+    }
+  },
+  legend: S,
+  li: {
+    attrs: {
+      value: null
+    }
+  },
+  link: {
+    attrs: {
+      href: null,
+      type: null,
+      hreflang: null,
+      media: null,
+      sizes: ["all", "16x16", "16x16 32x32", "16x16 32x32 64x64"]
+    }
+  },
+  map: {
+    attrs: {
+      name: null
+    }
+  },
+  mark: S,
+  menu: {
+    attrs: {
+      label: null,
+      type: ["list", "context", "toolbar"]
+    }
+  },
+  meta: {
+    attrs: {
+      content: null,
+      charset: Charsets,
+      name: ["viewport", "application-name", "author", "description", "generator", "keywords"],
+      "http-equiv": ["content-language", "content-type", "default-style", "refresh"]
+    }
+  },
+  meter: {
+    attrs: {
+      value: null,
+      min: null,
+      low: null,
+      high: null,
+      max: null,
+      optimum: null
+    }
+  },
+  nav: S,
+  noframes: S,
+  noscript: S,
+  object: {
+    attrs: {
+      data: null,
+      type: null,
+      name: null,
+      usemap: null,
+      form: null,
+      width: null,
+      height: null,
+      typemustmatch: ["typemustmatch"]
+    }
+  },
+  ol: {
+    attrs: {
+      reversed: ["reversed"],
+      start: null,
+      type: ["1", "a", "A", "i", "I"]
+    },
+    children: ["li", "script", "template", "ul", "ol"]
+  },
+  optgroup: {
+    attrs: {
+      disabled: ["disabled"],
+      label: null
+    }
+  },
+  option: {
+    attrs: {
+      disabled: ["disabled"],
+      label: null,
+      selected: ["selected"],
+      value: null
+    }
+  },
+  output: {
+    attrs: {
+      for: null,
+      form: null,
+      name: null
+    }
+  },
+  p: S,
+  param: {
+    attrs: {
+      name: null,
+      value: null
+    }
+  },
+  pre: S,
+  progress: {
+    attrs: {
+      value: null,
+      max: null
+    }
+  },
+  q: {
+    attrs: {
+      cite: null
+    }
+  },
+  rp: S,
+  rt: S,
+  ruby: S,
+  s: S,
+  samp: S,
+  script: {
+    attrs: {
+      type: ["text/javascript"],
+      src: null,
+      async: ["async"],
+      defer: ["defer"],
+      charset: Charsets
+    }
+  },
+  section: S,
+  select: {
+    attrs: {
+      form: null,
+      name: null,
+      size: null,
+      autofocus: ["autofocus"],
+      disabled: ["disabled"],
+      multiple: ["multiple"]
+    }
+  },
+  slot: {
+    attrs: {
+      name: null
+    }
+  },
+  small: S,
+  source: {
+    attrs: {
+      src: null,
+      type: null,
+      media: null
+    }
+  },
+  span: S,
+  strike: S,
+  strong: S,
+  style: {
+    attrs: {
+      type: ["text/css"],
+      media: null,
+      scoped: null
+    }
+  },
+  sub: S,
+  summary: S,
+  sup: S,
+  table: S,
+  tbody: S,
+  td: {
+    attrs: {
+      colspan: null,
+      rowspan: null,
+      headers: null
+    }
+  },
+  template: S,
+  textarea: {
+    attrs: {
+      dirname: null,
+      form: null,
+      maxlength: null,
+      name: null,
+      placeholder: null,
+      rows: null,
+      cols: null,
+      autofocus: ["autofocus"],
+      disabled: ["disabled"],
+      readonly: ["readonly"],
+      required: ["required"],
+      wrap: ["soft", "hard"]
+    }
+  },
+  tfoot: S,
+  th: {
+    attrs: {
+      colspan: null,
+      rowspan: null,
+      headers: null,
+      scope: ["row", "col", "rowgroup", "colgroup"]
+    }
+  },
+  thead: S,
+  time: {
+    attrs: {
+      datetime: null
+    }
+  },
+  title: S,
+  tr: S,
+  track: {
+    attrs: {
+      src: null,
+      label: null,
+      default: null,
+      kind: ["subtitles", "captions", "descriptions", "chapters", "metadata"],
+      srclang: null
+    }
+  },
+  tt: S,
+  u: S,
+  ul: {
+    children: ["li", "script", "template", "ul", "ol"]
+  },
+  var: S,
+  video: {
+    attrs: {
+      src: null,
+      poster: null,
+      width: null,
+      height: null,
+      crossorigin: ["anonymous", "use-credentials"],
+      preload: ["auto", "metadata", "none"],
+      autoplay: ["autoplay"],
+      mediagroup: ["movie"],
+      muted: ["muted"],
+      controls: ["controls"]
+    }
+  },
+  wbr: S
+};
+const GlobalAttrs = {
+  accesskey: null,
+  class: null,
+  contenteditable: Bool,
+  contextmenu: null,
+  dir: ["ltr", "rtl", "auto"],
+  draggable: ["true", "false", "auto"],
+  dropzone: ["copy", "move", "link", "string:", "file:"],
+  hidden: ["hidden"],
+  id: null,
+  inert: ["inert"],
+  itemid: null,
+  itemprop: null,
+  itemref: null,
+  itemscope: ["itemscope"],
+  itemtype: null,
+  lang: ["ar", "bn", "de", "en-GB", "en-US", "es", "fr", "hi", "id", "ja", "pa", "pt", "ru", "tr", "zh"],
+  spellcheck: Bool,
+  autocorrect: Bool,
+  autocapitalize: Bool,
+  style: null,
+  tabindex: null,
+  title: null,
+  translate: ["yes", "no"],
+  onclick: null,
+  rel: ["stylesheet", "alternate", "author", "bookmark", "help", "license", "next", "nofollow", "noreferrer", "prefetch", "prev", "search", "tag"],
+  role: /*@__PURE__*/"alert application article banner button cell checkbox complementary contentinfo dialog document feed figure form grid gridcell heading img list listbox listitem main navigation region row rowgroup search switch tab table tabpanel textbox timer".split(" "),
+  "aria-activedescendant": null,
+  "aria-atomic": Bool,
+  "aria-autocomplete": ["inline", "list", "both", "none"],
+  "aria-busy": Bool,
+  "aria-checked": ["true", "false", "mixed", "undefined"],
+  "aria-controls": null,
+  "aria-describedby": null,
+  "aria-disabled": Bool,
+  "aria-dropeffect": null,
+  "aria-expanded": ["true", "false", "undefined"],
+  "aria-flowto": null,
+  "aria-grabbed": ["true", "false", "undefined"],
+  "aria-haspopup": Bool,
+  "aria-hidden": Bool,
+  "aria-invalid": ["true", "false", "grammar", "spelling"],
+  "aria-label": null,
+  "aria-labelledby": null,
+  "aria-level": null,
+  "aria-live": ["off", "polite", "assertive"],
+  "aria-multiline": Bool,
+  "aria-multiselectable": Bool,
+  "aria-owns": null,
+  "aria-posinset": null,
+  "aria-pressed": ["true", "false", "mixed", "undefined"],
+  "aria-readonly": Bool,
+  "aria-relevant": null,
+  "aria-required": Bool,
+  "aria-selected": ["true", "false", "undefined"],
+  "aria-setsize": null,
+  "aria-sort": ["ascending", "descending", "none", "other"],
+  "aria-valuemax": null,
+  "aria-valuemin": null,
+  "aria-valuenow": null,
+  "aria-valuetext": null
+};
+class Schema {
+  constructor(extraTags, extraAttrs) {
+    this.tags = Object.assign(Object.assign({}, Tags), extraTags);
+    this.globalAttrs = Object.assign(Object.assign({}, GlobalAttrs), extraAttrs);
+    this.allTags = Object.keys(this.tags);
+    this.globalAttrNames = Object.keys(this.globalAttrs);
+  }
+}
+Schema.default = /*@__PURE__*/new Schema();
+function elementName(doc, tree, max = doc.length) {
+  if (!tree) return "";
+  let tag = tree.firstChild;
+  let name = tag && tag.getChild("TagName");
+  return name ? doc.sliceString(name.from, Math.min(name.to, max)) : "";
+}
+function findParentElement(tree, skip = false) {
+  for (let cur = tree.parent; cur; cur = cur.parent) if (cur.name == "Element") {
+    if (skip) skip = false;else return cur;
+  }
+  return null;
+}
+function allowedChildren(doc, tree, schema) {
+  let parentInfo = schema.tags[elementName(doc, findParentElement(tree, true))];
+  return (parentInfo === null || parentInfo === void 0 ? void 0 : parentInfo.children) || schema.allTags;
+}
+function openTags(doc, tree) {
+  let open = [];
+  for (let parent = tree; parent = findParentElement(parent);) {
+    let tagName = elementName(doc, parent);
+    if (tagName && parent.lastChild.name == "CloseTag") break;
+    if (tagName && open.indexOf(tagName) < 0 && (tree.name == "EndTag" || tree.from >= parent.firstChild.to)) open.push(tagName);
+  }
+  return open;
+}
+const identifier = /^[:\-\.\w\u00b7-\uffff]*$/;
+function completeTag(state, schema, tree, from, to) {
+  let end = /\s*>/.test(state.sliceDoc(to, to + 5)) ? "" : ">";
+  return {
+    from,
+    to,
+    options: allowedChildren(state.doc, tree, schema).map(tagName => ({
+      label: tagName,
+      type: "type"
+    })).concat(openTags(state.doc, tree).map((tag, i) => ({
+      label: "/" + tag,
+      apply: "/" + tag + end,
+      type: "type",
+      boost: 99 - i
+    }))),
+    validFor: /^\/?[:\-\.\w\u00b7-\uffff]*$/
+  };
+}
+function completeCloseTag(state, tree, from, to) {
+  let end = /\s*>/.test(state.sliceDoc(to, to + 5)) ? "" : ">";
+  return {
+    from,
+    to,
+    options: openTags(state.doc, tree).map((tag, i) => ({
+      label: tag,
+      apply: tag + end,
+      type: "type",
+      boost: 99 - i
+    })),
+    validFor: identifier
+  };
+}
+function completeStartTag(state, schema, tree, pos) {
+  let options = [],
+    level = 0;
+  for (let tagName of allowedChildren(state.doc, tree, schema)) options.push({
+    label: "<" + tagName,
+    type: "type"
+  });
+  for (let open of openTags(state.doc, tree)) options.push({
+    label: "</" + open + ">",
+    type: "type",
+    boost: 99 - level++
+  });
+  return {
+    from: pos,
+    to: pos,
+    options,
+    validFor: /^<\/?[:\-\.\w\u00b7-\uffff]*$/
+  };
+}
+function completeAttrName(state, schema, tree, from, to) {
+  let elt = findParentElement(tree),
+    info = elt ? schema.tags[elementName(state.doc, elt)] : null;
+  let names = info && info.attrs ? Object.keys(info.attrs).concat(schema.globalAttrNames) : schema.globalAttrNames;
+  return {
+    from,
+    to,
+    options: names.map(attrName => ({
+      label: attrName,
+      type: "property"
+    })),
+    validFor: identifier
+  };
+}
+function completeAttrValue(state, schema, tree, from, to) {
+  var _a;
+  let nameNode = (_a = tree.parent) === null || _a === void 0 ? void 0 : _a.getChild("AttributeName");
+  let options = [],
+    token = undefined;
+  if (nameNode) {
+    let attrName = state.sliceDoc(nameNode.from, nameNode.to);
+    let attrs = schema.globalAttrs[attrName];
+    if (!attrs) {
+      let elt = findParentElement(tree),
+        info = elt ? schema.tags[elementName(state.doc, elt)] : null;
+      attrs = (info === null || info === void 0 ? void 0 : info.attrs) && info.attrs[attrName];
+    }
+    if (attrs) {
+      let base = state.sliceDoc(from, to).toLowerCase(),
+        quoteStart = '"',
+        quoteEnd = '"';
+      if (/^['"]/.test(base)) {
+        token = base[0] == '"' ? /^[^"]*$/ : /^[^']*$/;
+        quoteStart = "";
+        quoteEnd = state.sliceDoc(to, to + 1) == base[0] ? "" : base[0];
+        base = base.slice(1);
+        from++;
+      } else {
+        token = /^[^\s<>='"]*$/;
+      }
+      for (let value of attrs) options.push({
+        label: value,
+        apply: quoteStart + value + quoteEnd,
+        type: "constant"
+      });
+    }
+  }
+  return {
+    from,
+    to,
+    options,
+    validFor: token
+  };
+}
+function htmlCompletionFor(schema, context) {
+  let {
+      state,
+      pos
+    } = context,
+    around = syntaxTree(state).resolveInner(pos),
+    tree = around.resolve(pos, -1);
+  for (let scan = pos, before; around == tree && (before = tree.childBefore(scan));) {
+    let last = before.lastChild;
+    if (!last || !last.type.isError || last.from < last.to) break;
+    around = tree = before;
+    scan = last.from;
+  }
+  if (tree.name == "TagName") {
+    return tree.parent && /CloseTag$/.test(tree.parent.name) ? completeCloseTag(state, tree, tree.from, pos) : completeTag(state, schema, tree, tree.from, pos);
+  } else if (tree.name == "StartTag") {
+    return completeTag(state, schema, tree, pos, pos);
+  } else if (tree.name == "StartCloseTag" || tree.name == "IncompleteCloseTag") {
+    return completeCloseTag(state, tree, pos, pos);
+  } else if (context.explicit && (tree.name == "OpenTag" || tree.name == "SelfClosingTag") || tree.name == "AttributeName") {
+    return completeAttrName(state, schema, tree, tree.name == "AttributeName" ? tree.from : pos, pos);
+  } else if (tree.name == "Is" || tree.name == "AttributeValue" || tree.name == "UnquotedAttributeValue") {
+    return completeAttrValue(state, schema, tree, tree.name == "Is" ? pos : tree.from, pos);
+  } else if (context.explicit && (around.name == "Element" || around.name == "Text" || around.name == "Document")) {
+    return completeStartTag(state, schema, tree, pos);
+  } else {
+    return null;
+  }
+}
+/**
+Create a completion source for HTML extended with additional tags
+or attributes.
+*/
+function htmlCompletionSourceWith(config) {
+  let {
+    extraTags,
+    extraGlobalAttributes: extraAttrs
+  } = config;
+  let schema = extraAttrs || extraTags ? new Schema(extraTags, extraAttrs) : Schema.default;
+  return context => htmlCompletionFor(schema, context);
+}
+
+/**
+A language provider based on the [Lezer HTML
+parser](https://github.com/lezer-parser/html), extended with the
+JavaScript and CSS parsers to parse the content of `<script>` and
+`<style>` tags.
+*/
+const htmlLanguage = /*@__PURE__*/LRLanguage.define({
+  parser: /*@__PURE__*/parser$3.configure({
+    props: [/*@__PURE__*/indentNodeProp.add({
+      Element(context) {
+        let after = /^(\s*)(<\/)?/.exec(context.textAfter);
+        if (context.node.to <= context.pos + after[0].length) return context.continue();
+        return context.lineIndent(context.node.from) + (after[2] ? 0 : context.unit);
+      },
+      "OpenTag CloseTag SelfClosingTag"(context) {
+        return context.column(context.node.from) + context.unit;
+      },
+      Document(context) {
+        if (context.pos + /\s*/.exec(context.textAfter)[0].length < context.node.to) return context.continue();
+        let endElt = null,
+          close;
+        for (let cur = context.node;;) {
+          let last = cur.lastChild;
+          if (!last || last.name != "Element" || last.to != cur.to) break;
+          endElt = cur = last;
+        }
+        if (endElt && !((close = endElt.lastChild) && (close.name == "CloseTag" || close.name == "SelfClosingTag"))) return context.lineIndent(endElt.from) + context.unit;
+        return null;
+      }
+    }), /*@__PURE__*/foldNodeProp.add({
+      Element(node) {
+        let first = node.firstChild,
+          last = node.lastChild;
+        if (!first || first.name != "OpenTag") return null;
+        return {
+          from: first.to,
+          to: last.name == "CloseTag" ? last.from : node.to
+        };
+      }
+    })],
+    wrap: /*@__PURE__*/configureNesting([{
+      tag: "script",
+      attrs(attrs) {
+        return !attrs.type || /^(?:text|application)\/(?:x-)?(?:java|ecma)script$|^module$|^$/i.test(attrs.type);
+      },
+      parser: javascriptLanguage.parser
+    }, {
+      tag: "style",
+      attrs(attrs) {
+        return (!attrs.lang || attrs.lang == "css") && (!attrs.type || /^(text\/)?(x-)?(stylesheet|css)$/i.test(attrs.type));
+      },
+      parser: cssLanguage.parser
+    }])
+  }),
+  languageData: {
+    commentTokens: {
+      block: {
+        open: "<!--",
+        close: "-->"
+      }
+    },
+    indentOnInput: /^\s*<\/\w+\W$/,
+    wordChars: "-._"
+  }
+});
+/**
+Language support for HTML, including
+[`htmlCompletion`](https://codemirror.net/6/docs/ref/#lang-html.htmlCompletion) and JavaScript and
+CSS support extensions.
+*/
+function html(config = {}) {
+  let lang = htmlLanguage;
+  if (config.matchClosingTags === false) lang = lang.configure({
+    dialect: "noMatch"
+  });
+  return new LanguageSupport(lang, [htmlLanguage.data.of({
+    autocomplete: htmlCompletionSourceWith(config)
+  }), config.autoCloseTags !== false ? autoCloseTags : [], javascript().support, css().support]);
+}
+/**
+Extension that will automatically insert close tags when a `>` or
+`/` is typed.
+*/
+const autoCloseTags = /*@__PURE__*/EditorView.inputHandler.of((view, from, to, text) => {
+  if (view.composing || view.state.readOnly || from != to || text != ">" && text != "/" || !htmlLanguage.isActiveAt(view.state, from, -1)) return false;
+  let {
+    state
+  } = view;
+  let changes = state.changeByRange(range => {
+    var _a, _b, _c;
+    let {
+        head
+      } = range,
+      around = syntaxTree(state).resolveInner(head, -1),
+      name;
+    if (around.name == "TagName" || around.name == "StartTag") around = around.parent;
+    if (text == ">" && around.name == "OpenTag") {
+      if (((_b = (_a = around.parent) === null || _a === void 0 ? void 0 : _a.lastChild) === null || _b === void 0 ? void 0 : _b.name) != "CloseTag" && (name = elementName(state.doc, around.parent, head))) return {
+        range: EditorSelection.cursor(head + 1),
+        changes: {
+          from: head,
+          insert: `></${name}>`
+        }
+      };
+    } else if (text == "/" && around.name == "OpenTag") {
+      let empty = around.parent,
+        base = empty === null || empty === void 0 ? void 0 : empty.parent;
+      if (empty.from == head - 1 && ((_c = base.lastChild) === null || _c === void 0 ? void 0 : _c.name) != "CloseTag" && (name = elementName(state.doc, base, head))) {
+        let insert = `/${name}>`;
+        return {
+          range: EditorSelection.cursor(head + insert.length),
+          changes: {
+            from: head,
+            insert
+          }
+        };
+      }
+    }
+    return {
+      range
+    };
+  });
+  if (changes.changes.empty) return false;
+  view.dispatch(changes, {
+    userEvent: "input.type",
+    scrollIntoView: true
+  });
+  return true;
+});
+
+const jsonHighlighting = styleTags({
+  String: tags$1.string,
+  Number: tags$1.number,
+  "True False": tags$1.bool,
+  PropertyName: tags$1.propertyName,
+  Null: tags$1.null,
+  ",": tags$1.separator,
+  "[ ]": tags$1.squareBracket,
+  "{ }": tags$1.brace
+});
+
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+const parser$1 = LRParser.deserialize({
+  version: 14,
+  states: "$bOVQPOOOOQO'#Cb'#CbOnQPO'#CeOvQPO'#CjOOQO'#Cp'#CpQOQPOOOOQO'#Cg'#CgO}QPO'#CfO!SQPO'#CrOOQO,59P,59PO![QPO,59PO!aQPO'#CuOOQO,59U,59UO!iQPO,59UOVQPO,59QOqQPO'#CkO!nQPO,59^OOQO1G.k1G.kOVQPO'#ClO!vQPO,59aOOQO1G.p1G.pOOQO1G.l1G.lOOQO,59V,59VOOQO-E6i-E6iOOQO,59W,59WOOQO-E6j-E6j",
+  stateData: "#O~OcOS~OQSORSOSSOTSOWQO]ROePO~OVXOeUO~O[[O~PVOg^O~Oh_OVfX~OVaO~OhbO[iX~O[dO~Oh_OVfa~OhbO[ia~O",
+  goto: "!kjPPPPPPkPPkqwPPk{!RPPP!XP!ePP!hXSOR^bQWQRf_TVQ_Q`WRg`QcZRicQTOQZRQe^RhbRYQR]R",
+  nodeNames: "⚠ JsonText True False Null Number String } { Object Property PropertyName ] [ Array",
+  maxTerm: 25,
+  nodeProps: [["openedBy", 7, "{", 12, "["], ["closedBy", 8, "}", 13, "]"]],
+  propSources: [jsonHighlighting],
+  skippedNodes: [0],
+  repeatNodeCount: 2,
+  tokenData: "(p~RaXY!WYZ!W]^!Wpq!Wrs!]|}$i}!O$n!Q!R$w!R![&V![!]&h!}#O&m#P#Q&r#Y#Z&w#b#c'f#h#i'}#o#p(f#q#r(k~!]Oc~~!`Upq!]qr!]rs!rs#O!]#O#P!w#P~!]~!wOe~~!zXrs!]!P!Q!]#O#P!]#U#V!]#Y#Z!]#b#c!]#f#g!]#h#i!]#i#j#g~#jR!Q![#s!c!i#s#T#Z#s~#vR!Q![$P!c!i$P#T#Z$P~$SR!Q![$]!c!i$]#T#Z$]~$`R!Q![!]!c!i!]#T#Z!]~$nOh~~$qQ!Q!R$w!R![&V~$|RT~!O!P%V!g!h%k#X#Y%k~%YP!Q![%]~%bRT~!Q![%]!g!h%k#X#Y%k~%nR{|%w}!O%w!Q![%}~%zP!Q![%}~&SPT~!Q![%}~&[ST~!O!P%V!Q![&V!g!h%k#X#Y%k~&mOg~~&rO]~~&wO[~~&zP#T#U&}~'QP#`#a'T~'WP#g#h'Z~'^P#X#Y'a~'fOR~~'iP#i#j'l~'oP#`#a'r~'uP#`#a'x~'}OS~~(QP#f#g(T~(WP#i#j(Z~(^P#X#Y(a~(fOQ~~(kOW~~(pOV~",
+  tokenizers: [0],
+  topRules: {
+    "JsonText": [0, 1]
+  },
+  tokenPrec: 0
+});
+
+/**
+A language provider that provides JSON parsing.
+*/
+const jsonLanguage = /*@__PURE__*/LRLanguage.define({
+  parser: /*@__PURE__*/parser$1.configure({
+    props: [/*@__PURE__*/indentNodeProp.add({
+      Object: /*@__PURE__*/continuedIndent({
+        except: /^\s*\}/
+      }),
+      Array: /*@__PURE__*/continuedIndent({
+        except: /^\s*\]/
+      })
+    }), /*@__PURE__*/foldNodeProp.add({
+      "Object Array": foldInside
+    })]
+  }),
+  languageData: {
+    closeBrackets: {
+      brackets: ["[", "{", '"']
+    },
+    indentOnInput: /^\s*[\}\]]$/
+  }
+});
+/**
+JSON language support.
+*/
+function json() {
+  return new LanguageSupport(jsonLanguage);
+}
+
+class CompositeBlock {
+  constructor(type,
+  // Used for indentation in list items, markup character in lists
+  value, from, hash, end, children, positions) {
+    this.type = type;
+    this.value = value;
+    this.from = from;
+    this.hash = hash;
+    this.end = end;
+    this.children = children;
+    this.positions = positions;
+    this.hashProp = [[NodeProp.contextHash, hash]];
+  }
+  static create(type, value, from, parentHash, end) {
+    let hash = parentHash + (parentHash << 8) + type + (value << 4) | 0;
+    return new CompositeBlock(type, value, from, hash, end, [], []);
+  }
+  addChild(child, pos) {
+    if (child.prop(NodeProp.contextHash) != this.hash) child = new Tree(child.type, child.children, child.positions, child.length, this.hashProp);
+    this.children.push(child);
+    this.positions.push(pos);
+  }
+  toTree(nodeSet, end = this.end) {
+    let last = this.children.length - 1;
+    if (last >= 0) end = Math.max(end, this.positions[last] + this.children[last].length + this.from);
+    let tree = new Tree(nodeSet.types[this.type], this.children, this.positions, end - this.from).balance({
+      makeTree: (children, positions, length) => new Tree(NodeType.none, children, positions, length, this.hashProp)
+    });
+    return tree;
+  }
+}
+var Type;
+(function (Type) {
+  Type[Type["Document"] = 1] = "Document";
+  Type[Type["CodeBlock"] = 2] = "CodeBlock";
+  Type[Type["FencedCode"] = 3] = "FencedCode";
+  Type[Type["Blockquote"] = 4] = "Blockquote";
+  Type[Type["HorizontalRule"] = 5] = "HorizontalRule";
+  Type[Type["BulletList"] = 6] = "BulletList";
+  Type[Type["OrderedList"] = 7] = "OrderedList";
+  Type[Type["ListItem"] = 8] = "ListItem";
+  Type[Type["ATXHeading1"] = 9] = "ATXHeading1";
+  Type[Type["ATXHeading2"] = 10] = "ATXHeading2";
+  Type[Type["ATXHeading3"] = 11] = "ATXHeading3";
+  Type[Type["ATXHeading4"] = 12] = "ATXHeading4";
+  Type[Type["ATXHeading5"] = 13] = "ATXHeading5";
+  Type[Type["ATXHeading6"] = 14] = "ATXHeading6";
+  Type[Type["SetextHeading1"] = 15] = "SetextHeading1";
+  Type[Type["SetextHeading2"] = 16] = "SetextHeading2";
+  Type[Type["HTMLBlock"] = 17] = "HTMLBlock";
+  Type[Type["LinkReference"] = 18] = "LinkReference";
+  Type[Type["Paragraph"] = 19] = "Paragraph";
+  Type[Type["CommentBlock"] = 20] = "CommentBlock";
+  Type[Type["ProcessingInstructionBlock"] = 21] = "ProcessingInstructionBlock";
+  // Inline
+  Type[Type["Escape"] = 22] = "Escape";
+  Type[Type["Entity"] = 23] = "Entity";
+  Type[Type["HardBreak"] = 24] = "HardBreak";
+  Type[Type["Emphasis"] = 25] = "Emphasis";
+  Type[Type["StrongEmphasis"] = 26] = "StrongEmphasis";
+  Type[Type["Link"] = 27] = "Link";
+  Type[Type["Image"] = 28] = "Image";
+  Type[Type["InlineCode"] = 29] = "InlineCode";
+  Type[Type["HTMLTag"] = 30] = "HTMLTag";
+  Type[Type["Comment"] = 31] = "Comment";
+  Type[Type["ProcessingInstruction"] = 32] = "ProcessingInstruction";
+  Type[Type["URL"] = 33] = "URL";
+  // Smaller tokens
+  Type[Type["HeaderMark"] = 34] = "HeaderMark";
+  Type[Type["QuoteMark"] = 35] = "QuoteMark";
+  Type[Type["ListMark"] = 36] = "ListMark";
+  Type[Type["LinkMark"] = 37] = "LinkMark";
+  Type[Type["EmphasisMark"] = 38] = "EmphasisMark";
+  Type[Type["CodeMark"] = 39] = "CodeMark";
+  Type[Type["CodeText"] = 40] = "CodeText";
+  Type[Type["CodeInfo"] = 41] = "CodeInfo";
+  Type[Type["LinkTitle"] = 42] = "LinkTitle";
+  Type[Type["LinkLabel"] = 43] = "LinkLabel";
+})(Type || (Type = {}));
+/// Data structure used to accumulate a block's content during [leaf
+/// block parsing](#BlockParser.leaf).
+class LeafBlock {
+  /// @internal
+  constructor(
+  /// The start position of the block.
+  start,
+  /// The block's text content.
+  content) {
+    this.start = start;
+    this.content = content;
+    /// @internal
+    this.marks = [];
+    /// The block parsers active for this block.
+    this.parsers = [];
+  }
+}
+/// Data structure used during block-level per-line parsing.
+class Line {
+  constructor() {
+    /// The line's full text.
+    this.text = "";
+    /// The base indent provided by the composite contexts (that have
+    /// been handled so far).
+    this.baseIndent = 0;
+    /// The string position corresponding to the base indent.
+    this.basePos = 0;
+    /// The number of contexts handled @internal
+    this.depth = 0;
+    /// Any markers (i.e. block quote markers) parsed for the contexts. @internal
+    this.markers = [];
+    /// The position of the next non-whitespace character beyond any
+    /// list, blockquote, or other composite block markers.
+    this.pos = 0;
+    /// The column of the next non-whitespace character.
+    this.indent = 0;
+    /// The character code of the character after `pos`.
+    this.next = -1;
+  }
+  /// @internal
+  forward() {
+    if (this.basePos > this.pos) this.forwardInner();
+  }
+  /// @internal
+  forwardInner() {
+    let newPos = this.skipSpace(this.basePos);
+    this.indent = this.countIndent(newPos, this.pos, this.indent);
+    this.pos = newPos;
+    this.next = newPos == this.text.length ? -1 : this.text.charCodeAt(newPos);
+  }
+  /// Skip whitespace after the given position, return the position of
+  /// the next non-space character or the end of the line if there's
+  /// only space after `from`.
+  skipSpace(from) {
+    return skipSpace(this.text, from);
+  }
+  /// @internal
+  reset(text) {
+    this.text = text;
+    this.baseIndent = this.basePos = this.pos = this.indent = 0;
+    this.forwardInner();
+    this.depth = 1;
+    while (this.markers.length) this.markers.pop();
+  }
+  /// Move the line's base position forward to the given position.
+  /// This should only be called by composite [block
+  /// parsers](#BlockParser.parse) or [markup skipping
+  /// functions](#NodeSpec.composite).
+  moveBase(to) {
+    this.basePos = to;
+    this.baseIndent = this.countIndent(to, this.pos, this.indent);
+  }
+  /// Move the line's base position forward to the given _column_.
+  moveBaseColumn(indent) {
+    this.baseIndent = indent;
+    this.basePos = this.findColumn(indent);
+  }
+  /// Store a composite-block-level marker. Should be called from
+  /// [markup skipping functions](#NodeSpec.composite) when they
+  /// consume any non-whitespace characters.
+  addMarker(elt) {
+    this.markers.push(elt);
+  }
+  /// Find the column position at `to`, optionally starting at a given
+  /// position and column.
+  countIndent(to, from = 0, indent = 0) {
+    for (let i = from; i < to; i++) indent += this.text.charCodeAt(i) == 9 ? 4 - indent % 4 : 1;
+    return indent;
+  }
+  /// Find the position corresponding to the given column.
+  findColumn(goal) {
+    let i = 0;
+    for (let indent = 0; i < this.text.length && indent < goal; i++) indent += this.text.charCodeAt(i) == 9 ? 4 - indent % 4 : 1;
+    return i;
+  }
+  /// @internal
+  scrub() {
+    if (!this.baseIndent) return this.text;
+    let result = "";
+    for (let i = 0; i < this.basePos; i++) result += " ";
+    return result + this.text.slice(this.basePos);
+  }
+}
+function skipForList(bl, cx, line) {
+  if (line.pos == line.text.length || bl != cx.block && line.indent >= cx.stack[line.depth + 1].value + line.baseIndent) return true;
+  if (line.indent >= line.baseIndent + 4) return false;
+  let size = (bl.type == Type.OrderedList ? isOrderedList : isBulletList)(line, cx, false);
+  return size > 0 && (bl.type != Type.BulletList || isHorizontalRule(line, cx, false) < 0) && line.text.charCodeAt(line.pos + size - 1) == bl.value;
+}
+const DefaultSkipMarkup = {
+  [Type.Blockquote](bl, cx, line) {
+    if (line.next != 62 /* '>' */) return false;
+    line.markers.push(elt(Type.QuoteMark, cx.lineStart + line.pos, cx.lineStart + line.pos + 1));
+    line.moveBase(line.pos + (space(line.text.charCodeAt(line.pos + 1)) ? 2 : 1));
+    bl.end = cx.lineStart + line.text.length;
+    return true;
+  },
+  [Type.ListItem](bl, _cx, line) {
+    if (line.indent < line.baseIndent + bl.value && line.next > -1) return false;
+    line.moveBaseColumn(line.baseIndent + bl.value);
+    return true;
+  },
+  [Type.OrderedList]: skipForList,
+  [Type.BulletList]: skipForList,
+  [Type.Document]() {
+    return true;
+  }
+};
+function space(ch) {
+  return ch == 32 || ch == 9 || ch == 10 || ch == 13;
+}
+function skipSpace(line, i = 0) {
+  while (i < line.length && space(line.charCodeAt(i))) i++;
+  return i;
+}
+function skipSpaceBack(line, i, to) {
+  while (i > to && space(line.charCodeAt(i - 1))) i--;
+  return i;
+}
+function isFencedCode(line) {
+  if (line.next != 96 && line.next != 126 /* '`~' */) return -1;
+  let pos = line.pos + 1;
+  while (pos < line.text.length && line.text.charCodeAt(pos) == line.next) pos++;
+  if (pos < line.pos + 3) return -1;
+  if (line.next == 96) for (let i = pos; i < line.text.length; i++) if (line.text.charCodeAt(i) == 96) return -1;
+  return pos;
+}
+function isBlockquote(line) {
+  return line.next != 62 /* '>' */ ? -1 : line.text.charCodeAt(line.pos + 1) == 32 ? 2 : 1;
+}
+function isHorizontalRule(line, cx, breaking) {
+  if (line.next != 42 && line.next != 45 && line.next != 95 /* '_-*' */) return -1;
+  let count = 1;
+  for (let pos = line.pos + 1; pos < line.text.length; pos++) {
+    let ch = line.text.charCodeAt(pos);
+    if (ch == line.next) count++;else if (!space(ch)) return -1;
+  }
+  // Setext headers take precedence
+  if (breaking && line.next == 45 && isSetextUnderline(line) > -1 && line.depth == cx.stack.length) return -1;
+  return count < 3 ? -1 : 1;
+}
+function inList(cx, type) {
+  for (let i = cx.stack.length - 1; i >= 0; i--) if (cx.stack[i].type == type) return true;
+  return false;
+}
+function isBulletList(line, cx, breaking) {
+  return (line.next == 45 || line.next == 43 || line.next == 42 /* '-+*' */) && (line.pos == line.text.length - 1 || space(line.text.charCodeAt(line.pos + 1))) && (!breaking || inList(cx, Type.BulletList) || line.skipSpace(line.pos + 2) < line.text.length) ? 1 : -1;
+}
+function isOrderedList(line, cx, breaking) {
+  let pos = line.pos,
+    next = line.next;
+  for (;;) {
+    if (next >= 48 && next <= 57 /* '0-9' */) pos++;else break;
+    if (pos == line.text.length) return -1;
+    next = line.text.charCodeAt(pos);
+  }
+  if (pos == line.pos || pos > line.pos + 9 || next != 46 && next != 41 /* '.)' */ || pos < line.text.length - 1 && !space(line.text.charCodeAt(pos + 1)) || breaking && !inList(cx, Type.OrderedList) && (line.skipSpace(pos + 1) == line.text.length || pos > line.pos + 1 || line.next != 49 /* '1' */)) return -1;
+  return pos + 1 - line.pos;
+}
+function isAtxHeading(line) {
+  if (line.next != 35 /* '#' */) return -1;
+  let pos = line.pos + 1;
+  while (pos < line.text.length && line.text.charCodeAt(pos) == 35) pos++;
+  if (pos < line.text.length && line.text.charCodeAt(pos) != 32) return -1;
+  let size = pos - line.pos;
+  return size > 6 ? -1 : size;
+}
+function isSetextUnderline(line) {
+  if (line.next != 45 && line.next != 61 /* '-=' */ || line.indent >= line.baseIndent + 4) return -1;
+  let pos = line.pos + 1;
+  while (pos < line.text.length && line.text.charCodeAt(pos) == line.next) pos++;
+  let end = pos;
+  while (pos < line.text.length && space(line.text.charCodeAt(pos))) pos++;
+  return pos == line.text.length ? end : -1;
+}
+const EmptyLine = /^[ \t]*$/,
+  CommentEnd = /-->/,
+  ProcessingEnd = /\?>/;
+const HTMLBlockStyle = [[/^<(?:script|pre|style)(?:\s|>|$)/i, /<\/(?:script|pre|style)>/i], [/^\s*<!--/, CommentEnd], [/^\s*<\?/, ProcessingEnd], [/^\s*<![A-Z]/, />/], [/^\s*<!\[CDATA\[/, /\]\]>/], [/^\s*<\/?(?: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|h1|h2|h3|h4|h5|h6|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?:\s|\/?>|$)/i, EmptyLine], [/^\s*(?:<\/[a-z][\w-]*\s*>|<[a-z][\w-]*(\s+[a-z:_][\w-.]*(?:\s*=\s*(?:[^\s"'=<>`]+|'[^']*'|"[^"]*"))?)*\s*>)\s*$/i, EmptyLine]];
+function isHTMLBlock(line, _cx, breaking) {
+  if (line.next != 60 /* '<' */) return -1;
+  let rest = line.text.slice(line.pos);
+  for (let i = 0, e = HTMLBlockStyle.length - (breaking ? 1 : 0); i < e; i++) if (HTMLBlockStyle[i][0].test(rest)) return i;
+  return -1;
+}
+function getListIndent(line, pos) {
+  let indentAfter = line.countIndent(pos, line.pos, line.indent);
+  let indented = line.countIndent(line.skipSpace(pos), pos, indentAfter);
+  return indented >= indentAfter + 5 ? indentAfter + 1 : indented;
+}
+function addCodeText(marks, from, to) {
+  let last = marks.length - 1;
+  if (last >= 0 && marks[last].to == from && marks[last].type == Type.CodeText) marks[last].to = to;else marks.push(elt(Type.CodeText, from, to));
+}
+// Rules for parsing blocks. A return value of false means the rule
+// doesn't apply here, true means it does. When true is returned and
+// `p.line` has been updated, the rule is assumed to have consumed a
+// leaf block. Otherwise, it is assumed to have opened a context.
+const DefaultBlockParsers = {
+  LinkReference: undefined,
+  IndentedCode(cx, line) {
+    let base = line.baseIndent + 4;
+    if (line.indent < base) return false;
+    let start = line.findColumn(base);
+    let from = cx.lineStart + start,
+      to = cx.lineStart + line.text.length;
+    let marks = [],
+      pendingMarks = [];
+    addCodeText(marks, from, to);
+    while (cx.nextLine() && line.depth >= cx.stack.length) {
+      if (line.pos == line.text.length) {
+        // Empty
+        addCodeText(pendingMarks, cx.lineStart - 1, cx.lineStart);
+        for (let m of line.markers) pendingMarks.push(m);
+      } else if (line.indent < base) {
+        break;
+      } else {
+        if (pendingMarks.length) {
+          for (let m of pendingMarks) {
+            if (m.type == Type.CodeText) addCodeText(marks, m.from, m.to);else marks.push(m);
+          }
+          pendingMarks = [];
+        }
+        addCodeText(marks, cx.lineStart - 1, cx.lineStart);
+        for (let m of line.markers) marks.push(m);
+        to = cx.lineStart + line.text.length;
+        let codeStart = cx.lineStart + line.findColumn(line.baseIndent + 4);
+        if (codeStart < to) addCodeText(marks, codeStart, to);
+      }
+    }
+    if (pendingMarks.length) {
+      pendingMarks = pendingMarks.filter(m => m.type != Type.CodeText);
+      if (pendingMarks.length) line.markers = pendingMarks.concat(line.markers);
+    }
+    cx.addNode(cx.buffer.writeElements(marks, -from).finish(Type.CodeBlock, to - from), from);
+    return true;
+  },
+  FencedCode(cx, line) {
+    let fenceEnd = isFencedCode(line);
+    if (fenceEnd < 0) return false;
+    let from = cx.lineStart + line.pos,
+      ch = line.next,
+      len = fenceEnd - line.pos;
+    let infoFrom = line.skipSpace(fenceEnd),
+      infoTo = skipSpaceBack(line.text, line.text.length, infoFrom);
+    let marks = [elt(Type.CodeMark, from, from + len)];
+    if (infoFrom < infoTo) marks.push(elt(Type.CodeInfo, cx.lineStart + infoFrom, cx.lineStart + infoTo));
+    for (let first = true; cx.nextLine() && line.depth >= cx.stack.length; first = false) {
+      let i = line.pos;
+      if (line.indent - line.baseIndent < 4) while (i < line.text.length && line.text.charCodeAt(i) == ch) i++;
+      if (i - line.pos >= len && line.skipSpace(i) == line.text.length) {
+        for (let m of line.markers) marks.push(m);
+        marks.push(elt(Type.CodeMark, cx.lineStart + line.pos, cx.lineStart + i));
+        cx.nextLine();
+        break;
+      } else {
+        if (!first) addCodeText(marks, cx.lineStart - 1, cx.lineStart);
+        for (let m of line.markers) marks.push(m);
+        let textStart = cx.lineStart + line.basePos,
+          textEnd = cx.lineStart + line.text.length;
+        if (textStart < textEnd) addCodeText(marks, textStart, textEnd);
+      }
+    }
+    cx.addNode(cx.buffer.writeElements(marks, -from).finish(Type.FencedCode, cx.prevLineEnd() - from), from);
+    return true;
+  },
+  Blockquote(cx, line) {
+    let size = isBlockquote(line);
+    if (size < 0) return false;
+    cx.startContext(Type.Blockquote, line.pos);
+    cx.addNode(Type.QuoteMark, cx.lineStart + line.pos, cx.lineStart + line.pos + 1);
+    line.moveBase(line.pos + size);
+    return null;
+  },
+  HorizontalRule(cx, line) {
+    if (isHorizontalRule(line, cx, false) < 0) return false;
+    let from = cx.lineStart + line.pos;
+    cx.nextLine();
+    cx.addNode(Type.HorizontalRule, from);
+    return true;
+  },
+  BulletList(cx, line) {
+    let size = isBulletList(line, cx, false);
+    if (size < 0) return false;
+    if (cx.block.type != Type.BulletList) cx.startContext(Type.BulletList, line.basePos, line.next);
+    let newBase = getListIndent(line, line.pos + 1);
+    cx.startContext(Type.ListItem, line.basePos, newBase - line.baseIndent);
+    cx.addNode(Type.ListMark, cx.lineStart + line.pos, cx.lineStart + line.pos + size);
+    line.moveBaseColumn(newBase);
+    return null;
+  },
+  OrderedList(cx, line) {
+    let size = isOrderedList(line, cx, false);
+    if (size < 0) return false;
+    if (cx.block.type != Type.OrderedList) cx.startContext(Type.OrderedList, line.basePos, line.text.charCodeAt(line.pos + size - 1));
+    let newBase = getListIndent(line, line.pos + size);
+    cx.startContext(Type.ListItem, line.basePos, newBase - line.baseIndent);
+    cx.addNode(Type.ListMark, cx.lineStart + line.pos, cx.lineStart + line.pos + size);
+    line.moveBaseColumn(newBase);
+    return null;
+  },
+  ATXHeading(cx, line) {
+    let size = isAtxHeading(line);
+    if (size < 0) return false;
+    let off = line.pos,
+      from = cx.lineStart + off;
+    let endOfSpace = skipSpaceBack(line.text, line.text.length, off),
+      after = endOfSpace;
+    while (after > off && line.text.charCodeAt(after - 1) == line.next) after--;
+    if (after == endOfSpace || after == off || !space(line.text.charCodeAt(after - 1))) after = line.text.length;
+    let buf = cx.buffer.write(Type.HeaderMark, 0, size).writeElements(cx.parser.parseInline(line.text.slice(off + size + 1, after), from + size + 1), -from);
+    if (after < line.text.length) buf.write(Type.HeaderMark, after - off, endOfSpace - off);
+    let node = buf.finish(Type.ATXHeading1 - 1 + size, line.text.length - off);
+    cx.nextLine();
+    cx.addNode(node, from);
+    return true;
+  },
+  HTMLBlock(cx, line) {
+    let type = isHTMLBlock(line, cx, false);
+    if (type < 0) return false;
+    let from = cx.lineStart + line.pos,
+      end = HTMLBlockStyle[type][1];
+    let marks = [],
+      trailing = end != EmptyLine;
+    while (!end.test(line.text) && cx.nextLine()) {
+      if (line.depth < cx.stack.length) {
+        trailing = false;
+        break;
+      }
+      for (let m of line.markers) marks.push(m);
+    }
+    if (trailing) cx.nextLine();
+    let nodeType = end == CommentEnd ? Type.CommentBlock : end == ProcessingEnd ? Type.ProcessingInstructionBlock : Type.HTMLBlock;
+    let to = cx.prevLineEnd();
+    cx.addNode(cx.buffer.writeElements(marks, -from).finish(nodeType, to - from), from);
+    return true;
+  },
+  SetextHeading: undefined // Specifies relative precedence for block-continue function
+};
+// This implements a state machine that incrementally parses link references. At each
+// next line, it looks ahead to see if the line continues the reference or not. If it
+// doesn't and a valid link is available ending before that line, it finishes that.
+// Similarly, on `finish` (when the leaf is terminated by external circumstances), it
+// creates a link reference if there's a valid reference up to the current point.
+class LinkReferenceParser {
+  constructor(leaf) {
+    this.stage = 0 /* Start */;
+    this.elts = [];
+    this.pos = 0;
+    this.start = leaf.start;
+    this.advance(leaf.content);
+  }
+  nextLine(cx, line, leaf) {
+    if (this.stage == -1 /* Failed */) return false;
+    let content = leaf.content + "\n" + line.scrub();
+    let finish = this.advance(content);
+    if (finish > -1 && finish < content.length) return this.complete(cx, leaf, finish);
+    return false;
+  }
+  finish(cx, leaf) {
+    if ((this.stage == 2 /* Link */ || this.stage == 3 /* Title */) && skipSpace(leaf.content, this.pos) == leaf.content.length) return this.complete(cx, leaf, leaf.content.length);
+    return false;
+  }
+  complete(cx, leaf, len) {
+    cx.addLeafElement(leaf, elt(Type.LinkReference, this.start, this.start + len, this.elts));
+    return true;
+  }
+  nextStage(elt) {
+    if (elt) {
+      this.pos = elt.to - this.start;
+      this.elts.push(elt);
+      this.stage++;
+      return true;
+    }
+    if (elt === false) this.stage = -1 /* Failed */;
+    return false;
+  }
+  advance(content) {
+    for (;;) {
+      if (this.stage == -1 /* Failed */) {
+        return -1;
+      } else if (this.stage == 0 /* Start */) {
+        if (!this.nextStage(parseLinkLabel(content, this.pos, this.start, true))) return -1;
+        if (content.charCodeAt(this.pos) != 58 /* ':' */) return this.stage = -1 /* Failed */;
+        this.elts.push(elt(Type.LinkMark, this.pos + this.start, this.pos + this.start + 1));
+        this.pos++;
+      } else if (this.stage == 1 /* Label */) {
+        if (!this.nextStage(parseURL(content, skipSpace(content, this.pos), this.start))) return -1;
+      } else if (this.stage == 2 /* Link */) {
+        let skip = skipSpace(content, this.pos),
+          end = 0;
+        if (skip > this.pos) {
+          let title = parseLinkTitle(content, skip, this.start);
+          if (title) {
+            let titleEnd = lineEnd(content, title.to - this.start);
+            if (titleEnd > 0) {
+              this.nextStage(title);
+              end = titleEnd;
+            }
+          }
+        }
+        if (!end) end = lineEnd(content, this.pos);
+        return end > 0 && end < content.length ? end : -1;
+      } else {
+        // RefStage.Title
+        return lineEnd(content, this.pos);
+      }
+    }
+  }
+}
+function lineEnd(text, pos) {
+  for (; pos < text.length; pos++) {
+    let next = text.charCodeAt(pos);
+    if (next == 10) break;
+    if (!space(next)) return -1;
+  }
+  return pos;
+}
+class SetextHeadingParser {
+  nextLine(cx, line, leaf) {
+    let underline = line.depth < cx.stack.length ? -1 : isSetextUnderline(line);
+    let next = line.next;
+    if (underline < 0) return false;
+    let underlineMark = elt(Type.HeaderMark, cx.lineStart + line.pos, cx.lineStart + underline);
+    cx.nextLine();
+    cx.addLeafElement(leaf, elt(next == 61 ? Type.SetextHeading1 : Type.SetextHeading2, leaf.start, cx.prevLineEnd(), [...cx.parser.parseInline(leaf.content, leaf.start), underlineMark]));
+    return true;
+  }
+  finish() {
+    return false;
+  }
+}
+const DefaultLeafBlocks = {
+  LinkReference(_, leaf) {
+    return leaf.content.charCodeAt(0) == 91 /* '[' */ ? new LinkReferenceParser(leaf) : null;
+  },
+  SetextHeading() {
+    return new SetextHeadingParser();
+  }
+};
+const DefaultEndLeaf = [(_, line) => isAtxHeading(line) >= 0, (_, line) => isFencedCode(line) >= 0, (_, line) => isBlockquote(line) >= 0, (p, line) => isBulletList(line, p, true) >= 0, (p, line) => isOrderedList(line, p, true) >= 0, (p, line) => isHorizontalRule(line, p, true) >= 0, (p, line) => isHTMLBlock(line, p, true) >= 0];
+const scanLineResult = {
+  text: "",
+  end: 0
+};
+/// Block-level parsing functions get access to this context object.
+class BlockContext {
+  /// @internal
+  constructor(
+  /// The parser configuration used.
+  parser,
+  /// @internal
+  input, fragments,
+  /// @internal
+  ranges) {
+    this.parser = parser;
+    this.input = input;
+    this.ranges = ranges;
+    this.line = new Line();
+    this.atEnd = false;
+    /// @internal
+    this.dontInject = new Set();
+    this.stoppedAt = null;
+    /// The range index that absoluteLineStart points into @internal
+    this.rangeI = 0;
+    this.to = ranges[ranges.length - 1].to;
+    this.lineStart = this.absoluteLineStart = this.absoluteLineEnd = ranges[0].from;
+    this.block = CompositeBlock.create(Type.Document, 0, this.lineStart, 0, 0);
+    this.stack = [this.block];
+    this.fragments = fragments.length ? new FragmentCursor(fragments, input) : null;
+    this.readLine();
+  }
+  get parsedPos() {
+    return this.absoluteLineStart;
+  }
+  advance() {
+    if (this.stoppedAt != null && this.absoluteLineStart > this.stoppedAt) return this.finish();
+    let {
+      line
+    } = this;
+    for (;;) {
+      while (line.depth < this.stack.length) this.finishContext();
+      for (let mark of line.markers) this.addNode(mark.type, mark.from, mark.to);
+      if (line.pos < line.text.length) break;
+      // Empty line
+      if (!this.nextLine()) return this.finish();
+    }
+    if (this.fragments && this.reuseFragment(line.basePos)) return null;
+    start: for (;;) {
+      for (let type of this.parser.blockParsers) if (type) {
+        let result = type(this, line);
+        if (result != false) {
+          if (result == true) return null;
+          line.forward();
+          continue start;
+        }
+      }
+      break;
+    }
+    let leaf = new LeafBlock(this.lineStart + line.pos, line.text.slice(line.pos));
+    for (let parse of this.parser.leafBlockParsers) if (parse) {
+      let parser = parse(this, leaf);
+      if (parser) leaf.parsers.push(parser);
+    }
+    lines: while (this.nextLine()) {
+      if (line.pos == line.text.length) break;
+      if (line.indent < line.baseIndent + 4) {
+        for (let stop of this.parser.endLeafBlock) if (stop(this, line, leaf)) break lines;
+      }
+      for (let parser of leaf.parsers) if (parser.nextLine(this, line, leaf)) return null;
+      leaf.content += "\n" + line.scrub();
+      for (let m of line.markers) leaf.marks.push(m);
+    }
+    this.finishLeaf(leaf);
+    return null;
+  }
+  stopAt(pos) {
+    if (this.stoppedAt != null && this.stoppedAt < pos) throw new RangeError("Can't move stoppedAt forward");
+    this.stoppedAt = pos;
+  }
+  reuseFragment(start) {
+    if (!this.fragments.moveTo(this.absoluteLineStart + start, this.absoluteLineStart) || !this.fragments.matches(this.block.hash)) return false;
+    let taken = this.fragments.takeNodes(this);
+    if (!taken) return false;
+    let withoutGaps = taken,
+      end = this.absoluteLineStart + taken;
+    for (let i = 1; i < this.ranges.length; i++) {
+      let gapFrom = this.ranges[i - 1].to,
+        gapTo = this.ranges[i].from;
+      if (gapFrom >= this.lineStart && gapTo < end) withoutGaps -= gapTo - gapFrom;
+    }
+    this.lineStart += withoutGaps;
+    this.absoluteLineStart += taken;
+    this.moveRangeI();
+    if (this.absoluteLineStart < this.to) {
+      this.lineStart++;
+      this.absoluteLineStart++;
+      this.readLine();
+    } else {
+      this.atEnd = true;
+      this.readLine();
+    }
+    return true;
+  }
+  /// The number of parent blocks surrounding the current block.
+  get depth() {
+    return this.stack.length;
+  }
+  /// Get the type of the parent block at the given depth. When no
+  /// depth is passed, return the type of the innermost parent.
+  parentType(depth = this.depth - 1) {
+    return this.parser.nodeSet.types[this.stack[depth].type];
+  }
+  /// Move to the next input line. This should only be called by
+  /// (non-composite) [block parsers](#BlockParser.parse) that consume
+  /// the line directly, or leaf block parser
+  /// [`nextLine`](#LeafBlockParser.nextLine) methods when they
+  /// consume the current line (and return true).
+  nextLine() {
+    this.lineStart += this.line.text.length;
+    if (this.absoluteLineEnd >= this.to) {
+      this.absoluteLineStart = this.absoluteLineEnd;
+      this.atEnd = true;
+      this.readLine();
+      return false;
+    } else {
+      this.lineStart++;
+      this.absoluteLineStart = this.absoluteLineEnd + 1;
+      this.moveRangeI();
+      this.readLine();
+      return true;
+    }
+  }
+  moveRangeI() {
+    while (this.rangeI < this.ranges.length - 1 && this.absoluteLineStart >= this.ranges[this.rangeI].to) {
+      this.rangeI++;
+      this.absoluteLineStart = Math.max(this.absoluteLineStart, this.ranges[this.rangeI].from);
+    }
+  }
+  /// @internal
+  scanLine(start) {
+    let r = scanLineResult;
+    r.end = start;
+    if (start >= this.to) {
+      r.text = "";
+    } else {
+      r.text = this.lineChunkAt(start);
+      r.end += r.text.length;
+      if (this.ranges.length > 1) {
+        let textOffset = this.absoluteLineStart,
+          rangeI = this.rangeI;
+        while (this.ranges[rangeI].to < r.end) {
+          rangeI++;
+          let nextFrom = this.ranges[rangeI].from;
+          let after = this.lineChunkAt(nextFrom);
+          r.end = nextFrom + after.length;
+          r.text = r.text.slice(0, this.ranges[rangeI - 1].to - textOffset) + after;
+          textOffset = r.end - r.text.length;
+        }
+      }
+    }
+    return r;
+  }
+  /// @internal
+  readLine() {
+    let {
+        line
+      } = this,
+      {
+        text,
+        end
+      } = this.scanLine(this.absoluteLineStart);
+    this.absoluteLineEnd = end;
+    line.reset(text);
+    for (; line.depth < this.stack.length; line.depth++) {
+      let cx = this.stack[line.depth],
+        handler = this.parser.skipContextMarkup[cx.type];
+      if (!handler) throw new Error("Unhandled block context " + Type[cx.type]);
+      if (!handler(cx, this, line)) break;
+      line.forward();
+    }
+  }
+  lineChunkAt(pos) {
+    let next = this.input.chunk(pos),
+      text;
+    if (!this.input.lineChunks) {
+      let eol = next.indexOf("\n");
+      text = eol < 0 ? next : next.slice(0, eol);
+    } else {
+      text = next == "\n" ? "" : next;
+    }
+    return pos + text.length > this.to ? text.slice(0, this.to - pos) : text;
+  }
+  /// The end position of the previous line.
+  prevLineEnd() {
+    return this.atEnd ? this.lineStart : this.lineStart - 1;
+  }
+  /// @internal
+  startContext(type, start, value = 0) {
+    this.block = CompositeBlock.create(type, value, this.lineStart + start, this.block.hash, this.lineStart + this.line.text.length);
+    this.stack.push(this.block);
+  }
+  /// Start a composite block. Should only be called from [block
+  /// parser functions](#BlockParser.parse) that return null.
+  startComposite(type, start, value = 0) {
+    this.startContext(this.parser.getNodeType(type), start, value);
+  }
+  /// @internal
+  addNode(block, from, to) {
+    if (typeof block == "number") block = new Tree(this.parser.nodeSet.types[block], none, none, (to !== null && to !== void 0 ? to : this.prevLineEnd()) - from);
+    this.block.addChild(block, from - this.block.from);
+  }
+  /// Add a block element. Can be called by [block
+  /// parsers](#BlockParser.parse).
+  addElement(elt) {
+    this.block.addChild(elt.toTree(this.parser.nodeSet), elt.from - this.block.from);
+  }
+  /// Add a block element from a [leaf parser](#LeafBlockParser). This
+  /// makes sure any extra composite block markup (such as blockquote
+  /// markers) inside the block are also added to the syntax tree.
+  addLeafElement(leaf, elt) {
+    this.addNode(this.buffer.writeElements(injectMarks(elt.children, leaf.marks), -elt.from).finish(elt.type, elt.to - elt.from), elt.from);
+  }
+  /// @internal
+  finishContext() {
+    let cx = this.stack.pop();
+    let top = this.stack[this.stack.length - 1];
+    top.addChild(cx.toTree(this.parser.nodeSet), cx.from - top.from);
+    this.block = top;
+  }
+  finish() {
+    while (this.stack.length > 1) this.finishContext();
+    return this.addGaps(this.block.toTree(this.parser.nodeSet, this.lineStart));
+  }
+  addGaps(tree) {
+    return this.ranges.length > 1 ? injectGaps(this.ranges, 0, tree.topNode, this.ranges[0].from, this.dontInject) : tree;
+  }
+  /// @internal
+  finishLeaf(leaf) {
+    for (let parser of leaf.parsers) if (parser.finish(this, leaf)) return;
+    let inline = injectMarks(this.parser.parseInline(leaf.content, leaf.start), leaf.marks);
+    this.addNode(this.buffer.writeElements(inline, -leaf.start).finish(Type.Paragraph, leaf.content.length), leaf.start);
+  }
+  elt(type, from, to, children) {
+    if (typeof type == "string") return elt(this.parser.getNodeType(type), from, to, children);
+    return new TreeElement(type, from);
+  }
+  /// @internal
+  get buffer() {
+    return new Buffer(this.parser.nodeSet);
+  }
+}
+function injectGaps(ranges, rangeI, tree, offset, dont) {
+  if (dont.has(tree.tree)) return tree.tree;
+  let rangeEnd = ranges[rangeI].to;
+  let children = [],
+    positions = [],
+    start = tree.from + offset;
+  function movePastNext(upto, inclusive) {
+    while (inclusive ? upto >= rangeEnd : upto > rangeEnd) {
+      let size = ranges[rangeI + 1].from - rangeEnd;
+      offset += size;
+      upto += size;
+      rangeI++;
+      rangeEnd = ranges[rangeI].to;
+    }
+  }
+  for (let ch = tree.firstChild; ch; ch = ch.nextSibling) {
+    movePastNext(ch.from + offset, true);
+    let from = ch.from + offset,
+      node;
+    if (ch.to + offset > rangeEnd) {
+      node = injectGaps(ranges, rangeI, ch, offset, dont);
+      movePastNext(ch.to + offset, false);
+    } else {
+      node = ch.toTree();
+    }
+    children.push(node);
+    positions.push(from - start);
+  }
+  movePastNext(tree.to + offset, false);
+  return new Tree(tree.type, children, positions, tree.to + offset - start, tree.tree ? tree.tree.propValues : undefined);
+}
+/// A Markdown parser configuration.
+class MarkdownParser extends Parser {
+  /// @internal
+  constructor(
+  /// The parser's syntax [node
+  /// types](https://lezer.codemirror.net/docs/ref/#common.NodeSet).
+  nodeSet,
+  /// @internal
+  blockParsers,
+  /// @internal
+  leafBlockParsers,
+  /// @internal
+  blockNames,
+  /// @internal
+  endLeafBlock,
+  /// @internal
+  skipContextMarkup,
+  /// @internal
+  inlineParsers,
+  /// @internal
+  inlineNames,
+  /// @internal
+  wrappers) {
+    super();
+    this.nodeSet = nodeSet;
+    this.blockParsers = blockParsers;
+    this.leafBlockParsers = leafBlockParsers;
+    this.blockNames = blockNames;
+    this.endLeafBlock = endLeafBlock;
+    this.skipContextMarkup = skipContextMarkup;
+    this.inlineParsers = inlineParsers;
+    this.inlineNames = inlineNames;
+    this.wrappers = wrappers;
+    /// @internal
+    this.nodeTypes = Object.create(null);
+    for (let t of nodeSet.types) this.nodeTypes[t.name] = t.id;
+  }
+  createParse(input, fragments, ranges) {
+    let parse = new BlockContext(this, input, fragments, ranges);
+    for (let w of this.wrappers) parse = w(parse, input, fragments, ranges);
+    return parse;
+  }
+  /// Reconfigure the parser.
+  configure(spec) {
+    let config = resolveConfig(spec);
+    if (!config) return this;
+    let {
+      nodeSet,
+      skipContextMarkup
+    } = this;
+    let blockParsers = this.blockParsers.slice(),
+      leafBlockParsers = this.leafBlockParsers.slice(),
+      blockNames = this.blockNames.slice(),
+      inlineParsers = this.inlineParsers.slice(),
+      inlineNames = this.inlineNames.slice(),
+      endLeafBlock = this.endLeafBlock.slice(),
+      wrappers = this.wrappers;
+    if (nonEmpty(config.defineNodes)) {
+      skipContextMarkup = Object.assign({}, skipContextMarkup);
+      let nodeTypes = nodeSet.types.slice(),
+        styles;
+      for (let s of config.defineNodes) {
+        let {
+          name,
+          block,
+          composite,
+          style
+        } = typeof s == "string" ? {
+          name: s
+        } : s;
+        if (nodeTypes.some(t => t.name == name)) continue;
+        if (composite) skipContextMarkup[nodeTypes.length] = (bl, cx, line) => composite(cx, line, bl.value);
+        let id = nodeTypes.length;
+        let group = composite ? ["Block", "BlockContext"] : !block ? undefined : id >= Type.ATXHeading1 && id <= Type.SetextHeading2 ? ["Block", "LeafBlock", "Heading"] : ["Block", "LeafBlock"];
+        nodeTypes.push(NodeType.define({
+          id,
+          name,
+          props: group && [[NodeProp.group, group]]
+        }));
+        if (style) {
+          if (!styles) styles = {};
+          if (Array.isArray(style) || style instanceof Tag) styles[name] = style;else Object.assign(styles, style);
+        }
+      }
+      nodeSet = new NodeSet(nodeTypes);
+      if (styles) nodeSet = nodeSet.extend(styleTags(styles));
+    }
+    if (nonEmpty(config.props)) nodeSet = nodeSet.extend(...config.props);
+    if (nonEmpty(config.remove)) {
+      for (let rm of config.remove) {
+        let block = this.blockNames.indexOf(rm),
+          inline = this.inlineNames.indexOf(rm);
+        if (block > -1) blockParsers[block] = leafBlockParsers[block] = undefined;
+        if (inline > -1) inlineParsers[inline] = undefined;
+      }
+    }
+    if (nonEmpty(config.parseBlock)) {
+      for (let spec of config.parseBlock) {
+        let found = blockNames.indexOf(spec.name);
+        if (found > -1) {
+          blockParsers[found] = spec.parse;
+          leafBlockParsers[found] = spec.leaf;
+        } else {
+          let pos = spec.before ? findName(blockNames, spec.before) : spec.after ? findName(blockNames, spec.after) + 1 : blockNames.length - 1;
+          blockParsers.splice(pos, 0, spec.parse);
+          leafBlockParsers.splice(pos, 0, spec.leaf);
+          blockNames.splice(pos, 0, spec.name);
+        }
+        if (spec.endLeaf) endLeafBlock.push(spec.endLeaf);
+      }
+    }
+    if (nonEmpty(config.parseInline)) {
+      for (let spec of config.parseInline) {
+        let found = inlineNames.indexOf(spec.name);
+        if (found > -1) {
+          inlineParsers[found] = spec.parse;
+        } else {
+          let pos = spec.before ? findName(inlineNames, spec.before) : spec.after ? findName(inlineNames, spec.after) + 1 : inlineNames.length - 1;
+          inlineParsers.splice(pos, 0, spec.parse);
+          inlineNames.splice(pos, 0, spec.name);
+        }
+      }
+    }
+    if (config.wrap) wrappers = wrappers.concat(config.wrap);
+    return new MarkdownParser(nodeSet, blockParsers, leafBlockParsers, blockNames, endLeafBlock, skipContextMarkup, inlineParsers, inlineNames, wrappers);
+  }
+  /// @internal
+  getNodeType(name) {
+    let found = this.nodeTypes[name];
+    if (found == null) throw new RangeError(`Unknown node type '${name}'`);
+    return found;
+  }
+  /// Parse the given piece of inline text at the given offset,
+  /// returning an array of [`Element`](#Element) objects representing
+  /// the inline content.
+  parseInline(text, offset) {
+    let cx = new InlineContext(this, text, offset);
+    outer: for (let pos = offset; pos < cx.end;) {
+      let next = cx.char(pos);
+      for (let token of this.inlineParsers) if (token) {
+        let result = token(cx, next, pos);
+        if (result >= 0) {
+          pos = result;
+          continue outer;
+        }
+      }
+      pos++;
+    }
+    return cx.resolveMarkers(0);
+  }
+}
+function nonEmpty(a) {
+  return a != null && a.length > 0;
+}
+function resolveConfig(spec) {
+  if (!Array.isArray(spec)) return spec;
+  if (spec.length == 0) return null;
+  let conf = resolveConfig(spec[0]);
+  if (spec.length == 1) return conf;
+  let rest = resolveConfig(spec.slice(1));
+  if (!rest || !conf) return conf || rest;
+  let conc = (a, b) => (a || none).concat(b || none);
+  let wrapA = conf.wrap,
+    wrapB = rest.wrap;
+  return {
+    props: conc(conf.props, rest.props),
+    defineNodes: conc(conf.defineNodes, rest.defineNodes),
+    parseBlock: conc(conf.parseBlock, rest.parseBlock),
+    parseInline: conc(conf.parseInline, rest.parseInline),
+    remove: conc(conf.remove, rest.remove),
+    wrap: !wrapA ? wrapB : !wrapB ? wrapA : (inner, input, fragments, ranges) => wrapA(wrapB(inner, input, fragments, ranges), input, fragments, ranges)
+  };
+}
+function findName(names, name) {
+  let found = names.indexOf(name);
+  if (found < 0) throw new RangeError(`Position specified relative to unknown parser ${name}`);
+  return found;
+}
+let nodeTypes = [NodeType.none];
+for (let i = 1, name; name = Type[i]; i++) {
+  nodeTypes[i] = NodeType.define({
+    id: i,
+    name,
+    props: i >= Type.Escape ? [] : [[NodeProp.group, i in DefaultSkipMarkup ? ["Block", "BlockContext"] : ["Block", "LeafBlock"]]]
+  });
+}
+const none = [];
+class Buffer {
+  constructor(nodeSet) {
+    this.nodeSet = nodeSet;
+    this.content = [];
+    this.nodes = [];
+  }
+  write(type, from, to, children = 0) {
+    this.content.push(type, from, to, 4 + children * 4);
+    return this;
+  }
+  writeElements(elts, offset = 0) {
+    for (let e of elts) e.writeTo(this, offset);
+    return this;
+  }
+  finish(type, length) {
+    return Tree.build({
+      buffer: this.content,
+      nodeSet: this.nodeSet,
+      reused: this.nodes,
+      topID: type,
+      length
+    });
+  }
+}
+/// Elements are used to compose syntax nodes during parsing.
+class Element {
+  /// @internal
+  constructor(
+  /// The node's
+  /// [id](https://lezer.codemirror.net/docs/ref/#common.NodeType.id).
+  type,
+  /// The start of the node, as an offset from the start of the document.
+  from,
+  /// The end of the node.
+  to,
+  /// The node's child nodes @internal
+  children = none) {
+    this.type = type;
+    this.from = from;
+    this.to = to;
+    this.children = children;
+  }
+  /// @internal
+  writeTo(buf, offset) {
+    let startOff = buf.content.length;
+    buf.writeElements(this.children, offset);
+    buf.content.push(this.type, this.from + offset, this.to + offset, buf.content.length + 4 - startOff);
+  }
+  /// @internal
+  toTree(nodeSet) {
+    return new Buffer(nodeSet).writeElements(this.children, -this.from).finish(this.type, this.to - this.from);
+  }
+}
+class TreeElement {
+  constructor(tree, from) {
+    this.tree = tree;
+    this.from = from;
+  }
+  get to() {
+    return this.from + this.tree.length;
+  }
+  get type() {
+    return this.tree.type.id;
+  }
+  get children() {
+    return none;
+  }
+  writeTo(buf, offset) {
+    buf.nodes.push(this.tree);
+    buf.content.push(buf.nodes.length - 1, this.from + offset, this.to + offset, -1);
+  }
+  toTree() {
+    return this.tree;
+  }
+}
+function elt(type, from, to, children) {
+  return new Element(type, from, to, children);
+}
+const EmphasisUnderscore = {
+  resolve: "Emphasis",
+  mark: "EmphasisMark"
+};
+const EmphasisAsterisk = {
+  resolve: "Emphasis",
+  mark: "EmphasisMark"
+};
+const LinkStart = {},
+  ImageStart = {};
+class InlineDelimiter {
+  constructor(type, from, to, side) {
+    this.type = type;
+    this.from = from;
+    this.to = to;
+    this.side = side;
+  }
+}
+const Escapable = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
+let Punctuation = /[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~\xA1\u2010-\u2027]/;
+try {
+  Punctuation = new RegExp("[\\p{Pc}|\\p{Pd}|\\p{Pe}|\\p{Pf}|\\p{Pi}|\\p{Po}|\\p{Ps}]", "u");
+} catch (_) {}
+const DefaultInline = {
+  Escape(cx, next, start) {
+    if (next != 92 /* '\\' */ || start == cx.end - 1) return -1;
+    let escaped = cx.char(start + 1);
+    for (let i = 0; i < Escapable.length; i++) if (Escapable.charCodeAt(i) == escaped) return cx.append(elt(Type.Escape, start, start + 2));
+    return -1;
+  },
+  Entity(cx, next, start) {
+    if (next != 38 /* '&' */) return -1;
+    let m = /^(?:#\d+|#x[a-f\d]+|\w+);/i.exec(cx.slice(start + 1, start + 31));
+    return m ? cx.append(elt(Type.Entity, start, start + 1 + m[0].length)) : -1;
+  },
+  InlineCode(cx, next, start) {
+    if (next != 96 /* '`' */ || start && cx.char(start - 1) == 96) return -1;
+    let pos = start + 1;
+    while (pos < cx.end && cx.char(pos) == 96) pos++;
+    let size = pos - start,
+      curSize = 0;
+    for (; pos < cx.end; pos++) {
+      if (cx.char(pos) == 96) {
+        curSize++;
+        if (curSize == size && cx.char(pos + 1) != 96) return cx.append(elt(Type.InlineCode, start, pos + 1, [elt(Type.CodeMark, start, start + size), elt(Type.CodeMark, pos + 1 - size, pos + 1)]));
+      } else {
+        curSize = 0;
+      }
+    }
+    return -1;
+  },
+  HTMLTag(cx, next, start) {
+    if (next != 60 /* '<' */ || start == cx.end - 1) return -1;
+    let after = cx.slice(start + 1, cx.end);
+    let url = /^(?:[a-z][-\w+.]+:[^\s>]+|[a-z\d.!#$%&'*+/=?^_`{|}~-]+@[a-z\d](?:[a-z\d-]{0,61}[a-z\d])?(?:\.[a-z\d](?:[a-z\d-]{0,61}[a-z\d])?)*)>/i.exec(after);
+    if (url) return cx.append(elt(Type.URL, start, start + 1 + url[0].length));
+    let comment = /^!--[^>](?:-[^-]|[^-])*?-->/i.exec(after);
+    if (comment) return cx.append(elt(Type.Comment, start, start + 1 + comment[0].length));
+    let procInst = /^\?[^]*?\?>/.exec(after);
+    if (procInst) return cx.append(elt(Type.ProcessingInstruction, start, start + 1 + procInst[0].length));
+    let m = /^(?:![A-Z][^]*?>|!\[CDATA\[[^]*?\]\]>|\/\s*[a-zA-Z][\w-]*\s*>|\s*[a-zA-Z][\w-]*(\s+[a-zA-Z:_][\w-.:]*(?:\s*=\s*(?:[^\s"'=<>`]+|'[^']*'|"[^"]*"))?)*\s*(\/\s*)?>)/.exec(after);
+    if (!m) return -1;
+    return cx.append(elt(Type.HTMLTag, start, start + 1 + m[0].length));
+  },
+  Emphasis(cx, next, start) {
+    if (next != 95 && next != 42) return -1;
+    let pos = start + 1;
+    while (cx.char(pos) == next) pos++;
+    let before = cx.slice(start - 1, start),
+      after = cx.slice(pos, pos + 1);
+    let pBefore = Punctuation.test(before),
+      pAfter = Punctuation.test(after);
+    let sBefore = /\s|^$/.test(before),
+      sAfter = /\s|^$/.test(after);
+    let leftFlanking = !sAfter && (!pAfter || sBefore || pBefore);
+    let rightFlanking = !sBefore && (!pBefore || sAfter || pAfter);
+    let canOpen = leftFlanking && (next == 42 || !rightFlanking || pBefore);
+    let canClose = rightFlanking && (next == 42 || !leftFlanking || pAfter);
+    return cx.append(new InlineDelimiter(next == 95 ? EmphasisUnderscore : EmphasisAsterisk, start, pos, (canOpen ? 1 /* Open */ : 0) | (canClose ? 2 /* Close */ : 0)));
+  },
+  HardBreak(cx, next, start) {
+    if (next == 92 /* '\\' */ && cx.char(start + 1) == 10 /* '\n' */) return cx.append(elt(Type.HardBreak, start, start + 2));
+    if (next == 32) {
+      let pos = start + 1;
+      while (cx.char(pos) == 32) pos++;
+      if (cx.char(pos) == 10 && pos >= start + 2) return cx.append(elt(Type.HardBreak, start, pos + 1));
+    }
+    return -1;
+  },
+  Link(cx, next, start) {
+    return next == 91 /* '[' */ ? cx.append(new InlineDelimiter(LinkStart, start, start + 1, 1 /* Open */)) : -1;
+  },
+  Image(cx, next, start) {
+    return next == 33 /* '!' */ && cx.char(start + 1) == 91 /* '[' */ ? cx.append(new InlineDelimiter(ImageStart, start, start + 2, 1 /* Open */)) : -1;
+  },
+  LinkEnd(cx, next, start) {
+    if (next != 93 /* ']' */) return -1;
+    // Scanning back to the next link/image start marker
+    for (let i = cx.parts.length - 1; i >= 0; i--) {
+      let part = cx.parts[i];
+      if (part instanceof InlineDelimiter && (part.type == LinkStart || part.type == ImageStart)) {
+        // If this one has been set invalid (because it would produce
+        // a nested link) or there's no valid link here ignore both.
+        if (!part.side || cx.skipSpace(part.to) == start && !/[(\[]/.test(cx.slice(start + 1, start + 2))) {
+          cx.parts[i] = null;
+          return -1;
+        }
+        // Finish the content and replace the entire range in
+        // this.parts with the link/image node.
+        let content = cx.takeContent(i);
+        let link = cx.parts[i] = finishLink(cx, content, part.type == LinkStart ? Type.Link : Type.Image, part.from, start + 1);
+        // Set any open-link markers before this link to invalid.
+        if (part.type == LinkStart) for (let j = 0; j < i; j++) {
+          let p = cx.parts[j];
+          if (p instanceof InlineDelimiter && p.type == LinkStart) p.side = 0;
+        }
+        return link.to;
+      }
+    }
+    return -1;
+  }
+};
+function finishLink(cx, content, type, start, startPos) {
+  let {
+      text
+    } = cx,
+    next = cx.char(startPos),
+    endPos = startPos;
+  content.unshift(elt(Type.LinkMark, start, start + (type == Type.Image ? 2 : 1)));
+  content.push(elt(Type.LinkMark, startPos - 1, startPos));
+  if (next == 40 /* '(' */) {
+    let pos = cx.skipSpace(startPos + 1);
+    let dest = parseURL(text, pos - cx.offset, cx.offset),
+      title;
+    if (dest) {
+      pos = cx.skipSpace(dest.to);
+      title = parseLinkTitle(text, pos - cx.offset, cx.offset);
+      if (title) pos = cx.skipSpace(title.to);
+    }
+    if (cx.char(pos) == 41 /* ')' */) {
+      content.push(elt(Type.LinkMark, startPos, startPos + 1));
+      endPos = pos + 1;
+      if (dest) content.push(dest);
+      if (title) content.push(title);
+      content.push(elt(Type.LinkMark, pos, endPos));
+    }
+  } else if (next == 91 /* '[' */) {
+    let label = parseLinkLabel(text, startPos - cx.offset, cx.offset, false);
+    if (label) {
+      content.push(label);
+      endPos = label.to;
+    }
+  }
+  return elt(type, start, endPos, content);
+}
+// These return `null` when falling off the end of the input, `false`
+// when parsing fails otherwise (for use in the incremental link
+// reference parser).
+function parseURL(text, start, offset) {
+  let next = text.charCodeAt(start);
+  if (next == 60 /* '<' */) {
+    for (let pos = start + 1; pos < text.length; pos++) {
+      let ch = text.charCodeAt(pos);
+      if (ch == 62 /* '>' */) return elt(Type.URL, start + offset, pos + 1 + offset);
+      if (ch == 60 || ch == 10 /* '<\n' */) return false;
+    }
+    return null;
+  } else {
+    let depth = 0,
+      pos = start;
+    for (let escaped = false; pos < text.length; pos++) {
+      let ch = text.charCodeAt(pos);
+      if (space(ch)) {
+        break;
+      } else if (escaped) {
+        escaped = false;
+      } else if (ch == 40 /* '(' */) {
+        depth++;
+      } else if (ch == 41 /* ')' */) {
+        if (!depth) break;
+        depth--;
+      } else if (ch == 92 /* '\\' */) {
+        escaped = true;
+      }
+    }
+    return pos > start ? elt(Type.URL, start + offset, pos + offset) : pos == text.length ? null : false;
+  }
+}
+function parseLinkTitle(text, start, offset) {
+  let next = text.charCodeAt(start);
+  if (next != 39 && next != 34 && next != 40 /* '"\'(' */) return false;
+  let end = next == 40 ? 41 : next;
+  for (let pos = start + 1, escaped = false; pos < text.length; pos++) {
+    let ch = text.charCodeAt(pos);
+    if (escaped) escaped = false;else if (ch == end) return elt(Type.LinkTitle, start + offset, pos + 1 + offset);else if (ch == 92 /* '\\' */) escaped = true;
+  }
+  return null;
+}
+function parseLinkLabel(text, start, offset, requireNonWS) {
+  for (let escaped = false, pos = start + 1, end = Math.min(text.length, pos + 999); pos < end; pos++) {
+    let ch = text.charCodeAt(pos);
+    if (escaped) escaped = false;else if (ch == 93 /* ']' */) return requireNonWS ? false : elt(Type.LinkLabel, start + offset, pos + 1 + offset);else {
+      if (requireNonWS && !space(ch)) requireNonWS = false;
+      if (ch == 91 /* '[' */) return false;else if (ch == 92 /* '\\' */) escaped = true;
+    }
+  }
+  return null;
+}
+/// Inline parsing functions get access to this context, and use it to
+/// read the content and emit syntax nodes.
+class InlineContext {
+  /// @internal
+  constructor(
+  /// The parser that is being used.
+  parser,
+  /// The text of this inline section.
+  text,
+  /// The starting offset of the section in the document.
+  offset) {
+    this.parser = parser;
+    this.text = text;
+    this.offset = offset;
+    /// @internal
+    this.parts = [];
+  }
+  /// Get the character code at the given (document-relative)
+  /// position.
+  char(pos) {
+    return pos >= this.end ? -1 : this.text.charCodeAt(pos - this.offset);
+  }
+  /// The position of the end of this inline section.
+  get end() {
+    return this.offset + this.text.length;
+  }
+  /// Get a substring of this inline section. Again uses
+  /// document-relative positions.
+  slice(from, to) {
+    return this.text.slice(from - this.offset, to - this.offset);
+  }
+  /// @internal
+  append(elt) {
+    this.parts.push(elt);
+    return elt.to;
+  }
+  /// Add a [delimiter](#DelimiterType) at this given position. `open`
+  /// and `close` indicate whether this delimiter is opening, closing,
+  /// or both. Returns the end of the delimiter, for convenient
+  /// returning from [parse functions](#InlineParser.parse).
+  addDelimiter(type, from, to, open, close) {
+    return this.append(new InlineDelimiter(type, from, to, (open ? 1 /* Open */ : 0) | (close ? 2 /* Close */ : 0)));
+  }
+  /// Add an inline element. Returns the end of the element.
+  addElement(elt) {
+    return this.append(elt);
+  }
+  /// Resolve markers between this.parts.length and from, wrapping matched markers in the
+  /// appropriate node and updating the content of this.parts. @internal
+  resolveMarkers(from) {
+    // Scan forward, looking for closing tokens
+    for (let i = from; i < this.parts.length; i++) {
+      let close = this.parts[i];
+      if (!(close instanceof InlineDelimiter && close.type.resolve && close.side & 2 /* Close */)) continue;
+      let emp = close.type == EmphasisUnderscore || close.type == EmphasisAsterisk;
+      let closeSize = close.to - close.from;
+      let open,
+        j = i - 1;
+      // Continue scanning for a matching opening token
+      for (; j >= from; j--) {
+        let part = this.parts[j];
+        if (part instanceof InlineDelimiter && part.side & 1 /* Open */ && part.type == close.type &&
+        // Ignore emphasis delimiters where the character count doesn't match
+        !(emp && (close.side & 1 /* Open */ || part.side & 2 /* Close */) && (part.to - part.from + closeSize) % 3 == 0 && ((part.to - part.from) % 3 || closeSize % 3))) {
+          open = part;
+          break;
+        }
+      }
+      if (!open) continue;
+      let type = close.type.resolve,
+        content = [];
+      let start = open.from,
+        end = close.to;
+      // Emphasis marker effect depends on the character count. Size consumed is minimum of the two
+      // markers.
+      if (emp) {
+        let size = Math.min(2, open.to - open.from, closeSize);
+        start = open.to - size;
+        end = close.from + size;
+        type = size == 1 ? "Emphasis" : "StrongEmphasis";
+      }
+      // Move the covered region into content, optionally adding marker nodes
+      if (open.type.mark) content.push(this.elt(open.type.mark, start, open.to));
+      for (let k = j + 1; k < i; k++) {
+        if (this.parts[k] instanceof Element) content.push(this.parts[k]);
+        this.parts[k] = null;
+      }
+      if (close.type.mark) content.push(this.elt(close.type.mark, close.from, end));
+      let element = this.elt(type, start, end, content);
+      // If there are leftover emphasis marker characters, shrink the close/open markers. Otherwise, clear them.
+      this.parts[j] = emp && open.from != start ? new InlineDelimiter(open.type, open.from, start, open.side) : null;
+      let keep = this.parts[i] = emp && close.to != end ? new InlineDelimiter(close.type, end, close.to, close.side) : null;
+      // Insert the new element in this.parts
+      if (keep) this.parts.splice(i, 0, element);else this.parts[i] = element;
+    }
+    // Collect the elements remaining in this.parts into an array.
+    let result = [];
+    for (let i = from; i < this.parts.length; i++) {
+      let part = this.parts[i];
+      if (part instanceof Element) result.push(part);
+    }
+    return result;
+  }
+  /// Find an opening delimiter of the given type. Returns `null` if
+  /// no delimiter is found, or an index that can be passed to
+  /// [`takeContent`](#InlineContext.takeContent) otherwise.
+  findOpeningDelimiter(type) {
+    for (let i = this.parts.length - 1; i >= 0; i--) {
+      let part = this.parts[i];
+      if (part instanceof InlineDelimiter && part.type == type) return i;
+    }
+    return null;
+  }
+  /// Remove all inline elements and delimiters starting from the
+  /// given index (which you should get from
+  /// [`findOpeningDelimiter`](#InlineContext.findOpeningDelimiter),
+  /// resolve delimiters inside of them, and return them as an array
+  /// of elements.
+  takeContent(startIndex) {
+    let content = this.resolveMarkers(startIndex);
+    this.parts.length = startIndex;
+    return content;
+  }
+  /// Skip space after the given (document) position, returning either
+  /// the position of the next non-space character or the end of the
+  /// section.
+  skipSpace(from) {
+    return skipSpace(this.text, from - this.offset) + this.offset;
+  }
+  elt(type, from, to, children) {
+    if (typeof type == "string") return elt(this.parser.getNodeType(type), from, to, children);
+    return new TreeElement(type, from);
+  }
+}
+function injectMarks(elements, marks) {
+  if (!marks.length) return elements;
+  if (!elements.length) return marks;
+  let elts = elements.slice(),
+    eI = 0;
+  for (let mark of marks) {
+    while (eI < elts.length && elts[eI].to < mark.to) eI++;
+    if (eI < elts.length && elts[eI].from < mark.from) {
+      let e = elts[eI];
+      if (e instanceof Element) elts[eI] = new Element(e.type, e.from, e.to, injectMarks(e.children, [mark]));
+    } else {
+      elts.splice(eI++, 0, mark);
+    }
+  }
+  return elts;
+}
+// These are blocks that can span blank lines, and should thus only be
+// reused if their next sibling is also being reused.
+const NotLast = [Type.CodeBlock, Type.ListItem, Type.OrderedList, Type.BulletList];
+class FragmentCursor {
+  constructor(fragments, input) {
+    this.fragments = fragments;
+    this.input = input;
+    // Index into fragment array
+    this.i = 0;
+    // Active fragment
+    this.fragment = null;
+    this.fragmentEnd = -1;
+    // Cursor into the current fragment, if any. When `moveTo` returns
+    // true, this points at the first block after `pos`.
+    this.cursor = null;
+    if (fragments.length) this.fragment = fragments[this.i++];
+  }
+  nextFragment() {
+    this.fragment = this.i < this.fragments.length ? this.fragments[this.i++] : null;
+    this.cursor = null;
+    this.fragmentEnd = -1;
+  }
+  moveTo(pos, lineStart) {
+    while (this.fragment && this.fragment.to <= pos) this.nextFragment();
+    if (!this.fragment || this.fragment.from > (pos ? pos - 1 : 0)) return false;
+    if (this.fragmentEnd < 0) {
+      let end = this.fragment.to;
+      while (end > 0 && this.input.read(end - 1, end) != "\n") end--;
+      this.fragmentEnd = end ? end - 1 : 0;
+    }
+    let c = this.cursor;
+    if (!c) {
+      c = this.cursor = this.fragment.tree.cursor();
+      c.firstChild();
+    }
+    let rPos = pos + this.fragment.offset;
+    while (c.to <= rPos) if (!c.parent()) return false;
+    for (;;) {
+      if (c.from >= rPos) return this.fragment.from <= lineStart;
+      if (!c.childAfter(rPos)) return false;
+    }
+  }
+  matches(hash) {
+    let tree = this.cursor.tree;
+    return tree && tree.prop(NodeProp.contextHash) == hash;
+  }
+  takeNodes(cx) {
+    let cur = this.cursor,
+      off = this.fragment.offset,
+      fragEnd = this.fragmentEnd - (this.fragment.openEnd ? 1 : 0);
+    let start = cx.absoluteLineStart,
+      end = start,
+      blockI = cx.block.children.length;
+    let prevEnd = end,
+      prevI = blockI;
+    for (;;) {
+      if (cur.to - off > fragEnd) {
+        if (cur.type.isAnonymous && cur.firstChild()) continue;
+        break;
+      }
+      cx.dontInject.add(cur.tree);
+      cx.addNode(cur.tree, cur.from - off);
+      // Taken content must always end in a block, because incremental
+      // parsing happens on block boundaries. Never stop directly
+      // after an indented code block, since those can continue after
+      // any number of blank lines.
+      if (cur.type.is("Block")) {
+        if (NotLast.indexOf(cur.type.id) < 0) {
+          end = cur.to - off;
+          blockI = cx.block.children.length;
+        } else {
+          end = prevEnd;
+          blockI = prevI;
+          prevEnd = cur.to - off;
+          prevI = cx.block.children.length;
+        }
+      }
+      if (!cur.nextSibling()) break;
+    }
+    while (cx.block.children.length > blockI) {
+      cx.block.children.pop();
+      cx.block.positions.pop();
+    }
+    return end - start;
+  }
+}
+const markdownHighlighting = styleTags({
+  "Blockquote/...": tags$1.quote,
+  HorizontalRule: tags$1.contentSeparator,
+  "ATXHeading1/... SetextHeading1/...": tags$1.heading1,
+  "ATXHeading2/... SetextHeading2/...": tags$1.heading2,
+  "ATXHeading3/...": tags$1.heading3,
+  "ATXHeading4/...": tags$1.heading4,
+  "ATXHeading5/...": tags$1.heading5,
+  "ATXHeading6/...": tags$1.heading6,
+  "Comment CommentBlock": tags$1.comment,
+  Escape: tags$1.escape,
+  Entity: tags$1.character,
+  "Emphasis/...": tags$1.emphasis,
+  "StrongEmphasis/...": tags$1.strong,
+  "Link/... Image/...": tags$1.link,
+  "OrderedList/... BulletList/...": tags$1.list,
+  "BlockQuote/...": tags$1.quote,
+  "InlineCode CodeText": tags$1.monospace,
+  URL: tags$1.url,
+  "HeaderMark HardBreak QuoteMark ListMark LinkMark EmphasisMark CodeMark": tags$1.processingInstruction,
+  "CodeInfo LinkLabel": tags$1.labelName,
+  LinkTitle: tags$1.string,
+  Paragraph: tags$1.content
+});
+/// The default CommonMark parser.
+const parser = new MarkdownParser(new NodeSet(nodeTypes).extend(markdownHighlighting), Object.keys(DefaultBlockParsers).map(n => DefaultBlockParsers[n]), Object.keys(DefaultBlockParsers).map(n => DefaultLeafBlocks[n]), Object.keys(DefaultBlockParsers), DefaultEndLeaf, DefaultSkipMarkup, Object.keys(DefaultInline).map(n => DefaultInline[n]), Object.keys(DefaultInline), []);
+function leftOverSpace(node, from, to) {
+  let ranges = [];
+  for (let n = node.firstChild, pos = from;; n = n.nextSibling) {
+    let nextPos = n ? n.from : to;
+    if (nextPos > pos) ranges.push({
+      from: pos,
+      to: nextPos
+    });
+    if (!n) break;
+    pos = n.to;
+  }
+  return ranges;
+}
+/// Create a Markdown extension to enable nested parsing on code
+/// blocks and/or embedded HTML.
+function parseCode(config) {
+  let {
+    codeParser,
+    htmlParser
+  } = config;
+  let wrap = parseMixed((node, input) => {
+    let id = node.type.id;
+    if (codeParser && (id == Type.CodeBlock || id == Type.FencedCode)) {
+      let info = "";
+      if (id == Type.FencedCode) {
+        let infoNode = node.node.getChild(Type.CodeInfo);
+        if (infoNode) info = input.read(infoNode.from, infoNode.to);
+      }
+      let parser = codeParser(info);
+      if (parser) return {
+        parser,
+        overlay: node => node.type.id == Type.CodeText
+      };
+    } else if (htmlParser && (id == Type.HTMLBlock || id == Type.HTMLTag)) {
+      return {
+        parser: htmlParser,
+        overlay: leftOverSpace(node.node, node.from, node.to)
+      };
+    }
+    return null;
+  });
+  return {
+    wrap
+  };
+}
+const StrikethroughDelim = {
+  resolve: "Strikethrough",
+  mark: "StrikethroughMark"
+};
+/// An extension that implements
+/// [GFM-style](https://github.github.com/gfm/#strikethrough-extension-)
+/// Strikethrough syntax using `~~` delimiters.
+const Strikethrough = {
+  defineNodes: [{
+    name: "Strikethrough",
+    style: {
+      "Strikethrough/...": tags$1.strikethrough
+    }
+  }, {
+    name: "StrikethroughMark",
+    style: tags$1.processingInstruction
+  }],
+  parseInline: [{
+    name: "Strikethrough",
+    parse(cx, next, pos) {
+      if (next != 126 /* '~' */ || cx.char(pos + 1) != 126 || cx.char(pos + 2) == 126) return -1;
+      let before = cx.slice(pos - 1, pos),
+        after = cx.slice(pos + 2, pos + 3);
+      let sBefore = /\s|^$/.test(before),
+        sAfter = /\s|^$/.test(after);
+      let pBefore = Punctuation.test(before),
+        pAfter = Punctuation.test(after);
+      return cx.addDelimiter(StrikethroughDelim, pos, pos + 2, !sAfter && (!pAfter || sBefore || pBefore), !sBefore && (!pBefore || sAfter || pAfter));
+    },
+    after: "Emphasis"
+  }]
+};
+function parseRow(cx, line, startI = 0, elts, offset = 0) {
+  let count = 0,
+    first = true,
+    cellStart = -1,
+    cellEnd = -1,
+    esc = false;
+  let parseCell = () => {
+    elts.push(cx.elt("TableCell", offset + cellStart, offset + cellEnd, cx.parser.parseInline(line.slice(cellStart, cellEnd), offset + cellStart)));
+  };
+  for (let i = startI; i < line.length; i++) {
+    let next = line.charCodeAt(i);
+    if (next == 124 /* '|' */ && !esc) {
+      if (!first || cellStart > -1) count++;
+      first = false;
+      if (elts) {
+        if (cellStart > -1) parseCell();
+        elts.push(cx.elt("TableDelimiter", i + offset, i + offset + 1));
+      }
+      cellStart = cellEnd = -1;
+    } else if (esc || next != 32 && next != 9) {
+      if (cellStart < 0) cellStart = i;
+      cellEnd = i + 1;
+    }
+    esc = !esc && next == 92;
+  }
+  if (cellStart > -1) {
+    count++;
+    if (elts) parseCell();
+  }
+  return count;
+}
+function hasPipe(str, start) {
+  for (let i = start; i < str.length; i++) {
+    let next = str.charCodeAt(i);
+    if (next == 124 /* '|' */) return true;
+    if (next == 92 /* '\\' */) i++;
+  }
+  return false;
+}
+const delimiterLine = /^\|?(\s*:?-+:?\s*\|)+(\s*:?-+:?\s*)?$/;
+class TableParser {
+  constructor() {
+    // Null means we haven't seen the second line yet, false means this
+    // isn't a table, and an array means this is a table and we've
+    // parsed the given rows so far.
+    this.rows = null;
+  }
+  nextLine(cx, line, leaf) {
+    if (this.rows == null) {
+      // Second line
+      this.rows = false;
+      let lineText;
+      if ((line.next == 45 || line.next == 58 || line.next == 124 /* '-:|' */) && delimiterLine.test(lineText = line.text.slice(line.pos))) {
+        let firstRow = [],
+          firstCount = parseRow(cx, leaf.content, 0, firstRow, leaf.start);
+        if (firstCount == parseRow(cx, lineText, line.pos)) this.rows = [cx.elt("TableHeader", leaf.start, leaf.start + leaf.content.length, firstRow), cx.elt("TableDelimiter", cx.lineStart + line.pos, cx.lineStart + line.text.length)];
+      }
+    } else if (this.rows) {
+      // Line after the second
+      let content = [];
+      parseRow(cx, line.text, line.pos, content, cx.lineStart);
+      this.rows.push(cx.elt("TableRow", cx.lineStart + line.pos, cx.lineStart + line.text.length, content));
+    }
+    return false;
+  }
+  finish(cx, leaf) {
+    if (!this.rows) return false;
+    cx.addLeafElement(leaf, cx.elt("Table", leaf.start, leaf.start + leaf.content.length, this.rows));
+    return true;
+  }
+}
+/// This extension provides
+/// [GFM-style](https://github.github.com/gfm/#tables-extension-)
+/// tables, using syntax like this:
+///
+/// ```
+/// | head 1 | head 2 |
+/// | ---    | ---    |
+/// | cell 1 | cell 2 |
+/// ```
+const Table = {
+  defineNodes: [{
+    name: "Table",
+    block: true
+  }, {
+    name: "TableHeader",
+    style: {
+      "TableHeader/...": tags$1.heading
+    }
+  }, "TableRow", {
+    name: "TableCell",
+    style: tags$1.content
+  }, {
+    name: "TableDelimiter",
+    style: tags$1.processingInstruction
+  }],
+  parseBlock: [{
+    name: "Table",
+    leaf(_, leaf) {
+      return hasPipe(leaf.content, 0) ? new TableParser() : null;
+    },
+    endLeaf(cx, line, leaf) {
+      if (leaf.parsers.some(p => p instanceof TableParser) || !hasPipe(line.text, line.basePos)) return false;
+      let next = cx.scanLine(cx.absoluteLineEnd + 1).text;
+      return delimiterLine.test(next) && parseRow(cx, line.text, line.basePos) == parseRow(cx, next, line.basePos);
+    },
+    before: "SetextHeading"
+  }]
+};
+class TaskParser {
+  nextLine() {
+    return false;
+  }
+  finish(cx, leaf) {
+    cx.addLeafElement(leaf, cx.elt("Task", leaf.start, leaf.start + leaf.content.length, [cx.elt("TaskMarker", leaf.start, leaf.start + 3), ...cx.parser.parseInline(leaf.content.slice(3), leaf.start + 3)]));
+    return true;
+  }
+}
+/// Extension providing
+/// [GFM-style](https://github.github.com/gfm/#task-list-items-extension-)
+/// task list items, where list items can be prefixed with `[ ]` or
+/// `[x]` to add a checkbox.
+const TaskList = {
+  defineNodes: [{
+    name: "Task",
+    block: true,
+    style: tags$1.list
+  }, {
+    name: "TaskMarker",
+    style: tags$1.atom
+  }],
+  parseBlock: [{
+    name: "TaskList",
+    leaf(cx, leaf) {
+      return /^\[[ xX]\]/.test(leaf.content) && cx.parentType().name == "ListItem" ? new TaskParser() : null;
+    },
+    after: "SetextHeading"
+  }]
+};
+/// Extension bundle containing [`Table`](#Table),
+/// [`TaskList`](#TaskList) and [`Strikethrough`](#Strikethrough).
+const GFM = [Table, TaskList, Strikethrough];
+function parseSubSuper(ch, node, mark) {
+  return (cx, next, pos) => {
+    if (next != ch || cx.char(pos + 1) == ch) return -1;
+    let elts = [cx.elt(mark, pos, pos + 1)];
+    for (let i = pos + 1; i < cx.end; i++) {
+      let next = cx.char(i);
+      if (next == ch) return cx.addElement(cx.elt(node, pos, i + 1, elts.concat(cx.elt(mark, i, i + 1))));
+      if (next == 92 /* '\\' */) elts.push(cx.elt("Escape", i, i++ + 2));
+      if (space(next)) break;
+    }
+    return -1;
+  };
+}
+/// Extension providing
+/// [Pandoc-style](https://pandoc.org/MANUAL.html#superscripts-and-subscripts)
+/// superscript using `^` markers.
+const Superscript = {
+  defineNodes: [{
+    name: "Superscript",
+    style: tags$1.special(tags$1.content)
+  }, {
+    name: "SuperscriptMark",
+    style: tags$1.processingInstruction
+  }],
+  parseInline: [{
+    name: "Superscript",
+    parse: parseSubSuper(94 /* '^' */, "Superscript", "SuperscriptMark")
+  }]
+};
+/// Extension providing
+/// [Pandoc-style](https://pandoc.org/MANUAL.html#superscripts-and-subscripts)
+/// subscript using `~` markers.
+const Subscript = {
+  defineNodes: [{
+    name: "Subscript",
+    style: tags$1.special(tags$1.content)
+  }, {
+    name: "SubscriptMark",
+    style: tags$1.processingInstruction
+  }],
+  parseInline: [{
+    name: "Subscript",
+    parse: parseSubSuper(126 /* '~' */, "Subscript", "SubscriptMark")
+  }]
+};
+/// Extension that parses two colons with only letters, underscores,
+/// and numbers between them as `Emoji` nodes.
+const Emoji = {
+  defineNodes: [{
+    name: "Emoji",
+    style: tags$1.character
+  }],
+  parseInline: [{
+    name: "Emoji",
+    parse(cx, next, pos) {
+      let match;
+      if (next != 58 /* ':' */ || !(match = /^[a-zA-Z_0-9]+:/.exec(cx.slice(pos + 1, cx.end)))) return -1;
+      return cx.addElement(cx.elt("Emoji", pos, pos + 1 + match[0].length));
+    }
+  }]
+};
+
+const data = /*@__PURE__*/defineLanguageFacet({
+  block: {
+    open: "<!--",
+    close: "-->"
+  }
+});
+const commonmark = /*@__PURE__*/parser.configure({
+  props: [/*@__PURE__*/foldNodeProp.add(type => {
+    if (!type.is("Block") || type.is("Document")) return undefined;
+    return (tree, state) => ({
+      from: state.doc.lineAt(tree.from).to,
+      to: tree.to
+    });
+  }), /*@__PURE__*/indentNodeProp.add({
+    Document: () => null
+  }), /*@__PURE__*/languageDataProp.add({
+    Document: data
+  })]
+});
+function mkLang(parser) {
+  return new Language(data, parser);
+}
+/**
+Language support for strict CommonMark.
+*/
+const commonmarkLanguage = /*@__PURE__*/mkLang(commonmark);
+const extended = /*@__PURE__*/commonmark.configure([GFM, Subscript, Superscript, Emoji]);
+/**
+Language support for [GFM](https://github.github.com/gfm/) plus
+subscript, superscript, and emoji syntax.
+*/
+const markdownLanguage = /*@__PURE__*/mkLang(extended);
+function getCodeParser(languages, defaultLanguage) {
+  return info => {
+    if (info && languages) {
+      let found = null;
+      // Strip anything after whitespace
+      info = /\S*/.exec(info)[0];
+      if (typeof languages == "function") found = languages(info);else found = LanguageDescription.matchLanguageName(languages, info, true);
+      if (found instanceof LanguageDescription) return found.support ? found.support.language.parser : ParseContext.getSkippingParser(found.load());else if (found) return found.parser;
+    }
+    return defaultLanguage ? defaultLanguage.parser : null;
+  };
+}
+function nodeStart(node, doc) {
+  return doc.sliceString(node.from, node.from + 50);
+}
+class Context {
+  constructor(node, from, to, spaceBefore, spaceAfter, type, item) {
+    this.node = node;
+    this.from = from;
+    this.to = to;
+    this.spaceBefore = spaceBefore;
+    this.spaceAfter = spaceAfter;
+    this.type = type;
+    this.item = item;
+  }
+  blank(trailing = true) {
+    let result = this.spaceBefore;
+    if (this.node.name == "Blockquote") result += ">";else for (let i = this.to - this.from - result.length - this.spaceAfter.length; i > 0; i--) result += " ";
+    return result + (trailing ? this.spaceAfter : "");
+  }
+  marker(doc, add) {
+    let number = this.node.name == "OrderedList" ? String(+itemNumber(this.item, doc)[2] + add) : "";
+    return this.spaceBefore + number + this.type + this.spaceAfter;
+  }
+}
+function getContext(node, line, doc) {
+  let nodes = [];
+  for (let cur = node; cur && cur.name != "Document"; cur = cur.parent) {
+    if (cur.name == "ListItem" || cur.name == "Blockquote") nodes.push(cur);
+  }
+  let context = [],
+    pos = 0;
+  for (let i = nodes.length - 1; i >= 0; i--) {
+    let node = nodes[i],
+      match,
+      start = pos;
+    if (node.name == "Blockquote" && (match = /^[ \t]*>( ?)/.exec(line.slice(pos)))) {
+      pos += match[0].length;
+      context.push(new Context(node, start, pos, "", match[1], ">", null));
+    } else if (node.name == "ListItem" && node.parent.name == "OrderedList" && (match = /^([ \t]*)\d+([.)])([ \t]*)/.exec(nodeStart(node, doc)))) {
+      let after = match[3],
+        len = match[0].length;
+      if (after.length >= 4) {
+        after = after.slice(0, after.length - 4);
+        len -= 4;
+      }
+      pos += len;
+      context.push(new Context(node.parent, start, pos, match[1], after, match[2], node));
+    } else if (node.name == "ListItem" && node.parent.name == "BulletList" && (match = /^([ \t]*)([-+*])([ \t]{1,4}\[[ xX]\])?([ \t]+)/.exec(nodeStart(node, doc)))) {
+      let after = match[4],
+        len = match[0].length;
+      if (after.length > 4) {
+        after = after.slice(0, after.length - 4);
+        len -= 4;
+      }
+      let type = match[2];
+      if (match[3]) type += match[3].replace(/[xX]/, ' ');
+      pos += len;
+      context.push(new Context(node.parent, start, pos, match[1], after, type, node));
+    }
+  }
+  return context;
+}
+function itemNumber(item, doc) {
+  return /^(\s*)(\d+)(?=[.)])/.exec(doc.sliceString(item.from, item.from + 10));
+}
+function renumberList(after, doc, changes, offset = 0) {
+  for (let prev = -1, node = after;;) {
+    if (node.name == "ListItem") {
+      let m = itemNumber(node, doc);
+      let number = +m[2];
+      if (prev >= 0) {
+        if (number != prev + 1) return;
+        changes.push({
+          from: node.from + m[1].length,
+          to: node.from + m[0].length,
+          insert: String(prev + 2 + offset)
+        });
+      }
+      prev = number;
+    }
+    let next = node.nextSibling;
+    if (!next) break;
+    node = next;
+  }
+}
+/**
+This command, when invoked in Markdown context with cursor
+selection(s), will create a new line with the markup for
+blockquotes and lists that were active on the old line. If the
+cursor was directly after the end of the markup for the old line,
+trailing whitespace and list markers are removed from that line.
+
+The command does nothing in non-Markdown context, so it should
+not be used as the only binding for Enter (even in a Markdown
+document, HTML and code regions might use a different language).
+*/
+const insertNewlineContinueMarkup = ({
+  state,
+  dispatch
+}) => {
+  let tree = syntaxTree(state),
+    {
+      doc
+    } = state;
+  let dont = null,
+    changes = state.changeByRange(range => {
+      if (!range.empty || !markdownLanguage.isActiveAt(state, range.from)) return dont = {
+        range
+      };
+      let pos = range.from,
+        line = doc.lineAt(pos);
+      let context = getContext(tree.resolveInner(pos, -1), line.text, doc);
+      while (context.length && context[context.length - 1].from > pos - line.from) context.pop();
+      if (!context.length) return dont = {
+        range
+      };
+      let inner = context[context.length - 1];
+      if (inner.to - inner.spaceAfter.length > pos - line.from) return dont = {
+        range
+      };
+      let emptyLine = pos >= inner.to - inner.spaceAfter.length && !/\S/.test(line.text.slice(inner.to));
+      // Empty line in list
+      if (inner.item && emptyLine) {
+        // First list item or blank line before: delete a level of markup
+        if (inner.node.firstChild.to >= pos || line.from > 0 && !/[^\s>]/.test(doc.lineAt(line.from - 1).text)) {
+          let next = context.length > 1 ? context[context.length - 2] : null;
+          let delTo,
+            insert = "";
+          if (next && next.item) {
+            // Re-add marker for the list at the next level
+            delTo = line.from + next.from;
+            insert = next.marker(doc, 1);
+          } else {
+            delTo = line.from + (next ? next.to : 0);
+          }
+          let changes = [{
+            from: delTo,
+            to: pos,
+            insert
+          }];
+          if (inner.node.name == "OrderedList") renumberList(inner.item, doc, changes, -2);
+          if (next && next.node.name == "OrderedList") renumberList(next.item, doc, changes);
+          return {
+            range: EditorSelection.cursor(delTo + insert.length),
+            changes
+          };
+        } else {
+          // Move this line down
+          let insert = "";
+          for (let i = 0, e = context.length - 2; i <= e; i++) insert += context[i].blank(i < e);
+          insert += state.lineBreak;
+          return {
+            range: EditorSelection.cursor(pos + insert.length),
+            changes: {
+              from: line.from,
+              insert
+            }
+          };
+        }
+      }
+      if (inner.node.name == "Blockquote" && emptyLine && line.from) {
+        let prevLine = doc.lineAt(line.from - 1),
+          quoted = />\s*$/.exec(prevLine.text);
+        // Two aligned empty quoted lines in a row
+        if (quoted && quoted.index == inner.from) {
+          let changes = state.changes([{
+            from: prevLine.from + quoted.index,
+            to: prevLine.to
+          }, {
+            from: line.from + inner.from,
+            to: line.to
+          }]);
+          return {
+            range: range.map(changes),
+            changes
+          };
+        }
+      }
+      let changes = [];
+      if (inner.node.name == "OrderedList") renumberList(inner.item, doc, changes);
+      let insert = state.lineBreak;
+      let continued = inner.item && inner.item.from < line.from;
+      // If not dedented
+      if (!continued || /^[\s\d.)\-+*>]*/.exec(line.text)[0].length >= inner.to) {
+        for (let i = 0, e = context.length - 1; i <= e; i++) insert += i == e && !continued ? context[i].marker(doc, 1) : context[i].blank();
+      }
+      let from = pos;
+      while (from > line.from && /\s/.test(line.text.charAt(from - line.from - 1))) from--;
+      changes.push({
+        from,
+        to: pos,
+        insert
+      });
+      return {
+        range: EditorSelection.cursor(from + insert.length),
+        changes
+      };
+    });
+  if (dont) return false;
+  dispatch(state.update(changes, {
+    scrollIntoView: true,
+    userEvent: "input"
+  }));
+  return true;
+};
+function isMark(node) {
+  return node.name == "QuoteMark" || node.name == "ListMark";
+}
+function contextNodeForDelete(tree, pos) {
+  let node = tree.resolveInner(pos, -1),
+    scan = pos;
+  if (isMark(node)) {
+    scan = node.from;
+    node = node.parent;
+  }
+  for (let prev; prev = node.childBefore(scan);) {
+    if (isMark(prev)) {
+      scan = prev.from;
+    } else if (prev.name == "OrderedList" || prev.name == "BulletList") {
+      node = prev.lastChild;
+      scan = node.to;
+    } else {
+      break;
+    }
+  }
+  return node;
+}
+/**
+This command will, when invoked in a Markdown context with the
+cursor directly after list or blockquote markup, delete one level
+of markup. When the markup is for a list, it will be replaced by
+spaces on the first invocation (a further invocation will delete
+the spaces), to make it easy to continue a list.
+
+When not after Markdown block markup, this command will return
+false, so it is intended to be bound alongside other deletion
+commands, with a higher precedence than the more generic commands.
+*/
+const deleteMarkupBackward = ({
+  state,
+  dispatch
+}) => {
+  let tree = syntaxTree(state);
+  let dont = null,
+    changes = state.changeByRange(range => {
+      let pos = range.from,
+        {
+          doc
+        } = state;
+      if (range.empty && markdownLanguage.isActiveAt(state, range.from)) {
+        let line = doc.lineAt(pos);
+        let context = getContext(contextNodeForDelete(tree, pos), line.text, doc);
+        if (context.length) {
+          let inner = context[context.length - 1];
+          let spaceEnd = inner.to - inner.spaceAfter.length + (inner.spaceAfter ? 1 : 0);
+          // Delete extra trailing space after markup
+          if (pos - line.from > spaceEnd && !/\S/.test(line.text.slice(spaceEnd, pos - line.from))) return {
+            range: EditorSelection.cursor(line.from + spaceEnd),
+            changes: {
+              from: line.from + spaceEnd,
+              to: pos
+            }
+          };
+          if (pos - line.from == spaceEnd) {
+            let start = line.from + inner.from;
+            // Replace a list item marker with blank space
+            if (inner.item && inner.node.from < inner.item.from && /\S/.test(line.text.slice(inner.from, inner.to))) return {
+              range,
+              changes: {
+                from: start,
+                to: line.from + inner.to,
+                insert: inner.blank()
+              }
+            };
+            // Delete one level of indentation
+            if (start < pos) return {
+              range: EditorSelection.cursor(start),
+              changes: {
+                from: start,
+                to: pos
+              }
+            };
+          }
+        }
+      }
+      return dont = {
+        range
+      };
+    });
+  if (dont) return false;
+  dispatch(state.update(changes, {
+    scrollIntoView: true,
+    userEvent: "delete"
+  }));
+  return true;
+};
+
+/**
+A small keymap with Markdown-specific bindings. Binds Enter to
+[`insertNewlineContinueMarkup`](https://codemirror.net/6/docs/ref/#lang-markdown.insertNewlineContinueMarkup)
+and Backspace to
+[`deleteMarkupBackward`](https://codemirror.net/6/docs/ref/#lang-markdown.deleteMarkupBackward).
+*/
+const markdownKeymap = [{
+  key: "Enter",
+  run: insertNewlineContinueMarkup
+}, {
+  key: "Backspace",
+  run: deleteMarkupBackward
+}];
+const htmlNoMatch = /*@__PURE__*/html({
+  matchClosingTags: false
+});
+/**
+Markdown language support.
+*/
+function markdown(config = {}) {
+  let {
+    codeLanguages,
+    defaultCodeLanguage,
+    addKeymap = true,
+    base: {
+      parser
+    } = commonmarkLanguage
+  } = config;
+  if (!(parser instanceof MarkdownParser)) throw new RangeError("Base parser provided to `markdown` should be a Markdown parser");
+  let extensions = config.extensions ? [config.extensions] : [];
+  let support = [htmlNoMatch.support],
+    defaultCode;
+  if (defaultCodeLanguage instanceof LanguageSupport) {
+    support.push(defaultCodeLanguage.support);
+    defaultCode = defaultCodeLanguage.language;
+  } else if (defaultCodeLanguage) {
+    defaultCode = defaultCodeLanguage;
+  }
+  let codeParser = codeLanguages || defaultCode ? getCodeParser(codeLanguages, defaultCode) : undefined;
+  extensions.push(parseCode({
+    codeParser,
+    htmlParser: htmlNoMatch.language.parser
+  }));
+  if (addKeymap) support.push(Prec.high(keymap.of(markdownKeymap)));
+  return new LanguageSupport(mkLang(parser.configure(extensions)), support);
+}
+
+const JS = javascript({
+  typescript: false
+});
+const TS = javascript({
+  typescript: true
+});
+const CSS = css();
+const HTML = html();
+const JSON$1 = json();
+const MD = markdown();
+var languages = {
+  [OrCodeLanguages.JS]: JS,
+  [OrCodeLanguages.TS]: TS,
+  [OrCodeLanguages.CSS]: CSS,
+  [OrCodeLanguages.HTML]: HTML,
+  [OrCodeLanguages.JSON]: JSON$1,
+  [OrCodeLanguages.MD]: MD
+};
+
+// Using https://github.com/one-dark/vscode-one-dark-theme/ as reference for the colors
+const chalky = 'var(--c-warning-darken-20)',
+  coral = 'var(--c-error)',
+  cyan = '#56b6c2',
+  invalid = 'var(--c-white)',
+  ivory = 'var(--c-neutral-6)',
+  stone = 'var(--c-neutral-5)',
+  // Brightened compared to original to increase contrast
+  malibu = '#61afef',
+  sage = 'var(--c-success)',
+  whiskey = 'var(--c-warning-darken-5)',
+  violet = '#c678dd',
+  darkBackground = 'var(--c-neutral-1)',
+  highlightBackground = 'var(--c-neutral-2)',
+  background = 'var(--c-neutral-1)',
+  tooltipBackground = 'var(--c-neutral-2)',
+  selection = 'var(--c-neutral-3)',
+  cursor = 'var(--c-primary)';
+/// The editor theme styles for One Dark.
+const orCodeTheme = EditorView.theme({
+  '&': {
+    color: ivory,
+    backgroundColor: background
+  },
+  '.cm-content': {
+    caretColor: cursor
+  },
+  '.cm-button': {
+    background: highlightBackground,
+    color: 'var(--c-neutral-6)',
+    border: 0,
+    borderRadius: 'var(--s-2)'
+  },
+  '.cm-panel.cm-search input[type=checkbox]': {
+    display: 'inline-block',
+    verticalAlign: 'middle'
+  },
+  '.cm-cursor, .cm-dropCursor': {
+    borderLeftColor: cursor
+  },
+  '&.cm-focused .cm-selectionBackground, .cm-selectionBackground, .cm-content ::selection': {
+    backgroundColor: selection
+  },
+  '.cm-panels': {
+    backgroundColor: darkBackground,
+    color: ivory
+  },
+  '.cm-panels.cm-panels-top': {
+    borderBottom: '2px solid var(--c-neutral-2)'
+  },
+  '.cm-panels.cm-panels-bottom': {
+    borderTop: '2px solid var(--c-neutral-2)'
+  },
+  '.cm-searchMatch': {
+    backgroundColor: 'var(--c-neutral-1)',
+    outline: '1px solid var(--c-neutral-2)'
+  },
+  '.cm-searchMatch.cm-searchMatch-selected': {
+    backgroundColor: '#6199ff2f'
+  },
+  '.cm-activeLine': {
+    backgroundColor: '#6699ff0b'
+  },
+  '.cm-selectionMatch': {
+    backgroundColor: '#aafe661a'
+  },
+  '&.cm-focused .cm-matchingBracket, &.cm-focused .cm-nonmatchingBracket': {
+    backgroundColor: '#bad0f847'
+  },
+  '.cm-gutters': {
+    backgroundColor: background,
+    color: stone,
+    border: 'none'
+  },
+  '.cm-activeLineGutter': {
+    backgroundColor: highlightBackground
+  },
+  '.cm-foldPlaceholder': {
+    backgroundColor: 'transparent',
+    border: 'none',
+    color: '#ddd'
+  },
+  '.cm-tooltip': {
+    border: 'none',
+    backgroundColor: tooltipBackground
+  },
+  '.cm-tooltip .cm-tooltip-arrow:before': {
+    borderTopColor: 'transparent',
+    borderBottomColor: 'transparent'
+  },
+  '.cm-tooltip .cm-tooltip-arrow:after': {
+    borderTopColor: tooltipBackground,
+    borderBottomColor: tooltipBackground
+  },
+  '.cm-tooltip-autocomplete': {
+    '& > ul > li[aria-selected]': {
+      backgroundColor: highlightBackground,
+      color: ivory
+    }
+  },
+  '.cm-textfield': {
+    outline: 'none',
+    background: background,
+    color: 'var(--c-neutral-6)',
+    backgroundColor: 'var(--c-neutral-1)',
+    border: '1px solid var(--c-neutral-2)',
+    borderRadius: 'var(--s-2)'
+  }
+}, {
+  dark: true
+});
+/// The highlighting style for code in the One Dark theme.
+const orCodeHighlightStyle = HighlightStyle.define([{
+  tag: tags$1.keyword,
+  color: violet
+}, {
+  tag: [tags$1.name, tags$1.deleted, tags$1.character, tags$1.propertyName, tags$1.macroName],
+  color: coral
+}, {
+  tag: [tags$1.function(tags$1.variableName), tags$1.labelName],
+  color: malibu
+}, {
+  tag: [tags$1.color, tags$1.constant(tags$1.name), tags$1.standard(tags$1.name)],
+  color: whiskey
+}, {
+  tag: [tags$1.definition(tags$1.name), tags$1.separator],
+  color: ivory
+}, {
+  tag: [tags$1.typeName, tags$1.className, tags$1.number, tags$1.changed, tags$1.annotation, tags$1.modifier, tags$1.self, tags$1.namespace],
+  color: chalky
+}, {
+  tag: [tags$1.operator, tags$1.operatorKeyword, tags$1.url, tags$1.escape, tags$1.regexp, tags$1.link, tags$1.special(tags$1.string)],
+  color: cyan
+}, {
+  tag: [tags$1.meta, tags$1.comment],
+  color: stone
+}, {
+  tag: tags$1.strong,
+  fontWeight: 'bold'
+}, {
+  tag: tags$1.emphasis,
+  fontStyle: 'italic'
+}, {
+  tag: tags$1.strikethrough,
+  textDecoration: 'line-through'
+}, {
+  tag: tags$1.link,
+  color: stone,
+  textDecoration: 'underline'
+}, {
+  tag: tags$1.heading,
+  fontWeight: 'bold',
+  color: coral
+}, {
+  tag: [tags$1.atom, tags$1.bool, tags$1.special(tags$1.variableName)],
+  color: whiskey
+}, {
+  tag: [tags$1.processingInstruction, tags$1.string, tags$1.inserted],
+  color: sage
+}, {
+  tag: tags$1.invalid,
+  color: invalid
+}]);
+/// Extension to enable the One Dark theme (both the editor theme and
+/// the highlight style).
+const theme = [orCodeTheme, syntaxHighlighting(orCodeHighlightStyle)];
+
+//partially based on https://github.com/logue/vue-codemirror6/blob/master/src/components/CodeMirror.vue
+var script = defineComponent({
+  name: 'OrCode',
+  components: {
+    OrIconButton,
+    OrModal,
+    OrTeleport,
+    OrError,
+    OrHint,
+    OrLabel
+  },
+  model: {
+    prop: 'modelValue',
+    event: 'update:modelValue'
+  },
+  props: {
+    label: {
+      type: String,
+      default: '',
+      required: false
+    },
+    modelValue: {
+      type: String,
+      default: '',
+      required: false
+    },
+    language: {
+      type: [Object, String],
+      required: false,
+      default: OrCodeLanguages.JS
+    },
+    isReadonly: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    extensions: {
+      type: Array,
+      required: false,
+      default: () => [basicSetup]
+    },
+    phrases: {
+      type: Object,
+      required: false,
+      default: null
+    },
+    isShowingFullscreen: {
+      type: Boolean,
+      default: true,
+      required: false
+    },
+    isInvalid: {
+      type: Boolean,
+      default: false,
+      required: false
+    },
+    error: {
+      type: String,
+      default: '',
+      required: false
+    },
+    hint: {
+      type: String,
+      default: '',
+      required: false
+    },
+    allowPaste: {
+      type: Boolean,
+      default: true
+    },
+    allowDrop: {
+      type: Boolean,
+      default: true
+    },
+    lineWrapping: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ['update:modelValue', 'focus', 'blur'],
+  setup(props, {
+    emit
+  }) {
+    // editor config
+    const root = ref();
+    const target = ref();
+    const fullscreenTarget = ref();
+    const isHovered = useElementHover(root);
+    const editor = new EditorView({
+      state: EditorState.create({
+        doc: props.modelValue
+      }),
+      dispatch: tr => {
+        editor.update([tr]);
+        if (tr.changes.empty) return;
+        emit('update:modelValue', editor.state.doc.toString());
+      }
+    });
+    return {
+      root,
+      target,
+      fullscreenTarget,
+      editor,
+      isHovered
+    };
+  },
+  data() {
+    return {
+      isFullscreen: false
+    };
+  },
+  computed: {
+    localLanguage() {
+      if (Object.values(OrCodeLanguages).includes(this.language)) {
+        return languages[this.language];
+      } else {
+        return this.language;
+      }
+    },
+    localExtensions() {
+      const {
+        allowDrop,
+        allowPaste,
+        lineWrapping,
+        extensions
+      } = this;
+      let ext = [theme, EditorView.baseTheme({}),
+      // locale settings
+      this.phrases ? EditorState.phrases.of(this.phrases) : undefined,
+      // Parser language setting
+      this.localLanguage,
+      // Editable option
+      EditorView.editable.of(!this.isReadonly),
+      // Focus and blur listener
+      EditorView.updateListener.of(viewUpdate => {
+        if (viewUpdate.focusChanged) {
+          viewUpdate.view.hasFocus ? this.$emit('focus') : this.$emit('blur', viewUpdate.state.doc.toString());
+        }
+      }), EditorView.domEventHandlers({
+        drop(event) {
+          if (!allowDrop) {
+            event.preventDefault();
+            return true;
+          }
+        },
+        paste(event) {
+          if (!allowPaste) {
+            event.preventDefault();
+            return true;
+          }
+        }
+      }),
+      // line wrapping
+      lineWrapping ? EditorView.lineWrapping : undefined, keymap.of([indentWithTab])];
+      if (Array.isArray(extensions)) {
+        ext = [...ext, ...extensions];
+      }
+      ext = ext.filter(Boolean);
+      return ext;
+    },
+    isShowingError() {
+      return !!this.error && this.isInvalid;
+    },
+    isShowingHint() {
+      return !!this.hint && !this.isShowingError;
+    },
+    isShowingHeader() {
+      var _a;
+      return this.isShowingFullscreen || this.$slots.label || this.$slots.actions || ((_a = this.$scopedSlots) === null || _a === void 0 ? void 0 : _a.actions);
+    }
+  },
+  watch: {
+    modelValue(value) {
+      if (this.editor.composing) return;
+      if (this.editor.state.doc.toString() === value) return;
+      const previous = this.editor.state.selection;
+      this.editor.setState(EditorState.create({
+        doc: value,
+        extensions: this.localExtensions,
+        selection: previous.ranges.some(range => range.to > value.length) ? {
+          anchor: value.length
+        } : previous
+      }));
+    },
+    isFullscreen(value) {
+      if (value) {
+        this.fullscreenTarget.append(this.editor.dom);
+      } else {
+        this.target.append(this.editor.dom);
+      }
+    },
+    localExtensions() {
+      this.updateEditorState();
+    }
+  },
+  mounted() {
+    this.updateEditorState();
+    this.target.append(this.editor.dom);
+  },
+  beforeUnmount() {
+    var _a;
+    (_a = this.editor) === null || _a === void 0 ? void 0 : _a.destroy();
+  },
+  methods: {
+    updateEditorState() {
+      this.editor.setState(EditorState.create({
+        doc: this.modelValue,
+        extensions: this.localExtensions
+      }));
+    },
+    toggleFullscreen(value) {
+      this.isFullscreen = value === undefined ? !this.isFullscreen : value;
+    }
+  }
+});
+
+var css_248z = "@keyframes spinAround-data-v-3ea817b2{from{transform:rotate(0)}to{transform:rotate(359deg)}}@keyframes fade-data-v-3ea817b2{from{opacity:1}to{opacity:0}}.or-code .fullscreen-button[data-v-3ea817b2]{width:2.25rem;height:2.25rem}.or-code .fullscreen-button>.or-icon[data-v-3ea817b2]{font-size:1.5rem}.or-code .footer .or-code-error[data-v-3ea817b2],.or-code .footer .or-code-hint[data-v-3ea817b2]{flex-shrink:1;transition-timing-function:var(--t-func);transition-duration:var(--t-duration);transition-property:height,opacity}.header[data-v-3ea817b2]{display:flex;flex-direction:row;align-items:center;height:36px}.header .actions[data-v-3ea817b2]{margin-left:auto}.header .actions[data-v-3ea817b2]:not(.is-visible){display:none}.or-code-editor[data-v-3ea817b2]{min-height:calc(1.4em + 8px);overflow:auto;font-size:var(--fs-0);border:1px solid var(--c-neutral-2);border-radius:var(--s-2)}.or-code-editor.is-invalid[data-v-3ea817b2]{border-color:var(--c-error)}.or-code-editor[data-v-3ea817b2]> *{width:100%;height:100%}.or-code[data-v-3ea817b2],.or-modal[data-v-3ea817b2]  .content{display:flex;flex-direction:column}.or-code .or-code-editor[data-v-3ea817b2],.or-modal[data-v-3ea817b2]  .content .or-code-editor{text-align:left!important}.or-code .or-code-editor[data-v-3ea817b2],.or-modal[data-v-3ea817b2]  .content .or-code-editor{flex-grow:1}";
+styleInject(css_248z);
+
+/* script */
+const __vue_script__ = script;
+/* template */
+var __vue_render__ = function () {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _c('div', {
+    ref: "root",
+    staticClass: "or-code"
+  }, [_vm.isShowingHeader ? _c('div', {
+    staticClass: "header"
+  }, [_c('or-label', {
+    attrs: {
+      "label": _vm.label
+    },
+    scopedSlots: _vm._u([{
+      key: "append",
+      fn: function () {
+        return [_vm._t("label-append")];
+      },
+      proxy: true
+    }], null, true)
+  }, [_vm._t("label")], 2), _vm._v(" "), _c('div', {
+    staticClass: "actions",
+    class: {
+      'is-visible': _vm.isHovered
+    }
+  }, [_vm._t("actions", function () {
+    return [_vm.isShowingFullscreen ? _c('or-icon-button', {
+      staticClass: "fullscreen-button",
+      attrs: {
+        "icon": "fullscreen",
+        "icon-color": "neutral-4"
+      },
+      on: {
+        "click": function ($event) {
+          return _vm.toggleFullscreen(true);
+        }
+      }
+    }) : _vm._e()];
+  }, {
+    "toggleFullscreen": _vm.toggleFullscreen
+  })], 2)], 1) : _vm._e(), _vm._v(" "), _c('div', {
+    ref: "target",
+    staticClass: "or-code-editor",
+    class: {
+      'is-invalid': _vm.isInvalid
+    }
+  }), _vm._v(" "), _c('div', {
+    staticClass: "footer"
+  }, [_vm.isShowingError ? _c('or-error', {
+    staticClass: "or-code-error",
+    attrs: {
+      "error": _vm.error
+    }
+  }) : _vm._e(), _vm._v(" "), _vm.isShowingHint ? _c('or-hint', {
+    staticClass: "or-code-hint",
+    attrs: {
+      "hint": _vm.hint
+    }
+  }) : _vm._e()], 1), _vm._v(" "), _c('or-teleport', [_c('or-modal', {
+    directives: [{
+      name: "show",
+      rawName: "v-show",
+      value: _vm.isFullscreen,
+      expression: "isFullscreen"
+    }],
+    attrs: {
+      "title-text": _vm.label,
+      "size": "fullScreen",
+      "is-open": "",
+      "trap-focus": false
+    },
+    on: {
+      "close": function ($event) {
+        return _vm.toggleFullscreen(false);
+      }
+    }
+  }, [_vm.$slots['modal-actions'] ? _c('div', {
+    staticClass: "header"
+  }, [_c('div', {
+    staticClass: "actions is-visible"
+  }, [_vm._t("modal-actions")], 2)]) : _vm._e(), _vm._v(" "), _c('div', {
+    ref: "fullscreenTarget",
+    staticClass: "or-code-editor",
+    class: {
+      'is-invalid': _vm.isInvalid
+    }
+  }), _vm._v(" "), _vm.isShowingError ? _c('or-error', {
+    staticClass: "or-code-error",
+    attrs: {
+      "error": _vm.error
+    }
+  }) : _vm._e()], 1)], 1)], 1);
+};
+var __vue_staticRenderFns__ = [];
+
+/* style */
+const __vue_inject_styles__ = undefined;
+/* scoped */
+const __vue_scope_id__ = "data-v-3ea817b2";
+/* module identifier */
+const __vue_module_identifier__ = undefined;
+/* functional template */
+const __vue_is_functional_template__ = false;
+/* style inject */
+
+/* style inject SSR */
+
+/* style inject shadow dom */
+
+const __vue_component__ = /*#__PURE__*/normalizeComponent({
+  render: __vue_render__,
+  staticRenderFns: __vue_staticRenderFns__
+}, __vue_inject_styles__, __vue_script__, __vue_scope_id__, __vue_is_functional_template__, __vue_module_identifier__, false, undefined, undefined, undefined);
+var __vue_component__$1 = __vue_component__;
+
+export { OrCodeLanguages as O, __vue_component__$1 as _ };