@markuplint/rules 4.12.0 → 5.0.0-alpha.0

package/lib/permitted-contents/utils.js

@@ -1,15 +1,3 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Collection_locked, _Collection_matched, _Collection_nodes, _Collection_origin;
 import { createSelector } from '@markuplint/selector';
 import { bgGreen, green, bgRed, bgBlue, blue, bgMagenta, cyan } from './debug.js';
 import { transparentMode } from './represent-transparent-nodes.js';
@@ -229,7 +217,7 @@ export function mergeHints(
 a, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 b) {
-    const missing = [a.missing, b.missing].sort((a, b) => (b?.barelyMatchedElements ?? 0) - (a?.barelyMatchedElements ?? 0))[0];
+    const missing = [a.missing, b.missing].toSorted((a, b) => (b?.barelyMatchedElements ?? 0) - (a?.barelyMatchedElements ?? 0))[0];
     return cleanObject({
         ...a,
         ...b,
@@ -263,6 +251,10 @@ export function cleanObject(object) {
  * into matched and unmatched sets as the validation algorithm progresses.
  */
 export class Collection {
+    #locked = new Set();
+    #matched = new Set();
+    #nodes;
+    #origin;
     /**
      * Creates a new Collection from the given child nodes.
      *
@@ -271,36 +263,32 @@ export class Collection {
     constructor(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     origin) {
-        _Collection_locked.set(this, new Set());
-        _Collection_matched.set(this, new Set());
-        _Collection_nodes.set(this, void 0);
-        _Collection_origin.set(this, void 0);
-        __classPrivateFieldSet(this, _Collection_origin, [...origin], "f");
-        __classPrivateFieldSet(this, _Collection_nodes, new Set(__classPrivateFieldGet(this, _Collection_origin, "f")), "f");
+        this.#origin = [...origin];
+        this.#nodes = new Set(this.#origin);
     }
     /**
      * Returns a copy of the currently matched nodes in insertion order.
      */
     get matched() {
-        return [...__classPrivateFieldGet(this, _Collection_matched, "f")];
+        return [...this.#matched];
     }
     /**
      * Returns the number of currently matched nodes.
      */
     get matchedCount() {
-        return __classPrivateFieldGet(this, _Collection_matched, "f").size;
+        return this.#matched.size;
     }
     /**
      * Returns a copy of all original nodes in their original order.
      */
     get nodes() {
-        return [...__classPrivateFieldGet(this, _Collection_origin, "f")];
+        return [...this.#origin];
     }
     /**
      * Returns the nodes that have not yet been matched, preserving original order.
      */
     get unmatched() {
-        return [...__classPrivateFieldGet(this, _Collection_nodes, "f")].filter(n => !__classPrivateFieldGet(this, _Collection_matched, "f").has(n));
+        return [...this.#nodes].filter(n => !this.#matched.has(n));
     }
     /**
      * Adds nodes to the matched set. All nodes must belong to the original
@@ -312,14 +300,14 @@ export class Collection {
     addMatched(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     nodes) {
-        const i = __classPrivateFieldGet(this, _Collection_matched, "f").size;
+        const i = this.#matched.size;
         for (const node of nodes) {
-            if (!__classPrivateFieldGet(this, _Collection_nodes, "f").has(node)) {
+            if (!this.#nodes.has(node)) {
                 throw new ReferenceError(`External Node: ${node.nodeName}`);
             }
-            __classPrivateFieldGet(this, _Collection_matched, "f").add(node);
+            this.#matched.add(node);
         }
-        return i < __classPrivateFieldGet(this, _Collection_matched, "f").size;
+        return i < this.#matched.size;
     }
     /**
      * Reverts the matched set to the last locked state, discarding
@@ -327,7 +315,7 @@ export class Collection {
      * when a pattern match attempt fails after a zero-match.
      */
     back() {
-        __classPrivateFieldSet(this, _Collection_matched, new Set(__classPrivateFieldGet(this, _Collection_locked, "f")), "f");
+        this.#matched = new Set(this.#locked);
     }
     /**
      * Saves the current matched set as a checkpoint that `back()` can
@@ -335,7 +323,7 @@ export class Collection {
      * the known-good state.
      */
     lock() {
-        __classPrivateFieldSet(this, _Collection_locked, new Set(__classPrivateFieldGet(this, _Collection_matched, "f")), "f");
+        this.#locked = new Set(this.#matched);
     }
     /**
      * Trims the matched set to at most `max` entries by removing
@@ -345,9 +333,9 @@ export class Collection {
      * @param max - The maximum number of matched nodes to retain.
      */
     max(max) {
-        const sliced = [...__classPrivateFieldGet(this, _Collection_matched, "f")].slice(max);
+        const sliced = [...this.#matched].slice(max);
         for (const n of sliced)
-            __classPrivateFieldGet(this, _Collection_matched, "f").delete(n);
+            this.#matched.delete(n);
     }
     /**
      * Returns a colored string representation of all nodes for debug logging.
@@ -360,9 +348,9 @@ export class Collection {
      */
     toString(highlightExtraNodes = false) {
         const out = [];
-        for (const n of __classPrivateFieldGet(this, _Collection_origin, "f")) {
+        for (const n of this.#origin) {
             const raw = n.is(n.TEXT_NODE) ? `:text(${n.raw.replaceAll('\n', '\\n')})` : n.raw;
-            if (__classPrivateFieldGet(this, _Collection_locked, "f").has(n)) {
+            if (this.#locked.has(n)) {
                 if (transparentMode.has(n)) {
                     out.push(bgBlue.bold(raw));
                 }
@@ -371,7 +359,7 @@ export class Collection {
                 }
                 continue;
             }
-            if (__classPrivateFieldGet(this, _Collection_matched, "f").has(n)) {
+            if (this.#matched.has(n)) {
                 if (transparentMode.has(n)) {
                     out.push(blue.bold(raw));
                 }
@@ -399,7 +387,6 @@ export class Collection {
         return `[ ${out.join(', ')} ]`;
     }
 }
-_Collection_locked = new WeakMap(), _Collection_matched = new WeakMap(), _Collection_nodes = new WeakMap(), _Collection_origin = new WeakMap();
 /**
  * Error class representing an unsupported content model feature.
  * Thrown when the validation engine encounters a pattern type or

package/lib/redundant-accessible-name/index.d.ts

@@ -0,0 +1,10 @@
+import type { RuleConfigValue } from '@markuplint/ml-core';
+/**
+ * Rule that detects elements with multiple accessible name sources
+ * where a higher-priority source overrides a lower-priority one.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<RuleConfigValue, {
+    checkTitleFallback: boolean;
+    checkPlaceholderFallback: boolean;
+}>>;
+export default _default;

package/lib/redundant-accessible-name/index.js

@@ -0,0 +1,123 @@
+import { createRule, getComputedRole } from '@markuplint/ml-core';
+import { ARIA_RECOMMENDED_VERSION, isExposed } from '@markuplint/ml-spec';
+import { accnameMayBeMutable, getOwnedLabel } from '../helpers.js';
+import meta from './meta.js';
+/**
+ * Rule that detects elements with multiple accessible name sources
+ * where a higher-priority source overrides a lower-priority one.
+ */
+export default createRule({
+    meta,
+    defaultSeverity: 'warning',
+    defaultOptions: {
+        checkTitleFallback: false,
+        checkPlaceholderFallback: false,
+    },
+    async verify({ document, report, t }) {
+        await document.walkOn('Element', el => {
+            const ariaVersion = ARIA_RECOMMENDED_VERSION;
+            // Skip mutable elements (template expressions etc.)
+            if (accnameMayBeMutable(el, document)) {
+                return;
+            }
+            // Skip hidden elements
+            if (!isExposed(el, document.specs, ariaVersion)) {
+                return;
+            }
+            // Skip nameFrom: "prohibited" roles (generic, none, presentation)
+            const computed = getComputedRole(document.specs, el, ariaVersion);
+            if (computed.role?.accessibleNameProhibited) {
+                return;
+            }
+            const sources = collectNamingSources(el, document, el.rule.options, computed);
+            if (sources.length >= 2) {
+                const winner = sources[0];
+                const overridden = sources.slice(1);
+                for (const loser of overridden) {
+                    report({
+                        scope: el,
+                        message: t('The accessible name from "{0*}" overrides "{1*}"', winner.label, loser.label),
+                    });
+                }
+            }
+        });
+    },
+});
+function collectNamingSources(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+document, options, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+computed) {
+    const sources = [];
+    // 1. aria-labelledby
+    const ariaLabelledby = el.getAttribute('aria-labelledby');
+    if (ariaLabelledby && ariaLabelledby.trim()) {
+        const ids = ariaLabelledby.trim().split(/\s+/);
+        const hasResolvableId = ids.some(id => document.querySelector(`[id="${id}"]`));
+        if (hasResolvableId) {
+            sources.push({ label: 'aria-labelledby' });
+        }
+    }
+    // 2. aria-label
+    const ariaLabel = el.getAttribute('aria-label');
+    if (ariaLabel && ariaLabel.trim()) {
+        sources.push({ label: 'aria-label' });
+    }
+    // 3. label (explicit or implicit) — only for labelable elements
+    const ownedLabel = getOwnedLabel(el, document);
+    if (ownedLabel) {
+        sources.push({ label: 'label' });
+    }
+    // 4. alt — img, area, input[type=image]
+    if (el.matches('img, area, input[type=image]')) {
+        const alt = el.getAttribute('alt');
+        if (alt != null && alt.trim()) {
+            sources.push({ label: 'alt' });
+        }
+    }
+    // 5. content — role allows nameFromContent
+    if (computed.role?.accessibleNameFromContent) {
+        const text = el.textContent.trim();
+        if (text) {
+            sources.push({ label: 'content' });
+        }
+    }
+    // 6. value — input[type=button/submit/reset]
+    if (el.matches('input[type=button], input[type=submit], input[type=reset]')) {
+        const value = el.getAttribute('value');
+        if (value != null && value.trim()) {
+            sources.push({ label: 'value' });
+        }
+    }
+    // 7. legend — fieldset (direct child only)
+    if (el.matches('fieldset')) {
+        const legend = el.querySelector(':scope > legend');
+        if (legend && legend.textContent.trim()) {
+            sources.push({ label: 'legend' });
+        }
+    }
+    // 8. caption — table (direct child only)
+    if (el.matches('table')) {
+        const caption = el.querySelector(':scope > caption');
+        if (caption && caption.textContent.trim()) {
+            sources.push({ label: 'caption' });
+        }
+    }
+    // 9. title (optional)
+    if (options.checkTitleFallback) {
+        const title = el.getAttribute('title');
+        if (title != null && title.trim()) {
+            sources.push({ label: 'title' });
+        }
+    }
+    // 10. placeholder (optional)
+    if (options.checkPlaceholderFallback) {
+        const placeholder = el.getAttribute('placeholder');
+        if (placeholder != null && placeholder.trim()) {
+            sources.push({ label: 'placeholder' });
+        }
+    }
+    return sources;
+}

package/lib/redundant-accessible-name/meta.d.ts

@@ -0,0 +1,5 @@
+/** Rule metadata for the `redundant-accessible-name` rule, categorized as accessibility. */
+declare const _default: {
+    readonly category: "a11y";
+};
+export default _default;

package/lib/redundant-accessible-name/meta.js

@@ -0,0 +1,4 @@
+/** Rule metadata for the `redundant-accessible-name` rule, categorized as accessibility. */
+export default {
+    category: 'a11y',
+};

package/lib/require-accessible-name/index.d.ts

@@ -1,11 +1,4 @@
 import type { ARIAVersion } from '@markuplint/ml-spec';
-/**
- * Configuration options for the require-accessible-name rule.
- */
-type Option = {
-    /** The ARIA specification version to use for role and accessible name computation. */
-    ariaVersion: ARIAVersion;
-};
 /**
  * Rule that requires elements with roles that need accessible names to have one.
  *
@@ -13,5 +6,7 @@ type Option = {
  * has `accessibleNameRequired` set to `true`, this rule verifies that the element
  * provides a non-empty accessible name.
  */
-declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Option>>;
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, {
+    ariaVersion: ARIAVersion | undefined;
+}>>;
 export default _default;

package/lib/require-accessible-name/index.js

@@ -12,25 +12,26 @@ import meta from './meta.js';
 export default createRule({
     meta: meta,
     defaultOptions: {
-        ariaVersion: ARIA_RECOMMENDED_VERSION,
+        ariaVersion: undefined,
     },
     async verify({ document, report, t }) {
         await document.walkOn('Element', el => {
+            const ariaVersion = el.rule.options?.ariaVersion ?? document.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION;
             if (accnameMayBeMutable(el, document)) {
                 return;
             }
-            if (!isExposed(el, document.specs, el.rule.options.ariaVersion)) {
+            if (!isExposed(el, document.specs, ariaVersion)) {
                 return;
             }
-            const computed = getComputedRole(document.specs, el, el.rule.options.ariaVersion);
+            const computed = getComputedRole(document.specs, el, ariaVersion);
             if (!computed.role) {
                 return;
             }
-            const roleSpec = getRoleSpec(document.specs, computed.role.name, el.namespaceURI, el.rule.options.ariaVersion);
+            const roleSpec = getRoleSpec(document.specs, computed.role.name, el.namespaceURI, ariaVersion);
             if (!roleSpec || !roleSpec.accessibleNameRequired) {
                 return;
             }
-            const hasAccessibleName = !!el.getAccessibleName(el.rule.options.ariaVersion).trim();
+            const hasAccessibleName = !!el.getAccessibleName(ariaVersion).trim();
             if (!hasAccessibleName) {
                 report({ scope: el, message: t('Require {0}', 'accessible name') });
             }

package/lib/require-dialog-autofocus/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Rule that requires a `<dialog>` element referenced by a `show-modal` command
+ * to contain a descendant (or itself) with the `autofocus` attribute.
+ *
+ * Without `autofocus`, the browser's dialog focusing steps fall back to the
+ * `<dialog>` element itself, which is not ideal for accessibility — screen
+ * reader users may miss the dialog content, and keyboard users may need
+ * extra tab presses to reach interactive elements.
+ *
+ * Detection algorithm:
+ * 1. Find all `<button>` elements with both `command` and `commandfor` attributes
+ * 2. Filter to triggers whose `command` value is `show-modal` (case-insensitive)
+ * 3. Resolve the referenced `<dialog>` via `document.getElementById(commandfor)`
+ * 4. Skip non-dialog targets and already-reported dialogs (deduplication)
+ * 5. Report if neither the dialog nor any descendant has the `autofocus` attribute
+ *
+ * @see https://html.spec.whatwg.org/multipage/interactive-elements.html#dialog-focusing-steps
+ * @see https://html.spec.whatwg.org/multipage/interactive-elements.html#the-dialog-element
+ * @see https://www.w3.org/WAI/ARIA/apg/patterns/dialog-modal/
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
+export default _default;

package/lib/require-dialog-autofocus/index.js

@@ -0,0 +1,62 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+/**
+ * Rule that requires a `<dialog>` element referenced by a `show-modal` command
+ * to contain a descendant (or itself) with the `autofocus` attribute.
+ *
+ * Without `autofocus`, the browser's dialog focusing steps fall back to the
+ * `<dialog>` element itself, which is not ideal for accessibility — screen
+ * reader users may miss the dialog content, and keyboard users may need
+ * extra tab presses to reach interactive elements.
+ *
+ * Detection algorithm:
+ * 1. Find all `<button>` elements with both `command` and `commandfor` attributes
+ * 2. Filter to triggers whose `command` value is `show-modal` (case-insensitive)
+ * 3. Resolve the referenced `<dialog>` via `document.getElementById(commandfor)`
+ * 4. Skip non-dialog targets and already-reported dialogs (deduplication)
+ * 5. Report if neither the dialog nor any descendant has the `autofocus` attribute
+ *
+ * @see https://html.spec.whatwg.org/multipage/interactive-elements.html#dialog-focusing-steps
+ * @see https://html.spec.whatwg.org/multipage/interactive-elements.html#the-dialog-element
+ * @see https://www.w3.org/WAI/ARIA/apg/patterns/dialog-modal/
+ */
+export default createRule({
+    defaultSeverity: 'warning',
+    meta: meta,
+    verify({ document, report, t }) {
+        const triggers = document.querySelectorAll('button[command][commandfor]');
+        const reportedDialogIds = new Set();
+        for (const trigger of triggers) {
+            const command = trigger.getAttribute('command');
+            if (!command || command.toLowerCase() !== 'show-modal') {
+                continue;
+            }
+            const targetId = trigger.getAttribute('commandfor');
+            if (!targetId) {
+                continue;
+            }
+            if (reportedDialogIds.has(targetId)) {
+                continue;
+            }
+            const target = document.getElementById(targetId);
+            if (!target) {
+                continue;
+            }
+            if (target.localName !== 'dialog') {
+                continue;
+            }
+            if (target.hasAttribute('autofocus')) {
+                continue;
+            }
+            const autofocusDescendants = target.querySelectorAll('[autofocus]');
+            if (autofocusDescendants.length > 0) {
+                continue;
+            }
+            reportedDialogIds.add(targetId);
+            report({
+                scope: target,
+                message: t('The "{0*}" element referenced by a "{1*}" command requires an element with the "{2*}" attribute', 'dialog', 'show-modal', 'autofocus'),
+            });
+        }
+    },
+});

package/lib/require-dialog-autofocus/meta.d.ts

@@ -0,0 +1,5 @@
+/** Rule metadata for the `require-dialog-autofocus` rule, categorized as accessibility. */
+declare const _default: {
+    readonly category: "a11y";
+};
+export default _default;

package/lib/require-dialog-autofocus/meta.js

@@ -0,0 +1,4 @@
+/** Rule metadata for the `require-dialog-autofocus` rule, categorized as accessibility. */
+export default {
+    category: 'a11y',
+};

package/lib/required-attr/index.d.ts

@@ -9,6 +9,13 @@ type Attr = {
     /** One or more allowed values for the attribute, if constrained. */
     value?: string | string[];
 };
+/**
+ * Configuration options for the `required-attr` rule.
+ */
+type Options = {
+    /** Attribute names to exclude from required-attribute checks. */
+    readonly ignoreAttrs?: readonly string[];
+};
 /**
  * Rule that validates elements have all required attributes.
  *
@@ -16,5 +23,5 @@ type Attr = {
  * specified in the rule configuration. Also validates that required attribute values
  * match expected patterns when value constraints are provided.
  */
-declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<RequiredAttributes, undefined>>;
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<RequiredAttributes, Options>>;
 export default _default;

package/lib/required-attr/index.js

@@ -11,6 +11,7 @@ import meta from './meta.js';
 export default createRule({
     meta: meta,
     defaultValue: [],
+    defaultOptions: {},
     async verify({ document, report, t }) {
         await document.walkOn('Element', el => {
             if (el.hasSpreadAttr) {
@@ -18,6 +19,7 @@ export default createRule({
             }
             const customRequiredAttrs = typeof el.rule.value === 'string' ? [el.rule.value] : el.rule.value;
             const attrSpec = getAttrSpecs(el, document.specs);
+            const ignoreAttrs = new Set(el.rule.options.ignoreAttrs);
             const attributeSpecs = {};
             if (attrSpec && el.elementType === 'html') {
                 for (const spec of attrSpec) {
@@ -51,12 +53,33 @@ export default createRule({
                 };
             }
             for (const spec of Object.values(attributeSpecs)) {
+                if (ignoreAttrs.has(spec.name)) {
+                    if (spec.requiredEither) {
+                        const activeCandidates = spec.requiredEither.filter(n => !ignoreAttrs.has(n));
+                        if (activeCandidates.length > 0) {
+                            const invalid = !activeCandidates.some(attrName => el.hasAttribute(attrName));
+                            if (invalid) {
+                                const sortedCandidate = activeCandidates.toSorted();
+                                const expects = sortedCandidate.length === 1
+                                    ? t('the "{0*}" {1}', sortedCandidate[0], 'attribute')
+                                    : t('{0} {1}', sortedCandidate
+                                        .map(attrName => t('the "{0*}"', attrName))
+                                        // eslint-disable-next-line unicorn/no-array-reduce
+                                        .reduce((a, b) => t('{0} or {1}', a, b)), t('attribute'));
+                                const message = t('{0} expects {1}', t('the "{0*}" {1}', el.localName, 'element'), expects);
+                                report({ scope: el, message });
+                            }
+                        }
+                    }
+                    continue;
+                }
                 const didntHave = !el.hasAttribute(spec.name);
                 const candidate = [spec.name];
                 let invalid = false;
                 if (spec.requiredEither) {
                     candidate.push(...spec.requiredEither);
-                    invalid = !candidate.some(attrName => el.hasAttribute(attrName));
+                    const activeCandidates = candidate.filter(n => !ignoreAttrs.has(n));
+                    invalid = !activeCandidates.some(attrName => el.hasAttribute(attrName));
                 }
                 else if (spec.required === true) {
                     invalid = attrMatches(el, spec.condition) && didntHave;
@@ -65,11 +88,11 @@ export default createRule({
                     const selector = typeof spec.required === 'string' ? spec.required : spec.required.join(',');
                     invalid = el.matches(selector) && didntHave;
                 }
-                candidate.sort();
+                const sortedCandidate = candidate.filter(n => !ignoreAttrs.has(n)).toSorted();
                 if (invalid) {
-                    const expects = candidate.length === 1
+                    const expects = sortedCandidate.length === 1
                         ? t('the "{0*}" {1}', spec.name, 'attribute')
-                        : t('{0} {1}', candidate
+                        : t('{0} {1}', sortedCandidate
                             .map(attrName => t('the "{0*}"', attrName))
                             // eslint-disable-next-line unicorn/no-array-reduce
                             .reduce((a, b) => t('{0} or {1}', a, b)), t('attribute'));

package/lib/required-element/index.js

@@ -13,7 +13,7 @@ export default createRule({
     defaultValue: [],
     defaultOptions: {
         ignoreHasMutableContents: true,
-        ignoreOmittedElements: false,
+        ignoreOmittedElements: true,
     },
     async verify({ document, report, t }) {
         const hasMutableContent = document.nodeList.some(n => n.is(n.ELEMENT_NODE) && n.hasMutableChildren());

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

@@ -0,0 +1,6 @@
+/**
+ * Rule that enforces WHATWG constraints between the `srcset`, `sizes`,
+ * and `loading` attributes on `<img>` and `<source>` elements.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
+export default _default;