'); expect($elem).toHaveLength(0); }); it('should be able to select multiple elements: cheerio(".apple, #fruits")', () => { const $elems = cheerio('.apple, #fruits', fruits); expect($elems).toHaveLength(2); const $apple = $elems .toArray() .filter((elem) => elem.attribs['class'] === 'apple'); const $fruit = $elems .toArray() .find((elem) => elem.attribs['id'] === 'fruits'); testAppleSelect($apple); expect($fruit?.attribs).toHaveProperty('id', 'fruits'); }); it('should select first element cheerio(:first)', () => { const $elem = cheerio('li:first', fruits); expect($elem.attr('class')).toBe('apple'); const $filtered = cheerio('li', fruits).filter(':even'); expect($filtered).toHaveLength(2); }); it('should be able to select immediate children: cheerio("#fruits > .pear")', () => { const $food = cheerio(food); cheerio('.pear', $food).append('

Another Pear!

'); expect(cheerio('#fruits .pear', $food)).toHaveLength(2); const $elem = cheerio('#fruits > .pear', $food); expect($elem).toHaveLength(1); expect($elem.attr('class')).toBe('pear'); }); it('should be able to select immediate children: cheerio(".apple + .pear")', () => { expect(cheerio('.apple + li', fruits)).toHaveLength(1); expect(cheerio('.apple + .pear', fruits)).toHaveLength(0); const $elem = cheerio('.apple + .orange', fruits); expect($elem).toHaveLength(1); expect($elem.attr('class')).toBe('orange'); }); it('should be able to select immediate children: cheerio(".apple ~ .pear")', () => { expect(cheerio('.apple ~ li', fruits)).toHaveLength(2); expect(cheerio('.apple ~ .pear', fruits).attr('class')).toBe('pear'); }); it('should handle wildcards on attributes: cheerio("li[class*=r]")', () => { const $elem = cheerio('li[class*=r]', fruits); expect($elem).toHaveLength(2); expect($elem.eq(0).attr('class')).toBe('orange'); expect($elem.eq(1).attr('class')).toBe('pear'); }); it('should handle beginning of attr selectors: cheerio("li[class^=o]")', () => { const $elem = cheerio('li[class^=o]', fruits); expect($elem).toHaveLength(1); expect($elem.eq(0).attr('class')).toBe('orange'); }); it('should handle beginning of attr selectors: cheerio("li[class$=e]")', () => { const $elem = cheerio('li[class$=e]', fruits); expect($elem).toHaveLength(2); expect($elem.eq(0).attr('class')).toBe('apple'); expect($elem.eq(1).attr('class')).toBe('orange'); }); it('(extended Array) should not interfere with prototype methods (issue #119)', () => { const extended: AnyNode[] = []; // @ts-expect-error - Ignore for testing extended.find = // @ts-expect-error - Ignore for testing extended.children = // @ts-expect-error - Ignore for testing extended.each = function () { /* Ignore */ }; const $empty = cheerio(extended); // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access expect($empty.find).toBe(cheerio.prototype.find); // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access expect($empty.children).toBe(cheerio.prototype.children); // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access expect($empty.each).toBe(cheerio.prototype.each); }); it('cheerio.html(null) should return a "" string', () => { expect(cheerio.html(null as never)).toBe(''); }); it('should set html(number) as a string', () => { const $elem = cheerio('

'); $elem.html(123 as never); expect(typeof $elem.text()).toBe('string'); }); it('should set text(number) as a string', () => { const $elem = cheerio('

'); $elem.text(123 as never); expect(typeof $elem.text()).toBe('string'); }); describe('.load', () => { it('should generate selections as proper instances', () => { const $ = cheerio.load(fruits); expect($('.apple')).toBeInstanceOf($); }); // Issue #1092 it('should handle a character `)` in `:contains` selector', () => { const result = cheerio.load('

)aaa

')( String.raw`:contains('\)aaa')`, ); expect(result).toHaveLength(3); expect(result.first().prop('tagName')).toBe('HTML'); expect(result.eq(1).prop('tagName')).toBe('BODY'); expect(result.last().prop('tagName')).toBe('P'); }); it('should be able to filter down using the context', () => { const $ = cheerio.load(fruits); const apple = $('.apple', 'ul'); const lis = $('li', 'ul'); expect(apple).toHaveLength(1); expect(lis).toHaveLength(3); }); it('should preserve root content', () => { const $ = cheerio.load(fruits); // Root should not be overwritten const el = $('

'); expect(Object.is(el, el._root)).toBe(false); // Query has to have results expect($('li', 'ul')).toHaveLength(3); }); it('should allow loading a pre-parsed DOM', () => { const dom = parseDOM(food); const $ = cheerio.load(dom); expect($('ul')).toHaveLength(3); }); it('should allow loading a single element', () => { const el = parseDOM(food)[0]; const $ = cheerio.load(el); expect($('ul')).toHaveLength(3); }); it('should render xml in html() when options.xml = true', () => { const str = ''; const expected = ''; const $ = cheerio.load(str, { xml: true }); expect($('MixedCaseTag').get(0)).toHaveProperty( 'tagName', 'MixedCaseTag', ); expect($.html()).toBe(expected); }); it('should render xml in html() when options.xml = true passed to html()', () => { const str = ''; // Since parsing done without xml flag, all tags converted to lowercase const expectedXml = ''; const expectedNoXml = ''; const $ = cheerio.load(str); expect($('MixedCaseTag').get(0)).toHaveProperty( 'tagName', 'mixedcasetag', ); expect($.html()).toBe(expectedNoXml); expect($.html({ xml: true })).toBe(expectedXml); }); it('should respect options on the element level', () => { const str = 'Some test'; const expectedHtml = '

'; const expectedXml = '

'; const domNotEncoded = cheerio.load(str, { xml: { decodeEntities: false }, }); const domEncoded = cheerio.load(str); expect(domNotEncoded('footer').html()).toBe(expectedHtml); expect(domEncoded('footer').html()).toBe(expectedXml); }); it('should use htmlparser2 if xml option is used', () => { const str = '

'; const dom = cheerio.load(str, null, false); expect(dom.html()).toBe(str); }); it('should return a fully-qualified Function', () => { const $ = cheerio.load('

'); expect($).toBeInstanceOf(Function); }); describe('prototype extensions', () => { it('should honor extensions defined on `prototype` property', () => { const $ = cheerio.load('

'); ($.prototype as Cheerio).myPlugin = function ( ...args: unknown[] ) { return { context: this, args, }; }; const $div = $('div'); expect(typeof $div.myPlugin).toBe('function'); expect($div.myPlugin().context).toBe($div); expect($div.myPlugin(1, 2, 3).args).toStrictEqual([1, 2, 3]); }); it('should honor extensions defined on `fn` property', () => { const $ = cheerio.load('

'); $.fn.myPlugin = function (...args: unknown[]) { return { context: this, args, }; }; const $div = $('div'); expect(typeof $div.myPlugin).toBe('function'); expect($div.myPlugin().context).toBe($div); expect($div.myPlugin(1, 2, 3).args).toStrictEqual([1, 2, 3]); }); it('should isolate extensions between loaded functions', () => { const $a = cheerio.load('

'); const $b = cheerio.load('

'); ($a.prototype as Cheerio).foo = function () { /* Ignore */ }; expect($b('div').foo).toBeUndefined(); }); }); }); describe('parse5 options', () => { // Should parse noscript tags only with false option value it('{scriptingEnabled: ???}', () => { // [default] `scriptingEnabled: true` - tag contains one text element const withScripts = cheerio.load(noscript)('noscript'); expect(withScripts).toHaveLength(1); expect(withScripts[0].children).toHaveLength(1); expect(withScripts[0].children[0].type).toBe('text'); // `scriptingEnabled: false` - content of noscript will parsed const noScripts = cheerio.load(noscript, { scriptingEnabled: false })( 'noscript', ); expect(noScripts).toHaveLength(1); expect(noScripts[0].children).toHaveLength(2); expect(noScripts[0].children[0].type).toBe('comment'); expect(noScripts[0].children[1].type).toBe('tag'); expect(noScripts[0].children[1]).toHaveProperty('name', 'a'); // `scriptingEnabled: ???` - should acts as true for (const val of [undefined, null, 0, '']) { const options = { scriptingEnabled: val as never }; const result = cheerio.load(noscript, options)('noscript'); expect(result).toHaveLength(1); expect(result[0].children).toHaveLength(1); expect(result[0].children[0].type).toBe('text'); } }); // Should contain location data only with truthful option value it('{sourceCodeLocationInfo: ???}', () => { // Location data should not be present for (const val of [undefined, null, 0, false, '']) { const options = { sourceCodeLocationInfo: val as never }; const result = cheerio.load(noscript, options)('noscript'); expect(result).toHaveLength(1); expect(result[0]).not.toHaveProperty('sourceCodeLocation'); } // Location data should be present for (const val of [true, 1, 'test']) { const options = { sourceCodeLocationInfo: val as never }; const result = cheerio.load(noscript, options)('noscript'); expect(result).toHaveLength(1); expect(result[0]).toHaveProperty('sourceCodeLocation'); expect(typeof result[0].sourceCodeLocation).toBe('object'); } }); }); }); /* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */ import type { InternalOptions } from './options.js'; import type { AnyNode, Document, ParentNode } from 'domhandler'; import type { BasicAcceptedElems } from './types.js'; import * as Attributes from './api/attributes.js'; import * as Traversing from './api/traversing.js'; import * as Manipulation from './api/manipulation.js'; import * as Css from './api/css.js'; import * as Forms from './api/forms.js'; import * as Extract from './api/extract.js'; type MethodsType = typeof Attributes & typeof Traversing & typeof Manipulation & typeof Css & typeof Forms & typeof Extract; /** * 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: * * ```html *

Apple
Orange
Pear

* ``` */ export abstract class Cheerio implements ArrayLike { length = 0; [index: number]: T; options: InternalOptions; /** * The root of the document. Can be set by using the `root` argument of the * constructor. * * @private */ _root: Cheerio | null; /** * Instance of cheerio. Methods are specified in the modules. Usage of this * constructor is not recommended. Please use `$.load` instead. * * @private * @param elements - The new selection. * @param root - Sets the root node. * @param options - Options for the instance. */ constructor( elements: ArrayLike | undefined, root: Cheerio | null, options: InternalOptions, ) { this.options = options; this._root = root; if (elements) { for (let idx = 0; idx < elements.length; idx++) { this[idx] = elements[idx]; } this.length = elements.length; } } prevObject: Cheerio | undefined; /** * Make a cheerio object. * * @private * @param dom - The contents of the new object. * @param context - The context of the new object. * @returns The new cheerio object. */ abstract _make( dom: ArrayLike | T | string, context?: BasicAcceptedElems, ): Cheerio; /** * Parses some content. * * @private * @param content - Content to parse. * @param options - Options for parsing. * @param isDocument - Allows parser to be switched to fragment mode. * @returns A document containing the `content`. */ abstract _parse( content: string | Document | AnyNode | AnyNode[] | Buffer, options: InternalOptions, isDocument: boolean, context: ParentNode | null, ): Document; /** * Render an element or a set of elements. * * @private * @param dom - DOM to render. * @returns The rendered DOM. */ abstract _render(dom: AnyNode | ArrayLike): string; } export interface Cheerio extends MethodsType, Iterable { cheerio: '[cheerio object]'; splice: typeof Array.prototype.splice; } /** Set a signature of the object. */ Cheerio.prototype.cheerio = '[cheerio object]'; /* * Make cheerio an array-like object */ Cheerio.prototype.splice = Array.prototype.splice; // Support for (const element of $(...)) iteration: Cheerio.prototype[Symbol.iterator] = Array.prototype[Symbol.iterator]; // Plug in the API Object.assign( Cheerio.prototype, Attributes, Traversing, Manipulation, Css, Forms, Extract, ); export type * from './types.js'; export type { Cheerio, CheerioAPI, CheerioOptions, HTMLParser2Options, } from './slim.js'; export { contains, merge } from './static.js'; export * from './load-parse.js'; import { describe, it, expect, afterEach } from 'vitest'; import * as cheerio from './index.js'; import { Writable } from 'node:stream'; import { createServer, type Server, type RequestListener } from 'node:http'; function noop() { // Ignore } // Returns a promise and a resolve function function getPromise() { let cb!: (error: Error | null | undefined, $: cheerio.CheerioAPI) => void; const promise = new Promise((resolve, reject) => { cb = (error, $) => (error ? reject(error) : resolve($)); }); return { promise, cb }; } const TEST_HTML = '

Hello World

'; const TEST_HTML_UTF16 = Buffer.from(TEST_HTML, 'utf16le'); const TEST_HTML_UTF16_BOM = Buffer.from([ // UTF16-LE BOM 0xff, 0xfe, ...Array.from(TEST_HTML_UTF16), ]); describe('loadBuffer', () => { it('should parse UTF-8 HTML', () => { const $ = cheerio.loadBuffer(Buffer.from(TEST_HTML)); expect($.html()).toBe( `${TEST_HTML}`, ); }); it('should parse UTF-16 HTML', () => { const $ = cheerio.loadBuffer(TEST_HTML_UTF16_BOM); expect($.html()).toBe( `${TEST_HTML}`, ); }); }); describe('stringStream', () => { it('should use parse5 by default', async () => { const { promise, cb } = getPromise(); const stream = cheerio.stringStream({}, cb); expect(stream).toBeInstanceOf(Writable); stream.end(TEST_HTML); const $ = await promise; expect($.html()).toBe( `${TEST_HTML}`, ); }); it('should error from parse5 on buffer', () => { const stream = cheerio.stringStream({}, noop); expect(stream).toBeInstanceOf(Writable); expect(() => stream.write(Buffer.from(TEST_HTML))).toThrow( 'Parser can work only with string streams.', ); }); it('should use htmlparser2 for XML', async () => { const { promise, cb } = getPromise(); const stream = cheerio.stringStream({ xmlMode: true }, cb); expect(stream).toBeInstanceOf(Writable); stream.end(TEST_HTML); const $ = await promise; expect($.html()).toBe(TEST_HTML); }); }); describe('decodeStream', () => { it('should use parse5 by default', async () => { const { promise, cb } = getPromise(); const stream = cheerio.decodeStream({}, cb); expect(stream).toBeInstanceOf(Writable); stream.end(TEST_HTML_UTF16_BOM); const $ = await promise; expect($.html()).toBe( `${TEST_HTML}`, ); }); it('should use htmlparser2 for XML', async () => { const { promise, cb } = getPromise(); const stream = cheerio.decodeStream({ xmlMode: true }, cb); expect(stream).toBeInstanceOf(Writable); stream.end(TEST_HTML_UTF16_BOM); const $ = await promise; expect($.html()).toBe(TEST_HTML); }); }); describe('fromURL', () => { let server: Server | undefined; function createTestServer( contentType: string, body: string | Buffer, handler: RequestListener = (_req, res) => { res.writeHead(200, { 'Content-Type': contentType }); res.end(body); }, ): Promise { return new Promise((resolve, reject) => { server = createServer(handler); server.listen(0, () => { const address = server?.address(); if (typeof address === 'string' || address == null) { reject(new Error('Failed to get port')); } else { resolve(address.port); } }); }); } afterEach( async () => new Promise((resolve, reject) => { if (server) { server.close((err) => (err ? reject(err) : resolve())); server = undefined; } else { resolve(); } }), ); it('should fetch UTF-8 HTML', async () => { const port = await createTestServer('text/html', TEST_HTML); const $ = await cheerio.fromURL(`http://localhost:${port}`); expect($.html()).toBe( `${TEST_HTML}`, ); }); it('should fetch UTF-16 HTML', async () => { const port = await createTestServer( 'text/html; charset=utf-16le', TEST_HTML_UTF16, ); const $ = await cheerio.fromURL(`http://localhost:${port}`); expect($.html()).toBe( `${TEST_HTML}`, ); }); it('should parse XML based on Content-Type', async () => { const port = await createTestServer('text/xml', TEST_HTML); const $ = await cheerio.fromURL(`http://localhost:${port}`); expect($.html()).toBe(TEST_HTML); }); it('should throw on non-HTML/XML Content-Type', async () => { const port = await createTestServer('text/plain', TEST_HTML); await expect(cheerio.fromURL(`http://localhost:${port}`)).rejects.toThrow( 'The content-type "text/plain" is neither HTML nor XML.', ); }); it('should throw on non-2xx responses', async () => { const port = await createTestServer('text/html', TEST_HTML, (_, res) => { res.writeHead(500); res.end(); }); await expect(cheerio.fromURL(`http://localhost:${port}`)).rejects.toThrow( 'Response Error', ); }); it('should follow redirects', async () => { let redirected = false; const port = await createTestServer('text/html', TEST_HTML, (req, res) => { if (redirected) { expect(req.url).toBe('/final'); res.writeHead(200, { 'Content-Type': 'text/html' }); res.end(TEST_HTML); } else { redirected = true; res.writeHead(302, { Location: `http://localhost:${port}/final` }); res.end(); } }); const $ = await cheerio.fromURL(`http://localhost:${port}`); expect($.html()).toBe( `${TEST_HTML}`, ); }); }); /** * @file Batteries-included version of Cheerio. This module includes several * convenience methods for loading documents from various sources. */ export * from './load-parse.js'; export { contains, merge } from './static.js'; export type * from './types.js'; export type { Cheerio, CheerioAPI, CheerioOptions, HTMLParser2Options, } from './slim.js'; import { adapter as htmlparser2Adapter } from 'parse5-htmlparser2-tree-adapter'; import * as htmlparser2 from 'htmlparser2'; import { ParserStream as Parse5Stream } from 'parse5-parser-stream'; import { decodeBuffer, DecodeStream, type SnifferOptions, } from 'encoding-sniffer'; import * as undici from 'undici'; import MIMEType from 'whatwg-mimetype'; import { Writable, finished } from 'node:stream'; import type { CheerioAPI } from './load.js'; import { flattenOptions, type InternalOptions, type CheerioOptions, } from './options.js'; import { load } from './load-parse.js'; /** * Sniffs the encoding of a buffer, then creates a querying function bound to a * document created from the buffer. * * @category Loading * @example * * ```js * import * as cheerio from 'cheerio'; * * const buffer = fs.readFileSync('index.html'); * const $ = cheerio.loadBuffer(buffer); * ``` * * @param buffer - The buffer to sniff the encoding of. * @param options - The options to pass to Cheerio. * @returns The loaded document. */ export function loadBuffer( buffer: Buffer, options: DecodeStreamOptions = {}, ): CheerioAPI { const opts = flattenOptions(options); const str = decodeBuffer(buffer, { defaultEncoding: opts?.xmlMode ? 'utf8' : 'windows-1252', ...options.encoding, }); return load(str, opts); } function _stringStream( options: InternalOptions | undefined, cb: (err: Error | null | undefined, $: CheerioAPI) => void, ): Writable { if (options?._useHtmlParser2) { const parser = htmlparser2.createDocumentStream( (err, document) => cb(err, load(document)), options, ); return new Writable({ decodeStrings: false, write(chunk, _encoding, callback) { if (typeof chunk !== 'string') { throw new TypeError('Expected a string'); } parser.write(chunk); callback(); }, final(callback) { parser.end(); callback(); }, }); } options ??= {}; options.treeAdapter ??= htmlparser2Adapter; if (options.scriptingEnabled !== false) { options.scriptingEnabled = true; } const stream = new Parse5Stream(options); finished(stream, (err) => cb(err, load(stream.document))); return stream; } /** * Creates a stream that parses a sequence of strings into a document. * * The stream is a `Writable` stream that accepts strings. When the stream is * finished, the callback is called with the loaded document. * * @category Loading * @example * * ```js * import * as cheerio from 'cheerio'; * import * as fs from 'fs'; * * const writeStream = cheerio.stringStream({}, (err, $) => { * if (err) { * // Handle error * } * * console.log($('h1').text()); * // Output: Hello, world! * }); * * fs.createReadStream('my-document.html', { encoding: 'utf8' }).pipe( * writeStream, * ); * ``` * * @param options - The options to pass to Cheerio. * @param cb - The callback to call when the stream is finished. * @returns The writable stream. */ export function stringStream( options: CheerioOptions, cb: (err: Error | null | undefined, $: CheerioAPI) => void, ): Writable { return _stringStream(flattenOptions(options), cb); } export interface DecodeStreamOptions extends CheerioOptions { encoding?: SnifferOptions; } /** * Parses a stream of buffers into a document. * * The stream is a `Writable` stream that accepts buffers. When the stream is * finished, the callback is called with the loaded document. * * @category Loading * @param options - The options to pass to Cheerio. * @param cb - The callback to call when the stream is finished. * @returns The writable stream. */ export function decodeStream( options: DecodeStreamOptions, cb: (err: Error | null | undefined, $: CheerioAPI) => void, ): Writable { const { encoding = {}, ...cheerioOptions } = options; const opts = flattenOptions(cheerioOptions); // Set the default encoding to UTF-8 for XML mode encoding.defaultEncoding ??= opts?.xmlMode ? 'utf8' : 'windows-1252'; const decodeStream = new DecodeStream(encoding); const loadStream = _stringStream(opts, cb); decodeStream.pipe(loadStream); return decodeStream; } type UndiciStreamOptions = Omit< undici.Dispatcher.RequestOptions, 'path' >; export interface CheerioRequestOptions extends DecodeStreamOptions { /** The options passed to `undici`'s `stream` method. */ requestOptions?: UndiciStreamOptions; } const defaultRequestOptions: UndiciStreamOptions = { method: 'GET', // Set an Accept header headers: { accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', }, }; /** * `fromURL` loads a document from a URL. * * By default, redirects are allowed and non-2xx responses are rejected. * * @category Loading * @example * * ```js * import * as cheerio from 'cheerio'; * * const $ = await cheerio.fromURL('https://example.com'); * ``` * * @param url - The URL to load the document from. * @param options - The options to pass to Cheerio. * @returns The loaded document. */ export async function fromURL( url: string | URL, options: CheerioRequestOptions = {}, ): Promise { const { requestOptions = defaultRequestOptions, encoding = {}, ...cheerioOptions } = options; let undiciStream: Promise> | undefined; // Add headers if none were supplied. const urlObject = typeof url === 'string' ? new URL(url) : url; const streamOptions = { headers: defaultRequestOptions.headers, path: urlObject.pathname + urlObject.search, ...requestOptions, }; const promise = new Promise((resolve, reject) => { undiciStream = new undici.Client(url) .compose(undici.interceptors.redirect({ maxRedirections: 5 })) .stream(streamOptions, (res) => { if (res.statusCode < 200 || res.statusCode >= 300) { throw new undici.errors.ResponseError( 'Response Error', res.statusCode, { headers: res.headers, }, ); } const contentTypeHeader = res.headers['content-type'] ?? 'text/html'; const mimeType = new MIMEType( Array.isArray(contentTypeHeader) ? contentTypeHeader[0] : contentTypeHeader, ); if (!mimeType.isHTML() && !mimeType.isXML()) { throw new RangeError( `The content-type "${mimeType.essence}" is neither HTML nor XML.`, ); } // Forward the charset from the header to the decodeStream. encoding.transportLayerEncodingLabel = mimeType.parameters.get('charset'); /* * If we allow redirects, we will have entries in the history. * The last entry will be the final URL. */ const history = ( res.context as | { history?: URL[]; } | undefined )?.history; const opts = { encoding, // Set XML mode based on the MIME type. xmlMode: mimeType.isXML(), // Set the `baseURL` to the final URL. baseURL: history ? history[history.length - 1] : url, ...cheerioOptions, }; return decodeStream(opts, (err, $) => (err ? reject(err) : resolve($))); }); }); // Let's make sure the request is completed before returning the promise. await undiciStream; return promise; } import { type CheerioAPI, getLoad } from './load.js'; import { getParse } from './parse.js'; import { renderWithParse5, parseWithParse5 } from './parsers/parse5-adapter.js'; import type { CheerioOptions } from './options.js'; import renderWithHtmlparser2 from 'dom-serializer'; import { parseDocument as parseWithHtmlparser2 } from 'htmlparser2'; import type { AnyNode } from 'domhandler'; const parse = getParse((content, options, isDocument, context) => options._useHtmlParser2 ? parseWithHtmlparser2(content, options) : parseWithParse5(content, options, isDocument, context), ); // Duplicate docs due to https://github.com/TypeStrong/typedoc/issues/1616 /** * Create a querying function, bound to a document created from the provided * markup. * * Note that similar to web browser contexts, this operation may introduce * ``, ``, and `` elements; set `isDocument` to `false` to * switch to fragment mode and disable this. * * @category Loading * @param content - Markup to be loaded. * @param options - Options for the created instance. * @param isDocument - Allows parser to be switched to fragment mode. * @returns The loaded document. * @see {@link https://cheerio.js.org/docs/basics/loading#load} for additional usage information. */ export const load: ( content: string | AnyNode | AnyNode[] | Buffer, options?: CheerioOptions | null, isDocument?: boolean, ) => CheerioAPI = getLoad(parse, (dom, options) => options._useHtmlParser2 ? renderWithHtmlparser2(dom, options) : renderWithParse5(dom), ); import { describe, it, expect } from 'vitest'; import { load } from './index.js'; describe('.load', () => { it('(html) : should retain original root after creating a new node', () => { const $ = load('

'); expect($('body')).toHaveLength(1); $('', { xml: true, }); expect($('script')[0].children[0].type).toBe('tag'); }); it('(buffer) : should accept a buffer', () => { const html = 'foo'; const $html = load(Buffer.from(html)); expect($html.html()).toBe(html); }); }); import { type CheerioOptions, type InternalOptions, flattenOptions, } from './options.js'; import * as staticMethods from './static.js'; import { Cheerio } from './cheerio.js'; import { isHtml, isCheerio } from './utils.js'; import type { AnyNode, Document, Element, ParentNode } from 'domhandler'; import type { SelectorType, BasicAcceptedElems } from './types.js'; import { ElementType } from 'htmlparser2'; type StaticType = typeof staticMethods; /** * A querying function, bound to a document created from the provided markup. * * Also provides several helper methods for dealing with the document as a * whole. */ export interface CheerioAPI extends StaticType { /** * This selector method is the starting point for traversing and manipulating * the document. Like jQuery, it's the primary method for selecting elements * in the document. * * `selector` searches within the `context` scope, which searches within the * `root` scope. * * @example * * ```js * $('ul .pear').attr('class'); * //=> pear * * $('li[class=orange]').html(); * //=> Orange * * $('.apple', '#fruits').text(); * //=> Apple * ``` * * Optionally, you can also load HTML by passing the string as the selector: * * ```js * $('

...'); * ``` * * Or the context: * * ```js * $('ul', '

...'); * ``` * * Or as the root: * * ```js * $('li', 'ul', '

...'); * ``` * * @param selector - Either a selector to look for within the document, or the * contents of a new Cheerio instance. * @param context - Either a selector to look for within the root, or the * contents of the document to query. * @param root - Optional HTML document string. */ ( selector?: S | BasicAcceptedElems, context?: BasicAcceptedElems | null, root?: BasicAcceptedElems, options?: CheerioOptions, ): Cheerio; /** * The root the document was originally loaded with. * * @private */ _root: Document; /** * The options the document was originally loaded with. * * @private */ _options: InternalOptions; /** Mimic jQuery's prototype alias for plugin authors. */ fn: typeof Cheerio.prototype; /** * The `.load` static method defined on the "loaded" Cheerio factory function * is deprecated. Users are encouraged to instead use the `load` function * exported by the Cheerio module. * * @deprecated Use the `load` function exported by the Cheerio module. * @category Deprecated * @example * * ```js * const $ = cheerio.load('
Hello, world.
'); * ``` */ load: ReturnType; } export function getLoad( parse: Cheerio['_parse'], render: ( dom: AnyNode | ArrayLike, options: InternalOptions, ) => string, ) { /** * Create a querying function, bound to a document created from the provided * markup. * * Note that similar to web browser contexts, this operation may introduce * ``, ``, and `` elements; set `isDocument` to `false` to * switch to fragment mode and disable this. * * @param content - Markup to be loaded. * @param options - Options for the created instance. * @param isDocument - Allows parser to be switched to fragment mode. * @returns The loaded document. * @see {@link https://cheerio.js.org/docs/basics/loading#load} for additional usage information. */ return function load( content: string | AnyNode | AnyNode[] | Buffer, options?: CheerioOptions | null, isDocument = true, ): CheerioAPI { if ((content as string | null) == null) { throw new Error('cheerio.load() expects a string'); } const internalOpts = flattenOptions(options); const initialRoot = parse(content, internalOpts, isDocument, null); /** * Create an extended class here, so that extensions only live on one * instance. */ class LoadedCheerio extends Cheerio { _make( selector?: ArrayLike | T | string, context?: BasicAcceptedElems | null, ): Cheerio { const cheerio = initialize(selector, context); cheerio.prevObject = this; return cheerio; } _parse( content: string | Document | AnyNode | AnyNode[] | Buffer, options: InternalOptions, isDocument: boolean, context: ParentNode | null, ) { return parse(content, options, isDocument, context); } _render(dom: AnyNode | ArrayLike): string { return render(dom, this.options); } } function initialize( selector?: ArrayLike | T | S, context?: BasicAcceptedElems | null, root: BasicAcceptedElems = initialRoot, opts?: CheerioOptions, ): Cheerio { type Result = S extends SelectorType ? Element : T; // $($) if (selector && isCheerio(selector)) return selector; const options = flattenOptions(opts, internalOpts); const r = typeof root === 'string' ? [parse(root, options, false, null)] : 'length' in root ? root : [root]; const rootInstance = isCheerio(r) ? r : new LoadedCheerio(r, null, options); // Add a cyclic reference, so that calling methods on `_root` never fails. rootInstance._root = rootInstance; // $(), $(null), $(undefined), $(false) if (!selector) { return new LoadedCheerio(undefined, rootInstance, options); } const elements: AnyNode[] | undefined = typeof selector === 'string' && isHtml(selector) ? // $() parse(selector, options, false, null).children : isNode(selector) ? // $(dom) [selector] : Array.isArray(selector) ? // $([dom]) selector : undefined; const instance = new LoadedCheerio(elements, rootInstance, options); if (elements) { return instance as Cheerio; } if (typeof selector !== 'string') { throw new TypeError('Unexpected type of selector'); } // We know that our selector is a string now. let search = selector; const searchContext: Cheerio | undefined = context ? // If we don't have a context, maybe we have a root, from loading typeof context === 'string' ? isHtml(context) ? // $('li', '
...
') new LoadedCheerio( [parse(context, options, false, null)], rootInstance, options, ) : // $('li', 'ul') ((search = `${context} ${search}` as S), rootInstance) : isCheerio(context) ? // $('li', $) context : // $('li', node), $('li', [nodes]) new LoadedCheerio( Array.isArray(context) ? context : [context], rootInstance, options, ) : rootInstance; // If we still don't have a context, return if (!searchContext) return instance as Cheerio; /* * #id, .class, tag */ return searchContext.find(search) as Cheerio; } // Add in static methods & properties Object.assign(initialize, staticMethods, { load, // `_root` and `_options` are used in static methods. _root: initialRoot, _options: internalOpts, // Add `fn` for plugins fn: LoadedCheerio.prototype, // Add the prototype here to maintain `instanceof` behavior. prototype: LoadedCheerio.prototype, }); return initialize as CheerioAPI; }; } function isNode(obj: unknown): obj is AnyNode { return ( // @ts-expect-error: TS doesn't know about the `name` property. !!obj.name || // @ts-expect-error: TS doesn't know about the `type` property. obj.type === ElementType.Root || // @ts-expect-error: TS doesn't know about the `type` property. obj.type === ElementType.Text || // @ts-expect-error: TS doesn't know about the `type` property. obj.type === ElementType.Comment ); } import type { DomHandlerOptions } from 'domhandler'; import type { ParserOptions as HTMLParser2ParserOptions } from 'htmlparser2'; import type { ParserOptions as Parse5ParserOptions } from 'parse5'; import type { Htmlparser2TreeAdapterMap } from 'parse5-htmlparser2-tree-adapter'; import type { Options as SelectOptions } from 'cheerio-select'; import type { DomSerializerOptions } from 'dom-serializer'; /** * Options accepted by htmlparser2, the default parser for XML. * * @see https://github.com/fb55/htmlparser2/wiki/Parser-options */ export interface HTMLParser2Options extends DomHandlerOptions, DomSerializerOptions, HTMLParser2ParserOptions { /** Treat the input as an XML document. */ xmlMode?: boolean; } /** * Options accepted by Cheerio. * * Please note that parser-specific options are _only recognized_ if the * relevant parser is used. */ export interface CheerioOptions extends Parse5ParserOptions { /** * Recommended way of configuring htmlparser2 when wanting to parse XML. * * This will switch Cheerio to use htmlparser2. * * @default false */ xml?: HTMLParser2Options | boolean; /** * Enable xml mode, which will switch Cheerio to use htmlparser2. * * @deprecated Please use the `xml` option instead. * @default false */ xmlMode?: boolean; /** The base URI for the document. Used to resolve the `href` and `src` props. */ baseURI?: string | URL; /** * Is the document in quirks mode? * * This will lead to `.className` and `#id` being case-insensitive. * * @default false */ quirksMode?: SelectOptions['quirksMode']; /** * Extension point for pseudo-classes. * * Maps from names to either strings of functions. * * - A string value is a selector that the element must match to be selected. * - A function is called with the element as its first argument, and optional * parameters second. If it returns true, the element is selected. * * @example * * ```js * const $ = cheerio.load( * '
', * { * pseudos: { * // `:foo` is an alias for `div.foo` * foo: 'div.foo', * // `:bar(val)` is equivalent to `[data-bar=val s]` * bar: (el, val) => el.attribs['data-bar'] === val, * }, * }, * ); * * $(':foo').length; // 1 * $('div:bar(boo)').length; // 1 * $('div:bar(baz)').length; // 0 * ``` */ pseudos?: SelectOptions['pseudos']; } /** Internal options for Cheerio. */ export interface InternalOptions extends HTMLParser2Options, Omit { /** * Whether to use htmlparser2. * * This is set to true if `xml` is set to true. */ _useHtmlParser2?: boolean; } const defaultOpts: InternalOptions = { _useHtmlParser2: false, }; /** * Flatten the options for Cheerio. * * This will set `_useHtmlParser2` to true if `xml` is set to true. * * @param options - The options to flatten. * @param baseOptions - The base options to use. * @returns The flattened options. */ export function flattenOptions( options?: CheerioOptions | null, baseOptions?: InternalOptions, ): InternalOptions { if (!options) { return baseOptions ?? defaultOpts; } const opts: InternalOptions = { _useHtmlParser2: !!options.xmlMode, ...baseOptions, ...options, }; if (options.xml) { opts._useHtmlParser2 = true; opts.xmlMode = true; if (options.xml !== true) { Object.assign(opts, options.xml); } } else if (options.xmlMode) { opts._useHtmlParser2 = true; } return opts; } import { describe, it, expect } from 'vitest'; import type { Document, Element } from 'domhandler'; import { getParse } from './parse.js'; import { parseDocument as parseWithHtmlparser2 } from 'htmlparser2'; import { parseWithParse5 } from './parsers/parse5-adapter.js'; const defaultOpts = { _useHtmlParser2: false }; const parse = getParse((content, options, isDocument, context) => options._useHtmlParser2 ? parseWithHtmlparser2(content, options) : parseWithParse5(content, options, isDocument, context), ); // Tags const basic = ''; const siblings = '
'; // Single Tags const single = '
'; const singleWrong = '
'; // Children const children = '
'; const li = '
Durian
'; // Attributes const attributes = ''; const noValueAttribute = ''; // Comments const comment = ''; const conditional = ''; // Text const text = 'lorem ipsum'; // Script const script = ''; const scriptEmpty = ''; // Style const style = ''; const styleEmpty = ''; // Directives const directive = ''; function rootTest(root: Document) { expect(root).toHaveProperty('type', 'root'); expect(root.nextSibling).toBe(null); expect(root.previousSibling).toBe(null); expect(root.parentNode).toBe(null); const child = root.childNodes[0]; expect(child.parentNode).toBe(root); } describe('parse', () => { describe('evaluate', () => { it(`should parse basic empty tags: ${basic}`, () => { const [tag] = parse(basic, defaultOpts, true, null).children as Element[]; expect(tag.type).toBe('tag'); expect(tag.tagName).toBe('html'); expect(tag.childNodes).toHaveLength(2); }); it(`should handle sibling tags: ${siblings}`, () => { const dom = parse(siblings, defaultOpts, false, null) .children as Element[]; const [h2, p] = dom; expect(dom).toHaveLength(2); expect(h2.tagName).toBe('h2'); expect(p.tagName).toBe('p'); }); it(`should handle single tags: ${single}`, () => { const [tag] = parse(single, defaultOpts, false, null) .children as Element[]; expect(tag.type).toBe('tag'); expect(tag.tagName).toBe('br'); expect(tag.childNodes).toHaveLength(0); }); it(`should handle malformatted single tags: ${singleWrong}`, () => { const [tag] = parse(singleWrong, defaultOpts, false, null) .children as Element[]; expect(tag.type).toBe('tag'); expect(tag.tagName).toBe('br'); expect(tag.childNodes).toHaveLength(0); }); it(`should handle tags with children: ${children}`, () => { const [tag] = parse(children, defaultOpts, true, null) .children as Element[]; expect(tag.type).toBe('tag'); expect(tag.tagName).toBe('html'); expect(tag.childNodes).toBeTruthy(); expect(tag.childNodes[1]).toHaveProperty('tagName', 'body'); expect((tag.childNodes[1] as Element).childNodes).toHaveLength(1); }); it(`should handle tags with children: ${li}`, () => { const [tag] = parse(li, defaultOpts, false, null).children as Element[]; expect(tag.childNodes).toHaveLength(1); expect(tag.childNodes[0]).toHaveProperty('data', 'Durian'); }); it(`should handle tags with attributes: ${attributes}`, () => { const attrs = parse(attributes, defaultOpts, false, null) .children[0] as Element; expect(attrs.attribs).toBeTruthy(); expect(attrs.attribs).toHaveProperty('src', 'hello.png'); expect(attrs.attribs).toHaveProperty('alt', 'man waving'); }); it(`should handle value-less attributes: ${noValueAttribute}`, () => { const attrs = parse(noValueAttribute, defaultOpts, false, null) .children[0] as Element; expect(attrs.attribs).toBeTruthy(); expect(attrs.attribs).toHaveProperty('disabled', ''); }); it(`should handle comments: ${comment}`, () => { const elem = parse(comment, defaultOpts, false, null).children[0]; expect(elem.type).toBe('comment'); expect(elem).toHaveProperty('data', ' sexy '); }); it(`should handle conditional comments: ${conditional}`, () => { const elem = parse(conditional, defaultOpts, false, null).children[0]; expect(elem.type).toBe('comment'); expect(elem).toHaveProperty( 'data', conditional.replace('', ''), ); }); it(`should handle text: ${text}`, () => { const text_ = parse(text, defaultOpts, false, null).children[0]; expect(text_.type).toBe('text'); expect(text_).toHaveProperty('data', 'lorem ipsum'); }); it(`should handle script tags: ${script}`, () => { const script_ = parse(script, defaultOpts, false, null) .children[0] as Element; expect(script_.type).toBe('script'); expect(script_.tagName).toBe('script'); expect(script_.attribs).toHaveProperty('type', 'text/javascript'); expect(script_.childNodes).toHaveLength(1); expect(script_.childNodes[0].type).toBe('text'); expect(script_.childNodes[0]).toHaveProperty( 'data', 'alert("hi world!");', ); }); it(`should handle style tags: ${style}`, () => { const style_ = parse(style, defaultOpts, false, null) .children[0] as Element; expect(style_.type).toBe('style'); expect(style_.tagName).toBe('style'); expect(style_.attribs).toHaveProperty('type', 'text/css'); expect(style_.childNodes).toHaveLength(1); expect(style_.childNodes[0].type).toBe('text'); expect(style_.childNodes[0]).toHaveProperty( 'data', ' h2 { color:blue; } ', ); }); it(`should handle directives: ${directive}`, () => { const elem = parse(directive, defaultOpts, true, null).children[0]; expect(elem.type).toBe('directive'); expect(elem).toHaveProperty('data', '!DOCTYPE html'); expect(elem).toHaveProperty('name', '!doctype'); }); }); describe('.parse', () => { // Root test utility it(`should add root to: ${basic}`, () => { const root = parse(basic, defaultOpts, true, null); rootTest(root); expect(root.childNodes).toHaveLength(1); expect(root.childNodes[0]).toHaveProperty('tagName', 'html'); }); it(`should add root to: ${siblings}`, () => { const root = parse(siblings, defaultOpts, false, null); rootTest(root); expect(root.childNodes).toHaveLength(2); expect(root.childNodes[0]).toHaveProperty('tagName', 'h2'); expect(root.childNodes[1]).toHaveProperty('tagName', 'p'); expect(root.childNodes[1].parent).toBe(root); }); it(`should add root to: ${comment}`, () => { const root = parse(comment, defaultOpts, false, null); rootTest(root); expect(root.childNodes).toHaveLength(1); expect(root.childNodes[0].type).toBe('comment'); }); it(`should add root to: ${text}`, () => { const root = parse(text, defaultOpts, false, null); rootTest(root); expect(root.childNodes).toHaveLength(1); expect(root.childNodes[0].type).toBe('text'); }); it(`should add root to: ${scriptEmpty}`, () => { const root = parse(scriptEmpty, defaultOpts, false, null); rootTest(root); expect(root.childNodes).toHaveLength(1); expect(root.childNodes[0].type).toBe('script'); }); it(`should add root to: ${styleEmpty}`, () => { const root = parse(styleEmpty, defaultOpts, false, null); rootTest(root); expect(root.childNodes).toHaveLength(1); expect(root.childNodes[0].type).toBe('style'); }); it(`should add root to: ${directive}`, () => { const root = parse(directive, defaultOpts, true, null); rootTest(root); expect(root.childNodes).toHaveLength(2); expect(root.childNodes[0].type).toBe('directive'); }); it('should simply return root', () => { const oldroot = parse(basic, defaultOpts, true, null); const root = parse(oldroot, defaultOpts, true, null); expect(root).toBe(oldroot); rootTest(root); expect(root.childNodes).toHaveLength(1); expect(root.childNodes[0]).toHaveProperty('tagName', 'html'); }); it('should expose the DOM level 1 API', () => { const root = parse( '
', defaultOpts, false, null, ).childNodes[0] as Element; const childNodes = root.childNodes as Element[]; expect(childNodes).toHaveLength(3); expect(root.tagName).toBe('div'); expect(root.firstChild).toBe(childNodes[0]); expect(root.lastChild).toBe(childNodes[2]); expect(childNodes[0].tagName).toBe('a'); expect(childNodes[0].previousSibling).toBe(null); expect(childNodes[0].nextSibling).toBe(childNodes[1]); expect(childNodes[0].parentNode).toBe(root); expect(childNodes[0].childNodes).toHaveLength(0); expect(childNodes[0].firstChild).toBe(null); expect(childNodes[0].lastChild).toBe(null); expect(childNodes[1].tagName).toBe('span'); expect(childNodes[1].previousSibling).toBe(childNodes[0]); expect(childNodes[1].nextSibling).toBe(childNodes[2]); expect(childNodes[1].parentNode).toBe(root); expect(childNodes[1].childNodes).toHaveLength(0); expect(childNodes[1].firstChild).toBe(null); expect(childNodes[1].lastChild).toBe(null); expect(childNodes[2].tagName).toBe('p'); expect(childNodes[2].previousSibling).toBe(childNodes[1]); expect(childNodes[2].nextSibling).toBe(null); expect(childNodes[2].parentNode).toBe(root); expect(childNodes[2].childNodes).toHaveLength(0); expect(childNodes[2].firstChild).toBe(null); expect(childNodes[2].lastChild).toBe(null); }); it('Should parse less than or equal sign sign', () => { const root = parse('A<=B', defaultOpts, false, null); const { childNodes } = root; expect(childNodes[0]).toHaveProperty('tagName', 'i'); expect((childNodes[0] as Element).childNodes[0]).toHaveProperty( 'data', 'A', ); expect(childNodes[1]).toHaveProperty('data', '<='); expect(childNodes[2]).toHaveProperty('tagName', 'i'); expect((childNodes[2] as Element).childNodes[0]).toHaveProperty( 'data', 'B', ); }); it('Should ignore unclosed CDATA', () => { const root = parse( '', defaultOpts, false, null, ); const childNodes = root.childNodes as Element[]; expect(childNodes[0].tagName).toBe('a'); expect(childNodes[1].tagName).toBe('script'); expect(childNodes[1].childNodes[0]).toHaveProperty( 'data', 'foo // to documents', () => { const root = parse('', defaultOpts, true, null); const childNodes = root.childNodes as Element[]; expect(childNodes[0].tagName).toBe('html'); expect(childNodes[0].childNodes[0]).toHaveProperty('tagName', 'head'); }); it('Should implicitly create around ', () => { const root = parse( '
bar
', defaultOpts, false, null, ); const table = root.childNodes[0] as Element; expect(table.tagName).toBe('table'); expect(table.childNodes.length).toBe(1); const tbody = table.childNodes[0] as Element; expect(table.childNodes[0]).toHaveProperty('tagName', 'tbody'); const tr = tbody.childNodes[0] as Element; expect(tr).toHaveProperty('tagName', 'tr'); const td = tr.childNodes[0] as Element; expect(td).toHaveProperty('tagName', 'td'); expect(td.childNodes[0]).toHaveProperty('data', 'bar'); }); it('Should parse custom tag ', () => { const root = parse('test', defaultOpts, false, null); const childNodes = root.childNodes as Element[]; expect(childNodes.length).toBe(1); expect(childNodes[0].tagName).toBe('line'); expect(childNodes[0].childNodes[0]).toHaveProperty('data', 'test'); }); it('Should properly parse misnested table tags', () => { const root = parse( 'i1i2i3', defaultOpts, false, null, ); const childNodes = root.childNodes as Element[]; expect(childNodes.length).toBe(3); for (let i = 0; i < childNodes.length; i++) { const child = childNodes[i]; expect(child.tagName).toBe('tr'); expect(child.childNodes[0]).toHaveProperty('tagName', 'td'); expect((child.childNodes[0] as Element).childNodes[0]).toHaveProperty( 'data', `i${i + 1}`, ); } }); it('Should correctly parse data url attributes', () => { const html = '
'; const expectedAttr = 'font-family:"butcherman-caps"; src:url(data:font/opentype;base64,AAEA...);'; const root = parse(html, defaultOpts, false, null); const childNodes = root.childNodes as Element[]; expect(childNodes[0].attribs).toHaveProperty('style', expectedAttr); }); it('Should treat ', defaultOpts, false, null); const childNodes = root.childNodes as Element[]; expect(childNodes[0].childNodes[0]).toHaveProperty('data', '
'); }); it('Should correctly parse malformed numbered entities', () => { const root = parse('
z&#
', defaultOpts, false, null); const childNodes = root.childNodes as Element[]; expect(childNodes[0].childNodes[0]).toHaveProperty('data', 'z&#'); }); it('Should correctly parse mismatched headings', () => { const root = parse('
Test
', defaultOpts, false, null); const { childNodes } = root; expect(childNodes.length).toBe(2); expect(childNodes[0]).toHaveProperty('tagName', 'h2'); expect(childNodes[1]).toHaveProperty('tagName', 'div'); }); it('Should correctly parse tricky
content', () => { const root = parse( '
\nA <- factor(A, levels = c("c","a","b"))\n
', defaultOpts, false, null, ); const childNodes = root.childNodes as Element[]; expect(childNodes.length).toBe(1); expect(childNodes[0].tagName).toBe('pre'); expect(childNodes[0].childNodes[0]).toHaveProperty( 'data', 'A <- factor(A, levels = c("c","a","b"))\n', ); }); it('should pass the options for including the location info to parse5', () => { const root = parse( '
Hello
', { ...defaultOpts, sourceCodeLocationInfo: true }, false, null, ); const location = root.children[0].sourceCodeLocation; expect(typeof location).toBe('object'); expect(location?.endOffset).toBe(12); }); }); }); import { removeElement } from 'domutils'; import { type AnyNode, Document, type ParentNode, isDocument as checkIsDocument, } from 'domhandler'; import type { InternalOptions } from './options.js'; /** * Get the parse function with options. * * @param parser - The parser function. * @returns The parse function with options. */ export function getParse( parser: ( content: string, options: InternalOptions, isDocument: boolean, context: ParentNode | null, ) => Document, ) { /** * Parse a HTML string or a node. * * @param content - The HTML string or node. * @param options - The parser options. * @param isDocument - If `content` is a document. * @param context - The context node in the DOM tree. * @returns The parsed document node. */ return function parse( content: string | Document | AnyNode | AnyNode[] | Buffer, options: InternalOptions, isDocument: boolean, context: ParentNode | null, ): Document { if (typeof Buffer !== 'undefined' && Buffer.isBuffer(content)) { content = content.toString(); } if (typeof content === 'string') { return parser(content, options, isDocument, context); } const doc = content as AnyNode | AnyNode[] | Document; if (!Array.isArray(doc) && checkIsDocument(doc)) { // If `doc` is already a root, just return it return doc; } // Add conent to new root element const root = new Document([]); // Update the DOM using the root update(doc, root); return root; }; } /** * Update the dom structure, for one changed layer. * * @param newChilds - The new children. * @param parent - The new parent. * @returns The parent node. */ export function update( newChilds: AnyNode[] | AnyNode, parent: ParentNode | null, ): ParentNode | null { // Normalize const arr = Array.isArray(newChilds) ? newChilds : [newChilds]; // Update parent if (parent) { parent.children = arr; } else { parent = null; } // Update neighbors for (let i = 0; i < arr.length; i++) { const node = arr[i]; // Cleanly remove existing nodes from their previous structures. if (node.parent && node.parent.children !== arr) { removeElement(node); } if (parent) { node.prev = arr[i - 1] || null; node.next = arr[i + 1] || null; } else { node.prev = node.next = null; } node.parent = parent; } return parent; } /** * @file Alternative entry point for Cheerio that always uses htmlparser2. This * way, parse5 won't be loaded, saving some memory. */ import { type CheerioAPI, getLoad } from './load.js'; import { type CheerioOptions } from './options.js'; import { getParse } from './parse.js'; import type { AnyNode } from 'domhandler'; import render from 'dom-serializer'; import { parseDocument } from 'htmlparser2'; export { contains, merge } from './static.js'; export type * from './types.js'; export type { Cheerio } from './cheerio.js'; export type { CheerioOptions, HTMLParser2Options } from './options.js'; export type { CheerioAPI } from './load.js'; /** * Create a querying function, bound to a document created from the provided * markup. * * @param content - Markup to be loaded. * @param options - Options for the created instance. * @param isDocument - Always `false` here, as we are always using * `htmlparser2`. * @returns The loaded document. * @see {@link https://cheerio.js.org#loading} for additional usage information. */ export const load: ( content: string | AnyNode | AnyNode[] | Buffer, options?: CheerioOptions | null, isDocument?: boolean, ) => CheerioAPI = getLoad(getParse(parseDocument), render); import { describe, it, expect, beforeEach } from 'vitest'; import { cheerio, food, eleven } from './__fixtures__/fixtures.js'; import { type CheerioAPI } from './index.js'; describe('cheerio', () => { describe('.html', () => { it('() : should return innerHTML; $.html(obj) should return outerHTML', () => { const $div = cheerio( 'div', '
foobar
', ); const span = $div.children()[1]; expect(cheerio(span).html()).toBe('bar'); expect(cheerio.html(span)).toBe('bar'); }); it('() : should accept an object, an array, or a cheerio object', () => { const $span = cheerio('foo'); expect(cheerio.html($span[0])).toBe('foo'); expect(cheerio.html($span)).toBe('foo'); }); it('() : should be able to set to an empty string', () => { const $elem = cheerio('foo').html(''); expect(cheerio.html($elem)).toBe(''); }); it('() : does not render the root element', () => { const $ = cheerio.load(''); expect(cheerio.html($.root())).toBe( '', ); }); it('(, , ) : does not render the root element', () => { const $ = cheerio.load('
a div
a span'); const $collection = $('div').add($.root()).add('span'); const expected = '
a div
a span
a div
a span'; expect(cheerio.html($collection)).toBe(expected); }); it('() : does not crash with `null` as `this` value', () => { const { html } = cheerio; expect(html.call(null as never)).toBe(''); expect(html.call(null as never, '#nothing')).toBe(''); }); }); describe('.text', () => { it('(cheerio object) : should return the text contents of the specified elements', () => { const $ = cheerio.load('This is content.'); expect(cheerio.text($('a'))).toBe('This is content.'); }); it('(cheerio object) : should omit comment nodes', () => { const $ = cheerio.load( 'This is not a comment.', ); expect(cheerio.text($('a'))).toBe('This is not a comment.'); }); it('(cheerio object) : should include text contents of children recursively', () => { const $ = cheerio.load( 'This is
a child with another child and not a comment followed by one last child and some final
text.', ); expect(cheerio.text($('a'))).toBe( 'This is a child with another child and not a comment followed by one last child and some final text.', ); }); it('() : should return the rendered text content of the root', () => { const $ = cheerio.load( 'This is
a child with another child and not a comment followed by one last child and some final
text.', ); expect(cheerio.text($.root())).toBe( 'This is a child with another child and not a comment followed by one last child and some final text.', ); }); it('(cheerio object) : should not omit script tags', () => { const $ = cheerio.load(''); expect(cheerio.text($.root())).toBe('console.log("test")'); }); it('(cheerio object) : should omit style tags', () => { const $ = cheerio.load( '', ); expect($.text()).toBe('.cf-hidden { display: none; }'); }); it('() : does not crash with `null` as `this` value', () => { const { text } = cheerio; expect(text.call(null as never)).toBe(''); }); }); describe('.parseHTML', () => { const $ = cheerio.load(''); it('() : returns null', () => { expect($.parseHTML()).toBe(null); }); it('(null) : returns null', () => { expect($.parseHTML(null)).toBe(null); }); it('("") : returns null', () => { expect($.parseHTML('')).toBe(null); }); it('(largeHtmlString) : parses large HTML strings', () => { const html = '
'.repeat(10); const nodes = $.parseHTML(html); expect(nodes.length).toBe(10); expect(nodes).toBeInstanceOf(Array); }); it('("'; expect($.parseHTML(html)).toHaveLength(0); }); it('("'; expect($.parseHTML(html, true)[0]).toHaveProperty('tagName', 'script'); }); it('("scriptAndNonScript) : preserves non-script nodes', () => { const html = '
'; expect($.parseHTML(html)[0]).toHaveProperty('tagName', 'div'); }); it('(scriptAndNonScript, true) : Preserves script position', () => { const html = '
'; expect($.parseHTML(html, true)[0]).toHaveProperty('tagName', 'script'); }); it('(text) : returns a text node', () => { expect($.parseHTML('text')[0].type).toBe('text'); }); it('(>text) : preserves leading whitespace', () => { expect($.parseHTML('\t
')[0]).toHaveProperty('data', '\t'); }); it('( text) : Leading spaces are treated as text nodes', () => { expect($.parseHTML('
')[0].type).toBe('text'); }); it('(html) : should preserve content', () => { const html = '
test div
'; expect(cheerio($.parseHTML(html)[0]).html()).toBe('test div'); }); it('(malformedHtml) : should not break', () => { expect($.parseHTML('')).toHaveLength(1); }); it('(garbageInput) : should not cause an error', () => { expect( $.parseHTML('<#if>
This is a test.
<#/if>'), ).toBeTruthy(); }); it('(text) : should return an array that is not effected by DOM manipulation methods', () => { const $div = cheerio.load('
'); const elems = $div.parseHTML(''); $div('div').append(elems); expect(elems).toHaveLength(2); }); it('(html, context) : should ignore context argument', () => { const $div = cheerio.load('
'); const elems = $div.parseHTML('', { foo: 123 }); $div('div').append(elems); expect(elems).toHaveLength(1); }); it('(html, context, keepScripts) : should ignore context argument', () => { const $div = cheerio.load('
'); const elems = $div.parseHTML( '', { foo: 123 }, true, ); $div('div').append(elems); expect(elems).toHaveLength(2); }); }); describe('.merge', () => { const $ = cheerio.load(''); it('should be a function', () => { expect(typeof $.merge).toBe('function'); }); it('(arraylike, arraylike) : should modify the first array, but not the second', () => { const arr1 = [1, 2, 3]; const arr2 = [4, 5, 6]; const ret = $.merge(arr1, arr2); expect(typeof ret).toBe('object'); expect(Array.isArray(ret)).toBe(true); expect(ret).toBe(arr1); expect(arr1).toHaveLength(6); expect(arr2).toHaveLength(3); }); it('(arraylike, arraylike) : should handle objects that arent arrays, but are arraylike', () => { const arr1: ArrayLike = { length: 3, 0: 'a', 1: 'b', 2: 'c', }; const arr2 = { length: 3, 0: 'd', 1: 'e', 2: 'f', }; $.merge(arr1, arr2); expect(arr1).toHaveLength(6); expect(arr1[3]).toBe('d'); expect(arr1[4]).toBe('e'); expect(arr1[5]).toBe('f'); expect(arr2).toHaveLength(3); }); it('(?, ?) : should gracefully reject invalid inputs', () => { expect($.merge([4], 3 as never)).toBeFalsy(); expect($.merge({} as never, {} as never)).toBeFalsy(); expect($.merge([], {} as never)).toBeFalsy(); expect($.merge({} as never, [])).toBeFalsy(); const fakeArray1 = { length: 3, 0: 'a', 1: 'b', 3: 'd' }; expect($.merge(fakeArray1, [])).toBeFalsy(); expect($.merge([], fakeArray1)).toBeFalsy(); expect($.merge({ length: '7' } as never, [])).toBeFalsy(); expect($.merge({ length: -1 }, [])).toBeFalsy(); }); it('(?, ?) : should no-op on invalid inputs', () => { const fakeArray1 = { length: 3, 0: 'a', 1: 'b', 3: 'd' }; $.merge(fakeArray1, []); expect(fakeArray1).toHaveLength(3); expect(fakeArray1[0]).toBe('a'); expect(fakeArray1[1]).toBe('b'); expect(fakeArray1[3]).toBe('d'); $.merge([], fakeArray1); expect(fakeArray1).toHaveLength(3); expect(fakeArray1[0]).toBe('a'); expect(fakeArray1[1]).toBe('b'); expect(fakeArray1[3]).toBe('d'); }); }); describe('.contains', () => { let $: CheerioAPI; beforeEach(() => { $ = cheerio.load(food); }); it('(container, contained) : should correctly detect the provided element', () => { const $food = $('#food'); const $fruits = $('#fruits'); const $apple = $('.apple'); expect($.contains($food[0], $fruits[0])).toBe(true); expect($.contains($food[0], $apple[0])).toBe(true); }); it('(container, other) : should not detect elements that are not contained', () => { const $fruits = $('#fruits'); const $vegetables = $('#vegetables'); const $apple = $('.apple'); expect($.contains($vegetables[0], $apple[0])).toBe(false); expect($.contains($fruits[0], $vegetables[0])).toBe(false); expect($.contains($vegetables[0], $fruits[0])).toBe(false); expect($.contains($fruits[0], $fruits[0])).toBe(false); expect($.contains($vegetables[0], $vegetables[0])).toBe(false); }); }); describe('.root', () => { it('() : should return a cheerio-wrapped root object', () => { const $ = cheerio.load('foo'); $.root().append('
'); expect($.html()).toBe( 'foo
', ); }); }); describe('.extract', () => { it('() : should extract values for selectors', () => { const $ = cheerio.load(eleven); expect( $.extract({ red: [{ selector: '.red', value: 'outerHTML' }], }), ).toStrictEqual({ red: [ '
Four
', '
Five
', '
Nine
', ], }); }); }); }); import type { BasicAcceptedElems } from './types.js'; import type { CheerioAPI } from './load.js'; import type { Cheerio } from './cheerio.js'; import type { AnyNode, Document } from 'domhandler'; import { textContent } from 'domutils'; import { type InternalOptions, type CheerioOptions, flattenOptions as flattenOptions, } from './options.js'; import type { ExtractedMap, ExtractMap } from './api/extract.js'; /** * Helper function to render a DOM. * * @param that - Cheerio instance to render. * @param dom - The DOM to render. Defaults to `that`'s root. * @param options - Options for rendering. * @returns The rendered document. */ function render( that: CheerioAPI, dom: BasicAcceptedElems | undefined, options: InternalOptions, ): string { if (!that) return ''; return that(dom ?? that._root.children, null, undefined, options).toString(); } /** * Checks if a passed object is an options object. * * @param dom - Object to check if it is an options object. * @param options - Options object. * @returns Whether the object is an options object. */ function isOptions( dom?: BasicAcceptedElems | CheerioOptions | null, options?: CheerioOptions, ): dom is CheerioOptions { return ( !options && typeof dom === 'object' && dom != null && !('length' in dom) && !('type' in dom) ); } /** * Renders the document. * * @category Static * @param options - Options for the renderer. * @returns The rendered document. */ export function html(this: CheerioAPI, options?: CheerioOptions): string; /** * Renders the document. * * @category Static * @param dom - Element to render. * @param options - Options for the renderer. * @returns The rendered document. */ export function html( this: CheerioAPI, dom?: BasicAcceptedElems, options?: CheerioOptions, ): string; export function html( this: CheerioAPI, dom?: BasicAcceptedElems | CheerioOptions, options?: CheerioOptions, ): string { /* * Be flexible about parameters, sometimes we call html(), * with options as only parameter * check dom argument for dom element specific properties * assume there is no 'length' or 'type' properties in the options object */ const toRender = isOptions(dom) ? ((options = dom), undefined) : dom; /* * Sometimes `$.html()` is used without preloading html, * so fallback non-existing options to the default ones. */ const opts = { ...this?._options, ...flattenOptions(options), }; return render(this, toRender, opts); } /** * Render the document as XML. * * @category Static * @param dom - Element to render. * @returns THe rendered document. */ export function xml( this: CheerioAPI, dom?: BasicAcceptedElems, ): string { const options = { ...this._options, xmlMode: true }; return render(this, dom, options); } /** * Render the document as text. * * This returns the `textContent` of the passed elements. The result will * include the contents of `alert("XSS!")'); }); it('(key, value) : should coerce values to a string', () => { const $apple = $('.apple'); $apple.attr('data-test', 1 as never); expect($apple[0].attribs['data-test']).toBe('1'); expect($apple.attr('data-test')).toBe('1'); }); it('(key, value) : handle removed boolean attributes', () => { const $apple = $('.apple'); $apple.attr('autofocus', 'autofocus'); expect($apple.attr('autofocus')).toBe('autofocus'); $apple.removeAttr('autofocus'); expect($apple.attr('autofocus')).toBeUndefined(); }); it('(key, value) : should remove non-boolean attributes with names or values similar to boolean ones', () => { const $apple = $('.apple'); $apple.attr('data-autofocus', 'autofocus'); expect($apple.attr('data-autofocus')).toBe('autofocus'); $apple.removeAttr('data-autofocus'); expect($apple.attr('data-autofocus')).toBeUndefined(); }); it('(key, value) : should remove attributes when called with null value', () => { const $pear = $('.pear').attr('autofocus', 'autofocus'); expect($pear.attr('autofocus')).toBe('autofocus'); $pear.attr('autofocus', null); expect($pear.attr('autofocus')).toBeUndefined(); }); it('(map) : should remove attributes with null values', () => { const $pear = $('.pear').attr({ autofocus: 'autofocus', style: 'color:red', }); expect($pear.attr('autofocus')).toBe('autofocus'); expect($pear.attr('style')).toBe('color:red'); $pear.attr({ autofocus: null, style: 'color:blue' }); expect($pear.attr('autofocus')).toBeUndefined(); expect($pear.attr('style')).toBe('color:blue'); }); it('(chaining) setting value and calling attr returns result', () => { const pearAttr = $('.pear').attr('foo', 'bar').attr('foo'); expect(pearAttr).toBe('bar'); }); it('(chaining) setting attr to null returns a $', () => { const $pear = $('.pear').attr('foo', null); expect($pear).toBeInstanceOf($); }); it('(chaining) setting attr to undefined returns a $', () => { const $pear = $('.pear').attr('foo', undefined); expect($('.pear')).toHaveLength(1); expect($('.pear').attr('foo')).toBeUndefined(); expect($pear).toBeInstanceOf($); }); it("(bool) shouldn't treat boolean attributes differently in XML mode", () => { const $xml = $.load(``, { xml: true, })('input'); expect($xml.attr('checked')).toBe('checked'); expect($xml.attr('disabled')).toBe('yes'); }); }); describe('.prop', () => { let $: CheerioAPI; let checkbox: Cheerio; beforeEach(() => { $ = load(inputs); checkbox = $('input[name=checkbox_on]'); }); it('(valid key) : valid prop should get value', () => { expect(checkbox.prop('checked')).toBe(true); checkbox.css('display', 'none'); expect(checkbox.prop('style')).toHaveProperty('display', 'none'); expect(checkbox.prop('style')).toHaveLength(1); expect(checkbox.prop('style')).toContain('display'); expect(checkbox.prop('tagName')).toBe('INPUT'); expect(checkbox.prop('nodeName')).toBe('INPUT'); }); it('(valid key) : should return on empty collection', () => { expect($(undefined).prop('checked')).toBeUndefined(); expect($(undefined).prop('style')).toBeUndefined(); expect($(undefined).prop('tagName')).toBeUndefined(); expect($(undefined).prop('nodeName')).toBeUndefined(); }); it('(invalid key) : invalid prop should get undefined', () => { expect(checkbox.prop('lol')).toBeUndefined(); expect(checkbox.prop(4 as never)).toBeUndefined(); expect(checkbox.prop(true as never)).toBeUndefined(); }); it('(key, value) : should set prop', () => { expect(checkbox.prop('checked')).toBe(true); checkbox.prop('checked', false); expect(checkbox.prop('checked')).toBe(false); checkbox.prop('checked', true); expect(checkbox.prop('checked')).toBe(true); }); it('(key, value) : should update attribute', () => { expect(checkbox.prop('checked')).toBe(true); expect(checkbox.attr('checked')).toBe('checked'); checkbox.prop('checked', false); expect(checkbox.prop('checked')).toBe(false); expect(checkbox.attr('checked')).toBeUndefined(); checkbox.prop('checked', true); expect(checkbox.prop('checked')).toBe(true); expect(checkbox.attr('checked')).toBe('checked'); }); it('(key, value) : should update namespace', () => { const imgs = $('\n\n\n\n'); const nsHtml = 'http://www.w3.org/1999/xhtml'; imgs.prop('src', '#').prop('namespace', nsHtml); expect(imgs.prop('namespace')).toBe(nsHtml); imgs.prop('attribs', null); expect(imgs.prop('src')).toBeUndefined(); expect(imgs.prop('data-foo')).toBeUndefined(); }); it('(key, value) : should ignore empty collection', () => { expect($(undefined).prop('checked')).toBeUndefined(); $(undefined).prop('checked', true); expect($(undefined).prop('checked')).toBeUndefined(); }); it('(map) : object map should set multiple props', () => { checkbox.prop({ id: 'check', checked: false, }); expect(checkbox.prop('id')).toBe('check'); expect(checkbox.prop('checked')).toBe(false); }); it('(map, val) : should throw with wrong combination of arguments', () => { expect(() => $('.apple').prop( { id: 'check', checked: false, } as never, () => '', ), ).toThrow('Bad combination of arguments.'); }); it('(key, function) : should call the function and update the prop with the return value', () => { checkbox.prop('checked', (index, value) => { expect(index).toBe(0); expect(value).toBe(true); return false; }); expect(checkbox.prop('checked')).toBe(false); }); it('(key, value) : should support chaining after setting props', () => { expect(checkbox.prop('checked', false)).toBe(checkbox); }); it('(invalid element/tag) : prop should return undefined', () => { expect($(undefined).prop('prop')).toBeUndefined(); expect($(null as never).prop('prop')).toBeUndefined(); }); it('("href") : should resolve links with `baseURI`', () => { const $ = load( ` example1 example2 example3 example4 `, { baseURI: 'http://example.com/page/1' }, ); expect($('#1').prop('href')).toBe('http://example.org/'); expect($('#2').prop('href')).toBe('http://example.org/'); expect($('#3').prop('href')).toBe('http://example.com/example.org'); expect($('#4').prop('href')).toBe('http://example.com/page/example.org'); expect($(undefined).prop('href')).toBeUndefined(); }); it('("href") : should skip values without an href', () => { const $ = load('example1'); expect($('#1').prop('href')).toBeUndefined(); }); it('("src") : should resolve links with `baseURI`', () => { const $ = load( ` `, { baseURI: 'http://example.com/page/1' }, ); expect($('#1').prop('src')).toBe('http://example.org/image.png'); expect($('#2').prop('src')).toBe('http://example.org/page.html'); expect($('#3').prop('src')).toBe( 'http://example.com/example.org/song.mp3', ); expect($('#4').prop('src')).toBe( 'http://example.com/page/example.org/image.png', ); expect($(undefined).prop('src')).toBeUndefined(); }); it('("outerHTML") : should render properly', () => { const outerHtml = '
'; const $a = $(outerHtml); expect($a.prop('outerHTML')).toBe(outerHtml); expect($(undefined).prop('outerHTML')).toBeUndefined(); }); it('("outerHTML") : should support root nodes', () => { const $ = load('
'); expect($.root().prop('outerHTML')).toBe( '
', ); }); it('("innerHTML") : should render properly', () => { const $a = $('
'); expect($a.prop('innerHTML')).toBe(''); expect($(undefined).prop('innerHTML')).toBeUndefined(); }); it('("textContent") : should render properly', () => { expect($('select').children().prop('textContent')).toBe( 'Option not selected', ); expect($(script).prop('textContent')).toBe('A var foo = "bar";B'); expect($(undefined).prop('textContent')).toBeUndefined(); }); it('("textContent") : should include style and script tags', () => { const $ = load( 'Welcome
Hello, testing text function,
End of message', ); expect($('body').prop('textContent')).toBe( 'Welcome Hello, testing text function,console.log("hello").cf-hidden { display: none; }End of message', ); expect($('style').prop('textContent')).toBe( '.cf-hidden { display: none; }', ); expect($('script').prop('textContent')).toBe('console.log("hello")'); }); it('("innerText") : should render properly', () => { expect($('select').children().prop('innerText')).toBe( 'Option not selected', ); expect($(script).prop('innerText')).toBe('AB'); expect($(undefined).prop('innerText')).toBeUndefined(); }); it('("innerText") : should omit style and script tags', () => { const $ = load( 'Welcome
Hello, testing text function,
End of message', ); expect($('body').prop('innerText')).toBe( 'Welcome Hello, testing text function,End of message', ); expect($('style').prop('innerText')).toBe(''); expect($('script').prop('innerText')).toBe(''); }); it('(inherited properties) : prop should support inherited properties', () => { expect($('select').prop('childNodes')).toBe($('select')[0].childNodes); }); it('(key) : should skip text nodes', () => { const $text = load(mixedText); const $body = $text($text('body')[0].children); expect($text($body[1]).prop('tagName')).toBeUndefined(); $body.prop('test-name', () => 'tester'); expect($text('body').html()).toBe( '1TEXT2', ); }); it("(bool) shouldn't treat boolean attributes differently in XML mode", () => { const $xml = $.load(``, { xml: true, })('input'); expect($xml.prop('checked')).toBe('checked'); expect($xml.prop('disabled')).toBe('yes'); }); }); describe('.data', () => { let $: CheerioAPI; beforeEach(() => { $ = load(chocolates); }); it('() : should get all data attributes initially declared in the markup', () => { const data = $('.linth').data(); expect(data).toStrictEqual({ highlight: 'Lindor', origin: 'swiss', }); }); it('() : should get all data set via `data`', () => { const $el = cheerio('
'); $el.data('a', 1); $el.data('b', 2); expect($el.data()).toStrictEqual({ a: 1, b: 2, }); }); it('() : should get all data attributes initially declared in the markup merged with all data additionally set via `data`', () => { const $el = cheerio('
'); $el.data('b', 'b-modified'); $el.data('c', 'c'); expect($el.data()).toStrictEqual({ a: 'a', b: 'b-modified', c: 'c', }); }); it('() : no data attribute should return an empty object', () => { const data = $('.cailler').data(); expect(Object.keys(data)).toHaveLength(0); expect($('.free').data()).toBeUndefined(); }); it('(invalid key) : invalid data attribute should return `undefined`', () => { const data = $('.frey').data('lol'); expect(data).toBeUndefined(); }); it('(valid key) : valid data attribute should get value', () => { const highlight = $('.linth').data('highlight'); const origin = $('.linth').data('origin'); expect(highlight).toBe('Lindor'); expect(origin).toBe('swiss'); }); it('(key) : should translate camel-cased key values to hyphen-separated versions', () => { const $el = cheerio( '
', ); expect($el.data('ThreeWordAttribute')).toBe('a'); expect($el.data('fooBar_baz-')).toBe('b'); }); it('(key) : should retrieve object values', () => { const data = {}; const $el = cheerio('
'); $el.data('test', data); expect($el.data('test')).toBe(data); }); it('(key) : should parse JSON data derived from the markup', () => { const $el = cheerio('
'); expect($el.data('json')).toStrictEqual([1, 2, 3]); }); it('(key) : should not parse JSON data set via the `data` API', () => { const $el = cheerio('
'); $el.data('json', '[1, 2, 3]'); expect($el.data('json')).toBe('[1, 2, 3]'); }); // See https://api.jquery.com/data/ and https://bugs.jquery.com/ticket/14523 it('(key) : should ignore the markup value after the first access', () => { const $el = cheerio('
'); expect($el.data('test')).toBe('a'); $el.attr('data-test', 'b'); expect($el.data('test')).toBe('a'); }); it('(key) : should recover from malformed JSON', () => { const $el = cheerio('
'); expect($el.data('custom')).toBe('{{templatevar}}'); }); it('("") : should accept the empty string as a name', () => { const $el = cheerio('
'); expect($el.data('')).toBe('a'); }); it('(hyphen key) : data addribute with hyphen should be camelized ;-)', () => { const data = $('.frey').data(); expect(data).toStrictEqual({ taste: 'sweet', bestCollection: 'Mahony', }); }); it('(key, value) : should set data attribute', () => { // Adding as object. const a = $('.frey').data({ balls: 'giandor', }); // Adding as string. const b = $('.linth').data('snack', 'chocoletti'); expect(() => { a.data(4 as never, 'throw'); }).not.toThrow(); expect(a.data('balls')).toStrictEqual('giandor'); expect(b.data('snack')).toStrictEqual('chocoletti'); }); it('(key, value) : should set data for all elements in the selection', () => { $('li').data('foo', 'bar'); expect($('li').eq(0).data('foo')).toStrictEqual('bar'); expect($('li').eq(1).data('foo')).toStrictEqual('bar'); expect($('li').eq(2).data('foo')).toStrictEqual('bar'); }); it('(map) : object map should set multiple data attributes', () => { const { data } = $('.linth').data({ id: 'Cailler', flop: 'Pippilotti Rist', top: 'Frigor', url: 'http://www.cailler.ch/', })[0] as never; expect(data).toHaveProperty('id', 'Cailler'); expect(data).toHaveProperty('flop', 'Pippilotti Rist'); expect(data).toHaveProperty('top', 'Frigor'); expect(data).toHaveProperty('url', 'http://www.cailler.ch/'); }); describe('(attr) : data-* attribute type coercion :', () => { it('boolean', () => { const $el = cheerio('
'); expect($el.data('bool')).toBe(true); }); it('number', () => { const $el = cheerio('
'); expect($el.data('number')).toBe(23); }); it('number (scientific notation is not coerced)', () => { const $el = cheerio('
'); expect($el.data('sci')).toBe('1E10'); }); it('null', () => { const $el = cheerio('
'); expect($el.data('null')).toBe(null); }); it('object', () => { const $el = cheerio('
'); expect($el.data('obj')).toStrictEqual({ a: 45 }); }); it('array', () => { const $el = cheerio('
'); expect($el.data('array')).toStrictEqual([1, 2, 3]); }); }); it('(key, value) : should skip text nodes', () => { const $text = load(mixedText); const $body = $text($text('body')[0].children); $body.data('snack', 'chocoletti'); expect($text('b').data('snack')).toBe('chocoletti'); }); }); describe('.val', () => { let $: CheerioAPI; beforeEach(() => { $ = load(inputs); }); it('(): on div should get undefined', () => { expect($('
').val()).toBeUndefined(); }); it('(): on select should get value', () => { const val = $('select#one').val(); expect(val).toBe('option_selected'); }); it('(): on select with no value should get text', () => { const val = $('select#one-valueless').val(); expect(val).toBe('Option selected'); }); it('(): on select with no value should get converted HTML', () => { const val = $('select#one-html-entity').val(); expect(val).toBe('Option '); }); it('(): on select with no value should get text content', () => { const val = $('select#one-nested').val(); expect(val).toBe('Option selected'); }); it('(): on option should get value', () => { const val = $('select#one option').eq(0).val(); expect(val).toBe('option_not_selected'); }); it('(): on text input should get value', () => { const val = $('input[type="text"]').val(); expect(val).toBe('input_text'); }); it('(): on checked checkbox should get value', () => { const val = $('input[name="checkbox_on"]').val(); expect(val).toBe('on'); }); it('(): on unchecked checkbox should get value', () => { const val = $('input[name="checkbox_off"]').val(); expect(val).toBe('off'); }); it('(): on valueless checkbox should get value', () => { const val = $('input[name="checkbox_valueless"]').val(); expect(val).toBe('on'); }); it('(): on radio should get value', () => { const val = $('input[type="radio"]').val(); expect(val).toBe('off'); }); it('(): on valueless radio should get value', () => { const val = $('input[name="radio_valueless"]').val(); expect(val).toBe('on'); }); it('(): on multiple select should get an array of values', () => { const val = $('select#multi').val(); expect(val).toStrictEqual(['2', '3']); }); it('(): on multiple select with no value attribute should get an array of text content', () => { const val = $('select#multi-valueless').val(); expect(val).toStrictEqual(['2', '3']); }); it('(): with no selector matches should return nothing', () => { const val = $('.nasty').val(); expect(val).toBeUndefined(); }); it('(invalid value): should only handle arrays when it has the attribute multiple', () => { const val = $('select#one').val([]); expect(val).not.toBeUndefined(); }); it('(value): on empty set should get `this`', () => { const $empty = $([]); expect($empty.val('test')).toBe($empty); }); it('(value): on input text should set value', () => { const element = $('input[type="text"]').val('test'); expect(element.val()).toBe('test'); }); it('(value): on select should set value', () => { const element = $('select#one').val('option_not_selected'); expect(element.val()).toBe('option_not_selected'); }); it('(value): on option should set value', () => { const element = $('select#one option').eq(0).val('option_changed'); expect(element.val()).toBe('option_changed'); }); it('(value): on radio should set value', () => { const element = $('input[name="radio"]').val('off'); expect(element.val()).toBe('off'); }); it('(value): on radio with special characters should set value', () => { const element = $('input[name="radio[brackets]"]').val('off'); expect(element.val()).toBe('off'); }); it('(values): on multiple select should set multiple values', () => { const element = $('select#multi').val(['1', '3', '4']); expect(element.val()).toHaveLength(3); }); }); describe('.removeAttr', () => { let $: CheerioAPI; beforeEach(() => { $ = load(fruits); }); it('(key) : should remove a single attr', () => { const $fruits = $('#fruits'); expect($fruits.attr('id')).not.toBeUndefined(); $fruits.removeAttr('id'); expect($fruits.attr('id')).toBeUndefined(); }); it('(key key) : should remove multiple attrs', () => { const $apple = $('.apple'); $apple.attr('id', 'favorite'); $apple.attr('size', 'small'); expect($apple.attr('id')).toBe('favorite'); expect($apple.attr('class')).toBe('apple'); expect($apple.attr('size')).toBe('small'); $apple.removeAttr('id class'); expect($apple.attr('id')).toBeUndefined(); expect($apple.attr('class')).toBeUndefined(); expect($apple.attr('size')).toBe('small'); }); it('(key) : should return cheerio object', () => { const obj = $('ul').removeAttr('id'); expect(obj).toBeInstanceOf($); }); it('(key) : should skip text nodes', () => { const $text = load(mixedText); const $body = $text($text('body')[0].children); $body.addClass(() => 'test'); expect($text('body').html()).toBe( '1TEXT2', ); $body.removeAttr('class'); expect($text('body').html()).toBe(mixedText); }); }); describe('.hasClass', () => { let $: CheerioAPI; beforeEach(() => { $ = load(fruits); }); it('(valid class) : should return true', () => { const cls = $('.apple').hasClass('apple'); expect(cls).toBe(true); expect(withClass('foo').hasClass('foo')).toBe(true); expect(withClass('foo bar').hasClass('foo')).toBe(true); expect(withClass('bar foo').hasClass('foo')).toBe(true); expect(withClass('bar foo bar').hasClass('foo')).toBe(true); }); it('(invalid class) : should return false', () => { const cls = $('#fruits').hasClass('fruits'); expect(cls).toBe(false); expect(withClass('foo-bar').hasClass('foo')).toBe(false); expect(withClass('foo-bar').hasClass('foo')).toBe(false); expect(withClass('foo-bar').hasClass('foo-ba')).toBe(false); }); it('should check multiple classes', () => { // Add a class $('.apple').addClass('red'); expect($('.apple').hasClass('apple')).toBe(true); expect($('.apple').hasClass('red')).toBe(true); // Remove one and test again $('.apple').removeClass('apple'); expect($('li').eq(0).hasClass('apple')).toBe(false); }); it('(empty string argument) : should return false', () => { expect(withClass('foo').hasClass('')).toBe(false); expect(withClass('foo bar').hasClass('')).toBe(false); expect(withClass('foo bar').removeClass('foo').hasClass('')).toBe(false); }); }); describe('.addClass', () => { let $: CheerioAPI; beforeEach(() => { $ = load(fruits); }); it('(first class) : should add the class to the element', () => { const $fruits = $('#fruits'); $fruits.addClass('fruits'); const cls = $fruits.hasClass('fruits'); expect(cls).toBe(true); }); it('(single class) : should add the class to the element', () => { $('.apple').addClass('fruit'); const cls = $('.apple').hasClass('fruit'); expect(cls).toBe(true); }); it('(class): adds classes to many selected items', () => { $('li').addClass('fruit'); expect($('.apple').hasClass('fruit')).toBe(true); expect($('.orange').hasClass('fruit')).toBe(true); expect($('.pear').hasClass('fruit')).toBe(true); // Mixed with text nodes const $red = $('\n
\n
\t').addClass('red'); expect($red).toHaveLength(3); expect($red[0].type).toBe('text'); expect($red[1].type).toBe('tag'); expect($red[2].type).toBe('text'); expect($red.hasClass('red')).toBe(true); }); it('(class class class) : should add multiple classes to the element', () => { $('.apple').addClass('fruit red tasty'); expect($('.apple').hasClass('apple')).toBe(true); expect($('.apple').hasClass('fruit')).toBe(true); expect($('.apple').hasClass('red')).toBe(true); expect($('.apple').hasClass('tasty')).toBe(true); }); it('(fn) : should add classes returned from the function', () => { const $fruits = $('#fruits').children().add($('#fruits')); const args: [i: number, className: string][] = []; const thisVals: Element[] = []; const toAdd = ['main', 'apple red', '', undefined]; $fruits.addClass(function (...myArgs) { args.push(myArgs); thisVals.push(this); return toAdd[myArgs[0]]; }); expect(args).toStrictEqual([ [0, ''], [1, 'apple'], [2, 'orange'], [3, 'pear'], ]); expect(thisVals).toStrictEqual([ $fruits[0], $fruits[1], $fruits[2], $fruits[3], ]); expect($fruits.eq(0).hasClass('main')).toBe(true); expect($fruits.eq(0).hasClass('apple')).toBe(false); expect($fruits.eq(1).hasClass('apple')).toBe(true); expect($fruits.eq(1).hasClass('red')).toBe(true); expect($fruits.eq(2).hasClass('orange')).toBe(true); expect($fruits.eq(3).hasClass('pear')).toBe(true); }); }); describe('.removeClass', () => { let $: CheerioAPI; beforeEach(() => { $ = load(fruits); }); it('() : should remove all the classes', () => { $('.pear').addClass('fruit'); $('.pear').removeClass(); expect($('.pear').attr('class')).toBeUndefined(); }); it('("") : should not modify class list', () => { const $fruits = $('#fruits'); $fruits.children().removeClass(''); expect($('.apple')).toHaveLength(1); }); it('(invalid class) : should not remove anything', () => { $('.pear').removeClass('fruit'); expect($('.pear').hasClass('pear')).toBe(true); }); it('(no class attribute) : should not throw an exception', () => { const $vegetables = cheerio(vegetables); expect(() => { $('li', $vegetables).removeClass('vegetable'); }).not.toThrow(); }); it('(single class) : should remove a single class from the element', () => { $('.pear').addClass('fruit'); expect($('.pear').hasClass('fruit')).toBe(true); $('.pear').removeClass('fruit'); expect($('.pear').hasClass('fruit')).toBe(false); expect($('.pear').hasClass('pear')).toBe(true); // Remove one class from set const $li = $('li').removeClass('orange'); expect($li.eq(0).attr('class')).toBe('apple'); expect($li.eq(1).attr('class')).toBe(''); expect($li.eq(2).attr('class')).toBe('pear'); // Mixed with text nodes const $red = $('\n
\n
\t').removeClass( 'one', ); expect($red).toHaveLength(3); expect($red[0].type).toBe('text'); expect($red[1].type).toBe('tag'); expect($red[2].type).toBe('text'); expect($red.eq(1).attr('class')).toBe(''); expect($red.eq(1).prop('tagName')).toBe('UL'); }); it('(single class) : should remove a single class from multiple classes on the element', () => { $('.pear').addClass('fruit green tasty'); expect($('.pear').hasClass('fruit')).toBe(true); expect($('.pear').hasClass('green')).toBe(true); expect($('.pear').hasClass('tasty')).toBe(true); $('.pear').removeClass('green'); expect($('.pear').hasClass('fruit')).toBe(true); expect($('.pear').hasClass('green')).toBe(false); expect($('.pear').hasClass('tasty')).toBe(true); }); it('(class class class) : should remove multiple classes from the element', () => { $('.apple').addClass('fruit red tasty'); expect($('.apple').hasClass('apple')).toBe(true); expect($('.apple').hasClass('fruit')).toBe(true); expect($('.apple').hasClass('red')).toBe(true); expect($('.apple').hasClass('tasty')).toBe(true); $('.apple').removeClass('apple red tasty'); expect($('.fruit').hasClass('apple')).toBe(false); expect($('.fruit').hasClass('red')).toBe(false); expect($('.fruit').hasClass('tasty')).toBe(false); expect($('.fruit').hasClass('fruit')).toBe(true); }); it('(class) : should remove all occurrences of a class name', () => { const $div = cheerio('
'); expect($div.removeClass('x').hasClass('x')).toBe(false); }); it('(fn) : should remove classes returned from the function', () => { const $fruits = $('#fruits').children(); const args: [number, string][] = []; const thisVals: Element[] = []; const toAdd = ['apple red', '', undefined]; $fruits.removeClass(function (...myArgs) { args.push(myArgs); thisVals.push(this); return toAdd[myArgs[0]]; }); expect(args).toStrictEqual([ [0, 'apple'], [1, 'orange'], [2, 'pear'], ]); expect(thisVals).toStrictEqual([$fruits[0], $fruits[1], $fruits[2]]); expect($fruits.eq(0).hasClass('apple')).toBe(false); expect($fruits.eq(0).hasClass('red')).toBe(false); expect($fruits.eq(1).hasClass('orange')).toBe(true); expect($fruits.eq(2).hasClass('pear')).toBe(true); }); it('(fn) : should no op elements without attributes', () => { const $inputs = $(inputs); const val = $inputs.removeClass(() => 'tasty'); expect(val).toHaveLength(15); }); it('(fn) : should skip text nodes', () => { const $text = load(mixedText); const $body = $text($text('body')[0].children); $body.addClass(() => 'test'); expect($text('body').html()).toBe( '1TEXT2', ); $body.removeClass(() => 'test'); expect($text('body').html()).toBe( '1TEXT2', ); }); }); describe('.toggleClass', () => { let $: CheerioAPI; beforeEach(() => { $ = load(fruits); }); it('(class class) : should toggle multiple classes from the element', () => { $('.apple').addClass('fruit'); expect($('.apple').hasClass('apple')).toBe(true); expect($('.apple').hasClass('fruit')).toBe(true); expect($('.apple').hasClass('red')).toBe(false); $('.apple').toggleClass('apple red'); expect($('.fruit').hasClass('apple')).toBe(false); expect($('.fruit').hasClass('red')).toBe(true); expect($('.fruit').hasClass('fruit')).toBe(true); // Mixed with text nodes const $red = $('\n
\n
\t').toggleClass( 'red', ); expect($red).toHaveLength(3); expect($red.hasClass('red')).toBe(true); expect($red.hasClass('one')).toBe(true); $red.toggleClass('one'); expect($red.hasClass('red')).toBe(true); expect($red.hasClass('one')).toBe(false); }); it('(class class, true) : should add multiple classes to the element', () => { $('.apple').addClass('fruit'); expect($('.apple').hasClass('apple')).toBe(true); expect($('.apple').hasClass('fruit')).toBe(true); expect($('.apple').hasClass('red')).toBe(false); $('.apple').toggleClass('apple red', true); expect($('.fruit').hasClass('apple')).toBe(true); expect($('.fruit').hasClass('red')).toBe(true); expect($('.fruit').hasClass('fruit')).toBe(true); }); it('(class true) : should add only one instance of class', () => { $('.apple').toggleClass('tasty', true); $('.apple').toggleClass('tasty', true); expect($('.apple').attr('class')).toMatch(/tasty/g); }); it('(class class, false) : should remove multiple classes from the element', () => { $('.apple').addClass('fruit'); expect($('.apple').hasClass('apple')).toBe(true); expect($('.apple').hasClass('fruit')).toBe(true); expect($('.apple').hasClass('red')).toBe(false); $('.apple').toggleClass('apple red', false); expect($('.fruit').hasClass('apple')).toBe(false); expect($('.fruit').hasClass('red')).toBe(false); expect($('.fruit').hasClass('fruit')).toBe(true); }); it('(fn) : should toggle classes returned from the function', () => { const $ = load(food); $('.apple').addClass('fruit'); $('.carrot').addClass('vegetable'); expect($('.apple').hasClass('fruit')).toBe(true); expect($('.apple').hasClass('vegetable')).toBe(false); expect($('.orange').hasClass('fruit')).toBe(false); expect($('.orange').hasClass('vegetable')).toBe(false); expect($('.carrot').hasClass('fruit')).toBe(false); expect($('.carrot').hasClass('vegetable')).toBe(true); expect($('.sweetcorn').hasClass('fruit')).toBe(false); expect($('.sweetcorn').hasClass('vegetable')).toBe(false); $('li').toggleClass(function () { return $(this).parent().is('#fruits') ? 'fruit' : 'vegetable'; }); expect($('.apple').hasClass('fruit')).toBe(false); expect($('.apple').hasClass('vegetable')).toBe(false); expect($('.orange').hasClass('fruit')).toBe(true); expect($('.orange').hasClass('vegetable')).toBe(false); expect($('.carrot').hasClass('fruit')).toBe(false); expect($('.carrot').hasClass('vegetable')).toBe(false); expect($('.sweetcorn').hasClass('fruit')).toBe(false); expect($('.sweetcorn').hasClass('vegetable')).toBe(true); }); it('(fn) : should work with no initial class attribute', () => { const $inputs = load(inputs); $inputs('input, select').toggleClass(function () { // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- `get` should never return undefined here. return $inputs(this).get(0)!.tagName === 'select' ? 'selectable' : 'inputable'; }); expect($inputs('.selectable')).toHaveLength(6); expect($inputs('.inputable')).toHaveLength(9); }); it('(fn) : should skip text nodes', () => { const $text = load(mixedText); const $body = $text($text('body')[0].children); $body.toggleClass(() => 'test'); expect($text('body').html()).toBe( '1TEXT2', ); $body.toggleClass(() => 'test'); expect($text('body').html()).toBe( '1TEXT2', ); }); it('(invalid) : should be a no-op for invalid inputs', () => { const original = $('.apple'); const testAgainst = original.attr('class'); expect(original.toggleClass().attr('class')).toStrictEqual(testAgainst); for (const value of [undefined, true, false, null, 0, 1, {}]) { expect( original.toggleClass(value as never).attr('class'), ).toStrictEqual(testAgainst); } }); }); }); /** * Methods for getting and modifying attributes. * * @module cheerio/attributes */ import { text } from '../static.js'; import { domEach, camelCase, cssCase } from '../utils.js'; import { isTag, type AnyNode, type Element } from 'domhandler'; import type { Cheerio } from '../cheerio.js'; import { innerText, textContent } from 'domutils'; import { ElementType } from 'htmlparser2'; const hasOwn = // @ts-expect-error `hasOwn` is a standard object method (Object.hasOwn as (object: unknown, prop: string) => boolean) ?? ((object: unknown, prop: string) => Object.prototype.hasOwnProperty.call(object, prop)); const rspace = /\s+/; const dataAttrPrefix = 'data-'; // Attributes that are booleans const rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i; // Matches strings that look like JSON objects or arrays const rbrace = /^{[^]*}$|^\[[^]*]$/; /** * Gets a node's attribute. For boolean attributes, it will return the value's * name should it be set. * * Also supports getting the `value` of several form elements. * * @private * @category Attributes * @param elem - Element to get the attribute of. * @param name - Name of the attribute. * @param xmlMode - Disable handling of special HTML attributes. * @returns The attribute's value. */ function getAttr( elem: AnyNode, name: undefined, xmlMode?: boolean, ): Record | undefined; function getAttr( elem: AnyNode, name: string, xmlMode?: boolean, ): string | undefined; function getAttr( elem: AnyNode, name: string | undefined, xmlMode?: boolean, ): Record | string | undefined { if (!elem || !isTag(elem)) return undefined; elem.attribs ??= {}; // Return the entire attribs object if no attribute specified if (!name) { return elem.attribs; } if (hasOwn(elem.attribs, name)) { // Get the (decoded) attribute return !xmlMode && rboolean.test(name) ? name : elem.attribs[name]; } // Mimic the DOM and return text content as value for `option's` if (elem.name === 'option' && name === 'value') { return text(elem.children); } // Mimic DOM with default value for radios/checkboxes if ( elem.name === 'input' && (elem.attribs['type'] === 'radio' || elem.attribs['type'] === 'checkbox') && name === 'value' ) { return 'on'; } return undefined; } /** * Sets the value of an attribute. The attribute will be deleted if the value is * `null`. * * @private * @param el - The element to set the attribute on. * @param name - The attribute's name. * @param value - The attribute's value. */ function setAttr(el: Element, name: string, value: string | null) { if (value === null) { removeAttribute(el, name); } else { el.attribs[name] = `${value}`; } } /** * Method for getting attributes. Gets the attribute value for only the first * element in the matched set. * * @category Attributes * @example * * ```js * $('ul').attr('id'); * //=> fruits * ``` * * @param name - Name of the attribute. * @returns The attribute's value. * @see {@link https://api.jquery.com/attr/} */ export function attr( this: Cheerio, name: string, ): string | undefined; /** * Method for getting all attributes and their values of the first element in * the matched set. * * @category Attributes * @example * * ```js * $('ul').attr(); * //=> { id: 'fruits' } * ``` * * @returns The attribute's values. * @see {@link https://api.jquery.com/attr/} */ export function attr( this: Cheerio, ): Record | undefined; /** * 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`. * * @category Attributes * @example * * ```js * $('.apple').attr('id', 'favorite').prop('outerHTML'); * //=>
Apple
* ``` * * @param name - Name of the attribute. * @param value - The new value of the attribute. * @returns The instance itself. * @see {@link https://api.jquery.com/attr/} */ export function attr( this: Cheerio, name: string, value?: | string | null | ((this: Element, i: number, attrib: string) => string | null), ): Cheerio; /** * 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. * * @category Attributes * @example * * ```js * $('.apple').attr({ id: 'favorite' }).prop('outerHTML'); * //=>
Apple
* ``` * * @param values - Map of attribute names and values. * @returns The instance itself. * @see {@link https://api.jquery.com/attr/} */ export function attr( this: Cheerio, values: Record, ): Cheerio; export function attr( this: Cheerio, name?: string | Record, value?: | string | null | ((this: Element, i: number, attrib: string) => string | null), ): string | Cheerio | undefined | Record { // Set the value (with attr map support) if (typeof name === 'object' || value !== undefined) { if (typeof value === 'function') { if (typeof name !== 'string') { { throw new Error('Bad combination of arguments.'); } } return domEach(this, (el, i) => { if (isTag(el)) setAttr(el, name, value.call(el, i, el.attribs[name])); }); } return domEach(this, (el) => { if (!isTag(el)) return; if (typeof name === 'object') { for (const objName of Object.keys(name)) { const objValue = name[objName]; setAttr(el, objName, objValue); } } else { setAttr(el, name!, value!); } }); } return arguments.length > 1 ? this : getAttr(this[0], name!, this.options.xmlMode); } /** * Gets a node's prop. * * @private * @category Attributes * @param el - Element to get the prop of. * @param name - Name of the prop. * @param xmlMode - Disable handling of special HTML attributes. * @returns The prop's value. */ function getProp( el: Element, name: string, xmlMode?: boolean, ): string | undefined | boolean | Element[keyof Element] { return name in el ? // @ts-expect-error TS doesn't like us accessing the value directly here. (el[name] as string | undefined) : !xmlMode && rboolean.test(name) ? getAttr(el, name, false) !== undefined : getAttr(el, name, xmlMode); } /** * Sets the value of a prop. * * @private * @param el - The element to set the prop on. * @param name - The prop's name. * @param value - The prop's value. * @param xmlMode - Disable handling of special HTML attributes. */ function setProp(el: Element, name: string, value: unknown, xmlMode?: boolean) { if (name in el) { // @ts-expect-error Overriding value el[name] = value; } else { setAttr( el, name, !xmlMode && rboolean.test(name) ? value ? '' : null : `${value as string}`, ); } } interface StyleProp { length: number; [key: string]: string | number; [index: number]: string; } /** * Method for getting and setting properties. Gets the property value for only * the first element in the matched set. * * @category Attributes * @example * * ```js * $('input[type="checkbox"]').prop('checked'); * //=> false * * $('input[type="checkbox"]').prop('checked', true).val(); * //=> ok * ``` * * @param name - Name of the property. * @returns If `value` is specified the instance itself, otherwise the prop's * value. * @see {@link https://api.jquery.com/prop/} */ export function prop( this: Cheerio, name: 'tagName' | 'nodeName', ): string | undefined; export function prop( this: Cheerio, name: 'innerHTML' | 'outerHTML' | 'innerText' | 'textContent', ): string | null; /** * Get a parsed CSS style object. * * @param name - Name of the property. * @returns The style object, or `undefined` if the element has no `style` * attribute. */ export function prop( this: Cheerio, name: 'style', ): StyleProp | undefined; /** * 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. * * @example With `baseURI` set to `'https://example.com'`: * * ```js * $('').prop('src'); * //=> 'https://example.com/image.png' * ``` * * @param name - Name of the property. * @returns The resolved URL, or `undefined` if the element is not supported. */ export function prop( this: Cheerio, name: 'href' | 'src', ): string | undefined; /** * Get a property of an element. * * @param name - Name of the property. * @returns The property's value. */ export function prop( this: Cheerio, name: K, ): Element[K]; /** * Set a property of an element. * * @param name - Name of the property. * @param value - Value to set the property to. * @returns The instance itself. */ export function prop( this: Cheerio, name: K, value: | Element[K] | ((this: Element, i: number, prop: K) => Element[keyof Element]), ): Cheerio; /** * Set multiple properties of an element. * * @example * * ```js * $('input[type="checkbox"]').prop({ * checked: true, * disabled: false, * }); * ``` * * @param map - Object of properties to set. * @returns The instance itself. */ export function prop( this: Cheerio, map: Record, ): Cheerio; /** * Set a property of an element. * * @param name - Name of the property. * @param value - Value to set the property to. * @returns The instance itself. */ export function prop( this: Cheerio, name: string, value: | string | boolean | null | ((this: Element, i: number, prop: string) => string | boolean), ): Cheerio; /** * Get a property of an element. * * @param name - The property's name. * @returns The property's value. */ export function prop(this: Cheerio, name: string): string; export function prop( this: Cheerio, name: string | Record, value?: unknown, ): | Cheerio | string | boolean | undefined | null | Element[keyof Element] | StyleProp { if (typeof name === 'string' && value === undefined) { const el = this[0]; if (!el) return undefined; switch (name) { case 'style': { const property = this.css() as StyleProp; const keys = Object.keys(property); for (let i = 0; i < keys.length; i++) { property[i] = keys[i]; } property.length = keys.length; return property; } case 'tagName': case 'nodeName': { if (!isTag(el)) return undefined; return el.name.toUpperCase(); } case 'href': case 'src': { if (!isTag(el)) return undefined; const prop = el.attribs?.[name]; if ( typeof URL !== 'undefined' && ((name === 'href' && (el.tagName === 'a' || el.tagName === 'link')) || (name === 'src' && (el.tagName === 'img' || el.tagName === 'iframe' || el.tagName === 'audio' || el.tagName === 'video' || el.tagName === 'source'))) && prop !== undefined && this.options.baseURI ) { return new URL(prop, this.options.baseURI).href; } return prop; } case 'innerText': { return innerText(el); } case 'textContent': { return textContent(el); } case 'outerHTML': { if (el.type === ElementType.Root) return this.html(); return this.clone().wrap('').parent().html(); } case 'innerHTML': { return this.html(); } default: { if (!isTag(el)) return undefined; return getProp(el, name, this.options.xmlMode); } } } if (typeof name === 'object' || value !== undefined) { if (typeof value === 'function') { if (typeof name === 'object') { throw new TypeError('Bad combination of arguments.'); } return domEach(this, (el, i) => { if (isTag(el)) { setProp( el, name, value.call(el, i, getProp(el, name, this.options.xmlMode)), this.options.xmlMode, ); } }); } return domEach(this, (el) => { if (!isTag(el)) return; if (typeof name === 'object') { for (const key of Object.keys(name)) { const val = name[key]; setProp(el, key, val, this.options.xmlMode); } } else { setProp(el, name, value, this.options.xmlMode); } }); } return undefined; } /** * An element with a data attribute. * * @private */ interface DataElement extends Element { /** The data attribute. */ data?: Record; } /** * Sets the value of a data attribute. * * @private * @param elem - The element to set the data attribute on. * @param name - The data attribute's name. * @param value - The data attribute's value. */ function setData( elem: DataElement, name: string | Record, value?: unknown, ) { elem.data ??= {}; if (typeof name === 'object') Object.assign(elem.data, name); else if (typeof name === 'string' && value !== undefined) { elem.data[name] = value; } } /** * Read _all_ HTML5 `data-*` attributes from the equivalent HTML5 `data-*` * attribute, and cache the value in the node's internal data store. * * @private * @category Attributes * @param el - Element to get the data attribute of. * @returns A map with all of the data attributes. */ function readAllData(el: DataElement): unknown { for (const domName of Object.keys(el.attribs)) { if (!domName.startsWith(dataAttrPrefix)) { continue; } const jsName = camelCase(domName.slice(dataAttrPrefix.length)); if (!hasOwn(el.data, jsName)) { el.data![jsName] = parseDataValue(el.attribs[domName]); } } return el.data; } /** * Read the specified attribute from the equivalent HTML5 `data-*` attribute, * and (if present) cache the value in the node's internal data store. * * @private * @category Attributes * @param el - Element to get the data attribute of. * @param name - Name of the data attribute. * @returns The data attribute's value. */ function readData(el: DataElement, name: string): unknown { const domName = dataAttrPrefix + cssCase(name); const data = el.data!; if (hasOwn(data, name)) { return data[name]; } if (hasOwn(el.attribs, domName)) { return (data[name] = parseDataValue(el.attribs[domName])); } return undefined; } /** * Coerce string data-* attributes to their corresponding JavaScript primitives. * * @private * @category Attributes * @param value - The value to parse. * @returns The parsed value. */ function parseDataValue(value: string): unknown { if (value === 'null') return null; if (value === 'true') return true; if (value === 'false') return false; const num = Number(value); if (value === String(num)) return num; if (rbrace.test(value)) { try { return JSON.parse(value); } catch { /* Ignore */ } } return value; } /** * Method for getting data attributes, for only the first element in the matched * set. * * @category Attributes * @example * * ```js * $('
').data('apple-color'); * //=> 'red' * ``` * * @param name - Name of the data attribute. * @returns The data attribute's value, or `undefined` if the attribute does not * exist. * @see {@link https://api.jquery.com/data/} */ export function data( this: Cheerio, name: string, ): unknown; /** * Method for getting all of an element's data attributes, for only the first * element in the matched set. * * @category Attributes * @example * * ```js * $('
').data(); * //=> { appleColor: 'red' } * ``` * * @returns A map with all of the data attributes. * @see {@link https://api.jquery.com/data/} */ export function data( this: Cheerio, ): Record; /** * Method for setting data attributes, for only the first element in the matched * set. * * @category Attributes * @example * * ```js * const apple = $('.apple').data('kind', 'mac'); * * apple.data('kind'); * //=> 'mac' * ``` * * @param name - Name of the data attribute. * @param value - The new value. * @returns The instance itself. * @see {@link https://api.jquery.com/data/} */ export function data( this: Cheerio, name: string, value: unknown, ): Cheerio; /** * Method for setting multiple data attributes at once, for only the first * element in the matched set. * * @category Attributes * @example * * ```js * const apple = $('.apple').data({ kind: 'mac' }); * * apple.data('kind'); * //=> 'mac' * ``` * * @param values - Map of names to values. * @returns The instance itself. * @see {@link https://api.jquery.com/data/} */ export function data( this: Cheerio, values: Record, ): Cheerio; export function data( this: Cheerio, name?: string | Record, value?: unknown, ): unknown { const elem = this[0]; if (!elem || !isTag(elem)) return; const dataEl: DataElement = elem; dataEl.data ??= {}; // Return the entire data object if no data specified if (name == null) { return readAllData(dataEl); } // Set the value (with attr map support) if (typeof name === 'object' || value !== undefined) { domEach(this, (el) => { if (isTag(el)) { if (typeof name === 'object') setData(el, name); else setData(el, name, value); } }); return this; } return readData(dataEl, name); } /** * Method for getting the value of input, select, and textarea. Note: Support * for `map`, and `function` has not been added yet. * * @category Attributes * @example * * ```js * $('input[type="text"]').val(); * //=> input_text * ``` * * @returns The value. * @see {@link https://api.jquery.com/val/} */ export function val( this: Cheerio, ): string | undefined | string[]; /** * Method for setting the value of input, select, and textarea. Note: Support * for `map`, and `function` has not been added yet. * * @category Attributes * @example * * ```js * $('input[type="text"]').val('test').prop('outerHTML'); * //=> * ``` * * @param value - The new value. * @returns The instance itself. * @see {@link https://api.jquery.com/val/} */ export function val( this: Cheerio, value: string | string[], ): Cheerio; export function val( this: Cheerio, value?: string | string[], ): string | string[] | Cheerio | undefined { const querying = arguments.length === 0; const element = this[0]; if (!element || !isTag(element)) return querying ? undefined : this; switch (element.name) { case 'textarea': { return this.text(value as string); } case 'select': { const option = this.find('option:selected'); if (!querying) { if (this.attr('multiple') == null && typeof value === 'object') { return this; } this.find('option').removeAttr('selected'); const values = typeof value === 'object' ? value : [value]; for (const val of values) { this.find(`option[value="${val}"]`).attr('selected', ''); } return this; } return this.attr('multiple') ? option.toArray().map((el) => text(el.children)) : option.attr('value'); } case 'input': case 'option': { return querying ? this.attr('value') : this.attr('value', value as string); } } return undefined; } /** * Remove an attribute. * * @private * @param elem - Node to remove attribute from. * @param name - Name of the attribute to remove. */ function removeAttribute(elem: Element, name: string) { if (!elem.attribs || !hasOwn(elem.attribs, name)) return; delete elem.attribs[name]; } /** * Splits a space-separated list of names to individual names. * * @category Attributes * @param names - Names to split. * @returns - Split names. */ function splitNames(names?: string): string[] { return names ? names.trim().split(rspace) : []; } /** * Method for removing attributes by `name`. * * @category Attributes * @example * * ```js * $('.pear').removeAttr('class').prop('outerHTML'); * //=>
Pear
* * $('.apple').attr('id', 'favorite'); * $('.apple').removeAttr('id class').prop('outerHTML'); * //=>
Apple
* ``` * * @param name - Name of the attribute. * @returns The instance itself. * @see {@link https://api.jquery.com/removeAttr/} */ export function removeAttr( this: Cheerio, name: string, ): Cheerio { const attrNames = splitNames(name); for (const attrName of attrNames) { domEach(this, (elem) => { if (isTag(elem)) removeAttribute(elem, attrName); }); } return this; } /** * Check to see if _any_ of the matched elements have the given `className`. * * @category Attributes * @example * * ```js * $('.pear').hasClass('pear'); * //=> true * * $('apple').hasClass('fruit'); * //=> false * * $('li').hasClass('pear'); * //=> true * ``` * * @param className - Name of the class. * @returns Indicates if an element has the given `className`. * @see {@link https://api.jquery.com/hasClass/} */ export function hasClass( this: Cheerio, className: string, ): boolean { return this.toArray().some((elem) => { const clazz = isTag(elem) && elem.attribs['class']; let idx = -1; if (clazz && className.length > 0) { while ((idx = clazz.indexOf(className, idx + 1)) > -1) { const end = idx + className.length; if ( (idx === 0 || rspace.test(clazz[idx - 1])) && (end === clazz.length || rspace.test(clazz[end])) ) { return true; } } } return false; }); } /** * Adds class(es) to all of the matched elements. Also accepts a `function`. * * @category Attributes * @example * * ```js * $('.pear').addClass('fruit').prop('outerHTML'); * //=>
Pear
* * $('.apple').addClass('fruit red').prop('outerHTML'); * //=>
Apple
* ``` * * @param value - Name of new class. * @returns The instance itself. * @see {@link https://api.jquery.com/addClass/} */ export function addClass>( this: R, value?: | string | ((this: Element, i: number, className: string) => string | undefined), ): R { // Support functions if (typeof value === 'function') { return domEach(this, (el, i) => { if (isTag(el)) { const className = el.attribs['class'] || ''; addClass.call([el], value.call(el, i, className)); } }); } // Return if no value or not a string or function if (!value || typeof value !== 'string') return this; const classNames = value.split(rspace); const numElements = this.length; for (let i = 0; i < numElements; i++) { const el = this[i]; // If selected element isn't a tag, move on if (!isTag(el)) continue; // If we don't already have classes — always set xmlMode to false here, as it doesn't matter for classes const className = getAttr(el, 'class', false); if (className) { let setClass = ` ${className} `; // Check if class already exists for (const cn of classNames) { const appendClass = `${cn} `; if (!setClass.includes(` ${appendClass}`)) setClass += appendClass; } setAttr(el, 'class', setClass.trim()); } else { setAttr(el, 'class', classNames.join(' ').trim()); } } return this; } /** * 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`. * * @category Attributes * @example * * ```js * $('.pear').removeClass('pear').prop('outerHTML'); * //=>
Pear
* * $('.apple').addClass('red').removeClass().prop('outerHTML'); * //=>
Apple
* ``` * * @param name - Name of the class. If not specified, removes all elements. * @returns The instance itself. * @see {@link https://api.jquery.com/removeClass/} */ export function removeClass>( this: R, name?: | string | ((this: Element, i: number, className: string) => string | undefined), ): R { // Handle if value is a function if (typeof name === 'function') { return domEach(this, (el, i) => { if (isTag(el)) { removeClass.call([el], name.call(el, i, el.attribs['class'] || '')); } }); } const classes = splitNames(name); const numClasses = classes.length; const removeAll = arguments.length === 0; return domEach(this, (el) => { if (!isTag(el)) return; if (removeAll) { // Short circuit the remove all case as this is the nice one el.attribs['class'] = ''; } else { const elClasses = splitNames(el.attribs['class']); let changed = false; for (let j = 0; j < numClasses; j++) { const index = elClasses.indexOf(classes[j]); if (index !== -1) { elClasses.splice(index, 1); changed = true; /* * We have to do another pass to ensure that there are not duplicate * classes listed */ j--; } } if (changed) { el.attribs['class'] = elClasses.join(' '); } } }); } /** * 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`. * * @category Attributes * @example * * ```js * $('.apple.green').toggleClass('fruit green red').prop('outerHTML'); * //=>
Apple
* * $('.apple.green').toggleClass('fruit green red', true).prop('outerHTML'); * //=>
Apple
* ``` * * @param value - Name of the class. Can also be a function. * @param stateVal - If specified the state of the class. * @returns The instance itself. * @see {@link https://api.jquery.com/toggleClass/} */ export function toggleClass>( this: R, value?: | string | (( this: Element, i: number, className: string, stateVal?: boolean, ) => string), stateVal?: boolean, ): R { // Support functions if (typeof value === 'function') { return domEach(this, (el, i) => { if (isTag(el)) { toggleClass.call( [el], value.call(el, i, el.attribs['class'] || '', stateVal), stateVal, ); } }); } // Return if no value or not a string or function if (!value || typeof value !== 'string') return this; const classNames = value.split(rspace); const numClasses = classNames.length; const state = typeof stateVal === 'boolean' ? (stateVal ? 1 : -1) : 0; const numElements = this.length; for (let i = 0; i < numElements; i++) { const el = this[i]; // If selected element isn't a tag, move on if (!isTag(el)) continue; const elementClasses = splitNames(el.attribs['class']); // Check if class already exists for (let j = 0; j < numClasses; j++) { // Check if the class name is currently defined const index = elementClasses.indexOf(classNames[j]); // Add if stateValue === true or we are toggling and there is no value if (state >= 0 && index === -1) { elementClasses.push(classNames[j]); } else if (state <= 0 && index !== -1) { // Otherwise remove but only if the item exists elementClasses.splice(index, 1); } } el.attribs['class'] = elementClasses.join(' '); } return this; } import { describe, it, expect, beforeEach } from 'vitest'; import { load, type Cheerio } from '../index.js'; import type { Element } from 'domhandler'; import { cheerio, mixedText } from '../__fixtures__/fixtures.js'; describe('$(...)', () => { describe('.css', () => { it('(prop): should return a css property value', () => { const el = cheerio('
'); expect(el.css('hai')).toBe('there'); }); it('([prop1, prop2]): should return the specified property values as an object', () => { const el = cheerio( '
', ); expect(el.css(['margin', 'color'])).toStrictEqual({ margin: '1px', color: 'blue', }); }); it('(prop, val): should set a css property', () => { const el = cheerio('
'); el.css('color', 'red'); expect(el.attr('style')).toBe('margin: 0; color: red;'); expect(el.eq(1).attr('style')).toBe('color: red;'); }); it('(prop, val) : should skip text nodes', () => { const $text = load(mixedText); const $body = $text($text('body')[0].children); $body.css('test', 'value'); expect($text('body').html()).toBe( '1TEXT2', ); }); it('(prop, ""): should unset a css property', () => { const el = cheerio('
'); el.css('padding', ''); expect(el.attr('style')).toBe('margin: 0;'); }); it('(any, val): should ignore unsupported prop types', () => { const el = cheerio('
'); el.css(123 as never, 'test'); expect(el.attr('style')).toBe('padding: 1px;'); }); it('(prop): should not mangle embedded urls', () => { const el = cheerio( '
', ); expect(el.css('background-image')).toBe( 'url(http://example.com/img.png)', ); }); it('(prop): should ignore blank properties', () => { const el = cheerio('
'); expect(el.css()).toStrictEqual({ color: '#aaa' }); }); it('(prop): should ignore blank values', () => { const el = cheerio('
'); expect(el.css()).toStrictEqual({ position: 'absolute' }); }); it('(prop): should return undefined for unmatched elements', () => { const $ = load('
'); expect($('ul').css('background-image')).toBeUndefined(); }); it('(prop): should return undefined for unmatched styles', () => { const el = cheerio('
'); expect(el.css('margin')).toBeUndefined(); }); describe('(prop, function):', () => { let $el: Cheerio; beforeEach(() => { const $ = load( '
', ); $el = $('div'); }); it('should iterate over the selection', () => { let count = 0; $el.css('margin', function (idx, value) { expect(idx).toBe(count); expect(value).toBe(`${count}px`); expect(this).toBe($el[count]); count++; return undefined; }); expect(count).toBe(3); }); it('should set each attribute independently', () => { const values = ['4px', '', undefined]; $el.css('margin', (idx) => values[idx]); expect($el.eq(0).attr('style')).toBe('margin: 4px;'); expect($el.eq(1).attr('style')).toBe(''); expect($el.eq(2).attr('style')).toBe('margin: 2px;'); }); }); it('(obj): should set each key and val', () => { const el = cheerio('
'); el.css({ foo: 0 } as never); expect(el.eq(0).attr('style')).toBe('padding: 0; foo: 0;'); expect(el.eq(1).attr('style')).toBe('foo: 0;'); }); describe('parser', () => { it('should allow any whitespace between declarations', () => { const el = cheerio('
'); expect(el.css(['one', 'two', 'five'])).toStrictEqual({ one: '0', two: '1', }); }); it('should add malformed values to previous field (#1134)', () => { const el = cheerio( '', ); expect(el.css('background-image')).toStrictEqual( 'url(data:image/png;base64,iVBORw0KGgo)', ); }); }); }); }); import { domEach } from '../utils.js'; import { isTag, type Element, type AnyNode } from 'domhandler'; import type { Cheerio } from '../cheerio.js'; /** * Get the value of a style property for the first element in the set of matched * elements. * * @category CSS * @param names - Optionally the names of the properties of interest. * @returns A map of all of the style properties. * @see {@link https://api.jquery.com/css/} */ export function css( this: Cheerio, names?: string[], ): Record | undefined; /** * Get the value of a style property for the first element in the set of matched * elements. * * @category CSS * @param name - The name of the property. * @returns The property value for the given name. * @see {@link https://api.jquery.com/css/} */ export function css( this: Cheerio, name: string, ): string | undefined; /** * Set one CSS property for every matched element. * * @category CSS * @param prop - The name of the property. * @param val - The new value. * @returns The instance itself. * @see {@link https://api.jquery.com/css/} */ export function css( this: Cheerio, prop: string, val: | string | ((this: Element, i: number, style: string) => string | undefined), ): Cheerio; /** * Set multiple CSS properties for every matched element. * * @category CSS * @param map - A map of property names and values. * @returns The instance itself. * @see {@link https://api.jquery.com/css/} */ export function css( this: Cheerio, map: Record, ): Cheerio; /** * Set multiple CSS properties for every matched element. * * @category CSS * @param prop - The names of the properties. * @param val - The new values. * @returns The instance itself. * @see {@link https://api.jquery.com/css/} */ export function css( this: Cheerio, prop?: string | string[] | Record, val?: | string | ((this: Element, i: number, style: string) => string | undefined), ): Cheerio | Record | string | undefined { if ( (prop != null && val != null) || // When `prop` is a "plain" object (typeof prop === 'object' && !Array.isArray(prop)) ) { return domEach(this, (el, i) => { if (isTag(el)) { // `prop` can't be an array here anymore. setCss(el, prop as string, val, i); } }); } if (this.length === 0) { return undefined; } return getCss(this[0], prop as string); } /** * Set styles of all elements. * * @private * @param el - Element to set style of. * @param prop - Name of property. * @param value - Value to set property to. * @param idx - Optional index within the selection. */ function setCss( el: Element, prop: string | Record, value: | string | ((this: Element, i: number, style: string) => string | undefined) | undefined, idx: number, ) { if (typeof prop === 'string') { const styles = getCss(el); const val = typeof value === 'function' ? value.call(el, idx, styles[prop]) : value; if (val === '') { delete styles[prop]; } else if (val != null) { styles[prop] = val; } el.attribs['style'] = stringify(styles); } else if (typeof prop === 'object') { const keys = Object.keys(prop); for (let i = 0; i < keys.length; i++) { const k = keys[i]; setCss(el, k, prop[k], i); } } } /** * Get the parsed styles of the first element. * * @private * @category CSS * @param el - Element to get styles from. * @param props - Optionally the names of the properties of interest. * @returns The parsed styles. */ function getCss(el: AnyNode, props?: string[]): Record; /** * Get a property from the parsed styles of the first element. * * @private * @category CSS * @param el - Element to get styles from. * @param prop - Name of the prop. * @returns The value of the property. */ function getCss(el: AnyNode, prop: string): string | undefined; function getCss( el: AnyNode, prop?: string | string[], ): Record | string | undefined { if (!el || !isTag(el)) return; const styles = parse(el.attribs['style']); if (typeof prop === 'string') { return styles[prop]; } if (Array.isArray(prop)) { const newStyles: Record = {}; for (const item of prop) { if (styles[item] != null) { newStyles[item] = styles[item]; } } return newStyles; } return styles; } /** * Stringify `obj` to styles. * * @private * @category CSS * @param obj - Object to stringify. * @returns The serialized styles. */ function stringify(obj: Record): string { return Object.keys(obj).reduce( (str, prop) => `${str}${str ? ' ' : ''}${prop}: ${obj[prop]};`, '', ); } /** * Parse `styles`. * * @private * @category CSS * @param styles - Styles to be parsed. * @returns The parsed styles. */ function parse(styles: string): Record { styles = (styles || '').trim(); if (!styles) return {}; const obj: Record = {}; let key: string | undefined; for (const str of styles.split(';')) { const n = str.indexOf(':'); // If there is no :, or if it is the first/last character, add to the previous item's value if (n < 1 || n === str.length - 1) { const trimmed = str.trimEnd(); if (trimmed.length > 0 && key !== undefined) { obj[key] += `;${trimmed}`; } } else { key = str.slice(0, n).trim(); obj[key] = str.slice(n + 1).trim(); } } return obj; } import { describe, it, expect, expectTypeOf } from 'vitest'; import * as fixtures from '../__fixtures__/fixtures.js'; import { load } from '../load-parse.js'; interface RedSelObject { red: string | undefined; sel: string | undefined; } interface RedSelMultipleObject { red: string[]; sel: string[]; } describe('$.extract', () => { it('should return an empty object when no selectors are provided', () => { const $ = load(fixtures.eleven); const $root = $.root(); expectTypeOf($root.extract({})).toEqualTypeOf>(); const emptyExtract = $root.extract({}); expect(emptyExtract).toStrictEqual({}); }); it('should return undefined for selectors that do not match any elements', () => { const $ = load(fixtures.eleven); const $root = $.root(); expectTypeOf($root.extract({ foo: 'bar' })).toEqualTypeOf<{ foo: string | undefined; }>(); const simpleExtract = $root.extract({ foo: 'bar' }); expect(simpleExtract).toStrictEqual({ foo: undefined }); }); it('should extract values for existing selectors', () => { const $ = load(fixtures.eleven); const $root = $.root(); expectTypeOf($root.extract({ red: '.red' })).toEqualTypeOf<{ red: string | undefined; }>(); expect($root.extract({ red: '.red' })).toStrictEqual({ red: 'Four' }); expectTypeOf( $root.extract({ red: '.red', sel: '.sel' }), ).toEqualTypeOf(); expect($root.extract({ red: '.red', sel: '.sel' })).toStrictEqual({ red: 'Four', sel: 'Three', }); }); it('should extract values using descriptor objects', () => { const $ = load(fixtures.eleven); const $root = $.root(); expectTypeOf( $root.extract({ red: { selector: '.red' }, sel: { selector: '.sel' }, }), ).toEqualTypeOf(); expect( $root.extract({ red: { selector: '.red' }, sel: { selector: '.sel' }, }), ).toStrictEqual({ red: 'Four', sel: 'Three' }); }); it('should extract multiple values for selectors', () => { const $ = load(fixtures.eleven); const $root = $.root(); expectTypeOf( $root.extract({ red: ['.red'], sel: ['.sel'], }), ).toEqualTypeOf<{ red: string[]; sel: string[] }>(); const multipleExtract = $root.extract({ red: ['.red'], sel: ['.sel'], }); expectTypeOf(multipleExtract).toEqualTypeOf(); expect(multipleExtract).toStrictEqual({ red: ['Four', 'Five', 'Nine'], sel: ['Three', 'Nine', 'Eleven'], }); }); it('should extract custom properties specified by the user', () => { const $ = load(fixtures.eleven); const $root = $.root(); expectTypeOf( $root.extract({ red: { selector: '.red', value: 'outerHTML' }, sel: { selector: '.sel', value: 'tagName' }, }), ).toEqualTypeOf(); expect( $root.extract({ red: { selector: '.red', value: 'outerHTML' }, sel: { selector: '.sel', value: 'tagName' }, }), ).toStrictEqual({ red: '
Four
', sel: 'LI' }); }); it('should extract multiple custom properties for selectors', () => { const $ = load(fixtures.eleven); const $root = $.root(); expectTypeOf( $root.extract({ red: [{ selector: '.red', value: 'outerHTML' }], }), ).toEqualTypeOf<{ red: string[] }>(); expect( $root.extract({ red: [{ selector: '.red', value: 'outerHTML' }], }), ).toStrictEqual({ red: [ '
Four
', '
Five
', '
Nine
', ], }); }); it('should extract values using custom extraction functions', () => { const $ = load(fixtures.eleven); const $root = $.root(); expectTypeOf( $root.extract({ red: { selector: '.red', value: (el, key) => `${key}=${$(el).text()}`, }, }), ).toEqualTypeOf<{ red: string | undefined }>(); expect( $root.extract({ red: { selector: '.red', value: (el, key) => `${key}=${$(el).text()}`, }, }), ).toStrictEqual({ red: 'red=Four' }); }); it('should correctly type check custom extraction functions returning non-string values', () => { const $ = load(fixtures.eleven); const $root = $.root(); expectTypeOf( $root.extract({ red: { selector: '.red', value: (el) => $(el).text().length, }, }), ).toEqualTypeOf<{ red: number | undefined }>(); expect( $root.extract({ red: { selector: '.red', value: (el) => $(el).text().length, }, }), ).toStrictEqual({ red: 4 }); }); it('should extract multiple values using custom extraction functions', () => { const $ = load(fixtures.eleven); const $root = $.root(); expectTypeOf( $root.extract({ red: [ { selector: '.red', value: (el, key) => `${key}=${$(el).text()}`, }, ], }), ).toEqualTypeOf<{ red: string[] }>(); expect( $root.extract({ red: [ { selector: '.red', value: (el, key) => `${key}=${$(el).text()}`, }, ], }), ).toStrictEqual({ red: ['red=Four', 'red=Five', 'red=Nine'] }); }); it('should extract nested objects based on selectors', () => { const $ = load(fixtures.eleven); const $root = $.root(); expectTypeOf( $root.extract({ section: { selector: 'ul:nth(1)', value: { red: '.red', sel: '.blue', }, }, }), ).toEqualTypeOf<{ section: { red: string | undefined; sel: string | undefined } | undefined; }>(); const subExtractObject = $root.extract({ section: { selector: 'ul:nth(1)', value: { red: '.red', sel: '.blue', }, }, }); expectTypeOf(subExtractObject).toEqualTypeOf<{ section: RedSelObject | undefined; }>(); expect(subExtractObject).toStrictEqual({ section: { red: 'Five', sel: 'Seven', }, }); }); it('should correctly type check nested objects returning non-string values', () => { const $ = load(fixtures.eleven); const $root = $.root(); expectTypeOf( $root.extract({ section: { selector: 'ul:nth(1)', value: { red: { selector: '.red', value: (el) => $(el).text().length, }, }, }, }), ).toEqualTypeOf<{ section: { red: number | undefined } | undefined; }>(); expect( $root.extract({ section: { selector: 'ul:nth(1)', value: { red: { selector: '.red', value: (el) => $(el).text().length, }, }, }, }), ).toStrictEqual({ section: { red: 4, }, }); }); it('should handle missing href properties without errors (#4239)', () => { const $ = load(fixtures.eleven); expect<{ links: string[] }>( $.extract({ links: [{ selector: 'li', value: 'href' }] }), ).toStrictEqual({ links: [] }); }); }); import type { AnyNode, Element } from 'domhandler'; import type { Cheerio } from '../cheerio.js'; import type { prop } from './attributes.js'; type ExtractDescriptorFn = ( el: Element, key: string, // TODO: This could be typed with ExtractedMap obj: Record, ) => unknown; interface ExtractDescriptor { selector: string; value?: string | ExtractDescriptorFn | ExtractMap; } type ExtractValue = string | ExtractDescriptor | [string | ExtractDescriptor]; export type ExtractMap = Record; type ExtractedValue = V extends [ string | ExtractDescriptor, ] ? NonNullable>[] : V extends string ? string | undefined : V extends ExtractDescriptor ? V['value'] extends infer U ? U extends ExtractMap ? ExtractedMap | undefined : U extends ExtractDescriptorFn ? ReturnType | undefined : ReturnType | undefined : never : never; export type ExtractedMap = { [key in keyof M]: ExtractedValue; }; function getExtractDescr( descr: string | ExtractDescriptor, ): Required { if (typeof descr === 'string') { return { selector: descr, value: 'textContent' }; } return { selector: descr.selector, value: descr.value ?? 'textContent', }; } /** * Extract multiple values from a document, and store them in an object. * * @param map - 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 An object containing the extracted values. */ export function extract( this: Cheerio, map: M, ): ExtractedMap { const ret: Record = {}; for (const key in map) { const descr = map[key]; const isArray = Array.isArray(descr); const { selector, value } = getExtractDescr(isArray ? descr[0] : descr); const fn: ExtractDescriptorFn = typeof value === 'function' ? value : typeof value === 'string' ? (el: Element) => this._make(el).prop(value) : (el: Element) => this._make(el).extract(value); if (isArray) { ret[key] = this._findBySelector(selector, Number.POSITIVE_INFINITY) .map((_, el) => fn(el, key, ret)) .get(); } else { const $ = this._findBySelector(selector, 1); ret[key] = $.length > 0 ? fn($[0], key, ret) : undefined; } } return ret as ExtractedMap; } import { describe, it, expect, beforeEach } from 'vitest'; import { type CheerioAPI } from '../index.js'; import { cheerio, forms } from '../__fixtures__/fixtures.js'; describe('$(...)', () => { let $: CheerioAPI; beforeEach(() => { $ = cheerio.load(forms); }); describe('.serializeArray', () => { it('() : should get form controls', () => { expect($('form#simple').serializeArray()).toStrictEqual([ { name: 'fruit', value: 'Apple', }, ]); }); it('() : should get nested form controls', () => { expect($('form#nested').serializeArray()).toHaveLength(2); const data = $('form#nested').serializeArray(); data.sort((a, b) => (a.value > b.value ? 1 : -1)); expect(data).toStrictEqual([ { name: 'fruit', value: 'Apple', }, { name: 'vegetable', value: 'Carrot', }, ]); }); it('() : should not get disabled form controls', () => { expect($('form#disabled').serializeArray()).toStrictEqual([]); }); it('() : should not get form controls with the wrong type', () => { expect($('form#submit').serializeArray()).toStrictEqual([ { name: 'fruit', value: 'Apple', }, ]); }); it('() : should get selected options', () => { expect($('form#select').serializeArray()).toStrictEqual([ { name: 'fruit', value: 'Orange', }, ]); }); it('() : should not get unnamed form controls', () => { expect($('form#unnamed').serializeArray()).toStrictEqual([ { name: 'fruit', value: 'Apple', }, ]); }); it('() : should get multiple selected options', () => { expect($('form#multiple').serializeArray()).toHaveLength(2); const data = $('form#multiple').serializeArray(); data.sort((a, b) => (a.value > b.value ? 1 : -1)); expect(data).toStrictEqual([ { name: 'fruit', value: 'Apple', }, { name: 'fruit', value: 'Orange', }, ]); }); it('() : should get individually selected elements', () => { const data = $('form#nested input').serializeArray(); data.sort((a, b) => (a.value > b.value ? 1 : -1)); expect(data).toStrictEqual([ { name: 'fruit', value: 'Apple', }, { name: 'vegetable', value: 'Carrot', }, ]); }); it('() : should standardize line breaks', () => { expect($('form#textarea').serializeArray()).toStrictEqual([ { name: 'fruits', value: 'Apple\r\nOrange', }, ]); }); it("() : shouldn't serialize the empty string", () => { expect($('').serializeArray()).toStrictEqual([]); expect( $('').serializeArray(), ).toStrictEqual([]); expect( $('').serializeArray(), ).toStrictEqual([ { name: 'fruit', value: 'pineapple', }, ]); }); it('() : should serialize inputs without value attributes', () => { expect($('').serializeArray()).toStrictEqual([ { name: 'fruit', value: '', }, ]); }); }); describe('.serialize', () => { it('() : should get form controls', () => { expect($('form#simple').serialize()).toBe('fruit=Apple'); }); it('() : should get nested form controls', () => { expect($('form#nested').serialize()).toBe('fruit=Apple&vegetable=Carrot'); }); it('() : should not get disabled form controls', () => { expect($('form#disabled').serialize()).toBe(''); }); it('() : should get multiple selected options', () => { expect($('form#multiple').serialize()).toBe('fruit=Apple&fruit=Orange'); }); it("() : should encode spaces as +'s", () => { expect($('form#spaces').serialize()).toBe('fruit=Blood+orange'); }); }); }); import { isTag, type AnyNode } from 'domhandler'; import type { Cheerio } from '../cheerio.js'; /* * https://github.com/jquery/jquery/blob/2.1.3/src/manipulation/var/rcheckableType.js * https://github.com/jquery/jquery/blob/2.1.3/src/serialize.js */ const submittableSelector = 'input,select,textarea,keygen'; const r20 = /%20/g; const rCRLF = /\r?\n/g; /** * Encode a set of form elements as a string for submission. * * @category Forms * @example * * ```js * $('
').serialize(); * //=> 'foo=bar' * ``` * * @returns The serialized form. * @see {@link https://api.jquery.com/serialize/} */ export function serialize(this: Cheerio): string { // Convert form elements into name/value objects const arr = this.serializeArray(); // Serialize each element into a key/value string const retArr = arr.map( (data) => `${encodeURIComponent(data.name)}=${encodeURIComponent(data.value)}`, ); // Return the resulting serialization return retArr.join('&').replace(r20, '+'); } /** * Encode a set of form elements as an array of names and values. * * @category Forms * @example * * ```js * $('
').serializeArray(); * //=> [ { name: 'foo', value: 'bar' } ] * ``` * * @returns The serialized form. * @see {@link https://api.jquery.com/serializeArray/} */ export function serializeArray( this: Cheerio, ): { name: string; value: string; }[] { // Resolve all form elements from either forms or collections of form elements return this.map((_, elem) => { const $elem = this._make(elem); if (isTag(elem) && elem.name === 'form') { return $elem.find(submittableSelector).toArray(); } return $elem.filter(submittableSelector).toArray(); }) .filter( // Verify elements have a name (`attr.name`) and are not disabled (`:enabled`) '[name!=""]:enabled' + // And cannot be clicked (`[type=submit]`) or are used in `x-www-form-urlencoded` (`[type=file]`) ':not(:submit, :button, :image, :reset, :file)' + // And are either checked/don't have a checkable state ':matches([checked], :not(:checkbox, :radio))', // Convert each of the elements to its value(s) ) .map< AnyNode, { name: string; value: string; } >((_, elem) => { const $elem = this._make(elem); const name = $elem.attr('name')!; // We have filtered for elements with a name before. // If there is no value set (e.g. `undefined`, `null`), then default value to empty const value = $elem.val() ?? ''; // If we have an array of values (e.g. `'s` */ ({ name, value: val.replace(rCRLF, '\r\n') }), ); } // Otherwise (e.g. `<input type="text">`, return only one key/value pair return { name, value: value.replace(rCRLF, '\r\n') }; }) .toArray(); } import { describe, it, expect, beforeEach } from 'vitest'; import { load, type CheerioAPI, type Cheerio } from '../index.js'; import { fruits, divcontainers, mixedText, unwrapspans, } from '../__fixtures__/fixtures.js'; import type { AnyNode, Element } from 'domhandler'; describe('$(...)', () => { let $: CheerioAPI; let $fruits: Cheerio<Element>; beforeEach(() => { $ = load(fruits); $fruits = $('#fruits'); }); describe('.wrap', () => { it('(Cheerio object) : should insert the element and add selected element(s) as its child', () => { const $redFruits = $('<div class="red-fruits"></div>'); $('.apple').wrap($redFruits); expect($fruits.children().eq(0).hasClass('red-fruits')).toBe(true); expect($('.red-fruits').children().eq(0).hasClass('apple')).toBe(true); expect($fruits.children().eq(1).hasClass('orange')).toBe(true); expect($redFruits.children()).toHaveLength(1); }); it('(element) : should wrap the base element correctly', () => { $('ul').wrap('<a></a>'); expect($('body').children()[0].tagName).toBe('a'); }); it('(document) : should ignore document node', () => { $.root().wrap('<a></a>'); expect($.root()[0]).toHaveProperty('type', 'root'); }); it('(element) : should insert the element and add selected element(s) as its child', () => { const $redFruits = $('<div class="red-fruits"></div>'); $('.apple').wrap($redFruits[0]); expect($fruits.children()[0]).toBe($redFruits[0]); expect($redFruits.children()).toHaveLength(1); expect($redFruits.children()[0]).toBe($('.apple')[0]); expect($fruits.children()[1]).toBe($('.orange')[0]); }); it('(html) : should insert the markup and add selected element(s) as its child', () => { $('.apple').wrap('<div class="red-fruits"> </div>'); expect($fruits.children().eq(0).hasClass('red-fruits')).toBe(true); expect($('.red-fruits').children().eq(0).hasClass('apple')).toBe(true); expect($fruits.children().eq(1).hasClass('orange')).toBe(true); expect($('.red-fruits').children()).toHaveLength(1); }); it('(html) : discards extraneous markup', () => { $('.apple').wrap('<div></div><p></p>'); expect($('div')).toHaveLength(1); expect($('p')).toHaveLength(0); }); it('(html) : wraps with nested elements', () => { const $orangeFruits = $( '<div class="orange-fruits"><div class="and-stuff"></div></div>', ); $('.orange').wrap($orangeFruits); expect($fruits.children().eq(1).hasClass('orange-fruits')).toBe(true); expect($('.orange-fruits').children().eq(0).hasClass('and-stuff')).toBe( true, ); expect($fruits.children().eq(2).hasClass('pear')).toBe(true); expect($('.orange-fruits').children()).toHaveLength(1); }); it('(html) : should only worry about the first tag children', () => { const delicious = '<span> This guy is delicious: <b></b></span>'; $('.apple').wrap(delicious); expect($('b>.apple')).toHaveLength(1); }); it('(selector) : wraps the content with a copy of the first matched element', () => { $('.apple').wrap('.orange, .pear'); const $oranges = $('.orange'); expect($('.pear')).toHaveLength(1); expect($oranges).toHaveLength(2); expect($oranges.eq(0).parent()[0]).toBe($fruits[0]); expect($oranges.eq(0).children()).toHaveLength(1); expect($oranges.eq(0).children()[0]).toBe($('.apple')[0]); expect($('.apple').parent()[0]).toBe($oranges[0]); expect($oranges.eq(1).children()).toHaveLength(0); }); it('(fn) : should invoke the provided function with the correct arguments and context', () => { const $children = $fruits.children(); const args: [number, AnyNode][] = []; const thisValues: AnyNode[] = []; $children.wrap(function (...myArgs) { args.push(myArgs); thisValues.push(this); return ''; }); expect(args).toStrictEqual([ [0, $children[0]], [1, $children[1]], [2, $children[2]], ]); expect(thisValues).toStrictEqual([ $children[0], $children[1], $children[2], ]); }); it('(fn) : should use the returned HTML to wrap each element', () => { const $children = $fruits.children(); const tagNames = ['div', 'span', 'p']; $children.wrap(() => `<${tagNames.shift()}>`); expect($fruits.find('div')).toHaveLength(1); expect($fruits.find('div')[0]).toBe($fruits.children()[0]); expect($fruits.find('.apple')).toHaveLength(1); expect($fruits.find('.apple').parent()[0]).toBe($fruits.find('div')[0]); expect($fruits.find('span')).toHaveLength(1); expect($fruits.find('span')[0]).toBe($fruits.children()[1]); expect($fruits.find('.orange')).toHaveLength(1); expect($fruits.find('.orange').parent()[0]).toBe($fruits.find('span')[0]); expect($fruits.find('p')).toHaveLength(1); expect($fruits.find('p')[0]).toBe($fruits.children()[2]); expect($fruits.find('.pear')).toHaveLength(1); expect($fruits.find('.pear').parent()[0]).toBe($fruits.find('p')[0]); }); it('(fn) : should use the returned Cheerio object to wrap each element', () => { const $children = $fruits.children(); const tagNames = ['span', 'p', 'div']; $children.wrap(() => $(`<${tagNames.shift()}>`)); expect($fruits.find('span')).toHaveLength(1); expect($fruits.find('span')[0]).toBe($fruits.children()[0]); expect($fruits.find('.apple')).toHaveLength(1); expect($fruits.find('.apple').parent()[0]).toBe($fruits.find('span')[0]); expect($fruits.find('p')).toHaveLength(1); expect($fruits.find('p')[0]).toBe($fruits.children()[1]); expect($fruits.find('.orange')).toHaveLength(1); expect($fruits.find('.orange').parent()[0]).toBe($fruits.find('p')[0]); expect($fruits.find('div')).toHaveLength(1); expect($fruits.find('div')[0]).toBe($fruits.children()[2]); expect($fruits.find('.pear')).toHaveLength(1); expect($fruits.find('.pear').parent()[0]).toBe($fruits.find('div')[0]); }); it('($(...)) : for each element it should add a wrapper elment and add the selected element as its child', () => { const $fruitDecorator = $('<div class="fruit-decorator"></div>'); $('li').wrap($fruitDecorator); expect($fruits.children().eq(0).hasClass('fruit-decorator')).toBe(true); expect($fruits.children().eq(0).children().eq(0).hasClass('apple')).toBe( true, ); expect($fruits.children().eq(1).hasClass('fruit-decorator')).toBe(true); expect($fruits.children().eq(1).children().eq(0).hasClass('orange')).toBe( true, ); expect($fruits.children().eq(2).hasClass('fruit-decorator')).toBe(true); expect($fruits.children().eq(2).children().eq(0).hasClass('pear')).toBe( true, ); }); }); describe('.wrapInner', () => { it('(Cheerio object) : should insert the element and add selected element(s) as its parent', () => { const $container = $('<div class="container"></div>') as Cheerio<Element>; $fruits.wrapInner($container); expect($fruits.children()[0]).toBe($container[0]); expect($container[0].parent).toBe($fruits[0]); expect($container[0].children[0]).toBe($('.apple')[0]); expect($container[0].children[1]).toBe($('.orange')[0]); expect($('.apple')[0].parent).toBe($container[0]); expect($fruits.children()).toHaveLength(1); expect($container.children()).toHaveLength(3); }); it('(element) : should insert the element and add selected element(s) as its parent', () => { const $container = $('<div class="container"></div>') as Cheerio<Element>; $fruits.wrapInner($container[0]); expect($fruits.children()[0]).toBe($container[0]); expect($container[0].parent).toBe($fruits[0]); expect($container[0].children[0]).toBe($('.apple')[0]); expect($container[0].children[1]).toBe($('.orange')[0]); expect($('.apple')[0].parent).toBe($container[0]); expect($fruits.children()).toHaveLength(1); expect($container.children()).toHaveLength(3); }); it('(html) : should ignore text nodes', () => { const $test = load(mixedText); $test($test('body')[0].children).wrapInner('<test>'); expect($test('body').html()).toBe( '<a><test>1</test></a>TEXT<b><test>2</test></b>', ); }); it('(html) : should insert the element and add selected element(s) as its parent', () => { $fruits.wrapInner('<div class="container"></div>'); expect($fruits.children()[0]).toBe($('.container')[0]); expect($('.container')[0].parent).toBe($fruits[0]); expect($('.container')[0].children[0]).toBe($('.apple')[0]); expect($('.container')[0].children[1]).toBe($('.orange')[0]); expect($('.apple')[0].parent).toBe($('.container')[0]); expect($fruits.children()).toHaveLength(1); expect($('.container').children()).toHaveLength(3); }); it("(selector) : should wrap the html of the element with the selector's first match", () => { $('.apple').wrapInner('.orange, .pear'); const $oranges = $('.orange'); expect($('.pear')).toHaveLength(1); expect($oranges).toHaveLength(2); expect($oranges.eq(0).parent()[0]).toBe($('.apple')[0]); expect($oranges.eq(0).text()).toBe('Apple'); expect($('.apple').eq(0).children()[0]).toBe($oranges[0]); expect($oranges.eq(1).parent()[0]).toBe($fruits[0]); expect($oranges.eq(1).text()).toBe('Orange'); }); it('(fn) : should invoke the provided function with the correct arguments and context', () => { const $children = $fruits.children(); const args: [number, AnyNode][] = []; const thisValues: AnyNode[] = []; $children.wrapInner(function (...myArgs) { args.push(myArgs); thisValues.push(this); return this; }); expect(args).toStrictEqual([ [0, $children[0]], [1, $children[1]], [2, $children[2]], ]); expect(thisValues).toStrictEqual([ $children[0], $children[1], $children[2], ]); }); it("(fn) : should use the returned HTML to wrap each element's contents", () => { const $children = $fruits.children(); const tagNames = ['div', 'span', 'p']; $children.wrapInner(() => `<${tagNames.shift()}>`); expect($fruits.find('div')).toHaveLength(1); expect($fruits.find('div')[0]).toBe($('.apple').children()[0]); expect($fruits.find('.apple')).toHaveLength(1); expect($fruits.find('span')).toHaveLength(1); expect($fruits.find('span')[0]).toBe($('.orange').children()[0]); expect($fruits.find('.orange')).toHaveLength(1); expect($fruits.find('p')).toHaveLength(1); expect($fruits.find('p')[0]).toBe($('.pear').children()[0]); expect($fruits.find('.pear')).toHaveLength(1); }); it("(fn) : should use the returned Cheerio object to wrap each element's contents", () => { const $children = $fruits.children(); const tags = [$('<div></div>'), $('<span></span>'), $('<p></p>')]; $children.wrapInner(() => tags.shift()!); expect($fruits.find('div')).toHaveLength(1); expect($fruits.find('div')[0]).toBe($('.apple').children()[0]); expect($fruits.find('.apple')).toHaveLength(1); expect($fruits.find('span')).toHaveLength(1); expect($fruits.find('span')[0]).toBe($('.orange').children()[0]); expect($fruits.find('.orange')).toHaveLength(1); expect($fruits.find('p')).toHaveLength(1); expect($fruits.find('p')[0]).toBe($('.pear').children()[0]); expect($fruits.find('.pear')).toHaveLength(1); }); it('($(...)) : for each element it should add a wrapper elment and add the selected element as its child', () => { const $fruitDecorator = $('<div class="fruit-decorator"></div>'); const $children = $fruits.children(); $('li').wrapInner($fruitDecorator); expect($('.fruit-decorator')).toHaveLength(3); expect($children.eq(0).children().eq(0).hasClass('fruit-decorator')).toBe( true, ); expect($children.eq(0).hasClass('apple')).toBe(true); expect($children.eq(1).children().eq(0).hasClass('fruit-decorator')).toBe( true, ); expect($children.eq(1).hasClass('orange')).toBe(true); expect($children.eq(2).children().eq(0).hasClass('fruit-decorator')).toBe( true, ); expect($children.eq(2).hasClass('pear')).toBe(true); }); it('(html) : wraps with nested elements', () => { const $badOrangeJoke = $( '<div class="orange-you-glad"><div class="i-didnt-say-apple"></div></div>', ); $('.orange').wrapInner($badOrangeJoke); expect($('.orange').children().eq(0).hasClass('orange-you-glad')).toBe( true, ); expect( $('.orange-you-glad').children().eq(0).hasClass('i-didnt-say-apple'), ).toBe(true); expect($fruits.children().eq(2).hasClass('pear')).toBe(true); expect($('.orange-you-glad').children()).toHaveLength(1); }); it('(html) : should only worry about the first tag children', () => { const delicious = '<span> This guy is delicious: <b></b></span>'; $('.apple').wrapInner(delicious); expect($('.apple>span>b')).toHaveLength(1); expect($('.apple>span>b').text()).toBe('Apple'); }); }); describe('.unwrap', () => { let $elem: CheerioAPI; beforeEach(() => { $elem = load(unwrapspans); }); it('() : should be unwrap span elements', () => { const abcd = $elem('#unwrap1 > span, #unwrap2 > span').get(); const abcdef = $elem('#unwrap span').get(); // Make #unwrap1 and #unwrap2 go away expect( $elem('#unwrap1 span').add('#unwrap2 span:first-child').unwrap(), ).toHaveLength(3); /* * .toEqual * all four spans should still exist */ expect($elem('#unwrap > span').get()).toEqual(abcd); // Make all b elements in #unwrap3 go away expect($elem('#unwrap3 span').unwrap().get()).toEqual( $elem('#unwrap3 > span').get(), ); // Make #unwrap3 go away expect($elem('#unwrap3 span').unwrap().get()).toEqual( $elem('#unwrap > span.unwrap3').get(), ); // #unwrap only contains 6 child spans expect($elem('#unwrap').children().get()).toEqual(abcdef); // Make the 6 spans become children of body expect($elem('#unwrap > span').unwrap().get()).toEqual( $elem('body > span.unwrap').get(), ); // Can't unwrap children of body expect($elem('body > span.unwrap').unwrap().get()).toEqual( $elem('body > span.unwrap').get(), ); // Can't unwrap children of body expect($elem('body > span.unwrap').unwrap().get()).toEqual(abcdef); // Can't unwrap children of body expect($elem('body > span.unwrap').get()).toEqual(abcdef); }); it('(selector) : should only unwrap element parent what specified', () => { const abcd = $elem('#unwrap1 > span, #unwrap2 > span').get(); // Shouldn't unwrap, no match $elem('#unwrap1 span').unwrap('#unwrap2'); expect($elem('#unwrap1')).toHaveLength(1); // Shouldn't unwrap, no match $elem('#unwrap1 span').unwrap('span'); expect($elem('#unwrap1')).toHaveLength(1); // Unwraps $elem('#unwrap1 span').unwrap('#unwrap1'); expect($elem('#unwrap1')).toHaveLength(0); // Should not unwrap - unmatched unwrap $elem('#unwrap2 span').unwrap('quote'); expect($elem('#unwrap > span')).toHaveLength(2); // Check return values - matched unwrap $elem('#unwrap2 span').unwrap('#unwrap2'); expect($elem('#unwrap > span').get()).toEqual(abcd); }); }); describe('.wrapAll', () => { let doc: CheerioAPI; let $inner: Cheerio<Element>; beforeEach(() => { doc = load(divcontainers); $inner = doc('.inner'); }); it('(Cheerio object) : should insert the element and wrap elements with it', () => { $inner.wrapAll(doc('#new')); const $container = doc('.container'); const $wrap = doc('b'); expect($container).toHaveLength(2); expect($container[0].children).toHaveLength(1); expect($container[1].children).toHaveLength(0); expect($container[0].children[0]).toBe(doc('#new')[0]); expect($inner).toHaveLength(4); expect($wrap[0].children).toHaveLength(4); expect($inner[0].parent).toBe($wrap[0]); expect($inner[1].parent).toBe($wrap[0]); expect($inner[2].parent).toBe($wrap[0]); expect($inner[3].parent).toBe($wrap[0]); }); it('(html) : should wrap elements with it', () => { $inner.wrapAll('<div class="wrap"></div>'); const $container = doc('.container'); const $wrap = doc('.wrap'); expect($inner).toHaveLength(4); expect($container).toHaveLength(2); expect($wrap).toHaveLength(1); expect($wrap[0].children).toHaveLength(4); expect($container[0].children).toHaveLength(1); expect($container[1].children).toHaveLength(0); expect($inner[0].parent).toBe($wrap[0]); expect($inner[1].parent).toBe($wrap[0]); expect($inner[2].parent).toBe($wrap[0]); expect($inner[3].parent).toBe($wrap[0]); expect($wrap[0].parent).toBe($container[0]); expect($container[0].children[0]).toBe($wrap[0]); }); it('(html) : should wrap single element with it', () => { const parent = doc('<p>').wrapAll('<div></div>').parent(); expect(parent).toHaveLength(1); expect(parent.is('div')).toBe(true); }); it('(selector) : should find element from dom, wrap elements with it', () => { $inner.wrapAll('#new'); const $container = doc('.container'); const $wrap = doc('b'); const $new = doc('#new'); expect($inner).toHaveLength(4); expect($container).toHaveLength(2); expect($container[0].children).toHaveLength(1); expect($container[1].children).toHaveLength(0); expect($wrap[0].children).toHaveLength(4); expect($inner[0].parent).toBe($wrap[0]); expect($inner[1].parent).toBe($wrap[0]); expect($inner[2].parent).toBe($wrap[0]); expect($inner[3].parent).toBe($wrap[0]); expect($new[0].parent).toBe($container[0]); expect($container[0].children[0]).toBe($new[0]); }); it('(function) : check execution', () => { const $container = doc('.container'); const p = $container[0].parent; const result = $container.wrapAll( () => "<div class='red'><div class='tmp'></div></div>", ); expect(result.parent()).toHaveLength(1); expect($container.eq(0).parent().parent().is('.red')).toBe(true); expect($container.eq(1).parent().parent().is('.red')).toBe(true); expect($container.eq(0).parent().parent().parent().is(p)).toBe(true); }); it('(function) : check execution characteristics', () => { const $new = doc('#new'); let i = 0; doc('no-result').wrapAll(() => { i++; return ''; }); expect(i).toBeFalsy(); $new.wrapAll(function (index) { expect(this).toBe($new[0]); expect(index).toBe(0); return this; }); }); it('(nodes) : should skip text nodes', () => { const $text = load(mixedText); const $body = $text($text('body')[0].children); $body.wrapAll($text('body')[0].children.slice(1)); expect($text('body').html()).toBe('TEXT<b>2<a>1</a>TEXT<b>2</b></b>'); }); }); describe('.append', () => { it('() : should do nothing', () => { expect($('#fruits').append()[0].tagName).toBe('ul'); }); it('(null) : should do nothing', () => { $fruits.append(null as never); expect($fruits.children()).toHaveLength(3); }); it('(html) : should add element as last child', () => { $fruits.append('<li class="plum">Plum</li>'); expect($fruits.children().eq(3).hasClass('plum')).toBe(true); }); it('(html) : should not fail on text nodes', () => { expect($(mixedText).append(' UP').html()).toBe('1 UP'); }); it('($(...)) : should add element as last child', () => { const $plum = $('<li class="plum">Plum</li>'); $fruits.append($plum); expect($fruits.children().eq(3).hasClass('plum')).toBe(true); }); it('(Node) : should add element as last child', () => { const plum = $('<li class="plum">Plum</li>')[0]; $fruits.append(plum); expect($fruits.children().eq(3).hasClass('plum')).toBe(true); }); it('(existing Node) : should remove node from previous location', () => { const apple = $fruits.children()[0]; expect($fruits.children()).toHaveLength(3); $fruits.append(apple); const $children = $fruits.children(); expect($children).toHaveLength(3); expect($children[0]).not.toBe(apple); expect($children[2]).toBe(apple); }); it('(existing Node) : should remove existing node from previous location', () => { const apple = $fruits.children()[0]; const $dest = $('<div></div>'); expect($fruits.children()).toHaveLength(3); $dest.append(apple); const $children = $fruits.children(); expect($children).toHaveLength(2); expect($children[0]).not.toBe(apple); expect($dest.children()).toHaveLength(1); expect($dest.children()[0]).toBe(apple); }); it('(existing Node) : should update original direct siblings', () => { $('.pear').append($('.orange')); expect($('.apple').next()[0]).toBe($('.pear')[0]); expect($('.pear').prev()[0]).toBe($('.apple')[0]); }); it('(existing Node) : should clone all but the last occurrence', () => { const $originalApple = $('.apple'); $('.orange, .pear').append($originalApple); const $apples = $('.apple'); expect($apples).toHaveLength(2); expect($apples.eq(0).parent()[0]).toBe($('.orange')[0]); expect($apples.eq(1).parent()[0]).toBe($('.pear')[0]); expect($apples[1]).toBe($originalApple[0]); }); it('(elem) : should NOP if removed', () => { const $apple = $('.apple'); $apple.remove(); $fruits.append($apple); expect($fruits.children().eq(2).hasClass('apple')).toBe(true); }); it('($(...), html) : should add multiple elements as last children', () => { const $plum = $('<li class="plum">Plum</li>'); const grape = '<li class="grape">Grape</li>'; $fruits.append($plum, grape); expect($fruits.children().eq(3).hasClass('plum')).toBe(true); expect($fruits.children().eq(4).hasClass('grape')).toBe(true); }); it('(Array) : should append all elements in the array', () => { const more = $( '<li class="plum">Plum</li><li class="grape">Grape</li>', ).get(); $fruits.append(more); expect($fruits.children().eq(3).hasClass('plum')).toBe(true); expect($fruits.children().eq(4).hasClass('grape')).toBe(true); }); it('(fn) : should invoke the callback with the correct arguments and context', () => { const $fruits = $('#fruits').children(); const args: [number, string][] = []; const thisValues: AnyNode[] = []; $fruits.append(function (...myArgs) { args.push(myArgs); thisValues.push(this); return this; }); expect(args).toStrictEqual([ [0, 'Apple'], [1, 'Orange'], [2, 'Pear'], ]); expect(thisValues).toStrictEqual([$fruits[0], $fruits[1], $fruits[2]]); }); it('(fn) : should add returned string as last child', () => { const $fruits = $('#fruits').children(); $fruits.append(() => '<div class="first">'); const $apple = $fruits.eq(0); const $orange = $fruits.eq(1); const $pear = $fruits.eq(2); expect($apple.find('.first')[0]).toBe($apple.contents()[1]); expect($orange.find('.first')[0]).toBe($orange.contents()[1]); expect($pear.find('.first')[0]).toBe($pear.contents()[1]); }); it('(fn) : should add returned Cheerio object as last child', () => { const $fruits = $('#fruits').children(); $fruits.append(() => $('<div class="second">')); const $apple = $fruits.eq(0); const $orange = $fruits.eq(1); const $pear = $fruits.eq(2); expect($apple.find('.second')[0]).toBe($apple.contents()[1]); expect($orange.find('.second')[0]).toBe($orange.contents()[1]); expect($pear.find('.second')[0]).toBe($pear.contents()[1]); }); it('(fn) : should add returned Node as last child', () => { const $fruits = $('#fruits').children(); $fruits.append(() => $('<div class="third">')[0]); const $apple = $fruits.eq(0); const $orange = $fruits.eq(1); const $pear = $fruits.eq(2); expect($apple.find('.third')[0]).toBe($apple.contents()[1]); expect($orange.find('.third')[0]).toBe($orange.contents()[1]); expect($pear.find('.third')[0]).toBe($pear.contents()[1]); }); it('should maintain correct object state (Issue: #10)', () => { const $obj = $('<div></div>') .append('<div><div></div></div>') .children() .children() .parent(); expect($obj).toBeTruthy(); }); it('($(...)) : should remove from root element', () => { const $plum = $('<li class="plum">Plum</li>'); const { parent } = $plum[0]; expect(parent).toBeTruthy(); $fruits.append($plum); expect($plum[0].parent?.type).not.toBe('root'); expect(parent?.childNodes).not.toContain($plum[0]); }); }); describe('.prepend', () => { it('() : should do nothing', () => { expect($('#fruits').prepend()[0].tagName).toBe('ul'); }); it('(html) : should add element as first child', () => { $fruits.prepend('<li class="plum">Plum</li>'); expect($fruits.children().eq(0).hasClass('plum')).toBe(true); }); it('($(...)) : should add element as first child', () => { const $plum = $('<li class="plum">Plum</li>'); $fruits.prepend($plum); expect($fruits.children().eq(0).hasClass('plum')).toBe(true); }); it('($(...)) : should add style element as first child', () => { const $style = $('<style>.foo {}</style>'); $fruits.prepend($style); const styleTag = $fruits.children().get(0); expect(styleTag?.tagName).toBe('style'); expect(styleTag?.children[0]).toHaveProperty('data', '.foo {}'); }); it('($(...)) : should add script element as first child', () => { const $script = $('<script>var foo;</script>'); $fruits.prepend($script); const scriptTag = $fruits.children().get(0); expect(scriptTag?.tagName).toBe('script'); expect(scriptTag?.children[0]).toHaveProperty('data', 'var foo;'); }); it('(Node) : should add node as first child', () => { const plum = $('<li class="plum">Plum</li>')[0]; $fruits.prepend(plum); expect($fruits.children().eq(0).hasClass('plum')).toBe(true); }); it('(existing Node) : should remove existing nodes from previous locations', () => { const pear = $fruits.children()[2]; expect($fruits.children()).toHaveLength(3); $fruits.prepend(pear); const $children = $fruits.children(); expect($children).toHaveLength(3); expect($children[2]).not.toBe(pear); expect($children[0]).toBe(pear); }); it('(existing Node) : should update original direct siblings', () => { $('.pear').prepend($('.orange')); expect($('.apple').next()[0]).toBe($('.pear')[0]); expect($('.pear').prev()[0]).toBe($('.apple')[0]); }); it('(existing Node) : should clone all but the last occurrence', () => { const $originalApple = $('.apple'); $('.orange, .pear').prepend($originalApple); const $apples = $('.apple'); expect($apples).toHaveLength(2); expect($apples.eq(0).parent()[0]).toBe($('.orange')[0]); expect($apples.eq(1).parent()[0]).toBe($('.pear')[0]); expect($apples[1]).toBe($originalApple[0]); }); it('(elem) : should handle if removed', () => { const $apple = $('.apple'); $apple.remove(); $fruits.prepend($apple); expect($fruits.children().eq(0).hasClass('apple')).toBe(true); }); it('(Array) : should add all elements in the array as initial children', () => { const more = $( '<li class="plum">Plum</li><li class="grape">Grape</li>', ).get(); $fruits.prepend(more); expect($fruits.children().eq(0).hasClass('plum')).toBe(true); expect($fruits.children().eq(1).hasClass('grape')).toBe(true); }); it('(html, $(...), html) : should add multiple elements as first children', () => { const $plum = $('<li class="plum">Plum</li>'); const grape = '<li class="grape">Grape</li>'; $fruits.prepend($plum, grape); expect($fruits.children().eq(0).hasClass('plum')).toBe(true); expect($fruits.children().eq(1).hasClass('grape')).toBe(true); }); it('(fn) : should invoke the callback with the correct arguments and context', () => { const args: [number, string][] = []; const thisValues: AnyNode[] = []; const $fruits = $('#fruits').children(); $fruits.prepend(function (...myArgs) { args.push(myArgs); thisValues.push(this); return this; }); expect(args).toStrictEqual([ [0, 'Apple'], [1, 'Orange'], [2, 'Pear'], ]); expect(thisValues).toStrictEqual([$fruits[0], $fruits[1], $fruits[2]]); }); it('(fn) : should add returned string as first child', () => { const $fruits = $('#fruits').children(); $fruits.prepend(() => '<div class="first">'); const $apple = $fruits.eq(0); const $orange = $fruits.eq(1); const $pear = $fruits.eq(2); expect($apple.find('.first')[0]).toBe($apple.contents()[0]); expect($orange.find('.first')[0]).toBe($orange.contents()[0]); expect($pear.find('.first')[0]).toBe($pear.contents()[0]); }); it('(fn) : should add returned Cheerio object as first child', () => { const $fruits = $('#fruits').children(); $fruits.prepend(() => $('<div class="second">')); const $apple = $fruits.eq(0); const $orange = $fruits.eq(1); const $pear = $fruits.eq(2); expect($apple.find('.second')[0]).toBe($apple.contents()[0]); expect($orange.find('.second')[0]).toBe($orange.contents()[0]); expect($pear.find('.second')[0]).toBe($pear.contents()[0]); }); it('(fn) : should add returned Node as first child', () => { const $fruits = $('#fruits').children(); $fruits.prepend(() => $('<div class="third">')[0]); const $apple = $fruits.eq(0); const $orange = $fruits.eq(1); const $pear = $fruits.eq(2); expect($apple.find('.third')[0]).toBe($apple.contents()[0]); expect($orange.find('.third')[0]).toBe($orange.contents()[0]); expect($pear.find('.third')[0]).toBe($pear.contents()[0]); }); it('($(...)) : should remove from root element', () => { const $plum = $('<li class="plum">Plum</li>'); const root = $plum[0].parent; expect(root?.type).toBe('root'); $fruits.prepend($plum); expect($plum[0].parent?.type).not.toBe('root'); expect(root?.childNodes).not.toContain($plum[0]); }); }); describe('.appendTo', () => { it('(html) : should add element as last child', () => { const $plum = $('<li class="plum">Plum</li>').appendTo(fruits); expect($plum.parent().children().eq(3).hasClass('plum')).toBe(true); }); it('($(...)) : should add element as last child', () => { $('<li class="plum">Plum</li>').appendTo($fruits); expect($fruits.children().eq(3).hasClass('plum')).toBe(true); }); it('(Node) : should add element as last child', () => { $('<li class="plum">Plum</li>').appendTo($fruits[0]); expect($fruits.children().eq(3).hasClass('plum')).toBe(true); }); it('(selector) : should add element as last child', () => { $('<li class="plum">Plum</li>').appendTo('#fruits'); expect($fruits.children().eq(3).hasClass('plum')).toBe(true); }); it('(Array) : should add element as last child of all elements in the array', () => { const $multiple = $('<ul><li>Apple</li></ul><ul><li>Orange</li></ul>'); $('<li class="plum">Plum</li>').appendTo($multiple.get()); expect($multiple.first().children().eq(1).hasClass('plum')).toBe(true); expect($multiple.last().children().eq(1).hasClass('plum')).toBe(true); }); }); describe('.prependTo', () => { it('(html) : should add element as first child', () => { const $plum = $('<li class="plum">Plum</li>').prependTo(fruits); expect($plum.parent().children().eq(0).hasClass('plum')).toBe(true); }); it('($(...)) : should add element as first child', () => { $('<li class="plum">Plum</li>').prependTo($fruits); expect($fruits.children().eq(0).hasClass('plum')).toBe(true); }); it('(Node) : should add node as first child', () => { $('<li class="plum">Plum</li>').prependTo($fruits[0]); expect($fruits.children().eq(0).hasClass('plum')).toBe(true); }); it('(selector) : should add element as first child', () => { $('<li class="plum">Plum</li>').prependTo('#fruits'); expect($fruits.children().eq(0).hasClass('plum')).toBe(true); }); it('(Array) : should add element as first child of all elements in the array', () => { const $multiple = $('<ul><li>Apple</li></ul><ul><li>Orange</li></ul>'); $('<li class="plum">Plum</li>').prependTo($multiple.get()); expect($multiple.first().children().eq(0).hasClass('plum')).toBe(true); expect($multiple.last().children().eq(0).hasClass('plum')).toBe(true); }); }); describe('.after', () => { it('() : should do nothing', () => { expect($fruits.after()[0].tagName).toBe('ul'); }); it('(html) : should add element as next sibling', () => { const grape = '<li class="grape">Grape</li>'; $('.apple').after(grape); expect($('.apple').next().hasClass('grape')).toBe(true); }); it('(Array) : should add all elements in the array as next sibling', () => { const more = $( '<li class="plum">Plum</li><li class="grape">Grape</li>', ).get(); $('.apple').after(more); expect($fruits.children().eq(1).hasClass('plum')).toBe(true); expect($fruits.children().eq(2).hasClass('grape')).toBe(true); }); it('($(...)) : should add element as next sibling', () => { const $plum = $('<li class="plum">Plum</li>'); $('.apple').after($plum); expect($('.apple').next().hasClass('plum')).toBe(true); }); it('(Node) : should add element as next sibling', () => { const plum = $('<li class="plum">Plum</li>')[0]; $('.apple').after(plum); expect($('.apple').next().hasClass('plum')).toBe(true); }); it('(existing Node) : should remove existing nodes from previous locations', () => { const pear = $fruits.children()[2]; $('.apple').after(pear); const $children = $fruits.children(); expect($children).toHaveLength(3); expect($children[1]).toBe(pear); }); it('(existing Node) : should update original direct siblings', () => { $('.pear').after($('.orange')); expect($('.apple').next()[0]).toBe($('.pear')[0]); expect($('.pear').prev()[0]).toBe($('.apple')[0]); }); it('(existing Node) : should clone all but the last occurrence', () => { const $originalApple = $('.apple'); $('.orange, .pear').after($originalApple); expect($('.apple')).toHaveLength(2); expect($('.apple').eq(0).prev()[0]).toBe($('.orange')[0]); expect($('.apple').eq(0).next()[0]).toBe($('.pear')[0]); expect($('.apple').eq(1).prev()[0]).toBe($('.pear')[0]); expect($('.apple').eq(1).next()).toHaveLength(0); expect($('.apple')[0]).not.toStrictEqual($originalApple[0]); expect($('.apple')[1]).toStrictEqual($originalApple[0]); }); it('(elem) : should handle if removed', () => { const $apple = $('.apple'); const $plum = $('<li class="plum">Plum</li>'); $apple.remove(); $apple.after($plum); expect($plum.prev()).toHaveLength(0); }); it('($(...), html) : should add multiple elements as next siblings', () => { const $plum = $('<li class="plum">Plum</li>'); const grape = '<li class="grape">Grape</li>'; $('.apple').after($plum, grape); expect($('.apple').next().hasClass('plum')).toBe(true); expect($('.plum').next().hasClass('grape')).toBe(true); }); it('(fn) : should invoke the callback with the correct arguments and context', () => { const args: [number, string][] = []; const thisValues: AnyNode[] = []; const $fruits = $('#fruits').children(); $fruits.after(function (...myArgs) { args.push(myArgs); thisValues.push(this); return this; }); expect(args).toStrictEqual([ [0, 'Apple'], [1, 'Orange'], [2, 'Pear'], ]); expect(thisValues).toStrictEqual([$fruits[0], $fruits[1], $fruits[2]]); }); it('(fn) : should add returned string as next sibling', () => { const $fruits = $('#fruits').children(); $fruits.after(() => '<li class="first">'); expect($('.first')[0]).toBe($('#fruits').contents()[1]); expect($('.first')[1]).toBe($('#fruits').contents()[3]); expect($('.first')[2]).toBe($('#fruits').contents()[5]); }); it('(fn) : should add returned Cheerio object as next sibling', () => { const $fruits = $('#fruits').children(); $fruits.after(() => $('<li class="second">')); expect($('.second')[0]).toBe($('#fruits').contents()[1]); expect($('.second')[1]).toBe($('#fruits').contents()[3]); expect($('.second')[2]).toBe($('#fruits').contents()[5]); }); it('(fn) : should add returned element as next sibling', () => { const $fruits = $('#fruits').children(); $fruits.after(() => $('<li class="third">')[0]); expect($('.third')[0]).toBe($('#fruits').contents()[1]); expect($('.third')[1]).toBe($('#fruits').contents()[3]); expect($('.third')[2]).toBe($('#fruits').contents()[5]); }); it('(fn) : should support text nodes', () => { const $text = load(mixedText); $text($text('body')[0].children).after( (_, content) => `<c>${content}added</c>`, ); expect($text('body').html()).toBe( '<a>1</a><c>1added</c>TEXT<b>2</b><c>2added</c>', ); }); it('($(...)) : should remove from root element', () => { const $plum = $('<li class="plum">Plum</li>'); const root = $plum[0].parent; expect(root?.type).toBe('root'); $fruits.after($plum); expect($plum[0].parent?.type).not.toBe('root'); expect(root?.childNodes).not.toContain($plum[0]); }); }); describe('.insertAfter', () => { it('(selector) : should create element and add as next sibling', () => { const grape = $('<li class="grape">Grape</li>'); grape.insertAfter('.apple'); expect($('.apple').next().hasClass('grape')).toBe(true); }); it('(selector) : should create element and add as next sibling of multiple elements', () => { const grape = $('<li class="grape">Grape</li>'); grape.insertAfter('.apple, .pear'); expect($('.apple').next().hasClass('grape')).toBe(true); expect($('.pear').next().hasClass('grape')).toBe(true); }); it('($(...)) : should create element and add as next sibling', () => { const grape = $('<li class="grape">Grape</li>'); grape.insertAfter($('.apple')); expect($('.apple').next().hasClass('grape')).toBe(true); }); it('($(...)) : should create element and add as next sibling of multiple elements', () => { const grape = $('<li class="grape">Grape</li>'); grape.insertAfter($('.apple, .pear')); expect($('.apple').next().hasClass('grape')).toBe(true); expect($('.pear').next().hasClass('grape')).toBe(true); }); it('($(...)) : should create all elements in the array and add as next siblings', () => { const more = $('<li class="plum">Plum</li><li class="grape">Grape</li>'); more.insertAfter($('.apple')); expect($fruits.children().eq(0).hasClass('apple')).toBe(true); expect($fruits.children().eq(1).hasClass('plum')).toBe(true); expect($fruits.children().eq(2).hasClass('grape')).toBe(true); }); it('(existing Node) : should remove existing nodes from previous locations', () => { $('.orange').insertAfter('.pear'); expect($fruits.children().eq(1).hasClass('orange')).toBe(false); expect($fruits.children().length).toBe(3); expect($('.orange').length).toBe(1); }); it('(existing Node) : should update original direct siblings', () => { $('.orange').insertAfter('.pear'); expect($('.apple').next().hasClass('pear')).toBe(true); expect($('.pear').prev().hasClass('apple')).toBe(true); expect($('.pear').next().hasClass('orange')).toBe(true); expect($('.orange').next()).toHaveLength(0); }); it('(existing Node) : should update original direct siblings of multiple elements', () => { $('.apple').insertAfter('.orange, .pear'); expect($('.orange').prev()).toHaveLength(0); expect($('.orange').next().hasClass('apple')).toBe(true); expect($('.pear').next().hasClass('apple')).toBe(true); expect($('.pear').prev().hasClass('apple')).toBe(true); expect($fruits.children().length).toBe(4); const apples = $('.apple'); expect(apples.length).toBe(2); expect(apples.eq(0).prev().hasClass('orange')).toBe(true); expect(apples.eq(1).prev().hasClass('pear')).toBe(true); }); it('(elem) : should handle if removed', () => { const $apple = $('.apple'); const $plum = $('<li class="plum">Plum</li>'); $apple.remove(); $plum.insertAfter($apple); expect($plum.prev()).toHaveLength(0); }); it('(single) should return the new element for chaining', () => { const $grape = $('<li class="grape">Grape</li>').insertAfter('.apple'); expect($grape.cheerio).toBeTruthy(); expect($grape.each).toBeTruthy(); expect($grape.length).toBe(1); expect($grape.hasClass('grape')).toBe(true); }); it('(single) should return the new elements for chaining', () => { const $purple = $( '<li class="grape">Grape</li><li class="plum">Plum</li>', ).insertAfter('.apple'); expect($purple.cheerio).toBeTruthy(); expect($purple.each).toBeTruthy(); expect($purple.length).toBe(2); expect($purple.eq(0).hasClass('grape')).toBe(true); expect($purple.eq(1).hasClass('plum')).toBe(true); }); it('(multiple) should return the new elements for chaining', () => { const $purple = $( '<li class="grape">Grape</li><li class="plum">Plum</li>', ).insertAfter('.apple, .pear'); expect($purple.cheerio).toBeTruthy(); expect($purple.each).toBeTruthy(); expect($purple.length).toBe(4); expect($purple.eq(0).hasClass('grape')).toBe(true); expect($purple.eq(1).hasClass('plum')).toBe(true); expect($purple.eq(2).hasClass('grape')).toBe(true); expect($purple.eq(3).hasClass('plum')).toBe(true); }); it('(single) should return the existing element for chaining', () => { const $pear = $('.pear').insertAfter('.apple'); expect($pear.cheerio).toBeTruthy(); expect($pear.each).toBeTruthy(); expect($pear.length).toBe(1); expect($pear.hasClass('pear')).toBe(true); }); it('(single) should return the existing elements for chaining', () => { const $things = $('.orange, .apple').insertAfter('.pear'); expect($things.cheerio).toBeTruthy(); expect($things.each).toBeTruthy(); expect($things.length).toBe(2); expect($things.eq(0).hasClass('apple')).toBe(true); expect($things.eq(1).hasClass('orange')).toBe(true); }); it('(multiple) should return the existing elements for chaining', () => { $('<li class="grape">Grape</li>').insertAfter('.apple'); const $things = $('.orange, .apple').insertAfter('.pear, .grape'); expect($things.cheerio).toBeTruthy(); expect($things.each).toBeTruthy(); expect($things.length).toBe(4); expect($things.eq(0).hasClass('apple')).toBe(true); expect($things.eq(1).hasClass('orange')).toBe(true); expect($things.eq(2).hasClass('apple')).toBe(true); expect($things.eq(3).hasClass('orange')).toBe(true); }); }); describe('.before', () => { it('() : should do nothing', () => { expect($('#fruits').before()[0].tagName).toBe('ul'); }); it('(html) : should add element as previous sibling', () => { const grape = '<li class="grape">Grape</li>'; $('.apple').before(grape); expect($('.apple').prev().hasClass('grape')).toBe(true); }); it('($(...)) : should add element as previous sibling', () => { const $plum = $('<li class="plum">Plum</li>'); $('.apple').before($plum); expect($('.apple').prev().hasClass('plum')).toBe(true); }); it('(Node) : should add element as previous sibling', () => { const plum = $('<li class="plum">Plum</li>')[0]; $('.apple').before(plum); expect($('.apple').prev().hasClass('plum')).toBe(true); }); it('(existing Node) : should remove existing nodes from previous locations', () => { const pear = $fruits.children()[2]; $('.apple').before(pear); const $children = $fruits.children(); expect($children).toHaveLength(3); expect($children[0]).toBe(pear); }); it('(existing Node) : should update original direct siblings', () => { $('.apple').before($('.orange')); expect($('.apple').next()[0]).toBe($('.pear')[0]); expect($('.pear').prev()[0]).toBe($('.apple')[0]); }); it('(existing Node) : should clone all but the last occurrence', () => { const $originalPear = $('.pear'); $('.apple, .orange').before($originalPear); expect($('.pear')).toHaveLength(2); expect($('.pear').eq(0).prev()).toHaveLength(0); expect($('.pear').eq(0).next()[0]).toBe($('.apple')[0]); expect($('.pear').eq(1).prev()[0]).toBe($('.apple')[0]); expect($('.pear').eq(1).next()[0]).toBe($('.orange')[0]); expect($('.pear')[0]).not.toStrictEqual($originalPear[0]); expect($('.pear')[1]).toStrictEqual($originalPear[0]); }); it('(elem) : should handle if removed', () => { const $apple = $('.apple'); const $plum = $('<li class="plum">Plum</li>'); $apple.remove(); $apple.before($plum); expect($plum.next()).toHaveLength(0); }); it('(Array) : should add all elements in the array as previous sibling', () => { const more = $( '<li class="plum">Plum</li><li class="grape">Grape</li>', ).get(); $('.apple').before(more); expect($fruits.children().eq(0).hasClass('plum')).toBe(true); expect($fruits.children().eq(1).hasClass('grape')).toBe(true); }); it('($(...), html) : should add multiple elements as previous siblings', () => { const $plum = $('<li class="plum">Plum</li>'); const grape = '<li class="grape">Grape</li>'; $('.apple').before($plum, grape); expect($('.apple').prev().hasClass('grape')).toBe(true); expect($('.grape').prev().hasClass('plum')).toBe(true); }); it('(fn) : should invoke the callback with the correct arguments and context', () => { const args: [number, string][] = []; const thisValues: AnyNode[] = []; const $fruits = $('#fruits').children(); $fruits.before(function (...myArgs) { args.push(myArgs); thisValues.push(this); return this; }); expect(args).toStrictEqual([ [0, 'Apple'], [1, 'Orange'], [2, 'Pear'], ]); expect(thisValues).toStrictEqual([$fruits[0], $fruits[1], $fruits[2]]); }); it('(fn) : should add returned string as previous sibling', () => { const $fruits = $('#fruits').children(); $fruits.before(() => '<li class="first">'); expect($('.first')[0]).toBe($('#fruits').contents()[0]); expect($('.first')[1]).toBe($('#fruits').contents()[2]); expect($('.first')[2]).toBe($('#fruits').contents()[4]); }); it('(fn) : should add returned Cheerio object as previous sibling', () => { const $fruits = $('#fruits').children(); $fruits.before(() => $('<li class="second">')); expect($('.second')[0]).toBe($('#fruits').contents()[0]); expect($('.second')[1]).toBe($('#fruits').contents()[2]); expect($('.second')[2]).toBe($('#fruits').contents()[4]); }); it('(fn) : should add returned Node as previous sibling', () => { const $fruits = $('#fruits').children(); $fruits.before(() => $('<li class="third">')[0]); expect($('.third')[0]).toBe($('#fruits').contents()[0]); expect($('.third')[1]).toBe($('#fruits').contents()[2]); expect($('.third')[2]).toBe($('#fruits').contents()[4]); }); it('(fn) : should support text nodes', () => { const $text = load(mixedText); $text($text('body')[0].children).before( (_, content) => `<c>${content}added</c>`, ); expect($text('body').html()).toBe( '<c>1added</c><a>1</a>TEXT<c>2added</c><b>2</b>', ); }); it('($(...)) : should remove from root element', () => { const $plum = $('<li class="plum">Plum</li>'); const root = $plum[0].parent; expect(root?.type).toBe('root'); $fruits.before($plum); expect($plum[0].parent?.type).not.toBe('root'); expect(root?.childNodes).not.toContain($plum[0]); }); }); describe('.insertBefore', () => { it('(selector) : should create element and add as prev sibling', () => { const grape = $('<li class="grape">Grape</li>'); grape.insertBefore('.apple'); expect($('.apple').prev().hasClass('grape')).toBe(true); }); it('(selector) : should create element and add as prev sibling of multiple elements', () => { const grape = $('<li class="grape">Grape</li>'); grape.insertBefore('.apple, .pear'); expect($('.apple').prev().hasClass('grape')).toBe(true); expect($('.pear').prev().hasClass('grape')).toBe(true); }); it('($(...)) : should create element and add as prev sibling', () => { const grape = $('<li class="grape">Grape</li>'); grape.insertBefore($('.apple')); expect($('.apple').prev().hasClass('grape')).toBe(true); }); it('($(...)) : should create element and add as next sibling of multiple elements', () => { const grape = $('<li class="grape">Grape</li>'); grape.insertBefore($('.apple, .pear')); expect($('.apple').prev().hasClass('grape')).toBe(true); expect($('.pear').prev().hasClass('grape')).toBe(true); }); it('($(...)) : should create all elements in the array and add as prev siblings', () => { const more = $('<li class="plum">Plum</li><li class="grape">Grape</li>'); more.insertBefore($('.apple')); expect($fruits.children().eq(0).hasClass('plum')).toBe(true); expect($fruits.children().eq(1).hasClass('grape')).toBe(true); expect($fruits.children().eq(2).hasClass('apple')).toBe(true); }); it('(existing Node) : should remove existing nodes from previous locations', () => { $('.pear').insertBefore('.apple'); expect($fruits.children().eq(2).hasClass('pear')).toBe(false); expect($fruits.children().length).toBe(3); expect($('.pear').length).toBe(1); }); it('(existing Node) : should update original direct siblings', () => { $('.pear').insertBefore('.apple'); expect($('.apple').prev().hasClass('pear')).toBe(true); expect($('.apple').next().hasClass('orange')).toBe(true); expect($('.pear').next().hasClass('apple')).toBe(true); expect($('.pear').prev()).toHaveLength(0); }); it('(existing Node) : should update original direct siblings of multiple elements', () => { $('.pear').insertBefore('.apple, .orange'); expect($('.apple').prev().hasClass('pear')).toBe(true); expect($('.apple').next().hasClass('pear')).toBe(true); expect($('.orange').prev().hasClass('pear')).toBe(true); expect($('.orange').next()).toHaveLength(0); expect($fruits.children().length).toBe(4); const pears = $('.pear'); expect(pears.length).toBe(2); expect(pears.eq(0).next().hasClass('apple')).toBe(true); expect(pears.eq(1).next().hasClass('orange')).toBe(true); }); it('(elem) : should handle if removed', () => { const $apple = $('.apple'); const $plum = $('<li class="plum">Plum</li>'); $apple.remove(); $plum.insertBefore($apple); expect($plum.next()).toHaveLength(0); }); it('(single) should return the new element for chaining', () => { const $grape = $('<li class="grape">Grape</li>').insertBefore('.apple'); expect($grape.cheerio).toBeTruthy(); expect($grape.each).toBeTruthy(); expect($grape.length).toBe(1); expect($grape.hasClass('grape')).toBe(true); }); it('(single) should return the new elements for chaining', () => { const $purple = $( '<li class="grape">Grape</li><li class="plum">Plum</li>', ).insertBefore('.apple'); expect($purple.cheerio).toBeTruthy(); expect($purple.each).toBeTruthy(); expect($purple.length).toBe(2); expect($purple.eq(0).hasClass('grape')).toBe(true); expect($purple.eq(1).hasClass('plum')).toBe(true); }); it('(multiple) should return the new elements for chaining', () => { const $purple = $( '<li class="grape">Grape</li><li class="plum">Plum</li>', ).insertBefore('.apple, .pear'); expect($purple.cheerio).toBeTruthy(); expect($purple.each).toBeTruthy(); expect($purple.length).toBe(4); expect($purple.eq(0).hasClass('grape')).toBe(true); expect($purple.eq(1).hasClass('plum')).toBe(true); expect($purple.eq(2).hasClass('grape')).toBe(true); expect($purple.eq(3).hasClass('plum')).toBe(true); }); it('(single) should return the existing element for chaining', () => { const $orange = $('.orange').insertBefore('.apple'); expect($orange.cheerio).toBeTruthy(); expect($orange.each).toBeTruthy(); expect($orange.length).toBe(1); expect($orange.hasClass('orange')).toBe(true); }); it('(single) should return the existing elements for chaining', () => { const $things = $('.orange, .pear').insertBefore('.apple'); expect($things.cheerio).toBeTruthy(); expect($things.each).toBeTruthy(); expect($things.length).toBe(2); expect($things.eq(0).hasClass('orange')).toBe(true); expect($things.eq(1).hasClass('pear')).toBe(true); }); it('(multiple) should return the existing elements for chaining', () => { $('<li class="grape">Grape</li>').insertBefore('.apple'); const $things = $('.orange, .apple').insertBefore('.pear, .grape'); expect($things.cheerio).toBeTruthy(); expect($things.each).toBeTruthy(); expect($things.length).toBe(4); expect($things.eq(0).hasClass('apple')).toBe(true); expect($things.eq(1).hasClass('orange')).toBe(true); expect($things.eq(2).hasClass('apple')).toBe(true); expect($things.eq(3).hasClass('orange')).toBe(true); }); }); describe('.remove', () => { it('() : should remove selected elements', () => { $('.apple').remove(); expect($fruits.find('.apple')).toHaveLength(0); }); it('() : should be reentrant', () => { const $apple = $('.apple'); $apple.remove(); $apple.remove(); expect($fruits.find('.apple')).toHaveLength(0); }); it('(selector) : should remove matching selected elements', () => { $('li').remove('.apple'); expect($fruits.find('.apple')).toHaveLength(0); }); it('($(...)) : should remove from root element', () => { const $plum = $('<li class="plum">Plum</li>'); const root = $plum[0].parent; expect(root?.type).toBe('root'); $plum.remove(); expect($plum[0].parent).toBe(null); expect(root?.childNodes).not.toContain($plum[0]); }); }); describe('.replaceWith', () => { it('(elem) : should replace one <li> tag with another', () => { const $plum = $('<li class="plum">Plum</li>'); $('.orange').replaceWith($plum); expect($('.apple').next().hasClass('plum')).toBe(true); expect($('.apple').next().html()).toBe('Plum'); expect($('.pear').prev().hasClass('plum')).toBe(true); expect($('.pear').prev().html()).toBe('Plum'); }); it('(Array) : should replace one <li> tag with the elements in the array', () => { const more = $( '<li class="plum">Plum</li><li class="grape">Grape</li>', ).get(); $('.orange').replaceWith(more); expect($fruits.children().eq(1).hasClass('plum')).toBe(true); expect($fruits.children().eq(2).hasClass('grape')).toBe(true); expect($('.apple').next().hasClass('plum')).toBe(true); expect($('.pear').prev().hasClass('grape')).toBe(true); expect($fruits.children()).toHaveLength(4); }); it('(Node) : should replace the selected element with given node', () => { const $src = $('<h2>hi <span>there</span></h2>'); const $new = $('<ul></ul>'); const $replaced = $src.find('span').replaceWith($new[0]); expect($new[0].parentNode).toBe($src[0]); expect($replaced[0].parentNode).toBe(null); expect($.html($src)).toBe('<h2>hi <ul></ul></h2>'); }); it('(existing element) : should remove element from its previous location', () => { $('.pear').replaceWith($('.apple')); expect($fruits.children()).toHaveLength(2); expect($fruits.children()[0]).toBe($('.orange')[0]); expect($fruits.children()[1]).toBe($('.apple')[0]); }); it('(elem) : should NOP if removed', () => { const $pear = $('.pear'); const $plum = $('<li class="plum">Plum</li>'); $pear.remove(); $pear.replaceWith($plum); expect($('.orange').next().hasClass('plum')).toBe(false); }); it('(elem) : should replace the single selected element with given element', () => { const $src = $('<h2>hi <span>there</span></h2>'); const $new = $('<div>here</div>'); const $replaced = $src.find('span').replaceWith($new); expect($new[0].parentNode).toBe($src[0]); expect($replaced[0].parentNode).toBe(null); expect($.html($src)).toBe('<h2>hi <div>here</div></h2>'); }); it('(self) : should be replaced after replacing it with itself', () => { const $a = load('<a>foo</a>', null, false); const replacement = '<a>bar</a>'; $a('a').replaceWith((_, el: AnyNode) => el); $a('a').replaceWith(replacement); expect($a.html()).toBe(replacement); }); it('(str) : should accept strings', () => { const $src = $('<h2>hi <span>there</span></h2>'); const newStr = '<div>here</div>'; const $replaced = $src.find('span').replaceWith(newStr); expect($replaced[0].parentNode).toBe(null); expect($.html($src)).toBe('<h2>hi <div>here</div></h2>'); }); it('(str) : should replace all selected elements', () => { const $src = $('<b>a<br>b<br>c<br>d</b>'); const $replaced = $src.find('br').replaceWith(' '); expect($replaced[0].parentNode).toBe(null); expect($.html($src)).toBe('<b>a b c d</b>'); }); it('(fn) : should invoke the callback with the correct argument and context', () => { const origChildren = $fruits.children().get(); const args: [number, AnyNode][] = []; const thisValues: AnyNode[] = []; $fruits.children().replaceWith(function (...myArgs) { args.push(myArgs); thisValues.push(this); return '<li class="first">'; }); expect(args).toStrictEqual([ [0, origChildren[0]], [1, origChildren[1]], [2, origChildren[2]], ]); expect(thisValues).toStrictEqual([ origChildren[0], origChildren[1], origChildren[2], ]); }); it('(fn) : should replace the selected element with the returned string', () => { $fruits.children().replaceWith(() => '<li class="first">'); expect($fruits.find('.first')).toHaveLength(3); }); it('(fn) : should replace the selected element with the returned Cheerio object', () => { $fruits.children().replaceWith(() => $('<li class="second">')); expect($fruits.find('.second')).toHaveLength(3); }); it('(fn) : should replace the selected element with the returned node', () => { $fruits.children().replaceWith(() => $('<li class="third">')[0]); expect($fruits.find('.third')).toHaveLength(3); }); it('($(...)) : should remove from root element', () => { const $plum = $('<li class="plum">Plum</li>'); const root = $plum[0].parent; expect(root?.type).toBe('root'); $fruits.children().replaceWith($plum); expect($plum[0].parent?.type).not.toBe('root'); expect(root?.childNodes).not.toContain($plum[0]); }); }); describe('.empty', () => { it('() : should remove all children from selected elements', () => { expect($fruits.children()).toHaveLength(3); $fruits.empty(); expect($fruits.children()).toHaveLength(0); }); it('() : should allow element reinsertion', () => { const $children = $fruits.children(); $fruits.empty(); expect($fruits.children()).toHaveLength(0); expect($children).toHaveLength(3); $fruits.append($('<div></div><div></div>')); const $remove = $fruits.children().eq(0); $remove.replaceWith($children); expect($fruits.children()).toHaveLength(4); }); it("() : should destroy children's references to the parent", () => { const $children = $fruits.children(); $fruits.empty(); expect($children.eq(0).parent()).toHaveLength(0); expect($children.eq(0).next()).toHaveLength(0); expect($children.eq(0).prev()).toHaveLength(0); expect($children.eq(1).parent()).toHaveLength(0); expect($children.eq(1).next()).toHaveLength(0); expect($children.eq(1).prev()).toHaveLength(0); expect($children.eq(2).parent()).toHaveLength(0); expect($children.eq(2).next()).toHaveLength(0); expect($children.eq(2).prev()).toHaveLength(0); }); it('() : should skip text nodes', () => { const $text = load(mixedText); const $body = $text($text('body')[0].children); $body.empty(); expect($text('body').html()).toBe('<a></a>TEXT<b></b>'); }); it('() : should skip comment nodes', () => { const $comment = load('<a>1</a>TEXT<b>2</b>'); const $body = $comment($comment('body')[0].children); $body.empty(); expect($comment('body').html()).toBe('<a></a>TEXT<b></b>'); }); }); describe('.html', () => { it('() : should get the innerHTML for an element', () => { expect($fruits.html()).toBe( [ '<li class="apple">Apple</li>', '<li class="orange">Orange</li>', '<li class="pear">Pear</li>', ].join(''), ); }); it('() : should get innerHTML even if its just text', () => { expect($('.pear', '<li class="pear">Pear</li>').html()).toBe('Pear'); }); it('() : should return empty string if nothing inside', () => { expect($('li', '<li></li>').html()).toBe(''); }); it('(html) : should set the html for its children', () => { $fruits.html('<li class="durian">Durian</li>'); const html = $fruits.html(); expect(html).toBe('<li class="durian">Durian</li>'); }); it('(html) : should add new elements for each element in selection', () => { const $fruits = $('li'); $fruits.html('<li class="durian">Durian</li>'); let tested = 0; $fruits.each(function () { expect($(this).children().parent().get(0)).toBe(this); tested++; }); expect(tested).toBe(3); }); it('(html) : should skip text nodes', () => { const $text = load(mixedText); const $body = $text($text('body')[0].children); $body.html('test'); expect($text('body').html()).toBe('<a>test</a>TEXT<b>test</b>'); }); it('(elem) : should set the html for its children with element', () => { $fruits.html($('<li class="durian">Durian</li>')); const html = $fruits.html(); expect(html).toBe('<li class="durian">Durian</li>'); }); it('(elem) : should move the passed element (#940)', () => { $('.apple').html($('.orange')); expect($fruits.html()).toBe( '<li class="apple"><li class="orange">Orange</li></li><li class="pear">Pear</li>', ); }); it('() : should allow element reinsertion', () => { const $children = $fruits.children(); $fruits.html('<div></div><div></div>'); expect($fruits.children()).toHaveLength(2); const $remove = $fruits.children().eq(0); $remove.replaceWith($children); expect($fruits.children()).toHaveLength(4); }); it('(script value) : should add content as text', () => { const $data = '<a><b>'; const $script = $('<script>').html($data) as Cheerio<Element>; expect($script).toHaveLength(1); expect($script[0].type).toBe('script'); expect($script[0]).toHaveProperty('name', 'script'); expect($script[0].children).toHaveLength(1); expect($script[0].children[0].type).toBe('text'); expect($script[0].children[0]).toHaveProperty('data', $data); }); }); describe('.toString', () => { it('() : should get the outerHTML for an element', () => { expect($fruits.toString()).toBe(fruits); }); it('() : should return an html string for a set of elements', () => { expect($fruits.find('li').toString()).toBe( '<li class="apple">Apple</li><li class="orange">Orange</li><li class="pear">Pear</li>', ); }); it('() : should be called implicitly', () => { const string = [$('<foo>'), $('<bar>'), $('<baz>')].join(''); expect(string).toBe('<foo></foo><bar></bar><baz></baz>'); }); it('() : should pass options', () => { const dom = load('&', { xml: { decodeEntities: false } }); expect(dom.root().toString()).toBe('&'); }); }); describe('.text', () => { it('() : gets the text for a single element', () => { expect($('.apple').text()).toBe('Apple'); }); it('() : combines all text from children text nodes', () => { expect($('#fruits').text()).toBe('AppleOrangePear'); }); it('(text) : sets the text for the child node', () => { $('.apple').text('Granny Smith Apple'); expect($('.apple')[0].childNodes[0]).toHaveProperty( 'data', 'Granny Smith Apple', ); }); it('(text) : inserts separate nodes for all children', () => { $('li').text('Fruits'); let tested = 0; $('li').each(function () { expect(this.childNodes[0].parentNode).toBe(this); tested++; }); expect(tested).toBe(3); }); it('(text) : should create a Node with the DOM level 1 API', () => { const $apple = $('.apple'); $apple.text('anything'); const textNode = $apple[0].childNodes[0]; expect(textNode.parentNode).toBe($apple[0]); expect(textNode.nodeType).toBe(3); expect(textNode).toHaveProperty('data', 'anything'); }); it('(html) : should skip text nodes', () => { const $text = load(mixedText); const $body = $text($text('body')[0].children); $body.text('test'); expect($text('body').html()).toBe('<a>test</a>TEXT<b>test</b>'); }); it('should allow functions as arguments', () => { $('.apple').text((idx, content) => { expect(idx).toBe(0); expect(content).toBe('Apple'); return 'whatever mate'; }); expect($('.apple')[0].childNodes[0]).toHaveProperty( 'data', 'whatever mate', ); }); it('should allow functions as arguments for multiple elements', () => { $('li').text((idx) => `text${idx}`); $('li').each(function (this, idx) { expect(this.childNodes[0]).toHaveProperty('data', `text${idx}`); }); }); it('should decode special chars', () => { const text = $('<p>M&M</p>').text(); expect(text).toBe('M&M'); }); it('should work with special chars added as strings', () => { const text = $('<p>M&M</p>').text(); expect(text).toBe('M&M'); }); it('should turn passed values to strings', () => { $('.apple').text(1 as never); expect($('.apple')[0].childNodes[0]).toHaveProperty('data', '1'); }); it('( undefined ) : should act as an accessor', () => { const $div = $('<div>test</div>'); expect(typeof $div.text(undefined as never)).toBe('string'); expect($div.text()).toBe('test'); }); it('( "" ) : should convert to string', () => { const $div = $('<div>test</div>'); expect($div.text('').text()).toBe(''); }); it('( null ) : should convert to string', () => { expect( $('<div>') .text(null as never) .text(), ).toBe('null'); }); it('( 0 ) : should convert to string', () => { expect( $('<div>') .text(0 as never) .text(), ).toBe('0'); }); it('(str) should encode then decode unsafe characters', () => { const $apple = $('.apple'); $apple.text('blah <script>alert("XSS!")</script> blah'); expect($apple[0].childNodes[0]).toHaveProperty( 'data', 'blah <script>alert("XSS!")</script> blah', ); expect($apple.text()).toBe('blah <script>alert("XSS!")</script> blah'); $apple.text('blah <script>alert("XSS!")</script> blah'); expect($apple.html()).not.toContain('<script>alert("XSS!")</script>'); }); }); describe('.clone', () => { it('() : should return a copy', () => { const $src = $( '<div><span>foo</span><span>bar</span><span>baz</span></div>', ).children(); const $elem = $src.clone(); expect($elem.length).toBe(3); expect($elem.parent()).toHaveLength(0); expect($elem.text()).toBe($src.text()); $src.text('rofl'); expect($elem.text()).not.toBe($src.text()); }); it('() : should return a copy of document', () => { const $src = load('<html><body><div>foo</div>bar</body></html>') .root() .children(); const $elem = $src.clone(); expect($elem.length).toBe(1); expect($elem.parent()).toHaveLength(0); expect($elem.text()).toBe($src.text()); $src.text('rofl'); expect($elem.text()).not.toBe($src.text()); }); it('() : should preserve parsing options', () => { const $ = load('<div>π</div>', { xml: { decodeEntities: false } }); const $div = $('div'); expect($div.text()).toBe($div.clone().text()); }); }); }); /** * Methods for modifying the DOM structure. * * @module cheerio/manipulation */ import { isTag, Text, hasChildren, cloneNode, Document, type ParentNode, type AnyNode, type Element, } from 'domhandler'; import { update as updateDOM } from '../parse.js'; import { text as staticText } from '../static.js'; import { domEach, isHtml, isCheerio } from '../utils.js'; import { removeElement } from 'domutils'; import type { Cheerio } from '../cheerio.js'; import type { BasicAcceptedElems, AcceptedElems } from '../types.js'; import { ElementType } from 'htmlparser2'; /** * Create an array of nodes, recursing into arrays and parsing strings if * necessary. * * @private * @category Manipulation * @param elem - Elements to make an array of. * @param clone - Optionally clone nodes. * @returns The array of nodes. */ export function _makeDomArray<T extends AnyNode>( this: Cheerio<T>, elem?: BasicAcceptedElems<AnyNode> | BasicAcceptedElems<AnyNode>[], clone?: boolean, ): AnyNode[] { if (elem == null) { return []; } if (typeof elem === 'string') { return this._parse(elem, this.options, false, null).children.slice(0); } if ('length' in elem) { if (elem.length === 1) { return this._makeDomArray(elem[0], clone); } const result: AnyNode[] = []; for (let i = 0; i < elem.length; i++) { const el = elem[i]; if (typeof el === 'object') { if (el == null) { continue; } if (!('length' in el)) { result.push(clone ? cloneNode(el, true) : el); continue; } } result.push(...this._makeDomArray(el, clone)); } return result; } return [clone ? cloneNode(elem, true) : elem]; } function _insert( concatenator: ( dom: AnyNode[], children: AnyNode[], parent: ParentNode, ) => void, ) { return function <T extends AnyNode>( this: Cheerio<T>, ...elems: | [ ( this: AnyNode, i: number, html: string, ) => BasicAcceptedElems<AnyNode>, ] | BasicAcceptedElems<AnyNode>[] ) { const lastIdx = this.length - 1; return domEach(this, (el, i) => { if (!hasChildren(el)) return; const domSrc = typeof elems[0] === 'function' ? elems[0].call(el, i, this._render(el.children)) : (elems as BasicAcceptedElems<AnyNode>[]); const dom = this._makeDomArray(domSrc, i < lastIdx); concatenator(dom, el.children, el); }); }; } /** * Modify an array in-place, removing some number of elements and adding new * elements directly following them. * * @private * @category Manipulation * @param array - Target array to splice. * @param spliceIdx - Index at which to begin changing the array. * @param spliceCount - Number of elements to remove from the array. * @param newElems - Elements to insert into the array. * @param parent - The parent of the node. * @returns The spliced array. */ function uniqueSplice( array: AnyNode[], spliceIdx: number, spliceCount: number, newElems: AnyNode[], parent: ParentNode, ): AnyNode[] { const spliceArgs: Parameters<AnyNode[]['splice']> = [ spliceIdx, spliceCount, ...newElems, ]; const prev = spliceIdx === 0 ? null : array[spliceIdx - 1]; const next = spliceIdx + spliceCount >= array.length ? null : array[spliceIdx + spliceCount]; /* * Before splicing in new elements, ensure they do not already appear in the * current array. */ for (let idx = 0; idx < newElems.length; ++idx) { const node = newElems[idx]; const oldParent = node.parent; if (oldParent) { const oldSiblings: AnyNode[] = oldParent.children; const prevIdx = oldSiblings.indexOf(node); if (prevIdx !== -1) { oldParent.children.splice(prevIdx, 1); if (parent === oldParent && spliceIdx > prevIdx) { spliceArgs[0]--; } } } node.parent = parent; if (node.prev) { node.prev.next = node.next ?? null; } if (node.next) { node.next.prev = node.prev ?? null; } node.prev = idx === 0 ? prev : newElems[idx - 1]; node.next = idx === newElems.length - 1 ? next : newElems[idx + 1]; } if (prev) { prev.next = newElems[0]; } if (next) { next.prev = newElems[newElems.length - 1]; } return array.splice(...spliceArgs); } /** * Insert every element in the set of matched elements to the end of the target. * * @category Manipulation * @example * * ```js * $('<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> * ``` * * @param target - Element to append elements to. * @returns The instance itself. * @see {@link https://api.jquery.com/appendTo/} */ export function appendTo<T extends AnyNode>( this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>, ): Cheerio<T> { const appendTarget = isCheerio<T>(target) ? target : this._make(target); appendTarget.append(this); return this; } /** * Insert every element in the set of matched elements to the beginning of the * target. * * @category Manipulation * @example * * ```js * $('<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> * ``` * * @param target - Element to prepend elements to. * @returns The instance itself. * @see {@link https://api.jquery.com/prependTo/} */ export function prependTo<T extends AnyNode>( this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>, ): Cheerio<T> { const prependTarget = isCheerio<T>(target) ? target : this._make(target); prependTarget.prepend(this); return this; } /** * Inserts content as the _last_ child of each of the selected elements. * * @category Manipulation * @example * * ```js * $('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 {@link https://api.jquery.com/append/} */ export const append: <T extends AnyNode>( this: Cheerio<T>, ...elems: | [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>] | BasicAcceptedElems<AnyNode>[] ) => Cheerio<T> = _insert((dom, children, parent) => { uniqueSplice(children, children.length, 0, dom, parent); }); /** * Inserts content as the _first_ child of each of the selected elements. * * @category Manipulation * @example * * ```js * $('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 {@link https://api.jquery.com/prepend/} */ export const prepend: <T extends AnyNode>( this: Cheerio<T>, ...elems: | [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>] | BasicAcceptedElems<AnyNode>[] ) => Cheerio<T> = _insert((dom, children, parent) => { uniqueSplice(children, 0, 0, dom, parent); }); function _wrap( insert: ( el: AnyNode, elInsertLocation: ParentNode, wrapperDom: ParentNode[], ) => void, ) { return function <T extends AnyNode>( this: Cheerio<T>, wrapper: AcceptedElems<AnyNode>, ) { const lastIdx = this.length - 1; const lastParent = this.parents().last(); for (let i = 0; i < this.length; i++) { const el = this[i]; const wrap = typeof wrapper === 'function' ? wrapper.call(el, i, el) : typeof wrapper === 'string' && !isHtml(wrapper) ? lastParent.find(wrapper).clone() : wrapper; const [wrapperDom] = this._makeDomArray(wrap, i < lastIdx); if (!wrapperDom || !hasChildren(wrapperDom)) continue; let elInsertLocation = wrapperDom; /* * Find the deepest child. Only consider the first tag child of each node * (ignore text); stop if no children are found. */ let j = 0; while (j < elInsertLocation.children.length) { const child = elInsertLocation.children[j]; if (isTag(child)) { elInsertLocation = child; j = 0; } else { j++; } } insert(el, elInsertLocation, [wrapperDom]); } return this; }; } /** * 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. * * @category Manipulation * @example * * ```js * 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> * ``` * * @param wrapper - The DOM structure to wrap around each element in the * selection. * @see {@link https://api.jquery.com/wrap/} */ export const wrap: <T extends AnyNode>( this: Cheerio<T>, wrapper: AcceptedElems<AnyNode>, ) => Cheerio<T> = _wrap((el, elInsertLocation, wrapperDom) => { const { parent } = el; if (!parent) return; const siblings: AnyNode[] = parent.children; const index = siblings.indexOf(el); updateDOM([el], elInsertLocation); /* * The previous operation removed the current element from the `siblings` * array, so the `dom` array can be inserted without removing any * additional elements. */ uniqueSplice(siblings, index, 0, wrapperDom, parent); }); /** * 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. * * @category Manipulation * @example * * ```js * 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> * ``` * * @param wrapper - The DOM structure to wrap around the content of each element * in the selection. * @returns The instance itself, for chaining. * @see {@link https://api.jquery.com/wrapInner/} */ export const wrapInner: <T extends AnyNode>( this: Cheerio<T>, wrapper: AcceptedElems<AnyNode>, ) => Cheerio<T> = _wrap((el, elInsertLocation, wrapperDom) => { if (!hasChildren(el)) return; updateDOM(el.children, elInsertLocation); updateDOM(wrapperDom, el); }); /** * The .unwrap() function, removes the parents of the set of matched elements * from the DOM, leaving the matched elements in their place. * * @category Manipulation * @example <caption>without selector</caption> * * ```js * 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> * * ```js * 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> * ``` * * @param selector - 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 The instance itself, for chaining. * @see {@link https://api.jquery.com/unwrap/} */ export function unwrap<T extends AnyNode>( this: Cheerio<T>, selector?: string, ): Cheerio<T> { this.parent(selector) .not('body') .each((_, el) => { this._make(el).replaceWith(el.children); }); return this; } /** * 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. * * @category Manipulation * @example <caption>With markup passed to `wrapAll`</caption> * * ```js * 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> * * ```js * 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> * ``` * * @param wrapper - The DOM structure to wrap around all matched elements in the * selection. * @returns The instance itself. * @see {@link https://api.jquery.com/wrapAll/} */ export function wrapAll<T extends AnyNode>( this: Cheerio<T>, wrapper: AcceptedElems<T>, ): Cheerio<T> { const el = this[0]; if (el) { const wrap: Cheerio<AnyNode> = this._make( typeof wrapper === 'function' ? wrapper.call(el, 0, el) : wrapper, ).insertBefore(el); // If html is given as wrapper, wrap may contain text elements let elInsertLocation: Element | undefined; for (let i = 0; i < wrap.length; i++) { if (wrap[i].type === ElementType.Tag) { elInsertLocation = wrap[i] as Element; } } let j = 0; /* * Find the deepest child. Only consider the first tag child of each node * (ignore text); stop if no children are found. */ while (elInsertLocation && j < elInsertLocation.children.length) { const child = elInsertLocation.children[j]; if (child.type === ElementType.Tag) { elInsertLocation = child; j = 0; } else { j++; } } if (elInsertLocation) this._make(elInsertLocation).append(this); } return this; } /** * Insert content next to each element in the set of matched elements. * * @category Manipulation * @example * * ```js * $('.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> * ``` * * @param elems - HTML string, DOM element, array of DOM elements or Cheerio to * insert after each element in the set of matched elements. * @returns The instance itself. * @see {@link https://api.jquery.com/after/} */ export function after<T extends AnyNode>( this: Cheerio<T>, ...elems: | [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>] | BasicAcceptedElems<AnyNode>[] ): Cheerio<T> { const lastIdx = this.length - 1; return domEach(this, (el, i) => { if (!hasChildren(el) || !el.parent) { return; } const siblings: AnyNode[] = el.parent.children; const index = siblings.indexOf(el); // If not found, move on /* istanbul ignore next */ if (index === -1) return; const domSrc = typeof elems[0] === 'function' ? elems[0].call(el, i, this._render(el.children)) : (elems as BasicAcceptedElems<AnyNode>[]); const dom = this._makeDomArray(domSrc, i < lastIdx); // Add element after `this` element uniqueSplice(siblings, index + 1, 0, dom, el.parent); }); } /** * Insert every element in the set of matched elements after the target. * * @category Manipulation * @example * * ```js * $('<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> * ``` * * @param target - Element to insert elements after. * @returns The set of newly inserted elements. * @see {@link https://api.jquery.com/insertAfter/} */ export function insertAfter<T extends AnyNode>( this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>, ): Cheerio<T> { if (typeof target === 'string') { target = this._make<AnyNode>(target); } this.remove(); const clones: T[] = []; for (const el of this._makeDomArray(target)) { const clonedSelf = this.clone().toArray(); const { parent } = el; if (!parent) { continue; } const siblings: AnyNode[] = parent.children; const index = siblings.indexOf(el); // If not found, move on /* istanbul ignore next */ if (index === -1) continue; // Add cloned `this` element(s) after target element uniqueSplice(siblings, index + 1, 0, clonedSelf, parent); clones.push(...clonedSelf); } return this._make(clones); } /** * Insert content previous to each element in the set of matched elements. * * @category Manipulation * @example * * ```js * $('.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> * ``` * * @param elems - HTML string, DOM element, array of DOM elements or Cheerio to * insert before each element in the set of matched elements. * @returns The instance itself. * @see {@link https://api.jquery.com/before/} */ export function before<T extends AnyNode>( this: Cheerio<T>, ...elems: | [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>] | BasicAcceptedElems<AnyNode>[] ): Cheerio<T> { const lastIdx = this.length - 1; return domEach(this, (el, i) => { if (!hasChildren(el) || !el.parent) { return; } const siblings: AnyNode[] = el.parent.children; const index = siblings.indexOf(el); // If not found, move on /* istanbul ignore next */ if (index === -1) return; const domSrc = typeof elems[0] === 'function' ? elems[0].call(el, i, this._render(el.children)) : (elems as BasicAcceptedElems<AnyNode>[]); const dom = this._makeDomArray(domSrc, i < lastIdx); // Add element before `el` element uniqueSplice(siblings, index, 0, dom, el.parent); }); } /** * Insert every element in the set of matched elements before the target. * * @category Manipulation * @example * * ```js * $('<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> * ``` * * @param target - Element to insert elements before. * @returns The set of newly inserted elements. * @see {@link https://api.jquery.com/insertBefore/} */ export function insertBefore<T extends AnyNode>( this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>, ): Cheerio<T> { const targetArr = this._make<AnyNode>(target); this.remove(); const clones: T[] = []; domEach(targetArr, (el) => { const clonedSelf = this.clone().toArray(); const { parent } = el; if (!parent) { return; } const siblings: AnyNode[] = parent.children; const index = siblings.indexOf(el); // If not found, move on /* istanbul ignore next */ if (index === -1) return; // Add cloned `this` element(s) after target element uniqueSplice(siblings, index, 0, clonedSelf, parent); clones.push(...clonedSelf); }); return this._make(clones); } /** * Removes the set of matched elements from the DOM and all their children. * `selector` filters the set of matched elements to be removed. * * @category Manipulation * @example * * ```js * $('.pear').remove(); * $.html(); * //=> <ul id="fruits"> * // <li class="apple">Apple</li> * // <li class="orange">Orange</li> * // </ul> * ``` * * @param selector - Optional selector for elements to remove. * @returns The instance itself. * @see {@link https://api.jquery.com/remove/} */ export function remove<T extends AnyNode>( this: Cheerio<T>, selector?: string, ): Cheerio<T> { // Filter if we have selector const elems = selector ? this.filter(selector) : this; domEach(elems, (el) => { removeElement(el); el.prev = el.next = el.parent = null; }); return this; } /** * Replaces matched elements with `content`. * * @category Manipulation * @example * * ```js * 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> * ``` * * @param content - Replacement for matched elements. * @returns The instance itself. * @see {@link https://api.jquery.com/replaceWith/} */ export function replaceWith<T extends AnyNode>( this: Cheerio<T>, content: AcceptedElems<AnyNode>, ): Cheerio<T> { return domEach(this, (el, i) => { const { parent } = el; if (!parent) { return; } const siblings: AnyNode[] = parent.children; const cont = typeof content === 'function' ? content.call(el, i, el) : content; const dom = this._makeDomArray(cont); /* * In the case that `dom` contains nodes that already exist in other * structures, ensure those nodes are properly removed. */ updateDOM(dom, null); const index = siblings.indexOf(el); // Completely remove old element uniqueSplice(siblings, index, 1, dom, parent); if (!dom.includes(el)) { el.parent = el.prev = el.next = null; } }); } /** * Removes all children from each item in the selection. Text nodes and comment * nodes are left as is. * * @category Manipulation * @example * * ```js * $('ul').empty(); * $.html(); * //=> <ul id="fruits"></ul> * ``` * * @returns The instance itself. * @see {@link https://api.jquery.com/empty/} */ export function empty<T extends AnyNode>(this: Cheerio<T>): Cheerio<T> { return domEach(this, (el) => { if (!hasChildren(el)) return; for (const child of el.children) { child.next = child.prev = child.parent = null; } el.children.length = 0; }); } /** * Gets an HTML content string from the first selected element. * * @category Manipulation * @example * * ```js * $('.orange').html(); * //=> Orange * * $('#fruits').html('<li class="mango">Mango</li>').html(); * //=> <li class="mango">Mango</li> * ``` * * @returns The HTML content string. * @see {@link https://api.jquery.com/html/} */ export function html<T extends AnyNode>(this: Cheerio<T>): string | null; /** * Replaces each selected element's content with the specified content. * * @category Manipulation * @example * * ```js * $('.orange').html('<li class="mango">Mango</li>').html(); * //=> <li class="mango">Mango</li> * ``` * * @param str - The content to replace selection's contents with. * @returns The instance itself. * @see {@link https://api.jquery.com/html/} */ export function html<T extends AnyNode>( this: Cheerio<T>, str: string | Cheerio<T>, ): Cheerio<T>; export function html<T extends AnyNode>( this: Cheerio<T>, str?: string | Cheerio<AnyNode>, ): Cheerio<T> | string | null { if (str === undefined) { const el = this[0]; if (!el || !hasChildren(el)) return null; return this._render(el.children); } return domEach(this, (el) => { if (!hasChildren(el)) return; for (const child of el.children) { child.next = child.prev = child.parent = null; } const content = isCheerio(str) ? str.toArray() : this._parse(`${str}`, this.options, false, el).children; updateDOM(content, el); }); } /** * Turns the collection to a string. Alias for `.html()`. * * @category Manipulation * @returns The rendered document. */ export function toString<T extends AnyNode>(this: Cheerio<T>): string { return this._render(this); } /** * Get the combined text contents of each element in the set of matched * elements, including their descendants. * * @category Manipulation * @example * * ```js * $('.orange').text(); * //=> Orange * * $('ul').text(); * //=> Apple * // Orange * // Pear * ``` * * @returns The text contents of the collection. * @see {@link https://api.jquery.com/text/} */ export function text<T extends AnyNode>(this: Cheerio<T>): string; /** * Set the content of each element in the set of matched elements to the * specified text. * * @category Manipulation * @example * * ```js * $('.orange').text('Orange'); * //=> <div class="orange">Orange</div> * ``` * * @param str - The text to set as the content of each matched element. * @returns The instance itself. * @see {@link https://api.jquery.com/text/} */ export function text<T extends AnyNode>( this: Cheerio<T>, str: string | ((this: AnyNode, i: number, text: string) => string), ): Cheerio<T>; export function text<T extends AnyNode>( this: Cheerio<T>, str?: string | ((this: AnyNode, i: number, text: string) => string), ): Cheerio<T> | string { // If `str` is undefined, act as a "getter" if (str === undefined) { return staticText(this); } if (typeof str === 'function') { // Function support return domEach(this, (el, i) => this._make(el).text(str.call(el, i, staticText([el]))), ); } // Append text node to each selected elements return domEach(this, (el) => { if (!hasChildren(el)) return; for (const child of el.children) { child.next = child.prev = child.parent = null; } const textNode = new Text(`${str}`); updateDOM(textNode, el); }); } /** * Clone the cheerio object. * * @category Manipulation * @example * * ```js * const moreFruit = $('#fruits').clone(); * ``` * * @returns The cloned object. * @see {@link https://api.jquery.com/clone/} */ export function clone<T extends AnyNode>(this: Cheerio<T>): Cheerio<T> { const clone = Array.prototype.map.call( this.get(), (el) => cloneNode(el, true) as T, ) as T[]; // Add a root node around the cloned nodes const root = new Document(clone); for (const node of clone) { node.parent = root; } return this._make(clone); } import { describe, it, expect, beforeEach } from 'vitest'; import { load, type CheerioAPI } from '../index.js'; import { Cheerio } from '../cheerio.js'; import { type AnyNode, type Element, type Text, isText } from 'domhandler'; import { cheerio, food, fruits, eleven, drinks, text, forms, mixedText, vegetables, } from '../__fixtures__/fixtures.js'; function getText(el: Cheerio<Element>) { if (el.length === 0) return undefined; const [firstChild] = el[0].childNodes; return isText(firstChild) ? firstChild.data : undefined; } describe('$(...)', () => { let $: CheerioAPI; beforeEach(() => { $ = load(fruits); }); describe('.load', () => { it('should throw a TypeError if given invalid input', () => { expect(() => { // @ts-expect-error Testing invalid input load(); }).toThrow('cheerio.load() expects a string'); }); }); describe('.find', () => { it('() : should find nothing', () => { expect($('ul').find()).toHaveLength(0); }); it('(single) : should find one descendant', () => { expect($('#fruits').find('.apple')[0].attribs).toHaveProperty( 'class', 'apple', ); }); // #1679 - text tags not filtered it('(single) : should filter out text nodes', () => { const $root = $(`<html>\n${fruits.replace(/></g, '>\n<')}\n</html>`); expect($root.find('.apple')[0].attribs).toHaveProperty('class', 'apple'); }); it('(many) : should find all matching descendant', () => { expect($('#fruits').find('li')).toHaveLength(3); }); it('(many) : should merge all selected elems with matching descendants', () => { expect($('#fruits, #food', food).find('.apple')).toHaveLength(1); }); it('(invalid single) : should return empty if cant find', () => { expect($('ul').find('blah')).toHaveLength(0); }); it('(invalid single) : should query descendants only', () => { expect($('#fruits').find('ul')).toHaveLength(0); }); it('should return empty if search already empty result', () => { expect($('#not-fruits').find('li')).toHaveLength(0); }); it('should lowercase selectors', () => { expect($('#fruits').find('LI')).toHaveLength(3); }); it('should query immediate descendant only', () => { const q = load('<foo><bar><bar></bar><bar></bar></bar></foo>'); expect(q('foo').find('> bar')).toHaveLength(1); }); it('should find siblings', () => { const q = load('<p class=a><p class=b></p>'); expect(q('.a').find('+.b')).toHaveLength(1); expect(q('.a').find('~.b')).toHaveLength(1); expect(q('.a').find('+.a')).toHaveLength(0); expect(q('.a').find('~.a')).toHaveLength(0); }); it('should query case-sensitively when in xml mode', () => { const q = load('<caseSenSitive allTheWay>', { xml: true }); expect(q('caseSenSitive')).toHaveLength(1); expect(q('[allTheWay]')).toHaveLength(1); expect(q('casesensitive')).toHaveLength(0); expect(q('[alltheway]')).toHaveLength(0); }); it('should throw an Error if given an invalid selector', () => { expect(() => { $('#fruits').find(':bah'); }).toThrow('Unknown pseudo-class :bah'); }); it('should respect the `lowerCaseTags` option (#3495)', () => { const q = load( `<parentTag class="myClass"> <firstTag> <child> blah </child> </firstTag> <secondTag> <child> blah </child> </secondTag> </parentTag> `, { xml: { xmlMode: true, decodeEntities: false, lowerCaseTags: true, lowerCaseAttributeNames: false, recognizeSelfClosing: true, }, }, ); expect(q('.myClass').find('firstTag > child')).toHaveLength(1); }); describe('(cheerio object) :', () => { it('returns only those nodes contained within the current selection', () => { const q = load(food); const $selection = q('#fruits').find(q('li')); expect($selection).toHaveLength(3); expect($selection[0]).toBe(q('.apple')[0]); expect($selection[1]).toBe(q('.orange')[0]); expect($selection[2]).toBe(q('.pear')[0]); }); it('returns only those nodes contained within any element in the current selection', () => { const q = load(food); const $selection = q('.apple, #vegetables').find(q('li')); expect($selection).toHaveLength(2); expect($selection[0]).toBe(q('.carrot')[0]); expect($selection[1]).toBe(q('.sweetcorn')[0]); }); }); describe('(node) :', () => { it('returns node when contained within the current selection', () => { const q = load(food); const $selection = q('#fruits').find(q('.apple')[0]); expect($selection).toHaveLength(1); expect($selection[0]).toBe(q('.apple')[0]); }); it('returns node when contained within any element the current selection', () => { const q = load(food); const $selection = q('#fruits, #vegetables').find(q('.carrot')[0]); expect($selection).toHaveLength(1); expect($selection[0]).toBe(q('.carrot')[0]); }); it('does not return node that is not contained within the current selection', () => { const q = load(food); const $selection = q('#fruits').find(q('.carrot')[0]); expect($selection).toHaveLength(0); }); }); }); describe('.children', () => { it('() : should get all children', () => { expect($('ul').children()).toHaveLength(3); }); it('() : should skip text nodes', () => { expect($(mixedText).children()).toHaveLength(0); }); it('() : should return children of all matched elements', () => { expect($('ul ul', food).children()).toHaveLength(5); }); it('(selector) : should return children matching selector', () => { const { attribs } = $('ul').children('.orange')[0]; expect(attribs).toHaveProperty('class', 'orange'); }); it('(invalid selector) : should return empty', () => { expect($('ul').children('.lulz')).toHaveLength(0); }); it('should only match immediate children, not ancestors', () => { expect($(food).children('li')).toHaveLength(0); }); }); describe('.contents', () => { beforeEach(() => { $ = load(text); }); it('() : should get all contents', () => { expect($('p').contents()).toHaveLength(5); }); it('() : should skip text nodes', () => { expect($(mixedText).contents()).toHaveLength(2); }); it('() : should include text nodes', () => { expect($('p').contents().first()[0].type).toBe('text'); }); it('() : should include comment nodes', () => { expect($('p').contents().last()[0].type).toBe('comment'); }); }); describe('.next', () => { it('() : should return next element', () => { const { attribs } = $('.orange').next()[0]; expect(attribs).toHaveProperty('class', 'pear'); }); it('() : should skip text nodes', () => { expect($(mixedText).next()[0]).toHaveProperty('name', 'b'); }); it('(no next) : should return empty for last child', () => { expect($('.pear').next()).toHaveLength(0); }); it('(next on empty object) : should return empty', () => { expect($('.banana').next()).toHaveLength(0); }); it('() : should operate over all elements in the selection', () => { expect($('.apple, .orange', food).next()).toHaveLength(2); }); it('() : should return elements in order', () => { const result = load(eleven)('.red').next(); expect(result).toHaveLength(2); expect(result.eq(0).text()).toBe('Six'); expect(result.eq(1).text()).toBe('Ten'); }); it('should reject elements that violate the filter', () => { expect($('.apple').next('.non-existent')).toHaveLength(0); }); it('should accept elements that satisify the filter', () => { expect($('.apple').next('.orange')).toHaveLength(1); }); describe('(selector) :', () => { it('should reject elements that violate the filter', () => { expect($('.apple').next('.non-existent')).toHaveLength(0); }); it('should accept elements that satisify the filter', () => { expect($('.apple').next('.orange')).toHaveLength(1); }); }); }); describe('.nextAll', () => { it('() : should return all following siblings', () => { const elems = $('.apple').nextAll(); expect(elems).toHaveLength(2); expect(elems[0].attribs).toHaveProperty('class', 'orange'); expect(elems[1].attribs).toHaveProperty('class', 'pear'); }); it('(no next) : should return empty for last child', () => { expect($('.pear').nextAll()).toHaveLength(0); }); it('(nextAll on empty object) : should return empty', () => { expect($('.banana').nextAll()).toHaveLength(0); }); it('() : should operate over all elements in the selection', () => { expect($('.apple, .carrot', food).nextAll()).toHaveLength(3); }); it('() : should not contain duplicate elements', () => { const elems = $('.apple, .orange', food); expect(elems.nextAll()).toHaveLength(2); }); it('() : should not contain text elements', () => { const elems = $('.apple', fruits.replace(/></g, '>\n<')); expect(elems.nextAll()).toHaveLength(2); }); describe('(selector) :', () => { it('should filter according to the provided selector', () => { expect($('.apple').nextAll('.pear')).toHaveLength(1); }); it("should not consider siblings' contents when filtering", () => { expect($('#fruits', food).nextAll('li')).toHaveLength(0); }); }); }); describe('.nextUntil', () => { it('() : should return all following siblings if no selector specified', () => { const elems = $('.apple', food).nextUntil(); expect(elems).toHaveLength(2); expect(elems[0].attribs).toHaveProperty('class', 'orange'); expect(elems[1].attribs).toHaveProperty('class', 'pear'); }); it('() : should filter out non-element nodes', () => { const elems = $('<div><div></div>text<div></div></div>'); const div = elems.children().eq(0); expect(div.nextUntil()).toHaveLength(1); }); it('() : should operate over all elements in the selection', () => { const elems = $('.apple, .carrot', food); expect(elems.nextUntil()).toHaveLength(3); }); it('() : should not contain duplicate elements', () => { const elems = $('.apple, .orange', food); expect(elems.nextUntil()).toHaveLength(2); }); it('(selector) : should return all following siblings until selector', () => { const elems = $('.apple', food).nextUntil('.pear'); expect(elems).toHaveLength(1); expect(elems[0].attribs).toHaveProperty('class', 'orange'); }); it('(selector) : should support selector matching multiple elements', () => { const elems = $('#disabled', forms).nextUntil('option, #unnamed'); expect(elems).toHaveLength(2); expect(elems[0].attribs).toHaveProperty('id', 'submit'); expect(elems[1].attribs).toHaveProperty('id', 'select'); }); it('(selector not sibling) : should return all following siblings', () => { const elems = $('.apple').nextUntil('#vegetables'); expect(elems).toHaveLength(2); }); it('(selector, filterString) : should return all following siblings until selector, filtered by filter', () => { const elems = $('.beer', drinks).nextUntil('.water', '.milk'); expect(elems).toHaveLength(1); expect(elems[0].attribs).toHaveProperty('class', 'milk'); }); it('(null, filterString) : should return all following siblings until selector, filtered by filter', () => { const elems = $('<ul><li></li><li><p></p></li></ul>'); const empty = elems.find('li').eq(0).nextUntil(null, 'p'); expect(empty).toHaveLength(0); }); it('() : should return an empty object for last child', () => { expect($('.pear').nextUntil()).toHaveLength(0); }); it('() : should return an empty object when called on an empty object', () => { expect($('.banana').nextUntil()).toHaveLength(0); }); it('(node) : should return all following siblings until the node', () => { const $fruits = $('#fruits').children(); const elems = $fruits.eq(0).nextUntil($fruits[2]); expect(elems).toHaveLength(1); }); it('(cheerio object) : should return all following siblings until any member of the cheerio object', () => { const $drinks = $(drinks).children(); const $until = $([$drinks[4], $drinks[3]]); const elems = $drinks.eq(0).nextUntil($until); expect(elems).toHaveLength(2); }); }); describe('.prev', () => { it('() : should return previous element', () => { const { attribs } = $('.orange').prev()[0]; expect(attribs).toHaveProperty('class', 'apple'); }); it('() : should skip text nodes', () => { expect($($(mixedText)[2]).prev()[0]).toHaveProperty('name', 'a'); }); it('(no prev) : should return empty for first child', () => { expect($('.apple').prev()).toHaveLength(0); }); it('(prev on empty object) : should return empty', () => { expect($('.banana').prev()).toHaveLength(0); }); it('() : should operate over all elements in the selection', () => { expect($('.orange, .pear', food).prev()).toHaveLength(2); }); it('() : should maintain elements order', () => { const sel = load(eleven)('.sel'); expect(sel).toHaveLength(3); expect(sel.eq(0).text()).toBe('Three'); expect(sel.eq(1).text()).toBe('Nine'); expect(sel.eq(2).text()).toBe('Eleven'); // Swap last elements const el = sel[2]; sel[2] = sel[1]; sel[1] = el; const result = sel.prev(); expect(result).toHaveLength(3); expect(result.eq(0).text()).toBe('Two'); expect(result.eq(1).text()).toBe('Ten'); expect(result.eq(2).text()).toBe('Eight'); }); describe('(selector) :', () => { it('should reject elements that violate the filter', () => { expect($('.orange').prev('.non-existent')).toHaveLength(0); }); it('should accept elements that satisify the filter', () => { expect($('.orange').prev('.apple')).toHaveLength(1); }); it('(selector) : should reject elements that violate the filter', () => { expect($('.orange').prev('.non-existent')).toHaveLength(0); }); it('(selector) : should accept elements that satisify the filter', () => { expect($('.orange').prev('.apple')).toHaveLength(1); }); }); }); describe('.prevAll', () => { it('() : should return all preceding siblings', () => { const elems = $('.pear').prevAll(); expect(elems).toHaveLength(2); expect(elems[0].attribs).toHaveProperty('class', 'orange'); expect(elems[1].attribs).toHaveProperty('class', 'apple'); }); it('() : should not contain text elements', () => { const elems = $('.pear', fruits.replace(/></g, '>\n<')); expect(elems.prevAll()).toHaveLength(2); }); it('(no prev) : should return empty for first child', () => { expect($('.apple').prevAll()).toHaveLength(0); }); it('(prevAll on empty object) : should return empty', () => { expect($('.banana').prevAll()).toHaveLength(0); }); it('() : should operate over all elements in the selection', () => { expect($('.orange, .sweetcorn', food).prevAll()).toHaveLength(2); }); it('() : should not contain duplicate elements', () => { const elems = $('.orange, .pear', food); expect(elems.prevAll()).toHaveLength(2); }); describe('(selector) :', () => { it('should filter returned elements', () => { const elems = $('.pear').prevAll('.apple'); expect(elems).toHaveLength(1); }); it("should not consider siblings's descendents", () => { const elems = $('#vegetables', food).prevAll('li'); expect(elems).toHaveLength(0); }); }); }); describe('.prevUntil', () => { it('() : should return all preceding siblings if no selector specified', () => { const elems = $('.pear').prevUntil(); expect(elems).toHaveLength(2); expect(elems[0].attribs).toHaveProperty('class', 'orange'); expect(elems[1].attribs).toHaveProperty('class', 'apple'); }); it('() : should filter out non-element nodes', () => { const elems = $( '<div class="1"><div class="2"></div>text<div class="3"></div></div>', ); const div = elems.children().last(); expect(div.prevUntil()).toHaveLength(1); }); it('() : should operate over all elements in the selection', () => { const elems = $('.pear, .sweetcorn', food); expect(elems.prevUntil()).toHaveLength(3); }); it('() : should not contain duplicate elements', () => { const elems = $('.orange, .pear', food); expect(elems.prevUntil()).toHaveLength(2); }); it('(selector) : should return all preceding siblings until selector', () => { const elems = $('.pear').prevUntil('.apple'); expect(elems).toHaveLength(1); expect(elems[0].attribs).toHaveProperty('class', 'orange'); }); it('(selector) : should support selector matching multiple elements', () => { const elems = $('#unnamed', forms).prevUntil('option, #disabled'); expect(elems).toHaveLength(2); expect(elems[0].attribs).toHaveProperty('id', 'select'); expect(elems[1].attribs).toHaveProperty('id', 'submit'); }); it('(selector not sibling) : should return all preceding siblings', () => { const elems = $('.sweetcorn', food).prevUntil('#fruits'); expect(elems).toHaveLength(1); expect(elems[0].attribs).toHaveProperty('class', 'carrot'); }); it('(selector, filterString) : should return all preceding siblings until selector, filtered by filter', () => { const elems = $('.cider', drinks).prevUntil('.juice', '.water'); expect(elems).toHaveLength(1); expect(elems[0].attribs).toHaveProperty('class', 'water'); }); it('(selector, filterString) : should return all preceding siblings until selector', () => { const elems = $('<ul><li><p></p></li><li></li></ul>'); const empty = elems.find('li').eq(1).prevUntil(null, 'p'); expect(empty).toHaveLength(0); }); it('() : should return an empty object for first child', () => { expect($('.apple').prevUntil()).toHaveLength(0); }); it('() : should return an empty object when called on an empty object', () => { expect($('.banana').prevUntil()).toHaveLength(0); }); it('(node) : should return all previous siblings until the node', () => { const $fruits = $('#fruits').children(); const elems = $fruits.eq(2).prevUntil($fruits[0]); expect(elems).toHaveLength(1); }); it('(cheerio object) : should return all previous siblings until any member of the cheerio object', () => { const $drinks = $(drinks).children(); const $until = $([$drinks[0], $drinks[1]]); const elems = $drinks.eq(4).prevUntil($until); expect(elems).toHaveLength(2); }); }); describe('.siblings', () => { it('() : should get all the siblings', () => { expect($('.orange').siblings()).toHaveLength(2); expect($('#fruits').siblings()).toHaveLength(0); expect($('.apple, .carrot', food).siblings()).toHaveLength(3); }); it('(selector) : should get all siblings that match the selector', () => { expect($('.orange').siblings('.apple')).toHaveLength(1); expect($('.orange').siblings('.peach')).toHaveLength(0); }); it('(selector) : should throw an Error if given an invalid selector', () => { expect(() => { $('.orange').siblings(':bah'); }).toThrow('Unknown pseudo-class :bah'); }); it('(selector) : does not consider the contents of siblings when filtering (GH-374)', () => { expect($('#fruits', food).siblings('li')).toHaveLength(0); }); it('() : when two elements are siblings to each other they have to be included', () => { const result = load(eleven)('.sel').siblings(); expect(result).toHaveLength(7); expect(result.eq(0).text()).toBe('One'); expect(result.eq(1).text()).toBe('Two'); expect(result.eq(2).text()).toBe('Four'); expect(result.eq(3).text()).toBe('Eight'); expect(result.eq(4).text()).toBe('Nine'); expect(result.eq(5).text()).toBe('Ten'); expect(result.eq(6).text()).toBe('Eleven'); }); it('(selector) : when two elements are siblings to each other they have to be included', () => { const result = load(eleven)('.sel').siblings('.red'); expect(result).toHaveLength(2); expect(result.eq(0).text()).toBe('Four'); expect(result.eq(1).text()).toBe('Nine'); }); it('(cheerio) : test filtering with cheerio object', () => { const doc = load(eleven); const result = doc('.sel').siblings(doc(':not([class])')); expect(result).toHaveLength(4); expect(result.eq(0).text()).toBe('One'); expect(result.eq(1).text()).toBe('Two'); expect(result.eq(2).text()).toBe('Eight'); expect(result.eq(3).text()).toBe('Ten'); }); }); describe('.parents', () => { beforeEach(() => { $ = load(food); }); it('() : should get all of the parents in logical order', () => { const orange = $('.orange').parents(); expect(orange).toHaveLength(4); expect(orange[0].attribs).toHaveProperty('id', 'fruits'); expect(orange[1].attribs).toHaveProperty('id', 'food'); expect(orange[2].tagName).toBe('body'); expect(orange[3].tagName).toBe('html'); const fruits = $('#fruits').parents(); expect(fruits).toHaveLength(3); expect(fruits[0].attribs).toHaveProperty('id', 'food'); expect(fruits[1].tagName).toBe('body'); expect(fruits[2].tagName).toBe('html'); }); it('(selector) : should get all of the parents that match the selector in logical order', () => { const fruits = $('.orange').parents('#fruits'); expect(fruits).toHaveLength(1); expect(fruits[0].attribs).toHaveProperty('id', 'fruits'); const uls = $('.orange').parents('ul'); expect(uls).toHaveLength(2); expect(uls[0].attribs).toHaveProperty('id', 'fruits'); expect(uls[1].attribs).toHaveProperty('id', 'food'); }); it('() : should not break if the selector does not have any results', () => { const result = $('.saladbar').parents(); expect(result).toHaveLength(0); }); it('() : should return an empty set for top-level elements', () => { const result = $('html').parents(); expect(result).toHaveLength(0); }); it('() : should return the parents of every element in the *reveresed* collection, omitting duplicates', () => { const $parents = $('li').parents(); expect($parents).toHaveLength(5); expect($parents[0]).toBe($('#vegetables')[0]); expect($parents[1]).toBe($('#fruits')[0]); expect($parents[2]).toBe($('#food')[0]); expect($parents[3]).toBe($('body')[0]); expect($parents[4]).toBe($('html')[0]); }); }); describe('.parentsUntil', () => { beforeEach(() => { $ = load(food); }); it('() : should get all of the parents in logical order', () => { const result = $('.orange').parentsUntil(); expect(result).toHaveLength(4); expect(result[0].attribs).toHaveProperty('id', 'fruits'); expect(result[1].attribs).toHaveProperty('id', 'food'); expect(result[2].tagName).toBe('body'); expect(result[3].tagName).toBe('html'); }); it('() : should get all of the parents in reversed order, omitting duplicates', () => { const result = $('.apple, .sweetcorn').parentsUntil(); expect(result).toHaveLength(5); expect(result[0]).toBe($('#vegetables')[0]); expect(result[1]).toBe($('#fruits')[0]); expect(result[2]).toBe($('#food')[0]); expect(result[3]).toBe($('body')[0]); expect(result[4]).toBe($('html')[0]); }); it('(selector) : should get all of the parents until selector', () => { const food = $('.orange').parentsUntil('#food'); expect(food).toHaveLength(1); expect(food[0].attribs).toHaveProperty('id', 'fruits'); const fruits = $('.orange').parentsUntil('#fruits'); expect(fruits).toHaveLength(0); }); it('(selector) : Less simple parentsUntil check with selector', () => { const result = $('#fruits').parentsUntil('html, body'); expect(result.eq(0).attr('id')).toBe('food'); }); it('(selector not parent) : should return all parents', () => { const result = $('.orange').parentsUntil('.apple'); expect(result).toHaveLength(4); expect(result[0].attribs).toHaveProperty('id', 'fruits'); expect(result[1].attribs).toHaveProperty('id', 'food'); expect(result[2].tagName).toBe('body'); expect(result[3].tagName).toBe('html'); }); it('(selector, filter) : should get all of the parents that match the filter', () => { const result = $('.apple, .sweetcorn').parentsUntil( '.saladbar', '#vegetables', ); expect(result).toHaveLength(1); expect(result[0].attribs).toHaveProperty('id', 'vegetables'); }); it('(selector, filter) : Multiple-filtered parentsUntil check', () => { const result = $('.orange').parentsUntil('html', 'ul,body'); expect(result).toHaveLength(3); expect(result.eq(0).attr('id')).toBe('fruits'); expect(result.eq(1).attr('id')).toBe('food'); expect(result.eq(2).prop('tagName')).toBe('BODY'); }); it('() : should return empty object when called on an empty object', () => { const result = $('.saladbar').parentsUntil(); expect(result).toHaveLength(0); }); it('() : should return an empty set for top-level elements', () => { const result = $('html').parentsUntil(); expect(result).toHaveLength(0); }); it('(cheerio object) : should return all parents until any member of the cheerio object', () => { const $fruits = $('#fruits'); const $until = $('#food'); const result = $fruits.children().eq(1).parentsUntil($until); expect(result).toHaveLength(1); expect(result[0].attribs).toHaveProperty('id', 'fruits'); }); it('(cheerio object) : should return all parents until body element', () => { const body = $('body')[0]; const result = $('.carrot').parentsUntil(body); expect(result).toHaveLength(2); expect(result.eq(0).is('ul#vegetables')).toBe(true); }); }); describe('.parent', () => { it('() : should return the parent of each matched element', () => { let result = $('.orange').parent(); expect(result).toHaveLength(1); expect(result[0].attribs).toHaveProperty('id', 'fruits'); result = $('li', food).parent(); expect(result).toHaveLength(2); expect(result[0].attribs).toHaveProperty('id', 'fruits'); expect(result[1].attribs).toHaveProperty('id', 'vegetables'); }); it('(undefined) : should not throw an exception', () => { expect(() => { $('li').parent(undefined); }).not.toThrow(); }); it('() : should return an empty object for top-level elements', () => { const result = $('html').parent(); expect(result).toHaveLength(0); }); it('() : should not contain duplicate elements', () => { const result = $('li').parent(); expect(result).toHaveLength(1); }); it('(selector) : should filter the matched parent elements by the selector', () => { const parents = $('.orange').parent(); expect(parents).toHaveLength(1); expect(parents[0].attribs).toHaveProperty('id', 'fruits'); const fruits = $('li', food).parent('#fruits'); expect(fruits).toHaveLength(1); expect(fruits[0].attribs).toHaveProperty('id', 'fruits'); }); }); describe('.closest', () => { it('() : should return an empty array', () => { const result = $('.orange').closest(); expect(result).toHaveLength(0); expect(result).toBeInstanceOf(Cheerio); }); it('(selector) : should find the closest element that matches the selector, searching through its ancestors and itself', () => { expect($('.orange').closest('.apple')).toHaveLength(0); expect( ($('.orange', food).closest('#food')[0] as Element).attribs, ).toHaveProperty('id', 'food'); expect( ($('.orange', food).closest('ul')[0] as Element).attribs, ).toHaveProperty('id', 'fruits'); expect( ($('.orange', food).closest('li')[0] as Element).attribs, ).toHaveProperty('class', 'orange'); }); it('(selector) : should find the closest element of each item, removing duplicates', () => { const result = $('li', food).closest('ul'); expect(result).toHaveLength(2); }); it('() : should not break if the selector does not have any results', () => { const result = $('.saladbar', food).closest('ul'); expect(result).toHaveLength(0); }); it('(selector) : should find closest element for text nodes', () => { const textNode = $('.apple', food).contents().first(); const result = textNode.closest('#food') as Cheerio<Element>; expect(result[0].attribs).toHaveProperty('id', 'food'); }); }); describe('.each', () => { it('( (i, elem) -> ) : should loop selected returning fn with (i, elem)', () => { const items: Element[] = []; const classes = ['apple', 'orange', 'pear']; $('li').each(function (idx, elem) { items[idx] = elem; expect(this.attribs).toHaveProperty('class', classes[idx]); }); expect(items[0].attribs).toHaveProperty('class', 'apple'); expect(items[1].attribs).toHaveProperty('class', 'orange'); expect(items[2].attribs).toHaveProperty('class', 'pear'); }); it('( (i, elem) -> ) : should break iteration when the iterator function returns false', () => { let iterationCount = 0; $('li').each((idx) => { iterationCount++; return idx < 1; }); expect(iterationCount).toBe(2); }); }); if (typeof Symbol !== 'undefined') { describe('[Symbol.iterator]', () => { it('should yield each element', () => { // The equivalent of: for (const element of $('li')) ... const $li = $('li'); const iterator = $li[Symbol.iterator]() as Iterator<Element, Element>; expect(iterator.next().value.attribs).toHaveProperty('class', 'apple'); expect(iterator.next().value.attribs).toHaveProperty('class', 'orange'); expect(iterator.next().value.attribs).toHaveProperty('class', 'pear'); expect(iterator.next().done).toBe(true); }); }); } describe('.map', () => { it('(fn) : should be invoked with the correct arguments and context', () => { const $fruits = $('li'); const args: [number, AnyNode][] = []; const thisVals: AnyNode[] = []; $fruits.map(function (...myArgs) { args.push(myArgs); thisVals.push(this); return undefined; }); expect(args).toStrictEqual([ [0, $fruits[0]], [1, $fruits[1]], [2, $fruits[2]], ]); expect(thisVals).toStrictEqual([$fruits[0], $fruits[1], $fruits[2]]); }); it('(fn) : should return an Cheerio object wrapping the returned items', () => { const $fruits = $('li'); const $mapped = $fruits.map((i) => $fruits[2 - i]); expect($mapped).toHaveLength(3); expect($mapped[0]).toBe($fruits[2]); expect($mapped[1]).toBe($fruits[1]); expect($mapped[2]).toBe($fruits[0]); }); it('(fn) : should ignore `null` and `undefined` returned by iterator', () => { const $fruits = $('li'); const retVals = [null, undefined, $fruits[1]]; const $mapped = $fruits.map((i) => retVals[i]); expect($mapped).toHaveLength(1); expect($mapped[0]).toBe($fruits[1]); }); it('(fn) : should preform a shallow merge on arrays returned by iterator', () => { const $fruits = $('li'); const $mapped = $fruits.map(() => [1, [3, 4]]); expect($mapped.get()).toStrictEqual([1, [3, 4], 1, [3, 4], 1, [3, 4]]); }); it('(fn) : should tolerate `null` and `undefined` when flattening arrays returned by iterator', () => { const $fruits = $('li'); const $mapped = $fruits.map(() => [null, undefined]); expect($mapped.get()).toStrictEqual([ null, undefined, null, undefined, null, undefined, ]); }); }); describe('.filter', () => { it('(selector) : should reduce the set of matched elements to those that match the selector', () => { const pear = $('li').filter('.pear').text(); expect(pear).toBe('Pear'); }); it('(selector) : should not consider nested elements', () => { const lis = $('#fruits').filter('li'); expect(lis).toHaveLength(0); }); it('(selection) : should reduce the set of matched elements to those that are contained in the provided selection', () => { const $fruits = $('li'); const $pear = $fruits.filter('.pear, .apple'); expect($fruits.filter($pear)).toHaveLength(2); }); it('(element) : should reduce the set of matched elements to those that specified directly', () => { const $fruits = $('li'); const pear = $fruits.filter('.pear')[0]; expect($fruits.filter(pear)).toHaveLength(1); }); it("(fn) : should reduce the set of matched elements to those that pass the function's test", () => { const orange = $('li') .filter(function (i, el) { expect(this).toBe(el); expect(el.tagName).toBe('li'); expect(typeof i).toBe('number'); return $(this).attr('class') === 'orange'; }) .text(); expect(orange).toBe('Orange'); }); it('should also iterate over text nodes (#1867)', () => { const text = $('<a>a</a>b<c></c>').filter((_, el): el is Text => isText(el), ); expect(text[0].data).toBe('b'); }); }); describe('.not', () => { it('(selector) : should reduce the set of matched elements to those that do not match the selector', () => { const $fruits = $('li'); const $notPear = $fruits.not('.pear'); expect($notPear).toHaveLength(2); expect($notPear[0]).toBe($fruits[0]); expect($notPear[1]).toBe($fruits[1]); }); it('(selector) : should not consider nested elements', () => { const lis = $('#fruits').not('li'); expect(lis).toHaveLength(1); }); it('(selection) : should reduce the set of matched elements to those that are mot contained in the provided selection', () => { const $fruits = $('li'); const $orange = $('.orange'); const $notOrange = $fruits.not($orange); expect($notOrange).toHaveLength(2); expect($notOrange[0]).toBe($fruits[0]); expect($notOrange[1]).toBe($fruits[2]); }); it('(element) : should reduce the set of matched elements to those that specified directly', () => { const $fruits = $('li'); const apple = $('.apple')[0]; const $notApple = $fruits.not(apple); expect($notApple).toHaveLength(2); expect($notApple[0]).toBe($fruits[1]); expect($notApple[1]).toBe($fruits[2]); }); it("(fn) : should reduce the set of matched elements to those that do not pass the function's test", () => { const $fruits = $('li'); const $notOrange = $fruits.not(function (i, el) { expect(this).toBe(el); expect(el).toHaveProperty('name', 'li'); expect(typeof i).toBe('number'); return $(this).attr('class') === 'orange'; }); expect($notOrange).toHaveLength(2); expect($notOrange[0]).toBe($fruits[0]); expect($notOrange[1]).toBe($fruits[2]); }); }); describe('.has', () => { beforeEach(() => { $ = load(food); }); it('(selector) : should reduce the set of matched elements to those with descendants that match the selector', () => { const $fruits = $('#fruits,#vegetables').has('.pear'); expect($fruits).toHaveLength(1); expect($fruits[0]).toBe($('#fruits')[0]); }); it('(selector) : should only consider nested elements', () => { const $empty = $('#fruits').has('#fruits'); expect($empty).toHaveLength(0); }); it('(element) : should reduce the set of matched elements to those that are ancestors of the provided element', () => { const $fruits = $('#fruits,#vegetables').has($('.pear')[0]); expect($fruits).toHaveLength(1); expect($fruits[0]).toBe($('#fruits')[0]); }); it('(element) : should only consider nested elements', () => { const $fruits = $('#fruits'); const fruitsEl = $fruits[0]; const $empty = $fruits.has(fruitsEl); expect($empty).toHaveLength(0); }); }); describe('.first', () => { it('() : should return the first item', () => { const $src = $( '<span>foo</span><span>bar</span><span>baz</span>', ) as Cheerio<Element>; const $elem = $src.first(); expect($elem.length).toBe(1); expect($elem[0].childNodes[0]).toHaveProperty('data', 'foo'); }); it('() : should return an empty object for an empty object', () => { const $src = $(); const $first = $src.first(); expect($first.length).toBe(0); expect($first[0]).toBeUndefined(); }); }); describe('.last', () => { it('() : should return the last element', () => { const $src = $( '<span>foo</span><span>bar</span><span>baz</span>', ) as Cheerio<Element>; const $elem = $src.last(); expect($elem.length).toBe(1); expect($elem[0].childNodes[0]).toHaveProperty('data', 'baz'); }); it('() : should return an empty object for an empty object', () => { const $src = $(); const $last = $src.last(); expect($last.length).toBe(0); expect($last[0]).toBeUndefined(); }); }); describe('.first & .last', () => { it('() : should return equivalent collections if only one element', () => { const $src = $('<span>bar</span>') as Cheerio<Element>; const $first = $src.first(); const $last = $src.last(); expect($first.length).toBe(1); expect($first[0].childNodes[0]).toHaveProperty('data', 'bar'); expect($last.length).toBe(1); expect($last[0].childNodes[0]).toHaveProperty('data', 'bar'); expect($first[0]).toBe($last[0]); }); }); describe('.eq', () => { it('(i) : should return the element at the specified index', () => { expect(getText($('li').eq(0))).toBe('Apple'); expect(getText($('li').eq(1))).toBe('Orange'); expect(getText($('li').eq(2))).toBe('Pear'); expect(getText($('li').eq(3))).toBeUndefined(); expect(getText($('li').eq(-1))).toBe('Pear'); }); }); describe('.get', () => { it('(i) : should return the element at the specified index', () => { const children = $('#fruits').children(); expect(children.get(0)).toBe(children[0]); expect(children.get(1)).toBe(children[1]); expect(children.get(2)).toBe(children[2]); }); it('(-1) : should return the element indexed from the end of the collection', () => { const children = $('#fruits').children(); expect(children.get(-1)).toBe(children[2]); expect(children.get(-2)).toBe(children[1]); expect(children.get(-3)).toBe(children[0]); }); it('() : should return an array containing all of the collection', () => { const children = $('#fruits').children(); const all = children.get(); expect(Array.isArray(all)).toBe(true); expect(all).toStrictEqual([children[0], children[1], children[2]]); }); }); describe('.index', () => { describe('() :', () => { it('returns the index of a child amongst its siblings', () => { expect($('.orange').index()).toBe(1); }); it('returns -1 when the selection has no parent', () => { expect($('<div/>').index()).toBe(-1); }); }); describe('(selector) :', () => { it('returns the index of the first element in the set matched by `selector`', () => { expect($('.apple').index('#fruits, li')).toBe(1); }); it('returns -1 when the item is not present in the set matched by `selector`', () => { expect($('.apple').index('#fuits')).toBe(-1); }); it('returns -1 when the first element in the set has no parent', () => { expect($('<div/>').index('*')).toBe(-1); }); }); describe('(node) :', () => { it('returns the index of the given node within the current selection', () => { const $lis = $('li'); expect($lis.index($lis.get(1))).toBe(1); }); it('returns the index of the given node within the current selection when the current selection has no parent', () => { const $apple = $('.apple').remove(); expect($apple.index($apple.get(0))).toBe(0); }); it('returns -1 when the given node is not present in the current selection', () => { expect($('li').index($('#fruits').get(0))).toBe(-1); }); it('returns -1 when the current selection is empty', () => { expect($('.not-fruit').index($('#fruits').get(0))).toBe(-1); }); }); describe('(selection) :', () => { it('returns the index of the first node in the provided selection within the current selection', () => { const $lis = $('li'); expect($lis.index($('.orange, .pear'))).toBe(1); }); it('returns -1 when the given node is not present in the current selection', () => { expect($('li').index($('#fruits'))).toBe(-1); }); it('returns -1 when the current selection is empty', () => { expect($('.not-fruit').index($('#fruits'))).toBe(-1); }); }); }); describe('.slice', () => { it('(start) : should return all elements after the given index', () => { const sliced = $('li').slice(1); expect(sliced).toHaveLength(2); expect(getText(sliced.eq(0))).toBe('Orange'); expect(getText(sliced.eq(1))).toBe('Pear'); }); it('(start, end) : should return all elements matching the given range', () => { const sliced = $('li').slice(1, 2); expect(sliced).toHaveLength(1); expect(getText(sliced.eq(0))).toBe('Orange'); }); it('(-start) : should return element matching the offset from the end', () => { const sliced = $('li').slice(-1); expect(sliced).toHaveLength(1); expect(getText(sliced.eq(0))).toBe('Pear'); }); }); describe('.end() :', () => { let $fruits: Cheerio<Element>; beforeEach(() => { $fruits = $('#fruits').children(); }); it('returns an empty object at the end of the chain', () => { expect($fruits.end().end().end()).toBeTruthy(); expect($fruits.end().end().end()).toHaveLength(0); }); it('find', () => { expect($fruits.find('.apple').end()).toBe($fruits); }); it('filter', () => { expect($fruits.filter('.apple').end()).toBe($fruits); }); it('map', () => { expect( $fruits .map(function () { return this; }) .end(), ).toBe($fruits); }); it('contents', () => { expect($fruits.contents().end()).toBe($fruits); }); it('eq', () => { expect($fruits.eq(1).end()).toBe($fruits); }); it('first', () => { expect($fruits.first().end()).toBe($fruits); }); it('last', () => { expect($fruits.last().end()).toBe($fruits); }); it('slice', () => { expect($fruits.slice(1).end()).toBe($fruits); }); it('children', () => { expect($fruits.children().end()).toBe($fruits); }); it('parent', () => { expect($fruits.parent().end()).toBe($fruits); }); it('parents', () => { expect($fruits.parents().end()).toBe($fruits); }); it('closest', () => { expect($fruits.closest('ul').end()).toBe($fruits); }); it('siblings', () => { expect($fruits.siblings().end()).toBe($fruits); }); it('next', () => { expect($fruits.next().end()).toBe($fruits); }); it('nextAll', () => { expect($fruits.nextAll().end()).toBe($fruits); }); it('prev', () => { expect($fruits.prev().end()).toBe($fruits); }); it('prevAll', () => { expect($fruits.prevAll().end()).toBe($fruits); }); it('clone', () => { expect($fruits.clone().end()).toBe($fruits); }); }); describe('.add()', () => { let $fruits: Cheerio<AnyNode>; let $apple: Cheerio<Element>; let $orange: Cheerio<Element>; let $pear: Cheerio<Element>; beforeEach(() => { $ = load(food); $fruits = $('#fruits'); $apple = $('.apple'); $orange = $('.orange'); $pear = $('.pear'); }); describe('(selector) matched element :', () => { it('occurs before current selection', () => { const $selection = $orange.add('.apple'); expect($selection).toHaveLength(2); expect($selection[0]).toBe($apple[0]); expect($selection[1]).toBe($orange[0]); }); it('is identical to the current selection', () => { const $selection = $orange.add('.orange'); expect($selection).toHaveLength(1); expect($selection[0]).toBe($orange[0]); }); it('occurs after current selection', () => { const $selection = $orange.add('.pear'); expect($selection).toHaveLength(2); expect($selection[0]).toBe($orange[0]); expect($selection[1]).toBe($pear[0]); }); it('contains the current selection', () => { const $selection = $orange.add('#fruits'); expect($selection).toHaveLength(2); expect($selection[0]).toBe($fruits[0]); expect($selection[1]).toBe($orange[0]); }); it('is a child of the current selection', () => { const $selection = $fruits.add('.orange'); expect($selection).toHaveLength(2); expect($selection[0]).toBe($fruits[0]); expect($selection[1]).toBe($orange[0]); }); it('is root object preserved', () => { const $selection = $('<div></div>').add('#fruits'); expect($selection).toHaveLength(2); expect($selection.eq(0).is('div')).toBe(true); expect($selection.eq(1).is($fruits.eq(0))).toBe(true); }); }); describe('(selector) matched elements :', () => { it('occur before the current selection', () => { const $selection = $pear.add('.apple, .orange'); expect($selection).toHaveLength(3); expect($selection[0]).toBe($apple[0]); expect($selection[1]).toBe($orange[0]); expect($selection[2]).toBe($pear[0]); }); it('include the current selection', () => { const $selection = $pear.add('#fruits li'); expect($selection).toHaveLength(3); expect($selection[0]).toBe($apple[0]); expect($selection[1]).toBe($orange[0]); expect($selection[2]).toBe($pear[0]); }); it('occur after the current selection', () => { const $selection = $apple.add('.orange, .pear'); expect($selection).toHaveLength(3); expect($selection[0]).toBe($apple[0]); expect($selection[1]).toBe($orange[0]); expect($selection[2]).toBe($pear[0]); }); it('occur within the current selection', () => { const $selection = $fruits.add('#fruits li'); expect($selection).toHaveLength(4); expect($selection[0]).toBe($fruits[0]); expect($selection[1]).toBe($apple[0]); expect($selection[2]).toBe($orange[0]); expect($selection[3]).toBe($pear[0]); }); }); describe('(selector, context) :', () => { it(', context)', () => { const $selection = $fruits.add('li', '#vegetables'); expect($selection).toHaveLength(3); expect($selection[0]).toBe($fruits[0]); expect($selection[1]).toBe($('.carrot')[0]); expect($selection[2]).toBe($('.sweetcorn')[0]); }); }); describe('(element) honors document order when element occurs :', () => { it('before the current selection', () => { const $selection = $orange.add($apple[0]); expect($selection).toHaveLength(2); expect($selection[0]).toBe($apple[0]); expect($selection[1]).toBe($orange[0]); }); it('after the current selection', () => { const $selection = $orange.add($pear[0]); expect($selection).toHaveLength(2); expect($selection[0]).toBe($orange[0]); expect($selection[1]).toBe($pear[0]); }); it('within the current selection', () => { const $selection = $fruits.add($orange[0]); expect($selection).toHaveLength(2); expect($selection[0]).toBe($fruits[0]); expect($selection[1]).toBe($orange[0]); }); it('as an ancestor of the current selection', () => { const $selection = $orange.add($fruits[0]); expect($selection).toHaveLength(2); expect($selection[0]).toBe($fruits[0]); expect($selection[1]).toBe($orange[0]); }); it('does not insert an element already contained within the current selection', () => { const $selection = $apple.add($apple[0]); expect($selection).toHaveLength(1); expect($selection[0]).toBe($apple[0]); }); }); describe('([elements]) : elements', () => { it('occur before the current selection', () => { const $selection = $pear.add($('.apple, .orange').get()); expect($selection).toHaveLength(3); expect($selection[0]).toBe($apple[0]); expect($selection[1]).toBe($orange[0]); expect($selection[2]).toBe($pear[0]); }); it('include the current selection', () => { const $selection = $pear.add($('#fruits li').get()); expect($selection).toHaveLength(3); expect($selection[0]).toBe($apple[0]); expect($selection[1]).toBe($orange[0]); expect($selection[2]).toBe($pear[0]); }); it('occur after the current selection', () => { const $selection = $apple.add($('.orange, .pear').get()); expect($selection).toHaveLength(3); expect($selection[0]).toBe($apple[0]); expect($selection[1]).toBe($orange[0]); expect($selection[2]).toBe($pear[0]); }); it('occur within the current selection', () => { const $selection = $fruits.add($('#fruits li').get()); expect($selection).toHaveLength(4); expect($selection[0]).toBe($fruits[0]); expect($selection[1]).toBe($apple[0]); expect($selection[2]).toBe($orange[0]); expect($selection[3]).toBe($pear[0]); }); }); /** * Element order is undefined in this case, so it should not be asserted * here. * * If the collection consists of elements from different documents or ones * not in any document, the sort order is undefined. * * @see {@link https://api.jquery.com/add/} */ it('(html) : correctly parses and adds the new elements', () => { const $selection = $apple.add('<li class="banana">banana</li>'); expect($selection).toHaveLength(2); expect($selection.is('.apple')).toBe(true); expect($selection.is('.banana')).toBe(true); }); describe('(selection) element in selection :', () => { it('occurs before current selection', () => { const $selection = $orange.add($('.apple')); expect($selection).toHaveLength(2); expect($selection[0]).toBe($apple[0]); expect($selection[1]).toBe($orange[0]); }); it('is identical to the current selection', () => { const $selection = $orange.add($('.orange')); expect($selection).toHaveLength(1); expect($selection[0]).toBe($orange[0]); }); it('occurs after current selection', () => { const $selection = $orange.add($('.pear')); expect($selection).toHaveLength(2); expect($selection[0]).toBe($orange[0]); expect($selection[1]).toBe($pear[0]); }); it('contains the current selection', () => { const $selection = $orange.add($('#fruits')); expect($selection).toHaveLength(2); expect($selection[0]).toBe($fruits[0]); expect($selection[1]).toBe($orange[0]); }); it('is a child of the current selection', () => { const $selection = $fruits.add($('.orange')); expect($selection).toHaveLength(2); expect($selection[0]).toBe($fruits[0]); expect($selection[1]).toBe($orange[0]); }); }); describe('(selection) elements in the selection :', () => { it('occur before the current selection', () => { const $selection = $pear.add($('.apple, .orange')); expect($selection).toHaveLength(3); expect($selection[0]).toBe($apple[0]); expect($selection[1]).toBe($orange[0]); expect($selection[2]).toBe($pear[0]); }); it('include the current selection', () => { const $selection = $pear.add($('#fruits li')); expect($selection).toHaveLength(3); expect($selection[0]).toBe($apple[0]); expect($selection[1]).toBe($orange[0]); expect($selection[2]).toBe($pear[0]); }); it('occur after the current selection', () => { const $selection = $apple.add($('.orange, .pear')); expect($selection).toHaveLength(3); expect($selection[0]).toBe($apple[0]); expect($selection[1]).toBe($orange[0]); expect($selection[2]).toBe($pear[0]); }); it('occur within the current selection', () => { const $selection = $fruits.add($('#fruits li')); expect($selection).toHaveLength(4); expect($selection[0]).toBe($fruits[0]); expect($selection[1]).toBe($apple[0]); expect($selection[2]).toBe($orange[0]); expect($selection[3]).toBe($pear[0]); }); }); describe('(selection) :', () => { it('modifying nested selections should not impact the parent [#834]', () => { const apple_pear = $apple.add($pear); // Applies red to apple and pear apple_pear.addClass('red'); expect($apple.hasClass('red')).toBe(true); // This is true expect($pear.hasClass('red')).toBe(true); // This is true // Applies green to pear... AND should not affect apple $pear.addClass('green'); expect($pear.hasClass('green')).toBe(true); // Currently this is true expect($apple.hasClass('green')).toBe(false); // And this should be false! }); }); }); describe('.addBack', () => { describe('() :', () => { it('includes siblings and self', () => { const $selection = $('.orange').siblings().addBack(); expect($selection).toHaveLength(3); expect($selection[0]).toBe($('.apple')[0]); expect($selection[1]).toBe($('.orange')[0]); expect($selection[2]).toBe($('.pear')[0]); }); it('includes children and self', () => { const $selection = $('#fruits').children().addBack(); expect($selection).toHaveLength(4); expect($selection[0]).toBe($('#fruits')[0]); expect($selection[1]).toBe($('.apple')[0]); expect($selection[2]).toBe($('.orange')[0]); expect($selection[3]).toBe($('.pear')[0]); }); it('includes parent and self', () => { const $selection = $('.apple').parent().addBack(); expect($selection).toHaveLength(2); expect($selection[0]).toBe($('#fruits')[0]); expect($selection[1]).toBe($('.apple')[0]); }); it('includes parents and self', () => { const q = load(food); const $selection = q('.apple').parents().addBack(); expect($selection).toHaveLength(5); expect($selection[0]).toBe(q('html')[0]); expect($selection[1]).toBe(q('body')[0]); expect($selection[2]).toBe(q('#food')[0]); expect($selection[3]).toBe(q('#fruits')[0]); expect($selection[4]).toBe(q('.apple')[0]); }); }); it('(filter) : filters the previous selection', () => { const $selection = $('li').eq(1).addBack('.apple'); expect($selection).toHaveLength(2); expect($selection[0]).toBe($('.apple')[0]); expect($selection[1]).toBe($('.orange')[0]); }); it('() : fails gracefully when no args are passed', () => { const $div = cheerio('<div>'); expect($div.addBack()).toBe($div); }); }); describe('.is', () => { it('() : should return false', () => { expect($('li.apple').is()).toBe(false); }); it('(true selector) : should return true', () => { expect(cheerio('#vegetables', vegetables).is('ul')).toBe(true); }); it('(false selector) : should return false', () => { expect(cheerio('#vegetables', vegetables).is('div')).toBe(false); }); it('(true selection) : should return true', () => { const $vegetables = cheerio('li', vegetables); expect($vegetables.is($vegetables.eq(1))).toBe(true); }); it('(false selection) : should return false', () => { const $vegetableList = cheerio(vegetables); const $vegetables = $vegetableList.find('li'); expect($vegetables.is($vegetableList)).toBe(false); }); it('(true element) : should return true', () => { const $vegetables = cheerio('li', vegetables); expect($vegetables.is($vegetables[0])).toBe(true); }); it('(false element) : should return false', () => { const $vegetableList = cheerio(vegetables); const $vegetables = $vegetableList.find('li'); expect($vegetables.is($vegetableList[0])).toBe(false); }); it('(true predicate) : should return true', () => { const result = $('li').is(function () { return this.tagName === 'li' && $(this).hasClass('pear'); }); expect(result).toBe(true); }); it('(false predicate) : should return false', () => { const result = $('li') .last() .is(function () { return this.tagName === 'ul'; }); expect(result).toBe(false); }); }); }); /** * Methods for traversing the DOM structure. * * @module cheerio/traversing */ import { isTag, type AnyNode, type Element, hasChildren, isDocument, type Document, } from 'domhandler'; import type { Cheerio } from '../cheerio.js'; import * as select from 'cheerio-select'; import { domEach, isCheerio } from '../utils.js'; import { contains } from '../static.js'; import { getChildren, getSiblings, nextElementSibling, prevElementSibling, uniqueSort, } from 'domutils'; import type { FilterFunction, AcceptedFilters } from '../types.js'; const reSiblingSelector = /^\s*[+~]/; /** * Get the descendants of each element in the current set of matched elements, * filtered by a selector, jQuery object, or element. * * @category Traversing * @example * * ```js * $('#fruits').find('li').length; * //=> 3 * $('#fruits').find($('.apple')).length; * //=> 1 * ``` * * @param selectorOrHaystack - Element to look for. * @returns The found elements. * @see {@link https://api.jquery.com/find/} */ export function find<T extends AnyNode>( this: Cheerio<T>, selectorOrHaystack?: string | Cheerio<Element> | Element, ): Cheerio<Element> { if (!selectorOrHaystack) { return this._make([]); } if (typeof selectorOrHaystack !== 'string') { const haystack = isCheerio(selectorOrHaystack) ? selectorOrHaystack.toArray() : [selectorOrHaystack]; const context = this.toArray(); return this._make( haystack.filter((elem) => context.some((node) => contains(node, elem))), ); } return this._findBySelector(selectorOrHaystack, Number.POSITIVE_INFINITY); } /** * Find elements by a specific selector. * * @private * @category Traversing * @param selector - Selector to filter by. * @param limit - Maximum number of elements to match. * @returns The found elements. */ export function _findBySelector<T extends AnyNode>( this: Cheerio<T>, selector: string, limit: number, ): Cheerio<Element> { const context = this.toArray(); const elems = reSiblingSelector.test(selector) ? context : this.children().toArray(); const options = { context, root: this._root?.[0], // Pass options that are recognized by `cheerio-select` xmlMode: this.options.xmlMode, lowerCaseTags: this.options.lowerCaseTags, lowerCaseAttributeNames: this.options.lowerCaseAttributeNames, pseudos: this.options.pseudos, quirksMode: this.options.quirksMode, }; return this._make(select.select(selector, elems, options, limit)); } /** * Creates a matcher, using a particular mapping function. Matchers provide a * function that finds elements using a generating function, supporting * filtering. * * @private * @param matchMap - Mapping function. * @returns - Function for wrapping generating functions. */ function _getMatcher<P>( matchMap: (fn: (elem: AnyNode) => P, elems: Cheerio<AnyNode>) => Element[], ) { return function ( fn: (elem: AnyNode) => P, ...postFns: ((elems: Element[]) => Element[])[] ) { return function <T extends AnyNode>( this: Cheerio<T>, selector?: AcceptedFilters<Element>, ): Cheerio<Element> { let matched: Element[] = matchMap(fn, this); if (selector) { matched = filterArray( matched, selector, this.options.xmlMode, this._root?.[0], ); } return this._make( // Post processing is only necessary if there is more than one element. this.length > 1 && matched.length > 1 ? postFns.reduce((elems, fn) => fn(elems), matched) : matched, ); }; }; } /** Matcher that adds multiple elements for each entry in the input. */ const _matcher = _getMatcher((fn: (elem: AnyNode) => Element[], elems) => { let ret: Element[] = []; for (let i = 0; i < elems.length; i++) { const value = fn(elems[i]); if (value.length > 0) ret = ret.concat(value); } return ret; }); /** Matcher that adds at most one element for each entry in the input. */ const _singleMatcher = _getMatcher( (fn: (elem: AnyNode) => Element | null, elems) => { const ret: Element[] = []; for (let i = 0; i < elems.length; i++) { const value = fn(elems[i]); if (value !== null) { ret.push(value); } } return ret; }, ); /** * Matcher that supports traversing until a condition is met. * * @param nextElem - Function that returns the next element. * @param postFns - Post processing functions. * @returns A function usable for `*Until` methods. */ function _matchUntil( nextElem: (elem: AnyNode) => Element | null, ...postFns: ((elems: Element[]) => Element[])[] ) { // We use a variable here that is used from within the matcher. let matches: ((el: Element, i: number) => boolean) | null = null; const innerMatcher = _getMatcher( (nextElem: (elem: AnyNode) => Element | null, elems) => { const matched: Element[] = []; domEach(elems, (elem) => { for (let next; (next = nextElem(elem)); elem = next) { // FIXME: `matched` might contain duplicates here and the index is too large. if (matches?.(next, matched.length)) break; matched.push(next); } }); return matched; }, )(nextElem, ...postFns); return function <T extends AnyNode>( this: Cheerio<T>, selector?: AcceptedFilters<Element> | null, filterSelector?: AcceptedFilters<Element>, ): Cheerio<Element> { // Override `matches` variable with the new target. matches = typeof selector === 'string' ? (elem: Element) => select.is(elem, selector, this.options) : selector ? getFilterFn(selector) : null; const ret = innerMatcher.call(this, filterSelector); // Set `matches` to `null`, so we don't waste memory. matches = null; return ret; }; } function _removeDuplicates<T extends AnyNode>(elems: T[]): T[] { return elems.length > 1 ? Array.from(new Set<T>(elems)) : elems; } /** * Get the parent of each element in the current set of matched elements, * optionally filtered by a selector. * * @category Traversing * @example * * ```js * $('.pear').parent().attr('id'); * //=> fruits * ``` * * @param selector - If specified filter for parent. * @returns The parents. * @see {@link https://api.jquery.com/parent/} */ export const parent: <T extends AnyNode>( this: Cheerio<T>, selector?: AcceptedFilters<Element>, ) => Cheerio<Element> = _singleMatcher( ({ parent }) => (parent && !isDocument(parent) ? (parent as Element) : null), _removeDuplicates, ); /** * Get a set of parents filtered by `selector` of each element in the current * set of match elements. * * @category Traversing * @example * * ```js * $('.orange').parents().length; * //=> 2 * $('.orange').parents('#fruits').length; * //=> 1 * ``` * * @param selector - If specified filter for parents. * @returns The parents. * @see {@link https://api.jquery.com/parents/} */ export const parents: <T extends AnyNode>( this: Cheerio<T>, selector?: AcceptedFilters<Element>, ) => Cheerio<Element> = _matcher( (elem) => { const matched = []; while (elem.parent && !isDocument(elem.parent)) { matched.push(elem.parent as Element); elem = elem.parent; } return matched; }, uniqueSort, (elems) => elems.reverse(), ); /** * 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. * * @category Traversing * @example * * ```js * $('.orange').parentsUntil('#food').length; * //=> 1 * ``` * * @param selector - Selector for element to stop at. * @param filterSelector - Optional filter for parents. * @returns The parents. * @see {@link https://api.jquery.com/parentsUntil/} */ export const parentsUntil: <T extends AnyNode>( this: Cheerio<T>, selector?: AcceptedFilters<Element> | null, filterSelector?: AcceptedFilters<Element>, ) => Cheerio<Element> = _matchUntil( ({ parent }) => (parent && !isDocument(parent) ? (parent as Element) : null), uniqueSort, (elems) => elems.reverse(), ); /** * 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. * * @category Traversing * @example * * ```js * $('.orange').closest(); * //=> [] * * $('.orange').closest('.apple'); * // => [] * * $('.orange').closest('li'); * //=> [<li class="orange">Orange</li>] * * $('.orange').closest('#fruits'); * //=> [<ul id="fruits"> ... </ul>] * ``` * * @param selector - Selector for the element to find. * @returns The closest nodes. * @see {@link https://api.jquery.com/closest/} */ export function closest<T extends AnyNode>( this: Cheerio<T>, selector?: AcceptedFilters<Element>, ): Cheerio<AnyNode> { const set: AnyNode[] = []; if (!selector) { return this._make(set); } const selectOpts = { xmlMode: this.options.xmlMode, root: this._root?.[0], }; const selectFn = typeof selector === 'string' ? (elem: Element) => select.is(elem, selector, selectOpts) : getFilterFn(selector); domEach(this, (elem: AnyNode | null) => { if (elem && !isDocument(elem) && !isTag(elem)) { elem = elem.parent; } while (elem && isTag(elem)) { if (selectFn(elem, 0)) { // Do not add duplicate elements to the set if (!set.includes(elem)) { set.push(elem); } break; } elem = elem.parent; } }); return this._make(set); } /** * Gets the next sibling of each selected element, optionally filtered by a * selector. * * @category Traversing * @example * * ```js * $('.apple').next().hasClass('orange'); * //=> true * ``` * * @param selector - If specified filter for sibling. * @returns The next nodes. * @see {@link https://api.jquery.com/next/} */ export const next: <T extends AnyNode>( this: Cheerio<T>, selector?: AcceptedFilters<Element>, ) => Cheerio<Element> = _singleMatcher((elem) => nextElementSibling(elem)); /** * Gets all the following siblings of the each selected element, optionally * filtered by a selector. * * @category Traversing * @example * * ```js * $('.apple').nextAll(); * //=> [<li class="orange">Orange</li>, <li class="pear">Pear</li>] * $('.apple').nextAll('.orange'); * //=> [<li class="orange">Orange</li>] * ``` * * @param selector - If specified filter for siblings. * @returns The next nodes. * @see {@link https://api.jquery.com/nextAll/} */ export const nextAll: <T extends AnyNode>( this: Cheerio<T>, selector?: AcceptedFilters<Element>, ) => Cheerio<Element> = _matcher((elem) => { const matched = []; while (elem.next) { elem = elem.next; if (isTag(elem)) matched.push(elem); } return matched; }, _removeDuplicates); /** * Gets all the following siblings up to but not including the element matched * by the selector, optionally filtered by another selector. * * @category Traversing * @example * * ```js * $('.apple').nextUntil('.pear'); * //=> [<li class="orange">Orange</li>] * ``` * * @param selector - Selector for element to stop at. * @param filterSelector - If specified filter for siblings. * @returns The next nodes. * @see {@link https://api.jquery.com/nextUntil/} */ export const nextUntil: <T extends AnyNode>( this: Cheerio<T>, selector?: AcceptedFilters<Element> | null, filterSelector?: AcceptedFilters<Element>, ) => Cheerio<Element> = _matchUntil( (el) => nextElementSibling(el), _removeDuplicates, ); /** * Gets the previous sibling of each selected element optionally filtered by a * selector. * * @category Traversing * @example * * ```js * $('.orange').prev().hasClass('apple'); * //=> true * ``` * * @param selector - If specified filter for siblings. * @returns The previous nodes. * @see {@link https://api.jquery.com/prev/} */ export const prev: <T extends AnyNode>( this: Cheerio<T>, selector?: AcceptedFilters<Element>, ) => Cheerio<Element> = _singleMatcher((elem) => prevElementSibling(elem)); /** * Gets all the preceding siblings of each selected element, optionally filtered * by a selector. * * @category Traversing * @example * * ```js * $('.pear').prevAll(); * //=> [<li class="orange">Orange</li>, <li class="apple">Apple</li>] * * $('.pear').prevAll('.orange'); * //=> [<li class="orange">Orange</li>] * ``` * * @param selector - If specified filter for siblings. * @returns The previous nodes. * @see {@link https://api.jquery.com/prevAll/} */ export const prevAll: <T extends AnyNode>( this: Cheerio<T>, selector?: AcceptedFilters<Element>, ) => Cheerio<Element> = _matcher((elem) => { const matched = []; while (elem.prev) { elem = elem.prev; if (isTag(elem)) matched.push(elem); } return matched; }, _removeDuplicates); /** * Gets all the preceding siblings up to but not including the element matched * by the selector, optionally filtered by another selector. * * @category Traversing * @example * * ```js * $('.pear').prevUntil('.apple'); * //=> [<li class="orange">Orange</li>] * ``` * * @param selector - Selector for element to stop at. * @param filterSelector - If specified filter for siblings. * @returns The previous nodes. * @see {@link https://api.jquery.com/prevUntil/} */ export const prevUntil: <T extends AnyNode>( this: Cheerio<T>, selector?: AcceptedFilters<Element> | null, filterSelector?: AcceptedFilters<Element>, ) => Cheerio<Element> = _matchUntil( (el) => prevElementSibling(el), _removeDuplicates, ); /** * Get the siblings of each element (excluding the element) in the set of * matched elements, optionally filtered by a selector. * * @category Traversing * @example * * ```js * $('.pear').siblings().length; * //=> 2 * * $('.pear').siblings('.orange').length; * //=> 1 * ``` * * @param selector - If specified filter for siblings. * @returns The siblings. * @see {@link https://api.jquery.com/siblings/} */ export const siblings: <T extends AnyNode>( this: Cheerio<T>, selector?: AcceptedFilters<Element>, ) => Cheerio<Element> = _matcher( (elem) => getSiblings(elem).filter((el): el is Element => isTag(el) && el !== elem), uniqueSort, ); /** * Gets the element children of each element in the set of matched elements. * * @category Traversing * @example * * ```js * $('#fruits').children().length; * //=> 3 * * $('#fruits').children('.pear').text(); * //=> Pear * ``` * * @param selector - If specified filter for children. * @returns The children. * @see {@link https://api.jquery.com/children/} */ export const children: <T extends AnyNode>( this: Cheerio<T>, selector?: AcceptedFilters<Element>, ) => Cheerio<Element> = _matcher( (elem) => getChildren(elem).filter(isTag), _removeDuplicates, ); /** * Gets the children of each element in the set of matched elements, including * text and comment nodes. * * @category Traversing * @example * * ```js * $('#fruits').contents().length; * //=> 3 * ``` * * @returns The children. * @see {@link https://api.jquery.com/contents/} */ export function contents<T extends AnyNode>( this: Cheerio<T>, ): Cheerio<AnyNode> { const elems = this.toArray().reduce<AnyNode[]>( (newElems, elem) => hasChildren(elem) ? newElems.concat(elem.children) : newElems, [], ); return this._make(elems); } /** * 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`. * * @category Traversing * @example * * ```js * const fruits = []; * * $('li').each(function (i, elem) { * fruits[i] = $(this).text(); * }); * * fruits.join(', '); * //=> Apple, Orange, Pear * ``` * * @param fn - Function to execute. * @returns The instance itself, useful for chaining. * @see {@link https://api.jquery.com/each/} */ export function each<T>( this: Cheerio<T>, fn: (this: T, i: number, el: T) => void | boolean, ): Cheerio<T> { let i = 0; const len = this.length; while (i < len && fn.call(this[i], i, this[i]) !== false) ++i; return this; } /** * 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. * * @category Traversing * @example * * ```js * $('li') * .map(function (i, el) { * // this === el * return $(this).text(); * }) * .toArray() * .join(' '); * //=> "apple orange pear" * ``` * * @param fn - Function to execute. * @returns The mapped elements, wrapped in a Cheerio collection. * @see {@link https://api.jquery.com/map/} */ export function map<T, M>( this: Cheerio<T>, fn: (this: T, i: number, el: T) => M[] | M | null | undefined, ): Cheerio<M> { let elems: M[] = []; for (let i = 0; i < this.length; i++) { const el = this[i]; const val = fn.call(el, i, el); if (val != null) { elems = elems.concat(val); } } return this._make(elems); } /** * Creates a function to test if a filter is matched. * * @param match - A filter. * @returns A function that determines if a filter has been matched. */ function getFilterFn<T>( match: FilterFunction<T> | Cheerio<T> | T, ): (el: T, i: number) => boolean { if (typeof match === 'function') { return (el, i) => (match as FilterFunction<T>).call(el, i, el); } if (isCheerio<T>(match)) { return (el) => Array.prototype.includes.call(match, el); } return function (el) { return match === el; }; } /** * 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. * * @category Traversing * @example <caption>Function</caption> * * ```js * $('li') * .filter(function (i, el) { * // this === el * return $(this).attr('class') === 'orange'; * }) * .attr('class'); //=> orange * ``` * * @param match - Value to look for, following the rules above. * @returns The filtered collection. * @see {@link https://api.jquery.com/filter/} */ export function filter<T, S extends T>( 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. * * - 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. * * @category Traversing * @example <caption>Selector</caption> * * ```js * $('li').filter('.orange').attr('class'); * //=> orange * ``` * * @example <caption>Function</caption> * * ```js * $('li') * .filter(function (i, el) { * // this === el * return $(this).attr('class') === 'orange'; * }) * .attr('class'); //=> orange * ``` * * @param match - Value to look for, following the rules above. See * {@link AcceptedFilters}. * @returns The filtered collection. * @see {@link https://api.jquery.com/filter/} */ export function filter<T, S extends AcceptedFilters<T>>( this: Cheerio<T>, match: S, ): Cheerio<S extends string ? Element : T>; export function filter<T>( this: Cheerio<T>, match: AcceptedFilters<T>, ): Cheerio<unknown> { return this._make<unknown>( filterArray(this.toArray(), match, this.options.xmlMode, this._root?.[0]), ); } export function filterArray<T>( nodes: T[], match: AcceptedFilters<T>, xmlMode?: boolean, root?: Document, ): Element[] | T[] { return typeof match === 'string' ? select.filter(match, nodes as unknown as AnyNode[], { xmlMode, root }) : nodes.filter(getFilterFn<T>(match)); } /** * 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. * * @category Traversing * @param selector - Selector for the selection. * @returns Whether or not the selector matches an element of the instance. * @see {@link https://api.jquery.com/is/} */ export function is<T>( this: Cheerio<T>, selector?: AcceptedFilters<T>, ): boolean { const nodes = this.toArray(); return typeof selector === 'string' ? select.some( (nodes as unknown as AnyNode[]).filter(isTag), selector, this.options, ) : selector ? nodes.some(getFilterFn<T>(selector)) : false; } /** * 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. * * @category Traversing * @example <caption>Selector</caption> * * ```js * $('li').not('.apple').length; * //=> 2 * ``` * * @example <caption>Function</caption> * * ```js * $('li').not(function (i, el) { * // this === el * return $(this).attr('class') === 'orange'; * }).length; //=> 2 * ``` * * @param match - Value to look for, following the rules above. * @returns The filtered collection. * @see {@link https://api.jquery.com/not/} */ export function not<T extends AnyNode>( this: Cheerio<T>, match: AcceptedFilters<T>, ): Cheerio<T> { let nodes = this.toArray(); if (typeof match === 'string') { const matches = new Set<AnyNode>(select.filter(match, nodes, this.options)); nodes = nodes.filter((el) => !matches.has(el)); } else { const filterFn = getFilterFn(match); nodes = nodes.filter((el, i) => !filterFn(el, i)); } return this._make(nodes); } /** * 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)')`. * * @category Traversing * @example <caption>Selector</caption> * * ```js * $('ul').has('.pear').attr('id'); * //=> fruits * ``` * * @example <caption>Element</caption> * * ```js * $('ul').has($('.pear')[0]).attr('id'); * //=> fruits * ``` * * @param selectorOrHaystack - Element to look for. * @returns The filtered collection. * @see {@link https://api.jquery.com/has/} */ export function has( this: Cheerio<AnyNode | Element>, selectorOrHaystack: string | Cheerio<Element> | Element, ): Cheerio<AnyNode | Element> { return this.filter( typeof selectorOrHaystack === 'string' ? // Using the `:has` selector here short-circuits searches. `:has(${selectorOrHaystack})` : (_, el) => this._make(el).find(selectorOrHaystack).length > 0, ); } /** * Will select the first element of a cheerio object. * * @category Traversing * @example * * ```js * $('#fruits').children().first().text(); * //=> Apple * ``` * * @returns The first element. * @see {@link https://api.jquery.com/first/} */ export function first<T extends AnyNode>(this: Cheerio<T>): Cheerio<T> { return this.length > 1 ? this._make(this[0]) : this; } /** * Will select the last element of a cheerio object. * * @category Traversing * @example * * ```js * $('#fruits').children().last().text(); * //=> Pear * ``` * * @returns The last element. * @see {@link https://api.jquery.com/last/} */ export function last<T>(this: Cheerio<T>): Cheerio<T> { return this.length > 0 ? this._make(this[this.length - 1]) : this; } /** * Reduce the set of matched elements to the one at the specified index. Use * `.eq(-i)` to count backwards from the last selected element. * * @category Traversing * @example * * ```js * $('li').eq(0).text(); * //=> Apple * * $('li').eq(-1).text(); * //=> Pear * ``` * * @param i - Index of the element to select. * @returns The element at the `i`th position. * @see {@link https://api.jquery.com/eq/} */ export function eq<T>(this: Cheerio<T>, i: number): Cheerio<T> { i = +i; // Use the first identity optimization if possible if (i === 0 && this.length <= 1) return this; if (i < 0) i = this.length + i; return this._make(this[i] ?? []); } /** * Retrieve one of the elements matched by the Cheerio object, at the `i`th * position. * * @category Traversing * @example * * ```js * $('li').get(0).tagName; * //=> li * ``` * * @param i - Element to retrieve. * @returns The element at the `i`th position. * @see {@link https://api.jquery.com/get/} */ export function get<T>(this: Cheerio<T>, i: number): T | undefined; /** * Retrieve all elements matched by the Cheerio object, as an array. * * @category Traversing * @example * * ```js * $('li').get().length; * //=> 3 * ``` * * @returns All elements matched by the Cheerio object. * @see {@link https://api.jquery.com/get/} */ export function get<T>(this: Cheerio<T>): T[]; export function get<T>(this: Cheerio<T>, i?: number): T | T[] { if (i == null) { return this.toArray(); } return this[i < 0 ? this.length + i : i]; } /** * Retrieve all the DOM elements contained in the jQuery set as an array. * * @example * * ```js * $('li').toArray(); * //=> [ {...}, {...}, {...} ] * ``` * * @returns The contained items. */ export function toArray<T>(this: Cheerio<T>): T[] { return (Array.prototype as T[]).slice.call(this); } /** * Search for a given element from among the matched elements. * * @category Traversing * @example * * ```js * $('.pear').index(); * //=> 2 $('.orange').index('li'); * //=> 1 * $('.apple').index($('#fruit, li')); * //=> 1 * ``` * * @param selectorOrNeedle - Element to look for. * @returns The index of the element. * @see {@link https://api.jquery.com/index/} */ export function index<T extends AnyNode>( this: Cheerio<T>, selectorOrNeedle?: string | Cheerio<AnyNode> | AnyNode, ): number { let $haystack: Cheerio<AnyNode>; let needle: AnyNode; if (selectorOrNeedle == null) { $haystack = this.parent().children(); needle = this[0]; } else if (typeof selectorOrNeedle === 'string') { $haystack = this._make<AnyNode>(selectorOrNeedle); needle = this[0]; } else { // eslint-disable-next-line @typescript-eslint/no-this-alias, unicorn/no-this-assignment $haystack = this; needle = isCheerio(selectorOrNeedle) ? selectorOrNeedle[0] : selectorOrNeedle; } return Array.prototype.indexOf.call($haystack, needle); } /** * Gets the elements matching the specified range (0-based position). * * @category Traversing * @example * * ```js * $('li').slice(1).eq(0).text(); * //=> 'Orange' * * $('li').slice(1, 2).length; * //=> 1 * ``` * * @param start - A position at which the elements begin to be selected. If * negative, it indicates an offset from the end of the set. * @param end - 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 The elements matching the specified range. * @see {@link https://api.jquery.com/slice/} */ export function slice<T>( this: Cheerio<T>, start?: number, end?: number, ): Cheerio<T> { return this._make<T>(Array.prototype.slice.call(this, start, end)); } /** * End the most recent filtering operation in the current chain and return the * set of matched elements to its previous state. * * @category Traversing * @example * * ```js * $('li').eq(0).end().length; * //=> 3 * ``` * * @returns The previous state of the set of matched elements. * @see {@link https://api.jquery.com/end/} */ export function end<T>(this: Cheerio<T>): Cheerio<AnyNode> { return (this.prevObject as Cheerio<AnyNode> | null) ?? this._make([]); } /** * Add elements to the set of matched elements. * * @category Traversing * @example * * ```js * $('.apple').add('.orange').length; * //=> 2 * ``` * * @param other - Elements to add. * @param context - Optionally the context of the new selection. * @returns The combined set. * @see {@link https://api.jquery.com/add/} */ export function add<S extends AnyNode, T extends AnyNode>( this: Cheerio<T>, other: string | Cheerio<S> | S | S[], context?: Cheerio<S> | string, ): Cheerio<S | T> { const selection = this._make(other, context); const contents = uniqueSort([...this.get(), ...selection.get()]); return this._make(contents); } /** * Add the previous set of elements on the stack to the current set, optionally * filtered by a selector. * * @category Traversing * @example * * ```js * $('li').eq(0).addBack('.orange').length; * //=> 2 * ``` * * @param selector - Selector for the elements to add. * @returns The combined set. * @see {@link https://api.jquery.com/addBack/} */ export function addBack<T extends AnyNode>( this: Cheerio<T>, selector?: string, ): Cheerio<AnyNode> { return this.prevObject ? this.add<AnyNode, T>( selector ? this.prevObject.filter(selector) : this.prevObject, ) : this; } /** * This file includes tests for deprecated APIs. The methods are expected to be * removed in the next major release of Cheerio, but their stability should be * maintained until that time. */ import { describe, it, expect, beforeEach } from 'vitest'; import { cheerio, food, fruits } from '../__fixtures__/fixtures.js'; describe('deprecated APIs', () => { describe('cheerio module', () => { describe('.parseHTML', () => { it('(html) : should preserve content', () => { const html = '<div>test div</div>'; expect(cheerio(cheerio.parseHTML(html)[0]).html()).toBe('test div'); }); }); describe('.merge', () => { it('should be a function', () => { expect(typeof cheerio.merge).toBe('function'); }); // #1674 - merge, wont accept Cheerio object it('should be a able merge array and cheerio object', () => { const ret = cheerio.merge<unknown>(cheerio(), ['elem1', 'elem2']); expect(typeof ret).toBe('object'); expect(ret).toHaveLength(2); }); it('(arraylike, arraylike) : should modify the first array, but not the second', () => { const arr1 = [1, 2, 3]; const arr2 = [4, 5, 6]; const ret = cheerio.merge(arr1, arr2); expect(typeof ret).toBe('object'); expect(Array.isArray(ret)).toBe(true); expect(ret).toBe(arr1); expect(arr1).toHaveLength(6); expect(arr2).toHaveLength(3); }); it('(arraylike, arraylike) : should handle objects that arent arrays, but are arraylike', () => { const arr1: ArrayLike<string> = { length: 3, 0: 'a', 1: 'b', 2: 'c', }; const arr2 = { length: 3, 0: 'd', 1: 'e', 2: 'f', }; cheerio.merge(arr1, arr2); expect(arr1).toHaveLength(6); expect(arr1[3]).toBe('d'); expect(arr1[4]).toBe('e'); expect(arr1[5]).toBe('f'); expect(arr2).toHaveLength(3); }); it('(?, ?) : should gracefully reject invalid inputs', () => { expect(cheerio.merge([4], 3 as never)).toBeUndefined(); expect(cheerio.merge({} as never, {} as never)).toBeUndefined(); expect(cheerio.merge([], {} as never)).toBeUndefined(); expect(cheerio.merge({} as never, [])).toBeUndefined(); const fakeArray = { length: 3, 0: 'a', 1: 'b', 3: 'd' }; expect(cheerio.merge(fakeArray, [])).toBeUndefined(); expect(cheerio.merge([], fakeArray)).toBeUndefined(); expect(cheerio.merge({ length: '7' } as never, [])).toBeUndefined(); expect(cheerio.merge({ length: -1 }, [])).toBeUndefined(); }); it('(?, ?) : should no-op on invalid inputs', () => { const fakeArray1 = { length: 3, 0: 'a', 1: 'b', 3: 'd' }; cheerio.merge(fakeArray1, []); expect(fakeArray1).toHaveLength(3); expect(fakeArray1[0]).toBe('a'); expect(fakeArray1[1]).toBe('b'); expect(fakeArray1[3]).toBe('d'); cheerio.merge([], fakeArray1); expect(fakeArray1).toHaveLength(3); expect(fakeArray1[0]).toBe('a'); expect(fakeArray1[1]).toBe('b'); expect(fakeArray1[3]).toBe('d'); }); }); describe('.contains', () => { let $: typeof cheerio; beforeEach(() => { $ = cheerio.load(food); }); it('(container, contained) : should correctly detect the provided element', () => { const $food = $('#food'); const $fruits = $('#fruits'); const $apple = $('.apple'); expect(cheerio.contains($food[0], $fruits[0])).toBe(true); expect(cheerio.contains($food[0], $apple[0])).toBe(true); }); it('(container, other) : should not detect elements that are not contained', () => { const $fruits = $('#fruits'); const $vegetables = $('#vegetables'); const $apple = $('.apple'); expect(cheerio.contains($vegetables[0], $apple[0])).toBe(false); expect(cheerio.contains($fruits[0], $vegetables[0])).toBe(false); expect(cheerio.contains($vegetables[0], $fruits[0])).toBe(false); expect(cheerio.contains($fruits[0], $fruits[0])).toBe(false); expect(cheerio.contains($vegetables[0], $vegetables[0])).toBe(false); }); }); describe('.root', () => { it('returns an empty selection', () => { const $empty = cheerio.root(); expect($empty).toHaveLength(1); expect($empty[0].children).toHaveLength(0); }); }); }); describe('Cheerio function', () => { it('.load', () => { const $1 = cheerio.load(fruits); const $2 = $1.load('<div><p>Some <a>text</a>.</p></div>'); expect($2('a')).toHaveLength(1); }); /** * The `.html` static method defined on the "loaded" Cheerio factory * function is deprecated. * * In order to promote consistency with the jQuery library, users are * encouraged to instead use the instance method of the same name. * * @example * * ```js * const $ = cheerio.load('<h1>Hello, <span>world</span>.</h1>'); * * $('h1').html(); * //=> 'Hello, <span>world</span>.' * ``` * * @example <caption>To render the markup of an entire document, invoke the * `html` function exported by the Cheerio module with a "root" * selection.</caption> * * ```js * cheerio.html($.root()); * //=> '<html><head></head><body><h1>Hello, <span>world</span>.</h1></body></html>' * ``` */ describe('.html - deprecated API', () => { it('() : of empty cheerio object should return null', () => { /* * Note: the direct invocation of the Cheerio constructor function is * also deprecated. */ const $ = cheerio(); expect($.html()).toBe(null); }); it('(selector) : should return the outerHTML of the selected element', () => { const $ = cheerio.load(fruits); expect($.html('.pear')).toBe('<li class="pear">Pear</li>'); }); }); /** * The `.xml` static method defined on the "loaded" Cheerio factory function * is deprecated. Users are encouraged to instead use the `xml` function * exported by the Cheerio module. * * @example * * ```js * cheerio.xml($.root()); * ``` */ describe('.xml - deprecated API', () => { it('() : renders XML', () => { const $ = cheerio.load('<foo></foo>', { xmlMode: true }); expect($.xml()).toBe('<foo/>'); }); }); /** * The `.text` static method defined on the "loaded" Cheerio factory * function is deprecated. * * In order to promote consistency with the jQuery library, users are * encouraged to instead use the instance method of the same name. * * @example * * ```js * const $ = cheerio.load('<h1>Hello, <span>world</span>.</h1>'); * $('h1').text(); * //=> 'Hello, world.' * ``` * * @example <caption>To render the text content of an entire document, * invoke the `text` function exported by the Cheerio module with a "root" * selection. </caption> * * ```js * cheerio.text($.root()); * //=> 'Hello, world.' * ``` */ describe('.text - deprecated API', () => { it('(cheerio object) : should return the text contents of the specified elements', () => { const $ = cheerio.load('<a>This is <em>content</em>.</a>'); expect($.text($('a'))).toBe('This is content.'); }); it('(cheerio object) : should omit comment nodes', () => { const $ = cheerio.load( '<a>This is  not a comment.</a>', ); expect($.text($('a'))).toBe('This is not a comment.'); }); it('(cheerio object) : should include text contents of children recursively', () => { const $ = cheerio.load( '<a>This is <div>a child with <span>another child and  not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>', ); expect($.text($('a'))).toBe( 'This is a child with another child and not a comment followed by one last child and some final text.', ); }); it('() : should return the rendered text content of the root', () => { const $ = cheerio.load( '<a>This is <div>a child with <span>another child and  not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>', ); expect($.text()).toBe( 'This is a child with another child and not a comment followed by one last child and some final text.', ); }); it('(cheerio object) : should not omit script tags', () => { const $ = cheerio.load('<script>console.log("test")</script>'); expect($.text()).toBe('console.log("test")'); }); it('(cheerio object) : should omit style tags', () => { const $ = cheerio.load( '<style type="text/css">.cf-hidden { display: none; }</style>', ); expect($.text()).toBe('.cf-hidden { display: none; }'); }); }); }); }); import { describe, it, expect } from 'vitest'; import { load } from '../index.js'; import type { CheerioOptions } from '../options.js'; function xml(str: string, options?: CheerioOptions) { options = { xml: true, ...options }; const $ = load(str, options); return $.xml(); } function dom(str: string, options?: CheerioOptions) { const $ = load('', options); return $(str).html(); } describe('render', () => { describe('(xml)', () => { it('should render <media:thumbnail /> tags correctly', () => { const str = '<media:thumbnail url="http://www.foo.com/keyframe.jpg" width="75" height="50" time="12:05:01.123" />'; expect(xml(str)).toBe( '<media:thumbnail url="http://www.foo.com/keyframe.jpg" width="75" height="50" time="12:05:01.123"/>', ); }); it('should render <link /> tags (RSS) correctly', () => { const str = '<link>http://www.github.com/</link>'; expect(xml(str)).toBe('<link>http://www.github.com/</link>'); }); it('should escape entities', () => { const str = '<tag attr="foo & bar"/>'; expect(xml(str)).toBe(str); }); it('should render HTML as XML', () => { const $ = load('<foo></foo>', null, false); expect($.xml()).toBe('<foo/>'); }); }); describe('(dom)', () => { it('should not keep camelCase for new nodes', () => { const str = '<g><someElem someAttribute="something">hello</someElem></g>'; expect(dom(str, { xml: false })).toBe( '<someelem someattribute="something">hello</someelem>', ); }); it('should keep camelCase for new nodes', () => { const str = '<g><someElem someAttribute="something">hello</someElem></g>'; expect(dom(str, { xml: true })).toBe( '<someElem someAttribute="something">hello</someElem>', ); }); it('should maintain the parsing options of distinct contexts independently', () => { const str = '<g><someElem someAttribute="something">hello</someElem></g>'; const $ = load('', { xml: false }); expect($(str).html()).toBe( '<someelem someattribute="something">hello</someelem>', ); }); }); }); import type { CheerioAPI } from '../load.js'; import { load } from '../load-parse.js'; /** A Cheerio instance with no content. */ export const cheerio: CheerioAPI = load([]); export const fruits: string = [ '<ul id="fruits">', '<li class="apple">Apple</li>', '<li class="orange">Orange</li>', '<li class="pear">Pear</li>', '</ul>', ].join(''); export const vegetables: string = [ '<ul id="vegetables">', '<li class="carrot">Carrot</li>', '<li class="sweetcorn">Sweetcorn</li>', '</ul>', ].join(''); export const divcontainers: string = [ '<div class="container">', '<div class="inner">First</div>', '<div class="inner">Second</div>', '</div>', '<div class="container">', '<div class="inner">Third</div>', '<div class="inner">Fourth</div>', '</div>', '<div id="new"><div>', '<div>\n\n<p><em><b></b></em></p>\n\n</div>', '</div>', ].join(''); export const chocolates: string = [ '<ul id="chocolates">', '<li class="linth" data-highlight="Lindor" data-origin="swiss">Linth</li>', '<li class="frey" data-taste="sweet" data-best-collection="Mahony">Frey</li>', '<li class="cailler">Cailler</li>', '</ul>', ].join(''); export const drinks: string = [ '<ul id="drinks">', '<li class="beer">Beer</li>', '<li class="juice">Juice</li>', '<li class="milk">Milk</li>', '<li class="water">Water</li>', '<li class="cider">Cider</li>', '</ul>', ].join(''); export const food: string = [ '<ul id="food">', fruits, vegetables, '</ul>', ].join(''); export const eleven = ` <html> <body> <ul> <li>One</li> <li>Two</li> <li class="blue sel">Three</li> <li class="red">Four</li> </ul> <ul> <li class="red">Five</li> <li>Six</li> <li class="blue">Seven</li> </ul> <ul> <li>Eight</li> <li class="red sel">Nine</li> <li>Ten</li> <li class="sel">Eleven</li> </ul> </body> </html> `; export const unwrapspans: string = [ '<div id=unwrap style="display: none;">', '<div id=unwrap1><span class=unwrap>a</span><span class=unwrap>b</span></div>', '<div id=unwrap2><span class=unwrap>c</span><span class=unwrap>d</span></div>', '<div id=unwrap3><b><span class="unwrap unwrap3">e</span></b><b><span class="unwrap unwrap3">f</span></b></div>', '</div>', ].join(''); export const inputs: string = [ '<select id="one"><option value="option_not_selected">Option not selected</option><option value="option_selected" selected>Option selected</option></select>', '<select id="one-valueless"><option>Option not selected</option><option selected>Option selected</option></select>', '<select id="one-html-entity"><option>Option not selected</option><option selected>Option <selected></option></select>', '<select id="one-nested"><option>Option not selected</option><option selected>Option <span>selected</span></option></select>', '<input type="text" value="input_text" />', '<input type="checkbox" name="checkbox_off" value="off" /><input type="checkbox" name="checkbox_on" value="on" checked />', '<input type="checkbox" name="checkbox_valueless" />', '<input type="radio" value="off" name="radio" /><input type="radio" name="radio" value="on" checked />', '<input type="radio" value="off" name="radio[brackets]" /><input type="radio" name="radio[brackets]" value="on" checked />', '<input type="radio" name="radio_valueless" />', '<select id="multi" multiple><option value="1">1</option><option value="2" selected>2</option><option value="3" selected>3</option><option value="4">4</option></select>', '<select id="multi-valueless" multiple><option>1</option><option selected>2</option><option selected>3</option><option>4</option></select>', ].join(''); export const text: string = [ '<p>Apples, <b>oranges</b> and pears.</p>', '<p>Carrots and </p>', ].join(''); export const forms: string = [ '<form id="simple"><input type="text" name="fruit" value="Apple" /></form>', '<form id="nested"><div><input type="text" name="fruit" value="Apple" /></div><input type="text" name="vegetable" value="Carrot" /></form>', '<form id="disabled"><input type="text" name="fruit" value="Apple" disabled /></form>', '<form id="submit"><input type="text" name="fruit" value="Apple" /><input type="submit" name="submit" value="Submit" /></form>', '<form id="select"><select name="fruit"><option value="Apple">Apple</option><option value="Orange" selected>Orange</option></select></form>', '<form id="unnamed"><input type="text" name="fruit" value="Apple" /><input type="text" value="Carrot" /></form>', '<form id="multiple"><select name="fruit" multiple><option value="Apple" selected>Apple</option><option value="Orange" selected>Orange</option><option value="Carrot">Carrot</option></select></form>', '<form id="textarea"><textarea name="fruits">Apple\nOrange', '
', ].join(''); export const noscript: string = [ '', '', '
Rocks!
', '', ].join(''); export const script: string = [ '
', 'A', '', 'B', '
', ].join(''); export const mixedText = '1TEXT2'; {"version":3,"file":"cheerio.d.ts","sourceRoot":"","sources":["../../src/cheerio.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD,OAAO,KAAK,UAAU,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,UAAU,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,YAAY,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,GAAG,MAAM,cAAc,CAAC;AACpC,OAAO,KAAK,KAAK,MAAM,gBAAgB,CAAC;AACxC,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAE5C,KAAK,WAAW,GAAG,OAAO,UAAU,GAClC,OAAO,UAAU,GACjB,OAAO,YAAY,GACnB,OAAO,GAAG,GACV,OAAO,KAAK,GACZ,OAAO,OAAO,CAAC;AAEjB;;;;;;;;;;;;;;;;;;GAkBG;AACH,8BAAsB,OAAO,CAAC,CAAC,CAAE,YAAW,SAAS,CAAC,CAAC,CAAC;IACtD,MAAM,SAAK;IACX,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC;IAEnB,OAAO,EAAE,eAAe,CAAC;IACzB;;;;;OAKG;IACH,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;IAEhC;;;;;;;;OAQG;gBAED,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,EAClC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,IAAI,EAC9B,OAAO,EAAE,eAAe;IAa1B,UAAU,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IACrC;;;;;;;OAOG;IACH,QAAQ,CAAC,KAAK,CAAC,CAAC,EACd,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,MAAM,EAC9B,OAAO,CAAC,EAAE,kBAAkB,CAAC,OAAO,CAAC,GACpC,OAAO,CAAC,CAAC,CAAC;IAEb;;;;;;;;OAQG;IACH,QAAQ,CAAC,MAAM,CACb,OAAO,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,EAAE,GAAG,MAAM,EACzD,OAAO,EAAE,eAAe,EACxB,UAAU,EAAE,OAAO,EACnB,OAAO,EAAE,UAAU,GAAG,IAAI,GACzB,QAAQ;IAEX;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC,GAAG,MAAM;CAC5D;AAED,MAAM,WAAW,OAAO,CAAC,CAAC,CAAE,SAAQ,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC1D,OAAO,EAAE,kBAAkB,CAAC;IAE5B,MAAM,EAAE,OAAO,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC;CACvC"}import * as Attributes from './api/attributes.js'; import * as Traversing from './api/traversing.js'; import * as Manipulation from './api/manipulation.js'; import * as Css from './api/css.js'; import * as Forms from './api/forms.js'; import * as Extract from './api/extract.js'; /** * 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: * * ```html *
*
Apple
*
Orange
*
Pear
*
* ``` */ export class Cheerio { /** * Instance of cheerio. Methods are specified in the modules. Usage of this * constructor is not recommended. Please use `$.load` instead. * * @private * @param elements - The new selection. * @param root - Sets the root node. * @param options - Options for the instance. */ constructor(elements, root, options) { this.length = 0; this.options = options; this._root = root; if (elements) { for (let idx = 0; idx < elements.length; idx++) { this[idx] = elements[idx]; } this.length = elements.length; } } } /** Set a signature of the object. */ Cheerio.prototype.cheerio = '[cheerio object]'; /* * Make cheerio an array-like object */ Cheerio.prototype.splice = Array.prototype.splice; // Support for (const element of $(...)) iteration: Cheerio.prototype[Symbol.iterator] = Array.prototype[Symbol.iterator]; // Plug in the API Object.assign(Cheerio.prototype, Attributes, Traversing, Manipulation, Css, Forms, Extract); //# sourceMappingURL=cheerio.js.map{"version":3,"file":"cheerio.js","sourceRoot":"","sources":["../../src/cheerio.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,UAAU,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,UAAU,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,YAAY,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,GAAG,MAAM,cAAc,CAAC;AACpC,OAAO,KAAK,KAAK,MAAM,gBAAgB,CAAC;AACxC,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAS5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,OAAgB,OAAO;IAa3B;;;;;;;;OAQG;IACH,YACE,QAAkC,EAClC,IAA8B,EAC9B,OAAwB;QAxB1B,WAAM,GAAG,CAAC,CAAC;QA0BT,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAElB,IAAI,QAAQ,EAAE,CAAC;YACb,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,QAAQ,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC;gBAC/C,IAAI,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;YAC5B,CAAC;YACD,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;QAChC,CAAC;IACH,CAAC;CAwCF;AAQD,qCAAqC;AACrC,OAAO,CAAC,SAAS,CAAC,OAAO,GAAG,kBAAkB,CAAC;AAE/C;;GAEG;AACH,OAAO,CAAC,SAAS,CAAC,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC;AAElD,mDAAmD;AACnD,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AAEtE,kBAAkB;AAClB,MAAM,CAAC,MAAM,CACX,OAAO,CAAC,SAAS,EACjB,UAAU,EACV,UAAU,EACV,YAAY,EACZ,GAAG,EACH,KAAK,EACL,OAAO,CACR,CAAC"}{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAC9C,mBAAmB,YAAY,CAAC;AAChC,YAAY,EACV,OAAO,EACP,UAAU,EACV,cAAc,EACd,kBAAkB,GACnB,MAAM,WAAW,CAAC;AAKnB,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC,OAAO,EAAE,QAAQ,EAAY,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAGtB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,mBAAwB,GAChC,UAAU,CAQZ;AA2CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,cAAc,EACvB,EAAE,EAAE,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,EAAE,CAAC,EAAE,UAAU,KAAK,IAAI,GACzD,QAAQ,CAEV;AAED,MAAM,WAAW,mBAAoB,SAAQ,cAAc;IACzD,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,mBAAmB,EAC5B,EAAE,EAAE,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,EAAE,CAAC,EAAE,UAAU,KAAK,IAAI,GACzD,QAAQ,CAaV;AAED,KAAK,mBAAmB,GAAG,IAAI,CAC7B,MAAM,CAAC,UAAU,CAAC,cAAc,CAAC,OAAO,CAAC,EACzC,MAAM,CACP,CAAC;AAEF,MAAM,WAAW,qBAAsB,SAAQ,mBAAmB;IAChE,wDAAwD;IACxD,cAAc,CAAC,EAAE,mBAAmB,CAAC;CACtC;AAUD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,MAAM,GAAG,GAAG,EACjB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,UAAU,CAAC,CA4ErB"}/** * @file Batteries-included version of Cheerio. This module includes several * convenience methods for loading documents from various sources. */ export * from './load-parse.js'; export { contains, merge } from './static.js'; import { adapter as htmlparser2Adapter } from 'parse5-htmlparser2-tree-adapter'; import * as htmlparser2 from 'htmlparser2'; import { ParserStream as Parse5Stream } from 'parse5-parser-stream'; import { decodeBuffer, DecodeStream, } from 'encoding-sniffer'; import * as undici from 'undici'; import MIMEType from 'whatwg-mimetype'; import { Writable, finished } from 'node:stream'; import { flattenOptions, } from './options.js'; import { load } from './load-parse.js'; /** * Sniffs the encoding of a buffer, then creates a querying function bound to a * document created from the buffer. * * @category Loading * @example * * ```js * import * as cheerio from 'cheerio'; * * const buffer = fs.readFileSync('index.html'); * const $ = cheerio.loadBuffer(buffer); * ``` * * @param buffer - The buffer to sniff the encoding of. * @param options - The options to pass to Cheerio. * @returns The loaded document. */ export function loadBuffer(buffer, options = {}) { const opts = flattenOptions(options); const str = decodeBuffer(buffer, { defaultEncoding: (opts === null || opts === void 0 ? void 0 : opts.xmlMode) ? 'utf8' : 'windows-1252', ...options.encoding, }); return load(str, opts); } function _stringStream(options, cb) { var _a; if (options === null || options === void 0 ? void 0 : options._useHtmlParser2) { const parser = htmlparser2.createDocumentStream((err, document) => cb(err, load(document)), options); return new Writable({ decodeStrings: false, write(chunk, _encoding, callback) { if (typeof chunk !== 'string') { throw new TypeError('Expected a string'); } parser.write(chunk); callback(); }, final(callback) { parser.end(); callback(); }, }); } options !== null && options !== void 0 ? options : (options = {}); (_a = options.treeAdapter) !== null && _a !== void 0 ? _a : (options.treeAdapter = htmlparser2Adapter); if (options.scriptingEnabled !== false) { options.scriptingEnabled = true; } const stream = new Parse5Stream(options); finished(stream, (err) => cb(err, load(stream.document))); return stream; } /** * Creates a stream that parses a sequence of strings into a document. * * The stream is a `Writable` stream that accepts strings. When the stream is * finished, the callback is called with the loaded document. * * @category Loading * @example * * ```js * import * as cheerio from 'cheerio'; * import * as fs from 'fs'; * * const writeStream = cheerio.stringStream({}, (err, $) => { * if (err) { * // Handle error * } * * console.log($('h1').text()); * // Output: Hello, world! * }); * * fs.createReadStream('my-document.html', { encoding: 'utf8' }).pipe( * writeStream, * ); * ``` * * @param options - The options to pass to Cheerio. * @param cb - The callback to call when the stream is finished. * @returns The writable stream. */ export function stringStream(options, cb) { return _stringStream(flattenOptions(options), cb); } /** * Parses a stream of buffers into a document. * * The stream is a `Writable` stream that accepts buffers. When the stream is * finished, the callback is called with the loaded document. * * @category Loading * @param options - The options to pass to Cheerio. * @param cb - The callback to call when the stream is finished. * @returns The writable stream. */ export function decodeStream(options, cb) { var _a; const { encoding = {}, ...cheerioOptions } = options; const opts = flattenOptions(cheerioOptions); // Set the default encoding to UTF-8 for XML mode (_a = encoding.defaultEncoding) !== null && _a !== void 0 ? _a : (encoding.defaultEncoding = (opts === null || opts === void 0 ? void 0 : opts.xmlMode) ? 'utf8' : 'windows-1252'); const decodeStream = new DecodeStream(encoding); const loadStream = _stringStream(opts, cb); decodeStream.pipe(loadStream); return decodeStream; } const defaultRequestOptions = { method: 'GET', // Set an Accept header headers: { accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', }, }; /** * `fromURL` loads a document from a URL. * * By default, redirects are allowed and non-2xx responses are rejected. * * @category Loading * @example * * ```js * import * as cheerio from 'cheerio'; * * const $ = await cheerio.fromURL('https://example.com'); * ``` * * @param url - The URL to load the document from. * @param options - The options to pass to Cheerio. * @returns The loaded document. */ export async function fromURL(url, options = {}) { const { requestOptions = defaultRequestOptions, encoding = {}, ...cheerioOptions } = options; let undiciStream; // Add headers if none were supplied. const urlObject = typeof url === 'string' ? new URL(url) : url; const streamOptions = { headers: defaultRequestOptions.headers, path: urlObject.pathname + urlObject.search, ...requestOptions, }; const promise = new Promise((resolve, reject) => { undiciStream = new undici.Client(url) .compose(undici.interceptors.redirect({ maxRedirections: 5 })) .stream(streamOptions, (res) => { var _a, _b; if (res.statusCode < 200 || res.statusCode >= 300) { throw new undici.errors.ResponseError('Response Error', res.statusCode, { headers: res.headers, }); } const contentTypeHeader = (_a = res.headers['content-type']) !== null && _a !== void 0 ? _a : 'text/html'; const mimeType = new MIMEType(Array.isArray(contentTypeHeader) ? contentTypeHeader[0] : contentTypeHeader); if (!mimeType.isHTML() && !mimeType.isXML()) { throw new RangeError(`The content-type "${mimeType.essence}" is neither HTML nor XML.`); } // Forward the charset from the header to the decodeStream. encoding.transportLayerEncodingLabel = mimeType.parameters.get('charset'); /* * If we allow redirects, we will have entries in the history. * The last entry will be the final URL. */ const history = (_b = res.context) === null || _b === void 0 ? void 0 : _b.history; const opts = { encoding, // Set XML mode based on the MIME type. xmlMode: mimeType.isXML(), // Set the `baseURL` to the final URL. baseURL: history ? history[history.length - 1] : url, ...cheerioOptions, }; return decodeStream(opts, (err, $) => (err ? reject(err) : resolve($))); }); }); // Let's make sure the request is completed before returning the promise. await undiciStream; return promise; } //# sourceMappingURL=index.js.map{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAS9C,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,KAAK,WAAW,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,YAAY,IAAI,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,EACL,YAAY,EACZ,YAAY,GAEb,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AACjC,OAAO,QAAQ,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEjD,OAAO,EACL,cAAc,GAGf,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,UAAU,CACxB,MAAc,EACd,UAA+B,EAAE;IAEjC,MAAM,IAAI,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC;IACrC,MAAM,GAAG,GAAG,YAAY,CAAC,MAAM,EAAE;QAC/B,eAAe,EAAE,CAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,OAAO,EAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,cAAc;QACxD,GAAG,OAAO,CAAC,QAAQ;KACpB,CAAC,CAAC;IAEH,OAAO,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AACzB,CAAC;AAED,SAAS,aAAa,CACpB,OAAoC,EACpC,EAA0D;;IAE1D,IAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,eAAe,EAAE,CAAC;QAC7B,MAAM,MAAM,GAAG,WAAW,CAAC,oBAAoB,CAC7C,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,EAC1C,OAAO,CACR,CAAC;QAEF,OAAO,IAAI,QAAQ,CAAC;YAClB,aAAa,EAAE,KAAK;YACpB,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ;gBAC9B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;oBAC9B,MAAM,IAAI,SAAS,CAAC,mBAAmB,CAAC,CAAC;gBAC3C,CAAC;gBAED,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBACpB,QAAQ,EAAE,CAAC;YACb,CAAC;YACD,KAAK,CAAC,QAAQ;gBACZ,MAAM,CAAC,GAAG,EAAE,CAAC;gBACb,QAAQ,EAAE,CAAC;YACb,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED,OAAO,aAAP,OAAO,cAAP,OAAO,IAAP,OAAO,GAAK,EAAE,EAAC;IACf,MAAA,OAAO,CAAC,WAAW,oCAAnB,OAAO,CAAC,WAAW,GAAK,kBAAkB,EAAC;IAE3C,IAAI,OAAO,CAAC,gBAAgB,KAAK,KAAK,EAAE,CAAC;QACvC,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAClC,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,OAAO,CAAC,CAAC;IAEzC,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAE1D,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,YAAY,CAC1B,OAAuB,EACvB,EAA0D;IAE1D,OAAO,aAAa,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;AACpD,CAAC;AAMD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAC1B,OAA4B,EAC5B,EAA0D;;IAE1D,MAAM,EAAE,QAAQ,GAAG,EAAE,EAAE,GAAG,cAAc,EAAE,GAAG,OAAO,CAAC;IACrD,MAAM,IAAI,GAAG,cAAc,CAAC,cAAc,CAAC,CAAC;IAE5C,iDAAiD;IACjD,MAAA,QAAQ,CAAC,eAAe,oCAAxB,QAAQ,CAAC,eAAe,GAAK,CAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,OAAO,EAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,cAAc,EAAC;IAErE,MAAM,YAAY,GAAG,IAAI,YAAY,CAAC,QAAQ,CAAC,CAAC;IAChD,MAAM,UAAU,GAAG,aAAa,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IAE3C,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAE9B,OAAO,YAAY,CAAC;AACtB,CAAC;AAYD,MAAM,qBAAqB,GAAwB;IACjD,MAAM,EAAE,KAAK;IACb,uBAAuB;IACvB,OAAO,EAAE;QACP,MAAM,EAAE,iEAAiE;KAC1E;CACF,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,GAAiB,EACjB,UAAiC,EAAE;IAEnC,MAAM,EACJ,cAAc,GAAG,qBAAqB,EACtC,QAAQ,GAAG,EAAE,EACb,GAAG,cAAc,EAClB,GAAG,OAAO,CAAC;IACZ,IAAI,YAAwE,CAAC;IAE7E,qCAAqC;IACrC,MAAM,SAAS,GAAG,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;IAC/D,MAAM,aAAa,GAAG;QACpB,OAAO,EAAE,qBAAqB,CAAC,OAAO;QACtC,IAAI,EAAE,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,MAAM;QAC3C,GAAG,cAAc;KAClB,CAAC;IAEF,MAAM,OAAO,GAAG,IAAI,OAAO,CAAa,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAC1D,YAAY,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC;aAClC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,CAAC,CAAC;aAC7D,MAAM,CAAC,aAAa,EAAE,CAAC,GAAG,EAAE,EAAE;;YAC7B,IAAI,GAAG,CAAC,UAAU,GAAG,GAAG,IAAI,GAAG,CAAC,UAAU,IAAI,GAAG,EAAE,CAAC;gBAClD,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,aAAa,CACnC,gBAAgB,EAChB,GAAG,CAAC,UAAU,EACd;oBACE,OAAO,EAAE,GAAG,CAAC,OAAO;iBACrB,CACF,CAAC;YACJ,CAAC;YAED,MAAM,iBAAiB,GAAG,MAAA,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,mCAAI,WAAW,CAAC;YACrE,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAC3B,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC;gBAC9B,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC;gBACtB,CAAC,CAAC,iBAAiB,CACtB,CAAC;YAEF,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC;gBAC5C,MAAM,IAAI,UAAU,CAClB,qBAAqB,QAAQ,CAAC,OAAO,4BAA4B,CAClE,CAAC;YACJ,CAAC;YAED,2DAA2D;YAC3D,QAAQ,CAAC,2BAA2B;gBAClC,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAErC;;;eAGG;YACH,MAAM,OAAO,GAAG,MACd,GAAG,CAAC,OAKL,0CAAE,OAAO,CAAC;YAEX,MAAM,IAAI,GAAG;gBACX,QAAQ;gBACR,uCAAuC;gBACvC,OAAO,EAAE,QAAQ,CAAC,KAAK,EAAE;gBACzB,sCAAsC;gBACtC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG;gBACpD,GAAG,cAAc;aAClB,CAAC;YAEF,OAAO,YAAY,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1E,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,yEAAyE;IACzE,MAAM,YAAY,CAAC;IAEnB,OAAO,OAAO,CAAC;AACjB,CAAC"}{"version":3,"file":"load-parse.d.ts","sourceRoot":"","sources":["../../src/load-parse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAW,MAAM,WAAW,CAAC;AAGrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAGnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAS1C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,IAAI,EAAE,CACjB,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,EAAE,GAAG,MAAM,EAC9C,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,EAC/B,UAAU,CAAC,EAAE,OAAO,KACjB,UAIJ,CAAC"}import { getLoad } from './load.js'; import { getParse } from './parse.js'; import { renderWithParse5, parseWithParse5 } from './parsers/parse5-adapter.js'; import renderWithHtmlparser2 from 'dom-serializer'; import { parseDocument as parseWithHtmlparser2 } from 'htmlparser2'; const parse = getParse((content, options, isDocument, context) => options._useHtmlParser2 ? parseWithHtmlparser2(content, options) : parseWithParse5(content, options, isDocument, context)); // Duplicate docs due to https://github.com/TypeStrong/typedoc/issues/1616 /** * Create a querying function, bound to a document created from the provided * markup. * * Note that similar to web browser contexts, this operation may introduce * ``, ``, and `` elements; set `isDocument` to `false` to * switch to fragment mode and disable this. * * @category Loading * @param content - Markup to be loaded. * @param options - Options for the created instance. * @param isDocument - Allows parser to be switched to fragment mode. * @returns The loaded document. * @see {@link https://cheerio.js.org/docs/basics/loading#load} for additional usage information. */ export const load = getLoad(parse, (dom, options) => options._useHtmlParser2 ? renderWithHtmlparser2(dom, options) : renderWithParse5(dom)); //# sourceMappingURL=load-parse.js.map{"version":3,"file":"load-parse.js","sourceRoot":"","sources":["../../src/load-parse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,OAAO,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAEhF,OAAO,qBAAqB,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,aAAa,IAAI,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGpE,MAAM,KAAK,GAAG,QAAQ,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE,CAC/D,OAAO,CAAC,eAAe;IACrB,CAAC,CAAC,oBAAoB,CAAC,OAAO,EAAE,OAAO,CAAC;IACxC,CAAC,CAAC,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,CAC3D,CAAC;AAEF,0EAA0E;AAC1E;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,IAAI,GAIC,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,CAChD,OAAO,CAAC,eAAe;IACrB,CAAC,CAAC,qBAAqB,CAAC,GAAG,EAAE,OAAO,CAAC;IACrC,CAAC,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAC1B,CAAC"}{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/load.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,eAAe,EAErB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,aAAa,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAc,MAAM,YAAY,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAGnE,KAAK,UAAU,GAAG,OAAO,aAAa,CAAC;AAEvC;;;;;GAKG;AACH,MAAM,WAAW,UAAW,SAAQ,UAAU;IAC5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,SAAS,MAAM,EAClC,QAAQ,CAAC,EAAE,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,EACpC,OAAO,CAAC,EAAE,kBAAkB,CAAC,OAAO,CAAC,GAAG,IAAI,EAC5C,IAAI,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,EACnC,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,CAAC,SAAS,YAAY,GAAG,OAAO,GAAG,CAAC,CAAC,CAAC;IAEjD;;;;OAIG;IACH,KAAK,EAAE,QAAQ,CAAC;IAEhB;;;;OAIG;IACH,QAAQ,EAAE,eAAe,CAAC;IAE1B,yDAAyD;IACzD,EAAE,EAAE,OAAO,OAAO,CAAC,SAAS,CAAC;IAE7B;;;;;;;;;;;;OAYG;IACH,IAAI,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC;CAClC;AAED,wBAAgB,OAAO,CACrB,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,EACjC,MAAM,EAAE,CACN,GAAG,EAAE,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC,EACjC,OAAO,EAAE,eAAe,KACrB,MAAM,IAiBT,SAAS,MAAM,GAAG,OAAO,GAAG,OAAO,EAAE,GAAG,MAAM,EAC9C,UAAU,cAAc,GAAG,IAAI,EAC/B,oBAAiB,KAChB,UAAU,CAyId"}import { flattenOptions, } from './options.js'; import * as staticMethods from './static.js'; import { Cheerio } from './cheerio.js'; import { isHtml, isCheerio } from './utils.js'; import { ElementType } from 'htmlparser2'; export function getLoad(parse, render) { /** * Create a querying function, bound to a document created from the provided * markup. * * Note that similar to web browser contexts, this operation may introduce * ``, ``, and `` elements; set `isDocument` to `false` to * switch to fragment mode and disable this. * * @param content - Markup to be loaded. * @param options - Options for the created instance. * @param isDocument - Allows parser to be switched to fragment mode. * @returns The loaded document. * @see {@link https://cheerio.js.org/docs/basics/loading#load} for additional usage information. */ return function load(content, options, isDocument = true) { if (content == null) { throw new Error('cheerio.load() expects a string'); } const internalOpts = flattenOptions(options); const initialRoot = parse(content, internalOpts, isDocument, null); /** * Create an extended class here, so that extensions only live on one * instance. */ class LoadedCheerio extends Cheerio { _make(selector, context) { const cheerio = initialize(selector, context); cheerio.prevObject = this; return cheerio; } _parse(content, options, isDocument, context) { return parse(content, options, isDocument, context); } _render(dom) { return render(dom, this.options); } } function initialize(selector, context, root = initialRoot, opts) { // $($) if (selector && isCheerio(selector)) return selector; const options = flattenOptions(opts, internalOpts); const r = typeof root === 'string' ? [parse(root, options, false, null)] : 'length' in root ? root : [root]; const rootInstance = isCheerio(r) ? r : new LoadedCheerio(r, null, options); // Add a cyclic reference, so that calling methods on `_root` never fails. rootInstance._root = rootInstance; // $(), $(null), $(undefined), $(false) if (!selector) { return new LoadedCheerio(undefined, rootInstance, options); } const elements = typeof selector === 'string' && isHtml(selector) ? // $() parse(selector, options, false, null).children : isNode(selector) ? // $(dom) [selector] : Array.isArray(selector) ? // $([dom]) selector : undefined; const instance = new LoadedCheerio(elements, rootInstance, options); if (elements) { return instance; } if (typeof selector !== 'string') { throw new TypeError('Unexpected type of selector'); } // We know that our selector is a string now. let search = selector; const searchContext = context ? // If we don't have a context, maybe we have a root, from loading typeof context === 'string' ? isHtml(context) ? // $('li', '
...
') new LoadedCheerio([parse(context, options, false, null)], rootInstance, options) : // $('li', 'ul') ((search = `${context} ${search}`), rootInstance) : isCheerio(context) ? // $('li', $) context : // $('li', node), $('li', [nodes]) new LoadedCheerio(Array.isArray(context) ? context : [context], rootInstance, options) : rootInstance; // If we still don't have a context, return if (!searchContext) return instance; /* * #id, .class, tag */ return searchContext.find(search); } // Add in static methods & properties Object.assign(initialize, staticMethods, { load, // `_root` and `_options` are used in static methods. _root: initialRoot, _options: internalOpts, // Add `fn` for plugins fn: LoadedCheerio.prototype, // Add the prototype here to maintain `instanceof` behavior. prototype: LoadedCheerio.prototype, }); return initialize; }; } function isNode(obj) { return ( // @ts-expect-error: TS doesn't know about the `name` property. !!obj.name || // @ts-expect-error: TS doesn't know about the `type` property. obj.type === ElementType.Root || // @ts-expect-error: TS doesn't know about the `type` property. obj.type === ElementType.Text || // @ts-expect-error: TS doesn't know about the `type` property. obj.type === ElementType.Comment); } //# sourceMappingURL=load.js.map{"version":3,"file":"load.js","sourceRoot":"","sources":["../../src/load.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,cAAc,GACf,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,aAAa,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAgG1C,MAAM,UAAU,OAAO,CACrB,KAAiC,EACjC,MAGW;IAEX;;;;;;;;;;;;;OAaG;IACH,OAAO,SAAS,IAAI,CAClB,OAA8C,EAC9C,OAA+B,EAC/B,UAAU,GAAG,IAAI;QAEjB,IAAK,OAAyB,IAAI,IAAI,EAAE,CAAC;YACvC,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;QACrD,CAAC;QAED,MAAM,YAAY,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC;QAC7C,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;QAEnE;;;WAGG;QACH,MAAM,aAAiB,SAAQ,OAAU;YACvC,KAAK,CACH,QAAoC,EACpC,OAA4C;gBAE5C,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;gBAC9C,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;gBAE1B,OAAO,OAAO,CAAC;YACjB,CAAC;YAED,MAAM,CACJ,OAAyD,EACzD,OAAwB,EACxB,UAAmB,EACnB,OAA0B;gBAE1B,OAAO,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;YACtD,CAAC;YAED,OAAO,CAAC,GAAiC;gBACvC,OAAO,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;YACnC,CAAC;SACF;QAED,SAAS,UAAU,CACjB,QAA+B,EAC/B,OAA4C,EAC5C,OAAqC,WAAW,EAChD,IAAqB;YAIrB,OAAO;YACP,IAAI,QAAQ,IAAI,SAAS,CAAS,QAAQ,CAAC;gBAAE,OAAO,QAAQ,CAAC;YAE7D,MAAM,OAAO,GAAG,cAAc,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;YACnD,MAAM,CAAC,GACL,OAAO,IAAI,KAAK,QAAQ;gBACtB,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;gBACrC,CAAC,CAAC,QAAQ,IAAI,IAAI;oBAChB,CAAC,CAAC,IAAI;oBACN,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YACf,MAAM,YAAY,GAAG,SAAS,CAAW,CAAC,CAAC;gBACzC,CAAC,CAAC,CAAC;gBACH,CAAC,CAAC,IAAI,aAAa,CAAW,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;YAClD,0EAA0E;YAC1E,YAAY,CAAC,KAAK,GAAG,YAAY,CAAC;YAElC,uCAAuC;YACvC,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,OAAO,IAAI,aAAa,CAAS,SAAS,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;YACrE,CAAC;YAED,MAAM,QAAQ,GACZ,OAAO,QAAQ,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC;gBAC9C,CAAC,CAAC,YAAY;oBACZ,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,QAAQ;gBAChD,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;oBAChB,CAAC,CAAC,SAAS;wBACT,CAAC,QAAQ,CAAC;oBACZ,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;wBACvB,CAAC,CAAC,WAAW;4BACX,QAAQ;wBACV,CAAC,CAAC,SAAS,CAAC;YAEpB,MAAM,QAAQ,GAAG,IAAI,aAAa,CAAC,QAAQ,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;YAEpE,IAAI,QAAQ,EAAE,CAAC;gBACb,OAAO,QAA2B,CAAC;YACrC,CAAC;YAED,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;gBACjC,MAAM,IAAI,SAAS,CAAC,6BAA6B,CAAC,CAAC;YACrD,CAAC;YAED,6CAA6C;YAC7C,IAAI,MAAM,GAAG,QAAQ,CAAC;YAEtB,MAAM,aAAa,GAAiC,OAAO;gBACzD,CAAC,CAAC,iEAAiE;oBACjE,OAAO,OAAO,KAAK,QAAQ;wBAC3B,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;4BACf,CAAC,CAAC,0BAA0B;gCAC1B,IAAI,aAAa,CACf,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,EACtC,YAAY,EACZ,OAAO,CACR;4BACH,CAAC,CAAC,gBAAgB;gCAChB,CAAC,CAAC,MAAM,GAAG,GAAG,OAAO,IAAI,MAAM,EAAO,CAAC,EAAE,YAAY,CAAC;wBAC1D,CAAC,CAAC,SAAS,CAAU,OAAO,CAAC;4BAC3B,CAAC,CAAC,aAAa;gCACb,OAAO;4BACT,CAAC,CAAC,kCAAkC;gCAClC,IAAI,aAAa,CACf,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,EAC5C,YAAY,EACZ,OAAO,CACR;gBACP,CAAC,CAAC,YAAY,CAAC;YAEjB,2CAA2C;YAC3C,IAAI,CAAC,aAAa;gBAAE,OAAO,QAA2B,CAAC;YAEvD;;eAEG;YACH,OAAO,aAAa,CAAC,IAAI,CAAC,MAAM,CAAoB,CAAC;QACvD,CAAC;QAED,qCAAqC;QACrC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,aAAa,EAAE;YACvC,IAAI;YACJ,qDAAqD;YACrD,KAAK,EAAE,WAAW;YAClB,QAAQ,EAAE,YAAY;YACtB,uBAAuB;YACvB,EAAE,EAAE,aAAa,CAAC,SAAS;YAC3B,4DAA4D;YAC5D,SAAS,EAAE,aAAa,CAAC,SAAS;SACnC,CAAC,CAAC;QAEH,OAAO,UAAwB,CAAC;IAClC,CAAC,CAAC;AACJ,CAAC;AAED,SAAS,MAAM,CAAC,GAAY;IAC1B,OAAO;IACL,+DAA+D;IAC/D,CAAC,CAAC,GAAG,CAAC,IAAI;QACV,+DAA+D;QAC/D,GAAG,CAAC,IAAI,KAAK,WAAW,CAAC,IAAI;QAC7B,+DAA+D;QAC/D,GAAG,CAAC,IAAI,KAAK,WAAW,CAAC,IAAI;QAC7B,+DAA+D;QAC/D,GAAG,CAAC,IAAI,KAAK,WAAW,CAAC,OAAO,CACjC,CAAC;AACJ,CAAC"}{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,IAAI,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,KAAK,EAAE,aAAa,IAAI,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AACnE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,KAAK,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D;;;;GAIG;AACH,MAAM,WAAW,kBACf,SAAQ,iBAAiB,EACvB,oBAAoB,EACpB,wBAAwB;IAC1B,0CAA0C;IAC1C,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;GAKG;AACH,MAAM,WAAW,cACf,SAAQ,mBAAmB,CAAC,yBAAyB,CAAC;IACtD;;;;;;OAMG;IACH,GAAG,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC;IAEnC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,iFAAiF;IACjF,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;IAEvB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;IACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;CACpC;AAED,oCAAoC;AACpC,MAAM,WAAW,eACf,SAAQ,kBAAkB,EACxB,IAAI,CAAC,cAAc,EAAE,KAAK,CAAC;IAC7B;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAMD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,EAC/B,WAAW,CAAC,EAAE,eAAe,GAC5B,eAAe,CAuBjB"}const defaultOpts = { _useHtmlParser2: false, }; /** * Flatten the options for Cheerio. * * This will set `_useHtmlParser2` to true if `xml` is set to true. * * @param options - The options to flatten. * @param baseOptions - The base options to use. * @returns The flattened options. */ export function flattenOptions(options, baseOptions) { if (!options) { return baseOptions !== null && baseOptions !== void 0 ? baseOptions : defaultOpts; } const opts = { _useHtmlParser2: !!options.xmlMode, ...baseOptions, ...options, }; if (options.xml) { opts._useHtmlParser2 = true; opts.xmlMode = true; if (options.xml !== true) { Object.assign(opts, options.xml); } } else if (options.xmlMode) { opts._useHtmlParser2 = true; } return opts; } //# sourceMappingURL=options.js.map{"version":3,"file":"options.js","sourceRoot":"","sources":["../../src/options.ts"],"names":[],"mappings":"AAoGA,MAAM,WAAW,GAAoB;IACnC,eAAe,EAAE,KAAK;CACvB,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAC5B,OAA+B,EAC/B,WAA6B;IAE7B,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,WAAW,aAAX,WAAW,cAAX,WAAW,GAAI,WAAW,CAAC;IACpC,CAAC;IAED,MAAM,IAAI,GAAoB;QAC5B,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO;QAClC,GAAG,WAAW;QACd,GAAG,OAAO;KACX,CAAC;IAEF,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;QAChB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QAEpB,IAAI,OAAO,CAAC,GAAG,KAAK,IAAI,EAAE,CAAC;YACzB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;SAAM,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;QAC3B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;IAC9B,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}{ "type": "module" } {"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/parse.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EACZ,QAAQ,EACR,KAAK,UAAU,EAEhB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,CACN,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,eAAe,EACxB,UAAU,EAAE,OAAO,EACnB,OAAO,EAAE,UAAU,GAAG,IAAI,KACvB,QAAQ,IAYX,SAAS,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,EAAE,GAAG,MAAM,EACzD,SAAS,eAAe,EACxB,YAAY,OAAO,EACnB,SAAS,UAAU,GAAG,IAAI,KACzB,QAAQ,CAwBZ;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CACpB,SAAS,EAAE,OAAO,EAAE,GAAG,OAAO,EAC9B,MAAM,EAAE,UAAU,GAAG,IAAI,GACxB,UAAU,GAAG,IAAI,CA+BnB"}import { removeElement } from 'domutils'; import { Document, isDocument as checkIsDocument, } from 'domhandler'; /** * Get the parse function with options. * * @param parser - The parser function. * @returns The parse function with options. */ export function getParse(parser) { /** * Parse a HTML string or a node. * * @param content - The HTML string or node. * @param options - The parser options. * @param isDocument - If `content` is a document. * @param context - The context node in the DOM tree. * @returns The parsed document node. */ return function parse(content, options, isDocument, context) { if (typeof Buffer !== 'undefined' && Buffer.isBuffer(content)) { content = content.toString(); } if (typeof content === 'string') { return parser(content, options, isDocument, context); } const doc = content; if (!Array.isArray(doc) && checkIsDocument(doc)) { // If `doc` is already a root, just return it return doc; } // Add conent to new root element const root = new Document([]); // Update the DOM using the root update(doc, root); return root; }; } /** * Update the dom structure, for one changed layer. * * @param newChilds - The new children. * @param parent - The new parent. * @returns The parent node. */ export function update(newChilds, parent) { // Normalize const arr = Array.isArray(newChilds) ? newChilds : [newChilds]; // Update parent if (parent) { parent.children = arr; } else { parent = null; } // Update neighbors for (let i = 0; i < arr.length; i++) { const node = arr[i]; // Cleanly remove existing nodes from their previous structures. if (node.parent && node.parent.children !== arr) { removeElement(node); } if (parent) { node.prev = arr[i - 1] || null; node.next = arr[i + 1] || null; } else { node.prev = node.next = null; } node.parent = parent; } return parent; } //# sourceMappingURL=parse.js.map{"version":3,"file":"parse.js","sourceRoot":"","sources":["../../src/parse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAEL,QAAQ,EAER,UAAU,IAAI,eAAe,GAC9B,MAAM,YAAY,CAAC;AAGpB;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CACtB,MAKa;IAEb;;;;;;;;OAQG;IACH,OAAO,SAAS,KAAK,CACnB,OAAyD,EACzD,OAAwB,EACxB,UAAmB,EACnB,OAA0B;QAE1B,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC9D,OAAO,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;QAC/B,CAAC;QAED,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;YAChC,OAAO,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;QACvD,CAAC;QAED,MAAM,GAAG,GAAG,OAAyC,CAAC;QAEtD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC;YAChD,6CAA6C;YAC7C,OAAO,GAAG,CAAC;QACb,CAAC;QAED,iCAAiC;QACjC,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;QAE9B,gCAAgC;QAChC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAElB,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,MAAM,CACpB,SAA8B,EAC9B,MAAyB;IAEzB,YAAY;IACZ,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAE/D,gBAAgB;IAChB,IAAI,MAAM,EAAE,CAAC;QACX,MAAM,CAAC,QAAQ,GAAG,GAAG,CAAC;IACxB,CAAC;SAAM,CAAC;QACN,MAAM,GAAG,IAAI,CAAC;IAChB,CAAC;IAED,mBAAmB;IACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACpC,MAAM,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;QAEpB,gEAAgE;QAChE,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,KAAK,GAAG,EAAE,CAAC;YAChD,aAAa,CAAC,IAAI,CAAC,CAAC;QACtB,CAAC;QAED,IAAI,MAAM,EAAE,CAAC;YACX,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC;YAC/B,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC;QACjC,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QAC/B,CAAC;QAED,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}{"version":3,"file":"slim.d.ts","sourceRoot":"","sources":["../../src/slim.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,UAAU,EAAW,MAAM,WAAW,CAAC;AACrD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAI1C,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAC9C,mBAAmB,YAAY,CAAC;AAChC,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvE,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,IAAI,EAAE,CACjB,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,EAAE,GAAG,MAAM,EAC9C,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,EAC/B,UAAU,CAAC,EAAE,OAAO,KACjB,UAAqD,CAAC"}/** * @file Alternative entry point for Cheerio that always uses htmlparser2. This * way, parse5 won't be loaded, saving some memory. */ import { getLoad } from './load.js'; import { getParse } from './parse.js'; import render from 'dom-serializer'; import { parseDocument } from 'htmlparser2'; export { contains, merge } from './static.js'; /** * Create a querying function, bound to a document created from the provided * markup. * * @param content - Markup to be loaded. * @param options - Options for the created instance. * @param isDocument - Always `false` here, as we are always using * `htmlparser2`. * @returns The loaded document. * @see {@link https://cheerio.js.org#loading} for additional usage information. */ export const load = getLoad(getParse(parseDocument), render); //# sourceMappingURL=slim.js.map{"version":3,"file":"slim.js","sourceRoot":"","sources":["../../src/slim.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAmB,OAAO,EAAE,MAAM,WAAW,CAAC;AAErD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,MAAM,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAM9C;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,IAAI,GAIC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,CAAC"}{"version":3,"file":"static.d.ts","sourceRoot":"","sources":["../../src/static.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEpD,OAAO,EAEL,KAAK,cAAc,EAEpB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAwCjE;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC;AACzE;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAClB,IAAI,EAAE,UAAU,EAChB,GAAG,CAAC,EAAE,kBAAkB,CAAC,OAAO,CAAC,EACjC,OAAO,CAAC,EAAE,cAAc,GACvB,MAAM,CAAC;AA0BV;;;;;;GAMG;AACH,wBAAgB,GAAG,CACjB,IAAI,EAAE,UAAU,EAChB,GAAG,CAAC,EAAE,kBAAkB,CAAC,OAAO,CAAC,GAChC,MAAM,CAIR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAClB,IAAI,EAAE,UAAU,GAAG,IAAI,EACvB,QAAQ,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,GAC5B,MAAM,CAUR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,EACjB,WAAW,CAAC,EAAE,OAAO,GACpB,OAAO,EAAE,CAAC;AACb,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;AA8BpE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAExD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,GAAG,OAAO,CAmBxE;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,UAAU,EAC1C,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,CAAC,GACL,YAAY,CAAC,CAAC,CAAC,CAEjB;AAED,KAAK,QAAQ,CAAC,CAAC,IAAI;IAAE,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAEtD;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,IAAI,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAC5B,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,GACjB,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAY1B"}import { textContent } from 'domutils'; import { flattenOptions as flattenOptions, } from './options.js'; /** * Helper function to render a DOM. * * @param that - Cheerio instance to render. * @param dom - The DOM to render. Defaults to `that`'s root. * @param options - Options for rendering. * @returns The rendered document. */ function render(that, dom, options) { if (!that) return ''; return that(dom !== null && dom !== void 0 ? dom : that._root.children, null, undefined, options).toString(); } /** * Checks if a passed object is an options object. * * @param dom - Object to check if it is an options object. * @param options - Options object. * @returns Whether the object is an options object. */ function isOptions(dom, options) { return (!options && typeof dom === 'object' && dom != null && !('length' in dom) && !('type' in dom)); } export function html(dom, options) { /* * Be flexible about parameters, sometimes we call html(), * with options as only parameter * check dom argument for dom element specific properties * assume there is no 'length' or 'type' properties in the options object */ const toRender = isOptions(dom) ? ((options = dom), undefined) : dom; /* * Sometimes `$.html()` is used without preloading html, * so fallback non-existing options to the default ones. */ const opts = { ...this === null || this === void 0 ? void 0 : this._options, ...flattenOptions(options), }; return render(this, toRender, opts); } /** * Render the document as XML. * * @category Static * @param dom - Element to render. * @returns THe rendered document. */ export function xml(dom) { const options = { ...this._options, xmlMode: true }; return render(this, dom, options); } /** * Render the document as text. * * This returns the `textContent` of the passed elements. The result will * include the contents of `", )); it("Empty tag name", () => runTest("< >")); it("Not quite closed", () => runTest("")); it("Entities in attributes", () => runTest("")); it("CDATA in HTML", () => runTest("")); it("Comment edge-cases", () => runTest("")); it("Scripts ending with <", () => runTest("")); it("CDATA more edge-cases", () => runTest("baz]]>", { recognizeCDATA: true })); it("tag names are not ASCII alpha", () => runTest("<12>text")); it("open-implies-close case of (non-br) void close tag in non-XML mode", () => runTest("", { lowerCaseAttributeNames: true })); it("entity in attribute (#276)", () => runTest( '?&image_uri=1&ℑ=2&image=3', )); it("entity in title (#592)", () => runTest("the "title"")); it("entity in title - decodeEntities=false (#592)", () => runTest("<title>the "title"", { decodeEntities: false })); it(" in ")); it("XML tags", () => runTest("<:foo><_bar>", { xmlMode: true })); it("Trailing legacy entity", () => runTest("⨱×bar")); it("Trailing numeric entity", () => runTest("55")); it("Multi-byte entity", () => runTest("≧̸")); it("Start & end indices from domhandler", () => runTest( " The Title Hello world
", )); it("Self-closing indices (#941)", () => runTest("", { xmlMode: true })); it("Entity after <", () => runTest("<&")); it("Attribute in XML (see #1350)", () => runTest( '', { xmlMode: true }, )); }); describe("Helper", () => { it("should handle errors", () => { const eventCallback = vi.fn(); const parser = new Parser(helper.getEventCollector(eventCallback)); parser.end(); parser.write("foo"); expect(eventCallback).toHaveBeenCalledTimes(2); expect(eventCallback).toHaveBeenNthCalledWith(1, null, []); expect(eventCallback).toHaveBeenLastCalledWith( new Error(".write() after done!"), ); }); }); import { describe, it, expect, vi } from "vitest"; import { Parser, Tokenizer } from "./index.js"; import type { Handler } from "./Parser.js"; describe("API", () => { it("should work without callbacks", () => { const cbs: Partial = { onerror: vi.fn() }; const p = new Parser(cbs, { xmlMode: true, lowerCaseAttributeNames: true, }); p.end("boohay"); p.write("foo"); // Check for an error p.end(); p.write("foo"); expect(cbs.onerror).toHaveBeenLastCalledWith( new Error(".write() after done!"), ); p.end(); expect(cbs.onerror).toHaveBeenLastCalledWith( new Error(".end() after done!"), ); // Should ignore the error if there is no callback delete cbs.onerror; p.write("foo"); p.reset(); // Remove method cbs.onopentag = vi.fn(); p.write(""); // Pause/resume const onText = vi.fn(); cbs.ontext = onText; p.pause(); p.write("foo"); expect(onText).not.toHaveBeenCalled(); p.resume(); expect(onText).toHaveBeenLastCalledWith("foo"); p.pause(); expect(onText).toHaveBeenCalledTimes(1); p.resume(); expect(onText).toHaveBeenCalledTimes(1); p.pause(); p.end("bar"); expect(onText).toHaveBeenCalledTimes(1); p.resume(); expect(onText).toHaveBeenCalledTimes(2); expect(onText).toHaveBeenLastCalledWith("bar"); }); it("should back out of numeric entities (#125)", () => { const onend = vi.fn(); let text = ""; const p = new Parser({ ontext(data) { text += data; }, onend, }); p.end("id=770&#anchor"); expect(onend).toHaveBeenCalledTimes(1); expect(text).toBe("id=770&#anchor"); p.reset(); text = ""; p.end("0&#xn"); expect(onend).toHaveBeenCalledTimes(2); expect(text).toBe("0&#xn"); }); it("should not have the start index be greater than the end index", () => { const onopentag = vi.fn(); const onclosetag = vi.fn(); const p = new Parser({ onopentag(tag) { expect(p.startIndex).toBeLessThanOrEqual(p.endIndex); onopentag(tag, p.startIndex, p.endIndex); }, onclosetag(tag) { expect(p.startIndex).toBeLessThanOrEqual(p.endIndex); onclosetag(tag, p.endIndex); }, }); p.write("
"); expect(onopentag).toHaveBeenLastCalledWith("p", 0, 2); expect(onclosetag).not.toHaveBeenCalled(); p.write("Foo"); p.write("
"); expect(onopentag).toHaveBeenLastCalledWith("hr", 6, 9); expect(onclosetag).toHaveBeenCalledTimes(2); expect(onclosetag).toHaveBeenNthCalledWith(1, "p", 9); expect(onclosetag).toHaveBeenNthCalledWith(2, "hr", 9); }); it("should update the position when a single tag is spread across multiple chunks", () => { let called = false; const p = new Parser({ onopentag() { called = true; expect(p.startIndex).toBe(0); expect(p.endIndex).toBe(12); }, }); p.write("
"); expect(called).toBe(true); }); it("should have the correct position for implied opening tags", () => { let called = false; const p = new Parser({ onopentag() { called = true; expect(p.startIndex).toBe(0); expect(p.endIndex).toBe(3); }, }); p.write("
"); expect(called).toBe(true); }); it("should parse <__proto__> (#387)", () => { const p = new Parser(null); // Should not throw p.parseChunk("<__proto__>"); }); it("should support custom tokenizer", () => { class CustomTokenizer extends Tokenizer {} const p = new Parser( { onparserinit(parser: Parser) { // @ts-expect-error Accessing private tokenizer here expect(parser.tokenizer).toBeInstanceOf(CustomTokenizer); }, }, { Tokenizer: CustomTokenizer }, ); p.done(); }); }); import Tokenizer, { type Callbacks, QuoteType } from "./Tokenizer.js"; import { fromCodePoint } from "entities/decode"; const formTags = new Set([ "input", "option", "optgroup", "select", "button", "datalist", "textarea", ]); const pTag = new Set(["p"]); const tableSectionTags = new Set(["thead", "tbody"]); const ddtTags = new Set(["dd", "dt"]); const rtpTags = new Set(["rt", "rp"]); const openImpliesClose = new Map>([ ["tr", new Set(["tr", "th", "td"])], ["th", new Set(["th"])], ["td", new Set(["thead", "th", "td"])], ["body", new Set(["head", "link", "script"])], ["li", new Set(["li"])], ["p", pTag], ["h1", pTag], ["h2", pTag], ["h3", pTag], ["h4", pTag], ["h5", pTag], ["h6", pTag], ["select", formTags], ["input", formTags], ["output", formTags], ["button", formTags], ["datalist", formTags], ["textarea", formTags], ["option", new Set(["option"])], ["optgroup", new Set(["optgroup", "option"])], ["dd", ddtTags], ["dt", ddtTags], ["address", pTag], ["article", pTag], ["aside", pTag], ["blockquote", pTag], ["details", pTag], ["div", pTag], ["dl", pTag], ["fieldset", pTag], ["figcaption", pTag], ["figure", pTag], ["footer", pTag], ["form", pTag], ["header", pTag], ["hr", pTag], ["main", pTag], ["nav", pTag], ["ol", pTag], ["pre", pTag], ["section", pTag], ["table", pTag], ["ul", pTag], ["rt", rtpTags], ["rp", rtpTags], ["tbody", tableSectionTags], ["tfoot", tableSectionTags], ]); const voidElements = new Set([ "area", "base", "basefont", "br", "col", "command", "embed", "frame", "hr", "img", "input", "isindex", "keygen", "link", "meta", "param", "source", "track", "wbr", ]); const foreignContextElements = new Set(["math", "svg"]); const htmlIntegrationElements = new Set([ "mi", "mo", "mn", "ms", "mtext", "annotation-xml", "foreignobject", "desc", "title", ]); export interface ParserOptions { /** * Indicates whether special tags (`
")).toMatchSnapshot(); }); it("for normal style tag", () => { expect(tokenize("
")).toMatchSnapshot(); }); it("for normal sitle tag", () => { expect(tokenize("
")).toMatchSnapshot(); }); it("for normal textarea tag", () => { expect( tokenize("
"), ).toMatchSnapshot(); }); it("for normal xmp tag", () => { expect(tokenize("
")).toMatchSnapshot(); }); }); describe("should treat html inside special tags as text", () => { it("for div inside script tag", () => { expect(tokenize("")).toMatchSnapshot(); }); it("for div inside style tag", () => { expect(tokenize("")).toMatchSnapshot(); }); it("for div inside title tag", () => { expect(tokenize("<div></div>")).toMatchSnapshot(); }); it("for div inside textarea tag", () => { expect( tokenize("<div></div>"), ).toMatchSnapshot(); }); it("for div inside xmp tag", () => { expect(tokenize("")).toMatchSnapshot(); }); }); describe("should correctly mark attributes", () => { it("for no value attribute", () => { expect(tokenize("
")).toMatchSnapshot(); }); it("for no quotes attribute", () => { expect(tokenize("
")).toMatchSnapshot(); }); it("for single quotes attribute", () => { expect(tokenize("
")).toMatchSnapshot(); }); it("for double quotes attribute", () => { expect(tokenize('
')).toMatchSnapshot(); }); }); describe("should not break after special tag followed by an entity", () => { it("for normal special tag", () => { expect(tokenize("'
")).toMatchSnapshot(); }); it("for self-closing special tag", () => { expect(tokenize("

AcreetionOS USB Flasher

Hello World

Hello, world.

Test