@markuplint/types 3.0.0-dev.25 → 3.0.0-dev.300

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,28 +28,27 @@ function checkKeywordType(value, type, cache = true) {
     }
     return result;
 }
-exports.checkKeywordType = checkKeywordType;
 function _checkKeywordType(value, type) {
-    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)();
+                log("Allow all of any value because the type doesn't exist");
+                return matched();
             }
             throw e;
         }
     }
-    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: matches.ref || def.ref,
-            expects: matches.expects || def.expects,
+            ref: matches.ref ?? def.ref,
+            expects: matches.expects ?? def.expects,
         };
     }
     return matches;

package/lib/list.d.ts

@@ -1,3 +1,4 @@
-import type { Result } from './types';
-import type { List } from './types.schema';
-export declare function checkList(value: string, type: List, ref?: string, cache?: boolean): Result;
+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,29 +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) {
-    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: res.partName || '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,9 +1,9 @@
-import type { FormattedPrimitiveTypeCheck, MatchedResult, UnmatchedResult, UnmatchedResultOptions, UnmatchedResultReason } from './types';
+import type { FormattedPrimitiveTypeCheck, MatchedResult, UnmatchedResult, UnmatchedResultOptions, UnmatchedResultReason } from './types.js';
 export declare function matches(checker: FormattedPrimitiveTypeCheck, options?: UnmatchedResultOptions & {
-    ref?: string;
-    reason?: UnmatchedResultReason;
+    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 & {
-    ref?: string;
+    readonly ref?: string;
 }): UnmatchedResult;

package/lib/match-result.js

@@ -1,33 +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) {
+export function unmatched(value, reason, options) {
     return {
         ...options,
         matched: false,
-        ref: (options === null || options === void 0 ? void 0 : options.ref) || 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: Number, ref?: string): Result;
+import type { Result } from './types.js';
+import type { Number } from './types.schema.js';
+export declare function checkNumber(value: string, type: Readonly<Number>, 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');
+            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) {
+export function isFloat(value) {
     return value === value.trim() && Number.isFinite(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) {
+export function isInt(value) {
     return /^-?[0-9]+$/.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) {
+export function isNonZeroUint(value) {
     return /^[0-9]+$/.test(value) && !/^0+$/.test(value);
 }
-exports.isNonZeroUint = isNonZeroUint;

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

@@ -4,4 +4,4 @@
  * @param units
  * @param numberType
  */
-export declare function isQuantity(value: string, units: 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

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

package/lib/primitive/is-uint.js

@@ -1,12 +1,9 @@
-"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) {
+export function isUint(value, options) {
     const matched = /^[0-9]+$/.test(value);
     if (matched && options) {
         const n = parseInt(value, 10);
@@ -16,4 +13,3 @@ function isUint(value, options) {
     }
     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) {
+export function range(value, from, to) {
     const num = parseFloat(value);
     if (isNaN(num)) {
         return false;
     }
     return from <= num && num <= to;
 }
-exports.range = range;

package/lib/primitive/split-unit.js

@@ -1,12 +1,9 @@
-"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);
     if (!matched) {
@@ -17,8 +14,7 @@ function splitUnit(value) {
     }
     const [, num, unit] = matched;
     return {
-        num,
-        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
  */

package/lib/rfc/is-bcp-47.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBCP47 = void 0;
-const bcp_47_1 = require("bcp-47");
+import { parse } from 'bcp-47';
 /**
  * @see https://tools.ietf.org/rfc/bcp/bcp47.html
  */
-const isBCP47 = () => {
+export const isBCP47 = () => {
     return value => {
-        const { language } = (0, bcp_47_1.parse)(value);
+        const { language } = parse(value);
         return !!language;
     };
 };
-exports.isBCP47 = isBCP47;

package/lib/token/index.d.ts

@@ -1,2 +1,2 @@
-export { Token } from './token';
-export { TokenCollection } from './token-collection';
+export { Token } from './token.js';
+export { TokenCollection } from './token-collection.js';

package/lib/token/index.js

@@ -1,7 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenCollection = exports.Token = void 0;
-var token_1 = require("./token");
-Object.defineProperty(exports, "Token", { enumerable: true, get: function () { return token_1.Token; } });
-var token_collection_1 = require("./token-collection");
-Object.defineProperty(exports, "TokenCollection", { enumerable: true, get: function () { return token_collection_1.TokenCollection; } });
+export { Token } from './token.js';
+export { TokenCollection } from './token-collection.js';

package/lib/token/token-collection.d.ts

@@ -1,12 +1,12 @@
-import type { UnmatchedResult } from '..';
-import type { Expect, Result, List } from '../types';
-import { Token } from './token';
+import type { TokenValue } from './types.js';
+import type { Expect, Result, List, UnmatchedResult } from '../types.js';
+import { Token } from './token.js';
 type TokenCollectionOptions = Partial<Omit<List, 'token'> & {
     specificSeparator: string | string[];
 }>;
-export type TokenEachCheck = (head: Token | null, tail: TokenCollection) => Result | void;
+export type TokenEachCheck = (head: Readonly<Token> | null, tail: TokenCollection) => Result | void;
 export declare class TokenCollection extends Array<Token> {
-    static fromPatterns(value: Token | string, patterns: RegExp[], typeOptions?: Omit<TokenCollectionOptions, 'specificSeparator'> & {
+    static fromPatterns(value: Readonly<Token> | string, patterns: readonly Readonly<RegExp>[], typeOptions?: Omit<TokenCollectionOptions, 'specificSeparator'> & {
         repeat?: boolean;
     }): TokenCollection;
     static get [Symbol.species](): ArrayConstructor;
@@ -24,20 +24,20 @@ export declare class TokenCollection extends Array<Token> {
         expects?: Expect[];
         ref?: string;
         cache?: boolean;
-    }): import("..").MatchedResult | UnmatchedResult;
+    }): import("../types.js").MatchedResult | UnmatchedResult;
     chunk(split: number): TokenCollection[];
-    compareTokens(callback: (prev: Token, current: Token) => Token | null | void): Token | null | undefined;
+    compareTokens(callback: (prev: Readonly<Token>, current: Readonly<Token>) => Readonly<Token> | null | void): Readonly<Token> | null | undefined;
     divide(position: number): readonly [TokenCollection, TokenCollection];
-    eachCheck(...callbacks: TokenEachCheck[]): Result;
-    filter(callback: (value: Token, index: number, array: Token[]) => boolean): TokenCollection;
-    getConsecutiveToken(tokenType: number): Token | null;
+    eachCheck(...callbacks: readonly TokenEachCheck[]): Result;
+    filter(callback: Parameters<Array<Token>['filter']>[0]): TokenCollection;
+    getConsecutiveToken(tokenType: number): Readonly<Token> | null;
     getDuplicated(): Token | null;
     getIdentTokens(): TokenCollection;
     /**
      *
      * @param value The token value or the token type or its list
      */
-    has(value: string | RegExp | number | (string | RegExp | number)[]): boolean;
+    has(value: TokenValue): boolean;
     headAndTail(): {
         head: Token | null;
         tail: TokenCollection;
@@ -46,10 +46,10 @@ export declare class TokenCollection extends Array<Token> {
      *
      * @param value The token value or the token type or its list
      */
-    search(value: string | RegExp | number | (string | RegExp | number)[]): Token | null;
+    search(value: TokenValue): Token | null;
     takeTurns(tokenNumbers: ReadonlyArray<number>, lastTokenNumber?: number): {
         unexpectedLastToken: boolean;
-        expectedTokenNumber: number;
+        expectedTokenNumber: number | undefined;
         token: Token;
     } | null;
     toJSON(): {