@markuplint/types 3.8.0 → 4.0.0-alpha.1

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,4 +1,4 @@
-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 & {
     readonly ref?: string;
     readonly reason?: UnmatchedResultReason;

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';
+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.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.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: 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
  */

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,8 +1,7 @@
-import type { TokenValue } from './types';
-import type { UnmatchedResult } from '..';
-import type { Expect, Result, List } from '../types';
+import type { TokenValue } from './types.js';
+import type { Expect, Result, List, UnmatchedResult } from '../types.js';
 import type { ReadonlyDeep } from 'type-fest';
-import { Token } from './token';
+import { Token } from './token.js';
 type TokenCollectionOptions = Partial<Omit<List, 'token'> & {
     specificSeparator: string | string[];
 }>;
@@ -26,7 +25,7 @@ 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: Readonly<Token>, current: Readonly<Token>) => Readonly<Token> | null | void): Readonly<Token> | null | undefined;
     divide(position: number): readonly [TokenCollection, TokenCollection];