@tbela99/css-parser 0.8.0 → 0.9.0

package/dist/lib/parser/parse.js

@@ -1,4 +1,4 @@
-import { isPseudo, isAtKeyword, isFunction, isNumber, isPercentage, isFlex, isDimension, parseDimension, isIdent, isHexColor, isHash, isIdentStart, mathFuncs, isColor, mediaTypes } from '../syntax/syntax.js';
+import { webkitPseudoAliasMap, isIdentStart, isIdent, mathFuncs, isColor, isHexColor, isPseudo, isAtKeyword, isFunction, isNumber, isPercentage, isFlex, isDimension, parseDimension, isHash, mediaTypes } from '../syntax/syntax.js';
 import './utils/config.js';
 import { EnumToken, funcLike, ValidationLevel } from '../ast/types.js';
 import { minify, definedPropertySettings, combinators } from '../ast/minify.js';
@@ -13,6 +13,7 @@ import '../validation/parser/types.js';
 import '../validation/parser/parse.js';
 import { validateSelector } from '../validation/selector.js';
 import { validateAtRule } from '../validation/atrule.js';
+import '../validation/syntaxes/complex-selector.js';
 
 const urlTokenMatcher = /^(["']?)[a-zA-Z0-9_/.-][a-zA-Z0-9_/:.#?-]+(\1)$/;
 const trimWhiteSpace = [EnumToken.CommentTokenType, EnumToken.GtTokenType, EnumToken.GteTokenType, EnumToken.LtTokenType, EnumToken.LteTokenType, EnumToken.ColumnCombinatorTokenType];
@@ -29,51 +30,14 @@ const enumTokenHints = new Set([
     EnumToken.StartMatchTokenType, EnumToken.EndMatchTokenType, EnumToken.IncludeMatchTokenType, EnumToken.DashMatchTokenType, EnumToken.ContainMatchTokenType,
     EnumToken.EOFTokenType
 ]);
-const webkitPseudoAliasMap = {
-    '-webkit-autofill': 'autofill',
-    '-webkit-any': 'is',
-    '-moz-any': 'is',
-    '-webkit-border-after': 'border-block-end',
-    '-webkit-border-after-color': 'border-block-end-color',
-    '-webkit-border-after-style': 'border-block-end-style',
-    '-webkit-border-after-width': 'border-block-end-width',
-    '-webkit-border-before': 'border-block-start',
-    '-webkit-border-before-color': 'border-block-start-color',
-    '-webkit-border-before-style': 'border-block-start-style',
-    '-webkit-border-before-width': 'border-block-start-width',
-    '-webkit-border-end': 'border-inline-end',
-    '-webkit-border-end-color': 'border-inline-end-color',
-    '-webkit-border-end-style': 'border-inline-end-style',
-    '-webkit-border-end-width': 'border-inline-end-width',
-    '-webkit-border-start': 'border-inline-start',
-    '-webkit-border-start-color': 'border-inline-start-color',
-    '-webkit-border-start-style': 'border-inline-start-style',
-    '-webkit-border-start-width': 'border-inline-start-width',
-    '-webkit-box-align': 'align-items',
-    '-webkit-box-direction': 'flex-direction',
-    '-webkit-box-flex': 'flex-grow',
-    '-webkit-box-lines': 'flex-flow',
-    '-webkit-box-ordinal-group': 'order',
-    '-webkit-box-orient': 'flex-direction',
-    '-webkit-box-pack': 'justify-content',
-    '-webkit-column-break-after': 'break-after',
-    '-webkit-column-break-before': 'break-before',
-    '-webkit-column-break-inside': 'break-inside',
-    '-webkit-font-feature-settings': 'font-feature-settings',
-    '-webkit-hyphenate-character': 'hyphenate-character',
-    '-webkit-initial-letter': 'initial-letter',
-    '-webkit-margin-end': 'margin-block-end',
-    '-webkit-margin-start': 'margin-block-start',
-    '-webkit-padding-after': 'padding-block-end',
-    '-webkit-padding-before': 'padding-block-start',
-    '-webkit-padding-end': 'padding-inline-end',
-    '-webkit-padding-start': 'padding-inline-start',
-    '-webkit-min-device-pixel-ratio': 'min-resolution',
-    '-webkit-max-device-pixel-ratio': 'max-resolution'
-};
 function reject(reason) {
     throw new Error(reason ?? 'Parsing aborted');
 }
+/**
+ * parse css string
+ * @param iterator
+ * @param options
+ */
 async function doParse(iterator, options = {}) {
     if (options.signal != null) {
         options.signal.addEventListener('abort', reject);
@@ -95,6 +59,7 @@ async function doParse(iterator, options = {}) {
         setParent: true,
         removePrefix: false,
         validation: true,
+        lenient: true,
         ...options
     };
     if (options.expandNestingRules) {
@@ -133,9 +98,10 @@ async function doParse(iterator, options = {}) {
     }
     const iter = tokenize(iterator);
     let item;
+    const rawTokens = [];
     while (item = iter.next().value) {
         stats.bytesIn = item.bytesIn;
-        //
+        rawTokens.push(item);
         // doParse error
         if (item.hint != null && BadTokensTypes.includes(item.hint)) {
             // bad token
@@ -145,7 +111,8 @@ async function doParse(iterator, options = {}) {
             tokens.push(item);
         }
         if (item.token == ';' || item.token == '{') {
-            let node = await parseNode(tokens, context, stats, options, errors, src, map);
+            let node = await parseNode(tokens, context, stats, options, errors, src, map, rawTokens);
+            rawTokens.length = 0;
             if (node != null) {
                 // @ts-ignore
                 stack.push(node);
@@ -171,7 +138,8 @@ async function doParse(iterator, options = {}) {
             map = new Map;
         }
         else if (item.token == '}') {
-            await parseNode(tokens, context, stats, options, errors, src, map);
+            await parseNode(tokens, context, stats, options, errors, src, map, rawTokens);
+            rawTokens.length = 0;
             const previousNode = stack.pop();
             // @ts-ignore
             context = stack[stack.length - 1] ?? ast;
@@ -194,7 +162,8 @@ async function doParse(iterator, options = {}) {
         }
     }
     if (tokens.length > 0) {
-        await parseNode(tokens, context, stats, options, errors, src, map);
+        await parseNode(tokens, context, stats, options, errors, src, map, rawTokens);
+        rawTokens.length = 0;
         if (context != null && context.typ == EnumToken.InvalidRuleTokenType) {
             const index = context.chi.findIndex(node => node == context);
             if (index > -1) {
@@ -206,6 +175,7 @@ async function doParse(iterator, options = {}) {
         const previousNode = stack.pop();
         // @ts-ignore
         context = stack[stack.length - 1] ?? ast;
+        // remove empty nodes
         // @ts-ignore
         if (options.removeEmpty && previousNode != null && previousNode.chi.length == 0 && context.chi[context.chi.length - 1] == previousNode) {
             // @ts-ignore
@@ -258,33 +228,6 @@ async function doParse(iterator, options = {}) {
             minify(ast, options, true, errors, false);
         }
     }
-    // if (options.setParent) {
-    //
-    //     const nodes: Array<AstRule | AstAtRule | AstRuleStyleSheet> = [ast];
-    //     let node: AstNode;
-    //
-    //     while ((node = nodes.shift()!)) {
-    //
-    //         // @ts-ignore
-    //         if (node.chi.length > 0) {
-    //
-    //             // @ts-ignore
-    //             for (const child of node.chi) {
-    //
-    //                 if (child.parent != node) {
-    //
-    //                     Object.defineProperty(child, 'parent', {...definedPropertySettings, value: node});
-    //                 }
-    //
-    //                 if ('chi' in child && child.chi.length > 0) {
-    //
-    //                     // @ts-ignore
-    //                     nodes.push(<AstRule | AstAtRule>child);
-    //                 }
-    //             }
-    //         }
-    //     }
-    // }
     const endTime = performance.now();
     if (options.signal != null) {
         options.signal.removeEventListener('abort', reject);
@@ -301,7 +244,17 @@ async function doParse(iterator, options = {}) {
         }
     };
 }
-async function parseNode(results, context, stats, options, errors, src, map) {
+function getLastNode(context) {
+    let i = context.chi.length;
+    while (i--) {
+        if ([EnumToken.CommentTokenType, EnumToken.CDOCOMMTokenType, EnumToken.WhitespaceTokenType].includes(context.chi[i].typ)) {
+            continue;
+        }
+        return context.chi[i];
+    }
+    return null;
+}
+async function parseNode(results, context, stats, options, errors, src, map, rawTokens) {
     let tokens = [];
     for (const t of results) {
         const node = getTokenType(t.token, t.hint);
@@ -356,24 +309,6 @@ async function parseNode(results, context, stats, options, errors, src, map) {
     if (tokens[0]?.typ == EnumToken.AtRuleTokenType) {
         const atRule = tokens.shift();
         const position = map.get(atRule);
-        // if (atRule.val == 'charset') {
-        //
-        //     if (context.typ  != EnumToken.StyleSheetNodeType || context.chi.some(t => t.typ != EnumToken.CDOCOMMTokenType && t.typ != EnumToken.CommentNodeType)) {
-        //
-        //         errors.push({
-        //             action: 'drop',
-        //             message: 'doParse: invalid @charset',
-        //             location: {src, ...position}
-        //         });
-        //
-        //         return null;
-        //     }
-        //
-        //     if (options.removeCharset) {
-        //
-        //         return null;
-        //     }
-        // }
         // @ts-ignore
         while ([EnumToken.WhitespaceTokenType].includes(tokens[0]?.typ)) {
             tokens.shift();
@@ -470,8 +405,43 @@ async function parseNode(results, context, stats, options, errors, src, map) {
         // https://www.w3.org/TR/css-nesting-1/#conditionals
         // allowed nesting at-rules
         // there must be a top level rule in the stack
-        if (atRule.val == 'charset' && options.removeCharset) {
-            return null;
+        if (atRule.val == 'charset') {
+            let spaces = 0;
+            // https://developer.mozilla.org/en-US/docs/Web/CSS/@charset
+            for (let k = 1; k < rawTokens.length; k++) {
+                if (rawTokens[k].hint == EnumToken.WhitespaceTokenType) {
+                    spaces += rawTokens[k].len;
+                    continue;
+                }
+                if (rawTokens[k].hint == EnumToken.CommentTokenType) {
+                    continue;
+                }
+                if (rawTokens[k].hint == EnumToken.CDOCOMMTokenType) {
+                    continue;
+                }
+                if (spaces > 1) {
+                    errors.push({
+                        action: 'drop',
+                        message: '@charset must have only one space',
+                        // @ts-ignore
+                        location: { src, ...(map.get(atRule) ?? position) }
+                    });
+                    return null;
+                }
+                if (rawTokens[k].hint != EnumToken.StringTokenType || rawTokens[k].token[0] != '"') {
+                    errors.push({
+                        action: 'drop',
+                        message: '@charset expects a "<charset>"',
+                        // @ts-ignore
+                        location: { src, ...(map.get(atRule) ?? position) }
+                    });
+                    return null;
+                }
+                break;
+            }
+            if (options.removeCharset) {
+                return null;
+            }
         }
         const t = parseAtRulePrelude(parseTokens(tokens, { minify: options.minify }), atRule);
         const raw = t.reduce((acc, curr) => {
@@ -499,11 +469,36 @@ async function parseNode(results, context, stats, options, errors, src, map) {
             node.loc = loc;
         }
         if (options.validation) {
-            const valid = validateAtRule(node, options, context);
+            let isValid = true;
+            if (node.nam == 'else') {
+                const prev = getLastNode(context);
+                if (prev != null && prev.typ == EnumToken.AtRuleNodeType && ['when', 'else'].includes(prev.nam)) {
+                    if (prev.nam == 'else') {
+                        isValid = Array.isArray(prev.tokens) && prev.tokens.length > 0;
+                    }
+                }
+                else {
+                    isValid = false;
+                }
+            }
+            const valid = isValid ? validateAtRule(node, options, context) : {
+                valid: ValidationLevel.Drop,
+                node,
+                syntax: '@' + node.nam,
+                error: '@' + node.nam + ' not allowed here'};
             if (valid.valid == ValidationLevel.Drop) {
+                errors.push({
+                    action: 'drop',
+                    message: valid.error + ' - "' + tokens.reduce((acc, curr) => acc + renderToken(curr, { minify: false }), '') + '"',
+                    // @ts-ignore
+                    location: { src, ...(map.get(valid.node) ?? position) }
+                });
                 // @ts-ignore
                 node.typ = EnumToken.InvalidAtRuleTokenType;
             }
+            else {
+                node.val = node.tokens.reduce((acc, curr) => acc + renderToken(curr, { minify: false, removeComments: true }), '');
+            }
         }
         // @ts-ignore
         context.chi.push(node);
@@ -682,7 +677,24 @@ async function parseNode(results, context, stats, options, errors, src, map) {
             };
             const result = parseDeclarationNode(node, errors, src, position);
             if (result != null) {
-                if (options.validation) ;
+                // if (options.validation) {
+                //
+                //     const valid: ValidationResult = validateDeclaration(result, options, context);
+                //
+                //     console.error({valid});
+                //
+                //     if (valid.valid == ValidationLevel.Drop) {
+                //
+                //         errors.push({
+                //             action: 'drop',
+                //             message: valid.error + ' - "' + tokens.reduce((acc, curr) => acc + renderToken(curr, {minify: false}), '') + '"',
+                //             // @ts-ignore
+                //             location: {src, ...(map.get(valid.node) ?? position)}
+                //         });
+                //
+                //         return null;
+                //     }
+                // }
                 // @ts-ignore
                 context.chi.push(result);
                 Object.defineProperty(result, 'parent', { ...definedPropertySettings, value: context });
@@ -691,6 +703,11 @@ async function parseNode(results, context, stats, options, errors, src, map) {
         }
     }
 }
+/**
+ * parse at-rule prelude
+ * @param tokens
+ * @param atRule
+ */
 function parseAtRulePrelude(tokens, atRule) {
     // @ts-ignore
     for (const { value, parent } of walkValues(tokens, null, null, true)) {
@@ -759,17 +776,18 @@ function parseAtRulePrelude(tokens, atRule) {
                 continue;
             }
         }
-        if (value.typ == EnumToken.ParensTokenType) {
+        if (value.typ == EnumToken.ParensTokenType || (value.typ == EnumToken.FunctionTokenType && ['media', 'supports', 'style', 'scroll-state'].includes(value.val))) {
             // @todo parse range and declarations
             // parseDeclaration(parent.chi);
             let i;
             let nameIndex = -1;
             let valueIndex = -1;
+            const dashedIdent = value.typ == EnumToken.FunctionTokenType && value.val == 'style';
             for (let i = 0; i < value.chi.length; i++) {
                 if (value.chi[i].typ == EnumToken.CommentTokenType || value.chi[i].typ == EnumToken.WhitespaceTokenType) {
                     continue;
                 }
-                if (value.chi[i].typ == EnumToken.IdenTokenType) {
+                if ((dashedIdent && value.chi[i].typ == EnumToken.DashedIdenTokenType) || value.chi[i].typ == EnumToken.IdenTokenType || value.chi[i].typ == EnumToken.FunctionTokenType || value.chi[i].typ == EnumToken.ColorTokenType) {
                     nameIndex = i;
                 }
                 break;
@@ -798,6 +816,13 @@ function parseAtRulePrelude(tokens, atRule) {
                 ].includes(value.chi[valueIndex].typ)) {
                     const val = value.chi.splice(valueIndex, 1)[0];
                     const node = value.chi.splice(nameIndex, 1)[0];
+                    // 'background'
+                    // @ts-ignore
+                    if (node.typ == EnumToken.ColorTokenType && node.kin == 'dpsys') {
+                        // @ts-ignore
+                        delete node.kin;
+                        node.typ = EnumToken.IdenTokenType;
+                    }
                     while (value.chi[0]?.typ == EnumToken.WhitespaceTokenType) {
                         value.chi.shift();
                     }
@@ -815,6 +840,10 @@ function parseAtRulePrelude(tokens, atRule) {
     }
     return tokens;
 }
+/**
+ * parse selector
+ * @param tokens
+ */
 function parseSelector(tokens) {
     for (const { value, previousValue, nextValue, parent } of walkValues(tokens)) {
         if (value.typ == EnumToken.CommentTokenType ||
@@ -958,6 +987,11 @@ function parseSelector(tokens) {
 //
 //     return doParse(`.x{${src}`, options).then((result: ParseResult) => <AstDeclaration[]>(<AstRule>result.ast.chi[0]).chi.filter(t => t.typ == EnumToken.DeclarationNodeType));
 // }
+/**
+ * parse string
+ * @param src
+ * @param options
+ */
 function parseString(src, options = { location: false }) {
     return parseTokens([...tokenize(src)].map(t => {
         const token = getTokenType(t.token, t.hint);
@@ -1039,7 +1073,7 @@ function getTokenType(val, hint) {
                 chi: []
             };
         }
-        if (['linear-gradient', 'radial-gradient', 'repeating-linear-gradient', 'repeating-radial-gradient', 'conic-gradient', 'image', 'image-set', 'element', 'cross-fade'].includes(val)) {
+        if (['linear-gradient', 'radial-gradient', 'repeating-linear-gradient', 'repeating-radial-gradient', 'conic-gradient', 'image', 'image-set', 'element', 'cross-fade', 'paint'].includes(val)) {
             return {
                 typ: EnumToken.ImageFunctionTokenType,
                 val,
@@ -1139,6 +1173,11 @@ function getTokenType(val, hint) {
         val
     };
 }
+/**
+ * parse token list
+ * @param tokens
+ * @param options
+ */
 function parseTokens(tokens, options = {}) {
     for (let i = 0; i < tokens.length; i++) {
         const t = tokens[i];
@@ -1474,4 +1513,4 @@ function parseTokens(tokens, options = {}) {
     return tokens;
 }
 
-export { doParse, parseAtRulePrelude, parseSelector, parseString, parseTokens, urlTokenMatcher };
+export { doParse, parseSelector, parseString, parseTokens, urlTokenMatcher };

package/dist/lib/parser/tokenize.js

@@ -16,7 +16,13 @@ function consumeWhiteSpace(parseInfo) {
     return count;
 }
 function pushToken(token, parseInfo, hint) {
-    const result = { token, hint, position: { ...parseInfo.position }, bytesIn: parseInfo.currentPosition.ind + 1 };
+    const result = {
+        token,
+        len: parseInfo.currentPosition.ind - parseInfo.position.ind,
+        hint,
+        position: { ...parseInfo.position },
+        bytesIn: parseInfo.currentPosition.ind + 1
+    };
     parseInfo.position.ind = parseInfo.currentPosition.ind;
     parseInfo.position.lin = parseInfo.currentPosition.lin;
     parseInfo.position.col = Math.max(parseInfo.currentPosition.col, 1);
@@ -136,6 +142,10 @@ function next(parseInfo, count = 1) {
     }
     return char;
 }
+/**
+ * tokenize css string
+ * @param stream
+ */
 function* tokenize(stream) {
     const parseInfo = {
         stream,
@@ -184,8 +194,10 @@ function* tokenize(stream) {
                             buffer += value;
                         }
                     }
-                    yield pushToken(buffer, parseInfo, EnumToken.BadCommentTokenType);
-                    buffer = '';
+                    if (buffer.length > 0) {
+                        yield pushToken(buffer, parseInfo, EnumToken.BadCommentTokenType);
+                        buffer = '';
+                    }
                 }
                 break;
             case '&':

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

@@ -2,7 +2,7 @@ import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
-import { getNumber, minmax } from './color.js';
+import { minmax, getNumber } from './color.js';
 import { hsl2rgb, hwb2rgb, cmyk2rgb, oklab2rgb, oklch2rgb, lab2rgb, lch2rgb } from './rgb.js';
 import { NAMES_COLORS } from './utils/constants.js';
 import { getComponents } from './utils/components.js';

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

@@ -1,6 +1,6 @@
 import { hwb2hsv } from './hsv.js';
 import { getNumber } from './color.js';
-import { hex2rgb, lab2rgb, lch2rgb, oklab2rgb, oklch2rgb } from './rgb.js';
+import { lch2rgb, lab2rgb, oklch2rgb, oklab2rgb, hex2rgb } from './rgb.js';
 import './utils/constants.js';
 import { getComponents } from './utils/components.js';
 import { EnumToken } from '../../ast/types.js';

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

@@ -1,12 +1,12 @@
 import { hsl2hsv } from './hsv.js';
 import './utils/constants.js';
 import { getComponents } from './utils/components.js';
-import { getNumber, getAngle } from './color.js';
+import { getAngle, getNumber } from './color.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
-import { lab2srgb, lch2srgb, oklab2srgb, oklch2srgb } from './srgb.js';
+import { lch2srgb, lab2srgb, oklch2srgb, oklab2srgb } from './srgb.js';
 import '../sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 

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

@@ -1,7 +1,7 @@
 import { e, k, D50 } from './utils/constants.js';
 import { getComponents } from './utils/components.js';
 import { srgb2xyz, xyzd502srgb } from './xyz.js';
-import { hex2srgb, rgb2srgb, hsl2srgb, hwb2srgb, oklch2srgb } from './srgb.js';
+import { oklch2srgb, hwb2srgb, hsl2srgb, rgb2srgb, hex2srgb } from './srgb.js';
 import { getLCHComponents } from './lch.js';
 import { OKLab_to_XYZ, getOKLABComponents } from './oklab.js';
 import { getNumber } from './color.js';

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

@@ -5,7 +5,7 @@ import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
-import { srgb2lab, xyz2lab, hex2lab, rgb2lab, hsl2lab, hwb2lab, getLABComponents, oklab2lab, oklch2lab } from './lab.js';
+import { srgb2lab, xyz2lab, oklch2lab, oklab2lab, getLABComponents, hwb2lab, hsl2lab, rgb2lab, hex2lab } from './lab.js';
 import '../sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 

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

@@ -1,7 +1,7 @@
 import { multiplyMatrices } from './utils/matrix.js';
 import './utils/constants.js';
 import { getComponents } from './utils/components.js';
-import { srgb2lsrgbvalues, hex2srgb, rgb2srgb, hsl2srgb, hwb2srgb, lab2srgb, lch2srgb, lsrgb2srgbvalues } from './srgb.js';
+import { srgb2lsrgbvalues, lch2srgb, lab2srgb, hwb2srgb, hsl2srgb, rgb2srgb, hex2srgb, lsrgb2srgbvalues } from './srgb.js';
 import { getNumber } from './color.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
@@ -106,7 +106,7 @@ function OKLab_to_sRGB(l, a, b) {
         1.2914855378640917399 * b, 3);
     return lsrgb2srgbvalues(
     /* r: */
-    +4.076741661347994 * L -
+    4.076741661347994 * L -
         3.307711590408193 * M +
         0.230969928729428 * S, 
     /*  g: */

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

@@ -6,7 +6,7 @@ import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { lab2lchvalues } from './lch.js';
-import { srgb2oklab, hex2oklab, rgb2oklab, hsl2oklab, hwb2oklab, lab2oklab, lch2oklab, getOKLABComponents } from './oklab.js';
+import { srgb2oklab, lch2oklab, getOKLABComponents, lab2oklab, hwb2oklab, hsl2oklab, rgb2oklab, hex2oklab } from './oklab.js';
 import '../sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 

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

@@ -1,4 +1,4 @@
-import { xyz2srgb, srgb2lsrgbvalues, lsrgb2srgbvalues } from './srgb.js';
+import { xyz2srgb, lsrgb2srgbvalues, srgb2lsrgbvalues } from './srgb.js';
 import { multiplyMatrices } from './utils/matrix.js';
 import './utils/constants.js';
 import '../../ast/types.js';

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

@@ -1,4 +1,4 @@
-import { xyzd502srgb, srgb2xyz } from './xyz.js';
+import { srgb2xyz, xyzd502srgb } from './xyz.js';
 import { XYZ_D65_to_D50 } from './xyzd50.js';
 
 function prophotorgb2srgbvalues(r, g, b, a = null) {

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

@@ -1,4 +1,4 @@
-import { xyzd502srgb, srgb2xyz } from './xyz.js';
+import { srgb2xyz, xyzd502srgb } from './xyz.js';
 import { XYZ_D65_to_D50 } from './xyzd50.js';
 
 function prophotorgb2srgbvalues(r, g, b, a = null) {

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

@@ -5,7 +5,7 @@ import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { expandHexValue } from './hex.js';
-import { hwb2srgb, hslvalues, hsl2srgbvalues, cmyk2srgb, oklab2srgb, oklch2srgb, lab2srgb, lch2srgb } from './srgb.js';
+import { hslvalues, hsl2srgbvalues, hwb2srgb, cmyk2srgb, oklab2srgb, oklch2srgb, lab2srgb, lch2srgb } from './srgb.js';
 import '../sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 

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

@@ -6,8 +6,8 @@ import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
 import { expandHexValue } from './hex.js';
-import { lch2labvalues, getLABComponents, Lab_to_sRGB } from './lab.js';
-import { getOKLABComponents, OKLab_to_sRGB } from './oklab.js';
+import { lch2labvalues, Lab_to_sRGB, getLABComponents } from './lab.js';
+import { OKLab_to_sRGB, getOKLABComponents } from './oklab.js';
 import { getLCHComponents } from './lch.js';
 import { getOKLCHComponents } from './oklch.js';
 import { XYZ_to_lin_sRGB } from './xyz.js';

package/dist/lib/renderer/color/utils/constants.js

@@ -28,7 +28,7 @@ const colorRange = {
     }
 };
 const colorFuncColorSpace = ['srgb', 'srgb-linear', 'display-p3', 'prophoto-rgb', 'a98-rgb', 'rec2020', 'xyz', 'xyz-d65', 'xyz-d50'];
-({ typ: EnumToken.IdenTokenType, val: 'none' });
+({ typ: EnumToken.IdenTokenType});
 const D50 = [0.3457 / 0.3585, 1.00000, (1.0 - 0.3457 - 0.3585) / 0.3585];
 const k = Math.pow(29, 3) / Math.pow(3, 3);
 const e = Math.pow(6, 3) / Math.pow(29, 3);

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

@@ -4,7 +4,7 @@ import '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
-import { lsrgb2srgbvalues, srgb2lsrgbvalues } from './srgb.js';
+import { srgb2lsrgbvalues, lsrgb2srgbvalues } from './srgb.js';
 import '../sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 

package/dist/lib/renderer/render.js

@@ -41,17 +41,27 @@ function update(position, str) {
         }
     }
 }
+/**
+ * render ast
+ * @param data
+ * @param options
+ */
 function doRender(data, options = {}) {
+    const minify = options.minify ?? true;
+    const beautify = options.beautify ?? !minify;
     options = {
-        ...(options.minify ?? true ? {
+        ...(beautify ? {
+            indent: ' ',
+            newLine: '\n',
+        } : {
             indent: '',
             newLine: '',
+        }),
+        ...(minify ? {
             removeEmpty: true,
             removeComments: true
         } : {
-            indent: ' ',
-            newLine: '\n',
-            compress: false,
+            removeEmpty: false,
             removeComments: false,
         }), sourcemap: false, convertColor: true, expandNestingRules: false, preserveLicense: false, ...options
     };
@@ -119,7 +129,18 @@ function updateSourceMap(node, options, cache, sourcemap, position, str) {
     }
     update(position, str);
 }
-// @ts-ignore
+/**
+ * render ast node
+ * @param data
+ * @param options
+ * @param sourcemap
+ * @param position
+ * @param errors
+ * @param reducer
+ * @param cache
+ * @param level
+ * @param indents
+ */
 function renderAstNode(data, options, sourcemap, position, errors, reducer, cache, level = 0, indents = []) {
     if (indents.length < level + 1) {
         indents.push(options.indent.repeat(level));
@@ -212,8 +233,15 @@ function renderAstNode(data, options, sourcemap, position, errors, reducer, cach
             // return renderToken(data as Token, options, cache, reducer, errors);
             throw new Error(`render: unexpected token ${JSON.stringify(data, null, 1)}`);
     }
-    return '';
 }
+/**
+ * render ast token
+ * @param token
+ * @param options
+ * @param cache
+ * @param reducer
+ * @param errors
+ */
 function renderToken(token, options = {}, cache = Object.create(null), reducer, errors) {
     if (reducer == null) {
         reducer = function (acc, curr) {