@alexlit/lint-kit 183.4.0 → 183.6.0

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isStandardSyntaxValue.mjs

@@ -0,0 +1,51 @@
+import hasInterpolation from './hasInterpolation.mjs';
+
+/**
+ * Check whether a value is standard
+ *
+ * @param {string} value
+ * @returns {boolean}
+ */
+export default function isStandardSyntaxValue(value) {
+	let normalizedValue = value;
+
+	// Ignore operators before variables (example -$variable)
+	if (/^[-+*/]/.test(value.charAt(0))) {
+		normalizedValue = normalizedValue.slice(1);
+	}
+
+	// SCSS variable (example $variable)
+	// styled component interpolation (example ${foo => foo.bar})
+	if (normalizedValue.startsWith('$')) {
+		return false;
+	}
+
+	// SCSS namespace (example namespace.$variable)
+	if (/^.+\.\$/.test(value)) {
+		return false;
+	}
+
+	// SCSS namespace (example namespace.function-name())
+	if (/^.+\.[-\w]+\(/.test(value)) {
+		return false;
+	}
+
+	// Less variable
+	if (normalizedValue.startsWith('@')) {
+		return false;
+	}
+
+	// SCSS or Less interpolation
+	if (hasInterpolation(normalizedValue)) {
+		return false;
+	}
+
+	// WebExtension replacement keyword used by Chrome/Firefox
+	// more information: https://developer.chrome.com/extensions/i18n
+	// and https://github.com/stylelint/stylelint/issues/4707
+	if (/__MSG_\S+__/.test(value)) {
+		return false;
+	}
+
+	return true;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isUnicodeRangeDescriptor.mjs

@@ -0,0 +1,24 @@
+import { isAtRule } from './typeGuards.mjs';
+
+const IS_UNICODE_RANGE = /^unicode-range$/i;
+const IS_AT_FONT_FACE = /^font-face$/i;
+
+/**
+ * Check whether a declaration is the `unicode-range` descriptor of an `@font-face` rule.
+ *
+ * @param {import('postcss').Declaration} decl
+ * @returns {boolean}
+ */
+export default function isUnicodeRangeDescriptor(decl) {
+	if (!IS_UNICODE_RANGE.test(decl.prop)) {
+		return false;
+	}
+
+	const parent = decl.parent;
+
+	if (!parent || !isAtRule(parent)) {
+		return false;
+	}
+
+	return IS_AT_FONT_FACE.test(parent.name);
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isUnicodeSupported.mjs

@@ -0,0 +1,26 @@
+import process from 'node:process';
+
+/**
+ * Originally copied from https://github.com/sindresorhus/is-unicode-supported/blob/506f27260df3636555714bf10ed40ab9e6a6c96e/index.js
+ * @version 2.0.0
+ * @summary Detect whether the terminal supports Unicode
+ * @see https://github.com/sindresorhus/is-unicode-supported/pull/1#issuecomment-827321546
+ * @see microsoft/terminal#13680
+ */
+export default function isUnicodeSupported() {
+	if (process.platform !== 'win32') {
+		return process.env.TERM !== 'linux'; // Linux console (kernel)
+	}
+
+	return (
+		Boolean(process.env.WT_SESSION) || // Windows Terminal
+		Boolean(process.env.TERMINUS_SUBLIME) || // Terminus (<0.2.27)
+		process.env.ConEmuTask === '{cmd::Cmder}' || // ConEmu and cmder
+		process.env.TERM_PROGRAM === 'Terminus-Sublime' ||
+		process.env.TERM_PROGRAM === 'vscode' ||
+		process.env.TERM === 'xterm-256color' ||
+		process.env.TERM === 'alacritty' ||
+		process.env.TERMINAL_EMULATOR === 'JetBrains-JediTerm' ||
+		process.env.TERM?.startsWith('rxvt-unicode') // fork of rxvt
+	);
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isUrlFunction.mjs

@@ -0,0 +1,9 @@
+import { isValueFunction } from './typeGuards.mjs';
+
+/**
+ * @param {import('postcss-value-parser').Node} node
+ * @returns {node is import('postcss-value-parser').FunctionNode}
+ */
+export default function isUrlFunction(node) {
+	return isValueFunction(node) && node.value.toLowerCase() === 'url';
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isValidFontSize.mjs

@@ -0,0 +1,38 @@
+import valueParser from 'postcss-value-parser';
+
+import { fontSizeKeywords } from '../reference/keywords.mjs';
+import { lengthUnits } from '../reference/units.mjs';
+
+/**
+ * Check if a word is a font-size value.
+ *
+ * @param {string} word
+ * @returns {boolean}
+ */
+export default function isValidFontSize(word) {
+	if (!word) {
+		return false;
+	}
+
+	if (fontSizeKeywords.has(word)) {
+		return true;
+	}
+
+	const numberUnit = valueParser.unit(word);
+
+	if (!numberUnit) {
+		return false;
+	}
+
+	const unit = numberUnit.unit;
+
+	if (unit === '%') {
+		return true;
+	}
+
+	if (lengthUnits.has(unit.toLowerCase())) {
+		return true;
+	}
+
+	return false;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isValidHex.mjs

@@ -0,0 +1,11 @@
+const IS_VALID_HEX = /^#(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/i;
+
+/**
+ * Check if a value is a valid 3, 4, 6 or 8 digit hex
+ *
+ * @param {string} value
+ * @returns {boolean}
+ */
+export default function isValidHex(value) {
+	return IS_VALID_HEX.test(value);
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isValidIdentifier.mjs

@@ -0,0 +1,39 @@
+const ISO_10646_CHARACTERS = /\\[0-9a-f]{1,6}(\\r\\n|[ \t\r\n\f])?/gi;
+const SINGLE_ESCAPED_CHARACTERS = /\\./g;
+const NON_WORD_OR_DASH = /[^\w-]/;
+const DIGIT = /\d/;
+
+/**
+ * Returns whether a string is a valid CSS identifier
+ * (i.e. only alphanumeric characters, `-`, and `_`;
+ * does not have a leading digit, leading dash followed by digit, or two leading dashes)
+ * furthermore, any escaped or ISO 10646 characters are allowed.
+ * @see https://www.w3.org/TR/CSS2/syndata.html#value-def-identifier
+ * @param {string} ident
+ * @returns {boolean}
+ */
+export default function isValidIdentifier(ident) {
+	if (!ident || ident.trim() === '') {
+		return false;
+	}
+
+	// trims, removes ISO 10646 characters, and singly-escaped characters
+	const trimmedIdent = ident
+		.trim()
+		.replace(ISO_10646_CHARACTERS, '')
+		.replace(SINGLE_ESCAPED_CHARACTERS, '');
+
+	if (NON_WORD_OR_DASH.test(trimmedIdent)) {
+		return false;
+	}
+
+	if (DIGIT.test(trimmedIdent.charAt(0))) {
+		return false;
+	}
+
+	if (trimmedIdent.charAt(0) === '-' && DIGIT.test(trimmedIdent.charAt(1))) {
+		return false;
+	}
+
+	return true;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isVarFunction.mjs

@@ -0,0 +1,9 @@
+import { isValueFunction } from './typeGuards.mjs';
+
+/**
+ * @param {import('postcss-value-parser').Node} node
+ * @returns {node is import('postcss-value-parser').FunctionNode}
+ */
+export default function isVarFunction(node) {
+	return isValueFunction(node) && node.value.toLowerCase() === 'var';
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isVariable.mjs

@@ -0,0 +1,9 @@
+/**
+ * Check whether a word is a variable i.e var(--custom-property).
+ *
+ * @param {string} word
+ * @returns {boolean}
+ */
+export default function isVariable(word) {
+	return word.toLowerCase().startsWith('var(');
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isWhitespace.mjs

@@ -0,0 +1,9 @@
+/**
+ * Check if a character is whitespace.
+ *
+ * @param {string} char
+ * @returns {boolean}
+ */
+export default function isWhitespace(char) {
+	return [' ', '\n', '\t', '\r', '\f'].includes(char);
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/matchesStringOrRegExp.mjs

@@ -0,0 +1,97 @@
+/**
+ * Compares a string to a second value that, if it fits a certain convention,
+ * is converted to a regular expression before the comparison.
+ * If it doesn't fit the convention, then two strings are compared.
+ *
+ * Any strings starting and ending with `/` are interpreted
+ * as regular expressions.
+ *
+ * @typedef {{match: string, pattern: (string | RegExp), substring: string} | false} MatchResult
+ *
+ * @param {string | Array<string>} input
+ * @param {string | RegExp | Array<string | RegExp>} comparison
+ * @returns {MatchResult}
+ */
+export default function matchesStringOrRegExp(input, comparison) {
+	if (!Array.isArray(input)) {
+		return testAgainstStringOrRegExpOrArray(input, comparison);
+	}
+
+	for (const inputItem of input) {
+		const testResult = testAgainstStringOrRegExpOrArray(inputItem, comparison);
+
+		if (testResult) {
+			return testResult;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * @param {string} value
+ * @param {string | RegExp | Array<string | RegExp>} comparison
+ * @returns {MatchResult}
+ */
+function testAgainstStringOrRegExpOrArray(value, comparison) {
+	if (!Array.isArray(comparison)) {
+		return testAgainstStringOrRegExp(value, comparison);
+	}
+
+	for (const comparisonItem of comparison) {
+		const testResult = testAgainstStringOrRegExp(value, comparisonItem);
+
+		if (testResult) {
+			return testResult;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * @param {string} value
+ * @param {RegExp} pattern
+ * @returns {MatchResult}
+ */
+function matchValue(value, pattern) {
+	const match = value.match(pattern);
+
+	return match ? { match: value, pattern, substring: match[0] ?? '' } : false;
+}
+
+/**
+ * @param {string} value
+ * @param {string | RegExp} comparison
+ * @returns {MatchResult}
+ */
+function testAgainstStringOrRegExp(value, comparison) {
+	// If it's a RegExp, test directly
+	if (comparison instanceof RegExp) {
+		return matchValue(value, comparison);
+	}
+
+	// Check if it's RegExp in a string
+	const regexFlag = 'i';
+	const comparisonIsRegex =
+		comparison.startsWith('/') &&
+		(comparison.endsWith('/') || comparison.endsWith(`/${regexFlag}`));
+
+	// If so, create a new RegExp from it
+	if (comparisonIsRegex) {
+		const pattern = comparison.endsWith(regexFlag)
+			? new RegExp(comparison.slice(1, -2), regexFlag)
+			: new RegExp(comparison.slice(1, -1));
+
+		const result = matchValue(value, pattern);
+
+		if (result) {
+			result.pattern = comparison;
+		}
+
+		return result;
+	}
+
+	// Otherwise, it's a string. Do a strict comparison
+	return value === comparison ? { match: value, pattern: comparison, substring: value } : false;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/mergeSyntaxDefinitions.mjs

@@ -0,0 +1,137 @@
+/** @typedef {Record<string, {prelude?: string | undefined, descriptors?: Record<string, string> | undefined}>} AtRuleDefinitions */
+/** @typedef {Record<string, string>} PropertyDefinitions */
+/** @typedef {Record<string, string>} TypeDefinitions */
+/** @typedef {Array<string>} CSSWideKeywords */
+/** @typedef {{atrules?: AtRuleDefinitions | undefined, properties?: PropertyDefinitions | undefined, types?: TypeDefinitions | undefined, cssWideKeywords?: CSSWideKeywords | undefined}} SyntaxDefinition */
+
+/**
+ * Merge multiple separate syntax definitions.
+ * Individual definitions will override each other unless the second definition starts with a pipe symbol `|`.
+ *
+ * @param {...(SyntaxDefinition|undefined)} sources
+ * @returns {SyntaxDefinition}
+ */
+export default function mergeSyntaxDefinitions(...sources) {
+	/** @type {SyntaxDefinition|undefined} */
+	let target = sources[0] ?? {};
+
+	for (let i = 1; i < sources.length; i++) {
+		const source = sources[i];
+
+		if (!source) continue;
+
+		target = mergeTwoSyntaxDefinitions(target, source);
+	}
+
+	return target;
+}
+
+/**
+ * Merge two separate syntax definitions.
+ * Individual definitions will override each other unless the second definition starts with a pipe symbol `|`.
+ *
+ * @param {SyntaxDefinition} source1
+ * @param {SyntaxDefinition} source2
+ * @returns {SyntaxDefinition}
+ */
+function mergeTwoSyntaxDefinitions(source1, source2) {
+	/** @type {SyntaxDefinition} */
+	const target = {};
+
+	target.atrules = mergeAtRuleDefinitions(source1.atrules, source2.atrules);
+	target.properties = mergePropertyOrTypeDefinitions(source1.properties, source2.properties);
+	target.types = mergePropertyOrTypeDefinitions(source1.types, source2.types);
+	target.cssWideKeywords = mergeKeywords(source1.cssWideKeywords, source2.cssWideKeywords);
+
+	return target;
+}
+
+/**
+ * @param {AtRuleDefinitions | undefined} source1
+ * @param {AtRuleDefinitions | undefined} source2
+ * @returns {AtRuleDefinitions | undefined}
+ */
+function mergeAtRuleDefinitions(source1, source2) {
+	if (typeof source1 === 'undefined' || typeof source2 === 'undefined')
+		return source1 ?? source2 ?? {};
+
+	/** @type {AtRuleDefinitions} */
+	const target = structuredClone(source1);
+
+	for (const [atRuleName, atRule] of Object.entries(source2)) {
+		const targetAtRule = target[atRuleName] ?? {};
+
+		targetAtRule.prelude = mergePrelude(targetAtRule.prelude, atRule.prelude);
+		targetAtRule.descriptors = mergePropertyOrTypeDefinitions(
+			targetAtRule.descriptors,
+			atRule.descriptors,
+		);
+
+		target[atRuleName] = targetAtRule;
+	}
+
+	return target;
+}
+
+/**
+ * @param {Record<string, string> | undefined} source1
+ * @param {Record<string, string> | undefined} source2
+ * @returns {Record<string, string> | undefined}
+ */
+function mergePropertyOrTypeDefinitions(source1, source2) {
+	if (typeof source1 === 'undefined' || typeof source2 === 'undefined')
+		return source1 ?? source2 ?? {};
+
+	/** @type {Record<string, string>} */
+	const target = {
+		...source1,
+	};
+
+	for (const [name, syntax] of Object.entries(source2)) {
+		target[name] = mergeSyntax(target[name], syntax);
+	}
+
+	return target;
+}
+
+/**
+ * @param {Array<string> | undefined} source1
+ * @param {Array<string> | undefined} source2
+ * @returns {Array<string> | undefined}
+ */
+function mergeKeywords(source1, source2) {
+	if (typeof source1 === 'undefined' || typeof source2 === 'undefined')
+		return source1 ?? source2 ?? [];
+
+	return Array.from(new Set([...source1, ...source2]));
+}
+
+/**
+ * @param {string | undefined} source1
+ * @param {string} source2
+ * @returns {string}
+ */
+function mergeSyntax(source1, source2) {
+	if (typeof source1 === 'undefined') return source2;
+
+	const trimmedSource2 = source2.trimStart();
+
+	if (!trimmedSource2.startsWith('|')) return source2;
+
+	return `${source1} ${trimmedSource2}`;
+}
+
+/**
+ * @param {string | undefined} source1
+ * @param {string | undefined} source2
+ * @returns {string | undefined}
+ */
+function mergePrelude(source1, source2) {
+	if (typeof source1 === 'undefined' || typeof source2 === 'undefined') return source1 ?? source2;
+
+	const trimmedSource2 = source2.trimStart();
+
+	if (!trimmedSource2.startsWith('|')) return source2;
+
+	return `${source1} ${trimmedSource2}`;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/narrowFixRange.mjs

@@ -0,0 +1,68 @@
+/** @import { Node as PostcssNode } from 'postcss' */
+
+/**
+ * Make a fix range as narrow as possible by trimming common prefixes and suffixes
+ *
+ * @param {PostcssNode} node
+ * @param {{range: [number, number], text: string}} fixData
+ * @returns {{range: [number, number], text: string}}
+ */
+export default function narrowFixRange(node, fixData) {
+	if (!node.source) {
+		return fixData;
+	}
+
+	let startOffset = fixData.range[0];
+	let endOffset = fixData.range[1];
+
+	const stringRepresentation = node.source.input.css.slice(startOffset, endOffset);
+
+	let replacementStartOffset = 0;
+
+	for (let i = 0; i < stringRepresentation.length; i++) {
+		const a = stringRepresentation[i];
+		const b = fixData.text[i];
+
+		if (a !== b) break;
+
+		startOffset++;
+		replacementStartOffset++;
+	}
+
+	let replacementEndOffset = fixData.text.length;
+
+	for (let i = 0; i < stringRepresentation.length; i++) {
+		const ia = stringRepresentation.length - 1 - i;
+
+		if (ia < replacementStartOffset) break;
+
+		const a = stringRepresentation[ia];
+
+		const ib = fixData.text.length - 1 - i;
+
+		if (ib < replacementStartOffset) break;
+
+		const b = fixData.text[ib];
+
+		if (a !== b) break;
+
+		endOffset--;
+		replacementEndOffset--;
+	}
+
+	// Try to have a context size of at least 1
+	if (startOffset === endOffset) {
+		if (startOffset > fixData.range[0]) {
+			startOffset--;
+			replacementStartOffset--;
+		} else if (endOffset < fixData.range[1]) {
+			endOffset++;
+			replacementEndOffset++;
+		}
+	}
+
+	return {
+		text: fixData.text.slice(replacementStartOffset, replacementEndOffset),
+		range: [startOffset, endOffset],
+	};
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/nodeContextLookup.mjs

@@ -0,0 +1,41 @@
+/**
+ * Create a collection of Maps that serve to contextualize a given node.
+ * This is useful to ensure that you only compare nodes that share a certain
+ * context.
+ *
+ * All nodes are initially contextualized by their input source.
+ * From there, you can contextualize them however you want.
+ *
+ * For a usage example, see `selector-no-descending-specificity`.
+ */
+export default function nodeContextLookup() {
+	const contextMap = new Map();
+
+	return {
+		/**
+		 * @param {import('postcss').Node} node
+		 * @param {any[]} subContexts
+		 * @returns {Map<any, any>}
+		 */
+		getContext(node, ...subContexts) {
+			if (!node.source) throw new Error('The node source must be present');
+
+			const nodeSource = node.source.input.from;
+			const baseContext = creativeGetMap(contextMap, nodeSource);
+
+			return subContexts.reduce((result, context) => creativeGetMap(result, context), baseContext);
+		},
+	};
+}
+
+/**
+ * @param {Map<any, any>} someMap
+ * @param {any} someThing
+ */
+function creativeGetMap(someMap, someThing) {
+	if (!someMap.has(someThing)) {
+		someMap.set(someThing, new Map());
+	}
+
+	return someMap.get(someThing);
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/nodeFieldIndices.mjs

@@ -0,0 +1,119 @@
+import getAtRuleParams from './getAtRuleParams.mjs';
+import getRuleSelector from './getRuleSelector.mjs';
+
+import { isObject, isString } from './validateTypes.mjs';
+
+/** @import {AtRule, Declaration, Rule} from 'postcss' */
+
+/**
+ * @param {AtRule} atRule
+ * @returns {number}
+ */
+export function atRuleParamIndex(atRule) {
+	const index = atRuleAfterNameIndex(atRule);
+
+	return index + (atRule.raws.afterName?.length ?? 0);
+}
+
+/**
+ * @param {AtRule} atRule
+ * @returns {number}
+ */
+export function atRuleAfterIndex(atRule) {
+	// subtract 1 for `}`
+
+	const endOffset = atRule.source?.end?.offset;
+
+	if (!endOffset) return atRule.toString().length - 1;
+
+	const afterLength = atRule.raws?.after?.length;
+
+	if (!afterLength) return endOffset - 1;
+
+	return endOffset - (afterLength + 1);
+}
+
+/**
+ * @param {AtRule} atRule
+ * @returns {number}
+ */
+export function atRuleAfterNameIndex(atRule) {
+	// Initial 1 is for the `@`
+	return 1 + atRule.name.length;
+}
+
+/**
+ * @param {AtRule} atRule
+ * @returns {number}
+ */
+export function atRuleBetweenIndex(atRule) {
+	return atRuleParamIndex(atRule) + getAtRuleParams(atRule).length;
+}
+
+/**
+ * @param {Declaration} decl
+ * @returns {number}
+ */
+export function declarationBetweenIndex(decl) {
+	const { prop } = decl.raws;
+	const propIsObject = isObject(prop);
+
+	return countChars([
+		propIsObject && 'prefix' in prop && prop.prefix,
+		(propIsObject && 'raw' in prop && prop.raw) || decl.prop,
+		propIsObject && 'suffix' in prop && prop.suffix,
+	]);
+}
+
+/**
+ * Get the index of a declaration's value
+ *
+ * @param {Declaration} decl
+ * @returns {number}
+ */
+export function declarationValueIndex(decl) {
+	const { between, value } = decl.raws;
+
+	return (
+		declarationBetweenIndex(decl) +
+		countChars([between || ':', value && 'prefix' in value && value.prefix])
+	);
+}
+
+/**
+ * @param {Rule} rule
+ * @returns {number}
+ */
+export function ruleBetweenIndex(rule) {
+	return getRuleSelector(rule).length;
+}
+
+/**
+ * @param {Rule} rule
+ * @returns {number}
+ */
+export function ruleAfterIndex(rule) {
+	// subtract 1 for `}`
+
+	const endOffset = rule.source?.end?.offset;
+
+	if (!endOffset) return rule.toString().length - 1;
+
+	const afterLength = rule.raws?.after?.length;
+
+	if (!afterLength) return endOffset - 1;
+
+	return endOffset - (afterLength + 1);
+}
+
+/**
+ * @param {unknown[]} values
+ * @returns {number}
+ */
+function countChars(values) {
+	return values.reduce((/** @type {number} */ count, value) => {
+		if (isString(value)) return count + value.length;
+
+		return count;
+	}, 0);
+}