Debian Codegraph @

codemirror-legacy-modes/mode/xml.js

raw
1 var htmlConfig = {
2 autoSelfClosers: {'area': true, 'base': true, 'br': true, 'col': true, 'command': true,
3 'embed': true, 'frame': true, 'hr': true, 'img': true, 'input': true,
4 'keygen': true, 'link': true, 'meta': true, 'param': true, 'source': true,
5 'track': true, 'wbr': true, 'menuitem': true},
6 implicitlyClosed: {'dd': true, 'li': true, 'optgroup': true, 'option': true, 'p': true,
7 'rp': true, 'rt': true, 'tbody': true, 'td': true, 'tfoot': true,
8 'th': true, 'tr': true},
9 contextGrabbers: {
10 'dd': {'dd': true, 'dt': true},
11 'dt': {'dd': true, 'dt': true},
12 'li': {'li': true},
13 'option': {'option': true, 'optgroup': true},
14 'optgroup': {'optgroup': true},
15 'p': {'address': true, 'article': true, 'aside': true, 'blockquote': true, 'dir': true,
16 'div': true, 'dl': true, 'fieldset': true, 'footer': true, 'form': true,
17 'h1': true, 'h2': true, 'h3': true, 'h4': true, 'h5': true, 'h6': true,
18 'header': true, 'hgroup': true, 'hr': true, 'menu': true, 'nav': true, 'ol': true,
19 'p': true, 'pre': true, 'section': true, 'table': true, 'ul': true},
20 'rp': {'rp': true, 'rt': true},
21 'rt': {'rp': true, 'rt': true},
22 'tbody': {'tbody': true, 'tfoot': true},
23 'td': {'td': true, 'th': true},
24 'tfoot': {'tbody': true},
25 'th': {'td': true, 'th': true},
26 'thead': {'tbody': true, 'tfoot': true},
27 'tr': {'tr': true}
28 },
29 doNotIndent: {"pre": true},
30 allowUnquoted: true,
31 allowMissing: true,
32 caseFold: true
33 }
34
35 var xmlConfig = {
36 autoSelfClosers: {},
37 implicitlyClosed: {},
38 contextGrabbers: {},
39 doNotIndent: {},
40 allowUnquoted: false,
41 allowMissing: false,
42 allowMissingTagName: false,
43 caseFold: false
44 }
45
46 export function mkXML(parserConfig) {
47 var config = {}
48 var defaults = parserConfig.htmlMode ? htmlConfig : xmlConfig
49 for (var prop in defaults) config[prop] = defaults[prop]
50 for (var prop in parserConfig) config[prop] = parserConfig[prop]
51
52 // Return variables for tokenizers
53 var type, setStyle;
54
55 function inText(stream, state) {
56 function chain(parser) {
57 state.tokenize = parser;
58 return parser(stream, state);
59 }
60
61 var ch = stream.next();
62 if (ch == "<") {
63 if (stream.eat("!")) {
64 if (stream.eat("[")) {
65 if (stream.match("CDATA[")) return chain(inBlock("atom", "]]>"));
66 else return null;
67 } else if (stream.match("--")) {
68 return chain(inBlock("comment", "-->"));
69 } else if (stream.match("DOCTYPE", true, true)) {
70 stream.eatWhile(/[\w\._\-]/);
71 return chain(doctype(1));
72 } else {
73 return null;
74 }
75 } else if (stream.eat("?")) {
76 stream.eatWhile(/[\w\._\-]/);
77 state.tokenize = inBlock("meta", "?>");
78 return "meta";
79 } else {
80 type = stream.eat("/") ? "closeTag" : "openTag";
81 state.tokenize = inTag;
82 return "angleBracket";
83 }
84 } else if (ch == "&") {
85 var ok;
86 if (stream.eat("#")) {
87 if (stream.eat("x")) {
88 ok = stream.eatWhile(/[a-fA-F\d]/) && stream.eat(";");
89 } else {
90 ok = stream.eatWhile(/[\d]/) && stream.eat(";");
91 }
92 } else {
93 ok = stream.eatWhile(/[\w\.\-:]/) && stream.eat(";");
94 }
95 return ok ? "atom" : "error";
96 } else {
97 stream.eatWhile(/[^&<]/);
98 return null;
99 }
100 }
101 inText.isInText = true;
102
103 function inTag(stream, state) {
104 var ch = stream.next();
105 if (ch == ">" || (ch == "/" && stream.eat(">"))) {
106 state.tokenize = inText;
107 type = ch == ">" ? "endTag" : "selfcloseTag";
108 return "angleBracket";
109 } else if (ch == "=") {
110 type = "equals";
111 return null;
112 } else if (ch == "<") {
113 state.tokenize = inText;
114 state.state = baseState;
115 state.tagName = state.tagStart = null;
116 state.tokenize(stream, state);
117 return "invalid"
118 } else if (/[\'\"]/.test(ch)) {
119 state.tokenize = inAttribute(ch);
120 state.stringStartCol = stream.column();
121 return state.tokenize(stream, state);
122 } else {
123 stream.match(/^[^\s\u00a0=<>\"\']*[^\s\u00a0=<>\"\'\/]/);
124 return "word";
125 }
126 }
127
128 function inAttribute(quote) {
129 var closure = function(stream, state) {
130 while (!stream.eol()) {
131 if (stream.next() == quote) {
132 state.tokenize = inTag;
133 break;
134 }
135 }
136 return "string";
137 };
138 closure.isInAttribute = true;
139 return closure;
140 }
141
142 function inBlock(style, terminator) {
143 return function(stream, state) {
144 while (!stream.eol()) {
145 if (stream.match(terminator)) {
146 state.tokenize = inText;
147 break;
148 }
149 stream.next();
150 }
151 return style;
152 }
153 }
154
155 function doctype(depth) {
156 return function(stream, state) {
157 var ch;
158 while ((ch = stream.next()) != null) {
159 if (ch == "<") {
160 state.tokenize = doctype(depth + 1);
161 return state.tokenize(stream, state);
162 } else if (ch == ">") {
163 if (depth == 1) {
164 state.tokenize = inText;
165 break;
166 } else {
167 state.tokenize = doctype(depth - 1);
168 return state.tokenize(stream, state);
169 }
170 }
171 }
172 return "meta";
173 };
174 }
175
176 function lower(tagName) {
177 return tagName && tagName.toLowerCase();
178 }
179
180 function Context(state, tagName, startOfLine) {
181 this.prev = state.context;
182 this.tagName = tagName || "";
183 this.indent = state.indented;
184 this.startOfLine = startOfLine;
185 if (config.doNotIndent.hasOwnProperty(tagName) || (state.context && state.context.noIndent))
186 this.noIndent = true;
187 }
188 function popContext(state) {
189 if (state.context) state.context = state.context.prev;
190 }
191 function maybePopContext(state, nextTagName) {
192 var parentTagName;
193 while (true) {
194 if (!state.context) {
195 return;
196 }
197 parentTagName = state.context.tagName;
198 if (!config.contextGrabbers.hasOwnProperty(lower(parentTagName)) ||
199 !config.contextGrabbers[lower(parentTagName)].hasOwnProperty(lower(nextTagName))) {
200 return;
201 }
202 popContext(state);
203 }
204 }
205
206 function baseState(type, stream, state) {
207 if (type == "openTag") {
208 state.tagStart = stream.column();
209 return tagNameState;
210 } else if (type == "closeTag") {
211 return closeTagNameState;
212 } else {
213 return baseState;
214 }
215 }
216 function tagNameState(type, stream, state) {
217 if (type == "word") {
218 state.tagName = stream.current();
219 setStyle = "tag";
220 return attrState;
221 } else if (config.allowMissingTagName && type == "endTag") {
222 setStyle = "angleBracket";
223 return attrState(type, stream, state);
224 } else {
225 setStyle = "error";
226 return tagNameState;
227 }
228 }
229 function closeTagNameState(type, stream, state) {
230 if (type == "word") {
231 var tagName = stream.current();
232 if (state.context && state.context.tagName != tagName &&
233 config.implicitlyClosed.hasOwnProperty(lower(state.context.tagName)))
234 popContext(state);
235 if ((state.context && state.context.tagName == tagName) || config.matchClosing === false) {
236 setStyle = "tag";
237 return closeState;
238 } else {
239 setStyle = "error";
240 return closeStateErr;
241 }
242 } else if (config.allowMissingTagName && type == "endTag") {
243 setStyle = "angleBracket";
244 return closeState(type, stream, state);
245 } else {
246 setStyle = "error";
247 return closeStateErr;
248 }
249 }
250
251 function closeState(type, _stream, state) {
252 if (type != "endTag") {
253 setStyle = "error";
254 return closeState;
255 }
256 popContext(state);
257 return baseState;
258 }
259 function closeStateErr(type, stream, state) {
260 setStyle = "error";
261 return closeState(type, stream, state);
262 }
263
264 function attrState(type, _stream, state) {
265 if (type == "word") {
266 setStyle = "attribute";
267 return attrEqState;
268 } else if (type == "endTag" || type == "selfcloseTag") {
269 var tagName = state.tagName, tagStart = state.tagStart;
270 state.tagName = state.tagStart = null;
271 if (type == "selfcloseTag" ||
272 config.autoSelfClosers.hasOwnProperty(lower(tagName))) {
273 maybePopContext(state, tagName);
274 } else {
275 maybePopContext(state, tagName);
276 state.context = new Context(state, tagName, tagStart == state.indented);
277 }
278 return baseState;
279 }
280 setStyle = "error";
281 return attrState;
282 }
283 function attrEqState(type, stream, state) {
284 if (type == "equals") return attrValueState;
285 if (!config.allowMissing) setStyle = "error";
286 return attrState(type, stream, state);
287 }
288 function attrValueState(type, stream, state) {
289 if (type == "string") return attrContinuedState;
290 if (type == "word" && config.allowUnquoted) {setStyle = "string"; return attrState;}
291 setStyle = "error";
292 return attrState(type, stream, state);
293 }
294 function attrContinuedState(type, stream, state) {
295 if (type == "string") return attrContinuedState;
296 return attrState(type, stream, state);
297 }
298
299 return {
300 name: "xml",
301
302 startState: function() {
303 var state = {tokenize: inText,
304 state: baseState,
305 indented: 0,
306 tagName: null, tagStart: null,
307 context: null}
308 return state
309 },
310
311 token: function(stream, state) {
312 if (!state.tagName && stream.sol())
313 state.indented = stream.indentation();
314
315 if (stream.eatSpace()) return null;
316 type = null;
317 var style = state.tokenize(stream, state);
318 if ((style || type) && style != "comment") {
319 setStyle = null;
320 state.state = state.state(type || style, stream, state);
321 if (setStyle) style = setStyle
322 }
323 return style;
324 },
325
326 indent: function(state, textAfter, cx) {
327 var context = state.context;
328 // Indent multi-line strings (e.g. css).
329 if (state.tokenize.isInAttribute) {
330 if (state.tagStart == state.indented)
331 return state.stringStartCol + 1;
332 else
333 return state.indented + cx.unit;
334 }
335 if (context && context.noIndent) return null;
336 if (state.tokenize != inTag && state.tokenize != inText) return null
337 // Indent the starts of attribute names.
338 if (state.tagName) {
339 if (config.multilineTagIndentPastTag !== false)
340 return state.tagStart + state.tagName.length + 2;
341 else
342 return state.tagStart + cx.unit * (config.multilineTagIndentFactor || 1);
343 }
344 if (config.alignCDATA && /<!\[CDATA\[/.test(textAfter)) return 0;
345 var tagAfter = textAfter && /^<(\/)?([\w_:\.-]*)/.exec(textAfter);
346 if (tagAfter && tagAfter[1]) { // Closing tag spotted
347 while (context) {
348 if (context.tagName == tagAfter[2]) {
349 context = context.prev;
350 break;
351 } else if (config.implicitlyClosed.hasOwnProperty(lower(context.tagName))) {
352 context = context.prev;
353 } else {
354 break;
355 }
356 }
357 } else if (tagAfter) { // Opening tag spotted
358 while (context) {
359 var grabbers = config.contextGrabbers[lower(context.tagName)];
360 if (grabbers && grabbers.hasOwnProperty(lower(tagAfter[2])))
361 context = context.prev;
362 else
363 break;
364 }
365 }
366 while (context && context.prev && !context.startOfLine)
367 context = context.prev;
368 if (context) return context.indent + cx.unit;
369 else return state.baseIndent || 0;
370 },
371
372 languageData: {
373 indentOnInput: /<\/[\s\w:]+>$/,
374 commentTokens: {block: {open: "<!--", close: "-->"}}
375 },
376
377 configuration: config.htmlMode ? "html" : "xml",
378 skipAttribute: function(state) {
379 if (state.state == attrValueState)
380 state.state = attrState
381 },
382
383 xmlCurrentTag: function(state) {
384 return state.tagName ? {name: state.tagName, close: state.type == "closeTag"} : null
385 },
386
387 xmlCurrentContext: function(state) {
388 var context = []
389 for (var cx = state.context; cx; cx = cx.prev)
390 context.push(cx.tagName)
391 return context.reverse()
392 }
393 };
394 };
395
396 export const xml = mkXML({})
397 export const html = mkXML({htmlMode: true})