@taiga-ui/stylelint-config 0.520.0 → 0.522.0

package/index.esm.js

@@ -0,0 +1,964 @@
+import browserslistConfig from '@taiga-ui/browserslist-config';
+import valueParser from 'postcss-value-parser';
+import stylelint from 'stylelint';
+import { extname } from 'node:path';
+
+const { createPlugin: createPlugin$2, utils: { report: report$2, ruleMessages: ruleMessages$2, validateOptions: validateOptions$2 }, } = stylelint;
+const ruleName$2 = '@taiga-ui/no-mask-shorthand';
+const messages$2 = ruleMessages$2(ruleName$2, {
+    expected: 'Expected "mask" shorthand to be expanded into longhand properties',
+});
+const meta$2 = {
+    fixable: true,
+    url: 'https://github.com/taiga-family/toolkit/tree/main/projects/stylelint-config',
+};
+const cssWideKeywords = new Set([
+    'inherit',
+    'initial',
+    'revert',
+    'revert-layer',
+    'unset',
+]);
+const geometryBoxes = new Set([
+    'border-box',
+    'content-box',
+    'fill-box',
+    'margin-box',
+    'padding-box',
+    'stroke-box',
+    'view-box',
+]);
+const imageFunctions = new Set([
+    '-webkit-gradient',
+    'conic-gradient',
+    'cross-fade',
+    'element',
+    'image',
+    'image-set',
+    'linear-gradient',
+    'paint',
+    'radial-gradient',
+    'repeating-conic-gradient',
+    'repeating-linear-gradient',
+    'repeating-radial-gradient',
+    'url',
+]);
+const positionSizeFunctions = new Set([
+    'anchor',
+    'anchor-size',
+    'calc',
+    'clamp',
+    'env',
+    'max',
+    'min',
+    'round',
+]);
+const maskModes = new Set(['alpha', 'luminance', 'match-source']);
+const maskComposites = new Set(['add', 'exclude', 'intersect', 'subtract']);
+const dimensionPattern = /^-?(?:\d+|\d*\.\d+)(?:%|[a-z]+)?$/i;
+const positionKeywords = new Set([
+    'block-end',
+    'block-start',
+    'bottom',
+    'center',
+    'end',
+    'inline-end',
+    'inline-start',
+    'left',
+    'right',
+    'start',
+    'top',
+    'x-end',
+    'x-start',
+    'y-end',
+    'y-start',
+]);
+const sizeKeywords = new Set(['auto', 'contain', 'cover']);
+const repeatKeywords = new Set(['no-repeat', 'repeat', 'round', 'space']);
+const singleRepeatKeywords = new Set([
+    'repeat-block',
+    'repeat-inline',
+    'repeat-x',
+    'repeat-y',
+]);
+const longhandDefinitions = [
+    { always: true, initial: 'none', key: 'image', prop: 'mask-image' },
+    { initial: 'repeat', key: 'repeat', prop: 'mask-repeat' },
+    { initial: '0% 0%', key: 'position', prop: 'mask-position' },
+    { initial: 'auto', key: 'size', prop: 'mask-size' },
+    { initial: 'border-box', key: 'origin', prop: 'mask-origin' },
+    { initial: 'border-box', key: 'clip', prop: 'mask-clip' },
+    { initial: 'match-source', key: 'mode', prop: 'mask-mode' },
+    { initial: 'add', key: 'composite', prop: 'mask-composite' },
+];
+function stringifyNodes(nodes) {
+    return valueParser.stringify(nodes).trim();
+}
+function containsVar(nodes) {
+    return nodes.some((node) => {
+        if (node.type !== 'function') {
+            return false;
+        }
+        return node.value.toLowerCase() === 'var' ? true : containsVar(node.nodes);
+    });
+}
+function splitLayers(nodes) {
+    const layers = [];
+    let current = [];
+    for (const node of nodes) {
+        if (node.type === 'div' && node.value === ',') {
+            layers.push(current);
+            current = [];
+            continue;
+        }
+        current.push(node);
+    }
+    layers.push(current);
+    return layers.filter((layer) => stringifyNodes(layer));
+}
+function pushTerm(terms, nodes) {
+    if (nodes.length === 0) {
+        return;
+    }
+    terms.push({
+        nodes,
+        type: 'value',
+        value: stringifyNodes(nodes),
+    });
+}
+function createTerms(nodes) {
+    const terms = [];
+    let current = [];
+    for (const node of nodes) {
+        if (node.type === 'comment') {
+            return null;
+        }
+        if (node.type === 'space') {
+            pushTerm(terms, current);
+            current = [];
+            continue;
+        }
+        if (node.type === 'div') {
+            if (node.value !== '/') {
+                return null;
+            }
+            pushTerm(terms, current);
+            current = [];
+            terms.push({ type: 'slash' });
+            continue;
+        }
+        current.push(node);
+    }
+    pushTerm(terms, current);
+    return terms;
+}
+function getWord(term) {
+    if (!term || term.type === 'slash' || term.nodes.length !== 1) {
+        return null;
+    }
+    const node = term.nodes[0];
+    return node?.type === 'word' ? node.value.toLowerCase() : null;
+}
+function getFunctionName(term) {
+    if (!term || term.type === 'slash' || term.nodes.length !== 1) {
+        return null;
+    }
+    const node = term.nodes[0];
+    return node?.type === 'function' ? node.value.toLowerCase() : null;
+}
+function isImage(term) {
+    const word = getWord(term);
+    if (word === 'none' || word?.startsWith('@') || word?.startsWith('$')) {
+        return true;
+    }
+    const functionName = getFunctionName(term);
+    return Boolean(functionName && imageFunctions.has(functionName));
+}
+function isPreprocessorValue(word) {
+    return word.startsWith('@') || word.startsWith('$') || word.startsWith('~');
+}
+function isPositionSizeFunction(term) {
+    const functionName = getFunctionName(term);
+    return Boolean(functionName && positionSizeFunctions.has(functionName));
+}
+function isPosition(term) {
+    const word = getWord(term);
+    return word
+        ? isPreprocessorValue(word) ||
+            positionKeywords.has(word) ||
+            dimensionPattern.test(word)
+        : isPositionSizeFunction(term);
+}
+function isSize(term) {
+    const word = getWord(term);
+    return word
+        ? isPreprocessorValue(word) ||
+            sizeKeywords.has(word) ||
+            dimensionPattern.test(word)
+        : isPositionSizeFunction(term);
+}
+function getRepeat(terms, index) {
+    const word = getWord(terms[index]);
+    if (!word) {
+        return null;
+    }
+    if (singleRepeatKeywords.has(word)) {
+        return { consumed: 1, value: word };
+    }
+    if (!repeatKeywords.has(word)) {
+        return null;
+    }
+    const nextWord = getWord(terms[index + 1]);
+    return nextWord && repeatKeywords.has(nextWord)
+        ? { consumed: 2, value: `${word} ${nextWord}` }
+        : { consumed: 1, value: word };
+}
+function assignGeometry(layer, geometry) {
+    if (geometry.length === 0) {
+        return true;
+    }
+    const boxes = geometry.filter((value) => value !== 'no-clip');
+    const clips = geometry.filter((value) => value === 'no-clip');
+    const hasTooManyGeometryValues = boxes.length > 2 || clips.length > 1;
+    if (hasTooManyGeometryValues) {
+        return false;
+    }
+    if (clips.length > 0) {
+        layer.clip = 'no-clip';
+        if (boxes.length > 0) {
+            const origin = boxes[0];
+            if (!origin) {
+                return false;
+            }
+            layer.origin = origin;
+        }
+        return true;
+    }
+    if (boxes.length === 1) {
+        const box = boxes[0];
+        if (!box) {
+            return false;
+        }
+        layer.clip = box;
+        layer.origin = box;
+        return true;
+    }
+    const origin = boxes[0];
+    const clip = boxes[1];
+    if (!origin || !clip) {
+        return false;
+    }
+    layer.origin = origin;
+    layer.clip = clip;
+    return true;
+}
+function assignValue(layer, key, value) {
+    if (layer[key]) {
+        return false;
+    }
+    layer[key] = value;
+    return true;
+}
+function parseLayer(nodes) {
+    const terms = createTerms(nodes);
+    if (!terms) {
+        return null;
+    }
+    const layer = {
+        clip: null,
+        composite: null,
+        image: null,
+        mode: null,
+        origin: null,
+        position: null,
+        repeat: null,
+        size: null,
+    };
+    const geometry = [];
+    const position = [];
+    const size = [];
+    let isParsingSize = false;
+    for (let index = 0; index < terms.length; index++) {
+        const term = terms[index];
+        if (!term) {
+            return null;
+        }
+        if (term.type === 'slash') {
+            if (isParsingSize) {
+                return null;
+            }
+            isParsingSize = true;
+            continue;
+        }
+        const word = getWord(term);
+        if (word && maskModes.has(word)) {
+            if (!assignValue(layer, 'mode', word)) {
+                return null;
+            }
+            continue;
+        }
+        if (word && maskComposites.has(word)) {
+            if (!assignValue(layer, 'composite', word)) {
+                return null;
+            }
+            continue;
+        }
+        const repeat = getRepeat(terms, index);
+        if (repeat) {
+            if (!assignValue(layer, 'repeat', repeat.value)) {
+                return null;
+            }
+            index += repeat.consumed - 1;
+            continue;
+        }
+        if (word && (geometryBoxes.has(word) || word === 'no-clip')) {
+            geometry.push(word);
+            continue;
+        }
+        if (!isParsingSize && !layer.image && isImage(term)) {
+            layer.image = term.value;
+            continue;
+        }
+        if (isParsingSize) {
+            if (!isSize(term)) {
+                return null;
+            }
+            size.push(term.value);
+        }
+        else {
+            if (!isPosition(term)) {
+                return null;
+            }
+            position.push(term.value);
+        }
+    }
+    if (!assignGeometry(layer, geometry)) {
+        return null;
+    }
+    if (position.length > 0) {
+        layer.position = position.join(' ');
+    }
+    if (size.length > 0) {
+        layer.size = size.join(' ');
+    }
+    if (!layer.image) {
+        layer.image = 'none';
+    }
+    return layer;
+}
+function isCssWideKeyword(value) {
+    return cssWideKeywords.has(value.trim().toLowerCase());
+}
+function getLonghandValue(layers, definition) {
+    const values = layers.map((layer) => layer[definition.key] || definition.initial);
+    const firstValue = values[0];
+    if (firstValue === undefined) {
+        return definition.initial;
+    }
+    const hasSameValue = values.every((value) => value === firstValue);
+    return hasSameValue ? firstValue : values.join(', ');
+}
+function isMaskLayer(layer) {
+    return layer !== null;
+}
+function hasExplicitLonghandValue(layers, definition) {
+    return definition.always === true || layers.some((layer) => layer[definition.key]);
+}
+function buildLonghands(value) {
+    if (isCssWideKeyword(value)) {
+        return null;
+    }
+    const nodes = valueParser(value).nodes;
+    if (containsVar(nodes)) {
+        return null;
+    }
+    const parsedLayers = splitLayers(nodes).map(parseLayer);
+    const hasUnparseableLayer = parsedLayers.some((layer) => !layer);
+    if (hasUnparseableLayer || parsedLayers.length === 0) {
+        return null;
+    }
+    const layers = parsedLayers.filter(isMaskLayer);
+    return [
+        ...longhandDefinitions
+            .filter((definition) => hasExplicitLonghandValue(layers, definition))
+            .map((definition) => ({
+            prop: definition.prop,
+            value: getLonghandValue(layers, definition),
+        })),
+    ];
+}
+function replaceDeclaration(decl, longhands) {
+    for (const longhand of longhands) {
+        decl.cloneBefore({
+            important: decl.important,
+            prop: longhand.prop,
+            value: longhand.value,
+        });
+    }
+    decl.remove();
+}
+const ruleFunction$2 = (primary) => (root, result) => {
+    const validOptions = validateOptions$2(result, ruleName$2, {
+        actual: primary,
+        possible: [true],
+    });
+    if (!validOptions) {
+        return;
+    }
+    root.walkDecls('mask', (decl) => {
+        const longhands = buildLonghands(decl.value);
+        report$2({
+            fix: longhands
+                ? () => {
+                    replaceDeclaration(decl, longhands);
+                }
+                : undefined,
+            message: messages$2.expected,
+            node: decl,
+            result,
+            ruleName: ruleName$2,
+        });
+    });
+};
+ruleFunction$2.ruleName = ruleName$2;
+ruleFunction$2.messages = messages$2;
+ruleFunction$2.meta = meta$2;
+const plugin$2 = Object.assign(createPlugin$2(ruleName$2, ruleFunction$2), {
+    messages: messages$2,
+    meta: meta$2,
+    ruleName: ruleName$2,
+});
+
+const { createPlugin: createPlugin$1, utils: { report: report$1, ruleMessages: ruleMessages$1, validateOptions: validateOptions$1 }, } = stylelint;
+const ruleName$1 = '@taiga-ui/no-webkit-box-orient-block-axis';
+const messages$1 = ruleMessages$1(ruleName$1, {
+    expected: 'Expected "-webkit-box-orient: block-axis" to be "-webkit-box-orient: vertical"',
+});
+const meta$1 = {
+    fixable: true,
+    url: 'https://github.com/taiga-family/toolkit/tree/main/projects/stylelint-config',
+};
+const ruleFunction$1 = (primary) => (root, result) => {
+    const validOptions = validateOptions$1(result, ruleName$1, {
+        actual: primary,
+        possible: [true],
+    });
+    if (!validOptions) {
+        return;
+    }
+    root.walkDecls('-webkit-box-orient', (decl) => {
+        if (decl.value.trim().toLowerCase() !== 'block-axis') {
+            return;
+        }
+        report$1({
+            fix: () => {
+                decl.value = 'vertical';
+            },
+            message: messages$1.expected,
+            node: decl,
+            result,
+            ruleName: ruleName$1,
+        });
+    });
+};
+ruleFunction$1.ruleName = ruleName$1;
+ruleFunction$1.messages = messages$1;
+ruleFunction$1.meta = meta$1;
+const plugin$1 = Object.assign(createPlugin$1(ruleName$1, ruleFunction$1), {
+    messages: messages$1,
+    meta: meta$1,
+    ruleName: ruleName$1,
+});
+
+const { createPlugin, utils: { report, ruleMessages, validateOptions }, } = stylelint;
+const ruleName = '@taiga-ui/relative-less-import-extension';
+const messages = ruleMessages(ruleName, {
+    expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`,
+});
+const meta = {
+    fixable: true,
+    url: 'https://github.com/taiga-family/toolkit/tree/main/projects/stylelint-config',
+};
+function getExpectedExtension(root) {
+    const file = root.source?.input.file;
+    if (!file) {
+        return '.less';
+    }
+    const ext = extname(file).toLowerCase();
+    return ext === '.scss' || ext === '.css' || ext === '.less' ? ext : '.less';
+}
+function hasKnownStyleExtension(value) {
+    return /\.(?:less|scss|css)(?:\?.*)?$/i.test(value);
+}
+function isExternalImport(value) {
+    return (value.startsWith('@') ||
+        value.startsWith('~') ||
+        value.startsWith('/') ||
+        value.startsWith('//') ||
+        /^https?:/i.test(value) ||
+        /^data:/i.test(value));
+}
+function isUrlImport(params) {
+    return /^url\(/i.test(params.trim());
+}
+function isLocalImportPath(value) {
+    if (!value || isExternalImport(value)) {
+        return false;
+    }
+    return true;
+}
+function splitQueryAndHash(value) {
+    const match = /^([^?#]+)([?#].*)?$/.exec(value);
+    return {
+        pathname: match?.[1] ?? value,
+        suffix: match?.[2] ?? '',
+    };
+}
+const ruleFunction = (primary) => (root, result) => {
+    const validOptions = validateOptions(result, ruleName, {
+        actual: primary,
+        possible: [true],
+    });
+    if (!validOptions) {
+        return;
+    }
+    const expectedExtension = getExpectedExtension(root);
+    root.walkAtRules('import', (atRule) => {
+        const params = atRule.params.trim();
+        if (isUrlImport(params)) {
+            return;
+        }
+        const match = /^(['"])([^'"]+)\1(.*)$/.exec(params);
+        if (!match) {
+            return;
+        }
+        const quote = match[1];
+        const rawImportPath = match[2];
+        const tail = match[3] ?? '';
+        if (!quote || !rawImportPath || !isLocalImportPath(rawImportPath)) {
+            return;
+        }
+        const { pathname, suffix } = splitQueryAndHash(rawImportPath);
+        if (hasKnownStyleExtension(pathname)) {
+            return;
+        }
+        const fixedPath = `${pathname}${expectedExtension}${suffix}`;
+        const fixedParams = `${quote}${fixedPath}${quote}${tail}`;
+        report({
+            fix: () => {
+                atRule.params = fixedParams;
+            },
+            message: messages.expected(rawImportPath, fixedPath),
+            node: atRule,
+            result,
+            ruleName,
+        });
+    });
+};
+ruleFunction.ruleName = ruleName;
+ruleFunction.messages = messages;
+ruleFunction.meta = meta;
+const plugin = Object.assign(createPlugin(ruleName, ruleFunction), {
+    messages,
+    meta,
+    ruleName,
+});
+
+const { defaults: browserslist } = browserslistConfig;
+const config = {
+    $schema: 'https://raw.githubusercontent.com/SchemaStore/schemastore/master/src/schemas/json/stylelintrc.json',
+    plugins: [
+        plugin$2,
+        plugin$1,
+        plugin,
+        'stylelint-order',
+        'stylelint-rem-over-px',
+        'stylelint-use-logical',
+        'stylelint-plugin-logical-css',
+        '@stylistic/stylelint-plugin',
+        'stylelint-plugin-use-baseline',
+        'stylelint-no-unsupported-browser-features',
+    ],
+    extends: [
+        '@stylistic/stylelint-config',
+        'stylelint-plugin-logical-css/configs/recommended',
+    ],
+    allowEmptyInput: true,
+    customSyntax: 'postcss-less',
+    defaultSeverity: 'error',
+    ignoreFiles: [
+        `${process.cwd()}/**/dist/**`,
+        `${process.cwd()}/**/coverage/**`,
+        `${process.cwd()}/**/node_modules/**`,
+        `${process.cwd()}/**/tests-report/**`,
+    ],
+    reportDescriptionlessDisables: true,
+    reportNeedlessDisables: true,
+    reportUnscopedDisables: false,
+    validate: true,
+    rules: {
+        '@stylistic/declaration-block-trailing-semicolon': null,
+        '@stylistic/declaration-colon-newline-after': null,
+        '@stylistic/declaration-colon-space-after': null,
+        '@stylistic/indentation': null,
+        '@stylistic/max-line-length': null,
+        '@stylistic/no-extra-semicolons': null,
+        '@stylistic/selector-descendant-combinator-no-non-space': null,
+        '@stylistic/selector-pseudo-class-parentheses-space-inside': null,
+        '@stylistic/string-quotes': 'single',
+        '@stylistic/value-list-comma-newline-after': null,
+        '@taiga-ui/no-mask-shorthand': true,
+        '@taiga-ui/no-webkit-box-orient-block-axis': true,
+        '@taiga-ui/relative-less-import-extension': true,
+        'alpha-value-notation': 'number',
+        'annotation-no-unknown': true,
+        'at-rule-allowed-list': [
+            'extend',
+            'keyframes',
+            'import',
+            'media',
+            'supports',
+            'font-face',
+            'property', // CSS Houdini
+        ],
+        'at-rule-empty-line-before': [
+            'always',
+            {
+                except: ['first-nested'],
+                ignore: ['after-comment', 'blockless-after-same-name-blockless'],
+            },
+        ],
+        'at-rule-no-unknown': true,
+        'at-rule-no-vendor-prefix': true,
+        'block-no-empty': true,
+        'color-function-notation': ['legacy', { ignore: ['with-var-inside'] }],
+        'color-hex-alpha': 'never',
+        'color-hex-length': 'short',
+        'color-named': ['never', { ignoreProperties: ['mask', 'mask-image'] }],
+        'color-no-invalid-hex': true,
+        'comment-no-empty': true,
+        'comment-whitespace-inside': 'always',
+        'csstools/use-logical': [
+            'always',
+            {
+                direction: 'ltr',
+                except: [
+                    'float', // Safari 15+
+                    /^margin/i,
+                    /^padding/i,
+                    /^border-/i,
+                ],
+            },
+        ],
+        'custom-property-empty-line-before': [
+            'always',
+            {
+                except: ['after-custom-property', 'first-nested'],
+                ignore: ['after-comment'],
+            },
+        ],
+        'custom-property-no-missing-var-function': null, // TODO: https://github.com/stylelint/stylelint/issues/9163
+        'declaration-block-no-duplicate-custom-properties': true,
+        'declaration-block-no-duplicate-properties': [
+            true,
+            { ignore: ['consecutive-duplicates'] },
+        ],
+        'declaration-block-no-redundant-longhand-properties': [
+            true,
+            {
+                ignoreShorthands: [
+                    'inset',
+                    'mask',
+                    'overflow',
+                    'margin-inline',
+                    'margin-block',
+                    'padding-inline',
+                    'padding-block',
+                    'inset-inline',
+                    'inset-block',
+                ],
+            },
+        ],
+        'declaration-block-no-shorthand-property-overrides': true,
+        'declaration-empty-line-before': [
+            'always',
+            {
+                except: ['first-nested', 'after-declaration'],
+                ignore: ['after-comment'],
+            },
+        ],
+        'declaration-no-important': null,
+        'declaration-property-value-disallowed-list': {
+            '/^(?:min|max)-(?:block-size|height)$/': [
+                /\bfit-content\b/i, // Firefox bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1672559
+            ],
+            'inline-size': ['stretch'],
+            width: ['stretch'],
+        },
+        'font-family-name-quotes': null,
+        'font-family-no-duplicate-names': true,
+        'font-family-no-missing-generic-family-keyword': true,
+        'font-weight-notation': 'named-where-possible',
+        'function-calc-no-unspaced-operator': true,
+        'function-linear-gradient-no-nonstandard-direction': true,
+        'function-name-case': 'lower',
+        'function-no-unknown': [true, { ignoreFunctions: ['fade', 'lighten', 'darken'] }],
+        'function-url-no-scheme-relative': true,
+        'function-url-quotes': 'always',
+        'keyframe-block-no-duplicate-selectors': true,
+        'keyframe-declaration-no-important': true,
+        'length-zero-no-unit': [true, { ignore: ['custom-properties'] }],
+        'lightness-notation': 'percentage',
+        'logical-css/require-logical-keywords': [
+            true,
+            {
+                ignore: [
+                    'clear',
+                    'float',
+                    'resize',
+                    'caption-side',
+                    'box-orient', // Legacy line clamping depends on vertical orientation, issue: https://github.com/taiga-family/toolkit/issues/1651
+                ],
+            },
+        ],
+        'logical-css/require-logical-properties': [
+            true,
+            {
+                ignore: [
+                    'scroll-margin-bottom',
+                    'scroll-margin-top',
+                    'scroll-margin-left',
+                    'scroll-margin-right',
+                    'scroll-padding-bottom',
+                    'scroll-padding-top',
+                    'scroll-padding-left',
+                    'scroll-padding-right',
+                    'border-bottom-left-radius',
+                    'border-bottom-right-radius',
+                    'border-top-left-radius',
+                    'border-top-right-radius',
+                    'overscroll-behavior-x',
+                    'overscroll-behavior-y',
+                    'contain-intrinsic-height',
+                    'contain-intrinsic-width',
+                    'overflow-y',
+                    'overflow-x',
+                ],
+            },
+        ],
+        'logical-css/require-logical-units': null, // Safari 15+ supports logical properties but not logical units
+        'media-feature-name-no-unknown': true,
+        'media-feature-name-no-vendor-prefix': null,
+        'media-feature-name-value-no-unknown': true,
+        'named-grid-areas-no-invalid': true,
+        'no-descending-specificity': null,
+        'no-duplicate-at-import-rules': true,
+        'no-duplicate-selectors': true,
+        'no-empty-source': true,
+        'no-invalid-double-slash-comments': true,
+        'no-invalid-position-at-import-rule': null,
+        'no-irregular-whitespace': true,
+        'no-unknown-animations': null,
+        'no-unknown-custom-media': true,
+        'order/properties-order': [
+            [
+                'all',
+                'content',
+                'position',
+                'inset',
+                {
+                    order: 'flexible',
+                    properties: ['top', 'left', 'right', 'bottom'],
+                },
+                'z-index',
+                'display',
+            ],
+            { unspecified: 'bottom' },
+        ],
+        'plugin/no-unsupported-browser-features': [
+            true,
+            {
+                browsers: browserslist,
+                ignore: [
+                    'css-resize',
+                    'css3-cursors',
+                    'css3-attr',
+                    'css-selection',
+                    'css-nth-child-of',
+                    'css3-cursors-grab',
+                    'css-has', // Safari 15.4+
+                    'css-nesting', // Safari 17.2+
+                    'css-overscroll-behavior', // Safari 16+
+                    'css-scroll-behavior', // Safari 15.4+
+                    'css-focus-visible', // Safari 15.4+
+                    'css-containment', // Safari 15.4+
+                    'css-grid-animation', // Safari 16+
+                    'css-autofill', // Safari 15+
+                    'css-text-align-last', // Safari 16+
+                    'css-scrollbar', // Safari 18.2+
+                    'css-touch-action', // Safari NaN
+                    'css-content-visibility', // Safari 18+
+                    'viewport-unit-variants', // Safari 16+
+                ],
+                ignorePartialSupport: true,
+            },
+        ],
+        'plugin/use-baseline': [
+            true,
+            {
+                available: 2021, // Safari 14.5 was released by Apple in May 2021
+                ignoreAtRules: ['view-transition', 'property', '/^font-/', '/^supports/'],
+                ignoreFunctions: [
+                    'color-mix', // Safari 16+
+                    'rect', // Safari 17+
+                    'anchor', // Safari 26+
+                    'anchor-size', // Safari 26+
+                ],
+                ignoreProperties: {
+                    '/^anchor-/': ['/^.+$/'], // Safari 26+
+                    '/^animation-/': ['/^.+$/'],
+                    '/^mask-/': ['/^.+$/'],
+                    '/^scroll-snap-/': ['/^.+$/'], // Safari 15+
+                    'accent-color': ['/^.+$/'], // Safari NaN
+                    appearance: ['/^.+$/'], // Safari 15+
+                    'backdrop-filter': ['/^.+$/'],
+                    'backface-visibility': ['/^.+$/'],
+                    'box-decoration-break': ['/^.+$/'], // Safari NaN
+                    clip: ['/^.+$/'],
+                    'clip-path': ['/^.+$/'],
+                    'color-scheme': ['/^.+$/'],
+                    contain: ['/^.+$/'], // Safari 15+
+                    'contain-intrinsic-block-size': ['/^.+$/'], // Safari 18+
+                    'content-visibility': ['/^.+$/'], // Safari 18+
+                    hyphens: ['auto'],
+                    'line-clamp': ['/^.+$/'],
+                    mask: ['/^.+$/'],
+                    'mix-blend-mode': ['/^.+$/'],
+                    outline: ['/^.+$/'],
+                    overflow: ['clip'], // Safari 16+
+                    'overflow-clip-margin': ['/^.+$/'], // Safari NaN
+                    'overflow-wrap': ['anywhere'], // Safari 15+
+                    'overscroll-behavior': ['/^.+$/'], // Safari 16+
+                    'overscroll-behavior-x': ['/^.+$/'], // Safari 16+
+                    'position-anchor': ['/^.+$/'],
+                    resize: ['/^.+$/'],
+                    rotate: ['/^.+$/'],
+                    scale: ['/^.+$/'],
+                    'scroll-behavior': ['/^.+$/'], // Safari 15+
+                    'scrollbar-width': ['/^.+$/'], // Safari 18.2+
+                    'text-decoration': ['currentColor'],
+                    'text-wrap': ['/^.+$/'], // Safari 17+
+                    'timeline-scope': ['/^.+$/'], // Safari 26+
+                    translate: ['/^.+$/'],
+                    'user-select': ['none', 'auto'],
+                    'view-timeline': ['/^.+$/'], // Safari 26+
+                    'word-break': ['break-word'],
+                    'writing-mode': ['tb'],
+                    zoom: ['/^.+$/'],
+                },
+                ignoreSelectors: [
+                    'nesting',
+                    'host-context',
+                    'selection',
+                    'has', // Safari 15.4+
+                    'focus-visible', // Safari 15+
+                    'fullscreen', // Safari 16+
+                ],
+                ignoreUnits: ['svh'],
+            },
+        ],
+        'property-disallowed-list': [
+            '/^word-wrap$/', // The word-wrap property was renamed to overflow-wrap in CSS3
+        ],
+        'property-no-unknown': [true, { ignoreProperties: ['interpolate-size'] }],
+        'property-no-vendor-prefix': null,
+        'rem-over-px/rem-over-px': [
+            true,
+            {
+                fontSize: 16,
+                ignore: [
+                    '-2px',
+                    '-1px',
+                    '0.1px',
+                    '0.2px',
+                    '0.3px',
+                    '0.4px',
+                    '0.5px',
+                    '0.6px',
+                    '0.7px',
+                    '0.8px',
+                    '0.9px',
+                    '1px',
+                    '2px',
+                    'font 16px',
+                ],
+                ignoreAtRules: ['media'],
+                ignoreFunctions: ['url'],
+            },
+        ],
+        'rule-empty-line-before': [
+            'always',
+            {
+                except: ['first-nested'],
+                ignore: ['after-comment'],
+            },
+        ],
+        'selector-anb-no-unmatchable': true,
+        'selector-attribute-quotes': 'always',
+        'selector-max-id': null,
+        'selector-max-specificity': null,
+        'selector-max-type': null,
+        'selector-no-qualifying-type': null,
+        'selector-no-vendor-prefix': true,
+        'selector-pseudo-class-no-unknown': true,
+        'selector-pseudo-element-colon-notation': 'double',
+        'selector-pseudo-element-no-unknown': [true, { ignorePseudoElements: ['ng-deep'] }],
+        'selector-type-case': 'lower',
+        'selector-type-no-unknown': [
+            true,
+            {
+                ignoreTypes: [
+                    /^app$/,
+                    /^markdown$/,
+                    '/^my-/',
+                    '/^cdk-/',
+                    '/^app-/',
+                    '/^tui-/',
+                    '/^ng-/',
+                ],
+            },
+        ],
+        'shorthand-property-no-redundant-values': true,
+        'string-no-newline': true,
+        'time-min-milliseconds': null,
+        'unit-allowed-list': [
+            'px',
+            'rem',
+            'em',
+            'deg',
+            's',
+            'ms',
+            'dpcm',
+            'turn',
+            'ch',
+            '%',
+            'vh',
+            'vw',
+            'fr',
+            'svh',
+            'lh',
+        ],
+        'unit-no-unknown': true,
+        'value-keyword-case': [
+            'lower',
+            {
+                ignoreKeywords: ['currentColor', 'backgroundColor', 'optimizeLegibility'],
+                ignoreProperties: ['/^--/', String.raw `/^\$/`],
+            },
+        ],
+        'value-no-vendor-prefix': true,
+    },
+};
+
+export { config as default };
+//# sourceMappingURL=index.esm.js.map