Lines Matching +full:css +full:- +full:lint
12 * Copyright (C) 2004-2016 Alex Gorbatchev.
95 // configured through the `--compat` parameter.
216 if (params['html-script'] == true || defaults['html-script'] == true) {
326 if (copy.indexOf(right) == copyLength - rightLength) {
327 copy = copy.substring(0, copyLength - rightLength);
345 /* an EJS hook for `gulp build --brushes` command
439 return key.replace(/-(\w+)/g, function (match, word) {
462 regex = XRegExp("(?<name>[\\w-]+)" + "\\s*:\\s*" + "(?<value>" + "[\\w%#-]+|" + // word
513 xmlComments: (0, _xregexp2.default)('(<|<)!--.*?--(>|>)', 'gs'),
514 url: /\w+:\/\/[\w-.\/?%&=:@;#]*/g,
525 * XRegExp 3.1.0-dev
527 * Steven Levithan (c) 2007-2015 MIT License
533 * make your client-side grepping simpler and more powerful, while freeing you from related
534 * cross-browser inconsistencies.
573 …'default': /\\(?:0(?:[0-3][0-7]{0,2}|[4-7][0-7]?)?|[1-9]\d*|x[\dA-Fa-f]{2}|u(?:[\dA-Fa-f]{4}|{[\dA…
575 …'class': /\\(?:[0-3][0-7]{0,2}|[4-7][0-7]?|x[\dA-Fa-f]{2}|u(?:[\dA-Fa-f]{4}|{[\dA-Fa-f]+})|c[A-Za-…
577 // Any backreference or dollar-prefixed character in replacement strings
627 * operations, and never exposed to users. For internal-only regexes, we can improve perf by
642 // Can't auto-inherit these since the XRegExp constructor returns a nonprimitive value
685 * operations, and never exposed to users. For internal-only regexes, we can improve perf by
730 // Flags are only added for non-internal regexes by `XRegExp.globalize`. Flags are
731 // never removed for non-internal regexes, so don't need to handle it
768 nativ.exec.call(/\/([a-z]*)$/i, RegExp.prototype.toString.call(regex))[1];
799 * @returns {Number} Zero-based index at which the item is found, or -1.
811 return -1;
836 return nativ.test.call(flags.indexOf('x') > -1 ?
845 * fixed-length hexadecimal values.
859 * Checks for flag-related errors, and strips/applies flags in a leading mode modifier. Offloads
923 * @param {String} flag Single-character flag to register.
927 throw new Error('Flag must be a single character A-Za-z0-9_$');
934 * Runs built-in and custom regex syntax tokens in reverse insertion order at the specified
953 while (i--) {
955 …!== leadChar || t.scope !== scope && t.scope !== 'all' || t.flag && flags.indexOf(t.flag) === -1) {
975 * Enables or disables implicit astral mode opt-in. When enabled, flag A is automatically added to
1033 * <li>`g` - global
1034 * <li>`i` - ignore case
1035 * <li>`m` - multiline anchors
1036 * <li>`u` - unicode (ES6)
1037 * <li>`y` - sticky (Firefox 3+, ES6)
1039 * <li>`n` - explicit capture
1040 * <li>`s` - dot matches all (aka singleline)
1041 * <li>`x` - free-spacing and line comments (aka extended)
1042 * <li>`A` - astral (requires the Unicode Base addon)
1048 * XRegExp('(?<year> [0-9]{4} ) -? # year \n\
1049 * (?<month> [0-9]{2} ) -? # month \n\
1050 * (?<day> [0-9]{2} ) # day ', 'x');
1082 if (XRegExp.isInstalled('astral') && flags.indexOf('A') === -1) {
1092 // Check for flag-related errors, and strip/apply flags in a leading mode modifier
1148 * The XRegExp version number as a string containing three dot-separated parts. For example,
1149 * '2.0.0-beta-3'.
1155 XRegExp.version = '3.1.0-dev';
1177 * <li>`flag` {String} Single-character flag that triggers the token. This also registers the
1197 * XRegExp('\\a[\\a-\\n]+').test('\x07\n\x07'); // -> true
1207 * XRegExp('a+', 'U').exec('aaa')[0]; // -> 'a'
1208 * XRegExp('a+?', 'U').exec('aaa')[0]; // -> 'aaa'
1287 * // -> 'Escaped\?\ <\.>'
1290 return nativ.replace.call(toObject(str), /[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
1299 * `RegExp.prototype.exec` and can be used reliably cross-browser.
1304 * @param {Number} [pos=0] Zero-based index at which to start the search.
1311 * var match = XRegExp.exec('U+2620', XRegExp('U\\+(?<hex>[0-9A-F]{4})'));
1312 * match.hex; // -> '2620'
1320 * // result -> ['2', '3', '4']
1369 * <li>The zero-based match index.
1379 * // evens -> [2, 4]
1383 i = -1,
1410 * globalCopy.global; // -> true
1430 * // backreferences and fix numerous cross-browser bugs
1474 * XRegExp.isRegExp('string'); // -> false
1475 * XRegExp.isRegExp(/regex/i); // -> true
1476 * XRegExp.isRegExp(RegExp('^', 'm')); // -> true
1477 * XRegExp.isRegExp(XRegExp('(?s).')); // -> true
1486 * This is essentially a more convenient re-implementation of `String.prototype.match` that gives
1487 * the result types you actually want (string instead of `exec`-style array in match-first mode,
1488 * and an empty array instead of `null` when no matches are found in match-all mode). It also lets
1497 * @returns {String|Array} In match-first mode: First match as a string, or `null`. In match-all
1502 * XRegExp.match('abc', /\w/); // -> 'a'
1503 * XRegExp.match('abc', /\w/g, 'one'); // -> 'a'
1504 * XRegExp.match('abc', /x/g, 'one'); // -> null
1507 * XRegExp.match('abc', /\w/g); // -> ['a', 'b', 'c']
1508 * XRegExp.match('abc', /\w/, 'all'); // -> ['a', 'b', 'c']
1509 * XRegExp.match('abc', /x/, 'all'); // -> []
1555 * // -> ['2', '4', '56']
1564 * // -> ['xregexp.com', 'www.google.com']
1593 … return level === chain.length - 1 || !matches.length ? matches : recurseChain(matches, level + 1);
1603 * to the native `String.prototype.replace` and can be used reliably cross-browser.
1610 * <li>$$ - Inserts a literal $ character.
1611 * <li>$&, $0 - Inserts the matched substring.
1612 * <li>$` - Inserts the string that precedes the matched substring (left context).
1613 * <li>$' - Inserts the string that follows the matched substring (right context).
1614 * <li>$n, $nn - Where n/nn are digits referencing an existent capturing group, inserts
1616 * <li>${n} - Where n is a name or any number of digits that reference an existent capturing
1622 * <li>The zero-based index of the match within the total search string.
1632 * // -> 'Smith, John'
1638 * // -> 'Smith, John'
1640 * // String search, with replace-all
1642 * // -> 'XRegExp builds XRegExps'
1695 * ['e', 'v', 'all'], // scope 'all' allows replace-all for strings
1717 * cross-browser.
1728 * // -> ['a', 'b', 'c']
1732 * // -> ['a', 'b']
1735 * XRegExp.split('..word1..', /([a-z]+)(\d+)/i);
1736 * // -> ['..', 'word', '1', '..']
1747 * `RegExp.prototype.test` and can be used reliably cross-browser.
1752 * @param {Number} [pos=0] Zero-based index at which to start the search.
1759 * XRegExp.test('abc', /c/); // -> true
1762 * XRegExp.test('abc', /c/, 0, 'sticky'); // -> false
1763 * XRegExp.test('abc', /c/, 2, 'sticky'); // -> true
1766 // Do this the easy way :-)
1816 * // -> /a\+b\*c|(dogs)\1|(cats)\2/i
1819 var parts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*]/g,
1826 var name = captureNames[numCaptures - numPriorCaptures];
1889 // capturing groups. This fixes IE 5.5-8, but not IE 9's quirks mode or emulation of
1891 if (!correctExecNpcg && match.length > 1 && indexOf(match, '') > -1) {
1902 for (i = 1; i < len - 2; ++i) {
1914 name = this[REGEX_DATA].captureNames[i - 1];
1921 // Fix browsers that increment `lastIndex` after zero-length matches
1944 // Do this the easy way :-)
2002 search += ''; // Type-convert
2008 // functions isn't type-converted to a string
2026 search.lastIndex = args[args.length - 2] + args[0].length;
2050 n = +$1; // Type-convert; drop leading zeros
2051 if (n <= args.length - 3) {
2055 n = captureNames ? indexOf(captureNames, $1) : -1;
2067 // $&, $0 (not followed by 1-9), $00
2072 return args[args.length - 1].slice(0, args[args.length - 2]);
2076 return args[args.length - 1].slice(args[args.length - 2] + args[0].length);
2079 $2 = +$2; // Type-convert; drop leading zero
2081 // - Backrefs end after 1 or 2 digits. Use `${..}` for more digits.
2082 // - `$1` is an error if no capturing groups.
2083 // - `$10` is an error if less than 10 capturing groups. Use `${1}0` instead.
2084 // - `$01` is `$1` if at least one capturing group, else it's an error.
2085 // - `$0` (not followed by 1-9) and `$00` are the entire match.
2087 // - Backrefs end after 1 or 2 digits. Cannot reference capturing group 100+.
2088 // - `$1` is a literal `$1` if no capturing groups.
2089 // - `$10` is `$1` followed by a literal `0` if less than 10 capturing groups.
2090 // - `$01` is `$1` if at least one capturing group, else it's a literal `$01`.
2091 // - `$0` is a literal `$0`.
2093 if ($2 > args.length - 3) {
2139 // If undefined: pow(2,32) - 1
2141 // If positive number: limit = floor(limit); if (limit >= pow(2,32)) limit -= pow(2,32);
2142 // If negative number: pow(2,32) - floor(abs(limit))
2143 // If other: Type-convert, then use the above rules
2144 // This line fails in very strange ways for some values of `limit` in Opera 10.5-10.63,
2145 // unless Opera Dragonfly is open (go figure). It works in at least Opera 9.5-10.1 and 11+
2146 limit = (limit === undefined ? -1 : limit) >>> 0;
2173 * Built-in syntax/flag tokens
2178 * SyntaxErrors but are allowed in web reality. XRegExp makes them errors for cross-browser
2181 …XRegExp.addToken(/\\([ABCE-RTUVXYZaeg-mopqyz]|c(?![A-Za-z])|u(?![\dA-Fa-f]{4}|{[\dA-Fa-f]+})|x(?![…
2194 …* hexadecimal number from 0-10FFFF, and can include leading zeros. Requires the native ES6 `u` flag
2200 XRegExp.addToken(/\\u{([\dA-Fa-f]+)}/, function (match, scope, flags) {
2211 if (hasNativeU && flags.indexOf('u') > -1) {
2221 * Empty character class: `[]` or `[^]`. This fixes a critical cross-browser syntax inconsistency.
2226 // For cross-browser compatibility with ES3, convert [] to \b\B and [^] to [\s\S].
2233 * free-spacing mode (flag x).
2241 * Whitespace and line comments, in free-spacing mode (aka extended mode, flag x) only.
2259 * Named backreference: `\k<name>`. Backreference names can use the characters A-Z, a-z, 0-9, _,
2275 * not followed by 0-9 and backreferences to unopened capture groups throw an error. Other matches
2279 …if (!(scope === defaultScope && /^[1-9]/.test(match[1]) && +match[1] <= this.captureNames.length) …
2290 * characters A-Z, a-z, 0-9, _, and $ only. Names can't be integers. Supports Python-style
2292 * supported the Python-style syntax. Otherwise, XRegExp might treat numbered backreferences to
2293 * Python-style named capture as octals.
2304 if (indexOf(this.captureNames, match[1]) > -1) {
2317 if (flags.indexOf('n') > -1) {
2382 function Match(value, index, css) {
2388 this.css = css;
2478 …esultMatch === 'string') resultMatch = [new _match.Match(resultMatch, match.index, regexInfo.css)];
2493 if (m1.index < m2.index) return -1;else if (m1.index > m2.index) return 1;else {
2495 if (m1.length < m2.length) return -1;else if (m1.length > m2.length) return 1;
2596 * @param {String} css Style name to apply to the string.
2599 wrapLinesWithCode: function wrapLinesWithCode(str, css) {
2600 if (str == null || str.length == 0 || str == '\n' || css == null) return str;
2616 for (i = 0, l = m.length; i < l - 1; i++) {
2634 … line = line.length === 0 ? spaces : spaces + '<code class="' + css + '">' + line + '</code>';
2650 url = /\w+:\/\/[\w-.\/?%&=:@;#]*/g;
2670 * Creates an array containing integer line numbers starting from the 'first-line' param.
2717 …if (pad == true) pad = (firstLine + count - 1).toString().length;else if (isNaN(pad) == true) pad …
2805 …de.substr(pos, match.index - pos), matchBrushName + 'plain') + _this.wrapLinesWithCode(match.value…
2840 // add brush alias to the class name for custom CSS
2971 var tabSize = opts['tab-size'];
2972 …code = opts['smart-tabs'] === true ? retabber.smart(code, tabSize) : retabber.regular(code, tabSiz…
3098 if (line.indexOf(tab) === -1) continue;
3102 while ((pos = line.indexOf(tab)) !== -1) {
3106 line = insertSpaces(line, pos, tabSize - pos % tabSize);
3142 * Checks if target DOM elements has specified CSS class.
3144 * @param {String} className Name of the CSS class to check for.
3148 return target.className.indexOf(className) != -1;
3152 * Adds CSS class name to the target DOM element.
3154 * @param {String} className New CSS class to add.
3161 * Removes CSS class name from the target DOM element.
3163 * @param {String} className CSS class to remove.
3215 if ((target[propertyToFind] || '').indexOf(expectedValue) != -1) return target;
3243 var x = (screen.width - width) / 2,
3244 y = (screen.height - height) / 2;
3370 /** Additional CSS class names to be added to highlighter elements. */
3371 'class-name': '',
3374 'first-line': 1,
3379 * false - don't pad line numbers.
3380 * true - automaticaly pad numbers with minimum required number of leading zeroes.
3381 * [int] - length up to which pad line numbers.
3383 'pad-line-numbers': false,
3392 'smart-tabs': true,
3395 'tab-size': 4,
3401 'quick-code': true,
3407 'auto-links': true,
3411 'html-script': false
3430 …if (scriptBrush.htmlScript == null) throw new Error('Brush wasn\'t configured for html-script opti…
3574 var queueIndex = -1;
3584 queueIndex = -1;
3607 queueIndex = -1;
3616 var args = new Array(arguments.length - 1);
3619 args[i - 1] = arguments[i];
3713 * Makes a brush compatible with the `html-script` functionality.
3727 left: { regex: regexGroup.left, css: 'script' }, property
3728 right: { regex: regexGroup.right, css: 'script' }, property
3763 regex: /(--|#).*$/gm,
3764 css: 'comments' property
3767 css: 'comments' property
3770 css: 'string' property
3773 css: 'color1' property
3775 regex: /(-)?(\d)+(\.(\d)?)?(E\+(\d)+)?/g, // numbers
3776 css: 'color1' property
3778 regex: /(?:&(amp;|gt;|lt;)?|=|� |>|<|≥|>=|≤|<=|\*|\+|-|\/|÷|\^)/g,
3779 css: 'color2' property
3782 css: 'keyword' property
3785 css: 'keyword' property
3788 css: 'color3' property
3790 …ves )?configuration|visible|image( name)?|menu form representation|tag|user(-| )defaults|associate…
3791 css: 'color4' property
3794 css: 'classes' property
3797 css: 'properties' property
3800 css: 'commandNames' property
3803 css: 'additionClasses' property
3806 css: 'additionParameterNames' property
3809 css: 'additionCommandNames' property
3812 css: 'parameterNames' property
3815 css: 'enumeratedValues' property
3818 css: 'color3' property
3821 css: 'keyword' property
3824 css: 'keyword' property
3846 …var keywords = '-Infinity ...rest Array as AS3 Boolean break case catch const continue Date decode…
3850 css: 'comments' property
3853 css: 'comments' property
3856 css: 'string' property
3859 css: 'string' property
3861 regex: /\b([\d]+(\.[\d]+)?|0x[a-f0-9]+)\b/gi,
3862 css: 'value' property
3865 css: 'color3' property
3868 css: 'keyword' property
3871 css: 'variable' property
3874 css: 'color1' property
3913 css: 'preprocessor bold' property
3915 regex: /\/[\w-\/]+/gm,
3916 css: 'plain' property
3919 css: 'comments' property
3922 css: 'string' property
3925 css: 'string' property
3928 css: 'keyword' property
3931 css: 'functions' property
3953 // http://www.jensbits.com/2009/05/14/coldfusion-brush-for-syntaxhighlighter-plus
3962 regex: new RegExp('--(.*)$', 'gm'),
3963 css: 'comments' property
3966 css: 'comments' property
3969 css: 'string' property
3972 css: 'string' property
3975 css: 'functions' property
3978 css: 'color1' property
3981 css: 'keyword' property
4009 css: 'comments' property
4012 css: 'comments' property
4015 css: 'string' property
4018 css: 'string' property
4021 css: 'preprocessor' property
4024 css: 'color1 bold' property
4027 css: 'functions bold' property
4030 css: 'keyword bold' property
4052 var css = match[0].indexOf("///") == 0 ? 'color1' : 'comments';
4053 return [new Match(match[0], match.index, css)];
4061 css: 'comments' property
4064 css: 'string' property
4067 css: 'string' property
4070 css: 'string' property
4073 css: 'preprocessor' property
4076 css: 'keyword' property
4079 css: 'keyword' property
4082 css: 'keyword' property
4089 Brush.aliases = ['c#', 'c-sharp', 'csharp'];
4103 return '\\b([a-z_]|)' + str.replace(/ /g, '(?=:)\\b|\\b([a-z_\\*]|\\*|)') + '(?=:)\\b';
4107 return '\\b' + str.replace(/ /g, '(?!-)(?!:)\\b|\\b()') + '\:\\b';
4110 …-attachment background-color background-image background-position ' + 'background-repeat backgroun…
4112 …-override black blink block blue bold bolder ' + 'both bottom braille capitalize caption center ce…
4114 …var fonts = '[mM]onospace [tT]ahoma [vV]erdana [aA]rial [hH]elvetica [sS]ans-serif [sS]erif [cC]ou…
4118 css: 'comments' property
4121 css: 'string' property
4124 css: 'string' property
4126 regex: /\#[a-fA-F0-9]{3,6}/g,
4127 css: 'value' property
4129 regex: /(-?\d+)(\.\d+)?(px|em|pt|\:|\%|)/g,
4130 css: 'value' property
4133 css: 'color3' property
4136 css: 'keyword' property
4139 css: 'value' property
4142 css: 'color1' property
4152 Brush.aliases = ['css'];
4169 css: 'comments' property
4172 css: 'comments' property
4175 css: 'comments' property
4178 css: 'string' property
4180 regex: /\{\$[a-zA-Z]+ .+\}/g,
4181 css: 'color1' property
4184 css: 'value' property
4186 regex: /\$[a-zA-Z0-9]+\b/g,
4187 css: 'value' property
4190 css: 'keyword' property
4210 css: 'color2' property
4212 regex: /^\-\-\- .*$/gm,
4213 css: 'color2' property
4216 css: 'color1' property
4219 css: 'variable' property
4222 css: 'string' property
4224 regex: /^\-.*$/gm,
4225 css: 'color3' property
4243 // Contributed by Jean-Lou Dupont
4244 // http://jldupont.blogspot.com/2009/06/erlang-syntax-highlighter.html
4252 regex: new RegExp("[A-Z][A-Za-z0-9_]+", 'g'),
4253 css: 'constants' property
4256 css: 'comments' property
4258 regex: new RegExp("\\?[A-Za-z0-9_]+", 'g'),
4259 css: 'preprocessor' property
4261 regex: new RegExp("[a-z0-9_]+:[a-z0-9_]+", 'g'),
4262 css: 'functions' property
4265 css: 'string' property
4268 css: 'string' property
4271 css: 'keyword' property
4299 css: 'comments' property
4302 css: 'comments' property
4305 css: 'string' property
4308 css: 'string' property
4311 css: 'string' property
4313 regex: new RegExp('\\b([\\d]+(\\.[\\d]+)?|0x[a-f0-9]+)\\b', 'gi'),
4314 css: 'value' property
4317 css: 'keyword' property
4320 css: 'color1' property
4323 css: 'constants' property
4326 css: 'functions' property
4353 css: 'comments' property
4356 css: 'comments' property
4359 css: 'string' property
4362 css: 'string' property
4364 regex: /\b([\d]+(\.[\d]+)?|0x[a-f0-9]+)\b/gi,
4365 css: 'value' property
4368 css: 'color3' property
4371 css: 'keyword' property
4374 css: 'variable' property
4377 css: 'color1' property
4380 css: 'comments' property
4383 css: 'comments' property
4386 css: 'comments' property
4389 css: 'comments' property
4398 for (i = 0; i <= length - 1; i++) {
4401 css: 'comments' property
4405 css: 'comments' property
4432 css: 'comments' property
4435 css: 'comments' property
4438 css: 'preprocessor' property
4441 css: 'string' property
4444 css: 'string' property
4446 regex: /\b([\d]+(\.[\d]+)?f?|[\d]+l?|0x[a-f0-9]+)\b/gi,
4447 css: 'value' property
4450 css: 'color1' property
4453 css: 'color2' property
4456 css: 'keyword' property
4480 // http://patrickwebster.blogspot.com/2009/04/javafx-brush-for-syntaxhighlighter.html
4483 … not null on or override package postinit ' + 'protected public public-init public-read replace re…
4487 css: 'comments' property
4490 css: 'comments' property
4493 css: 'string' property
4496 css: 'string' property
4498 regex: /(-?\.?)(\b(\d*\.?\d+|\d+\.?\d*)(e[+-]?\d+)?|0x[a-f\d]+)\b\.?/gi,
4499 css: 'color2' property
4502 css: 'variable' property
4505 css: 'keyword' property
4528 css: 'string' property
4531 css: 'string' property
4534 css: 'comments' property
4537 css: 'comments' property
4540 css: 'preprocessor' property
4543 css: 'keyword' property
4563 // Contributed by David Simmons-Duffin and Marty Kube
4579 css: 'string' property
4582 css: 'comments' property
4585 css: 'preprocessor' property
4587 regex: /-?\w+(?=\s*=(>|>))/g,
4588 css: 'string' property
4594 css: 'string' property
4597 css: 'string' property
4600 css: 'string' property
4603 css: 'string' property
4606 css: 'string' property
4609 css: 'string' property
4612 css: 'string' property
4614 regex: /(?:&|[$@%*]|\$#)\$?[a-zA-Z_](\w+|::)*/g,
4615 css: 'variable' property
4618 css: 'comments' property
4621 css: 'comments' property
4624 css: 'functions' property
4627 css: 'keyword' property
4659 …call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been …
4684 …css: 'comments' }, { regex: _syntaxhighlighterRegex.commonRegExp.multiLineCComments, css: 'comment… property
4729 …// I can't find a way to match the comment based help in multi-line comments, because SH won't hig…
4734 css: 'preprocessor help bold' property
4737 css: 'comments' property
4740 css: 'comments here' property
4743 css: 'script string here' property
4746 css: 'script string single here' property
4749 css: 'string' property
4752 css: 'string single' property
4754 regex: new RegExp('[\\$|@|@@](?:(?:global|script|private|env):)?[A-Z0-9_]+', 'gi'),
4755 css: 'variable' property
4757 … regex: new RegExp('(?:\\b' + verbs.replace(/ /g, '\\b|\\b') + ')-[a-zA-Z_][a-zA-Z0-9_]*', 'gmi'),
4758 css: 'functions' property
4761 css: 'keyword' property
4763 regex: new RegExp('-' + this.getKeywords(operators), 'gmi'),
4764 css: 'operator value' property
4766 regex: new RegExp('\\[[A-Z_\\[][A-Z0-9_. `,\\[\\]]*\\]', 'gi'),
4767 css: 'constants' property
4769 regex: new RegExp('\\s+-(?!' + this.getKeywords(operators) + ')[a-zA-Z_][a-zA-Z0-9_]*', 'gmi'),
4770 css: 'color1' property
4798 css: 'comments' property
4801 css: 'decorator' property
4804 css: 'comments' property
4807 css: 'string' property
4810 css: 'string' property
4812 regex: /\+|\-|\*|\/|\%|=|==/gm,
4813 css: 'keyword' property
4816 css: 'value' property
4819 css: 'functions' property
4822 css: 'keyword' property
4825 css: 'color1' property
4853 css: 'comments' property
4856 css: 'string' property
4859 css: 'string' property
4861 regex: /\b[A-Z0-9_]+\b/g,
4862 css: 'constants' property
4864 regex: /:[a-z][A-Za-z0-9_]*/g,
4865 css: 'color2' property
4868 css: 'variable bold' property
4871 css: 'keyword' property
4874 css: 'color1' property
4895 return '\\b([a-z_]|)' + str.replace(/ /g, '(?=:)\\b|\\b([a-z_\\*]|\\*|)') + '(?=:)\\b';
4899 return '\\b' + str.replace(/ /g, '(?!-)(?!:)\\b|\\b()') + '\:\\b';
4906 …-attachment background-color background-image background-position ' + 'background-repeat backgroun…
4908 …-override black blink block blue bold bolder ' + 'both bottom braille capitalize caption center ce…
4910 …var fonts = '[mM]onospace [tT]ahoma [vV]erdana [aA]rial [hH]elvetica [sS]ans-serif [sS]erif [cC]ou…
4919 css: 'comments' property
4922 css: 'comments' property
4925 css: 'string' property
4928 css: 'string' property
4930 regex: /\#[a-fA-F0-9]{3,6}/g,
4931 css: 'value' property
4933 regex: /\b(-?\d+)(\.\d+)?(px|em|rem|pt|\:|\%|)\b/g,
4934 css: 'value' property
4936 regex: /\$[\w-]+/g,
4937 css: 'variable' property
4940 css: 'color3' property
4943 css: 'preprocessor' property
4946 css: 'keyword' property
4949 css: 'value' property
4952 css: 'color1' property
4978 css: 'comments' property
4981 css: 'comments' property
4984 css: 'string' property
4987 css: 'string' property
4990 css: 'string' property
4992 regex: /0x[a-f0-9]+|\d+(\.\d+)?/gi,
4993 css: 'value' property
4996 css: 'keyword' property
4999 css: 'keyword' property
5019 …l declare default delete desc distinct double drop ' + 'dynamic else end end-exec escape except ex…
5024 regex: /--(.*)$/gm,
5025 css: 'comments' property
5028 css: 'comments' property
5031 css: 'string' property
5034 css: 'string' property
5037 css: 'color2' property
5040 css: 'color1' property
5043 css: 'keyword' property
5063 // http://natecook.com/code/swift-syntax-highlighting
5076 while (pos < str.length - 1) {
5091 level--;
5093 …esult.push(new Match(str.substring(matchStart, pos + 2), matchStart + match.index, regexInfo.css));
5112 while (pos < str.length - 1) {
5115 …esult.push(new Match(str.substring(matchStart, pos + 2), matchStart + match.index, regexInfo.css));
5126 level--;
5135 …lt.push(new Match(str.substring(matchStart, str.length), matchStart + match.index, regexInfo.css));
5141 …// "Swift-native types" are all the protocols, classes, structs, enums, funcs, vars, and typealias…
5151 regex: new RegExp('\&[a-z]+;', 'gi'),
5152 css: 'plain' property
5155 css: 'comments' property
5158 css: 'comments', property
5162 css: 'string', property
5165 …regex: new RegExp('\\b([\\d_]+(\\.[\\de_]+)?|0x[a-f0-9_]+(\\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\\b'…
5166 css: 'value' property
5169 css: 'keyword' property
5172 css: 'color1' property
5175 css: 'color2' property
5177 regex: new RegExp('\\b([a-zA-Z_][a-zA-Z0-9_]*)\\b', 'gi'),
5178 css: 'variable' property
5199 css: 'plain bold italic' property
5202 css: 'keyword' property
5205 css: 'color3 bold' property
5208 css: 'variable bold' property
5211 css: 'comments bold' property
5214 css: 'comments' property
5217 css: 'string' property
5220 css: 'string' property
5238 …l declare get module never number public readonly set string'; // TypeScript-specific, everything …
5242 css: 'string' property
5245 css: 'string' property
5248 css: 'comments' property
5251 css: 'comments' property
5254 css: 'keyword' property
5278 css: 'comments' property
5281 css: 'string' property
5284 css: 'preprocessor' property
5287 css: 'keyword' property
5311 tag = XRegExp.exec(code, XRegExp('(<|<)[\\s\\/\\?!]*(?<name>[:\\w-\\.]+)', 'xg')),
5317 … regex = XRegExp('(?<name> [\\w:.-]+)' + '\\s*=\\s*' + '(?<value> ".*?"|\'.*?\'|\\w+)', 'xg');
5333 css: 'color2' property
5336 css: 'comments' property
5365 css: 'string' property
5368 css: 'color1' property
5371 css: 'functions' property
5374 css: 'keyword' property
5377 css: 'comments' property
5395 …P INSERT INT INTERVAL ' + 'JMP JMPC JMPCN ' + 'L LD LDN LE LEFT LEN LIMIT LINT LN LOG LREAL LT LWO…
5400 css: 'color2' property
5403 regex: /(DT|dt|date_and_time|DATE_AND_TIME)#\d{4}-\d{2}-\d{2}-\d{2}:\d{2}:\d{2}\.\d{2}/g,
5404 css: 'color2' property
5408 css: 'color2' property
5411 regex: /(D|d|DATE|date)#\d{4}-\d{2}-\d{2}/g,
5412 css: 'color2' property
5415 regex: /%[A-Z]{1,2}\d+(\.\d+)*/g,
5416 css: 'color2' property
5420 css: 'comments' property
5424 css: 'string' property
5428 css: 'value' property
5432 css: 'keyword' property
5455 css: 'comments' property
5459 css: 'comments' property
5463 css: 'preprocessor' property
5466 css: 'string' property
5469 css: 'string' property
5472 regex: /\b([\d]+(\.[\d]+)?f?|[\d]+l?|0x[a-f0-9]+)\b/gi,
5473 css: 'value' property
5477 css: 'color2' property
5479 // User-site targets
5481 css: 'color2' property
5485 css: 'color3' property
5488 css: 'keyword' property
5528 css: 'comments' }, { regex: /\$[\s\S]*?\$/gm, property
5529 css: 'string' }, { regex: /\\\w+/gm, // Command property
5530 css: 'keyword' }, { regex: /\{.*}/gm, // Parameter property
5531 css: 'color2' }, { regex: /\[.*]/gm, // Optional Parameter property
5532 …css: 'color3' }, { regex: new RegExp(this.getKeywords(specials), 'gm'), css: 'color3' }, { regex: … property
5548 …var functions = 'subst patsubst strip findstring filter filter-out sort dir notdir suffix basename…
5550 …this.regexList = [{ regex: regexLib.singleLinePerlComments, css: 'comments' }, // one line comments property
5551 { regex: regexLib.doubleQuotedString, css: 'string' }, // double quoted strings property
5552 { regex: regexLib.singleQuotedString, css: 'string' }, // single quoted strings property
5553 { regex: /\$\([^\@%<\?\^\+\*]\w+\)/gm, css: 'variable' }, // 変数 property
5554 { regex: /((\$\(?[\@%<\?\^\+\*](D\)|F\))*)|%|\$<)/gm, css: 'keyword' }, // 自動変数 property
5555 { regex: new RegExp(this.getKeywords(functions), 'gm'), css: 'functions' }, // テキスト変形関数 property
5556 { regex: new RegExp(this.getKeywords(constants), 'gm'), css: 'constants' // ビルトインターゲット名 property
5575 …css: 'comments' }, { regex: regexLib.multiLineCComments, css: 'color1' }, { regex: regexLib.double… property
5600 css: 'comments' property
5603 css: 'comments' property
5606 css: 'string' property
5609 css: 'string' property
5612 css: 'preprocessor' property
5615 css: 'preprocessor' property
5618 css: 'keyword bold' property
5621 css: 'functions bold' property
5624 css: 'keyword bold' property
5627 css: 'keyword bold' property
5630 css: 'keyword bold' property
5633 css: 'keyword bold' property
5636 css: 'keyword bold' property
5641 Brush.aliases = ['objective-c', 'obj-c', 'objc', 'oc'];
5666 this.regexList = [{ regex: regexLib.singleLinePerlComments, css: 'comments' }, // comment property
5667 { regex: regexLib.doubleQuotedString, css: 'string' }, // double quoted string property
5668 { regex: regexLib.singleQuotedString, css: 'string' }, // single quoted string property
5669 { regex: /^\s*([a-z0-9\._-])+\s*:/gmi, css: 'variable' }, // key property
5670 { regex: /\s?(\.)([a-z0-9\._-])+\s?:/gmi, css: 'comments' }, // section property
5671 { regex: /\s(@|:)([a-z0-9\._-])+\s*$/gmi, css: 'variable bold' }, // variable, reference property
5672 { regex: /\s+\d+\s?$/gm, css: 'color2 bold' }, // integers property
5673 { regex: /(\{|\}|\[|\]|,|~|:)/gm, css: 'constants' }, // inline hash and array, comma, null property
5674 { regex: /^\s+(-)+/gm, css: 'string bold' }, // array list entry property
5675 { regex: /^---/gm, css: 'string bold' }, // category property
5676 { regex: new RegExp(this.getKeywords(constants), 'gmi'), css: 'constants' // constants property
5695 * domready (c) Dustin Diaz 2014 - License MIT
5732 return value.replace(/^([A-Z])/g, function (_, character) {
5734 }).replace(/([A-Z])/g, function (_, character) {
5735 return '-' + character.toLowerCase();
5759 …2.default; // Compatability layer to support V3 brushes. This file is only included when `--compat`