Lines Matching +full:lint +full:- +full:cpp
4 // it is generated from tools/node-lint-md-cli-rollup
48 var index = -1;
57 var index = -1;
148 var index = -1;
149 var input = slice$1.call(arguments, 0, -1);
150 var done = arguments[arguments.length - 1];
164 var pos = -1;
171 // Copy non-nully input into values.
204 throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
347 while (start > 0 && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(start - 1)) === -1) {
348 start -= 1;
349 if (this.position - start > (maxLength / 2 - 1)) {
359 … (end < this.buffer.length && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(end)) === -1) {
361 if (end - this.position > (maxLength / 2 - 1)) {
363 end -= 5;
371 common.repeat(' ', indent + this.position - start + head.length) + '^';
433 if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
449 if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
456 /*eslint-disable max-len*/
481 return exclude.indexOf(index) === -1;
512 …throw new exception('There is a non-scalar type in the implicit list of a schema. Implicit resolvi…
547 …ption('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');
551 …throw new exception('Specified list of YAML types (or a single Type object) contains a non-Type ob…
676 if (ch === '-' || ch === '+') {
742 // if !base60 - done;
746 return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
752 if (value.indexOf('_') !== -1) {
758 if (ch === '-' || ch === '+') {
759 if (ch === '-') sign = -1;
772 if (value.indexOf(':') !== -1) {
803 …binary: function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).s…
804 …octal: function (obj) { return obj >= 0 ? '0' + obj.toString(8) : '-0' + obj.toString(8).s…
806 /* eslint-disable max-len */
807 …hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() : '-0x' + o…
820 '^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +
823 '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' +
825 '|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*' +
827 '|[-+]?\\.(?:inf|Inf|INF)' +
837 data[data.length - 1] === '_') {
848 sign = value[0] === '-' ? -1 : 1;
851 if ('+-'.indexOf(value[0]) >= 0) {
881 var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
900 case 'lowercase': return '-.inf';
901 case 'uppercase': return '-.INF';
902 case 'camelcase': return '-.Inf';
905 return '-0.0';
910 // JS stringifier can build scientific format without dots: 5e-100,
911 // while YAML requres dot: 5.e-100. Fix it with simple hack
949 '^([0-9][0-9][0-9][0-9])' + // [1] year
950 '-([0-9][0-9])' + // [2] month
951 '-([0-9][0-9])$'); // [3] day
954 '^([0-9][0-9][0-9][0-9])' + // [1] year
955 '-([0-9][0-9]?)' + // [2] month
956 '-([0-9][0-9]?)' + // [3] day
958 '([0-9][0-9]?)' + // [4] hour
959 ':([0-9][0-9])' + // [5] minute
960 ':([0-9][0-9])' + // [6] second
961 '(?:\\.([0-9]*))?' + // [7] fraction
962 '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour
963 '(?::([0-9][0-9]))?))?$'); // [11] tz_minute
984 month = +(match[2]) - 1; // JS month starts with 0
999 while (fraction.length < 3) { // milli-seconds
1010 delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds
1011 if (match[9] === '-') delta = -delta;
1016 if (delta) date.setTime(date.getTime() - delta);
1042 /*eslint-disable no-bitwise*/
1055 // [ 64, 65, 66 ] -> [ padding, CR, LF ]
1203 if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
1317 /*eslint-disable no-undefined*/
1346 // `/foo/gim` - modifiers tail can be maximum 3 chars
1352 if (regexp[regexp.length - modifiers.length - 1] !== '/') return false;
1363 // `/foo/gim` - tail can be maximum 4 chars
1366 regexp = regexp.slice(1, regexp.length - modifiers.length - 1);
1400 // If not found - try to fallback to window.esprima. If not
1401 // found too - then fail to parse.
1460 /*eslint-disable no-new-func*/
1461 return new Function(params, source.slice(body[0] + 1, body[1] - 1));
1465 /*eslint-disable no-new-func*/
1496 /*eslint-disable max-len,no-use-before-define*/
1519 … = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\…
1522 var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
1523 var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.…
1555 return c - 0x30;
1558 /*eslint-disable no-bitwise*/
1562 return lc - 0x61 + 10;
1565 return -1;
1577 return c - 0x30;
1580 return -1;
1584 /* eslint-disable indent */
1609 // Encode UTF-16 surrogate pair
1610 // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF
1612 ((c - 0x010000) >> 10) + 0xD800,
1613 ((c - 0x010000) & 0x03FF) + 0xDC00
1662 …new mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStar…
1690 match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
1693 throwError(state, 'ill-formed argument of the YAML directive');
1723 throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');
1731 throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');
1754 throwError(state, 'the stream contains non-printable characters');
1888 if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
1903 if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&
1923 state.result += common.repeat('\n', count - 1);
1959 if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {
1983 preceding = state.input.charCodeAt(state.position - 1);
1997 skipSeparationSpace(state, false, -1);
2014 writeFoldedLines(state, state.line - _line);
2123 for (; hexLength > 0; hexLength--) {
2294 if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
2305 textIndent = nodeIndent + tmp - 1;
2366 // Lines starting with white space characters (more-indented lines) are not folded.
2372 // End of more-indented block.
2377 // Just one line break - perceive as the same line.
2383 // Several line breaks - perceive as different lines.
2426 if (ch !== 0x2D/* - */) {
2439 if (skipSeparationSpace(state, true, -1)) {
2450 skipSeparationSpace(state, true, -1);
2520 …incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line'…
2527 // Implicit notation case. Flow-style node as the key first, then ":", and the value.
2542 …throwError(state, 'a whitespace character is expected after the key-value separator within a block…
2595 skipSeparationSpace(state, true, -1);
2674 tagHandle = state.input.slice(_position - 1, state.position + 1);
2773 skipSeparationSpace(state, true, -1);
2781 indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent
2804 if (skipSeparationSpace(state, true, -1)) {
2812 indentStatus = -1;
2819 if (skipSeparationSpace(state, true, -1)) {
2828 indentStatus = -1;
2847 blockIndent = state.position - state.lineStart;
2892 // Implicit resolving is not allowed for non-scalar types, and '?'
2893 // non-specific tag is only assigned to plain scalars. So, it isn't
2945 skipSeparationSpace(state, true, -1);
2999 skipSeparationSpace(state, true, -1);
3002 state.input.charCodeAt(state.position) === 0x2D/* - */ &&
3003 state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&
3004 state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {
3006 skipSeparationSpace(state, true, -1);
3012 composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
3013 skipSeparationSpace(state, true, -1);
3017 throwWarning(state, 'non-ASCII line breaks are interpreted as content');
3026 skipSeparationSpace(state, true, -1);
3031 if (state.position < (state.length - 1)) {
3046 if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&
3047 input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {
3067 while (state.position < (state.length - 1)) {
3092 /*eslint-disable no-undefined*/
3127 /*eslint-disable no-use-before-define*/
3148 var CHAR_MINUS = 0x2D; /* - */
3228 return '\\' + handle + common.repeat('0', length - string.length) + string;
3236 this.flowLevel = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);
3258 next = -1,
3265 if (next === -1) {
3299 // [33] s-white ::= s-space | s-tab
3305 // From YAML 1.2: "any allowed characters known to be non-printable
3307 // Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029.
3317 // Uses a subset of nb-char - c-flow-indicator - ":" - "#"
3318 // where nb-char ::= c-printable - b-char - c-byte-order-mark.
3320 // - c-flow-indicator
3326 // - ":" - "#"
3333 // Uses a subset of ns-char - c-indicator
3334 // where ns-char = nb-char - s-white.
3336 && !isWhitespace(c) // - s-white
3337 // - (c-indicator ::=
3338 // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”
3375 // lineWidth = -1 => no limit.
3376 // Pre-conditions: str.length > 0.
3377 // Post-conditions:
3379 // STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).
3380 // STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).
3386 var shouldTrackWidth = lineWidth !== -1;
3387 var previousLineBreak = -1; // count the first line correctly
3389 && !isWhitespace(string.charCodeAt(string.length - 1));
3410 // Foldable line = too long, and not more-indented.
3411 (i - previousLineBreak - 1 > lineWidth &&
3422 (i - previousLineBreak - 1 > lineWidth &&
3427 // Also prefer folding a super-long line.
3446 // • No ending newline => unaffected; already using strip "-" chomping.
3455 DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) {
3459 var indent = state.indent * Math.max(1, level); // no 0-indent scalars
3467 var lineWidth = state.lineWidth === -1
3468 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
3473 || (state.flowLevel > -1 && level >= state.flowLevel);
3497 // Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.
3502 var clip = string[string.length - 1] === '\n';
3503 var keep = clip && (string[string.length - 2] === '\n' || string === '\n');
3504 var chomp = keep ? '+' : (clip ? '' : '-');
3511 return string[string.length - 1] === '\n' ? string.slice(0, -1) : string;
3515 // Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.
3518 // unless they're before or after a more-indented line, or at the very
3526 nextLF = nextLF !== -1 ? nextLF : string.length;
3552 // NB. More-indented lines *cannot* be folded, as that would add an extra \n.
3556 // Since a more-indented line adds a \n, breaks can't be followed by a space.
3557 var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.
3563 // Invariants: 0 <= start <= length-1.
3564 // 0 <= curr <= next <= max(0, length-2). curr - start <= width.
3566 // A match implies length >= 2, so curr and next are <= length-2.
3569 // maintain invariant: curr - start <= width
3570 if (next - start > width) {
3571 end = (curr > start) ? curr : next; // derive end <= length-2
3574 start = end + 1; // derive start <= length-1
3579 // By the invariants, start <= length-1, so there is something left over.
3580 // It is either the whole string or a part starting from non-whitespace.
3583 if (line.length - start > width && curr > start) {
3592 // Escapes a double-quoted string.
3605 result += encodeHex((char - 0xD800) * 0x400 + nextChar - 0xDC00 + 0x10000);
3651 _result += '-';
3653 _result += '- ';
3836 duplicate = duplicateIndex !== -1;
3862 var arrayLevel = (state.noArrayIndent && (level > 0)) ? level - 1 : level;
3912 if (index !== -1) {
3913 if (duplicatesIndexes.indexOf(index) === -1) {
3980 // Deprecated schema names from JS-YAML 2.0.x
3985 // Deprecated functions from JS-YAML 1.x.x
4179 ? txt.length - 1
4184 : errIdx - context;
4235 var column = index - offsets[line];
4250 … var nextOffset = line === this.offsets.length - 1 ? this.string.length : this.offsets[line + 1];
4251 return nextOffset - offset;
4269 // This regex comes from regex.coffee, and is inserted here by generate-index.js
4271 …-\uFFFF$\\'"~({]|[+\-!](?!=)|\.?\d))|[gmiyus]{1,6}\b(?![\u0080-\uFFFF$\\]|\s*(?:[+\-*%&|^<>!=?({]|…
4298 …-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u0…
4299 …-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0…
4702 var delta = max - min;
4710 h = (g - b) / delta;
4712 h = 2 + (b - r) / delta;
4714 h = 4 + (r - g) / delta;
4730 s = delta / (2 - max - min);
4747 var diff = v - Math.min(r, g, b);
4749 return (v - c) / 6 / diff + 1 / 2;
4761 h = bdif - gdif;
4763 h = (1 / 3) + rdif - bdif;
4765 h = (2 / 3) + gdif - rdif;
4770 h -= 1;
4788 b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
4802 k = Math.min(1 - r, 1 - g, 1 - b);
4803 c = (1 - r - k) / (1 - k) || 0;
4804 m = (1 - g - k) / (1 - k) || 0;
4805 y = (1 - b - k) / (1 - k) || 0;
4815 Math.pow(x[0] - y[0], 2) +
4816 Math.pow(x[1] - y[1], 2) +
4817 Math.pow(x[2] - y[2], 2)
4886 l = (116 * y) - 16;
4887 a = 500 * (x - y);
4888 b = 200 * (y - z);
4911 t2 = l + s - l * s;
4914 t1 = 2 * l - t2;
4918 t3 = h + 1 / 3 * -(i - 1);
4923 t3--;
4927 val = t1 + (t2 - t1) * 6 * t3;
4931 val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
4952 s *= (l <= 1) ? l : 2 - l;
4953 smin *= lmin <= 1 ? lmin : 2 - lmin;
4966 var f = h - Math.floor(h);
4967 var p = 255 * v * (1 - s);
4968 var q = 255 * v * (1 - (s * f));
4969 var t = 255 * v * (1 - (s * (1 - f)));
4997 l = (2 - s) * v;
4998 lmin = (2 - s) * vmin;
5000 sl /= (lmin <= 1) ? lmin : 2 - lmin;
5007 // http://dev.w3.org/csswg/css-color/#hwb-to-rgb
5025 v = 1 - bl;
5026 f = 6 * h - i;
5029 f = 1 - f;
5032 n = wh + f * (v - wh); // linear interpolation
5060 r = 1 - Math.min(1, c * (1 - k) + k);
5061 g = 1 - Math.min(1, m * (1 - k) + k);
5062 b = 1 - Math.min(1, y * (1 - k) + k);
5075 r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
5076 g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
5077 b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
5081 ? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055)
5085 ? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055)
5089 ? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055)
5115 l = (116 * y) - 16;
5116 a = 500 * (x - y);
5117 b = 200 * (y - z);
5132 z = y - b / 200;
5137 y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
5138 x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
5139 z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
5187 var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2]; // hsv -> ansi16 optimization
5229 return Math.round(((r - 8) / 247) * 24) + 232;
5265 var c = (args - 232) * 10 + 8;
5269 args -= 16;
5289 var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
5316 var chroma = (max - min);
5321 grayscale = min / (1 - chroma);
5330 hue = ((g - b) / chroma) % 6;
5333 hue = 2 + (b - r) / chroma;
5335 hue = 4 + (r - g) / chroma + 4;
5353 c = 2.0 * s * (1.0 - l);
5357 f = (l - 0.5 * c) / (1.0 - c);
5371 f = (v - c) / (1 - c);
5389 var w = 1 - v;
5407 mg = (1.0 - c) * g;
5420 var v = c + g * (1.0 - c);
5434 var l = g * (1.0 - c) + 0.5 * c;
5441 s = c / (2 * (1 - l));
5450 var v = c + g * (1.0 - c);
5451 return [hcg[0], (v - c) * 100, (1 - v) * 100];
5457 var v = 1 - b;
5458 var c = v - w;
5462 g = (v - c) / (1 - c);
5538 // https://jsperf.com/object-keys-vs-for-in-with-closure/3
5543 // http://jsperf.com/1-vs-infinity
5544 // micro-opt, but this is simple.
5545 distance: -1,
5553 // https://en.wikipedia.org/wiki/Breadth-first_search
5556 var queue = [fromModel]; // unshift -> queue -> pop
5568 if (node.distance === -1) {
5865 const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
5867 const terminatorPos = argv.indexOf('--');
5868 return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
5874 if (hasFlag('no-color') ||
5875 hasFlag('no-colors') ||
5950 return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
5969 if (/-256(color)?$/i.test(env.TERM)) {
5999 const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([…
6002 const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
6095 // eslint-disable-next-line max-params
6139 // `color-convert` models to exclude from the Chalk API due to conflicts and such
6280 builder.__proto__ = proto; // eslint-disable-line no-proto
6315 // Replace any instances already present with a re-opening code
6343 parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
6352 module.exports = Chalk(); // eslint-disable-line new-cap
6394 const JSX_TAG = /^[a-z][\w-]*$/i;
6398 const [offset, text] = match.slice(-2);
6406 …if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.substr(offset - 2, 2) == "</"))…
6500 line: -1
6511 let start = Math.max(startLine - (linesAbove + 1), 0);
6514 if (startLine === -1) {
6518 if (endLine === -1) {
6522 const lineDiff = endLine - startLine;
6532 const sourceLength = source[lineNumber - 1].length;
6533 markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
6537 const sourceLength = source[lineNumber - i].length;
6549 markerLines[startLine] = [startColumn, endColumn - startColumn];
6580 const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
6589 const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
6618 …const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `…
6709 * - `long` verbose formatting [false]
6713 * @throws {Error} throw an error if val is not a non-empty string or a number
6727 'val is not a non-empty string or a valid number. val=' +
6745 …var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours…
6889 * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
6903 hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
6931 const ms = curr - (prevTime || curr);
6946 args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
6959 index--;
6964 // Apply env-specific formatting (colors, etc.)
6980 // env-specific initialization logic for debug instances
6992 if (index !== -1) {
7030 if (namespaces[0] === '-') {
7052 ...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
7066 if (name[name.length - 1] === '*') {
7097 .substring(2, regexp.toString().length - 2)
7123 /* eslint-env browser */
7220 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
7227 // eslint-disable-next-line complexity
7242 // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
7247 // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
7279 args[0].replace(/%[a-zA-Z%]/g, match => {
7296 * No-op when `console.log` is not a "function".
7323 // XXX (@Qix-) should we be logging these?
7339 // XXX (@Qix-) should we be logging these?
7368 // XXX (@Qix-) should we be logging these?
7397 const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
7399 const terminatorPosition = argv.indexOf('--');
7400 return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
7406 if (hasFlag$1('no-color') ||
7407 hasFlag$1('no-colors') ||
7489 return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env$1.TEAMCITY_VERSION) ? 1 : 0;
7512 if (/-256(color)?$/i.test(env$1.TERM)) {
7565 // eslint-disable-next-line import/no-extraneous-dependencies
7649 // Swallow - we only care if `supports-color` is available; it doesn't have to be.
7661 // Camel-case
7665 .replace(/_([a-z])/g, (_, k) => {
7876 throw new Error(`Alias refers to invalid key: ${key} -> ${alias}`)
8093 activeCount--;
8220 // eslint-disable-next-line no-constant-condition
8332 if (key.length > 2 && key.slice(-2) === '[]') {
8333 key = key.substring(0, key.length - 2);
8350 // {a:{y:1},"a.b":{x:2}} --> {a:{y:1,b:{x:2}}}
8381 return (val.charAt(0) === '"' && val.slice(-1) === '"') ||
8382 (val.charAt(0) === "'" && val.slice(-1) === "'")
8401 val = val.substr(1, val.length - 2);
8405 // walk the val to find the first not-escaped ; character
8411 if ('\\;#'.indexOf(c) !== -1) {
8417 } else if (';#'.indexOf(c) !== -1) {
8464 .replace(/(?!^)_/g, '-');
8526 // c:\node\node.exe --> prefix=c:\node\
8529 // /usr/local/bin/node --> prefix=/usr/local
8572 // See: <https://github.com/eush77/npm-prefix/blob/master/index.js>
8604 // <https://docs.npmjs.com/files/folders#node-modules>
8605 // <https://github.com/sindresorhus/resolve-from>
8610 // If a prefix is given and $name is not a path, `$prefix-$name` is also
8611 // searched (preferring these over non-prefixed modules).
8635 // Non-path.
8643 prefix = prefix.charAt(prefix.length - 1) === '-' ? prefix : prefix + '-';
8652 if (slash !== -1) {
8667 index = -1;
8832 var debug = src('unified-engine:find-up');
8929 var index = -1;
8962 /* istanbul ignore if - Hard to test. */
8985 /* istanbul ignore else - maybe used in the future. */
9004 while (index--) {
9030 var debug = src('unified-engine:configuration');
9201 var index = -1;
9291 var index = -1;
9319 // A simple implementation of make-array
9339 ? Symbol.for('node-ignore')
9341 : 'node-ignore';
9346 const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
9366 // -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
9374 // (a\ ) -> (a )
9375 // (a ) -> (a)
9376 // (a \ ) -> (a )
9393 // > - the backslash \,
9394 // > - the caret ^,
9395 // > - the dollar sign $,
9396 // > - the period or dot .,
9397 // > - the vertical bar or pipe symbol |,
9398 // > - the question mark ?,
9399 // > - the asterisk or star *,
9400 // > - the plus sign +,
9401 // > - the opening parenthesis (,
9402 // > - the closing parenthesis ),
9403 // > - and the opening square bracket [,
9404 // > - the opening curly brace {,
9430 // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
9451 // '**/foo' <-> 'foo'
9462 // https://git-scm.com/docs/gitignore
9463 // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
9464 // which re-fixes #24, #38
9539 // 'abc.*/' -> go
9540 // 'abc.*' -> skip this rule
9744 // -------- | ------- | ------- | ------- | --------
9748 // - SKIP: always skip
9749 // - TEST: always test
9750 // - TESTIF: only test if checkUnignored
9751 // - X: that never happen
9823 // > It is not possible to re-include a file if a parent directory of
9862 // --------------------------------------------------------------
9872 /* eslint no-control-regex: "off" */
9874 || /["<>|\u0000-\u001F]+/u.test(str)
9880 // 'C:\\foo' <- 'C:\\foo' has been converted to 'C:/'
9882 const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
9976 // JavaScript implementation of realpath, ported from node pre-v6
10031 var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
10272 var ok = /^v[0-5]\./.test(version);
10449 p[p.length-1] += '{' + body + '}';
10452 p[p.length-1] += postParts.shift();
10482 return /^-?0\d/.test(el);
10498 var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
10499 var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
10533 // no need to expand pre, since it is guaranteed to be free of brace-sets
10551 incr *= -1;
10567 var need = width - c.length;
10571 c = '-' + z + c.slice(1);
10632 // "abc" -> { a:true, b:true, c:true }
10762 // step 3: now we have a set, so turn each one into a series of path-portion
10773 // glob --> regexps
10782 return s.indexOf(false) === -1
10811 // a{b,c}d -> abd acd
10812 // a{b,}c -> abc ac
10813 // a{0..3}d -> a0d a1d a2d a3d
10814 // a{b,c{d,e}f}g -> abg acdfg acefg
10815 // a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
10818 // a{2..}b -> a{2..}b
10819 // a{b}c -> a{b}c
10883 var reClassStart = -1;
10884 var classStart = -1;
10895 // we had some state-tracking character
10930 // Should already be path-split by now.
10945 this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c);
10981 start: i - 1,
11023 // swallow any state-tracking char before the [
11041 // first in the list. -- POSIX.2 2.8.3.2
11049 // "[z-a]" is valid, equivalent to "\[z-a\]"
11052 // an invalid re. if so, re-walk the contents of the
11053 // would-be class to re-translate any characters that
11054 // were passed through as-is
11098 // this is a huge pita. We now have to re-walk
11099 // the contents of the would-be class to re-translate
11100 // any characters that were passed through as-is
11110 // and escape any | chars that were passed through as-is for the regexp.
11111 // Go through and escape them, taking care not to double-escape any
11162 for (var n = negativeLists.length - 1; n > -1; n--) {
11166 var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
11167 var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
11175 var openParensBefore = nlBefore.split('(').length - 1;
11206 // skip the regexp for non-magical patterns
11219 // the string, which is of course impossible, except in multi-line
11295 // short-circuit in the case of busted things.
11321 // Find the basename of the path by looking for the last non-empty segment
11324 for (i = f.length - 1; i >= 0; i--) {
11393 // - a matches a
11394 // - doublestar
11395 // - matchOne(b/x/y/z/c, b/**/c)
11396 // - b matches b
11397 // - doublestar
11398 // - matchOne(x/y/z/c, c) -> no
11399 // - matchOne(y/z/c, c) -> no
11400 // - matchOne(z/c, c) -> no
11401 // - matchOne(c, c) yes, hit
11457 // non-magic patterns just have to match exactly
11501 var emptyFileEnd = (fi === fl - 1) && (file[fi] === '');
11515 return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
11566 var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
11622 if (pattern.slice(-3) === '/**') {
11637 // base-matching: just use globstar for that.
11638 if (options.matchBase && -1 === pattern.indexOf("/")) {
11765 var slash = p.slice(-1) === '/';
11770 m = m.slice(0, -1);
11803 // Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's conten…
11844 'See: https://github.com/isaacs/node-glob/issues/167')
11855 'See: https://github.com/isaacs/node-glob/issues/167')
11916 // pattern *starts* with some non-trivial item.
12002 if (prefix.slice(-1) !== '/')
12017 // now test all matched entries as stand-ins for that part
12063 // just proceed as if this is a non-globstar situation
12130 // mark and cache dir-ness
12137 case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
12238 var needDir = f.slice(-1) === '/';
12328 var cb = args[args.length-1];
12415 // de-zalgo, just in case, but don't call again.
12439 // 3. Store matches per-set, then uniq them
12471 // we ever care about is existence and directory-ness, we can just keep
12513 while (i--) {
12597 --self._processing;
12637 if (--n === 0)
12668 if (--n === 0) {
12713 this._processing--;
12751 // pattern *starts* with some non-trivial item.
12859 // now test all matched entries as stand-ins for that part
12918 // just proceed as if this is a non-globstar situation
13006 case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
13131 var needDir = f.slice(-1) === '/';
13192 var needDir = f.slice(-1) === '/';
13195 if (abs.slice(-1) === '/' && stat && !stat.isDirectory())
13263 return point(pos.start) + '-' + point(pos.end)
13350 if (index === -1) {
13427 index = -1;
13438 // Set non-path related properties.
13440 if (order.indexOf(prop) === -1) {
13447 return this.history[this.history.length - 1]
13492 if (ext.indexOf('.', 1) !== -1) {
13520 if (part.indexOf(path$1.sep) !== -1) {
13741 /* istanbul ignore if - glob errors are unusual.
13785 /* istanbul ignore if - Glob errors are unusual. */
13790 /* istanbul ignore if - Glob errors are unusual. */
13805 /* istanbul ignore if - `search` currently does not give errors. */
13872 extensions.indexOf(ext) === -1
13900 /* istanbul ignore if - Should not happen often: the directory is `stat`ed
13922 /* istanbul ignore else - Always given. */
13973 actual = -1;
14008 // Find files from the file-system.
14062 return left.path < right.path ? -1 : 1
14075 return toString$1.call(input).slice(8, -1) === 'ArrayBuffer'
14081 var maxLength = obj.byteLength - byteOffset;
14150 // Class returns internal [[Class]] property, used to avoid cross-frame instanceof issues:
14185 …p://blogs.msdn.com/b/ie/archive/2010/09/07/transitioning-existing-code-to-the-es5-getter-setter-ap…
14200 if (!o === Object(o)) throw new TypeError("Object.defineProperty called on non-object");
14209 if (o !== Object(o)) throw new TypeError("Object.getOwnPropertyNames called on non-object");
14242 // pack<Type>() - take a number (interpreted as Type), output a byte array
14243 // unpack<Type>() - take a byte array, output a Type-like number
14245 function as_signed(value, bits) { var s = 32 - bits; return (value << s) >> s; }
14246 function as_unsigned(value, bits) { var s = 32 - bits; return (value << s) >>> s; }
14270 var bias = (1 << (ebits - 1)) - 1,
14274 var w = floor(n), f = n - w;
14285 // http://dev.w3.org/2006/webapi/WebIDL/#es-type-mapping
14286 e = (1 << ebits) - 1; f = pow(2, fbits - 1); s = 0;
14287 } else if (v === Infinity || v === -Infinity) {
14288 e = (1 << ebits) - 1; f = 0; s = (v < 0) ? 1 : 0;
14290 e = 0; f = 0; s = (1 / v === -Infinity) ? 1 : 0;
14295 if (v >= pow(2, 1 - bias)) {
14304 e = (1 << ebits) - 1;
14309 f = f - pow(2, fbits);
14314 f = roundToEven(v / pow(2, 1 - bias - fbits));
14320 for (i = fbits; i; i -= 1) { bits.push(f % 2 ? 1 : 0); f = floor(f / 2); }
14321 for (i = ebits; i; i -= 1) { bits.push(e % 2 ? 1 : 0); e = floor(e / 2); }
14341 for (i = bytes.length; i; i -= 1) {
14342 b = bytes[i - 1];
14343 for (j = 8; j; j -= 1) {
14351 bias = (1 << (ebits - 1)) - 1;
14352 s = parseInt(str.substring(0, 1), 2) ? -1 : 1;
14357 if (e === (1 << ebits) - 1) {
14361 return s * pow(2, e - bias) * (1 + f / pow(2, fbits));
14364 return s * pow(2, -(bias - 1)) * (f / pow(2, fbits));
14366 return s < 0 ? -0 : 0;
14477 this.byteLength = this.buffer.byteLength - this.byteOffset;
14614 var len = end - start;
14681 this.byteLength = this.buffer.byteLength - this.byteOffset;
14919 var debug$1 = src('unified-engine:file-set-pipeline:stdin');
14934 … 'Do not pass both `--file-path` and real files.\nDid you mean to pass stdin instead of files?'
15021 if (!duplicate && self.plugins.indexOf(plugin) !== -1) {
15039 // Only runs `file-pipeline` on files which have not `failed` before addition.
15051 if (self.origins.indexOf(origin) !== -1) {
15085 var debug$2 = src('unified-engine:file-pipeline:read');
15198 var debug$3 = src('unified-engine:file-pipeline:configure');
15233 index = -1;
15256 /* istanbul ignore next - Should not happen anymore! */
15265 var debug$4 = src('unified-engine:file-pipeline:parse');
15310 var debug$5 = src('unified-engine:file-pipeline:transform');
15331 var debug$6 = src('unified-engine:file-pipeline:queue');
15337 // When the last file gets here, run the file-set pipeline and flush the queue.
15394 /* istanbul ignore next - browser */
15416 '(?:[0-9]{1,3})?(?:(?:;[0-9]{0,3})*)?[A-M|f-m]' +
15418 '\\u001b[A-M]',
15422 // Standard keys defined by unist: https://github.com/syntax-tree/unist.
15440 index = -1;
15457 index = -1;
15470 if (index === length - 1) {
15512 values.push(positions.join('-'));
15516 values.push(offsets.join('-'));
15558 ignore$2.indexOf(key) !== -1 ||
15590 var debug$7 = src('unified-engine:file-pipeline:stringify');
15644 var debug$8 = src('unified-engine:file-pipeline:copy');
15675 output.charAt(output.length - 1) === path$1.sep
15713 var debug$9 = src('unified-engine:file-pipeline:stdout');
15734 var debug$a = src('unified-engine:file-pipeline:file-system');
15742 // Write a virtual file to the file-system.
15748 debug$a('Ignoring writing to file-system');
15801 if (index === -1) {
15803 index = messages.length - 1;
15853 /* istanbul ignore next - Does not occur as all failures in `filePipeLine`
15869 const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
15871 const terminatorPos = argv.indexOf('--');
15872 return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
15878 if (hasFlag$2('no-color') ||
15879 hasFlag$2('no-colors') ||
15965 return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env$2.TEAMCITY_VERSION) ? 1 : 0;
15984 if (/-256(color)?$/i.test(env$2.TERM)) {
16012 '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
16013 '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'
16021 /* eslint-disable yoda */
16033 codePoint === 0x2329 || // LEFT-POINTING ANGLE BRACKET
16034 codePoint === 0x232A || // RIGHT-POINTING ANGLE BRACKET
16041 // Hangul Jamo Extended-A
16074 …-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])…
16118 * repeat-string <https://github.com/jonschlinkert/repeat-string>
16120 * Copyright (c) 2014-2015, Jon Schlinkert.
16144 * var repeat = require('repeat-string');
16204 severities[b.fatal] - severities[a.fatal] ||
16213 return (a[property] || 0) - (b[property] || 0)
16231 // `log-symbols` without chalk:
16232 /* istanbul ignore next - Windows. */
16235 // Match trailing white-space.
16290 var index = -1;
16310 var index = -1;
16335 if (rows.length !== 0 && rows[rows.length - 1].type !== 'header') {
16349 offset = -1;
16392 // eslint-disable-next-line complexity
16398 var index = -1;
16454 if (position !== -1) {
16512 var index = -1;
16531 return stringWidth_1(length === -1 ? value : value.slice(0, length))
16536 return repeatString(' ', minimum - realLength(value)) + value
16541 return value + repeatString(' ', minimum - realLength(value))
16550 var prefix = 'vfile-reporter';
16575 if (diagnostics.charAt(diagnostics.length - 1) !== '\n') {
16619 // <https://github.com/AtomLinter/linter-markdown/pull/85>.
16898 /* eslint-disable no-mixed-operators */
16957 const delta = max - min;
16964 h = (g - b) / delta;
16966 h = 2 + (b - r) / delta;
16968 h = 4 + (r - g) / delta;
16984 s = delta / (2 - max - min);
17001 const diff = v - Math.min(r, g, b);
17003 return (v - c) / 6 / diff + 1 / 2;
17016 h = bdif - gdif;
17018 h = (1 / 3) + rdif - bdif;
17020 h = (2 / 3) + gdif - rdif;
17026 h -= 1;
17044 b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
17054 const k = Math.min(1 - r, 1 - g, 1 - b);
17055 const c = (1 - r - k) / (1 - k) || 0;
17056 const m = (1 - g - k) / (1 - k) || 0;
17057 const y = (1 - b - k) / (1 - k) || 0;
17067 ((x[0] - y[0]) ** 2) +
17068 ((x[1] - y[1]) ** 2) +
17069 ((x[2] - y[2]) ** 2)
17133 const l = (116 * y) - 16;
17134 const a = 500 * (x - y);
17135 const b = 200 * (y - z);
17156 t2 = l + s - l * s;
17159 const t1 = 2 * l - t2;
17163 t3 = h + 1 / 3 * -(i - 1);
17169 t3--;
17173 val = t1 + (t2 - t1) * 6 * t3;
17177 val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
17196 s *= (l <= 1) ? l : 2 - l;
17197 smin *= lmin <= 1 ? lmin : 2 - lmin;
17210 const f = h - Math.floor(h);
17211 const p = 255 * v * (1 - s);
17212 const q = 255 * v * (1 - (s * f));
17213 const t = 255 * v * (1 - (s * (1 - f)));
17240 l = (2 - s) * v;
17241 const lmin = (2 - s) * vmin;
17243 sl /= (lmin <= 1) ? lmin : 2 - lmin;
17250 // http://dev.w3.org/csswg/css-color/#hwb-to-rgb
17265 const v = 1 - bl;
17266 f = 6 * h - i;
17269 f = 1 - f;
17272 const n = wh + f * (v - wh); // Linear interpolation
17277 /* eslint-disable max-statements-per-line,no-multi-spaces */
17288 /* eslint-enable max-statements-per-line,no-multi-spaces */
17299 const r = 1 - Math.min(1, c * (1 - k) + k);
17300 const g = 1 - Math.min(1, m * (1 - k) + k);
17301 const b = 1 - Math.min(1, y * (1 - k) + k);
17314 r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
17315 g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
17316 b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
17320 ? ((1.055 * (r ** (1.0 / 2.4))) - 0.055)
17324 ? ((1.055 * (g ** (1.0 / 2.4))) - 0.055)
17328 ? ((1.055 * (b ** (1.0 / 2.4))) - 0.055)
17351 const l = (116 * y) - 16;
17352 const a = 500 * (x - y);
17353 const b = 200 * (y - z);
17368 z = y - b / 200;
17373 y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
17374 x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
17375 z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
17416 …let value = saturation === null ? convert$1.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimi…
17458 return Math.round(((r - 8) / 247) * 24) + 232;
17494 const c = (args - 232) * 10 + 8;
17498 args -= 16;
17518 const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
17545 const chroma = (max - min);
17550 grayscale = min / (1 - chroma);
17559 hue = ((g - b) / chroma) % 6;
17562 hue = 2 + (b - r) / chroma;
17564 hue = 4 + (r - g) / chroma;
17577 const c = l < 0.5 ? (2.0 * s * l) : (2.0 * s * (1.0 - l));
17581 f = (l - 0.5 * c) / (1.0 - c);
17595 f = (v - c) / (1 - c);
17613 const w = 1 - v;
17616 /* eslint-disable max-statements-per-line */
17631 /* eslint-enable max-statements-per-line */
17633 mg = (1.0 - c) * g;
17646 const v = c + g * (1.0 - c);
17660 const l = g * (1.0 - c) + 0.5 * c;
17667 s = c / (2 * (1 - l));
17676 const v = c + g * (1.0 - c);
17677 return [hcg[0], (v - c) * 100, (1 - v) * 100];
17683 const v = 1 - b;
17684 const c = v - w;
17688 g = (v - c) / (1 - c);
17750 // https://jsperf.com/object-keys-vs-for-in-with-closure/3
17755 // http://jsperf.com/1-vs-infinity
17756 // micro-opt, but this is simple.
17757 distance: -1,
17765 // https://en.wikipedia.org/wiki/Breadth-first_search
17768 const queue = [fromModel]; // Unshift -> queue -> pop
17780 if (node.distance === -1) {
17949 /** @type {typeof import('color-convert')} */
18078 if (index === -1) {
18086 returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
18089 } while (index !== -1);
18099 const gotCR = string[index - 1] === '\r';
18100 …returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ?…
18103 } while (index !== -1);
18114 const TEMPLATE_REGEX$1 = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\(…
18117 const ESCAPE_REGEX$1 = /\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.)|([^\\])/gi;
18141 return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
18216 // eslint-disable-next-line max-params
18383 // eslint-disable-next-line no-implicit-coercion
18389 builder.__proto__ = proto$3; // eslint-disable-line no-proto
18410 if (string.indexOf('\u001B') !== -1) {
18412 // Replace any instances already present with a re-opening code
18425 if (lfIndex !== -1) {
18447 String(arguments_[i - 1]).replace(/[{}\\]/g, '\\$&'),
18461 const chalk$1 = Chalk(); // eslint-disable-line new-cap
18463 chalk$1.stderr = Chalk({level: stderrColor ? stderrColor.level : 0}); // eslint-disable-line new-cap
18546 alnum: 'a-zA-Z0-9',
18547 alpha: 'a-zA-Z',
18548 ascii: '\\x00-\\x7F',
18550 cntrl: '\\x00-\\x1F\\x7F',
18551 digit: '0-9',
18552 graph: '\\x21-\\x7E',
18553 lower: 'a-z',
18554 print: '\\x20-\\x7E ',
18555 punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
18557 upper: 'A-Z',
18558 word: 'A-Za-z0-9_',
18559 xdigit: 'A-Fa-f0-9'
18569 REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
18571 REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
18596 // Non-alphabetic chars.
18612 CHAR_HYPHEN_MINUS: 45, /* - */
18697 if (idx === -1) return input;
18698 if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
18764 * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
18781 const length = input.length - 1;
18788 let index = -1;
18866 braces--;
19023 lastIndex -= start;
19037 if (isPathSeparator(base.charCodeAt(base.length - 1))) {
19038 base = base.slice(0, -1);
19100 tokens[tokens.length - 1].value = value;
19101 depth(tokens[tokens.length - 1]);
19102 state.maxDepth += tokens[tokens.length - 1].depth;
19137 const value = `[${args.join('-')}]`;
19140 /* eslint-disable-next-line no-new */
19154 return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
19223 index: -1,
19252 const eos = () => state.index === len - 1;
19289 state[type]--;
19307 state.output = state.output.slice(0, -prev.output.length);
19316 extglobs[extglobs.length - 1].inner += tok.value;
19424 * Tokenize input until we reach end-of-string
19509 if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
19565 const extglob = extglobs[extglobs.length - 1];
19627 state.output = state.output.slice(0, -prev.value.length);
19664 const brace = braces[braces.length - 1];
19677 for (let i = arr.length - 1; i >= 0; i--) {
19714 extglobs[extglobs.length - 1].conditions++;
19727 const brace = braces[braces.length - 1];
19728 if (brace && stack[stack.length - 1] === 'braces') {
19766 const brace = braces[braces.length - 1];
19959 state.output = state.output.slice(0, -(prior.output + prev.output).length);
19974 state.output = state.output.slice(0, -(prior.output + prev.output).length);
20002 state.output = state.output.slice(0, -prev.output.length);
20229 throw new TypeError('Expected pattern to be a non-empty string');
20455 throw new TypeError('Expected a non-empty string');
20589 /* eslint-disable no-unused-vars */
20592 /* eslint-enable no-unused-vars */
20656 batch--;
20661 batch--;
20767 if (type === 'both') type = FILE_DIR_TYPE; // backwards-compatibility
20798 * normalize-path <https://github.com/jonschlinkert/normalize-path>
20800 * Copyright (c) 2014-2018, Jon Schlinkert.
20827 if (stripTrailing !== false && segs[segs.length - 1] === '') {
20887 return returnIndex ? -1 : false;
20899 return returnIndex ? -1 : false;
20940 * is-extglob <https://github.com/jonschlinkert/is-extglob>
20942 * Copyright (c) 2014-2016, Jon Schlinkert.
20961 * is-glob <https://github.com/jonschlinkert/is-glob>
20963 * Copyright (c) 2014-2017, Jon Schlinkert.
20999 if (n !== -1) {
21073 return ((Number(max) - Number(min)) / Number(step)) >= limit;
21200 * is-number <https://github.com/jonschlinkert/is-number>
21202 * Copyright (c) 2014-present, Jon Schlinkert.
21208 return num - num === 0;
21247 if (Math.abs(a - b) === 1) {
21293 let onlyNegative = filterPatterns(neg, pos, '-', false) || [];
21295 let intersected = filterPatterns(neg, pos, '-?', true) || [];
21313 stop = countZeros(max + 1, zeros) - 1;
21318 stop = countZeros(max + 1, zeros) - 1;
21358 pattern += options.shorthand === true ? '\\d' : '[0-9]';
21429 return a > b ? 1 : b > a ? -1 : 0;
21437 return Number(String(min).slice(0, -len) + '9'.repeat(len));
21441 return integer - (integer % Math.pow(10, zeros));
21453 return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;
21457 return /^-?(0+)\d/.test(str);
21465 let diff = Math.abs(tok.maxLen - String(value).length);
21508 let index = -1;
21509 if (value[0] === '-') value = value.slice(1);
21524 let dash = input[0] === '-' ? '-' : '';
21526 input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'));
21535 let negative = input[0] === '-' ? '-' : '';
21538 maxLength--;
21541 return negative ? ('-' + input) : input;
21545 parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
21546 parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
21558 negatives = `-(${prefix}${parts.negatives.join('|')})`;
21583 return `[${start}-${stop}]`;
21650 a = descending ? a - step : a + step;
21686 a = descending ? a - step : a + step;
21911 // Non-alphabetic chars.
21928 CHAR_HYPHEN_MINUS: '-', /* - */
22021 block = stack[stack.length - 1];
22072 brackets--;
22102 block = stack[stack.length - 1];
22143 let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
22176 depth--;
22178 block = stack[stack.length - 1];
22230 let before = siblings[siblings.length - 1];
22233 block.ranges--;
22263 let parent = stack[stack.length - 1];
22277 * Expand the given pattern or create a regex-compatible string.
22350 * Compiles a brace pattern into a regex-compatible, optimized string.
22410 * (if `options.expand` is true), a highly optimized regex-compatible string.
22415 * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
22416 * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
22891 // object to hold per-process fs_watch instances
22923 // case the file's watcher misses it (and rely on throttling to de-dupe)
23017 // Check to protect against issue gh-730.
23031 // object to hold per-process fs_watchFile instances
23048 /* eslint-disable no-unused-vars, prefer-destructuring */
23064 /* eslint-enable no-unused-vars, prefer-destructuring */
23334 * Read directory to add / remove files from `@watched` list and re-read it on change.
23338 * @param {Number} depth relative to user-supplied path
23379 * @param {Object} priorWh depth relative to user-supplied path
23520 * Object to hold per-process fsevents instances (may be shared across chokidar FSWatcher instances)
23547 * @param {Path} path - to be watched
23548 * @param {Path} realPath - real path for symlinks
23549 * @param {Function} listener - called when fsevents emits events
23550 * @param {Function} rawEmitter - passes data to listeners of the 'raw' event
23624 // Decide whether or not we should start a new higher-level
23743 * @param {String} watchPath - file/dir path to be watched with fsevents
23744 * @param {String} realPath - real path (in case of symlinks)
23745 * @param {Function} transform - path transformer
23746 * @param {Function} globFilter - path filter in case a glob pattern was provided
23815 * @param {Function} transform pre-existing path transformer
23920 ...Depth(opts.depth - (priorDepth || 0))
23950 …trange thing: "should not choke on an ignored watch path" will be failed without 2 ready calls -__-
24067 throw new TypeError(`Non-string provided as watch path: ${paths}`);
24081 // TODO: this is not equal to path-normalize module - investigate why
24291 // Other platforms use non-polling fs_watch.
24296 // Global override (useful for end-developers that need to force polling for all
24361 * @param {String=} _origAdd private; for handling non-existent paths to be watched
24362 * @param {Boolean=} _internal private; indicates a non-user add
24425 * @param {Path|Array<Path>} paths_ - string or array of strings, file/directory paths and/or globs
24502 // --------------
24681 const df = now - pw.lastChange;
24757 // -----------------
24772 // ------------
24777 * @param {fs.Stats} stats - object, result of fs_stat
24942 - (stringLength(c) - index)
24960 var n = (sizes[ix] - stringLength(c)) || 0;
25015 if (isLastCharLower && /[a-zA-Z]/.test(character) && character.toUpperCase() === character) {
25016 string = string.slice(0, i) + '-' + string.slice(i);
25021 …} else if (isLastCharUpper && isLastLastCharUpper && /[a-zA-Z]/.test(character) && character.toLow…
25022 string = string.slice(0, i - 1) + '-' + string.slice(i - 1);
25050 .join('-');
25070 .replace(/^[_.\- ]+/, '')
25072 .replace(/[_.\- ]+(\w|$)/g, (_, p1) => p1.toUpperCase())
25126 if (args.indexOf('--') !== -1) {
25127 notFlags = args.slice(args.indexOf('--')+1);
25128 args = args.slice(0, args.indexOf('--'));
25132 return (flags.allBools && /^--[^=]+$/.test(arg)) ||
25153 for (var i = 0; i < keys.length-1; i++) {
25163 var key = keys[keys.length - 1];
25188 if (/^--.+=/.test(arg)) {
25192 var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
25200 else if (/^--no-.+/.test(arg)) {
25201 var key = arg.match(/^--no-(.+)/)[1];
25204 else if (/^--.+/.test(arg)) {
25205 var key = arg.match(/^--(.+)/)[1];
25207 if (next !== undefined && !/^-/.test(next)
25222 else if (/^-[^-]+/.test(arg)) {
25223 var letters = arg.slice(1,-1).split('');
25229 if (next === '-') {
25234 if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
25240 if (/[A-Za-z]/.test(letters[j])
25241 && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
25257 var key = arg.slice(-1)[0];
25258 if (!broken && key !== '-') {
25259 if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
25297 if (opts['--']) {
25298 argv['--'] = new Array();
25300 argv['--'].push(key);
25314 keys.slice(0,-1).forEach(function (key) {
25318 var key = keys[keys.length - 1];
25324 if (/^0x[0-9a-f]+$/i.test(x)) return true;
25325 return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
25329 var Space_Separator = /[\u1680\u2000-\u200A\u202F\u205F\u3000]/;
25330 …-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u0…
25331 …-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u0…
25365 return typeof c === 'string' && /[0-9]/.test(c)
25369 return typeof c === 'string' && /[0-9A-Fa-f]/.test(c)
25607 case '-':
25609 if (read$5() === '-') {
25610 sign = -1;
25865 case '-':
26176 while (count-- > 0) {
26342 const parent = stack[stack.length - 1];
26359 const current = stack[stack.length - 1];
26373 const current = stack[stack.length - 1];
26416 column -= 5;
26753 long: "rc-path",
26760 long: "ignore-path",
26829 long: "file-path",
26835 long: "ignore-path-resolve-from",
26836 description: "resolve patterns in `ignore-path` from its directory or cwd",
26842 long: "ignore-pattern",
26848 long: "tree-in",
26853 long: "tree-out",
26934 ' $ ' + name + ' input.' + extension + ' -o output.' + extension,
26940 ' $ ' + name + ' . -o'
27021 return all[all.length - 1] || []
27059 if (flag.charAt(0) !== '-') {
27064 if (flag.charAt(1) === '-') {
27073 var index = -1;
27085 'Unknown short option `-%s`, expected:\n%s',
27108 long = '[no-]' + long;
27113 option.short ? '-' + option.short : '',
27114 '--' + long + (option.value ? ' ' + option.value : ''),
27145 // Transform the keys on an object to camel-case, recursivly.
27241 source.yellow('Note') + ': Ignoring `--output` until exit.\n',
27307 /* istanbul ignore next - Old versions of Node */ err;
27315 /* eslint-disable unicorn/no-process-exit */
27317 /* eslint-enable unicorn/no-process-exit */
27432 // Only deal with non-null/undefined values
27439 // Prevent never-ending loop
27513 var freezeIndex = -1;
27540 var index = -1;
27596 // Getter / setter for processor-specific informtion.
27681 index = -1;
27708 var index = -1;
27734 return Parser(String(file), file) // eslint-disable-line new-cap
27804 return Compiler(node, file) // eslint-disable-line new-cap
28019 // Factory to get the line and column-based `position` for `offset` in the bound
28024 // Get the line and column-based `position` for `offset` in the bound indices.
28026 var index = -1;
28037 column: offset - (indices[index - 1] || 0) + 1,
28047 // Factory to get the `offset` for a line and column-based `position` in the
28052 // Get the `offset` for a line and column-based `position` in the bound
28058 if (!isNaN(line) && !isNaN(column) && line - 1 in indices) {
28059 return (indices[line - 2] || 0) + column - 1 || 0
28062 return -1
28066 // Get indices of line-breaks in `value`.
28071 while (index !== -1) {
28085 // Factory to de-escape a value, based on a list at `key` in `ctx`.
28089 // De-escape a string using the expression at `key` in `ctx`.
28097 while (index !== -1) {
28103 if (!character || escape.indexOf(character) === -1) {
28485 return code >= 48 && code <= 57 /* 0-9 */
28510 (code >= 97 && code <= 122) /* a-z */ ||
28511 (code >= 65 && code <= 90) /* A-Z */
35313 // eslint-disable-next-line complexity
35327 var lines = -1;
35364 index--;
35426 end--;
35459 diff = 1 + end - start;
35477 diff = 1 + end - begin;
35505 // All non-terminated numeric entities are not rendered, and trigger a
35534 reference -= 0x10000;
35549 index = end - 1;
35550 column += end - start + 1;
35560 value.slice(start - 1, end)
35570 characters = value.slice(start - 1, end);
35573 index = end - 1;
35606 // “Throw” a parse-error: a warning.
35675 // Decode `value` (at `position`) into text-nodes.
35696 // See <https://github.com/wooorm/parse-entities> for the warnings.
35739 // something, re-iterate with the remaining value. If no tokenizer eats,
35742 index = -1;
35785 var lastIndex = -1;
35788 while (index !== -1) {
35794 if (lastIndex === -1) {
35797 column = subvalue.length - lastIndex;
35801 if (lastIndex !== -1) {
35850 // Capture stack-trace.
35905 var previous = children[children.length - 1];
35958 // column are reversed, and the eaten value is re-added. This is
35971 // Test the position, after eating, and reverse to a not-eaten state.
35999 start.line !== end.line || end.column - start.column === node.value.length
36035 '-',
36220 var index = -1;
36254 var index = -1;
36311 if (!test || is(node, index, parents[parents.length - 1] || null)) {
36329 var min = -1;
36330 var step = reverse ? -1 : 1;
36380 var parent = parents[parents.length - 1];
36414 // Clean non-unix newlines: `\r\n` and `\r` are all changed to `\n`.
36441 // See <https://spec.commonmark.org/0.29/#blank-line>.
36446 // (<https://spec.commonmark.org/0.29/#blank-lines>), it’s done by the list
36473 /* istanbul ignore if - never used (yet) */
36490 while (val.charAt(--index) === line$1) {
36507 var index = -1;
36819 index = -1;
36865 var index = -1;
36949 if (nextIndex === -1) {
36992 indents.push(index - startIndex);
36999 index = -1;
37028 var index = -1;
37041 index--;
37055 index--;
37073 // Eat intermediate white-space.
37080 index--;
37135 index--;
37155 var dash$1 = '-';
37161 var index = -1;
37273 while (position--) {
37296 while (position--) {
37301 index--;
37318 var dash$2 = '-';
37329 var bulletExpression = /^([ \t]*)([*+-]|\d+[.)])( {1,4}(?! )| |\t|$|(?=\n))([^\n]*)/;
37330 var pedanticBulletExpression = /^([ \t]*)([*+-]|\d+[.)])([ \t]+)/;
37443 if (nextIndex === -1) {
37453 size += tabSize$3 - (size % tabSize$3);
37509 size += tabSize$3 - (size % tabSize$3);
37524 index -= tabSize$3 - 1;
37525 size -= tabSize$3 - 1;
37619 index = -1;
37630 if (index !== length - 1) {
37671 // Create a list-item using overly simple mechanics.
37676 // Remove the list-item’s bullet.
37694 // Create a list-item using sane mechanics.
37706 // Remove the list-item’s bullet.
37727 (offsets[line] || 0) + lines[index].length - trimmedLines[index].length;
37733 /* eslint-disable-next-line max-params */
37757 var dash$3 = '-';
37768 var index = -1;
37781 index--;
37796 index--;
37822 // Eat Setext-line.
37834 index--;
37852 var attributeName = '[a-zA-Z_:][a-zA-Z0-9:._-]*';
37853 var unquoted = '[^"\'=<>`\\u0000-\\u0020]+';
37860 var openTag = '<[A-Za-z][A-Za-z0-9\\-]*' + attribute + '*\\s*\\/?>';
37861 var closeTag = '<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>';
37862 var comment = '<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->';
37864 var declaration = '<![A-Za-z]+\\s+[^>]*>';
37901 var commentOpenExpression = /^<!--/;
37902 var commentCloseExpression = /-->/;
37905 var directiveOpenExpression = /^<![A-Za-z]/;
37955 next = next === -1 ? length : next;
37957 offset = -1;
37980 next = next === -1 ? length : next;
38147 index -= queue.length + 1;
38302 var dash$4 = '-';
38339 // Exit when not in gfm-mode.
38357 if (lineIndex === -1) {
38361 if (pipeIndex === -1 || pipeIndex > lineIndex) {
38379 lineCount--;
38426 /* istanbul ignore if - never used (yet) */
38432 position = -1;
38478 subvalue += queue.slice(0, -1);
38479 queue = queue.charAt(queue.length - 1);
38507 if (character === backslash$3 && index !== length - 2) {
38551 if (index === -1) {
38561 // In commonmark-mode, following indented lines are part of the paragraph.
38597 if (index !== -1 && trim_1(value.slice(position, index)) === '') {
38605 /* istanbul ignore if - never used (yet) */
38639 if (self.escape.indexOf(character) !== -1) {
38640 /* istanbul ignore if - never used (yet) */
38749 /* istanbul ignore if - never used (yet) */
38803 while (index !== -1) {
38816 var min = -1;
38826 index = -1;
38831 if (position !== -1 && (min === -1 || position < min)) {
38848 var dash$5 = 45; // '-'
38865 var previousDot = -1;
38899 previousDot = index - 1;
38910 if (previousDot === index - 1) {
38936 index--;
38947 lastTwoPartsStart = dots.length < 2 ? start : dots[dots.length - 2] + 1;
38949 if (value.slice(lastTwoPartsStart, index).indexOf('_') !== -1) {
38953 /* istanbul ignore if - never used (yet) */
38989 if (value.charCodeAt(index - 1) === rightParenthesis$2) {
38997 rightCount--;
39001 if (value.charCodeAt(index - 1) === semicolon$1) {
39004 index--;
39007 if (isAlphabetical(value.charCodeAt(index - 1))) {
39008 end = index - 2;
39011 end--;
39040 var dash$6 = 45; // '-'
39046 // See: <https://github.github.com/gfm/#extended-email-autolink>
39053 return -1
39058 if (at === -1) {
39059 return -1
39064 if (position === fromIndex || !isGfmAtext(value.charCodeAt(position - 1))) {
39068 while (position > fromIndex && isGfmAtext(value.charCodeAt(position - 1))) {
39069 position--;
39091 var dash$7 = 45; // '-'
39102 var firstDot = -1;
39147 if (firstDot === -1 && code === dot$4) {
39158 firstDot === -1 ||
39167 index--;
39172 /* istanbul ignore if - never used (yet) */
39234 /* istanbul ignore if - not used yet. */
39256 if (image === -1) {
39260 // Link can never be `-1` if an image is found, so we don’t need to check
39342 // Inline-code in link content.
39366 depth--;
39394 // Eat white-space.
39467 depth--;
39489 // Eat white-space.
39519 // In commonmark-mode, things are pretty easy: the marker cannot occur
39520 // inside the title. Non-commonmark does, however, support nested
39595 /* istanbul ignore if - never used (yet) */
39689 depth--;
39783 /* istanbul ignore if - never used (yet) */
39817 if (underscore === -1) {
39821 if (asterisk === -1) {
39882 /* istanbul ignore if - never used (yet) */
39927 if (underscore === -1) {
39931 if (asterisk === -1) {
39990 /* istanbul ignore if - never used (yet) */
40063 /* istanbul ignore if - never used (yet) */
40131 closingFenceEnd - closingFenceStart === openingFenceEnd
40148 /* istanbul ignore if - never used (yet) */
40154 // are non-space characters in the content.
40158 next = value.charCodeAt(length - 1);
40162 length - index > 2 &&
40167 length--;
40182 closingFenceStart--;
40198 if (value.charAt(index - 1) !== ' ') {
40202 index--;
40217 var index = -1;
40229 /* istanbul ignore if - never used (yet) */
40262 /* istanbul ignore if - never used (yet) */
40270 index = -1;
40288 if (position !== -1 && position < min) {
40358 // - One
40503 bullet: '-',
41322 var surrogatePair = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
41324 // Non-ASCII characters.
41325 // eslint-disable-next-line no-control-regex, unicorn/no-hex-escape
41326 var bmp = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
41348 (pair.charCodeAt(0) - 0xd800) * 0x400 +
41349 pair.charCodeAt(1) -
41417 dangerous$2.indexOf(name) === -1 &&
41460 return !/[^0-9a-z\xDF-\xFF]/.test(str.toLowerCase());
41472 /* istanbul ignore if - Currently also tested for at implemention, but we
41480 return prefix.length - parseEntities_1(prefix).length
41494 var dash$8 = '-';
41536 var previous = siblings && siblings[index - 1];
41540 var position = -1;
41578 position < length - 1 &&
41580 !isAlphanumeric(value.charAt(position - 1)) ||
41605 if (markers.indexOf(value.charAt(offset)) !== -1) {
41625 // Multi-node versions.
41627 // Check for an opening parentheses after a link-reference (which can be
41628 // joined by white-space).
41630 position = -1;
41658 // Ensure non-auto-links are not seen as links. This pattern needs to
41665 protocol(previous.value.slice(-6))
41673 value.charAt(length - 1) === ampersand$3 &&
41676 escaped[escaped.length - 1] = one(ampersand$3);
41683 value.charAt(length - 1) === exclamationMark$5
41685 escaped[escaped.length - 1] = one(exclamationMark$5);
41692 value.charAt(length - 1) === tilde$5 &&
41695 escaped.splice(-1, 0, backslash$9);
41698 // Escape underscores, but not mid-word (unless in pedantic mode).
41699 wordCharBefore = text$1(previous) && isAlphanumeric(previous.value.slice(-1));
41718 value.charAt(length - 1) === underscore$7 &&
41721 !isAlphanumeric(value.charAt(length - 2)))
41723 escaped.splice(-1, 0, backslash$9);
41731 return escapable.indexOf(character) === -1
41744 end = end === -1 ? value.length : end;
41769 var tail = value.slice(-6).toLowerCase();
41770 return tail === mailto$1 || tail.slice(-5) === https || tail.slice(-4) === http
41778 bullet: {'*': true, '-': true, '+': true}, property
41779 rule: {'-': true, _: true, '*': true}, property
41893 // Factory to encode HTML entities. Creates a no-operation function when
41936 var prev = index && siblings[index - 1];
41977 start.line !== end.line || end.column - start.column === node.value.length
42018 var index = -1;
42033 var comment$1 = blank$1 + '<!---->' + blank$1;
42046 var index = -1;
42109 var index = -1;
42135 var index = -1;
42154 if (doc.charAt(doc.length - 1) !== lineFeed$m) {
42184 var dash$9 = '-';
42243 var index = -1;
42275 while (index--) {
42319 var index = -1;
42332 // the value, but unfortunately github does not support empty list-items
42342 if (style === '1' || (style === 'mixed' && value.indexOf(lineFeed$q) === -1)) {
42347 spacing = repeatString(space$k, indent - marker.length);
42372 while (index !== -1) {
42418 var tail = value.charCodeAt(value.length - 1);
42427 length = value.length - 1;
42459 // - No language tag exists
42460 // - Not in `fences: true` mode
42461 // - A non-empty value exists
42508 value.charAt(value.length - 1) !== lineFeed$s
42528 if (marker === graveAccent$5 && info.indexOf(graveAccent$5) !== -1) {
42547 // Stringify a `thematic-break`.
42615 content.indexOf(marker) !== -1
42660 // - has a length of `0`
42661 // - contains white-space
42662 // - has more or less opening than closing parentheses
42684 // CommonMark is not supported when mixing double- and single quotes inside a
42688 title.indexOf(quotationMark$2) === -1 ? quotationMark$2 : apostrophe$2;
42702 var protocol$1 = /^[a-z][a-z+.-]+:\/?/i;
42718 // [foo](<foo at bar dot com> 'An "example" e-mail')
42757 var punctuationExppresion = /[-!"#$%&'()*+,./:;<=>?@[\\\]^`{|}~_]/;
42775 // Take next non-punctuation characters from `value`.
42808 // Advance `index` to the next non-punctuation character.
42895 // [foo]: <foo at bar dot com> 'An "example" e-mail'
42964 var dash$a = '-';
42986 var rowIndex = -1;
43010 columnIndex = -1;
43041 columnIndex = -1;
43057 columnIndex = -1;
43076 // There *must* be at least one hyphen-minus in each alignment cell.
43080 longestCellByColumn[columnIndex] - before.length - after.length
43103 rowIndex = -1;
43110 columnIndex = -1;
43120 size = longestCellByColumn[columnIndex] - (sizes[columnIndex] || 0);
43131 after = repeatString(space$s, size / 2 - 0.5);
43166 if (end === true || columnIndex !== columnLength - 1) {
43213 // | :-: | - |
43221 // |:-:|---|
43235 while (index--) {
43331 "/Users/bytedance/Documents/code/github/node/tools/node-lint-md-cli-rollup"
43337 const _integrity = "sha512-oX4lMIS0csgk8AEbzY0h2jdR0ngiCHOpwwpxjmRa5TqAkeknY+tkhjRJGZqnCmvyuWh55/0S…
43354 const _resolved = "https://registry.npmjs.org/remark/-/remark-12.0.0.tgz";
43356 const _where = "/Users/bytedance/Documents/code/github/node/tools/node-lint-md-cli-rollup";
43373 "remark-parse": "^8.0.0",
43374 "remark-stringify": "^8.0.0",
43478 const name$2 = "node-lint-md-cli-rollup";
43482 "@rollup/plugin-commonjs": "^11.0.1",
43483 "@rollup/plugin-json": "^4.0.1",
43484 "@rollup/plugin-node-resolve": "^7.0.0",
43489 "markdown-extensions": "^1.1.1",
43491 "remark-lint": "^7.0.0",
43492 "remark-preset-lint-node": "^1.16.0",
43493 "unified-args": "^8.0.0"
43497 build: "npx rollup -c",
43498 "build-node": "npm run build && npx shx cp dist/index.js ../lint-md.js"
43533 // Factory to get the line and column-based `position` for `offset` in the bound
43538 // Get the line and column-based `position` for `offset` in the bound indices.
43540 var index = -1;
43551 column: offset - (indices[index - 1] || 0) + 1,
43561 // Factory to get the `offset` for a line and column-based `position` in the
43566 // Get the `offset` for a line and column-based `position` in the bound
43572 if (!isNaN(line) && !isNaN(column) && line - 1 in indices) {
43573 return (indices[line - 2] || 0) + column - 1 || 0
43576 return -1
43580 // Get indices of line-breaks in `value`.
43585 while (index !== -1) {
43620 var index = -1;
43654 var index = -1;
43711 if (!test || is(node, index, parents[parents.length - 1] || null)) {
43729 var min = -1;
43730 var step = reverse ? -1 : 1;
43780 var parent = parents[parents.length - 1];
43858 index = -1;
43891 if (!message.source || sources.indexOf(message.source) === -1) {
43908 while (gapIndex--) {
43920 var result = known ? known.indexOf(ruleId) !== -1 : true;
43938 return ranges[ranges.length - 1].state
43946 return enable.indexOf(ruleId) !== -1
43949 return disable.indexOf(ruleId) === -1
43980 var length = -1;
43983 while (--index > length) {
43986 /* istanbul ignore if - Generated marker. */
44006 return reset ? enable.indexOf(id) !== -1 : disable.indexOf(id) === -1
44013 var lastNode = tree.children[tree.children.length - 1];
44035 tree && tree.position && tree.position.end && tree.position.end.offset - 1
44079 var parametersExpression = /\s+([-a-z0-9_]+)(?:=(?:"((?:\\[\s\S]|[^"])+)"|'((?:\\[\s\S]|[^'])+)'|((…
44081 var commentExpression = /\s*([a-zA-Z0-9-]+)(\s+([\s\S]*))?\s*/;
44084 '(\\s*<!--' + commentExpression.source + '-->\\s*)'
44134 /* eslint-disable max-params */
44163 var remarkLint = lint;
44165 // `remark-lint`.
44166 // This adds support for ignoring stuff from messages (`<!--lint ignore-->`).
44168 function lint() { function
44173 return remarkMessageControl({name: 'lint', source: 'remark-lint'})
44201 while (len-- > start) {
44202 ret[len - start] = args[len];
44244 var hasCallback = len && 'function' == typeof args[len - 1];
44397 return --pending || done(null, results);
44409 --pending || done(null, results);
44528 var last = args[args.length - 1];
44623 /* istanbul ignore if - possibly useful if externalised later. */
44651 /* istanbul ignore if - only happens for incorrect plugins */
44652 if (err && messages.indexOf(err) === -1) {
44673 // Coerce a value to a severity--options tuple.
44679 /* istanbul ignore if - Handled by unified in v6.0.0 */
44728 var remarkLintFinalNewline = unifiedLintRule('remark-lint:final-newline', finalNewline);
44732 var last = contents.length - 1;
44734 if (last > -1 && contents.charAt(last) !== '\n') {
44752 // Rule storage - pluralize and singularize need to be run sequentially,
44826 return restoreCase(word[index - 1], result);
44850 while (len--) {
45067 [/[^\u0000-\u007F]$/i, '$0'],
45283 'remark-lint:list-item-bullet-indent',
45317 column: final.column - indent
45324 var remarkLintListItemIndent = unifiedLintRule('remark-lint:list-item-indent', listItemIndent);
45328 var styles$1 = {'tab-size': true, mixed: true, space: true};
45332 var preferred = typeof option === 'string' ? option : 'tab-size';
45336 'Incorrect list-item indent style `' +
45338 "`: use either `'tab-size'`, `'space'`, or `'mixed'`"
45368 preferred === 'tab-size' || (preferred === 'mixed' && spread)
45373 diff = style - marker.length;
45377 'Incorrect list-item indent: ' +
45393 // Prefer the node’s plain-text fields, otherwise serialize its children,
45410 var index = -1;
45420 'remark-lint:no-auto-link-without-protocol',
45429 var protocol$2 = /^[a-z][a-z+.-]+:\/?/i;
45443 start$4(node).column === start$4(children[0]).column - 1 &&
45444 end$1(node).column === end$1(children[children.length - 1]).column + 1 &&
45454 'remark-lint:no-blockquote-without-marker',
45483 index = -1;
45488 offset = location.toOffset(pos) - 1;
45497 /* istanbul ignore else - just for safety */
45507 var remarkLintNoLiteralUrls = unifiedLintRule('remark-lint:no-literal-urls', noLiteralURLs);
45524 end$2(node).column === end$2(children[children.length - 1]).column &&
45533 'remark-lint:ordered-list-marker-style',
45563 var index = -1;
45588 var remarkLintHardBreakSpaces = unifiedLintRule('remark-lint:hard-break-spaces', hardBreakSpaces);
45614 'remark-lint:no-duplicate-definitions',
45648 var last = node.children[node.children.length - 1];
45657 // This can only occur for `'atx'` and `'atx-closed'` headings.
45659 // space as an `'atx-closed'` heading.
45661 if (pos.column - 1 <= depth * 2) {
45665 return 'atx-closed'
45673 return 'atx-closed'
45679 // Get the probable style of an atx-heading, depending on preferred style.
45689 'remark-lint:no-heading-content-indent',
45722 if (type === 'atx' || type === 'atx-closed') {
45731 /* istanbul ignore if - CR/LF bug: remarkjs/remark#195. */
45736 index = depth + (index - initial.offset);
45744 diff = head - initial.column - 1 - index;
45763 if (type === 'atx-closed') {
45764 final = end$3(children[children.length - 1]);
45765 diff = end$3(node).column - final.column - 1 - depth;
45781 var remarkLintNoInlinePadding = unifiedLintRule('remark-lint:no-inline-padding', noInlinePadding);
45794 contents.charAt(contents.length - 1) === ' '
45803 'remark-lint:no-shortcut-reference-image',
45820 'remark-lint:no-shortcut-reference-link',
45837 'remark-lint:no-undefined-references',
45868 allow.indexOf(normalize$3(node.identifier)) === -1
45875 var remarkLintNoUnusedDefinitions = unifiedLintRule('remark-lint:no-unused-definitions', noUnusedDe…
45916 [remarkLintListItemIndent, 'tab-size'],
45938 'remark-lint:blockquote-indentation',
45957 diff = preferred - check$3(node);
45979 var indentation = unistUtilPosition.start(head).column - unistUtilPosition.start(node).column;
45990 'remark-lint:checkbox-character-style',
46044 value = contents.slice(initial, final).replace(/\s+$/, '').slice(0, -1);
46047 character = value.charAt(value.length - 1);
46060 start: location.toPosition(initial + value.length - 1),
46071 'remark-lint:checkbox-content-indent',
46097 /* istanbul ignore next - hard to test, couldn’t find a case. */
46111 start: location.toPosition(final - value.length + 1),
46118 var remarkLintCodeBlockStyle = unifiedLintRule('remark-lint:code-block-style', codeBlockStyle);
46167 var remarkLintDefinitionSpacing = unifiedLintRule('remark-lint:definition-spacing', definitionSpaci…
46190 var remarkLintFencedCodeFlag = unifiedLintRule('remark-lint:fenced-code-flag', fencedCodeFlag);
46221 if (allowed.length !== 0 && allowed.indexOf(node.lang) === -1) {
46235 var remarkLintFencedCodeMarker = unifiedLintRule('remark-lint:fenced-code-marker', fencedCodeMarker…
46288 var remarkLintFileExtension = unifiedLintRule('remark-lint:file-extension', fileExtension);
46299 var remarkLintFinalDefinition = unifiedLintRule('remark-lint:final-definition', finalDefinition);
46331 var remarkLintFirstHeadingLevel = unifiedLintRule('remark-lint:first-heading-level', firstHeadingLe…
46333 var re$3 = /<h([1-6])/;
46369 var remarkLintHeadingStyle = unifiedLintRule('remark-lint:heading-style', headingStyle);
46371 var types$2 = ['atx', 'atx-closed', 'setext'];
46374 var preferred = types$2.indexOf(option) === -1 ? null : option;
46391 var remarkLintMaximumLineLength = unifiedLintRule('remark-lint:maximum-line-length', maximumLineLen…
46401 var index = -1;
46404 // Note: JSX is from MDX: <https://github.com/mdx-js/specification>.
46429 /* istanbul ignore if - Nothing to whitelist when generated. */
46451 whitelist(initial.line - 1, final.line);
46455 /* istanbul ignore else - Hard to test, as we only run this case on `position: true` */
46457 whitelist(start$d(node).line - 1, end$8(node).line);
46461 // Whitelist from `initial` to `final`, zero-based.
46470 'remark-lint:no-consecutive-blank-lines',
46492 tail = children[children.length - 1];
46505 var diff = end.line - start.line;
46506 var lines = Math.abs(diff) - max;
46524 var previous = all[index - 1];
46540 var remarkLintNoFileNameArticles = unifiedLintRule('remark-lint:no-file-name-articles', noFileNameA…
46551 'remark-lint:no-file-name-consecutive-dashes',
46558 if (file.stem && /-{2,}/.test(file.stem)) {
46564 'remark-lint:no-file-name-outer-dashes',
46571 if (file.stem && /^-|-$/.test(file.stem)) {
46576 var remarkLintNoHeadingIndent = unifiedLintRule('remark-lint:no-heading-indent', noHeadingIndent);
46599 index = begin - 1;
46609 diff = index - begin;
46628 'remark-lint:no-multiple-toplevel-headings',
46652 var remarkLintNoShellDollars = unifiedLintRule('remark-lint:no-shell-dollars', noShellDollars);
46682 if (!unistUtilGenerated(node) && node.lang && flags.indexOf(node.lang) !== -1) {
46685 index = -1;
46708 var remarkLintNoTableIndentation = unifiedLintRule('remark-lint:no-table-indentation', noTableInden…
46737 var remarkLintNoTabs = unifiedLintRule('remark-lint:no-tabs', noTabs);
46746 while (index !== -1) {
46752 var remarkLintNoTrailingSpaces = unifiedLintRule('remark-lint:no-trailing-spaces', noTrailingSpaces…
46784 .replace(/-/g, '\\x2d');
46789 var remarkLintProhibitedStrings = unifiedLintRule('remark-lint:prohibited-strings', prohibitedStrin…
46800 let regexpString = '(?<!\\.|@[a-zA-Z0-9/-]*)';
46866 var remarkLintRuleStyle = rule('remark-lint:rule-style', ruleStyle);
46876 if (preferred !== null && /[^-_* ]/.test(preferred)) {
46903 var remarkLintStrongMarker = unifiedLintRule('remark-lint:strong-marker', strongMarker);
46940 var remarkLintTableCellPadding = unifiedLintRule('remark-lint:table-cell-padding', tableCellPadding…
46965 var length = unistUtilGenerated(node) ? -1 : rows.length;
46966 var index = -1;
46985 column = -2; // Start without a first cell.
47011 final = fence.length - pos - 1;
47024 index = -1;
47073 return end$a(node).offset - start$i(node).offset
47076 var remarkLintTablePipes = unifiedLintRule('remark-lint:table-pipes', tablePipes);
47092 var index = -1;
47106 tail = cells[cells.length - 1];
47110 if (initial.indexOf('|') === -1) {
47114 if (final.indexOf('|') === -1) {
47123 'remark-lint:unordered-list-marker-style',
47130 '-': true, property
47145 "`: use either `'-'`, `'*'`, or `'+'`"
47154 var index = -1;
47203 "cpp",
47235 { yes: "End-of-Life" },
47265 // To aid in future maintenance, this layout closely matches remark-cli/cli.js.
47266 // https://github.com/remarkjs/remark/blob/master/packages/remark-cli/cli.js
47284 presetPrefix: proc.name + '-preset',