GPQAPP

1
// CodeMirror, copyright (c) by Marijn Haverbeke and others
2
// Distributed under an MIT license: https://codemirror.net/LICENSE
3

4
(function(mod) {
5
  if (typeof exports == "object" && typeof module == "object") // CommonJS
6
    mod(require("../../lib/codemirror"), require("../python/python"), require("../stex/stex"), require("../../addon/mode/overlay"));
7
  else if (typeof define == "function" && define.amd) // AMD
8
    define(["../../lib/codemirror", "../python/python", "../stex/stex", "../../addon/mode/overlay"], mod);
9
  else // Plain browser env
10
    mod(CodeMirror);
11
})(function(CodeMirror) {
12
"use strict";
13

14
CodeMirror.defineMode('rst', function (config, options) {
15

16
  var rx_strong = /^\*\*[^\*\s](?:[^\*]*[^\*\s])?\*\*/;
17
  var rx_emphasis = /^\*[^\*\s](?:[^\*]*[^\*\s])?\*/;
18
  var rx_literal = /^``[^`\s](?:[^`]*[^`\s])``/;
19

20
  var rx_number = /^(?:[\d]+(?:[\.,]\d+)*)/;
21
  var rx_positive = /^(?:\s\+[\d]+(?:[\.,]\d+)*)/;
22
  var rx_negative = /^(?:\s\-[\d]+(?:[\.,]\d+)*)/;
23

24
  var rx_uri_protocol = "[Hh][Tt][Tt][Pp][Ss]?://";
25
  var rx_uri_domain = "(?:[\\d\\w.-]+)\\.(?:\\w{2,6})";
26
  var rx_uri_path = "(?:/[\\d\\w\\#\\%\\&\\-\\.\\,\\/\\:\\=\\?\\~]+)*";
27
  var rx_uri = new RegExp("^" + rx_uri_protocol + rx_uri_domain + rx_uri_path);
28

29
  var overlay = {
30
    token: function (stream) {
31

32
      if (stream.match(rx_strong) && stream.match (/\W+|$/, false))
33
        return 'strong';
34
      if (stream.match(rx_emphasis) && stream.match (/\W+|$/, false))
35
        return 'em';
36
      if (stream.match(rx_literal) && stream.match (/\W+|$/, false))
37
        return 'string-2';
38
      if (stream.match(rx_number))
39
        return 'number';
40
      if (stream.match(rx_positive))
41
        return 'positive';
42
      if (stream.match(rx_negative))
43
        return 'negative';
44
      if (stream.match(rx_uri))
45
        return 'link';
46

47
      while (stream.next() != null) {
48
        if (stream.match(rx_strong, false)) break;
49
        if (stream.match(rx_emphasis, false)) break;
50
        if (stream.match(rx_literal, false)) break;
51
        if (stream.match(rx_number, false)) break;
52
        if (stream.match(rx_positive, false)) break;
53
        if (stream.match(rx_negative, false)) break;
54
        if (stream.match(rx_uri, false)) break;
55
      }
56

57
      return null;
58
    }
59
  };
60

61
  var mode = CodeMirror.getMode(
62
    config, options.backdrop || 'rst-base'
63
  );
64

65
  return CodeMirror.overlayMode(mode, overlay, true); // combine
66
}, 'python', 'stex');
67

68
///////////////////////////////////////////////////////////////////////////////
69
///////////////////////////////////////////////////////////////////////////////
70

71
CodeMirror.defineMode('rst-base', function (config) {
72

73
  ///////////////////////////////////////////////////////////////////////////
74
  ///////////////////////////////////////////////////////////////////////////
75

76
  function format(string) {
77
    var args = Array.prototype.slice.call(arguments, 1);
78
    return string.replace(/{(\d+)}/g, function (match, n) {
79
      return typeof args[n] != 'undefined' ? args[n] : match;
80
    });
81
  }
82

83
  ///////////////////////////////////////////////////////////////////////////
84
  ///////////////////////////////////////////////////////////////////////////
85

86
  var mode_python = CodeMirror.getMode(config, 'python');
87
  var mode_stex = CodeMirror.getMode(config, 'stex');
88

89
  ///////////////////////////////////////////////////////////////////////////
90
  ///////////////////////////////////////////////////////////////////////////
91

92
  var SEPA = "\\s+";
93
  var TAIL = "(?:\\s*|\\W|$)",
94
  rx_TAIL = new RegExp(format('^{0}', TAIL));
95

96
  var NAME =
97
    "(?:[^\\W\\d_](?:[\\w!\"#$%&'()\\*\\+,\\-\\.\/:;<=>\\?]*[^\\W_])?)",
98
  rx_NAME = new RegExp(format('^{0}', NAME));
99
  var NAME_WWS =
100
    "(?:[^\\W\\d_](?:[\\w\\s!\"#$%&'()\\*\\+,\\-\\.\/:;<=>\\?]*[^\\W_])?)";
101
  var REF_NAME = format('(?:{0}|`{1}`)', NAME, NAME_WWS);
102

103
  var TEXT1 = "(?:[^\\s\\|](?:[^\\|]*[^\\s\\|])?)";
104
  var TEXT2 = "(?:[^\\`]+)",
105
  rx_TEXT2 = new RegExp(format('^{0}', TEXT2));
106

107
  var rx_section = new RegExp(
108
    "^([!'#$%&\"()*+,-./:;<=>?@\\[\\\\\\]^_`{|}~])\\1{3,}\\s*$");
109
  var rx_explicit = new RegExp(
110
    format('^\\.\\.{0}', SEPA));
111
  var rx_link = new RegExp(
112
    format('^_{0}:{1}|^__:{1}', REF_NAME, TAIL));
113
  var rx_directive = new RegExp(
114
    format('^{0}::{1}', REF_NAME, TAIL));
115
  var rx_substitution = new RegExp(
116
    format('^\\|{0}\\|{1}{2}::{3}', TEXT1, SEPA, REF_NAME, TAIL));
117
  var rx_footnote = new RegExp(
118
    format('^\\[(?:\\d+|#{0}?|\\*)]{1}', REF_NAME, TAIL));
119
  var rx_citation = new RegExp(
120
    format('^\\[{0}\\]{1}', REF_NAME, TAIL));
121

122
  var rx_substitution_ref = new RegExp(
123
    format('^\\|{0}\\|', TEXT1));
124
  var rx_footnote_ref = new RegExp(
125
    format('^\\[(?:\\d+|#{0}?|\\*)]_', REF_NAME));
126
  var rx_citation_ref = new RegExp(
127
    format('^\\[{0}\\]_', REF_NAME));
128
  var rx_link_ref1 = new RegExp(
129
    format('^{0}__?', REF_NAME));
130
  var rx_link_ref2 = new RegExp(
131
    format('^`{0}`_', TEXT2));
132

133
  var rx_role_pre = new RegExp(
134
    format('^:{0}:`{1}`{2}', NAME, TEXT2, TAIL));
135
  var rx_role_suf = new RegExp(
136
    format('^`{1}`:{0}:{2}', NAME, TEXT2, TAIL));
137
  var rx_role = new RegExp(
138
    format('^:{0}:{1}', NAME, TAIL));
139

140
  var rx_directive_name = new RegExp(format('^{0}', REF_NAME));
141
  var rx_directive_tail = new RegExp(format('^::{0}', TAIL));
142
  var rx_substitution_text = new RegExp(format('^\\|{0}\\|', TEXT1));
143
  var rx_substitution_sepa = new RegExp(format('^{0}', SEPA));
144
  var rx_substitution_name = new RegExp(format('^{0}', REF_NAME));
145
  var rx_substitution_tail = new RegExp(format('^::{0}', TAIL));
146
  var rx_link_head = new RegExp("^_");
147
  var rx_link_name = new RegExp(format('^{0}|_', REF_NAME));
148
  var rx_link_tail = new RegExp(format('^:{0}', TAIL));
149

150
  var rx_verbatim = new RegExp('^::\\s*$');
151
  var rx_examples = new RegExp('^\\s+(?:>>>|In \\[\\d+\\]:)\\s');
152

153
  ///////////////////////////////////////////////////////////////////////////
154
  ///////////////////////////////////////////////////////////////////////////
155

156
  function to_normal(stream, state) {
157
    var token = null;
158

159
    if (stream.sol() && stream.match(rx_examples, false)) {
160
      change(state, to_mode, {
161
        mode: mode_python, local: CodeMirror.startState(mode_python)
162
      });
163
    } else if (stream.sol() && stream.match(rx_explicit)) {
164
      change(state, to_explicit);
165
      token = 'meta';
166
    } else if (stream.sol() && stream.match(rx_section)) {
167
      change(state, to_normal);
168
      token = 'header';
169
    } else if (phase(state) == rx_role_pre ||
170
               stream.match(rx_role_pre, false)) {
171

172
      switch (stage(state)) {
173
      case 0:
174
        change(state, to_normal, context(rx_role_pre, 1));
175
        stream.match(/^:/);
176
        token = 'meta';
177
        break;
178
      case 1:
179
        change(state, to_normal, context(rx_role_pre, 2));
180
        stream.match(rx_NAME);
181
        token = 'keyword';
182

183
        if (stream.current().match(/^(?:math|latex)/)) {
184
          state.tmp_stex = true;
185
        }
186
        break;
187
      case 2:
188
        change(state, to_normal, context(rx_role_pre, 3));
189
        stream.match(/^:`/);
190
        token = 'meta';
191
        break;
192
      case 3:
193
        if (state.tmp_stex) {
194
          state.tmp_stex = undefined; state.tmp = {
195
            mode: mode_stex, local: CodeMirror.startState(mode_stex)
196
          };
197
        }
198

199
        if (state.tmp) {
200
          if (stream.peek() == '`') {
201
            change(state, to_normal, context(rx_role_pre, 4));
202
            state.tmp = undefined;
203
            break;
204
          }
205

206
          token = state.tmp.mode.token(stream, state.tmp.local);
207
          break;
208
        }
209

210
        change(state, to_normal, context(rx_role_pre, 4));
211
        stream.match(rx_TEXT2);
212
        token = 'string';
213
        break;
214
      case 4:
215
        change(state, to_normal, context(rx_role_pre, 5));
216
        stream.match(/^`/);
217
        token = 'meta';
218
        break;
219
      case 5:
220
        change(state, to_normal, context(rx_role_pre, 6));
221
        stream.match(rx_TAIL);
222
        break;
223
      default:
224
        change(state, to_normal);
225
      }
226
    } else if (phase(state) == rx_role_suf ||
227
               stream.match(rx_role_suf, false)) {
228

229
      switch (stage(state)) {
230
      case 0:
231
        change(state, to_normal, context(rx_role_suf, 1));
232
        stream.match(/^`/);
233
        token = 'meta';
234
        break;
235
      case 1:
236
        change(state, to_normal, context(rx_role_suf, 2));
237
        stream.match(rx_TEXT2);
238
        token = 'string';
239
        break;
240
      case 2:
241
        change(state, to_normal, context(rx_role_suf, 3));
242
        stream.match(/^`:/);
243
        token = 'meta';
244
        break;
245
      case 3:
246
        change(state, to_normal, context(rx_role_suf, 4));
247
        stream.match(rx_NAME);
248
        token = 'keyword';
249
        break;
250
      case 4:
251
        change(state, to_normal, context(rx_role_suf, 5));
252
        stream.match(/^:/);
253
        token = 'meta';
254
        break;
255
      case 5:
256
        change(state, to_normal, context(rx_role_suf, 6));
257
        stream.match(rx_TAIL);
258
        break;
259
      default:
260
        change(state, to_normal);
261
      }
262
    } else if (phase(state) == rx_role || stream.match(rx_role, false)) {
263

264
      switch (stage(state)) {
265
      case 0:
266
        change(state, to_normal, context(rx_role, 1));
267
        stream.match(/^:/);
268
        token = 'meta';
269
        break;
270
      case 1:
271
        change(state, to_normal, context(rx_role, 2));
272
        stream.match(rx_NAME);
273
        token = 'keyword';
274
        break;
275
      case 2:
276
        change(state, to_normal, context(rx_role, 3));
277
        stream.match(/^:/);
278
        token = 'meta';
279
        break;
280
      case 3:
281
        change(state, to_normal, context(rx_role, 4));
282
        stream.match(rx_TAIL);
283
        break;
284
      default:
285
        change(state, to_normal);
286
      }
287
    } else if (phase(state) == rx_substitution_ref ||
288
               stream.match(rx_substitution_ref, false)) {
289

290
      switch (stage(state)) {
291
      case 0:
292
        change(state, to_normal, context(rx_substitution_ref, 1));
293
        stream.match(rx_substitution_text);
294
        token = 'variable-2';
295
        break;
296
      case 1:
297
        change(state, to_normal, context(rx_substitution_ref, 2));
298
        if (stream.match(/^_?_?/)) token = 'link';
299
        break;
300
      default:
301
        change(state, to_normal);
302
      }
303
    } else if (stream.match(rx_footnote_ref)) {
304
      change(state, to_normal);
305
      token = 'quote';
306
    } else if (stream.match(rx_citation_ref)) {
307
      change(state, to_normal);
308
      token = 'quote';
309
    } else if (stream.match(rx_link_ref1)) {
310
      change(state, to_normal);
311
      if (!stream.peek() || stream.peek().match(/^\W$/)) {
312
        token = 'link';
313
      }
314
    } else if (phase(state) == rx_link_ref2 ||
315
               stream.match(rx_link_ref2, false)) {
316

317
      switch (stage(state)) {
318
      case 0:
319
        if (!stream.peek() || stream.peek().match(/^\W$/)) {
320
          change(state, to_normal, context(rx_link_ref2, 1));
321
        } else {
322
          stream.match(rx_link_ref2);
323
        }
324
        break;
325
      case 1:
326
        change(state, to_normal, context(rx_link_ref2, 2));
327
        stream.match(/^`/);
328
        token = 'link';
329
        break;
330
      case 2:
331
        change(state, to_normal, context(rx_link_ref2, 3));
332
        stream.match(rx_TEXT2);
333
        break;
334
      case 3:
335
        change(state, to_normal, context(rx_link_ref2, 4));
336
        stream.match(/^`_/);
337
        token = 'link';
338
        break;
339
      default:
340
        change(state, to_normal);
341
      }
342
    } else if (stream.match(rx_verbatim)) {
343
      change(state, to_verbatim);
344
    }
345

346
    else {
347
      if (stream.next()) change(state, to_normal);
348
    }
349

350
    return token;
351
  }
352

353
  ///////////////////////////////////////////////////////////////////////////
354
  ///////////////////////////////////////////////////////////////////////////
355

356
  function to_explicit(stream, state) {
357
    var token = null;
358

359
    if (phase(state) == rx_substitution ||
360
        stream.match(rx_substitution, false)) {
361

362
      switch (stage(state)) {
363
      case 0:
364
        change(state, to_explicit, context(rx_substitution, 1));
365
        stream.match(rx_substitution_text);
366
        token = 'variable-2';
367
        break;
368
      case 1:
369
        change(state, to_explicit, context(rx_substitution, 2));
370
        stream.match(rx_substitution_sepa);
371
        break;
372
      case 2:
373
        change(state, to_explicit, context(rx_substitution, 3));
374
        stream.match(rx_substitution_name);
375
        token = 'keyword';
376
        break;
377
      case 3:
378
        change(state, to_explicit, context(rx_substitution, 4));
379
        stream.match(rx_substitution_tail);
380
        token = 'meta';
381
        break;
382
      default:
383
        change(state, to_normal);
384
      }
385
    } else if (phase(state) == rx_directive ||
386
               stream.match(rx_directive, false)) {
387

388
      switch (stage(state)) {
389
      case 0:
390
        change(state, to_explicit, context(rx_directive, 1));
391
        stream.match(rx_directive_name);
392
        token = 'keyword';
393

394
        if (stream.current().match(/^(?:math|latex)/))
395
          state.tmp_stex = true;
396
        else if (stream.current().match(/^python/))
397
          state.tmp_py = true;
398
        break;
399
      case 1:
400
        change(state, to_explicit, context(rx_directive, 2));
401
        stream.match(rx_directive_tail);
402
        token = 'meta';
403

404
        if (stream.match(/^latex\s*$/) || state.tmp_stex) {
405
          state.tmp_stex = undefined; change(state, to_mode, {
406
            mode: mode_stex, local: CodeMirror.startState(mode_stex)
407
          });
408
        }
409
        break;
410
      case 2:
411
        change(state, to_explicit, context(rx_directive, 3));
412
        if (stream.match(/^python\s*$/) || state.tmp_py) {
413
          state.tmp_py = undefined; change(state, to_mode, {
414
            mode: mode_python, local: CodeMirror.startState(mode_python)
415
          });
416
        }
417
        break;
418
      default:
419
        change(state, to_normal);
420
      }
421
    } else if (phase(state) == rx_link || stream.match(rx_link, false)) {
422

423
      switch (stage(state)) {
424
      case 0:
425
        change(state, to_explicit, context(rx_link, 1));
426
        stream.match(rx_link_head);
427
        stream.match(rx_link_name);
428
        token = 'link';
429
        break;
430
      case 1:
431
        change(state, to_explicit, context(rx_link, 2));
432
        stream.match(rx_link_tail);
433
        token = 'meta';
434
        break;
435
      default:
436
        change(state, to_normal);
437
      }
438
    } else if (stream.match(rx_footnote)) {
439
      change(state, to_normal);
440
      token = 'quote';
441
    } else if (stream.match(rx_citation)) {
442
      change(state, to_normal);
443
      token = 'quote';
444
    }
445

446
    else {
447
      stream.eatSpace();
448
      if (stream.eol()) {
449
        change(state, to_normal);
450
      } else {
451
        stream.skipToEnd();
452
        change(state, to_comment);
453
        token = 'comment';
454
      }
455
    }
456

457
    return token;
458
  }
459

460
  ///////////////////////////////////////////////////////////////////////////
461
  ///////////////////////////////////////////////////////////////////////////
462

463
  function to_comment(stream, state) {
464
    return as_block(stream, state, 'comment');
465
  }
466

467
  function to_verbatim(stream, state) {
468
    return as_block(stream, state, 'meta');
469
  }
470

471
  function as_block(stream, state, token) {
472
    if (stream.eol() || stream.eatSpace()) {
473
      stream.skipToEnd();
474
      return token;
475
    } else {
476
      change(state, to_normal);
477
      return null;
478
    }
479
  }
480

481
  ///////////////////////////////////////////////////////////////////////////
482
  ///////////////////////////////////////////////////////////////////////////
483

484
  function to_mode(stream, state) {
485

486
    if (state.ctx.mode && state.ctx.local) {
487

488
      if (stream.sol()) {
489
        if (!stream.eatSpace()) change(state, to_normal);
490
        return null;
491
      }
492

493
      return state.ctx.mode.token(stream, state.ctx.local);
494
    }
495

496
    change(state, to_normal);
497
    return null;
498
  }
499

500
  ///////////////////////////////////////////////////////////////////////////
501
  ///////////////////////////////////////////////////////////////////////////
502

503
  function context(phase, stage, mode, local) {
504
    return {phase: phase, stage: stage, mode: mode, local: local};
505
  }
506

507
  function change(state, tok, ctx) {
508
    state.tok = tok;
509
    state.ctx = ctx || {};
510
  }
511

512
  function stage(state) {
513
    return state.ctx.stage || 0;
514
  }
515

516
  function phase(state) {
517
    return state.ctx.phase;
518
  }
519

520
  ///////////////////////////////////////////////////////////////////////////
521
  ///////////////////////////////////////////////////////////////////////////
522

523
  return {
524
    startState: function () {
525
      return {tok: to_normal, ctx: context(undefined, 0)};
526
    },
527

528
    copyState: function (state) {
529
      var ctx = state.ctx, tmp = state.tmp;
530
      if (ctx.local)
531
        ctx = {mode: ctx.mode, local: CodeMirror.copyState(ctx.mode, ctx.local)};
532
      if (tmp)
533
        tmp = {mode: tmp.mode, local: CodeMirror.copyState(tmp.mode, tmp.local)};
534
      return {tok: state.tok, ctx: ctx, tmp: tmp};
535
    },
536

537
    innerMode: function (state) {
538
      return state.tmp      ? {state: state.tmp.local, mode: state.tmp.mode}
539
      : state.ctx.mode ? {state: state.ctx.local, mode: state.ctx.mode}
540
      : null;
541
    },
542

543
    token: function (stream, state) {
544
      return state.tok(stream, state);
545
    }
546
  };
547
}, 'python', 'stex');
548

549
///////////////////////////////////////////////////////////////////////////////
550
///////////////////////////////////////////////////////////////////////////////
551

552
CodeMirror.defineMIME('text/x-rst', 'rst');
553

554
///////////////////////////////////////////////////////////////////////////////
555
///////////////////////////////////////////////////////////////////////////////
556

557
});
558