@tbela99/css-parser 0.5.4 → 0.7.0

package/dist/index.d.ts

@@ -72,6 +72,16 @@ declare enum EnumToken {
     IdenListTokenType = 70,
     GridTemplateFuncTokenType = 71,
     KeyFrameRuleNodeType = 72,
+    ClassSelectorTokenType = 73,
+    UniversalSelectorTokenType = 74,
+    ChildCombinatorTokenType = 75,
+    DescendantCombinatorTokenType = 76,// whitespace
+    NextSiblingCombinatorTokenType = 77,
+    SubsequentSiblingCombinatorTokenType = 78,
+    NestingSelectorTokenType = 79,
+    InvalidRuleTokenType = 80,
+    InvalidClassSelectorTokenType = 81,
+    InvalidAttrTokenType = 82,
     Time = 25,
     Iden = 7,
     EOF = 47,
@@ -119,18 +129,29 @@ declare function parseString(src: string, options?: {
 }): Token[];
 declare function parseTokens(tokens: Token[], options?: ParseTokenOptions): Token[];
 
-export declare interface BaseToken {
+export declare interface LiteralToken extends BaseToken {
 
-    typ: EnumToken;
-    loc?: Location;
+    typ: EnumToken.LiteralTokenType;
+    val: string;
 }
 
-export declare interface LiteralToken extends BaseToken {
+export declare interface ClassSelectorToken extends BaseToken {
 
-    typ: EnumToken.LiteralTokenType;
+    typ: EnumToken.ClassSelectorTokenType;
+    val: string;
+}
+
+export declare interface InvalidClassSelectorToken extends BaseToken {
+
+    typ: EnumToken.InvalidClassSelectorTokenType;
     val: string;
 }
 
+export declare interface UniversalSelectorToken extends BaseToken {
+
+    typ: EnumToken.UniversalSelectorTokenType;
+}
+
 
 export declare interface IdentToken extends BaseToken {
 
@@ -165,6 +186,11 @@ export declare interface SemiColonToken extends BaseToken {
     typ: EnumToken.SemiColonTokenType
 }
 
+export declare interface NestingSelectorToken extends BaseToken {
+
+    typ: EnumToken.NestingSelectorTokenType
+}
+
 export declare interface NumberToken extends BaseToken {
 
     typ: EnumToken.NumberTokenType,
@@ -434,7 +460,6 @@ export declare interface PseudoClassFunctionToken extends BaseToken {
 export declare interface DelimToken extends BaseToken {
 
     typ: EnumToken.DelimTokenType;
-    val: '=';
 }
 
 export declare interface BadUrlToken extends BaseToken {
@@ -459,7 +484,23 @@ export declare interface ImportantToken extends BaseToken {
     typ: EnumToken.ImportantTokenType;
 }
 
-export declare type ColorKind = 'lit' | 'hex' | 'rgb' | 'rgba' | 'hsl' | 'hsla' | 'hwb' | 'device-cmyk' | 'oklab' | 'oklch' | 'lab' | 'lch' | 'color';
+export declare type ColorKind =
+    'sys'
+    | 'dpsys'
+    | 'lit'
+    | 'hex'
+    | 'rgb'
+    | 'rgba'
+    | 'hsl'
+    | 'hsla'
+    | 'hwb'
+    | 'device-cmyk'
+    | 'oklab'
+    | 'oklch'
+    | 'lab'
+    | 'lch'
+    | 'color'
+    | 'light-dark';
 
 // export declare type HueInterpolationMethod = 'shorter' | 'longer' | 'increasing' | 'decreasing';
 
@@ -479,6 +520,32 @@ export declare interface AttrToken extends BaseToken {
     chi: Token[]
 }
 
+export declare interface InvalidAttrToken extends BaseToken {
+
+    typ: EnumToken.InvalidAttrTokenType,
+    chi: Token[]
+}
+
+export declare interface ChildCombinatorToken extends BaseToken {
+
+    typ: EnumToken.ChildCombinatorTokenType
+}
+
+export declare interface DescendantCombinatorToken extends BaseToken {
+
+    typ: EnumToken.DescendantCombinatorTokenType
+}
+
+export declare interface NextSiblingCombinatorToken extends BaseToken {
+
+    typ: EnumToken.NextSiblingCombinatorTokenType
+}
+
+export declare interface SubsequentCombinatorToken extends BaseToken {
+
+    typ: EnumToken.SubsequentSiblingCombinatorTokenType
+}
+
 export declare interface AddToken extends BaseToken {
 
     typ: EnumToken.Add;
@@ -556,6 +623,9 @@ export declare type BinaryExpressionNode = NumberToken | DimensionToken | Percen
     AngleToken | LengthToken | FrequencyToken | BinaryExpressionToken | FunctionToken | ParensToken;
 
 export declare type Token =
+    InvalidClassSelectorToken
+    | InvalidAttrToken
+    |
     LiteralToken
     | IdentToken
     | IdentListToken
@@ -563,6 +633,14 @@ export declare type Token =
     | CommaToken
     | ColonToken
     | SemiColonToken
+    | ClassSelectorToken
+    | UniversalSelectorToken
+    | ChildCombinatorToken
+    | DescendantCombinatorToken
+    | NextSiblingCombinatorToken
+    | SubsequentCombinatorToken
+    | ColumnCombinatorToken
+    | NestingSelectorToken
     |
     NumberToken
     | AtRuleToken
@@ -603,14 +681,15 @@ export declare type Token =
     | IncludeMatchToken
     | StartMatchToken
     | EndMatchToken
-    | ContainMatchToken | MatchExpressionToken | NameSpaceAttributeToken
+    | ContainMatchToken
+    | MatchExpressionToken
+    | NameSpaceAttributeToken
     |
     DashMatchToken
     | LessThanToken
     | LessThanOrEqualToken
     | GreaterThanToken
     | GreaterThanOrEqualToken
-    | ColumnCombinatorToken
     |
     ListToken
     | PseudoClassToken
@@ -646,19 +725,19 @@ export declare interface Location {
     src: string;
 }
 
-export declare interface Node {
+export declare interface BaseToken {
 
     typ: EnumToken;
     loc?: Location;
 }
 
-export declare interface AstComment extends Node {
+export declare interface AstComment extends BaseToken {
 
     typ: EnumToken.CommentNodeType | EnumToken.CDOCOMMNodeType,
     val: string;
 }
 
-export declare interface AstDeclaration extends Node {
+export declare interface AstDeclaration extends BaseToken {
 
     nam: string,
     val: Token[];
@@ -666,7 +745,7 @@ export declare interface AstDeclaration extends Node {
 }
 
 
-export declare interface AstRule extends Node {
+export declare interface AstRule extends BaseToken {
 
     typ: EnumToken.RuleNodeType;
     sel: string;
@@ -684,7 +763,7 @@ export declare interface OptimizedSelector {
     reducible: boolean;
 }
 
-export declare interface AstAtRule extends Node {
+export declare interface AstAtRule extends BaseToken {
 
     typ: AtRuleNodeType,
     nam: string;
@@ -692,10 +771,10 @@ export declare interface AstAtRule extends Node {
     chi?: Array<AstDeclaration | AstComment> | Array<AstRule | AstComment>
 }
 
-export declare interface AstRuleList extends Node {
+export declare interface AstRuleList extends BaseToken {
 
     typ: StyleSheetNodeType | RuleNodeType | AtRuleNodeType,
-    chi: Array<Node | AstComment>
+    chi: Array<BaseToken | AstComment>
 }
 
 export declare interface AstRuleStyleSheet extends AstRuleList {
@@ -739,6 +818,14 @@ export declare interface VisitorNodeMap {
     Value?: Record<EnumToken, ValueVisitorHandler> | ValueVisitorHandler;
 }
 
+declare class SourceMap {
+    #private;
+    lastLocation: Location | null;
+    add(source: Location, original: Location): void;
+    toUrl(): string;
+    toJSON(): SourceMapObject;
+}
+
 export declare type WalkerOption = 'ignore' | 'stop' | 'children' | 'ignore-children' | null;
 /**
  * returned value:
@@ -766,6 +853,8 @@ export declare interface WalkResult {
 
 export declare interface WalkAttributesResult {
     value: Token;
+    previousValue: Token | null;
+    nextValue: AstNode | null;
     root?: AstNode;
     parent: FunctionToken | ParensToken | BinaryExpressionToken | null;
 }
@@ -783,7 +872,12 @@ export declare interface ErrorDescription {
     error?: Error;
 }
 
-export declare interface ParserOptions extends PropertyListOptions {
+interface ValidationOptions {
+
+    validation?: boolean;
+}
+
+export declare interface ParserOptions extends ValidationOptions, PropertyListOptions {
 
     minify?: boolean;
     src?: string;
@@ -798,6 +892,7 @@ export declare interface ParserOptions extends PropertyListOptions {
     parseColor?: boolean;
     removeDuplicateDeclarations?: boolean;
     computeShorthand?: boolean;
+    removePrefix?: boolean;
     inlineCssVariables?: boolean;
     computeCalcExpression?: boolean;
     load?: (url: string, currentUrl: string) => Promise<string>;
@@ -820,11 +915,11 @@ export declare interface MinifyFeature {
 
     ordering: number;
 
-    register: (options: MinifyOptions | ParserOptions) => void;
-    run: (ast: AstRule | AstAtRule, options: ParserOptions = {}, parent: AstRule | AstAtRule | AstRuleStyleSheet, context: {
-        [key: string]: any
-    }) => void;
-    cleanup?: (ast: AstRuleStyleSheet, options: ParserOptions = {}, context: { [key: string]: any }) => void;
+    register(options: MinifyOptions | ParserOptions): void;
+
+    // run(ast: AstRule | AstAtRule, options: ParserOptions = {}, parent: AstRule | AstAtRule | AstRuleStyleSheet, context: { [key: string]: any }): void;
+
+    // cleanup?(ast: AstRuleStyleSheet, options: ParserOptions = {}, context: { [key: string]: any }): void;
 }
 
 export declare interface MinifyFeature {
@@ -882,7 +977,7 @@ export declare interface RenderResult {
     stats: {
         total: string;
     },
-    map?: SourceMapObject
+    map?: SourceMap
 }
 
 export declare interface TransformResult extends ParseResult, RenderResult {

package/dist/lib/ast/expand.js

@@ -1,9 +1,10 @@
 import { splitRule, combinators } from './minify.js';
 import { parseString } from '../parser/parse.js';
-import { renderToken } from '../renderer/render.js';
 import { EnumToken } from './types.js';
 import { walkValues } from './walk.js';
+import { renderToken } from '../renderer/render.js';
 import '../renderer/color/utils/constants.js';
+import '../parser/utils/config.js';
 
 function expand(ast) {
     //
@@ -154,7 +155,12 @@ function replaceCompoundLiteral(selector, replace) {
             return 1;
         }
         return b == '&' ? -1 : 0;
-    }).reduce((acc, curr) => acc + (curr == '&' ? replace : curr), '');
+    }).reduce((acc, curr) => {
+        if (acc.length > 0 && curr == '&' && (replace.charAt(0) != '.' || replace.includes(' '))) {
+            return acc + ':is(' + replace + ')';
+        }
+        return acc + (curr == '&' ? replace : curr);
+    }, '');
 }
 
 export { expand, replaceCompound };

package/dist/lib/ast/features/index.js

@@ -1,3 +1,4 @@
+export { ComputePrefixFeature } from './prefix.js';
 export { InlineCssVariablesFeature } from './inlinecssvariables.js';
 export { ComputeShorthandFeature } from './shorthand.js';
 export { ComputeCalcExpressionFeature } from './calc.js';

package/dist/lib/ast/features/prefix.js

@@ -0,0 +1,118 @@
+import { EnumToken } from '../types.js';
+import { getConfig } from '../../validation/config.js';
+import { walkValues } from '../walk.js';
+import { ValidationTokenEnum } from '../../validation/parser/types.js';
+import '../../validation/parser/parse.js';
+
+const config = getConfig();
+class ComputePrefixFeature {
+    static get ordering() {
+        return 2;
+    }
+    static register(options) {
+        if (options.removePrefix) {
+            for (const feature of options.features) {
+                if (feature instanceof ComputePrefixFeature) {
+                    return;
+                }
+            }
+            // @ts-ignore
+            options.features.push(new ComputePrefixFeature(options));
+        }
+    }
+    run(ast) {
+        // @ts-ignore
+        const j = ast.chi.length;
+        let k = 0;
+        // @ts-ignore
+        for (; k < j; k++) {
+            // @ts-ignore
+            const node = ast.chi[k];
+            if (node.typ == EnumToken.DeclarationNodeType) {
+                if (node.nam.charAt(0) == '-') {
+                    const match = node.nam.match(/^-(.*?)-(.*)$/);
+                    if (match != null) {
+                        const nam = match[2];
+                        if (nam.toLowerCase() in config.declarations) {
+                            node.nam = nam;
+                        }
+                    }
+                }
+                if (node.nam.toLowerCase() in config.declarations) {
+                    for (const { value } of walkValues(node.val)) {
+                        if (value.typ == EnumToken.IdenTokenType && value.val.charAt(0) == '-' && value.val.charAt(1) != '-') {
+                            // @ts-ignore
+                            const values = config.declarations[node.nam].ast.slice();
+                            const match = value.val.match(/^-(.*?)-(.*)$/);
+                            if (match != null) {
+                                const val = matchToken({ ...value, val: match[2] }, values);
+                                if (val != null) {
+                                    // @ts-ignore
+                                    value.val = val.val;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return ast;
+    }
+}
+function matchToken(token, matches) {
+    let result;
+    for (let i = 0; i < matches.length; i++) {
+        switch (matches[i].typ) {
+            case ValidationTokenEnum.Whitespace:
+            case ValidationTokenEnum.Comma:
+                break;
+            case ValidationTokenEnum.Keyword:
+                console.error(matches[i], token);
+                if (token.typ == EnumToken.IdenTokenType && token.val == matches[i].val) {
+                    return token;
+                }
+                break;
+            case ValidationTokenEnum.PropertyType:
+                if (['ident', 'custom-ident'].includes(matches[i].val)) {
+                    if (token.typ == EnumToken.IdenTokenType && token.val == matches[i].val) {
+                        return token;
+                    }
+                }
+                else {
+                    const val = matches[i].val;
+                    if (val in config.declarations || val in config.syntaxes) {
+                        // @ts-ignore
+                        result = matchToken(token, (config.syntaxes[val] ?? config.declarations[val]).ast.slice());
+                        if (result != null) {
+                            return result;
+                        }
+                    }
+                }
+                break;
+            case ValidationTokenEnum.PipeToken:
+            case ValidationTokenEnum.ColumnToken:
+            case ValidationTokenEnum.AmpersandToken:
+                result = matchToken(token, matches[i].l);
+                if (result == null) {
+                    result = matchToken(token, matches[i].r);
+                }
+                if (result != null) {
+                    return result;
+                }
+                break;
+            case ValidationTokenEnum.Bracket:
+                result = matchToken(token, matches[i].chi);
+                if (result != null) {
+                    return result;
+                }
+                break;
+            // default:
+            //
+            //     console.error(token, matches[i]);
+            //     throw new Error('bar bar');
+        }
+    }
+    return null;
+}
+
+export { ComputePrefixFeature };

package/dist/lib/ast/features/shorthand.js

@@ -4,6 +4,7 @@ import '../minify.js';
 import '../../parser/parse.js';
 import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
 
 class ComputeShorthandFeature {
     static get ordering() {

package/dist/lib/ast/minify.js

@@ -1,13 +1,14 @@
 import { parseString } from '../parser/parse.js';
-import { isWhiteSpace, isIdent, isFunction, isIdentStart } from '../parser/utils/syntax.js';
 import { EnumToken } from './types.js';
 import { walkValues } from './walk.js';
 import { replaceCompound } from './expand.js';
+import { isWhiteSpace, isIdent, isFunction, isIdentStart } from '../syntax/syntax.js';
+import '../parser/utils/config.js';
 import { eq } from '../parser/utils/eq.js';
 import { renderToken, doRender } from '../renderer/render.js';
 import * as index from './features/index.js';
 
-const combinators = ['+', '>', '~', '||'];
+const combinators = ['+', '>', '~', '||', '|'];
 const definedPropertySettings = { configurable: true, enumerable: false, writable: true };
 const notEndingWith = ['(', '['].concat(combinators);
 // @ts-ignore
@@ -26,6 +27,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
             removeDuplicateDeclarations: true,
             computeShorthand: true,
             computeCalcExpression: true,
+            removePrefix: false,
             features: [], ...options
         };
         // @ts-ignore
@@ -275,12 +277,17 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                                     }
                                     else {
                                         // @ts-ignore
-                                        ast.chi.splice(i, 1, intersect.node1);
+                                        ast.chi.splice(i--, 1, intersect.node1);
                                         // node = ast.chi intersect.node1;
                                     }
                                     if (intersect.node2.chi.length == 0) {
                                         // @ts-ignore
                                         ast.chi.splice(nodeIndex, 1, intersect.result);
+                                        i--;
+                                        // @ts-ignore
+                                        if (nodeIndex == i) {
+                                            nodeIndex = i;
+                                        }
                                     }
                                     else {
                                         // @ts-ignore
@@ -289,6 +296,11 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                                         i = (nodeIndex ?? 0) + 1;
                                     }
                                     reduceRuleSelector(intersect.result);
+                                    // @ts-ignore
+                                    if (node != ast.chi[i]) {
+                                        // @ts-ignore
+                                        node = ast.chi[i];
+                                    }
                                     previous = intersect.result;
                                     nodeIndex = i;
                                 }
@@ -389,6 +401,25 @@ function reduceSelector(selector) {
     if (selector.length == 0) {
         return null;
     }
+    selector = selector.reduce((acc, curr) => {
+        // @ts-ignore
+        if (curr.length > 0 && curr.at(-1).startsWith(':is(')) {
+            // @ts-ignore
+            const rules = splitRule(curr.at(-1).slice(4, -1)).map(x => {
+                if (x[0] == '&' && x.length > 1) {
+                    return x.slice(x[1] == ' ' ? 2 : 1);
+                }
+                return x;
+            });
+            const part = curr.slice(0, -1);
+            for (const rule of rules) {
+                acc.push(part.concat(rule));
+            }
+            return acc;
+        }
+        acc.push(curr);
+        return acc;
+    }, []);
     const optimized = [];
     const k = selector.reduce((acc, curr) => acc == 0 ? curr.length : (curr.length == 0 ? acc : Math.min(acc, curr.length)), 0);
     let i = 0;
@@ -427,9 +458,6 @@ function reduceSelector(selector) {
         if (optimized[1] == ' ') {
             optimized.splice(0, 2);
         }
-        // else if (combinators.includes(optimized[1])) {
-        //
-        // }
     }
     if (optimized.length == 0 ||
         (optimized[0].charAt(0) == '&' ||
@@ -937,18 +965,24 @@ function reduceRuleSelector(node) {
     }
     if (optimized != null && optimized.match && optimized.reducible && optimized.selector.length > 1) {
         for (const selector of optimized.selector) {
-            if (selector.length > 1 && selector[0] == '&' && combinators.includes(selector[1])) {
+            if (selector.length > 1 && selector[0] == '&' &&
+                (combinators.includes(selector[1]) || !/^[a-zA-Z:]/.test(selector[1]))) {
                 selector.shift();
             }
         }
+        const unique = new Set;
         const raw = [
             [
                 optimized.optimized[0], ':is('
             ].concat(optimized.selector.reduce((acc, curr) => {
-                if (acc.length > 0) {
-                    acc.push(',');
+                const sig = curr.join('');
+                if (!unique.has(sig)) {
+                    if (acc.length > 0) {
+                        acc.push(',');
+                    }
+                    unique.add(sig);
+                    acc.push(...curr);
                 }
-                acc.push(...curr);
                 return acc;
             }, [])).concat(')')
         ];

package/dist/lib/ast/types.js

@@ -1,3 +1,8 @@
+var ValidationLevel;
+(function (ValidationLevel) {
+    ValidationLevel[ValidationLevel["Valid"] = 0] = "Valid";
+    ValidationLevel[ValidationLevel["Drop"] = 1] = "Drop";
+})(ValidationLevel || (ValidationLevel = {}));
 var EnumToken;
 (function (EnumToken) {
     EnumToken[EnumToken["CommentTokenType"] = 0] = "CommentTokenType";
@@ -76,6 +81,16 @@ var EnumToken;
     EnumToken[EnumToken["IdenListTokenType"] = 70] = "IdenListTokenType";
     EnumToken[EnumToken["GridTemplateFuncTokenType"] = 71] = "GridTemplateFuncTokenType";
     EnumToken[EnumToken["KeyFrameRuleNodeType"] = 72] = "KeyFrameRuleNodeType";
+    EnumToken[EnumToken["ClassSelectorTokenType"] = 73] = "ClassSelectorTokenType";
+    EnumToken[EnumToken["UniversalSelectorTokenType"] = 74] = "UniversalSelectorTokenType";
+    EnumToken[EnumToken["ChildCombinatorTokenType"] = 75] = "ChildCombinatorTokenType";
+    EnumToken[EnumToken["DescendantCombinatorTokenType"] = 76] = "DescendantCombinatorTokenType";
+    EnumToken[EnumToken["NextSiblingCombinatorTokenType"] = 77] = "NextSiblingCombinatorTokenType";
+    EnumToken[EnumToken["SubsequentSiblingCombinatorTokenType"] = 78] = "SubsequentSiblingCombinatorTokenType";
+    EnumToken[EnumToken["NestingSelectorTokenType"] = 79] = "NestingSelectorTokenType";
+    EnumToken[EnumToken["InvalidRuleTokenType"] = 80] = "InvalidRuleTokenType";
+    EnumToken[EnumToken["InvalidClassSelectorTokenType"] = 81] = "InvalidClassSelectorTokenType";
+    EnumToken[EnumToken["InvalidAttrTokenType"] = 82] = "InvalidAttrTokenType";
     /* aliases */
     EnumToken[EnumToken["Time"] = 25] = "Time";
     EnumToken[EnumToken["Iden"] = 7] = "Iden";
@@ -117,4 +132,4 @@ const funcLike = [
     EnumToken.GridTemplateFuncTokenType
 ];
 
-export { EnumToken, funcLike };
+export { EnumToken, ValidationLevel, funcLike };

package/dist/lib/ast/walk.js

@@ -32,6 +32,7 @@ function* walkValues(values, root = null, filter) {
     const stack = values.slice();
     const map = new Map;
     let value;
+    let previous = null;
     while ((value = stack.shift())) {
         let option = null;
         if (filter != null) {
@@ -46,7 +47,7 @@ function* walkValues(values, root = null, filter) {
         // @ts-ignore
         if (option !== 'children') {
             // @ts-ignore
-            yield { value, parent: map.get(value), root };
+            yield { value, parent: map.get(value), previousValue: previous, nextValue: stack[0] ?? null, root };
         }
         if (option !== 'ignore-children' && 'chi' in value) {
             for (const child of value.chi.slice()) {
@@ -59,6 +60,7 @@ function* walkValues(values, root = null, filter) {
             map.set(value.r, value);
             stack.unshift(value.l, value.r);
         }
+        previous = value;
     }
 }
 

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

@@ -1,10 +1,10 @@
 import { PropertySet } from './set.js';
+import { getConfig } from '../utils/config.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import { parseString } from '../parse.js';
 import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
-import { getConfig } from '../utils/config.js';
 import { PropertyMap } from './map.js';
 
 const config = getConfig();

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

@@ -1,11 +1,11 @@
 import { eq } from '../utils/eq.js';
-import { renderToken } from '../../renderer/render.js';
+import { getConfig } from '../utils/config.js';
+import { matchType } from '../utils/type.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import { parseString } from '../parse.js';
+import { renderToken } from '../../renderer/render.js';
 import '../../renderer/color/utils/constants.js';
-import { getConfig } from '../utils/config.js';
-import { matchType } from '../utils/type.js';
 import { PropertySet } from './set.js';
 
 const propertiesConfig = getConfig();
@@ -248,7 +248,9 @@ class PropertyMap {
                     // @ts-ignore
                     let typ = (EnumToken[this.config.separator?.typ] ?? EnumToken.CommaTokenType);
                     // @ts-ignore
-                    let separator = this.config.separator ? renderToken(this.config.separator) : ',';
+                    const sep = this.config.separator == null ? null : { ...this.config.separator, typ: EnumToken[this.config.separator.typ] };
+                    // @ts-ignore
+                    const separator = this.config.separator ? renderToken({ ...this.config.separator, typ: EnumToken[this.config.separator.typ] }) : ',';
                     this.matchTypes(declaration);
                     values.push(value);
                     for (i = 0; i < declaration.val.length; i++) {
@@ -281,6 +283,9 @@ class PropertyMap {
                     }
                     this.removeDefaults(map, value);
                     declaration.val = values.reduce((acc, curr) => {
+                        if (sep != null && acc.length > 0) {
+                            acc.push({ ...sep });
+                        }
                         for (const cr of curr) {
                             if (cr.typ == EnumToken.WhitespaceTokenType && acc.at(-1)?.typ == cr.typ) {
                                 continue;