stylehacks 5.0.3 → 5.1.0

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "stylehacks",
-  "version": "5.0.3",
+  "version": "5.1.0",
   "description": "Detect/remove browser hacks from CSS files.",
   "main": "src/index.js",
+  "types": "types/index.d.ts",
   "files": [
     "LICENSE-MIT",
-    "src"
+    "src",
+    "types"
   ],
   "keywords": [
     "browsers",

package/src/exists.js

@@ -1,4 +1,11 @@
 'use strict';
+
+/**
+ * @param {import('postcss-selector-parser').Selector} selector
+ * @param {number} index
+ * @param {string} value
+ * @return {boolean | undefined | ''}
+ */
 module.exports = function exists(selector, index, value) {
   const node = selector.at(index);
 

package/src/index.js

@@ -2,11 +2,19 @@
 const browserslist = require('browserslist');
 const plugins = require('./plugins');
 
+/** @typedef {{lint?: boolean}} Options */
+
+/**
+ * @type {import('postcss').PluginCreator<Options>}
+ * @param {Options} opts
+ * @return {import('postcss').Plugin}
+ */
 function pluginCreator(opts = {}) {
   return {
     postcssPlugin: 'stylehacks',
 
     OnceExit(css, { result }) {
+      /** @type {typeof result.opts & browserslist.Options} */
       const resultOpts = result.opts || {};
       const browsers = browserslist(null, {
         stats: resultOpts.stats,
@@ -14,6 +22,7 @@ function pluginCreator(opts = {}) {
         env: resultOpts.env,
       });
 
+      /** @type {import('./plugin').Plugin[]} */
       const processors = [];
       for (const Plugin of plugins) {
         const hack = new Plugin(result);
@@ -38,6 +47,7 @@ function pluginCreator(opts = {}) {
   };
 }
 
+/** @type {(node: import('postcss').Node) => boolean} */
 pluginCreator.detect = (node) => {
   return plugins.some((Plugin) => {
     const hack = new Plugin();

package/src/isMixin.js

@@ -1,4 +1,8 @@
 'use strict';
+/**
+ * @param {import('postcss').Rule} node
+ * @return {boolean}
+ */
 module.exports = function isMixin(node) {
   const { selector } = node;
 

package/src/plugin.js

@@ -1,31 +1,70 @@
 'use strict';
+/**
+ * @typedef {object} Plugin
+ * @prop {Set<string>} targets
+ * @prop {Set<string>} nodeTypes
+ * @prop {(node: import('postcss').Node) => void} detectAndResolve
+ * @prop {(node: import('postcss').Node) => void} detectAndWarn
+ */
+
+/** 
+ * @typedef {import('postcss').Node & {_stylehacks: {
+                                          message: string, 
+                                          browsers: Set<string>, 
+                                          identifier: string, 
+                                          hack: string }}} NodeWithInfo
+ */
+
 module.exports = class BasePlugin {
+  /**
+   * @param {string[]} targets
+   * @param {string[]} nodeTypes
+   * @param {import('postcss').Result=} result
+   */
   constructor(targets, nodeTypes, result) {
+    /** @type {NodeWithInfo[]} */
     this.nodes = [];
     this.targets = new Set(targets);
     this.nodeTypes = new Set(nodeTypes);
     this.result = result;
   }
 
+  /**
+   * @param {import('postcss').Node} node
+   * @param {{identifier: string, hack: string}} metadata
+   * @return {void}
+   */
   push(node, metadata) {
-    node._stylehacks = Object.assign({}, metadata, {
-      message: `Bad ${metadata.identifier}: ${metadata.hack}`,
-      browsers: this.targets,
-    });
+    /** @type {NodeWithInfo} */ (node)._stylehacks = Object.assign(
+      {},
+      metadata,
+      {
+        message: `Bad ${metadata.identifier}: ${metadata.hack}`,
+        browsers: this.targets,
+      }
+    );
 
-    this.nodes.push(node);
+    this.nodes.push(/** @type {NodeWithInfo} */ (node));
   }
 
+  /**
+   * @param {import('postcss').Node} node
+   * @return {boolean}
+   */
   any(node) {
     if (this.nodeTypes.has(node.type)) {
       this.detect(node);
 
-      return !!node._stylehacks;
+      return /** @type {NodeWithInfo} */ (node)._stylehacks !== undefined;
     }
 
     return false;
   }
 
+  /**
+   * @param {import('postcss').Node} node
+   * @return {void}
+   */
   detectAndResolve(node) {
     this.nodes = [];
 
@@ -34,6 +73,10 @@ module.exports = class BasePlugin {
     return this.resolve();
   }
 
+  /**
+   * @param {import('postcss').Node} node
+   * @return {void}
+   */
   detectAndWarn(node) {
     this.nodes = [];
 
@@ -41,11 +84,13 @@ module.exports = class BasePlugin {
 
     return this.warn();
   }
+  /** @param {import('postcss').Node} node */
   // eslint-disable-next-line no-unused-vars
   detect(node) {
     throw new Error('You need to implement this method in a subclass.');
   }
 
+  /** @return {void} */
   resolve() {
     return this.nodes.forEach((node) => node.remove());
   }
@@ -54,7 +99,10 @@ module.exports = class BasePlugin {
     return this.nodes.forEach((node) => {
       const { message, browsers, identifier, hack } = node._stylehacks;
 
-      return node.warn(this.result, message, { browsers, identifier, hack });
+      return node.warn(
+        /** @type {import('postcss').Result} */ (this.result),
+        message + JSON.stringify({ browsers, identifier, hack })
+      );
     });
   }
 };

package/src/plugins/bodyEmpty.js

@@ -9,10 +9,15 @@ const { RULE } = require('../dictionary/postcss');
 const { BODY } = require('../dictionary/tags');
 
 module.exports = class BodyEmpty extends BasePlugin {
+  /** @param {import('postcss').Result} result */
   constructor(result) {
     super([FF_2], [RULE], result);
   }
 
+  /**
+   * @param {import('postcss').Rule} rule
+   * @return {void}
+   */
   detect(rule) {
     if (isMixin(rule)) {
       return;
@@ -20,6 +25,10 @@ module.exports = class BodyEmpty extends BasePlugin {
     parser(this.analyse(rule)).processSync(rule.selector);
   }
 
+  /**
+   * @param {import('postcss').Rule} rule
+   * @return {parser.SyncProcessor<void>}
+   */
   analyse(rule) {
     return (selectors) => {
       selectors.each((selector) => {

package/src/plugins/htmlCombinatorCommentBody.js

@@ -9,10 +9,15 @@ const { RULE } = require('../dictionary/postcss');
 const { BODY, HTML } = require('../dictionary/tags');
 
 module.exports = class HtmlCombinatorCommentBody extends BasePlugin {
+  /** @param {import('postcss').Result} result */
   constructor(result) {
     super([IE_5_5, IE_6, IE_7], [RULE], result);
   }
 
+  /**
+   * @param {import('postcss').Rule} rule
+   * @return {void}
+   */
   detect(rule) {
     if (isMixin(rule)) {
       return;
@@ -22,6 +27,9 @@ module.exports = class HtmlCombinatorCommentBody extends BasePlugin {
     }
   }
 
+  /** @param {import('postcss').Rule} rule
+   *  @return {parser.SyncProcessor<void>}
+   */
   analyse(rule) {
     return (selectors) => {
       selectors.each((selector) => {

package/src/plugins/htmlFirstChild.js

@@ -9,10 +9,15 @@ const { RULE } = require('../dictionary/postcss');
 const { HTML } = require('../dictionary/tags');
 
 module.exports = class HtmlFirstChild extends BasePlugin {
+  /** @param {import('postcss').Result} result */
   constructor(result) {
     super([OP_9], [RULE], result);
   }
 
+  /**
+   * @param {import('postcss').Rule} rule
+   * @return {void}
+   */
   detect(rule) {
     if (isMixin(rule)) {
       return;
@@ -21,6 +26,10 @@ module.exports = class HtmlFirstChild extends BasePlugin {
     parser(this.analyse(rule)).processSync(rule.selector);
   }
 
+  /**
+   * @param {import('postcss').Rule} rule
+   * @return {parser.SyncProcessor<void>}
+   */
   analyse(rule) {
     return (selectors) => {
       selectors.each((selector) => {

package/src/plugins/important.js

@@ -4,13 +4,17 @@ const { IE_5_5, IE_6, IE_7 } = require('../dictionary/browsers');
 const { DECL } = require('../dictionary/postcss');
 
 module.exports = class Important extends BasePlugin {
+  /** @param {import('postcss').Result=} result */
   constructor(result) {
     super([IE_5_5, IE_6, IE_7], [DECL], result);
   }
-
+  /**
+   * @param {import('postcss').Declaration} decl
+   * @return {void}
+   */
   detect(decl) {
     const match = decl.value.match(/!\w/);
-    if (match) {
+    if (match && match.index) {
       const hack = decl.value.substr(match.index, decl.value.length - 1);
       this.push(decl, {
         identifier: '!important',

package/src/plugins/leadingStar.js

@@ -7,10 +7,15 @@ const { ATRULE, DECL } = require('../dictionary/postcss');
 const hacks = '!_$_&_*_)_=_%_+_,_._/_`_]_#_~_?_:_|'.split('_');
 
 module.exports = class LeadingStar extends BasePlugin {
+  /** @param {import('postcss').Result=} result */
   constructor(result) {
     super([IE_5_5, IE_6, IE_7], [ATRULE, DECL], result);
   }
 
+  /**
+   * @param {import('postcss').Declaration | import('postcss').AtRule} node
+   * @return {void}
+   */
   detect(node) {
     if (node.type === DECL) {
       // some values are not picked up by before, so ensure they are
@@ -23,7 +28,7 @@ module.exports = class LeadingStar extends BasePlugin {
           });
         }
       });
-      let { before } = node.raws;
+      const { before } = node.raws;
       if (!before) {
         return;
       }
@@ -37,8 +42,8 @@ module.exports = class LeadingStar extends BasePlugin {
       });
     } else {
       // test for the @property: value; hack
-      let { name } = node;
-      let len = name.length - 1;
+      const { name } = node;
+      const len = name.length - 1;
       if (name.lastIndexOf(':') === len) {
         this.push(node, {
           identifier: PROPERTY,

package/src/plugins/leadingUnderscore.js

@@ -4,6 +4,10 @@ const { IE_6 } = require('../dictionary/browsers');
 const { PROPERTY } = require('../dictionary/identifiers');
 const { DECL } = require('../dictionary/postcss');
 
+/**
+ * @param {string} prop
+ * @return {string}
+ */
 function vendorPrefix(prop) {
   let match = prop.match(/^(-\w+-)/);
   if (match) {
@@ -14,10 +18,15 @@ function vendorPrefix(prop) {
 }
 
 module.exports = class LeadingUnderscore extends BasePlugin {
+  /** @param {import('postcss').Result=} result */
   constructor(result) {
     super([IE_6], [DECL], result);
   }
 
+  /**
+   * @param {import('postcss').Declaration} decl
+   * @return {void}
+   */
   detect(decl) {
     const { before } = decl.raws;
 

package/src/plugins/mediaSlash0.js

@@ -5,10 +5,14 @@ const { MEDIA_QUERY } = require('../dictionary/identifiers');
 const { ATRULE } = require('../dictionary/postcss');
 
 module.exports = class MediaSlash0 extends BasePlugin {
+  /** @param {import('postcss').Result} result */
   constructor(result) {
     super([IE_8], [ATRULE], result);
   }
-
+  /**
+   * @param {import('postcss').AtRule} rule
+   * @return {void}
+   */
   detect(rule) {
     const params = rule.params.trim();
 

package/src/plugins/mediaSlash0Slash9.js

@@ -5,10 +5,15 @@ const { MEDIA_QUERY } = require('../dictionary/identifiers');
 const { ATRULE } = require('../dictionary/postcss');
 
 module.exports = class MediaSlash0Slash9 extends BasePlugin {
+  /** @param {import('postcss').Result} result */
   constructor(result) {
     super([IE_5_5, IE_6, IE_7, IE_8], [ATRULE], result);
   }
 
+  /**
+   * @param {import('postcss').AtRule} rule
+   * @return {void}
+   */
   detect(rule) {
     const params = rule.params.trim();
 

package/src/plugins/mediaSlash9.js

@@ -5,10 +5,15 @@ const { MEDIA_QUERY } = require('../dictionary/identifiers');
 const { ATRULE } = require('../dictionary/postcss');
 
 module.exports = class MediaSlash9 extends BasePlugin {
+  /** @param {import('postcss').Result} result */
   constructor(result) {
     super([IE_5_5, IE_6, IE_7], [ATRULE], result);
   }
 
+  /**
+   * @param {import('postcss').AtRule} rule
+   * @return {void}
+   */
   detect(rule) {
     const params = rule.params.trim();
 

package/src/plugins/slash9.js

@@ -5,10 +5,15 @@ const { VALUE } = require('../dictionary/identifiers');
 const { DECL } = require('../dictionary/postcss');
 
 module.exports = class Slash9 extends BasePlugin {
+  /** @param {import('postcss').Result=} result */
   constructor(result) {
     super([IE_6, IE_7, IE_8], [DECL], result);
   }
 
+  /**
+   * @param {import('postcss').Declaration} decl
+   * @return {void}
+   */
   detect(decl) {
     let v = decl.value;
     if (v && v.length > 2 && v.indexOf('\\9') === v.length - 2) {

package/src/plugins/starHtml.js

@@ -9,10 +9,15 @@ const { RULE } = require('../dictionary/postcss');
 const { HTML } = require('../dictionary/tags');
 
 module.exports = class StarHtml extends BasePlugin {
+  /** @param {import('postcss').Result=} result */
   constructor(result) {
     super([IE_5_5, IE_6], [RULE], result);
   }
 
+  /**
+   * @param {import('postcss').Rule} rule
+   * @return {void}
+   */
   detect(rule) {
     if (isMixin(rule)) {
       return;
@@ -20,6 +25,10 @@ module.exports = class StarHtml extends BasePlugin {
     parser(this.analyse(rule)).processSync(rule.selector);
   }
 
+  /**
+   * @param {import('postcss').Rule} rule
+   * @return {parser.SyncProcessor<void>}
+   */
   analyse(rule) {
     return (selectors) => {
       selectors.each((selector) => {

package/src/plugins/trailingSlashComma.js

@@ -6,10 +6,15 @@ const { SELECTOR } = require('../dictionary/identifiers');
 const { RULE } = require('../dictionary/postcss');
 
 module.exports = class TrailingSlashComma extends BasePlugin {
+  /** @param {import('postcss').Result=} result */
   constructor(result) {
     super([IE_5_5, IE_6, IE_7], [RULE], result);
   }
 
+  /**
+   * @param {import('postcss').Rule} rule
+   * @return {void}
+   */
   detect(rule) {
     if (isMixin(rule)) {
       return;

package/types/dictionary/browsers.d.ts

@@ -0,0 +1,6 @@
+export const FF_2: "firefox 2";
+export const IE_5_5: "ie 5.5";
+export const IE_6: "ie 6";
+export const IE_7: "ie 7";
+export const IE_8: "ie 8";
+export const OP_9: "opera 9";

package/types/dictionary/identifiers.d.ts

@@ -0,0 +1,4 @@
+export const MEDIA_QUERY: "media query";
+export const PROPERTY: "property";
+export const SELECTOR: "selector";
+export const VALUE: "value";

package/types/dictionary/postcss.d.ts

@@ -0,0 +1,3 @@
+export const ATRULE: "atrule";
+export const DECL: "decl";
+export const RULE: "rule";

package/types/dictionary/tags.d.ts

@@ -0,0 +1,2 @@
+export const BODY: "body";
+export const HTML: "html";

package/types/exists.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(selector: import('postcss-selector-parser').Selector, index: number, value: string): boolean | undefined | '';
+export = _exports;

package/types/index.d.ts

@@ -0,0 +1,16 @@
+export = pluginCreator;
+/** @typedef {{lint?: boolean}} 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 { detect, postcss, Options };
+}
+type Options = {
+    lint?: boolean;
+};
+declare function detect(node: import('postcss').Node): boolean;
+declare var postcss: true;

package/types/isMixin.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(node: import('postcss').Rule): boolean;
+export = _exports;

package/types/plugin.d.ts

@@ -0,0 +1,60 @@
+export = BasePlugin;
+declare class BasePlugin {
+    /**
+     * @param {string[]} targets
+     * @param {string[]} nodeTypes
+     * @param {import('postcss').Result=} result
+     */
+    constructor(targets: string[], nodeTypes: string[], result?: import('postcss').Result | undefined);
+    /** @type {NodeWithInfo[]} */
+    nodes: NodeWithInfo[];
+    targets: Set<string>;
+    nodeTypes: Set<string>;
+    result: import("postcss").Result | undefined;
+    /**
+     * @param {import('postcss').Node} node
+     * @param {{identifier: string, hack: string}} metadata
+     * @return {void}
+     */
+    push(node: import('postcss').Node, metadata: {
+        identifier: string;
+        hack: string;
+    }): void;
+    /**
+     * @param {import('postcss').Node} node
+     * @return {boolean}
+     */
+    any(node: import('postcss').Node): boolean;
+    /**
+     * @param {import('postcss').Node} node
+     * @return {void}
+     */
+    detectAndResolve(node: import('postcss').Node): void;
+    /**
+     * @param {import('postcss').Node} node
+     * @return {void}
+     */
+    detectAndWarn(node: import('postcss').Node): void;
+    /** @param {import('postcss').Node} node */
+    detect(node: import('postcss').Node): void;
+    /** @return {void} */
+    resolve(): void;
+    warn(): void;
+}
+declare namespace BasePlugin {
+    export { Plugin, NodeWithInfo };
+}
+type NodeWithInfo = import('postcss').Node & {
+    _stylehacks: {
+        message: string;
+        browsers: Set<string>;
+        identifier: string;
+        hack: string;
+    };
+};
+type Plugin = {
+    targets: Set<string>;
+    nodeTypes: Set<string>;
+    detectAndResolve: (node: import('postcss').Node) => void;
+    detectAndWarn: (node: import('postcss').Node) => void;
+};

package/types/plugins/bodyEmpty.d.ts

@@ -0,0 +1,17 @@
+export = BodyEmpty;
+declare class BodyEmpty extends BasePlugin {
+    /** @param {import('postcss').Result} result */
+    constructor(result: import('postcss').Result);
+    /**
+     * @param {import('postcss').Rule} rule
+     * @return {void}
+     */
+    detect(rule: import('postcss').Rule): void;
+    /**
+     * @param {import('postcss').Rule} rule
+     * @return {parser.SyncProcessor<void>}
+     */
+    analyse(rule: import('postcss').Rule): parser.SyncProcessor<void>;
+}
+import BasePlugin = require("../plugin");
+import parser = require("postcss-selector-parser");

package/types/plugins/htmlCombinatorCommentBody.d.ts

@@ -0,0 +1,16 @@
+export = HtmlCombinatorCommentBody;
+declare class HtmlCombinatorCommentBody extends BasePlugin {
+    /** @param {import('postcss').Result} result */
+    constructor(result: import('postcss').Result);
+    /**
+     * @param {import('postcss').Rule} rule
+     * @return {void}
+     */
+    detect(rule: import('postcss').Rule): void;
+    /** @param {import('postcss').Rule} rule
+     *  @return {parser.SyncProcessor<void>}
+     */
+    analyse(rule: import('postcss').Rule): parser.SyncProcessor<void>;
+}
+import BasePlugin = require("../plugin");
+import parser = require("postcss-selector-parser");

package/types/plugins/htmlFirstChild.d.ts

@@ -0,0 +1,17 @@
+export = HtmlFirstChild;
+declare class HtmlFirstChild extends BasePlugin {
+    /** @param {import('postcss').Result} result */
+    constructor(result: import('postcss').Result);
+    /**
+     * @param {import('postcss').Rule} rule
+     * @return {void}
+     */
+    detect(rule: import('postcss').Rule): void;
+    /**
+     * @param {import('postcss').Rule} rule
+     * @return {parser.SyncProcessor<void>}
+     */
+    analyse(rule: import('postcss').Rule): parser.SyncProcessor<void>;
+}
+import BasePlugin = require("../plugin");
+import parser = require("postcss-selector-parser");

package/types/plugins/important.d.ts

@@ -0,0 +1,11 @@
+export = Important;
+declare class Important extends BasePlugin {
+    /** @param {import('postcss').Result=} result */
+    constructor(result?: import('postcss').Result | undefined);
+    /**
+     * @param {import('postcss').Declaration} decl
+     * @return {void}
+     */
+    detect(decl: import('postcss').Declaration): void;
+}
+import BasePlugin = require("../plugin");

package/types/plugins/index.d.ts

@@ -0,0 +1,365 @@
+declare const _exports: {
+    [n: number]: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    };
+    length: number;
+    toString(): string;
+    toLocaleString(): string;
+    pop(): {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    } | undefined;
+    push(...items: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]): number;
+    concat(...items: ConcatArray<{
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }>[]): ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[];
+    concat(...items: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    } | ConcatArray<{
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }>)[]): ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[];
+    join(separator?: string | undefined): string;
+    reverse(): ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[];
+    shift(): {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    } | undefined;
+    slice(start?: number | undefined, end?: number | undefined): ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[];
+    sort(compareFn?: ((a: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, b: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }) => number) | undefined): ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[];
+    splice(start: number, deleteCount?: number | undefined): ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[];
+    splice(start: number, deleteCount: number, ...items: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]): ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[];
+    unshift(...items: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]): number;
+    indexOf(searchElement: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, fromIndex?: number | undefined): number;
+    lastIndexOf(searchElement: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, fromIndex?: number | undefined): number;
+    every<S extends {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }>(predicate: (value: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, index: number, array: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => value is S, thisArg?: any): this is S[];
+    every(predicate: (value: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, index: number, array: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => unknown, thisArg?: any): boolean;
+    some(predicate: (value: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, index: number, array: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => unknown, thisArg?: any): boolean;
+    forEach(callbackfn: (value: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, index: number, array: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => void, thisArg?: any): void;
+    map<U>(callbackfn: (value: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, index: number, array: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => U, thisArg?: any): U[];
+    filter<S_1 extends {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }>(predicate: (value: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, index: number, array: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => value is S_1, thisArg?: any): S_1[];
+    filter(predicate: (value: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, index: number, array: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => unknown, thisArg?: any): ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[];
+    reduce(callbackfn: (previousValue: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, currentValue: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, currentIndex: number, array: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }): {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    };
+    reduce(callbackfn: (previousValue: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, currentValue: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, currentIndex: number, array: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, initialValue: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }): {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    };
+    reduce<U_1>(callbackfn: (previousValue: U_1, currentValue: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, currentIndex: number, array: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => U_1, initialValue: U_1): U_1;
+    reduceRight(callbackfn: (previousValue: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, currentValue: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, currentIndex: number, array: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }): {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    };
+    reduceRight(callbackfn: (previousValue: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, currentValue: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, currentIndex: number, array: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, initialValue: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }): {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    };
+    reduceRight<U_2>(callbackfn: (previousValue: U_2, currentValue: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, currentIndex: number, array: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => U_2, initialValue: U_2): U_2;
+    find<S_2 extends {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }>(predicate: (this: void, value: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, index: number, obj: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => value is S_2, thisArg?: any): S_2 | undefined;
+    find(predicate: (value: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, index: number, obj: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => unknown, thisArg?: any): {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    } | undefined;
+    findIndex(predicate: (value: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, index: number, obj: ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[]) => unknown, thisArg?: any): number;
+    fill(value: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, start?: number | undefined, end?: number | undefined): ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[];
+    copyWithin(target: number, start: number, end?: number | undefined): ({
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    })[];
+    entries(): IterableIterator<[number, {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<{
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }>;
+    includes(searchElement: {
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }, fromIndex?: number | undefined): boolean;
+    [Symbol.iterator](): IterableIterator<{
+        new (result?: import("postcss").Result | undefined): important;
+    } | {
+        new (result?: import("postcss").Result | undefined): trailingSlashComma;
+    }>;
+    [Symbol.unscopables](): {
+        copyWithin: boolean;
+        entries: boolean;
+        fill: boolean;
+        find: boolean;
+        findIndex: boolean;
+        keys: boolean;
+        values: boolean;
+    };
+};
+export = _exports;

package/types/plugins/leadingStar.d.ts

@@ -0,0 +1,11 @@
+export = LeadingStar;
+declare class LeadingStar extends BasePlugin {
+    /** @param {import('postcss').Result=} result */
+    constructor(result?: import('postcss').Result | undefined);
+    /**
+     * @param {import('postcss').Declaration | import('postcss').AtRule} node
+     * @return {void}
+     */
+    detect(node: import('postcss').Declaration | import('postcss').AtRule): void;
+}
+import BasePlugin = require("../plugin");

package/types/plugins/leadingUnderscore.d.ts

@@ -0,0 +1,11 @@
+export = LeadingUnderscore;
+declare class LeadingUnderscore extends BasePlugin {
+    /** @param {import('postcss').Result=} result */
+    constructor(result?: import('postcss').Result | undefined);
+    /**
+     * @param {import('postcss').Declaration} decl
+     * @return {void}
+     */
+    detect(decl: import('postcss').Declaration): void;
+}
+import BasePlugin = require("../plugin");

package/types/plugins/mediaSlash0.d.ts

@@ -0,0 +1,11 @@
+export = MediaSlash0;
+declare class MediaSlash0 extends BasePlugin {
+    /** @param {import('postcss').Result} result */
+    constructor(result: import('postcss').Result);
+    /**
+     * @param {import('postcss').AtRule} rule
+     * @return {void}
+     */
+    detect(rule: import('postcss').AtRule): void;
+}
+import BasePlugin = require("../plugin");

package/types/plugins/mediaSlash0Slash9.d.ts

@@ -0,0 +1,11 @@
+export = MediaSlash0Slash9;
+declare class MediaSlash0Slash9 extends BasePlugin {
+    /** @param {import('postcss').Result} result */
+    constructor(result: import('postcss').Result);
+    /**
+     * @param {import('postcss').AtRule} rule
+     * @return {void}
+     */
+    detect(rule: import('postcss').AtRule): void;
+}
+import BasePlugin = require("../plugin");

package/types/plugins/mediaSlash9.d.ts

@@ -0,0 +1,11 @@
+export = MediaSlash9;
+declare class MediaSlash9 extends BasePlugin {
+    /** @param {import('postcss').Result} result */
+    constructor(result: import('postcss').Result);
+    /**
+     * @param {import('postcss').AtRule} rule
+     * @return {void}
+     */
+    detect(rule: import('postcss').AtRule): void;
+}
+import BasePlugin = require("../plugin");

package/types/plugins/slash9.d.ts

@@ -0,0 +1,11 @@
+export = Slash9;
+declare class Slash9 extends BasePlugin {
+    /** @param {import('postcss').Result=} result */
+    constructor(result?: import('postcss').Result | undefined);
+    /**
+     * @param {import('postcss').Declaration} decl
+     * @return {void}
+     */
+    detect(decl: import('postcss').Declaration): void;
+}
+import BasePlugin = require("../plugin.js");

package/types/plugins/starHtml.d.ts

@@ -0,0 +1,17 @@
+export = StarHtml;
+declare class StarHtml extends BasePlugin {
+    /** @param {import('postcss').Result=} result */
+    constructor(result?: import('postcss').Result | undefined);
+    /**
+     * @param {import('postcss').Rule} rule
+     * @return {void}
+     */
+    detect(rule: import('postcss').Rule): void;
+    /**
+     * @param {import('postcss').Rule} rule
+     * @return {parser.SyncProcessor<void>}
+     */
+    analyse(rule: import('postcss').Rule): parser.SyncProcessor<void>;
+}
+import BasePlugin = require("../plugin");
+import parser = require("postcss-selector-parser");

package/types/plugins/trailingSlashComma.d.ts

@@ -0,0 +1,11 @@
+export = TrailingSlashComma;
+declare class TrailingSlashComma extends BasePlugin {
+    /** @param {import('postcss').Result=} result */
+    constructor(result?: import('postcss').Result | undefined);
+    /**
+     * @param {import('postcss').Rule} rule
+     * @return {void}
+     */
+    detect(rule: import('postcss').Rule): void;
+}
+import BasePlugin = require("../plugin");