styimat 8.6.0 → 9.1.0

package/dist/styimat.amd.js

@@ -0,0 +1,1653 @@
+/*!
+ * MIT License
+ * Copyright (c) 2025 王小玗
+ */
+/**
+ * CSS 变量预处理库 - 增强版
+ * 支持 CSS 变量预处理、嵌套选择器和嵌套变量
+ * 支持 Lab 和 LCH 颜色空间转换为 RGB（CSS标准格式）
+ * 支持 lab# 和 lch# 十六进制语法
+ * 支持 Display P3 广色域显示器
+ * 增强 math() 函数，支持复杂数学计算
+ * 支持配置头
+ * 支持 @import 语法
+ * 支持 @alias 语法
+ * 支持 @macro 宏定义系统
+ */
+
+
+const styimat = (function() {
+    // 默认配置
+    let defaultConfig = {
+        rootSelector: ':root',
+        variablePrefix: '--',
+        preserveOriginal: false,
+        indentSize: 4,
+        enableNesting: true,
+        autoProcessStyleTags: true,
+        styleTagAttribute: 'e',
+        convertLabToRGB: true,
+        convertLchToRGB: true,
+        enableP3: true,
+        enableMath: true,
+        importBaseUrl: '',
+        importCache: true,
+        importTimeout: 5000,
+        enableAlias: true,
+        enableMacros: true
+    };
+    
+    const REGEX = {
+        IMPORT: /@import\s+([^;]+?)\s*;/g,
+        ALIAS: /^@alias\s+([a-zA-Z_][a-zA-Z0-9_]*)\s+(.+?)\s*;$/,
+        MACRO: /^@macro\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(([^)]*)\)\s*\{$/,
+        COMMENT: /\/\*[\s\S]*?\*\//g,
+        MATH_SYMBOL: /([\da-z])([+-])(-?[\da-z])/g,
+        MATH: /math\(([^)]+)\)/gi,
+        COLOR: /(lab|lch)\([^)]+\)/gi,
+        HEXLAB: /lab#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})/gi,
+        HEXLCH: /lch#([0-9a-f]{2})([0-9a-f]{2})(\d{1,3})/gi,
+        SPACE: /\s+/g,
+        AND: /&/g,
+        HYPHEN: /-([a-z])/g,
+        VARIABLE: /(?:\$\$|\$)([a-zA-Z_][a-zA-Z0-9_]*)(?=[^a-zA-Z0-9_])/g
+    }
+
+    // 全局P3支持检测结果
+    let p3Supported = null;
+    
+    // 导入文件缓存
+    const importCache = new Map();
+    
+    // 别名映射表
+    const aliasMap = new Map();
+    
+    // 宏定义存储
+    const macroRegistry = new Map();
+
+    const pluginMap = new Map();
+    
+    function splitLines(str, splitChar = "\n") {
+        const lines = [];
+        const splitCharCode = splitChar.charCodeAt(0);
+        let start = 0;
+        
+        for (let i = 0, length = str.length; i < length; i++) {
+            if (str.charCodeAt(i) === splitCharCode) {
+                if (i > start || str.charAt(start) !== '\r') {
+                    lines.push(str.slice(start, i));
+                }
+                start = i + 1;
+            }
+        }
+    
+        // 处理最后一行
+        if (start < str.length) {
+            lines.push(str.substring(start));
+        } else if (start === str.length && str.charCodeAt(str.length - 1) === 10) {
+            lines.push('');
+        }
+        
+        return lines;
+    }
+
+    /**
+     * 解析配置头
+     */
+    function parseConfigHeader(cssText) {
+        const config = { ...defaultConfig };
+        const lines = splitLines(cssText);
+        const cleanLines = [];
+        
+        for (let line of lines) {
+            const trimmed = line.trim();
+            
+            if (trimmed.startsWith('#')) {
+                const configLine = trimmed.substring(1).trim();
+                const firstSpace = configLine.indexOf(' ');
+                
+                if (~firstSpace) {
+                    const key = configLine.substring(0, firstSpace).trim();
+                    const value = configLine.substring(firstSpace + 1).trim();
+                    
+                    const configKey = camelCase(key);
+                    
+                    
+                    if (value === 'true' || value === 'false') {
+                        config[configKey] = value === 'true';
+                    } else if (!isNaN(value) && value.trim() !== '') {
+                        config[configKey] = Number(value);
+                    } else {
+                        config[configKey] = value;
+                    }
+                } else {
+                    console.warn(`无效的配置行: ${trimmed}`);
+                }
+            } else {
+                cleanLines.push(line);
+            }
+        }
+        
+        return {
+            config,
+            css: cleanLines.join('\n')
+        };
+    }
+
+    /**
+     * 解析 @alias 语句
+     */
+    function parseAliasStatements(cssText) {
+        const aliases = new Map();
+        const lines = splitLines(cssText);
+        const cleanLines = [];
+        
+        for (let line of lines) {
+            const trimmed = line.trim();
+            
+            if (trimmed.startsWith('@alias')) {
+                const aliasMatch = trimmed.match(REGEX.ALIAS);
+                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 = splitLines(cssText);
+        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(REGEX.MACRO);
+                if (macroMatch) {
+                    inMacroDefinition = true;
+                    currentMacroName = macroMatch[1];
+                    currentMacroParams = splitLines(macroMatch[2], ',')
+                        .map(param => param.trim())
+                        .filter(param => param)
+                        .map(param => {
+                            const paramParts = splitLines(param, ':').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 parseMacroArguments(argsStr, paramDefs, splitChar = ',') {
+        const argsMap = new Map();
+        const argValues = parseArgumentList(argsStr, splitChar);
+        
+        for (let i = 0, length = paramDefs.length; i < length; i++) {
+            const param = paramDefs[i];
+            let value;
+            
+            if (i < argValues.length) {
+                value = argValues[i];
+            } else if (param.defaultValue !== null) {
+                value = param.defaultValue;
+            } else {
+                value = 'none';
+            }
+            
+            argsMap.set(param.name, value);
+        }
+        
+        return argsMap;
+    }
+
+    /**
+     * 解析参数列表
+     */
+    function parseArgumentList(argsStr, splitChar) {
+        const args = [];
+        let currentArg = '';
+        let inQuotes = false;
+        let quoteChar = '';
+        let parenDepth = 0;
+        let bracketDepth = 0;
+        
+        for (let i = 0, length = argsStr.length; i < 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 === splitChar && !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;
+        
+        result = result.replace(REGEX.VARIABLE, (match, paramName) => {
+            const paramValue = args.get(paramName);
+            if (paramValue) return args.get(paramName);
+            return match;
+        });
+        
+        result = processCSSValue(result, config);
+        
+        return result;
+    }
+
+    /**
+     * 将连字符分隔的字符串转换为驼峰命名
+     */
+    function camelCase(str) {
+        return str.replace(REGEX.HYPHEN, function(match, letter) {
+            return letter.toUpperCase();
+        });
+    }
+
+    /**
+     * 检测浏览器是否支持 Display P3
+     */
+    function detectP3Support() {
+        if (p3Supported !== null) return p3Supported;
+        
+        if (typeof window === 'undefined' || !window.CSS) {
+            p3Supported = false;
+            return false;
+        }
+        
+        try {
+            p3Supported = CSS.supports('color', 'color(display-p3 1 0 0)');
+        } catch (error) {
+            p3Supported = false;
+        }
+        
+        return p3Supported;
+    }
+
+    /**
+     * 解析一行CSS
+     */
+    function parseSingleLineCSS(cssString, aliases, macros) {
+        let str = cssString.trim();
+        
+        if (str.endsWith(';')) {
+            str = str.slice(0, -1);
+        }
+        
+        if (!str) {
+            return [];
+        }
+        
+        const declarations = [];
+        let currentDeclaration = '';
+        let inParens = 0;
+        let inQuotes = false;
+        let quoteChar = '';
+        
+        for (let i = 0, length = str.length; i < length; i++) {
+            const char = str[i];
+            
+            if ((char === '"' || char === "'") && !inQuotes) {
+                inQuotes = true;
+                quoteChar = char;
+            } else if (char === quoteChar && inQuotes) {
+                inQuotes = false;
+                quoteChar = '';
+            }
+            
+            if (!inQuotes) {
+                if (char === '(') {
+                    inParens++;
+                } else if (char === ')') {
+                    inParens--;
+                }
+            }
+            
+            if (char === ';' && !inQuotes && inParens === 0) {
+                if (currentDeclaration.trim()) {
+                    declarations.push(currentDeclaration.trim());
+                    currentDeclaration = '';
+                }
+            } else {
+                currentDeclaration += char;
+            }
+        }
+        
+        if (currentDeclaration.trim()) {
+            declarations.push(currentDeclaration.trim());
+        }
+        
+        const result = [];
+        
+        for (let declaration of declarations) {
+            declaration = declaration.replace(REGEX.COMMENT, '');
+            if (!declaration.trim()) continue;
+            
+            const colonIndex = findFirstColonOutsideQuotes(declaration);
+            
+            if (!~colonIndex) {
+                console.warn(`无效的CSS声明: "${declaration}"`);
+                continue;
+            }
+            
+            let property = declaration.substring(0, colonIndex).trim();
+            let value = declaration.substring(colonIndex + 1).trim();
+            
+            if (value.endsWith(';')) {
+                value = value.slice(0, -1).trim();
+            }
+            
+            if (property.startsWith('$')) {
+                property = "--" + property.slice(1);
+            }
+            
+            property = aliases.get(property) ?? property;
+            
+            if (property.startsWith("@") && macros.get(property.slice(1))) {
+                const macro = macros.get(property.slice(1));
+                const args = parseMacroArguments(value, macro.params, ' ');
+                property = applyMacro(macro.body, args, config);
+                value = "";
+            }
+            
+            result.push({ [property]: value });
+        }
+        
+        return result;
+    }
+
+    /**
+     * 查找不在引号内的第一个冒号位置
+     */
+    function findFirstColonOutsideQuotes(str) {
+        let inQuotes = false;
+        let quoteChar = '';
+        
+        for (let i = 0, length = str.length; i < length; i++) {
+            const char = str[i];
+            
+            if ((char === '"' || char === "'") && !inQuotes) {
+                inQuotes = true;
+                quoteChar = char;
+            } else if (char === quoteChar && inQuotes) {
+                inQuotes = false;
+                quoteChar = '';
+            }
+            
+            if (char === ':' && !inQuotes) {
+                return i;
+            }
+        }
+        
+        return -1;
+    }
+
+    /**
+     * 增强的数学表达式解析和计算
+     */
+    function evaluateMathExpression(expression, config) {
+        let cleanExpr = expression.replace(REGEX.SPACE, '');
+        
+        return parseMathExpression(cleanExpr);
+    }
+
+    /**
+     * 解析数学表达式
+     */
+    function parseMathExpression(expr) {
+        return `calc(${expr
+            .replace(REGEX.MATH_SYMBOL, '$1 $2 $3')})`;
+    }
+
+    /**
+     * 处理所有的math()函数
+     */
+    function processMathFunctions(cssValue, config) {
+        let result = cssValue;
+        
+        const processMath = (str) => {
+            return str.replace(REGEX.MATH, (match, expression) => {
+                return evaluateMathExpression(expression, config);
+            });
+        };
+        
+        result = processMath(result);
+
+        return result;
+    }
+
+    /**
+     * 解析并转换所有的 Lab 和 LCH 颜色
+     */
+    function convertAllLabLchColors(cssValue, config) {
+        if (!config.convertLabToRGB && !config.convertLchToRGB) {
+            return cssValue;
+        }
+        
+        let result = cssValue;
+        result = parseHexColorFormats(result, config);
+        
+        const processedColors = new Map();
+        
+        const processColorFunctions = (str) => {
+            return str.replace(REGEX.COLOR, (match) => {
+                if (processedColors.has(match)) {
+                    return processedColors.get(match);
+                }
+                
+                let converted = match;
+                
+                if (match.toLowerCase().startsWith('lab(')) {
+                    if (config.convertLabToRGB) {
+                        converted = convertSingleLabColor(match, config);
+                    }
+                } else if (match.toLowerCase().startsWith('lch(')) {
+                    if (config.convertLchToRGB) {
+                        converted = convertSingleLchColor(match, config);
+                    }
+                }
+                
+                processedColors.set(match, converted);
+                return converted;
+            });
+        };
+        
+        let lastResult;
+        do {
+            lastResult = result;
+            result = processColorFunctions(result);
+        } while (result !== lastResult);
+        
+        return result;
+    }
+
+    /**
+     * 解析十六进制颜色格式
+     */
+    function parseHexColorFormats(value, config) {
+        let result = value;
+        
+        const processedHexColors = new Map();
+        
+        result = result.replace(REGEX.HEXLAB, (match, L_hex, A_hex, B_hex) => {
+            if (processedHexColors.has(match)) {
+                return processedHexColors.get(match);
+            }
+            
+            try {
+                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);
+                return converted;
+            } catch (error) {
+                console.warn(`无法解析lab#十六进制颜色: ${match}`, error);
+                return match;
+            }
+        });
+        
+        result = result.replace(REGEX.HEXLCH, (match, L_hex, C_hex, H_dec) => {
+            if (processedHexColors.has(match)) {
+                return processedHexColors.get(match);
+            }
+            
+            try {
+                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);
+                processedHexColors.set(match, converted);
+                return converted;
+            } catch (error) {
+                console.warn(`无法解析lch#十六进制颜色: ${match}`, error);
+                return match;
+            }
+        });
+        
+        return result;
+    }
+
+    /**
+     * 转换单个 lab() 颜色函数
+     */
+    function convertSingleLabColor(labString, config) {
+        const labRegex = /lab\(\s*([\d.]+)(%?)\s+([\d.-]+)\s+([\d.-]+)(?:\s*\/\s*([\d.%]+))?\s*\)/i;
+        const match = labString.match(labRegex);
+        
+        if (!match) {
+            return labString;
+        }
+        
+        try {
+            let L = parseFloat(match[1]);
+            
+            if (match[2] !== '%') {
+                if (L < 0) L = 0;
+                if (L > 100) L = 100;
+            }
+            
+            const A = parseFloat(match[3]);
+            const B = parseFloat(match[4]);
+            
+            const alphaValue = match[5] !== undefined
+                ? match[5].includes('%') 
+                    ? parseFloat(match[5]) / 100 
+                    : parseFloat(match[5])
+                : null;
+            
+            return generateColorString(L, A, B, config, alphaValue);
+        } catch (error) {
+            console.warn(`无法转换LAB颜色: ${labString}`, error);
+            return labString;
+        }
+    }
+
+    /**
+     * 转换单个 lch() 颜色函数
+     */
+    function convertSingleLchColor(lchString, config) {
+        const lchRegex = /lch\(\s*([\d.]+)(%?)\s+([\d.]+)\s+([\d.]+)(deg)?(?:\s*\/\s*([\d.%]+))?\s*\)/i;
+        const match = lchString.match(lchRegex);
+        
+        if (!match) {
+            return lchString;
+        }
+        
+        try {
+            let L = parseFloat(match[1]);
+            
+            if (match[2] === '%') {
+                L = L;
+            } else {
+                if (L < 0) L = 0;
+                if (L > 100) L = 100;
+            }
+            
+            const C = parseFloat(match[3]);
+            let H = parseFloat(match[4]);
+            
+            if (C < 0) {
+                console.warn(`LCH中的C值不能为负: ${C}`);
+            }
+            
+            H = ((H % 360) + 360) % 360;
+            
+            const lab = lchToLab(L, C, H);
+            
+            const alphaValue = match[6] !== undefined
+                ? match[6].includes('%') 
+                    ? parseFloat(match[6]) / 100 
+                    : parseFloat(match[6])
+                : null;
+            
+            return generateColorString(lab.L, lab.a, lab.b, config, alphaValue);
+        } catch (error) {
+            console.warn(`无法转换LCH颜色: ${lchString}`, error);
+            return lchString;
+        }
+    }
+
+    /**
+     * LCH 转换为 Lab
+     */
+    function lchToLab(L, C, H) {
+        const H_rad = H * Math.PI / 180;
+        const a = C * Math.cos(H_rad);
+        const b = C * Math.sin(H_rad);
+        
+        return { L, a, b };
+    }
+
+    /**
+     * Lab -> sRGB 转换函数
+     */
+    function preciseLabToRGB(L, a, b) {
+        const labToXyz = (L, a, b) => {
+            const refX = 0.95047;
+            const refY = 1.00000;
+            const refZ = 1.08883;
+            
+            const epsilon = 0.008856;
+            const kappa = 903.3;
+            
+            const fy = (L + 16) / 116;
+            const fx = a / 500 + fy;
+            const fz = fy - b / 200;
+            
+            const xr = fx ** 3 > epsilon ? fx ** 3 : (116 * fx - 16) / kappa;
+            const yr = L > kappa * epsilon ? ((L + 16) / 116) ** 3 : L / kappa;
+            const zr = fz ** 3 > epsilon ? fz ** 3 : (116 * fz - 16) / kappa;
+            
+            return [
+                xr * refX,
+                yr * refY,
+                zr * refZ
+            ];
+        };
+        
+        const xyzToLinearRgb = (x, y, z) => {
+            const M = [
+                [ 3.2404542, -1.5371385, -0.4985314],
+                [-0.9692660,  1.8760108,  0.0415560],
+                [ 0.0556434, -0.2040259,  1.0572252]
+            ];
+            
+            const r = M[0][0] * x + M[0][1] * y + M[0][2] * z;
+            const g = M[1][0] * x + M[1][1] * y + M[1][2] * z;
+            const b = M[2][0] * x + M[2][1] * y + M[2][2] * z;
+            
+            return [r, g, b];
+        };
+        
+        const applyGamma = (c) => {
+            const sign = c < 0 ? -1 : 1;
+            const absC = sign * c;
+            
+            if (absC <= 0.0031308) {
+                return 12.92 * absC;
+            } else {
+                return sign * (1.055 * Math.pow(absC, 1/2.4) - 0.055);
+            }
+        };
+        
+        const clamp = (value) => {
+            return Math.max(0, Math.min(255, value * 255 |0));
+        };
+        
+        const [X, Y, Z] = labToXyz(L, a, b);
+        const [linearR, linearG, linearB] = xyzToLinearRgb(X, Y, Z);
+        
+        const r = applyGamma(linearR);
+        const g = applyGamma(linearG);
+        const bOut = applyGamma(linearB);
+        
+        return {
+            r: clamp(r),
+            g: clamp(g),
+            b: clamp(bOut)
+        };
+    }
+
+    /**
+     * Lab -> Display P3 转换
+     */
+    function labToP3(L, a, b) {
+        const labToXyz = (L, a, b) => {
+            const refX = 0.95047;
+            const refY = 1.00000;
+            const refZ = 1.08883;
+            
+            const epsilon = 0.008856;
+            const kappa = 903.3;
+            
+            const fy = (L + 16) / 116;
+            const fx = a / 500 + fy;
+            const fz = fy - b / 200;
+            
+            const xr = fx ** 3 > epsilon ? fx ** 3 : (116 * fx - 16) / kappa;
+            const yr = L > kappa * epsilon ? ((L + 16) / 116) ** 3 : L / kappa;
+            const zr = fz ** 3 > epsilon ? fz ** 3 : (116 * fz - 16) / kappa;
+            
+            return [
+                xr * refX,
+                yr * refY,
+                zr * refZ
+            ];
+        };
+        
+        const xyzToLinearP3 = (x, y, z) => {
+            const M = [
+                [ 2.493496911941425, -0.9313836179191239, -0.40271078445071684],
+                [-0.8294889695615747,  1.7626640603183463,  0.023624685841943577],
+                [ 0.03584583024378447, -0.07617238926804182, 0.9568845240076872]
+            ];
+            
+            const r = M[0][0] * x + M[0][1] * y + M[0][2] * z;
+            const g = M[1][0] * x + M[1][1] * y + M[1][2] * z;
+            const b = M[2][0] * x + M[2][1] * y + M[2][2] * z;
+            
+            return [r, g, b];
+        };
+        
+        const applyGamma = (c) => {
+            const sign = c < 0 ? -1 : 1;
+            const absC = Math.abs(c);
+            
+            if (absC <= 0.0031308) {
+                return sign * 12.92 * absC;
+            } else {
+                return sign * (1.055 * Math.pow(absC, 1/2.4) - 0.055);
+            }
+        };
+        
+        const clamp = (value) => {
+            return Math.max(0, Math.min(255, value * 255 |0));
+        };
+        
+        try {
+            const [X, Y, Z] = labToXyz(L, a, b);
+            const [linearR, linearG, linearB] = xyzToLinearP3(X, Y, Z);
+            
+            const r = applyGamma(linearR);
+            const g = applyGamma(linearG);
+            const bOut = applyGamma(linearB);
+            
+            return {
+                r: Math.max(0, Math.min(1, r)),
+                g: Math.max(0, Math.min(1, g)),
+                b: Math.max(0, Math.min(1, bOut))
+            };
+        } catch (error) {
+            console.warn('P3转换失败:', error);
+            const rgb = preciseLabToRGB(L, a, b);
+            return {
+                r: rgb.r / 255,
+                g: rgb.g / 255,
+                b: rgb.b / 255
+            };
+        }
+    }
+
+    /**
+     * 生成颜色字符串
+     */
+    function generateColorString(L, a, b, config, alpha = null) {
+        if (!config.enableP3 || !detectP3Support()) {
+            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 {
+            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})`;
+            }
+            return `color(display-p3 ${p3.r.toFixed(4)} ${p3.g.toFixed(4)} ${p3.b.toFixed(4)})`;
+        }
+    }
+
+    /**
+     * 处理CSS值
+     */
+    function processCSSValue(value, config) {
+        let result = value;
+        
+        if (config.enableMath) {
+            result = processMathFunctions(result, config);
+        }
+        
+        if (config.convertLabToRGB || config.convertLchToRGB) {
+            result = convertAllLabLchColors(result, config);
+        }
+        
+        return result;
+    }
+    
+/**
+ * 状态机解析嵌套规则（包含变量提取）
+ */
+function parseNestedRules(cssText, config, aliases, macros) {
+    const rootRules = [];
+    const stack = [];
+    const globalVariables = {}; // 存储全局变量
+    
+    let currentRule = null;
+    let currentLine = '';
+    let inRuleBlock = false;
+    let braceDepth = 0;
+    let isGlobalScope = true; // 标记是否在全局作用域
+    
+    for (let i = 0, length = cssText.length; i < length; i++) {
+        const char = cssText[i];
+        const charCode = cssText.charCodeAt(i);
+        
+        if (charCode === 123) {  // 123: "{"的码点
+            braceDepth++;
+            
+            // 在处理{之前，检查当前行是否有变量定义（仅限全局作用域）
+            if (isGlobalScope && currentLine.trim()) {
+                const varMatch = currentLine.trim().match(/^\$([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+?);?$/);
+                if (varMatch) {
+                    const [, varName, varValue] = varMatch;
+                    globalVariables[varName] = processCSSValue(varValue.trim(), config);
+                    currentLine = '';
+                    continue;
+                }
+            }
+            
+            if (!inRuleBlock) {
+                // 新规则开始
+                currentRule = {
+                    selector: currentLine.trim(),
+                    properties: [],
+                    children: []
+                };
+                stack.push(currentRule);
+                inRuleBlock = true;
+                isGlobalScope = false; // 进入选择器块，不再是全局作用域
+            } else {
+                // 嵌套规则开始，需要先处理当前行的属性
+                if (currentLine.trim() && currentLine.includes(':')) {
+                    const parsed = parseSingleLineCSS(currentLine.trim(), aliases, macros);
+                    parsed.forEach(obj => {
+                        const key = Object.keys(obj)[0];
+                        const value = processCSSValue(obj[key], config);
+                        if (currentRule) {
+                            currentRule.properties.push(!value.length ? key : `${key}: ${value}`);
+                        }
+                    });
+                }
+                // 开始嵌套规则
+                const nestedRule = {
+                    selector: currentLine.trim(),
+                    properties: [],
+                    children: []
+                };
+                stack.push(nestedRule);
+                currentRule = nestedRule;
+            }
+            currentLine = '';
+        } else if (charCode === 125) {  // 125: "}"的码点
+            braceDepth--;
+            
+            // 处理当前行的属性（在}之前的属性）
+            if (currentLine.trim() && currentLine.includes(':')) {
+                const parsed = parseSingleLineCSS(currentLine.trim(), aliases, macros);
+                parsed.forEach(obj => {
+                    const key = Object.keys(obj)[0];
+                    const value = processCSSValue(obj[key], config);
+                    if (currentRule) {
+                        currentRule.properties.push(!value.length ? key : `${key}: ${value}`);
+                    }
+                });
+            }
+            
+            // 规则结束
+            const finishedRule = stack.pop();
+            
+            if (stack.length === 0) {
+                rootRules.push(finishedRule);
+                inRuleBlock = false;
+                currentRule = null;
+                isGlobalScope = true; // 回到全局作用域
+            } else {
+                const parentRule = stack[stack.length - 1];
+                if (!parentRule.children) {
+                    parentRule.children = [];
+                }
+                parentRule.children.push(finishedRule);
+                currentRule = parentRule;
+            }
+            
+            currentLine = '';
+            
+            if (braceDepth === 0) {
+                inRuleBlock = false;
+                isGlobalScope = true;
+            }
+        } else if (charCode === 10 || charCode === 59) {
+            // 行结束，处理当前行的属性或变量
+            if (inRuleBlock && currentLine.trim() && currentLine.includes(':')) {
+                const parsed = parseSingleLineCSS(currentLine.trim(), aliases, macros);
+                parsed.forEach(obj => {
+                    const key = Object.keys(obj)[0];
+                    const value = processCSSValue(obj[key], config);
+                    if (currentRule) {
+                        currentRule.properties.push(!value.length ? key : `${key}: ${value}`);
+                    }
+                });
+            } else if (isGlobalScope && currentLine.trim()) {
+                // 全局作用域中检查变量定义
+                const varMatch = currentLine.trim().match(/^\$([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+?);?$/);
+                if (varMatch) {
+                    const [, varName, varValue] = varMatch;
+                    globalVariables[varName] = processCSSValue(varValue.trim(), config);
+                    currentLine = '';
+                    continue;
+                }
+            }
+            currentLine = '';
+        } else {
+            currentLine += char;
+        }
+    }
+    
+    // 处理最后一行（可能在全局作用域中的变量）
+    if (isGlobalScope && currentLine.trim()) {
+        const varMatch = currentLine.trim().match(/^\$([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+?);?$/);
+        if (varMatch) {
+            const [, varName, varValue] = varMatch;
+            globalVariables[varName] = processCSSValue(varValue.trim(), config);
+        }
+    } else if (inRuleBlock && currentLine.trim() && currentLine.includes(':')) {
+        const parsed = parseSingleLineCSS(currentLine.trim(), aliases, macros);
+        parsed.forEach(obj => {
+            const key = Object.keys(obj)[0];
+            const value = processCSSValue(obj[key], config);
+            if (currentRule) {
+                currentRule.properties.push(!value.length ? key : `${key}: ${value}`);
+            }
+        });
+    }
+    
+    // 如果存在全局变量，创建:root规则并添加到rootRules开头
+    if (Object.keys(globalVariables).length > 0) {
+        const rootVarsRule = {
+            selector: config.rootSelector,
+            properties: [],
+            children: []
+        };
+        
+        // 将变量转换为CSS属性
+        Object.entries(globalVariables).forEach(([name, value]) => {
+            rootVarsRule.properties.push(`--${name}: ${value}`);
+        });
+        
+        // 添加到rootRules的开头
+        rootRules.unshift(rootVarsRule);
+    }
+    
+    return convertRulesToCSS(rootRules, config, '', aliases, macros);
+}
+    
+    /**
+     * 将规则树转换为CSS
+     */
+    function convertRulesToCSS(rules, config, parentSelector = '', aliases, macros, isRootAt = false) {
+        let result = '';
+        
+        for (const rule of rules) {
+            const isAt = rule.selector.startsWith("@");
+            
+            if (isAt) {
+                result += rule.selector + " {\n";
+            }
+            
+            let fullSelector = rule.selector;
+            
+            if (parentSelector) {
+                if (fullSelector.includes('&')) {
+                    fullSelector = fullSelector.replace(REGEX.AND, parentSelector);
+                } else if (fullSelector.trim().startsWith(':')) {
+                    fullSelector = parentSelector + fullSelector;
+                } else {
+                    fullSelector = parentSelector + " " + fullSelector;
+                }
+            }
+            
+            fullSelector = fullSelector;
+            
+            if (rule.properties.length > 0) {
+                result += (isRootAt ? " ".repeat(config.indentSize) : '') + fullSelector + ' {\n';
+                for (const prop of rule.properties) {
+                    const parsed = parseSingleLineCSS(prop, aliases, macros);
+                    parsed.forEach(obj => {
+                        const key = Object.keys(obj)[0];
+                        const value = processCSSValue(obj[key], config);
+                        result += (isRootAt ? " ".repeat(config.indentSize) : '') + " ".repeat(config.indentSize) + (!value.length ? key : `${key}: ${value};\n`);
+                    });
+                }
+                result += isRootAt ? " ".repeat(config.indentSize) + '}\n' : '}\n\n';
+            }
+            
+            if (rule.children && rule.children.length > 0) {
+                result += convertRulesToCSS(rule.children, config, (isAt ? "" : fullSelector), aliases, macros, isRootAt || isAt);
+            }
+            
+            if (isAt) {
+                result += "}\n\n";
+            }
+        }
+        
+        return result;
+    }
+
+    /**
+     * 替换变量使用
+     */
+    function replaceVariableUses(cssText, config) {
+        let result = cssText;
+        result = result.replace(REGEX.VARIABLE, (match, varName) => {
+            return match.startsWith('$$') ? `attr(${varName})` : `var(--${varName})`;
+        });
+        
+        result = processCSSValue(result, config);
+        
+        return result;
+    }
+
+    /**
+     * 处理 @import 语句
+     */
+    async function processImports(cssText, config) {
+        const importRegex = REGEX.IMPORT;
+        
+        const processRecursive = async (text) => {
+            const importPromises = [];
+            
+            const processedText = text.replace(importRegex, (match, url) => {
+                const importPromise = fetchImportContent(url, config)
+                    .then(importedCSS => {
+                        return processImports(importedCSS, config);
+                    })
+                    .catch(error => {
+                        console.warn(`无法导入CSS文件: ${url}`, error);
+                        return '';
+                    });
+                
+                importPromises.push(importPromise);
+                
+                return `__IMPORT_PLACEHOLDER_${importPromises.length - 1}__`;
+            });
+            
+            if (importPromises.length > 0) {
+                const importedContents = await Promise.all(importPromises);
+                
+                let finalText = processedText;
+                for (let i = importedContents.length; i--;) {
+                    finalText = finalText.replace(`__IMPORT_PLACEHOLDER_${i}__`, importedContents[i]);
+                }
+                
+                return finalText;
+            }
+            
+            return processedText;
+        };
+        
+        return processRecursive(cssText);
+    }
+
+    /**
+     * 获取导入的CSS内容
+     */
+    async function fetchImportContent(url, config) {
+        if (config.importCache && importCache.has(url)) {
+            return importCache.get(url);
+        }
+        
+        const fullUrl = config.importBaseUrl 
+            ? new URL(url, config.importBaseUrl).href
+            : url;
+        
+        let content;
+        
+        const isNode = typeof process !== 'undefined' && 
+                      process.versions && 
+                      process.versions.node;
+        
+        if (isNode && typeof require !== 'undefined') {
+            try {
+                const fs = require('fs');
+                const path = require('path');
+                
+                let filePath = fullUrl;
+                if (fullUrl.startsWith('.')) {
+                    filePath = path.join(process.cwd(), fullUrl);
+                }
+                
+                content = fs.readFileSync(filePath, 'utf-8');
+            } catch (error) {
+                throw new Error(`Node.js文件读取失败: ${fullUrl} - ${error.message}`);
+            }
+        } else {
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), config.importTimeout);
+                
+                const response = await fetch(fullUrl, {
+                    signal: controller.signal,
+                    headers: {
+                        'Accept': 'text/css'
+                    }
+                });
+                
+                clearTimeout(timeoutId);
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP错误: ${response.status} ${response.statusText}`);
+                }
+                
+                content = await response.text();
+            } catch (error) {
+                if (error.name === 'AbortError') {
+                    throw new Error(`导入超时: ${fullUrl}`);
+                }
+                throw new Error(`无法获取CSS: ${fullUrl} - ${error.message}`);
+            }
+        }
+        
+        if (config.importCache) {
+            importCache.set(url, content);
+        }
+        
+        return content;
+    }
+
+    /**
+     * 主转换函数
+     */
+    async function convert(cssText, customConfig = {}) {
+        let { config: headerConfig, css: cleanedCSS } = parseConfigHeader(cssText);
+        const finalConfig = { ...defaultConfig, ...customConfig, ...headerConfig };
+        cleanedCSS = await processImports(cleanedCSS, finalConfig);
+        
+        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 processedCSS = cssWithMacros.trim();
+        if (finalConfig.enableNesting && cssWithMacros.includes('{')) {
+            try {
+                processedCSS = parseNestedRules(cssWithMacros, finalConfig, aliases, macros);
+            } catch (error) {
+                console.warn('嵌套解析失败，使用原始CSS:', error);
+            }
+        }
+        
+        let finalCSS = processedCSS;
+        
+        finalCSS = replaceVariableUses(finalCSS, finalConfig);
+        
+        for (const [name, plugin] of pluginMap) {
+            try {
+                finalCSS = plugin.convert(finalCSS, finalConfig);
+            } catch (error) {
+                console.error('插件处理失败:', error);
+            }
+        }
+        
+        return finalCSS;
+    }
+
+    /**
+     * 自动处理带有特定属性的 style 标签
+     */
+    function autoProcessStyleTags(customConfig = {}) {
+        const config = { ...defaultConfig, ...customConfig };
+        const styleTags = document.querySelectorAll(`style[${config.styleTagAttribute || 'e'}]`);
+        
+        styleTags.forEach(styleTag => {
+            let originalCSS = styleTag.textContent;
+            
+            const processStyleTag = async () => {
+                try {
+                    if (styleTag.getAttribute("src")){
+                        originalCSS = "@import "+styleTag.getAttribute("src")+";";
+                    }
+                    const convertedCSS = await convert(originalCSS, config);
+                    
+                    const newStyleTag = document.createElement('style');
+                    newStyleTag.textContent = convertedCSS;
+                    
+                    styleTag.parentNode.insertBefore(newStyleTag, styleTag.nextSibling);
+                    
+                    if (!config.preserveOriginal) {
+                        styleTag.remove();
+                    } else {
+                        styleTag.style.display = 'none';
+                    }
+                } catch (error) {
+                    console.error('处理style标签失败:', error);
+                }
+            };
+            
+            processStyleTag();
+        });
+        
+        return styleTags.length;
+    }
+
+    function config(config = {}) {
+        defaultConfig = { ...defaultConfig, ...config };
+    }
+
+    /**
+     * 应用CSS到页面
+     */
+    function apply(cssText, customConfig = {}) {
+        const config = { ...defaultConfig, ...customConfig };
+        
+        if (cssText) {
+            return (async () => {
+                try {
+                    const converted = await convert(cssText, config);
+                    const styleEl = document.createElement('style');
+                    styleEl.textContent = converted;
+                    document.head.appendChild(styleEl);
+                    return styleEl;
+                } catch (error) {
+                    console.error('应用CSS失败:', error);
+                    return null;
+                }
+            })();
+        } else {
+            if (document.readyState === 'loading') {
+                document.addEventListener('DOMContentLoaded', () => {
+                    autoProcessStyleTags(config);
+                });
+            } else {
+                autoProcessStyleTags(config);
+            }
+        }
+    }
+
+    // 创建公共 API
+    const api = {
+        convert,
+        apply,
+        config,
+        
+        supportsP3: detectP3Support(),
+        
+        detectP3Support: detectP3Support,
+        
+        imports: {
+            clearCache: function() {
+                importCache.clear();
+            },
+            setBaseUrl: function(baseUrl) {
+                defaultConfig.importBaseUrl = baseUrl;
+            },
+            setCacheEnabled: function(enabled) {
+                defaultConfig.importCache = enabled;
+            },
+            setTimeout: function(timeout) {
+                defaultConfig.importTimeout = timeout;
+            }
+        },
+        
+        plugins: {
+            use(plugin) {
+                const pluginObj = new plugin();
+                pluginMap.set(pluginObj.name ?? plugin.name, pluginObj);
+                return true;
+            },
+            remove(name) {
+                if (pluginMap.get(name)?.destroy) {
+                    pluginMap.get(name).destroy();
+                }
+                pluginMap.delete(name);
+                return true;
+            },
+            getAll: function() {
+                return Array.from(pluginMap.entries());
+            },
+            clear: function() {
+                pluginMap.clear();
+            }
+        },
+        
+        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, length = macro.params.length; i < 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: {
+            evaluate: function(expression) {
+                return evaluateMathExpression(expression, defaultConfig);
+            }
+        },
+        
+        colorUtils: {
+            labToRGB: preciseLabToRGB,
+            lchToLab: lchToLab,
+            lchToRGB: function(L, C, H) {
+                const lab = lchToLab(L, C, H);
+                return preciseLabToRGB(lab.L, lab.a, lab.b);
+            },
+            labToP3: labToP3,
+            lchToP3: function(L, C, H) {
+                const lab = lchToLab(L, C, H);
+                return labToP3(lab.L, lab.a, lab.b);
+            },
+            parseHexLab: function(hexString) {
+                const match = hexString.match(/lab#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})/i);
+                if (!match) return null;
+                
+                const L_hex = match[1];
+                const A_hex = match[2];
+                const B_hex = match[3];
+                
+                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;
+                
+                return preciseLabToRGB(L, A, B);
+            },
+            parseHexLch: function(hexString) {
+                const match = hexString.match(/lch#([0-9a-f]{2})([0-9a-f]{2})(\d{1,3})/i);
+                if (!match) return null;
+                
+                const L_hex = match[1];
+                const C_hex = match[2];
+                const H_dec = match[3];
+                
+                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);
+                return preciseLabToRGB(lab.L, lab.a, lab.b);
+            },
+            generateColor: function(L, a, b, alpha = null, useP3 = true) {
+                return generateColorString(L, a, b, { enableP3: useP3 }, alpha);
+            },
+            parseColor: function(colorString) {
+                try {
+                    const labMatch = colorString.match(/lab\(\s*([\d.]+)(%?)\s+([\d.-]+)\s+([\d.-]+)(?:\s*\/\s*([\d.%]+))?\s*\)/i);
+                    if (labMatch) {
+                        let L = parseFloat(labMatch[1]);
+                        const A = parseFloat(labMatch[3]);
+                        const B = parseFloat(labMatch[4]);
+                        const alpha = labMatch[5] ? 
+                            (labMatch[5].includes('%') ? parseFloat(labMatch[5]) / 100 : parseFloat(labMatch[5])) : 
+                            null;
+                        
+                        const colorStr = generateColorString(L, A, B, defaultConfig, alpha);
+                        
+                        return {
+                            L, A, B, alpha,
+                            rgb: preciseLabToRGB(L, A, B),
+                            p3: labToP3(L, A, B),
+                            colorString: colorStr
+                        };
+                    }
+                    
+                    const lchMatch = colorString.match(/lch\(\s*([\d.]+)(%?)\s+([\d.]+)\s+([\d.]+)(deg)?(?:\s*\/\s*([\d.%]+))?\s*\)/i);
+                    if (lchMatch) {
+                        let L = parseFloat(lchMatch[1]);
+                        const C = parseFloat(lchMatch[3]);
+                        let H = parseFloat(lchMatch[4]);
+                        const alpha = lchMatch[6] ? 
+                            (lchMatch[6].includes('%') ? parseFloat(lchMatch[6]) / 100 : parseFloat(lchMatch[6])) : 
+                            null;
+                        
+                        const lab = lchToLab(L, C, H);
+                        const colorStr = generateColorString(lab.L, lab.a, lab.b, defaultConfig, alpha);
+                        
+                        return {
+                            L, C, H, alpha,
+                            lab: lab,
+                            rgb: preciseLabToRGB(lab.L, lab.a, lab.b),
+                            p3: labToP3(lab.L, lab.a, lab.b),
+                            colorString: colorStr
+                        };
+                    }
+                    
+                    return null;
+                } catch (error) {
+                    console.warn('无法解析颜色:', colorString, error);
+                    return null;
+                }
+            }
+        }
+    };
+
+    // 创建主函数
+    const styimat = async function(...args) {
+        if (args.length > 1 || (args[0] && args[0].raw)) {
+            return await handleTemplateTag(...args);
+        }
+
+        const firstArg = args[0];
+
+        if (typeof firstArg === 'string') {
+            const result = await convert(firstArg, args[1]);
+            
+            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();
+        }
+
+        return styimat;
+    };
+
+    async function handleTemplateTag(strings, ...values) {
+        let cssText = strings[0];
+
+        for (let i = 0, length = values.length; i < length; i++) {
+            const value = values[i];
+            let result = '';
+
+            if (typeof value === 'function') {
+                result = value();
+            } else if (Array.isArray(value)) {
+                result = value.join(' ');
+            } else {
+                result = String(value != null ? value : 'none');
+            }
+
+            cssText += result + strings[i + 1];
+        }
+
+        const result = await convert(cssText, defaultConfig);
+        
+        if (result && typeof result.then === 'function') {
+            return result;
+        }
+        return result;
+    }
+
+    Object.assign(styimat, api);
+    
+    // 自动初始化
+    if (typeof window !== 'undefined') {
+        apply();
+        Object.defineProperty(window.HTMLElement.prototype, 'cssVar', {
+            get() {
+                const element = this;
+                return new Proxy(() => {}, {
+                    get(target, prop) {
+                        const varName = prop.startsWith('--') ? prop : `--${prop}`;
+                        return element.style.getPropertyValue(varName);
+                    },
+                    
+                    set(target, prop, value) {
+                        const varName = prop.startsWith('--') ? prop : `--${prop}`;
+                        element.style.setProperty(varName, value);
+                        return true;
+                    },
+                    
+                    apply(target, thisArg, argumentsList) {
+                        const prop = argumentsList[0];
+                        const value = argumentsList[1];
+                        const varName = prop.startsWith('--') ? prop : `--${prop}`;
+                        if (value === undefined) return element.style.getPropertyValue(varName);
+                        element.style.setProperty(varName, value);
+                    }
+                });
+            }
+        });
+    }
+    
+    return styimat;
+})();
+
+define([], _=>styimat);