static/highlight/es/languages/scala.js

   1 /*! `scala` grammar compiled for Highlight.js 11.11.1 */
   2 var hljsGrammar = (function () {
   3   'use strict';
   4
   5   /*
   6   Language: Scala
   7   Category: functional
   8   Author: Jan Berkel <jan.berkel@gmail.com>
   9   Contributors: Erik Osheim <d_m@plastic-idolatry.com>
  10   Website: https://www.scala-lang.org
  11   */
  12
  13   function scala(hljs) {
  14     const regex = hljs.regex;
  15     const ANNOTATION = {
  16       className: 'meta',
  17       begin: '@[A-Za-z]+'
  18     };
  19
  20     // used in strings for escaping/interpolation/substitution
  21     const SUBST = {
  22       className: 'subst',
  23       variants: [
  24         { begin: '\\$[A-Za-z0-9_]+' },
  25         {
  26           begin: /\$\{/,
  27           end: /\}/
  28         }
  29       ]
  30     };
  31
  32     const STRING = {
  33       className: 'string',
  34       variants: [
  35         {
  36           begin: '"""',
  37           end: '"""'
  38         },
  39         {
  40           begin: '"',
  41           end: '"',
  42           illegal: '\\n',
  43           contains: [ hljs.BACKSLASH_ESCAPE ]
  44         },
  45         {
  46           begin: '[a-z]+"',
  47           end: '"',
  48           illegal: '\\n',
  49           contains: [
  50             hljs.BACKSLASH_ESCAPE,
  51             SUBST
  52           ]
  53         },
  54         {
  55           className: 'string',
  56           begin: '[a-z]+"""',
  57           end: '"""',
  58           contains: [ SUBST ],
  59           relevance: 10
  60         }
  61       ]
  62
  63     };
  64
  65     const TYPE = {
  66       className: 'type',
  67       begin: '\\b[A-Z][A-Za-z0-9_]*',
  68       relevance: 0
  69     };
  70
  71     const NAME = {
  72       className: 'title',
  73       begin: /[^0-9\n\t "'(),.`{}\[\]:;][^\n\t "'(),.`{}\[\]:;]+|[^0-9\n\t "'(),.`{}\[\]:;=]/,
  74       relevance: 0
  75     };
  76
  77     const CLASS = {
  78       className: 'class',
  79       beginKeywords: 'class object trait type',
  80       end: /[:={\[\n;]/,
  81       excludeEnd: true,
  82       contains: [
  83         hljs.C_LINE_COMMENT_MODE,
  84         hljs.C_BLOCK_COMMENT_MODE,
  85         {
  86           beginKeywords: 'extends with',
  87           relevance: 10
  88         },
  89         {
  90           begin: /\[/,
  91           end: /\]/,
  92           excludeBegin: true,
  93           excludeEnd: true,
  94           relevance: 0,
  95           contains: [
  96             TYPE,
  97             hljs.C_LINE_COMMENT_MODE,
  98             hljs.C_BLOCK_COMMENT_MODE,
  99           ]
 100         },
 101         {
 102           className: 'params',
 103           begin: /\(/,
 104           end: /\)/,
 105           excludeBegin: true,
 106           excludeEnd: true,
 107           relevance: 0,
 108           contains: [
 109             TYPE,
 110             hljs.C_LINE_COMMENT_MODE,
 111             hljs.C_BLOCK_COMMENT_MODE,
 112           ]
 113         },
 114         NAME
 115       ]
 116     };
 117
 118     const METHOD = {
 119       className: 'function',
 120       beginKeywords: 'def',
 121       end: regex.lookahead(/[:={\[(\n;]/),
 122       contains: [ NAME ]
 123     };
 124
 125     const EXTENSION = {
 126       begin: [
 127         /^\s*/, // Is first token on the line
 128         'extension',
 129         /\s+(?=[[(])/, // followed by at least one space and `[` or `(`
 130       ],
 131       beginScope: { 2: "keyword", }
 132     };
 133
 134     const END = {
 135       begin: [
 136         /^\s*/, // Is first token on the line
 137         /end/,
 138         /\s+/,
 139         /(extension\b)?/, // `extension` is the only marker that follows an `end` that cannot be captured by another rule.
 140       ],
 141       beginScope: {
 142         2: "keyword",
 143         4: "keyword",
 144       }
 145     };
 146
 147     // TODO: use negative look-behind in future
 148     //       /(?<!\.)\binline(?=\s)/
 149     const INLINE_MODES = [
 150       { match: /\.inline\b/ },
 151       {
 152         begin: /\binline(?=\s)/,
 153         keywords: 'inline'
 154       }
 155     ];
 156
 157     const USING_PARAM_CLAUSE = {
 158       begin: [
 159         /\(\s*/, // Opening `(` of a parameter or argument list
 160         /using/,
 161         /\s+(?!\))/, // Spaces not followed by `)`
 162       ],
 163       beginScope: { 2: "keyword", }
 164     };
 165
 166     // glob all non-whitespace characters as a "string"
 167     // sourced from https://github.com/scala/docs.scala-lang/pull/2845
 168     const DIRECTIVE_VALUE = {
 169       className: 'string',
 170       begin: /\S+/,
 171     };
 172
 173     // directives
 174     // sourced from https://github.com/scala/docs.scala-lang/pull/2845
 175     const USING_DIRECTIVE = {
 176       begin: [
 177         '//>',
 178         /\s+/,
 179         /using/,
 180         /\s+/,
 181         /\S+/
 182       ],
 183       beginScope: {
 184         1: "comment",
 185         3: "keyword",
 186         5: "type"
 187       },
 188       end: /$/,
 189       contains: [
 190         DIRECTIVE_VALUE,
 191       ]
 192     };
 193
 194     return {
 195       name: 'Scala',
 196       keywords: {
 197         literal: 'true false null',
 198         keyword: 'type yield lazy override def with val var sealed abstract private trait object if then forSome for while do throw finally protected extends import final return else break new catch super class case package default try this match continue throws implicit export enum given transparent'
 199       },
 200       contains: [
 201         USING_DIRECTIVE,
 202         hljs.C_LINE_COMMENT_MODE,
 203         hljs.C_BLOCK_COMMENT_MODE,
 204         STRING,
 205         TYPE,
 206         METHOD,
 207         CLASS,
 208         hljs.C_NUMBER_MODE,
 209         EXTENSION,
 210         END,
 211         ...INLINE_MODES,
 212         USING_PARAM_CLAUSE,
 213         ANNOTATION
 214       ]
 215     };
 216   }
 217
 218   return scala;
 219
 220 })();
 221 ;
 222 export default hljsGrammar;