|
0
|
1 // CodeMirror, copyright (c) by Marijn Haverbeke and others
|
|
|
2 // Distributed under an MIT license: https://codemirror.net/5/LICENSE
|
|
|
3
|
|
|
4 (function(mod) {
|
|
|
5 if (typeof exports == "object" && typeof module == "object") { // CommonJS
|
|
|
6 mod(require("../../lib/codemirror"));
|
|
|
7 } else if (typeof define == "function" && define.amd) { // AMD
|
|
|
8 define(["../../lib/codemirror"], mod);
|
|
|
9 } else { // Plain browser env
|
|
|
10 mod(CodeMirror);
|
|
|
11 }
|
|
|
12 })(function(CodeMirror) {
|
|
|
13 "use strict";
|
|
|
14
|
|
|
15 var TOKEN_STYLES = {
|
|
|
16 addition: "positive",
|
|
|
17 attributes: "attribute",
|
|
|
18 bold: "strong",
|
|
|
19 cite: "keyword",
|
|
|
20 code: "atom",
|
|
|
21 definitionList: "number",
|
|
|
22 deletion: "negative",
|
|
|
23 div: "punctuation",
|
|
|
24 em: "em",
|
|
|
25 footnote: "variable",
|
|
|
26 footCite: "qualifier",
|
|
|
27 header: "header",
|
|
|
28 html: "comment",
|
|
|
29 image: "string",
|
|
|
30 italic: "em",
|
|
|
31 link: "link",
|
|
|
32 linkDefinition: "link",
|
|
|
33 list1: "variable-2",
|
|
|
34 list2: "variable-3",
|
|
|
35 list3: "keyword",
|
|
|
36 notextile: "string-2",
|
|
|
37 pre: "operator",
|
|
|
38 p: "property",
|
|
|
39 quote: "bracket",
|
|
|
40 span: "quote",
|
|
|
41 specialChar: "tag",
|
|
|
42 strong: "strong",
|
|
|
43 sub: "builtin",
|
|
|
44 sup: "builtin",
|
|
|
45 table: "variable-3",
|
|
|
46 tableHeading: "operator"
|
|
|
47 };
|
|
|
48
|
|
|
49 function startNewLine(stream, state) {
|
|
|
50 state.mode = Modes.newLayout;
|
|
|
51 state.tableHeading = false;
|
|
|
52
|
|
|
53 if (state.layoutType === "definitionList" && state.spanningLayout &&
|
|
|
54 stream.match(RE("definitionListEnd"), false))
|
|
|
55 state.spanningLayout = false;
|
|
|
56 }
|
|
|
57
|
|
|
58 function handlePhraseModifier(stream, state, ch) {
|
|
|
59 if (ch === "_") {
|
|
|
60 if (stream.eat("_"))
|
|
|
61 return togglePhraseModifier(stream, state, "italic", /__/, 2);
|
|
|
62 else
|
|
|
63 return togglePhraseModifier(stream, state, "em", /_/, 1);
|
|
|
64 }
|
|
|
65
|
|
|
66 if (ch === "*") {
|
|
|
67 if (stream.eat("*")) {
|
|
|
68 return togglePhraseModifier(stream, state, "bold", /\*\*/, 2);
|
|
|
69 }
|
|
|
70 return togglePhraseModifier(stream, state, "strong", /\*/, 1);
|
|
|
71 }
|
|
|
72
|
|
|
73 if (ch === "[") {
|
|
|
74 if (stream.match(/\d+\]/)) state.footCite = true;
|
|
|
75 return tokenStyles(state);
|
|
|
76 }
|
|
|
77
|
|
|
78 if (ch === "(") {
|
|
|
79 var spec = stream.match(/^(r|tm|c)\)/);
|
|
|
80 if (spec)
|
|
|
81 return tokenStylesWith(state, TOKEN_STYLES.specialChar);
|
|
|
82 }
|
|
|
83
|
|
|
84 if (ch === "<" && stream.match(/(\w+)[^>]+>[^<]+<\/\1>/))
|
|
|
85 return tokenStylesWith(state, TOKEN_STYLES.html);
|
|
|
86
|
|
|
87 if (ch === "?" && stream.eat("?"))
|
|
|
88 return togglePhraseModifier(stream, state, "cite", /\?\?/, 2);
|
|
|
89
|
|
|
90 if (ch === "=" && stream.eat("="))
|
|
|
91 return togglePhraseModifier(stream, state, "notextile", /==/, 2);
|
|
|
92
|
|
|
93 if (ch === "-" && !stream.eat("-"))
|
|
|
94 return togglePhraseModifier(stream, state, "deletion", /-/, 1);
|
|
|
95
|
|
|
96 if (ch === "+")
|
|
|
97 return togglePhraseModifier(stream, state, "addition", /\+/, 1);
|
|
|
98
|
|
|
99 if (ch === "~")
|
|
|
100 return togglePhraseModifier(stream, state, "sub", /~/, 1);
|
|
|
101
|
|
|
102 if (ch === "^")
|
|
|
103 return togglePhraseModifier(stream, state, "sup", /\^/, 1);
|
|
|
104
|
|
|
105 if (ch === "%")
|
|
|
106 return togglePhraseModifier(stream, state, "span", /%/, 1);
|
|
|
107
|
|
|
108 if (ch === "@")
|
|
|
109 return togglePhraseModifier(stream, state, "code", /@/, 1);
|
|
|
110
|
|
|
111 if (ch === "!") {
|
|
|
112 var type = togglePhraseModifier(stream, state, "image", /(?:\([^\)]+\))?!/, 1);
|
|
|
113 stream.match(/^:\S+/); // optional Url portion
|
|
|
114 return type;
|
|
|
115 }
|
|
|
116 return tokenStyles(state);
|
|
|
117 }
|
|
|
118
|
|
|
119 function togglePhraseModifier(stream, state, phraseModifier, closeRE, openSize) {
|
|
|
120 var charBefore = stream.pos > openSize ? stream.string.charAt(stream.pos - openSize - 1) : null;
|
|
|
121 var charAfter = stream.peek();
|
|
|
122 if (state[phraseModifier]) {
|
|
|
123 if ((!charAfter || /\W/.test(charAfter)) && charBefore && /\S/.test(charBefore)) {
|
|
|
124 var type = tokenStyles(state);
|
|
|
125 state[phraseModifier] = false;
|
|
|
126 return type;
|
|
|
127 }
|
|
|
128 } else if ((!charBefore || /\W/.test(charBefore)) && charAfter && /\S/.test(charAfter) &&
|
|
|
129 stream.match(new RegExp("^.*\\S" + closeRE.source + "(?:\\W|$)"), false)) {
|
|
|
130 state[phraseModifier] = true;
|
|
|
131 state.mode = Modes.attributes;
|
|
|
132 }
|
|
|
133 return tokenStyles(state);
|
|
|
134 };
|
|
|
135
|
|
|
136 function tokenStyles(state) {
|
|
|
137 var disabled = textileDisabled(state);
|
|
|
138 if (disabled) return disabled;
|
|
|
139
|
|
|
140 var styles = [];
|
|
|
141 if (state.layoutType) styles.push(TOKEN_STYLES[state.layoutType]);
|
|
|
142
|
|
|
143 styles = styles.concat(activeStyles(
|
|
|
144 state, "addition", "bold", "cite", "code", "deletion", "em", "footCite",
|
|
|
145 "image", "italic", "link", "span", "strong", "sub", "sup", "table", "tableHeading"));
|
|
|
146
|
|
|
147 if (state.layoutType === "header")
|
|
|
148 styles.push(TOKEN_STYLES.header + "-" + state.header);
|
|
|
149
|
|
|
150 return styles.length ? styles.join(" ") : null;
|
|
|
151 }
|
|
|
152
|
|
|
153 function textileDisabled(state) {
|
|
|
154 var type = state.layoutType;
|
|
|
155
|
|
|
156 switch(type) {
|
|
|
157 case "notextile":
|
|
|
158 case "code":
|
|
|
159 case "pre":
|
|
|
160 return TOKEN_STYLES[type];
|
|
|
161 default:
|
|
|
162 if (state.notextile)
|
|
|
163 return TOKEN_STYLES.notextile + (type ? (" " + TOKEN_STYLES[type]) : "");
|
|
|
164 return null;
|
|
|
165 }
|
|
|
166 }
|
|
|
167
|
|
|
168 function tokenStylesWith(state, extraStyles) {
|
|
|
169 var disabled = textileDisabled(state);
|
|
|
170 if (disabled) return disabled;
|
|
|
171
|
|
|
172 var type = tokenStyles(state);
|
|
|
173 if (extraStyles)
|
|
|
174 return type ? (type + " " + extraStyles) : extraStyles;
|
|
|
175 else
|
|
|
176 return type;
|
|
|
177 }
|
|
|
178
|
|
|
179 function activeStyles(state) {
|
|
|
180 var styles = [];
|
|
|
181 for (var i = 1; i < arguments.length; ++i) {
|
|
|
182 if (state[arguments[i]])
|
|
|
183 styles.push(TOKEN_STYLES[arguments[i]]);
|
|
|
184 }
|
|
|
185 return styles;
|
|
|
186 }
|
|
|
187
|
|
|
188 function blankLine(state) {
|
|
|
189 var spanningLayout = state.spanningLayout, type = state.layoutType;
|
|
|
190
|
|
|
191 for (var key in state) if (state.hasOwnProperty(key))
|
|
|
192 delete state[key];
|
|
|
193
|
|
|
194 state.mode = Modes.newLayout;
|
|
|
195 if (spanningLayout) {
|
|
|
196 state.layoutType = type;
|
|
|
197 state.spanningLayout = true;
|
|
|
198 }
|
|
|
199 }
|
|
|
200
|
|
|
201 var REs = {
|
|
|
202 cache: {},
|
|
|
203 single: {
|
|
|
204 bc: "bc",
|
|
|
205 bq: "bq",
|
|
|
206 definitionList: /- .*?:=+/,
|
|
|
207 definitionListEnd: /.*=:\s*$/,
|
|
|
208 div: "div",
|
|
|
209 drawTable: /\|.*\|/,
|
|
|
210 foot: /fn\d+/,
|
|
|
211 header: /h[1-6]/,
|
|
|
212 html: /\s*<(?:\/)?(\w+)(?:[^>]+)?>(?:[^<]+<\/\1>)?/,
|
|
|
213 link: /[^"]+":\S/,
|
|
|
214 linkDefinition: /\[[^\s\]]+\]\S+/,
|
|
|
215 list: /(?:#+|\*+)/,
|
|
|
216 notextile: "notextile",
|
|
|
217 para: "p",
|
|
|
218 pre: "pre",
|
|
|
219 table: "table",
|
|
|
220 tableCellAttributes: /[\/\\]\d+/,
|
|
|
221 tableHeading: /\|_\./,
|
|
|
222 tableText: /[^"_\*\[\(\?\+~\^%@|-]+/,
|
|
|
223 text: /[^!"_=\*\[\(<\?\+~\^%@-]+/
|
|
|
224 },
|
|
|
225 attributes: {
|
|
|
226 align: /(?:<>|<|>|=)/,
|
|
|
227 selector: /\([^\(][^\)]+\)/,
|
|
|
228 lang: /\[[^\[\]]+\]/,
|
|
|
229 pad: /(?:\(+|\)+){1,2}/,
|
|
|
230 css: /\{[^\}]+\}/
|
|
|
231 },
|
|
|
232 createRe: function(name) {
|
|
|
233 switch (name) {
|
|
|
234 case "drawTable":
|
|
|
235 return REs.makeRe("^", REs.single.drawTable, "$");
|
|
|
236 case "html":
|
|
|
237 return REs.makeRe("^", REs.single.html, "(?:", REs.single.html, ")*", "$");
|
|
|
238 case "linkDefinition":
|
|
|
239 return REs.makeRe("^", REs.single.linkDefinition, "$");
|
|
|
240 case "listLayout":
|
|
|
241 return REs.makeRe("^", REs.single.list, RE("allAttributes"), "*\\s+");
|
|
|
242 case "tableCellAttributes":
|
|
|
243 return REs.makeRe("^", REs.choiceRe(REs.single.tableCellAttributes,
|
|
|
244 RE("allAttributes")), "+\\.");
|
|
|
245 case "type":
|
|
|
246 return REs.makeRe("^", RE("allTypes"));
|
|
|
247 case "typeLayout":
|
|
|
248 return REs.makeRe("^", RE("allTypes"), RE("allAttributes"),
|
|
|
249 "*\\.\\.?", "(\\s+|$)");
|
|
|
250 case "attributes":
|
|
|
251 return REs.makeRe("^", RE("allAttributes"), "+");
|
|
|
252
|
|
|
253 case "allTypes":
|
|
|
254 return REs.choiceRe(REs.single.div, REs.single.foot,
|
|
|
255 REs.single.header, REs.single.bc, REs.single.bq,
|
|
|
256 REs.single.notextile, REs.single.pre, REs.single.table,
|
|
|
257 REs.single.para);
|
|
|
258
|
|
|
259 case "allAttributes":
|
|
|
260 return REs.choiceRe(REs.attributes.selector, REs.attributes.css,
|
|
|
261 REs.attributes.lang, REs.attributes.align, REs.attributes.pad);
|
|
|
262
|
|
|
263 default:
|
|
|
264 return REs.makeRe("^", REs.single[name]);
|
|
|
265 }
|
|
|
266 },
|
|
|
267 makeRe: function() {
|
|
|
268 var pattern = "";
|
|
|
269 for (var i = 0; i < arguments.length; ++i) {
|
|
|
270 var arg = arguments[i];
|
|
|
271 pattern += (typeof arg === "string") ? arg : arg.source;
|
|
|
272 }
|
|
|
273 return new RegExp(pattern);
|
|
|
274 },
|
|
|
275 choiceRe: function() {
|
|
|
276 var parts = [arguments[0]];
|
|
|
277 for (var i = 1; i < arguments.length; ++i) {
|
|
|
278 parts[i * 2 - 1] = "|";
|
|
|
279 parts[i * 2] = arguments[i];
|
|
|
280 }
|
|
|
281
|
|
|
282 parts.unshift("(?:");
|
|
|
283 parts.push(")");
|
|
|
284 return REs.makeRe.apply(null, parts);
|
|
|
285 }
|
|
|
286 };
|
|
|
287
|
|
|
288 function RE(name) {
|
|
|
289 return (REs.cache[name] || (REs.cache[name] = REs.createRe(name)));
|
|
|
290 }
|
|
|
291
|
|
|
292 var Modes = {
|
|
|
293 newLayout: function(stream, state) {
|
|
|
294 if (stream.match(RE("typeLayout"), false)) {
|
|
|
295 state.spanningLayout = false;
|
|
|
296 return (state.mode = Modes.blockType)(stream, state);
|
|
|
297 }
|
|
|
298 var newMode;
|
|
|
299 if (!textileDisabled(state)) {
|
|
|
300 if (stream.match(RE("listLayout"), false))
|
|
|
301 newMode = Modes.list;
|
|
|
302 else if (stream.match(RE("drawTable"), false))
|
|
|
303 newMode = Modes.table;
|
|
|
304 else if (stream.match(RE("linkDefinition"), false))
|
|
|
305 newMode = Modes.linkDefinition;
|
|
|
306 else if (stream.match(RE("definitionList")))
|
|
|
307 newMode = Modes.definitionList;
|
|
|
308 else if (stream.match(RE("html"), false))
|
|
|
309 newMode = Modes.html;
|
|
|
310 }
|
|
|
311 return (state.mode = (newMode || Modes.text))(stream, state);
|
|
|
312 },
|
|
|
313
|
|
|
314 blockType: function(stream, state) {
|
|
|
315 var match, type;
|
|
|
316 state.layoutType = null;
|
|
|
317
|
|
|
318 if (match = stream.match(RE("type")))
|
|
|
319 type = match[0];
|
|
|
320 else
|
|
|
321 return (state.mode = Modes.text)(stream, state);
|
|
|
322
|
|
|
323 if (match = type.match(RE("header"))) {
|
|
|
324 state.layoutType = "header";
|
|
|
325 state.header = parseInt(match[0][1]);
|
|
|
326 } else if (type.match(RE("bq"))) {
|
|
|
327 state.layoutType = "quote";
|
|
|
328 } else if (type.match(RE("bc"))) {
|
|
|
329 state.layoutType = "code";
|
|
|
330 } else if (type.match(RE("foot"))) {
|
|
|
331 state.layoutType = "footnote";
|
|
|
332 } else if (type.match(RE("notextile"))) {
|
|
|
333 state.layoutType = "notextile";
|
|
|
334 } else if (type.match(RE("pre"))) {
|
|
|
335 state.layoutType = "pre";
|
|
|
336 } else if (type.match(RE("div"))) {
|
|
|
337 state.layoutType = "div";
|
|
|
338 } else if (type.match(RE("table"))) {
|
|
|
339 state.layoutType = "table";
|
|
|
340 }
|
|
|
341
|
|
|
342 state.mode = Modes.attributes;
|
|
|
343 return tokenStyles(state);
|
|
|
344 },
|
|
|
345
|
|
|
346 text: function(stream, state) {
|
|
|
347 if (stream.match(RE("text"))) return tokenStyles(state);
|
|
|
348
|
|
|
349 var ch = stream.next();
|
|
|
350 if (ch === '"')
|
|
|
351 return (state.mode = Modes.link)(stream, state);
|
|
|
352 return handlePhraseModifier(stream, state, ch);
|
|
|
353 },
|
|
|
354
|
|
|
355 attributes: function(stream, state) {
|
|
|
356 state.mode = Modes.layoutLength;
|
|
|
357
|
|
|
358 if (stream.match(RE("attributes")))
|
|
|
359 return tokenStylesWith(state, TOKEN_STYLES.attributes);
|
|
|
360 else
|
|
|
361 return tokenStyles(state);
|
|
|
362 },
|
|
|
363
|
|
|
364 layoutLength: function(stream, state) {
|
|
|
365 if (stream.eat(".") && stream.eat("."))
|
|
|
366 state.spanningLayout = true;
|
|
|
367
|
|
|
368 state.mode = Modes.text;
|
|
|
369 return tokenStyles(state);
|
|
|
370 },
|
|
|
371
|
|
|
372 list: function(stream, state) {
|
|
|
373 var match = stream.match(RE("list"));
|
|
|
374 state.listDepth = match[0].length;
|
|
|
375 var listMod = (state.listDepth - 1) % 3;
|
|
|
376 if (!listMod)
|
|
|
377 state.layoutType = "list1";
|
|
|
378 else if (listMod === 1)
|
|
|
379 state.layoutType = "list2";
|
|
|
380 else
|
|
|
381 state.layoutType = "list3";
|
|
|
382
|
|
|
383 state.mode = Modes.attributes;
|
|
|
384 return tokenStyles(state);
|
|
|
385 },
|
|
|
386
|
|
|
387 link: function(stream, state) {
|
|
|
388 state.mode = Modes.text;
|
|
|
389 if (stream.match(RE("link"))) {
|
|
|
390 stream.match(/\S+/);
|
|
|
391 return tokenStylesWith(state, TOKEN_STYLES.link);
|
|
|
392 }
|
|
|
393 return tokenStyles(state);
|
|
|
394 },
|
|
|
395
|
|
|
396 linkDefinition: function(stream, state) {
|
|
|
397 stream.skipToEnd();
|
|
|
398 return tokenStylesWith(state, TOKEN_STYLES.linkDefinition);
|
|
|
399 },
|
|
|
400
|
|
|
401 definitionList: function(stream, state) {
|
|
|
402 stream.match(RE("definitionList"));
|
|
|
403
|
|
|
404 state.layoutType = "definitionList";
|
|
|
405
|
|
|
406 if (stream.match(/\s*$/))
|
|
|
407 state.spanningLayout = true;
|
|
|
408 else
|
|
|
409 state.mode = Modes.attributes;
|
|
|
410
|
|
|
411 return tokenStyles(state);
|
|
|
412 },
|
|
|
413
|
|
|
414 html: function(stream, state) {
|
|
|
415 stream.skipToEnd();
|
|
|
416 return tokenStylesWith(state, TOKEN_STYLES.html);
|
|
|
417 },
|
|
|
418
|
|
|
419 table: function(stream, state) {
|
|
|
420 state.layoutType = "table";
|
|
|
421 return (state.mode = Modes.tableCell)(stream, state);
|
|
|
422 },
|
|
|
423
|
|
|
424 tableCell: function(stream, state) {
|
|
|
425 if (stream.match(RE("tableHeading")))
|
|
|
426 state.tableHeading = true;
|
|
|
427 else
|
|
|
428 stream.eat("|");
|
|
|
429
|
|
|
430 state.mode = Modes.tableCellAttributes;
|
|
|
431 return tokenStyles(state);
|
|
|
432 },
|
|
|
433
|
|
|
434 tableCellAttributes: function(stream, state) {
|
|
|
435 state.mode = Modes.tableText;
|
|
|
436
|
|
|
437 if (stream.match(RE("tableCellAttributes")))
|
|
|
438 return tokenStylesWith(state, TOKEN_STYLES.attributes);
|
|
|
439 else
|
|
|
440 return tokenStyles(state);
|
|
|
441 },
|
|
|
442
|
|
|
443 tableText: function(stream, state) {
|
|
|
444 if (stream.match(RE("tableText")))
|
|
|
445 return tokenStyles(state);
|
|
|
446
|
|
|
447 if (stream.peek() === "|") { // end of cell
|
|
|
448 state.mode = Modes.tableCell;
|
|
|
449 return tokenStyles(state);
|
|
|
450 }
|
|
|
451 return handlePhraseModifier(stream, state, stream.next());
|
|
|
452 }
|
|
|
453 };
|
|
|
454
|
|
|
455 CodeMirror.defineMode("textile", function() {
|
|
|
456 return {
|
|
|
457 startState: function() {
|
|
|
458 return { mode: Modes.newLayout };
|
|
|
459 },
|
|
|
460 token: function(stream, state) {
|
|
|
461 if (stream.sol()) startNewLine(stream, state);
|
|
|
462 return state.mode(stream, state);
|
|
|
463 },
|
|
|
464 blankLine: blankLine
|
|
|
465 };
|
|
|
466 });
|
|
|
467
|
|
|
468 CodeMirror.defineMIME("text/x-textile", "textile");
|
|
|
469 });
|
