postcss 8.3.9 → 8.4.31

package/lib/list.js

@@ -1,13 +1,23 @@
 'use strict'
 
 let list = {
+  comma(string) {
+    return list.split(string, [','], true)
+  },
+
+  space(string) {
+    let spaces = [' ', '\n', '\t']
+    return list.split(string, spaces)
+  },
+
   split(string, separators, last) {
     let array = []
     let current = ''
     let split = false
 
     let func = 0
-    let quote = false
+    let inQuote = false
+    let prevQuote = ''
     let escape = false
 
     for (let letter of string) {
@@ -15,12 +25,13 @@ let list = {
         escape = false
       } else if (letter === '\\') {
         escape = true
-      } else if (quote) {
-        if (letter === quote) {
-          quote = false
+      } else if (inQuote) {
+        if (letter === prevQuote) {
+          inQuote = false
         }
       } else if (letter === '"' || letter === "'") {
-        quote = letter
+        inQuote = true
+        prevQuote = letter
       } else if (letter === '(') {
         func += 1
       } else if (letter === ')') {
@@ -40,15 +51,6 @@ let list = {
 
     if (last || current !== '') array.push(current.trim())
     return array
-  },
-
-  space(string) {
-    let spaces = [' ', '\n', '\t']
-    return list.split(string, spaces)
-  },
-
-  comma(string) {
-    return list.split(string, [','], true)
   }
 }
 

package/lib/map-generator.js

@@ -1,96 +1,45 @@
 'use strict'
 
 let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')
-let { dirname, resolve, relative, sep } = require('path')
+let { dirname, relative, resolve, sep } = require('path')
 let { pathToFileURL } = require('url')
 
+let Input = require('./input')
+
 let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator)
 let pathAvailable = Boolean(dirname && resolve && relative && sep)
 
 class MapGenerator {
-  constructor(stringify, root, opts) {
+  constructor(stringify, root, opts, cssString) {
     this.stringify = stringify
     this.mapOpts = opts.map || {}
     this.root = root
     this.opts = opts
-  }
-
-  isMap() {
-    if (typeof this.opts.map !== 'undefined') {
-      return !!this.opts.map
-    }
-    return this.previous().length > 0
-  }
-
-  previous() {
-    if (!this.previousMaps) {
-      this.previousMaps = []
-      this.root.walk(node => {
-        if (node.source && node.source.input.map) {
-          let map = node.source.input.map
-          if (!this.previousMaps.includes(map)) {
-            this.previousMaps.push(map)
-          }
-        }
-      })
-    }
+    this.css = cssString
+    this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute
 
-    return this.previousMaps
+    this.memoizedFileURLs = new Map()
+    this.memoizedPaths = new Map()
+    this.memoizedURLs = new Map()
   }
 
-  isInline() {
-    if (typeof this.mapOpts.inline !== 'undefined') {
-      return this.mapOpts.inline
-    }
-
-    let annotation = this.mapOpts.annotation
-    if (typeof annotation !== 'undefined' && annotation !== true) {
-      return false
-    }
-
-    if (this.previous().length) {
-      return this.previous().some(i => i.inline)
-    }
-    return true
-  }
-
-  isSourcesContent() {
-    if (typeof this.mapOpts.sourcesContent !== 'undefined') {
-      return this.mapOpts.sourcesContent
-    }
-    if (this.previous().length) {
-      return this.previous().some(i => i.withContent())
-    }
-    return true
-  }
-
-  clearAnnotation() {
-    if (this.mapOpts.annotation === false) return
+  addAnnotation() {
+    let content
 
-    let node
-    for (let i = this.root.nodes.length - 1; i >= 0; i--) {
-      node = this.root.nodes[i]
-      if (node.type !== 'comment') continue
-      if (node.text.indexOf('# sourceMappingURL=') === 0) {
-        this.root.removeChild(i)
-      }
+    if (this.isInline()) {
+      content =
+        'data:application/json;base64,' + this.toBase64(this.map.toString())
+    } else if (typeof this.mapOpts.annotation === 'string') {
+      content = this.mapOpts.annotation
+    } else if (typeof this.mapOpts.annotation === 'function') {
+      content = this.mapOpts.annotation(this.opts.to, this.root)
+    } else {
+      content = this.outputFile() + '.map'
     }
-  }
+    let eol = '\n'
+    if (this.css.includes('\r\n')) eol = '\r\n'
 
-  setSourcesContent() {
-    let already = {}
-    this.root.walk(node => {
-      if (node.source) {
-        let from = node.source.input.from
-        if (from && !already[from]) {
-          already[from] = true
-          this.map.setSourceContent(
-            this.toUrl(this.path(from)),
-            node.source.input.css
-          )
-        }
-      }
-    })
+    this.css += eol + '/*# sourceMappingURL=' + content + ' */'
   }
 
   applyPrevMaps() {
@@ -112,107 +61,62 @@ class MapGenerator {
     }
   }
 
-  isAnnotation() {
-    if (this.isInline()) {
-      return true
-    }
-    if (typeof this.mapOpts.annotation !== 'undefined') {
-      return this.mapOpts.annotation
-    }
-    if (this.previous().length) {
-      return this.previous().some(i => i.annotation)
-    }
-    return true
-  }
+  clearAnnotation() {
+    if (this.mapOpts.annotation === false) return
 
-  toBase64(str) {
-    if (Buffer) {
-      return Buffer.from(str).toString('base64')
-    } else {
-      // istanbul ignore next
-      return window.btoa(unescape(encodeURIComponent(str)))
+    if (this.root) {
+      let node
+      for (let i = this.root.nodes.length - 1; i >= 0; i--) {
+        node = this.root.nodes[i]
+        if (node.type !== 'comment') continue
+        if (node.text.indexOf('# sourceMappingURL=') === 0) {
+          this.root.removeChild(i)
+        }
+      }
+    } else if (this.css) {
+      this.css = this.css.replace(/(\n)?\/\*#[\S\s]*?\*\/$/gm, '')
     }
   }
 
-  addAnnotation() {
-    let content
-
-    if (this.isInline()) {
-      content =
-        'data:application/json;base64,' + this.toBase64(this.map.toString())
-    } else if (typeof this.mapOpts.annotation === 'string') {
-      content = this.mapOpts.annotation
-    } else if (typeof this.mapOpts.annotation === 'function') {
-      content = this.mapOpts.annotation(this.opts.to, this.root)
+  generate() {
+    this.clearAnnotation()
+    if (pathAvailable && sourceMapAvailable && this.isMap()) {
+      return this.generateMap()
     } else {
-      content = this.outputFile() + '.map'
+      let result = ''
+      this.stringify(this.root, i => {
+        result += i
+      })
+      return [result]
     }
-
-    let eol = '\n'
-    if (this.css.includes('\r\n')) eol = '\r\n'
-
-    this.css += eol + '/*# sourceMappingURL=' + content + ' */'
   }
 
-  outputFile() {
-    if (this.opts.to) {
-      return this.path(this.opts.to)
-    }
-    if (this.opts.from) {
-      return this.path(this.opts.from)
+  generateMap() {
+    if (this.root) {
+      this.generateString()
+    } else if (this.previous().length === 1) {
+      let prev = this.previous()[0].consumer()
+      prev.file = this.outputFile()
+      this.map = SourceMapGenerator.fromSourceMap(prev)
+    } else {
+      this.map = new SourceMapGenerator({ file: this.outputFile() })
+      this.map.addMapping({
+        generated: { column: 0, line: 1 },
+        original: { column: 0, line: 1 },
+        source: this.opts.from
+          ? this.toUrl(this.path(this.opts.from))
+          : '<no source>'
+      })
     }
-    return 'to.css'
-  }
 
-  generateMap() {
-    this.generateString()
     if (this.isSourcesContent()) this.setSourcesContent()
-    if (this.previous().length > 0) this.applyPrevMaps()
+    if (this.root && this.previous().length > 0) this.applyPrevMaps()
     if (this.isAnnotation()) this.addAnnotation()
 
     if (this.isInline()) {
       return [this.css]
-    }
-    return [this.css, this.map]
-  }
-
-  path(file) {
-    if (file.indexOf('<') === 0) return file
-    if (/^\w+:\/\//.test(file)) return file
-    if (this.mapOpts.absolute) return file
-
-    let from = this.opts.to ? dirname(this.opts.to) : '.'
-
-    if (typeof this.mapOpts.annotation === 'string') {
-      from = dirname(resolve(from, this.mapOpts.annotation))
-    }
-
-    file = relative(from, file)
-    return file
-  }
-
-  toUrl(path) {
-    if (sep === '\\') {
-      // istanbul ignore next
-      path = path.replace(/\\/g, '/')
-    }
-    return encodeURI(path).replace(/[#?]/g, encodeURIComponent)
-  }
-
-  sourcePath(node) {
-    if (this.mapOpts.from) {
-      return this.toUrl(this.mapOpts.from)
-    } else if (this.mapOpts.absolute) {
-      if (pathToFileURL) {
-        return pathToFileURL(node.source.input.from).toString()
-      } else {
-        // istanbul ignore next
-        throw new Error(
-          '`map.absolute` option is not available in this PostCSS build'
-        )
-      }
     } else {
-      return this.toUrl(this.path(node.source.input.from))
+      return [this.css, this.map]
     }
   }
 
@@ -225,9 +129,9 @@ class MapGenerator {
 
     let noSource = '<no source>'
     let mapping = {
-      source: '',
-      generated: { line: 0, column: 0 },
-      original: { line: 0, column: 0 }
+      generated: { column: 0, line: 0 },
+      original: { column: 0, line: 0 },
+      source: ''
     }
 
     let lines, last
@@ -261,7 +165,9 @@ class MapGenerator {
 
       if (node && type !== 'start') {
         let p = node.parent || { raws: {} }
-        if (node.type !== 'decl' || node !== p.last || p.raws.semicolon) {
+        let childless =
+          node.type === 'decl' || (node.type === 'atrule' && !node.nodes)
+        if (!childless || node !== p.last || p.raws.semicolon) {
           if (node.source && node.source.end) {
             mapping.source = this.sourcePath(node)
             mapping.original.line = node.source.end.line
@@ -282,18 +188,171 @@ class MapGenerator {
     })
   }
 
-  generate() {
-    this.clearAnnotation()
+  isAnnotation() {
+    if (this.isInline()) {
+      return true
+    }
+    if (typeof this.mapOpts.annotation !== 'undefined') {
+      return this.mapOpts.annotation
+    }
+    if (this.previous().length) {
+      return this.previous().some(i => i.annotation)
+    }
+    return true
+  }
 
-    if (pathAvailable && sourceMapAvailable && this.isMap()) {
-      return this.generateMap()
+  isInline() {
+    if (typeof this.mapOpts.inline !== 'undefined') {
+      return this.mapOpts.inline
     }
 
-    let result = ''
-    this.stringify(this.root, i => {
-      result += i
-    })
-    return [result]
+    let annotation = this.mapOpts.annotation
+    if (typeof annotation !== 'undefined' && annotation !== true) {
+      return false
+    }
+
+    if (this.previous().length) {
+      return this.previous().some(i => i.inline)
+    }
+    return true
+  }
+
+  isMap() {
+    if (typeof this.opts.map !== 'undefined') {
+      return !!this.opts.map
+    }
+    return this.previous().length > 0
+  }
+
+  isSourcesContent() {
+    if (typeof this.mapOpts.sourcesContent !== 'undefined') {
+      return this.mapOpts.sourcesContent
+    }
+    if (this.previous().length) {
+      return this.previous().some(i => i.withContent())
+    }
+    return true
+  }
+
+  outputFile() {
+    if (this.opts.to) {
+      return this.path(this.opts.to)
+    } else if (this.opts.from) {
+      return this.path(this.opts.from)
+    } else {
+      return 'to.css'
+    }
+  }
+
+  path(file) {
+    if (this.mapOpts.absolute) return file
+    if (file.charCodeAt(0) === 60 /* `<` */) return file
+    if (/^\w+:\/\//.test(file)) return file
+    let cached = this.memoizedPaths.get(file)
+    if (cached) return cached
+
+    let from = this.opts.to ? dirname(this.opts.to) : '.'
+
+    if (typeof this.mapOpts.annotation === 'string') {
+      from = dirname(resolve(from, this.mapOpts.annotation))
+    }
+
+    let path = relative(from, file)
+    this.memoizedPaths.set(file, path)
+
+    return path
+  }
+
+  previous() {
+    if (!this.previousMaps) {
+      this.previousMaps = []
+      if (this.root) {
+        this.root.walk(node => {
+          if (node.source && node.source.input.map) {
+            let map = node.source.input.map
+            if (!this.previousMaps.includes(map)) {
+              this.previousMaps.push(map)
+            }
+          }
+        })
+      } else {
+        let input = new Input(this.css, this.opts)
+        if (input.map) this.previousMaps.push(input.map)
+      }
+    }
+
+    return this.previousMaps
+  }
+
+  setSourcesContent() {
+    let already = {}
+    if (this.root) {
+      this.root.walk(node => {
+        if (node.source) {
+          let from = node.source.input.from
+          if (from && !already[from]) {
+            already[from] = true
+            let fromUrl = this.usesFileUrls
+              ? this.toFileUrl(from)
+              : this.toUrl(this.path(from))
+            this.map.setSourceContent(fromUrl, node.source.input.css)
+          }
+        }
+      })
+    } else if (this.css) {
+      let from = this.opts.from
+        ? this.toUrl(this.path(this.opts.from))
+        : '<no source>'
+      this.map.setSourceContent(from, this.css)
+    }
+  }
+
+  sourcePath(node) {
+    if (this.mapOpts.from) {
+      return this.toUrl(this.mapOpts.from)
+    } else if (this.usesFileUrls) {
+      return this.toFileUrl(node.source.input.from)
+    } else {
+      return this.toUrl(this.path(node.source.input.from))
+    }
+  }
+
+  toBase64(str) {
+    if (Buffer) {
+      return Buffer.from(str).toString('base64')
+    } else {
+      return window.btoa(unescape(encodeURIComponent(str)))
+    }
+  }
+
+  toFileUrl(path) {
+    let cached = this.memoizedFileURLs.get(path)
+    if (cached) return cached
+
+    if (pathToFileURL) {
+      let fileURL = pathToFileURL(path).toString()
+      this.memoizedFileURLs.set(path, fileURL)
+
+      return fileURL
+    } else {
+      throw new Error(
+        '`map.absolute` option is not available in this PostCSS build'
+      )
+    }
+  }
+
+  toUrl(path) {
+    let cached = this.memoizedURLs.get(path)
+    if (cached) return cached
+
+    if (sep === '\\') {
+      path = path.replace(/\\/g, '/')
+    }
+
+    let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent)
+    this.memoizedURLs.set(path, url)
+
+    return url
   }
 }
 

package/lib/no-work-result.d.ts

@@ -0,0 +1,46 @@
+import LazyResult from './lazy-result.js'
+import { SourceMap } from './postcss.js'
+import Processor from './processor.js'
+import Result, { Message, ResultOptions } from './result.js'
+import Root from './root.js'
+import Warning from './warning.js'
+
+declare namespace NoWorkResult {
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { NoWorkResult_ as default }
+}
+
+/**
+ * A Promise proxy for the result of PostCSS transformations.
+ * This lazy result instance doesn't parse css unless `NoWorkResult#root` or `Result#root`
+ * are accessed. See the example below for details.
+ * A `NoWork` instance is returned by `Processor#process` ONLY when no plugins defined.
+ *
+ * ```js
+ * const noWorkResult = postcss().process(css) // No plugins are defined.
+ *                                             // CSS is not parsed
+ * let root = noWorkResult.root // now css is parsed because we accessed the root
+ * ```
+ */
+declare class NoWorkResult_ implements LazyResult<Root> {
+  catch: Promise<Result<Root>>['catch']
+  finally: Promise<Result<Root>>['finally']
+  then: Promise<Result<Root>>['then']
+  constructor(processor: Processor, css: string, opts: ResultOptions)
+  async(): Promise<Result<Root>>
+  sync(): Result<Root>
+  toString(): string
+  warnings(): Warning[]
+  get content(): string
+  get css(): string
+  get map(): SourceMap
+  get messages(): Message[]
+  get opts(): ResultOptions
+  get processor(): Processor
+  get root(): Root
+  get [Symbol.toStringTag](): string
+}
+
+declare class NoWorkResult extends NoWorkResult_ {}
+
+export = NoWorkResult

package/lib/no-work-result.js

@@ -0,0 +1,135 @@
+'use strict'
+
+let MapGenerator = require('./map-generator')
+let stringify = require('./stringify')
+let warnOnce = require('./warn-once')
+let parse = require('./parse')
+const Result = require('./result')
+
+class NoWorkResult {
+  constructor(processor, css, opts) {
+    css = css.toString()
+    this.stringified = false
+
+    this._processor = processor
+    this._css = css
+    this._opts = opts
+    this._map = undefined
+    let root
+
+    let str = stringify
+    this.result = new Result(this._processor, root, this._opts)
+    this.result.css = css
+
+    let self = this
+    Object.defineProperty(this.result, 'root', {
+      get() {
+        return self.root
+      }
+    })
+
+    let map = new MapGenerator(str, root, this._opts, css)
+    if (map.isMap()) {
+      let [generatedCSS, generatedMap] = map.generate()
+      if (generatedCSS) {
+        this.result.css = generatedCSS
+      }
+      if (generatedMap) {
+        this.result.map = generatedMap
+      }
+    }
+  }
+
+  async() {
+    if (this.error) return Promise.reject(this.error)
+    return Promise.resolve(this.result)
+  }
+
+  catch(onRejected) {
+    return this.async().catch(onRejected)
+  }
+
+  finally(onFinally) {
+    return this.async().then(onFinally, onFinally)
+  }
+
+  sync() {
+    if (this.error) throw this.error
+    return this.result
+  }
+
+  then(onFulfilled, onRejected) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (!('from' in this._opts)) {
+        warnOnce(
+          'Without `from` option PostCSS could generate wrong source map ' +
+            'and will not find Browserslist config. Set it to CSS file path ' +
+            'or to `undefined` to prevent this warning.'
+        )
+      }
+    }
+
+    return this.async().then(onFulfilled, onRejected)
+  }
+
+  toString() {
+    return this._css
+  }
+
+  warnings() {
+    return []
+  }
+
+  get content() {
+    return this.result.css
+  }
+
+  get css() {
+    return this.result.css
+  }
+
+  get map() {
+    return this.result.map
+  }
+
+  get messages() {
+    return []
+  }
+
+  get opts() {
+    return this.result.opts
+  }
+
+  get processor() {
+    return this.result.processor
+  }
+
+  get root() {
+    if (this._root) {
+      return this._root
+    }
+
+    let root
+    let parser = parse
+
+    try {
+      root = parser(this._css, this._opts)
+    } catch (error) {
+      this.error = error
+    }
+
+    if (this.error) {
+      throw this.error
+    } else {
+      this._root = root
+      return root
+    }
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'NoWorkResult'
+  }
+}
+
+module.exports = NoWorkResult
+NoWorkResult.default = NoWorkResult