postcss-merge-rules 8.0.1 → 8.0.3

package/LICENSE-MIT

@@ -1,4 +1,4 @@
-Copyright (c) Ben Briggs <beneb.info@gmail.com> (http://beneb.info)
+Copyright (c) Ben Briggs <beneb.info@gmail.com> (https://beneb.info)
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

package/README.md

@@ -100,6 +100,6 @@ See [CONTRIBUTORS.md](https://github.com/cssnano/cssnano/blob/master/CONTRIBUTOR
 
 ## License
 
-MIT © [Ben Briggs](http://beneb.info)
+MIT © [Ben Briggs](https://beneb.info)
 
 [postcss]: https://github.com/postcss/postcss

package/package.json

@@ -1,9 +1,25 @@
 {
   "name": "postcss-merge-rules",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "description": "Merge CSS rules with PostCSS.",
-  "types": "types/index.d.ts",
-  "main": "src/index.js",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./src": "./src/index.js",
+    "./src/index": "./src/index.js",
+    "./src/index.js": "./src/index.js",
+    "./src/lib/ensureCompatibility.js": "./src/lib/ensureCompatibility.js",
+    "./src/lib/ensureCompatibility": "./src/lib/ensureCompatibility.js",
+    "./package.json": "./package.json"
+  },
+  "imports": {
+    "#getBrowsersList": {
+      "node": "./src/lib/computeBrowsersToSupport.js",
+      "default": "./src/lib/getBrowsersForWebBuild.js"
+    }
+  },
   "files": [
     "LICENSE-MIT",
     "src",
@@ -20,14 +36,17 @@
   "author": {
     "name": "Ben Briggs",
     "email": "beneb.info@gmail.com",
-    "url": "http://beneb.info"
+    "url": "https://beneb.info"
+  },
+  "repository": {
+    "type": "git",
+    "url": "cssnano/cssnano"
   },
-  "repository": "cssnano/cssnano",
   "dependencies": {
-    "browserslist": "^4.28.2",
+    "browserslist": "^4.28.8",
     "caniuse-api": "^4.0.0",
-    "postcss-selector-parser": "^7.1.2",
-    "cssnano-utils": "^6.0.1"
+    "postcss-selector-parser": "^7.1.5",
+    "cssnano-utils": "^6.0.3"
   },
   "bugs": {
     "url": "https://github.com/cssnano/cssnano/issues"
@@ -36,11 +55,14 @@
     "node": "^22.11.0 || ^24.11.0 || >=26.0"
   },
   "devDependencies": {
-    "postcss": "^8.5.15",
+    "postcss": "^8.5.26",
     "postcss-simple-vars": "^7.0.1",
-    "postcss-discard-comments": "^8.0.1"
+    "postcss-discard-comments": "^8.0.3"
   },
   "peerDependencies": {
-    "postcss": "^8.5.15"
+    "postcss": "^8.5.26"
+  },
+  "scripts": {
+    "test": "node --test"
   }
 }

package/src/index.js

@@ -1,16 +1,19 @@
 'use strict';
-const { dirname } = require('path');
-const browserslist = require('browserslist');
+
+const getBrowsersList = require('#getBrowsersList');
+
+/** @import browserslist from 'browserslist' */
+
 const { sameParent } = require('cssnano-utils');
 const {
   ensureCompatibility,
   sameVendor,
   noVendor,
 } = require('./lib/ensureCompatibility');
-
+/** @import {Declaration, Rule} from 'postcss' */
 /**
- * @param {import('postcss').Declaration} a
- * @param {import('postcss').Declaration} b
+ * @param {Declaration} a
+ * @param {Declaration} b
  * @return {boolean}
  */
 function declarationIsEqual(a, b) {
@@ -20,8 +23,8 @@ function declarationIsEqual(a, b) {
 }
 
 /**
- * @param {import('postcss').Declaration[]} array
- * @param {import('postcss').Declaration} decl
+ * @param {Declaration[]} array
+ * @param {Declaration} decl
  * @return {number}
  */
 function indexOfDeclaration(array, decl) {
@@ -30,10 +33,10 @@ function indexOfDeclaration(array, decl) {
 
 /**
  * Returns filtered array of matched or unmatched declarations
- * @param {import('postcss').Declaration[]} a
- * @param {import('postcss').Declaration[]} b
+ * @param {Declaration[]} a
+ * @param {Declaration[]} b
  * @param {boolean} [not=false]
- * @return {import('postcss').Declaration[]}
+ * @return {Declaration[]}
  */
 function intersect(a, b, not) {
   return a.filter((c) => {
@@ -43,8 +46,8 @@ function intersect(a, b, not) {
 }
 
 /**
- * @param {import('postcss').Declaration[]} a
- * @param {import('postcss').Declaration[]} b
+ * @param {Declaration[]} a
+ * @param {Declaration[]} b
  * @return {boolean}
  */
 function sameDeclarationsAndOrder(a, b) {
@@ -60,17 +63,17 @@ function sameDeclarationsAndOrder(a, b) {
  *
  * @typedef {Object} RuleMeta
  * @property {string[]} selectors - Array of selector strings for the rule
- * @property {import('postcss').Declaration[]} declarations - Array of declaration nodes for the rule
+ * @property {Declaration[]} declarations - Array of declaration nodes for the rule
  * @property {boolean} dirty - Whether the selectors have been modified and need flushing
  */
 
 /**
- * @param {import('postcss').Rule} ruleA
- * @param {import('postcss').Rule} ruleB
+ * @param {Rule} ruleA
+ * @param {Rule} ruleB
  * @param {string[]} browsers
  * @param {Map<string, boolean>} compatibilityCache
- * @param {WeakSet<import('postcss').Rule>} ruleCache
- * @param {WeakMap<import('postcss').Rule, RuleMeta>} ruleMeta
+ * @param {WeakSet<Rule>} ruleCache
+ * @param {WeakMap<Rule, RuleMeta>} ruleMeta
  * @return {boolean}
  */
 function canMerge(
@@ -131,7 +134,7 @@ function isRuleOrAtRule(node) {
 }
 /**
  * @param {import('postcss').ChildNode} node
- * @return {node is import('postcss').Declaration}
+ * @return {node is Declaration}
  */
 function isDeclaration(node) {
   return node.type === 'decl';
@@ -143,8 +146,8 @@ function isDeclaration(node) {
  * This metadata caches selectors and declarations to avoid expensive AST
  * re-parsing, especially for the selectors.
  *
- * @param {import('postcss').Rule} rule The PostCSS rule to get metadata for.
- * @param {WeakMap<import('postcss').Rule, RuleMeta>} [ruleMeta] The metadata cache.
+ * @param {Rule} rule The PostCSS rule to get metadata for.
+ * @param {WeakMap<Rule, RuleMeta>} [ruleMeta] The metadata cache.
  * @return {RuleMeta} The rule's virtual metadata.
  */
 function getMeta(rule, ruleMeta) {
@@ -170,8 +173,8 @@ function getMeta(rule, ruleMeta) {
 /**
  * Commits virtual metadata changes back to the actual PostCSS rule.
  *
- * @param {import('postcss').Rule} rule The PostCSS rule to flush.
- * @param {WeakMap<import('postcss').Rule, RuleMeta>} ruleMeta The metadata cache.
+ * @param {Rule} rule The PostCSS rule to flush.
+ * @param {WeakMap<Rule, RuleMeta>} ruleMeta The metadata cache.
  */
 function flush(rule, ruleMeta) {
   const meta = ruleMeta.get(rule);
@@ -182,15 +185,15 @@ function flush(rule, ruleMeta) {
 }
 
 /**
- * @param {import('postcss').Rule} rule
- * @return {import('postcss').Declaration[]}
+ * @param {Rule} rule
+ * @return {Declaration[]}
  */
 function getDecls(rule) {
   return rule.nodes.filter(isDeclaration);
 }
 
 /**
- * @param {...import('postcss').Rule} rules
+ * @param {...Rule} rules
  * @return {number}
  */
 function ruleLength(...rules) {
@@ -275,8 +278,8 @@ function isConflictingProp(propA, propB) {
 }
 
 /**
- * @param {import('postcss').Rule} first
- * @param {import('postcss').Rule} second
+ * @param {Rule} first
+ * @param {Rule} second
  * @return {boolean} merged
  */
 function mergeParents(first, second) {
@@ -298,31 +301,10 @@ function mergeParents(first, second) {
 }
 
 /**
- * @param {import('postcss').Rule} first
- * @param {import('postcss').Rule} second
- * @param {string[]} browsers
- * @param {Map<string, boolean>} compatibilityCache
- * @param {WeakSet<import('postcss').Rule>} ruleCache
- * @param {WeakMap<import('postcss').Rule, RuleMeta>} ruleMeta
- * @return {import('postcss').Rule} mergedRule
+ * @param {Rule} second
+ * @return {Rule | null}
  */
-function partialMerge(
-  first,
-  second,
-  browsers,
-  compatibilityCache,
-  ruleCache,
-  ruleMeta
-) {
-  if (ruleMeta) {
-    flush(first, ruleMeta);
-  }
-  const metaFirst = getMeta(first, ruleMeta);
-  const metaSecond = getMeta(second, ruleMeta);
-  let intersection = intersect(metaFirst.declarations, metaSecond.declarations);
-  if (intersection.length === 0) {
-    return second;
-  }
+function getNextRule(second) {
   let nextRule = second.next();
   if (!nextRule) {
     // Grab next cousin
@@ -333,9 +315,32 @@ function partialMerge(
       ).next();
     nextRule = parentSibling && parentSibling.nodes && parentSibling.nodes[0];
   }
+  return nextRule?.type === 'rule' ? nextRule : null;
+}
+
+/**
+ * @param {Rule} first
+ * @param {Rule} second
+ * @param {Declaration[]} intersection
+ * @param {string[]} browsers
+ * @param {Map<string, boolean>} compatibilityCache
+ * @param {WeakSet<Rule>} ruleCache
+ * @param {WeakMap<Rule, RuleMeta>} ruleMeta
+ * @return {{first: Rule, second: Rule, intersection: Declaration[]}}
+ */
+function mergeWithNextRule(
+  first,
+  second,
+  intersection,
+  browsers,
+  compatibilityCache,
+  ruleCache,
+  ruleMeta
+) {
+  const nextRule = getNextRule(second);
   if (
-    nextRule?.type === 'rule' &&
-    canMerge(
+    !nextRule ||
+    !canMerge(
       second,
       nextRule,
       browsers,
@@ -344,24 +349,28 @@ function partialMerge(
       ruleMeta
     )
   ) {
-    const metaNext = getMeta(nextRule, ruleMeta);
-    let nextIntersection = intersect(
-      metaSecond.declarations,
-      metaNext.declarations
-    );
-    if (nextIntersection.length > intersection.length) {
-      mergeParents(second, nextRule);
-      first = second;
-      second = nextRule;
-      intersection = nextIntersection;
-    }
+    return { first, second, intersection };
   }
 
-  const metaFirstActual = getMeta(first, ruleMeta);
-  const metaSecondActual = getMeta(second, ruleMeta);
-  let firstDecls = [...metaFirstActual.declarations];
-  let secondDecls = [...metaSecondActual.declarations];
+  const nextIntersection = intersect(
+    getMeta(second, ruleMeta).declarations,
+    getMeta(nextRule, ruleMeta).declarations
+  );
+  if (nextIntersection.length <= intersection.length) {
+    return { first, second, intersection };
+  }
+
+  mergeParents(second, nextRule);
+  return { first: second, second: nextRule, intersection: nextIntersection };
+}
 
+/**
+ * @param {Declaration[]} intersection
+ * @param {Declaration[]} firstDecls
+ * @param {Declaration[]} secondDecls
+ * @return {Declaration[]}
+ */
+function filterIntersections(intersection, firstDecls, secondDecls) {
   // Filter out intersections with later conflicts in First
   intersection = intersection.filter((decl, intersectIndex) => {
     const indexOfDecl = indexOfDeclaration(firstDecls, decl);
@@ -383,7 +392,7 @@ function partialMerge(
   });
 
   // Filter out intersections with previous conflicts in Second
-  intersection = intersection.filter((decl) => {
+  return intersection.filter((decl) => {
     const nextConflictIndex = secondDecls.findIndex((d) =>
       isConflictingProp(d.prop, decl.prop)
     );
@@ -405,15 +414,20 @@ function partialMerge(
     secondDecls.splice(nextConflictIndex, 1);
     return true;
   });
+}
 
-  if (intersection.length === 0) {
-    // Nothing to merge
-    return second;
-  }
-
+/**
+ * @param {Rule} first
+ * @param {Rule} second
+ * @param {Declaration[]} intersection
+ * @param {WeakSet<Rule>} ruleCache
+ * @param {WeakMap<Rule, RuleMeta>} ruleMeta
+ * @return {Rule}
+ */
+function buildMergedRule(first, second, intersection, ruleCache, ruleMeta) {
   const receivingBlock = second.clone();
-  const firstSelectors = metaFirstActual.selectors;
-  const secondSelectors = metaSecondActual.selectors;
+  const firstSelectors = getMeta(first, ruleMeta).selectors;
+  const secondSelectors = getMeta(second, ruleMeta).selectors;
 
   receivingBlock.selector = [...firstSelectors, ...secondSelectors].join();
   receivingBlock.nodes = [];
@@ -426,9 +440,9 @@ function partialMerge(
   const secondClone = second.clone({ selectors: secondSelectors });
 
   /**
-   * @param {function(import('postcss').Declaration):void} callback
+   * @param {(decl: Declaration) => void} callback
    * @this void
-   * @return {function(import('postcss').Declaration)}
+   * @return {(decl: Declaration) => void}
    */
   function moveDecl(callback) {
     return (decl) => {
@@ -438,10 +452,15 @@ function partialMerge(
     };
   }
   firstClone.walkDecls(
-    moveDecl((decl) => {
-      decl.remove();
-      receivingBlock.append(decl);
-    })
+    moveDecl(
+      /**
+       * @param {Declaration} decl
+       */
+      (decl) => {
+        decl.remove();
+        receivingBlock.append(decl);
+      }
+    )
   );
   secondClone.walkDecls(moveDecl((decl) => decl.remove()));
 
@@ -456,11 +475,11 @@ function partialMerge(
   if (merged < original) {
     first.replaceWith(firstClone);
     second.replaceWith(secondClone);
-    [firstClone, receivingBlock, secondClone].forEach((r) => {
+    for (const r of [firstClone, receivingBlock, secondClone]) {
       if (r.nodes.length === 0) {
         r.remove();
       }
-    });
+    }
     if (!secondClone.parent) {
       ruleCache?.add(receivingBlock);
       return receivingBlock;
@@ -470,21 +489,75 @@ function partialMerge(
     ruleMeta?.delete(first);
     ruleMeta?.delete(second);
     return secondClone;
-  } else {
-    receivingBlock.remove();
+  }
+
+  receivingBlock.remove();
+  return second;
+}
+
+/**
+ * @param {Rule} first
+ * @param {Rule} second
+ * @param {string[]} browsers
+ * @param {Map<string, boolean>} compatibilityCache
+ * @param {WeakSet<Rule>} ruleCache
+ * @param {WeakMap<Rule, RuleMeta>} ruleMeta
+ * @return {Rule} mergedRule
+ */
+function partialMerge(
+  first,
+  second,
+  browsers,
+  compatibilityCache,
+  ruleCache,
+  ruleMeta
+) {
+  if (ruleMeta) {
+    flush(first, ruleMeta);
+  }
+  const metaFirst = getMeta(first, ruleMeta);
+  const metaSecond = getMeta(second, ruleMeta);
+  let intersection = intersect(metaFirst.declarations, metaSecond.declarations);
+  if (intersection.length === 0) {
     return second;
   }
+  const mergedNext = mergeWithNextRule(
+    first,
+    second,
+    intersection,
+    browsers,
+    compatibilityCache,
+    ruleCache,
+    ruleMeta
+  );
+  first = mergedNext.first;
+  second = mergedNext.second;
+  intersection = mergedNext.intersection;
+
+  const metaFirstActual = getMeta(first, ruleMeta);
+  const metaSecondActual = getMeta(second, ruleMeta);
+  const firstDecls = [...metaFirstActual.declarations];
+  const secondDecls = [...metaSecondActual.declarations];
+
+  intersection = filterIntersections(intersection, firstDecls, secondDecls);
+
+  if (intersection.length === 0) {
+    // Nothing to merge
+    return second;
+  }
+
+  return buildMergedRule(first, second, intersection, ruleCache, ruleMeta);
 }
 
 /**
  * @param {string[]} browsers
  * @param {Map<string, boolean>} compatibilityCache
- * @param {WeakSet<import('postcss').Rule>} ruleCache
- * @param {WeakMap<import('postcss').Rule, RuleMeta>} ruleMeta
- * @return {{ merger: function(import('postcss').Rule): void, clean: function(): void }}
+ * @param {WeakSet<Rule>} ruleCache
+ * @param {WeakMap<Rule, RuleMeta>} ruleMeta
+ * @return {{ merger: (rule: Rule) => void, clean: () => void }}
  */
 function selectorMerger(browsers, compatibilityCache, ruleCache, ruleMeta) {
-  /** @type {import('postcss').Rule | null} */
+  /** @type {Rule | null} */
   let cache = null;
   return {
     merger(rule) {
@@ -550,7 +623,7 @@ function selectorMerger(browsers, compatibilityCache, ruleCache, ruleMeta) {
             node.remove();
             return;
           }
-          /** @type {import('postcss').Rule} */ (cache).append(node);
+          /** @type {Rule} */ (cache).append(node);
         });
         getMeta(cache, ruleMeta).declarations = getDecls(cache);
         rule.remove();
@@ -584,7 +657,6 @@ function selectorMerger(browsers, compatibilityCache, ruleCache, ruleMeta) {
  */
 
 /**
- * @type {import('postcss').PluginCreator<Options>}
  * @param {Options} opts
  * @return {import('postcss').Plugin}
  */
@@ -597,11 +669,7 @@ function pluginCreator(opts = {}) {
      */
     prepare(result) {
       const { stats, env, from, file } = result.opts || {};
-      const browsers = browserslist(opts.overrideBrowserslist, {
-        stats: opts.stats || stats,
-        path: opts.path || dirname(from || file || __filename),
-        env: opts.env || env,
-      });
+      const browsers = getBrowsersList(opts, stats, from, file, env);
 
       const compatibilityCache = new Map();
 
@@ -610,6 +678,9 @@ function pluginCreator(opts = {}) {
       const ruleMeta = new WeakMap();
 
       return {
+        /**
+         * @param {import('postcss').Root} css
+         */
         OnceExit(css) {
           const { merger, clean } = selectorMerger(
             browsers,
@@ -626,4 +697,6 @@ function pluginCreator(opts = {}) {
 }
 
 pluginCreator.postcss = true;
-module.exports = pluginCreator;
+module.exports = /** @type {import('postcss').PluginCreator<Options>} */ (
+  pluginCreator
+);

package/src/lib/computeBrowsersToSupport.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const browserslist = require('browserslist');
+const { dirname } = require('node:path');
+
+/**
+ *
+ * @param {{overrideBrowserslist?: string | string[] | undefined, stats?: browserslist.Options["stats"], path?: browserslist.Options["path"], env?: browserslist.Options["env"]}} options
+ * @param {browserslist.Options["stats"]} stats
+ * @param {string|undefined} from
+ * @param {string} [file]
+ * @param {browserslist.Options["env"]} [env]
+ * @returns {string[]}
+ */
+module.exports = function computeBrowsersToSupport(
+  options,
+  stats,
+  from,
+  file,
+  env
+) {
+  return browserslist(options.overrideBrowserslist, {
+    stats: options.stats || stats,
+    path: options.path || dirname(from || file || __filename),
+    env: options.env || env,
+  });
+};

package/src/lib/ensureCompatibility.js

@@ -26,14 +26,15 @@ function filterPrefixes(selector) {
   return selector.match(vendorPrefix);
 }
 
+const inputPlaceholderRegex = /-ms-input-placeholder/i;
 /**
  * Internet Explorer use :-ms-input-placeholder.
  * Microsoft Edge use ::-ms-input-placeholder.
  *
- * @type {(selector: string) => number}
+ * @type {(selector: string) => boolean}
  */
 const findMsInputPlaceholder = (selector) =>
-  ~selector.search(/-ms-input-placeholder/i);
+  inputPlaceholderRegex.test(selector);
 
 /**
  * @param {string[]} selectorsA
@@ -42,9 +43,9 @@ const findMsInputPlaceholder = (selector) =>
  */
 function sameVendor(selectorsA, selectorsB) {
   /** @type {(selectors: string[]) => string} */
-  let same = (selectors) => selectors.map(filterPrefixes).join();
+  const same = (selectors) => selectors.map(filterPrefixes).join();
   /** @type {(selectors: string[]) => string | undefined} */
-  let findMsVendor = (selectors) => selectors.find(findMsInputPlaceholder);
+  const findMsVendor = (selectors) => selectors.find(findMsInputPlaceholder);
   return (
     same(selectorsA) === same(selectorsB) &&
     !(findMsVendor(selectorsA) && findMsVendor(selectorsB))
@@ -177,7 +178,7 @@ function ensureCompatibility(selectors, browsers, compatibilityCache) {
         const { type, value } = node;
         if (type === 'pseudo') {
           const entry =
-            pseudoElements[/** @type {keyof pseudoElements} */ (value)];
+            pseudoElements[/** @type keyof typeof pseudoElements*/ (value)];
           if (!entry && noVendor(value)) {
             compatible = false;
           }

package/src/lib/getBrowsersForWebBuild.js

@@ -0,0 +1,35 @@
+'use strict';
+
+module.exports = function () {
+  return [
+    'and_chr 150',
+    'and_ff 152',
+    'and_qq 14.9',
+    'and_uc 15.5',
+    'android 150',
+    'chrome 150',
+    'chrome 149',
+    'chrome 148',
+    'chrome 118',
+    'chrome 109',
+    'edge 150',
+    'edge 149',
+    'edge 148',
+    'firefox 152',
+    'firefox 151',
+    'firefox 140',
+    'ios_saf 26.5',
+    'ios_saf 26.4',
+    'ios_saf 26.3',
+    'ios_saf 18.5-18.7',
+    'kaios 3.0-3.1',
+    'op_mob 80',
+    'opera 131',
+    'opera 127',
+    'safari 26.5',
+    'safari 26.4',
+    'safari 26.3',
+    'samsung 30',
+    'samsung 29',
+  ];
+};

package/types/index.d.ts

@@ -1,24 +1,8 @@
-export = pluginCreator;
-/**
- * @typedef {{ overrideBrowserslist?: string | string[] }} AutoprefixerOptions
- * @typedef {Pick<browserslist.Options, 'stats' | 'path' | 'env'>} BrowserslistOptions
- * @typedef {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, RuleMeta, AutoprefixerOptions, BrowserslistOptions, Options };
-}
-declare var postcss: true;
-/**
- * RuleMeta stores metadata about a `Rule` during the merging process.
- * It tracks selectors and declarations without re-parsing the AST many times.
- */
-type RuleMeta = {
+declare const _exports: import("postcss").PluginCreator<Options>;
+export = _exports;
+import type browserslist from 'browserslist';
+import type { Declaration } from 'postcss';
+export type RuleMeta = {
     /**
      * - Array of selector strings for the rule
      */
@@ -26,16 +10,15 @@ type RuleMeta = {
     /**
      * - Array of declaration nodes for the rule
      */
-    declarations: import("postcss").Declaration[];
+    declarations: Declaration[];
     /**
      * - Whether the selectors have been modified and need flushing
      */
     dirty: boolean;
 };
-type AutoprefixerOptions = {
+export type AutoprefixerOptions = {
     overrideBrowserslist?: string | string[];
 };
-type BrowserslistOptions = Pick<browserslist.Options, "stats" | "path" | "env">;
-type Options = AutoprefixerOptions & BrowserslistOptions;
-import browserslist = require("browserslist");
+export type BrowserslistOptions = Pick<browserslist.Options, 'stats' | 'path' | 'env'>;
+export type Options = AutoprefixerOptions & BrowserslistOptions;
 //# 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":";AAmkBA;;;;GAIG;AAEH;;;;GAIG;AACH,sCAHW,OAAO,GACN,OAAO,SAAS,EAAE,MAAM,CAqCnC;;;;;;;;;;;;;eApjBa,MAAM,EAAE;;;;kBACR,OAAO,SAAS,EAAE,WAAW,EAAE;;;;WAC/B,OAAO;;2BAqgBR;IAAE,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE;2BAC5C,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;eACpD,mBAAmB,GAAG,mBAAmB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";;AAII,OAAQ,KAAA,YAAY,MAAM,cAAc,CAAA;AAQxC,OAAQ,KAAA,EAAC,WAAW,EAAO,MAAM,SAAS,CAAA;AAmD3C,YAAkB,QAAQ,GAC1B;;;;IAAqB,SAAS,EAAnB,MAAM,EAAE,CACnB;;;;IAA0B,YAAY,EAA3B,WAAW,EAAE,CACxB;;;;IAAoB,KAAK,EAAd,OAAO,CACpB;CAAA,CAAA;AA0kBE,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"}

package/types/lib/computeBrowsersToSupport.d.ts

@@ -0,0 +1,18 @@
+export = computeBrowsersToSupport;
+/**
+ *
+ * @param {{overrideBrowserslist?: string | string[] | undefined, stats?: browserslist.Options["stats"], path?: browserslist.Options["path"], env?: browserslist.Options["env"]}} options
+ * @param {browserslist.Options["stats"]} stats
+ * @param {string|undefined} from
+ * @param {string} [file]
+ * @param {browserslist.Options["env"]} [env]
+ * @returns {string[]}
+ */
+declare function computeBrowsersToSupport(options: {
+    overrideBrowserslist?: string | string[] | undefined;
+    stats?: browserslist.Options["stats"];
+    path?: browserslist.Options["path"];
+    env?: browserslist.Options["env"];
+}, stats: browserslist.Options["stats"], from: string | undefined, file?: string, env?: browserslist.Options["env"]): string[];
+import browserslist = require('browserslist');
+//# sourceMappingURL=computeBrowsersToSupport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"computeBrowsersToSupport.d.ts","sourceRoot":"","sources":["../../src/lib/computeBrowsersToSupport.js"],"names":[],"mappings":";AAKA;;;;;;;;GAQG;0CAED,OAAO,EARE;IAAC,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;IAAC,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAAC,GAAG,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;CAQtK,EACP,KAAK,EARI,YAAY,CAAC,OAAO,CAAC,OAAO,CAQhC,EACL,IAAI,EARK,MAAM,GAAC,SAQZ,EACJ,IAAI,AARH,CACA,EADQ,MAQL,EACJ,GAAG,AARF,CACA,EADQ,YAAY,CAAC,OAAO,CAAC,KAAK,CAQhC,GAPQ,MAAM,EAAE;OAVf,YAAY,WAAW,cAAc"}

package/types/lib/ensureCompatibility.d.ts

@@ -1,72 +1,78 @@
+declare const _exports: {
+    sameVendor: typeof sameVendor;
+    noVendor: typeof noVendor;
+    pseudoElements: {
+        ':active': string;
+        ':after': string;
+        ':any-link': string;
+        ':before': string;
+        ':checked': string;
+        ':default': string;
+        ':dir': string;
+        ':disabled': string;
+        ':empty': string;
+        ':enabled': string;
+        ':first-child': string;
+        ':first-letter': string;
+        ':first-line': string;
+        ':first-of-type': string;
+        ':focus': string;
+        ':focus-within': string;
+        ':focus-visible': string;
+        ':has': string;
+        ':hover': string;
+        ':in-range': string;
+        ':indeterminate': string;
+        ':invalid': string;
+        ':is': string;
+        ':lang': string;
+        ':last-child': string;
+        ':last-of-type': string;
+        ':link': string;
+        ':matches': string;
+        ':not': string;
+        ':nth-child': string;
+        ':nth-last-child': string;
+        ':nth-last-of-type': string;
+        ':nth-of-type': string;
+        ':only-child': string;
+        ':only-of-type': string;
+        ':optional': string;
+        ':out-of-range': string;
+        ':placeholder-shown': string;
+        ':required': string;
+        ':root': string;
+        ':target': string;
+        '::after': string;
+        '::backdrop': string;
+        '::before': string;
+        '::first-letter': string;
+        '::first-line': string;
+        '::marker': string;
+        '::placeholder': string;
+        '::selection': string;
+        ':valid': string;
+        ':visited': string;
+    };
+    ensureCompatibility: typeof ensureCompatibility;
+};
+export = _exports;
 /**
  * @param {string[]} selectorsA
  * @param {string[]} selectorsB
  * @return {boolean}
  */
-export function sameVendor(selectorsA: string[], selectorsB: string[]): boolean;
+declare function sameVendor(selectorsA: string[], selectorsB: string[]): boolean;
 /**
  * @param {string} selector
  * @return {boolean}
  */
-export function noVendor(selector: string): boolean;
-export const pseudoElements: {
-    ':active': string;
-    ':after': string;
-    ':any-link': string;
-    ':before': string;
-    ':checked': string;
-    ':default': string;
-    ':dir': string;
-    ':disabled': string;
-    ':empty': string;
-    ':enabled': string;
-    ':first-child': string;
-    ':first-letter': string;
-    ':first-line': string;
-    ':first-of-type': string;
-    ':focus': string;
-    ':focus-within': string;
-    ':focus-visible': string;
-    ':has': string;
-    ':hover': string;
-    ':in-range': string;
-    ':indeterminate': string;
-    ':invalid': string;
-    ':is': string;
-    ':lang': string;
-    ':last-child': string;
-    ':last-of-type': string;
-    ':link': string;
-    ':matches': string;
-    ':not': string;
-    ':nth-child': string;
-    ':nth-last-child': string;
-    ':nth-last-of-type': string;
-    ':nth-of-type': string;
-    ':only-child': string;
-    ':only-of-type': string;
-    ':optional': string;
-    ':out-of-range': string;
-    ':placeholder-shown': string;
-    ':required': string;
-    ':root': string;
-    ':target': string;
-    '::after': string;
-    '::backdrop': string;
-    '::before': string;
-    '::first-letter': string;
-    '::first-line': string;
-    '::marker': string;
-    '::placeholder': string;
-    '::selection': string;
-    ':valid': string;
-    ':visited': string;
-};
+declare function noVendor(selector: string): boolean;
 /**
  * @param {string[]} selectors
  * @param{string[]=} browsers
  * @param{Map<string,boolean>=} compatibilityCache
  * @return {boolean}
  */
-export function ensureCompatibility(selectors: string[], browsers?: string[] | undefined, compatibilityCache?: Map<string, boolean> | undefined): boolean;
+declare function ensureCompatibility(selectors: string[], browsers?: string[] | undefined, compatibilityCache?: Map<string, boolean> | undefined): boolean;
 //# sourceMappingURL=ensureCompatibility.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ensureCompatibility.d.ts","sourceRoot":"","sources":["../../src/lib/ensureCompatibility.js"],"names":[],"mappings":"AAqCA;;;;GAIG;AACH,uCAJW,MAAM,EAAE,cACR,MAAM,EAAE,GACP,OAAO,CAWlB;AAED;;;GAGG;AACH,mCAHW,MAAM,GACL,OAAO,CAIlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoDE;AAqCF;;;;;GAKG;AACH,+CALW,MAAM,EAAE,aACT,MAAM,EAAE,YAAC,uBACT,GAAG,CAAC,MAAM,EAAC,OAAO,CAAC,YAAC,GAClB,OAAO,CA0ElB"}
+{"version":3,"file":"ensureCompatibility.d.ts","sourceRoot":"","sources":["../../src/lib/ensureCompatibility.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA;;;;GAIG;AACH,iBAAS,UAAU,CAAC,UAAU,EAJnB,MAAM,EAIa,EAAE,UAAU,EAH/B,MAAM,EAGyB,GAF9B,OAAO,CAWlB;AAED;;;GAGG;AACH,iBAAS,QAAQ,CAAC,QAAQ,EAHf,MAGe,GAFd,OAAO,CAIlB;AA2FD;;;;;GAKG;AACH,iBAAS,mBAAmB,CAAC,SAAS,EAL3B,MAAM,EAKqB,EAAE,QAAQ,AAJ7C,CACA,EADO,MAAM,EAAE,YAI8B,EAAE,kBAAkB,AAHjE,CACA,EADO,GAAG,CAAC,MAAM,EAAC,OAAO,CAAC,YAGuC,GAFxD,OAAO,CA0ElB"}

package/types/lib/getBrowsersForWebBuild.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"getBrowsersForWebBuild.d.ts","sourceRoot":"","sources":["../../src/lib/getBrowsersForWebBuild.js"],"names":[],"mappings":""}