init

node_modules/stylehacks/src/plugins/bodyEmpty.js

@@ -0,0 +1,49 @@
+'use strict';
+const parser = require('postcss-selector-parser');
+const exists = require('../exists');
+const isMixin = require('../isMixin');
+const BasePlugin = require('../plugin');
+const { FF_2 } = require('../dictionary/browsers');
+const { SELECTOR } = require('../dictionary/identifiers');
+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;
+    }
+    parser(this.analyse(rule)).processSync(rule.selector);
+  }
+
+  /**
+   * @param {import('postcss').Rule} rule
+   * @return {parser.SyncProcessor<void>}
+   */
+  analyse(rule) {
+    return (selectors) => {
+      selectors.each((selector) => {
+        if (
+          exists(selector, 0, BODY) &&
+          exists(selector, 1, ':empty') &&
+          exists(selector, 2, ' ') &&
+          selector.at(3)
+        ) {
+          this.push(rule, {
+            identifier: SELECTOR,
+            hack: selector.toString(),
+          });
+        }
+      });
+    };
+  }
+};

node_modules/stylehacks/src/plugins/htmlCombinatorCommentBody.js

@@ -0,0 +1,54 @@
+'use strict';
+const parser = require('postcss-selector-parser');
+const exists = require('../exists');
+const isMixin = require('../isMixin');
+const BasePlugin = require('../plugin');
+const { IE_5_5, IE_6, IE_7 } = require('../dictionary/browsers');
+const { SELECTOR } = require('../dictionary/identifiers');
+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;
+    }
+    if (rule.raws.selector && rule.raws.selector.raw) {
+      parser(this.analyse(rule)).processSync(rule.raws.selector.raw);
+    }
+  }
+
+  /** @param {import('postcss').Rule} rule
+   *  @return {parser.SyncProcessor<void>}
+   */
+  analyse(rule) {
+    return (selectors) => {
+      selectors.each((selector) => {
+        if (
+          exists(selector, 0, HTML) &&
+          (exists(selector, 1, '>') || exists(selector, 1, '~')) &&
+          selector.at(2) &&
+          selector.at(2).type === 'comment' &&
+          exists(selector, 3, ' ') &&
+          exists(selector, 4, BODY) &&
+          exists(selector, 5, ' ') &&
+          selector.at(6)
+        ) {
+          this.push(rule, {
+            identifier: SELECTOR,
+            hack: selector.toString(),
+          });
+        }
+      });
+    };
+  }
+};

node_modules/stylehacks/src/plugins/htmlFirstChild.js

@@ -0,0 +1,50 @@
+'use strict';
+const parser = require('postcss-selector-parser');
+const exists = require('../exists');
+const isMixin = require('../isMixin');
+const BasePlugin = require('../plugin');
+const { OP_9 } = require('../dictionary/browsers');
+const { SELECTOR } = require('../dictionary/identifiers');
+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;
+    }
+
+    parser(this.analyse(rule)).processSync(rule.selector);
+  }
+
+  /**
+   * @param {import('postcss').Rule} rule
+   * @return {parser.SyncProcessor<void>}
+   */
+  analyse(rule) {
+    return (selectors) => {
+      selectors.each((selector) => {
+        if (
+          exists(selector, 0, HTML) &&
+          exists(selector, 1, ':first-child') &&
+          exists(selector, 2, ' ') &&
+          selector.at(3)
+        ) {
+          this.push(rule, {
+            identifier: SELECTOR,
+            hack: selector.toString(),
+          });
+        }
+      });
+    };
+  }
+};

node_modules/stylehacks/src/plugins/important.js

@@ -0,0 +1,25 @@
+'use strict';
+const BasePlugin = require('../plugin');
+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 && match.index) {
+      const hack = decl.value.substr(match.index, decl.value.length - 1);
+      this.push(decl, {
+        identifier: '!important',
+        hack,
+      });
+    }
+  }
+};

node_modules/stylehacks/src/plugins/index.js

@@ -0,0 +1,28 @@
+'use strict';
+const bodyEmpty = require('./bodyEmpty');
+const htmlCombinatorCommentBody = require('./htmlCombinatorCommentBody');
+const htmlFirstChild = require('./htmlFirstChild');
+const important = require('./important');
+const leadingStar = require('./leadingStar');
+const leadingUnderscore = require('./leadingUnderscore');
+const mediaSlash0 = require('./mediaSlash0');
+const mediaSlash0Slash9 = require('./mediaSlash0Slash9');
+const mediaSlash9 = require('./mediaSlash9');
+const slash9 = require('./slash9');
+const starHtml = require('./starHtml');
+const trailingSlashComma = require('./trailingSlashComma');
+
+module.exports = [
+  bodyEmpty,
+  htmlCombinatorCommentBody,
+  htmlFirstChild,
+  important,
+  leadingStar,
+  leadingUnderscore,
+  mediaSlash0,
+  mediaSlash0Slash9,
+  mediaSlash9,
+  slash9,
+  starHtml,
+  trailingSlashComma,
+];

node_modules/stylehacks/src/plugins/leadingStar.js

@@ -0,0 +1,55 @@
+'use strict';
+const BasePlugin = require('../plugin');
+const { IE_5_5, IE_6, IE_7 } = require('../dictionary/browsers');
+const { PROPERTY } = require('../dictionary/identifiers');
+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
+      // at the beginning of the value
+      hacks.forEach((hack) => {
+        if (!node.prop.indexOf(hack)) {
+          this.push(node, {
+            identifier: PROPERTY,
+            hack: node.prop,
+          });
+        }
+      });
+      const { before } = node.raws;
+      if (!before) {
+        return;
+      }
+      hacks.forEach((hack) => {
+        if (before.includes(hack)) {
+          this.push(node, {
+            identifier: PROPERTY,
+            hack: `${before.trim()}${node.prop}`,
+          });
+        }
+      });
+    } else {
+      // test for the @property: value; hack
+      const { name } = node;
+      const len = name.length - 1;
+      if (name.lastIndexOf(':') === len) {
+        this.push(node, {
+          identifier: PROPERTY,
+          hack: `@${name.substr(0, len)}`,
+        });
+      }
+    }
+  }
+};

node_modules/stylehacks/src/plugins/leadingUnderscore.js

@@ -0,0 +1,51 @@
+'use strict';
+const BasePlugin = require('../plugin');
+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) {
+    return match[0];
+  }
+
+  return '';
+}
+
+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;
+
+    if (before && before.includes('_')) {
+      this.push(decl, {
+        identifier: PROPERTY,
+        hack: `${before.trim()}${decl.prop}`,
+      });
+    }
+
+    if (
+      decl.prop[0] === '-' &&
+      decl.prop[1] !== '-' &&
+      vendorPrefix(decl.prop) === ''
+    ) {
+      this.push(decl, {
+        identifier: PROPERTY,
+        hack: decl.prop,
+      });
+    }
+  }
+};

node_modules/stylehacks/src/plugins/mediaSlash0.js

@@ -0,0 +1,26 @@
+'use strict';
+const BasePlugin = require('../plugin');
+const { IE_8 } = require('../dictionary/browsers');
+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();
+
+    if (params.toLowerCase() === '\\0screen') {
+      this.push(rule, {
+        identifier: MEDIA_QUERY,
+        hack: params,
+      });
+    }
+  }
+};

node_modules/stylehacks/src/plugins/mediaSlash0Slash9.js

@@ -0,0 +1,27 @@
+'use strict';
+const BasePlugin = require('../plugin');
+const { IE_5_5, IE_6, IE_7, IE_8 } = require('../dictionary/browsers');
+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();
+
+    if (params.toLowerCase() === '\\0screen\\,screen\\9') {
+      this.push(rule, {
+        identifier: MEDIA_QUERY,
+        hack: params,
+      });
+    }
+  }
+};

node_modules/stylehacks/src/plugins/mediaSlash9.js

@@ -0,0 +1,27 @@
+'use strict';
+const BasePlugin = require('../plugin');
+const { IE_5_5, IE_6, IE_7 } = require('../dictionary/browsers');
+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();
+
+    if (params.toLowerCase() === 'screen\\9') {
+      this.push(rule, {
+        identifier: MEDIA_QUERY,
+        hack: params,
+      });
+    }
+  }
+};

node_modules/stylehacks/src/plugins/slash9.js

@@ -0,0 +1,26 @@
+'use strict';
+const BasePlugin = require('../plugin.js');
+const { IE_6, IE_7, IE_8 } = require('../dictionary/browsers');
+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) {
+      this.push(decl, {
+        identifier: VALUE,
+        hack: v,
+      });
+    }
+  }
+};

node_modules/stylehacks/src/plugins/starHtml.js

@@ -0,0 +1,50 @@
+'use strict';
+const parser = require('postcss-selector-parser');
+const exists = require('../exists');
+const isMixin = require('../isMixin');
+const BasePlugin = require('../plugin');
+const { IE_5_5, IE_6 } = require('../dictionary/browsers');
+const { SELECTOR } = require('../dictionary/identifiers');
+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;
+    }
+    parser(this.analyse(rule)).processSync(rule.selector);
+  }
+
+  /**
+   * @param {import('postcss').Rule} rule
+   * @return {parser.SyncProcessor<void>}
+   */
+  analyse(rule) {
+    return (selectors) => {
+      selectors.each((selector) => {
+        if (
+          exists(selector, 0, '*') &&
+          exists(selector, 1, ' ') &&
+          exists(selector, 2, HTML) &&
+          exists(selector, 3, ' ') &&
+          selector.at(4)
+        ) {
+          this.push(rule, {
+            identifier: SELECTOR,
+            hack: selector.toString(),
+          });
+        }
+      });
+    };
+  }
+};

node_modules/stylehacks/src/plugins/trailingSlashComma.js

@@ -0,0 +1,36 @@
+'use strict';
+const BasePlugin = require('../plugin');
+const isMixin = require('../isMixin');
+const { IE_5_5, IE_6, IE_7 } = require('../dictionary/browsers');
+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;
+    }
+
+    const { selector } = rule;
+    const trim = selector.trim();
+
+    if (
+      trim.lastIndexOf(',') === selector.length - 1 ||
+      trim.lastIndexOf('\\') === selector.length - 1
+    ) {
+      this.push(rule, {
+        identifier: SELECTOR,
+        hack: selector,
+      });
+    }
+  }
+};