pygments.rb 2.3.1 → 2.4.0

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

@@ -0,0 +1,128 @@
+"""
+    pygments.lexers.mips
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for MIPS assembly.
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, words
+from pygments.token import Whitespace, Comment, String, Keyword, Name, Text
+
+__all__ = ["MIPSLexer"]
+
+
+class MIPSLexer(RegexLexer):
+    """
+    A MIPS Assembly Lexer.
+
+    Based on the Emacs major mode by hlissner:
+    https://github.com/hlissner/emacs-mips-mode
+    """
+
+    name = 'MIPS'
+    aliases = ['mips']
+    # TODO: add '*.s' and '*.asm', which will require designing an analyse_text
+    # method for this lexer and refactoring those from Gas and Nasm in order to
+    # have relatively reliable detection
+    filenames = ['*.mips', '*.MIPS']
+
+    keywords = [
+        # Arithmetic insturctions
+        "add", "sub", "subu", "addi", "subi", "addu", "addiu",
+        # Multiplication/division
+        "mul", "mult", "multu", "mulu", "madd", "maddu", "msub", "msubu", "div", "divu",
+        # Bitwise operations
+        "and", "or", "nor", "xor", "andi", "ori", "xori", "clo", "clz",
+        # Shifts
+        "sll", "srl", "sllv", "srlv", "sra", "srav",
+        # Comparisons
+        "slt", "sltu", "slti", "sltiu",
+        # Move data
+        "mfhi", "mthi", "mflo", "mtlo", "movn", "movz", "movf", "movt",
+        # Jump
+        "j", "jal", "jalr", "jr",
+        # branch
+        "bc1f", "bc1t", "beq", "bgez", "bgezal", "bgtz", "blez", "bltzal", "bltz", "bne",
+        # Load
+        "lui", "lb", "lbu", "lh", "lhu", "lw", "lwcl", "lwl", "lwr",
+        # Store
+        "sb", "sh", "sw", "swl", "swr", # coproc: swc1 sdc1
+        # Concurrent load/store
+        "ll", "sc",
+        # Trap handling
+        "teq", "teqi", "tne", "tneqi", "tge", "tgeu", "tgei", "tgeiu", "tlt", "tltu", "tlti",
+        "tltiu",
+        # Exception / Interrupt
+        "eret", "break", "bop", "syscall",
+        # --- Floats -----------------------------------------------------
+        # Arithmetic
+        "add.s", "add.d", "sub.s", "sub.d", "mul.s", "mul.d", "div.s", "div.d", "neg.d",
+        "neg.s",
+        # Comparison
+        "c.e.d", "c.e.s", "c.le.d", "c.le.s", "c.lt.s", "c.lt.d", # "c.gt.s", "c.gt.d",
+        "madd.s", "madd.d", "msub.s", "msub.d",
+        # Move Floats
+        "mov.d", "move.s", "movf.d", "movf.s", "movt.d", "movt.s", "movn.d", "movn.s",
+        "movnzd", "movz.s", "movz.d",
+        # Conversion
+        "cvt.d.s", "cvt.d.w", "cvt.s.d", "cvt.s.w", "cvt.w.d", "cvt.w.s", "trunc.w.d",
+        "trunc.w.s",
+        # Math
+        "abs.s", "abs.d", "sqrt.s", "sqrt.d", "ceil.w.d", "ceil.w.s", "floor.w.d",
+        "floor.w.s", "round.w.d", "round.w.s",
+    ]
+
+    pseudoinstructions = [
+        # Arithmetic & logical
+        "rem", "remu", "mulo", "mulou", "abs", "neg", "negu", "not", "rol", "ror",
+        # branches
+        "b", "beqz", "bge", "bgeu", "bgt", "bgtu", "ble", "bleu", "blt", "bltu", "bnez",
+        # loads
+        "la", "li", "ld", "ulh", "ulhu", "ulw",
+        # Store
+        "sd", "ush", "usw",
+        # move
+        "move", # coproc: "mfc1.d",
+        # comparisons
+        "sgt", "sgtu", "sge", "sgeu", "sle", "sleu", "sne", "seq",
+        # --- Floats -----------------------------------------------------
+        # load-store
+        "l.d", "l.s", "s.d", "s.s",
+    ]
+
+    directives = [
+        ".align", ".ascii", ".asciiz", ".byte", ".data", ".double", ".extern", ".float",
+        ".globl", ".half", ".kdata", ".ktext", ".space", ".text", ".word",
+    ]
+
+    deprecated = [
+        "beql", "bnel", "bgtzl", "bgezl", "bltzl", "blezl", "bltzall", "bgezall",
+    ]
+
+    tokens = {
+        'root': [
+            (r'\s+', Whitespace),
+            (r'#.*', Comment),
+            (r'"', String, 'string'),
+            (r'-?[0-9]+?', Keyword.Constant),
+            (r'\w*:', Name.Function),
+            (words(deprecated, suffix=r'\b'), Keyword.Pseudo), # need warning face
+            (words(pseudoinstructions, suffix=r'\b'), Name.Variable),
+            (words(keywords, suffix=r'\b'), Keyword),
+            (r'[slm][ftwd]c[0-9]([.]d)?', Keyword),
+            (r'\$(f?[0-2][0-9]|f?3[01]|[ft]?[0-9]|[vk][01]|a[0-3]|s[0-7]|[gsf]p|ra|at|zero)',
+             Keyword.Type),
+            (words(directives, suffix=r'\b'), Name.Entity), # Preprocessor?
+            (r':|,|;|\{|\}|=>|@|\$|=', Name.Builtin),
+            (r'\w+', Text),
+            (r'.', Text),
+        ],
+        'string': [
+            (r'\\.', String.Escape),
+            (r'"', String, '#pop'),
+            (r'[^\\"]+', String),
+        ],
+    }

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

@@ -4,7 +4,7 @@
 
     Lexers for ML family 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.
 """
 
@@ -55,7 +55,7 @@ class SMLLexer(RegexLexer):
     # A character constant is a sequence of the form #s, where s is a string
     # constant denoting a string of size one character. This setup just parses
     # the entire string as either a String.Double or a String.Char (depending
-    # on the argument), even if the String.Char is an erronous
+    # on the argument), even if the String.Char is an erroneous
     # multiple-character string.
     def stringy(whatkind):
         return [
@@ -360,6 +360,7 @@ class OcamlLexer(RegexLexer):
     """
 
     name = 'OCaml'
+    url = 'https://ocaml.org/'
     aliases = ['ocaml']
     filenames = ['*.ml', '*.mli', '*.mll', '*.mly']
     mimetypes = ['text/x-ocaml']
@@ -446,7 +447,7 @@ class OcamlLexer(RegexLexer):
 
 class OpaLexer(RegexLexer):
     """
-    Lexer for the Opa language (http://opalang.org).
+    Lexer for the Opa language.
 
     .. versionadded:: 1.5
     """
@@ -769,12 +770,13 @@ class OpaLexer(RegexLexer):
 
 class ReasonLexer(RegexLexer):
     """
-    For the ReasonML language (https://reasonml.github.io/).
+    For the ReasonML language.
 
     .. versionadded:: 2.6
     """
 
     name = 'ReasonML'
+    url = 'https://reasonml.github.io/'
     aliases = ['reasonml', 'reason']
     filenames = ['*.re', '*.rei']
     mimetypes = ['text/x-reasonml']
@@ -861,11 +863,12 @@ class ReasonLexer(RegexLexer):
 
 class FStarLexer(RegexLexer):
     """
-    For the F* language (https://www.fstar-lang.org/).
+    For the F* language.
     .. versionadded:: 2.7
     """
 
     name = 'FStar'
+    url = 'https://www.fstar-lang.org/'
     aliases = ['fstar']
     filenames = ['*.fst', '*.fsti']
     mimetypes = ['text/x-fstar']
@@ -908,7 +911,7 @@ class FStarLexer(RegexLexer):
             (r'\b([A-Z][\w\']*)(?=\s*\.)', Name.Namespace, 'dotted'),
             (r'\b([A-Z][\w\']*)', Name.Class),
             (r'\(\*(?![)])', Comment, 'comment'),
-            (r'^\/\/.+$', Comment),
+            (r'\/\/.+$', Comment),
             (r'\b(%s)\b' % '|'.join(keywords), Keyword),
             (r'\b(%s)\b' % '|'.join(assume_keywords), Name.Exception),
             (r'\b(%s)\b' % '|'.join(decl_keywords), Keyword.Declaration),

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

@@ -4,7 +4,7 @@
 
     Lexers for modeling 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.
 """
 
@@ -22,11 +22,12 @@ __all__ = ['ModelicaLexer', 'BugsLexer', 'JagsLexer', 'StanLexer']
 
 class ModelicaLexer(RegexLexer):
     """
-    For `Modelica <http://www.modelica.org/>`_ source code.
+    For Modelica source code.
 
     .. versionadded:: 1.1
     """
     name = 'Modelica'
+    url = 'http://www.modelica.org/'
     aliases = ['modelica']
     filenames = ['*.mo']
     mimetypes = ['text/x-modelica']
@@ -97,7 +98,7 @@ class ModelicaLexer(RegexLexer):
 
 class BugsLexer(RegexLexer):
     """
-    Pygments Lexer for `OpenBugs <http://www.openbugs.net/>`_ and WinBugs
+    Pygments Lexer for OpenBugs and WinBugs
     models.
 
     .. versionadded:: 1.6
@@ -303,7 +304,6 @@ class StanLexer(RegexLexer):
             (r'(//|#).*$', Comment.Single),
         ],
         'root': [
-            # Stan is more restrictive on strings than this regex
             (r'"[^"]*"', String),
             # Comments
             include('comments'),
@@ -325,7 +325,7 @@ class StanLexer(RegexLexer):
             (r'(%s)\b' % r'|'.join(_stan_builtins.TYPES), Keyword.Type),
              # < should be punctuation, but elsewhere I can't tell if it is in
              # a range constraint
-            (r'(<)(\s*)(upper|lower)(\s*)(=)',
+            (r'(<)(\s*)(upper|lower|offset|multiplier)(\s*)(=)',
              bygroups(Operator, Whitespace, Keyword, Whitespace, Punctuation)),
             (r'(,)(\s*)(upper)(\s*)(=)',
              bygroups(Punctuation, Whitespace, Keyword, Whitespace, Punctuation)),
@@ -340,17 +340,21 @@ class StanLexer(RegexLexer):
             (r'(%s)\b' % r'|'.join(_stan_builtins.RESERVED), Keyword.Reserved),
             # user-defined functions
             (r'[A-Za-z]\w*(?=\s*\()]', Name.Function),
-            # Regular variable names
-            (r'[A-Za-z]\w*\b', Name),
+            # Imaginary Literals
+            (r'[0-9]+(\.[0-9]*)?([eE][+-]?[0-9]+)?i', Number.Float),
+            (r'\.[0-9]+([eE][+-]?[0-9]+)?i', Number.Float),
+            (r'[0-9]+i', Number.Float),
             # Real Literals
             (r'[0-9]+(\.[0-9]*)?([eE][+-]?[0-9]+)?', Number.Float),
             (r'\.[0-9]+([eE][+-]?[0-9]+)?', Number.Float),
             # Integer Literals
             (r'[0-9]+', Number.Integer),
+            # Regular variable names
+            (r'[A-Za-z]\w*\b', Name),
             # Assignment operators
             (r'<-|(?:\+|-|\.?/|\.?\*|=)?=|~', Operator),
             # Infix, prefix and postfix operators (and = )
-            (r"\+|-|\.?\*|\.?/|\\|'|\^|!=?|<=?|>=?|\|\||&&|%|\?|:", Operator),
+            (r"\+|-|\.?\*|\.?/|\\|'|\.?\^|!=?|<=?|>=?|\|\||&&|%|\?|:|%/%|!", Operator),
             # Block delimiters
             (r'[{}]', Punctuation),
             # Distribution |

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

@@ -4,7 +4,7 @@
 
     Multi-Dialect Lexer for Modula-2.
 
-    :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.
 """
 
@@ -21,7 +21,7 @@ __all__ = ['Modula2Lexer']
 # Multi-Dialect Modula-2 Lexer
 class Modula2Lexer(RegexLexer):
     """
-    For `Modula-2 <http://www.modula2.org/>`_ source code.
+    For Modula-2 source code.
 
     The Modula-2 lexer supports several dialects.  By default, it operates in
     fallback mode, recognising the *combined* literals, punctuation symbols
@@ -159,6 +159,7 @@ class Modula2Lexer(RegexLexer):
        Added multi-dialect support.
     """
     name = 'Modula-2'
+    url = 'http://www.modula2.org/'
     aliases = ['modula2', 'm2']
     filenames = ['*.def', '*.mod']
     mimetypes = ['text/x-modula2']

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

@@ -4,7 +4,7 @@
 
     Lexer for the Monte programming 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.
 """
 
@@ -77,11 +77,12 @@ _safeScope = [
 
 class MonteLexer(RegexLexer):
     """
-    Lexer for the `Monte <https://monte.readthedocs.io/>`_ programming language.
+    Lexer for the Monte programming language.
 
     .. versionadded:: 2.2
     """
     name = 'Monte'
+    url = 'https://monte.readthedocs.io/'
     aliases = ['monte']
     filenames = ['*.mt']
 

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

@@ -5,7 +5,7 @@
     Lexers for the mosel language.
     http://www.fico.com/en/products/fico-xpress-optimization
 
-    :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.
 """
 

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

@@ -4,7 +4,7 @@
 
     Lexers for NCAR Command 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.
 """
 

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

@@ -4,13 +4,13 @@
 
     Lexer for the Nim language (formerly known as Nimrod).
 
-    :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, default
+from pygments.lexer import RegexLexer, include, default, bygroups
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
     Number, Punctuation, Error
 
@@ -19,36 +19,38 @@ __all__ = ['NimrodLexer']
 
 class NimrodLexer(RegexLexer):
     """
-    For `Nim <http://nim-lang.org/>`_ source code.
+    For Nim source code.
 
     .. versionadded:: 1.5
     """
 
     name = 'Nimrod'
+    url = 'http://nim-lang.org/'
     aliases = ['nimrod', 'nim']
     filenames = ['*.nim', '*.nimrod']
     mimetypes = ['text/x-nim']
 
-    flags = re.MULTILINE | re.IGNORECASE | re.UNICODE
+    flags = re.MULTILINE | re.IGNORECASE
 
     def underscorize(words):
         newWords = []
-        new = ""
+        new = []
         for word in words:
             for ch in word:
-                new += (ch + "_?")
-            newWords.append(new)
-            new = ""
+                new.append(ch)
+                new.append("_?")
+            newWords.append(''.join(new))
+            new = []
         return "|".join(newWords)
 
     keywords = [
         'addr', 'and', 'as', 'asm', 'bind', 'block', 'break', 'case',
         'cast', 'concept', 'const', 'continue', 'converter', 'defer', 'discard',
         'distinct', 'div', 'do', 'elif', 'else', 'end', 'enum', 'except',
-        'export', 'finally', 'for', 'func', 'if', 'in', 'yield', 'interface',
-        'is', 'isnot', 'iterator', 'let', 'macro', 'method', 'mixin', 'mod',
-        'not', 'notin', 'object', 'of', 'or', 'out', 'proc', 'ptr', 'raise',
-        'ref', 'return', 'shl', 'shr', 'static', 'template', 'try',
+        'export', 'finally', 'for', 'if', 'in', 'yield', 'interface',
+        'is', 'isnot', 'iterator', 'let', 'mixin', 'mod',
+        'not', 'notin', 'object', 'of', 'or', 'out', 'ptr', 'raise',
+        'ref', 'return', 'shl', 'shr', 'static', 'try',
         'tuple', 'type', 'using', 'when', 'while', 'xor'
     ]
 
@@ -68,15 +70,27 @@ class NimrodLexer(RegexLexer):
 
     tokens = {
         'root': [
+            # Comments
+            (r'##\[', String.Doc, 'doccomment'),
             (r'##.*$', String.Doc),
+            (r'#\[', Comment.Multiline, 'comment'),
             (r'#.*$', Comment),
+
+            # Pragmas
+            (r'\{\.', String.Other, 'pragma'),
+
+            # Operators
             (r'[*=><+\-/@$~&%!?|\\\[\]]', Operator),
             (r'\.\.|\.|,|\[\.|\.\]|\{\.|\.\}|\(\.|\.\)|\{|\}|\(|\)|:|\^|`|;',
              Punctuation),
 
+            # Case statement branch
+            (r'(\n\s*)(of)(\s)', bygroups(Text.Whitespace, Keyword,
+                                          Text.Whitespace), 'casebranch'),
+
             # Strings
             (r'(?:[\w]+)"', String, 'rdqs'),
-            (r'"""', String, 'tdqs'),
+            (r'"""', String.Double, 'tdqs'),
             ('"', String, 'dqs'),
 
             # Char
@@ -84,15 +98,18 @@ class NimrodLexer(RegexLexer):
 
             # Keywords
             (r'(%s)\b' % underscorize(opWords), Operator.Word),
-            (r'(p_?r_?o_?c_?\s)(?![(\[\]])', Keyword, 'funcname'),
+            (r'(proc|func|method|macro|template)(\s)(?![(\[\]])',
+             bygroups(Keyword, Text.Whitespace), 'funcname'),
             (r'(%s)\b' % underscorize(keywords), Keyword),
-            (r'(%s)\b' % underscorize(['from', 'import', 'include']),
+            (r'(%s)\b' % underscorize(['from', 'import', 'include', 'export']),
              Keyword.Namespace),
             (r'(v_?a_?r)\b', Keyword.Declaration),
-            (r'(%s)\b' % underscorize(types), Keyword.Type),
+            (r'(%s)\b' % underscorize(types), Name.Builtin),
             (r'(%s)\b' % underscorize(keywordsPseudo), Keyword.Pseudo),
+
             # Identifiers
             (r'\b((?![_\d])\w)(((?!_)\w)|(_(?!_)\w))*', Name),
+
             # Numbers
             (r'[0-9][0-9_]*(?=([e.]|\'f(32|64)))',
              Number.Float, ('float-suffix', 'float-number')),
@@ -100,8 +117,9 @@ class NimrodLexer(RegexLexer):
             (r'0b[01][01_]*', Number.Bin, 'int-suffix'),
             (r'0o[0-7][0-7_]*', Number.Oct, 'int-suffix'),
             (r'[0-9][0-9_]*', Number.Integer, 'int-suffix'),
+
             # Whitespace
-            (r'\s+', Text),
+            (r'\s+', Text.Whitespace),
             (r'.+$', Error),
         ],
         'chars': [
@@ -118,6 +136,18 @@ class NimrodLexer(RegexLexer):
             (r'\$', String)
             # newlines are an error (use "nl" state)
         ],
+        'doccomment': [
+            (r'[^\]#]+', String.Doc),
+            (r'##\[', String.Doc, '#push'),
+            (r'\]##', String.Doc, '#pop'),
+            (r'[\]#]', String.Doc),
+        ],
+        'comment': [
+            (r'[^\]#]+', Comment.Multiline),
+            (r'#\[', Comment.Multiline, '#push'),
+            (r'\]#', Comment.Multiline, '#pop'),
+            (r'[\]#]', Comment.Multiline),
+        ],
         'dqs': [
             (r'\\([\\abcefnrtvl"\']|\n|x[a-f0-9]{2}|[0-9]{1,3})',
              String.Escape),
@@ -130,9 +160,9 @@ class NimrodLexer(RegexLexer):
             include('strings')
         ],
         'tdqs': [
-            (r'"""(?!")', String, '#pop'),
+            (r'"""', String.Double, '#pop'),
             include('strings'),
-            include('nl')
+            (r'\n', String.Double)
         ],
         'funcname': [
             (r'((?![\d_])\w)(((?!_)\w)|(_(?!_)\w))*', Name.Function, '#pop'),
@@ -142,7 +172,7 @@ class NimrodLexer(RegexLexer):
             (r'\n', String)
         ],
         'float-number': [
-            (r'\.(?!\.)[0-9_]*', Number.Float),
+            (r'\.(?!\.)[0-9_]*[f]*', Number.Float),
             (r'e[+-]?[0-9][0-9_]*', Number.Float),
             default('#pop')
         ],
@@ -155,4 +185,16 @@ class NimrodLexer(RegexLexer):
             (r'\'i(8|16)', Number.Integer),
             default('#pop')
         ],
+        'casebranch': [
+            (r',', Punctuation),
+            (r'[\n ]+', Text.Whitespace),
+            (r':', Operator, '#pop'),
+            (r'\w+|[^:]', Name.Label),
+        ],
+        'pragma': [
+            (r'[:,]', Text),
+            (r'[\n ]+', Text.Whitespace),
+            (r'\.\}', String.Other, '#pop'),
+            (r'\w+|\W+|[^.}]', String.Other),
+        ],
     }

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

@@ -4,7 +4,7 @@
 
     Lexer for the Nit 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.
 """
 
@@ -17,12 +17,13 @@ __all__ = ['NitLexer']
 
 class NitLexer(RegexLexer):
     """
-    For `nit <http://nitlanguage.org>`_ source.
+    For nit source.
 
     .. versionadded:: 2.0
     """
 
     name = 'Nit'
+    url = 'http://nitlanguage.org'
     aliases = ['nit']
     filenames = ['*.nit']
     tokens = {

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

@@ -4,7 +4,7 @@
 
     Lexers for the NixOS Nix 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.
 """
 
@@ -19,18 +19,17 @@ __all__ = ['NixLexer']
 
 class NixLexer(RegexLexer):
     """
-    For the `Nix language <http://nixos.org/nix/>`_.
+    For the Nix language.
 
     .. versionadded:: 2.0
     """
 
     name = 'Nix'
+    url = 'http://nixos.org/nix/'
     aliases = ['nixos', 'nix']
     filenames = ['*.nix']
     mimetypes = ['text/x-nix']
 
-    flags = re.MULTILINE | re.UNICODE
-
     keywords = ['rec', 'with', 'let', 'in', 'inherit', 'assert', 'if',
                 'else', 'then', '...']
     builtins = ['import', 'abort', 'baseNameOf', 'dirOf', 'isNull', 'builtins',
@@ -103,7 +102,8 @@ class NixLexer(RegexLexer):
             (r"''\t", String.Escape),
             (r"''", String.Single, '#pop'),
             (r'\$\{', String.Interpol, 'antiquote'),
-            (r"[^']", String.Single),
+            (r"['$]", String.Single),
+            (r"[^'$]+", String.Single),
         ],
         'doublequote': [
             (r'\\', String.Escape),

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

@@ -4,7 +4,7 @@
 
     Lexers for Oberon family 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.
 """
 
@@ -19,7 +19,7 @@ __all__ = ['ComponentPascalLexer']
 
 class ComponentPascalLexer(RegexLexer):
     """
-    For `Component Pascal <http://www.oberon.ch/pdf/CP-Lang.pdf>`_ source code.
+    For Component Pascal source code.
 
     .. versionadded:: 2.1
     """

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

@@ -4,7 +4,7 @@
 
     Lexers for Objective-C family 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.
 """
 
@@ -175,12 +175,12 @@ def objective(baselexer):
                 return 0.8
             return 0
 
-        def get_tokens_unprocessed(self, text):
+        def get_tokens_unprocessed(self, text, stack=('root',)):
             from pygments.lexers._cocoa_builtins import COCOA_INTERFACES, \
                 COCOA_PROTOCOLS, COCOA_PRIMITIVES
 
             for index, token, value in \
-                    baselexer.get_tokens_unprocessed(self, text):
+                    baselexer.get_tokens_unprocessed(self, text, stack):
                 if token is Name or token is Name.Class:
                     if value in COCOA_INTERFACES or value in COCOA_PROTOCOLS \
                        or value in COCOA_PRIMITIVES:
@@ -197,6 +197,7 @@ class ObjectiveCLexer(objective(CLexer)):
     """
 
     name = 'Objective-C'
+    url = 'https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html'
     aliases = ['objective-c', 'objectivec', 'obj-c', 'objc']
     filenames = ['*.m', '*.h']
     mimetypes = ['text/x-objective-c']
@@ -281,11 +282,12 @@ class LogosLexer(ObjectiveCppLexer):
 
 class SwiftLexer(RegexLexer):
     """
-    For `Swift <https://developer.apple.com/swift/>`_ source.
+    For Swift source.
 
     .. versionadded:: 2.0
     """
     name = 'Swift'
+    url = 'https://www.swift.org/'
     filenames = ['*.swift']
     aliases = ['swift']
     mimetypes = ['text/x-swift']