rusteerio 0.0.0-stage → 0.1.0

package/dist/slim.d.mts

@@ -0,0 +1,11 @@
+export { contains, dom, merge } from './index.mjs';
+import { L as LoadContent, C as CheerioOptions, a as CheerioAPI } from './types-BP6TpxE5.mjs';
+export { A as AcceptedElems, b as AcceptedFilters, c as AnyNode, B as BasicAcceptedElems, d as CDATA, type e as Cheerio, f as CheerioRequestOptions, g as ChildNode, h as Comment, D as DataNode, i as DecodeStreamOptions, j as Document, k as DocumentMode, E as Element, type l as ElementType, m as EncodingOptions, n as ExtractDescriptor, o as ExtractMap, p as ExtractedMap, q as ExtractedValue, r as ExtractionDescriptor, s as ExtractionMap, t as ExtractionResult, F as FilterFunction, u as FormDataLike, H as HTMLParser2Options, I as InternalOptions, N as NamespaceURI, v as Node, w as NodeWithChildren, P as ParallelOptions, x as ParentNode, y as ParserError, z as ParserErrorCode, G as ParserErrorHandler, J as ProcessingInstruction, S as SelectorType, K as SerializedField, M as SourceCodeLocation, T as TagSourceCodeLocation, O as Text, Q as Tokenizer, R as TokenizerCallbacks, U as TokenizerConstructor, V as TokenizerOptions, W as TreeAdapter, X as TreeAdapterAttribute } from './types-BP6TpxE5.mjs';
+import 'node:stream';
+import 'node:querystring';
+import 'node:buffer';
+
+/** Parser-compatible slim entry point, backed by the native fragment parser. */
+declare function load(content: LoadContent, options?: CheerioOptions | null, _isDocument?: boolean): CheerioAPI;
+
+export { CheerioAPI, CheerioOptions, LoadContent, load };

package/dist/slim.d.ts

@@ -0,0 +1,11 @@
+export { contains, dom, merge } from './index.js';
+import { L as LoadContent, C as CheerioOptions, a as CheerioAPI } from './types-BP6TpxE5.js';
+export { A as AcceptedElems, b as AcceptedFilters, c as AnyNode, B as BasicAcceptedElems, d as CDATA, type e as Cheerio, f as CheerioRequestOptions, g as ChildNode, h as Comment, D as DataNode, i as DecodeStreamOptions, j as Document, k as DocumentMode, E as Element, type l as ElementType, m as EncodingOptions, n as ExtractDescriptor, o as ExtractMap, p as ExtractedMap, q as ExtractedValue, r as ExtractionDescriptor, s as ExtractionMap, t as ExtractionResult, F as FilterFunction, u as FormDataLike, H as HTMLParser2Options, I as InternalOptions, N as NamespaceURI, v as Node, w as NodeWithChildren, P as ParallelOptions, x as ParentNode, y as ParserError, z as ParserErrorCode, G as ParserErrorHandler, J as ProcessingInstruction, S as SelectorType, K as SerializedField, M as SourceCodeLocation, T as TagSourceCodeLocation, O as Text, Q as Tokenizer, R as TokenizerCallbacks, U as TokenizerConstructor, V as TokenizerOptions, W as TreeAdapter, X as TreeAdapterAttribute } from './types-BP6TpxE5.js';
+import 'node:stream';
+import 'node:querystring';
+import 'node:buffer';
+
+/** Parser-compatible slim entry point, backed by the native fragment parser. */
+declare function load(content: LoadContent, options?: CheerioOptions | null, _isDocument?: boolean): CheerioAPI;
+
+export { CheerioAPI, CheerioOptions, LoadContent, load };

package/dist/slim.mjs

@@ -0,0 +1,19 @@
+import {
+  contains,
+  dom,
+  load,
+  merge
+} from "./chunk-DKULX6VO.mjs";
+import "./chunk-OHPGEY3E.mjs";
+
+// src/slim.ts
+function load2(content, options, _isDocument) {
+  return load(content, { ...options, _useHtmlParser2: true }, false);
+}
+export {
+  contains,
+  dom,
+  load2 as load,
+  merge
+};
+//# sourceMappingURL=slim.mjs.map

package/dist/slim.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/slim.ts"],"sourcesContent":["import { load as loadNative, contains, merge } from './index.js';\nimport type { CheerioAPI, CheerioOptions, LoadContent } from './types.js';\n\nexport { contains, merge };\nexport { dom } from './index.js';\nexport type * from './types.js';\nexport type { Cheerio } from './selection.js';\n\n/** Parser-compatible slim entry point, backed by the native fragment parser. */\nexport function load(content: LoadContent, options?: CheerioOptions | null, _isDocument?: boolean): CheerioAPI {\n  return loadNative(content, { ...options, _useHtmlParser2: true }, false);\n}\n"],"mappings":";;;;;;;;;AASO,SAASA,MAAK,SAAsB,SAAiC,aAAmC;AAC7G,SAAO,KAAW,SAAS,EAAE,GAAG,SAAS,iBAAiB,KAAK,GAAG,KAAK;AACzE;","names":["load"]}

package/dist/types-BP6TpxE5.d.mts

@@ -0,0 +1,532 @@
+import * as node_querystring from 'node:querystring';
+import * as node_stream from 'node:stream';
+import * as node_buffer from 'node:buffer';
+
+interface NativeDocument {
+    readonly nodeSpace?: object;
+    retainNode?(id: number): void;
+    retainNodeData?(id: number, data: object): void;
+    adopt?(source: NativeDocument, ids: number[], detach?: boolean): string;
+    op(command: string, argsJson: string): string;
+    create?(html: string, contextId?: number, optionsJson?: string): number[];
+    select(selector: string, contexts?: number[]): number[];
+    text(ids: number[]): string;
+    innerHtml(id: number): string;
+    outerHtml(ids: number[]): string;
+    attr(id: number, name: string): string | undefined | null;
+    tagName(id: number): string | undefined | null;
+    exportTree(): string;
+    rootId(): number;
+    parserDiagnostics?(): string;
+}
+interface NativeWorkerPoolInfo {
+    threads: number;
+    activeBatches: number;
+    activeWorkers: number;
+    peakActiveWorkers: number;
+}
+/** Useful for installation diagnostics and benchmarks that require native code. */
+declare function nativeStatus(): {
+    available: boolean;
+    error?: string;
+};
+
+interface StyleProp {
+    length: number;
+    [key: string]: string | number;
+    [index: number]: string;
+}
+interface AttributeMethods<T = AnyNode> {
+    attr<U extends AnyNode>(this: Cheerio<U>, name: string): string | undefined;
+    attr<U extends AnyNode>(this: Cheerio<U>): Record<string, string> | undefined;
+    attr<U extends AnyNode>(this: Cheerio<U>, name: string, value?: string | null | ((this: Element, index: number, value: string) => string | null)): Cheerio<U>;
+    attr<U extends AnyNode>(this: Cheerio<U>, values: Record<string, string | null>): Cheerio<U>;
+    prop<U extends AnyNode>(this: Cheerio<U>, name: 'tagName' | 'nodeName'): string | undefined;
+    prop<U extends AnyNode>(this: Cheerio<U>, name: 'innerHTML' | 'outerHTML' | 'innerText' | 'textContent'): string | null;
+    prop<U extends AnyNode>(this: Cheerio<U>, name: 'style'): StyleProp | undefined;
+    prop<U extends AnyNode>(this: Cheerio<U>, name: 'href' | 'src'): string | undefined;
+    prop<U extends AnyNode, K extends keyof Element>(this: Cheerio<U>, name: K): Element[K];
+    prop<U extends AnyNode, K extends keyof Element>(this: Cheerio<U>, name: K, value: Element[K] | ((this: Element, index: number, property: K) => Element[keyof Element])): Cheerio<U>;
+    prop<U extends AnyNode>(this: Cheerio<U>, values: Record<string, string | Element[keyof Element] | boolean>): Cheerio<U>;
+    prop<U extends AnyNode>(this: Cheerio<U>, name: string, value: string | boolean | null | ((this: Element, index: number, property: string) => string | boolean)): Cheerio<U>;
+    prop<U extends AnyNode>(this: Cheerio<U>, name: string): string;
+    data<U extends AnyNode>(this: Cheerio<U>, name: string): unknown;
+    data<U extends AnyNode>(this: Cheerio<U>): Record<string, unknown>;
+    data<U extends AnyNode>(this: Cheerio<U>, name: string, value: unknown): Cheerio<U>;
+    data<U extends AnyNode>(this: Cheerio<U>, values: Record<string, unknown>): Cheerio<U>;
+    val<U extends AnyNode>(this: Cheerio<U>): string | string[] | undefined;
+    val<U extends AnyNode>(this: Cheerio<U>, value: string | string[]): Cheerio<U>;
+    removeAttr<U extends AnyNode>(this: Cheerio<U>, name: string): Cheerio<U>;
+    hasClass<U extends AnyNode>(this: Cheerio<U>, name: string): boolean;
+    addClass<U extends AnyNode, R extends ArrayLike<U>>(this: R, name?: string | ((this: Element, index: number, current: string) => string | undefined)): R;
+    removeClass<U extends AnyNode, R extends ArrayLike<U>>(this: R, name?: string | ((this: Element, index: number, current: string) => string | undefined)): R;
+    toggleClass<U extends AnyNode, R extends ArrayLike<U>>(this: R, name?: string | ((this: Element, index: number, current: string, state?: boolean) => string), state?: boolean): R;
+    css<U extends AnyNode>(this: Cheerio<U>, names?: string[]): Record<string, string> | undefined;
+    css<U extends AnyNode>(this: Cheerio<U>, name: string): string | undefined;
+    css<U extends AnyNode>(this: Cheerio<U>, name: string, value: string | ((this: Element, index: number, current: string) => string | undefined)): Cheerio<U>;
+    css<U extends AnyNode>(this: Cheerio<U>, values: Record<string, string>): Cheerio<U>;
+    serializeArray<U extends AnyNode>(this: Cheerio<U>): SerializedField[];
+    serialize<U extends AnyNode>(this: Cheerio<U>): string;
+}
+
+/** An array-like selection of stable handles into the Rust document arena. */
+declare class Cheerio<T = AnyNode> implements ArrayLike<T>, Iterable<T> {
+    [index: number]: T;
+    options: CheerioOptions;
+    _root: Cheerio<Document> | null;
+    prevObject: Cheerio<any> | undefined;
+    length: number;
+    cheerio: "[cheerio object]";
+    constructor(api: CheerioAPI, document: NativeDocument, ids?: number[], root?: Cheerio<Document> | null, options?: CheerioOptions, values?: T[]);
+    _make<R>(value: ArrayLike<R> | R | string, context?: BasicAcceptedElems<AnyNode>): Cheerio<R>;
+    _parse(content: any, options: CheerioOptions, isDocument: boolean, context: ParentNode | null): Document;
+    _render(content: any): string;
+    _makeDomArray<T extends AnyNode>(this: Cheerio<T>, elem?: BasicAcceptedElems<AnyNode> | BasicAcceptedElems<AnyNode>[], clone?: boolean): AnyNode[];
+    find<T extends AnyNode>(this: Cheerio<T>, selectorOrHaystack?: string | Cheerio<Element> | Element): Cheerio<Element>;
+    _findBySelector<T extends AnyNode>(this: Cheerio<T>, selector: string, limit: number): Cheerio<Element>;
+    parent<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    parents<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    next<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    prev<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    nextAll<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    prevAll<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    siblings<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    children<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    contents<T extends AnyNode>(this: Cheerio<T>): Cheerio<AnyNode>;
+    parentsUntil<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | null, filterSelector?: AcceptedFilters<Element>): Cheerio<Element>;
+    nextUntil<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | null, filterSelector?: AcceptedFilters<Element>): Cheerio<Element>;
+    prevUntil<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | null, filterSelector?: AcceptedFilters<Element>): Cheerio<Element>;
+    closest<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<AnyNode>;
+    each<T>(this: Cheerio<T>, fn: (this: T, i: number, el: T) => void | boolean): Cheerio<T>;
+    map<T, M>(this: Cheerio<T>, fn: (this: T, i: number, el: T) => M[] | M | null | undefined): Cheerio<M>;
+    filter<T, S extends T>(this: Cheerio<T>, match: (this: T, index: number, value: T) => value is S): Cheerio<S>;
+    filter<T, S extends AcceptedFilters<T>>(this: Cheerio<T>, match: S): Cheerio<S extends string ? Element : T>;
+    filterArray<T>(nodes: T[], match: AcceptedFilters<T>, xmlMode?: boolean, root?: Document): Element[] | T[];
+    not<T extends AnyNode>(this: Cheerio<T>, match: AcceptedFilters<T>): Cheerio<T>;
+    is<T>(this: Cheerio<T>, selector?: AcceptedFilters<T>): boolean;
+    has(this: Cheerio<AnyNode | Element>, selectorOrHaystack: string | Cheerio<Element> | Element): Cheerio<AnyNode | Element>;
+    first<T extends AnyNode>(this: Cheerio<T>): Cheerio<T>;
+    last<T>(this: Cheerio<T>): Cheerio<T>;
+    eq<T>(this: Cheerio<T>, i: number): Cheerio<T>;
+    get<T>(this: Cheerio<T>, i: number): T | undefined;
+    get<T>(this: Cheerio<T>): T[];
+    toArray<T>(this: Cheerio<T>): T[];
+    slice<T>(this: Cheerio<T>, start?: number, end?: number): Cheerio<T>;
+    end<T>(this: Cheerio<T>): Cheerio<AnyNode>;
+    add<S extends AnyNode, T extends AnyNode>(this: Cheerio<T>, other: string | Cheerio<S> | S | S[], context?: Cheerio<S> | string): Cheerio<S | T>;
+    addBack<T extends AnyNode>(this: Cheerio<T>, selector?: string): Cheerio<AnyNode>;
+    index<T extends AnyNode>(this: Cheerio<T>, selectorOrNeedle?: string | Cheerio<AnyNode> | AnyNode): number;
+    splice(start: number, deleteCount?: number): any[];
+    splice(start: number, deleteCount: number, ...items: any[]): any[];
+    [Symbol.iterator](): Iterator<T>;
+    append<T extends AnyNode>(this: Cheerio<T>, ...elems: [
+        (this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>
+    ] | BasicAcceptedElems<AnyNode>[]): Cheerio<T>;
+    prepend<T extends AnyNode>(this: Cheerio<T>, ...elems: [
+        (this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>
+    ] | BasicAcceptedElems<AnyNode>[]): Cheerio<T>;
+    before<T extends AnyNode>(this: Cheerio<T>, ...elems: [
+        (this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>
+    ] | BasicAcceptedElems<AnyNode>[]): Cheerio<T>;
+    after<T extends AnyNode>(this: Cheerio<T>, ...elems: [
+        (this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>
+    ] | BasicAcceptedElems<AnyNode>[]): Cheerio<T>;
+    appendTo<T extends AnyNode>(this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>): Cheerio<T>;
+    prependTo<T extends AnyNode>(this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>): Cheerio<T>;
+    insertBefore<T extends AnyNode>(this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>): Cheerio<T>;
+    insertAfter<T extends AnyNode>(this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>): Cheerio<T>;
+    remove<T extends AnyNode>(this: Cheerio<T>, selector?: string): Cheerio<T>;
+    replaceWith<T extends AnyNode>(this: Cheerio<T>, content: AcceptedElems<AnyNode>): Cheerio<T>;
+    empty<T extends AnyNode>(this: Cheerio<T>): Cheerio<T>;
+    html<T extends AnyNode>(this: Cheerio<T>): string | null;
+    html<T extends AnyNode>(this: Cheerio<T>, str: string | Cheerio<T>): Cheerio<T>;
+    text<T extends AnyNode>(this: Cheerio<T>): string;
+    text<T extends AnyNode>(this: Cheerio<T>, str: string | ((this: AnyNode, i: number, text: string) => string)): Cheerio<T>;
+    toString<T extends AnyNode>(this: Cheerio<T>): string;
+    clone<T extends AnyNode>(this: Cheerio<T>): Cheerio<T>;
+    wrap<T extends AnyNode>(this: Cheerio<T>, wrapper: AcceptedElems<AnyNode>): Cheerio<T>;
+    wrapInner<T extends AnyNode>(this: Cheerio<T>, wrapper: AcceptedElems<AnyNode>): Cheerio<T>;
+    unwrap<T extends AnyNode>(this: Cheerio<T>, selector?: string): Cheerio<T>;
+    wrapAll<T extends AnyNode>(this: Cheerio<T>, wrapper: AcceptedElems<T>): Cheerio<T>;
+    extract<M extends ExtractMap, T extends AnyNode>(this: Cheerio<T>, map: M): ExtractedMap<M>;
+    extract<M extends ExtractMap, T extends AnyNode>(this: Cheerio<T>, map: M): Record<string, unknown>;
+}
+interface Cheerio<T = AnyNode> extends AttributeMethods<T> {
+}
+
+/** Parse5-compatible diagnostics, declared locally without a parser dependency. */
+declare enum ERR {
+    controlCharacterInInputStream = "control-character-in-input-stream",
+    noncharacterInInputStream = "noncharacter-in-input-stream",
+    surrogateInInputStream = "surrogate-in-input-stream",
+    nonVoidHtmlElementStartTagWithTrailingSolidus = "non-void-html-element-start-tag-with-trailing-solidus",
+    endTagWithAttributes = "end-tag-with-attributes",
+    endTagWithTrailingSolidus = "end-tag-with-trailing-solidus",
+    unexpectedSolidusInTag = "unexpected-solidus-in-tag",
+    unexpectedNullCharacter = "unexpected-null-character",
+    unexpectedQuestionMarkInsteadOfTagName = "unexpected-question-mark-instead-of-tag-name",
+    invalidFirstCharacterOfTagName = "invalid-first-character-of-tag-name",
+    unexpectedEqualsSignBeforeAttributeName = "unexpected-equals-sign-before-attribute-name",
+    missingEndTagName = "missing-end-tag-name",
+    unexpectedCharacterInAttributeName = "unexpected-character-in-attribute-name",
+    unknownNamedCharacterReference = "unknown-named-character-reference",
+    missingSemicolonAfterCharacterReference = "missing-semicolon-after-character-reference",
+    unexpectedCharacterAfterDoctypeSystemIdentifier = "unexpected-character-after-doctype-system-identifier",
+    unexpectedCharacterInUnquotedAttributeValue = "unexpected-character-in-unquoted-attribute-value",
+    eofBeforeTagName = "eof-before-tag-name",
+    eofInTag = "eof-in-tag",
+    missingAttributeValue = "missing-attribute-value",
+    missingWhitespaceBetweenAttributes = "missing-whitespace-between-attributes",
+    missingWhitespaceAfterDoctypePublicKeyword = "missing-whitespace-after-doctype-public-keyword",
+    missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers = "missing-whitespace-between-doctype-public-and-system-identifiers",
+    missingWhitespaceAfterDoctypeSystemKeyword = "missing-whitespace-after-doctype-system-keyword",
+    missingQuoteBeforeDoctypePublicIdentifier = "missing-quote-before-doctype-public-identifier",
+    missingQuoteBeforeDoctypeSystemIdentifier = "missing-quote-before-doctype-system-identifier",
+    missingDoctypePublicIdentifier = "missing-doctype-public-identifier",
+    missingDoctypeSystemIdentifier = "missing-doctype-system-identifier",
+    abruptDoctypePublicIdentifier = "abrupt-doctype-public-identifier",
+    abruptDoctypeSystemIdentifier = "abrupt-doctype-system-identifier",
+    cdataInHtmlContent = "cdata-in-html-content",
+    incorrectlyOpenedComment = "incorrectly-opened-comment",
+    eofInScriptHtmlCommentLikeText = "eof-in-script-html-comment-like-text",
+    eofInDoctype = "eof-in-doctype",
+    nestedComment = "nested-comment",
+    abruptClosingOfEmptyComment = "abrupt-closing-of-empty-comment",
+    eofInComment = "eof-in-comment",
+    incorrectlyClosedComment = "incorrectly-closed-comment",
+    eofInCdata = "eof-in-cdata",
+    absenceOfDigitsInNumericCharacterReference = "absence-of-digits-in-numeric-character-reference",
+    nullCharacterReference = "null-character-reference",
+    surrogateCharacterReference = "surrogate-character-reference",
+    characterReferenceOutsideUnicodeRange = "character-reference-outside-unicode-range",
+    controlCharacterReference = "control-character-reference",
+    noncharacterCharacterReference = "noncharacter-character-reference",
+    missingWhitespaceBeforeDoctypeName = "missing-whitespace-before-doctype-name",
+    missingDoctypeName = "missing-doctype-name",
+    invalidCharacterSequenceAfterDoctypeName = "invalid-character-sequence-after-doctype-name",
+    duplicateAttribute = "duplicate-attribute",
+    nonConformingDoctype = "non-conforming-doctype",
+    missingDoctype = "missing-doctype",
+    misplacedDoctype = "misplaced-doctype",
+    endTagWithoutMatchingOpenElement = "end-tag-without-matching-open-element",
+    closingOfElementWithOpenChildElements = "closing-of-element-with-open-child-elements",
+    disallowedContentInNoscriptInHead = "disallowed-content-in-noscript-in-head",
+    openElementsLeftAfterEof = "open-elements-left-after-eof",
+    abandonedHeadElementChild = "abandoned-head-element-child",
+    misplacedStartTagForHeadElement = "misplaced-start-tag-for-head-element",
+    nestedNoscriptInHead = "nested-noscript-in-head",
+    eofInElementThatCanContainOnlyText = "eof-in-element-that-can-contain-only-text"
+}
+type ParserErrorCode = ERR;
+interface ParserError extends SourceCodeLocation {
+    code: ParserErrorCode;
+}
+type ParserErrorHandler = (error: ParserError) => void;
+declare enum NS {
+    HTML = "http://www.w3.org/1999/xhtml",
+    MATHML = "http://www.w3.org/1998/Math/MathML",
+    SVG = "http://www.w3.org/2000/svg",
+    XLINK = "http://www.w3.org/1999/xlink",
+    XML = "http://www.w3.org/XML/1998/namespace",
+    XMLNS = "http://www.w3.org/2000/xmlns/"
+}
+declare enum DOCUMENT_MODE {
+    NO_QUIRKS = "no-quirks",
+    QUIRKS = "quirks",
+    LIMITED_QUIRKS = "limited-quirks"
+}
+type NamespaceURI = NS;
+type DocumentMode = DOCUMENT_MODE;
+interface TreeAdapterAttribute {
+    name: string;
+    value: string;
+    namespace?: string;
+    prefix?: string;
+}
+/** The HTML5 adapter shape used by Cheerio's DOM representation. */
+interface TreeAdapter {
+    adoptAttributes(recipient: Element, attrs: TreeAdapterAttribute[]): void;
+    appendChild(parentNode: ParentNode, newNode: ChildNode): void;
+    createCommentNode(data: string): Comment;
+    createTextNode(value: string): Text;
+    createDocument(): Document;
+    createDocumentFragment(): Document;
+    createElement(tagName: string, namespaceURI: NamespaceURI, attrs: TreeAdapterAttribute[]): Element;
+    detachNode(node: ChildNode): void;
+    getAttrList(element: Element): TreeAdapterAttribute[];
+    getChildNodes(node: ParentNode): ChildNode[];
+    getCommentNodeContent(node: Comment): string;
+    getDocumentMode(document: Document): DocumentMode;
+    getDocumentTypeNodeName(node: ProcessingInstruction): string;
+    getDocumentTypeNodePublicId(node: ProcessingInstruction): string;
+    getDocumentTypeNodeSystemId(node: ProcessingInstruction): string;
+    getFirstChild(node: ParentNode): ChildNode | null;
+    getNamespaceURI(element: Element): NamespaceURI;
+    getNodeSourceCodeLocation(node: AnyNode): TagSourceCodeLocation | undefined | null;
+    getParentNode(node: AnyNode): ParentNode | null;
+    getTagName(element: Element): string;
+    getTextNodeContent(node: Text): string;
+    getTemplateContent(element: Element): Document;
+    insertBefore(parent: ParentNode, child: ChildNode, reference: ChildNode): void;
+    insertText(parent: ParentNode, text: string): void;
+    insertTextBefore(parent: ParentNode, text: string, reference: ChildNode): void;
+    isCommentNode(node: AnyNode): node is Comment;
+    isDocumentTypeNode(node: AnyNode): node is ProcessingInstruction;
+    isElementNode(node: AnyNode): node is Element;
+    isTextNode(node: AnyNode): node is Text;
+    setDocumentMode(document: Document, mode: DocumentMode): void;
+    setDocumentType(document: Document, name: string, publicId: string, systemId: string): void;
+    setNodeSourceCodeLocation(node: AnyNode, location: TagSourceCodeLocation | null): void;
+    updateNodeSourceCodeLocation(node: AnyNode, location: Partial<TagSourceCodeLocation>): void;
+    setTemplateContent(element: Element, content: Document): void;
+    onItemPush?: (item: Element) => void;
+    onItemPop?: (item: Element, newTop: ParentNode) => void;
+}
+declare enum QuoteType {
+    NoValue = 0,
+    Unquoted = 1,
+    Single = 2,
+    Double = 3
+}
+interface TokenizerCallbacks {
+    onattribdata(start: number, endIndex: number): void;
+    onattribentity(codepoint: number): void;
+    onattribend(quote: QuoteType, endIndex: number): void;
+    onattribname(start: number, endIndex: number): void;
+    oncdata(start: number, endIndex: number, endOffset: number): void;
+    onclosetag(start: number, endIndex: number): void;
+    oncomment(start: number, endIndex: number, endOffset: number): void;
+    ondeclaration(start: number, endIndex: number): void;
+    onend(): void;
+    onopentagend(endIndex: number): void;
+    onopentagname(start: number, endIndex: number): void;
+    onprocessinginstruction(start: number, endIndex: number): void;
+    onselfclosingtag(endIndex: number): void;
+    ontext(start: number, endIndex: number): void;
+    ontextentity(codepoint: number, endIndex: number): void;
+}
+interface Tokenizer {
+    running: boolean;
+    reset(): void;
+    write(chunk: string): void;
+    end(): void;
+    pause(): void;
+    resume(): void;
+}
+interface TokenizerOptions {
+    xmlMode?: boolean;
+    decodeEntities?: boolean;
+}
+interface TokenizerConstructor {
+    new (options: TokenizerOptions, callbacks: TokenizerCallbacks): Tokenizer;
+    new (options: TokenizerOptions, callbacks: TokenizerCallbacks): any;
+}
+
+/** DOM-compatible views over stable nodes owned by the native document. */
+declare enum ElementType {
+    Root = "root",
+    Text = "text",
+    Directive = "directive",
+    Comment = "comment",
+    Script = "script",
+    Style = "style",
+    Tag = "tag",
+    CDATA = "cdata",
+    Doctype = "doctype"
+}
+interface SourceCodeLocation {
+    startLine: number;
+    startCol: number;
+    startOffset: number;
+    endLine: number;
+    endCol: number;
+    endOffset: number;
+}
+interface TagSourceCodeLocation extends SourceCodeLocation {
+    startTag?: SourceCodeLocation;
+    endTag?: SourceCodeLocation;
+    attrs?: Record<string, SourceCodeLocation>;
+}
+interface Node {
+    readonly type: ElementType;
+    parent: ParentNode | null;
+    prev: ChildNode | null;
+    next: ChildNode | null;
+    startIndex: number | null;
+    endIndex: number | null;
+    readonly nodeType: number;
+    parentNode: ParentNode | null;
+    previousSibling: ChildNode | null;
+    nextSibling: ChildNode | null;
+    sourceCodeLocation?: SourceCodeLocation | null;
+    cloneNode<T extends Node>(this: T, recursive?: boolean): T;
+}
+interface DataNode extends Node {
+    data: string;
+    nodeValue: string;
+}
+interface Text extends DataNode {
+    type: ElementType.Text;
+    readonly nodeType: 3;
+}
+interface Comment extends DataNode {
+    type: ElementType.Comment;
+    readonly nodeType: 8;
+}
+interface ProcessingInstruction extends DataNode {
+    type: ElementType.Directive;
+    name: string;
+    readonly nodeType: 1;
+    'x-name'?: string;
+    'x-publicId'?: string;
+    'x-systemId'?: string;
+}
+interface NodeWithChildren extends Node {
+    children: ChildNode[];
+    childNodes: ChildNode[];
+    readonly firstChild: ChildNode | null;
+    readonly lastChild: ChildNode | null;
+}
+interface Document extends NodeWithChildren {
+    type: ElementType.Root;
+    readonly nodeType: 9;
+    'x-mode'?: 'quirks' | 'limited-quirks' | 'no-quirks';
+}
+interface CDATA extends NodeWithChildren {
+    type: ElementType.CDATA;
+    readonly nodeType: 4;
+}
+interface Element extends NodeWithChildren {
+    type: ElementType.Tag | ElementType.Script | ElementType.Style;
+    readonly nodeType: 1;
+    name: string;
+    tagName: string;
+    attribs: Record<string, string>;
+    namespace?: string;
+    sourceCodeLocation?: TagSourceCodeLocation | null;
+    readonly attributes: {
+        name: string;
+        value: string;
+        namespace?: string;
+        prefix?: string;
+    }[];
+    'x-attribsNamespace'?: Record<string, string>;
+    'x-attribsPrefix'?: Record<string, string>;
+}
+type ParentNode = Document | Element | CDATA;
+type ChildNode = Text | Comment | ProcessingInstruction | Element | CDATA | Document;
+type AnyNode = ParentNode | ChildNode;
+interface HTMLParser2Options {
+    xmlMode?: boolean;
+    decodeEntities?: boolean;
+    encodeEntities?: boolean | 'utf8';
+    lowerCaseTags?: boolean;
+    lowerCaseAttributeNames?: boolean;
+    recognizeCDATA?: boolean;
+    recognizeSelfClosing?: boolean;
+    withStartIndices?: boolean;
+    withEndIndices?: boolean;
+    emptyAttrs?: boolean;
+    selfClosingTags?: boolean;
+    Tokenizer?: TokenizerConstructor;
+    [key: string]: any;
+}
+interface CheerioOptions extends HTMLParser2Options {
+    xml?: boolean | HTMLParser2Options;
+    baseURI?: string | URL;
+    quirksMode?: boolean;
+    scriptingEnabled?: boolean;
+    sourceCodeLocationInfo?: boolean;
+    treeAdapter?: TreeAdapter;
+    onParseError?: ParserErrorHandler | null;
+    pseudos?: Record<string, string | ((element: Element, value?: string | null) => boolean)>;
+    _useHtmlParser2?: boolean;
+}
+type InternalOptions = CheerioOptions;
+type LowercaseLetters = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+type AlphaNumeric = LowercaseLetters | Uppercase<LowercaseLetters> | `${number}`;
+type SelectorType = `${'.' | '#' | ':' | '|' | '>' | '+' | '~' | '['}${AlphaNumeric}${string}` | `${AlphaNumeric}${string}`;
+type BasicAcceptedElems<T extends AnyNode = AnyNode> = ArrayLike<T> | T | string;
+type AcceptedElems<T extends AnyNode = AnyNode> = BasicAcceptedElems<T> | ((this: T, index: number, element: T) => BasicAcceptedElems<T>);
+type FilterFunction<T> = (this: T, index: number, element: T) => boolean;
+type AcceptedFilters<T> = string | FilterFunction<T> | T | Cheerio<T>;
+type LoadContent = string | Buffer | AnyNode | ArrayLike<AnyNode>;
+interface CheerioAPI {
+    <T extends AnyNode, S extends string>(selector?: S | BasicAcceptedElems<T>, context?: BasicAcceptedElems<AnyNode> | null, root?: BasicAcceptedElems<Document>, options?: CheerioOptions): Cheerio<S extends SelectorType ? Element : T>;
+    <T extends AnyNode, S extends string>(selector?: S | BasicAcceptedElems<T>, context?: BasicAcceptedElems<AnyNode> | null, root?: BasicAcceptedElems<Document>, options?: CheerioOptions): Cheerio<AnyNode>;
+    html(options?: CheerioOptions): string;
+    html(dom?: BasicAcceptedElems<AnyNode> | Cheerio<AnyNode>, options?: CheerioOptions): string;
+    xml(dom?: BasicAcceptedElems<AnyNode> | Cheerio<AnyNode>): string;
+    text(elements?: ArrayLike<AnyNode>): string;
+    root(): Cheerio<Document>;
+    contains(container: AnyNode, contained: AnyNode): boolean;
+    merge<T>(first: ArrayLike<T>, second: ArrayLike<T>): ArrayLike<T> | undefined;
+    parseHTML(data: string, context?: unknown, keepScripts?: boolean): AnyNode[];
+    parseHTML(data?: '' | null): null;
+    load(content: LoadContent, options?: CheerioOptions | null, isDocument?: boolean): CheerioAPI;
+    extract<M extends ExtractMap>(this: CheerioAPI, map: M): ExtractedMap<M>;
+    extract<M extends ExtractMap>(this: CheerioAPI, map: M): Record<string, unknown>;
+    fn: typeof Cheerio.prototype;
+    _root: Document;
+    _options: InternalOptions;
+    [key: string]: any;
+}
+type ExtractDescriptorFn = (element: Element, key: string, result: Record<string, unknown>) => unknown;
+interface ExtractDescriptor {
+    selector: string;
+    value?: string | ExtractDescriptorFn | ExtractMap;
+}
+type ExtractValue = string | ExtractDescriptor | [string | ExtractDescriptor];
+type ExtractMap = Record<string, ExtractValue>;
+type ExtractedValue<V extends ExtractValue> = V extends [string | ExtractDescriptor] ? NonNullable<ExtractedValue<V[0]>>[] : V extends string ? string | undefined : V extends ExtractDescriptor ? V['value'] extends infer U ? U extends ExtractMap ? ExtractedMap<U> | undefined : U extends ExtractDescriptorFn ? ReturnType<U> | undefined : string | undefined : never : never;
+type ExtractedMap<M extends ExtractMap> = {
+    [key in keyof M]: ExtractedValue<M[key]>;
+};
+type ExtractionDescriptor = ExtractDescriptor;
+type ExtractionMap = ExtractMap;
+type ExtractionResult<M extends ExtractMap> = ExtractedMap<M>;
+interface EncodingOptions {
+    defaultEncoding?: string;
+    transportLayerEncodingLabel?: string | null;
+    userEncoding?: string;
+    maxBytes?: number;
+}
+interface DecodeStreamOptions extends CheerioOptions {
+    encoding?: EncodingOptions;
+}
+/** Structural Node/Undici FormData compatibility without importing its package. */
+interface FormDataLike extends Iterable<[string, string | node_buffer.Blob]> {
+    append(name: string, value: unknown, filename?: string): void;
+    get(name: string): string | node_buffer.Blob | null;
+}
+interface CheerioRequestOptions extends DecodeStreamOptions {
+    requestOptions?: {
+        method?: string;
+        headers?: Record<string, string | string[] | undefined> | string[] | Iterable<[string, string | string[] | undefined]> | Headers | null;
+        body?: string | Buffer | Uint8Array | node_stream.Readable | FormData | FormDataLike | null;
+        query?: node_querystring.ParsedUrlQueryInput;
+        onInfo?: (info: {
+            statusCode: number;
+            headers: Record<string, string | string[]>;
+        }) => void;
+        reset?: boolean;
+        typeOfService?: number | null;
+        highWaterMark?: number;
+        maxRedirections?: number;
+        throwOnError?: boolean;
+        signal?: unknown;
+        headersTimeout?: number | null;
+        bodyTimeout?: number | null;
+        dispatcher?: unknown;
+        [key: string]: unknown;
+    };
+}
+interface ParallelOptions extends CheerioOptions {
+    threads?: number;
+}
+type SerializedField = {
+    name: string;
+    value: string;
+};
+
+export { type AcceptedElems as A, type BasicAcceptedElems as B, type CheerioOptions as C, type DataNode as D, type Element as E, type FilterFunction as F, type ParserErrorHandler as G, type HTMLParser2Options as H, type InternalOptions as I, type ProcessingInstruction as J, type SerializedField as K, type LoadContent as L, type SourceCodeLocation as M, type NamespaceURI as N, type Text as O, type ParallelOptions as P, type Tokenizer as Q, type TokenizerCallbacks as R, type SelectorType as S, type TagSourceCodeLocation as T, type TokenizerConstructor as U, type TokenizerOptions as V, type TreeAdapter as W, type TreeAdapterAttribute as X, type NativeWorkerPoolInfo as Y, type NativeDocument as Z, nativeStatus as _, type CheerioAPI as a, type AcceptedFilters as b, type AnyNode as c, type CDATA as d, Cheerio as e, type CheerioRequestOptions as f, type ChildNode as g, type Comment as h, type DecodeStreamOptions as i, type Document as j, type DocumentMode as k, ElementType as l, type EncodingOptions as m, type ExtractDescriptor as n, type ExtractMap as o, type ExtractedMap as p, type ExtractedValue as q, type ExtractionDescriptor as r, type ExtractionMap as s, type ExtractionResult as t, type FormDataLike as u, type Node as v, type NodeWithChildren as w, type ParentNode as x, type ParserError as y, type ParserErrorCode as z };