Mercurial

comparison .cms/lib/codemirror/mode/textile/textile.js @ 0:78edf6b517a0 draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
24.10
author Coffee CMS <info@coffee-cms.ru>
date Fri, 11 Oct 2024 22:40:23 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:78edf6b517a0
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 });