@noodleseed/one 0.5.0 → 0.6.0

package/node_modules/postcss/lib/map-generator.js

@@ -1,376 +0,0 @@
-'use strict'
-
-let { dirname, relative, resolve, sep } = require('path')
-let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')
-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, cssString) {
-    this.stringify = stringify
-    this.mapOpts = opts.map || {}
-    this.root = root
-    this.opts = opts
-    this.css = cssString
-    this.originalCSS = cssString
-    this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute
-
-    this.memoizedFileURLs = new Map()
-    this.memoizedPaths = new Map()
-    this.memoizedURLs = new Map()
-  }
-
-  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)
-    } else {
-      content = this.outputFile() + '.map'
-    }
-    let eol = '\n'
-    if (this.css.includes('\r\n')) eol = '\r\n'
-
-    this.css += eol + '/*# sourceMappingURL=' + content + ' */'
-  }
-
-  applyPrevMaps() {
-    for (let prev of this.previous()) {
-      let from = this.toUrl(this.path(prev.file))
-      let root = prev.root || dirname(prev.file)
-      let map
-
-      if (this.mapOpts.sourcesContent === false) {
-        map = new SourceMapConsumer(prev.text)
-        if (map.sourcesContent) {
-          map.sourcesContent = null
-        }
-      } else {
-        map = prev.consumer()
-      }
-
-      this.map.applySourceMap(map, from, this.toUrl(this.path(root)))
-    }
-  }
-
-  clearAnnotation() {
-    if (this.mapOpts.annotation === false) return
-
-    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.startsWith('# sourceMappingURL=')) {
-          this.root.removeChild(i)
-        }
-      }
-    } else if (this.css) {
-      let startIndex
-      while ((startIndex = this.css.lastIndexOf('/*#')) !== -1) {
-        let endIndex = this.css.indexOf('*/', startIndex + 3)
-        if (endIndex === -1) break
-        while (startIndex > 0 && this.css[startIndex - 1] === '\n') {
-          startIndex--
-        }
-        this.css = this.css.slice(0, startIndex) + this.css.slice(endIndex + 2)
-      }
-    }
-  }
-
-  generate() {
-    this.clearAnnotation()
-    if (pathAvailable && sourceMapAvailable && this.isMap()) {
-      return this.generateMap()
-    } else {
-      let result = ''
-      this.stringify(this.root, i => {
-        result += i
-      })
-      return [result]
-    }
-  }
-
-  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, {
-        ignoreInvalidMapping: true
-      })
-    } else {
-      this.map = new SourceMapGenerator({
-        file: this.outputFile(),
-        ignoreInvalidMapping: true
-      })
-      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>'
-      })
-    }
-
-    if (this.isSourcesContent()) this.setSourcesContent()
-    if (this.root && this.previous().length > 0) this.applyPrevMaps()
-    if (this.isAnnotation()) this.addAnnotation()
-
-    if (this.isInline()) {
-      return [this.css]
-    } else {
-      return [this.css, this.map]
-    }
-  }
-
-  generateString() {
-    this.css = ''
-    this.map = new SourceMapGenerator({
-      file: this.outputFile(),
-      ignoreInvalidMapping: true
-    })
-
-    let line = 1
-    let column = 1
-
-    let noSource = '<no source>'
-    let mapping = {
-      generated: { column: 0, line: 0 },
-      original: { column: 0, line: 0 },
-      source: ''
-    }
-
-    let last, lines
-    this.stringify(this.root, (str, node, type) => {
-      this.css += str
-
-      if (node && type !== 'end') {
-        mapping.generated.line = line
-        mapping.generated.column = column - 1
-        if (node.source && node.source.start) {
-          mapping.source = this.sourcePath(node)
-          mapping.original.line = node.source.start.line
-          mapping.original.column = node.source.start.column - 1
-          this.map.addMapping(mapping)
-        } else {
-          mapping.source = noSource
-          mapping.original.line = 1
-          mapping.original.column = 0
-          this.map.addMapping(mapping)
-        }
-      }
-
-      lines = str.match(/\n/g)
-      if (lines) {
-        line += lines.length
-        last = str.lastIndexOf('\n')
-        column = str.length - last
-      } else {
-        column += str.length
-      }
-
-      if (node && type !== 'start') {
-        let p = node.parent || { raws: {} }
-        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
-            mapping.original.column = node.source.end.column - 1
-            mapping.generated.line = line
-            mapping.generated.column = column - 2
-            this.map.addMapping(mapping)
-          } else {
-            mapping.source = noSource
-            mapping.original.line = 1
-            mapping.original.column = 0
-            mapping.generated.line = line
-            mapping.generated.column = column - 1
-            this.map.addMapping(mapping)
-          }
-        }
-      }
-    })
-  }
-
-  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
-  }
-
-  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
-  }
-
-  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.originalCSS, 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
-  }
-}
-
-module.exports = MapGenerator

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

@@ -1,45 +0,0 @@
-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 {
-  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']
-  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
-  constructor(processor: Processor, css: string, opts: ResultOptions)
-  async(): Promise<Result<Root>>
-  sync(): Result<Root>
-  toString(): string
-  warnings(): Warning[]
-}
-
-declare class NoWorkResult extends NoWorkResult_ {}
-
-export = NoWorkResult

package/node_modules/postcss/lib/no-work-result.js

@@ -1,137 +0,0 @@
-'use strict'
-
-let MapGenerator = require('./map-generator')
-let parse = require('./parse')
-let Result = require('./result')
-let stringify = require('./stringify')
-let warnOnce = require('./warn-once')
-
-class NoWorkResult {
-  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'
-  }
-
-  constructor(processor, css, opts) {
-    css = css.toString()
-    this.stringified = false
-
-    this._processor = processor
-    this._css = css
-    this._opts = opts
-    this._map = undefined
-
-    let str = stringify
-    this.result = new Result(this._processor, undefined, this._opts)
-    this.result.css = css
-
-    let self = this
-    Object.defineProperty(this.result, 'root', {
-      get() {
-        return self.root
-      }
-    })
-
-    let map = new MapGenerator(str, undefined, this._opts, css)
-    if (map.isMap()) {
-      let [generatedCSS, generatedMap] = map.generate()
-      if (generatedCSS) {
-        this.result.css = generatedCSS
-      }
-      if (generatedMap) {
-        this.result.map = generatedMap
-      }
-    } else {
-      map.clearAnnotation()
-      this.result.css = map.css
-    }
-  }
-
-  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 []
-  }
-}
-
-module.exports = NoWorkResult
-NoWorkResult.default = NoWorkResult