Class Cheerio<T>`Abstract`

The cheerio class is the central class of the library. It wraps a set of elements and provides an API for traversing, modifying, and interacting with the set.

Loading a document will return the Cheerio class bound to the root element of the document. The class will be instantiated when querying the document (when calling $('selector')).

Example: This is the HTML markup we will be using in all of the API examples:

<ul id="fruits">
  <li class="apple">Apple</li>
  <li class="orange">Orange</li>
  <li class="pear">Pear</li>
</ul>

Type Parameters

Hierarchy (View Summary)

MethodsType
Iterable<T>
- Cheerio

Implements

ArrayLike<T>

Indexable

[index: number]: T

Index

Attributes

addClass

addClass<T extends AnyNode, R extends ArrayLike<T>>(
this: R,
value?: string | ((this: Element, i: number, className: string) => string),
): R
Adds class(es) to all of the matched elements. Also accepts a function.
Type Parameters
- T extends AnyNode
- R extends ArrayLike<T>
Parameters
- this: R
- Optionalvalue: string | ((this: Element, i: number, className: string) => string)
  Name of new class.
Returns R
The instance itself.
Example
```
$('.pear').addClass('fruit').prop('outerHTML');
//=> <li class="pear fruit">Pear</li>

$('.apple').addClass('fruit red').prop('outerHTML');
//=> <li class="apple fruit red">Apple</li>
```
See
https://api.jquery.com/addClass/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:340

attr

attr<T extends AnyNode>(this: Cheerio<T>, name: string): string
Method for getting attributes. Gets the attribute value for only the first element in the matched set.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- name: string
  Name of the attribute.
Returns string
The attribute's value.
Example
```
$('ul').attr('id');
//=> fruits
```
See
https://api.jquery.com/attr/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:24
attr<T extends AnyNode>(this: Cheerio<T>): Record<string, string>
Method for getting all attributes and their values of the first element in the matched set.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
Returns Record<string, string>
The attribute's values.
Example
```
$('ul').attr();
//=> { id: 'fruits' }
```
See
https://api.jquery.com/attr/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:40
attr<T extends AnyNode>(
    this: Cheerio<T>,
    name: string,
    value?: string | ((this: Element, i: number, attrib: string) => string),
): Cheerio<T>
Method for setting attributes. Sets the attribute value for all elements in the matched set. If you set an attribute's value to null, you remove that attribute. You may also pass a map and function.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- name: string
  Name of the attribute.
- Optionalvalue: string | ((this: Element, i: number, attrib: string) => string)
  The new value of the attribute.
Returns Cheerio<T>
The instance itself.
Example
```
$('.apple').attr('id', 'favorite').prop('outerHTML');
//=> <li class="apple" id="favorite">Apple</li>
```
See
https://api.jquery.com/attr/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:59
attr<T extends AnyNode>(
this: Cheerio<T>,
values: Record<string, string | null>,
): Cheerio<T>
Method for setting multiple attributes at once. Sets the attribute value for all elements in the matched set. If you set an attribute's value to null, you remove that attribute.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- values: Record<string, string | null>
  Map of attribute names and values.
Returns Cheerio<T>
The instance itself.
Example
```
$('.apple').attr({ id: 'favorite' }).prop('outerHTML');
//=> <li class="apple" id="favorite">Apple</li>
```
See
https://api.jquery.com/attr/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:77

data

data<T extends AnyNode>(this: Cheerio<T>, name: string): unknown
Method for getting data attributes, for only the first element in the matched set.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- name: string
  Name of the data attribute.
Returns unknown
The data attribute's value, or undefined if the attribute does not exist.
Example
```
$('<div data-apple-color="red"></div>').data('apple-color');
//=> 'red'
```
See
https://api.jquery.com/data/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:191
data<T extends AnyNode>(this: Cheerio<T>): Record<string, unknown>
Method for getting all of an element's data attributes, for only the first element in the matched set.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
Returns Record<string, unknown>
A map with all of the data attributes.
Example
```
$('<div data-apple-color="red"></div>').data();
//=> { appleColor: 'red' }
```
See
https://api.jquery.com/data/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:207
data<T extends AnyNode>(
    this: Cheerio<T>,
    name: string,
    value: unknown,
): Cheerio<T>
Method for setting data attributes, for only the first element in the matched set.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- name: string
  Name of the data attribute.
- value: unknown
  The new value.
Returns Cheerio<T>
The instance itself.
Example
```
const apple = $('.apple').data('kind', 'mac');

apple.data('kind');
//=> 'mac'
```
See
https://api.jquery.com/data/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:227
data<T extends AnyNode>(
this: Cheerio<T>,
values: Record<string, unknown>,
): Cheerio<T>
Method for setting multiple data attributes at once, for only the first element in the matched set.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- values: Record<string, unknown>
  Map of names to values.
Returns Cheerio<T>
The instance itself.
Example
```
const apple = $('.apple').data({ kind: 'mac' });

apple.data('kind');
//=> 'mac'
```
See
https://api.jquery.com/data/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:246

hasClass

hasClass<T extends AnyNode>(this: Cheerio<T>, className: string): boolean
Check to see if any of the matched elements have the given className.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- className: string
  Name of the class.
Returns boolean
Indicates if an element has the given className.
Example
```
$('.pear').hasClass('pear');
//=> true

$('apple').hasClass('fruit');
//=> false

$('li').hasClass('pear');
//=> true
```
See
https://api.jquery.com/hasClass/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:321

prop

prop<T extends AnyNode>(this: Cheerio<T>, name: "tagName" | "nodeName"): string
Method for getting and setting properties. Gets the property value for only the first element in the matched set.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- name: "tagName" | "nodeName"
  Name of the property.
Returns string
If value is specified the instance itself, otherwise the prop's value.
Example
```
$('input[type="checkbox"]').prop('checked');
//=> false

$('input[type="checkbox"]').prop('checked', true).val();
//=> ok
```
See
https://api.jquery.com/prop/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:103
prop<T extends AnyNode>(
this: Cheerio<T>,
name: "innerHTML" | "outerHTML" | "innerText" | "textContent",
): string
Method for getting and setting properties. Gets the property value for only the first element in the matched set.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- name: "innerHTML" | "outerHTML" | "innerText" | "textContent"
  Name of the property.
Returns string
If value is specified the instance itself, otherwise the prop's value.
Example
```
$('input[type="checkbox"]').prop('checked');
//=> false

$('input[type="checkbox"]').prop('checked', true).val();
//=> ok
```
See
https://api.jquery.com/prop/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:104
prop<T extends AnyNode>(this: Cheerio<T>, name: "style"): StyleProp
Get a parsed CSS style object.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- name: "style"
  Name of the property.
Returns StyleProp
The style object, or undefined if the element has no style attribute.
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:112
prop<T extends AnyNode>(this: Cheerio<T>, name: "href" | "src"): string
Resolve href or src of supported elements. Requires the baseURI option to be set, and a global URL object to be part of the environment.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- name: "href" | "src"
  Name of the property.
Returns string
The resolved URL, or undefined if the element is not supported.
Example: With `baseURI` set to `'https://example.com'`:
```
$('<img src="image.png">').prop('src');
//=> 'https://example.com/image.png'
```
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:127
prop<T extends AnyNode, K extends keyof Element>(
this: Cheerio<T>,
name: K,
): Element[K]
Get a property of an element.
Type Parameters
- T extends AnyNode
- K extends keyof Element
Parameters
- this: Cheerio<T>
- name: K
  Name of the property.
Returns Element[K]
The property's value.
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:134
prop<T extends AnyNode, K extends keyof Element>(
    this: Cheerio<T>,
    name: K,
    value:
        | Element[K]
        | (
            (
                this: Element,
                i: number,
                prop: K,
            ) =>
                | string
                | number
                | Document
                | Element
                | CDATA
                | Text
                | Comment
                | ProcessingInstruction
                | Record<string, string>
                | ChildNode[]
                | { [name: string]: string }
                | TagSourceCodeLocation
                | Attribute[]
                | (<T extends Node>(this: T, recursive?: boolean) => T)
        ),
): Cheerio<T>
Set a property of an element.
Type Parameters
- T extends AnyNode
- K extends keyof Element
Parameters
- this: Cheerio<T>
- name: K
  Name of the property.
- value:
      | Element[K]
      | (
          (
              this: Element,
              i: number,
              prop: K,
          ) =>
              | string
              | number
              | Document
              | Element
              | CDATA
              | Text
              | Comment
              | ProcessingInstruction
              | Record<string, string>
              | ChildNode[]
              | { [name: string]: string }
              | TagSourceCodeLocation
              | Attribute[]
              | (<T extends Node>(this: T, recursive?: boolean) => T)
      )
  Value to set the property to.
Returns Cheerio<T>
The instance itself.
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:142
prop<T extends AnyNode>(
this: Cheerio<T>,
map: Record<string, string | Element[keyof Element] | boolean>,
): Cheerio<T>
Set multiple properties of an element.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- map: Record<string, string | Element[keyof Element] | boolean>
  Object of properties to set.
Returns Cheerio<T>
The instance itself.
Example
```
$('input[type="checkbox"]').prop({
  checked: true,
  disabled: false,
});
```
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:158
prop<T extends AnyNode>(
    this: Cheerio<T>,
    name: string,
    value:
        | string
        | boolean
        | ((this: Element, i: number, prop: string) => string | boolean),
): Cheerio<T>
Set a property of an element.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- name: string
  Name of the property.
- value:
      | string
      | boolean
      | ((this: Element, i: number, prop: string) => string | boolean)
  Value to set the property to.
Returns Cheerio<T>
The instance itself.
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:166
prop<T extends AnyNode>(this: Cheerio<T>, name: string): string
Get a property of an element.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- name: string
  The property's name.
Returns string
The property's value.
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:173

removeAttr

removeAttr<T extends AnyNode>(this: Cheerio<T>, name: string): Cheerio<T>
Method for removing attributes by name.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- name: string
  Name of the attribute.
Returns Cheerio<T>
The instance itself.
Example
```
$('.pear').removeAttr('class').prop('outerHTML');
//=> <li>Pear</li>

$('.apple').attr('id', 'favorite');
$('.apple').removeAttr('id class').prop('outerHTML');
//=> <li>Apple</li>
```
See
https://api.jquery.com/removeAttr/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:299

removeClass

removeClass<T extends AnyNode, R extends ArrayLike<T>>(
this: R,
name?: string | ((this: Element, i: number, className: string) => string),
): R
Removes one or more space-separated classes from the selected elements. If no className is defined, all classes will be removed. Also accepts a function.
Type Parameters
- T extends AnyNode
- R extends ArrayLike<T>
Parameters
- this: R
- Optionalname: string | ((this: Element, i: number, className: string) => string)
  Name of the class. If not specified, removes all elements.
Returns R
The instance itself.
Example
```
$('.pear').removeClass('pear').prop('outerHTML');
//=> <li class="">Pear</li>

$('.apple').addClass('red').removeClass().prop('outerHTML');
//=> <li class="">Apple</li>
```
See
https://api.jquery.com/removeClass/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:361

toggleClass

toggleClass<T extends AnyNode, R extends ArrayLike<T>>(
    this: R,
    value?:
        | string
        | (
            (
                this: Element,
                i: number,
                className: string,
                stateVal?: boolean,
            ) => string
        ),
    stateVal?: boolean,
): R
Add or remove class(es) from the matched elements, depending on either the class's presence or the value of the switch argument. Also accepts a function.
Type Parameters
- T extends AnyNode
- R extends ArrayLike<T>
Parameters
- this: R
- Optionalvalue:
      | string
      | (
          (
              this: Element,
              i: number,
              className: string,
              stateVal?: boolean,
          ) => string
      )
  Name of the class. Can also be a function.
- OptionalstateVal: boolean
  If specified the state of the class.
Returns R
The instance itself.
Example
```
$('.apple.green').toggleClass('fruit green red').prop('outerHTML');
//=> <li class="apple fruit red">Apple</li>

$('.apple.green').toggleClass('fruit green red', true).prop('outerHTML');
//=> <li class="apple green fruit red">Apple</li>
```
See
https://api.jquery.com/toggleClass/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:383

val

val<T extends AnyNode>(this: Cheerio<T>): string | string[]
Method for getting the value of input, select, and textarea. Note: Support for map, and function has not been added yet.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
Returns string | string[]
The value.
Example
```
$('input[type="text"]').val();
//=> input_text
```
See
https://api.jquery.com/val/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:262
val<T extends AnyNode>(this: Cheerio<T>, value: string | string[]): Cheerio<T>
Method for setting the value of input, select, and textarea. Note: Support for map, and function has not been added yet.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- value: string | string[]
  The new value.
Returns Cheerio<T>
The instance itself.
Example
```
$('input[type="text"]').val('test').prop('outerHTML');
//=> <input type="text" value="test"/>
```
See
https://api.jquery.com/val/
- Defined in node_modules/cheerio/dist/esm/api/attributes.d.ts:279

CSS

css

css<T extends AnyNode>(
this: Cheerio<T>,
names?: string[],
): Record<string, string>
Get the value of a style property for the first element in the set of matched elements.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- Optionalnames: string[]
  Optionally the names of the properties of interest.
Returns Record<string, string>
A map of all of the style properties.

See
https://api.jquery.com/css/
- Defined in node_modules/cheerio/dist/esm/api/css.d.ts:12
css<T extends AnyNode>(this: Cheerio<T>, name: string): string
Get the value of a style property for the first element in the set of matched elements.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- name: string
  The name of the property.
Returns string
The property value for the given name.

See
https://api.jquery.com/css/
- Defined in node_modules/cheerio/dist/esm/api/css.d.ts:22
css<T extends AnyNode>(
    this: Cheerio<T>,
    prop: string,
    val: string | ((this: Element, i: number, style: string) => string),
): Cheerio<T>
Set one CSS property for every matched element.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- prop: string
  The name of the property.
- val: string | ((this: Element, i: number, style: string) => string)
  The new value.
Returns Cheerio<T>
The instance itself.

See
https://api.jquery.com/css/
- Defined in node_modules/cheerio/dist/esm/api/css.d.ts:32
css<T extends AnyNode>(
this: Cheerio<T>,
map: Record<string, string>,
): Cheerio<T>
Set multiple CSS properties for every matched element.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- map: Record<string, string>
  A map of property names and values.
Returns Cheerio<T>
The instance itself.

See
https://api.jquery.com/css/
- Defined in node_modules/cheerio/dist/esm/api/css.d.ts:41

Forms

serialize

serialize<T extends AnyNode>(this: Cheerio<T>): string
Encode a set of form elements as a string for submission.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
Returns string
The serialized form.
Example
```
$('<form><input name="foo" value="bar" /></form>').serialize();
//=> 'foo=bar'
```
See
https://api.jquery.com/serialize/
- Defined in node_modules/cheerio/dist/esm/api/forms.d.ts:17

serializeArray

serializeArray<T extends AnyNode>(
this: Cheerio<T>,
): { name: string; value: string }[]
Encode a set of form elements as an array of names and values.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
Returns { name: string; value: string }[]
The serialized form.
Example
```
$('<form><input name="foo" value="bar" /></form>').serializeArray();
//=> [ { name: 'foo', value: 'bar' } ]
```
See
https://api.jquery.com/serializeArray/
- Defined in node_modules/cheerio/dist/esm/api/forms.d.ts:32

Manipulation

append

append: <T extends AnyNode>(
    this: Cheerio<T>,
    ...elems:
        | [
            (
                this: AnyNode,
                i: number,
                html: string,
            ) => BasicAcceptedElems<AnyNode>,
        ]
        | BasicAcceptedElems<AnyNode>[],
) => Cheerio<T>

Inserts content as the last child of each of the selected elements.

Example

$('ul').append('<li class="plum">Plum</li>');
$.html();
//=>  <ul id="fruits">
//      <li class="apple">Apple</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//      <li class="plum">Plum</li>
//    </ul>

See

https://api.jquery.com/append/

prepend

prepend: <T extends AnyNode>(
    this: Cheerio<T>,
    ...elems:
        | [
            (
                this: AnyNode,
                i: number,
                html: string,
            ) => BasicAcceptedElems<AnyNode>,
        ]
        | BasicAcceptedElems<AnyNode>[],
) => Cheerio<T>

Inserts content as the first child of each of the selected elements.

Example

$('ul').prepend('<li class="plum">Plum</li>');
$.html();
//=>  <ul id="fruits">
//      <li class="plum">Plum</li>
//      <li class="apple">Apple</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//    </ul>

See

https://api.jquery.com/prepend/

wrap

wrap: <T extends AnyNode>(
this: Cheerio<T>,
wrapper: AcceptedElems<AnyNode>,
) => Cheerio<T>

The .wrap() function can take any string or object that could be passed to the $() factory function to specify a DOM structure. This structure may be nested several levels deep, but should contain only one inmost element. A copy of this structure will be wrapped around each of the elements in the set of matched elements. This method returns the original set of elements for chaining purposes.

Type Declaration

- <T extends AnyNode>(
  this: Cheerio<T>,
  wrapper: AcceptedElems<AnyNode>,
  ): Cheerio<T>
- Type Parameters
  - T extends AnyNode
  Parameters
  - this: Cheerio<T>
  - wrapper: AcceptedElems<AnyNode>
    The DOM structure to wrap around each element in the selection.
  Returns Cheerio<T>

Example

const redFruit = $('<div class="red-fruit"></div>');
$('.apple').wrap(redFruit);

//=> <ul id="fruits">
//     <div class="red-fruit">
//      <li class="apple">Apple</li>
//     </div>
//     <li class="orange">Orange</li>
//     <li class="plum">Plum</li>
//   </ul>

const healthy = $('<div class="healthy"></div>');
$('li').wrap(healthy);

//=> <ul id="fruits">
//     <div class="healthy">
//       <li class="apple">Apple</li>
//     </div>
//     <div class="healthy">
//       <li class="orange">Orange</li>
//     </div>
//     <div class="healthy">
//        <li class="plum">Plum</li>
//     </div>
//   </ul>

See

https://api.jquery.com/wrap/

wrapInner

wrapInner: <T extends AnyNode>(
this: Cheerio<T>,
wrapper: AcceptedElems<AnyNode>,
) => Cheerio<T>

The .wrapInner() function can take any string or object that could be passed to the $() factory function to specify a DOM structure. This structure may be nested several levels deep, but should contain only one inmost element. The structure will be wrapped around the content of each of the elements in the set of matched elements.

Type Declaration

- <T extends AnyNode>(
  this: Cheerio<T>,
  wrapper: AcceptedElems<AnyNode>,
  ): Cheerio<T>
- Type Parameters
  - T extends AnyNode
  Parameters
  - this: Cheerio<T>
  - wrapper: AcceptedElems<AnyNode>
    The DOM structure to wrap around the content of each element in the selection.
  Returns Cheerio<T>
  The instance itself, for chaining.

Example

const redFruit = $('<div class="red-fruit"></div>');
$('.apple').wrapInner(redFruit);

//=> <ul id="fruits">
//     <li class="apple">
//       <div class="red-fruit">Apple</div>
//     </li>
//     <li class="orange">Orange</li>
//     <li class="pear">Pear</li>
//   </ul>

const healthy = $('<div class="healthy"></div>');
$('li').wrapInner(healthy);

//=> <ul id="fruits">
//     <li class="apple">
//       <div class="healthy">Apple</div>
//     </li>
//     <li class="orange">
//       <div class="healthy">Orange</div>
//     </li>
//     <li class="pear">
//       <div class="healthy">Pear</div>
//     </li>
//   </ul>

See

https://api.jquery.com/wrapInner/

after

after<T extends AnyNode>(
    this: Cheerio<T>,
    ...elems:
        | BasicAcceptedElems<AnyNode>[]
        | [
            (
                this: AnyNode,
                i: number,
                html: string,
            ) => BasicAcceptedElems<AnyNode>,
        ],
): Cheerio<T>
Insert content next to each element in the set of matched elements.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- ...elems:
  | BasicAcceptedElems<AnyNode>[]
  | [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>]
  HTML string, DOM element, array of DOM elements or Cheerio to insert after each element in the set of matched elements.
Returns Cheerio<T>
The instance itself.
Example
```
$('.apple').after('<li class="plum">Plum</li>');
$.html();
//=>  <ul id="fruits">
//      <li class="apple">Apple</li>
//      <li class="plum">Plum</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//    </ul>
```
See
https://api.jquery.com/after/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:307

appendTo

appendTo<T extends AnyNode>(
this: Cheerio<T>,
target: BasicAcceptedElems<AnyNode>,
): Cheerio<T>
Insert every element in the set of matched elements to the end of the target.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- target: BasicAcceptedElems<AnyNode>
  Element to append elements to.
Returns Cheerio<T>
The instance itself.
Example
```
$('<li class="plum">Plum</li>').appendTo('#fruits');
$.html();
//=>  <ul id="fruits">
//      <li class="apple">Apple</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//      <li class="plum">Plum</li>
//    </ul>
```
See
https://api.jquery.com/appendTo/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:41

before

before<T extends AnyNode>(
    this: Cheerio<T>,
    ...elems:
        | BasicAcceptedElems<AnyNode>[]
        | [
            (
                this: AnyNode,
                i: number,
                html: string,
            ) => BasicAcceptedElems<AnyNode>,
        ],
): Cheerio<T>
Insert content previous to each element in the set of matched elements.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- ...elems:
  | BasicAcceptedElems<AnyNode>[]
  | [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>]
  HTML string, DOM element, array of DOM elements or Cheerio to insert before each element in the set of matched elements.
Returns Cheerio<T>
The instance itself.
Example
```
$('.apple').before('<li class="plum">Plum</li>');
$.html();
//=>  <ul id="fruits">
//      <li class="plum">Plum</li>
//      <li class="apple">Apple</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//    </ul>
```
See
https://api.jquery.com/before/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:352

clone

clone<T extends AnyNode>(this: Cheerio<T>): Cheerio<T>
Clone the cheerio object.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
Returns Cheerio<T>
The cloned object.
Example
```
const moreFruit = $('#fruits').clone();
```
See
https://api.jquery.com/clone/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:527

empty

empty<T extends AnyNode>(this: Cheerio<T>): Cheerio<T>
Removes all children from each item in the selection. Text nodes and comment nodes are left as is.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
Returns Cheerio<T>
The instance itself.
Example
```
$('ul').empty();
$.html();
//=>  <ul id="fruits"></ul>
```
See
https://api.jquery.com/empty/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:434

html

html<T extends AnyNode>(this: Cheerio<T>): string
Gets an HTML content string from the first selected element.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
Returns string
The HTML content string.
Example
```
$('.orange').html();
//=> Orange

$('#fruits').html('<li class="mango">Mango</li>').html();
//=> <li class="mango">Mango</li>
```
See
https://api.jquery.com/html/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:452
html<T extends AnyNode>(this: Cheerio<T>, str: string | Cheerio<T>): Cheerio<T>
Replaces each selected element's content with the specified content.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- str: string | Cheerio<T>
  The content to replace selection's contents with.
Returns Cheerio<T>
The instance itself.
Example
```
$('.orange').html('<li class="mango">Mango</li>').html();
//=> <li class="mango">Mango</li>
```
See
https://api.jquery.com/html/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:468

insertAfter

insertAfter<T extends AnyNode>(
this: Cheerio<T>,
target: BasicAcceptedElems<AnyNode>,
): Cheerio<T>
Insert every element in the set of matched elements after the target.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- target: BasicAcceptedElems<AnyNode>
  Element to insert elements after.
Returns Cheerio<T>
The set of newly inserted elements.
Example
```
$('<li class="plum">Plum</li>').insertAfter('.apple');
$.html();
//=>  <ul id="fruits">
//      <li class="apple">Apple</li>
//      <li class="plum">Plum</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//    </ul>
```
See
https://api.jquery.com/insertAfter/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:329

insertBefore

insertBefore<T extends AnyNode>(
this: Cheerio<T>,
target: BasicAcceptedElems<AnyNode>,
): Cheerio<T>
Insert every element in the set of matched elements before the target.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- target: BasicAcceptedElems<AnyNode>
  Element to insert elements before.
Returns Cheerio<T>
The set of newly inserted elements.
Example
```
$('<li class="plum">Plum</li>').insertBefore('.apple');
$.html();
//=>  <ul id="fruits">
//      <li class="plum">Plum</li>
//      <li class="apple">Apple</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//    </ul>
```
See
https://api.jquery.com/insertBefore/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:374

prependTo

prependTo<T extends AnyNode>(
this: Cheerio<T>,
target: BasicAcceptedElems<AnyNode>,
): Cheerio<T>
Insert every element in the set of matched elements to the beginning of the target.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- target: BasicAcceptedElems<AnyNode>
  Element to prepend elements to.
Returns Cheerio<T>
The instance itself.
Example
```
$('<li class="plum">Plum</li>').prependTo('#fruits');
$.html();
//=>  <ul id="fruits">
//      <li class="plum">Plum</li>
//      <li class="apple">Apple</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//    </ul>
```
See
https://api.jquery.com/prependTo/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:64

remove

remove<T extends AnyNode>(this: Cheerio<T>, selector?: string): Cheerio<T>
Removes the set of matched elements from the DOM and all their children. selector filters the set of matched elements to be removed.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- Optionalselector: string
  Optional selector for elements to remove.
Returns Cheerio<T>
The instance itself.
Example
```
$('.pear').remove();
$.html();
//=>  <ul id="fruits">
//      <li class="apple">Apple</li>
//      <li class="orange">Orange</li>
//    </ul>
```
See
https://api.jquery.com/remove/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:395

replaceWith

replaceWith<T extends AnyNode>(
this: Cheerio<T>,
content: AcceptedElems<AnyNode>,
): Cheerio<T>
Replaces matched elements with content.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- content: AcceptedElems<AnyNode>
  Replacement for matched elements.
Returns Cheerio<T>
The instance itself.
Example
```
const plum = $('<li class="plum">Plum</li>');
$('.pear').replaceWith(plum);
$.html();
//=> <ul id="fruits">
//     <li class="apple">Apple</li>
//     <li class="orange">Orange</li>
//     <li class="plum">Plum</li>
//   </ul>
```
See
https://api.jquery.com/replaceWith/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:417

text

text<T extends AnyNode>(this: Cheerio<T>): string
Get the combined text contents of each element in the set of matched elements, including their descendants.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
Returns string
The text contents of the collection.
Example
```
$('.orange').text();
//=> Orange

$('ul').text();
//=>  Apple
//    Orange
//    Pear
```
See
https://api.jquery.com/text/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:496
text<T extends AnyNode>(
this: Cheerio<T>,
str: string | ((this: AnyNode, i: number, text: string) => string),
): Cheerio<T>
Set the content of each element in the set of matched elements to the specified text.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- str: string | ((this: AnyNode, i: number, text: string) => string)
  The text to set as the content of each matched element.
Returns Cheerio<T>
The instance itself.
Example
```
$('.orange').text('Orange');
//=> <div class="orange">Orange</div>
```
See
https://api.jquery.com/text/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:513

toString

toString<T extends AnyNode>(this: Cheerio<T>): string
Turns the collection to a string. Alias for .html().
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
Returns string
The rendered document.
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:475

unwrap

unwrap<T extends AnyNode>(this: Cheerio<T>, selector?: string): Cheerio<T>
The .unwrap() function, removes the parents of the set of matched elements from the DOM, leaving the matched elements in their place.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- Optionalselector: string
  A selector to check the parent element against. If an element's parent does not match the selector, the element won't be unwrapped.
Returns Cheerio<T>
The instance itself, for chaining.
Example: <caption>without selector</caption>
```
const $ = cheerio.load(
  '<div id=test>\n  <div><p>Hello</p></div>\n  <div><p>World</p></div>\n</div>',
);
$('#test p').unwrap();

//=> <div id=test>
//     <p>Hello</p>
//     <p>World</p>
//   </div>
```
Example: <caption>with selector</caption>
```
const $ = cheerio.load(
  '<div id=test>\n  <p>Hello</p>\n  <b><p>World</p></b>\n</div>',
);
$('#test p').unwrap('b');

//=> <div id=test>
//     <p>Hello</p>
//     <p>World</p>
//   </div>
```
See
https://api.jquery.com/unwrap/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:232

wrapAll

wrapAll<T extends AnyNode>(
this: Cheerio<T>,
wrapper: AcceptedElems<T>,
): Cheerio<T>
The .wrapAll() function can take any string or object that could be passed to the $() function to specify a DOM structure. This structure may be nested several levels deep, but should contain only one inmost element. The structure will be wrapped around all of the elements in the set of matched elements, as a single group.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- wrapper: AcceptedElems<T>
  The DOM structure to wrap around all matched elements in the selection.
Returns Cheerio<T>
The instance itself.
Example: <caption>With markup passed to `wrapAll`</caption>
```
const $ = cheerio.load(
  '<div class="container"><div class="inner">First</div><div class="inner">Second</div></div>',
);
$('.inner').wrapAll("<div class='new'></div>");

//=> <div class="container">
//     <div class='new'>
//       <div class="inner">First</div>
//       <div class="inner">Second</div>
//     </div>
//   </div>
```
Example: <caption>With an existing cheerio instance</caption>
```
const $ = cheerio.load(
  '<span>Span 1</span><strong>Strong</strong><span>Span 2</span>',
);
const wrap = $('<div><p><em><b></b></em></p></div>');
$('span').wrapAll(wrap);

//=> <div>
//     <p>
//       <em>
//         <b>
//           <span>Span 1</span>
//           <span>Span 2</span>
//         </b>
//       </em>
//     </p>
//   </div>
//   <strong>Strong</strong>
```
See
https://api.jquery.com/wrapAll/
- Defined in node_modules/cheerio/dist/esm/api/manipulation.d.ts:284

Other

cheerio

cheerio: "[cheerio object]"

length

length: number

options

options: InternalOptions

prevObject

prevObject: Cheerio<any>

splice

splice: {
(start: number, deleteCount?: number): any[];
(start: number, deleteCount: number, ...items: any[]): any[];
}

Type Declaration

- (start: number, deleteCount?: number): any[]
- Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
  Parameters
  - start: number
    The zero-based location in the array from which to start removing elements.
  - OptionaldeleteCount: number
    The number of elements to remove. Omitting this argument will remove all elements from the start paramater location to end of the array. If value of this argument is either a negative number, zero, undefined, or a type that cannot be converted to an integer, the function will evaluate the argument as zero and not remove any elements.
  Returns any[]
  An array containing the elements that were deleted.
- (start: number, deleteCount: number, ...items: any[]): any[]
- Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
  Parameters
  - start: number
    The zero-based location in the array from which to start removing elements.
  - deleteCount: number
    The number of elements to remove. If value of this argument is either a negative number, zero, undefined, or a type that cannot be converted to an integer, the function will evaluate the argument as zero and not remove any elements.
  - ...items: any[]
    Elements to insert into the array in place of the deleted elements.
  Returns any[]
  An array containing the elements that were deleted.

[iterator]

"[iterator]"(): Iterator<T, any, any>
Returns Iterator<T, any, any>
Inherited from Iterable.[iterator]
- Defined in node_modules/typescript/lib/lib.es2015.iterable.d.ts:49

extract

extract<M extends ExtractMap, T extends AnyNode>(
this: Cheerio<T>,
map: M,
): ExtractedMap<M>
Extract multiple values from a document, and store them in an object.
Type Parameters
- M extends ExtractMap
- T extends AnyNode
Parameters
- this: Cheerio<T>
- map: M
  An object containing key-value pairs. The keys are the names of the properties to be created on the object, and the values are the selectors to be used to extract the values.
Returns ExtractedMap<M>
An object containing the extracted values.
- Defined in node_modules/cheerio/dist/esm/api/extract.d.ts:25

filterArray

filterArray<T>(
    nodes: T[],
    match: AcceptedFilters<T>,
    xmlMode?: boolean,
    root?: Document,
): T[] | Element[]
Type Parameters
- T
Parameters
- nodes: T[]
- match: AcceptedFilters<T>
- OptionalxmlMode: boolean
- Optionalroot: Document
Returns T[] | Element[]
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:398

toArray

toArray<T>(this: Cheerio<T>): T[]
Retrieve all the DOM elements contained in the jQuery set as an array.
Type Parameters
- T
Parameters
- this: Cheerio<T>
Returns T[]
The contained items.
Example
```
$('li').toArray();
//=> [ {...}, {...}, {...} ]
```
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:564

Traversing

children

children: <T extends AnyNode>(
this: Cheerio<T>,
selector?: AcceptedFilters<Element>,
) => Cheerio<Element>

Gets the element children of each element in the set of matched elements.

Type Declaration

- <T extends AnyNode>(
  this: Cheerio<T>,
  selector?: AcceptedFilters<Element>,
  ): Cheerio<Element>
- Type Parameters
  - T extends AnyNode
  Parameters
  - this: Cheerio<T>
  - Optionalselector: AcceptedFilters<Element>
    If specified filter for children.
  Returns Cheerio<Element>
  The children.

Example

$('#fruits').children().length;
//=> 3

$('#fruits').children('.pear').text();
//=> Pear

See

https://api.jquery.com/children/

next: <T extends AnyNode>(
this: Cheerio<T>,
selector?: AcceptedFilters<Element>,
) => Cheerio<Element>

Gets the next sibling of each selected element, optionally filtered by a selector.

Type Declaration

- <T extends AnyNode>(
  this: Cheerio<T>,
  selector?: AcceptedFilters<Element>,
  ): Cheerio<Element>
- Type Parameters
  - T extends AnyNode
  Parameters
  - this: Cheerio<T>
  - Optionalselector: AcceptedFilters<Element>
    If specified filter for sibling.
  Returns Cheerio<Element>
  The next nodes.

Example

$('.apple').next().hasClass('orange');
//=> true

See

https://api.jquery.com/next/

nextAll

nextAll: <T extends AnyNode>(
this: Cheerio<T>,
selector?: AcceptedFilters<Element>,
) => Cheerio<Element>

Gets all the following siblings of the each selected element, optionally filtered by a selector.

Type Declaration

- <T extends AnyNode>(
  this: Cheerio<T>,
  selector?: AcceptedFilters<Element>,
  ): Cheerio<Element>
- Type Parameters
  - T extends AnyNode
  Parameters
  - this: Cheerio<T>
  - Optionalselector: AcceptedFilters<Element>
    If specified filter for siblings.
  Returns Cheerio<Element>
  The next nodes.

Example

$('.apple').nextAll();
//=> [<li class="orange">Orange</li>, <li class="pear">Pear</li>]
$('.apple').nextAll('.orange');
//=> [<li class="orange">Orange</li>]

See

https://api.jquery.com/nextAll/

nextUntil

nextUntil: <T extends AnyNode>(
    this: Cheerio<T>,
    selector?: AcceptedFilters<Element> | null,
    filterSelector?: AcceptedFilters<Element>,
) => Cheerio<Element>

Gets all the following siblings up to but not including the element matched by the selector, optionally filtered by another selector.

Type Declaration

- <T extends AnyNode>(
      this: Cheerio<T>,
      selector?: AcceptedFilters<Element> | null,
      filterSelector?: AcceptedFilters<Element>,
  ): Cheerio<Element>
- Type Parameters
  - T extends AnyNode
  Parameters
  - this: Cheerio<T>
  - Optionalselector: AcceptedFilters<Element> | null
    Selector for element to stop at.
  - OptionalfilterSelector: AcceptedFilters<Element>
    If specified filter for siblings.
  Returns Cheerio<Element>
  The next nodes.

Example

$('.apple').nextUntil('.pear');
//=> [<li class="orange">Orange</li>]

See

https://api.jquery.com/nextUntil/

parent

parent: <T extends AnyNode>(
this: Cheerio<T>,
selector?: AcceptedFilters<Element>,
) => Cheerio<Element>

Get the parent of each element in the current set of matched elements, optionally filtered by a selector.

Type Declaration

- <T extends AnyNode>(
  this: Cheerio<T>,
  selector?: AcceptedFilters<Element>,
  ): Cheerio<Element>
- Type Parameters
  - T extends AnyNode
  Parameters
  - this: Cheerio<T>
  - Optionalselector: AcceptedFilters<Element>
    If specified filter for parent.
  Returns Cheerio<Element>
  The parents.

Example

$('.pear').parent().attr('id');
//=> fruits

See

https://api.jquery.com/parent/

parents

parents: <T extends AnyNode>(
this: Cheerio<T>,
selector?: AcceptedFilters<Element>,
) => Cheerio<Element>

Get a set of parents filtered by selector of each element in the current set of match elements.

Type Declaration

- <T extends AnyNode>(
  this: Cheerio<T>,
  selector?: AcceptedFilters<Element>,
  ): Cheerio<Element>
- Type Parameters
  - T extends AnyNode
  Parameters
  - this: Cheerio<T>
  - Optionalselector: AcceptedFilters<Element>
    If specified filter for parents.
  Returns Cheerio<Element>
  The parents.

Example

$('.orange').parents().length;
//=> 2
$('.orange').parents('#fruits').length;
//=> 1

See

https://api.jquery.com/parents/

parentsUntil

parentsUntil: <T extends AnyNode>(
    this: Cheerio<T>,
    selector?: AcceptedFilters<Element> | null,
    filterSelector?: AcceptedFilters<Element>,
) => Cheerio<Element>

Get the ancestors of each element in the current set of matched elements, up to but not including the element matched by the selector, DOM node, or cheerio object.

Type Declaration

- <T extends AnyNode>(
      this: Cheerio<T>,
      selector?: AcceptedFilters<Element> | null,
      filterSelector?: AcceptedFilters<Element>,
  ): Cheerio<Element>
- Type Parameters
  - T extends AnyNode
  Parameters
  - this: Cheerio<T>
  - Optionalselector: AcceptedFilters<Element> | null
    Selector for element to stop at.
  - OptionalfilterSelector: AcceptedFilters<Element>
    Optional filter for parents.
  Returns Cheerio<Element>
  The parents.

Example

$('.orange').parentsUntil('#food').length;
//=> 1

See

https://api.jquery.com/parentsUntil/

prev: <T extends AnyNode>(
this: Cheerio<T>,
selector?: AcceptedFilters<Element>,
) => Cheerio<Element>

Gets the previous sibling of each selected element optionally filtered by a selector.

Type Declaration

- <T extends AnyNode>(
  this: Cheerio<T>,
  selector?: AcceptedFilters<Element>,
  ): Cheerio<Element>
- Type Parameters
  - T extends AnyNode
  Parameters
  - this: Cheerio<T>
  - Optionalselector: AcceptedFilters<Element>
    If specified filter for siblings.
  Returns Cheerio<Element>
  The previous nodes.

Example

$('.orange').prev().hasClass('apple');
//=> true

See

https://api.jquery.com/prev/

prevAll

prevAll: <T extends AnyNode>(
this: Cheerio<T>,
selector?: AcceptedFilters<Element>,
) => Cheerio<Element>

Gets all the preceding siblings of each selected element, optionally filtered by a selector.

Type Declaration

- <T extends AnyNode>(
  this: Cheerio<T>,
  selector?: AcceptedFilters<Element>,
  ): Cheerio<Element>
- Type Parameters
  - T extends AnyNode
  Parameters
  - this: Cheerio<T>
  - Optionalselector: AcceptedFilters<Element>
    If specified filter for siblings.
  Returns Cheerio<Element>
  The previous nodes.

Example

$('.pear').prevAll();
//=> [<li class="orange">Orange</li>, <li class="apple">Apple</li>]

$('.pear').prevAll('.orange');
//=> [<li class="orange">Orange</li>]

See

https://api.jquery.com/prevAll/

prevUntil

prevUntil: <T extends AnyNode>(
    this: Cheerio<T>,
    selector?: AcceptedFilters<Element> | null,
    filterSelector?: AcceptedFilters<Element>,
) => Cheerio<Element>

Gets all the preceding siblings up to but not including the element matched by the selector, optionally filtered by another selector.

Type Declaration

- <T extends AnyNode>(
      this: Cheerio<T>,
      selector?: AcceptedFilters<Element> | null,
      filterSelector?: AcceptedFilters<Element>,
  ): Cheerio<Element>
- Type Parameters
  - T extends AnyNode
  Parameters
  - this: Cheerio<T>
  - Optionalselector: AcceptedFilters<Element> | null
    Selector for element to stop at.
  - OptionalfilterSelector: AcceptedFilters<Element>
    If specified filter for siblings.
  Returns Cheerio<Element>
  The previous nodes.

Example

$('.pear').prevUntil('.apple');
//=> [<li class="orange">Orange</li>]

See

https://api.jquery.com/prevUntil/

siblings

siblings: <T extends AnyNode>(
this: Cheerio<T>,
selector?: AcceptedFilters<Element>,
) => Cheerio<Element>

Get the siblings of each element (excluding the element) in the set of matched elements, optionally filtered by a selector.

Type Declaration

- <T extends AnyNode>(
  this: Cheerio<T>,
  selector?: AcceptedFilters<Element>,
  ): Cheerio<Element>
- Type Parameters
  - T extends AnyNode
  Parameters
  - this: Cheerio<T>
  - Optionalselector: AcceptedFilters<Element>
    If specified filter for siblings.
  Returns Cheerio<Element>
  The siblings.

Example

$('.pear').siblings().length;
//=> 2

$('.pear').siblings('.orange').length;
//=> 1

See

https://api.jquery.com/siblings/

add

add<S extends AnyNode, T extends AnyNode>(
    this: Cheerio<T>,
    other: string | S | Cheerio<S> | S[],
    context?: string | Cheerio<S>,
): Cheerio<S | T>
Add elements to the set of matched elements.
Type Parameters
- S extends AnyNode
- T extends AnyNode
Parameters
- this: Cheerio<T>
- other: string | S | Cheerio<S> | S[]
  Elements to add.
- Optionalcontext: string | Cheerio<S>
  Optionally the context of the new selection.
Returns Cheerio<S | T>
The combined set.
Example
```
$('.apple').add('.orange').length;
//=> 2
```
See
https://api.jquery.com/add/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:639

addBack

addBack<T extends AnyNode>(
this: Cheerio<T>,
selector?: string,
): Cheerio<AnyNode>
Add the previous set of elements on the stack to the current set, optionally filtered by a selector.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- Optionalselector: string
  Selector for the elements to add.
Returns Cheerio<AnyNode>
The combined set.
Example
```
$('li').eq(0).addBack('.orange').length;
//=> 2
```
See
https://api.jquery.com/addBack/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:656

closest

closest<T extends AnyNode>(
this: Cheerio<T>,
selector?: AcceptedFilters<Element>,
): Cheerio<AnyNode>
For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- Optionalselector: AcceptedFilters<Element>
  Selector for the element to find.
Returns Cheerio<AnyNode>
The closest nodes.
Example
```
$('.orange').closest();
//=> []

$('.orange').closest('.apple');
// => []

$('.orange').closest('li');
//=> [<li class="orange">Orange</li>]

$('.orange').closest('#fruits');
//=> [<ul id="fruits"> ... </ul>]
```
See
https://api.jquery.com/closest/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:119

contents<T extends AnyNode>(this: Cheerio<T>): Cheerio<AnyNode>
Gets the children of each element in the set of matched elements, including text and comment nodes.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
Returns Cheerio<AnyNode>
The children.
Example
```
$('#fruits').contents().length;
//=> 3
```
See
https://api.jquery.com/contents/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:283

each

each<T>(
this: Cheerio<T>,
fn: (this: T, i: number, el: T) => boolean | void,
): Cheerio<T>
Iterates over a cheerio object, executing a function for each matched element. When the callback is fired, the function is fired in the context of the DOM element, so this refers to the current element, which is equivalent to the function parameter element. To break out of the each loop early, return with false.
Type Parameters
- T
Parameters
- this: Cheerio<T>
- fn: (this: T, i: number, el: T) => boolean | void
  Function to execute.
Returns Cheerio<T>
The instance itself, useful for chaining.
Example
```
const fruits = [];

$('li').each(function (i, elem) {
  fruits[i] = $(this).text();
});

fruits.join(', ');
//=> Apple, Orange, Pear
```
See
https://api.jquery.com/each/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:309

end

end<T>(this: Cheerio<T>): Cheerio<AnyNode>
End the most recent filtering operation in the current chain and return the set of matched elements to its previous state.
Type Parameters
- T
Parameters
- this: Cheerio<T>
Returns Cheerio<AnyNode>
The previous state of the set of matched elements.
Example
```
$('li').eq(0).end().length;
//=> 3
```
See
https://api.jquery.com/end/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:622

eq

eq<T>(this: Cheerio<T>, i: number): Cheerio<T>
Reduce the set of matched elements to the one at the specified index. Use .eq(-i) to count backwards from the last selected element.
Type Parameters
- T
Parameters
- this: Cheerio<T>
- i: number
  Index of the element to select.
Returns Cheerio<T>
The element at the ith position.
Example
```
$('li').eq(0).text();
//=> Apple

$('li').eq(-1).text();
//=> Pear
```
See
https://api.jquery.com/eq/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:519

filter

filter<T, S>(
this: Cheerio<T>,
match: (this: T, index: number, value: T) => value is S,
): Cheerio<S>
Iterates over a cheerio object, reducing the set of selector elements to those that match the selector or pass the function's test.

This is the definition for using type guards; have a look below for other ways to invoke this method. The function is executed in the context of the selected element, so this refers to the current element.
Type Parameters
- T
- S
Parameters
- this: Cheerio<T>
- match: (this: T, index: number, value: T) => value is S
  Value to look for, following the rules above.
Returns Cheerio<S>
The filtered collection.
Example: <caption>Function</caption>
```
$('li')
  .filter(function (i, el) {
    // this === el
    return $(this).attr('class') === 'orange';
  })
  .attr('class'); //=> orange
```
See
https://api.jquery.com/filter/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:361
filter<T, S>(
this: Cheerio<T>,
match: S,
): Cheerio<S extends string ? Element : T>
Iterates over a cheerio object, reducing the set of selector elements to those that match the selector or pass the function's test.
- When a Cheerio selection is specified, return only the elements contained in that selection.
- When an element is specified, return only that element (if it is contained in the original selection).
- If using the function method, the function is executed in the context of the selected element, so this refers to the current element.
Type Parameters
- T
- S
Parameters
- this: Cheerio<T>
- match: S
  Value to look for, following the rules above. See AcceptedFilters.
Returns Cheerio<S extends string ? Element : T>
The filtered collection.
Example: <caption>Selector</caption>
```
$('li').filter('.orange').attr('class');
//=> orange
```
Example: <caption>Function</caption>
```
$('li')
  .filter(function (i, el) {
    // this === el
    return $(this).attr('class') === 'orange';
  })
  .attr('class'); //=> orange
```
See
https://api.jquery.com/filter/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:397

find

find<T extends AnyNode>(
this: Cheerio<T>,
selectorOrHaystack?: string | Element | Cheerio<Element>,
): Cheerio<Element>
Get the descendants of each element in the current set of matched elements, filtered by a selector, jQuery object, or element.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- OptionalselectorOrHaystack: string | Element | Cheerio<Element>
  Element to look for.
Returns Cheerio<Element>
The found elements.
Example
```
$('#fruits').find('li').length;
//=> 3
$('#fruits').find($('.apple')).length;
//=> 1
```
See
https://api.jquery.com/find/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:27

first

first<T extends AnyNode>(this: Cheerio<T>): Cheerio<T>
Will select the first element of a cheerio object.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
Returns Cheerio<T>
The first element.
Example
```
$('#fruits').children().first().text();
//=> Apple
```
See
https://api.jquery.com/first/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:484

get

get<T>(this: Cheerio<T>, i: number): T
Retrieve one of the elements matched by the Cheerio object, at the ith position.
Type Parameters
- T
Parameters
- this: Cheerio<T>
- i: number
  Element to retrieve.
Returns T
The element at the ith position.
Example
```
$('li').get(0).tagName;
//=> li
```
See
https://api.jquery.com/get/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:536
get<T>(this: Cheerio<T>): T[]
Retrieve all elements matched by the Cheerio object, as an array.
Type Parameters
- T
Parameters
- this: Cheerio<T>
Returns T[]
All elements matched by the Cheerio object.
Example
```
$('li').get().length;
//=> 3
```
See
https://api.jquery.com/get/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:551

has

has(
this: Cheerio<AnyNode>,
selectorOrHaystack: string | Element | Cheerio<Element>,
): Cheerio<AnyNode>
Filters the set of matched elements to only those which have the given DOM element as a descendant or which have a descendant that matches the given selector. Equivalent to .filter(':has(selector)').
Parameters
- this: Cheerio<AnyNode>
- selectorOrHaystack: string | Element | Cheerio<Element>
  Element to look for.
Returns Cheerio<AnyNode>
The filtered collection.
Example: <caption>Selector</caption>
```
$('ul').has('.pear').attr('id');
//=> fruits
```
Example: <caption>Element</caption>
```
$('ul').has($('.pear')[0]).attr('id');
//=> fruits
```
See
https://api.jquery.com/has/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:469

index

index<T extends AnyNode>(
this: Cheerio<T>,
selectorOrNeedle?: string | AnyNode | Cheerio<AnyNode>,
): number
Search for a given element from among the matched elements.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- OptionalselectorOrNeedle: string | AnyNode | Cheerio<AnyNode>
  Element to look for.
Returns number
The index of the element.
Example
```
$('.pear').index();
//=> 2 $('.orange').index('li');
//=> 1
$('.apple').index($('#fruit, li'));
//=> 1
```
See
https://api.jquery.com/index/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:583

is

is<T>(this: Cheerio<T>, selector?: AcceptedFilters<T>): boolean
Checks the current list of elements and returns true if any of the elements match the selector. If using an element or Cheerio selection, returns true if any of the elements match. If using a predicate function, the function is executed in the context of the selected element, so this refers to the current element.
Type Parameters
- T
Parameters
- this: Cheerio<T>
- Optionalselector: AcceptedFilters<T>
  Selector for the selection.
Returns boolean
Whether or not the selector matches an element of the instance.

See
https://api.jquery.com/is/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:411

last

last<T>(this: Cheerio<T>): Cheerio<T>
Will select the last element of a cheerio object.
Type Parameters
- T
Parameters
- this: Cheerio<T>
Returns Cheerio<T>
The last element.
Example
```
$('#fruits').children().last().text();
//=> Pear
```
See
https://api.jquery.com/last/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:499

map

map<T, M>(
this: Cheerio<T>,
fn: (this: T, i: number, el: T) => M | M[],
): Cheerio<M>
Pass each element in the current matched set through a function, producing a new Cheerio object containing the return values. The function can return an individual data item or an array of data items to be inserted into the resulting set. If an array is returned, the elements inside the array are inserted into the set. If the function returns null or undefined, no element will be inserted.
Type Parameters
- T
- M
Parameters
- this: Cheerio<T>
- fn: (this: T, i: number, el: T) => M | M[]
  Function to execute.
Returns Cheerio<M>
The mapped elements, wrapped in a Cheerio collection.
Example
```
$('li')
  .map(function (i, el) {
    // this === el
    return $(this).text();
  })
  .toArray()
  .join(' ');
//=> "apple orange pear"
```
See
https://api.jquery.com/map/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:336

not

not<T extends AnyNode>(this: Cheerio<T>, match: AcceptedFilters<T>): Cheerio<T>
Remove elements from the set of matched elements. Given a Cheerio object that represents a set of DOM elements, the .not() method constructs a new Cheerio object from a subset of the matching elements. The supplied selector is tested against each element; the elements that don't match the selector will be included in the result.

The .not() method can take a function as its argument in the same way that .filter() does. Elements for which the function returns true are excluded from the filtered set; all other elements are included.
Type Parameters
- T extends AnyNode
Parameters
- this: Cheerio<T>
- match: AcceptedFilters<T>
  Value to look for, following the rules above.
Returns Cheerio<T>
The filtered collection.
Example: <caption>Selector</caption>
```
$('li').not('.apple').length;
//=> 2
```
Example: <caption>Function</caption>
```
$('li').not(function (i, el) {
  // this === el
  return $(this).attr('class') === 'orange';
}).length; //=> 2
```
See
https://api.jquery.com/not/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:444

slice

slice<T>(this: Cheerio<T>, start?: number, end?: number): Cheerio<T>
Gets the elements matching the specified range (0-based position).
Type Parameters
- T
Parameters
- this: Cheerio<T>
- Optionalstart: number
  A position at which the elements begin to be selected. If negative, it indicates an offset from the end of the set.
- Optionalend: number
  A position at which the elements stop being selected. If negative, it indicates an offset from the end of the set. If omitted, the range continues until the end of the set.
Returns Cheerio<T>
The elements matching the specified range.
Example
```
$('li').slice(1).eq(0).text();
//=> 'Orange'

$('li').slice(1, 2).length;
//=> 1
```
See
https://api.jquery.com/slice/
- Defined in node_modules/cheerio/dist/esm/api/traversing.d.ts:606

Class Cheerio<T>Abstract

Example: This is the HTML markup we will be using in all of the API examples:

Type Parameters

Hierarchy (View Summary)

Implements

Indexable

Index

Attributes

CSS

Forms

Manipulation

Other

Traversing

Attributes

addClass

Type Parameters

Parameters

Returns R

Example

See

attr

Type Parameters

Parameters

Returns string

Example

See

Type Parameters

Parameters

Returns Record<string, string>

Example

See

Type Parameters

Parameters

Returns Cheerio<T>

Example

See

Type Parameters

Parameters

Returns Cheerio<T>

Example

See

data

Type Parameters

Parameters

Returns unknown

Example

See

Type Parameters

Parameters

Returns Record<string, unknown>

Example

See

Type Parameters

Parameters

Returns Cheerio<T>

Example

See

Type Parameters

Parameters

Returns Cheerio<T>

Example

See

hasClass

Type Parameters

Parameters

Returns boolean

Example

See

prop

Type Parameters

Parameters

Returns string

Example

See

Type Parameters

Parameters

Returns string

Example

See

Type Parameters

Class Cheerio<T>`Abstract`