@markuplint/types 3.1.0 → 3.3.0

package/lib/check-multi-types.d.ts

@@ -1,2 +1,5 @@
 import type { CustomSyntaxCheck, UnmatchedResult } from './types';
-export declare function checkMultiTypes(value: string, checks: CustomSyntaxCheck[]): import("./types").MatchedResult | UnmatchedResult;
+export declare function checkMultiTypes(
+	value: string,
+	checks: CustomSyntaxCheck[],
+): UnmatchedResult | import('./types').MatchedResult;

package/lib/check.spec.js

@@ -1,4 +1,5 @@
 "use strict";
+// @ts-nocheck
 Object.defineProperty(exports, "__esModule", { value: true });
 const check_1 = require("./check");
 test('Any', () => {

package/lib/css-syntax.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cssSyntaxMatch = void 0;
-const tslib_1 = require("tslib");
-const css_tree_1 = tslib_1.__importDefault(require("css-tree"));
+const css_tree_1 = require("css-tree");
 const debug_1 = require("./debug");
 const defs_1 = require("./defs");
 const match_result_1 = require("./match-result");
@@ -39,7 +38,7 @@ function cssSyntaxMatch(value, type) {
             if (typeof valueOrChecker === 'string') {
                 typesExtended[key] = valueOrChecker;
             }
-            else {
+            else if (valueOrChecker) {
                 typesCheckers[key] = valueOrChecker;
             }
         });
@@ -53,15 +52,17 @@ function cssSyntaxMatch(value, type) {
         ref = type.ref;
     }
     // @ts-ignore
-    const lexer = css_tree_1.default.fork({
+    const lexer = (0, css_tree_1.fork)({
         types: typesExtended,
         properties: propsExtended,
     }).lexer;
     Object.keys(typesCheckers).forEach(key => {
         const checker = typesCheckers[key];
-        lexer.addType_(key, (token, getNextToken) => checker(token, getNextToken, cssSyntaxMatch));
+        // @ts-ignore
+        lexer.addType_(key, (token, getNextToken) => checker === null || checker === void 0 ? void 0 : checker(token, getNextToken, cssSyntaxMatch));
     });
     const { isProp, name } = detectName(defName);
+    // @ts-ignore
     const matcher = isProp ? lexer.properties[name] : lexer.types[name];
     if (!matcher) {
         (0, debug_1.log)('"%s" CSS syntax not found', defName);
@@ -79,12 +80,12 @@ function cssSyntaxMatch(value, type) {
     (0, debug_1.log)('css-tree/result: %O', result);
     // eslint-disable-next-line no-console
     console.warn = _w;
-    if (result.matched) {
-        if (debug_1.log.enabled) {
-            (0, debug_1.log)('css-tree/result.matched: %s', JSON.stringify(result.matched, null, 2));
-        }
+    if (!result.error) {
         return (0, match_result_1.matched)();
     }
+    if (!('css' in result.error)) {
+        throw result.error;
+    }
     const error = result.error;
     if (caseSensitive) {
         const offset = error.mismatchOffset % MIMIC_LENGTH;
@@ -127,6 +128,9 @@ function detectName(def) {
 }
 function eachMimicCases(key, obj) {
     const value = obj[key];
+    if (!value) {
+        return;
+    }
     obj[key] = mimicCases(value);
 }
 function mimicCases(value) {

package/lib/css-syntax.spec.js

@@ -1,4 +1,5 @@
 "use strict";
+// @ts-nocheck
 Object.defineProperty(exports, "__esModule", { value: true });
 const css_syntax_1 = require("./css-syntax");
 test('CSS Standard', () => {

package/lib/defs.js

@@ -431,7 +431,7 @@ exports.types = {
             if (!height) {
                 return sep.unmatched({ reason: 'unexpected-token' });
             }
-            if (tail && tail.length) {
+            if (tail && tail[0]) {
                 return tail[0].unmatched({ reason: 'extra-token' });
             }
             if (!(0, primitive_1.isUint)(width.value)) {

package/lib/get-candidate.d.ts

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

package/lib/list.spec.js

@@ -1,4 +1,5 @@
 "use strict";
+// @ts-nocheck
 Object.defineProperty(exports, "__esModule", { value: true });
 const list_1 = require("./list");
 test('Zero space', () => {

package/lib/match-result.d.ts

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

package/lib/primitive/index.spec.js

@@ -1,4 +1,5 @@
 "use strict";
+// @ts-nocheck
 Object.defineProperty(exports, "__esModule", { value: true });
 const _1 = require(".");
 test('int', () => {

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

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

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

@@ -17,8 +17,8 @@ function splitUnit(value) {
     }
     const [, num, unit] = matched;
     return {
-        num,
-        unit,
+        num: num !== null && num !== void 0 ? num : value,
+        unit: unit !== null && unit !== void 0 ? unit : '',
     };
 }
 exports.splitUnit = splitUnit;

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

@@ -1,4 +1,5 @@
 "use strict";
+// @ts-nocheck
 Object.defineProperty(exports, "__esModule", { value: true });
 const is_bcp_47_1 = require("./is-bcp-47");
 const is = (0, is_bcp_47_1.isBCP47)();

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

@@ -1,62 +1,71 @@
 import type { UnmatchedResult } from '..';
 import type { Expect, Result, List } from '../types';
 import { Token } from './token';
-type TokenCollectionOptions = Partial<Omit<List, 'token'> & {
-    specificSeparator: string | string[];
-}>;
+type TokenCollectionOptions = Partial<
+	Omit<List, 'token'> & {
+		specificSeparator: string | string[];
+	}
+>;
 export type TokenEachCheck = (head: Token | null, tail: TokenCollection) => Result | void;
 export declare class TokenCollection extends Array<Token> {
-    static fromPatterns(value: Token | string, patterns: RegExp[], typeOptions?: Omit<TokenCollectionOptions, 'specificSeparator'> & {
-        repeat?: boolean;
-    }): TokenCollection;
-    static get [Symbol.species](): ArrayConstructor;
-    readonly allowEmpty: NonNullable<List['allowEmpty']>;
-    readonly caseInsensitive: NonNullable<List['caseInsensitive']>;
-    readonly disallowToSurroundBySpaces: NonNullable<List['disallowToSurroundBySpaces']>;
-    readonly number: List['number'];
-    readonly ordered: NonNullable<List['ordered']>;
-    readonly separator: NonNullable<List['separator']>;
-    readonly unique: NonNullable<List['unique']>;
-    constructor(value?: string, typeOptions?: TokenCollectionOptions);
-    constructor(value?: number);
-    get value(): string;
-    check(options?: {
-        expects?: Expect[];
-        ref?: string;
-        cache?: boolean;
-    }): import("..").MatchedResult | UnmatchedResult;
-    chunk(split: number): TokenCollection[];
-    compareTokens(callback: (prev: Token, current: Token) => Token | null | void): 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;
-    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;
-    headAndTail(): {
-        head: Token | null;
-        tail: TokenCollection;
-    };
-    /**
-     *
-     * @param value The token value or the token type or its list
-     */
-    search(value: string | RegExp | number | (string | RegExp | number)[]): Token | null;
-    takeTurns(tokenNumbers: ReadonlyArray<number>, lastTokenNumber?: number): {
-        unexpectedLastToken: boolean;
-        expectedTokenNumber: number;
-        token: Token;
-    } | null;
-    toJSON(): {
-        type: number;
-        value: string;
-        offset: number;
-    }[];
-    private static _new;
+	static fromPatterns(
+		value: Token | string,
+		patterns: RegExp[],
+		typeOptions?: Omit<TokenCollectionOptions, 'specificSeparator'> & {
+			repeat?: boolean;
+		},
+	): TokenCollection;
+	static get [Symbol.species](): ArrayConstructor;
+	readonly allowEmpty: NonNullable<List['allowEmpty']>;
+	readonly caseInsensitive: NonNullable<List['caseInsensitive']>;
+	readonly disallowToSurroundBySpaces: NonNullable<List['disallowToSurroundBySpaces']>;
+	readonly number: List['number'];
+	readonly ordered: NonNullable<List['ordered']>;
+	readonly separator: NonNullable<List['separator']>;
+	readonly unique: NonNullable<List['unique']>;
+	constructor(value?: string, typeOptions?: TokenCollectionOptions);
+	constructor(value?: number);
+	get value(): string;
+	check(options?: {
+		expects?: Expect[];
+		ref?: string;
+		cache?: boolean;
+	}): UnmatchedResult | import('..').MatchedResult;
+	chunk(split: number): TokenCollection[];
+	compareTokens(callback: (prev: Token, current: Token) => Token | null | void): 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;
+	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;
+	headAndTail(): {
+		head: Token | null;
+		tail: TokenCollection;
+	};
+	/**
+	 *
+	 * @param value The token value or the token type or its list
+	 */
+	search(value: string | RegExp | number | (string | RegExp | number)[]): Token | null;
+	takeTurns(
+		tokenNumbers: ReadonlyArray<number>,
+		lastTokenNumber?: number,
+	): {
+		unexpectedLastToken: boolean;
+		expectedTokenNumber: number | undefined;
+		token: Token;
+	} | null;
+	toJSON(): {
+		type: number;
+		value: string;
+		offset: number;
+	}[];
+	private static _new;
 }
 export {};

package/lib/token/token-collection.js

@@ -88,8 +88,9 @@ class TokenCollection extends Array {
                 continue;
             }
             const lastChar = last[0];
-            if (!separators.includes(char) &&
-                !separators.includes(last[0]) &&
+            if (lastChar &&
+                !separators.includes(char) &&
+                !separators.includes(lastChar) &&
                 ((token_1.Token.whitespace.includes(lastChar) && token_1.Token.whitespace.includes(char)) ||
                     (!token_1.Token.whitespace.includes(lastChar) && !token_1.Token.whitespace.includes(char)))) {
                 values.push(last + char);
@@ -353,6 +354,9 @@ class TokenCollection extends Array {
         const tokens = this.slice();
         for (let i = 0; i < tokens.length; i++) {
             const token = tokens[i];
+            if (!token) {
+                continue;
+            }
             const expectedTokenNumber = tokenNumbers[i % tokenNumbers.length];
             if (token.type !== expectedTokenNumber) {
                 return {

package/lib/token/token-collection.spec.js

@@ -1,4 +1,5 @@
 "use strict";
+// @ts-nocheck
 Object.defineProperty(exports, "__esModule", { value: true });
 const token_collection_1 = require("./token-collection");
 const _1 = require(".");

package/lib/token/token.d.ts

@@ -1,55 +1,60 @@
 import type { UnmatchedResult, UnmatchedResultOptions, UnmatchedResultReason } from '../types';
 export declare class Token {
-    #private;
-    /**
-     * @see https://github.com/csstree/csstree/blob/master/lib/tokenizer/types.js
-     */
-    static readonly Comma = 18;
-    static readonly Ident = 1;
-    static readonly WhiteSpace = 13;
-    /**
-     * ASCII whitespace is
-     * - U+0009 TAB
-     * - U+000A LF
-     * - U+000C FF
-     * - U+000D CR
-     * - U+0020 SPACE.
-     *
-     * @see https://infra.spec.whatwg.org/#ascii-whitespace
-     */
-    static readonly whitespace: ReadonlyArray<string>;
-    static getCol(value: string, offset: number): number;
-    static getLine(value: string, offset: number): number;
-    static getType(value: string, separators?: string[]): 1 | 13 | 18;
-    static shiftLocation(token: Token, offset: number): {
-        offset: number;
-        line: number;
-        column: number;
-    };
-    readonly offset: number;
-    readonly type: number;
-    readonly value: string;
-    constructor(value: string, offset: number, originalValue: string, separators?: string[]);
-    get length(): number;
-    get origin(): string;
-    /**
-     *
-     * @param value The token value or the token type or its list
-     */
-    includes(value: string | RegExp | number | (string | RegExp | number)[], caseInsensitive?: boolean): boolean;
-    /**
-     *
-     * @param value The token value or the token type or its list
-     */
-    match(value: string | RegExp | number | (string | RegExp | number)[], caseInsensitive?: boolean): boolean;
-    toJSON(): {
-        type: number;
-        value: string;
-        offset: number;
-    };
-    toNumber(): number;
-    unmatched(options?: UnmatchedResultOptions & {
-        ref?: string;
-        reason?: UnmatchedResultReason;
-    }): UnmatchedResult;
+	#private;
+	/**
+	 * @see https://github.com/csstree/csstree/blob/master/lib/tokenizer/types.js
+	 */
+	static readonly Comma = 18;
+	static readonly Ident = 1;
+	static readonly WhiteSpace = 13;
+	/**
+	 * ASCII whitespace is
+	 * - U+0009 TAB
+	 * - U+000A LF
+	 * - U+000C FF
+	 * - U+000D CR
+	 * - U+0020 SPACE.
+	 *
+	 * @see https://infra.spec.whatwg.org/#ascii-whitespace
+	 */
+	static readonly whitespace: ReadonlyArray<string>;
+	static getCol(value: string, offset: number): number;
+	static getLine(value: string, offset: number): number;
+	static getType(value: string, separators?: string[]): 1 | 13 | 18;
+	static shiftLocation(
+		token: Token,
+		offset: number,
+	): {
+		offset: number;
+		line: number;
+		column: number;
+	};
+	readonly offset: number;
+	readonly type: number;
+	readonly value: string;
+	constructor(value: string, offset: number, originalValue: string, separators?: string[]);
+	get length(): number;
+	get origin(): string;
+	/**
+	 *
+	 * @param value The token value or the token type or its list
+	 */
+	includes(value: string | RegExp | number | (string | RegExp | number)[], caseInsensitive?: boolean): boolean;
+	/**
+	 *
+	 * @param value The token value or the token type or its list
+	 */
+	match(value: string | RegExp | number | (string | RegExp | number)[], caseInsensitive?: boolean): boolean;
+	toJSON(): {
+		type: number;
+		value: string;
+		offset: number;
+	};
+	toNumber(): number;
+	unmatched(
+		options?: UnmatchedResultOptions & {
+			ref?: string;
+			reason?: UnmatchedResultReason;
+		},
+	): UnmatchedResult;
 }

package/lib/token/token.js

@@ -5,17 +5,19 @@ exports.Token = void 0;
 const tslib_1 = require("tslib");
 class Token {
     static getCol(value, offset) {
+        var _a;
         const lines = value.slice(0, offset).split(/\n/g);
-        return lines[lines.length - 1].length + 1;
+        return ((_a = lines[lines.length - 1]) !== null && _a !== void 0 ? _a : '').length + 1;
     }
     static getLine(value, offset) {
         return value.slice(0, offset).split(/\n/g).length;
     }
     static getType(value, separators) {
-        if (Token.whitespace.includes(value[0])) {
+        var _a, _b;
+        if (Token.whitespace.includes((_a = value[0]) !== null && _a !== void 0 ? _a : '')) {
             return Token.WhiteSpace;
         }
-        if (separators === null || separators === void 0 ? void 0 : separators.includes(value[0])) {
+        if (separators === null || separators === void 0 ? void 0 : separators.includes((_b = value[0]) !== null && _b !== void 0 ? _b : '')) {
             switch (value[0]) {
                 case ',':
                     return Token.Comma;

package/lib/types.d.ts

@@ -2,77 +2,101 @@ import type { cssSyntaxMatch } from './css-syntax';
 export type { Type, List, Enum, CssSyntax, KeywordDefinedType, Number } from './types.schema';
 export type Result = UnmatchedResult | MatchedResult;
 export type UnmatchedResult = {
-    matched: false;
-    ref: string | null;
-    raw: string;
-    length: number;
-    offset: number;
-    line: number;
-    column: number;
-    reason: UnmatchedResultReason;
-    passCount?: number;
+	matched: false;
+	ref: string | null;
+	raw: string;
+	length: number;
+	offset: number;
+	line: number;
+	column: number;
+	reason: UnmatchedResultReason;
+	passCount?: number;
 } & UnmatchedResultOptions;
 export type UnmatchedResultOptions = {
-    partName?: string;
-    expects?: Expect[];
-    extra?: Expect;
-    candidate?: string;
-};
-export type UnmatchedResultReason = 'syntax-error' | 'typo' | 'missing-token' | 'missing-comma' | 'unexpected-token' | 'unexpected-space' | 'unexpected-newline' | 'unexpected-comma' | 'empty-token' | 'out-of-range' | 'doesnt-exist-in-enum' | 'duplicated' | 'illegal-combination' | 'illegal-order' | 'extra-token' | 'must-be-percent-encoded' | 'must-be-serialized' | {
-    type: 'out-of-range';
-    gt?: number;
-    gte?: number;
-    lt?: number;
-    lte?: number;
-} | {
-    type: 'out-of-range-length-char';
-    gte: number;
-    lte?: number;
-} | {
-    type: 'out-of-range-length-digit';
-    gte: number;
-    lte?: number;
+	partName?: string;
+	expects?: Expect[];
+	extra?: Expect;
+	candidate?: string;
 };
+export type UnmatchedResultReason =
+	| 'syntax-error'
+	| 'typo'
+	| 'missing-token'
+	| 'missing-comma'
+	| 'unexpected-token'
+	| 'unexpected-space'
+	| 'unexpected-newline'
+	| 'unexpected-comma'
+	| 'empty-token'
+	| 'out-of-range'
+	| 'doesnt-exist-in-enum'
+	| 'duplicated'
+	| 'illegal-combination'
+	| 'illegal-order'
+	| 'extra-token'
+	| 'must-be-percent-encoded'
+	| 'must-be-serialized'
+	| {
+			type: 'out-of-range';
+			gt?: number;
+			gte?: number;
+			lt?: number;
+			lte?: number;
+	  }
+	| {
+			type: 'out-of-range-length-char';
+			gte: number;
+			lte?: number;
+	  }
+	| {
+			type: 'out-of-range-length-digit';
+			gte: number;
+			lte?: number;
+	  };
 export type MatchedResult = {
-    matched: true;
+	matched: true;
 };
 export type Expect = {
-    type: 'const' | 'format' | 'syntax' | 'regexp' | 'common';
-    value: string;
+	type: 'const' | 'format' | 'syntax' | 'regexp' | 'common';
+	value: string;
 };
 export type FormattedPrimitiveTypeCheck = (value: string) => boolean;
 export type FormattedPrimitiveTypeCreator<O = never> = (options?: O) => FormattedPrimitiveTypeCheck;
 export type Defs = Record<string, CustomCssSyntax | CustomSyntax>;
 export type CustomSyntax = {
-    ref: string;
-    expects?: Expect[];
-    is: CustomSyntaxCheck;
+	ref: string;
+	expects?: Expect[];
+	is: CustomSyntaxCheck;
 };
 export type CustomSyntaxCheck = (value: string) => Result;
 export type CustomSyntaxChecker<O = {}> = (options?: O) => CustomSyntaxCheck;
 export type CustomCssSyntax = {
-    ref: string;
-    caseSensitive?: boolean;
-    expects?: Expect[];
-    syntax: {
-        apply: `<${string}>`;
-        def: Record<string, string | CssSyntaxTokenizer>;
-        /**
-         * @deprecated
-         */
-        ebnf?: Record<string, string | string[]>;
-        /**
-         * @deprecated
-         */
-        properties?: Record<string, string>;
-    };
+	ref: string;
+	caseSensitive?: boolean;
+	expects?: Expect[];
+	syntax: {
+		apply: `<${string}>`;
+		def: Record<string, string | CssSyntaxTokenizer>;
+		/**
+		 * @deprecated
+		 */
+		ebnf?: Record<string, string | string[]>;
+		/**
+		 * @deprecated
+		 */
+		properties?: Record<string, string>;
+	};
 };
 export type CSSSyntaxToken = {
-    type: number;
-    value: string;
-    index: number;
-    balance: number;
-    node?: any;
+	type: number;
+	value: string;
+	index: number;
+	balance: number;
+	node?: any;
 };
-export type CssSyntaxTokenizer = (token: CSSSyntaxToken | null, getNextToken: GetNextToken, match: typeof cssSyntaxMatch) => number;
+export type CssSyntaxTokenizer = (
+	token: CSSSyntaxToken | null,
+	getNextToken: GetNextToken,
+	match: typeof cssSyntaxMatch,
+) => number;
 export type GetNextToken = (length: number) => CSSSyntaxToken | null;