pygments.rb 2.3.1 → 2.4.0

data/vendor/pygments-main/pygments/lexers/ruby.py

@@ -4,22 +4,20 @@
 
     Lexers for Ruby and related languages.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 import re
 
 from pygments.lexer import Lexer, RegexLexer, ExtendedRegexLexer, include, \
-    bygroups, default, LexerContext, do_insertions, words
+    bygroups, default, LexerContext, do_insertions, words, line_re
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Error, Generic
+    Number, Punctuation, Error, Generic, Whitespace
 from pygments.util import shebang_matches
 
 __all__ = ['RubyLexer', 'RubyConsoleLexer', 'FancyLexer']
 
-line_re = re.compile('.*?\n')
-
 
 RUBY_OPERATORS = (
     '*', '**', '-', '+', '-@', '+@', '/', '%', '&', '|', '^', '`', '~',
@@ -29,13 +27,14 @@ RUBY_OPERATORS = (
 
 class RubyLexer(ExtendedRegexLexer):
     """
-    For `Ruby <http://www.ruby-lang.org>`_ source code.
+    For Ruby source code.
     """
 
     name = 'Ruby'
+    url = 'http://www.ruby-lang.org'
     aliases = ['ruby', 'rb', 'duby']
     filenames = ['*.rb', '*.rbw', 'Rakefile', '*.rake', '*.gemspec',
-                 '*.rbx', '*.duby', 'Gemfile']
+                 '*.rbx', '*.duby', 'Gemfile', 'Vagrantfile']
     mimetypes = ['text/x-ruby', 'application/x-ruby']
 
     flags = re.DOTALL | re.MULTILINE
@@ -178,11 +177,11 @@ class RubyLexer(ExtendedRegexLexer):
             # special forms of fancy strings after operators or
             # in method calls with braces
             (r'(?<=[-+/*%=<>&!^|~,(])(\s*)(%([\t ])(?:(?:\\\3|(?!\3).)*)\3)',
-             bygroups(Text, String.Other, None)),
+             bygroups(Whitespace, String.Other, None)),
             # and because of fixed width lookbehinds the whole thing a
             # second time for line startings...
             (r'^(\s*)(%([\t ])(?:(?:\\\3|(?!\3).)*)\3)',
-             bygroups(Text, String.Other, None)),
+             bygroups(Whitespace, String.Other, None)),
             # all regular fancy strings without qsw
             (r'(%([^a-zA-Z0-9\s]))((?:\\\2|(?!\2).)*)(\2)',
              intp_string_callback),
@@ -205,10 +204,10 @@ class RubyLexer(ExtendedRegexLexer):
             # start of function, class and module names
             (r'(module)(\s+)([a-zA-Z_]\w*'
              r'(?:::[a-zA-Z_]\w*)*)',
-             bygroups(Keyword, Text, Name.Namespace)),
-            (r'(def)(\s+)', bygroups(Keyword, Text), 'funcname'),
+             bygroups(Keyword, Whitespace, Name.Namespace)),
+            (r'(def)(\s+)', bygroups(Keyword, Whitespace), 'funcname'),
             (r'def(?=[*%&^`~+-/\[<>=])', Keyword, 'funcname'),
-            (r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
+            (r'(class)(\s+)', bygroups(Keyword, Whitespace), 'classname'),
             # special methods
             (words((
                 'initialize', 'new', 'loop', 'include', 'extend', 'raise', 'attr_reader',
@@ -282,7 +281,7 @@ class RubyLexer(ExtendedRegexLexer):
             # multiline regex (in method calls or subscripts)
             (r'(?<=\(|,|\[)/', String.Regex, 'multiline-regex'),
             # multiline regex (this time the funny no whitespace rule)
-            (r'(\s+)(/)(?![\s=])', bygroups(Text, String.Regex),
+            (r'(\s+)(/)(?![\s=])', bygroups(Whitespace, String.Regex),
              'multiline-regex'),
             # lex numbers and ignore following regular expressions which
             # are division operators in fact (grrrr. i hate that. any
@@ -293,13 +292,13 @@ class RubyLexer(ExtendedRegexLexer):
             # stupid example:
             #   x>=0?n[x]:""
             (r'(0_?[0-7]+(?:_[0-7]+)*)(\s*)([/?])?',
-             bygroups(Number.Oct, Text, Operator)),
+             bygroups(Number.Oct, Whitespace, Operator)),
             (r'(0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*)(\s*)([/?])?',
-             bygroups(Number.Hex, Text, Operator)),
+             bygroups(Number.Hex, Whitespace, Operator)),
             (r'(0b[01]+(?:_[01]+)*)(\s*)([/?])?',
-             bygroups(Number.Bin, Text, Operator)),
+             bygroups(Number.Bin, Whitespace, Operator)),
             (r'([\d]+(?:_\d+)*)(\s*)([/?])?',
-             bygroups(Number.Integer, Text, Operator)),
+             bygroups(Number.Integer, Whitespace, Operator)),
             # Names
             (r'@@[a-zA-Z_]\w*', Name.Variable.Class),
             (r'@[a-zA-Z_]\w*', Name.Variable.Instance),
@@ -325,7 +324,7 @@ class RubyLexer(ExtendedRegexLexer):
              r'!~|&&?|\|\||\.{1,3})', Operator),
             (r'[-+/*%=<>&!^|~]=?', Operator),
             (r'[(){};,/?:\\]', Punctuation),
-            (r'\s+', Text)
+            (r'\s+', Whitespace)
         ],
         'funcname': [
             (r'\(', Punctuation, 'defexpr'),
@@ -439,7 +438,7 @@ class RubyConsoleLexer(Lexer):
 
 class FancyLexer(RegexLexer):
     """
-    Pygments Lexer For `Fancy <http://www.fancy-lang.org/>`_.
+    Pygments Lexer For Fancy.
 
     Fancy is a self-hosted, pure object-oriented, dynamic,
     class-based, concurrent general-purpose programming language
@@ -448,6 +447,7 @@ class FancyLexer(RegexLexer):
     .. versionadded:: 1.5
     """
     name = 'Fancy'
+    url = 'https://github.com/bakkdoor/fancy'
     filenames = ['*.fy', '*.fancypack']
     aliases = ['fancy', 'fy']
     mimetypes = ['text/x-fancysrc']
@@ -467,7 +467,7 @@ class FancyLexer(RegexLexer):
             (r'\$(\\\\|\\[^\\]|[^$\\])*\$[egimosx]*', String.Regex, '#pop'),
         ],
         'root': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
 
             # balanced delimiters (copied from PerlLexer):
             (r's\{(\\\\|\\[^\\]|[^}\\])*\}\s*', String.Regex, 'balanced-regex'),
@@ -510,13 +510,13 @@ class FancyLexer(RegexLexer):
             # numbers - / checks are necessary to avoid mismarking regexes,
             # see comment in RubyLexer
             (r'(0[oO]?[0-7]+(?:_[0-7]+)*)(\s*)([/?])?',
-             bygroups(Number.Oct, Text, Operator)),
+             bygroups(Number.Oct, Whitespace, Operator)),
             (r'(0[xX][0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*)(\s*)([/?])?',
-             bygroups(Number.Hex, Text, Operator)),
+             bygroups(Number.Hex, Whitespace, Operator)),
             (r'(0[bB][01]+(?:_[01]+)*)(\s*)([/?])?',
-             bygroups(Number.Bin, Text, Operator)),
+             bygroups(Number.Bin, Whitespace, Operator)),
             (r'([\d]+(?:_\d+)*)(\s*)([/?])?',
-             bygroups(Number.Integer, Text, Operator)),
+             bygroups(Number.Integer, Whitespace, Operator)),
             (r'\d+([eE][+-]?[0-9]+)|\d+\.\d+([eE][+-]?[0-9]+)?', Number.Float),
             (r'\d+', Number.Integer)
         ]

data/vendor/pygments-main/pygments/lexers/rust.py

@@ -4,7 +4,7 @@
 
     Lexers for the Rust language.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -22,6 +22,7 @@ class RustLexer(RegexLexer):
     .. versionadded:: 1.6
     """
     name = 'Rust'
+    url = 'https://www.rust-lang.org/'
     filenames = ['*.rs', '*.rs.in']
     aliases = ['rust', 'rs']
     mimetypes = ['text/rust', 'text/x-rust']
@@ -104,7 +105,7 @@ class RustLexer(RegexLexer):
             # Prelude (taken from Rust's src/libstd/prelude.rs)
             builtin_funcs_types,
             builtin_macros,
-            # Path seperators, so types don't catch them.
+            # Path separators, so types don't catch them.
             (r'::\b', Text),
             # Types in positions.
             (r'(?::|->)', Text, 'typename'),

data/vendor/pygments-main/pygments/lexers/sas.py

@@ -4,7 +4,7 @@
 
     Lexer for SAS.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -18,7 +18,7 @@ __all__ = ['SASLexer']
 
 class SASLexer(RegexLexer):
     """
-    For `SAS <http://www.sas.com/>`_ files.
+    For SAS files.
 
     .. versionadded:: 2.2
     """

data/vendor/pygments-main/pygments/lexers/savi.py

@@ -0,0 +1,170 @@
+"""
+    pygments.lexers.savi
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for Savi.
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, bygroups, include
+from pygments.token import Whitespace, Keyword, Name, String, Number, \
+  Operator, Punctuation, Comment, Generic, Error
+
+__all__ = ['SaviLexer']
+
+
+# The canonical version of this file can be found in the following repository,
+# where it is kept in sync with any language changes, as well as the other
+# pygments-like lexers that are maintained for use with other tools:
+# - https://github.com/savi-lang/savi/blob/main/tooling/pygments/lexers/savi.py
+#
+# If you're changing this file in the pygments repository, please ensure that
+# any changes you make are also propagated to the official Savi repository,
+# in order to avoid accidental clobbering of your changes later when an update
+# from the Savi repository flows forward into the pygments repository.
+#
+# If you're changing this file in the Savi repository, please ensure that
+# any changes you make are also reflected in the other pygments-like lexers
+# (rouge, vscode, etc) so that all of the lexers can be kept cleanly in sync.
+
+class SaviLexer(RegexLexer):
+  """
+  For Savi source code.
+
+  .. versionadded: 2.10
+  """
+
+  name = 'Savi'
+  url = 'https://github.com/savi-lang/savi'
+  aliases = ['savi']
+  filenames = ['*.savi']
+
+  tokens = {
+    "root": [
+      # Line Comment
+      (r'//.*?$', Comment.Single),
+
+      # Doc Comment
+      (r'::.*?$', Comment.Single),
+
+      # Capability Operator
+      (r'(\')(\w+)(?=[^\'])', bygroups(Operator, Name)),
+
+      # Double-Quote String
+      (r'\w?"', String.Double, "string.double"),
+
+      # Single-Char String
+      (r"'", String.Char, "string.char"),
+
+      # Type Name
+      (r'(_?[A-Z]\w*)', Name.Class),
+
+      # Nested Type Name
+      (r'(\.)(\s*)(_?[A-Z]\w*)', bygroups(Punctuation, Whitespace, Name.Class)),
+
+      # Declare
+      (r'^([ \t]*)(:\w+)',
+        bygroups(Whitespace, Name.Tag),
+        "decl"),
+
+      # Error-Raising Calls/Names
+      (r'((\w+|\+|\-|\*)\!)', Generic.Deleted),
+
+      # Numeric Values
+      (r'\b\d([\d_]*(\.[\d_]+)?)\b', Number),
+
+      # Hex Numeric Values
+      (r'\b0x([0-9a-fA-F_]+)\b', Number.Hex),
+
+      # Binary Numeric Values
+      (r'\b0b([01_]+)\b', Number.Bin),
+
+      # Function Call (with braces)
+      (r'\w+(?=\()', Name.Function),
+
+      # Function Call (with receiver)
+      (r'(\.)(\s*)(\w+)', bygroups(Punctuation, Whitespace, Name.Function)),
+
+      # Function Call (with self receiver)
+      (r'(@)(\w+)', bygroups(Punctuation, Name.Function)),
+
+      # Parenthesis
+      (r'\(', Punctuation, "root"),
+      (r'\)', Punctuation, "#pop"),
+
+      # Brace
+      (r'\{', Punctuation, "root"),
+      (r'\}', Punctuation, "#pop"),
+
+      # Bracket
+      (r'\[', Punctuation, "root"),
+      (r'(\])(\!)', bygroups(Punctuation, Generic.Deleted), "#pop"),
+      (r'\]', Punctuation, "#pop"),
+
+      # Punctuation
+      (r'[,;:\.@]', Punctuation),
+
+      # Piping Operators
+      (r'(\|\>)', Operator),
+
+      # Branching Operators
+      (r'(\&\&|\|\||\?\?|\&\?|\|\?|\.\?)', Operator),
+
+      # Comparison Operators
+      (r'(\<\=\>|\=\~|\=\=|\<\=|\>\=|\<|\>)', Operator),
+
+      # Arithmetic Operators
+      (r'(\+|\-|\/|\*|\%)', Operator),
+
+      # Assignment Operators
+      (r'(\=)', Operator),
+
+      # Other Operators
+      (r'(\!|\<\<|\<|\&|\|)', Operator),
+
+      # Identifiers
+      (r'\b\w+\b', Name),
+
+      # Whitespace
+      (r'[ \t\r]+\n*|\n+', Whitespace),
+    ],
+
+    # Declare (nested rules)
+    "decl": [
+      (r'\b[a-z_]\w*\b(?!\!)', Keyword.Declaration),
+      (r':', Punctuation, "#pop"),
+      (r'\n', Whitespace, "#pop"),
+      include("root"),
+    ],
+
+    # Double-Quote String (nested rules)
+    "string.double": [
+      (r'\\\(', String.Interpol, "string.interpolation"),
+      (r'\\u[0-9a-fA-F]{4}', String.Escape),
+      (r'\\x[0-9a-fA-F]{2}', String.Escape),
+      (r'\\[bfnrt\\\']', String.Escape),
+      (r'\\"', String.Escape),
+      (r'"', String.Double, "#pop"),
+      (r'[^\\"]+', String.Double),
+      (r'.', Error),
+    ],
+
+    # Single-Char String (nested rules)
+    "string.char": [
+      (r'\\u[0-9a-fA-F]{4}', String.Escape),
+      (r'\\x[0-9a-fA-F]{2}', String.Escape),
+      (r'\\[bfnrt\\\']', String.Escape),
+      (r"\\'", String.Escape),
+      (r"'", String.Char, "#pop"),
+      (r"[^\\']+", String.Char),
+      (r'.', Error),
+    ],
+
+    # Interpolation inside String (nested rules)
+    "string.interpolation": [
+      (r"\)", String.Interpol, "#pop"),
+      include("root"),
+    ]
+  }

data/vendor/pygments-main/pygments/lexers/scdoc.py

@@ -4,17 +4,14 @@
 
     Lexer for scdoc, a simple man page generator.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 import re
 
-from pygments.lexer import RegexLexer, include, bygroups, \
-    using, this
-from pygments.token import Text, Comment, Keyword, String, \
-    Generic
-
+from pygments.lexer import RegexLexer, include, bygroups, using, this
+from pygments.token import Text, Comment, Keyword, String, Generic
 
 __all__ = ['ScdocLexer']
 
@@ -22,11 +19,11 @@ __all__ = ['ScdocLexer']
 class ScdocLexer(RegexLexer):
     """
     `scdoc` is a simple man page generator for POSIX systems written in C99.
-    https://git.sr.ht/~sircmpwn/scdoc
 
     .. versionadded:: 2.5
     """
     name = 'scdoc'
+    url = 'https://git.sr.ht/~sircmpwn/scdoc'
     aliases = ['scdoc', 'scd']
     filenames = ['*.scd', '*.scdoc']
     flags = re.MULTILINE

data/vendor/pygments-main/pygments/lexers/scripting.py

@@ -4,7 +4,7 @@
 
     Lexer for scripting and embedded languages.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -23,7 +23,7 @@ __all__ = ['LuaLexer', 'MoonScriptLexer', 'ChaiscriptLexer', 'LSLLexer',
 
 class LuaLexer(RegexLexer):
     """
-    For `Lua <http://www.lua.org>`_ source code.
+    For Lua source code.
 
     Additional options accepted:
 
@@ -45,6 +45,7 @@ class LuaLexer(RegexLexer):
     """
 
     name = 'Lua'
+    url = 'https://www.lua.org/'
     aliases = ['lua']
     filenames = ['*.lua', '*.wlua']
     mimetypes = ['text/x-lua', 'application/x-lua']
@@ -163,12 +164,13 @@ class LuaLexer(RegexLexer):
 
 class MoonScriptLexer(LuaLexer):
     """
-    For `MoonScript <http://moonscript.org>`_ source code.
+    For MoonScript source code.
 
     .. versionadded:: 1.5
     """
 
     name = 'MoonScript'
+    url = 'http://moonscript.org'
     aliases = ['moonscript', 'moon']
     filenames = ['*.moon']
     mimetypes = ['text/x-moonscript', 'application/x-moonscript']
@@ -184,7 +186,7 @@ class MoonScriptLexer(LuaLexer):
             (r'(?i)\d+e[+-]?\d+', Number.Float),
             (r'(?i)0x[0-9a-f]*', Number.Hex),
             (r'\d+', Number.Integer),
-            (r'\n', Text),
+            (r'\n', Whitespace),
             (r'[^\S\n]+', Text),
             (r'(?s)\[(=*)\[.*?\]\1\]', String),
             (r'(->|=>)', Name.Function),
@@ -213,11 +215,11 @@ class MoonScriptLexer(LuaLexer):
         ],
         'sqs': [
             ("'", String.Single, '#pop'),
-            (".", String)
+            ("[^']+", String)
         ],
         'dqs': [
             ('"', String.Double, '#pop'),
-            (".", String)
+            ('[^"]+', String)
         ]
     }
 
@@ -231,12 +233,13 @@ class MoonScriptLexer(LuaLexer):
 
 class ChaiscriptLexer(RegexLexer):
     """
-    For `ChaiScript <http://chaiscript.com/>`_ source code.
+    For ChaiScript source code.
 
     .. versionadded:: 2.0
     """
 
     name = 'ChaiScript'
+    url = 'http://chaiscript.com/'
     aliases = ['chaiscript', 'chai']
     filenames = ['*.chai']
     mimetypes = ['text/x-chaiscript', 'application/x-chaiscript']
@@ -381,9 +384,7 @@ class LSLLexer(RegexLexer):
 
 class AppleScriptLexer(RegexLexer):
     """
-    For `AppleScript source code
-    <http://developer.apple.com/documentation/AppleScript/
-    Conceptual/AppleScriptLangGuide>`_,
+    For AppleScript source code,
     including `AppleScript Studio
     <http://developer.apple.com/documentation/AppleScript/
     Reference/StudioReference>`_.
@@ -393,6 +394,7 @@ class AppleScriptLexer(RegexLexer):
     """
 
     name = 'AppleScript'
+    url = 'https://developer.apple.com/library/archive/documentation/AppleScript/Conceptual/AppleScriptLangGuide/introduction/ASLR_intro.html'
     aliases = ['applescript']
     filenames = ['*.applescript']
 
@@ -704,7 +706,7 @@ class AppleScriptLexer(RegexLexer):
 
 class RexxLexer(RegexLexer):
     """
-    `Rexx <http://www.rexxinfo.org/>`_ is a scripting language available for
+    Rexx is a scripting language available for
     a wide range of different platforms with its roots found on mainframe
     systems. It is popular for I/O- and data based tasks and can act as glue
     language to bind different applications together.
@@ -712,6 +714,7 @@ class RexxLexer(RegexLexer):
     .. versionadded:: 2.0
     """
     name = 'Rexx'
+    url = 'http://www.rexxinfo.org/'
     aliases = ['rexx', 'arexx']
     filenames = ['*.rexx', '*.rex', '*.rx', '*.arexx']
     mimetypes = ['text/x-rexx']
@@ -719,7 +722,7 @@ class RexxLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'\s', Whitespace),
+            (r'\s+', Whitespace),
             (r'/\*', Comment.Multiline, 'comment'),
             (r'"', String, 'string_double'),
             (r"'", String, 'string_single'),
@@ -766,7 +769,7 @@ class RexxLexer(RegexLexer):
             (r'\n', Text, '#pop'),  # Stray linefeed also terminates strings.
         ],
         'string_single': [
-            (r'[^\'\n]', String),
+            (r'[^\'\n]+', String),
             (r'\'\'', String),
             (r'\'', String, '#pop'),
             (r'\n', Text, '#pop'),  # Stray linefeed also terminates strings.
@@ -798,7 +801,7 @@ class RexxLexer(RegexLexer):
 
     def analyse_text(text):
         """
-        Check for inital comment and patterns that distinguish Rexx from other
+        Check for initial comment and patterns that distinguish Rexx from other
         C-like languages.
         """
         if re.search(r'/\*\**\s*rexx', text, re.IGNORECASE):
@@ -817,12 +820,12 @@ class RexxLexer(RegexLexer):
 
 class MOOCodeLexer(RegexLexer):
     """
-    For `MOOCode <http://www.moo.mud.org/>`_ (the MOO scripting
-    language).
+    For MOOCode (the MOO scripting language).
 
     .. versionadded:: 0.9
     """
     name = 'MOOCode'
+    url = 'http://www.moo.mud.org/'
     filenames = ['*.moo']
     aliases = ['moocode', 'moo']
     mimetypes = ['text/x-moocode']
@@ -860,7 +863,7 @@ class MOOCodeLexer(RegexLexer):
 
 class HybrisLexer(RegexLexer):
     """
-    For `Hybris <http://www.hybris-lang.org>`_ source code.
+    For Hybris source code.
 
     .. versionadded:: 1.4
     """
@@ -975,7 +978,7 @@ class EasytrieveLexer(RegexLexer):
     #   * apostrophe (')
     #   * period (.)
     #   * comma (,)
-    #   * paranthesis ( and )
+    #   * parenthesis ( and )
     #   * colon (:)
     #
     # Additionally words end once a '*' appears, indicatins a comment.
@@ -1147,8 +1150,7 @@ class EasytrieveLexer(RegexLexer):
 
 class JclLexer(RegexLexer):
     """
-    `Job Control Language (JCL)
-    <http://publibz.boulder.ibm.com/cgi-bin/bookmgr_OS390/BOOKS/IEA2B570/CCONTENTS>`_
+    Job Control Language (JCL)
     is a scripting language used on mainframe platforms to instruct the system
     on how to run a batch job or start a subsystem. It is somewhat
     comparable to MS DOS batch and Unix shell scripts.
@@ -1231,12 +1233,13 @@ class JclLexer(RegexLexer):
 
 class MiniScriptLexer(RegexLexer):
     """
-    For `MiniScript <https://miniscript.org>`_ source code.
+    For MiniScript source code.
 
     .. versionadded:: 2.6
     """
 
     name = 'MiniScript'
+    url = 'https://miniscript.org'
     aliases = ['miniscript', 'ms']
     filenames = ['*.ms']
     mimetypes = ['text/x-minicript', 'application/x-miniscript']

data/vendor/pygments-main/pygments/lexers/sgf.py

@@ -4,12 +4,12 @@
 
     Lexer for Smart Game Format (sgf) file format.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 from pygments.lexer import RegexLexer, bygroups
-from pygments.token import Name, Literal, String, Text, Punctuation
+from pygments.token import Name, Literal, String, Punctuation, Whitespace
 
 __all__ = ["SmartGameFormatLexer"]
 
@@ -20,18 +20,17 @@ class SmartGameFormatLexer(RegexLexer):
 
     The format is used to store game records of board games for two players
     (mainly Go game).
-    For more information about the definition of the format, see:
-    https://www.red-bean.com/sgf/
 
     .. versionadded:: 2.4
     """
     name = 'SmartGameFormat'
+    url = 'https://www.red-bean.com/sgf/'
     aliases = ['sgf']
     filenames = ['*.sgf']
 
     tokens = {
         'root': [
-            (r'[\s():;]', Punctuation),
+            (r'[():;]+', Punctuation),
             # tokens:
             (r'(A[BW]|AE|AN|AP|AR|AS|[BW]L|BM|[BW]R|[BW]S|[BW]T|CA|CH|CP|CR|'
              r'DD|DM|DO|DT|EL|EV|EX|FF|FG|G[BW]|GC|GM|GN|HA|HO|ID|IP|IT|IY|KM|'
@@ -55,6 +54,7 @@ class SmartGameFormatLexer(RegexLexer):
             (r'(\[)([\w\s#()+,\-.:?]+)(\])',
              bygroups(Punctuation, String, Punctuation)),
             (r'(\[)(\s.*)(\])',
-             bygroups(Punctuation, Text, Punctuation)),
+             bygroups(Punctuation, Whitespace, Punctuation)),
+            (r'\s+', Whitespace)
         ],
     }