@tbela99/css-parser 1.4.1 → 1.4.3

package/dist/lib/ast/walk.js

@@ -110,29 +110,41 @@ var WalkerEvent;
 function* walk(node, filter, reverse) {
     const parents = [node];
     const root = node;
-    const map = new Map;
+    const map = new Map();
     let isNumeric = false;
     let i = 0;
     while ((node = parents[i++])) {
         let option = null;
         if (filter != null) {
             option = filter(node);
-            isNumeric = typeof option == 'number';
+            isNumeric = typeof option == "number";
             if (isNumeric) {
-                if ((option & WalkerOptionEnum.Ignore)) {
+                if (option & WalkerOptionEnum.Ignore) {
                     continue;
                 }
-                if ((option & WalkerOptionEnum.Stop)) {
+                if (option & WalkerOptionEnum.Stop) {
                     break;
                 }
             }
         }
         if (!isNumeric || (option & WalkerOptionEnum.Children) === 0) {
             // @ts-ignore
-            yield { node, parent: map.get(node), root };
+            yield {
+                node,
+                parent: map.get(node),
+                root,
+                // @ts-expect-error
+                parents: function* () {
+                    let parent = map.get(node);
+                    while (parent != null) {
+                        yield parent;
+                        parent = map.get(parent);
+                    }
+                },
+            };
         }
-        if ('chi' in node && (!isNumeric || ((option & WalkerOptionEnum.IgnoreChildren) === 0))) {
-            parents.splice(i, 0, ...node.chi[reverse ? 'reverse' : '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);
             }
@@ -188,44 +200,70 @@ function* walk(node, filter, reverse) {
  */
 function* walkValues(values, root = null, filter, reverse) {
     const stack = values.slice();
-    const map = new Map;
+    const map = new Map();
+    const used = new Set();
     let previous = null;
-    if (filter != null && typeof filter == 'function') {
+    if (filter != null && typeof filter == "function") {
         filter = {
             event: WalkerEvent.Enter,
-            fn: filter
+            fn: filter,
         };
     }
     else if (filter == null) {
         filter = {
-            event: WalkerEvent.Enter
+            event: WalkerEvent.Enter,
         };
     }
     let isNumeric = false;
+    let value;
+    let option;
+    let node;
+    // const parents: Token[] = [];
     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 & WalkerEvent.Enter)) {
-            const isValid = filter.type == null || value.typ == filter.type ||
+        value = reverse ? stack.pop() : stack.shift();
+        option = null;
+        node = map.get(value) ?? null;
+        if (used.has(value)) {
+            continue;
+        }
+        used.add(value);
+        // parents.length = 0;
+        // while (node != null) {
+        //     parents.push(node);
+        //     node = map.get(node) ?? null;
+        // }
+        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));
+                (typeof filter.type == "function" && filter.type(value));
             if (isValid) {
-                option = filter.fn(value, map.get(value) ?? root, WalkerEvent.Enter);
-                isNumeric = typeof option == 'number';
-                if (isNumeric && (option & WalkerOptionEnum.Stop)) {
+                option = filter.fn(value, map.get(value) ?? root, WalkerEvent.Enter, 
+                // @ts-expect-error
+                function* () {
+                    // @ts-expect-error
+                    let parent = map.get(node);
+                    console.debug({ parent });
+                    while (parent != null) {
+                        yield parent;
+                        parent = map.get(parent);
+                    }
+                });
+                isNumeric = typeof option == "number";
+                if (isNumeric && option & WalkerOptionEnum.Stop) {
                     return;
                 }
-                if (isNumeric && (option & WalkerOptionEnum.Ignore)) {
+                if (isNumeric && option & WalkerOptionEnum.Ignore) {
                     continue;
                 }
                 // @ts-ignore
-                if (option != null && typeof option == 'object' && ('typ' in option || Array.isArray(option))) {
+                if (option != null && typeof option == "object" && ("typ" in option || Array.isArray(option))) {
                     const op = Array.isArray(option) ? option : [option];
                     for (const o of op) {
                         map.set(o, map.get(value) ?? root);
                     }
-                    stack[reverse ? 'push' : 'unshift'](...op);
+                    stack[reverse ? "push" : "unshift"](...op);
                 }
             }
         }
@@ -235,61 +273,79 @@ function* walkValues(values, root = null, filter, reverse) {
             previousValue: previous,
             nextValue: stack[0] ?? null,
             // @ts-ignore
-            root: root ?? null
+            root: root ?? null,
+            // @ts-expect-error
+            parents: function* () {
+                // @ts-expect-error
+                let result = map.get(node) ?? root;
+                let next;
+                do {
+                    yield result;
+                    next = map.get(result) ?? root;
+                    if (next == result) {
+                        break;
+                    }
+                    result = next;
+                } while (result != null);
+            },
         };
-        if ('chi' in value && (!isNumeric || (option & WalkerOptionEnum.IgnoreChildren) === 0)) {
-            const sliced = value.chi.slice();
-            for (const child of sliced) {
-                map.set(child, value);
-            }
-            stack[reverse ? 'push' : 'unshift'](...sliced);
-        }
-        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 (!isNumeric || (option & WalkerOptionEnum.IgnoreChildren) === 0) {
+            if ("chi" in value) {
+                const sliced = value.chi.slice();
+                for (const child of sliced) {
+                    map.set(child, value);
+                }
+                stack[reverse ? "push" : "unshift"](...sliced);
             }
-            if ('r' in value && value.r != null) {
-                if (Array.isArray(value.r)) {
-                    for (const r of 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") {
+                    // @ts-ignore
+                    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(r);
+                        values.push(value.r);
                         // @ts-ignore
-                        map.set(r, value);
+                        map.set(value.r, value);
                     }
                 }
-                else {
-                    // @ts-ignore
-                    values.push(value.r);
-                    // @ts-ignore
-                    map.set(value.r, value);
+                if (values.length > 0) {
+                    stack[reverse ? "push" : "unshift"](...values);
                 }
             }
-            if (values.length > 0) {
-                stack[reverse ? 'push' : 'unshift'](...values);
-            }
         }
-        if ((eventType & WalkerEvent.Leave) && filter.fn != null) {
-            const isValid = filter.type == null || value.typ == filter.type ||
+        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));
+                (typeof filter.type == "function" && filter.type(value));
             if (isValid) {
                 option = filter.fn(value, map.get(value), WalkerEvent.Leave);
                 // @ts-ignore
-                if (option != null && ('typ' in option || Array.isArray(option))) {
+                if (option != null && ("typ" in option || Array.isArray(option))) {
                     const op = Array.isArray(option) ? option : [option];
                     for (const o of op) {
                         map.set(o, map.get(value) ?? root);
                     }
-                    stack[reverse ? 'push' : 'unshift'](...op);
+                    stack[reverse ? "push" : "unshift"](...op);
                 }
             }
         }

package/dist/lib/fs/resolve.d.ts

@@ -0,0 +1,20 @@
+export declare const matchUrl: RegExp;
+/**
+ * return the directory name of a path
+ * @param path
+ *
+ * @private
+ */
+export declare function dirname(path: string): string;
+/**
+ * resolve path
+ * @param url url or path to resolve
+ * @param currentDirectory directory used to resolve the path
+ * @param cwd current working directory
+ *
+ * @private
+ */
+export declare function resolve(url: string, currentDirectory: string, cwd?: string): {
+    absolute: string;
+    relative: string;
+};

package/dist/lib/fs/resolve.js

@@ -6,30 +6,22 @@ const matchUrl = /^(https?:)?\/\//;
  * @private
  */
 function dirname(path) {
-    // if (path == '/' || path === '') {
-    //
-    //     return path;
-    // }
-    if (path === '') {
-        return '';
+    if (path === "") {
+        return "";
     }
     let i = 0;
-    let parts = [''];
+    let parts = [""];
     for (; i < path.length; i++) {
         const chr = path.charAt(i);
-        if (chr == '/') {
-            parts.push('');
+        if (chr == "/") {
+            parts.push("");
         }
-        // else if (chr == '?' || chr == '#') {
-        //
-        //     break;
-        // }
         else {
             parts[parts.length - 1] += chr;
         }
     }
     parts.pop();
-    return parts.length == 0 ? '/' : parts.join('/');
+    return parts.length == 0 ? "/" : parts.join("/");
 }
 /**
  * split path
@@ -40,17 +32,17 @@ function splitPath(result) {
     if (result.length == 0) {
         return { parts: [], i: 0 };
     }
-    if (result === '/') {
-        return { parts: ['/'], i: 0 };
+    if (result === "/") {
+        return { parts: ["/"], i: 0 };
     }
-    const parts = [''];
+    const parts = [""];
     let i = 0;
     for (; i < result.length; i++) {
         const chr = result.charAt(i);
-        if (chr == '/') {
-            parts.push('');
+        if (chr == "/") {
+            parts.push("");
         }
-        else if (chr == '?' || chr == '#') {
+        else if (chr == "?" || chr == "#") {
             break;
         }
         else {
@@ -59,10 +51,10 @@ function splitPath(result) {
     }
     let k = -1;
     while (++k < parts.length) {
-        if (parts[k] == '.') {
+        if (parts[k] == ".") {
             parts.splice(k--, 1);
         }
-        else if (parts[k] == '..') {
+        else if (parts[k] == "..") {
             parts.splice(k - 1, 2);
             k -= 2;
         }
@@ -81,44 +73,44 @@ function resolve(url, currentDirectory, cwd) {
     if (matchUrl.test(url)) {
         return {
             absolute: url,
-            relative: url
+            relative: url,
         };
     }
-    cwd ??= '';
-    currentDirectory ??= '';
-    if (currentDirectory !== '' && url.startsWith(currentDirectory + '/')) {
+    cwd ??= "";
+    currentDirectory ??= "";
+    if (currentDirectory !== "" && url.startsWith(currentDirectory + "/")) {
         return {
             absolute: url,
-            relative: url.slice(currentDirectory.length + 1)
+            relative: url.slice(currentDirectory.length + 1),
         };
     }
-    if (currentDirectory === '' && cwd !== '' && url.startsWith(cwd == '/' ? cwd : cwd + '/')) {
+    if (currentDirectory === "" && cwd !== "" && url.startsWith(cwd == "/" ? cwd : cwd + "/")) {
         cwd = normalize(cwd);
         const absolute = normalize(url);
-        const prefix = cwd == '/' ? cwd : cwd + '/';
+        const prefix = cwd == "/" ? cwd : cwd + "/";
         return {
             absolute,
-            relative: absolute.startsWith(prefix) ? absolute.slice(prefix.length) : diff(absolute, cwd)
+            relative: absolute.startsWith(prefix) ? absolute.slice(prefix.length) : diff(absolute, cwd),
         };
     }
     if (matchUrl.test(currentDirectory)) {
         const path = new URL(url, currentDirectory).href;
         return {
             absolute: path,
-            relative: path
+            relative: path,
         };
     }
-    let result = '';
-    if (url.charAt(0) == '/') {
+    let result = "";
+    if (url.charAt(0) == "/") {
         result = url;
     }
-    else if (currentDirectory.charAt(0) == '/') {
-        result = dirname(currentDirectory) + '/' + url;
+    else if (currentDirectory.charAt(0) == "/") {
+        result = dirname(currentDirectory) + "/" + url;
     }
     const absolute = normalize(result);
     return {
         absolute,
-        relative: absolute === '' ? '' : diff(absolute, cwd ?? currentDirectory),
+        relative: absolute === "" ? "" : diff(absolute, cwd ?? currentDirectory),
     };
 }
 function diff(path1, path2) {
@@ -129,22 +121,22 @@ function diff(path1, path2) {
             parts.shift();
         }
         else {
-            parts.unshift('..');
+            parts.unshift("..");
         }
     }
-    return parts.join('/');
+    return parts.join("/");
 }
 function normalize(path) {
     let parts = [];
     let i = 0;
     for (; i < path.length; i++) {
         const chr = path.charAt(i);
-        if (chr == '/') {
-            if (parts.length == 0 || parts[parts.length - 1] !== '') {
-                parts.push('');
+        if (chr == "/") {
+            if (parts.length == 0 || parts[parts.length - 1] !== "") {
+                parts.push("");
             }
         }
-        else if (chr == '?' || chr == '#') {
+        else if (chr == "?" || chr == "#") {
             break;
         }
         else {
@@ -153,15 +145,15 @@ function normalize(path) {
     }
     let k = -1;
     while (++k < parts.length) {
-        if (parts[k] == '.') {
+        if (parts[k] == ".") {
             parts.splice(k--, 1);
         }
-        else if (parts[k] == '..') {
+        else if (parts[k] == "..") {
             parts.splice(k - 1, 2);
             k -= 2;
         }
     }
-    return (path.charAt(0) == '/' ? '/' : '') + parts.join('/');
+    return (path.charAt(0) == "/" ? "/" : "") + parts.join("/");
 }
 
 export { dirname, matchUrl, resolve };

package/dist/lib/parser/declaration/list.d.ts

@@ -0,0 +1,16 @@
+import type { AstNode, PropertyListOptions, Token } from "../../../@types/index.d.ts";
+import { PropertySet } from "./set.ts";
+import { PropertyMap } from "./map.ts";
+export declare class PropertyList {
+    protected options: PropertyListOptions;
+    protected declarations: Map<string, AstNode | PropertySet | PropertyMap>;
+    constructor(options?: PropertyListOptions);
+    set(nam: string, value: string | Token[]): this;
+    add(...declarations: AstNode[]): this;
+    [Symbol.iterator](): {
+        next(): {
+            value: AstNode;
+            done: boolean;
+        };
+    };
+}

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

@@ -1,13 +1,8 @@
 import { PropertySet } from './set.js';
 import { getConfig } from '../utils/config.js';
-import { EnumToken } from '../../ast/types.js';
-import '../../ast/minify.js';
-import '../../ast/walk.js';
-import { parseString } from '../parse.js';
-import '../tokenize.js';
-import '../../syntax/color/utils/constants.js';
-import '../../renderer/sourcemap/lib/encode.js';
 import { PropertyMap } from './map.js';
+import { parseString } from '../parse.js';
+import { EnumToken } from '../../ast/types.js';
 
 const config = getConfig();
 class PropertyList {
@@ -15,23 +10,29 @@ class PropertyList {
     declarations;
     constructor(options = {}) {
         this.options = options;
-        this.declarations = new Map;
+        this.declarations = new Map();
     }
     set(nam, value) {
         return this.add({
             typ: EnumToken.DeclarationNodeType,
             nam,
-            val: Array.isArray(value) ? value : parseString(String(value))
+            val: Array.isArray(value) ? value : parseString(String(value)),
         });
     }
     add(...declarations) {
         let name;
         for (const declaration of declarations) {
-            name = declaration.typ != EnumToken.DeclarationNodeType ? null : declaration.nam.toLowerCase();
+            name =
+                declaration.typ != EnumToken.DeclarationNodeType
+                    ? null
+                    : declaration.nam.toLowerCase();
             if (declaration.typ != EnumToken.DeclarationNodeType ||
-                'composes' === name ||
-                (typeof this.options.removeDuplicateDeclarations === 'string' && this.options.removeDuplicateDeclarations === name) ||
-                (Array.isArray(this.options.removeDuplicateDeclarations) ? this.options.removeDuplicateDeclarations.includes(declaration.nam) : !this.options.removeDuplicateDeclarations)) {
+                "composes" === name ||
+                (typeof this.options.removeDuplicateDeclarations === "string" &&
+                    this.options.removeDuplicateDeclarations === name) ||
+                (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;
             }
@@ -44,24 +45,24 @@ class PropertyList {
             let shorthand;
             if (propertyName in config.properties) {
                 // @ts-ignore
-                if ('map' in config.properties[propertyName]) {
-                    shortHandType = 'map';
+                if ("map" in config.properties[propertyName]) {
+                    shortHandType = "map";
                     // @ts-ignore
                     shorthand = config.properties[propertyName].map;
                 }
                 else {
-                    shortHandType = 'set';
+                    shortHandType = "set";
                     // @ts-ignore
                     shorthand = config.properties[propertyName].shorthand;
                 }
             }
             else if (propertyName in config.map) {
-                shortHandType = 'map';
+                shortHandType = "map";
                 // @ts-ignore
                 shorthand = config.map[propertyName].shorthand;
             }
             // @ts-ignore
-            if (shortHandType == 'map') {
+            if (shortHandType == "map") {
                 // @ts-ignore
                 if (!this.declarations.has(shorthand)) {
                     // @ts-ignore
@@ -69,19 +70,20 @@ class PropertyList {
                 }
                 // @ts-ignore
                 this.declarations.get(shorthand).add(declaration);
-                // return this;
             }
             // @ts-ignore
-            else if (shortHandType == 'set') {
+            else if (shortHandType == "set") {
                 // @ts-ignore
-                // const shorthand: string = <string>config.properties[propertyName].shorthand;
                 if (!this.declarations.has(shorthand)) {
                     // @ts-ignore
-                    this.declarations.set(shorthand, new PropertySet(config.properties[shorthand]));
+                    this.declarations.set(
+                    // @ts-ignore
+                    shorthand, 
+                    // @ts-ignore
+                    new PropertySet(config.properties[shorthand]));
                 }
                 // @ts-ignore
                 this.declarations.get(shorthand).add(declaration);
-                // return this;
             }
             else {
                 this.declarations.set(propertyName, declaration);
@@ -110,7 +112,7 @@ class PropertyList {
                     }
                 }
                 return value;
-            }
+            },
         };
     }
 }

package/dist/lib/parser/declaration/map.d.ts

@@ -0,0 +1,15 @@
+import type { AstDeclaration, ShorthandMapType } from "../../../@types/index.d.ts";
+import { PropertySet } from "./set.ts";
+export declare class PropertyMap {
+    protected config: ShorthandMapType;
+    protected declarations: Map<string, AstDeclaration | PropertySet>;
+    protected requiredCount: any;
+    protected pattern: string[];
+    constructor(config: ShorthandMapType);
+    add(declaration: AstDeclaration): this;
+    [Symbol.iterator](): ArrayIterator<AstDeclaration> | {
+        next(): IteratorResult<AstDeclaration>;
+    };
+    private matchTypes;
+    private removeDefaults;
+}