{"version":3,"file":"haxe-Cd8JQ-kk.cjs","sources":["../../../node_modules/@codemirror/legacy-modes/mode/haxe.js"],"sourcesContent":["// Tokenizer\n\nfunction kw(type) {return {type: type, style: \"keyword\"};}\nvar A = kw(\"keyword a\"), B = kw(\"keyword b\"), C = kw(\"keyword c\");\nvar operator = kw(\"operator\"), atom = {type: \"atom\", style: \"atom\"}, attribute = {type:\"attribute\", style: \"attribute\"};\nvar type = kw(\"typedef\");\nvar keywords = {\n  \"if\": A, \"while\": A, \"else\": B, \"do\": B, \"try\": B,\n  \"return\": C, \"break\": C, \"continue\": C, \"new\": C, \"throw\": C,\n  \"var\": kw(\"var\"), \"inline\":attribute, \"static\": attribute, \"using\":kw(\"import\"),\n  \"public\": attribute, \"private\": attribute, \"cast\": kw(\"cast\"), \"import\": kw(\"import\"), \"macro\": kw(\"macro\"),\n  \"function\": kw(\"function\"), \"catch\": kw(\"catch\"), \"untyped\": kw(\"untyped\"), \"callback\": kw(\"cb\"),\n  \"for\": kw(\"for\"), \"switch\": kw(\"switch\"), \"case\": kw(\"case\"), \"default\": kw(\"default\"),\n  \"in\": operator, \"never\": kw(\"property_access\"), \"trace\":kw(\"trace\"),\n  \"class\": type, \"abstract\":type, \"enum\":type, \"interface\":type, \"typedef\":type, \"extends\":type, \"implements\":type, \"dynamic\":type,\n  \"true\": atom, \"false\": atom, \"null\": atom\n};\n\nvar isOperatorChar = /[+\\-*&%=<>!?|]/;\n\nfunction chain(stream, state, f) {\n  state.tokenize = f;\n  return f(stream, state);\n}\n\nfunction toUnescaped(stream, end) {\n  var escaped = false, next;\n  while ((next = stream.next()) != null) {\n    if (next == end && !escaped)\n      return true;\n    escaped = !escaped && next == \"\\\\\";\n  }\n}\n\n// Used as scratch variables to communicate multiple values without\n// consing up tons of objects.\nvar type, content;\nfunction ret(tp, style, cont) {\n  type = tp; content = cont;\n  return style;\n}\n\nfunction haxeTokenBase(stream, state) {\n  var ch = stream.next();\n  if (ch == '\"' || ch == \"'\") {\n    return chain(stream, state, haxeTokenString(ch));\n  } else if (/[\\[\\]{}\\(\\),;\\:\\.]/.test(ch)) {\n    return ret(ch);\n  } else if (ch == \"0\" && stream.eat(/x/i)) {\n    stream.eatWhile(/[\\da-f]/i);\n    return ret(\"number\", \"number\");\n  } else if (/\\d/.test(ch) || ch == \"-\" && stream.eat(/\\d/)) {\n    stream.match(/^\\d*(?:\\.\\d*(?!\\.))?(?:[eE][+\\-]?\\d+)?/);\n    return ret(\"number\", \"number\");\n  } else if (state.reAllowed && (ch == \"~\" && stream.eat(/\\//))) {\n    toUnescaped(stream, \"/\");\n    stream.eatWhile(/[gimsu]/);\n    return ret(\"regexp\", \"string.special\");\n  } else if (ch == \"/\") {\n    if (stream.eat(\"*\")) {\n      return chain(stream, state, haxeTokenComment);\n    } else if (stream.eat(\"/\")) {\n      stream.skipToEnd();\n      return ret(\"comment\", \"comment\");\n    } else {\n      stream.eatWhile(isOperatorChar);\n      return ret(\"operator\", null, stream.current());\n    }\n  } else if (ch == \"#\") {\n    stream.skipToEnd();\n    return ret(\"conditional\", \"meta\");\n  } else if (ch == \"@\") {\n    stream.eat(/:/);\n    stream.eatWhile(/[\\w_]/);\n    return ret (\"metadata\", \"meta\");\n  } else if (isOperatorChar.test(ch)) {\n    stream.eatWhile(isOperatorChar);\n    return ret(\"operator\", null, stream.current());\n  } else {\n    var word;\n    if(/[A-Z]/.test(ch)) {\n      stream.eatWhile(/[\\w_<>]/);\n      word = stream.current();\n      return ret(\"type\", \"type\", word);\n    } else {\n      stream.eatWhile(/[\\w_]/);\n      var word = stream.current(), known = keywords.propertyIsEnumerable(word) && keywords[word];\n      return (known && state.kwAllowed) ? ret(known.type, known.style, word) :\n        ret(\"variable\", \"variable\", word);\n    }\n  }\n}\n\nfunction haxeTokenString(quote) {\n  return function(stream, state) {\n    if (toUnescaped(stream, quote))\n      state.tokenize = haxeTokenBase;\n    return ret(\"string\", \"string\");\n  };\n}\n\nfunction haxeTokenComment(stream, state) {\n  var maybeEnd = false, ch;\n  while (ch = stream.next()) {\n    if (ch == \"/\" && maybeEnd) {\n      state.tokenize = haxeTokenBase;\n      break;\n    }\n    maybeEnd = (ch == \"*\");\n  }\n  return ret(\"comment\", \"comment\");\n}\n\n// Parser\n\nvar atomicTypes = {\"atom\": true, \"number\": true, \"variable\": true, \"string\": true, \"regexp\": true};\n\nfunction HaxeLexical(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\nfunction inScope(state, varname) {\n  for (var v = state.localVars; v; v = v.next)\n    if (v.name == varname) return true;\n}\n\nfunction parseHaxe(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;\n\n  if (!state.lexical.hasOwnProperty(\"align\"))\n    state.lexical.align = true;\n\n  while(true) {\n    var combinator = cc.length ? cc.pop() : 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      if (type == \"variable\" && imported(state, content)) return \"variableName.special\";\n      return style;\n    }\n  }\n}\n\nfunction imported(state, typename) {\n  if (/[a-z]/.test(typename.charAt(0)))\n    return false;\n  var len = state.importedtypes.length;\n  for (var i = 0; i<len; i++)\n    if(state.importedtypes[i]==typename) return true;\n}\n\nfunction registerimport(importname) {\n  var state = cx.state;\n  for (var t = state.importedtypes; t; t = t.next)\n    if(t.name == importname) return;\n  state.importedtypes = { name: importname, next: state.importedtypes };\n}\n// Combinator utils\n\nvar cx = {state: null, column: null, marked: null, cc: null};\nfunction pass() {\n  for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);\n}\nfunction cont() {\n  pass.apply(null, arguments);\n  return true;\n}\nfunction inList(name, list) {\n  for (var v = list; v; v = v.next)\n    if (v.name == name) return true;\n  return false;\n}\nfunction register(varname) {\n  var state = cx.state;\n  if (state.context) {\n    cx.marked = \"def\";\n    if (inList(varname, state.localVars)) return;\n    state.localVars = {name: varname, next: state.localVars};\n  } else if (state.globalVars) {\n    if (inList(varname, state.globalVars)) return;\n    state.globalVars = {name: varname, next: state.globalVars};\n  }\n}\n\n// Combinators\n\nvar defaultVars = {name: \"this\", next: null};\nfunction pushcontext() {\n  if (!cx.state.context) cx.state.localVars = defaultVars;\n  cx.state.context = {prev: cx.state.context, vars: cx.state.localVars};\n}\nfunction popcontext() {\n  cx.state.localVars = cx.state.context.vars;\n  cx.state.context = cx.state.context.prev;\n}\npopcontext.lex = true;\nfunction pushlex(type, info) {\n  var result = function() {\n    var state = cx.state;\n    state.lexical = new HaxeLexical(state.indented, cx.stream.column(), type, null, state.lexical, info);\n  };\n  result.lex = true;\n  return result;\n}\nfunction 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}\npoplex.lex = true;\n\nfunction expect(wanted) {\n  function f(type) {\n    if (type == wanted) return cont();\n    else if (wanted == \";\") return pass();\n    else return cont(f);\n  }\n  return f;\n}\n\nfunction statement(type) {\n  if (type == \"@\") return cont(metadef);\n  if (type == \"var\") return cont(pushlex(\"vardef\"), vardef1, expect(\";\"), poplex);\n  if (type == \"keyword a\") return cont(pushlex(\"form\"), expression, statement, poplex);\n  if (type == \"keyword b\") return cont(pushlex(\"form\"), statement, poplex);\n  if (type == \"{\") return cont(pushlex(\"}\"), pushcontext, block, poplex, popcontext);\n  if (type == \";\") return cont();\n  if (type == \"attribute\") return cont(maybeattribute);\n  if (type == \"function\") return cont(functiondef);\n  if (type == \"for\") return cont(pushlex(\"form\"), expect(\"(\"), pushlex(\")\"), forspec1, expect(\")\"),\n                                 poplex, statement, poplex);\n  if (type == \"variable\") return cont(pushlex(\"stat\"), maybelabel);\n  if (type == \"switch\") return cont(pushlex(\"form\"), expression, pushlex(\"}\", \"switch\"), expect(\"{\"),\n                                    block, poplex, poplex);\n  if (type == \"case\") return cont(expression, expect(\":\"));\n  if (type == \"default\") return cont(expect(\":\"));\n  if (type == \"catch\") return cont(pushlex(\"form\"), pushcontext, expect(\"(\"), funarg, expect(\")\"),\n                                   statement, poplex, popcontext);\n  if (type == \"import\") return cont(importdef, expect(\";\"));\n  if (type == \"typedef\") return cont(typedef);\n  return pass(pushlex(\"stat\"), expression, expect(\";\"), poplex);\n}\nfunction expression(type) {\n  if (atomicTypes.hasOwnProperty(type)) return cont(maybeoperator);\n  if (type == \"type\" ) return cont(maybeoperator);\n  if (type == \"function\") return cont(functiondef);\n  if (type == \"keyword c\") return cont(maybeexpression);\n  if (type == \"(\") return cont(pushlex(\")\"), maybeexpression, expect(\")\"), poplex, maybeoperator);\n  if (type == \"operator\") return cont(expression);\n  if (type == \"[\") return cont(pushlex(\"]\"), commasep(maybeexpression, \"]\"), poplex, maybeoperator);\n  if (type == \"{\") return cont(pushlex(\"}\"), commasep(objprop, \"}\"), poplex, maybeoperator);\n  return cont();\n}\nfunction maybeexpression(type) {\n  if (type.match(/[;\\}\\)\\],]/)) return pass();\n  return pass(expression);\n}\n\nfunction maybeoperator(type, value) {\n  if (type == \"operator\" && /\\+\\+|--/.test(value)) return cont(maybeoperator);\n  if (type == \"operator\" || type == \":\") return cont(expression);\n  if (type == \";\") return;\n  if (type == \"(\") return cont(pushlex(\")\"), commasep(expression, \")\"), poplex, maybeoperator);\n  if (type == \".\") return cont(property, maybeoperator);\n  if (type == \"[\") return cont(pushlex(\"]\"), expression, expect(\"]\"), poplex, maybeoperator);\n}\n\nfunction maybeattribute(type) {\n  if (type == \"attribute\") return cont(maybeattribute);\n  if (type == \"function\") return cont(functiondef);\n  if (type == \"var\") return cont(vardef1);\n}\n\nfunction metadef(type) {\n  if(type == \":\") return cont(metadef);\n  if(type == \"variable\") return cont(metadef);\n  if(type == \"(\") return cont(pushlex(\")\"), commasep(metaargs, \")\"), poplex, statement);\n}\nfunction metaargs(type) {\n  if(type == \"variable\") return cont();\n}\n\nfunction importdef (type, value) {\n  if(type == \"variable\" && /[A-Z]/.test(value.charAt(0))) { registerimport(value); return cont(); }\n  else if(type == \"variable\" || type == \"property\" || type == \".\" || value == \"*\") return cont(importdef);\n}\n\nfunction typedef (type, value)\n{\n  if(type == \"variable\" && /[A-Z]/.test(value.charAt(0))) { registerimport(value); return cont(); }\n  else if (type == \"type\" && /[A-Z]/.test(value.charAt(0))) { return cont(); }\n}\n\nfunction maybelabel(type) {\n  if (type == \":\") return cont(poplex, statement);\n  return pass(maybeoperator, expect(\";\"), poplex);\n}\nfunction property(type) {\n  if (type == \"variable\") {cx.marked = \"property\"; return cont();}\n}\nfunction objprop(type) {\n  if (type == \"variable\") cx.marked = \"property\";\n  if (atomicTypes.hasOwnProperty(type)) return cont(expect(\":\"), expression);\n}\nfunction commasep(what, end) {\n  function proceed(type) {\n    if (type == \",\") return cont(what, proceed);\n    if (type == end) return cont();\n    return cont(expect(end));\n  }\n  return function(type) {\n    if (type == end) return cont();\n    else return pass(what, proceed);\n  };\n}\nfunction block(type) {\n  if (type == \"}\") return cont();\n  return pass(statement, block);\n}\nfunction vardef1(type, value) {\n  if (type == \"variable\"){register(value); return cont(typeuse, vardef2);}\n  return cont();\n}\nfunction vardef2(type, value) {\n  if (value == \"=\") return cont(expression, vardef2);\n  if (type == \",\") return cont(vardef1);\n}\nfunction forspec1(type, value) {\n  if (type == \"variable\") {\n    register(value);\n    return cont(forin, expression)\n  } else {\n    return pass()\n  }\n}\nfunction forin(_type, value) {\n  if (value == \"in\") return cont();\n}\nfunction functiondef(type, value) {\n  //function names starting with upper-case letters are recognised as types, so cludging them together here.\n  if (type == \"variable\" || type == \"type\") {register(value); return cont(functiondef);}\n  if (value == \"new\") return cont(functiondef);\n  if (type == \"(\") return cont(pushlex(\")\"), pushcontext, commasep(funarg, \")\"), poplex, typeuse, statement, popcontext);\n}\nfunction typeuse(type) {\n  if(type == \":\") return cont(typestring);\n}\nfunction typestring(type) {\n  if(type == \"type\") return cont();\n  if(type == \"variable\") return cont();\n  if(type == \"{\") return cont(pushlex(\"}\"), commasep(typeprop, \"}\"), poplex);\n}\nfunction typeprop(type) {\n  if(type == \"variable\") return cont(typeuse);\n}\nfunction funarg(type, value) {\n  if (type == \"variable\") {register(value); return cont(typeuse);}\n}\n\n// Interface\nexport const haxe = {\n  name: \"haxe\",\n  startState: function(indentUnit) {\n    var defaulttypes = [\"Int\", \"Float\", \"String\", \"Void\", \"Std\", \"Bool\", \"Dynamic\", \"Array\"];\n    var state = {\n      tokenize: haxeTokenBase,\n      reAllowed: true,\n      kwAllowed: true,\n      cc: [],\n      lexical: new HaxeLexical(-indentUnit, 0, \"block\", false),\n      importedtypes: defaulttypes,\n      context: null,\n      indented: 0\n    };\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    }\n    if (stream.eatSpace()) return null;\n    var style = state.tokenize(stream, state);\n    if (type == \"comment\") return style;\n    state.reAllowed = !!(type == \"operator\" || type == \"keyword c\" || type.match(/^[\\[{}\\(,;:]$/));\n    state.kwAllowed = type != '.';\n    return parseHaxe(state, style, type, content, stream);\n  },\n\n  indent: function(state, textAfter, cx) {\n    if (state.tokenize != haxeTokenBase) return 0;\n    var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical;\n    if (lexical.type == \"stat\" && firstChar == \"}\") lexical = lexical.prev;\n    var type = lexical.type, closing = firstChar == type;\n    if (type == \"vardef\") return lexical.indented + 4;\n    else if (type == \"form\" && firstChar == \"{\") return lexical.indented;\n    else if (type == \"stat\" || type == \"form\") return lexical.indented + cx.unit;\n    else if (lexical.info == \"switch\" && !closing)\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*[{}]$/,\n    commentTokens: {line: \"//\", block: {open: \"/*\", close: \"*/\"}}\n  }\n};\n\nexport const hxml = {\n  name: \"hxml\",\n  startState: function () {\n    return {\n      define: false,\n      inString: false\n    };\n  },\n  token: function (stream, state) {\n    var ch = stream.peek();\n    var sol = stream.sol();\n\n    ///* comments */\n    if (ch == \"#\") {\n      stream.skipToEnd();\n      return \"comment\";\n    }\n    if (sol && ch == \"-\") {\n      var style = \"variable-2\";\n\n      stream.eat(/-/);\n\n      if (stream.peek() == \"-\") {\n        stream.eat(/-/);\n        style = \"keyword a\";\n      }\n\n      if (stream.peek() == \"D\") {\n        stream.eat(/[D]/);\n        style = \"keyword c\";\n        state.define = true;\n      }\n\n      stream.eatWhile(/[A-Z]/i);\n      return style;\n    }\n\n    var ch = stream.peek();\n\n    if (state.inString == false && ch == \"'\") {\n      state.inString = true;\n      stream.next();\n    }\n\n    if (state.inString == true) {\n      if (stream.skipTo(\"'\")) {\n\n      } else {\n        stream.skipToEnd();\n      }\n\n      if (stream.peek() == \"'\") {\n        stream.next();\n        state.inString = false;\n      }\n\n      return \"string\";\n    }\n\n    stream.next();\n    return null;\n  },\n  languageData: {\n    commentTokens: {line: \"#\"}\n  }\n}\n"],"names":["kw","type","style","content","A","B","C","operator","atom","attribute","keywords","if","while","else","do","try","return","break","continue","new","throw","var","inline","static","using","public","private","cast","import","macro","function","catch","untyped","callback","for","switch","case","default","in","never","trace","class","abstract","enum","interface","typedef","extends","implements","dynamic","true","false","null","isOperatorChar","chain","stream","state","f","tokenize","toUnescaped","end","next","escaped","ret","tp","cont","haxeTokenBase","ch","quote","test","eat","eatWhile","match","reAllowed","haxeTokenComment","skipToEnd","current","word","known","propertyIsEnumerable","kwAllowed","maybeEnd","atomicTypes","number","variable","string","regexp","HaxeLexical","indented","column","align","prev","info","this","inScope","varname","v","localVars","name","imported","typename","charAt","len","importedtypes","length","i","registerimport","importname","cx","t","marked","cc","pass","arguments","push","apply","inList","list","register","context","globalVars","defaultVars","pushcontext","vars","popcontext","pushlex","result","lexical","lex","poplex","expect","wanted","statement","metadef","vardef1","expression","block","maybeattribute","functiondef","forspec1","maybelabel","funarg","importdef","hasOwnProperty","maybeoperator","maybeexpression","commasep","objprop","value","property","metaargs","what","proceed","typeuse","vardef2","forin","_type","typestring","typeprop","haxe","startState","indentUnit","token","sol","indentation","eatSpace","pop","parseHaxe","indent","textAfter","firstChar","closing","unit","languageData","indentOnInput","commentTokens","line","open","close","define","inString","peek","skipTo"],"mappings":"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","x_google_ignoreList":[0]}