mumukit-content-type 1.11.1 → 1.12.1

data/vendor/bundle/ruby/2.7.0/gems/rouge-3.30.0/lib/rouge/lexers/apple_script.rb

@@ -0,0 +1,370 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class AppleScript < RegexLexer
+      title "AppleScript"
+      desc "The AppleScript scripting language by Apple Inc. (https://developer.apple.com/library/archive/documentation/AppleScript/Conceptual/AppleScriptLangGuide/introduction/ASLR_intro.html)"
+
+      tag 'applescript'
+      aliases 'applescript'
+
+      filenames '*.applescript', '*.scpt'
+
+      mimetypes 'application/x-applescript'
+
+      def self.literals
+        @literals ||= ['AppleScript', 'current application', 'false', 'linefeed',
+                       'missing value', 'pi','quote', 'result', 'return', 'space',
+                       'tab', 'text item delimiters', 'true', 'version']
+      end
+
+      def self.classes
+        @classes ||= ['alias ', 'application ', 'boolean ', 'class ', 'constant ',
+                      'date ', 'file ', 'integer ', 'list ', 'number ', 'POSIX file ',
+                      'real ', 'record ', 'reference ', 'RGB color ', 'script ',
+                      'text ', 'unit types', '(?:Unicode )?text', 'string']
+      end
+
+      def self.builtins
+        @builtins ||= ['attachment', 'attribute run', 'character', 'day', 'month',
+                       'paragraph', 'word', 'year']
+      end
+
+      def self.handler_params
+        @handler_params ||= ['about', 'above', 'against', 'apart from', 'around',
+                             'aside from', 'at', 'below', 'beneath', 'beside',
+                             'between', 'for', 'given', 'instead of', 'on', 'onto',
+                             'out of', 'over', 'since']
+      end
+
+      def self.commands
+        @commands ||= ['ASCII (character|number)', 'activate', 'beep', 'choose URL',
+                'choose application', 'choose color', 'choose file( name)?',
+                'choose folder', 'choose from list',
+                'choose remote application', 'clipboard info',
+                'close( access)?', 'copy', 'count', 'current date', 'delay',
+                'delete', 'display (alert|dialog)', 'do shell script',
+                'duplicate', 'exists', 'get eof', 'get volume settings',
+                'info for', 'launch', 'list (disks|folder)', 'load script',
+                'log', 'make', 'mount volume', 'new', 'offset',
+                'open( (for access|location))?', 'path to', 'print', 'quit',
+                'random number', 'read', 'round', 'run( script)?',
+                'say', 'scripting components',
+                'set (eof|the clipboard to|volume)', 'store script',
+                'summarize', 'system attribute', 'system info',
+                'the clipboard', 'time to GMT', 'write', 'quoted form']
+      end
+
+      def self.references
+        @references ||= ['(in )?back of', '(in )?front of', '[0-9]+(st|nd|rd|th)',
+                  'first', 'second', 'third', 'fourth', 'fifth', 'sixth',
+                  'seventh', 'eighth', 'ninth', 'tenth', 'after', 'back',
+                  'before', 'behind', 'every', 'front', 'index', 'last',
+                  'middle', 'some', 'that', 'through', 'thru', 'where', 'whose']
+      end
+
+      def self.operators
+        @operators ||= ["and", "or", "is equal", "equals", "(is )?equal to", "is not",
+                 "isn't", "isn't equal( to)?", "is not equal( to)?",
+                 "doesn't equal", "does not equal", "(is )?greater than",
+                 "comes after", "is not less than or equal( to)?",
+                 "isn't less than or equal( to)?", "(is )?less than",
+                 "comes before", "is not greater than or equal( to)?",
+                 "isn't greater than or equal( to)?",
+                 "(is  )?greater than or equal( to)?", "is not less than",
+                 "isn't less than", "does not come before",
+                 "doesn't come before", "(is )?less than or equal( to)?",
+                 "is not greater than", "isn't greater than",
+                 "does not come after", "doesn't come after", "starts? with",
+                 "begins? with", "ends? with", "contains?", "does not contain",
+                 "doesn't contain", "is in", "is contained by", "is not in",
+                 "is not contained by", "isn't contained by", "div", "mod",
+                 "not", "(a  )?(ref( to)?|reference to)", "is", "does"]
+      end
+
+      def self.controls
+        @controls ||= ['considering', 'else', 'error', 'exit', 'from', 'if',
+               'ignoring', 'in', 'repeat', 'tell', 'then', 'times', 'to',
+               'try', 'until', 'using terms from', 'while', 'whith',
+               'with timeout( of)?', 'with transaction', 'by', 'continue',
+               'end', 'its?', 'me', 'my', 'return', 'of' , 'as']
+      end
+
+      def self.declarations
+        @declarations ||= ['global', 'local', 'prop(erty)?', 'set', 'get']
+      end
+
+      def self.reserved
+        @reserved ||= ['but', 'put', 'returning', 'the']
+      end
+
+      def self.studio_classes
+        @studio_classes ||= ['action cell', 'alert reply', 'application', 'box',
+                     'browser( cell)?', 'bundle', 'button( cell)?', 'cell',
+                     'clip view', 'color well', 'color-panel',
+                     'combo box( item)?', 'control',
+                     'data( (cell|column|item|row|source))?', 'default entry',
+                     'dialog reply', 'document', 'drag info', 'drawer',
+                     'event', 'font(-panel)?', 'formatter',
+                     'image( (cell|view))?', 'matrix', 'menu( item)?', 'item',
+                     'movie( view)?', 'open-panel', 'outline view', 'panel',
+                     'pasteboard', 'plugin', 'popup button',
+                     'progress indicator', 'responder', 'save-panel',
+                     'scroll view', 'secure text field( cell)?', 'slider',
+                     'sound', 'split view', 'stepper', 'tab view( item)?',
+                     'table( (column|header cell|header view|view))',
+                     'text( (field( cell)?|view))?', 'toolbar( item)?',
+                     'user-defaults', 'view', 'window']
+      end
+
+      def self.studio_events
+        @studio_events ||= ['accept outline drop', 'accept table drop', 'action',
+                    'activated', 'alert ended', 'awake from nib', 'became key',
+                    'became main', 'begin editing', 'bounds changed',
+                    'cell value', 'cell value changed', 'change cell value',
+                    'change item value', 'changed', 'child of item',
+                    'choose menu item', 'clicked', 'clicked toolbar item',
+                    'closed', 'column clicked', 'column moved',
+                    'column resized', 'conclude drop', 'data representation',
+                    'deminiaturized', 'dialog ended', 'document nib name',
+                    'double clicked', 'drag( (entered|exited|updated))?',
+                    'drop', 'end editing', 'exposed', 'idle', 'item expandable',
+                    'item value', 'item value changed', 'items changed',
+                    'keyboard down', 'keyboard up', 'launched',
+                    'load data representation', 'miniaturized', 'mouse down',
+                    'mouse dragged', 'mouse entered', 'mouse exited',
+                    'mouse moved', 'mouse up', 'moved',
+                    'number of browser rows', 'number of items',
+                    'number of rows', 'open untitled', 'opened', 'panel ended',
+                    'parameters updated', 'plugin loaded', 'prepare drop',
+                    'prepare outline drag', 'prepare outline drop',
+                    'prepare table drag', 'prepare table drop',
+                    'read from file', 'resigned active', 'resigned key',
+                    'resigned main', 'resized( sub views)?',
+                    'right mouse down', 'right mouse dragged',
+                    'right mouse up', 'rows changed', 'scroll wheel',
+                    'selected tab view item', 'selection changed',
+                    'selection changing', 'should begin editing',
+                    'should close', 'should collapse item',
+                    'should end editing', 'should expand item',
+                    'should open( untitled)?',
+                    'should quit( after last window closed)?',
+                    'should select column', 'should select item',
+                    'should select row', 'should select tab view item',
+                    'should selection change', 'should zoom', 'shown',
+                    'update menu item', 'update parameters',
+                    'update toolbar item', 'was hidden', 'was miniaturized',
+                    'will become active', 'will close', 'will dismiss',
+                    'will display browser cell', 'will display cell',
+                    'will display item cell', 'will display outline cell',
+                    'will finish launching', 'will hide', 'will miniaturize',
+                    'will move', 'will open', 'will pop up', 'will quit',
+                    'will resign active', 'will resize( sub views)?',
+                    'will select tab view item', 'will show', 'will zoom',
+                    'write to file', 'zoomed']
+      end
+
+      def self.studio_commands
+        @studio_commands ||= ['animate', 'append', 'call method', 'center',
+                      'close drawer', 'close panel', 'display',
+                      'display alert', 'display dialog', 'display panel', 'go',
+                      'hide', 'highlight', 'increment', 'item for',
+                      'load image', 'load movie', 'load nib', 'load panel',
+                      'load sound', 'localized string', 'lock focus', 'log',
+                      'open drawer', 'path for', 'pause', 'perform action',
+                      'play', 'register', 'resume', 'scroll', 'select( all)?',
+                      'show', 'size to fit', 'start', 'step back',
+                      'step forward', 'stop', 'synchronize', 'unlock focus',
+                      'update']
+      end
+
+      def self.studio_properties
+        @studio_properties ||= ['accepts arrow key', 'action method', 'active',
+                        'alignment', 'allowed identifiers',
+                        'allows branch selection', 'allows column reordering',
+                        'allows column resizing', 'allows column selection',
+                        'allows customization', 'allows editing text attributes',
+                        'allows empty selection', 'allows mixed state',
+                        'allows multiple selection', 'allows reordering',
+                        'allows undo', 'alpha( value)?', 'alternate image',
+                        'alternate increment value', 'alternate title',
+                        'animation delay', 'associated file name',
+                        'associated object', 'auto completes', 'auto display',
+                        'auto enables items', 'auto repeat', 'auto resizes( outline column)?',
+                        'auto save expanded items', 'auto save name',
+                        'auto save table columns', 'auto saves configuration',
+                        'auto scroll', 'auto sizes all columns to fit',
+                        'auto sizes cells', 'background color', 'bezel state',
+                        'bezel style', 'bezeled', 'border rect', 'border type',
+                        'bordered', 'bounds( rotation)?', 'box type',
+                        'button returned', 'button type',
+                        'can choose directories', 'can choose files', 'can draw', 'can hide',
+                        'cell( (background color|size|type))?', 'characters',
+                        'class', 'click count', 'clicked( data)? column',
+                        'clicked data item', 'clicked( data)? row',
+                        'closeable', 'collating', 'color( (mode|panel))',
+                        'command key down', 'configuration',
+                        'content(s| (size|view( margins)?))?', 'context',
+                        'continuous', 'control key down', 'control size',
+                        'control tint', 'control view',
+                        'controller visible', 'coordinate system',
+                        'copies( on scroll)?', 'corner view', 'current cell',
+                        'current column', 'current( field)?  editor',
+                        'current( menu)? item', 'current row',
+                        'current tab view item', 'data source',
+                        'default identifiers', 'delta (x|y|z)',
+                        'destination window', 'directory', 'display mode',
+                        'displayed cell', 'document( (edited|rect|view))?',
+                        'double value', 'dragged column', 'dragged distance',
+                        'dragged items', 'draws( cell)? background',
+                        'draws grid', 'dynamically scrolls', 'echos bullets',
+                        'edge', 'editable', 'edited( data)? column',
+                        'edited data item', 'edited( data)? row', 'enabled',
+                        'enclosing scroll view', 'ending page',
+                        'error handling', 'event number', 'event type',
+                        'excluded from windows menu', 'executable path',
+                        'expanded', 'fax number', 'field editor', 'file kind',
+                        'file name', 'file type', 'first responder',
+                        'first visible column', 'flipped', 'floating',
+                        'font( panel)?', 'formatter', 'frameworks path',
+                        'frontmost', 'gave up', 'grid color', 'has data items',
+                        'has horizontal ruler', 'has horizontal scroller',
+                        'has parent data item', 'has resize indicator',
+                        'has shadow', 'has sub menu', 'has vertical ruler',
+                        'has vertical scroller', 'header cell', 'header view',
+                        'hidden', 'hides when deactivated', 'highlights by',
+                        'horizontal line scroll', 'horizontal page scroll',
+                        'horizontal ruler view', 'horizontally resizable',
+                        'icon image', 'id', 'identifier',
+                        'ignores multiple clicks',
+                        'image( (alignment|dims when disabled|frame style|scaling))?',
+                        'imports graphics', 'increment value',
+                        'indentation per level', 'indeterminate', 'index',
+                        'integer value', 'intercell spacing', 'item height',
+                        'key( (code|equivalent( modifier)?|window))?',
+                        'knob thickness', 'label', 'last( visible)? column',
+                        'leading offset', 'leaf', 'level', 'line scroll',
+                        'loaded', 'localized sort', 'location', 'loop mode',
+                        'main( (bunde|menu|window))?', 'marker follows cell',
+                        'matrix mode', 'maximum( content)? size',
+                        'maximum visible columns',
+                        'menu( form representation)?', 'miniaturizable',
+                        'miniaturized', 'minimized image', 'minimized title',
+                        'minimum column width', 'minimum( content)? size',
+                        'modal', 'modified', 'mouse down state',
+                        'movie( (controller|file|rect))?', 'muted', 'name',
+                        'needs display', 'next state', 'next text',
+                        'number of tick marks', 'only tick mark values',
+                        'opaque', 'open panel', 'option key down',
+                        'outline table column', 'page scroll', 'pages across',
+                        'pages down', 'palette label', 'pane splitter',
+                        'parent data item', 'parent window', 'pasteboard',
+                        'path( (names|separator))?', 'playing',
+                        'plays every frame', 'plays selection only', 'position',
+                        'preferred edge', 'preferred type', 'pressure',
+                        'previous text', 'prompt', 'properties',
+                        'prototype cell', 'pulls down', 'rate',
+                        'released when closed', 'repeated',
+                        'requested print time', 'required file type',
+                        'resizable', 'resized column', 'resource path',
+                        'returns records', 'reuses columns', 'rich text',
+                        'roll over', 'row height', 'rulers visible',
+                        'save panel', 'scripts path', 'scrollable',
+                        'selectable( identifiers)?', 'selected cell',
+                        'selected( data)? columns?', 'selected data items?',
+                        'selected( data)? rows?', 'selected item identifier',
+                        'selection by rect', 'send action on arrow key',
+                        'sends action when done editing', 'separates columns',
+                        'separator item', 'sequence number', 'services menu',
+                        'shared frameworks path', 'shared support path',
+                        'sheet', 'shift key down', 'shows alpha',
+                        'shows state by', 'size( mode)?',
+                        'smart insert delete enabled', 'sort case sensitivity',
+                        'sort column', 'sort order', 'sort type',
+                        'sorted( data rows)?', 'sound', 'source( mask)?',
+                        'spell checking enabled', 'starting page', 'state',
+                        'string value', 'sub menu', 'super menu', 'super view',
+                        'tab key traverses cells', 'tab state', 'tab type',
+                        'tab view', 'table view', 'tag', 'target( printer)?',
+                        'text color', 'text container insert',
+                        'text container origin', 'text returned',
+                        'tick mark position', 'time stamp',
+                        'title(d| (cell|font|height|position|rect))?',
+                        'tool tip', 'toolbar', 'trailing offset', 'transparent',
+                        'treat packages as directories', 'truncated labels',
+                        'types', 'unmodified characters', 'update views',
+                        'use sort indicator', 'user defaults',
+                        'uses data source', 'uses ruler', 'uses threaded animation',
+                        'uses title from previous column', 'value wraps', 'version',
+                        'vertical( (line scroll|page scroll|ruler view))?', 'vertically resizable', 'view',
+                        'visible( document rect)?', 'volume', 'width', 'window',
+                        'windows menu', 'wraps', 'zoomable', 'zoomed']
+      end
+
+      operators = %r(\b(#{self.operators.to_a.join('|')})\b)
+      classes = %r(\b(as )(#{self.classes.to_a.join('|')})\b)
+      literals = %r(\b(#{self.literals.to_a.join('|')})\b)
+      commands = %r(\b(#{self.commands.to_a.join('|')})\b)
+      controls = %r(\b(#{self.controls.to_a.join('|')})\b)
+      declarations = %r(\b(#{self.declarations.to_a.join('|')})\b)
+      reserved = %r(\b(#{self.reserved.to_a.join('|')})\b)
+      builtins = %r(\b(#{self.builtins.to_a.join('|')})s?\b)
+      handler_params = %r(\b(#{self.handler_params.to_a.join('|')})\b)
+      references = %r(\b(#{self.references.to_a.join('|')})\b)
+      studio_properties = %r(\b(#{self.studio_properties.to_a.join('|')})\b)
+      studio_classes = %r(\b(#{self.studio_classes.to_a.join('|')})s?\b)
+      studio_commands = %r(\b(#{self.studio_commands.to_a.join('|')})\b)
+      identifiers = %r(\b([a-zA-Z]\w*)\b)
+
+      state :root do
+        rule %r/\s+/, Text::Whitespace
+        rule %r/¬\n/, Literal::String::Escape
+        rule %r/'s\s+/, Text
+        rule %r/(--|#).*?$/, Comment::Single
+        rule %r/\(\*/, Comment::Multiline
+        rule %r/[\(\){}!,.:]/, Punctuation
+        rule %r/(«)([^»]+)(»)/ do |match|
+          token Text, match[1]
+          token Name::Builtin, match[2]
+          token Text, match[3]
+        end
+        rule %r/\b((?:considering|ignoring)\s*)(application responses|case|diacriticals|hyphens|numeric strings|punctuation|white space)/ do |match|
+          token Keyword, match[1]
+          token Name::Builtin, match[2]
+        end
+        rule %r/(-|\*|\+|&|≠|>=?|<=?|=|≥|≤|\/|÷|\^)/, Operator
+        rule operators, Operator::Word
+        rule %r/^(\s*(?:on|end)\s+)'r'(%s)/ do |match|
+          token Keyword, match[1]
+          token Name::Function, match[2]
+        end
+        rule %r/^(\s*)(in|on|script|to)(\s+)/ do |match|
+          token Text, match[1]
+          token Keyword, match[2]
+          token Text, match[3]
+        end
+        rule classes do |match|
+          token Keyword, match[1]
+          token Name::Class, match[2]
+        end
+        rule literals, Name::Builtin
+        rule commands, Name::Builtin
+        rule controls, Keyword
+        rule declarations, Keyword
+        rule reserved, Name::Builtin
+        rule builtins, Name::Builtin
+        rule handler_params, Name::Builtin
+        rule studio_properties, Name::Attribute
+        rule studio_classes, Name::Builtin
+        rule studio_commands, Name::Builtin
+        rule references, Name::Builtin
+        rule %r/"(\\\\|\\"|[^"])*"/, Literal::String::Double
+        rule identifiers, Name::Variable
+        rule %r/[-+]?(\d+\.\d*|\d*\.\d+)(E[-+][0-9]+)?/, Literal::Number::Float
+        rule %r/[-+]?\d+/, Literal::Number::Integer
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rouge-3.30.0/lib/rouge/lexers/c.rb

@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class C < RegexLexer
+      tag 'c'
+      filenames '*.c', '*.h', '*.idc'
+      mimetypes 'text/x-chdr', 'text/x-csrc'
+
+      title "C"
+      desc "The C programming language"
+
+      # optional comment or whitespace
+      ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
+      id = /[a-zA-Z_][a-zA-Z0-9_]*/
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          auto break case const continue default do else enum extern
+          for goto if register restricted return sizeof static struct
+          switch typedef union volatile virtual while
+
+          _Alignas _Alignof _Atomic _Generic _Imaginary
+          _Noreturn _Static_assert _Thread_local
+        )
+      end
+
+      def self.keywords_type
+        @keywords_type ||= Set.new %w(
+          int long float short double char unsigned signed void
+
+          jmp_buf FILE DIR div_t ldiv_t mbstate_t sig_atomic_t fpos_t
+          clock_t time_t va_list size_t ssize_t off_t wchar_t ptrdiff_t
+          wctrans_t wint_t wctype_t
+
+          _Bool _Complex int8_t int16_t int32_t int64_t
+          uint8_t uint16_t uint32_t uint64_t int_least8_t
+          int_least16_t int_least32_t int_least64_t
+          uint_least8_t uint_least16_t uint_least32_t
+          uint_least64_t int_fast8_t int_fast16_t int_fast32_t
+          int_fast64_t uint_fast8_t uint_fast16_t uint_fast32_t
+          uint_fast64_t intptr_t uintptr_t intmax_t
+          uintmax_t
+
+          char16_t char32_t
+        )
+      end
+
+      def self.reserved
+        @reserved ||= Set.new %w(
+          __asm __int8 __based __except __int16 __stdcall __cdecl
+          __fastcall __int32 __declspec __finally __int61 __try __leave
+          inline _inline __inline naked _naked __naked restrict _restrict
+          __restrict thread _thread __thread typename _typename __typename
+        )
+      end
+
+      def self.builtins
+        @builtins ||= []
+      end
+
+      start { push :bol }
+
+      state :expr_bol do
+        mixin :inline_whitespace
+
+        rule %r/#if\s0/, Comment, :if_0
+        rule %r/#/, Comment::Preproc, :macro
+
+        rule(//) { pop! }
+      end
+
+      # :expr_bol is the same as :bol but without labels, since
+      # labels can only appear at the beginning of a statement.
+      state :bol do
+        rule %r/#{id}:(?!:)/, Name::Label
+        mixin :expr_bol
+      end
+
+      state :inline_whitespace do
+        rule %r/[ \t\r]+/, Text
+        rule %r/\\\n/, Text # line continuation
+        rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
+      end
+
+      state :whitespace do
+        rule %r/\n+/m, Text, :bol
+        rule %r(//(\\.|.)*?$), Comment::Single, :bol
+        mixin :inline_whitespace
+      end
+
+      state :expr_whitespace do
+        rule %r/\n+/m, Text, :expr_bol
+        mixin :whitespace
+      end
+
+      state :statements do
+        mixin :whitespace
+        rule %r/(u8|u|U|L)?"/, Str, :string
+        rule %r((u8|u|U|L)?'(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\'\n])')i, Str::Char
+        rule %r((\d+[.]\d*|[.]?\d+)e[+-]?\d+[lu]*)i, Num::Float
+        rule %r(\d+e[+-]?\d+[lu]*)i, Num::Float
+        rule %r/0x[0-9a-f]+[lu]*/i, Num::Hex
+        rule %r/0[0-7]+[lu]*/i, Num::Oct
+        rule %r/\d+[lu]*/i, Num::Integer
+        rule %r(\*/), Error
+        rule %r([~!%^&*+=\|?:<>/-]), Operator
+        rule %r/[()\[\],.;]/, Punctuation
+        rule %r/\bcase\b/, Keyword, :case
+        rule %r/(?:true|false|NULL)\b/, Name::Builtin
+        rule id do |m|
+          name = m[0]
+
+          if self.class.keywords.include? name
+            token Keyword
+          elsif self.class.keywords_type.include? name
+            token Keyword::Type
+          elsif self.class.reserved.include? name
+            token Keyword::Reserved
+          elsif self.class.builtins.include? name
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+      end
+
+      state :case do
+        rule %r/:/, Punctuation, :pop!
+        mixin :statements
+      end
+
+      state :root do
+        mixin :expr_whitespace
+        rule %r(
+          ([\w*\s]+?[\s*]) # return arguments
+          (#{id})          # function name
+          (\s*\([^;]*?\))  # signature
+          (#{ws}?)({|;)    # open brace or semicolon
+        )mx do |m|
+          # TODO: do this better.
+          recurse m[1]
+          token Name::Function, m[2]
+          recurse m[3]
+          recurse m[4]
+          token Punctuation, m[5]
+          if m[5] == ?{
+            push :function
+          end
+        end
+        rule %r/\{/, Punctuation, :function
+        mixin :statements
+      end
+
+      state :function do
+        mixin :whitespace
+        mixin :statements
+        rule %r/;/, Punctuation
+        rule %r/{/, Punctuation, :function
+        rule %r/}/, Punctuation, :pop!
+      end
+
+      state :string do
+        rule %r/"/, Str, :pop!
+        rule %r/\\([\\abfnrtv"']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})/, Str::Escape
+        rule %r/[^\\"\n]+/, Str
+        rule %r/\\\n/, Str
+        rule %r/\\/, Str # stray backslash
+      end
+
+      state :macro do
+        mixin :include
+        rule %r([^/\n\\]+), Comment::Preproc
+        rule %r/\\./m, Comment::Preproc
+        mixin :inline_whitespace
+        rule %r(/), Comment::Preproc
+        # NB: pop! goes back to :bol
+        rule %r/\n/, Comment::Preproc, :pop!
+      end
+
+      state :include do
+        rule %r/(include)(\s*)(<[^>]+>)([^\n]*)/ do
+          groups Comment::Preproc, Text, Comment::PreprocFile, Comment::Single
+        end
+        rule %r/(include)(\s*)("[^"]+")([^\n]*)/ do
+          groups Comment::Preproc, Text, Comment::PreprocFile, Comment::Single
+        end
+      end
+
+      state :if_0 do
+        # NB: no \b here, to cover #ifdef and #ifndef
+        rule %r/^\s*#if/, Comment, :if_0
+        rule %r/^\s*#\s*el(?:se|if)/, Comment, :pop!
+        rule %r/^\s*#\s*endif\b.*?(?<!\\)\n/m, Comment, :pop!
+        rule %r/.*?\n/, Comment
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rouge-3.30.0/lib/rouge/lexers/ceylon.rb

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Ceylon < RegexLexer
+      tag 'ceylon'
+      filenames '*.ceylon'
+      mimetypes 'text/x-ceylon'
+
+      title "Ceylon"
+      desc 'Say more, more clearly.'
+
+      state :whitespace do
+        rule %r([^\S\n]+), Text
+        rule %r(//.*?\n), Comment::Single
+        rule %r(/\*), Comment::Multiline
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule %r((shared|abstract|formal|default|actual|variable|deprecated|small|
+          late|literal|doc|by|see|throws|optional|license|tagged|final|native|
+          annotation|sealed)\b), Name::Decorator
+
+        rule %r((break|case|catch|continue|else|finally|for|in|
+          if|return|switch|this|throw|try|while|is|exists|dynamic|
+          nonempty|then|outer|assert|let)\b), Keyword
+
+        rule %r((abstracts|extends|satisfies|super|given|of|out|assign)\b), Keyword::Declaration
+
+        rule %r((function|value|void|new)\b), Keyword::Type
+
+        rule %r((assembly|module|package)(\s+)) do
+          groups Keyword::Namespace, Text
+          push :import
+        end
+
+        rule %r((true|false|null)\b), Keyword::Constant
+
+        rule %r((class|interface|object|alias)(\s+)) do
+          groups Keyword::Declaration, Text
+          push :class
+        end
+
+        rule %r((import)(\s+)) do
+          groups Keyword::Namespace, Text
+          push :import
+        end
+
+        rule %r("(\\\\|\\"|[^"])*"), Literal::String
+        rule %r('\\.'|'[^\\]'|'\\\{#[0-9a-fA-F]{4}\}'), Literal::String::Char
+        rule %r("[^`]*``[^`]*``[^`]*"), Literal::String::Interpol
+        rule %r((\.)([a-z_]\w*)) do
+          groups Operator, Name::Attribute
+        end
+        rule %r([a-zA-Z_]\w*:), Name::Label
+        rule %r((\\I[a-z]|[A-Z])\w*), Name::Decorator
+        rule %r([a-zA-Z_]\w*), Name
+        rule %r([~^*!%&\[\](){}<>|+=:;,./?`-]), Operator
+        rule %r(\d{1,3}(_\d{3})+\.\d{1,3}(_\d{3})+[kMGTPmunpf]?), Literal::Number::Float
+        rule %r(\d{1,3}(_\d{3})+\.[0-9]+([eE][+-]?[0-9]+)?[kMGTPmunpf]?),
+          Literal::Number::Float
+        rule %r([0-9][0-9]*\.\d{1,3}(_\d{3})+[kMGTPmunpf]?), Literal::Number::Float
+        rule %r([0-9][0-9]*\.[0-9]+([eE][+-]?[0-9]+)?[kMGTPmunpf]?),
+          Literal::Number::Float
+        rule %r(#([0-9a-fA-F]{4})(_[0-9a-fA-F]{4})+), Literal::Number::Hex
+        rule %r(#[0-9a-fA-F]+), Literal::Number::Hex
+        rule %r(\$([01]{4})(_[01]{4})+), Literal::Number::Bin
+        rule %r(\$[01]+), Literal::Number::Bin
+        rule %r(\d{1,3}(_\d{3})+[kMGTP]?), Literal::Number::Integer
+        rule %r([0-9]+[kMGTP]?), Literal::Number::Integer
+        rule %r(\n), Text
+
+      end
+
+      state :class do
+        mixin :whitespace
+        rule %r([A-Za-z_]\w*), Name::Class, :pop!
+      end
+
+      state :import do
+        rule %r([a-z][\w.]*), Name::Namespace, :pop!
+        rule %r("(\\\\|\\"|[^"])*"), Literal::String, :pop!
+      end
+
+      state :comment do
+        rule %r([^*/]), Comment.Multiline
+        rule %r(/\*), Comment::Multiline, :push!
+        rule %r(\*/), Comment::Multiline, :pop!
+        rule %r([*/]), Comment::Multiline
+      end
+    end
+  end
+end