@onereach/styles 27.0.2-beta.6103.0 → 27.0.2-beta.6105.0

package/postcss/tailwind-v4-compat.cjs

@@ -0,0 +1,816 @@
+const postcss = require('postcss');
+const postcssNested = require('postcss-nested');
+
+const screens = require('../screens.json');
+const {
+  importantMarker,
+} = require('../tailwind/compatibility/important');
+const {
+  legacySpacingAliasEntries,
+} = require('../tailwind/compatibility/legacy-spacing');
+const coreVariants = require('../tailwind/plugins/core').variants;
+const themePresetValues = require('../tailwind/plugins/theme-preset').values;
+const spacing = require('../tailwind.config.preset.v4').theme.spacing;
+
+const legacyStateVariantOrder = new Map(
+  Object.keys(coreVariants)
+    .map((variant, index) => [variant, index]),
+);
+
+const legacySpacingAliases = legacySpacingAliasEntries(spacing)
+  .sort(([, left], [, right]) => right.length - left.length);
+const legacySpacingUtilityPattern = /^-?(?:p(?:[xytrblse])?|m(?:[xytrblse])?|gap(?:-[xy])?|w|h|min-[wh]|max-[wh])-/;
+const responsiveVariantOrder = new Map(
+  ['xs', ...Object.keys(screens)].map((variant, index) => [variant, index]),
+);
+const legacyTransformValue = [
+  'translate(var(--tw-translate-x, 0), var(--tw-translate-y, 0))',
+  'rotate(var(--tw-rotate, 0))',
+  'skewX(var(--tw-skew-x, 0))',
+  'skewY(var(--tw-skew-y, 0))',
+  'scaleX(var(--tw-scale-x, 1))',
+  'scaleY(var(--tw-scale-y, 1))',
+].join(' ');
+const legacyComponentFactories = [
+  ['theme-outline', require('../tailwind/plugins/theme-outline').values],
+  ['theme-background', require('../tailwind/plugins/theme-background').values],
+  ['theme-foreground', require('../tailwind/plugins/theme-foreground').values],
+  ['theme-preset-1', themePresetValues],
+  ['theme-preset-2', themePresetValues],
+  ['theme-preset-3', themePresetValues],
+  ['theme-preset-4', themePresetValues],
+  ['theme-divider', require('../tailwind/plugins/theme-divider').values],
+  ['theme-border', require('../tailwind/plugins/theme-border').values],
+]
+  .map(([factory, values]) => [
+    factory,
+    new Map(Object.keys(values).map((value, index) => [value, index])),
+  ])
+  .sort(([left], [right]) => right.length - left.length);
+const legacyComponentFactoryNames = [
+  'theme-background',
+  'theme-foreground',
+  'theme-preset-1',
+  'theme-preset-2',
+  'theme-preset-3',
+  'theme-preset-4',
+  'theme-divider',
+  'theme-outline',
+  'theme-border',
+  'iconography',
+  'typography',
+  'layout',
+].sort((left, right) => right.length - left.length);
+const legacyCoreUtilities = new Map([
+  ['leading-none', [
+    ['line-height', '1'],
+  ]],
+  ['text-inherit', [
+    ['font-size', 'inherit'],
+    ['line-height', 'inherit'],
+    ['color', 'inherit'],
+  ]],
+  ['outline', [
+    ['outline-style', 'solid'],
+  ]],
+  ['outline-none', [
+    ['outline', '2px solid transparent'],
+    ['outline-offset', '2px'],
+  ]],
+  ['transition-transform', [
+    ['transition-property', 'transform'],
+  ]],
+  ['max-w-none', [
+    ['max-width', 'none'],
+  ]],
+  ['max-h-none', [
+    ['max-height', 'none'],
+  ]],
+]);
+const legacyCoreReplacementProps = new Map([
+  ['leading-none', new Set(['--tw-leading', 'line-height'])],
+  ['text-inherit', new Set(['font-size', 'line-height', 'color'])],
+  ['outline', new Set([
+    '--tw-outline-style',
+    'outline',
+    'outline-style',
+    'outline-width',
+  ])],
+  ['outline-none', new Set([
+    '--tw-outline-style',
+    'outline',
+    'outline-offset',
+    'outline-style',
+  ])],
+  ['transition-transform', new Set([
+    'transition-property',
+    'transition-timing-function',
+    'transition-duration',
+  ])],
+  ['max-w-none', new Set(['max-width'])],
+  ['max-h-none', new Set(['max-height'])],
+]);
+
+function tailwindV4Compat() {
+  return {
+    postcssPlugin: 'onereach-tailwind-v4-compat',
+    async OnceExit(root) {
+      utilityLayers(root).forEach(restoreNestedVariantOrder);
+      await flattenUtilityLayers(root);
+
+      utilityLayers(root).forEach((layer) => {
+        restoreLegacyGroupHover(layer);
+        restoreStackedVariantOrder(layer);
+        restoreLegacySpacingClassNames(layer);
+        restoreImportantDeclarations(layer);
+        restoreLegacyCoreUtilities(layer);
+        restoreLegacyTransformUtilities(layer);
+        restoreArbitraryValueOrder(layer);
+        reorderLegacyComponentValueSiblings(layer);
+        reorderLegacyStateVariantSiblings(layer);
+        reorderResponsiveVariantSiblings(layer);
+      });
+      restoreLegacyComponentLayers(root);
+    },
+  };
+}
+
+function restoreNestedVariantOrder(root) {
+  root.walkRules((candidateRule) => {
+    const candidate = classNames(candidateRule.selector)
+      .find((className) => {
+        const variants = classSegments(className).slice(0, -1);
+        const arbitraryIndex = variants.findIndex((variant) => variant.startsWith('[&'));
+
+        return variants.includes('children')
+          || arbitraryIndex > 0;
+      });
+
+    if (!candidate) return;
+
+    const segments = classSegments(candidate);
+    const variantDepth = segments.length - 1;
+
+    const paths = nestedContainerPaths(candidateRule, variantDepth);
+
+    if (paths.length === 0) return;
+
+    candidateRule.removeAll();
+    candidateRule.append(paths.map(({ containers, nodes }) => {
+      let content = nodes.map((node) => node.clone());
+
+      containers.forEach((container) => {
+        const wrapper = container.clone();
+
+        wrapper.removeAll();
+        wrapper.append(content);
+        content = wrapper;
+      });
+
+      return content;
+    }));
+  });
+}
+
+function classSegments(className) {
+  const segments = [];
+  let bracketDepth = 0;
+  let segment = '';
+
+  for (const character of className) {
+    if (character === '[') bracketDepth += 1;
+    if (character === ']') bracketDepth -= 1;
+
+    if (character === ':' && bracketDepth === 0) {
+      segments.push(segment);
+      segment = '';
+      continue;
+    }
+
+    segment += character;
+  }
+
+  segments.push(segment);
+
+  return segments;
+}
+
+function nestedContainerPaths(container, depth, containers = []) {
+  if (depth === 0) {
+    return [{
+      containers,
+      nodes: container.nodes,
+    }];
+  }
+
+  return container.nodes
+    .filter((node) => ['atrule', 'rule'].includes(node.type))
+    .flatMap((child) => nestedContainerPaths(child, depth - 1, [
+      ...containers,
+      child,
+    ]));
+}
+
+async function flattenUtilityLayers(root) {
+  const layers = utilityLayers(root);
+
+  for (const layer of layers) {
+    const isolatedRoot = postcss.root();
+
+    isolatedRoot.append(layer.clone());
+    await postcss([postcssNested()]).process(isolatedRoot, { from: undefined });
+    layer.replaceWith(isolatedRoot.first);
+  }
+}
+
+function utilityLayers(root) {
+  const layers = [];
+
+  root.walkAtRules('layer', (layer) => {
+    if (layer.params.trim() === 'utilities') layers.push(layer);
+  });
+
+  return layers;
+}
+
+function restoreLegacyComponentLayers(root) {
+  utilityLayers(root).forEach((utilityLayer) => {
+    const componentNodes = extractLegacyComponentNodes(utilityLayer);
+
+    if (componentNodes.length === 0) return;
+
+    const componentLayer = postcss.atRule({
+      name: 'layer',
+      params: 'components',
+    });
+
+    componentLayer.append(componentNodes);
+    utilityLayer.before(componentLayer);
+  });
+}
+
+function extractLegacyComponentNodes(container) {
+  return [...(container.nodes ?? [])].flatMap((node) => {
+    if (node.type === 'rule') {
+      const isLegacyComponent = classNames(node.selector)
+        .map(baseUtility)
+        .some((utility) => legacyComponentFactoryNames
+          .some((factory) => utility.startsWith(`${factory}-`)));
+
+      if (!isLegacyComponent) return [];
+
+      node.remove();
+      return [node];
+    }
+
+    if (!node.nodes) return [];
+
+    const childNodes = extractLegacyComponentNodes(node);
+
+    if (childNodes.length === 0) return [];
+    if (node.type === 'atrule' && node.name === 'layer' && node.params === 'utilities') {
+      if (node.nodes.length === 0) node.remove();
+
+      return childNodes;
+    }
+
+    const wrapper = node.clone();
+
+    wrapper.removeAll();
+    wrapper.append(childNodes);
+    if (node.nodes.length === 0) node.remove();
+
+    return [wrapper];
+  });
+}
+
+function reorderLegacyComponentValueSiblings(container) {
+  const groups = new Map();
+
+  container.nodes?.forEach((node, index) => {
+    if (node.type !== 'rule') return;
+
+    const candidate = classNames(node.selector)
+      .map((className) => ({
+        className,
+        utility: baseUtility(className),
+      }))
+      .map((entry) => ({
+        ...entry,
+        factory: legacyComponentFactories
+          .find(([factory]) => entry.utility.startsWith(`${factory}-`)),
+      }))
+      .find(({ factory }) => factory);
+
+    if (!candidate) return;
+
+    const [factory, valueOrder] = candidate.factory;
+    const value = candidate.utility.slice(factory.length + 1);
+    const order = valueOrder.get(value);
+
+    if (order === undefined) return;
+
+    const variants = classSegments(candidate.className).slice(0, -1).join(':');
+    const key = `${factory}\0${variants}`;
+    const group = groups.get(key) ?? [];
+
+    group.push({
+      index,
+      node,
+      order,
+    });
+    groups.set(key, group);
+  });
+
+  groups.forEach((group) => {
+    const sorted = [...group].sort((left, right) => (
+      left.order - right.order || left.index - right.index
+    ));
+
+    group.forEach(({ index }, sortedIndex) => {
+      const node = sorted[sortedIndex].node;
+
+      container.nodes[index] = node;
+      node.parent = container;
+    });
+  });
+
+  container.nodes?.forEach((node) => {
+    if (node.nodes) reorderLegacyComponentValueSiblings(node);
+  });
+}
+
+function restoreStackedVariantOrder(root) {
+  root.walkRules((rule) => {
+    const candidate = classNames(rule.selector)
+      .find((className) => (
+        className.split(':').includes('children')
+        && ['first', 'last'].some((variant) => className.split(':').includes(variant))
+      ));
+
+    if (!candidate) return;
+
+    const variants = candidate.split(':');
+    const childIndex = variants.indexOf('children');
+    const position = variants.includes('first') ? 'first' : 'last';
+    const positionIndex = variants.indexOf(position);
+
+    if (childIndex < positionIndex) {
+      rule.selector = rule.selector.replace(
+        new RegExp(`\\s*>\\s*\\*:${position}-child`, 'g'),
+        `:${position}-child > *`,
+      );
+    } else {
+      rule.selector = rule.selector.replace(
+        new RegExp(`:${position}-child\\s*>\\s*\\*`, 'g'),
+        ` > *:${position}-child`,
+      );
+    }
+  });
+}
+
+function restoreLegacySpacingClassNames(root) {
+  root.walkRules((rule) => {
+    let restoredLegacyClass = false;
+
+    rule.selector = rule.selector.replace(
+      /\.((?:\\.|[^\s.#>+~,[\]()=:])+)/g,
+      (selector, escapedClassName) => {
+        const utility = baseUtility(unescapeClassName(escapedClassName));
+        const aliasEntry = legacySpacingAliases.find(([, alias]) => (
+          utility.endsWith(`-${alias}`)
+          && legacySpacingUtilityPattern.test(utility)
+        ));
+
+        if (!aliasEntry) return selector;
+
+        const [legacyName, alias] = aliasEntry;
+        const aliasStart = escapedClassName.lastIndexOf(`-${alias}`);
+
+        restoredLegacyClass = true;
+
+        return `.${escapedClassName.slice(0, aliasStart)}-${escapeClassName(legacyName)}${escapedClassName.slice(aliasStart + alias.length + 1)}`;
+      },
+    );
+
+    if (restoredLegacyClass) {
+      restoreLegacyAxisDeclarations(rule);
+    }
+  });
+}
+
+function restoreLegacyAxisDeclarations(rule) {
+  const physicalAxis = classNames(rule.selector)
+    .map(baseUtility)
+    .map((utility) => utility.match(/^-?(px|py|mx|my)-.*[+*]/)?.[1])
+    .find(Boolean);
+  const declarationMap = {
+    px: ['padding-inline', 'padding-left', 'padding-right'],
+    py: ['padding-block', 'padding-top', 'padding-bottom'],
+    mx: ['margin-inline', 'margin-left', 'margin-right'],
+    my: ['margin-block', 'margin-top', 'margin-bottom'],
+  };
+
+  if (!physicalAxis) return;
+
+  const [logicalProperty, firstProperty, secondProperty] = declarationMap[physicalAxis];
+
+  rule.walkDecls(logicalProperty, (declaration) => {
+    declaration.cloneBefore({ prop: firstProperty });
+    declaration.cloneBefore({ prop: secondProperty });
+    declaration.remove();
+  });
+}
+
+function escapeClassName(className) {
+  return className.replace(/([!"#$%&'()*+,./:;<=>?@[\\\]^`{|}~])/g, '\\$1');
+}
+
+function unescapeClassName(className) {
+  return className.replace(/\\(.)/g, '$1');
+}
+
+function restoreImportantDeclarations(root) {
+  root.walkDecls(importantMarker, (marker) => {
+    marker.parent.nodes
+      .filter((node) => node.type === 'decl' && node !== marker)
+      .forEach((declaration) => {
+        declaration.important = true;
+      });
+
+    marker.remove();
+  });
+}
+
+function restoreLegacyCoreUtilities(root) {
+  const restoredContainers = new WeakSet();
+
+  root.walkRules((candidateRule) => {
+    const utility = classNames(candidateRule.selector)
+      .map(baseUtility)
+      .find((className) => legacyCoreUtilities.has(className));
+
+    if (!utility) return;
+    if (!candidateRule.selectors.every((selector) => classNames(selector)
+      .map(baseUtility)
+      .includes(utility))) return;
+
+    const declarations = legacyCoreUtilities.get(utility);
+    const replacedProps = legacyCoreReplacementProps.get(utility);
+
+    [candidateRule, ...descendantContainers(candidateRule)]
+      .filter((container) => directDeclarations(container).length > 0)
+      .forEach((container) => {
+        if (restoredContainers.has(container)) return;
+
+        const important = directDeclarations(container)
+          .some((declaration) => declaration.important);
+
+        directDeclarations(container)
+          .filter((declaration) => replacedProps.has(declaration.prop))
+          .forEach((declaration) => declaration.remove());
+        declarations.slice().reverse().forEach(([prop, value]) => {
+          container.prepend({
+            prop,
+            value,
+            important,
+          });
+        });
+        restoredContainers.add(container);
+      });
+  });
+}
+
+function restoreLegacyTransformUtilities(root) {
+  root.walkRules((rule) => {
+    const utility = classNames(rule.selector)
+      .map(baseUtility)
+      .find((className) => (
+        /^-?rotate-(?![xy]-)/.test(className)
+        || /^-?translate-[xy]-/.test(className)
+        || /^-?skew-[xy]-/.test(className)
+        || /^scale(?:-[xy])?-/.test(className)
+      ));
+
+    if (!utility) return;
+    if (!rule.selectors.every((selector) => classNames(selector)
+      .map(baseUtility)
+      .includes(utility))) return;
+
+    const declarations = directDeclarations(rule);
+    const important = declarations.some((declaration) => declaration.important);
+    const rotate = declarations.find((declaration) => declaration.prop === 'rotate');
+    const translate = declarations.find((declaration) => declaration.prop === 'translate');
+    const scale = declarations.find((declaration) => declaration.prop === 'scale');
+    const transform = declarations.find((declaration) => declaration.prop === 'transform');
+
+    if (rotate) {
+      rotate.cloneBefore({
+        prop: '--tw-rotate',
+        value: rotate.value,
+        important,
+      });
+      rotate.remove();
+    }
+    translate?.remove();
+    scale?.remove();
+    transform?.remove();
+    declarations
+      .filter(({ prop }) => prop === '--tw-scale-z')
+      .forEach((declaration) => declaration.remove());
+    declarations
+      .filter(({ prop }) => prop === '--tw-skew-x' || prop === '--tw-skew-y')
+      .forEach((declaration) => {
+        declaration.value = declaration.value.replace(/^skew[XY]\((.*)\)$/, '$1');
+      });
+    rule.append({
+      prop: 'transform',
+      value: legacyTransformValue,
+      important,
+    });
+  });
+}
+
+function restoreLegacyGroupHover(root) {
+  const restoredByParent = new WeakMap();
+
+  root.walkRules((rule) => {
+    const selectors = rule.selectors.map(restoreLegacyGroupHoverSelector);
+
+    if (selectors.every((selector, index) => selector === rule.selectors[index])) return;
+
+    rule.selectors = [...new Set(selectors)];
+
+    const signature = [
+      rule.selector,
+      ...directDeclarations(rule)
+        .map(({ prop, value, important }) => `${prop}:${value}:${important}`),
+    ].join('\0');
+    const restored = restoredByParent.get(rule.parent) ?? new Set();
+
+    if (restored.has(signature)) {
+      rule.remove();
+      return;
+    }
+
+    restored.add(signature);
+    restoredByParent.set(rule.parent, restored);
+  });
+}
+
+function restoreLegacyGroupHoverSelector(selector) {
+  const candidate = classNames(selector)
+    .map((className) => ({
+      className,
+      variant: classSegments(className)
+        .find((segment) => segment === 'group-hover' || segment.startsWith('group-hover/')),
+    }))
+    .find(({ variant }) => variant);
+
+  if (!candidate) return selector;
+
+  const groupName = `group${candidate.variant.slice('group-hover'.length)}`;
+  const groupSelector = `.${escapeClassName(groupName)}`;
+  const compoundStart = selector.indexOf(`:is(:where(${groupSelector})`);
+
+  if (compoundStart < 0) return selector;
+
+  const compoundEnd = closingParenthesis(selector, compoundStart + 3);
+
+  if (compoundEnd < 0) return selector;
+
+  return [
+    `${groupSelector}:hover `,
+    selector.slice(0, compoundStart),
+    selector.slice(compoundEnd + 1),
+  ].join('');
+}
+
+function closingParenthesis(value, openingIndex) {
+  let depth = 0;
+
+  for (let index = openingIndex;index < value.length;index += 1) {
+    if (value[index] === '(') depth += 1;
+    if (value[index] === ')') depth -= 1;
+    if (depth === 0) return index;
+  }
+
+  return -1;
+}
+
+function classNames(selector) {
+  const names = [];
+  let attributeDepth = 0;
+
+  for (let index = 0;index < selector.length;index += 1) {
+    if (selector[index] === '\\') {
+      index += 1;
+      continue;
+    }
+    if (selector[index] === '[') {
+      attributeDepth += 1;
+      continue;
+    }
+    if (selector[index] === ']') {
+      attributeDepth -= 1;
+      continue;
+    }
+    if (
+      attributeDepth > 0
+      || selector[index] !== '.'
+      || selector[index - 1] === '\\'
+    ) continue;
+
+    let name = '';
+    index += 1;
+
+    while (index < selector.length) {
+      const character = selector[index];
+
+      if (character === '\\' && index + 1 < selector.length) {
+        name += selector[index + 1];
+        index += 2;
+        continue;
+      }
+
+      if (/[\s.#>+~,[\]()=:]/.test(character)) break;
+
+      name += character;
+      index += 1;
+    }
+
+    if (name) names.push(name);
+    index -= 1;
+  }
+
+  return names;
+}
+
+function baseUtility(className) {
+  return className.split(':').at(-1).replace(/^!|!$/g, '');
+}
+
+function descendantContainers(rule) {
+  const containers = [];
+
+  rule.walk((node) => {
+    if (node !== rule && node.nodes) containers.push(node);
+  });
+
+  return containers;
+}
+
+function directDeclarations(container) {
+  return container.nodes?.filter((node) => node.type === 'decl') ?? [];
+}
+
+function restoreArbitraryValueOrder(root) {
+  reorderArbitraryValueSiblings(root);
+
+  root.each((node) => {
+    if (node.nodes) restoreArbitraryValueOrder(node);
+  });
+}
+
+function reorderLegacyStateVariantSiblings(container) {
+  const nodes = container.nodes ?? [];
+  const stateNodes = nodes.flatMap((node, index) => {
+    if (node.type !== 'rule') return [];
+
+    const variants = classNames(node.selector)
+      .map((className) => classSegments(className)
+        .slice(0, -1)
+        .filter((segment) => legacyStateVariantOrder.has(segment))
+        .map((segment) => legacyStateVariantOrder.get(segment))
+        .reverse())
+      .find((order) => order.length > 0);
+
+    if (!variants) return [];
+
+    return [{
+      index,
+      node,
+      order: variants,
+    }];
+  });
+  const stateSet = new Set(stateNodes.map(({ node }) => node));
+  const sorted = [...stateNodes].sort((left, right) => (
+    Math.min(...left.order) - Math.min(...right.order)
+    || compareVariantOrders(left.order, right.order)
+    || left.index - right.index
+  ));
+
+  if (stateNodes.length > 0) {
+    container.nodes = [
+      ...nodes.filter((node) => !stateSet.has(node)),
+      ...sorted.map(({ node }) => node),
+    ];
+    container.nodes.forEach((node) => {
+      node.parent = container;
+    });
+  }
+
+  container.nodes?.forEach((node) => {
+    if (node.nodes) reorderLegacyStateVariantSiblings(node);
+  });
+}
+
+function compareVariantOrders(left, right) {
+  const length = Math.max(left.length, right.length);
+
+  for (let index = 0;index < length;index += 1) {
+    const difference = (left[index] ?? -1) - (right[index] ?? -1);
+
+    if (difference !== 0) return difference;
+  }
+
+  return 0;
+}
+
+function reorderArbitraryValueSiblings(container) {
+  const groups = new Map();
+
+  container.nodes?.forEach((node, index) => {
+    if (node.type !== 'rule') return;
+
+    const candidate = classNames(node.selector)
+      .find((className) => className.includes('[') && className.includes(']'));
+
+    if (!candidate) return;
+
+    const normalizedCandidate = candidate.replace(/\[[^\]]*]/g, '[]');
+    const declarationSignature = [];
+
+    node.walkDecls((declaration) => {
+      declarationSignature.push(declaration.prop);
+    });
+    declarationSignature.sort();
+
+    const key = `${normalizedCandidate}\0${declarationSignature.join('\0')}`;
+    const group = groups.get(key) ?? [];
+
+    group.push({
+      candidate,
+      index,
+      node,
+    });
+    groups.set(key, group);
+  });
+
+  groups.forEach((group) => {
+    if (group.length < 2) return;
+
+    const sorted = [...group].sort((left, right) => {
+      if (left.candidate === right.candidate) return 0;
+
+      return left.candidate < right.candidate ? -1 : 1;
+    });
+
+    group.forEach(({ index }, sortedIndex) => {
+      const node = sorted[sortedIndex].node;
+
+      container.nodes[index] = node;
+      node.parent = container;
+    });
+  });
+}
+
+function reorderResponsiveVariantSiblings(container) {
+  const nodes = container.nodes ?? [];
+  const responsiveNodes = nodes.flatMap((node) => {
+    const variant = responsiveVariantForNode(node);
+
+    if (!variant) return [];
+
+    return [{
+      node,
+      order: responsiveVariantOrder.get(variant),
+    }];
+  });
+  const sorted = [...responsiveNodes].sort((left, right) => left.order - right.order);
+  const responsiveSet = new Set(responsiveNodes.map(({ node }) => node));
+
+  container.nodes = [
+    ...nodes.filter((node) => !responsiveSet.has(node)),
+    ...sorted.map(({ node }) => node),
+  ];
+  container.nodes.forEach((node) => {
+    node.parent = container;
+  });
+}
+
+function responsiveVariantForNode(node) {
+  const selectors = [];
+
+  if (node.type === 'rule') selectors.push(node.selector);
+  node.walkRules?.((rule) => selectors.push(rule.selector));
+
+  return selectors
+    .flatMap(classNames)
+    .flatMap((className) => className.split(':'))
+    .find((segment) => responsiveVariantOrder.has(segment));
+}
+
+tailwindV4Compat.postcss = true;
+
+module.exports = tailwindV4Compat;