rouge 4.1.3 → 4.7.0

data/lib/rouge/lexers/groovy.rb

@@ -7,11 +7,13 @@ module Rouge
       title "Groovy"
       desc 'The Groovy programming language (http://www.groovy-lang.org/)'
       tag 'groovy'
-      filenames '*.groovy', 'Jenkinsfile', '*.Jenkinsfile'
+      aliases 'nextflow', 'nf'
+      filenames '*.groovy', 'Jenkinsfile', '*.Jenkinsfile', '*.nf'
       mimetypes 'text/x-groovy'
 
       def self.detect?(text)
         return true if text.shebang?(/groovy/)
+        return true if text.shebang?(/nextflow/)
       end
 
       def self.keywords
@@ -23,7 +25,7 @@ module Rouge
 
       def self.declarations
         @declarations ||= Set.new %w(
-          abstract const enum extends final implements native private
+          abstract const extends final implements native private
           protected public static strictfp super synchronized throws
           transient volatile
         )
@@ -31,7 +33,7 @@ module Rouge
 
       def self.types
         @types ||= Set.new %w(
-          def boolean byte char double float int long short void
+          def var boolean byte char double float int long short void
         )
       end
 
@@ -56,7 +58,7 @@ module Rouge
         rule %r(//.*?$), Comment::Single
         rule %r(/[*].*?[*]/)m, Comment::Multiline
         rule %r/@\w[\w.]*/, Name::Decorator
-        rule %r/(class|interface|trait)\b/,  Keyword::Declaration, :class
+        rule %r/(class|interface|trait|enum|record)\b/,  Keyword::Declaration, :class
         rule %r/package\b/, Keyword::Namespace, :import
         rule %r/import\b/, Keyword::Namespace, :import
 

data/lib/rouge/lexers/gts.rb

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'typescript.rb'
+
+    class Gts < Typescript
+      title "Template Tag (gts)"
+      desc "Ember.js, TypeScript with <template> tags"
+      tag "gts"
+      filenames "*.gts"
+      mimetypes "text/x-gts", "application/x-gts"
+
+      def initialize(*)
+        super
+        @handlebars = Handlebars.new(options)
+      end
+
+      prepend :root do
+        rule %r/(<)(template)(>)/ do
+          groups Name::Tag, Keyword, Name::Tag
+          push :template
+        end
+      end
+
+      state :template do
+        rule %r((</)(template)(>)) do
+          groups Name::Tag, Keyword, Name::Tag
+          pop!
+        end
+
+        rule %r/.+?(?=<\/template>)/m do
+          delegate @handlebars
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/hcl.rb

@@ -26,6 +26,7 @@ module Rouge
       state :primitives do
         rule %r/[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?([kKmMgG]b?)?/, Num::Float
         rule %r/[0-9]+([kKmMgG]b?)?/, Num::Integer
+        rule %r/[-+*\/!%&<>|=:?]/, Operator
 
         rule %r/"/, Str::Double, :dq
         rule %r/'/, Str::Single, :sq

data/lib/rouge/lexers/html.rb

@@ -7,7 +7,7 @@ module Rouge
       title "HTML"
       desc "HTML, the markup language of the web"
       tag 'html'
-      filenames '*.htm', '*.html', '*.xhtml', '*.cshtml'
+      filenames '*.htm', '*.html', '*.xhtml', '*.cshtml', '*.razor'
       mimetypes 'text/html', 'application/xhtml+xml'
 
       def self.detect?(text)

data/lib/rouge/lexers/iecst.rb

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class IecST < RegexLexer
+      tag 'iecst'
+      title "IEC 61131-3 Structured Text"
+      desc 'Structured text is a programming language for PLCs (programmable logic controllers).'
+      filenames '*.awl', '*.scl', '*.st'
+
+      mimetypes 'text/x-iecst'
+
+      def self.keywords
+        blocks = %w(
+          PROGRAM CONFIGURATION INITIAL_STEP INTERFACE FUNCTION_BLOCK FUNCTION ACTION TRANSITION
+          TYPE STRUCT STEP NAMESPACE LIBRARY CHANNEL FOLDER RESOURCE
+          VAR_ACCESS VAR_CONFIG VAR_EXTERNAL VAR_GLOBAL VAR_INPUT VAR_IN_OUT VAR_OUTPUT VAR_TEMP VAR
+          CONST METHOD PROPERTY
+          CASE FOR IF REPEAT WHILE
+        )
+        @keywords ||= Set.new %w(
+          AT BEGIN BY CONSTANT CONTINUE DO ELSE ELSIF EXIT EXTENDS FROM GET GOTO IMPLEMENTS JMP
+          NON_RETAIN OF PRIVATE PROTECTED PUBLIC RETAIN RETURN SET TASK THEN TO UNTIL USING WITH
+          __CATCH __ENDTRY __FINALLY __TRY
+        ) + blocks + blocks.map {|kw| "END_" + kw}
+      end
+
+      def self.types
+        @types ||= Set.new %w(
+          ANY ARRAY BOOL BYTE POINTER STRING
+          DATE DATE_AND_TIME DT TIME TIME_OF_DAY TOD
+          INT DINT LINT SINT UINT UDINT ULINT USINT
+          WORD DWORD LWORD
+          REAL LREAL
+        )
+      end
+
+      def self.literals
+        @literals ||= Set.new %w(TRUE FALSE NULL)
+      end
+
+      def self.operators
+        @operators ||= Set.new %w(AND EQ EXPT GE GT LE LT MOD NE NOT OR XOR)
+      end
+
+      state :whitespace do
+        # Spaces
+        rule %r/\s+/m, Text
+        # // Comments
+        rule %r((//).*$\n?), Comment::Single
+        # (* Comments *)
+        rule %r(\(\*.*?\*\))m, Comment::Multiline
+        # { Comments }
+        rule %r(\{.*?\})m, Comment::Special
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule %r/'[^']+'/, Literal::String::Single
+        rule %r/"[^"]+"/, Literal::String::Symbol
+        rule %r/%[IQM][XBWDL][\d.]*|%[IQ][\d.]*/, Name::Variable::Magic
+        rule %r/\b(?:D|DT|T|TOD)#[\d_shmd:]*/i, Literal::Date
+        rule %r/\b(?:16#[\d_a-f]+|0x[\d_a-f]+)\b/i, Literal::Number::Hex
+        rule %r/\b2#[01_]+/, Literal::Number::Bin
+        rule %r/(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i, Literal::Number::Float
+        rule %r/\b[\d.,_]+/, Literal::Number
+
+        rule %r/\b[A-Z_]+\b/i do |m|
+          name = m[0].upcase
+          if self.class.keywords.include?(name)
+            token Keyword
+          elsif self.class.types.include?(name)
+            token Keyword::Type
+          elsif self.class.literals.include?(name)
+            token Literal
+          elsif self.class.operators.include?(name)
+            token Operator
+          else
+            token Name
+          end
+        end
+
+        rule %r/S?R?:?=>?|&&?|\*\*?|<[=>]?|>=?|[-:^\/+#]/, Operator
+        rule %r/\b[a-z_]\w*(?=\s*\()/i, Name::Function
+        rule %r/\b[a-z_]\w*\b/i, Name
+        rule %r/[()\[\].,;]/, Punctuation
+      end
+    end
+  end
+end

data/lib/rouge/lexers/ini.rb

@@ -8,15 +8,14 @@ module Rouge
       desc 'the INI configuration format'
       tag 'ini'
 
-      # TODO add more here
-      filenames '*.ini', '*.INI', '*.gitconfig'
-      mimetypes 'text/x-ini'
+      filenames '*.ini', '*.INI', '*.gitconfig', '*.cfg', '.editorconfig', '*.inf'
+      mimetypes 'text/x-ini', 'text/inf'
 
       identifier = /[\w\-.]+/
 
       state :basic do
+        rule %r/\s+/, Text::Whitespace
         rule %r/[;#].*?\n/, Comment
-        rule %r/\s+/, Text
         rule %r/\\\n/, Str::Escape
       end
 
@@ -24,11 +23,14 @@ module Rouge
         mixin :basic
 
         rule %r/(#{identifier})(\s*)(=)/ do
-          groups Name::Property, Text, Punctuation
+          groups Name::Property, Text::Whitespace, Punctuation
           push :value
         end
 
         rule %r/\[.*?\]/, Name::Namespace
+
+        # standalone option, supported by some INI parsers
+        rule %r/(.+?)/, Name::Attribute
       end
 
       state :value do

data/lib/rouge/lexers/java.rb

@@ -51,7 +51,7 @@ module Rouge
         rule %r/(?:#{declarations.join('|')})\b/, Keyword::Declaration
         rule %r/(?:#{types.join('|')})\b/, Keyword::Type
         rule %r/(?:true|false|null)\b/, Keyword::Constant
-        rule %r/(?:class|interface)\b/, Keyword::Declaration, :class
+        rule %r/(?:class|interface|record)\b/, Keyword::Declaration, :class
         rule %r/(?:import|package)\b/, Keyword::Namespace, :import
         rule %r/"""\s*\n.*?(?<!\\)"""/m, Str::Heredoc
         rule %r/"(\\\\|\\"|[^"])*"/, Str

data/lib/rouge/lexers/javascript.rb

@@ -100,7 +100,7 @@ module Rouge
 
       def self.keywords
         @keywords ||= Set.new %w(
-          as async await break case catch continue debugger default delete
+          async await break case catch continue debugger default delete
           do else export finally from for if import in instanceof new of
           return super switch this throw try typeof void while yield
         )
@@ -190,8 +190,8 @@ module Rouge
 
         rule %r/function(?=(\(.*\)))/, Keyword::Declaration # For anonymous functions
 
-        rule %r/(#{id})[ \t]*(?=(\(.*\)))/m do |m|
-          if self.class.keywords.include? m[1]
+        rule %r/(#?#{id})[ \t]*(?=(\(.*\)))/m do |m|
+          if self.class.keywords.include?(m[1])
             # "if" in "if (...)" or "switch" in "switch (...)" are recognized as keywords.
             token Keyword
           else
@@ -201,7 +201,7 @@ module Rouge
 
         rule %r/[{}]/, Punctuation, :statement
 
-        rule id do |m|
+        rule %r/#?#{id}/ do |m|
           if self.class.keywords.include? m[0]
             token Keyword
             push :expr_start

data/lib/rouge/lexers/json5.rb

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'json.rb'
+
+    class JSON5 < JSON
+      title 'JSON 5'
+      tag 'json5'
+      filenames '*.json5'
+      mimetypes 'application/json5', 'application/x-json5'
+
+      desc 'JSON 5 extension for JSON (json5.org)'
+
+      append :whitespace do
+        rule %r://.*$:, Comment
+
+        # comments are non-nesting, so a single regex will do
+        rule %r:/[*].*?[*]/:m, Comment
+      end
+
+      prepend :name do
+        rule Javascript.id_regex, Name::Label
+        rule %r/".*?"/, Name::Label
+      end
+
+      # comments can appear between keys and :, so we have to
+      # manage our states a little more carefully
+      append :object do
+        rule %r/:/ do
+          token Punctuation
+          goto :object_value
+        end
+      end
+
+      state :object_value do
+        mixin :value
+        rule %r/,/ do
+          token Punctuation
+          goto :object
+        end
+
+        rule %r/}/, Punctuation, :pop!
+      end
+
+      append :value do
+        rule %r/'/, Str::Single, :sstring
+      end
+
+      state :sstring do
+        rule %r/[^\\']+/, Str::Single
+        rule %r/\\./m, Str::Escape
+        rule %r/'/, Str::Single, :pop!
+      end
+
+      # can escape newlines
+      append :string do
+        rule %r/\\./m, Str::Escape
+      end
+
+      # override: numbers are very different in json5
+      state :constants do
+        rule %r/\b(?:true|false|null)\b/, Keyword::Constant
+        rule %r/[+-]?\b(?:Infinity|NaN)\b/, Keyword::Constant
+        rule %r/[+-]?0x\h+/i, Num::Hex
+
+        rule %r/[+-.]?[0-9]+[.]?[0-9]?([eE][-]?[0-9]+)?/i, Num::Float
+        rule %r/[+-]?\d+e[+-]?\d+/, Num::Integer
+        rule %r/[+-]?(?:0|[1-9]\d*)(?:e[+-]?\d+)?/i, Num::Integer
+      end
+    end
+  end
+end

data/lib/rouge/lexers/julia.rb

@@ -252,15 +252,16 @@ module Rouge
         rule %r/\d+/, Literal::Number::Integer
       end
 
+      NAME_RE = %r/[\p{L}\p{Nl}\p{S}_][\p{Word}\p{S}\p{Po}!]*/
 
       state :funcname do
-        rule %r/[\p{L}\p{Nl}\p{S}_][\p{Word}\p{S}\p{Po}!]*/, Name::Function, :pop!
+        rule NAME_RE, Name::Function, :pop!
         rule %r/\([^\s\w{]{1,2}\)/, Operator, :pop!
         rule %r/[^\s\w{]{1,2}/, Operator, :pop!
       end
 
       state :typename do
-        rule %r/[\p{L}\p{Nl}\p{S}_][\p{Word}\p{S}\p{Po}!]*/, Name::Class, :pop!
+        rule NAME_RE, Name::Class, :pop!
       end
 
       state :stringescape do

data/lib/rouge/lexers/kotlin.rb

@@ -24,7 +24,7 @@ module Rouge
         while yield
       )
 
-      name_chars = %r'[-_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}\p{Nd}\p{Pc}\p{Cf}\p{Mn}\p{Mc}]*'
+      name_chars = %r'[-\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}\p{Nd}\p{Pc}\p{Cf}\p{Mn}\p{Mc}]*'
 
       class_name = %r'`?[\p{Lu}]#{name_chars}`?'
       name = %r'`?[_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}]#{name_chars}`?'

data/lib/rouge/lexers/lua.rb

@@ -105,7 +105,26 @@ module Rouge
         rule %r/\)/, Punctuation, :pop!
         rule %r/[(,]/, Punctuation
         rule %r/\s+/, Text
-        rule %r/"/, Str::Regex, :regex
+        rule %r/'/, Str::Regex, :regex_sq
+        rule %r/"/, Str::Regex, :regex_dq
+      end
+
+      state :regex_sq do
+        rule %r(') do
+          token Str::Regex
+          goto :regex_end
+        end
+
+        mixin :regex
+      end
+
+      state :regex_dq do
+        rule %r(") do
+          token Str::Regex
+          goto :regex_end
+        end
+
+        mixin :regex
       end
 
       state :regex do
@@ -151,13 +170,15 @@ module Rouge
       end
 
       state :sqs do
+        rule %r(\\'), Str::Escape
         rule %r('), Str::Single, :pop!
-        rule %r([^']+), Str::Single
+        rule %r([^'\\]+), Str::Single
       end
 
       state :dqs do
+        rule %r(\\"), Str::Escape
         rule %r("), Str::Double, :pop!
-        rule %r([^"]+), Str::Double
+        rule %r([^"\\]+), Str::Double
       end
     end
   end

data/lib/rouge/lexers/make.rb

@@ -40,6 +40,10 @@ module Rouge
           groups Keyword, Text, Name::Variable
         end
 
+        rule %r/(else\b)([\t ]+)((?:ifn?def|ifn?eq)\b)([\t ]+)([^#\n]+)/ do
+          groups Keyword, Text, Keyword, Text, Name::Variable
+        end
+
         rule %r/(?:else|endif|endef|endfor)[\t ]*(?=[#\n])/, Keyword
 
         rule %r/(export)([\t ]+)(?=[\w\${}()\t -]+\n)/ do
@@ -73,7 +77,7 @@ module Rouge
       end
 
       state :export do
-        rule %r/[\w[\$]{1,2}{}()-]/, Name::Variable
+        rule %r/[\w\${}()-]/, Name::Variable
         rule %r/\n/, Text, :pop!
         rule %r/[\t ]+/, Text
       end

data/lib/rouge/lexers/markdown.rb

@@ -107,7 +107,8 @@ module Rouge
           push :link
         end
 
-        rule %r/[*][*]#{edot}*?[*][*]/, Generic::Strong
+        rule %r/[*]{2}[^* \n][^*\n]*[*]{2}/, Generic::Strong
+        rule %r/[*]{3}[^* \n][^*\n]*[*]{3}/, Generic::EmphStrong
         rule %r/__#{edot}*?__/, Generic::Strong
 
         rule %r/[*]#{edot}*?[*]/, Generic::Emph

data/lib/rouge/lexers/mathematica.rb

@@ -7,7 +7,7 @@ module Rouge
       title "Mathematica"
       desc "Wolfram Mathematica, the world's definitive system for modern technical computing."
       tag 'mathematica'
-      aliases 'wl'
+      aliases 'wl', 'wolfram'
       filenames '*.m', '*.wl'
       mimetypes 'application/vnd.wolfram.mathematica.package', 'application/vnd.wolfram.wl'
 

data/lib/rouge/lexers/meson.rb

@@ -38,7 +38,6 @@ module Rouge
       end
 
       identifier =        /[[:alpha:]_][[:alnum:]_]*/
-      dotted_identifier = /[[:alpha:]_.][[:alnum:]_.]*/
 
       def current_string
         @current_string ||= StringRegister.new

data/lib/rouge/lexers/mojo.rb

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'python.rb'
+    
+    class Mojo < Python
+      title "Mojo"
+      desc "The Mojo programming language (modular.com)"
+      tag 'mojo'
+      aliases 'mojo'
+      filenames '*.mojo', '*.🔥'
+      mimetypes 'text/x-mojo', 'application/x-mojo'
+
+      def self.detect?(text)
+        return true if text.shebang?(/mojow?(?:[23](?:\.\d+)?)?/)
+      end
+
+      def self.keywords
+        @keywords ||= super + %w(
+          fn self alias out read mut owned ref var
+          struct trait raises with in match case
+        )
+      end
+
+      def self.builtins
+        @builtins ||= super + %w(
+          __mlir_attr __mlir_type __mlir_op parameter alwaysinline
+          register_passable
+        )
+      end
+    end
+  end
+end

data/lib/rouge/lexers/nasm.rb

@@ -14,11 +14,12 @@ module Rouge
       mimetypes 'text/x-nasm'
 
       state :root do
-			  rule %r/^\s*%/, Comment::Preproc, :preproc
+        rule %r/^\s*%/, Comment::Preproc, :preproc
 
-			  mixin :whitespace
+        mixin :whitespace
+        mixin :punctuation
 
-			  rule %r/[a-z$._?][\w$.?#@~]*:/i, Name::Label
+        rule %r/[a-z$._?][\w$.?#@~]*:/i, Name::Label
 
         rule %r/([a-z$._?][\w$.?#@~]*)(\s+)(equ)/i do
           groups Name::Constant, Keyword::Declaration, Keyword::Declaration
@@ -32,7 +33,7 @@ module Rouge
       end
 
       state :instruction_args do
-			  rule %r/"(\\\\"|[^"\\n])*"|'(\\\\'|[^'\\n])*'|`(\\\\`|[^`\\n])*`/, Str
+        rule %r/"(\\\\"|[^"\\n])*"|'(\\\\'|[^'\\n])*'|`(\\\\`|[^`\\n])*`/, Str
         rule %r/(?:0x[\da-f]+|$0[\da-f]*|\d+[\da-f]*h)/i, Num::Hex
         rule %r/[0-7]+q/i, Num::Oct
         rule %r/[01]+b/i, Num::Bin

data/lib/rouge/lexers/nginx.rb

@@ -53,6 +53,7 @@ module Rouge
         # mimetype
         rule %r([a-z-]+/[a-z-]+)i, Name::Class
 
+        rule %r/\d+\.\d+/, Num::Float
         rule %r/[0-9]+[kmg]?\b/i, Num::Integer
         rule %r/(~)(\s*)([^\s{]+)/ do
           groups Punctuation, Text, Str::Regex

data/lib/rouge/lexers/objective_c/common.rb

@@ -4,8 +4,6 @@
 module Rouge
   module Lexers
     module ObjectiveCCommon
-      id = /[a-z$_][a-z0-9$_]*/i
-
       def at_keywords
         @at_keywords ||= %w(
           selector private protected public encode synchronized try

data/lib/rouge/lexers/objective_c.rb

@@ -12,7 +12,7 @@ module Rouge
       tag 'objective_c'
       title "Objective-C"
       desc 'an extension of C commonly used to write Apple software'
-      aliases 'objc', 'obj-c', 'obj_c', 'objectivec'
+      aliases 'objc', 'obj-c', 'obj_c', 'objectivec', 'objective-c'
       filenames '*.m', '*.h'
 
       mimetypes 'text/x-objective_c', 'application/x-objective_c'

data/lib/rouge/lexers/ocl.rb

@@ -61,9 +61,9 @@ module Rouge
         rule %r/--.*/, Comment::Single
         rule %r/\d+/, Num::Integer
         rule %r/'/, Str::Single, :single_string
-        rule %r([->|+*/<>=~!@#%&|?^-]), Operator
+        rule %r([-|+*/<>=~!@#%&?^]), Operator
         rule %r/[;:()\[\],.]/, Punctuation
-        rule %r/\w[\w\d]*/ do |m|
+        rule %r/[a-zA-Z]\w*/ do |m|
           if self.class.operators.include? m[0]
             token Operator
           elsif self.class.keywords_type.include? m[0]

data/lib/rouge/lexers/openedge.rb

@@ -12,8 +12,6 @@ module Rouge
       title 'OpenEdge ABL'
       desc 'The OpenEdge ABL programming language'
 
-      # optional comment or whitespace
-      ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
       id = /[a-zA-Z_&{}!][a-zA-Z0-9_\-&!}]*/
 
       def self.keywords

data/lib/rouge/lexers/p4.rb

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class P4 < RegexLexer
+      tag 'p4'
+      title 'P4'
+      desc 'The P4 programming language'
+      filenames '*.p4'
+      mimetypes 'text/x-p4'
+
+      def self.keywords
+        @keywords ||= %w(
+          abstract action actions apply const default default_action else enum
+          entries extern exit if in inout key list out package packet_in
+          packet_out return size select switch this transition tuple type
+          typedef
+        )
+      end
+
+      def self.operators
+        @operators ||= %w(
+          \|\+\| \|-\| \? \& \&\&\& < > << >> \* \| ~ \^ - \+ /
+          \# \. = != <= >= \+\+
+        )
+      end
+
+      def self.decls
+        @decls ||= %w(
+          control header header_union parser state struct table
+          value_set
+        )
+      end
+
+      def self.builtins
+        @builtins ||= %w(
+          bit bool error extract int isValid setValid setInvalid match_kind
+          string varbit verify void
+        )
+      end
+
+      state :whitespace do
+        rule %r/\s+/m, Text
+      end
+
+      state :comment do
+        rule %r((//).*$\n?), Comment::Single
+        rule %r/\/\*(?:(?!\*\/).)*\*\//m, Comment::Multiline
+      end
+
+      state :number do
+        rule %r/([0-9]+[sw])?0[oO][0-7_]+/, Num
+        rule %r/([0-9]+[sw])?0[xX][0-9a-fA-F_]+/, Num
+        rule %r/([0-9]+[sw])?0[bB][01_]+/, Num
+        rule %r/([0-9]+[sw])?0[dD][0-9_]+/, Num
+        rule %r/([0-9]+[sw])?[0-9_]+/, Num
+      end
+
+      id = /[\p{XID_Start}_]\p{XID_Continue}*/
+      string_element  = /\\"|[^"]/x
+
+      state :root do
+        mixin :whitespace
+        mixin :comment
+
+        rule %r/#\s*#{id}/, Comment::Preproc
+        rule %r/\b(?:#{P4.keywords.join('|')})\b/, Keyword
+        rule %r/\b(?:#{P4.decls.join('|')})\b/, Keyword::Declaration
+        rule %r/\b(?:#{P4.builtins.join('|')})\b/, Name::Builtin
+        rule %r/\b#{id}_[th]\b/x, Name::Class
+        rule %r/(?:#{P4.operators.join('|')})/x, Operator
+        rule %r/[(){}\[\]<>,:;\.]/, Punctuation
+        mixin :number
+        rule %r/@#{id}/x, Name::Label
+        rule %r/#{id}/x, Text
+        rule %r/"(?: #{string_element} )*"/x, Str::String
+      end
+    end
+  end
+end