@markuplint/types 3.3.0 → 3.4.0

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

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

package/lib/check.d.ts

@@ -1,8 +1,9 @@
 import type { Type, Result, List, CustomSyntax, CustomCssSyntax, Enum, KeywordDefinedType, Number } from './types';
-export declare function check(value: string, type: Type, ref?: string, cache?: boolean): Result;
-export declare function isKeyword(type: Type): type is KeywordDefinedType;
-export declare function isList(type: Type): type is List;
-export declare function isEnum(type: Type): type is Enum;
-export declare function isNumber(type: Type): type is Number;
+import type { ReadonlyDeep } from 'type-fest';
+export declare function check(value: string, type: ReadonlyDeep<Type>, ref?: string, cache?: boolean): Result;
+export declare function isKeyword(type: ReadonlyDeep<Type>): type is ReadonlyDeep<KeywordDefinedType>;
+export declare function isList(type: ReadonlyDeep<Type>): type is ReadonlyDeep<List>;
+export declare function isEnum(type: ReadonlyDeep<Type>): type is ReadonlyDeep<Enum>;
+export declare function isNumber(type: ReadonlyDeep<Type>): type is ReadonlyDeep<Number>;
 export declare function isCSSSyntax(type: CustomSyntax | CustomCssSyntax): type is CustomCssSyntax;
 export declare function isCustomSyntax(type: CustomSyntax | CustomCssSyntax): type is CustomSyntax;

package/lib/css-syntax.js

@@ -126,7 +126,17 @@ function detectName(def) {
         name,
     };
 }
-function eachMimicCases(key, obj) {
+/**
+ *
+ * @param key
+ * @param obj
+ * @modifies obj
+ * @returns
+ */
+function eachMimicCases(key, 
+// Mutable
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+obj) {
     const value = obj[key];
     if (!value) {
         return;

package/lib/enum.d.ts

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

package/lib/enum.js

@@ -9,7 +9,7 @@ function checkEnum(value, type, ref) {
     if (!disallowToSurroundBySpaces) {
         value = value.trim();
     }
-    let values = type.enum;
+    let values = type.enum.slice();
     if (caseInsensitive) {
         value = value.toLowerCase();
         values = type.enum.map(v => v.toLowerCase());

package/lib/get-candidate.d.ts

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

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 { ReadonlyDeep } from 'type-fest';
+export declare function checkList(value: string, type: ReadonlyDeep<List>, ref?: string, cache?: boolean): Result;

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 & {
-		ref?: string;
-		reason?: UnmatchedResultReason;
-	},
-): (value: string) => UnmatchedResult | MatchedResult;
+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) => MatchedResult | UnmatchedResult;
 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 & {
+    readonly ref?: string;
+}): UnmatchedResult;

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;
+export declare function checkNumber(value: string, type: Readonly<Number>, ref?: string): Result;

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-uint.d.ts

@@ -3,9 +3,6 @@
  *
  * @param value
  */
-export declare function isUint(
-	value: string,
-	options?: {
-		gt?: number;
-	},
-): boolean;
+export declare function isUint(value: string, options?: {
+    readonly 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/token/token-collection.d.ts

@@ -1,71 +1,64 @@
+import type { TokenValue } from './types';
 import type { UnmatchedResult } from '..';
 import type { Expect, Result, List } from '../types';
+import type { ReadonlyDeep } from 'type-fest';
 import { Token } from './token';
-type TokenCollectionOptions = Partial<
-	Omit<List, 'token'> & {
-		specificSeparator: string | string[];
-	}
->;
-export type TokenEachCheck = (head: Token | null, tail: TokenCollection) => Result | void;
+type TokenCollectionOptions = Partial<Omit<List, 'token'> & {
+    specificSeparator: string | string[];
+}>;
+export type TokenEachCheck = (head: Readonly<Token> | null, tail: ReadonlyDeep<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;
-	}): 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;
+    static fromPatterns(value: Readonly<Token> | string, patterns: readonly Readonly<RegExp>[], typeOptions?: ReadonlyDeep<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?: ReadonlyDeep<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: Readonly<Token>, current: Readonly<Token>) => Readonly<Token> | null | void): Readonly<Token> | null | undefined;
+    divide(position: number): readonly [TokenCollection, TokenCollection];
+    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: TokenValue): boolean;
+    headAndTail(): {
+        head: Token | null;
+        tail: TokenCollection;
+    };
+    /**
+     *
+     * @param value The token value or the token type or its list
+     */
+    search(value: TokenValue): 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

@@ -5,12 +5,12 @@ const match_result_1 = require("../match-result");
 const token_1 = require("./token");
 class TokenCollection extends Array {
     static fromPatterns(value, patterns, typeOptions) {
-        const origin = typeof value === 'string' ? value : value.origin;
+        const originalValue = typeof value === 'string' ? value : value.originalValue;
         let strings = typeof value === 'string' ? value : value.value;
         let cumulativeOffset = typeof value === 'string' ? 0 : value.offset;
         const tokens = [];
         function addToken(tokenValue) {
-            const token = new token_1.Token(tokenValue, cumulativeOffset, origin);
+            const token = new token_1.Token(tokenValue, cumulativeOffset, originalValue);
             tokens.push(token);
             strings = strings.slice(tokenValue.length);
             cumulativeOffset += tokenValue.length;
@@ -71,11 +71,11 @@ class TokenCollection extends Array {
             separators.push(',');
         }
         if (typeOptions === null || typeOptions === void 0 ? void 0 : typeOptions.specificSeparator) {
-            if (Array.isArray(typeOptions.specificSeparator)) {
-                separators.push(...typeOptions.specificSeparator);
+            if (typeof typeOptions.specificSeparator === 'string') {
+                separators.push(typeOptions.specificSeparator);
             }
             else {
-                separators.push(typeOptions.specificSeparator);
+                separators.push(...typeOptions.specificSeparator);
             }
         }
         const chars = value.split('');

package/lib/token/token.d.ts

@@ -1,60 +1,56 @@
+import type { TokenValue } from './types';
 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;
+    /**
+     * @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?: readonly string[]): 1 | 13 | 18;
+    static shiftLocation(token: Readonly<Token>, offset: number): {
+        offset: number;
+        line: number;
+        column: number;
+    };
+    readonly offset: number;
+    readonly originalValue: string;
+    readonly type: number;
+    readonly value: string;
+    constructor(value: string, offset: number, originalValue: string, separators?: readonly string[]);
+    get length(): number;
+    clone(): Token;
+    /**
+     *
+     * @param value The token value or the token type or its list
+     */
+    includes(value: TokenValue, caseInsensitive?: boolean): boolean;
+    /**
+     *
+     * @param value The token value or the token type or its list
+     */
+    match(value: TokenValue, caseInsensitive?: boolean): boolean;
+    toJSON(): {
+        type: number;
+        value: string;
+        offset: number;
+    };
+    toNumber(): number;
+    unmatched(options?: UnmatchedResultOptions & {
+        readonly ref?: string;
+        readonly reason?: UnmatchedResultReason;
+    }): UnmatchedResult;
 }

package/lib/token/token.js

@@ -1,8 +1,6 @@
 "use strict";
-var _Token_originalValue;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Token = void 0;
-const tslib_1 = require("tslib");
 class Token {
     static getCol(value, offset) {
         var _a;
@@ -29,22 +27,21 @@ class Token {
         const shifted = token.offset + offset;
         return {
             offset: shifted,
-            line: Token.getLine(tslib_1.__classPrivateFieldGet(token, _Token_originalValue, "f"), shifted),
-            column: Token.getCol(tslib_1.__classPrivateFieldGet(token, _Token_originalValue, "f"), shifted),
+            line: Token.getLine(token.originalValue, shifted),
+            column: Token.getCol(token.originalValue, shifted),
         };
     }
     constructor(value, offset, originalValue, separators) {
-        _Token_originalValue.set(this, void 0);
         this.type = Token.getType(value, separators);
         this.value = value;
         this.offset = offset;
-        tslib_1.__classPrivateFieldSet(this, _Token_originalValue, originalValue, "f");
+        this.originalValue = originalValue;
     }
     get length() {
         return this.value.length;
     }
-    get origin() {
-        return tslib_1.__classPrivateFieldGet(this, _Token_originalValue, "f");
+    clone() {
+        return new Token(this.value, this.offset, this.originalValue);
     }
     /**
      *
@@ -103,14 +100,12 @@ class Token {
             raw: this.value,
             offset: this.offset,
             length: this.value.length,
-            line: Token.getLine(tslib_1.__classPrivateFieldGet(this, _Token_originalValue, "f"), this.offset),
-            column: Token.getCol(tslib_1.__classPrivateFieldGet(this, _Token_originalValue, "f"), this.offset),
+            line: Token.getLine(this.originalValue, this.offset),
+            column: Token.getCol(this.originalValue, this.offset),
             reason: (_a = options === null || options === void 0 ? void 0 : options.reason) !== null && _a !== void 0 ? _a : 'syntax-error',
         };
     }
 }
-exports.Token = Token;
-_Token_originalValue = new WeakMap();
 /**
  * @see https://github.com/csstree/csstree/blob/master/lib/tokenizer/types.js
  */
@@ -128,3 +123,4 @@ Token.WhiteSpace = 13;
  * @see https://infra.spec.whatwg.org/#ascii-whitespace
  */
 Token.whitespace = ['\u0009', '\u000A', '\u000C', '\u000D', '\u0020'];
+exports.Token = Token;

package/lib/token/types.d.ts

@@ -0,0 +1,3 @@
+export type TokenValueScalar = string | Readonly<RegExp> | number;
+export type TokenValueArray = readonly TokenValue[];
+export type TokenValue = TokenValueScalar | TokenValueArray;

package/lib/token/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types.d.ts

@@ -2,101 +2,77 @@ 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;
+    readonly matched: false;
+    readonly ref: string | null;
+    readonly raw: string;
+    readonly length: number;
+    readonly offset: number;
+    readonly line: number;
+    readonly column: number;
+    readonly reason: UnmatchedResultReason;
+    readonly passCount?: number;
 } & UnmatchedResultOptions;
 export type UnmatchedResultOptions = {
-	partName?: string;
-	expects?: Expect[];
-	extra?: Expect;
-	candidate?: string;
+    readonly partName?: string;
+    readonly expects?: readonly Expect[];
+    readonly extra?: Expect;
+    readonly 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' | {
+    readonly type: 'out-of-range';
+    readonly gt?: number;
+    readonly gte?: number;
+    readonly lt?: number;
+    readonly lte?: number;
+} | {
+    readonly type: 'out-of-range-length-char';
+    readonly gte: number;
+    readonly lte?: number;
+} | {
+    readonly type: 'out-of-range-length-digit';
+    readonly gte: number;
+    readonly lte?: number;
 };
-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;
+    readonly matched: true;
 };
 export type Expect = {
-	type: 'const' | 'format' | 'syntax' | 'regexp' | 'common';
-	value: string;
+    readonly type: 'const' | 'format' | 'syntax' | 'regexp' | 'common';
+    readonly 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;
+    readonly ref: string;
+    readonly expects?: readonly Expect[];
+    readonly 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>;
-	};
+    readonly ref: string;
+    readonly caseSensitive?: boolean;
+    readonly expects?: readonly Expect[];
+    readonly syntax: {
+        readonly apply: `<${string}>`;
+        readonly def: Readonly<Record<string, string | CssSyntaxTokenizer>>;
+        /**
+         * @deprecated
+         */
+        readonly ebnf?: Readonly<Record<string, string | readonly string[]>>;
+        /**
+         * @deprecated
+         */
+        readonly properties?: Readonly<Record<string, string>>;
+    };
 };
 export type CSSSyntaxToken = {
-	type: number;
-	value: string;
-	index: number;
-	balance: number;
-	node?: any;
+    readonly type: number;
+    readonly value: string;
+    readonly index: number;
+    readonly balance: number;
+    readonly node?: any;
 };
-export type CssSyntaxTokenizer = (
-	token: CSSSyntaxToken | null,
-	getNextToken: GetNextToken,
-	match: typeof cssSyntaxMatch,
-) => number;
+export type CssSyntaxTokenizer = (token: Readonly<CSSSyntaxToken> | null, getNextToken: GetNextToken, match: typeof cssSyntaxMatch) => number;
 export type GetNextToken = (length: number) => CSSSyntaxToken | null;