eslint-plugin-greasemonkey 1.9.0 → 1.10.0

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

@@ -1,8 +1,9 @@
 import metadata from '../utils/metadata.js'
 import template from '../utils/template.js'
 
-const re = { specialChars: /[.*+?^${}()|[\]\\]/g, whitespace: /\s+/ },
-      resourceGetterNames = new Set(['GM_getResourceText', 'GM_getResourceURL'])
+import regex from '../data/regex.js'
+
+const resourceGetterNames = new Set(['GM_getResourceText', 'GM_getResourceURL'])
 
 export default {
     meta: {
@@ -29,8 +30,8 @@ export default {
                     const resolved = template.resolve(arg)
                     if (resolved)
                         for (const name of resolved) usedResources.add(name)
-                    else usedPatterns.push(new RegExp( // eslint-disable-line security/detect-non-literal-regexp
-                        `^${arg.quasis.map(quasi => quasi.value.raw.replace(re.specialChars, '\\$&')).join('.*')}$`))
+                    else usedPatterns.push(new RegExp( // oxlint-disable-line security/detect-non-literal-regexp
+                        `^${arg.quasis.map(quasi => quasi.value.raw.replace(regex.specialChars, '\\$&')).join('.*')}$`))
                 }
             },
             'Program:exit'() {
@@ -38,7 +39,7 @@ export default {
                       resources = metaEntries.filter(entry => entry.key == 'resource')
                 if (!resources.length) return
                 for (const res of resources) {
-                    const name = res.value.trim().split(re.whitespace)[0]
+                    const name = res.value.trim().split(regex.whitespace.all)[0]
                     if (usedResources.has(name) || usedPatterns.some(patt => patt.test(name))) continue
                     context.report({ node: res.comment, messageId: 'unusedResource', data: { name }})
                 }

package/src/rules/prefer-gm-add-style.js

@@ -1,5 +1,17 @@
 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',
@@ -16,11 +28,6 @@ export default {
 
     create(context) {
         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 isDocumentRef(node) {
             return node?.type == 'Identifier'
                 && (node.name == 'document' || docAliases.has(node.name))
@@ -28,12 +35,6 @@ export default {
         function isDocumentMember(node) {
             return node?.type == 'MemberExpression' && isDocumentRef(node.object)
         }
-        function isObjectAssign(node) {
-            return node?.type == 'CallExpression'
-                && node.callee?.type == 'MemberExpression'
-                && node.callee.object?.name == 'Object'
-                && node.callee.property?.name == 'assign'
-        }
         function isStyleTarget(node) {
             if (isCreateStyle(node)) return true
             if (node?.type == 'Identifier' && styleElems.has(node.name)

package/src/rules/require-license-header.js

@@ -0,0 +1,27 @@
+import regex from '../data/regex.js'
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Requires a `@license` metadata field',
+            category: 'Possible Errors',
+            recommended: false
+        },
+        schema: [],
+        messages: {
+            missingLicense: 'No `@license` field found. Add one (e.g. `@license MIT`).'
+        }
+    },
+    create(context) {
+        const sourceCode = context.sourceCode ?? context.getSourceCode()
+        return {
+            Program() {
+                const match = sourceCode.text.match(regex.meta.block)
+                if (!match) return
+                if (!regex.meta.license.test(match[1]))
+                    context.report({ loc: { line: 1, column: 0 }, messageId: 'missingLicense' })
+            }
+        }
+    }
+}

package/src/rules/require-space-before-meta-key.js

@@ -1,6 +1,5 @@
 import metadata from '../utils/metadata.js'
-
-const re = { leadingWhitespace: /^\s*/ }
+import regex from '../data/regex.js'
 
 export default {
     meta: {
@@ -24,7 +23,7 @@ export default {
                     const commentText = sourceCode.getText(entry.comment),
                           afterSlashes = commentText.slice(2)
                     if (afterSlashes.startsWith(' @')) continue
-                    const rest = afterSlashes.replace(re.leadingWhitespace, ''),
+                    const rest = afterSlashes.replace(regex.whitespace.leading, ''),
                           keyIdx = commentText.indexOf(`@${entry.key}`),
                           actual = commentText.slice(0, keyIdx +1 + entry.key.length),
                           fixedText = `// ${rest}`

package/src/rules/valid-field-values.js

@@ -1,10 +1,10 @@
 import metadata from '../utils/metadata.js'
+import regex from '../data/regex.js'
 
-const re = { /* eslint-disable security/detect-unsafe-regex */
+const re = { // oxlint-disable security/detect-unsafe-regex
     semVer: /^\d+\.\d+\.\d+(?:-[\da-z.-]+)?(?:\+[\da-z.-]+)?$/i,
-    dateVer: /^\d{4}\.(?:0?[1-9]|1[0-2])\.(?:0?[1-9]|[12]\d|3[01])(?:\.\d+)?$/,
-    whitespace: /\s+/
-} /* eslint-enable security/detect-unsafe-regex */
+    dateVer: /^\d{4}\.(?:0?[1-9]|1[0-2])\.(?:0?[1-9]|[12]\d|3[01])(?:\.\d+)?$/
+} // oxlint-enable security/detect-unsafe-regex
 
 const urlKeys = ['homepage', 'icon', 'icon64', 'require', 'source', 'website']
 
@@ -69,7 +69,7 @@ export default {
                     if (entry.key == 'grant' && allowedGrants.size && !allowedGrants.has(entry.value))
                         context.report({ node: entry.comment, messageId: 'invalidGrant', data: { grant: entry.value }})
                     else if (entry.key == 'resource') {
-                        const url = entry.value.trim().split(re.whitespace)[1]
+                        const url = entry.value.trim().split(regex.whitespace.all)[1]
                         if (url) try { new URL(url) }
                         catch {
                             context.report({ node: entry.comment, messageId: 'invalidURL', data: { field: entry.key }})

package/src/rules/valid-icon-headers.js

@@ -0,0 +1,74 @@
+import regex from '../data/regex.js'
+
+const re = {
+    dataURI: /^data:([^;,]+)(;base64)?,(.*)$/i,
+    iconLine: /^[ \t]*\/\/[ \t]*@(icon|icon64|defaulticon)[ \t]+(\S.*)$/,
+    scheme: /^([a-z][a-z0-9+.-]*):/i
+}
+
+export default {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Validates `@icon`/`@icon64`/`@defaulticon` values against allowed schemes',
+            category: 'Possible Errors',
+            recommended: true
+        },
+        schema: [],
+        messages: {
+            malformedURL:     '`@{{header}}` is not a valid URL.',
+            malformedDataURI: '`@{{header}}` data URI is malformed (expected `data:<mime>[;base64],<payload>`).',
+            nonImageMIME:     '`@{{header}}` data URI MIME type `{{mime}}` is not an image.',
+            disallowedScheme: '`@{{header}}` uses unsupported scheme `{{scheme}}:`'
+                            + ' (use `http(s)`, `data:`, or a relative path).'
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.sourceCode ?? context.getSourceCode()
+
+        function validate(value, header, line, col) {
+            const loc = { start: { line, column: col }, end: { line, column: col + value.length }}
+            const schemeMatch = value.match(re.scheme)
+            if (!schemeMatch) return // relative path — accepted
+            const scheme = schemeMatch[1].toLowerCase()
+            if (scheme == 'http' || scheme == 'https') {
+                try { new URL(value) }
+                catch { return context.report({ loc, messageId: 'malformedURL', data: { header }}) }
+                return
+            }
+            if (scheme == 'data') {
+                const dataMatch = value.match(re.dataURI)
+                if (!dataMatch)
+                    return context.report({ loc, messageId: 'malformedDataURI', data: { header }})
+                const mime = dataMatch[1]
+                if (!mime.toLowerCase().startsWith('image/'))
+                    return context.report({ loc, messageId: 'nonImageMIME', data: { header, mime }})
+                return
+            }
+            context.report({ loc, messageId: 'disallowedScheme', data: { header, scheme }})
+        }
+
+        return {
+            Program() {
+                const text = sourceCode.text,
+                      metaMatch = text.match(regex.meta.block)
+                if (!metaMatch) return
+                const lines = metaMatch[1].split(regex.newline),
+                      iconMatches = []
+                for (const [i, line] of lines.entries()) {
+                    const m = line.match(re.iconLine)
+                    if (m) iconMatches.push({ i, line, m })
+                }
+                if (!iconMatches.length) return
+                const baseLine = text.slice(0, metaMatch.index).split(regex.newline).length
+                for (const { i, line, m } of iconMatches) {
+                    const header = m[1],
+                          value = m[2].trim()
+                    if (!value) continue
+                    validate(value, header, baseLine + i, line.indexOf(value))
+                }
+            }
+        }
+    }
+}

package/src/rules/valid-license-header.js

@@ -0,0 +1,73 @@
+// oxlint-disable security/detect-object-injection
+
+import array from '../utils/array.js'
+import license from '../utils/license.js'
+
+import regex from '../data/regex.js'
+
+const re = { spdxExpr: /(?<=\s)(?:OR|AND)(?=\s)/i }
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Validates `@license` values against the SPDX license list',
+            category: 'Possible Errors',
+            recommended: true
+        },
+        defaultOptions: [{ allowedLicenses: [] }],
+        schema: [{
+            type: 'object',
+            properties: {
+                allowedLicenses: {
+                    description: 'SPDX license IDs to restrict to',
+                    oneOf: [
+                        { type: 'string', description: 'Single SPDX license ID' },
+                        { type: 'array', description: 'Array of SPDX license IDs', items: { type: 'string' }}
+                    ]
+                }
+            },
+            additionalProperties: false
+        }],
+        messages: {
+            invalidSPDX:    'Invalid SPDX identifier `{{id}}` (see https://spdx.org/licenses/).',
+            disallowedSPDX: '`@license {{id}}` is not in allowed list: {{allowed}}.'
+        }
+    },
+
+    create(context) {
+        const opts = context.options[0] ?? {},
+              allowedLicenses = array.to(opts.allowedLicenses) ?? [],
+              sourceCode = context.sourceCode ?? context.getSourceCode()
+        return {
+            Program() {
+                const text = sourceCode.text,
+                      metaMatch = text.match(regex.meta.block)
+                if (!metaMatch) return
+                const lines = text.split('\n'),
+                      startLine = text.slice(0, metaMatch.index).split('\n').length -1,
+                      endLine = startLine + metaMatch[0].split('\n').length -1
+                let licenseLineIdx = -1, licenseMatch = null
+                for (let i = startLine ; i < endLine ; i++) {
+                    const match = lines[i].match(regex.meta.license)
+                    if (match) { licenseLineIdx = i ; licenseMatch = match ; break }
+                }
+                if (!licenseMatch) return
+                const id = licenseMatch[1].trim() ; if (regex.url.test(id)) return
+                const parts = id.split(re.spdxExpr).map(part => part.trim()).filter(Boolean),
+                      idCol = lines[licenseLineIdx].indexOf(id),
+                      loc = { start: { line: licenseLineIdx +1, column: idCol },
+                              end: { line: licenseLineIdx +1, column: idCol + id.length }}
+                for (const part of parts)
+                    if (!license.spdx.isValid(part))
+                        return context.report({ loc, messageId: 'invalidSPDX', data: { id: part }})
+                if (allowedLicenses.length) {
+                    for (const part of parts)
+                        if (!allowedLicenses.includes(part))
+                            return context.report({ loc, messageId: 'disallowedSPDX',
+                                data: { id: part, allowed: allowedLicenses.join(', ') }})
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,114 @@
+import metadata from '../utils/metadata.js'
+import regex from '../data/regex.js'
+
+const re = {
+    matchPattern: /^(\*|http\*?|https?|file|ftp):\/\/([^/]*)(\/.*)$/,
+    regexForm: /^\/.+\/[a-z]*$/i
+}
+
+const urlKeys = new Set(['homepage', 'require', 'require-css', 'source', 'website']),
+      matchKeys = new Set(['match', 'exclude-match']),
+      regexOrMatchKeys = new Set(['include', 'exclude'])
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Validates URLs and match patterns in metadata headers',
+            category: 'Possible Errors',
+            recommended: true
+        },
+        defaultOptions: [{
+            checkURLfields: true,
+            checkMatchPatterns: true,
+            allowedSchemes: ['http', 'https', 'file', 'ftp', 'http*'],
+            allowBroadPatterns: false
+        }],
+        schema: [{
+            type: 'object',
+            properties: {
+                checkURLfields: {
+                    type: 'boolean',
+                    description: 'Validate URL fields (`@homepage`, `@require`, `@resource`, etc.)'
+                },
+                checkMatchPatterns: {
+                    type: 'boolean',
+                    description: 'Validate match patterns (`@match`, `@include`, `@exclude`, `@exclude-match`)'
+                },
+                allowedSchemes: {
+                    type: 'array', items: { type: 'string' },
+                    description: 'Permitted URL schemes for match patterns'
+                },
+                allowBroadPatterns: {
+                    type: 'boolean',
+                    description: 'Allow unrestricted patterns (`<all_urls>`, `*://*/*`, `http*://*/*`, `https://*/*`)'
+                }
+            },
+            additionalProperties: false
+        }],
+        messages: {
+            invalidURL:         '`@{{field}}` has an invalid URL: "{{value}}".',
+            invalidMatchPattern:'`@{{field}}` has an invalid match pattern: "{{value}}".',
+            invalidScheme:      '`@{{field}}` uses a disallowed scheme: "{{value}}".',
+            invalidFileHost:    '`@{{field}}` uses a `file://` scheme w/ a non-empty host: "{{value}}".',
+            invalidHost:        '`@{{field}}` has an invalid wildcard host: "{{value}}". Use `*.` prefix instead.',
+            allURLs:            '`@{{field}}` uses the unrestricted pattern "{{value}}".'
+        }
+    },
+
+    create(context) {
+        const opts = context.options[0] ?? {},
+              checkURLfields = opts.checkURLfields !== false,
+              checkMatchPatterns = opts.checkMatchPatterns !== false,
+              allowedSchemes = new Set(opts.allowedSchemes ?? ['http', 'https', 'file', 'ftp', 'http*']),
+              allowBroadPatterns = opts.allowBroadPatterns === true
+        if (!checkURLfields && !checkMatchPatterns) return {}
+        function validateMatchPattern(value, field, node) {
+            if (value == '<all_urls>') {
+                if (!allowBroadPatterns)
+                    context.report({ node, messageId: 'allURLs', data: { field, value }})
+                return
+            }
+            const m = value.match(re.matchPattern)
+            if (!m) {
+                if (regexOrMatchKeys.has(field) && re.regexForm.test(value)) return
+                context.report({ node, messageId: 'invalidMatchPattern', data: { field, value }})
+                return
+            }
+            const [, scheme, host, path] = m
+            if (scheme != '*' && !allowedSchemes.has(scheme))
+                context.report({ node, messageId: 'invalidScheme', data: { field, value }})
+            else if (scheme == 'file' && host != '')
+                context.report({ node, messageId: 'invalidFileHost', data: { field, value }})
+            else if (host.includes('*') && host != '*' && !host.startsWith('*.'))
+                context.report({ node, messageId: 'invalidHost', data: { field, value }})
+            else if (host == '*' && path == '/*' && !allowBroadPatterns)
+                context.report({ node, messageId: 'allURLs', data: { field, value }})
+        }
+        function validateURL(url, field, node) {
+            try { new URL(url) }
+            catch { context.report({ node, messageId: 'invalidURL', data: { field, value: url }}) }
+        }
+        return {
+            Program() {
+                for (const entry of metadata.extract(context.sourceCode)) {
+                    const key = entry.key, lower = key.toLowerCase()
+                    if (checkURLfields) {
+                        if (key == 'resource') {
+                            const tokens = entry.value.trim().split(regex.whitespace.all),
+                                  url = tokens[1]
+                            if (url) validateURL(url, key, entry.comment)
+                        } else if (urlKeys.has(key) || lower.endsWith('url')) {
+                            const url = entry.value.trim()
+                            if (url) validateURL(url, key, entry.comment)
+                        }
+                    }
+                    if (checkMatchPatterns && (matchKeys.has(key) || regexOrMatchKeys.has(key))) {
+                        const value = entry.value.trim()
+                        if (value) validateMatchPattern(value, key, entry.comment)
+                    }
+                }
+            }
+        }
+    }
+}

package/src/rules/valid-version-header.js

@@ -0,0 +1,83 @@
+import metadata from '../utils/metadata.js'
+
+const re = { // oxlint-disable security/detect-unsafe-regex
+    date: /^\d{4}\.(?:0?[1-9]|1[0-2])\.(?:0?[1-9]|[12]\d|3[01])(?:\.\d+)?$/,
+    semver: /^\d+\.\d+\.\d+(?:-[\da-z.-]+)?(?:\+[\da-z.-]+)?$/i
+} // oxlint-enable security/detect-unsafe-regex
+
+const examples = { date: 'YYYY.M.D or YYYY.M.D.N', semver: '1.2.3' }
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Validates the @version metadata field',
+            category: 'Possible Errors',
+            recommended: true
+        },
+        defaultOptions: [{ versionType: 'semver', allowFutureDate: false, timezone: '' }],
+        schema: [{
+            type: 'object',
+            properties: {
+                versionType: {
+                    type: 'string',
+                    enum: ['semver', 'date'],
+                    description: 'Version format to enforce'
+                },
+                allowFutureDate: {
+                    type: 'boolean',
+                    description: 'Allow `@version` dates later than the current date'
+                },
+                timezone: {
+                    type: 'string',
+                    description: 'IANA timezone for determining the current date '
+                               + '(when omitted, only year/month are checked)'
+                }
+            },
+            additionalProperties: false
+        }],
+        messages: {
+            invalidVersion: 'Invalid @version: must be a valid {{versionType}} version '
+                          + '(expected format: {{example}}).',
+            futureVersion: 'Invalid @version: date cannot be in the future.'
+        }
+    },
+
+    create(context) {
+        const opts = context.options[0] ?? {},
+              versionType = opts.versionType ?? 'semver',
+              allowFutureDate = opts.allowFutureDate ?? false,
+              timezone = opts.timezone ?? '',
+              example = examples[versionType] // oxlint-disable-line security/detect-object-injection
+        const now = timezone
+            ? Object.fromEntries(new Intl.DateTimeFormat('en', {
+                timeZone: timezone, year: 'numeric', month: 'numeric', day: 'numeric'
+            }).formatToParts().filter(({ type }) => ['year', 'month', 'day'].includes(type))
+                .map(({ type, value }) => [type, Number(value)]))
+            : { year: new Date().getUTCFullYear(), month: new Date().getUTCMonth() + 1 }
+        function validate(node, version) {
+            if (typeof version != 'string') return
+            if (versionType == 'semver') {
+                if (!re.semver.test(version))
+                    context.report({ node, messageId: 'invalidVersion', data: { versionType, example }})
+                return
+            }
+            if (versionType == 'date') {
+                if (!re.date.test(version))
+                    return context.report({ node, messageId: 'invalidVersion', data: { versionType, example }})
+                if (allowFutureDate) return
+                const [year, month, day] = version.split('.').map(Number)
+                if (year > now.year
+                    || year == now.year && month > now.month
+                    || timezone && year == now.year && month == now.month && day > now.day
+                ) context.report({ node, messageId: 'futureVersion' })
+            }
+        }
+        return {
+            Program() {
+                for (const entry of metadata.extract(context.sourceCode))
+                    if (entry.key == 'version') validate(entry.comment, entry.value)
+            }
+        }
+    }
+}

package/src/utils/api.js

@@ -0,0 +1,11 @@
+import apis from '../data/apis.js'
+
+export default {
+    supports({ manager, api }) {
+        return !apis.all.has(api) ? false
+            : api.startsWith('CAT') ? manager == 'scriptcat'
+            : apis.tm.has(api) ? manager == 'tampermonkey'
+            : manager == 'adguard' ? apis.ag.has(api)
+            : true
+    }
+}

package/src/utils/array.js

@@ -0,0 +1 @@
+export default { to(val) { return Array.isArray(val) ? val : val == null ? [] : [val] }}

package/src/utils/deprecations.js

@@ -1,5 +1,5 @@
 export default {
-    initAlias(plugin, [oldName, alias]) { /* eslint-disable security/detect-object-injection */
+    initAlias(plugin, [oldName, alias]) { // oxlint-disable security/detect-object-injection
         const routes = typeof alias == 'string' ? { [alias]: null } // 'old-rule': 'new-rule'
             : Array.isArray(alias) ? Object.fromEntries(alias.map(entry =>
                   typeof entry == 'string' ? [entry, null] // ['new-rule-1', 'new-rule-2']
@@ -72,5 +72,5 @@ export default {
                 }))
             }
         }
-    } /* eslint-enable security/detect-object-injection */
+    } // oxlint-enable security/detect-object-injection
 }

package/src/utils/init.js

@@ -1,6 +1,8 @@
 import deprecations from './deprecations.js'
+import pkg from './pkg.js'
 import rulesUtils from './rules.js'
 
+import headers from '../data/headers.js'
 import { rules as deprecationsData } from '../data/deprecations.js'
 
 import metaOrder from '../rules/meta-order.js'
@@ -12,12 +14,14 @@ import noInvalidGrants from '../rules/no-invalid-grants.js'
 import noInvalidHeaders from '../rules/no-invalid-headers.js'
 import noMissingGrants from '../rules/no-missing-grants.js'
 import noMissingResources from '../rules/no-missing-resources.js'
+import noSensitiveGrants from '../rules/no-sensitive-grants.js'
 import noUnusedGrants from '../rules/no-unused-grants.js'
 import noUnusedResources from '../rules/no-unused-resources.js'
 import preferGMaddStyle from '../rules/prefer-gm-add-style.js'
 import preferMatch from '../rules/prefer-match.js'
 import requireBlankLineAfterMetaBlock from '../rules/require-blank-line-after-meta-block.js'
 import requireHomepagePair from '../rules/require-homepage-pair.js'
+import requireLicenseHeader from '../rules/require-license-header.js'
 import requireMatchingLocalizedFields from '../rules/require-matching-localized-fields.js'
 import requireRequiredFields from '../rules/require-required-fields.js'
 import requireSpaceBeforeMetaKey from '../rules/require-space-before-meta-key.js'
@@ -25,9 +29,13 @@ import requireSRIhashing from '../rules/require-sri-hashing.js'
 import requireUpdateDownloadPair from '../rules/require-update-download-pair.js'
 import requireUserJsFilename from '../rules/require-user-js-filename.js'
 import validFieldValues from '../rules/valid-field-values.js'
+import validIconHeaders from '../rules/valid-icon-headers.js'
+import validLicenseHeader from '../rules/valid-license-header.js'
+import validUrlHeaders from '../rules/valid-url-headers.js'
+import validVersionHeader from '../rules/valid-version-header.js'
 
-const namespace = 'greasemonkey',
-      managers = ['tampermonkey', 'violentmonkey', 'greasemonkey', 'scriptcat', 'adguard']
+const pkgName = pkg.getName(),
+      namespace = pkgName.replace(/^@[^/]+\//, '').replace(/^eslint-plugin-/, '')
 
 export default {
     configs(plugin) {
@@ -38,10 +46,11 @@ export default {
             recommended: createConfig(rule => rule.meta.docs.recommended),
             strict: createConfig(() => true),
             problem: createConfig(rule => rule.meta.type == 'problem'),
-            security: createConfig(rule => rule.meta.docs.security)
+            security: createConfig(rule => rule.meta.docs.security),
+            stylistic: createConfig(rule => rule.meta.docs.category == 'Stylistic Issues')
         }
-        for (const manager of managers)
-            plugin.configs[manager] = { // eslint-disable-line security/detect-object-injection
+        for (const manager of headers.managers)
+            plugin.configs[manager] = { // oxlint-disable-line security/detect-object-injection
                 plugins,
                 rules: {
                     ...plugin.configs.recommended.rules,
@@ -58,7 +67,7 @@ export default {
             deprecations.initAlias(plugin, entry)
     },
 
-    plugin() { return { rules: {}, configs: {} }},
+    plugin() { return { meta: { name: pkgName }, rules: {}, configs: {} }},
 
     rules(plugin) {
         plugin.rules = {
@@ -71,21 +80,27 @@ export default {
             'no-invalid-headers': noInvalidHeaders,
             'no-missing-grants': noMissingGrants,
             'no-missing-resources': noMissingResources,
+            'no-sensitive-grants': noSensitiveGrants,
             'no-unused-grants': noUnusedGrants,
             'no-unused-resources': noUnusedResources,
             'prefer-gm-add-style': preferGMaddStyle,
             'prefer-match': preferMatch,
             'require-blank-line-after-meta-block': requireBlankLineAfterMetaBlock,
             'require-homepage-pair': requireHomepagePair,
+            'require-license-header': requireLicenseHeader,
             'require-matching-localized-fields': requireMatchingLocalizedFields,
             'require-required-fields': requireRequiredFields,
             'require-space-before-meta-key': requireSpaceBeforeMetaKey,
             'require-sri-hashing': requireSRIhashing,
             'require-update-download-pair': requireUpdateDownloadPair,
             'require-user-js-filename': requireUserJsFilename,
-            'valid-field-values': validFieldValues
+            'valid-field-values': validFieldValues,
+            'valid-icon-headers': validIconHeaders,
+            'valid-license-header': validLicenseHeader,
+            'valid-url-headers': validUrlHeaders,
+            'valid-version-header': validVersionHeader
         }
         for (const [ruleId, rule] of Object.entries(plugin.rules))
-            rule.meta.docs.url = `https://codeberg.org/adamlui/eslint-plugin-${namespace}/#${ruleId}`
+            rule.meta.docs.url = `https://codeberg.org/adamlui/${pkgName}/#${ruleId}`
     }
 }