switchboard-router 0.5.20 → 0.6.0

package/app/node_modules/next/node_modules/postcss/lib/previous-map.js

@@ -1,142 +0,0 @@
-'use strict'
-
-let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')
-let { existsSync, readFileSync } = require('fs')
-let { dirname, join } = require('path')
-
-function fromBase64(str) {
-  if (Buffer) {
-    return Buffer.from(str, 'base64').toString()
-  } else {
-    /* c8 ignore next 2 */
-    return window.atob(str)
-  }
-}
-
-class PreviousMap {
-  constructor(css, opts) {
-    if (opts.map === false) return
-    this.loadAnnotation(css)
-    this.inline = this.startWith(this.annotation, 'data:')
-
-    let prev = opts.map ? opts.map.prev : undefined
-    let text = this.loadMap(opts.from, prev)
-    if (!this.mapFile && opts.from) {
-      this.mapFile = opts.from
-    }
-    if (this.mapFile) this.root = dirname(this.mapFile)
-    if (text) this.text = text
-  }
-
-  consumer() {
-    if (!this.consumerCache) {
-      this.consumerCache = new SourceMapConsumer(this.text)
-    }
-    return this.consumerCache
-  }
-
-  decodeInline(text) {
-    let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/
-    let baseUri = /^data:application\/json;base64,/
-    let charsetUri = /^data:application\/json;charset=utf-?8,/
-    let uri = /^data:application\/json,/
-
-    if (charsetUri.test(text) || uri.test(text)) {
-      return decodeURIComponent(text.substr(RegExp.lastMatch.length))
-    }
-
-    if (baseCharsetUri.test(text) || baseUri.test(text)) {
-      return fromBase64(text.substr(RegExp.lastMatch.length))
-    }
-
-    let encoding = text.match(/data:application\/json;([^,]+),/)[1]
-    throw new Error('Unsupported source map encoding ' + encoding)
-  }
-
-  getAnnotationURL(sourceMapString) {
-    return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, '').trim()
-  }
-
-  isMap(map) {
-    if (typeof map !== 'object') return false
-    return (
-      typeof map.mappings === 'string' ||
-      typeof map._mappings === 'string' ||
-      Array.isArray(map.sections)
-    )
-  }
-
-  loadAnnotation(css) {
-    let comments = css.match(/\/\*\s*# sourceMappingURL=/gm)
-    if (!comments) return
-
-    // sourceMappingURLs from comments, strings, etc.
-    let start = css.lastIndexOf(comments.pop())
-    let end = css.indexOf('*/', start)
-
-    if (start > -1 && end > -1) {
-      // Locate the last sourceMappingURL to avoid pickin
-      this.annotation = this.getAnnotationURL(css.substring(start, end))
-    }
-  }
-
-  loadFile(path) {
-    this.root = dirname(path)
-    if (existsSync(path)) {
-      this.mapFile = path
-      return readFileSync(path, 'utf-8').toString().trim()
-    }
-  }
-
-  loadMap(file, prev) {
-    if (prev === false) return false
-
-    if (prev) {
-      if (typeof prev === 'string') {
-        return prev
-      } else if (typeof prev === 'function') {
-        let prevPath = prev(file)
-        if (prevPath) {
-          let map = this.loadFile(prevPath)
-          if (!map) {
-            throw new Error(
-              'Unable to load previous source map: ' + prevPath.toString()
-            )
-          }
-          return map
-        }
-      } else if (prev instanceof SourceMapConsumer) {
-        return SourceMapGenerator.fromSourceMap(prev).toString()
-      } else if (prev instanceof SourceMapGenerator) {
-        return prev.toString()
-      } else if (this.isMap(prev)) {
-        return JSON.stringify(prev)
-      } else {
-        throw new Error(
-          'Unsupported previous source map format: ' + prev.toString()
-        )
-      }
-    } else if (this.inline) {
-      return this.decodeInline(this.annotation)
-    } else if (this.annotation) {
-      let map = this.annotation
-      if (file) map = join(dirname(file), map)
-      return this.loadFile(map)
-    }
-  }
-
-  startWith(string, start) {
-    if (!string) return false
-    return string.substr(0, start.length) === start
-  }
-
-  withContent() {
-    return !!(
-      this.consumer().sourcesContent &&
-      this.consumer().sourcesContent.length > 0
-    )
-  }
-}
-
-module.exports = PreviousMap
-PreviousMap.default = PreviousMap

package/app/node_modules/next/node_modules/postcss/lib/processor.js

@@ -1,67 +0,0 @@
-'use strict'
-
-let NoWorkResult = require('./no-work-result')
-let LazyResult = require('./lazy-result')
-let Document = require('./document')
-let Root = require('./root')
-
-class Processor {
-  constructor(plugins = []) {
-    this.version = '8.4.31'
-    this.plugins = this.normalize(plugins)
-  }
-
-  normalize(plugins) {
-    let normalized = []
-    for (let i of plugins) {
-      if (i.postcss === true) {
-        i = i()
-      } else if (i.postcss) {
-        i = i.postcss
-      }
-
-      if (typeof i === 'object' && Array.isArray(i.plugins)) {
-        normalized = normalized.concat(i.plugins)
-      } else if (typeof i === 'object' && i.postcssPlugin) {
-        normalized.push(i)
-      } else if (typeof i === 'function') {
-        normalized.push(i)
-      } else if (typeof i === 'object' && (i.parse || i.stringify)) {
-        if (process.env.NODE_ENV !== 'production') {
-          throw new Error(
-            'PostCSS syntaxes cannot be used as plugins. Instead, please use ' +
-              'one of the syntax/parser/stringifier options as outlined ' +
-              'in your PostCSS runner documentation.'
-          )
-        }
-      } else {
-        throw new Error(i + ' is not a PostCSS plugin')
-      }
-    }
-    return normalized
-  }
-
-  process(css, opts = {}) {
-    if (
-      this.plugins.length === 0 &&
-      typeof opts.parser === 'undefined' &&
-      typeof opts.stringifier === 'undefined' &&
-      typeof opts.syntax === 'undefined'
-    ) {
-      return new NoWorkResult(this, css, opts)
-    } else {
-      return new LazyResult(this, css, opts)
-    }
-  }
-
-  use(plugin) {
-    this.plugins = this.plugins.concat(this.normalize([plugin]))
-    return this
-  }
-}
-
-module.exports = Processor
-Processor.default = Processor
-
-Root.registerProcessor(Processor)
-Document.registerProcessor(Processor)

package/app/node_modules/next/node_modules/postcss/lib/result.js

@@ -1,42 +0,0 @@
-'use strict'
-
-let Warning = require('./warning')
-
-class Result {
-  constructor(processor, root, opts) {
-    this.processor = processor
-    this.messages = []
-    this.root = root
-    this.opts = opts
-    this.css = undefined
-    this.map = undefined
-  }
-
-  toString() {
-    return this.css
-  }
-
-  warn(text, opts = {}) {
-    if (!opts.plugin) {
-      if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
-        opts.plugin = this.lastPlugin.postcssPlugin
-      }
-    }
-
-    let warning = new Warning(text, opts)
-    this.messages.push(warning)
-
-    return warning
-  }
-
-  warnings() {
-    return this.messages.filter(i => i.type === 'warning')
-  }
-
-  get content() {
-    return this.css
-  }
-}
-
-module.exports = Result
-Result.default = Result

package/app/node_modules/next/node_modules/postcss/lib/rule.js

@@ -1,27 +0,0 @@
-'use strict'
-
-let Container = require('./container')
-let list = require('./list')
-
-class Rule extends Container {
-  constructor(defaults) {
-    super(defaults)
-    this.type = 'rule'
-    if (!this.nodes) this.nodes = []
-  }
-
-  get selectors() {
-    return list.comma(this.selector)
-  }
-
-  set selectors(values) {
-    let match = this.selector ? this.selector.match(/,\s*/) : null
-    let sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen')
-    this.selector = values.join(sep)
-  }
-}
-
-module.exports = Rule
-Rule.default = Rule
-
-Container.registerRule(Rule)

package/app/node_modules/next/node_modules/postcss/lib/stringifier.js

@@ -1,353 +0,0 @@
-'use strict'
-
-const DEFAULT_RAW = {
-  after: '\n',
-  beforeClose: '\n',
-  beforeComment: '\n',
-  beforeDecl: '\n',
-  beforeOpen: ' ',
-  beforeRule: '\n',
-  colon: ': ',
-  commentLeft: ' ',
-  commentRight: ' ',
-  emptyBody: '',
-  indent: '    ',
-  semicolon: false
-}
-
-function capitalize(str) {
-  return str[0].toUpperCase() + str.slice(1)
-}
-
-class Stringifier {
-  constructor(builder) {
-    this.builder = builder
-  }
-
-  atrule(node, semicolon) {
-    let name = '@' + node.name
-    let params = node.params ? this.rawValue(node, 'params') : ''
-
-    if (typeof node.raws.afterName !== 'undefined') {
-      name += node.raws.afterName
-    } else if (params) {
-      name += ' '
-    }
-
-    if (node.nodes) {
-      this.block(node, name + params)
-    } else {
-      let end = (node.raws.between || '') + (semicolon ? ';' : '')
-      this.builder(name + params + end, node)
-    }
-  }
-
-  beforeAfter(node, detect) {
-    let value
-    if (node.type === 'decl') {
-      value = this.raw(node, null, 'beforeDecl')
-    } else if (node.type === 'comment') {
-      value = this.raw(node, null, 'beforeComment')
-    } else if (detect === 'before') {
-      value = this.raw(node, null, 'beforeRule')
-    } else {
-      value = this.raw(node, null, 'beforeClose')
-    }
-
-    let buf = node.parent
-    let depth = 0
-    while (buf && buf.type !== 'root') {
-      depth += 1
-      buf = buf.parent
-    }
-
-    if (value.includes('\n')) {
-      let indent = this.raw(node, null, 'indent')
-      if (indent.length) {
-        for (let step = 0; step < depth; step++) value += indent
-      }
-    }
-
-    return value
-  }
-
-  block(node, start) {
-    let between = this.raw(node, 'between', 'beforeOpen')
-    this.builder(start + between + '{', node, 'start')
-
-    let after
-    if (node.nodes && node.nodes.length) {
-      this.body(node)
-      after = this.raw(node, 'after')
-    } else {
-      after = this.raw(node, 'after', 'emptyBody')
-    }
-
-    if (after) this.builder(after)
-    this.builder('}', node, 'end')
-  }
-
-  body(node) {
-    let last = node.nodes.length - 1
-    while (last > 0) {
-      if (node.nodes[last].type !== 'comment') break
-      last -= 1
-    }
-
-    let semicolon = this.raw(node, 'semicolon')
-    for (let i = 0; i < node.nodes.length; i++) {
-      let child = node.nodes[i]
-      let before = this.raw(child, 'before')
-      if (before) this.builder(before)
-      this.stringify(child, last !== i || semicolon)
-    }
-  }
-
-  comment(node) {
-    let left = this.raw(node, 'left', 'commentLeft')
-    let right = this.raw(node, 'right', 'commentRight')
-    this.builder('/*' + left + node.text + right + '*/', node)
-  }
-
-  decl(node, semicolon) {
-    let between = this.raw(node, 'between', 'colon')
-    let string = node.prop + between + this.rawValue(node, 'value')
-
-    if (node.important) {
-      string += node.raws.important || ' !important'
-    }
-
-    if (semicolon) string += ';'
-    this.builder(string, node)
-  }
-
-  document(node) {
-    this.body(node)
-  }
-
-  raw(node, own, detect) {
-    let value
-    if (!detect) detect = own
-
-    // Already had
-    if (own) {
-      value = node.raws[own]
-      if (typeof value !== 'undefined') return value
-    }
-
-    let parent = node.parent
-
-    if (detect === 'before') {
-      // Hack for first rule in CSS
-      if (!parent || (parent.type === 'root' && parent.first === node)) {
-        return ''
-      }
-
-      // `root` nodes in `document` should use only their own raws
-      if (parent && parent.type === 'document') {
-        return ''
-      }
-    }
-
-    // Floating child without parent
-    if (!parent) return DEFAULT_RAW[detect]
-
-    // Detect style by other nodes
-    let root = node.root()
-    if (!root.rawCache) root.rawCache = {}
-    if (typeof root.rawCache[detect] !== 'undefined') {
-      return root.rawCache[detect]
-    }
-
-    if (detect === 'before' || detect === 'after') {
-      return this.beforeAfter(node, detect)
-    } else {
-      let method = 'raw' + capitalize(detect)
-      if (this[method]) {
-        value = this[method](root, node)
-      } else {
-        root.walk(i => {
-          value = i.raws[own]
-          if (typeof value !== 'undefined') return false
-        })
-      }
-    }
-
-    if (typeof value === 'undefined') value = DEFAULT_RAW[detect]
-
-    root.rawCache[detect] = value
-    return value
-  }
-
-  rawBeforeClose(root) {
-    let value
-    root.walk(i => {
-      if (i.nodes && i.nodes.length > 0) {
-        if (typeof i.raws.after !== 'undefined') {
-          value = i.raws.after
-          if (value.includes('\n')) {
-            value = value.replace(/[^\n]+$/, '')
-          }
-          return false
-        }
-      }
-    })
-    if (value) value = value.replace(/\S/g, '')
-    return value
-  }
-
-  rawBeforeComment(root, node) {
-    let value
-    root.walkComments(i => {
-      if (typeof i.raws.before !== 'undefined') {
-        value = i.raws.before
-        if (value.includes('\n')) {
-          value = value.replace(/[^\n]+$/, '')
-        }
-        return false
-      }
-    })
-    if (typeof value === 'undefined') {
-      value = this.raw(node, null, 'beforeDecl')
-    } else if (value) {
-      value = value.replace(/\S/g, '')
-    }
-    return value
-  }
-
-  rawBeforeDecl(root, node) {
-    let value
-    root.walkDecls(i => {
-      if (typeof i.raws.before !== 'undefined') {
-        value = i.raws.before
-        if (value.includes('\n')) {
-          value = value.replace(/[^\n]+$/, '')
-        }
-        return false
-      }
-    })
-    if (typeof value === 'undefined') {
-      value = this.raw(node, null, 'beforeRule')
-    } else if (value) {
-      value = value.replace(/\S/g, '')
-    }
-    return value
-  }
-
-  rawBeforeOpen(root) {
-    let value
-    root.walk(i => {
-      if (i.type !== 'decl') {
-        value = i.raws.between
-        if (typeof value !== 'undefined') return false
-      }
-    })
-    return value
-  }
-
-  rawBeforeRule(root) {
-    let value
-    root.walk(i => {
-      if (i.nodes && (i.parent !== root || root.first !== i)) {
-        if (typeof i.raws.before !== 'undefined') {
-          value = i.raws.before
-          if (value.includes('\n')) {
-            value = value.replace(/[^\n]+$/, '')
-          }
-          return false
-        }
-      }
-    })
-    if (value) value = value.replace(/\S/g, '')
-    return value
-  }
-
-  rawColon(root) {
-    let value
-    root.walkDecls(i => {
-      if (typeof i.raws.between !== 'undefined') {
-        value = i.raws.between.replace(/[^\s:]/g, '')
-        return false
-      }
-    })
-    return value
-  }
-
-  rawEmptyBody(root) {
-    let value
-    root.walk(i => {
-      if (i.nodes && i.nodes.length === 0) {
-        value = i.raws.after
-        if (typeof value !== 'undefined') return false
-      }
-    })
-    return value
-  }
-
-  rawIndent(root) {
-    if (root.raws.indent) return root.raws.indent
-    let value
-    root.walk(i => {
-      let p = i.parent
-      if (p && p !== root && p.parent && p.parent === root) {
-        if (typeof i.raws.before !== 'undefined') {
-          let parts = i.raws.before.split('\n')
-          value = parts[parts.length - 1]
-          value = value.replace(/\S/g, '')
-          return false
-        }
-      }
-    })
-    return value
-  }
-
-  rawSemicolon(root) {
-    let value
-    root.walk(i => {
-      if (i.nodes && i.nodes.length && i.last.type === 'decl') {
-        value = i.raws.semicolon
-        if (typeof value !== 'undefined') return false
-      }
-    })
-    return value
-  }
-
-  rawValue(node, prop) {
-    let value = node[prop]
-    let raw = node.raws[prop]
-    if (raw && raw.value === value) {
-      return raw.raw
-    }
-
-    return value
-  }
-
-  root(node) {
-    this.body(node)
-    if (node.raws.after) this.builder(node.raws.after)
-  }
-
-  rule(node) {
-    this.block(node, this.rawValue(node, 'selector'))
-    if (node.raws.ownSemicolon) {
-      this.builder(node.raws.ownSemicolon, node, 'end')
-    }
-  }
-
-  stringify(node, semicolon) {
-    /* c8 ignore start */
-    if (!this[node.type]) {
-      throw new Error(
-        'Unknown AST node type ' +
-          node.type +
-          '. ' +
-          'Maybe you need to change PostCSS stringifier.'
-      )
-    }
-    /* c8 ignore stop */
-    this[node.type](node, semicolon)
-  }
-}
-
-module.exports = Stringifier
-Stringifier.default = Stringifier