@tbela99/css-parser 1.3.3 → 1.4.0

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

@@ -2,9 +2,6 @@ const epsilon = 1e-5;
 function identity() {
     return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 }
-function pLength(point) {
-    return Math.sqrt(point[0] * point[0] + point[1] * point[1] + point[2] * point[2]);
-}
 function normalize(point) {
     const [x, y, z] = point;
     const norm = Math.sqrt(point[0] * point[0] + point[1] * point[1] + point[2] * point[2]);
@@ -32,8 +29,14 @@ function multiply(matrixA, matrixB) {
 function inverse(matrix) {
     // Create augmented matrix [matrix | identity]
     let augmented = [
-        1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,
-        1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1
+        ...matrix.slice(0, 4),
+        1, 0, 0, 0,
+        ...matrix.slice(4, 8),
+        0, 1, 0, 0,
+        ...matrix.slice(8, 12),
+        0, 0, 1, 0,
+        ...matrix.slice(12, 16),
+        0, 0, 0, 1
     ];
     // Gaussian elimination with partial pivoting
     for (let col = 0; col < 4; col++) {
@@ -73,24 +76,9 @@ function inverse(matrix) {
     // Extract the inverse from the right side of the augmented matrix
     return augmented.slice(0, 16);
 }
-// function transpose(matrix: Matrix): Matrix {
-//     // Crée une nouvelle matrice vide 4x4
-//     // @ts-ignore
-//     let transposed: Matrix = [[], [], [], []] as Matrix;
-//
-//     // Parcourt chaque ligne et colonne pour transposer
-//     for (let i = 0; i < 4; i++) {
-//
-//         for (let j = 0; j < 4; j++) {
-//
-//             transposed[j][i] = matrix[i][j];
-//         }
-//     }
-//
-//     return transposed;
-// }
 function round(number) {
-    return Math.abs(number) < epsilon ? 0 : +number.toPrecision(6);
+    const rounded = Math.round(number);
+    return Math.abs(rounded - number) <= epsilon ? rounded : +number.toPrecision(6);
 }
 // translate3d(25.9808px, 0, 15px ) rotateY(60deg) skewX(49.9999deg) scale(1, 1.2)
 // translate → rotate → skew → scale
@@ -113,7 +101,7 @@ function decompose(original) {
         perspectiveMatrix[15] = 1;
         // @ts-ignore
         const inverted = inverse(original.slice());
-        if (!inverted) {
+        if (inverted === null) {
             return null;
         }
         const transposedInverse = transposeMatrix4(inverted);
@@ -134,8 +122,13 @@ function decompose(original) {
     const row0 = [matrix[0], matrix[1], matrix[2]];
     const row1 = [matrix[4], matrix[5], matrix[6]];
     const row2 = [matrix[8], matrix[9], matrix[10]];
+    const cross = [
+        row1[1] * row2[2] - row1[2] * row2[1],
+        row1[2] * row2[0] - row1[0] * row2[2],
+        row1[0] * row2[1] - row1[1] * row2[0],
+    ];
     // Compute scale
-    const scaleX = pLength(row0);
+    const scaleX = Math.hypot(...row0);
     const row0Norm = normalize(row0);
     const skewXY = dot(row0Norm, row1);
     const row1Proj = [
@@ -143,7 +136,7 @@ function decompose(original) {
         row1[1] - skewXY * row0Norm[1],
         row1[2] - skewXY * row0Norm[2]
     ];
-    const scaleY = pLength(row1Proj);
+    const scaleY = Math.hypot(...row1Proj);
     const row1Norm = normalize(row1Proj);
     const skewXZ = dot(row0Norm, row2);
     const skewYZ = dot(row1Norm, row2);
@@ -152,8 +145,9 @@ function decompose(original) {
         row2[1] - skewXZ * row0Norm[1] - skewYZ * row1Norm[1],
         row2[2] - skewXZ * row0Norm[2] - skewYZ * row1Norm[2]
     ];
-    const scaleZ = pLength(row2Proj);
     const row2Norm = normalize(row2Proj);
+    const determinant = row0[0] * cross[0] + row0[1] * cross[1] + row0[2] * cross[2];
+    const scaleZ = Math.hypot(...row2Proj) * (determinant < 0 ? -1 : 1);
     // Build rotation matrix from orthonormalized vectors
     const r00 = row0Norm[0], r01 = row1Norm[0], r02 = row2Norm[0];
     const r10 = row0Norm[1], r11 = row1Norm[1], r12 = row2Norm[1];
@@ -190,7 +184,6 @@ function decompose(original) {
         qz = 0.25 * s;
     }
     [qx, qy, qz] = toZero([qx, qy, qz]);
-    // const q = gcd(qx, gcd(qy, qz));
     let q = [Math.abs(qx), Math.abs(qy), Math.abs(qz)].reduce((acc, curr) => {
         if (acc == 0 || (curr > 0 && curr < acc)) {
             acc = curr;
@@ -235,16 +228,16 @@ function toZero(v) {
 // https://drafts.csswg.org/css-transforms-1/#2d-matrix
 function is2DMatrix(matrix) {
     // m13,m14,  m23, m24, m31, m32, m34, m43 are all 0
-    return matrix[0 * 4 + 2] === 0 &&
-        matrix[0 * 4 + 3] === 0 &&
-        matrix[1 * 4 + 2] === 0 &&
-        matrix[1 * 4 + 3] === 0 &&
-        matrix[2 * 4 + 0] === 0 &&
-        matrix[2 * 4 + 1] === 0 &&
-        matrix[2 * 4 + 3] === 0 &&
-        matrix[3 * 4 + 2] === 0 &&
-        matrix[2 * 4 + 2] === 1 &&
-        matrix[3 * 4 + 3] === 1;
+    return matrix[2] === 0 &&
+        matrix[3] === 0 &&
+        matrix[6] === 0 &&
+        matrix[7] === 0 &&
+        matrix[8] === 0 &&
+        matrix[9] === 0 &&
+        matrix[11] === 0 &&
+        matrix[14] === 0 &&
+        matrix[10] === 1 &&
+        matrix[15] === 1;
 }
 
 export { decompose, epsilon, identity, is2DMatrix, multiply, round, toZero };

package/dist/lib/ast/types.js

@@ -19,14 +19,26 @@ var ValidationLevel;
      * disable validation
      */
     ValidationLevel[ValidationLevel["None"] = 0] = "None";
+    /**
+     * validate selectors
+     */
+    ValidationLevel[ValidationLevel["Selector"] = 1] = "Selector";
+    /**
+     * validate at-rules
+     */
+    ValidationLevel[ValidationLevel["AtRule"] = 2] = "AtRule";
+    /**
+     * validate declarations
+     */
+    ValidationLevel[ValidationLevel["Declaration"] = 4] = "Declaration";
     /**
      * validate selectors and at-rules
      */
-    ValidationLevel[ValidationLevel["Default"] = 1] = "Default";
+    ValidationLevel[ValidationLevel["Default"] = 3] = "Default";
     /**
      * validate selectors, at-rules and declarations
      */
-    ValidationLevel[ValidationLevel["All"] = 2] = "All"; // selectors + at-rules + declarations
+    ValidationLevel[ValidationLevel["All"] = 7] = "All"; // selectors + at-rules + declarations
 })(ValidationLevel || (ValidationLevel = {}));
 /**
  * enum of all token types
@@ -415,6 +427,23 @@ var EnumToken;
      * invalid declaration node type
      */
     EnumToken[EnumToken["InvalidDeclarationNodeType"] = 94] = "InvalidDeclarationNodeType";
+    /* css module nodes */
+    /**
+     * composes token node type
+     */
+    EnumToken[EnumToken["ComposesSelectorNodeType"] = 95] = "ComposesSelectorNodeType";
+    /**
+     * css variable token type
+     */
+    EnumToken[EnumToken["CssVariableTokenType"] = 96] = "CssVariableTokenType";
+    /**
+     * css variable import token type
+     */
+    EnumToken[EnumToken["CssVariableImportTokenType"] = 97] = "CssVariableImportTokenType";
+    /**
+     * css variable declaration map token type
+     */
+    EnumToken[EnumToken["CssVariableDeclarationMapTokenType"] = 98] = "CssVariableDeclarationMapTokenType";
     /* aliases */
     /**
      * alias for time token type
@@ -531,7 +560,7 @@ var EnumToken;
 var ColorType;
 (function (ColorType) {
     /**
-     * system colors
+     * deprecated system colors
      */
     ColorType[ColorType["SYS"] = 0] = "SYS";
     /**
@@ -539,7 +568,7 @@ var ColorType;
      */
     ColorType[ColorType["DPSYS"] = 1] = "DPSYS";
     /**
-     * colors as literals
+     * named colors
      */
     ColorType[ColorType["LIT"] = 2] = "LIT";
     /**
@@ -639,5 +668,47 @@ var ColorType;
      */
     ColorType[ColorType["DEVICE_CMYK"] = 7] = "DEVICE_CMYK";
 })(ColorType || (ColorType = {}));
+var ModuleCaseTransformEnum;
+(function (ModuleCaseTransformEnum) {
+    /**
+     * export class names as-is
+     */
+    ModuleCaseTransformEnum[ModuleCaseTransformEnum["IgnoreCase"] = 1] = "IgnoreCase";
+    /**
+     * transform mapping key name to camel case
+     */
+    ModuleCaseTransformEnum[ModuleCaseTransformEnum["CamelCase"] = 2] = "CamelCase";
+    /**
+     * transform class names and mapping key name to camel case
+     */
+    ModuleCaseTransformEnum[ModuleCaseTransformEnum["CamelCaseOnly"] = 4] = "CamelCaseOnly";
+    /**
+     * transform mapping key name to dash case
+     */
+    ModuleCaseTransformEnum[ModuleCaseTransformEnum["DashCase"] = 8] = "DashCase";
+    /**
+     * transform class names and mapping key name to dash case
+     */
+    ModuleCaseTransformEnum[ModuleCaseTransformEnum["DashCaseOnly"] = 16] = "DashCaseOnly";
+})(ModuleCaseTransformEnum || (ModuleCaseTransformEnum = {}));
+var ModuleScopeEnumOptions;
+(function (ModuleScopeEnumOptions) {
+    /**
+     * use the global scope
+     */
+    ModuleScopeEnumOptions[ModuleScopeEnumOptions["Global"] = 32] = "Global";
+    /**
+     * use the local scope
+     */
+    ModuleScopeEnumOptions[ModuleScopeEnumOptions["Local"] = 64] = "Local";
+    /**
+     * do not allow selector without an id or class
+     */
+    ModuleScopeEnumOptions[ModuleScopeEnumOptions["Pure"] = 128] = "Pure";
+    /**
+     * export using ICSS module format
+     */
+    ModuleScopeEnumOptions[ModuleScopeEnumOptions["ICSS"] = 256] = "ICSS";
+})(ModuleScopeEnumOptions || (ModuleScopeEnumOptions = {}));
 
-export { ColorType, EnumToken, SyntaxValidationResult, ValidationLevel };
+export { ColorType, EnumToken, ModuleCaseTransformEnum, ModuleScopeEnumOptions, SyntaxValidationResult, ValidationLevel };

package/dist/lib/ast/walk.js

@@ -12,28 +12,28 @@ var WalkerOptionEnum;
      */
     WalkerOptionEnum[WalkerOptionEnum["Stop"] = 2] = "Stop";
     /**
-     * ignore node and process children
+     * ignore the current node and process its children
      */
     WalkerOptionEnum[WalkerOptionEnum["Children"] = 4] = "Children";
     /**
-     * ignore children
+     * ignore the current node children
      */
     WalkerOptionEnum[WalkerOptionEnum["IgnoreChildren"] = 8] = "IgnoreChildren";
 })(WalkerOptionEnum || (WalkerOptionEnum = {}));
 /**
  * event types for the walkValues function
  */
-var WalkerValueEvent;
-(function (WalkerValueEvent) {
+var WalkerEvent;
+(function (WalkerEvent) {
     /**
      * enter node
      */
-    WalkerValueEvent[WalkerValueEvent["Enter"] = 1] = "Enter";
+    WalkerEvent[WalkerEvent["Enter"] = 1] = "Enter";
     /**
      * leave node
      */
-    WalkerValueEvent[WalkerValueEvent["Leave"] = 2] = "Leave";
-})(WalkerValueEvent || (WalkerValueEvent = {}));
+    WalkerEvent[WalkerEvent["Leave"] = 2] = "Leave";
+})(WalkerEvent || (WalkerEvent = {}));
 /**
  * walk ast nodes
  * @param node initial node
@@ -64,11 +64,10 @@ var WalkerValueEvent;
  * }
  * ```
  *
- * Using a filter to control the walk process:
+ * Using a {@link filter} function to control the ast traversal.  the filter function returns a value of type {@link WalkerOption}.
  *
  * ```ts
- *
- * import {walk} from '@tbela99/css-parser';
+ * 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)); }
@@ -84,17 +83,28 @@ var WalkerValueEvent;
  * }
  * `;
  *
- * for (const {node, parent, root} of walk(ast, (node) => {
+ * function filter(node) {
  *
  *     if (node.typ == EnumToken.AstRule && node.sel.includes('html')) {
  *
  *         // skip the children of the current node
  *         return WalkerOptionEnum.IgnoreChildren;
  *     }
- * })) {
+ * }
  *
- *     // do something with node
+ * 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, reverse) {
@@ -102,7 +112,8 @@ function* walk(node, filter, reverse) {
     const root = node;
     const map = new Map;
     let isNumeric = false;
-    while ((node = parents.shift())) {
+    let i = 0;
+    while ((node = parents[i++])) {
         let option = null;
         if (filter != null) {
             option = filter(node);
@@ -121,8 +132,8 @@ function* walk(node, filter, reverse) {
             yield { node, parent: map.get(node), root };
         }
         if ('chi' in node && (!isNumeric || ((option & WalkerOptionEnum.IgnoreChildren) === 0))) {
-            parents.unshift(...node.chi[reverse ? 'reverse' : 'slice']());
-            for (const child of node.chi.slice()) {
+            parents.splice(i, 0, ...node.chi[reverse ? 'reverse' : 'slice']());
+            for (const child of node.chi) {
                 map.set(child, node);
             }
         }
@@ -139,55 +150,68 @@ function* walk(node, filter, reverse) {
  *
  * ```ts
  *
- * import {EnumToken, walk} from '@tbela99/css-parser';
+ * 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)); }
- *
- * html,
- * body {
- *     line-height: 1.474;
- * }
- *
- * .ruler {
- *
- *     height: 10px;
- * }
  * `;
  *
- * for (const {value} of walkValues(result.ast.chi[0].chi[0].val, null, null,true)) {
+ * 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;
     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
         };
     }
     let isNumeric = false;
-    const eventType = filter.event ?? WalkerValueEvent.Enter;
+    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, WalkerValueEvent.Enter);
+                option = filter.fn(value, map.get(value) ?? root, WalkerEvent.Enter);
                 isNumeric = typeof option == 'number';
                 if (isNumeric && (option & WalkerOptionEnum.Stop)) {
                     return;
@@ -196,12 +220,15 @@ function* walkValues(values, root = null, filter, reverse) {
                     continue;
                 }
                 // @ts-ignore
-                if (option != null && typeof option == 'object' && 'typ' in option) {
-                    map.set(option, map.get(value) ?? root);
+                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);
                 }
             }
         }
-        // if ((eventType & WalkerValueEvent.Enter) && (!isNumeric || ((option as number) & WalkerOptionEnum.Children) === 0)) {
         yield {
             value,
             parent: map.get(value) ?? root,
@@ -210,7 +237,6 @@ function* walkValues(values, root = null, filter, reverse) {
             // @ts-ignore
             root: root ?? null
         };
-        // }
         if ('chi' in value && (!isNumeric || (option & WalkerOptionEnum.IgnoreChildren) === 0)) {
             const sliced = value.chi.slice();
             for (const child of sliced) {
@@ -222,12 +248,12 @@ function* walkValues(values, root = null, filter, reverse) {
             const values = [];
             if ('l' in value && value.l != null) {
                 // @ts-ignore
-                values[reverse ? 'push' : 'unshift'](value.l);
+                values.push(value.l);
                 // @ts-ignore
                 map.set(value.l, value);
             }
             if ('op' in value && typeof value.op == 'object') {
-                values[reverse ? 'push' : 'unshift'](value.op);
+                values.push(value.op);
                 // @ts-ignore
                 map.set(value.op, value);
             }
@@ -235,14 +261,14 @@ function* walkValues(values, root = null, filter, reverse) {
                 if (Array.isArray(value.r)) {
                     for (const r of value.r) {
                         // @ts-ignore
-                        values[reverse ? 'push' : 'unshift'](r);
+                        values.push(r);
                         // @ts-ignore
                         map.set(r, value);
                     }
                 }
                 else {
                     // @ts-ignore
-                    values[reverse ? 'push' : 'unshift'](value.r);
+                    values.push(value.r);
                     // @ts-ignore
                     map.set(value.r, value);
                 }
@@ -251,31 +277,24 @@ function* walkValues(values, root = null, filter, reverse) {
                 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), WalkerValueEvent.Leave);
+                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 (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);
                 }
             }
         }
-        // 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;
     }
 }
 
-export { WalkerOptionEnum, WalkerValueEvent, walk, walkValues };
+export { WalkerEvent, WalkerOptionEnum, walk, walkValues };

package/dist/lib/fs/resolve.js

@@ -10,6 +10,9 @@ function dirname(path) {
     //
     //     return path;
     // }
+    if (path === '') {
+        return '';
+    }
     let i = 0;
     let parts = [''];
     for (; i < path.length; i++) {
@@ -17,9 +20,10 @@ function dirname(path) {
         if (chr == '/') {
             parts.push('');
         }
-        else if (chr == '?' || chr == '#') {
-            break;
-        }
+        // else if (chr == '?' || chr == '#') {
+        //
+        //     break;
+        // }
         else {
             parts[parts.length - 1] += chr;
         }
@@ -33,6 +37,12 @@ function dirname(path) {
  * @private
  */
 function splitPath(result) {
+    if (result.length == 0) {
+        return { parts: [], i: 0 };
+    }
+    if (result === '/') {
+        return { parts: ['/'], i: 0 };
+    }
     const parts = [''];
     let i = 0;
     for (; i < result.length; i++) {
@@ -74,6 +84,23 @@ function resolve(url, currentDirectory, cwd) {
             relative: url
         };
     }
+    cwd ??= '';
+    currentDirectory ??= '';
+    if (currentDirectory !== '' && url.startsWith(currentDirectory + '/')) {
+        return {
+            absolute: url,
+            relative: url.slice(currentDirectory.length + 1)
+        };
+    }
+    if (currentDirectory === '' && cwd !== '' && url.startsWith(cwd == '/' ? cwd : cwd + '/')) {
+        cwd = normalize(cwd);
+        const absolute = normalize(url);
+        const prefix = cwd == '/' ? cwd : cwd + '/';
+        return {
+            absolute,
+            relative: absolute.startsWith(prefix) ? absolute.slice(prefix.length) : diff(absolute, cwd)
+        };
+    }
     if (matchUrl.test(currentDirectory)) {
         const path = new URL(url, currentDirectory).href;
         return {
@@ -88,9 +115,15 @@ function resolve(url, currentDirectory, cwd) {
     else if (currentDirectory.charAt(0) == '/') {
         result = dirname(currentDirectory) + '/' + url;
     }
-    let { parts, i } = splitPath(result);
-    const absolute = parts.join('/');
-    const { parts: dirs } = splitPath(cwd ?? currentDirectory);
+    const absolute = normalize(result);
+    return {
+        absolute,
+        relative: absolute === '' ? '' : diff(absolute, cwd ?? currentDirectory),
+    };
+}
+function diff(path1, path2) {
+    let { parts } = splitPath(path1);
+    const { parts: dirs } = splitPath(path2);
     for (const p of dirs) {
         if (parts[0] == p) {
             parts.shift();
@@ -99,10 +132,36 @@ function resolve(url, currentDirectory, cwd) {
             parts.unshift('..');
         }
     }
-    return {
-        absolute,
-        relative: parts.join('/') + (i < result.length ? result.slice(i) : '')
-    };
+    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('');
+            }
+        }
+        else if (chr == '?' || chr == '#') {
+            break;
+        }
+        else {
+            parts[parts.length - 1] += chr;
+        }
+    }
+    let k = -1;
+    while (++k < parts.length) {
+        if (parts[k] == '.') {
+            parts.splice(k--, 1);
+        }
+        else if (parts[k] == '..') {
+            parts.splice(k - 1, 2);
+            k -= 2;
+        }
+    }
+    return (path.charAt(0) == '/' ? '/' : '') + parts.join('/');
 }
 
 export { dirname, matchUrl, resolve };

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

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