@markuplint/rules 3.0.0-alpha.66 → 3.0.0-dev.24

package/lib/wai-aria/checkings/implicit-role.js

@@ -4,13 +4,13 @@ exports.checkingImplicitRole = void 0;
 const ml_spec_1 = require("@markuplint/ml-spec");
 const checkingImplicitRole = ({ attr }) => t => {
     var _a;
-    const implictRole = (0, ml_spec_1.getImplicitRoleName)(attr.ownerElement, attr.rule.option.version, attr.ownerMLDocument.specs);
+    const implicitRole = (0, ml_spec_1.getImplicitRoleName)(attr.ownerElement, attr.rule.options.version, attr.ownerMLDocument.specs);
     const tokens = (_a = attr.tokenList) === null || _a === void 0 ? void 0 : _a.allTokens();
     if (!tokens) {
         return;
     }
     for (const token of tokens) {
-        if (implictRole === token.raw) {
+        if (implicitRole === token.raw) {
             return {
                 scope: token,
                 message: t('{0} is {1}', t('the "{0*}" {1}', token.raw, 'role'), t('{0} of {1}', 'the implicit role', t('the "{0*}" {1}', attr.ownerElement.localName, 'element'))),

package/lib/wai-aria/checkings/interaction-in-hidden.d.ts

@@ -0,0 +1,11 @@
+import type { Options } from '../types';
+import type { ElementChecker } from '@markuplint/ml-core';
+/**
+ * Including Elements in the Accessibility Tree
+ *
+ * @see https://w3c.github.io/aria/#tree_inclusion
+ * > Elements that are not hidden and may fire an accessibility API event, including:
+ * > - Elements that are currently focused, even if the element or one of its ancestor elements has its aria-hidden attribute set to true.
+ * > - Elements that are a valid target of an aria-activedescendant attribute.
+ */
+export declare const checkingInteractionInHidden: ElementChecker<boolean, Options>;

package/lib/wai-aria/checkings/interaction-in-hidden.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingInteractionInHidden = void 0;
+const ml_spec_1 = require("@markuplint/ml-spec");
+/**
+ * Including Elements in the Accessibility Tree
+ *
+ * @see https://w3c.github.io/aria/#tree_inclusion
+ * > Elements that are not hidden and may fire an accessibility API event, including:
+ * > - Elements that are currently focused, even if the element or one of its ancestor elements has its aria-hidden attribute set to true.
+ * > - Elements that are a valid target of an aria-activedescendant attribute.
+ */
+// フォーカスがあたっている場合に限り、先祖がaria-hidden=trueでもアクセシビリティツリーに提示される
+// なので、aria-hidden=trueの子孫要素で且つインタラクティブ要素である場合、
+// それは開発者にとってはほとんどの場合、意図しないことが多いはずなので、
+// 仕様上不正にはならないが、十分に注意しなければならない状態である。
+const checkingInteractionInHidden = ({ el }) => t => {
+    if (!(0, ml_spec_1.mayBeFocusable)(el, el.ownerMLDocument.specs)) {
+        return;
+    }
+    const ariaHidden = getClosestAriaHidden(el);
+    if (!ariaHidden) {
+        return;
+    }
+    if (el === ariaHidden.ownerElement) {
+        return {
+            scope: el,
+            message: t('It may be focusable in spite of it has aria-hidden=true'),
+        };
+    }
+    return {
+        scope: el,
+        message: t('It may be focusable in spite of it has the ancestor that has aria-hidden=true'),
+    };
+};
+exports.checkingInteractionInHidden = checkingInteractionInHidden;
+function getClosestAriaHidden(el) {
+    let current = el;
+    while (current) {
+        const ariaHidden = current.getAttributeNode('aria-hidden');
+        if ((ariaHidden === null || ariaHidden === void 0 ? void 0 : ariaHidden.value) === 'true') {
+            return ariaHidden;
+        }
+        current = current.parentElement;
+    }
+    return null;
+}

package/lib/wai-aria/checkings/{non-existant-role.d.ts → non-existent-role.d.ts}

@@ -1,3 +1,3 @@
 import type { Options } from '../types';
 import type { AttrChecker } from '@markuplint/ml-core';
-export declare const checkingNonExistantRole: AttrChecker<boolean, Options>;
+export declare const checkingNonExistentRole: AttrChecker<boolean, Options>;

package/lib/wai-aria/checkings/{non-existant-role.js → non-existent-role.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkingNonExistantRole = void 0;
+exports.checkingNonExistentRole = void 0;
 const ml_spec_1 = require("@markuplint/ml-spec");
-const checkingNonExistantRole = ({ attr }) => t => {
+const checkingNonExistentRole = ({ attr }) => t => {
     var _a;
-    const { roles, graphicsRoles } = (0, ml_spec_1.ariaSpecs)(attr.ownerMLDocument.specs, attr.rule.option.version);
+    const { roles, graphicsRoles } = (0, ml_spec_1.ariaSpecs)(attr.ownerMLDocument.specs, attr.rule.options.version);
     const tokens = (_a = attr.tokenList) === null || _a === void 0 ? void 0 : _a.allTokens();
     if (!tokens) {
         return;
@@ -25,4 +25,4 @@ const checkingNonExistantRole = ({ attr }) => t => {
         }
     }
 };
-exports.checkingNonExistantRole = checkingNonExistantRole;
+exports.checkingNonExistentRole = checkingNonExistentRole;

package/lib/wai-aria/checkings/permitted-roles.js

@@ -5,7 +5,7 @@ const ml_spec_1 = require("@markuplint/ml-spec");
 const checkingPermittedRoles = ({ attr }) => t => {
     var _a;
     const el = attr.ownerElement;
-    const permittedRoles = (0, ml_spec_1.getPermittedRoles)(el, el.rule.option.version, attr.ownerMLDocument.specs);
+    const permittedRoles = (0, ml_spec_1.getPermittedRoles)(el, el.rule.options.version, attr.ownerMLDocument.specs);
     if (permittedRoles.length === 0) {
         return {
             scope: attr,

package/lib/wai-aria/checkings/presentational-children.d.ts

@@ -0,0 +1,29 @@
+import type { Options } from '../types';
+import type { ElementChecker } from '@markuplint/ml-core';
+/**
+ * Presentational Children
+ *
+ * @see https://www.w3.org/TR/wai-aria/#childrenArePresentational
+ * @see https://w3c.github.io/aria/#childrenArePresentational
+ *
+ * > The DOM descendants are presentational.
+ * > user agents SHOULD NOT expose descendants of
+ * > this element through the platform accessibility API.
+ * > If user agents do not hide the descendant nodes,
+ * > some information may be read twice.
+ *
+ * @see https://w3c.github.io/aria/#tree_exclusion
+ *
+ * > Any descendants of elements that have the characteristic "Children Presentational: True"
+ * > unless the descendant is not allowed to be presentational
+ * > because it meets one of the conditions for exception described
+ * > in Presentational Roles Conflict Resolution.
+ * > However, the text content of any excluded descendants is included.
+ *
+ * @see https://w3c.github.io/aria/#tree_inclusion
+ *
+ *  > Text equivalents for hidden referenced objects
+ * > may still be used in the name and description computation
+ * > even when not included in the accessibility tree.
+ */
+export declare const checkingPresentationalChildren: ElementChecker<boolean, Options>;

package/lib/wai-aria/checkings/presentational-children.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingPresentationalChildren = void 0;
+const ml_spec_1 = require("@markuplint/ml-spec");
+/**
+ * Presentational Children
+ *
+ * @see https://www.w3.org/TR/wai-aria/#childrenArePresentational
+ * @see https://w3c.github.io/aria/#childrenArePresentational
+ *
+ * > The DOM descendants are presentational.
+ * > user agents SHOULD NOT expose descendants of
+ * > this element through the platform accessibility API.
+ * > If user agents do not hide the descendant nodes,
+ * > some information may be read twice.
+ *
+ * @see https://w3c.github.io/aria/#tree_exclusion
+ *
+ * > Any descendants of elements that have the characteristic "Children Presentational: True"
+ * > unless the descendant is not allowed to be presentational
+ * > because it meets one of the conditions for exception described
+ * > in Presentational Roles Conflict Resolution.
+ * > However, the text content of any excluded descendants is included.
+ *
+ * @see https://w3c.github.io/aria/#tree_inclusion
+ *
+ *  > Text equivalents for hidden referenced objects
+ * > may still be used in the name and description computation
+ * > even when not included in the accessibility tree.
+ */
+const checkingPresentationalChildren = ({ el }) => t => {
+    const ancestor = getAncestorHasPresentationalChildren(el);
+    if (!ancestor) {
+        return;
+    }
+    if (!ancestor.role) {
+        return;
+    }
+    const hasAriaAttr = Array.from(el.attributes).some(attr => /^aria-|^role$/i.test(attr.name));
+    if (!hasAriaAttr) {
+        return;
+    }
+    return {
+        scope: el,
+        message: t('it may be ineffective because {0}', t("it has {0} as an ancestor that doesn't expose its descendants to the accessibility tree", t('the "{0*}" {1}', ancestor.role.name, 'role'))),
+    };
+};
+exports.checkingPresentationalChildren = checkingPresentationalChildren;
+function getAncestorHasPresentationalChildren(el) {
+    var _a;
+    let current = el.parentElement;
+    while (current) {
+        const computed = (0, ml_spec_1.getComputedRole)(el.ownerMLDocument.specs, current, el.rule.options.version);
+        if ((_a = computed.role) === null || _a === void 0 ? void 0 : _a.childrenPresentational) {
+            return computed;
+        }
+        current = current.parentElement;
+    }
+    return null;
+}

package/lib/wai-aria/checkings/required-owned-elements.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingRequiredOwnedElements = void 0;
+const ml_spec_1 = require("@markuplint/ml-spec");
+/**
+ * Required Owned Elements
+ *
+ * @see https://w3c.github.io/aria/#mustContain
+ */
+const checkingRequiredOwnedElements = ({ el, role }) => t => {
+    if (!role) {
+        return;
+    }
+    if (!role.requiredOwnedElements.length) {
+        return;
+    }
+    /**
+     * > There may be times that required owned elements are missing,
+     * > for example, while editing or while loading a data set.
+     * > When a widget is missing required owned elements due to script execution or loading,
+     * > authors MUST mark a containing element with aria-busy equal to true.
+     * > For example, until a page is fully initialized and complete,
+     * > an author could mark the document element as busy.
+     *
+     * Stop to evaluate when it has `aria-busy=true` for it considers the contents are missing.
+     */
+    if (el.matches('[aria-busy="true" i]')) {
+        return;
+    }
+    // TODO: Needs to resolve `aria-own`
+    const children = Array.from(el.childNodes).map(child => {
+        if (child.is(child.ELEMENT_NODE)) {
+            if (child.matches('[aria-busy="true" i]')) {
+                return [child, 'BUSY'];
+            }
+            const computedChild = (0, ml_spec_1.getComputedRole)(child.ownerMLDocument.specs, child, child.rule.options.version);
+            if (role.requiredOwnedElements.some(ownedRole => (0, ml_spec_1.isRequiredOwnedElement)(computedChild, ownedRole, child.ownerMLDocument.specs, child.rule.options.version))) {
+                return [child, 'REQUIRED'];
+            }
+            return [child, 'OTHER'];
+        }
+        else if (child.is(child.MARKUPLINT_PREPROCESSOR_BLOCK)) {
+            return [child, 'PB'];
+        }
+        return [null, 'NO_ELEMENT'];
+    });
+    if (children.some(([, type]) => type === 'BUSY')) {
+        return;
+    }
+    /**
+     * > Any element that will be owned by the element with this role.
+     * > For example, an element with the role list
+     * > **will own at least one element** with the role listitem.
+     */
+    if (children.some(([, type]) => type === 'REQUIRED')) {
+        return;
+    }
+    if (children.some(([, type]) => type === 'PB')) {
+        // TODO: https://github.com/markuplint/markuplint/issues/490
+        return;
+    }
+    /**
+     * Has mutable children
+     *
+     * Ex:
+     *
+     * ```jsx
+     * <table>
+     *   <tbody>
+     *     {list.map((item) => <tr><td>{item}</td></tr>)}
+     *   </tbody>
+     * </table>
+     * ```
+     */
+    if (el.hasMutableChildren(true)) {
+        return;
+    }
+    if (mayBeBeforeCreated(el)) {
+        return {
+            scope: el,
+            message: t('{0}. Or, {1}', t('require {0}', role.requiredOwnedElements.length === 1
+                ? t('the "{0*}" {1}', role.requiredOwnedElements[0], 'role')
+                : t('the {0}', 'roles') + `: ${t(role.requiredOwnedElements)}`), t('require {0}', 'aria-busy="true"')),
+        };
+    }
+    return {
+        scope: el,
+        message: t('{0} expects {1}', t('the "{0*}" {1}', role.name, 'role'), role.requiredOwnedElements.length === 1
+            ? t('the "{0*}" {1}', role.requiredOwnedElements[0], 'role')
+            : t('the {0}', 'roles') + `: ${t(role.requiredOwnedElements)}`),
+    };
+};
+exports.checkingRequiredOwnedElements = checkingRequiredOwnedElements;
+function mayBeBeforeCreated(el) {
+    if (el.isEmpty()) {
+        return true;
+    }
+    return Array.from(el.children).every(child => {
+        return ['script', 'template'].includes(child.localName);
+    });
+}

package/lib/wai-aria/checkings/value.d.ts

@@ -4,4 +4,10 @@ import type { ARIAProperty, ARIARole } from '@markuplint/ml-spec';
 export declare const checkingValue: AttrChecker<boolean, Options, {
     role?: ARIARole | null;
     propSpecs: ARIAProperty[];
+    booleanish?: boolean;
 }>;
+/**
+ *
+ * @see https://www.w3.org/TR/wai-aria-1.2/#propcharacteristic_value
+ */
+export declare function checkAriaValue(type: string, value: string, tokenEnum: string[], booleanish?: boolean): boolean;

package/lib/wai-aria/checkings/value.js

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkingValue = void 0;
-const helpers_1 = require("../../helpers");
-const checkingValue = ({ attr, role, propSpecs }) => t => {
+exports.checkAriaValue = exports.checkingValue = void 0;
+const checkingValue = ({ attr, role, propSpecs, booleanish }) => t => {
     var _a;
     if (attr.isDynamicValue) {
         return;
     }
     const propSpec = propSpecs.find(p => p.name === attr.name);
-    const result = (0, helpers_1.checkAria)(attr.ownerMLDocument.specs, attr.name, attr.value, attr.rule.option.version, role === null || role === void 0 ? void 0 : role.name);
+    const result = checkAria(propSpec, attr.value, role === null || role === void 0 ? void 0 : role.name, booleanish);
     if (result.isValid) {
         return;
     }
@@ -19,3 +18,74 @@ const checkingValue = ({ attr, role, propSpecs }) => t => {
     };
 };
 exports.checkingValue = checkingValue;
+function checkAria(propSpec, currentValue, role, booleanish) {
+    if (!propSpec) {
+        return {
+            currentValue,
+            // For skipping checking
+            isValid: true,
+        };
+    }
+    let valueType = propSpec.value;
+    if (role && propSpec.conditionalValue) {
+        for (const cond of propSpec.conditionalValue) {
+            if (cond.role.includes(role)) {
+                valueType = cond.value;
+                break;
+            }
+        }
+    }
+    const isValid = checkAriaValue(valueType, currentValue, propSpec.enum, booleanish);
+    return {
+        ...propSpec,
+        currentValue,
+        isValid,
+    };
+}
+/**
+ *
+ * @see https://www.w3.org/TR/wai-aria-1.2/#propcharacteristic_value
+ */
+function checkAriaValue(type, value, tokenEnum, booleanish) {
+    switch (type) {
+        case 'token': {
+            return tokenEnum.includes(value);
+        }
+        case 'token list': {
+            const list = value.split(/\s+/g).map(s => s.trim());
+            return list.every(token => tokenEnum.includes(token));
+        }
+        case 'string':
+        case 'ID reference':
+        case 'ID reference list': {
+            return true;
+        }
+        case 'true/false': {
+            if (booleanish && value === '') {
+                return true;
+            }
+            return ['true', 'false'].includes(value);
+        }
+        case 'tristate': {
+            if (booleanish && value === '') {
+                return true;
+            }
+            return ['mixed', 'true', 'false', 'undefined'].includes(value);
+        }
+        case 'true/false/undefined': {
+            if (booleanish && value === '') {
+                return true;
+            }
+            return ['true', 'false', 'undefined'].includes(value);
+        }
+        case 'integer': {
+            return parseInt(value).toString() === value;
+        }
+        case 'number': {
+            return parseFloat(value).toString() === value;
+        }
+    }
+    // For skipping checking
+    return true;
+}
+exports.checkAriaValue = checkAriaValue;

package/lib/wai-aria/index.js

@@ -3,15 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ml_core_1 = require("@markuplint/ml-core");
 const helpers_1 = require("../helpers");
 const abstract_role_1 = require("./checkings/abstract-role");
-const checking_required_owned_elements_1 = require("./checkings/checking-required-owned-elements");
 const default_value_1 = require("./checkings/default-value");
 const deprecated_props_1 = require("./checkings/deprecated-props");
 const disallowed_prop_1 = require("./checkings/disallowed-prop");
 const implicit_props_1 = require("./checkings/implicit-props");
 const implicit_role_1 = require("./checkings/implicit-role");
+const interaction_in_hidden_1 = require("./checkings/interaction-in-hidden");
 const no_global_prop_1 = require("./checkings/no-global-prop");
-const non_existant_role_1 = require("./checkings/non-existant-role");
+const non_existent_role_1 = require("./checkings/non-existent-role");
 const permitted_roles_1 = require("./checkings/permitted-roles");
+const presentational_children_1 = require("./checkings/presentational-children");
+const required_owned_elements_1 = require("./checkings/required-owned-elements");
 const required_prop_1 = require("./checkings/required-prop");
 const value_1 = require("./checkings/value");
 exports.default = (0, ml_core_1.createRule)({
@@ -20,6 +22,8 @@ exports.default = (0, ml_core_1.createRule)({
         checkingDeprecatedProps: true,
         permittedAriaRoles: true,
         checkingRequiredOwnedElements: true,
+        checkingPresentationalChildren: false,
+        checkingInteractionInHidden: false,
         disallowSetImplicitRole: true,
         disallowSetImplicitProps: true,
         disallowDefaultValue: false,
@@ -30,7 +34,7 @@ exports.default = (0, ml_core_1.createRule)({
             const roleAttr = el.getAttributeNode('role');
             const propAttrs = el.attributes.filter(attr => /^aria-/i.test(attr.name));
             const ariaAttrs = new helpers_1.Collection(roleAttr, ...propAttrs);
-            const elSpec = (0, ml_core_1.getSpec)(el, document.specs);
+            const elSpec = (0, ml_core_1.getSpec)(el, document.specs.specs);
             if (!elSpec) {
                 return;
             }
@@ -43,44 +47,50 @@ exports.default = (0, ml_core_1.createRule)({
                 }
                 return;
             }
-            const computed = (0, ml_core_1.getComputedRole)(document.specs, el, el.rule.option.version);
-            const { props: propSpecs } = (0, ml_core_1.ariaSpecs)(document.specs, el.rule.option.version);
+            const computed = (0, ml_core_1.getComputedRole)(document.specs, el, el.rule.options.version);
+            const { props: propSpecs } = (0, ml_core_1.ariaSpecs)(document.specs, el.rule.options.version);
             if (roleAttr) {
-                if (report((0, non_existant_role_1.checkingNonExistantRole)({ attr: roleAttr }))) {
+                if (report((0, non_existent_role_1.checkingNonExistentRole)({ attr: roleAttr }))) {
                     return;
                 }
                 if (report((0, abstract_role_1.checkingAbstractRole)({ attr: roleAttr }))) {
                     return;
                 }
                 report((0, required_prop_1.checkingRequiredProp)({ el, role: computed.role, propSpecs }));
-                if (el.rule.option.disallowSetImplicitRole) {
+                if (el.rule.options.disallowSetImplicitRole) {
                     report((0, implicit_role_1.checkingImplicitRole)({ attr: roleAttr }));
                 }
-                if (el.rule.option.permittedAriaRoles) {
+                if (el.rule.options.permittedAriaRoles) {
                     report((0, permitted_roles_1.checkingPermittedRoles)({ attr: roleAttr }));
                 }
             }
             for (const attr of propAttrs) {
                 report((0, disallowed_prop_1.checkingDisallowedProp)({ attr, role: computed.role, propSpecs }));
-                if (el.rule.option.checkingDeprecatedProps) {
+                if (el.rule.options.checkingDeprecatedProps) {
                     report((0, deprecated_props_1.checkingDeprecatedProps)({ attr, role: computed.role, propSpecs }));
                 }
-                if (el.rule.option.disallowSetImplicitProps) {
+                if (el.rule.options.disallowSetImplicitProps) {
                     const attrSpecs = (0, ml_core_1.getAttrSpecs)(el, document.specs);
                     report((0, implicit_props_1.checkingImplicitProps)({ attr, propSpecs, attrSpecs }));
                 }
-                if (el.rule.option.checkingValue) {
-                    report((0, value_1.checkingValue)({ attr, role: computed.role, propSpecs }));
+                if (el.rule.options.checkingValue) {
+                    report((0, value_1.checkingValue)({ attr, role: computed.role, propSpecs, booleanish: document.booleanish }));
                 }
-                if (el.rule.option.disallowDefaultValue) {
+                if (el.rule.options.disallowDefaultValue) {
                     report((0, default_value_1.checkingDefaultValue)({ attr, propSpecs }));
                 }
                 if (!computed.role) {
                     report((0, no_global_prop_1.checkingNoGlobalProp)({ attr, propSpecs }));
                 }
             }
-            if (el.rule.option.checkingRequiredOwnedElements) {
-                report((0, checking_required_owned_elements_1.checkingRequiredOwnedElements)({ el, role: computed.role }));
+            if (el.rule.options.checkingRequiredOwnedElements) {
+                report((0, required_owned_elements_1.checkingRequiredOwnedElements)({ el, role: computed.role }));
+            }
+            if (el.rule.options.checkingPresentationalChildren) {
+                report((0, presentational_children_1.checkingPresentationalChildren)({ el }));
+            }
+            if (el.rule.options.checkingInteractionInHidden) {
+                report((0, interaction_in_hidden_1.checkingInteractionInHidden)({ el }));
             }
         });
     },

package/lib/wai-aria/types.d.ts

@@ -1,9 +1,11 @@
 import type { ARIAVersion } from '@markuplint/ml-spec';
-export declare type Options = {
+export type Options = {
     checkingValue: boolean;
     checkingDeprecatedProps: boolean;
     permittedAriaRoles: boolean;
     checkingRequiredOwnedElements: boolean;
+    checkingPresentationalChildren: boolean;
+    checkingInteractionInHidden: boolean;
     disallowSetImplicitRole: boolean;
     disallowSetImplicitProps: boolean;
     disallowDefaultValue: boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@markuplint/rules",
-	"version": "3.0.0-alpha.66+6cde1134",
-	"description": "Rules for markuplint",
+	"version": "3.0.0-dev.24+f55f5eff",
+	"description": "Built-in rules of markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
 	"license": "MIT",
@@ -16,17 +16,21 @@
 		"dev": "tsc --build --watch",
 		"clean": "tsc --build --clean"
 	},
+	"browser": {
+		"./lib/permitted-contents/debug.js": "./lib/permitted-contents/debug.browser.js"
+	},
 	"dependencies": {
-		"@markuplint/html-spec": "3.0.0-alpha.66+6cde1134",
-		"@markuplint/ml-core": "3.0.0-alpha.66+6cde1134",
-		"@markuplint/ml-spec": "3.0.0-alpha.82+6cde1134",
-		"@markuplint/types": "2.1.0",
+		"@markuplint/html-spec": "3.0.0-dev.24+f55f5eff",
+		"@markuplint/ml-core": "3.0.0-dev.24+f55f5eff",
+		"@markuplint/ml-spec": "3.0.0-dev.24+f55f5eff",
+		"@markuplint/types": "3.0.0-dev.24+f55f5eff",
+		"@ungap/structured-clone": "^1.0.1",
 		"debug": "^4.3.4",
 		"html-entities": "^2.3.3",
-		"tslib": "^2.3.1"
+		"tslib": "^2.4.1"
 	},
 	"devDependencies": {
 		"@types/debug": "^4.1.7"
 	},
-	"gitHead": "6cde113402758a8fdbd6a0fcf98e78efd2cdb778"
+	"gitHead": "f55f5eff289296feba26f20b0c085e0528c80ac4"
 }

package/schema.json

@@ -48,6 +48,9 @@
 				"invalid-attr": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/invalid-attr/schema.json"
 				},
+				"label-has-control": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/label-has-control/schema.json"
+				},
 				"landmark-roles": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/landmark-roles/schema.json"
 				},
@@ -57,6 +60,9 @@
 				"no-default-value": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/no-default-value/schema.json"
 				},
+				"no-empty-palpable-content": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/no-empty-palpable-content/schema.json"
+				},
 				"no-hard-code-id": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/no-hard-code-id/schema.json"
 				},