GPQAPP

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"));
7
  else if (typeof define == "function" && define.amd) // AMD
8
    define(["../../lib/codemirror"], mod);
9
  else // Plain browser env
10
    mod(CodeMirror);
11
})(function(CodeMirror) {
12
"use strict";
13

14
CodeMirror.defineMode("css", function(config, parserConfig) {
15
  var inline = parserConfig.inline
16
  if (!parserConfig.propertyKeywords) parserConfig = CodeMirror.resolveMode("text/css");
17

18
  var indentUnit = config.indentUnit,
19
      tokenHooks = parserConfig.tokenHooks,
20
      documentTypes = parserConfig.documentTypes || {},
21
      mediaTypes = parserConfig.mediaTypes || {},
22
      mediaFeatures = parserConfig.mediaFeatures || {},
23
      mediaValueKeywords = parserConfig.mediaValueKeywords || {},
24
      propertyKeywords = parserConfig.propertyKeywords || {},
25
      nonStandardPropertyKeywords = parserConfig.nonStandardPropertyKeywords || {},
26
      fontProperties = parserConfig.fontProperties || {},
27
      counterDescriptors = parserConfig.counterDescriptors || {},
28
      colorKeywords = parserConfig.colorKeywords || {},
29
      valueKeywords = parserConfig.valueKeywords || {},
30
      allowNested = parserConfig.allowNested,
31
      lineComment = parserConfig.lineComment,
32
      supportsAtComponent = parserConfig.supportsAtComponent === true,
33
      highlightNonStandardPropertyKeywords = config.highlightNonStandardPropertyKeywords !== false;
34

35
  var type, override;
36
  function ret(style, tp) { type = tp; return style; }
37

38
  // Tokenizers
39

40
  function tokenBase(stream, state) {
41
    var ch = stream.next();
42
    if (tokenHooks[ch]) {
43
      var result = tokenHooks[ch](stream, state);
44
      if (result !== false) return result;
45
    }
46
    if (ch == "@") {
47
      stream.eatWhile(/[\w\\\-]/);
48
      return ret("def", stream.current());
49
    } else if (ch == "=" || (ch == "~" || ch == "|") && stream.eat("=")) {
50
      return ret(null, "compare");
51
    } else if (ch == "\"" || ch == "'") {
52
      state.tokenize = tokenString(ch);
53
      return state.tokenize(stream, state);
54
    } else if (ch == "#") {
55
      stream.eatWhile(/[\w\\\-]/);
56
      return ret("atom", "hash");
57
    } else if (ch == "!") {
58
      stream.match(/^\s*\w*/);
59
      return ret("keyword", "important");
60
    } else if (/\d/.test(ch) || ch == "." && stream.eat(/\d/)) {
61
      stream.eatWhile(/[\w.%]/);
62
      return ret("number", "unit");
63
    } else if (ch === "-") {
64
      if (/[\d.]/.test(stream.peek())) {
65
        stream.eatWhile(/[\w.%]/);
66
        return ret("number", "unit");
67
      } else if (stream.match(/^-[\w\\\-]*/)) {
68
        stream.eatWhile(/[\w\\\-]/);
69
        if (stream.match(/^\s*:/, false))
70
          return ret("variable-2", "variable-definition");
71
        return ret("variable-2", "variable");
72
      } else if (stream.match(/^\w+-/)) {
73
        return ret("meta", "meta");
74
      }
75
    } else if (/[,+>*\/]/.test(ch)) {
76
      return ret(null, "select-op");
77
    } else if (ch == "." && stream.match(/^-?[_a-z][_a-z0-9-]*/i)) {
78
      return ret("qualifier", "qualifier");
79
    } else if (/[:;{}\[\]\(\)]/.test(ch)) {
80
      return ret(null, ch);
81
    } else if (stream.match(/^[\w-.]+(?=\()/)) {
82
      if (/^(url(-prefix)?|domain|regexp)$/i.test(stream.current())) {
83
        state.tokenize = tokenParenthesized;
84
      }
85
      return ret("variable callee", "variable");
86
    } else if (/[\w\\\-]/.test(ch)) {
87
      stream.eatWhile(/[\w\\\-]/);
88
      return ret("property", "word");
89
    } else {
90
      return ret(null, null);
91
    }
92
  }
93

94
  function tokenString(quote) {
95
    return function(stream, state) {
96
      var escaped = false, ch;
97
      while ((ch = stream.next()) != null) {
98
        if (ch == quote && !escaped) {
99
          if (quote == ")") stream.backUp(1);
100
          break;
101
        }
102
        escaped = !escaped && ch == "\\";
103
      }
104
      if (ch == quote || !escaped && quote != ")") state.tokenize = null;
105
      return ret("string", "string");
106
    };
107
  }
108

109
  function tokenParenthesized(stream, state) {
110
    stream.next(); // Must be '('
111
    if (!stream.match(/^\s*[\"\')]/, false))
112
      state.tokenize = tokenString(")");
113
    else
114
      state.tokenize = null;
115
    return ret(null, "(");
116
  }
117

118
  // Context management
119

120
  function Context(type, indent, prev) {
121
    this.type = type;
122
    this.indent = indent;
123
    this.prev = prev;
124
  }
125

126
  function pushContext(state, stream, type, indent) {
127
    state.context = new Context(type, stream.indentation() + (indent === false ? 0 : indentUnit), state.context);
128
    return type;
129
  }
130

131
  function popContext(state) {
132
    if (state.context.prev)
133
      state.context = state.context.prev;
134
    return state.context.type;
135
  }
136

137
  function pass(type, stream, state) {
138
    return states[state.context.type](type, stream, state);
139
  }
140
  function popAndPass(type, stream, state, n) {
141
    for (var i = n || 1; i > 0; i--)
142
      state.context = state.context.prev;
143
    return pass(type, stream, state);
144
  }
145

146
  // Parser
147

148
  function wordAsValue(stream) {
149
    var word = stream.current().toLowerCase();
150
    if (valueKeywords.hasOwnProperty(word))
151
      override = "atom";
152
    else if (colorKeywords.hasOwnProperty(word))
153
      override = "keyword";
154
    else
155
      override = "variable";
156
  }
157

158
  var states = {};
159

160
  states.top = function(type, stream, state) {
161
    if (type == "{") {
162
      return pushContext(state, stream, "block");
163
    } else if (type == "}" && state.context.prev) {
164
      return popContext(state);
165
    } else if (supportsAtComponent && /@component/i.test(type)) {
166
      return pushContext(state, stream, "atComponentBlock");
167
    } else if (/^@(-moz-)?document$/i.test(type)) {
168
      return pushContext(state, stream, "documentTypes");
169
    } else if (/^@(media|supports|(-moz-)?document|import)$/i.test(type)) {
170
      return pushContext(state, stream, "atBlock");
171
    } else if (/^@(font-face|counter-style)/i.test(type)) {
172
      state.stateArg = type;
173
      return "restricted_atBlock_before";
174
    } else if (/^@(-(moz|ms|o|webkit)-)?keyframes$/i.test(type)) {
175
      return "keyframes";
176
    } else if (type && type.charAt(0) == "@") {
177
      return pushContext(state, stream, "at");
178
    } else if (type == "hash") {
179
      override = "builtin";
180
    } else if (type == "word") {
181
      override = "tag";
182
    } else if (type == "variable-definition") {
183
      return "maybeprop";
184
    } else if (type == "interpolation") {
185
      return pushContext(state, stream, "interpolation");
186
    } else if (type == ":") {
187
      return "pseudo";
188
    } else if (allowNested && type == "(") {
189
      return pushContext(state, stream, "parens");
190
    }
191
    return state.context.type;
192
  };
193

194
  states.block = function(type, stream, state) {
195
    if (type == "word") {
196
      var word = stream.current().toLowerCase();
197
      if (propertyKeywords.hasOwnProperty(word)) {
198
        override = "property";
199
        return "maybeprop";
200
      } else if (nonStandardPropertyKeywords.hasOwnProperty(word)) {
201
        override = highlightNonStandardPropertyKeywords ? "string-2" : "property";
202
        return "maybeprop";
203
      } else if (allowNested) {
204
        override = stream.match(/^\s*:(?:\s|$)/, false) ? "property" : "tag";
205
        return "block";
206
      } else {
207
        override += " error";
208
        return "maybeprop";
209
      }
210
    } else if (type == "meta") {
211
      return "block";
212
    } else if (!allowNested && (type == "hash" || type == "qualifier")) {
213
      override = "error";
214
      return "block";
215
    } else {
216
      return states.top(type, stream, state);
217
    }
218
  };
219

220
  states.maybeprop = function(type, stream, state) {
221
    if (type == ":") return pushContext(state, stream, "prop");
222
    return pass(type, stream, state);
223
  };
224

225
  states.prop = function(type, stream, state) {
226
    if (type == ";") return popContext(state);
227
    if (type == "{" && allowNested) return pushContext(state, stream, "propBlock");
228
    if (type == "}" || type == "{") return popAndPass(type, stream, state);
229
    if (type == "(") return pushContext(state, stream, "parens");
230

231
    if (type == "hash" && !/^#([0-9a-fA-f]{3,4}|[0-9a-fA-f]{6}|[0-9a-fA-f]{8})$/.test(stream.current())) {
232
      override += " error";
233
    } else if (type == "word") {
234
      wordAsValue(stream);
235
    } else if (type == "interpolation") {
236
      return pushContext(state, stream, "interpolation");
237
    }
238
    return "prop";
239
  };
240

241
  states.propBlock = function(type, _stream, state) {
242
    if (type == "}") return popContext(state);
243
    if (type == "word") { override = "property"; return "maybeprop"; }
244
    return state.context.type;
245
  };
246

247
  states.parens = function(type, stream, state) {
248
    if (type == "{" || type == "}") return popAndPass(type, stream, state);
249
    if (type == ")") return popContext(state);
250
    if (type == "(") return pushContext(state, stream, "parens");
251
    if (type == "interpolation") return pushContext(state, stream, "interpolation");
252
    if (type == "word") wordAsValue(stream);
253
    return "parens";
254
  };
255

256
  states.pseudo = function(type, stream, state) {
257
    if (type == "meta") return "pseudo";
258

259
    if (type == "word") {
260
      override = "variable-3";
261
      return state.context.type;
262
    }
263
    return pass(type, stream, state);
264
  };
265

266
  states.documentTypes = function(type, stream, state) {
267
    if (type == "word" && documentTypes.hasOwnProperty(stream.current())) {
268
      override = "tag";
269
      return state.context.type;
270
    } else {
271
      return states.atBlock(type, stream, state);
272
    }
273
  };
274

275
  states.atBlock = function(type, stream, state) {
276
    if (type == "(") return pushContext(state, stream, "atBlock_parens");
277
    if (type == "}" || type == ";") return popAndPass(type, stream, state);
278
    if (type == "{") return popContext(state) && pushContext(state, stream, allowNested ? "block" : "top");
279

280
    if (type == "interpolation") return pushContext(state, stream, "interpolation");
281

282
    if (type == "word") {
283
      var word = stream.current().toLowerCase();
284
      if (word == "only" || word == "not" || word == "and" || word == "or")
285
        override = "keyword";
286
      else if (mediaTypes.hasOwnProperty(word))
287
        override = "attribute";
288
      else if (mediaFeatures.hasOwnProperty(word))
289
        override = "property";
290
      else if (mediaValueKeywords.hasOwnProperty(word))
291
        override = "keyword";
292
      else if (propertyKeywords.hasOwnProperty(word))
293
        override = "property";
294
      else if (nonStandardPropertyKeywords.hasOwnProperty(word))
295
        override = highlightNonStandardPropertyKeywords ? "string-2" : "property";
296
      else if (valueKeywords.hasOwnProperty(word))
297
        override = "atom";
298
      else if (colorKeywords.hasOwnProperty(word))
299
        override = "keyword";
300
      else
301
        override = "error";
302
    }
303
    return state.context.type;
304
  };
305

306
  states.atComponentBlock = function(type, stream, state) {
307
    if (type == "}")
308
      return popAndPass(type, stream, state);
309
    if (type == "{")
310
      return popContext(state) && pushContext(state, stream, allowNested ? "block" : "top", false);
311
    if (type == "word")
312
      override = "error";
313
    return state.context.type;
314
  };
315

316
  states.atBlock_parens = function(type, stream, state) {
317
    if (type == ")") return popContext(state);
318
    if (type == "{" || type == "}") return popAndPass(type, stream, state, 2);
319
    return states.atBlock(type, stream, state);
320
  };
321

322
  states.restricted_atBlock_before = function(type, stream, state) {
323
    if (type == "{")
324
      return pushContext(state, stream, "restricted_atBlock");
325
    if (type == "word" && state.stateArg == "@counter-style") {
326
      override = "variable";
327
      return "restricted_atBlock_before";
328
    }
329
    return pass(type, stream, state);
330
  };
331

332
  states.restricted_atBlock = function(type, stream, state) {
333
    if (type == "}") {
334
      state.stateArg = null;
335
      return popContext(state);
336
    }
337
    if (type == "word") {
338
      if ((state.stateArg == "@font-face" && !fontProperties.hasOwnProperty(stream.current().toLowerCase())) ||
339
          (state.stateArg == "@counter-style" && !counterDescriptors.hasOwnProperty(stream.current().toLowerCase())))
340
        override = "error";
341
      else
342
        override = "property";
343
      return "maybeprop";
344
    }
345
    return "restricted_atBlock";
346
  };
347

348
  states.keyframes = function(type, stream, state) {
349
    if (type == "word") { override = "variable"; return "keyframes"; }
350
    if (type == "{") return pushContext(state, stream, "top");
351
    return pass(type, stream, state);
352
  };
353

354
  states.at = function(type, stream, state) {
355
    if (type == ";") return popContext(state);
356
    if (type == "{" || type == "}") return popAndPass(type, stream, state);
357
    if (type == "word") override = "tag";
358
    else if (type == "hash") override = "builtin";
359
    return "at";
360
  };
361

362
  states.interpolation = function(type, stream, state) {
363
    if (type == "}") return popContext(state);
364
    if (type == "{" || type == ";") return popAndPass(type, stream, state);
365
    if (type == "word") override = "variable";
366
    else if (type != "variable" && type != "(" && type != ")") override = "error";
367
    return "interpolation";
368
  };
369

370
  return {
371
    startState: function(base) {
372
      return {tokenize: null,
373
              state: inline ? "block" : "top",
374
              stateArg: null,
375
              context: new Context(inline ? "block" : "top", base || 0, null)};
376
    },
377

378
    token: function(stream, state) {
379
      if (!state.tokenize && stream.eatSpace()) return null;
380
      var style = (state.tokenize || tokenBase)(stream, state);
381
      if (style && typeof style == "object") {
382
        type = style[1];
383
        style = style[0];
384
      }
385
      override = style;
386
      if (type != "comment")
387
        state.state = states[state.state](type, stream, state);
388
      return override;
389
    },
390

391
    indent: function(state, textAfter) {
392
      var cx = state.context, ch = textAfter && textAfter.charAt(0);
393
      var indent = cx.indent;
394
      if (cx.type == "prop" && (ch == "}" || ch == ")")) cx = cx.prev;
395
      if (cx.prev) {
396
        if (ch == "}" && (cx.type == "block" || cx.type == "top" ||
397
                          cx.type == "interpolation" || cx.type == "restricted_atBlock")) {
398
          // Resume indentation from parent context.
399
          cx = cx.prev;
400
          indent = cx.indent;
401
        } else if (ch == ")" && (cx.type == "parens" || cx.type == "atBlock_parens") ||
402
            ch == "{" && (cx.type == "at" || cx.type == "atBlock")) {
403
          // Dedent relative to current context.
404
          indent = Math.max(0, cx.indent - indentUnit);
405
        }
406
      }
407
      return indent;
408
    },
409

410
    electricChars: "}",
411
    blockCommentStart: "/*",
412
    blockCommentEnd: "*/",
413
    blockCommentContinue: " * ",
414
    lineComment: lineComment,
415
    fold: "brace"
416
  };
417
});
418

419
  function keySet(array) {
420
    var keys = {};
421
    for (var i = 0; i < array.length; ++i) {
422
      keys[array[i].toLowerCase()] = true;
423
    }
424
    return keys;
425
  }
426

427
  var documentTypes_ = [
428
    "domain", "regexp", "url", "url-prefix"
429
  ], documentTypes = keySet(documentTypes_);
430

431
  var mediaTypes_ = [
432
    "all", "aural", "braille", "handheld", "print", "projection", "screen",
433
    "tty", "tv", "embossed"
434
  ], mediaTypes = keySet(mediaTypes_);
435

436
  var mediaFeatures_ = [
437
    "width", "min-width", "max-width", "height", "min-height", "max-height",
438
    "device-width", "min-device-width", "max-device-width", "device-height",
439
    "min-device-height", "max-device-height", "aspect-ratio",
440
    "min-aspect-ratio", "max-aspect-ratio", "device-aspect-ratio",
441
    "min-device-aspect-ratio", "max-device-aspect-ratio", "color", "min-color",
442
    "max-color", "color-index", "min-color-index", "max-color-index",
443
    "monochrome", "min-monochrome", "max-monochrome", "resolution",
444
    "min-resolution", "max-resolution", "scan", "grid", "orientation",
445
    "device-pixel-ratio", "min-device-pixel-ratio", "max-device-pixel-ratio",
446
    "pointer", "any-pointer", "hover", "any-hover", "prefers-color-scheme",
447
    "dynamic-range", "video-dynamic-range"
448
  ], mediaFeatures = keySet(mediaFeatures_);
449

450
  var mediaValueKeywords_ = [
451
    "landscape", "portrait", "none", "coarse", "fine", "on-demand", "hover",
452
    "interlace", "progressive",
453
    "dark", "light",
454
    "standard", "high"
455
  ], mediaValueKeywords = keySet(mediaValueKeywords_);
456

457
  var propertyKeywords_ = [
458
    "align-content", "align-items", "align-self", "alignment-adjust",
459
    "alignment-baseline", "all", "anchor-point", "animation", "animation-delay",
460
    "animation-direction", "animation-duration", "animation-fill-mode",
461
    "animation-iteration-count", "animation-name", "animation-play-state",
462
    "animation-timing-function", "appearance", "azimuth", "backdrop-filter",
463
    "backface-visibility", "background", "background-attachment",
464
    "background-blend-mode", "background-clip", "background-color",
465
    "background-image", "background-origin", "background-position",
466
    "background-position-x", "background-position-y", "background-repeat",
467
    "background-size", "baseline-shift", "binding", "bleed", "block-size",
468
    "bookmark-label", "bookmark-level", "bookmark-state", "bookmark-target",
469
    "border", "border-bottom", "border-bottom-color", "border-bottom-left-radius",
470
    "border-bottom-right-radius", "border-bottom-style", "border-bottom-width",
471
    "border-collapse", "border-color", "border-image", "border-image-outset",
472
    "border-image-repeat", "border-image-slice", "border-image-source",
473
    "border-image-width", "border-left", "border-left-color", "border-left-style",
474
    "border-left-width", "border-radius", "border-right", "border-right-color",
475
    "border-right-style", "border-right-width", "border-spacing", "border-style",
476
    "border-top", "border-top-color", "border-top-left-radius",
477
    "border-top-right-radius", "border-top-style", "border-top-width",
478
    "border-width", "bottom", "box-decoration-break", "box-shadow", "box-sizing",
479
    "break-after", "break-before", "break-inside", "caption-side", "caret-color",
480
    "clear", "clip", "color", "color-profile", "column-count", "column-fill",
481
    "column-gap", "column-rule", "column-rule-color", "column-rule-style",
482
    "column-rule-width", "column-span", "column-width", "columns", "contain",
483
    "content", "counter-increment", "counter-reset", "crop", "cue", "cue-after",
484
    "cue-before", "cursor", "direction", "display", "dominant-baseline",
485
    "drop-initial-after-adjust", "drop-initial-after-align",
486
    "drop-initial-before-adjust", "drop-initial-before-align", "drop-initial-size",
487
    "drop-initial-value", "elevation", "empty-cells", "fit", "fit-content", "fit-position",
488
    "flex", "flex-basis", "flex-direction", "flex-flow", "flex-grow",
489
    "flex-shrink", "flex-wrap", "float", "float-offset", "flow-from", "flow-into",
490
    "font", "font-family", "font-feature-settings", "font-kerning",
491
    "font-language-override", "font-optical-sizing", "font-size",
492
    "font-size-adjust", "font-stretch", "font-style", "font-synthesis",
493
    "font-variant", "font-variant-alternates", "font-variant-caps",
494
    "font-variant-east-asian", "font-variant-ligatures", "font-variant-numeric",
495
    "font-variant-position", "font-variation-settings", "font-weight", "gap",
496
    "grid", "grid-area", "grid-auto-columns", "grid-auto-flow", "grid-auto-rows",
497
    "grid-column", "grid-column-end", "grid-column-gap", "grid-column-start",
498
    "grid-gap", "grid-row", "grid-row-end", "grid-row-gap", "grid-row-start",
499
    "grid-template", "grid-template-areas", "grid-template-columns",
500
    "grid-template-rows", "hanging-punctuation", "height", "hyphens", "icon",
501
    "image-orientation", "image-rendering", "image-resolution", "inline-box-align",
502
    "inset", "inset-block", "inset-block-end", "inset-block-start", "inset-inline",
503
    "inset-inline-end", "inset-inline-start", "isolation", "justify-content",
504
    "justify-items", "justify-self", "left", "letter-spacing", "line-break",
505
    "line-height", "line-height-step", "line-stacking", "line-stacking-ruby",
506
    "line-stacking-shift", "line-stacking-strategy", "list-style",
507
    "list-style-image", "list-style-position", "list-style-type", "margin",
508
    "margin-bottom", "margin-left", "margin-right", "margin-top", "marks",
509
    "marquee-direction", "marquee-loop", "marquee-play-count", "marquee-speed",
510
    "marquee-style", "mask-clip", "mask-composite", "mask-image", "mask-mode",
511
    "mask-origin", "mask-position", "mask-repeat", "mask-size","mask-type",
512
    "max-block-size", "max-height", "max-inline-size",
513
    "max-width", "min-block-size", "min-height", "min-inline-size", "min-width",
514
    "mix-blend-mode", "move-to", "nav-down", "nav-index", "nav-left", "nav-right",
515
    "nav-up", "object-fit", "object-position", "offset", "offset-anchor",
516
    "offset-distance", "offset-path", "offset-position", "offset-rotate",
517
    "opacity", "order", "orphans", "outline", "outline-color", "outline-offset",
518
    "outline-style", "outline-width", "overflow", "overflow-style",
519
    "overflow-wrap", "overflow-x", "overflow-y", "padding", "padding-bottom",
520
    "padding-left", "padding-right", "padding-top", "page", "page-break-after",
521
    "page-break-before", "page-break-inside", "page-policy", "pause",
522
    "pause-after", "pause-before", "perspective", "perspective-origin", "pitch",
523
    "pitch-range", "place-content", "place-items", "place-self", "play-during",
524
    "position", "presentation-level", "punctuation-trim", "quotes",
525
    "region-break-after", "region-break-before", "region-break-inside",
526
    "region-fragment", "rendering-intent", "resize", "rest", "rest-after",
527
    "rest-before", "richness", "right", "rotate", "rotation", "rotation-point",
528
    "row-gap", "ruby-align", "ruby-overhang", "ruby-position", "ruby-span",
529
    "scale", "scroll-behavior", "scroll-margin", "scroll-margin-block",
530
    "scroll-margin-block-end", "scroll-margin-block-start", "scroll-margin-bottom",
531
    "scroll-margin-inline", "scroll-margin-inline-end",
532
    "scroll-margin-inline-start", "scroll-margin-left", "scroll-margin-right",
533
    "scroll-margin-top", "scroll-padding", "scroll-padding-block",
534
    "scroll-padding-block-end", "scroll-padding-block-start",
535
    "scroll-padding-bottom", "scroll-padding-inline", "scroll-padding-inline-end",
536
    "scroll-padding-inline-start", "scroll-padding-left", "scroll-padding-right",
537
    "scroll-padding-top", "scroll-snap-align", "scroll-snap-type",
538
    "shape-image-threshold", "shape-inside", "shape-margin", "shape-outside",
539
    "size", "speak", "speak-as", "speak-header", "speak-numeral",
540
    "speak-punctuation", "speech-rate", "stress", "string-set", "tab-size",
541
    "table-layout", "target", "target-name", "target-new", "target-position",
542
    "text-align", "text-align-last", "text-combine-upright", "text-decoration",
543
    "text-decoration-color", "text-decoration-line", "text-decoration-skip",
544
    "text-decoration-skip-ink", "text-decoration-style", "text-emphasis",
545
    "text-emphasis-color", "text-emphasis-position", "text-emphasis-style",
546
    "text-height", "text-indent", "text-justify", "text-orientation",
547
    "text-outline", "text-overflow", "text-rendering", "text-shadow",
548
    "text-size-adjust", "text-space-collapse", "text-transform",
549
    "text-underline-position", "text-wrap", "top", "touch-action", "transform", "transform-origin",
550
    "transform-style", "transition", "transition-delay", "transition-duration",
551
    "transition-property", "transition-timing-function", "translate",
552
    "unicode-bidi", "user-select", "vertical-align", "visibility", "voice-balance",
553
    "voice-duration", "voice-family", "voice-pitch", "voice-range", "voice-rate",
554
    "voice-stress", "voice-volume", "volume", "white-space", "widows", "width",
555
    "will-change", "word-break", "word-spacing", "word-wrap", "writing-mode", "z-index",
556
    // SVG-specific
557
    "clip-path", "clip-rule", "mask", "enable-background", "filter", "flood-color",
558
    "flood-opacity", "lighting-color", "stop-color", "stop-opacity", "pointer-events",
559
    "color-interpolation", "color-interpolation-filters",
560
    "color-rendering", "fill", "fill-opacity", "fill-rule", "image-rendering",
561
    "marker", "marker-end", "marker-mid", "marker-start", "paint-order", "shape-rendering", "stroke",
562
    "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin",
563
    "stroke-miterlimit", "stroke-opacity", "stroke-width", "text-rendering",
564
    "baseline-shift", "dominant-baseline", "glyph-orientation-horizontal",
565
    "glyph-orientation-vertical", "text-anchor", "writing-mode",
566
  ], propertyKeywords = keySet(propertyKeywords_);
567

568
  var nonStandardPropertyKeywords_ = [
569
    "accent-color", "aspect-ratio", "border-block", "border-block-color", "border-block-end",
570
    "border-block-end-color", "border-block-end-style", "border-block-end-width",
571
    "border-block-start", "border-block-start-color", "border-block-start-style",
572
    "border-block-start-width", "border-block-style", "border-block-width",
573
    "border-inline", "border-inline-color", "border-inline-end",
574
    "border-inline-end-color", "border-inline-end-style",
575
    "border-inline-end-width", "border-inline-start", "border-inline-start-color",
576
    "border-inline-start-style", "border-inline-start-width",
577
    "border-inline-style", "border-inline-width", "content-visibility", "margin-block",
578
    "margin-block-end", "margin-block-start", "margin-inline", "margin-inline-end",
579
    "margin-inline-start", "overflow-anchor", "overscroll-behavior", "padding-block", "padding-block-end",
580
    "padding-block-start", "padding-inline", "padding-inline-end",
581
    "padding-inline-start", "scroll-snap-stop", "scrollbar-3d-light-color",
582
    "scrollbar-arrow-color", "scrollbar-base-color", "scrollbar-dark-shadow-color",
583
    "scrollbar-face-color", "scrollbar-highlight-color", "scrollbar-shadow-color",
584
    "scrollbar-track-color", "searchfield-cancel-button", "searchfield-decoration",
585
    "searchfield-results-button", "searchfield-results-decoration", "shape-inside", "zoom"
586
  ], nonStandardPropertyKeywords = keySet(nonStandardPropertyKeywords_);
587

588
  var fontProperties_ = [
589
    "font-display", "font-family", "src", "unicode-range", "font-variant",
590
     "font-feature-settings", "font-stretch", "font-weight", "font-style"
591
  ], fontProperties = keySet(fontProperties_);
592

593
  var counterDescriptors_ = [
594
    "additive-symbols", "fallback", "negative", "pad", "prefix", "range",
595
    "speak-as", "suffix", "symbols", "system"
596
  ], counterDescriptors = keySet(counterDescriptors_);
597

598
  var colorKeywords_ = [
599
    "aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige",
600
    "bisque", "black", "blanchedalmond", "blue", "blueviolet", "brown",
601
    "burlywood", "cadetblue", "chartreuse", "chocolate", "coral", "cornflowerblue",
602
    "cornsilk", "crimson", "cyan", "darkblue", "darkcyan", "darkgoldenrod",
603
    "darkgray", "darkgreen", "darkgrey", "darkkhaki", "darkmagenta", "darkolivegreen",
604
    "darkorange", "darkorchid", "darkred", "darksalmon", "darkseagreen",
605
    "darkslateblue", "darkslategray", "darkslategrey", "darkturquoise", "darkviolet",
606
    "deeppink", "deepskyblue", "dimgray", "dimgrey", "dodgerblue", "firebrick",
607
    "floralwhite", "forestgreen", "fuchsia", "gainsboro", "ghostwhite",
608
    "gold", "goldenrod", "gray", "grey", "green", "greenyellow", "honeydew",
609
    "hotpink", "indianred", "indigo", "ivory", "khaki", "lavender",
610
    "lavenderblush", "lawngreen", "lemonchiffon", "lightblue", "lightcoral",
611
    "lightcyan", "lightgoldenrodyellow", "lightgray", "lightgreen", "lightgrey", "lightpink",
612
    "lightsalmon", "lightseagreen", "lightskyblue", "lightslategray", "lightslategrey",
613
    "lightsteelblue", "lightyellow", "lime", "limegreen", "linen", "magenta",
614
    "maroon", "mediumaquamarine", "mediumblue", "mediumorchid", "mediumpurple",
615
    "mediumseagreen", "mediumslateblue", "mediumspringgreen", "mediumturquoise",
616
    "mediumvioletred", "midnightblue", "mintcream", "mistyrose", "moccasin",
617
    "navajowhite", "navy", "oldlace", "olive", "olivedrab", "orange", "orangered",
618
    "orchid", "palegoldenrod", "palegreen", "paleturquoise", "palevioletred",
619
    "papayawhip", "peachpuff", "peru", "pink", "plum", "powderblue",
620
    "purple", "rebeccapurple", "red", "rosybrown", "royalblue", "saddlebrown",
621
    "salmon", "sandybrown", "seagreen", "seashell", "sienna", "silver", "skyblue",
622
    "slateblue", "slategray", "slategrey", "snow", "springgreen", "steelblue", "tan",
623
    "teal", "thistle", "tomato", "turquoise", "violet", "wheat", "white",
624
    "whitesmoke", "yellow", "yellowgreen"
625
  ], colorKeywords = keySet(colorKeywords_);
626

627
  var valueKeywords_ = [
628
    "above", "absolute", "activeborder", "additive", "activecaption", "afar",
629
    "after-white-space", "ahead", "alias", "all", "all-scroll", "alphabetic", "alternate",
630
    "always", "amharic", "amharic-abegede", "antialiased", "appworkspace",
631
    "arabic-indic", "armenian", "asterisks", "attr", "auto", "auto-flow", "avoid", "avoid-column", "avoid-page",
632
    "avoid-region", "axis-pan", "background", "backwards", "baseline", "below", "bidi-override", "binary",
633
    "bengali", "blink", "block", "block-axis", "blur", "bold", "bolder", "border", "border-box",
634
    "both", "bottom", "break", "break-all", "break-word", "brightness", "bullets", "button", "button-bevel",
635
    "buttonface", "buttonhighlight", "buttonshadow", "buttontext", "calc", "cambodian",
636
    "capitalize", "caps-lock-indicator", "caption", "captiontext", "caret",
637
    "cell", "center", "checkbox", "circle", "cjk-decimal", "cjk-earthly-branch",
638
    "cjk-heavenly-stem", "cjk-ideographic", "clear", "clip", "close-quote",
639
    "col-resize", "collapse", "color", "color-burn", "color-dodge", "column", "column-reverse",
640
    "compact", "condensed", "conic-gradient", "contain", "content", "contents",
641
    "content-box", "context-menu", "continuous", "contrast", "copy", "counter", "counters", "cover", "crop",
642
    "cross", "crosshair", "cubic-bezier", "currentcolor", "cursive", "cyclic", "darken", "dashed", "decimal",
643
    "decimal-leading-zero", "default", "default-button", "dense", "destination-atop",
644
    "destination-in", "destination-out", "destination-over", "devanagari", "difference",
645
    "disc", "discard", "disclosure-closed", "disclosure-open", "document",
646
    "dot-dash", "dot-dot-dash",
647
    "dotted", "double", "down", "drop-shadow", "e-resize", "ease", "ease-in", "ease-in-out", "ease-out",
648
    "element", "ellipse", "ellipsis", "embed", "end", "ethiopic", "ethiopic-abegede",
649
    "ethiopic-abegede-am-et", "ethiopic-abegede-gez", "ethiopic-abegede-ti-er",
650
    "ethiopic-abegede-ti-et", "ethiopic-halehame-aa-er",
651
    "ethiopic-halehame-aa-et", "ethiopic-halehame-am-et",
652
    "ethiopic-halehame-gez", "ethiopic-halehame-om-et",
653
    "ethiopic-halehame-sid-et", "ethiopic-halehame-so-et",
654
    "ethiopic-halehame-ti-er", "ethiopic-halehame-ti-et", "ethiopic-halehame-tig",
655
    "ethiopic-numeric", "ew-resize", "exclusion", "expanded", "extends", "extra-condensed",
656
    "extra-expanded", "fantasy", "fast", "fill", "fill-box", "fixed", "flat", "flex", "flex-end", "flex-start", "footnotes",
657
    "forwards", "from", "geometricPrecision", "georgian", "grayscale", "graytext", "grid", "groove",
658
    "gujarati", "gurmukhi", "hand", "hangul", "hangul-consonant", "hard-light", "hebrew",
659
    "help", "hidden", "hide", "higher", "highlight", "highlighttext",
660
    "hiragana", "hiragana-iroha", "horizontal", "hsl", "hsla", "hue", "hue-rotate", "icon", "ignore",
661
    "inactiveborder", "inactivecaption", "inactivecaptiontext", "infinite",
662
    "infobackground", "infotext", "inherit", "initial", "inline", "inline-axis",
663
    "inline-block", "inline-flex", "inline-grid", "inline-table", "inset", "inside", "intrinsic", "invert",
664
    "italic", "japanese-formal", "japanese-informal", "justify", "kannada",
665
    "katakana", "katakana-iroha", "keep-all", "khmer",
666
    "korean-hangul-formal", "korean-hanja-formal", "korean-hanja-informal",
667
    "landscape", "lao", "large", "larger", "left", "level", "lighter", "lighten",
668
    "line-through", "linear", "linear-gradient", "lines", "list-item", "listbox", "listitem",
669
    "local", "logical", "loud", "lower", "lower-alpha", "lower-armenian",
670
    "lower-greek", "lower-hexadecimal", "lower-latin", "lower-norwegian",
671
    "lower-roman", "lowercase", "ltr", "luminosity", "malayalam", "manipulation", "match", "matrix", "matrix3d",
672
    "media-controls-background", "media-current-time-display",
673
    "media-fullscreen-button", "media-mute-button", "media-play-button",
674
    "media-return-to-realtime-button", "media-rewind-button",
675
    "media-seek-back-button", "media-seek-forward-button", "media-slider",
676
    "media-sliderthumb", "media-time-remaining-display", "media-volume-slider",
677
    "media-volume-slider-container", "media-volume-sliderthumb", "medium",
678
    "menu", "menulist", "menulist-button", "menulist-text",
679
    "menulist-textfield", "menutext", "message-box", "middle", "min-intrinsic",
680
    "mix", "mongolian", "monospace", "move", "multiple", "multiple_mask_images", "multiply", "myanmar", "n-resize",
681
    "narrower", "ne-resize", "nesw-resize", "no-close-quote", "no-drop",
682
    "no-open-quote", "no-repeat", "none", "normal", "not-allowed", "nowrap",
683
    "ns-resize", "numbers", "numeric", "nw-resize", "nwse-resize", "oblique", "octal", "opacity", "open-quote",
684
    "optimizeLegibility", "optimizeSpeed", "oriya", "oromo", "outset",
685
    "outside", "outside-shape", "overlay", "overline", "padding", "padding-box",
686
    "painted", "page", "paused", "persian", "perspective", "pinch-zoom", "plus-darker", "plus-lighter",
687
    "pointer", "polygon", "portrait", "pre", "pre-line", "pre-wrap", "preserve-3d",
688
    "progress", "push-button", "radial-gradient", "radio", "read-only",
689
    "read-write", "read-write-plaintext-only", "rectangle", "region",
690
    "relative", "repeat", "repeating-linear-gradient", "repeating-radial-gradient",
691
    "repeating-conic-gradient", "repeat-x", "repeat-y", "reset", "reverse",
692
    "rgb", "rgba", "ridge", "right", "rotate", "rotate3d", "rotateX", "rotateY",
693
    "rotateZ", "round", "row", "row-resize", "row-reverse", "rtl", "run-in", "running",
694
    "s-resize", "sans-serif", "saturate", "saturation", "scale", "scale3d", "scaleX", "scaleY", "scaleZ", "screen",
695
    "scroll", "scrollbar", "scroll-position", "se-resize", "searchfield",
696
    "searchfield-cancel-button", "searchfield-decoration",
697
    "searchfield-results-button", "searchfield-results-decoration", "self-start", "self-end",
698
    "semi-condensed", "semi-expanded", "separate", "sepia", "serif", "show", "sidama",
699
    "simp-chinese-formal", "simp-chinese-informal", "single",
700
    "skew", "skewX", "skewY", "skip-white-space", "slide", "slider-horizontal",
701
    "slider-vertical", "sliderthumb-horizontal", "sliderthumb-vertical", "slow",
702
    "small", "small-caps", "small-caption", "smaller", "soft-light", "solid", "somali",
703
    "source-atop", "source-in", "source-out", "source-over", "space", "space-around", "space-between", "space-evenly", "spell-out", "square",
704
    "square-button", "start", "static", "status-bar", "stretch", "stroke", "stroke-box", "sub",
705
    "subpixel-antialiased", "svg_masks", "super", "sw-resize", "symbolic", "symbols", "system-ui", "table",
706
    "table-caption", "table-cell", "table-column", "table-column-group",
707
    "table-footer-group", "table-header-group", "table-row", "table-row-group",
708
    "tamil",
709
    "telugu", "text", "text-bottom", "text-top", "textarea", "textfield", "thai",
710
    "thick", "thin", "threeddarkshadow", "threedface", "threedhighlight",
711
    "threedlightshadow", "threedshadow", "tibetan", "tigre", "tigrinya-er",
712
    "tigrinya-er-abegede", "tigrinya-et", "tigrinya-et-abegede", "to", "top",
713
    "trad-chinese-formal", "trad-chinese-informal", "transform",
714
    "translate", "translate3d", "translateX", "translateY", "translateZ",
715
    "transparent", "ultra-condensed", "ultra-expanded", "underline", "unidirectional-pan", "unset", "up",
716
    "upper-alpha", "upper-armenian", "upper-greek", "upper-hexadecimal",
717
    "upper-latin", "upper-norwegian", "upper-roman", "uppercase", "urdu", "url",
718
    "var", "vertical", "vertical-text", "view-box", "visible", "visibleFill", "visiblePainted",
719
    "visibleStroke", "visual", "w-resize", "wait", "wave", "wider",
720
    "window", "windowframe", "windowtext", "words", "wrap", "wrap-reverse", "x-large", "x-small", "xor",
721
    "xx-large", "xx-small"
722
  ], valueKeywords = keySet(valueKeywords_);
723

724
  var allWords = documentTypes_.concat(mediaTypes_).concat(mediaFeatures_).concat(mediaValueKeywords_)
725
    .concat(propertyKeywords_).concat(nonStandardPropertyKeywords_).concat(colorKeywords_)
726
    .concat(valueKeywords_);
727
  CodeMirror.registerHelper("hintWords", "css", allWords);
728

729
  function tokenCComment(stream, state) {
730
    var maybeEnd = false, ch;
731
    while ((ch = stream.next()) != null) {
732
      if (maybeEnd && ch == "/") {
733
        state.tokenize = null;
734
        break;
735
      }
736
      maybeEnd = (ch == "*");
737
    }
738
    return ["comment", "comment"];
739
  }
740

741
  CodeMirror.defineMIME("text/css", {
742
    documentTypes: documentTypes,
743
    mediaTypes: mediaTypes,
744
    mediaFeatures: mediaFeatures,
745
    mediaValueKeywords: mediaValueKeywords,
746
    propertyKeywords: propertyKeywords,
747
    nonStandardPropertyKeywords: nonStandardPropertyKeywords,
748
    fontProperties: fontProperties,
749
    counterDescriptors: counterDescriptors,
750
    colorKeywords: colorKeywords,
751
    valueKeywords: valueKeywords,
752
    tokenHooks: {
753
      "/": function(stream, state) {
754
        if (!stream.eat("*")) return false;
755
        state.tokenize = tokenCComment;
756
        return tokenCComment(stream, state);
757
      }
758
    },
759
    name: "css"
760
  });
761

762
  CodeMirror.defineMIME("text/x-scss", {
763
    mediaTypes: mediaTypes,
764
    mediaFeatures: mediaFeatures,
765
    mediaValueKeywords: mediaValueKeywords,
766
    propertyKeywords: propertyKeywords,
767
    nonStandardPropertyKeywords: nonStandardPropertyKeywords,
768
    colorKeywords: colorKeywords,
769
    valueKeywords: valueKeywords,
770
    fontProperties: fontProperties,
771
    allowNested: true,
772
    lineComment: "//",
773
    tokenHooks: {
774
      "/": function(stream, state) {
775
        if (stream.eat("/")) {
776
          stream.skipToEnd();
777
          return ["comment", "comment"];
778
        } else if (stream.eat("*")) {
779
          state.tokenize = tokenCComment;
780
          return tokenCComment(stream, state);
781
        } else {
782
          return ["operator", "operator"];
783
        }
784
      },
785
      ":": function(stream) {
786
        if (stream.match(/^\s*\{/, false))
787
          return [null, null]
788
        return false;
789
      },
790
      "$": function(stream) {
791
        stream.match(/^[\w-]+/);
792
        if (stream.match(/^\s*:/, false))
793
          return ["variable-2", "variable-definition"];
794
        return ["variable-2", "variable"];
795
      },
796
      "#": function(stream) {
797
        if (!stream.eat("{")) return false;
798
        return [null, "interpolation"];
799
      }
800
    },
801
    name: "css",
802
    helperType: "scss"
803
  });
804

805
  CodeMirror.defineMIME("text/x-less", {
806
    mediaTypes: mediaTypes,
807
    mediaFeatures: mediaFeatures,
808
    mediaValueKeywords: mediaValueKeywords,
809
    propertyKeywords: propertyKeywords,
810
    nonStandardPropertyKeywords: nonStandardPropertyKeywords,
811
    colorKeywords: colorKeywords,
812
    valueKeywords: valueKeywords,
813
    fontProperties: fontProperties,
814
    allowNested: true,
815
    lineComment: "//",
816
    tokenHooks: {
817
      "/": function(stream, state) {
818
        if (stream.eat("/")) {
819
          stream.skipToEnd();
820
          return ["comment", "comment"];
821
        } else if (stream.eat("*")) {
822
          state.tokenize = tokenCComment;
823
          return tokenCComment(stream, state);
824
        } else {
825
          return ["operator", "operator"];
826
        }
827
      },
828
      "@": function(stream) {
829
        if (stream.eat("{")) return [null, "interpolation"];
830
        if (stream.match(/^(charset|document|font-face|import|(-(moz|ms|o|webkit)-)?keyframes|media|namespace|page|supports)\b/i, false)) return false;
831
        stream.eatWhile(/[\w\\\-]/);
832
        if (stream.match(/^\s*:/, false))
833
          return ["variable-2", "variable-definition"];
834
        return ["variable-2", "variable"];
835
      },
836
      "&": function() {
837
        return ["atom", "atom"];
838
      }
839
    },
840
    name: "css",
841
    helperType: "less"
842
  });
843

844
  CodeMirror.defineMIME("text/x-gss", {
845
    documentTypes: documentTypes,
846
    mediaTypes: mediaTypes,
847
    mediaFeatures: mediaFeatures,
848
    propertyKeywords: propertyKeywords,
849
    nonStandardPropertyKeywords: nonStandardPropertyKeywords,
850
    fontProperties: fontProperties,
851
    counterDescriptors: counterDescriptors,
852
    colorKeywords: colorKeywords,
853
    valueKeywords: valueKeywords,
854
    supportsAtComponent: true,
855
    tokenHooks: {
856
      "/": function(stream, state) {
857
        if (!stream.eat("*")) return false;
858
        state.tokenize = tokenCComment;
859
        return tokenCComment(stream, state);
860
      }
861
    },
862
    name: "css",
863
    helperType: "gss"
864
  });
865

866
});
867