eslint-plugin-chrome-extensions 2.5.0 → 2.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-chrome-extensions",
-  "version": "2.5.0",
+  "version": "2.6.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": {
@@ -83,8 +81,7 @@
     "eslint-plugin-package-json": "^1.10.1",
     "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-security": "^4.2.0"
   },
   "peerDependencies": {
     "@eslint/css": ">=0.5.0",

package/src/data/deprecations.js

@@ -2,9 +2,7 @@
 
 export default {
     bundles: {
-        'no-invalid-permissions': ['recommended'], // 2026-10-5 announced future removal
-        'require-mv3':            ['recommended'], // 2026-10-5 announced future removal
-        'valid-mv3-schema':       ['recommended'], // 2026-10-5 announced future removal
-        'valid-version-field':    ['recommended']  // 2026-10-5 announced future removal
+        // <rule-id-a>: [<old-bundle>],
+        // <rule-id-b>: [<old-bundle>]
     }
 }

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,6 +1,6 @@
 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$/,

package/src/index.js

@@ -1,5 +1,5 @@
-import deprecations from './data/deprecations.js'
 import init from './utils/init.js'
+import deprecations from './data/deprecations.js'
 
 const plugin = init.plugin()
 

package/src/rules/no-invalid-locales.js

@@ -0,0 +1,89 @@
+/* eslint-disable security/detect-non-literal-fs-filename -- lint-time project inspection only */
+
+import extension from '../utils/extension.js'
+import fs from 'node:fs'
+import i18nUtils from '../utils/i18n.js'
+import path from 'node:path'
+
+import regex from '../data/regex.js'
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow invalid Chrome locale codes in `_locales/` folders and `default_locale`',
+            category: 'Possible Errors',
+            recommended: true,
+            manifest: true
+        },
+        schema: [{
+            type: 'object',
+            properties: {
+                allowedLocales: {
+                    oneOf: [
+                        { type: 'string', description: 'Single locale code to allow' },
+                        {
+                            type: 'array',
+                            items: { type: 'string', description: 'Locale code to allow' },
+                            description: 'List of locale codes to allow'
+                        }
+                    ],
+                    description: 'Additional locale codes to allow (e.g. for Chromium forks)'
+                }
+            },
+            additionalProperties: false
+        }],
+        defaultOptions: [{ allowedLocales: [] }],
+        messages: {
+            invalidLocale: '`{{value}}` is not a Chrome-supported locale code.'
+        }
+    },
+
+    create(context) {
+        const filename = extension.file.getName(context),
+              isManifest = regex.filename.manifest.test(filename),
+              isScript = regex.filename.script.test(filename)
+        if (!isManifest && !isScript) return {}
+        const opts = context.options[0] || {},
+              allowed = new Set(Array.isArray(opts.allowedLocales) ? opts.allowedLocales
+                      : opts.allowedLocales ? [opts.allowedLocales] : []),
+              invalidFolders = [],
+              root = extension.findRoot(context)
+        if (root) {
+            const localesDir = path.join(root, '_locales')
+            try {
+                for (const entry of fs.readdirSync(localesDir, { withFileTypes: true }))
+                    if (entry.isDirectory() && isInvalid(entry.name)) invalidFolders.push(entry.name)
+                invalidFolders.sort()
+            } catch {} // eslint-disable-line no-empty
+        }
+        const loc = { line: 1, column: 1 }
+        if (!isManifest) {
+            const manifest = extension.manifest.read(context)
+            if (manifest) {
+                const defaultLocale = manifest.default_locale
+                if (isInvalid(defaultLocale))
+                    context.report({ loc, messageId: 'invalidLocale', data: { value: defaultLocale }})
+            }
+            for (const name of invalidFolders)
+                context.report({ loc, messageId: 'invalidLocale', data: { value: name }})
+            return {}
+        }
+        function isInvalid(locale) {
+            return typeof locale == 'string' && !i18nUtils.localeIsValid(locale, allowed) }
+        return {
+            '*'(node) {
+                const keyNode = node.name || node.key ; if (!keyNode) return
+                const keyName = keyNode.value ?? keyNode.name ; if (keyName != 'default_locale') return
+                const valueNode = node.value ; if (valueNode?.type != 'String') return
+                if (isInvalid(valueNode.value))
+                    context.report({ node: valueNode, messageId: 'invalidLocale',
+                                     data: { value: valueNode.value }})
+            },
+            'Document:exit'() {
+                for (const name of invalidFolders)
+                    context.report({ loc, messageId: 'invalidLocale', data: { value: name }})
+            }
+        }
+    }
+}

package/src/rules/no-invalid-permissions.js

@@ -1,6 +1,4 @@
 import extension from '../utils/extension.js'
-
-import permissions from '../data/permissions.js'
 import regex from '../data/regex.js'
 
 export default {
@@ -9,7 +7,7 @@ export default {
         docs: {
             description: 'Disallow invalid or unsupported manifest permission names',
             category: 'Possible Errors',
-            recommended: false,
+            recommended: true,
             manifest: true
         },
         defaultOptions: [{ target: 'mv3', allowedPermissions: [] }],
@@ -46,7 +44,7 @@ export default {
                       : opts.allowedPermissions ? [opts.allowedPermissions] : [])
         function checkPermission(node, permission) {
             if (typeof permission != 'string') return
-            if (allowed.has(permission) || permissions.isValid(permission, target)) return
+            if (allowed.has(permission) || extension.manifest.permission.isValid(permission, target)) return
             context.report({ node, messageId: 'invalidPermission', data: { permission, target }})
         }
         if (regex.filename.manifest.test(extension.file.getName(context))) // lint it directly
@@ -67,7 +65,7 @@ export default {
         return {
             'Program:exit'() {
                 for (const permission of allPermissions) {
-                    if (allowed.has(permission) || permissions.isValid(permission, target)) continue
+                    if (allowed.has(permission) || extension.manifest.permission.isValid(permission, target)) continue
                     context.report({ loc: { line: 1, column: 0 },
                         messageId: 'invalidPermission', data: { permission, target }})
                 }

package/src/rules/no-missing-default-locale.js

@@ -7,14 +7,7 @@ import path from 'node:path'
 
 import regex from '../data/regex.js'
 
-function readMessages(filePath) {
-    try {
-        const data = JSON.parse(fs.readFileSync(filePath, 'utf8'))
-        return (data && typeof data == 'object' && !Array.isArray(data)) ? data : null
-    } catch { return null }
-}
-
-function readLocaleDirs(localesDir) {
+function readLocaleDirs(localesDir)  {
     try {
         return fs.readdirSync(localesDir, { withFileTypes: true })
             .filter(entry => entry.isDirectory())
@@ -22,13 +15,20 @@ function readLocaleDirs(localesDir) {
     } catch { return [] }
 }
 
+function readMessages(filePath) {
+    try {
+        const data = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+        return (data && typeof data == 'object' && !Array.isArray(data)) ? data : null
+    } catch { return null }
+}
+
 export default {
     meta: {
         type: 'problem',
         docs: {
             description: 'Ensure `default_locale` is valid and all `_locales` keys exist in it',
             category: 'Possible Errors',
-            recommended: false,
+            recommended: true,
             manifest: true
         },
         schema: [{
@@ -36,23 +36,29 @@ export default {
             properties: {
                 ignoreKeys: {
                     type: 'array', items: { type: 'string' },
-                    description: 'Keys to skip when checking the default locale'
+                    description: 'Keys to skip when checking locales'
+                },
+                checkAllLocales: {
+                    type: 'boolean',
+                    description: 'Also flag keys missing from any locale, not just the default'
                 }
             },
             additionalProperties: false
         }],
-        defaultOptions: [{ ignoreKeys: [] }],
+        defaultOptions: [{ ignoreKeys: [], checkAllLocales: false }],
         messages: {
             missingDefaultLocale: '`_locales/` exists but `default_locale` is not declared.',
             unexpectedDefaultLocale: '`default_locale` is declared but no `_locales/` directory exists.',
             missingDefaultLocaleFile: '`_locales/{{locale}}/messages.json` does not exist.',
             missingKeyInDefault: '`{{key}}` exists in `_locales/{{locale}}/messages.json`, '
-                               + 'but not in default locale `{{defaultLocale}}`.'
+                               + 'but not in default locale `{{defaultLocale}}`.',
+            missingKeyInLocale: '`{{key}}` is missing from `_locales/{{locale}}/messages.json`.'
         }
     },
 
     create(context) {
-        const filename = context.filename ; if (!filename || !regex.filename.manifest.test(filename)) return {}
+        const filename = extension.file.getName(context) ; if (!filename) return {}
+        if (!regex.filename.manifest.test(filename) && !regex.filename.script.test(filename)) return {}
         const manifest = extension.manifest.read(context) ; if (!manifest) return {}
         const root = extension.findRoot(context) ; if (!root) return {}
         const localesDir = path.join(root, '_locales'),
@@ -60,6 +66,7 @@ export default {
               defaultLocale = manifest.default_locale,
               opts = context.options[0] || {},
               ignored = new Set(opts.ignoreKeys || []),
+              checkAllLocales = opts.checkAllLocales ?? false,
               loc = { line: 1, column: 1 }
         if (hasLocales && typeof defaultLocale != 'string') {
             context.report({ loc, messageId: 'missingDefaultLocale' })
@@ -75,7 +82,25 @@ export default {
             context.report({ loc, messageId: 'missingDefaultLocaleFile', data: { locale: defaultLocale }})
             return {}
         }
-        for (const locale of readLocaleDirs(localesDir)) {
+        const localeDirs = readLocaleDirs(localesDir)
+        if (checkAllLocales) {
+            const allMsgs = new Map([[defaultLocale, defaultMsgs]])
+            for (const locale of localeDirs) {
+                if (locale == defaultLocale) continue
+                const msgs = readMessages(path.join(localesDir, locale, 'messages.json'))
+                if (msgs) allMsgs.set(locale, msgs)
+            }
+            const union = new Set()
+            for (const msgs of allMsgs.values())
+                for (const key of Object.keys(msgs))
+                    if (!i18n.isPredefined(key) && !ignored.has(key)) union.add(key)
+            for (const [locale, msgs] of allMsgs)
+                for (const key of union)
+                    if (!(key in msgs))
+                        context.report({ loc, messageId: 'missingKeyInLocale', data: { key, locale }})
+            return {}
+        }
+        for (const locale of localeDirs) {
             if (locale == defaultLocale) continue
             const msgs = readMessages(path.join(localesDir, locale, 'messages.json')) ; if (!msgs) continue
             for (const key of Object.keys(msgs)) {

package/src/rules/no-missing-i18n-keys.js

@@ -13,9 +13,7 @@ export default {
             category: 'Possible Errors',
             recommended: true,
             manifest: true,
-            css: true,
-            html: true,
-            json: true
+            css: true
         },
         schema: [{
             type: 'object',
@@ -57,7 +55,7 @@ export default {
                         context.report({ loc, messageId: 'missingKey', data: { key, locale: i18n.locale }})
                 }
             }
-        if (!regex.filename.cssHTML.test(filename) && !regex.filename.manifest.test(filename))
+        if (!regex.filename.css.test(filename) && !regex.filename.manifest.test(filename))
             return {}
         const seenKeys = new Set()
         function scanPlaceholders() {
@@ -69,6 +67,6 @@ export default {
                     context.report({ loc, messageId: 'missingKey', data: { key, locale: i18n.locale }})
             }
         }
-        return { 'Document': scanPlaceholders, 'Program': scanPlaceholders }
+        return { 'Document': scanPlaceholders, 'Program': scanPlaceholders, 'StyleSheet': scanPlaceholders }
     }
 }

package/src/rules/no-sensitive-permissions.js

@@ -7,7 +7,7 @@ export default {
     meta: {
         type: 'problem',
         docs: {
-            description: 'Flag sensitive permissions that warrant security review',
+            description: 'Flag sensitive permissions',
             category: 'Possible Errors',
             recommended: true,
             security: true,

package/src/rules/no-unrestricted-host-permissions.js

@@ -10,7 +10,8 @@ export default {
         docs: {
             description: 'Disallow broad host permissions that grant access to every site',
             category: 'Possible Errors',
-            recommended: false,
+            recommended: true,
+            security: true,
             manifest: true
         },
         defaultOptions: [{ allowedPatterns: [] }],
@@ -32,23 +33,37 @@ export default {
     },
 
     create(context) {
-        if (!regex.filename.manifest.test(extension.file.getName(context))) return {}
         const allowedPatterns = new Set(context.options[0]?.allowedPatterns || [])
+        function isBroad(pattern) {
+            return typeof pattern == 'string'
+                && !allowedPatterns.has(pattern)
+                && re.broadHost.test(pattern)
+        }
+        if (regex.filename.manifest.test(extension.file.getName(context))) // lint it directly
+            return {
+                '*'(node) {
+                    const keyNode = node.name || node.key ; if (!keyNode) return
+                    const keyName = keyNode.value ?? keyNode.name ; if (!hostKeys.has(keyName)) return
+                    const arrNode = node.value ; if (arrNode?.type != 'Array') return
+                    const nodeElems = arrNode.elements || arrNode.items || []
+                    for (const elem of nodeElems) {
+                        const valueNode = elem.value || elem,
+                              pattern = valueNode?.value
+                        if (!isBroad(pattern)) continue
+                        context.report({ node: valueNode, messageId: 'unrestrictedHost', data: { pattern }})
+                    }
+                }
+            }
+        const manifest = extension.manifest.read(context) ; if (!manifest) return {}
         return {
-            '*'(node) {
-                const keyNode = node.name || node.key ; if (!keyNode) return
-                const keyName = keyNode.value ?? keyNode.name
-                if (!hostKeys.has(keyName)) return
-                const arrNode = node.value ; if (arrNode?.type != 'Array') return
-                const nodeElems = arrNode.elements || arrNode.items || []
-                for (const elem of nodeElems) {
-                    const valueNode = elem.value || elem,
-                          pattern = valueNode?.value
-                    if (typeof pattern != 'string'
-                        || allowedPatterns.has(pattern)
-                        || !re.broadHost.test(pattern)
-                    ) continue
-                    context.report({ node: valueNode, messageId: 'unrestrictedHost', data: { pattern }})
+            'Program:exit'() {
+                for (const key of hostKeys) {
+                    const patterns = manifest[key] // eslint-disable-line security/detect-object-injection
+                    if (!Array.isArray(patterns)) continue
+                    for (const pattern of patterns)
+                        if (isBroad(pattern))
+                            context.report({ loc: { line: 1, column: 1 },
+                                messageId: 'unrestrictedHost', data: { pattern }})
                 }
             }
         }

package/src/rules/no-unused-permissions.js

@@ -33,7 +33,7 @@ export default {
         docs: {
             description: 'Flag manifest permissions whose APIs are never used',
             category: 'Possible Errors',
-            recommended: false,
+            recommended: true,
             manifest: true
         },
         schema: [],
@@ -43,11 +43,11 @@ export default {
     },
 
     create(context) {
-        if (!regex.filename.manifest.test(extension.file.getName(context))) return {}
+        const filename = extension.file.getName(context)
+        if (!regex.filename.manifest.test(filename) && !regex.filename.script.test(filename)) return {}
         const manifest = extension.manifest.read(context) ; if (!manifest) return {}
         const root = extension.findRoot(context) ; if (!root) return {}
-        const usedAPIs = collectUsedAPIs(manifest, root),
-              permissionNodes = new Map()
+        const usedAPIs = collectUsedAPIs(manifest, root)
         function isUsed(permission) {
             let knownPerm = false
             for (const [, perm] of apis.permissionMap)
@@ -57,6 +57,15 @@ export default {
                 if (apis.findPermission(api) == permission) return true
             return false
         }
+        if (!regex.filename.manifest.test(filename)) {
+            const loc = { line: 1, column: 1 },
+                  declared = [...(manifest.permissions || []), ...(manifest.optional_permissions || [])]
+            for (const permission of declared)
+                if (typeof permission == 'string' && !isUsed(permission))
+                    context.report({ loc, messageId: 'unusedPermission', data: { permission }})
+            return {}
+        }
+        const permissionNodes = new Map()
         return {
             '*'(node) {
                 const keyNode = node.name || node.key ; if (!keyNode) return

package/src/rules/require-mv3.js

@@ -7,7 +7,7 @@ export default {
         docs: {
             description: 'Require manifest_version 3',
             category: 'Possible Errors',
-            recommended: false,
+            recommended: true,
             manifest: true
         },
         schema: [],

package/src/rules/valid-manifest-icons.js

@@ -7,13 +7,32 @@ import regex from '../data/regex.js'
 const re = { svg: /\.svg$/i },
       sizes = { recommended: ['16', '32', '48', '128'], required: '128' }
 
+function validateIcons(context, icons, root, opts, loc) {
+    const { requireRecommended, checkFiles, checkSVG } = opts,
+            declaredSizes = new Set(Object.keys(icons))
+    if (requireRecommended) {
+        for (const size of sizes.recommended)
+            if (!declaredSizes.has(size))
+                context.report({ loc, messageId: 'missingSize', data: { size }})
+    } else if (!declaredSizes.has(sizes.required))
+        context.report({ loc, messageId: 'missingRequiredSize' })
+    for (const file of Object.values(icons)) {
+        if (typeof file != 'string') continue
+        if (checkSVG && re.svg.test(file))
+            context.report({ loc, messageId: 'svgNotSupported' })
+        else if (checkFiles && root // eslint-disable-next-line security/detect-non-literal-fs-filename
+            && !fs.existsSync(path.resolve(root, file))
+        ) context.report({ loc, messageId: 'missingFile', data: { file }})
+    }
+}
+
 export default {
     meta: {
         type: 'problem',
         docs: {
             description: 'Validate manifest icons: sizes, existing files, no SVG',
             category: 'Possible Errors',
-            recommended: false,
+            recommended: true,
             manifest: true
         },
         defaultOptions: [{
@@ -48,12 +67,21 @@ export default {
     },
 
     create(context) {
-        if (!regex.filename.manifest.test(extension.file.getName(context))) return {}
+        const filename = extension.file.getName(context)
+        if (!regex.filename.manifest.test(filename) && !regex.filename.script.test(filename)) return {}
         const opts = context.options[0] || {},
               requireRecommended = opts.requireRecommendedSizes !== false,
               checkFiles = opts.checkIconExists !== false,
               checkSVG = opts.noSVG !== false,
-              root = checkFiles ? extension.findRoot(context) : null
+              root = checkFiles ? extension.findRoot(context) : null,
+              resolved = { requireRecommended, checkFiles, checkSVG }
+        if (!regex.filename.manifest.test(filename)) {
+            const manifest = extension.manifest.read(context) ; if (!manifest) return {}
+            const icons = manifest.icons
+            if (!icons || typeof icons != 'object' || Array.isArray(icons)) return {}
+            validateIcons(context, icons, root, resolved, { line: 1, column: 1 })
+            return {}
+        }
         return {
             '*'(node) {
                 const keyNode = node.name || node.key ; if (!keyNode) return

package/src/rules/valid-mv3-schema.js

@@ -9,7 +9,7 @@ export default {
         docs: {
             description: 'Validate manifest against the MV3 schema',
             category: 'Possible Errors',
-            recommended: false,
+            recommended: true,
             manifest: true
         },
         schema: [],

package/src/rules/valid-url-fields.js

@@ -22,6 +22,39 @@ function collectStrings(obj, path = [], out = []) {
 
 function isURL(value) { return re.absoluteURL.test(value.replace(re.template, 'x')) }
 
+function validateManifest(context, manifest, opts) {
+    const { checkURLfields, checkMatchPatterns, allowedSchemes, allowAllURLs } = opts,
+          loc = { line: 1, column: 1 }
+    for (const { path, value } of collectStrings(manifest)) {
+        if (checkURLfields && manifestData.paths.url.has(path)) {
+            if (!isURL(value))
+                context.report({ loc, messageId: 'invalidURL', data: { field: path, value }})
+        } else if (checkMatchPatterns && manifestData.paths.match.has(path)) {
+            if (value == '<all_urls>') {
+                if (!allowAllURLs)
+                    context.report({ loc, messageId: 'allURLs', data: { field: path }})
+                continue
+            }
+            const match = value.match(re.match)
+            if (!match) {
+                context.report({ loc, messageId: 'invalidMatchPattern', data: { field: path, value }})
+                continue
+            }
+            const [, scheme, host] = match
+            if (scheme != '*' && !allowedSchemes.includes(scheme))
+                context.report({ loc, messageId: 'invalidScheme', data: { field: path, value }})
+            else if (scheme == 'file' && host != '')
+                context.report({ loc, messageId: 'invalidFileHost', data: { field: path, value }})
+            else if (path == 'externally_connectable.matches' && host.includes('*'))
+                context.report({ loc, messageId: 'invalidExternalHost', data: { field: path, value }})
+            else if (host.includes('*') && host != '*' && !host.startsWith('*.'))
+                context.report({ loc, messageId: 'invalidHost', data: { field: path, value }})
+            else if (path == 'web_accessible_resources.matches' && !value.endsWith('/*'))
+                context.report({ loc, messageId: 'invalidWARPath', data: { field: path, value }})
+        }
+    }
+}
+
 export default {
     meta: {
         type: 'problem',
@@ -70,53 +103,25 @@ export default {
     },
 
     create(context) {
-        if (!regex.filename.manifest.test(extension.file.getName(context))) return {}
+        const filename = extension.file.getName(context)
+        if (!regex.filename.manifest.test(filename) && !regex.filename.script.test(filename)) return {}
         const opts = context.options[0] || {},
               checkURLfields = opts.checkURLfields ?? true,
               checkMatchPatterns = opts.checkMatchPatterns ?? true,
               allowedSchemes = opts.allowedSchemes ?? ['https', 'file'],
               allowAllURLs = opts.allowAllURLs ?? false
         if (!checkURLfields && !checkMatchPatterns) return {}
+        const resolved = { checkURLfields, checkMatchPatterns, allowedSchemes, allowAllURLs }
+        if (!regex.filename.manifest.test(filename)) {
+            const manifest = extension.manifest.read(context) ; if (!manifest) return {}
+            validateManifest(context, manifest, resolved)
+            return {}
+        }
         return {
             'Document:exit'() {
                 let manifest
                 try { manifest = JSON.parse(context.sourceCode.text) } catch { return }
-                for (const { path, value } of collectStrings(manifest)) {
-                    if (checkURLfields && manifestData.paths.url.has(path)) {
-                        if (!isURL(value))
-                            context.report({ loc: { line: 1, column: 1 }, messageId: 'invalidURL',
-                                data: { field: path, value }})
-                    } else if (checkMatchPatterns && manifestData.paths.match.has(path)) {
-                        if (value == '<all_urls>') {
-                            if (!allowAllURLs)
-                                context.report({ loc: { line: 1, column: 1 }, messageId: 'allURLs',
-                                    data: { field: path }})
-                            continue
-                        }
-                        const match = value.match(re.match)
-                        if (!match) {
-                            context.report({ loc: { line: 1, column: 1 }, messageId: 'invalidMatchPattern',
-                                data: { field: path, value }})
-                            continue
-                        }
-                        const [, scheme, host] = match
-                        if (scheme != '*' && !allowedSchemes.includes(scheme))
-                            context.report({ loc: { line: 1, column: 1 }, messageId: 'invalidScheme',
-                                data: { field: path, value }})
-                        else if (scheme == 'file' && host != '')
-                            context.report({ loc: { line: 1, column: 1 }, messageId: 'invalidFileHost',
-                                data: { field: path, value }})
-                        else if (path == 'externally_connectable.matches' && host.includes('*'))
-                            context.report({ loc: { line: 1, column: 1 }, messageId: 'invalidExternalHost',
-                                data: { field: path, value }})
-                        else if (host.includes('*') && host != '*' && !host.startsWith('*.'))
-                            context.report({ loc: { line: 1, column: 1 }, messageId: 'invalidHost',
-                                data: { field: path, value }})
-                        else if (path == 'web_accessible_resources.matches' && !value.endsWith('/*'))
-                            context.report({ loc: { line: 1, column: 1 }, messageId: 'invalidWARPath',
-                                data: { field: path, value }})
-                    }
-                }
+                validateManifest(context, manifest, resolved)
             }
         }
     }