{"version":3,"sources":["webpack:///./node_modules/codemirror/addon/edit/closetag.js","webpack:///./node_modules/codemirror/addon/edit/closebrackets.js","webpack:///./node_modules/codemirror/addon/mode/simple.js","webpack:///./node_modules/codemirror/mode/css/css.js","webpack:///./node_modules/codemirror/addon/edit/matchtags.js","webpack:///./node_modules/codemirror-editor-vue3/dist/codemirror-editor-vue3.es.js","webpack:///./node_modules/codemirror/addon/fold/xml-fold.js","webpack:///./node_modules/codemirror/addon/merge/merge.js","webpack:///./node_modules/codemirror/mode/xml/xml.js","webpack:///./node_modules/codemirror/mode/htmlmixed/htmlmixed.js","webpack:///./node_modules/codemirror/mode/javascript/javascript.js"],"names":["mod","CodeMirror","defineOption","cm","val","old","Init","removeKeyMap","map","name","whenClosing","autoCloseSlash","whenOpening","autoCloseGT","addKeyMap","htmlDontClose","htmlIndent","getOption","Pass","ranges","listSelections","replacements","opt","i","length","empty","pos","head","tok","getTokenAt","inner","innerMode","getMode","state","tagInfo","mode","xmlCurrentTag","tagName","html","configuration","dontCloseTags","indentTags","end","ch","slice","lowerTagName","toLowerCase","type","test","string","charAt","close","indexOf","start","closingTagExists","xmlCurrentContext","emptyTags","text","newPos","Pos","line","indent","dontIndentOnAutoClose","info","replaceRange","anchor","sel","setSelections","indentLine","autoCloseCurrent","typingSlash","dontIndentOnSlash","replacement","mixed","context","top","getLine","replaceSelections","collection","elt","e","newTag","scanForClosingTag","Math","min","lastLine","nextClose","tag","onCx","to","next","commands","closeTag","defaults","pairs","closeBefore","triples","explode","conf","keyMap","closeBrackets","ensureBound","Backspace","handleBackspace","Enter","handleEnter","chars","key","handler","handleChar","getConfig","deflt","override","getModeAt","getCursor","around","charsAround","cur","operation","linesep","lineSeparator","replaceSelection","moveSel","dir","newRanges","primary","range","push","contractSelection","inverted","cmpPos","identical","opening","curType","getRange","getTokenTypeAt","prev","isWordChar","stringStartsAfter","left","right","sels","getSelections","triggerElectric","str","token","ensureState","states","hasOwnProperty","Error","toRegex","caret","flags","RegExp","ignoreCase","unicode","source","String","asToken","apply","replace","result","Rule","data","this","regex","tokenFunction","config","stream","pending","pend","shift","local","match","endToken","localState","m","endScan","exec","current","index","curState","rule","matches","sol","stack","pop","enterLocalMode","indentation","indentUnit","dedent","j","backUp","join","cmp","a","b","props","prop","spec","pers","persistent","p","persistentStates","lState","startState","forceEnd","arr","indentFunction","meta","textAfter","dontIndentStates","rules","scan","dedentIfLineStart","defineSimpleMode","defineMode","simpleMode","states_","hasIndentation","list","orig","copyState","s","keySet","array","keys","parserConfig","inline","propertyKeywords","resolveMode","tokenHooks","documentTypes","mediaTypes","mediaFeatures","mediaValueKeywords","nonStandardPropertyKeywords","fontProperties","counterDescriptors","colorKeywords","valueKeywords","allowNested","lineComment","supportsAtComponent","highlightNonStandardPropertyKeywords","ret","style","tp","tokenBase","eatWhile","eat","tokenize","tokenString","tokenParenthesized","peek","quote","escaped","Context","pushContext","popContext","pass","popAndPass","n","wordAsValue","word","stateArg","_stream","atBlock","base","eatSpace","cx","max","electricChars","blockCommentStart","blockCommentEnd","blockCommentContinue","fold","documentTypes_","mediaTypes_","mediaFeatures_","mediaValueKeywords_","propertyKeywords_","nonStandardPropertyKeywords_","fontProperties_","counterDescriptors_","colorKeywords_","valueKeywords_","allWords","concat","tokenCComment","maybeEnd","registerHelper","defineMIME","skipToEnd","helperType","clear","tagHit","tagOther","doMatchTags","failedTagMatch","somethingSelected","getViewport","from","findMatchingTag","matchBothTags","hit","at","open","markText","className","other","maybeUpdateMatch","off","bothTags","on","toMatchingTag","found","extendSelection","__defProp","Object","defineProperty","__defProps","defineProperties","__getOwnPropDescs","getOwnPropertyDescriptors","__getOwnPropSymbols","getOwnPropertySymbols","__hasOwnProp","prototype","__propIsEnum","propertyIsEnumerable","__defNormalProp","obj","value","enumerable","configurable","writable","__spreadValues","call","__spreadProps","window","CodeMirror$1","_export_sfc","sfc","target","__vccOpts","_sfc_main$3","default","Date","content","options","cminstance","placeholder","emits","ready","instance","emit","textarea","_cminstance","initialize","fromTextArea","unwatch","_a","setValue","deep","_hoisted_1$2","_sfc_render$2","_ctx","_cache","$props","$setup","$data","$options","ref","Default","diff_match_patch","DIFF_DELETE","DIFF_INSERT","DIFF_EQUAL","_sfc_main$2","mergeView","MergeView","_hoisted_1$1","_sfc_render$1","logErrorType","Merge","getLinkMarks","linkRegexp","indexObj","node","document","createElement","attrs","JSON","parse","keyAndValues","entries","_key","_value","setAttribute","innerHTML","getLogMark","logRegexp","textArr","split","contentArr","offset","textItem","contentItem","cloneNode","innerText","logErrorType2","startRegex","error","warning","_sfc_main$1","renderTextMark","marks","getAllMarks","forEach","mark","getValue","linkMarks","_i","posFromIndex","replacedWith","immediate","_hoisted_1","_sfc_render","FcLog","componentEventMap","change","input","cmEvts","getCmEvts","args","emitOptions","DEFAULT_OPTIONS","theme","lineNumbers","smartIndent","scrollToEnd","Promise","resolve","then","nowScrollInfo","getScrollInfo","scrollTo","height","useEvents","internalInstance","realCm","merge","editor","getBindEvents","evts","vnode","v","startsWith","listenerEvents","currentVal","keepCursorInEnd","tmpEvents","bindEvts","filter","event","useViewControl","presetRef","containerWidth","containerHeight","refresh","resize","width","cmHeight","setSize","destroy","element","getWrapperElement","remove","reload","_b","_c","history","getDoc","getHistory","setHistory","isStyleChaotic","gutterEl","querySelector","gutterElLeft","reviseStyle","timer","setInterval","clearInterval","clearTimer","setTimeout","clearTimeout","_sfc_main","globalOptions","border","Boolean","Number","originalStyle","marker","Function","unseenLines","Array","__props","expose","assign","varArgs","TypeError","index2","arguments","nextSource","nextKey","presetModeName","cmOptions","instanceName","parent","realCminstance","_a2","unseenLineMarkers","_b2","lineInfo","setGutterMarker","gutterMarkers","onCodeChange","newVal","CM_VALUE","handlePresetModeName","setOption","class","bordered","ref_key","$event","$attrs","onReady","styleInject","css","insertAt","getElementsByTagName","firstChild","insertBefore","appendChild","styleSheet","cssText","createTextNode","nameStartChar","nameChar","xmlTagStart","Iter","firstLine","tagAt","iter","nextLine","prevLine","toTagEnd","gt","lastSlash","lastIndexOf","selfClose","toTagStart","lt","lastIndex","toNextTag","toPrevTag","findMatchingClose","startLine","startCh","findMatchingOpen","endLine","endCh","openTag","startPos","endPos","here","findEnclosingTag","forward","svgNS","DiffView","mv","classes","chunk","insert","del","connect","ensureDiff","dv","diffOutOfDate","diff","getDiff","edit","ignoreWhitespace","chunks","getChunks","signal","constructor","init","pane","diffViews","copyObj","readOnly","allowEditingOriginals","trackAlignable","TrackAlignable","lockButton","title","phrase","classLocation","chunkClassLocation","toString","asString","dealigned","needsScrollSync","showDifferences","registerEvents","otherDv","forceUpdate","registerUpdate","setScrollLock","registerScroll","setShowDifferences","updating","debounceChange","marked","updatingFast","update","svg","copyButtons","clearMarks","updateMarks","alignChunks","makeConnections","syncScroll","setDealign","fast","set","_cm","swapDoc","toOrig","lockScroll","now","scrollSetBy","scrollSetAt","sInfo","targetPos","botDist","mix","halfScreen","clientHeight","midY","mid","lineAtHeight","chunkBoundariesAround","getOffsets","offOther","ratio","bot","otherInfo","botDistOther","after","heightAtLine","before","action","addClass","rmClass","removeClass","locs","removeLineClass","TextMarker","vp","markChanges","lineNr","main","getLineHandle","addLineClass","clipPos","cls","markChunk","bfrom","bto","chunkStart","part","cleanFrom","startOfLineClean","moveOver","cleanTo","endOfLineClean","posMax","posMin","posEq","w","gap","offsetWidth","offsetHeight","vpEdit","vpOrig","outerTop","wrap","getBoundingClientRect","sTopEdit","getScrollerElement","sTopOrig","editFrom","editTo","origFrom","origTo","drawConnectorsForChunk","getMatchingOrigLine","editLine","editStart","origStart","alignableFor","isOrig","tracker","trackI","alignable","mergeAlignable","origAlignable","setIndex","rI","origI","chunkI","outer","nextR","nextO","rLine","oLine","record","splice","findAlignedLines","force","curOp","linesToAlign","aligners","scroll","alignLines","ln","cmOffset","lines","maxOffset","padAbove","size","above","minWidth","addLineWidget","mergeSpacer","handleMouseEvents","flip","topLpx","topRpx","tmp","botLpx","botRpx","curveTop","curveBot","createElementNS","copy","editOriginals","topReverse","copyReverse","copyChunk","origEnd","editEnd","revertChunk","dmp","origLeft","origRight","hasLeft","hasRight","panes","self","leftPane","buildGap","editPane","rightPane","wrapElt","collapseIdentical","collapseIdenticalStretches","onResize","resizeInterval","parentNode","body","lock","lockWrap","gapElts","revertButtons","srcElement","unshift","createSVGRect","diff_main","startEdit","startOrig","startOff","cleanFromEdit","cleanFromOrig","endOff","cleanToEdit","cleanToOrig","charCodeAt","last","nInEdit","beforeE","afterE","beforeO","afterO","fromLocal","toLocal","collapseSingle","widget","inclusiveLeft","inclusiveRight","clearOnEnter","explicitlyCleared","collapseStretch","editors","unclearNearChunks","margin","l","onCollapse","count","childNodes","removeChild","out","nl","rightOriginal","leftOriginal","rightChunks","leftChunks","F_WIDGET","F_WIDGET_BELOW","F_MARKER","doc","_","collapsed","find","_min","check","hasMarker","bind","lineNo","hasWidgetBelow","hasWidget","nBefore","nAfter","findPrevDiff","findNextDiff","goNearbyDiff","views","setCursor","flag","pred","handle","markedSpans","widgets","widgetFrom","widgetTo","goNextDiff","goPrevDiff","htmlConfig","autoSelfClosers","implicitlyClosed","contextGrabbers","doNotIndent","allowUnquoted","allowMissing","caseFold","xmlConfig","allowMissingTagName","editorConf","config_","setStyle","htmlMode","inText","chain","parser","ok","inBlock","doctype","inTag","baseState","tagStart","inAttribute","stringStartCol","column","closure","eol","isInAttribute","terminator","depth","lower","startOfLine","indented","noIndent","maybePopContext","nextTagName","parentTagName","tagNameState","closeTagNameState","attrState","matchClosing","closeState","closeStateErr","attrEqState","attrValueState","attrContinuedState","isInText","baseIndent","fullLine","multilineTagIndentPastTag","multilineTagIndentFactor","alignCDATA","tagAfter","grabbers","electricInput","skipAttribute","reverse","mimeModes","defaultTags","script","maybeBackup","pat","search","attrRegexpCache","getAttrRegexp","attr","regexp","getAttrValue","getTagRegexp","anchored","addTags","dest","findMatchingMode","tagText","tags","configTags","configScript","scriptTypes","htmlState","modeSpec","endTagA","endTag","localMode","statementIndent","jsonldMode","jsonld","jsonMode","json","trackScope","isTS","typescript","wordRE","wordCharacters","keywords","kw","A","B","C","D","operator","atom","isOperatorChar","isJsonldKeyword","readRegexp","inSet","cont","tokenComment","expressionAllowed","tokenQuasi","lexical","lastType","brackets","findFatArrow","fatArrowAt","arrow","sawSomething","bracket","atomicTypes","JSLexical","align","inScope","varname","localVars","vars","parseJS","cc","combinator","expression","statement","lex","inList","register","block","newContext","registerVarScoped","Var","globalVars","isModifier","defaultVars","pushcontext","pushblockcontext","popcontext","pushlex","poplex","expect","wanted","exp","vardef","parenExpr","maybeexpression","maybeelse","functiondef","forspec","enumdef","typename","typeexpr","pattern","maybelabel","maybeCatchBinding","afterExport","afterImport","funarg","expressionInner","expressionNoComma","noComma","arrowBodyNoComma","arrowBody","commasep","maybeop","maybeoperatorNoComma","maybeoperatorComma","classExpression","arrayLiteral","contCommasep","objprop","quasi","maybeTarget","me","expr","property","continueQuasi","targetNoComma","maybeTypeArgs","getterSetter","afterprop","maybetype","what","sep","proceed","maybetypeOrIn","mayberettype","isKW","afterType","typeprops","typearg","maybeReturnType","quasiType","typeprop","functiondecl","continueQuasiType","typeparam","maybeTypeDefault","maybeAssign","vardefCont","eltpattern","proppattern","_type","forspec1","forspec2","classNameAfter","classBody","classfield","isInterface","maybeFrom","exportField","importSpec","maybeMoreImports","maybeAs","enummember","isContinuedStatement","basecolumn","firstChar","c","closing","doubleIndentSwitch","skipExpression","StringStream"],"mappings":"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","file":"js/group-admin-mailing-page~c490252f.c54e5f85.js","sourcesContent":["// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n/**\n * Tag-closer extension for CodeMirror.\n *\n * This extension adds an \"autoCloseTags\" option that can be set to\n * either true to get the default behavior, or an object to further\n * configure its behavior.\n *\n * These are supported options:\n *\n * `whenClosing` (default true)\n *   Whether to autoclose when the '/' of a closing tag is typed.\n * `whenOpening` (default true)\n *   Whether to autoclose the tag when the final '>' of an opening\n *   tag is typed.\n * `dontCloseTags` (default is empty tags for HTML, none for XML)\n *   An array of tag names that should not be autoclosed.\n * `indentTags` (default is block tags for HTML, none for XML)\n *   An array of tag names that should, when opened, cause a\n *   blank line to be added inside the tag, and the blank line and\n *   closing line to be indented.\n * `emptyTags` (default is none)\n *   An array of XML tag names that should be autoclosed with '/>'.\n *\n * See demos/closetag.html for a usage example.\n */\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"), require(\"../fold/xml-fold\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\", \"../fold/xml-fold\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n  CodeMirror.defineOption(\"autoCloseTags\", false, function(cm, val, old) {\n    if (old != CodeMirror.Init && old)\n      cm.removeKeyMap(\"autoCloseTags\");\n    if (!val) return;\n    var map = {name: \"autoCloseTags\"};\n    if (typeof val != \"object\" || val.whenClosing !== false)\n      map[\"'/'\"] = function(cm) { return autoCloseSlash(cm); };\n    if (typeof val != \"object\" || val.whenOpening !== false)\n      map[\"'>'\"] = function(cm) { return autoCloseGT(cm); };\n    cm.addKeyMap(map);\n  });\n\n  var htmlDontClose = [\"area\", \"base\", \"br\", \"col\", \"command\", \"embed\", \"hr\", \"img\", \"input\", \"keygen\", \"link\", \"meta\", \"param\",\n                       \"source\", \"track\", \"wbr\"];\n  var htmlIndent = [\"applet\", \"blockquote\", \"body\", \"button\", \"div\", \"dl\", \"fieldset\", \"form\", \"frameset\", \"h1\", \"h2\", \"h3\", \"h4\",\n                    \"h5\", \"h6\", \"head\", \"html\", \"iframe\", \"layer\", \"legend\", \"object\", \"ol\", \"p\", \"select\", \"table\", \"ul\"];\n\n  function autoCloseGT(cm) {\n    if (cm.getOption(\"disableInput\")) return CodeMirror.Pass;\n    var ranges = cm.listSelections(), replacements = [];\n    var opt = cm.getOption(\"autoCloseTags\");\n    for (var i = 0; i < ranges.length; i++) {\n      if (!ranges[i].empty()) return CodeMirror.Pass;\n      var pos = ranges[i].head, tok = cm.getTokenAt(pos);\n      var inner = CodeMirror.innerMode(cm.getMode(), tok.state), state = inner.state;\n      var tagInfo = inner.mode.xmlCurrentTag && inner.mode.xmlCurrentTag(state)\n      var tagName = tagInfo && tagInfo.name\n      if (!tagName) return CodeMirror.Pass\n\n      var html = inner.mode.configuration == \"html\";\n      var dontCloseTags = (typeof opt == \"object\" && opt.dontCloseTags) || (html && htmlDontClose);\n      var indentTags = (typeof opt == \"object\" && opt.indentTags) || (html && htmlIndent);\n\n      if (tok.end > pos.ch) tagName = tagName.slice(0, tagName.length - tok.end + pos.ch);\n      var lowerTagName = tagName.toLowerCase();\n      // Don't process the '>' at the end of an end-tag or self-closing tag\n      if (!tagName ||\n          tok.type == \"string\" && (tok.end != pos.ch || !/[\\\"\\']/.test(tok.string.charAt(tok.string.length - 1)) || tok.string.length == 1) ||\n          tok.type == \"tag\" && tagInfo.close ||\n          tok.string.indexOf(\"/\") == (pos.ch - tok.start - 1) || // match something like <someTagName />\n          dontCloseTags && indexOf(dontCloseTags, lowerTagName) > -1 ||\n          closingTagExists(cm, inner.mode.xmlCurrentContext && inner.mode.xmlCurrentContext(state) || [], tagName, pos, true))\n        return CodeMirror.Pass;\n\n      var emptyTags = typeof opt == \"object\" && opt.emptyTags;\n      if (emptyTags && indexOf(emptyTags, tagName) > -1) {\n        replacements[i] = { text: \"/>\", newPos: CodeMirror.Pos(pos.line, pos.ch + 2) };\n        continue;\n      }\n\n      var indent = indentTags && indexOf(indentTags, lowerTagName) > -1;\n      replacements[i] = {indent: indent,\n                         text: \">\" + (indent ? \"\\n\\n\" : \"\") + \"</\" + tagName + \">\",\n                         newPos: indent ? CodeMirror.Pos(pos.line + 1, 0) : CodeMirror.Pos(pos.line, pos.ch + 1)};\n    }\n\n    var dontIndentOnAutoClose = (typeof opt == \"object\" && opt.dontIndentOnAutoClose);\n    for (var i = ranges.length - 1; i >= 0; i--) {\n      var info = replacements[i];\n      cm.replaceRange(info.text, ranges[i].head, ranges[i].anchor, \"+insert\");\n      var sel = cm.listSelections().slice(0);\n      sel[i] = {head: info.newPos, anchor: info.newPos};\n      cm.setSelections(sel);\n      if (!dontIndentOnAutoClose && info.indent) {\n        cm.indentLine(info.newPos.line, null, true);\n        cm.indentLine(info.newPos.line + 1, null, true);\n      }\n    }\n  }\n\n  function autoCloseCurrent(cm, typingSlash) {\n    var ranges = cm.listSelections(), replacements = [];\n    var head = typingSlash ? \"/\" : \"</\";\n    var opt = cm.getOption(\"autoCloseTags\");\n    var dontIndentOnAutoClose = (typeof opt == \"object\" && opt.dontIndentOnSlash);\n    for (var i = 0; i < ranges.length; i++) {\n      if (!ranges[i].empty()) return CodeMirror.Pass;\n      var pos = ranges[i].head, tok = cm.getTokenAt(pos);\n      var inner = CodeMirror.innerMode(cm.getMode(), tok.state), state = inner.state;\n      if (typingSlash && (tok.type == \"string\" || tok.string.charAt(0) != \"<\" ||\n                          tok.start != pos.ch - 1))\n        return CodeMirror.Pass;\n      // Kludge to get around the fact that we are not in XML mode\n      // when completing in JS/CSS snippet in htmlmixed mode. Does not\n      // work for other XML embedded languages (there is no general\n      // way to go from a mixed mode to its current XML state).\n      var replacement, mixed = inner.mode.name != \"xml\" && cm.getMode().name == \"htmlmixed\"\n      if (mixed && inner.mode.name == \"javascript\") {\n        replacement = head + \"script\";\n      } else if (mixed && inner.mode.name == \"css\") {\n        replacement = head + \"style\";\n      } else {\n        var context = inner.mode.xmlCurrentContext && inner.mode.xmlCurrentContext(state)\n        var top = context.length ? context[context.length - 1] : \"\"\n        if (!context || (context.length && closingTagExists(cm, context, top, pos)))\n          return CodeMirror.Pass;\n        replacement = head + top\n      }\n      if (cm.getLine(pos.line).charAt(tok.end) != \">\") replacement += \">\";\n      replacements[i] = replacement;\n    }\n    cm.replaceSelections(replacements);\n    ranges = cm.listSelections();\n    if (!dontIndentOnAutoClose) {\n        for (var i = 0; i < ranges.length; i++)\n            if (i == ranges.length - 1 || ranges[i].head.line < ranges[i + 1].head.line)\n                cm.indentLine(ranges[i].head.line);\n    }\n  }\n\n  function autoCloseSlash(cm) {\n    if (cm.getOption(\"disableInput\")) return CodeMirror.Pass;\n    return autoCloseCurrent(cm, true);\n  }\n\n  CodeMirror.commands.closeTag = function(cm) { return autoCloseCurrent(cm); };\n\n  function indexOf(collection, elt) {\n    if (collection.indexOf) return collection.indexOf(elt);\n    for (var i = 0, e = collection.length; i < e; ++i)\n      if (collection[i] == elt) return i;\n    return -1;\n  }\n\n  // If xml-fold is loaded, we use its functionality to try and verify\n  // whether a given tag is actually unclosed.\n  function closingTagExists(cm, context, tagName, pos, newTag) {\n    if (!CodeMirror.scanForClosingTag) return false;\n    var end = Math.min(cm.lastLine() + 1, pos.line + 500);\n    var nextClose = CodeMirror.scanForClosingTag(cm, pos, null, end);\n    if (!nextClose || nextClose.tag != tagName) return false;\n    // If the immediate wrapping context contains onCx instances of\n    // the same tag, a closing tag only exists if there are at least\n    // that many closing tags of that type following.\n    var onCx = newTag ? 1 : 0\n    for (var i = context.length - 1; i >= 0; i--) {\n      if (context[i] == tagName) ++onCx\n      else break\n    }\n    pos = nextClose.to;\n    for (var i = 1; i < onCx; i++) {\n      var next = CodeMirror.scanForClosingTag(cm, pos, null, end);\n      if (!next || next.tag != tagName) return false;\n      pos = next.to;\n    }\n    return true;\n  }\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n  var defaults = {\n    pairs: \"()[]{}''\\\"\\\"\",\n    closeBefore: \")]}'\\\":;>\",\n    triples: \"\",\n    explode: \"[]{}\"\n  };\n\n  var Pos = CodeMirror.Pos;\n\n  CodeMirror.defineOption(\"autoCloseBrackets\", false, function(cm, val, old) {\n    if (old && old != CodeMirror.Init) {\n      cm.removeKeyMap(keyMap);\n      cm.state.closeBrackets = null;\n    }\n    if (val) {\n      ensureBound(getOption(val, \"pairs\"))\n      cm.state.closeBrackets = val;\n      cm.addKeyMap(keyMap);\n    }\n  });\n\n  function getOption(conf, name) {\n    if (name == \"pairs\" && typeof conf == \"string\") return conf;\n    if (typeof conf == \"object\" && conf[name] != null) return conf[name];\n    return defaults[name];\n  }\n\n  var keyMap = {Backspace: handleBackspace, Enter: handleEnter};\n  function ensureBound(chars) {\n    for (var i = 0; i < chars.length; i++) {\n      var ch = chars.charAt(i), key = \"'\" + ch + \"'\"\n      if (!keyMap[key]) keyMap[key] = handler(ch)\n    }\n  }\n  ensureBound(defaults.pairs + \"`\")\n\n  function handler(ch) {\n    return function(cm) { return handleChar(cm, ch); };\n  }\n\n  function getConfig(cm) {\n    var deflt = cm.state.closeBrackets;\n    if (!deflt || deflt.override) return deflt;\n    var mode = cm.getModeAt(cm.getCursor());\n    return mode.closeBrackets || deflt;\n  }\n\n  function handleBackspace(cm) {\n    var conf = getConfig(cm);\n    if (!conf || cm.getOption(\"disableInput\")) return CodeMirror.Pass;\n\n    var pairs = getOption(conf, \"pairs\");\n    var ranges = cm.listSelections();\n    for (var i = 0; i < ranges.length; i++) {\n      if (!ranges[i].empty()) return CodeMirror.Pass;\n      var around = charsAround(cm, ranges[i].head);\n      if (!around || pairs.indexOf(around) % 2 != 0) return CodeMirror.Pass;\n    }\n    for (var i = ranges.length - 1; i >= 0; i--) {\n      var cur = ranges[i].head;\n      cm.replaceRange(\"\", Pos(cur.line, cur.ch - 1), Pos(cur.line, cur.ch + 1), \"+delete\");\n    }\n  }\n\n  function handleEnter(cm) {\n    var conf = getConfig(cm);\n    var explode = conf && getOption(conf, \"explode\");\n    if (!explode || cm.getOption(\"disableInput\")) return CodeMirror.Pass;\n\n    var ranges = cm.listSelections();\n    for (var i = 0; i < ranges.length; i++) {\n      if (!ranges[i].empty()) return CodeMirror.Pass;\n      var around = charsAround(cm, ranges[i].head);\n      if (!around || explode.indexOf(around) % 2 != 0) return CodeMirror.Pass;\n    }\n    cm.operation(function() {\n      var linesep = cm.lineSeparator() || \"\\n\";\n      cm.replaceSelection(linesep + linesep, null);\n      moveSel(cm, -1)\n      ranges = cm.listSelections();\n      for (var i = 0; i < ranges.length; i++) {\n        var line = ranges[i].head.line;\n        cm.indentLine(line, null, true);\n        cm.indentLine(line + 1, null, true);\n      }\n    });\n  }\n\n  function moveSel(cm, dir) {\n    var newRanges = [], ranges = cm.listSelections(), primary = 0\n    for (var i = 0; i < ranges.length; i++) {\n      var range = ranges[i]\n      if (range.head == cm.getCursor()) primary = i\n      var pos = range.head.ch || dir > 0 ? {line: range.head.line, ch: range.head.ch + dir} : {line: range.head.line - 1}\n      newRanges.push({anchor: pos, head: pos})\n    }\n    cm.setSelections(newRanges, primary)\n  }\n\n  function contractSelection(sel) {\n    var inverted = CodeMirror.cmpPos(sel.anchor, sel.head) > 0;\n    return {anchor: new Pos(sel.anchor.line, sel.anchor.ch + (inverted ? -1 : 1)),\n            head: new Pos(sel.head.line, sel.head.ch + (inverted ? 1 : -1))};\n  }\n\n  function handleChar(cm, ch) {\n    var conf = getConfig(cm);\n    if (!conf || cm.getOption(\"disableInput\")) return CodeMirror.Pass;\n\n    var pairs = getOption(conf, \"pairs\");\n    var pos = pairs.indexOf(ch);\n    if (pos == -1) return CodeMirror.Pass;\n\n    var closeBefore = getOption(conf,\"closeBefore\");\n\n    var triples = getOption(conf, \"triples\");\n\n    var identical = pairs.charAt(pos + 1) == ch;\n    var ranges = cm.listSelections();\n    var opening = pos % 2 == 0;\n\n    var type;\n    for (var i = 0; i < ranges.length; i++) {\n      var range = ranges[i], cur = range.head, curType;\n      var next = cm.getRange(cur, Pos(cur.line, cur.ch + 1));\n      if (opening && !range.empty()) {\n        curType = \"surround\";\n      } else if ((identical || !opening) && next == ch) {\n        if (identical && stringStartsAfter(cm, cur))\n          curType = \"both\";\n        else if (triples.indexOf(ch) >= 0 && cm.getRange(cur, Pos(cur.line, cur.ch + 3)) == ch + ch + ch)\n          curType = \"skipThree\";\n        else\n          curType = \"skip\";\n      } else if (identical && cur.ch > 1 && triples.indexOf(ch) >= 0 &&\n                 cm.getRange(Pos(cur.line, cur.ch - 2), cur) == ch + ch) {\n        if (cur.ch > 2 && /\\bstring/.test(cm.getTokenTypeAt(Pos(cur.line, cur.ch - 2)))) return CodeMirror.Pass;\n        curType = \"addFour\";\n      } else if (identical) {\n        var prev = cur.ch == 0 ? \" \" : cm.getRange(Pos(cur.line, cur.ch - 1), cur)\n        if (!CodeMirror.isWordChar(next) && prev != ch && !CodeMirror.isWordChar(prev)) curType = \"both\";\n        else return CodeMirror.Pass;\n      } else if (opening && (next.length === 0 || /\\s/.test(next) || closeBefore.indexOf(next) > -1)) {\n        curType = \"both\";\n      } else {\n        return CodeMirror.Pass;\n      }\n      if (!type) type = curType;\n      else if (type != curType) return CodeMirror.Pass;\n    }\n\n    var left = pos % 2 ? pairs.charAt(pos - 1) : ch;\n    var right = pos % 2 ? ch : pairs.charAt(pos + 1);\n    cm.operation(function() {\n      if (type == \"skip\") {\n        moveSel(cm, 1)\n      } else if (type == \"skipThree\") {\n        moveSel(cm, 3)\n      } else if (type == \"surround\") {\n        var sels = cm.getSelections();\n        for (var i = 0; i < sels.length; i++)\n          sels[i] = left + sels[i] + right;\n        cm.replaceSelections(sels, \"around\");\n        sels = cm.listSelections().slice();\n        for (var i = 0; i < sels.length; i++)\n          sels[i] = contractSelection(sels[i]);\n        cm.setSelections(sels);\n      } else if (type == \"both\") {\n        cm.replaceSelection(left + right, null);\n        cm.triggerElectric(left + right);\n        moveSel(cm, -1)\n      } else if (type == \"addFour\") {\n        cm.replaceSelection(left + left + left + left, \"before\");\n        moveSel(cm, 1)\n      }\n    });\n  }\n\n  function charsAround(cm, pos) {\n    var str = cm.getRange(Pos(pos.line, pos.ch - 1),\n                          Pos(pos.line, pos.ch + 1));\n    return str.length == 2 ? str : null;\n  }\n\n  function stringStartsAfter(cm, pos) {\n    var token = cm.getTokenAt(Pos(pos.line, pos.ch + 1))\n    return /\\bstring/.test(token.type) && token.start == pos.ch &&\n      (pos.ch == 0 || !/\\bstring/.test(cm.getTokenTypeAt(pos)))\n  }\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n  \"use strict\";\n\n  CodeMirror.defineSimpleMode = function(name, states) {\n    CodeMirror.defineMode(name, function(config) {\n      return CodeMirror.simpleMode(config, states);\n    });\n  };\n\n  CodeMirror.simpleMode = function(config, states) {\n    ensureState(states, \"start\");\n    var states_ = {}, meta = states.meta || {}, hasIndentation = false;\n    for (var state in states) if (state != meta && states.hasOwnProperty(state)) {\n      var list = states_[state] = [], orig = states[state];\n      for (var i = 0; i < orig.length; i++) {\n        var data = orig[i];\n        list.push(new Rule(data, states));\n        if (data.indent || data.dedent) hasIndentation = true;\n      }\n    }\n    var mode = {\n      startState: function() {\n        return {state: \"start\", pending: null,\n                local: null, localState: null,\n                indent: hasIndentation ? [] : null};\n      },\n      copyState: function(state) {\n        var s = {state: state.state, pending: state.pending,\n                 local: state.local, localState: null,\n                 indent: state.indent && state.indent.slice(0)};\n        if (state.localState)\n          s.localState = CodeMirror.copyState(state.local.mode, state.localState);\n        if (state.stack)\n          s.stack = state.stack.slice(0);\n        for (var pers = state.persistentStates; pers; pers = pers.next)\n          s.persistentStates = {mode: pers.mode,\n                                spec: pers.spec,\n                                state: pers.state == state.localState ? s.localState : CodeMirror.copyState(pers.mode, pers.state),\n                                next: s.persistentStates};\n        return s;\n      },\n      token: tokenFunction(states_, config),\n      innerMode: function(state) { return state.local && {mode: state.local.mode, state: state.localState}; },\n      indent: indentFunction(states_, meta)\n    };\n    if (meta) for (var prop in meta) if (meta.hasOwnProperty(prop))\n      mode[prop] = meta[prop];\n    return mode;\n  };\n\n  function ensureState(states, name) {\n    if (!states.hasOwnProperty(name))\n      throw new Error(\"Undefined state \" + name + \" in simple mode\");\n  }\n\n  function toRegex(val, caret) {\n    if (!val) return /(?:)/;\n    var flags = \"\";\n    if (val instanceof RegExp) {\n      if (val.ignoreCase) flags = \"i\";\n      if (val.unicode) flags += \"u\"\n      val = val.source;\n    } else {\n      val = String(val);\n    }\n    return new RegExp((caret === false ? \"\" : \"^\") + \"(?:\" + val + \")\", flags);\n  }\n\n  function asToken(val) {\n    if (!val) return null;\n    if (val.apply) return val\n    if (typeof val == \"string\") return val.replace(/\\./g, \" \");\n    var result = [];\n    for (var i = 0; i < val.length; i++)\n      result.push(val[i] && val[i].replace(/\\./g, \" \"));\n    return result;\n  }\n\n  function Rule(data, states) {\n    if (data.next || data.push) ensureState(states, data.next || data.push);\n    this.regex = toRegex(data.regex);\n    this.token = asToken(data.token);\n    this.data = data;\n  }\n\n  function tokenFunction(states, config) {\n    return function(stream, state) {\n      if (state.pending) {\n        var pend = state.pending.shift();\n        if (state.pending.length == 0) state.pending = null;\n        stream.pos += pend.text.length;\n        return pend.token;\n      }\n\n      if (state.local) {\n        if (state.local.end && stream.match(state.local.end)) {\n          var tok = state.local.endToken || null;\n          state.local = state.localState = null;\n          return tok;\n        } else {\n          var tok = state.local.mode.token(stream, state.localState), m;\n          if (state.local.endScan && (m = state.local.endScan.exec(stream.current())))\n            stream.pos = stream.start + m.index;\n          return tok;\n        }\n      }\n\n      var curState = states[state.state];\n      for (var i = 0; i < curState.length; i++) {\n        var rule = curState[i];\n        var matches = (!rule.data.sol || stream.sol()) && stream.match(rule.regex);\n        if (matches) {\n          if (rule.data.next) {\n            state.state = rule.data.next;\n          } else if (rule.data.push) {\n            (state.stack || (state.stack = [])).push(state.state);\n            state.state = rule.data.push;\n          } else if (rule.data.pop && state.stack && state.stack.length) {\n            state.state = state.stack.pop();\n          }\n\n          if (rule.data.mode)\n            enterLocalMode(config, state, rule.data.mode, rule.token);\n          if (rule.data.indent)\n            state.indent.push(stream.indentation() + config.indentUnit);\n          if (rule.data.dedent)\n            state.indent.pop();\n          var token = rule.token\n          if (token && token.apply) token = token(matches)\n          if (matches.length > 2 && rule.token && typeof rule.token != \"string\") {\n            for (var j = 2; j < matches.length; j++)\n              if (matches[j])\n                (state.pending || (state.pending = [])).push({text: matches[j], token: rule.token[j - 1]});\n            stream.backUp(matches[0].length - (matches[1] ? matches[1].length : 0));\n            return token[0];\n          } else if (token && token.join) {\n            return token[0];\n          } else {\n            return token;\n          }\n        }\n      }\n      stream.next();\n      return null;\n    };\n  }\n\n  function cmp(a, b) {\n    if (a === b) return true;\n    if (!a || typeof a != \"object\" || !b || typeof b != \"object\") return false;\n    var props = 0;\n    for (var prop in a) if (a.hasOwnProperty(prop)) {\n      if (!b.hasOwnProperty(prop) || !cmp(a[prop], b[prop])) return false;\n      props++;\n    }\n    for (var prop in b) if (b.hasOwnProperty(prop)) props--;\n    return props == 0;\n  }\n\n  function enterLocalMode(config, state, spec, token) {\n    var pers;\n    if (spec.persistent) for (var p = state.persistentStates; p && !pers; p = p.next)\n      if (spec.spec ? cmp(spec.spec, p.spec) : spec.mode == p.mode) pers = p;\n    var mode = pers ? pers.mode : spec.mode || CodeMirror.getMode(config, spec.spec);\n    var lState = pers ? pers.state : CodeMirror.startState(mode);\n    if (spec.persistent && !pers)\n      state.persistentStates = {mode: mode, spec: spec.spec, state: lState, next: state.persistentStates};\n\n    state.localState = lState;\n    state.local = {mode: mode,\n                   end: spec.end && toRegex(spec.end),\n                   endScan: spec.end && spec.forceEnd !== false && toRegex(spec.end, false),\n                   endToken: token && token.join ? token[token.length - 1] : token};\n  }\n\n  function indexOf(val, arr) {\n    for (var i = 0; i < arr.length; i++) if (arr[i] === val) return true;\n  }\n\n  function indentFunction(states, meta) {\n    return function(state, textAfter, line) {\n      if (state.local && state.local.mode.indent)\n        return state.local.mode.indent(state.localState, textAfter, line);\n      if (state.indent == null || state.local || meta.dontIndentStates && indexOf(state.state, meta.dontIndentStates) > -1)\n        return CodeMirror.Pass;\n\n      var pos = state.indent.length - 1, rules = states[state.state];\n      scan: for (;;) {\n        for (var i = 0; i < rules.length; i++) {\n          var rule = rules[i];\n          if (rule.data.dedent && rule.data.dedentIfLineStart !== false) {\n            var m = rule.regex.exec(textAfter);\n            if (m && m[0]) {\n              pos--;\n              if (rule.next || rule.push) rules = states[rule.next || rule.push];\n              textAfter = textAfter.slice(m[0].length);\n              continue scan;\n            }\n          }\n        }\n        break;\n      }\n      return pos < 0 ? 0 : state.indent[pos];\n    };\n  }\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n\"use strict\";\n\nCodeMirror.defineMode(\"css\", function(config, parserConfig) {\n  var inline = parserConfig.inline\n  if (!parserConfig.propertyKeywords) parserConfig = CodeMirror.resolveMode(\"text/css\");\n\n  var indentUnit = config.indentUnit,\n      tokenHooks = parserConfig.tokenHooks,\n      documentTypes = parserConfig.documentTypes || {},\n      mediaTypes = parserConfig.mediaTypes || {},\n      mediaFeatures = parserConfig.mediaFeatures || {},\n      mediaValueKeywords = parserConfig.mediaValueKeywords || {},\n      propertyKeywords = parserConfig.propertyKeywords || {},\n      nonStandardPropertyKeywords = parserConfig.nonStandardPropertyKeywords || {},\n      fontProperties = parserConfig.fontProperties || {},\n      counterDescriptors = parserConfig.counterDescriptors || {},\n      colorKeywords = parserConfig.colorKeywords || {},\n      valueKeywords = parserConfig.valueKeywords || {},\n      allowNested = parserConfig.allowNested,\n      lineComment = parserConfig.lineComment,\n      supportsAtComponent = parserConfig.supportsAtComponent === true,\n      highlightNonStandardPropertyKeywords = config.highlightNonStandardPropertyKeywords !== false;\n\n  var type, override;\n  function ret(style, tp) { type = tp; return style; }\n\n  // Tokenizers\n\n  function tokenBase(stream, state) {\n    var ch = stream.next();\n    if (tokenHooks[ch]) {\n      var result = tokenHooks[ch](stream, state);\n      if (result !== false) return result;\n    }\n    if (ch == \"@\") {\n      stream.eatWhile(/[\\w\\\\\\-]/);\n      return ret(\"def\", stream.current());\n    } else if (ch == \"=\" || (ch == \"~\" || ch == \"|\") && stream.eat(\"=\")) {\n      return ret(null, \"compare\");\n    } else if (ch == \"\\\"\" || ch == \"'\") {\n      state.tokenize = tokenString(ch);\n      return state.tokenize(stream, state);\n    } else if (ch == \"#\") {\n      stream.eatWhile(/[\\w\\\\\\-]/);\n      return ret(\"atom\", \"hash\");\n    } else if (ch == \"!\") {\n      stream.match(/^\\s*\\w*/);\n      return ret(\"keyword\", \"important\");\n    } else if (/\\d/.test(ch) || ch == \".\" && stream.eat(/\\d/)) {\n      stream.eatWhile(/[\\w.%]/);\n      return ret(\"number\", \"unit\");\n    } else if (ch === \"-\") {\n      if (/[\\d.]/.test(stream.peek())) {\n        stream.eatWhile(/[\\w.%]/);\n        return ret(\"number\", \"unit\");\n      } else if (stream.match(/^-[\\w\\\\\\-]*/)) {\n        stream.eatWhile(/[\\w\\\\\\-]/);\n        if (stream.match(/^\\s*:/, false))\n          return ret(\"variable-2\", \"variable-definition\");\n        return ret(\"variable-2\", \"variable\");\n      } else if (stream.match(/^\\w+-/)) {\n        return ret(\"meta\", \"meta\");\n      }\n    } else if (/[,+>*\\/]/.test(ch)) {\n      return ret(null, \"select-op\");\n    } else if (ch == \".\" && stream.match(/^-?[_a-z][_a-z0-9-]*/i)) {\n      return ret(\"qualifier\", \"qualifier\");\n    } else if (/[:;{}\\[\\]\\(\\)]/.test(ch)) {\n      return ret(null, ch);\n    } else if (stream.match(/^[\\w-.]+(?=\\()/)) {\n      if (/^(url(-prefix)?|domain|regexp)$/i.test(stream.current())) {\n        state.tokenize = tokenParenthesized;\n      }\n      return ret(\"variable callee\", \"variable\");\n    } else if (/[\\w\\\\\\-]/.test(ch)) {\n      stream.eatWhile(/[\\w\\\\\\-]/);\n      return ret(\"property\", \"word\");\n    } else {\n      return ret(null, null);\n    }\n  }\n\n  function tokenString(quote) {\n    return function(stream, state) {\n      var escaped = false, ch;\n      while ((ch = stream.next()) != null) {\n        if (ch == quote && !escaped) {\n          if (quote == \")\") stream.backUp(1);\n          break;\n        }\n        escaped = !escaped && ch == \"\\\\\";\n      }\n      if (ch == quote || !escaped && quote != \")\") state.tokenize = null;\n      return ret(\"string\", \"string\");\n    };\n  }\n\n  function tokenParenthesized(stream, state) {\n    stream.next(); // Must be '('\n    if (!stream.match(/^\\s*[\\\"\\')]/, false))\n      state.tokenize = tokenString(\")\");\n    else\n      state.tokenize = null;\n    return ret(null, \"(\");\n  }\n\n  // Context management\n\n  function Context(type, indent, prev) {\n    this.type = type;\n    this.indent = indent;\n    this.prev = prev;\n  }\n\n  function pushContext(state, stream, type, indent) {\n    state.context = new Context(type, stream.indentation() + (indent === false ? 0 : indentUnit), state.context);\n    return type;\n  }\n\n  function popContext(state) {\n    if (state.context.prev)\n      state.context = state.context.prev;\n    return state.context.type;\n  }\n\n  function pass(type, stream, state) {\n    return states[state.context.type](type, stream, state);\n  }\n  function popAndPass(type, stream, state, n) {\n    for (var i = n || 1; i > 0; i--)\n      state.context = state.context.prev;\n    return pass(type, stream, state);\n  }\n\n  // Parser\n\n  function wordAsValue(stream) {\n    var word = stream.current().toLowerCase();\n    if (valueKeywords.hasOwnProperty(word))\n      override = \"atom\";\n    else if (colorKeywords.hasOwnProperty(word))\n      override = \"keyword\";\n    else\n      override = \"variable\";\n  }\n\n  var states = {};\n\n  states.top = function(type, stream, state) {\n    if (type == \"{\") {\n      return pushContext(state, stream, \"block\");\n    } else if (type == \"}\" && state.context.prev) {\n      return popContext(state);\n    } else if (supportsAtComponent && /@component/i.test(type)) {\n      return pushContext(state, stream, \"atComponentBlock\");\n    } else if (/^@(-moz-)?document$/i.test(type)) {\n      return pushContext(state, stream, \"documentTypes\");\n    } else if (/^@(media|supports|(-moz-)?document|import)$/i.test(type)) {\n      return pushContext(state, stream, \"atBlock\");\n    } else if (/^@(font-face|counter-style)/i.test(type)) {\n      state.stateArg = type;\n      return \"restricted_atBlock_before\";\n    } else if (/^@(-(moz|ms|o|webkit)-)?keyframes$/i.test(type)) {\n      return \"keyframes\";\n    } else if (type && type.charAt(0) == \"@\") {\n      return pushContext(state, stream, \"at\");\n    } else if (type == \"hash\") {\n      override = \"builtin\";\n    } else if (type == \"word\") {\n      override = \"tag\";\n    } else if (type == \"variable-definition\") {\n      return \"maybeprop\";\n    } else if (type == \"interpolation\") {\n      return pushContext(state, stream, \"interpolation\");\n    } else if (type == \":\") {\n      return \"pseudo\";\n    } else if (allowNested && type == \"(\") {\n      return pushContext(state, stream, \"parens\");\n    }\n    return state.context.type;\n  };\n\n  states.block = function(type, stream, state) {\n    if (type == \"word\") {\n      var word = stream.current().toLowerCase();\n      if (propertyKeywords.hasOwnProperty(word)) {\n        override = \"property\";\n        return \"maybeprop\";\n      } else if (nonStandardPropertyKeywords.hasOwnProperty(word)) {\n        override = highlightNonStandardPropertyKeywords ? \"string-2\" : \"property\";\n        return \"maybeprop\";\n      } else if (allowNested) {\n        override = stream.match(/^\\s*:(?:\\s|$)/, false) ? \"property\" : \"tag\";\n        return \"block\";\n      } else {\n        override += \" error\";\n        return \"maybeprop\";\n      }\n    } else if (type == \"meta\") {\n      return \"block\";\n    } else if (!allowNested && (type == \"hash\" || type == \"qualifier\")) {\n      override = \"error\";\n      return \"block\";\n    } else {\n      return states.top(type, stream, state);\n    }\n  };\n\n  states.maybeprop = function(type, stream, state) {\n    if (type == \":\") return pushContext(state, stream, \"prop\");\n    return pass(type, stream, state);\n  };\n\n  states.prop = function(type, stream, state) {\n    if (type == \";\") return popContext(state);\n    if (type == \"{\" && allowNested) return pushContext(state, stream, \"propBlock\");\n    if (type == \"}\" || type == \"{\") return popAndPass(type, stream, state);\n    if (type == \"(\") return pushContext(state, stream, \"parens\");\n\n    if (type == \"hash\" && !/^#([0-9a-fA-f]{3,4}|[0-9a-fA-f]{6}|[0-9a-fA-f]{8})$/.test(stream.current())) {\n      override += \" error\";\n    } else if (type == \"word\") {\n      wordAsValue(stream);\n    } else if (type == \"interpolation\") {\n      return pushContext(state, stream, \"interpolation\");\n    }\n    return \"prop\";\n  };\n\n  states.propBlock = function(type, _stream, state) {\n    if (type == \"}\") return popContext(state);\n    if (type == \"word\") { override = \"property\"; return \"maybeprop\"; }\n    return state.context.type;\n  };\n\n  states.parens = function(type, stream, state) {\n    if (type == \"{\" || type == \"}\") return popAndPass(type, stream, state);\n    if (type == \")\") return popContext(state);\n    if (type == \"(\") return pushContext(state, stream, \"parens\");\n    if (type == \"interpolation\") return pushContext(state, stream, \"interpolation\");\n    if (type == \"word\") wordAsValue(stream);\n    return \"parens\";\n  };\n\n  states.pseudo = function(type, stream, state) {\n    if (type == \"meta\") return \"pseudo\";\n\n    if (type == \"word\") {\n      override = \"variable-3\";\n      return state.context.type;\n    }\n    return pass(type, stream, state);\n  };\n\n  states.documentTypes = function(type, stream, state) {\n    if (type == \"word\" && documentTypes.hasOwnProperty(stream.current())) {\n      override = \"tag\";\n      return state.context.type;\n    } else {\n      return states.atBlock(type, stream, state);\n    }\n  };\n\n  states.atBlock = function(type, stream, state) {\n    if (type == \"(\") return pushContext(state, stream, \"atBlock_parens\");\n    if (type == \"}\" || type == \";\") return popAndPass(type, stream, state);\n    if (type == \"{\") return popContext(state) && pushContext(state, stream, allowNested ? \"block\" : \"top\");\n\n    if (type == \"interpolation\") return pushContext(state, stream, \"interpolation\");\n\n    if (type == \"word\") {\n      var word = stream.current().toLowerCase();\n      if (word == \"only\" || word == \"not\" || word == \"and\" || word == \"or\")\n        override = \"keyword\";\n      else if (mediaTypes.hasOwnProperty(word))\n        override = \"attribute\";\n      else if (mediaFeatures.hasOwnProperty(word))\n        override = \"property\";\n      else if (mediaValueKeywords.hasOwnProperty(word))\n        override = \"keyword\";\n      else if (propertyKeywords.hasOwnProperty(word))\n        override = \"property\";\n      else if (nonStandardPropertyKeywords.hasOwnProperty(word))\n        override = highlightNonStandardPropertyKeywords ? \"string-2\" : \"property\";\n      else if (valueKeywords.hasOwnProperty(word))\n        override = \"atom\";\n      else if (colorKeywords.hasOwnProperty(word))\n        override = \"keyword\";\n      else\n        override = \"error\";\n    }\n    return state.context.type;\n  };\n\n  states.atComponentBlock = function(type, stream, state) {\n    if (type == \"}\")\n      return popAndPass(type, stream, state);\n    if (type == \"{\")\n      return popContext(state) && pushContext(state, stream, allowNested ? \"block\" : \"top\", false);\n    if (type == \"word\")\n      override = \"error\";\n    return state.context.type;\n  };\n\n  states.atBlock_parens = function(type, stream, state) {\n    if (type == \")\") return popContext(state);\n    if (type == \"{\" || type == \"}\") return popAndPass(type, stream, state, 2);\n    return states.atBlock(type, stream, state);\n  };\n\n  states.restricted_atBlock_before = function(type, stream, state) {\n    if (type == \"{\")\n      return pushContext(state, stream, \"restricted_atBlock\");\n    if (type == \"word\" && state.stateArg == \"@counter-style\") {\n      override = \"variable\";\n      return \"restricted_atBlock_before\";\n    }\n    return pass(type, stream, state);\n  };\n\n  states.restricted_atBlock = function(type, stream, state) {\n    if (type == \"}\") {\n      state.stateArg = null;\n      return popContext(state);\n    }\n    if (type == \"word\") {\n      if ((state.stateArg == \"@font-face\" && !fontProperties.hasOwnProperty(stream.current().toLowerCase())) ||\n          (state.stateArg == \"@counter-style\" && !counterDescriptors.hasOwnProperty(stream.current().toLowerCase())))\n        override = \"error\";\n      else\n        override = \"property\";\n      return \"maybeprop\";\n    }\n    return \"restricted_atBlock\";\n  };\n\n  states.keyframes = function(type, stream, state) {\n    if (type == \"word\") { override = \"variable\"; return \"keyframes\"; }\n    if (type == \"{\") return pushContext(state, stream, \"top\");\n    return pass(type, stream, state);\n  };\n\n  states.at = function(type, stream, state) {\n    if (type == \";\") return popContext(state);\n    if (type == \"{\" || type == \"}\") return popAndPass(type, stream, state);\n    if (type == \"word\") override = \"tag\";\n    else if (type == \"hash\") override = \"builtin\";\n    return \"at\";\n  };\n\n  states.interpolation = function(type, stream, state) {\n    if (type == \"}\") return popContext(state);\n    if (type == \"{\" || type == \";\") return popAndPass(type, stream, state);\n    if (type == \"word\") override = \"variable\";\n    else if (type != \"variable\" && type != \"(\" && type != \")\") override = \"error\";\n    return \"interpolation\";\n  };\n\n  return {\n    startState: function(base) {\n      return {tokenize: null,\n              state: inline ? \"block\" : \"top\",\n              stateArg: null,\n              context: new Context(inline ? \"block\" : \"top\", base || 0, null)};\n    },\n\n    token: function(stream, state) {\n      if (!state.tokenize && stream.eatSpace()) return null;\n      var style = (state.tokenize || tokenBase)(stream, state);\n      if (style && typeof style == \"object\") {\n        type = style[1];\n        style = style[0];\n      }\n      override = style;\n      if (type != \"comment\")\n        state.state = states[state.state](type, stream, state);\n      return override;\n    },\n\n    indent: function(state, textAfter) {\n      var cx = state.context, ch = textAfter && textAfter.charAt(0);\n      var indent = cx.indent;\n      if (cx.type == \"prop\" && (ch == \"}\" || ch == \")\")) cx = cx.prev;\n      if (cx.prev) {\n        if (ch == \"}\" && (cx.type == \"block\" || cx.type == \"top\" ||\n                          cx.type == \"interpolation\" || cx.type == \"restricted_atBlock\")) {\n          // Resume indentation from parent context.\n          cx = cx.prev;\n          indent = cx.indent;\n        } else if (ch == \")\" && (cx.type == \"parens\" || cx.type == \"atBlock_parens\") ||\n            ch == \"{\" && (cx.type == \"at\" || cx.type == \"atBlock\")) {\n          // Dedent relative to current context.\n          indent = Math.max(0, cx.indent - indentUnit);\n        }\n      }\n      return indent;\n    },\n\n    electricChars: \"}\",\n    blockCommentStart: \"/*\",\n    blockCommentEnd: \"*/\",\n    blockCommentContinue: \" * \",\n    lineComment: lineComment,\n    fold: \"brace\"\n  };\n});\n\n  function keySet(array) {\n    var keys = {};\n    for (var i = 0; i < array.length; ++i) {\n      keys[array[i].toLowerCase()] = true;\n    }\n    return keys;\n  }\n\n  var documentTypes_ = [\n    \"domain\", \"regexp\", \"url\", \"url-prefix\"\n  ], documentTypes = keySet(documentTypes_);\n\n  var mediaTypes_ = [\n    \"all\", \"aural\", \"braille\", \"handheld\", \"print\", \"projection\", \"screen\",\n    \"tty\", \"tv\", \"embossed\"\n  ], mediaTypes = keySet(mediaTypes_);\n\n  var mediaFeatures_ = [\n    \"width\", \"min-width\", \"max-width\", \"height\", \"min-height\", \"max-height\",\n    \"device-width\", \"min-device-width\", \"max-device-width\", \"device-height\",\n    \"min-device-height\", \"max-device-height\", \"aspect-ratio\",\n    \"min-aspect-ratio\", \"max-aspect-ratio\", \"device-aspect-ratio\",\n    \"min-device-aspect-ratio\", \"max-device-aspect-ratio\", \"color\", \"min-color\",\n    \"max-color\", \"color-index\", \"min-color-index\", \"max-color-index\",\n    \"monochrome\", \"min-monochrome\", \"max-monochrome\", \"resolution\",\n    \"min-resolution\", \"max-resolution\", \"scan\", \"grid\", \"orientation\",\n    \"device-pixel-ratio\", \"min-device-pixel-ratio\", \"max-device-pixel-ratio\",\n    \"pointer\", \"any-pointer\", \"hover\", \"any-hover\", \"prefers-color-scheme\",\n    \"dynamic-range\", \"video-dynamic-range\"\n  ], mediaFeatures = keySet(mediaFeatures_);\n\n  var mediaValueKeywords_ = [\n    \"landscape\", \"portrait\", \"none\", \"coarse\", \"fine\", \"on-demand\", \"hover\",\n    \"interlace\", \"progressive\",\n    \"dark\", \"light\",\n    \"standard\", \"high\"\n  ], mediaValueKeywords = keySet(mediaValueKeywords_);\n\n  var propertyKeywords_ = [\n    \"align-content\", \"align-items\", \"align-self\", \"alignment-adjust\",\n    \"alignment-baseline\", \"all\", \"anchor-point\", \"animation\", \"animation-delay\",\n    \"animation-direction\", \"animation-duration\", \"animation-fill-mode\",\n    \"animation-iteration-count\", \"animation-name\", \"animation-play-state\",\n    \"animation-timing-function\", \"appearance\", \"azimuth\", \"backdrop-filter\",\n    \"backface-visibility\", \"background\", \"background-attachment\",\n    \"background-blend-mode\", \"background-clip\", \"background-color\",\n    \"background-image\", \"background-origin\", \"background-position\",\n    \"background-position-x\", \"background-position-y\", \"background-repeat\",\n    \"background-size\", \"baseline-shift\", \"binding\", \"bleed\", \"block-size\",\n    \"bookmark-label\", \"bookmark-level\", \"bookmark-state\", \"bookmark-target\",\n    \"border\", \"border-bottom\", \"border-bottom-color\", \"border-bottom-left-radius\",\n    \"border-bottom-right-radius\", \"border-bottom-style\", \"border-bottom-width\",\n    \"border-collapse\", \"border-color\", \"border-image\", \"border-image-outset\",\n    \"border-image-repeat\", \"border-image-slice\", \"border-image-source\",\n    \"border-image-width\", \"border-left\", \"border-left-color\", \"border-left-style\",\n    \"border-left-width\", \"border-radius\", \"border-right\", \"border-right-color\",\n    \"border-right-style\", \"border-right-width\", \"border-spacing\", \"border-style\",\n    \"border-top\", \"border-top-color\", \"border-top-left-radius\",\n    \"border-top-right-radius\", \"border-top-style\", \"border-top-width\",\n    \"border-width\", \"bottom\", \"box-decoration-break\", \"box-shadow\", \"box-sizing\",\n    \"break-after\", \"break-before\", \"break-inside\", \"caption-side\", \"caret-color\",\n    \"clear\", \"clip\", \"color\", \"color-profile\", \"column-count\", \"column-fill\",\n    \"column-gap\", \"column-rule\", \"column-rule-color\", \"column-rule-style\",\n    \"column-rule-width\", \"column-span\", \"column-width\", \"columns\", \"contain\",\n    \"content\", \"counter-increment\", \"counter-reset\", \"crop\", \"cue\", \"cue-after\",\n    \"cue-before\", \"cursor\", \"direction\", \"display\", \"dominant-baseline\",\n    \"drop-initial-after-adjust\", \"drop-initial-after-align\",\n    \"drop-initial-before-adjust\", \"drop-initial-before-align\", \"drop-initial-size\",\n    \"drop-initial-value\", \"elevation\", \"empty-cells\", \"fit\", \"fit-content\", \"fit-position\",\n    \"flex\", \"flex-basis\", \"flex-direction\", \"flex-flow\", \"flex-grow\",\n    \"flex-shrink\", \"flex-wrap\", \"float\", \"float-offset\", \"flow-from\", \"flow-into\",\n    \"font\", \"font-family\", \"font-feature-settings\", \"font-kerning\",\n    \"font-language-override\", \"font-optical-sizing\", \"font-size\",\n    \"font-size-adjust\", \"font-stretch\", \"font-style\", \"font-synthesis\",\n    \"font-variant\", \"font-variant-alternates\", \"font-variant-caps\",\n    \"font-variant-east-asian\", \"font-variant-ligatures\", \"font-variant-numeric\",\n    \"font-variant-position\", \"font-variation-settings\", \"font-weight\", \"gap\",\n    \"grid\", \"grid-area\", \"grid-auto-columns\", \"grid-auto-flow\", \"grid-auto-rows\",\n    \"grid-column\", \"grid-column-end\", \"grid-column-gap\", \"grid-column-start\",\n    \"grid-gap\", \"grid-row\", \"grid-row-end\", \"grid-row-gap\", \"grid-row-start\",\n    \"grid-template\", \"grid-template-areas\", \"grid-template-columns\",\n    \"grid-template-rows\", \"hanging-punctuation\", \"height\", \"hyphens\", \"icon\",\n    \"image-orientation\", \"image-rendering\", \"image-resolution\", \"inline-box-align\",\n    \"inset\", \"inset-block\", \"inset-block-end\", \"inset-block-start\", \"inset-inline\",\n    \"inset-inline-end\", \"inset-inline-start\", \"isolation\", \"justify-content\",\n    \"justify-items\", \"justify-self\", \"left\", \"letter-spacing\", \"line-break\",\n    \"line-height\", \"line-height-step\", \"line-stacking\", \"line-stacking-ruby\",\n    \"line-stacking-shift\", \"line-stacking-strategy\", \"list-style\",\n    \"list-style-image\", \"list-style-position\", \"list-style-type\", \"margin\",\n    \"margin-bottom\", \"margin-left\", \"margin-right\", \"margin-top\", \"marks\",\n    \"marquee-direction\", \"marquee-loop\", \"marquee-play-count\", \"marquee-speed\",\n    \"marquee-style\", \"mask-clip\", \"mask-composite\", \"mask-image\", \"mask-mode\",\n    \"mask-origin\", \"mask-position\", \"mask-repeat\", \"mask-size\",\"mask-type\",\n    \"max-block-size\", \"max-height\", \"max-inline-size\",\n    \"max-width\", \"min-block-size\", \"min-height\", \"min-inline-size\", \"min-width\",\n    \"mix-blend-mode\", \"move-to\", \"nav-down\", \"nav-index\", \"nav-left\", \"nav-right\",\n    \"nav-up\", \"object-fit\", \"object-position\", \"offset\", \"offset-anchor\",\n    \"offset-distance\", \"offset-path\", \"offset-position\", \"offset-rotate\",\n    \"opacity\", \"order\", \"orphans\", \"outline\", \"outline-color\", \"outline-offset\",\n    \"outline-style\", \"outline-width\", \"overflow\", \"overflow-style\",\n    \"overflow-wrap\", \"overflow-x\", \"overflow-y\", \"padding\", \"padding-bottom\",\n    \"padding-left\", \"padding-right\", \"padding-top\", \"page\", \"page-break-after\",\n    \"page-break-before\", \"page-break-inside\", \"page-policy\", \"pause\",\n    \"pause-after\", \"pause-before\", \"perspective\", \"perspective-origin\", \"pitch\",\n    \"pitch-range\", \"place-content\", \"place-items\", \"place-self\", \"play-during\",\n    \"position\", \"presentation-level\", \"punctuation-trim\", \"quotes\",\n    \"region-break-after\", \"region-break-before\", \"region-break-inside\",\n    \"region-fragment\", \"rendering-intent\", \"resize\", \"rest\", \"rest-after\",\n    \"rest-before\", \"richness\", \"right\", \"rotate\", \"rotation\", \"rotation-point\",\n    \"row-gap\", \"ruby-align\", \"ruby-overhang\", \"ruby-position\", \"ruby-span\",\n    \"scale\", \"scroll-behavior\", \"scroll-margin\", \"scroll-margin-block\",\n    \"scroll-margin-block-end\", \"scroll-margin-block-start\", \"scroll-margin-bottom\",\n    \"scroll-margin-inline\", \"scroll-margin-inline-end\",\n    \"scroll-margin-inline-start\", \"scroll-margin-left\", \"scroll-margin-right\",\n    \"scroll-margin-top\", \"scroll-padding\", \"scroll-padding-block\",\n    \"scroll-padding-block-end\", \"scroll-padding-block-start\",\n    \"scroll-padding-bottom\", \"scroll-padding-inline\", \"scroll-padding-inline-end\",\n    \"scroll-padding-inline-start\", \"scroll-padding-left\", \"scroll-padding-right\",\n    \"scroll-padding-top\", \"scroll-snap-align\", \"scroll-snap-type\",\n    \"shape-image-threshold\", \"shape-inside\", \"shape-margin\", \"shape-outside\",\n    \"size\", \"speak\", \"speak-as\", \"speak-header\", \"speak-numeral\",\n    \"speak-punctuation\", \"speech-rate\", \"stress\", \"string-set\", \"tab-size\",\n    \"table-layout\", \"target\", \"target-name\", \"target-new\", \"target-position\",\n    \"text-align\", \"text-align-last\", \"text-combine-upright\", \"text-decoration\",\n    \"text-decoration-color\", \"text-decoration-line\", \"text-decoration-skip\",\n    \"text-decoration-skip-ink\", \"text-decoration-style\", \"text-emphasis\",\n    \"text-emphasis-color\", \"text-emphasis-position\", \"text-emphasis-style\",\n    \"text-height\", \"text-indent\", \"text-justify\", \"text-orientation\",\n    \"text-outline\", \"text-overflow\", \"text-rendering\", \"text-shadow\",\n    \"text-size-adjust\", \"text-space-collapse\", \"text-transform\",\n    \"text-underline-position\", \"text-wrap\", \"top\", \"touch-action\", \"transform\", \"transform-origin\",\n    \"transform-style\", \"transition\", \"transition-delay\", \"transition-duration\",\n    \"transition-property\", \"transition-timing-function\", \"translate\",\n    \"unicode-bidi\", \"user-select\", \"vertical-align\", \"visibility\", \"voice-balance\",\n    \"voice-duration\", \"voice-family\", \"voice-pitch\", \"voice-range\", \"voice-rate\",\n    \"voice-stress\", \"voice-volume\", \"volume\", \"white-space\", \"widows\", \"width\",\n    \"will-change\", \"word-break\", \"word-spacing\", \"word-wrap\", \"writing-mode\", \"z-index\",\n    // SVG-specific\n    \"clip-path\", \"clip-rule\", \"mask\", \"enable-background\", \"filter\", \"flood-color\",\n    \"flood-opacity\", \"lighting-color\", \"stop-color\", \"stop-opacity\", \"pointer-events\",\n    \"color-interpolation\", \"color-interpolation-filters\",\n    \"color-rendering\", \"fill\", \"fill-opacity\", \"fill-rule\", \"image-rendering\",\n    \"marker\", \"marker-end\", \"marker-mid\", \"marker-start\", \"paint-order\", \"shape-rendering\", \"stroke\",\n    \"stroke-dasharray\", \"stroke-dashoffset\", \"stroke-linecap\", \"stroke-linejoin\",\n    \"stroke-miterlimit\", \"stroke-opacity\", \"stroke-width\", \"text-rendering\",\n    \"baseline-shift\", \"dominant-baseline\", \"glyph-orientation-horizontal\",\n    \"glyph-orientation-vertical\", \"text-anchor\", \"writing-mode\",\n  ], propertyKeywords = keySet(propertyKeywords_);\n\n  var nonStandardPropertyKeywords_ = [\n    \"accent-color\", \"aspect-ratio\", \"border-block\", \"border-block-color\", \"border-block-end\",\n    \"border-block-end-color\", \"border-block-end-style\", \"border-block-end-width\",\n    \"border-block-start\", \"border-block-start-color\", \"border-block-start-style\",\n    \"border-block-start-width\", \"border-block-style\", \"border-block-width\",\n    \"border-inline\", \"border-inline-color\", \"border-inline-end\",\n    \"border-inline-end-color\", \"border-inline-end-style\",\n    \"border-inline-end-width\", \"border-inline-start\", \"border-inline-start-color\",\n    \"border-inline-start-style\", \"border-inline-start-width\",\n    \"border-inline-style\", \"border-inline-width\", \"content-visibility\", \"margin-block\",\n    \"margin-block-end\", \"margin-block-start\", \"margin-inline\", \"margin-inline-end\",\n    \"margin-inline-start\", \"overflow-anchor\", \"overscroll-behavior\", \"padding-block\", \"padding-block-end\",\n    \"padding-block-start\", \"padding-inline\", \"padding-inline-end\",\n    \"padding-inline-start\", \"scroll-snap-stop\", \"scrollbar-3d-light-color\",\n    \"scrollbar-arrow-color\", \"scrollbar-base-color\", \"scrollbar-dark-shadow-color\",\n    \"scrollbar-face-color\", \"scrollbar-highlight-color\", \"scrollbar-shadow-color\",\n    \"scrollbar-track-color\", \"searchfield-cancel-button\", \"searchfield-decoration\",\n    \"searchfield-results-button\", \"searchfield-results-decoration\", \"shape-inside\", \"zoom\"\n  ], nonStandardPropertyKeywords = keySet(nonStandardPropertyKeywords_);\n\n  var fontProperties_ = [\n    \"font-display\", \"font-family\", \"src\", \"unicode-range\", \"font-variant\",\n     \"font-feature-settings\", \"font-stretch\", \"font-weight\", \"font-style\"\n  ], fontProperties = keySet(fontProperties_);\n\n  var counterDescriptors_ = [\n    \"additive-symbols\", \"fallback\", \"negative\", \"pad\", \"prefix\", \"range\",\n    \"speak-as\", \"suffix\", \"symbols\", \"system\"\n  ], counterDescriptors = keySet(counterDescriptors_);\n\n  var colorKeywords_ = [\n    \"aliceblue\", \"antiquewhite\", \"aqua\", \"aquamarine\", \"azure\", \"beige\",\n    \"bisque\", \"black\", \"blanchedalmond\", \"blue\", \"blueviolet\", \"brown\",\n    \"burlywood\", \"cadetblue\", \"chartreuse\", \"chocolate\", \"coral\", \"cornflowerblue\",\n    \"cornsilk\", \"crimson\", \"cyan\", \"darkblue\", \"darkcyan\", \"darkgoldenrod\",\n    \"darkgray\", \"darkgreen\", \"darkgrey\", \"darkkhaki\", \"darkmagenta\", \"darkolivegreen\",\n    \"darkorange\", \"darkorchid\", \"darkred\", \"darksalmon\", \"darkseagreen\",\n    \"darkslateblue\", \"darkslategray\", \"darkslategrey\", \"darkturquoise\", \"darkviolet\",\n    \"deeppink\", \"deepskyblue\", \"dimgray\", \"dimgrey\", \"dodgerblue\", \"firebrick\",\n    \"floralwhite\", \"forestgreen\", \"fuchsia\", \"gainsboro\", \"ghostwhite\",\n    \"gold\", \"goldenrod\", \"gray\", \"grey\", \"green\", \"greenyellow\", \"honeydew\",\n    \"hotpink\", \"indianred\", \"indigo\", \"ivory\", \"khaki\", \"lavender\",\n    \"lavenderblush\", \"lawngreen\", \"lemonchiffon\", \"lightblue\", \"lightcoral\",\n    \"lightcyan\", \"lightgoldenrodyellow\", \"lightgray\", \"lightgreen\", \"lightgrey\", \"lightpink\",\n    \"lightsalmon\", \"lightseagreen\", \"lightskyblue\", \"lightslategray\", \"lightslategrey\",\n    \"lightsteelblue\", \"lightyellow\", \"lime\", \"limegreen\", \"linen\", \"magenta\",\n    \"maroon\", \"mediumaquamarine\", \"mediumblue\", \"mediumorchid\", \"mediumpurple\",\n    \"mediumseagreen\", \"mediumslateblue\", \"mediumspringgreen\", \"mediumturquoise\",\n    \"mediumvioletred\", \"midnightblue\", \"mintcream\", \"mistyrose\", \"moccasin\",\n    \"navajowhite\", \"navy\", \"oldlace\", \"olive\", \"olivedrab\", \"orange\", \"orangered\",\n    \"orchid\", \"palegoldenrod\", \"palegreen\", \"paleturquoise\", \"palevioletred\",\n    \"papayawhip\", \"peachpuff\", \"peru\", \"pink\", \"plum\", \"powderblue\",\n    \"purple\", \"rebeccapurple\", \"red\", \"rosybrown\", \"royalblue\", \"saddlebrown\",\n    \"salmon\", \"sandybrown\", \"seagreen\", \"seashell\", \"sienna\", \"silver\", \"skyblue\",\n    \"slateblue\", \"slategray\", \"slategrey\", \"snow\", \"springgreen\", \"steelblue\", \"tan\",\n    \"teal\", \"thistle\", \"tomato\", \"turquoise\", \"violet\", \"wheat\", \"white\",\n    \"whitesmoke\", \"yellow\", \"yellowgreen\"\n  ], colorKeywords = keySet(colorKeywords_);\n\n  var valueKeywords_ = [\n    \"above\", \"absolute\", \"activeborder\", \"additive\", \"activecaption\", \"afar\",\n    \"after-white-space\", \"ahead\", \"alias\", \"all\", \"all-scroll\", \"alphabetic\", \"alternate\",\n    \"always\", \"amharic\", \"amharic-abegede\", \"antialiased\", \"appworkspace\",\n    \"arabic-indic\", \"armenian\", \"asterisks\", \"attr\", \"auto\", \"auto-flow\", \"avoid\", \"avoid-column\", \"avoid-page\",\n    \"avoid-region\", \"axis-pan\", \"background\", \"backwards\", \"baseline\", \"below\", \"bidi-override\", \"binary\",\n    \"bengali\", \"blink\", \"block\", \"block-axis\", \"blur\", \"bold\", \"bolder\", \"border\", \"border-box\",\n    \"both\", \"bottom\", \"break\", \"break-all\", \"break-word\", \"brightness\", \"bullets\", \"button\",\n    \"buttonface\", \"buttonhighlight\", \"buttonshadow\", \"buttontext\", \"calc\", \"cambodian\",\n    \"capitalize\", \"caps-lock-indicator\", \"caption\", \"captiontext\", \"caret\",\n    \"cell\", \"center\", \"checkbox\", \"circle\", \"cjk-decimal\", \"cjk-earthly-branch\",\n    \"cjk-heavenly-stem\", \"cjk-ideographic\", \"clear\", \"clip\", \"close-quote\",\n    \"col-resize\", \"collapse\", \"color\", \"color-burn\", \"color-dodge\", \"column\", \"column-reverse\",\n    \"compact\", \"condensed\", \"conic-gradient\", \"contain\", \"content\", \"contents\",\n    \"content-box\", \"context-menu\", \"continuous\", \"contrast\", \"copy\", \"counter\", \"counters\", \"cover\", \"crop\",\n    \"cross\", \"crosshair\", \"cubic-bezier\", \"currentcolor\", \"cursive\", \"cyclic\", \"darken\", \"dashed\", \"decimal\",\n    \"decimal-leading-zero\", \"default\", \"default-button\", \"dense\", \"destination-atop\",\n    \"destination-in\", \"destination-out\", \"destination-over\", \"devanagari\", \"difference\",\n    \"disc\", \"discard\", \"disclosure-closed\", \"disclosure-open\", \"document\",\n    \"dot-dash\", \"dot-dot-dash\",\n    \"dotted\", \"double\", \"down\", \"drop-shadow\", \"e-resize\", \"ease\", \"ease-in\", \"ease-in-out\", \"ease-out\",\n    \"element\", \"ellipse\", \"ellipsis\", \"embed\", \"end\", \"ethiopic\", \"ethiopic-abegede\",\n    \"ethiopic-abegede-am-et\", \"ethiopic-abegede-gez\", \"ethiopic-abegede-ti-er\",\n    \"ethiopic-abegede-ti-et\", \"ethiopic-halehame-aa-er\",\n    \"ethiopic-halehame-aa-et\", \"ethiopic-halehame-am-et\",\n    \"ethiopic-halehame-gez\", \"ethiopic-halehame-om-et\",\n    \"ethiopic-halehame-sid-et\", \"ethiopic-halehame-so-et\",\n    \"ethiopic-halehame-ti-er\", \"ethiopic-halehame-ti-et\", \"ethiopic-halehame-tig\",\n    \"ethiopic-numeric\", \"ew-resize\", \"exclusion\", \"expanded\", \"extends\", \"extra-condensed\",\n    \"extra-expanded\", \"fantasy\", \"fast\", \"fill\", \"fill-box\", \"fixed\", \"flat\", \"flex\", \"flex-end\", \"flex-start\", \"footnotes\",\n    \"forwards\", \"from\", \"geometricPrecision\", \"georgian\", \"grayscale\", \"graytext\", \"grid\", \"groove\",\n    \"gujarati\", \"gurmukhi\", \"hand\", \"hangul\", \"hangul-consonant\", \"hard-light\", \"hebrew\",\n    \"help\", \"hidden\", \"hide\", \"higher\", \"highlight\", \"highlighttext\",\n    \"hiragana\", \"hiragana-iroha\", \"horizontal\", \"hsl\", \"hsla\", \"hue\", \"hue-rotate\", \"icon\", \"ignore\",\n    \"inactiveborder\", \"inactivecaption\", \"inactivecaptiontext\", \"infinite\",\n    \"infobackground\", \"infotext\", \"inherit\", \"initial\", \"inline\", \"inline-axis\",\n    \"inline-block\", \"inline-flex\", \"inline-grid\", \"inline-table\", \"inset\", \"inside\", \"intrinsic\", \"invert\",\n    \"italic\", \"japanese-formal\", \"japanese-informal\", \"justify\", \"kannada\",\n    \"katakana\", \"katakana-iroha\", \"keep-all\", \"khmer\",\n    \"korean-hangul-formal\", \"korean-hanja-formal\", \"korean-hanja-informal\",\n    \"landscape\", \"lao\", \"large\", \"larger\", \"left\", \"level\", \"lighter\", \"lighten\",\n    \"line-through\", \"linear\", \"linear-gradient\", \"lines\", \"list-item\", \"listbox\", \"listitem\",\n    \"local\", \"logical\", \"loud\", \"lower\", \"lower-alpha\", \"lower-armenian\",\n    \"lower-greek\", \"lower-hexadecimal\", \"lower-latin\", \"lower-norwegian\",\n    \"lower-roman\", \"lowercase\", \"ltr\", \"luminosity\", \"malayalam\", \"manipulation\", \"match\", \"matrix\", \"matrix3d\",\n    \"media-play-button\", \"media-slider\", \"media-sliderthumb\",\n    \"media-volume-slider\", \"media-volume-sliderthumb\", \"medium\",\n    \"menu\", \"menulist\", \"menulist-button\",\n    \"menutext\", \"message-box\", \"middle\", \"min-intrinsic\",\n    \"mix\", \"mongolian\", \"monospace\", \"move\", \"multiple\", \"multiple_mask_images\", \"multiply\", \"myanmar\", \"n-resize\",\n    \"narrower\", \"ne-resize\", \"nesw-resize\", \"no-close-quote\", \"no-drop\",\n    \"no-open-quote\", \"no-repeat\", \"none\", \"normal\", \"not-allowed\", \"nowrap\",\n    \"ns-resize\", \"numbers\", \"numeric\", \"nw-resize\", \"nwse-resize\", \"oblique\", \"octal\", \"opacity\", \"open-quote\",\n    \"optimizeLegibility\", \"optimizeSpeed\", \"oriya\", \"oromo\", \"outset\",\n    \"outside\", \"outside-shape\", \"overlay\", \"overline\", \"padding\", \"padding-box\",\n    \"painted\", \"page\", \"paused\", \"persian\", \"perspective\", \"pinch-zoom\", \"plus-darker\", \"plus-lighter\",\n    \"pointer\", \"polygon\", \"portrait\", \"pre\", \"pre-line\", \"pre-wrap\", \"preserve-3d\",\n    \"progress\", \"push-button\", \"radial-gradient\", \"radio\", \"read-only\",\n    \"read-write\", \"read-write-plaintext-only\", \"rectangle\", \"region\",\n    \"relative\", \"repeat\", \"repeating-linear-gradient\", \"repeating-radial-gradient\",\n    \"repeating-conic-gradient\", \"repeat-x\", \"repeat-y\", \"reset\", \"reverse\",\n    \"rgb\", \"rgba\", \"ridge\", \"right\", \"rotate\", \"rotate3d\", \"rotateX\", \"rotateY\",\n    \"rotateZ\", \"round\", \"row\", \"row-resize\", \"row-reverse\", \"rtl\", \"run-in\", \"running\",\n    \"s-resize\", \"sans-serif\", \"saturate\", \"saturation\", \"scale\", \"scale3d\", \"scaleX\", \"scaleY\", \"scaleZ\", \"screen\",\n    \"scroll\", \"scrollbar\", \"scroll-position\", \"se-resize\", \"searchfield\",\n    \"searchfield-cancel-button\", \"searchfield-decoration\",\n    \"searchfield-results-button\", \"searchfield-results-decoration\", \"self-start\", \"self-end\",\n    \"semi-condensed\", \"semi-expanded\", \"separate\", \"sepia\", \"serif\", \"show\", \"sidama\",\n    \"simp-chinese-formal\", \"simp-chinese-informal\", \"single\",\n    \"skew\", \"skewX\", \"skewY\", \"skip-white-space\", \"slide\", \"slider-horizontal\",\n    \"slider-vertical\", \"sliderthumb-horizontal\", \"sliderthumb-vertical\", \"slow\",\n    \"small\", \"small-caps\", \"small-caption\", \"smaller\", \"soft-light\", \"solid\", \"somali\",\n    \"source-atop\", \"source-in\", \"source-out\", \"source-over\", \"space\", \"space-around\", \"space-between\", \"space-evenly\", \"spell-out\", \"square\",\n    \"square-button\", \"start\", \"static\", \"status-bar\", \"stretch\", \"stroke\", \"stroke-box\", \"sub\",\n    \"subpixel-antialiased\", \"svg_masks\", \"super\", \"sw-resize\", \"symbolic\", \"symbols\", \"system-ui\", \"table\",\n    \"table-caption\", \"table-cell\", \"table-column\", \"table-column-group\",\n    \"table-footer-group\", \"table-header-group\", \"table-row\", \"table-row-group\",\n    \"tamil\",\n    \"telugu\", \"text\", \"text-bottom\", \"text-top\", \"textarea\", \"textfield\", \"thai\",\n    \"thick\", \"thin\", \"threeddarkshadow\", \"threedface\", \"threedhighlight\",\n    \"threedlightshadow\", \"threedshadow\", \"tibetan\", \"tigre\", \"tigrinya-er\",\n    \"tigrinya-er-abegede\", \"tigrinya-et\", \"tigrinya-et-abegede\", \"to\", \"top\",\n    \"trad-chinese-formal\", \"trad-chinese-informal\", \"transform\",\n    \"translate\", \"translate3d\", \"translateX\", \"translateY\", \"translateZ\",\n    \"transparent\", \"ultra-condensed\", \"ultra-expanded\", \"underline\", \"unidirectional-pan\", \"unset\", \"up\",\n    \"upper-alpha\", \"upper-armenian\", \"upper-greek\", \"upper-hexadecimal\",\n    \"upper-latin\", \"upper-norwegian\", \"upper-roman\", \"uppercase\", \"urdu\", \"url\",\n    \"var\", \"vertical\", \"vertical-text\", \"view-box\", \"visible\", \"visibleFill\", \"visiblePainted\",\n    \"visibleStroke\", \"visual\", \"w-resize\", \"wait\", \"wave\", \"wider\",\n    \"window\", \"windowframe\", \"windowtext\", \"words\", \"wrap\", \"wrap-reverse\", \"x-large\", \"x-small\", \"xor\",\n    \"xx-large\", \"xx-small\"\n  ], valueKeywords = keySet(valueKeywords_);\n\n  var allWords = documentTypes_.concat(mediaTypes_).concat(mediaFeatures_).concat(mediaValueKeywords_)\n    .concat(propertyKeywords_).concat(nonStandardPropertyKeywords_).concat(colorKeywords_)\n    .concat(valueKeywords_);\n  CodeMirror.registerHelper(\"hintWords\", \"css\", allWords);\n\n  function tokenCComment(stream, state) {\n    var maybeEnd = false, ch;\n    while ((ch = stream.next()) != null) {\n      if (maybeEnd && ch == \"/\") {\n        state.tokenize = null;\n        break;\n      }\n      maybeEnd = (ch == \"*\");\n    }\n    return [\"comment\", \"comment\"];\n  }\n\n  CodeMirror.defineMIME(\"text/css\", {\n    documentTypes: documentTypes,\n    mediaTypes: mediaTypes,\n    mediaFeatures: mediaFeatures,\n    mediaValueKeywords: mediaValueKeywords,\n    propertyKeywords: propertyKeywords,\n    nonStandardPropertyKeywords: nonStandardPropertyKeywords,\n    fontProperties: fontProperties,\n    counterDescriptors: counterDescriptors,\n    colorKeywords: colorKeywords,\n    valueKeywords: valueKeywords,\n    tokenHooks: {\n      \"/\": function(stream, state) {\n        if (!stream.eat(\"*\")) return false;\n        state.tokenize = tokenCComment;\n        return tokenCComment(stream, state);\n      }\n    },\n    name: \"css\"\n  });\n\n  CodeMirror.defineMIME(\"text/x-scss\", {\n    mediaTypes: mediaTypes,\n    mediaFeatures: mediaFeatures,\n    mediaValueKeywords: mediaValueKeywords,\n    propertyKeywords: propertyKeywords,\n    nonStandardPropertyKeywords: nonStandardPropertyKeywords,\n    colorKeywords: colorKeywords,\n    valueKeywords: valueKeywords,\n    fontProperties: fontProperties,\n    allowNested: true,\n    lineComment: \"//\",\n    tokenHooks: {\n      \"/\": function(stream, state) {\n        if (stream.eat(\"/\")) {\n          stream.skipToEnd();\n          return [\"comment\", \"comment\"];\n        } else if (stream.eat(\"*\")) {\n          state.tokenize = tokenCComment;\n          return tokenCComment(stream, state);\n        } else {\n          return [\"operator\", \"operator\"];\n        }\n      },\n      \":\": function(stream) {\n        if (stream.match(/^\\s*\\{/, false))\n          return [null, null]\n        return false;\n      },\n      \"$\": function(stream) {\n        stream.match(/^[\\w-]+/);\n        if (stream.match(/^\\s*:/, false))\n          return [\"variable-2\", \"variable-definition\"];\n        return [\"variable-2\", \"variable\"];\n      },\n      \"#\": function(stream) {\n        if (!stream.eat(\"{\")) return false;\n        return [null, \"interpolation\"];\n      }\n    },\n    name: \"css\",\n    helperType: \"scss\"\n  });\n\n  CodeMirror.defineMIME(\"text/x-less\", {\n    mediaTypes: mediaTypes,\n    mediaFeatures: mediaFeatures,\n    mediaValueKeywords: mediaValueKeywords,\n    propertyKeywords: propertyKeywords,\n    nonStandardPropertyKeywords: nonStandardPropertyKeywords,\n    colorKeywords: colorKeywords,\n    valueKeywords: valueKeywords,\n    fontProperties: fontProperties,\n    allowNested: true,\n    lineComment: \"//\",\n    tokenHooks: {\n      \"/\": function(stream, state) {\n        if (stream.eat(\"/\")) {\n          stream.skipToEnd();\n          return [\"comment\", \"comment\"];\n        } else if (stream.eat(\"*\")) {\n          state.tokenize = tokenCComment;\n          return tokenCComment(stream, state);\n        } else {\n          return [\"operator\", \"operator\"];\n        }\n      },\n      \"@\": function(stream) {\n        if (stream.eat(\"{\")) return [null, \"interpolation\"];\n        if (stream.match(/^(charset|document|font-face|import|(-(moz|ms|o|webkit)-)?keyframes|media|namespace|page|supports)\\b/i, false)) return false;\n        stream.eatWhile(/[\\w\\\\\\-]/);\n        if (stream.match(/^\\s*:/, false))\n          return [\"variable-2\", \"variable-definition\"];\n        return [\"variable-2\", \"variable\"];\n      },\n      \"&\": function() {\n        return [\"atom\", \"atom\"];\n      }\n    },\n    name: \"css\",\n    helperType: \"less\"\n  });\n\n  CodeMirror.defineMIME(\"text/x-gss\", {\n    documentTypes: documentTypes,\n    mediaTypes: mediaTypes,\n    mediaFeatures: mediaFeatures,\n    propertyKeywords: propertyKeywords,\n    nonStandardPropertyKeywords: nonStandardPropertyKeywords,\n    fontProperties: fontProperties,\n    counterDescriptors: counterDescriptors,\n    colorKeywords: colorKeywords,\n    valueKeywords: valueKeywords,\n    supportsAtComponent: true,\n    tokenHooks: {\n      \"/\": function(stream, state) {\n        if (!stream.eat(\"*\")) return false;\n        state.tokenize = tokenCComment;\n        return tokenCComment(stream, state);\n      }\n    },\n    name: \"css\",\n    helperType: \"gss\"\n  });\n\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"), require(\"../fold/xml-fold\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\", \"../fold/xml-fold\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n  \"use strict\";\n\n  CodeMirror.defineOption(\"matchTags\", false, function(cm, val, old) {\n    if (old && old != CodeMirror.Init) {\n      cm.off(\"cursorActivity\", doMatchTags);\n      cm.off(\"viewportChange\", maybeUpdateMatch);\n      clear(cm);\n    }\n    if (val) {\n      cm.state.matchBothTags = typeof val == \"object\" && val.bothTags;\n      cm.on(\"cursorActivity\", doMatchTags);\n      cm.on(\"viewportChange\", maybeUpdateMatch);\n      doMatchTags(cm);\n    }\n  });\n\n  function clear(cm) {\n    if (cm.state.tagHit) cm.state.tagHit.clear();\n    if (cm.state.tagOther) cm.state.tagOther.clear();\n    cm.state.tagHit = cm.state.tagOther = null;\n  }\n\n  function doMatchTags(cm) {\n    cm.state.failedTagMatch = false;\n    cm.operation(function() {\n      clear(cm);\n      if (cm.somethingSelected()) return;\n      var cur = cm.getCursor(), range = cm.getViewport();\n      range.from = Math.min(range.from, cur.line); range.to = Math.max(cur.line + 1, range.to);\n      var match = CodeMirror.findMatchingTag(cm, cur, range);\n      if (!match) return;\n      if (cm.state.matchBothTags) {\n        var hit = match.at == \"open\" ? match.open : match.close;\n        if (hit) cm.state.tagHit = cm.markText(hit.from, hit.to, {className: \"CodeMirror-matchingtag\"});\n      }\n      var other = match.at == \"close\" ? match.open : match.close;\n      if (other)\n        cm.state.tagOther = cm.markText(other.from, other.to, {className: \"CodeMirror-matchingtag\"});\n      else\n        cm.state.failedTagMatch = true;\n    });\n  }\n\n  function maybeUpdateMatch(cm) {\n    if (cm.state.failedTagMatch) doMatchTags(cm);\n  }\n\n  CodeMirror.commands.toMatchingTag = function(cm) {\n    var found = CodeMirror.findMatchingTag(cm, cm.getCursor());\n    if (found) {\n      var other = found.at == \"close\" ? found.open : found.close;\n      if (other) cm.extendSelection(other.to, other.from);\n    }\n  };\n});\n","var __defProp = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nimport { defineComponent, ref, onMounted, markRaw, watch, unref, openBlock, createElementBlock, computed, nextTick, shallowRef, getCurrentInstance, onBeforeUnmount, normalizeClass, normalizeStyle, createBlock, resolveDynamicComponent, mergeProps } from \"vue\";\nimport \"codemirror/lib/codemirror.css\";\nimport _CodeMirror from \"codemirror\";\nimport \"codemirror/addon/merge/merge.css\";\nimport \"codemirror/addon/merge/merge.js\";\nimport DiffMatchPatch from \"diff-match-patch\";\nimport \"codemirror/addon/mode/simple.js\";\n!window.CodeMirror && (window.CodeMirror = _CodeMirror);\nconst CodeMirror$1 = window.CodeMirror || _CodeMirror;\nvar _export_sfc = (sfc, props) => {\n  const target = sfc.__vccOpts || sfc;\n  for (const [key, val] of props) {\n    target[key] = val;\n  }\n  return target;\n};\nconst _sfc_main$3 = defineComponent({\n  name: \"DefaultMode\",\n  props: {\n    name: {\n      type: String,\n      default: `cm-textarea-${+new Date()}`\n    },\n    value: {\n      type: String,\n      default: \"\"\n    },\n    content: {\n      type: String,\n      default: \"\"\n    },\n    options: {\n      type: Object,\n      default: () => ({})\n    },\n    cminstance: {\n      type: Object,\n      default: () => null\n    },\n    placeholder: {\n      type: String,\n      default: \"\"\n    }\n  },\n  emits: {\n    ready: (instance) => instance,\n    \"update:cminstance\": (instance) => instance\n  },\n  setup(props, { emit }) {\n    const textarea = ref();\n    const _cminstance = ref(null);\n    const initialize = () => {\n      _cminstance.value = markRaw(CodeMirror$1.fromTextArea(textarea.value, props.options));\n      emit(\"update:cminstance\", _cminstance.value);\n      const unwatch = watch(() => props.cminstance, (val) => {\n        var _a;\n        val && ((_a = props.cminstance) == null ? void 0 : _a.setValue(props.value || props.content));\n        emit(\"ready\", unref(_cminstance));\n        unwatch == null ? void 0 : unwatch();\n      }, { deep: true });\n    };\n    onMounted(() => {\n      initialize();\n    });\n    return {\n      textarea,\n      initialize\n    };\n  }\n});\nconst _hoisted_1$2 = [\"name\", \"placeholder\"];\nfunction _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {\n  return openBlock(), createElementBlock(\"textarea\", {\n    ref: \"textarea\",\n    name: _ctx.$props.name,\n    placeholder: _ctx.$props.placeholder\n  }, null, 8, _hoisted_1$2);\n}\nvar Default = /* @__PURE__ */ _export_sfc(_sfc_main$3, [[\"render\", _sfc_render$2]]);\nwindow.diff_match_patch = DiffMatchPatch;\nwindow.DIFF_DELETE = -1;\nwindow.DIFF_INSERT = 1;\nwindow.DIFF_EQUAL = 0;\nconst _sfc_main$2 = defineComponent({\n  name: \"MergeMode\",\n  props: {\n    options: {\n      type: Object,\n      default: () => ({})\n    },\n    cminstance: {\n      type: Object,\n      default: () => ({})\n    }\n  },\n  emits: [\"update:cminstance\", \"ready\"],\n  setup(props, { emit }) {\n    const _cminstance = ref();\n    const mergeView = ref();\n    const initialize = () => {\n      _cminstance.value = markRaw(CodeMirror$1.MergeView(mergeView.value, props.options));\n      emit(\"update:cminstance\", _cminstance.value);\n      emit(\"ready\", _cminstance);\n    };\n    onMounted(() => {\n      initialize();\n    });\n    return {\n      mergeView,\n      initialize\n    };\n  }\n});\nconst _hoisted_1$1 = { ref: \"mergeView\" };\nfunction _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {\n  return openBlock(), createElementBlock(\"div\", _hoisted_1$1, null, 512);\n}\nvar Merge = /* @__PURE__ */ _export_sfc(_sfc_main$2, [[\"render\", _sfc_render$1]]);\nvar logErrorType;\n(function(logErrorType2) {\n  logErrorType2[\"info\"] = \"info\";\n  logErrorType2[\"warning\"] = \"warning\";\n  logErrorType2[\"error\"] = \"error\";\n})(logErrorType || (logErrorType = {}));\nfunction getLocalTime() {\n  const date = new Date();\n  const h = date.getHours() < 10 ? `0${date.getHours()}` : date.getHours();\n  const m = date.getMinutes() < 10 ? `0${date.getMinutes()}` : date.getMinutes();\n  const s = date.getSeconds() < 10 ? `0${date.getSeconds()}` : date.getSeconds();\n  return `${h}:${m}:${s}`;\n}\nfunction createLinkMark(attrs) {\n  return `#link#${JSON.stringify(attrs)}#link#`;\n}\nfunction getLinkMarks(value) {\n  const linkRegexp = /#link#(.+)#link#/g;\n  const result = [];\n  let indexObj;\n  indexObj = linkRegexp.exec(value);\n  while (indexObj) {\n    const node = document.createElement(\"a\");\n    const attrs = JSON.parse(indexObj[1]);\n    const keyAndValues = Object.entries(attrs);\n    for (const [_key, _value] of keyAndValues) {\n      node.setAttribute(_key, _value);\n    }\n    node.className = \"editor_custom_link\";\n    node.innerHTML = \"logDownload\";\n    result.push({\n      start: indexObj.index,\n      end: indexObj.index + indexObj[0].length,\n      node\n    });\n    indexObj = linkRegexp.exec(value);\n  }\n  return result;\n}\nfunction createLogMark(text = \"\", type = \"info\") {\n  return `#log<${type}>log#${text}#log<${type}>log#`;\n}\nfunction getLogMark(value) {\n  const result = [];\n  function match() {\n    const logRegexp = /#log<(\\w*)>log#((.|\\r\\n|\\n)*?)#log<(\\w*)>log#/g;\n    let indexObj;\n    indexObj = logRegexp.exec(value);\n    while (indexObj) {\n      const text = indexObj[0].replace(/\\r\\n/g, \"\\n\");\n      const textArr = text.split(\"\\n\");\n      const content = indexObj[2].replace(/\\r\\n/g, \"\\n\");\n      const contentArr = content.split(\"\\n\");\n      const node = document.createElement(\"span\");\n      const type = indexObj[1];\n      node.className = `c-editor--log__${type}`;\n      let offset = 0;\n      for (let i = 0; i < textArr.length; i++) {\n        const textItem = textArr[i];\n        const contentItem = contentArr[i];\n        const cloneNode = node.cloneNode(false);\n        cloneNode.innerText = contentItem;\n        result.push({\n          start: indexObj.index + offset,\n          end: indexObj.index + offset + textItem.length,\n          node: cloneNode\n        });\n        offset = offset + textItem.length + 1;\n      }\n      indexObj = logRegexp.exec(value);\n    }\n  }\n  match();\n  return result;\n}\nfunction createLog(log, type) {\n  const now = getLocalTime();\n  return `[${now}] <${type}> ${log}`;\n}\nfunction createTitle(title, symbolLength, symbol) {\n  const arr = new Array(Math.max(symbolLength || 15, 5));\n  const wrapText = arr.join(symbol || \"=\");\n  return `${wrapText}${title}${wrapText}`;\n}\nconst startRegex = [\n  {\n    regex: /(\\[.*?\\])([ \\t]*)(<error>[ \\t])(.+)/,\n    token: [\"tag\", \"\", \"error.strong\", \"error.strong\"],\n    sol: true\n  },\n  {\n    regex: /(\\[.*?\\])([ \\t]*)(<info>)(.+)(.?)/,\n    token: [\"tag\", \"\", \"bracket\", \"bracket\", \"hr\"],\n    sol: true\n  },\n  {\n    regex: /(\\[.*?\\])([ \\t]*)(<warning>)(.+)(.?)/,\n    token: [\"tag\", \"\", \"comment\", \"comment\", \"hr\"],\n    sol: true\n  }\n];\nCodeMirror$1.defineSimpleMode(\"fclog\", {\n  start: [\n    ...startRegex,\n    {\n      regex: /.*/,\n      token: \"hr\"\n    }\n  ],\n  error: [\n    ...startRegex,\n    {\n      regex: /.*/,\n      token: \"error.strong\"\n    }\n  ],\n  info: [\n    ...startRegex,\n    {\n      regex: /.*/,\n      token: \"bracket\"\n    }\n  ],\n  warning: [\n    ...startRegex,\n    {\n      regex: /.*\\[/,\n      token: \"comment\"\n    }\n  ]\n});\nCodeMirror$1.defineSimpleMode(\"log\", {\n  start: [\n    {\n      regex: /^[=]+[^=]*[=]+/,\n      token: \"strong\"\n    },\n    {\n      regex: /([^\\w])([A-Z][\\w]*)/,\n      token: [\"\", \"string\"]\n    },\n    {\n      regex: /(^[A-Z][\\w]*)/,\n      token: \"string\"\n    }\n  ]\n});\nconst _sfc_main$1 = defineComponent({\n  name: \"CodemirrorFclog\",\n  props: {\n    value: {\n      type: String,\n      default: \"\"\n    },\n    name: {\n      type: String,\n      default: `cm-textarea-${+new Date()}`\n    },\n    options: {\n      type: Object,\n      default: () => ({})\n    },\n    cminstance: {\n      type: Object,\n      default: () => ({})\n    },\n    placeholder: {\n      type: String,\n      default: \"\"\n    }\n  },\n  emits: [\"update:cminstance\", \"ready\"],\n  setup(props, { emit }) {\n    const textarea = ref();\n    const _cminstance = ref(null);\n    const renderTextMark = (cminstance = props.cminstance) => {\n      const marks = cminstance.getAllMarks();\n      marks.forEach((mark) => mark.clear());\n      const value = cminstance.getValue();\n      const linkMarks = [].concat(getLinkMarks(value)).concat(getLogMark(value));\n      for (let _i = 0; _i < linkMarks.length; _i++) {\n        const mark = linkMarks[_i];\n        cminstance.markText(cminstance.posFromIndex(mark.start), cminstance.posFromIndex(mark.end), { replacedWith: mark.node });\n      }\n    };\n    const initialize = () => {\n      var _a;\n      _cminstance.value = markRaw(CodeMirror$1.fromTextArea(textarea.value, props.options));\n      emit(\"update:cminstance\", unref(_cminstance));\n      (_a = _cminstance.value) == null ? void 0 : _a.on(\"change\", renderTextMark);\n    };\n    watch(() => props.cminstance, (val) => {\n      var _a;\n      if (val) {\n        renderTextMark(props.cminstance);\n        (_a = props.cminstance) == null ? void 0 : _a.setValue(props.value);\n        emit(\"ready\", _cminstance);\n      }\n    }, { deep: true, immediate: true });\n    onMounted(() => {\n      initialize();\n    });\n    return {\n      initialize,\n      textarea\n    };\n  }\n});\nconst _hoisted_1 = [\"name\", \"placeholder\"];\nfunction _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {\n  return openBlock(), createElementBlock(\"textarea\", {\n    ref: \"textarea\",\n    name: _ctx.$props.name,\n    placeholder: _ctx.$props.placeholder\n  }, null, 8, _hoisted_1);\n}\nvar FcLog = /* @__PURE__ */ _export_sfc(_sfc_main$1, [[\"render\", _sfc_render]]);\nconst componentEventMap = {\n  \"update:value\": (value) => value,\n  change: (value, cm) => ({ value, cm }),\n  input: (value) => value,\n  ready: (cm) => cm\n};\nconst cmEvts = [\n  \"changes\",\n  \"scroll\",\n  \"beforeChange\",\n  \"cursorActivity\",\n  \"keyHandled\",\n  \"inputRead\",\n  \"electricInput\",\n  \"beforeSelectionChange\",\n  \"viewportChange\",\n  \"swapDoc\",\n  \"gutterClick\",\n  \"gutterContextMenu\",\n  \"focus\",\n  \"blur\",\n  \"refresh\",\n  \"optionChange\",\n  \"scrollCursorIntoView\",\n  \"update\"\n];\nconst getCmEvts = () => {\n  const result = {};\n  cmEvts.forEach((name) => {\n    result[name] = (...args) => args;\n  });\n  return result;\n};\nconst emitOptions = __spreadValues(__spreadValues({}, componentEventMap), getCmEvts());\nconst DEFAULT_OPTIONS = {\n  mode: \"text\",\n  theme: \"default\",\n  lineNumbers: true,\n  smartIndent: true,\n  indentUnit: 2\n};\nfunction scrollToEnd(cm) {\n  Promise.resolve().then(() => {\n    const nowScrollInfo = cm.getScrollInfo();\n    cm.scrollTo(nowScrollInfo.left, nowScrollInfo.height);\n  });\n}\nconst useEvents = ({\n  props,\n  cminstance,\n  emit,\n  internalInstance,\n  content\n}) => {\n  const realCm = computed(() => {\n    var _a;\n    return props.merge ? (_a = unref(cminstance)) == null ? void 0 : _a.editor() : unref(cminstance);\n  });\n  const getBindEvents = () => {\n    const evts = [];\n    Object.keys(internalInstance == null ? void 0 : internalInstance.vnode.props).forEach((v) => {\n      if (v.startsWith(\"on\")) {\n        const e = v.replace(v[2], v[2].toLowerCase()).slice(2);\n        !componentEventMap[e] && evts.push(e);\n      }\n    });\n    return evts;\n  };\n  const listenerEvents = () => {\n    realCm.value.on(\"change\", (cm) => {\n      const currentVal = cm.getValue();\n      if (currentVal === content.value)\n        return;\n      content.value = currentVal;\n      content.value && emit(\"update:value\", content.value || \"\");\n      content.value && emit(\"input\", content.value || \"\");\n      Promise.resolve().then(() => {\n        emit(\"change\", content.value, cm);\n      });\n      props.keepCursorInEnd && scrollToEnd(cm);\n    });\n    const tmpEvents = {};\n    const bindEvts = getBindEvents();\n    bindEvts.filter((e) => !tmpEvents[e] && (tmpEvents[e] = true)).forEach((event) => {\n      realCm.value.on(event, (...args) => {\n        emit(event, ...args);\n      });\n    });\n  };\n  return {\n    listenerEvents\n  };\n};\nfunction useViewControl({\n  props,\n  cminstance,\n  presetRef\n}) {\n  const containerWidth = ref(null);\n  const containerHeight = ref(null);\n  const realCm = computed(() => {\n    var _a;\n    return props.merge ? (_a = unref(cminstance)) == null ? void 0 : _a.editor() : unref(cminstance);\n  });\n  const refresh = () => {\n    nextTick(() => {\n      var _a;\n      (_a = realCm.value) == null ? void 0 : _a.refresh();\n    });\n  };\n  const resize = (width = props.width, height = props.height) => {\n    var _a;\n    containerWidth.value = String(width).replace(\"px\", \"\");\n    containerHeight.value = String(height).replace(\"px\", \"\");\n    const cmHeight = containerHeight.value;\n    (_a = realCm.value) == null ? void 0 : _a.setSize(containerWidth.value, cmHeight);\n  };\n  const destroy = () => {\n    var _a;\n    const element = (_a = realCm.value) == null ? void 0 : _a.getWrapperElement();\n    element == null ? void 0 : element.remove();\n  };\n  const reload = () => {\n    var _a, _b, _c;\n    const history = (_a = realCm.value) == null ? void 0 : _a.getDoc().getHistory();\n    (_b = presetRef.value) == null ? void 0 : _b.initialize();\n    destroy();\n    (_c = realCm.value) == null ? void 0 : _c.getDoc().setHistory(history);\n  };\n  const isStyleChaotic = () => {\n    const gutterEl = document.querySelector(\".CodeMirror-gutters\");\n    const gutterElLeft = gutterEl == null ? void 0 : gutterEl.style.left.replace(\"px\", \"\");\n    return gutterElLeft !== \"0\";\n  };\n  const reviseStyle = () => {\n    refresh();\n    if (!isStyleChaotic())\n      return;\n    const timer = setInterval(() => {\n      isStyleChaotic() ? refresh() : clearInterval(timer);\n    }, 60);\n    const clearTimer = setTimeout(() => {\n      clearInterval(timer);\n      clearTimeout(clearTimer);\n    }, 400);\n  };\n  return {\n    reload,\n    refresh,\n    resize,\n    destroy,\n    containerHeight,\n    reviseStyle\n  };\n}\nconst _sfc_main = /* @__PURE__ */ defineComponent({\n  props: {\n    value: {\n      type: String,\n      default: \"\"\n    },\n    options: {\n      type: Object,\n      default: () => DEFAULT_OPTIONS\n    },\n    globalOptions: {\n      type: Object,\n      default: () => DEFAULT_OPTIONS\n    },\n    placeholder: {\n      type: String,\n      default: \"\"\n    },\n    border: {\n      type: Boolean,\n      default: false\n    },\n    width: {\n      type: [String, Number],\n      default: null\n    },\n    height: {\n      type: [String, Number],\n      default: null\n    },\n    originalStyle: {\n      type: Boolean,\n      default: false\n    },\n    keepCursorInEnd: {\n      type: Boolean,\n      default: false\n    },\n    merge: {\n      type: Boolean,\n      default: false\n    },\n    name: {\n      type: String,\n      default: \"\"\n    },\n    marker: {\n      type: Function,\n      default: () => null\n    },\n    unseenLines: {\n      type: Array,\n      default: () => []\n    }\n  },\n  emits: emitOptions,\n  setup(__props, { expose, emit }) {\n    var _a, _b;\n    const props = __props;\n    if (typeof Object.assign !== \"function\") {\n      Object.defineProperty(Object, \"assign\", {\n        value(target, varArgs) {\n          if (target == null) {\n            throw new TypeError(\"Cannot convert undefined or null to object\");\n          }\n          const to = Object(target);\n          for (let index2 = 1; index2 < arguments.length; index2++) {\n            const nextSource = arguments[index2];\n            if (nextSource != null) {\n              for (const nextKey in nextSource) {\n                if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {\n                  to[nextKey] = nextSource[nextKey];\n                }\n              }\n            }\n          }\n          return to;\n        },\n        writable: true,\n        configurable: true\n      });\n    }\n    const cminstance = ref(null);\n    const content = ref(\"\");\n    const presetModeName = shallowRef(Default);\n    const cmOptions = ref(__spreadValues(__spreadValues(__spreadValues({}, DEFAULT_OPTIONS), props.globalOptions), props.options));\n    const internalInstance = getCurrentInstance();\n    const instanceName = props.name || ((_b = (_a = internalInstance == null ? void 0 : internalInstance.parent) == null ? void 0 : _a.type) == null ? void 0 : _b.name) || void 0;\n    const presetRef = ref(null);\n    const realCminstance = computed(() => {\n      var _a2;\n      return props.merge ? (_a2 = unref(cminstance)) == null ? void 0 : _a2.editor() : unref(cminstance);\n    });\n    const { refresh, resize, destroy, containerHeight, reviseStyle } = useViewControl({\n      props,\n      cminstance,\n      presetRef\n    });\n    const { listenerEvents } = useEvents({\n      props,\n      cminstance,\n      emit,\n      internalInstance,\n      content\n    });\n    const unseenLineMarkers = () => {\n      if (props.unseenLines !== void 0 && props.marker !== void 0) {\n        props.unseenLines.forEach((line) => {\n          var _a2, _b2;\n          const info = (_a2 = cminstance.value) == null ? void 0 : _a2.lineInfo(line);\n          (_b2 = cminstance.value) == null ? void 0 : _b2.setGutterMarker(line, \"breakpoints\", (info == null ? void 0 : info.gutterMarkers) ? null : props.marker());\n        });\n      }\n    };\n    const onCodeChange = (newVal) => {\n      var _a2, _b2;\n      const CM_VALUE = (_a2 = cminstance.value) == null ? void 0 : _a2.getValue();\n      if (newVal !== CM_VALUE) {\n        (_b2 = cminstance.value) == null ? void 0 : _b2.setValue(newVal);\n        content.value = newVal;\n        reviseStyle();\n      }\n      unseenLineMarkers();\n    };\n    const ready = () => {\n      listenerEvents();\n      unseenLineMarkers();\n      resize(props.width, props.height);\n      emit(\"ready\", cminstance.value);\n      watch([() => props.width, () => props.height], ([width, height]) => {\n        resize(width, height);\n      }, { deep: true });\n    };\n    const handlePresetModeName = () => {\n      if (props.options.mode === \"fclog\" || props.options.mode === \"log\") {\n        presetModeName.value = FcLog;\n        return;\n      }\n      if (props.merge) {\n        presetModeName.value = Merge;\n        return;\n      }\n      presetModeName.value = Default;\n    };\n    watch(() => props.options, (val) => {\n      var _a2;\n      for (const key in props.options) {\n        (_a2 = realCminstance.value) == null ? void 0 : _a2.setOption(key, unref(val[key]));\n      }\n    }, { deep: true });\n    watch(() => props.value, (val) => {\n      onCodeChange(val);\n    });\n    watch(() => props.placeholder, (val) => {\n      var _a2;\n      (_a2 = realCminstance.value) == null ? void 0 : _a2.setOption(\"placeholder\", val);\n    });\n    watch(() => props.merge, (val) => {\n      handlePresetModeName();\n    }, { immediate: true });\n    onBeforeUnmount(() => {\n      destroy();\n    });\n    expose({\n      cminstance,\n      resize,\n      refresh,\n      destroy\n    });\n    return (_ctx, _cache) => {\n      return openBlock(), createElementBlock(\"div\", {\n        class: normalizeClass([\"codemirror-container\", {\n          merge: _ctx.$props.merge,\n          bordered: _ctx.$props.border || _ctx.$props.merge && !props.originalStyle,\n          \"width-auto\": !_ctx.$props.width || _ctx.$props.width == \"100%\",\n          \"height-auto\": !_ctx.$props.height || _ctx.$props.height == \"100%\",\n          \"original-style\": props.originalStyle\n        }]),\n        style: normalizeStyle({\n          height: unref(containerHeight) + \"px\"\n        })\n      }, [\n        (openBlock(), createBlock(resolveDynamicComponent(unref(presetModeName)), mergeProps({\n          ref_key: \"presetRef\",\n          ref: presetRef,\n          cminstance: cminstance.value,\n          \"onUpdate:cminstance\": _cache[0] || (_cache[0] = ($event) => cminstance.value = $event),\n          style: { \"height\": \"100%\" }\n        }, __spreadProps(__spreadValues(__spreadValues({}, _ctx.$props), _ctx.$attrs), {\n          options: cmOptions.value,\n          name: unref(instanceName),\n          content: content.value\n        }), { onReady: ready }), null, 16, [\"cminstance\"]))\n      ], 6);\n    };\n  }\n});\nvar index = \"\";\nconst install = (app, config) => {\n  if (config) {\n    if (config.options) {\n      _sfc_main.props.globalOptions.default = () => config.options;\n    }\n  }\n  app.component((config == null ? void 0 : config.componentName) || \"Codemirror\", _sfc_main);\n  return app;\n};\nconst CodeMirror = window.CodeMirror || CodeMirror$1;\nconst GlobalCmComponent = install;\nfunction styleInject(css,ref){if(ref===void 0){ref={}}var insertAt=ref.insertAt;if(!css||typeof document===\"undefined\"){return}var head=document.head||document.getElementsByTagName(\"head\")[0];var style=document.createElement(\"style\");style.type=\"text/css\";if(insertAt===\"top\"){if(head.firstChild){head.insertBefore(style,head.firstChild)}else{head.appendChild(style)}}else{head.appendChild(style)}if(style.styleSheet){style.styleSheet.cssText=css}else{style.appendChild(document.createTextNode(css))}};styleInject(`.codemirror-container {\n  position: relative;\n  display: inline-block;\n  height: 100%;\n  width: fit-content;\n  font-size: 12px;\n  overflow: hidden;\n}\n.codemirror-container.bordered {\n  border-radius: 4px;\n  border: 1px solid #dddddd;\n}\n.codemirror-container.width-auto {\n  width: 100%;\n}\n.codemirror-container.height-auto {\n  height: 100%;\n}\n.codemirror-container.height-auto .CodeMirror,\n.codemirror-container.height-auto .cm-s-default {\n  height: 100% !important;\n}\n.codemirror-container .editor_custom_link {\n  cursor: pointer;\n  color: #1474f1;\n  text-decoration: underline;\n}\n.codemirror-container .editor_custom_link:hover {\n  color: #04b4fa;\n}\n.codemirror-container:not(.original-style) .CodeMirror-lines .CodeMirror-placeholder.CodeMirror-line-like {\n  color: #666;\n}\n.codemirror-container:not(.original-style) .CodeMirror,\n.codemirror-container:not(.original-style) .CodeMirror-merge-pane {\n  height: 100%;\n  font-family: consolas !important;\n}\n.codemirror-container:not(.original-style) .CodeMirror-merge,\n.codemirror-container:not(.original-style) .CodeMirror-merge-right .CodeMirror {\n  height: 100%;\n  border: none !important;\n}\n.codemirror-container:not(.original-style) .c-editor--log__error {\n  color: #bb0606;\n  font-weight: bold;\n}\n.codemirror-container:not(.original-style) .c-editor--log__info {\n  color: #333333;\n  font-weight: bold;\n}\n.codemirror-container:not(.original-style) .c-editor--log__warning {\n  color: #ee9900;\n}\n.codemirror-container:not(.original-style) .c-editor--log__success {\n  color: #669600;\n}\n.codemirror-container:not(.original-style) .cm-header,\n.codemirror-container:not(.original-style) .cm-strong {\n  font-weight: bold;\n}\n`);\nexport { CodeMirror, GlobalCmComponent, _sfc_main as VueCodemirror, createLinkMark, createLog, createLogMark, createTitle, _sfc_main as default, getLinkMarks, getLocalTime, getLogMark, logErrorType };\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n  \"use strict\";\n\n  var Pos = CodeMirror.Pos;\n  function cmp(a, b) { return a.line - b.line || a.ch - b.ch; }\n\n  var nameStartChar = \"A-Z_a-z\\\\u00C0-\\\\u00D6\\\\u00D8-\\\\u00F6\\\\u00F8-\\\\u02FF\\\\u0370-\\\\u037D\\\\u037F-\\\\u1FFF\\\\u200C-\\\\u200D\\\\u2070-\\\\u218F\\\\u2C00-\\\\u2FEF\\\\u3001-\\\\uD7FF\\\\uF900-\\\\uFDCF\\\\uFDF0-\\\\uFFFD\";\n  var nameChar = nameStartChar + \"\\-\\:\\.0-9\\\\u00B7\\\\u0300-\\\\u036F\\\\u203F-\\\\u2040\";\n  var xmlTagStart = new RegExp(\"<(/?)([\" + nameStartChar + \"][\" + nameChar + \"]*)\", \"g\");\n\n  function Iter(cm, line, ch, range) {\n    this.line = line; this.ch = ch;\n    this.cm = cm; this.text = cm.getLine(line);\n    this.min = range ? Math.max(range.from, cm.firstLine()) : cm.firstLine();\n    this.max = range ? Math.min(range.to - 1, cm.lastLine()) : cm.lastLine();\n  }\n\n  function tagAt(iter, ch) {\n    var type = iter.cm.getTokenTypeAt(Pos(iter.line, ch));\n    return type && /\\btag\\b/.test(type);\n  }\n\n  function nextLine(iter) {\n    if (iter.line >= iter.max) return;\n    iter.ch = 0;\n    iter.text = iter.cm.getLine(++iter.line);\n    return true;\n  }\n  function prevLine(iter) {\n    if (iter.line <= iter.min) return;\n    iter.text = iter.cm.getLine(--iter.line);\n    iter.ch = iter.text.length;\n    return true;\n  }\n\n  function toTagEnd(iter) {\n    for (;;) {\n      var gt = iter.text.indexOf(\">\", iter.ch);\n      if (gt == -1) { if (nextLine(iter)) continue; else return; }\n      if (!tagAt(iter, gt + 1)) { iter.ch = gt + 1; continue; }\n      var lastSlash = iter.text.lastIndexOf(\"/\", gt);\n      var selfClose = lastSlash > -1 && !/\\S/.test(iter.text.slice(lastSlash + 1, gt));\n      iter.ch = gt + 1;\n      return selfClose ? \"selfClose\" : \"regular\";\n    }\n  }\n  function toTagStart(iter) {\n    for (;;) {\n      var lt = iter.ch ? iter.text.lastIndexOf(\"<\", iter.ch - 1) : -1;\n      if (lt == -1) { if (prevLine(iter)) continue; else return; }\n      if (!tagAt(iter, lt + 1)) { iter.ch = lt; continue; }\n      xmlTagStart.lastIndex = lt;\n      iter.ch = lt;\n      var match = xmlTagStart.exec(iter.text);\n      if (match && match.index == lt) return match;\n    }\n  }\n\n  function toNextTag(iter) {\n    for (;;) {\n      xmlTagStart.lastIndex = iter.ch;\n      var found = xmlTagStart.exec(iter.text);\n      if (!found) { if (nextLine(iter)) continue; else return; }\n      if (!tagAt(iter, found.index + 1)) { iter.ch = found.index + 1; continue; }\n      iter.ch = found.index + found[0].length;\n      return found;\n    }\n  }\n  function toPrevTag(iter) {\n    for (;;) {\n      var gt = iter.ch ? iter.text.lastIndexOf(\">\", iter.ch - 1) : -1;\n      if (gt == -1) { if (prevLine(iter)) continue; else return; }\n      if (!tagAt(iter, gt + 1)) { iter.ch = gt; continue; }\n      var lastSlash = iter.text.lastIndexOf(\"/\", gt);\n      var selfClose = lastSlash > -1 && !/\\S/.test(iter.text.slice(lastSlash + 1, gt));\n      iter.ch = gt + 1;\n      return selfClose ? \"selfClose\" : \"regular\";\n    }\n  }\n\n  function findMatchingClose(iter, tag) {\n    var stack = [];\n    for (;;) {\n      var next = toNextTag(iter), end, startLine = iter.line, startCh = iter.ch - (next ? next[0].length : 0);\n      if (!next || !(end = toTagEnd(iter))) return;\n      if (end == \"selfClose\") continue;\n      if (next[1]) { // closing tag\n        for (var i = stack.length - 1; i >= 0; --i) if (stack[i] == next[2]) {\n          stack.length = i;\n          break;\n        }\n        if (i < 0 && (!tag || tag == next[2])) return {\n          tag: next[2],\n          from: Pos(startLine, startCh),\n          to: Pos(iter.line, iter.ch)\n        };\n      } else { // opening tag\n        stack.push(next[2]);\n      }\n    }\n  }\n  function findMatchingOpen(iter, tag) {\n    var stack = [];\n    for (;;) {\n      var prev = toPrevTag(iter);\n      if (!prev) return;\n      if (prev == \"selfClose\") { toTagStart(iter); continue; }\n      var endLine = iter.line, endCh = iter.ch;\n      var start = toTagStart(iter);\n      if (!start) return;\n      if (start[1]) { // closing tag\n        stack.push(start[2]);\n      } else { // opening tag\n        for (var i = stack.length - 1; i >= 0; --i) if (stack[i] == start[2]) {\n          stack.length = i;\n          break;\n        }\n        if (i < 0 && (!tag || tag == start[2])) return {\n          tag: start[2],\n          from: Pos(iter.line, iter.ch),\n          to: Pos(endLine, endCh)\n        };\n      }\n    }\n  }\n\n  CodeMirror.registerHelper(\"fold\", \"xml\", function(cm, start) {\n    var iter = new Iter(cm, start.line, 0);\n    for (;;) {\n      var openTag = toNextTag(iter)\n      if (!openTag || iter.line != start.line) return\n      var end = toTagEnd(iter)\n      if (!end) return\n      if (!openTag[1] && end != \"selfClose\") {\n        var startPos = Pos(iter.line, iter.ch);\n        var endPos = findMatchingClose(iter, openTag[2]);\n        return endPos && cmp(endPos.from, startPos) > 0 ? {from: startPos, to: endPos.from} : null\n      }\n    }\n  });\n  CodeMirror.findMatchingTag = function(cm, pos, range) {\n    var iter = new Iter(cm, pos.line, pos.ch, range);\n    if (iter.text.indexOf(\">\") == -1 && iter.text.indexOf(\"<\") == -1) return;\n    var end = toTagEnd(iter), to = end && Pos(iter.line, iter.ch);\n    var start = end && toTagStart(iter);\n    if (!end || !start || cmp(iter, pos) > 0) return;\n    var here = {from: Pos(iter.line, iter.ch), to: to, tag: start[2]};\n    if (end == \"selfClose\") return {open: here, close: null, at: \"open\"};\n\n    if (start[1]) { // closing tag\n      return {open: findMatchingOpen(iter, start[2]), close: here, at: \"close\"};\n    } else { // opening tag\n      iter = new Iter(cm, to.line, to.ch, range);\n      return {open: here, close: findMatchingClose(iter, start[2]), at: \"open\"};\n    }\n  };\n\n  CodeMirror.findEnclosingTag = function(cm, pos, range, tag) {\n    var iter = new Iter(cm, pos.line, pos.ch, range);\n    for (;;) {\n      var open = findMatchingOpen(iter, tag);\n      if (!open) break;\n      var forward = new Iter(cm, pos.line, pos.ch, range);\n      var close = findMatchingClose(forward, open.tag);\n      if (close) return {open: open, close: close};\n    }\n  };\n\n  // Used by addon/edit/closetag.js\n  CodeMirror.scanForClosingTag = function(cm, pos, name, end) {\n    var iter = new Iter(cm, pos.line, pos.ch, end ? {from: 0, to: end} : null);\n    return findMatchingClose(iter, name);\n  };\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n// declare global: diff_match_patch, DIFF_INSERT, DIFF_DELETE, DIFF_EQUAL\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\")); // Note non-packaged dependency diff_match_patch\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\", \"diff_match_patch\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n  \"use strict\";\n  var Pos = CodeMirror.Pos;\n  var svgNS = \"http://www.w3.org/2000/svg\";\n\n  function DiffView(mv, type) {\n    this.mv = mv;\n    this.type = type;\n    this.classes = type == \"left\"\n      ? {chunk: \"CodeMirror-merge-l-chunk\",\n         start: \"CodeMirror-merge-l-chunk-start\",\n         end: \"CodeMirror-merge-l-chunk-end\",\n         insert: \"CodeMirror-merge-l-inserted\",\n         del: \"CodeMirror-merge-l-deleted\",\n         connect: \"CodeMirror-merge-l-connect\"}\n      : {chunk: \"CodeMirror-merge-r-chunk\",\n         start: \"CodeMirror-merge-r-chunk-start\",\n         end: \"CodeMirror-merge-r-chunk-end\",\n         insert: \"CodeMirror-merge-r-inserted\",\n         del: \"CodeMirror-merge-r-deleted\",\n         connect: \"CodeMirror-merge-r-connect\"};\n  }\n\n  DiffView.prototype = {\n    constructor: DiffView,\n    init: function(pane, orig, options) {\n      this.edit = this.mv.edit;\n      ;(this.edit.state.diffViews || (this.edit.state.diffViews = [])).push(this);\n      this.orig = CodeMirror(pane, copyObj({value: orig, readOnly: !this.mv.options.allowEditingOriginals}, copyObj(options)));\n      if (this.mv.options.connect == \"align\") {\n        if (!this.edit.state.trackAlignable) this.edit.state.trackAlignable = new TrackAlignable(this.edit)\n        this.orig.state.trackAlignable = new TrackAlignable(this.orig)\n      }\n      this.lockButton.title = this.edit.phrase(\"Toggle locked scrolling\");\n      this.lockButton.setAttribute(\"aria-label\", this.lockButton.title);\n\n      this.orig.state.diffViews = [this];\n      var classLocation = options.chunkClassLocation || \"background\";\n      if (Object.prototype.toString.call(classLocation) != \"[object Array]\") classLocation = [classLocation]\n      this.classes.classLocation = classLocation\n\n      this.diff = getDiff(asString(orig), asString(options.value), this.mv.options.ignoreWhitespace);\n      this.chunks = getChunks(this.diff);\n      this.diffOutOfDate = this.dealigned = false;\n      this.needsScrollSync = null\n\n      this.showDifferences = options.showDifferences !== false;\n    },\n    registerEvents: function(otherDv) {\n      this.forceUpdate = registerUpdate(this);\n      setScrollLock(this, true, false);\n      registerScroll(this, otherDv);\n    },\n    setShowDifferences: function(val) {\n      val = val !== false;\n      if (val != this.showDifferences) {\n        this.showDifferences = val;\n        this.forceUpdate(\"full\");\n      }\n    }\n  };\n\n  function ensureDiff(dv) {\n    if (dv.diffOutOfDate) {\n      dv.diff = getDiff(dv.orig.getValue(), dv.edit.getValue(), dv.mv.options.ignoreWhitespace);\n      dv.chunks = getChunks(dv.diff);\n      dv.diffOutOfDate = false;\n      CodeMirror.signal(dv.edit, \"updateDiff\", dv.diff);\n    }\n  }\n\n  var updating = false;\n  function registerUpdate(dv) {\n    var edit = {from: 0, to: 0, marked: []};\n    var orig = {from: 0, to: 0, marked: []};\n    var debounceChange, updatingFast = false;\n    function update(mode) {\n      updating = true;\n      updatingFast = false;\n      if (mode == \"full\") {\n        if (dv.svg) clear(dv.svg);\n        if (dv.copyButtons) clear(dv.copyButtons);\n        clearMarks(dv.edit, edit.marked, dv.classes);\n        clearMarks(dv.orig, orig.marked, dv.classes);\n        edit.from = edit.to = orig.from = orig.to = 0;\n      }\n      ensureDiff(dv);\n      if (dv.showDifferences) {\n        updateMarks(dv.edit, dv.diff, edit, DIFF_INSERT, dv.classes);\n        updateMarks(dv.orig, dv.diff, orig, DIFF_DELETE, dv.classes);\n      }\n\n      if (dv.mv.options.connect == \"align\")\n        alignChunks(dv);\n      makeConnections(dv);\n      if (dv.needsScrollSync != null) syncScroll(dv, dv.needsScrollSync)\n\n      updating = false;\n    }\n    function setDealign(fast) {\n      if (updating) return;\n      dv.dealigned = true;\n      set(fast);\n    }\n    function set(fast) {\n      if (updating || updatingFast) return;\n      clearTimeout(debounceChange);\n      if (fast === true) updatingFast = true;\n      debounceChange = setTimeout(update, fast === true ? 20 : 250);\n    }\n    function change(_cm, change) {\n      if (!dv.diffOutOfDate) {\n        dv.diffOutOfDate = true;\n        edit.from = edit.to = orig.from = orig.to = 0;\n      }\n      // Update faster when a line was added/removed\n      setDealign(change.text.length - 1 != change.to.line - change.from.line);\n    }\n    function swapDoc() {\n      dv.diffOutOfDate = true;\n      dv.dealigned = true;\n      update(\"full\");\n    }\n    dv.edit.on(\"change\", change);\n    dv.orig.on(\"change\", change);\n    dv.edit.on(\"swapDoc\", swapDoc);\n    dv.orig.on(\"swapDoc\", swapDoc);\n    if (dv.mv.options.connect == \"align\") {\n      CodeMirror.on(dv.edit.state.trackAlignable, \"realign\", setDealign)\n      CodeMirror.on(dv.orig.state.trackAlignable, \"realign\", setDealign)\n    }\n    dv.edit.on(\"viewportChange\", function() { set(false); });\n    dv.orig.on(\"viewportChange\", function() { set(false); });\n    update();\n    return update;\n  }\n\n  function registerScroll(dv, otherDv) {\n    dv.edit.on(\"scroll\", function() {\n      syncScroll(dv, true) && makeConnections(dv);\n    });\n    dv.orig.on(\"scroll\", function() {\n      syncScroll(dv, false) && makeConnections(dv);\n      if (otherDv) syncScroll(otherDv, true) && makeConnections(otherDv);\n    });\n  }\n\n  function syncScroll(dv, toOrig) {\n    // Change handler will do a refresh after a timeout when diff is out of date\n    if (dv.diffOutOfDate) {\n      if (dv.lockScroll && dv.needsScrollSync == null) dv.needsScrollSync = toOrig\n      return false\n    }\n    dv.needsScrollSync = null\n    if (!dv.lockScroll) return true;\n    var editor, other, now = +new Date;\n    if (toOrig) { editor = dv.edit; other = dv.orig; }\n    else { editor = dv.orig; other = dv.edit; }\n    // Don't take action if the position of this editor was recently set\n    // (to prevent feedback loops)\n    if (editor.state.scrollSetBy == dv && (editor.state.scrollSetAt || 0) + 250 > now) return false;\n\n    var sInfo = editor.getScrollInfo();\n    if (dv.mv.options.connect == \"align\") {\n      targetPos = sInfo.top;\n    } else {\n      var halfScreen = .5 * sInfo.clientHeight, midY = sInfo.top + halfScreen;\n      var mid = editor.lineAtHeight(midY, \"local\");\n      var around = chunkBoundariesAround(dv.chunks, mid, toOrig);\n      var off = getOffsets(editor, toOrig ? around.edit : around.orig);\n      var offOther = getOffsets(other, toOrig ? around.orig : around.edit);\n      var ratio = (midY - off.top) / (off.bot - off.top);\n      var targetPos = (offOther.top - halfScreen) + ratio * (offOther.bot - offOther.top);\n\n      var botDist, mix;\n      // Some careful tweaking to make sure no space is left out of view\n      // when scrolling to top or bottom.\n      if (targetPos > sInfo.top && (mix = sInfo.top / halfScreen) < 1) {\n        targetPos = targetPos * mix + sInfo.top * (1 - mix);\n      } else if ((botDist = sInfo.height - sInfo.clientHeight - sInfo.top) < halfScreen) {\n        var otherInfo = other.getScrollInfo();\n        var botDistOther = otherInfo.height - otherInfo.clientHeight - targetPos;\n        if (botDistOther > botDist && (mix = botDist / halfScreen) < 1)\n          targetPos = targetPos * mix + (otherInfo.height - otherInfo.clientHeight - botDist) * (1 - mix);\n      }\n    }\n\n    other.scrollTo(sInfo.left, targetPos);\n    other.state.scrollSetAt = now;\n    other.state.scrollSetBy = dv;\n    return true;\n  }\n\n  function getOffsets(editor, around) {\n    var bot = around.after;\n    if (bot == null) bot = editor.lastLine() + 1;\n    return {top: editor.heightAtLine(around.before || 0, \"local\"),\n            bot: editor.heightAtLine(bot, \"local\")};\n  }\n\n  function setScrollLock(dv, val, action) {\n    dv.lockScroll = val;\n    if (val && action != false) syncScroll(dv, DIFF_INSERT) && makeConnections(dv);\n    (val ? CodeMirror.addClass : CodeMirror.rmClass)(dv.lockButton, \"CodeMirror-merge-scrolllock-enabled\");\n  }\n\n  // Updating the marks for editor content\n\n  function removeClass(editor, line, classes) {\n    var locs = classes.classLocation\n    for (var i = 0; i < locs.length; i++) {\n      editor.removeLineClass(line, locs[i], classes.chunk);\n      editor.removeLineClass(line, locs[i], classes.start);\n      editor.removeLineClass(line, locs[i], classes.end);\n    }\n  }\n\n  function clearMarks(editor, arr, classes) {\n    for (var i = 0; i < arr.length; ++i) {\n      var mark = arr[i];\n      if (mark instanceof CodeMirror.TextMarker)\n        mark.clear();\n      else if (mark.parent)\n        removeClass(editor, mark, classes);\n    }\n    arr.length = 0;\n  }\n\n  // FIXME maybe add a margin around viewport to prevent too many updates\n  function updateMarks(editor, diff, state, type, classes) {\n    var vp = editor.getViewport();\n    editor.operation(function() {\n      if (state.from == state.to || vp.from - state.to > 20 || state.from - vp.to > 20) {\n        clearMarks(editor, state.marked, classes);\n        markChanges(editor, diff, type, state.marked, vp.from, vp.to, classes);\n        state.from = vp.from; state.to = vp.to;\n      } else {\n        if (vp.from < state.from) {\n          markChanges(editor, diff, type, state.marked, vp.from, state.from, classes);\n          state.from = vp.from;\n        }\n        if (vp.to > state.to) {\n          markChanges(editor, diff, type, state.marked, state.to, vp.to, classes);\n          state.to = vp.to;\n        }\n      }\n    });\n  }\n\n  function addClass(editor, lineNr, classes, main, start, end) {\n    var locs = classes.classLocation, line = editor.getLineHandle(lineNr);\n    for (var i = 0; i < locs.length; i++) {\n      if (main) editor.addLineClass(line, locs[i], classes.chunk);\n      if (start) editor.addLineClass(line, locs[i], classes.start);\n      if (end) editor.addLineClass(line, locs[i], classes.end);\n    }\n    return line;\n  }\n\n  function markChanges(editor, diff, type, marks, from, to, classes) {\n    var pos = Pos(0, 0);\n    var top = Pos(from, 0), bot = editor.clipPos(Pos(to - 1));\n    var cls = type == DIFF_DELETE ? classes.del : classes.insert;\n    function markChunk(start, end) {\n      var bfrom = Math.max(from, start), bto = Math.min(to, end);\n      for (var i = bfrom; i < bto; ++i)\n        marks.push(addClass(editor, i, classes, true, i == start, i == end - 1));\n      // When the chunk is empty, make sure a horizontal line shows up\n      if (start == end && bfrom == end && bto == end) {\n        if (bfrom)\n          marks.push(addClass(editor, bfrom - 1, classes, false, false, true));\n        else\n          marks.push(addClass(editor, bfrom, classes, false, true, false));\n      }\n    }\n\n    var chunkStart = 0, pending = false;\n    for (var i = 0; i < diff.length; ++i) {\n      var part = diff[i], tp = part[0], str = part[1];\n      if (tp == DIFF_EQUAL) {\n        var cleanFrom = pos.line + (startOfLineClean(diff, i) ? 0 : 1);\n        moveOver(pos, str);\n        var cleanTo = pos.line + (endOfLineClean(diff, i) ? 1 : 0);\n        if (cleanTo > cleanFrom) {\n          if (pending) { markChunk(chunkStart, cleanFrom); pending = false }\n          chunkStart = cleanTo;\n        }\n      } else {\n        pending = true\n        if (tp == type) {\n          var end = moveOver(pos, str, true);\n          var a = posMax(top, pos), b = posMin(bot, end);\n          if (!posEq(a, b))\n            marks.push(editor.markText(a, b, {className: cls}));\n          pos = end;\n        }\n      }\n    }\n    if (pending) markChunk(chunkStart, pos.line + 1);\n  }\n\n  // Updating the gap between editor and original\n\n  function makeConnections(dv) {\n    if (!dv.showDifferences) return;\n\n    if (dv.svg) {\n      clear(dv.svg);\n      var w = dv.gap.offsetWidth;\n      attrs(dv.svg, \"width\", w, \"height\", dv.gap.offsetHeight);\n    }\n    if (dv.copyButtons) clear(dv.copyButtons);\n\n    var vpEdit = dv.edit.getViewport(), vpOrig = dv.orig.getViewport();\n    var outerTop = dv.mv.wrap.getBoundingClientRect().top\n    var sTopEdit = outerTop - dv.edit.getScrollerElement().getBoundingClientRect().top + dv.edit.getScrollInfo().top\n    var sTopOrig = outerTop - dv.orig.getScrollerElement().getBoundingClientRect().top + dv.orig.getScrollInfo().top;\n    for (var i = 0; i < dv.chunks.length; i++) {\n      var ch = dv.chunks[i];\n      if (ch.editFrom <= vpEdit.to && ch.editTo >= vpEdit.from &&\n          ch.origFrom <= vpOrig.to && ch.origTo >= vpOrig.from)\n        drawConnectorsForChunk(dv, ch, sTopOrig, sTopEdit, w);\n    }\n  }\n\n  function getMatchingOrigLine(editLine, chunks) {\n    var editStart = 0, origStart = 0;\n    for (var i = 0; i < chunks.length; i++) {\n      var chunk = chunks[i];\n      if (chunk.editTo > editLine && chunk.editFrom <= editLine) return null;\n      if (chunk.editFrom > editLine) break;\n      editStart = chunk.editTo;\n      origStart = chunk.origTo;\n    }\n    return origStart + (editLine - editStart);\n  }\n\n  // Combines information about chunks and widgets/markers to return\n  // an array of lines, in a single editor, that probably need to be\n  // aligned with their counterparts in the editor next to it.\n  function alignableFor(cm, chunks, isOrig) {\n    var tracker = cm.state.trackAlignable\n    var start = cm.firstLine(), trackI = 0\n    var result = []\n    for (var i = 0;; i++) {\n      var chunk = chunks[i]\n      var chunkStart = !chunk ? 1e9 : isOrig ? chunk.origFrom : chunk.editFrom\n      for (; trackI < tracker.alignable.length; trackI += 2) {\n        var n = tracker.alignable[trackI] + 1\n        if (n <= start) continue\n        if (n <= chunkStart) result.push(n)\n        else break\n      }\n      if (!chunk) break\n      result.push(start = isOrig ? chunk.origTo : chunk.editTo)\n    }\n    return result\n  }\n\n  // Given information about alignable lines in two editors, fill in\n  // the result (an array of three-element arrays) to reflect the\n  // lines that need to be aligned with each other.\n  function mergeAlignable(result, origAlignable, chunks, setIndex) {\n    var rI = 0, origI = 0, chunkI = 0, diff = 0\n    outer: for (;; rI++) {\n      var nextR = result[rI], nextO = origAlignable[origI]\n      if (!nextR && nextO == null) break\n\n      var rLine = nextR ? nextR[0] : 1e9, oLine = nextO == null ? 1e9 : nextO\n      while (chunkI < chunks.length) {\n        var chunk = chunks[chunkI]\n        if (chunk.origFrom <= oLine && chunk.origTo > oLine) {\n          origI++\n          rI--\n          continue outer;\n        }\n        if (chunk.editTo > rLine) {\n          if (chunk.editFrom <= rLine) continue outer;\n          break\n        }\n        diff += (chunk.origTo - chunk.origFrom) - (chunk.editTo - chunk.editFrom)\n        chunkI++\n      }\n      if (rLine == oLine - diff) {\n        nextR[setIndex] = oLine\n        origI++\n      } else if (rLine < oLine - diff) {\n        nextR[setIndex] = rLine + diff\n      } else {\n        var record = [oLine - diff, null, null]\n        record[setIndex] = oLine\n        result.splice(rI, 0, record)\n        origI++\n      }\n    }\n  }\n\n  function findAlignedLines(dv, other) {\n    var alignable = alignableFor(dv.edit, dv.chunks, false), result = []\n    if (other) for (var i = 0, j = 0; i < other.chunks.length; i++) {\n      var n = other.chunks[i].editTo\n      while (j < alignable.length && alignable[j] < n) j++\n      if (j == alignable.length || alignable[j] != n) alignable.splice(j++, 0, n)\n    }\n    for (var i = 0; i < alignable.length; i++)\n      result.push([alignable[i], null, null])\n\n    mergeAlignable(result, alignableFor(dv.orig, dv.chunks, true), dv.chunks, 1)\n    if (other)\n      mergeAlignable(result, alignableFor(other.orig, other.chunks, true), other.chunks, 2)\n\n    return result\n  }\n\n  function alignChunks(dv, force) {\n    if (!dv.dealigned && !force) return;\n    if (!dv.orig.curOp) return dv.orig.operation(function() {\n      alignChunks(dv, force);\n    });\n\n    dv.dealigned = false;\n    var other = dv.mv.left == dv ? dv.mv.right : dv.mv.left;\n    if (other) {\n      ensureDiff(other);\n      other.dealigned = false;\n    }\n    var linesToAlign = findAlignedLines(dv, other);\n\n    // Clear old aligners\n    var aligners = dv.mv.aligners;\n    for (var i = 0; i < aligners.length; i++)\n      aligners[i].clear();\n    aligners.length = 0;\n\n    var cm = [dv.edit, dv.orig], scroll = [], offset = []\n    if (other) cm.push(other.orig);\n    for (var i = 0; i < cm.length; i++) {\n      scroll.push(cm[i].getScrollInfo().top);\n      offset.push(-cm[i].getScrollerElement().getBoundingClientRect().top)\n    }\n\n    if (offset[0] != offset[1] || cm.length == 3 && offset[1] != offset[2])\n      alignLines(cm, offset, [0, 0, 0], aligners)\n    for (var ln = 0; ln < linesToAlign.length; ln++)\n      alignLines(cm, offset, linesToAlign[ln], aligners);\n\n    for (var i = 0; i < cm.length; i++)\n      cm[i].scrollTo(null, scroll[i]);\n  }\n\n  function alignLines(cm, cmOffset, lines, aligners) {\n    var maxOffset = -1e8, offset = [];\n    for (var i = 0; i < cm.length; i++) if (lines[i] != null) {\n      var off = cm[i].heightAtLine(lines[i], \"local\") - cmOffset[i];\n      offset[i] = off;\n      maxOffset = Math.max(maxOffset, off);\n    }\n    for (var i = 0; i < cm.length; i++) if (lines[i] != null) {\n      var diff = maxOffset - offset[i];\n      if (diff > 1)\n        aligners.push(padAbove(cm[i], lines[i], diff));\n    }\n  }\n\n  function padAbove(cm, line, size) {\n    var above = true;\n    if (line > cm.lastLine()) {\n      line--;\n      above = false;\n    }\n    var elt = document.createElement(\"div\");\n    elt.className = \"CodeMirror-merge-spacer\";\n    elt.style.height = size + \"px\"; elt.style.minWidth = \"1px\";\n    return cm.addLineWidget(line, elt, {height: size, above: above, mergeSpacer: true, handleMouseEvents: true});\n  }\n\n  function drawConnectorsForChunk(dv, chunk, sTopOrig, sTopEdit, w) {\n    var flip = dv.type == \"left\";\n    var top = dv.orig.heightAtLine(chunk.origFrom, \"local\", true) - sTopOrig;\n    if (dv.svg) {\n      var topLpx = top;\n      var topRpx = dv.edit.heightAtLine(chunk.editFrom, \"local\", true) - sTopEdit;\n      if (flip) { var tmp = topLpx; topLpx = topRpx; topRpx = tmp; }\n      var botLpx = dv.orig.heightAtLine(chunk.origTo, \"local\", true) - sTopOrig;\n      var botRpx = dv.edit.heightAtLine(chunk.editTo, \"local\", true) - sTopEdit;\n      if (flip) { var tmp = botLpx; botLpx = botRpx; botRpx = tmp; }\n      var curveTop = \" C \" + w/2 + \" \" + topRpx + \" \" + w/2 + \" \" + topLpx + \" \" + (w + 2) + \" \" + topLpx;\n      var curveBot = \" C \" + w/2 + \" \" + botLpx + \" \" + w/2 + \" \" + botRpx + \" -1 \" + botRpx;\n      attrs(dv.svg.appendChild(document.createElementNS(svgNS, \"path\")),\n            \"d\", \"M -1 \" + topRpx + curveTop + \" L \" + (w + 2) + \" \" + botLpx + curveBot + \" z\",\n            \"class\", dv.classes.connect);\n    }\n    if (dv.copyButtons) {\n      var copy = dv.copyButtons.appendChild(elt(\"div\", dv.type == \"left\" ? \"\\u21dd\" : \"\\u21dc\",\n                                                \"CodeMirror-merge-copy\"));\n      var editOriginals = dv.mv.options.allowEditingOriginals;\n      copy.title = dv.edit.phrase(editOriginals ? \"Push to left\" : \"Revert chunk\");\n      copy.chunk = chunk;\n      copy.style.top = (chunk.origTo > chunk.origFrom ? top : dv.edit.heightAtLine(chunk.editFrom, \"local\") - sTopEdit) + \"px\";\n      copy.setAttribute(\"role\", \"button\");\n      copy.setAttribute(\"tabindex\", \"0\");\n      copy.setAttribute(\"aria-label\", copy.title);\n\n      if (editOriginals) {\n        var topReverse = dv.edit.heightAtLine(chunk.editFrom, \"local\") - sTopEdit;\n        var copyReverse = dv.copyButtons.appendChild(elt(\"div\", dv.type == \"right\" ? \"\\u21dd\" : \"\\u21dc\",\n                                                         \"CodeMirror-merge-copy-reverse\"));\n        copyReverse.title = \"Push to right\";\n        copyReverse.chunk = {editFrom: chunk.origFrom, editTo: chunk.origTo,\n                             origFrom: chunk.editFrom, origTo: chunk.editTo};\n        copyReverse.style.top = topReverse + \"px\";\n        dv.type == \"right\" ? copyReverse.style.left = \"2px\" : copyReverse.style.right = \"2px\";\n        copyReverse.setAttribute(\"role\", \"button\");\n        copyReverse.setAttribute(\"tabindex\", \"0\");\n        copyReverse.setAttribute(\"aria-label\", copyReverse.title);\n      }\n    }\n  }\n\n  function copyChunk(dv, to, from, chunk) {\n    if (dv.diffOutOfDate) return;\n    var origStart = chunk.origTo > from.lastLine() ? Pos(chunk.origFrom - 1) : Pos(chunk.origFrom, 0)\n    var origEnd = Pos(chunk.origTo, 0)\n    var editStart = chunk.editTo > to.lastLine() ? Pos(chunk.editFrom - 1) : Pos(chunk.editFrom, 0)\n    var editEnd = Pos(chunk.editTo, 0)\n    var handler = dv.mv.options.revertChunk\n    if (handler)\n      handler(dv.mv, from, origStart, origEnd, to, editStart, editEnd)\n    else\n      to.replaceRange(from.getRange(origStart, origEnd), editStart, editEnd)\n  }\n\n  // Merge view, containing 0, 1, or 2 diff views.\n\n  var MergeView = CodeMirror.MergeView = function(node, options) {\n    if (!(this instanceof MergeView)) return new MergeView(node, options);\n\n    this.options = options;\n    var origLeft = options.origLeft, origRight = options.origRight == null ? options.orig : options.origRight;\n\n    var hasLeft = origLeft != null, hasRight = origRight != null;\n    var panes = 1 + (hasLeft ? 1 : 0) + (hasRight ? 1 : 0);\n    var wrap = [], left = this.left = null, right = this.right = null;\n    var self = this;\n\n    if (hasLeft) {\n      left = this.left = new DiffView(this, \"left\");\n      var leftPane = elt(\"div\", null, \"CodeMirror-merge-pane CodeMirror-merge-left\");\n      wrap.push(leftPane);\n      wrap.push(buildGap(left));\n    }\n\n    var editPane = elt(\"div\", null, \"CodeMirror-merge-pane CodeMirror-merge-editor\");\n    wrap.push(editPane);\n\n    if (hasRight) {\n      right = this.right = new DiffView(this, \"right\");\n      wrap.push(buildGap(right));\n      var rightPane = elt(\"div\", null, \"CodeMirror-merge-pane CodeMirror-merge-right\");\n      wrap.push(rightPane);\n    }\n\n    (hasRight ? rightPane : editPane).className += \" CodeMirror-merge-pane-rightmost\";\n\n    wrap.push(elt(\"div\", null, null, \"height: 0; clear: both;\"));\n\n    var wrapElt = this.wrap = node.appendChild(elt(\"div\", wrap, \"CodeMirror-merge CodeMirror-merge-\" + panes + \"pane\"));\n    this.edit = CodeMirror(editPane, copyObj(options));\n\n    if (left) left.init(leftPane, origLeft, options);\n    if (right) right.init(rightPane, origRight, options);\n    if (options.collapseIdentical)\n      this.editor().operation(function() {\n        collapseIdenticalStretches(self, options.collapseIdentical);\n      });\n    if (options.connect == \"align\") {\n      this.aligners = [];\n      alignChunks(this.left || this.right, true);\n    }\n    if (left) left.registerEvents(right)\n    if (right) right.registerEvents(left)\n\n\n    var onResize = function() {\n      if (left) makeConnections(left);\n      if (right) makeConnections(right);\n    };\n    CodeMirror.on(window, \"resize\", onResize);\n    var resizeInterval = setInterval(function() {\n      for (var p = wrapElt.parentNode; p && p != document.body; p = p.parentNode) {}\n      if (!p) { clearInterval(resizeInterval); CodeMirror.off(window, \"resize\", onResize); }\n    }, 5000);\n  };\n\n  function buildGap(dv) {\n    var lock = dv.lockButton = elt(\"div\", null, \"CodeMirror-merge-scrolllock\");\n    lock.setAttribute(\"role\", \"button\");\n    lock.setAttribute(\"tabindex\", \"0\");\n    var lockWrap = elt(\"div\", [lock], \"CodeMirror-merge-scrolllock-wrap\");\n    CodeMirror.on(lock, \"click\", function() { setScrollLock(dv, !dv.lockScroll); });\n    CodeMirror.on(lock, \"keyup\", function(e) { e.key === \"Enter\" && setScrollLock(dv, !dv.lockScroll); });\n    var gapElts = [lockWrap];\n    if (dv.mv.options.revertButtons !== false) {\n      dv.copyButtons = elt(\"div\", null, \"CodeMirror-merge-copybuttons-\" + dv.type);\n      function copyButtons(e) {\n        var node = e.target || e.srcElement;\n        if (!node.chunk) return;\n        if (node.className == \"CodeMirror-merge-copy-reverse\") {\n          copyChunk(dv, dv.orig, dv.edit, node.chunk);\n          return;\n        }\n        copyChunk(dv, dv.edit, dv.orig, node.chunk);\n      }\n      CodeMirror.on(dv.copyButtons, \"click\", copyButtons);\n      CodeMirror.on(dv.copyButtons, \"keyup\", function(e) { e.key === \"Enter\" && copyButtons(e); });\n      gapElts.unshift(dv.copyButtons);\n    }\n    if (dv.mv.options.connect != \"align\") {\n      var svg = document.createElementNS && document.createElementNS(svgNS, \"svg\");\n      if (svg && !svg.createSVGRect) svg = null;\n      dv.svg = svg;\n      if (svg) gapElts.push(svg);\n    }\n\n    return dv.gap = elt(\"div\", gapElts, \"CodeMirror-merge-gap\");\n  }\n\n  MergeView.prototype = {\n    constructor: MergeView,\n    editor: function() { return this.edit; },\n    rightOriginal: function() { return this.right && this.right.orig; },\n    leftOriginal: function() { return this.left && this.left.orig; },\n    setShowDifferences: function(val) {\n      if (this.right) this.right.setShowDifferences(val);\n      if (this.left) this.left.setShowDifferences(val);\n    },\n    rightChunks: function() {\n      if (this.right) { ensureDiff(this.right); return this.right.chunks; }\n    },\n    leftChunks: function() {\n      if (this.left) { ensureDiff(this.left); return this.left.chunks; }\n    }\n  };\n\n  function asString(obj) {\n    if (typeof obj == \"string\") return obj;\n    else return obj.getValue();\n  }\n\n  // Operations on diffs\n  var dmp;\n  function getDiff(a, b, ignoreWhitespace) {\n    if (!dmp) dmp = new diff_match_patch();\n\n    var diff = dmp.diff_main(a, b);\n    // The library sometimes leaves in empty parts, which confuse the algorithm\n    for (var i = 0; i < diff.length; ++i) {\n      var part = diff[i];\n      if (ignoreWhitespace ? !/[^ \\t]/.test(part[1]) : !part[1]) {\n        diff.splice(i--, 1);\n      } else if (i && diff[i - 1][0] == part[0]) {\n        diff.splice(i--, 1);\n        diff[i][1] += part[1];\n      }\n    }\n    return diff;\n  }\n\n  function getChunks(diff) {\n    var chunks = [];\n    if (!diff.length) return chunks;\n    var startEdit = 0, startOrig = 0;\n    var edit = Pos(0, 0), orig = Pos(0, 0);\n    for (var i = 0; i < diff.length; ++i) {\n      var part = diff[i], tp = part[0];\n      if (tp == DIFF_EQUAL) {\n        var startOff = !startOfLineClean(diff, i) || edit.line < startEdit || orig.line < startOrig ? 1 : 0;\n        var cleanFromEdit = edit.line + startOff, cleanFromOrig = orig.line + startOff;\n        moveOver(edit, part[1], null, orig);\n        var endOff = endOfLineClean(diff, i) ? 1 : 0;\n        var cleanToEdit = edit.line + endOff, cleanToOrig = orig.line + endOff;\n        if (cleanToEdit > cleanFromEdit) {\n          if (i) chunks.push({origFrom: startOrig, origTo: cleanFromOrig,\n                              editFrom: startEdit, editTo: cleanFromEdit});\n          startEdit = cleanToEdit; startOrig = cleanToOrig;\n        }\n      } else {\n        moveOver(tp == DIFF_INSERT ? edit : orig, part[1]);\n      }\n    }\n    if (startEdit <= edit.line || startOrig <= orig.line)\n      chunks.push({origFrom: startOrig, origTo: orig.line + 1,\n                   editFrom: startEdit, editTo: edit.line + 1});\n    return chunks;\n  }\n\n  function endOfLineClean(diff, i) {\n    if (i == diff.length - 1) return true;\n    var next = diff[i + 1][1];\n    if ((next.length == 1 && i < diff.length - 2) || next.charCodeAt(0) != 10) return false;\n    if (i == diff.length - 2) return true;\n    next = diff[i + 2][1];\n    return (next.length > 1 || i == diff.length - 3) && next.charCodeAt(0) == 10;\n  }\n\n  function startOfLineClean(diff, i) {\n    if (i == 0) return true;\n    var last = diff[i - 1][1];\n    if (last.charCodeAt(last.length - 1) != 10) return false;\n    if (i == 1) return true;\n    last = diff[i - 2][1];\n    return last.charCodeAt(last.length - 1) == 10;\n  }\n\n  function chunkBoundariesAround(chunks, n, nInEdit) {\n    var beforeE, afterE, beforeO, afterO;\n    for (var i = 0; i < chunks.length; i++) {\n      var chunk = chunks[i];\n      var fromLocal = nInEdit ? chunk.editFrom : chunk.origFrom;\n      var toLocal = nInEdit ? chunk.editTo : chunk.origTo;\n      if (afterE == null) {\n        if (fromLocal > n) { afterE = chunk.editFrom; afterO = chunk.origFrom; }\n        else if (toLocal > n) { afterE = chunk.editTo; afterO = chunk.origTo; }\n      }\n      if (toLocal <= n) { beforeE = chunk.editTo; beforeO = chunk.origTo; }\n      else if (fromLocal <= n) { beforeE = chunk.editFrom; beforeO = chunk.origFrom; }\n    }\n    return {edit: {before: beforeE, after: afterE}, orig: {before: beforeO, after: afterO}};\n  }\n\n  function collapseSingle(cm, from, to) {\n    cm.addLineClass(from, \"wrap\", \"CodeMirror-merge-collapsed-line\");\n    var widget = document.createElement(\"span\");\n    widget.className = \"CodeMirror-merge-collapsed-widget\";\n    widget.title = cm.phrase(\"Identical text collapsed. Click to expand.\");\n    var mark = cm.markText(Pos(from, 0), Pos(to - 1), {\n      inclusiveLeft: true,\n      inclusiveRight: true,\n      replacedWith: widget,\n      clearOnEnter: true\n    });\n    function clear() {\n      mark.clear();\n      cm.removeLineClass(from, \"wrap\", \"CodeMirror-merge-collapsed-line\");\n    }\n    if (mark.explicitlyCleared) clear();\n    CodeMirror.on(widget, \"click\", clear);\n    mark.on(\"clear\", clear);\n    CodeMirror.on(widget, \"click\", clear);\n    return {mark: mark, clear: clear};\n  }\n\n  function collapseStretch(size, editors) {\n    var marks = [];\n    function clear() {\n      for (var i = 0; i < marks.length; i++) marks[i].clear();\n    }\n    for (var i = 0; i < editors.length; i++) {\n      var editor = editors[i];\n      var mark = collapseSingle(editor.cm, editor.line, editor.line + size);\n      marks.push(mark);\n      mark.mark.on(\"clear\", clear);\n    }\n    return marks[0].mark;\n  }\n\n  function unclearNearChunks(dv, margin, off, clear) {\n    for (var i = 0; i < dv.chunks.length; i++) {\n      var chunk = dv.chunks[i];\n      for (var l = chunk.editFrom - margin; l < chunk.editTo + margin; l++) {\n        var pos = l + off;\n        if (pos >= 0 && pos < clear.length) clear[pos] = false;\n      }\n    }\n  }\n\n  function collapseIdenticalStretches(mv, margin) {\n    if (typeof margin != \"number\") margin = 2;\n    var clear = [], edit = mv.editor(), off = edit.firstLine();\n    for (var l = off, e = edit.lastLine(); l <= e; l++) clear.push(true);\n    if (mv.left) unclearNearChunks(mv.left, margin, off, clear);\n    if (mv.right) unclearNearChunks(mv.right, margin, off, clear);\n\n    for (var i = 0; i < clear.length; i++) {\n      if (clear[i]) {\n        var line = i + off;\n        for (var size = 1; i < clear.length - 1 && clear[i + 1]; i++, size++) {}\n        if (size > margin) {\n          var editors = [{line: line, cm: edit}];\n          if (mv.left) editors.push({line: getMatchingOrigLine(line, mv.left.chunks), cm: mv.left.orig});\n          if (mv.right) editors.push({line: getMatchingOrigLine(line, mv.right.chunks), cm: mv.right.orig});\n          var mark = collapseStretch(size, editors);\n          if (mv.options.onCollapse) mv.options.onCollapse(mv, line, size, mark);\n        }\n      }\n    }\n  }\n\n  // General utilities\n\n  function elt(tag, content, className, style) {\n    var e = document.createElement(tag);\n    if (className) e.className = className;\n    if (style) e.style.cssText = style;\n    if (typeof content == \"string\") e.appendChild(document.createTextNode(content));\n    else if (content) for (var i = 0; i < content.length; ++i) e.appendChild(content[i]);\n    return e;\n  }\n\n  function clear(node) {\n    for (var count = node.childNodes.length; count > 0; --count)\n      node.removeChild(node.firstChild);\n  }\n\n  function attrs(elt) {\n    for (var i = 1; i < arguments.length; i += 2)\n      elt.setAttribute(arguments[i], arguments[i+1]);\n  }\n\n  function copyObj(obj, target) {\n    if (!target) target = {};\n    for (var prop in obj) if (obj.hasOwnProperty(prop)) target[prop] = obj[prop];\n    return target;\n  }\n\n  function moveOver(pos, str, copy, other) {\n    var out = copy ? Pos(pos.line, pos.ch) : pos, at = 0;\n    for (;;) {\n      var nl = str.indexOf(\"\\n\", at);\n      if (nl == -1) break;\n      ++out.line;\n      if (other) ++other.line;\n      at = nl + 1;\n    }\n    out.ch = (at ? 0 : out.ch) + (str.length - at);\n    if (other) other.ch = (at ? 0 : other.ch) + (str.length - at);\n    return out;\n  }\n\n  // Tracks collapsed markers and line widgets, in order to be able to\n  // accurately align the content of two editors.\n\n  var F_WIDGET = 1, F_WIDGET_BELOW = 2, F_MARKER = 4\n\n  function TrackAlignable(cm) {\n    this.cm = cm\n    this.alignable = []\n    this.height = cm.doc.height\n    var self = this\n    cm.on(\"markerAdded\", function(_, marker) {\n      if (!marker.collapsed) return\n      var found = marker.find(1)\n      if (found != null) self.set(found.line, F_MARKER)\n    })\n    cm.on(\"markerCleared\", function(_, marker, _min, max) {\n      if (max != null && marker.collapsed)\n        self.check(max, F_MARKER, self.hasMarker)\n    })\n    cm.on(\"markerChanged\", this.signal.bind(this))\n    cm.on(\"lineWidgetAdded\", function(_, widget, lineNo) {\n      if (widget.mergeSpacer) return\n      if (widget.above) self.set(lineNo - 1, F_WIDGET_BELOW)\n      else self.set(lineNo, F_WIDGET)\n    })\n    cm.on(\"lineWidgetCleared\", function(_, widget, lineNo) {\n      if (widget.mergeSpacer) return\n      if (widget.above) self.check(lineNo - 1, F_WIDGET_BELOW, self.hasWidgetBelow)\n      else self.check(lineNo, F_WIDGET, self.hasWidget)\n    })\n    cm.on(\"lineWidgetChanged\", this.signal.bind(this))\n    cm.on(\"change\", function(_, change) {\n      var start = change.from.line, nBefore = change.to.line - change.from.line\n      var nAfter = change.text.length - 1, end = start + nAfter\n      if (nBefore || nAfter) self.map(start, nBefore, nAfter)\n      self.check(end, F_MARKER, self.hasMarker)\n      if (nBefore || nAfter) self.check(change.from.line, F_MARKER, self.hasMarker)\n    })\n    cm.on(\"viewportChange\", function() {\n      if (self.cm.doc.height != self.height) self.signal()\n    })\n  }\n\n  TrackAlignable.prototype = {\n    signal: function() {\n      CodeMirror.signal(this, \"realign\")\n      this.height = this.cm.doc.height\n    },\n\n    set: function(n, flags) {\n      var pos = -1\n      for (; pos < this.alignable.length; pos += 2) {\n        var diff = this.alignable[pos] - n\n        if (diff == 0) {\n          if ((this.alignable[pos + 1] & flags) == flags) return\n          this.alignable[pos + 1] |= flags\n          this.signal()\n          return\n        }\n        if (diff > 0) break\n      }\n      this.signal()\n      this.alignable.splice(pos, 0, n, flags)\n    },\n\n    find: function(n) {\n      for (var i = 0; i < this.alignable.length; i += 2)\n        if (this.alignable[i] == n) return i\n      return -1\n    },\n\n    check: function(n, flag, pred) {\n      var found = this.find(n)\n      if (found == -1 || !(this.alignable[found + 1] & flag)) return\n      if (!pred.call(this, n)) {\n        this.signal()\n        var flags = this.alignable[found + 1] & ~flag\n        if (flags) this.alignable[found + 1] = flags\n        else this.alignable.splice(found, 2)\n      }\n    },\n\n    hasMarker: function(n) {\n      var handle = this.cm.getLineHandle(n)\n      if (handle.markedSpans) for (var i = 0; i < handle.markedSpans.length; i++)\n        if (handle.markedSpans[i].marker.collapsed && handle.markedSpans[i].to != null)\n          return true\n      return false\n    },\n\n    hasWidget: function(n) {\n      var handle = this.cm.getLineHandle(n)\n      if (handle.widgets) for (var i = 0; i < handle.widgets.length; i++)\n        if (!handle.widgets[i].above && !handle.widgets[i].mergeSpacer) return true\n      return false\n    },\n\n    hasWidgetBelow: function(n) {\n      if (n == this.cm.lastLine()) return false\n      var handle = this.cm.getLineHandle(n + 1)\n      if (handle.widgets) for (var i = 0; i < handle.widgets.length; i++)\n        if (handle.widgets[i].above && !handle.widgets[i].mergeSpacer) return true\n      return false\n    },\n\n    map: function(from, nBefore, nAfter) {\n      var diff = nAfter - nBefore, to = from + nBefore, widgetFrom = -1, widgetTo = -1\n      for (var i = 0; i < this.alignable.length; i += 2) {\n        var n = this.alignable[i]\n        if (n == from && (this.alignable[i + 1] & F_WIDGET_BELOW)) widgetFrom = i\n        if (n == to && (this.alignable[i + 1] & F_WIDGET_BELOW)) widgetTo = i\n        if (n <= from) continue\n        else if (n < to) this.alignable.splice(i--, 2)\n        else this.alignable[i] += diff\n      }\n      if (widgetFrom > -1) {\n        var flags = this.alignable[widgetFrom + 1]\n        if (flags == F_WIDGET_BELOW) this.alignable.splice(widgetFrom, 2)\n        else this.alignable[widgetFrom + 1] = flags & ~F_WIDGET_BELOW\n      }\n      if (widgetTo > -1 && nAfter)\n        this.set(from + nAfter, F_WIDGET_BELOW)\n    }\n  }\n\n  function posMin(a, b) { return (a.line - b.line || a.ch - b.ch) < 0 ? a : b; }\n  function posMax(a, b) { return (a.line - b.line || a.ch - b.ch) > 0 ? a : b; }\n  function posEq(a, b) { return a.line == b.line && a.ch == b.ch; }\n\n  function findPrevDiff(chunks, start, isOrig) {\n    for (var i = chunks.length - 1; i >= 0; i--) {\n      var chunk = chunks[i];\n      var to = (isOrig ? chunk.origTo : chunk.editTo) - 1;\n      if (to < start) return to;\n    }\n  }\n\n  function findNextDiff(chunks, start, isOrig) {\n    for (var i = 0; i < chunks.length; i++) {\n      var chunk = chunks[i];\n      var from = (isOrig ? chunk.origFrom : chunk.editFrom);\n      if (from > start) return from;\n    }\n  }\n\n  function goNearbyDiff(cm, dir) {\n    var found = null, views = cm.state.diffViews, line = cm.getCursor().line;\n    if (views) for (var i = 0; i < views.length; i++) {\n      var dv = views[i], isOrig = cm == dv.orig;\n      ensureDiff(dv);\n      var pos = dir < 0 ? findPrevDiff(dv.chunks, line, isOrig) : findNextDiff(dv.chunks, line, isOrig);\n      if (pos != null && (found == null || (dir < 0 ? pos > found : pos < found)))\n        found = pos;\n    }\n    if (found != null)\n      cm.setCursor(found, 0);\n    else\n      return CodeMirror.Pass;\n  }\n\n  CodeMirror.commands.goNextDiff = function(cm) {\n    return goNearbyDiff(cm, 1);\n  };\n  CodeMirror.commands.goPrevDiff = function(cm) {\n    return goNearbyDiff(cm, -1);\n  };\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n\"use strict\";\n\nvar htmlConfig = {\n  autoSelfClosers: {'area': true, 'base': true, 'br': true, 'col': true, 'command': true,\n                    'embed': true, 'frame': true, 'hr': true, 'img': true, 'input': true,\n                    'keygen': true, 'link': true, 'meta': true, 'param': true, 'source': true,\n                    'track': true, 'wbr': true, 'menuitem': true},\n  implicitlyClosed: {'dd': true, 'li': true, 'optgroup': true, 'option': true, 'p': true,\n                     'rp': true, 'rt': true, 'tbody': true, 'td': true, 'tfoot': true,\n                     'th': true, 'tr': true},\n  contextGrabbers: {\n    'dd': {'dd': true, 'dt': true},\n    'dt': {'dd': true, 'dt': true},\n    'li': {'li': true},\n    'option': {'option': true, 'optgroup': true},\n    'optgroup': {'optgroup': true},\n    'p': {'address': true, 'article': true, 'aside': true, 'blockquote': true, 'dir': true,\n          'div': true, 'dl': true, 'fieldset': true, 'footer': true, 'form': true,\n          'h1': true, 'h2': true, 'h3': true, 'h4': true, 'h5': true, 'h6': true,\n          'header': true, 'hgroup': true, 'hr': true, 'menu': true, 'nav': true, 'ol': true,\n          'p': true, 'pre': true, 'section': true, 'table': true, 'ul': true},\n    'rp': {'rp': true, 'rt': true},\n    'rt': {'rp': true, 'rt': true},\n    'tbody': {'tbody': true, 'tfoot': true},\n    'td': {'td': true, 'th': true},\n    'tfoot': {'tbody': true},\n    'th': {'td': true, 'th': true},\n    'thead': {'tbody': true, 'tfoot': true},\n    'tr': {'tr': true}\n  },\n  doNotIndent: {\"pre\": true},\n  allowUnquoted: true,\n  allowMissing: true,\n  caseFold: true\n}\n\nvar xmlConfig = {\n  autoSelfClosers: {},\n  implicitlyClosed: {},\n  contextGrabbers: {},\n  doNotIndent: {},\n  allowUnquoted: false,\n  allowMissing: false,\n  allowMissingTagName: false,\n  caseFold: false\n}\n\nCodeMirror.defineMode(\"xml\", function(editorConf, config_) {\n  var indentUnit = editorConf.indentUnit\n  var config = {}\n  var defaults = config_.htmlMode ? htmlConfig : xmlConfig\n  for (var prop in defaults) config[prop] = defaults[prop]\n  for (var prop in config_) config[prop] = config_[prop]\n\n  // Return variables for tokenizers\n  var type, setStyle;\n\n  function inText(stream, state) {\n    function chain(parser) {\n      state.tokenize = parser;\n      return parser(stream, state);\n    }\n\n    var ch = stream.next();\n    if (ch == \"<\") {\n      if (stream.eat(\"!\")) {\n        if (stream.eat(\"[\")) {\n          if (stream.match(\"CDATA[\")) return chain(inBlock(\"atom\", \"]]>\"));\n          else return null;\n        } else if (stream.match(\"--\")) {\n          return chain(inBlock(\"comment\", \"-->\"));\n        } else if (stream.match(\"DOCTYPE\", true, true)) {\n          stream.eatWhile(/[\\w\\._\\-]/);\n          return chain(doctype(1));\n        } else {\n          return null;\n        }\n      } else if (stream.eat(\"?\")) {\n        stream.eatWhile(/[\\w\\._\\-]/);\n        state.tokenize = inBlock(\"meta\", \"?>\");\n        return \"meta\";\n      } else {\n        type = stream.eat(\"/\") ? \"closeTag\" : \"openTag\";\n        state.tokenize = inTag;\n        return \"tag bracket\";\n      }\n    } else if (ch == \"&\") {\n      var ok;\n      if (stream.eat(\"#\")) {\n        if (stream.eat(\"x\")) {\n          ok = stream.eatWhile(/[a-fA-F\\d]/) && stream.eat(\";\");\n        } else {\n          ok = stream.eatWhile(/[\\d]/) && stream.eat(\";\");\n        }\n      } else {\n        ok = stream.eatWhile(/[\\w\\.\\-:]/) && stream.eat(\";\");\n      }\n      return ok ? \"atom\" : \"error\";\n    } else {\n      stream.eatWhile(/[^&<]/);\n      return null;\n    }\n  }\n  inText.isInText = true;\n\n  function inTag(stream, state) {\n    var ch = stream.next();\n    if (ch == \">\" || (ch == \"/\" && stream.eat(\">\"))) {\n      state.tokenize = inText;\n      type = ch == \">\" ? \"endTag\" : \"selfcloseTag\";\n      return \"tag bracket\";\n    } else if (ch == \"=\") {\n      type = \"equals\";\n      return null;\n    } else if (ch == \"<\") {\n      state.tokenize = inText;\n      state.state = baseState;\n      state.tagName = state.tagStart = null;\n      var next = state.tokenize(stream, state);\n      return next ? next + \" tag error\" : \"tag error\";\n    } else if (/[\\'\\\"]/.test(ch)) {\n      state.tokenize = inAttribute(ch);\n      state.stringStartCol = stream.column();\n      return state.tokenize(stream, state);\n    } else {\n      stream.match(/^[^\\s\\u00a0=<>\\\"\\']*[^\\s\\u00a0=<>\\\"\\'\\/]/);\n      return \"word\";\n    }\n  }\n\n  function inAttribute(quote) {\n    var closure = function(stream, state) {\n      while (!stream.eol()) {\n        if (stream.next() == quote) {\n          state.tokenize = inTag;\n          break;\n        }\n      }\n      return \"string\";\n    };\n    closure.isInAttribute = true;\n    return closure;\n  }\n\n  function inBlock(style, terminator) {\n    return function(stream, state) {\n      while (!stream.eol()) {\n        if (stream.match(terminator)) {\n          state.tokenize = inText;\n          break;\n        }\n        stream.next();\n      }\n      return style;\n    }\n  }\n\n  function doctype(depth) {\n    return function(stream, state) {\n      var ch;\n      while ((ch = stream.next()) != null) {\n        if (ch == \"<\") {\n          state.tokenize = doctype(depth + 1);\n          return state.tokenize(stream, state);\n        } else if (ch == \">\") {\n          if (depth == 1) {\n            state.tokenize = inText;\n            break;\n          } else {\n            state.tokenize = doctype(depth - 1);\n            return state.tokenize(stream, state);\n          }\n        }\n      }\n      return \"meta\";\n    };\n  }\n\n  function lower(tagName) {\n    return tagName && tagName.toLowerCase();\n  }\n\n  function Context(state, tagName, startOfLine) {\n    this.prev = state.context;\n    this.tagName = tagName || \"\";\n    this.indent = state.indented;\n    this.startOfLine = startOfLine;\n    if (config.doNotIndent.hasOwnProperty(tagName) || (state.context && state.context.noIndent))\n      this.noIndent = true;\n  }\n  function popContext(state) {\n    if (state.context) state.context = state.context.prev;\n  }\n  function maybePopContext(state, nextTagName) {\n    var parentTagName;\n    while (true) {\n      if (!state.context) {\n        return;\n      }\n      parentTagName = state.context.tagName;\n      if (!config.contextGrabbers.hasOwnProperty(lower(parentTagName)) ||\n          !config.contextGrabbers[lower(parentTagName)].hasOwnProperty(lower(nextTagName))) {\n        return;\n      }\n      popContext(state);\n    }\n  }\n\n  function baseState(type, stream, state) {\n    if (type == \"openTag\") {\n      state.tagStart = stream.column();\n      return tagNameState;\n    } else if (type == \"closeTag\") {\n      return closeTagNameState;\n    } else {\n      return baseState;\n    }\n  }\n  function tagNameState(type, stream, state) {\n    if (type == \"word\") {\n      state.tagName = stream.current();\n      setStyle = \"tag\";\n      return attrState;\n    } else if (config.allowMissingTagName && type == \"endTag\") {\n      setStyle = \"tag bracket\";\n      return attrState(type, stream, state);\n    } else {\n      setStyle = \"error\";\n      return tagNameState;\n    }\n  }\n  function closeTagNameState(type, stream, state) {\n    if (type == \"word\") {\n      var tagName = stream.current();\n      if (state.context && state.context.tagName != tagName &&\n          config.implicitlyClosed.hasOwnProperty(lower(state.context.tagName)))\n        popContext(state);\n      if ((state.context && state.context.tagName == tagName) || config.matchClosing === false) {\n        setStyle = \"tag\";\n        return closeState;\n      } else {\n        setStyle = \"tag error\";\n        return closeStateErr;\n      }\n    } else if (config.allowMissingTagName && type == \"endTag\") {\n      setStyle = \"tag bracket\";\n      return closeState(type, stream, state);\n    } else {\n      setStyle = \"error\";\n      return closeStateErr;\n    }\n  }\n\n  function closeState(type, _stream, state) {\n    if (type != \"endTag\") {\n      setStyle = \"error\";\n      return closeState;\n    }\n    popContext(state);\n    return baseState;\n  }\n  function closeStateErr(type, stream, state) {\n    setStyle = \"error\";\n    return closeState(type, stream, state);\n  }\n\n  function attrState(type, _stream, state) {\n    if (type == \"word\") {\n      setStyle = \"attribute\";\n      return attrEqState;\n    } else if (type == \"endTag\" || type == \"selfcloseTag\") {\n      var tagName = state.tagName, tagStart = state.tagStart;\n      state.tagName = state.tagStart = null;\n      if (type == \"selfcloseTag\" ||\n          config.autoSelfClosers.hasOwnProperty(lower(tagName))) {\n        maybePopContext(state, tagName);\n      } else {\n        maybePopContext(state, tagName);\n        state.context = new Context(state, tagName, tagStart == state.indented);\n      }\n      return baseState;\n    }\n    setStyle = \"error\";\n    return attrState;\n  }\n  function attrEqState(type, stream, state) {\n    if (type == \"equals\") return attrValueState;\n    if (!config.allowMissing) setStyle = \"error\";\n    return attrState(type, stream, state);\n  }\n  function attrValueState(type, stream, state) {\n    if (type == \"string\") return attrContinuedState;\n    if (type == \"word\" && config.allowUnquoted) {setStyle = \"string\"; return attrState;}\n    setStyle = \"error\";\n    return attrState(type, stream, state);\n  }\n  function attrContinuedState(type, stream, state) {\n    if (type == \"string\") return attrContinuedState;\n    return attrState(type, stream, state);\n  }\n\n  return {\n    startState: function(baseIndent) {\n      var state = {tokenize: inText,\n                   state: baseState,\n                   indented: baseIndent || 0,\n                   tagName: null, tagStart: null,\n                   context: null}\n      if (baseIndent != null) state.baseIndent = baseIndent\n      return state\n    },\n\n    token: function(stream, state) {\n      if (!state.tagName && stream.sol())\n        state.indented = stream.indentation();\n\n      if (stream.eatSpace()) return null;\n      type = null;\n      var style = state.tokenize(stream, state);\n      if ((style || type) && style != \"comment\") {\n        setStyle = null;\n        state.state = state.state(type || style, stream, state);\n        if (setStyle)\n          style = setStyle == \"error\" ? style + \" error\" : setStyle;\n      }\n      return style;\n    },\n\n    indent: function(state, textAfter, fullLine) {\n      var context = state.context;\n      // Indent multi-line strings (e.g. css).\n      if (state.tokenize.isInAttribute) {\n        if (state.tagStart == state.indented)\n          return state.stringStartCol + 1;\n        else\n          return state.indented + indentUnit;\n      }\n      if (context && context.noIndent) return CodeMirror.Pass;\n      if (state.tokenize != inTag && state.tokenize != inText)\n        return fullLine ? fullLine.match(/^(\\s*)/)[0].length : 0;\n      // Indent the starts of attribute names.\n      if (state.tagName) {\n        if (config.multilineTagIndentPastTag !== false)\n          return state.tagStart + state.tagName.length + 2;\n        else\n          return state.tagStart + indentUnit * (config.multilineTagIndentFactor || 1);\n      }\n      if (config.alignCDATA && /<!\\[CDATA\\[/.test(textAfter)) return 0;\n      var tagAfter = textAfter && /^<(\\/)?([\\w_:\\.-]*)/.exec(textAfter);\n      if (tagAfter && tagAfter[1]) { // Closing tag spotted\n        while (context) {\n          if (context.tagName == tagAfter[2]) {\n            context = context.prev;\n            break;\n          } else if (config.implicitlyClosed.hasOwnProperty(lower(context.tagName))) {\n            context = context.prev;\n          } else {\n            break;\n          }\n        }\n      } else if (tagAfter) { // Opening tag spotted\n        while (context) {\n          var grabbers = config.contextGrabbers[lower(context.tagName)];\n          if (grabbers && grabbers.hasOwnProperty(lower(tagAfter[2])))\n            context = context.prev;\n          else\n            break;\n        }\n      }\n      while (context && context.prev && !context.startOfLine)\n        context = context.prev;\n      if (context) return context.indent + indentUnit;\n      else return state.baseIndent || 0;\n    },\n\n    electricInput: /<\\/[\\s\\w:]+>$/,\n    blockCommentStart: \"<!--\",\n    blockCommentEnd: \"-->\",\n\n    configuration: config.htmlMode ? \"html\" : \"xml\",\n    helperType: config.htmlMode ? \"html\" : \"xml\",\n\n    skipAttribute: function(state) {\n      if (state.state == attrValueState)\n        state.state = attrState\n    },\n\n    xmlCurrentTag: function(state) {\n      return state.tagName ? {name: state.tagName, close: state.type == \"closeTag\"} : null\n    },\n\n    xmlCurrentContext: function(state) {\n      var context = []\n      for (var cx = state.context; cx; cx = cx.prev)\n        context.push(cx.tagName)\n      return context.reverse()\n    }\n  };\n});\n\nCodeMirror.defineMIME(\"text/xml\", \"xml\");\nCodeMirror.defineMIME(\"application/xml\", \"xml\");\nif (!CodeMirror.mimeModes.hasOwnProperty(\"text/html\"))\n  CodeMirror.defineMIME(\"text/html\", {name: \"xml\", htmlMode: true});\n\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"), require(\"../xml/xml\"), require(\"../javascript/javascript\"), require(\"../css/css\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\", \"../xml/xml\", \"../javascript/javascript\", \"../css/css\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n  \"use strict\";\n\n  var defaultTags = {\n    script: [\n      [\"lang\", /(javascript|babel)/i, \"javascript\"],\n      [\"type\", /^(?:text|application)\\/(?:x-)?(?:java|ecma)script$|^module$|^$/i, \"javascript\"],\n      [\"type\", /./, \"text/plain\"],\n      [null, null, \"javascript\"]\n    ],\n    style:  [\n      [\"lang\", /^css$/i, \"css\"],\n      [\"type\", /^(text\\/)?(x-)?(stylesheet|css)$/i, \"css\"],\n      [\"type\", /./, \"text/plain\"],\n      [null, null, \"css\"]\n    ]\n  };\n\n  function maybeBackup(stream, pat, style) {\n    var cur = stream.current(), close = cur.search(pat);\n    if (close > -1) {\n      stream.backUp(cur.length - close);\n    } else if (cur.match(/<\\/?$/)) {\n      stream.backUp(cur.length);\n      if (!stream.match(pat, false)) stream.match(cur);\n    }\n    return style;\n  }\n\n  var attrRegexpCache = {};\n  function getAttrRegexp(attr) {\n    var regexp = attrRegexpCache[attr];\n    if (regexp) return regexp;\n    return attrRegexpCache[attr] = new RegExp(\"\\\\s+\" + attr + \"\\\\s*=\\\\s*('|\\\")?([^'\\\"]+)('|\\\")?\\\\s*\");\n  }\n\n  function getAttrValue(text, attr) {\n    var match = text.match(getAttrRegexp(attr))\n    return match ? /^\\s*(.*?)\\s*$/.exec(match[2])[1] : \"\"\n  }\n\n  function getTagRegexp(tagName, anchored) {\n    return new RegExp((anchored ? \"^\" : \"\") + \"<\\/\\\\s*\" + tagName + \"\\\\s*>\", \"i\");\n  }\n\n  function addTags(from, to) {\n    for (var tag in from) {\n      var dest = to[tag] || (to[tag] = []);\n      var source = from[tag];\n      for (var i = source.length - 1; i >= 0; i--)\n        dest.unshift(source[i])\n    }\n  }\n\n  function findMatchingMode(tagInfo, tagText) {\n    for (var i = 0; i < tagInfo.length; i++) {\n      var spec = tagInfo[i];\n      if (!spec[0] || spec[1].test(getAttrValue(tagText, spec[0]))) return spec[2];\n    }\n  }\n\n  CodeMirror.defineMode(\"htmlmixed\", function (config, parserConfig) {\n    var htmlMode = CodeMirror.getMode(config, {\n      name: \"xml\",\n      htmlMode: true,\n      multilineTagIndentFactor: parserConfig.multilineTagIndentFactor,\n      multilineTagIndentPastTag: parserConfig.multilineTagIndentPastTag,\n      allowMissingTagName: parserConfig.allowMissingTagName,\n    });\n\n    var tags = {};\n    var configTags = parserConfig && parserConfig.tags, configScript = parserConfig && parserConfig.scriptTypes;\n    addTags(defaultTags, tags);\n    if (configTags) addTags(configTags, tags);\n    if (configScript) for (var i = configScript.length - 1; i >= 0; i--)\n      tags.script.unshift([\"type\", configScript[i].matches, configScript[i].mode])\n\n    function html(stream, state) {\n      var style = htmlMode.token(stream, state.htmlState), tag = /\\btag\\b/.test(style), tagName\n      if (tag && !/[<>\\s\\/]/.test(stream.current()) &&\n          (tagName = state.htmlState.tagName && state.htmlState.tagName.toLowerCase()) &&\n          tags.hasOwnProperty(tagName)) {\n        state.inTag = tagName + \" \"\n      } else if (state.inTag && tag && />$/.test(stream.current())) {\n        var inTag = /^([\\S]+) (.*)/.exec(state.inTag)\n        state.inTag = null\n        var modeSpec = stream.current() == \">\" && findMatchingMode(tags[inTag[1]], inTag[2])\n        var mode = CodeMirror.getMode(config, modeSpec)\n        var endTagA = getTagRegexp(inTag[1], true), endTag = getTagRegexp(inTag[1], false);\n        state.token = function (stream, state) {\n          if (stream.match(endTagA, false)) {\n            state.token = html;\n            state.localState = state.localMode = null;\n            return null;\n          }\n          return maybeBackup(stream, endTag, state.localMode.token(stream, state.localState));\n        };\n        state.localMode = mode;\n        state.localState = CodeMirror.startState(mode, htmlMode.indent(state.htmlState, \"\", \"\"));\n      } else if (state.inTag) {\n        state.inTag += stream.current()\n        if (stream.eol()) state.inTag += \" \"\n      }\n      return style;\n    };\n\n    return {\n      startState: function () {\n        var state = CodeMirror.startState(htmlMode);\n        return {token: html, inTag: null, localMode: null, localState: null, htmlState: state};\n      },\n\n      copyState: function (state) {\n        var local;\n        if (state.localState) {\n          local = CodeMirror.copyState(state.localMode, state.localState);\n        }\n        return {token: state.token, inTag: state.inTag,\n                localMode: state.localMode, localState: local,\n                htmlState: CodeMirror.copyState(htmlMode, state.htmlState)};\n      },\n\n      token: function (stream, state) {\n        return state.token(stream, state);\n      },\n\n      indent: function (state, textAfter, line) {\n        if (!state.localMode || /^\\s*<\\//.test(textAfter))\n          return htmlMode.indent(state.htmlState, textAfter, line);\n        else if (state.localMode.indent)\n          return state.localMode.indent(state.localState, textAfter, line);\n        else\n          return CodeMirror.Pass;\n      },\n\n      innerMode: function (state) {\n        return {state: state.localState || state.htmlState, mode: state.localMode || htmlMode};\n      }\n    };\n  }, \"xml\", \"javascript\", \"css\");\n\n  CodeMirror.defineMIME(\"text/html\", \"htmlmixed\");\n});\n","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/5/LICENSE\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n\"use strict\";\n\nCodeMirror.defineMode(\"javascript\", function(config, parserConfig) {\n  var indentUnit = config.indentUnit;\n  var statementIndent = parserConfig.statementIndent;\n  var jsonldMode = parserConfig.jsonld;\n  var jsonMode = parserConfig.json || jsonldMode;\n  var trackScope = parserConfig.trackScope !== false\n  var isTS = parserConfig.typescript;\n  var wordRE = parserConfig.wordCharacters || /[\\w$\\xa1-\\uffff]/;\n\n  // Tokenizer\n\n  var keywords = function(){\n    function kw(type) {return {type: type, style: \"keyword\"};}\n    var A = kw(\"keyword a\"), B = kw(\"keyword b\"), C = kw(\"keyword c\"), D = kw(\"keyword d\");\n    var operator = kw(\"operator\"), atom = {type: \"atom\", style: \"atom\"};\n\n    return {\n      \"if\": kw(\"if\"), \"while\": A, \"with\": A, \"else\": B, \"do\": B, \"try\": B, \"finally\": B,\n      \"return\": D, \"break\": D, \"continue\": D, \"new\": kw(\"new\"), \"delete\": C, \"void\": C, \"throw\": C,\n      \"debugger\": kw(\"debugger\"), \"var\": kw(\"var\"), \"const\": kw(\"var\"), \"let\": kw(\"var\"),\n      \"function\": kw(\"function\"), \"catch\": kw(\"catch\"),\n      \"for\": kw(\"for\"), \"switch\": kw(\"switch\"), \"case\": kw(\"case\"), \"default\": kw(\"default\"),\n      \"in\": operator, \"typeof\": operator, \"instanceof\": operator,\n      \"true\": atom, \"false\": atom, \"null\": atom, \"undefined\": atom, \"NaN\": atom, \"Infinity\": atom,\n      \"this\": kw(\"this\"), \"class\": kw(\"class\"), \"super\": kw(\"atom\"),\n      \"yield\": C, \"export\": kw(\"export\"), \"import\": kw(\"import\"), \"extends\": C,\n      \"await\": C\n    };\n  }();\n\n  var isOperatorChar = /[+\\-*&%=<>!?|~^@]/;\n  var isJsonldKeyword = /^@(context|id|value|language|type|container|list|set|reverse|index|base|vocab|graph)\"/;\n\n  function readRegexp(stream) {\n    var escaped = false, next, inSet = false;\n    while ((next = stream.next()) != null) {\n      if (!escaped) {\n        if (next == \"/\" && !inSet) return;\n        if (next == \"[\") inSet = true;\n        else if (inSet && next == \"]\") inSet = false;\n      }\n      escaped = !escaped && next == \"\\\\\";\n    }\n  }\n\n  // Used as scratch variables to communicate multiple values without\n  // consing up tons of objects.\n  var type, content;\n  function ret(tp, style, cont) {\n    type = tp; content = cont;\n    return style;\n  }\n  function tokenBase(stream, state) {\n    var ch = stream.next();\n    if (ch == '\"' || ch == \"'\") {\n      state.tokenize = tokenString(ch);\n      return state.tokenize(stream, state);\n    } else if (ch == \".\" && stream.match(/^\\d[\\d_]*(?:[eE][+\\-]?[\\d_]+)?/)) {\n      return ret(\"number\", \"number\");\n    } else if (ch == \".\" && stream.match(\"..\")) {\n      return ret(\"spread\", \"meta\");\n    } else if (/[\\[\\]{}\\(\\),;\\:\\.]/.test(ch)) {\n      return ret(ch);\n    } else if (ch == \"=\" && stream.eat(\">\")) {\n      return ret(\"=>\", \"operator\");\n    } else if (ch == \"0\" && stream.match(/^(?:x[\\dA-Fa-f_]+|o[0-7_]+|b[01_]+)n?/)) {\n      return ret(\"number\", \"number\");\n    } else if (/\\d/.test(ch)) {\n      stream.match(/^[\\d_]*(?:n|(?:\\.[\\d_]*)?(?:[eE][+\\-]?[\\d_]+)?)?/);\n      return ret(\"number\", \"number\");\n    } else if (ch == \"/\") {\n      if (stream.eat(\"*\")) {\n        state.tokenize = tokenComment;\n        return tokenComment(stream, state);\n      } else if (stream.eat(\"/\")) {\n        stream.skipToEnd();\n        return ret(\"comment\", \"comment\");\n      } else if (expressionAllowed(stream, state, 1)) {\n        readRegexp(stream);\n        stream.match(/^\\b(([gimyus])(?![gimyus]*\\2))+\\b/);\n        return ret(\"regexp\", \"string-2\");\n      } else {\n        stream.eat(\"=\");\n        return ret(\"operator\", \"operator\", stream.current());\n      }\n    } else if (ch == \"`\") {\n      state.tokenize = tokenQuasi;\n      return tokenQuasi(stream, state);\n    } else if (ch == \"#\" && stream.peek() == \"!\") {\n      stream.skipToEnd();\n      return ret(\"meta\", \"meta\");\n    } else if (ch == \"#\" && stream.eatWhile(wordRE)) {\n      return ret(\"variable\", \"property\")\n    } else if (ch == \"<\" && stream.match(\"!--\") ||\n               (ch == \"-\" && stream.match(\"->\") && !/\\S/.test(stream.string.slice(0, stream.start)))) {\n      stream.skipToEnd()\n      return ret(\"comment\", \"comment\")\n    } else if (isOperatorChar.test(ch)) {\n      if (ch != \">\" || !state.lexical || state.lexical.type != \">\") {\n        if (stream.eat(\"=\")) {\n          if (ch == \"!\" || ch == \"=\") stream.eat(\"=\")\n        } else if (/[<>*+\\-|&?]/.test(ch)) {\n          stream.eat(ch)\n          if (ch == \">\") stream.eat(ch)\n        }\n      }\n      if (ch == \"?\" && stream.eat(\".\")) return ret(\".\")\n      return ret(\"operator\", \"operator\", stream.current());\n    } else if (wordRE.test(ch)) {\n      stream.eatWhile(wordRE);\n      var word = stream.current()\n      if (state.lastType != \".\") {\n        if (keywords.propertyIsEnumerable(word)) {\n          var kw = keywords[word]\n          return ret(kw.type, kw.style, word)\n        }\n        if (word == \"async\" && stream.match(/^(\\s|\\/\\*([^*]|\\*(?!\\/))*?\\*\\/)*[\\[\\(\\w]/, false))\n          return ret(\"async\", \"keyword\", word)\n      }\n      return ret(\"variable\", \"variable\", word)\n    }\n  }\n\n  function tokenString(quote) {\n    return function(stream, state) {\n      var escaped = false, next;\n      if (jsonldMode && stream.peek() == \"@\" && stream.match(isJsonldKeyword)){\n        state.tokenize = tokenBase;\n        return ret(\"jsonld-keyword\", \"meta\");\n      }\n      while ((next = stream.next()) != null) {\n        if (next == quote && !escaped) break;\n        escaped = !escaped && next == \"\\\\\";\n      }\n      if (!escaped) state.tokenize = tokenBase;\n      return ret(\"string\", \"string\");\n    };\n  }\n\n  function tokenComment(stream, state) {\n    var maybeEnd = false, ch;\n    while (ch = stream.next()) {\n      if (ch == \"/\" && maybeEnd) {\n        state.tokenize = tokenBase;\n        break;\n      }\n      maybeEnd = (ch == \"*\");\n    }\n    return ret(\"comment\", \"comment\");\n  }\n\n  function tokenQuasi(stream, state) {\n    var escaped = false, next;\n    while ((next = stream.next()) != null) {\n      if (!escaped && (next == \"`\" || next == \"$\" && stream.eat(\"{\"))) {\n        state.tokenize = tokenBase;\n        break;\n      }\n      escaped = !escaped && next == \"\\\\\";\n    }\n    return ret(\"quasi\", \"string-2\", stream.current());\n  }\n\n  var brackets = \"([{}])\";\n  // This is a crude lookahead trick to try and notice that we're\n  // parsing the argument patterns for a fat-arrow function before we\n  // actually hit the arrow token. It only works if the arrow is on\n  // the same line as the arguments and there's no strange noise\n  // (comments) in between. Fallback is to only notice when we hit the\n  // arrow, and not declare the arguments as locals for the arrow\n  // body.\n  function findFatArrow(stream, state) {\n    if (state.fatArrowAt) state.fatArrowAt = null;\n    var arrow = stream.string.indexOf(\"=>\", stream.start);\n    if (arrow < 0) return;\n\n    if (isTS) { // Try to skip TypeScript return type declarations after the arguments\n      var m = /:\\s*(?:\\w+(?:<[^>]*>|\\[\\])?|\\{[^}]*\\})\\s*$/.exec(stream.string.slice(stream.start, arrow))\n      if (m) arrow = m.index\n    }\n\n    var depth = 0, sawSomething = false;\n    for (var pos = arrow - 1; pos >= 0; --pos) {\n      var ch = stream.string.charAt(pos);\n      var bracket = brackets.indexOf(ch);\n      if (bracket >= 0 && bracket < 3) {\n        if (!depth) { ++pos; break; }\n        if (--depth == 0) { if (ch == \"(\") sawSomething = true; break; }\n      } else if (bracket >= 3 && bracket < 6) {\n        ++depth;\n      } else if (wordRE.test(ch)) {\n        sawSomething = true;\n      } else if (/[\"'\\/`]/.test(ch)) {\n        for (;; --pos) {\n          if (pos == 0) return\n          var next = stream.string.charAt(pos - 1)\n          if (next == ch && stream.string.charAt(pos - 2) != \"\\\\\") { pos--; break }\n        }\n      } else if (sawSomething && !depth) {\n        ++pos;\n        break;\n      }\n    }\n    if (sawSomething && !depth) state.fatArrowAt = pos;\n  }\n\n  // Parser\n\n  var atomicTypes = {\"atom\": true, \"number\": true, \"variable\": true, \"string\": true,\n                     \"regexp\": true, \"this\": true, \"import\": true, \"jsonld-keyword\": true};\n\n  function JSLexical(indented, column, type, align, prev, info) {\n    this.indented = indented;\n    this.column = column;\n    this.type = type;\n    this.prev = prev;\n    this.info = info;\n    if (align != null) this.align = align;\n  }\n\n  function inScope(state, varname) {\n    if (!trackScope) return false\n    for (var v = state.localVars; v; v = v.next)\n      if (v.name == varname) return true;\n    for (var cx = state.context; cx; cx = cx.prev) {\n      for (var v = cx.vars; v; v = v.next)\n        if (v.name == varname) return true;\n    }\n  }\n\n  function parseJS(state, style, type, content, stream) {\n    var cc = state.cc;\n    // Communicate our context to the combinators.\n    // (Less wasteful than consing up a hundred closures on every call.)\n    cx.state = state; cx.stream = stream; cx.marked = null, cx.cc = cc; cx.style = style;\n\n    if (!state.lexical.hasOwnProperty(\"align\"))\n      state.lexical.align = true;\n\n    while(true) {\n      var combinator = cc.length ? cc.pop() : jsonMode ? expression : statement;\n      if (combinator(type, content)) {\n        while(cc.length && cc[cc.length - 1].lex)\n          cc.pop()();\n        if (cx.marked) return cx.marked;\n        if (type == \"variable\" && inScope(state, content)) return \"variable-2\";\n        return style;\n      }\n    }\n  }\n\n  // Combinator utils\n\n  var cx = {state: null, column: null, marked: null, cc: null};\n  function pass() {\n    for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);\n  }\n  function cont() {\n    pass.apply(null, arguments);\n    return true;\n  }\n  function inList(name, list) {\n    for (var v = list; v; v = v.next) if (v.name == name) return true\n    return false;\n  }\n  function register(varname) {\n    var state = cx.state;\n    cx.marked = \"def\";\n    if (!trackScope) return\n    if (state.context) {\n      if (state.lexical.info == \"var\" && state.context && state.context.block) {\n        // FIXME function decls are also not block scoped\n        var newContext = registerVarScoped(varname, state.context)\n        if (newContext != null) {\n          state.context = newContext\n          return\n        }\n      } else if (!inList(varname, state.localVars)) {\n        state.localVars = new Var(varname, state.localVars)\n        return\n      }\n    }\n    // Fall through means this is global\n    if (parserConfig.globalVars && !inList(varname, state.globalVars))\n      state.globalVars = new Var(varname, state.globalVars)\n  }\n  function registerVarScoped(varname, context) {\n    if (!context) {\n      return null\n    } else if (context.block) {\n      var inner = registerVarScoped(varname, context.prev)\n      if (!inner) return null\n      if (inner == context.prev) return context\n      return new Context(inner, context.vars, true)\n    } else if (inList(varname, context.vars)) {\n      return context\n    } else {\n      return new Context(context.prev, new Var(varname, context.vars), false)\n    }\n  }\n\n  function isModifier(name) {\n    return name == \"public\" || name == \"private\" || name == \"protected\" || name == \"abstract\" || name == \"readonly\"\n  }\n\n  // Combinators\n\n  function Context(prev, vars, block) { this.prev = prev; this.vars = vars; this.block = block }\n  function Var(name, next) { this.name = name; this.next = next }\n\n  var defaultVars = new Var(\"this\", new Var(\"arguments\", null))\n  function pushcontext() {\n    cx.state.context = new Context(cx.state.context, cx.state.localVars, false)\n    cx.state.localVars = defaultVars\n  }\n  function pushblockcontext() {\n    cx.state.context = new Context(cx.state.context, cx.state.localVars, true)\n    cx.state.localVars = null\n  }\n  pushcontext.lex = pushblockcontext.lex = true\n  function popcontext() {\n    cx.state.localVars = cx.state.context.vars\n    cx.state.context = cx.state.context.prev\n  }\n  popcontext.lex = true\n  function pushlex(type, info) {\n    var result = function() {\n      var state = cx.state, indent = state.indented;\n      if (state.lexical.type == \"stat\") indent = state.lexical.indented;\n      else for (var outer = state.lexical; outer && outer.type == \")\" && outer.align; outer = outer.prev)\n        indent = outer.indented;\n      state.lexical = new JSLexical(indent, cx.stream.column(), type, null, state.lexical, info);\n    };\n    result.lex = true;\n    return result;\n  }\n  function poplex() {\n    var state = cx.state;\n    if (state.lexical.prev) {\n      if (state.lexical.type == \")\")\n        state.indented = state.lexical.indented;\n      state.lexical = state.lexical.prev;\n    }\n  }\n  poplex.lex = true;\n\n  function expect(wanted) {\n    function exp(type) {\n      if (type == wanted) return cont();\n      else if (wanted == \";\" || type == \"}\" || type == \")\" || type == \"]\") return pass();\n      else return cont(exp);\n    };\n    return exp;\n  }\n\n  function statement(type, value) {\n    if (type == \"var\") return cont(pushlex(\"vardef\", value), vardef, expect(\";\"), poplex);\n    if (type == \"keyword a\") return cont(pushlex(\"form\"), parenExpr, statement, poplex);\n    if (type == \"keyword b\") return cont(pushlex(\"form\"), statement, poplex);\n    if (type == \"keyword d\") return cx.stream.match(/^\\s*$/, false) ? cont() : cont(pushlex(\"stat\"), maybeexpression, expect(\";\"), poplex);\n    if (type == \"debugger\") return cont(expect(\";\"));\n    if (type == \"{\") return cont(pushlex(\"}\"), pushblockcontext, block, poplex, popcontext);\n    if (type == \";\") return cont();\n    if (type == \"if\") {\n      if (cx.state.lexical.info == \"else\" && cx.state.cc[cx.state.cc.length - 1] == poplex)\n        cx.state.cc.pop()();\n      return cont(pushlex(\"form\"), parenExpr, statement, poplex, maybeelse);\n    }\n    if (type == \"function\") return cont(functiondef);\n    if (type == \"for\") return cont(pushlex(\"form\"), pushblockcontext, forspec, statement, popcontext, poplex);\n    if (type == \"class\" || (isTS && value == \"interface\")) {\n      cx.marked = \"keyword\"\n      return cont(pushlex(\"form\", type == \"class\" ? type : value), className, poplex)\n    }\n    if (type == \"variable\") {\n      if (isTS && value == \"declare\") {\n        cx.marked = \"keyword\"\n        return cont(statement)\n      } else if (isTS && (value == \"module\" || value == \"enum\" || value == \"type\") && cx.stream.match(/^\\s*\\w/, false)) {\n        cx.marked = \"keyword\"\n        if (value == \"enum\") return cont(enumdef);\n        else if (value == \"type\") return cont(typename, expect(\"operator\"), typeexpr, expect(\";\"));\n        else return cont(pushlex(\"form\"), pattern, expect(\"{\"), pushlex(\"}\"), block, poplex, poplex)\n      } else if (isTS && value == \"namespace\") {\n        cx.marked = \"keyword\"\n        return cont(pushlex(\"form\"), expression, statement, poplex)\n      } else if (isTS && value == \"abstract\") {\n        cx.marked = \"keyword\"\n        return cont(statement)\n      } else {\n        return cont(pushlex(\"stat\"), maybelabel);\n      }\n    }\n    if (type == \"switch\") return cont(pushlex(\"form\"), parenExpr, expect(\"{\"), pushlex(\"}\", \"switch\"), pushblockcontext,\n                                      block, poplex, poplex, popcontext);\n    if (type == \"case\") return cont(expression, expect(\":\"));\n    if (type == \"default\") return cont(expect(\":\"));\n    if (type == \"catch\") return cont(pushlex(\"form\"), pushcontext, maybeCatchBinding, statement, poplex, popcontext);\n    if (type == \"export\") return cont(pushlex(\"stat\"), afterExport, poplex);\n    if (type == \"import\") return cont(pushlex(\"stat\"), afterImport, poplex);\n    if (type == \"async\") return cont(statement)\n    if (value == \"@\") return cont(expression, statement)\n    return pass(pushlex(\"stat\"), expression, expect(\";\"), poplex);\n  }\n  function maybeCatchBinding(type) {\n    if (type == \"(\") return cont(funarg, expect(\")\"))\n  }\n  function expression(type, value) {\n    return expressionInner(type, value, false);\n  }\n  function expressionNoComma(type, value) {\n    return expressionInner(type, value, true);\n  }\n  function parenExpr(type) {\n    if (type != \"(\") return pass()\n    return cont(pushlex(\")\"), maybeexpression, expect(\")\"), poplex)\n  }\n  function expressionInner(type, value, noComma) {\n    if (cx.state.fatArrowAt == cx.stream.start) {\n      var body = noComma ? arrowBodyNoComma : arrowBody;\n      if (type == \"(\") return cont(pushcontext, pushlex(\")\"), commasep(funarg, \")\"), poplex, expect(\"=>\"), body, popcontext);\n      else if (type == \"variable\") return pass(pushcontext, pattern, expect(\"=>\"), body, popcontext);\n    }\n\n    var maybeop = noComma ? maybeoperatorNoComma : maybeoperatorComma;\n    if (atomicTypes.hasOwnProperty(type)) return cont(maybeop);\n    if (type == \"function\") return cont(functiondef, maybeop);\n    if (type == \"class\" || (isTS && value == \"interface\")) { cx.marked = \"keyword\"; return cont(pushlex(\"form\"), classExpression, poplex); }\n    if (type == \"keyword c\" || type == \"async\") return cont(noComma ? expressionNoComma : expression);\n    if (type == \"(\") return cont(pushlex(\")\"), maybeexpression, expect(\")\"), poplex, maybeop);\n    if (type == \"operator\" || type == \"spread\") return cont(noComma ? expressionNoComma : expression);\n    if (type == \"[\") return cont(pushlex(\"]\"), arrayLiteral, poplex, maybeop);\n    if (type == \"{\") return contCommasep(objprop, \"}\", null, maybeop);\n    if (type == \"quasi\") return pass(quasi, maybeop);\n    if (type == \"new\") return cont(maybeTarget(noComma));\n    return cont();\n  }\n  function maybeexpression(type) {\n    if (type.match(/[;\\}\\)\\],]/)) return pass();\n    return pass(expression);\n  }\n\n  function maybeoperatorComma(type, value) {\n    if (type == \",\") return cont(maybeexpression);\n    return maybeoperatorNoComma(type, value, false);\n  }\n  function maybeoperatorNoComma(type, value, noComma) {\n    var me = noComma == false ? maybeoperatorComma : maybeoperatorNoComma;\n    var expr = noComma == false ? expression : expressionNoComma;\n    if (type == \"=>\") return cont(pushcontext, noComma ? arrowBodyNoComma : arrowBody, popcontext);\n    if (type == \"operator\") {\n      if (/\\+\\+|--/.test(value) || isTS && value == \"!\") return cont(me);\n      if (isTS && value == \"<\" && cx.stream.match(/^([^<>]|<[^<>]*>)*>\\s*\\(/, false))\n        return cont(pushlex(\">\"), commasep(typeexpr, \">\"), poplex, me);\n      if (value == \"?\") return cont(expression, expect(\":\"), expr);\n      return cont(expr);\n    }\n    if (type == \"quasi\") { return pass(quasi, me); }\n    if (type == \";\") return;\n    if (type == \"(\") return contCommasep(expressionNoComma, \")\", \"call\", me);\n    if (type == \".\") return cont(property, me);\n    if (type == \"[\") return cont(pushlex(\"]\"), maybeexpression, expect(\"]\"), poplex, me);\n    if (isTS && value == \"as\") { cx.marked = \"keyword\"; return cont(typeexpr, me) }\n    if (type == \"regexp\") {\n      cx.state.lastType = cx.marked = \"operator\"\n      cx.stream.backUp(cx.stream.pos - cx.stream.start - 1)\n      return cont(expr)\n    }\n  }\n  function quasi(type, value) {\n    if (type != \"quasi\") return pass();\n    if (value.slice(value.length - 2) != \"${\") return cont(quasi);\n    return cont(maybeexpression, continueQuasi);\n  }\n  function continueQuasi(type) {\n    if (type == \"}\") {\n      cx.marked = \"string-2\";\n      cx.state.tokenize = tokenQuasi;\n      return cont(quasi);\n    }\n  }\n  function arrowBody(type) {\n    findFatArrow(cx.stream, cx.state);\n    return pass(type == \"{\" ? statement : expression);\n  }\n  function arrowBodyNoComma(type) {\n    findFatArrow(cx.stream, cx.state);\n    return pass(type == \"{\" ? statement : expressionNoComma);\n  }\n  function maybeTarget(noComma) {\n    return function(type) {\n      if (type == \".\") return cont(noComma ? targetNoComma : target);\n      else if (type == \"variable\" && isTS) return cont(maybeTypeArgs, noComma ? maybeoperatorNoComma : maybeoperatorComma)\n      else return pass(noComma ? expressionNoComma : expression);\n    };\n  }\n  function target(_, value) {\n    if (value == \"target\") { cx.marked = \"keyword\"; return cont(maybeoperatorComma); }\n  }\n  function targetNoComma(_, value) {\n    if (value == \"target\") { cx.marked = \"keyword\"; return cont(maybeoperatorNoComma); }\n  }\n  function maybelabel(type) {\n    if (type == \":\") return cont(poplex, statement);\n    return pass(maybeoperatorComma, expect(\";\"), poplex);\n  }\n  function property(type) {\n    if (type == \"variable\") {cx.marked = \"property\"; return cont();}\n  }\n  function objprop(type, value) {\n    if (type == \"async\") {\n      cx.marked = \"property\";\n      return cont(objprop);\n    } else if (type == \"variable\" || cx.style == \"keyword\") {\n      cx.marked = \"property\";\n      if (value == \"get\" || value == \"set\") return cont(getterSetter);\n      var m // Work around fat-arrow-detection complication for detecting typescript typed arrow params\n      if (isTS && cx.state.fatArrowAt == cx.stream.start && (m = cx.stream.match(/^\\s*:\\s*/, false)))\n        cx.state.fatArrowAt = cx.stream.pos + m[0].length\n      return cont(afterprop);\n    } else if (type == \"number\" || type == \"string\") {\n      cx.marked = jsonldMode ? \"property\" : (cx.style + \" property\");\n      return cont(afterprop);\n    } else if (type == \"jsonld-keyword\") {\n      return cont(afterprop);\n    } else if (isTS && isModifier(value)) {\n      cx.marked = \"keyword\"\n      return cont(objprop)\n    } else if (type == \"[\") {\n      return cont(expression, maybetype, expect(\"]\"), afterprop);\n    } else if (type == \"spread\") {\n      return cont(expressionNoComma, afterprop);\n    } else if (value == \"*\") {\n      cx.marked = \"keyword\";\n      return cont(objprop);\n    } else if (type == \":\") {\n      return pass(afterprop)\n    }\n  }\n  function getterSetter(type) {\n    if (type != \"variable\") return pass(afterprop);\n    cx.marked = \"property\";\n    return cont(functiondef);\n  }\n  function afterprop(type) {\n    if (type == \":\") return cont(expressionNoComma);\n    if (type == \"(\") return pass(functiondef);\n  }\n  function commasep(what, end, sep) {\n    function proceed(type, value) {\n      if (sep ? sep.indexOf(type) > -1 : type == \",\") {\n        var lex = cx.state.lexical;\n        if (lex.info == \"call\") lex.pos = (lex.pos || 0) + 1;\n        return cont(function(type, value) {\n          if (type == end || value == end) return pass()\n          return pass(what)\n        }, proceed);\n      }\n      if (type == end || value == end) return cont();\n      if (sep && sep.indexOf(\";\") > -1) return pass(what)\n      return cont(expect(end));\n    }\n    return function(type, value) {\n      if (type == end || value == end) return cont();\n      return pass(what, proceed);\n    };\n  }\n  function contCommasep(what, end, info) {\n    for (var i = 3; i < arguments.length; i++)\n      cx.cc.push(arguments[i]);\n    return cont(pushlex(end, info), commasep(what, end), poplex);\n  }\n  function block(type) {\n    if (type == \"}\") return cont();\n    return pass(statement, block);\n  }\n  function maybetype(type, value) {\n    if (isTS) {\n      if (type == \":\") return cont(typeexpr);\n      if (value == \"?\") return cont(maybetype);\n    }\n  }\n  function maybetypeOrIn(type, value) {\n    if (isTS && (type == \":\" || value == \"in\")) return cont(typeexpr)\n  }\n  function mayberettype(type) {\n    if (isTS && type == \":\") {\n      if (cx.stream.match(/^\\s*\\w+\\s+is\\b/, false)) return cont(expression, isKW, typeexpr)\n      else return cont(typeexpr)\n    }\n  }\n  function isKW(_, value) {\n    if (value == \"is\") {\n      cx.marked = \"keyword\"\n      return cont()\n    }\n  }\n  function typeexpr(type, value) {\n    if (value == \"keyof\" || value == \"typeof\" || value == \"infer\" || value == \"readonly\") {\n      cx.marked = \"keyword\"\n      return cont(value == \"typeof\" ? expressionNoComma : typeexpr)\n    }\n    if (type == \"variable\" || value == \"void\") {\n      cx.marked = \"type\"\n      return cont(afterType)\n    }\n    if (value == \"|\" || value == \"&\") return cont(typeexpr)\n    if (type == \"string\" || type == \"number\" || type == \"atom\") return cont(afterType);\n    if (type == \"[\") return cont(pushlex(\"]\"), commasep(typeexpr, \"]\", \",\"), poplex, afterType)\n    if (type == \"{\") return cont(pushlex(\"}\"), typeprops, poplex, afterType)\n    if (type == \"(\") return cont(commasep(typearg, \")\"), maybeReturnType, afterType)\n    if (type == \"<\") return cont(commasep(typeexpr, \">\"), typeexpr)\n    if (type == \"quasi\") { return pass(quasiType, afterType); }\n  }\n  function maybeReturnType(type) {\n    if (type == \"=>\") return cont(typeexpr)\n  }\n  function typeprops(type) {\n    if (type.match(/[\\}\\)\\]]/)) return cont()\n    if (type == \",\" || type == \";\") return cont(typeprops)\n    return pass(typeprop, typeprops)\n  }\n  function typeprop(type, value) {\n    if (type == \"variable\" || cx.style == \"keyword\") {\n      cx.marked = \"property\"\n      return cont(typeprop)\n    } else if (value == \"?\" || type == \"number\" || type == \"string\") {\n      return cont(typeprop)\n    } else if (type == \":\") {\n      return cont(typeexpr)\n    } else if (type == \"[\") {\n      return cont(expect(\"variable\"), maybetypeOrIn, expect(\"]\"), typeprop)\n    } else if (type == \"(\") {\n      return pass(functiondecl, typeprop)\n    } else if (!type.match(/[;\\}\\)\\],]/)) {\n      return cont()\n    }\n  }\n  function quasiType(type, value) {\n    if (type != \"quasi\") return pass();\n    if (value.slice(value.length - 2) != \"${\") return cont(quasiType);\n    return cont(typeexpr, continueQuasiType);\n  }\n  function continueQuasiType(type) {\n    if (type == \"}\") {\n      cx.marked = \"string-2\";\n      cx.state.tokenize = tokenQuasi;\n      return cont(quasiType);\n    }\n  }\n  function typearg(type, value) {\n    if (type == \"variable\" && cx.stream.match(/^\\s*[?:]/, false) || value == \"?\") return cont(typearg)\n    if (type == \":\") return cont(typeexpr)\n    if (type == \"spread\") return cont(typearg)\n    return pass(typeexpr)\n  }\n  function afterType(type, value) {\n    if (value == \"<\") return cont(pushlex(\">\"), commasep(typeexpr, \">\"), poplex, afterType)\n    if (value == \"|\" || type == \".\" || value == \"&\") return cont(typeexpr)\n    if (type == \"[\") return cont(typeexpr, expect(\"]\"), afterType)\n    if (value == \"extends\" || value == \"implements\") { cx.marked = \"keyword\"; return cont(typeexpr) }\n    if (value == \"?\") return cont(typeexpr, expect(\":\"), typeexpr)\n  }\n  function maybeTypeArgs(_, value) {\n    if (value == \"<\") return cont(pushlex(\">\"), commasep(typeexpr, \">\"), poplex, afterType)\n  }\n  function typeparam() {\n    return pass(typeexpr, maybeTypeDefault)\n  }\n  function maybeTypeDefault(_, value) {\n    if (value == \"=\") return cont(typeexpr)\n  }\n  function vardef(_, value) {\n    if (value == \"enum\") {cx.marked = \"keyword\"; return cont(enumdef)}\n    return pass(pattern, maybetype, maybeAssign, vardefCont);\n  }\n  function pattern(type, value) {\n    if (isTS && isModifier(value)) { cx.marked = \"keyword\"; return cont(pattern) }\n    if (type == \"variable\") { register(value); return cont(); }\n    if (type == \"spread\") return cont(pattern);\n    if (type == \"[\") return contCommasep(eltpattern, \"]\");\n    if (type == \"{\") return contCommasep(proppattern, \"}\");\n  }\n  function proppattern(type, value) {\n    if (type == \"variable\" && !cx.stream.match(/^\\s*:/, false)) {\n      register(value);\n      return cont(maybeAssign);\n    }\n    if (type == \"variable\") cx.marked = \"property\";\n    if (type == \"spread\") return cont(pattern);\n    if (type == \"}\") return pass();\n    if (type == \"[\") return cont(expression, expect(']'), expect(':'), proppattern);\n    return cont(expect(\":\"), pattern, maybeAssign);\n  }\n  function eltpattern() {\n    return pass(pattern, maybeAssign)\n  }\n  function maybeAssign(_type, value) {\n    if (value == \"=\") return cont(expressionNoComma);\n  }\n  function vardefCont(type) {\n    if (type == \",\") return cont(vardef);\n  }\n  function maybeelse(type, value) {\n    if (type == \"keyword b\" && value == \"else\") return cont(pushlex(\"form\", \"else\"), statement, poplex);\n  }\n  function forspec(type, value) {\n    if (value == \"await\") return cont(forspec);\n    if (type == \"(\") return cont(pushlex(\")\"), forspec1, poplex);\n  }\n  function forspec1(type) {\n    if (type == \"var\") return cont(vardef, forspec2);\n    if (type == \"variable\") return cont(forspec2);\n    return pass(forspec2)\n  }\n  function forspec2(type, value) {\n    if (type == \")\") return cont()\n    if (type == \";\") return cont(forspec2)\n    if (value == \"in\" || value == \"of\") { cx.marked = \"keyword\"; return cont(expression, forspec2) }\n    return pass(expression, forspec2)\n  }\n  function functiondef(type, value) {\n    if (value == \"*\") {cx.marked = \"keyword\"; return cont(functiondef);}\n    if (type == \"variable\") {register(value); return cont(functiondef);}\n    if (type == \"(\") return cont(pushcontext, pushlex(\")\"), commasep(funarg, \")\"), poplex, mayberettype, statement, popcontext);\n    if (isTS && value == \"<\") return cont(pushlex(\">\"), commasep(typeparam, \">\"), poplex, functiondef)\n  }\n  function functiondecl(type, value) {\n    if (value == \"*\") {cx.marked = \"keyword\"; return cont(functiondecl);}\n    if (type == \"variable\") {register(value); return cont(functiondecl);}\n    if (type == \"(\") return cont(pushcontext, pushlex(\")\"), commasep(funarg, \")\"), poplex, mayberettype, popcontext);\n    if (isTS && value == \"<\") return cont(pushlex(\">\"), commasep(typeparam, \">\"), poplex, functiondecl)\n  }\n  function typename(type, value) {\n    if (type == \"keyword\" || type == \"variable\") {\n      cx.marked = \"type\"\n      return cont(typename)\n    } else if (value == \"<\") {\n      return cont(pushlex(\">\"), commasep(typeparam, \">\"), poplex)\n    }\n  }\n  function funarg(type, value) {\n    if (value == \"@\") cont(expression, funarg)\n    if (type == \"spread\") return cont(funarg);\n    if (isTS && isModifier(value)) { cx.marked = \"keyword\"; return cont(funarg); }\n    if (isTS && type == \"this\") return cont(maybetype, maybeAssign)\n    return pass(pattern, maybetype, maybeAssign);\n  }\n  function classExpression(type, value) {\n    // Class expressions may have an optional name.\n    if (type == \"variable\") return className(type, value);\n    return classNameAfter(type, value);\n  }\n  function className(type, value) {\n    if (type == \"variable\") {register(value); return cont(classNameAfter);}\n  }\n  function classNameAfter(type, value) {\n    if (value == \"<\") return cont(pushlex(\">\"), commasep(typeparam, \">\"), poplex, classNameAfter)\n    if (value == \"extends\" || value == \"implements\" || (isTS && type == \",\")) {\n      if (value == \"implements\") cx.marked = \"keyword\";\n      return cont(isTS ? typeexpr : expression, classNameAfter);\n    }\n    if (type == \"{\") return cont(pushlex(\"}\"), classBody, poplex);\n  }\n  function classBody(type, value) {\n    if (type == \"async\" ||\n        (type == \"variable\" &&\n         (value == \"static\" || value == \"get\" || value == \"set\" || (isTS && isModifier(value))) &&\n         cx.stream.match(/^\\s+[\\w$\\xa1-\\uffff]/, false))) {\n      cx.marked = \"keyword\";\n      return cont(classBody);\n    }\n    if (type == \"variable\" || cx.style == \"keyword\") {\n      cx.marked = \"property\";\n      return cont(classfield, classBody);\n    }\n    if (type == \"number\" || type == \"string\") return cont(classfield, classBody);\n    if (type == \"[\")\n      return cont(expression, maybetype, expect(\"]\"), classfield, classBody)\n    if (value == \"*\") {\n      cx.marked = \"keyword\";\n      return cont(classBody);\n    }\n    if (isTS && type == \"(\") return pass(functiondecl, classBody)\n    if (type == \";\" || type == \",\") return cont(classBody);\n    if (type == \"}\") return cont();\n    if (value == \"@\") return cont(expression, classBody)\n  }\n  function classfield(type, value) {\n    if (value == \"!\") return cont(classfield)\n    if (value == \"?\") return cont(classfield)\n    if (type == \":\") return cont(typeexpr, maybeAssign)\n    if (value == \"=\") return cont(expressionNoComma)\n    var context = cx.state.lexical.prev, isInterface = context && context.info == \"interface\"\n    return pass(isInterface ? functiondecl : functiondef)\n  }\n  function afterExport(type, value) {\n    if (value == \"*\") { cx.marked = \"keyword\"; return cont(maybeFrom, expect(\";\")); }\n    if (value == \"default\") { cx.marked = \"keyword\"; return cont(expression, expect(\";\")); }\n    if (type == \"{\") return cont(commasep(exportField, \"}\"), maybeFrom, expect(\";\"));\n    return pass(statement);\n  }\n  function exportField(type, value) {\n    if (value == \"as\") { cx.marked = \"keyword\"; return cont(expect(\"variable\")); }\n    if (type == \"variable\") return pass(expressionNoComma, exportField);\n  }\n  function afterImport(type) {\n    if (type == \"string\") return cont();\n    if (type == \"(\") return pass(expression);\n    if (type == \".\") return pass(maybeoperatorComma);\n    return pass(importSpec, maybeMoreImports, maybeFrom);\n  }\n  function importSpec(type, value) {\n    if (type == \"{\") return contCommasep(importSpec, \"}\");\n    if (type == \"variable\") register(value);\n    if (value == \"*\") cx.marked = \"keyword\";\n    return cont(maybeAs);\n  }\n  function maybeMoreImports(type) {\n    if (type == \",\") return cont(importSpec, maybeMoreImports)\n  }\n  function maybeAs(_type, value) {\n    if (value == \"as\") { cx.marked = \"keyword\"; return cont(importSpec); }\n  }\n  function maybeFrom(_type, value) {\n    if (value == \"from\") { cx.marked = \"keyword\"; return cont(expression); }\n  }\n  function arrayLiteral(type) {\n    if (type == \"]\") return cont();\n    return pass(commasep(expressionNoComma, \"]\"));\n  }\n  function enumdef() {\n    return pass(pushlex(\"form\"), pattern, expect(\"{\"), pushlex(\"}\"), commasep(enummember, \"}\"), poplex, poplex)\n  }\n  function enummember() {\n    return pass(pattern, maybeAssign);\n  }\n\n  function isContinuedStatement(state, textAfter) {\n    return state.lastType == \"operator\" || state.lastType == \",\" ||\n      isOperatorChar.test(textAfter.charAt(0)) ||\n      /[,.]/.test(textAfter.charAt(0));\n  }\n\n  function expressionAllowed(stream, state, backUp) {\n    return state.tokenize == tokenBase &&\n      /^(?:operator|sof|keyword [bcd]|case|new|export|default|spread|[\\[{}\\(,;:]|=>)$/.test(state.lastType) ||\n      (state.lastType == \"quasi\" && /\\{\\s*$/.test(stream.string.slice(0, stream.pos - (backUp || 0))))\n  }\n\n  // Interface\n\n  return {\n    startState: function(basecolumn) {\n      var state = {\n        tokenize: tokenBase,\n        lastType: \"sof\",\n        cc: [],\n        lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, \"block\", false),\n        localVars: parserConfig.localVars,\n        context: parserConfig.localVars && new Context(null, null, false),\n        indented: basecolumn || 0\n      };\n      if (parserConfig.globalVars && typeof parserConfig.globalVars == \"object\")\n        state.globalVars = parserConfig.globalVars;\n      return state;\n    },\n\n    token: function(stream, state) {\n      if (stream.sol()) {\n        if (!state.lexical.hasOwnProperty(\"align\"))\n          state.lexical.align = false;\n        state.indented = stream.indentation();\n        findFatArrow(stream, state);\n      }\n      if (state.tokenize != tokenComment && stream.eatSpace()) return null;\n      var style = state.tokenize(stream, state);\n      if (type == \"comment\") return style;\n      state.lastType = type == \"operator\" && (content == \"++\" || content == \"--\") ? \"incdec\" : type;\n      return parseJS(state, style, type, content, stream);\n    },\n\n    indent: function(state, textAfter) {\n      if (state.tokenize == tokenComment || state.tokenize == tokenQuasi) return CodeMirror.Pass;\n      if (state.tokenize != tokenBase) return 0;\n      var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical, top\n      // Kludge to prevent 'maybelse' from blocking lexical scope pops\n      if (!/^\\s*else\\b/.test(textAfter)) for (var i = state.cc.length - 1; i >= 0; --i) {\n        var c = state.cc[i];\n        if (c == poplex) lexical = lexical.prev;\n        else if (c != maybeelse && c != popcontext) break;\n      }\n      while ((lexical.type == \"stat\" || lexical.type == \"form\") &&\n             (firstChar == \"}\" || ((top = state.cc[state.cc.length - 1]) &&\n                                   (top == maybeoperatorComma || top == maybeoperatorNoComma) &&\n                                   !/^[,\\.=+\\-*:?[\\(]/.test(textAfter))))\n        lexical = lexical.prev;\n      if (statementIndent && lexical.type == \")\" && lexical.prev.type == \"stat\")\n        lexical = lexical.prev;\n      var type = lexical.type, closing = firstChar == type;\n\n      if (type == \"vardef\") return lexical.indented + (state.lastType == \"operator\" || state.lastType == \",\" ? lexical.info.length + 1 : 0);\n      else if (type == \"form\" && firstChar == \"{\") return lexical.indented;\n      else if (type == \"form\") return lexical.indented + indentUnit;\n      else if (type == \"stat\")\n        return lexical.indented + (isContinuedStatement(state, textAfter) ? statementIndent || indentUnit : 0);\n      else if (lexical.info == \"switch\" && !closing && parserConfig.doubleIndentSwitch != false)\n        return lexical.indented + (/^(?:case|default)\\b/.test(textAfter) ? indentUnit : 2 * indentUnit);\n      else if (lexical.align) return lexical.column + (closing ? 0 : 1);\n      else return lexical.indented + (closing ? 0 : indentUnit);\n    },\n\n    electricInput: /^\\s*(?:case .*?:|default:|\\{|\\})$/,\n    blockCommentStart: jsonMode ? null : \"/*\",\n    blockCommentEnd: jsonMode ? null : \"*/\",\n    blockCommentContinue: jsonMode ? null : \" * \",\n    lineComment: jsonMode ? null : \"//\",\n    fold: \"brace\",\n    closeBrackets: \"()[]{}''\\\"\\\"``\",\n\n    helperType: jsonMode ? \"json\" : \"javascript\",\n    jsonldMode: jsonldMode,\n    jsonMode: jsonMode,\n\n    expressionAllowed: expressionAllowed,\n\n    skipExpression: function(state) {\n      parseJS(state, \"atom\", \"atom\", \"true\", new CodeMirror.StringStream(\"\", 2, null))\n    }\n  };\n});\n\nCodeMirror.registerHelper(\"wordChars\", \"javascript\", /[\\w$]/);\n\nCodeMirror.defineMIME(\"text/javascript\", \"javascript\");\nCodeMirror.defineMIME(\"text/ecmascript\", \"javascript\");\nCodeMirror.defineMIME(\"application/javascript\", \"javascript\");\nCodeMirror.defineMIME(\"application/x-javascript\", \"javascript\");\nCodeMirror.defineMIME(\"application/ecmascript\", \"javascript\");\nCodeMirror.defineMIME(\"application/json\", { name: \"javascript\", json: true });\nCodeMirror.defineMIME(\"application/x-json\", { name: \"javascript\", json: true });\nCodeMirror.defineMIME(\"application/manifest+json\", { name: \"javascript\", json: true })\nCodeMirror.defineMIME(\"application/ld+json\", { name: \"javascript\", jsonld: true });\nCodeMirror.defineMIME(\"text/typescript\", { name: \"javascript\", typescript: true });\nCodeMirror.defineMIME(\"application/typescript\", { name: \"javascript\", typescript: true });\n\n});\n"],"sourceRoot":""}