@markuplint/types 4.8.2 → 5.0.0-alpha.0

package/lib/whatwg/check-autocomplete.d.ts

@@ -2,8 +2,13 @@ import type { CustomSyntaxChecker } from '../types.js';
 /**
  * Validates the `autocomplete` attribute value according to the WHATWG specification.
  *
- * Supports "on"/"off" keywords, optional named groups (`section-*`),
- * address parts (shipping/billing), contacting tokens, and autofill field names.
+ * 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
  */

package/lib/whatwg/check-autocomplete.js

@@ -82,25 +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.
  *
- * Supports "on"/"off" keywords, optional named groups (`section-*`),
- * address parts (shipping/billing), contacting tokens, and autofill field names.
+ * 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,
@@ -122,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: [
                     {
@@ -149,173 +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)) {
-        // eslint-disable-next-line no-useless-assignment
-        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/datetime-tokens.js

@@ -509,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-link-type.d.ts

@@ -1,4 +1,107 @@
 import type { CustomSyntaxChecker } from '../types.js';
+/**
+ * A WHATWG-defined link type keyword with per-element context and body-ok flag.
+ *
+ * @see https://html.spec.whatwg.org/multipage/links.html#linkTypes
+ */
+export type DefLinkTypeWhatwg = {
+    readonly keyword: string;
+    readonly link: string;
+    readonly a: string;
+    readonly form: string;
+    readonly bodyOk: string;
+};
+/**
+ * A Microformats-registered link type keyword with per-element context flags.
+ *
+ * @see https://microformats.org/wiki/existing-rel-values
+ */
+export type DefLinkTypeMicroformats = {
+    readonly keyword: string;
+    readonly link: boolean;
+    readonly a: boolean;
+};
+/**
+ * A dropped, rejected, or non-HTML link type keyword from the Microformats registry.
+ *
+ * @see https://microformats.org/wiki/existing-rel-values
+ */
+export type DefLinkTypeMicroformatsDropped = {
+    readonly keyword: string;
+};
+/**
+ * @see https://html.spec.whatwg.org/multipage/links.html#linkTypes
+ *
+ * Scraping:
+ * ```js
+ * JSON.stringify(document.querySelectorAll('#table-link-relations tbody tr').values().toArray().map((el) => {
+ *     const keyword = el.querySelector('td').textContent.trim();
+ *     const link = el.querySelector('td:nth-child(2)').textContent.trim();
+ *     const a = el.querySelector('td[colspan="3"]:nth-child(2)')?.textContent.trim() ?? el.querySelector('td[colspan="2"]:nth-child(2)')?.textContent.trim() ?? el.querySelector('td:nth-child(3)')?.textContent.trim();
+ *     const form = el.querySelector('td[colspan="3"]:nth-child(2)')?.textContent.trim() ?? el.querySelector('td[colspan="2"]:nth-child(3)')?.textContent.trim() ?? el.querySelector('td[colspan="2"]:nth-child(2) + td')?.textContent.trim() ?? el.querySelector('td:nth-child(4)')?.textContent.trim();
+ *     const bodyOk = el.querySelector('td[colspan="3"]:nth-child(2) + td')?.textContent.trim() ?? el.querySelector('td[colspan="2"]:nth-child(3) + td')?.textContent.trim() ?? el.querySelector('td[colspan="2"]:nth-child(2) + td + td')?.textContent.trim() ?? el.querySelector('td:nth-child(5)')?.textContent.trim();
+ *     return { keyword, link, a, form, bodyOk }
+ * }));
+ * ```
+ */
+export declare const DEF_LINK_TYPE_WHATWG: DefLinkTypeWhatwg[];
+/**
+ * @see https://microformats.org/wiki/existing-rel-values#non_HTML_rel_values
+ *
+ * Scraping:
+ * ```js
+ * JSON.stringify($("h2:has('#non_HTML_rel_values') ~ table").eq(0).find('tr:has(td)').toArray().map((el) => {
+ *     const $tr = $(el);
+ *     const keyword = $tr.find('td')[0].textContent.trim();
+ *     return { keyword, link: true, a: true }
+ * }));
+ */
+export declare const DEF_LINK_TYPE_MICROFORMATS_NON_HTML_REL_VALUES: DefLinkTypeMicroformatsDropped[];
+/**
+ * @see https://microformats.org/wiki/existing-rel-values#dropped
+ *
+ * Scraping:
+ * ```js
+ * JSON.stringify($("h2:has('#dropped') ~ table").eq(0).find('tr:has(td)').toArray().map((el) => {
+ *     const $tr = $(el);
+ *     const keyword = $tr.find('td')[0].textContent.split(' ')[0]?.trim();
+ *     return { keyword }
+ * }));
+ */
+export declare const DEF_LINK_TYPE_MICROFORMATS_DROPPED: DefLinkTypeMicroformatsDropped[];
+/**
+ * @see https://microformats.org/wiki/existing-rel-values#dropped_without_prejudice
+ *
+ * Scraping:
+ * ```js
+ * JSON.stringify($("h2:has('#dropped_without_prejudice') ~ table").eq(0).find('tr:has(td)').toArray().map((el) => {
+ *     const $tr = $(el);
+ *     const keyword = $tr.find('td')[0].textContent.split(' ')[0]?.trim();
+ *     return { keyword }
+ * }));
+ * ```
+ */
+export declare const DEF_LINK_TYPE_MICROFORMATS_DROPPED_WITHOUT_PREJUDICE: DefLinkTypeMicroformatsDropped[];
+/**
+ * @see https://microformats.org/wiki/existing-rel-values#rejected
+ *
+ * Scraping:
+ * ```js
+ * JSON.stringify($("h2:has('#rejected') ~ table").eq(0).find('tr:has(td)').toArray().map((el) => {
+ *     const $tr = $(el);
+ *     const keyword = $tr.find('td')[0].textContent.split(' ')[0]?.trim();
+ *     return { keyword }
+ * }));
+ * ```
+ */
+export declare const DEF_LINK_TYPE_MICROFORMATS_REJECTED: DefLinkTypeMicroformatsDropped[];
+/**
+ * Combined list of all allowed Microformats link type keywords,
+ * excluding any that overlap with WHATWG standard keywords.
+ *
+ * @see https://microformats.org/wiki/existing-rel-values
+ */
+export declare const ALLOWED_LINK_TYPE_MICROFORMATS: DefLinkTypeMicroformats[];
 /**
  * Validates a link type attribute value against WHATWG and Microformats registries.
  *

package/lib/whatwg/check-link-type.js

@@ -15,7 +15,7 @@ import { TokenCollection } from '../token/token-collection.js';
  * }));
  * ```
  */
-const DEF_LINK_TYPE_WHATWG = [
+export const DEF_LINK_TYPE_WHATWG = [
     { keyword: 'alternate', link: 'Hyperlink', a: 'Hyperlink', form: 'not allowed', bodyOk: '·' },
     { keyword: 'canonical', link: 'Hyperlink', a: 'not allowed', form: 'not allowed', bodyOk: '·' },
     { keyword: 'author', link: 'Hyperlink', a: 'Hyperlink', form: 'not allowed', bodyOk: '·' },
@@ -353,7 +353,7 @@ const DEF_LINK_TYPE_MICROFORMATS_DUBLIN_CORE = [
  *     return { keyword, link: true, a: true }
  * }));
  */
-const DEF_LINK_TYPE_MICROFORMATS_NON_HTML_REL_VALUES = [
+export const DEF_LINK_TYPE_MICROFORMATS_NON_HTML_REL_VALUES = [
     { keyword: 'self' },
     { keyword: 'http://gdata.youtube.com/schemas/2007#in-reply-to' },
     { keyword: 'collection' },
@@ -394,7 +394,7 @@ const DEF_LINK_TYPE_MICROFORMATS_NON_HTML_REL_VALUES = [
  *     return { keyword }
  * }));
  */
-const DEF_LINK_TYPE_MICROFORMATS_DROPPED = [
+export const DEF_LINK_TYPE_MICROFORMATS_DROPPED = [
     { keyword: 'banner' },
     { keyword: 'begin' },
     { keyword: 'biblioentry' }, // cspell:disable-line
@@ -430,7 +430,7 @@ const DEF_LINK_TYPE_MICROFORMATS_DROPPED = [
  * }));
  * ```
  */
-const DEF_LINK_TYPE_MICROFORMATS_DROPPED_WITHOUT_PREJUDICE = [
+export const DEF_LINK_TYPE_MICROFORMATS_DROPPED_WITHOUT_PREJUDICE = [
     { keyword: 'first' },
     { keyword: 'index' },
     { keyword: 'last' },
@@ -448,11 +448,17 @@ const DEF_LINK_TYPE_MICROFORMATS_DROPPED_WITHOUT_PREJUDICE = [
  * }));
  * ```
  */
-const DEF_LINK_TYPE_MICROFORMATS_REJECTED = [
+export const DEF_LINK_TYPE_MICROFORMATS_REJECTED = [
     { keyword: 'logo' },
     { keyword: 'pavatar' }, // cspell:disable-line
 ];
-const ALLOWED_LINK_TYPE_MICROFORMATS = [
+/**
+ * Combined list of all allowed Microformats link type keywords,
+ * excluding any that overlap with WHATWG standard keywords.
+ *
+ * @see https://microformats.org/wiki/existing-rel-values
+ */
+export const ALLOWED_LINK_TYPE_MICROFORMATS = [
     ...DEF_LINK_TYPE_MICROFORMATS_FORMATS,
     ...DEF_LINK_TYPE_MICROFORMATS_PROPOSALS,
     ...DEF_LINK_TYPE_MICROFORMATS_HTML5_LINK_TYPE_EXTENSIONS,

package/lib/whatwg/check-mime-type.js

@@ -1,5 +1,5 @@
-// @ts-ignore
-import MIMEType from 'whatwg-mimetype';
+// @ts-ignore -- whatwg-mimetype v5 has no type definitions
+import { MIMEType } from 'whatwg-mimetype';
 import { matched, unmatched } from '../match-result.js';
 import { Token } from '../token/index.js';
 const expects = (withoutParameters) => [

package/lib/whatwg/is-abs-url.js

@@ -19,10 +19,7 @@ export const isAbsURL = () => {
             new URL(value);
         }
         catch (error) {
-            if (error &&
-                typeof error === 'object' &&
-                'code' in error && // @ts-ignore
-                error.code === 'ERR_INVALID_URL') {
+            if (error instanceof TypeError) {
                 return false;
             }
             throw error;