@askviraj/linter 1.1.0 → 1.1.3

package/node_modules/postcss/lib/fromJSON.js

@@ -8,26 +8,24 @@ let PreviousMap = require('./previous-map')
 let Root = require('./root')
 let Rule = require('./rule')
 
-function fromJSON(json, inputs) {
-  if (Array.isArray(json)) return json.map(n => fromJSON(n))
-
-  let { inputs: ownInputs, ...defaults } = json
-  if (ownInputs) {
-    inputs = []
-    for (let input of ownInputs) {
-      let inputHydrated = { ...input, __proto__: Input.prototype }
-      if (inputHydrated.map) {
-        inputHydrated.map = {
-          ...inputHydrated.map,
-          __proto__: PreviousMap.prototype
-        }
+function hydrateInputs(json, inputs) {
+  if (!json.inputs) return inputs
+  return json.inputs.map(input => {
+    let inputHydrated = { ...input, __proto__: Input.prototype }
+    if (inputHydrated.map) {
+      inputHydrated.map = {
+        ...inputHydrated.map,
+        __proto__: PreviousMap.prototype
       }
-      inputs.push(inputHydrated)
     }
-  }
-  if (defaults.nodes) {
-    defaults.nodes = json.nodes.map(n => fromJSON(n, inputs))
-  }
+    return inputHydrated
+  })
+}
+
+function constructNode(json, inputs, children) {
+  let defaults = { ...json }
+  delete defaults.inputs
+  delete defaults.nodes
   if (defaults.source) {
     let { inputId, ...source } = defaults.source
     defaults.source = source
@@ -35,19 +33,74 @@ function fromJSON(json, inputs) {
       defaults.source.input = inputs[inputId]
     }
   }
+
+  let node
   if (defaults.type === 'root') {
-    return new Root(defaults)
+    node = new Root(defaults)
   } else if (defaults.type === 'decl') {
-    return new Declaration(defaults)
+    node = new Declaration(defaults)
   } else if (defaults.type === 'rule') {
-    return new Rule(defaults)
+    node = new Rule(defaults)
   } else if (defaults.type === 'comment') {
-    return new Comment(defaults)
+    node = new Comment(defaults)
   } else if (defaults.type === 'atrule') {
-    return new AtRule(defaults)
+    node = new AtRule(defaults)
   } else {
     throw new Error('Unknown node type: ' + json.type)
   }
+
+  // Rehydrated children are attached after construction. Passing them
+  // through the container constructor would re-run insertion spacing
+  // normalization and overwrite each child's own `raws.before`.
+  if (children) {
+    node.nodes = children
+    for (let child of children) child.parent = node
+  }
+
+  return node
+}
+
+function fromJSON(json, inputs) {
+  if (Array.isArray(json)) return json.map(n => fromJSON(n))
+
+  // An explicit stack instead of recursive calls to survive deeply
+  // nested trees. Children are rehydrated before their parent node
+  // is constructed.
+  let result
+  let stack = [
+    { childIndex: 0, children: [], inputs: hydrateInputs(json, inputs), json }
+  ]
+
+  while (stack.length > 0) {
+    let frame = stack[stack.length - 1]
+    let jsonNodes = frame.json.nodes
+
+    if (jsonNodes && frame.childIndex < jsonNodes.length) {
+      let childJson = jsonNodes[frame.childIndex]
+      frame.childIndex += 1
+      stack.push({
+        childIndex: 0,
+        children: [],
+        inputs: hydrateInputs(childJson, frame.inputs),
+        json: childJson
+      })
+      continue
+    }
+
+    stack.pop()
+    let node = constructNode(
+      frame.json,
+      frame.inputs,
+      jsonNodes ? frame.children : undefined
+    )
+    if (stack.length > 0) {
+      stack[stack.length - 1].children.push(node)
+    } else {
+      result = node
+    }
+  }
+
+  return result
 }
 
 module.exports = fromJSON

package/node_modules/postcss/lib/input.js

@@ -206,12 +206,21 @@ class Input {
     if (!this.map) return false
     let consumer = this.map.consumer()
 
-    let from = consumer.originalPositionFor({ column, line })
+    let from = consumer.originalPositionFor({ column: column - 1, line })
     if (!from.source) return false
 
     let to
     if (typeof endLine === 'number') {
-      to = consumer.originalPositionFor({ column: endColumn, line: endLine })
+      let toPosition = consumer.originalPositionFor({
+        column: endColumn - 1,
+        line: endLine
+      })
+      // The source map may not have a mapping that covers the end position
+      // (`originalPositionFor()` then returns `null` for `line`/`column`
+      // instead of omitting them). Treat that the same as not requesting
+      // an end position at all, so `endLine`/`endColumn` stay a consistent
+      // `undefined` pair instead of a mix of `null` and a bogus number.
+      if (toPosition.source) to = toPosition
     }
 
     let fromUrl
@@ -226,8 +235,8 @@ class Input {
     }
 
     let result = {
-      column: from.column,
-      endColumn: to && to.column,
+      column: from.column + 1,
+      endColumn: to && to.column + 1,
       endLine: to && to.line,
       line: from.line,
       url: fromUrl.toString()

package/node_modules/postcss/lib/lazy-result.js

@@ -97,8 +97,14 @@ function toStack(node) {
 }
 
 function cleanMarks(node) {
-  node[isClean] = false
-  if (node.nodes) node.nodes.forEach(i => cleanMarks(i))
+  let stack = [node]
+  while (stack.length > 0) {
+    let next = stack.pop()
+    next[isClean] = false
+    if (next.nodes) {
+      for (let i of next.nodes) stack.push(i)
+    }
+  }
   return node
 }
 
@@ -497,14 +503,24 @@ class LazyResult {
 
     if (visit.iterator !== 0) {
       let iterator = visit.iterator
+      // Advance past the child we just finished visiting. Like
+      // `Container#each`, the index is incremented only after a child has
+      // been fully processed, so a node inserted right after the current
+      // child is not skipped by the `existIndex < index` adjustment in
+      // `Container#insertAfter()` (which would fire exit events too early).
+      if (visit.descending) {
+        visit.descending = false
+        node.indexes[iterator] += 1
+      }
       let child
       while ((child = node.nodes[node.indexes[iterator]])) {
-        node.indexes[iterator] += 1
         if (!child[isClean]) {
           child[isClean] = true
+          visit.descending = true
           stack.push(toStack(child))
           return
         }
+        node.indexes[iterator] += 1
       }
       visit.iterator = 0
       delete node.indexes[iterator]
@@ -529,21 +545,68 @@ class LazyResult {
   }
 
   walkSync(node) {
+    // An explicit stack like in async `visitTick()` to survive deeply
+    // nested trees. Unlike `visitTick()`, nodes are marked clean only
+    // on entering, so a node dirtied by its own visitors is revisited
+    // on the next pass.
     node[isClean] = true
-    let events = getEvents(node)
-    for (let event of events) {
-      if (event === CHILDREN) {
-        if (node.nodes) {
-          node.each(child => {
-            if (!child[isClean]) this.walkSync(child)
-          })
+    let stack = [{ eventIndex: 0, events: getEvents(node), iterator: 0, node }]
+
+    while (stack.length > 0) {
+      let visit = stack[stack.length - 1]
+      let visitNode = visit.node
+
+      if (visit.iterator !== 0) {
+        let iterator = visit.iterator
+        // Advance past the child we just finished visiting. Like
+        // `Container#each`, the index is incremented only after a child has
+        // been fully processed. Incrementing before (as this loop used to)
+        // makes a node inserted right after the current child get skipped by
+        // the `existIndex < index` adjustment in `Container#insertAfter()`,
+        // which fires exit events before those new siblings are visited.
+        if (visit.descending) {
+          visit.descending = false
+          visitNode.indexes[iterator] += 1
         }
-      } else {
-        let visitors = this.listeners[event]
-        if (visitors) {
-          if (this.visitSync(visitors, node.toProxy())) return
+        let child
+        let descended = false
+        while ((child = visitNode.nodes[visitNode.indexes[iterator]])) {
+          if (!child[isClean]) {
+            child[isClean] = true
+            visit.descending = true
+            stack.push({
+              eventIndex: 0,
+              events: getEvents(child),
+              iterator: 0,
+              node: child
+            })
+            descended = true
+            break
+          }
+          visitNode.indexes[iterator] += 1
         }
+        if (descended) continue
+        visit.iterator = 0
+        delete visitNode.indexes[iterator]
       }
+
+      if (visit.eventIndex < visit.events.length) {
+        let event = visit.events[visit.eventIndex]
+        visit.eventIndex += 1
+        if (event === CHILDREN) {
+          if (visitNode.nodes && visitNode.nodes.length) {
+            visit.iterator = visitNode.getIterator()
+          }
+        } else {
+          let visitors = this.listeners[event]
+          if (visitors) {
+            if (this.visitSync(visitors, visitNode.toProxy())) stack.pop()
+          }
+        }
+        continue
+      }
+
+      stack.pop()
     }
   }
 

package/node_modules/postcss/lib/list.js

@@ -11,6 +11,7 @@ let list = {
   },
 
   split(string, separators, last) {
+    if (!string) return []
     let array = []
     let current = ''
     let split = false

package/node_modules/postcss/lib/node.d.ts

@@ -31,12 +31,12 @@ declare namespace Node {
 
   export interface Position {
     /**
-     * Source line in file. In contrast to `offset` it starts from 1.
+     * Source column in file. It starts from 1.
      */
     column: number
 
     /**
-     * Source column in file.
+     * Source line in file. It starts from 1.
      */
     line: number
 

package/node_modules/postcss/lib/node.js

@@ -7,25 +7,41 @@ let { isClean, my } = require('./symbols')
 
 function cloneNode(obj, parent) {
   let cloned = new obj.constructor()
-
-  for (let i in obj) {
-    if (!Object.prototype.hasOwnProperty.call(obj, i)) {
-      /* c8 ignore next 2 */
-      continue
-    }
-    if (i === 'proxyCache') continue
-    let value = obj[i]
-    let type = typeof value
-
-    if (i === 'parent' && type === 'object') {
-      if (parent) cloned[i] = parent
-    } else if (i === 'source') {
-      cloned[i] = value
-    } else if (Array.isArray(value)) {
-      cloned[i] = value.map(j => cloneNode(j, cloned))
-    } else {
-      if (type === 'object' && value !== null) value = cloneNode(value)
-      cloned[i] = value
+  // An explicit stack instead of recursive calls to survive deeply
+  // nested trees. Each entry is [source, its clone, clone's parent].
+  let stack = [[obj, cloned, parent]]
+
+  while (stack.length > 0) {
+    let [source, target, targetParent] = stack.pop()
+    for (let i in source) {
+      if (!Object.prototype.hasOwnProperty.call(source, i)) {
+        /* c8 ignore next 2 */
+        continue
+      }
+      if (i === 'proxyCache') continue
+      let value = source[i]
+      let type = typeof value
+
+      if (i === 'parent' && type === 'object') {
+        if (targetParent) target[i] = targetParent
+      } else if (i === 'source') {
+        target[i] = value
+      } else if (Array.isArray(value)) {
+        let children = []
+        target[i] = children
+        for (let j of value) {
+          let childClone = new j.constructor()
+          children.push(childClone)
+          stack.push([j, childClone, target])
+        }
+      } else {
+        if (type === 'object' && value !== null) {
+          let valueClone = new value.constructor()
+          stack.push([value, valueClone, undefined])
+          value = valueClone
+        }
+        target[i] = value
+      }
     }
   }
 
@@ -69,11 +85,15 @@ class Node {
     this[isClean] = false
     this[my] = true
 
-    for (let name in defaults) {
+    for (let name of Object.keys(defaults)) {
+      if (name === '__proto__') continue
       if (name === 'nodes') {
         this.nodes = []
         for (let node of defaults[name]) {
-          if (typeof node.clone === 'function') {
+          // Clone only nodes that already belong to another tree, so passing a
+          // freshly created (parent-less) node adopts that instance instead of
+          // a copy and keeps the caller's reference usable. See #1987.
+          if (typeof node.clone === 'function' && node.parent) {
             this.append(node.clone())
           } else {
             this.append(node)
@@ -206,14 +226,18 @@ class Node {
   }
 
   positionBy(opts = {}) {
-    let pos = this.source.start
+    let inputString =
+      'document' in this.source.input
+        ? this.source.input.document
+        : this.source.input.css
+    let pos = {
+      column: this.source.start.column,
+      line: this.source.start.line,
+      offset: sourceOffset(inputString, this.source.start)
+    }
     if (opts.index) {
       pos = this.positionInside(opts.index)
     } else if (opts.word) {
-      let inputString =
-        'document' in this.source.input
-          ? this.source.input.document
-          : this.source.input.css
       let stringRepresentation = inputString.slice(
         sourceOffset(inputString, this.source.start),
         sourceOffset(inputString, this.source.end)
@@ -298,7 +322,7 @@ class Node {
           line: opts.start.line,
           offset: sourceOffset(inputString, opts.start)
         }
-      } else if (opts.index) {
+      } else if (typeof opts.index === 'number') {
         start = this.positionInside(opts.index)
       }
 
@@ -310,7 +334,7 @@ class Node {
         }
       } else if (typeof opts.endIndex === 'number') {
         end = this.positionInside(opts.endIndex)
-      } else if (opts.index) {
+      } else if (typeof opts.index === 'number') {
         end = this.positionInside(opts.index + 1)
       }
     }
@@ -374,47 +398,68 @@ class Node {
   }
 
   toJSON(_, inputs) {
-    let fixed = {}
     let emitInputs = inputs == null
     inputs = inputs || new Map()
-    let inputsNextIndex = 0
-
-    for (let name in this) {
-      if (!Object.prototype.hasOwnProperty.call(this, name)) {
-        /* c8 ignore next 2 */
-        continue
-      }
-      if (name === 'parent' || name === 'proxyCache') continue
-      let value = this[name]
 
-      if (Array.isArray(value)) {
-        fixed[name] = value.map(i => {
-          if (typeof i === 'object' && i.toJSON) {
-            return i.toJSON(null, inputs)
+    // A worklist instead of recursive `toJSON()` calls to survive deeply
+    // nested trees. Each entry converts one node and writes the result
+    // into the already converted parent by [holder, key].
+    let holderOfRoot = []
+    let queue = [[this, holderOfRoot, 0]]
+
+    for (let step = 0; step < queue.length; step++) {
+      let [node, holder, key] = queue[step]
+      let fixed = {}
+      holder[key] = fixed
+
+      for (let name in node) {
+        if (!Object.prototype.hasOwnProperty.call(node, name)) {
+          /* c8 ignore next 2 */
+          continue
+        }
+        if (name === 'parent' || name === 'proxyCache') continue
+        let value = node[name]
+
+        if (Array.isArray(value)) {
+          let fixedArray = []
+          fixed[name] = fixedArray
+          for (let i = 0; i < value.length; i++) {
+            let item = value[i]
+            if (typeof item === 'object' && item.toJSON) {
+              if (item.toJSON === Node.prototype.toJSON) {
+                queue.push([item, fixedArray, i])
+              } else {
+                fixedArray[i] = item.toJSON(null, inputs)
+              }
+            } else {
+              fixedArray[i] = item
+            }
+          }
+        } else if (typeof value === 'object' && value.toJSON) {
+          if (value.toJSON === Node.prototype.toJSON) {
+            queue.push([value, fixed, name])
           } else {
-            return i
+            fixed[name] = value.toJSON(null, inputs)
           }
-        })
-      } else if (typeof value === 'object' && value.toJSON) {
-        fixed[name] = value.toJSON(null, inputs)
-      } else if (name === 'source') {
-        if (value == null) continue
-        let inputId = inputs.get(value.input)
-        if (inputId == null) {
-          inputId = inputsNextIndex
-          inputs.set(value.input, inputsNextIndex)
-          inputsNextIndex++
-        }
-        fixed[name] = {
-          end: value.end,
-          inputId,
-          start: value.start
+        } else if (name === 'source') {
+          if (value == null) continue
+          let inputId = inputs.get(value.input)
+          if (inputId == null) {
+            inputId = inputs.size
+            inputs.set(value.input, inputId)
+          }
+          fixed[name] = {
+            end: value.end,
+            inputId,
+            start: value.start
+          }
+        } else {
+          fixed[name] = value
         }
-      } else {
-        fixed[name] = value
       }
     }
 
+    let fixed = holderOfRoot[0]
     if (emitInputs) {
       fixed.inputs = [...inputs.keys()].map(input => input.toJSON())
     }

package/node_modules/postcss/lib/postcss.d.ts

@@ -229,7 +229,7 @@ declare namespace postcss {
   export interface Parser<RootNode = Document | Root> {
     (
       css: { toString(): string } | string,
-      opts?: Pick<ProcessOptions, 'document' | 'from' | 'map'>
+      opts?: Pick<ProcessOptions, 'document' | 'from' | 'map' | 'unsafeMap'>
     ): RootNode
   }
 
@@ -354,6 +354,9 @@ declare namespace postcss {
 
     /**
      * Disable source map file protections.
+     *
+     * By default source map is limited only for `.map` files
+     * in the `from` folder.
      */
     unsafeMap?: boolean
   }

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

@@ -1,7 +1,7 @@
 'use strict'
 
 let { existsSync, readFileSync } = require('fs')
-let { dirname, join } = require('path')
+let { dirname, isAbsolute, join, relative, sep } = require('path')
 let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')
 
 function fromBase64(str) {
@@ -85,9 +85,12 @@ class PreviousMap {
   }
 
   loadFile(path, cssFile, trusted) {
-    /* c8 ignore next 5 */
     if (!trusted && !this.unsafeMap) {
-      if (!/\.map$/i.test(path)) {
+      if (!/\.map$/i.test(path)) return undefined
+      if (!cssFile) return undefined
+
+      let rel = relative(dirname(cssFile), path)
+      if (rel === '..' || rel.startsWith('..' + sep) || isAbsolute(rel)) {
         return undefined
       }
     }

package/node_modules/postcss/lib/processor.js

@@ -7,7 +7,7 @@ let Root = require('./root')
 
 class Processor {
   constructor(plugins = []) {
-    this.version = '8.5.15'
+    this.version = '8.5.25'
     this.plugins = this.normalize(plugins)
   }
 

package/node_modules/postcss/lib/root.js

@@ -12,6 +12,19 @@ class Root extends Container {
   }
 
   normalize(child, sample, type) {
+    let keepBefore = new Set()
+    for (let node of Array.isArray(child) ? child : [child]) {
+      if (
+        node &&
+        typeof node === 'object' &&
+        !node.parent &&
+        node.raws &&
+        typeof node.raws.before !== 'undefined'
+      ) {
+        keepBefore.add(node.raws)
+      }
+    }
+
     let nodes = super.normalize(child)
 
     if (sample) {
@@ -23,7 +36,9 @@ class Root extends Container {
         }
       } else if (this.first !== sample) {
         for (let node of nodes) {
-          node.raws.before = sample.raws.before
+          if (!keepBefore.has(node.raws)) {
+            node.raws.before = sample.raws.before
+          }
         }
       }
     }