@weapp-tailwindcss/postcss 2.1.6 → 2.2.0-next.0

package/dist/index.mjs

@@ -1,7 +1,11 @@
+import {
+  html_transform_default
+} from "./chunk-2DNJBRQ3.mjs";
 import "./chunk-WAXGOBY2.mjs";
 
 // src/handler.ts
 import { defuOverrideArray as defuOverrideArray4 } from "@weapp-tailwindcss/shared";
+import { LRUCache } from "lru-cache";
 
 // src/compat/uni-app-x.ts
 import postcss from "postcss";
@@ -132,6 +136,145 @@ function shouldRemoveEmptyRuleForUniAppX(rule, options) {
   return isUniAppXEnabled(options) && rule.nodes.length === 0;
 }
 
+// src/compat/uni-app-x-uvue.ts
+import selectorParser from "postcss-selector-parser";
+var ALLOWED_DISPLAY_VALUES = /* @__PURE__ */ new Set(["flex", "none"]);
+var FALLBACK_CLASS_RE = /\.((?:\\.|[\w-])+)/g;
+var IMPORTANT_SUFFIX_RE = /\s*!important$/i;
+function isUniAppXUvueTarget(options) {
+  return Boolean(options?.uniAppX) && options?.uniAppXCssTarget === "uvue";
+}
+function normalizeUnsupportedMode(mode) {
+  return mode ?? "warn";
+}
+function normalizeValue(value) {
+  return value.trim().toLowerCase().replace(IMPORTANT_SUFFIX_RE, "");
+}
+function getSourceFile(rule, result) {
+  return rule.source?.input.from ?? result.opts.from ?? "unknown source";
+}
+function collectUtilityClassNames(rule) {
+  const classNames = /* @__PURE__ */ new Set();
+  for (const selector of rule.selectors ?? []) {
+    try {
+      const ast = selectorParser().astSync(selector);
+      ast.walkClasses((node) => {
+        if (node.value) {
+          classNames.add(node.value);
+        }
+      });
+    } catch {
+      for (const match of selector.matchAll(FALLBACK_CLASS_RE)) {
+        if (match[1]) {
+          classNames.add(match[1].replaceAll("\\", ""));
+        }
+      }
+    }
+  }
+  return [...classNames];
+}
+function hasOnlyClassSelectors(rule) {
+  const selectors = rule.selectors ?? [];
+  if (selectors.length === 0) {
+    return false;
+  }
+  return selectors.every((selector) => {
+    try {
+      const ast = selectorParser().astSync(selector);
+      return ast.nodes.every((node) => node.nodes.length > 0 && node.nodes.every((child) => child.type === "class"));
+    } catch {
+      return false;
+    }
+  });
+}
+function getUnsupportedDeclarationReason(prop, value) {
+  const normalizedProp = prop.trim().toLowerCase();
+  const normalizedValue = normalizeValue(value);
+  if (normalizedProp === "display" && !ALLOWED_DISPLAY_VALUES.has(normalizedValue)) {
+    return `${normalizedProp}: ${value}`;
+  }
+  if (normalizedProp === "min-height" && normalizedValue === "100vh") {
+    return `${normalizedProp}: ${value}`;
+  }
+  if (normalizedProp === "grid-template-columns" || normalizedProp === "grid-template-rows" || normalizedProp === "grid-auto-columns" || normalizedProp === "grid-auto-rows" || normalizedProp === "grid-auto-flow") {
+    return `${normalizedProp}: ${value}`;
+  }
+  if (normalizedProp === "gap" || normalizedProp === "row-gap" || normalizedProp === "column-gap") {
+    return `${normalizedProp}: ${value}`;
+  }
+}
+function reportUnsupportedRule(rule, result, mode, warningCache, reason) {
+  if (mode === "silent") {
+    return;
+  }
+  const classNames = collectUtilityClassNames(rule);
+  const classLabel = classNames.length > 0 ? classNames.join(", ") : rule.selector;
+  const source = getSourceFile(rule, result);
+  const message = `uni-app x uvue unsupported utility: ${classLabel} (${reason}) in ${source}`;
+  if (mode === "error") {
+    throw rule.error(message);
+  }
+  if (warningCache.has(message)) {
+    return;
+  }
+  warningCache.add(message);
+  rule.warn(result, message);
+}
+function applyUniAppXUvueCompatibility(result, options) {
+  if (!isUniAppXUvueTarget(options)) {
+    return result;
+  }
+  const mode = normalizeUnsupportedMode(options?.uniAppXUnsupported);
+  const warningCache = /* @__PURE__ */ new Set();
+  result.root.walkRules((rule) => {
+    if (!hasOnlyClassSelectors(rule)) {
+      reportUnsupportedRule(rule, result, mode, warningCache, "selector must be class-only");
+      rule.remove();
+      return;
+    }
+    rule.walkDecls((decl) => {
+      const reason = getUnsupportedDeclarationReason(decl.prop, decl.value);
+      if (!reason) {
+        return;
+      }
+      reportUnsupportedRule(rule, result, mode, warningCache, reason);
+      decl.remove();
+    });
+    if ((rule.nodes?.length ?? 0) === 0) {
+      rule.remove();
+    }
+  });
+  result.root.walkAtRules((atRule) => {
+    if ((atRule.nodes?.length ?? 0) === 0) {
+      atRule.remove();
+    }
+  });
+  const nextResult = result.root.toResult(result.opts);
+  nextResult.messages.push(...result.messages);
+  return nextResult;
+}
+
+// src/content-probe.ts
+var EMPTY_SIGNAL = {
+  hasModernColorFunction: false,
+  hasPresetEnvFeatures: false
+};
+var MODERN_COLOR_RE = /rgb\w*\s*\([^),][^\s),]*\s[^),][^\s),]*\s[^),][^),/]*\/[^)]+\)/i;
+function probeFeatures(css) {
+  if (!css) {
+    return { ...EMPTY_SIGNAL };
+  }
+  const hasModernColorFunction = MODERN_COLOR_RE.test(css);
+  const hasPresetEnvFeatures = true;
+  return {
+    hasModernColorFunction,
+    hasPresetEnvFeatures
+  };
+}
+function signalToCacheKey(signal) {
+  return `signal:${signal.hasPresetEnvFeatures ? 1 : 0},${signal.hasModernColorFunction ? 1 : 0}`;
+}
+
 // src/defaults.ts
 function getDefaultOptions(options) {
   return {
@@ -154,6 +297,7 @@ function getDefaultOptions(options) {
     },
     // 支付宝小程序不支持，所以默认关闭
     cssRemoveProperty: true,
+    uniAppXUnsupported: "warn",
     // cssRemoveAtSupports: true,
     // cssRemoveAtMedia: true,
     cssSelectorReplacement: {
@@ -163,9 +307,6 @@ function getDefaultOptions(options) {
   };
 }
 
-// src/options-resolver.ts
-import { defuOverrideArray } from "@weapp-tailwindcss/shared";
-
 // src/fingerprint.ts
 function fingerprintOptions(value, state = { map: /* @__PURE__ */ new WeakMap(), counter: 0 }) {
   if (value === null || value === void 0) {
@@ -197,6 +338,7 @@ function fingerprintOptions(value, state = { map: /* @__PURE__ */ new WeakMap(),
 }
 
 // src/options-resolver.ts
+import { defuOverrideArray } from "@weapp-tailwindcss/shared";
 var BASE_CACHE_KEY = "base";
 var SIMPLE_OVERRIDE_UNSET = "__unset__";
 function getSimpleOverrideCacheKey(options) {
@@ -213,6 +355,7 @@ function getSimpleOverrideCacheKey(options) {
   let cssCalc = SIMPLE_OVERRIDE_UNSET;
   let cssChildCombinatorReplaceValue = SIMPLE_OVERRIDE_UNSET;
   let cssPreflight = SIMPLE_OVERRIDE_UNSET;
+  let autoprefixer = SIMPLE_OVERRIDE_UNSET;
   for (const key of Object.keys(options)) {
     const value = options[key];
     switch (key) {
@@ -294,6 +437,12 @@ function getSimpleOverrideCacheKey(options) {
         }
         cssPreflight = "0";
         break;
+      case "autoprefixer":
+        if (typeof value !== "boolean") {
+          return void 0;
+        }
+        autoprefixer = value ? "1" : "0";
+        break;
       default:
         return void 0;
     }
@@ -312,7 +461,8 @@ function getSimpleOverrideCacheKey(options) {
     unitsToPx,
     cssCalc,
     cssChildCombinatorReplaceValue,
-    cssPreflight
+    cssPreflight,
+    autoprefixer
   ].join(":");
 }
 function hasOverrides(options) {
@@ -387,6 +537,28 @@ import postcss2 from "postcss";
 // src/pipeline.ts
 import postcssPresetEnv from "postcss-preset-env";
 
+// src/autoprefixer.ts
+import autoprefixerPlugin from "autoprefixer";
+var WEAPP_AUTOPREFIXER_BROWSERS = [
+  "iOS >= 8",
+  "Android >= 4.4",
+  "ChromeAndroid >= 37"
+];
+var AUTOPREFIXER_PLUGIN_NAME = "autoprefixer";
+function isAutoprefixerPlugin(plugin) {
+  return plugin?.postcssPlugin === AUTOPREFIXER_PLUGIN_NAME;
+}
+function resolveAutoprefixerPlugin(option) {
+  if (option === false) {
+    return void 0;
+  }
+  const userOptions = option === true || option === void 0 ? {} : option;
+  return autoprefixerPlugin({
+    ...userOptions,
+    overrideBrowserslist: userOptions.overrideBrowserslist ?? WEAPP_AUTOPREFIXER_BROWSERS
+  });
+}
+
 // src/plugins/colorFunctionalFallback.ts
 import valueParser from "postcss-value-parser";
 var RGB_FUNCTION_NAME = "rgb";
@@ -532,7 +704,7 @@ function getCalcDuplicateCleaner(options) {
 // src/plugins/getCalcPlugin.ts
 import postcssCalc from "@weapp-tailwindcss/postcss-calc";
 
-// ../../node_modules/.pnpm/es-toolkit@1.45.1/node_modules/es-toolkit/dist/object/omit.mjs
+// ../../node_modules/.pnpm/es-toolkit@1.46.0/node_modules/es-toolkit/dist/object/omit.mjs
 function omit(obj, keys) {
   const result = { ...obj };
   for (let i = 0; i < keys.length; i++) {
@@ -1822,6 +1994,7 @@ function dedupeDeclarations(rule) {
 }
 
 // src/plugins/post/specificity-cleaner.ts
+var FALLBACK_PLACEHOLDER_SUFFIXES = [":not(#n)", ":not(#\\#)"];
 function normalizeSelectorList(value) {
   if (value === void 0 || value === false) {
     return [];
@@ -1836,6 +2009,45 @@ function getSpecificityMatchingName(options) {
   }
   return void 0;
 }
+function replaceFallbackPlaceholder(selector) {
+  let output = selector;
+  for (const suffix of FALLBACK_PLACEHOLDER_SUFFIXES) {
+    if (output.includes(suffix)) {
+      output = output.split(suffix).join("");
+    }
+  }
+  return output;
+}
+function createFallbackPlaceholderReplacer() {
+  return (code) => {
+    let output = code;
+    for (const suffix of FALLBACK_PLACEHOLDER_SUFFIXES) {
+      if (output.includes(suffix)) {
+        output = output.split(suffix).join("");
+      }
+    }
+    return output;
+  };
+}
+function createFallbackPlaceholderCleaner() {
+  return (rule) => {
+    if (!rule.selectors || rule.selectors.length === 0) {
+      return;
+    }
+    let changed = false;
+    const next = rule.selectors.map((selector) => {
+      const updated = replaceFallbackPlaceholder(selector);
+      if (updated !== selector) {
+        changed = true;
+      }
+      return updated;
+    });
+    changed && assignRuleSelectors(rule, next, {
+      phase: "post",
+      reason: "clean-fallback-placeholder"
+    });
+  };
+}
 function createRootSpecificityCleaner(options) {
   const specificityMatchingName = getSpecificityMatchingName(options);
   const selectors = normalizeSelectorList(options.cssSelectorReplacement?.root);
@@ -1908,6 +2120,7 @@ var postcssWeappTailwindcssPostPlugin = (options) => {
     postcssPlugin
   };
   const cleanRootSpecificity = createRootSpecificityCleaner(opts);
+  const cleanFallbackPlaceholder = createFallbackPlaceholderCleaner();
   const shouldAppendHostSelector = createHostSelectorAppender(opts);
   const enableMainChunkTransforms = opts.isMainChunk !== false;
   if (enableMainChunkTransforms || cleanRootSpecificity) {
@@ -1916,6 +2129,7 @@ var postcssWeappTailwindcssPostPlugin = (options) => {
       if (enableMainChunkTransforms) {
         fallbackRemove?.transformSync(rule);
       }
+      cleanFallbackPlaceholder(rule);
       cleanRootSpecificity?.(rule);
       if (enableMainChunkTransforms) {
         if (shouldAppendHostSelector?.(rule)) {
@@ -2373,7 +2587,29 @@ function createPreparedNode(id, stage, createPlugin) {
     createPlugin
   };
 }
-function createPreparedNodes(options) {
+function hasUserAutoprefixerPlugin(rawPlugins, plugins) {
+  if (plugins.some((plugin) => isAutoprefixerPlugin(plugin))) {
+    return true;
+  }
+  if (rawPlugins && !Array.isArray(rawPlugins) && typeof rawPlugins === "object") {
+    const autoprefixerEntry = rawPlugins["autoprefixer"];
+    return Boolean(autoprefixerEntry);
+  }
+  return false;
+}
+function shouldUseDefaultAutoprefixer(options, userPlugins) {
+  if (options.autoprefixer === false) {
+    return false;
+  }
+  if (hasUserAutoprefixerPlugin(options.postcssOptions?.plugins, userPlugins)) {
+    return false;
+  }
+  if (options.autoprefixer === true || typeof options.autoprefixer === "object") {
+    return true;
+  }
+  return options.majorVersion === 4;
+}
+function createPreparedNodes(options, signal) {
   const preparedNodes = [];
   const userPlugins = normalizeUserPlugins(options.postcssOptions?.plugins);
   const presetEnvOptions = options.cssPresetEnv;
@@ -2381,8 +2617,12 @@ function createPreparedNodes(options) {
     preparedNodes.push(createPreparedNode(`pre:user-${index}`, "pre", () => plugin));
   });
   preparedNodes.push(createPreparedNode("pre:core", "pre", () => postcssWeappTailwindcssPrePlugin(options)));
-  preparedNodes.push(createPreparedNode("normal:preset-env", "normal", () => postcssPresetEnv(presetEnvOptions)));
-  preparedNodes.push(createPreparedNode("normal:color-functional-fallback", "normal", () => createColorFunctionalFallback()));
+  if (!signal || signal.hasPresetEnvFeatures) {
+    preparedNodes.push(createPreparedNode("normal:preset-env", "normal", () => postcssPresetEnv(presetEnvOptions)));
+  }
+  if (!signal || signal.hasModernColorFunction) {
+    preparedNodes.push(createPreparedNode("normal:color-functional-fallback", "normal", () => createColorFunctionalFallback()));
+  }
   const unitsToPxPlugin = getUnitsToPxPlugin(options);
   if (unitsToPxPlugin) {
     preparedNodes.push(createPreparedNode("normal:units-to-px", "normal", () => unitsToPxPlugin));
@@ -2407,12 +2647,18 @@ function createPreparedNodes(options) {
   if (customPropertyCleaner) {
     preparedNodes.push(createPreparedNode("normal:custom-property-cleaner", "normal", () => customPropertyCleaner));
   }
+  if (shouldUseDefaultAutoprefixer(options, userPlugins)) {
+    const plugin = resolveAutoprefixerPlugin(options.autoprefixer);
+    if (plugin) {
+      preparedNodes.push(createPreparedNode("normal:autoprefixer", "normal", () => plugin));
+    }
+  }
   preparedNodes.push(createPreparedNode("post:core", "post", () => postcssWeappTailwindcssPostPlugin(options)));
   return preparedNodes;
 }
-function createStylePipeline(options) {
+function createStylePipeline(options, signal) {
   options.ctx = createContext();
-  const preparedNodes = createPreparedNodes(options);
+  const preparedNodes = createPreparedNodes(options, signal);
   if (preparedNodes.length === 0) {
     return {
       nodes: [],
@@ -2504,9 +2750,8 @@ function getSimpleProcessOptionsCacheKey(options) {
   return parts.join("|");
 }
 var StyleProcessorCache = class {
-  pipelineCache = /* @__PURE__ */ new WeakMap();
+  pipelineCacheByKey = /* @__PURE__ */ new Map();
   processOptionsCache = /* @__PURE__ */ new WeakMap();
-  processorCache = /* @__PURE__ */ new WeakMap();
   processorCacheByKey = /* @__PURE__ */ new Map();
   processorKeyCache = /* @__PURE__ */ new WeakMap();
   createProcessorCacheKey(options) {
@@ -2525,11 +2770,26 @@ var StyleProcessorCache = class {
       }
     });
   }
-  getPipeline(options) {
-    let pipeline = this.pipelineCache.get(options);
+  /**
+   * 构建包含信号的复合缓存键
+   */
+  createCompositeCacheKey(optionsFingerprint, signal) {
+    if (!signal) {
+      return optionsFingerprint;
+    }
+    return `${optionsFingerprint}|${signalToCacheKey(signal)}`;
+  }
+  getPipeline(options, signal) {
+    let optionsKey = this.processorKeyCache.get(options);
+    if (!optionsKey) {
+      optionsKey = this.createProcessorCacheKey(options);
+      this.processorKeyCache.set(options, optionsKey);
+    }
+    const compositeKey = this.createCompositeCacheKey(optionsKey, signal);
+    let pipeline = this.pipelineCacheByKey.get(compositeKey);
     if (!pipeline) {
-      pipeline = createStylePipeline(options);
-      this.pipelineCache.set(options, pipeline);
+      pipeline = createStylePipeline(options, signal);
+      this.pipelineCacheByKey.set(compositeKey, pipeline);
     }
     return pipeline;
   }
@@ -2544,27 +2804,33 @@ var StyleProcessorCache = class {
     }
     return { ...cached.value };
   }
-  getProcessor(options) {
-    let processor = this.processorCache.get(options);
+  getProcessor(options, signal) {
+    let optionsKey = this.processorKeyCache.get(options);
+    if (!optionsKey) {
+      optionsKey = this.createProcessorCacheKey(options);
+      this.processorKeyCache.set(options, optionsKey);
+    }
+    const compositeKey = this.createCompositeCacheKey(optionsKey, signal);
+    let processor = this.processorCacheByKey.get(compositeKey);
     if (!processor) {
-      let cacheKey = this.processorKeyCache.get(options);
-      if (!cacheKey) {
-        cacheKey = this.createProcessorCacheKey(options);
-        this.processorKeyCache.set(options, cacheKey);
-      }
-      processor = this.processorCacheByKey.get(cacheKey);
-      if (!processor) {
-        const pipeline = this.getPipeline(options);
-        processor = postcss2(pipeline.plugins);
-        this.processorCacheByKey.set(cacheKey, processor);
-      }
-      this.processorCache.set(options, processor);
+      const pipeline = this.getPipeline(options, signal);
+      processor = postcss2(pipeline.plugins);
+      this.processorCacheByKey.set(compositeKey, processor);
     }
     return processor;
   }
 };
 
 // src/handler.ts
+var CSS_RESULT_CACHE_MAX = 256;
+function simpleHash(str) {
+  let hash = 2166136261 | 0;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = hash * 16777619 | 0;
+  }
+  return (hash >>> 0).toString(36);
+}
 function createStyleHandler(options) {
   const cachedOptions = defuOverrideArray4(
     options,
@@ -2572,28 +2838,65 @@ function createStyleHandler(options) {
   );
   cachedOptions.cssInjectPreflight = createInjectPreflight(cachedOptions.cssPreflight);
   const resolver = createOptionsResolver(cachedOptions);
-  const cache = new StyleProcessorCache();
+  const processorCache = new StyleProcessorCache();
   const base = resolver.resolve();
-  cache.getProcessor(base);
-  cache.getProcessOptions(base);
+  processorCache.getProcessor(base);
+  processorCache.getProcessOptions(base);
+  const optionsFingerprintCache = /* @__PURE__ */ new WeakMap();
+  function getOptionsFingerprint(opts) {
+    const cached = optionsFingerprintCache.get(opts);
+    if (cached) {
+      return cached;
+    }
+    const fp = fingerprintOptions(opts);
+    optionsFingerprintCache.set(opts, fp);
+    return fp;
+  }
+  const resultCache = new LRUCache({ max: CSS_RESULT_CACHE_MAX });
+  const hasUserPlugins = Boolean(
+    cachedOptions.postcssOptions?.plugins && (Array.isArray(cachedOptions.postcssOptions.plugins) ? cachedOptions.postcssOptions.plugins.length > 0 : typeof cachedOptions.postcssOptions.plugins === "object" && Object.keys(cachedOptions.postcssOptions.plugins).length > 0)
+  );
   const handler = ((rawSource, opt) => {
     const resolvedOptions = resolver.resolve(opt);
-    const processor = cache.getProcessor(resolvedOptions);
-    const processOptions = cache.getProcessOptions(resolvedOptions);
+    let signal;
+    if (!hasUserPlugins) {
+      try {
+        signal = probeFeatures(rawSource);
+      } catch {
+        signal = void 0;
+      }
+    }
+    const optsFp = getOptionsFingerprint(resolvedOptions);
+    const signalKey = signal ? signalToCacheKey(signal) : "";
+    const contentHash = simpleHash(rawSource);
+    const cacheKey = `${optsFp}|${signalKey}|${contentHash}`;
+    const cachedResult = resultCache.get(cacheKey);
+    if (cachedResult) {
+      return Promise.resolve(cachedResult);
+    }
+    const processor = processorCache.getProcessor(resolvedOptions, signal);
+    const processOptions = processorCache.getProcessOptions(resolvedOptions);
     return processor.process(
       rawSource,
       processOptions
-    ).async().then((result) => applyUniAppXBaseCompatibility(result, resolvedOptions));
+    ).async().then((result) => {
+      const baseCompatible = applyUniAppXBaseCompatibility(result, resolvedOptions);
+      const finalResult = applyUniAppXUvueCompatibility(baseCompatible, resolvedOptions);
+      resultCache.set(cacheKey, finalResult);
+      return finalResult;
+    });
   });
   handler.getPipeline = (opt) => {
     const resolvedOptions = resolver.resolve(opt);
-    return cache.getPipeline(resolvedOptions);
+    return processorCache.getPipeline(resolvedOptions);
   };
   return handler;
 }
 export {
+  createFallbackPlaceholderReplacer,
   createInjectPreflight,
   createStyleHandler,
   createStylePipeline,
-  internalCssSelectorReplacer
+  internalCssSelectorReplacer,
+  html_transform_default as postcssHtmlTransform
 };

package/dist/{types-CsRGpZ_r.d.mts → types-DJDvtI8K.d.mts}

@@ -4,6 +4,27 @@ import { Result } from 'postcss-load-config';
 import { PxTransformOptions } from 'postcss-pxtrans';
 import { UserDefinedOptions } from 'postcss-rem-to-responsive-pixel';
 import { UserDefinedOptions as UserDefinedOptions$1 } from 'postcss-units-to-px';
+import autoprefixer from 'autoprefixer';
+
+type AutoprefixerOptions = autoprefixer.Options;
+type WeappAutoprefixerOptions = boolean | AutoprefixerOptions;
+
+/**
+ * CSS 内容特征探测模块
+ *
+ * 通过正则和字符串匹配快速判断 CSS 是否包含特定特征，
+ * 用于在构建流水线前决定哪些插件可以跳过。
+ * 仅使用字符串方法和正则表达式，不引入 AST 解析开销。
+ */
+/**
+ * CSS 内容特征信号，表示哪些特征存在于当前 CSS 中
+ */
+interface FeatureSignal {
+    /** CSS 中是否包含现代颜色函数语法（如 rgb(r g b / a) 空格分隔写法） */
+    hasModernColorFunction: boolean;
+    /** CSS 中是否包含需要 postcss-preset-env 处理的特征 */
+    hasPresetEnvFeatures: boolean;
+}
 
 type PipelineStage = 'pre' | 'normal' | 'post';
 interface PipelineNodeCursor {
@@ -45,7 +66,7 @@ interface StyleProcessingPipeline {
     nodes: ResolvedPipelineNode[];
     plugins: AcceptedPlugin[];
 }
-declare function createStylePipeline(options: IStyleHandlerOptions): StyleProcessingPipeline;
+declare function createStylePipeline(options: IStyleHandlerOptions, signal?: FeatureSignal): StyleProcessingPipeline;
 
 declare function createContext(): {
     variablesScopeWeakMap: WeakMap<WeakKey, any>;
@@ -77,6 +98,8 @@ interface IPropValue {
     prop: string;
     value: string;
 }
+type UniAppXCssTarget = 'uvue';
+type UniAppXUnsupportedMode = 'error' | 'warn' | 'silent';
 type CssPreflightOptions = {
     [key: string]: string | number | boolean;
 } | false;
@@ -101,6 +124,7 @@ type IStyleHandlerOptions = {
     cssRemoveProperty?: boolean;
     cssRemoveHoverPseudoClass?: boolean;
     cssPresetEnv?: PresetEnvOptions;
+    autoprefixer?: WeappAutoprefixerOptions;
     cssCalc?: boolean | CssCalcOptions | (string | RegExp)[];
     atRules?: {
         property?: boolean;
@@ -108,6 +132,8 @@ type IStyleHandlerOptions = {
         media?: boolean;
     };
     uniAppX?: boolean;
+    uniAppXCssTarget?: UniAppXCssTarget;
+    uniAppXUnsupported?: UniAppXUnsupportedMode;
     majorVersion?: number;
 } & RequiredStyleHandlerOptions;
 interface UserDefinedPostcssOptions {
@@ -115,6 +141,7 @@ interface UserDefinedPostcssOptions {
     cssPreflightRange?: 'all';
     cssChildCombinatorReplaceValue?: string | string[];
     cssPresetEnv?: PresetEnvOptions;
+    autoprefixer?: WeappAutoprefixerOptions;
     injectAdditionalCssVarScope?: boolean;
     cssSelectorReplacement?: {
         root?: string | string[] | false;
@@ -127,6 +154,8 @@ interface UserDefinedPostcssOptions {
     cssRemoveHoverPseudoClass?: boolean;
     cssRemoveProperty?: boolean;
     uniAppX?: boolean;
+    uniAppXCssTarget?: UniAppXCssTarget;
+    uniAppXUnsupported?: UniAppXUnsupportedMode;
 }
 
 interface StyleHandler {
@@ -134,4 +163,4 @@ interface StyleHandler {
     getPipeline: (opt?: Partial<IStyleHandlerOptions>) => StyleProcessingPipeline;
 }
 
-export { type CssCalcOptions as C, type IStyleHandlerOptions as I, type LoadedPostcssOptions as L, type PipelineNodeContext as P, type RequiredStyleHandlerOptions as R, type StyleHandler as S, type UserDefinedPostcssOptions as U, type InternalCssSelectorReplacerOptions as a, type CssPreflightOptions as b, type IPropValue as c, type PipelineNodeCursor as d, type PipelineStage as e, type PresetEnvOptions as f, type ResolvedPipelineNode as g, type StyleProcessingPipeline as h, createInjectPreflight as i, createStylePipeline as j };
+export { type CssCalcOptions as C, type IStyleHandlerOptions as I, type LoadedPostcssOptions as L, type PipelineNodeContext as P, type RequiredStyleHandlerOptions as R, type StyleHandler as S, type UniAppXCssTarget as U, type WeappAutoprefixerOptions as W, type InternalCssSelectorReplacerOptions as a, type CssPreflightOptions as b, type IPropValue as c, type PipelineNodeCursor as d, type PipelineStage as e, type PresetEnvOptions as f, type ResolvedPipelineNode as g, type StyleProcessingPipeline as h, type UniAppXUnsupportedMode as i, type UserDefinedPostcssOptions as j, createInjectPreflight as k, createStylePipeline as l };