postcss 8.3.9 → 8.4.31

package/lib/root.d.ts

@@ -3,40 +3,45 @@ import Document from './document.js'
 import { ProcessOptions } from './postcss.js'
 import Result from './result.js'
 
-interface RootRaws extends Record<string, any> {
-  /**
-   * The space symbols after the last child to the end of file.
-   */
-  after?: string
+declare namespace Root {
+  export interface RootRaws extends Record<string, any> {
+    /**
+     * The space symbols after the last child to the end of file.
+     */
+    after?: string
 
-  /**
-   * Non-CSS code before `Root`, when `Root` is inside `Document`.
-   *
-   * **Experimental:** some aspects of this node could change within minor
-   * or patch version releases.
-   */
-  codeBefore?: string
+    /**
+     * Non-CSS code after `Root`, when `Root` is inside `Document`.
+     *
+     * **Experimental:** some aspects of this node could change within minor
+     * or patch version releases.
+     */
+    codeAfter?: string
 
-  /**
-   * Non-CSS code after `Root`, when `Root` is inside `Document`.
-   *
-   * **Experimental:** some aspects of this node could change within minor
-   * or patch version releases.
-   */
-  codeAfter?: string
+    /**
+     * Non-CSS code before `Root`, when `Root` is inside `Document`.
+     *
+     * **Experimental:** some aspects of this node could change within minor
+     * or patch version releases.
+     */
+    codeBefore?: string
 
-  /**
-   * Is the last child has an (optional) semicolon.
-   */
-  semicolon?: boolean
-}
+    /**
+     * Is the last child has an (optional) semicolon.
+     */
+    semicolon?: boolean
+  }
 
-export interface RootProps extends ContainerProps {
-  /**
-   * Information used to generate byte-to-byte equal node string
-   * as it was in the origin input.
-   * */
-  raws?: RootRaws
+  export interface RootProps extends ContainerProps {
+    /**
+     * Information used to generate byte-to-byte equal node string
+     * as it was in the origin input.
+     * */
+    raws?: RootRaws
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Root_ as default }
 }
 
 /**
@@ -48,10 +53,17 @@ export interface RootProps extends ContainerProps {
  * root.nodes.length //=> 2
  * ```
  */
-export default class Root extends Container {
-  type: 'root'
+declare class Root_ extends Container {
   parent: Document | undefined
-  raws: RootRaws
+  raws: Root.RootRaws
+  type: 'root'
+
+  constructor(defaults?: Root.RootProps)
+
+  assign(overrides: object | Root.RootProps): this
+  clone(overrides?: Partial<Root.RootProps>): Root
+  cloneAfter(overrides?: Partial<Root.RootProps>): Root
+  cloneBefore(overrides?: Partial<Root.RootProps>): Root
 
   /**
    * Returns a `Result` instance representing the root’s CSS.
@@ -67,7 +79,8 @@ export default class Root extends Container {
    * @return Result with current root’s CSS.
    */
   toResult(options?: ProcessOptions): Result
-
-  constructor(defaults?: RootProps)
-  assign(overrides: object | RootProps): this
 }
+
+declare class Root extends Root_ {}
+
+export = Root

package/lib/root.js

@@ -11,16 +11,6 @@ class Root extends Container {
     if (!this.nodes) this.nodes = []
   }
 
-  removeChild(child, ignore) {
-    let index = this.index(child)
-
-    if (!ignore && index === 0 && this.nodes.length > 1) {
-      this.nodes[1].raws.before = this.nodes[index].raws.before
-    }
-
-    return super.removeChild(child)
-  }
-
   normalize(child, sample, type) {
     let nodes = super.normalize(child)
 
@@ -41,6 +31,16 @@ class Root extends Container {
     return nodes
   }
 
+  removeChild(child, ignore) {
+    let index = this.index(child)
+
+    if (!ignore && index === 0 && this.nodes.length > 1) {
+      this.nodes[1].raws.before = this.nodes[index].raws.before
+    }
+
+    return super.removeChild(child)
+  }
+
   toResult(opts = {}) {
     let lazy = new LazyResult(new Processor(), this, opts)
     return lazy.stringify()
@@ -57,3 +57,5 @@ Root.registerProcessor = dependant => {
 
 module.exports = Root
 Root.default = Root
+
+Container.registerRoot(Root)

package/lib/rule.d.ts

@@ -1,48 +1,53 @@
 import Container, { ContainerProps } from './container.js'
 
-interface RuleRaws {
-  /**
-   * The space symbols before the node. It also stores `*`
-   * and `_` symbols before the declaration (IE hack).
-   */
-  before?: string
+declare namespace Rule {
+  export interface RuleRaws extends Record<string, unknown> {
+    /**
+     * The space symbols after the last child of the node to the end of the node.
+     */
+    after?: string
 
-  /**
-   * The space symbols after the last child of the node to the end of the node.
-   */
-  after?: string
+    /**
+     * The space symbols before the node. It also stores `*`
+     * and `_` symbols before the declaration (IE hack).
+     */
+    before?: string
 
-  /**
-   * The symbols between the selector and `{` for rules.
-   */
-  between?: string
+    /**
+     * The symbols between the selector and `{` for rules.
+     */
+    between?: string
 
-  /**
-   * Contains `true` if the last child has an (optional) semicolon.
-   */
-  semicolon?: boolean
+    /**
+     * Contains `true` if there is semicolon after rule.
+     */
+    ownSemicolon?: string
 
-  /**
-   * Contains `true` if there is semicolon after rule.
-   */
-  ownSemicolon?: string
+    /**
+     * The rule’s selector with comments.
+     */
+    selector?: {
+      raw: string
+      value: string
+    }
 
-  /**
-   * The rule’s selector with comments.
-   */
-  selector?: {
-    value: string
-    raw: string
+    /**
+     * Contains `true` if the last child has an (optional) semicolon.
+     */
+    semicolon?: boolean
   }
-}
 
-export interface RuleProps extends ContainerProps {
-  /** Selector or selectors of the rule. */
-  selector?: string
-  /** Selectors of the rule represented as an array of strings. */
-  selectors?: string[]
-  /** Information used to generate byte-to-byte equal node string as it was in the origin input. */
-  raws?: RuleRaws
+  export interface RuleProps extends ContainerProps {
+    /** 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 of the rule represented as an array of strings. */
+    selectors?: string[]
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Rule_ as default }
 }
 
 /**
@@ -63,11 +68,9 @@ export interface RuleProps extends ContainerProps {
  * rule.toString() //=> 'a{}'
  * ```
  */
-export default class Rule extends Container {
-  type: 'rule'
+declare class Rule_ extends Container {
   parent: Container | undefined
-  raws: RuleRaws
-
+  raws: Rule.RuleRaws
   /**
    * The rule’s full selector represented as a string.
    *
@@ -96,9 +99,15 @@ export default class Rule extends Container {
    */
   selectors: string[]
 
-  constructor(defaults?: RuleProps)
-  assign(overrides: object | RuleProps): this
-  clone(overrides?: Partial<RuleProps>): this
-  cloneBefore(overrides?: Partial<RuleProps>): this
-  cloneAfter(overrides?: Partial<RuleProps>): this
+  type: 'rule'
+
+  constructor(defaults?: Rule.RuleProps)
+  assign(overrides: object | Rule.RuleProps): this
+  clone(overrides?: Partial<Rule.RuleProps>): Rule
+  cloneAfter(overrides?: Partial<Rule.RuleProps>): Rule
+  cloneBefore(overrides?: Partial<Rule.RuleProps>): Rule
 }
+
+declare class Rule extends Rule_ {}
+
+export = Rule

package/lib/stringifier.d.ts

@@ -0,0 +1,46 @@
+import {
+  AnyNode,
+  AtRule,
+  Builder,
+  Comment,
+  Container,
+  Declaration,
+  Document,
+  Root,
+  Rule
+} from './postcss.js'
+
+declare namespace Stringifier {
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Stringifier_ as default }
+}
+
+declare class Stringifier_ {
+  builder: Builder
+  constructor(builder: Builder)
+  atrule(node: AtRule, semicolon?: boolean): void
+  beforeAfter(node: AnyNode, detect: 'after' | 'before'): string
+  block(node: AnyNode, start: string): void
+  body(node: Container): void
+  comment(node: Comment): void
+  decl(node: Declaration, semicolon?: boolean): void
+  document(node: Document): void
+  raw(node: AnyNode, own: null | string, detect?: string): string
+  rawBeforeClose(root: Root): string | undefined
+  rawBeforeComment(root: Root, node: Comment): string | undefined
+  rawBeforeDecl(root: Root, node: Declaration): string | undefined
+  rawBeforeOpen(root: Root): string | undefined
+  rawBeforeRule(root: Root): string | undefined
+  rawColon(root: Root): string | undefined
+  rawEmptyBody(root: Root): string | undefined
+  rawIndent(root: Root): string | undefined
+  rawSemicolon(root: Root): boolean | undefined
+  rawValue(node: AnyNode, prop: string): string
+  root(node: Root): void
+  rule(node: Rule): void
+  stringify(node: AnyNode, semicolon?: boolean): void
+}
+
+declare class Stringifier extends Stringifier_ {}
+
+export = Stringifier

package/lib/stringifier.js

@@ -1,17 +1,17 @@
 'use strict'
 
 const DEFAULT_RAW = {
-  colon: ': ',
-  indent: '    ',
-  beforeDecl: '\n',
-  beforeRule: '\n',
-  beforeOpen: ' ',
+  after: '\n',
   beforeClose: '\n',
   beforeComment: '\n',
-  after: '\n',
-  emptyBody: '',
+  beforeDecl: '\n',
+  beforeOpen: ' ',
+  beforeRule: '\n',
+  colon: ': ',
   commentLeft: ' ',
   commentRight: ' ',
+  emptyBody: '',
+  indent: '    ',
   semicolon: false
 }
 
@@ -24,53 +24,6 @@ class Stringifier {
     this.builder = builder
   }
 
-  stringify(node, semicolon) {
-    /* istanbul ignore if */
-    if (!this[node.type]) {
-      throw new Error(
-        'Unknown AST node type ' +
-          node.type +
-          '. ' +
-          'Maybe you need to change PostCSS stringifier.'
-      )
-    }
-    this[node.type](node, semicolon)
-  }
-
-  document(node) {
-    this.body(node)
-  }
-
-  root(node) {
-    this.body(node)
-    if (node.raws.after) this.builder(node.raws.after)
-  }
-
-  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)
-  }
-
-  rule(node) {
-    this.block(node, this.rawValue(node, 'selector'))
-    if (node.raws.ownSemicolon) {
-      this.builder(node.raws.ownSemicolon, node, 'end')
-    }
-  }
-
   atrule(node, semicolon) {
     let name = '@' + node.name
     let params = node.params ? this.rawValue(node, 'params') : ''
@@ -89,20 +42,33 @@ class Stringifier {
     }
   }
 
-  body(node) {
-    let last = node.nodes.length - 1
-    while (last > 0) {
-      if (node.nodes[last].type !== 'comment') break
-      last -= 1
+  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 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)
+    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) {
@@ -121,6 +87,44 @@ class Stringifier {
     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
@@ -175,42 +179,20 @@ class Stringifier {
     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
-  }
-
-  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
+  rawBeforeClose(root) {
     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, '')
+      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
   }
 
@@ -252,6 +234,17 @@ class Stringifier {
     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 => {
@@ -269,71 +262,53 @@ class Stringifier {
     return value
   }
 
-  rawBeforeClose(root) {
+  rawColon(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
-        }
+    root.walkDecls(i => {
+      if (typeof i.raws.between !== 'undefined') {
+        value = i.raws.between.replace(/[^\s:]/g, '')
+        return false
       }
     })
-    if (value) value = value.replace(/\S/g, '')
     return value
   }
 
-  rawBeforeOpen(root) {
+  rawEmptyBody(root) {
     let value
     root.walk(i => {
-      if (i.type !== 'decl') {
-        value = i.raws.between
+      if (i.nodes && i.nodes.length === 0) {
+        value = i.raws.after
         if (typeof value !== 'undefined') return false
       }
     })
     return value
   }
 
-  rawColon(root) {
+  rawIndent(root) {
+    if (root.raws.indent) return root.raws.indent
     let value
-    root.walkDecls(i => {
-      if (typeof i.raws.between !== 'undefined') {
-        value = i.raws.between.replace(/[^\s:]/g, '')
-        return false
+    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
   }
 
-  beforeAfter(node, detect) {
+  rawSemicolon(root) {
     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
+    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
   }
 
@@ -346,6 +321,33 @@ class Stringifier {
 
     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