@markuplint/types 1.0.0-dev.20211213.0

package/lib/enum.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from './types';
+import type { Enum } from './types.schema';
+export declare function checkEnum(value: string, type: Enum, ref?: string): Result;

package/lib/enum.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkEnum = void 0;
+const match_result_1 = require("./match-result");
+function checkEnum(value, type, ref) {
+    var _a, _b;
+    const disallowToSurroundBySpaces = (_a = type.disallowToSurroundBySpaces) !== null && _a !== void 0 ? _a : true;
+    const caseInsensitive = (_b = type.caseInsensitive) !== null && _b !== void 0 ? _b : true;
+    if (!disallowToSurroundBySpaces) {
+        value = value.trim();
+    }
+    let values = type.enum;
+    if (caseInsensitive) {
+        value = value.toLowerCase();
+        values = type.enum.map(v => v.toLowerCase());
+    }
+    const res = values.includes(value);
+    if (res) {
+        return (0, match_result_1.matched)();
+    }
+    return (0, match_result_1.unmatched)(value, 'doesnt-exist-in-enum', {
+        ref,
+        expects: type.enum.map(value => ({ type: 'const', value })),
+    });
+}
+exports.checkEnum = checkEnum;

package/lib/get-candicate.d.ts

@@ -0,0 +1,3 @@
+declare type NullableString = string | null | undefined;
+export declare function getCandicate(value: NullableString, ...candicates: (NullableString | NullableString[])[]): string | undefined;
+export {};

package/lib/get-candicate.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCandicate = void 0;
+const tslib_1 = require("tslib");
+const leven_1 = (0, tslib_1.__importDefault)(require("leven"));
+function getCandicate(value, ...candicates) {
+    if (!value) {
+        return;
+    }
+    const list = candicates.flat(2).filter((s) => !!s);
+    let candicate;
+    let maxRatio = 0;
+    list.forEach(word => {
+        const dist = (0, leven_1.default)(value.trim().toLowerCase(), word.trim().toLowerCase());
+        const ratio = 1 - dist / word.length;
+        if (0.5 <= ratio && maxRatio < ratio) {
+            candicate = word;
+        }
+        maxRatio = Math.max(ratio, maxRatio);
+    });
+    if (value === candicate) {
+        return;
+    }
+    return candicate;
+}
+exports.getCandicate = getCandicate;

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './whatwg/is-custom-element-name';
+export * from './check';
+export * from './types';

package/lib/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./whatwg/is-custom-element-name"), exports);
+(0, tslib_1.__exportStar)(require("./check"), exports);
+(0, tslib_1.__exportStar)(require("./types"), exports);

package/lib/keyword-type.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from './types';
+import type { KeywordDefinedType } from './types.schema';
+export declare function checkKeywordType(value: string, type: KeywordDefinedType, cache?: boolean): Result;

package/lib/keyword-type.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkKeywordType = void 0;
+const check_1 = require("./check");
+const css_syntax_1 = require("./css-syntax");
+const debug_1 = require("./debug");
+const defs_1 = require("./defs");
+const resultCache = new Map();
+const CACHE_KEY_PREFIX = '@markuplint/types/checkKeywordType/cache:::';
+function checkKeywordType(value, type, cache = true) {
+    const key = `${CACHE_KEY_PREFIX}${value}${type}`;
+    if (cache) {
+        const cachedResult = resultCache.get(key);
+        if (cachedResult) {
+            (0, debug_1.log)('Restore cache: %s / %s', value, type);
+            return cachedResult;
+        }
+    }
+    const result = _checkKeywordType(value, type);
+    if (cache) {
+        resultCache.set(key, result);
+        (0, debug_1.log)('Cache checking: %O', {
+            input: value,
+            type,
+            key,
+            result: result,
+        });
+    }
+    return result;
+}
+exports.checkKeywordType = checkKeywordType;
+function _checkKeywordType(value, type) {
+    const def = defs_1.types[type];
+    if (!def) {
+        return (0, css_syntax_1.cssSyntaxMatch)(value, type);
+    }
+    const matched = (0, check_1.isCSSSyntax)(def) ? (0, css_syntax_1.cssSyntaxMatch)(value, def) : def.is(value);
+    if (!matched.matched) {
+        return {
+            ...matched,
+            ref: matched.ref || def.ref,
+            expects: matched.expects || def.expects,
+        };
+    }
+    return matched;
+}

package/lib/list.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from './types';
+import type { List } from './types.schema';
+export declare function checkList(value: string, type: List, ref?: string, cache?: boolean): Result;

package/lib/list.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkList = void 0;
+const check_1 = require("./check");
+const match_result_1 = require("./match-result");
+const token_1 = require("./token");
+function checkList(value, type, ref, cache = true) {
+    const tokens = new token_1.TokenCollection(value, type);
+    const matches = tokens.check({ ref });
+    if (!matches.matched) {
+        return matches;
+    }
+    const identTokens = tokens.getIdentTokens();
+    for (const token of identTokens) {
+        const res = (0, check_1.check)(token.value, type.token, ref, cache);
+        if (!res.matched) {
+            const { offset, line, column } = token_1.Token.shiftLocation(token, res.offset);
+            return {
+                ...res,
+                partName: res.partName || 'the content of the list',
+                offset,
+                line,
+                column,
+            };
+        }
+    }
+    return (0, match_result_1.matched)();
+}
+exports.checkList = checkList;

package/lib/list.spec.d.ts

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

package/lib/list.spec.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const list_1 = require("./list");
+test('Zero space', () => {
+    const type = { token: 'Zero', separator: 'space' };
+    expect((0, list_1.checkList)('0', type).matched).toBe(true);
+    expect((0, list_1.checkList)(' 0 ', type).matched).toBe(true);
+    expect((0, list_1.checkList)(' 0 0', type).matched).toBe(true);
+    expect((0, list_1.checkList)(' 0 0 ', type).matched).toBe(true);
+    expect((0, list_1.checkList)('0 0 0 ', type).matched).toBe(true);
+    expect((0, list_1.checkList)('0 0 0 0', type).matched).toBe(true);
+    expect((0, list_1.checkList)('0 0 0    0', type).matched).toBe(true);
+    expect((0, list_1.checkList)('1', type).matched).toBe(false);
+    expect((0, list_1.checkList)(' 1 ', type).matched).toBe(false);
+    expect((0, list_1.checkList)(' 1 0', type).matched).toBe(false);
+    expect((0, list_1.checkList)(' 1 0 ', type).matched).toBe(false);
+    expect((0, list_1.checkList)('0 1 0 ', type).matched).toBe(false);
+    expect((0, list_1.checkList)('0 1 0 0', type).matched).toBe(false);
+    expect((0, list_1.checkList)('0 1 0    0', type).matched).toBe(false);
+});
+test('Zero comma', () => {
+    const type = { token: 'Zero', separator: 'comma' };
+    expect((0, list_1.checkList)('0', type).matched).toBe(true);
+    expect((0, list_1.checkList)(' 0 ', type).matched).toBe(true);
+    expect((0, list_1.checkList)(' 0 0', type).matched).toBe(false);
+    expect((0, list_1.checkList)(' 0,0', type).matched).toBe(true);
+    expect((0, list_1.checkList)(' 0,,0 ', type).matched).toBe(false);
+    expect((0, list_1.checkList)('0 0 0 ', type).matched).toBe(false);
+    expect((0, list_1.checkList)(' 0,0,0,0 ', type).matched).toBe(true);
+    expect((0, list_1.checkList)('0, 0, 0 , 0', type).matched).toBe(true);
+    expect((0, list_1.checkList)('0,0,0,0,', type).matched).toBe(false);
+    expect((0, list_1.checkList)(',0,0,0,0', type).matched).toBe(false);
+});
+test('Zero comma (disallowToSurroundBySpaces)', () => {
+    const type = { token: 'Zero', separator: 'comma', disallowToSurroundBySpaces: true };
+    expect((0, list_1.checkList)('0', type).matched).toBe(true);
+    expect((0, list_1.checkList)(' 0 ', type).matched).toBe(false);
+    expect((0, list_1.checkList)(' 0 0', type).matched).toBe(false);
+    expect((0, list_1.checkList)(' 0,0', type).matched).toBe(false);
+    expect((0, list_1.checkList)(' 0,,0 ', type).matched).toBe(false);
+    expect((0, list_1.checkList)('0 0 0 ', type).matched).toBe(false);
+    expect((0, list_1.checkList)(' 0,0,0,0 ', type).matched).toBe(false);
+    expect((0, list_1.checkList)('0, 0, 0 , 0', type).matched).toBe(false);
+    expect((0, list_1.checkList)('0,0,0,0', type).matched).toBe(true);
+    expect((0, list_1.checkList)('0,0,0,0,', type).matched).toBe(false);
+    expect((0, list_1.checkList)(',0,0,0,0', type).matched).toBe(false);
+});
+test('Location of the token', () => {
+    const type = { token: 'Accept', separator: 'comma' };
+    expect((0, list_1.checkList)('x/y;a=b', type)).toStrictEqual({
+        candicate: '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((0, list_1.checkList)('x/y,x/y;a=b', type)).toStrictEqual({
+        candicate: '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((0, list_1.checkList)('x/y\n,\nx/y;a=b', type)).toStrictEqual({
+        candicate: '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((0, list_1.checkList)('x/y,', type)).toStrictEqual({
+        column: 4,
+        expects: undefined,
+        length: 1,
+        line: 1,
+        matched: false,
+        offset: 3,
+        raw: ',',
+        reason: 'extra-token',
+        ref: null,
+    });
+    expect((0, list_1.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((0, list_1.checkList)('a/b,x/y a/z', type)).toStrictEqual({
+        column: 9,
+        candicate: ',a/z',
+        expects: undefined,
+        length: 3,
+        line: 1,
+        matched: false,
+        offset: 8,
+        raw: 'a/z',
+        reason: 'missing-comma',
+        ref: null,
+    });
+});

package/lib/match-result.d.ts

@@ -0,0 +1,9 @@
+import type { FormattedPrimitiveTypeCheck, MatchedResult, UnmatchedResult, UnmatchedResultOptions, UnmatchedResultReason } from './types';
+export declare function matches(checker: FormattedPrimitiveTypeCheck, options?: UnmatchedResultOptions & {
+    ref?: string;
+    reason?: UnmatchedResultReason;
+}): (value: string) => UnmatchedResult | MatchedResult;
+export declare function matched(): MatchedResult;
+export declare function unmatched(value: string, reason?: UnmatchedResultReason, options?: UnmatchedResultOptions & {
+    ref?: string;
+}): UnmatchedResult;

package/lib/match-result.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unmatched = exports.matched = exports.matches = void 0;
+function matches(checker, options) {
+    return (value) => {
+        const valid = checker(value);
+        if (!valid && !value) {
+            return unmatched(value, 'empty-token', options);
+        }
+        return valid ? matched() : unmatched(value, options === null || options === void 0 ? void 0 : options.reason, options);
+    };
+}
+exports.matches = matches;
+function matched() {
+    return {
+        matched: true,
+    };
+}
+exports.matched = matched;
+function unmatched(value, reason, options) {
+    return {
+        ...options,
+        matched: false,
+        ref: (options === null || options === void 0 ? void 0 : options.ref) || null,
+        raw: value,
+        offset: 0,
+        length: value.length,
+        line: 1,
+        column: 1,
+        reason: reason !== null && reason !== void 0 ? reason : 'syntax-error',
+    };
+}
+exports.unmatched = unmatched;

package/lib/number.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from './types';
+import type { Number } from './types.schema';
+export declare function checkNumber(value: string, type: Number, ref?: string): Result;

package/lib/number.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNumber = void 0;
+const match_result_1 = require("./match-result");
+const primitive_1 = require("./primitive");
+function checkNumber(value, type, ref) {
+    if (!value) {
+        return (0, match_result_1.unmatched)(value, 'empty-token');
+    }
+    const syntaxMatched = type.type === 'float' ? (0, primitive_1.isFloat)(value) : (0, primitive_1.isInt)(value);
+    if (syntaxMatched) {
+        const n = parseFloat(value);
+        if (!isFinite(n)) {
+            return (0, match_result_1.unmatched)(value, 'unexpected-token');
+        }
+        const clampable = type.clampable;
+        const isInt = type.type === 'integer';
+        if (type.gt != null && type.gt < n) {
+            return (0, match_result_1.unmatched)(value, 'out-of-range', {
+                candicate: clampable && isInt ? `${type.gt + 1}` : undefined,
+            });
+        }
+        if (type.gte != null && type.gte <= n) {
+            return (0, match_result_1.unmatched)(value, 'out-of-range', {
+                candicate: clampable ? `${type.gte}` : undefined,
+            });
+        }
+        if (type.lt != null && n < type.lt) {
+            return (0, match_result_1.unmatched)(value, 'out-of-range', {
+                candicate: clampable && isInt ? `${type.lt - 1}` : undefined,
+            });
+        }
+        if (type.lte != null && n <= type.lte) {
+            return (0, match_result_1.unmatched)(value, 'out-of-range', {
+                candicate: clampable ? `${type.lte}` : undefined,
+            });
+        }
+    }
+    return syntaxMatched ? (0, match_result_1.matched)() : (0, match_result_1.unmatched)(value, 'unexpected-token');
+}
+exports.checkNumber = checkNumber;

package/lib/primitive/index.d.ts

@@ -0,0 +1,7 @@
+export { isInt } from './is-int';
+export { isUint } from './is-uint';
+export { isFloat } from './is-float';
+export { isNonZeroUint } from './is-non-zero-uint';
+export { isQuantity } from './is-quantity';
+export { splitUnit } from './split-unit';
+export { range } from './range';

package/lib/primitive/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.range = exports.splitUnit = exports.isQuantity = exports.isNonZeroUint = exports.isFloat = exports.isUint = exports.isInt = void 0;
+var is_int_1 = require("./is-int");
+Object.defineProperty(exports, "isInt", { enumerable: true, get: function () { return is_int_1.isInt; } });
+var is_uint_1 = require("./is-uint");
+Object.defineProperty(exports, "isUint", { enumerable: true, get: function () { return is_uint_1.isUint; } });
+var is_float_1 = require("./is-float");
+Object.defineProperty(exports, "isFloat", { enumerable: true, get: function () { return is_float_1.isFloat; } });
+var is_non_zero_uint_1 = require("./is-non-zero-uint");
+Object.defineProperty(exports, "isNonZeroUint", { enumerable: true, get: function () { return is_non_zero_uint_1.isNonZeroUint; } });
+var is_quantity_1 = require("./is-quantity");
+Object.defineProperty(exports, "isQuantity", { enumerable: true, get: function () { return is_quantity_1.isQuantity; } });
+var split_unit_1 = require("./split-unit");
+Object.defineProperty(exports, "splitUnit", { enumerable: true, get: function () { return split_unit_1.splitUnit; } });
+var range_1 = require("./range");
+Object.defineProperty(exports, "range", { enumerable: true, get: function () { return range_1.range; } });

package/lib/primitive/index.spec.d.ts

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

package/lib/primitive/index.spec.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+test('int', () => {
+    expect((0, _1.isInt)('0')).toBe(true);
+    expect((0, _1.isInt)('1')).toBe(true);
+    expect((0, _1.isInt)('-0')).toBe(true);
+    expect((0, _1.isInt)('-1')).toBe(true);
+    expect((0, _1.isInt)('10')).toBe(true);
+    expect((0, _1.isInt)('100')).toBe(true);
+    expect((0, _1.isInt)('1.00')).toBe(false);
+    expect((0, _1.isInt)('.001')).toBe(false);
+    expect((0, _1.isInt)(' 1 ')).toBe(false);
+    expect((0, _1.isInt)('- 1')).toBe(false);
+});
+test('uint', () => {
+    expect((0, _1.isUint)('0')).toBe(true);
+    expect((0, _1.isUint)('1')).toBe(true);
+    expect((0, _1.isUint)('10')).toBe(true);
+    expect((0, _1.isUint)('100')).toBe(true);
+    expect((0, _1.isUint)('-0')).toBe(false);
+    expect((0, _1.isUint)('-1')).toBe(false);
+    expect((0, _1.isUint)('1.00')).toBe(false);
+    expect((0, _1.isUint)('.001')).toBe(false);
+    expect((0, _1.isUint)(' 1 ')).toBe(false);
+    expect((0, _1.isUint)('- 1')).toBe(false);
+});
+test('float', () => {
+    expect((0, _1.isFloat)('0')).toBe(true);
+    expect((0, _1.isFloat)('1')).toBe(true);
+    expect((0, _1.isFloat)('10')).toBe(true);
+    expect((0, _1.isFloat)('100')).toBe(true);
+    expect((0, _1.isFloat)('-0')).toBe(true);
+    expect((0, _1.isFloat)('-1')).toBe(true);
+    expect((0, _1.isFloat)('1.00')).toBe(true);
+    expect((0, _1.isFloat)('.001')).toBe(true);
+    expect((0, _1.isFloat)(' 1 ')).toBe(false);
+    expect((0, _1.isFloat)('- 1')).toBe(false);
+});
+test('nonZeroUint', () => {
+    expect((0, _1.isNonZeroUint)('0')).toBe(false);
+    expect((0, _1.isNonZeroUint)('1')).toBe(true);
+    expect((0, _1.isNonZeroUint)('10')).toBe(true);
+    expect((0, _1.isNonZeroUint)('100')).toBe(true);
+    expect((0, _1.isNonZeroUint)('-0')).toBe(false);
+    expect((0, _1.isNonZeroUint)('-1')).toBe(false);
+    expect((0, _1.isNonZeroUint)('1.00')).toBe(false);
+    expect((0, _1.isNonZeroUint)('.001')).toBe(false);
+    expect((0, _1.isNonZeroUint)(' 1 ')).toBe(false);
+    expect((0, _1.isNonZeroUint)('- 1')).toBe(false);
+});
+test('quantity', () => {
+    expect((0, _1.isQuantity)('0px', ['px', 'em'])).toBe(true);
+    expect((0, _1.isQuantity)('.5px', ['px', 'em'])).toBe(true);
+    expect((0, _1.isQuantity)('1.5em', ['px', 'em'])).toBe(true);
+    expect((0, _1.isQuantity)('1.5cm', ['px', 'em'])).toBe(false);
+    expect((0, _1.isQuantity)('1.5px', ['px', 'em'], 'int')).toBe(false);
+    expect((0, _1.isQuantity)('-5px', ['px', 'em'], 'int')).toBe(true);
+    expect((0, _1.isQuantity)('-5px', ['px', 'em'], 'uint')).toBe(false);
+    expect((0, _1.isQuantity)('1.12e+21px', ['px', 'em'], 'float')).toBe(true);
+    expect((0, _1.isQuantity)('1.12e+21px', ['px', 'em'], 'int')).toBe(false);
+});

package/lib/primitive/is-float.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @see https://html.spec.whatwg.org/dev/common-microsyntaxes.html#floating-point-numbers
+ *
+ * @param value
+ */
+export declare function isFloat(value: string): boolean;

package/lib/primitive/is-float.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFloat = void 0;
+/**
+ * @see https://html.spec.whatwg.org/dev/common-microsyntaxes.html#floating-point-numbers
+ *
+ * @param value
+ */
+function isFloat(value) {
+    return value === value.trim() && Number.isFinite(parseFloat(value));
+}
+exports.isFloat = isFloat;

package/lib/primitive/is-int.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @see https://html.spec.whatwg.org/dev/common-microsyntaxes.html#signed-integers
+ *
+ * @param value
+ */
+export declare function isInt(value: string): boolean;

package/lib/primitive/is-int.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInt = void 0;
+/**
+ * @see https://html.spec.whatwg.org/dev/common-microsyntaxes.html#signed-integers
+ *
+ * @param value
+ */
+function isInt(value) {
+    return /^-?[0-9]+$/.test(value);
+}
+exports.isInt = isInt;

package/lib/primitive/is-non-zero-uint.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Non-negative integer greater than zero
+ *
+ * @param value
+ */
+export declare function isNonZeroUint(value: string): boolean;

package/lib/primitive/is-non-zero-uint.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNonZeroUint = void 0;
+/**
+ * Non-negative integer greater than zero
+ *
+ * @param value
+ */
+function isNonZeroUint(value) {
+    return /^[0-9]+$/.test(value) && !/^0+$/.test(value);
+}
+exports.isNonZeroUint = isNonZeroUint;

package/lib/primitive/is-quantity.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param value
+ * @param units
+ * @param numberType
+ */
+export declare function isQuantity(value: string, units: string[], numberType?: 'int' | 'uint' | 'float'): boolean;

package/lib/primitive/is-quantity.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isQuantity = void 0;
+const is_float_1 = require("./is-float");
+const is_int_1 = require("./is-int");
+const is_uint_1 = require("./is-uint");
+const split_unit_1 = require("./split-unit");
+/**
+ *
+ * @param value
+ * @param units
+ * @param numberType
+ */
+function isQuantity(value, units, numberType = 'float') {
+    const { num, unit } = (0, split_unit_1.splitUnit)(value);
+    if (!units.includes(unit.toLowerCase())) {
+        return false;
+    }
+    switch (numberType) {
+        case 'int': {
+            if (!(0, is_int_1.isInt)(num)) {
+                return false;
+            }
+            break;
+        }
+        case 'uint': {
+            if (!(0, is_uint_1.isUint)(num)) {
+                return false;
+            }
+            break;
+        }
+        case 'float': {
+            if (!(0, is_float_1.isFloat)(num)) {
+                return false;
+            }
+            break;
+        }
+    }
+    return true;
+}
+exports.isQuantity = isQuantity;

package/lib/primitive/is-uint.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @see https://html.spec.whatwg.org/dev/common-microsyntaxes.html#non-negative-integers
+ *
+ * @param value
+ */
+export declare function isUint(value: string, opions?: {
+    gt?: number;
+}): boolean;

package/lib/primitive/is-uint.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUint = void 0;
+/**
+ * @see https://html.spec.whatwg.org/dev/common-microsyntaxes.html#non-negative-integers
+ *
+ * @param value
+ */
+function isUint(value, opions) {
+    const matched = /^[0-9]+$/.test(value);
+    if (matched && opions) {
+        const n = parseInt(value, 10);
+        if (opions.gt != null) {
+            return isFinite(n) && opions.gt < n;
+        }
+    }
+    return matched;
+}
+exports.isUint = isUint;

package/lib/primitive/range.d.ts

@@ -0,0 +1,8 @@
+/**
+ * It is in the range between `from` and `to`.
+ *
+ * @param value
+ * @param from
+ * @param to
+ */
+export declare function range(value: string, from: number, to: number): boolean;

package/lib/primitive/range.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.range = void 0;
+/**
+ * It is in the range between `from` and `to`.
+ *
+ * @param value
+ * @param from
+ * @param to
+ */
+function range(value, from, to) {
+    const num = parseFloat(value);
+    if (isNaN(num)) {
+        return false;
+    }
+    return from <= num && num <= to;
+}
+exports.range = range;