@markuplint/types 1.0.0-dev.20211213.0

package/lib/w3c/check-serialized-permissions-policy.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSerializedPermissionsPolicy = void 0;
+const debug_1 = require("../debug");
+const match_result_1 = require("../match-result");
+const token_1 = require("../token");
+/**
+ * @see https://w3c.github.io/webappsec-permissions-policy/#serialized-permissions-policy
+ *
+ * > Policy Directives in HTML attributes are represented as their
+ * > ASCII serialization, with the following ABNF:
+ * > ```abnf
+ * > serialized-permissions-policy = serialized-policy-directive *(";" serialized-policy-directive)
+ * > serialized-policy-directive = feature-identifier RWS allow-list
+ * > feature-identifier = 1*( ALPHA / DIGIT / "-")
+ * > allow-list = allow-list-value *(RWS allow-list-value)
+ * > allow-list-value = serialized-origin / "*" / "'self'" / "'src'" / "'none'"
+ * > ```
+ */
+const checkSerializedPermissionsPolicy = () => value => {
+    const res = _checkSerializedPermissionsPolicy(value);
+    if (!res.matched) {
+        (0, debug_1.log)('Failed: %O', res);
+    }
+    return res;
+};
+exports.checkSerializedPermissionsPolicy = checkSerializedPermissionsPolicy;
+function _checkSerializedPermissionsPolicy(value) {
+    /**
+     * The list of serialized-policy-directive
+     *
+     * > ```abnf
+     * > serialized-policy-directive *(";" serialized-policy-directive)
+     * > ```
+     */
+    const patterns = [
+        /**
+         * serialized-policy-directive
+         */
+        /[^;]*/,
+        /**
+         * separator
+         */
+        /;?/,
+    ];
+    const tokens = token_1.TokenCollection.fromPatterns(value, patterns, { repeat: true });
+    const serializedPolicyDirectives = tokens.chunk(patterns.length);
+    (0, debug_1.log)('Serialized Permissions Policy: %s => %O', value, serializedPolicyDirectives);
+    for (const [serializedPolicyDirective] of serializedPolicyDirectives) {
+        if (!serializedPolicyDirective || !serializedPolicyDirective.value) {
+            return (0, match_result_1.unmatched)('', 'empty-token');
+        }
+        const [featureIdentifier, rws, allowListValue] = token_1.TokenCollection.fromPatterns(serializedPolicyDirective, [
+            /**
+             * feature-identifier
+             *
+             * > ```abnf
+             * > feature-identifier = 1*( ALPHA / DIGIT / "-")
+             * > ```
+             */
+            /[^\s]*/,
+            /**
+             * RWS (Required whitespace)
+             *
+             * @see https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.3
+             */
+            /\s*/,
+            /**
+             * allow-list-value
+             */
+            /.*/,
+        ]);
+        (0, debug_1.log)('Serialized Policy Directive: %s => %O', serializedPolicyDirective.value, {
+            featureIdentifier,
+            rws,
+            allowListValue,
+        });
+        /**
+         * > ```abnf
+         * > feature-identifier = 1*( ALPHA / DIGIT / "-")
+         * > ```
+         */
+        if (!featureIdentifier || !featureIdentifier.match(/^[a-z0-9-]+$/i)) {
+            return featureIdentifier.unmatched({
+                reason: 'unexpected-token',
+                expects: [{ type: 'common', value: 'feature-identifier' }],
+                partName: 'feature-identifier',
+            });
+        }
+        if (!rws || !rws.value) {
+            return (0, match_result_1.unmatched)('', 'missing-token', {
+                expects: [{ type: 'common', value: 'whitespace' }],
+                partName: 'directive',
+            });
+        }
+        if (!allowListValue || !allowListValue.value) {
+            return (0, match_result_1.unmatched)('', 'missing-token', {
+                expects: [{ type: 'common', value: 'allow-list' }],
+                partName: 'allow-list',
+            });
+        }
+        const allowListPatterns = [
+            // Value
+            /[^\s]*/,
+            // Separator
+            /\s*/,
+        ];
+        const allowListTokens = token_1.TokenCollection.fromPatterns(allowListValue, allowListPatterns, { repeat: true });
+        const allowList = allowListTokens.chunk(allowListPatterns.length);
+        (0, debug_1.log)('Allow List: %s => %O', allowListTokens.value, allowList);
+        for (const [allow] of allowList) {
+            if (!allow || !allow.value) {
+                return (0, match_result_1.unmatched)('', 'missing-token', {
+                    expects: [
+                        { type: 'const', value: '*' },
+                        { type: 'const', value: "'self'" },
+                        { type: 'const', value: "'src'" },
+                        { type: 'const', value: "'none'" },
+                        { type: 'common', value: 'serialized-origin' },
+                    ],
+                    partName: 'allow-list',
+                });
+            }
+            const origin = checkSerializedOrigin(allow);
+            if (origin.matched) {
+                continue;
+            }
+            if (origin.reason !== 'syntax-error') {
+                return origin;
+            }
+            if (allow.match(['*', "'self'", "'src'", "'none'"], true)) {
+                continue;
+            }
+            if (allow.match(['self', 'src', 'none'], true)) {
+                return allow.unmatched({
+                    reason: 'missing-token',
+                    expects: [{ type: 'common', value: 'single-quote' }],
+                    partName: 'keyword',
+                });
+            }
+            return allow.unmatched({
+                reason: 'unexpected-token',
+                expects: [
+                    { type: 'const', value: '*' },
+                    { type: 'const', value: "'self'" },
+                    { type: 'const', value: "'src'" },
+                    { type: 'const', value: "'none'" },
+                    { type: 'common', value: 'serialized-origin' },
+                ],
+                partName: 'allow-list',
+            });
+        }
+    }
+    return (0, match_result_1.matched)();
+}
+/**
+ * serialized-origin
+ *
+ * > serialized-origin is the serialization of an origin.
+ * > However, the code points U+0027 ('), U+0021 (*), U+002C (,)
+ * > and U+003B (;) MUST NOT appear in the serialization.
+ * > If they are required, they must be percent-encoded
+ * > as "%27", "%2A", "%2C" or "%3B", respectively.
+ */
+function checkSerializedOrigin(token) {
+    const url = parseUrl(token.value);
+    (0, debug_1.log)('Parse URL: "%s" => %O', token.value, url);
+    if (!url) {
+        return token.unmatched({
+            expects: [{ type: 'common', value: 'serialized-origin' }],
+        });
+    }
+    if (url.pathname && url.pathname !== '/') {
+        return token.unmatched({
+            reason: 'extra-token',
+            extra: { type: 'common', value: 'pathname' },
+            partName: 'serialized-origin',
+        });
+    }
+    if (url.search) {
+        return token.unmatched({
+            reason: 'extra-token',
+            extra: { type: 'common', value: 'query' },
+            partName: 'serialized-origin',
+        });
+    }
+    if (url.hash) {
+        return token.unmatched({
+            reason: 'extra-token',
+            extra: { type: 'common', value: 'hash' },
+            partName: 'serialized-origin',
+        });
+    }
+    if (url.username) {
+        return token.unmatched({
+            reason: 'extra-token',
+            extra: { type: 'common', value: 'username' },
+            partName: 'serialized-origin',
+        });
+    }
+    if (url.password) {
+        return token.unmatched({
+            reason: 'extra-token',
+            extra: { type: 'common', value: 'password' },
+            partName: 'serialized-origin',
+        });
+    }
+    if (!token.value.includes(url.host)) {
+        return token.unmatched({
+            reason: 'must-be-serialized',
+            partName: 'serialized-origin',
+        });
+    }
+    if (token.includes("'")) {
+        return token.unmatched({
+            expects: [{ type: 'const', value: '%27' }],
+            reason: 'must-be-percent-encoded',
+            partName: 'serialized-origin',
+        });
+    }
+    if (token.includes('*')) {
+        return token.unmatched({
+            expects: [{ type: 'const', value: '%2A' }],
+            reason: 'must-be-percent-encoded',
+            partName: 'serialized-origin',
+        });
+    }
+    if (token.includes(',')) {
+        return token.unmatched({
+            expects: [{ type: 'const', value: '%2C' }],
+            reason: 'must-be-percent-encoded',
+            partName: 'serialized-origin',
+        });
+    }
+    if (token.includes(';')) {
+        return token.unmatched({
+            expects: [{ type: 'const', value: '%3B' }],
+            reason: 'must-be-percent-encoded',
+            partName: 'serialized-origin',
+        });
+    }
+    return (0, match_result_1.matched)();
+}
+function parseUrl(value) {
+    try {
+        return new URL(value);
+    }
+    catch {
+        return null;
+    }
+}

package/lib/w3c/check-serialized-permissions-policy.spec.d.ts

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

package/lib/w3c/check-serialized-permissions-policy.spec.js

@@ -0,0 +1,26 @@
+"use strict";
+// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+const check_serialized_permissions_policy_1 = require("./check-serialized-permissions-policy");
+const check = (0, check_serialized_permissions_policy_1.checkSerializedPermissionsPolicy)();
+test('checkSerializedPermissionsPolicy', () => {
+    expect(check('').reason).toBe('empty-token');
+    expect(check(' ').reason).toBe('unexpected-token');
+    expect(check('a').reason).toBe('missing-token');
+    expect(check('a:').reason).toBe('unexpected-token');
+    expect(check('a ').reason).toBe('missing-token');
+    expect(check('a a').reason).toBe('unexpected-token');
+    expect(check('a *').matched).toBe(true);
+    expect(check('a *a').reason).toBe('unexpected-token');
+    expect(check('a none').reason).toBe('missing-token');
+    expect(check("a 'none'").matched).toBe(true);
+    expect(check('a https://markuplint.dev').matched).toBe(true);
+    expect(check('a https://markuplint.dev/path/to').reason).toBe('extra-token');
+    expect(check('a https://マルチバイト.abc.xyz').reason).toBe('must-be-serialized');
+    expect(check('a * https://markuplint.dev').matched).toBe(true);
+    expect(check("a * https://markuplint.dev 'none'").matched).toBe(true);
+    expect(check("a * https://markuplint.dev 'none';b").reason).toBe('missing-token');
+    expect(check("a * https://markuplint.dev 'none';b ").reason).toBe('missing-token');
+    expect(check("a * https://markuplint.dev 'none';b *").matched).toBe(true);
+    expect(check("a * https://markuplint.dev 'none';b *;c 'none'").matched).toBe(true);
+});

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

@@ -0,0 +1,5 @@
+import type { CustomSyntaxChecker } from '../types';
+/**
+ * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-autocomplete
+ */
+export declare const checkAutoComplete: CustomSyntaxChecker;

package/lib/whatwg/check-autocomplete.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAutoComplete = void 0;
+const get_candicate_1 = require("../get-candicate");
+const match_result_1 = require("../match-result");
+const token_1 = require("../token");
+/**
+ * https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-autocomplete-section
+ */
+const namedGroup = /^section-/i;
+/**
+ * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-autocomplete-shipping
+ */
+const partOfAddress = ['shipping', 'billing'];
+/**
+ * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill-field
+ */
+const autofillFieldNames = [
+    'name',
+    'honorific-prefix',
+    'given-name',
+    'additional-name',
+    'family-name',
+    'honorific-suffix',
+    'nickname',
+    'username',
+    'new-password',
+    'current-password',
+    'one-time-code',
+    'organization-title',
+    'organization',
+    'street-address',
+    'address-line1',
+    'address-line2',
+    'address-line3',
+    'address-level4',
+    'address-level3',
+    'address-level2',
+    'address-level1',
+    'country',
+    'country-name',
+    'postal-code',
+    'cc-name',
+    'cc-given-name',
+    'cc-additional-name',
+    'cc-family-name',
+    'cc-number',
+    'cc-exp',
+    'cc-exp-month',
+    'cc-exp-year',
+    'cc-csc',
+    'cc-type',
+    'transaction-currency',
+    'transaction-amount',
+    'language',
+    'bday',
+    'bday-day',
+    'bday-month',
+    'bday-year',
+    'sex',
+    'url',
+    'photo',
+];
+/**
+ * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-autocomplete-home
+ */
+const contactingTokens = ['home', 'work', 'mobile', 'fax', 'pager'];
+/**
+ * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofilling-form-controls:-the-autocomplete-attribute:ascii-case-insensitive-7
+ */
+const contactableFieldNames = [
+    'tel',
+    'tel-country-code',
+    'tel-national',
+    'tel-area-code',
+    'tel-local',
+    'tel-local-prefix',
+    'tel-local-suffix',
+    'tel-extension',
+    'email',
+    'impp',
+];
+const URL_AUTOCOMPLET = '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';
+/**
+ * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-autocomplete
+ */
+const checkAutoComplete = () => value => {
+    let hasNamedGroup = false;
+    let hasPartOfAddress = false;
+    let hasContactingToken = false;
+    const tokens = new token_1.TokenCollection(value, {
+        disallowToSurroundBySpaces: false,
+        allowEmpty: false,
+        ordered: true,
+        unique: true,
+        caseInsensitive: true,
+    });
+    const listingChecked = tokens.check({
+        expects: [
+            {
+                type: 'format',
+                value: 'autocomplete',
+            },
+        ],
+        ref: URL_AUTOCOMPLET,
+    });
+    if (!listingChecked.matched) {
+        return listingChecked;
+    }
+    const idents = tokens.getIdentTokens();
+    const headAndTail1 = idents.headAndTail();
+    let { head, tail } = headAndTail1;
+    if (!head) {
+        // Never
+        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.match(['on', 'off'], true)) {
+        if (tail.length) {
+            return tail[0].unmatched({
+                reason: 'extra-token',
+                expects: [
+                    {
+                        type: 'format',
+                        value: 'autocomplete',
+                    },
+                ],
+                ref: URL_ON_OFF,
+            });
+        }
+        return (0, match_result_1.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.match(namedGroup, true)) {
+        hasNamedGroup = true;
+        const sectionToken = tail.search(namedGroup);
+        if (sectionToken) {
+            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 (0, match_result_1.matched)();
+        }
+    }
+    // > 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.match(partOfAddress, true)) {
+        hasPartOfAddress = true;
+        const partToken = tail.search(partOfAddress);
+        if (partToken) {
+            return partToken.unmatched({
+                reason: 'duplicated',
+                expects: [
+                    {
+                        type: 'format',
+                        value: 'autocomplete',
+                    },
+                ],
+                ref: URL_PART_OF_ADDRESS,
+            });
+        }
+        const headAndTail3 = tail.headAndTail();
+        head = headAndTail3.head;
+        tail = headAndTail3.tail;
+        if (!head) {
+            // Missing autofill field name but it is valid
+            return (0, match_result_1.matched)();
+        }
+    }
+    if (head.match(contactingTokens, true)) {
+        hasContactingToken = true;
+        const contactableFiledToken = tail[0];
+        if (!contactableFiledToken) {
+            // Missing autofill field name but it is valid
+            return (0, match_result_1.matched)();
+        }
+        if (!contactableFiledToken.match(contactableFieldNames, true)) {
+            const candicate = (0, get_candicate_1.getCandicate)(contactableFiledToken.value, contactableFieldNames);
+            return contactableFiledToken.unmatched({
+                reason: 'unexpected-token',
+                expects: contactableFieldNames.slice().map(token => ({
+                    type: 'const',
+                    value: token,
+                })),
+                candicate,
+                ref: URL_CONTACTABLE_FIELD,
+            });
+        }
+        if (tail[1]) {
+            return tail[1].unmatched({
+                reason: 'extra-token',
+                expects: [
+                    {
+                        type: 'format',
+                        value: 'autocomplete',
+                    },
+                ],
+                ref: URL_AUTOFILL_FIELD,
+            });
+        }
+        return (0, match_result_1.matched)();
+    }
+    if (head.match([...autofillFieldNames, ...contactableFieldNames], true)) {
+        if (tail.length) {
+            return tail[0].unmatched({
+                reason: 'extra-token',
+                expects: [
+                    {
+                        type: 'format',
+                        value: 'autocomplete',
+                    },
+                ],
+                ref: URL_AUTOFILL_FIELD,
+            });
+        }
+        return (0, match_result_1.matched)();
+    }
+    const expects = [
+        {
+            type: 'common',
+            value: 'autofill field name',
+        },
+    ];
+    let candicate;
+    if (!hasNamedGroup) {
+        expects.unshift({
+            type: 'common',
+            value: 'autofill named group',
+        });
+        // Potentially typo a named group
+        const [prefix, namedGroupStr] = head.value.split('-');
+        const candicatePrefix = (0, get_candicate_1.getCandicate)(prefix, 'section');
+        if (candicatePrefix) {
+            candicate = `${candicatePrefix}-${namedGroupStr || ''}`;
+        }
+    }
+    else if (!hasPartOfAddress) {
+        expects.unshift(...partOfAddress
+            .slice()
+            .reverse()
+            .map(token => ({
+            type: 'const',
+            value: token,
+        })));
+        candicate = (0, get_candicate_1.getCandicate)(head.value, partOfAddress, autofillFieldNames, contactingTokens, contactableFieldNames);
+    }
+    else if (!hasContactingToken) {
+        expects.push(...contactingTokens.slice().map(token => ({
+            type: 'const',
+            value: token,
+        })));
+        candicate = (0, get_candicate_1.getCandicate)(head.value, autofillFieldNames, contactingTokens, contactableFieldNames);
+    }
+    candicate = candicate || (0, get_candicate_1.getCandicate)(head.value, autofillFieldNames);
+    return head.unmatched({
+        reason: 'unexpected-token',
+        expects,
+        candicate,
+        ref: URL_AUTOFILL_FIELD,
+    });
+};
+exports.checkAutoComplete = checkAutoComplete;

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

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