postcss-minify-params 9.0.3 → 9.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss-minify-params",
-  "version": "9.0.3",
+  "version": "9.0.5",
   "description": "Minify at-rule params with PostCSS",
   "exports": {
     ".": {
@@ -41,9 +41,8 @@
   },
   "homepage": "https://github.com/cssnano/cssnano",
   "dependencies": {
-    "browserslist": "^4.29.0",
-    "cssnano-utils": "^7.0.3",
-    "postcss-value-parser": "^4.2.0"
+    "browserslist": "^4.29.2",
+    "cssnano-utils": "^8.0.1"
   },
   "engines": {
     "node": "^22.22.3 || ^24.15.0 || >=26.0"

package/src/index.js

@@ -1,138 +1,9 @@
 import getBrowsersList from '#getBrowsersList';
-import valueParser from 'postcss-value-parser';
-import cssnanoUtils from 'cssnano-utils';
+import transform from './lib/transform.js';
 
-const { getArguments } = cssnanoUtils;
 /** @import browserslist from 'browserslist' */
 
-/**
- * Return the greatest common divisor
- * of two numbers.
- *
- * @param {number} a
- * @param {number} b
- * @return {number}
- */
-function gcd(a, b) {
-  return b ? gcd(b, a % b) : a;
-}
-
-/**
- * @param {number} a
- * @param {number} b
- * @return {[number, number]}
- */
-function aspectRatio(a, b) {
-  const divisor = gcd(a, b);
-
-  return [a / divisor, b / divisor];
-}
-
-/**
- * @param {valueParser.Node[]} args
- * @return {string}
- */
-function split(args) {
-  return args.map((arg) => valueParser.stringify(arg)).join('');
-}
-
-/**
- * @param {valueParser.Node} node
- * @return {void}
- */
-function removeNode(node) {
-  node.value = '';
-  node.type = 'word';
-}
-
-/**
- * @param {unknown[]} items
- * @return {string}
- */
-function sortAndDedupe(items) {
-  const a = [...new Set(items)];
-  a.sort();
-  return a.join();
-}
-
-/**
- * @param {boolean} legacy
- * @param {import('postcss').AtRule} rule
- * @return {void}
- */
-function transform(legacy, rule) {
-  const ruleName = rule.name.toLowerCase();
-
-  // We should re-arrange parameters only for `@media` and `@supports` at-rules
-  if (!rule.params || !['media', 'supports'].includes(ruleName)) {
-    return;
-  }
-
-  const params = valueParser(rule.params);
-
-  params.walk((node, index) => {
-    if (node.type === 'div') {
-      node.before = node.after = '';
-    } else if (node.type === 'function') {
-      node.before = '';
-      if (
-        node.nodes[0] &&
-        node.nodes[0].type === 'word' &&
-        node.nodes[0].value.startsWith('--') &&
-        node.nodes[2] === undefined
-      ) {
-        node.after = ' ';
-      } else {
-        node.after = '';
-      }
-      if (
-        node.nodes[4] &&
-        node.nodes[0].value.toLowerCase().indexOf('-aspect-ratio') === 3
-      ) {
-        const [a, b] = aspectRatio(
-          Number(node.nodes[2].value),
-          Number(node.nodes[4].value)
-        );
-
-        node.nodes[2].value = a.toString();
-        node.nodes[4].value = b.toString();
-      }
-    } else if (node.type === 'space') {
-      node.value = ' ';
-    } else {
-      const prevWord = params.nodes[index - 2];
-
-      if (
-        node.value.toLowerCase() === 'all' &&
-        rule.name.toLowerCase() === 'media' &&
-        !prevWord
-      ) {
-        const nextWord = params.nodes[index + 2];
-
-        if (!legacy || nextWord) {
-          removeNode(node);
-        }
-
-        if (nextWord && nextWord.value.toLowerCase() === 'and') {
-          const nextSpace = params.nodes[index + 1];
-          const secondSpace = params.nodes[index + 3];
-
-          removeNode(nextWord);
-          removeNode(nextSpace);
-          removeNode(secondSpace);
-        }
-      }
-    }
-  }, true);
-
-  rule.params = sortAndDedupe(getArguments(params).map(split));
-
-  if (!rule.params.length) {
-    rule.raws.afterName = '';
-  }
-}
-
-const allBugBrowers = new Set(['ie 10', 'ie 11']);
+const allBugBrowsers = new Set(['ie 10', 'ie 11']);
 
 /**
  * @typedef {{ overrideBrowserslist?: string | string[] }} AutoprefixerOptions
@@ -155,13 +26,10 @@ function pluginCreator(options = {}) {
     prepare(result) {
       const { stats, env, from, file } = result.opts || {};
       const browsers = getBrowsersList(options, stats, from, file, env);
-
-      const hasAllBug = !new Set(browsers).isDisjointFrom(allBugBrowers);
+      const hasAllBug = !new Set(browsers).isDisjointFrom(allBugBrowsers);
 
       return {
-        /**
-         * @param {import('postcss').Root} css
-         */
+        /** @param {import('postcss').Root} css */
         OnceExit(css) {
           css.walkAtRules((rule) => transform(hasAllBug, rule));
         },

package/src/lib/media.js

@@ -0,0 +1,86 @@
+import {
+  decoded,
+  significantIndex,
+  TokenType,
+  tokenEnd,
+} from './tokenUtils.js';
+
+/** @import cssnanoUtils from 'cssnano-utils' */
+/** @typedef {Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>['tokens']} Tokens */
+
+/** @param {Tokens} input @param {{startIndex:number,endIndex:number}} segment @return {{endIndex:number,first:number,last:number}} */
+function mediaSegmentInfo(input, { startIndex, endIndex }) {
+  const first = significantIndex(input, startIndex, 1);
+  let last = endIndex - 1;
+  while (
+    last >= first &&
+    (input[last][0] === TokenType.Whitespace ||
+      input[last][0] === TokenType.Comment)
+  ) {
+    last--;
+  }
+  return { endIndex, first, last };
+}
+
+/** @param {Tokens} input @param {{first:number,last:number}} segment @return {boolean} */
+function isStandaloneAll(input, { first, last }) {
+  return (
+    first === last &&
+    input[first]?.[0] === TokenType.Ident &&
+    decoded(input[first]).toLowerCase() === 'all'
+  );
+}
+
+/** @param {boolean} legacy @param {Tokens} input @param {{endIndex:number,first:number}} segment @param {{start:number,end:number,text:string}[]} changes @return {void} */
+function minifyMediaAllSegment(legacy, input, { endIndex, first }, changes) {
+  if (
+    input[first]?.[0] !== TokenType.Ident ||
+    decoded(input[first]).toLowerCase() !== 'all'
+  )
+    return;
+  const second = significantIndex(input, first + 1, 1);
+  const and =
+    second < endIndex &&
+    input[second]?.[0] === TokenType.Ident &&
+    decoded(input[second]).toLowerCase() === 'and';
+  if (legacy && !and) return;
+  const end = and ? second : first;
+  for (let i = first; i <= end; i++) {
+    if (
+      input[i][0] === TokenType.Ident ||
+      input[i][0] === TokenType.Whitespace
+    ) {
+      changes.push({
+        start: input[i][2],
+        end: tokenEnd(input[i]),
+        text: '',
+      });
+    }
+  }
+  const trailing = end + 1;
+  if (trailing < endIndex && input[trailing]?.[0] === TokenType.Whitespace) {
+    changes.push({
+      start: input[trailing][2],
+      end: tokenEnd(input[trailing]),
+      text: '',
+    });
+  }
+}
+
+/** @param {boolean} legacy @param {Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>} structure @param {{start:number,end:number,text:string}[]} changes @return {boolean} */
+export default function minifyMediaAll(legacy, structure, changes) {
+  const { tokens: input } = structure;
+  const ranges = structure
+    .topLevelSegments()
+    .map((segment) => mediaSegmentInfo(input, segment));
+
+  if (!legacy && ranges.some((segment) => isStandaloneAll(input, segment))) {
+    const last = input.at(-1);
+    if (last) changes.push({ start: 0, end: tokenEnd(last), text: '' });
+    return true;
+  }
+
+  for (const segment of ranges)
+    minifyMediaAllSegment(legacy, input, segment, changes);
+  return false;
+}

package/src/lib/tokenUtils.js

@@ -0,0 +1,180 @@
+import cssnanoUtils from 'cssnano-utils';
+
+const { TokenType } = cssnanoUtils;
+const decoded = /** @type {typeof cssnanoUtils.decoded} */ (
+  cssnanoUtils.decoded
+);
+const tokenEnd = /** @type {typeof cssnanoUtils.tokenEnd} */ (
+  cssnanoUtils.tokenEnd
+);
+
+/** @typedef {Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>['tokens']} Tokens */
+
+export { TokenType, decoded, tokenEnd };
+
+/**
+ * Reports whether a value ends in a backslash that begins an escape
+ * sequence, as opposed to a backslash that is itself escaped.
+ * @param {string} value
+ * @return {boolean}
+ */
+export function endsWithEscapingBackslash(value) {
+  if (!value.endsWith('\\')) return false;
+
+  let backslashes = 0;
+  for (let i = value.length - 1; i >= 0 && value[i] === '\\'; i--) {
+    backslashes++;
+  }
+  return backslashes % 2 === 1;
+}
+
+export const openingTypes = new Set([
+  TokenType.Function,
+  TokenType.OpenParen,
+  TokenType.OpenSquare,
+  TokenType.OpenCurly,
+]);
+export const closingTypes = new Set([
+  TokenType.CloseParen,
+  TokenType.CloseSquare,
+  TokenType.CloseCurly,
+]);
+export const calcProductEndTypes = new Set([
+  TokenType.Number,
+  TokenType.Percentage,
+  TokenType.Dimension,
+  TokenType.Ident,
+  TokenType.CloseParen,
+]);
+export const calcProductStartTypes = new Set([
+  TokenType.Number,
+  TokenType.Percentage,
+  TokenType.Dimension,
+  TokenType.Ident,
+  TokenType.Function,
+  TokenType.OpenParen,
+]);
+export const mathFunctions = cssnanoUtils.mathFunctions;
+export const whitespaceInsensitiveFunctions = new Set(['selector']);
+export const aspectRatioFeatures = new Set([
+  'aspect-ratio',
+  'min-aspect-ratio',
+  'max-aspect-ratio',
+  'device-aspect-ratio',
+  'min-device-aspect-ratio',
+  'max-device-aspect-ratio',
+]);
+
+/**
+ * Convert a CSS number spelling to an exact rational number.
+ *
+ * @param {string} source
+ * @return {[bigint, bigint] | undefined}
+ */
+function rational(source) {
+  const match = source.match(
+    /^[+]?((?:\d+(?:\.\d*)?)|(?:\.\d+))(?:[eE]([+\-]?\d+))?$/v
+  );
+  if (!match) return undefined;
+  const [, coefficient, exponent = '0'] = match;
+  const [whole, fraction = ''] = coefficient.split('.');
+  const digits = `${whole}${fraction}`;
+  let numerator = BigInt(digits);
+  let denominator = 10n ** BigInt(fraction.length);
+  if (numerator === 0n) return [0n, 1n];
+  const power = BigInt(exponent);
+  if (power > 10000n || power < -10000n) return undefined;
+  if (power >= 0n) numerator *= 10n ** power;
+  else denominator *= 10n ** -power;
+  return [numerator, denominator];
+}
+
+/** @param {bigint} a @param {bigint} b @return {bigint} */
+function gcd(a, b) {
+  return b ? gcd(b, a % b) : a;
+}
+
+/**
+ * @param {string} left
+ * @param {string} right
+ * @return {[string, string] | undefined}
+ */
+export function aspectRatio(left, right) {
+  const a = rational(left);
+  const b = rational(right);
+  if (!a || !b) return undefined;
+  const numerator = a[0] * b[1];
+  const denominator = b[0] * a[1];
+  if (numerator === 0n && denominator === 0n) return undefined;
+  const divisor = gcd(numerator, denominator);
+  const result = [String(numerator / divisor), String(denominator / divisor)];
+  return result.join('/').length < left.length + right.length + 1
+    ? /** @type {[string, string]} */ (result)
+    : undefined;
+}
+
+/** @param {Tokens} input @param {number} index @param {number} step @return {number} */
+export function significantIndex(input, index, step) {
+  let cursor = index;
+  while (
+    input[cursor] &&
+    (input[cursor][0] === TokenType.Whitespace ||
+      input[cursor][0] === TokenType.Comment)
+  ) {
+    cursor += step;
+  }
+  return cursor;
+}
+
+/**
+ * @param {string} source
+ * @param {{start:number,end:number}[]} segments
+ * @param {{start:number,end:number,text:string}[]} edits
+ * @return {string[]}
+ */
+export function serializeSegments(source, segments, edits) {
+  let segmentIndex = 0;
+  let previousEnd = -1;
+  let previousEdit;
+  for (const edit of edits) {
+    if (
+      previousEdit &&
+      edit.start === previousEdit.start &&
+      edit.end === previousEdit.end &&
+      edit.text === previousEdit.text
+    ) {
+      continue;
+    }
+    while (
+      segmentIndex < segments.length &&
+      edit.start >= segments[segmentIndex].end
+    ) {
+      segmentIndex++;
+    }
+    const segment = segments[segmentIndex];
+    if (
+      !segment ||
+      edit.start < segment.start ||
+      edit.start < previousEnd ||
+      edit.end < edit.start ||
+      edit.end > segment.end
+    ) {
+      return segments.map(({ start, end }) => source.slice(start, end));
+    }
+    previousEnd = edit.end;
+    previousEdit = edit;
+  }
+  let editIndex = 0;
+  return segments.map(({ start, end }) => {
+    let cursor = start;
+    let result = '';
+    while (editIndex < edits.length && edits[editIndex].start < end) {
+      const edit = edits[editIndex++];
+      if (edit.start < start || edit.start < cursor) continue;
+      result += source.slice(cursor, edit.start) + edit.text;
+      cursor = edit.end;
+    }
+    result += source.slice(cursor, end);
+    return result;
+  });
+}

package/src/lib/transform.js

@@ -0,0 +1,102 @@
+import cssnanoUtils from 'cssnano-utils';
+import minifyMediaAll from './media.js';
+import {
+  minifyAspectRatios,
+  minifyWhitespace,
+  parentIndexes,
+} from './whitespace.js';
+import {
+  endsWithEscapingBackslash,
+  serializeSegments,
+  tokenEnd,
+  TokenType,
+} from './tokenUtils.js';
+
+const { balancedTokens, tokens: tokenizeValue } = cssnanoUtils;
+
+/**
+ * @param {boolean} legacy
+ * @param {import('postcss').AtRule} rule
+ * @return {void}
+ */
+export default function transform(legacy, rule) {
+  const ruleName = rule.name.toLowerCase();
+
+  // We should re-arrange parameters only for `@media` and `@supports` at-rules
+  if (!rule.params || !['media', 'supports'].includes(ruleName)) return;
+
+  const source =
+    rule.raws.params?.value === rule.params
+      ? (rule.raws.params.raw ?? rule.params)
+      : rule.params;
+  const structure = balancedTokens(source);
+  if (!structure) {
+    if (rule.raws.params?.raw) {
+      rule.raws.params = { raw: rule.params, value: rule.params };
+    }
+    return;
+  }
+  /** @type {{start:number,end:number,text:string}[]} */
+  const changes = [];
+  const parents = parentIndexes(structure);
+  const mediaIsUnconditional =
+    ruleName === 'media' && minifyMediaAll(legacy, structure, changes);
+  if (mediaIsUnconditional) {
+    rule.params = '';
+    if (rule.raws.params?.raw) rule.raws.params = { raw: '', value: '' };
+    updateAfterName(rule);
+    return;
+  }
+  minifyWhitespace(structure, parents, changes);
+  minifyAspectRatios(ruleName === 'supports', structure, parents, changes);
+  const { tokens: input } = structure;
+  const segmentRanges = structure
+    .topLevelSegments()
+    .map(({ startIndex, endIndex }) => {
+      const start = input[startIndex]?.[2] ?? source.length;
+      const end = endIndex > startIndex ? tokenEnd(input[endIndex - 1]) : start;
+      return { start, end };
+    });
+  changes.sort((a, b) => a.start - b.start);
+  const segments = serializeSegments(source, segmentRanges, changes);
+  rule.params = [...new Set(segments)].toSorted().join();
+  if (rule.raws.params?.raw) {
+    rule.raws.params = { raw: rule.params, value: rule.params };
+  }
+
+  updateAfterName(rule);
+}
+
+/**
+ * Strip whitespace after @media or @supports when parameters begin with (.
+ *
+ * @param {import('postcss').AtRule} rule
+ * @return {void}
+ */
+function updateAfterName(rule) {
+  if (!rule.params.length) {
+    rule.raws.afterName = '';
+  } else if (
+    rule.params.startsWith('(') &&
+    !endsWithEscapingBackslash(rule.name)
+  ) {
+    rule.raws.afterName = stripWhitespacePreservingComments(
+      rule.raws.afterName
+    );
+  }
+}
+
+/**
+ * @param {string | undefined} raw
+ * @return {string}
+ */
+function stripWhitespacePreservingComments(raw) {
+  if (!raw?.includes('/*')) return '';
+  let result = '';
+  for (const [type, tokenRaw] of tokenizeValue(raw)) {
+    if (type !== TokenType.Whitespace) {
+      result += tokenRaw;
+    }
+  }
+  return result;
+}

package/src/lib/whitespace.js

@@ -0,0 +1,229 @@
+import cssnanoUtils from 'cssnano-utils';
+import {
+  aspectRatio,
+  aspectRatioFeatures,
+  calcProductEndTypes,
+  calcProductStartTypes,
+  closingTypes,
+  decoded,
+  mathFunctions,
+  openingTypes,
+  significantIndex,
+  TokenType,
+  tokenEnd,
+  whitespaceInsensitiveFunctions,
+} from './tokenUtils.js';
+
+const { numeric } = cssnanoUtils;
+/** @typedef {Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>['tokens']} Tokens */
+
+/** @param {ReturnType<typeof cssnanoUtils.balancedTokens>} structure @return {(number|undefined)[]} */
+export function parentIndexes(structure) {
+  if (!structure) return [];
+  const parents = [];
+  const stack = [];
+  for (let i = 0; i < structure.tokens.length; i++) {
+    const type = structure.tokens[i][0];
+    parents[i] = stack.at(-1);
+    if (openingTypes.has(type)) stack.push(i);
+    else if (closingTypes.has(type)) stack.pop();
+  }
+  return parents;
+}
+
+/** @param {Tokens} input @param {number} index @return {boolean} */
+function isTightWhitespace(input, index) {
+  const previous = input[index - 1];
+  const next = input[index + 1];
+  return [
+    previous?.[0] === TokenType.Function,
+    previous?.[0] === TokenType.OpenParen,
+    next?.[0] === TokenType.CloseParen,
+    previous?.[0] === TokenType.Comma,
+    next?.[0] === TokenType.Comma,
+    previous?.[0] === TokenType.Colon,
+    next?.[0] === TokenType.Colon,
+    previous?.[0] === TokenType.Delim,
+    next?.[0] === TokenType.Delim,
+  ].some(Boolean);
+}
+
+/** @param {unknown} token @return {boolean} */
+function isAdditiveOperator(token) {
+  return (
+    Array.isArray(token) &&
+    token[0] === TokenType.Delim &&
+    (token[1] === '+' || token[1] === '-')
+  );
+}
+
+/** @param {Tokens} input @param {number} index @param {(number|undefined)[]} parents @return {boolean} */
+function isRequiredMathOperatorWhitespace(input, index, parents) {
+  const previous = significantIndex(input, index - 1, -1);
+  const next = significantIndex(input, index + 1, 1);
+  const before = input[previous];
+  const after = input[next];
+  let operator;
+  if (isAdditiveOperator(before)) operator = previous;
+  else if (isAdditiveOperator(after)) operator = next;
+  if (operator === undefined) return false;
+
+  let parent = parents[index];
+  while (parent !== undefined) {
+    const token = input[parent];
+    if (token?.[0] === TokenType.Function) {
+      const name = String(decoded(token)).toLowerCase();
+      if (whitespaceInsensitiveFunctions.has(name)) return false;
+      if (!mathFunctions.has(name)) return true;
+      break;
+    }
+    parent = parents[parent];
+  }
+
+  const left = input[significantIndex(input, operator - 1, -1)];
+  const right = input[significantIndex(input, operator + 1, 1)];
+  return (
+    calcProductEndTypes.has(left?.[0]) && calcProductStartTypes.has(right?.[0])
+  );
+}
+
+/** @param {Tokens} input @param {number} name @param {number} colon @param {number} left @param {number} slash @param {number} right @param {number} after @param {number} close @return {boolean} */
+function isAspectRatioFeature(
+  input,
+  name,
+  colon,
+  left,
+  slash,
+  right,
+  after,
+  close
+) {
+  if (name >= close || input[name]?.[0] !== TokenType.Ident) return false;
+  const a = input[left] ? numeric(input[left]) : false;
+  const b = input[right] ? numeric(input[right]) : false;
+  const lowerName = String(decoded(input[name])).toLowerCase();
+  return (
+    aspectRatioFeatures.has(lowerName) &&
+    input[colon]?.[0] === TokenType.Colon &&
+    input[slash]?.[0] === TokenType.Delim &&
+    input[slash][1] === '/' &&
+    input[left]?.[0] === TokenType.Number &&
+    input[right]?.[0] === TokenType.Number &&
+    a &&
+    b &&
+    !a.unit &&
+    !b.unit &&
+    after === close
+  );
+}
+
+/** @param {Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>} structure @param {number} index @param {(number|undefined)[]} parents @return {{start:number,end:number,text:string}} */
+function whitespaceEdit(structure, index, parents) {
+  const input = structure.tokens;
+  const token = input[index];
+  const next = input[index + 1];
+  const tight = isTightWhitespace(input, index);
+  const open = parents[index];
+  const first = open === undefined ? -1 : significantIndex(input, open + 1, 1);
+  const colon = significantIndex(input, first + 1, 1);
+  const close = open === undefined ? -1 : (structure.endForOpening(open) ?? -1);
+  const emptyCustomProperty =
+    next?.[0] === TokenType.CloseParen &&
+    first >= 0 &&
+    input[first][0] === TokenType.Ident &&
+    decoded(input[first]).startsWith('--') &&
+    input[colon]?.[0] === TokenType.Colon &&
+    significantIndex(input, colon + 1, 1) === close;
+  return {
+    start: token[2],
+    end: tokenEnd(token),
+    text:
+      tight &&
+      !emptyCustomProperty &&
+      !isRequiredMathOperatorWhitespace(input, index, parents)
+        ? ''
+        : ' ',
+  };
+}
+
+/** @param {Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>} structure @param {(number|undefined)[]} parents @param {{start:number,end:number,text:string}[]} changes @return {void} */
+export function minifyWhitespace(structure, parents, changes) {
+  const { tokens: input } = structure;
+  const existingRanges = new Set(
+    changes.map((change) => `${change.start}:${change.end}`)
+  );
+  for (let i = 0; i < input.length; i++) {
+    if (input[i][0] === TokenType.Whitespace) {
+      const edit = whitespaceEdit(structure, i, parents);
+      const range = `${edit.start}:${edit.end}`;
+      if (!existingRanges.has(range)) {
+        changes.push(edit);
+        existingRanges.add(range);
+      }
+    }
+  }
+}
+
+/** @param {Tokens} input @param {(number|undefined)[]} parents @param {number} index @return {boolean} */
+function isGroupingParent(input, parents, index) {
+  let parent = parents[index];
+  while (parent !== undefined) {
+    if (input[parent][0] !== TokenType.OpenParen) return false;
+    parent = parents[parent];
+  }
+  return true;
+}
+
+/** @param {boolean} supports @param {Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>} structure @param {(number|undefined)[]} parents @param {{start:number,end:number,text:string}[]} changes @return {void} */
+export function minifyAspectRatios(supports, structure, parents, changes) {
+  const { tokens: input } = structure;
+  for (let open = 0; open < input.length; open++) {
+    if (
+      input[open][0] !== TokenType.OpenParen ||
+      (supports
+        ? !isGroupingParent(input, parents, open)
+        : parents[open] !== undefined)
+    )
+      continue;
+    const close = structure.endForOpening(open);
+    if (close === undefined) continue;
+    const name = significantIndex(input, open + 1, 1);
+    const colon = significantIndex(input, name + 1, 1);
+    const left = significantIndex(input, colon + 1, 1);
+    const slash = significantIndex(input, left + 1, 1);
+    const right = significantIndex(input, slash + 1, 1);
+    const after = significantIndex(input, right + 1, 1);
+    if (
+      !isAspectRatioFeature(
+        input,
+        name,
+        colon,
+        left,
+        slash,
+        right,
+        after,
+        close
+      )
+    )
+      continue;
+    const a = numeric(input[left]);
+    const b = numeric(input[right]);
+    if (
+      !a ||
+      !b ||
+      !Number.isFinite(a.number) ||
+      a.number < 0 ||
+      !Number.isFinite(b.number) ||
+      b.number < 0 ||
+      (a.number === 0 && b.number === 0)
+    )
+      continue;
+    const ratio = aspectRatio(input[left][1], input[right][1]);
+    if (!ratio) continue;
+    const [x, y] = ratio;
+    changes.push(
+      { start: input[left][2], end: tokenEnd(input[left]), text: String(x) },
+      { start: input[right][2], end: tokenEnd(input[right]), text: String(y) }
+    );
+  }
+}

package/types/index.d.ts

@@ -24,9 +24,7 @@ declare function pluginCreator(options?: {}): {
             file?: string;
         };
     }): {
-        /**
-         * @param {import('postcss').Root} css
-         */
+        /** @param {import('postcss').Root} css */
         OnceExit(css: import('postcss').Root): void;
     };
 };

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAKI,OAAQ,KAAA,YAAY,MAAM,cAAc,CAAA;AAoIzC,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,YAAqD,OAAO,GAAlD,mBAAmB,GAAG,mBAAmB,CAAS;AAH/D;;;;GAIG;AAEH;;;;GAIG;AACH,iBAAS,aAAa,CAAC,OAAO,KAAK;IAE/B,aAAa;IAEb;;OAEG;IACH,OAAO,SAFI,OAAO,SAAS,EAAE,MAAM,GAAG;QAAC,IAAI,EAAE,mBAAmB,GAAG;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC;QAS/E;;WAEG;QACH,QAAQ,MAFG,OAAO,SAAS,EAAE,IAAI;;EAQxC;AAGD,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;AAKzC,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,YAAqD,OAAO,GAAlD,mBAAmB,GAAG,mBAAmB,CAAS;AAH/D;;;;GAIG;AAEH;;;;GAIG;AACH,iBAAS,aAAa,CAAC,OAAO,KAAK;IAE/B,aAAa;IAEb;;OAEG;IACH,OAAO,SAFI,OAAO,SAAS,EAAE,MAAM,GAAG;QAAC,IAAI,EAAE,mBAAmB,GAAG;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC;QAQ/E,0CAA0C;QAC1C,QAAQ,MADI,OAAO,SAAS,EAAE,IAAI;;EAOzC;AAGD,QAAA,MAAM,aAAa,sBAAgB,CAAC;AAEpC,OAAO,EAAE,aAAa,IAAI,OAAO,EAAE,aAAa,IAAI,gBAAgB,EAAE,CAAC"}

package/types/lib/media.d.ts

@@ -0,0 +1,9 @@
+import type cssnanoUtils from 'cssnano-utils';
+export type Tokens = Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>['tokens'];
+/** @param {boolean} legacy @param {Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>} structure @param {{start:number,end:number,text:string}[]} changes @return {boolean} */
+export default function minifyMediaAll(legacy: boolean, structure: Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>, changes: {
+    start: number;
+    end: number;
+    text: string;
+}[]): boolean;
+//# sourceMappingURL=media.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../../src/lib/media.js"],"names":[],"mappings":"AAOI,OAAQ,KAAA,YAAY,MAAM,eAAe,CAAA;AACzC,YAAwF,MAAM,GAApF,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,cAAc,CAAC,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAQ;AA6DlG,+LAA+L;AAC/L,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,MAAM,EADjC,OACiC,EAAE,SAAS,EADpB,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,cAAc,CAAC,EAAE,SAAS,CAC7C,EAAE,OAAO,EADyD;IAAC,KAAK,EAAC,MAAM,CAAC;IAAA,GAAG,EAAC,MAAM,CAAC;IAAA,IAAI,EAAC,MAAM,CAAA;CAAC,EAC9F,GADmH,OAAO,CAgB1L"}

package/types/lib/token-utils.d.ts

@@ -0,0 +1,44 @@
+import cssnanoUtils from 'cssnano-utils';
+declare const TokenType: typeof import("@csstools/css-tokenizer").TokenType;
+declare const decoded: typeof cssnanoUtils.decoded;
+declare const tokenEnd: typeof cssnanoUtils.tokenEnd;
+export type Tokens = Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>['tokens'];
+/** @typedef {Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>['tokens']} Tokens */
+export { TokenType, decoded, tokenEnd };
+/**
+ * Reports whether a value ends in a backslash that begins an escape
+ * sequence, as opposed to a backslash that is itself escaped.
+ * @param {string} value
+ * @return {boolean}
+ */
+export declare function endsWithEscapingBackslash(value: string): boolean;
+export declare const openingTypes: Set<import("@csstools/css-tokenizer").TokenType>;
+export declare const closingTypes: Set<import("@csstools/css-tokenizer").TokenType>;
+export declare const calcProductEndTypes: Set<import("@csstools/css-tokenizer").TokenType>;
+export declare const calcProductStartTypes: Set<import("@csstools/css-tokenizer").TokenType>;
+export declare const mathFunctions: Set<string>;
+export declare const whitespaceInsensitiveFunctions: Set<string>;
+export declare const aspectRatioFeatures: Set<string>;
+/**
+ * @param {string} left
+ * @param {string} right
+ * @return {[string, string] | undefined}
+ */
+export declare function aspectRatio(left: string, right: string): [string, string] | undefined;
+/** @param {Tokens} input @param {number} index @param {number} step @return {number} */
+export declare function significantIndex(input: Tokens, index: number, step: number): number;
+/**
+ * @param {string} source
+ * @param {{start:number,end:number}[]} segments
+ * @param {{start:number,end:number,text:string}[]} edits
+ * @return {string[]}
+ */
+export declare function serializeSegments(source: string, segments: {
+    start: number;
+    end: number;
+}[], edits: {
+    start: number;
+    end: number;
+    text: string;
+}[]): string[];
+//# sourceMappingURL=token-utils.d.ts.map

package/types/lib/token-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-utils.d.ts","sourceRoot":"","sources":["../../src/lib/token-utils.js"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,eAAe,CAAC;AAEzC,QAAA,MAAQ,SAAS,oDAAiB,CAAC;AACnC,QAAA,MAAM,OAAO,EAAc,OAAO,YAAY,CAAC,OAE9C,CAAC;AACF,QAAA,MAAM,QAAQ,EAAc,OAAO,YAAY,CAAC,QAE/C,CAAC;AAEE,YAAwF,MAAM,GAApF,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,cAAc,CAAC,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAQ;AAAlG,qGAAqG;AAErG,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;AAExC;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAHpC,MAGoC,GAFnC,OAAO,CAUlB;AAED,eAAO,MAAM,YAAY,kDAKvB,CAAC;AACH,eAAO,MAAM,YAAY,kDAIvB,CAAC;AACH,eAAO,MAAM,mBAAmB,kDAM9B,CAAC;AACH,eAAO,MAAM,qBAAqB,kDAOhC,CAAC;AACH,eAAO,MAAM,aAAa,aAA6B,CAAC;AACxD,eAAO,MAAM,8BAA8B,aAAwB,CAAC;AACpE,eAAO,MAAM,mBAAmB,aAO9B,CAAC;AA+BH;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAJrB,MAIqB,EAAE,KAAK,EAH5B,MAG4B,GAF3B,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAcvC;AAED,wFAAwF;AACxF,wBAAgB,gBAAgB,CAAC,KAAK,EAD1B,MAC0B,EAAE,KAAK,EADX,MACW,EAAE,IAAI,EADK,MACL,GAD2B,MAAM,CAWnF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAL7B,MAK6B,EAAE,QAAQ,EAJvC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAA,GAAG,EAAC,MAAM,CAAA;CAAC,EAIc,EAAE,KAAK,EAH9C;IAAC,KAAK,EAAC,MAAM,CAAC;IAAA,GAAG,EAAC,MAAM,CAAC;IAAA,IAAI,EAAC,MAAM,CAAA;CAAC,EAGS,GAF7C,MAAM,EAAE,CA+CnB"}

package/types/lib/tokenUtils.d.ts

@@ -0,0 +1,44 @@
+import cssnanoUtils from 'cssnano-utils';
+declare const TokenType: typeof import("@csstools/css-tokenizer").TokenType;
+declare const decoded: typeof cssnanoUtils.decoded;
+declare const tokenEnd: typeof cssnanoUtils.tokenEnd;
+export type Tokens = Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>['tokens'];
+/** @typedef {Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>['tokens']} Tokens */
+export { TokenType, decoded, tokenEnd };
+/**
+ * Reports whether a value ends in a backslash that begins an escape
+ * sequence, as opposed to a backslash that is itself escaped.
+ * @param {string} value
+ * @return {boolean}
+ */
+export declare function endsWithEscapingBackslash(value: string): boolean;
+export declare const openingTypes: Set<import("@csstools/css-tokenizer").TokenType>;
+export declare const closingTypes: Set<import("@csstools/css-tokenizer").TokenType>;
+export declare const calcProductEndTypes: Set<import("@csstools/css-tokenizer").TokenType>;
+export declare const calcProductStartTypes: Set<import("@csstools/css-tokenizer").TokenType>;
+export declare const mathFunctions: Set<string>;
+export declare const whitespaceInsensitiveFunctions: Set<string>;
+export declare const aspectRatioFeatures: Set<string>;
+/**
+ * @param {string} left
+ * @param {string} right
+ * @return {[string, string] | undefined}
+ */
+export declare function aspectRatio(left: string, right: string): [string, string] | undefined;
+/** @param {Tokens} input @param {number} index @param {number} step @return {number} */
+export declare function significantIndex(input: Tokens, index: number, step: number): number;
+/**
+ * @param {string} source
+ * @param {{start:number,end:number}[]} segments
+ * @param {{start:number,end:number,text:string}[]} edits
+ * @return {string[]}
+ */
+export declare function serializeSegments(source: string, segments: {
+    start: number;
+    end: number;
+}[], edits: {
+    start: number;
+    end: number;
+    text: string;
+}[]): string[];
+//# sourceMappingURL=tokenUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tokenUtils.d.ts","sourceRoot":"","sources":["../../src/lib/tokenUtils.js"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,eAAe,CAAC;AAEzC,QAAA,MAAQ,SAAS,oDAAiB,CAAC;AACnC,QAAA,MAAM,OAAO,EAAc,OAAO,YAAY,CAAC,OAE9C,CAAC;AACF,QAAA,MAAM,QAAQ,EAAc,OAAO,YAAY,CAAC,QAE/C,CAAC;AAEE,YAAwF,MAAM,GAApF,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,cAAc,CAAC,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAQ;AAAlG,qGAAqG;AAErG,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;AAExC;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAHpC,MAGoC,GAFnC,OAAO,CAUlB;AAED,eAAO,MAAM,YAAY,kDAKvB,CAAC;AACH,eAAO,MAAM,YAAY,kDAIvB,CAAC;AACH,eAAO,MAAM,mBAAmB,kDAM9B,CAAC;AACH,eAAO,MAAM,qBAAqB,kDAOhC,CAAC;AACH,eAAO,MAAM,aAAa,aAA6B,CAAC;AACxD,eAAO,MAAM,8BAA8B,aAAwB,CAAC;AACpE,eAAO,MAAM,mBAAmB,aAO9B,CAAC;AA+BH;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAJrB,MAIqB,EAAE,KAAK,EAH5B,MAG4B,GAF3B,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAcvC;AAED,wFAAwF;AACxF,wBAAgB,gBAAgB,CAAC,KAAK,EAD1B,MAC0B,EAAE,KAAK,EADX,MACW,EAAE,IAAI,EADK,MACL,GAD2B,MAAM,CAWnF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAL7B,MAK6B,EAAE,QAAQ,EAJvC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAA,GAAG,EAAC,MAAM,CAAA;CAAC,EAIc,EAAE,KAAK,EAH9C;IAAC,KAAK,EAAC,MAAM,CAAC;IAAA,GAAG,EAAC,MAAM,CAAC;IAAA,IAAI,EAAC,MAAM,CAAA;CAAC,EAGS,GAF7C,MAAM,EAAE,CA+CnB"}

package/types/lib/transform.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param {boolean} legacy
+ * @param {import('postcss').AtRule} rule
+ * @return {void}
+ */
+export default function transform(legacy: boolean, rule: import('postcss').AtRule): 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":"AAgBA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,MAAM,EAJ7B,OAI6B,EAAE,IAAI,EAHnC,OAAO,SAAS,EAAE,MAGiB,GAFlC,IAAI,CAgDf"}

package/types/lib/whitespace.d.ts

@@ -0,0 +1,18 @@
+import cssnanoUtils from 'cssnano-utils';
+export type Tokens = Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>['tokens'];
+/** @typedef {Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>['tokens']} Tokens */
+/** @param {ReturnType<typeof cssnanoUtils.balancedTokens>} structure @return {(number|undefined)[]} */
+export declare function parentIndexes(structure: ReturnType<typeof cssnanoUtils.balancedTokens>): (number | undefined)[];
+/** @param {Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>} structure @param {(number|undefined)[]} parents @param {{start:number,end:number,text:string}[]} changes @return {void} */
+export declare function minifyWhitespace(structure: Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>, parents: (number | undefined)[], changes: {
+    start: number;
+    end: number;
+    text: string;
+}[]): void;
+/** @param {boolean} supports @param {Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>} structure @param {(number|undefined)[]} parents @param {{start:number,end:number,text:string}[]} changes @return {void} */
+export declare function minifyAspectRatios(supports: boolean, structure: Exclude<ReturnType<typeof cssnanoUtils.balancedTokens>, undefined>, parents: (number | undefined)[], changes: {
+    start: number;
+    end: number;
+    text: string;
+}[]): void;
+//# sourceMappingURL=whitespace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"whitespace.d.ts","sourceRoot":"","sources":["../../src/lib/whitespace.js"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,eAAe,CAAC;AAiBrC,YAAwF,MAAM,GAApF,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,cAAc,CAAC,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAQ;AAAlG,qGAAqG;AAErG,uGAAuG;AACvG,wBAAgB,aAAa,CAAC,SAAS,EAD3B,UAAU,CAAC,OAAO,YAAY,CAAC,cAAc,CAClB,GADwC,CAAC,MAAM,GAAC,SAAS,CAAC,EAAE,CAYlG;AAqHD,0MAA0M;AAC1M,wBAAgB,gBAAgB,CAAC,SAAS,EAD9B,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,cAAc,CAAC,EAAE,SAAS,CACnC,EAAE,OAAO,EAD+C,CAAC,MAAM,GAAC,SAAS,CAAC,EACjE,EAAE,OAAO,EAD4E;IAAC,KAAK,EAAC,MAAM,CAAC;IAAA,GAAG,EAAC,MAAM,CAAC;IAAA,IAAI,EAAC,MAAM,CAAA;CAAC,EACjH,GADsI,IAAI,CAgBrM;AAYD,oOAAoO;AACpO,wBAAgB,kBAAkB,CAAC,QAAQ,EAD/B,OAC+B,EAAE,SAAS,EADhB,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,cAAc,CAAC,EAAE,SAAS,CACjD,EAAE,OAAO,EAD6D,CAAC,MAAM,GAAC,SAAS,CAAC,EAC/E,EAAE,OAAO,EAD0F;IAAC,KAAK,EAAC,MAAM,CAAC;IAAA,GAAG,EAAC,MAAM,CAAC;IAAA,IAAI,EAAC,MAAM,CAAA;CAAC,EAC/H,GADoJ,IAAI,CAoD/N"}