@markuplint/types 5.0.0-rc.2 → 5.0.0-rc.5

package/lib/defs.js

@@ -1,17 +1,23 @@
 import { checkMultiTypes } from './check-multi-types.js';
+import { cssSyntaxMatch } from './css-syntax.js';
 import { getCandidate } from './get-candidate.js';
 import { matched, matches, unmatched } from './match-result.js';
 import { splitUnit, isFloat, isUint, isInt } from './primitive/index.js';
 import { isBCP47 } from './rfc/is-bcp-47.js';
 import { Token, TokenCollection } from './token/index.js';
+import { checkContentSecurityPolicy } from './w3c/check-content-security-policy.js';
 import { checkSerializedPermissionsPolicy } from './w3c/check-serialized-permissions-policy.js';
 import { checkAutoComplete } from './whatwg/check-autocomplete.js';
 import { checkDateTime } from './whatwg/check-datetime/index.js';
 import { checkDateString } from './whatwg/check-datetime/date-string.js';
+import { checkDateStringWithOptionalTime } from './whatwg/check-datetime/date-string-with-optional-time.js';
 import { checkLocalDateAndTimeString } from './whatwg/check-datetime/local-date-and-time-string.js';
 import { checkMonthString } from './whatwg/check-datetime/month-string.js';
 import { checkTimeString } from './whatwg/check-datetime/time-string.js';
 import { checkWeekString } from './whatwg/check-datetime/week-string.js';
+import { checkHTTPEquivContentType } from './whatwg/check-http-equiv-content-type.js';
+import { checkHTTPEquivRefresh } from './whatwg/check-http-equiv-refresh.js';
+import { checkMediaQueryList, findGeneralEnclosed } from './whatwg/check-media-query-list.js';
 import { checkMIMEType } from './whatwg/check-mime-type.js';
 import { checkURL } from './whatwg/check-url.js';
 import { isAbsURL } from './whatwg/is-abs-url.js';
@@ -22,14 +28,27 @@ import { isNavigableTargetName } from './whatwg/is-navigable-target-name.js';
 import { checkLinkType } from './whatwg/check-link-type.js';
 import { isEmail } from './whatwg/check-email.js';
 import { isSimpleColor } from './whatwg/check-simple-color.js';
-/**
- * Built-in type definitions registry for HTML attribute value validation.
- *
- * Maps type identifiers to their validation logic, reference URLs,
- * and expected value descriptions. Includes definitions for common types
- * (Any, Number, URL, etc.), WHATWG-specified types (DateTime, MIMEType,
- * CustomElementName, etc.), and format-specific validators (BCP47, Pattern, etc.).
- */
+// Hoist the URL Living Standard checker once so type entries that wrap it
+// (e.g. `BaseURL`, which adds the `<base>`-specific data:/javascript: filter
+// on top) do not pay closure-construction cost per attribute value.
+//
+// URL-family selection guide — when wiring an attribute in spec data, map
+// the HTML Living Standard's exact production wording to the type name:
+//
+// - "valid URL potentially surrounded by spaces" → `URL`
+//   (empty is valid; it resolves to the document's own URL)
+// - "valid non-empty URL potentially surrounded by spaces" → `NonEmptyURL`
+//   (the `src`-attribute production)
+// - `<base href>` ("set the frozen base URL") → `BaseURL`
+// - "valid absolute URL" as a per-token constraint in a list (e.g.
+//   `itemtype`) → `AbsoluteURL`
+// - "if specified and not empty, must be a valid absolute URL potentially
+//   surrounded by ASCII whitespace" (HTML LS §4.10.5.1.7,
+//   `<input type=url value>`) → `AbsoluteURLOrEmpty`
+//
+// All of these layer their per-attribute constraint on top of the shared
+// `checkURLOnce` so URL LS validation-error coverage stays uniform.
+const checkURLOnce = checkURL();
 export const defs = {
     Any: {
         ref: '',
@@ -225,6 +244,16 @@ export const defs = {
         ],
         is: checkDateString(),
     },
+    DateStringWithOptionalTime: {
+        ref: 'https://html.spec.whatwg.org/multipage/edits.html#attr-mod-datetime',
+        expects: [
+            {
+                type: 'format',
+                value: 'date string with optional time',
+            },
+        ],
+        is: checkDateStringWithOptionalTime(),
+    },
     TimeString: {
         ref: 'https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#times',
         expects: [
@@ -301,11 +330,6 @@ export const defs = {
         is: value => (value === '' ? matched() : matches(isBCP47(), { reason: 'unexpected-token' })(value)),
     },
     /**
-     * Validates a URL (potentially surrounded by spaces) per WHATWG URL Standard.
-     * Uses `new URL()` for structural parsing plus strict checks for illegal
-     * whitespace, malformed percent-encoding, and C0 control characters.
-     * Relative URLs are resolved against a dummy base for syntax validation.
-     *
      * Previously this was always-matched ("NO IMPLEMENT NEVER") because
      * relative URLs accept almost any character string. After investigating
      * nu-html-checker's galimatias parser, we found that resolving relative
@@ -317,7 +341,26 @@ export const defs = {
      */
     URL: {
         ref: 'https://html.spec.whatwg.org/multipage/urls-and-fetching.html#valid-url-potentially-surrounded-by-spaces',
-        is: checkURL(),
+        is: checkURLOnce,
+    },
+    /**
+     * Validates a "valid non-empty URL potentially surrounded by spaces". HTML
+     * LS uses this stricter production for `src` attributes on
+     * `<audio>`/`<embed>`/`<iframe>`/`<img>`/`<input type=image>`/`<script>`/
+     * `<source>`/`<track>`/`<video>` — the URL token MUST contain at least one
+     * non-whitespace character.
+     *
+     * @see https://html.spec.whatwg.org/multipage/urls-and-fetching.html#valid-non-empty-url
+     * @see https://html.spec.whatwg.org/multipage/urls-and-fetching.html#valid-non-empty-url-potentially-surrounded-by-spaces
+     */
+    NonEmptyURL: {
+        ref: 'https://html.spec.whatwg.org/multipage/urls-and-fetching.html#valid-non-empty-url-potentially-surrounded-by-spaces',
+        is(value) {
+            if (value.replaceAll(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, '') === '') {
+                return unmatched(value, 'unexpected-token');
+            }
+            return checkURLOnce(value);
+        },
     },
     /**
      * Fail if it inclides "data" or "javascript" scheme.
@@ -331,21 +374,57 @@ export const defs = {
     BaseURL: {
         ref: 'https://html.spec.whatwg.org/multipage/semantics.html#set-the-frozen-base-url',
         is(value) {
-            value = value.toLowerCase().trim();
-            if (value.startsWith('data:') || value.startsWith('javascript:')) {
+            // `<base href>` is forbidden from declaring `data:` / `javascript:`
+            // schemes (HTML LS — "set the frozen base URL"). Surface that
+            // constraint first because it is `<base>`-specific, then delegate
+            // to the shared URL Living Standard validator so all URL LS
+            // validation errors (invalid-credentials, scheme-missing-solidus,
+            // invalid-reverse-solidus, etc.) are reported uniformly with
+            // `URL` / `HTTPSchemaURL` / etc.
+            const normalised = value.toLowerCase().trim();
+            if (normalised.startsWith('data:') || normalised.startsWith('javascript:')) {
                 return unmatched(value, 'unexpected-token');
             }
-            return matched();
+            return checkURLOnce(value);
         },
     },
     AbsoluteURL: {
         ref: 'https://url.spec.whatwg.org/#syntax-url-absolute',
-        is: matches(isAbsURL()),
+        is(value) {
+            // `AbsoluteURL` is used by per-token list types (e.g. `itemtype`),
+            // where each token must be a valid absolute URL. Reject
+            // non-absolute / unparsable values first, then run the full URL
+            // Living Standard validator so callers get the same
+            // auto-correction error coverage as `URL` (invalid-credentials,
+            // invalid-reverse-solidus, multiple `#`, etc.).
+            if (!isAbsURL()(value)) {
+                return unmatched(value, 'unexpected-token');
+            }
+            return checkURLOnce(value);
+        },
     },
     /**
-     * Subresource Integrity metadata: one or more space-separated
-     * `hash-algo-base64` tokens where algo is sha256, sha384, or sha512.
+     * Validates `<input type="url" value="...">` per HTML LS §4.10.5.1.7:
+     * "if specified and not empty, must have a value that is a valid absolute
+     * URL potentially surrounded by ASCII whitespace." Accepts empty values
+     * (no default URL) and absolute URLs that pass URL Living Standard
+     * validation; rejects relative URLs and URL LS validation errors.
      *
+     * @see https://html.spec.whatwg.org/multipage/input.html#url-state-(type=url)
+     */
+    AbsoluteURLOrEmpty: {
+        ref: 'https://html.spec.whatwg.org/multipage/input.html#url-state-(type=url)',
+        is(value) {
+            if (value.replaceAll(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, '') === '') {
+                return matched();
+            }
+            if (!isAbsURL()(value)) {
+                return unmatched(value, 'unexpected-token');
+            }
+            return checkURLOnce(value);
+        },
+    },
+    /**
      * Note: The SRI spec also allows `?options` suffix (e.g., `sha256-abc?ct=...`)
      * but this is not widely used and not tested by nu-validator.
      *
@@ -380,7 +459,18 @@ export const defs = {
                 value: 'hash name',
             },
         ],
-        is: value => (value[0] === '#' ? matched() : unmatched(value, 'unexpected-token')),
+        // HTML LS: "A string is a valid hash-name reference [...] if the string
+        // consists of a U+0023 NUMBER SIGN (#) followed by a string which
+        // exactly matches the value of the name attribute [...]". The spec
+        // requires the name part to be non-empty: `#` alone is not a valid
+        // hash-name reference.
+        is: value => {
+            if (value.length < 2)
+                return unmatched(value, 'unexpected-token');
+            if (value[0] !== '#')
+                return unmatched(value, 'unexpected-token');
+            return matched();
+        },
     },
     OneCodePointChar: {
         ref: 'https://html.spec.whatwg.org/multipage/interaction.html#the-accesskey-attribute',
@@ -521,6 +611,52 @@ export const defs = {
         ],
         is: checkMIMEType(),
     },
+    MediaQueryList: {
+        ref: 'https://www.w3.org/TR/mediaqueries-5/',
+        expects: [
+            {
+                type: 'format',
+                value: 'media query list',
+            },
+        ],
+        is: checkMediaQueryList(),
+    },
+    // `HTTPEquivRefresh` / `HTTPEquivContentType` / `ContentSecurityPolicy` are
+    // selected at runtime by a `ConditionalAttributeType[]` entry on
+    // `meta.content` in `@markuplint/html-spec`, keyed by the `http-equiv`
+    // value (`refresh` / `content-type` / `content-security-policy`). Other
+    // `http-equiv` values fall through to `Any` via the resolver in
+    // `@markuplint/rules`.
+    HTTPEquivRefresh: {
+        ref: 'https://html.spec.whatwg.org/multipage/semantics.html#attr-meta-http-equiv-refresh',
+        expects: [
+            {
+                type: 'format',
+                value: 'refresh directive (a non-negative integer, optionally followed by a URL)',
+            },
+        ],
+        is: checkHTTPEquivRefresh(),
+    },
+    HTTPEquivContentType: {
+        ref: 'https://html.spec.whatwg.org/multipage/semantics.html#attr-meta-http-equiv-content-type',
+        expects: [
+            {
+                type: 'format',
+                value: 'content-type directive (text/html; charset=<encoding>)',
+            },
+        ],
+        is: checkHTTPEquivContentType(),
+    },
+    ContentSecurityPolicy: {
+        ref: 'https://www.w3.org/TR/CSP3/#framework-policy',
+        expects: [
+            {
+                type: 'format',
+                value: 'Content Security Policy (a semicolon-separated list of directives)',
+            },
+        ],
+        is: checkContentSecurityPolicy(),
+    },
     ItemProp: {
         ref: 'https://html.spec.whatwg.org/multipage/microdata.html#names:-the-itemprop-attribute',
         expects: [
@@ -548,6 +684,12 @@ export const defs = {
             const images = value.split(',');
             let hasWidth = false;
             let hasDensity = false;
+            // Spec: "Let candidates be an initially empty source set. ... If candidates already has an
+            // entry whose descriptor's width is equal to width [or pixel density], then a parse error
+            // must be reported." Track normalised numeric values so 1x / 1.0x / omitted-descriptor
+            // (implicit 1x) all collide.
+            const usedWidths = new Set();
+            const usedDensities = new Set();
             for (const image of images) {
                 // image candidate string
                 const [url, , descriptor, ...tail] = new TokenCollection(image.trim(), {
@@ -564,6 +706,22 @@ export const defs = {
                         ],
                     });
                 }
+                // HTML LS srcset: each image candidate's URL must be a valid
+                // non-empty URL. css-tree's <url> token allows things like bare
+                // `http:` (URL LS `special-scheme-missing-following-solidus`),
+                // so we parse it explicitly via WHATWG URL with a dummy base.
+                try {
+                    new URL(url.value, 'https://example.com/');
+                }
+                catch (error) {
+                    if (error instanceof TypeError) {
+                        return url.unmatched({
+                            reason: 'unexpected-token',
+                            expects: [{ type: 'format', value: 'valid non-empty URL' }],
+                        });
+                    }
+                    throw error;
+                }
                 if (descriptor) {
                     const { num, unit } = splitUnit(descriptor.value);
                     switch (unit) {
@@ -579,6 +737,13 @@ export const defs = {
                                     ],
                                 });
                             }
+                            const w = Number(num);
+                            if (usedWidths.has(w)) {
+                                return unmatched(value, 'duplicated', {
+                                    expects: [{ type: 'format', value: 'unique width descriptor' }],
+                                });
+                            }
+                            usedWidths.add(w);
                             hasWidth = true;
                             break;
                         }
@@ -594,6 +759,13 @@ export const defs = {
                                     ],
                                 });
                             }
+                            const d = Number(num);
+                            if (usedDensities.has(d)) {
+                                return unmatched(value, 'duplicated', {
+                                    expects: [{ type: 'format', value: 'unique pixel density descriptor' }],
+                                });
+                            }
+                            usedDensities.add(d);
                             hasDensity = true;
                             break;
                         }
@@ -614,7 +786,14 @@ export const defs = {
                     }
                 }
                 else {
-                    // No descriptor implies 1x (density descriptor)
+                    // Spec: "If image candidate's descriptor is the empty string, [...] add an
+                    // image source with a pixel density of 1.0."
+                    if (usedDensities.has(1)) {
+                        return unmatched(value, 'duplicated', {
+                            expects: [{ type: 'format', value: 'unique pixel density descriptor' }],
+                        });
+                    }
+                    usedDensities.add(1);
                     hasDensity = true;
                 }
                 if (tail[0]) {
@@ -649,21 +828,90 @@ export const defs = {
                 value: '<source-size-list>',
             },
         ],
-        syntax: {
-            apply: '<source-size-list>',
-            def: {
-                'source-size-list': '[ <source-size># , ]? <source-size-value>',
-                'source-size': '<media-condition> <source-size-value> | auto',
-                /**
-                 * > Percentages are not allowed in a `<source-size-value>`,
-                 * > to avoid confusion about what it would be relative to.
-                 * > The 'vw' unit can be used for sizes relative to the viewport width.
-                 *
-                 * `<length>` doesn't allow percentages.
-                 * @see https://csstree.github.io/docs/syntax/#Type:length
-                 */
-                'source-size-value': '<length> | auto',
-            },
+        is(value) {
+            const result = cssSyntaxMatch(value, {
+                ref: 'https://html.spec.whatwg.org/multipage/images.html#sizes-attributes',
+                syntax: {
+                    apply: '<source-size-list>',
+                    def: {
+                        'source-size-list': '[ <source-size># , ]? <source-size-value>',
+                        'source-size': '<media-condition> <source-size-value> | auto',
+                        /**
+                         * > Percentages are not allowed in a `<source-size-value>`,
+                         * > to avoid confusion about what it would be relative to.
+                         * > The 'vw' unit can be used for sizes relative to the viewport width.
+                         *
+                         * `<length>` doesn't allow percentages.
+                         * @see https://csstree.github.io/docs/syntax/#Type:length
+                         */
+                        'source-size-value': '<length> | auto',
+                    },
+                },
+            });
+            if (!result.matched) {
+                return result;
+            }
+            // HTML LS imposes a non-negative additional constraint on
+            // <source-size-value> ("a <length> that does not contain
+            // percentages [...] and that is greater than or equal to zero")
+            // beyond what css-tree's <length> grammar checks. A
+            // <source-size-value> always appears either at the start of the
+            // list, immediately after the `,` separator, or immediately after
+            // the `)` that closes a <media-condition>; a `-` followed by a
+            // digit at any of those boundaries is a negative length token.
+            //
+            // Regex breakdown: boundary (start-of-string | `,` | `)`)
+            // → optional whitespace → literal `-` → optional whitespace
+            // → digit. Note this only catches negative numbers that *start*
+            // a <source-size-value>; positive scientific notation like
+            // `1e-5px` is unaffected because the `-` is preceded by `e`.
+            const negativeAtSourceSizeBoundary = /(?:^|[,)])\s*-\s*\d/u;
+            if (negativeAtSourceSizeBoundary.test(value)) {
+                return unmatched(value, 'out-of-range', {
+                    expects: [{ type: 'format', value: 'non-negative <length>' }],
+                });
+            }
+            // Each top-level `(<any-value>?)` group inside the sizes list is a
+            // `<media-condition>` per HTML LS. Media Queries Level 5 §3 forbids
+            // `<general-enclosed>` in author stylesheets, but css-tree accepts
+            // it grammatically (that's the point of the fallback — future syntax
+            // must parse in older UAs). Extract each balanced-parens group and
+            // route it through the media-query walker so malformed feature forms
+            // like `(min-width:)` (empty value) and `(123)` (non-ident content)
+            // surface as syntax errors rather than silently accepted GE matches.
+            let depth = 0;
+            let groupStart = -1;
+            for (let i = 0; i < value.length; i++) {
+                const c = value[i];
+                if (c === '(') {
+                    if (depth === 0) {
+                        // A `(` preceded by an identifier / digit character is a CSS
+                        // function call (`clamp(...)`, `min(...)`, `calc(...)`, `env(...)`)
+                        // inside a `<source-size-value>`, not a `<media-condition>`.
+                        // Skip: its contents are function arguments, not a media query.
+                        const prev = i > 0 ? (value[i - 1] ?? '') : '';
+                        const isFunctionCall = /[\w-]/u.test(prev);
+                        groupStart = isFunctionCall ? -1 : i;
+                    }
+                    depth++;
+                }
+                else if (c === ')') {
+                    depth--;
+                    if (depth === 0 && groupStart >= 0) {
+                        const groupText = value.slice(groupStart, i + 1);
+                        const hit = findGeneralEnclosed(groupText);
+                        if (hit) {
+                            return new Token(hit.raw, groupStart + hit.offset, value).unmatched({
+                                reason: 'syntax-error',
+                                expects: [{ type: 'format', value: 'media condition' }],
+                                partName: `unknown or malformed media condition ${JSON.stringify(hit.raw)} (Media Queries Level 5 §3 forbids <general-enclosed> in author stylesheets)`,
+                            });
+                        }
+                        groupStart = -1;
+                    }
+                }
+            }
+            return matched();
         },
     },
     IconSize: {
@@ -719,6 +967,29 @@ export const defs = {
         ref: 'https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-autocomplete',
         is: checkAutoComplete(),
     },
+    /**
+     * `autocomplete` variant for elements where the `webauthn` token is not
+     * valid. Per HTML LS §attr-fe-autocomplete-webauthn: "webauthn is only
+     * valid for input and textarea elements." Applied to `button`,
+     * `fieldset`, `object`, `output`, and `select`.
+     *
+     * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-autocomplete-webauthn
+     */
+    AutoCompleteNoWebauthn: {
+        ref: 'https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-autocomplete-webauthn',
+        is: checkAutoComplete({ noWebauthn: true }),
+    },
+    /**
+     * `autocomplete` variant for the autofill anchor mantle: on `<input
+     * type=hidden>`, the `on` / `off` keywords are not allowed and the
+     * value must consist of just autofill detail tokens.
+     *
+     * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill-anchor-mantle
+     */
+    AutoCompleteAnchorMantle: {
+        ref: 'https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill-anchor-mantle',
+        is: checkAutoComplete({ anchorMantle: true }),
+    },
     Accept: {
         ref: 'https://html.spec.whatwg.org/multipage/input.html#attr-input-accept',
         expects: [

package/lib/directive.d.ts

@@ -1,17 +1,3 @@
 import type { Result, Directive, Defs } from './types.js';
 import type { ReadonlyDeep } from 'type-fest';
-/**
- * Checks a value against a directive type definition.
- *
- * A directive type consists of a prefix pattern (string or regex) followed by
- * a token value. This function extracts the token portion after the directive
- * prefix and validates it against the token type.
- *
- * @param value - The string value to check
- * @param type - The directive type definition containing directive patterns and token type
- * @param defs - The type definitions registry for resolving nested types
- * @param ref - Optional reference URL for the unmatched result
- * @param cache - Whether to use cached results (defaults to `true`)
- * @returns The validation result
- */
 export declare function checkDirective(value: string, type: ReadonlyDeep<Directive>, defs: Defs, ref?: string, cache?: boolean): Result;

package/lib/directive.js

@@ -1,20 +1,6 @@
 import { regexParser } from '@markuplint/shared';
 import { checkBase } from './check-base.js';
 import { matched, unmatched } from './match-result.js';
-/**
- * Checks a value against a directive type definition.
- *
- * A directive type consists of a prefix pattern (string or regex) followed by
- * a token value. This function extracts the token portion after the directive
- * prefix and validates it against the token type.
- *
- * @param value - The string value to check
- * @param type - The directive type definition containing directive patterns and token type
- * @param defs - The type definitions registry for resolving nested types
- * @param ref - Optional reference URL for the unmatched result
- * @param cache - Whether to use cached results (defaults to `true`)
- * @returns The validation result
- */
 export function checkDirective(value, type, defs, ref, cache = true) {
     const unmatches = [];
     for (const directive of type.directive) {

package/lib/enum.d.ts

@@ -1,15 +1,4 @@
 import type { Result } from './types.js';
 import type { Enum } from './types.schema.js';
 import type { ReadonlyDeep } from 'type-fest';
-/**
- * Checks whether a value matches one of the allowed enumeration values.
- *
- * By default, comparison is case-insensitive and surrounding spaces are not allowed.
- * These behaviors can be configured through the type definition.
- *
- * @param value - The string value to check
- * @param type - The enum type definition containing the allowed values and options
- * @param ref - Optional reference URL for the unmatched result
- * @returns The validation result
- */
 export declare function checkEnum(value: string, type: ReadonlyDeep<Enum>, ref?: string): Result;

package/lib/enum.js

@@ -1,15 +1,4 @@
 import { matched, unmatched } from './match-result.js';
-/**
- * Checks whether a value matches one of the allowed enumeration values.
- *
- * By default, comparison is case-insensitive and surrounding spaces are not allowed.
- * These behaviors can be configured through the type definition.
- *
- * @param value - The string value to check
- * @param type - The enum type definition containing the allowed values and options
- * @param ref - Optional reference URL for the unmatched result
- * @returns The validation result
- */
 export function checkEnum(value, type, ref) {
     const disallowToSurroundBySpaces = type.disallowToSurroundBySpaces ?? true;
     const caseInsensitive = type.caseInsensitive ?? true;

package/lib/keyword-type.d.ts

@@ -1,16 +1,3 @@
 import type { Defs, Result } from './types.js';
 import type { KeywordDefinedType } from './types.schema.js';
-/**
- * Checks a value against a keyword-defined type or CSS syntax type.
- *
- * Looks up the type in the definitions registry and validates the value.
- * If the type is not found in custom definitions, falls back to CSS syntax matching.
- * Results are cached by default for performance.
- *
- * @param value - The string value to check
- * @param type - The keyword type identifier to look up
- * @param defs - The type definitions registry
- * @param cache - Whether to use cached results (defaults to `true`)
- * @returns The validation result
- */
 export declare function checkKeywordType(value: string, type: KeywordDefinedType, defs: Defs, cache?: boolean): Result;

package/lib/keyword-type.js

@@ -4,19 +4,6 @@ import { log } from './debug.js';
 import { matched } from './match-result.js';
 const resultCache = new Map();
 const CACHE_KEY_PREFIX = '@markuplint/types/checkKeywordType/cache:::';
-/**
- * Checks a value against a keyword-defined type or CSS syntax type.
- *
- * Looks up the type in the definitions registry and validates the value.
- * If the type is not found in custom definitions, falls back to CSS syntax matching.
- * Results are cached by default for performance.
- *
- * @param value - The string value to check
- * @param type - The keyword type identifier to look up
- * @param defs - The type definitions registry
- * @param cache - Whether to use cached results (defaults to `true`)
- * @returns The validation result
- */
 export function checkKeywordType(value, type, defs, cache = true) {
     const key = `${CACHE_KEY_PREFIX}${value}${type}`;
     if (cache) {

package/lib/list.d.ts

@@ -1,17 +1,4 @@
 import type { Defs, Result } from './types.js';
 import type { List } from './types.schema.js';
 import type { ReadonlyDeep } from 'type-fest';
-/**
- * Checks a value as a separated list of tokens against a type definition.
- *
- * Parses the value into tokens based on the list separator configuration,
- * then validates each individual token against the list's token type.
- *
- * @param value - The string value to check as a list
- * @param type - The list type definition containing separator and token type
- * @param defs - The type definitions registry for resolving nested types
- * @param ref - Optional reference URL for the unmatched result
- * @param cache - Whether to use cached results (defaults to `true`)
- * @returns The validation result
- */
 export declare function checkList(value: string, type: ReadonlyDeep<List>, defs: Defs, ref?: string, cache?: boolean): Result;

package/lib/list.js

@@ -1,19 +1,6 @@
 import { checkBase } from './check-base.js';
 import { matched } from './match-result.js';
 import { Token, TokenCollection } from './token/index.js';
-/**
- * Checks a value as a separated list of tokens against a type definition.
- *
- * Parses the value into tokens based on the list separator configuration,
- * then validates each individual token against the list's token type.
- *
- * @param value - The string value to check as a list
- * @param type - The list type definition containing separator and token type
- * @param defs - The type definitions registry for resolving nested types
- * @param ref - Optional reference URL for the unmatched result
- * @param cache - Whether to use cached results (defaults to `true`)
- * @returns The validation result
- */
 export function checkList(value, type, defs, ref, cache = true) {
     const tokens = new TokenCollection(value, type);
     const matches = tokens.check({ ref });

package/lib/match-result.d.ts

@@ -1,30 +1,9 @@
 import type { FormattedPrimitiveTypeCheck, MatchedResult, UnmatchedResult, UnmatchedResultOptions, UnmatchedResultReason } from './types.js';
-/**
- * Creates a value checker function that wraps a primitive type check
- * and returns a matched or unmatched result.
- *
- * @param checker - The primitive type check function to wrap
- * @param options - Optional settings for the unmatched result including ref and reason
- * @returns A function that takes a string value and returns a match result
- */
 export declare function matches(checker: FormattedPrimitiveTypeCheck, options?: UnmatchedResultOptions & {
     readonly ref?: string;
     readonly reason?: UnmatchedResultReason;
 }): (value: string) => MatchedResult | UnmatchedResult;
-/**
- * Creates a successful match result.
- *
- * @returns A matched result object
- */
 export declare function matched(): MatchedResult;
-/**
- * Creates a failed match result with location and reason information.
- *
- * @param value - The raw string value that failed to match
- * @param reason - The reason for the mismatch
- * @param options - Optional settings including ref URL and expected values
- * @returns An unmatched result object with position details
- */
 export declare function unmatched(value: string, reason?: UnmatchedResultReason, options?: UnmatchedResultOptions & {
     readonly ref?: string;
 }): UnmatchedResult;