@tbela99/css-parser 0.8.0 → 0.9.0

package/dist/lib/validation/syntaxes/compound-selector.js

@@ -0,0 +1,226 @@
+import { ValidationLevel, EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../ast/walk.js';
+import '../../parser/parse.js';
+import { mozExtensions, webkitExtensions } from '../../syntax/syntax.js';
+import '../../parser/utils/config.js';
+import '../../renderer/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
+import { consumeWhitespace } from '../utils/whitespace.js';
+import { getSyntaxConfig } from '../config.js';
+
+function validateCompoundSelector(tokens, root, options) {
+    if (tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            // @ts-ignore
+            node: root,
+            // @ts-ignore
+            syntax: null,
+            error: 'expected selector',
+            tokens
+        };
+    }
+    tokens = tokens.slice();
+    consumeWhitespace(tokens);
+    const config = getSyntaxConfig();
+    let match = 0;
+    let length = tokens.length;
+    while (tokens.length > 0) {
+        while (tokens.length > 0 && tokens[0].typ == EnumToken.NestingSelectorTokenType) {
+            if (!options?.nestedSelector) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    // @ts-ignore
+                    node: tokens[0],
+                    syntax: null,
+                    error: 'nested selector not allowed',
+                    tokens
+                };
+            }
+            match++;
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        // <type-selector>
+        while (tokens.length > 0 &&
+            [
+                EnumToken.IdenTokenType,
+                EnumToken.NameSpaceAttributeTokenType,
+                EnumToken.ClassSelectorTokenType,
+                EnumToken.HashTokenType,
+                EnumToken.UniversalSelectorTokenType
+            ].includes(tokens[0].typ)) {
+            match++;
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        while (tokens.length > 0 && tokens[0].typ == EnumToken.PseudoClassFuncTokenType) {
+            if (!mozExtensions.has(tokens[0].val + '()') &&
+                !webkitExtensions.has(tokens[0].val + '()') &&
+                !((tokens[0].val + '()') in config.selectors)) {
+                if (!options?.lenient || /^(:?)-webkit-/.test(tokens[0].val)) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        // @ts-ignore
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'unknown pseudo-class: ' + tokens[0].val + '()',
+                        tokens
+                    };
+                }
+            }
+            match++;
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        while (tokens.length > 0 && tokens[0].typ == EnumToken.PseudoClassTokenType) {
+            const isPseudoElement = tokens[0].val.startsWith('::');
+            if (
+            // https://developer.mozilla.org/en-US/docs/Web/CSS/WebKit_Extensions#pseudo-elements
+            !(isPseudoElement && tokens[0].val.startsWith('::-webkit-')) &&
+                !mozExtensions.has(tokens[0].val) &&
+                !webkitExtensions.has(tokens[0].val) &&
+                !(tokens[0].val in config.selectors) &&
+                !(!isPseudoElement &&
+                    (':' + tokens[0].val) in config.selectors)) {
+                if (!options?.lenient || /^(:?)-webkit-/.test(tokens[0].val)) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        // @ts-ignore
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'unknown pseudo-class: ' + tokens[0].val,
+                        tokens
+                    };
+                }
+            }
+            match++;
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        while (tokens.length > 0 && tokens[0].typ == EnumToken.AttrTokenType) {
+            const children = tokens[0].chi.slice();
+            consumeWhitespace(children);
+            if (children.length == 0) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0],
+                    syntax: null,
+                    error: 'invalid attribute selector',
+                    tokens
+                };
+            }
+            if (![
+                EnumToken.IdenTokenType,
+                EnumToken.NameSpaceAttributeTokenType,
+                EnumToken.MatchExpressionTokenType
+            ].includes(children[0].typ)) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0],
+                    syntax: null,
+                    error: 'invalid attribute selector',
+                    tokens
+                };
+            }
+            if (children[0].typ == EnumToken.MatchExpressionTokenType) {
+                if (children.length != 1) {
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'invalid <attribute-selector>',
+                        tokens
+                    };
+                }
+                if (![
+                    EnumToken.IdenTokenType,
+                    EnumToken.NameSpaceAttributeTokenType
+                ].includes(children[0].l.typ) ||
+                    ![
+                        EnumToken.EqualMatchTokenType, EnumToken.DashMatchTokenType,
+                        EnumToken.StartMatchTokenType, EnumToken.ContainMatchTokenType,
+                        EnumToken.EndMatchTokenType, EnumToken.IncludeMatchTokenType
+                    ].includes(children[0].op.typ) ||
+                    ![
+                        EnumToken.StringTokenType,
+                        EnumToken.IdenTokenType
+                    ].includes(children[0].r.typ)) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'invalid attribute selector',
+                        tokens
+                    };
+                }
+                if (children[0].attr != null && !['i', 's'].includes(children[0].attr)) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'invalid attribute selector',
+                        tokens
+                    };
+                }
+            }
+            match++;
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        if (length == tokens.length) {
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                // @ts-ignore
+                node: tokens[0],
+                // @ts-ignore
+                syntax: null,
+                error: 'expected compound selector',
+                tokens
+            };
+        }
+        length = tokens.length;
+    }
+    return match == 0 ? {
+        valid: ValidationLevel.Drop,
+        matches: [],
+        // @ts-ignore
+        node: root,
+        // @ts-ignore
+        syntax: null,
+        error: 'expected compound selector',
+        tokens
+    } :
+        // @ts-ignore
+        {
+            valid: ValidationLevel.Valid,
+            matches: [],
+            // @ts-ignore
+            node: root,
+            // @ts-ignore
+            syntax: null,
+            error: null,
+            tokens
+        };
+}
+
+export { validateCompoundSelector };

package/dist/lib/validation/syntaxes/image.js

@@ -0,0 +1,29 @@
+import { EnumToken, ValidationLevel } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../ast/walk.js';
+import '../../parser/parse.js';
+import '../../renderer/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
+import { validateSyntax } from '../syntax.js';
+import { getParsedSyntax } from '../config.js';
+import { validateURL } from './url.js';
+
+function validateImage(token) {
+    if (token.typ == EnumToken.UrlFunctionTokenType) {
+        return validateURL(token);
+    }
+    if (token.typ == EnumToken.ImageFunctionTokenType) {
+        return validateSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, token.val + '()'), token.chi);
+    }
+    return {
+        valid: ValidationLevel.Drop,
+        matches: [],
+        node: token,
+        syntax: 'image()',
+        error: 'expected <image> or <url>',
+        tokens: []
+    };
+}
+
+export { validateImage };

package/dist/lib/validation/syntaxes/keyframe-block-list.js

@@ -7,7 +7,7 @@ import '../../renderer/sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 import { validateKeyframeSelector } from './keyframe-selector.js';
 
-function validateKeyframeBlockList(tokens, atRule) {
+function validateKeyframeBlockList(tokens, atRule, options) {
     let i = 0;
     let j = 0;
     let result = null;

package/dist/lib/validation/syntaxes/keyframe-selector.js

@@ -7,7 +7,7 @@ import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 
-function validateKeyframeSelector(tokens, atRule) {
+function validateKeyframeSelector(tokens, atRule, options) {
     consumeWhitespace(tokens);
     if (tokens.length == 0) {
         // @ts-ignore

package/dist/lib/validation/syntaxes/relative-selector-list.js

@@ -1,4 +1,4 @@
-import { EnumToken, ValidationLevel } from '../../ast/types.js';
+import { ValidationLevel } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
@@ -6,22 +6,52 @@ import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 import { validateRelativeSelector } from './relative-selector.js';
+import { consumeWhitespace } from '../utils/whitespace.js';
+import { splitTokenList } from '../utils/list.js';
 
 function validateRelativeSelectorList(tokens, root, options) {
-    let i = 0;
-    let j = 0;
-    let result = null;
-    while (i + 1 < tokens.length) {
-        if (tokens[++i].typ == EnumToken.CommaTokenType) {
-            result = validateRelativeSelector(tokens.slice(j, i), root, options);
-            if (result.valid == ValidationLevel.Drop) {
-                return result;
-            }
-            j = i + 1;
-            i = j;
+    tokens = tokens.slice();
+    consumeWhitespace(tokens);
+    if (tokens.length == 0) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            // @ts-ignore
+            node: root,
+            // @ts-ignore
+            syntax: null,
+            error: 'expecting relative selector list',
+            tokens
+        };
+    }
+    for (const t of splitTokenList(tokens)) {
+        if (t.length == 0) {
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                // @ts-ignore
+                node: root,
+                // @ts-ignore
+                syntax: null,
+                error: 'unexpected comma',
+                tokens
+            };
+        }
+        const result = validateRelativeSelector(t, root, options);
+        if (result.valid == ValidationLevel.Drop) {
+            return result;
         }
     }
-    return validateRelativeSelector(i == j ? tokens.slice(i) : tokens.slice(j, i + 1), root, options);
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        // @ts-ignore
+        node: root,
+        // @ts-ignore
+        syntax: null,
+        error: '',
+        tokens
+    };
 }
 
 export { validateRelativeSelectorList };

package/dist/lib/validation/utils/list.js

@@ -6,12 +6,12 @@ import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 
-function splitTokenList(tokenList) {
+function splitTokenList(tokenList, split = [EnumToken.CommaTokenType]) {
     return tokenList.reduce((acc, curr) => {
         if (curr.typ == EnumToken.CommentTokenType) {
             return acc;
         }
-        if (curr.typ == EnumToken.CommaTokenType) {
+        if (split.includes(curr.typ)) {
             acc.push([]);
         }
         else {

package/dist/node/index.js

@@ -13,7 +13,7 @@ import '../lib/validation/config.js';
 import '../lib/validation/parser/types.js';
 import '../lib/validation/parser/parse.js';
 import '../lib/validation/syntaxes/complex-selector.js';
-import { resolve, dirname } from '../lib/fs/resolve.js';
+import { dirname, resolve } from '../lib/fs/resolve.js';
 import { load } from './load.js';
 
 /**

package/dist/web/index.js

@@ -12,7 +12,7 @@ import '../lib/validation/config.js';
 import '../lib/validation/parser/types.js';
 import '../lib/validation/parser/parse.js';
 import '../lib/validation/syntaxes/complex-selector.js';
-import { resolve, dirname } from '../lib/fs/resolve.js';
+import { dirname, resolve } from '../lib/fs/resolve.js';
 import { load } from './load.js';
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tbela99/css-parser",
   "description": "CSS parser for node and the browser",
-  "version": "0.8.0",
+  "version": "v0.9.0",
   "exports": {
     ".": "./dist/node/index.js",
     "./umd": "./dist/index-umd-web.js",
@@ -56,15 +56,15 @@
     "@rollup/plugin-typescript": "^12.1.2",
     "@types/chai": "^5.0.1",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^22.10.2",
-    "@types/web": "^0.0.187",
-    "@web/test-runner": "^0.19.0",
+    "@types/node": "^22.13.5",
+    "@types/web": "^0.0.206",
+    "@web/test-runner": "^0.20.0",
     "@web/test-runner-playwright": "^0.11.0",
     "c8": "^10.1.3",
     "esno": "^4.8.0",
-    "mocha": "^11.0.1",
-    "playwright": "^1.49.1",
-    "rollup": "^4.29.2",
+    "mocha": "^11.1.0",
+    "playwright": "^1.50.1",
+    "rollup": "^4.34.8",
     "rollup-plugin-dts": "^6.1.1",
     "tslib": "^2.8.1"
   }