@poveste/vendors 0.14.0 → 0.16.0

package/dist/client/node_modules/postcss/lib/container.d.ts

@@ -1,474 +0,0 @@
-import AtRule from './at-rule.js'
-import Comment from './comment.js'
-import Declaration from './declaration.js'
-import Node, { ChildNode, ChildProps, NodeProps } from './node.js'
-import { Root } from './postcss.js'
-import Rule from './rule.js'
-
-declare namespace Container {
-  export type ContainerWithChildren<Child extends Node = ChildNode> = {
-    nodes: Child[]
-  } & (AtRule | Root | Rule)
-
-  export interface ValueOptions {
-    /**
-     * String that’s used to narrow down values and speed up the regexp search.
-     */
-    fast?: string
-
-    /**
-     * An array of property names.
-     */
-    props?: readonly string[]
-  }
-
-  export interface ContainerProps extends NodeProps {
-    nodes?: readonly (ChildProps | Node)[]
-  }
-
-  /**
-   * All types that can be passed into container methods to create or add a new
-   * child node.
-   */
-  export type NewChild =
-    | ChildProps
-    | Node
-    | readonly ChildProps[]
-    | readonly Node[]
-    | readonly string[]
-    | string
-    | undefined
-
-  export { Container_ as default }
-}
-
-/**
- * The `Root`, `AtRule`, and `Rule` container nodes
- * inherit some common methods to help work with their children.
- *
- * Note that all containers can store any content. If you write a rule inside
- * a rule, PostCSS will parse it.
- */
-declare abstract class Container_<Child extends Node = ChildNode> extends Node {
-  /**
-   * An array containing the container’s children.
-   *
-   * ```js
-   * const root = postcss.parse('a { color: black }')
-   * root.nodes.length           //=> 1
-   * root.nodes[0].selector      //=> 'a'
-   * root.nodes[0].nodes[0].prop //=> 'color'
-   * ```
-   */
-  nodes: Child[] | undefined
-
-  /**
-   * The container’s first child.
-   *
-   * ```js
-   * rule.first === rules.nodes[0]
-   * ```
-   */
-  get first(): Child | undefined
-
-  /**
-   * The container’s last child.
-   *
-   * ```js
-   * rule.last === rule.nodes[rule.nodes.length - 1]
-   * ```
-   */
-  get last(): Child | undefined
-  /**
-   * Inserts new nodes to the end of the container.
-   *
-   * ```js
-   * const decl1 = new Declaration({ prop: 'color', value: 'black' })
-   * const decl2 = new Declaration({ prop: 'background-color', value: 'white' })
-   * rule.append(decl1, decl2)
-   *
-   * root.append({ name: 'charset', params: '"UTF-8"' })  // at-rule
-   * root.append({ selector: 'a' })                       // rule
-   * rule.append({ prop: 'color', value: 'black' })       // declaration
-   * rule.append({ text: 'Comment' })                     // comment
-   *
-   * root.append('a {}')
-   * root.first.append('color: black; z-index: 1')
-   * ```
-   *
-   * @param nodes New nodes.
-   * @return This node for methods chain.
-   */
-  append(...nodes: Container.NewChild[]): this
-  assign(overrides: Container.ContainerProps | object): this
-  clone(overrides?: Partial<Container.ContainerProps>): this
-
-  cloneAfter(overrides?: Partial<Container.ContainerProps>): this
-
-  cloneBefore(overrides?: Partial<Container.ContainerProps>): this
-  /**
-   * Iterates through the container’s immediate children,
-   * calling `callback` for each child.
-   *
-   * Returning `false` in the callback will break iteration.
-   *
-   * This method only iterates through the container’s immediate children.
-   * If you need to recursively iterate through all the container’s descendant
-   * nodes, use `Container#walk`.
-   *
-   * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe
-   * if you are mutating the array of child nodes during iteration.
-   * PostCSS will adjust the current index to match the mutations.
-   *
-   * ```js
-   * const root = postcss.parse('a { color: black; z-index: 1 }')
-   * const rule = root.first
-   *
-   * for (const decl of rule.nodes) {
-   *   decl.cloneBefore({ prop: '-webkit-' + decl.prop })
-   *   // Cycle will be infinite, because cloneBefore moves the current node
-   *   // to the next index
-   * }
-   *
-   * rule.each(decl => {
-   *   decl.cloneBefore({ prop: '-webkit-' + decl.prop })
-   *   // Will be executed only for color and z-index
-   * })
-   * ```
-   *
-   * @param callback Iterator receives each node and index.
-   * @return Returns `false` if iteration was broke.
-   */
-  each(
-    callback: (node: Child, index: number) => false | void
-  ): false | undefined
-
-  /**
-   * Returns `true` if callback returns `true`
-   * for all of the container’s children.
-   *
-   * ```js
-   * const noPrefixes = rule.every(i => i.prop[0] !== '-')
-   * ```
-   *
-   * @param condition Iterator returns true or false.
-   * @return Is every child pass condition.
-   */
-  every(
-    condition: (node: Child, index: number, nodes: Child[]) => boolean
-  ): boolean
-  /**
-   * Returns a `child`’s index within the `Container#nodes` array.
-   *
-   * ```js
-   * rule.index( rule.nodes[2] ) //=> 2
-   * ```
-   *
-   * @param child Child of the current container.
-   * @return Child index.
-   */
-  index(child: Child | number): number
-
-  /**
-   * Insert new node after old node within the container.
-   *
-   * @param oldNode Child or child’s index.
-   * @param newNode New node.
-   * @return This node for methods chain.
-   */
-  insertAfter(oldNode: Child | number, newNode: Container.NewChild): this
-
-  /**
-   * Insert new node before old node within the container.
-   *
-   * ```js
-   * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop }))
-   * ```
-   *
-   * @param oldNode Child or child’s index.
-   * @param newNode New node.
-   * @return This node for methods chain.
-   */
-  insertBefore(oldNode: Child | number, newNode: Container.NewChild): this
-  /**
-   * Inserts new nodes to the start of the container.
-   *
-   * ```js
-   * const decl1 = new Declaration({ prop: 'color', value: 'black' })
-   * const decl2 = new Declaration({ prop: 'background-color', value: 'white' })
-   * rule.prepend(decl1, decl2)
-   *
-   * root.append({ name: 'charset', params: '"UTF-8"' })  // at-rule
-   * root.append({ selector: 'a' })                       // rule
-   * rule.append({ prop: 'color', value: 'black' })       // declaration
-   * rule.append({ text: 'Comment' })                     // comment
-   *
-   * root.append('a {}')
-   * root.first.append('color: black; z-index: 1')
-   * ```
-   *
-   * @param nodes New nodes.
-   * @return This node for methods chain.
-   */
-  prepend(...nodes: Container.NewChild[]): this
-
-  /**
-   * Add child to the end of the node.
-   *
-   * ```js
-   * rule.push(new Declaration({ prop: 'color', value: 'black' }))
-   * ```
-   *
-   * @param child New node.
-   * @return This node for methods chain.
-   */
-  push(child: Child): this
-
-  /**
-   * Removes all children from the container
-   * and cleans their parent properties.
-   *
-   * ```js
-   * rule.removeAll()
-   * rule.nodes.length //=> 0
-   * ```
-   *
-   * @return This node for methods chain.
-   */
-  removeAll(): this
-
-  /**
-   * Removes node from the container and cleans the parent properties
-   * from the node and its children.
-   *
-   * ```js
-   * rule.nodes.length  //=> 5
-   * rule.removeChild(decl)
-   * rule.nodes.length  //=> 4
-   * decl.parent        //=> undefined
-   * ```
-   *
-   * @param child Child or child’s index.
-   * @return This node for methods chain.
-   */
-  removeChild(child: Child | number): this
-
-  replaceValues(
-    pattern: RegExp | string,
-    replaced: { (substring: string, ...args: any[]): string } | string
-  ): this
-  /**
-   * Passes all declaration values within the container that match pattern
-   * through callback, replacing those values with the returned result
-   * of callback.
-   *
-   * This method is useful if you are using a custom unit or function
-   * and need to iterate through all values.
-   *
-   * ```js
-   * root.replaceValues(/\d+rem/, { fast: 'rem' }, string => {
-   *   return 15 * parseInt(string) + 'px'
-   * })
-   * ```
-   *
-   * @param pattern      Replace pattern.
-   * @param {object} options             Options to speed up the search.
-   * @param replaced   String to replace pattern or callback
-   *                                     that returns a new value. The callback
-   *                                     will receive the same arguments
-   *                                     as those passed to a function parameter
-   *                                     of `String#replace`.
-   * @return This node for methods chain.
-   */
-  replaceValues(
-    pattern: RegExp | string,
-    options: Container.ValueOptions,
-    replaced: { (substring: string, ...args: any[]): string } | string
-  ): this
-
-  /**
-   * Returns `true` if callback returns `true` for (at least) one
-   * of the container’s children.
-   *
-   * ```js
-   * const hasPrefix = rule.some(i => i.prop[0] === '-')
-   * ```
-   *
-   * @param condition Iterator returns true or false.
-   * @return Is some child pass condition.
-   */
-  some(
-    condition: (node: Child, index: number, nodes: Child[]) => boolean
-  ): boolean
-
-  /**
-   * Traverses the container’s descendant nodes, calling callback
-   * for each node.
-   *
-   * Like container.each(), this method is safe to use
-   * if you are mutating arrays during iteration.
-   *
-   * If you only need to iterate through the container’s immediate children,
-   * use `Container#each`.
-   *
-   * ```js
-   * root.walk(node => {
-   *   // Traverses all descendant nodes.
-   * })
-   * ```
-   *
-   * @param callback Iterator receives each node and index.
-   * @return  Returns `false` if iteration was broke.
-   */
-  walk(
-    callback: (node: ChildNode, index: number) => false | void
-  ): false | undefined
-
-  /**
-   * Traverses the container’s descendant nodes, calling callback
-   * for each at-rule node.
-   *
-   * If you pass a filter, iteration will only happen over at-rules
-   * that have matching names.
-   *
-   * Like `Container#each`, this method is safe
-   * to use if you are mutating arrays during iteration.
-   *
-   * ```js
-   * root.walkAtRules(rule => {
-   *   if (isOld(rule.name)) rule.remove()
-   * })
-   *
-   * let first = false
-   * root.walkAtRules('charset', rule => {
-   *   if (!first) {
-   *     first = true
-   *   } else {
-   *     rule.remove()
-   *   }
-   * })
-   * ```
-   *
-   * @param name     String or regular expression to filter at-rules by name.
-   * @param callback Iterator receives each node and index.
-   * @return Returns `false` if iteration was broke.
-   */
-  walkAtRules(
-    nameFilter: RegExp | string,
-    callback: (atRule: AtRule, index: number) => false | void
-  ): false | undefined
-  walkAtRules(
-    callback: (atRule: AtRule, index: number) => false | void
-  ): false | undefined
-
-  /**
-   * Traverses the container’s descendant nodes, calling callback
-   * for each comment node.
-   *
-   * Like `Container#each`, this method is safe
-   * to use if you are mutating arrays during iteration.
-   *
-   * ```js
-   * root.walkComments(comment => {
-   *   comment.remove()
-   * })
-   * ```
-   *
-   * @param callback Iterator receives each node and index.
-   * @return Returns `false` if iteration was broke.
-   */
-  walkComments(
-    callback: (comment: Comment, indexed: number) => false | void
-  ): false | undefined
-
-  /**
-   * Traverses the container’s descendant nodes, calling callback
-   * for each declaration node.
-   *
-   * If you pass a filter, iteration will only happen over declarations
-   * with matching properties.
-   *
-   * ```js
-   * root.walkDecls(decl => {
-   *   checkPropertySupport(decl.prop)
-   * })
-   *
-   * root.walkDecls('border-radius', decl => {
-   *   decl.remove()
-   * })
-   *
-   * root.walkDecls(/^background/, decl => {
-   *   decl.value = takeFirstColorFromGradient(decl.value)
-   * })
-   * ```
-   *
-   * Like `Container#each`, this method is safe
-   * to use if you are mutating arrays during iteration.
-   *
-   * @param prop     String or regular expression to filter declarations
-   *                 by property name.
-   * @param callback Iterator receives each node and index.
-   * @return Returns `false` if iteration was broke.
-   */
-  walkDecls(
-    propFilter: RegExp | string,
-    callback: (decl: Declaration, index: number) => false | void
-  ): false | undefined
-  walkDecls(
-    callback: (decl: Declaration, index: number) => false | void
-  ): false | undefined
-  /**
-   * Traverses the container’s descendant nodes, calling callback
-   * for each rule node.
-   *
-   * If you pass a filter, iteration will only happen over rules
-   * with matching selectors.
-   *
-   * Like `Container#each`, this method is safe
-   * to use if you are mutating arrays during iteration.
-   *
-   * ```js
-   * const selectors = []
-   * root.walkRules(rule => {
-   *   selectors.push(rule.selector)
-   * })
-   * console.log(`Your CSS uses ${ selectors.length } selectors`)
-   * ```
-   *
-   * @param selector String or regular expression to filter rules by selector.
-   * @param callback Iterator receives each node and index.
-   * @return Returns `false` if iteration was broke.
-   */
-  walkRules(
-    selectorFilter: RegExp | string,
-    callback: (rule: Rule, index: number) => false | void
-  ): false | undefined
-  walkRules(
-    callback: (rule: Rule, index: number) => false | void
-  ): false | undefined
-  /**
-   * An internal method that converts a {@link NewChild} into a list of actual
-   * child nodes that can then be added to this container.
-   *
-   * This ensures that the nodes' parent is set to this container, that they use
-   * the correct prototype chain, and that they're marked as dirty.
-   *
-   * @param mnodes The new node or nodes to add.
-   * @param sample A node from whose raws the new node's `before` raw should be
-   *               taken.
-   * @param type   This should be set to `'prepend'` if the new nodes will be
-   *               inserted at the beginning of the container.
-   * @hidden
-   */
-  protected normalize(
-    nodes: Container.NewChild,
-    sample: Node | undefined,
-    type?: 'prepend' | false
-  ): Child[]
-}
-
-declare class Container<
-  Child extends Node = ChildNode
-> extends Container_<Child> {}
-
-export = Container

package/dist/client/node_modules/postcss/lib/css-syntax-error.d.ts

@@ -1,247 +0,0 @@
-import { FilePosition } from './input.js'
-
-declare namespace CssSyntaxError {
-  /**
-   * A position that is part of a range.
-   */
-  export interface RangePosition {
-    /**
-     * The column number in the input.
-     */
-    column: number
-
-    /**
-     * The line number in the input.
-     */
-    line: number
-  }
-
-  export { CssSyntaxError_ as default }
-}
-
-/**
- * The CSS parser throws this error for broken CSS.
- *
- * Custom parsers can throw this error for broken custom syntax using
- * the `Node#error` method.
- *
- * PostCSS will use the input source map to detect the original error location.
- * If you wrote a Sass file, compiled it to CSS and then parsed it with PostCSS,
- * PostCSS will show the original position in the Sass file.
- *
- * If you need the position in the PostCSS input
- * (e.g., to debug the previous compiler), use `error.input.file`.
- *
- * ```js
- * // Raising error from plugin
- * throw node.error('Unknown variable', { plugin: 'postcss-vars' })
- * ```
- *
- * ```js
- * // Catching and checking syntax error
- * try {
- *   postcss.parse('a{')
- * } catch (error) {
- *   if (error.name === 'CssSyntaxError') {
- *     error //=> CssSyntaxError
- *   }
- * }
- * ```
- */
-declare class CssSyntaxError_ extends Error {
-  /**
-   * Source column of the error.
-   *
-   * ```js
-   * error.column       //=> 1
-   * error.input.column //=> 4
-   * ```
-   *
-   * PostCSS will use the input source map to detect the original location.
-   * If you need the position in the PostCSS input, use `error.input.column`.
-   */
-  column?: number
-
-  /**
-   * Source column of the error's end, exclusive. Provided if the error pertains
-   * to a range.
-   *
-   * ```js
-   * error.endColumn       //=> 1
-   * error.input.endColumn //=> 4
-   * ```
-   *
-   * PostCSS will use the input source map to detect the original location.
-   * If you need the position in the PostCSS input, use `error.input.endColumn`.
-   */
-  endColumn?: number
-
-  /**
-   * Source line of the error's end, exclusive. Provided if the error pertains
-   * to a range.
-   *
-   * ```js
-   * error.endLine       //=> 3
-   * error.input.endLine //=> 4
-   * ```
-   *
-   * PostCSS will use the input source map to detect the original location.
-   * If you need the position in the PostCSS input, use `error.input.endLine`.
-   */
-  endLine?: number
-
-  /**
-   * Absolute path to the broken file.
-   *
-   * ```js
-   * error.file       //=> 'a.sass'
-   * error.input.file //=> 'a.css'
-   * ```
-   *
-   * PostCSS will use the input source map to detect the original location.
-   * If you need the position in the PostCSS input, use `error.input.file`.
-   */
-  file?: string
-
-  /**
-   * Input object with PostCSS internal information
-   * about input file. If input has source map
-   * from previous tool, PostCSS will use origin
-   * (for example, Sass) source. You can use this
-   * object to get PostCSS input source.
-   *
-   * ```js
-   * error.input.file //=> 'a.css'
-   * error.file       //=> 'a.sass'
-   * ```
-   */
-  input?: FilePosition
-
-  /**
-   * Source line of the error.
-   *
-   * ```js
-   * error.line       //=> 2
-   * error.input.line //=> 4
-   * ```
-   *
-   * PostCSS will use the input source map to detect the original location.
-   * If you need the position in the PostCSS input, use `error.input.line`.
-   */
-  line?: number
-
-  /**
-   * Full error text in the GNU error format
-   * with plugin, file, line and column.
-   *
-   * ```js
-   * error.message //=> 'a.css:1:1: Unclosed block'
-   * ```
-   */
-  message: string
-
-  /**
-   * Always equal to `'CssSyntaxError'`. You should always check error type
-   * by `error.name === 'CssSyntaxError'`
-   * instead of `error instanceof CssSyntaxError`,
-   * because npm could have several PostCSS versions.
-   *
-   * ```js
-   * if (error.name === 'CssSyntaxError') {
-   *   error //=> CssSyntaxError
-   * }
-   * ```
-   */
-  name: 'CssSyntaxError'
-
-  /**
-   * Plugin name, if error came from plugin.
-   *
-   * ```js
-   * error.plugin //=> 'postcss-vars'
-   * ```
-   */
-  plugin?: string
-
-  /**
-   * Error message.
-   *
-   * ```js
-   * error.message //=> 'Unclosed block'
-   * ```
-   */
-  reason: string
-
-  /**
-   * Source code of the broken file.
-   *
-   * ```js
-   * error.source       //=> 'a { b {} }'
-   * error.input.source //=> 'a b { }'
-   * ```
-   */
-  source?: string
-
-  stack: string
-
-  /**
-   * Instantiates a CSS syntax error. Can be instantiated for a single position
-   * or for a range.
-   * @param message        Error message.
-   * @param lineOrStartPos If for a single position, the line number, or if for
-   *                       a range, the inclusive start position of the error.
-   * @param columnOrEndPos If for a single position, the column number, or if for
-   *                       a range, the exclusive end position of the error.
-   * @param source         Source code of the broken file.
-   * @param file           Absolute path to the broken file.
-   * @param plugin         PostCSS plugin name, if error came from plugin.
-   */
-  constructor(
-    message: string,
-    lineOrStartPos?: CssSyntaxError.RangePosition | number,
-    columnOrEndPos?: CssSyntaxError.RangePosition | number,
-    source?: string,
-    file?: string,
-    plugin?: string
-  )
-
-  /**
-   * Returns a few lines of CSS source that caused the error.
-   *
-   * If the CSS has an input source map without `sourceContent`,
-   * this method will return an empty string.
-   *
-   * ```js
-   * error.showSourceCode() //=> "  4 | }
-   *                        //      5 | a {
-   *                        //    > 6 |   bad
-   *                        //        |   ^
-   *                        //      7 | }
-   *                        //      8 | b {"
-   * ```
-   *
-   * @param color Whether arrow will be colored red by terminal
-   *              color codes. By default, PostCSS will detect
-   *              color support by `process.stdout.isTTY`
-   *              and `process.env.NODE_DISABLE_COLORS`.
-   * @return Few lines of CSS source that caused the error.
-   */
-  showSourceCode(color?: boolean): string
-
-  /**
-   * Returns error position, message and source code of the broken part.
-   *
-   * ```js
-   * error.toString() //=> "CssSyntaxError: app.css:1:1: Unclosed block
-   *                  //    > 1 | a {
-   *                  //        | ^"
-   * ```
-   *
-   * @return Error position, message and source code.
-   */
-  toString(): string
-}
-
-declare class CssSyntaxError extends CssSyntaxError_ {}
-
-export = CssSyntaxError