@alexlit/lint-kit 182.2.0 → 182.3.0

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

@@ -1,119 +0,0 @@
-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);
-}

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

@@ -1,26 +0,0 @@
-import normalizePath from 'normalize-path';
-import process from 'node:process';
-
-/**
- * Normalize a path for comparisons on Windows while keeping POSIX platforms
- * untouched. On Windows, this lowercases the drive letter and converts
- * backslashes to forward slashes. Only the drive letter is lowercased, since
- * the rest of the path may be case-sensitive on certain file systems mounted
- * on Windows.
- *
- * @param {string} filePath
- * @param {NodeJS.Platform} [platform=process.platform]
- * @returns {string}
- */
-export default function normalizeFilePath(filePath, platform = process.platform) {
-	if (platform !== 'win32') {
-		return filePath;
-	}
-
-	const loweredDrive = filePath.replace(
-		/^(!?)([a-z]):/i,
-		(_, prefix, drive) => `${prefix}${drive.toLowerCase()}:`,
-	);
-
-	return normalizePath(loweredDrive);
-}

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

@@ -1,22 +0,0 @@
-import { DEFAULT_FIX_MODE } from '../constants.mjs';
-
-/** @import { FixMode } from 'stylelint' */
-
-/**
- * Normalize the fix mode based on options and configuration.
- * If the input is unknown, this returns `undefined`.
- *
- * @param {unknown} fix
- * @returns {FixMode | undefined}
- */
-export default function normalizeFixMode(fix) {
-	if (fix === true || fix === 'true' || fix === '' || fix === DEFAULT_FIX_MODE) {
-		return DEFAULT_FIX_MODE;
-	}
-
-	if (fix === 'lax') {
-		return 'lax';
-	}
-
-	return undefined;
-}

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

@@ -1,166 +0,0 @@
-import parser from 'postcss-selector-parser';
-
-/** @import { Node, Root, Selector } from 'postcss-selector-parser' */
-/** @import { PostcssResult } from 'stylelint' */
-
-/**
- * @template T
- * @typedef {{ node: T, string: string }} NormalizedEntry<T>
- */
-
-/** @type {WeakMap<Root | Selector, Map<PostcssResult, NormalizedEntry<any>>>} */
-const cache = new WeakMap();
-
-/** @type {Map<string, NormalizedEntry<any>>} */
-const stringCache = new Map();
-const MAX_STRING_CACHE_SIZE = 10000;
-
-/**
- * Normalize a selector node so that it can be more easily compared to other selectors
- * Uses two-tier caching to minimise cloning:
- * - Result-scoped cache for within-file reuse
- * - Bounded string cache for cross-file reuse
- *
- * @template {Root | Selector} T
- * @param {T} node
- * @param {PostcssResult} result
- * @returns {NormalizedEntry<T>}
- */
-export default function normalizeSelector(node, result) {
-	let nodeCache = cache.get(node);
-
-	if (nodeCache) {
-		const cached = nodeCache.get(result);
-
-		if (cached) return cached;
-	} else {
-		nodeCache = new Map();
-		cache.set(node, nodeCache);
-	}
-
-	const selectorString = node.toString();
-	const cachedByString = stringCache.get(selectorString);
-
-	if (cachedByString) {
-		nodeCache.set(result, cachedByString);
-
-		return cachedByString;
-	}
-
-	const normalizedNode = /** @type {T} */ (normalize(node.clone()));
-	const entry = { node: normalizedNode, string: normalizedNode.toString() };
-
-	nodeCache.set(result, entry);
-
-	if (stringCache.size >= MAX_STRING_CACHE_SIZE) {
-		const oldestKey = stringCache.keys().next().value;
-
-		if (oldestKey !== undefined) stringCache.delete(oldestKey);
-	}
-
-	stringCache.set(selectorString, entry);
-
-	return entry;
-}
-
-/**
- * @template {Root | Selector} T
- * @param {T} node
- * @returns {T}
- */
-function normalize(node) {
-	normalizeNodeEscaping(node);
-	normalizeSelectorNodeWhitespaceAndComments(node);
-
-	node.walk((child) => {
-		normalizeNodeEscaping(child);
-		normalizeSelectorNodeWhitespaceAndComments(child);
-	});
-
-	normalizeSelectorNodesOrder(node);
-
-	return node;
-}
-
-/**
- * @param {Node} node
- */
-function normalizeSelectorNodeWhitespaceAndComments(node) {
-	if (parser.isComment(node)) {
-		node.remove();
-
-		return;
-	}
-
-	node.rawSpaceBefore = '';
-	node.rawSpaceAfter = '';
-
-	node.spaces.before = '';
-	node.spaces.after = '';
-
-	if (parser.isAttribute(node)) {
-		delete node.spaces.insensitive;
-		delete node.spaces.operator;
-		delete node.spaces.attribute;
-		delete node.spaces.value;
-
-		delete node.raws.spaces;
-	}
-}
-
-/**
- * @param {Node} node
- */
-function normalizeSelectorNodesOrder(node) {
-	if (!parser.isContainer(node)) return;
-
-	// Need to sort inside out, not outside in.
-	// As the parents needs to sorted with their children already in the right order.
-	node.each(normalizeSelectorNodesOrder);
-
-	if (parser.isRoot(node) || parser.isPseudoClass(node) || parser.isPseudoElement(node)) {
-		const nodes = node.nodes.map((childNode) => {
-			// Make sure to only stringify the node once.
-			return { node: childNode, string: childNode.toString() };
-		});
-
-		nodes.sort((a, b) => a.string.localeCompare(b.string));
-
-		const uniqueNodes = new Set();
-		const nodesIndices = new Map();
-
-		nodes.forEach((x, i) => {
-			if (uniqueNodes.has(x.string)) return;
-
-			uniqueNodes.add(x.string);
-			nodesIndices.set(x.node, i);
-		});
-
-		node.nodes = node.nodes
-			.filter((childNode) => {
-				return nodesIndices.has(childNode);
-			})
-			.sort((a, b) => {
-				return nodesIndices.get(a) - nodesIndices.get(b);
-			});
-	}
-}
-
-/**
- * Normalize CSS escaping in selector node values.
- * Field getters return unescaped values, setters handle re-escaping.
- * Setting a field to itself normalizes the escaping representation.
- * This ensures selectors like `.u-m\00002b` and `.u-m\+` are treated as equivalent.
- *
- * @see https://github.com/postcss/postcss-selector-parser/blob/1b1e9c3bc10ccc3bc5f07a987caa7f2684c0b52f/src/selectors/className.js#L13-L28
- * @param {Node} node
- */
-function normalizeNodeEscaping(node) {
-	if (parser.isClassName(node)) {
-		// @ts-expect-error -- The `raws` property exists, but isn't exposed in the type. This check provides a performance benefit by avoiding extra escaping.
-		if (!node.raws?.value) return;
-
-		// eslint-disable-next-line no-self-assign -- Intentional: setter normalizes escaping
-		node.value = node.value;
-	}
-}

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

@@ -1,20 +0,0 @@
-import matchesStringOrRegExp from './matchesStringOrRegExp.mjs';
-
-/**
- * Check if an options object's propertyName contains a user-defined string or
- * regex that matches the passed in input.
- *
- * @param {{ [x: string]: any; }} options
- * @param {string} propertyName
- * @param {unknown} input
- *
- * @returns {boolean}
- */
-export default function optionsMatches(options, propertyName, input) {
-	return Boolean(
-		options &&
-		options[propertyName] &&
-		typeof input === 'string' &&
-		matchesStringOrRegExp(input, options[propertyName]),
-	);
-}

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

@@ -1,15 +0,0 @@
-import { parseCustomMedia } from '@csstools/media-query-list-parser';
-
-import getAtRuleParams from './getAtRuleParams.mjs';
-
-/**
- * @param {import('postcss').AtRule} atRule
- * @returns {ReturnType<typeof import('@csstools/media-query-list-parser').parseCustomMedia>}
- */
-export default function parseCustomMediaQuery(atRule) {
-	const mediaQuery = parseCustomMedia(getAtRuleParams(atRule), {
-		preserveInvalidMediaQueries: true,
-	});
-
-	return mediaQuery;
-}

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

@@ -1,15 +0,0 @@
-import { parse } from '@csstools/media-query-list-parser';
-
-import getAtRuleParams from './getAtRuleParams.mjs';
-
-/**
- * @param {import('postcss').AtRule} atRule
- * @returns {ReturnType<typeof import('@csstools/media-query-list-parser').parse>}
- */
-export default function parseMediaQuery(atRule) {
-	const mediaQueries = parse(getAtRuleParams(atRule), {
-		preserveInvalidMediaQueries: true,
-	});
-
-	return mediaQueries;
-}

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

@@ -1,19 +0,0 @@
-import selectorParser from 'postcss-selector-parser';
-
-/**
- * @param {string} selector
- * @param {import('stylelint').PostcssResult} result
- * @param {import('postcss').Node} node
- * @returns {import('postcss-selector-parser').Root | undefined}
- */
-export default function parseSelector(selector, result, node) {
-	if (!selector) return undefined;
-
-	try {
-		return selectorParser().astSync(selector);
-	} catch (err) {
-		result.warn(`Cannot parse selector (${err})`, { node, stylelintType: 'parseError' });
-
-		return undefined;
-	}
-}

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

@@ -1,16 +0,0 @@
-import { access } from 'node:fs/promises';
-
-/**
- * Check if a file or directory exists at the given path.
- * @param {string} path
- * @returns {Promise<boolean>}
- */
-export default async function pathExists(path) {
-	try {
-		await access(path);
-
-		return true;
-	} catch {
-		return false;
-	}
-}

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

@@ -1,10 +0,0 @@
-/**
- * Returns the plural form of the given word.
- *
- * @param {string} singular
- * @param {number} count
- * @returns {string}
- */
-export default function pluralize(singular, count) {
-	return count === 1 ? singular : `${singular}s`;
-}

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

@@ -1,20 +0,0 @@
-/**
- * If `map` already has the given `key`, returns its value. Otherwise, calls
- * `callback`, adds the result to `map` at `key`, and then returns it.
- *
- * @template K
- * @template V
- * @param {Map<K, V>} map
- * @param {K} key
- * @param {() => V} callback
- * @returns {V}
- */
-export default function putIfAbsent(map, key, callback) {
-	if (map.has(key)) return /** @type {V} */ (map.get(key));
-
-	const value = callback();
-
-	map.set(key, value);
-
-	return value;
-}

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

@@ -1,19 +0,0 @@
-/**
- * Check if two ranges of source offsets overlap.
- * This function assumes that the provided ranges have a width of at least one column.
- *
- * @param {[number, number]} a
- * @param {[number, number]} b
- * @returns {boolean}
- */
-export default function rangesOverlap(a, b) {
-	// a: ----
-	// b:      ----
-	if (a[1] <= b[0]) return false;
-
-	// a:      ----
-	// b: ----
-	if (a[0] >= b[1]) return false;
-
-	return true;
-}

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

@@ -1,29 +0,0 @@
-/**
- * @typedef {{result: string, before: string}} CacheEntry
- */
-
-/** @type {WeakMap<import('postcss').Node, CacheEntry>} */
-const cache = new WeakMap();
-
-/**
- * Stringify PostCSS node including its raw "before" string.
- *
- * @param {import('postcss').Node} node
- *
- * @returns {string}
- */
-export default function rawNodeString(node) {
-	const cachedEntry = cache.get(node);
-	const before = node.raws.before ?? '';
-
-	// Valid cache only if `node.raws.before` is unchanged
-	if (cachedEntry && cachedEntry.before === before) {
-		return cachedEntry.result;
-	}
-
-	const result = before + node.toString();
-
-	cache.set(node, { result, before });
-
-	return result;
-}

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

@@ -1,135 +0,0 @@
-import {
-	aNPlusBNotationPseudoClasses,
-	aNPlusBOfSNotationPseudoClasses,
-	percentageKeyframeWithNamedEquivalent,
-} from '../reference/selectors.mjs';
-import {
-	colorFunctions,
-	hueColorFunctions,
-	legacyNotationColorFunctions,
-	lightnessColorFunctions,
-	mathFunctions,
-	withAlphaAliasColorFunctions,
-	withoutAlphaAliasColorFunctions,
-} from '../reference/functions.mjs';
-import {
-	displayInsideKeywords,
-	displayLegacyKeywords,
-	displayListItemKeyword,
-	displayOutsideKeywords,
-	fontWeightNonNumericKeywords,
-	fontWeightNumericKeywordsWithNamedEquivalent,
-	fontWeightRelativeKeywords,
-	keyframeSelectorKeywords,
-	namedColorsKeywords,
-} from '../reference/keywords.mjs';
-import { deprecatedMediaTypesNames } from '../reference/mediaTypes.mjs';
-import { lengthUnits } from '../reference/units.mjs';
-import { nestingSupportedAtKeywords } from '../reference/atKeywords.mjs';
-import { prefixes } from '../reference/prefixes.mjs';
-
-const aNPlusBClasses = [
-	...aNPlusBNotationPseudoClasses.values(),
-	...aNPlusBOfSNotationPseudoClasses.values(),
-].join('|');
-
-export const atRuleRegexes = {
-	containerName: /^container$/i,
-	customMediaName: /^custom-media$/i,
-	importName: /^import$/i,
-	keyframesName: /^(-(o|moz|ms|webkit)-)?keyframes$/i,
-	layerName: /^layer$/i,
-	mediaName: /^media$/i,
-	pageName: /^page$/i,
-	propertyName: /^property$/i,
-	scopeName: /^scope$/i,
-	unsupportedNestingNames: new RegExp(
-		`^((?!${[...nestingSupportedAtKeywords.values()].join('|')}).)*$`,
-		'i',
-	),
-};
-
-export const descriptorRegexes = {
-	syntaxName: /^syntax$/i,
-};
-
-export const propertyRegexes = {
-	containerNameAndShorthandName: /^container(-name)?$/i,
-	custom: /^--/,
-	fontFamilyAndShorthandName: /^font(-family)?$/i,
-	fontWeightAndShorthandName: /^font(-weight)?$/i,
-	gridAreaNames: /^(?:grid|grid-template|grid-template-areas)$/i,
-};
-
-export const mayIncludeRegexes = {
-	aNPlusBNotationPseudoClass: new RegExp(`\\b:(?:${aNPlusBClasses})\\(`, 'i'),
-	annotation: /!/,
-	attributeSelector: /\[/,
-	attributeSelectorWithOperator: /\[.*=/,
-	classSelector: /\./,
-	colorFunction: new RegExp(`\\b(?:${[...colorFunctions.values()].join('|')})\\(`, 'i'),
-	legacyNotationColorFunction: new RegExp(
-		`\\b(?:${[...legacyNotationColorFunctions.values()].join('|')})\\(`,
-		'i',
-	),
-	combinator: /[>+~\s]/,
-	customProperty: /--/,
-	deprecatedMediaType: new RegExp(`\\b(?:${[...deprecatedMediaTypesNames].join('|')})\\b`, 'i'),
-	displayKeyword: new RegExp(
-		`\\b(?:${[...displayListItemKeyword, ...displayOutsideKeywords, ...displayInsideKeywords, ...displayLegacyKeywords].join('|')})\\b`,
-		'i',
-	),
-	dimension: /\d[%\w-]/,
-	grayFunction: /\bgray\(/i,
-	hexColor: /#[\da-z]+/i,
-	hueColorFunction: new RegExp(`\\b(?:${[...hueColorFunctions.values()].join('|')})\\(`, 'i'),
-	lightnessColorFunction: new RegExp(
-		`\\b(?:${[...lightnessColorFunctions.values()].join('|')})\\(`,
-		'i',
-	),
-	idClassAttributeSelector: /[#.[]/,
-	idSelector: /#/,
-	keyword: /(?<![0-9])[a-z]+(?!\()/i,
-	layerFunction: /\blayer\(/i,
-	mathFunction: new RegExp(`\\b(?:${[...mathFunctions.values()].join('|')})\\(`, 'i'),
-	namedFontWeight: new RegExp(
-		`\\b(?:${[...new Set([...fontWeightNonNumericKeywords, ...fontWeightRelativeKeywords])].join('|')})\\b`,
-		'i',
-	),
-	numericFontWeight: new RegExp(
-		`\\b(?:${[...fontWeightNumericKeywordsWithNamedEquivalent.values()].join('|')})\\b`,
-	),
-	namedKeyframeSelectorWithPercentageEquivalent: new RegExp(
-		`\\b(?:${[...keyframeSelectorKeywords.values()].join('|')})\\b`,
-		'i',
-	),
-	percentageKeyframeSelectorWithNamedEquivalent: new RegExp(
-		`(?:^|[,\\s])(?:${[...percentageKeyframeWithNamedEquivalent.values()].join('|')})`,
-	),
-	multipleValues: /\s|,/,
-	namedColor: new RegExp(`\\b(?:${[...namedColorsKeywords.values()].join('|')})\\b`, 'i'),
-	nestingSelector: /&/,
-	notPseudoClass: /:not\(/i,
-	operator: /[+-]/,
-	prefix: new RegExp(`(?:${[...prefixes].join('|')})`, 'i'),
-	pseudo: /:/,
-	pseudoElement: /::/,
-	time: /\dm?s/i,
-	typeSelector: /(?:[^.#[:a-z-]|^)[a-z]/i,
-	universalSelector: /\*/,
-	urlFunction: /\burl\(/i,
-	validHex: /#(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})(?:$|[^\da-f])/i,
-	varFunction: /\bvar\(/i,
-	withAlphaAliasColorFunction: new RegExp(
-		`\\b(?:${[...withAlphaAliasColorFunctions.values()].join('|')})\\(`,
-		'i',
-	),
-	withoutAlphaAliasColorFunction: new RegExp(
-		`\\b(?:${[...withoutAlphaAliasColorFunctions.values()].join('|')})\\(`,
-		'i',
-	),
-	zeroLength: new RegExp(
-		`\\b[+-]?(?:0+|0*\\.\\d+)(?:${[...lengthUnits.values()].join('|')})\\b`,
-		'i',
-	),
-};

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

@@ -1,13 +0,0 @@
-/**
- * Remove empty lines before a node. Mutates the node.
- *
- * @template {import('postcss').Node} T
- * @param {T} node
- * @param {string} newline
- * @returns {T}
- */
-export default function removeEmptyLinesBefore(node, newline) {
-	node.raws.before = node.raws.before ? node.raws.before.replace(/(\r?\n\s*\n)+/g, newline) : '';
-
-	return node;
-}