eslint-plugin-chrome-extensions 2.5.0 → 2.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-chrome-extensions",
-  "version": "2.5.0",
+  "version": "2.7.0",
   "description": "ESLint rules for Chrome extensions",
   "keywords": [
     "eslint",
@@ -54,10 +54,8 @@
     "bump:minor": "bash utils/bump.sh minor",
     "bump:patch": "bash utils/bump.sh patch",
     "demo": "node demo/run.js",
-    "lint": "eslint . --cache && yamllint .",
-    "lint:all": "eslint . && yamllint .",
-    "lint:fix": "eslint . --fix --cache && yamllint .",
-    "lint:fix-all": "eslint . --fix && yamllint .",
+    "lint": "pre-commit run",
+    "lint:all": "pre-commit run --all-files",
     "test": "node tests/run.js"
   },
   "dependencies": {
@@ -71,7 +69,7 @@
     "@eslint/js": "^10.0.1",
     "@eslint/json": "^2.1.1",
     "@eslint/markdown": "^7.5.1",
-    "@html-eslint/eslint-plugin": "^0.66.1",
+    "@html-eslint/eslint-plugin": "^0.67.0",
     "@stylistic/eslint-plugin": "^5.10.0",
     "eslint": "^10.12.0",
     "eslint-plugin-constructors": "^1.4.3",
@@ -84,7 +82,7 @@
     "eslint-plugin-promise": "^7.3.0",
     "eslint-plugin-regexp": "^3.3.1",
     "eslint-plugin-security": "^4.2.0",
-    "yamllint-js": "^0.2.4"
+    "eslint-plugin-woodpecker": "^1.0.0"
   },
   "peerDependencies": {
     "@eslint/css": ">=0.5.0",

package/src/data/i18n.js

@@ -1,5 +1,13 @@
 export default {
     defaultScanExtensions: ['cjs', 'css', 'htm', 'html', 'js', 'json', 'jsx', 'md', 'mjs', 'svg', 'ts', 'tsx', 'txt'],
+    locales: {
+        supported: new Set([ // https://developer.chrome.com/docs/extensions/reference/api/i18n
+            'af', 'am', 'ar', 'bg', 'bn', 'ca', 'cs', 'da', 'de', 'el', 'en', 'en_AU', 'en_GB', 'en_IN', 'en_US', 'es',
+            'es_419', 'es_MX', 'es_US', 'et', 'fa', 'fi', 'fil', 'fr', 'fr_CA', 'fr_FR', 'gu', 'he', 'hi', 'hr', 'hu',
+            'id', 'it', 'ja', 'kn', 'ko', 'lt', 'lv', 'ml', 'mr', 'ms', 'nl', 'no', 'pl', 'pt_BR', 'pt_PT', 'ro', 'ru',
+            'sk', 'sl', 'sr', 'sv', 'sw', 'ta', 'te', 'th', 'tr', 'uk', 'vi', 'zh_CN', 'zh_TW'
+        ])
+    },
     re: {
         getMsg: {
             literal: /\b(?:browser|chrome)\.i18n\.getMessage\(\s*['"]([^'"]+)['"]/g,

package/src/data/permissions.js

@@ -1,5 +1,3 @@
-import regex from './regex.js'
-
 export default {
     sensitive: new Set([
         'accessibilityFeatures.modify', 'accessibilityFeatures.read', 'bookmarks', 'browsingData', 'clipboardRead',
@@ -22,10 +20,5 @@ export default {
         'sessions', 'sidePanel', 'storage', 'system.cpu', 'system.display', 'system.memory', 'system.storage',
         'tabCapture', 'tabGroups', 'tabs', 'topSites', 'tts', 'ttsEngine', 'unlimitedStorage', 'userScripts',
         'vpnProvider', 'wallpaper', 'webAuthenticationProxy', 'webNavigation', 'webRequest', 'webRequestBlocking'
-    ]),
-    isValid(name, target = 'mv3') {
-        if (this.valid.has(name)) return true
-        if (target == 'mv3') return false
-        return regex.url.test(name) || name.startsWith('<') || name == '*://*/*'
-    }
+    ])
 }

package/src/data/regex.js

@@ -1,10 +1,11 @@
 export default {
     filename: {
-        cssHTML: /\.(css|htm|html)$/i,
+        css: /\.css$/i,
         license: // eslint-disable-next-line security/detect-unsafe-regex
             /^(?:[\w.-]*-)?(?:LICEN[SC]E|COPYING)(?:[-.][\w.-]+)?$/i,
         manifest: /manifest\.json$/,
         script: /\.[cm]?[jt]sx?$/i
     },
+    prefix: { at: /^@/, css: /^CSS/ },
     url: /^https?:\/\//
 }

package/src/index.js

@@ -1,4 +1,3 @@
-import deprecations from './data/deprecations.js'
 import init from './utils/init.js'
 
 const plugin = init.plugin()
@@ -6,7 +5,4 @@ const plugin = init.plugin()
 init.rules(plugin)
 init.configs(plugin)
 
-for (const entry of Object.entries(deprecations.bundles))
-    init.bundleDeprecation(plugin, entry, 'chrome-extensions')
-
 export { plugin as default, plugin as chromeExtensions }

package/src/rules/css-spacing.js

@@ -0,0 +1,367 @@
+/* eslint-disable security/detect-object-injection -- array indices are controlled */
+
+import extension from '../utils/extension.js'
+import regex from '../data/regex.js'
+
+const re = { leadingWhitespace: /^[ \t]+/, trailingWhitespace: /[ \t]+$/ },
+      combinators = new Set(['>', '+', '~'])
+
+function endOf(node) { return node.loc.end.offset }
+function startOf(node) { return node.loc.start.offset }
+
+export default {
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'Enforces consistent indentation and spacing in CSS',
+            category: 'Stylistic Issues',
+            css: true
+        },
+        fixable: 'whitespace',
+        schema: [{
+            type: 'object',
+            properties: {
+                spaces: { type: 'number', description: 'Number of spaces per indent level (default 2)' },
+                checkBraces: { type: 'boolean', description: 'Enforce 1 space after `{` and before `}` in single-line rules (default true)' },
+                checkBrackets: { type: 'boolean', description: 'Enforce 0 spaces after `[` and before `]` in attribute selectors (default true)' },
+                checkColons: { type: 'boolean', description: 'Enforce 0 spaces before and 1 space after `:` in declarations, and 1 space between value tokens (default true)' },
+                checkCombinators: { type: 'boolean', description: 'Enforce 1 space on each side of `>`, `+`, `~` in selectors (default true)' },
+                checkCommas: { type: 'boolean', description: 'Enforce 0 spaces before and 1 space after `,` in selector lists (default true)' },
+                checkParentheses: { type: 'boolean', description: 'Enforce 0 spaces after `(` and before `)` in functions and pseudo-classes (default true)' },
+                checkSemicolons: { type: 'boolean', description: 'Enforce 1 space after `;` in single-line declaration blocks (default true)' }
+            },
+            additionalProperties: false
+        }],
+        defaultOptions: [{
+            spaces: 2, checkBraces: true, checkBrackets: true, checkColons: true,
+            checkCombinators: true, checkCommas: true, checkParentheses: true, checkSemicolons: true
+        }],
+        messages: {
+            wrongIndent: 'Expected {{expected}} spaces of indentation (found {{found}}).',
+            tabFound: 'Expected spaces for indentation, found tabs.',
+            spaceBeforeColon: 'Expected no spaces before `:`.',
+            spaceAfterColon: 'Expected 1 space after `:`.',
+            spaceBeforeComma: 'Expected no spaces before `,`.',
+            spaceAfterComma: 'Expected 1 space after `,`.',
+            spaceAfterBrace: 'Expected 1 space after `{`.',
+            spaceBeforeBrace: 'Expected 1 space before `}`.',
+            spaceInEmptyBraces: 'Expected no spaces in empty `{}`.',
+            spaceAfterBracket: 'Expected no spaces after `[`.',
+            spaceBeforeBracket: 'Expected no spaces before `]`.',
+            spaceAfterParen: 'Expected no spaces after `(`.',
+            spaceBeforeParen: 'Expected no spaces before `)`.',
+            spaceAroundCombinator: 'Expected 1 space on each side of `{{combinator}}`.',
+            spaceAfterSemicolon: 'Expected 1 space after `;`.',
+            spaceBetweenValues: 'Expected 1 space between value tokens.'
+        }
+    },
+
+    create(context) {
+        if (!regex.filename.css.test(extension.file.getName(context))) return {}
+        const opts = context.options[0] || {},
+              spaces = opts.spaces ?? 2,
+              checkBraces = opts.checkBraces ?? true,
+              checkBrackets = opts.checkBrackets ?? true,
+              checkColons = opts.checkColons ?? true,
+              checkCombinators = opts.checkCombinators ?? true,
+              checkCommas = opts.checkCommas ?? true,
+              checkParentheses = opts.checkParentheses ?? true,
+              checkSemicolons = opts.checkSemicolons ?? true,
+              sourceCode = context.sourceCode,
+              text = sourceCode.text,
+              lines = text.split('\n'),
+              lineOffsets = [0]
+        for (const line of lines) lineOffsets.push(lineOffsets.at(-1) + line.length +1)
+        function checkBlockBraces(block) {
+            if (!checkBraces) return
+            const innerStart = startOf(block) +1,
+                  innerEnd = endOf(block) -1,
+                  interior = text.slice(innerStart, innerEnd)
+            if (interior.includes('\n')) return
+            if (!interior.trim()) {
+                if (interior != '')
+                    context.report({
+                        loc: block.loc, messageId: 'spaceInEmptyBraces',
+                        fix(fixer) { return fixer.replaceTextRange([innerStart, innerEnd], '') }
+                    })
+                return
+            }
+            const leadingWs = interior.match(re.leadingWhitespace)?.[0] ?? ''
+            if (leadingWs != ' ')
+                context.report({
+                    loc: block.loc.start, messageId: 'spaceAfterBrace',
+                    fix(fixer) { return fixer.replaceTextRange([innerStart, innerStart + leadingWs.length], ' ') }
+                })
+            const trailingWs = interior.match(re.trailingWhitespace)?.[0] ?? ''
+            if (trailingWs != ' ')
+                context.report({
+                    loc: block.loc.end, messageId: 'spaceBeforeBrace',
+                    fix(fixer) { return fixer.replaceTextRange([innerEnd - trailingWs.length, innerEnd], ' ') }
+                })
+        }
+        function checkBlockChildren(children) {
+            for (let i = 1 ; i < children.length ; i++)
+                if (children[i -1].type?.replace(regex.prefix.css, '') == 'Declaration'
+                    && children[i].type?.replace(regex.prefix.css, '') == 'Declaration')
+                    checkSemicolonBetween(children[i -1], children[i])
+        }
+        function checkBracketSpacing(node) {
+            if (!checkBrackets || !node?.loc) return
+            const innerStart = startOf(node) +1,
+                  innerEnd = endOf(node) -1,
+                  interior = text.slice(innerStart, innerEnd)
+            if (interior.includes('\n')) return
+            const leadingWs = interior.match(re.leadingWhitespace)?.[0] ?? ''
+            if (leadingWs)
+                context.report({
+                    loc: node.loc.start, messageId: 'spaceAfterBracket',
+                    fix(fixer) { return fixer.replaceTextRange([innerStart, innerStart + leadingWs.length], '') }
+                })
+            const trailingWs = interior.match(re.trailingWhitespace)?.[0] ?? ''
+            if (trailingWs)
+                context.report({
+                    loc: node.loc.end, messageId: 'spaceBeforeBracket',
+                    fix(fixer) { return fixer.replaceTextRange([innerEnd - trailingWs.length, innerEnd], '') }
+                })
+        }
+        function checkColon(decl) {
+            if (!checkColons || !decl.value?.loc) return
+            const declStart = startOf(decl),
+                  valueStart = startOf(decl.value),
+                  valueEnd = endOf(decl.value),
+                  between = text.slice(declStart, valueStart),
+                  colonPos = between.lastIndexOf(':')
+            if (colonPos < 0) return
+            const before = between.slice(0, colonPos),
+                  after = between.slice(colonPos +1),
+                  beforeTrailing = before.match(re.trailingWhitespace)?.[0] ?? ''
+            if (beforeTrailing) {
+                const fixEnd = declStart + colonPos
+                context.report({
+                    loc: decl.loc.start, messageId: 'spaceBeforeColon',
+                    fix(fixer) { return fixer.replaceTextRange([fixEnd - beforeTrailing.length, fixEnd], '') }
+                })
+            }
+            if (!after.includes('\n') && after != ' ') {
+                const fixStart = declStart + colonPos +1
+                context.report({
+                    loc: decl.loc.start, messageId: 'spaceAfterColon',
+                    fix(fixer) { return fixer.replaceTextRange([fixStart, valueStart], ' ') }
+                })
+            }
+            checkValueSpacing(valueStart, valueEnd)
+        }
+        function checkCombinatorSpacing(node) {
+            if (!checkCombinators || !node?.loc || !combinators.has(node.name)) return
+            const nodeStart = startOf(node),
+                  nodeEnd = endOf(node)
+            let i = nodeStart -1
+            while (i >= 0 && (text[i] == ' ' || text[i] == '\t')) i--
+            if (i >= 0 && text[i] != '\n') {
+                const beforeWs = text.slice(i +1, nodeStart)
+                if (beforeWs != ' ')
+                    context.report({
+                        loc: node.loc.start, messageId: 'spaceAroundCombinator',
+                        data: { combinator: node.name },
+                        fix(fixer) { return fixer.replaceTextRange([i +1, nodeStart], ' ') }
+                    })
+            }
+            let j = nodeEnd
+            while (j < text.length && (text[j] == ' ' || text[j] == '\t')) j++
+            if (j < text.length && text[j] != '\n') {
+                const afterWs = text.slice(nodeEnd, j)
+                if (afterWs != ' ')
+                    context.report({
+                        loc: node.loc.end, messageId: 'spaceAroundCombinator',
+                        data: { combinator: node.name },
+                        fix(fixer) { return fixer.replaceTextRange([nodeEnd, j], ' ') }
+                    })
+            }
+        }
+        function checkCommaBetween(prev, curr) {
+            if (!checkCommas) return
+            const prevEnd = endOf(prev),
+                  currStart = startOf(curr),
+                  between = text.slice(prevEnd, currStart)
+            if (between.includes('\n') || between == ', ') return
+            const commaIdx = between.indexOf(',')
+            if (commaIdx < 0) return
+            if (between.slice(0, commaIdx)) {
+                const commaPos = prevEnd + commaIdx
+                context.report({
+                    loc: offsetToLoc(commaPos), messageId: 'spaceBeforeComma',
+                    fix(fixer) { return fixer.replaceTextRange([prevEnd, commaPos], '') }
+                })
+            }
+            if (between.slice(commaIdx +1) != ' ') {
+                const commaPos = prevEnd + commaIdx
+                context.report({
+                    loc: offsetToLoc(commaPos +1), messageId: 'spaceAfterComma',
+                    fix(fixer) { return fixer.replaceTextRange([commaPos +1, currStart], ' ') }
+                })
+            }
+        }
+        function checkFunctionCommas(node) {
+            if (!checkCommas) return
+            const nodeStart = startOf(node),
+                  nodeText = text.slice(nodeStart, endOf(node)),
+                  openIdx = nodeText.indexOf('('),
+                  closeIdx = nodeText.lastIndexOf(')')
+            if (openIdx < 0 || closeIdx <= openIdx) return
+            const interior = nodeText.slice(openIdx +1, closeIdx)
+            if (interior.includes('\n')) return
+            let depth = 0, inString = null
+            for (let i = 0 ; i < interior.length ; i++) {
+                const ch = interior[i]
+                if (inString) {
+                    if (ch == '\\') { i++; continue }
+                    if (ch === inString) inString = null
+                    continue
+                }
+                if (ch == '"' || ch === `'`) { inString = ch; continue }
+                if (ch == '(') { depth++; continue }
+                if (ch == ')') { depth--; continue }
+                if (ch == ',' && depth === 0) {
+                    const commaPos = nodeStart + openIdx +1 + i,
+                          before = interior.slice(0, i).match(re.trailingWhitespace)?.[0] ?? '',
+                          after = interior.slice(i +1).match(re.leadingWhitespace)?.[0] ?? ''
+                    if (before)
+                        context.report({
+                            loc: offsetToLoc(commaPos), messageId: 'spaceBeforeComma',
+                            fix(fixer) { return fixer.replaceTextRange([commaPos - before.length, commaPos], '') }
+                        })
+                    if (after != ' ')
+                        context.report({
+                            loc: offsetToLoc(commaPos +1), messageId: 'spaceAfterComma',
+                            fix(fixer) { return fixer.replaceTextRange([commaPos +1, commaPos +1 + after.length], ' ') }
+                        })
+                }
+            }
+        }
+        function checkIndent(lineNum, expectedDepth) {
+            const lineText = lines[lineNum -1]
+            if (!lineText?.trim()) return
+            const indent = lineText.match(re.leadingWhitespace)?.[0] ?? '',
+                  expected = ' '.repeat(expectedDepth * spaces)
+            if (indent !== expected) {
+                const lineStart = lineOffsets[lineNum -1]
+                context.report({
+                    loc: { line: lineNum, column: 1 },
+                    messageId: indent.includes('\t') ? 'tabFound' : 'wrongIndent',
+                    data: { expected: expectedDepth * spaces, found: indent.length },
+                    fix(fixer) { return fixer.replaceTextRange([lineStart, lineStart + indent.length], expected) }
+                })
+            }
+        }
+        function offsetToLoc(offset) {
+            for (let i = lineOffsets.length -1; i >= 0; i--)
+                if (lineOffsets[i] <= offset)
+                    return { line: i +1, column: offset - lineOffsets[i] +1 }
+            return { line: 1, column: 1 }
+        }
+        function checkParenSpacing(node) {
+            if (!checkParentheses || !node?.loc) return
+            const nodeStart = startOf(node),
+                  nodeText = text.slice(nodeStart, endOf(node)),
+                  openIdx = nodeText.indexOf('('),
+                  closeIdx = nodeText.lastIndexOf(')')
+            if (openIdx < 0 || closeIdx <= openIdx) return
+            const interior = nodeText.slice(openIdx +1, closeIdx)
+            if (interior.includes('\n')) return
+            const leadingWs = interior.match(re.leadingWhitespace)?.[0] ?? ''
+            if (leadingWs)
+                context.report({
+                    loc: node.loc.start, messageId: 'spaceAfterParen',
+                    fix(fixer) {
+                        return fixer.replaceTextRange(
+                            [nodeStart + openIdx +1, nodeStart + openIdx +1 + leadingWs.length], '')
+                    }
+                })
+            const trailingWs = interior.match(re.trailingWhitespace)?.[0] ?? ''
+            if (trailingWs)
+                context.report({
+                    loc: node.loc.end, messageId: 'spaceBeforeParen',
+                    fix(fixer) {
+                        return fixer.replaceTextRange(
+                            [nodeStart + closeIdx - trailingWs.length, nodeStart + closeIdx], '')
+                    }
+                })
+        }
+        function checkSemicolonBetween(prev, curr) {
+            if (!checkSemicolons) return
+            const prevEnd = endOf(prev),
+                  currStart = startOf(curr),
+                  between = text.slice(prevEnd, currStart)
+            if (between.includes('\n') || between == '; ' || between == ' ') return
+            if (between.startsWith(';'))
+                context.report({
+                    loc: curr.loc.start, messageId: 'spaceAfterSemicolon',
+                    fix(fixer) { return fixer.replaceTextRange([prevEnd, currStart], '; ') }
+                })
+        }
+        function checkValueSpacing(valueStart, valueEnd) {
+            const rawText = text.slice(valueStart, valueEnd),
+                  scanStart = valueStart + (rawText.length - rawText.trimStart().length),
+                  scanEnd = valueEnd - (rawText.length - rawText.trimEnd().length)
+            if (scanEnd <= scanStart) return
+            const valueText = text.slice(scanStart, scanEnd)
+            if (valueText.includes('\n')) return
+            let inString = null
+            for (let i = 0 ; i < valueText.length ; i++) {
+                const ch = valueText[i]
+                if (inString) {
+                    if (ch == '\\') { i++; continue }
+                    if (ch === inString) inString = null
+                    continue
+                }
+                if (ch == '"' || ch === `'`) { inString = ch; continue }
+                if (ch == ' ' && valueText[i +1] == ' ') {
+                    let end = i
+                    while (end < valueText.length -1 && valueText[end +1] == ' ') end++
+                    const runStart = scanStart + i
+                    context.report({
+                        loc: offsetToLoc(runStart), messageId: 'spaceBetweenValues',
+                        fix(fixer) { return fixer.replaceTextRange([runStart, scanStart + end +1], ' ') }
+                    })
+                    i = end
+                }
+            }
+        }
+        function walkTree(node, depth) {
+            if (!node?.loc) return
+            const lineNum = node.loc.start.line,
+                  lineStart = lineOffsets[lineNum -1],
+                  indent = lines[lineNum -1]?.match(re.leadingWhitespace)?.[0] ?? ''
+            if (startOf(node) === lineStart + indent.length) checkIndent(lineNum, depth)
+            if (node.block?.children) {
+                checkBlockBraces(node.block)
+                checkBlockChildren(node.block.children)
+                for (const child of node.block.children) walkTree(child, depth +1)
+                if (node.block.loc.end.line !== node.block.loc.start.line)
+                    checkIndent(node.block.loc.end.line, depth)
+            }
+        }
+        return {
+            AttributeSelector(node) { checkBracketSpacing(node) },
+            Combinator(node) { checkCombinatorSpacing(node) },
+            Declaration(node) { checkColon(node) },
+            Function(node) {
+                checkParenSpacing(node)
+                checkFunctionCommas(node)
+            },
+            PseudoClassSelector(node) {
+                if (!text.slice(startOf(node), endOf(node)).includes('(')) return
+                checkParenSpacing(node)
+                checkFunctionCommas(node)
+            },
+            SelectorList(node) {
+                const children = node.children ?? []
+                for (let i = 1 ; i < children.length ; i++)
+                    checkCommaBetween(children[i -1], children[i])
+            },
+            'StyleSheet:exit'() {
+                for (const topNode of sourceCode.ast.children ?? []) walkTree(topNode, 0)
+            }
+        }
+    }
+}

package/src/rules/manifest-key-order.js

@@ -24,7 +24,6 @@ export default {
         docs: {
             description: 'Enforces a preferred order for manifest keys',
             category: 'Stylistic Issues',
-            recommended: false,
             manifest: true
         },
         fixable: 'code',

package/src/rules/manifest-spacing.js

@@ -10,7 +10,6 @@ export default {
         docs: {
             description: 'Enforces consistent indentation and spacing in `manifest.json`',
             category: 'Stylistic Issues',
-            recommended: false,
             manifest: true
         },
         fixable: 'whitespace',

package/src/rules/no-duplicate-manifest-keys.js

@@ -7,7 +7,6 @@ export default {
         docs: {
             description: 'Disallow duplicate keys in manifest.json',
             category: 'Possible Errors',
-            recommended: false,
             manifest: true
         },
         schema: [],

package/src/rules/no-global-keyframes.js

@@ -0,0 +1,84 @@
+import regex from '../data/regex.js'
+
+const commonNames = new Set([
+    'blink', 'bounce', 'bounce-in', 'bounce-out', 'fade', 'fade-in', 'fade-in-down', 'fade-in-left', 'fade-in-right',
+    'fade-in-up', 'fade-out', 'fade-out-down', 'fade-out-left', 'fade-out-right', 'fade-out-up', 'flip', 'flip-in',
+    'flip-out', 'heartbeat', 'hinge', 'jello', 'loading', 'progress', 'pulse', 'roll-in', 'roll-out', 'rotate', 'shake',
+    'slide', 'slide-in', 'slide-in-down', 'slide-in-left', 'slide-in-right', 'slide-in-up', 'slide-out',
+    'slide-out-down', 'slide-out-left', 'slide-out-right', 'slide-out-up', 'spin', 'spinner', 'swing', 'wobble', 'zoom',
+    'zoom-in', 'zoom-out'
+])
+const re = {
+    keyframesHeader: /^@(?:-webkit-)?keyframes\s+([\w-]+)/i,
+    quotes: /^["']|["']$/g
+}
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow `@keyframes` in content-script CSS that could collide with the host page',
+            category: 'Possible Errors',
+            css: true
+        },
+        defaultOptions: [{}],
+        schema: [{
+            type: 'object',
+            properties: {
+                flagCommonNames: {
+                    type: 'boolean',
+                    description: 'Flag well-known animation names (e.g. `spin`, `fade-in`)'
+                },
+                requiredPrefix: {
+                    type: 'string',
+                    minLength: 1,
+                    description: 'Flag any `@keyframes` name not starting w/ this prefix'
+                }
+            },
+            additionalProperties: false
+        }],
+        messages: {
+            missingRequiredPrefix: '`@keyframes {{name}}` must start w/ `{{requiredPrefix}}` '
+                                 + 'to avoid colliding with host page animations.',
+            commonKeyframeName: '`@keyframes {{name}}` is a common name likely to collide w/ host page animations. '
+                              + 'Prefix it with your extension namespace (e.g. `myext-{{name}}`).'
+        }
+    },
+
+    create(context) {
+        const opts = context.options[0] || {},
+              requiredPrefix = opts.requiredPrefix,
+              flagCommonNames = opts.flagCommonNames !== false
+        function getKeyframeName(node) {
+            const pv = node.prelude?.value
+            if (typeof pv == 'string' && pv.trim())
+                return pv.trim().replace(re.quotes, '')
+            for (const child of node.prelude?.children ?? []) {
+                const type = child.type?.replace(regex.prefix.css, '')
+                if (type == 'Identifier' || type == 'TypeSelector') {
+                    const name = (child.name ?? child.value ?? '').trim()
+                    if (name) return name.replace(re.quotes, '')
+                }
+            }
+            if (node.range)
+                return (context.sourceCode.text.slice(node.range[0], node.range[1])
+                    .match(re.keyframesHeader) ?? [])[1] ?? null
+            return null
+        }
+        function handleAtrule(node) {
+            const name = (node.name ?? '').replace(regex.prefix.at, '').toLowerCase()
+            if (name != 'keyframes' && name != '-webkit-keyframes') return
+            const keyframeName = getKeyframeName(node)
+            if (!keyframeName) return
+            if (requiredPrefix) {
+                if (!keyframeName.startsWith(requiredPrefix))
+                    context.report({ node, messageId: 'missingRequiredPrefix',
+                        data: { name: keyframeName, requiredPrefix }})
+                return
+            }
+            if (flagCommonNames && commonNames.has(keyframeName.toLowerCase()))
+                context.report({ node, messageId: 'commonKeyframeName', data: { name: keyframeName }})
+        }
+        return { Atrule: handleAtrule, CSSAtrule: handleAtrule, CSSAtRule: handleAtrule, AtRule: handleAtrule }
+    }
+}