postcss-selector-parser

constructor(input: ParserOptions);

current: Selector;

input: ParserOptions;

lossy: boolean;

position: number;

root: Root;

selectors: globalThis.String;

error: (message: string, options?: ErrorOptions) => void;

res: Root;

readonly result: string;

ast: (selectors: Selectors, options?: Partial<Options>) => Promise<Root>;

astSync: (selectors: SyncSelectorsType, options?: Partial<Options>) => Root;

process: (selectors: Selectors, options?: Partial<Options>) => Promise<string>;

processSync: (
    selectors: SyncSelectorsType,
    options?: Partial<Options>
) => string;

transform: (
    selectors: Selectors,
    options?: Partial<Options>
) => Promise<TransformType>;

transformSync: (
    selectors: SyncSelectorsType,
    options?: Partial<Options>
) => TransformType;

attribute: string;

insensitive?: boolean;

readonly insensitiveFlag: 'i' | '';

operator?: AttributeOperator;

readonly qualifiedAttribute: string;

quoted?: boolean;

quoteMark: QuoteMark;

raws: {
    /** @deprecated The attribute value is unquoted, use that instead.. */
    unquoted?: string;
    attribute?: string;
    operator?: string;
    /** The value of the attribute with quotes and escapes. */
    value?: string;
    insensitive?: string;
    spaces?: {
        attribute?: Partial<Spaces>;
        operator?: Partial<Spaces>;
        value?: Partial<Spaces>;
        insensitive?: Partial<Spaces>;
    };
};

spaces: {
    before: string;
    after: string;
    attribute?: Partial<Spaces>;
    operator?: Partial<Spaces>;
    value?: Partial<Spaces>;
    insensitive?: Partial<Spaces>;
};

type: 'attribute';

getQuotedValue: (options?: SmartQuoteMarkOptions) => string;

offsetOf: (
    part:
        | 'ns'
        | 'namespace'
        | 'attribute'
        | 'attributeNS'
        | 'operator'
        | 'value'
        | 'insensitive'
) => number;

preferredQuoteMark: (options: PreferredQuoteMarkOptions) => QuoteMark;

setValue: (value: string, options?: SmartQuoteMarkOptions) => void;

smartQuoteMark: (options: PreferredQuoteMarkOptions) => QuoteMark;

attribute: string;

insensitive?: boolean;

operator?: AttributeOperator;

quoted?: boolean;

quoteMark?: QuoteMark;

raws: {
    unquoted?: string;
    attribute?: string;
    operator?: string;
    value?: string;
    insensitive?: string;
    spaces?: {
        attribute?: Partial<Spaces>;
        operator?: Partial<Spaces>;
        value?: Partial<Spaces>;
        insensitive?: Partial<Spaces>;
    };
};

spaces?: {
    before?: string;
    after?: string;
    attribute?: Partial<SpaceAround>;
    operator?: Partial<SpaceAround>;
    value?: Partial<SpaceAround>;
    insensitive?: Partial<SpaceAround>;
};

parent: ParentType;

rawSpaceAfter: string;

rawSpaceBefore: string;

source?: NodeSource;

sourceIndex: number;

spaces: Spaces;

type: keyof NodeTypes;

value: Value;

appendToPropertyAndEscape: (
    name: string,
    value: any,
    valueEscaped: string
) => void;

clone: (opts?: { [override: string]: any }) => this;

isAtPosition: (line: number, column: number) => boolean | undefined;

next: () => Node | undefined;

prev: () => Node | undefined;

remove: () => Node;

replaceWith: (...nodes: Node[]) => Node;

setPropertyAndEscape: (name: string, value: any, valueEscaped: string) => void;

setPropertyWithoutEscape: (name: string, value: any) => void;

toString: () => string;

type: 'class';

raws?: CombinatorRaws;

type: 'combinator';

spaces?: {
    before?: string;
    after?: string;
};

value?: string;

type: 'comment';

readonly first: Child;

readonly last: Child;

readonly length: number;

nodes: Array<Child>;

append: (selector: Child) => this;

at: (index: number) => Child;

atPosition: (line: number, column: number) => Child;

each: (
    callback: (node: Child, index: number) => boolean | void
) => boolean | undefined;

empty: () => this;

every: (callback: (node: Child) => boolean) => boolean;

filter: (callback: (node: Child) => boolean) => Child[];

index: (child: Child) => number;

insertAfter: (oldNode: Child, newNode: Child) => this;

insertBefore: (oldNode: Child, newNode: Child) => this;

map: <T>(callback: (node: Child) => T) => T[];

prepend: (selector: Child) => this;

reduce: {
    (
        callback: (
            previousValue: Child,
            currentValue: Child,
            currentIndex: number,
            array: readonly Child[]
        ) => Child
    ): Child;
    (
        callback: (
            previousValue: Child,
            currentValue: Child,
            currentIndex: number,
            array: readonly Child[]
        ) => Child,
        initialValue: Child
    ): Child;
    <T>(
        callback: (
            previousValue: T,
            currentValue: Child,
            currentIndex: number,
            array: readonly Child[]
        ) => T,
        initialValue: T
    ): T;
};

removeAll: () => this;

removeChild: (child: Child) => this;

some: (callback: (node: Child) => boolean) => boolean;

sort: (callback: (nodeA: Child, nodeB: Child) => number) => Child[];

split: (callback: (node: Child) => boolean) => [Child[], Child[]];

toString: () => string;

walk: (
    callback: (node: Node, index: number) => boolean | void
) => boolean | undefined;

walkAttributes: (
    callback: (node: Attribute) => boolean | void
) => boolean | undefined;

walkClasses: (
    callback: (node: ClassName) => boolean | void
) => boolean | undefined;

walkCombinators: (
    callback: (node: Combinator) => boolean | void
) => boolean | undefined;

walkComments: (
    callback: (node: Comment) => boolean | void
) => boolean | undefined;

walkIds: (callback: (node: Identifier) => boolean | void) => boolean | undefined;

walkNesting: (
    callback: (node: Nesting) => boolean | void
) => boolean | undefined;

walkPseudos: (callback: (node: Pseudo) => boolean | void) => boolean | undefined;

walkTags: (callback: (node: Tag) => boolean | void) => boolean | undefined;

nodes?: Array<Node>;

type: 'id';

namespace: string | true;

readonly namespaceString: string;

ns: string | true;

qualifiedName: (value: string) => string;

namespace?: string | true;

type: 'nesting';

source?: NodeSource;

sourceIndex?: number;

spaces?: Partial<Spaces>;

value: Value;

end?: {
    line: number;
    column: number;
};

start?: {
    line: number;
    column: number;
};

attribute: Attribute;

class: ClassName;

combinator: Combinator;

comment: Comment;

id: Identifier;

nesting: Nesting;

pseudo: Pseudo;

root: Root;

selector: Selector;

string: String;

tag: Tag;

universal: Universal;

lossless: boolean;

updateSelector: boolean;

css: string;

error: (message: string, options: ErrorOptions) => Error;

options: Options;

preferCurrentQuoteMark?: boolean;

quoteMark?: QuoteMark;

type: 'pseudo';

type: 'root';

error: (message: string, options?: ErrorOptions) => Error;

nodeAt: (line: number, column: number) => Node;

smart?: boolean;

after: string;

before: string;

[spaceType: string]: string | Partial<SpaceAround> | undefined;

type: 'string';

type: 'tag';

type: 'universal';