@markuplint/types 4.8.1 → 5.0.0-alpha.0

package/lib/whatwg/check-autocomplete.js

@@ -82,20 +82,45 @@ const contactableFieldNames = [
 /**
  * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-autocomplete-webauthn
  */
-const webauthnFieldNames = ['webauthn'];
+const webauthnFieldNames = new Set(['webauthn']);
 const URL_AUTOCOMPLETE = 'https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-autocomplete';
 const URL_ON_OFF = 'https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofilling-form-controls:-the-autocomplete-attribute:attr-fe-autocomplete-on-2';
 const URL_NAMED_GROUP = 'https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-autocomplete-section';
 const URL_PART_OF_ADDRESS = 'https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-autocomplete-shipping';
 const URL_AUTOFILL_FIELD = 'https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill-field';
-const URL_CONTACTABLE_FIELD = 'https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofilling-form-controls:-the-autocomplete-attribute:attr-fe-autocomplete-tel';
 /**
+ * Determines the field category and maximum allowed token count
+ * based on the last meaningful token (the field name).
+ *
+ * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill-field
+ */
+function determineFieldCategory(value) {
+    const lower = value.toLowerCase();
+    if (autofillFieldNames.includes(lower)) {
+        return { category: 'Normal' };
+    }
+    if (contactableFieldNames.includes(lower)) {
+        return { category: 'Contact' };
+    }
+    if (webauthnFieldNames.has(lower)) {
+        return { category: 'Credential' };
+    }
+    return null;
+}
+/**
+ * Validates the `autocomplete` attribute value according to the WHATWG specification.
+ *
+ * Uses backward parsing (right-to-left) to match the spec algorithm:
+ * 1. Determine field name from the last token
+ * 2. Handle `webauthn` credential token and category re-determination
+ * 3. Validate optional contacting token (home/work/mobile/fax/pager)
+ * 4. Validate optional shipping/billing token
+ * 5. Validate optional section-* named group
+ * 6. Check maximum token count per category
+ *
  * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-autocomplete
  */
 export const checkAutoComplete = () => value => {
-    let hasNamedGroup = false;
-    let hasPartOfAddress = false;
-    let hasContactingToken = false;
     const tokens = new TokenCollection(value, {
         disallowToSurroundBySpaces: false,
         allowEmpty: false,
@@ -117,21 +142,16 @@ export const checkAutoComplete = () => value => {
         return listingChecked;
     }
     const identTokens = tokens.getIdentTokens();
-    const headAndTail1 = identTokens.headAndTail();
-    let { head, tail } = headAndTail1;
-    if (!head) {
-        // Never
+    if (identTokens.length === 0) {
+        // Never — TokenCollection.check would catch empty
         throw new Error('TokenCollection is empty');
     }
-    // > When wearing the autofill anchor mantle, the autocomplete attribute,
-    // > if specified, must have a value that is
-    // > an ordered set of space-separated tokens consisting of
-    // > just autofill detail tokens
-    // > (i.e. the "on" and "off" keywords are not allowed).
-    if (head.matches(['on', 'off'], true)) {
-        if (tail[0]) {
-            acLog('[Unmatched ("%s")] Unexpected pair with "on" or "off": "%s"', value, tail.value);
-            return tail[0].unmatched({
+    const firstToken = identTokens[0];
+    // Check for "on" / "off"
+    if (firstToken.matches(['on', 'off'], true)) {
+        if (identTokens[1]) {
+            acLog('[Unmatched ("%s")] Unexpected pair with "on" or "off": "%s"', value, identTokens[1].value);
+            return identTokens[1].unmatched({
                 reason: 'extra-token',
                 expects: [
                     {
@@ -144,172 +164,207 @@ export const checkAutoComplete = () => value => {
         }
         return matched();
     }
-    // > Optionally, a token whose first eight characters are
-    // > an ASCII case-insensitive match for the string "section-",
-    // > meaning that the field belongs to the named group.
-    if (head.matches(namedGroup, true)) {
-        hasNamedGroup = true;
-        const sectionToken = tail.search(namedGroup);
-        if (sectionToken) {
-            acLog('[Unmatched ("%s")] Deprecated in autofill named group: "%s"', value, sectionToken.value);
-            return sectionToken.unmatched({
-                partName: 'autofill named group',
-                reason: 'duplicated',
-                ref: URL_NAMED_GROUP,
-            });
-        }
-        const headAndTail2 = tail.headAndTail();
-        head = headAndTail2.head;
-        tail = headAndTail2.tail;
-        if (!head) {
-            // Missing autofill field name but it is valid
-            return matched();
-        }
+    // Check for "on" / "off" appearing as the last token in a multi-token context
+    const lastIdentToken = identTokens.at(-1);
+    if (lastIdentToken.matches(['on', 'off'], true) && identTokens.length > 1) {
+        acLog('[Unmatched ("%s")] Extra token "on"/"off" at end: "%s"', value, lastIdentToken.value);
+        return lastIdentToken.unmatched({
+            reason: 'extra-token',
+            expects: [
+                {
+                    type: 'format',
+                    value: 'autocomplete',
+                },
+            ],
+            ref: URL_AUTOFILL_FIELD,
+        });
     }
-    // > Optionally, a token that is an ASCII case-insensitive match for
-    // > one of the following strings:
-    // > - "shipping", meaning the field is part of the shipping address or contact information
-    // > - "billing", meaning the field is part of the billing address or contact information
-    if (head.matches(partOfAddress, true)) {
-        hasPartOfAddress = true;
-        const partToken = tail.search(partOfAddress);
-        if (partToken) {
-            acLog('[Unmatched ("%s")] Duplicated values: "%s"', value, partToken.value);
-            return partToken.unmatched({
-                reason: 'duplicated',
-                expects: [
-                    {
-                        type: 'format',
-                        value: 'autocomplete',
-                    },
-                ],
-                ref: URL_PART_OF_ADDRESS,
+    // --- Backward parsing ---
+    let index = identTokens.length - 1;
+    // Step 1: Determine field category from last token
+    const lastToken = identTokens[index];
+    const fieldResult = determineFieldCategory(lastToken.value);
+    if (!fieldResult) {
+        // Last token is not a valid field name
+        const allFieldNames = [...autofillFieldNames, ...contactableFieldNames];
+        const expects = [
+            {
+                type: 'common',
+                value: 'autofill field name',
+            },
+        ];
+        // If single token, also suggest named group
+        if (identTokens.length === 1) {
+            expects.unshift({
+                type: 'common',
+                value: 'autofill named group',
             });
         }
-        const headAndTail3 = tail.headAndTail();
-        head = headAndTail3.head;
-        tail = headAndTail3.tail;
-        if (!head) {
-            // Missing autofill field name but it is valid
-            return matched();
+        let candidate = getCandidate(lastToken.value, allFieldNames);
+        // If single token, also check for section- typo
+        if (!candidate && identTokens.length === 1) {
+            const [prefix, namedGroupStr] = lastToken.value.split('-');
+            const candidatePrefix = getCandidate(prefix, 'section');
+            if (candidatePrefix) {
+                candidate = `${candidatePrefix}-${namedGroupStr ?? ''}`;
+            }
         }
+        acLog('[Unmatched ("%s")] Unexpected token: "%s"', value, lastToken.value);
+        return lastToken.unmatched({
+            reason: 'unexpected-token',
+            expects,
+            candidate,
+            ref: URL_AUTOFILL_FIELD,
+        });
     }
-    if (head.matches(contactingTokens, true)) {
-        hasContactingToken = true;
-        const contactableFiledToken = tail[0];
-        if (!contactableFiledToken) {
-            // Missing autofill field name but it is valid
-            return matched();
-        }
-        if (!contactableFiledToken.matches(contactableFieldNames, true)) {
-            const candidate = getCandidate(contactableFiledToken.value, contactableFieldNames);
-            acLog('[Unmatched ("%s")] Unexpected token: "%s"', value, contactableFiledToken.value);
-            return contactableFiledToken.unmatched({
-                reason: 'unexpected-token',
-                expects: contactableFieldNames.map(token => ({
-                    type: 'const',
-                    value: token,
-                })),
-                candidate,
-                ref: URL_CONTACTABLE_FIELD,
-            });
-        }
-        if (tail[1]) {
-            if (tail[1].matches(webauthnFieldNames)) {
-                return matched();
+    let { category } = fieldResult;
+    index--;
+    // Step 2: Handle webauthn (Credential category re-determination)
+    if (category === 'Credential') {
+        // webauthn token consumed; if there are more tokens, re-determine category
+        if (index >= 0) {
+            const preWebauthnToken = identTokens[index];
+            const reResult = determineFieldCategory(preWebauthnToken.value);
+            if (reResult && reResult.category !== 'Credential') {
+                // Re-determine: the token before webauthn is the actual field name
+                category = reResult.category;
+                index--;
             }
-            const candidate = getCandidate(tail[1].value, webauthnFieldNames);
-            if (candidate) {
-                acLog('[Unmatched ("%s")] Unnecessarily token: "%s", Do you mean "%s"? ', value, tail[1].value, candidate);
+            else if (reResult && reResult.category === 'Credential') {
+                // webauthn webauthn — duplicate caught by TokenCollection.check unique
+                acLog('[Unmatched ("%s")] Duplicate webauthn', value);
+                return preWebauthnToken.unmatched({
+                    reason: 'extra-token',
+                    expects: [{ type: 'format', value: 'autocomplete' }],
+                    ref: URL_AUTOFILL_FIELD,
+                });
             }
             else {
-                acLog('[Unmatched ("%s")] Unnecessarily token: "%s"', value, tail[1].value);
+                // Token before webauthn is not a valid field name
+                const allFieldNames = [...autofillFieldNames, ...contactableFieldNames];
+                const candidate = getCandidate(preWebauthnToken.value, allFieldNames);
+                acLog('[Unmatched ("%s")] Unexpected token before webauthn: "%s"', value, preWebauthnToken.value);
+                return preWebauthnToken.unmatched({
+                    reason: 'unexpected-token',
+                    expects: [{ type: 'common', value: 'autofill field name' }],
+                    candidate,
+                    ref: URL_AUTOFILL_FIELD,
+                });
             }
-            return tail[1].unmatched({
-                reason: 'extra-token',
-                expects: [
-                    {
-                        type: 'format',
-                        value: 'autocomplete',
-                    },
-                ],
-                ref: URL_AUTOFILL_FIELD,
-            });
         }
+        else {
+            // Standalone "webauthn" is valid
+            return matched();
+        }
+    }
+    // No more tokens to validate — only the field name was present
+    if (index < 0) {
         return matched();
     }
-    if (head.matches([...autofillFieldNames, ...contactableFieldNames], true)) {
-        if (tail[0]) {
-            if (tail[0].matches(webauthnFieldNames)) {
+    // Track which optional prefixes have been consumed
+    let hasPartOfAddress = false;
+    let hasNamedGroup = false;
+    // Step 3: If Contact category, optionally consume contacting token
+    if (category === 'Contact') {
+        const currentToken = identTokens[index];
+        if (currentToken.matches(contactingTokens, true)) {
+            index--;
+            if (index < 0) {
                 return matched();
             }
-            const candidate = getCandidate(tail[0].value, webauthnFieldNames);
-            if (candidate) {
-                acLog('[Unmatched ("%s")] Unnecessarily token: "%s", Do you mean "%s"? ', value, tail[0].value, candidate);
-            }
-            else {
-                acLog('[Unmatched ("%s")] Unnecessarily token: "%s"', value, tail[0].value);
-            }
-            return tail[0].unmatched({
-                reason: 'extra-token',
+        }
+    }
+    // Step 4: If Normal category, the current token must NOT be a contacting token
+    // (contacting tokens are only valid before contactable field names)
+    if (category === 'Normal') {
+        const currentToken = identTokens[index];
+        if (currentToken.matches(contactingTokens, true)) {
+            acLog('[Unmatched ("%s")] Contacting token not valid for Normal field', value, currentToken.value);
+            return currentToken.unmatched({
+                reason: 'unexpected-token',
                 expects: [
+                    ...partOfAddress.map(token => ({
+                        type: 'const',
+                        value: token,
+                    })),
                     {
-                        type: 'format',
-                        value: 'autocomplete',
+                        type: 'common',
+                        value: 'autofill named group',
                     },
                 ],
-                ref: URL_AUTOFILL_FIELD,
+                ref: URL_PART_OF_ADDRESS,
             });
         }
-        return matched();
     }
-    if (head.matches(webauthnFieldNames)) {
-        return matched();
+    // Step 5: Optionally consume shipping/billing
+    if (index >= 0) {
+        const currentToken = identTokens[index];
+        if (currentToken.matches(partOfAddress, true)) {
+            hasPartOfAddress = true;
+            index--;
+            if (index < 0) {
+                return matched();
+            }
+        }
     }
-    const expects = [
-        {
-            type: 'common',
-            value: 'autofill field name',
-        },
-    ];
-    let candidate;
-    if (!hasNamedGroup) {
-        expects.unshift({
-            type: 'common',
-            value: 'autofill named group',
-        });
-        // Potentially typo a named group
-        const [prefix, namedGroupStr] = head.value.split('-');
+    // Step 6: Optionally consume section-*
+    if (index >= 0) {
+        const currentToken = identTokens[index];
+        if (currentToken.matches(namedGroup, true)) {
+            hasNamedGroup = true;
+            index--;
+            if (index < 0) {
+                return matched();
+            }
+        }
+    }
+    // Step 7: If there are remaining tokens, they are extra
+    if (index >= 0) {
+        const extraToken = identTokens[index];
+        // Build expects based on what hasn't been consumed yet
+        const extraExpects = [];
+        if (!hasPartOfAddress && !hasNamedGroup) {
+            // Neither shipping/billing nor section-* consumed — could be either
+            extraExpects.push(...partOfAddress.map(token => ({
+                type: 'const',
+                value: token,
+            })), {
+                type: 'common',
+                value: 'autofill field name',
+            });
+        }
+        else if (hasNamedGroup) {
+            // Both consumed — nothing expected, pure extra
+            extraExpects.push({
+                type: 'common',
+                value: 'autofill named group',
+            });
+        }
+        else {
+            // shipping/billing consumed but section-* not — expect section-*
+            extraExpects.push({
+                type: 'common',
+                value: 'autofill named group',
+            });
+        }
+        // Check if it's a section-* typo
+        let candidate;
+        const [prefix, namedGroupStr] = extraToken.value.split('-');
         const candidatePrefix = getCandidate(prefix, 'section');
         if (candidatePrefix) {
             candidate = `${candidatePrefix}-${namedGroupStr ?? ''}`;
         }
+        if (!candidate) {
+            candidate = getCandidate(extraToken.value, partOfAddress, autofillFieldNames, contactableFieldNames);
+        }
+        const ref = !hasPartOfAddress && !hasNamedGroup ? URL_AUTOFILL_FIELD : URL_NAMED_GROUP;
+        acLog('[Unmatched ("%s")] Extra token: "%s"', value, extraToken.value);
+        return extraToken.unmatched({
+            reason: 'unexpected-token',
+            expects: extraExpects,
+            candidate,
+            ref,
+        });
     }
-    else if (!hasPartOfAddress) {
-        expects.unshift(...[...partOfAddress].reverse().map(token => ({
-            type: 'const',
-            value: token,
-        })));
-        candidate = getCandidate(head.value, partOfAddress, autofillFieldNames, contactingTokens, contactableFieldNames);
-    }
-    else if (!hasContactingToken) {
-        expects.push(...contactingTokens.map(token => ({
-            type: 'const',
-            value: token,
-        })));
-        candidate = getCandidate(head.value, autofillFieldNames, contactingTokens, contactableFieldNames);
-    }
-    candidate = candidate ?? getCandidate(head.value, autofillFieldNames);
-    if (candidate) {
-        acLog('[Unmatched ("%s")] Unexpected token: "%s", Do you mean "%s"? ', value, head.value, candidate);
-    }
-    else {
-        acLog('[Unmatched ("%s")] Unexpected token: "%s"', value, head.value);
-    }
-    return head.unmatched({
-        reason: 'unexpected-token',
-        expects,
-        candidate,
-        ref: URL_AUTOFILL_FIELD,
-    });
+    return matched();
 };

package/lib/whatwg/check-datetime/date-string.d.ts

@@ -1,5 +1,7 @@
 import type { CustomSyntaxChecker } from '../../types.js';
 /**
+ * Validates a date string in the format `YYYY-MM-DD`.
+ *
  * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#dates
  */
 export declare const checkDateString: CustomSyntaxChecker;

package/lib/whatwg/check-datetime/date-string.js

@@ -2,6 +2,8 @@ import { log } from '../../debug.js';
 import { TokenCollection } from '../../token/index.js';
 import { datetimeTokenCheck } from './datetime-tokens.js';
 /**
+ * Validates a date string in the format `YYYY-MM-DD`.
+ *
  * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#dates
  */
 export const checkDateString = () => function checkDateString(value) {

package/lib/whatwg/check-datetime/datetime-tokens.d.ts

@@ -1,3 +1,16 @@
 import type { TokenEachCheck } from '../../token/token-collection.js';
+/**
+ * Collection of token check functions for datetime component validation.
+ *
+ * Each property is a {@link TokenEachCheck} function that validates a specific
+ * datetime component (year, month, date, hour, minute, second, etc.)
+ * according to the WHATWG specification.
+ */
 export declare const datetimeTokenCheck: Record<'year' | 'month' | 'date' | 'hour' | 'minute' | 'second' | 'secondFractionalPart' | 'week' | 'hyphen' | 'colon' | 'extra' | 'colonOrEnd' | 'decimalPointOrEnd' | 'localDateTimeSeparator' | 'normalizedlocalDateTimeSeparator' | 'plusOrMinusSign' | 'weekSign', TokenEachCheck> & Record<'_year' | '_month', number | null>;
+/**
+ * Calculates the maximum ISO week number for a given year.
+ *
+ * @param year - The year to calculate for
+ * @returns The maximum week number (52 or 53) for the year
+ */
 export declare function getMaxWeekNum(year: number): number;

package/lib/whatwg/check-datetime/datetime-tokens.js

@@ -1,5 +1,12 @@
 import { log } from '../../debug.js';
 import { matched, unmatched } from '../../match-result.js';
+/**
+ * Collection of token check functions for datetime component validation.
+ *
+ * Each property is a {@link TokenEachCheck} function that validates a specific
+ * datetime component (year, month, date, hour, minute, second, etc.)
+ * according to the WHATWG specification.
+ */
 export const datetimeTokenCheck = {
     /**
      * Temporary year state
@@ -489,6 +496,12 @@ const daysOfMonth = [
     // 12
     31,
 ];
+/**
+ * Calculates the maximum ISO week number for a given year.
+ *
+ * @param year - The year to calculate for
+ * @returns The maximum week number (52 or 53) for the year
+ */
 export function getMaxWeekNum(year) {
     let date = 31;
     while (date > 0) {
@@ -496,7 +509,7 @@ export function getMaxWeekNum(year) {
         const day = d.getDay();
         d.setDate(d.getDate() + 4 - (day > 0 ? day : 7));
         const yearStart = new Date(d.getFullYear(), 0, 1);
-        const weekNo = Math.ceil(((d.valueOf() - yearStart.valueOf()) / 86400000 + 1) / 7);
+        const weekNo = Math.ceil(((d.valueOf() - yearStart.valueOf()) / 86_400_000 + 1) / 7);
         if (weekNo !== 1) {
             return weekNo;
         }

package/lib/whatwg/check-datetime/duration-string.d.ts

@@ -1,6 +1,13 @@
 import type { CustomSyntaxChecker } from '../../types.js';
 /**
+ * Validates a duration string in ISO 8601-like format (e.g., `PT1H30M`).
+ *
  * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#durations
  */
 export declare const checkDurationISO8601LikeString: CustomSyntaxChecker;
+/**
+ * Validates a duration string in component list format (e.g., `1h 30m 5s`).
+ *
+ * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#durations
+ */
 export declare const checkDurationComponentListString: CustomSyntaxChecker;

package/lib/whatwg/check-datetime/duration-string.js

@@ -3,6 +3,8 @@ import { matched, unmatched } from '../../match-result.js';
 import { TokenCollection } from '../../token/index.js';
 import { datetimeTokenCheck } from './datetime-tokens.js';
 /**
+ * Validates a duration string in ISO 8601-like format (e.g., `PT1H30M`).
+ *
  * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#durations
  */
 export const checkDurationISO8601LikeString = () => function checkDurationISO8601LikeString(value) {
@@ -201,6 +203,11 @@ export const checkDurationISO8601LikeString = () => function checkDurationISO860
     }
     return res;
 };
+/**
+ * Validates a duration string in component list format (e.g., `1h 30m 5s`).
+ *
+ * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#durations
+ */
 export const checkDurationComponentListString = () => function checkDurationComponentListString(value) {
     log('CHECK: duration-string (duration component list)');
     if (!value) {

package/lib/whatwg/check-datetime/global-date-and-time-string.d.ts

@@ -1,5 +1,7 @@
 import type { CustomSyntaxChecker } from '../../types.js';
 /**
+ * Validates a global date and time string (date + time + time-zone offset).
+ *
  * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#global-dates-and-times
  */
 export declare const checkGlobalDateAndTimeString: CustomSyntaxChecker;

package/lib/whatwg/check-datetime/global-date-and-time-string.js

@@ -4,6 +4,8 @@ import { TokenCollection } from '../../token/index.js';
 import { datetimeTokenCheck } from './datetime-tokens.js';
 import { parseTimeZone } from './time-zone-offset-string.js';
 /**
+ * Validates a global date and time string (date + time + time-zone offset).
+ *
  * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#global-dates-and-times
  */
 export const checkGlobalDateAndTimeString = () => function checkGlobalDateAndTimeString(value) {

package/lib/whatwg/check-datetime/index.d.ts

@@ -1,5 +1,10 @@
 import type { CustomSyntaxChecker } from '../../types.js';
 /**
+ * Validates a datetime string against all WHATWG date and time formats.
+ *
+ * Tries each format (date, time, month, yearless date, local/global date-time,
+ * time-zone offset, week, year, and duration strings) and returns the best match.
+ *
  * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#dates-and-times
  */
 export declare const checkDateTime: CustomSyntaxChecker;

package/lib/whatwg/check-datetime/index.js

@@ -24,6 +24,11 @@ const checks = [
     checkDurationComponentListString(),
 ];
 /**
+ * Validates a datetime string against all WHATWG date and time formats.
+ *
+ * Tries each format (date, time, month, yearless date, local/global date-time,
+ * time-zone offset, week, year, and duration strings) and returns the best match.
+ *
  * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#dates-and-times
  */
 export const checkDateTime = () => value => {

package/lib/whatwg/check-datetime/local-date-and-time-string.d.ts

@@ -1,9 +1,13 @@
 import type { CustomSyntaxChecker } from '../../types.js';
 /**
+ * Validates a local date and time string (date + `T` or space + time, no time-zone).
+ *
  * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-local-date-and-time-string
  */
 export declare const checkLocalDateAndTimeString: CustomSyntaxChecker;
 /**
+ * Validates a normalized local date and time string (uses `T` separator only, omits zero seconds).
+ *
  * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-normalised-local-date-and-time-string
  */
 export declare const checkNormalizedLocalDateAndTimeString: CustomSyntaxChecker;

package/lib/whatwg/check-datetime/local-date-and-time-string.js

@@ -2,6 +2,8 @@ import { log } from '../../debug.js';
 import { TokenCollection } from '../../token/index.js';
 import { datetimeTokenCheck } from './datetime-tokens.js';
 /**
+ * Validates a local date and time string (date + `T` or space + time, no time-zone).
+ *
  * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-local-date-and-time-string
  */
 export const checkLocalDateAndTimeString = () => function checkLocalDateAndTimeString(value) {
@@ -42,6 +44,8 @@ export const checkLocalDateAndTimeString = () => function checkLocalDateAndTimeS
     return res;
 };
 /**
+ * Validates a normalized local date and time string (uses `T` separator only, omits zero seconds).
+ *
  * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-normalised-local-date-and-time-string
  */
 export const checkNormalizedLocalDateAndTimeString = () => function checkNormalizedLocalDateAndTimeString(value) {

package/lib/whatwg/check-datetime/month-string.d.ts

@@ -1,5 +1,7 @@
 import type { CustomSyntaxChecker } from '../../types.js';
 /**
+ * Validates a month string in the format `YYYY-MM`.
+ *
  * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-month-string
  */
 export declare const checkMonthString: CustomSyntaxChecker;

package/lib/whatwg/check-datetime/month-string.js

@@ -2,6 +2,8 @@ import { log } from '../../debug.js';
 import { TokenCollection } from '../../token/index.js';
 import { datetimeTokenCheck } from './datetime-tokens.js';
 /**
+ * Validates a month string in the format `YYYY-MM`.
+ *
  * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-month-string
  */
 export const checkMonthString = () => function checkMonthString(value) {

package/lib/whatwg/check-datetime/time-string.d.ts

@@ -1,5 +1,7 @@
 import type { CustomSyntaxChecker } from '../../types.js';
 /**
+ * Validates a time string in the format `HH:MM[:SS[.sss]]`.
+ *
  * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#times
  */
 export declare const checkTimeString: CustomSyntaxChecker;