1{"version":3,"sources":["../../node_modules/codemirror/mode/javascript/javascript.js"],"names":["mod","exports","module","require","define","amd","CodeMirror","defineMode","config","parserConfig","indentUnit","statementIndent","jsonldMode","jsonld","jsonMode","json","isTS","typescript","wordRE","wordCharacters","keywords","kw","type","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","readRegexp","stream","escaped","next","inSet","content","ret","tp","cont","tokenBase","state","ch","tokenize","tokenString","match","test","eat","tokenComment","skipToEnd","expressionAllowed","current","tokenQuasi","peek","eatWhile","string","slice","start","lexical","word","lastType","propertyIsEnumerable","quote","maybeEnd","brackets","findFatArrow","fatArrowAt","arrow","indexOf","m","exec","index","depth","sawSomething","pos","charAt","bracket","atomicTypes","number","variable","regexp","jsonld-keyword","JSLexical","indented","column","align","prev","info","inScope","varname","v","localVars","name","cx","context","vars","parseJS","cc","marked","hasOwnProperty","combinator","length","pop","expression","statement","lex","pass","i","arguments","push","apply","inList","list","register","block","newContext","registerVarScoped","Var","globalVars","inner","Context","isModifier","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","backUp","continueQuasi","targetNoComma","target","maybeTypeArgs","_","getterSetter","afterprop","maybetype","what","end","sep","proceed","maybetypeOrIn","mayberettype","isKW","afterType","typeprop","typearg","maybeReturnType","functiondecl","typeparam","maybeTypeDefault","maybeAssign","vardefCont","eltpattern","proppattern","_type","forspec1","forspec2","classNameAfter","classBody","classfield","isInterface","maybeFrom","exportField","importSpec","maybeMoreImports","maybeAs","enummember","isContinuedStatement","textAfter","startState","basecolumn","token","sol","indentation","eatSpace","Pass","firstChar","top","c","closing","doubleIndentSwitch","electricInput","blockCommentStart","blockCommentEnd","blockCommentContinue","lineComment","fold","closeBrackets","helperType","skipExpression","registerHelper","defineMIME"],"mappings":"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","file":"javascript.min.js","sourcesContent":["// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/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 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, \"regexp\": true, \"this\": 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 \"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 (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 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\"), forspec, statement, 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 if (type == \"import\") return cont(expression);\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(expression, 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\") {\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(\"}\"), commasep(typeprop, \"}\", \",;\"), poplex, afterType)\n if (type == \"(\") return cont(commasep(typearg, \")\"), maybeReturnType, afterType)\n if (type == \"<\") return cont(commasep(typeexpr, \">\"), typeexpr)\n }\n function maybeReturnType(type) {\n if (type == \"=>\") return cont(typeexpr)\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 }\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 (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 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) 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) 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 var top = state.cc[state.cc.length - 1]\n if (top == expression || top == expressionNoComma) state.cc.pop()\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/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"]}