postcss-convert-values 9.0.2 → 9.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss-convert-values",
-  "version": "9.0.2",
+  "version": "9.0.4",
   "description": "Convert values with PostCSS (e.g. ms -> s)",
   "exports": {
     ".": {
@@ -40,8 +40,8 @@
     "url": "git+https://github.com/cssnano/cssnano.git"
   },
   "dependencies": {
-    "browserslist": "^4.28.9",
-    "postcss-value-parser": "^4.2.0"
+    "browserslist": "^4.29.1",
+    "cssnano-utils": "^8.0.0"
   },
   "bugs": {
     "url": "https://github.com/cssnano/cssnano/issues"
@@ -57,6 +57,7 @@
   },
   "type": "module",
   "scripts": {
+    "fuzz": "node ./script/fuzz.js",
     "test": "node --test"
   }
 }

package/src/index.js

@@ -1,212 +1,8 @@
-import valueParser from 'postcss-value-parser';
 import getBrowsersList from '#getBrowsersList';
-import convert from './lib/convert.js';
+import transform from './lib/transform.js';
 
 /** @import browserslist from 'browserslist' */
-
-const LENGTH_UNITS = new Set([
-  'em',
-  'ex',
-  'ch',
-  'rem',
-  'vw',
-  'vh',
-  'vmin',
-  'vmax',
-  'cm',
-  'mm',
-  'q',
-  'in',
-  'pt',
-  'pc',
-  'px',
-]);
-
-// These properties only accept percentages, so no point in trying to transform
-const notALength = new Set([
-  'descent-override',
-  'ascent-override',
-  'font-stretch',
-  'size-adjust',
-  'line-gap-override',
-]);
-
-// Can't change the unit on these properties when they're 0
-const keepWhenZero = new Set([
-  'stroke-dashoffset',
-  'stroke-width',
-  'line-height',
-]);
-
-// Can't remove the % on these properties when they're 0 on IE 11
-const keepZeroPercentOnIE11 = new Set(['max-height', 'height', 'min-width']);
-
-const keepZeroPercentAlways = new Set([
-  'calc',
-  'color-mix',
-  'min',
-  'max',
-  'clamp',
-  'hsl',
-  'hsla',
-  'hwb',
-  'linear',
-]);
-
-const keepZeroPercentageInKeyframe = new Set([
-  'border-image-width',
-  'stroke-dasharray',
-]);
-
-/**
- * Numbers without digits after the dot are technically invalid,
- * but in that case css-value-parser returns the dot as part of the unit,
- * so we use this to remove the dot.
- *
- * @param {string} item
- * @return {string}
- */
-function stripLeadingDot(item) {
-  if (item.charCodeAt(0) === '.'.charCodeAt(0)) {
-    return item.slice(1);
-  } else {
-    return item;
-  }
-}
-
-/**
- * @param {valueParser.Node} node
- * @param {Options} opts
- * @param {boolean} keepZeroUnit
- * @return {void}
- */
-function parseWord(node, opts, keepZeroUnit) {
-  const pair = valueParser.unit(node.value);
-  if (pair) {
-    const num = Number(pair.number);
-    const u = stripLeadingDot(pair.unit);
-    if (num === 0) {
-      node.value =
-        0 +
-        (keepZeroUnit || (!LENGTH_UNITS.has(u.toLowerCase()) && u !== '%')
-          ? u
-          : '');
-      if (node.value === '0ms') {
-        node.value = '0s';
-      }
-    } else {
-      node.value = convert(num, u, opts);
-
-      if (
-        typeof opts.precision === 'number' &&
-        u.toLowerCase() === 'px' &&
-        pair.number.includes('.')
-      ) {
-        const precision = Math.pow(10, opts.precision);
-        node.value =
-          Math.round(Number.parseFloat(node.value) * precision) / precision + u;
-      }
-    }
-  }
-}
-
-/**
- * @param {valueParser.WordNode} node
- * @return {void}
- */
-function clampOpacity(node) {
-  const pair = valueParser.unit(node.value);
-  if (!pair) {
-    return;
-  }
-  const num = Number(pair.number);
-  if (num > 1) {
-    node.value = pair.unit === '%' ? num + pair.unit : 1 + pair.unit;
-  } else if (num < 0) {
-    node.value = 0 + pair.unit;
-  }
-}
-
-/**
- * @param {import('postcss').Declaration} decl
- * @param {string[]} browsers
- * @return {boolean}
- */
-function shouldKeepZeroUnit(decl, browsers) {
-  const { parent } = decl;
-  const lowerCasedProp = decl.prop.toLowerCase();
-
-  return (
-    (decl.value.includes('%') &&
-      keepZeroPercentOnIE11.has(lowerCasedProp) &&
-      browsers.includes('ie 11')) ||
-    (keepZeroPercentageInKeyframe.has(lowerCasedProp) &&
-      parent &&
-      parent.parent &&
-      parent.parent.type === 'atrule' &&
-      /** @type {import('postcss').AtRule} */
-      (parent.parent).name.toLowerCase() === 'keyframes') ||
-    (lowerCasedProp === 'initial-value' &&
-      parent &&
-      parent.type === 'atrule' &&
-      parent.name === 'property' &&
-      parent.nodes !== undefined &&
-      parent.nodes.some(
-        (node) =>
-          node.type === 'decl' &&
-          node.prop.toLowerCase() === 'syntax' &&
-          (node.value === "'<percentage>'" ||
-            node.value === '"<percentage>"' ||
-            node.value === "'<length-percentage>'" ||
-            node.value === '"<length-percentage>"')
-      )) ||
-    keepWhenZero.has(lowerCasedProp)
-  );
-}
-/**
- * @param {Options} opts
- * @param {string[]} browsers
- * @param {import('postcss').Declaration} decl
- * @return {void}
- */
-function transform(opts, browsers, decl) {
-  const lowerCasedProp = decl.prop.toLowerCase();
-  if (
-    lowerCasedProp.includes('flex') ||
-    (lowerCasedProp.indexOf('--') === 0 && !opts.transformCustomProperties) ||
-    notALength.has(lowerCasedProp)
-  ) {
-    return;
-  }
-
-  decl.value = valueParser(decl.value)
-    .walk((node) => {
-      const lowerCasedValue = node.value.toLowerCase();
-
-      if (node.type === 'word') {
-        parseWord(node, opts, shouldKeepZeroUnit(decl, browsers));
-        if (
-          lowerCasedProp === 'opacity' ||
-          lowerCasedProp === 'shape-image-threshold'
-        ) {
-          clampOpacity(node);
-        }
-      } else if (node.type === 'function') {
-        if (keepZeroPercentAlways.has(lowerCasedValue)) {
-          valueParser.walk(node.nodes, (n) => {
-            if (n.type === 'word') {
-              parseWord(n, opts, true);
-            }
-          });
-          return false;
-        }
-        if (lowerCasedValue === 'url') {
-          return false;
-        }
-      }
-    })
-    .toString();
-}
+/** @import convert from './lib/convert.js' */
 
 const plugin = 'postcss-convert-values';
 
@@ -217,28 +13,37 @@ const plugin = 'postcss-convert-values';
  * @typedef {{precision?: false | number, transformCustomProperties?: boolean} & ConvertOptions & AutoprefixerOptions & BrowserslistOptions} Options
  */
 
-/**
- * @param {Options} opts
- * @return {import('postcss').Plugin}
- */
+/** @param {Options} opts @return {import('postcss').Plugin} */
 function pluginCreator(opts = { precision: false }) {
+  /** @type {Map<string, boolean>} */
+  const browserCache = new Map();
+
   return {
     postcssPlugin: plugin,
 
-    /**
-     * @param {import('postcss').Result & {opts: BrowserslistOptions & {file?: string}}} result
-     */
+    /** @param {import('postcss').Result & {opts: BrowserslistOptions & {file?: string}}} result */
     prepare(result) {
       const { stats, env, from, file } = result.opts || {};
-      const browsers = getBrowsersList(opts, stats, from, file, env);
-
+      const overrideKey = opts.overrideBrowserslist
+        ? JSON.stringify(opts.overrideBrowserslist)
+        : '';
+      const pathKey = opts.path ?? '';
+      const envKey = opts.env ?? env ?? '';
+      const effectiveStats = opts.stats || stats;
+      const statsKey = effectiveStats ? JSON.stringify(effectiveStats) : '';
+      const cacheKey = `${overrideKey}\0${pathKey}\0${envKey}\0${from ?? ''}\0${file ?? ''}\0${statsKey}`;
+      let supportsIE = browserCache.get(cacheKey);
+      if (supportsIE === undefined) {
+        const browsers = getBrowsersList(opts, stats, from, file, env);
+        supportsIE = browsers.some((b) => b.startsWith('ie '));
+        browserCache.set(cacheKey, supportsIE);
+      }
+      const cache = new Map();
       return {
-        /**
-         * @param {import('postcss').Root} css
-         */
+        /** @param {import('postcss').Root} css */
         OnceExit(css) {
           css.walkDecls((decl) =>
-            transform(/** @type {Options} */ (opts), browsers, decl)
+            transform(/** @type {Options} */ (opts), supportsIE, decl, cache)
           );
         },
       };

package/src/lib/computeBrowsersToSupport.js

@@ -1,8 +1,6 @@
 import { fileURLToPath } from 'node:url';
 import browserslist from 'browserslist';
-import nodepath from 'node:path';
-
-const { dirname } = nodepath;
+import { dirname } from 'node:path';
 
 /**
  *

package/src/lib/convert.js

@@ -1,26 +1,63 @@
-const lengthConv = new Map([
-  ['in', 96],
-  ['px', 1],
-  ['pt', 4 / 3],
-  ['pc', 16],
+export const lengthConv = new Map([
+  ['in', 288],
+  ['px', 3],
+  ['pt', 4],
+  ['pc', 48],
 ]);
 
-const timeConv = new Map([
+export const metricConv = new Map([
+  ['cm', 40],
+  ['mm', 4],
+  ['q', 1],
+]);
+
+export const timeConv = new Map([
   ['s', 1000],
   ['ms', 1],
 ]);
 
-const angleConv = new Map([
-  ['turn', 360],
-  ['deg', 1],
+export const angleConv = new Map([
+  ['deg', 10],
+  ['turn', 3600],
+  ['grad', 9],
+]);
+
+export const freqConv = new Map([
+  ['khz', 1000],
+  ['hz', 1],
 ]);
 
-/** @typedef {{time?: boolean, length?: boolean, angle?: boolean}} ConvertOptions */
+/** @typedef {{time?: boolean, length?: boolean, angle?: boolean, frequency?: boolean}} ConvertOptions */
+
+/**
+ * Accurately round a number to a fixed decimal precision without IEEE-754 binary
+ * floating point multiplication errors.
+ *
+ * @param {number} value
+ * @param {number} precision
+ * @return {number}
+ */
+export function roundToPrecision(value, precision) {
+  if (
+    typeof precision !== 'number' ||
+    precision < 0 ||
+    !Number.isFinite(precision) ||
+    !Number.isFinite(value)
+  ) {
+    return value;
+  }
+  const p = Math.floor(precision);
+  const [mantissa, exponent = 0] = String(value).toLowerCase().split('e');
+  const shifted = Number(mantissa + 'e' + (Number(exponent) + p));
+  const rounded = (Math.sign(shifted) || 0) * Math.round(Math.abs(shifted));
+  return Number(rounded + 'e-' + p);
+}
+
 /**
  * @param {number} number
  * @return {string}
  */
-function dropLeadingZero(number) {
+export function dropLeadingZero(number) {
   const value = String(number);
 
   if (number % 1) {
@@ -35,23 +72,23 @@ function dropLeadingZero(number) {
 
   return value;
 }
+
 /**
  * @param {number} number
  * @param {string} originalUnit
- * @param {typeof lengthConv | typeof timeConv | typeof angleConv} conversions
+ * @param {typeof lengthConv | typeof timeConv | typeof angleConv | typeof freqConv | typeof metricConv} conversions
  * @return {string}
  */
-function transform(number, originalUnit, conversions) {
-  const conversionUnits = [...conversions.keys()].filter((u) => {
-    return originalUnit !== u;
-  });
-
+function findShortestConversion(number, originalUnit, conversions) {
   const base = number * /** @type {number} */ (conversions.get(originalUnit));
 
   let shortest = '';
-  for (const u of conversionUnits) {
-    const value =
-      dropLeadingZero(base / /** @type {number} */ (conversions.get(u))) + u;
+  for (const [u, factor] of conversions) {
+    if (u === originalUnit) {
+      continue;
+    }
+    const convertedNumber = Number((base / factor).toPrecision(15));
+    const value = dropLeadingZero(convertedNumber) + u;
 
     if (!shortest || value.length < shortest.length) {
       shortest = value;
@@ -60,6 +97,22 @@ function transform(number, originalUnit, conversions) {
 
   return shortest;
 }
+
+/**
+ * @param {number} number
+ * @param {string} unit
+ * @return {string | undefined}
+ */
+function convertAngle(number, unit) {
+  if (unit === 'rad') {
+    return number === 0 ? '0deg' : undefined;
+  }
+  if (angleConv.has(unit)) {
+    return findShortestConversion(number, unit, angleConv);
+  }
+  return undefined;
+}
+
 /**
  * @param {number} number
  * @param {string} unit
@@ -67,24 +120,34 @@ function transform(number, originalUnit, conversions) {
  * @return {string}
  */
 const convert = function (number, unit, options) {
-  const { time, length, angle } = options;
-  let value = dropLeadingZero(number) + (unit ? unit : '');
-  let converted;
+  const { time, length, angle, frequency } = options;
   const lowerCaseUnit = unit.toLowerCase();
+  let converted;
   if (length !== false && lengthConv.has(lowerCaseUnit)) {
-    converted = transform(number, lowerCaseUnit, lengthConv);
+    converted = findShortestConversion(number, lowerCaseUnit, lengthConv);
+  } else if (length !== false && metricConv.has(lowerCaseUnit)) {
+    converted = findShortestConversion(number, lowerCaseUnit, metricConv);
+  } else if (time !== false && timeConv.has(lowerCaseUnit)) {
+    converted = findShortestConversion(number, lowerCaseUnit, timeConv);
   }
 
-  if (time !== false && timeConv.has(lowerCaseUnit)) {
-    converted = transform(number, lowerCaseUnit, timeConv);
+  if (!converted && angle !== false) {
+    converted = convertAngle(number, lowerCaseUnit);
+  }
+  if (!converted && frequency !== false && freqConv.has(lowerCaseUnit)) {
+    converted = findShortestConversion(number, lowerCaseUnit, freqConv);
   }
 
-  if (angle !== false && angleConv.has(lowerCaseUnit)) {
-    converted = transform(number, lowerCaseUnit, angleConv);
+  const value = dropLeadingZero(number) + (unit ? unit : '');
+  if (!converted) {
+    return value;
   }
 
-  if (converted && converted.length < value.length) {
-    value = converted;
+  if (
+    converted.length < value.length ||
+    (lowerCaseUnit === 'rad' && converted.length <= value.length)
+  ) {
+    return converted;
   }
 
   return value;

package/src/lib/parse-syntax.js

@@ -0,0 +1,234 @@
+import cssnanoUtils from 'cssnano-utils';
+
+const { TokenType, decoded, tokens } = cssnanoUtils;
+
+const percentageSyntaxTypes = new Set([
+  'percentage',
+  'length-percentage',
+  'angle-percentage',
+  'time-percentage',
+  'frequency-percentage',
+]);
+
+/**
+ * @param {ReturnType<typeof tokens>} tokensList
+ * @param {number} i
+ * @return {number}
+ */
+function skipTrivia(tokensList, i) {
+  let index = i;
+  while (index < tokensList.length) {
+    const type = tokensList[index][0];
+    if (type !== TokenType.Whitespace && type !== TokenType.Comment) {
+      break;
+    }
+    index++;
+  }
+  return index;
+}
+
+/**
+ * @param {ReturnType<typeof tokens>} tokensList
+ * @param {number} startIndex
+ * @param {string} openType
+ * @param {string} closeType
+ * @return {number}
+ */
+function skipMatching(tokensList, startIndex, openType, closeType) {
+  let depth = 1;
+  let index = startIndex + 1;
+  while (index < tokensList.length) {
+    const type = tokensList[index][0];
+    if (type === openType) {
+      depth++;
+    } else if (type === closeType) {
+      depth--;
+      if (depth === 0) return index + 1;
+    }
+    index++;
+  }
+  return -1;
+}
+
+/**
+ * @param {ReturnType<typeof tokens>} innerTokens
+ * @param {number} i
+ * @return {number}
+ */
+function consumeMultipliers(innerTokens, i) {
+  let index = i;
+  while (index < innerTokens.length) {
+    const token = innerTokens[index];
+    const type = token[0];
+    if (
+      type === TokenType.Delim &&
+      (token[1] === '+' ||
+        token[1] === '#' ||
+        token[1] === '?' ||
+        token[1] === '*' ||
+        token[1] === '!')
+    ) {
+      index = skipTrivia(innerTokens, index + 1);
+    } else if (type === TokenType.OpenCurly) {
+      const next = skipMatching(
+        innerTokens,
+        index,
+        TokenType.OpenCurly,
+        TokenType.CloseCurly
+      );
+      if (next === -1) return -1;
+      index = skipTrivia(innerTokens, next);
+    } else {
+      break;
+    }
+  }
+  return index;
+}
+
+/**
+ * @param {ReturnType<typeof tokens>} innerTokens
+ * @param {number} i
+ * @return {{nextIndex: number, hasPercentage: boolean} | undefined}
+ */
+function consumeComponent(innerTokens, i) {
+  const token = innerTokens[i];
+  if (!token) return undefined;
+
+  if (token[0] === TokenType.OpenSquare) {
+    const closeIndex = skipMatching(
+      innerTokens,
+      i,
+      TokenType.OpenSquare,
+      TokenType.CloseSquare
+    );
+    if (closeIndex === -1) return undefined;
+    const subTokens = innerTokens.slice(i + 1, closeIndex - 1);
+    const hasPercentage = scanSyntaxAllowsPercentage(subTokens);
+    let nextIndex = skipTrivia(innerTokens, closeIndex);
+    nextIndex = consumeMultipliers(innerTokens, nextIndex);
+    if (nextIndex === -1) return undefined;
+    return { nextIndex, hasPercentage };
+  }
+
+  if (token[0] === TokenType.Ident) {
+    let nextIndex = skipTrivia(innerTokens, i + 1);
+    nextIndex = consumeMultipliers(innerTokens, nextIndex);
+    if (nextIndex === -1) return undefined;
+    return { nextIndex, hasPercentage: false };
+  }
+
+  if (token[0] !== TokenType.Delim || token[1] !== '<') {
+    return undefined;
+  }
+  const identIndex = skipTrivia(innerTokens, i + 1);
+  const ident = innerTokens[identIndex];
+  if (!ident || ident[0] !== TokenType.Ident) return undefined;
+
+  const hasPercentage = percentageSyntaxTypes.has(decoded(ident).toLowerCase());
+  let afterIdent = skipTrivia(innerTokens, identIndex + 1);
+
+  if (
+    afterIdent < innerTokens.length &&
+    innerTokens[afterIdent][0] === TokenType.OpenSquare
+  ) {
+    afterIdent = skipMatching(
+      innerTokens,
+      afterIdent,
+      TokenType.OpenSquare,
+      TokenType.CloseSquare
+    );
+    if (afterIdent === -1) return undefined;
+    afterIdent = skipTrivia(innerTokens, afterIdent);
+  }
+
+  const close = innerTokens[afterIdent];
+  if (!close || close[0] !== TokenType.Delim || close[1] !== '>') {
+    return undefined;
+  }
+
+  let nextIndex = skipTrivia(innerTokens, afterIdent + 1);
+  nextIndex = consumeMultipliers(innerTokens, nextIndex);
+  if (nextIndex === -1) return undefined;
+  return { nextIndex, hasPercentage };
+}
+
+/**
+ * @param {ReturnType<typeof tokens>} innerTokens
+ * @param {number} i
+ * @return {number} next index, or -1 if invalid combinator
+ */
+function consumeCombinator(innerTokens, i) {
+  const sep = innerTokens[i];
+  if (sep[0] === TokenType.Delim && sep[1] === '|') {
+    let next = skipTrivia(innerTokens, i + 1);
+    if (
+      next < innerTokens.length &&
+      innerTokens[next][0] === TokenType.Delim &&
+      innerTokens[next][1] === '|'
+    ) {
+      next = skipTrivia(innerTokens, next + 1);
+    }
+    return next >= innerTokens.length ? -1 : next;
+  }
+  if (sep[0] === TokenType.Delim && sep[1] === '&') {
+    let next = skipTrivia(innerTokens, i + 1);
+    if (
+      next < innerTokens.length &&
+      innerTokens[next][0] === TokenType.Delim &&
+      innerTokens[next][1] === '&'
+    ) {
+      next = skipTrivia(innerTokens, next + 1);
+      return next >= innerTokens.length ? -1 : next;
+    }
+    return -1;
+  }
+  return i;
+}
+
+/**
+ * Parses an @property syntax string per CSS Properties and Values API Level 1 and CSS Values 4/5.
+ *
+ * @param {ReturnType<typeof tokens>} innerTokens
+ * @return {boolean}
+ */
+function scanSyntaxAllowsPercentage(innerTokens) {
+  let i = skipTrivia(innerTokens, 0);
+  if (i >= innerTokens.length) return true;
+
+  if (
+    innerTokens[i][0] === TokenType.Delim &&
+    innerTokens[i][1] === '*' &&
+    skipTrivia(innerTokens, i + 1) >= innerTokens.length
+  ) {
+    return true;
+  }
+
+  let allowsPercentage = false;
+  while (i < innerTokens.length) {
+    const comp = consumeComponent(innerTokens, i);
+    if (!comp) return true;
+    if (comp.hasPercentage) allowsPercentage = true;
+    i = comp.nextIndex;
+
+    if (i < innerTokens.length) {
+      const nextIndex = consumeCombinator(innerTokens, i);
+      if (nextIndex === -1) return true;
+      i = nextIndex;
+    }
+  }
+  return allowsPercentage;
+}
+
+/** @param {string} value @return {boolean} */
+export function syntaxAllowsPercentage(value) {
+  const outerTokens = tokens(value);
+  let syntaxToken;
+  for (const token of outerTokens) {
+    if (token[0] === TokenType.Whitespace || token[0] === TokenType.Comment)
+      continue;
+    if (syntaxToken || token[0] !== TokenType.String) return true;
+    syntaxToken = token;
+  }
+  if (!syntaxToken) return true;
+  return scanSyntaxAllowsPercentage(tokens(decoded(syntaxToken)));
+}

package/src/lib/transform.js

@@ -0,0 +1,529 @@
+import cssnanoUtils from 'cssnano-utils';
+import convert, {
+  dropLeadingZero,
+  roundToPrecision,
+  timeConv,
+  angleConv,
+  freqConv,
+} from './convert.js';
+import { syntaxAllowsPercentage } from './parse-syntax.js';
+
+const {
+  TokenType,
+  applyEdits,
+  calcSumFunctions,
+  closeForOpening,
+  decoded,
+  lengthUnits,
+  mathFunctions,
+  numericSource,
+  tokens,
+} = cssnanoUtils;
+
+const flexBasisProperties = new Set([
+  'flex',
+  'flex-basis',
+  'flex-basic',
+  'flex-preferred-size',
+]);
+const alphaProperties = new Set([
+  'opacity',
+  'shape-image-threshold',
+  'fill-opacity',
+  'stroke-opacity',
+  'stop-opacity',
+  'flood-opacity',
+]);
+const zeroPercentRetention = new Set([
+  'descent-override',
+  'ascent-override',
+  'font-stretch',
+  'font-width',
+  'size-adjust',
+  'line-gap-override',
+  'text-size-adjust',
+  'subscript-position-override',
+  'superscript-position-override',
+  'subscript-size-override',
+  'superscript-size-override',
+  'stroke-dasharray',
+  'stroke-dashoffset',
+  'stroke-width',
+]);
+const zeroUnitRetention = {
+  ie11Percent: new Set(['max-height', 'height', 'min-width']),
+  keyframePercent: new Set([
+    'border-image-width',
+    'stroke-dasharray',
+    'stroke-dashoffset',
+    'stroke-width',
+  ]),
+};
+/* Functions in which a zero cannot lose its unit. Every math function qualifies
+ * because `calc(0%)` and `calc(0)` differ in type; the rest are listed per
+ * grammar, e.g. conic-gradient stops take an <angle-percentage>, which no
+ * unitless zero represents, while linear-gradient stops take a
+ * <length-percentage>, which it does. */
+const functionsPreservingZeroUnits = new Set([
+  ...mathFunctions,
+  ...calcSumFunctions,
+  'anchor',
+  'anchor-size',
+  'contrast-color',
+  'view',
+  'color-mix',
+  'hsl',
+  'hsla',
+  'hwb',
+  'linear',
+  'conic-gradient',
+  'repeating-conic-gradient',
+  'cross-fade',
+  'rgb',
+  'rgba',
+  'oklch',
+  'oklab',
+  'lab',
+  'lch',
+  'color',
+  'palette-mix',
+]);
+
+const convertibleUnits = new Set([
+  ...timeConv.keys(),
+  ...angleConv.keys(),
+  ...freqConv.keys(),
+  'rad',
+]);
+
+/** @typedef {Parameters<typeof convert>[2]} ConvertOptions */
+/** @typedef {{precision?: false | number, transformCustomProperties?: boolean} & ConvertOptions & { overrideBrowserslist?: string | string[] } & import('browserslist').Options} Options */
+
+/** @param {number} number @param {string} unit @param {string} raw @param {Options} opts @param {boolean} keepZeroPercent @param {boolean} keepZeroLength @param {boolean} hasDecimal @return {string} */
+function parseNumber(
+  number,
+  unit,
+  raw,
+  opts,
+  keepZeroPercent,
+  keepZeroLength,
+  hasDecimal
+) {
+  if (raw.includes('\\')) return raw;
+  const lowerCasedUnit = unit.toLowerCase();
+  if (
+    unit !== '' &&
+    unit !== '%' &&
+    !lengthUnits.has(lowerCasedUnit) &&
+    !convertibleUnits.has(lowerCasedUnit)
+  )
+    return raw;
+  let num = number;
+  if (
+    typeof opts.precision === 'number' &&
+    opts.precision >= 0 &&
+    (hasDecimal || !Number.isInteger(num))
+  ) {
+    num = roundToPrecision(num, opts.precision);
+  }
+  if (num === 0) {
+    if (convertibleUnits.has(lowerCasedUnit)) {
+      return convert(0, unit, opts);
+    }
+    if (unit === '%') {
+      return keepZeroPercent ? '0%' : '0';
+    }
+    if (lengthUnits.has(lowerCasedUnit)) {
+      return keepZeroLength ? '0' + unit : '0';
+    }
+    return '0';
+  }
+  return convert(num, unit, opts);
+}
+
+/** @param {string} value @param {number} number @param {string} unit @param {Options} opts @param {boolean} [clamp] @return {string} */
+function clampOpacity(value, number, unit, opts, clamp = true) {
+  if (unit === '%') {
+    if (clamp) {
+      if (number >= 100) return '1';
+      if (number <= 0) return '0';
+    }
+    let decimalNumber = Number((number / 100).toPrecision(15));
+    if (typeof opts.precision === 'number' && opts.precision >= 0) {
+      decimalNumber = roundToPrecision(decimalNumber, opts.precision);
+    }
+    const decimal = dropLeadingZero(decimalNumber);
+    return decimal.length < value.length ? decimal : value;
+  }
+  if (clamp) {
+    if (number > 1) return '1';
+    if (number < 0) return '0';
+  }
+  return value;
+}
+
+/** @param {string} str @return {string} */
+function stripVendorPrefix(str) {
+  if (str.charCodeAt(0) !== 45 /* '-' */) return str;
+  if (str.startsWith('-webkit-')) return str.slice(8);
+  if (str.startsWith('-moz-')) return str.slice(5);
+  if (str.startsWith('-ms-')) return str.slice(4);
+  if (str.startsWith('-o-')) return str.slice(3);
+  return str;
+}
+
+/** @type {WeakMap<import('postcss').AtRule, boolean>} */
+const atPropertySyntaxCache = new WeakMap();
+
+/** @param {import('postcss').AtRule} parent @return {boolean} */
+function atPropertyAllowsPercentage(parent) {
+  const cached = atPropertySyntaxCache.get(parent);
+  if (cached !== undefined) return cached;
+
+  const syntaxDecl = /** @type {import('postcss').Declaration | undefined} */ (
+    parent.nodes?.find(
+      (node) => node.type === 'decl' && node.prop.toLowerCase() === 'syntax'
+    )
+  );
+  const result = syntaxDecl ? syntaxAllowsPercentage(syntaxDecl.value) : true;
+  atPropertySyntaxCache.set(parent, result);
+  return result;
+}
+
+/** @param {import('postcss').Declaration} decl @return {boolean} */
+function isInsideKeyframes(decl) {
+  let current = decl.parent;
+  while (current && current.type !== 'root') {
+    if (
+      current.type === 'atrule' &&
+      /** @type {import('postcss').AtRule} */ (current).name
+        .toLowerCase()
+        .endsWith('keyframes')
+    ) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+
+/** @param {string} property @param {Options} opts @return {boolean} */
+function skipsTransformation(property, opts) {
+  return property.startsWith('--') && !opts.transformCustomProperties;
+}
+
+/**
+ * @param {import('postcss').Declaration} decl
+ * @param {string} lowerCasedProp
+ * @param {string} strippedProp
+ * @param {boolean | string[]} supportsIE
+ * @return {{keepZeroPercent: boolean, keepZeroLength: boolean, hasParentContext: boolean, clampAlpha: boolean}}
+ */
+function getDeclarationFlags(decl, lowerCasedProp, strippedProp, supportsIE) {
+  const isLineHeight = strippedProp === 'line-height';
+  const isFlexBasis = flexBasisProperties.has(strippedProp);
+  const isAtProperty =
+    lowerCasedProp === 'initial-value' &&
+    decl.parent?.type === 'atrule' &&
+    /** @type {import('postcss').AtRule} */ (decl.parent).name.toLowerCase() ===
+      'property';
+  const isAlphaProp = alphaProperties.has(strippedProp);
+  const isKeyframeProp = zeroUnitRetention.keyframePercent.has(strippedProp);
+  const inKeyframes =
+    (isKeyframeProp || isAlphaProp) && isInsideKeyframes(decl);
+  const hasParentContext = lowerCasedProp === 'initial-value' || inKeyframes;
+
+  const hasIESupport =
+    typeof supportsIE === 'boolean'
+      ? supportsIE
+      : supportsIE.some((b) => b.startsWith('ie '));
+
+  const keepZeroPercent =
+    isLineHeight ||
+    isFlexBasis ||
+    zeroPercentRetention.has(strippedProp) ||
+    (hasIESupport && zeroUnitRetention.ie11Percent.has(strippedProp)) ||
+    (inKeyframes && isKeyframeProp) ||
+    (isAtProperty &&
+      atPropertyAllowsPercentage(
+        /** @type {import('postcss').AtRule} */ (decl.parent)
+      ));
+
+  const keepZeroLength =
+    isLineHeight ||
+    isFlexBasis ||
+    strippedProp === 'columns' ||
+    strippedProp === 'flex-order' ||
+    isAtProperty;
+
+  const clampAlpha = !inKeyframes;
+
+  return { keepZeroPercent, keepZeroLength, hasParentContext, clampAlpha };
+}
+
+/**
+ * @param {string} replacement
+ * @param {string} raw
+ * @param {boolean} isAlpha
+ * @param {boolean} isConvertibleZero
+ * @return {boolean}
+ */
+function shouldReplace(replacement, raw, isAlpha, isConvertibleZero) {
+  if (replacement === raw) return false;
+  if (replacement.length < raw.length) return true;
+  return (isAlpha || isConvertibleZero) && replacement.length <= raw.length;
+}
+
+class FrameStack {
+  /** @type {string[]} */
+  #closeStack = [];
+  #keepZeroPercent;
+  #keepZeroLength;
+  #keepZeroUnitsDepth = -1;
+  #skippedDepth = -1;
+
+  /**
+   * @param {boolean} keepZeroPercent
+   * @param {boolean} keepZeroLength
+   */
+  constructor(keepZeroPercent, keepZeroLength) {
+    this.#keepZeroPercent = keepZeroPercent;
+    this.#keepZeroLength = keepZeroLength;
+  }
+
+  get isTopLevel() {
+    return this.#closeStack.length === 0;
+  }
+
+  get isSkipped() {
+    return this.#skippedDepth !== -1;
+  }
+
+  get keepZeroPercent() {
+    return this.#keepZeroPercent || this.#keepZeroUnitsDepth !== -1;
+  }
+
+  get keepZeroLength() {
+    return this.#keepZeroLength || this.#keepZeroUnitsDepth !== -1;
+  }
+
+  /**
+   * @param {ReturnType<typeof tokens>[number]} token
+   * @return {boolean}
+   */
+  advance(token) {
+    const type = token[0];
+    if (type === TokenType.Function) {
+      const name = stripVendorPrefix(decoded(token).toLowerCase());
+      const keepInFunction = functionsPreservingZeroUnits.has(name);
+      const depth = this.#closeStack.length + 1;
+      this.#closeStack.push(TokenType.CloseParen);
+      if (keepInFunction && this.#keepZeroUnitsDepth === -1) {
+        this.#keepZeroUnitsDepth = depth;
+      }
+      if (name === 'url' && this.#skippedDepth === -1) {
+        this.#skippedDepth = depth;
+      }
+      return true;
+    }
+    if (
+      type === TokenType.OpenParen ||
+      type === TokenType.OpenSquare ||
+      type === TokenType.OpenCurly
+    ) {
+      const close = closeForOpening(type);
+      if (close !== undefined) this.#closeStack.push(close);
+      return true;
+    }
+    if (
+      type === TokenType.CloseParen ||
+      type === TokenType.CloseSquare ||
+      type === TokenType.CloseCurly
+    ) {
+      if (
+        this.#closeStack.length > 0 &&
+        this.#closeStack[this.#closeStack.length - 1] === type
+      ) {
+        const depth = this.#closeStack.length;
+        if (depth === this.#keepZeroUnitsDepth) this.#keepZeroUnitsDepth = -1;
+        if (depth === this.#skippedDepth) this.#skippedDepth = -1;
+        this.#closeStack.pop();
+      }
+      return true;
+    }
+    return false;
+  }
+}
+
+/** @typedef {{index: number, start: number, end: number, raw: string, number: number, unit: string, hasDecimal: boolean}} NumericSource */
+
+/**
+ * @param {NumericSource} source
+ * @param {boolean} isLineHeight
+ * @param {string} strippedProp
+ * @param {FrameStack} frames
+ * @param {Options} opts
+ * @param {boolean} clampAlpha
+ * @return {{start: number, end: number, text: string} | undefined}
+ */
+function processNumericToken(
+  source,
+  isLineHeight,
+  strippedProp,
+  frames,
+  opts,
+  clampAlpha
+) {
+  const currentKeepZeroPercent = frames.keepZeroPercent || isLineHeight;
+  const currentKeepZeroLength = frames.keepZeroLength || isLineHeight;
+
+  const converted = parseNumber(
+    source.number,
+    source.unit,
+    source.raw,
+    opts,
+    currentKeepZeroPercent,
+    currentKeepZeroLength,
+    source.hasDecimal
+  );
+  const isAlpha = alphaProperties.has(strippedProp) && frames.isTopLevel;
+  const replacement = isAlpha
+    ? clampOpacity(converted, source.number, source.unit, opts, clampAlpha)
+    : converted;
+  const isConvertibleZero =
+    source.number === 0 && convertibleUnits.has(source.unit.toLowerCase());
+
+  if (shouldReplace(replacement, source.raw, isAlpha, isConvertibleZero)) {
+    return {
+      start: source.start,
+      end: source.end,
+      text: replacement,
+    };
+  }
+  return undefined;
+}
+
+/**
+ * @param {string} value
+ * @param {string} strippedProp
+ * @param {{keepZeroPercent: boolean, keepZeroLength: boolean, clampAlpha: boolean}} flags
+ * @param {Options} opts
+ * @return {{start: number, end: number, text: string}[]}
+ */
+function findReplacements(value, strippedProp, flags, opts) {
+  /** @type {{start: number, end: number, text: string}[]} */
+  const replacements = [];
+  const frames = new FrameStack(flags.keepZeroPercent, flags.keepZeroLength);
+  const isFont = strippedProp === 'font';
+  let afterFontSlash = false;
+
+  const input = tokens(value);
+  for (let index = 0; index < input.length; index++) {
+    const token = input[index];
+    if (frames.advance(token)) {
+      if (frames.isTopLevel && afterFontSlash) afterFontSlash = false;
+      continue;
+    }
+    if (frames.isSkipped) continue;
+
+    const type = token[0];
+    if (frames.isTopLevel) {
+      if (type === TokenType.Whitespace || type === TokenType.Comment) {
+        continue;
+      }
+      if (isFont && type === TokenType.Delim && token[1] === '/') {
+        afterFontSlash = true;
+        continue;
+      }
+    }
+
+    const wasAfterFontSlash = frames.isTopLevel && afterFontSlash;
+    if (afterFontSlash) afterFontSlash = false;
+
+    if (
+      type !== TokenType.Number &&
+      type !== TokenType.Dimension &&
+      type !== TokenType.Percentage
+    ) {
+      continue;
+    }
+
+    const source = numericSource(input, index);
+    if (!source) continue;
+    index = source.index;
+
+    const edit = processNumericToken(
+      source,
+      wasAfterFontSlash,
+      strippedProp,
+      frames,
+      opts,
+      flags.clampAlpha
+    );
+    if (edit) replacements.push(edit);
+  }
+  return replacements;
+}
+
+/** @param {import('postcss').Declaration} decl @param {string} newValue @return {void} */
+function updateDeclValue(decl, newValue) {
+  decl.value = newValue;
+  if (decl.raws?.value?.raw) {
+    decl.raws.value = { raw: newValue, value: newValue };
+  } else if (decl.raws?.value) {
+    delete decl.raws.value;
+  }
+}
+
+/** @param {import('postcss').Declaration} decl @return {string} */
+function getRawOrDeclarationValue(decl) {
+  const raw = decl.raws?.value;
+  return raw?.raw && raw.value === decl.value ? raw.raw : decl.value;
+}
+
+/**
+ * @param {import('postcss').Declaration} decl
+ * @param {string} newValue
+ * @param {string} originalValue
+ * @return {void}
+ */
+function syncDeclValue(decl, newValue, originalValue) {
+  const isStale = Boolean(
+    decl.raws?.value && decl.raws.value.value !== decl.value
+  );
+  if (newValue !== originalValue || isStale) {
+    updateDeclValue(decl, newValue);
+  }
+}
+
+/** @param {Options} opts @param {boolean | string[]} supportsIE @param {import('postcss').Declaration} decl @param {Map<string, string>} [cache] @return {void} */
+export default function transform(opts, supportsIE, decl, cache) {
+  const lowerCasedProp = decl.prop.toLowerCase();
+  if (skipsTransformation(lowerCasedProp, opts)) return;
+  const value = getRawOrDeclarationValue(decl);
+  if (!/[0-9]/v.test(value)) return;
+
+  const strippedProp = stripVendorPrefix(lowerCasedProp);
+  const flags = getDeclarationFlags(
+    decl,
+    lowerCasedProp,
+    strippedProp,
+    supportsIE
+  );
+
+  const cacheKey = flags.hasParentContext
+    ? undefined
+    : `${lowerCasedProp}:${value}`;
+  if (cacheKey !== undefined && cache?.has(cacheKey)) {
+    const cached = /** @type {string} */ (cache.get(cacheKey));
+    syncDeclValue(decl, cached, value);
+    return;
+  }
+
+  const replacements = findReplacements(value, strippedProp, flags, opts);
+  const result = replacements.length ? applyEdits(value, replacements) : value;
+  if (cacheKey !== undefined) {
+    cache?.set(cacheKey, result);
+  }
+  syncDeclValue(decl, result, value);
+}

package/types/index.d.ts

@@ -1,5 +1,5 @@
-import convert from './lib/convert.js';
 import type browserslist from 'browserslist';
+import type convert from './lib/convert.js';
 export type ConvertOptions = Parameters<typeof convert>[2];
 export type AutoprefixerOptions = {
     overrideBrowserslist?: string | string[];
@@ -15,10 +15,7 @@ export type Options = {
  * @typedef {Pick<browserslist.Options, 'stats' | 'path' | 'env'>} BrowserslistOptions
  * @typedef {{precision?: false | number, transformCustomProperties?: boolean} & ConvertOptions & AutoprefixerOptions & BrowserslistOptions} Options
  */
-/**
- * @param {Options} opts
- * @return {import('postcss').Plugin}
- */
+/** @param {Options} opts @return {import('postcss').Plugin} */
 declare function pluginCreator(opts?: Options): import('postcss').Plugin;
 declare namespace pluginCreator {
     var postcss: true;

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAEA,OAAO,OAAO,MAAM,kBAAkB,CAAC;AAEnC,OAAQ,KAAA,YAAY,MAAM,cAAc,CAAA;AAiNzC,YAAyC,cAAc,GAA7C,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,CAAgB;AACvD,YAAwD,mBAAmB,GAAjE;IAAE,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE,CAAqB;AAC3E,YAAgE,mBAAmB,GAAzE,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC,CAAqB;AACnF,YAA0I,OAAO,GAAvI;IAAC,SAAS,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAAC,yBAAyB,CAAC,EAAE,OAAO,CAAA;CAAC,GAAG,cAAc,GAAG,mBAAmB,GAAG,mBAAmB,CAAS;AAJpJ;;;;;GAKG;AAEH;;;GAGG;AACH,iBAAS,aAAa,CAAC,IAAI,GAHhB,OAGuC,GAFtC,OAAO,SAAS,EAAE,MAAM,CAyBnC;kBAvBQ,aAAa;iBAwBX,IAAI;;AAEf,QAAA,MAAM,aAAa,sBAAgB,CAAC;AAEpC,OAAO,EAAE,aAAa,IAAI,OAAO,EAAE,aAAa,IAAI,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAGI,OAAQ,KAAA,YAAY,MAAM,cAAc,CAAA;AACxC,OAAQ,KAAA,OAAO,MAAM,kBAAkB,CAAA;AAKxC,YAAyC,cAAc,GAA7C,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,CAAgB;AACvD,YAAwD,mBAAmB,GAAjE;IAAE,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE,CAAqB;AAC3E,YAAgE,mBAAmB,GAAzE,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC,CAAqB;AACnF,YAA0I,OAAO,GAAvI;IAAC,SAAS,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAAC,yBAAyB,CAAC,EAAE,OAAO,CAAA;CAAC,GAAG,cAAc,GAAG,mBAAmB,GAAG,mBAAmB,CAAS;AAJpJ;;;;;GAKG;AAEH,+DAA+D;AAC/D,iBAAS,aAAa,CAAC,IAAI,GADf,OACsC,GADf,OAAO,SAAS,EAAE,MAAM,CAoC1D;kBAnCQ,aAAa;iBAoCX,IAAI;;AAEf,QAAA,MAAM,aAAa,sBAAgB,CAAC;AAEpC,OAAO,EAAE,aAAa,IAAI,OAAO,EAAE,aAAa,IAAI,gBAAgB,EAAE,CAAC"}

package/types/lib/computeBrowsersToSupport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeBrowsersToSupport.d.ts","sourceRoot":"","sources":["../../src/lib/computeBrowsersToSupport.js"],"names":[],"mappings":"AACA,OAAO,YAAY,MAAM,cAAc,CAAC;AAKxC;;;;;;;;GAQG;AACH,iBAAS,wBAAwB,CAAC,OAAO,EAP9B;IAAC,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;IAAC,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAAC,GAAG,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;CAOtI,EAAE,KAAK,EANrC,YAAY,CAAC,OAAO,CAAC,OAAO,CAMS,EAAE,IAAI,EAL3C,MAAM,GAAC,SAKoC,EAAE,IAAI,AAJzD,CACA,EADQ,MAIiD,EAAE,GAAG,AAH9D,CACA,EADQ,YAAY,CAAC,OAAO,CAAC,KAAK,CAG4B,GAFpD,MAAM,EAAE,CASpB;eAEc,wBAAwB"}
+{"version":3,"file":"computeBrowsersToSupport.d.ts","sourceRoot":"","sources":["../../src/lib/computeBrowsersToSupport.js"],"names":[],"mappings":"AACA,OAAO,YAAY,MAAM,cAAc,CAAC;AAGxC;;;;;;;;GAQG;AACH,iBAAS,wBAAwB,CAAC,OAAO,EAP9B;IAAC,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;IAAC,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAAC,GAAG,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;CAOtI,EAAE,KAAK,EANrC,YAAY,CAAC,OAAO,CAAC,OAAO,CAMS,EAAE,IAAI,EAL3C,MAAM,GAAC,SAKoC,EAAE,IAAI,AAJzD,CACA,EADQ,MAIiD,EAAE,GAAG,AAH9D,CACA,EADQ,YAAY,CAAC,OAAO,CAAC,KAAK,CAG4B,GAFpD,MAAM,EAAE,CASpB;eAEc,wBAAwB"}

package/types/lib/convert.d.ts

@@ -1,8 +1,29 @@
+export declare const lengthConv: Map<string, number>;
+export declare const metricConv: Map<string, number>;
+export declare const timeConv: Map<string, number>;
+export declare const angleConv: Map<string, number>;
+export declare const freqConv: Map<string, number>;
 export type ConvertOptions = {
     time?: boolean;
     length?: boolean;
     angle?: boolean;
+    frequency?: boolean;
 };
+/** @typedef {{time?: boolean, length?: boolean, angle?: boolean, frequency?: boolean}} ConvertOptions */
+/**
+ * Accurately round a number to a fixed decimal precision without IEEE-754 binary
+ * floating point multiplication errors.
+ *
+ * @param {number} value
+ * @param {number} precision
+ * @return {number}
+ */
+export declare function roundToPrecision(value: number, precision: number): number;
+/**
+ * @param {number} number
+ * @return {string}
+ */
+export declare function dropLeadingZero(number: number): string;
 /**
  * @param {number} number
  * @param {string} unit

package/types/lib/convert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../src/lib/convert.js"],"names":[],"mappings":"AAiBI,YAA+D,cAAc,GAAnE;IAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAC,CAAgB;AA6CjF;;;;;GAKG;AACH,QAAA,MAAM,OAAO,WALF,MAAM,QACN,MAAM,WACN,cAAc,KACb,MAwBX,CAAC;eAEa,OAAO"}
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../src/lib/convert.js"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,qBAKrB,CAAC;AAEH,eAAO,MAAM,UAAU,qBAIrB,CAAC;AAEH,eAAO,MAAM,QAAQ,qBAGnB,CAAC;AAEH,eAAO,MAAM,SAAS,qBAIpB,CAAC;AAEH,eAAO,MAAM,QAAQ,qBAGnB,CAAC;AAEC,YAAoF,cAAc,GAAxF;IAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAAC,CAAgB;AAAtG,yGAAyG;AAEzG;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAJ3B,MAI2B,EAAE,SAAS,EAHtC,MAGsC,GAFrC,MAAM,CAgBjB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAH3B,MAG2B,GAF1B,MAAM,CAgBjB;AA0CD;;;;;GAKG;AACH,QAAA,MAAM,OAAO,WALF,MAAM,QACN,MAAM,WACN,cAAc,KACb,MAkCX,CAAC;eAEa,OAAO"}

package/types/lib/parse-syntax.d.ts

@@ -0,0 +1,3 @@
+/** @param {string} value @return {boolean} */
+export declare function syntaxAllowsPercentage(value: string): boolean;
+//# sourceMappingURL=parse-syntax.d.ts.map

package/types/lib/parse-syntax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-syntax.d.ts","sourceRoot":"","sources":["../../src/lib/parse-syntax.js"],"names":[],"mappings":"AA6NA,8CAA8C;AAC9C,wBAAgB,sBAAsB,CAAC,KAAK,EADhC,MACgC,GADT,OAAO,CAYzC"}

package/types/lib/transform.d.ts

@@ -0,0 +1,20 @@
+import convert from './convert.js';
+export type ConvertOptions = Parameters<typeof convert>[2];
+export type Options = {
+    precision?: false | number;
+    transformCustomProperties?: boolean;
+} & ConvertOptions & {
+    overrideBrowserslist?: string | string[];
+} & import('browserslist').Options;
+export type NumericSource = {
+    index: number;
+    start: number;
+    end: number;
+    raw: string;
+    number: number;
+    unit: string;
+    hasDecimal: boolean;
+};
+/** @param {Options} opts @param {boolean | string[]} supportsIE @param {import('postcss').Declaration} decl @param {Map<string, string>} [cache] @return {void} */
+export default function transform(opts: Options, supportsIE: boolean | string[], decl: import('postcss').Declaration, cache?: Map<string, string>): void;
+//# sourceMappingURL=transform.d.ts.map

package/types/lib/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../src/lib/transform.js"],"names":[],"mappings":"AACA,OAAO,OAMN,MAAM,cAAc,CAAC;AA2FlB,YAAyC,cAAc,GAA7C,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,CAAgB;AACvD,YAA8K,OAAO,GAA3K;IAAC,SAAS,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAAC,yBAAyB,CAAC,EAAE,OAAO,CAAA;CAAC,GAAG,cAAc,GAAG;IAAE,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE,GAAG,OAAO,cAAc,EAAE,OAAO,CAAS;AAkQrL,YAAuH,aAAa,GAA1H;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAC,CAAe;AA6IxI,mKAAmK;AACnK,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,IAAI,EAD1B,OAC0B,EAAE,UAAU,EADhB,OAAO,GAAG,MAAM,EACA,EAAE,IAAI,EADiB,OAAO,SAAS,EAAE,WACnC,EAAE,KAAK,AAD8C,CAAqC,EAA7B,GAAG,CAAC,MAAM,EAAE,MAAM,CACxE,GAD4F,IAAI,CA8B9J"}