gitlab-rouge 1.9.2

data/lib/rouge/lexers/dart.rb

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Dart < RegexLexer
+      title "Dart"
+      desc "The Dart programming language (dartlang.com)"
+
+      tag 'dart'
+      filenames '*.dart'
+      mimetypes 'text/x-dart'
+
+      keywords = %w(
+        as assert break case catch continue default do else finally for
+        if in is new rethrow return super switch this throw try while with
+      )
+
+      declarations = %w(
+        abstract dynamic const external extends factory final get implements
+        native operator set static typedef var
+      )
+
+      types = %w(bool double Dynamic enum int num Object Set String void)
+
+      imports = %w(import export library part\s*of part source)
+
+      id = /[a-zA-Z_]\w*/
+
+      state :root do
+        rule %r(^
+          (\s*(?:[a-zA-Z_][a-zA-Z\d_.\[\]]*\s+)+?) # return arguments
+          ([a-zA-Z_][\w]*)                          # method name
+          (\s*)(\()                                 # signature start
+        )mx do |m|
+          # TODO: do this better, this shouldn't need a delegation
+          delegate Dart, m[1]
+          token Name::Function, m[2]
+          token Text, m[3]
+          token Punctuation, m[4]
+        end
+
+        rule /\s+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        rule /"/, Str, :dqs
+        rule /'/, Str, :sqs
+        rule /r"[^"]*"/, Str::Other
+        rule /r'[^']*'/, Str::Other
+        rule /##{id}*/i, Str::Symbol
+        rule /@#{id}/, Name::Decorator
+        rule /(?:#{keywords.join('|')})\b/, Keyword
+        rule /(?:#{declarations.join('|')})\b/, Keyword::Declaration
+        rule /(?:#{types.join('|')})\b/, Keyword::Type
+        rule /(?:true|false|null)\b/, Keyword::Constant
+        rule /(?:class|interface)\b/, Keyword::Declaration, :class
+        rule /(?:#{imports.join('|')})\b/, Keyword::Namespace, :import
+        rule /(\.)(#{id})/ do
+          groups Operator, Name::Attribute
+        end
+
+        rule /#{id}:/, Name::Label
+        rule /\$?#{id}/, Name
+        rule /[~^*!%&\[\](){}<>\|+=:;,.\/?-]/, Operator
+        rule /\d*\.\d+([eE]\-?\d+)?/, Num::Float
+        rule /0x[\da-fA-F]+/, Num::Hex
+        rule /\d+L?/, Num::Integer
+        rule /\n/, Text
+      end
+
+      state :class do
+        rule /\s+/m, Text
+        rule id, Name::Class, :pop!
+      end
+
+      state :dqs do
+        rule /"/, Str, :pop!
+        rule /[^\\\$"]+/, Str
+        mixin :string
+      end
+
+      state :sqs do
+        rule /'/, Str, :pop!
+        rule /[^\\\$']+/, Str
+        mixin :string
+      end
+
+      state :import do
+        rule /;/, Operator, :pop!
+        rule /(?:show|hide)\b/, Keyword::Declaration
+        mixin :root
+      end
+
+      state :string do
+        mixin :interpolation
+        rule /\\[nrt\"\'\\]/, Str::Escape
+      end
+
+      state :interpolation do
+        rule /\$#{id}/, Str::Interpol
+        rule /\$\{[^\}]+\}/, Str::Interpol
+      end
+    end
+  end
+end

data/lib/rouge/lexers/diff.rb

@@ -0,0 +1,31 @@
+module Rouge
+  module Lexers
+    class Diff < RegexLexer
+      title 'diff'
+      desc 'Lexes unified diffs or patches'
+
+      tag 'diff'
+      aliases 'patch', 'udiff'
+      filenames '*.diff', '*.patch'
+      mimetypes 'text/x-diff', 'text/x-patch'
+
+      def self.analyze_text(text)
+        return 1   if text.start_with?('Index: ')
+        return 1   if text.start_with?('diff ')
+        return 0.9 if text.start_with?('--- ')
+      end
+
+      state :root do
+        rule(/^ .*\n/, Text)
+        rule(/^---\n/, Text)
+        rule(/^\+.*\n/, Generic::Inserted)
+        rule(/^-+.*\n/, Generic::Deleted)
+        rule(/^!.*\n/, Generic::Strong)
+        rule(/^@.*\n/, Generic::Subheading)
+        rule(/^([Ii]ndex|diff).*\n/, Generic::Heading)
+        rule(/^=.*\n/, Generic::Heading)
+        rule(/.*\n/, Text)
+      end
+    end
+  end
+end

data/lib/rouge/lexers/elixir.rb

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    # Direct port of pygments Lexer.
+    # See: https://bitbucket.org/birkenfeld/pygments-main/src/7304e4759ae65343d89a51359ca538912519cc31/pygments/lexers/functional.py?at=default#cl-2362
+    class Elixir < RegexLexer
+      title "Elixir"
+      desc "Elixir language (elixir-lang.org)"
+
+      tag 'elixir'
+      aliases 'elixir', 'exs'
+
+      filenames '*.ex', '*.exs'
+
+      mimetypes 'text/x-elixir', 'application/x-elixir'
+
+      BRACES = [
+        ['\{', '\}', 'cb'],
+        ['\[', '\]', 'sb'],
+        ['\(', '\)', 'pa'],
+        ['\<', '\>', 'lt']
+      ]
+
+      state :root do
+        rule /\s+/m, Text
+        rule /#.*$/, Comment::Single
+        rule %r{\b(case|cond|end|bc|lc|if|unless|try|loop|receive|fn|defmodule|
+             defp?|defprotocol|defimpl|defrecord|defmacrop?|defdelegate|
+             defexception|exit|raise|throw|unless|after|rescue|catch|else)\b(?![?!])|
+             (?<!\.)\b(do|\-\>)\b}x, Keyword
+        rule /\b(import|require|use|recur|quote|unquote|super|refer)\b(?![?!])/, Keyword::Namespace
+        rule /(?<!\.)\b(and|not|or|when|xor|in)\b/, Operator::Word
+        rule %r{%=|\*=|\*\*=|\+=|\-=|\^=|\|\|=|
+             <=>|<(?!<|=)|>(?!<|=|>)|<=|>=|===|==|=~|!=|!~|(?=[\s\t])\?|
+             (?<=[\s\t])!+|&(&&?|(?!\d))|\|\||\^|\*|\+|\-|/|
+             \||\+\+|\-\-|\*\*|\/\/|\<\-|\<\>|<<|>>|=|\.|~~~}x, Operator
+        rule %r{(?<!:)(:)([a-zA-Z_]\w*([?!]|=(?![>=]))?|\<\>|===?|>=?|<=?|
+             <=>|&&?|%\(\)|%\[\]|%\{\}|\+\+?|\-\-?|\|\|?|\!|//|[%&`/\|]|
+             \*\*?|=?~|<\-)|([a-zA-Z_]\w*([?!])?)(:)(?!:)}, Str::Symbol
+        rule /:"/, Str::Symbol, :interpoling_symbol
+        rule /\b(nil|true|false)\b(?![?!])|\b[A-Z]\w*\b/, Name::Constant
+        rule /\b(__(FILE|LINE|MODULE|MAIN|FUNCTION)__)\b(?![?!])/, Name::Builtin::Pseudo
+        rule /[a-zA-Z_!][\w_]*[!\?]?/, Name
+        rule %r{::|[%(){};,/\|:\\\[\]]}, Punctuation
+        rule /@[a-zA-Z_]\w*|&\d/, Name::Variable
+        rule %r{\b(0[xX][0-9A-Fa-f]+|\d(_?\d)*(\.(?![^\d\s])
+             (_?\d)*)?([eE][-+]?\d(_?\d)*)?|0[bB][01]+)\b}x, Num
+        rule %r{~r\/.*\/}, Str::Regex
+
+        mixin :strings
+      end
+
+      state :strings do
+        rule /(%[A-Ba-z])?"""(?:.|\n)*?"""/, Str::Doc
+        rule /'''(?:.|\n)*?'''/, Str::Doc
+        rule /"/, Str::Doc, :dqs
+        rule /'.*?'/, Str::Single
+        rule %r{(?<!\w)\?(\\(x\d{1,2}|\h{1,2}(?!\h)\b|0[0-7]{0,2}(?![0-7])\b[^x0MC])|(\\[MC]-)+\w|[^\s\\])}, Str::Other
+
+        BRACES.each do |_, _, name|
+          mixin :"braces_#{name}"
+        end
+      end
+
+      BRACES.each do |lbrace, rbrace, name|
+        state :"braces_#{name}" do
+          rule /%[a-z]#{lbrace}/, Str::Double, :"braces_#{name}_intp"
+          rule /%[A-Z]#{lbrace}/, Str::Double, :"braces_#{name}_no_intp"
+        end
+
+        state :"braces_#{name}_intp" do
+          rule /#{rbrace}[a-z]*/, Str::Double, :pop!
+          mixin :enddoublestr
+        end
+
+        state :"braces_#{name}_no_intp" do
+          rule /.*#{rbrace}[a-z]*/, Str::Double, :pop!
+        end
+      end
+
+      state :dqs do
+        rule /"/, Str::Double, :pop!
+        mixin :enddoublestr
+      end
+
+      state :interpoling do
+        rule /#\{/, Str::Interpol, :interpoling_string
+      end
+
+      state :interpoling_string do
+        rule /\}/, Str::Interpol, :pop!
+        mixin :root
+      end
+
+      state :interpoling_symbol do
+        rule /"/, Str::Symbol, :pop!
+        mixin :interpoling
+        rule /[^#"]+/, Str::Symbol
+      end
+
+      state :enddoublestr do
+        mixin :interpoling
+        rule /[^#"]+/, Str::Double
+      end
+    end
+  end
+end

data/lib/rouge/lexers/erb.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class ERB < TemplateLexer
+      title "ERB"
+      desc "Embedded ruby template files"
+
+      tag 'erb'
+      aliases 'eruby', 'rhtml'
+
+      filenames '*.erb', '*.erubis', '*.rhtml', '*.eruby'
+
+      def self.analyze_text(text)
+        return 0.4 if text =~ /<%.*%>/
+      end
+
+      def initialize(opts={})
+        @ruby_lexer = Ruby.new(opts)
+
+        super(opts)
+      end
+
+      start do
+        parent.reset!
+        @ruby_lexer.reset!
+      end
+
+      open  = /<%%|<%=|<%#|<%-|<%/
+      close = /%%>|-%>|%>/
+
+      state :root do
+        rule /<%#/, Comment, :comment
+
+        rule open, Comment::Preproc, :ruby
+
+        rule /.+?(?=#{open})|.+/m do
+          delegate parent
+        end
+      end
+
+      state :comment do
+        rule close, Comment, :pop!
+        rule /.+(?=#{close})|.+/m, Comment
+      end
+
+      state :ruby do
+        rule close, Comment::Preproc, :pop!
+
+        rule /.+?(?=#{close})|.+/m do
+          delegate @ruby_lexer
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/erlang.rb

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Erlang < RegexLexer
+      title "Erlang"
+      desc "The Erlang programming language (erlang.org)"
+      tag 'erlang'
+      aliases 'erl'
+      filenames '*.erl', '*.hrl'
+
+      mimetypes 'text/x-erlang', 'application/x-erlang'
+
+      def self.analyze_text(text)
+        return 0.3 if text =~ /^-module[(]\w+[)][.]/
+      end
+
+      keywords = %w(
+        after begin case catch cond end fun if
+        let of query receive try when
+      )
+
+      builtins = %w(
+        abs append_element apply atom_to_list binary_to_list
+        bitstring_to_list binary_to_term bit_size bump_reductions
+        byte_size cancel_timer check_process_code delete_module
+        demonitor disconnect_node display element erase exit
+        float float_to_list fun_info fun_to_list
+        function_exported garbage_collect get get_keys
+        group_leader hash hd integer_to_list iolist_to_binary
+        iolist_size is_atom is_binary is_bitstring is_boolean
+        is_builtin is_float is_function is_integer is_list
+        is_number is_pid is_port is_process_alive is_record
+        is_reference is_tuple length link list_to_atom
+        list_to_binary list_to_bitstring list_to_existing_atom
+        list_to_float list_to_integer list_to_pid list_to_tuple
+        load_module localtime_to_universaltime make_tuple md5
+        md5_final md5_update memory module_loaded monitor
+        monitor_node node nodes open_port phash phash2
+        pid_to_list port_close port_command port_connect
+        port_control port_call port_info port_to_list
+        process_display process_flag process_info purge_module
+        put read_timer ref_to_list register resume_process
+        round send send_after send_nosuspend set_cookie
+        setelement size spawn spawn_link spawn_monitor
+        spawn_opt split_binary start_timer statistics
+        suspend_process system_flag system_info system_monitor
+        system_profile term_to_binary tl trace trace_delivered
+        trace_info trace_pattern trunc tuple_size tuple_to_list
+        universaltime_to_localtime unlink unregister whereis
+      )
+
+      operators = %r{(\+\+?|--?|\*|/|<|>|/=|=:=|=/=|=<|>=|==?|<-|!|\?)}
+      word_operators = %w(
+        and andalso band bnot bor bsl bsr bxor
+        div not or orelse rem xor
+      )
+
+      atom_re = %r{(?:[a-z][a-zA-Z0-9_]*|'[^\n']*[^\\]')}
+
+      variable_re = %r{(?:[A-Z_][a-zA-Z0-9_]*)}
+
+      escape_re = %r{(?:\\(?:[bdefnrstv\'"\\/]|[0-7][0-7]?[0-7]?|\^[a-zA-Z]))}
+
+      macro_re = %r{(?:#{variable_re}|#{atom_re})}
+
+      base_re = %r{(?:[2-9]|[12][0-9]|3[0-6])}
+
+      state :root do
+        rule(/\s+/, Text)
+        rule(/%.*\n/, Comment)
+        rule(%r{(#{keywords.join('|')})\b}, Keyword)
+        rule(%r{(#{builtins.join('|')})\b}, Name::Builtin)
+        rule(%r{(#{word_operators.join('|')})\b}, Operator::Word)
+        rule(/^-/, Punctuation, :directive)
+        rule(operators, Operator)
+        rule(/"/, Str, :string)
+        rule(/<</, Name::Label)
+        rule(/>>/, Name::Label)
+        rule %r{(#{atom_re})(:)} do
+          groups Name::Namespace, Punctuation
+        end
+        rule %r{(?:^|(?<=:))(#{atom_re})(\s*)(\()} do
+          groups Name::Function, Text, Punctuation
+        end
+        rule(%r{[+-]?#{base_re}#[0-9a-zA-Z]+}, Num::Integer)
+        rule(/[+-]?\d+/, Num::Integer)
+        rule(/[+-]?\d+.\d+/, Num::Float)
+        rule(%r{[\]\[:_@\".{}()|;,]}, Punctuation)
+        rule(variable_re, Name::Variable)
+        rule(atom_re, Name)
+        rule(%r{\?#{macro_re}}, Name::Constant)
+        rule(%r{\$(?:#{escape_re}|\\[ %]|[^\\])}, Str::Char)
+        rule(%r{##{atom_re}(:?\.#{atom_re})?}, Name::Label)
+      end
+
+      state :string do
+        rule(escape_re, Str::Escape)
+        rule(/"/, Str, :pop!)
+        rule(%r{~[0-9.*]*[~#+bBcdefginpPswWxX]}, Str::Interpol)
+        rule(%r{[^"\\~]+}, Str)
+        rule(/~/, Str)
+      end
+
+      state :directive do
+        rule %r{(define)(\s*)(\()(#{macro_re})} do
+          groups Name::Entity, Text, Punctuation, Name::Constant
+          pop!
+        end
+        rule %r{(record)(\s*)(\()(#{macro_re})} do
+          groups Name::Entity, Text, Punctuation, Name::Label
+          pop!
+        end
+        rule(atom_re, Name::Entity, :pop!)
+      end
+    end
+  end
+end

data/lib/rouge/lexers/factor.rb

@@ -0,0 +1,302 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Factor < RegexLexer
+      title "Factor"
+      desc "Factor, the practical stack language (factorcode.org)"
+      tag 'factor'
+      filenames '*.factor'
+      mimetypes 'text/x-factor'
+
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'factor'
+      end
+
+      def self.builtins
+        @builtins ||= {}.tap do |builtins|
+          builtins[:kernel] = Set.new %w(
+            or 2bi 2tri while wrapper nip 4dip wrapper? bi*
+            callstack>array both? hashcode die dupd callstack
+            callstack? 3dup tri@ pick curry build ?execute 3bi prepose
+            >boolean if clone eq? tri* ? = swapd 2over 2keep 3keep clear
+            2dup when not tuple? dup 2bi* 2tri* call tri-curry object bi@
+            do unless* if* loop bi-curry* drop when* assert= retainstack
+            assert? -rot execute 2bi@ 2tri@ boa with either? 3drop bi
+            curry?  datastack until 3dip over 3curry tri-curry* tri-curry@
+            swap and 2nip throw bi-curry (clone) hashcode* compose 2dip if
+            3tri unless compose? tuple keep 2curry equal? assert tri 2drop
+            most <wrapper> boolean? identity-hashcode identity-tuple?
+            null new dip bi-curry@ rot xor identity-tuple boolean
+          )
+
+          builtins[:assocs] = Set.new %w(
+            ?at assoc? assoc-clone-like assoc= delete-at* assoc-partition
+            extract-keys new-assoc value? assoc-size map>assoc push-at
+            assoc-like key? assoc-intersect assoc-refine update
+            assoc-union assoc-combine at* assoc-empty? at+ set-at
+            assoc-all? assoc-subset?  assoc-hashcode change-at assoc-each
+            assoc-diff zip values value-at rename-at inc-at enum? at cache
+            assoc>map <enum> assoc assoc-map enum value-at* assoc-map-as
+            >alist assoc-filter-as clear-assoc assoc-stack maybe-set-at
+            substitute assoc-filter 2cache delete-at assoc-find keys
+            assoc-any? unzip
+          )
+
+          builtins[:combinators] = Set.new %w(
+            case execute-effect no-cond no-case? 3cleave>quot 2cleave
+            cond>quot wrong-values? no-cond? cleave>quot no-case case>quot
+            3cleave wrong-values to-fixed-point alist>quot case-find
+            cond cleave call-effect 2cleave>quot recursive-hashcode
+            linear-case-quot spread spread>quot
+          )
+
+          builtins[:math] = Set.new %w(
+            number= if-zero next-power-of-2 each-integer ?1+
+            fp-special? imaginary-part unless-zero float>bits number?
+            fp-infinity? bignum? fp-snan? denominator fp-bitwise= *
+            + power-of-2? - u>= / >= bitand log2-expects-positive <
+            log2 > integer? number bits>double 2/ zero? (find-integer)
+            bits>float float? shift ratio? even? ratio fp-sign bitnot
+            >fixnum complex? /i /f byte-array>bignum when-zero sgn >bignum
+            next-float u< u> mod recip rational find-last-integer >float
+            (all-integers?) 2^ times integer fixnum? neg fixnum sq bignum
+            (each-integer) bit? fp-qnan? find-integer complex <fp-nan>
+            real double>bits bitor rem fp-nan-payload all-integers?
+            real-part log2-expects-positive? prev-float align unordered?
+            float fp-nan? abs bitxor u<= odd? <= /mod rational? >integer
+            real? numerator
+          )
+
+          builtins[:sequences] = Set.new %w(
+            member-eq? append assert-sequence= find-last-from
+            trim-head-slice clone-like 3sequence assert-sequence? map-as
+            last-index-from reversed index-from cut* pad-tail
+            remove-eq! concat-as but-last snip trim-tail nths
+            nth 2selector sequence slice?  <slice> partition
+            remove-nth tail-slice empty? tail* if-empty
+            find-from virtual-sequence? member? set-length
+            drop-prefix unclip unclip-last-slice iota map-sum
+            bounds-error? sequence-hashcode-step selector-for
+            accumulate-as map start midpoint@ (accumulate) rest-slice
+            prepend fourth sift accumulate! new-sequence follow map! like
+            first4 1sequence reverse slice unless-empty padding virtual@
+            repetition? set-last index 4sequence max-length set-second
+            immutable-sequence first2 first3 replicate-as reduce-index
+            unclip-slice supremum suffix! insert-nth trim-tail-slice
+            tail 3append short count suffix concat flip filter sum
+            immutable? reverse! 2sequence map-integers delete-all start*
+            indices snip-slice check-slice sequence?  head map-find
+            filter! append-as reduce sequence= halves collapse-slice
+            interleave 2map filter-as binary-reduce slice-error? product
+            bounds-check? bounds-check harvest immutable virtual-exemplar
+            find produce remove pad-head last replicate set-fourth
+            remove-eq shorten reversed?  map-find-last 3map-as
+            2unclip-slice shorter? 3map find-last head-slice pop* 2map-as
+            tail-slice* but-last-slice 2map-reduce iota? collector-for
+            accumulate each selector append! new-resizable cut-slice
+            each-index head-slice* 2reverse-each sequence-hashcode
+            pop set-nth ?nth <flat-slice> second join when-empty
+            collector immutable-sequence? <reversed> all? 3append-as
+            virtual-sequence subseq? remove-nth! push-either new-like
+            length last-index push-if 2all? lengthen assert-sequence
+            copy map-reduce move third first 3each tail? set-first prefix
+            bounds-error any? <repetition> trim-slice exchange surround
+            2reduce cut change-nth min-length set-third produce-as
+            push-all head? delete-slice rest sum-lengths 2each head*
+            infimum remove! glue slice-error subseq trim replace-slice
+            push repetition map-index trim-head unclip-last mismatch
+          )
+
+          builtins[:namespaces] = Set.new %w(
+            global +@ change set-namestack change-global init-namespaces
+            on off set-global namespace set with-scope bind with-variable
+            inc dec counter initialize namestack get get-global make-assoc
+          )
+
+          builtins[:arrays] = Set.new %w(
+            <array> 2array 3array pair >array 1array 4array pair?
+            array resize-array array?
+          )
+
+          builtins[:io] = Set.new %w(
+            +character+ bad-seek-type? readln each-morsel
+            stream-seek read print with-output-stream contents
+            write1 stream-write1 stream-copy stream-element-type
+            with-input-stream stream-print stream-read stream-contents
+            stream-tell tell-output bl seek-output bad-seek-type nl
+            stream-nl write flush stream-lines +byte+ stream-flush
+            read1 seek-absolute? stream-read1 lines stream-readln
+            stream-read-until each-line seek-end with-output-stream*
+            seek-absolute with-streams seek-input seek-relative?
+            input-stream stream-write read-partial seek-end?
+            seek-relative error-stream read-until with-input-stream*
+            with-streams* tell-input each-block output-stream
+            stream-read-partial each-stream-block each-stream-line
+          )
+
+          builtins[:strings] = Set.new %w(
+            resize-string >string <string> 1string string string?
+          )
+
+          builtins[:vectors] = Set.new %w(
+            with-return restarts return-continuation with-datastack
+            recover rethrow-restarts <restart> ifcc set-catchstack
+            >continuation< cleanup ignore-errors restart?
+            compute-restarts attempt-all-error error-thread
+            continue <continuation> attempt-all-error? condition?
+            <condition> throw-restarts error catchstack continue-with
+            thread-error-hook continuation rethrow callcc1
+            error-continuation callcc0 attempt-all condition
+            continuation? restart return
+          )
+
+          builtins[:continuations] = Set.new %w(
+            with-return restarts return-continuation with-datastack
+            recover rethrow-restarts <restart> ifcc set-catchstack
+            >continuation< cleanup ignore-errors restart?
+            compute-restarts attempt-all-error error-thread
+            continue <continuation> attempt-all-error? condition?
+            <condition> throw-restarts error catchstack continue-with
+            thread-error-hook continuation rethrow callcc1
+            error-continuation callcc0 attempt-all condition
+            continuation? restart return
+          )
+        end
+      end
+
+      state :root do
+        rule /\s+/m, Text
+
+        rule /(:|::|MACRO:|MEMO:|GENERIC:|HELP:)(\s+)(\S+)/m do
+          groups Keyword, Text, Name::Function
+        end
+
+        rule /(M:|HOOK:|GENERIC#)(\s+)(\S+)(\s+)(\S+)/m do
+          groups Keyword, Text, Name::Class, Text, Name::Function
+        end
+
+        rule /\((?=\s)/, Name::Function, :stack_effect
+        rule /;(?=\s)/, Keyword
+
+        rule /(USING:)((?:\s|\\\s)+)/m do
+          groups Keyword::Namespace, Text
+          push :import
+        end
+
+        rule /(IN:|USE:|UNUSE:|QUALIFIED:|QUALIFIED-WITH:)(\s+)(\S+)/m do
+          groups Keyword::Namespace, Text, Name::Namespace
+        end
+
+        rule /(FROM:|EXCLUDE:)(\s+)(\S+)(\s+)(=>)/m do
+          groups Keyword::Namespace, Text, Name::Namespace, Text, Punctuation
+        end
+
+        rule /(?:ALIAS|DEFER|FORGET|POSTPONE):/, Keyword::Namespace
+
+        rule /(TUPLE:)(\s+)(\S+)(\s+)(<)(\s+)(\S+)/m do
+          groups(
+            Keyword, Text,
+            Name::Class, Text,
+            Punctuation, Text,
+            Name::Class
+          )
+          push :slots
+        end
+
+        rule /(TUPLE:)(\s+)(\S+)/m do
+          groups Keyword, Text, Name::Class
+          push :slots
+        end
+
+        rule /(UNION:|INTERSECTION:)(\s+)(\S+)/m do
+          groups Keyword, Text, Name::Class
+        end
+
+        rule /(PREDICATE:)(\s+)(\S+)(\s+)(<)(\s+)(\S+)/m do
+          groups(
+            Keyword, Text,
+            Name::Class, Text,
+            Punctuation, Text,
+            Name::Class
+          )
+        end
+
+        rule /(C:)(\s+)(\S+)(\s+)(\S+)/m do
+          groups(
+            Keyword, Text,
+            Name::Function, Text,
+            Name::Class
+          )
+        end
+
+        rule %r(
+          (INSTANCE|SLOT|MIXIN|SINGLETONS?|CONSTANT|SYMBOLS?|ERROR|SYNTAX
+           |ALIEN|TYPEDEF|FUNCTION|STRUCT):
+        )x, Keyword
+
+        rule /(?:<PRIVATE|PRIVATE>)/, Keyword::Namespace
+
+        rule /(MAIN:)(\s+)(\S+)/ do
+          groups Keyword::Namespace, Text, Name::Function
+        end
+
+        # strings
+        rule /"""\s+.*?\s+"""/, Str
+        rule /"(\\.|[^\\])*?"/, Str
+        rule /(CHAR:)(\s+)(\\[\\abfnrstv]*|\S)(?=\s)/, Str::Char
+
+        # comments
+        rule /!\s+.*$/, Comment
+        rule /#!\s+.*$/, Comment
+
+        # booleans
+        rule /[tf](?=\s)/, Name::Constant
+
+        # numbers
+        rule /-?\d+\.\d+(?=\s)/, Num::Float
+        rule /-?\d+(?=\s)/, Num::Integer
+
+        rule /HEX:\s+[a-fA-F\d]+(?=\s)/m, Num::Hex
+        rule /BIN:\s+[01]+(?=\s)/, Num::Bin
+        rule /OCT:\s+[0-7]+(?=\s)/, Num::Oct
+
+        rule %r([-+/*=<>^](?=\s)), Operator
+
+        rule /(?:deprecated|final|foldable|flushable|inline|recursive)(?=\s)/,
+          Keyword
+
+        rule /\S+/ do |m|
+          name = m[0]
+
+          if self.class.builtins.values.any? { |b| b.include? name }
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+      end
+
+      state :stack_effect do
+        rule /\s+/, Text
+        rule /\(/, Name::Function, :stack_effect
+        rule /\)/, Name::Function, :pop!
+
+        rule /--/, Name::Function
+        rule /\S+/, Name::Variable
+      end
+
+      state :slots do
+        rule /\s+/, Text
+        rule /;(?=\s)/, Keyword, :pop!
+        rule /\S+/, Name::Variable
+      end
+
+      state :import do
+        rule /;(?=\s)/, Keyword, :pop!
+        rule /\s+/, Text
+        rule /\S+/, Name::Namespace
+      end
+    end
+  end
+end