@@ -6,22 +6,20 @@ All notable changes to this project will be documented in this file. See [commit
 
 ### Bug fixes
 
-- fold a division or unit conversion only when the result is exact at the
+- transform a division or unit conversion only when the result is exact at the
   configured `precision`. `calc(100% / 3)` stays `calc(100% / 3)` instead of
-  becoming `calc(33.33333%)`, which drifted when repeated (#62), and
-  `calc(1cm + 1px)` is no longer converted to an approximate `1.02646cm`.
-  Use `precision: false` to fold every division.
+  becoming `calc(33.33333%)`, and `calc(1cm + 1px)` 
+  is no longer converted to an approximate `1.02646cm`.
+  Use `precision: false` to transform every division.
 - keep `precision` significant digits for values below 1, so
   `calc(1px / 150000)` is no longer rounded to `.00001px`
-- `min()`, `max()` and `clamp()` return the chosen argument, keeping its
-  original unit
-- treat `var()`, `env()`, `attr()` and other substitution functions as
-  positional barriers. They are replaced by raw tokens before the value is
-  computed, so with `--a: 1px + 2px`, `var(--a) * 2` means `1px + 2px * 2`.
-  Factors are no longer reordered or cancelled across them
-  (`var(--a) * 2` is no longer rewritten to `2 * var(--a)`,
-  `var(--a) / var(--a)` is not cancelled), and parentheses around them are kept
-  (`1px - (2 * var(--a))`)
+- `min()`, `max()` and `clamp()` preserve the original unit
+- keep the order of terms and factors around `var()`, `env()`, `attr()` and
+  other substitution functions. These are replaced by raw tokens before the
+  value is computed, so with `--a: 1px + 2px`, `var(--a) * 2` means
+  `1px + 2px * 2`. Factors are no longer reordered or cancelled:
+  `var(--a) * 2` is not rewritten to `2 * var(--a)`, `var(--a) / var(--a)` is
+  not cancelled, and parentheses are kept (`1px - (2 * var(--a))`).
   Unrecognised functions such as `anchor-size()` are treated the same way, so
   `2 * anchor-size(width) * .5` is no longer folded
 - keep the parentheses of a nested `calc()` that contains unresolved values, so
 
@@ -65,12 +65,13 @@ function applyTransform(
 function pluginCreator(opts) {
   /** @type {ResolvedOptions} */
   const options = {
-    precision: 5,
     warnWhenCannotResolve: false,
     mediaQueries: false,
     selectors: false,
     unwrapSingleValue: false,
     ...opts,
+    // An explicit `precision: undefined` keeps the default.
+    precision: opts?.precision ?? 5,
   };
 
   return {
 
@@ -3,16 +3,17 @@ import { isExact } from './exact.js';
 
 /**
  * If `dims` contain exactly one numerator / one denominator pair with the
- * same base type and convertible units, return the numeric factor produced
- * by cancelling them and the list of remaining (uncancelled) dims.
- * Otherwise return null. Used by `simplifyProduct` for typed division
- * (§10.2). More complex cancellation (e.g. `px^2 / px`) is left
+ * same base type and convertible units, return the two sides expressed in a
+ * common unit, so the caller can fold them into its own numerator and
+ * denominator. Otherwise return null. Used by `simplifyProduct` for typed
+ * division (§10.2). More complex cancellation (e.g. `px^2 / px`) is left
  * unreduced — consumers rarely rely on it and the spec doesn't require it.
  * @template {{ exponent: 1 | -1, value: number, unit: string }} D
  * @param {D[]} dims
- * @param {number | false} [precision] A factor that is not exact at this
- *   precision is not cancelled, so the quotient stays symbolic.
- * @return {{ factor: number, remaining: D[] } | null}
+ * @param {number | false} [precision] The denominator is converted into the
+ *   numerator's unit when that is exact at this precision (`1px / 1in` →
+ *   `1 / 96`); otherwise the numerator is converted (`1in / 1px` → `96 / 1`).
+ * @return {{ numerator: number, denominator: number, remaining: D[] } | null}
  */
 function tryCancelPair(dims, precision = false) {
   if (dims.length !== 2) {
@@ -29,16 +30,32 @@ function tryCancelPair(dims, precision = false) {
   if (!numBase || numBase !== denBase) {
     return null;
   }
-  const converted = convert(numerator.value, numerator.unit, denominator.unit);
-  if (converted === null) {
-    return null;
-  }
+  const converted = convert(
+    denominator.value,
+    denominator.unit,
+    numerator.unit
+  );
   // denominator.value === 0 yields ±Infinity / NaN naturally (§10.9.1).
-  const factor = converted / denominator.value;
-  if (!isExact(factor, precision)) {
-    return null;
+  if (converted !== null && isExact(converted, precision)) {
+    return {
+      numerator: numerator.value,
+      denominator: converted,
+      remaining: [],
+    };
+  }
+  const numConverted = convert(
+    numerator.value,
+    numerator.unit,
+    denominator.unit
+  );
+  if (numConverted !== null && isExact(numConverted, precision)) {
+    return {
+      numerator: numConverted,
+      denominator: denominator.value,
+      remaining: [],
+    };
   }
-  return { factor, remaining: [] };
+  return null;
 }
 
 export { tryCancelPair };
@@ -49,6 +49,34 @@ function isScalarSum(opaque) {
   );
 }
 
+/**
+ * Whether a folded quotient prints exactly. A quotient distributed over a
+ * scalar Sum is judged term by term, so `(3px + 6em) / 3` still folds.
+ * @param {number} value
+ * @param {ProductFactor[]} opaque
+ * @param {boolean} distributable
+ * @param {number | false} precision
+ * @return {boolean}
+ */
+function foldsExactly(value, opaque, distributable, precision) {
+  if (!Number.isFinite(value) || isExact(value, precision)) {
+    return true;
+  }
+  if (!distributable) {
+    return false;
+  }
+  const sum = /** @type {import('../node.js').Sum} */ (opaque[0].node);
+  return sum.terms.every((t) =>
+    isExact(
+      value *
+        /** @type {import('../node.js').Num | import('../node.js').Dim} */ (
+          t.node
+        ).value,
+      precision
+    )
+  );
+}
+
 /**
  * Emit an inexact quotient as `numerator * dims * opaque / denominator`, with
  * integer parts reduced by their gcd. A lone Dim absorbs the numerator.
@@ -166,8 +194,9 @@ function foldFactors(items, start, end, simplify, precision) {
   // unreduced — consumers don't rely on it and the spec doesn't require it.
   const cancelled = tryCancelPair(dims, precision);
   if (cancelled !== null) {
-    coeff *= cancelled.factor;
-    numerator *= cancelled.factor;
+    coeff *= cancelled.numerator / cancelled.denominator;
+    numerator *= cancelled.numerator;
+    denominator *= cancelled.denominator;
   }
   const divides = denominator !== 1 || cancelled !== null;
   const remainingDims = cancelled ? cancelled.remaining : dims;
@@ -178,10 +207,11 @@ function foldFactors(items, start, end, simplify, precision) {
       ? remainingDims[0]
       : null;
   const value = loneDim === null ? coeff : chainValue(scalarChain);
+  const distributable = remainingDims.length === 0 && isScalarSum(opaque);
 
   // An inexact quotient stays symbolic when its numerator and denominator
   // print exactly; otherwise it is folded and rounded at serialization.
-  if (divides && Number.isFinite(value) && !isExact(value, precision)) {
+  if (divides && !foldsExactly(value, opaque, distributable, precision)) {
     const rational = rationalProduct(
       numerator,
       denominator,
@@ -198,7 +228,7 @@ function foldFactors(items, start, end, simplify, precision) {
   // §10.10 distributive multiplication: `0.5 * (100vw - 10px)` → `50vw - 5px`.
   // Only distribute when every Sum term is Num/Dim — partial distribution
   // over opaque terms matches neither the legacy implementation nor csstools.
-  if (remainingDims.length === 0 && isScalarSum(opaque)) {
+  if (distributable) {
     const sum = /** @type {import('../node.js').Sum} */ (opaque[0].node);
     const distributed = sum.terms.map((t) => ({
       sign: t.sign,
 
@@ -61,11 +61,12 @@ function reduceCalc(value, opts) {
 
   /** @type {ResolvedReduceCalcOptions} */
   const options = {
-    precision: 5,
     warnWhenCannotResolve: false,
     unwrapSingleNegativeNumber: false,
     unwrapSingleValue: false,
     ...opts,
+    // An explicit `precision: undefined` keeps the default.
+    precision: opts?.precision ?? 5,
   };
   /** @type {import('@csstools/css-tokenizer').CSSToken[]} */
   let tokens;
 
@@ -106,3 +106,10 @@ test(
     'calc(var(--xxx, var(--yyy)) / 2)'
   )
 );
+
+test(
+  'should keep the default precision when precision is undefined',
+  testCss('a{width:calc(100% / 3)}', 'a{width:calc(100% / 3)}', {
+    precision: undefined,
+  })
+);
@@ -22,8 +22,25 @@ describe('Exact-by-default division', () => {
     ['calc(1 / 3)', 'calc(1 / 3)'],
     ['calc(10px / 3 * 3)', 'calc(10px)'],
     ['calc(10px / -3)', 'calc(-10px / 3)'],
-    ['calc(1px / 1in)', 'calc(1px / 1in)'],
+    ['calc(1px / 1in)', 'calc(1 / 96)'],
     ['calc(1in / 1px)', 'calc(96)'],
+    ['calc(1pt / 1pc)', 'calc(1 / 12)'],
+    ['calc(1pc / 1pt)', 'calc(12)'],
+    ['calc(2in / 1px)', 'calc(192)'],
+    ['calc(7px / 1in)', 'calc(7 / 96)'],
+    ['calc(1in / 7px)', 'calc(96 / 7)'],
+    ['calc(-1px / 1in)', 'calc(-1 / 96)'],
+    ['calc(1px / -1in)', 'calc(-1 / 96)'],
+    ['calc(1cm / 1px)', 'calc(1cm / 1px)'],
+    ['calc(1deg / 1rad)', 'calc(1deg / 1rad)'],
+    ['calc((100px + 60em) / 3)', 'calc((100px + 60em) / 3)'],
+    ['calc((3px + 5em) / 3)', 'calc((3px + 5em) / 3)'],
+    ['calc((3px + 6em) / -3)', 'calc(-1px - 2em)'],
+    ['calc((3px + var(--a)) / 3)', 'calc((3px + var(--a)) / 3)'],
+    ['calc(1px * 3 / 3px)', 'calc(1)'],
+    ['calc(1px / 3px * 3)', 'calc(1)'],
+    ['calc((3px + 6em) / 3)', 'calc(1px + 2em)'],
+    ['calc((30px + 60%) / 3)', 'calc(10px + 20%)'],
     ['calc(var(--n) / 4)', 'calc(var(--n) / 4)'],
     ['calc(2 * var(--n) / 3)', 'calc(2 * var(--n) / 3)'],
     // Quotients whose parts would be rounded on output are folded instead.
@@ -54,6 +71,24 @@ describe('Exact-by-default division', () => {
     );
   });
 
+  test('precision undefined keeps the default', () => {
+    assert.equal(
+      reduceCalc('calc(100% / 3)', { precision: undefined }),
+      'calc(100% / 3)'
+    );
+    assert.equal(
+      reduceCalc('calc(1cm + 1px)', { precision: undefined }),
+      'calc(1cm + 1px)'
+    );
+  });
+
+  test('precision false folds inexact unit quotients', () => {
+    assert.equal(
+      reduceCalc('calc(1cm / 1px)', { precision: false }),
+      'calc(37.79527559055118)'
+    );
+  });
+
   test('a higher precision folds quotients that are exact there', () => {
     assert.equal(
       reduceCalc('calc(1px / 96)', { precision: 10 }),
 
@@ -1,22 +1,24 @@
 /**
  * If `dims` contain exactly one numerator / one denominator pair with the
- * same base type and convertible units, return the numeric factor produced
- * by cancelling them and the list of remaining (uncancelled) dims.
- * Otherwise return null. Used by `simplifyProduct` for typed division
- * (§10.2). More complex cancellation (e.g. `px^2 / px`) is left
+ * same base type and convertible units, return the two sides expressed in a
+ * common unit, so the caller can fold them into its own numerator and
+ * denominator. Otherwise return null. Used by `simplifyProduct` for typed
+ * division (§10.2). More complex cancellation (e.g. `px^2 / px`) is left
  * unreduced — consumers rarely rely on it and the spec doesn't require it.
  * @template {{ exponent: 1 | -1, value: number, unit: string }} D
  * @param {D[]} dims
- * @param {number | false} [precision] A factor that is not exact at this
- *   precision is not cancelled, so the quotient stays symbolic.
- * @return {{ factor: number, remaining: D[] } | null}
+ * @param {number | false} [precision] The denominator is converted into the
+ *   numerator's unit when that is exact at this precision (`1px / 1in` →
+ *   `1 / 96`); otherwise the numerator is converted (`1in / 1px` → `96 / 1`).
+ * @return {{ numerator: number, denominator: number, remaining: D[] } | null}
  */
 declare function tryCancelPair<D extends {
     exponent: 1 | -1;
     value: number;
     unit: string;
 }>(dims: D[], precision?: number | false): {
-    factor: number;
+    numerator: number;
+    denominator: number;
     remaining: D[];
 } | null;
 export { tryCancelPair };