@tbela99/css-parser 0.9.0 → 0.9.1

package/dist/index.d.ts

@@ -91,6 +91,7 @@ declare enum EnumToken {
     MediaFeatureAndTokenType = 89,
     MediaFeatureOrTokenType = 90,
     PseudoPageTokenType = 91,
+    PseudoElementTokenType = 92,
     Time = 25,
     Iden = 7,
     EOF = 48,
@@ -129,7 +130,7 @@ declare enum EnumToken {
  * @param nestingContent
  * @param context
  */
-declare function minify(ast: AstNode, options?: ParserOptions | MinifyOptions, recursive?: boolean, errors?: ErrorDescription[], nestingContent?: boolean, context?: {
+declare function minify(ast: AstNode, options?: ParserOptions | MinifyFeatureOptions, recursive?: boolean, errors?: ErrorDescription[], nestingContent?: boolean, context?: {
     [key: string]: any;
 }): AstNode;
 
@@ -517,6 +518,12 @@ export declare interface PseudoClassToken extends BaseToken {
     val: string;
 }
 
+export declare interface PseudoElementToken extends BaseToken {
+
+    typ: EnumToken.PseudoElementTokenType;
+    val: string;
+}
+
 export declare interface PseudoPageToken extends BaseToken {
 
     typ: EnumToken.PseudoPageTokenType;
@@ -812,6 +819,7 @@ export declare type Token =
     ListToken
     | PseudoClassToken
     | PseudoPageToken
+    | PseudoElementToken
     | PseudoClassFunctionToken
     | DelimToken
     | BinaryExpressionToken
@@ -1035,24 +1043,29 @@ interface ValidationOptions {
     lenient?: boolean;
 }
 
-export declare interface ParserOptions extends ValidationOptions, PropertyListOptions {
+interface MinifyOptions {
 
     minify?: boolean;
-    src?: string;
-    sourcemap?: boolean;
     nestingRules?: boolean;
     expandNestingRules?: boolean;
-    removeCharset?: boolean;
+    removeDuplicateDeclarations?: boolean;
+    computeShorthand?: boolean;
+    computeCalcExpression?: boolean;
+    inlineCssVariables?: boolean;
     removeEmpty?: boolean;
+    pass?: number;
+}
+
+export declare interface ParserOptions extends MinifyOptions, ValidationOptions, PropertyListOptions {
+
+    src?: string;
+    sourcemap?: boolean;
+    removeCharset?: boolean;
     resolveUrls?: boolean;
     resolveImport?: boolean;
     cwd?: string;
     parseColor?: boolean;
-    removeDuplicateDeclarations?: boolean;
-    computeShorthand?: boolean;
     removePrefix?: boolean;
-    inlineCssVariables?: boolean;
-    computeCalcExpression?: boolean;
     load?: (url: string, currentUrl: string) => Promise<string>;
     dirname?: (path: string) => string;
     resolve?: (url: string, currentUrl: string, currentWorkingDirectory?: string) => {
@@ -1064,7 +1077,7 @@ export declare interface ParserOptions extends ValidationOptions, PropertyListOp
     setParent?: boolean;
 }
 
-export declare interface MinifyOptions extends ParserOptions {
+export declare interface MinifyFeatureOptions extends ParserOptions {
 
     features: MinifyFeature[];
 }
@@ -1073,7 +1086,7 @@ export declare interface MinifyFeature {
 
     ordering: number;
 
-    register(options: MinifyOptions | ParserOptions): void;
+    register(options: MinifyFeatureOptions | ParserOptions): void;
 
     // run(ast: AstRule | AstAtRule, options: ParserOptions = {}, parent: AstRule | AstAtRule | AstRuleStyleSheet, context: { [key: string]: any }): void;
 
@@ -1083,7 +1096,7 @@ export declare interface MinifyFeature {
 export declare interface MinifyFeature {
 
     ordering: number;
-    register: (options: MinifyOptions | ParserOptions) => void;
+    register: (options: MinifyFeatureOptions | ParserOptions) => void;
     run: (ast: AstRule | AstAtRule, options: ParserOptions, parent: AstRule | AstAtRule | AstRuleStyleSheet, context: {
         [key: string]: any
     }) => void;

package/dist/lib/ast/expand.js

@@ -69,7 +69,14 @@ function expandRule(node) {
                         rule.sel = splitRule(ast.sel).reduce((a, b) => a.concat([b.join('') + r]), []).join(',');
                     }
                     else {
-                        selRule.forEach(arr => combinators.includes(arr[0].charAt(0)) ? arr.unshift(ast.sel) : arr.unshift(ast.sel, ' '));
+                        // selRule = splitRule(selRule.reduce((acc, curr) => acc + (acc.length > 0 ? ',' : '') + curr.join(''), ''));
+                        const arSelf = splitRule(ast.sel).filter((r) => r.every((t) => t != ':before' && t != ':after' && !t.startsWith('::'))).reduce((acc, curr) => acc.concat([curr.join('')]), []).join(',');
+                        if (arSelf.length == 0) {
+                            ast.chi.splice(i--, 1);
+                            continue;
+                        }
+                        //
+                        selRule.forEach(arr => combinators.includes(arr[0].charAt(0)) ? arr.unshift(arSelf) : arr.unshift(arSelf, ' '));
                         rule.sel = selRule.reduce((acc, curr) => {
                             acc.push(curr.join(''));
                             return acc;
@@ -80,8 +87,14 @@ function expandRule(node) {
                     let childSelectorCompound = [];
                     let withCompound = [];
                     let withoutCompound = [];
-                    const rules = splitRule(ast.sel);
+                    // pseudo elements cannot be used with '&'
+                    // https://www.w3.org/TR/css-nesting-1/#example-7145ff1e
+                    const rules = splitRule(ast.sel).filter((r) => r.every((t) => t != ':before' && t != ':after' && !t.startsWith('::')));
                     const parentSelector = !node.sel.includes('&');
+                    if (rules.length == 0) {
+                        ast.chi.splice(i--, 1);
+                        continue;
+                    }
                     for (const sel of (rule.raw ?? splitRule(rule.sel))) {
                         const s = sel.join('');
                         if (s.includes('&') || parentSelector) {

package/dist/lib/ast/minify.js

@@ -227,7 +227,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                         return s.join('');
                     }).join(',');
                     // @ts-ignore
-                    let sel = wrap ? node.optimized.optimized[0] + `:is(${rule})` : rule;
+                    let sel = wrap ? node.optimized.optimized.join('') + `:is(${rule})` : rule;
                     if (rule.includes('&')) {
                         // @ts-ignore
                         rule = replaceCompound(rule, node.optimized.optimized[0]);

package/dist/lib/ast/types.js

@@ -101,6 +101,7 @@ var EnumToken;
     EnumToken[EnumToken["MediaFeatureAndTokenType"] = 89] = "MediaFeatureAndTokenType";
     EnumToken[EnumToken["MediaFeatureOrTokenType"] = 90] = "MediaFeatureOrTokenType";
     EnumToken[EnumToken["PseudoPageTokenType"] = 91] = "PseudoPageTokenType";
+    EnumToken[EnumToken["PseudoElementTokenType"] = 92] = "PseudoElementTokenType";
     /* aliases */
     EnumToken[EnumToken["Time"] = 25] = "Time";
     EnumToken[EnumToken["Iden"] = 7] = "Iden";

package/dist/lib/parser/parse.js

@@ -1,4 +1,4 @@
-import { webkitPseudoAliasMap, isIdentStart, isIdent, mathFuncs, isColor, isHexColor, isPseudo, isAtKeyword, isFunction, isNumber, isPercentage, isFlex, isDimension, parseDimension, isHash, mediaTypes } from '../syntax/syntax.js';
+import { webkitPseudoAliasMap, isIdentStart, isIdent, mathFuncs, isColor, isHexColor, isPseudo, pseudoElements, 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';
@@ -46,6 +46,7 @@ async function doParse(iterator, options = {}) {
         src: '',
         sourcemap: false,
         minify: true,
+        pass: 1,
         parseColor: true,
         nestingRules: false,
         resolveImport: false,
@@ -165,7 +166,7 @@ async function doParse(iterator, options = {}) {
         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);
+            const index = context.chi.findIndex((node) => node == context);
             if (index > -1) {
                 context.chi.splice(index, 1);
             }
@@ -225,7 +226,10 @@ async function doParse(iterator, options = {}) {
     }
     if (options.minify) {
         if (ast.chi.length > 0) {
-            minify(ast, options, true, errors, false);
+            let passes = options.pass ?? 1;
+            while (passes--) {
+                minify(ast, options, true, errors, false);
+            }
         }
     }
     const endTime = performance.now();
@@ -326,8 +330,13 @@ async function parseNode(results, context, stats, options, errors, src, map, raw
                         continue;
                     }
                     if (type != EnumToken.AtRuleNodeType) {
-                        errors.push({ action: 'drop', message: 'invalid @import', location: { src, ...position } });
-                        return null;
+                        // @ts-ignore
+                        if (!(type == EnumToken.InvalidAtRuleTokenType &&
+                            // @ts-ignore
+                            ['charset', 'layer', 'import'].includes(context.chi[i].nam))) {
+                            errors.push({ action: 'drop', message: 'invalid @import', location: { src, ...position } });
+                            return null;
+                        }
                     }
                     // @ts-ignore
                     const name = context.chi[i].nam;
@@ -362,12 +371,20 @@ async function parseNode(results, context, stats, options, errors, src, map, raw
             if (tokens[0].typ == EnumToken.UrlFunctionTokenType) {
                 if (tokens[1].typ == EnumToken.UrlTokenTokenType || tokens[1].typ == EnumToken.StringTokenType) {
                     tokens.shift();
-                    if (tokens[1].typ == EnumToken.UrlTokenTokenType) {
+                    if (tokens[0]?.typ == EnumToken.UrlTokenTokenType) {
                         // @ts-ignore
                         tokens[0].typ = EnumToken.StringTokenType;
                         // @ts-ignore
                         tokens[0].val = `"${tokens[0].val}"`;
                     }
+                    // @ts-ignore
+                    while (tokens[1]?.typ == EnumToken.WhitespaceTokenType || tokens[1]?.typ == EnumToken.CommentTokenType) {
+                        tokens.splice(1, 1);
+                    }
+                    // @ts-ignore
+                    if (tokens[1]?.typ == EnumToken.EndParensTokenType) {
+                        tokens.splice(1, 1);
+                    }
                 }
             }
             // @ts-ignore
@@ -451,11 +468,11 @@ async function parseNode(results, context, stats, options, errors, src, map, raw
         const node = {
             typ: EnumToken.AtRuleNodeType,
             nam: renderToken(atRule, { removeComments: true }),
-            tokens: t,
+            // tokens: t,
             val: raw.join('')
         };
         Object.defineProperties(node, {
-            tokens: { ...definedPropertySettings, enumerable: true, value: tokens.slice() },
+            tokens: { ...definedPropertySettings, enumerable: false, value: tokens.slice() },
             raw: { ...definedPropertySettings, value: raw }
         });
         if (delim.typ == EnumToken.BlockStartTokenType) {
@@ -580,7 +597,7 @@ async function parseNode(results, context, stats, options, errors, src, map, raw
             };
             Object.defineProperty(node, 'tokens', {
                 ...definedPropertySettings,
-                enumerable: true,
+                enumerable: false,
                 value: tokens.slice()
             });
             let raw = [...uniq.values()];
@@ -681,7 +698,7 @@ async function parseNode(results, context, stats, options, errors, src, map, raw
                 //
                 //     const valid: ValidationResult = validateDeclaration(result, options, context);
                 //
-                //     console.error({valid});
+                //     // console.error({valid});
                 //
                 //     if (valid.valid == ValidationLevel.Drop) {
                 //
@@ -1053,10 +1070,16 @@ function getTokenType(val, hint) {
             val: val.slice(0, -1),
             chi: []
         }
-            : {
-                typ: EnumToken.PseudoClassTokenType,
+            : (
+            // https://www.w3.org/TR/selectors-4/#single-colon-pseudos
+            val.startsWith('::') || pseudoElements.includes(val) ? {
+                typ: EnumToken.PseudoElementTokenType,
                 val
-            };
+            } :
+                {
+                    typ: EnumToken.PseudoClassTokenType,
+                    val
+                });
     }
     if (isAtKeyword(val)) {
         return {
@@ -1233,25 +1256,25 @@ function parseTokens(tokens, options = {}) {
                     break;
                 }
             }
-            Object.assign(t, {
+            const attr = Object.assign(t, {
                 typ: inAttr == 0 ? EnumToken.AttrTokenType : EnumToken.InvalidAttrTokenType,
                 chi: tokens.splice(i + 1, k - i)
             });
             // @ts-ignore
-            if (t.chi.at(-1).typ == EnumToken.AttrEndTokenType) {
+            if (attr.chi.at(-1).typ == EnumToken.AttrEndTokenType) {
                 // @ts-ignore
-                t.chi.pop();
+                attr.chi.pop();
             }
             // @ts-ignore
-            if (t.chi.length > 1) {
+            if (attr.chi.length > 1) {
                 /*(<AttrToken>t).chi =*/
                 // @ts-ignore
-                parseTokens(t.chi, t.typ);
+                parseTokens(attr.chi, t.typ);
             }
-            let m = t.chi.length;
+            let m = attr.chi.length;
             let val;
-            for (m = 0; m < t.chi.length; m++) {
-                val = t.chi[m];
+            for (m = 0; m < attr.chi.length; m++) {
+                val = attr.chi[m];
                 if (val.typ == EnumToken.StringTokenType) {
                     const slice = val.val.slice(1, -1);
                     if ((slice.charAt(0) != '-' || (slice.charAt(0) == '-' && isIdentStart(slice.charCodeAt(1)))) && isIdent(slice)) {
@@ -1261,55 +1284,55 @@ function parseTokens(tokens, options = {}) {
                 else if (val.typ == EnumToken.LiteralTokenType && val.val == '|') {
                     let upper = m;
                     let lower = m;
-                    while (++upper < t.chi.length) {
-                        if (t.chi[upper].typ == EnumToken.CommentTokenType) {
+                    while (++upper < attr.chi.length) {
+                        if (attr.chi[upper].typ == EnumToken.CommentTokenType) {
                             continue;
                         }
                         break;
                     }
                     while (lower-- > 0) {
-                        if (t.chi[lower].typ == EnumToken.CommentTokenType) {
+                        if (attr.chi[lower].typ == EnumToken.CommentTokenType) {
                             continue;
                         }
                         break;
                     }
                     // @ts-ignore
-                    t.chi[m] = {
+                    attr.chi[m] = {
                         typ: EnumToken.NameSpaceAttributeTokenType,
-                        l: t.chi[lower],
-                        r: t.chi[upper]
+                        l: attr.chi[lower],
+                        r: attr.chi[upper]
                     };
-                    t.chi.splice(upper, 1);
+                    attr.chi.splice(upper, 1);
                     if (lower >= 0) {
-                        t.chi.splice(lower, 1);
+                        attr.chi.splice(lower, 1);
                         m--;
                     }
                 }
                 else if ([
                     EnumToken.DashMatchTokenType, EnumToken.StartMatchTokenType, EnumToken.ContainMatchTokenType, EnumToken.EndMatchTokenType, EnumToken.IncludeMatchTokenType, EnumToken.DelimTokenType
-                ].includes(t.chi[m].typ)) {
+                ].includes(attr.chi[m].typ)) {
                     let upper = m;
                     let lower = m;
-                    while (++upper < t.chi.length) {
-                        if (t.chi[upper].typ == EnumToken.CommentTokenType) {
+                    while (++upper < attr.chi.length) {
+                        if (attr.chi[upper].typ == EnumToken.CommentTokenType) {
                             continue;
                         }
                         break;
                     }
                     while (lower-- > 0) {
-                        if (t.chi[lower].typ == EnumToken.CommentTokenType) {
+                        if (attr.chi[lower].typ == EnumToken.CommentTokenType) {
                             continue;
                         }
                         break;
                     }
-                    val = t.chi[lower];
+                    val = attr.chi[lower];
                     if (val.typ == EnumToken.StringTokenType) {
                         const slice = val.val.slice(1, -1);
                         if ((slice.charAt(0) != '-' || (slice.charAt(0) == '-' && isIdentStart(slice.charCodeAt(1)))) && isIdent(slice)) {
                             Object.assign(val, { typ: EnumToken.IdenTokenType, val: slice });
                         }
                     }
-                    val = t.chi[upper];
+                    val = attr.chi[upper];
                     if (val.typ == EnumToken.StringTokenType) {
                         const slice = val.val.slice(1, -1);
                         if ((slice.charAt(0) != '-' || (slice.charAt(0) == '-' && isIdentStart(slice.charCodeAt(1)))) && isIdent(slice)) {
@@ -1429,7 +1452,9 @@ function parseTokens(tokens, options = {}) {
                 t.typ = EnumToken.ColorTokenType;
                 // @ts-ignore
                 t.kin = t.val;
+                // @ts-ignore
                 if (t.chi[0].typ == EnumToken.IdenTokenType) {
+                    // @ts-ignore
                     if (t.chi[0].val == 'from') {
                         // @ts-ignore
                         t.cal = 'rel';
@@ -1439,10 +1464,11 @@ function parseTokens(tokens, options = {}) {
                         // @ts-ignore
                         t.cal = 'mix';
                     }
-                    else if (t.val == 'color') {
-                        // @ts-ignore
-                        t.cal = 'col';
-                        // t.chi = t.chi.filter((t: Token) => [EnumToken.IdenTokenType, EnumToken.NumberTokenType, EnumToken.PercentageTokenType].includes(t.typ));
+                    else { // @ts-ignore
+                        if (t.val == 'color') {
+                            // @ts-ignore
+                            t.cal = 'col';
+                        }
                     }
                 }
                 const filter = [EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType];
@@ -1476,7 +1502,7 @@ function parseTokens(tokens, options = {}) {
             if (t.chi.length > 0) {
                 if (t.typ == EnumToken.PseudoClassFuncTokenType && t.val == ':is' && options.minify) {
                     //
-                    const count = t.chi.filter(t => t.typ != EnumToken.CommentTokenType).length;
+                    const count = t.chi.filter((t) => t.typ != EnumToken.CommentTokenType).length;
                     if (count == 1 ||
                         (i == 0 &&
                             (tokens[i + 1]?.typ == EnumToken.CommaTokenType || tokens.length == i + 1)) ||

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

@@ -15,9 +15,9 @@ import { xyz2srgb, lsrgb2srgbvalues, srgb2lsrgbvalues, lch2srgb, oklab2srgb, lab
 import { prophotorgb2srgbvalues, srgb2prophotorgbvalues } from './prophotorgb.js';
 import { a98rgb2srgbvalues, srgb2a98values } from './a98rgb.js';
 import { rec20202srgb, srgb2rec2020values } from './rec2020.js';
-import { xyzd502srgb, srgb2xyz } from './xyz.js';
+import { srgb2xyz } from './xyz.js';
 import { p32srgbvalues, srgb2p3values } from './p3.js';
-import { XYZ_D65_to_D50 } from './xyzd50.js';
+import { xyzd502srgb, XYZ_D65_to_D50 } from './xyzd50.js';
 import '../sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 

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

@@ -1,6 +1,6 @@
 import { e, k, D50 } from './utils/constants.js';
 import { getComponents } from './utils/components.js';
-import { srgb2xyz, xyzd502srgb } from './xyz.js';
+import { srgb2xyz } from './xyz.js';
 import { oklch2srgb, hwb2srgb, hsl2srgb, rgb2srgb, hex2srgb } from './srgb.js';
 import { getLCHComponents } from './lch.js';
 import { OKLab_to_XYZ, getOKLABComponents } from './oklab.js';
@@ -9,6 +9,7 @@ import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
+import { xyzd502srgb } from './xyzd50.js';
 import '../sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 

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

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

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

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

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

@@ -4,26 +4,10 @@ import '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
-import { srgb2lsrgbvalues, lsrgb2srgbvalues } from './srgb.js';
+import { srgb2lsrgbvalues } from './srgb.js';
 import '../sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 
-function xyzd502srgb(x, y, z) {
-    // @ts-ignore
-    return lsrgb2srgbvalues(
-    /* r: */
-    x * 3.1341359569958707 -
-        y * 1.6173863321612538 -
-        0.4906619460083532 * z, 
-    /*  g: */
-    x * -0.978795502912089 +
-        y * 1.916254567259524 +
-        0.03344273116131949 * z, 
-    /*    b: */
-    x * 0.07195537988411677 -
-        y * 0.2289768264158322 +
-        1.405386058324125 * z);
-}
 function XYZ_to_lin_sRGB(x, y, z) {
     // convert XYZ to linear-light sRGB
     const M = [
@@ -63,4 +47,4 @@ function srgb2xyz(r, g, b, alpha) {
     return rgb;
 }
 
-export { XYZ_D50_to_D65, XYZ_to_lin_sRGB, srgb2xyz, xyzd502srgb };
+export { XYZ_D50_to_D65, XYZ_to_lin_sRGB, srgb2xyz };

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

@@ -1,3 +1,4 @@
+import { lsrgb2srgbvalues } from './srgb.js';
 import { multiplyMatrices } from './utils/matrix.js';
 import './utils/constants.js';
 import '../../ast/types.js';
@@ -10,11 +11,12 @@ import { XYZ_D50_to_D65 } from './xyz.js';
 import '../sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 
+/*
+*/
 function xyzd502lch(x, y, z, alpha) {
     // @ts-ignore
     const [l, a, b] = xyz2lab(...XYZ_D50_to_D65(x, y, z));
     // L in range [0,100]. For use in CSS, add a percent
-    // @ts-ignore
     return lab2lchvalues(l, a, b, alpha);
 }
 function XYZ_D65_to_D50(x, y, z) {
@@ -31,5 +33,21 @@ function XYZ_D65_to_D50(x, y, z) {
     ];
     return multiplyMatrices(M, [x, y, z]);
 }
+function xyzd502srgb(x, y, z) {
+    // @ts-ignore
+    return lsrgb2srgbvalues(
+    /* r: */
+    x * 3.1341359569958707 -
+        y * 1.6173863321612538 -
+        0.4906619460083532 * z, 
+    /*  g: */
+    x * -0.978795502912089 +
+        y * 1.916254567259524 +
+        0.03344273116131949 * z, 
+    /*    b: */
+    x * 0.07195537988411677 -
+        y * 0.2289768264158322 +
+        1.405386058324125 * z);
+}
 
-export { XYZ_D65_to_D50, xyzd502lch };
+export { XYZ_D65_to_D50, xyzd502lch, xyzd502srgb };

package/dist/lib/renderer/render.js

@@ -9,7 +9,7 @@ import { expand } from '../ast/expand.js';
 import { colorMix } from './color/colormix.js';
 import { parseRelativeColor } from './color/relativecolor.js';
 import { SourceMap } from './sourcemap/sourcemap.js';
-import { isColor, mathFuncs, isNewLine } from '../syntax/syntax.js';
+import { isColor, pseudoElements, mathFuncs, isNewLine } from '../syntax/syntax.js';
 
 const colorsFunc = ['rgb', 'rgba', 'hsl', 'hsla', 'hwb', 'device-cmyk', 'color-mix', 'color', 'oklab', 'lab', 'oklch', 'lch', 'light-dark'];
 function reduceNumber(val) {
@@ -589,8 +589,9 @@ function renderToken(token, options = {}, cache = Object.create(null), reducer,
                 return '';
             }
         case EnumToken.PseudoClassTokenType:
+        case EnumToken.PseudoElementTokenType:
             // https://www.w3.org/TR/selectors-4/#single-colon-pseudos
-            if (token.typ == EnumToken.PseudoClassTokenType && ['::before', '::after', '::first-line', '::first-letter'].includes(token.val)) {
+            if (token.typ == EnumToken.PseudoElementTokenType && pseudoElements.includes(token.val.slice(1))) {
                 return token.val.slice(1);
             }
         case EnumToken.UrlTokenTokenType:

package/dist/lib/renderer/sourcemap/sourcemap.js

@@ -1,11 +1,11 @@
 import { encode } from './lib/encode.js';
 
 class SourceMap {
+    lastLocation = null;
     #version = 3;
     #sources = [];
     #map = new Map;
     #line = -1;
-    lastLocation = null;
     add(source, original) {
         if (original.src !== '') {
             if (!this.#sources.includes(original.src)) {

package/dist/lib/syntax/syntax.js

@@ -25,6 +25,7 @@ const mediaTypes = ['all', 'print', 'screen',
     'aural', 'braille', 'embossed', 'handheld', 'projection', 'tty', 'tv', 'speech'];
 // https://www.w3.org/TR/css-values-4/#math-function
 const mathFuncs = ['calc', 'clamp', 'min', 'max', 'round', 'mod', 'rem', 'sin', 'cos', 'tan', 'asin', 'acos', 'atan', 'atan2', 'pow', 'sqrt', 'hypot', 'log', 'exp', 'abs', 'sign'];
+const pseudoElements = [':before', ':after', ':first-line', ':first-letter'];
 const webkitPseudoAliasMap = {
     '-webkit-autofill': 'autofill',
     '-webkit-any': 'is',
@@ -811,4 +812,4 @@ function isWhiteSpace(codepoint) {
         codepoint == 0xa || codepoint == 0xc || codepoint == 0xd;
 }
 
-export { colorFontTech, fontFeaturesTech, fontFormat, isAngle, isAtKeyword, isColor, isColorspace, isDigit, isDimension, isFlex, isFrequency, isFunction, isHash, isHexColor, isHueInterpolationMethod, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNonPrintable, isNumber, isPercentage, isPolarColorspace, isPseudo, isRectangularOrthogonalColorspace, isResolution, isTime, isWhiteSpace, mathFuncs, mediaTypes, mozExtensions, parseDimension, webkitExtensions, webkitPseudoAliasMap };
+export { colorFontTech, fontFeaturesTech, fontFormat, isAngle, isAtKeyword, isColor, isColorspace, isDigit, isDimension, isFlex, isFrequency, isFunction, isHash, isHexColor, isHueInterpolationMethod, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNonPrintable, isNumber, isPercentage, isPolarColorspace, isPseudo, isRectangularOrthogonalColorspace, isResolution, isTime, isWhiteSpace, mathFuncs, mediaTypes, mozExtensions, parseDimension, pseudoElements, webkitExtensions, webkitPseudoAliasMap };