@weapp-tailwindcss/postcss 2.0.7 → 2.1.0

package/dist/index.js

@@ -1,8 +1,7 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }require('./chunk-GGNOJ77I.js');
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;require('./chunk-GGNOJ77I.js');
 
 // src/handler.ts
 var _shared = require('@weapp-tailwindcss/shared');
-var _postcss = require('postcss'); var _postcss2 = _interopRequireDefault(_postcss);
 
 // src/defaults.ts
 function getDefaultOptions(options) {
@@ -35,6 +34,102 @@ function getDefaultOptions(options) {
   };
 }
 
+// src/options-resolver.ts
+
+
+// src/fingerprint.ts
+function fingerprintOptions(value, state = { map: /* @__PURE__ */ new WeakMap(), counter: 0 }) {
+  if (value === null || value === void 0) {
+    return String(value);
+  }
+  if (typeof value === "function") {
+    return `fn:${value.name || "anonymous"}`;
+  }
+  if (typeof value === "symbol") {
+    return `sym:${String(value)}`;
+  }
+  if (typeof value !== "object") {
+    return `${typeof value}:${String(value)}`;
+  }
+  const objectValue = value;
+  const cached = state.map.get(objectValue);
+  if (cached) {
+    return cached;
+  }
+  const marker = `ref:${state.counter++}`;
+  state.map.set(objectValue, marker);
+  if (Array.isArray(objectValue)) {
+    const parts2 = objectValue.map((entry) => fingerprintOptions(entry, state));
+    return `[${parts2.join(",")}]`;
+  }
+  const keys = Object.keys(objectValue).sort();
+  const parts = keys.map((key) => `${key}:${fingerprintOptions(objectValue[key], state)}`);
+  return `{${parts.join(",")}}@${marker}`;
+}
+
+// src/options-resolver.ts
+var BASE_CACHE_KEY = "base";
+function hasOverrides(options) {
+  return Boolean(options && Object.keys(options).length > 0);
+}
+function createOptionsResolver(baseOptions) {
+  const cacheByKey = /* @__PURE__ */ new Map();
+  const cacheByRef = /* @__PURE__ */ new WeakMap();
+  const fingerprintByRef = /* @__PURE__ */ new WeakMap();
+  cacheByKey.set(BASE_CACHE_KEY, baseOptions);
+  const resolve = (overrides) => {
+    if (!hasOverrides(overrides)) {
+      return baseOptions;
+    }
+    const refCached = cacheByRef.get(overrides);
+    if (refCached) {
+      return refCached;
+    }
+    let key = fingerprintByRef.get(overrides);
+    if (!key) {
+      key = fingerprintOptions(overrides);
+      fingerprintByRef.set(overrides, key);
+    }
+    const cached = cacheByKey.get(key);
+    if (cached) {
+      cacheByRef.set(overrides, cached);
+      return cached;
+    }
+    const merged = _shared.defuOverrideArray.call(void 0, 
+      { ...overrides },
+      baseOptions
+    );
+    cacheByKey.set(key, merged);
+    cacheByRef.set(overrides, merged);
+    return merged;
+  };
+  return {
+    resolve
+  };
+}
+
+// src/preflight.ts
+function createInjectPreflight(options) {
+  const result = [];
+  if (options && typeof options === "object") {
+    const entries = Object.entries(options);
+    for (const [prop, value] of entries) {
+      if (value !== false) {
+        result.push({
+          prop,
+          value: value.toString()
+        });
+      }
+    }
+  }
+  return () => {
+    return result;
+  };
+}
+
+// src/processor-cache.ts
+var _postcss = require('postcss'); var _postcss2 = _interopRequireDefault(_postcss);
+
 // src/pipeline.ts
 var _postcsspresetenv = require('postcss-preset-env'); var _postcsspresetenv2 = _interopRequireDefault(_postcsspresetenv);
 
@@ -154,7 +249,7 @@ function createContext() {
 // src/plugins/getCalcPlugin.ts
 var _postcsscalc = require('@weapp-tailwindcss/postcss-calc'); var _postcsscalc2 = _interopRequireDefault(_postcsscalc);
 
-// ../../node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/object/omit.mjs
+// ../../node_modules/.pnpm/es-toolkit@1.43.0/node_modules/es-toolkit/dist/object/omit.mjs
 function omit(obj, keys) {
   const result = { ...obj };
   for (let i = 0; i < keys.length; i++) {
@@ -220,9 +315,10 @@ function getCustomPropertyCleaner(options) {
 
 // src/plugins/getPxTransformPlugin.ts
 
-var _postcsspxtransform = require('postcss-pxtransform'); var _postcsspxtransform2 = _interopRequireDefault(_postcsspxtransform);
+var _postcsspxtrans = require('postcss-pxtrans'); var _postcsspxtrans2 = _interopRequireDefault(_postcsspxtrans);
 var defaultPxTransformOptions = {
   platform: "weapp",
+  targetUnit: "rpx",
   unitPrecision: 5,
   propList: ["*"],
   selectorBlackList: [],
@@ -242,7 +338,7 @@ function getPxTransformPlugin(options) {
     return null;
   }
   const userOptions = typeof options.px2rpx === "object" ? options.px2rpx : {};
-  return _postcsspxtransform2.default.call(void 0, 
+  return _postcsspxtrans2.default.call(void 0, 
     _shared.defuOverrideArray.call(void 0, 
       userOptions,
       defaultPxTransformOptions
@@ -276,8 +372,36 @@ function getRemTransformPlugin(options) {
 // src/plugins/post.ts
 
 
-// src/compat/tailwindcss-v4.ts
-
+// src/compat/tailwindcss-rpx.ts
+var LENGTH_VALUE_REGEXP = /^[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?rpx$/i;
+function normalizeTailwindcssRpxDeclaration(decl, options) {
+  const majorVersion = _optionalChain([options, 'optionalAccess', _12 => _12.majorVersion]);
+  const normalizedValue = decl.value.trim();
+  if (LENGTH_VALUE_REGEXP.test(normalizedValue) && (majorVersion === void 0 || majorVersion === 2 || majorVersion === 3 || majorVersion === 4)) {
+    const lowerProp = decl.prop.toLowerCase();
+    if (lowerProp === "color") {
+      decl.prop = "font-size";
+      return true;
+    }
+    if (lowerProp === "background-color") {
+      decl.prop = "background-size";
+      return true;
+    }
+    if (lowerProp === "outline-color") {
+      decl.prop = "outline-width";
+      return true;
+    }
+    if (lowerProp.startsWith("border") && lowerProp.endsWith("color")) {
+      decl.prop = `${decl.prop.slice(0, -"color".length)}width`;
+      return true;
+    }
+    if (lowerProp === "--tw-ring-color") {
+      decl.prop = "--tw-ring-offset-width";
+      return true;
+    }
+  }
+  return false;
+}
 
 // src/cssVarsV4.ts
 function property(ident, initialValue, _syntax) {
@@ -417,23 +541,27 @@ for (const edge of ["top", "right", "bottom", "left"]) {
 }
 var cssVarsV4_default = nodes;
 
+// src/utils/css-vars.ts
+
+function createCssVarNodes(definitions) {
+  return definitions.map((def) => new (0, _postcss.Declaration)({
+    prop: def.prop,
+    value: def.value
+  }));
+}
+
 // src/compat/tailwindcss-v4.ts
 var OKLAB_SUFFIX = "in oklab";
 var INFINITY_CALC_REGEXP = /calc\(\s*infinity\s*\*\s*(?:\d+(?:\.\d*)?|\.\d+)r?px/;
 var RADIUS_THRESHOLD = 1e5;
 var CLAMP_PX = 9999;
 function isTailwindcssV4(options) {
-  return _optionalChain([options, 'optionalAccess', _12 => _12.majorVersion]) === 4;
+  return _optionalChain([options, 'optionalAccess', _13 => _13.majorVersion]) === 4;
 }
 function testIfRootHostForV4(node) {
   return node.type === "rule" && node.selector.includes(":root") && node.selector.includes(":host");
 }
-var cssVarsV4Nodes = cssVarsV4_default.map((x) => {
-  return new (0, _postcss.Declaration)({
-    prop: x.prop,
-    value: x.value
-  });
-});
+var cssVarsV4Nodes = createCssVarNodes(cssVarsV4_default);
 function isTailwindcssV4ModernCheck(atRule) {
   return atRule.name === "supports" && [
     /-webkit-hyphens\s*:\s*none/,
@@ -475,7 +603,7 @@ function normalizeTailwindcssV4Declaration(decl) {
 
 // src/compat/uni-app-x.ts
 function isUniAppXEnabled(options) {
-  return Boolean(_optionalChain([options, 'optionalAccess', _13 => _13.uniAppX]));
+  return Boolean(_optionalChain([options, 'optionalAccess', _14 => _14.uniAppX]));
 }
 function stripUnsupportedPseudoForUniAppX(node, enabled) {
   if (!enabled) {
@@ -509,7 +637,7 @@ var beforeAfterParser = _postcssselectorparser2.default.call(void 0, (selectors)
     return;
   }
   selectors.walkPseudos((s) => {
-    if (_optionalChain([s, 'access', _14 => _14.parent, 'optionalAccess', _15 => _15.length]) === 1) {
+    if (_optionalChain([s, 'access', _15 => _15.parent, 'optionalAccess', _16 => _16.length]) === 1) {
       if (/^:?:before$/.test(s.value)) {
         state.before = true;
       }
@@ -583,6 +711,7 @@ function getCombinatorSelectorAst(options) {
 // src/selectorParser/fallback.ts
 var fallbackRemoveCache = /* @__PURE__ */ new WeakMap();
 var fallbackDefaultKey = {};
+var FALLBACK_TRANSFORM_OPTIONS = normalizeTransformOptions();
 function getFallbackRemove(_rule, options) {
   const cacheKey = _nullishCoalesce(options, () => ( fallbackDefaultKey));
   let entry = fallbackRemoveCache.get(cacheKey);
@@ -597,13 +726,13 @@ function getFallbackRemove(_rule, options) {
           maybeImportantId = true;
         }
         if (selector.type === "universal") {
-          _optionalChain([selector, 'access', _16 => _16.parent, 'optionalAccess', _17 => _17.remove, 'call', _18 => _18()]);
+          _optionalChain([selector, 'access', _17 => _17.parent, 'optionalAccess', _18 => _18.remove, 'call', _19 => _19()]);
         } else if (selector.type === "pseudo") {
           if (selector.value === ":is") {
-            if (maybeImportantId && _optionalChain([selector, 'access', _19 => _19.nodes, 'access', _20 => _20[0], 'optionalAccess', _21 => _21.type]) === "selector") {
+            if (maybeImportantId && _optionalChain([selector, 'access', _20 => _20.nodes, 'access', _21 => _21[0], 'optionalAccess', _22 => _22.type]) === "selector") {
               selector.replaceWith(selector.nodes[0]);
             } else {
-              _optionalChain([selector, 'access', _22 => _22.parent, 'optionalAccess', _23 => _23.remove, 'call', _24 => _24()]);
+              _optionalChain([selector, 'access', _23 => _23.parent, 'optionalAccess', _24 => _24.remove, 'call', _25 => _25()]);
             }
           } else if (selector.value === ":not") {
             for (const x of selector.nodes) {
@@ -626,7 +755,7 @@ function getFallbackRemove(_rule, options) {
           }
         } else if (selector.type === "attribute") {
           if (selector.attribute === "hidden") {
-            _optionalChain([activeRule, 'optionalAccess', _25 => _25.remove, 'call', _26 => _26()]);
+            _optionalChain([activeRule, 'optionalAccess', _26 => _26.remove, 'call', _27 => _27()]);
           }
         }
       });
@@ -647,24 +776,25 @@ function getFallbackRemove(_rule, options) {
     const transform = (targetRule) => {
       currentRule = targetRule;
       try {
-        rawTransformSync(targetRule, normalizeTransformOptions());
+        rawTransformSync(targetRule, FALLBACK_TRANSFORM_OPTIONS);
       } finally {
         currentRule = void 0;
       }
     };
     parser.transformSync = ((input, opts) => {
+      const transformOptions = opts ? normalizeTransformOptions(opts) : FALLBACK_TRANSFORM_OPTIONS;
       if (input && typeof input === "object" && "type" in input) {
         const maybeRule = input;
         if (maybeRule.type === "rule") {
           currentRule = input;
           try {
-            return rawTransformSync(input, normalizeTransformOptions(opts));
+            return rawTransformSync(input, transformOptions);
           } finally {
             currentRule = void 0;
           }
         }
       }
-      return rawTransformSync(input, opts);
+      return rawTransformSync(input, transformOptions);
     });
     entry = {
       parser,
@@ -698,6 +828,47 @@ function composeIsPseudo(strs) {
   return strs.join("");
 }
 
+// src/utils/decl-order.ts
+function reorderLiteralFirst(rule, declarations, isVariable) {
+  if (declarations.length <= 1) {
+    return;
+  }
+  const literals = [];
+  const variables = [];
+  for (const decl of declarations) {
+    if (isVariable(decl)) {
+      variables.push(decl);
+    } else {
+      literals.push(decl);
+    }
+  }
+  if (literals.length === 0 || variables.length === 0) {
+    return;
+  }
+  const desired = [...literals, ...variables];
+  let alreadyOrdered = true;
+  for (let index = 0; index < desired.length; index++) {
+    if (desired[index] !== declarations[index]) {
+      alreadyOrdered = false;
+      break;
+    }
+  }
+  if (alreadyOrdered) {
+    return;
+  }
+  const anchor = _nullishCoalesce(_optionalChain([declarations, 'access', _28 => _28[declarations.length - 1], 'optionalAccess', _29 => _29.next, 'call', _30 => _30()]), () => ( void 0));
+  for (const decl of declarations) {
+    decl.remove();
+  }
+  for (const decl of desired) {
+    if (anchor) {
+      rule.insertBefore(anchor, decl);
+    } else {
+      rule.append(decl);
+    }
+  }
+}
+
 // src/selectorParser/rule-transformer.ts
 var ruleTransformCache = /* @__PURE__ */ new WeakMap();
 var MIRROR_PROP_PAIRS = [
@@ -725,6 +896,7 @@ var LEGACY_WEBKIT_SPACING_PROPS = /* @__PURE__ */ new Set([
   "-webkit-margin-after"
 ]);
 var VAR_REFERENCE_PATTERN = /var\(/i;
+var SELECTOR_TRANSFORM_OPTIONS = normalizeTransformOptions();
 function dedupeSpacingProps(rule) {
   const grouped = /* @__PURE__ */ new Map();
   for (const node of rule.nodes) {
@@ -762,27 +934,11 @@ function dedupeSpacingProps(rule) {
     if (unique.length <= 1) {
       continue;
     }
-    const literals = unique.filter((decl) => !VAR_REFERENCE_PATTERN.test(decl.value));
-    const variables = unique.filter((decl) => VAR_REFERENCE_PATTERN.test(decl.value));
-    if (variables.length === 0 || literals.length === 0) {
-      continue;
-    }
-    const ordered = [...literals, ...variables];
-    const alreadyOrdered = ordered.every((decl, index) => decl === unique[index]);
-    if (alreadyOrdered) {
-      continue;
-    }
-    const anchor = _nullishCoalesce(_optionalChain([unique, 'access', _27 => _27[unique.length - 1], 'optionalAccess', _28 => _28.next, 'call', _29 => _29()]), () => ( void 0));
-    for (const decl of unique) {
-      decl.remove();
-    }
-    for (const decl of ordered) {
-      if (anchor) {
-        rule.insertBefore(anchor, decl);
-      } else {
-        rule.append(decl);
-      }
-    }
+    reorderLiteralFirst(
+      rule,
+      unique,
+      (decl) => VAR_REFERENCE_PATTERN.test(decl.value)
+    );
   }
 }
 function isNotLastChildPseudo(node) {
@@ -797,7 +953,7 @@ function isNotLastChildPseudo(node) {
   if (firstSelector.type !== "selector") {
     return false;
   }
-  const target = _optionalChain([firstSelector, 'access', _30 => _30.nodes, 'optionalAccess', _31 => _31[0]]);
+  const target = _optionalChain([firstSelector, 'access', _31 => _31.nodes, 'optionalAccess', _32 => _32[0]]);
   return Boolean(target && target.type === "pseudo" && target.value === ":last-child");
 }
 function transformSpacingSelector(nodes2, options) {
@@ -844,7 +1000,7 @@ function flattenWherePseudo(node, context, index, parent) {
     node.value = ":is";
   }
   if (index === 0 && node.length === 1) {
-    const targetSelector = _optionalChain([node, 'access', _32 => _32.nodes, 'optionalAccess', _33 => _33[0]]);
+    const targetSelector = _optionalChain([node, 'access', _33 => _33.nodes, 'optionalAccess', _34 => _34[0]]);
     if (targetSelector && targetSelector.type === "selector" && transformSpacingSelector(targetSelector.nodes, context.options)) {
       context.requiresSpacingNormalization = true;
     }
@@ -864,7 +1020,7 @@ function handleUniversalNode(node, context) {
   if (node.type !== "universal") {
     return;
   }
-  const replacement = _optionalChain([context, 'access', _34 => _34.options, 'access', _35 => _35.cssSelectorReplacement, 'optionalAccess', _36 => _36.universal]);
+  const replacement = _optionalChain([context, 'access', _35 => _35.options, 'access', _36 => _36.cssSelectorReplacement, 'optionalAccess', _37 => _37.universal]);
   if (replacement) {
     node.value = composeIsPseudo(replacement);
   }
@@ -899,7 +1055,7 @@ function handleCombinatorNode(node, index, context) {
   if (node.type !== "combinator" || node.value !== ">") {
     return;
   }
-  const nodes2 = _optionalChain([node, 'access', _37 => _37.parent, 'optionalAccess', _38 => _38.nodes]);
+  const nodes2 = _optionalChain([node, 'access', _38 => _38.parent, 'optionalAccess', _39 => _39.nodes]);
   if (!nodes2) {
     return;
   }
@@ -915,7 +1071,7 @@ function handlePseudoNode(node, index, context, parent) {
   if (node.type !== "pseudo") {
     return;
   }
-  if (node.value === ":root" && _optionalChain([context, 'access', _39 => _39.options, 'access', _40 => _40.cssSelectorReplacement, 'optionalAccess', _41 => _41.root])) {
+  if (node.value === ":root" && _optionalChain([context, 'access', _40 => _40.options, 'access', _41 => _41.cssSelectorReplacement, 'optionalAccess', _42 => _42.root])) {
     node.value = composeIsPseudo(context.options.cssSelectorReplacement.root);
     return;
   }
@@ -937,7 +1093,7 @@ function handleSelectorNode(selector, context) {
 }
 function transformSelectors(selectors, context) {
   selectors.walk((node, index) => {
-    const parent = _optionalChain([node, 'access', _42 => _42.parent, 'optionalAccess', _43 => _43.type]) === "selector" ? node.parent : void 0;
+    const parent = _optionalChain([node, 'access', _43 => _43.parent, 'optionalAccess', _44 => _44.type]) === "selector" ? node.parent : void 0;
     switch (node.type) {
       case "class":
         handleClassNode(node, context);
@@ -992,7 +1148,7 @@ function createRuleTransformer(options) {
       rule
     };
     try {
-      parser.transformSync(rule, normalizeTransformOptions());
+      parser.transformSync(rule, SELECTOR_TRANSFORM_OPTIONS);
     } finally {
       context = void 0;
     }
@@ -1015,7 +1171,7 @@ function normalizeSelectorList(value) {
   return Array.isArray(value) ? value.filter(Boolean) : [value];
 }
 function getSpecificityMatchingName(options) {
-  const feature = _optionalChain([options, 'access', _44 => _44.cssPresetEnv, 'optionalAccess', _45 => _45.features, 'optionalAccess', _46 => _46["is-pseudo-class"]]);
+  const feature = _optionalChain([options, 'access', _45 => _45.cssPresetEnv, 'optionalAccess', _46 => _46.features, 'optionalAccess', _47 => _47["is-pseudo-class"]]);
   if (feature && typeof feature === "object" && "specificityMatchingName" in feature) {
     const specificityName = feature.specificityMatchingName;
     return typeof specificityName === "string" && specificityName.length > 0 ? specificityName : void 0;
@@ -1024,12 +1180,12 @@ function getSpecificityMatchingName(options) {
 }
 function createRootSpecificityCleaner(options) {
   const specificityMatchingName = getSpecificityMatchingName(options);
-  const selectors = normalizeSelectorList(_optionalChain([options, 'access', _47 => _47.cssSelectorReplacement, 'optionalAccess', _48 => _48.root]));
+  const selectors = normalizeSelectorList(_optionalChain([options, 'access', _48 => _48.cssSelectorReplacement, 'optionalAccess', _49 => _49.root]));
   if (!specificityMatchingName || selectors.length === 0) {
     return void 0;
   }
   const suffix = `:not(.${specificityMatchingName})`;
-  const targets = selectors.map((selector) => _optionalChain([selector, 'optionalAccess', _49 => _49.trim, 'call', _50 => _50()])).filter((selector) => Boolean(_optionalChain([selector, 'optionalAccess', _51 => _51.length]))).map((selector) => ({
+  const targets = selectors.map((selector) => _optionalChain([selector, 'optionalAccess', _50 => _50.trim, 'call', _51 => _51()])).filter((selector) => Boolean(_optionalChain([selector, 'optionalAccess', _52 => _52.length]))).map((selector) => ({
     match: `${selector}${suffix}`,
     spacedMatch: `${selector} ${suffix}`,
     replacement: selector
@@ -1158,33 +1314,11 @@ function dedupeDeclarations(rule) {
     if (declarations.length <= 1) {
       continue;
     }
-    const literals = declarations.filter((decl) => !hasVariableReference(decl.value));
-    const variables = declarations.filter((decl) => hasVariableReference(decl.value));
-    if (literals.length === 0 || variables.length === 0) {
-      continue;
-    }
-    const ordered = [...literals, ...variables];
-    let needReorder = false;
-    for (let index = 0; index < ordered.length; index++) {
-      if (ordered[index] !== declarations[index]) {
-        needReorder = true;
-        break;
-      }
-    }
-    if (!needReorder) {
-      continue;
-    }
-    const anchor = _nullishCoalesce(_optionalChain([declarations, 'access', _52 => _52[declarations.length - 1], 'optionalAccess', _53 => _53.next, 'call', _54 => _54()]), () => ( void 0));
-    for (const decl of declarations) {
-      decl.remove();
-    }
-    for (const decl of ordered) {
-      if (anchor) {
-        rule.insertBefore(anchor, decl);
-      } else {
-        rule.append(decl);
-      }
-    }
+    reorderLiteralFirst(
+      rule,
+      declarations,
+      (decl) => hasVariableReference(decl.value)
+    );
   }
   const literalSeen = /* @__PURE__ */ new Map();
   for (const node of [...rule.nodes]) {
@@ -1219,9 +1353,9 @@ var postcssWeappTailwindcssPostPlugin = (options) => {
     const fallbackRemove = enableMainChunkTransforms ? getFallbackRemove(void 0, opts) : void 0;
     p.RuleExit = (rule) => {
       if (enableMainChunkTransforms) {
-        _optionalChain([fallbackRemove, 'optionalAccess', _55 => _55.transformSync, 'call', _56 => _56(rule)]);
+        _optionalChain([fallbackRemove, 'optionalAccess', _53 => _53.transformSync, 'call', _54 => _54(rule)]);
       }
-      _optionalChain([cleanRootSpecificity, 'optionalCall', _57 => _57(rule)]);
+      _optionalChain([cleanRootSpecificity, 'optionalCall', _55 => _55(rule)]);
       if (enableMainChunkTransforms) {
         dedupeDeclarations(rule);
         if (rule.selectors.length === 0 || rule.selectors.length === 1 && rule.selector.trim() === "") {
@@ -1234,12 +1368,15 @@ var postcssWeappTailwindcssPostPlugin = (options) => {
     };
   }
   if (enableMainChunkTransforms) {
-    p.DeclarationExit = (decl) => normalizeTailwindcssV4Declaration(decl);
+    p.DeclarationExit = (decl) => {
+      normalizeTailwindcssRpxDeclaration(decl, { majorVersion: opts.majorVersion });
+      normalizeTailwindcssV4Declaration(decl);
+    };
     p.AtRuleExit = (atRule) => {
       if (opts.cssRemoveProperty && atRule.name === "property") {
         atRule.remove();
       }
-      _optionalChain([atRule, 'access', _58 => _58.nodes, 'optionalAccess', _59 => _59.length]) === 0 && atRule.remove();
+      _optionalChain([atRule, 'access', _56 => _56.nodes, 'optionalAccess', _57 => _57.length]) === 0 && atRule.remove();
     };
   }
   return p;
@@ -1460,42 +1597,31 @@ var cssVarsV3_default = [
   }
 ];
 
-// src/mp.ts
-var cssVarsV3Nodes = cssVarsV3_default.map((x) => {
-  return new (0, _postcss.Declaration)({
-    prop: x.prop,
-    value: x.value
-  });
-});
-function testIfVariablesScope(node, count = 2) {
-  if (isOnlyBeforeAndAfterPseudoElement(node)) {
-    const nodes2 = node.nodes;
-    let c = 0;
-    for (const tryTestDecl of nodes2) {
-      if (tryTestDecl && tryTestDecl.type === "decl" && tryTestDecl.prop.startsWith("--tw-")) {
-        c++;
-      }
-      if (c >= count) {
+// src/utils/tw-vars.ts
+function hasTwVars(rule, count = 2) {
+  let matched = 0;
+  for (const node of _nullishCoalesce(rule.nodes, () => ( []))) {
+    if (node.type === "decl" && node.prop.startsWith("--tw-")) {
+      matched++;
+      if (matched >= count) {
         return true;
       }
     }
-    return false;
+  }
+  return false;
+}
+
+// src/mp.ts
+var cssVarsV3Nodes = createCssVarNodes(cssVarsV3_default);
+function testIfVariablesScope(node, count = 2) {
+  if (isOnlyBeforeAndAfterPseudoElement(node)) {
+    return hasTwVars(node, count);
   }
   return false;
 }
 function testIfTwBackdrop(node, count = 2) {
   if (node.type === "rule" && node.selector === "::backdrop") {
-    const nodes2 = node.nodes;
-    let c = 0;
-    for (const tryTestDecl of nodes2) {
-      if (tryTestDecl && tryTestDecl.type === "decl" && tryTestDecl.prop.startsWith("--tw-")) {
-        c++;
-      }
-      if (c >= count) {
-        return true;
-      }
-    }
-    return false;
+    return hasTwVars(node, count);
   }
   return false;
 }
@@ -1533,7 +1659,7 @@ function remakeCssVarSelector(selectors, options) {
 function commonChunkPreflight(node, options) {
   const { ctx, cssInjectPreflight, injectAdditionalCssVarScope } = options;
   if (testIfVariablesScope(node)) {
-    _optionalChain([ctx, 'optionalAccess', _60 => _60.markVariablesScope, 'call', _61 => _61(node)]);
+    _optionalChain([ctx, 'optionalAccess', _58 => _58.markVariablesScope, 'call', _59 => _59(node)]);
     node.selectors = remakeCssVarSelector(node.selectors, options);
     node.before(makePseudoVarRule());
     if (typeof cssInjectPreflight === "function") {
@@ -1590,9 +1716,9 @@ var postcssWeappTailwindcssPrePlugin = (options) => {
       root.walkAtRules((atRule) => {
         if (atRule.name === "layer") {
           if (atRule.params === "properties") {
-            if (atRule.nodes === void 0 || _optionalChain([atRule, 'access', _62 => _62.nodes, 'optionalAccess', _63 => _63.length]) === 0) {
+            if (atRule.nodes === void 0 || _optionalChain([atRule, 'access', _60 => _60.nodes, 'optionalAccess', _61 => _61.length]) === 0) {
               layerProperties = atRule;
-            } else if (_optionalChain([atRule, 'access', _64 => _64.first, 'optionalAccess', _65 => _65.type]) === "atrule" && isTailwindcssV4ModernCheck(atRule.first)) {
+            } else if (_optionalChain([atRule, 'access', _62 => _62.first, 'optionalAccess', _63 => _63.type]) === "atrule" && isTailwindcssV4ModernCheck(atRule.first)) {
               if (layerProperties) {
                 layerProperties.replaceWith(atRule.first.nodes);
                 atRule.remove();
@@ -1604,7 +1730,7 @@ var postcssWeappTailwindcssPrePlugin = (options) => {
             atRule.replaceWith(atRule.nodes);
           }
         } else if (isTailwindcssV4ModernCheck(atRule)) {
-          if (_optionalChain([atRule, 'access', _66 => _66.first, 'optionalAccess', _67 => _67.type]) === "atrule" && atRule.first.name === "layer") {
+          if (_optionalChain([atRule, 'access', _64 => _64.first, 'optionalAccess', _65 => _65.type]) === "atrule" && atRule.first.name === "layer") {
             atRule.replaceWith(atRule.first.nodes);
           }
         }
@@ -1649,7 +1775,7 @@ function createPipelineDefinitions(options) {
     normal: [],
     post: []
   };
-  const userPlugins = normalizeUserPlugins(_optionalChain([options, 'access', _68 => _68.postcssOptions, 'optionalAccess', _69 => _69.plugins]));
+  const userPlugins = normalizeUserPlugins(_optionalChain([options, 'access', _66 => _66.postcssOptions, 'optionalAccess', _67 => _67.plugins]));
   userPlugins.forEach((plugin, index) => {
     stages.pre.push(createStaticDefinition(`pre:user-${index}`, "pre", plugin));
   });
@@ -1786,83 +1912,71 @@ function createStylePipeline(options) {
   };
 }
 
-// src/preflight.ts
-function createInjectPreflight(options) {
-  const result = [];
-  if (options && typeof options === "object") {
-    const entries = Object.entries(options);
-    for (const [prop, value] of entries) {
-      if (value !== false) {
-        result.push({
-          prop,
-          value: value.toString()
-        });
-      }
-    }
-  }
-  return () => {
-    return result;
-  };
-}
-
-// src/handler.ts
+// src/processor-cache.ts
 function createProcessOptions(options) {
   return {
     from: void 0,
-    ..._nullishCoalesce(_optionalChain([options, 'access', _70 => _70.postcssOptions, 'optionalAccess', _71 => _71.options]), () => ( {}))
+    ..._nullishCoalesce(_optionalChain([options, 'access', _68 => _68.postcssOptions, 'optionalAccess', _69 => _69.options]), () => ( {}))
   };
 }
-var pipelineCache = /* @__PURE__ */ new WeakMap();
-var processOptionsCache = /* @__PURE__ */ new WeakMap();
-var processOptionsSourceCache = /* @__PURE__ */ new WeakMap();
-function getCachedPipeline(options) {
-  let pipeline = pipelineCache.get(options);
-  if (!pipeline) {
-    pipeline = createStylePipeline(options);
-    pipelineCache.set(options, pipeline);
-  }
-  return pipeline;
-}
-function getCachedProcessOptions(options) {
-  const source = _optionalChain([options, 'access', _72 => _72.postcssOptions, 'optionalAccess', _73 => _73.options]);
-  let cached = processOptionsCache.get(options);
-  const cachedSource = processOptionsSourceCache.get(options);
-  if (!cached || cachedSource !== source) {
-    cached = createProcessOptions(options);
-    processOptionsCache.set(options, cached);
-    processOptionsSourceCache.set(options, source);
-  }
-  return { ...cached };
-}
-function styleHandler(rawSource, options) {
-  const plugins = getCachedPipeline(options).plugins;
-  const processOptions = getCachedProcessOptions(options);
-  return _postcss2.default.call(void 0, plugins).process(
-    rawSource,
-    processOptions
-  ).async();
-}
+var StyleProcessorCache = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this); }
+  __init() {this.pipelineCache = /* @__PURE__ */ new WeakMap()}
+  __init2() {this.processOptionsCache = /* @__PURE__ */ new WeakMap()}
+  __init3() {this.processorCache = /* @__PURE__ */ new WeakMap()}
+  getPipeline(options) {
+    let pipeline = this.pipelineCache.get(options);
+    if (!pipeline) {
+      pipeline = createStylePipeline(options);
+      this.pipelineCache.set(options, pipeline);
+    }
+    return pipeline;
+  }
+  getProcessOptions(options) {
+    const source = _optionalChain([options, 'access', _70 => _70.postcssOptions, 'optionalAccess', _71 => _71.options]);
+    const fingerprint = source ? fingerprintOptions(source) : void 0;
+    const cached = this.processOptionsCache.get(options);
+    if (!cached || cached.fingerprint !== fingerprint) {
+      const created = createProcessOptions(options);
+      this.processOptionsCache.set(options, { value: created, fingerprint });
+      return { ...created };
+    }
+    return { ...cached.value };
+  }
+  getProcessor(options) {
+    let processor = this.processorCache.get(options);
+    if (!processor) {
+      const pipeline = this.getPipeline(options);
+      processor = _postcss2.default.call(void 0, pipeline.plugins);
+      this.processorCache.set(options, processor);
+    }
+    return processor;
+  }
+}, _class);
+
+// src/handler.ts
 function createStyleHandler(options) {
   const cachedOptions = _shared.defuOverrideArray.call(void 0, 
     options,
     getDefaultOptions(options)
   );
   cachedOptions.cssInjectPreflight = createInjectPreflight(cachedOptions.cssPreflight);
-  getCachedPipeline(cachedOptions);
-  getCachedProcessOptions(cachedOptions);
+  const resolver = createOptionsResolver(cachedOptions);
+  const cache = new StyleProcessorCache();
+  const base = resolver.resolve();
+  cache.getProcessor(base);
+  cache.getProcessOptions(base);
   const handler = ((rawSource, opt) => {
-    const resolvedOptions = _shared.defuOverrideArray.call(void 0, opt, cachedOptions);
-    return styleHandler(
+    const resolvedOptions = resolver.resolve(opt);
+    const processor = cache.getProcessor(resolvedOptions);
+    const processOptions = cache.getProcessOptions(resolvedOptions);
+    return processor.process(
       rawSource,
-      resolvedOptions
-    );
+      processOptions
+    ).async();
   });
   handler.getPipeline = (opt) => {
-    if (!opt) {
-      return getCachedPipeline(cachedOptions);
-    }
-    const resolvedOptions = _shared.defuOverrideArray.call(void 0, opt, cachedOptions);
-    return getCachedPipeline(resolvedOptions);
+    const resolvedOptions = resolver.resolve(opt);
+    return cache.getPipeline(resolvedOptions);
   };
   return handler;
 }