{"version":3,"file":"javascript-D6Y0eXWo.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","type","content","statementIndent","jsonldMode","jsonld","jsonMode","json","isTS","typescript","wordRE","wordCharacters","keywords","kw","style","A","B","C","D","operator","atom","if","while","with","else","do","try","finally","return","break","continue","new","delete","void","throw","debugger","var","const","let","function","catch","for","switch","case","default","in","typeof","instanceof","true","false","null","undefined","NaN","Infinity","this","class","super","yield","export","import","extends","await","isOperatorChar","isJsonldKeyword","ret","tp","cont","tokenBase","stream","state","quote","ch","next","tokenize","escaped","peek","match","test","eat","tokenComment","skipToEnd","backUp","lastType","string","slice","pos","expressionAllowed","inSet","readRegexp","current","tokenQuasi","eatWhile","start","lexical","word","propertyIsEnumerable","maybeEnd","findFatArrow","fatArrowAt","arrow","indexOf","m","exec","index","depth","sawSomething","charAt","bracket","atomicTypes","number","variable","regexp","JSLexical","indented","column","align","prev","info","inScope","varname","v","localVars","name","cx","context","vars","marked","cc","pass","i","arguments","length","push","apply","inList","list","register","block","newContext","registerVarScoped","Var","globalVars","inner","Context","isModifier","defaultVars","pushcontext","pushblockcontext","popcontext","pushlex","result","indent","outer","lex","poplex","expect","wanted","exp","statement","value","vardef","parenExpr","maybeexpression","pop","maybeelse","functiondef","forspec","className","enumdef","typename","typeexpr","pattern","expression","maybelabel","maybeCatchBinding","afterExport","afterImport","funarg","expressionInner","expressionNoComma","noComma","body","arrowBodyNoComma","arrowBody","commasep","maybeop","maybeoperatorNoComma","maybeoperatorComma","hasOwnProperty","classExpression","arrayLiteral","contCommasep","objprop","quasi","targetNoComma","target","maybeTypeArgs","maybeTarget","me","expr","property","continueQuasi","_","getterSetter","afterprop","maybetype","what","end","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","maybeFrom","exportField","importSpec","maybeMoreImports","maybeAs","enummember","startState","indentUnit","token","sol","indentation","eatSpace","parseJS","textAfter","top","firstChar","c","closing","unit","isContinuedStatement","doubleIndentSwitch","languageData","indentOnInput","commentTokens","line","open","close","closeBrackets","brackets","wordChars","javascript"],"mappings":"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","x_google_ignoreList":[0]}