postcss-merge-rules 8.0.5 → 9.0.1

package/src/lib/computeBrowsersToSupport.js

@@ -1,7 +1,8 @@
-'use strict';
+import { fileURLToPath } from 'node:url';
+import browserslist from 'browserslist';
+import nodepath from 'node:path';
 
-const browserslist = require('browserslist');
-const { dirname } = require('node:path');
+const { dirname } = nodepath;
 
 /**
  *
@@ -12,16 +13,13 @@ const { dirname } = require('node:path');
  * @param {browserslist.Options["env"]} [env]
  * @returns {string[]}
  */
-module.exports = function computeBrowsersToSupport(
-  options,
-  stats,
-  from,
-  file,
-  env
-) {
+function computeBrowsersToSupport(options, stats, from, file, env) {
   return browserslist(options.overrideBrowserslist, {
     stats: options.stats || stats,
-    path: options.path || dirname(from || file || __filename),
+    path:
+      options.path || dirname(from || file || fileURLToPath(import.meta.url)),
     env: options.env || env,
   });
-};
+}
+
+export default computeBrowsersToSupport;

package/src/lib/declarations.js

@@ -0,0 +1,146 @@
+import { isConflictingProp } from './propertyRelations.js';
+
+/** @import {Declaration} from 'postcss' */
+
+/**
+ * @param {Declaration} a
+ * @param {Declaration} b
+ * @return {boolean}
+ */
+function declarationIsEqual(a, b) {
+  return (
+    a.important === b.important && a.prop === b.prop && a.value === b.value
+  );
+}
+
+/**
+ * @param {Declaration[]} array
+ * @param {Declaration} decl
+ * @return {number}
+ */
+export function indexOfDeclaration(array, decl) {
+  return array.findIndex((d) => declarationIsEqual(d, decl));
+}
+
+/**
+ * @param {Declaration[]} a
+ * @param {Declaration[]} b
+ * @param {boolean} [not=false]
+ * @return {Declaration[]}
+ */
+export function intersect(a, b, not) {
+  return a.filter((c) => {
+    const index = indexOfDeclaration(b, c) !== -1;
+    return not ? !index : index;
+  });
+}
+
+/**
+ * @param {Declaration[]} a
+ * @param {Declaration[]} b
+ * @return {boolean}
+ */
+export function sameDeclarationsAndOrder(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  return a.every((d, index) => declarationIsEqual(d, b[index]));
+}
+
+/**
+ * @param {Declaration} candidate
+ * @param {number} candidateIndex
+ * @param {Declaration[]} hoistCandidates
+ * @param {Declaration[]} earlierRuleDeclarations
+ * @return {boolean}
+ */
+function hoistingPreservesOverrideOrder(
+  candidate,
+  candidateIndex,
+  hoistCandidates,
+  earlierRuleDeclarations
+) {
+  const indexInEarlierRule = indexOfDeclaration(
+    earlierRuleDeclarations,
+    candidate
+  );
+  const overridesInEarlierRule = earlierRuleDeclarations
+    .slice(indexInEarlierRule + 1)
+    .filter((d) => isConflictingProp(d.prop, candidate.prop));
+  if (overridesInEarlierRule.length === 0) {
+    return true;
+  }
+  const overridesAmongCandidates = hoistCandidates
+    .slice(candidateIndex + 1)
+    .filter((d) => isConflictingProp(d.prop, candidate.prop));
+  if (overridesInEarlierRule.length !== overridesAmongCandidates.length) {
+    return false;
+  }
+  return overridesInEarlierRule.every((d, index) =>
+    declarationIsEqual(d, overridesAmongCandidates[index])
+  );
+}
+
+/**
+ * @param {Declaration} candidate
+ * @param {Declaration[]} laterDeclarations
+ * @param {Set<number>} claimedIndices
+ * @return {boolean}
+ */
+function claimMatchInLaterRule(candidate, laterDeclarations, claimedIndices) {
+  const matchIndex = laterDeclarations.findIndex(
+    (d, index) =>
+      !claimedIndices.has(index) && isConflictingProp(d.prop, candidate.prop)
+  );
+  if (matchIndex === -1) {
+    return false;
+  }
+  if (!declarationIsEqual(laterDeclarations[matchIndex], candidate)) {
+    return false;
+  }
+  if (
+    candidate.prop.toLowerCase() !== 'direction' &&
+    candidate.prop.toLowerCase() !== 'unicode-bidi' &&
+    laterDeclarations.some(
+      (declaration) => declaration.prop.toLowerCase() === 'all'
+    )
+  ) {
+    return false;
+  }
+  claimedIndices.add(matchIndex);
+  return true;
+}
+
+/**
+ * @param {Declaration[]} hoistCandidates
+ * @param {Declaration[]} earlierRuleDeclarations
+ * @param {Declaration[]} laterRuleDeclarations
+ * @return {{intersection: Declaration[], claimedIndices: Set<number>}}
+ */
+export function filterRuleIntersections(
+  hoistCandidates,
+  earlierRuleDeclarations,
+  laterRuleDeclarations
+) {
+  let remainingCandidates = hoistCandidates;
+  for (;;) {
+    const claimedIndices = new Set();
+    const survivors = remainingCandidates.filter(
+      (candidate, candidateIndex) =>
+        hoistingPreservesOverrideOrder(
+          candidate,
+          candidateIndex,
+          remainingCandidates,
+          earlierRuleDeclarations
+        ) &&
+        claimMatchInLaterRule(candidate, laterRuleDeclarations, claimedIndices)
+    );
+    if (
+      survivors.length === remainingCandidates.length ||
+      survivors.length === 0
+    ) {
+      return { intersection: survivors, claimedIndices };
+    }
+    remainingCandidates = survivors;
+  }
+}

package/src/lib/ensureCompatibility.js

@@ -1,7 +1,7 @@
-'use strict';
-const { isSupported } = require('caniuse-api');
-const selectorParser = require('postcss-selector-parser');
+import caniuseApi from 'caniuse-api';
+import selectorParser from 'postcss-selector-parser';
 
+const { isSupported } = caniuseApi;
 const simpleSelectorRe = /^#?[-._a-z0-9 ]+$/i;
 
 const cssSel2 = 'css-sel2';
@@ -246,4 +246,4 @@ function ensureCompatibility(selectors, browsers, compatibilityCache) {
   });
 }
 
-module.exports = { sameVendor, noVendor, pseudoElements, ensureCompatibility };
+export { sameVendor, noVendor, pseudoElements, ensureCompatibility };

package/src/lib/getBrowsersForWebBuild.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports = function () {
+export default (function () {
   return [
     'and_chr 150',
     'and_ff 152',
@@ -32,4 +30,4 @@ module.exports = function () {
     'samsung 30',
     'samsung 29',
   ];
-};
+});

package/src/lib/propertyRelations.js

@@ -1,6 +1,4 @@
-'use strict';
-
-const data = require('../data/propertyGroups.json');
+import data from '../data/propertyGroups.json' with { type: 'json' };
 
 const vendorPrefixRegex = /^-\w+-/;
 /**
@@ -167,5 +165,4 @@ function isConflictingProp(propA, propB) {
   }
   return false;
 }
-
-module.exports = { isConflictingProp };
+export { isConflictingProp };

package/src/lib/rule-meta.js

@@ -0,0 +1,58 @@
+/** @import {Declaration, Rule} from 'postcss' */
+
+/**
+ * @typedef {Object} RuleMeta
+ * @property {string[]} selectors
+ * @property {Declaration[]} declarations
+ * @property {boolean} dirty
+ */
+
+/**
+ * @param {import('postcss').ChildNode} node
+ * @return {node is Declaration}
+ */
+function isDeclaration(node) {
+  return node.type === 'decl';
+}
+
+/**
+ * @param {Rule} rule
+ * @param {WeakMap<Rule, RuleMeta>} [ruleMeta]
+ * @return {RuleMeta}
+ */
+export function getMeta(rule, ruleMeta) {
+  if (ruleMeta && rule) {
+    let meta = ruleMeta.get(rule);
+    if (!meta && rule.nodes) {
+      meta = {
+        selectors: rule.selectors,
+        declarations: rule.nodes.filter(isDeclaration),
+        dirty: false,
+      };
+      ruleMeta.set(rule, meta);
+    }
+    return meta ?? { selectors: [], declarations: [], dirty: false };
+  }
+  return {
+    selectors: rule?.selectors ?? [],
+    declarations: rule?.nodes?.filter(isDeclaration) ?? [],
+    dirty: false,
+  };
+}
+
+/**
+ * @param {Rule} rule
+ * @param {WeakMap<Rule, RuleMeta>} ruleMeta
+ */
+export function flush(rule, ruleMeta) {
+  const meta = ruleMeta.get(rule);
+  if (meta && meta.dirty) {
+    rule.selector = meta.selectors.join(',');
+    meta.dirty = false;
+  }
+}
+
+/** @param {Rule} rule @return {Declaration[]} */
+export function getDecls(rule) {
+  return rule.nodes.filter(isDeclaration);
+}

package/src/lib/rule-rewrite.js

@@ -0,0 +1,170 @@
+import { intersect, indexOfDeclaration } from './declarations.js';
+import { flush, getMeta } from './rule-meta.js';
+
+/** @import {Declaration, Rule} from 'postcss' */
+
+/**
+ * @param {Rule} first
+ * @param {Rule} second
+ * @return {boolean}
+ */
+export function mergeParents(first, second) {
+  if (!first.parent || !second.parent || first.parent === second.parent) {
+    return false;
+  }
+  second.remove();
+  first.parent.append(second);
+  return true;
+}
+
+/** @param {Rule} second @return {Rule | null} */
+function getNextRule(second) {
+  let nextRule = second.next();
+  if (!nextRule) {
+    const parentSibling =
+      /** @type {import('postcss').Container | undefined} */ (
+        /** @type {import('postcss').Container<import('postcss').ChildNode>} */ (
+          second.parent
+        ).next()
+      );
+    nextRule = parentSibling && parentSibling.nodes && parentSibling.nodes[0];
+  }
+  return nextRule?.type === 'rule' ? nextRule : null;
+}
+
+/**
+ * @param {...Rule} rules
+ * @return {number}
+ */
+function ruleLength(...rules) {
+  return rules.map((r) => (r.nodes.length ? String(r) : '')).join('').length;
+}
+
+/**
+ * @param {Rule} first
+ * @param {Rule} second
+ * @param {Declaration[]} intersection
+ * @param {string[]} browsers
+ * @param {Map<string, boolean>} compatibilityCache
+ * @param {WeakSet<Rule>} ruleCache
+ * @param {WeakMap<Rule, import('./rule-meta.js').RuleMeta>} ruleMeta
+ * @param {(a: Rule, b: Rule, browsers: string[], compatibilityCache: Map<string, boolean>, ruleCache: WeakSet<Rule>, ruleMeta: WeakMap<Rule, import('./rule-meta.js').RuleMeta>) => boolean} canMerge
+ * @param {(rule: Rule, oldParent: import('postcss').Container, newParent: import('postcss').Container) => void} [onMove]
+ * @return {{first: Rule, second: Rule, intersection: Declaration[], moved: boolean}}
+ */
+export function mergeWithNextRule(
+  first,
+  second,
+  intersection,
+  browsers,
+  compatibilityCache,
+  ruleCache,
+  ruleMeta,
+  canMerge,
+  onMove
+) {
+  const nextRule = getNextRule(second);
+  if (
+    !nextRule ||
+    !canMerge(
+      second,
+      nextRule,
+      browsers,
+      compatibilityCache,
+      ruleCache,
+      ruleMeta
+    )
+  ) {
+    return { first, second, intersection, moved: false };
+  }
+  const nextIntersection = intersect(
+    getMeta(second, ruleMeta).declarations,
+    getMeta(nextRule, ruleMeta).declarations
+  );
+  if (nextIntersection.length <= intersection.length) {
+    return { first, second, intersection, moved: false };
+  }
+  const oldParent = nextRule.parent;
+  const newParent = second.parent;
+  const moved = mergeParents(second, nextRule);
+  if (moved && oldParent && newParent) onMove?.(nextRule, oldParent, newParent);
+  return {
+    first: second,
+    second: nextRule,
+    intersection: nextIntersection,
+    moved,
+  };
+}
+
+/**
+ * @param {Rule} first
+ * @param {Rule} second
+ * @param {Declaration[]} intersection
+ * @param {Set<number>} claimedIndices
+ * @param {WeakSet<Rule>} ruleCache
+ * @param {WeakMap<Rule, import('./rule-meta.js').RuleMeta>} ruleMeta
+ * @return {{rule: Rule, replacements: Rule[]}}
+ */
+export function buildMergedRule(
+  first,
+  second,
+  intersection,
+  claimedIndices,
+  ruleCache,
+  ruleMeta
+) {
+  const receivingBlock = second.clone();
+  const firstSelectors = getMeta(first, ruleMeta).selectors;
+  const secondSelectors = getMeta(second, ruleMeta).selectors;
+  receivingBlock.selector = [...firstSelectors, ...secondSelectors].join();
+  receivingBlock.nodes = [];
+  /** @type {import('postcss').Container<import('postcss').ChildNode>} */ (
+    second.parent
+  ).insertBefore(second, receivingBlock);
+  const firstClone = first.clone({ selectors: firstSelectors });
+  const secondClone = second.clone({ selectors: secondSelectors });
+  firstClone.walkDecls((decl) => {
+    if (indexOfDeclaration(intersection, decl) !== -1) {
+      decl.remove();
+      receivingBlock.append(decl);
+    }
+  });
+  let laterIndex = 0;
+  secondClone.walkDecls((decl) => {
+    if (claimedIndices.has(laterIndex++)) {
+      decl.remove();
+    }
+  });
+  flush(first, ruleMeta);
+  flush(second, ruleMeta);
+  const merged = ruleLength(firstClone, receivingBlock, secondClone);
+  const original = ruleLength(first, second);
+  if (merged < original) {
+    first.replaceWith(firstClone);
+    second.replaceWith(secondClone);
+    for (const rule of [firstClone, receivingBlock, secondClone]) {
+      if (rule.nodes.length === 0) rule.remove();
+    }
+    if (!secondClone.parent) {
+      ruleCache?.add(receivingBlock);
+      return {
+        rule: receivingBlock,
+        replacements: [firstClone, receivingBlock].filter((rule) =>
+          Boolean(rule.parent)
+        ),
+      };
+    }
+    ruleCache?.add(receivingBlock);
+    ruleCache?.add(secondClone);
+    ruleMeta?.delete(first);
+    ruleMeta?.delete(second);
+    return {
+      rule: secondClone,
+      replacements: [firstClone, receivingBlock, secondClone].filter((rule) =>
+        Boolean(rule.parent)
+      ),
+    };
+  }
+  receivingBlock.remove();
+  return { rule: second, replacements: [] };
+}

package/types/index.d.ts

@@ -1,5 +1,3 @@
-declare const _exports: import("postcss").PluginCreator<Options>;
-export = _exports;
 import type browserslist from 'browserslist';
 import type { Declaration } from 'postcss';
 export type RuleMeta = {
@@ -21,4 +19,19 @@ export type AutoprefixerOptions = {
 };
 export type BrowserslistOptions = Pick<browserslist.Options, 'stats' | 'path' | 'env'>;
 export type Options = AutoprefixerOptions & BrowserslistOptions;
+/**
+ * @typedef {{ overrideBrowserslist?: string | string[] }} AutoprefixerOptions
+ * @typedef {Pick<browserslist.Options, 'stats' | 'path' | 'env'>} BrowserslistOptions
+ * @typedef {AutoprefixerOptions & BrowserslistOptions} Options
+ */
+/**
+ * @param {Options} opts
+ * @return {import('postcss').Plugin}
+ */
+declare function pluginCreator(opts?: Options): import('postcss').Plugin;
+declare namespace pluginCreator {
+    var postcss: true;
+}
+declare const moduleExports: typeof pluginCreator;
+export { moduleExports as default, moduleExports 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":";;AAII,OAAQ,KAAA,YAAY,MAAM,cAAc,CAAA;AASxC,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;AA8lBE,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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAoBI,OAAQ,KAAA,YAAY,MAAM,cAAc,CAAA;AAExC,OAAQ,KAAA,EAAC,WAAW,EAAO,MAAM,SAAS,CAAA;AAE3C,YAAkB,QAAQ,GAC1B;;;;IAAqB,SAAS,EAAnB,MAAM,EAAE,CACnB;;;;IAA0B,YAAY,EAA3B,WAAW,EAAE,CACxB;;;;IAAoB,KAAK,EAAd,OAAO,CACpB;CAAA,CAAA;AAoqBE,YAAwD,mBAAmB,GAAjE;IAAE,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE,CAAqB;AAC3E,YAAgE,mBAAmB,GAAzE,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC,CAAqB;AACnF,YAAqD,OAAO,GAAlD,mBAAmB,GAAG,mBAAmB,CAAS;AAH/D;;;;GAIG;AAEH;;;GAGG;AACH,iBAAS,aAAa,CAAC,IAAI,GAHhB,OAGqB,GAFpB,OAAO,SAAS,EAAE,MAAM,CAmCnC;kBAjCQ,aAAa;iBAkCX,IAAI;;AAEf,QAAA,MAAM,aAAa,sBAAgB,CAAC;AAEpC,OAAO,EAAE,aAAa,IAAI,OAAO,EAAE,aAAa,IAAI,gBAAgB,EAAE,CAAC"}

package/types/lib/computeBrowsersToSupport.d.ts

@@ -1,4 +1,4 @@
-export = computeBrowsersToSupport;
+import browserslist from 'browserslist';
 /**
  *
  * @param {{overrideBrowserslist?: string | string[] | undefined, stats?: browserslist.Options["stats"], path?: browserslist.Options["path"], env?: browserslist.Options["env"]}} options
@@ -14,5 +14,5 @@ declare function computeBrowsersToSupport(options: {
     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');
+export default computeBrowsersToSupport;
 //# sourceMappingURL=computeBrowsersToSupport.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"computeBrowsersToSupport.d.ts","sourceRoot":"","sources":["../../src/lib/computeBrowsersToSupport.js"],"names":[],"mappings":"AACA,OAAO,YAAY,MAAM,cAAc,CAAC;AAKxC;;;;;;;;GAQG;AACH,iBAAS,wBAAwB,CAAC,OAAO,EAP9B;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;CAOtI,EAAE,KAAK,EANrC,YAAY,CAAC,OAAO,CAAC,OAAO,CAMS,EAAE,IAAI,EAL3C,MAAM,GAAC,SAKoC,EAAE,IAAI,AAJzD,CACA,EADQ,MAIiD,EAAE,GAAG,AAH9D,CACA,EADQ,YAAY,CAAC,OAAO,CAAC,KAAK,CAG4B,GAFpD,MAAM,EAAE,CASpB;eAEc,wBAAwB"}

package/types/lib/declarations.d.ts

@@ -0,0 +1,31 @@
+import type { Declaration } from 'postcss';
+/**
+ * @param {Declaration[]} array
+ * @param {Declaration} decl
+ * @return {number}
+ */
+export declare function indexOfDeclaration(array: Declaration[], decl: Declaration): number;
+/**
+ * @param {Declaration[]} a
+ * @param {Declaration[]} b
+ * @param {boolean} [not=false]
+ * @return {Declaration[]}
+ */
+export declare function intersect(a: Declaration[], b: Declaration[], not?: boolean): Declaration[];
+/**
+ * @param {Declaration[]} a
+ * @param {Declaration[]} b
+ * @return {boolean}
+ */
+export declare function sameDeclarationsAndOrder(a: Declaration[], b: Declaration[]): boolean;
+/**
+ * @param {Declaration[]} hoistCandidates
+ * @param {Declaration[]} earlierRuleDeclarations
+ * @param {Declaration[]} laterRuleDeclarations
+ * @return {{intersection: Declaration[], claimedIndices: Set<number>}}
+ */
+export declare function filterRuleIntersections(hoistCandidates: Declaration[], earlierRuleDeclarations: Declaration[], laterRuleDeclarations: Declaration[]): {
+    intersection: Declaration[];
+    claimedIndices: Set<number>;
+};
+//# sourceMappingURL=declarations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"declarations.d.ts","sourceRoot":"","sources":["../../src/lib/declarations.js"],"names":[],"mappings":"AAEI,OAAQ,KAAA,EAAC,WAAW,EAAC,MAAM,SAAS,CAAA;AAaxC;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAJ7B,WAAW,EAIkB,EAAE,IAAI,EAHnC,WAGmC,GAFlC,MAAM,CAIjB;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EALhB,WAAW,EAKK,EAAE,CAAC,EAJnB,WAAW,EAIQ,EAAE,GAAG,AAHhC,CACA,EADQ,OAGwB,GAFvB,WAAW,EAAE,CAOxB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAJ/B,WAAW,EAIoB,EAAE,CAAC,EAHlC,WAAW,EAGuB,GAFjC,OAAO,CAOlB;AAkED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,eAAe,EANN,WAAW,EAML,EACf,uBAAuB,EANd,WAAW,EAMG,EACvB,qBAAqB,EANZ,WAAW,EAMC,GALX;IAAC,YAAY,EAAE,WAAW,EAAE,CAAC;IAAC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAC,CA4BrE"}

package/types/lib/ensureCompatibility.d.ts

@@ -1,62 +1,3 @@
-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
@@ -68,6 +9,59 @@ declare function sameVendor(selectorsA: string[], selectorsB: string[]): boolean
  * @return {boolean}
  */
 declare function noVendor(selector: string): boolean;
+declare 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;
+};
 /**
  * @param {string[]} selectors
  * @param{string[]=} browsers
@@ -75,4 +69,5 @@ declare function noVendor(selector: string): boolean;
  * @return {boolean}
  */
 declare function ensureCompatibility(selectors: string[], browsers?: string[] | undefined, compatibilityCache?: Map<string, boolean> | undefined): boolean;
+export { sameVendor, noVendor, pseudoElements, ensureCompatibility };
 //# 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;AA4GD;;;;;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"}
+{"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;AAED,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDnB,CAAC;AAsDF;;;;;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;AAED,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,EAAE,mBAAmB,EAAE,CAAC"}

package/types/lib/getBrowsersForWebBuild.d.ts

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