@tbela99/css-parser 1.3.4 → 1.4.0

package/dist/index-umd-web.js

@@ -433,6 +433,23 @@
          * invalid declaration node type
          */
         EnumToken[EnumToken["InvalidDeclarationNodeType"] = 94] = "InvalidDeclarationNodeType";
+        /* css module nodes */
+        /**
+         * composes token node type
+         */
+        EnumToken[EnumToken["ComposesSelectorNodeType"] = 95] = "ComposesSelectorNodeType";
+        /**
+         * css variable token type
+         */
+        EnumToken[EnumToken["CssVariableTokenType"] = 96] = "CssVariableTokenType";
+        /**
+         * css variable import token type
+         */
+        EnumToken[EnumToken["CssVariableImportTokenType"] = 97] = "CssVariableImportTokenType";
+        /**
+         * css variable declaration map token type
+         */
+        EnumToken[EnumToken["CssVariableDeclarationMapTokenType"] = 98] = "CssVariableDeclarationMapTokenType";
         /* aliases */
         /**
          * alias for time token type
@@ -549,7 +566,7 @@
     exports.ColorType = void 0;
     (function (ColorType) {
         /**
-         * system colors
+         * deprecated system colors
          */
         ColorType[ColorType["SYS"] = 0] = "SYS";
         /**
@@ -557,7 +574,7 @@
          */
         ColorType[ColorType["DPSYS"] = 1] = "DPSYS";
         /**
-         * colors as literals
+         * named colors
          */
         ColorType[ColorType["LIT"] = 2] = "LIT";
         /**
@@ -657,6 +674,48 @@
          */
         ColorType[ColorType["DEVICE_CMYK"] = 7] = "DEVICE_CMYK";
     })(exports.ColorType || (exports.ColorType = {}));
+    exports.ModuleCaseTransformEnum = void 0;
+    (function (ModuleCaseTransformEnum) {
+        /**
+         * export class names as-is
+         */
+        ModuleCaseTransformEnum[ModuleCaseTransformEnum["IgnoreCase"] = 1] = "IgnoreCase";
+        /**
+         * transform mapping key name to camel case
+         */
+        ModuleCaseTransformEnum[ModuleCaseTransformEnum["CamelCase"] = 2] = "CamelCase";
+        /**
+         * transform class names and mapping key name to camel case
+         */
+        ModuleCaseTransformEnum[ModuleCaseTransformEnum["CamelCaseOnly"] = 4] = "CamelCaseOnly";
+        /**
+         * transform mapping key name to dash case
+         */
+        ModuleCaseTransformEnum[ModuleCaseTransformEnum["DashCase"] = 8] = "DashCase";
+        /**
+         * transform class names and mapping key name to dash case
+         */
+        ModuleCaseTransformEnum[ModuleCaseTransformEnum["DashCaseOnly"] = 16] = "DashCaseOnly";
+    })(exports.ModuleCaseTransformEnum || (exports.ModuleCaseTransformEnum = {}));
+    exports.ModuleScopeEnumOptions = void 0;
+    (function (ModuleScopeEnumOptions) {
+        /**
+         * use the global scope
+         */
+        ModuleScopeEnumOptions[ModuleScopeEnumOptions["Global"] = 32] = "Global";
+        /**
+         * use the local scope
+         */
+        ModuleScopeEnumOptions[ModuleScopeEnumOptions["Local"] = 64] = "Local";
+        /**
+         * do not allow selector without an id or class
+         */
+        ModuleScopeEnumOptions[ModuleScopeEnumOptions["Pure"] = 128] = "Pure";
+        /**
+         * export using ICSS module format
+         */
+        ModuleScopeEnumOptions[ModuleScopeEnumOptions["ICSS"] = 256] = "ICSS";
+    })(exports.ModuleScopeEnumOptions || (exports.ModuleScopeEnumOptions = {}));
 
     // from https://www.w3.org/TR/css-color-4/multiply-matrices.js
     /**
@@ -3915,10 +3974,7 @@
                 // normalize hue
                 for (const k of walkValues([object.h])) {
                     if (k.value.typ == exports.EnumToken.AngleTokenType && k.value.unit == 'deg') {
-                        // @ts-ignore
                         k.value.typ = exports.EnumToken.NumberTokenType;
-                        // @ts-ignore
-                        delete k.value.unit;
                     }
                 }
             }
@@ -4121,7 +4177,7 @@
     function identity() {
         return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
     }
-    function normalize(point) {
+    function normalize$1(point) {
         const [x, y, z] = point;
         const norm = Math.sqrt(point[0] * point[0] + point[1] * point[1] + point[2] * point[2]);
         return norm === 0 ? [0, 0, 0] : [x / norm, y / norm, z / norm];
@@ -4248,7 +4304,7 @@
         ];
         // Compute scale
         const scaleX = Math.hypot(...row0);
-        const row0Norm = normalize(row0);
+        const row0Norm = normalize$1(row0);
         const skewXY = dot(row0Norm, row1);
         const row1Proj = [
             row1[0] - skewXY * row0Norm[0],
@@ -4256,7 +4312,7 @@
             row1[2] - skewXY * row0Norm[2]
         ];
         const scaleY = Math.hypot(...row1Proj);
-        const row1Norm = normalize(row1Proj);
+        const row1Norm = normalize$1(row1Proj);
         const skewXZ = dot(row0Norm, row2);
         const skewYZ = dot(row1Norm, row2);
         const row2Proj = [
@@ -4264,7 +4320,7 @@
             row2[1] - skewXZ * row0Norm[1] - skewYZ * row1Norm[1],
             row2[2] - skewXZ * row0Norm[2] - skewYZ * row1Norm[2]
         ];
-        const row2Norm = normalize(row2Proj);
+        const row2Norm = normalize$1(row2Proj);
         const determinant = row0[0] * cross[0] + row0[1] * cross[1] + row0[2] * cross[2];
         const scaleZ = Math.hypot(...row2Proj) * (determinant < 0 ? -1 : 1);
         // Build rotation matrix from orthonormalized vectors
@@ -6530,6 +6586,9 @@
     	},
     	animation: {
     		shorthand: "animation",
+    		separator: {
+    			typ: "Comma"
+    		},
     		pattern: "animation-name animation-duration animation-timing-function animation-delay animation-iteration-count animation-direction animation-fill-mode animation-play-state animation-timeline",
     		"default": [
     			"1",
@@ -7480,6 +7539,60 @@
             });
             return null;
         }
+        if ('composes' == node.nam.toLowerCase()) {
+            let left = [];
+            let right = [];
+            let current = 0;
+            let hasFrom = 0;
+            for (; current < node.val.length; current++) {
+                if (exports.EnumToken.WhitespaceTokenType == node.val[current].typ || exports.EnumToken.CommentTokenType == node.val[current].typ) {
+                    if (!hasFrom) {
+                        left.push(node.val[current]);
+                    }
+                    else {
+                        right.push(node.val[current]);
+                    }
+                    continue;
+                }
+                if (exports.EnumToken.IdenTokenType == node.val[current].typ || exports.EnumToken.DashedIdenTokenType == node.val[current].typ || exports.EnumToken.StringTokenType == node.val[current].typ) {
+                    if (exports.EnumToken.IdenTokenType == node.val[current].typ) {
+                        if ('from' == node.val[current].val) {
+                            if (hasFrom) {
+                                return null;
+                            }
+                            hasFrom++;
+                            continue;
+                        }
+                    }
+                    if (hasFrom) {
+                        right.push(node.val[current]);
+                    }
+                    else {
+                        left.push(node.val[current]);
+                    }
+                    continue;
+                }
+                break;
+            }
+            if (hasFrom <= 1 && current > 0) {
+                if (hasFrom == 0) {
+                    node.val.splice(0, left.length, {
+                        typ: exports.EnumToken.ComposesSelectorNodeType,
+                        l: left,
+                        r: null
+                    });
+                }
+                else {
+                    node.val.splice(0, current, {
+                        typ: exports.EnumToken.ComposesSelectorNodeType,
+                        l: left,
+                        r: right.reduce((a, b) => {
+                            return a == null ? b : b.typ == exports.EnumToken.WhitespaceTokenType || b.typ == exports.EnumToken.CommentTokenType ? a : b;
+                        }, null)
+                    });
+                }
+            }
+        }
         for (const { value: val, parent } of walkValues(node.val, node)) {
             if (val.typ == exports.EnumToken.AttrTokenType && val.chi.every((t) => [exports.EnumToken.IdenTokenType, exports.EnumToken.WhitespaceTokenType, exports.EnumToken.CommentTokenType].includes(t.typ))) {
                 // @ts-ignore
@@ -7526,6 +7639,13 @@
         return buffer.length > 0 ? result + buffer : result;
     }
 
+    function dasherize(value) {
+        return value.replace(/([A-Z])/g, (all, one) => `-${one.toLowerCase()}`);
+    }
+    function camelize(value) {
+        return value.replace(/-([a-z])/g, (all, one) => one.toUpperCase());
+    }
+
     // from https://github.com/Rich-Harris/vlq/tree/master
     // credit: Rich Harris
     const integer_to_char = {};
@@ -7672,9 +7792,10 @@
      * render ast
      * @param data
      * @param options
+     * @param mapping
      * @private
      */
-    function doRender(data, options = {}) {
+    function doRender(data, options = {}, mapping) {
         const minify = options.minify ?? true;
         const beautify = options.beautify ?? !minify;
         options = {
@@ -7711,12 +7832,23 @@
         const errors = [];
         const sourcemap = options.sourcemap ? new SourceMap : null;
         const cache = Object.create(null);
+        const position = {
+            ind: 0,
+            lin: 1,
+            col: 1
+        };
+        let code = '';
+        if (mapping != null) {
+            if (mapping.importMapping != null) {
+                for (const [key, value] of Object.entries(mapping.importMapping)) {
+                    code += `:import("${key}")${options.indent}{${options.newLine}${Object.entries(value).reduce((acc, [k, v]) => acc + (acc.length > 0 ? options.newLine : '') + `${options.indent}${v}:${options.indent}${k};`, '')}${options.newLine}}${options.newLine}`;
+                }
+            }
+            code += `:export${options.indent}{${options.newLine}${Object.entries(mapping.mapping).reduce((acc, [k, v]) => acc + (acc.length > 0 ? options.newLine : '') + `${options.indent}${k}:${options.indent}${v};`, '')}${options.newLine}}${options.newLine}`;
+            update(position, code);
+        }
         const result = {
-            code: renderAstNode(options.expandNestingRules && [exports.EnumToken.StyleSheetNodeType, exports.EnumToken.AtRuleNodeType, exports.EnumToken.RuleNodeType].includes(data.typ) && 'chi' in data ? expand(data) : data, options, sourcemap, {
-                ind: 0,
-                lin: 1,
-                col: 1
-            }, errors, function reducer(acc, curr) {
+            code: code + renderAstNode(options.expandNestingRules && [exports.EnumToken.StyleSheetNodeType, exports.EnumToken.AtRuleNodeType, exports.EnumToken.RuleNodeType].includes(data.typ) && 'chi' in data ? expand(data) : data, options, sourcemap, position, errors, function reducer(acc, curr) {
                 if (curr.typ == exports.EnumToken.CommentTokenType && options.removeComments) {
                     if (!options.preserveLicense || !curr.val.startsWith('/*!')) {
                         return acc;
@@ -7875,6 +8007,11 @@
                     return `@${data.nam}${data.val === '' ? '' : options.indent || ' '}${data.val}${options.indent}{${options.newLine}` + (children === '' ? '' : indentSub + children + options.newLine) + indent + `}`;
                 }
                 return data.sel + `${options.indent}{${options.newLine}` + (children === '' ? '' : indentSub + children + options.newLine) + indent + `}`;
+            case exports.EnumToken.CssVariableTokenType:
+            case exports.EnumToken.CssVariableImportTokenType:
+                return `@value ${data.nam}:${options.indent}${filterValues((options.minify ? data.val : data.val)).reduce(reducer, '').trim()};`;
+            case exports.EnumToken.CssVariableDeclarationMapTokenType:
+                return `@value ${filterValues(data.vars).reduce((acc, curr) => acc + renderToken(curr), '').trim()} from ${filterValues(data.from).reduce((acc, curr) => acc + renderToken(curr), '').trim()};`;
             case exports.EnumToken.InvalidDeclarationNodeType:
             case exports.EnumToken.InvalidRuleTokenType:
             case exports.EnumToken.InvalidAtRuleTokenType:
@@ -8029,6 +8166,8 @@
             case exports.EnumToken.NameSpaceAttributeTokenType:
                 return (token.l == null ? '' : renderToken(token.l, options, cache, reducer, errors)) + '|' +
                     renderToken(token.r, options, cache, reducer, errors);
+            case exports.EnumToken.ComposesSelectorNodeType:
+                return token.l.reduce((acc, curr) => acc + renderToken(curr, options, cache), '') + (token.r == null ? '' : ' from ' + renderToken(token.r, options, cache, reducer, errors));
             case exports.EnumToken.BlockStartTokenType:
                 return '{';
             case exports.EnumToken.BlockEndTokenType:
@@ -8399,23 +8538,27 @@
         }
     }
     function match$1(parseInfo, input) {
-        return parseInfo.stream.slice(parseInfo.currentPosition.ind + 1, parseInfo.currentPosition.ind + input.length + 1) == input;
+        const position = parseInfo.currentPosition.ind - parseInfo.offset;
+        return parseInfo.stream.slice(position + 1, position + input.length + 1) == input;
     }
     function peek(parseInfo, count = 1) {
         if (count == 1) {
-            return parseInfo.stream.charAt(parseInfo.currentPosition.ind + 1);
+            return parseInfo.stream.charAt(parseInfo.currentPosition.ind - parseInfo.offset + 1);
         }
-        return parseInfo.stream.slice(parseInfo.currentPosition.ind + 1, parseInfo.currentPosition.ind + count + 1);
+        const position = parseInfo.currentPosition.ind - parseInfo.offset;
+        return parseInfo.stream.slice(position + 1, position + count + 1);
     }
     function prev(parseInfo) {
-        return parseInfo.stream.charAt(parseInfo.currentPosition.ind - 1);
+        return parseInfo.offset == parseInfo.currentPosition.ind ? parseInfo.buffer.slice(-1) : parseInfo.stream.charAt(parseInfo.currentPosition.ind - parseInfo.offset - 1);
     }
     function next(parseInfo, count = 1) {
         let char = '';
         let chr = '';
-        while (count-- && (chr = parseInfo.stream.charAt(parseInfo.currentPosition.ind + 1))) {
+        let position = parseInfo.currentPosition.ind - parseInfo.offset;
+        while (count-- && (chr = parseInfo.stream.charAt(position + 1))) {
             char += chr;
-            const codepoint = parseInfo.stream.charCodeAt(++parseInfo.currentPosition.ind);
+            const codepoint = parseInfo.stream.charCodeAt(++position);
+            ++parseInfo.currentPosition.ind;
             if (isNewLine(codepoint)) {
                 parseInfo.currentPosition.lin++;
                 parseInfo.currentPosition.col = 0;
@@ -8831,6 +8974,7 @@
         const parseInfo = {
             stream: '',
             buffer: '',
+            offset: 0,
             position: { ind: 0, lin: 1, col: 1 },
             currentPosition: { ind: -1, lin: 1, col: 0 }
         };
@@ -8838,7 +8982,17 @@
         const reader = input.getReader();
         while (true) {
             const { done, value } = await reader.read();
-            parseInfo.stream += ArrayBuffer.isView(value) ? decoder.decode(value, { stream: true }) : value;
+            const stream = ArrayBuffer.isView(value) ? decoder.decode(value, { stream: true }) : value;
+            if (!done) {
+                if (parseInfo.stream.length > 2) {
+                    parseInfo.stream = parseInfo.stream.slice(-2) + stream;
+                    parseInfo.offset = parseInfo.currentPosition.ind - 1;
+                }
+                else {
+                    parseInfo.stream = stream;
+                    parseInfo.offset = Math.max(0, parseInfo.currentPosition.ind);
+                }
+            }
             yield* tokenize$1(parseInfo, done);
             if (done) {
                 break;
@@ -9601,7 +9755,7 @@
     		syntax: "[ <counter-name> <integer>? ]+ | none"
     	},
     	cursor: {
-    		syntax: "[ [ <url> [ <x> <y> ]? , ]* [ auto | default | none | context-menu | help | pointer | progress | wait | cell | crosshair | text | vertical-text | alias | copy | move | no-drop | not-allowed | e-resize | n-resize | ne-resize | nw-resize | s-resize | se-resize | sw-resize | w-resize | ew-resize | ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | all-scroll | zoom-in | zoom-out | grab | grabbing ] ] [ [ <url> [ <x> <y> ]? , ]* [ auto | default | none | context-menu | help | pointer | progress | wait | cell | crosshair | text | vertical-text | alias | copy | move | no-drop | not-allowed | e-resize | n-resize | ne-resize | nw-resize | s-resize | se-resize | sw-resize | w-resize | ew-resize | ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | all-scroll | zoom-in | zoom-out | grab | grabbing | hand | -webkit-grab | -webkit-grabbing | -webkit-zoom-in | -webkit-zoom-out | -moz-grab | -moz-grabbing | -moz-zoom-in | -moz-zoom-out ] ]"
+    		syntax: "[ [ <url> [ <x> <y> ]? , ]* <cursor-predefined> ] [ [ <url> [ <x> <y> ]? , ]* [ auto | default | none | context-menu | help | pointer | progress | wait | cell | crosshair | text | vertical-text | alias | copy | move | no-drop | not-allowed | e-resize | n-resize | ne-resize | nw-resize | s-resize | se-resize | sw-resize | w-resize | ew-resize | ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | all-scroll | zoom-in | zoom-out | grab | grabbing | hand | -webkit-grab | -webkit-grabbing | -webkit-zoom-in | -webkit-zoom-out | -moz-grab | -moz-grabbing | -moz-zoom-in | -moz-zoom-out ] ]"
     	},
     	cx: {
     		syntax: "<length> | <percentage>"
@@ -10829,6 +10983,12 @@
     	},
     	"white-space-trim": {
     		syntax: "none | discard-before || discard-after || discard-inner"
+    	},
+    	composes: {
+    		syntax: "<composes-selector>#"
+    	},
+    	"composes-selector": {
+    		syntax: "<ident>+ [from [global&&<string>]]?"
     	}
     };
     var functions = {
@@ -10854,7 +11014,7 @@
     		syntax: "atan2( <calc-sum>, <calc-sum> )"
     	},
     	attr: {
-    		syntax: "attr( <attr-name> <type-or-unit>? [, <attr-fallback> ]? )"
+    		syntax: "attr( <attr-name> <attr-type>? , <declaration-value>? )"
     	},
     	blur: {
     		syntax: "blur( <length>? )"
@@ -11207,7 +11367,7 @@
     		syntax: "scroll | fixed | local"
     	},
     	"attr()": {
-    		syntax: "attr( <attr-name> <type-or-unit>? [, <attr-fallback> ]? )"
+    		syntax: "attr( <attr-name> <attr-type>? , <declaration-value>? )"
     	},
     	"attr-matcher": {
     		syntax: "[ '~' | '|' | '^' | '$' | '*' ]? '='"
@@ -11215,6 +11375,9 @@
     	"attr-modifier": {
     		syntax: "i | s"
     	},
+    	"attr-type": {
+    		syntax: "type( <syntax> ) | raw-string | number | <attr-unit>"
+    	},
     	"attribute-selector": {
     		syntax: "'[' <wq-name> ']' | '[' <wq-name> <attr-matcher> [ <string-token> | <ident-token> ] <attr-modifier>? ']'"
     	},
@@ -11428,6 +11591,9 @@
     	"cubic-bezier-easing-function": {
     		syntax: "ease | ease-in | ease-out | ease-in-out | cubic-bezier( <number [0,1]> , <number> , <number [0,1]> , <number> )"
     	},
+    	"cursor-predefined": {
+    		syntax: "auto | default | none | context-menu | help | pointer | progress | wait | cell | crosshair | text | vertical-text | alias | copy | move | no-drop | not-allowed | e-resize | n-resize | ne-resize | nw-resize | s-resize | se-resize | sw-resize | w-resize | ew-resize | ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | all-scroll | zoom-in | zoom-out | grab | grabbing"
+    	},
     	"custom-color-space": {
     		syntax: "<dashed-ident>"
     	},
@@ -14349,8 +14515,7 @@
                 node: root,
                 // @ts-ignore
                 syntax: null,
-                error: 'expected selector',
-                tokens
+                error: 'expected selector'
             };
         }
         tokens = tokens.slice();
@@ -14598,15 +14763,12 @@
                 return result;
             }
         }
+        // @ts-ignore
         return {
             valid: SyntaxValidationResult.Valid,
-            matches: [],
-            // @ts-ignore
             node: root,
-            // @ts-ignore
             syntax: null,
-            error: '',
-            tokens
+            error: ''
         };
     }
 
@@ -15250,6 +15412,7 @@
             'color',
             'integer',
             'bg-position',
+            'composes-selector',
             'length-percentage', 'flex', 'calc-sum', 'color',
             'color-base', 'system-color', 'deprecated-system-color',
             'pseudo-class-selector', 'pseudo-element-selector', 'feature-value-declaration'
@@ -15280,6 +15443,9 @@
             return { ...result, context };
         }
         switch (syntax.val) {
+            case 'composes-selector':
+                success = token.typ == exports.EnumToken.ComposesSelectorNodeType;
+                break;
             case 'bg-position': {
                 let val;
                 let keyworkMatchCount = 0;
@@ -15447,7 +15613,7 @@
                 }
                 break;
             case 'integer':
-                success = (token.typ == exports.EnumToken.NumberTokenType && Number.isInteger(+token.val) && token.val > 0) || (token.typ == exports.EnumToken.FunctionTokenType && mathFuncs.includes(token.val.toLowerCase()) || (token.typ == exports.EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val)));
+                success = (token.typ == exports.EnumToken.NumberTokenType && /^[+-]?\d+$/.test(token.val.toString())) || (token.typ == exports.EnumToken.FunctionTokenType && mathFuncs.includes(token.val.toLowerCase()) || (token.typ == exports.EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val)));
                 if ('range' in syntax) {
                     success = success && +token.val >= +syntax.range[0] && +token.val <= +syntax.range[1];
                 }
@@ -17610,6 +17776,91 @@
         };
     }
 
+    // Alphabet: a-z, A-Z, 0-9, _, -
+    const LOWER = "abcdefghijklmnopqrstuvwxyz";
+    const DIGITS = "0123456789";
+    const FULL_ALPHABET = (LOWER + DIGITS).split(""); // 64 chars
+    const FIRST_ALPHABET = (LOWER).split(""); // 54 chars (no digits)
+    /**
+     * supported hash algorithms
+     */
+    const hashAlgorithms = ['hex', 'base64', 'base64url', 'sha1', 'sha256', 'sha384', 'sha512'];
+    // simple deterministic hash → number
+    function hashCode(str) {
+        let hash = 0;
+        let l = str.length;
+        let i = 0;
+        while (i < l) {
+            hash = (hash * 31 + str.charCodeAt(i++)) >>> 0;
+        }
+        return hash;
+    }
+    /**
+     * generate a hash id
+     * @param input
+     * @param length
+     */
+    function hashId(input, length = 6) {
+        let n = hashCode(input);
+        const chars = [];
+        // First character: must not be a digit
+        chars.push(FIRST_ALPHABET[n % FIRST_ALPHABET.length]);
+        // Remaining characters
+        for (let i = 1; i < length; i++) {
+            n = (n + chars.length + i) % FULL_ALPHABET.length;
+            chars.push(FULL_ALPHABET[n]);
+        }
+        return chars.join("");
+    }
+    /**
+     * convert input to hex
+     * @param input
+     */
+    function toHex(input) {
+        let result = '';
+        if (input instanceof ArrayBuffer || ArrayBuffer.isView(input)) {
+            for (const byte of Array.from(new Uint8Array(input))) {
+                result += byte.toString(16).padStart(2, '0');
+            }
+        }
+        else {
+            for (const char of String(input)) {
+                result += char.charCodeAt(0).toString(16).padStart(2, '0');
+            }
+        }
+        return result;
+    }
+    /**
+     * generate a hash
+     * @param input
+     * @param length
+     * @param algo
+     */
+    async function hash(input, length = 6, algo) {
+        let result;
+        if (algo != null) {
+            switch (algo) {
+                case 'hex':
+                    return toHex(input).slice(0, length);
+                case 'base64':
+                case 'base64url':
+                    result = btoa(input);
+                    if (algo == 'base64url') {
+                        result = result.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+                    }
+                    return result.slice(0, length);
+                case 'sha1':
+                case 'sha256':
+                case 'sha384':
+                case 'sha512':
+                    return toHex(await crypto.subtle.digest(algo.replace('sha', 'SHA-'), new TextEncoder().encode(input))).slice(0, length);
+                default:
+                    throw new Error(`Unsupported hash algorithm: ${algo}`);
+            }
+        }
+        return hashId(input, length);
+    }
+
     const urlTokenMatcher = /^(["']?)[a-zA-Z0-9_/.-][a-zA-Z0-9_/:.#?-]+(\1)$/;
     const trimWhiteSpace = [exports.EnumToken.CommentTokenType, exports.EnumToken.GtTokenType, exports.EnumToken.GteTokenType, exports.EnumToken.LtTokenType, exports.EnumToken.LteTokenType, exports.EnumToken.ColumnCombinatorTokenType];
     const BadTokensTypes = [
@@ -17628,9 +17879,12 @@
     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) {
         for (const node of (Array.isArray(replacement) ? replacement : [replacement])) {
             if ('parent' in value && value.parent != node.parent) {
@@ -17658,11 +17912,129 @@
             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 exports.ModuleCaseTransformEnum.CamelCase:
+            case exports.ModuleCaseTransformEnum.CamelCaseOnly:
+                return camelize(key);
+            case exports.ModuleCaseTransformEnum.DashCase:
+            case exports.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 = {}) {
@@ -17694,6 +18066,9 @@
         if (typeof options.validation == 'boolean') {
             options.validation = options.validation ? exports.ValidationLevel.All : exports.ValidationLevel.None;
         }
+        if (options.module) {
+            options.expandNestingRules = true;
+        }
         if (options.expandNestingRules) {
             options.nestingRules = false;
         }
@@ -17959,6 +18334,7 @@
                     const root = await doParse(stream instanceof ReadableStream ? tokenizeStream(stream) : tokenize$1({
                         stream,
                         buffer: '',
+                        offset: 0,
                         position: { ind: 0, lin: 1, col: 1 },
                         currentPosition: { ind: -1, lin: 1, col: 0 }
                     }), Object.assign({}, options, {
@@ -18018,7 +18394,7 @@
                         }
                         let node = result.node;
                         for (const handler of handlers) {
-                            callable = typeof handler == 'function' ? handler : handler[normalizeVisitorKeyName(node.typ == exports.EnumToken.DeclarationNodeType || node.typ == exports.EnumToken.AtRuleNodeType ? node.nam : node.val)];
+                            callable = typeof handler == 'function' ? handler : handler[camelize(node.typ == exports.EnumToken.DeclarationNodeType || node.typ == exports.EnumToken.AtRuleNodeType ? node.nam : node.val)];
                             if (callable == null) {
                                 continue;
                             }
@@ -18153,12 +18529,9 @@
                 }
             }
         }
-        const endTime = performance.now();
-        if (options.signal != null) {
-            options.signal.removeEventListener('abort', reject);
-        }
         stats.bytesIn += stats.importedBytesIn;
-        return {
+        let endTime = performance.now();
+        const result = {
             ast,
             errors,
             stats: {
@@ -18168,6 +18541,503 @@
                 total: `${(endTime - startTime).toFixed(2)}ms`
             }
         };
+        if (options.module) {
+            const moduleSettings = {
+                hashLength: 5,
+                filePath: '',
+                scoped: exports.ModuleScopeEnumOptions.Local,
+                naming: exports.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 & exports.ModuleCaseTransformEnum.CamelCase) {
+                    moduleSettings.naming = exports.ModuleCaseTransformEnum.CamelCase;
+                }
+                else if (options.module & exports.ModuleCaseTransformEnum.CamelCaseOnly) {
+                    moduleSettings.naming = exports.ModuleCaseTransformEnum.CamelCaseOnly;
+                }
+                else if (options.module & exports.ModuleCaseTransformEnum.DashCase) {
+                    moduleSettings.naming = exports.ModuleCaseTransformEnum.DashCase;
+                }
+                else if (options.module & exports.ModuleCaseTransformEnum.DashCaseOnly) {
+                    moduleSettings.naming = exports.ModuleCaseTransformEnum.DashCaseOnly;
+                }
+                if (options.module & exports.ModuleScopeEnumOptions.Global) {
+                    moduleSettings.scoped = exports.ModuleScopeEnumOptions.Global;
+                }
+                if (options.module & exports.ModuleScopeEnumOptions.Pure) {
+                    // @ts-ignore
+                    moduleSettings.scoped |= exports.ModuleScopeEnumOptions.Pure;
+                }
+                if (options.module & exports.ModuleScopeEnumOptions.ICSS) {
+                    // @ts-ignore
+                    moduleSettings.scoped |= exports.ModuleScopeEnumOptions.ICSS;
+                }
+            }
+            if (typeof moduleSettings.scoped == 'boolean') {
+                moduleSettings.scoped = moduleSettings.scoped ? exports.ModuleScopeEnumOptions.Local : exports.ModuleScopeEnumOptions.Global;
+            }
+            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 == exports.EnumToken.CssVariableImportTokenType) {
+                    const url = node.val.find(t => t.typ == exports.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$1({
+                        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 == exports.EnumToken.CssVariableDeclarationMapTokenType) {
+                    const from = node.from.find(t => t.typ == exports.EnumToken.IdenTokenType || isIdentColor(t));
+                    if (!(from.val in cssVariablesMap)) {
+                        errors.push({
+                            node,
+                            message: `could not resolve @value import from '${from.val}'`,
+                            action: 'drop'
+                        });
+                    }
+                    else {
+                        for (const token of node.vars) {
+                            if (token.typ == exports.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];
+                            }
+                        }
+                    }
+                    parent.chi.splice(parent.chi.indexOf(node), 1);
+                    continue;
+                }
+                if (node.typ == exports.EnumToken.CssVariableTokenType) {
+                    if (parent?.typ == exports.EnumToken.StyleSheetNodeType) {
+                        if (result.cssModuleVariables == null) {
+                            result.cssModuleVariables = {};
+                        }
+                        result.cssModuleVariables[node.nam] = node;
+                    }
+                    parent.chi.splice(parent.chi.indexOf(node), 1);
+                    continue;
+                }
+                if (node.typ == exports.EnumToken.DeclarationNodeType) {
+                    if (node.nam.startsWith('--')) {
+                        if (!(node.nam in namesMapping)) {
+                            let result = (moduleSettings.scoped & exports.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 & exports.ModuleCaseTransformEnum.DashCaseOnly || moduleSettings.naming & exports.ModuleCaseTransformEnum.CamelCaseOnly ? getKeyName(value, moduleSettings.naming) : value);
+                            revMapping[node.nam] = node.nam;
+                        }
+                        node.nam = mapping[node.nam];
+                    }
+                    if ('composes' == node.nam.toLowerCase()) {
+                        const tokens = [];
+                        let isValid = true;
+                        for (const token of node.val) {
+                            if (token.typ == exports.EnumToken.ComposesSelectorNodeType) {
+                                if (!(token.r == null || token.r.typ == exports.EnumToken.StringTokenType || token.r.typ == exports.EnumToken.IdenTokenType)) {
+                                    errors.push({
+                                        action: 'drop',
+                                        message: `composes '${exports.EnumToken[token.r.typ]}' is not supported`,
+                                        node
+                                    });
+                                    isValid = false;
+                                    break;
+                                }
+                                tokens.push(token);
+                            }
+                        }
+                        // find parent rule
+                        let parentRule = node.parent;
+                        while (parentRule != null && parentRule.typ != exports.EnumToken.RuleNodeType) {
+                            parentRule = parentRule.parent;
+                        }
+                        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;
+                        }
+                        for (const token of tokens) {
+                            // composes: a b c;
+                            if (token.r == null) {
+                                for (const rule of token.l) {
+                                    if (rule.typ == exports.EnumToken.WhitespaceTokenType || rule.typ == exports.EnumToken.CommentTokenType) {
+                                        continue;
+                                    }
+                                    if (!(rule.val in mapping)) {
+                                        let result = (moduleSettings.scoped & exports.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 == exports.EnumToken.DashedIdenTokenType ? '--' : '') + (moduleSettings.naming & exports.ModuleCaseTransformEnum.DashCaseOnly || moduleSettings.naming & exports.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 == exports.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 == exports.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$1({
+                                    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 == exports.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 != exports.EnumToken.IdenTokenType && iden.typ != exports.EnumToken.DashedIdenTokenType) {
+                                                        continue;
+                                                    }
+                                                    if (!(iden.val in root.mapping)) {
+                                                        const result = (moduleSettings.scoped & exports.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 & exports.ModuleCaseTransformEnum.DashCaseOnly || moduleSettings.naming & exports.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 == exports.EnumToken.IdenTokenType) {
+                                // global
+                                if (parentRule != null) {
+                                    if ('global' == token.r.val.toLowerCase()) {
+                                        for (const tk of parentRule.tokens) {
+                                            if (tk.typ == exports.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 == exports.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.typ == exports.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 != exports.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 & exports.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 (node.nam == 'grid-template-areas' || node.nam == 'grid-template') {
+                        for (let i = 0; i < node.val.length; i++) {
+                            if (node.val[i].typ == exports.EnumToken.String) {
+                                const tokens = parseString(node.val[i].val.slice(1, -1), { location: true });
+                                for (const { value } of walkValues(tokens)) {
+                                    if (value.typ == exports.EnumToken.IdenTokenType || value.typ == exports.EnumToken.DashedIdenTokenType) {
+                                        if (value.val in mapping) {
+                                            value.val = mapping[value.val];
+                                        }
+                                        else {
+                                            let result = (moduleSettings.scoped & exports.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);
+                            }
+                        }
+                    }
+                    else if (node.nam == 'animation' || node.nam == 'animation-name') {
+                        for (const { value } of walkValues(node.val, node)) {
+                            if (value.typ == exports.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 & exports.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];
+                            }
+                        }
+                    }
+                    for (const { value, parent } of walkValues(node.val, node)) {
+                        if (value.typ == exports.EnumToken.DashedIdenTokenType) {
+                            if (!(value.val in mapping)) {
+                                const result = (moduleSettings.scoped & exports.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 & exports.ModuleCaseTransformEnum.DashCaseOnly || moduleSettings.naming & exports.ModuleCaseTransformEnum.CamelCaseOnly ? getKeyName(val, moduleSettings.naming) : val);
+                                revMapping[mapping[value.val]] = value.val;
+                            }
+                            value.val = mapping[value.val];
+                        }
+                        else if ((value.typ == exports.EnumToken.IdenTokenType || isIdentColor(value)) && value.val in importedCssVariables) {
+                            replaceToken(parent, value, importedCssVariables[value.val].val);
+                        }
+                    }
+                }
+                else if (node.typ == exports.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 == exports.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 == exports.EnumToken.WhitespaceTokenType || parent.tokens[index]?.typ == exports.EnumToken.DescendantCombinatorTokenType) {
+                                            parent.tokens.splice(index, 1);
+                                        }
+                                        if (val == ':global') {
+                                            for (; index < parent.tokens.length; index++) {
+                                                if (parent.tokens[index].typ == exports.EnumToken.CommaTokenType ||
+                                                    ([exports.EnumToken.PseudoClassFuncTokenType, exports.EnumToken.PseudoClassTokenType].includes(parent.tokens[index].typ) &&
+                                                        [':global', ':local'].includes(parent.tokens[index].val.toLowerCase()))) {
+                                                    break;
+                                                }
+                                                global.add(parent.tokens[index]);
+                                            }
+                                        }
+                                    }
+                                    break;
+                            }
+                        }
+                        else if (value.typ == exports.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 (value.typ == exports.EnumToken.HashTokenType || value.typ == exports.EnumToken.ClassSelectorTokenType) {
+                            hasIdOrClass = true;
+                        }
+                        if (processed.has(value)) {
+                            continue;
+                        }
+                        processed.add(value);
+                        if (value.typ == exports.EnumToken.PseudoClassTokenType) ;
+                        else if (value.typ == exports.EnumToken.PseudoClassFuncTokenType) ;
+                        else {
+                            if (global.has(value)) {
+                                continue;
+                            }
+                            if (value.typ == exports.EnumToken.ClassSelectorTokenType) {
+                                const val = value.val.slice(1);
+                                if (!(val in mapping)) {
+                                    const result = (moduleSettings.scoped & exports.ModuleScopeEnumOptions.Global) ? val : moduleSettings.generateScopedName(val, moduleSettings.filePath, moduleSettings.pattern, moduleSettings.hashLength);
+                                    let value = result instanceof Promise ? await result : result;
+                                    mapping[val] = (moduleSettings.naming & exports.ModuleCaseTransformEnum.DashCaseOnly || moduleSettings.naming & exports.ModuleCaseTransformEnum.CamelCaseOnly ? getKeyName(value, moduleSettings.naming) : value);
+                                    revMapping[mapping[val]] = val;
+                                }
+                                value.val = '.' + mapping[val];
+                            }
+                        }
+                    }
+                    if (moduleSettings.scoped & exports.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 ?? ''}`);
+                        }
+                    }
+                    node.sel = '';
+                    for (const token of node.tokens) {
+                        node.sel += renderToken(token);
+                    }
+                }
+                else if (node.typ == exports.EnumToken.AtRuleNodeType || node.typ == exports.EnumToken.KeyframesAtRuleNodeType) {
+                    const val = node.nam.toLowerCase();
+                    if (node.tokens == null) {
+                        Object.defineProperty(node, 'tokens', {
+                            ...definedPropertySettings,
+                            // @ts-ignore
+                            value: parseAtRulePrelude(parseString(node.val), node)
+                        });
+                    }
+                    if (val == 'property' || val == 'keyframes') {
+                        const prefix = val == 'property' ? '--' : '';
+                        for (const value of node.tokens) {
+                            if ((prefix == '--' && value.typ == exports.EnumToken.DashedIdenTokenType) || (prefix == '' && value.typ == exports.EnumToken.IdenTokenType)) {
+                                if (!(value.val in mapping)) {
+                                    const result = (moduleSettings.scoped & exports.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 & exports.ModuleCaseTransformEnum.DashCaseOnly || moduleSettings.naming & exports.ModuleCaseTransformEnum.CamelCaseOnly ? getKeyName(val, moduleSettings.naming) : val);
+                                    revMapping[mapping[value.val]] = value.val;
+                                }
+                                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 (exports.EnumToken.MediaQueryConditionTokenType == parent.typ && value != parent.l) {
+                                if ((value.typ == exports.EnumToken.IdenTokenType || isIdentColor(value)) && value.val in importedCssVariables) {
+                                    isReplaced = true;
+                                    parent.r.splice(parent.r.indexOf(value), 1, ...importedCssVariables[value.val].val);
+                                }
+                            }
+                        }
+                        if (isReplaced) {
+                            node.val = node.tokens.reduce((a, b) => a + renderToken(b), '');
+                        }
+                    }
+                }
+            }
+            if (moduleSettings.naming != exports.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 & exports.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`;
+        }
+        if (options.signal != null) {
+            options.signal.removeEventListener('abort', reject);
+        }
+        return result;
     }
     function getLastNode(context) {
         let i = context.chi.length;
@@ -18385,6 +19255,147 @@
                     isValid = false;
                 }
             }
+            if (node.nam == 'value') {
+                let i = 0;
+                while (i < tokens.length) {
+                    if (tokens[i].typ == exports.EnumToken.WhitespaceTokenType || tokens[i].typ == exports.EnumToken.CommentTokenType) {
+                        i++;
+                        continue;
+                    }
+                    break;
+                }
+                if (i < tokens.length) {
+                    if (tokens[i].typ == exports.EnumToken.IdenTokenType || isIdentColor(tokens[i])) {
+                        let k = i + 1;
+                        while (k < tokens.length) {
+                            if (tokens[k].typ == exports.EnumToken.WhitespaceTokenType || tokens[k].typ == exports.EnumToken.CommentTokenType) {
+                                k++;
+                                continue;
+                            }
+                            // var or import
+                            if (tokens[k].typ == exports.EnumToken.ColonTokenType) {
+                                let j = k;
+                                while (++j < tokens.length) {
+                                    if (tokens[j].typ != exports.EnumToken.WhitespaceTokenType && tokens[j].typ != exports.EnumToken.CommentTokenType) {
+                                        break;
+                                    }
+                                }
+                                let offset = k + 1;
+                                while (offset < tokens.length && tokens[offset].typ == exports.EnumToken.WhitespaceTokenType) {
+                                    offset++;
+                                }
+                                if (tokens[j].typ == exports.EnumToken.StringTokenType) {
+                                    Object.assign(node, {
+                                        typ: exports.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: exports.EnumToken.CssVariableTokenType,
+                                    nam: tokens[i].val,
+                                    val: tokens.slice(offset)
+                                });
+                                context.chi.push(node);
+                                return null;
+                            }
+                            if (tokens[k].typ == exports.EnumToken.PseudoClassTokenType) {
+                                Object.assign(tokens[k], {
+                                    typ: exports.EnumToken.IdenTokenType,
+                                    val: tokens[k].val.slice(1)
+                                });
+                                Object.assign(node, {
+                                    typ: exports.EnumToken.CssVariableTokenType,
+                                    nam: tokens[i].val,
+                                    val: tokens.slice(k)
+                                });
+                                context.chi.push(node);
+                                return null;
+                            }
+                            if (tokens[k].typ == exports.EnumToken.CommaTokenType) {
+                                let j = i;
+                                while (++j < tokens.length) {
+                                    if (tokens[j].typ == exports.EnumToken.IdenTokenType && tokens[j].val.toLowerCase() == 'from') {
+                                        const vars = tokens.slice(i, j);
+                                        const from = tokens.slice(j + 1);
+                                        let l = 0;
+                                        let expect = exports.EnumToken.IdenTokenType;
+                                        for (; l < vars.length; l++) {
+                                            if (vars[l].typ == exports.EnumToken.WhitespaceTokenType || vars[l].typ == exports.EnumToken.CommentTokenType) {
+                                                continue;
+                                            }
+                                            if (expect == vars[l].typ || (expect == exports.EnumToken.IdenTokenType && isIdentColor(vars[l]))) {
+                                                expect = expect == exports.EnumToken.CommaTokenType ? exports.EnumToken.IdenTokenType : exports.EnumToken.CommaTokenType;
+                                                continue;
+                                            }
+                                            errors.push({
+                                                action: 'drop',
+                                                node: node,
+                                                location: map.get(vars[l]) ?? location,
+                                                message: `expecting '${exports.EnumToken[expect]}' but found ${renderToken(vars[l])}`
+                                            });
+                                            return null;
+                                        }
+                                        l = 0;
+                                        expect = exports.EnumToken.IdenTokenType;
+                                        for (; l < from.length; l++) {
+                                            if (from[l].typ == exports.EnumToken.WhitespaceTokenType || from[l].typ == exports.EnumToken.CommentTokenType) {
+                                                continue;
+                                            }
+                                            if (expect == from[l].typ || isIdentColor(from[l])) {
+                                                while (++l < from.length) {
+                                                    if (from[l].typ == exports.EnumToken.WhitespaceTokenType || from[l].typ == exports.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: exports.EnumToken.CssVariableDeclarationMapTokenType,
+                                            vars,
+                                            from
+                                        });
+                                        context.chi.push(node);
+                                        return null;
+                                    }
+                                }
+                            }
+                            k++;
+                        }
+                        Object.assign(node, {
+                            typ: exports.EnumToken.CssVariableTokenType,
+                            nam: tokens[i].val,
+                            val: tokens.slice(k)
+                        });
+                        context.chi.push(node);
+                        return null;
+                    }
+                }
+            }
             // @ts-ignore
             const skipValidate = (options.validation & exports.ValidationLevel.AtRule) == 0;
             const isAllowed = skipValidate || isNodeAllowedInContext(node, context);
@@ -18923,6 +19934,7 @@
         return doParse(tokenize$1({
             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 => {
@@ -19043,6 +20055,7 @@
         const parseInfo = {
             stream: src,
             buffer: '',
+            offset: 0,
             position: { ind: 0, lin: 1, col: 1 },
             currentPosition: { ind: -1, lin: 1, col: 0 }
         };
@@ -19168,12 +20181,10 @@
                 val: +val.slice(0, -1)
             };
         }
-        // if (isDimension(val)) {
         const dimension = parseDimension(val);
         if (dimension != null) {
             return dimension;
         }
-        // }
         const v = val.toLowerCase();
         if (v == 'currentcolor' || v == 'transparent' || v in COLORS_NAMES) {
             return {
@@ -19202,6 +20213,12 @@
                 val
             };
         }
+        if (val.charAt(0) == '.' && isIdent(val.slice(1))) {
+            return {
+                typ: exports.EnumToken.ClassSelectorTokenType,
+                val
+            };
+        }
         if (val.charAt(0) == '#' && isHexColor(val)) {
             return {
                 typ: exports.EnumToken.ColorTokenType,
@@ -19249,6 +20266,55 @@
     function parseTokens(tokens, options = {}) {
         for (let i = 0; i < tokens.length; i++) {
             const t = tokens[i];
+            if (t.typ == exports.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 == exports.EnumToken.CommentTokenType || tokens[k - 1].typ == exports.EnumToken.WhitespaceTokenType) {
+                        left.push(tokens[--k]);
+                        continue;
+                    }
+                    if (tokens[k - 1].typ == exports.EnumToken.IdenTokenType || tokens[k - 1].typ == exports.EnumToken.DashedIdenTokenType) {
+                        foundLeft++;
+                        left.push(tokens[--k]);
+                        continue;
+                    }
+                    break;
+                }
+                while (++l < tokens.length) {
+                    if (tokens[l].typ == exports.EnumToken.CommentTokenType || tokens[l].typ == exports.EnumToken.WhitespaceTokenType) {
+                        right.push(tokens[l]);
+                        continue;
+                    }
+                    if (tokens[l].typ == exports.EnumToken.IdenTokenType || tokens[l].typ == exports.EnumToken.StringTokenType) {
+                        foundRight++;
+                        right.push(tokens[l]);
+                        continue;
+                    }
+                    break;
+                }
+                if (foundLeft > 0 && foundRight == 1) {
+                    while (left?.[0].typ == exports.EnumToken.WhitespaceTokenType) {
+                        left.shift();
+                    }
+                    while (left.at(-1)?.typ == exports.EnumToken.WhitespaceTokenType) {
+                        left.pop();
+                    }
+                    tokens.splice(k, l - k + 1, {
+                        typ: exports.EnumToken.ComposesSelectorNodeType,
+                        l: left,
+                        r: right.reduce((a, b) => {
+                            return a == null ? b : b.typ == exports.EnumToken.IdenTokenType || b.typ == exports.EnumToken.StringTokenType ? b : a;
+                        }, null)
+                    });
+                    i = k;
+                    continue;
+                }
+            }
             if (t.typ == exports.EnumToken.WhitespaceTokenType && ((i == 0 ||
                 i + 1 == tokens.length ||
                 [exports.EnumToken.CommaTokenType, exports.EnumToken.GteTokenType, exports.EnumToken.LteTokenType, exports.EnumToken.ColumnCombinatorTokenType].includes(tokens[i + 1].typ)) ||
@@ -19757,7 +20823,6 @@
      * ```
      */
     function* walkValues(values, root = null, filter, reverse) {
-        // const set = new Set<Token>();
         const stack = values.slice();
         const map = new Map;
         let previous = null;
@@ -19791,8 +20856,12 @@
                         continue;
                     }
                     // @ts-ignore
-                    if (option != null && typeof option == 'object' && 'typ' in option) {
-                        map.set(option, map.get(value) ?? root);
+                    if (option != null && typeof option == 'object' && ('typ' in option || Array.isArray(option))) {
+                        const op = Array.isArray(option) ? option : [option];
+                        for (const o of op) {
+                            map.set(o, map.get(value) ?? root);
+                        }
+                        stack[reverse ? 'push' : 'unshift'](...op);
                     }
                 }
             }
@@ -19815,12 +20884,12 @@
                 const values = [];
                 if ('l' in value && value.l != null) {
                     // @ts-ignore
-                    values[reverse ? 'push' : 'unshift'](value.l);
+                    values.push(value.l);
                     // @ts-ignore
                     map.set(value.l, value);
                 }
                 if ('op' in value && typeof value.op == 'object') {
-                    values[reverse ? 'push' : 'unshift'](value.op);
+                    values.push(value.op);
                     // @ts-ignore
                     map.set(value.op, value);
                 }
@@ -19828,14 +20897,14 @@
                     if (Array.isArray(value.r)) {
                         for (const r of value.r) {
                             // @ts-ignore
-                            values[reverse ? 'push' : 'unshift'](r);
+                            values.push(r);
                             // @ts-ignore
                             map.set(r, value);
                         }
                     }
                     else {
                         // @ts-ignore
-                        values[reverse ? 'push' : 'unshift'](value.r);
+                        values.push(value.r);
                         // @ts-ignore
                         map.set(value.r, value);
                     }
@@ -19851,8 +20920,12 @@
                 if (isValid) {
                     option = filter.fn(value, map.get(value), exports.WalkerEvent.Leave);
                     // @ts-ignore
-                    if (option != null && 'typ' in option) {
-                        map.set(option, map.get(value) ?? root);
+                    if (option != null && ('typ' in option || Array.isArray(option))) {
+                        const op = Array.isArray(option) ? option : [option];
+                        for (const o of op) {
+                            map.set(o, map.get(value) ?? root);
+                        }
+                        stack[reverse ? 'push' : 'unshift'](...op);
                     }
                 }
             }
@@ -19863,7 +20936,7 @@
     /**
      * feature walk mode
      *
-     * @internal
+     * @private
      */
     exports.FeatureWalkMode = void 0;
     (function (FeatureWalkMode) {
@@ -20947,9 +22020,12 @@
             });
         }
         add(...declarations) {
+            let name;
             for (const declaration of declarations) {
+                name = declaration.typ != exports.EnumToken.DeclarationNodeType ? null : declaration.nam.toLowerCase();
                 if (declaration.typ != exports.EnumToken.DeclarationNodeType ||
-                    (typeof this.options.removeDuplicateDeclarations === 'string' && this.options.removeDuplicateDeclarations === declaration.nam.toLowerCase()) ||
+                    'composes' === name ||
+                    (typeof this.options.removeDuplicateDeclarations === 'string' && this.options.removeDuplicateDeclarations === name) ||
                     (Array.isArray(this.options.removeDuplicateDeclarations) ? this.options.removeDuplicateDeclarations.includes(declaration.nam) : !this.options.removeDuplicateDeclarations)) {
                     this.declarations.set(Number(Math.random().toString().slice(2)).toString(36), declaration);
                     continue;
@@ -22511,7 +23587,7 @@
                                     continue;
                                 }
                                 else if (node.typ == previous?.typ && [exports.EnumToken.KeyFramesRuleNodeType, exports.EnumToken.RuleNodeType].includes(node.typ)) {
-                                    const intersect = diff(previous, node, reducer, options);
+                                    const intersect = diff$1(previous, node, reducer, options);
                                     if (intersect != null) {
                                         if (intersect.node1.chi.length == 0) {
                                             ast.chi.splice(i--, 1);
@@ -22557,7 +23633,7 @@
                 nodeIndex = i;
             }
             if (recursive && node != null && ('chi' in node)) {
-                if (node.typ == exports.EnumToken.KeyframesAtRuleNodeType || !node.chi.some(n => n.typ == exports.EnumToken.DeclarationNodeType)) {
+                if (node.typ == exports.EnumToken.KeyframesAtRuleNodeType || !node.chi.some((n) => n.typ == exports.EnumToken.DeclarationNodeType)) {
                     if (!(node.typ == exports.EnumToken.AtRuleNodeType && node.nam != 'font-face')) {
                         doMinify(node, options, recursive, errors, nestingContent, context);
                     }
@@ -22990,7 +24066,7 @@
      *
      * @private
      */
-    function diff(n1, n2, reducer, options = {}) {
+    function diff$1(n1, n2, reducer, options = {}) {
         if (!('cache' in options)) {
             options.cache = new WeakMap();
         }
@@ -23388,6 +24464,9 @@
         //
         //     return path;
         // }
+        if (path === '') {
+            return '';
+        }
         let i = 0;
         let parts = [''];
         for (; i < path.length; i++) {
@@ -23412,6 +24491,12 @@
      * @private
      */
     function splitPath(result) {
+        if (result.length == 0) {
+            return { parts: [], i: 0 };
+        }
+        if (result === '/') {
+            return { parts: ['/'], i: 0 };
+        }
         const parts = [''];
         let i = 0;
         for (; i < result.length; i++) {
@@ -23455,6 +24540,21 @@
         }
         cwd ??= '';
         currentDirectory ??= '';
+        if (currentDirectory !== '' && url.startsWith(currentDirectory + '/')) {
+            return {
+                absolute: url,
+                relative: url.slice(currentDirectory.length + 1)
+            };
+        }
+        if (currentDirectory === '' && cwd !== '' && url.startsWith(cwd == '/' ? cwd : cwd + '/')) {
+            cwd = normalize(cwd);
+            const absolute = normalize(url);
+            const prefix = cwd == '/' ? cwd : cwd + '/';
+            return {
+                absolute,
+                relative: absolute.startsWith(prefix) ? absolute.slice(prefix.length) : diff(absolute, cwd)
+            };
+        }
         if (matchUrl.test(currentDirectory)) {
             const path = new URL(url, currentDirectory).href;
             return {
@@ -23469,9 +24569,15 @@
         else if (currentDirectory.charAt(0) == '/') {
             result = dirname(currentDirectory) + '/' + url;
         }
-        let { parts, i } = splitPath(result);
-        const absolute = parts.join('/');
-        const { parts: dirs } = splitPath(cwd ?? currentDirectory);
+        const absolute = normalize(result);
+        return {
+            absolute,
+            relative: absolute === '' ? '' : diff(absolute, cwd ?? currentDirectory),
+        };
+    }
+    function diff(path1, path2) {
+        let { parts } = splitPath(path1);
+        const { parts: dirs } = splitPath(path2);
         for (const p of dirs) {
             if (parts[0] == p) {
                 parts.shift();
@@ -23480,21 +24586,69 @@
                 parts.unshift('..');
             }
         }
-        return {
-            absolute,
-            relative: parts.join('/') + (i < result.length ? result.slice(i) : '')
-        };
+        return parts.join('/');
+    }
+    function normalize(path) {
+        let parts = [];
+        let i = 0;
+        for (; i < path.length; i++) {
+            const chr = path.charAt(i);
+            if (chr == '/') {
+                if (parts.length == 0 || parts[parts.length - 1] !== '') {
+                    parts.push('');
+                }
+            }
+            else if (chr == '?' || chr == '#') {
+                break;
+            }
+            else {
+                parts[parts.length - 1] += chr;
+            }
+        }
+        let k = -1;
+        while (++k < parts.length) {
+            if (parts[k] == '.') {
+                parts.splice(k--, 1);
+            }
+            else if (parts[k] == '..') {
+                parts.splice(k - 1, 2);
+                k -= 2;
+            }
+        }
+        return (path.charAt(0) == '/' ? '/' : '') + parts.join('/');
     }
 
+    /**
+     * response type
+     */
+    exports.ResponseType = void 0;
+    (function (ResponseType) {
+        /**
+         * return text
+         */
+        ResponseType[ResponseType["Text"] = 0] = "Text";
+        /**
+         * return a readable stream
+         */
+        ResponseType[ResponseType["ReadableStream"] = 1] = "ReadableStream";
+        /**
+         * return an arraybuffer
+         */
+        ResponseType[ResponseType["ArrayBuffer"] = 2] = "ArrayBuffer";
+    })(exports.ResponseType || (exports.ResponseType = {}));
+
     /**
      * default file or url loader
      * @param url
      * @param currentFile
      *
-     * @param asStream
+     * @param responseType
      * @private
      */
-    async function load(url, currentFile = '.', asStream = false) {
+    async function load(url, currentFile = '.', responseType = false) {
+        if (typeof responseType == 'boolean') {
+            responseType = responseType ? exports.ResponseType.ReadableStream : exports.ResponseType.Text;
+        }
         let t;
         if (matchUrl.test(url)) {
             t = new URL(url);
@@ -23510,13 +24664,17 @@
             if (!response.ok) {
                 throw new Error(`${response.status} ${response.statusText} ${response.url}`);
             }
-            return asStream ? response.body : await response.text();
+            if (responseType == exports.ResponseType.ArrayBuffer) {
+                return response.arrayBuffer();
+            }
+            return responseType == exports.ResponseType.ReadableStream ? response.body : await response.text();
         });
     }
     /**
      * render the ast tree
      * @param data
      * @param options
+     * @param mapping
      *
      * Example:
      *
@@ -23541,12 +24699,12 @@
      * // }
      * ```
      */
-    function render(data, options = {}) {
+    function render(data, options = {}, mapping) {
         return doRender(data, Object.assign(options, {
             resolve,
             dirname,
             cwd: options.cwd ?? self.location.pathname.endsWith('/') ? self.location.pathname : dirname(self.location.pathname)
-        }));
+        }), mapping);
     }
     /**
      * parse css file
@@ -23606,6 +24764,7 @@
         return doParse(stream instanceof ReadableStream ? tokenizeStream(stream) : tokenize$1({
             stream,
             buffer: '',
+            offset: 0,
             position: { ind: 0, lin: 1, col: 1 },
             currentPosition: { ind: -1, lin: 1, col: 0 }
         }), Object.assign(options, {
@@ -23613,7 +24772,10 @@
             resolve,
             dirname,
             cwd: options.cwd ?? self.location.pathname.endsWith('/') ? self.location.pathname : dirname(self.location.pathname)
-        }));
+        })).then(result => {
+            const { revMapping, ...res } = result;
+            return res;
+        });
     }
     /**
      * transform css file
@@ -23665,8 +24827,21 @@
         options = { minify: true, removeEmpty: true, removeCharset: true, ...options };
         const startTime = performance.now();
         return parse(css, options).then((parseResult) => {
+            let mapping = null;
+            let importMapping = null;
+            if (typeof options.module == 'number' && (options.module & exports.ModuleScopeEnumOptions.ICSS)) {
+                mapping = parseResult.mapping;
+                importMapping = parseResult.importMapping;
+            }
+            else if (typeof options.module == 'object' && typeof options.module.scoped == 'number' && (options.module.scoped & exports.ModuleScopeEnumOptions.ICSS)) {
+                mapping = parseResult.mapping;
+                importMapping = parseResult.importMapping;
+            }
             // ast already expanded by parse
-            const rendered = render(parseResult.ast, { ...options, expandNestingRules: false });
+            const rendered = render(parseResult.ast, {
+                ...options,
+                expandNestingRules: false
+            }, mapping != null ? { mapping, importMapping } : null);
             return {
                 ...parseResult,
                 ...rendered,