• Version 2.3.8
  • Published
  • 5.04 kB
  • No dependencies
  • MIT license


npm i @types/sizzle
yarn add @types/sizzle
pnpm add @types/sizzle


TypeScript definitions for sizzle



variable Sizzle

const Sizzle: SizzleStatic;


    interface Selectors

    interface Selectors {}

      property attrHandle

      attrHandle: Selectors.AttrHandleFunctions;

        property cacheLength

        cacheLength: number;

          property filter

          filter: Selectors.FilterFunctions;

            property find

            find: Selectors.FindFunctions;

              property match

              match: Selectors.Matches;

                property preFilter

                preFilter: Selectors.PreFilterFunctions;

                  property pseudos

                  pseudos: Selectors.PseudoFunctions;

                    property setFilters

                    setFilters: Selectors.SetFilterFunctions;

                      method createPseudo

                      createPseudo: (fn: Selectors.CreatePseudoFunction) => Selectors.PseudoFunction;


                        namespace Selectors

                        namespace Selectors {}

                          interface AttrHandleFunction

                          interface AttrHandleFunction {}

                            call signature

                            (elem: any, casePreservedName: string, isXML: boolean): string;

                              interface AttrHandleFunctions

                              interface AttrHandleFunctions {}

                                index signature

                                [name: string]: AttrHandleFunction;

                                  interface CreatePseudoFunction

                                  interface CreatePseudoFunction {}

                                    call signature

                                    (...args: any[]): PseudoFunction;

                                      interface FilterFunction

                                      interface FilterFunction {}

                                        call signature

                                        (element: string, ...matches: string[]): boolean;

                                          interface FilterFunctions

                                          interface FilterFunctions {}

                                            index signature

                                            [name: string]: FilterFunction;

                                              interface FindFunction

                                              interface FindFunction {}

                                                call signature

                                                (match: RegExpMatchArray, context: Element | Document, isXML: boolean):
                                                | Element[]
                                                | void;

                                                  interface FindFunctions

                                                  interface FindFunctions {}

                                                    index signature

                                                    [name: string]: FindFunction;

                                                      interface Matches

                                                      interface Matches {}

                                                        index signature

                                                        [name: string]: RegExp;

                                                          interface PreFilterFunction

                                                          interface PreFilterFunction {}

                                                            call signature

                                                            (match: RegExpMatchArray): string[];

                                                              interface PreFilterFunctions

                                                              interface PreFilterFunctions {}

                                                                index signature

                                                                [name: string]: PreFilterFunction;

                                                                  interface PseudoFunction

                                                                  interface PseudoFunction {}

                                                                    call signature

                                                                    (elem: Element): boolean;

                                                                      interface PseudoFunctions

                                                                      interface PseudoFunctions {}

                                                                        index signature

                                                                        [name: string]: PseudoFunction;

                                                                          interface SetFilterFunction

                                                                          interface SetFilterFunction {}

                                                                            call signature

                                                                            (elements: Element[], argument: number, not: boolean): Element[];

                                                                              interface SetFilterFunctions

                                                                              interface SetFilterFunctions {}

                                                                                index signature

                                                                                [name: string]: SetFilterFunction;

                                                                                  Package Files (1)

                                                                                  Dependencies (0)

                                                                                  No dependencies.

                                                                                  Dev Dependencies (0)

                                                                                  No dev dependencies.

                                                                                  Peer Dependencies (0)

                                                                                  No peer dependencies.


                                                                                  To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                  You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/sizzle.

                                                                                  • Markdown
                                                                                  • HTML
                                                                                    <a href="https://www.jsdocs.io/package/@types/sizzle"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>