@tbela99/css-parser 1.3.3 → 1.3.4

package/dist/lib/validation/syntax.js

@@ -1,12 +1,11 @@
-import { ValidationTokenEnum } from './parser/types.js';
-import { renderSyntax } from './parser/parse.js';
-import { EnumToken, SyntaxValidationResult, ColorType } from '../ast/types.js';
+import { ValidationTokenEnum, renderSyntax } from './parser/parse.js';
+import { SyntaxValidationResult, EnumToken, ColorType } from '../ast/types.js';
 import '../ast/minify.js';
 import '../ast/walk.js';
 import '../parser/parse.js';
 import '../parser/tokenize.js';
 import '../parser/utils/config.js';
-import { wildCardFuncs, isIdentColor, mathFuncs } from '../syntax/syntax.js';
+import { wildCardFuncs, isIdentColor, mathFuncs, isColor } from '../syntax/syntax.js';
 import { renderToken } from '../renderer/render.js';
 import '../renderer/sourcemap/lib/encode.js';
 import { getSyntaxConfig, getParsedSyntax, getSyntax } from './config.js';
@@ -17,6 +16,116 @@ import '../ast/features/type.js';
 const config = getSyntaxConfig();
 // @ts-ignore
 const allValues = getSyntaxConfig()["declarations" /* ValidationSyntaxGroupEnum.Declarations */].all.syntax.trim().split(/[\s|]+/g);
+/**
+ * Check if a node is allowed as child in a given context
+ * @param node
+ * @param context
+ */
+function isNodeAllowedInContext(node, context) {
+    if (node.typ == EnumToken.CommentNodeType || context == null) {
+        return true;
+    }
+    switch (context?.typ) {
+        case EnumToken.StyleSheetNodeType:
+        case EnumToken.RuleNodeType:
+            return node.typ == EnumToken.RuleNodeType ||
+                node.typ == EnumToken.AtRuleNodeType ||
+                node.typ == EnumToken.KeyframesAtRuleNodeType ||
+                (node.typ == EnumToken.DeclarationNodeType && context.typ == EnumToken.RuleNodeType) ||
+                (node.typ == EnumToken.CDOCOMMNodeType && context.typ == EnumToken.StyleSheetNodeType);
+        case EnumToken.KeyframesAtRuleNodeType:
+            return node.typ == EnumToken.KeyFramesRuleNodeType;
+        case EnumToken.KeyFramesRuleNodeType:
+            return node.typ == EnumToken.DeclarationNodeType;
+        case EnumToken.AtRuleNodeType:
+            // @ts-ignore
+            const syntax = getParsedSyntax("atRules" /* ValidationSyntaxGroupEnum.AtRules */, '@' + context.nam)?.[0].chi ?? null;
+            //
+            if (syntax == null) {
+                // console.error(`syntax: Not found ${ValidationSyntaxGroupEnum.AtRules}@${(context as AstAtRule).nam}`);
+                return true;
+            }
+            const stack = syntax.slice();
+            for (const child of stack) {
+                if (Array.isArray(child)) {
+                    stack.push(...child);
+                    continue;
+                }
+                if ('chi' in child && Array.isArray(child.chi)) {
+                    stack.push(...child.chi);
+                    continue;
+                }
+                // @ts-ignore
+                if (child.l != null) {
+                    // @ts-ignore
+                    stack.push(child.l);
+                    // @ts-ignore
+                    if (child.r != null) {
+                        // @ts-ignore
+                        stack.push(...(Array.isArray(child.r) ? child.r : [child.r]));
+                    }
+                    continue;
+                }
+                if (node.typ == EnumToken.DeclarationNodeType) {
+                    if (child.typ == ValidationTokenEnum.DeclarationDefinitionToken) {
+                        if (node.nam == child.nam) {
+                            return true;
+                        }
+                    }
+                }
+                if (child.typ == ValidationTokenEnum.PropertyType) {
+                    if (['group-rule-body', 'block-contents', 'rule-list', 'stylesheet'].includes(child.val)) {
+                        if ((node.typ == EnumToken.RuleNodeType ||
+                            node.typ == EnumToken.AtRuleNodeType ||
+                            node.typ == EnumToken.KeyframesAtRuleNodeType)) {
+                            return true;
+                        }
+                        if (node.typ == EnumToken.DeclarationNodeType) {
+                            let parent = node.parent;
+                            while (parent != null) {
+                                if (parent.parent?.typ == EnumToken.RuleNodeType) {
+                                    return true;
+                                }
+                                parent = parent.parent;
+                            }
+                        }
+                    }
+                    if (['declaration-list', 'feature-value-declaration'].includes(child.val) && node.typ == EnumToken.DeclarationNodeType) {
+                        return true;
+                    }
+                    if (child.val == 'page-body' && (node.typ == EnumToken.DeclarationNodeType || (node.typ == EnumToken.AtRuleNodeType && [
+                        'top-left-corner', 'top-left', 'top-center', 'top-right', 'top-right-corner',
+                        'bottom-left-corner', 'bottom-left', 'bottom-center', 'bottom-right', 'bottom-right-corner',
+                        'left-top', 'left-middle', 'left-bottom', 'right-top', 'right-middle', 'right-bottom'
+                    ].includes(node.nam)))) {
+                        return true;
+                    }
+                    if (child.val == 'feature-value-block-list' &&
+                        (node.typ == EnumToken.AtRuleNodeType && ['stylistic', 'historical-forms', 'styleset', 'character-variant', 'swash', 'ornaments', 'annotation'].includes(node.nam))) {
+                        return true;
+                    }
+                    if (['feature-value-declaration-list', 'feature-value-declaration'].includes(child.val) && node.typ == EnumToken.DeclarationNodeType) {
+                        return true;
+                    }
+                    if (child.val == 'page-body') {
+                        if (node.typ == EnumToken.DeclarationNodeType) {
+                            return true;
+                        }
+                    }
+                    // console.error(`isNodeAllowedInContext: Not found ${(child as ValidationPropertyToken).val}`, {
+                    //     child,
+                    //     node
+                    // });
+                }
+            }
+            break;
+    }
+    return false;
+}
+/**
+ * Create a syntax validation context from a list of tokens
+ * @param input
+ */
 function createContext(input) {
     const values = input.slice();
     const result = values.filter(token => token.typ != EnumToken.CommentTokenType).slice();
@@ -77,7 +186,22 @@ function createContext(input) {
         }
     };
 }
-function evaluateSyntax(node, options) {
+/**
+ * Evaluate the validity of the syntax of a node
+ * @param node
+ * @param parent
+ * @param options
+ */
+function evaluateSyntax(node, parent, options) {
+    if (node.validSyntax) {
+        return {
+            valid: SyntaxValidationResult.Valid,
+            node,
+            syntax: null,
+            error: '',
+            context: []
+        };
+    }
     let ast;
     let result;
     switch (node.typ) {
@@ -85,25 +209,34 @@ function evaluateSyntax(node, options) {
             if (node.nam.startsWith('--')) {
                 break;
             }
+            let token = null;
+            let values = node.val.slice();
             ast = getParsedSyntax("declarations" /* ValidationSyntaxGroupEnum.Declarations */, node.nam);
-            if (ast != null) {
-                let token = null;
-                const values = node.val.slice();
-                while (values.length > 0) {
-                    token = values.at(-1);
-                    if (token.typ == EnumToken.WhitespaceTokenType || token.typ == EnumToken.CommentTokenType) {
+            while (values.length > 0) {
+                token = values.at(-1);
+                if (token.typ == EnumToken.WhitespaceTokenType || token.typ == EnumToken.CommentTokenType) {
+                    values.pop();
+                }
+                else {
+                    if (token.typ == EnumToken.ImportantTokenType) {
                         values.pop();
-                    }
-                    else {
-                        if (token.typ == EnumToken.ImportantTokenType) {
+                        if (values.at(-1)?.typ == EnumToken.WhitespaceTokenType) {
                             values.pop();
-                            if (values.at(-1)?.typ == EnumToken.WhitespaceTokenType) {
-                                values.pop();
-                            }
                         }
-                        break;
+                    }
+                    break;
+                }
+            }
+            if (ast == null) {
+                if (parent?.typ == EnumToken.AtRuleNodeType) {
+                    ast = (getParsedSyntax("atRules" /* ValidationSyntaxGroupEnum.AtRules */, ['@' + parent.nam, 'descriptors', node.nam]));
+                    if (ast == null) {
+                        ast = (getParsedSyntax("atRules" /* ValidationSyntaxGroupEnum.AtRules */, ['@' + parent.nam, 'descriptors', node.nam]) ?? getParsedSyntax("atRules" /* ValidationSyntaxGroupEnum.AtRules */, '@' + parent.nam))?.[0]?.chi;
+                        values = [{ ...node, val: values }];
                     }
                 }
+            }
+            if (ast != null) {
                 result = doEvaluateSyntax(ast, createContext(values), { ...options, visited: new WeakMap() });
                 if (result.valid == SyntaxValidationResult.Valid && !result.context.done()) {
                     let token = null;
@@ -195,7 +328,7 @@ function doEvaluateSyntax(syntaxes, context, options) {
                 continue;
             }
         }
-        else if (options.occurence !== false && syntax.occurence != null) {
+        else if (options.occurrence !== false && syntax.occurence != null) {
             result = matchOccurence(syntax, context, options);
         }
         else if (options.atLeastOnce !== false && syntax.atLeastOnce) {
@@ -284,7 +417,7 @@ function matchList(syntax, context, options) {
         result = doEvaluateSyntax([syntax], createContext(tokens), {
             ...options,
             isList: false,
-            occurence: false
+            occurrence: false
         });
         if (result.valid == SyntaxValidationResult.Valid) {
             context = con.clone();
@@ -319,7 +452,7 @@ function matchOccurence(syntax, context, options) {
     let counter = 0;
     let result;
     do {
-        result = match(syntax, context.clone(), { ...options, occurence: false });
+        result = match(syntax, context.clone(), { ...options, occurrence: false });
         if (result.valid == SyntaxValidationResult.Drop) {
             break;
         }
@@ -370,7 +503,7 @@ function match(syntax, context, options) {
             ...options,
             isRepeatable: null,
             isList: null,
-            occurence: null,
+            occurrence: null,
             atLeastOnce: null
         });
         if (result.valid == SyntaxValidationResult.Valid) {
@@ -382,7 +515,7 @@ function match(syntax, context, options) {
         case ValidationTokenEnum.Keyword:
             success = (token.typ == EnumToken.IdenTokenType || token.typ == EnumToken.DashedIdenTokenType || isIdentColor(token)) &&
                 (token.val == syntax.val ||
-                    syntax.val === token.val?.toLowerCase?.() ||
+                    syntax.val.toLowerCase() === token.val?.toLowerCase?.() ||
                     // config.declarations.all
                     allValues.includes(token.val.toLowerCase()));
             if (success) {
@@ -421,7 +554,7 @@ function match(syntax, context, options) {
                 ...options,
                 isRepeatable: null,
                 isList: null,
-                occurence: null,
+                occurrence: null,
                 atLeastOnce: null
             });
         case ValidationTokenEnum.Comma:
@@ -456,7 +589,7 @@ function match(syntax, context, options) {
                     ...options,
                     isRepeatable: null,
                     isList: null,
-                    occurence: null,
+                    occurrence: null,
                     atLeastOnce: null
                 }).valid == SyntaxValidationResult.Valid;
                 if (success) {
@@ -479,18 +612,19 @@ function match(syntax, context, options) {
 }
 function matchPropertyType(syntax, context, options) {
     if (![
-        'bg-position',
+        'color',
         'integer',
+        'bg-position',
         'length-percentage', 'flex', 'calc-sum', 'color',
         'color-base', 'system-color', 'deprecated-system-color',
-        'pseudo-class-selector', 'pseudo-element-selector'
+        'pseudo-class-selector', 'pseudo-element-selector', 'feature-value-declaration'
     ].includes(syntax.val)) {
         if (syntax.val in config["syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */]) {
             return doEvaluateSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, syntax.val), context, {
                 ...options,
                 isRepeatable: null,
                 isList: null,
-                occurence: null,
+                occurrence: null,
                 atLeastOnce: null
             });
         }
@@ -502,7 +636,7 @@ function matchPropertyType(syntax, context, options) {
             ...options,
             isRepeatable: null,
             isList: null,
-            occurence: null,
+            occurrence: null,
             atLeastOnce: null
         });
         if (result.valid == SyntaxValidationResult.Valid) {
@@ -607,6 +741,14 @@ function matchPropertyType(syntax, context, options) {
                 (token.typ == EnumToken.IdenTokenType && typeof Math[token.val.toUpperCase()] == 'number') ||
                 [EnumToken.BinaryExpressionTokenType, EnumToken.NumberTokenType, EnumToken.PercentageTokenType, EnumToken.DimensionTokenType, EnumToken.LengthTokenType, EnumToken.AngleTokenType, EnumToken.TimeTokenType, EnumToken.ResolutionTokenType, EnumToken.FrequencyTokenType].includes(token.typ);
             break;
+        case 'declaration':
+            {
+                success = token.typ == EnumToken.DeclarationNodeType;
+                if (success) {
+                    success = evaluateSyntax(token, null, options).valid == SyntaxValidationResult.Valid;
+                }
+            }
+            break;
         case 'declaration-value':
             while (!context.done()) {
                 context.next();
@@ -633,13 +775,17 @@ function matchPropertyType(syntax, context, options) {
             break;
         case 'color':
         case 'color-base':
-            success = token.typ == EnumToken.ColorTokenType || (token.typ == EnumToken.IdenTokenType && 'currentcolor' === token.val.toLowerCase()) || (token.typ == EnumToken.IdenTokenType && 'transparent' === token.val.toLowerCase()) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
+            success = token.typ == EnumToken.ColorTokenType ||
+                (token.typ == EnumToken.IdenTokenType && 'currentcolor' === token.val.toLowerCase()) ||
+                (token.typ == EnumToken.IdenTokenType && 'transparent' === token.val.toLowerCase()) ||
+                (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val) ||
+                    isColor(token));
             if (!success && token.typ == EnumToken.FunctionTokenType && colorsFunc.includes(token.val)) {
                 success = doEvaluateSyntax(getParsedSyntax("functions" /* ValidationSyntaxGroupEnum.Functions */, token.val)?.[0]?.chi, createContext(token.chi), {
                     ...options,
                     isRepeatable: null,
                     isList: null,
-                    occurence: null,
+                    occurrence: null,
                     atLeastOnce: null
                 }).valid == SyntaxValidationResult.Valid;
             }
@@ -647,8 +793,26 @@ function matchPropertyType(syntax, context, options) {
         case 'hex-color':
             success = (token.typ == EnumToken.ColorTokenType && token.kin == ColorType.HEX) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
             break;
+        case 'feature-value-declaration':
+            {
+                let hasNumber = false;
+                success = token.typ == EnumToken.DeclarationNodeType && token.val.length > 0 && token.val.every((val) => {
+                    if (val.typ == EnumToken.WhitespaceTokenType || val.typ == EnumToken.CommentTokenType) {
+                        return true;
+                    }
+                    const success = (val.typ == EnumToken.NumberTokenType && Number.isInteger(+val.val) && val.val > 0) || (val.typ == EnumToken.FunctionTokenType && mathFuncs.includes(val.val.toLowerCase()) || (val.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(val.val)));
+                    if (success) {
+                        hasNumber = true;
+                    }
+                    if ('range' in syntax) {
+                        return success && +val.val >= +syntax.range[0] && +val.val <= +syntax.range[1];
+                    }
+                    return success;
+                }) && hasNumber;
+            }
+            break;
         case 'integer':
-            success = (token.typ == EnumToken.NumberTokenType && Number.isInteger(+(token.val))) || (token.typ == EnumToken.FunctionTokenType && mathFuncs.includes(token.val.toLowerCase()) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val)));
+            success = (token.typ == EnumToken.NumberTokenType && Number.isInteger(+token.val) && token.val > 0) || (token.typ == EnumToken.FunctionTokenType && mathFuncs.includes(token.val.toLowerCase()) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val)));
             if ('range' in syntax) {
                 success = success && +token.val >= +syntax.range[0] && +token.val <= +syntax.range[1];
             }
@@ -712,7 +876,7 @@ function matchPropertyType(syntax, context, options) {
                         ...options,
                         isRepeatable: null,
                         isList: null,
-                        occurence: null,
+                        occurrence: null,
                         atLeastOnce: null
                     }).valid == SyntaxValidationResult.Valid;
                 }
@@ -728,7 +892,7 @@ function matchPropertyType(syntax, context, options) {
                     ...options,
                     isRepeatable: null,
                     isList: null,
-                    occurence: null,
+                    occurrence: null,
                     atLeastOnce: null
                 }).valid == SyntaxValidationResult.Valid;
         }
@@ -875,7 +1039,6 @@ function allOf(syntax, context, options) {
             i = -1;
         }
     }
-    // console.error()
     const success = syntax.length == 0;
     return {
         valid: success ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
@@ -902,4 +1065,4 @@ function flatten(syntax) {
     return data;
 }
 
-export { createContext, doEvaluateSyntax, evaluateSyntax };
+export { createContext, doEvaluateSyntax, evaluateSyntax, isNodeAllowedInContext };

package/dist/node.js

@@ -1,7 +1,7 @@
 import process from 'node:process';
 export { ColorType, EnumToken, ValidationLevel } from './lib/ast/types.js';
 export { minify } from './lib/ast/minify.js';
-export { WalkerOptionEnum, WalkerValueEvent, walk, walkValues } from './lib/ast/walk.js';
+export { WalkerEvent, WalkerOptionEnum, walk, walkValues } from './lib/ast/walk.js';
 export { expand } from './lib/ast/expand.js';
 import { doRender } from './lib/renderer/render.js';
 export { renderToken } from './lib/renderer/render.js';
@@ -14,42 +14,45 @@ export { convertColor } from './lib/syntax/color/color.js';
 import './lib/syntax/color/utils/constants.js';
 export { isOkLabClose, okLabDistance } from './lib/syntax/color/utils/distance.js';
 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 './lib/validation/syntax.js';
 import { resolve, matchUrl, dirname } from './lib/fs/resolve.js';
 import { Readable } from 'node:stream';
 import { createReadStream } from 'node:fs';
-import { lstat } from 'node:fs/promises';
+import { readFile, lstat } from 'node:fs/promises';
 export { FeatureWalkMode } from './lib/ast/features/type.js';
 
 /**
  * load file or url as stream
  * @param url
  * @param currentFile
+ * @param asStream
  * @throws Error file not found
  *
  * @private
  */
-async function load(url, currentFile = '.') {
+async function load(url, currentFile = '.', asStream = false) {
     const resolved = resolve(url, currentFile);
-    // @ts-ignore
     if (matchUrl.test(resolved.absolute)) {
-        return fetch(resolved.absolute).then((response) => {
+        return fetch(resolved.absolute).then(async (response) => {
             if (!response.ok) {
                 throw new Error(`${response.status} ${response.statusText} ${response.url}`);
             }
-            return response.body;
+            return asStream ? response.body : await response.text();
         });
     }
     try {
+        if (!asStream) {
+            return readFile(resolved.absolute, 'utf-8');
+        }
         const stats = await lstat(resolved.absolute);
         if (stats.isFile()) {
-            return Readable.toWeb(createReadStream(resolved.absolute));
+            return Readable.toWeb(createReadStream(resolved.absolute, { encoding: 'utf-8', highWaterMark: 64 * 1024 }));
         }
     }
     catch (error) {
+        console.warn(error);
     }
     throw new Error(`File not found: '${resolved.absolute || url}'`);
 }
@@ -88,6 +91,7 @@ function render(data, options = {}) {
  * parse css file
  * @param file url or path
  * @param options
+ * @param asStream load file as stream
  *
  * @throws Error file not found
  *
@@ -106,8 +110,8 @@ function render(data, options = {}) {
  * console.log(result.ast);
  * ```
  */
-async function parseFile(file, options = {}) {
-    return load(file).then(stream => parse(stream, { src: file, ...options }));
+async function parseFile(file, options = {}, asStream = false) {
+    return Promise.resolve((options.load ?? load)(file, '.', asStream)).then(stream => parse(stream, { src: file, ...options }));
 }
 /**
  * parse css
@@ -164,6 +168,7 @@ async function parse(stream, options = {}) {
  * transform css file
  * @param file url or path
  * @param options
+ * @param asStream load file as stream
  *
  * @throws Error file not found
  *
@@ -182,8 +187,8 @@ async function parse(stream, options = {}) {
  * console.log(result.code);
  * ```
  */
-async function transformFile(file, options = {}) {
-    return load(file).then(stream => transform(stream, { src: file, ...options }));
+async function transformFile(file, options = {}, asStream = false) {
+    return Promise.resolve((options.load ?? load)(file, '.', asStream)).then(stream => transform(stream, { src: file, ...options }));
 }
 /**
  * transform css

package/dist/web.js

@@ -1,6 +1,6 @@
 export { ColorType, EnumToken, ValidationLevel } from './lib/ast/types.js';
 export { minify } from './lib/ast/minify.js';
-export { WalkerOptionEnum, WalkerValueEvent, walk, walkValues } from './lib/ast/walk.js';
+export { WalkerEvent, WalkerOptionEnum, walk, walkValues } from './lib/ast/walk.js';
 export { expand } from './lib/ast/expand.js';
 import { doRender } from './lib/renderer/render.js';
 export { renderToken } from './lib/renderer/render.js';
@@ -13,7 +13,6 @@ export { convertColor } from './lib/syntax/color/color.js';
 import './lib/syntax/color/utils/constants.js';
 export { isOkLabClose, okLabDistance } from './lib/syntax/color/utils/distance.js';
 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 './lib/validation/syntax.js';
@@ -25,9 +24,10 @@ export { FeatureWalkMode } from './lib/ast/features/type.js';
  * @param url
  * @param currentFile
  *
+ * @param asStream
  * @private
  */
-async function load(url, currentFile = '.') {
+async function load(url, currentFile = '.', asStream = false) {
     let t;
     if (matchUrl.test(url)) {
         t = new URL(url);
@@ -37,15 +37,13 @@ async function load(url, currentFile = '.') {
     }
     else {
         const path = resolve(url, currentFile).absolute;
-        // @ts-ignore
         t = new URL(path, self.origin);
     }
-    // @ts-ignore
-    return fetch(t, t.origin != self.origin ? { mode: 'cors' } : {}).then((response) => {
+    return fetch(t, t.origin != self.origin ? { mode: 'cors' } : {}).then(async (response) => {
         if (!response.ok) {
             throw new Error(`${response.status} ${response.statusText} ${response.url}`);
         }
-        return response.body;
+        return asStream ? response.body : await response.text();
     });
 }
 /**
@@ -87,6 +85,7 @@ function render(data, options = {}) {
  * parse css file
  * @param file url or path
  * @param options
+ * @param asStream load file as stream
  *
  * @throws Error file not found
  *
@@ -105,8 +104,8 @@ function render(data, options = {}) {
  * console.log(result.ast);
  * ```
  */
-async function parseFile(file, options = {}) {
-    return load(file).then(stream => parse(stream, { src: file, ...options }));
+async function parseFile(file, options = {}, asStream = false) {
+    return Promise.resolve((options.load ?? load)(file, '.', asStream)).then(stream => parse(stream, { src: file, ...options }));
 }
 /**
  * parse css
@@ -153,6 +152,7 @@ async function parse(stream, options = {}) {
  * transform css file
  * @param file url or path
  * @param options
+ * @param asStream load file as stream
  *
  * Example:
  *
@@ -169,8 +169,8 @@ async function parse(stream, options = {}) {
  * console.log(result.code);
  * ```
  */
-async function transformFile(file, options = {}) {
-    return load(file).then(stream => transform(stream, { src: file, ...options }));
+async function transformFile(file, options = {}, asStream = false) {
+    return Promise.resolve((options.load ?? load)(file, '.', asStream)).then(stream => transform(stream, { src: file, ...options }));
 }
 /**
  * transform css

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tbela99/css-parser",
   "description": "CSS parser, minifier and validator for node and the browser",
-  "version": "v1.3.3",
+  "version": "v1.3.4",
   "exports": {
     ".": "./dist/node.js",
     "./node": "./dist/node.js",
@@ -42,7 +42,10 @@
     "css-nesting",
     "css-compiler",
     "nested-css",
-    "walker"
+    "walker",
+    "stream",
+    "streaming",
+    "streaming-parser"
   ],
   "author": "Thierry Bela",
   "license": "MIT OR LGPL-3.0",
@@ -69,7 +72,7 @@
     "rollup": "^4.48.0",
     "rollup-plugin-dts": "^6.2.1",
     "tslib": "^2.8.1",
-    "typedoc": "^0.28.10",
+    "typedoc": "^0.28.13",
     "typedoc-material-theme": "^1.4.0"
   }
 }

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

@@ -1,54 +0,0 @@
-var ValidationTokenEnum;
-(function (ValidationTokenEnum) {
-    ValidationTokenEnum[ValidationTokenEnum["Root"] = 0] = "Root";
-    ValidationTokenEnum[ValidationTokenEnum["Keyword"] = 1] = "Keyword";
-    ValidationTokenEnum[ValidationTokenEnum["PropertyType"] = 2] = "PropertyType";
-    ValidationTokenEnum[ValidationTokenEnum["DeclarationType"] = 3] = "DeclarationType";
-    ValidationTokenEnum[ValidationTokenEnum["AtRule"] = 4] = "AtRule";
-    ValidationTokenEnum[ValidationTokenEnum["ValidationFunctionDefinition"] = 5] = "ValidationFunctionDefinition";
-    ValidationTokenEnum[ValidationTokenEnum["OpenBracket"] = 6] = "OpenBracket";
-    ValidationTokenEnum[ValidationTokenEnum["CloseBracket"] = 7] = "CloseBracket";
-    ValidationTokenEnum[ValidationTokenEnum["OpenParenthesis"] = 8] = "OpenParenthesis";
-    ValidationTokenEnum[ValidationTokenEnum["CloseParenthesis"] = 9] = "CloseParenthesis";
-    ValidationTokenEnum[ValidationTokenEnum["Comma"] = 10] = "Comma";
-    ValidationTokenEnum[ValidationTokenEnum["Pipe"] = 11] = "Pipe";
-    ValidationTokenEnum[ValidationTokenEnum["Column"] = 12] = "Column";
-    ValidationTokenEnum[ValidationTokenEnum["Star"] = 13] = "Star";
-    ValidationTokenEnum[ValidationTokenEnum["OpenCurlyBrace"] = 14] = "OpenCurlyBrace";
-    ValidationTokenEnum[ValidationTokenEnum["CloseCurlyBrace"] = 15] = "CloseCurlyBrace";
-    ValidationTokenEnum[ValidationTokenEnum["HashMark"] = 16] = "HashMark";
-    ValidationTokenEnum[ValidationTokenEnum["QuestionMark"] = 17] = "QuestionMark";
-    ValidationTokenEnum[ValidationTokenEnum["Function"] = 18] = "Function";
-    ValidationTokenEnum[ValidationTokenEnum["Number"] = 19] = "Number";
-    ValidationTokenEnum[ValidationTokenEnum["Whitespace"] = 20] = "Whitespace";
-    ValidationTokenEnum[ValidationTokenEnum["Parenthesis"] = 21] = "Parenthesis";
-    ValidationTokenEnum[ValidationTokenEnum["Bracket"] = 22] = "Bracket";
-    ValidationTokenEnum[ValidationTokenEnum["Block"] = 23] = "Block";
-    ValidationTokenEnum[ValidationTokenEnum["AtLeastOnce"] = 24] = "AtLeastOnce";
-    ValidationTokenEnum[ValidationTokenEnum["Separator"] = 25] = "Separator";
-    ValidationTokenEnum[ValidationTokenEnum["Exclamation"] = 26] = "Exclamation";
-    ValidationTokenEnum[ValidationTokenEnum["Ampersand"] = 27] = "Ampersand";
-    ValidationTokenEnum[ValidationTokenEnum["PipeToken"] = 28] = "PipeToken";
-    ValidationTokenEnum[ValidationTokenEnum["ColumnToken"] = 29] = "ColumnToken";
-    ValidationTokenEnum[ValidationTokenEnum["AmpersandToken"] = 30] = "AmpersandToken";
-    ValidationTokenEnum[ValidationTokenEnum["Parens"] = 31] = "Parens";
-    ValidationTokenEnum[ValidationTokenEnum["PseudoClassToken"] = 32] = "PseudoClassToken";
-    ValidationTokenEnum[ValidationTokenEnum["PseudoClassFunctionToken"] = 33] = "PseudoClassFunctionToken";
-    ValidationTokenEnum[ValidationTokenEnum["StringToken"] = 34] = "StringToken";
-    ValidationTokenEnum[ValidationTokenEnum["AtRuleDefinition"] = 35] = "AtRuleDefinition";
-    ValidationTokenEnum[ValidationTokenEnum["DeclarationNameToken"] = 36] = "DeclarationNameToken";
-    ValidationTokenEnum[ValidationTokenEnum["DeclarationDefinitionToken"] = 37] = "DeclarationDefinitionToken";
-    ValidationTokenEnum[ValidationTokenEnum["SemiColon"] = 38] = "SemiColon";
-    ValidationTokenEnum[ValidationTokenEnum["Character"] = 39] = "Character";
-    ValidationTokenEnum[ValidationTokenEnum["InfinityToken"] = 40] = "InfinityToken";
-})(ValidationTokenEnum || (ValidationTokenEnum = {}));
-var ValidationSyntaxGroupEnum;
-(function (ValidationSyntaxGroupEnum) {
-    ValidationSyntaxGroupEnum["Declarations"] = "declarations";
-    ValidationSyntaxGroupEnum["Functions"] = "functions";
-    ValidationSyntaxGroupEnum["Syntaxes"] = "syntaxes";
-    ValidationSyntaxGroupEnum["Selectors"] = "selectors";
-    ValidationSyntaxGroupEnum["AtRules"] = "atRules";
-})(ValidationSyntaxGroupEnum || (ValidationSyntaxGroupEnum = {}));
-
-export { ValidationSyntaxGroupEnum, ValidationTokenEnum };