@live-codes/browser-compilers 0.5.1 → 0.5.2

package/vendor_modules/modules/monaco-languages/imba.ts

@@ -0,0 +1,1520 @@
+/* eslint-disable */
+// @ts-nocheck
+
+// from https://github.com/imba/imba.io/blob/master/scripts/lexer/grammar.imba
+// and https://github.com/imba/imba.io/blob/master/src/repl/languages/imba.imba
+
+function iter$__(a) {
+  let v;
+  return a ? ((v = a.toIterable) ? v.call(a) : a) : [];
+}
+
+/*body*/
+const eolpop = [/^/, { token: '@rematch', next: '@pop' }];
+const repop = { token: '@rematch', next: '@pop' };
+const toodeep = { token: 'white.indent', next: '@>illegal_indent' };
+
+const EOF = '§EOF§';
+
+function regexify(array, pattern = '#') {
+  if (typeof array == 'string') {
+    array = array.split(' ');
+  }
+
+  let items = array.slice().sort(function (_0, _1) {
+    return _1.length - _0.length;
+  });
+  items = items.map(function (item) {
+    let escaped = item.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&');
+    return pattern.replace('#', escaped);
+  });
+  return new RegExp('(?:' + items.join('|') + ')');
+}
+
+function denter(indent, outdent, stay, o = {}) {
+  var v$φ;
+
+  if (indent == null) {
+    indent = toodeep;
+  } else if (indent == 1) {
+    indent = { next: '@>' };
+  } else if (indent == 2) {
+    indent = { next: '@>_indent&-_indent' };
+  } else if (typeof indent == 'string') {
+    indent = { next: indent };
+  }
+
+  if (outdent == -1) {
+    outdent = repop;
+  }
+  if (stay == -1) {
+    stay = repop;
+  } else if (stay == 0) {
+    o.comment == null ? (o.comment = true) : o.comment;
+
+    stay = {};
+  }
+
+  indent = Object.assign({ token: 'white.tabs' }, indent || {});
+  stay = Object.assign({ token: 'white.tabs' }, stay || {});
+  outdent = Object.assign({ token: '@rematch', next: '@pop' }, outdent || {});
+
+  let cases = {
+    '$1==$S2\t': indent,
+    '$1==$S2': {
+      cases: { '$1==$S6': stay, '@default': { token: '@rematch', switchTo: '@*$1' } },
+    },
+    '@default': outdent,
+  };
+  v$φ = 0;
+  for (let k of ['next', 'switchTo']) {
+    let v = v$φ++;
+    if (indent[k] && indent[k].indexOf('*') == -1) {
+      indent[k] += '*$1';
+    }
+  }
+
+  // for own k,v of cases
+  let rule = [/^(\t*)(?=[^ \t\n])/, { cases: cases }];
+  if (o.comment) {
+    let clones = {};
+    for (let iφ = 0, keysφ = Object.keys(cases), lφ = keysφ.length, k, v; iφ < lφ; iφ++) {
+      k = keysφ[iφ];
+      v = cases[k];
+      let clone = Object.assign({}, v);
+      if (!clone.next && !clone.switchTo) {
+        clone.next = '@>_comment';
+      }
+      clones[k] = clone;
+    }
+    return [[/^(\t*)(?=#\s|#$)/, { cases: clones }], rule];
+  }
+
+  return rule;
+}
+
+const states = {
+  root: [
+    [/^@comment/, 'comment', '@>_comment'], // want to push this state _ before the token
+    [
+      /^(\t+)(?=[^\t\n])/,
+      {
+        cases: {
+          '$1==$S2\t': { token: 'white.indent', next: '@>_indent*$1' },
+          '@default': 'white.indent',
+        },
+      },
+    ],
+    'block_',
+  ],
+
+  _comment: [
+    [/^([\t\s\n]*)$/, 'comment'],
+    [
+      /^(\t*)([\S\s]*)/,
+      {
+        cases: {
+          // same or deeper indentation
+          '$1~$S2\t*': { token: 'comment' },
+          '@default': { token: '@rematch', next: '@pop' },
+        },
+      },
+    ],
+    [/[\S\s]+/, 'comment'],
+  ],
+
+  illegal_indent: [denter()],
+
+  identifier_: [
+    [/\$\w+\$/, 'identifier.env'],
+    [/\$\d+/, 'identifier.special'],
+    [/\#+@id/, 'identifier.symbol'],
+    [/\¶@id/, 'ivar'], // imba1
+    [
+      /@id\!?/,
+      {
+        cases: {
+          this: 'this',
+          self: 'self',
+          '@keywords': 'keyword.$#',
+          '$0~[A-Z].*': 'identifier.uppercase.$F',
+          '@default': 'identifier.$F',
+        },
+      },
+    ],
+  ],
+
+  block_: [
+    // 'common_'
+    [/^(\t+)(?=[\r\n]|$)/, 'white.tabs'],
+    'class_',
+    'tagclass_',
+    'var_',
+    'func_',
+    'import_',
+    'export_',
+    'flow_',
+    'for_',
+    'try_',
+    'catch_',
+    'while_',
+    'css_',
+    'tag_',
+    'do_',
+    'block_comment_',
+    'expr_',
+    [/[ ]+/, 'white'],
+    'common_',
+  ],
+
+  indentable_: [
+    [/^[ ]+/, 'white'],
+    denter('@>_paren_indent&-_indent', null, null),
+    [/^(\t+)(?=[\r\n]|$)/, 'white.tabs'],
+    'whitespace',
+  ],
+
+  _indent: [denter(2, -1, 0), 'block_'],
+
+  _paren_indent: [denter(2, -1, 0), 'block_', [/\)|\}|\]/, '@rematch', '@pop']],
+
+  block: [denter('@>', -1, 0), 'block_'],
+  bool_: [[/(true|false|yes|no|undefined|null)(?![\:\-\w\.\_])/, 'boolean']],
+
+  op_: [
+    [/\s+\:\s+/, 'operator.ternary'],
+    // [/\s*(\=)/]
+    [
+      /(@unspaced_ops)/,
+      {
+        cases: {
+          '@spread': 'operator.spread',
+          '@access': 'operator.access',
+          '@default': 'operator',
+        },
+      },
+    ],
+    [/\/(?!\/)/, 'operator.math'],
+    [/\&(?=[,\)])/, 'operator.special.blockparam'],
+    [
+      /(\s*)(@symbols)(\s*)/,
+      {
+        cases: {
+          '$2@assignments': 'operator.assign',
+          '$2@math': 'operator.math',
+          '$2@operators': 'operator',
+          '$2@logic': 'operator.logic',
+          '$2@access': 'operator.access',
+          '@default': 'delimiter',
+        },
+      },
+    ],
+    [/\&\b/, 'operator'],
+  ],
+
+  keyword_: [
+    [/new@B/, 'keyword.new'],
+    [/isa@B/, 'keyword.isa'],
+    [/is@B/, 'keyword.is'],
+    [/(switch|when|throw|continue|break|then|await|typeof|by)@B/, 'keyword.$1'],
+    [/delete@B/, 'keyword.delete'],
+    [/and@B|or@B/, 'operator.flow'],
+  ],
+
+  return_: [[/return@B/, 'keyword.new']],
+
+  primitive_: ['string_', 'number_', 'regexp_', 'bool_'],
+
+  value_: [
+    'primitive_',
+    'keyword_',
+    'implicit_call_',
+    'parens_', // call will always capture?
+    'key_',
+    'access_',
+    'identifier_',
+    'array_',
+    'object_',
+  ],
+
+  expr_: ['comment_', 'inline_var_', 'return_', 'value_', 'tag_', 'op_', 'type_', 'spread_'],
+
+  attr_expr_: [
+    'primitive_',
+    'parens_',
+    'access_',
+    'identifier_',
+    'array_',
+    'object_',
+    'tag_',
+    'op_',
+  ],
+
+  access_: [
+    [
+      /(\.\.?)(@propid\!?)/,
+      {
+        cases: {
+          '$2~[A-Z].*': ['operator.access', 'accessor.uppercase'],
+          '$2~#.*': ['operator.access', 'accessor.symbol'],
+          '@default': ['operator.access', 'accessor'],
+        },
+      },
+    ],
+  ],
+
+  call_: [[/\(/, '(', '@call_body']],
+
+  key_: [
+    [/(\#+@id)(\:\s*)/, ['key.symbol', 'operator.assign.key-value']],
+    [
+      /(@propid)(\:\s*)/,
+      {
+        cases: {
+          '@default': ['key', 'operator.assign.key-value'],
+        },
+      },
+    ],
+  ],
+
+  implicit_call_: [
+    [
+      /(\.\.?)(@propid)@implicitCall/,
+      {
+        cases: {
+          '$2~[A-Z].*': ['operator.access', 'accessor.uppercase', '@implicit_call_body'],
+          '@default': ['operator.access', 'accessor', '@implicit_call_body'],
+        },
+      },
+    ],
+    [
+      /(@propid)@implicitCall/,
+      {
+        cases: {
+          '$2~[A-Z].*': ['identifier.uppercase', '@implicit_call_body'],
+          '@default': ['identifier', '@implicit_call_body'],
+        },
+      },
+    ],
+  ],
+
+  implicit_call_body: [eolpop, [/\)|\}|\]|\>/, '@rematch', '@pop'], 'arglist_', 'whitespace'],
+
+  arglist_: ['do_', 'expr_', [/\s*\,\s*/, 'delimiter.comma']],
+
+  params_: [
+    [/\[/, 'array.[', '@array_var_body=decl-param'],
+    [/\{/, 'object.{', '@object_body=decl-param'],
+    [/(@variable)/, 'identifier.decl-param'],
+    // [/(\s*\=\s*)(?=(for|while|until|if|unless)\s)/,'operator','@pop']
+    'spread_',
+    'type_',
+    [/\s*\=\s*/, 'operator', '@var_value='],
+    [/\s*\,\s*/, 'separator'],
+  ],
+
+  object_: [[/\{/, 'object.{', '@object_body']],
+
+  parens_: [[/\(/, 'parens.(', '@parens_body']],
+
+  parens_body: [[/\)/, ')', '@pop'], 'indentable_', 'arglist_'],
+
+  array_: [[/\[/, 'array.[', '@array_body']],
+
+  array_body: [
+    [/\]@implicitCall/, { token: ']', switchTo: '@implicit_call_body=' }],
+    [/\]/, ']', '@pop'],
+    [/\)|\}/, 'invalid'],
+    'indentable_',
+    'expr_',
+    [',', 'delimiter'],
+  ],
+
+  object_body: [
+    [/\}/, '}', '@pop'],
+    [/(@id)(\s*:\s*)/, ['key', 'operator.assign.key-value', '@object_value']],
+    [/(@id)/, 'identifier.$F'],
+    [/\[/, '[', '@object_dynamic_key='], //
+    [/\s*=\s*/, 'operator.assign', '@object_value='],
+    [/:/, 'operator.assign.key-value', '@object_value='],
+    [/\,/, 'delimiter.comma'],
+    'indentable_',
+    'expr_',
+  ],
+
+  object_value: [
+    eolpop,
+    // couldnt this be indented as well?
+    // [/(?=,|\})/, 'delimiter', '@pop']
+    [/,|\}|\]|\)/, '@rematch', '@pop'],
+    'expr_',
+  ],
+
+  object_dynamic_key: [[']', ']', '@pop'], 'expr_'],
+
+  comment_: [[/#(\s.*)?(\n|$)/, 'comment']],
+
+  block_comment_: [[/###/, 'comment.start', '@_block_comment']],
+
+  _block_comment: [
+    [/###/, 'comment.end', '@pop'],
+    [/[^#]+/, 'comment'],
+    [/#(?!##)/, 'comment'],
+  ],
+
+  // add try_start that accepts catch on the same line?
+  try_: [[/try@B/, 'keyword.try', '@>_try&try']],
+
+  catch_: [
+    [/(catch\s+)(?=@id(\s|$))/, 'keyword.catch', '@catch_start&catch'],
+    [/catch@B/, 'keyword.catch', '@catch_start&catch'],
+  ],
+
+  catch_start: [
+    [/@id/, 'identifier.decl-const', { switchTo: '@>_catch' }],
+    [/.?/, '@rematch', { switchTo: '@>_catch' }],
+  ],
+
+  _catch: [denter('@>block', -1, 0), 'block_'],
+
+  _try: [denter('@>block', -1, 0), 'block_'],
+
+  do_: [
+    // [/(do)(\()/,['keyword.do','(','@>_do_params&do']]
+    [/do(?=\()/, 'keyword.do', '@>do_start&do'],
+    [/do(?=\s*\|)/, 'keyword.do', '@>do_piped&do'],
+    [/do@B/, 'keyword.do', '@>_do&do'],
+  ],
+
+  do_start: [
+    denter(null, -1, -1),
+    [/\(/, '(', { switchTo: '@_do_params' }],
+    [/./, '@rematch', { switchTo: '@_do' }],
+  ],
+
+  do_piped: [
+    denter(null, -1, -1),
+    [/\s*\|/, 'args.open', { switchTo: '@_do_piped_params' }],
+    [/./, '@rematch', { switchTo: '@_do' }],
+  ],
+
+  _do_piped_params: [[/\|/, 'args.close', { switchTo: '@_do' }], 'params_'],
+
+  _do_params: [[/\)/, ')', { switchTo: '@_do' }], 'params_'],
+
+  _do: [
+    denter(2, -1, 0),
+    // block in general, no?
+    [/(\}|\)|\])/, '@rematch', '@pop'],
+    'block_',
+  ],
+
+  class_: [
+    [/(extend)(?=\s+class )/, 'keyword.$1'],
+    [/(global)(?=\s+class )/, 'keyword.$1'],
+    [
+      /(class)(\s)(@id)/,
+      ['keyword.$1', 'white.$1name', 'entity.name.class.decl-const', '@class_start='],
+    ],
+    [/(class)(?=\n)/, 'keyword.$1', '@>_class&class='],
+  ],
+
+  class_start: [
+    [/(\s+\<\s+)(@id)/, ['keyword.extends', 'identifier.superclass']],
+    [/@comment/, 'comment'],
+    [/^/, '@rematch', { switchTo: '@>_class&class=' }],
+  ],
+
+  tagclass_: [
+    [/(extend)(?=\s+tag )/, 'keyword.$1'],
+    [/(global)(?=\s+tag )/, 'keyword.$1'],
+    [
+      /(tag)(\s)(@constant)/,
+      ['keyword.tag', 'white.tagname', 'entity.name.component.local', '@tagclass_start='],
+    ], // only when uppercase
+    [
+      /(tag)(\s)(@id)/,
+      ['keyword.tag', 'white.tagname', 'entity.name.component.global', '@tagclass_start='],
+    ], // only when uppercase
+  ],
+
+  tagclass_start: [
+    [/(\s+\<\s+)(@id)/, ['keyword.extends', 'identifier.superclass']],
+    [/@comment/, 'comment'],
+    [/^/, '@rematch', { switchTo: '@>_tagclass&component=' }],
+  ],
+
+  import_: [
+    [/(import)(?=\s+['"])/, 'keyword.import', '@>import_source'],
+    [
+      /(import)(\s+type)(?=\s[\w\$\@\{])/,
+      ['keyword.import', 'keyword.type', '@>import_body&-_imports=decl-import/part'],
+    ],
+    [/(import)@B/, 'keyword.import', '@>import_body&-_imports=decl-import/part'],
+  ],
+
+  import_body: [
+    denter(null, -1, 0),
+    [
+      /(@esmIdentifier)( +from)/,
+      ['identifier.$F.default', 'keyword.from', { switchTo: '@import_source' }],
+    ],
+    [
+      /(\*)(\s+as\s+)(@esmIdentifier)(\s+from)/,
+      [
+        'keyword.star',
+        'keyword.as',
+        'identifier.$F.ns',
+        'keyword.from',
+        { switchTo: '@import_source' },
+      ],
+    ],
+    [
+      /(@esmIdentifier)(\s*,\s*)(\*)(\s+as\s+)(@esmIdentifier)(from)/,
+      [
+        'identifier.$F.default',
+        'delimiter.comma',
+        'keyword.star',
+        'keyword.as',
+        'identifier.$F.ns',
+        'keyword.from',
+        { switchTo: '@import_source' },
+      ],
+    ],
+    // [/(\*)(\s+as\s+)(@esmIdentifier)/, ['keyword.star','keyword.as','identifier.const.import',switchTo: '@/delim']]
+    // [/(@esmIdentifier)(\s+as\s+)(@esmIdentifier)/, ['alias','keyword.as','identifier.const.import']]
+    [/\ *from/, 'keyword.from', { switchTo: '@import_source' }],
+    [/\{/, 'specifiers.{', '@esm_specifiers/part'],
+    [/(@esmIdentifier)/, 'identifier.$F', { switchTo: '@/delim' }],
+    [/\s*\,\s*/, 'delimiter.comma', { switchTo: '@/part' }],
+    'comma_',
+    'common_',
+  ],
+
+  import_source: [denter(null, -1, 0), [/["']/, 'path.open', '@_path=$#'], eolpop],
+
+  export_: [
+    [/(export)( +)(default)@B/, ['keyword.export', 'white', 'keyword.default']], // ,'@>import_body'
+    [/(export)(?= +(let|const|var|class|tag)@B)/, 'keyword.export'], // ,'@>import_body'
+    [/(export)( +)(global)@B/, ['keyword.export', 'white', 'keyword.global']], // ,'@>import_body'
+
+    [
+      /(export)(\s+\*\s+)(from)@B/,
+      ['keyword.export', 'operator.star', 'keyword.from', '@>import_source'],
+    ],
+    [/(export)@B/, 'keyword.export', '@>export_body'],
+  ],
+
+  export_body: [
+    denter(null, -1, 0),
+    [/(\*)(\s+as\s+)(@esmIdentifier)/, ['keyword.star', 'keyword.as', 'identifier.const.export']],
+    [/(@esmIdentifier)(\s+as\s+)(default)/, ['alias', 'keyword.as', 'alias.default']],
+    [
+      /(@esmIdentifier)(\s+as\s+)(@esmIdentifier)/,
+      ['alias', 'keyword.as', 'identifier.const.export'],
+    ],
+    [/from/, 'keyword.from', { switchTo: '@import_source' }],
+    [/\{/, '{', '@esm_specifiers=export/part'],
+    [/(@esmIdentifier)/, 'identifier.const.export'],
+    [/\*/, 'operator.star'],
+    'comma_',
+    'common_',
+  ],
+
+  esm_specifiers: [
+    [/\}/, '}', '@pop'],
+    [
+      /(@esmIdentifier)(\s+as\s+)(@esmIdentifier)/,
+      ['alias', 'keyword.as', 'identifier.const.$F', { switchTo: '@/delim' }],
+    ],
+    [
+      /@esmIdentifier/,
+      {
+        cases: {
+          '$/==part': { token: 'identifier.const.$S4', switchTo: '@/delim' },
+          '@default': { token: 'invalid' },
+        },
+      },
+    ],
+    [/\s*\,\s*/, 'delimiter.comma', { switchTo: '@/part' }],
+    'whitespace',
+  ],
+
+  _path: [
+    [/[^"'\`\{\\]+/, 'path'],
+    [/@escapes/, 'path.escape'],
+    [/\./, 'path.escape.invalid'],
+    [/\{/, 'invalid'],
+    [/["'`]/, { cases: { '$#==$F': { token: 'path.close', next: '@pop' }, '@default': 'path' } }],
+  ],
+
+  member_: [
+    // [/static(?=\s+(get|set|def) )/,'keyword.static'] # only in class and tagclass?
+    [/(constructor)@B/, 'entity.name.constructor', '@>def_params&def/def'],
+    [
+      /(def|get|set)(\s)(@defid)/,
+      ['keyword.$1', 'white.entity', 'entity.name.$1', '@>def_params&$1/$1'],
+    ],
+    [/(def|get|set)(\s)(\[)/, ['keyword.$1', 'white.entity', '$$', '@>def_dynamic_name/$1']],
+  ],
+
+  func_: [
+    [/export(?=\s+(get|set|def|global) )/, 'keyword.export'], // only in class and tagclass?
+    [/global(?=\s+(get|set|def) )/, 'keyword.global'], // only in class and tagclass?
+    [
+      /(def)(\s)(@id)(\.)(@defid)/,
+      [
+        'keyword.$1',
+        'white.entity',
+        'identifier.target',
+        'operator',
+        'entity.name.def',
+        '@>def_params&$1/$1',
+      ],
+    ],
+
+    [
+      /(def)(\s)(@defid)/,
+      ['keyword.$1', 'white.entity', 'entity.name.function.decl-const-func', '@>def_params&$1/$1'],
+    ],
+  ],
+
+  flow_: [
+    // [/(else)(?=\s|$)/, ['keyword.$1','@flow_start.$S2.flow.$S4']]
+    [/(if|else|elif|unless)(?=\s|$)/, ['keyword.$1', '@flow_start=$1']],
+  ],
+
+  flow_start: [
+    denter({ switchTo: '@>_flow&$F' }, -1, -1),
+    // denter({switchTo: '@>_flow&-body'},-1,-1)
+    // denter('@>_flow&block',-1,-1)
+    [/[ \t]+/, 'white'],
+    'expr_',
+  ],
+
+  for_: [
+    [/for(?: own)?@B/, 'keyword.$#', '@for_start&forscope=decl-for'],
+    // [/for@B/,'keyword.$#','@for_start&flow=let']
+  ],
+
+  while_: [[/(while|until)@B/, 'keyword.$#', '@>while_body']],
+  while_body: [denter(2, -1, 0), 'block_'],
+
+  for_start: [
+    denter({ switchTo: '@>for_body' }, -1, -1),
+    [/\[/, 'array.[', '@array_var_body'],
+    [/\{/, 'object.{', '@object_body'], // object_var_body?
+    [/(@variable)/, 'identifier.$F'],
+    [/(\s*\,\s*)/, 'separator', '@=decl-for-index'],
+    [/\s(in|of)@B/, 'keyword.$1', { switchTo: '@>for_source=' }],
+    [/[ \t]+/, 'white'],
+    'type_',
+  ],
+  for_source: [
+    denter({ switchTo: '@>for_body' }, -1, { switchTo: '@for_body' }),
+    'expr_',
+    [/[ \t]+/, 'white'],
+  ],
+
+  for_body: [denter(2, -1, 0), 'block_'],
+
+  decorator_: [
+    [/(@decid)(\()/, ['decorator', '$2', '@_decorator_params']],
+    [/(@decid)/, 'decorator'],
+  ],
+
+  _decorator_params: [[/\)/, ')', '@pop'], 'params_'],
+
+  field_: [
+    [
+      /((?:lazy )?)((?:static )?)(const|let|attr)(?=\s|$)/,
+      ['keyword.lazy', 'keyword.static', 'keyword.$1', '@_vardecl=field-$3'],
+    ], // $2_body.$S2.$2.$S4
+    [/(static\s+)(?=@fieldid)/, 'keyword.static'],
+    [/(@fieldid)(?=$)/, 'entity.name.field'],
+    [/(@fieldid)/, ['entity.name.field', '@_field_1']],
+  ],
+
+  _field_1: [
+    denter(null, -1, -1),
+    'type_',
+    [/(\s*=)(?!\=)/, ['operator.assign', '@>_field_value&field']],
+    [/(\s*(?:\@)set\s*)/, ['keyword.spy', '@>_def&spy']],
+  ],
+
+  _field_value: [
+    denter(2, -1, 0),
+    'block_', // sure?
+    [/(\s*(?:\@)set\s*)/, ['@rematch', '@pop']],
+  ],
+
+  var_: [
+    [
+      /((?:export )?)(const|let)(?=\s[\[\{\$a-zA-Z]|\s*$)/,
+      ['keyword.export', 'keyword.$1', '@_vardecl=decl-$2'],
+    ], // $2_body.$S2.$2.$S4
+    [/((?:export )?)(const|let)(?=\s|$)/, ['keyword.export', 'keyword.$1']],
+  ],
+
+  inline_var_: [
+    [/(const|let)(?=\s[\[\{\$a-zA-Z]|\s*$)/, ['keyword.$1', '@inline_var_body=decl-$1']],
+  ],
+
+  string_: [
+    [/"""/, 'string', '@_herestring="""'],
+    [/'''/, 'string', "@_herestring='''"],
+    [/["'`]/, 'string.open', '@_string=$#'],
+  ],
+
+  number_: [
+    [/0[xX][0-9a-fA-F_]+/, 'number.hex'],
+    [/0[b][01_]+/, 'number.binary'],
+    [/0[o][0-9_]+/, 'number.octal'],
+    [/(\d+)([a-z]+|\%)/, ['number', 'unit']],
+    [/(\d*\.\d+(?:[eE][\-+]?\d+)?)([a-z]+|\%)/, ['number.float', 'unit']],
+    [/\d+[eE]([\-+]?\d+)?/, 'number.float'],
+    [/\d[\d_]*\.\d[\d_]*([eE][\-+]?\d+)?/, 'number.float'],
+    [/\d[\d_]*/, 'number.integer'],
+    [/0[0-7]+(?!\d)/, 'number.octal'],
+    [/\d+/, 'number'],
+  ],
+
+  _string: [
+    [/[^"'\`\{\\]+/, 'string'],
+    [/@escapes/, 'string.escape'],
+    [/\./, 'string.escape.invalid'],
+    [
+      /\{/,
+      {
+        cases: {
+          "$F=='": 'string',
+          '@default': { token: 'string.bracket.open', next: '@interpolation_body' },
+        },
+      },
+    ],
+    [
+      /["'`]/,
+      { cases: { '$#==$F': { token: 'string.close', next: '@pop' }, '@default': 'string' } },
+    ],
+    [/#/, 'string'],
+  ],
+
+  _herestring: [
+    [/("""|''')/, { cases: { '$1==$F': { token: 'string', next: '@pop' }, '@default': 'string' } }],
+    [/[^#\\'"\{]+/, 'string'],
+    [/['"]+/, 'string'],
+    [/@escapes/, 'string.escape'],
+    [/\./, 'string.escape.invalid'],
+    [
+      /\{/,
+      {
+        cases: {
+          '$F=="""': { token: 'string', next: '@interpolation_body' },
+          '@default': 'string',
+        },
+      },
+    ],
+    [/#/, 'string'],
+  ],
+
+  interpolation_body: [[/\}/, 'string.bracket.close', '@pop'], 'expr_'],
+
+  _class: [
+    denter(toodeep, -1, 0),
+    // 'var_'
+    'css_',
+    'member_',
+    'comment_',
+    'decorator_',
+    [/(get|set|def|static|prop|attr)@B/, 'keyword.$0'],
+    'field_',
+    'common_',
+  ],
+
+  _tagclass: [
+    '_class',
+    [/(?=\<self)/, 'entity.name.def.render', '@_render&def'],
+    // self def
+  ],
+
+  def_params: [
+    // denter({switchTo: '@>_def'},-1,{switchTo: '@>_def'})
+    [/\(/, '(', '@def_parens'],
+    [/^/, '@rematch', { switchTo: '@_def' }],
+    [/do@B/, 'keyword.do', { switchTo: '@_def' }],
+    'params_',
+    [/@comment/, 'comment'],
+  ],
+
+  def_parens: [[/\)/, ')', '@pop'], 'params_'],
+
+  def_dynamic_name: [[']', { token: 'square.close', switchTo: '@def_params&$/' }], 'expr_'],
+
+  _render: [denter(2, -1, -1), 'block_'],
+
+  _def: [denter(2, -1, 0), 'block_'],
+
+  _flow: [denter(2, -1, 0), 'block_'],
+
+  _varblock: [
+    denter(1, -1, -1),
+    [/\[/, 'array.[', '@array_var_body'],
+    [/\{/, 'object.{', '@object_body'],
+    [/(@variable)/, 'identifier.$F'],
+    [/\s*\,\s*/, 'separator'],
+    [/(\s*\=\s*)(?=(for|while|until|if|unless|try)\s)/, 'operator', '@pop'],
+    [/(\s*\=\s*)/, 'operator', '@var_value='],
+    'type_',
+    [/#(\s.*)?\n?$/, 'comment'],
+  ],
+
+  _vardecl: [
+    denter(null, -1, -1),
+    [/\[/, 'array.[', '@array_var_body'],
+    [/\{/, 'object.{', '@object_body'],
+    [/(@variable)(?=\n|,|$)/, 'identifier.$F', '@pop'],
+    [/(@variable)/, 'identifier.$F'],
+    [/(\s*\=\s*)/, 'operator.declval', { switchTo: '@var_value&value=' }], // ,switchTo: '@var_value='
+    'type_',
+  ],
+
+  array_var_body: [
+    [/\]/, ']', '@pop'],
+    [/\{/, 'object.{', '@object_body'],
+    [/\[/, 'array.[', '@array_var_body'],
+    'spread_',
+    [/(@variable)/, 'identifier.$F'],
+    [/(\s*\=\s*)/, 'operator.assign', '@array_var_body_value='],
+    // 'expr_'
+    [',', 'delimiter'],
+  ],
+
+  array_var_body_value: [[/(?=,|\)|]|})/, 'delimiter', '@pop'], 'expr_'],
+
+  inline_var_body: [
+    [/\[/, 'array.[', '@array_var_body'],
+    [/\{/, 'object.{', '@object_body'],
+    [/(@variable)/, 'identifier.$F'],
+    [/(\s*\=\s*)/, 'operator', '@pop'], // ,switchTo: '@var_value='
+    'type_',
+  ],
+
+  var_value: [
+    [/(?=,|\)|]|})/, 'delimiter', '@pop'],
+    denter({ switchTo: '@>block' }, -1, -1),
+    'block_',
+    // 'do_'
+    // 'expr_'
+    // 'common_'
+  ],
+
+  common_: [[/^(\t+)(?=\n|$)/, 'white.tabs'], 'whitespace'],
+  comma_: [[/\s*,\s*/, 'delimiter.comma']],
+
+  spread_: [[/\.\.\./, 'operator.spread']],
+
+  type_: [[/\\/, '@rematch', '@_type&-_type/0']],
+
+  _type: [
+    denter(-1, -1, -1),
+    [/\\/, 'delimiter.type.prefix'],
+    // these should probably stack and pair
+    [/\[/, 'delimiter.type', '@/]'],
+    [/\(/, 'delimiter.type', '@/)'],
+    [/\{/, 'delimiter.type', '@/}'],
+    [/\</, 'delimiter.type', '@/>'],
+    [/\|/, 'delimiter.type.union'],
+    [
+      /\,|\s|\=|\./,
+      {
+        cases: {
+          '$/==0': { token: '@rematch', next: '@pop' },
+          '@default': 'type',
+        },
+      },
+    ],
+    [
+      /[\]\}\)\>]/,
+      {
+        cases: {
+          '$#==$/': { token: 'delimiter.type', next: '@pop' },
+          '@default': { token: '@rematch', next: '@pop' },
+        },
+      },
+    ],
+    [/[\w\-\$]+/, 'type'],
+  ],
+
+  css_: [
+    [/global(?=\s+css@B)/, 'keyword.$#'],
+    [/css(?:\s+)?/, 'keyword.css', '@>css_selector&rule-_sel'],
+  ],
+
+  sel_: [
+    [/(\%)((?:@id)?)/, ['style.selector.mixin.prefix', 'style.selector.mixin']],
+    [/(\@)(\.{0,2}[\w\-\<\>\!]*\+?)/, 'style.selector.modifier'],
+    [/(\@)(\.{0,2}[\w\-\<\>\!]*)/, 'style.selector.modifier'],
+    [/\.([\w\-]+)/, 'style.selector.class-name'],
+    [/\#([\w\-]+)/, 'style.selector.id'],
+    [/([\w\-]+)/, 'style.selector.element'],
+    [/(>+|~|\+)/, 'style.selector.operator'],
+    [/(\*+)/, 'style.selector.element.any'],
+    [/(\$)((?:@id)?)/, ['style.selector.reference.prefix', 'style.selector.reference']],
+    [/\&/, 'style.selector.context'],
+    [/\(/, 'delimiter.selector.parens.open', '@css_selector_parens'],
+    [/\[/, 'delimiter.selector.attr.open', '@css_selector_attr'],
+    [/\s+/, 'white'],
+    [/,/, 'style.selector.delimiter'],
+    [/#(\s.*)?\n?$/, 'comment'],
+  ],
+
+  css_props: [
+    denter(null, -1, 0),
+    [/(?=@cssPropertyKey2)/, '', '@css_property&-_styleprop-_stylepropkey'],
+    [/#(\s.*)?\n?$/, 'comment'],
+    [/(?=[\%\*\w\&\$\>\.\[\@\!]|\#[\w\-])/, '', '@>css_selector&rule-_sel'],
+    [/\s+/, 'white'],
+  ],
+
+  css_selector: [
+    denter({ switchTo: '@css_props' }, -1, { token: '@rematch', switchTo: '@css_props&_props' }),
+    [/(\}|\)|\])/, '@rematch', '@pop'],
+    [/(?=\s*@cssPropertyKey2)/, '', { switchTo: '@css_props&_props' }],
+    [/\s*#\s/, '@rematch', { switchTo: '@css_props&_props' }],
+    'sel_',
+  ],
+
+  css_inline: [
+    [/\]/, 'style.close', '@pop'],
+    [/(?=@cssPropertyKey2)/, '', '@css_property&-_styleprop-_stylepropkey'],
+    [/(?=@cssPropertyPath\])/, '', '@css_property&-_styleprop-_stylepropkey'],
+  ],
+
+  css_selector_parens: [[/\)/, 'delimiter.selector.parens.close', '@pop'], 'sel_'],
+
+  css_selector_attr: [[/\]/, 'delimiter.selector.parens.close', '@pop'], 'sel_'],
+
+  css_property: [
+    denter(null, -1, -1),
+    [/\]/, '@rematch', '@pop'],
+    [/(\d+)(@id)/, ['style.property.unit.number', 'style.property.unit.name']],
+    [/((--|\$)@id)/, 'style.property.var'],
+    [/(-*@id)/, 'style.property.name'],
+    // [/(\@+)([\>\<\!]?[\w\-]+)/, ['style.property.modifier.start','style.property.modifier']]
+    [/@cssModifier/, 'style.property.modifier'],
+    [/(\@+|\.+)(@id\-?)/, ['style.property.modifier.start', 'style.property.modifier']],
+    [/\+(@id)/, 'style.property.scope'],
+    [
+      /\s*([\:]\s*)(?=@br|$)/,
+      'style.property.operator',
+      { switchTo: '@>css_multiline_value&_stylevalue' },
+    ],
+    [/\s*([\:]\s*)/, 'style.property.operator', { switchTo: '@>css_value&_stylevalue' }],
+  ],
+
+  css_value_: [
+    [/(x?xs|sm\-?|md\-?|lg\-?|xx*l|\dxl|hg|x+h)\b/, 'style.value.size'],
+    [/\#[0-9a-fA-F]+/, 'style.value.color.hex'],
+    [/((--|\$)@id)/, 'style.value.var'],
+    [
+      /(@optid)(\@+|\.+)(@optid)/,
+      ['style.property.name', 'style.property.modifier.prefix', 'style.property.modifier'],
+    ],
+    'op_',
+    'string_',
+    'number_',
+    'comment_',
+    [/\s+/, 'style.value.white'],
+    [/\(/, 'delimiter.style.parens.open', '@css_expressions'],
+    [/\{/, 'delimiter.style.curly.open', '@css_interpolation&-_styleinterpolation'],
+    [/(@id)/, 'style.value'],
+  ],
+
+  css_value: [
+    denter({ switchTo: '@>css_multiline_value' }, -1, -1),
+    // [/@cssModifier/, '@rematch', '@pop']
+    [/@cssPropertyKey2/, '@rematch', '@pop'],
+    [/;/, 'style.delimiter', '@pop'],
+    [/(\}|\)|\])/, '@rematch', '@pop'],
+    'css_value_',
+  ],
+
+  css_multiline_value: [denter(null, -1, 0), [/@cssPropertyKey2/, 'invalid'], 'css_value_'],
+
+  css_expressions: [
+    [/\)/, 'delimiter.style.parens.close', '@pop'],
+    [/\(/, 'delimiter.style.parens.open', '@css_expressions'],
+    'css_value',
+  ],
+
+  css_interpolation: [[/\}/, 'delimiter.style.curly.close', '@pop'], 'expr_'],
+
+  expressions: [[/\,/, 'delimiter.comma']],
+
+  whitespace: [
+    [/[\r\n]+/, 'br'],
+    [/[ \t\r\n]+/, 'white'],
+  ],
+
+  space: [[/[ \t]+/, 'white']],
+
+  tag_: [
+    [/(\s*)(<)(?=\.)/, ['white', 'tag.open', '@_tag/flag']],
+    [/(\s*)(<)(?=\w|\{|\[|\%|\#|>)/, ['white', 'tag.open', '@_tag/name']],
+  ],
+  tag_content: [
+    denter(2, -1, 0),
+    [/\)|\}|\]/, '@rematch', '@pop'],
+    'common_',
+    'flow_',
+    'var_',
+    'for_',
+    'css_',
+    'expr_',
+    'do_',
+    // dont support object keys directly here
+  ],
+
+  tag_children: [],
+
+  _tag: [
+    [/\/>/, 'tag.close', '@pop'],
+    [/>/, 'tag.close', { switchTo: '@>tag_content=&-_tagcontent' }],
+    // '@>css_selector&rule-_sel'
+    [/>/, 'tag.close', '@pop'],
+    [/(\-?\d+)/, 'tag.$S3'],
+    [/(\%)(@id)/, ['tag.mixin.prefix', 'tag.mixin']],
+    [/\#@id/, 'tag.id'],
+
+    [
+      /\./,
+      {
+        cases: {
+          '$/==event': { token: 'tag.event-modifier.start', switchTo: '@/event-modifier' },
+          '$/==event-modifier': { token: 'tag.event-modifier.start', switchTo: '@/event-modifier' },
+          '$/==modifier': { token: 'tag.modifier.start', switchTo: '@/modifier' },
+          '$/==rule': { token: 'tag.rule-modifier.start', switchTo: '@/rule-modifier' },
+          '$/==rule-modifier': { token: 'tag.rule-modifier.start', switchTo: '@/rule-modifier' },
+          '@default': { token: 'tag.flag.start', switchTo: '@/flag' },
+        },
+      },
+    ],
+
+    [
+      /(\$@id)/,
+      {
+        cases: {
+          '$/==name': 'tag.reference',
+          '@default': 'tag.$/',
+        },
+      },
+    ],
+
+    [/\{/, 'tag.$/.interpolation.open', '@_tag_interpolation'],
+    [/\[/, 'style.open', '@css_inline'],
+    [/(\s*\=\s*)/, 'operator.equals.tagop.tag-$/', '@_tag_value&-value'],
+    [/\:/, { token: 'tag.event.start', switchTo: '@/event' }],
+    'tag_event_',
+    // 'tag_attr_'
+    [
+      /(\-?@tagIdentifier)(\:@id)?/,
+      {
+        cases: {
+          '$/==attr': { token: '@rematch', next: '@_tag_attr&-_tagattr' },
+          '@default': { token: 'tag.$/' },
+        },
+      },
+    ],
+    // [/\@/,token: 'tag.event.start', switchTo: '@/event']
+    // [/\{/,token: 'tag.$/.braces.open', next: '@_tag_interpolation/0']
+    [/\(/, { token: 'tag.$/.parens.open', next: '@_tag_parens/0' }],
+    [/\s+/, { token: 'tag.white', switchTo: '@/attr' }],
+    'comment_',
+  ],
+  tag_event_: [
+    // add an additional slot for name etc?
+    // [/(\@)(@optid)/,['tag.event.start','tag.event.name','@_tag_event&_tagevent/$2']]
+    [/(?=\@@optid)/, '', '@_tag_event&-_listener'],
+  ],
+
+  _tag_part: [[/\)|\}|\]|\>/, '@rematch', '@pop']],
+  _tag_event: [
+    '_tag_part',
+    [/(\@)(@optid)/, ['tag.event.start', 'tag.event.name']],
+    [/(\.)(@optid)/, ['tag.event-modifier.start', 'tag.event-modifier.name']],
+    [/\(/, { token: 'tag.$/.parens.open', next: '@_tag_parens/0' }],
+    [/(\s*\=\s*)/, 'operator.equals.tagop.tag-$/', '@_tag_value&handler'],
+    [/\s+/, '@rematch', '@pop'],
+  ],
+
+  tag_attr_: [
+    // add an additional slot for name etc?
+    // [/(\@)(@optid)/,['tag.event.start','tag.event.name','@_tag_event&_tagevent/$2']]
+    [/(?=@tagIdentifier(\:@id)?)/, '', '@_tag_attr&-_attribute'],
+  ],
+
+  _tag_attr: [
+    '_tag_part',
+    [/(\-?@tagIdentifier)(\:@id)?/, 'tag.attr'],
+    [/\.(@optid)/, 'tag.event-modifierzz'],
+    [/\(/, { token: 'tag.parens.open.$/', next: '@_tag_parens/0' }],
+    [/(\s*\=\s*)/, 'operator.equals.tagop.tag-$/', '@_tag_value&-tagattrvalue'],
+    [/\s+/, '@rematch', '@pop'],
+  ],
+
+  _tag_interpolation: [[/\}/, 'tag.$/.interpolation.close', '@pop'], 'expr_', [/\)|\]/, 'invalid']],
+
+  _tag_parens: [[/\)/, 'tag.$/.parens.close', '@pop'], 'arglist_', [/\]|\}/, 'invalid']],
+
+  _tag_value: [[/(?=(\/?\>|\s))/, '', '@pop'], 'attr_expr_'],
+
+  regexp_: [
+    [
+      /\/(?!\ )(?=([^\\\/]|\\.)+\/)/,
+      { token: 'regexp.slash.open', bracket: '@open', next: '@_regexp' },
+    ],
+    [/\/\/\//, { token: 'regexp.slash.open', bracket: '@open', next: '@_hereregexp' }],
+    [/(\/)(\/)/, ['regexp.slash.open', 'regexp.slash.close']],
+  ],
+
+  _regexp: [
+    [
+      /(\{)(\d+(?:,\d*)?)(\})/,
+      ['regexp.escape.control', 'regexp.escape.control', 'regexp.escape.control'],
+    ],
+    [
+      /(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/,
+      ['regexp.escape.control', { token: 'regexp.escape.control', next: '@_regexrange' }],
+    ],
+    [/(\()(\?:|\?=|\?!)/, ['regexp.escape.control', 'regexp.escape.control']],
+    [/[()]/, 'regexp.escape.control'],
+    [/@regexpctl/, 'regexp.escape.control'],
+    [/[^\\\/]/, 'regexp'],
+    [/@regexpesc/, 'regexp.escape'],
+    [/\\:/, 'regexp.escape'],
+    [/\\\./, 'regexp.invalid'],
+    [/(\/)(\w+)/, [{ token: 'regexp.slash.close' }, { token: 'regexp.flags', next: '@pop' }]],
+    ['/', { token: 'regexp.slash.close', next: '@pop' }],
+    [/./, 'regexp.invalid'],
+  ],
+
+  _regexrange: [
+    [/-/, 'regexp.escape.control'],
+    [/\^/, 'regexp.invalid'],
+    [/@regexpesc/, 'regexp.escape'],
+    [/[^\]]/, 'regexp'],
+    [/\]/, 'regexp.escape.control', '@pop'],
+  ],
+
+  _hereregexp: [
+    [/[^\\\/#]/, 'regexp'],
+    [/\\./, 'regexp'],
+    [/#.*$/, 'comment'],
+    ['///[igm]*', 'regexp', '@pop'],
+    [/\//, 'regexp'],
+    'comment_',
+  ],
+};
+
+// states are structured:
+// 1 = the monarch state
+// 2 = the current indentation (I)
+// 3 = the current scope name/type (&)
+// 4 = various flags (F)
+// 5 = the monarch substate -- for identifiers++
+function rewriteΞstate(raw) {
+  let state = ['$S1', '$S2', '$S3', '$S4', '$S5', '$S6'];
+
+  if (raw.match(/\@(pop|push|popall)/)) {
+    return raw;
+  }
+
+  if (raw[0] == '@') {
+    raw = raw.slice(1);
+  }
+
+  if (raw.indexOf('.') >= 0) {
+    return raw;
+  }
+
+  raw = rewriteΞtoken(raw);
+  // if raw.match(/^[\w\$\.\-]+$/)
+  // return raw
+
+  if (raw[0] == '>') {
+    state[1] = '$S6\t';
+    raw = raw.slice(1);
+  }
+
+  for (
+    let iφ2 = 0, itemsφ = iter$__(raw.split(/(?=[\/\&\=\*])/)), lenφ = itemsφ.length;
+    iφ2 < lenφ;
+    iφ2++
+  ) {
+    let part = itemsφ[iφ2];
+    if (part[0] == '&') {
+      if (part[1] == '-' || part[1] == '_') {
+        state[2] = '$S3' + part.slice(1);
+      } else {
+        state[2] = '$S3-' + part.slice(1);
+      }
+    } else if (part[0] == '+') {
+      state[3] = '$S4-' + part.slice(1);
+    } else if (part[0] == '=') {
+      state[3] = part.slice(1);
+    } else if (part[0] == '/') {
+      state[4] = part.slice(1);
+    } else if (part[0] == '*') {
+      state[5] = part.slice(1);
+    } else {
+      state[0] = part;
+    }
+  }
+  return state.join('.');
+}
+
+function rewriteΞtoken(raw) {
+  let orig = raw;
+  raw = raw.replace('$/', '$S5');
+  raw = raw.replace('$F', '$S4');
+  raw = raw.replace('$&', '$S3');
+  raw = raw.replace('$I', '$S2');
+  raw = raw.replace('$T', '$S2');
+
+  // if orig != raw
+  // console.log 'rewriting token',orig,raw
+  return raw;
+}
+
+function rewriteΞactions(actions, add) {
+  if (typeof actions == 'string') {
+    // and parts.indexOf('$') >= 0
+
+    actions = { token: actions };
+  }
+
+  if (actions && actions.token != undefined) {
+    actions.token = rewriteΞtoken(actions.token);
+
+    if (typeof add == 'string') {
+      actions.next = add;
+    } else if (add) {
+      Object.assign(actions, add);
+    }
+
+    if (actions.next) {
+      actions.next = rewriteΞstate(actions.next);
+    }
+    if (actions.switchTo) {
+      actions.switchTo = rewriteΞstate(actions.switchTo);
+    }
+  } else if (actions && actions.cases) {
+    // console.log 'found cases to transform!!'
+    let cases = {};
+    for (
+      let oφ = actions.cases, iφ3 = 0, keysφ2 = Object.keys(oφ), lφ2 = keysφ2.length, k, v;
+      iφ3 < lφ2;
+      iφ3++
+    ) {
+      k = keysφ2[iφ3];
+      v = oφ[k];
+      let newkey = rewriteΞtoken(k);
+      cases[newkey] = rewriteΞactions(v);
+    }
+    actions.cases = cases;
+  } else if (actions instanceof Array) {
+    let result = [];
+    let curr = null;
+    for (let i = 0, itemsφ2 = iter$__(actions), lenφ2 = itemsφ2.length; i < lenφ2; i++) {
+      let action = itemsφ2[i];
+      if (action[0] == '@' && i == actions.length - 1 && curr) {
+        action = { next: action };
+      }
+
+      if (typeof action == 'object') {
+        if (action.token != undefined || action.cases) {
+          result.push((curr = Object.assign({}, action)));
+        } else {
+          Object.assign(curr, action);
+        }
+      } else if (typeof action == 'string') {
+        result.push((curr = { token: rewriteΞtoken(action) }));
+      }
+    }
+    actions = result;
+  }
+
+  if (actions instanceof Array) {
+    for (let i = 0, itemsφ3 = iter$__(actions), lenφ3 = itemsφ3.length; i < lenφ3; i++) {
+      let action = itemsφ3[i];
+      if (action.token && action.token.indexOf('$$') >= 0) {
+        action.token = action.token.replace('$$', '$' + (i + 1));
+      }
+      if (action.next) {
+        action.next = rewriteΞstate(action.next);
+      }
+      if (action.switchTo) {
+        action.switchTo = rewriteΞstate(action.switchTo);
+      }
+    }
+  }
+
+  return actions;
+}
+
+function rewriteΞrule(owner, key) {
+  let rule;
+
+  return (rule = owner[key]);
+}
+
+for (let iφ4 = 0, keysφ3 = Object.keys(states), lφ3 = keysφ3.length, key, rules; iφ4 < lφ3; iφ4++) {
+  key = keysφ3[iφ4];
+  rules = states[key];
+  let i = 0;
+  while (i < rules.length) {
+    let rule = rules[i];
+    if (rule[0] instanceof Array) {
+      rules.splice(i, 1, ...rule);
+      continue;
+    } else if (typeof rule == 'string') {
+      rules[i] = { include: rule };
+    } else if (rule[1] instanceof Array) {
+      rule[1] = rewriteΞactions(rule[1]);
+    } else if (rule instanceof Array) {
+      rule.splice(1, 2, rewriteΞactions(rule[1], rule[2]));
+    }
+    i++;
+  }
+}
+
+const grammar = {
+  defaultToken: 'invalid',
+  ignoreCase: false,
+  tokenPostfix: '',
+  brackets: [
+    { open: '{', close: '}', token: 'bracket.curly' },
+    { open: '[', close: ']', token: 'bracket.square' },
+    { open: '(', close: ')', token: 'bracket.parenthesis' },
+  ],
+  keywords: [
+    'def',
+    'and',
+    'or',
+    'is',
+    'isnt',
+    'not',
+    'on',
+    'yes',
+    '@',
+    'no',
+    'off',
+    'true',
+    'false',
+    'null',
+    'this',
+    'self',
+    'as',
+    'new',
+    'delete',
+    'typeof',
+    'in',
+    'instanceof',
+    'return',
+    'throw',
+    'break',
+    'continue',
+    'debugger',
+    'if',
+    'elif',
+    'else',
+    'switch',
+    'for',
+    'while',
+    'do',
+    'try',
+    'catch',
+    'finally',
+    'class',
+    'extends',
+    'super',
+    'undefined',
+    'then',
+    'unless',
+    'until',
+    'loop',
+    'of',
+    'by',
+    'when',
+    'tag',
+    'prop',
+    'attr',
+    'export',
+    'import',
+    'extend',
+    'var',
+    'let',
+    'const',
+    'require',
+    'isa',
+    'await',
+  ],
+  boolean: ['true', 'false', 'yes', 'no', 'undefined', 'null'],
+  operators: [
+    '=',
+    '!',
+    '~',
+    '?',
+    ':',
+    '!!',
+    '??',
+    '&',
+    '|',
+    '^',
+    '%',
+    '<<',
+    '!&',
+    '>>',
+    '>>>',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '&=',
+    '|=',
+    '?=',
+    '??=',
+    '^=',
+    '%=',
+    '~=',
+    '<<=',
+    '>>=',
+    '>>>=',
+    '..',
+    '...',
+    '||=',
+    `&&=`,
+    '**=',
+    '**',
+    '|=?',
+    '~=?',
+    '^=?',
+    '=?',
+    'and',
+    'or',
+  ],
+  assignments: [
+    '=',
+    '|=?',
+    '~=?',
+    '^=?',
+    '=?',
+    '^=',
+    '%=',
+    '~=',
+    '<<=',
+    '>>=',
+    '>>>=',
+    '||=',
+    `&&=`,
+    '?=',
+    '??=',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '&=',
+    '|=',
+    '**=',
+  ],
+  logic: ['>', '<', '==', '<=', '>=', '!=', '&&', '||', '===', '!=='],
+  ranges: ['..', '...'],
+  spread: ['...'],
+  dot: ['.'],
+  access: ['.', '..'],
+  math: ['+', '-', '*', '/', '++', '--'],
+
+  unspaced_ops: regexify('... . .. + * ++ --'),
+  comment: /#(\s.*)?(\n|$)/,
+  // we include these common regular expressions
+  symbols: /[=><!~?&%|+\-*\^,]+/,
+  escapes: /\\(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  postaccess: /(:(?=\w))?/,
+  ivar: /\@[a-zA-Z_]\w*/,
+  B: /(?=\s|$)/,
+  br: /[\r\n]+/,
+  constant: /[A-Z][\w\$]*(?:\-+[\w\$]+)*/,
+  // subIdentifer: /(?:\-*[\w\$]+)*/
+  // identifier: /[a-z_]@subIdentifer/
+  // anyIdentifier: /[A-Za-z_\$][\w\$]*(?:\-+[\w\$]+)*/
+  // anyIdentifierOpt: /(?:@anyIdentifier)?/
+  id: /[A-Za-z_\$][\w\$]*(?:\-+[\w\$]+)*\??/,
+  plainid: /[A-Za-z_\$][\w\$]*(?:\-+[\w\$]+)*\??/,
+  fieldid: /[\@\#]*@plainid/,
+  propid: /[\@\#]*@plainid/,
+  defid: /[\@\#]*@plainid/,
+  decid: /\@@plainid/,
+  symid: /\#+@plainid/,
+  symref: /\#\#@plainid/,
+  optid: /(?:@id)?/,
+  // (?:\-+[\w\$]+)*\??
+  esmIdentifier: /[A-Za-z_\$\@][\w\$]*(?:\-+[\w\$]+)*\??/,
+  propertyPath: /(?:[A-Za-z_\$][A-Za-z\d\-\_\$]*\.)?(?:[A-Za-z_\$][A-Za-z\d\-\_\$]*)/,
+  tagNameIdentifier: /(?:[\w\-]+\:)?\w+(?:\-\w+)*/,
+  variable: /[\w\$]+(?:-[\w\$]*)*\??/,
+  varKeyword: /var|let|const/,
+  tagIdentifier: /-*[a-zA-Z][\w\-]*/,
+  implicitCall: /(?!\s(?:and|or|is|isa)\s)(?=\s[\w\'\"\/\[\{])/, // not true for or etc
+  cssModifier: /(?:\@+[\<\>\!]?[\w\-]+\+?|\.+@id\-?)/,
+  cssPropertyPath: /[\@\.]*[\w\-\$]+(?:[\@\.]+[\w\-\$]+)*/,
+  cssPropertyKey: /[\@\.]*[\w\-\$]+(?:[\@\.]+[\w\-\$]+)*(?:\s*\:)/,
+
+  cssVariable: /(?:--|\$)[\w\-\$]+/,
+  cssPropertyName: /[\w\-\$]+/,
+  // cssModifier: /\@[\w\-\$]+/
+  cssPropertyKey2: /(?:@cssPropertyName(?:@cssModifier)*|@cssModifier+)(?:\s*\:)/,
+  cssUpModifier: /\.\.[\w\-\$]+/,
+  cssIsModifier: /\.[\w\-\$]+/,
+
+  regEx: /\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,
+  regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
+  regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
+  // The main tokenizer for our languages
+  tokenizer: states,
+};
+
+export default {
+  tokens: grammar,
+
+  config: {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      blockComment: ['###', '###'],
+      lineComment: '#',
+    },
+    brackets: [
+      ['{', '}', 'delimiter.curly'],
+      ['[', ']', 'delimiter.square'],
+      ['(', ')', 'delimiter.parenthesis'],
+      ['<', '>', 'delimiter.angle'],
+    ],
+    autoClosingPairs: [
+      { open: '"', close: '"', notIn: ['string', 'comment'] },
+      { open: "'", close: "'", notIn: ['string', 'comment'] },
+      { open: '{', close: '}', notIn: ['comment'] },
+      { open: '[', close: ']', notIn: ['string', 'comment'] },
+      { open: '(', close: ')', notIn: ['string', 'comment'] },
+      { open: '<', close: '>', notIn: ['string', 'comment', 'operators'] },
+    ],
+    onEnterRules: [
+      {
+        beforeText: /^\s*(?:def|get \w|set \w|class|for|if|elif|else|while|try|with|finally|except|async).*?$/,
+        action: { indentAction: 1 },
+      },
+      {
+        beforeText: /\s*(?:do)\s*(\|.*\|\s*)?$/,
+        action: { indentAction: 1 },
+      },
+    ],
+  },
+};