nano-clean-pkg 0.0.1

data/rouge-5.0.0/lib/rouge/lexers/abap/builtins.rb

@@ -0,0 +1,187 @@
+# ABAP keywords, builtins, RAP syntax and CDS syntax taken from 
+#
+# https://help.sap.com/doc/abapdocu_758_index_htm/7.58/en-US/index.htm?file=abenabap_shortref.htm
+# https://help.sap.com/doc/abapdocu_758_index_htm/7.58/en-us/abenbuilt_in_functions_overview.htm
+# https://help.sap.com/doc/abapdocu_758_index_htm/7.58/en-US/abencds_language_elements.htm
+# https://help.sap.com/doc/abapdocu_758_index_htm/7.58/en-us/abenabap_words.htm
+#
+# Updated with modern ABAP 7.40+ and CDS keywords from ABAP 7.58 documentation
+#
+# This file is manually maintained by Manuel Laggner <manuel@laggner.info>
+#
+# Please contact them with any requests for updates.
+
+module Rouge
+  module Lexers
+    class ABAP
+      KEYWORDS = Set.new %w(
+        *-INPUT ?TO ABAP-SOURCE ABBREVIATED ABS ABSTRACT ACCEPT ACCEPTING
+        ACCESS ACCORDING ACCP ACTION ACTIVATION ACTUAL ADD
+        ADD-CORRESPONDING ADJACENT ADJUST_NUMBERS AFTER ALIAS ALIASES ALIGN
+        ALL ALLOCATE ALLOW_PRECISION_LOSS ALLOWED ALPHA ANALYSIS ANALYZER
+        AMDP AND ANNOTATION ANNOTATIONS ANY APPEND APPENDAGE APPENDING
+        APPLICATION ARCHIVE AREA ARITHMETIC AS ASCENDING ASPECT ASSERT ASSIGN
+        ASSIGNED ASSIGNING ASSOCIATION ASSOCIATIONS ASYNCHRONOUS AT
+        ATTRIBUTES AUTHORITY AUTHORITY-CHECK AUTHORIZATION AUTO AVG BACK
+        BACKGROUND BACKUP BACKWARD BADI BASE BEFORE BEGIN BETWEEN BIG BINARY
+        BINTOHEX BIT BIT-AND BIT-NOT BIT-OR BIT-XOR BITFIELD BLACK BLANK
+        BLANKS BLOB BLOCK BLOCKED BLOCKS BLUE BOUND BOUNDARIES BOUNDS BOXED
+        BREAK-POINT BREAKUP BT BUFFER BULK BY BYPASSING BYTE BYTE-CA BYTE-CN
+        BYTE-CO BYTE-CS BYTE-NA BYTE-NS BYTE-ORDER CA CALL CALLING CASE CAST
+        CASTING CATCH CEIL CENTER CENTERED CHAIN CHAIN-INPUT CHAIN-REQUEST
+        CHANGE CHANGING CHANNELS CHAR CHAR-TO-HEX CHARACTER CHECK CHECKBOX
+        CHECK_BEFORE_SAVE CHILD CI_ CID CIRCULAR CLASS CLASS-CODING
+        CLASS-DATA CLASS-EVENTS CLASS-METHODS CLASS-POOL CDS CLEANUP
+        CLEANUP_FINALIZE CLEAR CLIENT CLIENTS CLNT CLOB CLOCK CLOSE CN CO
+        COALESCE CODE CODING COLLECT COLOR COLUMN COLUMNS COL_BACKGROUND
+        COL_GROUP COL_HEADING COL_KEY COL_NEGATIVE COL_NORMAL COL_POSITIVE
+        COL_TOTAL COMMENT COMMENTS COMMIT COMMON COMMUNICATION COMPARING
+        COMPONENT COMPONENTS COMPOSITION COMPRESSION COMPUTE CONCAT
+        CONCATENATE CONCAT_WITH_SPACE COND CONDENSE CONDITION CONNECT
+        CONNECTION CONSTANTS CONTEXT CONTEXTS CONTINUE CONTROL CONTROLS CONV
+        CONVERSION CONVERT COPIES COPY CORR CORR_SPEARMAN CORRESPONDING
+        CORRSPEARMAN COUNT COUNTRY COVER CP CPI CREATE CREATING CRITICAL CS
+        CUKY CURR CURRENCY CURRENCY_CONVERSION CURRENT CURSOR
+        CURSOR-SELECTION CUSTOMER CUSTOMER-FUNCTION DANGEROUS DATA DATABASE
+        DATAINFO DATASET DATE DATN DATN_ADD_DAYS DATN_ADD_MONTHS
+        DATN_DAYS_BETWEEN DATS DATS_ADD_DAYS DATS_ADD_MONTHS
+        DATS_DAYS_BETWEEN DATS_FROM_DATN DATS_IS_VALID DATS_TIMS_TO_TSTMP
+        DATS_TO_DATN DAYLIGHT DAYNAME DB2 DB6 DD/MM/YY DD/MM/YYYY DDMMYY
+        DEALLOCATE DEC DECFLOAT16 DECFLOAT16_DEC DECFLOAT34 DECFLOAT34_DEC
+        DECIMALS DECIMAL_SHIFT DECLARATIONS DEEP DEFAULT DEFERRED DEFINE
+        DEFINING DEFINITION DELETE DELETING DEMAND DENSE_RANK DEPARTMENT
+        DEPTH DESCENDING DESCRIBE DESTINATION DETAIL DETERMINATION DETERMINE
+        DETERMINISTIC DF16_DEC DF16_RAW DF16_SCL DF34_DEC DF34_RAW DF34_SCL
+        DIALOG DIRECTORY DISABLE DISCARDING DISCONNECT DISPLAY DISPLAY-MODE
+        DISTANCE DISTINCT DIV DIVIDE DIVIDE-CORRESPONDING DIVISION DO DUMMY
+        DUPLICATE DUPLICATES DURATION DURING DYNAMIC DYNPRO E EARLY EDIT
+        EDITOR-CALL ELSE ELSEIF EMPTY ENABLED ENABLING ENCODING END
+        END-ENHANCEMENT-SECTION END-LINES END-OF-DEFINITION END-OF-FILE
+        END-OF-EDITING END-OF-PAGE END-OF-SELECTION END-TEST-INJECTION
+        END-TEST-SEAM ENDAT ENDCASE ENDCATCH ENDCHAIN ENDCLASS ENDDO
+        ENDENHANCEMENT ENDEXEC ENDFORM ENDFUNCTION ENDIAN ENDIF ENDING
+        ENDINTERFACE ENDLOOP ENDMETHOD ENDMODULE ENDON ENDPROVIDE ENDSELECT
+        ENDTRY ENDWHILE ENDWITH ENGINEERING ENHANCEMENT ENHANCEMENT-POINT
+        ENHANCEMENT-SECTION ENHANCEMENTS ENTITIES ENTITY ENTRIES ENTRY ENUM
+        ENVIRONMENT EQ EQUIV ERROR ERRORMESSAGE ERRORS ESCAPE ESCAPING EVENT
+        EVENTS EXACT EXCEPT EXCEPTION EXCEPTION-TABLE EXCEPTIONS EXCLUDE
+        EXCLUDING EXEC EXECUTE EXISTS EXIT EXIT-COMMAND EXPAND EXPANDING
+        EXPIRATION EXPLICIT EXPONENT EXPORT EXPORTING EXTEND EXTENDED
+        EXTENSION EXTRACT EXTRACT_DAY EXTRACT_HOUR EXTRACT_MINUTE
+        EXTRACT_MONTH EXTRACT_SECOND EXTRACT_YEAR FAIL FETCH FIELD
+        FIELD-GROUPS FIELD-SYMBOL FIELD-SYMBOLS FIELDS FILE FILTER
+        FILTER-TABLE FILTERS FINAL FIND FIRST FIRST-LINE FIRST_VALUE
+        FIXED-POINT FKEQ FKGE FLOOR FLTP FLTP_TO_DEC FLUSH FOLLOWING FONT
+        FOR FORM FORMAT FORWARD FOUND FRAME FRAMES FREE FRIENDS FROM FULL
+        FUNCTION FUNCTION-POOL FUNCTIONALITY FURTHER GAPS GE GENERATE GET
+        GGM1 GEOM_EWKB GIVING GKEQ GKGE GLOBAL GRANT GRAPH GREEN GROUP
+        GROUPING GROUPS GT HANDLE HANDLER HARMLESS HASHED HAVING HDB
+        HEAD-LINES HEADER HEADERS HEADING HELP-ID HELP-REQUEST HEXTOBIN HIDE
+        HIERARCHY HIERARCHY_ANCESTORS HIERARCHY_ANCESTORS_AGGREGATE
+        HIERARCHY_DESCENDANTS HIERARCHY_DESCENDANTS_AGGREGATE
+        HIERARCHY_SIBLINGS HIGH HINT HOLD HOTSPOT I ICON ID IDENTIFICATION
+        IDENTIFIER IDS IF IGNORE IGNORING IMMEDIATELY IMPLEMENTATION
+        IMPLEMENTATIONS IMPLEMENTED IMPLICIT IMPORT IMPORTING IN INACTIVE
+        INCL INCLUDE INCLUDES INCLUDING INCREMENT INDEX INDEX-LINE INFOTYPES
+        INHERITING INIT INITIAL INITIALIZATION INNER INOUT INPUT INSERT
+        INSTANCE INSTANCES INSTR INT1 INT2 INT4 INT8 INTENSIFIED INTERFACE
+        INTERFACE-POOL INTERFACES INTERNAL INTERVALS INTO INVERSE
+        INVERTED-DATE IS ISO IS_VALID ITNO JOB JOIN KEEP KEEPING KERNEL KEY
+        KEYS KEYWORDS KIND LAG LANG LANGUAGE LAST LAST_VALUE LATE LAYOUT
+        LCHR LDB_PROCESS LE LEAD LEADING LEAVE LEFT LEFT-JUSTIFIED LEFTPLUS
+        LEFTSPACE LEGACY LENGTH LET LEVEL LEVELS LIKE LIKE_REGEXPR LINE
+        LINE-COUNT LINE-SELECTION LINE-SIZE LINEFEED LINES LIST
+        LIST-PROCESSING LISTBOX LITTLE LLANG LOAD LOAD-OF-PROGRAM LOB LOCAL
+        LOCALE LOCATE LOCATE_REGEXPR LOCATE_REGEXPR_AFTER LOCATOR LOCK
+        LOCKS LOG-POINT LOGFILE LOGICAL LONG LOOP LOW LOWER LPAD LPI LRAW
+        LT LTRIM M MAIL MAIN MAJOR-ID MANY MAP_MESSAGES MAPPING MARGIN MARK
+        MASK MATCH MATCH_RESULT MATCH_RESULT_TAB MATCHCODE MATCHED MAX
+        MAXIMUM MEASURES MEDIAN MEDIUM MEMBERS MEMORY MESH MESSAGE
+        MESSAGE-ID MESSAGES MESSAGING METHOD METHODS MIN MINIMUM MINOR-ID
+        MM/DD/YY MM/DD/YYYY MMDDYY MOD MODE MODIF MODIFIER MODIFY MODULE
+        MONTHNAME MOVE MOVE-CORRESPONDING MSSQLNT MULTIPLE MULTIPLY
+        MULTIPLY-CORRESPONDING NA NAME NAMETAB NATIVE NB NE NESTED NESTING
+        NEW NEW-LINE NEW-PAGE NEW-SECTION NEXT NO NO-DISPLAY NO-EXTENSION
+        NO-GAP NO-GAPS NO-GROUPING NO-HEADING NO-SCROLLING NO-SIGN NO-TITLE
+        NO-TOPOFPAGE NO-ZERO NODE NODES NON-UNICODE NON-UNIQUE NOT NP NS
+        NTILE NULL NULLS NUMBER NUMBERING NUMC O OBJECT OBJECTS OBLIGATORY
+        OCCURRENCE OCCURRENCES OCCURS OF OFF OFFSET ON ONE ONLY OPEN OPTION
+        OPTIONAL OPTIONS OR ORACLE ORDER ORPHANS OTHER OTHERS OUT OUTER
+        OUTPUT OUTPUT-LENGTH OVERFLOW OVERLAY PACK PACKAGE PAD PADDING PAGE
+        PAGES PARAMETER PARAMETER-TABLE PARAMETERS PARENT PARENTS PART
+        PARTIALLY PARTITION PATTERN PCRE PERCENTAGE PERFORM PERFORMING
+        PERSON PF PF-STATUS PINK PLACES POOL POSITION POS_HIGH POS_LOW
+        PRAGMAS PREC PRECEDING PRECOMPILED PREFERRED PRESERVING PRIMARY
+        PRINT PRINT-CONTROL PRIORITY PRIVATE PROCEDURE PROCESS PROGRAM
+        PROPERTY PROTECTED PROVIDE PUBLIC PUSH PUSHBUTTON PUT QUAN
+        QUEUE-ONLY QUICKINFO RADIOBUTTON RAISE RAISING RANGE RANGES RAW
+        RAWSTRING READ READ-ONLY READER RECEIVE RECEIVED RECEIVER RECEIVING
+        RED REDEFINITION REDUCE REDUCED REF REFERENCE REFRESH REGEX REJECT
+        RELATING REMOTE RENAMING REPLACE REPLACEMENT REPLACING REPORT
+        REPORTED REQUEST REQUESTED REQUIRED RESERVE RESET RESOLUTION
+        RESPECTING RESPONSE RESPONSES RESPONSIBLE RESULT RESULTS RESUMABLE
+        RESUME RETRY RETURN RETURNCODE RETURNING RETURNS RIGHT
+        RIGHT-JUSTIFIED RIGHTPLUS RIGHTSPACE RISK RMC_COMMUNICATION_FAILURE
+        RMC_INVALID_STATUS RMC_SYSTEM_FAILURE ROLE ROLLBACK ROUND ROW
+        ROW_NUMBER ROWS RPAD RTRIM RUN SAP SAP-SPOOL SAVING SCALAR
+        SCALE_PRESERVING SCALE_PRESERVING_SCIENTIFIC SCAN SCIENTIFIC
+        SCIENTIFIC_WITH_LEADING_ZERO SCHEMA SCREEN SCROLL SCROLL-BOUNDARY
+        SCROLLING SEARCH SECONDARY SECONDS SECTION SELECT SELECT-OPTIONS
+        SELECTION SELECTION-SCREEN SELECTION-SET SELECTION-SETS
+        SELECTION-TABLE SELECTIONS SEND SEPARATE SEPARATED SESSION SET SETS
+        SHARED SHIFT SHORT SHORTDUMP SHORTDUMP-ID SIBLINGS SIGN
+        SIGN_AS_POSTFIX SIMPLE SINGLE SIZE SKIP SKIPPING SMART SOME SORT
+        SORTABLE SORTED SOURCE SPACE SPANTREE SPECIFIED SPLIT SPOOL SPOTS
+        SQL SQLSCRIPT SSTRING STABLE STAMP STANDARD START START-OF-EDITING
+        START-OF-SELECTION STARTING STATE STATEMENT STATEMENTS STATIC
+        STATICS STATUSINFO STDDEV STEP-LOOP STEP STOP STRING STRING_AGG
+        STRUCTURE STRUCTURES STYLE SUBKEY SUBMATCH_RESULT
+        SUBMATCH_RESULT_TAB SUBMATCHES SUBMIT SUBROUTINE SUBSCREEN SUBSTRING
+        SUBSTRING_REGEXPR SUBTOTAL SUBTRACT SUBTRACT-CORRESPONDING SUFFIX
+        SUM SUMMARY SUMMING SUPPLIED SUPPLY SUPPRESS SWITCH SWITCHSTATES
+        SYMBOL SYBASE SYNCPOINTS SYNTAX SYNTAX-CHECK SYNTAX-TRACE SYST
+        SYSTEM-CALL SYSTEM-EXCEPTIONS SYSTEM-EXIT T000 TAB TABBED TABLE
+        TABLES TABLEVIEW TABSTRIP TARGET TASK TASKS TEST TEST-INJECTION
+        TEST-SEAM TESTING TEXT TEXTPOOL THEN THROW TIME TIMES TIMESTAMP
+        TIMEZONE TIMN TIMS TIMS_FROM_TIMN TIMS_IS_VALID TIMS_TO_TIMN TITLE
+        TITLE-LINES TITLEBAR TO TOKENIZATION TOKENS TOP-LINES TOP-OF-PAGE
+        TOTAL TRACE-ENTRY TRACE-FILE TRACE-TABLE TRAILING TRANSACTION
+        TRANSFER TRANSFORMATION TRANSLATE TRANSPORTING TRDIR TRMAC TRUNCATE
+        TRUNCATION TRY TSTMP_ADD_SECONDS TSTMP_CURRENT_UTCTIMESTAMP
+        TSTMP_IS_VALID TSTMP_SECONDS_BETWEEN TYPE TYPE-POOL TYPE-POOLS
+        TYPES ULINE UNASSIGN UNDER UNICODE UNION UNIQUE UNIT UNIT_CONVERSION
+        UNIX UNBLOCKED UNBOUNDED UNPACK UNTIL UNWIND UP UPDATE UPPER USER
+        USER-COMMAND USING UTF-8 VALID VALIDATE VALIDATION VALUE
+        VALUE-REQUEST VALUES VAR VARC VARY VARYING VERBATIM
+        VERIFICATION-MESSAGE VERSION VIA VIEW VISIBLE WAIT WARNING WEEKDAY
+        WHEN WHENEVER WHERE WHILE WIDTH WINDOW WINDOWS WITH WITH-HEADING
+        WITH-TITLE WITHOUT WORD WORK WORKSPACE WRITE WRITER XML XSD YELLOW
+        YES YYMMDD Z ZERO ZONE
+      )
+
+      BUILTINS = Set.new %w(
+        abs acos add_days add_months add_seconds asin atan attribute
+        bintohex bit-set boolc boolx cast ceil cfunc charlen char_off
+        class_constructor cmax cmin cnt coalesce concat concat_lines_of cond
+        cond-var condense constructor contains contains_any_not_of
+        contains_any_of conv corresponding cos cosh count count_any_not_of
+        count_any_of curr_to_decfloat_amount currency_conversion
+        current_utctimestamp datn_add_days datn_add_months datn_days_between
+        dats_from_datn dats_to_datn days_between dbmaxlen dbtab deserialize
+        distance div division escape exact exp filter find find_any_not_of
+        find_any_of find_end floor fltp_to_dec frac get_numeric_value
+        hextobin idx index insert ipow is_valid lines line_exists
+        line_index log log10 match matches mod new nmax nmin numofchar reduce
+        ref repeat replace replace_regexpr rescale reverse round
+        seconds_between segment serialize shift_left shift_right sign sin
+        sinh sqrt strlen substring substring_after substring_before
+        substring_from substring_to sum switch switch-var table_line tan tanh
+        tims_from_timn tims_to_timn to_lower to_mixed to_upper translate
+        trunc tstmp_to_dats tstmp_to_dst tstmp_to_tims tstmpl_from_utcl
+        tstmpl_to_utcl unit_conversion utcl_add_seconds utcl_current
+        utcl_seconds_between utclong_add utclong_current utclong_diff value
+        xsdbool xstrlen
+      )
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class ABAP < RegexLexer
+      title "ABAP"
+      desc "SAP - Advanced Business Application Programming"
+      tag 'abap'
+      filenames '*.abap'
+      mimetypes 'text/x-abap'
+
+      lazy { require_relative 'abap/builtins' }
+
+      TYPES = Set.new %w(
+        b c d decfloat16 decfloat34 f i int8 n p s t x
+        clike csequence decfloat string xstring
+      )
+
+      NEW_KEYWORDS = Set.new %w(DATA FIELD-SYMBOL)
+
+      state :root do
+        rule %r/\s+/m, Text
+
+        rule %r/(".*?$)/, Comment::Single
+        rule %r/(^\*.*?$)/, Comment::Single
+        rule %r/\d+/, Num::Integer
+
+        # String templates |...|
+        rule %r/\|/, Str::Interpol, :string_template
+
+        rule %r/('|`)/, Str::Single, :single_string
+
+        # CDS annotations: @KEYWORD.field
+        rule %r/(@)([A-Z][A-Za-z0-9_]*)(\.)([A-Za-z][A-Za-z0-9_]*)/ do |m|
+          token Operator, m[1]
+          if KEYWORDS.include? m[2].upcase
+            token Keyword, m[2]
+          else
+            token Name, m[2]
+          end
+          token Punctuation, m[3]
+          token Name, m[4]
+        end
+
+        # structure field access with dot (table.field should not highlight field as keyword)
+        # This must come before the general punctuation rule
+        # In dot-access patterns, treat both parts as names (even if they match keywords)
+        rule %r/([A-Za-z][A-Za-z0-9_]*)(\.)([A-Za-z][A-Za-z0-9_]*)/ do |m|
+          token Name, m[1]
+          token Punctuation, m[2]
+          token Name, m[3]
+        end
+        # Parameter names in function/method interfaces (word before =)
+        # Matches word followed by optional whitespace and =
+        # This handles EXPORTING/IMPORTING/CHANGING/TABLES/USING parameter names
+        rule %r/([A-Za-z][A-Za-z0-9_]*)(?=\s*=)/ do |m|
+          token Name, m[1]
+        end
+        rule %r/[\[\]\(\)\{\}\.,:]/, Punctuation
+
+        # builtins / new ABAP 7.40 keywords (@DATA(), ...)
+        rule %r/(->|=>)?([A-Za-z][A-Za-z0-9_\-]*)(\()/ do |m|
+          token Operator, m[1]
+
+          word = m[2]
+
+          if (NEW_KEYWORDS.include? word.upcase) && m[1].nil?
+            token Keyword, m[2]
+          elsif (BUILTINS.include? word.downcase) && m[1].nil?
+            token Name::Builtin, m[2]
+          else
+            token Name, m[2]
+          end
+
+          token Punctuation, m[3]
+        end
+
+        # hyphenated keywords (like NON-UNIQUE)
+        rule %r/[A-Za-z][A-Za-z0-9_]*(-[A-Za-z][A-Za-z0-9_]*)+/ do |m|
+          if KEYWORDS.include? m[0].upcase
+            token Keyword
+          else
+            token Name
+          end
+        end
+
+        # structure component access (variable-component should not be highlighted as keyword)
+        # this rule matches: word-word where the second part is lowercase or starts lowercase
+        rule %r/[A-Za-z][A-Za-z0-9_]*-[a-z][A-Za-z0-9_]*/, Name
+
+        # variable names starting with $ (like $session)
+        rule %r/\$[A-Za-z][A-Za-z0-9_]*/, Name
+
+        # keywords, types and normal text
+        rule %r/\w\w*/ do |m|
+          if KEYWORDS.include? m[0].upcase
+            token Keyword
+          elsif TYPES.include? m[0].downcase
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+
+        # operators
+        rule %r((->|->>|=>)), Operator
+        rule %r([-\*\+%/~=&\?<>!#\@\^]+), Operator
+
+      end
+
+      state :operators do
+        rule %r((->|->>|=>)), Operator
+        rule %r([-\*\+%/~=&\?<>!#\@\^]+), Operator
+      end
+
+      state :single_string do
+        rule %r/\\./, Str::Escape
+        rule %r/(''|``)/, Str::Escape
+        rule %r/['`]/, Str::Single, :pop!
+        rule %r/[^\\'`]+/, Str::Single
+      end
+
+      state :string_template do
+        rule %r/\{[^}]*\}/, Str::Interpol  # embedded expressions
+        rule %r/\|/, Str::Interpol, :pop!
+        rule %r/[^|{]+/, Str::Interpol
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,196 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Actionscript < RegexLexer
+      title "ActionScript"
+      desc "ActionScript"
+
+      tag 'actionscript'
+      aliases 'as', 'as3'
+      filenames '*.as'
+      mimetypes 'application/x-actionscript'
+
+      state :comments_and_whitespace do
+        rule %r/\s+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+      end
+
+      state :expr_start do
+        mixin :comments_and_whitespace
+
+        rule %r(/) do
+          token Str::Regex
+          goto :regex
+        end
+
+        rule %r/[{]/, Punctuation, :object
+
+        rule %r//, Text, :pop!
+      end
+
+      state :regex do
+        rule %r(/) do
+          token Str::Regex
+          goto :regex_end
+        end
+
+        rule %r([^/]\n), Error, :pop!
+
+        rule %r/\n/, Error, :pop!
+        rule %r/\[\^/, Str::Escape, :regex_group
+        rule %r/\[/, Str::Escape, :regex_group
+        rule %r/\\./, Str::Escape
+        rule %r{[(][?][:=<!]}, Str::Escape
+        rule %r/[{][\d,]+[}]/, Str::Escape
+        rule %r/[()?]/, Str::Escape
+        rule %r/./, Str::Regex
+      end
+
+      state :regex_end do
+        rule %r/[gim]+/, Str::Regex, :pop!
+        rule(//) { pop! }
+      end
+
+      state :regex_group do
+        # specially highlight / in a group to indicate that it doesn't
+        # close the regex
+        rule %r(/), Str::Escape
+
+        rule %r([^/]\n) do
+          token Error
+          pop! 2
+        end
+
+        rule %r/\]/, Str::Escape, :pop!
+        rule %r/\\./, Str::Escape
+        rule %r/./, Str::Regex
+      end
+
+      state :bad_regex do
+        rule %r/[^\n]+/, Error, :pop!
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          for in while do break return continue switch case default
+          if else throw try catch finally new delete typeof is
+          this with
+        )
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(var with function)
+      end
+
+      def self.reserved
+        @reserved ||= Set.new %w(
+          dynamic final internal native public protected private class const
+          override static package interface extends implements namespace
+          set get import include super flash_proxy object_proxy trace
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(true false null NaN Infinity undefined)
+      end
+
+      def self.builtins
+        @builtins ||= %w(
+          void Function Math Class
+          Object RegExp decodeURI
+          decodeURIComponent encodeURI encodeURIComponent
+          eval isFinite isNaN parseFloat parseInt this
+        )
+      end
+
+      id = /[$a-zA-Z_][a-zA-Z0-9_]*/
+
+      state :root do
+        rule %r/\A\s*#!.*?\n/m, Comment::Preproc, :statement
+        rule %r/\n/, Text, :statement
+        rule %r((?<=\n)(?=\s|/|<!--)), Text, :expr_start
+        mixin :comments_and_whitespace
+        rule %r(\+\+ | -- | ~ | && | \|\| | \\(?=\n) | << | >>>? | ===
+               | !== )x,
+          Operator, :expr_start
+        rule %r([:-<>+*%&|\^/!=]=?), Operator, :expr_start
+        rule %r/[(\[,]/, Punctuation, :expr_start
+        rule %r/;/, Punctuation, :statement
+        rule %r/[)\].]/, Punctuation
+
+        rule %r/[?]/ do
+          token Punctuation
+          push :ternary
+          push :expr_start
+        end
+
+        rule %r/[{}]/, Punctuation, :statement
+
+        rule id do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+            push :expr_start
+          elsif self.class.declarations.include? m[0]
+            token Keyword::Declaration
+            push :expr_start
+          elsif self.class.reserved.include? m[0]
+            token Keyword::Reserved
+          elsif self.class.constants.include? m[0]
+            token Keyword::Constant
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          else
+            token Name::Other
+          end
+        end
+
+        rule %r/\-?[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
+        rule %r/0x[0-9a-fA-F]+/, Num::Hex
+        rule %r/\-?[0-9]+/, Num::Integer
+        rule %r/"(\\\\|\\"|[^"])*"/, Str::Double
+        rule %r/'(\\\\|\\'|[^'])*'/, Str::Single
+      end
+
+      # braced parts that aren't object literals
+      state :statement do
+        rule %r/(#{id})(\s*)(:)/ do
+          groups Name::Label, Text, Punctuation
+        end
+
+        rule %r/[{}]/, Punctuation
+
+        mixin :expr_start
+      end
+
+      # object literals
+      state :object do
+        mixin :comments_and_whitespace
+        rule %r/[}]/ do
+          token Punctuation
+          goto :statement
+        end
+
+        rule %r/(#{id})(\s*)(:)/ do
+          groups Name::Attribute, Text, Punctuation
+          push :expr_start
+        end
+
+        rule %r/:/, Punctuation
+        mixin :root
+      end
+
+      # ternary expressions, where <id>: is not a label!
+      state :ternary do
+        rule %r/:/ do
+          token Punctuation
+          goto :expr_start
+        end
+
+        mixin :root
+      end
+    end
+  end
+end

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

@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Ada < RegexLexer
+      tag 'ada'
+      filenames '*.ada', '*.ads', '*.adb', '*.adc', '*.gpr'
+      mimetypes 'text/x-ada'
+
+      title 'Ada'
+      desc 'The Ada 2012 programming language'
+
+      # Ada identifiers are Unicode with underscores only allowed as separators.
+      ID = /[[:alpha:]](?:\p{Pc}?[[:alnum:]])*\b/
+
+      # Numerals can also contain underscores.
+      NUM = /\d(_?\d)*/
+      XNUM = /\h(_?\h)*/
+      EXP = /(E[-+]?#{NUM})?/i
+
+      # Return a hash mapping lower-case identifiers to token classes.
+      def self.idents
+        @idents ||= Hash.new(Name).tap do |h|
+          %w(
+            abort abstract accept access aliased all array at begin body
+            case constant declare delay delta digits do else elsif end
+            exception exit for generic goto if in interface is limited
+            loop new null of others out overriding parallel pragma private
+            protected raise range record renames requeue return reverse
+            select separate some synchronized tagged task terminate then
+            until use when while with
+          ).each {|w| h[w] = Keyword}
+
+          %w(abs and mod not or rem xor).each {|w| h[w] = Operator::Word}
+
+          %w(
+            entry function package procedure subtype type
+          ).each {|w| h[w] = Keyword::Declaration}
+
+          %w(
+            boolean character constraint_error duration float integer
+            natural positive long_float long_integer long_long_float
+            long_long_integer program_error short_float short_integer
+            short_short_integer storage_error string tasking_error
+            wide_character wide_string wide_wide_character
+            wide_wide_string
+          ).each {|w| h[w] = Name::Builtin}
+        end
+      end
+
+      state :whitespace do
+        rule %r{\s+}m, Text
+        rule %r{--.*$}, Comment::Single
+      end
+
+      state :dquote_string do
+        rule %r{[^"\n]+}, Literal::String::Double
+        rule %r{""}, Literal::String::Escape
+        rule %r{"}, Literal::String::Double, :pop!
+        rule %r{\n}, Error, :pop!
+      end
+
+      state :attr do
+        mixin :whitespace
+        rule ID, Name::Attribute, :pop!
+        rule %r{}, Text, :pop!
+      end
+
+      # Handle a dotted name immediately following a declaration keyword.
+      state :decl_name do
+        mixin :whitespace
+        rule %r{body\b}i, Keyword::Declaration  # package body Foo.Bar is...
+        rule %r{(#{ID})(\.)} do
+          groups Name::Namespace, Punctuation
+        end
+        # function "<=" (Left, Right: Type) is ...
+        rule %r{#{ID}|"(and|or|xor|/?=|<=?|>=?|\+|–|&\|/|mod|rem|\*?\*|abs|not)"},
+             Name::Function, :pop!
+        rule %r{}, Text, :pop!
+      end
+
+      # Handle a sequence of library unit names: with Ada.Foo, Ada.Bar;
+      #
+      # There's a chance we entered this state mistakenly since 'with'
+      # has multiple other uses in Ada (none of which are likely to
+      # appear at the beginning of a line). Try to bail as soon as
+      # possible if we see something suspicious like keywords.
+      #
+      # See ada_spec.rb for some examples.
+      state :libunit_name do
+        mixin :whitespace
+
+        rule ID do |m|
+          t = self.class.idents[m[0].downcase]
+          if t <= Name
+            # Convert all kinds of Name to namespaces in this context.
+            token Name::Namespace
+          else
+            # Yikes, we're not supposed to get a keyword in a library unit name!
+            # We probably entered this state by mistake, so try to fix it.
+            token t
+            if t == Keyword::Declaration
+              goto :decl_name
+            else
+              pop!
+            end
+          end
+        end
+
+        rule %r{[.,]}, Punctuation
+        rule %r{}, Text, :pop!
+      end
+
+      state :root do
+        mixin :whitespace
+
+        # String literals.
+        rule %r{'.'}, Literal::String::Char
+        rule %r{"[^"\n]*}, Literal::String::Double, :dquote_string
+
+        # Real literals.
+        rule %r{#{NUM}\.#{NUM}#{EXP}}, Literal::Number::Float
+        rule %r{#{NUM}##{XNUM}\.#{XNUM}##{EXP}}, Literal::Number::Float
+
+        # Integer literals.
+        rule %r{2#[01](_?[01])*##{EXP}}, Literal::Number::Bin
+        rule %r{8#[0-7](_?[0-7])*##{EXP}}, Literal::Number::Oct
+        rule %r{16##{XNUM}*##{EXP}}, Literal::Number::Hex
+        rule %r{#{NUM}##{XNUM}##{EXP}}, Literal::Number::Integer
+        rule %r{#{NUM}#\w+#}, Error
+        rule %r{#{NUM}#{EXP}}, Literal::Number::Integer
+
+        # Special constructs.
+        rule %r{'}, Punctuation, :attr
+        rule %r{<<#{ID}>>}, Name::Label
+
+        # Context clauses are tricky because the 'with' keyword is used
+        # for many purposes. Detect at beginning of the line only.
+        rule %r{^(?:(limited)(\s+))?(?:(private)(\s+))?(with)\b}i do
+          groups Keyword::Namespace, Text, Keyword::Namespace, Text, Keyword::Namespace
+          push :libunit_name
+        end
+
+        # Operators and punctuation characters.
+        rule %r{[+*/&<=>|]|-|=>|\.\.|\*\*|[:></]=|<<|>>|<>|@}, Operator
+        rule %r{[.,:;()\[\]]}, Punctuation
+
+        rule ID do |m|
+          t = self.class.idents[m[0].downcase]
+          token t
+          if t == Keyword::Declaration
+            push :decl_name
+          end
+        end
+
+        # Flag word-like things that don't match the ID pattern.
+        rule %r{\b(\p{Pc}|[[:alpha:]])\p{Word}*}, Error
+      end
+    end
+  end
+end