@tbela99/css-parser 1.3.2 → 1.3.4

package/dist/lib/ast/walk.js

@@ -1,61 +1,139 @@
+/**
+ * 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
+     * ignore the current node and process its children
      */
-    WalkerOptionEnum[WalkerOptionEnum["Children"] = 2] = "Children";
+    WalkerOptionEnum[WalkerOptionEnum["Children"] = 4] = "Children";
     /**
-     * ignore children
+     * ignore the current node children
      */
-    WalkerOptionEnum[WalkerOptionEnum["IgnoreChildren"] = 3] = "IgnoreChildren";
+    WalkerOptionEnum[WalkerOptionEnum["IgnoreChildren"] = 8] = "IgnoreChildren";
 })(WalkerOptionEnum || (WalkerOptionEnum = {}));
-var WalkerValueEvent;
-(function (WalkerValueEvent) {
+/**
+ * event types for the walkValues function
+ */
+var WalkerEvent;
+(function (WalkerEvent) {
     /**
      * enter node
      */
-    WalkerValueEvent[WalkerValueEvent["Enter"] = 0] = "Enter";
+    WalkerEvent[WalkerEvent["Enter"] = 1] = "Enter";
     /**
      * leave node
      */
-    WalkerValueEvent[WalkerValueEvent["Leave"] = 1] = "Leave";
-})(WalkerValueEvent || (WalkerValueEvent = {}));
+    WalkerEvent[WalkerEvent["Leave"] = 2] = "Leave";
+})(WalkerEvent || (WalkerEvent = {}));
 /**
  * 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 {@link filter} function to control the ast traversal.  the filter function returns a value of type {@link WalkerOption}.
+ *
+ * ```ts
+ * import {EnumToken, transform, walk, WalkerOptionEnum} 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;
+ * }
+ * `;
+ *
+ * function filter(node) {
+ *
+ *     if (node.typ == EnumToken.AstRule && node.sel.includes('html')) {
+ *
+ *         // skip the children of the current node
+ *         return WalkerOptionEnum.IgnoreChildren;
+ *     }
+ * }
+ *
+ * const result = await transform(css);
+ * for (const {node} of walk(result.ast, filter)) {
+ *
+ *     console.error([EnumToken[node.typ]]);
+ * }
+ *
+ * // [ "StyleSheetNodeType" ]
+ * // [ "RuleNodeType" ]
+ * // [ "DeclarationNodeType" ]
+ * // [ "RuleNodeType" ]
+ * // [ "DeclarationNodeType" ]
+ * // [ "RuleNodeType" ]
+ * // [ "DeclarationNodeType" ]
+ * ```
  */
-function* walk(node, filter) {
+function* walk(node, filter, reverse) {
     const parents = [node];
     const root = node;
     const map = new Map;
-    while ((node = parents.shift())) {
+    let isNumeric = false;
+    let i = 0;
+    while ((node = parents[i++])) {
         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);
-            for (const child of node.chi.slice()) {
+        if ('chi' in node && (!isNumeric || ((option & WalkerOptionEnum.IgnoreChildren) === 0))) {
+            parents.splice(i, 0, ...node.chi[reverse ? 'reverse' : 'slice']());
+            for (const child of node.chi) {
                 map.set(child, node);
             }
         }
@@ -67,39 +145,80 @@ function* walk(node, filter) {
  * @param root
  * @param filter
  * @param reverse
+ *
+ * Example:
+ *
+ * ```ts
+ *
+ * import {AstDeclaration, EnumToken, transform, walkValues} from '@tbela99/css-parser';
+ *
+ * const css = `
+ * body { color:    color(from var(--base-color) display-p3 r calc(g + 0.24) calc(b + 0.15)); }
+ * `;
+ *
+ * const result = await transform(css);
+ * const declaration = result.ast.chi[0].chi[0] as AstDeclaration;
+ *
+ * // walk the node attribute's tokens in reverse order
+ * for (const {value} of walkValues(declaration.val, null, null,true)) {
+ *
+ *     console.error([EnumToken[value.typ], value.val]);
+ * }
+ *
+ * // [ "Color", "color" ]
+ * // [ "FunctionTokenType", "calc" ]
+ * // [ "Number", 0.15 ]
+ * // [ "Add", undefined ]
+ * // [ "Iden", "b" ]
+ * // [ "Whitespace", undefined ]
+ * // [ "FunctionTokenType", "calc" ]
+ * // [ "Number", 0.24 ]
+ * // [ "Add", undefined ]
+ * // [ "Iden", "g" ]
+ * // [ "Whitespace", undefined ]
+ * // [ "Iden", "r" ]
+ * // [ "Whitespace", undefined ]
+ * // [ "Iden", "display-p3" ]
+ * // [ "Whitespace", undefined ]
+ * // [ "FunctionTokenType", "var" ]
+ * // [ "DashedIden", "--base-color" ]
+ * // [ "Whitespace", undefined ]
+ * // [ "Iden", "from" ]
+ * ```
  */
 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,
+            event: WalkerEvent.Enter,
             fn: filter
         };
     }
     else if (filter == null) {
         filter = {
-            event: WalkerValueEvent.Enter
+            event: WalkerEvent.Enter
         };
     }
-    const eventType = filter.event ?? WalkerValueEvent.Enter;
+    let isNumeric = false;
+    const eventType = filter.event ?? WalkerEvent.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 & WalkerEvent.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, WalkerEvent.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 +226,31 @@ 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) {
+        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,46 +258,36 @@ 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 & WalkerEvent.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), WalkerEvent.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
-            };
-        }
         previous = value;
     }
 }
 
-export { WalkerOptionEnum, WalkerValueEvent, walk, walkValues };
+export { WalkerEvent, WalkerOptionEnum, walk, walkValues };

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++) {
@@ -15,9 +17,10 @@ function dirname(path) {
         if (chr == '/') {
             parts.push('');
         }
-        else if (chr == '?' || chr == '#') {
-            break;
-        }
+        // else if (chr == '?' || chr == '#') {
+        //
+        //     break;
+        // }
         else {
             parts[parts.length - 1] += chr;
         }
@@ -72,6 +75,8 @@ function resolve(url, currentDirectory, cwd) {
             relative: url
         };
     }
+    cwd ??= '';
+    currentDirectory ??= '';
     if (matchUrl.test(currentDirectory)) {
         const path = new URL(url, currentDirectory).href;
         return {

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

@@ -26,7 +26,9 @@ class PropertyList {
     }
     add(...declarations) {
         for (const declaration of declarations) {
-            if (declaration.typ != EnumToken.DeclarationNodeType || !this.options.removeDuplicateDeclarations) {
+            if (declaration.typ != EnumToken.DeclarationNodeType ||
+                (typeof this.options.removeDuplicateDeclarations === 'string' && this.options.removeDuplicateDeclarations === declaration.nam.toLowerCase()) ||
+                (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;
             }