linter-bundle 5.1.0 → 6.1.0

package/stylelint/plugins/stylelint-15.11.0-stylistic/style-search/index.cjs

@@ -0,0 +1,216 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const SKIP = 'skip';
+const CHECK = 'check';
+const ONLY = 'only';
+
+module.exports = function (options, callback) {
+	const source = options.source;
+	const target = options.target;
+
+	const skipComments = (options.comments) ? options.comments === SKIP : true;
+	const skipStrings = (options.strings) ? options.strings === SKIP : true;
+	const skipFunctionNames = (options.functionNames) ? options.functionNames === SKIP : true;
+	const skipFunctionArguments = options.functionArguments === SKIP;
+	const skipParentheticals = options.parentheticals === SKIP;
+
+	let onceOptionUsed = false;
+	for (const key of Object.keys(options)) {
+		if (options[key] !== ONLY) { continue; }
+		if (!onceOptionUsed) {
+			onceOptionUsed = true;
+		}
+		else {
+			throw new Error('Only one syntax feature option can be the "only" one to check');
+		}
+	}
+
+	const onlyComments = options.comments === ONLY;
+	const onlyStrings = options.strings === ONLY;
+	const onlyFunctionNames = options.functionNames === ONLY;
+	const onlyFunctionArguments = options.functionArguments === ONLY;
+	const onlyParentheticals = options.parentheticals === ONLY;
+
+	let insideString = false;
+	let insideComment = false;
+	let insideSingleLineComment = false;
+	let insideParens = false;
+	let insideFunctionArguments = false;
+	let openingParenCount = 0;
+	let matchCount = 0;
+	let openingQuote;
+
+	const targetIsArray = Array.isArray(target);
+
+	// If the target is just a string, it is easy to check whether
+	// some index of the source matches it.
+	// If the target is an array of strings, though, we have to
+	// check whether some index of the source matches *any* of
+	// those target strings (stopping after the first match).
+	const getMatch = (function () {
+		if (!targetIsArray) {
+			return getMatchBase.bind(null, target);
+		}
+		return function (index) {
+			for (let ti = 0, tl = target.length; ti < tl; ti++) {
+				const checkResult = getMatchBase(target[ti], index);
+				if (checkResult) { return checkResult; }
+			}
+			return false;
+		};
+	}());
+
+	/**
+	 *
+	 * @param targetString
+	 * @param index
+	 */
+	function getMatchBase (targetString, index) {
+		const targetStringLength = targetString.length;
+
+		// Target is a single character
+		if (targetStringLength === 1 && source[index] !== targetString) { return false; }
+
+		// Target is multiple characters
+		if (source.substr(index, targetStringLength) !== targetString) { return false; }
+
+		return {
+			insideParens,
+			insideFunctionArguments,
+			insideComment,
+			insideString,
+			startIndex: index,
+			endIndex: index + targetStringLength,
+			target: targetString
+		};
+	}
+
+	for (let i = 0, l = source.length; i < l; i++) {
+		const currentChar = source[i];
+
+		// Register the beginning of a comment
+		if (
+			!insideString && !insideComment &&
+      currentChar === '/' &&
+      source[i - 1] !== '\\' // escaping
+		) {
+			// standard comments
+			if (source[i + 1] === '*') {
+				insideComment = true;
+				continue;
+			}
+			// single-line comments
+			if (source[i + 1] === '/') {
+				insideComment = true;
+				insideSingleLineComment = true;
+				continue;
+			}
+		}
+
+		if (insideComment) {
+			// Register the end of a standard comment
+			if (
+				!insideSingleLineComment &&
+        currentChar === '*' &&
+        source[i - 1] !== '\\' && // escaping
+        source[i + 1] === '/' &&
+        source[i - 1] !== '/' // don't end if it's /*/
+			) {
+				insideComment = false;
+				continue;
+			}
+
+			// Register the end of a single-line comment
+			if (
+				insideSingleLineComment &&
+        currentChar === '\n'
+			) {
+				insideComment = false;
+				insideSingleLineComment = false;
+			}
+
+			if (skipComments) { continue; }
+		}
+
+		// Register the beginning of a string
+		if (!insideComment && !insideString && (currentChar === '"' || currentChar === "'")) {
+			if (source[i - 1] === '\\') { continue; } // escaping
+
+			openingQuote = currentChar;
+			insideString = true;
+
+			// For string-quotes rule
+			if (target === currentChar) { handleMatch(getMatch(i)); }
+			continue;
+		}
+
+		if (insideString) {
+			// Register the end of a string
+			if (currentChar === openingQuote) {
+				if (source[i - 1] === '\\') { continue; } // escaping
+				insideString = false;
+				continue;
+			}
+
+			if (skipStrings) { continue; }
+		}
+
+		// Register the beginning of parens/functions
+		if (!insideString && !insideComment && currentChar === '(') {
+			// Keep track of opening parentheticals so that we
+			// know when the outermost function (possibly
+			// containing nested functions) is closing
+			openingParenCount++;
+
+			insideParens = true;
+			// Only inside a function if there is a function name
+			// before the opening paren
+			if ((/[A-Za-z]/).test(source[i - 1])) {
+				insideFunctionArguments = true;
+			}
+
+			if (target === '(') { handleMatch(getMatch(i)); }
+			continue;
+		}
+
+		if (insideParens) {
+			// Register the end of a function
+			if (currentChar === ')') {
+				openingParenCount--;
+				// Do this here so the match is still technically inside a function
+				if (target === ')') { handleMatch(getMatch(i)); }
+				if (openingParenCount === 0) {
+					insideParens = false;
+					insideFunctionArguments = false;
+				}
+				continue;
+			}
+		}
+
+		const isFunctionName = (/^[A-Za-z]*\(/).test(source.slice(i));
+		if (skipFunctionNames && isFunctionName) { continue; }
+		if (onlyFunctionNames && !isFunctionName) { continue; }
+
+		const match = getMatch(i);
+
+		if (!match) { continue; }
+		handleMatch(match);
+		if (options.once) { return; }
+	}
+
+	/**
+	 *
+	 * @param match
+	 */
+	function handleMatch (match) {
+		if (onlyParentheticals && !insideParens) { return; }
+		if (skipParentheticals && insideParens) { return; }
+		if (onlyFunctionArguments && !insideFunctionArguments) { return; }
+		if (skipFunctionArguments && insideFunctionArguments) { return; }
+		if (onlyStrings && !insideString) { return; }
+		if (onlyComments && !insideComment) { return; }
+		matchCount++;
+		callback(match, matchCount);
+	}
+};

package/stylelint/plugins/stylelint-15.11.0-stylistic/utils/addEmptyLineAfter.cjs

@@ -0,0 +1,30 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+/**
+ * Add an empty line after a node. Mutates the node.
+ *
+ * @template {import('postcss').Rule | import('postcss').AtRule} T
+ * @param {T} node
+ * @param {string} newline
+ * @returns {T}
+ */
+module.exports = function addEmptyLineAfter (node, newline) {
+	const { raws } = node;
+
+	if (typeof raws.after !== 'string') {
+		return node;
+	}
+
+	const spaces = raws.after.split(';');
+	const after = spaces[spaces.length - 1] || '';
+
+	if (!(/\r?\n/).test(after)) {
+		raws.after += newline.repeat(2);
+	}
+	else {
+		raws.after = raws.after.replace(/(\r?\n)/, `${newline}$1`);
+	}
+
+	return node;
+};

package/stylelint/plugins/stylelint-15.11.0-stylistic/utils/hasEmptyBlock.cjs

@@ -0,0 +1,14 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const hasBlock = require('stylelint/lib/utils/hasBlock.cjs');
+
+/**
+ * Check if a statement has an empty block.
+ *
+ * @param {import('postcss').Rule | import('postcss').AtRule} statement - postcss rule or at-rule node
+ * @returns {boolean} True if the statement has a block and it is empty
+ */
+module.exports = function hasEmptyBlock (statement) {
+	return hasBlock(statement) && statement.nodes.length === 0;
+};

package/stylelint/plugins/stylelint-15.11.0-stylistic/utils/nextNonCommentNode.cjs

@@ -0,0 +1,21 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+/** @typedef {import('postcss').Node} PostcssNode */
+
+/**
+ * Get the next non-comment node in a PostCSS AST
+ * at or after a given node.
+ *
+ * @param {PostcssNode | void} startNode
+ * @returns {PostcssNode | null}
+ */
+module.exports = function nextNonCommentNode (startNode) {
+	if (!startNode || !startNode.next) { return null; }
+
+	if (startNode.type === 'comment') {
+		return nextNonCommentNode(startNode.next());
+	}
+
+	return startNode;
+};

package/stylelint/plugins/stylelint-15.11.0-stylistic/utils/removeEmptyLinesAfter.cjs

@@ -0,0 +1,16 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+/**
+ * Remove empty lines before a node. Mutates the node.
+ *
+ * @template {import('postcss').Rule | import('postcss').AtRule} T
+ * @param {T} node
+ * @param {string} newline
+ * @returns {T}
+ */
+module.exports = function removeEmptyLinesAfter (node, newline) {
+	node.raws.after = node.raws.after ? node.raws.after.replace(/(\r?\n\s*\n)+/g, newline) : '';
+
+	return node;
+};

package/stylelint/plugins/stylelint-15.11.0-stylistic/utils/whitespaceChecker.cjs

@@ -0,0 +1,361 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const configurationError = require('stylelint/lib/utils/configurationError.cjs');
+const isSingleLineString = require('stylelint/lib/utils/isSingleLineString.cjs');
+const isWhitespace = require('stylelint/lib/utils/isWhitespace.cjs');
+const { assertFunction, isNullish } = require('stylelint/lib/utils/validateTypes.cjs');
+
+/**
+ * @typedef {(message: string) => string} MessageFunction
+ */
+
+/**
+ * @typedef {object} Messages
+ * @property {MessageFunction} [expectedBefore]
+ * @property {MessageFunction} [rejectedBefore]
+ * @property {MessageFunction} [expectedAfter]
+ * @property {MessageFunction} [rejectedAfter]
+ * @property {MessageFunction} [expectedBeforeSingleLine]
+ * @property {MessageFunction} [rejectedBeforeSingleLine]
+ * @property {MessageFunction} [expectedBeforeMultiLine]
+ * @property {MessageFunction} [rejectedBeforeMultiLine]
+ * @property {MessageFunction} [expectedAfterSingleLine]
+ * @property {MessageFunction} [rejectedAfterSingleLine]
+ * @property {MessageFunction} [expectedAfterMultiLine]
+ * @property {MessageFunction} [rejectedAfterMultiLine]
+ */
+
+/**
+ * @typedef {object} WhitespaceCheckerArgs
+ * @property {string} source - The source string
+ * @property {number} index - The index of the character to check before
+ * @property {(message: string) => void} err - If a problem is found, this callback
+ * will be invoked with the relevant warning message.
+ * Typically this callback will report() the problem.
+ * @property {string} [errTarget] - If a problem is found, this string
+ * will be sent to the relevant warning message.
+ * @property {string} [lineCheckStr] - Single- and multi-line checkers
+ * will use this string to determine whether they should proceed,
+ * i.e. if this string is one line only, single-line checkers will check,
+ * multi-line checkers will ignore.
+ * If none is passed, they will use `source`.
+ * @property {boolean} [onlyOneChar=false] - Only check *one* character before.
+ * By default, "always-*" checks will look for the `targetWhitespace` one
+ * before and then ensure there is no whitespace two before. This option
+ * bypasses that second check.
+ * @property {boolean} [allowIndentation=false] - Allow arbitrary indentation
+ * between the `targetWhitespace` (almost definitely a newline) and the `index`.
+ * With this option, the checker will see if a newline *begins* the whitespace before
+ * the `index`.
+ */
+
+/**
+ * @typedef {(args: WhitespaceCheckerArgs) => void} WhitespaceChecker
+ */
+
+/**
+ * @typedef {{
+ *   before: WhitespaceChecker,
+ *   beforeAllowingIndentation: WhitespaceChecker,
+ *   after: WhitespaceChecker,
+ *   afterOneOnly: WhitespaceChecker,
+ * }} WhitespaceCheckers
+ */
+
+/**
+ * Create a whitespaceChecker, which exposes the following functions:
+ * - `before()`
+ * - `beforeAllowingIndentation()`
+ * - `after()`
+ * - `afterOneOnly()`
+ *
+ * @param {"space" | "newline"} targetWhitespace - This is a keyword instead
+ * of the actual character (e.g. " ") in order to accommodate
+ * different styles of newline ("\n" vs "\r\n")
+ * @param {"always" | "never" | "always-single-line" | "always-multi-line" | "never-single-line" | "never-multi-line"} expectation
+ * @param {Messages} messages - An object of message functions;
+ * calling `before*()` or `after*()` and the `expectation` that is passed
+ * determines which message functions are required
+ *
+ * @returns {WhitespaceCheckers} The checker, with its exposed checking functions
+ */
+module.exports = function whitespaceChecker (targetWhitespace, expectation, messages) {
+	// Keep track of active arguments in order to avoid passing
+	// too much stuff around, making signatures long and confusing.
+	// This variable gets reset anytime a checking function is called.
+	/** @type {WhitespaceCheckerArgs} */
+	let activeArgs;
+
+	/**
+	 * Check for whitespace *before* a character.
+	 * @type {WhitespaceChecker}
+	 */
+	function before ({
+		source,
+		index,
+		err,
+		errTarget,
+		lineCheckStr,
+		onlyOneChar = false,
+		allowIndentation = false
+	}) {
+		activeArgs = {
+			source,
+			index,
+			err,
+			errTarget,
+			onlyOneChar,
+			allowIndentation
+		};
+
+		switch (expectation) {
+			case 'always':
+				expectBefore();
+				break;
+			case 'never':
+				rejectBefore();
+				break;
+			case 'always-single-line':
+				if (!isSingleLineString(lineCheckStr || source)) {
+					return;
+				}
+
+				expectBefore(messages.expectedBeforeSingleLine);
+				break;
+			case 'never-single-line':
+				if (!isSingleLineString(lineCheckStr || source)) {
+					return;
+				}
+
+				rejectBefore(messages.rejectedBeforeSingleLine);
+				break;
+			case 'always-multi-line':
+				if (isSingleLineString(lineCheckStr || source)) {
+					return;
+				}
+
+				expectBefore(messages.expectedBeforeMultiLine);
+				break;
+			case 'never-multi-line':
+				if (isSingleLineString(lineCheckStr || source)) {
+					return;
+				}
+
+				rejectBefore(messages.rejectedBeforeMultiLine);
+				break;
+			default:
+				throw configurationError(`Unknown expectation "${expectation}"`);
+		}
+	}
+
+	/**
+	 * Check for whitespace *after* a character.
+	 * @type {WhitespaceChecker}
+	 */
+	function after ({ source, index, err, errTarget, lineCheckStr, onlyOneChar = false }) {
+		activeArgs = { source, index, err, errTarget, onlyOneChar };
+
+		switch (expectation) {
+			case 'always':
+				expectAfter();
+				break;
+			case 'never':
+				rejectAfter();
+				break;
+			case 'always-single-line':
+				if (!isSingleLineString(lineCheckStr || source)) {
+					return;
+				}
+
+				expectAfter(messages.expectedAfterSingleLine);
+				break;
+			case 'never-single-line':
+				if (!isSingleLineString(lineCheckStr || source)) {
+					return;
+				}
+
+				rejectAfter(messages.rejectedAfterSingleLine);
+				break;
+			case 'always-multi-line':
+				if (isSingleLineString(lineCheckStr || source)) {
+					return;
+				}
+
+				expectAfter(messages.expectedAfterMultiLine);
+				break;
+			case 'never-multi-line':
+				if (isSingleLineString(lineCheckStr || source)) {
+					return;
+				}
+
+				rejectAfter(messages.rejectedAfterMultiLine);
+				break;
+			default:
+				throw configurationError(`Unknown expectation "${expectation}"`);
+		}
+	}
+
+	/**
+	 * @type {WhitespaceChecker}
+	 */
+	function beforeAllowingIndentation (obj) {
+		before({ ...obj, allowIndentation: true });
+	}
+
+	/**
+	 *
+	 * @param messageFunction
+	 */
+	function expectBefore (messageFunction = messages.expectedBefore) {
+		if (activeArgs.allowIndentation) {
+			expectBeforeAllowingIndentation(messageFunction);
+
+			return;
+		}
+
+		const _activeArgs = activeArgs;
+		const source = _activeArgs.source;
+		const index = _activeArgs.index;
+
+		const oneCharBefore = source[index - 1];
+		const twoCharsBefore = source[index - 2];
+
+		if (isNullish(oneCharBefore)) {
+			return;
+		}
+
+		if (
+			targetWhitespace === 'space' &&
+			oneCharBefore === ' ' &&
+			(activeArgs.onlyOneChar || isNullish(twoCharsBefore) || !isWhitespace(twoCharsBefore))
+		) {
+			return;
+		}
+
+		assertFunction(messageFunction);
+		activeArgs.err(messageFunction(activeArgs.errTarget || source.charAt(index)));
+	}
+
+	/**
+	 *
+	 * @param messageFunction
+	 */
+	function expectBeforeAllowingIndentation (messageFunction = messages.expectedBefore) {
+		const _activeArgs2 = activeArgs;
+		const source = _activeArgs2.source;
+		const index = _activeArgs2.index;
+		const error = _activeArgs2.err;
+
+		const expectedChar = targetWhitespace === 'newline' ? '\n' : undefined;
+		let i = index - 1;
+
+		while (source[i] !== expectedChar) {
+			if (source[i] === '\t' || source[i] === ' ') {
+				i--;
+				continue;
+			}
+
+			assertFunction(messageFunction);
+			error(messageFunction(activeArgs.errTarget || source.charAt(index)));
+
+			return;
+		}
+	}
+
+	/**
+	 *
+	 * @param messageFunction
+	 */
+	function rejectBefore (messageFunction = messages.rejectedBefore) {
+		const _activeArgs3 = activeArgs;
+		const source = _activeArgs3.source;
+		const index = _activeArgs3.index;
+
+		const oneCharBefore = source[index - 1];
+
+		if (!isNullish(oneCharBefore) && isWhitespace(oneCharBefore)) {
+			assertFunction(messageFunction);
+			activeArgs.err(messageFunction(activeArgs.errTarget || source.charAt(index)));
+		}
+	}
+
+	/**
+	 * @type {WhitespaceChecker}
+	 */
+	function afterOneOnly (obj) {
+		after({ ...obj, onlyOneChar: true });
+	}
+
+	/**
+	 *
+	 * @param messageFunction
+	 */
+	function expectAfter (messageFunction = messages.expectedAfter) {
+		const _activeArgs4 = activeArgs;
+		const source = _activeArgs4.source;
+		const index = _activeArgs4.index;
+
+		const oneCharAfter = source[index + 1];
+		const twoCharsAfter = source[index + 2];
+		const threeCharsAfter = source[index + 3];
+
+		if (isNullish(oneCharAfter)) {
+			return;
+		}
+
+		if (targetWhitespace === 'newline') {
+			// If index is followed by a Windows CR-LF ...
+			if (
+				oneCharAfter === '\r' &&
+				twoCharsAfter === '\n' &&
+				(activeArgs.onlyOneChar || isNullish(threeCharsAfter) || !isWhitespace(threeCharsAfter))
+			) {
+				return;
+			}
+
+			// If index is followed by a Unix LF ...
+			if (
+				oneCharAfter === '\n' &&
+				(activeArgs.onlyOneChar || isNullish(twoCharsAfter) || !isWhitespace(twoCharsAfter))
+			) {
+				return;
+			}
+		}
+
+		if (
+			targetWhitespace === 'space' &&
+			oneCharAfter === ' ' &&
+			(activeArgs.onlyOneChar || isNullish(twoCharsAfter) || !isWhitespace(twoCharsAfter))
+		) {
+			return;
+		}
+
+		assertFunction(messageFunction);
+		activeArgs.err(messageFunction(activeArgs.errTarget || source.charAt(index)));
+	}
+
+	/**
+	 *
+	 * @param messageFunction
+	 */
+	function rejectAfter (messageFunction = messages.rejectedAfter) {
+		const _activeArgs5 = activeArgs;
+		const source = _activeArgs5.source;
+		const index = _activeArgs5.index;
+
+		const oneCharAfter = source[index + 1];
+
+		if (!isNullish(oneCharAfter) && isWhitespace(oneCharAfter)) {
+			assertFunction(messageFunction);
+			activeArgs.err(messageFunction(activeArgs.errTarget || source.charAt(index)));
+		}
+	}
+
+	return {
+		before,
+		beforeAllowingIndentation,
+		after,
+		afterOneOnly
+	};
+};

package/stylelint/plugins/stylelint-selector-no-empty.js

@@ -53,9 +53,9 @@ export default stylelint.createPlugin(ruleName, (enabled) => {
 /**
  * Splits the selectors based on a specified delimiter and filters out empty selectors.
  *
- * @param {string[]} splittedSelectors - The selectors to be split.
- * @param {string} splitBy - The delimiter to split the selectors.
- * @returns {string[]} The split and filtered selectors.
+ * @param {string[]} splittedSelectors - The selectors to be split
+ * @param {string} splitBy - The delimiter to split the selectors
+ * @returns {string[]} The split and filtered selectors
  */
 function getSplittedSelectors (splittedSelectors, splitBy) {
 	const res = [];
@@ -77,9 +77,9 @@ function getSplittedSelectors (splittedSelectors, splitBy) {
 /**
  * Checks for empty selectors within the space-split selectors.
  *
- * @param {string[]} spaceSplittedSelectors - The space-split selectors.
- * @param {stylelint.PostcssResult} result - The result object.
- * @param {import('postcss').Rule} rule - The current rule.
+ * @param {string[]} spaceSplittedSelectors - The space-split selectors
+ * @param {stylelint.PostcssResult} result - The result object
+ * @param {import('postcss').Rule} rule - The current rule
  */
 function checkEmptySelector (spaceSplittedSelectors, result, rule) {
 	for (let sp of spaceSplittedSelectors) {
@@ -101,8 +101,8 @@ function checkEmptySelector (spaceSplittedSelectors, result, rule) {
 /**
  * Reports an error for an empty selector.
  *
- * @param {import('postcss').Rule} rule - The current rule.
- * @param {stylelint.PostcssResult} result - The result object.
+ * @param {import('postcss').Rule} rule - The current rule
+ * @param {stylelint.PostcssResult} result - The result object
  */
 function reportError (rule, result) {
 	stylelint.utils.report({