eslint-plugin-chrome-extensions 2.6.0 → 2.8.0

package/src/rules/css-spacing.js

@@ -0,0 +1,375 @@
+// oxlint-disable security/detect-object-injection
+
+import extension from '../utils/extension.js'
+import regex from '../data/regex.js'
+
+const re = { leadingWhitespace: /^[ \t]+/ },
+      combinators = new Set(['>', '+', '~'])
+
+function endOf(node) { return node.loc.end.offset }
+function startOf(node) { return node.loc.start.offset }
+function getTrailingWs(str) {
+    let end = str.length
+    while (end > 0 && (str[end -1] == ' ' || str[end -1] == '\t')) end--
+    return str.slice(end)
+}
+
+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 = getTrailingWs(interior)
+            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 = getTrailingWs(interior)
+            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 = getTrailingWs(before)
+            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, i = 0
+            while (i < interior.length) {
+                const ch = interior[i]
+                if (inString) {
+                    if (ch == '\\') { i += 2 ; continue }
+                    if (ch === inString) inString = null
+                    i++ ; continue
+                }
+                if (ch == '"' || ch === `'`) { inString = ch ; i++ ; continue }
+                if (ch == '(') { depth++ ; i++ ; continue }
+                if (ch == ')') { depth-- ; i++ ; continue }
+                if (ch == ',' && depth === 0) {
+                    const commaPos = nodeStart + openIdx +1 + i,
+                          before = getTrailingWs(interior.slice(0, i)),
+                          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], ' ') }
+                        })
+                }
+                i++
+            }
+        }
+        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 = getTrailingWs(interior)
+            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 - getTrailingWs(rawText).length
+            if (scanEnd <= scanStart) return
+            const valueText = text.slice(scanStart, scanEnd)
+            if (valueText.includes('\n')) return
+            let inString = null, i = 0
+            while (i < valueText.length) {
+                const ch = valueText[i]
+                if (inString) {
+                    if (ch == '\\') { i += 2 ; continue }
+                    if (ch === inString) inString = null
+                    i++ ; continue
+                }
+                if (ch == '"' || ch === `'`) { inString = ch ; i++ ; 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 +1
+                    continue
+                }
+                i++
+            }
+        }
+        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

@@ -14,7 +14,7 @@ function findViolation(members, keys) {
               const key = keyOf(member)
               return { member, key, rank: ranks.get(key) }
           }).filter(item => item.rank !== undefined)
-    for (let i = 1 ; i < known.length ; i++) // eslint-disable-next-line security/detect-object-injection
+    for (let i = 1 ; i < known.length ; i++) // oxlint-disable-next-line security/detect-object-injection
         if (known[i -1].rank > known[i].rank) return [known[i -1], known[i]]
 }
 
@@ -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',
@@ -103,7 +102,7 @@ export default {
                     prevToken = token
                 }
                 for (let t = 0 ; t < tokens.length ; t++) { // check inline spacing
-                    const token = tokens[t], // eslint-disable-line security/detect-object-injection
+                    const token = tokens[t], // oxlint-disable-line security/detect-object-injection
                           type = token.type,
                           prev = tokens[t -1], next = tokens[t +1]
                     if (next) {

package/src/rules/no-content-style-leak.js

@@ -2,6 +2,18 @@ import extension from '../utils/extension.js'
 
 const re = { appendMethod: /^append(?:Child)?$/ }
 
+function isCreateStyle(node) {
+    return node?.type == 'CallExpression'
+        && node.callee?.property?.name == 'createElement'
+        && node.arguments[0]?.value == 'style'
+}
+function isObjectAssign(node) {
+    return node?.type == 'CallExpression'
+        && node.callee?.type == 'MemberExpression'
+        && node.callee.object?.name == 'Object'
+        && node.callee.property?.name == 'assign'
+}
+
 export default {
     meta: {
         type: 'suggestion',
@@ -20,17 +32,6 @@ export default {
         const manifest = extension.manifest.read(context)
         if (!manifest || !extension.file.isContentScript(context, manifest)) return {}
         const styleElems = new Set(), docAliases = new Set()
-        function isCreateStyle(node) {
-            return node?.type == 'CallExpression'
-                && node.callee?.property?.name == 'createElement'
-                && node.arguments[0]?.value == 'style'
-        }
-        function isObjectAssign(node) {
-            return node?.type == 'CallExpression'
-                && node.callee?.type == 'MemberExpression'
-                && node.callee.object?.name == 'Object'
-                && node.callee.property?.name == 'assign'
-        }
         function isDocumentRef(node) {
             return node?.type == 'Identifier'
                 && (node.name == 'document' || docAliases.has(node.name))

package/src/rules/no-deprecated-apis.js

@@ -1,5 +1,5 @@
+import apiUtils from '../utils/api.js'
 import nodeUtils from '../utils/node.js'
-import apis from '../data/apis.js'
 
 export default {
     meta: {
@@ -51,7 +51,7 @@ export default {
             MemberExpression(node) {
                 if (node.parent.type == 'MemberExpression' && node.parent.object === node) return
                 const api = nodeUtils.getMemberPath(node) ; if (!api?.startsWith('chrome.') || isAllowed(api)) return
-                const found = apis.findDeprecated(api) ; if (!found) return
+                const found = apiUtils.findDeprecated(api) ; if (!found) return
                 context.report({ node, messageId: 'deprecatedAPI',
                     data: { api: found.deprecated, replacement: found.replacement, target }})
             }

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 }
+    }
+}

package/src/rules/no-host-page-selectors.js

@@ -0,0 +1,105 @@
+import array from '../utils/array.js'
+import node from '../utils/node.js'
+
+const re = { keyframeSelector: /^(?:from|to|[\d.]+%)$/i }
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow host-page selectors (`html`, `body`, `:root`, `*`, bare element types) in content-script CSS',
+            category: 'Possible Errors',
+            css: true
+        },
+        defaultOptions: [{
+            allowedSelectors: [],
+            disallowUniversal: true,
+            disallowStructural: true,
+            disallowBareElements: true
+        }],
+        schema: [{
+            type: 'object',
+            properties: {
+                allowedSelectors: {
+                    oneOf: [
+                        { type: 'string', description: 'A single selector' },
+                        { type: 'array', items: { type: 'string' }, description: 'List of selectors' }
+                    ],
+                    description: 'Selectors to explicitly allow (e.g. `body.dark`)'
+                },
+                disallowUniversal: {
+                    type: 'boolean',
+                    description: 'Flag `*`'
+                },
+                disallowStructural: {
+                    type: 'boolean',
+                    description: 'Flag `html`, `body`, `:root`'
+                },
+                disallowBareElements: {
+                    type: 'boolean',
+                    description: 'Flag bare element types (`div`, `a`, etc.) lacking a class/id/attribute qualifier'
+                }
+            },
+            additionalProperties: false
+        }],
+        messages: {
+            universalSelector: 'Universal selector `*` targets every element on the host page. Scope with a namespaced class or use `:host`.',
+            structuralSelector: 'Selector `{{selector}}` targets a host-page structural element. Use `:host` or a namespaced root instead.',
+            elementSelector: 'Selector `{{selector}}` targets a bare element type on the host page. Scope with a namespaced class or wrap in `:host()`.'
+        }
+    },
+
+    create(context) {
+        const opts = context.options[0] || {},
+              allowedSelectors = new Set(array.to(opts.allowedSelectors)),
+              checkUniversal = opts.disallowUniversal !== false,
+              checkStructural = opts.disallowStructural !== false,
+              checkBareElements = opts.disallowBareElements !== false
+        function checkSelector(selector) {
+            if (!selector) return
+            const text = getSelectorText(selector).trim()
+            if (re.keyframeSelector.test(text) || allowedSelectors.has(text)) return
+            const simples = []
+            for (const child of selector.children ?? []) {
+                if (node.plainType(child) == 'Combinator') break
+                simples.push(child)
+            }
+            let hasQualifier = false,
+                isUniversal = false,
+                isRoot = false,
+                elementTypes = []
+            for (const simple of simples) {
+                const type = node.plainType(simple)
+                if (['AttributeSelector', 'ClassSelector', 'IdSelector'].includes(type)) hasQualifier = true
+                else if (type == 'PseudoClassSelector' && (simple.name ?? '').toLowerCase() == 'root') isRoot = true
+                else if (type == 'TypeSelector') {
+                    const name = (simple.name ?? '').toLowerCase()
+                    if (name == '*') isUniversal = true
+                    else if (name) elementTypes.push(name)
+                }
+            }
+            if (isUniversal && checkUniversal)
+                return context.report({ node: selector, messageId: 'universalSelector' })
+            if (isRoot && checkStructural)
+                return context.report({ node: selector, messageId: 'structuralSelector', data: { selector: text }})
+            for (const type of elementTypes) {
+                if (type == 'html' || type == 'body') {
+                    if (checkStructural)
+                        return context.report({ node: selector, messageId: 'structuralSelector', data: { selector: text }})
+                } else if (checkBareElements && !hasQualifier) {
+                    return context.report({ node: selector, messageId: 'elementSelector', data: { selector: text }})
+                }
+            }
+        }
+        function getSelectorText(selector) {
+            const range = selector.range
+            if (range?.length == 2) return context.sourceCode.text.slice(range[0], range[1])
+            return context.sourceCode.getText(selector)
+        }
+        function handleRule(node) {
+            for (const selector of node.prelude?.children ?? [])
+                checkSelector(selector)
+        }
+        return { Rule: handleRule, CSSRule: handleRule }
+    }
+}