FM / lib

/var/www/cobraambalaj/node_modules/postcss/lib/

/var/www/cobraambalaj/node_modules/postcss/lib

Name	Size	Mode	Actions
at-rule.d.ts	2205	0644	edit dl rm
at-rule.js	474	0644	edit dl rm
comment.d.ts	1095	0644	edit dl rm
comment.js	204	0644	edit dl rm
container.d.ts	12726	0644	edit dl rm
container.js	10183	0644	edit dl rm
css-syntax-error.d.ts	4830	0644	edit dl rm
css-syntax-error.js	2299	0644	edit dl rm
declaration.d.ts	2650	0644	edit dl rm
declaration.js	497	0644	edit dl rm
fromJSON.d.ts	107	0644	edit dl rm
fromJSON.js	1507	0644	edit dl rm
input.d.ts	2816	0644	edit dl rm
input.js	4549	0644	edit dl rm
lazy-result.d.ts	4833	0644	edit dl rm
lazy-result.js	12279	0644	edit dl rm
list.d.ts	850	0644	edit dl rm
list.js	1170	0644	edit dl rm
map-generator.js	7306	0644	edit dl rm
node.d.ts	11348	0644	edit dl rm
node.js	6909	0644	edit dl rm
parse.d.ts	89	0644	edit dl rm
parse.js	1148	0644	edit dl rm
parser.js	13323	0644	edit dl rm
postcss.d.ts	10569	0644	edit dl rm
postcss.js	2513	0644	edit dl rm
postcss.mjs	855	0644	edit dl rm
previous-map.d.ts	1618	0644	edit dl rm
previous-map.js	3960	0644	edit dl rm
processor.d.ts	2944	0644	edit dl rm
processor.js	1965	0644	edit dl rm
result.d.ts	4086	0644	edit dl rm
result.js	750	0644	edit dl rm
root.d.ts	1195	0644	edit dl rm
root.js	1213	0644	edit dl rm
rule.d.ts	2078	0644	edit dl rm
rule.js	572	0644	edit dl rm
stringifier.js	7996	0644	edit dl rm
stringify.d.ts	107	0644	edit dl rm
stringify.js	214	0644	edit dl rm
symbols.js	57	0644	edit dl rm
terminal-highlight.js	1360	0644	edit dl rm
tokenize.js	6542	0644	edit dl rm
warn-once.js	225	0644	edit dl rm
warning.d.ts	1935	0644	edit dl rm
warning.js	650	0644	edit dl rm

Edit: /var/www/cobraambalaj/node_modules/postcss/lib/postcss.d.ts (10569B)

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

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

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

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

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

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 `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 {
  (
    css: string | { toString(): string },
    opts?: Pick<ProcessOptions, 'map' | 'from'>
  ): Root
}

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

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

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

cmd: