@tbela99/css-parser 0.9.0 → 1.0.0

package/dist/lib/validation/parser/parse.js

@@ -949,100 +949,6 @@ function move(position, chr) {
     }
     return position;
 }
-function renderSyntax(token, parent) {
-    let glue;
-    switch (token.typ) {
-        case ValidationTokenEnum.Root:
-            return token.chi.reduce((acc, curr) => acc + renderSyntax(curr), '');
-        case ValidationTokenEnum.Whitespace:
-            return ' ';
-        case ValidationTokenEnum.ValidationFunctionDefinition:
-            return '<' + token.val + '()>';
-        case ValidationTokenEnum.HashMark:
-            return '#';
-        case ValidationTokenEnum.Pipe:
-            return '|';
-        case ValidationTokenEnum.Column:
-            return '||';
-        case ValidationTokenEnum.PipeToken:
-            return token.chi.reduce((acc, curr) => acc + (acc.trim().length > 0 ? '|' : '') + curr.reduce((acc, curr) => acc + renderSyntax(curr), ''), '');
-        case ValidationTokenEnum.ColumnToken:
-        case ValidationTokenEnum.AmpersandToken:
-            glue = token.typ == ValidationTokenEnum.ColumnToken ? '||' : '&&';
-            return token.l.reduce((acc, curr) => acc + renderSyntax(curr), '') +
-                glue +
-                token.r.reduce((acc, curr) => acc + renderSyntax(curr), '');
-        case ValidationTokenEnum.Function:
-        case ValidationTokenEnum.PseudoClassFunctionToken:
-        case ValidationTokenEnum.Parens:
-            return token.val + '(' + token.chi.reduce((acc, curr) => acc + renderSyntax(curr), '') + ')' + renderAttributes(token);
-        case ValidationTokenEnum.Comma:
-            return ',';
-        case ValidationTokenEnum.Keyword:
-            return token.val + renderAttributes(token);
-        case ValidationTokenEnum.OpenBracket:
-            return '[';
-        case ValidationTokenEnum.Ampersand:
-            return '&&';
-        case ValidationTokenEnum.QuestionMark:
-            return '?';
-        case ValidationTokenEnum.Separator:
-            return '/';
-        case ValidationTokenEnum.Bracket:
-            return '[' + token.chi.reduce((acc, curr) => acc + renderSyntax(curr), '') + ']' + renderAttributes(token);
-        case ValidationTokenEnum.PropertyType:
-            return '<' + token.val + '>' + renderAttributes(token);
-        case ValidationTokenEnum.DeclarationType:
-            return "<'" + token.val + "'>" + renderAttributes(token);
-        case ValidationTokenEnum.Number:
-        case ValidationTokenEnum.PseudoClassToken:
-        case ValidationTokenEnum.StringToken:
-            return token.val + '';
-        case ValidationTokenEnum.SemiColon:
-            return ';';
-        case ValidationTokenEnum.AtRule:
-            return '@' + token.val;
-        case ValidationTokenEnum.AtRuleDefinition:
-            return '@' + token.val +
-                (token.prelude == null ? '' : ' ' + token.prelude.reduce((acc, curr) => acc + renderSyntax(curr), '')) +
-                (token.chi == null ? '' : ' {\n' + token.chi.reduce((acc, curr) => acc + renderSyntax(curr), '')).slice(1, -1) + '\n}';
-        case ValidationTokenEnum.Block:
-            return '{' + token.chi.reduce((acc, t) => acc + renderSyntax(t), '') + '}';
-        case ValidationTokenEnum.DeclarationDefinitionToken:
-            return token.nam + ': ' + renderSyntax(token.val);
-        case ValidationTokenEnum.ColumnArrayToken:
-            return token.chi.reduce((acc, curr) => acc + (acc.trim().length > 0 ? '||' : '') + renderSyntax(curr), '');
-        default:
-            throw new Error('Unhandled token: ' + JSON.stringify({ token }));
-    }
-}
-function renderAttributes(token) {
-    let result = '';
-    if (token.isList) {
-        result += '#';
-    }
-    if (token.isOptional) {
-        result += '?';
-    }
-    if (token.isRepeatableGroup) {
-        result += '!';
-    }
-    if (token.isRepeatable) {
-        result += '*';
-    }
-    if (token.atLeastOnce) {
-        result += '+';
-    }
-    if (token.occurence != null) {
-        if (token.occurence.max == 0 || token.occurence.max == token.occurence.min || Number.isNaN(token.occurence.max)) {
-            result += '{' + token.occurence.min + '}';
-        }
-        else {
-            result += '{' + token.occurence.min + ',' + token.occurence.max + '}';
-        }
-    }
-    return result;
-}
 function minify(ast) {
     if (Array.isArray(ast)) {
         // @ts-ignore
@@ -1143,4 +1049,4 @@ function* walkValidationToken(token, parent, callback, key) {
     }
 }
 
-export { WalkValidationTokenEnum, WalkValidationTokenKeyTypeEnum, parseSyntax, renderSyntax, walkValidationToken };
+export { WalkValidationTokenEnum, WalkValidationTokenKeyTypeEnum, parseSyntax, walkValidationToken };

package/dist/lib/validation/parser/types.js

@@ -1,4 +1,3 @@
-const specialValues = ['inherit', 'initial', 'unset', 'revert', 'revert-layer'];
 var ValidationTokenEnum;
 (function (ValidationTokenEnum) {
     ValidationTokenEnum[ValidationTokenEnum["Root"] = 0] = "Root";
@@ -52,4 +51,4 @@ var ValidationSyntaxGroupEnum;
     ValidationSyntaxGroupEnum["AtRules"] = "atRules";
 })(ValidationSyntaxGroupEnum || (ValidationSyntaxGroupEnum = {}));
 
-export { ValidationSyntaxGroupEnum, ValidationTokenEnum, specialValues };
+export { ValidationSyntaxGroupEnum, ValidationTokenEnum };

package/dist/lib/validation/selector.js

@@ -19,7 +19,7 @@ function validateSelector(selector, options, root) {
     }
     // @ts-ignore
     if (root.typ == EnumToken.AtRuleNodeType && root.nam.match(/^(-[a-z]+-)?keyframes$/)) {
-        return validateKeyframeBlockList(selector, root);
+        return validateKeyframeBlockList(selector);
     }
     let isNested = root.typ == EnumToken.RuleNodeType ? 1 : 0;
     let currentRoot = root.parent;
@@ -35,7 +35,10 @@ function validateSelector(selector, options, root) {
     }
     const nestedSelector = isNested > 0;
     // @ts-ignore
-    return nestedSelector ? validateRelativeSelectorList(selector, root, { ...(options ?? {}), nestedSelector }) : validateSelectorList(selector, root, { ...(options ?? {}), nestedSelector });
+    return nestedSelector ? validateRelativeSelectorList(selector, root, {
+        ...(options ?? {}),
+        nestedSelector
+    }) : validateSelectorList(selector, root, { ...(options ?? {}), nestedSelector });
 }
 
 export { validateSelector };

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

@@ -80,8 +80,8 @@ function validateCompoundSelector(tokens, root, options) {
             tokens.shift();
             consumeWhitespace(tokens);
         }
-        while (tokens.length > 0 && tokens[0].typ == EnumToken.PseudoClassTokenType) {
-            const isPseudoElement = tokens[0].val.startsWith('::');
+        while (tokens.length > 0 && (tokens[0].typ == EnumToken.PseudoElementTokenType || tokens[0].typ == EnumToken.PseudoClassTokenType)) {
+            const isPseudoElement = tokens[0].typ == EnumToken.PseudoElementTokenType;
             if (
             // https://developer.mozilla.org/en-US/docs/Web/CSS/WebKit_Extensions#pseudo-elements
             !(isPseudoElement && tokens[0].val.startsWith('::-webkit-')) &&

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

@@ -13,7 +13,7 @@ function validateKeyframeBlockList(tokens, atRule, options) {
     let result = null;
     while (i + 1 < tokens.length) {
         if (tokens[++i].typ == EnumToken.CommaTokenType) {
-            result = validateKeyframeSelector(tokens.slice(j, i), atRule);
+            result = validateKeyframeSelector(tokens.slice(j, i));
             if (result.valid == ValidationLevel.Drop) {
                 return result;
             }
@@ -21,7 +21,7 @@ function validateKeyframeBlockList(tokens, atRule, options) {
             i = j;
         }
     }
-    return validateKeyframeSelector(i == j ? tokens.slice(i) : tokens.slice(j, i + 1), atRule);
+    return validateKeyframeSelector(i == j ? tokens.slice(i) : tokens.slice(j, i + 1));
 }
 
 export { validateKeyframeBlockList };

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

@@ -1,4 +1,5 @@
 import { consumeWhitespace } from '../utils/whitespace.js';
+import { splitTokenList } from '../utils/list.js';
 import { ValidationLevel, EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
@@ -7,120 +8,40 @@ import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 
-function validateKeyframeSelector(tokens, atRule, options) {
+function validateKeyframeSelector(tokens, options) {
     consumeWhitespace(tokens);
     if (tokens.length == 0) {
         // @ts-ignore
         return {
             valid: ValidationLevel.Drop,
             matches: [],
-            node: atRule,
+            node: null,
             syntax: null,
             error: 'expected keyframe selector',
             tokens
         };
     }
-    if (tokens[0].typ == EnumToken.PercentageTokenType) {
-        tokens.shift();
-        consumeWhitespace(tokens);
-        if (tokens.length == 0) {
-            // @ts-ignore
+    for (const t of splitTokenList(tokens)) {
+        if (t.length != 1) {
             return {
-                valid: ValidationLevel.Valid,
+                valid: ValidationLevel.Drop,
                 matches: [],
-                node: atRule,
+                node: t[0] ?? null,
                 syntax: null,
-                error: '',
+                error: 'unexpected token',
                 tokens
             };
         }
-        // @ts-ignore
-        return {
-            valid: ValidationLevel.Drop,
-            matches: [],
-            node: tokens[0],
-            syntax: null,
-            error: 'unexpected token',
-            tokens
-        };
-    }
-    if (tokens[0].typ != EnumToken.IdenTokenType) {
-        // @ts-ignore
-        return {
-            valid: ValidationLevel.Drop,
-            matches: [],
-            node: tokens[0],
-            // @ts-ignore
-            syntax: null,
-            error: 'expected keyframe selector',
-            tokens
-        };
-    }
-    if (['from', 'to'].includes(tokens[0].val)) {
-        tokens.shift();
-        consumeWhitespace(tokens);
-        if (tokens.length > 0) {
-            // @ts-ignore
+        if (t[0].typ != EnumToken.PercentageTokenType && !(t[0].typ == EnumToken.IdenTokenType && ['from', 'to', 'cover', 'contain', 'entry', 'exit', 'entry-crossing', 'exit-crossing'].includes(t[0].val))) {
             return {
                 valid: ValidationLevel.Drop,
                 matches: [],
-                node: tokens[0],
+                node: t[0],
                 syntax: null,
-                error: 'unexpected token',
+                error: 'expected keyframe selector',
                 tokens
             };
         }
-        // @ts-ignore
-        return {
-            valid: ValidationLevel.Valid,
-            matches: [],
-            node: null,
-            // @ts-ignore
-            syntax: null,
-            error: '',
-            tokens
-        };
-    }
-    if (!['cover', 'contain', 'entry', 'exit', 'entry-crossing', 'exit-crossing'].includes(tokens[0].val)) {
-        // @ts-ignore
-        return {
-            valid: ValidationLevel.Drop,
-            matches: [],
-            node: tokens[0],
-            // @ts-ignore
-            syntax: null,
-            error: 'unexpected token',
-            tokens
-        };
-    }
-    tokens.shift();
-    consumeWhitespace(tokens);
-    // @ts-ignore
-    if (tokens.length == 0 || tokens[0].typ != EnumToken.PercentageTokenType) {
-        // @ts-ignore
-        return {
-            valid: ValidationLevel.Drop,
-            matches: [],
-            node: tokens[0],
-            // @ts-ignore
-            syntax: null,
-            error: 'expecting percentage token',
-            tokens
-        };
-    }
-    tokens.shift();
-    consumeWhitespace(tokens);
-    if (tokens.length > 0) {
-        // @ts-ignore
-        return {
-            valid: ValidationLevel.Drop,
-            matches: [],
-            node: tokens[0],
-            // @ts-ignore
-            syntax: null,
-            error: 'unexpected token',
-            tokens
-        };
     }
     // @ts-ignore
     return {

package/dist/lib/validation/syntaxes/layer-name.js

@@ -15,7 +15,7 @@ function validateLayerName(tokens) {
             acc[acc.length - 1].push(curr);
         }
         return acc;
-    }, [[]]).slice(1);
+    }, [[]]);
     for (let i = 0; i < slice.length; i++) {
         if (slice[i].length == 0) {
             // @ts-ignore
@@ -28,26 +28,15 @@ function validateLayerName(tokens) {
                 tokens
             };
         }
-        if (slice[i][0].typ != EnumToken.IdenTokenType) {
-            // @ts-ignore
-            return {
-                valid: ValidationLevel.Drop,
-                matches: tokens,
-                node: slice[i][0],
-                syntax: 'ident',
-                error: 'expecting ident',
-                tokens
-            };
-        }
-        for (let j = 1; j < slice[i].length; j++) {
-            if (slice[i][j].typ != EnumToken.ClassSelectorTokenType) {
+        for (let j = 0; j < slice[i].length; j++) {
+            if (slice[i][j].typ != EnumToken.IdenTokenType && slice[i][j].typ != EnumToken.ClassSelectorTokenType) {
                 // @ts-ignore
                 return {
                     valid: ValidationLevel.Drop,
                     matches: tokens,
                     node: slice[i][j],
-                    syntax: 'layer-name',
-                    error: 'expecting class selector',
+                    syntax: '<layer-name>',
+                    error: 'expecting ident or class selector',
                     tokens
                 };
             }

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

@@ -1,5 +1,5 @@
 import { consumeWhitespace } from '../utils/whitespace.js';
-import { ValidationLevel } from '../../ast/types.js';
+import '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
@@ -12,19 +12,20 @@ import { combinatorsTokens } from './complex-selector.js';
 function validateRelativeSelector(tokens, root, options) {
     tokens = tokens.slice();
     consumeWhitespace(tokens);
-    if (tokens.length == 0) {
-        // @ts-ignore
-        return {
-            valid: ValidationLevel.Drop,
-            matches: [],
-            // @ts-ignore
-            node: root,
-            // @ts-ignore
-            syntax: null,
-            error: 'expected selector',
-            tokens
-        };
-    }
+    // if (tokens.length == 0) {
+    //
+    //     // @ts-ignore
+    //     return {
+    //         valid: ValidationLevel.Drop,
+    //         matches: [],
+    //         // @ts-ignore
+    //         node: root,
+    //         // @ts-ignore
+    //         syntax: null,
+    //         error: 'expected selector',
+    //         tokens
+    //     }
+    // }
     // , EnumToken.DescendantCombinatorTokenType
     if (combinatorsTokens.includes(tokens[0].typ)) {
         tokens.shift();

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

@@ -6,6 +6,23 @@ import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 
+function stripCommaToken(tokenList) {
+    let result = [];
+    let last = null;
+    for (let i = 0; i < tokenList.length; i++) {
+        if (tokenList[i].typ == EnumToken.CommaTokenType && last != null && last.typ == EnumToken.CommaTokenType) {
+            return null;
+        }
+        if (tokenList[i].typ != EnumToken.WhitespaceTokenType) {
+            last = tokenList[i];
+        }
+        if (tokenList[i].typ == EnumToken.CommentTokenType || tokenList[i].typ == EnumToken.CommaTokenType) {
+            continue;
+        }
+        result.push(tokenList[i]);
+    }
+    return result;
+}
 function splitTokenList(tokenList, split = [EnumToken.CommaTokenType]) {
     return tokenList.reduce((acc, curr) => {
         if (curr.typ == EnumToken.CommentTokenType) {
@@ -21,4 +38,4 @@ function splitTokenList(tokenList, split = [EnumToken.CommaTokenType]) {
     }, [[]]);
 }
 
-export { splitTokenList };
+export { splitTokenList, stripCommaToken };

package/dist/node/load.js

@@ -7,7 +7,7 @@ function parseResponse(response) {
     }
     return response.text();
 }
-async function load(url, currentFile) {
+async function load(url, currentFile = '.') {
     const resolved = resolve(url, currentFile);
     return matchUrl.test(resolved.absolute) ? fetch(resolved.absolute).then(parseResponse) : readFile(resolved.absolute, { encoding: 'utf-8' });
 }

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@tbela99/css-parser",
   "description": "CSS parser for node and the browser",
-  "version": "v0.9.0",
+  "version": "v1.0.0",
   "exports": {
     ".": "./dist/node/index.js",
+    "./node": "./dist/node/index.js",
     "./umd": "./dist/index-umd-web.js",
     "./web": "./dist/web/index.js",
     "./cjs": "./dist/index.cjs"
@@ -17,8 +18,8 @@
     "build": "rollup -c;./build.sh dist/index.d.ts 'declare interface' 'declare type'",
     "test": "web-test-runner \"test/**/web.spec.js\" --node-resolve --playwright --browsers chromium firefox webkit --root-dir=.; mocha --reporter-options='maxDiffSize=1801920' \"test/**/node.spec.js\"",
     "test:node": "mocha --reporter-options='maxDiffSize=1801920' \"test/**/node.spec.js\"",
-    "test:cov": "c8 --reporter=html --reporter=text --reporter=json-summary mocha --reporter-options='maxDiffSize=1801920' \"test/**/node.spec.js\"",
-    "test:web-cov": "web-test-runner \"test/**/web.spec.js\" --node-resolve --playwright --browsers chromium firefox webkit --root-dir=. --coverage",
+    "test:cov": "c8 -x 'test/specs/**/*.js' -x dist/lib/validation/syntax.js -x 'dist/lib/validation/parser/*.js' --reporter=html --reporter=text --reporter=json-summary mocha --reporter-options='maxDiffSize=1801920' \"test/**/node.spec.js\"",
+    "test:web-cov": "web-test-runner -x 'test/specs/**/*.js' -x dist/lib/validation/syntax.js,dist/lib/validation/parser \"test/**/web.spec.js\" --node-resolve --playwright --browsers chromium firefox webkit --root-dir=. --coverage",
     "profile": "node --enable-source-maps --inspect-brk test/inspect.js",
     "syntax-update": "esno tools/validation.ts",
     "debug": "web-test-runner \"test/**/web.spec.js\" --manual --open --node-resolve --root-dir=."
@@ -50,22 +51,22 @@
   "homepage": "https://github.com/tbela99/css-parser#readme",
   "devDependencies": {
     "@esm-bundle/chai": "^4.3.4-fix.0",
-    "@rollup/plugin-commonjs": "^28.0.2",
+    "@rollup/plugin-commonjs": "^28.0.3",
     "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-typescript": "^12.1.2",
-    "@types/chai": "^5.0.1",
+    "@types/chai": "^5.2.1",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^22.13.5",
-    "@types/web": "^0.0.206",
-    "@web/test-runner": "^0.20.0",
+    "@types/node": "^22.15.2",
+    "@types/web": "^0.0.226",
+    "@web/test-runner": "^0.20.1",
     "@web/test-runner-playwright": "^0.11.0",
     "c8": "^10.1.3",
     "esno": "^4.8.0",
     "mocha": "^11.1.0",
-    "playwright": "^1.50.1",
-    "rollup": "^4.34.8",
-    "rollup-plugin-dts": "^6.1.1",
+    "playwright": "^1.52.0",
+    "rollup": "^4.40.0",
+    "rollup-plugin-dts": "^6.2.1",
     "tslib": "^2.8.1"
   }
 }

package/dist/lib/renderer/color/prophotoRgb.js

@@ -1,56 +0,0 @@
-import { srgb2xyz, xyzd502srgb } from './xyz.js';
-import { XYZ_D65_to_D50 } from './xyzd50.js';
-
-function prophotorgb2srgbvalues(r, g, b, a = null) {
-    // @ts-ignore
-    return xyzd502srgb(...prophotorgb2xyz50(r, g, b, a));
-}
-function srgb2prophotorgbvalues(r, g, b, a) {
-    // @ts-ignore
-    return xyz50_to_prophotorgb(...XYZ_D65_to_D50(...srgb2xyz(r, g, b, a)));
-}
-function prophotorgb2lin_ProPhoto(r, g, b, a = null) {
-    return [r, g, b].map(v => {
-        let abs = Math.abs(v);
-        if (abs >= 16 / 512) {
-            return Math.sign(v) * Math.pow(abs, 1.8);
-        }
-        return v / 16;
-    }).concat(a == null || a == 1 ? [] : [a]);
-}
-function prophotorgb2xyz50(r, g, b, a = null) {
-    [r, g, b, a] = prophotorgb2lin_ProPhoto(r, g, b, a);
-    const xyz = [
-        0.7977666449006423 * r +
-            0.1351812974005331 * g +
-            0.0313477341283922 * b,
-        0.2880748288194013 * r +
-            0.7118352342418731 * g +
-            0.0000899369387256 * b,
-        0.8251046025104602 * b
-    ];
-    return xyz.concat(a == null || a == 1 ? [] : [a]);
-}
-function xyz50_to_prophotorgb(x, y, z, a) {
-    // @ts-ignore
-    return gam_prophotorgb(...[
-        x * 1.3457868816471585 -
-            y * 0.2555720873797946 -
-            0.0511018649755453 * z,
-        x * -0.5446307051249019 +
-            y * 1.5082477428451466 +
-            0.0205274474364214 * z,
-        1.2119675456389452 * z
-    ].concat(a == null || a == 1 ? [] : [a]));
-}
-function gam_prophotorgb(r, g, b, a) {
-    return [r, g, b].map(v => {
-        let abs = Math.abs(v);
-        if (abs >= 1 / 512) {
-            return Math.sign(v) * Math.pow(abs, 1 / 1.8);
-        }
-        return 16 * v;
-    }).concat(a == null || a == 1 ? [] : [a]);
-}
-
-export { prophotorgb2srgbvalues, srgb2prophotorgbvalues };

package/dist/lib/validation/declaration.js

@@ -1,102 +0,0 @@
-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 { getParsedSyntax, getSyntaxConfig } from './config.js';
-import { validateSyntax } from './syntax.js';
-
-function validateDeclaration(declaration, options, root) {
-    const config = getSyntaxConfig();
-    let name = declaration.nam;
-    if (!(name in config.declarations) && !(name in config.syntaxes)) {
-        if (name[0] == '-') {
-            const match = /^-([a-z]+)-(.*)$/.exec(name);
-            if (match != null) {
-                name = match[2];
-            }
-        }
-    }
-    // root is at-rule - check if declaration allowed
-    if (root?.typ == EnumToken.AtRuleNodeType) {
-        //
-        const syntax = getParsedSyntax("atRules" /* ValidationSyntaxGroupEnum.AtRules */, '@' + root.nam)?.[0];
-        // console.error({syntax});
-        if (syntax != null) {
-            if (!('chi' in syntax)) {
-                return {
-                    valid: ValidationLevel.Drop,
-                    node: declaration,
-                    syntax,
-                    error: 'declaration not allowed here'
-                };
-            }
-            if (name.startsWith('--')) {
-                return {
-                    valid: ValidationLevel.Valid,
-                    node: declaration,
-                    syntax: null,
-                    error: ''
-                };
-            }
-            // console.error({syntax});
-            const config = getSyntaxConfig();
-            // @ts-ignore
-            const obj = config["atRules" /* ValidationSyntaxGroupEnum.AtRules */]['@' + root.nam];
-            if ('descriptors' in obj) {
-                const descriptors = obj.descriptors;
-                if (!(name in descriptors)) {
-                    return {
-                        valid: ValidationLevel.Drop,
-                        node: declaration,
-                        syntax: `<${declaration.nam}>`,
-                        error: ` declaration <${declaration.nam}> is not allowed in <@${root.nam}>`
-                    };
-                }
-                const syntax = getParsedSyntax("atRules" /* ValidationSyntaxGroupEnum.AtRules */, ['@' + root.nam, 'descriptors', name]);
-                return validateSyntax(syntax, declaration.val, root, options);
-            }
-            // console.error({name});
-            //         if (!(name in config.declarations) && !(name in config.syntaxes)) {
-            //
-            //             return {
-            //
-            //                 valid: ValidationLevel.Drop,
-            //                 node: declaration,
-            //                 syntax: null,
-            //                 error: `unknown declaration "${declaration.nam}"`
-            //             }
-            //         }
-            //
-            //         return validateSyntax((syntax as ValidationAtRuleDefinitionToken).chi as ValidationToken[], [declaration], root, options);
-        }
-    }
-    if (name.startsWith('--')) {
-        return {
-            valid: ValidationLevel.Valid,
-            node: declaration,
-            syntax: null,
-            error: ''
-        };
-    }
-    if (!(name in config.declarations) && !(name in config.syntaxes)) {
-        return {
-            valid: ValidationLevel.Drop,
-            node: declaration,
-            syntax: `<${declaration.nam}>`,
-            error: `unknown declaration "${declaration.nam}"`
-        };
-    }
-    // return {
-    //
-    //     valid: ValidationLevel.Valid,
-    //     node: declaration,
-    //     syntax: null,
-    //     error: ''
-    // }
-    return validateSyntax(getParsedSyntax("declarations" /* ValidationSyntaxGroupEnum.Declarations */, name), declaration.val);
-}
-
-export { validateDeclaration };