nano-clean-pkg 0.0.1

data/rouge-5.0.0/lib/rouge/lexers/d.rb

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class D < RegexLexer
+      tag 'd'
+      aliases 'dlang'
+      filenames '*.d', '*.di'
+      mimetypes 'application/x-dsrc', 'text/x-dsrc'
+
+      title "D"
+      desc 'The D programming language(dlang.org)'
+
+      keywords = %w(
+        abstract alias align asm assert auto body
+        break case cast catch class const continue
+        debug default delegate delete deprecated do else
+        enum export extern finally final foreach_reverse
+        foreach for function goto if immutable import
+        interface invariant inout in is lazy mixin
+        module new nothrow out override package pragma
+        private protected public pure ref return scope
+        shared static struct super switch synchronized
+        template this throw try typedef typeid typeof
+        union unittest version volatile while with
+        __gshared __traits __vector __parameters
+      )
+
+      keywords_type = %w(
+        bool byte cdouble cent cfloat char creal
+        dchar double float idouble ifloat int ireal
+        long real short ubyte ucent uint ulong
+        ushort void wchar
+      )
+
+      keywords_pseudo = %w(
+        __FILE__ __FILE_FULL_PATH__ __MODULE__ __LINE__ __FUNCTION__
+        __PRETTY_FUNCTION__ __DATE__ __EOF__ __TIME__ __TIMESTAMP__
+        __VENDOR__ __VERSION__
+      )
+
+      state :whitespace do
+        rule %r/\n/m, Text
+        rule %r/\s+/m, Text
+      end
+
+      state :root do
+        mixin :whitespace
+        # Comments
+        rule %r(//.*), Comment::Single
+        rule %r(/(\\\n)?[*](.|\n)*?[*](\\\n)?/), Comment::Multiline
+        rule %r(/\+), Comment::Multiline, :nested_comment
+        # Keywords
+        rule %r/(#{keywords.join('|')})\b/, Keyword
+        rule %r/(#{keywords_type.join('|')})\b/, Keyword::Type
+        rule %r/(false|true|null)\b/, Keyword::Constant
+        rule %r/(#{keywords_pseudo.join('|')})\b/, Keyword::Pseudo
+        rule %r/macro\b/, Keyword::Reserved
+        rule %r/(string|wstring|dstring|size_t|ptrdiff_t)\b/, Name::Builtin
+        # Literals
+        # HexFloat
+        rule %r/0[xX]([0-9a-fA-F_]*\.[0-9a-fA-F_]+|[0-9a-fA-F_]+)[pP][+\-]?[0-9_]+[fFL]?[i]?/, Num::Float
+        # DecimalFloat
+        rule %r/[0-9_]+(\.[0-9_]+[eE][+\-]?[0-9_]+|\.[0-9_]*|[eE][+\-]?[0-9_]+)[fFL]?[i]?/, Num::Float
+        rule %r/\.(0|[1-9][0-9_]*)([eE][+\-]?[0-9_]+)?[fFL]?[i]?/, Num::Float
+        # IntegerLiteral
+        # Binary
+        rule %r/0[Bb][01_]+/, Num::Bin
+        # Octal
+        # TODO: 0[0-7] isn't supported use octal![0-7] instead
+        rule %r/0[0-7_]+/, Num::Oct
+        # Hexadecimal
+        rule %r/0[xX][0-9a-fA-F_]+/, Num::Hex
+        # Decimal
+        rule %r/(0|[1-9][0-9_]*)([LUu]|Lu|LU|uL|UL)?/, Num::Integer
+        # CharacterLiteral
+        rule %r/'(\\['"?\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\&\w+;|.)'/, Str::Char
+        # StringLiteral
+        # WysiwygString
+        rule %r/r"[^"]*"[cwd]?/, Str
+        # Alternate WysiwygString
+        rule %r/`[^`]*`[cwd]?/, Str
+        # DoubleQuotedString
+        rule %r/"(\\\\|\\"|[^"])*"[cwd]?/, Str
+        # EscapeSequence
+        rule %r/\\(['\"?\\abfnrtv]|x[0-9a-fA-F]{2}|[0-7]{1,3}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|&\w+;)/, Str
+        # HexString
+        rule %r/x"[0-9a-fA-F_\s]*"[cwd]?/, Str
+        # DelimitedString
+        rule %r/q"\[/, Str, :delimited_bracket
+        rule %r/q"\(/, Str, :delimited_parenthesis
+        rule %r/q"</, Str, :delimited_angle
+        rule %r/q"\{/, Str, :delimited_curly
+        rule %r/q"([a-zA-Z_]\w*)\n.*?\n\1"/, Str
+        rule %r/q"(.).*?\1"/, Str
+        # TokenString
+        rule %r/q\{/, Str, :token_string
+        # Attributes
+        rule %r/@([a-zA-Z_]\w*)?/, Name::Decorator
+        # Tokens
+        rule %r`(~=|\^=|%=|\*=|==|!>=|!<=|!<>=|!<>|!<|!>|!=|>>>=|>>>|>>=|>>|>=|<>=|<>|<<=|<<|<=|\+\+|\+=|--|-=|\|\||\|=|&&|&=|\.\.\.|\.\.|/=)|[/.&|\-+<>!()\[\]{}?,;:$=*%^~]`, Punctuation
+        # Identifier
+        rule %r/[a-zA-Z_]\w*/, Name
+        # Line
+        rule %r/#line\s.*\n/, Comment::Special
+      end
+
+      state :nested_comment do
+        rule %r([^+/]+), Comment::Multiline
+        rule %r(/\+), Comment::Multiline, :push
+        rule %r(\+/), Comment::Multiline, :pop!
+        rule %r([+/]), Comment::Multiline
+      end
+
+      state :token_string do
+        rule %r/\{/, Punctuation, :token_string_nest
+        rule %r/\}/, Str, :pop!
+        mixin :root
+      end
+
+      state :token_string_nest do
+        rule %r/\{/, Punctuation, :push
+        rule %r/\}/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :delimited_bracket do
+        rule %r/[^\[\]]+/, Str
+        rule %r/\[/, Str, :delimited_inside_bracket
+        rule %r/\]"/, Str, :pop!
+      end
+
+      state :delimited_inside_bracket do
+        rule %r/[^\[\]]+/, Str
+        rule %r/\[/, Str, :push
+        rule %r/\]/, Str, :pop!
+      end
+
+      state :delimited_parenthesis do
+        rule %r/[^()]+/, Str
+        rule %r/\(/, Str, :delimited_inside_parenthesis
+        rule %r/\)"/, Str, :pop!
+      end
+
+      state :delimited_inside_parenthesis do
+        rule %r/[^()]+/, Str
+        rule %r/\(/, Str, :push
+        rule %r/\)/, Str, :pop!
+      end
+
+      state :delimited_angle do
+        rule %r/[^<>]+/, Str
+        rule %r/</, Str, :delimited_inside_angle
+        rule %r/>"/, Str, :pop!
+      end
+
+      state :delimited_inside_angle do
+        rule %r/[^<>]+/, Str
+        rule %r/</, Str, :push
+        rule %r/>/, Str, :pop!
+      end
+
+      state :delimited_curly do
+        rule %r/[^{}]+/, Str
+        rule %r/\{/, Str, :delimited_inside_curly
+        rule %r/\}"/, Str, :pop!
+      end
+
+      state :delimited_inside_curly do
+        rule %r/[^{}]+/, Str
+        rule %r/\{/, Str, :push
+        rule %r/\}/, Str, :pop!
+      end
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/dafny.rb

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Dafny < RegexLexer
+      title "Dafny"
+      desc "The Dafny programming language (github.com/dafny-lang/dafny)"
+      tag "dafny"
+      filenames "*.dfy"
+      mimetypes "text/x-dafny"
+
+      keywords = %w(
+        abstract allocated assert assume
+        break by
+        calc case class codatatype const constructor
+        datatype decreases downto
+        else ensures exists expect export extends
+        false for forall fresh function
+        ghost greatest
+        if import include invariant iterator
+        label least lemma
+        match method modifies modify module
+        nameonly new newtype null
+        old opened
+        predicate print provides
+        reads refines requires return returns reveal reveals
+        static
+        then this to trait true twostate type
+        unchanged
+        var
+        while witness
+        yield yields
+      )
+
+      literals = %w{ true false null }
+
+      textOperators = %w{ as is in }
+
+      types = %w(bool char int real string nat
+                 array array? object object? ORDINAL
+                 seq set iset map imap multiset )
+
+      idstart = /[0-9a-zA-Z?]/
+      idchar = /[0-9a-zA-Z_'?]/
+      id = /#{idstart}#{idchar}*/
+
+      arrayType = /array(?:1[0-9]+|[2-9][0-9]*)\??(?!#{idchar})/
+      bvType = /bv(?:0|[1-9][0-9]*)(?!#{idchar})/
+
+      digit = /\d/
+      digits = /#{digit}+(?:_#{digit}+)*/
+      bin_digits = /[01]+(?:_[01]+)*/
+      hex_digit = /(?:[0-9a-fA-F])/
+      hex_digits = /#{hex_digit}+(?:_#{hex_digit}+)*/
+
+      cchar = /(?:[^\\'\n\r]|\\["'ntr\\0])/
+      schar = /(?:[^\\"\n\r]|\\["'ntr\\0])/
+      uchar = /(?:\\u#{hex_digit}{4})/
+
+      ## IMPORTANT: Rules are ordered, which allows later rules to be
+      ## simpler than they would otherwise be
+      state :root do
+        rule %r(/\*), Comment::Multiline, :comment
+        rule %r(//.*?$), Comment::Single
+        rule %r(\*/), Error          # should not have closing comment in :root
+                                     # is an improperly nested comment
+
+        rule %r/'#{cchar}'/, Str::Char           # standard or escape char
+        rule %r/'#{uchar}'/, Str::Char           # unicode char
+        rule %r/'[^'\n\r]*'/, Error              # bad any other enclosed char
+        rule %r/'[^'\n\r]*$/, Error              # bad unclosed char
+
+        rule %r/"(?:#{schar}|#{uchar})*"/, Str::Double        # valid string
+        rule %r/".*"/, Error                     # anything else that is closed
+        rule %r/".*$/, Error                     # bad unclosed string
+
+        rule %r/@"([^"]|"")*"/, Str::Other     # valid verbatim string
+        rule %r/@".*/m, Error             # anything else , multiline unclosed
+
+
+        rule %r/#{digits}\.#{digits}(?!#{idchar})/, Num::Float
+        rule %r/0b#{bin_digits}(?!#{idchar})/, Num::Bin
+        rule %r/0b#{idchar}*/, Error
+        rule %r/0x#{hex_digits}(?!#{idchar})/, Num::Hex
+        rule %r/0x#{idchar}*/, Error
+        rule %r/#{digits}(?!#{idchar})/, Num::Integer
+        rule %r/_(?!#{idchar})/, Name
+        rule %r/_[0-9_]+[_]?(?!#{idchar})/, Error
+        rule %r/[0-9_]+_(?!#{idchar})/, Error
+        rule %r/[0-9]#{idchar}+/, Error
+
+        rule %r/#{arrayType}/, Keyword::Type
+        rule %r/#{bvType}/, Keyword::Type
+
+        rule id do |m|
+          if types.include?(m[0])
+            token Keyword::Type
+          elsif literals.include?(m[0])
+            token Keyword::Constant
+          elsif textOperators.include?(m[0])
+            token Operator::Word
+          elsif keywords.include?(m[0])
+            token Keyword::Reserved
+          else
+            token Name
+          end
+        end
+
+        rule %r/\.\./, Operator
+        rule %r/[*!%&<>\|^+=:.\/-]/, Operator
+        rule %r/[\[\](){},;`]/, Punctuation
+
+        rule %r/[^\S\n]+/, Text
+        rule %r/\n/, Text
+        rule %r/./, Error # Catchall
+      end
+
+      state :comment do
+        rule %r(\*/), Comment::Multiline, :pop!
+        rule %r(/\*), Comment::Multiline, :comment
+        rule %r([^*/]+), Comment::Multiline
+        rule %r(.), Comment::Multiline
+      end
+
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/dart.rb

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Dart < RegexLexer
+      title "Dart"
+      desc "The Dart programming language (dart.dev)"
+
+      tag 'dart'
+      filenames '*.dart'
+      mimetypes 'text/x-dart'
+
+      keywords = %w(
+        as assert await break case catch continue default do else finally for if
+        in is new rethrow return super switch this throw try while when with yield
+      )
+
+      declarations = %w(
+        abstract base async dynamic const covariant external extends factory final get implements
+        interface late native on operator required sealed set static sync typedef var
+      )
+
+      types = %w(bool Comparable double Dynamic enum Function int List Map Never Null num Object Pattern Record Set String Symbol Type Uri void)
+
+      imports = %w(import deferred export library part\s*of part source)
+
+      id = /[a-zA-Z_]\w*/
+
+      state :root do
+        rule %r(^
+          (\s*(?:[a-zA-Z_][a-zA-Z\d_.\[\]]*\s+)+?) # return arguments
+          ([a-zA-Z_]\w*)                           # method name
+          (\s*)(\()                                # signature start
+        )mx do |m|
+          # TODO: do this better, this shouldn't need a delegation
+          delegate Dart, m[1]
+          token Name::Function, m[2]
+          token Text, m[3]
+          token Punctuation, m[4]
+        end
+
+        rule %r/\s+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        rule %r/"/, Str, :dqs
+        rule %r/'/, Str, :sqs
+        rule %r/r""".*?"""/m, Str::Other
+        rule %r/r'''.*?'''/m, Str::Other
+        rule %r/r"[^"]*"/, Str::Other
+        rule %r/r'[^']*'/, Str::Other
+        rule %r/##{id}*/i, Str::Symbol
+        rule %r/@#{id}/, Name::Decorator
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword
+        rule %r/(?:#{declarations.join('|')})\b/, Keyword::Declaration
+        rule %r/(?:#{types.join('|')})\b/, Keyword::Type
+        rule %r/(?:true|false|null)\b/, Keyword::Constant
+        rule %r/(?:class|mixin)\b/, Keyword::Declaration, :class
+        rule %r/(?:#{imports.join('|')})\b/, Keyword::Namespace, :import
+        rule %r/(\.)(#{id})/ do
+          groups Operator, Name::Attribute
+        end
+
+        rule %r/#{id}:/, Name::Label
+        rule %r/\$?#{id}/, Name
+        rule %r/[~^*!%&\|+=:\/?-]/, Operator
+        rule %r/[\[\](){}<>\.,;]/, Punctuation
+        rule %r/\d*\.\d+([eE]\-?\d+)?/, Num::Float
+        rule %r/0x[\da-fA-F]+/, Num::Hex
+        rule %r/\d+L?/, Num::Integer
+        rule %r/\n/, Text
+      end
+
+      state :class do
+        rule %r/\s+/m, Text
+        rule id, Name::Class, :pop!
+      end
+
+      state :dqs do
+        rule %r/"/, Str, :pop!
+        rule %r/[^\\\$"]+/, Str
+        mixin :string
+      end
+
+      state :sqs do
+        rule %r/'/, Str, :pop!
+        rule %r/[^\\\$']+/, Str
+        mixin :string
+      end
+
+      state :import do
+        rule %r/;/, Operator, :pop!
+        rule %r/(?:show|hide)\b/, Keyword::Declaration
+        mixin :root
+      end
+
+      state :string do
+        mixin :interpolation
+        rule %r/\\[nrt\"\'\\]/, Str::Escape
+      end
+
+      state :interpolation do
+        rule %r/\$#{id}/, Str::Interpol
+        rule %r/\$\{[^\}]+\}/, Str::Interpol
+      end
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/datastudio.rb

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Datastudio < RegexLexer
+      tag 'datastudio'
+      filenames '*.job'
+      mimetypes 'text/x-datastudio'
+
+      title "Datastudio"
+      desc 'Datastudio scripting language'
+
+      id = /@?[_a-z]\w*/i
+
+      def self.sql_keywords
+        @sql_keywords ||= %w(
+          ABORT ABS ABSOLUTE ACCESS ADA ADD ADMIN AFTER AGGREGATE ALIAS
+          ALL ALLOCATE ALTER ANALYSE ANALYZE AND ANY ARE AS ASC ASENSITIVE
+          ASSERTION ASSIGNMENT ASYMMETRIC AT ATOMIC AUTHORIZATION
+          AVG BACKWARD BEFORE BEGIN BETWEEN BITVAR BIT_LENGTH BOTH
+          BREADTH BY C CACHE CALL CALLED CARDINALITY CASCADE CASCADED
+          CASE CAST CATALOG CATALOG_NAME CHAIN CHARACTERISTICS
+          CHARACTER_LENGTH CHARACTER_SET_CATALOG CHARACTER_SET_NAME
+          CHARACTER_SET_SCHEMA CHAR_LENGTH CHECK CHECKED CHECKPOINT
+          CLASS CLASS_ORIGIN CLOB CLOSE CLUSTER COALSECE COBOL COLLATE
+          COLLATION COLLATION_CATALOG COLLATION_NAME COLLATION_SCHEMA
+          COLUMN COLUMN_NAME COMMAND_FUNCTION COMMAND_FUNCTION_CODE
+          COMMENT COMMIT COMMITTED COMPLETION CONDITION_NUMBER
+          CONNECT CONNECTION CONNECTION_NAME CONSTRAINT CONSTRAINTS
+          CONSTRAINT_CATALOG CONSTRAINT_NAME CONSTRAINT_SCHEMA
+          CONSTRUCTOR CONTAINS CONTINUE CONVERSION CONVERT COPY
+          CORRESPONTING COUNT CREATE CREATEDB CREATEUSER CROSS CUBE
+          CURRENT CURRENT_DATE CURRENT_PATH CURRENT_ROLE CURRENT_TIME
+          CURRENT_TIMESTAMP CURRENT_USER CURSOR CURSOR_NAME CYCLE DATA
+          DATABASE DATETIME_INTERVAL_CODE DATETIME_INTERVAL_PRECISION
+          DAY DEALLOCATE DECLARE DEFAULT DEFAULTS DEFERRABLE DEFERRED
+          DEFINED DEFINER DELETE DELIMITER DELIMITERS DEREF DESC DESCRIBE
+          DESCRIPTOR DESTROY DESTRUCTOR DETERMINISTIC DIAGNOSTICS
+          DICTIONARY DISCONNECT DISPATCH DISTINCT DO DOMAIN DROP
+          DYNAMIC DYNAMIC_FUNCTION DYNAMIC_FUNCTION_CODE EACH ELSE
+          ENCODING ENCRYPTED END END-EXEC EQUALS ESCAPE EVERY EXCEPT
+          ESCEPTION EXCLUDING EXCLUSIVE EXEC EXECUTE EXISTING EXISTS
+          EXPLAIN EXTERNAL EXTRACT FALSE FETCH FINAL FIRST FOR FORCE
+          FOREIGN FORTRAN FORWARD FOUND FREE FREEZE FROM FULL FUNCTION
+          G GENERAL GENERATED GET GLOBAL GO GOTO GRANT GRANTED GROUP
+          GROUPING HANDLER HAVING HIERARCHY HOLD HOST IDENTITY IGNORE
+          ILIKE IMMEDIATE IMMUTABLE IMPLEMENTATION IMPLICIT IN INCLUDING
+          INCREMENT INDEX INDITCATOR INFIX INHERITS INITIALIZE INITIALLY
+          INNER INOUT INPUT INSENSITIVE INSERT INSTANTIABLE INSTEAD
+          INTERSECT INTO INVOKER IS ISNULL ISOLATION ITERATE JOIN KEY
+          KEY_MEMBER KEY_TYPE LANCOMPILER LANGUAGE LARGE LAST LATERAL
+          LEADING LEFT LENGTH LESS LEVEL LIKE LIMIT LISTEN LOAD LOCAL
+          LOCALTIME LOCALTIMESTAMP LOCATION LOCATOR LOCK LOWER MAP MATCH
+          MAX MAXVALUE MESSAGE_LENGTH MESSAGE_OCTET_LENGTH MESSAGE_TEXT
+          METHOD MIN MINUTE MINVALUE MOD MODE MODIFIES MODIFY MONTH
+          MORE MOVE MUMPS NAMES NATURAL NCLOB NEW NEXT
+          NO NOCREATEDB NOCREATEUSER NONE NOT NOTHING NOTIFY NOTNULL
+          NULL NULLABLE NULLIF OBJECT OCTET_LENGTH OF OFF OFFSET OIDS
+          OLD ON ONLY OPEN OPERATION OPERATOR OPTION OPTIONS OR ORDER
+          ORDINALITY OUT OUTER OUTPUT OVERLAPS OVERLAY OVERRIDING
+          OWNER PAD PARAMETER PARAMETERS PARAMETER_MODE PARAMATER_NAME
+          PARAMATER_ORDINAL_POSITION PARAMETER_SPECIFIC_CATALOG
+          PARAMETER_SPECIFIC_NAME PARAMATER_SPECIFIC_SCHEMA PARTIAL PASCAL
+          PENDANT PLACING PLI POSITION POSTFIX PREFIX PREORDER
+          PREPARE PRESERVE PRIMARY PRIOR PRIVILEGES PROCEDURAL PROCEDURE
+          PUBLIC READ READS RECHECK RECURSIVE REF REFERENCES REFERENCING
+          REINDEX RELATIVE RENAME REPEATABLE REPLACE RESET RESTART
+          RESTRICT RESULT RETURN RETURNED_LENGTH RETURNED_OCTET_LENGTH
+          RETURNED_SQLSTATE RETURNS REVOKE RIGHT ROLE ROLLBACK ROLLUP
+          ROUTINE ROUTINE_CATALOG ROUTINE_NAME ROUTINE_SCHEMA ROW ROWS
+          ROW_COUNT RULE SAVE_POINT SCALE SCHEMA SCHEMA_NAME SCOPE SCROLL
+          SEARCH SECOND SECURITY SELECT SELF SENSITIVE SERIALIZABLE
+          SERVER_NAME SESSION SESSION_USER SET SETOF SETS SHARE SHOW
+          SIMILAR SIMPLE SIZE SOME SOURCE SPACE SPECIFIC SPECIFICTYPE
+          SPECIFIC_NAME SQL SQLCODE SQLERROR SQLEXCEPTION SQLSTATE
+          SQLWARNINIG STABLE START STATE STATEMENT STATIC STATISTICS
+          STDIN STDOUT STORAGE STRICT STRUCTURE STYPE SUBCLASS_ORIGIN
+          SUBLIST SUBSTRING SUM SYMMETRIC SYSID SYSTEM SYSTEM_USER
+          TABLE TABLE_NAME  TEMP TEMPLATE TEMPORARY TERMINATE THAN THEN
+          TIMEZONE_HOUR TIMEZONE_MINUTE TO TOAST TRAILING
+          TRANSATION TRANSACTIONS_COMMITTED TRANSACTIONS_ROLLED_BACK
+          TRANSATION_ACTIVE TRANSFORM TRANSFORMS TRANSLATE TRANSLATION
+          TREAT TRIGGER TRIGGER_CATALOG TRIGGER_NAME TRIGGER_SCHEMA TRIM
+          TRUE TRUNCATE TRUSTED TYPE UNCOMMITTED UNDER UNENCRYPTED UNION
+          UNIQUE UNKNOWN UNLISTEN UNNAMED UNNEST UNTIL UPDATE UPPER
+          USAGE USER USER_DEFINED_TYPE_CATALOG USER_DEFINED_TYPE_NAME
+          USER_DEFINED_TYPE_SCHEMA USING VACUUM VALID VALIDATOR VALUES
+          VARIABLE VERBOSE VERSION VIEW VOLATILE WHEN WHENEVER WHERE
+          WITH WITHOUT WORK WRITE ZONE
+        )
+      end
+
+      state :whitespace do
+        rule %r/\s+/m, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
+      end
+
+      state :string do
+        rule %r/%(\\.|.)+?%/, Str::Escape
+        rule %r/\\"/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+        rule %r/./m, Str::Double
+      end
+
+      state :string_s do
+        rule %r/%(\\.|.)+?%/, Str::Escape
+        rule %r/\\'/, Str::Single
+        rule %r/'/, Str::Single, :pop!
+        rule %r/./m, Str::Single
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule %r/^:#{id}/, Name::Label
+        rule %r/@#{id}(\.#{id})?/m, Name::Entity
+        rule %r/%(\\.|.)+?%/, Name::Variable
+        rule %r/[~!%^&*()+=|\[\]{}:;,.<>\/?-]/, Punctuation
+        rule %r/"/, Str::Double, :string
+        rule %r/'/, Str::Single, :string_s
+        rule %r/\d(\.\d*)?/i, Num
+        rule %r/#{id}(?=\s*[(])/, Name::Function
+        rule id do |m|
+          name = m[0].upcase
+
+          if self.class.sql_keywords.include? name
+            token Keyword
+          else
+            token Name
+          end
+        end
+      end
+
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/diff.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Diff < RegexLexer
+      title 'diff'
+      desc 'Lexes unified diffs or patches'
+
+      tag 'diff'
+      aliases 'patch', 'udiff'
+      filenames '*.diff', '*.patch'
+      mimetypes 'text/x-diff', 'text/x-patch'
+
+      def self.detect?(text)
+        return true if text.start_with?('Index: ')
+        return true if text =~ %r(\Adiff[^\n]*?\ba/[^\n]*\bb/)
+        return true if text =~ /---.*?\n[+][+][+]/ || text =~ /[+][+][+].*?\n---/
+      end
+
+      state :root do
+        rule(/^ .*$\n?/, Text)
+        rule(/^---$\n?/, Punctuation)
+
+        rule %r(
+          (^\++.*$\n?) |
+          (^>+[ \t]+.*$\n?) |
+          (^>+$\n?)
+        )x, Generic::Inserted
+
+        rule %r(
+          (^-+.*$\n?) |
+          (^<+[ \t]+.*$\n?) |
+          (^<+$\n?)
+        )x, Generic::Deleted
+
+        rule(/^!.*$\n?/, Generic::Strong)
+        rule(/^([Ii]ndex|diff).*$\n?/, Generic::Heading)
+        rule(/^(@@[^@]*@@)([^\n]*\n)/) do
+          groups Punctuation, Text
+        end
+        rule(/^\w.*$\n?/, Punctuation)
+        rule(/^=.*$\n?/, Generic::Heading)
+        rule(/.+$\n?/, Text)
+      end
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/digdag.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'yaml'
+
+module Rouge
+  module Lexers
+    class Digdag < YAML
+      title 'digdag'
+      desc 'A simple, open source, multi-cloud workflow engine (https://www.digdag.io/)'
+      tag 'digdag'
+      filenames '*.dig'
+
+      mimetypes 'application/x-digdag'
+
+      # http://docs.digdag.io/operators.html
+      # as of digdag v0.9.10
+      KEYWORD_PATTERN = Regexp.union(%w(
+        call
+        require
+        loop
+        for_each
+        if
+        fail
+        echo
+
+        td
+        td_run
+        td_ddl
+        td_load
+        td_for_each
+        td_wait
+        td_wait_table
+        td_partial_delete
+        td_table_export
+
+        pg
+
+        mail
+        http
+        s3_wait
+        redshift
+        redshift_load
+        redshift_unload
+        emr
+
+        gcs_wait
+        bq
+        bq_ddl
+        bq_extract
+        bq_load
+
+        sh
+        py
+        rb
+        embulk
+      ).map { |name| "#{name}>"} + %w(
+        _do
+        _parallel
+      ))
+
+      prepend :block_nodes do
+        rule %r/(#{KEYWORD_PATTERN})(:)(?=\s|$)/ do |m|
+          groups Keyword::Reserved, Punctuation::Indicator
+          set_indent m[0], :implicit => true
+        end
+      end
+    end
+  end
+end