postcss 8.4.23 → 8.4.25

package/lib/processor.js

@@ -7,28 +7,10 @@ let Root = require('./root')
 
 class Processor {
   constructor(plugins = []) {
-    this.version = '8.4.23'
+    this.version = '8.4.25'
     this.plugins = this.normalize(plugins)
   }
 
-  use(plugin) {
-    this.plugins = this.plugins.concat(this.normalize([plugin]))
-    return this
-  }
-
-  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)
-    }
-  }
-
   normalize(plugins) {
     let normalized = []
     for (let i of plugins) {
@@ -58,6 +40,24 @@ class Processor {
     }
     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

package/lib/result.d.ts

@@ -1,11 +1,11 @@
 import {
-  ProcessOptions,
+  Document,
+  Node,
   Plugin,
+  ProcessOptions,
+  Root,
   SourceMap,
   TransformCallback,
-  Root,
-  Document,
-  Node,
   Warning,
   WarningOptions
 } from './postcss.js'
@@ -13,17 +13,17 @@ import Processor from './processor.js'
 
 declare namespace Result {
   export interface Message {
-    /**
-     * Message type.
-     */
-    type: string
+    [others: string]: any
 
     /**
      * Source PostCSS plugin name.
      */
     plugin?: string
 
-    [others: string]: any
+    /**
+     * Message type.
+     */
+    type: string
   }
 
   export interface ResultOptions extends ProcessOptions {
@@ -62,17 +62,34 @@ declare namespace Result {
  */
 declare class Result_ {
   /**
-   * The Processor instance used for this transformation.
+   * A CSS string representing of `Result#root`.
    *
    * ```js
-   * for (const plugin of result.processor.plugins) {
-   *   if (plugin.postcssPlugin === 'postcss-bad') {
-   *     throw 'postcss-good is incompatible with postcss-bad'
-   *   }
-   * })
+   * postcss.parse('a{}').toResult().css //=> "a{}"
    * ```
    */
-  processor: Processor
+  css: string
+
+  /**
+   * Last runned PostCSS plugin.
+   */
+  lastPlugin: Plugin | TransformCallback
+
+  /**
+   * An instance of `SourceMapGenerator` class from the `source-map` library,
+   * representing changes to the `Result#root` instance.
+   *
+   * ```js
+   * result.map.toJSON() //=> { version: 3, file: 'a.css', … }
+   * ```
+   *
+   * ```js
+   * if (result.map) {
+   *   fs.writeFileSync(result.opts.to + '.map', result.map.toString())
+   * }
+   * ```
+   */
+  map: SourceMap
 
   /**
    * Contains messages from plugins (e.g., warnings or custom messages).
@@ -94,15 +111,6 @@ declare class Result_ {
    */
   messages: Result.Message[]
 
-  /**
-   * Root node after all transformations.
-   *
-   * ```js
-   * root.toResult().root === root
-   * ```
-   */
-  root: Root | Document
-
   /**
    * Options from the `Processor#process` or `Root#toResult` call
    * that produced this Result instance.]
@@ -114,41 +122,33 @@ declare class Result_ {
   opts: Result.ResultOptions
 
   /**
-   * A CSS string representing of `Result#root`.
+   * The Processor instance used for this transformation.
    *
    * ```js
-   * postcss.parse('a{}').toResult().css //=> "a{}"
+   * for (const plugin of result.processor.plugins) {
+   *   if (plugin.postcssPlugin === 'postcss-bad') {
+   *     throw 'postcss-good is incompatible with postcss-bad'
+   *   }
+   * })
    * ```
    */
-  css: string
+  processor: Processor
 
   /**
-   * An instance of `SourceMapGenerator` class from the `source-map` library,
-   * representing changes to the `Result#root` instance.
-   *
-   * ```js
-   * result.map.toJSON() //=> { version: 3, file: 'a.css', … }
-   * ```
+   * Root node after all transformations.
    *
    * ```js
-   * if (result.map) {
-   *   fs.writeFileSync(result.opts.to + '.map', result.map.toString())
-   * }
+   * root.toResult().root === root
    * ```
    */
-  map: SourceMap
-
-  /**
-   * Last runned PostCSS plugin.
-   */
-  lastPlugin: Plugin | TransformCallback
+  root: Document | Root
 
   /**
    * @param processor Processor used for this transformation.
    * @param root      Root node after all transformations.
    * @param opts      Options from the `Processor#process` or `Root#toResult`.
    */
-  constructor(processor: Processor, root: Root | Document, opts: Result.ResultOptions)
+  constructor(processor: Processor, root: Document | Root, opts: Result.ResultOptions)
 
   /**
    * An alias for the `Result#css` property.

package/lib/result.js

@@ -12,6 +12,10 @@ class Result {
     this.map = undefined
   }
 
+  get content() {
+    return this.css
+  }
+
   toString() {
     return this.css
   }
@@ -32,10 +36,6 @@ class Result {
   warnings() {
     return this.messages.filter(i => i.type === 'warning')
   }
-
-  get content() {
-    return this.css
-  }
 }
 
 module.exports = Result

package/lib/root.d.ts

@@ -11,20 +11,20 @@ declare namespace Root {
     after?: string
 
     /**
-     * Non-CSS code before `Root`, when `Root` is inside `Document`.
+     * Non-CSS code after `Root`, when `Root` is inside `Document`.
      *
      * **Experimental:** some aspects of this node could change within minor
      * or patch version releases.
      */
-    codeBefore?: string
+    codeAfter?: string
 
     /**
-     * Non-CSS code after `Root`, when `Root` is inside `Document`.
+     * Non-CSS code before `Root`, when `Root` is inside `Document`.
      *
      * **Experimental:** some aspects of this node could change within minor
      * or patch version releases.
      */
-    codeAfter?: string
+    codeBefore?: string
 
     /**
      * Is the last child has an (optional) semicolon.
@@ -54,10 +54,13 @@ declare namespace Root {
  * ```
  */
 declare class Root_ extends Container {
-  type: 'root'
   parent: Document | undefined
   raws: Root.RootRaws
+  type: 'root'
+
+  constructor(defaults?: Root.RootProps)
 
+  assign(overrides: object | Root.RootProps): this
   /**
    * Returns a `Result` instance representing the root’s CSS.
    *
@@ -72,9 +75,6 @@ declare class Root_ extends Container {
    * @return Result with current root’s CSS.
    */
  toResult(options?: ProcessOptions): Result
-
-  constructor(defaults?: Root.RootProps)
-  assign(overrides: object | Root.RootProps): this
 }
 
 declare class Root extends 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()

package/lib/rule.d.ts

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

package/lib/stringifier.d.ts

@@ -1,13 +1,13 @@
 import {
-  Document,
-  Root,
-  Comment,
-  Declaration,
-  Builder,
   AnyNode,
-  Rule,
   AtRule,
-  Container
+  Builder,
+  Comment,
+  Container,
+  Declaration,
+  Document,
+  Root,
+  Rule
 } from './postcss.js'
 
 declare namespace Stringifier {
@@ -18,27 +18,27 @@ declare namespace Stringifier {
 declare class Stringifier_ {
   builder: Builder
   constructor(builder: Builder)
-  stringify(node: AnyNode, semicolon?: boolean): void
-  document(node: Document): void
-  root(node: Root): void
-  comment(node: Comment): void
-  decl(node: Declaration, semicolon?: boolean): void
-  rule(node: Rule): void
   atrule(node: AtRule, semicolon?: boolean): void
-  body(node: Container): void
+  beforeAfter(node: AnyNode, detect: 'after' | 'before'): string
   block(node: AnyNode, start: string): void
-  raw(node: AnyNode, own: string | null, detect?: string): string
-  rawSemicolon(root: Root): boolean | undefined
-  rawEmptyBody(root: Root): string | undefined
-  rawIndent(root: Root): string | undefined
+  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
-  rawBeforeRule(root: Root): string | undefined
-  rawBeforeClose(root: Root): string | undefined
   rawBeforeOpen(root: Root): string | undefined
+  rawBeforeRule(root: Root): string | undefined
   rawColon(root: Root): string | undefined
-  beforeAfter(node: AnyNode, detect: 'before' | 'after'): string
+  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_ {}