@markuplint/types 3.12.0 → 4.0.0-alpha.10

package/lib/enum.js

@@ -1,26 +1,21 @@
-"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;
+import { matched, unmatched } from './match-result.js';
+export function checkEnum(value, type, ref) {
+    const disallowToSurroundBySpaces = type.disallowToSurroundBySpaces ?? true;
+    const caseInsensitive = type.caseInsensitive ?? true;
     if (!disallowToSurroundBySpaces) {
         value = value.trim();
     }
-    let values = type.enum.slice();
+    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 matched();
     }
-    return (0, match_result_1.unmatched)(value, 'doesnt-exist-in-enum', {
+    return unmatched(value, 'doesnt-exist-in-enum', {
         ref,
         expects: type.enum.map(value => ({ type: 'const', value })),
     });
 }
-exports.checkEnum = checkEnum;

package/lib/get-candidate.d.ts

@@ -1,6 +1,3 @@
 type NullableString = string | null | undefined;
-export declare function getCandidate(
-	value: NullableString,
-	...candidates: readonly (NullableString | readonly NullableString[])[]
-): string | undefined;
+export declare function getCandidate(value: NullableString, ...candidates: readonly (NullableString | readonly NullableString[])[]): string | undefined;
 export {};

package/lib/get-candidate.js

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

package/lib/index.d.ts

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

package/lib/index.js

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

package/lib/keyword-type.d.ts

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

package/lib/keyword-type.js

@@ -1,27 +1,24 @@
-"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 match_result_1 = require("./match-result");
+import { isCSSSyntax } from './check.js';
+import { cssSyntaxMatch } from './css-syntax.js';
+import { log } from './debug.js';
+import { types } from './defs.js';
+import { matched } from './match-result.js';
 const resultCache = new Map();
 const CACHE_KEY_PREFIX = '@markuplint/types/checkKeywordType/cache:::';
-function checkKeywordType(value, type, cache = true) {
+export 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);
+            log('Restore cache: %s / %s', value, type);
             return cachedResult;
         }
     }
     const result = _checkKeywordType(value, type);
     if (cache) {
         resultCache.set(key, result);
-        if (debug_1.log.enabled) {
-            (0, debug_1.log)('Cache checking: %O', {
+        if (log.enabled) {
+            log('Cache checking: %O', {
                 input: value,
                 type,
                 key,
@@ -31,29 +28,27 @@ function checkKeywordType(value, type, cache = true) {
     }
     return result;
 }
-exports.checkKeywordType = checkKeywordType;
 function _checkKeywordType(value, type) {
-    var _a, _b;
-    const def = defs_1.types[type];
+    const def = types[type];
     if (!def) {
-        (0, debug_1.log)('The "%s" type is not defined in custom type identifier markuplint specified', type);
+        log('The "%s" type is not defined in custom type identifier markuplint specified', type);
         try {
-            return (0, css_syntax_1.cssSyntaxMatch)(value, type);
+            return cssSyntaxMatch(value, type);
         }
-        catch (e) {
-            if (e instanceof Error && e.message === 'MARKUPLINT_TYPE_NO_EXIST') {
-                (0, debug_1.log)("Allow all of any value because the type doesn't exist");
-                return (0, match_result_1.matched)();
+        catch (error) {
+            if (error instanceof Error && error.message === 'MARKUPLINT_TYPE_NO_EXIST') {
+                log("Allow all of any value because the type doesn't exist");
+                return matched();
             }
-            throw e;
+            throw error;
         }
     }
-    const matches = (0, check_1.isCSSSyntax)(def) ? (0, css_syntax_1.cssSyntaxMatch)(value, def) : def.is(value);
+    const matches = isCSSSyntax(def) ? cssSyntaxMatch(value, def) : def.is(value);
     if (!matches.matched) {
         return {
             ...matches,
-            ref: (_a = matches.ref) !== null && _a !== void 0 ? _a : def.ref,
-            expects: (_b = matches.expects) !== null && _b !== void 0 ? _b : def.expects,
+            ref: matches.ref ?? def.ref,
+            expects: matches.expects ?? def.expects,
         };
     }
     return matches;

package/lib/list.d.ts

@@ -1,4 +1,4 @@
-import type { Result } from './types';
-import type { List } from './types.schema';
+import type { Result } from './types.js';
+import type { List } from './types.schema.js';
 import type { ReadonlyDeep } from 'type-fest';
 export declare function checkList(value: string, type: ReadonlyDeep<List>, ref?: string, cache?: boolean): Result;

package/lib/list.js

@@ -1,30 +1,25 @@
-"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) {
-    var _a;
-    const tokens = new token_1.TokenCollection(value, type);
+import { check } from './check.js';
+import { matched } from './match-result.js';
+import { Token, TokenCollection } from './token/index.js';
+export function checkList(value, type, ref, cache = true) {
+    const tokens = new 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);
+        const res = check(token.value, type.token, ref, cache);
         if (!res.matched) {
-            const { offset, line, column } = token_1.Token.shiftLocation(token, res.offset);
+            const { offset, line, column } = Token.shiftLocation(token, res.offset);
             return {
                 ...res,
-                partName: (_a = res.partName) !== null && _a !== void 0 ? _a : 'the content of the list',
+                partName: res.partName ?? 'the content of the list',
                 offset,
                 line,
                 column,
             };
         }
     }
-    return (0, match_result_1.matched)();
+    return matched();
 }
-exports.checkList = checkList;

package/lib/match-result.d.ts

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

package/lib/match-result.js

@@ -1,34 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unmatched = exports.matched = exports.matches = void 0;
-function matches(checker, options) {
+export 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);
+        return valid ? matched() : unmatched(value, options?.reason, options);
     };
 }
-exports.matches = matches;
-function matched() {
+export function matched() {
     return {
         matched: true,
     };
 }
-exports.matched = matched;
-function unmatched(value, reason, options) {
-    var _a;
+export function unmatched(value, reason, options) {
     return {
         ...options,
         matched: false,
-        ref: (_a = options === null || options === void 0 ? void 0 : options.ref) !== null && _a !== void 0 ? _a : null,
+        ref: options?.ref ?? null,
         raw: value,
         offset: 0,
         length: value.length,
         line: 1,
         column: 1,
-        reason: reason !== null && reason !== void 0 ? reason : 'syntax-error',
+        reason: reason ?? 'syntax-error',
     };
 }
-exports.unmatched = unmatched;

package/lib/number.d.ts

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

package/lib/number.js

@@ -1,41 +1,37 @@
-"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) {
+import { matched, unmatched } from './match-result.js';
+import { isFloat, isInt } from './primitive/index.js';
+export function checkNumber(value, type, ref) {
     if (!value) {
-        return (0, match_result_1.unmatched)(value, 'empty-token');
+        return unmatched(value, 'empty-token');
     }
-    const syntaxMatched = type.type === 'float' ? (0, primitive_1.isFloat)(value) : (0, primitive_1.isInt)(value);
+    const syntaxMatched = type.type === 'float' ? isFloat(value) : isInt(value);
     if (syntaxMatched) {
-        const n = parseFloat(value);
-        if (!isFinite(n)) {
-            return (0, match_result_1.unmatched)(value, 'unexpected-token');
+        const n = Number.parseFloat(value);
+        if (!Number.isFinite(n)) {
+            return unmatched(value, 'unexpected-token');
         }
         const clampable = type.clampable;
         const isInt = type.type === 'integer';
         if (type.gt != null && n <= type.gt) {
-            return (0, match_result_1.unmatched)(value, 'out-of-range', {
+            return unmatched(value, 'out-of-range', {
                 candidate: clampable && isInt ? `${type.gt + 1}` : undefined,
             });
         }
         if (type.gte != null && n < type.gte) {
-            return (0, match_result_1.unmatched)(value, 'out-of-range', {
+            return unmatched(value, 'out-of-range', {
                 candidate: clampable ? `${type.gte}` : undefined,
             });
         }
         if (type.lt != null && type.lt <= n) {
-            return (0, match_result_1.unmatched)(value, 'out-of-range', {
+            return unmatched(value, 'out-of-range', {
                 candidate: clampable && isInt ? `${type.lt - 1}` : undefined,
             });
         }
         if (type.lte != null && type.lte < n) {
-            return (0, match_result_1.unmatched)(value, 'out-of-range', {
+            return unmatched(value, 'out-of-range', {
                 candidate: clampable ? `${type.lte}` : undefined,
             });
         }
     }
-    return syntaxMatched ? (0, match_result_1.matched)() : (0, match_result_1.unmatched)(value, 'unexpected-token');
+    return syntaxMatched ? matched() : unmatched(value, 'unexpected-token');
 }
-exports.checkNumber = checkNumber;

package/lib/primitive/index.d.ts

@@ -1,7 +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';
+export { isInt } from './is-int.js';
+export { isUint } from './is-uint.js';
+export { isFloat } from './is-float.js';
+export { isNonZeroUint } from './is-non-zero-uint.js';
+export { isQuantity } from './is-quantity.js';
+export { splitUnit } from './split-unit.js';
+export { range } from './range.js';

package/lib/primitive/index.js

@@ -1,17 +1,7 @@
-"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; } });
+export { isInt } from './is-int.js';
+export { isUint } from './is-uint.js';
+export { isFloat } from './is-float.js';
+export { isNonZeroUint } from './is-non-zero-uint.js';
+export { isQuantity } from './is-quantity.js';
+export { splitUnit } from './split-unit.js';
+export { range } from './range.js';

package/lib/primitive/is-float.js

@@ -1,12 +1,8 @@
-"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));
+export function isFloat(value) {
+    return value === value.trim() && Number.isFinite(Number.parseFloat(value));
 }
-exports.isFloat = isFloat;

package/lib/primitive/is-int.js

@@ -1,12 +1,8 @@
-"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);
+export function isInt(value) {
+    return /^-?\d+$/.test(value);
 }
-exports.isInt = isInt;

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

@@ -1,12 +1,8 @@
-"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);
+export function isNonZeroUint(value) {
+    return /^\d+$/.test(value) && !/^0+$/.test(value);
 }
-exports.isNonZeroUint = isNonZeroUint;

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

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

package/lib/primitive/is-quantity.js

@@ -1,36 +1,33 @@
-"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");
+import { isFloat } from './is-float.js';
+import { isInt } from './is-int.js';
+import { isUint } from './is-uint.js';
+import { splitUnit } from './split-unit.js';
 /**
  *
  * @param value
  * @param units
  * @param numberType
  */
-function isQuantity(value, units, numberType = 'float') {
-    const { num, unit } = (0, split_unit_1.splitUnit)(value);
+export function isQuantity(value, units, numberType = 'float') {
+    const { num, unit } = splitUnit(value);
     if (!units.includes(unit.toLowerCase())) {
         return false;
     }
     switch (numberType) {
         case 'int': {
-            if (!(0, is_int_1.isInt)(num)) {
+            if (!isInt(num)) {
                 return false;
             }
             break;
         }
         case 'uint': {
-            if (!(0, is_uint_1.isUint)(num)) {
+            if (!isUint(num)) {
                 return false;
             }
             break;
         }
         case 'float': {
-            if (!(0, is_float_1.isFloat)(num)) {
+            if (!isFloat(num)) {
                 return false;
             }
             break;
@@ -38,4 +35,3 @@ function isQuantity(value, units, numberType = 'float') {
     }
     return true;
 }
-exports.isQuantity = isQuantity;

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

@@ -3,9 +3,6 @@
  *
  * @param value
  */
-export declare function isUint(
-	value: string,
-	options?: {
-		readonly gt?: number;
-	},
-): boolean;
+export declare function isUint(value: string, options?: {
+    readonly gt?: number;
+}): boolean;

package/lib/primitive/is-uint.js

@@ -1,19 +1,15 @@
-"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, options) {
-    const matched = /^[0-9]+$/.test(value);
+export function isUint(value, options) {
+    const matched = /^\d+$/.test(value);
     if (matched && options) {
-        const n = parseInt(value, 10);
+        const n = Number.parseInt(value, 10);
         if (options.gt != null) {
-            return isFinite(n) && options.gt < n;
+            return Number.isFinite(n) && options.gt < n;
         }
     }
     return matched;
 }
-exports.isUint = isUint;

package/lib/primitive/range.js

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

package/lib/primitive/split-unit.d.ts

@@ -4,6 +4,6 @@
  * @returns
  */
 export declare function splitUnit(value: string): {
-	num: string;
-	unit: string;
+    num: string;
+    unit: string;
 };

package/lib/primitive/split-unit.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitUnit = void 0;
 /**
  *
  * @param value
  * @returns
  */
-function splitUnit(value) {
+export function splitUnit(value) {
     value = value.trim().toLowerCase();
-    const matched = value.match(/(^-?\.[0-9]+|^-?[0-9]+(?:\.[0-9]+(?:e[+-][0-9]+)?)?)([a-z]+$)/i);
+    const matched = value.match(/(^-?\.\d+|^-?\d+(?:\.\d+(?:e[+-]\d+)?)?)([a-z]+$)/i);
     if (!matched) {
         return {
             num: value,
@@ -17,8 +14,7 @@ function splitUnit(value) {
     }
     const [, num, unit] = matched;
     return {
-        num: num !== null && num !== void 0 ? num : value,
-        unit: unit !== null && unit !== void 0 ? unit : '',
+        num: num ?? value,
+        unit: unit ?? '',
     };
 }
-exports.splitUnit = splitUnit;

package/lib/rfc/is-bcp-47.d.ts

@@ -1,4 +1,4 @@
-import type { FormattedPrimitiveTypeCreator } from '../types';
+import type { FormattedPrimitiveTypeCreator } from '../types.js';
 /**
  * @see https://tools.ietf.org/rfc/bcp/bcp47.html
  */