Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1# -*- coding: utf-8 -*- 

2""" 

3 pygments.lexers.javascript 

4 ~~~~~~~~~~~~~~~~~~~~~~~~~~ 

5 

6 Lexers for JavaScript and related languages. 

7 

8 :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS. 

9 :license: BSD, see LICENSE for details. 

10""" 

11 

12import re 

13 

14from pygments.lexer import RegexLexer, include, bygroups, default, using, \ 

15 this, words, combined 

16from pygments.token import Text, Comment, Operator, Keyword, Name, String, \ 

17 Number, Punctuation, Other 

18from pygments.util import get_bool_opt 

19import pygments.unistring as uni 

20 

21__all__ = ['JavascriptLexer', 'KalLexer', 'LiveScriptLexer', 'DartLexer', 

22 'TypeScriptLexer', 'LassoLexer', 'ObjectiveJLexer', 

23 'CoffeeScriptLexer', 'MaskLexer', 'EarlGreyLexer', 'JuttleLexer'] 

24 

25JS_IDENT_START = ('(?:[$_' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl') + 

26 ']|\\\\u[a-fA-F0-9]{4})') 

27JS_IDENT_PART = ('(?:[$' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl', 

28 'Mn', 'Mc', 'Nd', 'Pc') + 

29 '\u200c\u200d]|\\\\u[a-fA-F0-9]{4})') 

30JS_IDENT = JS_IDENT_START + '(?:' + JS_IDENT_PART + ')*' 

31 

32 

33class JavascriptLexer(RegexLexer): 

34 """ 

35 For JavaScript source code. 

36 """ 

37 

38 name = 'JavaScript' 

39 aliases = ['js', 'javascript'] 

40 filenames = ['*.js', '*.jsm', '*.mjs'] 

41 mimetypes = ['application/javascript', 'application/x-javascript', 

42 'text/x-javascript', 'text/javascript'] 

43 

44 flags = re.DOTALL | re.UNICODE | re.MULTILINE 

45 

46 tokens = { 

47 'commentsandwhitespace': [ 

48 (r'\s+', Text), 

49 (r'<!--', Comment), 

50 (r'//.*?\n', Comment.Single), 

51 (r'/\*.*?\*/', Comment.Multiline) 

52 ], 

53 'slashstartsregex': [ 

54 include('commentsandwhitespace'), 

55 (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/' 

56 r'([gimuys]+\b|\B)', String.Regex, '#pop'), 

57 (r'(?=/)', Text, ('#pop', 'badregex')), 

58 default('#pop') 

59 ], 

60 'badregex': [ 

61 (r'\n', Text, '#pop') 

62 ], 

63 'root': [ 

64 (r'\A#! ?/.*?\n', Comment.Hashbang), # recognized by node.js 

65 (r'^(?=\s|/|<!--)', Text, 'slashstartsregex'), 

66 include('commentsandwhitespace'), 

67 

68 # Numeric literals 

69 (r'0[bB][01]+n?', Number.Bin), 

70 (r'0[oO]?[0-7]+n?', Number.Oct), # Browsers support "0o7" and "07" (< ES5) notations 

71 (r'0[xX][0-9a-fA-F]+n?', Number.Hex), 

72 (r'[0-9]+n', Number.Integer), # Javascript BigInt requires an "n" postfix 

73 # Javascript doesn't have actual integer literals, so every other 

74 # numeric literal is handled by the regex below (including "normal") 

75 # integers 

76 (r'(\.[0-9]+|[0-9]+\.[0-9]*|[0-9]+)([eE][-+]?[0-9]+)?', Number.Float), 

77 

78 (r'\.\.\.|=>', Punctuation), 

79 (r'\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|' 

80 r'(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?', Operator, 'slashstartsregex'), 

81 (r'[{(\[;,]', Punctuation, 'slashstartsregex'), 

82 (r'[})\].]', Punctuation), 

83 (r'(for|in|while|do|break|return|continue|switch|case|default|if|else|' 

84 r'throw|try|catch|finally|new|delete|typeof|instanceof|void|yield|await|async|' 

85 r'this|of|static|export|import|debugger|extends|super)\b', Keyword, 'slashstartsregex'), 

86 (r'(var|let|const|with|function|class)\b', Keyword.Declaration, 'slashstartsregex'), 

87 (r'(abstract|boolean|byte|char|double|enum|final|float|goto' 

88 r'implements|int|interface|long|native|package|private|protected' 

89 r'public|short|synchronized|throws|transient|volatile)\b', Keyword.Reserved), 

90 (r'(true|false|null|NaN|Infinity|undefined)\b', Keyword.Constant), 

91 (r'(Array|Boolean|Date|BigInt|Error|Function|Math|' 

92 r'Number|Object|RegExp|String|Promise|Proxy|decodeURI|' 

93 r'decodeURIComponent|encodeURI|encodeURIComponent|' 

94 r'Error|eval|isFinite|isNaN|isSafeInteger|parseFloat|parseInt|' 

95 r'document|this|window|globalThis|Symbol)\b', Name.Builtin), 

96 (JS_IDENT, Name.Other), 

97 (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double), 

98 (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single), 

99 (r'`', String.Backtick, 'interp'), 

100 ], 

101 'interp': [ 

102 (r'`', String.Backtick, '#pop'), 

103 (r'\\\\', String.Backtick), 

104 (r'\\`', String.Backtick), 

105 (r'\$\{', String.Interpol, 'interp-inside'), 

106 (r'\$', String.Backtick), 

107 (r'[^`\\$]+', String.Backtick), 

108 ], 

109 'interp-inside': [ 

110 # TODO: should this include single-line comments and allow nesting strings? 

111 (r'\}', String.Interpol, '#pop'), 

112 include('root'), 

113 ], 

114 } 

115 

116 

117class KalLexer(RegexLexer): 

118 """ 

119 For `Kal`_ source code. 

120 

121 .. _Kal: http://rzimmerman.github.io/kal 

122 

123 

124 .. versionadded:: 2.0 

125 """ 

126 

127 name = 'Kal' 

128 aliases = ['kal'] 

129 filenames = ['*.kal'] 

130 mimetypes = ['text/kal', 'application/kal'] 

131 

132 flags = re.DOTALL 

133 tokens = { 

134 'commentsandwhitespace': [ 

135 (r'\s+', Text), 

136 (r'###[^#].*?###', Comment.Multiline), 

137 (r'#(?!##[^#]).*?\n', Comment.Single), 

138 ], 

139 'functiondef': [ 

140 (r'[$a-zA-Z_][\w$]*\s*', Name.Function, '#pop'), 

141 include('commentsandwhitespace'), 

142 ], 

143 'classdef': [ 

144 (r'\binherits\s+from\b', Keyword), 

145 (r'[$a-zA-Z_][\w$]*\s*\n', Name.Class, '#pop'), 

146 (r'[$a-zA-Z_][\w$]*\s*', Name.Class), 

147 include('commentsandwhitespace'), 

148 ], 

149 'listcomprehension': [ 

150 (r'\]', Punctuation, '#pop'), 

151 (r'\b(property|value)\b', Keyword), 

152 include('root'), 

153 ], 

154 'waitfor': [ 

155 (r'\n', Punctuation, '#pop'), 

156 (r'\bfrom\b', Keyword), 

157 include('root'), 

158 ], 

159 'root': [ 

160 include('commentsandwhitespace'), 

161 (r'/(?! )(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/' 

162 r'([gimuys]+\b|\B)', String.Regex), 

163 (r'\?|:|_(?=\n)|==?|!=|-(?!>)|[<>+*/-]=?', 

164 Operator), 

165 (r'\b(and|or|isnt|is|not|but|bitwise|mod|\^|xor|exists|' 

166 r'doesnt\s+exist)\b', Operator.Word), 

167 (r'(?:\([^()]+\))?\s*>', Name.Function), 

168 (r'[{(]', Punctuation), 

169 (r'\[', Punctuation, 'listcomprehension'), 

170 (r'[})\].,]', Punctuation), 

171 (r'\b(function|method|task)\b', Keyword.Declaration, 'functiondef'), 

172 (r'\bclass\b', Keyword.Declaration, 'classdef'), 

173 (r'\b(safe\s+)?wait\s+for\b', Keyword, 'waitfor'), 

174 (r'\b(me|this)(\.[$a-zA-Z_][\w.$]*)?\b', Name.Variable.Instance), 

175 (r'(?<![.$])(for(\s+(parallel|series))?|in|of|while|until|' 

176 r'break|return|continue|' 

177 r'when|if|unless|else|otherwise|except\s+when|' 

178 r'throw|raise|fail\s+with|try|catch|finally|new|delete|' 

179 r'typeof|instanceof|super|run\s+in\s+parallel|' 

180 r'inherits\s+from)\b', Keyword), 

181 (r'(?<![.$])(true|false|yes|no|on|off|null|nothing|none|' 

182 r'NaN|Infinity|undefined)\b', 

183 Keyword.Constant), 

184 (r'(Array|Boolean|Date|Error|Function|Math|' 

185 r'Number|Object|RegExp|String|decodeURI|' 

186 r'decodeURIComponent|encodeURI|encodeURIComponent|' 

187 r'eval|isFinite|isNaN|isSafeInteger|parseFloat|parseInt|document|' 

188 r'window|globalThis|Symbol|print)\b', Name.Builtin), 

189 (r'[$a-zA-Z_][\w.$]*\s*(:|[+\-*/]?\=)?\b', Name.Variable), 

190 (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float), 

191 (r'0x[0-9a-fA-F]+', Number.Hex), 

192 (r'[0-9]+', Number.Integer), 

193 ('"""', String, 'tdqs'), 

194 ("'''", String, 'tsqs'), 

195 ('"', String, 'dqs'), 

196 ("'", String, 'sqs'), 

197 ], 

198 'strings': [ 

199 (r'[^#\\\'"]+', String), 

200 # note that all kal strings are multi-line. 

201 # hashmarks, quotes and backslashes must be parsed one at a time 

202 ], 

203 'interpoling_string': [ 

204 (r'\}', String.Interpol, "#pop"), 

205 include('root') 

206 ], 

207 'dqs': [ 

208 (r'"', String, '#pop'), 

209 (r'\\.|\'', String), # double-quoted string don't need ' escapes 

210 (r'#\{', String.Interpol, "interpoling_string"), 

211 include('strings') 

212 ], 

213 'sqs': [ 

214 (r"'", String, '#pop'), 

215 (r'#|\\.|"', String), # single quoted strings don't need " escapses 

216 include('strings') 

217 ], 

218 'tdqs': [ 

219 (r'"""', String, '#pop'), 

220 (r'\\.|\'|"', String), # no need to escape quotes in triple-string 

221 (r'#\{', String.Interpol, "interpoling_string"), 

222 include('strings'), 

223 ], 

224 'tsqs': [ 

225 (r"'''", String, '#pop'), 

226 (r'#|\\.|\'|"', String), # no need to escape quotes in triple-strings 

227 include('strings') 

228 ], 

229 } 

230 

231 

232class LiveScriptLexer(RegexLexer): 

233 """ 

234 For `LiveScript`_ source code. 

235 

236 .. _LiveScript: http://gkz.github.com/LiveScript/ 

237 

238 .. versionadded:: 1.6 

239 """ 

240 

241 name = 'LiveScript' 

242 aliases = ['live-script', 'livescript'] 

243 filenames = ['*.ls'] 

244 mimetypes = ['text/livescript'] 

245 

246 flags = re.DOTALL 

247 tokens = { 

248 'commentsandwhitespace': [ 

249 (r'\s+', Text), 

250 (r'/\*.*?\*/', Comment.Multiline), 

251 (r'#.*?\n', Comment.Single), 

252 ], 

253 'multilineregex': [ 

254 include('commentsandwhitespace'), 

255 (r'//([gimuys]+\b|\B)', String.Regex, '#pop'), 

256 (r'/', String.Regex), 

257 (r'[^/#]+', String.Regex) 

258 ], 

259 'slashstartsregex': [ 

260 include('commentsandwhitespace'), 

261 (r'//', String.Regex, ('#pop', 'multilineregex')), 

262 (r'/(?! )(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/' 

263 r'([gimuys]+\b|\B)', String.Regex, '#pop'), 

264 (r'/', Operator, '#pop'), 

265 default('#pop'), 

266 ], 

267 'root': [ 

268 (r'\A(?=\s|/)', Text, 'slashstartsregex'), 

269 include('commentsandwhitespace'), 

270 (r'(?:\([^()]+\))?[ ]*[~-]{1,2}>|' 

271 r'(?:\(?[^()\n]+\)?)?[ ]*<[~-]{1,2}', Name.Function), 

272 (r'\+\+|&&|(?<![.$])\b(?:and|x?or|is|isnt|not)\b|\?|:|=|' 

273 r'\|\||\\(?=\n)|(<<|>>>?|==?|!=?|' 

274 r'~(?!\~?>)|-(?!\-?>)|<(?!\[)|(?<!\])>|' 

275 r'[+*`%&|^/])=?', 

276 Operator, 'slashstartsregex'), 

277 (r'[{(\[;,]', Punctuation, 'slashstartsregex'), 

278 (r'[})\].]', Punctuation), 

279 (r'(?<![.$])(for|own|in|of|while|until|loop|break|' 

280 r'return|continue|switch|when|then|if|unless|else|' 

281 r'throw|try|catch|finally|new|delete|typeof|instanceof|super|' 

282 r'extends|this|class|by|const|var|to|til)\b', Keyword, 

283 'slashstartsregex'), 

284 (r'(?<![.$])(true|false|yes|no|on|off|' 

285 r'null|NaN|Infinity|undefined|void)\b', 

286 Keyword.Constant), 

287 (r'(Array|Boolean|Date|Error|Function|Math|' 

288 r'Number|Object|RegExp|String|decodeURI|' 

289 r'decodeURIComponent|encodeURI|encodeURIComponent|' 

290 r'eval|isFinite|isNaN|parseFloat|parseInt|document|window|' 

291 r'globalThis|Symbol|Symbol|BigInt)\b', Name.Builtin), 

292 (r'[$a-zA-Z_][\w.\-:$]*\s*[:=]\s', Name.Variable, 

293 'slashstartsregex'), 

294 (r'@[$a-zA-Z_][\w.\-:$]*\s*[:=]\s', Name.Variable.Instance, 

295 'slashstartsregex'), 

296 (r'@', Name.Other, 'slashstartsregex'), 

297 (r'@?[$a-zA-Z_][\w-]*', Name.Other, 'slashstartsregex'), 

298 (r'[0-9]+\.[0-9]+([eE][0-9]+)?[fd]?(?:[a-zA-Z_]+)?', Number.Float), 

299 (r'[0-9]+(~[0-9a-z]+)?(?:[a-zA-Z_]+)?', Number.Integer), 

300 ('"""', String, 'tdqs'), 

301 ("'''", String, 'tsqs'), 

302 ('"', String, 'dqs'), 

303 ("'", String, 'sqs'), 

304 (r'\\\S+', String), 

305 (r'<\[.*?\]>', String), 

306 ], 

307 'strings': [ 

308 (r'[^#\\\'"]+', String), 

309 # note that all coffee script strings are multi-line. 

310 # hashmarks, quotes and backslashes must be parsed one at a time 

311 ], 

312 'interpoling_string': [ 

313 (r'\}', String.Interpol, "#pop"), 

314 include('root') 

315 ], 

316 'dqs': [ 

317 (r'"', String, '#pop'), 

318 (r'\\.|\'', String), # double-quoted string don't need ' escapes 

319 (r'#\{', String.Interpol, "interpoling_string"), 

320 (r'#', String), 

321 include('strings') 

322 ], 

323 'sqs': [ 

324 (r"'", String, '#pop'), 

325 (r'#|\\.|"', String), # single quoted strings don't need " escapses 

326 include('strings') 

327 ], 

328 'tdqs': [ 

329 (r'"""', String, '#pop'), 

330 (r'\\.|\'|"', String), # no need to escape quotes in triple-string 

331 (r'#\{', String.Interpol, "interpoling_string"), 

332 (r'#', String), 

333 include('strings'), 

334 ], 

335 'tsqs': [ 

336 (r"'''", String, '#pop'), 

337 (r'#|\\.|\'|"', String), # no need to escape quotes in triple-strings 

338 include('strings') 

339 ], 

340 } 

341 

342 

343class DartLexer(RegexLexer): 

344 """ 

345 For `Dart <http://dart.dev/>`_ source code. 

346 

347 .. versionadded:: 1.5 

348 """ 

349 

350 name = 'Dart' 

351 aliases = ['dart'] 

352 filenames = ['*.dart'] 

353 mimetypes = ['text/x-dart'] 

354 

355 flags = re.MULTILINE | re.DOTALL 

356 

357 tokens = { 

358 'root': [ 

359 include('string_literal'), 

360 (r'#!(.*?)$', Comment.Preproc), 

361 (r'\b(import|export)\b', Keyword, 'import_decl'), 

362 (r'\b(library|source|part of|part)\b', Keyword), 

363 (r'[^\S\n]+', Text), 

364 (r'//.*?\n', Comment.Single), 

365 (r'/\*.*?\*/', Comment.Multiline), 

366 (r'\b(class|extension|mixin)\b(\s+)', 

367 bygroups(Keyword.Declaration, Text), 'class'), 

368 (r'\b(as|assert|break|case|catch|const|continue|default|do|else|finally|' 

369 r'for|if|in|is|new|rethrow|return|super|switch|this|throw|try|while)\b', 

370 Keyword), 

371 (r'\b(abstract|async|await|const|covariant|extends|external|factory|final|' 

372 r'get|implements|late|native|on|operator|required|set|static|sync|typedef|' 

373 r'var|with|yield)\b', Keyword.Declaration), 

374 (r'\b(bool|double|dynamic|int|num|Function|Never|Null|Object|String|void)\b', 

375 Keyword.Type), 

376 (r'\b(false|null|true)\b', Keyword.Constant), 

377 (r'[~!%^&*+=|?:<>/-]|as\b', Operator), 

378 (r'@[a-zA-Z_$]\w*', Name.Decorator), 

379 (r'[a-zA-Z_$]\w*:', Name.Label), 

380 (r'[a-zA-Z_$]\w*', Name), 

381 (r'[(){}\[\],.;]', Punctuation), 

382 (r'0[xX][0-9a-fA-F]+', Number.Hex), 

383 # DIGIT+ (‘.’ DIGIT*)? EXPONENT? 

384 (r'\d+(\.\d*)?([eE][+-]?\d+)?', Number), 

385 (r'\.\d+([eE][+-]?\d+)?', Number), # ‘.’ DIGIT+ EXPONENT? 

386 (r'\n', Text) 

387 # pseudo-keyword negate intentionally left out 

388 ], 

389 'class': [ 

390 (r'[a-zA-Z_$]\w*', Name.Class, '#pop') 

391 ], 

392 'import_decl': [ 

393 include('string_literal'), 

394 (r'\s+', Text), 

395 (r'\b(as|deferred|show|hide)\b', Keyword), 

396 (r'[a-zA-Z_$]\w*', Name), 

397 (r'\,', Punctuation), 

398 (r'\;', Punctuation, '#pop') 

399 ], 

400 'string_literal': [ 

401 # Raw strings. 

402 (r'r"""([\w\W]*?)"""', String.Double), 

403 (r"r'''([\w\W]*?)'''", String.Single), 

404 (r'r"(.*?)"', String.Double), 

405 (r"r'(.*?)'", String.Single), 

406 # Normal Strings. 

407 (r'"""', String.Double, 'string_double_multiline'), 

408 (r"'''", String.Single, 'string_single_multiline'), 

409 (r'"', String.Double, 'string_double'), 

410 (r"'", String.Single, 'string_single') 

411 ], 

412 'string_common': [ 

413 (r"\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\{[0-9A-Fa-f]*\}|[a-z'\"$\\])", 

414 String.Escape), 

415 (r'(\$)([a-zA-Z_]\w*)', bygroups(String.Interpol, Name)), 

416 (r'(\$\{)(.*?)(\})', 

417 bygroups(String.Interpol, using(this), String.Interpol)) 

418 ], 

419 'string_double': [ 

420 (r'"', String.Double, '#pop'), 

421 (r'[^"$\\\n]+', String.Double), 

422 include('string_common'), 

423 (r'\$+', String.Double) 

424 ], 

425 'string_double_multiline': [ 

426 (r'"""', String.Double, '#pop'), 

427 (r'[^"$\\]+', String.Double), 

428 include('string_common'), 

429 (r'(\$|\")+', String.Double) 

430 ], 

431 'string_single': [ 

432 (r"'", String.Single, '#pop'), 

433 (r"[^'$\\\n]+", String.Single), 

434 include('string_common'), 

435 (r'\$+', String.Single) 

436 ], 

437 'string_single_multiline': [ 

438 (r"'''", String.Single, '#pop'), 

439 (r'[^\'$\\]+', String.Single), 

440 include('string_common'), 

441 (r'(\$|\')+', String.Single) 

442 ] 

443 } 

444 

445 

446class TypeScriptLexer(RegexLexer): 

447 """ 

448 For `TypeScript <http://typescriptlang.org/>`_ source code. 

449 

450 .. versionadded:: 1.6 

451 """ 

452 

453 name = 'TypeScript' 

454 aliases = ['ts', 'typescript'] 

455 filenames = ['*.ts', '*.tsx'] 

456 mimetypes = ['text/x-typescript'] 

457 

458 flags = re.DOTALL | re.MULTILINE 

459 

460 # Higher priority than the TypoScriptLexer, as TypeScript is far more 

461 # common these days 

462 priority = 0.5 

463 

464 tokens = { 

465 'commentsandwhitespace': [ 

466 (r'\s+', Text), 

467 (r'<!--', Comment), 

468 (r'//.*?\n', Comment.Single), 

469 (r'/\*.*?\*/', Comment.Multiline) 

470 ], 

471 'slashstartsregex': [ 

472 include('commentsandwhitespace'), 

473 (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/' 

474 r'([gimuys]+\b|\B)', String.Regex, '#pop'), 

475 (r'(?=/)', Text, ('#pop', 'badregex')), 

476 default('#pop') 

477 ], 

478 'badregex': [ 

479 (r'\n', Text, '#pop') 

480 ], 

481 'root': [ 

482 (r'^(?=\s|/|<!--)', Text, 'slashstartsregex'), 

483 include('commentsandwhitespace'), 

484 (r'\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|' 

485 r'(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?', Operator, 'slashstartsregex'), 

486 (r'[{(\[;,]', Punctuation, 'slashstartsregex'), 

487 (r'[})\].]', Punctuation), 

488 (r'(for|in|while|do|break|return|continue|switch|case|default|if|else|' 

489 r'throw|try|catch|finally|new|delete|typeof|instanceof|void|of|' 

490 r'this|async|await|debugger|yield|abstract|static|import|export|' 

491 r'implements|super|extends|private|protected|public|readonly)\b', Keyword, 'slashstartsregex'), 

492 (r'(var|let|const|with|function|class|type|enum|interface)\b', Keyword.Declaration, 'slashstartsregex'), 

493 (r'(boolean|byte|char|double|final|float|goto|int|long|native|' 

494 r'package|short|synchronized|throws|transient|volatile)\b', Keyword.Reserved), 

495 (r'(true|false|null|NaN|Infinity|undefined)\b', Keyword.Constant), 

496 (r'(Array|Boolean|Date|Error|Function|Math|' 

497 r'Number|Object|RegExp|String|decodeURI|' 

498 r'decodeURIComponent|encodeURI|encodeURIComponent|' 

499 r'Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|' 

500 r'window|globalThis|Symbol|BigInt)\b', Name.Builtin), 

501 # Match stuff like: module name {...} 

502 (r'\b(module)(\s*)(\s*[\w?.$][\w?.$]*)(\s*)', 

503 bygroups(Keyword.Reserved, Text, Name.Other, Text), 'slashstartsregex'), 

504 # Match variable type keywords 

505 (r'\b(string|bool|number)\b', Keyword.Type), 

506 # Match stuff like: constructor 

507 (r'\b(constructor|declare|interface|as|AS)\b', Keyword.Reserved), 

508 # Match stuff like: super(argument, list) 

509 (r'(super)(\s*)(\([\w,?.$\s]+\s*\))', 

510 bygroups(Keyword.Reserved, Text), 'slashstartsregex'), 

511 # Match stuff like: function() {...} 

512 (r'([a-zA-Z_?.$][\w?.$]*)(?=\(\) \{)', Name.Other, 'slashstartsregex'), 

513 # Match stuff like: (function: return type) 

514 (r'([\w?.$][\w?.$]*)(\s*:\s*)([\w?.$][\w?.$]*)', 

515 bygroups(Name.Other, Text, Keyword.Type)), 

516 (r'[$a-zA-Z_]\w*', Name.Other), 

517 (r'0[bB][01]+n?', Number.Bin), 

518 (r'0[oO]?[0-7]+n?', Number.Oct), # Browsers support "0o7" and "07" (< ES5) notations 

519 (r'0[xX][0-9a-fA-F]+n?', Number.Hex), 

520 (r'[0-9]+n', Number.Integer), 

521 (r'(\.[0-9]+|[0-9]+\.[0-9]*|[0-9]+)([eE][-+]?[0-9]+)?', Number.Float), 

522 (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double), 

523 (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single), 

524 (r'`', String.Backtick, 'interp'), 

525 # Match stuff like: Decorators 

526 (r'@\w+', Keyword.Declaration), 

527 ], 

528 

529 # The 'interp*' rules match those in JavascriptLexer. Changes made 

530 # there should be reflected here as well. 

531 'interp': [ 

532 (r'`', String.Backtick, '#pop'), 

533 (r'\\\\', String.Backtick), 

534 (r'\\`', String.Backtick), 

535 (r'\$\{', String.Interpol, 'interp-inside'), 

536 (r'\$', String.Backtick), 

537 (r'[^`\\$]+', String.Backtick), 

538 ], 

539 'interp-inside': [ 

540 # TODO: should this include single-line comments and allow nesting strings? 

541 (r'\}', String.Interpol, '#pop'), 

542 include('root'), 

543 ], 

544 } 

545 

546 

547class LassoLexer(RegexLexer): 

548 """ 

549 For `Lasso <http://www.lassosoft.com/>`_ source code, covering both Lasso 9 

550 syntax and LassoScript for Lasso 8.6 and earlier. For Lasso embedded in 

551 HTML, use the `LassoHtmlLexer`. 

552 

553 Additional options accepted: 

554 

555 `builtinshighlighting` 

556 If given and ``True``, highlight builtin types, traits, methods, and 

557 members (default: ``True``). 

558 `requiredelimiters` 

559 If given and ``True``, only highlight code between delimiters as Lasso 

560 (default: ``False``). 

561 

562 .. versionadded:: 1.6 

563 """ 

564 

565 name = 'Lasso' 

566 aliases = ['lasso', 'lassoscript'] 

567 filenames = ['*.lasso', '*.lasso[89]'] 

568 alias_filenames = ['*.incl', '*.inc', '*.las'] 

569 mimetypes = ['text/x-lasso'] 

570 flags = re.IGNORECASE | re.DOTALL | re.MULTILINE 

571 

572 tokens = { 

573 'root': [ 

574 (r'^#![ \S]+lasso9\b', Comment.Preproc, 'lasso'), 

575 (r'(?=\[|<)', Other, 'delimiters'), 

576 (r'\s+', Other), 

577 default(('delimiters', 'lassofile')), 

578 ], 

579 'delimiters': [ 

580 (r'\[no_square_brackets\]', Comment.Preproc, 'nosquarebrackets'), 

581 (r'\[noprocess\]', Comment.Preproc, 'noprocess'), 

582 (r'\[', Comment.Preproc, 'squarebrackets'), 

583 (r'<\?(lasso(script)?|=)', Comment.Preproc, 'anglebrackets'), 

584 (r'<(!--.*?-->)?', Other), 

585 (r'[^[<]+', Other), 

586 ], 

587 'nosquarebrackets': [ 

588 (r'\[noprocess\]', Comment.Preproc, 'noprocess'), 

589 (r'\[', Other), 

590 (r'<\?(lasso(script)?|=)', Comment.Preproc, 'anglebrackets'), 

591 (r'<(!--.*?-->)?', Other), 

592 (r'[^[<]+', Other), 

593 ], 

594 'noprocess': [ 

595 (r'\[/noprocess\]', Comment.Preproc, '#pop'), 

596 (r'\[', Other), 

597 (r'[^[]', Other), 

598 ], 

599 'squarebrackets': [ 

600 (r'\]', Comment.Preproc, '#pop'), 

601 include('lasso'), 

602 ], 

603 'anglebrackets': [ 

604 (r'\?>', Comment.Preproc, '#pop'), 

605 include('lasso'), 

606 ], 

607 'lassofile': [ 

608 (r'\]|\?>', Comment.Preproc, '#pop'), 

609 include('lasso'), 

610 ], 

611 'whitespacecomments': [ 

612 (r'\s+', Text), 

613 (r'//.*?\n', Comment.Single), 

614 (r'/\*\*!.*?\*/', String.Doc), 

615 (r'/\*.*?\*/', Comment.Multiline), 

616 ], 

617 'lasso': [ 

618 # whitespace/comments 

619 include('whitespacecomments'), 

620 

621 # literals 

622 (r'\d*\.\d+(e[+-]?\d+)?', Number.Float), 

623 (r'0x[\da-f]+', Number.Hex), 

624 (r'\d+', Number.Integer), 

625 (r'(infinity|NaN)\b', Number), 

626 (r"'", String.Single, 'singlestring'), 

627 (r'"', String.Double, 'doublestring'), 

628 (r'`[^`]*`', String.Backtick), 

629 

630 # names 

631 (r'\$[a-z_][\w.]*', Name.Variable), 

632 (r'#([a-z_][\w.]*|\d+\b)', Name.Variable.Instance), 

633 (r"(\.\s*)('[a-z_][\w.]*')", 

634 bygroups(Name.Builtin.Pseudo, Name.Variable.Class)), 

635 (r"(self)(\s*->\s*)('[a-z_][\w.]*')", 

636 bygroups(Name.Builtin.Pseudo, Operator, Name.Variable.Class)), 

637 (r'(\.\.?\s*)([a-z_][\w.]*(=(?!=))?)', 

638 bygroups(Name.Builtin.Pseudo, Name.Other.Member)), 

639 (r'(->\\?\s*|&\s*)([a-z_][\w.]*(=(?!=))?)', 

640 bygroups(Operator, Name.Other.Member)), 

641 (r'(?<!->)(self|inherited|currentcapture|givenblock)\b', 

642 Name.Builtin.Pseudo), 

643 (r'-(?!infinity)[a-z_][\w.]*', Name.Attribute), 

644 (r'::\s*[a-z_][\w.]*', Name.Label), 

645 (r'(error_(code|msg)_\w+|Error_AddError|Error_ColumnRestriction|' 

646 r'Error_DatabaseConnectionUnavailable|Error_DatabaseTimeout|' 

647 r'Error_DeleteError|Error_FieldRestriction|Error_FileNotFound|' 

648 r'Error_InvalidDatabase|Error_InvalidPassword|' 

649 r'Error_InvalidUsername|Error_ModuleNotFound|' 

650 r'Error_NoError|Error_NoPermission|Error_OutOfMemory|' 

651 r'Error_ReqColumnMissing|Error_ReqFieldMissing|' 

652 r'Error_RequiredColumnMissing|Error_RequiredFieldMissing|' 

653 r'Error_UpdateError)\b', Name.Exception), 

654 

655 # definitions 

656 (r'(define)(\s+)([a-z_][\w.]*)(\s*=>\s*)(type|trait|thread)\b', 

657 bygroups(Keyword.Declaration, Text, Name.Class, Operator, Keyword)), 

658 (r'(define)(\s+)([a-z_][\w.]*)(\s*->\s*)([a-z_][\w.]*=?|[-+*/%])', 

659 bygroups(Keyword.Declaration, Text, Name.Class, Operator, 

660 Name.Function), 'signature'), 

661 (r'(define)(\s+)([a-z_][\w.]*)', 

662 bygroups(Keyword.Declaration, Text, Name.Function), 'signature'), 

663 (r'(public|protected|private|provide)(\s+)(([a-z_][\w.]*=?|[-+*/%])' 

664 r'(?=\s*\())', bygroups(Keyword, Text, Name.Function), 

665 'signature'), 

666 (r'(public|protected|private|provide)(\s+)([a-z_][\w.]*)', 

667 bygroups(Keyword, Text, Name.Function)), 

668 

669 # keywords 

670 (r'(true|false|none|minimal|full|all|void)\b', Keyword.Constant), 

671 (r'(local|var|variable|global|data(?=\s))\b', Keyword.Declaration), 

672 (r'(array|date|decimal|duration|integer|map|pair|string|tag|xml|' 

673 r'null|boolean|bytes|keyword|list|locale|queue|set|stack|' 

674 r'staticarray)\b', Keyword.Type), 

675 (r'([a-z_][\w.]*)(\s+)(in)\b', bygroups(Name, Text, Keyword)), 

676 (r'(let|into)(\s+)([a-z_][\w.]*)', bygroups(Keyword, Text, Name)), 

677 (r'require\b', Keyword, 'requiresection'), 

678 (r'(/?)(Namespace_Using)\b', bygroups(Punctuation, Keyword.Namespace)), 

679 (r'(/?)(Cache|Database_Names|Database_SchemaNames|' 

680 r'Database_TableNames|Define_Tag|Define_Type|Email_Batch|' 

681 r'Encode_Set|HTML_Comment|Handle|Handle_Error|Header|If|Inline|' 

682 r'Iterate|LJAX_Target|Link|Link_CurrentAction|Link_CurrentGroup|' 

683 r'Link_CurrentRecord|Link_Detail|Link_FirstGroup|Link_FirstRecord|' 

684 r'Link_LastGroup|Link_LastRecord|Link_NextGroup|Link_NextRecord|' 

685 r'Link_PrevGroup|Link_PrevRecord|Log|Loop|Output_None|Portal|' 

686 r'Private|Protect|Records|Referer|Referrer|Repeating|ResultSet|' 

687 r'Rows|Search_Args|Search_Arguments|Select|Sort_Args|' 

688 r'Sort_Arguments|Thread_Atomic|Value_List|While|Abort|Case|Else|' 

689 r'Fail_If|Fail_IfNot|Fail|If_Empty|If_False|If_Null|If_True|' 

690 r'Loop_Abort|Loop_Continue|Loop_Count|Params|Params_Up|Return|' 

691 r'Return_Value|Run_Children|SOAP_DefineTag|SOAP_LastRequest|' 

692 r'SOAP_LastResponse|Tag_Name|ascending|average|by|define|' 

693 r'descending|do|equals|frozen|group|handle_failure|import|in|into|' 

694 r'join|let|match|max|min|on|order|parent|protected|provide|public|' 

695 r'require|returnhome|skip|split_thread|sum|take|thread|to|trait|' 

696 r'type|where|with|yield|yieldhome)\b', 

697 bygroups(Punctuation, Keyword)), 

698 

699 # other 

700 (r',', Punctuation, 'commamember'), 

701 (r'(and|or|not)\b', Operator.Word), 

702 (r'([a-z_][\w.]*)(\s*::\s*[a-z_][\w.]*)?(\s*=(?!=))', 

703 bygroups(Name, Name.Label, Operator)), 

704 (r'(/?)([\w.]+)', bygroups(Punctuation, Name.Other)), 

705 (r'(=)(n?bw|n?ew|n?cn|lte?|gte?|n?eq|n?rx|ft)\b', 

706 bygroups(Operator, Operator.Word)), 

707 (r':=|[-+*/%=<>&|!?\\]+', Operator), 

708 (r'[{}():;,@^]', Punctuation), 

709 ], 

710 'singlestring': [ 

711 (r"'", String.Single, '#pop'), 

712 (r"[^'\\]+", String.Single), 

713 include('escape'), 

714 (r"\\", String.Single), 

715 ], 

716 'doublestring': [ 

717 (r'"', String.Double, '#pop'), 

718 (r'[^"\\]+', String.Double), 

719 include('escape'), 

720 (r'\\', String.Double), 

721 ], 

722 'escape': [ 

723 (r'\\(U[\da-f]{8}|u[\da-f]{4}|x[\da-f]{1,2}|[0-7]{1,3}|:[^:\n\r]+:|' 

724 r'[abefnrtv?"\'\\]|$)', String.Escape), 

725 ], 

726 'signature': [ 

727 (r'=>', Operator, '#pop'), 

728 (r'\)', Punctuation, '#pop'), 

729 (r'[(,]', Punctuation, 'parameter'), 

730 include('lasso'), 

731 ], 

732 'parameter': [ 

733 (r'\)', Punctuation, '#pop'), 

734 (r'-?[a-z_][\w.]*', Name.Attribute, '#pop'), 

735 (r'\.\.\.', Name.Builtin.Pseudo), 

736 include('lasso'), 

737 ], 

738 'requiresection': [ 

739 (r'(([a-z_][\w.]*=?|[-+*/%])(?=\s*\())', Name, 'requiresignature'), 

740 (r'(([a-z_][\w.]*=?|[-+*/%])(?=(\s*::\s*[\w.]+)?\s*,))', Name), 

741 (r'[a-z_][\w.]*=?|[-+*/%]', Name, '#pop'), 

742 (r'::\s*[a-z_][\w.]*', Name.Label), 

743 (r',', Punctuation), 

744 include('whitespacecomments'), 

745 ], 

746 'requiresignature': [ 

747 (r'(\)(?=(\s*::\s*[\w.]+)?\s*,))', Punctuation, '#pop'), 

748 (r'\)', Punctuation, '#pop:2'), 

749 (r'-?[a-z_][\w.]*', Name.Attribute), 

750 (r'::\s*[a-z_][\w.]*', Name.Label), 

751 (r'\.\.\.', Name.Builtin.Pseudo), 

752 (r'[(,]', Punctuation), 

753 include('whitespacecomments'), 

754 ], 

755 'commamember': [ 

756 (r'(([a-z_][\w.]*=?|[-+*/%])' 

757 r'(?=\s*(\(([^()]*\([^()]*\))*[^)]*\)\s*)?(::[\w.\s]+)?=>))', 

758 Name.Function, 'signature'), 

759 include('whitespacecomments'), 

760 default('#pop'), 

761 ], 

762 } 

763 

764 def __init__(self, **options): 

765 self.builtinshighlighting = get_bool_opt( 

766 options, 'builtinshighlighting', True) 

767 self.requiredelimiters = get_bool_opt( 

768 options, 'requiredelimiters', False) 

769 

770 self._builtins = set() 

771 self._members = set() 

772 if self.builtinshighlighting: 

773 from pygments.lexers._lasso_builtins import BUILTINS, MEMBERS 

774 for key, value in BUILTINS.items(): 

775 self._builtins.update(value) 

776 for key, value in MEMBERS.items(): 

777 self._members.update(value) 

778 RegexLexer.__init__(self, **options) 

779 

780 def get_tokens_unprocessed(self, text): 

781 stack = ['root'] 

782 if self.requiredelimiters: 

783 stack.append('delimiters') 

784 for index, token, value in \ 

785 RegexLexer.get_tokens_unprocessed(self, text, stack): 

786 if (token is Name.Other and value.lower() in self._builtins or 

787 token is Name.Other.Member and 

788 value.lower().rstrip('=') in self._members): 

789 yield index, Name.Builtin, value 

790 continue 

791 yield index, token, value 

792 

793 def analyse_text(text): 

794 rv = 0.0 

795 if 'bin/lasso9' in text: 

796 rv += 0.8 

797 if re.search(r'<\?lasso', text, re.I): 

798 rv += 0.4 

799 if re.search(r'local\(', text, re.I): 

800 rv += 0.4 

801 return rv 

802 

803 

804class ObjectiveJLexer(RegexLexer): 

805 """ 

806 For Objective-J source code with preprocessor directives. 

807 

808 .. versionadded:: 1.3 

809 """ 

810 

811 name = 'Objective-J' 

812 aliases = ['objective-j', 'objectivej', 'obj-j', 'objj'] 

813 filenames = ['*.j'] 

814 mimetypes = ['text/x-objective-j'] 

815 

816 #: optional Comment or Whitespace 

817 _ws = r'(?:\s|//.*?\n|/[*].*?[*]/)*' 

818 

819 flags = re.DOTALL | re.MULTILINE 

820 

821 tokens = { 

822 'root': [ 

823 include('whitespace'), 

824 

825 # function definition 

826 (r'^(' + _ws + r'[+-]' + _ws + r')([(a-zA-Z_].*?[^(])(' + _ws + r'\{)', 

827 bygroups(using(this), using(this, state='function_signature'), 

828 using(this))), 

829 

830 # class definition 

831 (r'(@interface|@implementation)(\s+)', bygroups(Keyword, Text), 

832 'classname'), 

833 (r'(@class|@protocol)(\s*)', bygroups(Keyword, Text), 

834 'forward_classname'), 

835 (r'(\s*)(@end)(\s*)', bygroups(Text, Keyword, Text)), 

836 

837 include('statements'), 

838 ('[{()}]', Punctuation), 

839 (';', Punctuation), 

840 ], 

841 'whitespace': [ 

842 (r'(@import)(\s+)("(?:\\\\|\\"|[^"])*")', 

843 bygroups(Comment.Preproc, Text, String.Double)), 

844 (r'(@import)(\s+)(<(?:\\\\|\\>|[^>])*>)', 

845 bygroups(Comment.Preproc, Text, String.Double)), 

846 (r'(#(?:include|import))(\s+)("(?:\\\\|\\"|[^"])*")', 

847 bygroups(Comment.Preproc, Text, String.Double)), 

848 (r'(#(?:include|import))(\s+)(<(?:\\\\|\\>|[^>])*>)', 

849 bygroups(Comment.Preproc, Text, String.Double)), 

850 

851 (r'#if\s+0', Comment.Preproc, 'if0'), 

852 (r'#', Comment.Preproc, 'macro'), 

853 

854 (r'\n', Text), 

855 (r'\s+', Text), 

856 (r'\\\n', Text), # line continuation 

857 (r'//(\n|(.|\n)*?[^\\]\n)', Comment.Single), 

858 (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline), 

859 (r'<!--', Comment), 

860 ], 

861 'slashstartsregex': [ 

862 include('whitespace'), 

863 (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/' 

864 r'([gim]+\b|\B)', String.Regex, '#pop'), 

865 (r'(?=/)', Text, ('#pop', 'badregex')), 

866 default('#pop'), 

867 ], 

868 'badregex': [ 

869 (r'\n', Text, '#pop'), 

870 ], 

871 'statements': [ 

872 (r'(L|@)?"', String, 'string'), 

873 (r"(L|@)?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'", 

874 String.Char), 

875 (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double), 

876 (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single), 

877 (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?', Number.Float), 

878 (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float), 

879 (r'0x[0-9a-fA-F]+[Ll]?', Number.Hex), 

880 (r'0[0-7]+[Ll]?', Number.Oct), 

881 (r'\d+[Ll]?', Number.Integer), 

882 

883 (r'^(?=\s|/|<!--)', Text, 'slashstartsregex'), 

884 

885 (r'\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|' 

886 r'(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?', 

887 Operator, 'slashstartsregex'), 

888 (r'[{(\[;,]', Punctuation, 'slashstartsregex'), 

889 (r'[})\].]', Punctuation), 

890 

891 (r'(for|in|while|do|break|return|continue|switch|case|default|if|' 

892 r'else|throw|try|catch|finally|new|delete|typeof|instanceof|void|' 

893 r'prototype|__proto__)\b', Keyword, 'slashstartsregex'), 

894 

895 (r'(var|with|function)\b', Keyword.Declaration, 'slashstartsregex'), 

896 

897 (r'(@selector|@private|@protected|@public|@encode|' 

898 r'@synchronized|@try|@throw|@catch|@finally|@end|@property|' 

899 r'@synthesize|@dynamic|@for|@accessors|new)\b', Keyword), 

900 

901 (r'(int|long|float|short|double|char|unsigned|signed|void|' 

902 r'id|BOOL|bool|boolean|IBOutlet|IBAction|SEL|@outlet|@action)\b', 

903 Keyword.Type), 

904 

905 (r'(self|super)\b', Name.Builtin), 

906 

907 (r'(TRUE|YES|FALSE|NO|Nil|nil|NULL)\b', Keyword.Constant), 

908 (r'(true|false|null|NaN|Infinity|undefined)\b', Keyword.Constant), 

909 (r'(ABS|ASIN|ACOS|ATAN|ATAN2|SIN|COS|TAN|EXP|POW|CEIL|FLOOR|ROUND|' 

910 r'MIN|MAX|RAND|SQRT|E|LN2|LN10|LOG2E|LOG10E|PI|PI2|PI_2|SQRT1_2|' 

911 r'SQRT2)\b', Keyword.Constant), 

912 

913 (r'(Array|Boolean|Date|Error|Function|Math|' 

914 r'Number|Object|RegExp|String|decodeURI|' 

915 r'decodeURIComponent|encodeURI|encodeURIComponent|' 

916 r'Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|' 

917 r'window|globalThis|Symbol)\b', Name.Builtin), 

918 

919 (r'([$a-zA-Z_]\w*)(' + _ws + r')(?=\()', 

920 bygroups(Name.Function, using(this))), 

921 

922 (r'[$a-zA-Z_]\w*', Name), 

923 ], 

924 'classname': [ 

925 # interface definition that inherits 

926 (r'([a-zA-Z_]\w*)(' + _ws + r':' + _ws + 

927 r')([a-zA-Z_]\w*)?', 

928 bygroups(Name.Class, using(this), Name.Class), '#pop'), 

929 # interface definition for a category 

930 (r'([a-zA-Z_]\w*)(' + _ws + r'\()([a-zA-Z_]\w*)(\))', 

931 bygroups(Name.Class, using(this), Name.Label, Text), '#pop'), 

932 # simple interface / implementation 

933 (r'([a-zA-Z_]\w*)', Name.Class, '#pop'), 

934 ], 

935 'forward_classname': [ 

936 (r'([a-zA-Z_]\w*)(\s*,\s*)', 

937 bygroups(Name.Class, Text), '#push'), 

938 (r'([a-zA-Z_]\w*)(\s*;?)', 

939 bygroups(Name.Class, Text), '#pop'), 

940 ], 

941 'function_signature': [ 

942 include('whitespace'), 

943 

944 # start of a selector w/ parameters 

945 (r'(\(' + _ws + r')' # open paren 

946 r'([a-zA-Z_]\w+)' # return type 

947 r'(' + _ws + r'\)' + _ws + r')' # close paren 

948 r'([$a-zA-Z_]\w+' + _ws + r':)', # function name 

949 bygroups(using(this), Keyword.Type, using(this), 

950 Name.Function), 'function_parameters'), 

951 

952 # no-param function 

953 (r'(\(' + _ws + r')' # open paren 

954 r'([a-zA-Z_]\w+)' # return type 

955 r'(' + _ws + r'\)' + _ws + r')' # close paren 

956 r'([$a-zA-Z_]\w+)', # function name 

957 bygroups(using(this), Keyword.Type, using(this), 

958 Name.Function), "#pop"), 

959 

960 # no return type given, start of a selector w/ parameters 

961 (r'([$a-zA-Z_]\w+' + _ws + r':)', # function name 

962 bygroups(Name.Function), 'function_parameters'), 

963 

964 # no return type given, no-param function 

965 (r'([$a-zA-Z_]\w+)', # function name 

966 bygroups(Name.Function), "#pop"), 

967 

968 default('#pop'), 

969 ], 

970 'function_parameters': [ 

971 include('whitespace'), 

972 

973 # parameters 

974 (r'(\(' + _ws + ')' # open paren 

975 r'([^)]+)' # type 

976 r'(' + _ws + r'\)' + _ws + r')' # close paren 

977 r'([$a-zA-Z_]\w+)', # param name 

978 bygroups(using(this), Keyword.Type, using(this), Text)), 

979 

980 # one piece of a selector name 

981 (r'([$a-zA-Z_]\w+' + _ws + r':)', # function name 

982 Name.Function), 

983 

984 # smallest possible selector piece 

985 (r'(:)', Name.Function), 

986 

987 # var args 

988 (r'(,' + _ws + r'\.\.\.)', using(this)), 

989 

990 # param name 

991 (r'([$a-zA-Z_]\w+)', Text), 

992 ], 

993 'expression': [ 

994 (r'([$a-zA-Z_]\w*)(\()', bygroups(Name.Function, 

995 Punctuation)), 

996 (r'(\))', Punctuation, "#pop"), 

997 ], 

998 'string': [ 

999 (r'"', String, '#pop'), 

1000 (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})', String.Escape), 

1001 (r'[^\\"\n]+', String), # all other characters 

1002 (r'\\\n', String), # line continuation 

1003 (r'\\', String), # stray backslash 

1004 ], 

1005 'macro': [ 

1006 (r'[^/\n]+', Comment.Preproc), 

1007 (r'/[*](.|\n)*?[*]/', Comment.Multiline), 

1008 (r'//.*?\n', Comment.Single, '#pop'), 

1009 (r'/', Comment.Preproc), 

1010 (r'(?<=\\)\n', Comment.Preproc), 

1011 (r'\n', Comment.Preproc, '#pop'), 

1012 ], 

1013 'if0': [ 

1014 (r'^\s*#if.*?(?<!\\)\n', Comment.Preproc, '#push'), 

1015 (r'^\s*#endif.*?(?<!\\)\n', Comment.Preproc, '#pop'), 

1016 (r'.*?\n', Comment), 

1017 ] 

1018 } 

1019 

1020 def analyse_text(text): 

1021 if re.search(r'^\s*@import\s+[<"]', text, re.MULTILINE): 

1022 # special directive found in most Objective-J files 

1023 return True 

1024 return False 

1025 

1026 

1027class CoffeeScriptLexer(RegexLexer): 

1028 """ 

1029 For `CoffeeScript`_ source code. 

1030 

1031 .. _CoffeeScript: http://coffeescript.org 

1032 

1033 .. versionadded:: 1.3 

1034 """ 

1035 

1036 name = 'CoffeeScript' 

1037 aliases = ['coffee-script', 'coffeescript', 'coffee'] 

1038 filenames = ['*.coffee'] 

1039 mimetypes = ['text/coffeescript'] 

1040 

1041 _operator_re = ( 

1042 r'\+\+|~|&&|\band\b|\bor\b|\bis\b|\bisnt\b|\bnot\b|\?|:|' 

1043 r'\|\||\\(?=\n)|' 

1044 r'(<<|>>>?|==?(?!>)|!=?|=(?!>)|-(?!>)|[<>+*`%&|\^/])=?') 

1045 

1046 flags = re.DOTALL 

1047 tokens = { 

1048 'commentsandwhitespace': [ 

1049 (r'\s+', Text), 

1050 (r'###[^#].*?###', Comment.Multiline), 

1051 (r'#(?!##[^#]).*?\n', Comment.Single), 

1052 ], 

1053 'multilineregex': [ 

1054 (r'[^/#]+', String.Regex), 

1055 (r'///([gimuys]+\b|\B)', String.Regex, '#pop'), 

1056 (r'#\{', String.Interpol, 'interpoling_string'), 

1057 (r'[/#]', String.Regex), 

1058 ], 

1059 'slashstartsregex': [ 

1060 include('commentsandwhitespace'), 

1061 (r'///', String.Regex, ('#pop', 'multilineregex')), 

1062 (r'/(?! )(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/' 

1063 r'([gimuys]+\b|\B)', String.Regex, '#pop'), 

1064 # This isn't really guarding against mishighlighting well-formed 

1065 # code, just the ability to infinite-loop between root and 

1066 # slashstartsregex. 

1067 (r'/', Operator, '#pop'), 

1068 default('#pop'), 

1069 ], 

1070 'root': [ 

1071 include('commentsandwhitespace'), 

1072 (r'\A(?=\s|/)', Text, 'slashstartsregex'), 

1073 (_operator_re, Operator, 'slashstartsregex'), 

1074 (r'(?:\([^()]*\))?\s*[=-]>', Name.Function, 'slashstartsregex'), 

1075 (r'[{(\[;,]', Punctuation, 'slashstartsregex'), 

1076 (r'[})\].]', Punctuation), 

1077 (r'(?<![.$])(for|own|in|of|while|until|' 

1078 r'loop|break|return|continue|' 

1079 r'switch|when|then|if|unless|else|' 

1080 r'throw|try|catch|finally|new|delete|typeof|instanceof|super|' 

1081 r'extends|this|class|by)\b', Keyword, 'slashstartsregex'), 

1082 (r'(?<![.$])(true|false|yes|no|on|off|null|' 

1083 r'NaN|Infinity|undefined)\b', 

1084 Keyword.Constant), 

1085 (r'(Array|Boolean|Date|Error|Function|Math|' 

1086 r'Number|Object|RegExp|String|decodeURI|' 

1087 r'decodeURIComponent|encodeURI|encodeURIComponent|' 

1088 r'eval|isFinite|isNaN|parseFloat|parseInt|document|window|globalThis|Symbol)\b', 

1089 Name.Builtin), 

1090 (r'[$a-zA-Z_][\w.:$]*\s*[:=]\s', Name.Variable, 

1091 'slashstartsregex'), 

1092 (r'@[$a-zA-Z_][\w.:$]*\s*[:=]\s', Name.Variable.Instance, 

1093 'slashstartsregex'), 

1094 (r'@', Name.Other, 'slashstartsregex'), 

1095 (r'@?[$a-zA-Z_][\w$]*', Name.Other), 

1096 (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float), 

1097 (r'0x[0-9a-fA-F]+', Number.Hex), 

1098 (r'[0-9]+', Number.Integer), 

1099 ('"""', String, 'tdqs'), 

1100 ("'''", String, 'tsqs'), 

1101 ('"', String, 'dqs'), 

1102 ("'", String, 'sqs'), 

1103 ], 

1104 'strings': [ 

1105 (r'[^#\\\'"]+', String), 

1106 # note that all coffee script strings are multi-line. 

1107 # hashmarks, quotes and backslashes must be parsed one at a time 

1108 ], 

1109 'interpoling_string': [ 

1110 (r'\}', String.Interpol, "#pop"), 

1111 include('root') 

1112 ], 

1113 'dqs': [ 

1114 (r'"', String, '#pop'), 

1115 (r'\\.|\'', String), # double-quoted string don't need ' escapes 

1116 (r'#\{', String.Interpol, "interpoling_string"), 

1117 (r'#', String), 

1118 include('strings') 

1119 ], 

1120 'sqs': [ 

1121 (r"'", String, '#pop'), 

1122 (r'#|\\.|"', String), # single quoted strings don't need " escapses 

1123 include('strings') 

1124 ], 

1125 'tdqs': [ 

1126 (r'"""', String, '#pop'), 

1127 (r'\\.|\'|"', String), # no need to escape quotes in triple-string 

1128 (r'#\{', String.Interpol, "interpoling_string"), 

1129 (r'#', String), 

1130 include('strings'), 

1131 ], 

1132 'tsqs': [ 

1133 (r"'''", String, '#pop'), 

1134 (r'#|\\.|\'|"', String), # no need to escape quotes in triple-strings 

1135 include('strings') 

1136 ], 

1137 } 

1138 

1139 

1140class MaskLexer(RegexLexer): 

1141 """ 

1142 For `Mask <https://github.com/atmajs/MaskJS>`__ markup. 

1143 

1144 .. versionadded:: 2.0 

1145 """ 

1146 name = 'Mask' 

1147 aliases = ['mask'] 

1148 filenames = ['*.mask'] 

1149 mimetypes = ['text/x-mask'] 

1150 

1151 flags = re.MULTILINE | re.IGNORECASE | re.DOTALL 

1152 tokens = { 

1153 'root': [ 

1154 (r'\s+', Text), 

1155 (r'//.*?\n', Comment.Single), 

1156 (r'/\*.*?\*/', Comment.Multiline), 

1157 (r'[{};>]', Punctuation), 

1158 (r"'''", String, 'string-trpl-single'), 

1159 (r'"""', String, 'string-trpl-double'), 

1160 (r"'", String, 'string-single'), 

1161 (r'"', String, 'string-double'), 

1162 (r'([\w-]+)', Name.Tag, 'node'), 

1163 (r'([^.#;{>\s]+)', Name.Class, 'node'), 

1164 (r'(#[\w-]+)', Name.Function, 'node'), 

1165 (r'(\.[\w-]+)', Name.Variable.Class, 'node') 

1166 ], 

1167 'string-base': [ 

1168 (r'\\.', String.Escape), 

1169 (r'~\[', String.Interpol, 'interpolation'), 

1170 (r'.', String.Single), 

1171 ], 

1172 'string-single': [ 

1173 (r"'", String.Single, '#pop'), 

1174 include('string-base') 

1175 ], 

1176 'string-double': [ 

1177 (r'"', String.Single, '#pop'), 

1178 include('string-base') 

1179 ], 

1180 'string-trpl-single': [ 

1181 (r"'''", String.Single, '#pop'), 

1182 include('string-base') 

1183 ], 

1184 'string-trpl-double': [ 

1185 (r'"""', String.Single, '#pop'), 

1186 include('string-base') 

1187 ], 

1188 'interpolation': [ 

1189 (r'\]', String.Interpol, '#pop'), 

1190 (r'\s*:', String.Interpol, 'expression'), 

1191 (r'\s*\w+:', Name.Other), 

1192 (r'[^\]]+', String.Interpol) 

1193 ], 

1194 'expression': [ 

1195 (r'[^\]]+', using(JavascriptLexer), '#pop') 

1196 ], 

1197 'node': [ 

1198 (r'\s+', Text), 

1199 (r'\.', Name.Variable.Class, 'node-class'), 

1200 (r'\#', Name.Function, 'node-id'), 

1201 (r'style[ \t]*=', Name.Attribute, 'node-attr-style-value'), 

1202 (r'[\w:-]+[ \t]*=', Name.Attribute, 'node-attr-value'), 

1203 (r'[\w:-]+', Name.Attribute), 

1204 (r'[>{;]', Punctuation, '#pop') 

1205 ], 

1206 'node-class': [ 

1207 (r'[\w-]+', Name.Variable.Class), 

1208 (r'~\[', String.Interpol, 'interpolation'), 

1209 default('#pop') 

1210 ], 

1211 'node-id': [ 

1212 (r'[\w-]+', Name.Function), 

1213 (r'~\[', String.Interpol, 'interpolation'), 

1214 default('#pop') 

1215 ], 

1216 'node-attr-value': [ 

1217 (r'\s+', Text), 

1218 (r'\w+', Name.Variable, '#pop'), 

1219 (r"'", String, 'string-single-pop2'), 

1220 (r'"', String, 'string-double-pop2'), 

1221 default('#pop') 

1222 ], 

1223 'node-attr-style-value': [ 

1224 (r'\s+', Text), 

1225 (r"'", String.Single, 'css-single-end'), 

1226 (r'"', String.Single, 'css-double-end'), 

1227 include('node-attr-value') 

1228 ], 

1229 'css-base': [ 

1230 (r'\s+', Text), 

1231 (r";", Punctuation), 

1232 (r"[\w\-]+\s*:", Name.Builtin) 

1233 ], 

1234 'css-single-end': [ 

1235 include('css-base'), 

1236 (r"'", String.Single, '#pop:2'), 

1237 (r"[^;']+", Name.Entity) 

1238 ], 

1239 'css-double-end': [ 

1240 include('css-base'), 

1241 (r'"', String.Single, '#pop:2'), 

1242 (r'[^;"]+', Name.Entity) 

1243 ], 

1244 'string-single-pop2': [ 

1245 (r"'", String.Single, '#pop:2'), 

1246 include('string-base') 

1247 ], 

1248 'string-double-pop2': [ 

1249 (r'"', String.Single, '#pop:2'), 

1250 include('string-base') 

1251 ], 

1252 } 

1253 

1254 

1255class EarlGreyLexer(RegexLexer): 

1256 """ 

1257 For `Earl-Grey`_ source code. 

1258 

1259 .. _Earl-Grey: https://breuleux.github.io/earl-grey/ 

1260 

1261 .. versionadded: 2.1 

1262 """ 

1263 

1264 name = 'Earl Grey' 

1265 aliases = ['earl-grey', 'earlgrey', 'eg'] 

1266 filenames = ['*.eg'] 

1267 mimetypes = ['text/x-earl-grey'] 

1268 

1269 tokens = { 

1270 'root': [ 

1271 (r'\n', Text), 

1272 include('control'), 

1273 (r'[^\S\n]+', Text), 

1274 (r';;.*\n', Comment), 

1275 (r'[\[\]{}:(),;]', Punctuation), 

1276 (r'\\\n', Text), 

1277 (r'\\', Text), 

1278 include('errors'), 

1279 (words(( 

1280 'with', 'where', 'when', 'and', 'not', 'or', 'in', 

1281 'as', 'of', 'is'), 

1282 prefix=r'(?<=\s|\[)', suffix=r'(?![\w$\-])'), 

1283 Operator.Word), 

1284 (r'[*@]?->', Name.Function), 

1285 (r'[+\-*/~^<>%&|?!@#.]*=', Operator.Word), 

1286 (r'\.{2,3}', Operator.Word), # Range Operator 

1287 (r'([+*/~^<>&|?!]+)|([#\-](?=\s))|@@+(?=\s)|=+', Operator), 

1288 (r'(?<![\w$\-])(var|let)(?:[^\w$])', Keyword.Declaration), 

1289 include('keywords'), 

1290 include('builtins'), 

1291 include('assignment'), 

1292 (r'''(?x) 

1293 (?:()([a-zA-Z$_](?:[\w$\-]*[\w$])?)| 

1294 (?<=[\s{\[(])(\.)([a-zA-Z$_](?:[\w$\-]*[\w$])?)) 

1295 (?=.*%)''', 

1296 bygroups(Punctuation, Name.Tag, Punctuation, Name.Class.Start), 'dbs'), 

1297 (r'[rR]?`', String.Backtick, 'bt'), 

1298 (r'[rR]?```', String.Backtick, 'tbt'), 

1299 (r'(?<=[\s\[{(,;])\.([a-zA-Z$_](?:[\w$\-]*[\w$])?)' 

1300 r'(?=[\s\]}),;])', String.Symbol), 

1301 include('nested'), 

1302 (r'(?:[rR]|[rR]\.[gmi]{1,3})?"', String, combined('stringescape', 'dqs')), 

1303 (r'(?:[rR]|[rR]\.[gmi]{1,3})?\'', String, combined('stringescape', 'sqs')), 

1304 (r'"""', String, combined('stringescape', 'tdqs')), 

1305 include('tuple'), 

1306 include('import_paths'), 

1307 include('name'), 

1308 include('numbers'), 

1309 ], 

1310 'dbs': [ 

1311 (r'(\.)([a-zA-Z$_](?:[\w$\-]*[\w$])?)(?=[.\[\s])', 

1312 bygroups(Punctuation, Name.Class.DBS)), 

1313 (r'(\[)([\^#][a-zA-Z$_](?:[\w$\-]*[\w$])?)(\])', 

1314 bygroups(Punctuation, Name.Entity.DBS, Punctuation)), 

1315 (r'\s+', Text), 

1316 (r'%', Operator.DBS, '#pop'), 

1317 ], 

1318 'import_paths': [ 

1319 (r'(?<=[\s:;,])(\.{1,3}(?:[\w\-]*/)*)(\w(?:[\w\-]*\w)*)(?=[\s;,])', 

1320 bygroups(Text.Whitespace, Text)), 

1321 ], 

1322 'assignment': [ 

1323 (r'(\.)?([a-zA-Z$_](?:[\w$\-]*[\w$])?)' 

1324 r'(?=\s+[+\-*/~^<>%&|?!@#.]*\=\s)', 

1325 bygroups(Punctuation, Name.Variable)) 

1326 ], 

1327 'errors': [ 

1328 (words(('Error', 'TypeError', 'ReferenceError'), 

1329 prefix=r'(?<![\w\-$.])', suffix=r'(?![\w\-$.])'), 

1330 Name.Exception), 

1331 (r'''(?x) 

1332 (?<![\w$]) 

1333 E\.[\w$](?:[\w$\-]*[\w$])? 

1334 (?:\.[\w$](?:[\w$\-]*[\w$])?)* 

1335 (?=[({\[?!\s])''', 

1336 Name.Exception), 

1337 ], 

1338 'control': [ 

1339 (r'''(?x) 

1340 ([a-zA-Z$_](?:[\w$-]*[\w$])?) 

1341 (?!\n)\s+ 

1342 (?!and|as|each\*|each|in|is|mod|of|or|when|where|with) 

1343 (?=(?:[+\-*/~^<>%&|?!@#.])?[a-zA-Z$_](?:[\w$-]*[\w$])?)''', 

1344 Keyword.Control), 

1345 (r'([a-zA-Z$_](?:[\w$-]*[\w$])?)(?!\n)\s+(?=[\'"\d{\[(])', 

1346 Keyword.Control), 

1347 (r'''(?x) 

1348 (?: 

1349 (?<=[%=])| 

1350 (?<=[=\-]>)| 

1351 (?<=with|each|with)| 

1352 (?<=each\*|where) 

1353 )(\s+) 

1354 ([a-zA-Z$_](?:[\w$-]*[\w$])?)(:)''', 

1355 bygroups(Text, Keyword.Control, Punctuation)), 

1356 (r'''(?x) 

1357 (?<![+\-*/~^<>%&|?!@#.])(\s+) 

1358 ([a-zA-Z$_](?:[\w$-]*[\w$])?)(:)''', 

1359 bygroups(Text, Keyword.Control, Punctuation)), 

1360 ], 

1361 'nested': [ 

1362 (r'''(?x) 

1363 (?<=[\w$\]})])(\.) 

1364 ([a-zA-Z$_](?:[\w$-]*[\w$])?) 

1365 (?=\s+with(?:\s|\n))''', 

1366 bygroups(Punctuation, Name.Function)), 

1367 (r'''(?x) 

1368 (?<!\s)(\.) 

1369 ([a-zA-Z$_](?:[\w$-]*[\w$])?) 

1370 (?=[}\]).,;:\s])''', 

1371 bygroups(Punctuation, Name.Field)), 

1372 (r'''(?x) 

1373 (?<=[\w$\]})])(\.) 

1374 ([a-zA-Z$_](?:[\w$-]*[\w$])?) 

1375 (?=[\[{(:])''', 

1376 bygroups(Punctuation, Name.Function)), 

1377 ], 

1378 'keywords': [ 

1379 (words(( 

1380 'each', 'each*', 'mod', 'await', 'break', 'chain', 

1381 'continue', 'elif', 'expr-value', 'if', 'match', 

1382 'return', 'yield', 'pass', 'else', 'require', 'var', 

1383 'let', 'async', 'method', 'gen'), 

1384 prefix=r'(?<![\w\-$.])', suffix=r'(?![\w\-$.])'), 

1385 Keyword.Pseudo), 

1386 (words(('this', 'self', '@'), 

1387 prefix=r'(?<![\w\-$.])', suffix=r'(?![\w\-$])'), 

1388 Keyword.Constant), 

1389 (words(( 

1390 'Function', 'Object', 'Array', 'String', 'Number', 

1391 'Boolean', 'ErrorFactory', 'ENode', 'Promise'), 

1392 prefix=r'(?<![\w\-$.])', suffix=r'(?![\w\-$])'), 

1393 Keyword.Type), 

1394 ], 

1395 'builtins': [ 

1396 (words(( 

1397 'send', 'object', 'keys', 'items', 'enumerate', 'zip', 

1398 'product', 'neighbours', 'predicate', 'equal', 

1399 'nequal', 'contains', 'repr', 'clone', 'range', 

1400 'getChecker', 'get-checker', 'getProperty', 'get-property', 

1401 'getProjector', 'get-projector', 'consume', 'take', 

1402 'promisify', 'spawn', 'constructor'), 

1403 prefix=r'(?<![\w\-#.])', suffix=r'(?![\w\-.])'), 

1404 Name.Builtin), 

1405 (words(( 

1406 'true', 'false', 'null', 'undefined'), 

1407 prefix=r'(?<![\w\-$.])', suffix=r'(?![\w\-$.])'), 

1408 Name.Constant), 

1409 ], 

1410 'name': [ 

1411 (r'@([a-zA-Z$_](?:[\w$-]*[\w$])?)', Name.Variable.Instance), 

1412 (r'([a-zA-Z$_](?:[\w$-]*[\w$])?)(\+\+|\-\-)?', 

1413 bygroups(Name.Symbol, Operator.Word)) 

1414 ], 

1415 'tuple': [ 

1416 (r'#[a-zA-Z_][\w\-]*(?=[\s{(,;])', Name.Namespace) 

1417 ], 

1418 'interpoling_string': [ 

1419 (r'\}', String.Interpol, '#pop'), 

1420 include('root') 

1421 ], 

1422 'stringescape': [ 

1423 (r'\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|' 

1424 r'U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})', String.Escape) 

1425 ], 

1426 'strings': [ 

1427 (r'[^\\\'"]', String), 

1428 (r'[\'"\\]', String), 

1429 (r'\n', String) # All strings are multiline in EG 

1430 ], 

1431 'dqs': [ 

1432 (r'"', String, '#pop'), 

1433 (r'\\\\|\\"|\\\n', String.Escape), 

1434 include('strings') 

1435 ], 

1436 'sqs': [ 

1437 (r"'", String, '#pop'), 

1438 (r"\\\\|\\'|\\\n", String.Escape), 

1439 (r'\{', String.Interpol, 'interpoling_string'), 

1440 include('strings') 

1441 ], 

1442 'tdqs': [ 

1443 (r'"""', String, '#pop'), 

1444 include('strings'), 

1445 ], 

1446 'bt': [ 

1447 (r'`', String.Backtick, '#pop'), 

1448 (r'(?<!`)\n', String.Backtick), 

1449 (r'\^=?', String.Escape), 

1450 (r'.+', String.Backtick), 

1451 ], 

1452 'tbt': [ 

1453 (r'```', String.Backtick, '#pop'), 

1454 (r'\n', String.Backtick), 

1455 (r'\^=?', String.Escape), 

1456 (r'[^`]+', String.Backtick), 

1457 ], 

1458 'numbers': [ 

1459 (r'\d+\.(?!\.)\d*([eE][+-]?[0-9]+)?', Number.Float), 

1460 (r'\d+[eE][+-]?[0-9]+', Number.Float), 

1461 (r'8r[0-7]+', Number.Oct), 

1462 (r'2r[01]+', Number.Bin), 

1463 (r'16r[a-fA-F0-9]+', Number.Hex), 

1464 (r'([3-79]|[12][0-9]|3[0-6])r[a-zA-Z\d]+(\.[a-zA-Z\d]+)?', 

1465 Number.Radix), 

1466 (r'\d+', Number.Integer) 

1467 ], 

1468 } 

1469 

1470 

1471class JuttleLexer(RegexLexer): 

1472 """ 

1473 For `Juttle`_ source code. 

1474 

1475 .. _Juttle: https://github.com/juttle/juttle 

1476 

1477 .. versionadded:: 2.2 

1478 """ 

1479 

1480 name = 'Juttle' 

1481 aliases = ['juttle'] 

1482 filenames = ['*.juttle'] 

1483 mimetypes = ['application/juttle', 'application/x-juttle', 

1484 'text/x-juttle', 'text/juttle'] 

1485 

1486 flags = re.DOTALL | re.UNICODE | re.MULTILINE 

1487 

1488 tokens = { 

1489 'commentsandwhitespace': [ 

1490 (r'\s+', Text), 

1491 (r'//.*?\n', Comment.Single), 

1492 (r'/\*.*?\*/', Comment.Multiline) 

1493 ], 

1494 'slashstartsregex': [ 

1495 include('commentsandwhitespace'), 

1496 (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/' 

1497 r'([gimuys]+\b|\B)', String.Regex, '#pop'), 

1498 (r'(?=/)', Text, ('#pop', 'badregex')), 

1499 default('#pop') 

1500 ], 

1501 'badregex': [ 

1502 (r'\n', Text, '#pop') 

1503 ], 

1504 'root': [ 

1505 (r'^(?=\s|/)', Text, 'slashstartsregex'), 

1506 include('commentsandwhitespace'), 

1507 (r':\d{2}:\d{2}:\d{2}(\.\d*)?:', String.Moment), 

1508 (r':(now|beginning|end|forever|yesterday|today|tomorrow|' 

1509 r'(\d+(\.\d*)?|\.\d+)(ms|[smhdwMy])?):', String.Moment), 

1510 (r':\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d*)?)?' 

1511 r'(Z|[+-]\d{2}:\d{2}|[+-]\d{4})?:', String.Moment), 

1512 (r':((\d+(\.\d*)?|\.\d+)[ ]+)?(millisecond|second|minute|hour|' 

1513 r'day|week|month|year)[s]?' 

1514 r'(([ ]+and[ ]+(\d+[ ]+)?(millisecond|second|minute|hour|' 

1515 r'day|week|month|year)[s]?)' 

1516 r'|[ ]+(ago|from[ ]+now))*:', String.Moment), 

1517 (r'\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|' 

1518 r'(==?|!=?|[-<>+*%&|^/])=?', Operator, 'slashstartsregex'), 

1519 (r'[{(\[;,]', Punctuation, 'slashstartsregex'), 

1520 (r'[})\].]', Punctuation), 

1521 (r'(import|return|continue|if|else)\b', Keyword, 'slashstartsregex'), 

1522 (r'(var|const|function|reducer|sub|input)\b', Keyword.Declaration, 

1523 'slashstartsregex'), 

1524 (r'(batch|emit|filter|head|join|keep|pace|pass|put|read|reduce|remove|' 

1525 r'sequence|skip|sort|split|tail|unbatch|uniq|view|write)\b', 

1526 Keyword.Reserved), 

1527 (r'(true|false|null|Infinity)\b', Keyword.Constant), 

1528 (r'(Array|Date|Juttle|Math|Number|Object|RegExp|String)\b', 

1529 Name.Builtin), 

1530 (JS_IDENT, Name.Other), 

1531 (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float), 

1532 (r'[0-9]+', Number.Integer), 

1533 (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double), 

1534 (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single), 

1535 ] 

1536 

1537 }