postcss-minify-gradients 9.0.2 → 9.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss-minify-gradients",
-  "version": "9.0.2",
+  "version": "9.0.4",
   "description": "Minify gradient parameters with PostCSS.",
   "exports": {
     ".": {
@@ -33,9 +33,9 @@
     "url": "git+https://github.com/cssnano/cssnano.git"
   },
   "dependencies": {
-    "@colordx/core": "^6.3.0",
-    "cssnano-utils": "^7.0.2",
-    "postcss-value-parser": "^4.2.0"
+    "@colordx/core": "^7.2.0",
+    "@csstools/css-tokenizer": "^4.0.2",
+    "cssnano-utils": "^8.0.0"
   },
   "bugs": {
     "url": "https://github.com/cssnano/cssnano/issues"
@@ -51,6 +51,7 @@
   },
   "type": "module",
   "scripts": {
+    "fuzz": "node ./script/fuzz.js",
     "test": "node --test"
   }
 }

package/src/index.js

@@ -1,376 +1,401 @@
-import valueParser from 'postcss-value-parser';
+/** @import {CSSToken} from '@csstools/css-tokenizer' */
 import cssnanoUtils from 'cssnano-utils';
-import isColorStop from './isColorStop.js';
-
-const { getArguments } = cssnanoUtils;
-const directionsToAngles = new Map([
+import isKnownColor from './isKnownColor.js';
+
+const {
+  TokenType,
+  applyEdits,
+  asciiLowerCase,
+  decoded,
+  lengthUnits,
+  numeric,
+  tokenEnd,
+} = cssnanoUtils;
+/** @type {typeof cssnanoUtils.balancedTokens} */
+const balancedTokens = cssnanoUtils.balancedTokens;
+
+const directions = new Map([
   ['top', '0deg'],
   ['right', '90deg'],
   ['bottom', '180deg'],
   ['left', '270deg'],
 ]);
+const gradientNames = new Set([
+  'linear-gradient',
+  'repeating-linear-gradient',
+  '-webkit-linear-gradient',
+  '-webkit-repeating-linear-gradient',
+  'radial-gradient',
+  'repeating-radial-gradient',
+  'conic-gradient',
+  'repeating-conic-gradient',
+  '-webkit-radial-gradient',
+  '-webkit-repeating-radial-gradient',
+]);
+const variableFunctions = new Set(['var', 'env']);
+// Only these functions can compute a position, so any other leading function
+// such as `rgb()` or `var()` cannot be one.
+const positionFunctions = new Set(['calc', 'clamp', 'max', 'min']);
+const gradientSourceRegex = /[gG][rR][aA][dD][iI][eE][nN][tT]/v;
+// Identifiers that may start a gradient line, shape or size specification, so
+// the argument carrying one is never a colour stop slot.
+const lineKeywords = new Set([
+  'at',
+  'bottom',
+  'center',
+  'circle',
+  'closest-corner',
+  'closest-side',
+  'ellipse',
+  'farthest-corner',
+  'farthest-side',
+  'from',
+  'in',
+  'left',
+  'right',
+  'to',
+  'top',
+]);
 
+/** @typedef {{start: number, end: number, text: string}} SourceEdit */
 /**
- * Returns whether b is less than or equal to a.
+ * A gradient stop before fixup: the argument it came from, the extent of its
+ * colour, and the position tokens following that colour.
  *
- * @param {valueParser.Dimension} a
- * @param {valueParser.Dimension} b
- * @returns {boolean}
+ * @typedef {object} ColorStop
+ * @property {number} argIndex Comma-separated argument the stop came from.
+ * @property {number} colorEnd Offset just past the colour in the declaration value.
+ * @property {readonly number[]} position Positions following the colour.
  */
-function isLessThan(a, b) {
-  return (
-    a.unit.toLowerCase() === b.unit.toLowerCase() &&
-    Number.parseFloat(a.number) >= Number.parseFloat(b.number)
-  );
-}
-
 /**
- * Compares positions when their ordering is independent of layout.
+ * A position as a number and its unit, as reported by `numeric()`.
  *
- * @param {valueParser.Dimension} a
- * @param {valueParser.Dimension} b
- * @returns {boolean | undefined}
+ * @typedef {{number: number, unit: string}} PositionValue
  */
-function isLessThanOrEqual(a, b) {
-  if (a.unit.toLowerCase() === b.unit.toLowerCase()) {
-    return isLessThan(a, b);
-  }
-
-  const aNumber = Number.parseFloat(a.number);
-  const bNumber = Number.parseFloat(b.number);
-
-  if (aNumber === 0) {
-    return bNumber <= 0;
-  }
-
-  if (bNumber === 0) {
-    return aNumber >= 0;
-  }
-}
 
 /**
- * Returns whether a node is a literal color stop position.
+ * Significant tokens of a range, skipping whitespace, comments and the contents
+ * of any balanced frame the range opens.
  *
- * @param {import('postcss-value-parser').Node} node
- * @returns {boolean}
+ * @param {readonly CSSToken[]} input
+ * @param {NonNullable<ReturnType<typeof balancedTokens>>} structure
+ * @param {{startIndex: number, endIndex: number}} range
+ * @return {number[]} Indexes of the significant tokens in `input`.
  */
-function isPosition(node) {
-  return node.type === 'word' && valueParser.unit(node.value) !== false;
+function significant(input, structure, range) {
+  const result = [];
+  for (let index = range.startIndex; index < range.endIndex; index++) {
+    const token = input[index];
+    if (token[0] !== TokenType.Whitespace && token[0] !== TokenType.Comment) {
+      result.push(index);
+    }
+    const frameEnd = structure.endForOpening(index);
+    if (frameEnd !== undefined) index = frameEnd;
+  }
+  return result;
 }
 
 /**
- * Returns whether an argument begins a color stop.
+ * Whether an argument starts a line, shape or size specification instead of a
+ * colour. Numbers cannot start a colour, and every other token here has to be
+ * an identifier the gradient grammar reserves for its first argument.
  *
- * @param {import('postcss-value-parser').Node[]} argument
- * @returns {boolean}
+ * @param {readonly CSSToken[]} input
+ * @param {readonly number[]} parts Offsets of an argument's significant tokens.
+ * @return {boolean}
  */
-function isColorStopArgument(argument) {
-  const first = argument[0];
-
-  if (!first) {
-    return false;
-  }
-
-  if (first.type === 'function') {
-    return !new Set(['calc', 'clamp', 'max', 'min']).has(
-      first.value.toLowerCase()
-    );
+function startsLineSpecification(input, parts) {
+  const token = input[parts[0]];
+  if (!token) return false;
+  if (
+    token[0] === TokenType.Dimension ||
+    token[0] === TokenType.Number ||
+    token[0] === TokenType.Percentage
+  ) {
+    return true;
   }
-
-  return first.type === 'word' && isColorStop(first.value);
+  return (
+    token[0] === TokenType.Ident &&
+    lineKeywords.has(asciiLowerCase(decoded(token)))
+  );
 }
 
 /**
- * Gets the position nodes from a color stop or transition hint.
+ * A zero length and a zero percentage name the same gradient position, which is
+ * also what the unitless zero this plugin emits denotes. Angles and other
+ * dimensions only share a spelling with it.
  *
- * @param {import('postcss-value-parser').Node[]} argument
- * @param {boolean} colorStopArgument
- * @returns {import('postcss-value-parser').Node[]}
+ * @param {string} unit
+ * @return {boolean}
  */
-function getPositions(argument, colorStopArgument) {
-  return argument.slice(colorStopArgument ? 1 : 0).filter((node) => {
-    return node.type !== 'space' && node.type !== 'comment';
-  });
+function isPositionZeroUnit(unit) {
+  const lowered = asciiLowerCase(unit);
+  return lowered === '' || lowered === '%' || lengthUnits.has(lowered);
 }
 
 /**
- * Updates the largest preceding position, replacing a position that will be
- * fixed up with its shorter equivalent.
+ * Whether two positions are on the same scale, so their numbers can be ordered.
+ * Only a length and a percentage naming zero are interchangeable.
  *
- * @param {valueParser.Dimension | undefined} largestPosition
- * @param {import('postcss-value-parser').Node} position
- * @returns {valueParser.Dimension | undefined}
+ * @param {PositionValue} current
+ * @param {PositionValue} largest
+ * @return {boolean}
  */
-function updateLargestPosition(largestPosition, position) {
-  if (!isPosition(position)) {
-    return undefined;
-  }
-
-  const currentPosition = valueParser.unit(position.value);
-
-  if (!currentPosition) {
-    return undefined;
-  }
-
-  if (!largestPosition) {
-    return currentPosition;
-  }
-
-  const isFixedUp = isLessThanOrEqual(largestPosition, currentPosition);
-
-  if (isFixedUp) {
-    position.value = '0';
-    return largestPosition;
-  }
-
-  return isFixedUp === undefined ? undefined : currentPosition;
+function positionsComparable(current, largest) {
+  const unit = asciiLowerCase(current.unit);
+  const largestUnit = asciiLowerCase(largest.unit);
+  if (unit === largestUnit) return true;
+  return (
+    (current.number === 0 || largest.number === 0) &&
+    isPositionZeroUnit(unit) &&
+    isPositionZeroUnit(largestUnit)
+  );
 }
 
 /**
- * Optimizes a standard gradient color stop list using the color stop fixup
- * algorithm. A non-literal position prevents later comparisons because its
- * used value can only be known during layout.
+ * Offset just past the leading colour of an argument, so a functional colour
+ * such as `rgb(0 0 0 / 50%)` ends at its closing parenthesis.
  *
- * @param {import('postcss-value-parser').Node[][]} args
- * @returns {void}
+ * @param {readonly CSSToken[]} input
+ * @param {NonNullable<ReturnType<typeof balancedTokens>>} structure
+ * @param {readonly number[]} parts Offsets of an argument's significant tokens.
+ * @return {number}
  */
-function optimizeColorStops(args) {
-  const firstStopIndex = args.findIndex(isColorStopArgument);
-
-  if (firstStopIndex === -1) {
-    return;
-  }
-
-  const stops = [];
-  let largestPosition = /** @type {valueParser.Dimension | undefined} */ (
-    undefined
-  );
-  let hasSeenStop = false;
-
-  for (const argument of args.slice(firstStopIndex)) {
-    const colorStop = isColorStopArgument(argument);
-    const positions = getPositions(argument, colorStop);
-
-    if (colorStop) {
-      stops.push({ argument, positions });
-
-      if (!hasSeenStop && positions.length === 0) {
-        largestPosition = /** @type {valueParser.Dimension} */ (
-          valueParser.unit('0%')
-        );
-      }
-
-      hasSeenStop = true;
-    }
-
-    if (positions.length === 0) {
-      continue;
-    }
-
-    for (const position of positions) {
-      largestPosition = updateLargestPosition(largestPosition, position);
-    }
-  }
-
-  const firstStop = stops[0];
-  const lastStop = stops.at(-1);
-
-  if (
-    firstStop &&
-    firstStop.positions.length === 1 &&
-    firstStop.argument.length === 3 &&
-    firstStop.positions[0].value === '0%'
-  ) {
-    firstStop.argument[1].value = firstStop.positions[0].value = '';
-  }
-
-  if (
-    lastStop &&
-    lastStop.positions.length === 1 &&
-    lastStop.argument.length === 3 &&
-    lastStop.positions[0].value === '100%'
-  ) {
-    lastStop.argument[1].value = lastStop.positions[0].value = '';
-  }
+function colorEnd(input, structure, parts) {
+  const leading = parts[0];
+  const component = input[leading];
+  if (component[0] !== TokenType.Function) return component[3];
+  const closing = structure.endForOpening(leading);
+  return closing === undefined ? component[3] : input[closing][3];
 }
 
 /**
- * Shortens a direction like `to left top` into an angle.
+ * A `to <side>` line specification is an angle in fewer bytes.
  *
- * @param {import('postcss-value-parser').FunctionNode} node
- * @returns {void}
+ * @param {readonly CSSToken[]} input
+ * @param {readonly number[]} parts Significant tokens of the first argument.
+ * @return {SourceEdit | undefined}
  */
-function shortenDirection(node) {
-  node.nodes = node.nodes.slice(2);
-  node.nodes[0].value = /** @type {string} */ (
-    directionsToAngles.get(node.nodes[0].value.toLowerCase())
-  );
+function lineDirectionEdit(input, parts) {
+  if (parts.length !== 2) return undefined;
+  const from = input[parts[0]];
+  const side = input[parts[1]];
+  if (
+    from[0] !== TokenType.Ident ||
+    side[0] !== TokenType.Ident ||
+    asciiLowerCase(decoded(from)) !== 'to'
+  )
+    return undefined;
+  const direction = directions.get(asciiLowerCase(decoded(side)));
+  if (!direction) return undefined;
+  return { start: from[2], end: tokenEnd(side), text: direction };
 }
 
 /**
- * Optimises a linear gradient.
+ * Colour stop fixup raises a position to the largest position before it, so a
+ * position at or below that non-negative maximum can be written as a zero.
  *
- * @param {import('postcss-value-parser').FunctionNode} node
- * @returns {false}
+ * @param {readonly CSSToken[]} input
+ * @param {readonly number[]} position Offsets of the position tokens.
+ * @param {PositionValue | undefined} maximum Running maximum of the preceding positions.
+ * @param {Map<number, SourceEdit>} edits Collects the positions reduced to a zero.
+ * @return {PositionValue | undefined} The maximum the following stops clamp to.
  */
-function optimizeLinearGradient(node) {
-  const args = getArguments(node);
-  if (node.nodes[0]?.value.toLowerCase() === 'to' && args[0].length === 3) {
-    shortenDirection(node);
+function zeroPositionEdits(input, position, maximum, edits) {
+  let largest = maximum;
+  for (const index of position) {
+    const token = input[index];
+    const current = numeric(token);
+    if (!current) {
+      largest = undefined;
+      continue;
+    }
+    // A zero clamps to any non-negative maximum whatever units name them, so
+    // the maximum survives the rewritten spelling instead of resetting on the
+    // next pass.
+    if (
+      largest &&
+      largest.number >= 0 &&
+      current.number === 0 &&
+      isPositionZeroUnit(current.unit)
+    ) {
+      edits.set(index, { start: token[2], end: tokenEnd(token), text: '0' });
+      continue;
+    }
+    if (largest && !positionsComparable(current, largest)) {
+      largest = undefined;
+      continue;
+    }
+    if (largest && largest.number >= 0 && largest.number >= current.number) {
+      edits.set(index, { start: token[2], end: tokenEnd(token), text: '0' });
+    } else {
+      largest = current;
+    }
   }
-  optimizeColorStops(getArguments(node));
-
-  return false;
+  return largest;
 }
 
 /**
- * Optimises a radial gradient.
+ * Collect the colour stops of one gradient argument list, the count of leading
+ * arguments naming the line or shape instead of a stop, and the positions that
+ * colour stop fixup clamps to a zero.
  *
- * @param {import('postcss-value-parser').ParsedValue | import('postcss-value-parser').FunctionNode} node
- * @returns {false}
+ * @param {string} source
+ * @param {readonly CSSToken[]} input
+ * @param {NonNullable<ReturnType<typeof balancedTokens>>} structure
+ * @param {{startIndex: number, endIndex: number}[]} args
+ * @param {boolean} linear Whether the line specification may hold an angle.
+ * @return {{stops: ColorStop[], lineSpecifications: number, zeroEdits: Map<number, SourceEdit>, directionEdit: SourceEdit | undefined}}
  */
-function optimizeRadialGradient(node) {
-  optimizeColorStops(getArguments(node));
-
-  return false;
+function collectColorStops(source, input, structure, args, linear) {
+  /** @type {ColorStop[]} */
+  const stops = [];
+  /** @type {Map<number, SourceEdit>} */
+  const zeroEdits = new Map();
+  /** @type {SourceEdit | undefined} */
+  let directionEdit;
+  // A stop may only drop its start position when nothing but these arguments
+  // precede it.
+  let lineSpecifications = 0;
+  /** @type {PositionValue | undefined} */
+  let largest;
+  for (const [argIndex, range] of args.entries()) {
+    const parts = significant(input, structure, range);
+    if (!parts.length) continue;
+    if (linear && argIndex === 0)
+      directionEdit = lineDirectionEdit(input, parts);
+    const end = colorEnd(input, structure, parts);
+    const leading = input[parts[0]];
+    const color = asciiLowerCase(source.slice(leading[2], end + 1));
+    const isColor =
+      isKnownColor(color) ||
+      (leading[0] === TokenType.Function &&
+        !positionFunctions.has(asciiLowerCase(decoded(leading))));
+    const position = isColor ? parts.slice(1) : parts;
+    if (
+      !isColor &&
+      argIndex === lineSpecifications &&
+      startsLineSpecification(input, parts)
+    )
+      lineSpecifications = argIndex + 1;
+    if (isColor) {
+      // A stop without a position sits at the running maximum, which starts at zero.
+      if (!position.length && !largest) largest = { number: 0, unit: '%' };
+      stops.push({ argIndex, colorEnd: end, position });
+    }
+    // Positions before the first stop belong to the line specification.
+    if (!stops.length) continue;
+    largest = zeroPositionEdits(input, position, largest, zeroEdits);
+  }
+  return { stops, lineSpecifications, zeroEdits, directionEdit };
 }
 
 /**
- * Optimises a radial gradient.
+ * The first colour stop defaults to the zero position and the last one to 100%,
+ * so either can drop a position already spelling its default. A single-stop
+ * gradient holds one stop in both slots, hence the slots by index and the
+ * zero edit dropped in favour of the wider removal.
  *
- * @param {import('postcss-value-parser').ParsedValue | import('postcss-value-parser').FunctionNode} node
- * @returns {false}
+ * @param {readonly CSSToken[]} input
+ * @param {readonly ColorStop[]} stops
+ * @param {number} lineSpecifications
+ * @param {number} args
+ * @param {Map<number, SourceEdit>} zeroEdits
+ * @return {SourceEdit[]}
  */
-function optimizeWebkitRadialGradient(node) {
-  const args = getArguments(node);
-  /** @type {valueParser.Dimension | false | undefined} */
-  let previousStop = undefined;
-
-  for (const arg of args) {
-    let color;
-    let stop;
-
-    if (arg[2] !== undefined) {
-      if (arg[0].type === 'function') {
-        color = `${arg[0].value}(${valueParser.stringify(arg[0].nodes)})`;
-      } else {
-        color = arg[0].value;
-      }
-
-      if (arg[2].type === 'function') {
-        stop = `${arg[2].value}(${valueParser.stringify(arg[2].nodes)})`;
-      } else {
-        stop = arg[2].value;
-      }
-    } else {
-      if (arg[0].type === 'function') {
-        // eslint-disable-next-line no-useless-assignment
-        color = `${arg[0].value}(${valueParser.stringify(arg[0].nodes)})`;
-      }
-
-      color = arg[0].value;
+function boundaryStopEdits(input, stops, lineSpecifications, args, zeroEdits) {
+  /** @type {SourceEdit[]} */
+  const edits = [];
+  for (const slot of new Set([0, stops.length - 1])) {
+    const stop = stops[slot];
+    if (!stop || stop.position.length !== 1) continue;
+    const [index] = stop.position;
+    const position = input[index];
+    const value = numeric(position);
+    if (!value) continue;
+    let removable = false;
+    if (slot === 0 && stop.argIndex === lineSpecifications) {
+      removable = value.number === 0 && isPositionZeroUnit(value.unit);
     }
-
-    color = color.toLowerCase();
-
-    const colorStop =
-      stop !== undefined
-        ? isColorStop(color, stop.toLowerCase())
-        : isColorStop(color);
-
-    if (!colorStop || !arg[2]) {
-      continue;
+    if (
+      slot === stops.length - 1 &&
+      stop.argIndex === args - 1 &&
+      value.number === 100 &&
+      asciiLowerCase(value.unit) === '%'
+    ) {
+      removable = true;
     }
-
-    const thisStop = valueParser.unit(arg[2].value);
-
-    if (!previousStop) {
-      previousStop = thisStop;
-
-      continue;
-    }
-
-    if (previousStop && thisStop && isLessThan(previousStop, thisStop)) {
-      arg[2].value = '0';
-    }
-
-    previousStop = thisStop;
+    if (!removable) continue;
+    // Removing the position from the colour onwards also covers a zero edit
+    // emitted for the same token.
+    zeroEdits.delete(index);
+    edits.push({
+      start: stop.colorEnd + 1,
+      end: tokenEnd(position),
+      text: '',
+    });
   }
-
-  return false;
+  return edits;
 }
 
 /**
  * @param {import('postcss').Declaration} decl
- * @return {void}
  */
 function optimise(decl) {
-  const value = decl.value;
-
-  if (!value) {
-    return;
-  }
-
-  const normalizedValue = value.toLowerCase();
-
-  if (normalizedValue.includes('var(') || normalizedValue.includes('env(')) {
-    return;
-  }
-
-  if (!normalizedValue.includes('gradient')) {
+  const source = decl.value;
+  if (!source || !gradientSourceRegex.test(source)) return;
+  const structure = balancedTokens(source);
+  if (!structure) return;
+  const { tokens: input } = structure;
+  if (
+    input.some(
+      (token) =>
+        token[0] === TokenType.Function &&
+        variableFunctions.has(asciiLowerCase(decoded(token)))
+    )
+  )
     return;
+  /** @type {SourceEdit[]} */
+  const replacements = [];
+  // Nested gradients are visited in token order; their argument ranges come
+  // from the shared delimiter map.
+  for (let index = 0; index < input.length; index++) {
+    const token = input[index];
+    if (token[0] !== TokenType.Function) continue;
+    const name = asciiLowerCase(decoded(token));
+    if (!gradientNames.has(name)) continue;
+    const end = structure.endForOpening(index);
+    if (end === undefined) continue;
+    const args = structure.topLevelSegments(index + 1, end);
+    const { stops, lineSpecifications, zeroEdits, directionEdit } =
+      collectColorStops(
+        source,
+        input,
+        structure,
+        args,
+        name.includes('linear')
+      );
+    if (directionEdit) replacements.push(directionEdit);
+    replacements.push(
+      ...boundaryStopEdits(
+        input,
+        stops,
+        lineSpecifications,
+        args.length,
+        zeroEdits
+      ),
+      ...zeroEdits.values()
+    );
   }
-
-  decl.value = valueParser(value)
-    .walk((node) => {
-      if (node.type !== 'function' || !node.nodes.length) {
-        return false;
-      }
-
-      const lowerCasedValue = node.value.toLowerCase();
-
-      if (
-        lowerCasedValue === 'linear-gradient' ||
-        lowerCasedValue === 'repeating-linear-gradient' ||
-        lowerCasedValue === '-webkit-linear-gradient' ||
-        lowerCasedValue === '-webkit-repeating-linear-gradient'
-      ) {
-        return optimizeLinearGradient(node);
-      }
-
-      if (
-        lowerCasedValue === 'radial-gradient' ||
-        lowerCasedValue === 'repeating-radial-gradient'
-      ) {
-        return optimizeRadialGradient(node);
-      }
-
-      if (
-        lowerCasedValue === '-webkit-radial-gradient' ||
-        lowerCasedValue === '-webkit-repeating-radial-gradient'
-      ) {
-        return optimizeWebkitRadialGradient(node);
-      }
-
-      if (
-        lowerCasedValue === 'conic-gradient' ||
-        lowerCasedValue === 'repeating-conic-gradient'
-      ) {
-        optimizeColorStops(getArguments(node));
-      }
-      return false;
-    })
-    .toString();
+  // With nothing to rewrite, neither the edit pass nor the write can change the
+  // declaration.
+  if (replacements.length) decl.value = applyEdits(source, replacements);
 }
-/**
- * @return {import('postcss').Plugin}
- */
+
+/** @return {import('postcss').Plugin} */
 function pluginCreator() {
   return {
     postcssPlugin: 'postcss-minify-gradients',
-    /**
-     * @param {import('postcss').Root} css
-     */
     OnceExit(css) {
       css.walkDecls(optimise);
     },
@@ -378,6 +403,4 @@ function pluginCreator() {
 }
 /** @type {true} */
 pluginCreator.postcss = true;
-const moduleExports = pluginCreator;
-
-export { moduleExports as default, moduleExports as 'module.exports' };
+export { pluginCreator as default, pluginCreator as 'module.exports' };

package/src/isKnownColor.js

@@ -0,0 +1,79 @@
+import { colordx as colord, extend } from '@colordx/core';
+import hwbPlugin from '@colordx/core/plugins/hwb';
+import namesPlugin from '@colordx/core/plugins/names';
+
+extend([
+  /** @type {import('@colordx/core').Plugin} */ (
+    /** @type {unknown} */ (hwbPlugin)
+  ),
+  /** @type {import('@colordx/core').Plugin} */ (
+    /** @type {unknown} */ (namesPlugin)
+  ),
+]);
+
+/* A gradient stop may hold `currentColor` and the `<system-color>` keywords,
+ * which resolve only at used-value time, so no colour parser can validate
+ * them; the keyword list carries them. Plugin registration is process-global
+ * and `postcss-colormin` shares it, so colordx loads only the plugins this
+ * module needs — otherwise colormin would gamut-map wide-gamut colours.
+ * Colour notations colordx cannot parse remain valid stop colours.
+ * `postcss-merge-longhand` duplicates this list on purpose. */
+export const dynamicColorKeywords = new Set([
+  'currentcolor',
+  'accentcolor',
+  'accentcolortext',
+  'activetext',
+  'buttonborder',
+  'buttonface',
+  'buttontext',
+  'canvas',
+  'canvastext',
+  'field',
+  'fieldtext',
+  'graytext',
+  'highlight',
+  'highlighttext',
+  'linktext',
+  'mark',
+  'marktext',
+  'selecteditem',
+  'selecteditemtext',
+  'visitedtext',
+  // Deprecated system colors (CSS Color 3 / CSS Color 4 § 3.3.1)
+  'activeborder',
+  'activecaption',
+  'appworkspace',
+  'background',
+  'buttonhighlight',
+  'buttonshadow',
+  'captiontext',
+  'inactiveborder',
+  'inactivecaption',
+  'inactivecaptiontext',
+  'infobackground',
+  'infotext',
+  'menu',
+  'menutext',
+  'scrollbar',
+  'threeddarkshadow',
+  'threedface',
+  'threedhighlight',
+  'threedlightshadow',
+  'threedshadow',
+  'window',
+  'windowframe',
+  'windowtext',
+]);
+
+/**
+ * Whether `color` is a `<color>` a gradient stop may hold, including the
+ * keywords that only resolve at used-value time. Arguments beginning with a
+ * function other than `calc()`, `clamp()`, `max()` or `min()` are treated as
+ * colour stops without this check.
+ *
+ * @param {string} color
+ * @returns {boolean}
+ */
+export default function isKnownColor(color) {
+  return dynamicColorKeywords.has(color) || colord(color).isValid();
+}

package/types/index.d.ts

@@ -1,10 +1,30 @@
-/**
- * @return {import('postcss').Plugin}
- */
+export type SourceEdit = {
+    start: number;
+    end: number;
+    text: string;
+};
+export type ColorStop = {
+    /**
+     * Comma-separated argument the stop came from.
+     */
+    argIndex: number;
+    /**
+     * Offset just past the colour in the declaration value.
+     */
+    colorEnd: number;
+    /**
+     * Positions following the colour.
+     */
+    position: readonly number[];
+};
+export type PositionValue = {
+    number: number;
+    unit: string;
+};
+/** @return {import('postcss').Plugin} */
 declare function pluginCreator(): import('postcss').Plugin;
 declare namespace pluginCreator {
     var postcss: true;
 }
-declare const moduleExports: typeof pluginCreator;
-export { moduleExports as default, moduleExports as 'module.exports' };
+export { pluginCreator as default, pluginCreator as 'module.exports' };
 //# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AA4WA;;GAEG;AACH,iBAAS,aAAa,IAFV,OAAO,SAAS,EAAE,MAAM,CAYnC;kBAVQ,aAAa;iBAWX,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":"AA2DI,YAAsD,UAAU,GAAtD;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAY;AAKjE,YAAkB,SAAS,GAC3B;;;;IAAmB,QAAQ,EAAhB,MAAM,CACjB;;;;IAAmB,QAAQ,EAAhB,MAAM,CACjB;;;;IAA8B,QAAQ,EAA3B,SAAS,MAAM,EAAE,CAC9B;CAAA,CAAA;AAIE,YAA0C,aAAa,GAA7C;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAe;AAkU1D,yCAAyC;AACzC,iBAAS,aAAa,IADT,OAAO,SAAS,EAAE,MAAM,CAQpC;kBAPQ,aAAa;iBAQX,IAAI;;AAEf,OAAO,EAAE,aAAa,IAAI,OAAO,EAAE,aAAa,IAAI,gBAAgB,EAAE,CAAC"}

package/types/isKnownColor.d.ts

@@ -0,0 +1,12 @@
+export declare const dynamicColorKeywords: Set<string>;
+/**
+ * Whether `color` is a `<color>` a gradient stop may hold, including the
+ * keywords that only resolve at used-value time. Arguments beginning with a
+ * function other than `calc()`, `clamp()`, `max()` or `min()` are treated as
+ * colour stops without this check.
+ *
+ * @param {string} color
+ * @returns {boolean}
+ */
+export default function isKnownColor(color: string): boolean;
+//# sourceMappingURL=isKnownColor.d.ts.map

package/types/isKnownColor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isKnownColor.d.ts","sourceRoot":"","sources":["../src/isKnownColor.js"],"names":[],"mappings":"AAoBA,eAAO,MAAM,oBAAoB,aA6C/B,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,KAAK,EAH/B,MAG+B,GAF7B,OAAO,CAInB"}

package/src/isColorStop.js

@@ -1,77 +0,0 @@
-import postcssValueParser from 'postcss-value-parser';
-import { colordx as colord, extend } from '@colordx/core';
-import hwbPlugin from '@colordx/core/plugins/hwb';
-import namesPlugin from '@colordx/core/plugins/names';
-
-const { unit } = postcssValueParser;
-extend([
-  /** @type {import('@colordx/core').Plugin} */ (
-    /** @type {unknown} */ (hwbPlugin)
-  ),
-  /** @type {import('@colordx/core').Plugin} */ (
-    /** @type {unknown} */ (namesPlugin)
-  ),
-]);
-
-/* Code derived from https://www.npmjs.com/package/is-color-stop Licensed under MIT license */
-
-const lengthUnits = new Set([
-  'PX',
-  'IN',
-  'CM',
-  'MM',
-  'EM',
-  'REM',
-  'POINTS',
-  'PC',
-  'EX',
-  'CH',
-  'VW',
-  'VH',
-  'VMIN',
-  'VMAX',
-  '%',
-]);
-
-const colorStopRegex = /^calc\(\S+\)$/g;
-
-/**
- * @param {string} input
- * @return {boolean}
- */
-function isCSSLengthUnit(input) {
-  return lengthUnits.has(input.toUpperCase());
-}
-/**
- * @param {string|undefined} str
- * @return {boolean}
- */
-function isStop(str) {
-  if (str) {
-    let colorStop = false;
-    const node = unit(str);
-    if (node) {
-      const number = Number(node.number);
-      if (
-        number === 0 ||
-        (!Number.isNaN(number) && isCSSLengthUnit(node.unit))
-      ) {
-        colorStop = true;
-      }
-    } else {
-      colorStop = colorStopRegex.test(str);
-    }
-    return colorStop;
-  }
-  return true;
-}
-/**
- * @param {string} color
- * @param {string} [stop]
- * @return {boolean}
- */
-function isColorStop(color, stop) {
-  return colord(color).isValid() && isStop(stop);
-}
-
-export default isColorStop;

package/types/isColorStop.d.ts

@@ -1,8 +0,0 @@
-/**
- * @param {string} color
- * @param {string} [stop]
- * @return {boolean}
- */
-declare function isColorStop(color: string, stop?: string): boolean;
-export default isColorStop;
-//# sourceMappingURL=isColorStop.d.ts.map

package/types/isColorStop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isColorStop.d.ts","sourceRoot":"","sources":["../src/isColorStop.js"],"names":[],"mappings":"AAmEA;;;;GAIG;AACH,iBAAS,WAAW,CAAC,KAAK,EAJf,MAIe,EAAE,IAAI,AAH7B,CACA,EADQ,MAGqB,GAFpB,OAAO,CAIlB;eAEc,WAAW"}