@tbela99/css-parser 1.3.4 → 1.4.0

package/dist/lib/parser/tokenize.js

@@ -138,23 +138,27 @@ function* consumeString(quoteStr, buffer, parseInfo) {
     }
 }
 function match(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;
@@ -570,6 +574,7 @@ async function* tokenizeStream(input) {
     const parseInfo = {
         stream: '',
         buffer: '',
+        offset: 0,
         position: { ind: 0, lin: 1, col: 1 },
         currentPosition: { ind: -1, lin: 1, col: 0 }
     };
@@ -577,7 +582,17 @@ async function* tokenizeStream(input) {
     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(parseInfo, done);
         if (done) {
             break;

package/dist/lib/parser/utils/declaration.js

@@ -20,6 +20,60 @@ function parseDeclarationNode(node, errors, location) {
         });
         return null;
     }
+    if ('composes' == node.nam.toLowerCase()) {
+        let left = [];
+        let right = [];
+        let current = 0;
+        let hasFrom = 0;
+        for (; current < node.val.length; current++) {
+            if (EnumToken.WhitespaceTokenType == node.val[current].typ || EnumToken.CommentTokenType == node.val[current].typ) {
+                if (!hasFrom) {
+                    left.push(node.val[current]);
+                }
+                else {
+                    right.push(node.val[current]);
+                }
+                continue;
+            }
+            if (EnumToken.IdenTokenType == node.val[current].typ || EnumToken.DashedIdenTokenType == node.val[current].typ || EnumToken.StringTokenType == node.val[current].typ) {
+                if (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: EnumToken.ComposesSelectorNodeType,
+                    l: left,
+                    r: null
+                });
+            }
+            else {
+                node.val.splice(0, current, {
+                    typ: EnumToken.ComposesSelectorNodeType,
+                    l: left,
+                    r: right.reduce((a, b) => {
+                        return a == null ? b : b.typ == EnumToken.WhitespaceTokenType || b.typ == EnumToken.CommentTokenType ? a : b;
+                    }, null)
+                });
+            }
+        }
+    }
     for (const { value: val, parent } of walkValues(node.val, node)) {
         if (val.typ == EnumToken.AttrTokenType && val.chi.every((t) => [EnumToken.IdenTokenType, EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ))) {
             // @ts-ignore

package/dist/lib/parser/utils/hash.js

@@ -0,0 +1,86 @@
+// 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);
+}
+
+export { hash, hashAlgorithms, hashId };

package/dist/lib/parser/utils/text.js

@@ -0,0 +1,8 @@
+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());
+}
+
+export { camelize, dasherize };

package/dist/lib/renderer/render.js

@@ -29,9 +29,10 @@ function update(position, str) {
  * 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 = {
@@ -68,12 +69,23 @@ function doRender(data, options = {}) {
     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 && [EnumToken.StyleSheetNodeType, EnumToken.AtRuleNodeType, 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 && [EnumToken.StyleSheetNodeType, EnumToken.AtRuleNodeType, EnumToken.RuleNodeType].includes(data.typ) && 'chi' in data ? expand(data) : data, options, sourcemap, position, errors, function reducer(acc, curr) {
             if (curr.typ == EnumToken.CommentTokenType && options.removeComments) {
                 if (!options.preserveLicense || !curr.val.startsWith('/*!')) {
                     return acc;
@@ -232,6 +244,11 @@ function renderAstNode(data, options, sourcemap, position, errors, reducer, cach
                 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 EnumToken.CssVariableTokenType:
+        case EnumToken.CssVariableImportTokenType:
+            return `@value ${data.nam}:${options.indent}${filterValues((options.minify ? data.val : data.val)).reduce(reducer, '').trim()};`;
+        case 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 EnumToken.InvalidDeclarationNodeType:
         case EnumToken.InvalidRuleTokenType:
         case EnumToken.InvalidAtRuleTokenType:
@@ -386,6 +403,8 @@ function renderToken(token, options = {}, cache = Object.create(null), reducer,
         case EnumToken.NameSpaceAttributeTokenType:
             return (token.l == null ? '' : renderToken(token.l, options, cache, reducer, errors)) + '|' +
                 renderToken(token.r, options, cache, reducer, errors);
+        case 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 EnumToken.BlockStartTokenType:
             return '{';
         case EnumToken.BlockEndTokenType:

package/dist/lib/syntax/color/relativecolor.js

@@ -77,10 +77,7 @@ function computeComponentValue(expr, converted, values) {
             // normalize hue
             for (const k of walkValues([object.h])) {
                 if (k.value.typ == EnumToken.AngleTokenType && k.value.unit == 'deg') {
-                    // @ts-ignore
                     k.value.typ = EnumToken.NumberTokenType;
-                    // @ts-ignore
-                    delete k.value.unit;
                 }
             }
         }

package/dist/lib/validation/config.json.js

@@ -753,7 +753,7 @@ var declarations = {
 		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>"
@@ -1981,6 +1981,12 @@ var declarations = {
 	},
 	"white-space-trim": {
 		syntax: "none | discard-before || discard-after || discard-inner"
+	},
+	composes: {
+		syntax: "<composes-selector>#"
+	},
+	"composes-selector": {
+		syntax: "<ident>+ [from [global&&<string>]]?"
 	}
 };
 var functions = {
@@ -2006,7 +2012,7 @@ var functions = {
 		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>? )"
@@ -2359,7 +2365,7 @@ var syntaxes = {
 		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: "[ '~' | '|' | '^' | '$' | '*' ]? '='"
@@ -2367,6 +2373,9 @@ var syntaxes = {
 	"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>? ']'"
 	},
@@ -2580,6 +2589,9 @@ var syntaxes = {
 	"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>"
 	},

package/dist/lib/validation/syntax.js

@@ -11,6 +11,7 @@ import '../renderer/sourcemap/lib/encode.js';
 import { getSyntaxConfig, getParsedSyntax, getSyntax } from './config.js';
 import './syntaxes/complex-selector.js';
 import { funcLike, colorsFunc } from '../syntax/color/utils/constants.js';
+import '../../types.js';
 import '../ast/features/type.js';
 
 const config = getSyntaxConfig();
@@ -615,6 +616,7 @@ function matchPropertyType(syntax, context, options) {
         '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'
@@ -645,6 +647,9 @@ function matchPropertyType(syntax, context, options) {
         return { ...result, context };
     }
     switch (syntax.val) {
+        case 'composes-selector':
+            success = token.typ == EnumToken.ComposesSelectorNodeType;
+            break;
         case 'bg-position': {
             let val;
             let keyworkMatchCount = 0;
@@ -812,7 +817,7 @@ function matchPropertyType(syntax, context, options) {
             }
             break;
         case 'integer':
-            success = (token.typ == EnumToken.NumberTokenType && Number.isInteger(+token.val) && token.val > 0) || (token.typ == EnumToken.FunctionTokenType && mathFuncs.includes(token.val.toLowerCase()) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val)));
+            success = (token.typ == EnumToken.NumberTokenType && /^[+-]?\d+$/.test(token.val.toString())) || (token.typ == EnumToken.FunctionTokenType && mathFuncs.includes(token.val.toLowerCase()) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val)));
             if ('range' in syntax) {
                 success = success && +token.val >= +syntax.range[0] && +token.val <= +syntax.range[1];
             }

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

@@ -20,8 +20,7 @@ function validateCompoundSelector(tokens, root, options) {
             node: root,
             // @ts-ignore
             syntax: null,
-            error: 'expected selector',
-            tokens
+            error: 'expected selector'
         };
     }
     tokens = tokens.slice();

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

@@ -19,15 +19,12 @@ function validateRelativeSelectorList(tokens, root, options) {
             return result;
         }
     }
+    // @ts-ignore
     return {
         valid: SyntaxValidationResult.Valid,
-        matches: [],
-        // @ts-ignore
         node: root,
-        // @ts-ignore
         syntax: null,
-        error: '',
-        tokens
+        error: ''
     };
 }
 

package/dist/node.js

@@ -1,5 +1,6 @@
 import process from 'node:process';
-export { ColorType, EnumToken, ValidationLevel } from './lib/ast/types.js';
+import { ModuleScopeEnumOptions } from './lib/ast/types.js';
+export { ColorType, EnumToken, ModuleCaseTransformEnum, ValidationLevel } from './lib/ast/types.js';
 export { minify } from './lib/ast/minify.js';
 export { WalkerEvent, WalkerOptionEnum, walk, walkValues } from './lib/ast/walk.js';
 export { expand } from './lib/ast/expand.js';
@@ -21,34 +22,47 @@ import { resolve, matchUrl, dirname } from './lib/fs/resolve.js';
 import { Readable } from 'node:stream';
 import { createReadStream } from 'node:fs';
 import { readFile, lstat } from 'node:fs/promises';
+import { ResponseType } from './types.js';
 export { FeatureWalkMode } from './lib/ast/features/type.js';
 
 /**
  * load file or url as stream
  * @param url
  * @param currentFile
- * @param asStream
+ * @param responseType
  * @throws Error file not found
  *
  * @private
  */
-async function load(url, currentFile = '.', asStream = false) {
+async function load(url, currentFile = '.', responseType = false) {
     const resolved = resolve(url, currentFile);
+    if (typeof responseType == 'boolean') {
+        responseType = responseType ? ResponseType.ReadableStream : ResponseType.Text;
+    }
     if (matchUrl.test(resolved.absolute)) {
         return fetch(resolved.absolute).then(async (response) => {
             if (!response.ok) {
                 throw new Error(`${response.status} ${response.statusText} ${response.url}`);
             }
-            return asStream ? response.body : await response.text();
+            if (responseType == ResponseType.ArrayBuffer) {
+                return response.arrayBuffer();
+            }
+            return responseType == ResponseType.ReadableStream ? response.body : await response.text();
         });
     }
     try {
-        if (!asStream) {
+        if (responseType == ResponseType.Text) {
             return readFile(resolved.absolute, 'utf-8');
         }
+        if (responseType == ResponseType.ArrayBuffer) {
+            return readFile(resolved.absolute).then(buffer => buffer.buffer);
+        }
         const stats = await lstat(resolved.absolute);
         if (stats.isFile()) {
-            return Readable.toWeb(createReadStream(resolved.absolute, { encoding: 'utf-8', highWaterMark: 64 * 1024 }));
+            return Readable.toWeb(createReadStream(resolved.absolute, {
+                encoding: 'utf-8',
+                highWaterMark: 64 * 1024
+            }));
         }
     }
     catch (error) {
@@ -60,6 +74,7 @@ async function load(url, currentFile = '.', asStream = false) {
  * render the ast tree
  * @param data
  * @param options
+ * @param mapping
  *
  * Example:
  *
@@ -84,8 +99,8 @@ async function load(url, currentFile = '.', asStream = false) {
  * // }
  * ```
  */
-function render(data, options = {}) {
-    return doRender(data, Object.assign(options, { resolve, dirname, cwd: options.cwd ?? process.cwd() }));
+function render(data, options = {}, mapping) {
+    return doRender(data, Object.assign(options, { resolve, dirname, cwd: options.cwd ?? process.cwd() }), mapping);
 }
 /**
  * parse css file
@@ -160,9 +175,18 @@ async function parse(stream, options = {}) {
     return doParse(stream instanceof ReadableStream ? tokenizeStream(stream) : tokenize({
         stream,
         buffer: '',
+        offset: 0,
         position: { ind: 0, lin: 1, col: 1 },
         currentPosition: { ind: -1, lin: 1, col: 0 }
-    }), Object.assign(options, { load, resolve, dirname, cwd: options.cwd ?? process.cwd() }));
+    }), Object.assign(options, {
+        load,
+        resolve,
+        dirname,
+        cwd: options.cwd ?? process.cwd()
+    })).then(result => {
+        const { revMapping, ...res } = result;
+        return res;
+    });
 }
 /**
  * transform css file
@@ -237,8 +261,21 @@ async function transform(css, options = {}) {
     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 & ModuleScopeEnumOptions.ICSS)) {
+            mapping = parseResult.mapping;
+            importMapping = parseResult.importMapping;
+        }
+        else if (typeof options.module == 'object' && typeof options.module.scoped == 'number' && (options.module.scoped & 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,
@@ -253,4 +290,4 @@ async function transform(css, options = {}) {
     });
 }
 
-export { dirname, load, parse, parseFile, render, resolve, transform, transformFile };
+export { ModuleScopeEnumOptions, ResponseType, dirname, load, parse, parseFile, render, resolve, transform, transformFile };

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * response type
+ */
+export declare enum ResponseType {
+    /**
+     * return text
+     */
+    Text = 0,
+    /**
+     * return a readable stream
+     */
+    ReadableStream = 1,
+    /**
+     * return an arraybuffer
+     */
+    ArrayBuffer = 2
+}

package/dist/types.js

@@ -0,0 +1,20 @@
+/**
+ * response type
+ */
+var ResponseType;
+(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";
+})(ResponseType || (ResponseType = {}));
+
+export { ResponseType };