@depup/postcss 8.5.8-depup.0 → 8.5.21-depup.0

package/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/lib/parse.d.ts

@@ -4,6 +4,6 @@ interface Parse extends Parser {
   default: Parse
 }
 
-declare const parse: Parse
+declare let parse: Parse
 
 export = parse

package/lib/parser.js

@@ -20,6 +20,12 @@ function findLastWithPosition(tokens) {
   }
 }
 
+function tokensToString(tokens, from, to) {
+  let result = ''
+  for (let i = from; i < to; i++) result += tokens[i][1]
+  return result
+}
+
 class Parser {
   constructor(input) {
     this.input = input
@@ -132,9 +138,10 @@ class Parser {
         if (founded === 2) break
       }
     }
-    // If the token is a word, e.g. `!important`, `red` or any other valid property's value.
-    // Then we need to return the colon after that word token. [3] is the "end" colon of that word.
-    // And because we need it after that one we do +1 to get the next one.
+    // If the token is a word, e.g. `!important`, `red` or any other valid
+    // property's value. Then we need to return the colon after that word
+    // token. [3] is the "end" colon of that word. And because we need it
+    // after that one we do +1 to get the next one.
     throw this.input.error(
       'Missed semicolon',
       token[0] === 'word' ? token[3] + 1 : token[2]
@@ -207,50 +214,50 @@ class Parser {
     )
     node.source.end.offset++
 
-    while (tokens[0][0] !== 'word') {
-      if (tokens.length === 1) this.unknownWord(tokens)
-      node.raws.before += tokens.shift()[1]
+    let start = 0
+    while (tokens[start][0] !== 'word') {
+      if (start === tokens.length - 1) this.unknownWord([tokens[start]])
+      start++
     }
-    node.source.start = this.getPosition(tokens[0][2])
+    node.raws.before += tokensToString(tokens, 0, start)
+    node.source.start = this.getPosition(tokens[start][2])
 
-    node.prop = ''
-    while (tokens.length) {
-      let type = tokens[0][0]
+    let propStart = start
+    while (start < tokens.length) {
+      let type = tokens[start][0]
       if (type === ':' || type === 'space' || type === 'comment') {
         break
       }
-      node.prop += tokens.shift()[1]
+      start++
     }
+    node.prop = tokensToString(tokens, propStart, start)
 
-    node.raws.between = ''
-
+    let betweenStart = start
     let token
-    while (tokens.length) {
-      token = tokens.shift()
-
-      if (token[0] === ':') {
-        node.raws.between += token[1]
-        break
-      } else {
-        if (token[0] === 'word' && /\w/.test(token[1])) {
-          this.unknownWord([token])
-        }
-        node.raws.between += token[1]
+    while (start < tokens.length) {
+      token = tokens[start]
+      start++
+      if (token[0] === ':') break
+      if (token[0] === 'word' && /\w/.test(token[1])) {
+        this.unknownWord([token])
       }
     }
+    node.raws.between = tokensToString(tokens, betweenStart, start)
 
     if (node.prop[0] === '_' || node.prop[0] === '*') {
       node.raws.before += node.prop[0]
       node.prop = node.prop.slice(1)
     }
 
-    let firstSpaces = []
-    let next
-    while (tokens.length) {
-      next = tokens[0][0]
+    let firstSpacesStart = start
+    while (start < tokens.length) {
+      let next = tokens[start][0]
       if (next !== 'space' && next !== 'comment') break
-      firstSpaces.push(tokens.shift())
+      start++
     }
+    let firstSpaces = tokens.slice(firstSpacesStart, start)
+
+    tokens = tokens.slice(start)
 
     this.precheckMissedSemicolon(tokens)
 

package/lib/postcss.d.mts

@@ -1,7 +1,6 @@
 export {
   // Type-only exports
   AcceptedPlugin,
-
   AnyNode,
   atRule,
   AtRule,
@@ -27,7 +26,6 @@ export {
   fromJSON,
   Helpers,
   Input,
-
   JSONHydrator,
   // This is a class, but it’s not re-exported. That’s why it’s exported as type-only here.
   type LazyResult,
@@ -64,6 +62,5 @@ export {
   TransformCallback,
   Transformer,
   Warning,
-
   WarningOptions
 } from './postcss.js'

package/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
   }
 
@@ -351,6 +351,14 @@ declare namespace postcss {
      * to generate correct source maps.
      */
     to?: string
+
+    /**
+     * Disable source map file protections.
+     *
+     * By default source map is limited only for `.map` files
+     * in the `from` folder.
+     */
+    unsafeMap?: boolean
   }
 
   export type Postcss = typeof postcss
@@ -450,9 +458,7 @@ declare namespace postcss {
  * @param plugins PostCSS plugins.
  * @return Processor to process multiple CSS.
  */
-declare function postcss(
-  plugins?: readonly postcss.AcceptedPlugin[]
-): Processor
+declare function postcss(plugins?: readonly postcss.AcceptedPlugin[]): Processor
 declare function postcss(...plugins: postcss.AcceptedPlugin[]): Processor
 
 export = postcss

package/lib/previous-map.d.ts

@@ -3,7 +3,6 @@ import { SourceMapConsumer } from 'source-map-js'
 import { ProcessOptions } from './postcss.js'
 
 declare namespace PreviousMap {
-   
   export { PreviousMap_ as default }
 }
 

package/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) {
@@ -16,6 +16,7 @@ function fromBase64(str) {
 class PreviousMap {
   constructor(css, opts) {
     if (opts.map === false) return
+    if (opts.unsafeMap) this.unsafeMap = true
     this.loadAnnotation(css)
     this.inline = this.startWith(this.annotation, 'data:')
 
@@ -30,7 +31,7 @@ class PreviousMap {
 
   consumer() {
     if (!this.consumerCache) {
-      this.consumerCache = new SourceMapConsumer(this.text)
+      this.consumerCache = new SourceMapConsumer(this.json || this.text)
     }
     return this.consumerCache
   }
@@ -51,7 +52,8 @@ class PreviousMap {
       return fromBase64(text.substr(baseUriMatch[0].length))
     }
 
-    let encoding = text.match(/data:application\/json;([^,]+),/)[1]
+    let encoding = text.slice('data:application/json;'.length)
+    encoding = encoding.slice(0, encoding.indexOf(','))
     throw new Error('Unsupported source map encoding ' + encoding)
   }
 
@@ -82,7 +84,22 @@ class PreviousMap {
     }
   }
 
-  loadFile(path) {
+  loadFile(path, cssFile, trusted) {
+    if (!trusted && !this.unsafeMap) {
+      if (!/\.map$/i.test(path)) {
+        return undefined
+      }
+      if (cssFile) {
+        let relativePath = relative(dirname(cssFile), path)
+        if (
+          relativePath === '..' ||
+          relativePath.startsWith('..' + sep) ||
+          isAbsolute(relativePath)
+        ) {
+          return undefined
+        }
+      }
+    }
     this.root = dirname(path)
     if (existsSync(path)) {
       this.mapFile = path
@@ -99,7 +116,7 @@ class PreviousMap {
       } else if (typeof prev === 'function') {
         let prevPath = prev(file)
         if (prevPath) {
-          let map = this.loadFile(prevPath)
+          let map = this.loadFile(prevPath, file, true)
           if (!map) {
             throw new Error(
               'Unable to load previous source map: ' + prevPath.toString()
@@ -123,7 +140,16 @@ class PreviousMap {
     } else if (this.annotation) {
       let map = this.annotation
       if (file) map = join(dirname(file), map)
-      return this.loadFile(map)
+      let unknown = this.loadFile(map, file, false)
+      if (unknown) {
+        try {
+          /* c8 ignore next 4 */
+          this.json = JSON.parse(unknown.replace(/^\)]}'[^\n]*\n/, ''))
+        } catch {
+          return undefined
+        }
+      }
+      return unknown
     }
   }
 

package/lib/processor.d.ts

@@ -12,7 +12,6 @@ import Result from './result.js'
 import Root from './root.js'
 
 declare namespace Processor {
-   
   export { Processor_ as default }
 }
 

package/lib/processor.js

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

package/lib/result.d.ts

@@ -39,7 +39,6 @@ declare namespace Result {
     plugin?: string
   }
 
-   
   export { Result_ as default }
 }
 

package/lib/root.d.ts

@@ -40,7 +40,6 @@ declare namespace Root {
     raws?: RootRaws
   }
 
-   
   export { Root_ as default }
 }
 

package/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
+          }
         }
       }
     }

package/lib/rule.d.ts

@@ -44,19 +44,19 @@ declare namespace Rule {
     /** Information used to generate byte-to-byte equal node string as it was in the origin input. */
     raws?: RuleRaws
   } & (
-      | {
-          /** Selector or selectors of the rule. */
-          selector: string
-          selectors?: never
-        }
-      | {
-          selector?: never
-          /** Selectors of the rule represented as an array of strings. */
-          selectors: readonly string[]
-        }
-    ) & ContainerProps
+    | {
+        /** Selector or selectors of the rule. */
+        selector: string
+        selectors?: never
+      }
+    | {
+        selector?: never
+        /** Selectors of the rule represented as an array of strings. */
+        selectors: readonly string[]
+      }
+  ) &
+    ContainerProps
 
-   
   export { Rule_ as default }
 }
 

package/lib/stringifier.d.ts

@@ -11,7 +11,6 @@ import {
 } from './postcss.js'
 
 declare namespace Stringifier {
-   
   export { Stringifier_ as default }
 }