@markuplint/types 1.0.0-dev.20211213.0

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkYearString = void 0;
+const debug_1 = require("../../debug");
+const token_1 = require("../../token");
+const datetime_tokens_1 = require("./datetime-tokens");
+/**
+ * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html
+ */
+const checkYearString = () => function checkYearString(value) {
+    (0, debug_1.log)('CHECK: year-string');
+    const tokens = token_1.TokenCollection.fromPatterns(value, [/.*/]);
+    (0, debug_1.log)('Year: "%s" => %O', tokens.value, tokens);
+    const res = tokens.eachCheck(datetime_tokens_1.datetimeTokenCheck.year, datetime_tokens_1.datetimeTokenCheck.extra);
+    if (!res.matched) {
+        (0, debug_1.log)('Failed: %O', res);
+    }
+    return res;
+};
+exports.checkYearString = checkYearString;

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

@@ -0,0 +1,5 @@
+import type { CustomSyntaxChecker } from '../../types';
+/**
+ * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#yearless-dates
+ */
+export declare const checkYearlessDateString: CustomSyntaxChecker;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkYearlessDateString = void 0;
+const debug_1 = require("../../debug");
+const token_1 = require("../../token");
+const datetime_tokens_1 = require("./datetime-tokens");
+/**
+ * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#yearless-dates
+ */
+const checkYearlessDateString = () => function checkYearlessDateString(value) {
+    (0, debug_1.log)('CHECK: yearless-date-string');
+    const tokens = token_1.TokenCollection.fromPatterns(value, [
+        // MM
+        /[^-]*/,
+        // -
+        /[^0-9]?/,
+        // DD
+        /.[0-9]*/,
+    ]);
+    (0, debug_1.log)('Yearless Date: "%s" => %O', tokens.value, tokens);
+    const res = tokens.eachCheck(datetime_tokens_1.datetimeTokenCheck.month, datetime_tokens_1.datetimeTokenCheck.hyphen, datetime_tokens_1.datetimeTokenCheck.date, datetime_tokens_1.datetimeTokenCheck.extra);
+    if (!res.matched) {
+        (0, debug_1.log)('Failed: %O', res);
+    }
+    return res;
+};
+exports.checkYearlessDateString = checkYearlessDateString;

package/lib/whatwg/check-mime-type.d.ts

@@ -0,0 +1,11 @@
+import type { CustomSyntaxChecker } from '../types';
+/**
+ * MIME Type
+ * @see https://mimesniff.spec.whatwg.org/#valid-mime-type
+ */
+export declare const checkMIMEType: CustomSyntaxChecker<{
+    /**
+     * @see https://mimesniff.spec.whatwg.org/#valid-mime-type-with-no-parameters
+     */
+    withoutParameters?: boolean;
+}>;

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMIMEType = void 0;
+const tslib_1 = require("tslib");
+// @ts-ignore
+const whatwg_mimetype_1 = (0, tslib_1.__importDefault)(require("whatwg-mimetype"));
+const match_result_1 = require("../match-result");
+const token_1 = require("../token");
+const expects = (withoutParameters) => [
+    {
+        type: 'format',
+        value: withoutParameters ? 'MIME Type with no parameters' : 'MIME Type',
+    },
+];
+/**
+ * MIME Type
+ * @see https://mimesniff.spec.whatwg.org/#valid-mime-type
+ */
+const checkMIMEType = options => value => {
+    var _a;
+    const withoutParameters = (_a = options === null || options === void 0 ? void 0 : options.withoutParameters) !== null && _a !== void 0 ? _a : false;
+    if (!value) {
+        return (0, match_result_1.unmatched)(value, 'empty-token', { expects: expects(withoutParameters) });
+    }
+    const mimeType = whatwg_mimetype_1.default.parse(value);
+    if (mimeType) {
+        if (value.toLowerCase() === mimeType.essence) {
+            return (0, match_result_1.matched)();
+        }
+        if (!withoutParameters && mimeType.parameters.size) {
+            return (0, match_result_1.matched)();
+        }
+        const extraToken = value.slice(mimeType.essence.length);
+        return new token_1.Token(extraToken, mimeType.essence.length, value).unmatched({
+            reason: 'extra-token',
+            expects: expects(withoutParameters),
+            candicate: mimeType.essence,
+        });
+    }
+    return (0, match_result_1.unmatched)(value, 'syntax-error', { expects: expects(withoutParameters) });
+};
+exports.checkMIMEType = checkMIMEType;

package/lib/whatwg/check-mime-type.spec.d.ts

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

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const check_mime_type_1 = require("./check-mime-type");
+const check = (0, check_mime_type_1.checkMIMEType)();
+const checkNoParam = (0, check_mime_type_1.checkMIMEType)({ withoutParameters: true });
+test('valid', () => {
+    expect(check('x/y').matched).toBe(true);
+    expect(check('x/y;a=b;c=D;E="F"').matched).toBe(true);
+});
+test('excrescence-token', () => {
+    expect(check('xy;')).toStrictEqual({
+        column: 1,
+        expects: [{ type: 'format', value: 'MIME Type' }],
+        length: 3,
+        line: 1,
+        matched: false,
+        offset: 0,
+        raw: 'xy;',
+        reason: 'syntax-error',
+        ref: null,
+    });
+    expect(check('x/y;')).toStrictEqual({
+        candicate: 'x/y',
+        column: 4,
+        expects: [{ type: 'format', value: 'MIME Type' }],
+        length: 1,
+        line: 1,
+        matched: false,
+        offset: 3,
+        raw: ';',
+        reason: 'extra-token',
+        ref: null,
+    });
+    expect(checkNoParam('x/y;')).toStrictEqual({
+        candicate: 'x/y',
+        column: 4,
+        expects: [{ type: 'format', value: 'MIME Type with no parameters' }],
+        length: 1,
+        line: 1,
+        matched: false,
+        offset: 3,
+        raw: ';',
+        reason: 'extra-token',
+        ref: null,
+    });
+    expect(checkNoParam('x/y;a=b;c=D;E="F"')).toStrictEqual({
+        candicate: 'x/y',
+        column: 4,
+        expects: [{ type: 'format', value: 'MIME Type with no parameters' }],
+        length: 14,
+        line: 1,
+        matched: false,
+        offset: 3,
+        raw: ';a=b;c=D;E="F"',
+        reason: 'extra-token',
+        ref: null,
+    });
+});

package/lib/whatwg/is-abs-url.d.ts

@@ -0,0 +1,15 @@
+import type { FormattedPrimitiveTypeCreator } from '../types';
+/**
+ * @see https://url.spec.whatwg.org/#syntax-url-absolute
+ *
+ * > An absolute-URL string must be one of the following:
+ * > - a URL-scheme string that is an ASCII case-insensitive match
+ * >   for a special scheme and not an ASCII case-insensitive match for "file",
+ * >   followed by U+003A (:) and a scheme-relative-special-URL string
+ * > - a URL-scheme string that is not an ASCII case-insensitive match
+ * >   for a special scheme, followed by U+003A (:) and a relative-URL string
+ * > - a URL-scheme string that is an ASCII case-insensitive match for "file",
+ * >   followed by U+003A (:) and a scheme-relative-file-URL string
+ *
+ */
+export declare const isAbsURL: FormattedPrimitiveTypeCreator;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAbsURL = void 0;
+/**
+ * @see https://url.spec.whatwg.org/#syntax-url-absolute
+ *
+ * > An absolute-URL string must be one of the following:
+ * > - a URL-scheme string that is an ASCII case-insensitive match
+ * >   for a special scheme and not an ASCII case-insensitive match for "file",
+ * >   followed by U+003A (:) and a scheme-relative-special-URL string
+ * > - a URL-scheme string that is not an ASCII case-insensitive match
+ * >   for a special scheme, followed by U+003A (:) and a relative-URL string
+ * > - a URL-scheme string that is an ASCII case-insensitive match for "file",
+ * >   followed by U+003A (:) and a scheme-relative-file-URL string
+ *
+ */
+const isAbsURL = () => {
+    return value => {
+        try {
+            new URL(value);
+        }
+        catch (e) {
+            if (e && typeof e === 'object' && 'code' in e) {
+                // @ts-ignore
+                if (e.code === 'ERR_INVALID_URL') {
+                    return false;
+                }
+            }
+            throw e;
+        }
+        return true;
+    };
+};
+exports.isAbsURL = isAbsURL;

package/lib/whatwg/is-abs-url.spec.d.ts

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

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_abs_url_1 = require("./is-abs-url");
+const is = (0, is_abs_url_1.isAbsURL)();
+test('valid', () => {
+    expect(is('https://markuplint.dev')).toBe(true);
+    expect(is('markuplint.dev')).toBe(false);
+});

package/lib/whatwg/is-browser-context-name.d.ts

@@ -0,0 +1,11 @@
+import type { FormattedPrimitiveTypeCreator } from '../types';
+/**
+ *
+ * @see https://html.spec.whatwg.org/multipage/browsers.html#valid-browsing-context-name
+ *
+ * > A valid browsing context name is any string with at least one character
+ * > that does not start with a U+005F LOW LINE character.
+ * > (Names starting with an underscore are reserved for special keywords.)
+ *
+ */
+export declare const isBrowserContextName: FormattedPrimitiveTypeCreator;

package/lib/whatwg/is-browser-context-name.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBrowserContextName = void 0;
+/**
+ *
+ * @see https://html.spec.whatwg.org/multipage/browsers.html#valid-browsing-context-name
+ *
+ * > A valid browsing context name is any string with at least one character
+ * > that does not start with a U+005F LOW LINE character.
+ * > (Names starting with an underscore are reserved for special keywords.)
+ *
+ */
+const isBrowserContextName = () => {
+    return value => {
+        return !!value && value[0] !== '_';
+    };
+};
+exports.isBrowserContextName = isBrowserContextName;

package/lib/whatwg/is-custom-element-name.d.ts

@@ -0,0 +1,22 @@
+import type { FormattedPrimitiveTypeCreator } from '../types';
+/**
+ * valid name of custom element
+ *
+ * @see https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
+ *
+ * > - name must match the [PotentialCustomElementName](https://html.spec.whatwg.org/multipage/custom-elements.html#prod-potentialcustomelementname) production
+ * > - name must not be any of the following:
+ * >   - `<annotation-xml>`
+ * >   - `<color-profile>`
+ * >   - `<font-face>`
+ * >   - `<font-face-src>`
+ * >   - `<font-face-uri>`
+ * >   - `<font-face-format>`
+ * >   - `<font-face-name>`
+ * >   - `<missing-glyph>`
+ *
+ * ASCII-case-insensitively.
+ * Originally, it is not possible to define a name including ASCII upper alphas in the custom element, but it is not treated as illegal by the HTML parser.
+ *
+ */
+export declare const isCustomElementName: FormattedPrimitiveTypeCreator;

package/lib/whatwg/is-custom-element-name.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCustomElementName = void 0;
+/**
+ * PotentialCustomElementName
+ *
+ * @see https://html.spec.whatwg.org/multipage/custom-elements.html#prod-potentialcustomelementname
+ *
+ * > PotentialCustomElementName ::=
+ * >   [a-z] (PCENChar)* '-' (PCENChar)*
+ * > PCENChar ::=
+ * >   "-" | "." | [0-9] | "_" | [a-z] | #xB7 | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x37D] |
+ * >   [#x37F-#x1FFF] | [#x200C-#x200D] | [#x203F-#x2040] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
+ * > This uses the EBNF notation from the XML specification. [XML]
+ *
+ * ASCII-case-insensitively.
+ * Originally, it is not possible to define a name including ASCII upper alphas in the custom element, but it is not treated as illegal by the HTML parser.
+ */
+const rePCENChar = [
+    '\\-',
+    '\\.',
+    '[0-9]',
+    '_',
+    '[a-z]',
+    '\u00B7',
+    '[\u00C0-\u00D6]',
+    '[\u00D8-\u00F6]',
+    '[\u00F8-\u037D]',
+    '[\u037F-\u1FFF]',
+    '[\u200C-\u200D]',
+    '[\u203F-\u2040]',
+    '[\u2070-\u218F]',
+    '[\u2C00-\u2FEF]',
+    '[\u3001-\uD7FF]',
+    '[\uF900-\uFDCF]',
+    '[\uFDF0-\uFFFD]',
+    '[\uD800-\uDBFF][\uDC00-\uDFFF]',
+].join('|');
+const rePCEN = new RegExp(`^[a-z](?:${rePCENChar})*\\-(?:${rePCENChar})*$`, 'i');
+/**
+ * valid name of custom element
+ *
+ * @see https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
+ *
+ * > - name must match the [PotentialCustomElementName](https://html.spec.whatwg.org/multipage/custom-elements.html#prod-potentialcustomelementname) production
+ * > - name must not be any of the following:
+ * >   - `<annotation-xml>`
+ * >   - `<color-profile>`
+ * >   - `<font-face>`
+ * >   - `<font-face-src>`
+ * >   - `<font-face-uri>`
+ * >   - `<font-face-format>`
+ * >   - `<font-face-name>`
+ * >   - `<missing-glyph>`
+ *
+ * ASCII-case-insensitively.
+ * Originally, it is not possible to define a name including ASCII upper alphas in the custom element, but it is not treated as illegal by the HTML parser.
+ *
+ */
+const isCustomElementName = () => {
+    return tagName => {
+        switch (tagName) {
+            case 'annotation-xml':
+            case 'color-profile':
+            case 'font-face':
+            case 'font-face-src':
+            case 'font-face-uri':
+            case 'font-face-format':
+            case 'font-face-name':
+            case 'missing-glyph': {
+                return false;
+            }
+        }
+        return rePCEN.test(tagName);
+    };
+};
+exports.isCustomElementName = isCustomElementName;

package/lib/whatwg/is-itemprop-name.d.ts

@@ -0,0 +1,12 @@
+import type { FormattedPrimitiveTypeCreator } from '../types';
+/**
+ *
+ * @see https://html.spec.whatwg.org/multipage/microdata.html#defined-property-name
+ *
+ * > The rules above disallow U+003A COLON characters (:) in non-URL values
+ * > because otherwise they could not be distinguished from URLs.
+ * > Values with U+002E FULL STOP characters (.) are reserved for future extensions.
+ * > ASCII whitespace are disallowed because otherwise the values would be parsed as multiple tokens.
+ *
+ */
+export declare const isItempropName: FormattedPrimitiveTypeCreator;

package/lib/whatwg/is-itemprop-name.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isItempropName = void 0;
+/**
+ *
+ * @see https://html.spec.whatwg.org/multipage/microdata.html#defined-property-name
+ *
+ * > The rules above disallow U+003A COLON characters (:) in non-URL values
+ * > because otherwise they could not be distinguished from URLs.
+ * > Values with U+002E FULL STOP characters (.) are reserved for future extensions.
+ * > ASCII whitespace are disallowed because otherwise the values would be parsed as multiple tokens.
+ *
+ */
+const isItempropName = () => {
+    return value => {
+        return value.indexOf(':') === -1 && value.indexOf('.') === -1 && value.indexOf(' ') === -1;
+    };
+};
+exports.isItempropName = isItempropName;

package/package.json

@@ -0,0 +1,33 @@
+{
+	"name": "@markuplint/types",
+	"version": "1.0.0-dev.20211213.0",
+	"description": "Types of attributes and properties and more",
+	"repository": "git@github.com:markuplint/markuplint.git",
+	"author": "Yusuke Hirao <yusukehirao@me.com>",
+	"license": "MIT",
+	"private": false,
+	"main": "lib/index.js",
+	"types": "lib/index.d.ts",
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "tsc",
+		"clean": "tsc --build --clean",
+		"schema": "ts-node './gen/types.ts'; json2ts './types.schema.json' > './src/types.schema.ts'; prettier './src/types.schema.ts' './types.schema.json' --write; eslint './src/types.schema.ts' --fix; tsc;"
+	},
+	"dependencies": {
+		"bcp-47": "1",
+		"css-tree": "^1.1.3",
+		"debug": "^4.3.2",
+		"leven": "3",
+		"whatwg-mimetype": "2"
+	},
+	"devDependencies": {
+		"@types/bcp-47": "1",
+		"@types/css-tree": "^1.0.7",
+		"@types/debug": "^4.1.7",
+		"@types/whatwg-mimetype": "^2.1.1"
+	},
+	"gitHead": "8f4682ca3e0937082af8c39b999443afa4a1aef3"
+}

package/src/check-multi-types.ts

@@ -0,0 +1,35 @@
+import type { CustomSyntaxCheck, UnmatchedResult } from './types';
+
+import { log } from './debug';
+import { matched } from './match-result';
+
+export function checkMultiTypes(value: string, checks: CustomSyntaxCheck[]) {
+	let unmatched: UnmatchedResult | undefined;
+
+	for (const check of checks) {
+		const res = check(value);
+		if (res.matched) {
+			return res;
+		}
+
+		// @ts-ignore
+		res._fn = check.name;
+
+		// @ts-ignore
+		log('%s(%d) vs %s(%d)', unmatched?._fn, unmatched?.passCount, res._fn, res.passCount);
+		const passedA = unmatched?.passCount || 0;
+		const passedB = res.passCount || 0;
+		const offsetA = unmatched?.offset || 0;
+		const offsetB = res.offset;
+
+		if (passedA < passedB || (passedA === passedB && offsetA <= offsetB)) {
+			unmatched = res;
+		}
+	}
+
+	const result = unmatched || matched();
+
+	log('%d checks result: %O', checks.length, result);
+
+	return result;
+}

package/src/check.spec.ts

@@ -0,0 +1,62 @@
+import { check } from './check';
+
+test('Any', () => {
+	expect(check('', 'Any').matched).toBe(true);
+	expect(check(' ', 'Any').matched).toBe(true);
+	expect(check('a', 'Any').matched).toBe(true);
+});
+
+test('NoEmptyAny', () => {
+	expect(check('', 'NoEmptyAny').matched).toBe(false);
+	expect(check(' ', 'NoEmptyAny').matched).toBe(true);
+	expect(check('a', 'NoEmptyAny').matched).toBe(true);
+});
+
+test('OneLineAny', () => {
+	expect(check('', 'OneLineAny').matched).toBe(true);
+	expect(check(' ', 'OneLineAny').matched).toBe(true);
+	expect(check('a', 'OneLineAny').matched).toBe(true);
+	expect(check('a ', 'OneLineAny').matched).toBe(true);
+	expect(check('a b', 'OneLineAny').matched).toBe(true);
+	expect(check('a\n', 'OneLineAny').matched).toBe(false);
+	expect(check('a\nb', 'OneLineAny').matched).toBe(false);
+	expect(check('a\r\nb', 'OneLineAny').matched).toBe(false);
+	expect(check('a\rb', 'OneLineAny').matched).toBe(false);
+});
+
+test('Pattern', () => {
+	expect(check('.*', 'Pattern').matched).toBe(true);
+	expect(check('[a-z]+', 'Pattern').matched).toBe(true);
+	expect(check(']//[()?!+*', 'Pattern').matched).toBe(false);
+});
+
+test('BCP47', () => {
+	expect(check('en', 'BCP47').matched).toBe(true);
+	expect(check('en-US', 'BCP47').matched).toBe(true);
+	expect(check('ja', 'BCP47').matched).toBe(true);
+	expect(check(' ja ', 'BCP47').matched).toBe(false);
+	expect(check('', 'BCP47').matched).toBe(false);
+	expect(check('zh/cn', 'BCP47').matched).toBe(false);
+});
+
+test('Srcset', () => {
+	expect(check('a/bb/ccc/dddd', 'Srcset').matched).toBe(true);
+	expect(check('a/bb/ccc/dddd 200w', 'Srcset').matched).toBe(true);
+	expect(check('a/bb/ccc/dddd 200w, b/cc/ddd/eeee 1.5x', 'Srcset').matched).toBe(true);
+	expect(check('a/bb/ccc/dddd 200w, b/cc/ddd/eeee 1.5a', 'Srcset').matched).toBe(false);
+});
+
+test('Srcset', () => {
+	expect(check('any', 'IconSize').matched).toBe(true);
+	expect(check('Any', 'IconSize').matched).toBe(true);
+	expect(check('10x10', 'IconSize').matched).toBe(true);
+	expect(check('1x1', 'IconSize').matched).toBe(true);
+	expect(check('1x0', 'IconSize').matched).toBe(false);
+	expect(check('0x1', 'IconSize').matched).toBe(false);
+	expect(check('0x0', 'IconSize').matched).toBe(false);
+	expect(check('', 'IconSize').matched).toBe(false);
+	expect(check(' ', 'IconSize').matched).toBe(false);
+	expect(check('1', 'IconSize').matched).toBe(false);
+	expect(check('1x', 'IconSize').matched).toBe(false);
+	expect(check('x1', 'IconSize').matched).toBe(false);
+});

package/src/check.ts

@@ -0,0 +1,48 @@
+import type { Type, Result, List, CustomSyntax, CustomCssSyntax, Enum, KeywordDefinedType, Number } from './types';
+
+import { log } from './debug';
+import { checkEnum } from './enum';
+import { checkKeywordType } from './keyword-type';
+import { checkList } from './list';
+import { checkNumber } from './number';
+
+export function check(value: string, type: Type, ref?: string, cache = true): Result {
+	if (isKeyword(type)) {
+		log('Check keyword: %s', type);
+		return checkKeywordType(value, type, cache);
+	}
+	if (isList(type)) {
+		log('Check list: %O', type);
+		return checkList(value, type, ref, cache);
+	}
+	if (isEnum(type)) {
+		log('Check enum: %O', type);
+		return checkEnum(value, type, ref);
+	}
+	log('Check number: %O', type);
+	return checkNumber(value, type, ref);
+}
+
+export function isKeyword(type: Type): type is KeywordDefinedType {
+	return typeof type === 'string';
+}
+
+export function isList(type: Type): type is List {
+	return typeof type !== 'string' && 'token' in type;
+}
+
+export function isEnum(type: Type): type is Enum {
+	return typeof type !== 'string' && 'enum' in type;
+}
+
+export function isNumber(type: Type): type is Number {
+	return typeof type !== 'string' && 'enum' in type;
+}
+
+export function isCSSSyntax(type: CustomSyntax | CustomCssSyntax): type is CustomCssSyntax {
+	return typeof type === 'string' || 'syntax' in type;
+}
+
+export function isCustomSyntax(type: CustomSyntax | CustomCssSyntax): type is CustomSyntax {
+	return !isCSSSyntax(type);
+}