Revert "Update stylelint to 14.0.1"
This reverts commit 1e08ee816bab192a7d295d2f457be97bd88c09c1.
Reason for revert: tree is closed due to errors https://ci.chromium.org/ui/p/devtools-frontend/builders/ci/Stand-alone%20Linux/8169/overview
Original change's description:
> Update stylelint to 14.0.1
>
> This also upgrades PostCSS to 8.3.11.
>
> DISABLE_THIRD_PARTY_CHECK=Updating Stylelint configuration
> R=szuend@chromium.org
>
> Bug: none
> Change-Id: I606540b03509d7c6e73f3d490327cd4174e03d31
> Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/3259541
> Reviewed-by: Simon Zünd <szuend@chromium.org>
> Commit-Queue: Tim van der Lippe <tvanderlippe@chromium.org>
Bug: none
Change-Id: Icb1c02b41dbccc3b4fc5760f5dd0b78eca078b61
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/3263399
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Owners-Override: Alex Rudenko <alexrudenko@chromium.org>
Commit-Queue: Alex Rudenko <alexrudenko@chromium.org>
diff --git a/node_modules/postcss/lib/css-syntax-error.js b/node_modules/postcss/lib/css-syntax-error.js
index 3161f21..adcade3 100644
--- a/node_modules/postcss/lib/css-syntax-error.js
+++ b/node_modules/postcss/lib/css-syntax-error.js
@@ -1,93 +1,298 @@
-'use strict'
+"use strict";
-let pico = require('picocolors')
+exports.__esModule = true;
+exports.default = void 0;
-let terminalHighlight = require('./terminal-highlight')
+var _supportsColor = _interopRequireDefault(require("supports-color"));
-class CssSyntaxError extends Error {
- constructor(message, line, column, source, file, plugin) {
- super(message)
- this.name = 'CssSyntaxError'
- this.reason = message
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _terminalHighlight = _interopRequireDefault(require("./terminal-highlight"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+/**
+ * The CSS parser throws this error for broken CSS.
+ *
+ * Custom parsers can throw this error for broken custom syntax using
+ * the {@link Node#error} method.
+ *
+ * PostCSS will use the input source map to detect the original error location.
+ * If you wrote a Sass file, compiled it to CSS and then parsed it with PostCSS,
+ * PostCSS will show the original position in the Sass file.
+ *
+ * If you need the position in the PostCSS input
+ * (e.g., to debug the previous compiler), use `error.input.file`.
+ *
+ * @example
+ * // Catching and checking syntax error
+ * try {
+ * postcss.parse('a{')
+ * } catch (error) {
+ * if (error.name === 'CssSyntaxError') {
+ * error //=> CssSyntaxError
+ * }
+ * }
+ *
+ * @example
+ * // Raising error from plugin
+ * throw node.error('Unknown variable', { plugin: 'postcss-vars' })
+ */
+var CssSyntaxError = /*#__PURE__*/function (_Error) {
+ _inheritsLoose(CssSyntaxError, _Error);
+
+ /**
+ * @param {string} message Error message.
+ * @param {number} [line] Source line of the error.
+ * @param {number} [column] Source column of the error.
+ * @param {string} [source] Source code of the broken file.
+ * @param {string} [file] Absolute path to the broken file.
+ * @param {string} [plugin] PostCSS plugin name, if error came from plugin.
+ */
+ function CssSyntaxError(message, line, column, source, file, plugin) {
+ var _this;
+
+ _this = _Error.call(this, message) || this;
+ /**
+ * Always equal to `'CssSyntaxError'`. You should always check error type
+ * by `error.name === 'CssSyntaxError'`
+ * instead of `error instanceof CssSyntaxError`,
+ * because npm could have several PostCSS versions.
+ *
+ * @type {string}
+ *
+ * @example
+ * if (error.name === 'CssSyntaxError') {
+ * error //=> CssSyntaxError
+ * }
+ */
+
+ _this.name = 'CssSyntaxError';
+ /**
+ * Error message.
+ *
+ * @type {string}
+ *
+ * @example
+ * error.message //=> 'Unclosed block'
+ */
+
+ _this.reason = message;
if (file) {
- this.file = file
- }
- if (source) {
- this.source = source
- }
- if (plugin) {
- this.plugin = plugin
- }
- if (typeof line !== 'undefined' && typeof column !== 'undefined') {
- this.line = line
- this.column = column
+ /**
+ * Absolute path to the broken file.
+ *
+ * @type {string}
+ *
+ * @example
+ * error.file //=> 'a.sass'
+ * error.input.file //=> 'a.css'
+ */
+ _this.file = file;
}
- this.setMessage()
+ if (source) {
+ /**
+ * Source code of the broken file.
+ *
+ * @type {string}
+ *
+ * @example
+ * error.source //=> 'a { b {} }'
+ * error.input.column //=> 'a b { }'
+ */
+ _this.source = source;
+ }
+
+ if (plugin) {
+ /**
+ * Plugin name, if error came from plugin.
+ *
+ * @type {string}
+ *
+ * @example
+ * error.plugin //=> 'postcss-vars'
+ */
+ _this.plugin = plugin;
+ }
+
+ if (typeof line !== 'undefined' && typeof column !== 'undefined') {
+ /**
+ * Source line of the error.
+ *
+ * @type {number}
+ *
+ * @example
+ * error.line //=> 2
+ * error.input.line //=> 4
+ */
+ _this.line = line;
+ /**
+ * Source column of the error.
+ *
+ * @type {number}
+ *
+ * @example
+ * error.column //=> 1
+ * error.input.column //=> 4
+ */
+
+ _this.column = column;
+ }
+
+ _this.setMessage();
if (Error.captureStackTrace) {
- Error.captureStackTrace(this, CssSyntaxError)
+ Error.captureStackTrace(_assertThisInitialized(_this), CssSyntaxError);
}
+
+ return _this;
}
- setMessage() {
- this.message = this.plugin ? this.plugin + ': ' : ''
- this.message += this.file ? this.file : '<css input>'
+ var _proto = CssSyntaxError.prototype;
+
+ _proto.setMessage = function setMessage() {
+ /**
+ * Full error text in the GNU error format
+ * with plugin, file, line and column.
+ *
+ * @type {string}
+ *
+ * @example
+ * error.message //=> 'a.css:1:1: Unclosed block'
+ */
+ this.message = this.plugin ? this.plugin + ': ' : '';
+ this.message += this.file ? this.file : '<css input>';
+
if (typeof this.line !== 'undefined') {
- this.message += ':' + this.line + ':' + this.column
+ this.message += ':' + this.line + ':' + this.column;
}
- this.message += ': ' + this.reason
+
+ this.message += ': ' + this.reason;
}
+ /**
+ * Returns a few lines of CSS source that caused the error.
+ *
+ * If the CSS has an input source map without `sourceContent`,
+ * this method will return an empty string.
+ *
+ * @param {boolean} [color] Whether arrow will be colored red by terminal
+ * color codes. By default, PostCSS will detect
+ * color support by `process.stdout.isTTY`
+ * and `process.env.NODE_DISABLE_COLORS`.
+ *
+ * @example
+ * error.showSourceCode() //=> " 4 | }
+ * // 5 | a {
+ * // > 6 | bad
+ * // | ^
+ * // 7 | }
+ * // 8 | b {"
+ *
+ * @return {string} Few lines of CSS source that caused the error.
+ */
+ ;
- showSourceCode(color) {
- if (!this.source) return ''
+ _proto.showSourceCode = function showSourceCode(color) {
+ var _this2 = this;
- let css = this.source
- if (color == null) color = pico.isColorSupported
- if (terminalHighlight) {
- if (color) css = terminalHighlight(css)
+ if (!this.source) return '';
+ var css = this.source;
+
+ if (_terminalHighlight.default) {
+ if (typeof color === 'undefined') color = _supportsColor.default.stdout;
+ if (color) css = (0, _terminalHighlight.default)(css);
}
- let lines = css.split(/\r?\n/)
- let start = Math.max(this.line - 3, 0)
- let end = Math.min(this.line + 2, lines.length)
+ var lines = css.split(/\r?\n/);
+ var start = Math.max(this.line - 3, 0);
+ var end = Math.min(this.line + 2, lines.length);
+ var maxWidth = String(end).length;
- let maxWidth = String(end).length
+ function mark(text) {
+ if (color && _chalk.default.red) {
+ return _chalk.default.red.bold(text);
+ }
- let mark, aside
- if (color) {
- let { bold, red, gray } = pico.createColors(true)
- mark = text => bold(red(text))
- aside = text => gray(text)
- } else {
- mark = aside = str => str
+ return text;
}
- return lines
- .slice(start, end)
- .map((line, index) => {
- let number = start + 1 + index
- let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | '
- if (number === this.line) {
- let spacing =
- aside(gutter.replace(/\d/g, ' ')) +
- line.slice(0, this.column - 1).replace(/[^\t]/g, ' ')
- return mark('>') + aside(gutter) + line + '\n ' + spacing + mark('^')
- }
- return ' ' + aside(gutter) + line
- })
- .join('\n')
+ function aside(text) {
+ if (color && _chalk.default.gray) {
+ return _chalk.default.gray(text);
+ }
+
+ return text;
+ }
+
+ return lines.slice(start, end).map(function (line, index) {
+ var number = start + 1 + index;
+ var gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | ';
+
+ if (number === _this2.line) {
+ var spacing = aside(gutter.replace(/\d/g, ' ')) + line.slice(0, _this2.column - 1).replace(/[^\t]/g, ' ');
+ return mark('>') + aside(gutter) + line + '\n ' + spacing + mark('^');
+ }
+
+ return ' ' + aside(gutter) + line;
+ }).join('\n');
}
+ /**
+ * Returns error position, message and source code of the broken part.
+ *
+ * @example
+ * error.toString() //=> "CssSyntaxError: app.css:1:1: Unclosed block
+ * // > 1 | a {
+ * // | ^"
+ *
+ * @return {string} Error position, message and source code.
+ */
+ ;
- toString() {
- let code = this.showSourceCode()
+ _proto.toString = function toString() {
+ var code = this.showSourceCode();
+
if (code) {
- code = '\n\n' + code + '\n'
+ code = '\n\n' + code + '\n';
}
- return this.name + ': ' + this.message + code
- }
-}
-module.exports = CssSyntaxError
-CssSyntaxError.default = CssSyntaxError
+ return this.name + ': ' + this.message + code;
+ }
+ /**
+ * @memberof CssSyntaxError#
+ * @member {Input} input Input object with PostCSS internal information
+ * about input file. If input has source map
+ * from previous tool, PostCSS will use origin
+ * (for example, Sass) source. You can use this
+ * object to get PostCSS input source.
+ *
+ * @example
+ * error.input.file //=> 'a.css'
+ * error.file //=> 'a.sass'
+ */
+ ;
+
+ return CssSyntaxError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+var _default = CssSyntaxError;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["css-syntax-error.es6"],"names":["CssSyntaxError","message","line","column","source","file","plugin","name","reason","setMessage","Error","captureStackTrace","showSourceCode","color","css","terminalHighlight","supportsColor","stdout","lines","split","start","Math","max","end","min","length","maxWidth","String","mark","text","chalk","red","bold","aside","gray","slice","map","index","number","gutter","spacing","replace","join","toString","code"],"mappings":"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","sourcesContent":["import supportsColor from 'supports-color'\nimport chalk from 'chalk'\n\nimport terminalHighlight from './terminal-highlight'\n\n/**\n * The CSS parser throws this error for broken CSS.\n *\n * Custom parsers can throw this error for broken custom syntax using\n * the {@link Node#error} method.\n *\n * PostCSS will use the input source map to detect the original error location.\n * If you wrote a Sass file, compiled it to CSS and then parsed it with PostCSS,\n * PostCSS will show the original position in the Sass file.\n *\n * If you need the position in the PostCSS input\n * (e.g., to debug the previous compiler), use `error.input.file`.\n *\n * @example\n * // Catching and checking syntax error\n * try {\n *   postcss.parse('a{')\n * } catch (error) {\n *   if (error.name === 'CssSyntaxError') {\n *     error //=> CssSyntaxError\n *   }\n * }\n *\n * @example\n * // Raising error from plugin\n * throw node.error('Unknown variable', { plugin: 'postcss-vars' })\n */\nclass CssSyntaxError extends Error {\n  /**\n   * @param {string} message  Error message.\n   * @param {number} [line]   Source line of the error.\n   * @param {number} [column] Source column of the error.\n   * @param {string} [source] Source code of the broken file.\n   * @param {string} [file]   Absolute path to the broken file.\n   * @param {string} [plugin] PostCSS plugin name, if error came from plugin.\n   */\n  constructor (message, line, column, source, file, plugin) {\n    super(message)\n\n    /**\n     * Always equal to `'CssSyntaxError'`. You should always check error type\n     * by `error.name === 'CssSyntaxError'`\n     * instead of `error instanceof CssSyntaxError`,\n     * because npm could have several PostCSS versions.\n     *\n     * @type {string}\n     *\n     * @example\n     * if (error.name === 'CssSyntaxError') {\n     *   error //=> CssSyntaxError\n     * }\n     */\n    this.name = 'CssSyntaxError'\n    /**\n     * Error message.\n     *\n     * @type {string}\n     *\n     * @example\n     * error.message //=> 'Unclosed block'\n     */\n    this.reason = message\n\n    if (file) {\n      /**\n       * Absolute path to the broken file.\n       *\n       * @type {string}\n       *\n       * @example\n       * error.file       //=> 'a.sass'\n       * error.input.file //=> 'a.css'\n       */\n      this.file = file\n    }\n    if (source) {\n      /**\n       * Source code of the broken file.\n       *\n       * @type {string}\n       *\n       * @example\n       * error.source       //=> 'a { b {} }'\n       * error.input.column //=> 'a b { }'\n       */\n      this.source = source\n    }\n    if (plugin) {\n      /**\n       * Plugin name, if error came from plugin.\n       *\n       * @type {string}\n       *\n       * @example\n       * error.plugin //=> 'postcss-vars'\n       */\n      this.plugin = plugin\n    }\n    if (typeof line !== 'undefined' && typeof column !== 'undefined') {\n      /**\n       * Source line of the error.\n       *\n       * @type {number}\n       *\n       * @example\n       * error.line       //=> 2\n       * error.input.line //=> 4\n       */\n      this.line = line\n      /**\n       * Source column of the error.\n       *\n       * @type {number}\n       *\n       * @example\n       * error.column       //=> 1\n       * error.input.column //=> 4\n       */\n      this.column = column\n    }\n\n    this.setMessage()\n\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, CssSyntaxError)\n    }\n  }\n\n  setMessage () {\n    /**\n     * Full error text in the GNU error format\n     * with plugin, file, line and column.\n     *\n     * @type {string}\n     *\n     * @example\n     * error.message //=> 'a.css:1:1: Unclosed block'\n     */\n    this.message = this.plugin ? this.plugin + ': ' : ''\n    this.message += this.file ? this.file : '<css input>'\n    if (typeof this.line !== 'undefined') {\n      this.message += ':' + this.line + ':' + this.column\n    }\n    this.message += ': ' + this.reason\n  }\n\n  /**\n   * Returns a few lines of CSS source that caused the error.\n   *\n   * If the CSS has an input source map without `sourceContent`,\n   * this method will return an empty string.\n   *\n   * @param {boolean} [color] Whether arrow will be colored red by terminal\n   *                          color codes. By default, PostCSS will detect\n   *                          color support by `process.stdout.isTTY`\n   *                          and `process.env.NODE_DISABLE_COLORS`.\n   *\n   * @example\n   * error.showSourceCode() //=> \"  4 | }\n   *                        //      5 | a {\n   *                        //    > 6 |   bad\n   *                        //        |   ^\n   *                        //      7 | }\n   *                        //      8 | b {\"\n   *\n   * @return {string} Few lines of CSS source that caused the error.\n   */\n  showSourceCode (color) {\n    if (!this.source) return ''\n\n    let css = this.source\n    if (terminalHighlight) {\n      if (typeof color === 'undefined') color = supportsColor.stdout\n      if (color) css = terminalHighlight(css)\n    }\n\n    let lines = css.split(/\\r?\\n/)\n    let start = Math.max(this.line - 3, 0)\n    let end = Math.min(this.line + 2, lines.length)\n\n    let maxWidth = String(end).length\n\n    function mark (text) {\n      if (color && chalk.red) {\n        return chalk.red.bold(text)\n      }\n      return text\n    }\n    function aside (text) {\n      if (color && chalk.gray) {\n        return chalk.gray(text)\n      }\n      return text\n    }\n\n    return lines.slice(start, end).map((line, index) => {\n      let number = start + 1 + index\n      let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | '\n      if (number === this.line) {\n        let spacing = aside(gutter.replace(/\\d/g, ' ')) +\n          line.slice(0, this.column - 1).replace(/[^\\t]/g, ' ')\n        return mark('>') + aside(gutter) + line + '\\n ' + spacing + mark('^')\n      }\n      return ' ' + aside(gutter) + line\n    }).join('\\n')\n  }\n\n  /**\n   * Returns error position, message and source code of the broken part.\n   *\n   * @example\n   * error.toString() //=> \"CssSyntaxError: app.css:1:1: Unclosed block\n   *                  //    > 1 | a {\n   *                  //        | ^\"\n   *\n   * @return {string} Error position, message and source code.\n   */\n  toString () {\n    let code = this.showSourceCode()\n    if (code) {\n      code = '\\n\\n' + code + '\\n'\n    }\n    return this.name + ': ' + this.message + code\n  }\n\n  /**\n   * @memberof CssSyntaxError#\n   * @member {Input} input Input object with PostCSS internal information\n   *                       about input file. If input has source map\n   *                       from previous tool, PostCSS will use origin\n   *                       (for example, Sass) source. You can use this\n   *                       object to get PostCSS input source.\n   *\n   * @example\n   * error.input.file //=> 'a.css'\n   * error.file       //=> 'a.sass'\n   */\n}\n\nexport default CssSyntaxError\n"],"file":"css-syntax-error.js"}