@umijs/bundler-webpack 3.5.20 → 4.0.0-beta.4

package/compiled/autoprefixer/postcss/lib/postcss.d.ts

@@ -0,0 +1,472 @@
+import { SourceMapGenerator, RawSourceMap } from '../../source-map-js'
+
+import Node, {
+  Position,
+  Source,
+  ChildNode,
+  NodeErrorOptions,
+  NodeProps,
+  ChildProps,
+  AnyNode
+} from './node.js'
+import Declaration, { DeclarationProps } from './declaration'
+import Root, { RootProps } from './root'
+import Document, { DocumentProps } from './document'
+import Comment, { CommentProps } from './comment'
+import AtRule, { AtRuleProps } from './at-rule'
+import Result, { Message } from './result'
+import LazyResult from './lazy-result'
+import Rule, { RuleProps } from './rule'
+import Container, { ContainerProps } from './container'
+import Warning, { WarningOptions } from './warning'
+import Input, { FilePosition } from './input'
+import CssSyntaxError from './css-syntax-error'
+import list, { List } from './list'
+import Processor from './processor'
+
+export {
+  WarningOptions,
+  FilePosition,
+  Position,
+  Source,
+  ChildNode,
+  AnyNode,
+  Message,
+  NodeErrorOptions,
+  NodeProps,
+  DeclarationProps,
+  ContainerProps,
+  CommentProps,
+  RuleProps,
+  ChildProps,
+  AtRuleProps,
+  RootProps,
+  DocumentProps,
+  Warning,
+  CssSyntaxError,
+  Node,
+  Container,
+  list,
+  Declaration,
+  Comment,
+  AtRule,
+  Rule,
+  Root,
+  Document,
+  Result,
+  LazyResult,
+  Input
+}
+
+export type SourceMap = SourceMapGenerator & {
+  toJSON(): RawSourceMap
+}
+
+export type Helpers = { result: Result; postcss: Postcss } & Postcss
+
+type DocumentProcessor = (
+  document: Document,
+  helper: Helpers
+) => Promise<void> | void
+type RootProcessor = (root: Root, helper: Helpers) => Promise<void> | void
+type DeclarationProcessor = (
+  decl: Declaration,
+  helper: Helpers
+) => Promise<void> | void
+type RuleProcessor = (rule: Rule, helper: Helpers) => Promise<void> | void
+type AtRuleProcessor = (atRule: AtRule, helper: Helpers) => Promise<void> | void
+type CommentProcessor = (
+  comment: Comment,
+  helper: Helpers
+) => Promise<void> | void
+
+interface Processors {
+  /**
+   * Will be called on `Document` node.
+   *
+   * Will be called again on children changes.
+   */
+  Document?: DocumentProcessor
+
+  /**
+   * Will be called on `Document` node, when all children will be processed.
+   *
+   * Will be called again on children changes.
+   */
+  DocumentExit?: DocumentProcessor
+
+  /**
+   * Will be called on `Root` node once.
+   */
+  Once?: RootProcessor
+
+  /**
+   * Will be called on `Root` node once, when all children will be processed.
+   */
+  OnceExit?: RootProcessor
+
+  /**
+   * Will be called on `Root` node.
+   *
+   * Will be called again on children changes.
+   */
+  Root?: RootProcessor
+
+  /**
+   * Will be called on `Root` node, when all children will be processed.
+   *
+   * Will be called again on children changes.
+   */
+  RootExit?: RootProcessor
+
+  /**
+   * Will be called on all `Declaration` nodes after listeners
+   * for `Declaration` event.
+   *
+   * Will be called again on node or children changes.
+   */
+  Declaration?: DeclarationProcessor | { [prop: string]: DeclarationProcessor }
+
+  /**
+   * Will be called on all `Declaration` nodes.
+   *
+   * Will be called again on node or children changes.
+   */
+  DeclarationExit?:
+    | DeclarationProcessor
+    | { [prop: string]: DeclarationProcessor }
+
+  /**
+   * Will be called on all `Rule` nodes.
+   *
+   * Will be called again on node or children changes.
+   */
+  Rule?: RuleProcessor
+
+  /**
+   * Will be called on all `Rule` nodes, when all children will be processed.
+   *
+   * Will be called again on node or children changes.
+   */
+  RuleExit?: RuleProcessor
+
+  /**
+   * Will be called on all`AtRule` nodes.
+   *
+   * Will be called again on node or children changes.
+   */
+  AtRule?: AtRuleProcessor | { [name: string]: AtRuleProcessor }
+
+  /**
+   * Will be called on all `AtRule` nodes, when all children will be processed.
+   *
+   * Will be called again on node or children changes.
+   */
+  AtRuleExit?: AtRuleProcessor | { [name: string]: AtRuleProcessor }
+
+  /**
+   * Will be called on all `Comment` nodes.
+   *
+   * Will be called again on node or children changes.
+   */
+  Comment?: CommentProcessor
+
+  /**
+   * Will be called on all `Comment` nodes after listeners
+   * for `Comment` event.
+   *
+   * Will be called again on node or children changes.
+   */
+  CommentExit?: CommentProcessor
+
+  /**
+   * Will be called when all other listeners processed the document.
+   *
+   * This listener will not be called again.
+   */
+  Exit?: RootProcessor
+}
+
+export interface Plugin extends Processors {
+  postcssPlugin: string
+  prepare?: (result: Result) => Processors
+}
+
+export interface PluginCreator<PluginOptions> {
+  (opts?: PluginOptions): Plugin | Processor
+  postcss: true
+}
+
+export interface Transformer extends TransformCallback {
+  postcssPlugin: string
+  postcssVersion: string
+}
+
+export interface TransformCallback {
+  (root: Root, result: Result): Promise<void> | void
+}
+
+export interface OldPlugin<T> extends Transformer {
+  (opts?: T): Transformer
+  postcss: Transformer
+}
+
+export type AcceptedPlugin =
+  | Plugin
+  | PluginCreator<any>
+  | OldPlugin<any>
+  | TransformCallback
+  | {
+      postcss: TransformCallback | Processor
+    }
+  | Processor
+
+export interface Parser<RootNode = Root> {
+  (
+    css: string | { toString(): string },
+    opts?: Pick<ProcessOptions, 'map' | 'from'>
+  ): RootNode
+}
+
+export interface Builder {
+  (part: string, node?: AnyNode, type?: 'start' | 'end'): void
+}
+
+export interface Stringifier {
+  (node: AnyNode, builder: Builder): void
+}
+
+export interface JSONHydrator {
+  (data: object[]): Node[]
+  (data: object): Node
+}
+
+export interface Syntax {
+  /**
+   * Function to generate AST by string.
+   */
+  parse?: Parser<Root | Document>
+
+  /**
+   * Class to generate string by AST.
+   */
+  stringify?: Stringifier
+}
+
+export interface SourceMapOptions {
+  /**
+   * Indicates that the source map should be embedded in the output CSS
+   * as a Base64-encoded comment. By default, it is `true`.
+   * But if all previous maps are external, not inline, PostCSS will not embed
+   * the map even if you do not set this option.
+   *
+   * If you have an inline source map, the result.map property will be empty,
+   * as the source map will be contained within the text of `result.css`.
+   */
+  inline?: boolean
+
+  /**
+   * Source map content from a previous processing step (e.g., Sass).
+   *
+   * PostCSS will try to read the previous source map
+   * automatically (based on comments within the source CSS), but you can use
+   * this option to identify it manually.
+   *
+   * If desired, you can omit the previous map with prev: `false`.
+   */
+  prev?: string | boolean | object | ((file: string) => string)
+
+  /**
+   * Indicates that PostCSS should set the origin content (e.g., Sass source)
+   * of the source map. By default, it is true. But if all previous maps do not
+   * contain sources content, PostCSS will also leave it out even if you
+   * do not set this option.
+   */
+  sourcesContent?: boolean
+
+  /**
+   * Indicates that PostCSS should add annotation comments to the CSS.
+   * By default, PostCSS will always add a comment with a path
+   * to the source map. PostCSS will not add annotations to CSS files
+   * that do not contain any comments.
+   *
+   * By default, PostCSS presumes that you want to save the source map as
+   * `opts.to + '.map'` and will use this path in the annotation comment.
+   * A different path can be set by providing a string value for annotation.
+   *
+   * If you have set `inline: true`, annotation cannot be disabled.
+   */
+  annotation?: string | boolean | ((file: string, root: Root) => string)
+
+  /**
+   * Override `from` in map’s sources.
+   */
+  from?: string
+
+  /**
+   * Use absolute path in generated source map.
+   */
+  absolute?: boolean
+}
+
+export interface ProcessOptions {
+  /**
+   * The path of the CSS source file. You should always set `from`,
+   * because it is used in source map generation and syntax error messages.
+   */
+  from?: string
+
+  /**
+   * The path where you'll put the output CSS file. You should always set `to`
+   * to generate correct source maps.
+   */
+  to?: string
+
+  /**
+   * Function to generate AST by string.
+   */
+  parser?: Syntax | Parser
+
+  /**
+   * Class to generate string by AST.
+   */
+  stringifier?: Syntax | Stringifier
+
+  /**
+   * Object with parse and stringify.
+   */
+  syntax?: Syntax
+
+  /**
+   * Source map options
+   */
+  map?: SourceMapOptions | boolean
+}
+
+export interface Postcss {
+  /**
+   * Create a new `Processor` instance that will apply `plugins`
+   * as CSS processors.
+   *
+   * ```js
+   * let postcss = require('postcss')
+   *
+   * postcss(plugins).process(css, { from, to }).then(result => {
+   *   console.log(result.css)
+   * })
+   * ```
+   *
+   * @param plugins PostCSS plugins.
+   * @return Processor to process multiple CSS.
+   */
+  (plugins?: AcceptedPlugin[]): Processor
+  (...plugins: AcceptedPlugin[]): Processor
+
+  /**
+   * Default function to convert a node tree into a CSS string.
+   */
+  stringify: Stringifier
+
+  /**
+   * Parses source css and returns a new `Root` or `Document` node,
+   * which contains the source CSS nodes.
+   *
+   * ```js
+   * // Simple CSS concatenation with source map support
+   * const root1 = postcss.parse(css1, { from: file1 })
+   * const root2 = postcss.parse(css2, { from: file2 })
+   * root1.append(root2).toResult().css
+   * ```
+   */
+  parse: Parser
+
+  /**
+   * Rehydrate a JSON AST (from `Node#toJSON`) back into the AST classes.
+   *
+   * ```js
+   * const json = root.toJSON()
+   * // save to file, send by network, etc
+   * const root2  = postcss.fromJSON(json)
+   * ```
+   */
+  fromJSON: JSONHydrator
+
+  /**
+   * Contains the `list` module.
+   */
+  list: List
+
+  /**
+   * Creates a new `Comment` node.
+   *
+   * @param defaults Properties for the new node.
+   * @return New comment node
+   */
+  comment(defaults?: CommentProps): Comment
+
+  /**
+   * Creates a new `AtRule` node.
+   *
+   * @param defaults Properties for the new node.
+   * @return New at-rule node.
+   */
+  atRule(defaults?: AtRuleProps): AtRule
+
+  /**
+   * Creates a new `Declaration` node.
+   *
+   * @param defaults Properties for the new node.
+   * @return New declaration node.
+   */
+  decl(defaults?: DeclarationProps): Declaration
+
+  /**
+   * Creates a new `Rule` node.
+   *
+   * @param default Properties for the new node.
+   * @return New rule node.
+   */
+  rule(defaults?: RuleProps): Rule
+
+  /**
+   * Creates a new `Root` node.
+   *
+   * @param defaults Properties for the new node.
+   * @return New root node.
+   */
+  root(defaults?: RootProps): Root
+
+  /**
+   * Creates a new `Document` node.
+   *
+   * @param defaults Properties for the new node.
+   * @return New document node.
+   */
+  document(defaults?: DocumentProps): Document
+
+  CssSyntaxError: typeof CssSyntaxError
+  Declaration: typeof Declaration
+  Container: typeof Container
+  Comment: typeof Comment
+  Warning: typeof Warning
+  AtRule: typeof AtRule
+  Result: typeof Result
+  Input: typeof Input
+  Rule: typeof Rule
+  Root: typeof Root
+  Node: typeof Node
+}
+
+export const stringify: Stringifier
+export const parse: Parser
+export const fromJSON: JSONHydrator
+
+export const comment: Postcss['comment']
+export const atRule: Postcss['atRule']
+export const decl: Postcss['decl']
+export const rule: Postcss['rule']
+export const root: Postcss['root']
+
+declare const postcss: Postcss
+
+export default postcss

package/compiled/autoprefixer/postcss/lib/previous-map.d.ts

@@ -0,0 +1,72 @@
+import { SourceMapConsumer } from '../../source-map-js'
+
+import { ProcessOptions } from './postcss'
+
+/**
+ * Source map information from input CSS.
+ * For example, source map after Sass compiler.
+ *
+ * This class will automatically find source map in input CSS or in file system
+ * near input file (according `from` option).
+ *
+ * ```js
+ * const root = parse(css, { from: 'a.sass.css' })
+ * root.input.map //=> PreviousMap
+ * ```
+ */
+export default class PreviousMap {
+  /**
+   * Was source map inlined by data-uri to input CSS.
+   */
+  inline: boolean
+
+  /**
+   * `sourceMappingURL` content.
+   */
+  annotation?: string
+
+  /**
+   * Source map file content.
+   */
+  text?: string
+
+  /**
+   * The directory with source map file, if source map is in separated file.
+   */
+  root?: string
+
+  /**
+   * The CSS source identifier. Contains `Input#file` if the user
+   * set the `from` option, or `Input#id` if they did not.
+   */
+  file?: string
+
+  /**
+   * Path to source map file.
+   */
+  mapFile?: string
+
+  /**
+   * @param css  Input CSS source.
+   * @param opts Process options.
+   */
+  constructor(css: string, opts?: ProcessOptions)
+
+  /**
+   * Create a instance of `SourceMapGenerator` class
+   * from the `source-map` library to work with source map information.
+   *
+   * It is lazy method, so it will create object only on first call
+   * and then it will use cache.
+   *
+   * @return Object with source map information.
+   */
+  consumer(): SourceMapConsumer
+
+  /**
+   * Does source map contains `sourcesContent` with input source text.
+   *
+   * @return Is `sourcesContent` present.
+   */
+  withContent(): boolean
+}

package/compiled/autoprefixer/postcss/lib/processor.d.ts

@@ -0,0 +1,101 @@
+import {
+  AcceptedPlugin,
+  Plugin,
+  ProcessOptions,
+  Transformer,
+  TransformCallback
+} from './postcss.js'
+import LazyResult from './lazy-result'
+import Result from './result'
+import Root from './root'
+
+/**
+ * Contains plugins to process CSS. Create one `Processor` instance,
+ * initialize its plugins, and then use that instance on numerous CSS files.
+ *
+ * ```js
+ * const processor = postcss([autoprefixer, precss])
+ * processor.process(css1).then(result => console.log(result.css))
+ * processor.process(css2).then(result => console.log(result.css))
+ * ```
+ */
+export default class Processor {
+  /**
+   * Current PostCSS version.
+   *
+   * ```js
+   * if (result.processor.version.split('.')[0] !== '6') {
+   *   throw new Error('This plugin works only with PostCSS 6')
+   * }
+   * ```
+   */
+  version: string
+
+  /**
+   * Plugins added to this processor.
+   *
+   * ```js
+   * const processor = postcss([autoprefixer, precss])
+   * processor.plugins.length //=> 2
+   * ```
+   */
+  plugins: (Plugin | Transformer | TransformCallback)[]
+
+  /**
+   * @param plugins PostCSS plugins
+   */
+  constructor(plugins?: AcceptedPlugin[])
+
+  /**
+   * Adds a plugin to be used as a CSS processor.
+   *
+   * PostCSS plugin can be in 4 formats:
+   * * A plugin in `Plugin` format.
+   * * A plugin creator function with `pluginCreator.postcss = true`.
+   *   PostCSS will call this function without argument to get plugin.
+   * * A function. PostCSS will pass the function a @{link Root}
+   *   as the first argument and current `Result` instance
+   *   as the second.
+   * * Another `Processor` instance. PostCSS will copy plugins
+   *   from that instance into this one.
+   *
+   * Plugins can also be added by passing them as arguments when creating
+   * a `postcss` instance (see [`postcss(plugins)`]).
+   *
+   * Asynchronous plugins should return a `Promise` instance.
+   *
+   * ```js
+   * const processor = postcss()
+   *   .use(autoprefixer)
+   *   .use(precss)
+   * ```
+   *
+   * @param plugin PostCSS plugin or `Processor` with plugins.
+   * @return {Processes} Current processor to make methods chain.
+   */
+  use(plugin: AcceptedPlugin): this
+
+  /**
+   * Parses source CSS and returns a `LazyResult` Promise proxy.
+   * Because some plugins can be asynchronous it doesn’t make
+   * any transformations. Transformations will be applied
+   * in the `LazyResult` methods.
+   *
+   * ```js
+   * processor.process(css, { from: 'a.css', to: 'a.out.css' })
+   *   .then(result => {
+   *      console.log(result.css)
+   *   })
+   * ```
+   *
+   * @param css String with input CSS or any object with a `toString()` method,
+   *            like a Buffer. Optionally, senda `Result` instance
+   *            and the processor will take the `Root` from it.
+   * @param opts Options.
+   * @return Promise proxy.
+   */
+  process(
+    css: string | { toString(): string } | Result | LazyResult | Root,
+    options?: ProcessOptions
+  ): LazyResult
+}