styimat 1.11.0 → 1.11.2

package/README.md

@@ -124,12 +124,10 @@ npx styimat
 # 全局安装后使用
 npm install -g styimat
 styimat input.css output.css
-
-# 监听
-npx styimat --watch input.css output.css
-npx styimat -w input.css output.css
 ```
 
+**更多使用方法请 `npx styimat -h`**
+
 ## 高级用法
 
 ### 1. 作为函数直接调用
@@ -632,8 +630,9 @@ $primary-transparent: lab(55 190 0 / 0.8);
 欢迎贡献代码！请遵循以下步骤：
 
 1. **Fork 本仓库**  
-[![Forks](https://img.shields.io/badge/点击即可Forks-red?logo=gitee)](https://gitee.com/wxy6987/styimat/members)
-2. **创建特性分支**  
+[![Fork me on Gitee](https://gitee.com/wxy6987/styimat/widgets/widget_2.svg)](https://gitee.com/wxy6987/styimat/members)
+
+2. **切换到特性分支**
 ```bash
 git checkout -b feature/AmazingFeature
 ```

package/convert-styimat.js

@@ -18,6 +18,8 @@ async function main() {
         
         if (arg === '--watch' || arg === '-w') {
             watchMode = true;
+        } else if (arg === '--interactive' || arg === '-i') {
+            interactiveMode();
         } else if (arg === '--help' || arg === '-h') {
             showHelp();
             process.exit(0);
@@ -38,17 +40,19 @@ async function main() {
     
     function showHelp() {
         console.log(`
-用法: huecss-converter [选项] [输入文件] [输出文件]
+用法: styimat [选项] [输入文件] [输出文件]
 
 选项:
-  -w, --watch  监控输入文件变化并自动转换
-  -h, --help   显示帮助信息
+  -w, --watch        监控输入文件变化并自动转换
+  -h, --help         显示帮助信息
+  -i, --interactive  进入交互模式
 
 示例:
-  huecss-converter                     # 从 stdin 读取，输出到 stdout
-  huecss-converter input.css          # 从文件读取，输出到 stdout
-  huecss-converter input.css output.css # 从文件读取，输出到文件
-  huecss-converter -w input.css output.css # 监控并自动转换
+  styimat                         # 从 stdin 读取，输出到 stdout
+  styimat input.css               # 从文件读取，输出到 stdout
+  styimat input.css output.css    # 从文件读取，输出到文件
+  styimat -w input.css output.css # 监控并自动转换
+  styimat -i                      # 进入交互模式
 `);
     }
     
@@ -104,7 +108,7 @@ async function main() {
         
         // 处理进程终止
         process.on('SIGINT', () => {
-            console.log('\n停止监控...');
+            console.log('停止监控...\n');
             watcher.close();
             process.exit(0);
         });
@@ -119,7 +123,7 @@ async function main() {
 async function convertFile(inputFilePath, outputFilePath) {
     try {
         const inputContent = fs.readFileSync(inputFilePath, 'utf8');
-        const outputContent = await convertHuecss(inputContent);
+        const outputContent = await convertStyimat(inputContent);
         fs.writeFileSync(outputFilePath, outputContent, 'utf8');
         console.log(`${new Date().toLocaleTimeString()} - 转换完成: ${inputFilePath} -> ${outputFilePath}`);
     } catch (error) {
@@ -127,9 +131,34 @@ async function convertFile(inputFilePath, outputFilePath) {
     }
 }
 
+async function interactiveMode() {
+    console.log('提示: 在这个模式下，您需要一次性输入所有 CSS 代码');
+    console.log('输入完成后按 Ctrl+D (Unix) 或 Ctrl+Z (Windows)\n');
+
+    console.log('请输入 CSS 代码:');
+    console.log('='.repeat(50));
+
+    try {
+        // 读取 stdin
+        const inputData = fs.readFileSync(0, 'utf8').trim();
+        
+        if (!inputData) {
+            console.log('没有输入内容');
+            return;
+        }
+
+        const output = await convertStyimat(inputData);
+        console.log('\n转换结果:');
+        console.log(output);
+        
+    } catch (error) {
+        console.error('错误:', error.message);
+    }
+}
+
 async function convertAndOutput(inputContent, outputFile) {
     try {
-        const outputContent = await convertHuecss(inputContent);
+        const outputContent = await convertStyimat(inputContent);
         
         if (outputFile) {
             fs.writeFileSync(outputFile, outputContent, 'utf8');
@@ -142,7 +171,7 @@ async function convertAndOutput(inputContent, outputFile) {
     }
 }
 
-async function convertHuecss(inputContent) {
+async function convertStyimat(inputContent) {
     // 尝试从多个位置加载 styimat.js
     const possiblePaths = [
         path.join(__dirname, 'styimat.js'),
@@ -150,11 +179,11 @@ async function convertHuecss(inputContent) {
         path.join(process.cwd(), 'node_modules', 'styimat', 'styimat.js')
     ];
     
-    let huecssModule = null;
+    let styimatModule = null;
     for (const modulePath of possiblePaths) {
         try {
             if (fs.existsSync(modulePath)) {
-                huecssModule = require(modulePath);
+                styimatModule = require(modulePath);
                 break;
             }
         } catch (e) {
@@ -162,19 +191,19 @@ async function convertHuecss(inputContent) {
         }
     }
     
-    if (!huecssModule) {
+    if (!styimatModule) {
         throw new Error('找不到 styimat.js 模块');
     }
     
     // 获取转换函数
-    const huecss = huecssModule.huecss || huecssModule;
+    const styimat = styimatModule.styimat || styimatModule;
     
-    if (typeof huecss.convert !== 'function') {
+    if (typeof styimat.convert !== 'function') {
         throw new Error('styimat.convert 不是函数');
     }
     
     // 执行转换
-    return await huecss.convert(inputContent);
+    return await styimat.convert(inputContent);
 }
 
 // 处理 promise 错误

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "styimat",
-  "version": "1.11.0",
+  "version": "1.11.2",
   "description": "一个高效的CSS变量预处理库，支持Lab/LCH颜色空间自动转换、嵌套选择器和Display P3广色域，让现代CSS开发更简洁强大。",
   "keywords": [
     "css",
@@ -41,7 +41,7 @@
   "homepage": "https://gitee.com/wxy6987/styimat#readme",
   "scripts": {
     "test": "echo \"No tests yet\" && exit 0",
-    "build:min": "npx terser styimat.js -o styimat.min.js --comments '/^!'",
+    "build:min": "npx esbuild styimat.js --minify --outfile=styimat.min.js",
     "prepare": "npm run build:min",
     "prepublishOnly": "npm run build:min",
     "postpublish": "npm run git:auto-commit && npm run git:auto-tag",
@@ -53,7 +53,9 @@
     "git:auto-tag": "git tag -d v$(node -p \"require('./package.json').version\") 2>/dev/null || true && git tag -a v$(node -p \"require('./package.json').version\") -m 'Version $(node -p \"require('./package.json').version\")' && git push && git push --tags"
   },
   "dependencies": {
-    "chokidar": "^5.0.0",
-    "terser": "^5.44.1"
+    "chokidar": "^5.0.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.27.2"
   }
 }

package/styimat.min.js

@@ -1,634 +1,29 @@
 /*!
  * MIT License
  * Copyright (c) 2025 王小玗
- */
-/**
- * CSS 变量预处理库 - 增强版
- * 支持 CSS 变量预处理、嵌套选择器和嵌套变量
- * 支持 Lab 和 LCH 颜色空间转换为 RGB（CSS标准格式）
- * 支持 lab# 和 lch# 十六进制语法
- * 支持 Display P3 广色域显示器
- * 增强 math() 函数，支持复杂数学计算
- * 支持配置头
- * 支持 @import 语法
- */
-(function(root,factory){if(typeof define==="function"&&define.amd){
-// AMD 支持 (RequireJS)
-define([],factory)}else if(typeof module==="object"&&module.exports){
-// CommonJS 支持 (Node.js, Browserify, Webpack)
-module.exports=factory()}else{
-// 浏览器全局变量
-root.styimat=factory()}})(typeof self!=="undefined"?self:this,function(){
-// 默认配置
-let defaultConfig={rootSelector:":root",variablePrefix:"--",preserveOriginal:false,indentSize:4,enableNesting:true,autoProcessStyleTags:true,styleTagAttribute:"e",convertLabToRGB:true,convertLchToRGB:true,enableP3:true,enableMath:true,// 启用math()函数增强
-mathPrecision:6,// 数学计算精度
-importBaseUrl:"",// @import 的基础URL
-importCache:true,// 缓存导入的文件
-importTimeout:5e3};
-// 全局P3支持检测结果
-let p3Supported=null;
-// 导入文件缓存
-const importCache=new Map;
-/**
-     * 解析配置头
-     * @param {string} cssText - CSS文本
-     * @returns {Object} {config: 配置对象, css: 清理后的CSS}
-     */function parseConfigHeader(cssText){const config={...defaultConfig};const lines=cssText.split("\n");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!==-1){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{console.warn(`未知的配置项: ${key}`)}}else{console.warn(`无效的配置行: ${trimmed}`)}}else{cleanLines.push(line)}}return{config:config,css:cleanLines.join("\n")}}
-/**
-     * 将连字符分隔的字符串转换为驼峰命名
-     * @param {string} str - 输入字符串
-     * @returns {string} 驼峰命名字符串
-     */function camelCase(str){return str.replace(/-([a-z])/g,function(match,letter){return letter.toUpperCase()})}
-/**
-     * 检测浏览器是否支持 Display P3
-     * @returns {boolean} 是否支持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){console.warn("P3支持检测失败:",error);p3Supported=false}return p3Supported}
-/**
-     * 解析一行CSS（可能多个语句在同一行，可能最后一个语句没有分号）
-     * 返回格式：[{属性名:值}, {属性名:值}, ...]
-     * @param {string} cssString - 要解析的CSS字符串
-     * @returns {Array} 包含属性名值对象的数组
-     */function parseSingleLineCSS(cssString){
-// 移除首尾空白字符
-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="";// 当前引号字符
-for(let i=0;i<str.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(const declaration of declarations){
-// 跳过空声明
-if(!declaration.trim())continue;
-// 查找第一个冒号的位置
-const colonIndex=findFirstColonOutsideQuotes(declaration);if(colonIndex===-1){console.warn(`无效的CSS声明: "${declaration}"`);continue}
-// 分割属性名和值
-const property=declaration.substring(0,colonIndex).trim();let value=declaration.substring(colonIndex+1).trim();
-// 如果值以分号结尾，移除它（理论上不应该有，但处理一下）
-if(value.endsWith(";")){value=value.slice(0,-1).trim()}
-// 添加到结果数组
-result.push({[property]:value})}return result}
-/**
-     * 查找不在引号内的第一个冒号位置
-     * @param {string} str 
-     * @returns {number}
-     */function findFirstColonOutsideQuotes(str){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}else if(char===quoteChar&&inQuotes){inQuotes=false;quoteChar=""}
-// 如果找到冒号且不在引号内，返回位置
-if(char===":"&&!inQuotes){return i}}return-1}
-/**
-     * 增强的数学表达式解析和计算
-     * @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){console.warn("math()表达式解析失败:",expression,error);return`math(${expression})`}}
-/**
-     * 解析数学表达式
-     * @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);if(end===-1)break;const inner=expr.substring(start+1,end);const innerResult=parseMathExpression(inner,config);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},{regex:/([\d.]+(?:[a-zA-Z%]+)?)\+([\d.]+(?:[a-zA-Z%]+)?)/,handler:add},{regex:/([\d.]+(?:[a-zA-Z%]+)?)-([\d.]+(?:[a-zA-Z%]+)?)/,handler:subtract}];let lastExpr=expr;
-// 按照优先级处理操作符
-for(const op of operators){let match;while((match=expr.match(op.regex))!==null){const left=parseValueWithUnit(match[1]);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){throw new Error(`无法解析值: ${str}`)}const value=parseFloat(match[1]);const unit=match[2]||"";return{value:value,unit:unit}}
-/**
-     * 检查表达式是否包含单位
-     * @param {string} expr - 表达式
-     * @returns {boolean} 是否包含单位
-     */function hasUnits(expr){return/[a-zA-Z%]/.test(expr)}
-/**
-     * 处理带单位的表达式
-     * @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"}
-// 数学运算函数
-function multiply(a,b){if(a.unit===b.unit||!a.unit&&!b.unit){return{value:a.value*b.value,unit:a.unit||b.unit}}
-// 单位不匹配，返回原始表达式
-return{value:`${a.value}${a.unit}*${b.value}${b.unit}`,unit:""}}function divide(a,b){if(b.value===0){throw new Error("除以零")}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:""}}function add(a,b){if(a.unit===b.unit){return{value:a.value+b.value,unit:a.unit}}
-// 单位不匹配，返回原始表达式
-return{value:`${a.value}${a.unit}+${b.value}${b.unit}`,unit:""}}function subtract(a,b){if(a.unit===b.unit){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(/\.$/,"")}return str}
-/**
-     * 处理所有的math()函数
-     * @param {string} cssValue - CSS属性值
-     * @param {Object} config - 配置对象
-     * @returns {string} 转换后的CSS值
-     */function processMathFunctions(cssValue,config){if(!config.enableMath){return cssValue}let result=cssValue;
-// 匹配math()函数
-const mathRegex=/math\(([^)]+)\)/gi;
-// 递归处理嵌套的math()函数
-const processMath=str=>str.replace(mathRegex,(match,expression)=>evaluateMathExpression(expression,config));
-// 递归处理，直到没有更多math()函数
-let lastResult;do{lastResult=result;result=processMath(result)}while(result!==lastResult&&result.includes("math("));return result}
-/**
-     * 解析并转换所有的 Lab 和 LCH 颜色（全局一次性处理）
-     * @param {string} cssValue - CSS属性值
-     * @param {Object} config - 配置对象
-     * @returns {string} 转换后的CSS值
-     */function convertAllLabLchColors(cssValue,config){if(!config.convertLabToRGB&&!config.convertLchToRGB){return cssValue}let result=cssValue;
-// 首先处理特殊的十六进制格式
-result=parseHexColorFormats(result,config);
-// 一次性处理所有的 lab() 和 lch() 函数
-const colorFunctionRegex=/(lab|lch)\([^)]+\)/gi;
-// 存储已经处理过的颜色字符串，避免重复处理
-const processedColors=new Map;
-// 使用一个函数来递归处理嵌套的颜色函数
-const processColorFunctions=str=>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)}}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}
-/**
-     * 解析十六进制颜色格式：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 converted=generateColorString(L,A,B,config);processedHexColors.set(match,converted);return converted}catch(error){console.warn(`无法解析lab#十六进制颜色: ${match}`,error);return match}});
-// 处理 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 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() 颜色函数
-     * @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);if(!match){return labString}try{
-// 转换为数字
-let L=parseFloat(match[1]);
-// 如果L有百分号，转换为0-100范围的值
-if(match[2]==="%"){L=L;// 百分比值直接使用 (0-100)
-}else{
-// 没有百分号，确保在0-100范围内
-if(L<0)L=0;if(L>100)L=100}const A=parseFloat(match[3]);const B=parseFloat(match[4]);
-// 处理 alpha 通道（如果有）
-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() 颜色函数
-     * @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);if(!match){return lchString}try{
-// 转换为数字
-let L=parseFloat(match[1]);
-// 如果L有百分号，转换为0-100范围的值
-if(match[2]==="%"){L=L;// 百分比值直接使用 (0-100)
-}else{
-// 没有百分号，确保在0-100范围内
-if(L<0)L=0;if(L>100)L=100}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
-// LCH -> Lab
-const lab=lchToLab(L,C,H);
-// 处理 alpha 通道（如果有）
-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 (CSS标准)
-     * @param {number} L - 明度 0-100 或 0%-100%
-     * @param {number} C - 色度 >=0
-     * @param {number} H - 色相角 0-360 度
-     * @returns {Object} Lab 值 {L, a, b}
-     */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:L,a:a,b:b}}
-// 精确的 Lab -> sRGB 转换函数
-function preciseLabToRGB(L,a,b){
-// 1. Lab -> XYZ (D65白点)
-const labToXyz=(L,a,b)=>{
-// D65 白点参考值
-const refX=.95047;const refY=1;const refZ=1.08883;const epsilon=.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]};
-// 2. XYZ -> Linear RGB
-const xyzToLinearRgb=(x,y,z)=>{
-// sRGB 转换矩阵 (D65)
-const M=[[3.2404542,-1.5371385,-.4985314],[-.969266,1.8760108,.041556],[.0556434,-.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]};
-// 3. sRGB Gamma 校正
-const applyGamma=c=>{const sign=c<0?-1:1;const absC=Math.abs(c);if(absC<=.0031308){return sign*12.92*absC}else{return sign*(1.055*Math.pow(absC,1/2.4)-.055)}};
-// 4. 钳制到 [0, 255]
-const clamp=value=>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);const r=applyGamma(linearR);const g=applyGamma(linearG);const bOut=applyGamma(linearB);
-// 返回钳制后的 RGB 值
-return{r:clamp(r),g:clamp(g),b:clamp(bOut)}}
-/**
-     * 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=.95047;const refY=1;const refZ=1.08883;const epsilon=.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]};
-// 2. XYZ -> Linear P3
-const xyzToLinearP3=(x,y,z)=>{
-// Display P3 转换矩阵 (D65)
-const M=[[2.493496911941425,-.9313836179191239,-.40271078445071684],[-.8294889695615747,1.7626640603183463,.023624685841943577],[.03584583024378447,-.07617238926804182,.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]};
-// 3. P3 Gamma 校正（与sRGB相同）
-const applyGamma=c=>{const sign=c<0?-1:1;const absC=Math.abs(c);if(absC<=.0031308){return sign*12.92*absC}else{return sign*(1.055*Math.pow(absC,1/2.4)-.055)}};
-// 4. 钳制到 [0, 255]，然后转换为 [0, 1] 范围
-const clamp=value=>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);const r=applyGamma(linearR);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)),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}}}
-/**
-     * 生成颜色字符串（根据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})`}return`color(display-p3 ${p3.r.toFixed(4)} ${p3.g.toFixed(4)} ${p3.b.toFixed(4)})`}}
-/**
-     * 处理CSS值，根据配置转换LAB、LCH颜色和math()函数
-     * @param {string} value - CSS属性值
-     * @param {Object} config - 配置对象
-     * @returns {string} 处理后的值
-     */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)}return result}
-// 私有方法：提取变量定义并移除（支持嵌套作用域）
-function extractVariablesAndCSS(cssText,config){const lines=cssText.split("\n");const globalVariables={};const selectorVariables=new Map;let cssWithoutVars="";let currentSelector=null;let inSelectorBlock=false;let currentIndent=0;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,...currentSelector?selectorVariables.get(currentSelector)||{}:{}}),config);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;cssWithoutVars+=line+"\n";continue}
-// 检查是否是选择器结束
-if(trimmed==="}"){if(inSelectorBlock){
-// 在选择器结束前插入变量声明
-if(currentSelector&&selectorVariables.has(currentSelector)){const vars=selectorVariables.get(currentSelector);const indent=" ".repeat(currentIndent);for(const[varName,varValue]of Object.entries(vars)){cssWithoutVars+=`${indent}  --${varName}: ${varValue};\n`}}}inSelectorBlock=false;currentSelector=null}cssWithoutVars+=line+"\n";
-// 更新缩进级别
-if(line.includes("{")){currentIndent+=config.indentSize}if(line.includes("}")){currentIndent=Math.max(0,currentIndent-config.indentSize)}}return{globalVariables:globalVariables,selectorVariables:selectorVariables,cssWithoutVars:cssWithoutVars.trim()}}
-// 修复的嵌套解析函数
-function parseNestedRules(cssText,config){const lines=cssText.split("\n");const stack=[];// 存储规则信息：{selector, properties, children}
-const rootRules=[];let currentIndent=0;for(let i=0;i<lines.length;i++){const line=lines[i];const trimmed=line.trim();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);parsed.forEach(obj=>{const key=Object.keys(obj)[0];const value=processCSSValue(obj[key],config);currentRule.properties.push(`${key}: ${value}`)})}continue}}
-// 处理栈中剩余规则
-while(stack.length>0){const rule=stack.pop();if(stack.length===0){rootRules.push(rule)}else{const parent=stack[stack.length-1];if(!parent.children)parent.children=[];parent.children.push(rule)}}
-// 将规则树转换为CSS字符串
-return convertRulesToCSS(rootRules,config)}
-// 将规则树转换为CSS字符串
-function convertRulesToCSS(rules,config,parentSelector=""){let result="";const isParentAt=parentSelector.startsWith("@");for(const rule of rules){
-// 构建完整选择器
-const isAt=rule.selector.startsWith("@");let fullSelector=(isParentAt?" ".repeat(config.indentSize):"")+rule.selector;if(isAt){fullSelector=rule.selector+" {\n"}if(parentSelector){
-// 处理 & 选择器
-if(fullSelector.includes("&")){fullSelector=fullSelector.replace(/&/g,parentSelector)}else if(fullSelector.trim().startsWith(":")){fullSelector=parentSelector+fullSelector}else{fullSelector=parentSelector+(isParentAt?"":" ")+fullSelector}}
-// 如果有属性，生成规则块
-if(rule.properties.length>0){result+=(isAt?"":fullSelector)+" {\n";for(const prop of rule.properties){
-// 再次处理属性值（确保math()函数和颜色被转换）
-const parsed=parseSingleLineCSS(prop);parsed.forEach(obj=>{const key=Object.keys(obj)[0];const value=processCSSValue(obj[key],config);result+=(isParentAt?" ".repeat(config.indentSize):"")+" ".repeat(config.indentSize)+`${key}: ${value};\n`})}result+=isParentAt?" ".repeat(config.indentSize)+"}\n":"}\n\n"}
-// 递归处理子规则
-if(rule.children&&rule.children.length>0){result+=convertRulesToCSS(rule.children,config,fullSelector)}if(isParentAt){result+="}\n\n"}}return result.trim()+"\n\n"}
-// 替换变量值中的变量引用
-function replaceVariableUsesInValue(value,variables){return value.replace(/\$([a-zA-Z0-9_-]+)/g,(match,varName)=>{if(variables[varName]){return`var(--${varName})`}return match})}
-// 替换变量使用
-function replaceVariableUses(cssText,globalVariables,selectorVariables,config){let result=cssText;
-// 处理变量
-result=result.replace(/(?:\$\$|\$)([a-zA-Z0-9_-]+)/g,(match,varName)=>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""}const declarations=Object.entries(variables).map(([name,value])=>{const processedValue=processCSSValue(replaceVariableUsesInValue(value,variables),config);return" ".repeat(config.indentSize)+`--${name}: ${processedValue};`}).join("\n");return`${config.rootSelector} {\n${declarations}\n}\n\n`}
-// 处理选择器内部的变量
-function injectSelectorVariables(cssText,selectorVariables,config){let result="";const lines=cssText.split("\n");let currentSelector=null;for(let line of lines){const trimmed=line.trim();if(trimmed.endsWith("{")){currentSelector=trimmed.slice(0,-1).trim()}if(trimmed==="}"&&currentSelector){
-// 在选择器结束前插入变量声明
-if(selectorVariables.has(currentSelector)){const vars=selectorVariables.get(currentSelector);const indent=line.match(/^(\s*)/)[0];for(const[varName,varValue]of Object.entries(vars)){result+="  --"+varName+": "+varValue+";\n"}}currentSelector=null}
-// 使用全局处理函数处理所有math()和颜色
-result+=processCSSValue(line,config)+"\n"}return result.trim()}
-/**
-     * 处理 @import 语句
-     * @param {string} cssText - CSS文本
-     * @param {Object} config - 配置对象
-     * @returns {Promise<string>} 处理后的CSS文本
-     */async function processImports(cssText,config){
-// 匹配所有@import语句
-const importRegex=/@import\s+(?:url\()?["']([^"']+)["'](?:\))?[^;]*;/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=>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])}return finalText}return processedText};return processRecursive(cssText)}
-/**
-     * 获取导入的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)}content=fs.readFileSync(filePath,"utf-8")}catch(error){throw new Error(`Node.js文件读取失败: ${fullUrl} - ${error.message}`)}}else{
-// 浏览器环境：使用fetch
-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}
-/**
-     * 主转换函数
-     * @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. 提取变量定义（区分全局和选择器局部）
-const{globalVariables:globalVariables,selectorVariables:selectorVariables,cssWithoutVars:cssWithoutVars}=extractVariablesAndCSS(cleanedCSS,finalConfig);
-// 2. 解析嵌套规则（如果启用）
-let processedCSS=cssWithoutVars.trim();if(finalConfig.enableNesting&&cssWithoutVars.includes("{")){try{processedCSS=parseNestedRules(cssWithoutVars,finalConfig)}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+(?:url\()?["']([^"']+)["']/i.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)}})()}}
-// 自动处理带有 e 属性的 style 标签
-function autoProcessStyleTags(customConfig={}){const config={...defaultConfig,...customConfig};const styleTags=document.querySelectorAll(`style[${config.styleTagAttribute||"e"}]`);styleTags.forEach(styleTag=>{let originalCSS=styleTag.textContent;
-// 处理@import（如果是异步的）
-const processStyleTag=async()=>{try{if(styleTag.getAttribute("src")){originalCSS='@import url("'+styleTag.getAttribute("src")+'");'}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{styleTag.style.display="none"}}catch(error){console.error("处理style标签失败:",error)}};processStyleTag()});return styleTags.length}function config(config={}){defaultConfig={...defaultConfig,...config}}
-// 初始化自动处理
-function apply(cssText,customConfig={}){const config={...defaultConfig,...customConfig};if(cssText){
-// 检查是否有@import
-const hasImports=/@import\s+(?:url\()?["']([^"']+)["']/i.test(cssText);if(hasImports){
-// 异步处理
-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{
-// 同步处理
-const converted=convert(cssText,config);const styleEl=document.createElement("style");styleEl.textContent=converted;document.head.appendChild(styleEl);return styleEl}}else{if(document.readyState==="loading"){document.addEventListener("DOMContentLoaded",()=>{autoProcessStyleTags(config)})}else{autoProcessStyleTags(config)}}}
-// 返回公共 API
-const api={convert:convert,apply:apply,config:config,version:"1.9.0",
-// 检测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}},
-// 数学计算工具方法
-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{const result=evaluateMathExpression(expression,config);return{success:true,expression:expression,result:result,parsed:parseValueWithUnit(result.replace(/^calc\(|\)$/g,""))}}catch(error){return{success:false,expression:expression,error:error.message}}}},
-// 颜色转换工具方法
-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)},
-/**
-             * 生成颜色字符串（根据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]);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:L,A:A,B:B,alpha:alpha,rgb:preciseLabToRGB(L,A,B),p3:labToP3(L,A,B),colorString:colorStr}}
-// 尝试解析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]);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:L,C:C,H:H,alpha: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=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()}return styimat};
-// 处理模板字符串的函数
-function handleTemplateTag(strings,...values){
-// 拼接模板字符串
-let cssText=strings[0];for(let i=0;i<values.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:"")}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);
-// 自动初始化
-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});
+ */(function(d,C){typeof define=="function"&&define.amd?define([],C):typeof module=="object"&&module.exports?module.exports=C():d.styimat=C()})(typeof self<"u"?self:this,function(){let d={rootSelector:":root",variablePrefix:"--",preserveOriginal:!1,indentSize:4,enableNesting:!0,autoProcessStyleTags:!0,styleTagAttribute:"e",convertLabToRGB:!0,convertLchToRGB:!0,enableP3:!0,enableMath:!0,mathPrecision:6,importBaseUrl:"",importCache:!0,importTimeout:5e3},C=null;const F=new Map;function q(t){const e={...d},r=t.split(`
+`),n=[];for(let o of r){const s=o.trim();if(s.startsWith("#")){const i=s.substring(1).trim(),c=i.indexOf(" ");if(c!==-1){const l=i.substring(0,c).trim(),a=i.substring(c+1).trim(),u=Y(l);u in e?a==="true"||a==="false"?e[u]=a==="true":!isNaN(a)&&a.trim()!==""?e[u]=Number(a):e[u]=a:console.warn(`\u672A\u77E5\u7684\u914D\u7F6E\u9879: ${l}`)}else console.warn(`\u65E0\u6548\u7684\u914D\u7F6E\u884C: ${s}`)}else n.push(o)}return{config:e,css:n.join(`
+`)}}function Y(t){return t.replace(/-([a-z])/g,function(e,r){return r.toUpperCase()})}function z(){if(C!==null)return C;if(typeof window>"u"||!window.CSS)return C=!1,!1;try{C=CSS.supports("color","color(display-p3 1 0 0)")}catch(t){console.warn("P3\u652F\u6301\u68C0\u6D4B\u5931\u8D25:",t),C=!1}return C}function V(t){let e=t.trim();if(e.endsWith(";")&&(e=e.slice(0,-1)),!e)return[];const r=[];let n="",o=0,s=!1,i="";for(let l=0;l<e.length;l++){const a=e[l];(a==='"'||a==="'")&&!s?(s=!0,i=a):a===i&&s&&(s=!1,i=""),s||(a==="("?o++:a===")"&&o--),a===";"&&!s&&o===0?n.trim()&&(r.push(n.trim()),n=""):n+=a}n.trim()&&r.push(n.trim());const c=[];for(const l of r){if(!l.trim())continue;const a=D(l);if(a===-1){console.warn(`\u65E0\u6548\u7684CSS\u58F0\u660E: "${l}"`);continue}const u=l.substring(0,a).trim();let f=l.substring(a+1).trim();f.endsWith(";")&&(f=f.slice(0,-1).trim()),c.push({[u]:f})}return c}function D(t){let e=!1,r="";for(let n=0;n<t.length;n++){const o=t[n];if((o==='"'||o==="'")&&!e?(e=!0,r=o):o===r&&e&&(e=!1,r=""),o===":"&&!e)return n}return-1}function E(t,e){if(!e.enableMath)return`math(${t})`;try{let r=t.replace(/\s+/g,"");const n=_(r,e);return Q(r)?K(r,n):Z(n,e.mathPrecision)}catch(r){return console.warn("math()\u8868\u8FBE\u5F0F\u89E3\u6790\u5931\u8D25:",t,r),`math(${t})`}}function _(t,e){for(;t.includes("(")&&t.includes(")");){const r=t.lastIndexOf("("),n=t.indexOf(")",r);if(n===-1)break;const o=t.substring(r+1,n),s=_(o,e);t=t.substring(0,r)+s+t.substring(n+1)}return W(t,e)}function W(t,e){const r=[{regex:/([\d.]+(?:[a-zA-Z%]+)?)\*([\d.]+(?:[a-zA-Z%]+)?)/,handler:J},{regex:/([\d.]+(?:[a-zA-Z%]+)?)\/([\d.]+(?:[a-zA-Z%]+)?)/,handler:tt},{regex:/([\d.]+(?:[a-zA-Z%]+)?)\+([\d.]+(?:[a-zA-Z%]+)?)/,handler:et},{regex:/([\d.]+(?:[a-zA-Z%]+)?)-([\d.]+(?:[a-zA-Z%]+)?)/,handler:nt}];let n=t;for(const s of r){let i;for(;(i=t.match(s.regex))!==null;){const c=A(i[1]),l=A(i[2]),a=s.handler(c,l);t=t.substring(0,i.index)+a.value+t.substring(i.index+i[0].length)}}return t!==n?W(t,e):A(t).value}function A(t){const e=t.match(/^([\d.]+)([a-zA-Z%]*)$/);if(!e)throw new Error(`\u65E0\u6CD5\u89E3\u6790\u503C: ${t}`);const r=parseFloat(e[1]),n=e[2]||"";return{value:r,unit:n}}function Q(t){return/[a-zA-Z%]/.test(t)}function K(t,e){const r=t.match(/([a-zA-Z%]+)(?!.*[a-zA-Z%])/);return r?e+r[1]:t.includes("%")?e+"%":e+"px"}function J(t,e){return t.unit===e.unit||!t.unit&&!e.unit?{value:t.value*e.value,unit:t.unit||e.unit}:{value:`${t.value}${t.unit}*${e.value}${e.unit}`,unit:""}}function tt(t,e){if(e.value===0)throw new Error("\u9664\u4EE5\u96F6");return t.unit&&!e.unit?{value:t.value/e.value,unit:t.unit}:t.unit===e.unit?{value:t.value/e.value,unit:""}:{value:`${t.value}${t.unit}/${e.value}${e.unit}`,unit:""}}function et(t,e){return t.unit===e.unit?{value:t.value+e.value,unit:t.unit}:{value:`${t.value}${t.unit}+${e.value}${e.unit}`,unit:""}}function nt(t,e){return t.unit===e.unit?{value:t.value-e.value,unit:t.unit}:{value:`${t.value}${t.unit}-${e.value}${e.unit}`,unit:""}}function Z(t,e=6){const r=Math.pow(10,e),o=(Math.round(t*r)/r).toString();return o.includes(".")?o.replace(/(\.\d*?)0+$/,"$1").replace(/\.$/,""):o}function rt(t,e){if(!e.enableMath)return t;let r=t;const n=/math\(([^)]+)\)/gi,o=i=>i.replace(n,(c,l)=>E(l,e));let s;do s=r,r=o(r);while(r!==s&&r.includes("math("));return r}function st(t,e){if(!e.convertLabToRGB&&!e.convertLchToRGB)return t;let r=t;r=ot(r,e);const n=/(lab|lch)\([^)]+\)/gi,o=new Map,s=c=>c.replace(n,l=>{if(o.has(l))return o.get(l);let a=l;return l.toLowerCase().startsWith("lab(")?e.convertLabToRGB&&(a=ct(l,e)):l.toLowerCase().startsWith("lch(")&&e.convertLchToRGB&&(a=it(l,e)),o.set(l,a),a});let i;do i=r,r=s(r);while(r!==i);return r}function ot(t,e){let r=t;const n=/lab#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})/gi,o=/lch#([0-9a-f]{2})([0-9a-f]{2})(\d{1,3})/gi,s=new Map;return r=r.replace(n,(i,c,l,a)=>{if(s.has(i))return s.get(i);try{const u=parseInt(c,16)/255*100,f=(parseInt(l,16)-128)*1.5,p=(parseInt(a,16)-128)*1.5,h=L(u,f,p,e);return s.set(i,h),h}catch(u){return console.warn(`\u65E0\u6CD5\u89E3\u6790lab#\u5341\u516D\u8FDB\u5236\u989C\u8272: ${i}`,u),i}}),r=r.replace(o,(i,c,l,a)=>{if(s.has(i))return s.get(i);try{const u=parseInt(c,16)/255*100,f=parseInt(l,16)/255*150,p=parseInt(a)/100*360,h=w(u,f,p),g=L(h.L,h.a,h.b,e);return s.set(i,g),g}catch(u){return console.warn(`\u65E0\u6CD5\u89E3\u6790lch#\u5341\u516D\u8FDB\u5236\u989C\u8272: ${i}`,u),i}}),r}function ct(t,e){const r=/lab\(\s*([\d.]+)(%?)\s+([\d.-]+)\s+([\d.-]+)(?:\s*\/\s*([\d.%]+))?\s*\)/i,n=t.match(r);if(!n)return t;try{let o=parseFloat(n[1]);n[2]==="%"?o=o:(o<0&&(o=0),o>100&&(o=100));const s=parseFloat(n[3]),i=parseFloat(n[4]),c=n[5]!==void 0?n[5].includes("%")?parseFloat(n[5])/100:parseFloat(n[5]):null;return L(o,s,i,e,c)}catch(o){return console.warn(`\u65E0\u6CD5\u8F6C\u6362LAB\u989C\u8272: ${t}`,o),t}}function it(t,e){const r=/lch\(\s*([\d.]+)(%?)\s+([\d.]+)\s+([\d.]+)(deg)?(?:\s*\/\s*([\d.%]+))?\s*\)/i,n=t.match(r);if(!n)return t;try{let o=parseFloat(n[1]);n[2]==="%"?o=o:(o<0&&(o=0),o>100&&(o=100));const s=parseFloat(n[3]);let i=parseFloat(n[4]);s<0&&console.warn(`LCH\u4E2D\u7684C\u503C\u4E0D\u80FD\u4E3A\u8D1F: ${s}`),i=(i%360+360)%360;const c=w(o,s,i),l=n[6]!==void 0?n[6].includes("%")?parseFloat(n[6])/100:parseFloat(n[6]):null;return L(c.L,c.a,c.b,e,l)}catch(o){return console.warn(`\u65E0\u6CD5\u8F6C\u6362LCH\u989C\u8272: ${t}`,o),t}}function w(t,e,r){const n=r*Math.PI/180,o=e*Math.cos(n),s=e*Math.sin(n);return{L:t,a:o,b:s}}function S(t,e,r){const n=(m,y,v)=>{const X=(m+16)/116,B=y/500+X,O=X-v/200,bt=B**3>.008856?B**3:(116*B-16)/903.3,yt=m>903.3*.008856?((m+16)/116)**3:m/903.3,$t=O**3>.008856?O**3:(116*O-16)/903.3;return[bt*.95047,yt*1,$t*1.08883]},o=(m,y,v)=>{const $=[[3.2404542,-1.5371385,-.4985314],[-.969266,1.8760108,.041556],[.0556434,-.2040259,1.0572252]],T=$[0][0]*m+$[0][1]*y+$[0][2]*v,N=$[1][0]*m+$[1][1]*y+$[1][2]*v,U=$[2][0]*m+$[2][1]*y+$[2][2]*v;return[T,N,U]},s=m=>{const y=m<0?-1:1,v=Math.abs(m);return v<=.0031308?y*12.92*v:y*(1.055*Math.pow(v,.4166666666666667)-.055)},i=m=>Math.max(0,Math.min(255,Math.round(m*255))),[c,l,a]=n(t,e,r),[u,f,p]=o(c,l,a),h=s(u),g=s(f),b=s(p);return{r:i(h),g:i(g),b:i(b)}}function R(t,e,r){const n=(c,l,a)=>{const b=(c+16)/116,m=l/500+b,y=b-a/200,v=m**3>.008856?m**3:(116*m-16)/903.3,$=c>903.3*.008856?((c+16)/116)**3:c/903.3,T=y**3>.008856?y**3:(116*y-16)/903.3;return[v*.95047,$*1,T*1.08883]},o=(c,l,a)=>{const u=[[2.493496911941425,-.9313836179191239,-.40271078445071684],[-.8294889695615747,1.7626640603183463,.023624685841943577],[.03584583024378447,-.07617238926804182,.9568845240076872]],f=u[0][0]*c+u[0][1]*l+u[0][2]*a,p=u[1][0]*c+u[1][1]*l+u[1][2]*a,h=u[2][0]*c+u[2][1]*l+u[2][2]*a;return[f,p,h]},s=c=>{const l=c<0?-1:1,a=Math.abs(c);return a<=.0031308?l*12.92*a:l*(1.055*Math.pow(a,.4166666666666667)-.055)},i=c=>Math.max(0,Math.min(255,Math.round(c*255)));try{const[c,l,a]=n(t,e,r),[u,f,p]=o(c,l,a),h=s(u),g=s(f),b=s(p);return{r:Math.max(0,Math.min(1,h)),g:Math.max(0,Math.min(1,g)),b:Math.max(0,Math.min(1,b))}}catch(c){console.warn("P3\u8F6C\u6362\u5931\u8D25:",c);const l=S(t,e,r);return{r:l.r/255,g:l.g/255,b:l.b/255}}}function L(t,e,r,n,o=null){if(!n.enableP3||!z()){const s=S(t,e,r);return o!==null?`rgba(${s.r}, ${s.g}, ${s.b}, ${o})`:`rgb(${s.r}, ${s.g}, ${s.b})`}else{const s=R(t,e,r);return o!==null?`color(display-p3 ${s.r.toFixed(4)} ${s.g.toFixed(4)} ${s.b.toFixed(4)} / ${o})`:`color(display-p3 ${s.r.toFixed(4)} ${s.g.toFixed(4)} ${s.b.toFixed(4)})`}}function M(t,e){let r=t;return e.enableMath&&(r=rt(r,e)),(e.convertLabToRGB||e.convertLchToRGB)&&(r=st(r,e)),r}function lt(t,e){const r=t.split(`
+`),n={},o=new Map;let s="",i=null,c=!1,l=0;for(let a of r){const u=a.trim(),f=u.match(/^\$([a-zA-Z0-9_-]+)\s*:\s*(.+?);?$/);if(f){const[,p,h]=f,g=M(H(h.trim(),{...n,...i?o.get(i)||{}:{}}),e);i?(o.has(i)||o.set(i,{}),o.get(i)[p]=g):n[p]=g;continue}if(u.endsWith("{")){i=u.slice(0,-1).trim(),c=!0,s+=a+`
+`;continue}if(u==="}"){if(c&&i&&o.has(i)){const p=o.get(i),h=" ".repeat(l);for(const[g,b]of Object.entries(p))s+=`${h}  --${g}: ${b};
+`}c=!1,i=null}s+=a+`
+`,a.includes("{")&&(l+=e.indentSize),a.includes("}")&&(l=Math.max(0,l-e.indentSize))}return{globalVariables:n,selectorVariables:o,cssWithoutVars:s.trim()}}function at(t,e){const r=t.split(`
+`),n=[],o=[];let s=0;for(let i=0;i<r.length;i++){const c=r[i],l=c.trim();if(!l)continue;const a=c.match(/^(\s*)/)[0].length;if(l==="}"){if(n.length>0){const u=n.pop();if(n.length>0){const f=n[n.length-1];f.children||(f.children=[]),f.children.push(u)}else o.push(u)}continue}if(l.endsWith("{")){const f={selector:l.slice(0,-1).trim(),properties:[],children:[]};n.push(f);continue}if(!l.includes("{")&&!l.includes("}")&&l.includes(":")){if(n.length>0){const u=n[n.length-1];V(l).forEach(p=>{const h=Object.keys(p)[0],g=M(p[h],e);u.properties.push(`${h}: ${g}`)})}continue}}for(;n.length>0;){const i=n.pop();if(n.length===0)o.push(i);else{const c=n[n.length-1];c.children||(c.children=[]),c.children.push(i)}}return k(o,e)}function k(t,e,r=""){let n="";const o=r.startsWith("@");for(const s of t){const i=s.selector.startsWith("@");let c=(o?" ".repeat(e.indentSize):"")+s.selector;if(i&&(c=s.selector+` {
+`),r&&(c.includes("&")?c=c.replace(/&/g,r):c.trim().startsWith(":")?c=r+c:c=r+(o?"":" ")+c),s.properties.length>0){n+=(i?"":c)+` {
+`;for(const l of s.properties)V(l).forEach(u=>{const f=Object.keys(u)[0],p=M(u[f],e);n+=(o?" ".repeat(e.indentSize):"")+" ".repeat(e.indentSize)+`${f}: ${p};
+`});n+=o?" ".repeat(e.indentSize)+`}
+`:`}
+
+`}s.children&&s.children.length>0&&(n+=k(s.children,e,c)),o&&(n+=`}
+
+`)}return n.trim()+`
+
+`}function H(t,e){return t.replace(/\$([a-zA-Z0-9_-]+)/g,(r,n)=>e[n]?`var(--${n})`:r)}function ut(t,e,r,n){let o=t;return o=o.replace(/(?:\$\$|\$)([a-zA-Z0-9_-]+)/g,(s,i)=>s.startsWith("$$")?`attr(${i})`:`var(--${i})`),o=M(o,n),o}function ft(t,e){if(Object.keys(t).length===0)return"";const r=Object.entries(t).map(([n,o])=>{const s=M(H(o,t),e);return" ".repeat(e.indentSize)+`--${n}: ${s};`}).join(`
+`);return`${e.rootSelector} {
+${r}
+}
+
+`}function pt(t,e,r){let n="";const o=t.split(`
+`);let s=null;for(let i of o){const c=i.trim();if(c.endsWith("{")&&(s=c.slice(0,-1).trim()),c==="}"&&s){if(e.has(s)){const l=e.get(s),a=i.match(/^(\s*)/)[0];for(const[u,f]of Object.entries(l))n+="  --"+u+": "+f+`;
+`}s=null}n+=M(i,r)+`
+`}return n.trim()}async function j(t,e){const r=/@import\s+(?:url\()?["']([^"']+)["'](?:\))?[^;]*;/g;return(async o=>{const s=[],i=o.replace(r,(c,l)=>{const a=ht(l,e).then(u=>j(u,e)).catch(u=>(console.warn(`\u65E0\u6CD5\u5BFC\u5165CSS\u6587\u4EF6: ${l}`,u),""));return s.push(a),`__IMPORT_PLACEHOLDER_${s.length-1}__`});if(s.length>0){const c=await Promise.all(s);let l=i;for(let a=0;a<c.length;a++)l=l.replace(`__IMPORT_PLACEHOLDER_${a}__`,c[a]);return l}return i})(t)}async function ht(t,e){if(e.importCache&&F.has(t))return F.get(t);const r=e.importBaseUrl?new URL(t,e.importBaseUrl).href:t;let n;if(typeof process<"u"&&process.versions&&process.versions.node&&typeof require<"u")try{const s=require("fs"),i=require("path");let c=r;r.startsWith(".")&&(c=i.join(process.cwd(),r)),n=s.readFileSync(c,"utf-8")}catch(s){throw new Error(`Node.js\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25: ${r} - ${s.message}`)}else try{const s=new AbortController,i=setTimeout(()=>s.abort(),e.importTimeout),c=await fetch(r,{signal:s.signal,headers:{Accept:"text/css"}});if(clearTimeout(i),!c.ok)throw new Error(`HTTP\u9519\u8BEF: ${c.status} ${c.statusText}`);n=await c.text()}catch(s){throw s.name==="AbortError"?new Error(`\u5BFC\u5165\u8D85\u65F6: ${r}`):new Error(`\u65E0\u6CD5\u83B7\u53D6CSS: ${r} - ${s.message}`)}return e.importCache&&F.set(t,n),n}function x(t,e={}){const r=(s,i)=>{const{config:c,css:l}=q(s),a={...d,...e,...c},{globalVariables:u,selectorVariables:f,cssWithoutVars:p}=lt(l,a);let h=p.trim();if(a.enableNesting&&p.includes("{"))try{h=at(p,a)}catch(m){console.warn("\u5D4C\u5957\u89E3\u6790\u5931\u8D25\uFF0C\u4F7F\u7528\u539F\u59CBCSS:",m)}const g=ft(u,a);let b=h;return f.size>0&&(b=pt(h,f,a)),b=ut(b,u,f,a),g+b},n=t&&/@import\s+(?:url\()?["']([^"']+)["']/i.test(t),o={...d,...e};return n?(async()=>{try{const s=await j(t,o);return r(s,o)}catch(s){return console.error("@import\u5904\u7406\u5931\u8D25:",s),r(cleanedCSS,o)}})():r(t,o)}function G(t={}){const e={...d,...t},r=document.querySelectorAll(`style[${e.styleTagAttribute||"e"}]`);return r.forEach(n=>{let o=n.textContent;(async()=>{try{n.getAttribute("src")&&(o='@import url("'+n.getAttribute("src")+'");');const i=await x(o,e),c=document.createElement("style");c.textContent=i,n.parentNode.insertBefore(c,n.nextSibling),e.preserveOriginal?n.style.display="none":n.remove()}catch(i){console.error("\u5904\u7406style\u6807\u7B7E\u5931\u8D25:",i)}})()}),r.length}function dt(t={}){d={...d,...t}}function I(t,e={}){const r={...d,...e};if(t){if(/@import\s+(?:url\()?["']([^"']+)["']/i.test(t))return(async()=>{try{const o=await x(t,r),s=document.createElement("style");return s.textContent=o,document.head.appendChild(s),s}catch(o){return console.error("\u5E94\u7528CSS\u5931\u8D25:",o),null}})();{const o=x(t,r),s=document.createElement("style");return s.textContent=o,document.head.appendChild(s),s}}else document.readyState==="loading"?document.addEventListener("DOMContentLoaded",()=>{G(r)}):G(r)}const mt={convert:x,apply:I,config:dt,version:"1.9.0",supportsP3:z(),detectP3Support:z,imports:{clearCache:function(){F.clear()},setBaseUrl:function(t){d.importBaseUrl=t},setCacheEnabled:function(t){d.importCache=t},setTimeout:function(t){d.importTimeout=t}},math:{evaluate:function(t){return E(t,d)},parseUnit:A,round:Z,test:function(t,e={}){const r={...d,...e};try{const n=E(t,r);return{success:!0,expression:t,result:n,parsed:A(n.replace(/^calc\(|\)$/g,""))}}catch(n){return{success:!1,expression:t,error:n.message}}}},colorUtils:{labToRGB:S,lchToLab:w,lchToRGB:function(t,e,r){const n=w(t,e,r);return S(n.L,n.a,n.b)},labToP3:R,lchToP3:function(t,e,r){const n=w(t,e,r);return R(n.L,n.a,n.b)},parseHexLab:function(t){const e=t.match(/lab#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})/i);if(!e)return null;const r=e[1],n=e[2],o=e[3],s=parseInt(r,16)/255*100,i=(parseInt(n,16)-128)*1.5,c=(parseInt(o,16)-128)*1.5;return S(s,i,c)},parseHexLch:function(t){const e=t.match(/lch#([0-9a-f]{2})([0-9a-f]{2})(\d{1,3})/i);if(!e)return null;const r=e[1],n=e[2],o=e[3],s=parseInt(r,16)/255*100,i=parseInt(n,16)/255*150,c=parseInt(o)/100*360,l=w(s,i,c);return S(l.L,l.a,l.b)},generateColor:function(t,e,r,n=null,o=!0){return L(t,e,r,{enableP3:o},n)},parseColor:function(t){try{const e=t.match(/lab\(\s*([\d.]+)(%?)\s+([\d.-]+)\s+([\d.-]+)(?:\s*\/\s*([\d.%]+))?\s*\)/i);if(e){let n=parseFloat(e[1]);const o=parseFloat(e[3]),s=parseFloat(e[4]),i=e[5]?e[5].includes("%")?parseFloat(e[5])/100:parseFloat(e[5]):null,c=L(n,o,s,d,i);return{L:n,A:o,B:s,alpha:i,rgb:S(n,o,s),p3:R(n,o,s),colorString:c}}const r=t.match(/lch\(\s*([\d.]+)(%?)\s+([\d.]+)\s+([\d.]+)(deg)?(?:\s*\/\s*([\d.%]+))?\s*\)/i);if(r){let n=parseFloat(r[1]);const o=parseFloat(r[3]);let s=parseFloat(r[4]);const i=r[6]?r[6].includes("%")?parseFloat(r[6])/100:parseFloat(r[6]):null,c=w(n,o,s),l=L(c.L,c.a,c.b,d,i);return{L:n,C:o,H:s,alpha:i,lab:c,rgb:S(c.L,c.a,c.b),p3:R(c.L,c.a,c.b),colorString:l}}return null}catch(e){return console.warn("\u65E0\u6CD5\u89E3\u6790\u989C\u8272:",t,e),null}}}},P=function(...t){if(t.length>1||t[0]&&t[0].raw)return gt(...t);const e=t[0];if(typeof e=="string"){const r=x(e,{...d,...t[1]});return r&&typeof r.then=="function",r}return typeof e=="object"&&e!==null?(d={...d,...e},P):t.length===0?I():P};function gt(t,...e){let r=t[0];for(let o=0;o<e.length;o++){const s=e[o];let i="";typeof s=="function"?i=s():Array.isArray(s)?i=s.join(" "):i=String(s??""),r+=i+t[o+1]}const n=x(r,d);return n&&typeof n.then=="function",n}return Object.assign(P,mt),Object.setPrototypeOf(P,Function.prototype),typeof window<"u"&&(I(),Object.defineProperty(window.HTMLElement.prototype,"cssVar",{get(){const t=this;return new Proxy(()=>{},{get(e,r){const n=r.startsWith("--")?r:`--${r}`;return t.style.getPropertyValue(n)},set(e,r,n){const o=r.startsWith("--")?r:`--${r}`;return t.style.setProperty(o,n),!0},apply(e,r,n){const o=n[0],s=n[1],i=o.startsWith("--")?o:`--${o}`;if(s===void 0)return t.style.getPropertyValue(i);t.style.setProperty(i,s)}})}})),P});