@markuplint/rules 5.0.0-rc.2 → 5.0.0-rc.5

package/lib/rule-aliases.js

@@ -0,0 +1,325 @@
+/**
+ * Maps every rule name removed or renamed by the v5 rule-system redesign
+ * (#3989) to how it expands into its current replacement(s). Consumed by
+ * `markuplint`'s config resolution via `@markuplint/ml-config`'s
+ * `applyRuleAliases`, so a user's existing configuration keeps working
+ * (with a deprecation notice) instead of silently losing checks.
+ *
+ * Populated incrementally, one entry per rename/split commit, once the
+ * replacement rule(s) exist — see `spec-conformance.spec.ts` for the
+ * matching incremental rollout of `meta.specConformance`. Removed in v6
+ * alongside the deprecated names themselves.
+ */
+/**
+ * A 1:1 rename: the old name's resolved configuration passes through
+ * unchanged under the new name.
+ */
+function renamed(newName) {
+    return {
+        expand: rule => ({ [newName]: rule }),
+        targets: [newName],
+    };
+}
+/**
+ * A 1:N split where every replacement takes the exact same configuration
+ * (severity/reason/options passed through unchanged to each) — for rules
+ * with no options whose single check split by *what it checks* rather than
+ * by *option*, e.g. `deprecated-attr`'s `obsolete`/`deprecated` split.
+ */
+function split(...newNames) {
+    return {
+        expand: rule => Object.fromEntries(newNames.map(name => [name, rule])),
+        targets: newNames,
+    };
+}
+/** `AnyRule` is either a bare boolean/value shorthand or a full `RuleConfig` object. */
+function normalize(rule) {
+    if (typeof rule !== 'object' || rule === null) {
+        return {};
+    }
+    const { severity, options, reason, reasonOnly } = rule;
+    return { severity, options, reason, reasonOnly };
+}
+/**
+ * Whether `rule` disables the rule outright — either the bare `false`
+ * shorthand, or the long form `{ value: false, ... }` (meaningful for the
+ * boolean-`value`-typed rules every custom `expand` function in this file
+ * operates on, where `value` doubles as the enable flag).
+ */
+function isDisabled(rule) {
+    if (rule === false) {
+        return true;
+    }
+    return typeof rule === 'object' && rule !== null && rule.value === false;
+}
+function withOptions(rule, options) {
+    if (isDisabled(rule)) {
+        return false;
+    }
+    const { severity, reason, reasonOnly } = normalize(rule);
+    return {
+        value: true,
+        ...(severity && { severity }),
+        ...(options && Object.keys(options).length > 0 && { options }),
+        ...(reason && { reason }),
+        ...(reasonOnly && { reasonOnly }),
+    };
+}
+/**
+ * `invalid-attr`'s single check split four ways (v5 rule-system redesign):
+ * `no-unknown-attr` (name not in spec at all), `no-disallowed-attr` (name
+ * known but disallowed here — `noUse` / unmet `condition` / `is` on an
+ * autonomous custom element), `no-invalid-attr-value` (value/type
+ * violation), and `no-restricted-attr` (purely user-defined `disallowAttrs`
+ * denylisting, replacing the old rule's narrow named-rule mode).
+ *
+ * `allowAttrs` extends what a spec-validating rule considers valid, so it
+ * is copied to all three of them: it can suppress `no-unknown-attr` and
+ * `no-disallowed-attr`'s reports for a name, and supplies the value type
+ * `no-invalid-attr-value` checks against for names the spec doesn't define.
+ * `ignoreAttrNamePrefix` is copied to the two name-eligibility rules only —
+ * `no-invalid-attr-value` never reports for a name neither rule recognizes,
+ * so it needs no exclusion list of its own. `allowToAddPropertiesForPretender`
+ * moves to `no-unknown-attr` alone: it is specifically the pretender escape
+ * hatch for the "this name doesn't exist" report. `disallowAttrs` moves to
+ * `no-restricted-attr` alone — only included when actually configured, so a
+ * plain `invalid-attr: true` (no options) never turns on a rule with
+ * nothing to restrict.
+ */
+function expandInvalidAttr(rule) {
+    const { options } = normalize(rule);
+    const allowAttrs = options?.allowAttrs;
+    const disallowAttrs = options?.disallowAttrs;
+    const ignoreAttrNamePrefix = options?.ignoreAttrNamePrefix;
+    const allowToAddPropertiesForPretender = options?.allowToAddPropertiesForPretender;
+    const expanded = {
+        'no-unknown-attr': withOptions(rule, {
+            ...(allowAttrs !== undefined && { allowAttrs }),
+            ...(ignoreAttrNamePrefix !== undefined && { ignoreAttrNamePrefix }),
+            ...(allowToAddPropertiesForPretender !== undefined && { allowToAddPropertiesForPretender }),
+        }),
+        'no-disallowed-attr': withOptions(rule, {
+            ...(allowAttrs !== undefined && { allowAttrs }),
+            ...(ignoreAttrNamePrefix !== undefined && { ignoreAttrNamePrefix }),
+        }),
+        'no-invalid-attr-value': withOptions(rule, {
+            ...(allowAttrs !== undefined && { allowAttrs }),
+        }),
+    };
+    if (disallowAttrs !== undefined) {
+        expanded['no-restricted-attr'] = withOptions(rule, { disallowAttrs });
+    }
+    return expanded;
+}
+/**
+ * `landmark-roles` split two ways: `no-nested-top-level-landmark` (the
+ * `ignoreRoles` half — always present, `ignoreRoles` carried over unchanged)
+ * and `require-landmark-label` (the `labelEachArea` half, included unless
+ * the user explicitly set `labelEachArea: false` to opt out of it; the split
+ * rule has no such option itself, so there is nothing to carry over beyond
+ * whether it runs at all).
+ */
+function expandLandmarkRoles(rule) {
+    const { options } = normalize(rule);
+    const ignoreRoles = options?.ignoreRoles;
+    const labelEachArea = options?.labelEachArea;
+    const expanded = {
+        'no-nested-top-level-landmark': withOptions(rule, {
+            ...(ignoreRoles !== undefined && { ignoreRoles }),
+        }),
+    };
+    if (labelEachArea !== false) {
+        expanded['require-landmark-label'] = withOptions(rule);
+    }
+    return expanded;
+}
+/**
+ * `required-h1` split two ways: `require-h1` (the missing-`<h1>` half —
+ * always present regardless of the old options) and `no-duplicate-h1` (the
+ * `expected-once` half, included unless the user explicitly set
+ * `expected-once: false` to opt out of it). `in-document-fragment` is
+ * shared by both halves, so it is copied to each.
+ */
+function expandRequiredH1(rule) {
+    const { options } = normalize(rule);
+    const inDocumentFragment = options?.['in-document-fragment'];
+    const expectedOnce = options?.['expected-once'];
+    const sharedOptions = inDocumentFragment === undefined ? undefined : { 'in-document-fragment': inDocumentFragment };
+    const expanded = {
+        'require-h1': withOptions(rule, sharedOptions),
+    };
+    if (expectedOnce !== false) {
+        expanded['no-duplicate-h1'] = withOptions(rule, sharedOptions);
+    }
+    return expanded;
+}
+/**
+ * `no-unsupported-features` split three ways: `no-unsupported-browser-features`
+ * (the browserslist-based check — always present, `browserslist` /
+ * `browserslistConfig` / `browserslistEnv` carried over unchanged),
+ * `no-experimental-features` (the `checkExperimental` half, included only
+ * when that option was `true` — the split rule has no toggle of its own,
+ * enabling it IS the toggle), and `no-nonstandard-features` (the
+ * `checkNonStandard` half, same reasoning). `ignoreFeatures` is shared by
+ * all three, so it is copied to each.
+ */
+function expandNoUnsupportedFeatures(rule) {
+    const { options } = normalize(rule);
+    const browserslist = options?.browserslist;
+    const browserslistConfig = options?.browserslistConfig;
+    const browserslistEnv = options?.browserslistEnv;
+    const ignoreFeatures = options?.ignoreFeatures;
+    const checkExperimental = options?.checkExperimental;
+    const checkNonStandard = options?.checkNonStandard;
+    const expanded = {
+        'no-unsupported-browser-features': withOptions(rule, {
+            ...(browserslist !== undefined && { browserslist }),
+            ...(browserslistConfig !== undefined && { browserslistConfig }),
+            ...(browserslistEnv !== undefined && { browserslistEnv }),
+            ...(ignoreFeatures !== undefined && { ignoreFeatures }),
+        }),
+    };
+    if (checkExperimental) {
+        expanded['no-experimental-features'] = withOptions(rule, {
+            ...(ignoreFeatures !== undefined && { ignoreFeatures }),
+        });
+    }
+    if (checkNonStandard) {
+        expanded['no-nonstandard-features'] = withOptions(rule, {
+            ...(ignoreFeatures !== undefined && { ignoreFeatures }),
+        });
+    }
+    return expanded;
+}
+/**
+ * Every rule the `wai-aria` umbrella rule used to run a check for — the
+ * pre-existing 1:1-renamed/split successors, plus `no-aria-on-unsupported-element`
+ * (the `#ARIAAttrs: false` check the umbrella alone used to perform, before
+ * any of its per-check option toggles were even consulted).
+ */
+const WAI_ARIA_TARGETS = [
+    'no-aria-on-unsupported-element',
+    'no-unknown-role',
+    'no-abstract-role',
+    'require-parent-role',
+    'require-aria-prop',
+    'no-deprecated-role',
+    'no-redundant-role',
+    'permitted-roles',
+    'no-prohibited-naming',
+    'element-supports-aria-prop',
+    'role-supports-aria-prop',
+    'no-deprecated-aria-prop',
+    'no-redundant-aria-prop',
+    'no-contradictory-aria-prop',
+    'no-invalid-aria-prop-value',
+    'no-default-aria-value',
+    'aria-prop-requires-role',
+    'require-owned-elements',
+    'no-aria-on-presentational-children',
+    'no-focusable-in-aria-hidden',
+    'tab-requires-tabpanel',
+];
+/**
+ * `wai-aria: v` expands to every rule in `WAI_ARIA_TARGETS`, all receiving
+ * the same severity/reason (bare `withOptions(rule)`, no `options`). The
+ * umbrella's own per-check option toggles (`checkingDeprecatedRole`,
+ * `disallowSetImplicitProps`, `version`, etc.) have no successor to route
+ * to: each of these rules already ran its single check unconditionally
+ * once split off from the umbrella in an earlier step, and none of their
+ * schemas accept an `options` object at all — passing the toggles through
+ * would fail every target's schema validation, not silently no-op.
+ */
+function expandWaiAria(rule) {
+    const bare = withOptions(rule);
+    return Object.fromEntries(WAI_ARIA_TARGETS.map(name => [name, bare]));
+}
+/**
+ * `doctype` split two ways: `require-doctype` (missing-DOCTYPE-entirely, the
+ * `value: 'always'` half — always present regardless of the old options) and
+ * `no-obsolete-doctype` (the `denyObsoleteType` half, included unless the
+ * user explicitly set `denyObsoleteType: false` to opt out of it).
+ */
+function expandDoctype(rule) {
+    const { options } = normalize(rule);
+    const denyObsoleteType = options?.denyObsoleteType;
+    const expanded = {
+        'require-doctype': withOptions(rule),
+    };
+    if (denyObsoleteType !== false) {
+        expanded['no-obsolete-doctype'] = withOptions(rule);
+    }
+    return expanded;
+}
+export const ruleAliasTable = {
+    doctype: {
+        expand: expandDoctype,
+        targets: ['require-doctype', 'no-obsolete-doctype'],
+    },
+    'deprecated-attr': split('no-obsolete-attr', 'no-deprecated-attr'),
+    'deprecated-element': split('no-obsolete-element', 'no-deprecated-element'),
+    'character-reference': split('no-malformed-character-reference', 'no-unescaped-char'),
+    'table-row-column-alignment': split('no-table-cell-overlap', 'no-table-span-overflow', 'no-empty-table-track', 'consistent-table-row-length'),
+    'script-content': split('valid-importmap', 'valid-speculation-rules'),
+    'srcset-sizes-constraint': split('no-unpaired-srcset-sizes', 'no-mixed-srcset-descriptors', 'sizes-auto-requires-lazy-loading', 'no-always-matching-source'),
+    'wai-aria-disallowed-props': split('no-prohibited-naming', 'element-supports-aria-prop', 'role-supports-aria-prop'),
+    'wai-aria-implicit-props': split('no-redundant-aria-prop', 'no-contradictory-aria-prop'),
+    'landmark-roles': {
+        expand: expandLandmarkRoles,
+        targets: ['no-nested-top-level-landmark', 'require-landmark-label'],
+    },
+    'required-h1': {
+        expand: expandRequiredH1,
+        targets: ['require-h1', 'no-duplicate-h1'],
+    },
+    'no-unsupported-features': {
+        expand: expandNoUnsupportedFeatures,
+        targets: ['no-unsupported-browser-features', 'no-experimental-features', 'no-nonstandard-features'],
+    },
+    'wai-aria': {
+        expand: expandWaiAria,
+        targets: WAI_ARIA_TARGETS,
+    },
+    'attr-duplication': renamed('no-duplicate-attr'),
+    'id-duplication': renamed('no-duplicate-id'),
+    'required-element': renamed('require-element'),
+    'ineffective-attr': renamed('no-ineffective-attr'),
+    'end-tag': renamed('require-end-tag'),
+    'disallowed-element': renamed('no-restricted-element'),
+    'correct-aspect-ratio': renamed('no-mismatched-aspect-ratio'),
+    'heading-levels': renamed('no-skipped-heading-level'),
+    'input-file-empty-value': renamed('no-input-file-value'),
+    'neighbor-popovers': renamed('require-adjacent-popover'),
+    'no-hard-code-id': renamed('no-hardcoded-id'),
+    'no-use-event-handler-attr': renamed('no-event-handler-attr'),
+    'redundant-accessible-name': renamed('no-redundant-accessible-name'),
+    'use-list': renamed('no-pseudo-list'),
+    'wai-aria-abstract-role': renamed('no-abstract-role'),
+    'wai-aria-deprecated-role': renamed('no-deprecated-role'),
+    'wai-aria-deprecated-props': renamed('no-deprecated-aria-prop'),
+    'wai-aria-default-value': renamed('no-default-aria-value'),
+    'wai-aria-implicit-role': renamed('no-redundant-role'),
+    'wai-aria-no-global-prop': renamed('aria-prop-requires-role'),
+    'wai-aria-non-existent-role': renamed('no-unknown-role'),
+    'wai-aria-permitted-roles': renamed('permitted-roles'),
+    'wai-aria-interaction-in-hidden': renamed('no-focusable-in-aria-hidden'),
+    'wai-aria-presentational-children': renamed('no-aria-on-presentational-children'),
+    'wai-aria-required-owned-elements': renamed('require-owned-elements'),
+    'wai-aria-required-parent-role': renamed('require-parent-role'),
+    'wai-aria-required-props': renamed('require-aria-prop'),
+    'wai-aria-tab-requires-tabpanel': renamed('tab-requires-tabpanel'),
+    'wai-aria-value': renamed('no-invalid-aria-prop-value'),
+    // A straight rename. The original plan (#4.4) proposed also moving this
+    // rule's `{ name, value }` pattern-matching responsibility to
+    // `no-restricted-attr` once that rule existed — reconsidered once
+    // `no-restricted-attr` actually landed: "require this attribute's value
+    // to match a pattern" is a positive REQUIRE constraint, not a denylist,
+    // and only fits `no-restricted-attr`'s deny-only shape via an awkward
+    // negated pattern that changes the violation message's wording for no
+    // real benefit. `require-attr` keeps its full pre-rename scope.
+    'required-attr': renamed('require-attr'),
+    'invalid-attr': {
+        expand: expandInvalidAttr,
+        targets: ['no-unknown-attr', 'no-disallowed-attr', 'no-invalid-attr-value', 'no-restricted-attr'],
+    },
+};

package/lib/sizes-auto-requires-lazy-loading/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * HTML LS § the img element / the source element: `sizes="auto"` defers
+ * sizing to the image's intrinsic dimensions, which are unknown until the
+ * image starts loading — so it only makes sense together with
+ * `loading="lazy"`, which the spec requires. Split out of the former
+ * `srcset-sizes-constraint` rule's Checks 3 (`<img>`) and 4 (`<source>`, which
+ * checks the following sibling `<img>` instead of itself).
+ *
+ * Gated on `srcset` being present, matching the source rule this was split
+ * from: `sizes="auto"` has nothing to auto-size without candidates to choose
+ * from.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
+export default _default;

package/lib/sizes-auto-requires-lazy-loading/index.js

@@ -0,0 +1,68 @@
+import { createRule } from '@markuplint/ml-core';
+import { hasSizesAuto } from '../srcset-sizes-constraint/parse-srcset.js';
+import { findFollowingImg } from '../srcset-sizes-constraint/sibling-helpers.js';
+import meta from './meta.js';
+/**
+ * HTML LS § the img element / the source element: `sizes="auto"` defers
+ * sizing to the image's intrinsic dimensions, which are unknown until the
+ * image starts loading — so it only makes sense together with
+ * `loading="lazy"`, which the spec requires. Split out of the former
+ * `srcset-sizes-constraint` rule's Checks 3 (`<img>`) and 4 (`<source>`, which
+ * checks the following sibling `<img>` instead of itself).
+ *
+ * Gated on `srcset` being present, matching the source rule this was split
+ * from: `sizes="auto"` has nothing to auto-size without candidates to choose
+ * from.
+ */
+export default createRule({
+    meta,
+    async verify({ document, report }) {
+        await document.walkOn('Element', el => {
+            const localName = el.localName;
+            // Only check img and source (inside picture) elements
+            if (localName !== 'img' && localName !== 'source') {
+                return;
+            }
+            // source is only relevant inside <picture>
+            if (localName === 'source' && el.parentElement?.localName !== 'picture') {
+                return;
+            }
+            // Skip if element has spread attributes (dynamic props)
+            if (el.hasSpreadAttr) {
+                return;
+            }
+            if (!el.getAttributeNode('srcset')) {
+                return;
+            }
+            const sizesAttr = el.getAttributeNode('sizes');
+            const sizesValue = sizesAttr?.value ?? null;
+            const sizesIsDynamic = sizesAttr?.isDynamicValue;
+            // img[sizes=auto] → loading=lazy required
+            if (localName === 'img' && sizesValue != null && !sizesIsDynamic && hasSizesAuto(sizesValue)) {
+                const loading = el.getAttribute('loading');
+                if (loading !== 'lazy') {
+                    report({
+                        scope: el,
+                        line: sizesAttr.valueNode?.startLine,
+                        col: sizesAttr.valueNode?.startCol,
+                        raw: sizesAttr.valueNode?.raw,
+                        message: 'The "sizes" attribute with "auto" requires the "loading" attribute to be "lazy"',
+                    });
+                }
+            }
+            // source[sizes=auto] → following sibling img must have loading=lazy
+            if (localName === 'source' && sizesValue != null && !sizesIsDynamic && hasSizesAuto(sizesValue)) {
+                const img = findFollowingImg(el);
+                if (!img || img.getAttribute('loading') !== 'lazy') {
+                    report({
+                        scope: el,
+                        line: sizesAttr.valueNode?.startLine,
+                        col: sizesAttr.valueNode?.startCol,
+                        raw: sizesAttr.valueNode?.raw,
+                        message: 'The "source" element with sizes="auto" requires the following sibling "img" element to have loading="lazy"',
+                    });
+                }
+            }
+        });
+    },
+});

package/lib/sizes-auto-requires-lazy-loading/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "attributes";
+};
+export default _default;

package/lib/sizes-auto-requires-lazy-loading/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'attributes',
+};

package/lib/srcset-sizes-constraint/parse-srcset.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Shared by the four rules split out of the former `srcset-sizes-constraint` rule:
+ * `no-unpaired-srcset-sizes`, `no-mixed-srcset-descriptors`, and
+ * `sizes-auto-requires-lazy-loading` (`no-always-matching-source` does not parse
+ * `srcset` at all).
+ */
 /**
  * Descriptor type for an image candidate in a srcset attribute.
  * - `width`: ends with `w` (e.g., `480w`)

package/lib/srcset-sizes-constraint/parse-srcset.js

@@ -1,3 +1,9 @@
+/**
+ * Shared by the four rules split out of the former `srcset-sizes-constraint` rule:
+ * `no-unpaired-srcset-sizes`, `no-mixed-srcset-descriptors`, and
+ * `sizes-auto-requires-lazy-loading` (`no-always-matching-source` does not parse
+ * `srcset` at all).
+ */
 /**
  * Parse a `srcset` attribute value into its image candidates.
  *

package/lib/srcset-sizes-constraint/sibling-helpers.d.ts

@@ -0,0 +1,21 @@
+import type { Element } from '@markuplint/ml-core';
+/**
+ * Iterate the element's following element siblings in document order.
+ *
+ * Shared by `no-unpaired-srcset-sizes`, `sizes-auto-requires-lazy-loading`, and
+ * `no-always-matching-source` — the three rules split out of the former
+ * `srcset-sizes-constraint` rule that need to look at a `<source>`'s following
+ * siblings.
+ *
+ * @param el - The element whose following siblings to iterate
+ * @yields Each following element sibling, nearest first
+ */
+export declare function followingElementSiblings(el: Element<boolean>): Generator<Element<boolean>>;
+/**
+ * Find the first following sibling `<img>` element.
+ * Per the spec, the img does not have to be the immediately next sibling.
+ *
+ * @param el - The starting element to search from
+ * @returns The first following sibling `<img>` element, or `null` if none found
+ */
+export declare function findFollowingImg(el: Element<boolean>): Element<boolean> | null;

package/lib/srcset-sizes-constraint/sibling-helpers.js

@@ -0,0 +1,37 @@
+/**
+ * Iterate the element's following element siblings in document order.
+ *
+ * Shared by `no-unpaired-srcset-sizes`, `sizes-auto-requires-lazy-loading`, and
+ * `no-always-matching-source` — the three rules split out of the former
+ * `srcset-sizes-constraint` rule that need to look at a `<source>`'s following
+ * siblings.
+ *
+ * @param el - The element whose following siblings to iterate
+ * @yields Each following element sibling, nearest first
+ */
+export function* followingElementSiblings(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el) {
+    let sibling = el.nextElementSibling;
+    while (sibling != null) {
+        yield sibling;
+        sibling = sibling.nextElementSibling;
+    }
+}
+/**
+ * Find the first following sibling `<img>` element.
+ * Per the spec, the img does not have to be the immediately next sibling.
+ *
+ * @param el - The starting element to search from
+ * @returns The first following sibling `<img>` element, or `null` if none found
+ */
+export function findFollowingImg(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el) {
+    for (const sibling of followingElementSiblings(el)) {
+        if (sibling.localName === 'img') {
+            return sibling;
+        }
+    }
+    return null;
+}

package/lib/tab-requires-tabpanel/index.d.ts

@@ -0,0 +1,3 @@
+import type { Options } from '../wai-aria/types.js';
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/tab-requires-tabpanel/index.js

@@ -0,0 +1,21 @@
+import { createRule, getComputedRole, getSpec } from '@markuplint/ml-core';
+import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
+import { checkingTabRequiresTabpanel } from '../wai-aria/checkings/tab-requires-tabpanel.js';
+import { defaultOptions } from '../wai-aria/default-options.js';
+import meta from './meta.js';
+export default createRule({
+    meta,
+    defaultOptions,
+    async verify({ document, report }) {
+        await document.walkOn('Element', el => {
+            const elSpec = getSpec(el, document.specs.specs);
+            if (!elSpec)
+                return;
+            if (!elSpec.globalAttrs['#ARIAAttrs'])
+                return;
+            const ariaVersion = el.rule.options?.version ?? document.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION;
+            const computed = getComputedRole(document.specs, el, ariaVersion);
+            report(checkingTabRequiresTabpanel({ el, role: computed.role }));
+        });
+    },
+});

package/lib/tab-requires-tabpanel/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "a11y";
+};
+export default _default;

package/lib/tab-requires-tabpanel/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'a11y',
+};