autoprefixer 10.4.13 → 10.4.15

package/lib/supports.js

@@ -1,5 +1,5 @@
 let featureQueries = require('caniuse-lite/data/features/css-featurequeries.js')
-let { feature } = require('caniuse-lite')
+let feature = require('caniuse-lite/dist/unpacker/feature')
 let { parse } = require('postcss')
 
 let Browsers = require('./browsers')
@@ -27,73 +27,89 @@ class Supports {
   }
 
   /**
-   * Return prefixer only with @supports supported browsers
+   * Add prefixes
    */
-  prefixer() {
-    if (this.prefixerCache) {
-      return this.prefixerCache
-    }
+  add(nodes, all) {
+    return nodes.map(i => {
+      if (this.isProp(i)) {
+        let prefixed = this.prefixed(i[0])
+        if (prefixed.length > 1) {
+          return this.convert(prefixed)
+        }
 
-    let filtered = this.all.browsers.selected.filter(i => {
-      return supported.includes(i)
-    })
+        return i
+      }
 
-    let browsers = new Browsers(
-      this.all.browsers.data,
-      filtered,
-      this.all.options
-    )
-    this.prefixerCache = new this.Prefixes(
-      this.all.data,
-      browsers,
-      this.all.options
-    )
-    return this.prefixerCache
+      if (typeof i === 'object') {
+        return this.add(i, all)
+      }
+
+      return i
+    })
   }
 
   /**
-   * Parse string into declaration property and value
+   * Clean brackets with one child
    */
-  parse(str) {
-    let parts = str.split(':')
-    let prop = parts[0]
-    let value = parts[1]
-    if (!value) value = ''
-    return [prop.trim(), value.trim()]
+  cleanBrackets(nodes) {
+    return nodes.map(i => {
+      if (typeof i !== 'object') {
+        return i
+      }
+
+      if (i.length === 1 && typeof i[0] === 'object') {
+        return this.cleanBrackets(i[0])
+      }
+
+      return this.cleanBrackets(i)
+    })
   }
 
   /**
-   * Create virtual rule to process it by prefixer
+   * Add " or " between properties and convert it to brackets format
    */
-  virtual(str) {
-    let [prop, value] = this.parse(str)
-    let rule = parse('a{}').first
-    rule.append({ prop, value, raws: { before: '' } })
-    return rule
+  convert(progress) {
+    let result = ['']
+    for (let i of progress) {
+      result.push([`${i.prop}: ${i.value}`])
+      result.push(' or ')
+    }
+    result[result.length - 1] = ''
+    return result
   }
 
   /**
-   * Return array of Declaration with all necessary prefixes
+   * Check global options
    */
-  prefixed(str) {
-    let rule = this.virtual(str)
-    if (this.disabled(rule.first)) {
-      return rule.nodes
+  disabled(node) {
+    if (!this.all.options.grid) {
+      if (node.prop === 'display' && node.value.includes('grid')) {
+        return true
+      }
+      if (node.prop.includes('grid') || node.prop === 'justify-items') {
+        return true
+      }
     }
 
-    let result = { warn: () => null }
-
-    let prefixer = this.prefixer().add[rule.first.prop]
-    prefixer && prefixer.process && prefixer.process(rule.first, result)
-
-    for (let decl of rule.nodes) {
-      for (let value of this.prefixer().values('add', rule.first.prop)) {
-        value.process(decl)
+    if (this.all.options.flexbox === false) {
+      if (node.prop === 'display' && node.value.includes('flex')) {
+        return true
+      }
+      let other = ['order', 'justify-content', 'align-items', 'align-content']
+      if (node.prop.includes('flex') || other.includes(node.prop)) {
+        return true
       }
-      Value.save(this.all, decl)
     }
 
-    return rule.nodes
+    return false
+  }
+
+  /**
+   * Return true if prefixed property has no unprefixed
+   */
+  isHack(all, unprefixed) {
+    let check = new RegExp(`(\\(|\\s)${utils.escapeRegexp(unprefixed)}:`)
+    return !check.test(all)
   }
 
   /**
@@ -121,99 +137,6 @@ class Supports {
     )
   }
 
-  /**
-   * Return true if prefixed property has no unprefixed
-   */
-  isHack(all, unprefixed) {
-    let check = new RegExp(`(\\(|\\s)${utils.escapeRegexp(unprefixed)}:`)
-    return !check.test(all)
-  }
-
-  /**
-   * Return true if we need to remove node
-   */
-  toRemove(str, all) {
-    let [prop, value] = this.parse(str)
-    let unprefixed = this.all.unprefixed(prop)
-
-    let cleaner = this.all.cleaner()
-
-    if (
-      cleaner.remove[prop] &&
-      cleaner.remove[prop].remove &&
-      !this.isHack(all, unprefixed)
-    ) {
-      return true
-    }
-
-    for (let checker of cleaner.values('remove', unprefixed)) {
-      if (checker.check(value)) {
-        return true
-      }
-    }
-
-    return false
-  }
-
-  /**
-   * Remove all unnecessary prefixes
-   */
-  remove(nodes, all) {
-    let i = 0
-    while (i < nodes.length) {
-      if (
-        !this.isNot(nodes[i - 1]) &&
-        this.isProp(nodes[i]) &&
-        this.isOr(nodes[i + 1])
-      ) {
-        if (this.toRemove(nodes[i][0], all)) {
-          nodes.splice(i, 2)
-          continue
-        }
-
-        i += 2
-        continue
-      }
-
-      if (typeof nodes[i] === 'object') {
-        nodes[i] = this.remove(nodes[i], all)
-      }
-
-      i += 1
-    }
-    return nodes
-  }
-
-  /**
-   * Clean brackets with one child
-   */
-  cleanBrackets(nodes) {
-    return nodes.map(i => {
-      if (typeof i !== 'object') {
-        return i
-      }
-
-      if (i.length === 1 && typeof i[0] === 'object') {
-        return this.cleanBrackets(i[0])
-      }
-
-      return this.cleanBrackets(i)
-    })
-  }
-
-  /**
-   * Add " or " between properties and convert it to brackets format
-   */
-  convert(progress) {
-    let result = ['']
-    for (let i of progress) {
-      result.push([`${i.prop}: ${i.value}`])
-      result.push(' or ')
-    }
-    result[result.length - 1] = ''
-    return result
-  }
-
   /**
    * Compress value functions into a string nodes
    */
@@ -239,25 +162,63 @@ class Supports {
   }
 
   /**
-   * Add prefixes
+   * Parse string into declaration property and value
    */
-  add(nodes, all) {
-    return nodes.map(i => {
-      if (this.isProp(i)) {
-        let prefixed = this.prefixed(i[0])
-        if (prefixed.length > 1) {
-          return this.convert(prefixed)
-        }
+  parse(str) {
+    let parts = str.split(':')
+    let prop = parts[0]
+    let value = parts[1]
+    if (!value) value = ''
+    return [prop.trim(), value.trim()]
+  }
 
-        return i
-      }
+  /**
+   * Return array of Declaration with all necessary prefixes
+   */
+  prefixed(str) {
+    let rule = this.virtual(str)
+    if (this.disabled(rule.first)) {
+      return rule.nodes
+    }
 
-      if (typeof i === 'object') {
-        return this.add(i, all)
+    let result = { warn: () => null }
+
+    let prefixer = this.prefixer().add[rule.first.prop]
+    prefixer && prefixer.process && prefixer.process(rule.first, result)
+
+    for (let decl of rule.nodes) {
+      for (let value of this.prefixer().values('add', rule.first.prop)) {
+        value.process(decl)
       }
+      Value.save(this.all, decl)
+    }
 
-      return i
+    return rule.nodes
+  }
+
+  /**
+   * Return prefixer only with @supports supported browsers
+   */
+  prefixer() {
+    if (this.prefixerCache) {
+      return this.prefixerCache
+    }
+
+    let filtered = this.all.browsers.selected.filter(i => {
+      return supported.includes(i)
     })
+
+    let browsers = new Browsers(
+      this.all.browsers.data,
+      filtered,
+      this.all.options
+    )
+    this.prefixerCache = new this.Prefixes(
+      this.all.data,
+      browsers,
+      this.all.options
+    )
+    return this.prefixerCache
   }
 
   /**
@@ -273,30 +234,69 @@ class Supports {
   }
 
   /**
-   * Check global options
+   * Remove all unnecessary prefixes
    */
-  disabled(node) {
-    if (!this.all.options.grid) {
-      if (node.prop === 'display' && node.value.includes('grid')) {
-        return true
+  remove(nodes, all) {
+    let i = 0
+    while (i < nodes.length) {
+      if (
+        !this.isNot(nodes[i - 1]) &&
+        this.isProp(nodes[i]) &&
+        this.isOr(nodes[i + 1])
+      ) {
+        if (this.toRemove(nodes[i][0], all)) {
+          nodes.splice(i, 2)
+          continue
+        }
+
+        i += 2
+        continue
       }
-      if (node.prop.includes('grid') || node.prop === 'justify-items') {
-        return true
+
+      if (typeof nodes[i] === 'object') {
+        nodes[i] = this.remove(nodes[i], all)
       }
+
+      i += 1
     }
+    return nodes
+  }
 
-    if (this.all.options.flexbox === false) {
-      if (node.prop === 'display' && node.value.includes('flex')) {
-        return true
-      }
-      let other = ['order', 'justify-content', 'align-items', 'align-content']
-      if (node.prop.includes('flex') || other.includes(node.prop)) {
+  /**
+   * Return true if we need to remove node
+   */
+  toRemove(str, all) {
+    let [prop, value] = this.parse(str)
+    let unprefixed = this.all.unprefixed(prop)
+
+    let cleaner = this.all.cleaner()
+
+    if (
+      cleaner.remove[prop] &&
+      cleaner.remove[prop].remove &&
+      !this.isHack(all, unprefixed)
+    ) {
+      return true
+    }
+
+    for (let checker of cleaner.values('remove', unprefixed)) {
+      if (checker.check(value)) {
         return true
       }
     }
 
     return false
   }
+
+  /**
+   * Create virtual rule to process it by prefixer
+   */
+  virtual(str) {
+    let [prop, value] = this.parse(str)
+    let rule = parse('a{}').first
+    rule.append({ prop, raws: { before: '' }, value })
+    return rule
+  }
 }
 
 module.exports = Supports

package/lib/transition.js

@@ -79,21 +79,6 @@ class Transition {
     }
   }
 
-  /**
-   * Find property name
-   */
-  findProp(param) {
-    let prop = param[0].value
-    if (/^\d/.test(prop)) {
-      for (let [i, token] of param.entries()) {
-        if (i !== 0 && token.type === 'word') {
-          return token.value
-        }
-      }
-    }
-    return prop
-  }
-
   /**
    * Does we already have this declaration
    */
@@ -101,15 +86,6 @@ class Transition {
     return decl.parent.some(i => i.prop === prop && i.value === value)
   }
 
-  /**
-   * Add declaration if it is not exist
-   */
-  cloneBefore(decl, prop, value) {
-    if (!this.already(decl, prop, value)) {
-      decl.cloneBefore({ prop, value })
-    }
-  }
-
   /**
    * Show transition-property warning
    */
@@ -156,79 +132,30 @@ class Transition {
   }
 
   /**
-   * Process transition and remove all unnecessary properties
+   * Remove all non-webkit prefixes and unprefixed params if we have prefixed
    */
-  remove(decl) {
-    let params = this.parse(decl.value)
-    params = params.filter(i => {
-      let prop = this.prefixes.remove[this.findProp(i)]
-      return !prop || !prop.remove
-    })
-    let value = this.stringify(params)
-
-    if (decl.value === value) {
-      return
-    }
-
-    if (params.length === 0) {
-      decl.remove()
-      return
-    }
-
-    let double = decl.parent.some(i => {
-      return i.prop === decl.prop && i.value === value
-    })
-    let smaller = decl.parent.some(i => {
-      return i !== decl && i.prop === decl.prop && i.value.length > value.length
-    })
-
-    if (double || smaller) {
-      decl.remove()
-      return
-    }
-
-    decl.value = value
-  }
+  cleanFromUnprefixed(params, prefix) {
+    let remove = params
+      .map(i => this.findProp(i))
+      .filter(i => i.slice(0, prefix.length) === prefix)
+      .map(i => this.prefixes.unprefixed(i))
 
-  /**
-   * Parse properties list to array
-   */
-  parse(value) {
-    let ast = parser(value)
     let result = []
-    let param = []
-    for (let node of ast.nodes) {
-      param.push(node)
-      if (node.type === 'div' && node.value === ',') {
+    for (let param of params) {
+      let prop = this.findProp(param)
+      let p = vendor.prefix(prop)
+      if (!remove.includes(prop) && (p === prefix || p === '')) {
         result.push(param)
-        param = []
       }
     }
-    result.push(param)
-    return result.filter(i => i.length > 0)
+    return result
   }
 
-  /**
-   * Return properties string from array
-   */
-  stringify(params) {
-    if (params.length === 0) {
-      return ''
-    }
-    let nodes = []
-    for (let param of params) {
-      if (param[param.length - 1].type !== 'div') {
-        param.push(this.div(params))
-      }
-      nodes = nodes.concat(param)
-    }
-    if (nodes[0].type === 'div') {
-      nodes = nodes.slice(1)
-    }
-    if (nodes[nodes.length - 1].type === 'div') {
-      nodes = nodes.slice(0, +-2 + 1 || undefined)
-    }
-    return parser.stringify({ nodes })
+  cleanOtherPrefixes(params, prefix) {
+    return params.filter(param => {
+      let current = vendor.prefix(this.findProp(param))
+      return current === '' || current === prefix
+    })
   }
 
   /**
@@ -248,6 +175,32 @@ class Transition {
     return result
   }
 
+  /**
+   * Add declaration if it is not exist
+   */
+  cloneBefore(decl, prop, value) {
+    if (!this.already(decl, prop, value)) {
+      decl.cloneBefore({ prop, value })
+    }
+  }
+
+  /**
+   * Check property for disabled by option
+   */
+  disabled(prop, prefix) {
+    let other = ['order', 'justify-content', 'align-self', 'align-content']
+    if (prop.includes('flex') || other.includes(prop)) {
+      if (this.prefixes.options.flexbox === false) {
+        return true
+      }
+
+      if (this.prefixes.options.flexbox === 'no-2009') {
+        return prefix.includes('2009')
+      }
+    }
+    return undefined
+  }
+
   /**
    * Find or create separator
    */
@@ -259,51 +212,75 @@ class Transition {
         }
       }
     }
-    return { type: 'div', value: ',', after: ' ' }
+    return { after: ' ', type: 'div', value: ',' }
   }
 
-  cleanOtherPrefixes(params, prefix) {
-    return params.filter(param => {
-      let current = vendor.prefix(this.findProp(param))
-      return current === '' || current === prefix
-    })
+  /**
+   * Find property name
+   */
+  findProp(param) {
+    let prop = param[0].value
+    if (/^\d/.test(prop)) {
+      for (let [i, token] of param.entries()) {
+        if (i !== 0 && token.type === 'word') {
+          return token.value
+        }
+      }
+    }
+    return prop
   }
 
   /**
-   * Remove all non-webkit prefixes and unprefixed params if we have prefixed
+   * Parse properties list to array
    */
-  cleanFromUnprefixed(params, prefix) {
-    let remove = params
-      .map(i => this.findProp(i))
-      .filter(i => i.slice(0, prefix.length) === prefix)
-      .map(i => this.prefixes.unprefixed(i))
-
+  parse(value) {
+    let ast = parser(value)
     let result = []
-    for (let param of params) {
-      let prop = this.findProp(param)
-      let p = vendor.prefix(prop)
-      if (!remove.includes(prop) && (p === prefix || p === '')) {
+    let param = []
+    for (let node of ast.nodes) {
+      param.push(node)
+      if (node.type === 'div' && node.value === ',') {
         result.push(param)
+        param = []
       }
     }
-    return result
+    result.push(param)
+    return result.filter(i => i.length > 0)
   }
 
   /**
-   * Check property for disabled by option
+   * Process transition and remove all unnecessary properties
    */
-  disabled(prop, prefix) {
-    let other = ['order', 'justify-content', 'align-self', 'align-content']
-    if (prop.includes('flex') || other.includes(prop)) {
-      if (this.prefixes.options.flexbox === false) {
-        return true
-      }
+  remove(decl) {
+    let params = this.parse(decl.value)
+    params = params.filter(i => {
+      let prop = this.prefixes.remove[this.findProp(i)]
+      return !prop || !prop.remove
+    })
+    let value = this.stringify(params)
 
-      if (this.prefixes.options.flexbox === 'no-2009') {
-        return prefix.includes('2009')
-      }
+    if (decl.value === value) {
+      return
     }
-    return undefined
+
+    if (params.length === 0) {
+      decl.remove()
+      return
+    }
+
+    let double = decl.parent.some(i => {
+      return i.prop === decl.prop && i.value === value
+    })
+    let smaller = decl.parent.some(i => {
+      return i !== decl && i.prop === decl.prop && i.value.length > value.length
+    })
+
+    if (double || smaller) {
+      decl.remove()
+      return
+    }
+
+    decl.value = value
   }
 
   /**
@@ -324,6 +301,29 @@ class Transition {
 
     return selectors.length > 0 ? selectors : false
   }
+
+  /**
+   * Return properties string from array
+   */
+  stringify(params) {
+    if (params.length === 0) {
+      return ''
+    }
+    let nodes = []
+    for (let param of params) {
+      if (param[param.length - 1].type !== 'div') {
+        param.push(this.div(params))
+      }
+      nodes = nodes.concat(param)
+    }
+    if (nodes[0].type === 'div') {
+      nodes = nodes.slice(1)
+    }
+    if (nodes[nodes.length - 1].type === 'div') {
+      nodes = nodes.slice(0, +-2 + 1 || undefined)
+    }
+    return parser.stringify({ nodes })
+  }
 }
 
 module.exports = Transition