eslint-plugin-chrome-extensions 2.4.2 → 2.5.0

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

@@ -1,9 +1,7 @@
-import { mv2OnlyKeys, forbiddenCSPdirectives, ffMV3bgKeys, ffDataCollectionRequired, ffDataCollectionOptional }
-    from '../data/manifest.js'
+import extension from '../utils/extension.js'
 
-import { file, readManifest } from '../utils/extension.js'
-
-const re = { manifestFilename: /manifest\.json$/ }
+import manifestData from '../data/manifest.js'
+import regex from '../data/regex.js'
 
 export default {
     meta: {
@@ -24,7 +22,7 @@ export default {
     },
 
     create(context) {
-        if (re.manifestFilename.test(file.getName(context))) { // lint it directly
+        if (regex.filename.manifest.test(extension.file.getName(context))) { // lint it directly
             const ancestors = [], pendingReports = [], deferredMV2 = []
             let isMV3 = false, isFF = false
             function keyOf(node) {
@@ -44,10 +42,10 @@ export default {
                             keyOf(ancestor) == 'data_collection_permissions')
                         if (keyName == 'manifest_version' && node.value?.value == 3) isMV3 = true
                         if (isTopLevel && keyName == 'browser_specific_settings') isFF = true
-                        if (isTopLevel && mv2OnlyKeys.has(keyName))
+                        if (isTopLevel && manifestData.keys.mv2Only.has(keyName))
                             pendingReports.push({ node, messageId: 'mv2Key',
                                 data: { key: keyName, reason: 'MV2-only key' }})
-                        if (inBackground && ffMV3bgKeys.has(keyName))
+                        if (inBackground && manifestData.keys.ff.mv3BG.has(keyName))
                             deferredMV2.push({ node, messageId: 'mv2Key',
                                 data: { key: `background.${keyName}`,
                                         reason: 'Use background.service_worker instead' }})
@@ -58,7 +56,7 @@ export default {
                         if (isTopLevel && keyName == 'content_security_policy' && node.value?.type == 'String')
                             pendingReports.push({ node: node.value, messageId: 'wrongCSPType' })
                         if (inCSP && keyName == 'extension_pages' && typeof node.value?.value == 'string')
-                            for (const directive of forbiddenCSPdirectives)
+                            for (const directive of manifestData.csp.forbiddenDirectives)
                                 if (node.value.value.includes(directive))
                                     pendingReports.push({ node: node.value, messageId: 'unsafeCSP',
                                         data: { directive }})
@@ -67,8 +65,9 @@ export default {
                         ) for (const elem of node.value.elements) {
                             const value = typeof elem.value == 'string' ? elem.value : elem.value?.value
                             if (typeof value == 'string') {
-                                const set = keyName == 'required' ? ffDataCollectionRequired : ffDataCollectionOptional
-                                if (!set.has(value))
+                                const allowedVals = manifestData.keys.ff[
+                                    `dataCollection${ keyName == 'required' ? 'Required' : 'Optional' }`]
+                                if (!allowedVals.has(value))
                                     pendingReports.push({ node: elem, messageId: 'invalidDataCollectionValue',
                                         data: { value, kind: keyName }})
                             }
@@ -86,14 +85,14 @@ export default {
                 }
             }
         }
-        const manifest = readManifest(context) ; if (!manifest || manifest.manifest_version != 3) return {}
+        const manifest = extension.manifest.read(context) ; if (!manifest || manifest.manifest_version != 3) return {}
         const isFF = manifest.browser_specific_settings != null
         return {
             Program(node) { /* eslint-disable security/detect-object-injection */
                 for (const key of Object.keys(manifest))
-                    if (mv2OnlyKeys.has(key))
+                    if (manifestData.keys.mv2Only.has(key))
                         context.report({ node, messageId: 'mv2Key', data: { key, reason: 'MV2-only key' }})
-                for (const key of ffMV3bgKeys)
+                for (const key of manifestData.keys.ff.mv3BG)
                     if (manifest.background?.[key] && !isFF)
                         context.report({ node, messageId: 'mv2Key',
                             data: { key: `background.${key}`, reason: 'Use background.service_worker instead' }})
@@ -105,17 +104,18 @@ export default {
                     context.report({ node, messageId: 'wrongCSPType' })
                 const cspPages = csp?.extension_pages
                 if (typeof cspPages == 'string')
-                    for (const directive of forbiddenCSPdirectives)
+                    for (const directive of manifestData.csp.forbiddenDirectives)
                         if (cspPages.includes(directive))
                             context.report({ node, messageId: 'unsafeCSP', data: { directive }})
                 if (isFF) { // validate data collection permissions
                     const dcp = manifest.browser_specific_settings?.gecko?.data_collection_permissions
-                    for (const [kind, set] of [['required', ffDataCollectionRequired], ['optional', ffDataCollectionOptional]])
-                        if (Array.isArray(dcp?.[kind]))
-                            for (const value of dcp[kind])
-                                if (!set.has(value))
-                                    context.report({ node, messageId: 'invalidDataCollectionValue',
-                                        data: { value, kind }})
+                    for (const [kind, set] of [
+                        ['required', manifestData.keys.ff.dataCollectionRequired],
+                        ['optional', manifestData.keys.ff.dataCollectionOptional]
+                    ]) if (Array.isArray(dcp?.[kind]))
+                        for (const value of dcp[kind])
+                            if (!set.has(value))
+                                context.report({ node, messageId: 'invalidDataCollectionValue', data: { value, kind }})
                 }
             } /* eslint-enable security/detect-object-injection */
         }

package/src/rules/valid-service-worker.js

@@ -1,7 +1,7 @@
-import { domGlobals, serviceWorkerKeepaliveMinMS } from '../data/manifest.js'
+import extension from '../utils/extension.js'
+import nodeUtils from '../utils/node.js'
 
-import { isInsideNestedFunction } from '../utils/node.js'
-import { file, readManifest } from '../utils/extension.js'
+import manifestData from '../data/manifest.js'
 
 export default {
     meta: {
@@ -11,7 +11,23 @@ export default {
             category: 'Possible Errors',
             recommended: true
         },
-        schema: [],
+        schema: [{
+            type: 'object',
+            properties: {
+                checkListenerTopLevel: { type: 'boolean',
+                    description: 'Flag `chrome.*.addListener()` calls not registered at module top level' },
+                checkKeepaliveTimer: { type: 'boolean',
+                    description: 'Flag sub-30s `setTimeout`/`setInterval` calls used as a keepalive workaround' },
+                checkDOMglobals: { type: 'boolean',
+                    description: 'Flag DOM globals (`window`, `document`, `localStorage`) inside the service worker' }
+            },
+            additionalProperties: false
+        }],
+        defaultOptions: [{
+            checkListenerTopLevel: true,
+            checkKeepaliveTimer: true,
+            checkDOMglobals: true
+        }],
         messages: {
             listenerNotTopLevel: '`chrome.*.addListener()` must be registered at module top level'
                                + ' so it attaches on service worker wake-up.',
@@ -21,29 +37,34 @@ export default {
     },
 
     create(context) {
-        const manifest = readManifest(context) ; if (!manifest || !file.isServiceWorker(context, manifest)) return {}
+        const { checkListenerTopLevel, checkKeepaliveTimer, checkDOMglobals } = context.options[0],
+                manifest = extension.manifest.read(context)
+        if (!manifest || !extension.file.isServiceWorker(context, manifest)) return {}
         return {
             CallExpression(node) {
-                if (node.callee.type == 'MemberExpression'
+                if (checkListenerTopLevel
+                    && node.callee.type == 'MemberExpression'
                     && node.callee.property.name == 'addListener'
-                    && isInsideNestedFunction(node)
+                    && nodeUtils.isInsideNestedFunction(node)
                 ) context.report({ node, messageId: 'listenerNotTopLevel' })
-                if (node.callee.type == 'Identifier'
+                if (checkKeepaliveTimer
+                    && node.callee.type == 'Identifier'
                     && ['setTimeout', 'setInterval'].includes(node.callee.name)
                     && node.arguments[1]?.type == 'Literal'
                     && typeof node.arguments[1].value == 'number'
-                    && node.arguments[1].value < serviceWorkerKeepaliveMinMS
-                    && !isInsideNestedFunction(node)
+                    && node.arguments[1].value < 30000
+                    && !nodeUtils.isInsideNestedFunction(node)
                 ) context.report({ node, messageId: 'keepaliveTimer', data: { fn: node.callee.name }})
             },
             Identifier(node) {
+                if (!checkDOMglobals) return
                 if (node.parent?.type == 'MemberExpression' && node.parent.property === node
                     || node.parent?.type == 'Property' && node.parent.key === node && !node.parent.computed
-                    || !domGlobals.has(node.name)
+                    || !manifestData.globals.dom.has(node.name)
                 ) return
                 for (let scope = context.sourceCode.getScope(node)
-                    ;scope && scope.type != 'global'
-                    ;scope = scope.upper
+                    ; scope && scope.type != 'global'
+                    ; scope = scope.upper
                 ) if (scope.set.has(node.name)) return // shadowed by a local binding
                 context.report({ node, messageId: 'domInSW', data: { global: node.name }})
             }

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

@@ -1,9 +1,12 @@
-import { matchPaths, urlPaths } from '../data/manifest.js'
-import { file } from '../utils/extension.js'
+import extension from '../utils/extension.js'
+
+import manifestData from '../data/manifest.js'
+import regex from '../data/regex.js'
 
 const re = {
-    absoluteURL: /^[a-z][a-z0-9+.-]*:\/\/[^\s/]+/i, manifestFilename: /manifest\.json$/,
-    match: /^(\*|https?|file|ftp):\/\/([^/]*)(\/.*)$/, template: /\{[^}]+\}/g
+    absoluteURL: /^[a-z][a-z0-9+.-]*:\/\/[^\s/]+/i,
+    match: /^(\*|https?|file|ftp):\/\/([^/]*)(\/.*)$/,
+    template: /\{[^}]+\}/g
 }
 
 function collectStrings(obj, path = [], out = []) {
@@ -67,7 +70,7 @@ export default {
     },
 
     create(context) {
-        if (!re.manifestFilename.test(file.getName(context))) return {}
+        if (!regex.filename.manifest.test(extension.file.getName(context))) return {}
         const opts = context.options[0] || {},
               checkURLfields = opts.checkURLfields ?? true,
               checkMatchPatterns = opts.checkMatchPatterns ?? true,
@@ -79,11 +82,11 @@ export default {
                 let manifest
                 try { manifest = JSON.parse(context.sourceCode.text) } catch { return }
                 for (const { path, value } of collectStrings(manifest)) {
-                    if (checkURLfields && urlPaths.has(path)) {
+                    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 && matchPaths.has(path)) {
+                    } else if (checkMatchPatterns && manifestData.paths.match.has(path)) {
                         if (value == '<all_urls>') {
                             if (!allowAllURLs)
                                 context.report({ loc: { line: 1, column: 1 }, messageId: 'allURLs',

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

@@ -1,9 +1,9 @@
-import { file, readManifest } from '../utils/extension.js'
+import extension from '../utils/extension.js'
+import regex from '../data/regex.js'
 
 const re = { /* eslint-disable security/detect-unsafe-regex */
     chromeParts: /^\d+(?:\.\d+){0,3}$/,
     date: /^\d{4}\.(?:0?[1-9]|1[0-2])\.(?:0?[1-9]|[12]\d|3[01])(?:\.\d+)?$/,
-    manifestFilename: /manifest\.json$/,
     semver: /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/
 } /* eslint-enable security/detect-unsafe-regex */
 
@@ -79,7 +79,7 @@ export default {
                 }
             }
         }
-        if (re.manifestFilename.test(file.getName(context))) // lint it directly
+        if (regex.filename.manifest.test(extension.file.getName(context))) // lint it directly
             return {
                 '*'(node) {
                     const keyNode = node.name || node.key ; if (!keyNode) return
@@ -88,10 +88,6 @@ export default {
                     validate(valueNode, valueNode.value)
                 }
             }
-        return {
-            Program(node) {
-                validate(node, readManifest(context)?.version)
-            }
-        }
+        return { Program(node) { validate(node, extension.manifest.read(context)?.version) }}
     }
 }

package/src/utils/extension.js

@@ -1,45 +1,51 @@
+/* eslint-disable security/detect-non-literal-fs-filename -- lint-time test fixtures only */
+
 import fs from 'node:fs'
 import path from 'node:path'
 
 const manifestCache = new Map()
 
-export function findRoot(context) {
-    let dir = path.dirname(file.getName(context))
-    while (dir) {
-        // eslint-disable-next-line security/detect-non-literal-fs-filename
-        if (fs.existsSync(path.join(dir, 'manifest.json'))) return dir
-        const parent = path.dirname(dir)
-        if (parent == dir) break // reached fs root
-        dir = parent
-    }
-    return null
-}
+const utils = {
+    file: {
+        getName(context) { return context.filename || context.getFilename() },
 
-export const file = {
-    getName(context) { return context.filename || context.getFilename() },
+        isContentScript(context, manifest) {
+            const scripts = (manifest?.content_scripts || []).flatMap(cs => cs.js || [])
+            if (!scripts.length) return false
+            const root = utils.findRoot(context) ; if (!root) return false
+            const filename = path.resolve(utils.file.getName(context))
+            return scripts.some(script => filename == path.resolve(root, script))
+        },
 
-    isContentScript(context, manifest) {
-        const scripts = (manifest?.content_scripts || []).flatMap(cs => cs.js || []) ; if (!scripts.length) return false
-        const root = findRoot(context) ; if (!root) return false
-        const filename = path.resolve(file.getName(context))
-        return scripts.some(script => filename == path.resolve(root, script))
+        isServiceWorker(context, manifest) {
+            const worker = manifest?.background?.service_worker ; if (!worker) return false
+            const root = utils.findRoot(context) ; if (!root) return false
+            return path.resolve(utils.file.getName(context)) == path.resolve(root, worker)
+        }
     },
 
-    isServiceWorker(context, manifest) {
-        const worker = manifest?.background?.service_worker ; if (!worker) return false
-        const root = findRoot(context) ; if (!root) return false
-        return path.resolve(file.getName(context)) == path.resolve(root, worker)
+    findRoot(context) {
+        let dir = path.dirname(utils.file.getName(context))
+        while (dir) {
+            if (fs.existsSync(path.join(dir, 'manifest.json'))) return dir
+            const parent = path.dirname(dir)
+            if (parent == dir) break // reached fs root
+            dir = parent
+        }
+        return null
+    },
+
+    manifest: {
+        read(context) {
+            const root = utils.findRoot(context) ; if (!root) return null
+            if (manifestCache.has(root)) return manifestCache.get(root)
+            let parsed
+            try { parsed = JSON.parse(fs.readFileSync(path.join(root, 'manifest.json'), 'utf8')) }
+            catch { parsed = null }
+            manifestCache.set(root, parsed)
+            return parsed
+        }
     }
 }
 
-export function readManifest(context) {
-    const root = findRoot(context)
-    if (!root) return null
-    if (manifestCache.has(root)) return manifestCache.get(root)
-    let parsed
-    try { // eslint-disable-next-line security/detect-non-literal-fs-filename
-        parsed = JSON.parse(fs.readFileSync(path.join(root, 'manifest.json'), 'utf8'))
-    } catch { parsed = null }
-    manifestCache.set(root, parsed)
-    return parsed
-}
+export default utils

package/src/utils/i18n.js

@@ -0,0 +1,55 @@
+/* eslint-disable security/detect-non-literal-fs-filename -- lint-time test fixtures only */
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+import i18n from '../data/i18n.js'
+
+function templateToPattern(body) {
+    const parts = body.split(i18n.re.templateExpr).map(part => part.replace(i18n.re.specialChars, '\\$&'))
+    return new RegExp(`^${parts.join('.*')}$`) // eslint-disable-line security/detect-non-literal-regexp
+}
+
+export default {
+    collectUsedKeys(root, scanExtensions) {
+        const used = new Set(),
+              patterns = [],
+              exts = new Set(scanExtensions),
+              stack = [root]
+        while (stack.length) {
+            const dir = stack.pop() ; let entries
+            try { entries = fs.readdirSync(dir, { withFileTypes: true }) } catch { continue }
+            for (const entry of entries) {
+                if (entry.name.startsWith('.') || entry.name == 'node_modules') continue
+                const fullPath = path.join(dir, entry.name)
+                if (entry.isDirectory()) { stack.push(fullPath) ; continue }
+                const ext = path.extname(entry.name).slice(1).toLowerCase()
+                if (!exts.has(ext)) continue
+                let text
+                try { text = fs.readFileSync(fullPath, 'utf8') } catch { continue }
+                for (const match of text.matchAll(i18n.re.msgPlaceholder))
+                    if (!this.isPredefined(match[1])) used.add(match[1])
+                for (const match of text.matchAll(i18n.re.getMsg.literal))
+                    used.add(match[1])
+                for (const match of text.matchAll(i18n.re.getMsg.template)) {
+                    const body = match[1]
+                    if (body.includes('${')) patterns.push(templateToPattern(body))
+                    else used.add(body)
+                }
+            }
+        }
+        return { used, patterns }
+    },
+
+    isPredefined(key) { return key.startsWith('@@') },
+
+    readDefaultLocaleMessages(manifest, root) {
+        const locale = manifest?.default_locale
+        if (typeof locale != 'string') return null
+        const filePath = path.join(root, '_locales', locale, 'messages.json')
+        let messages
+        try { messages = JSON.parse(fs.readFileSync(filePath, 'utf8')) } catch { return null }
+        if (!messages || typeof messages != 'object' || Array.isArray(messages)) return null
+        return { locale, messages }
+    }
+}

package/src/utils/init.js

@@ -0,0 +1,105 @@
+import css from '@eslint/css'
+import html from '@html-eslint/eslint-plugin'
+import json from '@eslint/json'
+import rulesUtils from './rules.js'
+import text from './text.js'
+
+import manifestKeyOrder from '../rules/manifest-key-order.js'
+import manifestSpacing from '../rules/manifest-spacing.js'
+import noContentStyleLeak from '../rules/no-content-style-leak.js'
+import noDeprecatedAPIs from '../rules/no-deprecated-apis.js'
+import noDuplicateManifestKeys from '../rules/no-duplicate-manifest-keys.js'
+import noInsecureFetch from '../rules/no-insecure-fetch.js'
+import noInsecureMessaging from '../rules/no-insecure-messaging.js'
+import noInvalidPermissions from '../rules/no-invalid-permissions.js'
+import noMissingDefaultLocale from '../rules/no-missing-default-locale.js'
+import noMissingI18nKeys from '../rules/no-missing-i18n-keys.js'
+import noMissingPermissions from '../rules/no-missing-permissions.js'
+import noMissingWebAccessibleResources from '../rules/no-missing-web-accessible-resources.js'
+import noRemoteCode from '../rules/no-remote-code.js'
+import noSensitivePermissions from '../rules/no-sensitive-permissions.js'
+import noUnrestrictedHostPermissions from '../rules/no-unrestricted-host-permissions.js'
+import noUnusedI18nKeys from '../rules/no-unused-i18n-keys.js'
+import noUnusedPermissions from '../rules/no-unused-permissions.js'
+import requireLicenseFile from '../rules/require-license-file.js'
+import requireMV3 from '../rules/require-mv3.js'
+import requireShortNameWhenUseful from '../rules/require-short-name-when-useful.js'
+import validFilenames from '../rules/valid-filenames.js'
+import validLicenseFile from '../rules/valid-license-file.js'
+import validManifestIcons from '../rules/valid-manifest-icons.js'
+import validMV3schema from '../rules/valid-mv3-schema.js'
+import validServiceWorker from '../rules/valid-service-worker.js'
+import validURLfields from '../rules/valid-url-fields.js'
+import validVersionField from '../rules/valid-version-field.js'
+
+const namespace = 'chrome-extensions'
+
+export default {
+    bundleDeprecation(plugin, [ruleId, bundleNames], pluginName) { /* eslint-disable security/detect-object-injection */
+        for (const bundleName of bundleNames)
+            if (plugin.configs[bundleName])
+                plugin.configs[bundleName].rules[`${pluginName}/${ruleId}`] = 'error'
+    }, /* eslint-enable security/detect-object-injection */
+
+    configs(plugin) {
+        const plugins = { [namespace]: plugin },
+              rules = plugin.rules,
+              createConfig = predicate => ({ plugins, rules: rulesUtils.bundle(rules, predicate, namespace) })
+        plugin.configs = {
+            recommended: createConfig(rule => rule.meta.docs.recommended),
+            strict: createConfig(() => true),
+            problem: createConfig(rule => rule.meta.type == 'problem'),
+            security: createConfig(rule => rule.meta.docs.security),
+            manifest: {
+                ...createConfig(rule => rule.meta.docs.manifest), language: 'json/json', plugins: { ...plugins, json }},
+            license: {
+                ...createConfig(rule => rule.meta.docs.license), languageOptions: { parser: text.parser }},
+            css: {
+                ...createConfig(rule => rule.meta.docs.css), language: 'css/css', plugins: { ...plugins, css }},
+            html: {
+                ...createConfig(rule => rule.meta.docs.html), language: 'html/html', plugins: { ...plugins, html }},
+            json: {
+                ...createConfig(rule => rule.meta.docs.json), language: 'json/json', plugins: { ...plugins, json }},
+            json5: {
+                ...createConfig(rule => rule.meta.docs.json), language: 'json/json5', plugins: { ...plugins, json }},
+            jsonc: {
+                ...createConfig(rule => rule.meta.docs.json), language: 'json/jsonc', plugins: { ...plugins, json }}
+        }
+    },
+
+    plugin() { return { rules: {}, configs: {}}},
+
+    rules(plugin) {
+        plugin.rules = {
+            'manifest-key-order': manifestKeyOrder,
+            'manifest-spacing': manifestSpacing,
+            'no-content-style-leak': noContentStyleLeak,
+            'no-deprecated-apis': noDeprecatedAPIs,
+            'no-duplicate-manifest-keys': noDuplicateManifestKeys,
+            'no-insecure-fetch': noInsecureFetch,
+            'no-insecure-messaging': noInsecureMessaging,
+            'no-invalid-permissions': noInvalidPermissions,
+            'no-missing-default-locale': noMissingDefaultLocale,
+            'no-missing-i18n-keys': noMissingI18nKeys,
+            'no-missing-permissions': noMissingPermissions,
+            'no-missing-web-accessible-resources': noMissingWebAccessibleResources,
+            'no-remote-code': noRemoteCode,
+            'no-sensitive-permissions': noSensitivePermissions,
+            'no-unrestricted-host-permissions': noUnrestrictedHostPermissions,
+            'no-unused-i18n-keys': noUnusedI18nKeys,
+            'no-unused-permissions': noUnusedPermissions,
+            'require-mv3': requireMV3,
+            'require-license-file': requireLicenseFile,
+            'require-short-name-when-useful': requireShortNameWhenUseful,
+            'valid-filenames': validFilenames,
+            'valid-license-file': validLicenseFile,
+            'valid-manifest-icons': validManifestIcons,
+            'valid-mv3-schema': validMV3schema,
+            'valid-service-worker': validServiceWorker,
+            'valid-url-fields': validURLfields,
+            'valid-version-field': validVersionField
+        }
+        for (const [ruleId, rule] of Object.entries(plugin.rules))
+            rule.meta.docs.url = `https://codeberg.org/adamlui/eslint-plugin-${namespace}/#${ruleId}`
+    }
+}

package/src/utils/license.js

@@ -0,0 +1,55 @@
+/* eslint-disable security/detect-non-literal-fs-filename -- lint-time test fixtures only */
+
+import { createRequire } from 'node:module'
+import fs from 'node:fs'
+import path from 'node:path'
+
+import regex from '../data/regex.js'
+
+const re = { spdxTag: /SPDX-License-Identifier:\s*([\w.-]+)/i },
+      require = createRequire(import.meta.url),
+      skipDirs = new Set(['node_modules']),
+      spdxIDs = new Set(require('spdx-license-ids')),
+      spdxNames = Object.entries(require('spdx-license-list'))
+          .map(([id, { name }]) => ({ id, name }))
+          .sort((a, b) => b.name.length - a.name.length)
+
+function tryReaddir(dir) {
+    try { return fs.readdirSync(dir, { withFileTypes: true }) } catch { return null }}
+
+export default {
+    find(root) {
+        const queue = [root]
+        while (queue.length) {
+            const dir = queue.shift(), entries = tryReaddir(dir)
+            if (!entries) continue
+            for (const entry of entries) {
+                if (entry.name.startsWith('.') || skipDirs.has(entry.name)) continue
+                if (entry.isFile() && regex.filename.license.test(entry.name)) return path.join(dir, entry.name)
+                if (entry.isDirectory()) queue.push(path.join(dir, entry.name))
+            }
+        }
+        return null
+    },
+
+    spdx: {
+        appendTag(fixer, text, id) {
+            const nl = text.includes('\r\n') ? '\r\n' : '\n',
+                trailer = `${text.endsWith(nl) ? '' : nl}${nl}SPDX-License-Identifier: ${id}${nl}`
+            return fixer.insertTextAfterRange([0, text.length], trailer)
+        },
+        find(text) {
+            const normalizedTxt = text.replace(/\s+/g, ' ')
+            let best = null
+            for (const { id, name } of spdxNames) {
+                const idx = normalizedTxt.indexOf(name)
+                if (idx == -1) continue
+                if (!best || idx < best.idx || (idx == best.idx && name.length > best.name.length))
+                    best = { id, idx, name }
+            }
+            return best?.id ?? null
+        },
+        isValid(id) { return spdxIDs.has(id) },
+        parse(text) { return text.match(re.spdxTag)?.[1] ?? null }
+    }
+}

package/src/utils/node.js

@@ -1,22 +1,23 @@
-export function getMemberPath(node) {
-    const parts = []
-    let cur = node
-    while (cur?.type == 'MemberExpression') {
-        if (cur.computed || cur.property.type != 'Identifier') return null
-        parts.unshift(cur.property.name)
-        cur = cur.object
-    }
-    if (cur?.type != 'Identifier') return null
-    parts.unshift(cur.name)
-    return parts.join('.')
-}
+export default {
+    getMemberPath(node) {
+        const parts = [] ; let currentNode = node
+        while (currentNode?.type == 'MemberExpression') {
+            if (currentNode.computed || currentNode.property.type != 'Identifier') return null
+            parts.unshift(currentNode.property.name)
+            currentNode = currentNode.object
+        }
+        if (currentNode?.type != 'Identifier') return null
+        parts.unshift(currentNode.name)
+        return parts.join('.')
+    },
 
-export function isInsideNestedFunction(node) {
-    let current = node.parent
-    while (current) {
-        if (['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'].includes(current.type))
-            return true
-        current = current.parent
+    isInsideNestedFunction(node) {
+        let ancestor = node.parent
+        while (ancestor) {
+            if (['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'].includes(ancestor.type))
+                return true
+            ancestor = ancestor.parent
+        }
+        return false
     }
-    return false
 }

package/src/utils/pkg.js

@@ -1,19 +1,21 @@
 import fs from 'node:fs'
 import path from 'node:path'
 
-export function findRoot(dir) {
-    let current = path.resolve(dir)
-    while (true) {
-        if (current.split(path.sep).includes('node_modules')) {
+export default {
+    findRoot(dir) {
+        let current = path.resolve(dir)
+        while (true) {
+            if (current.split(path.sep).includes('node_modules')) {
+                const parent = path.dirname(current)
+                if (parent === current) return null
+                current = parent
+                continue
+            }
+            if ( // eslint-disable-next-line security/detect-non-literal-fs-filename
+                fs.existsSync(path.join(current, 'package.json'))) return current
             const parent = path.dirname(current)
             if (parent === current) return null
             current = parent
-            continue
         }
-        // eslint-disable-next-line security/detect-non-literal-fs-filename
-        if (fs.existsSync(path.join(current, 'package.json'))) return current
-        const parent = path.dirname(current)
-        if (parent === current) return null
-        current = parent
     }
 }

package/src/utils/rules.js

@@ -1,5 +1,7 @@
-export function bundle(rules, predicate, pluginName) {
-    return Object.fromEntries(Object.entries(rules)
-        .filter(([, rule]) => predicate(rule))
-        .map(([ruleId]) => [`${pluginName}/${ruleId}`, 'error']))
+export default {
+    bundle(rules, predicate, pluginName) {
+        return Object.fromEntries(Object.entries(rules)
+            .filter(([, rule]) => predicate(rule))
+            .map(([ruleId]) => [`${pluginName}/${ruleId}`, 'error']))
+    }
 }