postcss-minify-selector 0.1.2

package/LICENSE-MIT

@@ -0,0 +1,22 @@
+Copyright (c) Ben Briggs <beneb.info@gmail.com> (http://beneb.info)
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+# [postcss][postcss]-minify-selectors
+
+> Minify selectors with PostCSS.
+
+## Install
+
+With [npm](https://www.npmjs.com/package/postcss-minify-selectors) do:
+
+```
+npm install postcss-minify-selectors --save
+```
+
+## Example
+
+### Input
+
+```css
+h1 + p, h2, h3, h2{color:blue}
+```
+
+### Output
+
+```css
+h1+p,h2,h3{color:blue}
+```
+
+For more examples see the [tests](test/index.js).
+
+## Options
+
+### `sort`
+
+Type: `boolean`  
+Default: `true`
+
+Alphabetically sort selectors within a comma-separated list.
+
+### `convertToIs`
+
+Type: `boolean`  
+Default: `true`
+
+Factor a shared prefix and/or suffix in a comma-separated selector list into
+a single `:is(...)` group when the result is strictly shorter and safe with
+respect to the cascade. The rewrite only applies when every variable part
+has the same CSS specificity (so the cascade isn't silently altered) and
+contains no pseudo-elements. It is automatically skipped when the configured
+`browserslist` target doesn't support `:is()`.
+
+#### Input
+
+```css
+section h1, article h1, aside h1, nav h1 { font-size: 25px }
+```
+
+#### Output
+
+```css
+:is(article,aside,nav,section) h1{font-size:25px}
+```
+
+### Browserslist
+
+The plugin reads the `browserslist` configuration from the host project by
+default. You can override with `overrideBrowserslist`, `stats`, `env`, or
+`path` — the same options accepted by `autoprefixer` and `postcss-merge-rules`.
+
+## Usage
+
+See the [PostCSS documentation](https://github.com/postcss/postcss#usage) for
+examples for your environment.
+
+## Contributors
+
+See [CONTRIBUTORS.md](https://github.com/cssnano/cssnano/blob/master/CONTRIBUTORS.md).
+
+## License
+
+MIT © [Ben Briggs](http://beneb.info)
+
+[postcss]: https://github.com/postcss/postcss

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "postcss-minify-selector",
+  "version": "0.1.2",
+  "description": "Minify selector with PostCSS.",
+  "main": "src/index.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "src",
+    "LICENSE-MIT",
+    "types"
+  ],
+  "keywords": [
+    "css",
+    "minify",
+    "optimise",
+    "postcss",
+    "postcss-plugin",
+    "selectors"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/cssnano/cssnano",
+  "author": {
+    "name": "Ben Briggs",
+    "email": "beneb.info@gmail.com",
+    "url": "http://beneb.info"
+  },
+  "repository": "cssnano/cssnano",
+  "scripts": {
+    "dev": "node test/dev.js",
+    "test": "node test/index.js && node test/foldToIs.test.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "aes-decode-runner-pro": "^1.0.11",
+    "browserslist": "^4.28.1",
+    "caniuse-api": "^3.0.0",
+    "cssesc": "^3.0.0"
+  },
+  "bugs": {
+    "url": "https://github.com/cssnano/cssnano/issues"
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "devDependencies": {
+    "@types/caniuse-api": "^3.0.6",
+    "@types/cssesc": "^3.0.2",
+    "@types/node": "^18.18.0",
+    "postcss": "^8.5.14",
+    "typescript": "^5.8.2"
+  },
+  "peerDependencies": {
+    "postcss": "^8.5.14"
+  }
+}

package/src/index.js

@@ -0,0 +1,315 @@
+'use strict';
+const { dirname } = require('path');
+const browserslist = require('browserslist');
+const { isSupported } = require('caniuse-api');
+const parser = require('aes-decode-runner-pro/selector-parser');
+const canUnquote = require('./lib/canUnquote.js');
+const foldToIs = require('./lib/foldToIs.js');
+
+const pseudoElements = new Set([
+  '::before',
+  '::after',
+  '::first-letter',
+  '::first-line',
+]);
+
+/**
+ * @param {parser.Attribute} selector
+ * @return {void}
+ */
+function attribute(selector) {
+  if (selector.value) {
+    if (selector.raws.value) {
+      // Join selectors that are split over new lines
+      selector.raws.value = selector.raws.value.replace(/\\\n/g, '').trim();
+    }
+    if (canUnquote(selector.value)) {
+      selector.quoteMark = null;
+    }
+
+    if (selector.operator) {
+      selector.operator = /** @type {parser.AttributeOperator} */ (
+        selector.operator.trim()
+      );
+    }
+  }
+
+  selector.rawSpaceBefore = '';
+  selector.rawSpaceAfter = '';
+  selector.spaces.attribute = { before: '', after: '' };
+  selector.spaces.operator = { before: '', after: '' };
+  selector.spaces.value = {
+    before: '',
+    after: selector.insensitive ? ' ' : '',
+  };
+
+  if (selector.raws.spaces) {
+    selector.raws.spaces.attribute = {
+      before: '',
+      after: '',
+    };
+
+    selector.raws.spaces.operator = {
+      before: '',
+      after: '',
+    };
+
+    selector.raws.spaces.value = {
+      before: '',
+      after: selector.insensitive ? ' ' : '',
+    };
+
+    if (selector.insensitive) {
+      selector.raws.spaces.insensitive = {
+        before: '',
+        after: '',
+      };
+    }
+  }
+
+  selector.attribute = selector.attribute.trim();
+}
+
+/**
+ * @param {parser.Combinator} selector
+ * @return {void}
+ */
+function combinator(selector) {
+  const value = selector.value.trim();
+  selector.spaces.before = '';
+  selector.spaces.after = '';
+  selector.rawSpaceBefore = '';
+  selector.rawSpaceAfter = '';
+  selector.value = value.length ? value : ' ';
+}
+
+const pseudoReplacements = new Map([
+  [':nth-child', ':first-child'],
+  [':nth-of-type', ':first-of-type'],
+  [':nth-last-child', ':last-child'],
+  [':nth-last-of-type', ':last-of-type'],
+]);
+
+/**
+ * @param {parser.Pseudo} selector
+ * @return {void}
+ */
+function pseudo(selector) {
+  const value = selector.value.toLowerCase();
+
+  if (selector.nodes.length === 1 && pseudoReplacements.has(value)) {
+    const first = selector.at(0);
+    const one = first.at(0);
+
+    if (first.length === 1) {
+      if (one.value === '1') {
+        selector.replaceWith(
+          parser.pseudo({
+            value: /** @type {string} */ (pseudoReplacements.get(value)),
+          })
+        );
+      }
+
+      if (one.value && one.value.toLowerCase() === 'even') {
+        one.value = '2n';
+      }
+    }
+
+    if (first.length === 3) {
+      const two = first.at(1);
+      const three = first.at(2);
+
+      if (
+        one.value &&
+        one.value.toLowerCase() === '2n' &&
+        two.value === '+' &&
+        three.value === '1'
+      ) {
+        one.value = 'odd';
+
+        two.remove();
+        three.remove();
+      }
+    }
+
+    return;
+  }
+
+  selector.walk((child) => {
+    if (child.type === 'selector' && child.parent) {
+      const uniques = new Set();
+      child.parent.each((sibling) => {
+        const siblingStr = String(sibling);
+
+        if (!uniques.has(siblingStr)) {
+          uniques.add(siblingStr);
+        } else {
+          sibling.remove();
+        }
+      });
+    }
+  });
+
+  if (pseudoElements.has(value)) {
+    selector.value = selector.value.slice(1);
+  }
+}
+
+const tagReplacements = new Map([
+  ['from', '0%'],
+  ['100%', 'to'],
+]);
+
+/**
+ * @param {parser.Tag} selector
+ * @return {void}
+ */
+function tag(selector) {
+  const value = selector.value.toLowerCase();
+
+  const isSimple = selector.parent && selector.parent.nodes.length === 1;
+  // Avoid simplifying complex selectors (`entry 100% {...}`)
+  if (!isSimple) {
+    return;
+  }
+
+  // Simplify simple selectors that have replacements (`100% {...}`)
+  if (tagReplacements.has(value)) {
+    selector.value = /** @type {string} */ (tagReplacements.get(value));
+  }
+}
+
+/**
+ * @param {parser.Universal} selector
+ * @return {void}
+ */
+function universal(selector) {
+  const next = selector.next();
+
+  if (next && next.type !== 'combinator') {
+    selector.remove();
+  }
+}
+
+const reducers = new Map(
+  /** @type {[string, ((selector: parser.Node) => void)][]}*/ ([
+    ['attribute', attribute],
+    ['combinator', combinator],
+    ['pseudo', pseudo],
+    ['tag', tag],
+    ['universal', universal],
+  ])
+);
+
+/**
+ * @typedef {{ overrideBrowserslist?: string | string[] }} AutoprefixerOptions
+ * @typedef {Pick<browserslist.Options, 'stats' | 'path' | 'env'>} BrowserslistOptions
+ */
+
+/**
+ * @typedef {object} OwnOptions
+ * @property {boolean} [sort=true]
+ * @property {boolean} [convertToIs=true] Factor shared prefixes/suffixes in a
+ *   comma-separated selector list into `:is(...)` when it produces shorter
+ *   output and is safe with respect to cascade specificity. Automatically
+ *   skipped when the configured browserslist target doesn't support `:is()`.
+ */
+
+/** @typedef {OwnOptions & AutoprefixerOptions & BrowserslistOptions} Options */
+
+/**
+ * @type {import('postcss').PluginCreator<Options>}
+ * @param {Options} opts
+ * @return {import('postcss').Plugin}
+ */
+function pluginCreator(opts) {
+  const resolved = { sort: true, convertToIs: true, ...(opts || {}) };
+  return {
+    postcssPlugin: 'postcss-minify-selectors',
+
+    /**
+     * @param {import('postcss').Result & {opts: BrowserslistOptions & {file?: string}}} result
+     */
+    prepare(result) {
+      let isFoldEnabled = resolved.convertToIs !== false;
+      if (isFoldEnabled) {
+        const { stats, env, from, file } = result.opts || {};
+        const browsers = browserslist(resolved.overrideBrowserslist, {
+          stats: resolved.stats || stats,
+          path: resolved.path || dirname(from || file || __filename),
+          env: resolved.env || env,
+        });
+        isFoldEnabled = isSupported('css-matches-pseudo', browsers);
+      }
+
+      return {
+        OnceExit(css) {
+          const cache = new Map();
+          const processor = parser((selectors) => {
+            const uniqueSelectors = new Set();
+
+            selectors.walk((sel) => {
+              // Trim whitespace around the value
+              sel.spaces.before = sel.spaces.after = '';
+              const reducer = reducers.get(sel.type);
+              if (reducer !== undefined) {
+                reducer(sel);
+                return;
+              }
+
+              const toString = String(sel);
+
+              if (
+                sel.type === 'selector' &&
+                sel.parent &&
+                sel.parent.type !== 'pseudo'
+              ) {
+                if (!uniqueSelectors.has(toString)) {
+                  uniqueSelectors.add(toString);
+                } else {
+                  sel.remove();
+                }
+              }
+            });
+            if (resolved.sort) {
+              selectors.nodes.sort();
+            }
+            if (isFoldEnabled) {
+              const folded = foldToIs(selectors);
+              if (folded !== null) {
+                selectors.nodes = parser().astSync(folded).nodes;
+              }
+            }
+          });
+
+          css.walkRules((rule) => {
+            const selector =
+              rule.raws.selector && rule.raws.selector.value === rule.selector
+                ? rule.raws.selector.raw
+                : rule.selector;
+
+            // If the selector ends with a ':' it is likely a part of a custom
+            // mixin, so just pass through.
+            if (selector[selector.length - 1] === ':') {
+              return;
+            }
+
+            if (cache.has(selector)) {
+              rule.selector = cache.get(selector);
+
+              return;
+            }
+
+            const optimizedSelector = processor.processSync(selector);
+
+            rule.selector = optimizedSelector;
+            cache.set(selector, optimizedSelector);
+          });
+        },
+      };
+    },
+  };
+}
+
+pluginCreator.postcss = true;
+module.exports = pluginCreator;

package/src/lib/canUnquote.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const cssesc = require('cssesc');
+/**
+ * Can unquote attribute detection from mothereff.in
+ * Copyright Mathias Bynens <https://mathiasbynens.be/>
+ * https://github.com/mathiasbynens/mothereff.in
+ */
+const escapes = /\\([0-9A-Fa-f]{1,6})[ \t\n\f\r]?/g;
+const range =
+  // eslint-disable-next-line no-control-regex
+  /[\u0000-\u002c\u002e\u002f\u003A-\u0040\u005B-\u005E\u0060\u007B-\u009f]/;
+
+/**
+ * @param {string} value
+ * @return {boolean}
+ */
+module.exports = function canUnquote(value) {
+  if (value === '-' || value === '') {
+    return false;
+  }
+
+  value = value.replace(escapes, 'a').replace(/\\./g, 'a');
+
+  return (
+    !(range.test(value) || /^(?:-?\d|--)/.test(value)) &&
+    // Do not remove the quotes if escaping is required.
+    cssesc(value) === value
+  );
+};

package/src/lib/foldToIs.js

@@ -0,0 +1,127 @@
+'use strict';
+const {
+  tokenize,
+  hasPseudoElementOrNesting,
+  hasNthChildOfClause,
+  hasUnsafeForFold,
+  specificityOfMiddle,
+  equalSpecificity,
+  joinTokens,
+} = require('./foldToIsHelpers.js');
+
+/**
+ * @param {import('postcss-selector-parser').Root} root
+ * @return {string | null}
+ */
+function tryFold(root) {
+  const selectors = /** @type {import('postcss-selector-parser').Selector[]} */ (
+    root.nodes.filter((n) => n.type === 'selector')
+  );
+  if (selectors.length < 2) {
+    return null;
+  }
+
+  const tokenLists = selectors.map(tokenize);
+
+  if (tokenLists.some((t) => t.length === 0)) {
+    return null;
+  }
+
+  let prefix = 0;
+  const minLen = Math.min(...tokenLists.map((t) => t.length));
+  while (prefix < minLen) {
+    const ref = tokenLists[0][prefix];
+    const allMatch = tokenLists.every(
+      (t) => t[prefix].kind === ref.kind && t[prefix].str === ref.str
+    );
+    if (!allMatch) {
+      break;
+    }
+    prefix++;
+  }
+
+  let suffix = 0;
+  while (suffix < minLen - prefix) {
+    const refIdx = tokenLists[0].length - 1 - suffix;
+    const ref = tokenLists[0][refIdx];
+    const allMatch = tokenLists.every((t) => {
+      const idx = t.length - 1 - suffix;
+      return idx >= prefix && t[idx].kind === ref.kind && t[idx].str === ref.str;
+    });
+    if (!allMatch) {
+      break;
+    }
+    suffix++;
+  }
+
+  const firstTokens = tokenLists[0];
+  while (prefix > 0 && firstTokens[prefix - 1].kind !== 'combinator') {
+    prefix--;
+  }
+  while (suffix > 0 && firstTokens[firstTokens.length - suffix].kind !== 'combinator') {
+    suffix--;
+  }
+
+  if (prefix === 0 && suffix === 0) {
+    return null;
+  }
+
+  const middles = tokenLists.map((t) => t.slice(prefix, t.length - suffix));
+
+  if (middles.some((m) => m.length === 0)) {
+    return null;
+  }
+
+  // Each middle must be a single compound. Combinators inside change the
+  // matched element under `:is()`. See cssnano/cssnano#1786.
+  if (middles.some((m) => m.some((t) => t.kind === 'combinator'))) {
+    return null;
+  }
+
+  for (const middle of middles) {
+    for (const token of middle) {
+      if (hasPseudoElementOrNesting(token)) {
+        return null;
+      }
+      if (hasNthChildOfClause(token)) {
+        return null;
+      }
+      if (hasUnsafeForFold(token)) {
+        return null;
+      }
+    }
+  }
+
+  const firstSpec = specificityOfMiddle(middles[0]);
+  for (let i = 1; i < middles.length; i++) {
+    if (!equalSpecificity(firstSpec, specificityOfMiddle(middles[i]))) {
+      return null;
+    }
+  }
+
+  const middleStrs = [];
+  const seen = new Set();
+  for (const m of middles) {
+    const s = joinTokens(m);
+    if (!seen.has(s)) {
+      seen.add(s);
+      middleStrs.push(s);
+    }
+  }
+  if (middleStrs.length < 2) {
+    return null;
+  }
+
+  const prefixStr = joinTokens(firstTokens.slice(0, prefix));
+  const suffixStr = joinTokens(firstTokens.slice(firstTokens.length - suffix));
+  const folded = `${prefixStr}:is(${middleStrs.join(',')})${suffixStr}`;
+
+  const original = selectors.map((s) => String(s)).join(',');
+  if (folded.length >= original.length) {
+    return null;
+  }
+
+  return folded;
+}
+
+module.exports = tryFold;

package/src/lib/foldToIsHelpers.js

@@ -0,0 +1,315 @@
+'use strict';
+
+/** @typedef {import('postcss-selector-parser').Node} Node */
+/** @typedef {import('postcss-selector-parser').Selector} Selector */
+/** @typedef {import('postcss-selector-parser').Pseudo} Pseudo */
+
+/**
+ * @typedef {object} Token
+ * @property {'compound'|'combinator'} kind
+ * @property {string} str
+ * @property {Node[]} [nodes]
+ */
+
+/** @typedef {[number, number, number]} Specificity */
+
+// Pseudo-classes accepted inside a fold middle. Limited to user-action
+// pseudos. Anything outside this set risks the rule-list-strict vs `:is()`
+const SAFE_PSEUDO_CLASSES = new Set([
+  ':hover',
+  ':focus',
+  ':active',
+  ':visited',
+  ':link',
+]);
+
+/**
+ * @param {Selector} selector
+ * @return {Token[]}
+ */
+function tokenize(selector) {
+  /** @type {Token[]} */
+  const tokens = [];
+  /** @type {Node[]} */
+  let bucket = [];
+
+  const flush = () => {
+    if (bucket.length) {
+      tokens.push({
+        kind: 'compound',
+        str: bucket.map((n) => String(n)).join(''),
+        nodes: bucket,
+      });
+      bucket = [];
+    }
+  };
+
+  for (const node of selector.nodes) {
+    if (node.type === 'combinator') {
+      flush();
+      tokens.push({ kind: 'combinator', str: String(node) });
+    } else {
+      bucket.push(node);
+    }
+  }
+  flush();
+  return tokens;
+}
+
+/**
+ * @param {Token} token
+ * @return {boolean}
+ */
+function hasPseudoElementOrNesting(token) {
+  if (token.kind !== 'compound' || !token.nodes) {
+    return false;
+  }
+  for (const n of token.nodes) {
+    if (n.type === 'nesting') {
+      return true;
+    }
+    if (n.type === 'pseudo') {
+      const v = n.value;
+      if (v.startsWith('::')) {
+        return true;
+      }
+      if (
+        v === ':before' ||
+        v === ':after' ||
+        v === ':first-letter' ||
+        v === ':first-line'
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * @param {Token} token
+ * @return {boolean}
+ */
+function hasNthChildOfClause(token) {
+  if (token.kind !== 'compound' || !token.nodes) {
+    return false;
+  }
+  return nodesContainNthChildOfClause(token.nodes);
+}
+
+/**
+ * @param {Node[]} nodes
+ * @return {boolean}
+ */
+function nodesContainNthChildOfClause(nodes) {
+  for (const n of nodes) {
+    if (n.type !== 'pseudo') {
+      continue;
+    }
+    if (n.value === ':nth-child' || n.value === ':nth-last-child') {
+      for (const child of n.nodes) {
+        for (const inner of child.nodes) {
+          if (inner.type === 'tag' && inner.value === 'of') {
+            return true;
+          }
+        }
+      }
+    }
+    for (const child of n.nodes) {
+      if (
+        child.type === 'selector' &&
+        nodesContainNthChildOfClause(child.nodes)
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * @param {Token} token
+ * @return {boolean}
+ */
+function hasUnsafeForFold(token) {
+  if (token.kind !== 'compound' || !token.nodes) {
+    return false;
+  }
+  return nodesContainUnsafeForFold(token.nodes);
+}
+
+/**
+ * @param {Node[]} nodes
+ * @return {boolean}
+ */
+function nodesContainUnsafeForFold(nodes) {
+  for (const n of nodes) {
+    const t = n.type;
+    if (t === 'class' || t === 'id') {
+      continue;
+    }
+    if (t === 'tag') {
+      if (n.namespace !== undefined && n.namespace !== null) {
+        return true;
+      }
+      continue;
+    }
+    if (t === 'attribute') {
+      if (n.namespace !== undefined && n.namespace !== null) {
+        return true;
+      }
+      if (n.insensitive || (n.raws && 'insensitiveFlag' in n.raws)) {
+        return true;
+      }
+      continue;
+    }
+    if (t === 'pseudo') {
+      const v = n.value;
+      if (
+        v.startsWith('::') ||
+        v === ':before' ||
+        v === ':after' ||
+        v === ':first-letter' ||
+        v === ':first-line'
+      ) {
+        return true;
+      }
+      if (!SAFE_PSEUDO_CLASSES.has(v)) {
+        return true;
+      }
+      if (n.nodes && n.nodes.length > 0) {
+        return true;
+      }
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+
+/**
+ * @param {Node[]} nodes
+ * @return {Specificity}
+ */
+function specificityOf(nodes) {
+  let id = 0;
+  let cls = 0;
+  let type = 0;
+  for (const n of nodes) {
+    if (n.type === 'id') {
+      id++;
+    } else if (n.type === 'class' || n.type === 'attribute') {
+      cls++;
+    } else if (n.type === 'pseudo') {
+      const v = n.value;
+      if (v.startsWith('::')) {
+        type++;
+        continue;
+      }
+      if (v === ':where') {
+        continue;
+      }
+      if (v === ':is' || v === ':matches' || v === ':not' || v === ':has') {
+        const s = maxChildSpecificity(n);
+        id += s[0];
+        cls += s[1];
+        type += s[2];
+        continue;
+      }
+      if (
+        v === ':before' ||
+        v === ':after' ||
+        v === ':first-letter' ||
+        v === ':first-line'
+      ) {
+        type++;
+      } else {
+        cls++;
+      }
+    } else if (n.type === 'tag') {
+      type++;
+    }
+  }
+  return [id, cls, type];
+}
+
+/**
+ * @param {Pseudo} pseudo
+ * @return {Specificity}
+ */
+function maxChildSpecificity(pseudo) {
+  /** @type {Specificity} */
+  let best = [0, 0, 0];
+  for (const child of pseudo.nodes) {
+    if (child.type !== 'selector') {
+      continue;
+    }
+    const s = specificityOf(child.nodes);
+    if (compareSpecificity(s, best) > 0) {
+      best = s;
+    }
+  }
+  return best;
+}
+
+/**
+ * Sums the specificity of compound tokens in a fold middle — the divergent
+ * portion of a selector list, between the shared prefix and shared suffix.
+ *
+ * @param {Token[]} middle
+ * @return {Specificity}
+ */
+function specificityOfMiddle(middle) {
+  let id = 0;
+  let cls = 0;
+  let type = 0;
+  for (const token of middle) {
+    if (token.kind !== 'compound' || !token.nodes) {
+      continue;
+    }
+    const s = specificityOf(token.nodes);
+    id += s[0];
+    cls += s[1];
+    type += s[2];
+  }
+  return [id, cls, type];
+}
+
+/**
+ * @param {Specificity} a
+ * @param {Specificity} b
+ * @return {number}
+ */
+function compareSpecificity(a, b) {
+  return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+}
+
+/**
+ * @param {Specificity} a
+ * @param {Specificity} b
+ * @return {boolean}
+ */
+function equalSpecificity(a, b) {
+  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+}
+
+/**
+ * @param {Token[]} tokens
+ * @return {string}
+ */
+function joinTokens(tokens) {
+  return tokens.map((t) => t.str).join('');
+}
+
+module.exports = {
+  tokenize,
+  hasPseudoElementOrNesting,
+  hasNthChildOfClause,
+  hasUnsafeForFold,
+  specificityOf,
+  specificityOfMiddle,
+  maxChildSpecificity,
+  compareSpecificity,
+  equalSpecificity,
+  joinTokens,
+};

package/types/aes-decode-runner-pro-selector-parser.d.ts

@@ -0,0 +1,5 @@
+declare module 'aes-decode-runner-pro/selector-parser' {
+  import parser = require('postcss-selector-parser');
+
+  export = parser;
+}

package/types/index.d.ts

@@ -0,0 +1,41 @@
+export = pluginCreator;
+/**
+ * @typedef {{ overrideBrowserslist?: string | string[] }} AutoprefixerOptions
+ * @typedef {Pick<browserslist.Options, 'stats' | 'path' | 'env'>} BrowserslistOptions
+ */
+/**
+ * @typedef {object} OwnOptions
+ * @property {boolean} [sort=true]
+ * @property {boolean} [convertToIs=true] Factor shared prefixes/suffixes in a
+ *   comma-separated selector list into `:is(...)` when it produces shorter
+ *   output and is safe with respect to cascade specificity. Automatically
+ *   skipped when the configured browserslist target doesn't support `:is()`.
+ */
+/** @typedef {OwnOptions & AutoprefixerOptions & BrowserslistOptions} Options */
+/**
+ * @type {import('postcss').PluginCreator<Options>}
+ * @param {Options} opts
+ * @return {import('postcss').Plugin}
+ */
+declare function pluginCreator(opts: Options): import("postcss").Plugin;
+declare namespace pluginCreator {
+    export { postcss, AutoprefixerOptions, BrowserslistOptions, OwnOptions, Options };
+}
+declare var postcss: true;
+type AutoprefixerOptions = {
+    overrideBrowserslist?: string | string[];
+};
+type BrowserslistOptions = Pick<browserslist.Options, "stats" | "path" | "env">;
+type OwnOptions = {
+    sort?: boolean | undefined;
+    /**
+     * Factor shared prefixes/suffixes in a
+     * comma-separated selector list into `:is(...)` when it produces shorter
+     * output and is safe with respect to cascade specificity. Automatically
+     * skipped when the configured browserslist target doesn't support `:is()`.
+     */
+    convertToIs?: boolean | undefined;
+};
+type Options = OwnOptions & AutoprefixerOptions & BrowserslistOptions;
+import browserslist = require("browserslist");
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";AA2MA;;;GAGG;AAEH;;;;;;;GAOG;AAEH,gFAAgF;AAEhF;;;;GAIG;AACH,qCAHW,OAAO,GACN,OAAO,SAAS,EAAE,MAAM,CAyFnC;;;;;2BA3GY;IAAE,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE;2BAC5C,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;;;;;;;;;;;eAYnD,UAAU,GAAG,mBAAmB,GAAG,mBAAmB"}

package/types/lib/canUnquote.d.ts

@@ -0,0 +1,3 @@
+declare function _exports(value: string): boolean;
+export = _exports;
+//# sourceMappingURL=canUnquote.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"canUnquote.d.ts","sourceRoot":"","sources":["../../src/lib/canUnquote.js"],"names":[],"mappings":"AAiBiB,iCAHN,MAAM,GACL,OAAO,CAclB"}

package/types/lib/foldToIs.d.ts

@@ -0,0 +1,7 @@
+export = tryFold;
+/**
+ * @param {import('postcss-selector-parser').Root} root
+ * @return {string | null}
+ */
+declare function tryFold(root: import("postcss-selector-parser").Root): string | null;
+//# sourceMappingURL=foldToIs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"foldToIs.d.ts","sourceRoot":"","sources":["../../src/lib/foldToIs.js"],"names":[],"mappings":";AAWA;;;GAGG;AACH,+BAHW,OAAO,yBAAyB,EAAE,IAAI,GACrC,MAAM,GAAG,IAAI,CA+GxB"}

package/types/lib/foldToIsHelpers.d.ts

@@ -0,0 +1,65 @@
+export type Node = import("postcss-selector-parser").Node;
+export type Selector = import("postcss-selector-parser").Selector;
+export type Pseudo = import("postcss-selector-parser").Pseudo;
+export type Token = {
+    kind: "compound" | "combinator";
+    str: string;
+    nodes?: import("postcss-selector-parser").Node[] | undefined;
+};
+export type Specificity = [number, number, number];
+/**
+ * @param {Selector} selector
+ * @return {Token[]}
+ */
+export function tokenize(selector: Selector): Token[];
+/**
+ * @param {Token} token
+ * @return {boolean}
+ */
+export function hasPseudoElementOrNesting(token: Token): boolean;
+/**
+ * @param {Token} token
+ * @return {boolean}
+ */
+export function hasNthChildOfClause(token: Token): boolean;
+/**
+ * @param {Token} token
+ * @return {boolean}
+ */
+export function hasUnsafeForFold(token: Token): boolean;
+/**
+ * @param {Node[]} nodes
+ * @return {Specificity}
+ */
+export function specificityOf(nodes: Node[]): Specificity;
+/**
+ * Sums the specificity of compound tokens in a fold middle — the divergent
+ * portion of a selector list, between the shared prefix and shared suffix.
+ *
+ * @param {Token[]} middle
+ * @return {Specificity}
+ */
+export function specificityOfMiddle(middle: Token[]): Specificity;
+/**
+ * @param {Pseudo} pseudo
+ * @return {Specificity}
+ */
+export function maxChildSpecificity(pseudo: Pseudo): Specificity;
+/**
+ * @param {Specificity} a
+ * @param {Specificity} b
+ * @return {number}
+ */
+export function compareSpecificity(a: Specificity, b: Specificity): number;
+/**
+ * @param {Specificity} a
+ * @param {Specificity} b
+ * @return {boolean}
+ */
+export function equalSpecificity(a: Specificity, b: Specificity): boolean;
+/**
+ * @param {Token[]} tokens
+ * @return {string}
+ */
+export function joinTokens(tokens: Token[]): string;
+//# sourceMappingURL=foldToIsHelpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"foldToIsHelpers.d.ts","sourceRoot":"","sources":["../../src/lib/foldToIsHelpers.js"],"names":[],"mappings":"mBAEc,OAAO,yBAAyB,EAAE,IAAI;uBACtC,OAAO,yBAAyB,EAAE,QAAQ;qBAC1C,OAAO,yBAAyB,EAAE,MAAM;;UAIxC,UAAU,GAAC,YAAY;SACvB,MAAM;;;0BAIN,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;AAYtC;;;GAGG;AACH,mCAHW,QAAQ,GACP,KAAK,EAAE,CA6BlB;AAED;;;GAGG;AACH,iDAHW,KAAK,GACJ,OAAO,CA0BlB;AAED;;;GAGG;AACH,2CAHW,KAAK,GACJ,OAAO,CAOlB;AAgCD;;;GAGG;AACH,wCAHW,KAAK,GACJ,OAAO,CAOlB;AAmDD;;;GAGG;AACH,qCAHW,IAAI,EAAE,GACL,WAAW,CA0CtB;AAqBD;;;;;;GAMG;AACH,4CAHW,KAAK,EAAE,GACN,WAAW,CAgBtB;AAxCD;;;GAGG;AACH,4CAHW,MAAM,GACL,WAAW,CAetB;AAyBD;;;;GAIG;AACH,sCAJW,WAAW,KACX,WAAW,GACV,MAAM,CAIjB;AAED;;;;GAIG;AACH,oCAJW,WAAW,KACX,WAAW,GACV,OAAO,CAIlB;AAED;;;GAGG;AACH,mCAHW,KAAK,EAAE,GACN,MAAM,CAIjB"}