@tbela99/css-parser 1.4.2 → 1.4.3

package/dist/lib/parser/utils/eq.d.ts

@@ -0,0 +1 @@
+export declare function eq(a: any, b: any): boolean;

package/dist/lib/parser/utils/hash.d.ts

@@ -0,0 +1,21 @@
+export declare const LOWER = "abcdefghijklmnopqrstuvwxyz";
+export declare const DIGITS = "0123456789";
+export declare const FULL_ALPHABET: string[];
+export declare const FIRST_ALPHABET: string[];
+/**
+ * supported hash algorithms
+ */
+export declare const hashAlgorithms: string[];
+/**
+ * generate a hash id
+ * @param input
+ * @param length
+ */
+export declare function hashId(input: string, length?: number): string;
+/**
+ * generate a hash
+ * @param input
+ * @param length
+ * @param algo
+ */
+export declare function hash(input: string, length?: number, algo?: string): Promise<string>;

package/dist/lib/parser/utils/hash.js

@@ -83,4 +83,4 @@ async function hash(input, length = 6, algo) {
     return hashId(input, length);
 }
 
-export { hash, hashAlgorithms, hashId };
+export { DIGITS, FIRST_ALPHABET, FULL_ALPHABET, LOWER, hash, hashAlgorithms, hashId };

package/dist/lib/parser/utils/selector.d.ts

@@ -0,0 +1,5 @@
+import type { Token, AstRule, AstAtRule, AstKeyFrameRule, AstKeyframesAtRule, AstStyleSheet, ParserOptions, ErrorDescription, AstInvalidRule, AtRuleToken } from "../../../@types/index.d.ts";
+/**
+ * parse selector
+ */
+export declare function parseSelector(tokens: Token[], context: AtRuleToken | AstRule | AstAtRule | AstKeyFrameRule | AstKeyframesAtRule | AstStyleSheet | null, options: ParserOptions, errors: ErrorDescription[]): AstRule | AstInvalidRule | AstKeyFrameRule;

package/dist/lib/parser/utils/selector.js

@@ -0,0 +1,476 @@
+import { EnumToken } from '../../ast/types.js';
+import { renderToken } from '../../renderer/render.js';
+import { definedPropertySettings, tokensfuncDefMap, combinators } from '../../syntax/constants.js';
+import { pseudoElements, isIdent, isHash } from '../../syntax/syntax.js';
+import { getParsedSyntax, getSyntaxConfig } from '../../validation/config.js';
+import { matchAllSyntax, createValidationContext, trimArray, matchSelectorSyntax } from '../../validation/match.js';
+import { ValidationSyntaxGroupEnum } from '../../validation/parser/typedef.js';
+import { splitTokenList } from '../../validation/utils/list.js';
+import { trimWhiteSpace } from '../parse.js';
+
+/**
+ * parse selector
+ */
+function parseSelector(tokens, context, options, errors) {
+    if (context?.typ === EnumToken.KeyframesAtRuleNodeType) {
+        const result = matchAllSyntax(getParsedSyntax(ValidationSyntaxGroupEnum.Syntaxes, "keyframe-selectors"), createValidationContext(tokens), options);
+        const parts = splitTokenList(tokens);
+        for (const part of parts) {
+            trimArray(part);
+            if (options.minify) {
+                const filtered = part.filter((token) => token.typ !== EnumToken.WhitespaceTokenType && token.typ !== EnumToken.CommentTokenType);
+                if (filtered.length === 1) {
+                    if (filtered[0].typ === EnumToken.IdenTokenType &&
+                        "from" === filtered[0].val.toLowerCase()) {
+                        filtered[0] = Object.defineProperty({
+                            typ: EnumToken.PercentageTokenType,
+                            val: 0,
+                        }, "loc", {
+                            ...definedPropertySettings,
+                            value: filtered[0].loc,
+                        });
+                    }
+                    else if (filtered[0].typ === EnumToken.PercentageTokenType &&
+                        100 === filtered[0].val) {
+                        filtered[0] = Object.defineProperty({
+                            typ: EnumToken.IdenTokenType,
+                            val: "to",
+                        }, "loc", {
+                            ...definedPropertySettings,
+                            value: filtered[0].loc,
+                        });
+                    }
+                    part.splice(0, part.length, ...filtered);
+                }
+            }
+        }
+        tokens.splice(0, tokens.length, ...parts.reduce((acc, curr) => {
+            if (acc.length > 0) {
+                acc.push({ typ: EnumToken.CommaTokenType });
+            }
+            acc.push(...curr);
+            return acc;
+        }, []));
+        return Object.defineProperties({
+            typ: result.success ? EnumToken.KeyFramesRuleNodeType : EnumToken.InvalidRuleNodeType,
+            sel: [
+                ...splitTokenList(trimArray(tokens)).reduce((acc, curr) => {
+                    acc.add(curr.reduce((acc, curr) => acc + renderToken(curr, { minify: false }), ""));
+                    return acc;
+                }, new Set()),
+            ].join(),
+            chi: [],
+        }, {
+            tokens: { ...definedPropertySettings, value: tokens.length === 0 ? null : tokens },
+            loc: {
+                ...definedPropertySettings,
+                value: {
+                    ...tokens[0].loc,
+                    end: { ...(tokens[tokens.length - 1]?.loc?.end ?? tokens[0]?.loc?.end) },
+                },
+            },
+        });
+    }
+    const stack = [];
+    const uniq = new Map();
+    let i = 0;
+    let index;
+    let parent = context;
+    let nested = false;
+    let val;
+    do {
+        if (parent?.typ === EnumToken.AtRuleNodeType && "media" === parent.nam) {
+            parent = parent.parent;
+            continue;
+        }
+        nested = parent?.typ == EnumToken.RuleNodeType;
+        parent = parent?.parent;
+    } while (!nested && parent != null);
+    for (; i < tokens.length; i++) {
+        if (tokens[i].typ == EnumToken.ColonTokenType) {
+            if (tokens[i + 1]?.typ == EnumToken.IdenTokenType) {
+                Object.assign(tokens[i], {
+                    typ: EnumToken.PseudoElementTokenType,
+                    val: ":" + tokens[i + 1].val,
+                });
+                tokens[i].loc.end = tokens[i + 1].loc.end;
+                tokens.splice(i + 1, 1);
+                continue;
+            }
+            if (tokens[i + 1]?.typ == EnumToken.FunctionTokenDefType) {
+                val = ":" + tokens[i + 1].val;
+                Object.assign(tokens[i], {
+                    typ: val + "()" in getSyntaxConfig().selectors
+                        ? EnumToken.PseudoClassFunctionTokenDefType
+                        : tokens[i + 1].typ,
+                    val,
+                });
+                tokens[i].loc.end = tokens[i + 1].loc.end;
+                tokens.splice(i + 1, 1);
+                continue;
+            }
+        }
+        if (tokens[i].typ == EnumToken.DoubleColonTokenType) {
+            val = ":" + tokens[i + 1].val;
+            if (tokens[i + 1]?.typ == EnumToken.IdenTokenType) {
+                Object.assign(tokens[i], {
+                    typ: EnumToken.PseudoClassTokenType,
+                    val: (pseudoElements.includes(val) ? "" : ":") + val,
+                });
+                tokens[i].loc.end = tokens[i + 1].loc.end;
+                tokens.splice(i + 1, 1);
+                continue;
+            }
+            if (tokens[i + 1]?.typ == EnumToken.FunctionTokenDefType) {
+                val = "::" + tokens[i + 1].val;
+                Object.assign(tokens[i], {
+                    typ: val + "()" in getSyntaxConfig().selectors
+                        ? EnumToken.PseudoClassFunctionTokenDefType
+                        : EnumToken.FunctionTokenDefType,
+                    val,
+                });
+                tokens[i].loc.end = tokens[i + 1].loc.end;
+                tokens.splice(i + 1, 1);
+                continue;
+            }
+        }
+        if (tokens[i].typ == EnumToken.ColorTokenType) {
+            if (isIdent(tokens[i].val)) {
+                Object.assign(tokens[i], {
+                    typ: EnumToken.IdenTokenType,
+                });
+            }
+            else if (isHash(tokens[i].val)) {
+                Object.assign(tokens[i], {
+                    typ: EnumToken.HashTokenType,
+                });
+            }
+        }
+    }
+    const result = matchSelectorSyntax(tokens, errors, options, nested === true);
+    trimArray(tokens);
+    if (result.success) {
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            switch (token.typ) {
+                case EnumToken.AttrStartTokenType:
+                    stack.push(token);
+                    break;
+                case EnumToken.AttrEndTokenType:
+                    if (stack.at(-1)?.typ == EnumToken.AttrStartTokenType) {
+                        index = tokens.indexOf(stack.at(-1));
+                        // @ts-expect-error
+                        const { val, ...attr } = stack.at(-1);
+                        Object.defineProperty(attr, "loc", {
+                            ...definedPropertySettings,
+                            value: {
+                                ...stack.at(-1).loc,
+                                end: token.loc.end,
+                            },
+                        });
+                        tokens.splice(i, 1);
+                        Object.assign(attr, {
+                            typ: EnumToken.AttrTokenType,
+                            chi: tokens.splice(index + 1, i - index - 1),
+                        });
+                        tokens[index] = attr;
+                        i = index;
+                        stack.pop();
+                    }
+                    break;
+                case EnumToken.PseudoClassFunctionTokenDefType:
+                    stack.push(token);
+                    break;
+                case EnumToken.EndParensTokenType:
+                    if (stack.at(-1)?.typ == EnumToken.PseudoClassFunctionTokenDefType) {
+                        const func = stack.at(-1);
+                        index = tokens.indexOf(func);
+                        stack.at(-1).loc.end = token.loc.end;
+                        tokens.splice(i, 1);
+                        if (tokensfuncDefMap.has(func.typ)) {
+                            // @ts-expect-error
+                            func.typ = tokensfuncDefMap.get(func.typ);
+                            func.chi = tokens.splice(index + 1, i - index - 1);
+                        }
+                        if (result.success && options.minify) {
+                            // parse an+b
+                            // an+b produces an ident such as 'n-0', a literal such as '+2n-0' or a list of tokens such as[2n\s?[+-]\s?3]
+                            if (func.val == ":nth-child" ||
+                                func.val == ":nth-last-child" ||
+                                func.val == ":nth-of-type" ||
+                                func.val == ":nth-last-of-type") {
+                                const token = func.chi.find((t) => t.typ != EnumToken.WhitespaceTokenType && t.typ != EnumToken.CommentTokenType);
+                                if (token?.typ == EnumToken.IdenTokenType || token?.typ == EnumToken.LiteralTokenType) {
+                                    if (token.typ == EnumToken.IdenTokenType &&
+                                        (token.val == "odd" || token.val == "even")) {
+                                        if (token.val == "even") {
+                                            Object.assign(token, {
+                                                typ: EnumToken.DimensionTokenType,
+                                                val: 2,
+                                                unit: "n",
+                                            });
+                                        }
+                                    }
+                                    else {
+                                        if (!/\d+$/.test(token.val)) {
+                                            let index = func.chi.indexOf(token);
+                                            let i = index + 1;
+                                            let sign = null;
+                                            let num = null;
+                                            for (; i < func.chi.length; i++) {
+                                                if (func.chi[i].typ == EnumToken.WhitespaceTokenType ||
+                                                    func.chi[i].typ == EnumToken.CommentTokenType) {
+                                                    continue;
+                                                }
+                                                if (func.chi[i].typ == EnumToken.NumberTokenType) {
+                                                    num = func.chi[i];
+                                                    break;
+                                                }
+                                                else {
+                                                    sign = func.chi[i];
+                                                }
+                                            }
+                                            if (num != null) {
+                                                if (num.val === 0) {
+                                                    func.chi.splice(index + 1, i - index);
+                                                    if (token.val == "-n") {
+                                                        token.val = "n";
+                                                    }
+                                                    break;
+                                                }
+                                                if (sign == null) {
+                                                    func.chi.splice(index + 1, i - index - 1);
+                                                    if (Math.sign(num.val) === 1) {
+                                                        func.chi.splice(index + 1, 0, {
+                                                            typ: EnumToken.LiteralTokenType,
+                                                            val: "+",
+                                                        });
+                                                    }
+                                                }
+                                            }
+                                            else if (token.val == "-n") {
+                                                token.val = "n";
+                                            }
+                                            break;
+                                        }
+                                        const matches = /^(([+-]?[0-9]*)?n)?([+-]?[0-9]+)?$/.exec(token.val);
+                                        if (matches != null) {
+                                            const a1 = matches[2] === "" ? 1 : matches[2] === "-" ? -1 : +matches[2];
+                                            const b1 = +matches[3];
+                                            if (a1 === 0) {
+                                                if (b1 === 1) {
+                                                    let hasSelector = false;
+                                                    let i = func.chi.indexOf(token);
+                                                    let j = i + 1;
+                                                    for (; j < func.chi.length; j++) {
+                                                        if (func.chi[j].typ == EnumToken.IdenTokenType &&
+                                                            func.chi[j].val == "of") {
+                                                            hasSelector = true;
+                                                            break;
+                                                        }
+                                                    }
+                                                    if (hasSelector) {
+                                                        Object.assign(token, {
+                                                            typ: EnumToken.NumberTokenType,
+                                                            val: b1,
+                                                        });
+                                                    }
+                                                    else {
+                                                        // :first-child
+                                                        tokens[tokens.indexOf(func)] = Object.defineProperties({
+                                                            typ: EnumToken.PseudoClassTokenType,
+                                                            val: ":first-child",
+                                                        }, {
+                                                            loc: {
+                                                                ...definedPropertySettings,
+                                                                value: func.loc,
+                                                            },
+                                                        });
+                                                    }
+                                                    break;
+                                                }
+                                                else {
+                                                    Object.assign(token, { typ: EnumToken.NumberTokenType, val: b1 });
+                                                }
+                                            }
+                                            else if (b1 === 0) {
+                                                Object.assign(token, Math.abs(a1) === 1
+                                                    ? {
+                                                        typ: EnumToken.IdenTokenType,
+                                                        val: "n",
+                                                    }
+                                                    : {
+                                                        typ: EnumToken.DimensionTokenType,
+                                                        val: a1 * Math.sign(a1),
+                                                        unit: "n",
+                                                    });
+                                            }
+                                            else if (Math.abs(a1) === 2) {
+                                                if (b1 === 0) {
+                                                    Object.assign(token, {
+                                                        typ: EnumToken.DimensionTokenType,
+                                                        val: a1,
+                                                        unit: "n",
+                                                    });
+                                                }
+                                                else if (Math.abs(b1) === 1) {
+                                                    Object.assign(token, { typ: EnumToken.IdenTokenType, val: "odd" });
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                else if (token?.typ === EnumToken.DimensionTokenType) {
+                                    const index = func.chi.indexOf(token);
+                                    let sign = null;
+                                    let num = null;
+                                    let i = index + 1;
+                                    for (; i < func.chi.length; i++) {
+                                        if (func.chi[i].typ == EnumToken.WhitespaceTokenType ||
+                                            func.chi[i].typ == EnumToken.CommentTokenType) {
+                                            continue;
+                                        }
+                                        if (func.chi[i].typ == EnumToken.NumberTokenType) {
+                                            num = func.chi[i];
+                                            break;
+                                        }
+                                        else {
+                                            sign = func.chi[i];
+                                        }
+                                    }
+                                    if (num != null) {
+                                        if (token.val === 0) {
+                                            if (num.val === 0) {
+                                                func.chi.splice(0, i);
+                                            }
+                                            else if (num.val === 1) {
+                                                let hasSelector = false;
+                                                let j = i + 1;
+                                                for (; j < func.chi.length; j++) {
+                                                    if (func.chi[j].typ == EnumToken.IdenTokenType &&
+                                                        func.chi[j].val == "of") {
+                                                        hasSelector = true;
+                                                        break;
+                                                    }
+                                                }
+                                                if (hasSelector) {
+                                                    func.chi.splice(0, i);
+                                                }
+                                                else {
+                                                    tokens[tokens.indexOf(func)] = Object.defineProperties({
+                                                        typ: EnumToken.PseudoClassTokenType,
+                                                        val: ":first-child",
+                                                    }, {
+                                                        loc: {
+                                                            ...definedPropertySettings,
+                                                            value: func.loc,
+                                                        },
+                                                    });
+                                                }
+                                                break;
+                                            }
+                                            else {
+                                                func.chi.splice(0, i);
+                                            }
+                                            break;
+                                        }
+                                        else if (num.val === 0) {
+                                            func.chi.splice(index + 1, i - index);
+                                            if (token.val < 0) {
+                                                token.val *= -1;
+                                            }
+                                            break;
+                                        }
+                                        else if (token.val === 2 &&
+                                            Math.abs(num.val) === 1) {
+                                            Object.assign(token, {
+                                                typ: EnumToken.IdenTokenType,
+                                                val: "odd",
+                                            });
+                                            func.chi.splice(index + 1, i - index);
+                                            break;
+                                        }
+                                        if (token.val === 1) {
+                                            Object.assign(token, {
+                                                typ: EnumToken.IdenTokenType,
+                                                val: Math.sign(token.val) === 1
+                                                    ? "n"
+                                                    : "-n",
+                                            });
+                                        }
+                                        if (sign == null) {
+                                            func.chi.splice(index + 1, i - index - 1);
+                                            if (Math.sign(num.val) === 1) {
+                                                func.chi.splice(index + 1, 0, {
+                                                    typ: EnumToken.LiteralTokenType,
+                                                    val: "+",
+                                                });
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        i = index;
+                        stack.pop();
+                    }
+                    break;
+            }
+        }
+    }
+    return Object.defineProperties({
+        typ: result.success ? EnumToken.RuleNodeType : EnumToken.InvalidRuleNodeType,
+        sel: [
+            ...tokens
+                .reduce((acc, curr, index, array) => {
+                if (curr.typ == EnumToken.CommentTokenType) {
+                    return acc;
+                }
+                if (curr.typ == EnumToken.WhitespaceTokenType) {
+                    if (trimWhiteSpace.includes(array[index - 1]?.typ) ||
+                        trimWhiteSpace.includes(array[index + 1]?.typ) ||
+                        combinators.includes(array[index - 1]?.val) ||
+                        combinators.includes(array[index + 1]?.val)) {
+                        return acc;
+                    }
+                }
+                let t = renderToken(curr, { minify: false });
+                if (t == ",") {
+                    acc.push([]);
+                }
+                else {
+                    acc[acc.length - 1].push(t);
+                }
+                return acc;
+            }, [[]])
+                .reduce((acc, curr) => {
+                let i = 0;
+                for (; i < curr.length; i++) {
+                    if (i + 1 < curr.length && curr[i] == "*") {
+                        if (curr[i] == "*") {
+                            let index = curr[i + 1] == " " ? 2 : 1;
+                            if (![">", "~", "+"].includes(curr[index])) {
+                                curr.splice(i, index);
+                            }
+                        }
+                    }
+                }
+                acc.set(curr.join(""), curr);
+                return acc;
+            }, uniq)
+                .keys(),
+        ].join(","),
+        chi: [],
+    }, {
+        tokens: { ...definedPropertySettings, value: tokens },
+        loc: {
+            ...definedPropertySettings,
+            value: {
+                ...tokens[0].loc,
+                end: tokens[tokens.length - 1].loc.end,
+            },
+        },
+    });
+}
+
+export { parseSelector };

package/dist/lib/parser/utils/text.d.ts

@@ -0,0 +1,3 @@
+export declare function dasherize(value: string): string;
+export declare function camelize(value: string): string;
+export declare function equalsIgnoreCase(a: string, b: string): boolean;

package/dist/lib/parser/utils/text.js

@@ -4,5 +4,21 @@ function dasherize(value) {
 function camelize(value) {
     return value.replace(/-([a-z])/g, (all, one) => one.toUpperCase());
 }
+function equalsIgnoreCase(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        let ca = a.charCodeAt(i);
+        let cb = b.charCodeAt(i);
+        // Normalize A-Z to a-z
+        if (ca >= 65 && ca <= 90)
+            ca += 32;
+        if (cb >= 65 && cb <= 90)
+            cb += 32;
+        if (ca !== cb)
+            return false;
+    }
+    return true;
+}
 
-export { camelize, dasherize };
+export { camelize, dasherize, equalsIgnoreCase };

package/dist/lib/parser/utils/token.d.ts

@@ -0,0 +1,14 @@
+import type { AstNode } from "../../../@types/ast.d.ts";
+import type { BinaryExpressionToken, Token } from "../../../@types/token.d.ts";
+/**
+ * replace token in its parent node
+ * @param parent
+ * @param value
+ * @param replacement
+ */
+export declare function replaceToken(parent: BinaryExpressionToken | (AstNode & ({
+    chi: Token[];
+} | {
+    val: Token[];
+})), value: Token, replacement: Token | Token[]): boolean;
+export declare function trimWhiteSpaceTokens(tokens: Token[]): Token[];

package/dist/lib/parser/utils/token.js

@@ -0,0 +1,102 @@
+import { EnumToken } from '../../ast/types.js';
+import { definedPropertySettings, tokensfuncSet } from '../../syntax/constants.js';
+
+const trimTokenSpace = new Set([
+    EnumToken.CommaTokenType,
+    EnumToken.DelimTokenType,
+    EnumToken.GtTokenType,
+    EnumToken.GteTokenType,
+    EnumToken.LtTokenType,
+    EnumToken.LteTokenType,
+    EnumToken.ChildCombinatorTokenType,
+]);
+const trimSpaceAfter = new Set([
+    ...tokensfuncSet.values(),
+    EnumToken.ChildCombinatorTokenType,
+    EnumToken.SupportsQueryConditionTokenType,
+    EnumToken.SupportsQueryUnaryConditionTokenType,
+]);
+/**
+ * replace token in its parent node
+ * @param parent
+ * @param value
+ * @param replacement
+ */
+function replaceToken(parent, value, replacement) {
+    if (replacement == null || (Array.isArray(replacement) && replacement.length === 0)) {
+        throw new TypeError(`replacement is null`);
+    }
+    for (const node of Array.isArray(replacement) ? replacement : [replacement]) {
+        if ("parent" in value && value.parent != node.parent) {
+            Object.defineProperty(node, "parent", {
+                ...definedPropertySettings,
+                value: value.parent,
+            });
+        }
+    }
+    if (parent.typ == EnumToken.BinaryExpressionTokenType) {
+        if (parent.l == value) {
+            parent.l = replacement;
+        }
+        else if (parent.r == value) {
+            parent.r = replacement;
+        }
+        else {
+            throw new ReferenceError("Node not found");
+        }
+    }
+    else {
+        const target = "val" in parent && Array.isArray(parent.val)
+            ? parent.val
+            : (parent.chi ?? parent);
+        if (Array.isArray(target)) {
+            // @ts-ignore
+            const index = target.indexOf(value);
+            if (index == -1) {
+                throw new ReferenceError("Node not found");
+            }
+            target.splice(index, 1, ...(Array.isArray(replacement) ? replacement : [replacement]));
+        }
+        else if ("l" in target && target.l == value) {
+            target.l = replacement;
+        }
+        else if ("r" in target && target.r == value) {
+            target.r = replacement;
+        }
+        else {
+            throw new ReferenceError("Node not found");
+        }
+    }
+    return true;
+}
+function trimWhiteSpaceTokens(tokens) {
+    let i = 0;
+    if (tokens[0]?.typ === EnumToken.WhitespaceTokenType) {
+        tokens.shift();
+    }
+    if (tokens[tokens.length - 1]?.typ === EnumToken.WhitespaceTokenType) {
+        tokens.pop();
+    }
+    if (tokens.length === 1) {
+        if (tokens[0].typ === EnumToken.WhitespaceTokenType) {
+            tokens.length = 0;
+        }
+        return tokens;
+    }
+    for (; i < tokens.length; i++) {
+        if (trimSpaceAfter.has(tokens[i].typ) && tokens[i + 1]?.typ === EnumToken.WhitespaceTokenType) {
+            tokens.splice(i + 1, 1);
+        }
+        else if (trimTokenSpace.has(tokens[i].typ)) {
+            if (tokens[i + 1]?.typ === EnumToken.WhitespaceTokenType) {
+                tokens.splice(i + 1, 1);
+            }
+            if (i > 0 && tokens[i - 1].typ === EnumToken.Whitespace) {
+                tokens.splice(--i, 1);
+            }
+        }
+    }
+    return tokens;
+}
+
+export { replaceToken, trimWhiteSpaceTokens };

package/dist/lib/parser/utils/type.d.ts

@@ -0,0 +1,2 @@
+import type { PropertyMapType, Token } from "../../../@types/index.d.ts";
+export declare function matchType(val: Token, properties: PropertyMapType): boolean;