{"version":3,"file":"javascript-DngSGg_0.cjs","sources":["../node_modules/@codemirror/legacy-modes/mode/javascript.js"],"sourcesContent":["function mkJavaScript(parserConfig) {\n  var statementIndent = parserConfig.statementIndent;\n  var jsonldMode = parserConfig.jsonld;\n  var jsonMode = parserConfig.json || jsonldMode;\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.special\");\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.special\", 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    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 \"variableName.local\";\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 (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.special\";\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.special\";\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 == \"!\" || 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    name: parserConfig.name,\n\n    startState: function(indentUnit) {\n      var state = {\n        tokenize: tokenBase,\n        lastType: \"sof\",\n        cc: [],\n        lexical: new JSLexical(-indentUnit, 0, \"block\", false),\n        localVars: parserConfig.localVars,\n        context: parserConfig.localVars && new Context(null, null, false),\n        indented: 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, cx) {\n      if (state.tokenize == tokenComment || state.tokenize == tokenQuasi) return null;\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 + cx.unit;\n      else if (type == \"stat\")\n        return lexical.indented + (isContinuedStatement(state, textAfter) ? statementIndent || cx.unit : 0);\n      else if (lexical.info == \"switch\" && !closing && parserConfig.doubleIndentSwitch != false)\n        return lexical.indented + (/^(?:case|default)\\b/.test(textAfter) ? cx.unit : 2 * cx.unit);\n      else if (lexical.align) return lexical.column + (closing ? 0 : 1);\n      else return lexical.indented + (closing ? 0 : cx.unit);\n    },\n\n    languageData: {\n      indentOnInput: /^\\s*(?:case .*?:|default:|\\{|\\})$/,\n      commentTokens: jsonMode ? undefined : {line: \"//\", block: {open: \"/*\", close: \"*/\"}},\n      closeBrackets: {brackets: [\"(\", \"[\", \"{\", \"'\", '\"', \"`\"]},\n      wordChars: \"$\"\n    }\n  };\n};\n\nexport const javascript = mkJavaScript({name: \"javascript\"})\nexport const json = mkJavaScript({name: \"json\", json: true})\nexport const jsonld = mkJavaScript({name: \"json\", jsonld: true})\nexport const typescript = mkJavaScript({name: \"typescript\", typescript: true})\n"],"names":["mkJavaScript","parserConfig","statementIndent","jsonldMode","jsonMode","isTS","wordRE","keywords","kw","type","A","B","C","D","operator","atom","isOperatorChar","isJsonldKeyword","readRegexp","stream","escaped","next","inSet","content","ret","tp","style","cont","tokenBase","state","ch","tokenString","tokenComment","expressionAllowed","tokenQuasi","word","quote","maybeEnd","brackets","findFatArrow","arrow","m","depth","sawSomething","pos","bracket","atomicTypes","JSLexical","indented","column","align","prev","info","inScope","varname","v","cx","parseJS","cc","combinator","expression","statement","pass","i","inList","name","list","register","newContext","registerVarScoped","Var","context","inner","Context","isModifier","vars","block","defaultVars","pushcontext","pushblockcontext","popcontext","pushlex","result","indent","outer","poplex","expect","wanted","exp","value","vardef","parenExpr","maybeexpression","maybeelse","functiondef","forspec","className","enumdef","typename","typeexpr","pattern","maybelabel","maybeCatchBinding","afterExport","afterImport","funarg","expressionInner","expressionNoComma","noComma","body","arrowBodyNoComma","arrowBody","commasep","maybeop","maybeoperatorNoComma","maybeoperatorComma","classExpression","arrayLiteral","contCommasep","objprop","quasi","maybeTarget","me","expr","property","continueQuasi","targetNoComma","target","maybeTypeArgs","_","getterSetter","afterprop","maybetype","what","end","sep","proceed","lex","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","textAfter","backUp","indentUnit","firstChar","lexical","top","c","closing","javascript","jsonld"],"mappings":"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","x_google_ignoreList":[0]}