@markuplint/rules 4.6.1 → 4.8.0-alpha.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+# [4.8.0-alpha.0](https://github.com/markuplint/markuplint/compare/@markuplint/rules@4.7.0...@markuplint/rules@4.8.0-alpha.0) (2024-05-04)
+
+### Features
+
+- **rules:** add `no-ambiguous-navigable-target-names` rule ([742db4e](https://github.com/markuplint/markuplint/commit/742db4eb98b8f27e8a1f6a82d3b6541871e02a5c))
+- **rules:** add `table-row-column-alignment` rule ([4b071f8](https://github.com/markuplint/markuplint/commit/4b071f8d7dae0f1500e1a77046b289489eb5a598))
+- **rules:** apply `no-ambiguous-navigable-target-names` to build-in rules ([93d34f0](https://github.com/markuplint/markuplint/commit/93d34f0ead2624107a5b6f315af0c8bbd4f1e1ec))
+- **rules:** apply `table-row-column-alignment` to build-in rules ([85de609](https://github.com/markuplint/markuplint/commit/85de6098813cd7c3167099f9e7e6250ca8324539))

package/lib/index.d.ts

@@ -16,13 +16,7 @@ declare const rules: {
     readonly 'id-duplication': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
     readonly 'ineffective-attr': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
     readonly 'invalid-attr': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, {
-        allowAttrs?: Record<string, {
-            enum: [string, ...string[]];
-        } | {
-            pattern: string;
-        } | {
-            type: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
-        }> | (string | {
+        allowAttrs?: (string | {
             name: string;
             value: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType | ({
                 enum: [string, ...string[]];
@@ -31,14 +25,14 @@ declare const rules: {
             } | {
                 type: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
             });
-        })[] | undefined;
-        disallowAttrs?: Record<string, {
+        })[] | Record<string, {
             enum: [string, ...string[]];
         } | {
             pattern: string;
         } | {
             type: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
-        }> | (string | {
+        }> | undefined;
+        disallowAttrs?: (string | {
             name: string;
             value: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType | ({
                 enum: [string, ...string[]];
@@ -47,7 +41,13 @@ declare const rules: {
             } | {
                 type: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
             });
-        })[] | undefined;
+        })[] | Record<string, {
+            enum: [string, ...string[]];
+        } | {
+            pattern: string;
+        } | {
+            type: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
+        }> | undefined;
         ignoreAttrNamePrefix?: string | string[] | undefined;
         allowToAddPropertiesForPretender?: boolean | undefined;
         attrs?: Record<string, ({
@@ -66,6 +66,7 @@ declare const rules: {
         labelEachArea: boolean;
     }>>;
     readonly 'neighbor-popovers': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
+    readonly 'no-ambiguous-navigable-target-names': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
     readonly 'no-boolean-attr-value': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
     readonly 'no-consecutive-br': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
     readonly 'no-default-value': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
@@ -99,6 +100,7 @@ declare const rules: {
         ignoreHasMutableContents: boolean;
     }>>;
     readonly 'required-h1': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, import("./required-h1/index.js").Options>>;
+    readonly 'table-row-column-alignment': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
     readonly 'use-list': Readonly<import("@markuplint/ml-core").RuleSeed<readonly string[], {
         spaceNeededBullets?: string[] | undefined;
         noPrev?: boolean | undefined;

package/lib/index.js

@@ -16,6 +16,7 @@ import InvalidAttr from './invalid-attr/index.js';
 import LabelHasControl from './label-has-control/index.js';
 import LandmarkRoles from './landmark-roles/index.js';
 import NeighborPopovers from './neighbor-popovers/index.js';
+import NoAmbiguousNavigableTargetNames from './no-ambiguous-navigable-target-names/index.js';
 import NoBooleanAttrValue from './no-boolean-attr-value/index.js';
 import NoConsecutiveBr from './no-consecutive-br/index.js';
 import NoDefaultValue from './no-default-value/index.js';
@@ -32,6 +33,7 @@ import RequireDatetime from './require-datetime/index.js';
 import RequiredAttr from './required-attr/index.js';
 import RequiredElement from './required-element/index.js';
 import RequiredH1 from './required-h1/index.js';
+import TableRowColumnAlignment from './table-row-column-alignment/index.js';
 import UseList from './use-list/index.js';
 import WaiAria from './wai-aria/index.js';
 const rules = {
@@ -53,6 +55,7 @@ const rules = {
     'label-has-control': LabelHasControl,
     'landmark-roles': LandmarkRoles,
     'neighbor-popovers': NeighborPopovers,
+    'no-ambiguous-navigable-target-names': NoAmbiguousNavigableTargetNames,
     'no-boolean-attr-value': NoBooleanAttrValue,
     'no-consecutive-br': NoConsecutiveBr,
     'no-default-value': NoDefaultValue,
@@ -69,6 +72,7 @@ const rules = {
     'required-attr': RequiredAttr,
     'required-element': RequiredElement,
     'required-h1': RequiredH1,
+    'table-row-column-alignment': TableRowColumnAlignment,
     'use-list': UseList,
     'wai-aria': WaiAria,
 };

package/lib/no-ambiguous-navigable-target-names/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
+export default _default;

package/lib/no-ambiguous-navigable-target-names/index.js

@@ -0,0 +1,44 @@
+import { createRule, getAttrSpecs } from '@markuplint/ml-core';
+import { valueCheck } from '../attr-check.js';
+import meta from './meta.js';
+export default createRule({
+    meta: meta,
+    defaultSeverity: 'warning',
+    async verify({ document, report, t }) {
+        await document.walkOn('Attr', attr => {
+            if (!attr.valueNode) {
+                return;
+            }
+            const attrSpecs = getAttrSpecs(attr.ownerElement, document.specs);
+            if (!attrSpecs) {
+                return;
+            }
+            const attrSpec = attrSpecs.find(spec => spec.name === attr.name);
+            if (attrSpec?.type !== 'NavigableTargetNameOrKeyword' && attrSpec?.type !== 'NavigableTargetName') {
+                return;
+            }
+            const value = attr.value.trim();
+            if (value.startsWith('_')) {
+                // This is a keyword
+                return;
+            }
+            const valueWithUnderscore = `_${value}`;
+            const invalid = valueCheck(t, attr.name, valueWithUnderscore, 'NavigableTargetNameOrKeyword');
+            if (invalid !== false) {
+                return;
+            }
+            report({
+                scope: attr,
+                line: attr.valueNode.startLine,
+                col: attr.valueNode.startCol,
+                raw: attr.valueNode.raw,
+                message: 
+                //
+                t("don't use {0}", t('a {0}', t('ambiguous {0}', 'navigable target name'))) +
+                    (attrSpec.type === 'NavigableTargetNameOrKeyword'
+                        ? t('. ') + t('Did you mean "{0}"?', valueWithUnderscore)
+                        : ''),
+            });
+        });
+    },
+});

package/lib/no-ambiguous-navigable-target-names/meta.d.ts

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

package/lib/no-ambiguous-navigable-target-names/meta.js

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

package/lib/permitted-contents/choice.d.ts

@@ -1,4 +1,4 @@
 import type { ChildNode, Options, Result, Specs } from './types.js';
 import type { PermittedContentChoice } from '@markuplint/ml-spec';
 import type { ReadonlyDeep } from 'type-fest';
-export declare function choice(pattern: ReadonlyDeep<PermittedContentChoice>, elements: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;
+export declare function choice(pattern: ReadonlyDeep<PermittedContentChoice>, childNodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;

package/lib/permitted-contents/choice.js

@@ -4,9 +4,9 @@ import { Collection, modelLog } from './utils.js';
 const indexes = new WeakMap();
 export function choice(pattern, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-elements, specs, options, depth) {
+childNodes, specs, options, depth) {
     const choiceLog = cmLog.extend(`choice#${depth}`);
-    const collection = new Collection(elements);
+    const collection = new Collection(childNodes);
     const unmatchedResults = [];
     let i = 0;
     for (const some of pattern.choice) {

package/lib/permitted-contents/complex-branch.d.ts

@@ -5,10 +5,10 @@ import type { ReadonlyDeep } from 'type-fest';
  * Check content condition
  *
  * @param pattern
- * @param elements
+ * @param childNodes
  * @param specs
  * @param options
  * @param depth
  * @returns
  */
-export declare function complexBranch(pattern: ReadonlyDeep<PermittedContentPattern>, elements: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;
+export declare function complexBranch(pattern: ReadonlyDeep<PermittedContentPattern>, childNodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;

package/lib/permitted-contents/complex-branch.js

@@ -6,7 +6,7 @@ import { isChoice, isTransparent } from './utils.js';
  * Check content condition
  *
  * @param pattern
- * @param elements
+ * @param childNodes
  * @param specs
  * @param options
  * @param depth
@@ -14,12 +14,12 @@ import { isChoice, isTransparent } from './utils.js';
  */
 export function complexBranch(pattern, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-elements, specs, options, depth) {
+childNodes, specs, options, depth) {
     if (isChoice(pattern)) {
-        return choice(pattern, elements, specs, options, depth);
+        return choice(pattern, childNodes, specs, options, depth);
     }
     if (isTransparent(pattern)) {
-        return transparent(elements);
+        return transparent(childNodes);
     }
-    return countPattern(pattern, elements, specs, options, depth);
+    return countPattern(pattern, childNodes, specs, options, depth);
 }

package/lib/permitted-contents/count-pattern.d.ts

@@ -5,10 +5,10 @@ import type { ReadonlyDeep } from 'type-fest';
  * Check count
  *
  * @param pattern
- * @param elements
+ * @param childNodes
  * @param specs
  * @param options
  * @param depth
  * @returns
  */
-export declare function countPattern(pattern: ReadonlyDeep<PermittedContentOneOrMore> | ReadonlyDeep<PermittedContentOptional> | ReadonlyDeep<PermittedContentRequire> | ReadonlyDeep<PermittedContentZeroOrMore>, elements: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;
+export declare function countPattern(pattern: ReadonlyDeep<PermittedContentOneOrMore> | ReadonlyDeep<PermittedContentOptional> | ReadonlyDeep<PermittedContentRequire> | ReadonlyDeep<PermittedContentZeroOrMore>, childNodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;

package/lib/permitted-contents/count-pattern.js

@@ -6,7 +6,7 @@ const cLog = cmLog.extend('countCompereResult');
  * Check count
  *
  * @param pattern
- * @param elements
+ * @param childNodes
  * @param specs
  * @param options
  * @param depth
@@ -14,9 +14,9 @@ const cLog = cmLog.extend('countCompereResult');
  */
 export function countPattern(pattern, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-elements, specs, options, depth) {
+childNodes, specs, options, depth) {
     const ptLog = cmLog.extend(`countPattern#${depth}`);
-    const collection = new Collection(elements);
+    const collection = new Collection(childNodes);
     const { model, min, max, repeat, missingType } = normalizeModel(pattern);
     ptLog('Model:\n  RegEx: %s\n  Schema: %o', modelLog(model, repeat), pattern);
     let prevResult = null;

package/lib/permitted-contents/index.js

@@ -7,12 +7,10 @@ export default createRule({
     defaultValue: [],
     defaultOptions: {
         ignoreHasMutableChildren: true,
+        evaluateConditionalChildNodes: false,
     },
     async verify({ document, report, t }) {
         await document.walkOn('Element', el => {
-            if (el.rule.options.ignoreHasMutableChildren && el.hasMutableChildren()) {
-                return;
-            }
             const results = contentModel(el, el.rule.value, el.rule.options);
             for (const { type, scope, query, hint } of results) {
                 let message = '';
@@ -28,6 +26,10 @@ export default createRule({
                         break;
                     }
                     case 'MISSING_NODE_ONE_OR_MORE': {
+                        if (scope.rule.options.ignoreHasMutableChildren &&
+                            (!scope.is(scope.ELEMENT_NODE) || scope.hasMutableChildren())) {
+                            break;
+                        }
                         message =
                             message ||
                                 t('Require {0}', t('one or more elements')) + t('. ') + '(' + t('Need "{0*}"', query) + ')';
@@ -38,6 +40,10 @@ export default createRule({
                         break;
                     }
                     case 'MISSING_NODE_REQUIRED': {
+                        if (scope.rule.options.ignoreHasMutableChildren &&
+                            (!scope.is(scope.ELEMENT_NODE) || scope.hasMutableChildren())) {
+                            break;
+                        }
                         message =
                             message ||
                                 t('Require {0}', t('an {0}', 'element')) + t('. ') + '(' + t('Need "{0*}"', query) + ')';

package/lib/permitted-contents/matches-selector.d.ts

@@ -1,3 +1,3 @@
 import type { ChildNode, Result, Specs } from './types.js';
 export type SelectorResult = Result<'UNMATCHED_SELECTOR_BUT_MAY_EMPTY' | 'MISSING_NODE' | 'UNMATCHED_SELECTORS'>;
-export declare function matchesSelector(query: string, node: ChildNode | undefined, specs: Specs, depth: number): SelectorResult;
+export declare function matchesSelector(query: string, childNode: ChildNode | undefined, specs: Specs, depth: number): SelectorResult;

package/lib/permitted-contents/matches-selector.js

@@ -3,10 +3,10 @@ import { cmLog } from './debug.js';
 import { cleanObject, matches } from './utils.js';
 export function matchesSelector(query, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, specs, depth) {
+childNode, specs, depth) {
     const nodeLog = cmLog.extend(`node#${depth}`);
     const { selector, hasText, hasCustom } = optCondition(query, specs);
-    if (node == null) {
+    if (childNode == null) {
         if (hasText) {
             nodeLog('<#text>.matches(%s) => ""', query);
             return {
@@ -27,23 +27,23 @@ node, specs, depth) {
             hint: {},
         };
     }
-    if (node.is(node.TEXT_NODE)) {
+    if (childNode.is(childNode.TEXT_NODE)) {
         if (hasText) {
-            nodeLog('<#text>.matches(%s) => "%s"', query, node.raw.trim());
+            nodeLog('<#text>.matches(%s) => "%s"', query, childNode.raw.trim());
             return {
                 type: 'MATCHED',
-                matched: [node],
+                matched: [childNode],
                 unmatched: [],
                 zeroMatch: true,
                 query,
                 hint: {},
             };
         }
-        if (node.isWhitespace()) {
+        if (childNode.isWhitespace()) {
             nodeLog('<#text>.matches(%s) => WHITESPACE', query);
             return {
                 type: 'MATCHED',
-                matched: [node],
+                matched: [childNode],
                 unmatched: [],
                 zeroMatch: true,
                 query,
@@ -54,41 +54,41 @@ node, specs, depth) {
         return {
             type: 'UNEXPECTED_EXTRA_NODE',
             matched: [],
-            unmatched: [node],
+            unmatched: [childNode],
             zeroMatch: false,
             query,
             hint: {},
         };
     }
-    if (node.is(node.MARKUPLINT_PREPROCESSOR_BLOCK)) {
-        nodeLog('%s.matches(%s) => PBlock', node.raw, query);
+    if (childNode.is(childNode.MARKUPLINT_PREPROCESSOR_BLOCK)) {
+        nodeLog('%s.matches(%s) => PBlock', childNode.raw, query);
         return {
             type: 'MATCHED',
-            matched: [node],
+            matched: [childNode],
             unmatched: [],
             zeroMatch: !!hasText,
             query,
             hint: {},
         };
     }
-    if (node.is(node.ELEMENT_NODE)) {
-        if (node.elementType !== 'html' && hasCustom) {
-            nodeLog('%s.matches(%s) => CustomElement', node.raw, query);
+    if (childNode.is(childNode.ELEMENT_NODE)) {
+        if (childNode.elementType !== 'html' && hasCustom) {
+            nodeLog('%s.matches(%s) => CustomElement', childNode.raw, query);
             return {
                 type: 'MATCHED',
-                matched: [node],
+                matched: [childNode],
                 unmatched: [],
                 zeroMatch: !!hasText,
                 query,
                 hint: {},
             };
         }
-        const result = matches(selector, node, specs);
-        nodeLog('%s.matches(%s) => %s', node.raw, query, result.matched);
+        const result = matches(selector, childNode, specs);
+        nodeLog('%s.matches(%s) => %s', childNode.raw, query, result.matched);
         if (result.matched) {
             return {
                 type: 'MATCHED',
-                matched: [node],
+                matched: [childNode],
                 unmatched: [],
                 zeroMatch: !!hasText,
                 query,
@@ -99,7 +99,7 @@ node, specs, depth) {
             return {
                 type: 'UNMATCHED_SELECTOR_BUT_MAY_EMPTY',
                 matched: [],
-                unmatched: [node],
+                unmatched: [childNode],
                 zeroMatch: true,
                 query,
                 hint: cleanObject({
@@ -110,7 +110,7 @@ node, specs, depth) {
         return {
             type: 'UNMATCHED_SELECTORS',
             matched: [],
-            unmatched: [node],
+            unmatched: [childNode],
             zeroMatch: false,
             query,
             hint: cleanObject({
@@ -120,7 +120,7 @@ node, specs, depth) {
     }
     return {
         type: 'MATCHED',
-        matched: [node],
+        matched: [childNode],
         unmatched: [],
         zeroMatch: !!hasText,
         query,

package/lib/permitted-contents/order.d.ts

@@ -5,10 +5,10 @@ import type { ReadonlyDeep } from 'type-fest';
  * Check ordered array
  *
  * @param contents
- * @param nodes
+ * @param childNodes
  * @param specs
  * @param options
  * @param depth
  * @returns
  */
-export declare function order(contents: ReadonlyDeep<PermittedContentPattern[]>, nodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;
+export declare function order(contents: ReadonlyDeep<PermittedContentPattern[]>, childNodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;

package/lib/permitted-contents/order.js

@@ -6,7 +6,7 @@ import { Collection, mergeHints, modelLog } from './utils.js';
  * Check ordered array
  *
  * @param contents
- * @param nodes
+ * @param childNodes
  * @param specs
  * @param options
  * @param depth
@@ -14,11 +14,11 @@ import { Collection, mergeHints, modelLog } from './utils.js';
  */
 export function order(contents, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodes, specs, options, depth) {
+childNodes, specs, options, depth) {
     const orderLog = cmLog.extend(`order#${depth}`);
     const btLog = cmLog.extend(`backtrack#${depth}`);
     const patterns = deepCopy(contents);
-    const collection = new Collection(nodes);
+    const collection = new Collection(childNodes);
     orderLog('Model:\n  RegEx: %s\n  Schema: %o', modelLog(patterns, ''), patterns);
     orderLog('Starts: %s', collection);
     let result = undefined;

package/lib/permitted-contents/recursive-branch.d.ts

@@ -2,4 +2,4 @@ import type { SelectorResult } from './matches-selector.js';
 import type { ChildNode, Options, Specs } from './types.js';
 import type { PermittedContentPattern, Model } from '@markuplint/ml-spec';
 import type { ReadonlyDeep } from 'type-fest';
-export declare function recursiveBranch(model: ReadonlyDeep<Model | PermittedContentPattern[]>, nodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): SelectorResult;
+export declare function recursiveBranch(model: ReadonlyDeep<Model | PermittedContentPattern[]>, childNodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): SelectorResult;

package/lib/permitted-contents/recursive-branch.js

@@ -3,14 +3,14 @@ import { order } from './order.js';
 import { Collection, isModel } from './utils.js';
 export function recursiveBranch(model, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodes, specs, options, depth) {
+childNodes, specs, options, depth) {
     if (!isModel(model)) {
-        return order(model, nodes, specs, options, depth + 1);
+        return order(model, childNodes, specs, options, depth + 1);
     }
     if (typeof model === 'string') {
-        return matchesSelector(model, nodes[0], specs, depth);
+        return matchesSelector(model, childNodes[0], specs, depth);
     }
-    const collection = new Collection(nodes);
+    const collection = new Collection(childNodes);
     let lastUnmatched = null;
     for (const query of model) {
         const result = matchesSelector(query, collection.unmatched[0], specs, depth);

package/lib/permitted-contents/represent-transparent-nodes.d.ts

@@ -1,6 +1,8 @@
 import type { ChildNode, Options, Result, Specs } from './types.js';
 export declare const transparentMode: Map<ChildNode, true>;
-export declare function representTransparentNodes(nodes: ChildNode[], specs: Specs, options: Options): {
+type TransparentNode = {
     nodes: ChildNode[];
     errors: Result[];
 };
+export declare function representTransparentNodes(childNodes: readonly ChildNode[], specs: Specs, options: Options): TransparentNode[];
+export {};

package/lib/permitted-contents/represent-transparent-nodes.js

@@ -1,73 +1,94 @@
 import { getContentModel } from '@markuplint/ml-spec';
+import { branchesToPatterns } from '@markuplint/shared';
 import { order } from './order.js';
-import { Collection, getChildNodesWithoutWhitespaces, isTransparent, matches } from './utils.js';
+import { Collection, isTransparent, matches } from './utils.js';
 export const transparentMode = new Map();
 export function representTransparentNodes(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodes, specs, options) {
-    const result = [];
-    const errors = [];
-    const parent = nodes[0]?.parentElement;
-    if (parent) {
-        const { errors: parentErrors } = representTransparentNodes([parent], specs, options);
-        errors.push(...parentErrors);
-    }
-    for (const node of nodes) {
-        if (!node.is(node.ELEMENT_NODE)) {
-            result.push(node);
+childNodes, specs, options) {
+    const parentElement = childNodes[0]?.parentElement;
+    const parentResults = parentElement
+        ? representTransparentNodes([parentElement], specs, options)
+        : [{ nodes: [], errors: [] }];
+    const branches = [];
+    for (const childNode of childNodes) {
+        if (!childNode.is(childNode.ELEMENT_NODE)) {
+            branches.push(childNode);
             continue;
         }
-        const models = getContentModel(node, specs.specs);
+        const models = getContentModel(childNode, specs.specs);
         if (models == null || typeof models === 'boolean') {
-            result.push(node);
+            branches.push(childNode);
             continue;
         }
         const noTransparentModels = models.filter(m => !isTransparent(m));
         if (noTransparentModels.length === models.length) {
-            result.push(node);
+            branches.push(childNode);
             continue;
         }
-        const collection = new Collection(getChildNodesWithoutWhitespaces(node));
-        let unmatched;
-        if (noTransparentModels.length > 0) {
-            const result = order(noTransparentModels, collection.unmatched, specs, options, Number.POSITIVE_INFINITY);
-            unmatched = result.unmatched;
-        }
-        else {
-            unmatched = collection.unmatched;
-        }
-        const transparent = models.find(m => isTransparent(m));
-        if (!transparent || !isTransparent(transparent)) {
-            throw new Error('Unreachable code');
-        }
-        for (const _child of unmatched) {
-            const child = _child;
-            if (transparentMode.has(child)) {
-                continue;
+        const childNodesPatterns = options.evaluateConditionalChildNodes
+            ? childNode.conditionalChildNodes().map(childNodes => [...childNodes])
+            : [[...childNode.childNodes].filter(child => !(child.is(child.TEXT_NODE) && child.isWhitespace()))];
+        const representPattern = [];
+        for (const childNodes of childNodesPatterns) {
+            const collection = new Collection([...childNodes]);
+            let unmatched;
+            if (noTransparentModels.length > 0) {
+                const result = order(noTransparentModels, collection.unmatched, specs, options, Number.POSITIVE_INFINITY);
+                unmatched = result.unmatched;
             }
-            transparentMode.set(child, true);
-            if (child.is(child.ELEMENT_NODE)) {
-                const transparentCondMatched = matches(transparent.transparent, child, specs);
-                if (!transparentCondMatched.matched) {
-                    errors.push({
-                        type: 'TRANSPARENT_MODEL_DISALLOWS',
-                        matched: [],
-                        unmatched: [node],
-                        zeroMatch: false,
-                        query: transparent.transparent,
-                        hint: {
-                            not: transparentCondMatched.not,
-                            transparent: node,
-                        },
-                    });
+            else {
+                unmatched = collection.unmatched;
+            }
+            const transparent = models.find(m => isTransparent(m));
+            if (!transparent || !isTransparent(transparent)) {
+                throw new Error('Unreachable code');
+            }
+            for (const _child of unmatched) {
+                const child = _child;
+                if (transparentMode.has(child)) {
                     continue;
                 }
+                transparentMode.set(child, true);
+                if (child.is(child.ELEMENT_NODE)) {
+                    const transparentCondMatched = matches(transparent.transparent, child, specs);
+                    if (!transparentCondMatched.matched) {
+                        representPattern.push({
+                            type: 'TRANSPARENT_MODEL_DISALLOWS',
+                            matched: [],
+                            unmatched: [childNode],
+                            zeroMatch: false,
+                            query: transparent.transparent,
+                            hint: {
+                                not: transparentCondMatched.not,
+                                transparent: childNode,
+                            },
+                        });
+                        continue;
+                    }
+                }
+                representPattern.push(child);
             }
-            result.push(child);
         }
+        branches.push(representPattern);
     }
-    return {
-        nodes: result,
-        errors,
-    };
+    const patterns = branchesToPatterns(branches);
+    const result = parentResults.flatMap(parentResult => {
+        const patternResults = patterns.map(pattern => {
+            const nodes = pattern.filter((node) => 'nodeName' in node);
+            const errors = pattern.filter((node) => 'type' in node);
+            return {
+                nodes,
+                errors: [...parentResult.errors, ...errors],
+            };
+        });
+        if (patternResults.length === 0) {
+            return {
+                nodes: [],
+                errors: parentResult.errors,
+            };
+        }
+        return patternResults;
+    });
+    return result;
 }

package/lib/permitted-contents/start.js

@@ -1,6 +1,5 @@
 import { order } from './order.js';
 import { representTransparentNodes } from './represent-transparent-nodes.js';
-import { getChildNodesWithoutWhitespaces } from './utils.js';
 /**
  * Check start
  *
@@ -13,53 +12,60 @@ import { getChildNodesWithoutWhitespaces } from './utils.js';
 export function start(contents, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el, specs, options) {
-    if (contents === false) {
-        if (el.childNodes.length > 0) {
+    const childNodesPatterns = options.evaluateConditionalChildNodes
+        ? el.conditionalChildNodes().map(childNodes => [...childNodes])
+        : [[...el.childNodes].filter(child => !(child.is(child.TEXT_NODE) && child.isWhitespace()))];
+    return childNodesPatterns.flatMap(childNodes => {
+        if (contents === false) {
+            if (childNodes.length > 0) {
+                return [
+                    {
+                        type: 'NOTHING',
+                        scope: el,
+                        query: ':not(*)',
+                        hint: {},
+                    },
+                ];
+            }
             return [
                 {
-                    type: 'NOTHING',
+                    type: 'MATCHED',
                     scope: el,
-                    query: ':not(*)',
+                    query: '*',
                     hint: {},
                 },
             ];
         }
-        return [
-            {
-                type: 'MATCHED',
-                scope: el,
-                query: '*',
-                hint: {},
-            },
-        ];
-    }
-    if (contents === true) {
-        // Allows all elements
-        return [
-            {
-                type: 'MATCHED',
-                scope: el,
-                query: '*',
-                hint: {},
-            },
-        ];
-    }
-    const { nodes, errors } = representTransparentNodes(getChildNodesWithoutWhitespaces(el), specs, options);
-    const result = order(contents, nodes, specs, options, 0);
-    return [
-        {
-            type: result.type,
-            scope: result.type === 'MISSING_NODE_REQUIRED' || result.type === 'MISSING_NODE_ONE_OR_MORE'
-                ? el
-                : result.unmatched[0] ?? el,
-            query: result.query,
-            hint: result.hint,
-        },
-        ...errors.map(error => ({
-            type: error.type,
-            scope: error.unmatched[0] ?? el,
-            query: error.query,
-            hint: error.hint,
-        })),
-    ];
+        if (contents === true) {
+            // Allows all elements
+            return [
+                {
+                    type: 'MATCHED',
+                    scope: el,
+                    query: '*',
+                    hint: {},
+                },
+            ];
+        }
+        const patterns = representTransparentNodes(childNodes, specs, options);
+        return patterns.flatMap(({ nodes, errors }) => {
+            const result = order(contents, nodes, specs, options, 0);
+            return [
+                {
+                    type: result.type,
+                    scope: result.type === 'MISSING_NODE_REQUIRED' || result.type === 'MISSING_NODE_ONE_OR_MORE'
+                        ? el
+                        : result.unmatched[0] ?? el,
+                    query: result.query,
+                    hint: result.hint,
+                },
+                ...errors.map(error => ({
+                    type: error.type,
+                    scope: error.unmatched[0] ?? el,
+                    query: error.query,
+                    hint: error.hint,
+                })),
+            ];
+        });
+    });
 }

package/lib/permitted-contents/transparent.d.ts

@@ -1,2 +1,2 @@
 import type { ChildNode, Result } from './types.js';
-export declare function transparent(nodes: readonly ChildNode[]): Result;
+export declare function transparent(childNodes: readonly ChildNode[]): Result;

package/lib/permitted-contents/transparent.js

@@ -2,14 +2,14 @@ import { cmLog } from './debug.js';
 const transparentLog = cmLog.extend('transparent');
 export function transparent(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodes) {
-    if (nodes.length === 0 || nodes[0]?.parentElement?.parentElement) {
+childNodes) {
+    if (childNodes.length === 0 || childNodes[0]?.parentElement?.parentElement) {
         transparentLog('Skipped');
         return {
-            type: nodes.length === 0 ? 'MATCHED_ZERO' : 'MATCHED',
-            matched: [...nodes],
+            type: childNodes.length === 0 ? 'MATCHED_ZERO' : 'MATCHED',
+            matched: [...childNodes],
             unmatched: [],
-            zeroMatch: nodes.length === 0,
+            zeroMatch: childNodes.length === 0,
             query: 'transparent',
             hint: {},
         };
@@ -17,7 +17,7 @@ nodes) {
     transparentLog('Transparent model element is component root');
     return {
         type: 'MATCHED',
-        matched: [...nodes],
+        matched: [...childNodes],
         unmatched: [],
         zeroMatch: false,
         query: 'transparent',

package/lib/permitted-contents/types.d.ts

@@ -49,4 +49,8 @@ export type TagRule = {
 } & ReadonlyDeep<ContentModel>;
 export type Options = {
     readonly ignoreHasMutableChildren: boolean;
+    /**
+     * @experimental
+     */
+    readonly evaluateConditionalChildNodes: boolean;
 };

package/lib/permitted-contents/utils.d.ts

@@ -1,7 +1,6 @@
-import type { ChildNode, Element, Hints, MissingNodeReason, RepeatSign, Specs } from './types.js';
+import type { ChildNode, Hints, MissingNodeReason, RepeatSign, Specs } from './types.js';
 import type { PermittedContentPattern, PermittedContentChoice, PermittedContentOneOrMore, PermittedContentOptional, PermittedContentRequire, PermittedContentTransparent, PermittedContentZeroOrMore, Model } from '@markuplint/ml-spec';
 import type { ReadonlyDeep } from 'type-fest';
-export declare function getChildNodesWithoutWhitespaces(el: Element): ChildNode[];
 export declare function isModel(model: ReadonlyDeep<Model | PermittedContentPattern[]>): model is ReadonlyDeep<Model>;
 export declare function matches(selector: string, node: ChildNode, specs: Specs): {
     matched: boolean;
@@ -30,7 +29,7 @@ export declare function mergeHints(a: Readonly<Hints>, b: Readonly<Hints>): Part
     }> | undefined;
     max?: number | undefined;
     not?: ChildNode | undefined;
-    transparent?: Element | undefined;
+    transparent?: import("./types.js").Element | undefined;
 }>;
 export declare function cleanObject<T extends Object>(object: T): Partial<T>;
 export declare class Collection {

package/lib/permitted-contents/utils.js

@@ -13,20 +13,6 @@ var _Collection_locked, _Collection_matched, _Collection_nodes, _Collection_orig
 import { createSelector } from '@markuplint/selector';
 import { bgGreen, green, bgRed, bgBlue, blue, bgMagenta, cyan } from './debug.js';
 import { transparentMode } from './represent-transparent-nodes.js';
-const getChildNodesWithoutWhitespacesCaches = new Map();
-export function getChildNodesWithoutWhitespaces(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-el) {
-    let nodes = getChildNodesWithoutWhitespacesCaches.get(el);
-    if (nodes) {
-        return nodes;
-    }
-    nodes = [...el.childNodes].filter(node => {
-        return !(node.is(node.TEXT_NODE) && node.isWhitespace());
-    });
-    getChildNodesWithoutWhitespacesCaches.set(el, nodes);
-    return nodes;
-}
 export function isModel(model) {
     if (typeof model === 'string') {
         return true;

package/lib/table-row-column-alignment/find-children.d.ts

@@ -0,0 +1,2 @@
+import type { Element } from '@markuplint/ml-core';
+export declare function findChildren(el: Element<boolean>, selector: string): Element<boolean, undefined>[];

package/lib/table-row-column-alignment/find-children.js

@@ -0,0 +1,13 @@
+const findCache = {};
+export function findChildren(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el, selector) {
+    const key = `${el.uuid}:${selector}`;
+    const cached = findCache[key];
+    if (cached) {
+        return cached;
+    }
+    const children = [...el.children].filter(child => child.matches(selector));
+    findCache[key] = children;
+    return children;
+}

package/lib/table-row-column-alignment/grid.d.ts

@@ -0,0 +1,22 @@
+import type { CellType } from './types.js';
+import type { Element } from '@markuplint/ml-core';
+export declare class Grid {
+    #private;
+    readonly tbodyGrid: ReadonlyArray<ReadonlyArray<CellType>>;
+    readonly tfootGrid: ReadonlyArray<ReadonlyArray<CellType>>;
+    readonly theadGrid: ReadonlyArray<ReadonlyArray<CellType>>;
+    constructor(table: Element<boolean>);
+    getAllRowElements(): Element<boolean, undefined>[];
+    getAllRows(): (readonly CellType[])[];
+    getBaseColLength(): number;
+    getSections(): {
+        section: readonly (readonly CellType[])[];
+        elements: readonly Element<boolean, undefined>[];
+    }[];
+    hasOverlapped(): boolean;
+    log(): void;
+}
+export declare function getOverflowRowSpan(rows: ReadonlyArray<ReadonlyArray<CellType>>, rowElements: ReadonlyArray<Element<boolean>>): {
+    rowSpan: import("@markuplint/ml-core").Attr<boolean, undefined>;
+} | null;
+export declare function getIndexes(row: readonly CellType[]): (number | null)[];

package/lib/table-row-column-alignment/grid.js

@@ -0,0 +1,186 @@
+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 _Grid_tbodyRowElements, _Grid_tfootRowElements, _Grid_theadRowElements;
+import { findChildren } from './find-children.js';
+export class Grid {
+    constructor(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    table) {
+        _Grid_tbodyRowElements.set(this, void 0);
+        _Grid_tfootRowElements.set(this, void 0);
+        _Grid_theadRowElements.set(this, void 0);
+        const thead = findChildren(table, 'thead')[0];
+        const tbody = findChildren(table, 'tbody')[0];
+        const tfoot = findChildren(table, 'tfoot')[0];
+        __classPrivateFieldSet(this, _Grid_theadRowElements, thead ? findChildren(thead, 'tr') : [], "f");
+        __classPrivateFieldSet(this, _Grid_tbodyRowElements, tbody ? findChildren(tbody, 'tr') : [], "f");
+        __classPrivateFieldSet(this, _Grid_tfootRowElements, tfoot ? findChildren(tfoot, 'tr') : [], "f");
+        this.theadGrid = createGrid(__classPrivateFieldGet(this, _Grid_theadRowElements, "f"));
+        this.tbodyGrid = createGrid(__classPrivateFieldGet(this, _Grid_tbodyRowElements, "f"));
+        this.tfootGrid = createGrid(__classPrivateFieldGet(this, _Grid_tfootRowElements, "f"));
+    }
+    getAllRowElements() {
+        return [...__classPrivateFieldGet(this, _Grid_theadRowElements, "f"), ...__classPrivateFieldGet(this, _Grid_tbodyRowElements, "f"), ...__classPrivateFieldGet(this, _Grid_tfootRowElements, "f")];
+    }
+    getAllRows() {
+        return [
+            ...this.theadGrid.filter(hasElementFilter),
+            ...this.tbodyGrid.filter(hasElementFilter),
+            ...this.tfootGrid.filter(hasElementFilter),
+        ];
+    }
+    getBaseColLength() {
+        if (this.theadGrid.length > 0) {
+            return getBaseColLength(this.theadGrid);
+        }
+        if (this.tfootGrid.length > 0) {
+            return getBaseColLength(this.tfootGrid);
+        }
+        return getBaseColLength(this.tbodyGrid);
+    }
+    getSections() {
+        return [
+            {
+                section: this.theadGrid,
+                elements: __classPrivateFieldGet(this, _Grid_theadRowElements, "f"),
+            },
+            {
+                section: this.tbodyGrid,
+                elements: __classPrivateFieldGet(this, _Grid_tbodyRowElements, "f"),
+            },
+            {
+                section: this.tfootGrid,
+                elements: __classPrivateFieldGet(this, _Grid_tfootRowElements, "f"),
+            },
+        ];
+    }
+    hasOverlapped() {
+        return (this.tbodyGrid.some(row => row.includes('x')) ||
+            this.tfootGrid.some(row => row.includes('x')) ||
+            this.theadGrid.some(row => row.includes('x')));
+    }
+    log() {
+        // eslint-disable-next-line no-console
+        console.table(this.theadGrid);
+        // eslint-disable-next-line no-console
+        console.table(this.tbodyGrid);
+        // eslint-disable-next-line no-console
+        console.table(this.tfootGrid);
+    }
+}
+_Grid_tbodyRowElements = new WeakMap(), _Grid_tfootRowElements = new WeakMap(), _Grid_theadRowElements = new WeakMap();
+export function getOverflowRowSpan(rows, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+rowElements) {
+    for (const [rowNum] of rows.entries()) {
+        const rowEl = rowElements[rowNum];
+        if (!rowEl) {
+            const prevRow = rows[rowNum - 1];
+            const prevRowEl = rowElements[rowNum - 1];
+            if (!prevRow || !prevRowEl) {
+                continue;
+            }
+            const spanStart = prevRow.indexOf('◎');
+            if (spanStart === -1) {
+                continue;
+            }
+            const indexes = getIndexes(prevRow);
+            const index = indexes[spanStart];
+            if (index == null) {
+                continue;
+            }
+            const cells = findChildren(prevRowEl, 'th, td');
+            const spanStartCell = cells[index];
+            if (!spanStartCell) {
+                continue;
+            }
+            const rowSpan = spanStartCell.getAttributeNode('rowspan');
+            if (!rowSpan) {
+                continue;
+            }
+            return {
+                rowSpan,
+            };
+        }
+    }
+    return null;
+}
+export function getIndexes(row) {
+    let indexCounter = 0;
+    return row.map(col => (col === '●' || col === '◎' ? indexCounter++ : null));
+}
+function getBaseColLength(grid) {
+    let baseColLength;
+    if (grid.length >= 3) {
+        const totalCols = grid.reduce((acc, row) => {
+            return acc + row.length;
+        }, 0);
+        const average = Math.round(totalCols / grid.length);
+        baseColLength = grid
+            // eslint-disable-next-line unicorn/no-array-reduce
+            .reduce((closest, row) => {
+            return Math.abs(row.length - average) < Math.abs(closest - average) ? row.length : closest;
+        }, grid[0]?.length ?? 0);
+    }
+    else {
+        baseColLength = grid[0]?.length ?? 0;
+    }
+    return baseColLength;
+}
+function createGrid(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+rows) {
+    const rowSpans = new Set();
+    const matrix = [];
+    for (const [rowNum, row] of rows.entries()) {
+        const cols = findChildren(row, 'th, td');
+        let colNum = 0;
+        matrix[rowNum] = matrix[rowNum] ?? [];
+        for (const col of cols) {
+            const colSpan = Number.parseInt(col.getAttribute('colspan') ?? '1');
+            const rowSpan = Number.parseInt(col.getAttribute('rowspan') ?? '1');
+            for (let i = 0; i < colSpan; i++) {
+                const key = `${rowNum}:${colNum}`;
+                let spanStart = false;
+                if (colSpan > 1 && i === 0) {
+                    spanStart = true;
+                }
+                if (rowSpan > 1) {
+                    if (i === 0) {
+                        spanStart = true;
+                    }
+                    for (let i = 1; i <= rowSpan - 1; i++) {
+                        matrix[rowNum + i] = matrix[rowNum + i] ?? [];
+                        matrix[rowNum + i][colNum] = '↓';
+                        rowSpans.add(`${rowNum + i}:${colNum}`);
+                    }
+                }
+                const addCol = rowSpans.has(key) ? 1 : 0;
+                if (matrix[rowNum]?.[colNum] === '↓' && !spanStart && colSpan > 1) {
+                    // Overlap
+                    matrix[rowNum][colNum] = 'x';
+                }
+                else {
+                    matrix[rowNum][colNum] = spanStart ? '◎' : addCol > 0 ? '↓' : colSpan > 1 ? '→' : '●';
+                }
+                if (addCol === 1) {
+                    matrix[rowNum].push('●');
+                }
+                colNum += 1;
+            }
+        }
+    }
+    return matrix;
+}
+function hasElementFilter(row) {
+    return row.some(cell => cell === '●' || cell === '◎');
+}

package/lib/table-row-column-alignment/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
+export default _default;

package/lib/table-row-column-alignment/index.js

@@ -0,0 +1,73 @@
+import { createRule } from '@markuplint/ml-core';
+import { findChildren } from './find-children.js';
+import { Grid, getIndexes, getOverflowRowSpan } from './grid.js';
+import meta from './meta.js';
+export default createRule({
+    meta,
+    defaultSeverity: 'warning',
+    verify({ document, report, t }) {
+        const tables = document.querySelectorAll('table');
+        for (const table of tables) {
+            const grid = new Grid(table);
+            const baseColLength = grid.getBaseColLength();
+            // grid.log();
+            if (grid.hasOverlapped()) {
+                report({
+                    scope: table,
+                    message: t(
+                    //
+                    '{0} are causing {1}', t(['rowspan', 'colspan'], true), 'cell overlap'),
+                });
+                break;
+            }
+            for (const { section, elements } of grid.getSections()) {
+                const overflow = getOverflowRowSpan(section, elements);
+                if (overflow) {
+                    report({
+                        scope: overflow.rowSpan,
+                        message: t('Exceeds the number of available {0}', 'rows'),
+                    });
+                }
+            }
+            const rows = grid.getAllRows();
+            const rowElements = grid.getAllRowElements();
+            for (const [rowNum, row] of rows.entries()) {
+                const colLength = row.length;
+                const rowEl = rowElements[rowNum];
+                if (!rowEl) {
+                    continue;
+                }
+                const indexes = getIndexes(row);
+                if (colLength > baseColLength) {
+                    const index = indexes.slice(baseColLength)[0];
+                    const cells = findChildren(rowEl, 'th, td');
+                    const unexpected = typeof index === 'number' ? cells[index] : null;
+                    if (!unexpected) {
+                        const spanStart = cells.findLast(cell => Number.parseInt(cell.getAttribute('colspan') ?? '1') > 1);
+                        const colSpan = spanStart?.getAttributeNode('colspan');
+                        if (!colSpan) {
+                            continue;
+                        }
+                        report({
+                            scope: colSpan,
+                            message: t('Exceeds the number of available {0}', 'columns'),
+                        });
+                        continue;
+                    }
+                    const diff = colLength - baseColLength;
+                    report({
+                        scope: unexpected,
+                        message: t('{0} extra {1} in {2}', t(`${diff}`), t(diff === 1 ? 'column' : 'columns'), t('a {0}', t('row'))),
+                    });
+                }
+                if (colLength < baseColLength) {
+                    const diff = baseColLength - colLength;
+                    report({
+                        scope: rowEl,
+                        message: t('{0} missing {1} in {2}', t(`${diff}`), t(diff === 1 ? 'column' : 'columns'), t('a {0}', t('row'))),
+                    });
+                }
+            }
+        }
+    },
+});

package/lib/table-row-column-alignment/meta.d.ts

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

package/lib/table-row-column-alignment/meta.js

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

package/lib/table-row-column-alignment/types.d.ts

@@ -0,0 +1,2 @@
+export type Key = `${number}:${number}`;
+export type CellType = '●' | '◎' | '↓' | '→' | 'x';

package/lib/table-row-column-alignment/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/rules",
-	"version": "4.6.1",
+	"version": "4.8.0-alpha.0",
 	"description": "Built-in rules of markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -25,18 +25,18 @@
 		"./lib/permitted-contents/debug.js": "./lib/permitted-contents/debug.browser.js"
 	},
 	"dependencies": {
-		"@markuplint/html-spec": "4.6.1",
-		"@markuplint/ml-core": "4.6.1",
-		"@markuplint/ml-spec": "4.4.1",
-		"@markuplint/selector": "4.5.1",
-		"@markuplint/shared": "4.2.0",
-		"@markuplint/types": "4.3.0",
+		"@markuplint/html-spec": "4.7.1-alpha.0",
+		"@markuplint/ml-core": "4.7.1-alpha.0",
+		"@markuplint/ml-spec": "4.5.1-alpha.0",
+		"@markuplint/selector": "4.6.1-alpha.0",
+		"@markuplint/shared": "4.3.1-alpha.0",
+		"@markuplint/types": "4.4.1-alpha.0",
 		"@types/debug": "4.1.12",
 		"@ungap/structured-clone": "1.2.0",
 		"ansi-colors": "4.1.3",
 		"chrono-node": "2.7.5",
 		"debug": "4.3.4",
-		"type-fest": "4.15.0"
+		"type-fest": "4.18.1"
 	},
-	"gitHead": "b029c86a6b3a9ea8189d2e5535e3023aaea753fd"
+	"gitHead": "d091e2199e3dc6757c2c8edbf01fd19e8b072015"
 }

package/schema.json

@@ -60,6 +60,9 @@
 				"neighbor-popovers": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/neighbor-popovers/schema.json"
 				},
+				"no-ambiguous-navigable-target-names": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/no-ambiguous-navigable-target-names/schema.json"
+				},
 				"no-boolean-attr-value": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/no-boolean-attr-value/schema.json"
 				},
@@ -108,6 +111,9 @@
 				"required-h1": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/required-h1/schema.json"
 				},
+				"table-row-column-alignment": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/table-row-column-alignment/schema.json"
+				},
 				"use-list": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/use-list/schema.json"
 				},