rouge 3.24.0 → 3.27.0

data/lib/rouge/lexers/perl.rb

@@ -110,9 +110,10 @@ module Rouge
 
         rule %r/(__(END|DATA)__)\b/, Comment::Preproc, :end_part
         rule %r/\$\^[ADEFHILMOPSTWX]/, Name::Variable::Global
-        rule %r/\$[\\"'\[\]&`+*.,;=%~?@$!<>(^\|\/-](?!\w)/, Name::Variable::Global
+        rule %r/\$[\\"'\[\]&`+*.,;=%~?@$!<>(^\|\/_-](?!\w)/, Name::Variable::Global
+        rule %r/[$@%&*][$@%&*#_]*(?=[a-z{\[;])/i, Name::Variable, :varname
+
         rule %r/[-+\/*%=<>&^\|!\\~]=?/, Operator
-        rule %r/[$@%#]+/, Name::Variable, :varname
 
         rule %r/0_?[0-7]+(_[0-7]+)*/, Num::Oct
         rule %r/0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*/, Num::Hex
@@ -159,8 +160,9 @@ module Rouge
 
       state :varname do
         rule %r/\s+/, Text
-        rule %r/\{/, Punctuation, :pop! # hash syntax
-        rule %r/\)|,/, Punctuation, :pop! # arg specifier
+        rule %r/[{\[]/, Punctuation, :pop! # hash syntax
+        rule %r/[),]/, Punctuation, :pop! # arg specifier
+        rule %r/[;]/, Punctuation, :pop! # postfix
         mixin :name_common
       end
 

data/lib/rouge/lexers/powershell.rb

@@ -131,34 +131,50 @@ module Rouge
         rule %r/[:,]/, Punctuation
       end
 
-      state :hasht do
-        rule %r/\s+/, Text::Whitespace
-        rule %r/\}/, Punctuation, :pop!
+      state :expr do
+        mixin :comments
         rule %r/"/, Str::Double, :dq
         rule %r/'/, Str::Single, :sq
-        rule %r/\w+/, Name::Other
+        rule %r/@"/, Str::Heredoc, :heredoc
+        rule %r/@'.*?'@/m, Str::Heredoc
+        rule %r/\d*\.\d+/, Num::Float
+        rule %r/\d+/, Num::Integer
+        rule %r/@\{/, Punctuation, :hasht
+        rule %r/@\(/, Punctuation, :array
+        rule %r/{/, Punctuation, :brace
+        rule %r/\[/, Punctuation, :bracket
+      end
+
+      state :hasht do
+        rule %r/\}/, Punctuation, :pop!
         rule %r/=/, Operator
-        rule %r/,/, Punctuation
+        rule %r/[,;]/, Punctuation
+        mixin :expr
+        rule %r/\w+/, Name::Other
         mixin :variable
       end
 
       state :array do
         rule %r/\s+/, Text::Whitespace
         rule %r/\)/, Punctuation, :pop!
-        rule %r/"/, Str::Double, :dq
-        rule %r/'/, Str::Single, :sq
-        rule %r/,/, Punctuation
+        rule %r/[,;]/, Punctuation
+        mixin :expr
         mixin :variable
       end
 
+      state :brace do
+        rule %r/[}]/, Punctuation, :pop!
+        mixin :root
+      end
+
       state :bracket do
         rule %r/\]/, Punctuation, :pop!
-        rule %r/[A-Za-z]\w+\./, Name::Constant
+        rule %r/[A-Za-z]\w+\./, Name
         rule %r/([A-Za-z]\w+)/ do |m|
           if ATTRIBUTES.include? m[0]
             token Name::Builtin::Pseudo
           else
-            token Keyword::Type
+            token Name
           end
         end
         mixin :root
@@ -174,20 +190,15 @@ module Rouge
         mixin :root
       end
 
-      state :root do
+      state :comments do
         rule %r/\s+/, Text::Whitespace
-
-        rule %r/#requires\s-version \d(?:\.\d+)?/, Comment::Preproc
         rule %r/#.*/, Comment
         rule %r/<#/, Comment::Multiline, :multiline
+      end
 
-        rule %r/"/, Str::Double, :dq
-        rule %r/'/, Str::Single, :sq
-        rule %r/@"/, Str::Heredoc, :heredoc
-        rule %r/@'.*?'@/m, Str::Heredoc
-
-        rule %r/\d*\.\d+/, Num::Float
-        rule %r/\d+/, Num::Integer
+      state :root do
+        mixin :comments
+        rule %r/#requires\s-version \d(?:\.\d+)?/, Comment::Preproc
 
         rule %r/\.\.(?=\.?\d)/, Operator
         rule %r/(?:#{OPERATORS})\b/i, Operator
@@ -204,28 +215,27 @@ module Rouge
         rule %r/-{1,2}\w+/, Name::Tag
 
         rule %r/(\.)?([-\w]+)(\[)/ do |m|
-          groups Operator, Name::Function, Punctuation
+          groups Operator, Name, Punctuation
           push :bracket
         end
 
-        rule %r/([\/\\~\w][-.:\/\\~\w]*)(\n)?/ do |m|
-          groups Name::Function, Text::Whitespace
+        rule %r/([\/\\~[a-z]][-.:\/\\~\w]*)(\n)?/i do |m|
+          groups Name, Text::Whitespace
           push :parameters
         end
 
-        rule %r/(\.)?([-\w]+)(?:(\()|(\n))?/ do |m|
+        rule %r/(\.)([-\w]+)(?:(\()|(\n))?/ do |m|
           groups Operator, Name::Function, Punctuation, Text::Whitespace
           push :parameters unless m[3].nil?
         end
 
         rule %r/\?/, Name::Function, :parameters
-        rule %r/[-+*\/%=!.&|]/, Operator
-        rule %r/@\{/, Punctuation, :hasht
-        rule %r/@\(/, Punctuation, :array
-        rule %r/\[/, Punctuation, :bracket
-        rule %r/[{}(),:;]/, Punctuation
 
+        mixin :expr
         mixin :variable
+
+        rule %r/[-+*\/%=!.&|]/, Operator
+        rule %r/[{}(),:;]/, Punctuation
       end
     end
   end

data/lib/rouge/lexers/python.rb

@@ -115,7 +115,7 @@ module Rouge
         # TODO: not in python 3
         rule %r/`.*?`/, Str::Backtick
         rule %r/([rfbu]{0,2})('''|"""|['"])/i do |m|
-          token Str
+          groups Str::Affix, Str
           current_string.register type: m[1].downcase, delim: m[2]
           push :generic_string
         end

data/lib/rouge/lexers/reasonml.rb

@@ -24,7 +24,8 @@ module Rouge
         rule %r/#{@@upper_id}(?=\s*[.])/, Name::Namespace, :dotted
         rule %r/`#{@@id}/, Name::Tag
         rule @@upper_id, Name::Class
-        rule %r/[\/][*](?![\/])/, Comment, :comment
+        rule %r(//.*), Comment::Single
+        rule %r(/\*), Comment::Multiline, :comment
         rule @@id do |m|
           match = m[0]
           if self.class.keywords.include? match
@@ -55,10 +56,10 @@ module Rouge
       end
 
       state :comment do
-        rule %r|[^/*)]+|, Comment
-        rule %r|[/][*]|, Comment, :push
-        rule %r|[*][/]|, Comment, :pop!
-        rule %r|[*/]|, Comment
+        rule %r([^/*]+), Comment::Multiline
+        rule %r(/\*), Comment::Multiline, :comment
+        rule %r(\*/), Comment::Multiline, :pop!
+        rule %r([*/]), Comment::Multiline
       end
     end
   end

data/lib/rouge/lexers/rescript.rb

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'ocaml/common.rb'
+
+    class ReScript < OCamlCommon
+      title "ReScript"
+      desc "The ReScript programming language (rescript-lang.org)"
+      tag 'rescript'
+      filenames '*.res', '*.resi'
+      mimetypes 'text/x-rescript'
+
+      def self.keywords
+        @keywords ||= Set.new(%w(
+          open let rec and as exception assert lazy if else
+          for in to downto while switch when external type private
+          mutable constraint include module of with try import export
+        ))
+      end
+
+      def self.types
+        @types ||= Set.new(%w(
+          bool int float char string
+          unit list array option ref exn format
+        ))
+      end
+
+      def self.word_operators
+        @word_operators ||= Set.new(%w(mod land lor lxor lsl lsr asr or))
+      end
+
+      state :root do
+        rule %r/\s+/m, Text
+        rule %r([,.:?~\\]), Text
+
+        # Boolean Literal
+        rule %r/\btrue|false\b/, Keyword::Constant
+
+        # Module chain
+        rule %r/#{@@upper_id}(?=\s*[.])/, Name::Namespace, :dotted
+
+        # Decorator
+        rule %r/@#{@@id}(\.#{@@id})*/, Name::Decorator
+
+        # Poly variant
+        rule %r/\##{@@id}/, Name::Class
+
+        # Variant or Module
+        rule @@upper_id, Name::Class
+
+        # Comments
+        rule %r(//.*), Comment::Single
+        rule %r(/\*), Comment::Multiline, :comment
+
+        # Keywords and identifiers
+        rule @@id do |m|
+          match = m[0]
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.word_operators.include? match
+            token Operator::Word
+          elsif self.class.types.include? match
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+
+        # Braces
+        rule %r/[(){}\[\];]+/, Punctuation
+
+        # Operators
+        rule %r([;_!$%&*+/<=>@^|-]+), Operator
+
+        # Numbers
+        rule %r/-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
+        rule %r/0x\h[\h_]*/i, Num::Hex
+        rule %r/0o[0-7][0-7_]*/i, Num::Oct
+        rule %r/0b[01][01_]*/i, Num::Bin
+        rule %r/\d[\d_]*/, Num::Integer
+
+        # String and Char
+        rule %r/'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, Str::Char
+        rule %r/'[^'\/]'/, Str::Char
+        rule %r/'/, Keyword
+        rule %r/"/, Str::Double, :string
+
+        # Interpolated string
+        rule %r/`/ do
+          token Str::Double
+          push :interpolated_string
+        end
+      end
+
+      state :comment do
+        rule %r([^/\*]+), Comment::Multiline
+        rule %r(/\*), Comment::Multiline, :comment
+        rule %r(\*/), Comment::Multiline, :pop!
+        rule %r([*/]), Comment::Multiline
+      end
+
+      state :interpolated_string do
+        rule %r/[$]{/, Punctuation, :interpolated_expression
+        rule %r/`/, Str::Double, :pop!
+        rule %r/\\[$`]/, Str::Escape
+        rule %r/[^$`\\]+/, Str::Double
+        rule %r/[\\$]/, Str::Double
+      end
+
+      state :interpolated_expression do
+        rule %r/}/, Punctuation, :pop!
+        mixin :root
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/ruby.rb

@@ -90,7 +90,7 @@ module Rouge
       end
 
       state :regex_flags do
-        rule %r/[mixounse]+/, Str::Regex, :pop!
+        rule %r/[mixounse]*/, Str::Regex, :pop!
       end
 
       # double-quoted string and symbol
@@ -267,7 +267,7 @@ module Rouge
       end
 
       state :test_heredoc do
-        rule %r/[^#\\\n]+$/ do |m|
+        rule %r/[^#\\\n]*$/ do |m|
           tolerant, heredoc_name = @heredoc_queue.first
           check = tolerant ? m[0].strip : m[0].rstrip
 

data/lib/rouge/lexers/rust.rb

@@ -22,10 +22,10 @@ module Rouge
 
       def self.keywords
         @keywords ||= %w(
-          as assert async await break const copy do drop else enum extern fail false
-          fn for if impl let log loop match mod move mut priv pub pure
-          ref return self static struct true trait type unsafe use where
-          while box
+          as assert async await break crate const continue copy do drop dyn else enum extern
+          fail false fn for if impl let log loop macro match mod move mut priv pub pure
+          ref return self Self static struct super true try trait type union unsafe use
+          where while yield box
         )
       end
 
@@ -40,6 +40,9 @@ module Rouge
           Right Send Shl Shr size_t Some ssize_t str Sub Success time_t
           u16 u32 u64 u8 usize uint uintptr_t
           Box Vec String Gc Rc Arc
+          u128 i128 Result Sync Pin Unpin Sized Drop drop Fn FnMut FnOnce
+          Clone PartialEq PartialOrd AsMut AsRef From Into Default
+          DoubleEndedIterator ExactSizeIterator Extend IntoIterator Iterator
         )
       end
 
@@ -54,12 +57,12 @@ module Rouge
 
       delim_map = { '[' => ']', '(' => ')', '{' => '}' }
 
-      id = /[a-z_]\w*/i
+      id = /[\p{XID_Start}_]\p{XID_Continue}*/
       hex = /[0-9a-f]/i
       escapes = %r(
-        \\ ([nrt'"\\0] | x#{hex}{2} | u#{hex}{4} | U#{hex}{8})
+        \\ ([nrt'"\\0] | x#{hex}{2} | u\{(#{hex}_*){1,6}\})
       )x
-      size = /8|16|32|64/
+      size = /8|16|32|64|128|size/
 
       # Although not officially part of Rust, the rustdoc tool allows code in
       # comments to begin with `#`. Code like this will be evaluated but not
@@ -82,8 +85,62 @@ module Rouge
 
       state :whitespace do
         rule %r/\s+/, Text
-        rule %r(//[^\n]*), Comment
-        rule %r(/[*].*?[*]/)m, Comment::Multiline
+        mixin :comments
+      end
+
+      state :comments do
+        # Only 3 slashes are doc comments, `////` and beyond become normal
+        # comments again (for some reason), so match this before the
+        # doc line comments rather than figure out a
+        rule %r(////+[^\n]*), Comment::Single
+        # doc line comments — either inner (`//!`), or outer (`///`).
+        rule %r(//[/!][^\n]*), Comment::Doc
+        # otherwise, `//` is just a plain line comme
+        rule %r(//[^\n]*), Comment::Single
+        # /**/ and /***/ are self-closing block comments, not doc. Because this
+        # is self-closing, it doesn't enter the states for nested comments
+        rule %r(/\*\*\*?/), Comment::Multiline
+        # 3+ stars and it's a normal non-doc block comment.
+        rule %r(/\*\*\*+), Comment::Multiline, :nested_plain_block
+        # `/*!` and `/**` begin doc comments. These nest and can have internal
+        # block/doc comments, but they're still part of the documentation
+        # inside.
+        rule %r(/[*][*!]), Comment::Doc, :nested_doc_block
+        # any other /* is a plain multiline comment
+        rule %r(/[*]), Comment::Multiline, :nested_plain_block
+      end
+
+      # Multiline/block comments fully nest. This is true for ones that are
+      # marked as documentation too. The behavior here is:
+      #
+      # - Anything inside a block doc comment is still included in the
+      #   documentation, even if it's a nested non-doc block comment. For
+      #   example: `/** /* still docs */ */`
+      # - Anything inside of a block non-doc comment is still just a normal
+      #   comment, even if it's a nested block documentation comment. For
+      #   example: `/* /** not docs */ */`
+      #
+      # This basically means: if (on the outermost level) the comment starts as
+      # one kind of block comment (either doc/non-doc), then everything inside
+      # of it, including nested block comments of the opposite type, needs to
+      # stay that type.
+      #
+      # Also note that single line comments do nothing anywhere inside of block
+      # comments, thankfully.
+      #
+      # We just define this as two states, because this seems easier than
+      # tracking it with instance vars.
+      [
+        [:nested_plain_block, Comment::Multiline],
+        [:nested_doc_block, Comment::Doc]
+      ].each do |state_name, comment_token|
+        state state_name do
+          rule %r(\*/), comment_token, :pop!
+          rule %r(/\*), comment_token, state_name
+          # We only want to eat at most one `[*/]` at a time,
+          # but we can skip past non-`[*/]` in bulk.
+          rule %r([^*/]+|[*/]), comment_token
+        end
       end
 
       state :root do
@@ -110,6 +167,7 @@ module Rouge
         rule %r/\bmacro_rules!/, Name::Decorator, :macro_rules
         rule %r/#{id}!/, Name::Decorator, :macro
 
+        rule %r/'static\b/, Keyword
         rule %r/'#{id}/, Name::Variable
         rule %r/#{id}/ do |m|
           name = m[0]
@@ -155,31 +213,33 @@ module Rouge
       state :has_literals do
         # constants
         rule %r/\b(?:true|false|nil)\b/, Keyword::Constant
-        # characters
+        # characters/bytes
         rule %r(
-          ' (?: #{escapes} | [^\\] ) '
+          b?' (?: #{escapes} | [^\\] ) '
         )x, Str::Char
 
-        rule %r/"/, Str, :string
-        rule %r/r(#*)".*?"\1/m, Str
+        rule %r/b?"/, Str, :string
+        rule %r/b?r(#*)".*?"\1/m, Str
 
         # numbers
-        dot = /[.][0-9_]+/
-        exp = /e[-+]?[0-9_]+/
+        dot = /[.][0-9][0-9_]*/
+        exp = /[eE][-+]?[0-9_]+/
         flt = /f32|f64/
 
         rule %r(
-          [0-9_]+
+          [0-9][0-9_]*
           (#{dot}  #{exp}? #{flt}?
           |#{dot}? #{exp}  #{flt}?
           |#{dot}? #{exp}? #{flt}
+          |[.](?![._\p{XID_Start}])
           )
         )x, Num::Float
 
         rule %r(
           ( 0b[10_]+
           | 0x[0-9a-fA-F_]+
-          | [0-9_]+
+          | 0o[0-7_]+
+          | [0-9][0-9_]*
           ) (u#{size}?|i#{size})?
         )x, Num::Integer
 

data/lib/rouge/lexers/sql.rb

@@ -38,8 +38,8 @@ module Rouge
           DYNAMIC DYNAMIC_FUNCTION DYNAMIC_FUNCTION_CODE EACH ELSE
           ENCODING ENCRYPTED END END-EXEC EQUALS ESCAPE EVERY EXCEPT
           ESCEPTION EXCLUDING EXCLUSIVE EXEC EXECUTE EXISTING EXISTS
-          EXPLAIN EXTERNAL EXTRACT FALSE FETCH FINAL FIRST FOR FORCE
-          FOREIGN FORTRAN FORWARD FOUND FREE FREEZE FROM FULL FUNCTION
+          EXPLAIN EXTERNAL EXTRACT FALSE FETCH FINAL FIRST FOLLOWING FOR
+          FORCE FOREIGN FORTRAN FORWARD FOUND FREE FREEZE FROM FULL FUNCTION
           G GENERAL GENERATED GET GLOBAL GO GOTO GRANT GRANTED GROUP
           GROUPING HANDLER HAVING HIERARCHY HOLD HOST IDENTITY IGNORE
           ILIKE IMMEDIATE IMMUTABLE IMPLEMENTATION IMPLICIT IN INCLUDING
@@ -58,10 +58,10 @@ module Rouge
           ORDINALITY OUT OUTER OUTPUT OVERLAPS OVERLAY OVERRIDING
           OWNER PAD PARAMETER PARAMETERS PARAMETER_MODE PARAMATER_NAME
           PARAMATER_ORDINAL_POSITION PARAMETER_SPECIFIC_CATALOG
-          PARAMETER_SPECIFIC_NAME PARAMATER_SPECIFIC_SCHEMA PARTIAL PASCAL
-          PENDANT PLACING PLI POSITION POSTFIX PREFIX PREORDER
+          PARAMETER_SPECIFIC_NAME PARAMATER_SPECIFIC_SCHEMA PARTIAL PARTITION
+          PASCAL PENDANT PLACING PLI POSITION POSTFIX PREFIX PRECEDING PREORDER
           PREPARE PRESERVE PRIMARY PRIOR PRIVILEGES PROCEDURAL PROCEDURE
-          PUBLIC READ READS RECHECK RECURSIVE REF REFERENCES REFERENCING
+          PUBLIC RANGE READ READS RECHECK RECURSIVE REF REFERENCES REFERENCING
           REINDEX RELATIVE RENAME REPEATABLE REPLACE RESET RESTART
           RESTRICT RESULT RETURN RETURNED_LENGTH RETURNED_OCTET_LENGTH
           RETURNED_SQLSTATE RETURNS REVOKE RIGHT ROLE ROLLBACK ROLLUP
@@ -84,7 +84,7 @@ module Rouge
           USAGE USER USER_DEFINED_TYPE_CATALOG USER_DEFINED_TYPE_NAME
           USER_DEFINED_TYPE_SCHEMA USING VACUUM VALID VALIDATOR VALUES
           VARIABLE VERBOSE VERSION VIEW VOLATILE WHEN WHENEVER WHERE
-          WITH WITHOUT WORK WRITE ZONE
+          WINDOW WITH WITHOUT WORK WRITE ZONE
         )
       end
 
@@ -126,7 +126,7 @@ module Rouge
         end
 
         rule %r([+*/<>=~!@#%&|?^-]), Operator
-        rule %r/[;:()\[\],.]/, Punctuation
+        rule %r/[;:()\[\]\{\},.]/, Punctuation
       end
 
       state :multiline_comments do

data/lib/rouge/lexers/swift.rb

@@ -15,17 +15,17 @@ module Rouge
       id = /#{id_head}#{id_rest}*/
 
       keywords = Set.new %w(
-        break case continue default do else fallthrough if in for return switch where while try catch throw guard defer repeat
+        await break case continue default do else fallthrough if in for return switch where while try catch throw guard defer repeat
 
         as dynamicType is new super self Self Type __COLUMN__ __FILE__ __FUNCTION__ __LINE__
 
-        associativity didSet get infix inout mutating none nonmutating operator override postfix precedence prefix set unowned weak willSet throws rethrows precedencegroup
+        associativity async didSet get infix inout isolated mutating none nonmutating operator override postfix precedence prefix set unowned weak willSet throws rethrows precedencegroup
 
         #available #colorLiteral #column #else #elseif #endif #error #file #fileLiteral #function #if #imageLiteral #line #selector #sourceLocation #warning
       )
 
       declarations = Set.new %w(
-        class deinit enum convenience extension final func import init internal lazy let optional private protocol public required static struct subscript typealias var dynamic indirect associatedtype open fileprivate some
+        actor class deinit enum convenience extension final func import init internal lazy let nonisolated optional private protocol public required static struct subscript typealias var dynamic indirect associatedtype open fileprivate some
       )
 
       constants = Set.new %w(

data/lib/rouge/lexers/velocity.rb

@@ -63,7 +63,7 @@ module Rouge
         rule %r/0[xX][0-9a-fA-F]+[Ll]?/, Num::Hex
         rule %r/\b[0-9]+\b/, Num::Integer
         rule %r/(true|false|null)\b/, Keyword::Constant
-        rule %r/[(\[]/, Punctuation, :push!
+        rule %r/[(\[]/, Punctuation, :push
         rule %r/[)\]}]/, Punctuation, :pop!
       end
     end

data/lib/rouge/lexers/yaml.rb

@@ -175,7 +175,7 @@ module Rouge
 
       state :block_nodes do
         # implicit key
-        rule %r/((?:[\p{L}\p{Nl}\p{Nd}_][\p{L}\p{Nl}\p{Nd}\p{Blank}_-]*)?)(:)(?=\s|$)/ do |m|
+        rule %r/([^#,:?\[\]{}"'\n]+)(:)(?=\s|$)/ do |m|
           groups Name::Attribute, Punctuation::Indicator
           set_indent m[0], :implicit => true
         end

data/lib/rouge/themes/base16.rb

@@ -67,6 +67,7 @@ module Rouge
       style Keyword::Declaration, :fg => :base09
 
       style Literal::String, :fg => :base0B
+      style Literal::String::Affix, :fg => :base0E
       style Literal::String::Regex, :fg => :base0C
 
       style Literal::String::Interpol,

data/lib/rouge/themes/bw.rb

@@ -26,6 +26,7 @@ module Rouge
       style Name::Tag,                   :bold => true
 
       style Literal::String,             :italic => true
+      style Literal::String::Affix,      :bold => true
       style Literal::String::Interpol,   :bold => true
       style Literal::String::Escape,     :bold => true
 

data/lib/rouge/themes/colorful.rb

@@ -37,6 +37,7 @@ module Rouge
       style Name::Decorator,             :fg => "#555", :bold => true
 
       style Literal::String,             :bg => "#fff0f0"
+      style Literal::String::Affix,      :fg => "#080", :bold => true
       style Literal::String::Char,       :fg => "#04D"
       style Literal::String::Doc,        :fg => "#D42"
       style Literal::String::Interpol,   :bg => "#eee"

data/lib/rouge/themes/github.rb

@@ -35,6 +35,7 @@ module Rouge
       style Literal::Number::Integer,         :fg => '#009999'
       style Literal::Number::Oct,             :fg => '#009999'
       style Literal::Number,                  :fg => '#009999'
+      style Literal::String::Affix,           :fg => '#000000', :bold => true
       style Literal::String::Backtick,        :fg => '#d14'
       style Literal::String::Char,            :fg => '#d14'
       style Literal::String::Doc,             :fg => '#d14'

data/lib/rouge/themes/gruvbox.rb

@@ -150,6 +150,8 @@ module Rouge
             Literal::String::Interpol,
             Literal::String::Regex, :fg => :green, :italic => true
 
+      style Literal::String::Affix, :fg => :red
+
       style Literal::String::Escape, :fg => :orange
 
       style Name::Namespace,

data/lib/rouge/themes/igor_pro.rb

@@ -15,6 +15,7 @@ module Rouge
       style Keyword::Reserved,                :fg => '#007575'
       style Keyword,                          :fg => '#0000FF'
       style Literal::String,                  :fg => '#009C00'
+      style Literal::String::Affix,           :fg => '#0000FF'
       style Name::Builtin,                    :fg => '#C34E00'
     end
   end

data/lib/rouge/themes/magritte.rb

@@ -62,6 +62,7 @@ module Rouge
             Literal::Date,                :fg => :forest, :bold => true
       style Literal::String::Symbol,      :fg => :forest
       style Literal::String,              :fg => :wine, :bold => true
+      style Literal::String::Affix,       :fg => :royal, :bold => true
       style Literal::String::Escape,
             Literal::String::Char,
             Literal::String::Interpol,    :fg => :purple, :bold => true

data/lib/rouge/themes/monokai.rb

@@ -59,6 +59,7 @@ module Rouge
             Literal::Number::Oct,
             Literal::Number,
             Literal::String::Escape,          :fg => :light_violet
+      style Literal::String::Affix,           :fg => :soft_cyan, :bold => true
       style Literal::String::Backtick,
             Literal::String::Char,
             Literal::String::Doc,

data/lib/rouge/themes/pastie.rb

@@ -36,6 +36,7 @@ module Rouge
       style Num,                       :fg => '#0000dd', :bold => true
 
       style Str,                       :fg => '#dd2200', :bg => '#fff0f0'
+      style Str::Affix,                :fg => '#008800', :bold => true
       style Str::Escape,               :fg => '#0044dd', :bg => '#fff0f0'
       style Str::Interpol,             :fg => '#3333bb', :bg => '#fff0f0'
       style Str::Other,                :fg => '#22bb22', :bg => '#f0fff0'

data/lib/rouge/themes/thankful_eyes.rb

@@ -59,6 +59,7 @@ module Rouge
             Literal::Date,
             Literal::String::Symbol, :fg => :pink_merengue, :bold => true
       style Literal::String, :fg => :dune, :bold => true
+      style Literal::String::Affix, :fg => :sandy, :bold => true
       style Literal::String::Escape,
             Literal::String::Char,
             Literal::String::Interpol, :fg => :backlit, :bold => true

data/lib/rouge/themes/tulip.rb

@@ -55,6 +55,7 @@ module Rouge
             Literal::Date,
             Literal::String::Symbol, :fg => :lpurple, :bold => true
       style Literal::String, :fg => :dune, :bold => true
+      style Literal::String::Affix, :fg => :yellow, :bold => true
       style Literal::String::Escape,
             Literal::String::Char,
             Literal::String::Interpol, :fg => :orange, :bold => true