FM / lib

/opt/canhelp/node_modules/postcss/lib

Name	Size	Mode	Actions
at-rule.d.ts	3360	0644	edit dl rm
at-rule.js	471	0644	edit dl rm
comment.d.ts	1684	0644	edit dl rm
comment.js	203	0644	edit dl rm
container.d.ts	14047	0644	edit dl rm
container.js	10647	0644	edit dl rm
css-syntax-error.d.ts	6451	0644	edit dl rm
css-syntax-error.js	3402	0644	edit dl rm
declaration.d.ts	3837	0644	edit dl rm
declaration.js	495	0644	edit dl rm
document.d.ts	1888	0644	edit dl rm
document.js	654	0644	edit dl rm
fromJSON.d.ts	162	0644	edit dl rm
fromJSON.js	1506	0644	edit dl rm
input.d.ts	5130	0644	edit dl rm
input.js	6752	0644	edit dl rm
lazy-result.d.ts	4941	0644	edit dl rm
lazy-result.js	13562	0644	edit dl rm
list.d.ts	1426	0644	edit dl rm
list.js	1227	0644	edit dl rm
map-generator.js	10031	0644	edit dl rm
no-work-result.d.ts	1507	0644	edit dl rm
no-work-result.js	2621	0644	edit dl rm
node.d.ts	14698	0644	edit dl rm
node.js	10719	0644	edit dl rm
parse.d.ts	135	0644	edit dl rm
parse.js	1147	0644	edit dl rm
parser.js	14846	0644	edit dl rm
postcss.d.mts	1049	0644	edit dl rm
postcss.d.ts	11461	0644	edit dl rm
postcss.js	2898	0644	edit dl rm
postcss.mjs	980	0644	edit dl rm
previous-map.d.ts	1761	0644	edit dl rm
previous-map.js	3984	0644	edit dl rm
processor.d.ts	3349	0644	edit dl rm
processor.js	1738	0644	edit dl rm
result.d.ts	4350	0644	edit dl rm
result.js	738	0644	edit dl rm
root.d.ts	2257	0644	edit dl rm
root.js	1239	0644	edit dl rm
rule.d.ts	2901	0644	edit dl rm
rule.js	569	0644	edit dl rm
stringifier.d.ts	1364	0644	edit dl rm
stringifier.js	8220	0644	edit dl rm
stringify.d.ts	165	0644	edit dl rm
stringify.js	213	0644	edit dl rm
symbols.js	91	0644	edit dl rm
terminal-highlight.js	1399	0644	edit dl rm
tokenize.js	6538	0644	edit dl rm
warn-once.js	256	0644	edit dl rm
warning.d.ts	2928	0644	edit dl rm
warning.js	739	0644	edit dl rm

Edit: /opt/canhelp/node_modules/postcss/lib/postcss.d.ts (11461B)

import { RawSourceMap, SourceMapGenerator } from 'source-map-js'

import AtRule, { AtRuleProps } from './at-rule.js'
import Comment, { CommentProps } from './comment.js'
import Container, { ContainerProps, NewChild } from './container.js'
import CssSyntaxError from './css-syntax-error.js'
import Declaration, { DeclarationProps } from './declaration.js'
import Document, { DocumentProps } from './document.js'
import Input, { FilePosition } from './input.js'
import LazyResult from './lazy-result.js'
import list from './list.js'
import Node, {
  AnyNode,
  ChildNode,
  ChildProps,
  NodeErrorOptions,
  NodeProps,
  Position,
  Source
} from './node.js'
import Processor from './processor.js'
import Result, { Message } from './result.js'
import Root, { RootProps } from './root.js'
import Rule, { RuleProps } from './rule.js'
import Warning, { WarningOptions } from './warning.js'

type DocumentProcessor = (
  document: Document,
  helper: postcss.Helpers
) => Promise<void> | void
type RootProcessor = (
  root: Root,
  helper: postcss.Helpers
) => Promise<void> | void
type DeclarationProcessor = (
  decl: Declaration,
  helper: postcss.Helpers
) => Promise<void> | void
type RuleProcessor = (
  rule: Rule,
  helper: postcss.Helpers
) => Promise<void> | void
type AtRuleProcessor = (
  atRule: AtRule,
  helper: postcss.Helpers
) => Promise<void> | void
type CommentProcessor = (
  comment: Comment,
  helper: postcss.Helpers
) => Promise<void> | void

interface Processors {
  /**
   * Will be called on all`AtRule` nodes.
   *
   * Will be called again on node or children changes.
   */
  AtRule?: { [name: string]: AtRuleProcessor } | AtRuleProcessor

/**
   * Will be called on all `AtRule` nodes, when all children will be processed.
   *
   * Will be called again on node or children changes.
   */
  AtRuleExit?: { [name: string]: AtRuleProcessor } | 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 on all `Declaration` nodes after listeners
   * for `Declaration` event.
   *
   * Will be called again on node or children changes.
   */
  Declaration?: { [prop: string]: DeclarationProcessor } | DeclarationProcessor

/**
   * Will be called on all `Declaration` nodes.
   *
   * Will be called again on node or children changes.
   */
  DeclarationExit?:
    | { [prop: string]: DeclarationProcessor }
    | DeclarationProcessor

/**
   * 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 `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
}

declare namespace postcss {
  export {
    AnyNode,
    AtRule,
    AtRuleProps,
    ChildNode,
    ChildProps,
    Comment,
    CommentProps,
    Container,
    ContainerProps,
    CssSyntaxError,
    Declaration,
    DeclarationProps,
    Document,
    DocumentProps,
    FilePosition,
    Input,
    LazyResult,
    list,
    Message,
    NewChild,
    Node,
    NodeErrorOptions,
    NodeProps,
    Position,
    Processor,
    Result,
    Root,
    RootProps,
    Rule,
    RuleProps,
    Source,
    Warning,
    WarningOptions
  }

export type SourceMap = {
    toJSON(): RawSourceMap
  } & SourceMapGenerator

export type Helpers = { postcss: Postcss; result: Result } & Postcss

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 =
    | {
        postcss: Processor | TransformCallback
      }
    | OldPlugin<any>
    | Plugin
    | PluginCreator<any>
    | Processor
    | TransformCallback

export interface Parser<RootNode = Document | Root> {
    (
      css: { toString(): string } | string,
      opts?: Pick<ProcessOptions, 'document' | 'from' | 'map'>
    ): RootNode
  }

export interface Builder {
    (part: string, node?: AnyNode, type?: 'end' | 'start'): void
  }

export interface Stringifier {
    (node: AnyNode, builder: Builder): void
  }

export interface JSONHydrator {
    (data: object): Node
    (data: object[]): Node[]
  }

export interface Syntax<RootNode = Document | Root> {
    /**
     * Function to generate AST by string.
     */
    parse?: Parser<RootNode>

/**
     * Class to generate string by AST.
     */
    stringify?: Stringifier
  }

export interface SourceMapOptions {
    /**
     * Use absolute path in generated source map.
     */
    absolute?: 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?: ((file: string, root: Root) => string) | boolean | string

/**
     * Override `from` in map’s sources.
     */
    from?: string

/**
     * 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?: ((file: string) => string) | boolean | object | 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
  }

export interface ProcessOptions<RootNode = Document | Root> {
    /**
     * Input file if it is not simple CSS file, but HTML with <style> or JS with CSS-in-JS blocks.
     */
    document?: string

/**
     * 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 | undefined

/**
     * Source map options
     */
    map?: boolean | SourceMapOptions

/**
     * Function to generate AST by string.
     */
    parser?: Parser<RootNode> | Syntax<RootNode>

/**
     * Class to generate string by AST.
     */
    stringifier?: Stringifier | Syntax<RootNode>

/**
     * Object with parse and stringify.
     */
    syntax?: Syntax<RootNode>

/**
     * The path where you'll put the output CSS file. You should always set `to`
     * to generate correct source maps.
     */
    to?: string
  }

export type Postcss = typeof postcss

/**
   * Default function to convert a node tree into a CSS string.
   */
  export let 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
   * ```
   */
  export let parse: Parser<Root>

/**
   * 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)
   * ```
   */
  export let fromJSON: JSONHydrator

/**
   * Creates a new `Comment` node.
   *
   * @param defaults Properties for the new node.
   * @return New comment node
   */
  export function comment(defaults?: CommentProps): Comment

/**
   * Creates a new `AtRule` node.
   *
   * @param defaults Properties for the new node.
   * @return New at-rule node.
   */
  export function atRule(defaults?: AtRuleProps): AtRule

/**
   * Creates a new `Declaration` node.
   *
   * @param defaults Properties for the new node.
   * @return New declaration node.
   */
  export function decl(defaults?: DeclarationProps): Declaration

/**
   * Creates a new `Rule` node.
   *
   * @param default Properties for the new node.
   * @return New rule node.
   */
  export function rule(defaults?: RuleProps): Rule

/**
   * Creates a new `Root` node.
   *
   * @param defaults Properties for the new node.
   * @return New root node.
   */
  export function root(defaults?: RootProps): Root

/**
   * Creates a new `Document` node.
   *
   * @param defaults Properties for the new node.
   * @return New document node.
   */
  export function document(defaults?: DocumentProps): Document

export { postcss as default }
}

/**
 * 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.
 */
declare function postcss(
  plugins?: readonly postcss.AcceptedPlugin[]
): Processor
declare function postcss(...plugins: postcss.AcceptedPlugin[]): Processor

export = postcss

cmd: