@tbela99/css-parser 1.0.0 → 1.1.1-alpha4

package/dist/lib/ast/minify.js

@@ -1,12 +1,15 @@
 import { parseString } from '../parser/parse.js';
+import '../parser/tokenize.js';
+import '../parser/utils/config.js';
 import { EnumToken } from './types.js';
 import { walkValues } from './walk.js';
 import { replaceCompound } from './expand.js';
-import { isIdent, isFunction, isWhiteSpace, isIdentStart } from '../syntax/syntax.js';
-import '../parser/utils/config.js';
+import { isWhiteSpace, isIdent, isFunction, isIdentStart } from '../syntax/syntax.js';
 import { eq } from '../parser/utils/eq.js';
 import { doRender, renderToken } from '../renderer/render.js';
+import '../renderer/color/utils/constants.js';
 import * as index from './features/index.js';
+import { FeatureWalkMode } from './features/type.js';
 
 const combinators = ['+', '>', '~', '||', '|'];
 const definedPropertySettings = { configurable: true, enumerable: false, writable: true };
@@ -23,13 +26,9 @@ const features = Object.values(index).sort((a, b) => a.ordering - b.ordering);
  * @param context
  */
 function minify(ast, options = {}, recursive = false, errors, nestingContent, context = {}) {
-    if (!('nodes' in context)) {
-        context.nodes = new Set;
-    }
-    if (context.nodes.has(ast)) {
-        return ast;
-    }
-    context.nodes.add(ast);
+    let preprocess = false;
+    let postprocess = false;
+    let parents;
     if (!('features' in options)) {
         // @ts-ignore
         options = {
@@ -43,28 +42,118 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
         for (const feature of features) {
             feature.register(options);
         }
+        options.features.sort((a, b) => a.ordering - b.ordering);
+    }
+    for (const feature of options.features) {
+        if (feature.preProcess) {
+            preprocess = true;
+        }
+        if (feature.postProcess) {
+            postprocess = true;
+        }
+    }
+    if (preprocess) {
+        parents = [ast];
+        for (const parent of parents) {
+            if (parent.typ == EnumToken.CommentTokenType ||
+                parent.typ == EnumToken.CDOCOMMTokenType) {
+                Object.defineProperty(parent, 'parent', {
+                    ...definedPropertySettings,
+                    value: parent
+                });
+                continue;
+            }
+            for (const feature of options.features) {
+                if (!feature.preProcess) {
+                    continue;
+                }
+                feature.run(parent, options, parent.parent ?? ast, context, FeatureWalkMode.Pre);
+            }
+            if (('chi' in parent)) {
+                // @ts-ignore
+                for (const node of parent.chi) {
+                    parents.push(Object.defineProperty(node, 'parent', {
+                        ...definedPropertySettings,
+                        value: parent
+                    }));
+                }
+            }
+        }
+        for (const feature of options.features) {
+            if (feature.preProcess && 'cleanup' in feature) {
+                // @ts-ignore
+                feature.cleanup(ast, options, context, FeatureWalkMode.Pre);
+            }
+        }
     }
-    function reducer(acc, curr, index, array) {
-        // trim :is()
-        if (array.length == 1 && array[0][0] == ':is(' && array[0].at(-1) == ')') {
-            curr = curr.slice(1, -1);
+    doMinify(ast, options, recursive, errors, nestingContent, context);
+    parents = [ast];
+    for (const parent of parents) {
+        // parent = parents.shift() as AstNode;
+        if (parent.typ == EnumToken.CommentTokenType ||
+            parent.typ == EnumToken.CDOCOMMTokenType) {
+            continue;
         }
-        if (curr[0] == '&') {
-            if (curr[1] == ' ' && !isIdent(curr[2]) && !isFunction(curr[2])) {
-                curr.splice(0, 2);
+        if (postprocess) {
+            for (const feature of options.features) {
+                if (!feature.postProcess) {
+                    continue;
+                }
+                feature.run(parent, options, parent.parent ?? ast, context, FeatureWalkMode.Post);
             }
-            else if (combinators.includes(curr[1])) {
-                curr.shift();
+        }
+        if (('chi' in parent)) {
+            // @ts-ignore
+            for (const node of parent.chi) {
+                parents.push(Object.defineProperty(node, 'parent', {
+                    ...definedPropertySettings,
+                    value: parent
+                }));
             }
         }
-        else if (ast.typ == EnumToken.RuleNodeType && (isIdent(curr[0]) || isFunction(curr[0]))) {
+    }
+    if (postprocess) {
+        for (const feature of options.features) {
+            if (feature.postProcess && 'cleanup' in feature) {
+                // @ts-ignore
+                feature.cleanup(ast, options, context, FeatureWalkMode.Post);
+            }
+        }
+    }
+    return ast;
+}
+function reduce(acc, curr, index, array) {
+    // trim :is()
+    if (array.length == 1 && array[0][0] == ':is(' && array[0].at(-1) == ')') {
+        curr = curr.slice(1, -1);
+    }
+    if (curr[0] == '&') {
+        if (curr[1] == ' ' && !isIdent(curr[2]) && !isFunction(curr[2])) {
+            curr.splice(0, 2);
+        }
+        else if (combinators.includes(curr[1])) {
+            curr.shift();
+        }
+    }
+    else { // @ts-ignore
+        if (this.typ == EnumToken.RuleNodeType && (isIdent(curr[0]) || isFunction(curr[0]))) {
             curr.unshift('&', ' ');
         }
-        acc.push(curr.join(''));
-        return acc;
     }
+    acc.push(curr.join(''));
+    return acc;
+}
+function doMinify(ast, options = {}, recursive = false, errors, nestingContent, context = {}) {
+    if (!('nodes' in context)) {
+        context.nodes = new Set;
+    }
+    if (context.nodes.has(ast)) {
+        return ast;
+    }
+    context.nodes.add(ast);
     // @ts-ignore
     if ('chi' in ast && ast.chi.length > 0) {
+        const reducer = reduce.bind(ast);
         if (!nestingContent) {
             nestingContent = options.nestingRules && ast.typ == EnumToken.RuleNodeType;
         }
@@ -99,7 +188,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                     continue;
                 }
                 if (node.chi.length > 0) {
-                    minify(node, options, true, errors, nestingContent, context);
+                    doMinify(node, options, true, errors, nestingContent, context);
                 }
             }
             if (node.typ == EnumToken.KeyFrameRuleNodeType) {
@@ -148,7 +237,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                 }
                 // @ts-ignore
                 if (!hasDeclaration(node)) {
-                    minify(node, options, recursive, errors, nestingContent, context);
+                    doMinify(node, options, recursive, errors, nestingContent, context);
                 }
                 previous = node;
                 nodeIndex = i;
@@ -199,7 +288,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                         nodeIndex = --i;
                         // @ts-ignore
                         previous = ast.chi[nodeIndex];
-                        minify(wrapper, options, recursive, errors, nestingContent, context);
+                        doMinify(wrapper, options, recursive, errors, nestingContent, context);
                         continue;
                     }
                     // @ts-ignore
@@ -306,7 +395,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                                     // @ts-ignore
                                     // minifyRule(node, <MinifyOptions>options, ast, context);
                                     // } else {
-                                    minify(node, options, recursive, errors, nestingContent, context);
+                                    doMinify(node, options, recursive, errors, nestingContent, context);
                                 }
                                 i--;
                                 previous = node;
@@ -361,7 +450,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                             // @ts-ignore
                             // minifyRule(previous, <MinifyOptions>options, ast, context);
                             // } else {
-                            minify(previous, options, recursive, errors, nestingContent, context);
+                            doMinify(previous, options, recursive, errors, nestingContent, context);
                         }
                     }
                 }
@@ -372,14 +461,14 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                             // @ts-ignore
                             // minifyRule(previous, <MinifyOptions>options, ast, context);
                             // } else {
-                            minify(previous, options, recursive, errors, nestingContent, context);
+                            doMinify(previous, options, recursive, errors, nestingContent, context);
                         }
                     }
                 }
             }
             // else if ('chi' in node) {
             //
-            //     minify(node, options, recursive, errors, nestingContent, context);
+            //     doMinify(node, options, recursive, errors, nestingContent, context);
             // }
             if (!nestingContent &&
                 // @ts-ignore
@@ -398,7 +487,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
             if (node.typ == EnumToken.KeyframeAtRuleNodeType || !node.chi.some(n => n.typ == EnumToken.DeclarationNodeType)) {
                 // @ts-ignore
                 if (!(node.typ == EnumToken.AtRuleNodeType && node.nam != 'font-face')) {
-                    minify(node, options, recursive, errors, nestingContent, context);
+                    doMinify(node, options, recursive, errors, nestingContent, context);
                 }
             }
         }
@@ -411,41 +500,6 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
             fixSelector(node);
         }
     }
-    if (ast.typ == EnumToken.StyleSheetNodeType) {
-        let parent;
-        let parents = [ast];
-        while (parents.length > 0) {
-            parent = parents.shift();
-            // @ts-ignore
-            for (let k = 0; k < parent.chi.length; k++) {
-                // @ts-ignore
-                const node = parent.chi[k];
-                if (!('chi' in node) || node.typ == EnumToken.StyleSheetNodeType || (node.typ == EnumToken.AtRuleNodeType && node.nam == 'font-face')) {
-                    continue;
-                }
-                // @ts-ignore
-                if (node.chi.length > 0) {
-                    parents.push(node);
-                    Object.defineProperty(node, 'parent', { ...definedPropertySettings, value: parent });
-                    for (const feature of options.features) {
-                        feature.run(node, options, parent, context);
-                    }
-                }
-                // @ts-ignore
-                if (options.removeEmpty && node.chi.length == 0) {
-                    // @ts-ignore
-                    parent.chi.splice(k, 1);
-                    k--;
-                }
-            }
-        }
-        for (const feature of options.features) {
-            if ('cleanup' in feature) {
-                // @ts-ignore
-                feature.cleanup(ast, options, context);
-            }
-        }
-    }
     return ast;
 }
 function hasDeclaration(node) {
@@ -600,6 +654,28 @@ function splitRule(buffer) {
             result.push([]);
             continue;
         }
+        if (chr == '.') {
+            if (str !== '') {
+                // @ts-ignore
+                result.at(-1).push(str);
+                str = '';
+            }
+            str += chr;
+            continue;
+        }
+        if (combinators.includes(chr)) {
+            if (str !== '') {
+                // @ts-ignore
+                result.at(-1).push(str);
+                str = '';
+            }
+            if (chr == '|' && buffer.charAt(i + 1) == '|') {
+                chr += buffer.charAt(++i);
+            }
+            // @ts-ignore
+            result.at(-1).push(chr);
+            continue;
+        }
         if (chr == ':') {
             if (str !== '') {
                 // @ts-ignore
@@ -816,7 +892,6 @@ function matchSelectors(selector1, selector2, parentType, errors) {
                 }, []);
             }
         }
-        // @todo: check hasCompoundSelector && curr[0] == '&' && curr[1] == ' '
         acc.push(match.length == 0 ? ['&'] : (hasCompoundSelector && curr[0] != '&' && (curr.length == 0 || !combinators.includes(curr[0].charAt(0))) ? ['&'].concat(curr) : curr));
         return acc;
     }
@@ -894,6 +969,9 @@ function wrapNodes(previous, node, match, ast, reducer, i, nodeIndex) {
     return wrapper;
 }
 function diff(n1, n2, reducer, options = {}) {
+    if (!('cache' in options)) {
+        options.cache = new WeakMap();
+    }
     let node1 = n1;
     let node2 = n2;
     let exchanged = false;
@@ -906,12 +984,9 @@ function diff(n1, n2, reducer, options = {}) {
     let i = node1.chi.length;
     let j = node2.chi.length;
     if (i == 0 || j == 0) {
-        // @ts-ignore
         return null;
     }
-    // @ts-ignore
     const raw1 = node1.raw;
-    // @ts-ignore
     const raw2 = node2.raw;
     if (raw1 != null && raw2 != null) {
         const prefixes1 = new Set;
@@ -959,9 +1034,16 @@ function diff(n1, n2, reducer, options = {}) {
             }
         }
     }
-    // @ts-ignore
+    const css1 = options.cache.get(node1);
+    const css2 = options.cache.get(node2);
     node1 = { ...node1, chi: node1.chi.slice() };
     node2 = { ...node2, chi: node2.chi.slice() };
+    if (css1 != null) {
+        options.cache.set(node1, css1);
+    }
+    if (css2 != null) {
+        options.cache.set(node2, css2);
+    }
     if (raw1 != null) {
         Object.defineProperty(node1, 'raw', { ...definedPropertySettings, value: raw1 });
     }
@@ -982,24 +1064,34 @@ function diff(n1, n2, reducer, options = {}) {
                 continue;
             }
             if (node1.chi[i].nam == node2.chi[j].nam) {
-                if (eq(node1.chi[i], node2.chi[j])) {
+                if (node1.chi[i].typ == node2.chi[j].typ && eq(node1.chi[i], node2.chi[j])) {
                     intersect.push(node1.chi[i]);
                     node1.chi.splice(i, 1);
                     node2.chi.splice(j, 1);
+                    options.cache.delete(node1);
+                    options.cache.delete(node2);
                     break;
                 }
             }
         }
     }
-    // @ts-ignore
     const result = (intersect.length == 0 ? null : {
         ...node1,
         // @ts-ignore
         sel: [...new Set([...(n1?.raw?.reduce(reducer, []) ?? splitRule(n1.sel)).concat(n2?.raw?.reduce(reducer, []) ?? splitRule(n2.sel))])].join(','),
         chi: intersect.reverse()
     });
-    if (result == null || [n1, n2].reduce((acc, curr) => curr.chi.length == 0 ? acc : acc + doRender(curr, options).code.length, 0) <= [node1, node2, result].reduce((acc, curr) => curr.chi.length == 0 ? acc : acc + doRender(curr, options).code.length, 0)) {
-        // @ts-ignore
+    if (result == null || [n1, n2].reduce((acc, curr) => {
+        let css = options.cache.get(curr);
+        if (css == null) {
+            css = doRender(curr, options).code;
+            options.cache.set(curr, css);
+        }
+        return curr.chi.length == 0 ? acc : acc + css.length;
+    }, 0) <= [node1, node2, result].reduce((acc, curr) => {
+        const css = doRender(curr, options).code;
+        return curr.chi.length == 0 ? acc : acc + css.length;
+    }, 0)) {
         return null;
     }
     return { result, node1: exchanged ? node2 : node1, node2: exchanged ? node1 : node2 };
@@ -1008,9 +1100,6 @@ function reduceRuleSelector(node) {
     if (node.raw == null) {
         Object.defineProperty(node, 'raw', { ...definedPropertySettings, value: splitRule(node.sel) });
     }
-    // @ts-ignore
-    // if (node.raw != null) {
-    // @ts-ignore
     let optimized = reduceSelector(node.raw.reduce((acc, curr) => {
         acc.push(curr.slice());
         return acc;
@@ -1044,7 +1133,6 @@ function reduceRuleSelector(node) {
         const sel = raw[0].join('');
         if (sel.length < node.sel.length) {
             node.sel = sel;
-            // node.raw = raw;
             Object.defineProperty(node, 'raw', { ...definedPropertySettings, value: raw });
         }
     }

package/dist/lib/ast/transform/compute.js

@@ -5,6 +5,7 @@ import { transformFunctions } from '../../syntax/syntax.js';
 import '../minify.js';
 import '../walk.js';
 import '../../parser/parse.js';
+import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
 import { getNumber, getAngle } from '../../renderer/color/color.js';
 import '../../renderer/color/utils/constants.js';

package/dist/lib/ast/transform/matrix.js

@@ -7,6 +7,7 @@ import '../../renderer/color/utils/constants.js';
 import '../minify.js';
 import '../walk.js';
 import '../../parser/parse.js';
+import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
 
 function parseMatrix(mat) {

package/dist/lib/ast/types.js

@@ -1,9 +1,30 @@
+var SyntaxValidationResult;
+(function (SyntaxValidationResult) {
+    SyntaxValidationResult[SyntaxValidationResult["Valid"] = 0] = "Valid";
+    SyntaxValidationResult[SyntaxValidationResult["Drop"] = 1] = "Drop";
+    SyntaxValidationResult[SyntaxValidationResult["Lenient"] = 2] = "Lenient"; /* preserve unknown at-rules, declarations and pseudo-classes */
+})(SyntaxValidationResult || (SyntaxValidationResult = {}));
+/**
+ * validation level enum
+ */
 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 */
+    /**
+     * disable validation
+     */
+    ValidationLevel[ValidationLevel["None"] = 0] = "None";
+    /**
+     * validate selectors and at-rules
+     */
+    ValidationLevel[ValidationLevel["Default"] = 1] = "Default";
+    /**
+     * validate selectors, at-rules and declarations
+     */
+    ValidationLevel[ValidationLevel["All"] = 2] = "All"; // selectors + at-rules + declarations
 })(ValidationLevel || (ValidationLevel = {}));
+/**
+ * token types enum
+ */
 var EnumToken;
 (function (EnumToken) {
     EnumToken[EnumToken["CommentTokenType"] = 0] = "CommentTokenType";
@@ -103,6 +124,7 @@ var EnumToken;
     EnumToken[EnumToken["PseudoPageTokenType"] = 91] = "PseudoPageTokenType";
     EnumToken[EnumToken["PseudoElementTokenType"] = 92] = "PseudoElementTokenType";
     EnumToken[EnumToken["KeyframeAtRuleNodeType"] = 93] = "KeyframeAtRuleNodeType";
+    EnumToken[EnumToken["InvalidDeclarationNodeType"] = 94] = "InvalidDeclarationNodeType";
     /* aliases */
     EnumToken[EnumToken["Time"] = 25] = "Time";
     EnumToken[EnumToken["Iden"] = 7] = "Iden";
@@ -132,16 +154,5 @@ var EnumToken;
     EnumToken[EnumToken["TimingFunction"] = 17] = "TimingFunction";
     EnumToken[EnumToken["TimelineFunction"] = 16] = "TimelineFunction";
 })(EnumToken || (EnumToken = {}));
-const funcLike = [
-    EnumToken.ParensTokenType,
-    EnumToken.FunctionTokenType,
-    EnumToken.UrlFunctionTokenType,
-    EnumToken.StartParensTokenType,
-    EnumToken.ImageFunctionTokenType,
-    EnumToken.TimingFunctionTokenType,
-    EnumToken.TimingFunctionTokenType,
-    EnumToken.PseudoClassFuncTokenType,
-    EnumToken.GridTemplateFuncTokenType
-];
 
-export { EnumToken, ValidationLevel, funcLike };
+export { EnumToken, SyntaxValidationResult, ValidationLevel };

package/dist/lib/ast/utils/utils.js

@@ -0,0 +1,104 @@
+import { funcLike, ColorKind } from '../../renderer/color/utils/constants.js';
+import { EnumToken } from '../types.js';
+import '../minify.js';
+import '../walk.js';
+import '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
+import '../../renderer/sourcemap/lib/encode.js';
+import { minmax } from '../../renderer/color/color.js';
+
+function reduceNumber(val) {
+    val = String(+val);
+    if (val === '0') {
+        return '0';
+    }
+    const chr = val.charAt(0);
+    if (chr == '-') {
+        const slice = val.slice(0, 2);
+        if (slice == '-0') {
+            return val.length == 2 ? '0' : '-' + val.slice(2);
+        }
+    }
+    if (chr == '0') {
+        return val.slice(1);
+    }
+    return val;
+}
+/**
+ * clamp color values
+ * @param token
+ */
+function clamp(token) {
+    if (token.kin == ColorKind.RGB || token.kin == ColorKind.RGBA) {
+        token.chi.filter((token) => ![EnumToken.LiteralTokenType, EnumToken.CommaTokenType, EnumToken.WhitespaceTokenType].includes(token.typ)).forEach((token, index) => {
+            if (index <= 2) {
+                if (token.typ == EnumToken.NumberTokenType) {
+                    token.val = String(minmax(+token.val, 0, 255));
+                }
+                else if (token.typ == EnumToken.PercentageTokenType) {
+                    token.val = String(minmax(+token.val, 0, 100));
+                }
+            }
+            else {
+                if (token.typ == EnumToken.NumberTokenType) {
+                    token.val = String(minmax(+token.val, 0, 1));
+                }
+                else if (token.typ == EnumToken.PercentageTokenType) {
+                    token.val = String(minmax(+token.val, 0, 100));
+                }
+            }
+        });
+    }
+    return token;
+}
+function getNumber(token) {
+    if (token.typ == EnumToken.IdenTokenType && token.val == 'none') {
+        return 0;
+    }
+    // @ts-ignore
+    return token.typ == EnumToken.PercentageTokenType ? token.val / 100 : +token.val;
+}
+/**
+ * convert angle to turn
+ * @param token
+ */
+function getAngle(token) {
+    if (token.typ == EnumToken.IdenTokenType) {
+        if (token.val == 'none') {
+            return 0;
+        }
+    }
+    if (token.typ == EnumToken.AngleTokenType) {
+        switch (token.unit) {
+            case 'deg':
+                // @ts-ignore
+                return token.val / 360;
+            case 'rad':
+                // @ts-ignore
+                return token.val / (2 * Math.PI);
+            case 'grad':
+                // @ts-ignore
+                return token.val / 400;
+            case 'turn':
+                // @ts-ignore
+                return +token.val;
+        }
+    }
+    // @ts-ignore
+    return token.val / 360;
+}
+function filterValues(values) {
+    let i = 0;
+    for (; i < values.length; i++) {
+        if (values[i].typ == EnumToken.ImportantTokenType && values[i - 1]?.typ == EnumToken.WhitespaceTokenType) {
+            values.splice(i - 1, 1);
+        }
+        else if (funcLike.includes(values[i].typ) && !['var', 'calc'].includes(values[i].val) && values[i + 1]?.typ == EnumToken.WhitespaceTokenType) {
+            values.splice(i + 1, 1);
+        }
+    }
+    return values;
+}
+
+export { clamp, filterValues, getAngle, getNumber, reduceNumber };

package/dist/lib/ast/walk.js

@@ -1,5 +1,3 @@
-import { EnumToken } from './types.js';
-
 var WalkerOptionEnum;
 (function (WalkerOptionEnum) {
     WalkerOptionEnum[WalkerOptionEnum["Ignore"] = 0] = "Ignore";
@@ -46,7 +44,7 @@ function* walk(node, filter) {
     }
 }
 /**
- * walk ast values
+ * walk ast node value tokens
  * @param values
  * @param root
  * @param filter
@@ -113,10 +111,38 @@ function* walkValues(values, root = null, filter, reverse) {
                 stack.unshift(...sliced);
             }
         }
-        else if (value.typ == EnumToken.BinaryExpressionTokenType) {
-            map.set(value.l, value);
-            map.set(value.r, value);
-            stack.unshift(value.l, value.r);
+        else {
+            const values = [];
+            if ('l' in value && value.l != null) {
+                // @ts-ignore
+                values.push(value.l);
+                // @ts-ignore
+                map.set(value.l, value);
+            }
+            if ('op' in value && typeof value.op == 'object') {
+                values.push(value.op);
+                // @ts-ignore
+                map.set(value.op, value);
+            }
+            if ('r' in value && value.r != null) {
+                if (Array.isArray(value.r)) {
+                    for (const r of value.r) {
+                        // @ts-ignore
+                        values.push(r);
+                        // @ts-ignore
+                        map.set(r, value);
+                    }
+                }
+                else {
+                    // @ts-ignore
+                    values.push(value.r);
+                    // @ts-ignore
+                    map.set(value.r, value);
+                }
+            }
+            if (values.length > 0) {
+                stack.unshift(...values);
+            }
         }
         if (eventType == WalkerValueEvent.Leave && filter.fn != null) {
             const isValid = filter.type == null || value.typ == filter.type ||

package/dist/lib/fs/resolve.js

@@ -1,4 +1,8 @@
 const matchUrl = /^(https?:)?\/\//;
+/**
+ * return the directory name of a path
+ * @param path
+ */
 function dirname(path) {
     if (path == '/' || path === '') {
         return path;
@@ -47,6 +51,12 @@ function splitPath(result) {
     }
     return { parts, i };
 }
+/**
+ * resolve path
+ * @param url
+ * @param currentDirectory
+ * @param cwd
+ */
 function resolve(url, currentDirectory, cwd) {
     if (matchUrl.test(url)) {
         return {