@a11yfred/neighbor 0.1.0

package/lib/ulam-rules.js

@@ -0,0 +1,225 @@
+/**
+ * neighbor/lib/ulam-rules.js
+ * Lint rules specific to @ulam framework patterns.
+ *
+ * These rules operate on JS/JSX call expressions and import declarations,
+ * not on JSX element visitors — they do not take the `h` adapter.
+ *
+ * Rules:
+ *   no-announce-in-render        — announce() called in component body, not effect/handler
+ *   no-hash-router-in-remix      — importing from siling-labuyo/hashRouter in a Remix project
+ *   no-use-page-title-in-remix   — usePageTitle() used alongside react-router imports
+ */
+
+// ─── no-announce-in-render ───────────────────────────────────────────────────
+//
+// announce() writes to a live region. Calling it directly in a component body
+// fires on every render, spamming screen readers with repeated announcements.
+// It must only be called inside useEffect, useLayoutEffect, or event handlers.
+
+const ANNOUNCE_FNS = new Set(['announce', 'clearAnnouncements'])
+const SAFE_PARENT_CALLS = new Set([
+  'useEffect', 'useLayoutEffect', 'useInsertionEffect',
+  'useCallback', 'useMemo',
+])
+
+function isInsideSafeContext(node) {
+  let cur = node.parent
+  while (cur) {
+    // Arrow or function expression passed as argument to useEffect etc.
+    if (
+      cur.type === 'CallExpression' &&
+      cur.callee?.name &&
+      SAFE_PARENT_CALLS.has(cur.callee.name)
+    ) return true
+    // Event handler: onClick={...}, onKeyDown={...}, etc.
+    if (
+      cur.type === 'JSXExpressionContainer' &&
+      cur.parent?.type === 'JSXAttribute' &&
+      cur.parent?.name?.name?.startsWith('on')
+    ) return true
+    // Regular function (not a component body) — event listeners, async handlers
+    if (
+      cur.type === 'FunctionDeclaration' ||
+      cur.type === 'FunctionExpression' ||
+      cur.type === 'ArrowFunctionExpression'
+    ) {
+      // Standalone function (not a callback) — safe
+      const parent = cur.parent
+      if (parent?.type !== 'CallExpression') return true
+      // It's a callback — only safe if the callee is a known safe hook
+      if (parent.callee?.name && SAFE_PARENT_CALLS.has(parent.callee.name)) return true
+      // Could be an event handler function passed as a prop — allow it
+      if (parent.callee?.type === 'MemberExpression') return true
+      // Nested callback (e.g. setState inside onClick) — keep traversing upward
+      // Don't bail here; let the loop continue to find the enclosing context
+    }
+    cur = cur.parent
+  }
+  return false
+}
+
+export function makeNoAnnounceInRender() {
+  return {
+    meta: {
+      type: 'problem',
+      docs: { description: 'Disallow announce() called directly in a component render body' },
+      messages: {
+        inRender:
+          '`{{fn}}()` called outside a useEffect or event handler will fire on every render, ' +
+          'spamming screen readers. Move it into useEffect(() => { {{fn}}(...) }, [dep]) ' +
+          'or call it from an event handler. (@ulam/taho)',
+      },
+      schema: [],
+    },
+    create(context) {
+      return {
+        CallExpression(node) {
+          const name = node.callee?.name
+          if (!name || !ANNOUNCE_FNS.has(name)) return
+          if (isInsideSafeContext(node)) return
+          context.report({ node, messageId: 'inRender', data: { fn: name } })
+        },
+      }
+    },
+  }
+}
+
+// ─── no-hash-router-in-remix ─────────────────────────────────────────────────
+//
+// The @ulam hash router (siling-labuyo/hashRouter, @ulam/sili/hashRouter) is a
+// fallback for plain SPA builds. In Remix, file-based routing replaces it.
+// Importing from the hash router in a file that also uses react-router means
+// the migration to siling-mahaba is incomplete.
+
+const HASH_ROUTER_PATHS = new Set([
+  'siling-labuyo/hashRouter',
+  '@ulam/sili/hashRouter',
+  '@ulam/siling-labuyo/hashRouter',
+])
+
+const REMIX_PATHS = new Set([
+  'react-router',
+  '@remix-run/react',
+  'react-router-dom',
+])
+
+export function makeNoHashRouterInRemix() {
+  return {
+    meta: {
+      type: 'suggestion',
+      docs: { description: 'Disallow @ulam hash router imports alongside react-router' },
+      messages: {
+        hashRouter:
+          'Importing from the @ulam hash router alongside react-router means the Remix migration ' +
+          'is incomplete. Replace hash router usage with siling-mahaba equivalents: ' +
+          'useRouter/useRouteMatch from @ulam/siling-mahaba. (@ulam/siling-mahaba)',
+      },
+      schema: [],
+    },
+    create(context) {
+      let hasRemixImport = false
+      const hashRouterNodes = []
+
+      return {
+        ImportDeclaration(node) {
+          const src = node.source.value
+          if (REMIX_PATHS.has(src)) hasRemixImport = true
+          if (HASH_ROUTER_PATHS.has(src) || src.includes('/hashRouter')) {
+            hashRouterNodes.push(node)
+          }
+        },
+        'Program:exit'() {
+          if (!hasRemixImport) return
+          for (const node of hashRouterNodes) {
+            context.report({ node, messageId: 'hashRouter' })
+          }
+        },
+      }
+    },
+  }
+}
+
+// ─── no-use-page-title-in-remix ──────────────────────────────────────────────
+//
+// usePageTitle() from siling-labuyo sets document.title imperatively.
+// In Remix, page titles are set via the `meta` export on each route module.
+// Using usePageTitle() alongside react-router imports means the migration shim
+// has not been cleaned up.
+
+const USE_PAGE_TITLE_SOURCES = new Set([
+  'siling-labuyo/hooks/usePageTitle',
+  '@ulam/sili',
+  '@ulam/siling-labuyo',
+  '@ulam/siling-mahaba',
+])
+
+export function makeNoUsePageTitleInRemix() {
+  return {
+    meta: {
+      type: 'suggestion',
+      docs: { description: 'Disallow usePageTitle() in Remix — use the meta export instead' },
+      messages: {
+        usePageTitle:
+          '`usePageTitle()` sets document.title imperatively, which conflicts with Remix\'s ' +
+          'declarative `meta` export. Export a `meta` function from each route module instead: ' +
+          '`export const meta = () => [{ title: "App | Page" }]`. ' +
+          'Then remove this import. (@ulam/siling-mahaba)',
+      },
+      schema: [],
+    },
+    create(context) {
+      let hasRemixImport = false
+      const usePageTitleNodes = []
+
+      return {
+        ImportDeclaration(node) {
+          const src = node.source.value
+          if (REMIX_PATHS.has(src)) hasRemixImport = true
+          const importsUsePageTitle = node.specifiers.some(
+            s => s.type === 'ImportSpecifier' && s.imported?.name === 'usePageTitle'
+          )
+          if (importsUsePageTitle && USE_PAGE_TITLE_SOURCES.has(src)) {
+            usePageTitleNodes.push(node)
+          }
+          // Also catch wildcard re-exports like @ulam/siling-mahaba (which re-exports it)
+          if (importsUsePageTitle) usePageTitleNodes.push(node)
+        },
+        'Program:exit'() {
+          if (!hasRemixImport) return
+          // Deduplicate (wildcard catch above may double-push)
+          const seen = new Set()
+          for (const node of usePageTitleNodes) {
+            if (seen.has(node)) continue
+            seen.add(node)
+            context.report({ node, messageId: 'usePageTitle' })
+          }
+        },
+      }
+    },
+  }
+}
+
+// ─── All ulam rule factories ──────────────────────────────────────────────────
+
+export const ULAM_RULE_FACTORIES = {
+  'no-announce-in-render':      makeNoAnnounceInRender,
+  'no-hash-router-in-remix':    makeNoHashRouterInRemix,
+  'no-use-page-title-in-remix': makeNoUsePageTitleInRemix,
+}
+
+export function buildUlamRules() {
+  const rules = {}
+  for (const [name, factory] of Object.entries(ULAM_RULE_FACTORIES)) {
+    rules[name] = factory()
+  }
+  return rules
+}
+
+export function buildUlamRecommendedRules(ns) {
+  return {
+    [`${ns}/no-announce-in-render`]:      'error',
+    [`${ns}/no-hash-router-in-remix`]:    'warn',
+    [`${ns}/no-use-page-title-in-remix`]: 'warn',
+  }
+}

package/neighbor-eslint-angular.mjs

@@ -0,0 +1,66 @@
+/**
+ * @a11yfred/neighbor — ESLint plugin (Angular templates)
+ *
+ * Flags the same ARIA anti-patterns as neighbor-eslint.mjs but for Angular
+ * component templates. Requires @angular-eslint/template-parser.
+ *
+ * Rules that require ancestor walking (no-log-with-interactive-children,
+ * no-menu-role-on-nav, no-heading-inside-interactive) are limited because
+ * @angular-eslint/template-parser does not attach parent references to nodes.
+ * Those rules will still fire for direct matches but cannot walk the tree.
+ *
+ * Usage in eslint.config.js:
+ *   import angularTemplateParser from '@angular-eslint/template-parser'
+ *   import neighbor from '@a11yfred/neighbor/angular'
+ *
+ *   export default [
+ *     {
+ *       files: ['**\/*.html'],
+ *       languageOptions: { parser: angularTemplateParser },
+ *       plugins: { '@a11yfred/neighbor': neighbor },
+ *       rules: neighbor.configs.recommended.rules,
+ *     },
+ *   ]
+ */
+
+import { h } from './lib/helpers-angular.js'
+import { buildRules, buildRecommendedRules, buildPortabilityRules } from './lib/rules.js'
+
+const NS = '@a11yfred/neighbor'
+const rules = buildRules(h)
+const plugin = { meta: { name: `${NS}/angular` }, rules }
+
+let angularA11y = null
+try { angularA11y = (await import('@angular-eslint/eslint-plugin-template')).default } catch {}
+
+const ANGULAR_A11Y_RULES = [
+  'alt-text', 'click-events-have-key-events', 'elements-content',
+  'interactive-supports-focus', 'label-has-associated-control',
+  'mouse-events-have-key-events', 'no-autofocus', 'no-distracting-elements',
+  'no-positive-tabindex', 'role-has-required-aria', 'table-scope', 'valid-aria',
+]
+
+function getAngularA11yRules(plugin) {
+  const out = {}
+  for (const rule of ANGULAR_A11Y_RULES) {
+    if (plugin.rules?.[rule]) out[`@angular-eslint/template/${rule}`] = 'error'
+  }
+  return out
+}
+
+export default {
+  ...plugin,
+  configs: {
+    recommended: {
+      plugins: {
+        [NS]: plugin,
+        ...(angularA11y ? { '@angular-eslint/template': angularA11y } : {}),
+      },
+      rules: {
+        ...(angularA11y ? getAngularA11yRules(angularA11y) : {}),
+        ...buildRecommendedRules(NS),
+        ...buildPortabilityRules(NS),
+      },
+    },
+  },
+}

package/neighbor-eslint-vue.mjs

@@ -0,0 +1,46 @@
+/**
+ * @a11yfred/neighbor — ESLint plugin (Vue SFCs)
+ *
+ * Flags the same ARIA anti-patterns as neighbor-eslint.mjs but for Vue templates.
+ * Requires vue-eslint-parser as the project's ESLint parser for .vue files.
+ *
+ * Usage in eslint.config.js:
+ *   import vueParser from 'vue-eslint-parser'
+ *   import neighbor from '@a11yfred/neighbor/vue'
+ *
+ *   export default [
+ *     {
+ *       files: ['**\/*.vue'],
+ *       languageOptions: { parser: vueParser },
+ *       plugins: { '@a11yfred/neighbor': neighbor },
+ *       rules: neighbor.configs.recommended.rules,
+ *     },
+ *   ]
+ */
+
+import { h } from './lib/helpers-vue.js'
+import { buildRules, buildRecommendedRules, buildPortabilityRules } from './lib/rules.js'
+
+const NS = '@a11yfred/neighbor'
+const rules = buildRules(h)
+const plugin = { meta: { name: `${NS}/vue` }, rules }
+
+let vueA11y = null
+try { vueA11y = (await import('eslint-plugin-vuejs-accessibility')).default } catch {}
+
+export default {
+  ...plugin,
+  configs: {
+    recommended: {
+      plugins: {
+        [NS]: plugin,
+        ...(vueA11y ? { 'vuejs-accessibility': vueA11y } : {}),
+      },
+      rules: {
+        ...(vueA11y ? vueA11y.configs['flat/recommended'].rules : {}),
+        ...buildRecommendedRules(NS),
+        ...buildPortabilityRules(NS),
+      },
+    },
+  },
+}

package/neighbor-eslint.mjs

@@ -0,0 +1,56 @@
+/**
+ * @a11yfred/neighbor — ESLint plugin (React / JSX)
+ *
+ * Flags ARIA patterns that are widely derided, semantically wrong, or have
+ * poor/no AT support — but are not caught by eslint-plugin-jsx-a11y recommended.
+ *
+ * Sources and credits:
+ *   Adrian Roselli         adrianroselli.com
+ *   Heydon Pickering       heydonworks.com, inclusive-components.design
+ *   Scott O'Hara           scottohara.me
+ *   Patrick Lauke          splintered.co.uk, patrickhlauke.github.io/aria
+ *   Karl Groves            karlgroves.com
+ *   Marcy Sutton           marcysutton.com
+ *   Eric Eggert            yatil.net
+ *   WAI-ARIA APG           w3.org/WAI/ARIA/apg
+ *   ARIA 1.2 spec          w3.org/TR/wai-aria-1.2
+ *
+ * Rules already covered by jsx-a11y recommended (not duplicated here):
+ *   aria-hidden on focusable           → jsx-a11y/no-aria-hidden-on-focusable
+ *   presentation/none on interactive   → jsx-a11y/no-interactive-element-to-noninteractive-role
+ *   redundant role                     → jsx-a11y/no-redundant-roles
+ *   prefer semantic element            → jsx-a11y/prefer-tag-over-role
+ *   invalid role value                 → jsx-a11y/aria-role
+ *   invalid aria prop                  → jsx-a11y/aria-props
+ *   tabindex > 0                       → jsx-a11y/tabindex-no-positive
+ *   tabindex on non-interactive        → jsx-a11y/no-noninteractive-tabindex
+ *   img missing alt                    → jsx-a11y/alt-text
+ *   input missing label                → jsx-a11y/label-has-associated-control
+ */
+
+import jsxA11y from 'eslint-plugin-jsx-a11y'
+import { h } from './lib/helpers-jsx.js'
+import { buildRules, buildRecommendedRules } from './lib/rules.js'
+import { buildUlamRules, buildUlamRecommendedRules } from './lib/ulam-rules.js'
+
+const NS = '@a11yfred/neighbor'
+const rules = { ...buildRules(h), ...buildUlamRules() }
+
+const plugin = { meta: { name: NS }, rules }
+
+export default {
+  ...plugin,
+  configs: {
+    recommended: {
+      plugins: {
+        [NS]: plugin,
+        'jsx-a11y': jsxA11y,
+      },
+      rules: {
+        ...jsxA11y.configs.recommended.rules,
+        ...buildRecommendedRules(NS),
+        ...buildUlamRecommendedRules(NS),
+      },
+    },
+  },
+}

package/neighbor-stylelint.mjs

@@ -0,0 +1,196 @@
+/**
+ * @a11yfred/neighbor — Stylelint plugin
+ *
+ * Rules:
+ *   ulam/user-preferences  — Warn when motion, transparency, or alpha colors
+ *                            are used without @media (prefers-*) fallbacks.
+ *   ulam/no-outline-none   — Disallow bare outline:none/0 outside :focus selectors.
+ *
+ * Sources and credits:
+ *   WCAG 2.1 / 2.2         w3.org/TR/WCAG21, w3.org/TR/WCAG22
+ *   WebAIM                 webaim.org
+ *   double-great/stylelint-a11y  github.com/double-great/stylelint-a11y
+ */
+
+const defined = (x) => x !== undefined && x !== null;
+
+/** True if the node or any ancestor is a prefers-* / forced-colors media block */
+function insidePreferencesMedia(node) {
+  let current = node.parent;
+  while (defined(current)) {
+    if (
+      current.type === 'atrule' &&
+      current.name === 'media' &&
+      /prefers-|forced-colors/.test(current.params)
+    ) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+
+/** True if the value string contains an alpha channel (rgb/hsl with slash, or 8-digit hex) */
+function hasAlphaChannel(value) {
+  // rgb(r g b / a) or rgba() or hsl(h s l / a)
+  if (/\b(rgb|hsl)a?\s*\(/.test(value) && /\/\s*[01]?\.?\d+[^)]*\)/.test(value)) return true;
+  // 8-digit hex #rrggbbaa
+  if (/#[0-9a-fA-F]{8}\b/.test(value)) return true;
+  return false;
+}
+
+/** True if the opacity value is a structural endpoint (0 or 1), not a dim */
+function isStructuralOpacity(value) {
+  const n = parseFloat(value.trim());
+  return n === 0 || n === 1;
+}
+
+const ruleName = 'ulam/user-preferences';
+
+const messages = {
+  opacity: (value) =>
+    `opacity: ${value} creates a transparency effect. Add a fallback in @media (prefers-reduced-transparency: reduce) that uses an explicit color token instead. See src/components/ui/user-preferences.css.`,
+  animation: (prop, value) =>
+    `${prop}: ${value} uses motion. Add a fallback in @media (prefers-reduced-motion: reduce) that disables or stills this animation. See src/components/ui/user-preferences.css.`,
+  alpha: (value) =>
+    `Color value "${value}" uses an alpha channel. Add an opaque fallback in @media (prefers-reduced-transparency: reduce). See src/components/ui/user-preferences.css.`,
+};
+
+const meta = { url: 'https://github.com/a11yfred/neighbor' };
+
+/**
+ * Collect all selectors that appear inside a prefers-reduced-* or forced-colors
+ * media block anywhere in the file. Used to suppress warnings when an override exists.
+ * Splits comma-separated selector lists so each individual selector is tracked.
+ */
+function collectCoveredSelectors(root) {
+  const covered = new Set();
+  root.walkAtRules('media', (atRule) => {
+    if (!/prefers-|forced-colors/.test(atRule.params)) return;
+    atRule.walkRules((ruleNode) => {
+      // Split comma-separated selector lists
+      for (const part of ruleNode.selector.split(',')) {
+        const sel = part.trim();
+        covered.add(sel);
+        // Also add bare selector without pseudo-classes/pseudo-elements
+        covered.add(sel.replace(/::[^,\s{]+|:[^,\s{(]+(\([^)]*\))?/g, '').trim());
+      }
+    });
+  });
+  return covered;
+}
+
+/** True if the given selector (or its bare form) is in the covered set */
+function isCovered(selector, covered) {
+  // Split comma lists in the base selector too
+  for (const part of selector.split(',')) {
+    const norm = part.trim();
+    if (covered.has(norm)) return true;
+    const bare = norm.replace(/::[^,\s{]+|:[^,\s{(]+(\([^)]*\))?/g, '').trim();
+    if (covered.has(bare)) return true;
+  }
+  return false;
+}
+
+/** @type {import('stylelint').Rule} */
+function rule(primaryOption) {
+  return (root, result) => {
+    // Only enforce inside src/components/ui/
+    const filePath = (root.source?.input?.file ?? '').replace(/\\/g, '/');
+    if (!filePath.includes('src/components/ui')) return;
+    // Never enforce inside user-preferences.css itself
+    if (filePath.includes('user-preferences.css')) return;
+
+    // Pre-scan: collect selectors already covered by prefers overrides in this file
+    const covered = collectCoveredSelectors(root);
+
+    root.walkDecls((decl) => {
+      if (insidePreferencesMedia(decl)) return;
+
+      // If the containing rule's selector is already overridden in a prefers block, skip
+      const parentSelector = decl.parent?.selector ?? '';
+      if (parentSelector && isCovered(parentSelector, covered)) return;
+
+      const prop = decl.prop.toLowerCase();
+      const value = decl.value;
+
+      // opacity — warn on non-structural values (i.e. dims like 0.5, 0.75)
+      if (prop === 'opacity' && !isStructuralOpacity(value)) {
+        decl.warn(result, messages.opacity(value), { rule: ruleName });
+        return;
+      }
+
+      // animation or transition
+      if (prop === 'animation' || prop === 'transition' || prop === 'animation-name') {
+        // Skip "none" values — they're already the reduced state
+        if (/^none\b/i.test(value.trim())) return;
+        decl.warn(result, messages.animation(prop, value), { rule: ruleName });
+        return;
+      }
+
+      // Alpha-channel color values on visual properties
+      const visualProps = new Set([
+        'background', 'background-color', 'color', 'border', 'border-color',
+        'border-top-color', 'border-right-color', 'border-bottom-color', 'border-left-color',
+        'outline-color', 'box-shadow', 'text-shadow', 'fill', 'stroke',
+      ]);
+      if (visualProps.has(prop) && hasAlphaChannel(value)) {
+        decl.warn(result, messages.alpha(value), { rule: ruleName });
+      }
+    });
+  };
+}
+
+const userPreferences = { ruleName, rule, meta };
+
+// ─── Rule: ulam/no-outline-none ──────────────────────────────────────────────
+// outline: none / outline: 0 removes the browser's default keyboard focus
+// indicator. This is one of the most common keyboard accessibility failures —
+// keyboard users lose all visual indication of where focus is.
+//
+// Only fires when the declaration is NOT inside a :focus-visible, :focus, or
+// :focus-within selector, and no sibling :focus-visible rule overrides it in
+// the same block.
+//
+// Ref: WCAG 2.4.7 (Focus Visible); WebAIM; Roselli; cross-practitioner consensus
+
+const noOutlineNoneRuleName = 'ulam/no-outline-none';
+
+const noOutlineNoneMessages = {
+  removed: (value) =>
+    `outline: ${value} removes the keyboard focus indicator. Add a :focus-visible rule with a visible outline or custom focus style. (WCAG 2.4.7 / WebAIM)`,
+};
+
+const noOutlineNoneMeta = { url: 'https://github.com/a11yfred/neighbor' };
+
+/** Returns true if the selector string targets a focus state. */
+function isFocusSelector(selector) {
+  return /:focus(?:-visible|-within)?/i.test(selector);
+}
+
+/** @type {import('stylelint').Rule} */
+function noOutlineNoneRule(_primaryOption) {
+  return (root, result) => {
+    root.walkDecls(/^outline$/i, (decl) => {
+      const value = decl.value.trim().toLowerCase();
+      if (value !== 'none' && value !== '0') return;
+
+      // If this declaration is already inside a :focus / :focus-visible rule, it's fine —
+      // the author is intentionally restyling focus, which is acceptable as long as they
+      // provide an alternative (we can't verify the alternative statically, so we allow it).
+      const parent = decl.parent;
+      if (parent?.type === 'rule' && isFocusSelector(parent.selector ?? '')) return;
+
+      // Flag it
+      decl.warn(result, noOutlineNoneMessages.removed(decl.value), { rule: noOutlineNoneRuleName });
+    });
+  };
+}
+
+const noOutlineNone = {
+  ruleName: noOutlineNoneRuleName,
+  rule: noOutlineNoneRule,
+  meta: noOutlineNoneMeta,
+};
+
+export default [userPreferences, noOutlineNone];

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@a11yfred/neighbor",
+  "version": "0.1.0",
+  "description": "Accessibility linting plugin for a11yfred — Stylelint (user-preference fallbacks) and ESLint (bad ARIA patterns). Won't you be my neighbor?",
+  "type": "module",
+  "license": "MIT",
+  "files": ["lib", "*.mjs", "LICENSE", "README.md"],
+  "main": "./neighbor-stylelint.mjs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/a11yfred/neighbor.git"
+  },
+  "homepage": "https://github.com/a11yfred/neighbor#readme",
+  "bugs": {
+    "url": "https://github.com/a11yfred/neighbor/issues"
+  },
+  "exports": {
+    ".": "./neighbor-stylelint.mjs",
+    "./stylelint": "./neighbor-stylelint.mjs",
+    "./eslint": "./neighbor-eslint.mjs",
+    "./eslint-vue": "./neighbor-eslint-vue.mjs",
+    "./eslint-angular": "./neighbor-eslint-angular.mjs"
+  },
+  "keywords": [
+    "stylelint",
+    "stylelint-plugin",
+    "eslint",
+    "eslint-plugin",
+    "a11yfred",
+    "css",
+    "aria",
+    "accessibility",
+    "a11y"
+  ],
+  "peerDependencies": {
+    "@angular-eslint/eslint-plugin-template": ">=17",
+    "eslint": ">=8",
+    "eslint-plugin-jsx-a11y": ">=6",
+    "eslint-plugin-vuejs-accessibility": ">=2",
+    "stylelint": ">=14"
+  },
+  "peerDependenciesMeta": {
+    "eslint": {
+      "optional": true
+    },
+    "eslint-plugin-vuejs-accessibility": {
+      "optional": true
+    },
+    "@angular-eslint/eslint-plugin-template": {
+      "optional": true
+    },
+    "stylelint": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "eslint": "^9.39.4",
+    "eslint-plugin-jsx-a11y": "^6.10.2",
+    "stylelint": "^17.11.0"
+  }
+}