@alexlit/lint-kit 183.4.0 → 183.6.0

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

@@ -0,0 +1,364 @@
+import vendor from './vendor.mjs';
+
+/**
+ * Extract each list using the internal API of Autoprefixer 10.2.5.
+ *
+ * @see https://github.com/postcss/autoprefixer/tree/10.2.5
+ *
+ * @example
+ * const autoprefixer = require('autoprefixer');
+ * const Browsers = require('autoprefixer/lib/browsers');
+ * const Prefixes = require('autoprefixer/lib/prefixes');
+ * const utils = require('autoprefixer/lib/utils');
+ *
+ * const prefixes = new Prefixes(autoprefixer.data.prefixes, new Browsers(autoprefixer.data.browsers, []));
+ */
+
+/**
+ * @example
+ * Object.keys(prefixes.remove).filter((s) => s.startsWith('@'));
+ */
+const AT_RULES = new Set([
+	'@-moz-keyframes',
+	'@-moz-document',
+	'@-ms-keyframes',
+	'@-ms-viewport',
+	'@-o-keyframes',
+	'@-o-viewport',
+	'@-webkit-keyframes',
+	'@-webkit-viewport',
+]);
+
+/**
+ * @example
+ * prefixes.remove.selectors.map((s) => s.prefixed);
+ */
+const SELECTORS = new Set([
+	':-moz-any-link',
+	':-moz-full-screen',
+	':-moz-placeholder',
+	':-moz-placeholder-shown',
+	':-moz-read-only',
+	':-moz-read-write',
+	':-ms-fullscreen',
+	':-ms-input-placeholder',
+	':-webkit-any-link',
+	':-webkit-full-screen',
+	'::-moz-placeholder',
+	'::-moz-selection',
+	'::-ms-input-placeholder',
+	'::-webkit-backdrop',
+	'::-webkit-input-placeholder',
+]);
+
+/**
+ * @example
+ * Object.entries(autoprefixer.data.prefixes)
+ *   .filter(([key, value]) => !value.selector && !value.props && !key.startsWith('@'))
+ *   .map(([key, value]) => key);
+ */
+const PROPERTIES = new Set([
+	'align-content',
+	'align-items',
+	'align-self',
+	'animation',
+	'animation-delay',
+	'animation-direction',
+	'animation-duration',
+	'animation-fill-mode',
+	'animation-iteration-count',
+	'animation-name',
+	'animation-play-state',
+	'animation-timing-function',
+	'appearance',
+	'backdrop-filter',
+	'backface-visibility',
+	'background-clip',
+	'background-origin',
+	'background-size',
+	'border-block-end',
+	'border-block-start',
+	'border-bottom-left-radius',
+	'border-bottom-right-radius',
+	'border-image',
+	'border-inline-end',
+	'border-inline-start',
+	'border-radius',
+	'border-top-left-radius',
+	'border-top-right-radius',
+	'box-decoration-break',
+	'box-shadow',
+	'box-sizing',
+	'break-after',
+	'break-before',
+	'break-inside',
+	'clip-path',
+	'color-adjust',
+	'column-count',
+	'column-fill',
+	'column-gap',
+	'column-rule',
+	'column-rule-color',
+	'column-rule-style',
+	'column-rule-width',
+	'column-span',
+	'column-width',
+	'columns',
+	'filter',
+	'flex',
+	'flex-basis',
+	'flex-direction',
+	'flex-flow',
+	'flex-grow',
+	'flex-shrink',
+	'flex-wrap',
+	'flow-from',
+	'flow-into',
+	'font-feature-settings',
+	'font-kerning',
+	'font-language-override',
+	'font-variant-ligatures',
+	'grid-area',
+	'grid-column',
+	'grid-column-align',
+	'grid-column-end',
+	'grid-column-start',
+	'grid-row',
+	'grid-row-align',
+	'grid-row-end',
+	'grid-row-start',
+	'grid-template',
+	'grid-template-areas',
+	'grid-template-columns',
+	'grid-template-rows',
+	'hyphens',
+	'image-rendering',
+	'justify-content',
+	'margin-block-end',
+	'margin-block-start',
+	'margin-inline-end',
+	'margin-inline-start',
+	'mask',
+	'mask-border',
+	'mask-border-outset',
+	'mask-border-repeat',
+	'mask-border-slice',
+	'mask-border-source',
+	'mask-border-width',
+	'mask-clip',
+	'mask-composite',
+	'mask-image',
+	'mask-origin',
+	'mask-position',
+	'mask-repeat',
+	'mask-size',
+	'object-fit',
+	'object-position',
+	'order',
+	'overscroll-behavior',
+	'padding-block-end',
+	'padding-block-start',
+	'padding-inline-end',
+	'padding-inline-start',
+	'perspective',
+	'perspective-origin',
+	'place-self',
+	'region-fragment',
+	'scroll-snap-coordinate',
+	'scroll-snap-destination',
+	'scroll-snap-points-x',
+	'scroll-snap-points-y',
+	'scroll-snap-type',
+	'shape-image-threshold',
+	'shape-margin',
+	'shape-outside',
+	'tab-size',
+	'text-align-last',
+	'text-decoration',
+	'text-decoration-color',
+	'text-decoration-line',
+	'text-decoration-skip',
+	'text-decoration-skip-ink',
+	'text-decoration-style',
+	'text-emphasis',
+	'text-emphasis-color',
+	'text-emphasis-position',
+	'text-emphasis-style',
+	'text-orientation',
+	'text-overflow',
+	'text-size-adjust',
+	'text-spacing',
+	'touch-action',
+	'transform',
+	'transform-origin',
+	'transform-style',
+	'transition',
+	'transition-delay',
+	'transition-duration',
+	'transition-property',
+	'transition-timing-function',
+	'user-select',
+	'writing-mode',
+]);
+
+/**
+ * This list is currently being used to compile all the prefixed values that can safely be unprefixed.
+ * i.e. value-no-vendor-prefix autofix ought to be able to handle it appropriately
+ * It was initially populated using the following example:
+ * @example
+ * Object.values(prefixes.remove)
+ *   .filter((p) => Array.isArray(p.values))
+ *   .flatMap((p) => p.values)
+ *   .map((p) => utils.removeNote(p.prefixed)) // normalize '-webkit- old'
+ *   .filter((p) => !p.endsWith('-'));         // remove '-webkit-' only
+ *
+ * @see https://github.com/stylelint/stylelint/pull/5312/files#r636018013
+ */
+const PROPERTY_VALUES = new Set([
+	'-moz-all',
+	'-moz-calc',
+	'-moz-crisp-edges',
+	'-moz-element',
+	'-moz-fit-content',
+	'-moz-grab',
+	'-moz-grabbing',
+	'-moz-initial',
+	'-moz-isolate',
+	'-moz-isolate-override',
+	'-moz-linear-gradient',
+	'-moz-max-content',
+	'-moz-min-content',
+	'-moz-pre-wrap',
+	'-moz-plaintext',
+	'-moz-radial-gradient',
+	'-moz-repeating-linear-gradient',
+	'-moz-repeating-radial-gradient',
+	'-moz-zoom-in',
+	'-moz-zoom-out',
+	'-ms-flexbox',
+	'-ms-grid',
+	'-ms-inline-grid',
+	'-ms-linear-gradient',
+	'-ms-radial-gradient',
+	'-ms-repeating-linear-gradient',
+	'-ms-repeating-radial-gradient',
+	'-o-crisp-edges',
+	'-o-linear-gradient',
+	'-o-pre-wrap',
+	'-o-radial-gradient',
+	'-o-repeating-linear-gradient',
+	'-o-repeating-radial-gradient',
+	'-webkit-calc',
+	'-webkit-cross-fade',
+	'-webkit-filter',
+	'-webkit-fit-content',
+	'-webkit-flex',
+	'-webkit-grab',
+	'-webkit-grabbing',
+	'-webkit-image-set',
+	'-webkit-inline-flex',
+	'-webkit-isolate',
+	'-webkit-linear-gradient',
+	'-webkit-max-content',
+	'-webkit-min-content',
+	'-webkit-plaintext',
+	'-webkit-radial-gradient',
+	'-webkit-repeating-linear-gradient',
+	'-webkit-repeating-radial-gradient',
+	'-webkit-sticky',
+	'-webkit-zoom-in',
+	'-webkit-zoom-out',
+	'-xv-digits',
+	'-xv-literal-punctuation',
+	'-xv-no-punctuation',
+	// Firefox does not support
+	// ethiopic-halehame, ethiopic-halehame-am, ethiopic-halehame-ti-er and ethiopic-halehame-ti-et
+	// without a -moz- prefix
+	// see https://developer.mozilla.org/en-US/docs/Web/CSS/list-style-type
+	'-moz-arabic-indic',
+	'-moz-bengali',
+	'-moz-cjk-earthly-branch',
+	'-moz-cjk-heavenly-stem',
+	'-moz-devanagari',
+	'-moz-ethiopic-numeric',
+	'-moz-gujarati',
+	'-moz-gurmukhi',
+	'-moz-hangul',
+	'-moz-hangul-consonant',
+	'-moz-japanese-formal',
+	'-moz-japanese-informal',
+	'-moz-kannada',
+	'-moz-khmer',
+	'-moz-lao',
+	'-moz-malayalam',
+	'-moz-myanmar',
+	'-moz-oriya',
+	'-moz-persian',
+	'-moz-simp-chinese-formal',
+	'-moz-simp-chinese-informal',
+	'-moz-tamil',
+	'-moz-telugu',
+	'-moz-thai',
+	'-moz-trad-chinese-formal',
+	'-moz-trad-chinese-informal',
+]);
+
+/**
+ * Most identifier types have to be looked up in a unique way,
+ * so we're exposing special functions for each.
+ */
+export default {
+	/**
+	 * @param {string} identifier
+	 * @returns {boolean}
+	 */
+	atRuleName(identifier) {
+		return AT_RULES.has(`@${identifier.toLowerCase()}`);
+	},
+
+	/**
+	 * @param {string} identifier
+	 * @returns {boolean}
+	 */
+	selector(identifier) {
+		return SELECTORS.has(identifier.toLowerCase());
+	},
+
+	/**
+	 * @param {string} identifier
+	 * @returns {boolean}
+	 */
+	mediaFeatureName(identifier) {
+		return identifier.toLowerCase().includes('device-pixel-ratio');
+	},
+
+	/**
+	 * @param {string} identifier
+	 * @returns {boolean}
+	 */
+	property(identifier) {
+		const ident = identifier.toLowerCase();
+
+		if (vendor.prefix(ident).length === 0) {
+			return false;
+		}
+
+		return PROPERTIES.has(vendor.unprefixed(ident));
+	},
+
+	/**
+	 * @param {string} value
+	 * @returns {boolean}
+	 */
+	propertyValue(value) {
+		return PROPERTY_VALUES.has(value.toLowerCase());
+	},
+
+	/**
+	 * @param {string} value
+	 * @returns {string}
+	 */
+	unprefix(value) {
+		return value.replace(/-\w+-/, '');
+	},
+};

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

@@ -0,0 +1,21 @@
+import getPreviousNonSharedLineCommentNode from './getPreviousNonSharedLineCommentNode.mjs';
+import hasBlock from './hasBlock.mjs';
+import { isAtRule } from './typeGuards.mjs';
+
+/**
+ * @param {import('postcss').AtRule} atRule
+ * @returns {boolean}
+ */
+export default function isBlocklessAtRuleAfterBlocklessAtRule(atRule) {
+	if (atRule.type !== 'atrule') {
+		return false;
+	}
+
+	const previousNode = getPreviousNonSharedLineCommentNode(atRule);
+
+	if (previousNode === undefined) {
+		return false;
+	}
+
+	return isAtRule(previousNode) && !hasBlock(previousNode) && !hasBlock(atRule);
+}

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

@@ -0,0 +1,21 @@
+import getPreviousNonSharedLineCommentNode from './getPreviousNonSharedLineCommentNode.mjs';
+import { isAtRule } from './typeGuards.mjs';
+import isBlocklessAtRuleAfterBlocklessAtRule from './isBlocklessAtRuleAfterBlocklessAtRule.mjs';
+
+/**
+ * @param {import('postcss').AtRule} atRule
+ * @returns {boolean}
+ */
+export default function isBlocklessAtRuleAfterSameNameBlocklessAtRule(atRule) {
+	if (!isBlocklessAtRuleAfterBlocklessAtRule(atRule)) {
+		return false;
+	}
+
+	const previousNode = getPreviousNonSharedLineCommentNode(atRule);
+
+	if (previousNode && isAtRule(previousNode)) {
+		return previousNode.name === atRule.name;
+	}
+
+	return false;
+}

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

@@ -0,0 +1,24 @@
+import {
+	aNPlusBOfSNotationPseudoClasses,
+	logicalCombinationsPseudoClasses,
+} from '../reference/selectors.mjs';
+
+/**
+ * Check whether a node is a context-functional pseudo-class (i.e. either a logical combination
+ * or a 'aNPlusBOfSNotationPseudoClasses' / tree-structural pseudo-class)
+ *
+ * @param {import('postcss-selector-parser').Node | import('postcss-selector-parser').Container | undefined} node - postcss-selector-parser node (of type pseudo)
+ * @returns {node is import('postcss-selector-parser').Pseudo} If `true`, the node is a context-functional pseudo-class
+ */
+export default function isContextFunctionalPseudoClass(node) {
+	if (node?.type === 'pseudo') {
+		const normalisedParentName = node.value.toLowerCase().replace(/:+/, '');
+
+		return (
+			logicalCombinationsPseudoClasses.has(normalisedParentName) ||
+			aNPlusBOfSNotationPseudoClasses.has(normalisedParentName)
+		);
+	}
+
+	return false;
+}

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

@@ -0,0 +1,19 @@
+import { counterIncrementKeywords } from '../reference/keywords.mjs';
+
+/**
+ * Check value is a custom ident
+ *
+ * @param {string} value
+ */
+export default function isCounterIncrementCustomIdentValue(value) {
+	const valueLowerCase = value.toLowerCase();
+
+	if (
+		counterIncrementKeywords.has(valueLowerCase) ||
+		Number.isFinite(Number.parseInt(valueLowerCase, 10))
+	) {
+		return false;
+	}
+
+	return true;
+}

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

@@ -0,0 +1,19 @@
+import { counterResetKeywords } from '../reference/keywords.mjs';
+
+/**
+ * Check value is a custom ident
+ *
+ * @param {string} value
+ */
+export default function isCounterResetCustomIdentValue(value) {
+	const valueLowerCase = value.toLowerCase();
+
+	if (
+		counterResetKeywords.has(valueLowerCase) ||
+		Number.isFinite(Number.parseInt(valueLowerCase, 10))
+	) {
+		return false;
+	}
+
+	return true;
+}

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

@@ -0,0 +1,34 @@
+import { mathmlTagNames } from 'mathml-tag-names';
+import svgTags from 'svg-tags';
+
+/**
+ * Check whether a type selector is a custom element
+ *
+ * @param {string} selector
+ * @returns {boolean}
+ */
+export default function isCustomElement(selector) {
+	if (!/^[a-z]/.test(selector)) {
+		return false;
+	}
+
+	if (!selector.includes('-')) {
+		return false;
+	}
+
+	const selectorLowerCase = selector.toLowerCase();
+
+	if (selectorLowerCase !== selector) {
+		return false;
+	}
+
+	if (svgTags.includes(selectorLowerCase)) {
+		return false;
+	}
+
+	if (mathmlTagNames.includes(selectorLowerCase)) {
+		return false;
+	}
+
+	return true;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Check whether a function is custom / user-defined
+ * https://github.com/w3c/css-houdini-drafts/issues/1007
+ * @param {string} func
+ * @returns {boolean}
+ */
+export default function isCustomFunction(func) {
+	return func.startsWith('--');
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Check whether a media query is a custom
+ * @param {string} mediaQuery
+ * @returns {boolean}
+ */
+export default function isCustomMediaQuery(mediaQuery) {
+	return mediaQuery.startsWith('--');
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Check whether a property is a custom one
+ * @param {string} property
+ * @returns {boolean}
+ */
+export default function isCustomProperty(property) {
+	return property.startsWith('--');
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Check whether a selector is a custom one
+ *
+ * @param {string} selector
+ * @returns {boolean}
+ */
+export default function isCustomSelector(selector) {
+	return selector.startsWith(':--');
+}

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

@@ -0,0 +1,22 @@
+import findNodeUpToRoot from './findNodeUpToRoot.mjs';
+import { isAtRule } from './typeGuards.mjs';
+import { nestingSupportedAtKeywords } from '../reference/atKeywords.mjs';
+
+/** @import { Declaration, Node } from 'postcss' */
+
+/**
+ * Check whether a declaration is a descriptor one
+ *
+ * @param {Declaration} decl
+ * @returns {boolean}
+ */
+export default function isDescriptorDeclaration(decl) {
+	return Boolean(findNodeUpToRoot(decl, isAtRuleSupportingDescriptors));
+}
+
+/**
+ * @param {Node} node
+ */
+function isAtRuleSupportingDescriptors(node) {
+	return isAtRule(node) && !nestingSupportedAtKeywords.has(node.name.toLowerCase());
+}

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

@@ -0,0 +1,83 @@
+import { hasSource, isComment, isDocument, isRoot } from './typeGuards.mjs';
+
+/**
+ * @param {import('postcss').Node} statement
+ * @returns {boolean}
+ */
+export default function isFirstNested(statement) {
+	const parentNode = statement.parent;
+
+	if (parentNode === undefined) {
+		return false;
+	}
+
+	if (isRoot(parentNode) && !isInDocument(parentNode)) {
+		return false;
+	}
+
+	if (statement === parentNode.first) {
+		return true;
+	}
+
+	/*
+	 * Search for the statement in the parent's nodes, ignoring comment
+	 * nodes on the same line as the parent's opening brace.
+	 */
+
+	const parentNodes = parentNode.nodes;
+
+	if (!parentNodes) {
+		return false;
+	}
+
+	const firstNode = parentNodes[0];
+
+	if (!firstNode) {
+		return false;
+	}
+
+	if (
+		!isComment(firstNode) ||
+		(typeof firstNode.raws.before === 'string' && firstNode.raws.before.includes('\n'))
+	) {
+		return false;
+	}
+
+	if (!hasSource(firstNode) || !firstNode.source.start) {
+		return false;
+	}
+
+	const openingBraceLine = firstNode.source.start.line;
+
+	if (!firstNode.source.end || openingBraceLine !== firstNode.source.end.line) {
+		return false;
+	}
+
+	for (const [index, node] of parentNodes.entries()) {
+		if (index === 0) {
+			continue;
+		}
+
+		if (node === statement) {
+			return true;
+		}
+
+		if (
+			!isComment(node) ||
+			(hasSource(node) && node.source.end && node.source.end.line !== openingBraceLine)
+		) {
+			return false;
+		}
+	}
+
+	/* istanbul ignore next: Should always return in the loop */
+	return false;
+}
+
+/**
+ * @param {import('postcss').Node} node
+ * @returns {boolean}
+ */
+function isInDocument({ parent }) {
+	return Boolean(parent && isDocument(parent));
+}

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

@@ -0,0 +1,17 @@
+import { isRoot } from './typeGuards.mjs';
+
+/**
+ * @param {import('postcss').Node} node
+ * @returns {boolean}
+ */
+export default function isFirstNodeOfRoot(node) {
+	if (isRoot(node)) return false;
+
+	const parentNode = node.parent;
+
+	if (!parentNode) {
+		return false;
+	}
+
+	return isRoot(parentNode) && node === parentNode.first;
+}

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

@@ -0,0 +1,9 @@
+import isValidHex from './isValidHex.mjs';
+
+/**
+ * @param {import('postcss-value-parser').Node} node
+ * @returns {boolean}
+ */
+export default function isHexColor({ type, value }) {
+	return type === 'word' && isValidHex(value);
+}