styimat 4.0.0 → 4.2.0

package/dist/styimat.js

@@ -11,6 +11,8 @@
  * 增强 math() 函数，支持复杂数学计算
  * 支持配置头
  * 支持 @import 语法
+ * 支持 @alias 语法
+ * 支持 @macro 宏定义系统
  */
 
 const styimat = (function() {
@@ -26,11 +28,13 @@ const styimat = (function() {
         convertLabToRGB: true,
         convertLchToRGB: true,
         enableP3: true,
-        enableMath: true, // 启用math()函数增强
-        mathPrecision: 6, // 数学计算精度
-        importBaseUrl: '', // @import 的基础URL
-        importCache: true, // 缓存导入的文件
-        importTimeout: 5000, // 导入超时时间（毫秒）
+        enableMath: true,
+        mathPrecision: 6,
+        importBaseUrl: '',
+        importCache: true,
+        importTimeout: 5000,
+        enableAlias: true,
+        enableMacros: true,
     };
 
     // 全局P3支持检测结果
@@ -38,11 +42,15 @@ const styimat = (function() {
     
     // 导入文件缓存
     const importCache = new Map();
+    
+    // 别名映射表
+    const aliasMap = new Map();
+    
+    // 宏定义存储
+    const macroRegistry = new Map();
 
     /**
      * 解析配置头
-     * @param {string} cssText - CSS文本
-     * @returns {Object} {config: 配置对象, css: 清理后的CSS}
      */
     function parseConfigHeader(cssText) {
         const config = { ...defaultConfig };
@@ -52,7 +60,6 @@ const styimat = (function() {
         for (let line of lines) {
             const trimmed = line.trim();
             
-            // 检查是否是配置行（以 # 开头）
             if (trimmed.startsWith('#')) {
                 const configLine = trimmed.substring(1).trim();
                 const firstSpace = configLine.indexOf(' ');
@@ -61,18 +68,14 @@ const styimat = (function() {
                     const key = configLine.substring(0, firstSpace).trim();
                     const value = configLine.substring(firstSpace + 1).trim();
                     
-                    // 转换配置值
                     const configKey = camelCase(key);
                     
                     if (configKey in config) {
-                        // 根据值的类型进行转换
                         if (value === 'true' || value === 'false') {
                             config[configKey] = value === 'true';
                         } else if (!isNaN(value) && value.trim() !== '') {
-                            // 数字类型
                             config[configKey] = Number(value);
                         } else {
-                            // 字符串类型
                             config[configKey] = value;
                         }
                     } else {
@@ -92,10 +95,266 @@ const styimat = (function() {
         };
     }
 
+    /**
+     * 解析 @alias 语句
+     */
+    function parseAliasStatements(cssText) {
+        const aliases = new Map();
+        const lines = cssText.split('\n');
+        const cleanLines = [];
+        
+        for (let line of lines) {
+            const trimmed = line.trim();
+            
+            if (trimmed.startsWith('@alias')) {
+                const aliasMatch = trimmed.match(/^@alias\s+([a-zA-Z0-9_-]+)\s+(.+?)\s*;$/);
+                if (aliasMatch) {
+                    const aliasName = aliasMatch[1];
+                    const originalProperty = aliasMatch[2];
+                    
+                    aliases.set(aliasName, originalProperty);
+                    continue;
+                }
+            }
+            
+            cleanLines.push(line);
+        }
+        
+        return {
+            aliases,
+            css: cleanLines.join('\n')
+        };
+    }
+
+    /**
+     * 解析 @macro 语句
+     */
+    function parseMacroStatements(cssText, config) {
+        if (!config.enableMacros) {
+            return { macros: new Map(), css: cssText };
+        }
+        
+        const macros = new Map();
+        const lines = cssText.split('\n');
+        const cleanLines = [];
+        let inMacroDefinition = false;
+        let currentMacroName = '';
+        let currentMacroParams = [];
+        let currentMacroBody = [];
+        let braceDepth = 0;
+        
+        for (let line of lines) {
+            const trimmed = line.trim();
+            
+            if (!inMacroDefinition && trimmed.startsWith('@macro')) {
+                const macroMatch = trimmed.match(/^@macro\s+([a-zA-Z0-9_-]+)\s*\(([^)]*)\)\s*\{$/);
+                if (macroMatch) {
+                    inMacroDefinition = true;
+                    currentMacroName = macroMatch[1];
+                    currentMacroParams = macroMatch[2]
+                        .split(',')
+                        .map(param => param.trim())
+                        .filter(param => param)
+                        .map(param => {
+                            const paramParts = param.split(':').map(p => p.trim());
+                            return {
+                                name: paramParts[0].slice(1),
+                                defaultValue: paramParts[1] || null
+                            };
+                        });
+                    currentMacroBody = [];
+                    braceDepth = 1;
+                    continue;
+                }
+            }
+            
+            if (inMacroDefinition) {
+                for (const char of line) {
+                    if (char === '{') braceDepth++;
+                    if (char === '}') braceDepth--;
+                }
+                
+                if (braceDepth === 0) {
+                    macros.set(currentMacroName, {
+                        params: currentMacroParams,
+                        body: currentMacroBody.join('\n')
+                    });
+                    
+                    inMacroDefinition = false;
+                    currentMacroName = '';
+                    currentMacroParams = [];
+                    currentMacroBody = [];
+                } else {
+                    currentMacroBody.push(line);
+                }
+                continue;
+            }
+            
+            cleanLines.push(line);
+        }
+        
+        return {
+            macros,
+            css: cleanLines.join('\n')
+        };
+    }
+
+    /**
+     * 应用宏调用
+     */
+    function applyMacroCalls(cssText, macros, config) {
+        if (!config.enableMacros || macros.size === 0) {
+            return cssText;
+        }
+        
+        const macroNames = Array.from(macros.keys()).map(name => 
+            name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        ).join('|');
+        
+        const macroCallRegex = new RegExp(`@(${macroNames})\\s*\\(([^)]*)\\)\\s*;?`, 'g');
+        
+        const processMacroCalls = (text) => {
+            let result = text;
+            let changed = false;
+            
+            do {
+                changed = false;
+                result = result.replace(macroCallRegex, (match, macroName, argsStr) => {
+                    changed = true;
+                    
+                    const macro = macros.get(macroName);
+                    if (!macro) {
+                        console.warn(`未定义的宏: ${macroName}`);
+                        return match;
+                    }
+                    
+                    const args = parseMacroArguments(argsStr, macro.params);
+                    return applyMacro(macro.body, args, config);
+                });
+            } while (changed);
+            
+            return result;
+        };
+        
+        return processMacroCalls(cssText);
+    }
+
+    /**
+     * 解析宏参数
+     */
+    function parseMacroArguments(argsStr, paramDefs) {
+        const argsMap = new Map();
+        const argValues = parseArgumentList(argsStr);
+        
+        for (let i = 0; i < paramDefs.length; i++) {
+            const param = paramDefs[i];
+            let value;
+            
+            if (i < argValues.length) {
+                value = argValues[i];
+            } else if (param.defaultValue !== null) {
+                value = param.defaultValue;
+            } else {
+                console.warn(`宏调用缺少必需参数: ${param.name}`);
+                value = '';
+            }
+            
+            argsMap.set(param.name, value);
+        }
+        
+        if (argValues.length > paramDefs.length) {
+            console.warn(`宏调用传递了过多参数，多余的参数将被忽略`);
+        }
+        
+        return argsMap;
+    }
+
+    /**
+     * 解析参数列表
+     */
+    function parseArgumentList(argsStr) {
+        const args = [];
+        let currentArg = '';
+        let inQuotes = false;
+        let quoteChar = '';
+        let parenDepth = 0;
+        let bracketDepth = 0;
+        
+        for (let i = 0; i < argsStr.length; i++) {
+            const char = argsStr[i];
+            
+            if ((char === '"' || char === "'") && !inQuotes) {
+                inQuotes = true;
+                quoteChar = char;
+            } else if (char === quoteChar && inQuotes) {
+                inQuotes = false;
+                quoteChar = '';
+            }
+            
+            if (!inQuotes) {
+                if (char === '(') parenDepth++;
+                if (char === ')') parenDepth--;
+                if (char === '[') bracketDepth++;
+                if (char === ']') bracketDepth--;
+            }
+            
+            if (char === ',' && !inQuotes && parenDepth === 0 && bracketDepth === 0) {
+                args.push(currentArg.trim());
+                currentArg = '';
+            } else {
+                currentArg += char;
+            }
+        }
+        
+        if (currentArg.trim()) {
+            args.push(currentArg.trim());
+        }
+        
+        return args;
+    }
+
+    /**
+     * 应用宏替换
+     */
+    function applyMacro(macroBody, args, config) {
+        let result = macroBody;
+        
+        for (const [paramName, paramValue] of args) {
+            const paramRegex = new RegExp(`\\$${paramName}`, 'g');
+            result = result.replace(paramRegex, paramValue);
+        }
+        
+        if (config.enableMacros) {
+            const macroNames = Array.from(macroRegistry.keys()).map(name => 
+                name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+            ).join('|');
+            
+            if (macroNames) {
+                const macroCallRegex = new RegExp(`@(${macroNames})\\s*\\(([^)]*)\\)\\s*;?`, 'g');
+                
+                let changed;
+                do {
+                    changed = false;
+                    result = result.replace(macroCallRegex, (match, macroName, argsStr) => {
+                        changed = true;
+                        
+                        const macro = macroRegistry.get(macroName);
+                        if (!macro) return match;
+                        
+                        const nestedArgs = parseMacroArguments(argsStr, macro.params);
+                        return applyMacro(macro.body, nestedArgs, config);
+                    });
+                } while (changed);
+            }
+        }
+        
+        result = processCSSValue(result, config);
+        
+        return result;
+    }
+
     /**
      * 将连字符分隔的字符串转换为驼峰命名
-     * @param {string} str - 输入字符串
-     * @returns {string} 驼峰命名字符串
      */
     function camelCase(str) {
         return str.replace(/-([a-z])/g, function(match, letter) {
@@ -105,7 +364,6 @@ const styimat = (function() {
 
     /**
      * 检测浏览器是否支持 Display P3
-     * @returns {boolean} 是否支持P3
      */
     function detectP3Support() {
         if (p3Supported !== null) return p3Supported;
@@ -126,36 +384,28 @@ const styimat = (function() {
     }
 
     /**
-     * 解析一行CSS（可能多个语句在同一行，可能最后一个语句没有分号）
-     * 返回格式：[{属性名:值}, {属性名:值}, ...]
-     * @param {string} cssString - 要解析的CSS字符串
-     * @returns {Array} 包含属性名值对象的数组
+     * 解析一行CSS
      */
-    function parseSingleLineCSS(cssString) {
-        // 移除首尾空白字符
+    function parseSingleLineCSS(cssString, aliases=[]) {
         let str = cssString.trim();
         
-        // 如果以分号结尾，移除最后一个分号
         if (str.endsWith(';')) {
             str = str.slice(0, -1);
         }
         
-        // 如果字符串为空，返回空数组
         if (!str) {
             return [];
         }
         
-        // 分割多个CSS声明（以分号分隔）
         const declarations = [];
         let currentDeclaration = '';
-        let inParens = 0; // 记录括号嵌套层数，用于处理函数内的分号
-        let inQuotes = false; // 是否在引号内
-        let quoteChar = ''; // 当前引号字符
+        let inParens = 0;
+        let inQuotes = false;
+        let quoteChar = '';
         
         for (let i = 0; i < str.length; i++) {
             const char = str[i];
             
-            // 处理引号
             if ((char === '"' || char === "'") && !inQuotes) {
                 inQuotes = true;
                 quoteChar = char;
@@ -164,7 +414,6 @@ const styimat = (function() {
                 quoteChar = '';
             }
             
-            // 处理括号（不在引号内时）
             if (!inQuotes) {
                 if (char === '(') {
                     inParens++;
@@ -173,7 +422,6 @@ const styimat = (function() {
                 }
             }
             
-            // 如果遇到分号且不在括号和引号内，则分割声明
             if (char === ';' && !inQuotes && inParens === 0) {
                 if (currentDeclaration.trim()) {
                     declarations.push(currentDeclaration.trim());
@@ -184,19 +432,15 @@ const styimat = (function() {
             }
         }
         
-        // 添加最后一个声明（如果没有分号结尾）
         if (currentDeclaration.trim()) {
             declarations.push(currentDeclaration.trim());
         }
         
-        // 解析每个声明为对象
         const result = [];
         
         for (const declaration of declarations) {
-            // 跳过空声明
             if (!declaration.trim()) continue;
             
-            // 查找第一个冒号的位置
             const colonIndex = findFirstColonOutsideQuotes(declaration);
             
             if (colonIndex === -1) {
@@ -204,16 +448,17 @@ const styimat = (function() {
                 continue;
             }
             
-            // 分割属性名和值
-            const property = declaration.substring(0, colonIndex).trim();
+            let property = declaration.substring(0, colonIndex).trim();
             let value = declaration.substring(colonIndex + 1).trim();
             
-            // 如果值以分号结尾，移除它（理论上不应该有，但处理一下）
             if (value.endsWith(';')) {
                 value = value.slice(0, -1).trim();
             }
             
-            // 添加到结果数组
+            if (aliases.get(property)) {
+                property = aliases.get(property);
+            }
+            
             result.push({ [property]: value });
         }
         
@@ -222,8 +467,6 @@ const styimat = (function() {
 
     /**
      * 查找不在引号内的第一个冒号位置
-     * @param {string} str 
-     * @returns {number}
      */
     function findFirstColonOutsideQuotes(str) {
         let inQuotes = false;
@@ -232,7 +475,6 @@ const styimat = (function() {
         for (let i = 0; i < str.length; i++) {
             const char = str[i];
             
-            // 处理引号
             if ((char === '"' || char === "'") && !inQuotes) {
                 inQuotes = true;
                 quoteChar = char;
@@ -241,7 +483,6 @@ const styimat = (function() {
                 quoteChar = '';
             }
             
-            // 如果找到冒号且不在引号内，返回位置
             if (char === ':' && !inQuotes) {
                 return i;
             }
@@ -252,29 +493,19 @@ const styimat = (function() {
 
     /**
      * 增强的数学表达式解析和计算
-     * @param {string} expression - 数学表达式
-     * @param {Object} config - 配置对象
-     * @returns {string} 计算结果
      */
     function evaluateMathExpression(expression, config) {
-        // 如果禁用math()增强，则返回原始表达式
         if (!config.enableMath) {
             return `math(${expression})`;
         }
         
         try {
-            // 清理表达式：移除空白字符
             let cleanExpr = expression.replace(/\s+/g, '');
-            
-            // 解析数学表达式
             const result = parseMathExpression(cleanExpr, config);
             
-            // 如果结果包含单位，保留原始格式
             if (hasUnits(cleanExpr)) {
-                // 处理带单位的表达式
                 return processUnitExpression(cleanExpr, result);
             } else {
-                // 纯数字表达式，直接计算结果
                 return roundNumber(result, config.mathPrecision);
             }
         } catch (error) {
@@ -285,12 +516,8 @@ const styimat = (function() {
 
     /**
      * 解析数学表达式
-     * @param {string} expr - 清理后的表达式
-     * @param {Object} config - 配置对象
-     * @returns {number} 计算结果
      */
     function parseMathExpression(expr, config) {
-        // 处理括号
         while (expr.includes('(') && expr.includes(')')) {
             const start = expr.lastIndexOf('(');
             const end = expr.indexOf(')', start);
@@ -303,18 +530,13 @@ const styimat = (function() {
             expr = expr.substring(0, start) + innerResult + expr.substring(end + 1);
         }
         
-        // 现在expr应该没有括号了
         return evaluateSimpleExpression(expr, config);
     }
 
     /**
      * 评估简单表达式（无括号）
-     * @param {string} expr - 简单表达式
-     * @param {Object} config - 配置对象
-     * @returns {number} 计算结果
      */
     function evaluateSimpleExpression(expr, config) {
-        // 处理操作符优先级：乘除优先于加减
         const operators = [
             { regex: /([\d.]+(?:[a-zA-Z%]+)?)\*([\d.]+(?:[a-zA-Z%]+)?)/, handler: multiply },
             { regex: /([\d.]+(?:[a-zA-Z%]+)?)\/([\d.]+(?:[a-zA-Z%]+)?)/, handler: divide },
@@ -324,7 +546,6 @@ const styimat = (function() {
         
         let lastExpr = expr;
         
-        // 按照优先级处理操作符
         for (const op of operators) {
             let match;
             while ((match = expr.match(op.regex)) !== null) {
@@ -332,30 +553,24 @@ const styimat = (function() {
                 const right = parseValueWithUnit(match[2]);
                 const result = op.handler(left, right);
                 
-                // 替换匹配的部分
                 expr = expr.substring(0, match.index) + 
                        result.value + 
                        expr.substring(match.index + match[0].length);
             }
         }
         
-        // 如果表达式无法进一步简化，尝试解析为数字
         if (expr !== lastExpr) {
             return evaluateSimpleExpression(expr, config);
         }
         
-        // 解析最终结果
         const parsed = parseValueWithUnit(expr);
         return parsed.value;
     }
 
     /**
      * 解析带单位的数值
-     * @param {string} str - 字符串值
-     * @returns {Object} {value: number, unit: string}
      */
     function parseValueWithUnit(str) {
-        // 匹配数值和单位
         const match = str.match(/^([\d.]+)([a-zA-Z%]*)$/);
         
         if (!match) {
@@ -370,8 +585,6 @@ const styimat = (function() {
 
     /**
      * 检查表达式是否包含单位
-     * @param {string} expr - 表达式
-     * @returns {boolean} 是否包含单位
      */
     function hasUnits(expr) {
         return /[a-zA-Z%]/.test(expr);
@@ -379,24 +592,18 @@ const styimat = (function() {
 
     /**
      * 处理带单位的表达式
-     * @param {string} originalExpr - 原始表达式
-     * @param {number} result - 计算结果
-     * @returns {string} 处理后的表达式
      */
     function processUnitExpression(originalExpr, result) {
-        // 提取原始表达式中的单位
         const unitMatch = originalExpr.match(/([a-zA-Z%]+)(?!.*[a-zA-Z%])/);
         
         if (unitMatch) {
             return result + unitMatch[1];
         }
         
-        // 如果没有明确单位，检查是否为百分比
         if (originalExpr.includes('%')) {
             return result + '%';
         }
         
-        // 默认为像素
         return result + 'px';
     }
 
@@ -406,7 +613,6 @@ const styimat = (function() {
             return { value: a.value * b.value, unit: a.unit || b.unit };
         }
         
-        // 单位不匹配，返回原始表达式
         return { value: `${a.value}${a.unit}*${b.value}${b.unit}`, unit: '' };
     }
 
@@ -416,14 +622,11 @@ const styimat = (function() {
         }
         
         if (a.unit && !b.unit) {
-            // 如 100px / 2
             return { value: a.value / b.value, unit: a.unit };
         } else if (a.unit === b.unit) {
-            // 如 100px / 2px
             return { value: a.value / b.value, unit: '' };
         }
         
-        // 单位不匹配，返回原始表达式
         return { value: `${a.value}${a.unit}/${b.value}${b.unit}`, unit: '' };
     }
 
@@ -432,7 +635,6 @@ const styimat = (function() {
             return { value: a.value + b.value, unit: a.unit };
         }
         
-        // 单位不匹配，返回原始表达式
         return { value: `${a.value}${a.unit}+${b.value}${b.unit}`, unit: '' };
     }
 
@@ -441,21 +643,16 @@ const styimat = (function() {
             return { value: a.value - b.value, unit: a.unit };
         }
         
-        // 单位不匹配，返回原始表达式
         return { value: `${a.value}${a.unit}-${b.value}${b.unit}`, unit: '' };
     }
 
     /**
      * 四舍五入到指定精度
-     * @param {number} num - 要四舍五入的数字
-     * @param {number} precision - 精度
-     * @returns {string} 四舍五入后的数字字符串
      */
     function roundNumber(num, precision = 6) {
         const factor = Math.pow(10, precision);
         const rounded = Math.round(num * factor) / factor;
         
-        // 移除不必要的尾随零
         const str = rounded.toString();
         if (str.includes('.')) {
             return str.replace(/(\.\d*?)0+$/, '$1').replace(/\.$/, '');
@@ -465,9 +662,6 @@ const styimat = (function() {
 
     /**
      * 处理所有的math()函数
-     * @param {string} cssValue - CSS属性值
-     * @param {Object} config - 配置对象
-     * @returns {string} 转换后的CSS值
      */
     function processMathFunctions(cssValue, config) {
         if (!config.enableMath) {
@@ -475,18 +669,14 @@ const styimat = (function() {
         }
         
         let result = cssValue;
-        
-        // 匹配math()函数
         const mathRegex = /math\(([^)]+)\)/gi;
         
-        // 递归处理嵌套的math()函数
         const processMath = (str) => {
             return str.replace(mathRegex, (match, expression) => {
                 return evaluateMathExpression(expression, config);
             });
         };
         
-        // 递归处理，直到没有更多math()函数
         let lastResult;
         do {
             lastResult = result;
@@ -497,10 +687,7 @@ const styimat = (function() {
     }
 
     /**
-     * 解析并转换所有的 Lab 和 LCH 颜色（全局一次性处理）
-     * @param {string} cssValue - CSS属性值
-     * @param {Object} config - 配置对象
-     * @returns {string} 转换后的CSS值
+     * 解析并转换所有的 Lab 和 LCH 颜色
      */
     function convertAllLabLchColors(cssValue, config) {
         if (!config.convertLabToRGB && !config.convertLchToRGB) {
@@ -508,27 +695,19 @@ const styimat = (function() {
         }
         
         let result = cssValue;
-        
-        // 首先处理特殊的十六进制格式
         result = parseHexColorFormats(result, config);
         
-        // 一次性处理所有的 lab() 和 lch() 函数
         const colorFunctionRegex = /(lab|lch)\([^)]+\)/gi;
-        
-        // 存储已经处理过的颜色字符串，避免重复处理
         const processedColors = new Map();
         
-        // 使用一个函数来递归处理嵌套的颜色函数
         const processColorFunctions = (str) => {
             return str.replace(colorFunctionRegex, (match) => {
-                // 如果这个颜色已经处理过，直接返回缓存结果
                 if (processedColors.has(match)) {
                     return processedColors.get(match);
                 }
                 
                 let converted = match;
                 
-                // 根据函数类型处理
                 if (match.toLowerCase().startsWith('lab(')) {
                     if (config.convertLabToRGB) {
                         converted = convertSingleLabColor(match, config);
@@ -539,13 +718,11 @@ const styimat = (function() {
                     }
                 }
                 
-                // 缓存结果
                 processedColors.set(match, converted);
                 return converted;
             });
         };
         
-        // 递归处理，直到没有更多颜色函数
         let lastResult;
         do {
             lastResult = result;
@@ -556,32 +733,25 @@ const styimat = (function() {
     }
 
     /**
-     * 解析十六进制颜色格式：lab#L16A16B16 或 lch#L16C16H
-     * @param {string} value - 颜色值
-     * @param {Object} config - 配置对象
-     * @returns {string} 转换后的CSS颜色
+     * 解析十六进制颜色格式
      */
     function parseHexColorFormats(value, config) {
         let result = value;
         
-        // 使用正则表达式一次性匹配所有 lab# 和 lch# 格式
         const hexLabRegex = /lab#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})/gi;
         const hexLchRegex = /lch#([0-9a-f]{2})([0-9a-f]{2})(\d{1,3})/gi;
         
-        // 存储处理过的十六进制颜色，避免重复处理
         const processedHexColors = new Map();
         
-        // 处理 lab# 格式
         result = result.replace(hexLabRegex, (match, L_hex, A_hex, B_hex) => {
             if (processedHexColors.has(match)) {
                 return processedHexColors.get(match);
             }
             
             try {
-                // 将十六进制转换为十进制，并映射到Lab范围
-                const L = parseInt(L_hex, 16) / 255 * 100; // 0-100
-                const A = (parseInt(A_hex, 16) - 128) * 1.5; // 大约 -192 到 192
-                const B = (parseInt(B_hex, 16) - 128) * 1.5; // 大约 -192 到 192
+                const L = parseInt(L_hex, 16) / 255 * 100;
+                const A = (parseInt(A_hex, 16) - 128) * 1.5;
+                const B = (parseInt(B_hex, 16) - 128) * 1.5;
                 
                 const converted = generateColorString(L, A, B, config);
                 processedHexColors.set(match, converted);
@@ -592,17 +762,15 @@ const styimat = (function() {
             }
         });
         
-        // 处理 lch# 格式
         result = result.replace(hexLchRegex, (match, L_hex, C_hex, H_dec) => {
             if (processedHexColors.has(match)) {
                 return processedHexColors.get(match);
             }
             
             try {
-                // 将十六进制转换为十进制，并映射到LCH范围
-                const L = parseInt(L_hex, 16) / 255 * 100; // 0-100
-                const C = parseInt(C_hex, 16) / 255 * 150; // 0-150
-                const H = parseInt(H_dec) / 100 * 360; // 0-360
+                const L = parseInt(L_hex, 16) / 255 * 100;
+                const C = parseInt(C_hex, 16) / 255 * 150;
+                const H = parseInt(H_dec) / 100 * 360;
                 
                 const lab = lchToLab(L, C, H);
                 const converted = generateColorString(lab.L, lab.a, lab.b, config);
@@ -619,12 +787,8 @@ const styimat = (function() {
 
     /**
      * 转换单个 lab() 颜色函数
-     * @param {string} labString - lab() 颜色字符串
-     * @param {Object} config - 配置对象
-     * @returns {string} 转换后的颜色字符串
      */
     function convertSingleLabColor(labString, config) {
-        // 使用更精确的正则匹配 lab() 函数
         const labRegex = /lab\(\s*([\d.]+)(%?)\s+([\d.-]+)\s+([\d.-]+)(?:\s*\/\s*([\d.%]+))?\s*\)/i;
         const match = labString.match(labRegex);
         
@@ -633,14 +797,11 @@ const styimat = (function() {
         }
         
         try {
-            // 转换为数字
             let L = parseFloat(match[1]);
             
-            // 如果L有百分号，转换为0-100范围的值
             if (match[2] === '%') {
-                L = L; // 百分比值直接使用 (0-100)
+                L = L;
             } else {
-                // 没有百分号，确保在0-100范围内
                 if (L < 0) L = 0;
                 if (L > 100) L = 100;
             }
@@ -648,7 +809,6 @@ const styimat = (function() {
             const A = parseFloat(match[3]);
             const B = parseFloat(match[4]);
             
-            // 处理 alpha 通道（如果有）
             const alphaValue = match[5] !== undefined
                 ? match[5].includes('%') 
                     ? parseFloat(match[5]) / 100 
@@ -664,12 +824,8 @@ const styimat = (function() {
 
     /**
      * 转换单个 lch() 颜色函数
-     * @param {string} lchString - lch() 颜色字符串
-     * @param {Object} config - 配置对象
-     * @returns {string} 转换后的颜色字符串
      */
     function convertSingleLchColor(lchString, config) {
-        // 使用更精确的正则匹配 lch() 函数
         const lchRegex = /lch\(\s*([\d.]+)(%?)\s+([\d.]+)\s+([\d.]+)(deg)?(?:\s*\/\s*([\d.%]+))?\s*\)/i;
         const match = lchString.match(lchRegex);
         
@@ -678,14 +834,11 @@ const styimat = (function() {
         }
         
         try {
-            // 转换为数字
             let L = parseFloat(match[1]);
             
-            // 如果L有百分号，转换为0-100范围的值
             if (match[2] === '%') {
-                L = L; // 百分比值直接使用 (0-100)
+                L = L;
             } else {
-                // 没有百分号，确保在0-100范围内
                 if (L < 0) L = 0;
                 if (L > 100) L = 100;
             }
@@ -693,18 +846,14 @@ const styimat = (function() {
             const C = parseFloat(match[3]);
             let H = parseFloat(match[4]);
             
-            // 验证C范围：>= 0
             if (C < 0) {
                 console.warn(`LCH中的C值不能为负: ${C}`);
             }
             
-            // 验证H范围：0-360，有deg单位或无单位都是0-360
-            H = ((H % 360) + 360) % 360; // 标准化到0-360
+            H = ((H % 360) + 360) % 360;
             
-            // LCH -> Lab
             const lab = lchToLab(L, C, H);
             
-            // 处理 alpha 通道（如果有）
             const alphaValue = match[6] !== undefined
                 ? match[6].includes('%') 
                     ? parseFloat(match[6]) / 100 
@@ -719,28 +868,21 @@ const styimat = (function() {
     }
 
     /**
-     * LCH 转换为 Lab (CSS标准)
-     * @param {number} L - 明度 0-100 或 0%-100%
-     * @param {number} C - 色度 >=0
-     * @param {number} H - 色相角 0-360 度
-     * @returns {Object} Lab 值 {L, a, b}
+     * LCH 转换为 Lab
      */
     function lchToLab(L, C, H) {
-        // 角度转换为弧度
         const H_rad = H * Math.PI / 180;
-        
-        // LCH -> Lab 转换公式
         const a = C * Math.cos(H_rad);
         const b = C * Math.sin(H_rad);
         
         return { L, a, b };
     }
 
-    // 精确的 Lab -> sRGB 转换函数
+    /**
+     * Lab -> sRGB 转换函数
+     */
     function preciseLabToRGB(L, a, b) {
-        // 1. Lab -> XYZ (D65白点)
         const labToXyz = (L, a, b) => {
-            // D65 白点参考值
             const refX = 0.95047;
             const refY = 1.00000;
             const refZ = 1.08883;
@@ -763,9 +905,7 @@ const styimat = (function() {
             ];
         };
         
-        // 2. XYZ -> Linear RGB
         const xyzToLinearRgb = (x, y, z) => {
-            // sRGB 转换矩阵 (D65)
             const M = [
                 [ 3.2404542, -1.5371385, -0.4985314],
                 [-0.9692660,  1.8760108,  0.0415560],
@@ -779,7 +919,6 @@ const styimat = (function() {
             return [r, g, b];
         };
         
-        // 3. sRGB Gamma 校正
         const applyGamma = (c) => {
             const sign = c < 0 ? -1 : 1;
             const absC = Math.abs(c);
@@ -791,12 +930,10 @@ const styimat = (function() {
             }
         };
         
-        // 4. 钳制到 [0, 255]
         const clamp = (value) => {
             return Math.max(0, Math.min(255, Math.round(value * 255)));
         };
         
-        // 执行转换
         const [X, Y, Z] = labToXyz(L, a, b);
         const [linearR, linearG, linearB] = xyzToLinearRgb(X, Y, Z);
         
@@ -804,7 +941,6 @@ const styimat = (function() {
         const g = applyGamma(linearG);
         const bOut = applyGamma(linearB);
         
-        // 返回钳制后的 RGB 值
         return {
             r: clamp(r),
             g: clamp(g),
@@ -814,13 +950,8 @@ const styimat = (function() {
 
     /**
      * Lab -> Display P3 转换
-     * @param {number} L - 明度 0-100
-     * @param {number} a - a分量
-     * @param {number} b - b分量
-     * @returns {Object} P3颜色 {r, g, b}
      */
     function labToP3(L, a, b) {
-        // 1. Lab -> XYZ (使用与RGB相同的转换)
         const labToXyz = (L, a, b) => {
             const refX = 0.95047;
             const refY = 1.00000;
@@ -844,9 +975,7 @@ const styimat = (function() {
             ];
         };
         
-        // 2. XYZ -> Linear P3
         const xyzToLinearP3 = (x, y, z) => {
-            // Display P3 转换矩阵 (D65)
             const M = [
                 [ 2.493496911941425, -0.9313836179191239, -0.40271078445071684],
                 [-0.8294889695615747,  1.7626640603183463,  0.023624685841943577],
@@ -860,7 +989,6 @@ const styimat = (function() {
             return [r, g, b];
         };
         
-        // 3. P3 Gamma 校正（与sRGB相同）
         const applyGamma = (c) => {
             const sign = c < 0 ? -1 : 1;
             const absC = Math.abs(c);
@@ -872,12 +1000,10 @@ const styimat = (function() {
             }
         };
         
-        // 4. 钳制到 [0, 255]，然后转换为 [0, 1] 范围
         const clamp = (value) => {
             return Math.max(0, Math.min(255, Math.round(value * 255)));
         };
         
-        // 执行转换
         try {
             const [X, Y, Z] = labToXyz(L, a, b);
             const [linearR, linearG, linearB] = xyzToLinearP3(X, Y, Z);
@@ -886,7 +1012,6 @@ const styimat = (function() {
             const g = applyGamma(linearG);
             const bOut = applyGamma(linearB);
             
-            // 转换为0-1范围的浮点数用于P3颜色格式
             return {
                 r: Math.max(0, Math.min(1, r)),
                 g: Math.max(0, Math.min(1, g)),
@@ -904,24 +1029,16 @@ const styimat = (function() {
     }
 
     /**
-     * 生成颜色字符串（根据P3支持情况输出P3或RGB）
-     * @param {number} L - Lab L值
-     * @param {number} a - Lab a值
-     * @param {number} b - Lab b值
-     * @param {Object} config - 配置对象
-     * @param {number|null} alpha - 透明度值
-     * @returns {string} CSS颜色字符串
+     * 生成颜色字符串
      */
     function generateColorString(L, a, b, config, alpha = null) {
         if (!config.enableP3 || !detectP3Support()) {
-            // 使用RGB
             const rgb = preciseLabToRGB(L, a, b);
             if (alpha !== null) {
                 return `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${alpha})`;
             }
             return `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})`;
         } else {
-            // 使用P3
             const p3 = labToP3(L, a, b);
             if (alpha !== null) {
                 return `color(display-p3 ${p3.r.toFixed(4)} ${p3.g.toFixed(4)} ${p3.b.toFixed(4)} / ${alpha})`;
@@ -931,20 +1048,15 @@ const styimat = (function() {
     }
 
     /**
-     * 处理CSS值，根据配置转换LAB、LCH颜色和math()函数
-     * @param {string} value - CSS属性值
-     * @param {Object} config - 配置对象
-     * @returns {string} 处理后的值
+     * 处理CSS值
      */
     function processCSSValue(value, config) {
         let result = value;
         
-        // 1. 首先处理math()函数
         if (config.enableMath) {
             result = processMathFunctions(result, config);
         }
         
-        // 2. 然后处理LAB和LCH颜色
         if (config.convertLabToRGB || config.convertLchToRGB) {
             result = convertAllLabLchColors(result, config);
         }
@@ -952,7 +1064,9 @@ const styimat = (function() {
         return result;
     }
 
-    // 私有方法：提取变量定义并移除（支持嵌套作用域）
+    /**
+     * 提取变量定义并移除
+     */
     function extractVariablesAndCSS(cssText, config) {
         const lines = cssText.split('\n');
         const globalVariables = {};
@@ -965,12 +1079,10 @@ const styimat = (function() {
         for (let line of lines) {
             const trimmed = line.trim();
             
-            // 检查是否是变量定义
             const varMatch = trimmed.match(/^\$([a-zA-Z0-9_-]+)\s*:\s*(.+?);?$/);
             
             if (varMatch) {
                 const [, varName, varValue] = varMatch;
-                // 处理变量值中的数学表达式和颜色转换
                 const processedValue = processCSSValue(
                     replaceVariableUsesInValue(varValue.trim(), {
                         ...globalVariables,
@@ -980,19 +1092,16 @@ const styimat = (function() {
                 );
                 
                 if (currentSelector) {
-                    // 选择器内部的变量
                     if (!selectorVariables.has(currentSelector)) {
                         selectorVariables.set(currentSelector, {});
                     }
                     selectorVariables.get(currentSelector)[varName] = processedValue;
                 } else {
-                    // 全局变量（:root 中）
                     globalVariables[varName] = processedValue;
                 }
                 continue;
             }
             
-            // 检查是否是选择器开始
             if (trimmed.endsWith('{')) {
                 currentSelector = trimmed.slice(0, -1).trim();
                 inSelectorBlock = true;
@@ -1000,10 +1109,8 @@ const styimat = (function() {
                 continue;
             }
             
-            // 检查是否是选择器结束
             if (trimmed === '}') {
                 if (inSelectorBlock) {
-                    // 在选择器结束前插入变量声明
                     if (currentSelector && selectorVariables.has(currentSelector)) {
                         const vars = selectorVariables.get(currentSelector);
                         const indent = ' '.repeat(currentIndent);
@@ -1018,7 +1125,6 @@ const styimat = (function() {
             
             cssWithoutVars += line + '\n';
             
-            // 更新缩进级别
             if (line.includes('{')) {
                 currentIndent += config.indentSize;
             }
@@ -1034,10 +1140,12 @@ const styimat = (function() {
         };
     }
 
-    // 修复的嵌套解析函数
-    function parseNestedRules(cssText, config) {
+    /**
+     * 解析嵌套规则
+     */
+    function parseNestedRules(cssText, config, aliases) {
         const lines = cssText.split('\n');
-        const stack = []; // 存储规则信息：{selector, properties, children}
+        const stack = [];
         const rootRules = [];
         let currentIndent = 0;
         
@@ -1047,49 +1155,40 @@ const styimat = (function() {
             
             if (!trimmed) continue;
             
-            // 计算缩进级别（假设使用空格缩进）
             const indent = line.match(/^(\s*)/)[0].length;
             
-            // 处理规则块结束
             if (trimmed === '}') {
                 if (stack.length > 0) {
                     const rule = stack.pop();
                     
-                    // 如果这个规则有父规则，添加到父规则的children中
                     if (stack.length > 0) {
                         const parent = stack[stack.length - 1];
                         if (!parent.children) parent.children = [];
                         parent.children.push(rule);
                     } else {
-                        // 否则是根级规则
                         rootRules.push(rule);
                     }
                 }
                 continue;
             }
             
-            // 处理规则开始
             if (trimmed.endsWith('{')) {
                 const selector = trimmed.slice(0, -1).trim();
                 
-                // 创建新规则
                 const rule = {
                     selector: selector,
                     properties: [],
                     children: []
                 };
                 
-                // 推入堆栈
                 stack.push(rule);
                 continue;
             }
             
-            // 处理属性行（不包含 { 或 } 的行）
             if (!trimmed.includes('{') && !trimmed.includes('}') && trimmed.includes(':')) {
                 if (stack.length > 0) {
                     const currentRule = stack[stack.length - 1];
-                    // 处理属性值中的math()函数和颜色转换
-                    const parsed = parseSingleLineCSS(trimmed);
+                    const parsed = parseSingleLineCSS(trimmed, aliases);
                     parsed.forEach(obj => {
                         const key = Object.keys(obj)[0];
                         const value = processCSSValue(obj[key], config);
@@ -1100,7 +1199,6 @@ const styimat = (function() {
             }
         }
         
-        // 处理栈中剩余规则
         while (stack.length > 0) {
             const rule = stack.pop();
             if (stack.length === 0) {
@@ -1112,17 +1210,17 @@ const styimat = (function() {
             }
         }
         
-        // 将规则树转换为CSS字符串
-        return convertRulesToCSS(rootRules, config);
+        return convertRulesToCSS(rootRules, config, '', aliases);
     }
     
-    // 将规则树转换为CSS字符串
-    function convertRulesToCSS(rules, config, parentSelector = '') {
+    /**
+     * 将规则树转换为CSS字符串
+     */
+    function convertRulesToCSS(rules, config, parentSelector = '', aliases=[]) {
         let result = '';
         const isParentAt = parentSelector.startsWith("@");
         
         for (const rule of rules) {
-            // 构建完整选择器
             const isAt = rule.selector.startsWith("@");
             let fullSelector = (isParentAt ? " ".repeat(config.indentSize) : '') + rule.selector;
             
@@ -1131,7 +1229,6 @@ const styimat = (function() {
             }
             
             if (parentSelector) {
-                // 处理 & 选择器
                 if (fullSelector.includes('&')) {
                     fullSelector = fullSelector.replace(/&/g, parentSelector);
                 } else if (fullSelector.trim().startsWith(':')) {
@@ -1141,12 +1238,10 @@ const styimat = (function() {
                 }
             }
             
-            // 如果有属性，生成规则块
             if (rule.properties.length > 0) {
                 result += (isAt ? "" : fullSelector) + ' {\n';
                 for (const prop of rule.properties) {
-                    // 再次处理属性值（确保math()函数和颜色被转换）
-                    const parsed = parseSingleLineCSS(prop);
+                    const parsed = parseSingleLineCSS(prop, aliases);
                     parsed.forEach(obj => {
                         const key = Object.keys(obj)[0];
                         const value = processCSSValue(obj[key], config);
@@ -1156,9 +1251,8 @@ const styimat = (function() {
                 result += isParentAt ? " ".repeat(config.indentSize) + '}\n' : '}\n\n';
             }
             
-            // 递归处理子规则
             if (rule.children && rule.children.length > 0) {
-                result += convertRulesToCSS(rule.children, config, fullSelector);
+                result += convertRulesToCSS(rule.children, config, fullSelector, aliases);
             }
             
             if (isParentAt){
@@ -1169,7 +1263,9 @@ const styimat = (function() {
         return result.trim() + "\n\n";
     }
 
-    // 替换变量值中的变量引用
+    /**
+     * 替换变量值中的变量引用
+     */
     function replaceVariableUsesInValue(value, variables) {
         return value.replace(/\$([a-zA-Z0-9_-]+)/g, (match, varName) => {
             if (variables[varName]) {
@@ -1179,22 +1275,24 @@ const styimat = (function() {
         });
     }
 
-    // 替换变量使用
+    /**
+     * 替换变量使用
+     */
     function replaceVariableUses(cssText, globalVariables, selectorVariables, config) {
         let result = cssText;
         
-        // 处理变量
         result = result.replace(/(?:\$\$|\$)([a-zA-Z0-9_-]+)/g, (match, varName) => {
           return match.startsWith('$$') ? `attr(${varName})` : `var(--${varName})`;
         });
         
-        // 最后处理所有的LAB、LCH颜色和math()函数
         result = processCSSValue(result, config);
         
         return result;
     }
 
-    // 生成根规则
+    /**
+     * 生成根规则
+     */
     function generateRootRule(variables, config) {
         if (Object.keys(variables).length === 0) {
             return '';
@@ -1213,7 +1311,9 @@ const styimat = (function() {
         return `${config.rootSelector} {\n${declarations}\n}\n\n`;
     }
 
-    // 处理选择器内部的变量
+    /**
+     * 注入选择器局部变量
+     */
     function injectSelectorVariables(cssText, selectorVariables, config) {
         let result = '';
         const lines = cssText.split('\n');
@@ -1227,7 +1327,6 @@ const styimat = (function() {
             }
             
             if (trimmed === '}' && currentSelector) {
-                // 在选择器结束前插入变量声明
                 if (selectorVariables.has(currentSelector)) {
                     const vars = selectorVariables.get(currentSelector);
                     const indent = line.match(/^(\s*)/)[0];
@@ -1238,7 +1337,6 @@ const styimat = (function() {
                 currentSelector = null;
             }
             
-            // 使用全局处理函数处理所有math()和颜色
             result += processCSSValue(line, config) + '\n';
         }
         
@@ -1247,43 +1345,31 @@ const styimat = (function() {
 
     /**
      * 处理 @import 语句
-     * @param {string} cssText - CSS文本
-     * @param {Object} config - 配置对象
-     * @returns {Promise<string>} 处理后的CSS文本
      */
     async function processImports(cssText, config) {
-        // 匹配所有@import语句
         const importRegex = /@import\s+([^;]+?)\s*;/g;
         
-        // 递归处理函数
         const processRecursive = async (text) => {
-            // 使用replace更简单的方式
             const importPromises = [];
             
-            // 使用replace的回调函数收集所有import的promise
             const processedText = text.replace(importRegex, (match, url) => {
                 const importPromise = fetchImportContent(url, config)
                     .then(importedCSS => {
-                        // 递归处理导入的CSS中的import
                         return processImports(importedCSS, config);
                     })
                     .catch(error => {
                         console.warn(`无法导入CSS文件: ${url}`, error);
-                        // 导入失败时返回空字符串
                         return '';
                     });
                 
                 importPromises.push(importPromise);
                 
-                // 返回占位符
                 return `__IMPORT_PLACEHOLDER_${importPromises.length - 1}__`;
             });
             
-            // 等待所有import完成
             if (importPromises.length > 0) {
                 const importedContents = await Promise.all(importPromises);
                 
-                // 替换占位符为实际内容
                 let finalText = processedText;
                 for (let i = 0; i < importedContents.length; i++) {
                     finalText = finalText.replace(`__IMPORT_PLACEHOLDER_${i}__`, importedContents[i]);
@@ -1300,35 +1386,27 @@ const styimat = (function() {
 
     /**
      * 获取导入的CSS内容
-     * @param {string} url - CSS文件URL
-     * @param {Object} config - 配置对象
-     * @returns {Promise<string>} CSS内容
      */
     async function fetchImportContent(url, config) {
-        // 检查缓存
         if (config.importCache && importCache.has(url)) {
             return importCache.get(url);
         }
         
-        // 构建完整的URL
         const fullUrl = config.importBaseUrl 
             ? new URL(url, config.importBaseUrl).href
             : url;
         
         let content;
         
-        // 检查是否为Node.js环境
         const isNode = typeof process !== 'undefined' && 
                       process.versions && 
                       process.versions.node;
         
         if (isNode && typeof require !== 'undefined') {
-            // Node.js环境：使用fs模块
             try {
                 const fs = require('fs');
                 const path = require('path');
                 
-                // 处理相对路径
                 let filePath = fullUrl;
                 if (fullUrl.startsWith('.')) {
                     filePath = path.join(process.cwd(), fullUrl);
@@ -1339,7 +1417,6 @@ const styimat = (function() {
                 throw new Error(`Node.js文件读取失败: ${fullUrl} - ${error.message}`);
             }
         } else {
-            // 浏览器环境：使用fetch
             try {
                 const controller = new AbortController();
                 const timeoutId = setTimeout(() => controller.abort(), config.importTimeout);
@@ -1366,7 +1443,6 @@ const styimat = (function() {
             }
         }
         
-        // 缓存内容
         if (config.importCache) {
             importCache.set(url, content);
         }
@@ -1376,73 +1452,82 @@ const styimat = (function() {
 
     /**
      * 主转换函数
-     * @param {string} cssText - CSS文本
-     * @param {Object} customConfig - 自定义配置
-     * @returns {string|Promise<string>} 转换后的CSS（如果是异步则为Promise）
      */
     function convert(cssText, customConfig = {}) {
-        // 处理同步和异步版本
         const syncConvert = (cssText, config) => {
-            // 先解析配置头
             const { config: headerConfig, css: cleanedCSS } = parseConfigHeader(cssText);
             const finalConfig = { ...defaultConfig, ...customConfig,...headerConfig };
             
-            // 1. 提取变量定义（区分全局和选择器局部）
+            let cssWithAliases = cleanedCSS;
+            let aliases = new Map();
+            if (finalConfig.enableAlias) {
+                const { aliases: parsedAliases, css: cssWithoutAliases } = parseAliasStatements(cssWithAliases);
+                aliases = parsedAliases;
+                cssWithAliases = cssWithoutAliases;
+            }
+            
+            let cssWithMacros = cssWithAliases;
+            let macros = new Map();
+            if (finalConfig.enableMacros) {
+                const { macros: parsedMacros, css: cssWithoutMacros } = parseMacroStatements(cssWithMacros, finalConfig);
+                macros = parsedMacros;
+                cssWithMacros = cssWithoutMacros;
+                
+                for (const [name, macro] of macros) {
+                    macroRegistry.set(name, macro);
+                }
+            }
+            
+            let cssAfterMacros = cssWithMacros;
+            if (finalConfig.enableMacros && macros.size > 0) {
+                cssAfterMacros = applyMacroCalls(cssAfterMacros, macros, finalConfig);
+            }
+            
             const { globalVariables, selectorVariables, cssWithoutVars } = 
-                extractVariablesAndCSS(cleanedCSS, finalConfig);
+                extractVariablesAndCSS(cssAfterMacros, finalConfig);
             
-            // 2. 解析嵌套规则（如果启用）
             let processedCSS = cssWithoutVars.trim();
             if (finalConfig.enableNesting && cssWithoutVars.includes('{')) {
                 try {
-                    processedCSS = parseNestedRules(cssWithoutVars, finalConfig);
+                    processedCSS = parseNestedRules(cssWithoutVars, finalConfig, aliases);
                 } catch (error) {
                     console.warn('嵌套解析失败，使用原始CSS:', error);
                 }
             }
             
-            // 3. 生成根规则（全局变量）
             const rootRule = generateRootRule(globalVariables, finalConfig);
             
-            // 4. 注入选择器局部变量
             let finalCSS = processedCSS;
             if (selectorVariables.size > 0) {
                 finalCSS = injectSelectorVariables(processedCSS, selectorVariables, finalConfig);
             }
             
-            // 5. 替换变量使用
             finalCSS = replaceVariableUses(finalCSS, globalVariables, selectorVariables, finalConfig);
             
-            // 6. 组合结果
             return rootRule + finalCSS;
         };
         
-        // 检查是否有@import语句（需要异步处理）
         const hasImports = cssText && /@import\s+([^;]+?)\s*;/g.test(cssText);
         const finalConfig = { ...defaultConfig, ...customConfig };
         
         if (!hasImports) {
-            // 没有@import，同步处理
             return syncConvert(cssText, finalConfig);
         } else {
-            // 有@import，异步处理
             return (async () => {
                 try {
-                    // 处理@import
                     const processedWithImports = await processImports(cssText, finalConfig);
-                    
-                    // 同步处理剩余部分
                     return syncConvert(processedWithImports, finalConfig);
                 } catch (error) {
                     console.error('@import处理失败:', error);
-                    // 如果导入失败，尝试同步处理原始CSS
-                    return syncConvert(cleanedCSS, finalConfig);
+                    return syncConvert(cssText, finalConfig);
                 }
             })();
         }
     }
 
-    // 自动处理带有 e 属性的 style 标签
+    /**
+     * 自动处理带有特定属性的 style 标签
+     */
     function autoProcessStyleTags(customConfig = {}) {
         const config = { ...defaultConfig, ...customConfig };
         const styleTags = document.querySelectorAll(`style[${config.styleTagAttribute || 'e'}]`);
@@ -1450,7 +1535,6 @@ const styimat = (function() {
         styleTags.forEach(styleTag => {
             let originalCSS = styleTag.textContent;
             
-            // 处理@import（如果是异步的）
             const processStyleTag = async () => {
                 try {
                     if (styleTag.getAttribute("src")){
@@ -1458,14 +1542,11 @@ const styimat = (function() {
                     }
                     const convertedCSS = await convert(originalCSS, config);
                     
-                    // 创建新的 style 标签
                     const newStyleTag = document.createElement('style');
                     newStyleTag.textContent = convertedCSS;
                     
-                    // 插入到原标签后面
                     styleTag.parentNode.insertBefore(newStyleTag, styleTag.nextSibling);
                     
-                    // 可选：移除原标签
                     if (!config.preserveOriginal) {
                         styleTag.remove();
                     } else {
@@ -1486,16 +1567,16 @@ const styimat = (function() {
         defaultConfig = { ...defaultConfig, ...config };
     }
 
-    // 初始化自动处理
+    /**
+     * 应用CSS到页面
+     */
     function apply(cssText, customConfig = {}) {
         const config = { ...defaultConfig, ...customConfig };
         
         if (cssText) {
-            // 检查是否有@import
             const hasImports = /@import\s+([^;]+?)\s*;/g.test(cssText);
             
             if (hasImports) {
-                // 异步处理
                 return (async () => {
                     try {
                         const converted = await convert(cssText, config);
@@ -1509,7 +1590,6 @@ const styimat = (function() {
                     }
                 })();
             } else {
-                // 同步处理
                 const converted = convert(cssText, config);
                 const styleEl = document.createElement('style');
                 styleEl.textContent = converted;
@@ -1527,84 +1607,110 @@ const styimat = (function() {
         }
     }
 
-    // 返回公共 API
+    // 创建公共 API
     const api = {
         convert,
         apply,
         config,
         
-        // 检测P3支持
         supportsP3: detectP3Support(),
         
-        // 重新检测P3支持（如果配置变化）
         detectP3Support: detectP3Support,
         
-        // 导入相关方法
         imports: {
-            /**
-             * 清除导入缓存
-             */
             clearCache: function() {
                 importCache.clear();
             },
-            
-            /**
-             * 设置导入基础URL
-             * @param {string} baseUrl - 基础URL
-             */
             setBaseUrl: function(baseUrl) {
                 defaultConfig.importBaseUrl = baseUrl;
             },
-            
-            /**
-             * 启用/禁用导入缓存
-             * @param {boolean} enabled - 是否启用缓存
-             */
             setCacheEnabled: function(enabled) {
                 defaultConfig.importCache = enabled;
             },
-            
-            /**
-             * 设置导入超时时间
-             * @param {number} timeout - 超时时间（毫秒）
-             */
             setTimeout: function(timeout) {
                 defaultConfig.importTimeout = timeout;
             }
         },
         
-        // 数学计算工具方法
+        aliases: {
+            add: function(alias, property) {
+                aliasMap.set(alias, property);
+            },
+            remove: function(alias) {
+                aliasMap.delete(alias);
+            },
+            getAll: function() {
+                return Array.from(aliasMap.entries());
+            },
+            clear: function() {
+                aliasMap.clear();
+            }
+        },
+        
+        macros: {
+            define: function(name, body, params = []) {
+                if (typeof body === 'function') {
+                    const funcString = body.toString();
+                    const bodyMatch = funcString.match(/{([\s\S]*)}/);
+                    if (bodyMatch) {
+                        macroRegistry.set(name, {
+                            params: params.map(p => typeof p === 'string' ? { name: p } : p),
+                            body: bodyMatch[1].trim()
+                        });
+                    }
+                } else {
+                    macroRegistry.set(name, {
+                        params: params.map(p => typeof p === 'string' ? { name: p } : p),
+                        body: body
+                    });
+                }
+            },
+            
+            call: function(name, ...args) {
+                const macro = macroRegistry.get(name);
+                if (!macro) {
+                    throw new Error(`未定义的宏: ${name}`);
+                }
+                
+                const argsMap = new Map();
+                for (let i = 0; i < macro.params.length; i++) {
+                    const param = macro.params[i];
+                    const value = i < args.length ? args[i] : param.defaultValue;
+                    if (value === undefined && param.defaultValue === null) {
+                        throw new Error(`缺少必需参数: ${param.name}`);
+                    }
+                    argsMap.set(param.name, value !== undefined ? value : '');
+                }
+                
+                return applyMacro(macro.body, argsMap, defaultConfig);
+            },
+            
+            getAll: function() {
+                return Array.from(macroRegistry.entries());
+            },
+            
+            remove: function(name) {
+                macroRegistry.delete(name);
+            },
+            
+            clear: function() {
+                macroRegistry.clear();
+            },
+            
+            parse: function(cssText) {
+                const { macros } = parseMacroStatements(cssText, defaultConfig);
+                for (const [name, macro] of macros) {
+                    macroRegistry.set(name, macro);
+                }
+            }
+        },
+        
         math: {
-            /**
-             * 计算数学表达式
-             * @param {string} expression - 数学表达式
-             * @returns {string} 计算结果
-             */
             evaluate: function(expression) {
                 return evaluateMathExpression(expression, defaultConfig);
             },
-            
-            /**
-             * 解析带单位的数值
-             * @param {string} value - 带单位的字符串
-             * @returns {Object} {value: number, unit: string}
-             */
             parseUnit: parseValueWithUnit,
-            
-            /**
-             * 四舍五入数字
-             * @param {number} num - 要四舍五入的数字
-             * @param {number} precision - 精度
-             * @returns {string} 四舍五入后的数字字符串
-             */
             round: roundNumber,
-            
-            /**
-             * 测试数学表达式
-             * @param {string} expression - 要测试的表达式
-             * @param {Object} testConfig - 测试配置
-             * @returns {Object} 测试结果
-             */
             test: function(expression, testConfig = {}) {
                 const config = { ...defaultConfig, ...testConfig };
                 try {
@@ -1625,7 +1731,6 @@ const styimat = (function() {
             }
         },
         
-        // 颜色转换工具方法
         colorUtils: {
             labToRGB: preciseLabToRGB,
             lchToLab: lchToLab,
@@ -1667,26 +1772,11 @@ const styimat = (function() {
                 const lab = lchToLab(L, C, H);
                 return preciseLabToRGB(lab.L, lab.a, lab.b);
             },
-            /**
-             * 生成颜色字符串（根据P3支持情况）
-             * @param {number} L - Lab L值
-             * @param {number} a - Lab a值
-             * @param {number} b - Lab b值
-             * @param {number|null} alpha - 透明度
-             * @param {boolean} useP3 - 是否使用P3（自动检测）
-             * @returns {string} CSS颜色字符串
-             */
             generateColor: function(L, a, b, alpha = null, useP3 = true) {
                 return generateColorString(L, a, b, { enableP3: useP3 }, alpha);
             },
-            /**
-             * 解析CSS颜色字符串
-             * @param {string} colorString - CSS颜色字符串
-             * @returns {Object} 包含原始Lab值和颜色字符串的对象
-             */
             parseColor: function(colorString) {
                 try {
-                    // 尝试解析lab()函数格式
                     const labMatch = colorString.match(/lab\(\s*([\d.]+)(%?)\s+([\d.-]+)\s+([\d.-]+)(?:\s*\/\s*([\d.%]+))?\s*\)/i);
                     if (labMatch) {
                         let L = parseFloat(labMatch[1]);
@@ -1706,7 +1796,6 @@ const styimat = (function() {
                         };
                     }
                     
-                    // 尝试解析lch()函数格式
                     const lchMatch = colorString.match(/lch\(\s*([\d.]+)(%?)\s+([\d.]+)\s+([\d.]+)(deg)?(?:\s*\/\s*([\d.%]+))?\s*\)/i);
                     if (lchMatch) {
                         let L = parseFloat(lchMatch[1]);
@@ -1737,35 +1826,28 @@ const styimat = (function() {
         }
     };
 
-    // 创建一个可调用的主函数
+    // 创建主函数
     const styimat = function(...args) {
-        // 检查是否是模板字符串调用（标签函数）
         if (args.length > 1 || (args[0] && args[0].raw)) {
-            // 处理模板字符串
             return handleTemplateTag(...args);
         }
 
-        // 获取第一个参数
         const firstArg = args[0];
 
-        // 如果传入CSS文本，则编译并返回结果
         if (typeof firstArg === 'string') {
             const result = convert(firstArg, { ...defaultConfig, ...args[1] });
             
-            // 如果结果是Promise，返回Promise
             if (result && typeof result.then === 'function') {
                 return result;
             }
             return result;
         }
 
-        // 如果传入配置对象，则应用配置
         if (typeof firstArg === 'object' && firstArg !== null) {
             defaultConfig = { ...defaultConfig, ...firstArg };
             return styimat;
         }
 
-        // 如果没有参数，执行自动处理
         if (args.length === 0) {
             return apply();
         }
@@ -1773,13 +1855,10 @@ const styimat = (function() {
         return styimat;
     };
 
-    // 处理模板字符串的函数
     function handleTemplateTag(strings, ...values) {
-        // 拼接模板字符串
         let cssText = strings[0];
 
         for (let i = 0; i < values.length; i++) {
-            // 处理插值（支持字符串、数字、函数等）
             const value = values[i];
             let result = '';
 
@@ -1794,17 +1873,14 @@ const styimat = (function() {
             cssText += result + strings[i + 1];
         }
 
-        // 使用convert函数处理
         const result = convert(cssText, defaultConfig);
         
-        // 如果结果是Promise，返回Promise
         if (result && typeof result.then === 'function') {
             return result;
         }
         return result;
     }
 
-    // 将API的所有方法复制到主函数上
     Object.assign(styimat, api);
     Object.setPrototypeOf(styimat, Function.prototype);
 
@@ -1842,13 +1918,10 @@ const styimat = (function() {
 })();
 
 if (typeof define === 'function' && define.amd) {
-    // AMD 支持 (RequireJS)
     define([], ()=>styimat);
 } else if (typeof module === 'object' && module.exports) {
-    // CommonJS 支持 (Node.js, Browserify, Webpack)
     module.exports = styimat;
 } else {
-    // 浏览器全局变量
-    const globalObj = globalThis ?? (typeof self !== 'undefined' && self) ?? (typeof window !== 'undefined' &window) ?? global ?? {};
+    const globalObj = globalThis ?? (typeof self !== 'undefined' && self) ?? (typeof window !== 'undefined' && window) ?? global ?? {};
     globalObj.styimat = styimat;
 }