rouge 4.1.0 → 4.2.1

data/lib/rouge/lexers/php.rb

@@ -66,7 +66,7 @@ module Rouge
 
       id = /[\p{L}_][\p{L}\p{N}_]*/
       ns = /(?:#{id}\\)+/
-      id_with_ns = /(?:#{ns})?#{id}/
+      id_with_ns = /\\?(?:#{ns})?#{id}/
 
       start do
         case @start_inline
@@ -273,7 +273,7 @@ module Rouge
       state :in_catch do
         rule %r/\(/, Punctuation
         rule %r/\|/, Operator
-        rule id, Name::Class
+        rule id_with_ns, Name::Class
         mixin :escape
         mixin :whitespace
         mixin :return

data/lib/rouge/lexers/plsql.rb

@@ -472,7 +472,7 @@ module Rouge
         # A double-quoted string refers to a database object in our default SQL
         rule %r/"/, Operator, :double_string
         # preprocessor directive treated as special comment
-        rule %r/(\$(?:IF|THEN|ELSE|ELSIF|ERROR|END|(?:\$\$?\w[\w\d]*)))(\s+)/im do
+        rule %r/(\$(?:IF|THEN|ELSE|ELSIF|ERROR|END|(?:\$\$?[a-z]\w*)))(\s+)/im do
           groups Comment::Preproc, Text
         end
 
@@ -503,7 +503,7 @@ module Rouge
         # Special processing for keywords with multiple contexts
         #
         # this madness is to keep the word "replace" from being treated as a builtin function in this context
-        rule %r/(create)(\s+)(?:(or)(\s+)(replace)(\s+))?(package|function|procedure|type)(?:(\s+)(body))?(\s+)(\w[\w\d\$]*)/im do
+        rule %r/(create)(\s+)(?:(or)(\s+)(replace)(\s+))?(package|function|procedure|type)(?:(\s+)(body))?(\s+)([a-z][\w$]*)/im do
           groups Keyword::Reserved, Text, Keyword::Reserved, Text, Keyword::Reserved, Text, Keyword::Reserved, Text, Keyword::Reserved, Text, Name
         end
         # similar for MERGE keywords
@@ -515,7 +515,7 @@ module Rouge
         # General keyword classification with sepcial attention to names
         # in a chained "dot" notation.
         #
-        rule %r/(\w[\w\d\$]*)(\.(?=\w))?/ do |m|
+        rule %r/([a-zA-Z][\w$]*)(\.(?=\w))?/ do |m|
           if self.class.keywords_type.include? m[1].upcase
             tok = Keyword::Type 
           elsif self.class.keywords_func.include? m[1].upcase
@@ -556,11 +556,11 @@ module Rouge
 
       state :dotnames do
         # if we are followed by a dot and another name, we are an ordinary name
-        rule %r/(\w[\w\d\$]*)(\.(?=\w))/ do
+        rule %r/([a-zA-Z][\w\$]*)(\.(?=\w))/ do
           groups Name, Punctuation
         end
         # this rule WILL be true if something pushed into our state. That is our state contract
-        rule %r/\w[\w\d\$]*/ do |m|
+        rule %r/[a-zA-Z][\w\$]*/ do |m|
           if self.class.keywords_func.include? m[0].upcase
             # The Function lookup allows collection methods like COUNT, FIRST, LAST, etc.. to be 
             # classified correctly. Occasionally misidentifies ordinary names as builtin functions,

data/lib/rouge/lexers/python.rb

@@ -8,8 +8,8 @@ module Rouge
       desc "The Python programming language (python.org)"
       tag 'python'
       aliases 'py'
-      filenames '*.py', '*.pyw', '*.sc', 'SConstruct', 'SConscript', '*.tac',
-                '*.bzl', 'BUCK', 'BUILD', 'BUILD.bazel', 'WORKSPACE'
+      filenames '*.py', '*.pyi', '*.pyw', '*.sc', 'SConstruct', 'SConscript',
+                '*.tac', '*.bzl', 'BUCK', 'BUILD', 'BUILD.bazel', 'WORKSPACE'
       mimetypes 'text/x-python', 'application/x-python'
 
       def self.detect?(text)
@@ -80,6 +80,8 @@ module Rouge
           groups Punctuation, Text, Str::Doc
         end
 
+        rule %r/\.\.\.\B$/, Name::Builtin::Pseudo
+
         rule %r/[^\S\n]+/, Text
         rule %r(#(.*)?\n?), Comment::Single
         rule %r/[\[\]{}:(),;.]/, Punctuation
@@ -120,7 +122,7 @@ module Rouge
         # TODO: not in python 3
         rule %r/`.*?`/, Str::Backtick
         rule %r/([rfbu]{0,2})('''|"""|['"])/i do |m|
-          groups Str::Affix, Str
+          groups Str::Affix, Str::Heredoc
           current_string.register type: m[1].downcase, delim: m[2]
           push :generic_string
         end
@@ -178,11 +180,12 @@ module Rouge
       end
 
       state :generic_string do
-        rule %r/[^'"\\{]+/, Str
+        rule %r/^\s*(>>>|\.\.\.)\B/, Generic::Prompt, :doctest
+        rule %r/[^'"\\{]+?/, Str
         rule %r/{{/, Str
 
         rule %r/'''|"""|['"]/ do |m|
-          token Str
+          token Str::Heredoc
           if current_string.delim? m[0]
             current_string.remove
             pop!
@@ -220,6 +223,17 @@ module Rouge
         rule %r/\\./, Str, :pop!
       end
 
+      state :doctest do
+        rule %r/\n\n/, Text, :pop!
+
+        rule %r/'''|"""/ do
+          token Str::Heredoc
+          pop!(2) if in_state?(:generic_string) # pop :doctest and :generic_string
+        end
+
+        mixin :root
+      end
+
       state :generic_interpol do
         rule %r/[^{}!:]+/ do |m|
           recurse m[0]

data/lib/rouge/lexers/ruby.rb

@@ -42,7 +42,7 @@ module Rouge
         rule %r/%([rqswQWxiI])?([^\w\s])/ do |m|
           open = Regexp.escape(m[2])
           close = Regexp.escape(delimiter_map[m[2]] || m[2])
-          interp = /[rQWxI]/ === m[1]
+          interp = /[rQWxI]/ === m[1] || !m[1]
           toktype = Str::Other
 
           puts "    open: #{open.inspect}" if @debug
@@ -57,7 +57,7 @@ module Rouge
           token toktype
 
           push do
-            uniq_chars = "#{open}#{close}".squeeze
+            uniq_chars = [open, close].uniq.join
             uniq_chars = '' if open == close && open == "\\#"
             rule %r/\\[##{uniq_chars}\\]/, Str::Escape
             # nesting rules only with asymmetric delimiters
@@ -188,6 +188,7 @@ module Rouge
 
         rule %r/(?:#{keywords.join('|')})(?=\W|$)/, Keyword, :expr_start
         rule %r/(?:#{keywords_pseudo.join('|')})\b/, Keyword::Pseudo, :expr_start
+        rule %r/(not|and|or)\b/, Operator::Word, :expr_start
 
         rule %r(
           (module)

data/lib/rouge/lexers/rust.rb

@@ -35,17 +35,18 @@ module Rouge
       def self.builtins
         @builtins ||= Set.new %w(
           Add BitAnd BitOr BitXor bool c_char c_double c_float char
-          c_int clock_t c_long c_longlong Cons Const Copy c_schar c_short
+          c_int clock_t c_long c_longlong Copy c_schar c_short
           c_uchar c_uint c_ulong c_ulonglong c_ushort c_void dev_t DIR
-          dirent Div Either Eq Err f32 f64 Failure FILE float fpos_t
-          i16 i32 i64 i8 isize Index ino_t int intptr_t Left mode_t Modulo Mul
-          Neg Nil None Num off_t Ok Option Ord Owned pid_t Ptr ptrdiff_t
-          Right Send Shl Shr size_t Some ssize_t str Sub Success time_t
+          dirent Div Eq Err f32 f64 FILE float fpos_t
+          i16 i32 i64 i8 isize Index ino_t int intptr_t mode_t Mul
+          Neg None off_t Ok Option Ord Owned pid_t ptrdiff_t
+          Send Shl Shr size_t Some ssize_t str Sub time_t
           u16 u32 u64 u8 usize uint uintptr_t
-          Box Vec String Gc Rc Arc
+          Box Vec String 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
+          FromIterator ToOwned ToString TryFrom TryInto
         )
       end
 

data/lib/rouge/lexers/scala.rb

@@ -13,7 +13,8 @@ module Rouge
       mimetypes 'text/x-scala', 'application/x-scala'
 
       # As documented in the ENBF section of the scala specification
-      # http://www.scala-lang.org/docu/files/ScalaReference.pdf
+      # https://scala-lang.org/files/archive/spec/2.13/13-syntax-summary.html
+      # https://en.wikipedia.org/wiki/Unicode_character_property#General_Category
       whitespace = /\p{Space}/
       letter = /[\p{L}$_]/
       upper = /[\p{Lu}$_]/
@@ -24,8 +25,10 @@ module Rouge
       # negative lookahead to filter out other classes
       op = %r(
         (?!#{whitespace}|#{letter}|#{digits}|#{parens}|#{delims})
-        [\u0020-\u007F\p{Sm}\p{So}]
+        [-!#%&*/:?@\\^\p{Sm}\p{So}]
       )x
+      # manually removed +<=>|~ from regexp because they're in property Sm
+      # pp CHRS:(0x00..0x7f).map(&:chr).grep(/\p{Sm}/)
 
       idrest = %r(#{letter}(?:#{letter}|#{digits})*(?:(?<=_)#{op}+)?)x
 

data/lib/rouge/lexers/shell.rb

@@ -9,8 +9,11 @@ module Rouge
 
       tag 'shell'
       aliases 'bash', 'zsh', 'ksh', 'sh'
-      filenames '*.sh', '*.bash', '*.zsh', '*.ksh', '.bashrc', '.zshrc',
-                '.kshrc', '.profile', 'APKBUILD', 'PKGBUILD', '*.ebuild',
+      filenames '*.sh', '*.bash', '*.zsh', '*.ksh', '.bashrc',
+                '.kshrc', '.profile',
+                '.zshenv', '.zprofile', '.zshrc', '.zlogin', '.zlogout',
+                'zshenv',  'zprofile',  'zshrc',  'zlogin',  'zlogout',
+                'APKBUILD', 'PKGBUILD', '*.ebuild',
                 '*.eclass', '*.exheres-0', '*.exlib'
 
       mimetypes 'application/x-sh', 'application/x-shellscript', 'text/x-sh',
@@ -18,6 +21,7 @@ module Rouge
 
       def self.detect?(text)
         return true if text.shebang?(/(ba|z|k)?sh/)
+        return true if text.start_with?('#compdef', '#autoload')
       end
 
       KEYWORDS = %w(

data/lib/rouge/lexers/sql.rb

@@ -115,7 +115,7 @@ module Rouge
         rule %r/"/, Name::Variable, :double_string
         rule %r/`/, Name::Variable, :backtick
 
-        rule %r/\w[\w\d]*/ do |m|
+        rule %r/\w+/ do |m|
           if self.class.keywords_type.include? m[0].upcase
             token Name::Builtin
           elsif self.class.keywords.include? m[0].upcase

data/lib/rouge/lexers/svelte.rb

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'html.rb'
+
+    class Svelte < HTML
+      desc 'Svelte single-file components (https://svelte.dev/)'
+      tag 'svelte'
+      filenames '*.svelte'
+      mimetypes 'text/x-svelte', 'application/x-svelte'
+
+      def initialize(*)
+        super
+        # todo add support for typescript script blocks
+        @js = Javascript.new(options)
+      end
+
+      # Shorthand syntax for passing attributes - ex, `{src}` instead of `src={src}`
+      prepend :tag do
+        rule %r/(\{)\s*([a-zA-Z0-9_]+)\s*(})/m do
+          groups Str::Interpol, Name::Variable, Str::Interpol
+          pop!
+        end
+      end
+
+      prepend :attr do
+        # Duplicate template_start mixin here with a pop!
+        # Because otherwise we'll never exit the attr state
+        rule %r/\{/ do
+          token Str::Interpol
+          pop!
+          push :template
+        end
+      end
+
+      # handle templates within attribute single/double quotes
+      prepend :dq do
+        mixin :template_start
+      end
+
+      prepend :sq do
+        mixin :template_start
+      end
+
+      prepend :root do
+        # detect curly braces within HTML text (outside of tags/attributes)
+        rule %r/([^<&{]*)(\{)(\s*)/ do
+          groups Text, Str::Interpol, Text
+          push :template
+        end
+      end
+
+      state :template_start do
+        # open template
+        rule %r/\s*\{\s*/, Str::Interpol, :template
+      end
+
+      state :template do
+        # template end
+        rule %r/}/, Str::Interpol, :pop!
+
+        # Allow JS lexer to handle matched curly braces within template
+        rule(/(?<=^|[^\\])\{.*?(?<=^|[^\\])\}/) do
+          delegate @js
+        end
+
+        # keywords
+        rule %r/@(debug|html)\b/, Keyword
+        rule %r/(#await)(.*)(then|catch)(\s+)(\w+)/ do |m|
+          token Keyword, m[1]
+          delegate @js, m[2]
+          token Keyword, m[3]
+          token Text, m[4]
+          delegate @js, m[5]
+        end
+        rule %r/([#\/])(await|each|if|key)\b/, Keyword
+        rule %r/(:else)(\s+)(if)?\b/ do
+          groups Keyword, Text, Keyword
+        end
+        rule %r/:?(catch|then)\b/, Keyword
+
+        # allow JS parser to handle anything that's not a curly brace
+        rule %r/[^{}]+/ do
+          delegate @js
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/swift.rb

@@ -15,28 +15,29 @@ module Rouge
       id = /#{id_head}#{id_rest}*/
 
       keywords = Set.new %w(
-        await break case continue default do else fallthrough if in for return switch where while try catch throw guard defer repeat
+        autoreleasepool await break case catch consume continue default defer discard do each else fallthrough guard if in for repeat return switch throw try where while
 
-        as dynamicType is new super self Self Type __COLUMN__ __FILE__ __FUNCTION__ __LINE__
+        as dynamicType is new super self Self Type
 
-        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
+        associativity async didSet get infix inout isolated left mutating none nonmutating operator override postfix precedence precedencegroup prefix rethrows right set throws unowned weak willSet
       )
 
       declarations = Set.new %w(
-        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
+        actor any associatedtype borrowing class consuming deinit distributed dynamic enum convenience extension fileprivate final func import indirect init internal lazy let macro nonisolated open optional package private protocol public required some static struct subscript typealias var
       )
 
       constants = Set.new %w(
         true false nil
       )
 
-      start { push :bol }
+      start do
+        push :bol
+        @re_delim = "" # multi-line regex delimiter
+      end
 
       # beginning of line
       state :bol do
-        rule %r/#.*/, Comment::Preproc
+        rule %r/#(?![#"\/]).*/, Comment::Preproc
 
         mixin :inline_whitespace
 
@@ -69,8 +70,11 @@ module Rouge
         mixin :whitespace
         
         rule %r/\$(([1-9]\d*)?\d)/, Name::Variable
+        rule %r/\$#{id}/, Name
+        rule %r/~Copyable\b/, Keyword::Type
 
         rule %r{[()\[\]{}:;,?\\]}, Punctuation
+        rule %r{(#*)/(?!\s).*(?<![\s\\])/\1}, Str::Regex
         rule %r([-/=+*%<>!&|^.~]+), Operator
         rule %r/@?"/, Str, :dq
         rule %r/'(\\.|.)'/, Str::Char
@@ -82,6 +86,7 @@ module Rouge
         rule %r{[\d]+(?:_\d+)*}, Num::Integer
 
         rule %r/@#{id}/, Keyword::Declaration
+        rule %r/##{id}/, Keyword
 
         rule %r/(private|internal)(\([ ]*)(\w+)([ ]*\))/ do |m|
           if m[3] == 'set'
@@ -99,14 +104,6 @@ module Rouge
           end
         end
 
-        rule %r/#available\([^)]+\)/, Keyword::Declaration
-
-        rule %r/(#(?:selector|keyPath)\()([^)]+?(?:[(].*?[)])?)(\))/ do
-          groups Keyword::Declaration, Name::Function, Keyword::Declaration
-        end
-
-        rule %r/#(line|file|column|function|dsohandle)/, Keyword::Declaration
-
         rule %r/(let|var)\b(\s*)(#{id})/ do
           groups Keyword, Text, Name::Variable
         end
@@ -148,6 +145,12 @@ module Rouge
         rule %r/(`)(#{id})(`)/ do
           groups Punctuation, Name::Variable, Punctuation
         end
+
+        rule %r{(#+)/\n} do |m|
+          @re_delim = m[1]
+          token Str::Regex
+          push :re_multi
+        end
       end
 
       state :tuple do
@@ -181,6 +184,19 @@ module Rouge
         rule %r/[)]/, Punctuation, :pop!
         mixin :root
       end
+
+      state :re_multi do
+        rule %r{^\s*/#+} do |m|
+          token Str::Regex
+          if m[0].end_with?("/#{@re_delim}")
+            @re_delim = ""
+            pop!
+          end
+        end
+
+        rule %r/#.*/, Comment::Single
+        rule %r/./m, Str::Regex
+      end
     end
   end
 end

data/lib/rouge/lexers/syzlang.rb

@@ -27,7 +27,6 @@ module Rouge
 
       comment = /#.*$/
       inline_spaces = /[ \t]+/
-      eol_spaces = /[\n\r]+/
       spaces = /\s+/
 
       state :inline_break do

data/lib/rouge/lexers/terraform.rb

@@ -37,14 +37,6 @@ module Rouge
         @builtins ||= %w()
       end
 
-      prepend :hash do
-        rule %r/[.,()*]/, Punctuation
-      end
-
-      prepend :array do
-        rule %r/[.,()*]/, Punctuation
-      end
-
       state :strings do
         rule %r/\\./, Str::Escape
         rule %r/\$\{/ do

data/lib/rouge/lexers/toml.rb

@@ -20,20 +20,9 @@ module Rouge
         rule %r/(true|false)/, Keyword::Constant
 
         rule %r/(#{identifier})(\s*)(=)(\s*)(\{)/ do
-          groups Name::Namespace, Text, Operator, Text, Punctuation
+          groups Name::Property, Text, Operator, Text, Punctuation
           push :inline
         end
-
-        rule %r/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/, Literal::Date
-
-        rule %r/[+-]?\d+(?:_\d+)*\.\d+(?:_\d+)*(?:[eE][+-]?\d+(?:_\d+)*)?/, Num::Float
-        rule %r/[+-]?\d+(?:_\d+)*[eE][+-]?\d+(?:_\d+)*/, Num::Float
-        rule %r/[+-]?(?:nan|inf)/, Num::Float
-
-        rule %r/0x\h+(?:_\h+)*/, Num::Hex
-        rule %r/0o[0-7]+(?:_[0-7]+)*/, Num::Oct
-        rule %r/0b[01]+(?:_[01]+)*/, Num::Bin
-        rule %r/[+-]?\d+(?:_\d+)*/, Num::Integer
       end
 
       state :root do
@@ -59,6 +48,17 @@ module Rouge
           groups Name::Property, Text, Punctuation
         end
 
+        rule %r/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/, Literal::Date
+
+        rule %r/[+-]?\d+(?:_\d+)*\.\d+(?:_\d+)*(?:[eE][+-]?\d+(?:_\d+)*)?/, Num::Float
+        rule %r/[+-]?\d+(?:_\d+)*[eE][+-]?\d+(?:_\d+)*/, Num::Float
+        rule %r/[+-]?(?:nan|inf)/, Num::Float
+
+        rule %r/0x\h+(?:_\h+)*/, Num::Hex
+        rule %r/0o[0-7]+(?:_[0-7]+)*/, Num::Oct
+        rule %r/0b[01]+(?:_[01]+)*/, Num::Bin
+        rule %r/[+-]?\d+(?:_\d+)*/, Num::Integer
+
         rule %r/"""/, Str, :mdq
         rule %r/"/, Str, :dq
         rule %r/'''/, Str, :msq

data/lib/rouge/lexers/ttcn3.rb

@@ -46,8 +46,6 @@ module Rouge
         )
       end
 
-      # optional comment or whitespace
-      ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
       id = /[a-zA-Z_]\w*/
       digit = /\d_+\d|\d/
       bin_digit = /[01]_+[01]|[01]/

data/lib/rouge/lexers/twig.rb

@@ -16,24 +16,24 @@ module Rouge
       mimetypes 'application/x-twig', 'text/html+twig'
 
       def self.keywords
-        @@keywords ||= %w(as do extends flush from import include use else starts
-                          ends with without autoescape endautoescape block
-                          endblock embed endembed filter endfilter for endfor
-                          if endif macro endmacro sandbox endsandbox set endset
-                          spaceless endspaceless)
+        @keywords ||= %w(as do extends flush from import include use else starts
+                         ends with without autoescape endautoescape block
+                         endblock embed endembed filter endfilter for endfor
+                         if endif macro endmacro sandbox endsandbox set endset
+                         spaceless endspaceless)
       end
 
       def self.tests
-        @@tests ||= %w(constant defined divisibleby empty even iterable null odd
-                       sameas)
+        @tests ||= %w(constant defined divisibleby empty even iterable null odd
+                      sameas)
       end
 
       def self.pseudo_keywords
-        @@pseudo_keywords ||= %w(true false none)
+        @pseudo_keywords ||= %w(true false none)
       end
 
       def self.word_operators
-        @@word_operators ||= %w(b-and b-or b-xor is in and or not)
+        @word_operators ||= %w(b-and b-or b-xor is in and or not)
       end
     end
   end

data/lib/rouge/lexers/typescript.rb

@@ -10,12 +10,12 @@ module Rouge
       extend TypescriptCommon
 
       title "TypeScript"
-      desc "TypeScript, a superset of JavaScript"
+      desc "TypeScript, a superset of JavaScript (https://www.typescriptlang.org/)"
 
       tag 'typescript'
       aliases 'ts'
 
-      filenames '*.ts', '*.d.ts'
+      filenames '*.ts', '*.d.ts', '*.cts', '*.mts'
 
       mimetypes 'text/typescript'
     end

data/lib/rouge/lexers/wollok.rb

@@ -14,8 +14,6 @@ module Rouge
       entity_name = /[a-zA-Z][a-zA-Z0-9]*/
       variable_naming = /_?#{entity_name}/
 
-      entities = []
-
       state :whitespaces_and_comments do
         rule %r/\s+/m, Text::Whitespace
         rule %r(//.*$), Comment::Single
@@ -98,6 +96,12 @@ module Rouge
         rule %r/\(|\)|=/, Text
         rule %r/,/, Punctuation
       end
+
+      private
+
+      def entities
+        @entities ||= []
+      end
     end
   end
 end

data/lib/rouge/lexers/xojo.rb

@@ -12,20 +12,20 @@ module Rouge
 
       keywords = %w(
           addhandler aggregates array asc assigns attributes begin break
-          byref byval call case catch class const continue char ctype declare
+          byref byval call case catch class const continue color ctype declare
           delegate dim do downto each else elseif end enum event exception
           exit extends false finally for function global goto if
           implements inherits interface lib loop mod module
           new next nil object of optional paramarray
           private property protected public raise raiseevent rect redim
           removehandler return select shared soft static step sub super
-          then to true try until using uend uhile
+          then to true try until using var wend while
         )
 
       keywords_type = %w(
-          boolean cfstringref cgfloat cstring curency date double int8 int16
-          int32 int64 integer ostype pstring ptr short single
-          single string structure variant uinteger uint8 uint16 uint32 uint64
+          boolean byte cfstringref cgfloat cstring currency date datetime double int8 int16
+          int32 int64 integer ostype pair pstring ptr short single
+          string structure variant uinteger uint8 uint16 uint32 uint64
           ushort windowptr wstring
         )
 
@@ -37,7 +37,7 @@ module Rouge
         rule %r/\s+/, Text::Whitespace
 
         rule %r/rem\b.*?$/i, Comment::Single
-        rule %r([//'].*$), Comment::Single
+        rule %r((?://|').*$), Comment::Single
         rule %r/\#tag Note.*?\#tag EndNote/mi, Comment::Preproc
         rule %r/\s*[#].*$/x, Comment::Preproc
 

data/lib/rouge/lexers/xquery.rb

@@ -8,7 +8,7 @@ module Rouge
       title 'XQuery'
       desc 'XQuery 3.1: An XML Query Language'
       tag 'xquery'
-      filenames '*.xquery', '*.xq'
+      filenames '*.xquery', '*.xq', '*.xqm'
       mimetypes 'application/xquery'
 
       def self.keywords

data/lib/rouge/lexers/yang.rb

@@ -10,7 +10,7 @@ module Rouge
       filenames '*.yang'
       mimetypes 'application/yang'
 
-      id = /[\w_-]+(?=[^\w\-\:])\b/
+      id = /[\w-]+(?=[^\w\-\:])\b/
 
       #Keywords from RFC7950 ; oriented at BNF style
       def self.top_stmts_keywords

data/lib/rouge/tex_theme_renderer.rb

@@ -109,7 +109,7 @@ END
     end
 
     def render_blank(tok, &b)
-      out = "\\expandafter\\def#{token_name(tok)}#1{#1}"
+      "\\expandafter\\def#{token_name(tok)}#1{#1}"
     end
 
     def render_style(tok, style, &b)

data/lib/rouge/version.rb

@@ -3,6 +3,6 @@
 
 module Rouge
   def self.version
-    "4.1.0"
+    "4.2.1"
   end
 end