{"version":3,"sources":["jsdelivr-header.js","/npm/codemirror@5.65.21/mode/javascript/javascript.js"],"names":[],"mappings":"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","file":"/npm/codemirror@5.65.21/mode/javascript/javascript.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/codemirror@5.65.21/mode/javascript/javascript.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\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"]}