pygments.rb 2.3.1 → 2.4.0

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

@@ -4,49 +4,49 @@
 
     Lexers for theorem-proving 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 RegexLexer, default, words
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Generic
+    Number, Punctuation, Generic, Whitespace
 
 __all__ = ['CoqLexer', 'IsabelleLexer', 'LeanLexer']
 
 
 class CoqLexer(RegexLexer):
     """
-    For the `Coq <http://coq.inria.fr/>`_ theorem prover.
+    For the Coq theorem prover.
 
     .. versionadded:: 1.5
     """
 
     name = 'Coq'
+    url = 'http://coq.inria.fr/'
     aliases = ['coq']
     filenames = ['*.v']
     mimetypes = ['text/x-coq']
 
-    flags = re.UNICODE
+    flags = 0 # no re.MULTILINE
 
     keywords1 = (
         # Vernacular commands
         'Section', 'Module', 'End', 'Require', 'Import', 'Export', 'Variable',
-        'Variables', 'Parameter', 'Parameters', 'Axiom', 'Hypothesis',
+        'Variables', 'Parameter', 'Parameters', 'Axiom', 'Axioms', 'Hypothesis',
         'Hypotheses', 'Notation', 'Local', 'Tactic', 'Reserved', 'Scope',
-        'Open', 'Close', 'Bind', 'Delimit', 'Definition', 'Let', 'Ltac',
-        'Fixpoint', 'CoFixpoint', 'Morphism', 'Relation', 'Implicit',
-        'Arguments', 'Set', 'Unset', 'Contextual', 'Strict', 'Prenex',
+        'Open', 'Close', 'Bind', 'Delimit', 'Definition', 'Example', 'Let',
+        'Ltac', 'Fixpoint', 'CoFixpoint', 'Morphism', 'Relation', 'Implicit',
+        'Arguments', 'Types', 'Unset', 'Contextual', 'Strict', 'Prenex',
         'Implicits', 'Inductive', 'CoInductive', 'Record', 'Structure',
-        'Canonical', 'Coercion', 'Theorem', 'Lemma', 'Corollary',
-        'Proposition', 'Fact', 'Remark', 'Example', 'Proof', 'Goal', 'Save',
-        'Qed', 'Defined', 'Hint', 'Resolve', 'Rewrite', 'View', 'Search',
-        'Abort', 'Admitted',
+        'Variant', 'Canonical', 'Coercion', 'Theorem', 'Lemma', 'Fact',
+        'Remark', 'Corollary', 'Proposition', 'Property', 'Goal',
+        'Proof', 'Restart', 'Save', 'Qed', 'Defined', 'Abort', 'Admitted',
+        'Hint', 'Resolve', 'Rewrite', 'View', 'Search', 'Compute', 'Eval',
         'Show', 'Print', 'Printing', 'All', 'Graph', 'Projections', 'inside',
         'outside', 'Check', 'Global', 'Instance', 'Class', 'Existing',
-        'Universe', 'Polymorphic', 'Monomorphic', 'Context'
+        'Universe', 'Polymorphic', 'Monomorphic', 'Context', 'Scheme', 'From',
+        'Undo', 'Fail', 'Function',
     )
     keywords2 = (
         # Gallina
@@ -56,7 +56,7 @@ class CoqLexer(RegexLexer):
     )
     keywords3 = (
         # Sorts
-        'Type', 'Prop', 'SProp',
+        'Type', 'Prop', 'SProp', 'Set',
     )
     keywords4 = (
         # Tactics
@@ -74,9 +74,10 @@ class CoqLexer(RegexLexer):
     )
     keywords5 = (
         # Terminators
-        'by', 'done', 'exact', 'reflexivity', 'tauto', 'romega', 'omega',
+        'by', 'now', 'done', 'exact', 'reflexivity',
+        'tauto', 'romega', 'omega', 'lia', 'nia', 'lra', 'nra', 'psatz',
         'assumption', 'solve', 'contradiction', 'discriminate',
-        'congruence',
+        'congruence', 'admit'
     )
     keywords6 = (
         # Control
@@ -107,6 +108,10 @@ class CoqLexer(RegexLexer):
             (r'\s+', Text),
             (r'false|true|\(\)|\[\]', Name.Builtin.Pseudo),
             (r'\(\*', Comment, 'comment'),
+            (r'\b(?:[^\W\d][\w\']*\.)+[^\W\d][\w\']*\b', Name),
+            (r'\bEquations\b\??', Keyword.Namespace),
+            # Very weak heuristic to distinguish the Set vernacular from the Set sort
+            (r'\bSet(?=[ \t]+[A-Z][a-z][^\n]*?\.)', Keyword.Namespace),
             (words(keywords1, prefix=r'\b', suffix=r'\b'), Keyword.Namespace),
             (words(keywords2, prefix=r'\b', suffix=r'\b'), Keyword),
             (words(keywords3, prefix=r'\b', suffix=r'\b'), Keyword.Type),
@@ -164,12 +169,13 @@ class CoqLexer(RegexLexer):
 
 class IsabelleLexer(RegexLexer):
     """
-    For the `Isabelle <http://isabelle.in.tum.de/>`_ proof assistant.
+    For the Isabelle proof assistant.
 
     .. versionadded:: 2.0
     """
 
     name = 'Isabelle'
+    url = 'https://isabelle.in.tum.de/'
     aliases = ['isabelle']
     filenames = ['*.thy']
     mimetypes = ['text/x-isabelle']
@@ -302,9 +308,10 @@ class IsabelleLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'\(\*', Comment, 'comment'),
-            (r'\{\*', Comment, 'text'),
+            (r'\\<open>', String.Symbol, 'cartouche'),
+            (r'\{\*|‹', String, 'cartouche'),
 
             (words(operators), Operator),
             (words(proof_operators), Operator.Word),
@@ -335,19 +342,17 @@ class IsabelleLexer(RegexLexer):
 
             (words(keyword_proof_script, prefix=r'\b', suffix=r'\b'), Keyword.Pseudo),
 
-            (r'\\<\w*>', Text.Symbol),
+            (r'\\<(\w|\^)*>', Text.Symbol),
 
-            (r"[^\W\d][.\w']*", Name),
-            (r"\?[^\W\d][.\w']*", Name),
             (r"'[^\W\d][.\w']*", Name.Type),
 
-            (r'\d[\d_]*', Name),  # display numbers as name
             (r'0[xX][\da-fA-F][\da-fA-F_]*', Number.Hex),
             (r'0[oO][0-7][0-7_]*', Number.Oct),
             (r'0[bB][01][01_]*', Number.Bin),
 
             (r'"', String, 'string'),
             (r'`', String.Other, 'fact'),
+            (r'[^\s:|\[\]\-()=,+!?{}._][^\s:|\[\]\-()=,+!?{}]*', Name),
         ],
         'comment': [
             (r'[^(*)]+', Comment),
@@ -355,22 +360,25 @@ class IsabelleLexer(RegexLexer):
             (r'\*\)', Comment, '#pop'),
             (r'[(*)]', Comment),
         ],
-        'text': [
-            (r'[^*}]+', Comment),
-            (r'\*\}', Comment, '#pop'),
-            (r'\*', Comment),
-            (r'\}', Comment),
+        'cartouche': [
+            (r'[^{*}\\‹›]+', String),
+            (r'\\<open>', String.Symbol, '#push'),
+            (r'\{\*|‹', String, '#push'),
+            (r'\\<close>', String.Symbol, '#pop'),
+            (r'\*\}|›', String, '#pop'),
+            (r'\\<(\w|\^)*>', String.Symbol),
+            (r'[{*}\\]', String),
         ],
         'string': [
             (r'[^"\\]+', String),
-            (r'\\<\w*>', String.Symbol),
+            (r'\\<(\w|\^)*>', String.Symbol),
             (r'\\"', String),
             (r'\\', String),
             (r'"', String, '#pop'),
         ],
         'fact': [
             (r'[^`\\]+', String.Other),
-            (r'\\<\w*>', String.Symbol),
+            (r'\\<(\w|\^)*>', String.Symbol),
             (r'\\`', String.Other),
             (r'\\', String.Other),
             (r'`', String.Other, '#pop'),
@@ -380,18 +388,16 @@ class IsabelleLexer(RegexLexer):
 
 class LeanLexer(RegexLexer):
     """
-    For the `Lean <https://github.com/leanprover/lean>`_
-    theorem prover.
+    For the Lean theorem prover.
 
     .. versionadded:: 2.0
     """
     name = 'Lean'
+    url = 'https://github.com/leanprover/lean'
     aliases = ['lean']
     filenames = ['*.lean']
     mimetypes = ['text/x-lean']
 
-    flags = re.MULTILINE | re.UNICODE
-
     tokens = {
         'root': [
             (r'\s+', Text),

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

@@ -1,15 +1,13 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.thingsdb
-    ~~~~~~~~~~~~~~~~~~~~~~
+    ~~~~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for the ThingsDB language.
 
-    :copyright: Copyright 2006-2019 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
 from pygments.token import Comment, Keyword, Name, Number, String, Text, \
     Operator, Punctuation, Whitespace

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

@@ -0,0 +1,57 @@
+"""
+    pygments.lexers.tlb
+    ~~~~~~~~~~~~~~~~~~~
+
+    Lexers for TL-b.
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, include, words
+from pygments.token import Operator, Name, \
+    Number, Whitespace, Punctuation, Comment
+
+__all__ = ['TlbLexer']
+
+
+class TlbLexer(RegexLexer):
+    """
+    For TL-b source code.
+    """
+
+    name = 'Tl-b'
+    aliases = ['tlb']
+    filenames = ['*.tlb']
+
+    tokens = {
+        'root': [
+            (r'\s+', Whitespace),
+
+            include('comments'),
+
+            (r'[0-9]+', Number),
+            (words((
+                '+', '-', '*', '=', '?', '~', '.',
+                '^', '==', '<', '>', '<=', '>=', '!='
+            )), Operator),
+            (words(('##', '#<', '#<=')), Name.Tag),
+            (r'#[0-9a-f]*_?', Name.Tag),
+            (r'\$[01]*_?', Name.Tag),
+
+            (r'[a-zA-Z_][0-9a-zA-Z_]*', Name),
+
+            (r'[;():\[\]{}]', Punctuation)
+        ],
+
+        'comments': [
+            (r'//.*', Comment.Singleline),
+            (r'/\*', Comment.Multiline, 'comment'),
+        ],
+        'comment': [
+            (r'[^/*]+', Comment.Multiline),
+            (r'/\*', Comment.Multiline, '#push'),
+            (r'\*/', Comment.Multiline, '#pop'),
+            (r'[*/]', Comment.Multiline),
+        ],
+    }

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

@@ -4,7 +4,7 @@
 
     Lexer for Typographic Number Theory.
 
-    :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.
 """
 
@@ -20,14 +20,13 @@ __all__ = ['TNTLexer']
 class TNTLexer(Lexer):
     """
     Lexer for Typographic Number Theory, as described in the book
-    Gödel, Escher, Bach, by Douglas R. Hofstadter,
-    or as summarized here:
-    https://github.com/Kenny2github/language-tnt/blob/master/README.md#summary-of-tnt
+    Gödel, Escher, Bach, by Douglas R. Hofstadter
 
     .. versionadded:: 2.7
     """
 
     name = 'Typographic Number Theory'
+    url = 'https://github.com/Kenny2github/language-tnt'
     aliases = ['tnt']
     filenames = ['*.tnt']
 

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

@@ -4,12 +4,10 @@
 
     Lexer for RiverBed's TrafficScript (RTS) 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.
 """
 
-import re
-
 from pygments.lexer import RegexLexer
 from pygments.token import String, Number, Name, Keyword, Operator, Text, Comment
 
@@ -18,7 +16,7 @@ __all__ = ['RtsLexer']
 
 class RtsLexer(RegexLexer):
     """
-    For `Riverbed Stingray Traffic Manager <http://www.riverbed.com/stingray>`_
+    For Riverbed Stingray Traffic Manager
 
     .. versionadded:: 2.1
     """

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

@@ -13,7 +13,7 @@
     `TypoScriptHtmlDataLexer`
         Lexer that highlights markers, constants and registers within html tags.
 
-    :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.
 """
 
@@ -100,12 +100,11 @@ class TypoScriptLexer(RegexLexer):
     """
     Lexer for TypoScript code.
 
-    http://docs.typo3.org/typo3cms/TyposcriptReference/
-
     .. versionadded:: 2.2
     """
 
     name = 'TypoScript'
+    url = 'http://docs.typo3.org/typo3cms/TyposcriptReference/'
     aliases = ['typoscript']
     filenames = ['*.typoscript']
     mimetypes = ['text/x-typoscript']

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

@@ -0,0 +1,267 @@
+"""
+    pygments.lexers.ul4
+    ~~~~~~~~~~~~~~~~~~~
+
+    Lexer for the UL4 templating language.
+
+    More information: https://python.livinglogic.de/UL4.html
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, DelegatingLexer, bygroups, words, include
+from pygments.token import Comment, Text, Keyword, String, Number, Literal, \
+    Name, Other, Operator
+from pygments.lexers.web import HtmlLexer, XmlLexer, CssLexer, JavascriptLexer
+from pygments.lexers.python import PythonLexer
+
+__all__ = ['UL4Lexer', 'HTMLUL4Lexer', 'XMLUL4Lexer', 'CSSUL4Lexer',
+           'JavascriptUL4Lexer', 'PythonUL4Lexer']
+
+
+class UL4Lexer(RegexLexer):
+    """
+    Generic lexer for UL4.
+
+    .. versionadded:: 2.12
+    """
+
+    flags = re.MULTILINE | re.DOTALL
+
+    name = 'UL4'
+    aliases = ['ul4']
+    filenames = ['*.ul4']
+
+    tokens = {
+        "root": [
+            (
+                # Template header without name:
+                # ``<?ul4?>``
+                r"(<\?)(\s*)(ul4)(\s*)(\?>)",
+                bygroups(Comment.Preproc, Text.Whitespace, Keyword,
+                         Text.Whitespace, Comment.Preproc),
+            ),
+            (
+                # Template header with name (potentially followed by the signature):
+                # ``<?ul4 foo(bar=42)?>``
+                r"(<\?)(\s*)(ul4)(\s*)([a-zA-Z_][a-zA-Z_0-9]*)?",
+                bygroups(Comment.Preproc, Text.Whitespace, Keyword,
+                         Text.Whitespace, Name.Function),
+                "ul4", # Switch to "expression" mode
+            ),
+            (
+                # Comment:
+                # ``<?note foobar?>``
+                r"<\?\s*note\s.*?\?>",
+                Comment,
+            ),
+            (
+                # Template documentation:
+                # ``<?doc foobar?>``
+                r"<\?\s*doc\s.*?\?>",
+                String.Doc,
+            ),
+            (
+                # ``<?ignore?>`` tag for commenting out code:
+                # ``<?ignore?>...<?end ignore?>``
+                r"<\?\s*ignore\s*\?>",
+                Comment,
+                "ignore", # Switch to "ignore" mode
+            ),
+            (
+                # ``<?def?>`` tag for defining local templates
+                # ``<?def foo(bar=42)?>...<?end def?>``
+                r"(<\?)(\s*)(def)(\s*)([a-zA-Z_][a-zA-Z_0-9]*)?",
+                bygroups(Comment.Preproc, Text.Whitespace, Keyword,
+                         Text.Whitespace, Name.Function),
+                "ul4", # Switch to "expression" mode
+            ),
+            (
+                # The rest of the supported tags
+                r"(<\?)(\s*)(printx|print|for|if|elif|else|while|code|renderblocks?|render)\b",
+                bygroups(Comment.Preproc, Text.Whitespace, Keyword),
+                "ul4", # Switch to "expression" mode
+            ),
+            (
+                # ``<?end?>`` tag for ending ``<?def?>``, ``<?for?>``,
+                # ``<?if?>``, ``<?while?>``, ``<?renderblock?>`` and
+                # ``<?renderblocks?>`` blocks.
+                r"(<\?)(\s*)(end)\b",
+                bygroups(Comment.Preproc, Text.Whitespace, Keyword),
+                "end", # Switch to "end tag" mode
+            ),
+            (
+                # ``<?whitespace?>`` tag for configuring whitespace handlng
+                r"(<\?)(\s*)(whitespace)\b",
+                bygroups(Comment.Preproc, Text.Whitespace, Keyword),
+                "whitespace", # Switch to "whitespace" mode
+            ),
+            # Plain text
+            (r"[^<]+", Other),
+            (r"<", Other),
+        ],
+        # Ignore mode ignores everything upto the matching ``<?end ignore?>`` tag
+        "ignore": [
+            # Nested ``<?ignore?>`` tag
+            (r"<\?\s*ignore\s*\?>", Comment, "#push"),
+            # ``<?end ignore?>`` tag
+            (r"<\?\s*end\s+ignore\s*\?>", Comment, "#pop"),
+            # Everything else
+            (r"[^<]+", Comment),
+            (r".", Comment),
+        ],
+        # UL4 expressions
+        "ul4": [
+            # End the tag
+            (r"\?>", Comment.Preproc, "#pop"),
+            # Start triple quoted string constant
+            ("'''", String, "string13"),
+            ('"""', String, "string23"),
+            # Start single quoted string constant
+            ("'", String, "string1"),
+            ('"', String, "string2"),
+            # Floating point number
+            (r"\d+\.\d*([eE][+-]?\d+)?", Number.Float),
+            (r"\.\d+([eE][+-]?\d+)?", Number.Float),
+            (r"\d+[eE][+-]?\d+", Number.Float),
+            # Binary integer: ``0b101010``
+            (r"0[bB][01]+", Number.Bin),
+            # Octal integer: ``0o52``
+            (r"0[oO][0-7]+", Number.Oct),
+            # Hexadecimal integer: ``0x2a``
+            (r"0[xX][0-9a-fA-F]+", Number.Hex),
+            # Date or datetime: ``@(2000-02-29)``/``@(2000-02-29T12:34:56.987654)``
+            (r"@\(\d\d\d\d-\d\d-\d\d(T(\d\d:\d\d(:\d\d(\.\d{6})?)?)?)?\)", Literal.Date),
+            # Color: ``#fff``, ``#fff8f0`` etc.
+            (r"#[0-9a-fA-F]{8}", Literal.Color),
+            (r"#[0-9a-fA-F]{6}", Literal.Color),
+            (r"#[0-9a-fA-F]{3,4}", Literal.Color),
+            # Decimal integer: ``42``
+            (r"\d+", Number.Integer),
+            # Operators
+            (r"//|==|!=|>=|<=|<<|>>|\+=|-=|\*=|/=|//=|<<=|>>=|&=|\|=|^=|=|[\[\]{},:*/().~%&|<>^+-]", Operator),
+            # Keywords
+            (words(("for", "in", "if", "else", "not", "is", "and", "or"), suffix=r"\b"), Keyword),
+            # Builtin constants
+            (words(("None", "False", "True"), suffix=r"\b"), Keyword.Constant),
+            # Variable names
+            (r"[a-zA-Z_][a-zA-Z0-9_]*", Name),
+            # Whitespace
+            (r"\s+", Text.Whitespace),
+        ],
+        # ``<?end ...?>`` tag for closing the last open block
+        "end": [
+            (r"\?>", Comment.Preproc, "#pop"),
+            (words(("for", "if", "def", "while", "renderblock", "renderblocks"), suffix=r"\b"), Keyword),
+            (r"\s+", Text),
+        ],
+        # Content of the ``<?whitespace ...?>`` tag:
+        # ``keep``, ``strip`` or ``smart``
+        "whitespace": [
+            (r"\?>", Comment.Preproc, "#pop"),
+            (words(("keep", "strip", "smart"), suffix=r"\b"), Comment.Preproc),
+            (r"\s+", Text.Whitespace),
+        ],
+        # Inside a string constant
+        "stringescapes": [
+            (r"""\\[\\'"abtnfr]""", String.Escape),
+            (r"\\x[0-9a-fA-F]{2}", String.Escape),
+            (r"\\u[0-9a-fA-F]{4}", String.Escape),
+            (r"\\U[0-9a-fA-F]{8}", String.Escape),
+        ],
+        # Inside a triple quoted string started with ``'''``
+        "string13": [
+            (r"'''", String, "#pop"),
+            include("stringescapes"),
+            (r"[^\\']+", String),
+            (r'.', String),
+        ],
+        # Inside a triple quoted string started with ``"""``
+        "string23": [
+            (r'"""', String, "#pop"),
+            include("stringescapes"),
+            (r'[^\\"]+', String),
+            (r'.', String),
+        ],
+        # Inside a single quoted string started with ``'``
+        "string1": [
+            (r"'", String, "#pop"),
+            include("stringescapes"),
+            (r"[^\\']+", String),
+            (r'.', String),
+        ],
+        # Inside a single quoted string started with ``"``
+        "string2": [
+            (r'"', String, "#pop"),
+            include("stringescapes"),
+            (r'[^\\"]+', String),
+            (r'.', String),
+        ],
+    }
+
+class HTMLUL4Lexer(DelegatingLexer):
+    """
+    Lexer for UL4 embedded in HTML.
+    """
+
+    name = 'HTML+UL4'
+    aliases = ['html+ul4']
+    filenames = ['*.htmlul4']
+
+    def __init__(self, **options):
+        super().__init__(HtmlLexer, UL4Lexer, **options)
+
+
+class XMLUL4Lexer(DelegatingLexer):
+    """
+    Lexer for UL4 embedded in XML.
+    """
+
+    name = 'XML+UL4'
+    aliases = ['xml+ul4']
+    filenames = ['*.xmlul4']
+
+    def __init__(self, **options):
+        super().__init__(XmlLexer, UL4Lexer, **options)
+
+
+class CSSUL4Lexer(DelegatingLexer):
+    """
+    Lexer for UL4 embedded in CSS.
+    """
+
+    name = 'CSS+UL4'
+    aliases = ['css+ul4']
+    filenames = ['*.cssul4']
+
+    def __init__(self, **options):
+        super().__init__(CssLexer, UL4Lexer, **options)
+
+
+class JavascriptUL4Lexer(DelegatingLexer):
+    """
+    Lexer for UL4 embedded in Javascript.
+    """
+
+    name = 'Javascript+UL4'
+    aliases = ['js+ul4']
+    filenames = ['*.jsul4']
+
+    def __init__(self, **options):
+        super().__init__(JavascriptLexer, UL4Lexer, **options)
+
+
+class PythonUL4Lexer(DelegatingLexer):
+    """
+    Lexer for UL4 embedded in Python.
+    """
+
+    name = 'Python+UL4'
+    aliases = ['py+ul4']
+    filenames = ['*.pyul4']
+
+    def __init__(self, **options):
+        super().__init__(PythonLexer, UL4Lexer, **options)

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

@@ -4,7 +4,7 @@
 
     Lexers for the Icon and Unicon languages, including ucode VM.
 
-    :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/urbi.py

@@ -4,7 +4,7 @@
 
     Lexers for UrbiScript 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.
 """
 
@@ -51,7 +51,7 @@ class UrbiscriptLexer(ExtendedRegexLexer):
             ctx.pos += len(result)
             return
 
-        # if blob is well formated, yield as Escape
+        # if blob is well formatted, yield as Escape
         blob_text = blob_start + ctx.text[match.end():match.end()+blob_size] + ")"
         yield match.start(), String.Escape, blob_text
         ctx.pos = match.end() + blob_size + 1  # +1 is the ending ")"
@@ -78,9 +78,9 @@ class UrbiscriptLexer(ExtendedRegexLexer):
                 'struct', 'template', 'typedef', 'typeid', 'typename', 'union',
                 'unsigned', 'using', 'virtual', 'volatile', 'wchar_t'), suffix=r'\b'),
              Keyword.Reserved),
-            # deprecated keywords, use a meaningfull token when available
+            # deprecated keywords, use a meaningful token when available
             (r'(emit|foreach|internal|loopn|static)\b', Keyword),
-            # ignored keywords, use a meaningfull token when available
+            # ignored keywords, use a meaningful token when available
             (r'(private|protected|public)\b', Keyword),
             (r'(var|do|const|function|class)\b', Keyword.Declaration),
             (r'(true|false|nil|void)\b', Keyword.Constant),

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

@@ -4,7 +4,7 @@
 
     The module that parses Pixar's Universal Scene Description 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.
 """
 
@@ -35,6 +35,7 @@ class UsdLexer(RegexLexer):
     """
 
     name = "USD"
+    url = 'https://graphics.pixar.com/usd/release/index.html'
     aliases = ["usd", "usda"]
     filenames = ["*.usd", "*.usda"]