static/highlight/es/languages/crystal.js

   1 /*! `crystal` grammar compiled for Highlight.js 11.11.1 */
   2 var hljsGrammar = (function () {
   3   'use strict';
   4
   5   /*
   6   Language: Crystal
   7   Author: TSUYUSATO Kitsune <make.just.on@gmail.com>
   8   Website: https://crystal-lang.org
   9   Category: system
  10   */
  11
  12   /** @type LanguageFn */
  13   function crystal(hljs) {
  14     const INT_SUFFIX = '(_?[ui](8|16|32|64|128))?';
  15     const FLOAT_SUFFIX = '(_?f(32|64))?';
  16     const CRYSTAL_IDENT_RE = '[a-zA-Z_]\\w*[!?=]?';
  17     const CRYSTAL_METHOD_RE = '[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|[=!]~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~|]|//|//=|&[-+*]=?|&\\*\\*|\\[\\][=?]?';
  18     const CRYSTAL_PATH_RE = '[A-Za-z_]\\w*(::\\w+)*(\\?|!)?';
  19     const CRYSTAL_KEYWORDS = {
  20       $pattern: CRYSTAL_IDENT_RE,
  21       keyword:
  22         'abstract alias annotation as as? asm begin break case class def do else elsif end ensure enum extend for fun if '
  23         + 'include instance_sizeof is_a? lib macro module next nil? of out pointerof private protected rescue responds_to? '
  24         + 'return require select self sizeof struct super then type typeof union uninitialized unless until verbatim when while with yield '
  25         + '__DIR__ __END_LINE__ __FILE__ __LINE__',
  26       literal: 'false nil true'
  27     };
  28     const SUBST = {
  29       className: 'subst',
  30       begin: /#\{/,
  31       end: /\}/,
  32       keywords: CRYSTAL_KEYWORDS
  33     };
  34     // borrowed from Ruby
  35     const VARIABLE = {
  36       // negative-look forward attemps to prevent false matches like:
  37       // @ident@ or $ident$ that might indicate this is not ruby at all
  38       className: "variable",
  39       begin: '(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])' + `(?![A-Za-z])(?![@$?'])`
  40     };
  41     const EXPANSION = {
  42       className: 'template-variable',
  43       variants: [
  44         {
  45           begin: '\\{\\{',
  46           end: '\\}\\}'
  47         },
  48         {
  49           begin: '\\{%',
  50           end: '%\\}'
  51         }
  52       ],
  53       keywords: CRYSTAL_KEYWORDS
  54     };
  55
  56     function recursiveParen(begin, end) {
  57       const
  58           contains = [
  59             {
  60               begin: begin,
  61               end: end
  62             }
  63           ];
  64       contains[0].contains = contains;
  65       return contains;
  66     }
  67     const STRING = {
  68       className: 'string',
  69       contains: [
  70         hljs.BACKSLASH_ESCAPE,
  71         SUBST
  72       ],
  73       variants: [
  74         {
  75           begin: /'/,
  76           end: /'/
  77         },
  78         {
  79           begin: /"/,
  80           end: /"/
  81         },
  82         {
  83           begin: /`/,
  84           end: /`/
  85         },
  86         {
  87           begin: '%[Qwi]?\\(',
  88           end: '\\)',
  89           contains: recursiveParen('\\(', '\\)')
  90         },
  91         {
  92           begin: '%[Qwi]?\\[',
  93           end: '\\]',
  94           contains: recursiveParen('\\[', '\\]')
  95         },
  96         {
  97           begin: '%[Qwi]?\\{',
  98           end: /\}/,
  99           contains: recursiveParen(/\{/, /\}/)
 100         },
 101         {
 102           begin: '%[Qwi]?<',
 103           end: '>',
 104           contains: recursiveParen('<', '>')
 105         },
 106         {
 107           begin: '%[Qwi]?\\|',
 108           end: '\\|'
 109         },
 110         {
 111           begin: /<<-\w+$/,
 112           end: /^\s*\w+$/
 113         }
 114       ],
 115       relevance: 0
 116     };
 117     const Q_STRING = {
 118       className: 'string',
 119       variants: [
 120         {
 121           begin: '%q\\(',
 122           end: '\\)',
 123           contains: recursiveParen('\\(', '\\)')
 124         },
 125         {
 126           begin: '%q\\[',
 127           end: '\\]',
 128           contains: recursiveParen('\\[', '\\]')
 129         },
 130         {
 131           begin: '%q\\{',
 132           end: /\}/,
 133           contains: recursiveParen(/\{/, /\}/)
 134         },
 135         {
 136           begin: '%q<',
 137           end: '>',
 138           contains: recursiveParen('<', '>')
 139         },
 140         {
 141           begin: '%q\\|',
 142           end: '\\|'
 143         },
 144         {
 145           begin: /<<-'\w+'$/,
 146           end: /^\s*\w+$/
 147         }
 148       ],
 149       relevance: 0
 150     };
 151     const REGEXP = {
 152       begin: '(?!%\\})(' + hljs.RE_STARTERS_RE + '|\\n|\\b(case|if|select|unless|until|when|while)\\b)\\s*',
 153       keywords: 'case if select unless until when while',
 154       contains: [
 155         {
 156           className: 'regexp',
 157           contains: [
 158             hljs.BACKSLASH_ESCAPE,
 159             SUBST
 160           ],
 161           variants: [
 162             {
 163               begin: '//[a-z]*',
 164               relevance: 0
 165             },
 166             {
 167               begin: '/(?!\\/)',
 168               end: '/[a-z]*'
 169             }
 170           ]
 171         }
 172       ],
 173       relevance: 0
 174     };
 175     const REGEXP2 = {
 176       className: 'regexp',
 177       contains: [
 178         hljs.BACKSLASH_ESCAPE,
 179         SUBST
 180       ],
 181       variants: [
 182         {
 183           begin: '%r\\(',
 184           end: '\\)',
 185           contains: recursiveParen('\\(', '\\)')
 186         },
 187         {
 188           begin: '%r\\[',
 189           end: '\\]',
 190           contains: recursiveParen('\\[', '\\]')
 191         },
 192         {
 193           begin: '%r\\{',
 194           end: /\}/,
 195           contains: recursiveParen(/\{/, /\}/)
 196         },
 197         {
 198           begin: '%r<',
 199           end: '>',
 200           contains: recursiveParen('<', '>')
 201         },
 202         {
 203           begin: '%r\\|',
 204           end: '\\|'
 205         }
 206       ],
 207       relevance: 0
 208     };
 209     const ATTRIBUTE = {
 210       className: 'meta',
 211       begin: '@\\[',
 212       end: '\\]',
 213       contains: [ hljs.inherit(hljs.QUOTE_STRING_MODE, { className: 'string' }) ]
 214     };
 215     const CRYSTAL_DEFAULT_CONTAINS = [
 216       EXPANSION,
 217       STRING,
 218       Q_STRING,
 219       REGEXP2,
 220       REGEXP,
 221       ATTRIBUTE,
 222       VARIABLE,
 223       hljs.HASH_COMMENT_MODE,
 224       {
 225         className: 'class',
 226         beginKeywords: 'class module struct',
 227         end: '$|;',
 228         illegal: /=/,
 229         contains: [
 230           hljs.HASH_COMMENT_MODE,
 231           hljs.inherit(hljs.TITLE_MODE, { begin: CRYSTAL_PATH_RE }),
 232           { // relevance booster for inheritance
 233             begin: '<' }
 234         ]
 235       },
 236       {
 237         className: 'class',
 238         beginKeywords: 'lib enum union',
 239         end: '$|;',
 240         illegal: /=/,
 241         contains: [
 242           hljs.HASH_COMMENT_MODE,
 243           hljs.inherit(hljs.TITLE_MODE, { begin: CRYSTAL_PATH_RE })
 244         ]
 245       },
 246       {
 247         beginKeywords: 'annotation',
 248         end: '$|;',
 249         illegal: /=/,
 250         contains: [
 251           hljs.HASH_COMMENT_MODE,
 252           hljs.inherit(hljs.TITLE_MODE, { begin: CRYSTAL_PATH_RE })
 253         ],
 254         relevance: 2
 255       },
 256       {
 257         className: 'function',
 258         beginKeywords: 'def',
 259         end: /\B\b/,
 260         contains: [
 261           hljs.inherit(hljs.TITLE_MODE, {
 262             begin: CRYSTAL_METHOD_RE,
 263             endsParent: true
 264           })
 265         ]
 266       },
 267       {
 268         className: 'function',
 269         beginKeywords: 'fun macro',
 270         end: /\B\b/,
 271         contains: [
 272           hljs.inherit(hljs.TITLE_MODE, {
 273             begin: CRYSTAL_METHOD_RE,
 274             endsParent: true
 275           })
 276         ],
 277         relevance: 2
 278       },
 279       {
 280         className: 'symbol',
 281         begin: hljs.UNDERSCORE_IDENT_RE + '(!|\\?)?:',
 282         relevance: 0
 283       },
 284       {
 285         className: 'symbol',
 286         begin: ':',
 287         contains: [
 288           STRING,
 289           { begin: CRYSTAL_METHOD_RE }
 290         ],
 291         relevance: 0
 292       },
 293       {
 294         className: 'number',
 295         variants: [
 296           { begin: '\\b0b([01_]+)' + INT_SUFFIX },
 297           { begin: '\\b0o([0-7_]+)' + INT_SUFFIX },
 298           { begin: '\\b0x([A-Fa-f0-9_]+)' + INT_SUFFIX },
 299           { begin: '\\b([1-9][0-9_]*[0-9]|[0-9])(\\.[0-9][0-9_]*)?([eE]_?[-+]?[0-9_]*)?' + FLOAT_SUFFIX + '(?!_)' },
 300           { begin: '\\b([1-9][0-9_]*|0)' + INT_SUFFIX }
 301         ],
 302         relevance: 0
 303       }
 304     ];
 305     SUBST.contains = CRYSTAL_DEFAULT_CONTAINS;
 306     EXPANSION.contains = CRYSTAL_DEFAULT_CONTAINS.slice(1); // without EXPANSION
 307
 308     return {
 309       name: 'Crystal',
 310       aliases: [ 'cr' ],
 311       keywords: CRYSTAL_KEYWORDS,
 312       contains: CRYSTAL_DEFAULT_CONTAINS
 313     };
 314   }
 315
 316   return crystal;
 317
 318 })();
 319 ;
 320 export default hljsGrammar;