osbzr
/
com
项目红包剩余9514，下一贡献奖励5%，即 476个红包
Watch 15
Star 7
Wiki 捐赠
本站源代码
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 4f0cac5ea6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4f0cac5ea6'
${ noResults }
com/public/vendor/plugins/codemirror/mode/rst/rst.js

558 lines
17KB
Raw Blame History 

  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. });
上海开阖软件有限公司 沪ICP备12045867号-1