eslint-plugin-greasemonkey 1.8.4 → 1.9.0

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

@@ -0,0 +1,66 @@
+const re = { appendMethod: /^append(?:Child)?$/ }
+
+export default {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefers `GM_addStyle()` or a shadow root over manual `<style>` injection',
+            category: 'Best Practices'
+        },
+        schema: [],
+        messages: {
+            preferGmAddStyle: 'Use `GM_addStyle()` or inject into a `shadowRoot` '
+                            + 'instead of manually appending a `<style>` element.'
+        }
+    },
+
+    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))
+        }
+        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)
+                || isObjectAssign(node) && isCreateStyle(node.arguments[0])
+                || isObjectAssign(node)
+                    && node.arguments[0]?.type == 'Identifier'
+                    && styleElems.has(node.arguments[0].name)
+            ) return true
+            return false
+        }
+        return {
+            VariableDeclarator(node) {
+                if (node.id.type != 'Identifier') return
+                if (isStyleTarget(node.init))
+                    styleElems.add(node.id.name)
+                if (node.init?.type == 'Identifier' && isDocumentRef(node.init))
+                    docAliases.add(node.id.name)
+            },
+            CallExpression(node) {
+                if (node.callee.type != 'MemberExpression') return
+                const method = node.callee.property.name
+                if (!re.appendMethod.test(method) || !isDocumentMember(node.callee.object))
+                    return
+                for (const arg of node.arguments)
+                    if (isStyleTarget(arg))
+                        context.report({ node: arg, messageId: 'preferGmAddStyle' })
+            }
+        }
+    }
+}

package/src/rules/prefer-match.js

@@ -1,4 +1,4 @@
-import { extractMetadata } from '../utils.js'
+import metadata from '../utils/metadata.js'
 
 export default {
     meta: {
@@ -6,7 +6,8 @@ export default {
         docs: {
             description: 'Prefer @match over @include (see https://developer.chrome.com/docs/extensions/develop/migrate/mv2-deprecation-timeline)',
             category: 'Best Practices',
-            recommended: true
+            recommended: true,
+            security: true
         },
         schema: [],
         messages: { preferMatch: 'Use @match instead of @include.' }
@@ -15,7 +16,7 @@ export default {
     create(context) {
         return {
             Program() {
-                for (const entry of extractMetadata(context.sourceCode))
+                for (const entry of metadata.extract(context.sourceCode))
                     if (entry.key == 'include')
                         context.report({ node: entry.comment, messageId: 'preferMatch' })
             }

package/src/rules/require-homepage-pair.js

@@ -1,12 +1,11 @@
-import { extractMetadata } from '../utils.js'
+import metadata from '../utils/metadata.js'
 
 export default {
     meta: {
         type: 'problem',
         docs: {
             description: 'Require @homepage and @homepageURL to be used together',
-            category: 'Best Practices',
-            recommended: false
+            category: 'Best Practices'
         },
         fixable: 'code',
         schema: [],
@@ -16,7 +15,7 @@ export default {
     create(context) {
         return {
             Program() {
-                const metaEntries = extractMetadata(context.sourceCode),
+                const metaEntries = metadata.extract(context.sourceCode),
                       homepageEntry = metaEntries.find(entry => entry.key == 'homepage'),
                       homepageURLentry = metaEntries.find(entry => entry.key == 'homepageURL')
                 if (homepageEntry && !homepageURLentry)

package/src/rules/require-matching-localized-fields.js

@@ -1,4 +1,4 @@
-import { extractMetadata } from '../utils.js'
+import metadata from '../utils/metadata.js'
 
 export default {
     meta: {
@@ -31,7 +31,7 @@ export default {
               ignoreLangs = new Set(Array.isArray(rawLangs) ? rawLangs : [rawLangs])
         return {
             Program() {
-                const metaEntries = extractMetadata(context.sourceCode),
+                const metaEntries = metadata.extract(context.sourceCode),
                       nameEntries = metaEntries.filter(entry => entry.key.startsWith('name:')),
                       descEntries = metaEntries.filter(entry => entry.key.startsWith('description:')),
                       nameLangs = new Set(nameEntries.map(entry => entry.key.split(':')[1])),

package/src/rules/require-required-fields.js

@@ -1,4 +1,4 @@
-import { extractMetadata } from '../utils.js'
+import metadata from '../utils/metadata.js'
 
 export default {
     meta: {
@@ -33,7 +33,7 @@ export default {
               requireMatchOrInclude = options.requireMatchOrInclude ?? true
         return {
             Program(node) {
-                const metaEntries = extractMetadata(context.sourceCode),
+                const metaEntries = metadata.extract(context.sourceCode),
                       keys = new Set(metaEntries.map(entry => entry.key))
                 for (const field of requiredFields)
                     if (!keys.has(field))

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

@@ -1,4 +1,4 @@
-import { extractMetadata } from '../utils.js'
+import metadata from '../utils/metadata.js'
 
 const re = { leadingWhitespace: /^\s*/ }
 
@@ -19,7 +19,7 @@ export default {
         return {
             Program() {
                 const sourceCode = context.sourceCode,
-                      metaEntries = extractMetadata(sourceCode)
+                      metaEntries = metadata.extract(sourceCode)
                 for (const entry of metaEntries) {
                     const commentText = sourceCode.getText(entry.comment),
                           afterSlashes = commentText.slice(2)

package/src/rules/require-sri-hashing.js

@@ -1,4 +1,4 @@
-import { extractMetadata } from '../utils.js'
+import metadata from '../utils/metadata.js'
 
 const re = {
     hashEntry: /^(sha1|sha256|sha384|sha512|md5)[=-]([a-z0-9+/]+={0,2})$/i, hashFragment: /#([^#]+)$/, hashSep: /[,;]/ }
@@ -9,7 +9,7 @@ export default {
         docs: {
             description: 'Require SRI hashes on @require and @resource URLs',
             category: 'Possible Errors',
-            recommended: false
+            security: true
         },
         schema: [{
             type: 'object',
@@ -42,7 +42,7 @@ export default {
               expected = algorithms.join(' or ')
         return {
             'Program:exit'() {
-                for (const entry of extractMetadata(context.sourceCode)) {
+                for (const entry of metadata.extract(context.sourceCode)) {
                     if (entry.key != 'require' && entry.key != 'resource') continue
                     const fragment = entry.value.trim().match(re.hashFragment)?.[1]
                     if (!fragment) {

package/src/rules/require-update-download-pair.js

@@ -1,12 +1,11 @@
-import { extractMetadata } from '../utils.js'
+import metadata from '../utils/metadata.js'
 
 export default {
     meta: {
         type: 'problem',
         docs: {
             description: 'Require @updateURL and @downloadURL to be used together',
-            category: 'Best Practices',
-            recommended: false
+            category: 'Best Practices'
         },
         schema: [],
         messages: { missingPair: 'Missing @{{missing}} (required when @{{present}} is used).' }
@@ -15,7 +14,7 @@ export default {
     create(context) {
         return {
             Program() {
-                const metaEntries = extractMetadata(context.sourceCode),
+                const metaEntries = metadata.extract(context.sourceCode),
                       updateEntry = metaEntries.find(entry => entry.key == 'updateURL'),
                       downloadEntry = metaEntries.find(entry => entry.key == 'downloadURL')
                 if (updateEntry && !downloadEntry)

package/src/rules/require-user-js-filename.js

@@ -1,4 +1,4 @@
-import { extractMetadata } from '../utils.js'
+import metadata from '../utils/metadata.js'
 
 export default {
     meta: {
@@ -15,7 +15,7 @@ export default {
     create(context) {
         return {
             Program(node) {
-                const metaEntries = extractMetadata(context.sourceCode)
+                const metaEntries = metadata.extract(context.sourceCode)
                 if (!metaEntries.length) return
                 if (!context.filename.endsWith('.user.js'))
                     context.report({ node, messageId: 'requireUserJS' })

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

@@ -1,4 +1,4 @@
-import { extractMetadata } from '../utils.js'
+import metadata from '../utils/metadata.js'
 
 const re = { /* eslint-disable security/detect-unsafe-regex */
     semVer: /^\d+\.\d+\.\d+(?:-[\da-z.-]+)?(?:\+[\da-z.-]+)?$/i,
@@ -64,7 +64,7 @@ export default {
             : { year: new Date().getUTCFullYear(), month: new Date().getUTCMonth() +1 }
         return {
             Program() {
-                const metaEntries = extractMetadata(context.sourceCode)
+                const metaEntries = metadata.extract(context.sourceCode)
                 for (const entry of metaEntries) {
                     if (entry.key == 'grant' && allowedGrants.size && !allowedGrants.has(entry.value))
                         context.report({ node: entry.comment, messageId: 'invalidGrant', data: { grant: entry.value }})

package/src/utils/deprecations.js

@@ -0,0 +1,76 @@
+export default {
+    initAlias(plugin, [oldName, alias]) { /* eslint-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']
+                : Object.entries(entry)[0])) // [{ 'new-rule': { 'old-opt': 'new-opt' }}]
+            : alias // { 'new-rule': null | { 'new-opt': default } | { 'old-val': 'new-val' } | { ..., 'new-opt': default }}
+        const targetNames = Object.keys(routes),
+              isRename = !targetNames.includes(oldName),
+              originals = Object.fromEntries(targetNames.map(name => [name, plugin.rules[name]])),
+              source = originals[oldName] ?? originals[targetNames[0]]
+        plugin.rules[oldName] = {
+            meta: {
+                ...source.meta,
+                defaultOptions: [],
+                schema: [{ type: ['object', 'array', 'string', 'number', 'boolean', 'null'] }],
+                docs: { ...source.meta.docs, recommended: isRename ? false : source.meta.docs.recommended },
+                messages: {
+                    ...source.meta.messages,
+                    deprecatedOption: `'{{old}}' is deprecated. Use '{{new}}' instead.`
+                },
+                ...(isRename ? { deprecated: {
+                    message: `Use ${targetNames.map(name => `\`${name}\``).join(', ')} instead.`,
+                    replacedBy: targetNames.map(name => ({ rule: { name }}))
+                }} : {})
+            },
+            create(context) {
+                const opts = context.options[0],
+                      isObj = opts?.constructor === Object
+                return Object.assign({}, ...Object.entries(routes).map(([targetName, mapping]) => {
+                    let newOpts = opts, deprecation
+                    if (mapping) {
+                        const entries = Object.entries(mapping),
+                              namedRemap = entries.every(([, val]) => typeof val == 'string'),
+                              wrapKey = namedRemap && entries.length > 1 ? entries.at(-1)[0] : null,
+                              valMap = wrapKey ? Object.fromEntries(entries.slice(0, -1)) : mapping
+                        if (namedRemap) {
+                            if (typeof opts == 'string') { // bare old val → remap, optionally wrapped
+                                if (valMap[opts]) deprecation = { old: opts, new: valMap[opts] }
+                                const remapped = valMap[opts] ?? opts
+                                newOpts = wrapKey ? { [wrapKey]: remapped } : remapped
+                            } else if (wrapKey) { // object opts (or defaults) → remap inner val, warn if deprecated
+                                const raw = isObj ? (opts[wrapKey] ?? mapping[wrapKey]) : mapping[wrapKey],
+                                      remapped = valMap[raw]
+                                if (remapped) deprecation = { old: raw, new: remapped }
+                                newOpts = { [wrapKey]: remapped ?? raw }
+                            } else { // object opts → old key → new key
+                                newOpts = { ...opts }
+                                for (const [oldKey, newKey] of entries)
+                                    if (opts?.[oldKey] !== undefined) {
+                                        newOpts[newKey] = opts[oldKey] ; delete newOpts[oldKey] }
+                            }
+                        } else { // { new-opt: default } — positional wrap
+                            const [newKey, defaultValue] = entries[0]
+                            if (opts !== undefined && !isObj)
+                                deprecation = { old: JSON.stringify(opts), new: `{ ${newKey}: ${JSON.stringify(opts)} }` }
+                            newOpts = { [newKey]: isObj ? (opts[newKey] ?? defaultValue) : (opts ?? defaultValue) }
+                        }
+                    }
+                    const aliasContext = Object.create(context)
+                    Object.defineProperty(aliasContext, 'options',
+                        { value: [newOpts], writable: true, configurable: true, enumerable: true })
+                    const visitors = { ...originals[targetName].create(aliasContext) }
+                    if (deprecation) {
+                        const ruleProgram = visitors.Program
+                        visitors.Program = function(node) {
+                            context.report({ node, messageId: 'deprecatedOption', data: deprecation })
+                            if (ruleProgram) ruleProgram.call(this, node)
+                        }
+                    }
+                    return visitors
+                }))
+            }
+        }
+    } /* eslint-enable security/detect-object-injection */
+}

package/src/utils/init.js

@@ -0,0 +1,91 @@
+import deprecations from './deprecations.js'
+import rulesUtils from './rules.js'
+
+import { rules as deprecationsData } from '../data/deprecations.js'
+
+import metaOrder from '../rules/meta-order.js'
+import metaSpacing from '../rules/meta-spacing.js'
+import noDuplicateKeys from '../rules/no-duplicate-keys.js'
+import noInsecureFetch from '../rules/no-insecure-fetch.js'
+import noInsecureMessaging from '../rules/no-insecure-messaging.js'
+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 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 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'
+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'
+
+const namespace = 'greasemonkey',
+      managers = ['tampermonkey', 'violentmonkey', 'greasemonkey', 'scriptcat', 'adguard']
+
+export default {
+    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)
+        }
+        for (const manager of managers)
+            plugin.configs[manager] = { // eslint-disable-line security/detect-object-injection
+                plugins,
+                rules: {
+                    ...plugin.configs.recommended.rules,
+                    [`${namespace}/no-invalid-grants`]: ['error', { target: manager }],
+                    [`${namespace}/no-invalid-headers`]: ['error', { target: manager }],
+                    ...(['tampermonkey', 'scriptcat', 'adguard'].includes(manager) &&
+                        { [`${namespace}/require-update-download-pair`]: 'error' })
+                }
+            }
+    },
+
+    deprecations(plugin) {
+        for (const entry of Object.entries(deprecationsData))
+            deprecations.initAlias(plugin, entry)
+    },
+
+    plugin() { return { rules: {}, configs: {} }},
+
+    rules(plugin) {
+        plugin.rules = {
+            'meta-order': metaOrder,
+            'meta-spacing': metaSpacing,
+            'no-duplicate-keys': noDuplicateKeys,
+            'no-insecure-fetch': noInsecureFetch,
+            'no-insecure-messaging': noInsecureMessaging,
+            'no-invalid-grants': noInvalidGrants,
+            'no-invalid-headers': noInvalidHeaders,
+            'no-missing-grants': noMissingGrants,
+            'no-missing-resources': noMissingResources,
+            '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-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
+        }
+        for (const [ruleId, rule] of Object.entries(plugin.rules))
+            rule.meta.docs.url = `https://codeberg.org/adamlui/eslint-plugin-${namespace}/#${ruleId}`
+    }
+}

package/src/utils/metadata.js

@@ -0,0 +1,31 @@
+const re = { whitespace: /\s/ }
+
+export default {
+    createBlock(...entries) {
+        const lines = ['// ==UserScript==']
+        for (const entry of entries)
+            lines.push(typeof entry == 'string'
+                ? `// ${entry}`
+                : `// @${entry.key}${entry.value ? ` ${entry.value}` : ''}`)
+        lines.push('// ==/UserScript==')
+        return lines.join('\n') + '\n'
+    },
+
+    extract(sourceCode) {
+        const comments = sourceCode.getAllComments(),
+              metaEntries = []
+        let inMetaBlock
+        for (const comment of comments) {
+            const text = comment.value.trim()
+            if (!inMetaBlock && text == '==UserScript==') inMetaBlock = true
+            else if (inMetaBlock && text == '==/UserScript==') break
+            else if (inMetaBlock && text.startsWith('@')) { // capture entry
+                const spaceIdx = text.search(re.whitespace),
+                      key = ( spaceIdx == -1 ? text.slice(1) : text.slice(1, spaceIdx) ).trim(),
+                      value = spaceIdx == -1 ? '' : text.slice(spaceIdx +1).trim()
+                if (key) metaEntries.push({ key, value, comment, line: comment.loc.start.line })
+            }
+        }
+        return metaEntries
+    }
+}

package/src/utils/rules.js

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

package/src/utils/template.js

@@ -0,0 +1,21 @@
+export default {
+    resolve(node) {
+        function walk(n) {
+            if (n.type == 'ConditionalExpression') {
+                const branches = [n.consequent, n.alternate].map(walk)
+                return branches.every(Boolean) ? branches.flat() : null
+            } else if (n.type == 'Literal' && ['number', 'string'].includes(typeof n.value))
+                return [String(n.value)]
+            else if (n.type == 'TemplateLiteral')
+                return n.quasis.reduce((combos, quasi, idx) => {
+                    if (!combos) return null
+                    const withQuasi = combos.map(combo => combo + quasi.value.raw)
+                    if (idx >= n.expressions.length) return withQuasi
+                    const vals = walk(n.expressions[idx]) // eslint-disable-line security/detect-object-injection -- AST array indices are bounded
+                    return vals ? withQuasi.flatMap(combo => vals.map(val => combo + val)) : null
+                }, [''])
+            else return null
+        }
+        return walk(node)
+    }
+}

package/src/utils.js

@@ -1,119 +0,0 @@
-const re = { whitespace: /\s/ }
-
-export function bundleRules(rules, predicate, pluginName) {
-    return Object.fromEntries(Object.entries(rules)
-        .filter(([, rule]) => predicate(rule))
-        .map(([ruleId]) => [`${pluginName}/${ruleId}`, 'error']))
-}
-
-export function extractMetadata(sourceCode) {
-    const comments = sourceCode.getAllComments(),
-          metaEntries = []
-    let inMetaBlock
-    for (const comment of comments) {
-        const text = comment.value.trim()
-        if (!inMetaBlock && text == '==UserScript==') inMetaBlock = true
-        else if (inMetaBlock && text == '==/UserScript==') break
-        else if (inMetaBlock && text.startsWith('@')) { // capture entry
-            const spaceIdx = text.search(re.whitespace),
-                  key = ( spaceIdx == -1 ? text.slice(1) : text.slice(1, spaceIdx) ).trim(),
-                  value = spaceIdx == -1 ? '' : text.slice(spaceIdx +1).trim()
-            if (key) metaEntries.push({ key, value, comment, line: comment.loc.start.line })
-        }
-    }
-    return metaEntries
-}
-
-export function initDeprecatedAlias(plugin, [oldName, alias]) { /* eslint-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']
-            : Object.entries(entry)[0])) // [{ 'new-rule': { 'old-opt': 'new-opt' }}]
-        : alias // { 'new-rule': null | { 'new-opt': default } | { 'old-val': 'new-val' } | { ..., 'new-opt': default }}
-    const targetNames = Object.keys(routes),
-          isRename = !targetNames.includes(oldName),
-          originals = Object.fromEntries(targetNames.map(name => [name, plugin.rules[name]])),
-          source = originals[oldName] ?? originals[targetNames[0]]
-    plugin.rules[oldName] = {
-        meta: {
-            ...source.meta,
-            defaultOptions: [],
-            schema: [{ type: ['object', 'array', 'string', 'number', 'boolean', 'null'] }],
-            docs: { ...source.meta.docs, recommended: isRename ? false : source.meta.docs.recommended },
-            messages: {
-                ...source.meta.messages,
-                deprecatedOption: `'{{old}}' is deprecated. Use '{{new}}' instead.`
-            },
-            ...(isRename ? { deprecated: {
-                message: `Use ${targetNames.map(name => `\`${name}\``).join(', ')} instead.`,
-                replacedBy: targetNames.map(name => ({ rule: { name }}))
-            }} : {})
-        },
-        create(context) {
-            const opts = context.options[0],
-                  isObj = opts?.constructor === Object
-            return Object.assign({}, ...Object.entries(routes).map(([targetName, mapping]) => {
-                let newOpts = opts, deprecation
-                if (mapping) {
-                    const entries = Object.entries(mapping),
-                          namedRemap = entries.every(([, val]) => typeof val == 'string'),
-                          wrapKey = namedRemap && entries.length > 1 ? entries.at(-1)[0] : null,
-                          valMap = wrapKey ? Object.fromEntries(entries.slice(0, -1)) : mapping
-                    if (namedRemap) {
-                        if (typeof opts == 'string') { // bare old val → remap, optionally wrapped
-                            if (valMap[opts]) deprecation = { old: opts, new: valMap[opts] }
-                            const remapped = valMap[opts] ?? opts
-                            newOpts = wrapKey ? { [wrapKey]: remapped } : remapped
-                        } else if (wrapKey) { // object opts (or defaults) → remap inner val, warn if deprecated
-                            const raw = isObj ? (opts[wrapKey] ?? mapping[wrapKey]) : mapping[wrapKey],
-                                  remapped = valMap[raw]
-                            if (remapped) deprecation = { old: raw, new: remapped }
-                            newOpts = { [wrapKey]: remapped ?? raw }
-                        } else { // object opts → old key → new key
-                            newOpts = { ...opts }
-                            for (const [oldKey, newKey] of entries)
-                                if (opts?.[oldKey] !== undefined) {
-                                    newOpts[newKey] = opts[oldKey] ; delete newOpts[oldKey] }
-                        }
-                    } else { // { new-opt: default } — positional wrap
-                        const [newKey, defaultValue] = entries[0]
-                        if (opts !== undefined && !isObj)
-                            deprecation = { old: JSON.stringify(opts), new: `{ ${newKey}: ${JSON.stringify(opts)} }` }
-                        newOpts = { [newKey]: isObj ? (opts[newKey] ?? defaultValue) : (opts ?? defaultValue) }
-                    }
-                }
-                const aliasContext = Object.create(context)
-                Object.defineProperty(aliasContext, 'options',
-                    { value: [newOpts], writable: true, configurable: true, enumerable: true })
-                const visitors = { ...originals[targetName].create(aliasContext) }
-                if (deprecation) {
-                    const ruleProgram = visitors.Program
-                    visitors.Program = function(node) {
-                        context.report({ node, messageId: 'deprecatedOption', data: deprecation })
-                        if (ruleProgram) ruleProgram.call(this, node)
-                    }
-                }
-                return visitors
-            }))
-        }
-    }
-} /* eslint-enable security/detect-object-injection */
-
-export function resolveTemplate(node) {
-    if (node.type == 'ConditionalExpression') {
-        const branches = [node.consequent, node.alternate].map(resolveTemplate)
-        return branches.every(Boolean) ? branches.flat() : null
-    } else if (node.type == 'Literal' && ['number', 'string'].includes(typeof node.value))
-        return [String(node.value)]
-    else if (node.type == 'TemplateLiteral') // build every combo of quasis + resolved expressions
-        return node.quasis.reduce((combos, quasi, idx) => {
-            if (!combos) return null
-            const withQuasi = combos.map(combo => combo + quasi.value.raw)
-            if (idx >= node.expressions.length) return withQuasi
-            const vals = // eslint-disable-next-line security/detect-object-injection -- AST array indices are bounded
-                resolveTemplate(node.expressions[idx])
-            return vals ? withQuasi.flatMap(combo => vals.map(val => combo + val)) : null
-        }, [''])
-    else
-        return null
-}