@tbela99/css-parser 1.3.3 → 1.4.0

package/dist/lib/parser/parse.js

@@ -1,25 +1,26 @@
-import { isIdentStart, isIdent, isIdentColor, mathFuncs, isColor, parseColor, isPseudo, pseudoElements, isAtKeyword, isFunction, isNumber, isPercentage, isFlex, isDimension, parseDimension, isHexColor, isHash, mediaTypes } from '../syntax/syntax.js';
-import { EnumToken, ColorType, ValidationLevel, SyntaxValidationResult } from '../ast/types.js';
-import { minify, definedPropertySettings, combinators } from '../ast/minify.js';
-import { walkValues, WalkerValueEvent, walk, WalkerOptionEnum } from '../ast/walk.js';
+import { isIdentStart, isIdent, isIdentColor, mathFuncs, isColor, parseColor, isPseudo, pseudoElements, isAtKeyword, isFunction, isNumber, isPercentage, parseDimension, isHexColor, isHash, mediaTypes } from '../syntax/syntax.js';
+import { EnumToken, ColorType, ValidationLevel, ModuleCaseTransformEnum, ModuleScopeEnumOptions, SyntaxValidationResult } from '../ast/types.js';
+import { definedPropertySettings, minify, combinators } from '../ast/minify.js';
+import { walkValues, WalkerEvent, walk, WalkerOptionEnum } from '../ast/walk.js';
 import { expand } from '../ast/expand.js';
 import './utils/config.js';
 import { parseDeclarationNode } from './utils/declaration.js';
+import { camelize, dasherize } from './utils/text.js';
 import { renderToken } from '../renderer/render.js';
 import '../renderer/sourcemap/lib/encode.js';
 import { funcLike, timingFunc, timelineFunc, COLORS_NAMES, systemColors, deprecatedSystemColors, colorsFunc } from '../syntax/color/utils/constants.js';
 import { buildExpression } from '../ast/math/expression.js';
 import { tokenize, tokenizeStream } from './tokenize.js';
 import '../validation/config.js';
-import '../validation/parser/types.js';
 import '../validation/parser/parse.js';
 import { validateSelector } from '../validation/selector.js';
 import { validateAtRule } from '../validation/atrule.js';
 import { splitTokenList } from '../validation/utils/list.js';
 import '../validation/syntaxes/complex-selector.js';
 import { validateKeyframeSelector } from '../validation/syntaxes/keyframe-selector.js';
-import { evaluateSyntax } from '../validation/syntax.js';
+import { isNodeAllowedInContext, evaluateSyntax } from '../validation/syntax.js';
 import { validateAtRuleKeyframes } from '../validation/at-rules/keyframes.js';
+import { hashAlgorithms, hash } from './utils/hash.js';
 
 const urlTokenMatcher = /^(["']?)[a-zA-Z0-9_/.-][a-zA-Z0-9_/:.#?-]+(\1)$/;
 const trimWhiteSpace = [EnumToken.CommentTokenType, EnumToken.GtTokenType, EnumToken.GteTokenType, EnumToken.LtTokenType, EnumToken.LteTokenType, EnumToken.ColumnCombinatorTokenType];
@@ -39,16 +40,20 @@ const enumTokenHints = new Set([
 function reject(reason) {
     throw new Error(reason ?? 'Parsing aborted');
 }
-function normalizeVisitorKeyName(keyName) {
-    return keyName.replace(/-([a-z])/g, (all, one) => one.toUpperCase());
-}
+/**
+ * replace token in its parent node
+ * @param parent
+ * @param value
+ * @param replacement
+ */
 function replaceToken(parent, value, replacement) {
-    // @ts-ignore
-    if ('parent' in value && value.parent != replacement.parent) {
-        Object.defineProperty(replacement, 'parent', {
-            ...definedPropertySettings,
-            value: value.parent
-        });
+    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) {
@@ -59,22 +64,138 @@ function replaceToken(parent, value, replacement) {
         }
     }
     else {
-        // @ts-ignore
         const target = 'val' in parent && Array.isArray(parent.val) ? parent.val : parent.chi;
         // @ts-ignore
         const index = target.indexOf(value);
         if (index == -1) {
             return;
         }
-        // @ts-ignore
         target.splice(index, 1, ...(Array.isArray(replacement) ? replacement : [replacement]));
     }
 }
+/**
+ * transform case of key name
+ * @param key
+ * @param how
+ *
+ * @throws Error
+ * @private
+ */
+function getKeyName(key, how) {
+    switch (how) {
+        case ModuleCaseTransformEnum.CamelCase:
+        case ModuleCaseTransformEnum.CamelCaseOnly:
+            return camelize(key);
+        case ModuleCaseTransformEnum.DashCase:
+        case ModuleCaseTransformEnum.DashCaseOnly:
+            return dasherize(key);
+    }
+    return key;
+}
+/**
+ * generate scoped name
+ * @param localName
+ * @param filePath
+ * @param pattern
+ * @param hashLength
+ *
+ * @throws Error
+ * @private
+ */
+async function generateScopedName(localName, filePath, pattern, hashLength = 5) {
+    if (localName.startsWith('--')) {
+        localName = localName.slice(2);
+    }
+    const matches = /.*?(([^/]+)\/)?([^/\\]*?)(\.([^?/]+))?([?].*)?$/.exec(filePath);
+    const folder = matches?.[2]?.replace?.(/[^A-Za-z0-9_-]/g, "_") ?? '';
+    const fileBase = matches?.[3] ?? '';
+    const ext = matches?.[5] ?? '';
+    const path = filePath.replace(/[^A-Za-z0-9_-]/g, "_");
+    // sanitize localName for safe char set (replace spaces/illegal chars)
+    const safeLocal = localName.replace(/[^A-Za-z0-9_-]/g, "_");
+    const hashString = `${localName}::${filePath}`;
+    let result = '';
+    let inParens = 0;
+    let key = '';
+    let position = 0;
+    // Compose final scoped name. Ensure the entire class doesn't start with digit:
+    for (const char of pattern) {
+        position += char.length;
+        if (char == '[') {
+            inParens++;
+            if (inParens != 1) {
+                throw new Error(`Unexpected character: '${char} at position ${position - 1}' in pattern '${pattern}'`);
+            }
+            continue;
+        }
+        if (char == ']') {
+            inParens--;
+            if (inParens != 0) {
+                throw new Error(`Unexpected character: '${char}:${position - 1}'`);
+            }
+            let hashAlgo = null;
+            let length = null;
+            if (key.includes(':')) {
+                const parts = key.split(':');
+                if (parts.length == 2) {
+                    // @ts-ignore
+                    [key, length] = parts;
+                    // @ts-ignore
+                    if (key == 'hash' && hashAlgorithms.includes(length)) {
+                        // @ts-ignore
+                        hashAlgo = length;
+                        length = null;
+                    }
+                }
+                if (parts.length == 3) {
+                    // @ts-ignore
+                    [key, hashAlgo, length] = parts;
+                }
+                if (length != null && !Number.isInteger(+length)) {
+                    throw new Error(`Unsupported hash length: '${length}'. expecting format [hash:length] or [hash:hash-algo:length]`);
+                }
+            }
+            switch (key) {
+                case 'hash':
+                    result += await hash(hashString, length ?? hashLength, hashAlgo);
+                    break;
+                case 'name':
+                    result += length != null ? fileBase.slice(0, +length) : fileBase;
+                    break;
+                case 'local':
+                    result += length != null ? safeLocal.slice(0, +length) : localName;
+                    break;
+                case 'ext':
+                    result += length != null ? ext.slice(0, +length) : ext;
+                    break;
+                case 'path':
+                    result += length != null ? path.slice(0, +length) : path;
+                    break;
+                case 'folder':
+                    result += length != null ? folder.slice(0, +length) : folder;
+                    break;
+                default:
+                    throw new Error(`Unsupported key: '${key}'`);
+            }
+            key = '';
+            continue;
+        }
+        if (inParens > 0) {
+            key += char;
+        }
+        else {
+            result += char;
+        }
+    }
+    // if leading char is digit, prefix underscore (very rare)
+    return (/^[0-9]/.test(result) ? '_' : '') + result;
+}
 /**
  * parse css string
  * @param iter
  * @param options
  *
+ * @throws Error
  * @private
  */
 async function doParse(iter, options = {}) {
@@ -106,6 +227,9 @@ async function doParse(iter, options = {}) {
     if (typeof options.validation == 'boolean') {
         options.validation = options.validation ? ValidationLevel.All : ValidationLevel.None;
     }
+    if (options.module) {
+        options.expandNestingRules = true;
+    }
     if (options.expandNestingRules) {
         options.nestingRules = false;
     }
@@ -119,6 +243,8 @@ async function doParse(iter, options = {}) {
     const stats = {
         src: options.src ?? '',
         bytesIn: 0,
+        nodesCount: 0,
+        tokensCount: 0,
         importedBytesIn: 0,
         parse: `0ms`,
         minify: `0ms`,
@@ -147,14 +273,107 @@ async function doParse(iter, options = {}) {
             src: ''
         };
     }
-    let item;
-    let node;
+    let valuesHandlers;
+    let preValuesHandlers;
+    let postValuesHandlers;
+    let preVisitorsHandlersMap;
+    let visitorsHandlersMap;
+    let postVisitorsHandlersMap;
     const rawTokens = [];
     const imports = [];
+    let item;
+    let node;
     // @ts-ignore ignore error
     let isAsync = typeof iter[Symbol.asyncIterator] === 'function';
+    if (options.visitor != null) {
+        valuesHandlers = new Map;
+        preValuesHandlers = new Map;
+        postValuesHandlers = new Map;
+        preVisitorsHandlersMap = new Map;
+        visitorsHandlersMap = new Map;
+        postVisitorsHandlersMap = new Map;
+        const visitors = Object.entries(options.visitor);
+        let key;
+        let value;
+        let i;
+        for (i = 0; i < visitors.length; i++) {
+            key = visitors[i][0];
+            value = visitors[i][1];
+            if (Number.isInteger(+key)) {
+                visitors.splice(i + 1, 0, ...Object.entries(value));
+                continue;
+            }
+            if (Array.isArray(value)) {
+                // @ts-ignore
+                visitors.splice(i + 1, 0, ...value.map((item) => [key, item]));
+                continue;
+            }
+            if (key in EnumToken) {
+                if (typeof value == 'function') {
+                    if (!valuesHandlers.has(EnumToken[key])) {
+                        valuesHandlers.set(EnumToken[key], []);
+                    }
+                    valuesHandlers.get(EnumToken[key]).push(value);
+                }
+                else if (typeof value == 'object' && 'type' in value && 'handler' in value && value.type in WalkerEvent) {
+                    if (value.type == WalkerEvent.Enter) {
+                        if (!preValuesHandlers.has(EnumToken[key])) {
+                            preValuesHandlers.set(EnumToken[key], []);
+                        }
+                        preValuesHandlers.get(EnumToken[key]).push(value.handler);
+                    }
+                    else if (value.type == WalkerEvent.Leave) {
+                        if (!postValuesHandlers.has(EnumToken[key])) {
+                            postValuesHandlers.set(EnumToken[key], []);
+                        }
+                        postValuesHandlers.get(EnumToken[key]).push(value.handler);
+                    }
+                }
+                else {
+                    errors.push({ action: 'ignore', message: `doParse: visitor.${key} is not a valid key name` });
+                }
+            }
+            else if (['Declaration', 'Rule', 'AtRule', 'KeyframesRule', 'KeyframesAtRule'].includes(key)) {
+                if (typeof value == 'function') {
+                    if (!visitorsHandlersMap.has(key)) {
+                        visitorsHandlersMap.set(key, []);
+                    }
+                    visitorsHandlersMap.get(key).push(value);
+                }
+                else if (typeof value == 'object') {
+                    if ('type' in value && 'handler' in value && value.type in WalkerEvent) {
+                        if (value.type == WalkerEvent.Enter) {
+                            if (!preVisitorsHandlersMap.has(key)) {
+                                preVisitorsHandlersMap.set(key, []);
+                            }
+                            preVisitorsHandlersMap.get(key).push(value.handler);
+                        }
+                        else if (value.type == WalkerEvent.Leave) {
+                            if (!postVisitorsHandlersMap.has(key)) {
+                                postVisitorsHandlersMap.set(key, []);
+                            }
+                            postVisitorsHandlersMap.get(key).push(value.handler);
+                        }
+                    }
+                    else {
+                        if (!visitorsHandlersMap.has(key)) {
+                            visitorsHandlersMap.set(key, []);
+                        }
+                        visitorsHandlersMap.get(key).push(value);
+                    }
+                }
+                else {
+                    errors.push({ action: 'ignore', message: `doParse: visitor.${key} is not a valid key name` });
+                }
+            }
+            else {
+                errors.push({ action: 'ignore', message: `doParse: visitor.${key} is not a valid key name` });
+            }
+        }
+    }
     while (item = isAsync ? (await iter.next()).value : iter.next().value) {
         stats.bytesIn = item.bytesIn;
+        stats.tokensCount++;
         rawTokens.push(item);
         if (item.hint != null && BadTokensTypes.includes(item.hint)) {
             const node = getTokenType(item.token, item.hint);
@@ -182,7 +401,7 @@ async function doParse(iter, options = {}) {
             ast.loc.end = item.end;
         }
         if (item.token == ';' || item.token == '{') {
-            node = parseNode(tokens, context, options, errors, src, map, rawTokens);
+            node = parseNode(tokens, context, options, errors, src, map, rawTokens, stats);
             rawTokens.length = 0;
             if (node != null) {
                 if ('chi' in node) {
@@ -226,7 +445,7 @@ async function doParse(iter, options = {}) {
             map = new Map;
         }
         else if (item.token == '}') {
-            parseNode(tokens, context, options, errors, src, map, rawTokens);
+            parseNode(tokens, context, options, errors, src, map, rawTokens, stats);
             rawTokens.length = 0;
             if (context.loc != null) {
                 context.loc.end = item.end;
@@ -247,7 +466,7 @@ async function doParse(iter, options = {}) {
         }
     }
     if (tokens.length > 0) {
-        node = parseNode(tokens, context, options, errors, src, map, rawTokens);
+        node = parseNode(tokens, context, options, errors, src, map, rawTokens, stats);
         rawTokens.length = 0;
         if (node != null) {
             if (node.typ == EnumToken.AtRuleNodeType && node.nam == 'import') {
@@ -276,6 +495,7 @@ async function doParse(iter, options = {}) {
                 const root = await doParse(stream instanceof ReadableStream ? tokenizeStream(stream) : tokenize({
                     stream,
                     buffer: '',
+                    offset: 0,
                     position: { ind: 0, lin: 1, col: 1 },
                     currentPosition: { ind: -1, lin: 1, col: 0 }
                 }), Object.assign({}, options, {
@@ -310,256 +530,675 @@ async function doParse(iter, options = {}) {
     if (options.expandNestingRules) {
         ast = expand(ast);
     }
-    const valuesHandlers = new Map;
-    const preValuesHandlers = new Map;
-    const postValuesHandlers = new Map;
-    const preVisitorsHandlersMap = new Map;
-    const visitorsHandlersMap = new Map;
-    const postVisitorsHandlersMap = new Map;
-    const allValuesHandlers = [];
+    let replacement;
+    let callable;
     if (options.visitor != null) {
-        for (const [key, value] of Object.entries(options.visitor)) {
-            if (key in EnumToken) {
-                if (typeof value == 'function') {
-                    valuesHandlers.set(EnumToken[key], value);
-                }
-                else if (typeof value == 'object' && 'type' in value && 'handler' in value && value.type in WalkerValueEvent) {
-                    if (WalkerValueEvent[value.type] == WalkerValueEvent.Enter) {
-                        preValuesHandlers.set(EnumToken[key], value.handler);
+        for (const result of walk(ast)) {
+            if (valuesHandlers.size > 0 || preVisitorsHandlersMap.size > 0 || visitorsHandlersMap.size > 0 || postVisitorsHandlersMap.size > 0) {
+                if ((result.node.typ == EnumToken.DeclarationNodeType &&
+                    (preVisitorsHandlersMap.has('Declaration') || visitorsHandlersMap.has('Declaration') || postVisitorsHandlersMap.has('Declaration'))) ||
+                    (result.node.typ == EnumToken.AtRuleNodeType && (preVisitorsHandlersMap.has('AtRule') || visitorsHandlersMap.has('AtRule') || postVisitorsHandlersMap.has('AtRule'))) ||
+                    (result.node.typ == EnumToken.KeyframesAtRuleNodeType && (preVisitorsHandlersMap.has('KeyframesAtRule') || visitorsHandlersMap.has('KeyframesAtRule') || postVisitorsHandlersMap.has('KeyframesAtRule')))) {
+                    const handlers = [];
+                    const key = result.node.typ == EnumToken.DeclarationNodeType ? 'Declaration' : result.node.typ == EnumToken.AtRuleNodeType ? 'AtRule' : 'KeyframesAtRule';
+                    if (preVisitorsHandlersMap.has(key)) {
+                        // @ts-ignore
+                        handlers.push(...preVisitorsHandlersMap.get(key));
                     }
-                    else if (WalkerValueEvent[value.type] == WalkerValueEvent.Leave) {
-                        postValuesHandlers.set(EnumToken[key], value.handler);
+                    if (visitorsHandlersMap.has(key)) {
+                        // @ts-ignore
+                        handlers.push(...visitorsHandlersMap.get(key));
+                    }
+                    if (postVisitorsHandlersMap.has(key)) {
+                        // @ts-ignore
+                        handlers.push(...postVisitorsHandlersMap.get(key));
+                    }
+                    let node = result.node;
+                    for (const handler of handlers) {
+                        callable = typeof handler == 'function' ? handler : handler[camelize(node.typ == EnumToken.DeclarationNodeType || node.typ == EnumToken.AtRuleNodeType ? node.nam : node.val)];
+                        if (callable == null) {
+                            continue;
+                        }
+                        replacement = callable(node, result.parent);
+                        if (replacement == null) {
+                            continue;
+                        }
+                        isAsync = replacement instanceof Promise || Object.getPrototypeOf(replacement).constructor.name == 'AsyncFunction';
+                        if (replacement) {
+                            replacement = await replacement;
+                        }
+                        if (replacement == null || replacement == node) {
+                            continue;
+                        }
+                        // @ts-ignore
+                        node = replacement;
+                        //
+                        if (Array.isArray(node)) {
+                            break;
+                        }
+                    }
+                    if (node != result.node) {
+                        // @ts-ignore
+                        replaceToken(result.parent, result.node, node);
                     }
                 }
-                else {
-                    console.warn(`doParse: visitor.${key} is not a valid key name`);
-                }
-            }
-            else if (['Declaration', 'Rule', 'AtRule', 'KeyframesRule', 'KeyframesAtRule'].includes(key)) {
-                if (typeof value == 'function') {
-                    visitorsHandlersMap.set(key, value);
-                }
-                else if (typeof value == 'object') {
-                    if ('type' in value && 'handler' in value && value.type in WalkerValueEvent) {
-                        if (WalkerValueEvent[value.type] == WalkerValueEvent.Enter) {
-                            preVisitorsHandlersMap.set(key, value.handler);
+                else if ((result.node.typ == EnumToken.RuleNodeType && (preVisitorsHandlersMap.has('Rule') || visitorsHandlersMap.has('Rule') || postVisitorsHandlersMap.has('Rule'))) ||
+                    (result.node.typ == EnumToken.KeyFramesRuleNodeType && (preVisitorsHandlersMap.has('KeyframesRule') || visitorsHandlersMap.has('KeyframesRule') || postVisitorsHandlersMap.has('KeyframesRule')))) {
+                    const handlers = [];
+                    const key = result.node.typ == EnumToken.RuleNodeType ? 'Rule' : 'KeyframesRule';
+                    if (preVisitorsHandlersMap.has(key)) {
+                        handlers.push(...preVisitorsHandlersMap.get(key));
+                    }
+                    if (visitorsHandlersMap.has(key)) {
+                        handlers.push(...visitorsHandlersMap.get(key));
+                    }
+                    if (postVisitorsHandlersMap.has(key)) {
+                        handlers.push(...postVisitorsHandlersMap.get(key));
+                    }
+                    let node = result.node;
+                    for (const callable of handlers) {
+                        replacement = callable(node, result.parent);
+                        if (replacement == null) {
+                            continue;
+                        }
+                        isAsync = replacement instanceof Promise || Object.getPrototypeOf(replacement).constructor.name == 'AsyncFunction';
+                        if (replacement) {
+                            replacement = await replacement;
                         }
-                        else if (WalkerValueEvent[value.type] == WalkerValueEvent.Leave) {
-                            postVisitorsHandlersMap.set(key, value.handler);
+                        if (replacement == null || replacement == node) {
+                            continue;
+                        }
+                        // @ts-ignore
+                        node = replacement;
+                        //
+                        if (Array.isArray(node)) {
+                            break;
                         }
                     }
-                    else {
-                        visitorsHandlersMap.set(key, value);
+                    // @ts-ignore
+                    if (node != result.node) {
+                        // @ts-ignore
+                        replaceToken(result.parent, result.node, node);
                     }
                 }
-                else {
-                    console.warn(`doParse: visitor.${key} is not a valid key name`);
+                else if (valuesHandlers.size > 0) {
+                    let node = null;
+                    node = result.node;
+                    if (valuesHandlers.has(node.typ)) {
+                        for (const valueHandler of valuesHandlers.get(node.typ)) {
+                            callable = valueHandler;
+                            replacement = callable(node, result.parent);
+                            if (replacement == null) {
+                                continue;
+                            }
+                            isAsync = replacement instanceof Promise || Object.getPrototypeOf(replacement).constructor.name == 'AsyncFunction';
+                            if (isAsync) {
+                                replacement = await replacement;
+                            }
+                            if (replacement != null && replacement != node) {
+                                node = replacement;
+                            }
+                        }
+                    }
+                    if (node != result.node) {
+                        // @ts-ignore
+                        replaceToken(result.parent, value, node);
+                    }
+                    const tokens = 'tokens' in result.node ? result.node.tokens : [];
+                    if ('val' in result.node && Array.isArray(result.node.val)) {
+                        tokens.push(...result.node.val);
+                    }
+                    if (tokens.length == 0) {
+                        continue;
+                    }
+                    for (const { value, parent, root } of walkValues(tokens, result.node)) {
+                        node = value;
+                        if (valuesHandlers.has(node.typ)) {
+                            for (const valueHandler of valuesHandlers.get(node.typ)) {
+                                callable = valueHandler;
+                                let result = callable(node, parent, root);
+                                if (result == null) {
+                                    continue;
+                                }
+                                isAsync = result instanceof Promise || Object.getPrototypeOf(result).constructor.name == 'AsyncFunction';
+                                if (isAsync) {
+                                    result = await result;
+                                }
+                                if (result != null && result != node) {
+                                    node = result;
+                                }
+                                //
+                                if (Array.isArray(node)) {
+                                    break;
+                                }
+                            }
+                        }
+                        if (node != value) {
+                            // @ts-ignore
+                            replaceToken(parent, value, node);
+                        }
+                    }
                 }
             }
-            else {
-                console.warn(`doParse: visitor.${key} is not a valid key name`);
+        }
+    }
+    if (options.minify) {
+        if (ast.chi.length > 0) {
+            let passes = options.pass ?? 1;
+            while (passes--) {
+                minify(ast, options, true, errors, false);
             }
         }
-        if (preValuesHandlers.size > 0) {
-            allValuesHandlers.push(preValuesHandlers);
+    }
+    stats.bytesIn += stats.importedBytesIn;
+    let endTime = performance.now();
+    const result = {
+        ast,
+        errors,
+        stats: {
+            ...stats,
+            parse: `${(endParseTime - startTime).toFixed(2)}ms`,
+            minify: `${(endTime - endParseTime).toFixed(2)}ms`,
+            total: `${(endTime - startTime).toFixed(2)}ms`
         }
-        if (valuesHandlers.size > 0) {
-            allValuesHandlers.push(valuesHandlers);
+    };
+    if (options.module) {
+        const moduleSettings = {
+            hashLength: 5,
+            filePath: '',
+            scoped: ModuleScopeEnumOptions.Local,
+            naming: ModuleCaseTransformEnum.IgnoreCase,
+            pattern: '',
+            generateScopedName,
+            ...(typeof options.module != 'object' ? {} : options.module)
+        };
+        const parseModuleTime = performance.now();
+        const namesMapping = {};
+        const global = new Set;
+        const processed = new Set;
+        const pattern = typeof options.module == 'boolean' ? null : moduleSettings.pattern;
+        const importMapping = {};
+        const cssVariablesMap = {};
+        const importedCssVariables = {};
+        let mapping = {};
+        let revMapping = {};
+        let filePath = typeof options.module == 'boolean' ? options.src : (moduleSettings.filePath ?? options.src);
+        filePath = filePath === '' ? options.src : options.resolve(filePath, options.dirname(options.src), options.cwd).relative;
+        if (typeof options.module == 'number') {
+            if (options.module & ModuleCaseTransformEnum.CamelCase) {
+                moduleSettings.naming = ModuleCaseTransformEnum.CamelCase;
+            }
+            else if (options.module & ModuleCaseTransformEnum.CamelCaseOnly) {
+                moduleSettings.naming = ModuleCaseTransformEnum.CamelCaseOnly;
+            }
+            else if (options.module & ModuleCaseTransformEnum.DashCase) {
+                moduleSettings.naming = ModuleCaseTransformEnum.DashCase;
+            }
+            else if (options.module & ModuleCaseTransformEnum.DashCaseOnly) {
+                moduleSettings.naming = ModuleCaseTransformEnum.DashCaseOnly;
+            }
+            if (options.module & ModuleScopeEnumOptions.Global) {
+                moduleSettings.scoped = ModuleScopeEnumOptions.Global;
+            }
+            if (options.module & ModuleScopeEnumOptions.Pure) {
+                // @ts-ignore
+                moduleSettings.scoped |= ModuleScopeEnumOptions.Pure;
+            }
+            if (options.module & ModuleScopeEnumOptions.ICSS) {
+                // @ts-ignore
+                moduleSettings.scoped |= ModuleScopeEnumOptions.ICSS;
+            }
         }
-        if (postValuesHandlers.size > 0) {
-            allValuesHandlers.push(postValuesHandlers);
+        if (typeof moduleSettings.scoped == 'boolean') {
+            moduleSettings.scoped = moduleSettings.scoped ? ModuleScopeEnumOptions.Local : ModuleScopeEnumOptions.Global;
         }
-    }
-    for (const result of walk(ast)) {
-        // if (result.parent != null && !isNodeAllowedInContext(result.node, result.parent as AstNode)) {
-        //
-        //     errors.push({
-        //         action: 'drop',
-        //         message: `${EnumToken[result.parent.typ]}: child ${EnumToken[result.node.typ]}${result.node.typ == EnumToken.DeclarationNodeType ? ` '${(result.node as AstDeclaration).nam}'` :  result.node.typ == EnumToken.AtRuleNodeType || result.node.typ == EnumToken.KeyframesAtRuleNodeType ? ` '@${(result.node as AstAtRule).nam}'` : ''} not allowed in context${result.parent.typ == EnumToken.AtRuleNodeType ? ` '@${(result.parent as AstAtRule).nam}'` : result.parent.typ == EnumToken.StyleSheetNodeType ? ` 'stylesheet'` : ''}`,
-        //         // @ts-ignore
-        //         location: result.node.loc ?? map.get(result.node ) ?? null
-        //     });
-        //
-        //     // @ts-ignore
-        //     removeNode(result.node, result.parent as AstNode);
-        //     continue;
-        // }
-        if (allValuesHandlers.length > 0 || preVisitorsHandlersMap.size > 0 || visitorsHandlersMap.size > 0 || postVisitorsHandlersMap.size > 0) {
-            if ((result.node.typ == EnumToken.DeclarationNodeType &&
-                (preVisitorsHandlersMap.has('Declaration') || visitorsHandlersMap.has('Declaration') || postVisitorsHandlersMap.has('Declaration'))) ||
-                (result.node.typ == EnumToken.AtRuleNodeType && (preVisitorsHandlersMap.has('AtRule') || visitorsHandlersMap.has('AtRule') || postVisitorsHandlersMap.has('AtRule'))) ||
-                (result.node.typ == EnumToken.KeyframesAtRuleNodeType && (preVisitorsHandlersMap.has('KeyframesAtRule') || visitorsHandlersMap.has('KeyframesAtRule') || postVisitorsHandlersMap.has('KeyframesAtRule')))) {
-                const handlers = [];
-                const key = result.node.typ == EnumToken.DeclarationNodeType ? 'Declaration' : result.node.typ == EnumToken.AtRuleNodeType ? 'AtRule' : 'KeyframesAtRule';
-                if (preVisitorsHandlersMap.has(key)) {
-                    // @ts-ignore
-                    handlers.push(preVisitorsHandlersMap.get(key));
+        moduleSettings.filePath = filePath;
+        moduleSettings.pattern = pattern != null && pattern !== '' ? pattern : (filePath === '' ? `[local]_[hash]` : `[local]_[hash]_[name]`);
+        for (const { node, parent } of walk(ast)) {
+            if (node.typ == EnumToken.CssVariableImportTokenType) {
+                const url = node.val.find(t => t.typ == EnumToken.StringTokenType).val.slice(1, -1);
+                const src = options.resolve(url, options.dirname(options.src), options.cwd);
+                const result = options.load(url, options.src);
+                const stream = result instanceof Promise || Object.getPrototypeOf(result).constructor.name == 'AsyncFunction' ? await result : result;
+                const root = await doParse(stream instanceof ReadableStream ? tokenizeStream(stream) : tokenize({
+                    stream,
+                    buffer: '',
+                    offset: 0,
+                    position: { ind: 0, lin: 1, col: 1 },
+                    currentPosition: { ind: -1, lin: 1, col: 0 }
+                }), Object.assign({}, options, {
+                    minify: false,
+                    setParent: false,
+                    src: src.relative
+                }));
+                cssVariablesMap[node.nam] = root.cssModuleVariables;
+                parent.chi.splice(parent.chi.indexOf(node), 1);
+                continue;
+            }
+            if (node.typ == EnumToken.CssVariableDeclarationMapTokenType) {
+                const from = node.from.find(t => t.typ == EnumToken.IdenTokenType || isIdentColor(t));
+                if (!(from.val in cssVariablesMap)) {
+                    errors.push({
+                        node,
+                        message: `could not resolve @value import from '${from.val}'`,
+                        action: 'drop'
+                    });
                 }
-                if (visitorsHandlersMap.has(key)) {
-                    // @ts-ignore
-                    handlers.push(visitorsHandlersMap.get(key));
+                else {
+                    for (const token of node.vars) {
+                        if (token.typ == EnumToken.IdenTokenType || isIdentColor(token)) {
+                            if (!(token.val in cssVariablesMap[from.val])) {
+                                errors.push({
+                                    node,
+                                    message: `value '${token.val}' is not exported from '${from.val}'`,
+                                    action: 'drop'
+                                });
+                                continue;
+                            }
+                            result.cssModuleVariables ??= {};
+                            result.cssModuleVariables[token.val] = importedCssVariables[token.val] = cssVariablesMap[from.val][token.val];
+                        }
+                    }
                 }
-                if (postVisitorsHandlersMap.has(key)) {
-                    // @ts-ignore
-                    handlers.push(postVisitorsHandlersMap.get(key));
+                parent.chi.splice(parent.chi.indexOf(node), 1);
+                continue;
+            }
+            if (node.typ == EnumToken.CssVariableTokenType) {
+                if (parent?.typ == EnumToken.StyleSheetNodeType) {
+                    if (result.cssModuleVariables == null) {
+                        result.cssModuleVariables = {};
+                    }
+                    result.cssModuleVariables[node.nam] = node;
                 }
-                let callable;
-                let node = result.node;
-                for (const handler of handlers) {
-                    callable = typeof handler == 'function' ? handler : handler[normalizeVisitorKeyName(node.typ == EnumToken.DeclarationNodeType || node.typ == EnumToken.AtRuleNodeType ? node.nam : node.val)];
-                    if (callable == null) {
-                        continue;
+                parent.chi.splice(parent.chi.indexOf(node), 1);
+                continue;
+            }
+            if (node.typ == EnumToken.DeclarationNodeType) {
+                if (node.nam.startsWith('--')) {
+                    if (!(node.nam in namesMapping)) {
+                        let result = (moduleSettings.scoped & ModuleScopeEnumOptions.Global) ? node.nam : moduleSettings.generateScopedName(node.nam, moduleSettings.filePath, moduleSettings.pattern, moduleSettings.hashLength);
+                        let value = result instanceof Promise ? await result : result;
+                        mapping[node.nam] = '--' + (moduleSettings.naming & ModuleCaseTransformEnum.DashCaseOnly || moduleSettings.naming & ModuleCaseTransformEnum.CamelCaseOnly ? getKeyName(value, moduleSettings.naming) : value);
+                        revMapping[node.nam] = node.nam;
                     }
-                    let replacement = callable(node, result.parent);
-                    if (replacement == null) {
-                        continue;
+                    node.nam = mapping[node.nam];
+                }
+                if ('composes' == node.nam.toLowerCase()) {
+                    const tokens = [];
+                    let isValid = true;
+                    for (const token of node.val) {
+                        if (token.typ == EnumToken.ComposesSelectorNodeType) {
+                            if (!(token.r == null || token.r.typ == EnumToken.StringTokenType || token.r.typ == EnumToken.IdenTokenType)) {
+                                errors.push({
+                                    action: 'drop',
+                                    message: `composes '${EnumToken[token.r.typ]}' is not supported`,
+                                    node
+                                });
+                                isValid = false;
+                                break;
+                            }
+                            tokens.push(token);
+                        }
                     }
-                    isAsync = replacement instanceof Promise || Object.getPrototypeOf(replacement).constructor.name == 'AsyncFunction';
-                    if (replacement) {
-                        replacement = await replacement;
+                    // find parent rule
+                    let parentRule = node.parent;
+                    while (parentRule != null && parentRule.typ != EnumToken.RuleNodeType) {
+                        parentRule = parentRule.parent;
                     }
-                    if (replacement == null || replacement == node) {
+                    if (!isValid || tokens.length == 0) {
+                        if (tokens.length == 0) {
+                            errors.push({
+                                action: 'drop',
+                                message: `composes is empty`,
+                                node
+                            });
+                        }
+                        parentRule.chi.splice(parentRule.chi.indexOf(node), 1);
                         continue;
                     }
-                    // @ts-ignore
-                    node = replacement;
-                    //
-                    if (Array.isArray(node)) {
-                        break;
+                    for (const token of tokens) {
+                        // composes: a b c;
+                        if (token.r == null) {
+                            for (const rule of token.l) {
+                                if (rule.typ == EnumToken.WhitespaceTokenType || rule.typ == EnumToken.CommentTokenType) {
+                                    continue;
+                                }
+                                if (!(rule.val in mapping)) {
+                                    let result = (moduleSettings.scoped & ModuleScopeEnumOptions.Global) ? rule.val : moduleSettings.generateScopedName(rule.val, moduleSettings.filePath, moduleSettings.pattern, moduleSettings.hashLength);
+                                    let value = result instanceof Promise ? await result : result;
+                                    mapping[rule.val] = (rule.typ == EnumToken.DashedIdenTokenType ? '--' : '') + (moduleSettings.naming & ModuleCaseTransformEnum.DashCaseOnly || moduleSettings.naming & ModuleCaseTransformEnum.CamelCaseOnly ? getKeyName(value, moduleSettings.naming) : value);
+                                    revMapping[mapping[rule.val]] = rule.val;
+                                }
+                                if (parentRule != null) {
+                                    for (const tk of parentRule.tokens) {
+                                        if (tk.typ == EnumToken.ClassSelectorTokenType) {
+                                            const val = tk.val.slice(1);
+                                            if (val in revMapping) {
+                                                const key = revMapping[val];
+                                                mapping[key] = [...new Set([...mapping[key].split(' '), mapping[rule.val]])].join(' ');
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        // composes: a b c from 'file.css';
+                        else if (token.r.typ == EnumToken.String) {
+                            const url = token.r.val.slice(1, -1);
+                            const src = options.resolve(url, options.dirname(options.src), options.cwd);
+                            const result = options.load(url, options.src);
+                            const stream = result instanceof Promise || Object.getPrototypeOf(result).constructor.name == 'AsyncFunction' ? await result : result;
+                            const root = await doParse(stream instanceof ReadableStream ? tokenizeStream(stream) : tokenize({
+                                stream,
+                                buffer: '',
+                                offset: 0,
+                                position: { ind: 0, lin: 1, col: 1 },
+                                currentPosition: { ind: -1, lin: 1, col: 0 }
+                            }), Object.assign({}, options, {
+                                minify: false,
+                                setParent: false,
+                                src: src.relative
+                            }));
+                            const srcIndex = (src.relative.startsWith('/') || src.relative.startsWith('../') ? '' : './') + src.relative;
+                            if (Object.keys(root.mapping).length > 0) {
+                                importMapping[srcIndex] = {};
+                            }
+                            if (parentRule != null) {
+                                for (const tk of parentRule.tokens) {
+                                    if (tk.typ == EnumToken.ClassSelectorTokenType) {
+                                        const val = tk.val.slice(1);
+                                        if (val in revMapping) {
+                                            const key = revMapping[val];
+                                            const values = [];
+                                            for (const iden of token.l) {
+                                                if (iden.typ != EnumToken.IdenTokenType && iden.typ != EnumToken.DashedIdenTokenType) {
+                                                    continue;
+                                                }
+                                                if (!(iden.val in root.mapping)) {
+                                                    const result = (moduleSettings.scoped & ModuleScopeEnumOptions.Global) ? iden.val : moduleSettings.generateScopedName(iden.val, srcIndex, moduleSettings.pattern, moduleSettings.hashLength);
+                                                    let value = result instanceof Promise ? await result : result;
+                                                    root.mapping[iden.val] = (moduleSettings.naming & ModuleCaseTransformEnum.DashCaseOnly || moduleSettings.naming & ModuleCaseTransformEnum.CamelCaseOnly ? getKeyName(value, moduleSettings.naming) : value);
+                                                    root.revMapping[root.mapping[iden.val]] = iden.val;
+                                                }
+                                                importMapping[srcIndex][iden.val] = root.mapping[iden.val];
+                                                values.push(root.mapping[iden.val]);
+                                            }
+                                            mapping[key] = [...new Set([...mapping[key].split(' '), ...values])].join(' ');
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        // composes: a b c from global;
+                        else if (token.r.typ == EnumToken.IdenTokenType) {
+                            // global
+                            if (parentRule != null) {
+                                if ('global' == token.r.val.toLowerCase()) {
+                                    for (const tk of parentRule.tokens) {
+                                        if (tk.typ == EnumToken.ClassSelectorTokenType) {
+                                            const val = tk.val.slice(1);
+                                            if (val in revMapping) {
+                                                const key = revMapping[val];
+                                                mapping[key] = [...new Set([...mapping[key].split(' '), ...(token.l.reduce((acc, curr) => {
+                                                            if (curr.typ == EnumToken.IdenTokenType) {
+                                                                acc.push(curr.val);
+                                                            }
+                                                            return acc;
+                                                        }, []))])].join(' ');
+                                            }
+                                        }
+                                    }
+                                }
+                                else {
+                                    errors.push({
+                                        action: 'drop',
+                                        message: `composes '${token.r.val}' is not supported`,
+                                        node
+                                    });
+                                }
+                            }
+                        }
                     }
+                    parentRule.chi.splice(parentRule.chi.indexOf(node), 1);
                 }
-                if (node != result.node) {
-                    // @ts-ignore
-                    replaceToken(result.parent, result.node, node);
+                if (node.typ == EnumToken.DeclarationNodeType && ['grid-column', 'grid-column-start', 'grid-column-end', 'grid-row', 'grid-row-start', 'grid-row-end', 'grid-template', 'grid-template-columns', 'grid-template-rows'].includes(node.nam)) {
+                    for (const { value } of walkValues(node.val, node)) {
+                        if (value.typ != EnumToken.IdenTokenType) {
+                            continue;
+                        }
+                        let idenToken = value.val;
+                        let suffix = '';
+                        if (idenToken.endsWith('-start')) {
+                            suffix = '-start';
+                            idenToken = idenToken.slice(0, -6);
+                        }
+                        else if (idenToken.endsWith('-end')) {
+                            suffix = '-end';
+                            idenToken = idenToken.slice(0, -4);
+                        }
+                        if (!(idenToken in mapping)) {
+                            let result = (moduleSettings.scoped & ModuleScopeEnumOptions.Global) ? idenToken : moduleSettings.generateScopedName(idenToken, moduleSettings.filePath, moduleSettings.pattern, moduleSettings.hashLength);
+                            if (result instanceof Promise) {
+                                result = await result;
+                            }
+                            mapping[idenToken] = result;
+                            revMapping[result] = idenToken;
+                            if (suffix !== '') {
+                                idenToken += suffix;
+                                if (!(idenToken in mapping)) {
+                                    mapping[idenToken] = result + suffix;
+                                    revMapping[result + suffix] = idenToken;
+                                }
+                            }
+                        }
+                        value.val = mapping[idenToken];
+                    }
                 }
-            }
-            else if ((result.node.typ == EnumToken.RuleNodeType && (preVisitorsHandlersMap.has('Rule') || visitorsHandlersMap.has('Rule') || postVisitorsHandlersMap.has('Rule'))) ||
-                (result.node.typ == EnumToken.KeyFramesRuleNodeType && (preVisitorsHandlersMap.has('KeyframesRule') || visitorsHandlersMap.has('KeyframesRule') || postVisitorsHandlersMap.has('KeyframesRule')))) {
-                const handlers = [];
-                const key = result.node.typ == EnumToken.RuleNodeType ? 'Rule' : 'KeyframesRule';
-                if (preVisitorsHandlersMap.has(key)) {
-                    // @ts-ignore
-                    handlers.push(preVisitorsHandlersMap.get(key));
+                else if (node.nam == 'grid-template-areas' || node.nam == 'grid-template') {
+                    for (let i = 0; i < node.val.length; i++) {
+                        if (node.val[i].typ == EnumToken.String) {
+                            const tokens = parseString(node.val[i].val.slice(1, -1), { location: true });
+                            for (const { value } of walkValues(tokens)) {
+                                if (value.typ == EnumToken.IdenTokenType || value.typ == EnumToken.DashedIdenTokenType) {
+                                    if (value.val in mapping) {
+                                        value.val = mapping[value.val];
+                                    }
+                                    else {
+                                        let result = (moduleSettings.scoped & ModuleScopeEnumOptions.Global) ? value.val : moduleSettings.generateScopedName(value.val, moduleSettings.filePath, moduleSettings.pattern, moduleSettings.hashLength);
+                                        if (result instanceof Promise) {
+                                            result = await result;
+                                        }
+                                        mapping[value.val] = result;
+                                        revMapping[result] = value.val;
+                                        value.val = result;
+                                    }
+                                }
+                            }
+                            node.val[i].val = node.val[i].val.charAt(0) + tokens.reduce((acc, curr) => acc + renderToken(curr), '') + node.val[i].val.charAt(node.val[i].val.length - 1);
+                        }
+                    }
                 }
-                if (visitorsHandlersMap.has(key)) {
-                    // @ts-ignore
-                    handlers.push(visitorsHandlersMap.get(key));
+                else if (node.nam == 'animation' || node.nam == 'animation-name') {
+                    for (const { value } of walkValues(node.val, node)) {
+                        if (value.typ == EnumToken.IdenTokenType && ![
+                            'none', 'infinite', 'normal', 'reverse', 'alternate',
+                            'alternate-reverse', 'forwards', 'backwards', 'both',
+                            'running', 'paused', 'linear', 'ease', 'ease-in', 'ease-out', 'ease-in-out',
+                            'step-start', 'step-end', 'jump-start', 'jump-end',
+                            'jump-none', 'jump-both', 'start', 'end',
+                            'inherit', 'initial', 'unset'
+                        ].includes(value.val)) {
+                            if (!(value.val in mapping)) {
+                                const result = (moduleSettings.scoped & ModuleScopeEnumOptions.Global) ? value.val : moduleSettings.generateScopedName(value.val, moduleSettings.filePath, moduleSettings.pattern, moduleSettings.hashLength);
+                                mapping[value.val] = result instanceof Promise ? await result : result;
+                                revMapping[mapping[value.val]] = value.val;
+                            }
+                            value.val = mapping[value.val];
+                        }
+                    }
                 }
-                if (postVisitorsHandlersMap.has(key)) {
-                    // @ts-ignore
-                    handlers.push(postVisitorsHandlersMap.get(key));
+                for (const { value, parent } of walkValues(node.val, node)) {
+                    if (value.typ == EnumToken.DashedIdenTokenType) {
+                        if (!(value.val in mapping)) {
+                            const result = (moduleSettings.scoped & ModuleScopeEnumOptions.Global) ? value.val : moduleSettings.generateScopedName(value.val, moduleSettings.filePath, moduleSettings.pattern, moduleSettings.hashLength);
+                            let val = result instanceof Promise ? await result : result;
+                            mapping[value.val] = '--' + (moduleSettings.naming & ModuleCaseTransformEnum.DashCaseOnly || moduleSettings.naming & ModuleCaseTransformEnum.CamelCaseOnly ? getKeyName(val, moduleSettings.naming) : val);
+                            revMapping[mapping[value.val]] = value.val;
+                        }
+                        value.val = mapping[value.val];
+                    }
+                    else if ((value.typ == EnumToken.IdenTokenType || isIdentColor(value)) && value.val in importedCssVariables) {
+                        replaceToken(parent, value, importedCssVariables[value.val].val);
+                    }
                 }
-                let node = result.node;
-                for (const callable of handlers) {
-                    // @ts-ignore
-                    let replacement = callable(node, result.parent);
-                    if (replacement == null) {
-                        continue;
+            }
+            else if (node.typ == EnumToken.RuleNodeType) {
+                if (node.tokens == null) {
+                    Object.defineProperty(node, 'tokens', {
+                        ...definedPropertySettings,
+                        value: parseSelector(parseString(node.sel, { location: true }))
+                    });
+                }
+                let hasIdOrClass = false;
+                for (const { value } of walkValues(node.tokens, node, 
+                // @ts-ignore
+                (value, parent) => {
+                    if (value.typ == EnumToken.PseudoClassTokenType) {
+                        const val = value.val.toLowerCase();
+                        switch (val) {
+                            case ':local':
+                            case ':global':
+                                {
+                                    let index = parent.tokens.indexOf(value);
+                                    parent.tokens.splice(index, 1);
+                                    if (parent.tokens[index]?.typ == EnumToken.WhitespaceTokenType || parent.tokens[index]?.typ == EnumToken.DescendantCombinatorTokenType) {
+                                        parent.tokens.splice(index, 1);
+                                    }
+                                    if (val == ':global') {
+                                        for (; index < parent.tokens.length; index++) {
+                                            if (parent.tokens[index].typ == EnumToken.CommaTokenType ||
+                                                ([EnumToken.PseudoClassFuncTokenType, EnumToken.PseudoClassTokenType].includes(parent.tokens[index].typ) &&
+                                                    [':global', ':local'].includes(parent.tokens[index].val.toLowerCase()))) {
+                                                break;
+                                            }
+                                            global.add(parent.tokens[index]);
+                                        }
+                                    }
+                                }
+                                break;
+                        }
                     }
-                    isAsync = replacement instanceof Promise || Object.getPrototypeOf(replacement).constructor.name == 'AsyncFunction';
-                    if (replacement) {
-                        replacement = await replacement;
+                    else if (value.typ == EnumToken.PseudoClassFuncTokenType) {
+                        switch (value.val.toLowerCase()) {
+                            case ':global':
+                                for (const token of value.chi) {
+                                    global.add(token);
+                                }
+                                parent.tokens.splice(parent.tokens.indexOf(value), 1, ...value.chi);
+                                break;
+                            case ':local':
+                                parent.tokens.splice(parent.tokens.indexOf(value), 1, ...value.chi);
+                                break;
+                        }
                     }
-                    if (replacement == null || replacement == node) {
-                        continue;
+                })) {
+                    if (value.typ == EnumToken.HashTokenType || value.typ == EnumToken.ClassSelectorTokenType) {
+                        hasIdOrClass = true;
                     }
-                    // @ts-ignore
-                    node = replacement;
-                    //
-                    if (Array.isArray(node)) {
-                        break;
+                    if (processed.has(value)) {
+                        continue;
                     }
-                }
-                // @ts-ignore
-                if (node != result.node) {
-                    // @ts-ignore
-                    replaceToken(result.parent, result.node, node);
-                }
-            }
-            else if (allValuesHandlers.length > 0) {
-                let callable;
-                let node = null;
-                node = result.node;
-                for (const valueHandler of allValuesHandlers) {
-                    if (valueHandler.has(node.typ)) {
-                        callable = valueHandler.get(node.typ);
-                        let replacement = callable(node, result.parent);
-                        if (replacement == null) {
+                    processed.add(value);
+                    if (value.typ == EnumToken.PseudoClassTokenType) ;
+                    else if (value.typ == EnumToken.PseudoClassFuncTokenType) ;
+                    else {
+                        if (global.has(value)) {
                             continue;
                         }
-                        isAsync = replacement instanceof Promise || Object.getPrototypeOf(replacement).constructor.name == 'AsyncFunction';
-                        if (isAsync) {
-                            replacement = await replacement;
-                        }
-                        if (replacement != null && replacement != node) {
-                            node = replacement;
+                        if (value.typ == EnumToken.ClassSelectorTokenType) {
+                            const val = value.val.slice(1);
+                            if (!(val in mapping)) {
+                                const result = (moduleSettings.scoped & ModuleScopeEnumOptions.Global) ? val : moduleSettings.generateScopedName(val, moduleSettings.filePath, moduleSettings.pattern, moduleSettings.hashLength);
+                                let value = result instanceof Promise ? await result : result;
+                                mapping[val] = (moduleSettings.naming & ModuleCaseTransformEnum.DashCaseOnly || moduleSettings.naming & ModuleCaseTransformEnum.CamelCaseOnly ? getKeyName(value, moduleSettings.naming) : value);
+                                revMapping[mapping[val]] = val;
+                            }
+                            value.val = '.' + mapping[val];
                         }
                     }
                 }
-                if (node != result.node) {
-                    // @ts-ignore
-                    replaceToken(result.parent, value, node);
+                if (moduleSettings.scoped & ModuleScopeEnumOptions.Pure) {
+                    if (!hasIdOrClass) {
+                        throw new Error(`pure module: No id or class found in selector '${node.sel}' at '${node.loc?.src ?? ''}':${node.loc?.sta?.lin ?? ''}:${node.loc?.sta?.col ?? ''}`);
+                    }
                 }
-                const tokens = 'tokens' in result.node ? result.node.tokens : [];
-                if ('val' in result.node && Array.isArray(result.node.val)) {
-                    tokens.push(...result.node.val);
+                node.sel = '';
+                for (const token of node.tokens) {
+                    node.sel += renderToken(token);
                 }
-                if (tokens.length == 0) {
-                    continue;
+            }
+            else if (node.typ == EnumToken.AtRuleNodeType || node.typ == EnumToken.KeyframesAtRuleNodeType) {
+                const val = node.nam.toLowerCase();
+                if (node.tokens == null) {
+                    Object.defineProperty(node, 'tokens', {
+                        ...definedPropertySettings,
+                        // @ts-ignore
+                        value: parseAtRulePrelude(parseString(node.val), node)
+                    });
                 }
-                for (const { value, parent, root } of walkValues(tokens, result.node)) {
-                    node = value;
-                    for (const valueHandler of allValuesHandlers) {
-                        if (valueHandler.has(node.typ)) {
-                            callable = valueHandler.get(node.typ);
-                            let result = callable(node, parent, root);
-                            if (result == null) {
-                                continue;
-                            }
-                            isAsync = result instanceof Promise || Object.getPrototypeOf(result).constructor.name == 'AsyncFunction';
-                            if (isAsync) {
-                                result = await result;
+                if (val == 'property' || val == 'keyframes') {
+                    const prefix = val == 'property' ? '--' : '';
+                    for (const value of node.tokens) {
+                        if ((prefix == '--' && value.typ == EnumToken.DashedIdenTokenType) || (prefix == '' && value.typ == EnumToken.IdenTokenType)) {
+                            if (!(value.val in mapping)) {
+                                const result = (moduleSettings.scoped & ModuleScopeEnumOptions.Global) ? value.val : moduleSettings.generateScopedName(value.val, moduleSettings.filePath, moduleSettings.pattern, moduleSettings.hashLength);
+                                let val = result instanceof Promise ? await result : result;
+                                mapping[value.val] = prefix + (moduleSettings.naming & ModuleCaseTransformEnum.DashCaseOnly || moduleSettings.naming & ModuleCaseTransformEnum.CamelCaseOnly ? getKeyName(val, moduleSettings.naming) : val);
+                                revMapping[mapping[value.val]] = value.val;
                             }
-                            if (result != null && result != node) {
-                                node = result;
-                            }
-                            //
-                            if (Array.isArray(node)) {
-                                break;
+                            value.val = mapping[value.val];
+                        }
+                    }
+                    node.val = node.tokens.reduce((a, b) => a + renderToken(b), '');
+                }
+                else {
+                    let isReplaced = false;
+                    for (const { value, parent } of walkValues(node.tokens, node)) {
+                        if (EnumToken.MediaQueryConditionTokenType == parent.typ && value != parent.l) {
+                            if ((value.typ == EnumToken.IdenTokenType || isIdentColor(value)) && value.val in importedCssVariables) {
+                                isReplaced = true;
+                                parent.r.splice(parent.r.indexOf(value), 1, ...importedCssVariables[value.val].val);
                             }
                         }
                     }
-                    if (node != value) {
-                        // @ts-ignore
-                        replaceToken(parent, value, node);
+                    if (isReplaced) {
+                        node.val = node.tokens.reduce((a, b) => a + renderToken(b), '');
                     }
                 }
             }
         }
-    }
-    if (options.minify) {
-        if (ast.chi.length > 0) {
-            let passes = options.pass ?? 1;
-            while (passes--) {
-                minify(ast, options, true, errors, false);
-            }
+        if (moduleSettings.naming != ModuleCaseTransformEnum.IgnoreCase) {
+            revMapping = {};
+            mapping = Object.entries(mapping).reduce((acc, [key, value]) => {
+                const keyName = getKeyName(key, moduleSettings.naming);
+                acc[keyName] = value;
+                revMapping[value] = keyName;
+                return acc;
+            }, {});
         }
+        result.mapping = mapping;
+        result.revMapping = revMapping;
+        if ((moduleSettings.scoped & ModuleScopeEnumOptions.ICSS) && Object.keys(importMapping).length > 0) {
+            result.importMapping = importMapping;
+        }
+        endTime = performance.now();
+        result.stats.module = `${(endTime - parseModuleTime).toFixed(2)}ms`;
+        result.stats.total = `${(endTime - startTime).toFixed(2)}ms`;
     }
-    const endTime = performance.now();
     if (options.signal != null) {
         options.signal.removeEventListener('abort', reject);
     }
-    stats.bytesIn += stats.importedBytesIn;
-    return {
-        ast,
-        errors,
-        stats: {
-            ...stats,
-            parse: `${(endParseTime - startTime).toFixed(2)}ms`,
-            minify: `${(endTime - endParseTime).toFixed(2)}ms`,
-            total: `${(endTime - startTime).toFixed(2)}ms`
-        }
-    };
+    return result;
 }
 function getLastNode(context) {
     let i = context.chi.length;
@@ -571,7 +1210,7 @@ function getLastNode(context) {
     }
     return null;
 }
-function parseNode(results, context, options, errors, src, map, rawTokens) {
+function parseNode(results, context, options, errors, src, map, rawTokens, stats) {
     let tokens = [];
     for (const t of results) {
         const node = getTokenType(t.token, t.hint);
@@ -594,9 +1233,12 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
             }
             loc = location;
             context.chi.push(tokens[i]);
-            if (options.sourcemap) {
-                tokens[i].loc = loc;
-            }
+            stats.nodesCount++;
+            Object.defineProperty(tokens[i], 'loc', {
+                ...definedPropertySettings,
+                value: loc,
+                enumerable: options.sourcemap !== false
+            });
         }
         else if (tokens[i].typ != EnumToken.WhitespaceTokenType) {
             break;
@@ -737,10 +1379,10 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
             }
         }
         const t = parseAtRulePrelude(parseTokens(tokens, { minify: options.minify }), atRule);
-        const raw = t.reduce((acc, curr) => {
-            acc.push(renderToken(curr, { removeComments: true, convertColor: false }));
-            return acc;
-        }, []);
+        const raw = [];
+        for (const curr of t) {
+            raw.push(renderToken(curr, { removeComments: true, convertColor: false }));
+        }
         const nam = renderToken(atRule, { removeComments: true });
         // @ts-ignore
         const node = {
@@ -756,10 +1398,12 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
             node.chi = [];
         }
         loc = map.get(atRule);
-        if (options.sourcemap) {
-            node.loc = loc;
-            node.loc.end = { ...map.get(delim).end };
-        }
+        Object.defineProperty(node, 'loc', {
+            ...definedPropertySettings,
+            value: loc,
+            enumerable: options.sourcemap !== false
+        });
+        node.loc.end = { ...map.get(delim).end };
         let isValid = true;
         if (node.nam == 'else') {
             const prev = getLastNode(context);
@@ -772,21 +1416,173 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
                 isValid = false;
             }
         }
+        if (node.nam == 'value') {
+            let i = 0;
+            while (i < tokens.length) {
+                if (tokens[i].typ == EnumToken.WhitespaceTokenType || tokens[i].typ == EnumToken.CommentTokenType) {
+                    i++;
+                    continue;
+                }
+                break;
+            }
+            if (i < tokens.length) {
+                if (tokens[i].typ == EnumToken.IdenTokenType || isIdentColor(tokens[i])) {
+                    let k = i + 1;
+                    while (k < tokens.length) {
+                        if (tokens[k].typ == EnumToken.WhitespaceTokenType || tokens[k].typ == EnumToken.CommentTokenType) {
+                            k++;
+                            continue;
+                        }
+                        // var or import
+                        if (tokens[k].typ == EnumToken.ColonTokenType) {
+                            let j = k;
+                            while (++j < tokens.length) {
+                                if (tokens[j].typ != EnumToken.WhitespaceTokenType && tokens[j].typ != EnumToken.CommentTokenType) {
+                                    break;
+                                }
+                            }
+                            let offset = k + 1;
+                            while (offset < tokens.length && tokens[offset].typ == EnumToken.WhitespaceTokenType) {
+                                offset++;
+                            }
+                            if (tokens[j].typ == EnumToken.StringTokenType) {
+                                Object.assign(node, {
+                                    typ: EnumToken.CssVariableImportTokenType,
+                                    nam: tokens[i].val,
+                                    val: tokens.slice(offset)
+                                });
+                                delete node.tokens;
+                                // @ts-ignore
+                                delete node.raw;
+                                context.chi.push(node);
+                                return null;
+                            }
+                            Object.assign(node, {
+                                typ: EnumToken.CssVariableTokenType,
+                                nam: tokens[i].val,
+                                val: tokens.slice(offset)
+                            });
+                            context.chi.push(node);
+                            return null;
+                        }
+                        if (tokens[k].typ == EnumToken.PseudoClassTokenType) {
+                            Object.assign(tokens[k], {
+                                typ: EnumToken.IdenTokenType,
+                                val: tokens[k].val.slice(1)
+                            });
+                            Object.assign(node, {
+                                typ: EnumToken.CssVariableTokenType,
+                                nam: tokens[i].val,
+                                val: tokens.slice(k)
+                            });
+                            context.chi.push(node);
+                            return null;
+                        }
+                        if (tokens[k].typ == EnumToken.CommaTokenType) {
+                            let j = i;
+                            while (++j < tokens.length) {
+                                if (tokens[j].typ == EnumToken.IdenTokenType && tokens[j].val.toLowerCase() == 'from') {
+                                    const vars = tokens.slice(i, j);
+                                    const from = tokens.slice(j + 1);
+                                    let l = 0;
+                                    let expect = EnumToken.IdenTokenType;
+                                    for (; l < vars.length; l++) {
+                                        if (vars[l].typ == EnumToken.WhitespaceTokenType || vars[l].typ == EnumToken.CommentTokenType) {
+                                            continue;
+                                        }
+                                        if (expect == vars[l].typ || (expect == EnumToken.IdenTokenType && isIdentColor(vars[l]))) {
+                                            expect = expect == EnumToken.CommaTokenType ? EnumToken.IdenTokenType : EnumToken.CommaTokenType;
+                                            continue;
+                                        }
+                                        errors.push({
+                                            action: 'drop',
+                                            node: node,
+                                            location: map.get(vars[l]) ?? location,
+                                            message: `expecting '${EnumToken[expect]}' but found ${renderToken(vars[l])}`
+                                        });
+                                        return null;
+                                    }
+                                    l = 0;
+                                    expect = EnumToken.IdenTokenType;
+                                    for (; l < from.length; l++) {
+                                        if (from[l].typ == EnumToken.WhitespaceTokenType || from[l].typ == EnumToken.CommentTokenType) {
+                                            continue;
+                                        }
+                                        if (expect == from[l].typ || isIdentColor(from[l])) {
+                                            while (++l < from.length) {
+                                                if (from[l].typ == EnumToken.WhitespaceTokenType || from[l].typ == EnumToken.CommentTokenType) {
+                                                    continue;
+                                                }
+                                                errors.push({
+                                                    action: 'drop',
+                                                    node: node,
+                                                    location: map.get(from[l]) ?? location,
+                                                    message: `unexpected '${renderToken(from[l])}'`
+                                                });
+                                                return null;
+                                            }
+                                            break;
+                                        }
+                                        errors.push({
+                                            action: 'drop',
+                                            node: node,
+                                            location: map.get(from[l]) ?? location,
+                                            message: `expecting <string> but found ${renderToken(from[l])}`
+                                        });
+                                        return null;
+                                    }
+                                    // @ts-ignore
+                                    delete node.nam;
+                                    // @ts-ignore
+                                    delete node.val;
+                                    Object.assign(node, {
+                                        typ: EnumToken.CssVariableDeclarationMapTokenType,
+                                        vars,
+                                        from
+                                    });
+                                    context.chi.push(node);
+                                    return null;
+                                }
+                            }
+                        }
+                        k++;
+                    }
+                    Object.assign(node, {
+                        typ: EnumToken.CssVariableTokenType,
+                        nam: tokens[i].val,
+                        val: tokens.slice(k)
+                    });
+                    context.chi.push(node);
+                    return null;
+                }
+            }
+        }
         // @ts-ignore
-        const valid = options.validation == ValidationLevel.None ? {
+        const skipValidate = (options.validation & ValidationLevel.AtRule) == 0;
+        const isAllowed = skipValidate || isNodeAllowedInContext(node, context);
+        // @ts-ignore
+        const valid = skipValidate ? {
             valid: SyntaxValidationResult.Valid,
             error: '',
             node,
             syntax: '@' + node.nam
-        } : isValid ? (node.typ == EnumToken.KeyframesAtRuleNodeType ? validateAtRuleKeyframes(node) : validateAtRule(node, options, context)) : {
+        } : !isAllowed ? {
+            valid: SyntaxValidationResult.Drop,
+            node,
+            syntax: '@' + node.nam,
+            error: `${EnumToken[context.typ]}: child ${EnumToken[node.typ]} not allowed in context${context.typ == EnumToken.AtRuleNodeType ? ` '@${context.nam}'` : context.typ == EnumToken.StyleSheetNodeType ? ` 'stylesheet'` : ''}`} : isValid ? (node.typ == EnumToken.KeyframesAtRuleNodeType ? validateAtRuleKeyframes(node) : validateAtRule(node, options, context)) : {
             valid: SyntaxValidationResult.Drop,
             node,
             syntax: '@' + node.nam,
             error: '@' + node.nam + ' not allowed here'};
         if (valid.valid == SyntaxValidationResult.Drop) {
+            let message = '';
+            for (const token of tokens) {
+                message += renderToken(token, { minify: false });
+            }
             errors.push({
                 action: 'drop',
-                message: valid.error + ' - "' + tokens.reduce((acc, curr) => acc + renderToken(curr, { minify: false }), '') + '"',
+                message: valid.error + ' - "' + message + '"',
                 node,
                 // @ts-ignore
                 location: { src, ...(map.get(valid.node) ?? location) }
@@ -795,13 +1591,17 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
             node.typ = EnumToken.InvalidAtRuleTokenType;
         }
         else {
-            node.val = node.tokens.reduce((acc, curr) => acc + renderToken(curr, {
-                minify: false,
-                convertColor: false,
-                removeComments: true
-            }), '');
+            node.val = '';
+            for (const token of node.tokens) {
+                node.val += renderToken(token, {
+                    minify: false,
+                    convertColor: false,
+                    removeComments: true
+                });
+            }
         }
         context.chi.push(node);
+        stats.nodesCount++;
         Object.defineProperties(node, {
             parent: { ...definedPropertySettings, value: context },
             validSyntax: { ...definedPropertySettings, value: valid.valid == SyntaxValidationResult.Valid }
@@ -899,16 +1699,23 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
                 value: tokens.slice()
             });
             loc = location;
-            if (options.sourcemap) {
-                node.loc = loc;
-            }
-            // @ts-ignore
+            Object.defineProperty(node, 'loc', {
+                ...definedPropertySettings,
+                value: loc,
+                enumerable: options.sourcemap !== false
+            });
             context.chi.push(node);
             Object.defineProperty(node, 'parent', { ...definedPropertySettings, value: context });
             // @ts-ignore
-            const valid = options.validation == ValidationLevel.None ? {
+            const skipValidate = (options.validation & ValidationLevel.Selector) == 0;
+            const isAllowed = skipValidate || isNodeAllowedInContext(node, context);
+            // @ts-ignore
+            const valid = skipValidate ? {
                 valid: SyntaxValidationResult.Valid,
                 error: null
+            } : !isAllowed ? {
+                valid: SyntaxValidationResult.Drop,
+                error: `${EnumToken[context.typ]}: child ${EnumToken[node.typ]} not allowed in context${context.typ == EnumToken.AtRuleNodeType ? ` '@${context.nam}'` : context.typ == EnumToken.StyleSheetNodeType ? ` 'stylesheet'` : ''}`
             } : ruleType == EnumToken.KeyFramesRuleNodeType ? validateKeyframeSelector(tokens) : validateSelector(tokens, options, context);
             if (valid.valid != SyntaxValidationResult.Valid) {
                 // @ts-ignore
@@ -1018,11 +1825,13 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
                         nam,
                         val: []
                     };
-                    if (options.sourcemap) {
-                        node.loc = location;
-                        node.loc.end = { ...map.get(delim).end };
-                    }
+                    Object.defineProperty(node, 'loc', {
+                        ...definedPropertySettings,
+                        value: location,
+                        enumerable: options.sourcemap !== false
+                    });
                     context.chi.push(node);
+                    stats.nodesCount++;
                 }
                 return null;
             }
@@ -1046,22 +1855,31 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
                 nam,
                 val: value
             };
-            if (options.sourcemap) {
-                node.loc = location;
-                node.loc.end = { ...map.get(delim).end };
-            }
+            Object.defineProperty(node, 'loc', {
+                ...definedPropertySettings,
+                value: location,
+                enumerable: options.sourcemap !== false
+            });
+            node.loc.end = { ...map.get(delim).end };
             // do not allow declarations in style sheets
             if (context.typ == EnumToken.StyleSheetNodeType && options.lenient) {
-                // @ts-ignore
-                node.typ = EnumToken.InvalidDeclarationNodeType;
+                Object.assign(node, { typ: EnumToken.InvalidDeclarationNodeType });
                 context.chi.push(node);
+                stats.nodesCount++;
                 return null;
             }
             const result = parseDeclarationNode(node, errors, location);
             Object.defineProperty(result, 'parent', { ...definedPropertySettings, value: context });
             if (result != null) {
-                if (options.validation == ValidationLevel.All) {
-                    const valid = evaluateSyntax(result, options);
+                if (options.validation & ValidationLevel.Declaration) {
+                    const isAllowed = isNodeAllowedInContext(node, context);
+                    // @ts-ignore
+                    const valid = !isAllowed ? {
+                        valid: SyntaxValidationResult.Drop,
+                        error: `${EnumToken[node.typ]} not allowed in context${context.typ == EnumToken.AtRuleNodeType ? ` '@${context.nam}'` : context.typ == EnumToken.StyleSheetNodeType ? ` 'stylesheet'` : ''}`,
+                        node,
+                        syntax: null
+                    } : evaluateSyntax(result, context, options);
                     Object.defineProperty(result, 'validSyntax', {
                         ...definedPropertySettings,
                         value: valid.valid == SyntaxValidationResult.Valid
@@ -1077,11 +1895,11 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
                         if (!options.lenient) {
                             return null;
                         }
-                        // @ts-ignore
-                        node.typ = EnumToken.InvalidDeclarationNodeType;
+                        Object.assign(node, { typ: EnumToken.InvalidDeclarationNodeType });
                     }
                 }
                 context.chi.push(result);
+                stats.nodesCount++;
             }
             return null;
         }
@@ -1093,7 +1911,6 @@ function parseNode(results, context, options, errors, src, map, rawTokens) {
  * @param atRule
  */
 function parseAtRulePrelude(tokens, atRule) {
-    // @ts-ignore
     for (const { value, parent } of walkValues(tokens, null, null, true)) {
         if (value.typ == EnumToken.CommentTokenType ||
             value.typ == EnumToken.WhitespaceTokenType ||
@@ -1129,16 +1946,14 @@ function parseAtRulePrelude(tokens, atRule) {
         }
         if (atRule.val == 'page' && value.typ == EnumToken.PseudoClassTokenType) {
             if ([':left', ':right', ':first', ':blank'].includes(value.val)) {
-                // @ts-ignore
-                value.typ = EnumToken.PseudoPageTokenType;
+                Object.assign(value, { typ: EnumToken.PseudoPageTokenType });
             }
         }
         if (atRule.val == 'layer') {
             if (parent == null && value.typ == EnumToken.LiteralTokenType) {
                 if (value.val.charAt(0) == '.') {
                     if (isIdent(value.val.slice(1))) {
-                        // @ts-ignore
-                        value.typ = EnumToken.ClassSelectorTokenType;
+                        Object.assign(value, { typ: EnumToken.ClassSelectorTokenType });
                     }
                 }
             }
@@ -1147,8 +1962,7 @@ function parseAtRulePrelude(tokens, atRule) {
         if (value.typ == EnumToken.IdenTokenType) {
             if (parent == null && mediaTypes.some((t) => {
                 if (val === t) {
-                    // @ts-ignore
-                    value.typ = EnumToken.MediaFeatureTokenType;
+                    Object.assign(value, { typ: EnumToken.MediaFeatureTokenType });
                     return true;
                 }
                 return false;
@@ -1156,18 +1970,15 @@ function parseAtRulePrelude(tokens, atRule) {
                 continue;
             }
             if (value.typ == EnumToken.IdenTokenType && 'and' === val) {
-                // @ts-ignore
-                value.typ = EnumToken.MediaFeatureAndTokenType;
+                Object.assign(value, { typ: EnumToken.MediaFeatureAndTokenType });
                 continue;
             }
             if (value.typ == EnumToken.IdenTokenType && 'or' === val) {
-                // @ts-ignore
-                value.typ = EnumToken.MediaFeatureOrTokenType;
+                Object.assign(value, { typ: EnumToken.MediaFeatureOrTokenType });
                 continue;
             }
             if (value.typ == EnumToken.IdenTokenType &&
                 ['not', 'only'].some((t) => val === t)) {
-                // @ts-ignore
                 const array = parent?.chi ?? tokens;
                 const startIndex = array.indexOf(value);
                 let index = startIndex + 1;
@@ -1212,12 +2023,15 @@ function parseAtRulePrelude(tokens, atRule) {
                 if (value.chi[i].typ == EnumToken.CommentTokenType || value.chi[i].typ == EnumToken.WhitespaceTokenType) {
                     continue;
                 }
-                if (value.chi[i].typ == EnumToken.LiteralTokenType && value.chi[i].val.startsWith(':') && isDimension(value.chi[i].val.slice(1))) {
-                    value.chi.splice(i, 1, {
-                        typ: EnumToken.ColonTokenType,
-                    }, Object.assign(value.chi[i], parseDimension(value.chi[i].val.slice(1))));
-                    i--;
-                    continue;
+                if (value.chi[i].typ == EnumToken.LiteralTokenType && value.chi[i].val.startsWith(':')) {
+                    const dimension = parseDimension(value.chi[i].val.slice(1));
+                    if (dimension != null) {
+                        value.chi.splice(i, 1, {
+                            typ: EnumToken.ColonTokenType,
+                        }, Object.assign(value.chi[i], dimension));
+                        i--;
+                        continue;
+                    }
                 }
                 if (nameIndex != -1 && value.chi[i].typ == EnumToken.PseudoClassTokenType) {
                     value.chi.splice(i, 1, {
@@ -1244,11 +2058,10 @@ function parseAtRulePrelude(tokens, atRule) {
                     const val = value.chi.splice(valueIndex, 1)[0];
                     const node = value.chi.splice(nameIndex, 1)[0];
                     // 'background'
-                    // @ts-ignore
                     if (node.typ == EnumToken.ColorTokenType && node.kin == ColorType.DPSYS) {
+                        Object.assign(node, { typ: EnumToken.IdenTokenType });
                         // @ts-ignore
                         delete node.kin;
-                        node.typ = EnumToken.IdenTokenType;
                     }
                     while (value.chi[0]?.typ == EnumToken.WhitespaceTokenType) {
                         value.chi.shift();
@@ -1282,6 +2095,7 @@ async function parseDeclarations(declaration) {
     return doParse(tokenize({
         stream: `.x{${declaration}}`,
         buffer: '',
+        offset: 0,
         position: { ind: 0, lin: 1, col: 1 },
         currentPosition: { ind: -1, lin: 1, col: 0 }
     }), { setParent: false, minify: false, validation: false }).then(result => {
@@ -1303,43 +2117,35 @@ function parseSelector(tokens) {
         }
         if (parent == null) {
             if (value.typ == EnumToken.GtTokenType) {
-                // @ts-ignore
-                value.typ = EnumToken.ChildCombinatorTokenType;
+                Object.assign(value, { typ: EnumToken.ChildCombinatorTokenType });
             }
             else if (value.typ == EnumToken.LiteralTokenType) {
                 if (value.val.charAt(0) == '&') {
-                    // @ts-ignore
-                    value.typ = EnumToken.NestingSelectorTokenType;
+                    Object.assign(value, { typ: EnumToken.NestingSelectorTokenType });
                     // @ts-ignore
                     delete value.val;
                 }
                 else if (value.val.charAt(0) == '.') {
                     if (!isIdent(value.val.slice(1))) {
-                        // @ts-ignore
-                        value.typ = EnumToken.InvalidClassSelectorTokenType;
+                        Object.assign(value, { typ: EnumToken.InvalidClassSelectorTokenType });
                     }
                     else {
-                        // @ts-ignore
-                        value.typ = EnumToken.ClassSelectorTokenType;
+                        Object.assign(value, { typ: EnumToken.ClassSelectorTokenType });
                     }
                 }
                 if (['*', '>', '+', '~'].includes(value.val)) {
                     switch (value.val) {
                         case '*':
-                            // @ts-ignore
-                            value.typ = EnumToken.UniversalSelectorTokenType;
+                            Object.assign(value, { typ: EnumToken.UniversalSelectorTokenType });
                             break;
                         case '>':
-                            // @ts-ignore
-                            value.typ = EnumToken.ChildCombinatorTokenType;
+                            Object.assign(value, { typ: EnumToken.ChildCombinatorTokenType });
                             break;
                         case '+':
-                            // @ts-ignore
-                            value.typ = EnumToken.NextSiblingCombinatorTokenType;
+                            Object.assign(value, { typ: EnumToken.NextSiblingCombinatorTokenType });
                             break;
                         case '~':
-                            // @ts-ignore
-                            value.typ = EnumToken.SubsequentSiblingCombinatorTokenType;
+                            Object.assign(value, { typ: EnumToken.SubsequentSiblingCombinatorTokenType });
                             break;
                     }
                     // @ts-ignore
@@ -1352,12 +2158,10 @@ function parseSelector(tokens) {
                         if (!isIdent(value.val.slice(1))) {
                             continue;
                         }
-                        // @ts-ignore
-                        value.typ = EnumToken.HashTokenType;
+                        Object.assign(value, { typ: EnumToken.HashTokenType });
                     }
                     else {
-                        // @ts-ignore
-                        value.typ = EnumToken.IdenTokenType;
+                        Object.assign(value, { typ: EnumToken.IdenTokenType });
                     }
                     // @ts-ignore
                     delete value.kin;
@@ -1412,6 +2216,7 @@ function parseString(src, options = { location: false }) {
     const parseInfo = {
         stream: src,
         buffer: '',
+        offset: 0,
         position: { ind: 0, lin: 1, col: 1 },
         currentPosition: { ind: -1, lin: 1, col: 0 }
     };
@@ -1420,15 +2225,17 @@ function parseString(src, options = { location: false }) {
             return acc;
         }
         const token = getTokenType(t.token, t.hint);
-        if (options.location) {
-            Object.assign(token, { loc: t.sta });
-        }
+        Object.defineProperty(token, 'loc', {
+            ...definedPropertySettings,
+            value: { sta: t.sta },
+            enumerable: options.location !== false
+        });
         acc.push(token);
         return acc;
     }, []));
 }
 /**
- * get token type from a string
+ * get the token type from a string
  * @param val
  * @param hint
  */
@@ -1464,7 +2271,7 @@ function getTokenType(val, hint) {
         case '>':
             return { typ: EnumToken.GtTokenType };
     }
-    if (isPseudo(val)) {
+    if (val.charAt(0) == ':' && isPseudo(val)) {
         return val.endsWith('(') ? {
             typ: EnumToken.PseudoClassFuncTokenType,
             val: val.slice(0, -1),
@@ -1481,13 +2288,13 @@ function getTokenType(val, hint) {
                     val
                 });
     }
-    if (isAtKeyword(val)) {
+    if (val.charAt(0) == '@' && isAtKeyword(val)) {
         return {
             typ: EnumToken.AtRuleTokenType,
             val: val.slice(1)
         };
     }
-    if (isFunction(val)) {
+    if (val.endsWith('(') && isFunction(val)) {
         val = val.slice(0, -1);
         if (val == 'url') {
             return {
@@ -1535,14 +2342,9 @@ function getTokenType(val, hint) {
             val: +val.slice(0, -1)
         };
     }
-    if (isFlex(val)) {
-        return {
-            typ: EnumToken.FlexTokenType,
-            val: +val.slice(0, -2)
-        };
-    }
-    if (isDimension(val)) {
-        return parseDimension(val);
+    const dimension = parseDimension(val);
+    if (dimension != null) {
+        return dimension;
     }
     const v = val.toLowerCase();
     if (v == 'currentcolor' || v == 'transparent' || v in COLORS_NAMES) {
@@ -1572,6 +2374,12 @@ function getTokenType(val, hint) {
             val
         };
     }
+    if (val.charAt(0) == '.' && isIdent(val.slice(1))) {
+        return {
+            typ: EnumToken.ClassSelectorTokenType,
+            val
+        };
+    }
     if (val.charAt(0) == '#' && isHexColor(val)) {
         return {
             typ: EnumToken.ColorTokenType,
@@ -1619,6 +2427,55 @@ function getTokenType(val, hint) {
 function parseTokens(tokens, options = {}) {
     for (let i = 0; i < tokens.length; i++) {
         const t = tokens[i];
+        if (t.typ == EnumToken.IdenTokenType && t.val == 'from' && i > 0) {
+            const left = [];
+            const right = [];
+            let foundLeft = 0;
+            let foundRight = 0;
+            let k = i;
+            let l = i;
+            while (k > 0) {
+                if (tokens[k - 1].typ == EnumToken.CommentTokenType || tokens[k - 1].typ == EnumToken.WhitespaceTokenType) {
+                    left.push(tokens[--k]);
+                    continue;
+                }
+                if (tokens[k - 1].typ == EnumToken.IdenTokenType || tokens[k - 1].typ == EnumToken.DashedIdenTokenType) {
+                    foundLeft++;
+                    left.push(tokens[--k]);
+                    continue;
+                }
+                break;
+            }
+            while (++l < tokens.length) {
+                if (tokens[l].typ == EnumToken.CommentTokenType || tokens[l].typ == EnumToken.WhitespaceTokenType) {
+                    right.push(tokens[l]);
+                    continue;
+                }
+                if (tokens[l].typ == EnumToken.IdenTokenType || tokens[l].typ == EnumToken.StringTokenType) {
+                    foundRight++;
+                    right.push(tokens[l]);
+                    continue;
+                }
+                break;
+            }
+            if (foundLeft > 0 && foundRight == 1) {
+                while (left?.[0].typ == EnumToken.WhitespaceTokenType) {
+                    left.shift();
+                }
+                while (left.at(-1)?.typ == EnumToken.WhitespaceTokenType) {
+                    left.pop();
+                }
+                tokens.splice(k, l - k + 1, {
+                    typ: EnumToken.ComposesSelectorNodeType,
+                    l: left,
+                    r: right.reduce((a, b) => {
+                        return a == null ? b : b.typ == EnumToken.IdenTokenType || b.typ == EnumToken.StringTokenType ? b : a;
+                    }, null)
+                });
+                i = k;
+                continue;
+            }
+        }
         if (t.typ == EnumToken.WhitespaceTokenType && ((i == 0 ||
             i + 1 == tokens.length ||
             [EnumToken.CommaTokenType, EnumToken.GteTokenType, EnumToken.LteTokenType, EnumToken.ColumnCombinatorTokenType].includes(tokens[i + 1].typ)) ||
@@ -1902,4 +2759,4 @@ function parseTokens(tokens, options = {}) {
     return tokens;
 }
 
-export { doParse, getTokenType, parseAtRulePrelude, parseDeclarations, parseSelector, parseString, parseTokens, replaceToken, urlTokenMatcher };
+export { doParse, generateScopedName, getKeyName, getTokenType, parseAtRulePrelude, parseDeclarations, parseSelector, parseString, parseTokens, replaceToken, urlTokenMatcher };