Upgrading postcss from 7.x to 8.x

Comparison of the public API of postcss 7.0.39 and 8.5.33, computed automatically from their TypeScript types. A changed signature is a candidate for a breaking change, not a certainty.

Summary

Removed import paths	0
Removed exports	31
Changed signatures	23
Removed class or interface members	9
Changed class or interface members	149
Newly deprecated	0
Requirement changes (engines, peer dependencies)	1
New exports	25

Removed exports

import	export	kind	Before
`postcss`	`plugin`	function	`<T>(name: string, initializer: PluginInitializer<T>): Plugin<T>`
`postcss`	`vendor`	namespace	`namespace`
`postcss`	`JsonNode`	interface	`interface`
`postcss`	`JsonRoot`	interface	`interface`
`postcss`	`JsonRule`	interface	`interface`
`postcss`	`NodeBase`	interface	`interface`
`postcss`	`NodeRaws`	interface	`interface`
`postcss`	`RuleRaws`	interface	`interface`
`postcss`	`ResultMap`	interface	`interface`
`postcss`	`AtRuleRaws`	interface	`interface`
`postcss`	`JsonAtRule`	interface	`interface`
`postcss`	`NodeSource`	interface	`interface`
`postcss`	`InputOrigin`	interface	`interface`
`postcss`	`JsonComment`	interface	`interface`
`postcss`	`ParserInput`	type	`string \| { toString(): string; }`
`postcss`	`PreviousMap`	class	`class`
`postcss`	`NodeNewProps`	interface	`interface`
`postcss`	`RootNewProps`	interface	`interface`
`postcss`	`RuleNewProps`	interface	`interface`
`postcss`	`ContainerBase`	interface	`interface`
`postcss`	`ContainerRaws`	interface	`interface`
`postcss`	`JsonContainer`	interface	`interface`
`postcss`	`ResultMessage`	interface	`interface`
`postcss`	`ResultOptions`	interface	`interface`
`postcss`	`AtRuleNewProps`	interface	`interface`
`postcss`	`CommentNewProps`	interface	`interface`
`postcss`	`DeclarationRaws`	interface	`interface`
`postcss`	`JsonDeclaration`	interface	`interface`
`postcss`	`ContainerNewProps`	interface	`interface`
`postcss`	`PluginInitializer`	interface	`interface`
`postcss`	`DeclarationNewProps`	interface	`interface`

Changed signatures

export	Before	After
`postcss · Node`	`Root \| ChildNode`	`class`
`postcss · Root`	`interface`	`class`
`postcss · Rule`	`interface`	`class`
`postcss · decl`	`(defaults?: DeclarationNewProps \| undefined): Declaration`	`(defaults?: DeclarationProps \| undefined): Declaration_`
`postcss · list`	`namespace`	`List`
`postcss · root`	`(defaults?: object \| undefined): Root`	`(defaults?: RootProps \| undefined): Root_`
`postcss · rule`	`(defaults?: RuleNewProps \| undefined): Rule`	`(defaults?: RuleProps \| undefined): Rule_`
`postcss · Input`	`interface`	`class`
`postcss · parse`	`(css: ParserInput, opts?: Pick<ProcessOptions, "map" \| "from"> \| undefined): Root`	`(css: string \| { toString(): string; }, opts?: Pick<ProcessOptions<Root_ \| Document_>, "document" \| "from" \| "map" \| "unsafeMap"> \| undefined): Root_`
`postcss · AtRule`	`interface`	`class`
`postcss · Result`	`interface`	`class`
`postcss · atRule`	`(defaults?: AtRuleNewProps \| undefined): AtRule`	`(defaults?: AtRuleProps \| undefined): AtRule_`
`postcss · Comment`	`interface`	`class`
`postcss · Warning`	`interface`	`class`
`postcss · comment`	`(defaults?: CommentNewProps \| undefined): Comment`	`(defaults?: CommentProps \| undefined): Comment_`
`postcss · ChildNode`	`Comment \| AtRule \| Declaration \| Rule`	`Comment_ \| AtRule_ \| Declaration_ \| Rule_`
`postcss · Container`	`AtRule \| Rule \| Root`	`class`
`postcss · Processor`	`interface`	`class`
`postcss · stringify`	`(node: Node, builder: Builder): void`	`(node: AnyNode, builder: Builder): void`
`postcss · LazyResult`	`interface`	`class`
`postcss · Declaration`	`interface`	`class`
`postcss · AcceptedPlugin`	`Plugin<any> \| Transformer \| { postcss: TransformCallback \| Processor; } \| Processor`	`Processor_ \| { postcss: Processor_ \| TransformCallback; } \| OldPlugin<any> \| Plugin \| PluginCreator<any> \| TransformCallback`
`postcss · CssSyntaxError`	`interface`	`class`

Removed class or interface members

member	import	Before
`Plugin.postcss`	`postcss`	`(root: Root, result: Result): any`
`Plugin.process`	`postcss`	`(css: string \| Result \| { toString(): string; }, processOpts?: ProcessOptions \| undefined, pluginOpts?: T \| undefined): LazyResult`
`Plugin.postcssVersion`	`postcss`	`string \| undefined`
`WarningOptions.to`	`postcss`	`string \| undefined`
`WarningOptions.map`	`postcss`	`boolean \| SourceMapOptions \| undefined`
`WarningOptions.from`	`postcss`	`string \| undefined`
`WarningOptions.parser`	`postcss`	`Parser \| undefined`
`WarningOptions.syntax`	`postcss`	`Syntax \| undefined`
`WarningOptions.stringifier`	`postcss`	`Stringifier \| undefined`

Changed class or interface members

member	Before	After
`Root.each`	`(callback: (node: ChildNode, index: number) => void): void \| (callback: (node: ChildNode, index: number) => boolean): boolean`	`(callback: (node: ChildNode, index: number) => false \| void): false \| undefined`
`Root.raws`	`NodeRaws`	`RootRaws`
`Root.root`	`(): Root`	`(): Root_`
`Root.some`	`(callback: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean): boolean`	`(condition: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean): boolean`
`Root.walk`	`(callback: (node: ChildNode, index: number) => void): void \| (callback: (node: ChildNode, index: number) => boolean): boolean`	`(callback: (node: ChildNode, index: number) => false \| void): false \| undefined`
`Root.warn`	`(result: Result, text: string, opts?: WarningOptions \| undefined): void`	`(result: Result_<Root_ \| Document_>, message: string, options?: WarningOptions \| undefined): Warning_`
`Root.after`	`(newNode: string \| object \| Node \| Node[]): Root`	`(newNode: string \| Node \| ChildProps \| readonly Node[] \| undefined): Root_`
`Root.clone`	`(overrides?: object \| undefined): Root`	`(overrides?: Partial<RootProps> \| undefined): Root_`
`Root.error`	`(message: string, options?: NodeErrorOptions \| undefined): CssSyntaxError`	`(message: string, options?: NodeErrorOptions \| undefined): CssSyntaxError_`
`Root.every`	`(callback: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean): boolean`	`(condition: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean): boolean`
`Root.nodes`	`ChildNode[] \| undefined`	`ChildNode[]`
`Root.append`	`(...nodes: (string \| object \| Node)[]): Root`	`(...nodes: NewChild[]): Root_`
`Root.before`	`(newNode: string \| object \| Node \| Node[]): Root`	`(newNode: string \| Node \| ChildProps \| readonly Node[] \| undefined): Root_`
`Root.parent`	`void`	`Document_ \| undefined`
`Root.remove`	`(): Root`	`(): Root_`
`Root.source`	`NodeSource \| undefined`	`Source \| undefined`
`Root.prepend`	`(...nodes: (string \| object \| Node)[]): Root`	`(...nodes: NewChild[]): Root_`
`Root.toResult`	`(options?: { to?: string \| undefined; map?: SourceMapOptions \| undefined; } \| undefined): Result`	`(options?: ProcessOptions<Root_ \| Document_> \| undefined): Result_<Root_ \| Document_>`
`Root.toString`	`(stringifier?: Stringifier \| Syntax \| undefined): string`	`(stringifier?: Stringifier \| Syntax<Root_ \| Document_> \| undefined): string`
`Root.removeAll`	`(): Root`	`(): Root_`
`Root.walkDecls`	`(propFilter: string \| RegExp, callback: (decl: Declaration, index: number) => void): void \| (callback: (decl: Declaration, index: number) => void): void \| (propFilter: string \| RegExp, callback: (decl: Declaration, index: number) => boolean): boolean \| (callback: (decl: Declaration, index: number) =…`	`(propFilter: string \| RegExp, callback: (decl: Declaration_, index: number) => false \| void): false \| undefined \| (callback: (decl: Declaration_, index: number) => false \| void): false \| undefined`
`Root.walkRules`	`(selectorFilter: string \| RegExp, callback: (atRule: Rule, index: number) => void): void \| (callback: (atRule: Rule, index: number) => void): void \| (selectorFilter: string \| RegExp, callback: (atRule: Rule, index: number) => boolean): boolean \| (callback: (atRule: Rule, index: number) => boolean): …`	`(selectorFilter: string \| RegExp, callback: (rule: Rule_, index: number) => false \| void): false \| undefined \| (callback: (rule: Rule_, index: number) => false \| void): false \| undefined`
`Root.cloneAfter`	`(overrides?: object \| undefined): Root`	`(overrides?: Partial<RootProps> \| undefined): Root_`
`Root.cloneBefore`	`(overrides?: object \| undefined): Root`	`(overrides?: Partial<RootProps> \| undefined): Root_`
`Root.insertAfter`	`(oldNode: number \| ChildNode, newNode: string \| object \| ChildNode): Root`	`(oldNode: number \| ChildNode, newNode: NewChild): Root_`
`Root.removeChild`	`(child: number \| ChildNode): Root`	`(child: number \| ChildNode): Root_`
`Root.replaceWith`	`(...nodes: (object \| Node)[]): Root`	`(...nodes: NewChild[]): Root_`
`Root.walkAtRules`	`(nameFilter: string \| RegExp, callback: (atRule: AtRule, index: number) => void): void \| (callback: (atRule: AtRule, index: number) => void): void \| (nameFilter: string \| RegExp, callback: (atRule: AtRule, index: number) => boolean): boolean \| (callback: (atRule: AtRule, index: number) => boolean): …`	`(nameFilter: string \| RegExp, callback: (atRule: AtRule_, index: number) => false \| void): false \| undefined \| (callback: (atRule: AtRule_, index: number) => false \| void): false \| undefined`
`Root.insertBefore`	`(oldNode: number \| ChildNode, newNode: string \| object \| ChildNode): Root`	`(oldNode: number \| ChildNode, newNode: NewChild): Root_`
`Root.walkComments`	`(callback: (comment: Comment, indexed: number) => void): void \| (callback: (comment: Comment, indexed: number) => boolean): boolean`	`(callback: (comment: Comment_, indexed: number) => false \| void): false \| undefined`
`Root.replaceValues`	`(pattern: string \| RegExp, options: { props?: string[] \| undefined; fast?: string \| undefined; }, callbackOrReplaceValue: string \| ((substring: string, ...args: any[]) => string)): Root \| (pattern: string \| RegExp, callbackOrReplaceValue: string \| ((substring: string, ...args: any[]) => string)): Ro…`	`(pattern: string \| RegExp, replaced: string \| ((substring: string, ...args: any[]) => string)): Root_ \| (pattern: string \| RegExp, options: ValueOptions, replaced: string \| ((substring: string, ...args: any[]) => string)): Root_`
`Rule.each`	`(callback: (node: ChildNode, index: number) => void): void \| (callback: (node: ChildNode, index: number) => boolean): boolean`	`(callback: (node: ChildNode, index: number) => false \| void): false \| undefined`
`Rule.raws`	`NodeRaws`	`RuleRaws`
`Rule.root`	`(): Root`	`(): Root_`
`Rule.some`	`(callback: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean): boolean`	`(condition: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean): boolean`
`Rule.walk`	`(callback: (node: ChildNode, index: number) => void): void \| (callback: (node: ChildNode, index: number) => boolean): boolean`	`(callback: (node: ChildNode, index: number) => false \| void): false \| undefined`
`Rule.warn`	`(result: Result, text: string, opts?: WarningOptions \| undefined): void`	`(result: Result_<Root_ \| Document_>, message: string, options?: WarningOptions \| undefined): Warning_`
`Rule.after`	`(newNode: string \| object \| Node \| Node[]): Rule`	`(newNode: string \| Node \| ChildProps \| readonly Node[] \| undefined): Rule_`
`Rule.clone`	`(overrides?: object \| undefined): Rule`	`(overrides?: Partial<RuleProps> \| undefined): Rule_`
`Rule.error`	`(message: string, options?: NodeErrorOptions \| undefined): CssSyntaxError`	`(message: string, options?: NodeErrorOptions \| undefined): CssSyntaxError_`
`Rule.every`	`(callback: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean): boolean`	`(condition: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean): boolean`
`Rule.nodes`	`ChildNode[] \| undefined`	`ChildNode[]`
`Rule.append`	`(...nodes: (string \| object \| Node)[]): Rule`	`(...nodes: NewChild[]): Rule_`
`Rule.before`	`(newNode: string \| object \| Node \| Node[]): Rule`	`(newNode: string \| Node \| ChildProps \| readonly Node[] \| undefined): Rule_`
`Rule.parent`	`Container`	`ContainerWithChildren \| undefined`
`Rule.remove`	`(): Rule`	`(): Rule_`
`Rule.source`	`NodeSource \| undefined`	`Source \| undefined`
`Rule.prepend`	`(...nodes: (string \| object \| Node)[]): Rule`	`(...nodes: NewChild[]): Rule_`
`Rule.toString`	`(stringifier?: Stringifier \| Syntax \| undefined): string`	`(stringifier?: Stringifier \| Syntax<Root_ \| Document_> \| undefined): string`
`Rule.removeAll`	`(): Rule`	`(): Rule_`
`Rule.walkDecls`	`(propFilter: string \| RegExp, callback: (decl: Declaration, index: number) => void): void \| (callback: (decl: Declaration, index: number) => void): void \| (propFilter: string \| RegExp, callback: (decl: Declaration, index: number) => boolean): boolean \| (callback: (decl: Declaration, index: number) =…`	`(propFilter: string \| RegExp, callback: (decl: Declaration_, index: number) => false \| void): false \| undefined \| (callback: (decl: Declaration_, index: number) => false \| void): false \| undefined`
`Rule.walkRules`	`(selectorFilter: string \| RegExp, callback: (atRule: Rule, index: number) => void): void \| (callback: (atRule: Rule, index: number) => void): void \| (selectorFilter: string \| RegExp, callback: (atRule: Rule, index: number) => boolean): boolean \| (callback: (atRule: Rule, index: number) => boolean): …`	`(selectorFilter: string \| RegExp, callback: (rule: Rule_, index: number) => false \| void): false \| undefined \| (callback: (rule: Rule_, index: number) => false \| void): false \| undefined`
`Rule.cloneAfter`	`(overrides?: object \| undefined): Rule`	`(overrides?: Partial<RuleProps> \| undefined): Rule_`
`Rule.cloneBefore`	`(overrides?: object \| undefined): Rule`	`(overrides?: Partial<RuleProps> \| undefined): Rule_`
`Rule.insertAfter`	`(oldNode: number \| ChildNode, newNode: string \| object \| ChildNode): Rule`	`(oldNode: number \| ChildNode, newNode: NewChild): Rule_`
`Rule.removeChild`	`(child: number \| ChildNode): Rule`	`(child: number \| ChildNode): Rule_`
`Rule.replaceWith`	`(...nodes: (object \| Node)[]): Rule`	`(...nodes: NewChild[]): Rule_`
`Rule.walkAtRules`	`(nameFilter: string \| RegExp, callback: (atRule: AtRule, index: number) => void): void \| (callback: (atRule: AtRule, index: number) => void): void \| (nameFilter: string \| RegExp, callback: (atRule: AtRule, index: number) => boolean): boolean \| (callback: (atRule: AtRule, index: number) => boolean): …`	`(nameFilter: string \| RegExp, callback: (atRule: AtRule_, index: number) => false \| void): false \| undefined \| (callback: (atRule: AtRule_, index: number) => false \| void): false \| undefined`
`Rule.insertBefore`	`(oldNode: number \| ChildNode, newNode: string \| object \| ChildNode): Rule`	`(oldNode: number \| ChildNode, newNode: NewChild): Rule_`
`Rule.walkComments`	`(callback: (comment: Comment, indexed: number) => void): void \| (callback: (comment: Comment, indexed: number) => boolean): boolean`	`(callback: (comment: Comment_, indexed: number) => false \| void): false \| undefined`
`Rule.replaceValues`	`(pattern: string \| RegExp, options: { props?: string[] \| undefined; fast?: string \| undefined; }, callbackOrReplaceValue: string \| ((substring: string, ...args: any[]) => string)): Rule \| (pattern: string \| RegExp, callbackOrReplaceValue: string \| ((substring: string, ...args: any[]) => string)): Ru…`	`(pattern: string \| RegExp, replaced: string \| ((substring: string, ...args: any[]) => string)): Rule_ \| (pattern: string \| RegExp, options: ValueOptions, replaced: string \| ((substring: string, ...args: any[]) => string)): Rule_`
`Input.map`	`PreviousMap`	`PreviousMap_`
`Input.origin`	`(line: number, column: number): false \| InputOrigin`	`(line: number, column: number, endLine?: number \| undefined, endColumn?: number \| undefined): false \| FilePosition`
`AtRule.each`	`(callback: (node: ChildNode, index: number) => void): void \| (callback: (node: ChildNode, index: number) => boolean): boolean`	`(callback: (node: ChildNode, index: number) => false \| void): false \| undefined`
`AtRule.raws`	`NodeRaws`	`AtRuleRaws`
`AtRule.root`	`(): Root`	`(): Root_`
`AtRule.some`	`(callback: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean): boolean`	`(condition: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean): boolean`
`AtRule.walk`	`(callback: (node: ChildNode, index: number) => void): void \| (callback: (node: ChildNode, index: number) => boolean): boolean`	`(callback: (node: ChildNode, index: number) => false \| void): false \| undefined`
`AtRule.warn`	`(result: Result, text: string, opts?: WarningOptions \| undefined): void`	`(result: Result_<Root_ \| Document_>, message: string, options?: WarningOptions \| undefined): Warning_`
`AtRule.after`	`(newNode: string \| object \| Node \| Node[]): AtRule`	`(newNode: string \| Node \| ChildProps \| readonly Node[] \| undefined): AtRule_`
`AtRule.clone`	`(overrides?: object \| undefined): AtRule`	`(overrides?: Partial<AtRuleProps> \| undefined): AtRule_`
`AtRule.error`	`(message: string, options?: NodeErrorOptions \| undefined): CssSyntaxError`	`(message: string, options?: NodeErrorOptions \| undefined): CssSyntaxError_`
`AtRule.every`	`(callback: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean): boolean`	`(condition: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean): boolean`
`AtRule.append`	`(...nodes: (string \| object \| Node)[]): AtRule`	`(...nodes: NewChild[]): AtRule_`
`AtRule.before`	`(newNode: string \| object \| Node \| Node[]): AtRule`	`(newNode: string \| Node \| ChildProps \| readonly Node[] \| undefined): AtRule_`
`AtRule.parent`	`Container`	`ContainerWithChildren \| undefined`
`AtRule.remove`	`(): AtRule`	`(): AtRule_`
`AtRule.source`	`NodeSource \| undefined`	`Source \| undefined`
`AtRule.prepend`	`(...nodes: (string \| object \| Node)[]): AtRule`	`(...nodes: NewChild[]): AtRule_`
`AtRule.toString`	`(stringifier?: Stringifier \| Syntax \| undefined): string`	`(stringifier?: Stringifier \| Syntax<Root_ \| Document_> \| undefined): string`
`AtRule.removeAll`	`(): AtRule`	`(): AtRule_`
`AtRule.walkDecls`	`(propFilter: string \| RegExp, callback: (decl: Declaration, index: number) => void): void \| (callback: (decl: Declaration, index: number) => void): void \| (propFilter: string \| RegExp, callback: (decl: Declaration, index: number) => boolean): boolean \| (callback: (decl: Declaration, index: number) =…`	`(propFilter: string \| RegExp, callback: (decl: Declaration_, index: number) => false \| void): false \| undefined \| (callback: (decl: Declaration_, index: number) => false \| void): false \| undefined`
`AtRule.walkRules`	`(selectorFilter: string \| RegExp, callback: (atRule: Rule, index: number) => void): void \| (callback: (atRule: Rule, index: number) => void): void \| (selectorFilter: string \| RegExp, callback: (atRule: Rule, index: number) => boolean): boolean \| (callback: (atRule: Rule, index: number) => boolean): …`	`(selectorFilter: string \| RegExp, callback: (rule: Rule_, index: number) => false \| void): false \| undefined \| (callback: (rule: Rule_, index: number) => false \| void): false \| undefined`
`AtRule.cloneAfter`	`(overrides?: object \| undefined): AtRule`	`(overrides?: Partial<AtRuleProps> \| undefined): AtRule_`
`AtRule.cloneBefore`	`(overrides?: object \| undefined): AtRule`	`(overrides?: Partial<AtRuleProps> \| undefined): AtRule_`
`AtRule.insertAfter`	`(oldNode: number \| ChildNode, newNode: string \| object \| ChildNode): AtRule`	`(oldNode: number \| ChildNode, newNode: NewChild): AtRule_`
`AtRule.removeChild`	`(child: number \| ChildNode): AtRule`	`(child: number \| ChildNode): AtRule_`
`AtRule.replaceWith`	`(...nodes: (object \| Node)[]): AtRule`	`(...nodes: NewChild[]): AtRule_`
`AtRule.walkAtRules`	`(nameFilter: string \| RegExp, callback: (atRule: AtRule, index: number) => void): void \| (callback: (atRule: AtRule, index: number) => void): void \| (nameFilter: string \| RegExp, callback: (atRule: AtRule, index: number) => boolean): boolean \| (callback: (atRule: AtRule, index: number) => boolean): …`	`(nameFilter: string \| RegExp, callback: (atRule: AtRule_, index: number) => false \| void): false \| undefined \| (callback: (atRule: AtRule_, index: number) => false \| void): false \| undefined`
`AtRule.insertBefore`	`(oldNode: number \| ChildNode, newNode: string \| object \| ChildNode): AtRule`	`(oldNode: number \| ChildNode, newNode: NewChild): AtRule_`
`AtRule.walkComments`	`(callback: (comment: Comment, indexed: number) => void): void \| (callback: (comment: Comment, indexed: number) => boolean): boolean`	`(callback: (comment: Comment_, indexed: number) => false \| void): false \| undefined`
`AtRule.replaceValues`	`(pattern: string \| RegExp, options: { props?: string[] \| undefined; fast?: string \| undefined; }, callbackOrReplaceValue: string \| ((substring: string, ...args: any[]) => string)): AtRule \| (pattern: string \| RegExp, callbackOrReplaceValue: string \| ((substring: string, ...args: any[]) => string)): …`	`(pattern: string \| RegExp, replaced: string \| ((substring: string, ...args: any[]) => string)): AtRule_ \| (pattern: string \| RegExp, options: ValueOptions, replaced: string \| ((substring: string, ...args: any[]) => string)): AtRule_`
`Plugin.postcssPlugin`	`string \| undefined`	`string`
`Result.map`	`ResultMap`	`any`
`Result.opts`	`ResultOptions \| undefined`	`ResultOptions`
`Result.root`	`Root \| undefined`	`RootNode`
`Result.warn`	`(message: string, options?: WarningOptions \| undefined): void`	`(message: string, options?: WarningOptions \| undefined): Warning_`
`Result.messages`	`ResultMessage[]`	`Message[]`
`Result.warnings`	`(): Warning[]`	`(): Warning_[]`
`Result.processor`	`Processor \| undefined`	`Processor_`
`Syntax.parse`	`Parser \| undefined`	`Parser<RootNode> \| undefined`
`Comment.raws`	`NodeRaws`	`CommentRaws`
`Comment.root`	`(): Root`	`(): Root_`
`Comment.warn`	`(result: Result, text: string, opts?: WarningOptions \| undefined): void`	`(result: Result_<Root_ \| Document_>, message: string, options?: WarningOptions \| undefined): Warning_`
`Comment.after`	`(newNode: string \| object \| Node \| Node[]): Comment`	`(newNode: string \| Node \| ChildProps \| readonly Node[] \| undefined): Comment_`
`Comment.clone`	`(overrides?: object \| undefined): Comment`	`(overrides?: Partial<CommentProps> \| undefined): Comment_`
`Comment.error`	`(message: string, options?: NodeErrorOptions \| undefined): CssSyntaxError`	`(message: string, options?: NodeErrorOptions \| undefined): CssSyntaxError_`
`Comment.before`	`(newNode: string \| object \| Node \| Node[]): Comment`	`(newNode: string \| Node \| ChildProps \| readonly Node[] \| undefined): Comment_`
`Comment.parent`	`Container`	`Container_<ChildNode> \| undefined`
`Comment.remove`	`(): Comment`	`(): Comment_`
`Comment.source`	`NodeSource \| undefined`	`Source \| undefined`
`Comment.toString`	`(stringifier?: Stringifier \| Syntax \| undefined): string`	`(stringifier?: Stringifier \| Syntax<Root_ \| Document_> \| undefined): string`
`Comment.cloneAfter`	`(overrides?: object \| undefined): Comment`	`(overrides?: Partial<CommentProps> \| undefined): Comment_`
`Comment.cloneBefore`	`(overrides?: object \| undefined): Comment`	`(overrides?: Partial<CommentProps> \| undefined): Comment_`
`Comment.replaceWith`	`(...nodes: (object \| Node)[]): Comment`	`(...nodes: NewChild[]): Comment_`
`Processor.use`	`(plugin: AcceptedPlugin): Processor`	`(plugin: AcceptedPlugin): Processor_`
`Processor.plugins`	`Plugin<any>[]`	`(Plugin \| TransformCallback \| Transformer)[]`
`Processor.process`	`(css: Root \| Result \| LazyResult \| ParserInput, options?: ProcessOptions \| undefined): LazyResult`	`(css: string \| Root_ \| Result_<Root_ \| Document_> \| { toString(): string; } \| LazyResult_<Root_ \| Document_>): LazyResult_<Root_ \| Document_> \| NoWorkResult_ \| <RootNode extends Document \| Root = Root_>(css: string \| Root_ \| Result_<Root_ \| Document_> \| LazyResult_<Root_ \| Document_> \| { toString():…`
`LazyResult.map`	`ResultMap`	`any`
`LazyResult.root`	`Root`	`RootNode`
`LazyResult.then`	`<TResult1 = Result, TResult2 = never>(onfulfilled?: ((value: Result) => TResult1 \| PromiseLike<TResult1>) \| null \| undefined, onrejected?: ((reason: any) => TResult2 \| PromiseLike<TResult2>) \| null \| undefined): Promise<TResult1 \| TResult2>`	`<TResult1 = Result_<RootNode>, TResult2 = never>(onfulfilled?: ((value: Result_<RootNode>) => TResult1 \| PromiseLike<TResult1>) \| null \| undefined, onrejected?: ((reason: any) => TResult2 \| PromiseLike<TResult2>) \| null \| undefined): Promise<TResult1 \| TResult2>`
`LazyResult.catch`	`<TResult = never>(onrejected?: ((reason: any) => TResult \| PromiseLike<TResult>) \| null \| undefined): Promise<Result \| TResult>`	`<TResult = never>(onrejected?: ((reason: any) => TResult \| PromiseLike<TResult>) \| null \| undefined): Promise<Result_<RootNode> \| TResult>`
`LazyResult.messages`	`ResultMessage[]`	`Message[]`
`LazyResult.warnings`	`(): Warning[]`	`(): Warning_[]`
`LazyResult.processor`	`Processor`	`Processor_`
`Declaration.raws`	`NodeRaws`	`DeclarationRaws`
`Declaration.root`	`(): Root`	`(): Root_`
`Declaration.warn`	`(result: Result, text: string, opts?: WarningOptions \| undefined): void`	`(result: Result_<Root_ \| Document_>, message: string, options?: WarningOptions \| undefined): Warning_`
`Declaration.after`	`(newNode: string \| object \| Node \| Node[]): Declaration`	`(newNode: string \| Node \| ChildProps \| readonly Node[] \| undefined): Declaration_`
`Declaration.clone`	`(overrides?: object \| undefined): Declaration`	`(overrides?: Partial<DeclarationProps> \| undefined): Declaration_`
`Declaration.error`	`(message: string, options?: NodeErrorOptions \| undefined): CssSyntaxError`	`(message: string, options?: NodeErrorOptions \| undefined): CssSyntaxError_`
`Declaration.before`	`(newNode: string \| object \| Node \| Node[]): Declaration`	`(newNode: string \| Node \| ChildProps \| readonly Node[] \| undefined): Declaration_`
`Declaration.parent`	`Container`	`ContainerWithChildren \| undefined`
`Declaration.remove`	`(): Declaration`	`(): Declaration_`
`Declaration.source`	`NodeSource \| undefined`	`Source \| undefined`
`Declaration.toString`	`(stringifier?: Stringifier \| Syntax \| undefined): string`	`(stringifier?: Stringifier \| Syntax<Root_ \| Document_> \| undefined): string`
`Declaration.important`	`boolean`	`boolean \| undefined`
`Declaration.cloneAfter`	`(overrides?: object \| undefined): Declaration`	`(overrides?: Partial<DeclarationProps> \| undefined): Declaration_`
`Declaration.cloneBefore`	`(overrides?: object \| undefined): Declaration`	`(overrides?: Partial<DeclarationProps> \| undefined): Declaration_`
`Declaration.replaceWith`	`(...nodes: (object \| Node)[]): Declaration`	`(...nodes: NewChild[]): Declaration_`
`Transformer.postcssPlugin`	`string \| undefined`	`string`
`Transformer.postcssVersion`	`string \| undefined`	`string`
`CssSyntaxError.name`	`string`	`"CssSyntaxError"`
`CssSyntaxError.input`	`InputOrigin \| undefined`	`FilePosition \| undefined`
`ProcessOptions.parser`	`Parser \| undefined`	`Parser<RootNode> \| Syntax<RootNode> \| undefined`
`ProcessOptions.syntax`	`Syntax \| undefined`	`Syntax<RootNode> \| undefined`
`ProcessOptions.stringifier`	`Stringifier \| undefined`	`Stringifier \| Syntax<RootNode> \| undefined`
`SourceMapOptions.prev`	`any`	`string \| boolean \| object \| ((file: string) => string) \| undefined`
`SourceMapOptions.annotation`	`string \| boolean \| undefined`	`string \| boolean \| ((file: string, root: Root_) => string) \| undefined`

Newly deprecated

None detected.

Requirement changes (engines, peer dependencies)

	Before	After
`engines.node`	`>=6.0.0`	`^10 \|\| ^12 \|\| >=14`

New exports (25)

import	export	kind
`postcss`	`Source`	interface
`postcss`	`AnyNode`	type
`postcss`	`Helpers`	type
`postcss`	`Message`	interface
`postcss`	`Postcss`	type
`postcss`	`default`	function
`postcss`	`Document`	class
`postcss`	`NewChild`	type
`postcss`	`Position`	interface
`postcss`	`document`	function
`postcss`	`fromJSON`	variable
`postcss`	`NodeProps`	interface
`postcss`	`OldPlugin`	interface
`postcss`	`RootProps`	interface
`postcss`	`RuleProps`	type
`postcss`	`SourceMap`	type
`postcss`	`ChildProps`	type
`postcss`	`AtRuleProps`	interface
`postcss`	`CommentProps`	interface
`postcss`	`FilePosition`	interface
`postcss`	`JSONHydrator`	interface
`postcss`	`DocumentProps`	interface
`postcss`	`PluginCreator`	interface
`postcss`	`ContainerProps`	interface
`postcss`	`DeclarationProps`	interface

Give your AI agent these facts

Vigia is a free MCP server: your coding agent checks versions, breaking changes and vulnerabilities before it writes code. No signup, no API key.

claude mcp add --transport http vigia https://vigia.coredls.cloud/mcp

Add to Cursor Add to VS Code ★ Star on GitHub

Any other MCP client

{ "mcpServers": { "vigia": { "url": "https://vigia.coredls.cloud/mcp" } } }

Agent skill (SKILL.md): tells the agent when to use Vigia · GitHub Action for pull requests

Frequently asked questions

What are the breaking changes when upgrading postcss from 7 to 8?

Between postcss 7.0.39 and 8.5.33, Vigia found 31 removed exports, 23 changed signatures and 158 removed or changed class or interface members.

What became deprecated in postcss 8?

0 exports or members are newly marked as deprecated in postcss 8.5.33.

For agents

GET https://vigia.coredls.cloud/v1/packages/npm/postcss/upgrade?from=7.0.39&to=8.5.33