@tbela99/css-parser 1.3.1 → 1.3.3

package/dist/lib/ast/walk.js

@@ -1,60 +1,127 @@
+/**
+ * options for the walk function
+ */
 var WalkerOptionEnum;
 (function (WalkerOptionEnum) {
     /**
      * ignore the current node and its children
      */
-    WalkerOptionEnum[WalkerOptionEnum["Ignore"] = 0] = "Ignore";
+    WalkerOptionEnum[WalkerOptionEnum["Ignore"] = 1] = "Ignore";
     /**
      * stop walking the tree
      */
-    WalkerOptionEnum[WalkerOptionEnum["Stop"] = 1] = "Stop";
+    WalkerOptionEnum[WalkerOptionEnum["Stop"] = 2] = "Stop";
     /**
      * ignore node and process children
      */
-    WalkerOptionEnum[WalkerOptionEnum["Children"] = 2] = "Children";
+    WalkerOptionEnum[WalkerOptionEnum["Children"] = 4] = "Children";
     /**
      * ignore children
      */
-    WalkerOptionEnum[WalkerOptionEnum["IgnoreChildren"] = 3] = "IgnoreChildren";
+    WalkerOptionEnum[WalkerOptionEnum["IgnoreChildren"] = 8] = "IgnoreChildren";
 })(WalkerOptionEnum || (WalkerOptionEnum = {}));
+/**
+ * event types for the walkValues function
+ */
 var WalkerValueEvent;
 (function (WalkerValueEvent) {
     /**
      * enter node
      */
-    WalkerValueEvent[WalkerValueEvent["Enter"] = 0] = "Enter";
+    WalkerValueEvent[WalkerValueEvent["Enter"] = 1] = "Enter";
     /**
      * leave node
      */
-    WalkerValueEvent[WalkerValueEvent["Leave"] = 1] = "Leave";
+    WalkerValueEvent[WalkerValueEvent["Leave"] = 2] = "Leave";
 })(WalkerValueEvent || (WalkerValueEvent = {}));
 /**
  * walk ast nodes
- * @param node
- * @param filter
+ * @param node initial node
+ * @param filter control the walk process
+ * @param reverse walk in reverse order
+ *
+ * ```ts
+ *
+ * import {walk} from '@tbela99/css-parser';
+ *
+ * const css = `
+ * body { color:    color(from var(--base-color) display-p3 r calc(g + 0.24) calc(b + 0.15)); }
+ *
+ * html,
+ * body {
+ *     line-height: 1.474;
+ * }
+ *
+ * .ruler {
+ *
+ *     height: 10px;
+ * }
+ * `;
+ *
+ * for (const {node, parent, root} of walk(ast)) {
+ *
+ *     // do something with node
+ * }
+ * ```
+ *
+ * Using a filter to control the walk process:
+ *
+ * ```ts
+ *
+ * import {walk} from '@tbela99/css-parser';
+ *
+ * const css = `
+ * body { color:    color(from var(--base-color) display-p3 r calc(g + 0.24) calc(b + 0.15)); }
+ *
+ * html,
+ * body {
+ *     line-height: 1.474;
+ * }
+ *
+ * .ruler {
+ *
+ *     height: 10px;
+ * }
+ * `;
+ *
+ * for (const {node, parent, root} of walk(ast, (node) => {
+ *
+ *     if (node.typ == EnumToken.AstRule && node.sel.includes('html')) {
+ *
+ *         // skip the children of the current node
+ *         return WalkerOptionEnum.IgnoreChildren;
+ *     }
+ * })) {
+ *
+ *     // do something with node
+ * }
+ * ```
  */
-function* walk(node, filter) {
+function* walk(node, filter, reverse) {
     const parents = [node];
     const root = node;
     const map = new Map;
+    let isNumeric = false;
     while ((node = parents.shift())) {
         let option = null;
         if (filter != null) {
             option = filter(node);
-            if (option === WalkerOptionEnum.Ignore) {
-                continue;
-            }
-            if (option === WalkerOptionEnum.Stop) {
-                break;
+            isNumeric = typeof option == 'number';
+            if (isNumeric) {
+                if ((option & WalkerOptionEnum.Ignore)) {
+                    continue;
+                }
+                if ((option & WalkerOptionEnum.Stop)) {
+                    break;
+                }
             }
         }
-        // @ts-ignore
-        if (option !== 'children') {
+        if (!isNumeric || (option & WalkerOptionEnum.Children) === 0) {
             // @ts-ignore
             yield { node, parent: map.get(node), root };
         }
-        if (option !== WalkerOptionEnum.IgnoreChildren && 'chi' in node) {
-            parents.unshift(...node.chi);
+        if ('chi' in node && (!isNumeric || ((option & WalkerOptionEnum.IgnoreChildren) === 0))) {
+            parents.unshift(...node.chi[reverse ? 'reverse' : 'slice']());
             for (const child of node.chi.slice()) {
                 map.set(child, node);
             }
@@ -67,13 +134,38 @@ function* walk(node, filter) {
  * @param root
  * @param filter
  * @param reverse
+ *
+ * Example:
+ *
+ * ```ts
+ *
+ * import {EnumToken, walk} from '@tbela99/css-parser';
+ *
+ * const css = `
+ * body { color:    color(from var(--base-color) display-p3 r calc(g + 0.24) calc(b + 0.15)); }
+ *
+ * html,
+ * body {
+ *     line-height: 1.474;
+ * }
+ *
+ * .ruler {
+ *
+ *     height: 10px;
+ * }
+ * `;
+ *
+ * for (const {value} of walkValues(result.ast.chi[0].chi[0].val, null, null,true)) {
+ *
+ *     console.error([EnumToken[value.typ], value.val]);
+ * }
+ *
  */
 function* walkValues(values, root = null, filter, reverse) {
     // const set = new Set<Token>();
     const stack = values.slice();
     const map = new Map;
     let previous = null;
-    // let parent: FunctionToken | ParensToken | BinaryExpressionToken | null = null;
     if (filter != null && typeof filter == 'function') {
         filter = {
             event: WalkerValueEvent.Enter,
@@ -85,21 +177,23 @@ function* walkValues(values, root = null, filter, reverse) {
             event: WalkerValueEvent.Enter
         };
     }
+    let isNumeric = false;
     const eventType = filter.event ?? WalkerValueEvent.Enter;
     while (stack.length > 0) {
         let value = reverse ? stack.pop() : stack.shift();
         let option = null;
-        if (filter.fn != null && eventType == WalkerValueEvent.Enter) {
+        if (filter.fn != null && (eventType & WalkerValueEvent.Enter)) {
             const isValid = filter.type == null || value.typ == filter.type ||
                 (Array.isArray(filter.type) && filter.type.includes(value.typ)) ||
                 (typeof filter.type == 'function' && filter.type(value));
             if (isValid) {
-                option = filter.fn(value, map.get(value) ?? root);
-                if (option === WalkerOptionEnum.Ignore) {
-                    continue;
+                option = filter.fn(value, map.get(value) ?? root, WalkerValueEvent.Enter);
+                isNumeric = typeof option == 'number';
+                if (isNumeric && (option & WalkerOptionEnum.Stop)) {
+                    return;
                 }
-                if (option === WalkerOptionEnum.Stop) {
-                    break;
+                if (isNumeric && (option & WalkerOptionEnum.Ignore)) {
+                    continue;
                 }
                 // @ts-ignore
                 if (option != null && typeof option == 'object' && 'typ' in option) {
@@ -107,38 +201,33 @@ function* walkValues(values, root = null, filter, reverse) {
                 }
             }
         }
-        if (eventType == WalkerValueEvent.Enter && option !== WalkerOptionEnum.Children) {
-            yield {
-                value,
-                parent: map.get(value) ?? root,
-                previousValue: previous,
-                nextValue: stack[0] ?? null,
-                // @ts-ignore
-                root: root ?? null
-            };
-        }
-        if (option !== WalkerOptionEnum.IgnoreChildren && 'chi' in value) {
+        // if ((eventType & WalkerValueEvent.Enter) && (!isNumeric || ((option as number) & WalkerOptionEnum.Children) === 0)) {
+        yield {
+            value,
+            parent: map.get(value) ?? root,
+            previousValue: previous,
+            nextValue: stack[0] ?? null,
+            // @ts-ignore
+            root: root ?? null
+        };
+        // }
+        if ('chi' in value && (!isNumeric || (option & WalkerOptionEnum.IgnoreChildren) === 0)) {
             const sliced = value.chi.slice();
             for (const child of sliced) {
                 map.set(child, value);
             }
-            if (reverse) {
-                stack.push(...sliced);
-            }
-            else {
-                stack.unshift(...sliced);
-            }
+            stack[reverse ? 'push' : 'unshift'](...sliced);
         }
         else {
             const values = [];
             if ('l' in value && value.l != null) {
                 // @ts-ignore
-                values.push(value.l);
+                values[reverse ? 'push' : 'unshift'](value.l);
                 // @ts-ignore
                 map.set(value.l, value);
             }
             if ('op' in value && typeof value.op == 'object') {
-                values.push(value.op);
+                values[reverse ? 'push' : 'unshift'](value.op);
                 // @ts-ignore
                 map.set(value.op, value);
             }
@@ -146,44 +235,45 @@ function* walkValues(values, root = null, filter, reverse) {
                 if (Array.isArray(value.r)) {
                     for (const r of value.r) {
                         // @ts-ignore
-                        values.push(r);
+                        values[reverse ? 'push' : 'unshift'](r);
                         // @ts-ignore
                         map.set(r, value);
                     }
                 }
                 else {
                     // @ts-ignore
-                    values.push(value.r);
+                    values[reverse ? 'push' : 'unshift'](value.r);
                     // @ts-ignore
                     map.set(value.r, value);
                 }
             }
             if (values.length > 0) {
-                stack.unshift(...values);
+                stack[reverse ? 'push' : 'unshift'](...values);
             }
         }
-        if (eventType == WalkerValueEvent.Leave && filter.fn != null) {
+        if ((eventType & WalkerValueEvent.Leave) && filter.fn != null) {
             const isValid = filter.type == null || value.typ == filter.type ||
                 (Array.isArray(filter.type) && filter.type.includes(value.typ)) ||
                 (typeof filter.type == 'function' && filter.type(value));
             if (isValid) {
-                option = filter.fn(value, map.get(value));
+                option = filter.fn(value, map.get(value), WalkerValueEvent.Leave);
                 // @ts-ignore
                 if (option != null && 'typ' in option) {
                     map.set(option, map.get(value) ?? root);
                 }
             }
         }
-        if (eventType == WalkerValueEvent.Leave && option !== WalkerOptionEnum.Children) {
-            yield {
-                value,
-                parent: map.get(value) ?? root,
-                previousValue: previous,
-                nextValue: stack[0] ?? null,
-                // @ts-ignore
-                root: root ?? null
-            };
-        }
+        // if ((eventType & WalkerValueEvent.Leave) && (!isNumeric && ((option as number) & WalkerOptionEnum.Children) === 0)) {
+        //
+        //     yield {
+        //         value,
+        //         parent: <FunctionToken | ParensToken>map.get(value) ?? root,
+        //         previousValue: previous,
+        //         nextValue: <Token>stack[0] ?? null,
+        //         // @ts-ignore
+        //         root: root ?? null
+        //     };
+        // }
         previous = value;
     }
 }

package/dist/lib/fs/resolve.js

@@ -2,12 +2,14 @@ const matchUrl = /^(https?:)?\/\//;
 /**
  * return the directory name of a path
  * @param path
- * @internal
+ *
+ * @private
  */
 function dirname(path) {
-    if (path == '/' || path === '') {
-        return path;
-    }
+    // if (path == '/' || path === '') {
+    //
+    //     return path;
+    // }
     let i = 0;
     let parts = [''];
     for (; i < path.length; i++) {

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

@@ -26,7 +26,7 @@ class PropertyList {
     }
     add(...declarations) {
         for (const declaration of declarations) {
-            if (declaration.typ != EnumToken.DeclarationNodeType || !this.options.removeDuplicateDeclarations) {
+            if (declaration.typ != EnumToken.DeclarationNodeType || (Array.isArray(this.options.removeDuplicateDeclarations) ? this.options.removeDuplicateDeclarations.includes(declaration.nam) : !this.options.removeDuplicateDeclarations)) {
                 this.declarations.set(Number(Math.random().toString().slice(2)).toString(36), declaration);
                 continue;
             }