FM / lib

/var/www/cobraambalaj/node_modules/postcss/lib/

/var/www/cobraambalaj/node_modules/postcss/lib

Name	Size	Mode	Actions
at-rule.d.ts	2205	0644	edit dl rm
at-rule.js	474	0644	edit dl rm
comment.d.ts	1095	0644	edit dl rm
comment.js	204	0644	edit dl rm
container.d.ts	12726	0644	edit dl rm
container.js	10183	0644	edit dl rm
css-syntax-error.d.ts	4830	0644	edit dl rm
css-syntax-error.js	2299	0644	edit dl rm
declaration.d.ts	2650	0644	edit dl rm
declaration.js	497	0644	edit dl rm
fromJSON.d.ts	107	0644	edit dl rm
fromJSON.js	1507	0644	edit dl rm
input.d.ts	2816	0644	edit dl rm
input.js	4549	0644	edit dl rm
lazy-result.d.ts	4833	0644	edit dl rm
lazy-result.js	12279	0644	edit dl rm
list.d.ts	850	0644	edit dl rm
list.js	1170	0644	edit dl rm
map-generator.js	7306	0644	edit dl rm
node.d.ts	11348	0644	edit dl rm
node.js	6909	0644	edit dl rm
parse.d.ts	89	0644	edit dl rm
parse.js	1148	0644	edit dl rm
parser.js	13323	0644	edit dl rm
postcss.d.ts	10569	0644	edit dl rm
postcss.js	2513	0644	edit dl rm
postcss.mjs	855	0644	edit dl rm
previous-map.d.ts	1618	0644	edit dl rm
previous-map.js	3960	0644	edit dl rm
processor.d.ts	2944	0644	edit dl rm
processor.js	1965	0644	edit dl rm
result.d.ts	4086	0644	edit dl rm
result.js	750	0644	edit dl rm
root.d.ts	1195	0644	edit dl rm
root.js	1213	0644	edit dl rm
rule.d.ts	2078	0644	edit dl rm
rule.js	572	0644	edit dl rm
stringifier.js	7996	0644	edit dl rm
stringify.d.ts	107	0644	edit dl rm
stringify.js	214	0644	edit dl rm
symbols.js	57	0644	edit dl rm
terminal-highlight.js	1360	0644	edit dl rm
tokenize.js	6542	0644	edit dl rm
warn-once.js	225	0644	edit dl rm
warning.d.ts	1935	0644	edit dl rm
warning.js	650	0644	edit dl rm

Edit: /var/www/cobraambalaj/node_modules/postcss/lib/container.js (10183B)

'use strict'

let Declaration = require('./declaration')
let { isClean } = require('./symbols')
let Comment = require('./comment')
let Node = require('./node')

let parse, Rule, AtRule

function cleanSource (nodes) {
  return nodes.map(i => {
    if (i.nodes) i.nodes = cleanSource(i.nodes)
    delete i.source
    return i
  })
}

function markDirtyUp (node) {
  node[isClean] = false
  if (node.proxyOf.nodes) {
    for (let i of node.proxyOf.nodes) {
      markDirtyUp(i)
    }
  }
}

// istanbul ignore next
function rebuild (node) {
  if (node.type === 'atrule') {
    Object.setPrototypeOf(node, AtRule.prototype)
  } else if (node.type === 'rule') {
    Object.setPrototypeOf(node, Rule.prototype)
  } else if (node.type === 'decl') {
    Object.setPrototypeOf(node, Declaration.prototype)
  } else if (node.type === 'comment') {
    Object.setPrototypeOf(node, Comment.prototype)
  }

if (node.nodes) {
    node.nodes.forEach(child => {
      rebuild(child)
    })
  }
}

class Container extends Node {
  push (child) {
    child.parent = this
    this.proxyOf.nodes.push(child)
    return this
  }

each (callback) {
    if (!this.proxyOf.nodes) return undefined
    let iterator = this.getIterator()

let index, result
    while (this.indexes[iterator] < this.proxyOf.nodes.length) {
      index = this.indexes[iterator]
      result = callback(this.proxyOf.nodes[index], index)
      if (result === false) break

this.indexes[iterator] += 1
    }

delete this.indexes[iterator]
    return result
  }

walk (callback) {
    return this.each((child, i) => {
      let result
      try {
        result = callback(child, i)
      } catch (e) {
        throw child.addToError(e)
      }
      if (result !== false && child.walk) {
        result = child.walk(callback)
      }

return result
    })
  }

walkDecls (prop, callback) {
    if (!callback) {
      callback = prop
      return this.walk((child, i) => {
        if (child.type === 'decl') {
          return callback(child, i)
        }
      })
    }
    if (prop instanceof RegExp) {
      return this.walk((child, i) => {
        if (child.type === 'decl' && prop.test(child.prop)) {
          return callback(child, i)
        }
      })
    }
    return this.walk((child, i) => {
      if (child.type === 'decl' && child.prop === prop) {
        return callback(child, i)
      }
    })
  }

walkRules (selector, callback) {
    if (!callback) {
      callback = selector

return this.walk((child, i) => {
        if (child.type === 'rule') {
          return callback(child, i)
        }
      })
    }
    if (selector instanceof RegExp) {
      return this.walk((child, i) => {
        if (child.type === 'rule' && selector.test(child.selector)) {
          return callback(child, i)
        }
      })
    }
    return this.walk((child, i) => {
      if (child.type === 'rule' && child.selector === selector) {
        return callback(child, i)
      }
    })
  }

walkAtRules (name, callback) {
    if (!callback) {
      callback = name
      return this.walk((child, i) => {
        if (child.type === 'atrule') {
          return callback(child, i)
        }
      })
    }
    if (name instanceof RegExp) {
      return this.walk((child, i) => {
        if (child.type === 'atrule' && name.test(child.name)) {
          return callback(child, i)
        }
      })
    }
    return this.walk((child, i) => {
      if (child.type === 'atrule' && child.name === name) {
        return callback(child, i)
      }
    })
  }

walkComments (callback) {
    return this.walk((child, i) => {
      if (child.type === 'comment') {
        return callback(child, i)
      }
    })
  }

append (...children) {
    for (let child of children) {
      let nodes = this.normalize(child, this.last)
      for (let node of nodes) this.proxyOf.nodes.push(node)
    }

this.markDirty()

return this
  }

prepend (...children) {
    children = children.reverse()
    for (let child of children) {
      let nodes = this.normalize(child, this.first, 'prepend').reverse()
      for (let node of nodes) this.proxyOf.nodes.unshift(node)
      for (let id in this.indexes) {
        this.indexes[id] = this.indexes[id] + nodes.length
      }
    }

this.markDirty()

return this
  }

cleanRaws (keepBetween) {
    super.cleanRaws(keepBetween)
    if (this.nodes) {
      for (let node of this.nodes) node.cleanRaws(keepBetween)
    }
  }

insertBefore (exist, add) {
    exist = this.index(exist)

let type = exist === 0 ? 'prepend' : false
    let nodes = this.normalize(add, this.proxyOf.nodes[exist], type).reverse()
    for (let node of nodes) this.proxyOf.nodes.splice(exist, 0, node)

let index
    for (let id in this.indexes) {
      index = this.indexes[id]
      if (exist <= index) {
        this.indexes[id] = index + nodes.length
      }
    }

this.markDirty()

return this
  }

insertAfter (exist, add) {
    exist = this.index(exist)

let nodes = this.normalize(add, this.proxyOf.nodes[exist]).reverse()
    for (let node of nodes) this.proxyOf.nodes.splice(exist + 1, 0, node)

let index
    for (let id in this.indexes) {
      index = this.indexes[id]
      if (exist < index) {
        this.indexes[id] = index + nodes.length
      }
    }

this.markDirty()

return this
  }

removeChild (child) {
    child = this.index(child)
    this.proxyOf.nodes[child].parent = undefined
    this.proxyOf.nodes.splice(child, 1)

let index
    for (let id in this.indexes) {
      index = this.indexes[id]
      if (index >= child) {
        this.indexes[id] = index - 1
      }
    }

this.markDirty()

return this
  }

removeAll () {
    for (let node of this.proxyOf.nodes) node.parent = undefined
    this.proxyOf.nodes = []

this.markDirty()

return this
  }

replaceValues (pattern, opts, callback) {
    if (!callback) {
      callback = opts
      opts = {}
    }

this.walkDecls(decl => {
      if (opts.props && !opts.props.includes(decl.prop)) return
      if (opts.fast && !decl.value.includes(opts.fast)) return

decl.value = decl.value.replace(pattern, callback)
    })

this.markDirty()

return this
  }

every (condition) {
    return this.nodes.every(condition)
  }

some (condition) {
    return this.nodes.some(condition)
  }

index (child) {
    if (typeof child === 'number') return child
    if (child.proxyOf) child = child.proxyOf
    return this.proxyOf.nodes.indexOf(child)
  }

get first () {
    if (!this.proxyOf.nodes) return undefined
    return this.proxyOf.nodes[0]
  }

get last () {
    if (!this.proxyOf.nodes) return undefined
    return this.proxyOf.nodes[this.proxyOf.nodes.length - 1]
  }

normalize (nodes, sample) {
    if (typeof nodes === 'string') {
      nodes = cleanSource(parse(nodes).nodes)
    } else if (Array.isArray(nodes)) {
      nodes = nodes.slice(0)
      for (let i of nodes) {
        if (i.parent) i.parent.removeChild(i, 'ignore')
      }
    } else if (nodes.type === 'root') {
      nodes = nodes.nodes.slice(0)
      for (let i of nodes) {
        if (i.parent) i.parent.removeChild(i, 'ignore')
      }
    } else if (nodes.type) {
      nodes = [nodes]
    } else if (nodes.prop) {
      if (typeof nodes.value === 'undefined') {
        throw new Error('Value field is missed in node creation')
      } else if (typeof nodes.value !== 'string') {
        nodes.value = String(nodes.value)
      }
      nodes = [new Declaration(nodes)]
    } else if (nodes.selector) {
      nodes = [new Rule(nodes)]
    } else if (nodes.name) {
      nodes = [new AtRule(nodes)]
    } else if (nodes.text) {
      nodes = [new Comment(nodes)]
    } else {
      throw new Error('Unknown node type in node creation')
    }

let processed = nodes.map(i => {
      // istanbul ignore next
      if (typeof i.markDirty !== 'function') rebuild(i)
      i = i.proxyOf
      if (i.parent) i.parent.removeChild(i)
      if (i[isClean]) markDirtyUp(i)
      if (typeof i.raws.before === 'undefined') {
        if (sample && typeof sample.raws.before !== 'undefined') {
          i.raws.before = sample.raws.before.replace(/\S/g, '')
        }
      }
      i.parent = this
      return i
    })

return processed
  }

getProxyProcessor () {
    return {
      set (node, prop, value) {
        if (node[prop] === value) return true
        node[prop] = value
        if (prop === 'name' || prop === 'params' || prop === 'selector') {
          node.markDirty()
        }
        return true
      },

get (node, prop) {
        if (prop === 'proxyOf') {
          return node
        } else if (!node[prop]) {
          return node[prop]
        } else if (
          prop === 'each' ||
          (typeof prop === 'string' && prop.startsWith('walk'))
        ) {
          return (...args) => {
            return node[prop](
              ...args.map(i => {
                if (typeof i === 'function') {
                  return (child, index) => i(child.toProxy(), index)
                } else {
                  return i
                }
              })
            )
          }
        } else if (prop === 'every' || prop === 'some') {
          return cb => {
            return node[prop]((child, ...other) =>
              cb(child.toProxy(), ...other)
            )
          }
        } else if (prop === 'root') {
          return () => node.root().toProxy()
        } else if (prop === 'nodes') {
          return node.nodes.map(i => i.toProxy())
        } else if (prop === 'first' || prop === 'last') {
          return node[prop].toProxy()
        } else {
          return node[prop]
        }
      }
    }
  }

getIterator () {
    if (!this.lastEach) this.lastEach = 0
    if (!this.indexes) this.indexes = {}

this.lastEach += 1
    let iterator = this.lastEach
    this.indexes[iterator] = 0

return iterator
  }
}

Container.registerParse = dependant => {
  parse = dependant
}

Container.registerRule = dependant => {
  Rule = dependant
}

Container.registerAtRule = dependant => {
  AtRule = dependant
}

module.exports = Container
Container.default = Container

cmd: