Mercurial
comparison .cms/lib/codemirror/mode/textile/textile.js @ 0:78edf6b517a0 draft
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 }); |