@tbela99/css-parser 0.4.1 → 0.5.0

package/dist/index.d.ts

@@ -664,7 +664,7 @@ export declare interface AstDeclaration extends Node {
     typ: EnumToken.DeclarationNodeType
 }
 
-export declare interface AstRule$1 extends Node {
+export declare interface AstRule extends Node {
 
     typ: EnumToken.RuleNodeType;
     sel: string;
@@ -682,12 +682,12 @@ export declare interface OptimizedSelector {
     reducible: boolean;
 }
 
-export declare interface AstAtRule$1 extends Node {
+export declare interface AstAtRule extends Node {
 
     typ: AtRuleNodeType,
     nam: string;
     val: string;
-    chi?: Array<AstDeclaration | AstComment> | Array<AstRule$1 | AstComment>
+    chi?: Array<AstDeclaration | AstComment> | Array<AstRule | AstComment>
 }
 
 export declare interface AstRuleList extends Node {
@@ -696,17 +696,17 @@ export declare interface AstRuleList extends Node {
     chi: Array<Node | AstComment>
 }
 
-export declare interface AstRuleStyleSheet$1 extends AstRuleList {
+export declare interface AstRuleStyleSheet extends AstRuleList {
     typ: StyleSheetNodeType,
     chi: Array<AstRuleList | AstComment>
 }
 
 export declare type AstNode =
-    AstRuleStyleSheet$1
+    AstRuleStyleSheet
     | AstRuleList
     | AstComment
-    | AstAtRule$1
-    | AstRule$1
+    | AstAtRule
+    | AstRule
     | AstDeclaration;
 
 /**
@@ -716,12 +716,12 @@ export declare type DeclarationVisitorHandler = (node: AstDeclaration) => AstDec
 /**
  * Rule visitor handler
  */
-export declare type RuleVisitorHandler = (node: AstRule$1) => AstRule$1 | AstRule$1[] | null | Promise<AstRule$1 | AstRule$1[] | null>;
+export declare type RuleVisitorHandler = (node: AstRule) => AstRule | AstRule[] | null | Promise<AstRule | AstRule[] | null>;
 
 /**
  * AtRule visitor handler
  */
-export declare type AtRuleVisitorHandler = (node: AstAtRule$1) => AstAtRule$1 | AstAtRule$1[] | null | Promise<AstAtRule$1 | AstAtRule$1[] | null>;
+export declare type AtRuleVisitorHandler = (node: AstAtRule) => AstAtRule | AstAtRule[] | null | Promise<AstAtRule | AstAtRule[] | null>;
 
 /**
  * Value visitor handler
@@ -781,17 +781,6 @@ export declare interface ErrorDescription {
     error?: Error;
 }
 
-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;
-}
-
 export declare interface ParserOptions extends PropertyListOptions {
 
     minify?: boolean;
@@ -817,6 +806,7 @@ export declare interface ParserOptions extends PropertyListOptions {
     };
     visitor?: VisitorNodeMap;
     signal?: AbortSignal;
+    setParent?: boolean;
 }
 
 export declare interface MinifyOptions extends ParserOptions {
@@ -824,6 +814,28 @@ export declare interface MinifyOptions extends ParserOptions {
     features: MinifyFeature[];
 }
 
+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;
+}
+
+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;
+}
+
 export declare interface ResolvedPath {
     absolute: string;
     relative: string;
@@ -839,6 +851,7 @@ export declare interface RenderOptions {
     newLine?: string;
     removeComments?: boolean;
     convertColor?: boolean;
+    withParents?: boolean;
     output?: string;
     cwd?: string;
     load?: (url: string, currentUrl: string) => Promise<string>;

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

@@ -1,10 +1,8 @@
 import { EnumToken } from '../types.js';
 import { walkValues } from '../walk.js';
-import { MinifyFeature } from '../utils/minifyfeature.js';
-import { IterableWeakSet } from '../../iterable/weakset.js';
 import { evaluate } from '../math/expression.js';
 
-class ComputeCalcExpressionFeature extends MinifyFeature {
+class ComputeCalcExpressionFeature {
     static get ordering() {
         return 1;
     }
@@ -28,7 +26,7 @@ class ComputeCalcExpressionFeature extends MinifyFeature {
             if (node.typ != EnumToken.DeclarationNodeType) {
                 continue;
             }
-            const set = new IterableWeakSet;
+            const set = new Set;
             for (const { value, parent } of walkValues(node.val)) {
                 if (value != null && value.typ == EnumToken.FunctionTokenType && value.val == 'calc') {
                     if (!set.has(parent)) {

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

@@ -1,7 +1,5 @@
 import { EnumToken } from '../types.js';
 import { walkValues } from '../walk.js';
-import { MinifyFeature } from '../utils/minifyfeature.js';
-import { IterableWeakSet } from '../../iterable/weakset.js';
 
 function replace(node, variableScope) {
     for (const { value, parent: parentValue } of walkValues(node.val)) {
@@ -26,7 +24,7 @@ function replace(node, variableScope) {
         }
     }
 }
-class InlineCssVariablesFeature extends MinifyFeature {
+class InlineCssVariablesFeature {
     static get ordering() {
         return 0;
     }
@@ -61,7 +59,7 @@ class InlineCssVariablesFeature extends MinifyFeature {
                     const info = {
                         globalScope: isRoot,
                         // @ts-ignore
-                        parent: new IterableWeakSet(),
+                        parent: new Set(),
                         declarationCount: 1,
                         replaceable: isRoot,
                         node: node
@@ -99,6 +97,9 @@ class InlineCssVariablesFeature extends MinifyFeature {
     }
     cleanup(ast, options = {}, context) {
         const variableScope = context.variableScope;
+        if (variableScope == null) {
+            return;
+        }
         for (const info of variableScope.values()) {
             if (info.replaceable) {
                 let i;

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

@@ -4,9 +4,8 @@ import '../minify.js';
 import '../../parser/parse.js';
 import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
-import { MinifyFeature } from '../utils/minifyfeature.js';
 
-class ComputeShorthandFeature extends MinifyFeature {
+class ComputeShorthandFeature {
     static get ordering() {
         return 2;
     }
@@ -18,7 +17,7 @@ class ComputeShorthandFeature extends MinifyFeature {
                 }
             }
             // @ts-ignore
-            options.features.push(new ComputeShorthandFeature());
+            options.features.push(new ComputeShorthandFeature(options));
         }
     }
     run(ast, options = {}, parent, context) {

package/dist/lib/ast/minify.js

@@ -8,8 +8,8 @@ import { renderToken, doRender } from '../renderer/render.js';
 import * as index from './features/index.js';
 
 const combinators = ['+', '>', '~', '||'];
-const notEndingWith = ['(', '['].concat(combinators);
 const definedPropertySettings = { configurable: true, enumerable: false, writable: true };
+const notEndingWith = ['(', '['].concat(combinators);
 // @ts-ignore
 const features = Object.values(index).sort((a, b) => a.ordering - b.ordering);
 function minify(ast, options = {}, recursive = false, errors, nestingContent, context = {}) {
@@ -892,4 +892,4 @@ function reduceRuleSelector(node) {
     }
 }
 
-export { combinators, hasDeclaration, minify, reduceSelector, splitRule };
+export { combinators, definedPropertySettings, hasDeclaration, minify, reduceSelector, splitRule };

package/dist/lib/ast/walk.js

@@ -3,9 +3,8 @@ import { EnumToken } from './types.js';
 function* walk(node, filter) {
     const parents = [node];
     const root = node;
-    const weakMap = new WeakMap;
-    while (parents.length > 0) {
-        node = parents.shift();
+    const map = new Map;
+    while ((node = parents.shift())) {
         let option = null;
         if (filter != null) {
             option = filter(node);
@@ -19,22 +18,21 @@ function* walk(node, filter) {
         // @ts-ignore
         if (option !== 'children') {
             // @ts-ignore
-            yield { node, parent: weakMap.get(node), root };
+            yield { node, parent: map.get(node), root };
         }
         if (option !== 'ignore-children' && 'chi' in node) {
             parents.unshift(...node.chi);
             for (const child of node.chi.slice()) {
-                weakMap.set(child, node);
+                map.set(child, node);
             }
         }
     }
 }
 function* walkValues(values, root = null, filter) {
     const stack = values.slice();
-    const weakMap = new WeakMap;
+    const map = new Map;
     let value;
-    while (stack.length > 0) {
-        value = stack.shift();
+    while ((value = stack.shift())) {
         let option = null;
         if (filter != null) {
             option = filter(value);
@@ -48,17 +46,17 @@ function* walkValues(values, root = null, filter) {
         // @ts-ignore
         if (option !== 'children') {
             // @ts-ignore
-            yield { value, parent: weakMap.get(value), root };
+            yield { value, parent: map.get(value), root };
         }
         if (option !== 'ignore-children' && 'chi' in value) {
             for (const child of value.chi.slice()) {
-                weakMap.set(child, value);
+                map.set(child, value);
             }
             stack.unshift(...value.chi);
         }
         else if (value.typ == EnumToken.BinaryExpressionTokenType) {
-            weakMap.set(value.l, value);
-            weakMap.set(value.r, value);
+            map.set(value.l, value);
+            map.set(value.r, value);
             stack.unshift(value.l, value.r);
         }
     }

package/dist/lib/iterable/weakset.js

@@ -1,30 +1,40 @@
 class IterableWeakSet {
     #weakset = new WeakSet;
     #set = new Set;
-    constructor(iterable) {
-        if (iterable) {
-            for (const value of iterable) {
-                const ref = new WeakRef(value);
-                this.#weakset.add(value);
-                this.#set.add(ref);
-            }
-        }
-    }
+    // constructor(iterable?: Iterable<any>) {
+    //
+    //     if (iterable) {
+    //
+    //         for (const value of iterable) {
+    //
+    //             const ref: WeakRef<any> = new WeakRef(value);
+    //
+    //             this.#weakset.add(value);
+    //             this.#set.add(ref);
+    //         }
+    //     }
+    // }
     has(value) {
         return this.#weakset.has(value);
     }
-    delete(value) {
-        if (this.#weakset.has(value)) {
-            for (const ref of this.#set) {
-                if (ref.deref() === value) {
-                    this.#set.delete(ref);
-                    break;
-                }
-            }
-            return this.#weakset.delete(value);
-        }
-        return false;
-    }
+    // delete(value: any): boolean {
+    //
+    //     if (this.#weakset.has(value)) {
+    //
+    //         for (const ref of this.#set) {
+    //
+    //             if (ref.deref() === value) {
+    //
+    //                 this.#set.delete(ref);
+    //                 break;
+    //             }
+    //         }
+    //
+    //         return this.#weakset.delete(value);
+    //     }
+    //
+    //     return false;
+    // }
     add(value) {
         if (!this.#weakset.has(value)) {
             this.#weakset.add(value);

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

@@ -12,12 +12,7 @@ class PropertyList {
     options = { removeDuplicateDeclarations: true, computeShorthand: true };
     declarations;
     constructor(options = {}) {
-        for (const key of Object.keys(this.options)) {
-            if (key in options) {
-                // @ts-ignore
-                this.options[key] = options[key];
-            }
-        }
+        this.options = options;
         this.declarations = new Map;
     }
     set(nam, value) {

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

@@ -30,6 +30,7 @@ class PropertyMap {
         else {
             const separator = this.config.separator != null ? {
                 ...this.config.separator,
+                // @ts-ignore
                 typ: EnumToken[this.config.separator.typ]
             } : null;
             // expand shorthand
@@ -39,7 +40,7 @@ class PropertyMap {
                 // @ts-ignore
                 this.declarations.get(this.config.shorthand).val.slice().reduce((acc, curr) => {
                     // @ts-ignore
-                    if (separator != null && separator.typ == curr.typ && eq(separator, curr)) {
+                    if (separator != null && separator.typ == curr.typ && separator.val == curr.val) {
                         acc.push([]);
                         return acc;
                     }
@@ -78,11 +79,8 @@ class PropertyMap {
                                 i--;
                                 // @ts-ignore
                                 if ('prefix' in props && acc[i]?.typ == EnumToken[props.prefix.typ]) {
-                                    if (eq(acc[i], {
-                                        ...this.config.properties[property].prefix,
-                                        // @ts-ignore
-                                        typ: EnumToken[props.prefix.typ]
-                                    })) {
+                                    // @ts-ignore
+                                    if (acc[i].typ == EnumToken[props.prefix.typ] && acc[i].val == this.config.properties[property].prefix.val) {
                                         acc.splice(i, 1);
                                         i--;
                                     }
@@ -249,6 +247,7 @@ class PropertyMap {
                     let values = [];
                     // @ts-ignore
                     let typ = (EnumToken[this.config.separator?.typ] ?? EnumToken.CommaTokenType);
+                    // @ts-ignore
                     let separator = this.config.separator ? renderToken(this.config.separator) : ',';
                     this.matchTypes(declaration);
                     values.push(value);
@@ -328,6 +327,26 @@ class PropertyMap {
                 }
                 return (filtered.length > 0 ? filtered : values)[Symbol.iterator]();
             }
+            for (const declaration of this.declarations.values()) {
+                if (declaration instanceof PropertySet) {
+                    continue;
+                }
+                const config = declaration.nam == this.config.shorthand ? this.config : this.config.properties[declaration.nam] ?? this.config;
+                if (!('mapping' in config)) {
+                    continue;
+                }
+                // @ts-ignore
+                for (const [key, val] of Object.entries(config.mapping)) {
+                    const keys = parseString(key);
+                    if (keys.length != declaration.val.length) {
+                        continue;
+                    }
+                    if (eq(declaration.val, keys)) {
+                        declaration.val = parseString(val);
+                        break;
+                    }
+                }
+            }
             // @ts-ignore
             iterable = this.declarations.values();
         }
@@ -336,6 +355,7 @@ class PropertyMap {
             let match;
             const separator = this.config.separator != null ? {
                 ...this.config.separator,
+                // @ts-ignore
                 typ: EnumToken[this.config.separator.typ]
             } : null;
             const tokens = {};
@@ -353,7 +373,8 @@ class PropertyMap {
                 for (const declaration of [(properties instanceof PropertySet ? [...properties][0] : properties)]) {
                     // @ts-ignore
                     for (const val of declaration.val) {
-                        if (separator != null && separator.typ == val.typ && eq(separator, val)) {
+                        // @ts-ignore
+                        if (separator != null && separator.typ == val.typ && separator.val == val.val) {
                             current++;
                             if (tokens[curr[0]].length == current) {
                                 tokens[curr[0]].push([]);
@@ -364,10 +385,11 @@ class PropertyMap {
                             continue;
                         }
                         // @ts-ignore
-                        if (props.multiple && props.separator != null && EnumToken[props.separator.typ] == val.typ && eq({
-                            ...props.separator,
-                            typ: EnumToken[props.separator.typ]
-                        }, val)) {
+                        if (props.multiple && props.separator != null &&
+                            // @ts-ignore
+                            EnumToken[props.separator.typ] == val.typ &&
+                            // @ts-ignore
+                            props.separator.val == val.val) {
                             continue;
                         }
                         // @ts-ignore
@@ -472,6 +494,7 @@ class PropertyMap {
                                     acc.push({
                                         ...((props.separator && {
                                             ...props.separator,
+                                            // @ts-ignore
                                             typ: EnumToken[props.separator.typ]
                                         }) ?? { typ: EnumToken.WhitespaceTokenType })
                                     });
@@ -572,6 +595,7 @@ class PropertyMap {
                                 if (value[index].typ == EnumToken.WhitespaceTokenType) {
                                     continue;
                                 }
+                                // @ts-ignore@
                                 if (value[index].typ == EnumToken[config.prefix.typ] &&
                                     // @ts-ignore
                                     value[index].val == config.prefix.val) {

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

@@ -68,6 +68,7 @@ class PropertySet {
                             }
                             tokens[current].push(token);
                         }
+                        // @ts-ignore
                         if (token.typ == EnumToken.LiteralTokenType && token.val == this.config.separator) {
                             tokens.push([]);
                             current++;
@@ -171,6 +172,7 @@ class PropertySet {
                             }
                         }
                         if (acc.length > 0) {
+                            // @ts-ignore
                             acc.push({ typ: EnumToken.LiteralTokenType, val: this.config.separator });
                         }
                         acc.push(...curr);