@markuplint/types 3.5.0 → 3.6.0

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

@@ -1,59 +1,59 @@
-"use strict";
+'use strict';
 // @ts-nocheck
-Object.defineProperty(exports, "__esModule", { value: true });
-const check_mime_type_1 = require("./check-mime-type");
+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);
+	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({
-        candidate: '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({
-        candidate: '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({
-        candidate: '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,
-    });
+	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({
+		candidate: '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({
+		candidate: '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({
+		candidate: '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.spec.js

@@ -1,9 +1,9 @@
-"use strict";
+'use strict';
 // @ts-nocheck
-Object.defineProperty(exports, "__esModule", { value: true });
-const is_abs_url_1 = require("./is-abs-url");
+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);
+	expect(is('https://markuplint.dev')).toBe(true);
+	expect(is('markuplint.dev')).toBe(false);
 });

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

@@ -13,7 +13,7 @@ exports.isItempropName = void 0;
  */
 const isItempropName = () => {
     return value => {
-        return value.includes(':') && value.includes('.') && value.includes(' ');
+        return !value.includes(':') && !value.includes('.') && !value.includes(' ');
     };
 };
 exports.isItempropName = isItempropName;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/types",
-	"version": "3.5.0",
+	"version": "3.6.0",
 	"description": "Type declaration and value checker",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -20,18 +20,16 @@
 		"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": {
+		"@types/bcp-47": "1",
+		"@types/css-tree": "^2.0.1",
+		"@types/debug": "^4.1.7",
+		"@types/whatwg-mimetype": "3.0.0",
 		"bcp-47": "1",
 		"css-tree": "^2.3.1",
 		"debug": "^4.3.4",
 		"leven": "3",
-		"whatwg-mimetype": "2"
-	},
-	"devDependencies": {
-		"@types/bcp-47": "1",
-		"@types/css-tree": "^2.0.1",
-		"@types/debug": "^4.1.7",
-		"@types/whatwg-mimetype": "2",
-		"type-fest": "^3.6.1"
+		"type-fest": "^3.8.0",
+		"whatwg-mimetype": "^3.0.0"
 	},
-	"gitHead": "715dd53d3b1064a9bcf616c1533921cad9e3b187"
+	"gitHead": "adc6e432cccba7cfad0dc8bf9f92e5aaf1107359"
 }

package/test/check.spec.js

@@ -0,0 +1,89 @@
+const { check } = require('../lib/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('IconSize', () => {
+	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);
+});
+
+test('Number', () => {
+	expect(check('10', { type: 'integer', gt: 0 }).matched).toBe(true);
+	expect(check('0', { type: 'integer', gt: 0 }).matched).toBe(false);
+	expect(check('0', { type: 'integer', gte: 0 }).matched).toBe(true);
+	expect(check('9', { type: 'integer', lt: 10 }).matched).toBe(true);
+	expect(check('10', { type: 'integer', lt: 10 }).matched).toBe(false);
+});
+
+test('Non-exist types', () => {
+	// @ts-ignore
+	expect(check('abc', 'String').matched).toBe(true);
+	// @ts-ignore
+	expect(check('abc', 'FooBar').matched).toBe(true);
+	// @ts-ignore
+	expect(check('abc', ' ').matched).toBe(true);
+	// @ts-ignore
+	expect(check('abc', '\n').matched).toBe(true);
+	// @ts-ignore
+	expect(check('abc', '').matched).toBe(true);
+});
+
+test('ItemProp', () => {
+	expect(check('itemListElement', 'ItemProp').matched).toBe(true);
+	expect(check('item', 'ItemProp').matched).toBe(true);
+	expect(check('position', 'ItemProp').matched).toBe(true);
+});

package/test/css-syntax.spec.js

@@ -0,0 +1,165 @@
+const { cssSyntaxMatch } = require('../lib/css-syntax');
+
+test('CSS Standard', () => {
+	expect(cssSyntaxMatch('10px', '<length>').matched).toBe(true);
+	expect(cssSyntaxMatch('one-pixel', '<length>').matched).toBe(false);
+	expect(cssSyntaxMatch('(prefers-color-scheme: dark)', '<media-query-list>').matched).toBe(true);
+});
+
+test('Extends', () => {
+	const sourceSizeList = {
+		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>',
+				'source-size-value': '<length>',
+			},
+		},
+	};
+	expect(cssSyntaxMatch('50vw', sourceSizeList).matched).toBe(true);
+	expect(cssSyntaxMatch('(max-width: 600px) 200px, 50vw', sourceSizeList).matched).toBe(true);
+	expect(cssSyntaxMatch('print 300vw', sourceSizeList).matched).toBe(false);
+	expect(cssSyntaxMatch('(max-width: 600px) 200px', sourceSizeList).matched).toBe(false);
+	expect(
+		cssSyntaxMatch('(max-width: 600px) 200px', {
+			...sourceSizeList,
+			syntax: {
+				...sourceSizeList.syntax,
+				apply: '<source-size>',
+			},
+		}).matched,
+	).toBe(true);
+
+	const keyTimes = {
+		ref: 'https://svgwg.org/specs/animations/#KeyTimesAttribute',
+		syntax: {
+			apply: '<key-times>',
+			def: {
+				'key-times': '<number> [; <number>]* [;]?',
+			},
+		},
+	};
+	expect(cssSyntaxMatch('20; 20; 30', keyTimes).matched).toBe(true);
+	expect(cssSyntaxMatch('20; 20; 30;', keyTimes).matched).toBe(true);
+	expect(cssSyntaxMatch('20; 20; abc;', keyTimes).matched).toBe(false);
+	expect(cssSyntaxMatch('20; 20; ;', keyTimes).matched).toBe(false);
+
+	const SVGViewBox = {
+		ref: 'https://svgwg.org/svg2-draft/coords.html#ViewBoxAttribute',
+		syntax: {
+			apply: '<view-box>',
+			def: {
+				'view-box': '<min-x> [,]? <min-y> [,]? <width> [,]? <height>',
+				'min-x': '<number>',
+				'min-y': '<number>',
+				width: '<number>',
+				height: '<number>',
+			},
+		},
+	};
+	expect(cssSyntaxMatch('0 0 30 10', SVGViewBox).matched).toBe(true);
+	expect(cssSyntaxMatch('0 0, 30, 10', SVGViewBox).matched).toBe(true);
+	expect(cssSyntaxMatch('0 0, 30', SVGViewBox).matched).toBe(false);
+
+	const percentageList = {
+		ref: 'https://developer.mozilla.org/en-US/docs/Web/SVG/Content_type#percentage',
+		syntax: {
+			apply: '<percentage-list>',
+			def: {
+				'percentage-list': '[ <number> [,]? ]* <number>',
+			},
+		},
+	};
+	expect(cssSyntaxMatch('0 0 30 10', percentageList).matched).toBe(true);
+	expect(cssSyntaxMatch('0, 0, 30 10', percentageList).matched).toBe(true);
+	expect(cssSyntaxMatch('0', percentageList).matched).toBe(true);
+	expect(cssSyntaxMatch('', percentageList).matched).toBe(false);
+
+	const custom = {
+		ref: 'n/a',
+		syntax: {
+			apply: '<custom>',
+			def: {
+				custom: '0 | 1 | .',
+			},
+		},
+	};
+	expect(cssSyntaxMatch('0', custom).matched).toBe(true);
+	expect(cssSyntaxMatch('1', custom).matched).toBe(true);
+	expect(cssSyntaxMatch('.', custom).matched).toBe(true);
+	expect(cssSyntaxMatch('2', custom).matched).toBe(false);
+	expect(cssSyntaxMatch(':', custom).matched).toBe(false);
+});
+
+test('custom-type-checking', () => {
+	const custom = {
+		ref: 'n/a',
+		caseSensitive: true,
+		syntax: {
+			apply: '<custom>',
+			def: {
+				custom: '<custom-type>',
+				'custom-type': token => {
+					if (!token) {
+						return 0;
+					}
+					return token.value === '1' ? 1 : 0;
+				},
+			},
+		},
+	};
+	expect(cssSyntaxMatch('1', custom).matched).toBe(true);
+	expect(cssSyntaxMatch('0', custom).matched).toBe(false);
+});
+
+test('case-sensitive', () => {
+	const custom = {
+		ref: 'n/a',
+		caseSensitive: true,
+		syntax: {
+			apply: '<custom>',
+			def: {
+				custom: 'CaSeS [a | B | aBc]',
+			},
+		},
+	};
+	expect(cssSyntaxMatch('CaSeS a', custom).matched).toBe(true);
+	expect(cssSyntaxMatch('CaSeS B', custom).matched).toBe(true);
+	expect(cssSyntaxMatch('CaSeS aBc', custom).matched).toBe(true);
+	expect(cssSyntaxMatch('CaSeS A', custom)).toStrictEqual({
+		column: 7,
+		line: 1,
+		matched: false,
+		length: 1,
+		offset: 6,
+		partName: 'value',
+		raw: 'A',
+		reason: 'syntax-error',
+		ref: 'n/a',
+		expects: [
+			{
+				type: 'syntax',
+				value: '<custom>',
+			},
+		],
+	});
+	expect(cssSyntaxMatch('CaSeS abc', custom)).toStrictEqual({
+		column: 7,
+		line: 1,
+		matched: false,
+		length: 3,
+		offset: 6,
+		partName: 'value',
+		raw: 'abc',
+		reason: 'syntax-error',
+		ref: 'n/a',
+		expects: [
+			{
+				type: 'syntax',
+				value: '<custom>',
+			},
+		],
+	});
+});

package/test/list.spec.js

@@ -0,0 +1,133 @@
+const { checkList } = require('../lib/list');
+
+test('Zero space', () => {
+	const type = { token: 'Zero', separator: 'space' };
+	expect(checkList('0', type).matched).toBe(true);
+	expect(checkList(' 0 ', type).matched).toBe(true);
+	expect(checkList(' 0 0', type).matched).toBe(true);
+	expect(checkList(' 0 0 ', type).matched).toBe(true);
+	expect(checkList('0 0 0 ', type).matched).toBe(true);
+	expect(checkList('0 0 0 0', type).matched).toBe(true);
+	expect(checkList('0 0 0    0', type).matched).toBe(true);
+	expect(checkList('1', type).matched).toBe(false);
+	expect(checkList(' 1 ', type).matched).toBe(false);
+	expect(checkList(' 1 0', type).matched).toBe(false);
+	expect(checkList(' 1 0 ', type).matched).toBe(false);
+	expect(checkList('0 1 0 ', type).matched).toBe(false);
+	expect(checkList('0 1 0 0', type).matched).toBe(false);
+	expect(checkList('0 1 0    0', type).matched).toBe(false);
+});
+
+test('Zero comma', () => {
+	const type = { token: 'Zero', separator: 'comma' };
+	expect(checkList('0', type).matched).toBe(true);
+	expect(checkList(' 0 ', type).matched).toBe(true);
+	expect(checkList(' 0 0', type).matched).toBe(false);
+	expect(checkList(' 0,0', type).matched).toBe(true);
+	expect(checkList(' 0,,0 ', type).matched).toBe(false);
+	expect(checkList('0 0 0 ', type).matched).toBe(false);
+	expect(checkList(' 0,0,0,0 ', type).matched).toBe(true);
+	expect(checkList('0, 0, 0 , 0', type).matched).toBe(true);
+	expect(checkList('0,0,0,0,', type).matched).toBe(false);
+	expect(checkList(',0,0,0,0', type).matched).toBe(false);
+});
+
+test('Zero comma (disallowToSurroundBySpaces)', () => {
+	const type = { token: 'Zero', separator: 'comma', disallowToSurroundBySpaces: true };
+	expect(checkList('0', type).matched).toBe(true);
+	expect(checkList(' 0 ', type).matched).toBe(false);
+	expect(checkList(' 0 0', type).matched).toBe(false);
+	expect(checkList(' 0,0', type).matched).toBe(false);
+	expect(checkList(' 0,,0 ', type).matched).toBe(false);
+	expect(checkList('0 0 0 ', type).matched).toBe(false);
+	expect(checkList(' 0,0,0,0 ', type).matched).toBe(false);
+	expect(checkList('0, 0, 0 , 0', type).matched).toBe(false);
+	expect(checkList('0,0,0,0', type).matched).toBe(true);
+	expect(checkList('0,0,0,0,', type).matched).toBe(false);
+	expect(checkList(',0,0,0,0', type).matched).toBe(false);
+});
+
+test('Location of the token', () => {
+	const type = { token: 'Accept', separator: 'comma' };
+	expect(checkList('x/y;a=b', type)).toStrictEqual({
+		candidate: 'x/y',
+		column: 4,
+		expects: [{ type: 'format', value: 'MIME Type with no parameters' }],
+		length: 4,
+		line: 1,
+		matched: false,
+		offset: 3,
+		raw: ';a=b',
+		reason: 'extra-token',
+		partName: 'the content of the list',
+		ref: 'https://html.spec.whatwg.org/multipage/input.html#attr-input-accept',
+	});
+	expect(checkList('x/y,x/y;a=b', type)).toStrictEqual({
+		candidate: 'x/y',
+		column: 8,
+		expects: [{ type: 'format', value: 'MIME Type with no parameters' }],
+		length: 4,
+		line: 1,
+		matched: false,
+		offset: 7,
+		raw: ';a=b',
+		reason: 'extra-token',
+		partName: 'the content of the list',
+		ref: 'https://html.spec.whatwg.org/multipage/input.html#attr-input-accept',
+	});
+	expect(checkList('x/y\n,\nx/y;a=b', type)).toStrictEqual({
+		candidate: 'x/y',
+		column: 4,
+		expects: [{ type: 'format', value: 'MIME Type with no parameters' }],
+		length: 4,
+		line: 3,
+		matched: false,
+		offset: 9,
+		raw: ';a=b',
+		reason: 'extra-token',
+		partName: 'the content of the list',
+		ref: 'https://html.spec.whatwg.org/multipage/input.html#attr-input-accept',
+	});
+});
+
+test('Expected comma', () => {
+	const type = { token: 'Accept', separator: 'comma' };
+	expect(checkList('x/y,', type)).toStrictEqual({
+		column: 4,
+		expects: undefined,
+		length: 1,
+		line: 1,
+		matched: false,
+		offset: 3,
+		raw: ',',
+		reason: 'extra-token',
+		ref: null,
+	});
+	expect(checkList('x/y,,x/y', type)).toStrictEqual({
+		column: 5,
+		expects: undefined,
+		length: 1,
+		line: 1,
+		matched: false,
+		offset: 4,
+		raw: ',',
+		reason: 'unexpected-comma',
+		ref: null,
+	});
+});
+
+test('Missing comma', () => {
+	const type = { token: 'Accept', separator: 'comma' };
+	expect(checkList('a/b,x/y a/z', type)).toStrictEqual({
+		column: 9,
+		candidate: ',a/z',
+		expects: undefined,
+		length: 3,
+		line: 1,
+		matched: false,
+		offset: 8,
+		raw: 'a/z',
+		reason: 'missing-comma',
+		ref: null,
+	});
+});

package/test/primitive/index.spec.js

@@ -0,0 +1,65 @@
+const { isInt, isUint, isFloat, isNonZeroUint, isQuantity } = require('../../lib/primitive');
+
+test('int', () => {
+	expect(isInt('0')).toBe(true);
+	expect(isInt('1')).toBe(true);
+	expect(isInt('-0')).toBe(true);
+	expect(isInt('-1')).toBe(true);
+	expect(isInt('10')).toBe(true);
+	expect(isInt('100')).toBe(true);
+	expect(isInt('1.00')).toBe(false);
+	expect(isInt('.001')).toBe(false);
+	expect(isInt(' 1 ')).toBe(false);
+	expect(isInt('- 1')).toBe(false);
+});
+
+test('uint', () => {
+	expect(isUint('0')).toBe(true);
+	expect(isUint('1')).toBe(true);
+	expect(isUint('10')).toBe(true);
+	expect(isUint('100')).toBe(true);
+	expect(isUint('-0')).toBe(false);
+	expect(isUint('-1')).toBe(false);
+	expect(isUint('1.00')).toBe(false);
+	expect(isUint('.001')).toBe(false);
+	expect(isUint(' 1 ')).toBe(false);
+	expect(isUint('- 1')).toBe(false);
+});
+
+test('float', () => {
+	expect(isFloat('0')).toBe(true);
+	expect(isFloat('1')).toBe(true);
+	expect(isFloat('10')).toBe(true);
+	expect(isFloat('100')).toBe(true);
+	expect(isFloat('-0')).toBe(true);
+	expect(isFloat('-1')).toBe(true);
+	expect(isFloat('1.00')).toBe(true);
+	expect(isFloat('.001')).toBe(true);
+	expect(isFloat(' 1 ')).toBe(false);
+	expect(isFloat('- 1')).toBe(false);
+});
+
+test('nonZeroUint', () => {
+	expect(isNonZeroUint('0')).toBe(false);
+	expect(isNonZeroUint('1')).toBe(true);
+	expect(isNonZeroUint('10')).toBe(true);
+	expect(isNonZeroUint('100')).toBe(true);
+	expect(isNonZeroUint('-0')).toBe(false);
+	expect(isNonZeroUint('-1')).toBe(false);
+	expect(isNonZeroUint('1.00')).toBe(false);
+	expect(isNonZeroUint('.001')).toBe(false);
+	expect(isNonZeroUint(' 1 ')).toBe(false);
+	expect(isNonZeroUint('- 1')).toBe(false);
+});
+
+test('quantity', () => {
+	expect(isQuantity('0px', ['px', 'em'])).toBe(true);
+	expect(isQuantity('.5px', ['px', 'em'])).toBe(true);
+	expect(isQuantity('1.5em', ['px', 'em'])).toBe(true);
+	expect(isQuantity('1.5cm', ['px', 'em'])).toBe(false);
+	expect(isQuantity('1.5px', ['px', 'em'], 'int')).toBe(false);
+	expect(isQuantity('-5px', ['px', 'em'], 'int')).toBe(true);
+	expect(isQuantity('-5px', ['px', 'em'], 'uint')).toBe(false);
+	expect(isQuantity('1.12e+21px', ['px', 'em'], 'float')).toBe(true);
+	expect(isQuantity('1.12e+21px', ['px', 'em'], 'int')).toBe(false);
+});

package/test/rfc/is-bcp-47.spec.js

@@ -0,0 +1,23 @@
+const { isBCP47 } = require('../../lib/rfc/is-bcp-47');
+
+const is = isBCP47();
+
+test('en-us', () => {
+	expect(is('en-us')).toBe(true);
+});
+
+test('ja-JP', () => {
+	expect(is('ja-JP')).toBe(true);
+});
+
+test('Empty', () => {
+	expect(is('')).toBe(false);
+});
+
+test('Invalid', () => {
+	expect(is(':::')).toBe(false);
+});
+
+test('Surrounded by spaces', () => {
+	expect(is(' en ')).toBe(false);
+});