@weapp-tailwindcss/postcss 2.1.6 → 2.2.0-alpha.1

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.1/node_modules/es-toolkit/dist/object/omit.mjs
 function omit(obj, keys) {
   const result = { ...obj };
   for (let i = 0; i < keys.length; i++) {
@@ -667,13 +839,52 @@ function getRemTransformPlugin(options) {
 }
 
 // src/plugins/getUnitsToPxPlugin.ts
-import postcssUnitsToPx from "postcss-units-to-px";
+import postcssUnitConverter, { presets } from "postcss-rule-unit-converter";
 function getUnitsToPxPlugin(options) {
   if (!options.unitsToPx) {
     return null;
   }
   const userOptions = typeof options.unitsToPx === "object" ? options.unitsToPx : void 0;
-  return postcssUnitsToPx(userOptions);
+  if (userOptions?.disabled || userOptions?.transform === false) {
+    return postcssUnitConverter({ disabled: true });
+  }
+  const presetOptions = {};
+  const converterOptions = {
+    rules: []
+  };
+  if (userOptions?.minValue !== void 0) {
+    presetOptions.minValue = userOptions.minValue;
+    converterOptions.minValue = userOptions.minValue;
+  }
+  if (userOptions?.to !== void 0) {
+    presetOptions.to = userOptions.to;
+  }
+  if (userOptions?.transform !== void 0) {
+    presetOptions.transform = userOptions.transform;
+  }
+  if (userOptions?.unitMap !== void 0) {
+    presetOptions.unitMap = userOptions.unitMap;
+  }
+  if (userOptions?.exclude !== void 0) {
+    converterOptions.exclude = userOptions.exclude;
+  }
+  if (userOptions?.mediaQuery !== void 0) {
+    converterOptions.mediaQuery = userOptions.mediaQuery;
+  }
+  if (userOptions?.propList !== void 0) {
+    converterOptions.propList = userOptions.propList;
+  }
+  if (userOptions?.replace !== void 0) {
+    converterOptions.replace = userOptions.replace;
+  }
+  if (userOptions?.selectorBlackList !== void 0) {
+    converterOptions.selectorBlackList = userOptions.selectorBlackList;
+  }
+  if (userOptions?.unitPrecision !== void 0) {
+    converterOptions.unitPrecision = userOptions.unitPrecision;
+  }
+  converterOptions.rules = presets.unitsToPx(presetOptions);
+  return postcssUnitConverter(converterOptions);
 }
 
 // src/plugins/post.ts
@@ -1822,6 +2033,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 +2048,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 +2159,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 +2168,7 @@ var postcssWeappTailwindcssPostPlugin = (options) => {
       if (enableMainChunkTransforms) {
         fallbackRemove?.transformSync(rule);
       }
+      cleanFallbackPlaceholder(rule);
       cleanRootSpecificity?.(rule);
       if (enableMainChunkTransforms) {
         if (shouldAppendHostSelector?.(rule)) {
@@ -2373,7 +2626,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 +2656,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 +2686,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 +2789,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 +2809,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 +2843,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 +2877,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
 };