@tbela99/css-parser 0.8.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,
@@ -120,7 +121,16 @@ declare enum EnumToken {
     TimelineFunction = 16
 }
 
-declare function minify(ast: AstNode, options?: ParserOptions | MinifyOptions, recursive?: boolean, errors?: ErrorDescription[], nestingContent?: boolean, context?: {
+/**
+ * minify ast
+ * @param ast
+ * @param options
+ * @param recursive
+ * @param errors
+ * @param nestingContent
+ * @param context
+ */
+declare function minify(ast: AstNode, options?: ParserOptions | MinifyFeatureOptions, recursive?: boolean, errors?: ErrorDescription[], nestingContent?: boolean, context?: {
     [key: string]: any;
 }): AstNode;
 
@@ -128,22 +138,56 @@ declare enum WalkerValueEvent {
     Enter = 0,
     Leave = 1
 }
+/**
+ * walk ast nodes
+ * @param node
+ * @param filter
+ */
 declare function walk(node: AstNode, filter?: WalkerFilter): Generator<WalkResult>;
+/**
+ * walk ast values
+ * @param values
+ * @param root
+ * @param filter
+ * @param reverse
+ */
 declare function walkValues(values: Token[], root?: AstNode | Token | null, filter?: WalkerValueFilter | {
     event: WalkerValueEvent;
     fn?: WalkerValueFilter;
     type?: EnumToken | EnumToken[] | ((token: Token) => boolean);
 }, reverse?: boolean): Generator<WalkAttributesResult>;
 
+/**
+ * expand nested css ast
+ * @param ast
+ */
 declare function expand(ast: AstNode): AstNode;
 
+/**
+ * render ast token
+ * @param token
+ * @param options
+ * @param cache
+ * @param reducer
+ * @param errors
+ */
 declare function renderToken(token: Token, options?: RenderOptions, cache?: {
     [key: string]: any;
 }, reducer?: (acc: string, curr: Token) => string, errors?: ErrorDescription[]): string;
 
+/**
+ * parse string
+ * @param src
+ * @param options
+ */
 declare function parseString(src: string, options?: {
     location: boolean;
 }): Token[];
+/**
+ * parse token list
+ * @param tokens
+ * @param options
+ */
 declare function parseTokens(tokens: Token[], options?: ParseTokenOptions): Token[];
 
 export declare interface LiteralToken extends BaseToken {
@@ -474,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;
@@ -567,21 +617,15 @@ export declare interface MediaFeatureToken extends BaseToken {
     val: string;
 }
 
-export declare interface MediaFeatureOnlyToken extends BaseToken {
-
-    typ: EnumToken.MediaFeatureOnlyTokenType,
-    val: Token;
-}
-
 export declare interface MediaFeatureNotToken extends BaseToken {
 
     typ: EnumToken.MediaFeatureNotTokenType,
     val: Token;
 }
 
-export declare interface MediaFeatureNotToken extends BaseToken {
+export declare interface MediaFeatureOnlyToken extends BaseToken {
 
-    typ: EnumToken.MediaFeatureNotTokenType,
+    typ: EnumToken.MediaFeatureOnlyTokenType,
     val: Token;
 }
 
@@ -775,6 +819,7 @@ export declare type Token =
     ListToken
     | PseudoClassToken
     | PseudoPageToken
+    | PseudoElementToken
     | PseudoClassFunctionToken
     | DelimToken
     | BinaryExpressionToken
@@ -861,6 +906,7 @@ export declare interface AstKeyFrameRule extends BaseToken {
     chi: Array<AstDeclaration | AstComment>;
     optimized?: OptimizedSelector;
     raw?: RawSelectorTokens;
+    tokens?: Token[]
 }
 
 export declare type RawSelectorTokens = string[][];
@@ -994,26 +1040,32 @@ export declare interface ErrorDescription {
 interface ValidationOptions {
 
     validation?: boolean;
+    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) => {
@@ -1025,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[];
 }
@@ -1034,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;
 
@@ -1044,9 +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;
@@ -1060,6 +1110,7 @@ export declare interface ResolvedPath {
 export declare interface RenderOptions {
 
     minify?: boolean;
+    beautify?: boolean;
     removeEmpty?: boolean;
     expandNestingRules?: boolean;
     preserveLicense?: boolean;
@@ -1073,7 +1124,6 @@ export declare interface RenderOptions {
     cwd?: string;
     load?: (url: string, currentUrl: string) => Promise<string>;
     resolve?: (url: string, currentUrl: string, currentWorkingDirectory?: string) => ResolvedPath;
-
 }
 
 export declare interface TransformOptions extends ParserOptions, RenderOptions {

package/dist/lib/ast/expand.js

@@ -6,6 +6,10 @@ import { renderToken } from '../renderer/render.js';
 import '../renderer/color/utils/constants.js';
 import '../parser/utils/config.js';
 
+/**
+ * expand nested css ast
+ * @param ast
+ */
 function expand(ast) {
     //
     if (![EnumToken.RuleNodeType, EnumToken.StyleSheetNodeType, EnumToken.AtRuleNodeType].includes(ast.typ)) {
@@ -50,7 +54,7 @@ function expand(ast) {
     }
     return result;
 }
-function expandRule(node, parent) {
+function expandRule(node) {
     const ast = { ...node, chi: node.chi.slice() };
     const result = [];
     if (ast.typ == EnumToken.RuleNodeType) {
@@ -65,7 +69,14 @@ function expandRule(node, parent) {
                         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;
@@ -76,8 +87,14 @@ function expandRule(node, parent) {
                     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) {
@@ -155,7 +172,10 @@ function expandRule(node, parent) {
                     if (astAtRule.val.includes('&')) {
                         astAtRule.val = replaceCompound(astAtRule.val, ast.sel);
                     }
-                    astAtRule = expand(astAtRule);
+                    const slice = astAtRule.chi.slice().filter(t => t.typ == EnumToken.RuleNodeType && t.sel.includes('&'));
+                    if (slice.length > 0) {
+                        expandRule({ ...node, chi: astAtRule.chi.slice() });
+                    }
                 }
                 else {
                     // @ts-ignore
@@ -194,6 +214,11 @@ function expandRule(node, parent) {
     // @ts-ignore
     return ast.chi.length > 0 ? [ast].concat(result) : result;
 }
+/**
+ * replace compound selector
+ * @param input
+ * @param replace
+ */
 function replaceCompound(input, replace) {
     const tokens = parseString(input);
     let replacement = null;

package/dist/lib/ast/math/expression.js

@@ -1,5 +1,5 @@
 import { EnumToken } from '../types.js';
-import { compute, rem } from './math.js';
+import { rem, compute } from './math.js';
 import { reduceNumber } from '../../renderer/render.js';
 import { mathFuncs } from '../../syntax/syntax.js';
 

package/dist/lib/ast/minify.js

@@ -2,10 +2,10 @@ import { parseString } from '../parser/parse.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 { isIdent, isFunction, isWhiteSpace, 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 { doRender, renderToken } from '../renderer/render.js';
 import * as index from './features/index.js';
 
 const combinators = ['+', '>', '~', '||', '|'];
@@ -13,6 +13,15 @@ const definedPropertySettings = { configurable: true, enumerable: false, writabl
 const notEndingWith = ['(', '['].concat(combinators);
 // @ts-ignore
 const features = Object.values(index).sort((a, b) => a.ordering - b.ordering);
+/**
+ * minify ast
+ * @param ast
+ * @param options
+ * @param recursive
+ * @param errors
+ * @param nestingContent
+ * @param context
+ */
 function minify(ast, options = {}, recursive = false, errors, nestingContent, context = {}) {
     if (!('nodes' in context)) {
         context.nodes = new Set;
@@ -82,7 +91,8 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                 continue;
             }
             if (node.typ == EnumToken.AtRuleNodeType) {
-                if (node.nam == 'media' && node.val == 'all') {
+                // @ts-ignore
+                if (node.nam == 'media' && ['all', '', null].includes(node.val)) {
                     // @ts-ignore
                     ast.chi?.splice(i, 1, ...node.chi);
                     i--;
@@ -217,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]);
@@ -397,6 +407,18 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
     }
     return ast;
 }
+function hasDeclaration(node) {
+    // @ts-ignore
+    for (let i = 0; i < node.chi?.length; i++) {
+        // @ts-ignore
+        if (node.chi[i].typ == EnumToken.CommentNodeType) {
+            continue;
+        }
+        // @ts-ignore
+        return node.chi[i].typ == EnumToken.DeclarationNodeType;
+    }
+    return true;
+}
 function reduceSelector(selector) {
     if (selector.length == 0) {
         return null;
@@ -497,18 +519,10 @@ function reduceSelector(selector) {
         reducible: selector.every((selector) => !['>', '+', '~', '&'].includes(selector[0]))
     };
 }
-function hasDeclaration(node) {
-    // @ts-ignore
-    for (let i = 0; i < node.chi?.length; i++) {
-        // @ts-ignore
-        if (node.chi[i].typ == EnumToken.CommentNodeType) {
-            continue;
-        }
-        // @ts-ignore
-        return node.chi[i].typ == EnumToken.DeclarationNodeType;
-    }
-    return true;
-}
+/**
+ * split selector string
+ * @param buffer
+ */
 function splitRule(buffer) {
     const result = [[]];
     let str = '';
@@ -995,4 +1009,4 @@ function reduceRuleSelector(node) {
     }
 }
 
-export { combinators, definedPropertySettings, hasDeclaration, matchSelectors, minify, reduceSelector, splitRule };
+export { combinators, definedPropertySettings, minify, splitRule };

package/dist/lib/ast/types.js

@@ -2,6 +2,7 @@ var ValidationLevel;
 (function (ValidationLevel) {
     ValidationLevel[ValidationLevel["Valid"] = 0] = "Valid";
     ValidationLevel[ValidationLevel["Drop"] = 1] = "Drop";
+    ValidationLevel[ValidationLevel["Lenient"] = 2] = "Lenient"; /* preserve unknown at-rules, declarations and pseudo-classes */
 })(ValidationLevel || (ValidationLevel = {}));
 var EnumToken;
 (function (EnumToken) {
@@ -100,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/ast/walk.js

@@ -5,6 +5,11 @@ var WalkerValueEvent;
     WalkerValueEvent[WalkerValueEvent["Enter"] = 0] = "Enter";
     WalkerValueEvent[WalkerValueEvent["Leave"] = 1] = "Leave";
 })(WalkerValueEvent || (WalkerValueEvent = {}));
+/**
+ * walk ast nodes
+ * @param node
+ * @param filter
+ */
 function* walk(node, filter) {
     const parents = [node];
     const root = node;
@@ -33,6 +38,13 @@ function* walk(node, filter) {
         }
     }
 }
+/**
+ * walk ast values
+ * @param values
+ * @param root
+ * @param filter
+ * @param reverse
+ */
 function* walkValues(values, root = null, filter, reverse) {
     // const set = new Set<Token>();
     const stack = values.slice();

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

@@ -162,55 +162,6 @@ class PropertyMap {
         }
         return this;
     }
-    matchTypes(declaration) {
-        const patterns = this.pattern.slice();
-        const values = [...declaration.val];
-        let i;
-        let j;
-        const map = new Map;
-        for (i = 0; i < patterns.length; i++) {
-            for (j = 0; j < values.length; j++) {
-                if (!map.has(patterns[i])) {
-                    // @ts-ignore
-                    map.set(patterns[i], this.config.properties?.[patterns[i]]?.constraints?.mapping?.max ?? 1);
-                }
-                let count = map.get(patterns[i]);
-                if (count > 0 && matchType(values[j], this.config.properties[patterns[i]])) {
-                    Object.defineProperty(values[j], 'propertyName', {
-                        enumerable: false,
-                        writable: true,
-                        value: patterns[i]
-                    });
-                    map.set(patterns[i], --count);
-                    values.splice(j--, 1);
-                }
-            }
-        }
-        if (this.config.set != null) {
-            for (const [key, val] of Object.entries(this.config.set)) {
-                if (map.has(key)) {
-                    for (const v of val) {
-                        // missing
-                        if (map.get(v) == 1) {
-                            let i = declaration.val.length;
-                            while (i--) {
-                                // @ts-ignore
-                                if (declaration.val[i].propertyName == key) {
-                                    const val = { ...declaration.val[i] };
-                                    Object.defineProperty(val, 'propertyName', {
-                                        enumerable: false,
-                                        writable: true,
-                                        value: v
-                                    });
-                                    declaration.val.splice(i, 0, val, { typ: EnumToken.WhitespaceTokenType });
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
     [Symbol.iterator]() {
         let iterable;
         let requiredCount = 0;
@@ -249,9 +200,15 @@ class PropertyMap {
                     // @ts-ignore
                     let typ = (EnumToken[this.config.separator?.typ] ?? EnumToken.CommaTokenType);
                     // @ts-ignore
-                    const sep = this.config.separator == null ? null : { ...this.config.separator, typ: EnumToken[this.config.separator.typ] };
+                    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] }) : ',';
+                    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++) {
@@ -446,7 +403,6 @@ class PropertyMap {
                             acc.push(curr);
                             return acc;
                         }, []);
-                        // @todo remove renderToken call
                         if (props.default.includes(curr[1][i].reduce((acc, curr) => acc + renderToken(curr) + ' ', '').trimEnd())) {
                             if (!this.config.properties[curr[0]].required) {
                                 continue;
@@ -544,6 +500,7 @@ class PropertyMap {
                 }
                 // @ts-ignore
                 if (values.length == 1 &&
+                    // @ts-ignore
                     typeof values[0].val == 'string' &&
                     this.config.default.includes(values[0].val.toLowerCase()) &&
                     this.config.default[0] != values[0].val.toLowerCase()) {
@@ -562,6 +519,7 @@ class PropertyMap {
             // @ts-ignore
             next() {
                 let v = iterable.next();
+                // @ts-ignore
                 while (v.done || v.value instanceof PropertySet) {
                     if (v.value instanceof PropertySet) {
                         // @ts-ignore
@@ -584,6 +542,55 @@ class PropertyMap {
             }
         };
     }
+    matchTypes(declaration) {
+        const patterns = this.pattern.slice();
+        const values = [...declaration.val];
+        let i;
+        let j;
+        const map = new Map;
+        for (i = 0; i < patterns.length; i++) {
+            for (j = 0; j < values.length; j++) {
+                if (!map.has(patterns[i])) {
+                    // @ts-ignore
+                    map.set(patterns[i], this.config.properties?.[patterns[i]]?.constraints?.mapping?.max ?? 1);
+                }
+                let count = map.get(patterns[i]);
+                if (count > 0 && matchType(values[j], this.config.properties[patterns[i]])) {
+                    Object.defineProperty(values[j], 'propertyName', {
+                        enumerable: false,
+                        writable: true,
+                        value: patterns[i]
+                    });
+                    map.set(patterns[i], --count);
+                    values.splice(j--, 1);
+                }
+            }
+        }
+        if (this.config.set != null) {
+            for (const [key, val] of Object.entries(this.config.set)) {
+                if (map.has(key)) {
+                    for (const v of val) {
+                        // missing
+                        if (map.get(v) == 1) {
+                            let i = declaration.val.length;
+                            while (i--) {
+                                // @ts-ignore
+                                if (declaration.val[i].propertyName == key) {
+                                    const val = { ...declaration.val[i] };
+                                    Object.defineProperty(val, 'propertyName', {
+                                        enumerable: false,
+                                        writable: true,
+                                        value: v
+                                    });
+                                    declaration.val.splice(i, 0, val, { typ: EnumToken.WhitespaceTokenType });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
     removeDefaults(map, value) {
         for (const [key, val] of map) {
             const config = this.config.properties[key];

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

@@ -181,20 +181,8 @@ class PropertySet {
                         return acc;
                     }, [])
                 }][Symbol.iterator]();
-            // return {
-            //     next() {
-            //
-            //         return iterator.next();
-            //     }
-            // }
         }
         return iterator;
-        // return {
-        //     next() {
-        //
-        //         return iterator.next();
-        //     }
-        // }
     }
 }