rusteerio 0.0.0-stage → 0.1.0

package/src/selection.ts

@@ -0,0 +1,566 @@
+import type { AnyNode, Document, Element, ParentNode, CheerioAPI, CheerioOptions, AcceptedFilters, BasicAcceptedElems, AcceptedElems, ExtractMap, ExtractedMap } from './types.js';
+import { requireNative, type NativeDocument } from './native.js';
+import { getNode, importNodes, nodeBinding, nodeId, nodeRecord, operation, isTag } from './nodes.js';
+import { installAttributes, type AttributeMethods } from './attributes.js';
+import { extract } from './extract.js';
+import { sameNodeSpace, retainNodes } from './router.js';
+import { parse } from './parse.js';
+const numeric = /^(?:0|[1-9]\d*)$/;
+const isMarkup = (value: string) => /<[a-zA-Z!/?]/.test(value);
+function* customPseudoArguments(selector: string, name: string): Generator<string | undefined> {
+    let attributeDepth = 0;
+    let quote = '';
+    for (let index = 0; index < selector.length; index++) {
+        const character = selector[index];
+        if (character === '\\') {
+            index++;
+            continue;
+        }
+        if (quote) {
+            if (character === quote)
+                quote = '';
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            quote = character;
+            continue;
+        }
+        if (character === '[') {
+            attributeDepth++;
+            continue;
+        }
+        if (character === ']') {
+            attributeDepth--;
+            continue;
+        }
+        if (attributeDepth || character !== ':' || selector[index - 1] === ':')
+            continue;
+        const start = index + 1;
+        let end = start;
+        while (/[\w-]/.test(selector[end] ?? '') && end < selector.length)
+            end++;
+        if (selector.slice(start, end).toLowerCase() !== name.toLowerCase())
+            continue;
+        index = end - 1;
+        if (selector[end] !== '(') {
+            yield undefined;
+            continue;
+        }
+        const argumentStart = end + 1;
+        let depth = 1;
+        let argumentQuote = '';
+        for (end++; end < selector.length; end++) {
+            const next = selector[end];
+            if (next === '\\') {
+                end++;
+                continue;
+            }
+            if (argumentQuote) {
+                if (next === argumentQuote)
+                    argumentQuote = '';
+                continue;
+            }
+            if (next === '"' || next === "'") {
+                argumentQuote = next;
+                continue;
+            }
+            if (next === '(')
+                depth++;
+            else if (next === ')' && --depth === 0)
+                break;
+        }
+        if (depth)
+            continue; // The native selector parser reports malformed syntax.
+        yield selector.slice(argumentStart, end);
+        index = end;
+    }
+}
+/** An array-like selection of stable handles into the Rust document arena. */
+export class Cheerio<T = AnyNode> implements ArrayLike<T>, Iterable<T> {
+    [index: number]: T;
+    /** @internal */ declare _document: NativeDocument;
+    /** @internal */ declare _api: CheerioAPI;
+    /** @internal */ declare _ids: number[];
+    /** @internal */ declare _values: T[] | undefined;
+    /** @internal */ declare _lease: object;
+    declare options: CheerioOptions;
+    declare _root: Cheerio<Document> | null;
+    declare prevObject: Cheerio<any> | undefined;
+    declare length: number;
+    cheerio = '[cheerio object]' as const;
+    constructor(api: CheerioAPI, document: NativeDocument, ids: number[] = [], root: Cheerio<Document> | null = null, options: CheerioOptions = {}, values?: T[]) {
+        Object.defineProperties(this, {
+            _document: { value: document, writable: true, configurable: true },
+            _api: { value: api, writable: true, configurable: true },
+            _ids: { value: ids, writable: true, configurable: true },
+            _values: { value: values, writable: true, configurable: true },
+            _lease: { value: retainNodes(document, ids), writable: true, configurable: true },
+            options: { value: options, writable: true, configurable: true, enumerable: true },
+            _root: { value: root, writable: true, configurable: true, enumerable: true },
+            length: { configurable: true, enumerable: true, get: () => this._values?.length ?? this._ids.length, set: (value: number) => { if (this._values)
+                    this._values.length = value;
+                else
+                    this._ids.length = value; this._lease = retainNodes(document, this._values ? [] : this._ids); } },
+        });
+        delete (this as any).cheerio;
+        return new Proxy(this, {
+            get: (target, property, receiver) => typeof property === 'string' && numeric.test(property)
+                ? (target._values ? target._values[Number(property)] : target._ids[Number(property)] === undefined ? undefined : getNode(document, target._ids[Number(property)]))
+                : Reflect.get(target, property, receiver),
+            set: (target, property, value, receiver) => {
+                if (typeof property === 'string' && numeric.test(property)) {
+                    if (target._values)
+                        target._values[Number(property)] = value;
+                    else {
+                        const id = importNodes(document, [value])[0];
+                        if (id === undefined) {
+                            target._values = target._ids.map((existing) => getNode(document, existing)) as T[];
+                            target._values[Number(property)] = value;
+                        }
+                        else
+                            target._ids[Number(property)] = id;
+                    }
+                    target._lease = retainNodes(document, target._values ? [] : target._ids);
+                    return true;
+                }
+                return Reflect.set(target, property, value, receiver);
+            },
+            has: (target, property) => typeof property === 'string' && numeric.test(property) ? Number(property) < target.length : Reflect.has(target, property),
+            ownKeys: (target) => [...Array.from({ length: target.length }, (_, i) => String(i)), ...Reflect.ownKeys(target)],
+            getOwnPropertyDescriptor: (target, property) => typeof property === 'string' && numeric.test(property) && Number(property) < target.length
+                ? { value: target._values ? target._values[Number(property)] : getNode(document, target._ids[Number(property)]), writable: true, configurable: true, enumerable: true }
+                : Reflect.getOwnPropertyDescriptor(target, property),
+            deleteProperty: (target, property) => {
+                if (typeof property === 'string' && numeric.test(property)) {
+                    if (target._values)
+                        delete target._values[Number(property)];
+                    else
+                        delete target._ids[Number(property)];
+                    target._lease = retainNodes(document, target._values ? [] : target._ids);
+                    return true;
+                }
+                return Reflect.deleteProperty(target, property);
+            },
+        });
+    }
+    /** @internal */ get ids(): number[] { return this._values ? importNodes(this._document, this._values) : this._ids; }
+    /** @internal */ op<R = any>(command: string, args: unknown = {}): R { const values = args as Record<string, unknown>; return operation<R>(this._document, command, { ...values, options: values.options ?? this.options }); }
+    /** @internal */ _query(command: 'select' | 'matches', args: {
+        selector: string;
+        ids?: number[];
+        contexts?: number[];
+        options?: CheerioOptions;
+    }): number[] {
+        const callbacks = Object.entries(this.options.pseudos ?? {}).filter((entry): entry is [
+            string,
+            (element: Element, argument?: string | null) => boolean
+        ] => typeof entry[1] === 'function');
+        if (!callbacks.length)
+            return command === 'select' && !args.options ? this._document.select(args.selector, args.contexts) : this.op(command, args);
+        const pseudoMatches: Record<string, number[]> = {};
+        const candidates = [...new Set([...this._document.select('*'), ...(args.ids ?? []), ...(args.contexts ? this._document.select('*', args.contexts) : [])])];
+        for (const [name, callback] of callbacks) {
+            for (const argument of customPseudoArguments(args.selector, name)) {
+                if (argument !== undefined && callback.length < 2)
+                    throw new Error(`Pseudo-class :${name} doesn't have any arguments`);
+                if (argument === undefined && callback.length >= 2)
+                    throw new Error(`Pseudo-class :${name} requires an argument`);
+                pseudoMatches[`${name}(${argument ?? ''})`] = candidates.filter((id) => callback(getNode(this._document, id) as Element, argument ?? null));
+            }
+        }
+        return this.op(command, { ...args, pseudoMatches });
+    }
+    /** @internal */ _fromIds<R = AnyNode>(ids: number[]): Cheerio<R> {
+        const result = new (this._api.fn.constructor as typeof Cheerio)<R>(this._api, this._document, ids, this._root, this.options);
+        result.prevObject = this;
+        return result;
+    }
+    /** @internal */ _fromValues<R>(values: R[]): Cheerio<R> {
+        const allNodes = values.every((value: any) => value && typeof value === 'object' && typeof value.type === 'string');
+        const result = new (this._api.fn.constructor as typeof Cheerio)<R>(this._api, this._document, allNodes ? importNodes(this._document, values) : [], this._root, this.options, allNodes ? undefined : values);
+        result.prevObject = this;
+        return result;
+    }
+    _make<R>(value: ArrayLike<R> | R | string, context?: BasicAcceptedElems<AnyNode>): Cheerio<R>;
+    _make<R>(value: any, context?: any): Cheerio<R> {
+        const result = typeof value === 'string' || value?.cheerio ? this._api(value, context) : this._fromValues<R>(value == null ? [] : typeof value === 'object' && 'length' in value && !value.type ? Array.from(value) : [value]);
+        result.prevObject = this;
+        return result as Cheerio<R>;
+    }
+    _parse(content: any, options: CheerioOptions, isDocument: boolean, context: ParentNode | null): Document {
+        return parse(content, options, isDocument, context);
+    }
+    _render(content: any): string { return this._document.outerHtml(importNodes(this._document, content)); }
+    /** @internal */ _domIds(content: any, contextId?: number): number[] {
+        if (content == null || content === false)
+            return [];
+        if (typeof content === 'string')
+            return this.op('create', { html: content, contextId, options: this.options });
+        if (content?.cheerio)
+            return content._document && sameNodeSpace(this._document, content._document) ? content.ids : importNodes(this._document, content.toArray());
+        if (typeof content === 'object' && 'length' in content && !content.type)
+            return Array.from(content as ArrayLike<any>).flatMap((item) => this._domIds(item, contextId));
+        return importNodes(this._document, [content]);
+    }
+    _makeDomArray<T extends AnyNode>(this: Cheerio<T>, elem?: BasicAcceptedElems<AnyNode> | BasicAcceptedElems<AnyNode>[], clone?: boolean): AnyNode[];
+    _makeDomArray(this: Cheerio<any>, content: any, clone: any = false): any {
+        const ids = this._domIds(content);
+        return (clone ? this.op<number[]>('clone', { ids, deep: true }) : ids).map((id) => getNode(this._document, id));
+    }
+    find<T extends AnyNode>(this: Cheerio<T>, selectorOrHaystack?: string | Cheerio<Element> | Element): Cheerio<Element>;
+    find(this: Cheerio<any>, selector?: any): any {
+        if (!selector)
+            return this._fromIds([]);
+        if (typeof selector === 'string')
+            return this._findBySelector(selector, Infinity);
+        const ids = importNodes(this._document, selector);
+        return this._fromIds(ids.filter((id) => this.ids.some((container) => this.op<boolean>('contains', { container, contained: id }))));
+    }
+    _findBySelector<T extends AnyNode>(this: Cheerio<T>, selector: string, limit: number): Cheerio<Element>;
+    _findBySelector(this: Cheerio<any>, selector: any, limit: any): any {
+        const ids = this._query('select', { selector, contexts: this.ids });
+        return this._fromIds(Number.isFinite(limit) ? ids.slice(0, limit) : ids);
+    }
+    /** @internal */ _filterIds(ids: number[], selector?: any): number[] {
+        if (!selector)
+            return ids;
+        if (typeof selector === 'string')
+            return this._query('matches', { ids, selector, options: this.options });
+        return ids.filter((id, index) => this._predicate(selector, getNode(this._document, id), index));
+    }
+    /** @internal */ _predicate(selector: any, node: any, index: number): boolean {
+        if (typeof selector === 'function')
+            return !!selector.call(node, index, node);
+        if (typeof selector === 'string')
+            return this._query('matches', { ids: importNodes(this._document, [node]), selector, options: this.options }).length > 0;
+        if (selector?.cheerio)
+            return selector.toArray().includes(node);
+        return node === selector;
+    }
+    /** @internal */ _traverse(kind: string, selector?: any): Cheerio<Element> {
+        let ids = this.op<number[]>('traverse', { ids: this.ids, kind });
+        ids = this._filterIds(ids, selector);
+        if (this.length > 1 && ids.length > 1) {
+            if (kind === 'parents' || kind === 'siblings')
+                ids = this.op('uniqueSort', { ids });
+            else if (!['next', 'prev', 'contents'].includes(kind))
+                ids = [...new Set(ids)];
+            if (kind === 'parents')
+                ids.reverse();
+        }
+        return this._fromIds(ids);
+    }
+    parent<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    parent(this: Cheerio<any>, selector?: any): any { return this._traverse('parent', selector); }
+    parents<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    parents(this: Cheerio<any>, selector?: any): any { return this._traverse('parents', selector); }
+    next<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    next(this: Cheerio<any>, selector?: any): any { return this._traverse('next', selector); }
+    prev<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    prev(this: Cheerio<any>, selector?: any): any { return this._traverse('prev', selector); }
+    nextAll<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    nextAll(this: Cheerio<any>, selector?: any): any { return this._traverse('nextAll', selector); }
+    prevAll<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    prevAll(this: Cheerio<any>, selector?: any): any { return this._traverse('prevAll', selector); }
+    siblings<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    siblings(this: Cheerio<any>, selector?: any): any { return this._traverse('siblings', selector); }
+    children<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>;
+    children(this: Cheerio<any>, selector?: any): any { return this._traverse('children', selector); }
+    contents<T extends AnyNode>(this: Cheerio<T>): Cheerio<AnyNode>;
+    contents(this: Cheerio<any>): any { return this._traverse('contents') as any; }
+    /** @internal */ _until(kind: string, until?: any, filter?: any): Cheerio<Element> {
+        let ids: number[] = [];
+        for (const id of this.ids)
+            for (const candidate of this.op<number[]>('traverse', { ids: [id], kind })) {
+                if (until && this._predicate(until, getNode(this._document, candidate), ids.length))
+                    break;
+                ids.push(candidate);
+            }
+        ids = this._filterIds(ids, filter);
+        if (this.length > 1 && ids.length > 1)
+            ids = kind === 'parents' ? this.op<number[]>('uniqueSort', { ids }).reverse() : [...new Set(ids)];
+        return this._fromIds(ids);
+    }
+    parentsUntil<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | null, filterSelector?: AcceptedFilters<Element>): Cheerio<Element>;
+    parentsUntil(this: Cheerio<any>, until?: any, filter?: any): any { return this._until('parents', until, filter); }
+    nextUntil<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | null, filterSelector?: AcceptedFilters<Element>): Cheerio<Element>;
+    nextUntil(this: Cheerio<any>, until?: any, filter?: any): any { return this._until('nextAll', until, filter); }
+    prevUntil<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | null, filterSelector?: AcceptedFilters<Element>): Cheerio<Element>;
+    prevUntil(this: Cheerio<any>, until?: any, filter?: any): any { return this._until('prevAll', until, filter); }
+    closest<T extends AnyNode>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<AnyNode>;
+    closest(this: Cheerio<any>, selector?: any): any {
+        if (!selector)
+            return this._fromIds([]);
+        const result: number[] = [];
+        for (const id of this.ids) {
+            const record = nodeRecord(this._document, id);
+            const candidates = [...(['tag', 'script', 'style'].includes(record.type) ? [id] : []), ...this.op<number[]>('traverse', { ids: [id], kind: 'parents' })];
+            const match = candidates.find((candidate) => this._predicate(selector, getNode(this._document, candidate), 0));
+            if (match !== undefined && !result.includes(match))
+                result.push(match);
+        }
+        return this._fromIds(result);
+    }
+    each<T>(this: Cheerio<T>, fn: (this: T, i: number, el: T) => void | boolean): Cheerio<T>;
+    each(this: Cheerio<any>, callback: any): any {
+        const length = this.length;
+        for (let i = 0; i < length; i++)
+            if (callback.call(this[i], i, this[i]) === false)
+                break;
+        return this;
+    }
+    map<T, M>(this: Cheerio<T>, fn: (this: T, i: number, el: T) => M[] | M | null | undefined): Cheerio<M>;
+    map<R>(this: Cheerio<any>, callback: any): any {
+        const result: R[] = [];
+        for (let i = 0; i < this.length; i++) {
+            const value = callback.call(this[i], i, this[i]);
+            if (value != null)
+                result.push(...(Array.isArray(value) ? value : [value]));
+        }
+        return this._fromValues(result);
+    }
+    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>;
+    filter<S extends AcceptedFilters<T>>(this: Cheerio<any>, selector: any): any {
+        return (typeof selector === 'string' ? this._fromIds(this._query('matches', { ids: this.ids, selector, options: this.options })) : this._fromValues(this.toArray().filter((node, i) => this._predicate(selector, node, i)))) as any;
+    }
+    filterArray<T>(nodes: T[], match: AcceptedFilters<T>, xmlMode?: boolean, root?: Document): Element[] | T[];
+    filterArray<R>(this: Cheerio<any>, nodes: any, match: any, xmlMode?: any, root?: any): any {
+        const matcher: any = match;
+        if (typeof match !== 'string')
+            return nodes.filter((node: any, index: number) => typeof matcher === 'function' ? matcher.call(node, index, node) : matcher?.cheerio ? matcher.toArray().includes(node) : matcher === node);
+        const document = this?._document ?? nodeBinding(root)?.document ?? nodeBinding(nodes[0])?.document ?? new (requireNative().NativeDocument)('', false);
+        const ids = importNodes(document, nodes);
+        const selected = new Set(operation<number[]>(document, 'matches', { ids, selector: match, options: { xmlMode } }));
+        return nodes.filter((node: any) => { const id = nodeId(node, document); return id !== undefined && selected.has(id); });
+    }
+    not<T extends AnyNode>(this: Cheerio<T>, match: AcceptedFilters<T>): Cheerio<T>;
+    not(this: Cheerio<any>, selector: any): any {
+        if (typeof selector === 'string') {
+            const matched = new Set(this._query('matches', { ids: this.ids, selector, options: this.options }));
+            return this._fromIds(this.ids.filter((id) => !matched.has(id)));
+        }
+        return this._fromValues(this.toArray().filter((node, i) => !this._predicate(selector, node, i)));
+    }
+    is<T>(this: Cheerio<T>, selector?: AcceptedFilters<T>): boolean;
+    is(this: Cheerio<any>, selector?: any): any {
+        return typeof selector === 'string' ? this._query('matches', { ids: this.ids, selector, options: this.options }).length > 0 : !!selector && this.toArray().some((node, i) => this._predicate(selector, node, i));
+    }
+    has(this: Cheerio<AnyNode | Element>, selectorOrHaystack: string | Cheerio<Element> | Element): Cheerio<AnyNode | Element>;
+    has(this: Cheerio<any>, selector: any): any { return this.filter(((_i: number, node: any) => this._make(node).find(selector).length > 0) as any) as Cheerio<T>; }
+    first<T extends AnyNode>(this: Cheerio<T>): Cheerio<T>;
+    first(this: Cheerio<any>): any { return this.length > 1 ? this.slice(0, 1) : this; }
+    last<T>(this: Cheerio<T>): Cheerio<T>;
+    last(this: Cheerio<any>): any { return this.length > 0 ? this.slice(-1) : this; }
+    eq<T>(this: Cheerio<T>, i: number): Cheerio<T>;
+    eq(this: Cheerio<any>, index: any): any {
+        index = +index;
+        if (index === 0 && this.length <= 1)
+            return this;
+        if (index < 0)
+            index += this.length;
+        return this._fromValues(this[index] === undefined ? [] : [this[index]]);
+    }
+    get<T>(this: Cheerio<T>, i: number): T | undefined;
+    get<T>(this: Cheerio<T>): T[];
+    get(this: Cheerio<any>, index?: any): any { return index == null ? this.toArray() : this[index < 0 ? this.length + index : index]; }
+    toArray<T>(this: Cheerio<T>): T[];
+    toArray(this: Cheerio<any>): any { return Array.from({ length: this.length }, (_unused, i) => this[i]); }
+    slice<T>(this: Cheerio<T>, start?: number, end?: number): Cheerio<T>;
+    slice(this: Cheerio<any>, start?: any, end?: any): any { return this._values ? this._fromValues(this._values.slice(start, end)) : this._fromIds(this._ids.slice(start, end)); }
+    end<T>(this: Cheerio<T>): Cheerio<AnyNode>;
+    end(this: Cheerio<any>): any { return this.prevObject ?? this._make([]); }
+    add<S extends AnyNode, T extends AnyNode>(this: Cheerio<T>, other: string | Cheerio<S> | S | S[], context?: Cheerio<S> | string): Cheerio<S | T>;
+    add<R extends AnyNode>(this: Cheerio<any>, other: any, context?: any): any { return this._fromIds(this.op('uniqueSort', { ids: [...this.ids, ...this._api(other, context).ids] })); }
+    addBack<T extends AnyNode>(this: Cheerio<T>, selector?: string): Cheerio<AnyNode>;
+    addBack(this: Cheerio<any>, selector?: any): any { return this.prevObject ? this.add(selector ? this.prevObject.filter(selector) : this.prevObject) as any : this as any; }
+    index<T extends AnyNode>(this: Cheerio<T>, selectorOrNeedle?: string | Cheerio<AnyNode> | AnyNode): number;
+    index(this: Cheerio<any>, selector?: any): any { const haystack = selector == null ? this.parent().children() : typeof selector === 'string' ? this._api(selector) : this; const needle = selector == null || typeof selector === 'string' ? this[0] : selector?.cheerio ? selector[0] : selector; return haystack.toArray().indexOf(needle); }
+    splice(start: number, deleteCount?: number): any[];
+    splice(start: number, deleteCount: number, ...items: any[]): any[];
+    splice(...args: any[]): any[] { return Reflect.apply(Array.prototype.splice, this, args); }
+    [Symbol.iterator](): Iterator<T>;
+    *[Symbol.iterator](): IterableIterator<T> { for (let i = 0; i < this.length; i++)
+        yield this[i]; }
+    /** @internal */ _insert(position: string, content: any[]): this {
+        const targets = this.ids.filter((id) => ['root', 'tag', 'script', 'style', 'cdata'].includes(nodeRecord(this._document, id).type));
+        if (!targets.length)
+            return this;
+        if (typeof content[0] === 'function')
+            return (this as Cheerio<any>).each((index, node: any) => {
+                if (!targets.includes(this.ids[index]))
+                    return;
+                if ((position === 'before' || position === 'after') && nodeRecord(this._document, this.ids[index]).parent == null)
+                    return;
+                const value = content[0].call(node, index, this._document.innerHtml(this.ids[index]));
+                let nodes = this._domIds(value);
+                if (index < this.length - 1)
+                    nodes = this.op('clone', { ids: nodes, deep: true });
+                this.op('insert', { targetIds: [this.ids[index]], nodeIds: nodes, position });
+            }) as this;
+        let nodes = this._domIds(content);
+        if (targets[targets.length - 1] !== this.ids[this.ids.length - 1])
+            nodes = this.op('clone', { ids: nodes, deep: true });
+        this.op('insert', { targetIds: targets, nodeIds: nodes, position });
+        return this;
+    }
+    append<T extends AnyNode>(this: Cheerio<T>, ...elems: [
+        (this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>
+    ] | BasicAcceptedElems<AnyNode>[]): Cheerio<T>;
+    append(this: Cheerio<any>, ...content: any[]): any { return this._insert('append', content); }
+    prepend<T extends AnyNode>(this: Cheerio<T>, ...elems: [
+        (this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>
+    ] | BasicAcceptedElems<AnyNode>[]): Cheerio<T>;
+    prepend(this: Cheerio<any>, ...content: any[]): any { return this._insert('prepend', content); }
+    before<T extends AnyNode>(this: Cheerio<T>, ...elems: [
+        (this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>
+    ] | BasicAcceptedElems<AnyNode>[]): Cheerio<T>;
+    before(this: Cheerio<any>, ...content: any[]): any { return this._insert('before', content); }
+    after<T extends AnyNode>(this: Cheerio<T>, ...elems: [
+        (this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>
+    ] | BasicAcceptedElems<AnyNode>[]): Cheerio<T>;
+    after(this: Cheerio<any>, ...content: any[]): any { return this._insert('after', content); }
+    appendTo<T extends AnyNode>(this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>): Cheerio<T>;
+    appendTo(this: Cheerio<any>, target: any): any { this._api(target).append(this); return this; }
+    prependTo<T extends AnyNode>(this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>): Cheerio<T>;
+    prependTo(this: Cheerio<any>, target: any): any { this._api(target).prepend(this); return this; }
+    /** @internal */ _insertRelative(target: any, position: string): Cheerio<T> {
+        const targets = this._api(target).ids;
+        (this as Cheerio<any>).remove();
+        const inserted: number[] = [];
+        for (const id of targets) {
+            if (nodeRecord(this._document, id).parent == null)
+                continue;
+            const clones = this.op<number[]>('clone', { ids: this.ids, deep: true });
+            this.op('insert', { targetIds: [id], nodeIds: clones, position });
+            inserted.push(...clones);
+        }
+        return this._fromIds(inserted);
+    }
+    insertBefore<T extends AnyNode>(this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>): Cheerio<T>;
+    insertBefore(this: Cheerio<any>, target: any): any { return this._insertRelative(target, 'before'); }
+    insertAfter<T extends AnyNode>(this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>): Cheerio<T>;
+    insertAfter(this: Cheerio<any>, target: any): any { return this._insertRelative(target, 'after'); }
+    remove<T extends AnyNode>(this: Cheerio<T>, selector?: string): Cheerio<T>;
+    remove(this: Cheerio<any>, selector?: any): any { this.op('remove', { ids: selector ? this.filter(selector).ids : this.ids }); return this; }
+    replaceWith<T extends AnyNode>(this: Cheerio<T>, content: AcceptedElems<AnyNode>): Cheerio<T>;
+    replaceWith(this: Cheerio<any>, content: any): any {
+        return this.each((index, node: any) => {
+            if (nodeRecord(this._document, this.ids[index]).parent == null)
+                return;
+            const value = typeof content === 'function' ? content.call(node, index, node) : content;
+            this.op('insert', { targetIds: [this.ids[index]], nodeIds: this._domIds(value), position: 'replace' });
+        });
+    }
+    empty<T extends AnyNode>(this: Cheerio<T>): Cheerio<T>;
+    empty(this: Cheerio<any>): any {
+        for (const id of this.ids)
+            this.op('setNode', { id, field: 'children', value: [] });
+        return this;
+    }
+    html<T extends AnyNode>(this: Cheerio<T>): string | null;
+    html<T extends AnyNode>(this: Cheerio<T>, str: string | Cheerio<T>): Cheerio<T>;
+    html(this: Cheerio<any>, content?: any): any {
+        if (content === undefined)
+            return this.length && ['root', 'tag', 'script', 'style', 'cdata'].includes(nodeRecord(this._document, this.ids[0]).type) ? this._document.innerHtml(this.ids[0]) : null;
+        if (!content?.cheerio) {
+            this.op('html', { ids: this.ids, value: String(content) });
+            return this;
+        }
+        for (const id of this.ids) {
+            const nodes = content?.cheerio ? importNodes(this._document, content.toArray()) : this._domIds(String(content), id);
+            this.op('setNode', { id, field: 'children', value: nodes });
+        }
+        return this;
+    }
+    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>;
+    text(this: Cheerio<any>, content?: any): any {
+        if (content === undefined)
+            return this._document.text(this.ids);
+        if (typeof content !== 'function') {
+            this.op('text', { ids: this.ids, value: String(content) });
+            return this;
+        }
+        for (let i = 0; i < this.ids.length; i++) {
+            const id = this.ids[i];
+            const value = typeof content === 'function' ? content.call(getNode(this._document, id), i, this._document.text([id])) : content;
+            this.op('text', { ids: [id], value: String(value) });
+        }
+        return this;
+    }
+    toString<T extends AnyNode>(this: Cheerio<T>): string;
+    toString(this: Cheerio<any>): any { return this._document.outerHtml(this.ids); }
+    clone<T extends AnyNode>(this: Cheerio<T>): Cheerio<T>;
+    clone(this: Cheerio<any>): any { return this._fromIds(this.op('clone', { ids: this.ids, deep: true })); }
+    /** @internal */ _deepest(id: number, tagsOnly = false): number {
+        for (;;) {
+            const children = this.op<number[]>('traverse', { ids: [id], kind: 'children' });
+            const child = tagsOnly ? children.find((candidate) => nodeRecord(this._document, candidate).type === 'tag') : children[0];
+            if (child === undefined)
+                return id;
+            id = child;
+        }
+    }
+    /** @internal */ _wrap(content: any, inner: boolean): this {
+        const lastParent = (this as Cheerio<any>).parents().last();
+        for (let i = 0; i < this.length; i++) {
+            const id = this.ids[i];
+            const node = getNode(this._document, id);
+            const value = typeof content === 'function' ? content.call(node, i, node) : typeof content === 'string' && !isMarkup(content) ? lastParent.find(content).clone() : content;
+            let wrappers = this._domIds(value);
+            if (i < this.length - 1)
+                wrappers = this.op('clone', { ids: wrappers, deep: true });
+            const wrapper = wrappers[0];
+            if (wrapper === undefined || !['root', 'tag', 'script', 'style'].includes(nodeRecord(this._document, wrapper).type))
+                continue;
+            const deepest = this._deepest(wrapper);
+            if (inner) {
+                if (!['root', 'tag', 'script', 'style', 'cdata'].includes(nodeRecord(this._document, id).type))
+                    continue;
+                const contents = this.op<number[]>('traverse', { ids: [id], kind: 'contents' });
+                this.op('setNode', { id: deepest, field: 'children', value: contents });
+                this.op('setNode', { id, field: 'children', value: [wrapper] });
+            }
+            else if (nodeRecord(this._document, id).parent != null) {
+                this.op('insert', { targetIds: [id], nodeIds: [wrapper], position: 'before' });
+                this.op('setNode', { id: deepest, field: 'children', value: [id] });
+            }
+        }
+        return this;
+    }
+    wrap<T extends AnyNode>(this: Cheerio<T>, wrapper: AcceptedElems<AnyNode>): Cheerio<T>;
+    wrap(this: Cheerio<any>, content: any): any { return this._wrap(content, false); }
+    wrapInner<T extends AnyNode>(this: Cheerio<T>, wrapper: AcceptedElems<AnyNode>): Cheerio<T>;
+    wrapInner(this: Cheerio<any>, content: any): any { return this._wrap(content, true); }
+    unwrap<T extends AnyNode>(this: Cheerio<T>, selector?: string): Cheerio<T>;
+    unwrap(this: Cheerio<any>, selector?: any): any { this.op('remove', { ids: this.parent(selector).not('body').ids, keepChildren: true }); return this; }
+    wrapAll<T extends AnyNode>(this: Cheerio<T>, wrapper: AcceptedElems<T>): Cheerio<T>;
+    wrapAll(this: Cheerio<any>, content: any): any {
+        if (!this.length)
+            return this;
+        const first = this[0];
+        const wrappers = this._make(typeof content === 'function' ? content.call(first, 0, first) : content).insertBefore(first);
+        const root = [...wrappers.ids].reverse().find((id) => nodeRecord(this._document, id).type === 'tag');
+        if (root !== undefined)
+            this.op('insert', { targetIds: [this._deepest(root, true)], nodeIds: this.ids, position: 'append' });
+        return this;
+    }
+    extract<M extends ExtractMap, T extends AnyNode>(this: Cheerio<T>, map: M): ExtractedMap<M>;
+    // A structurally shared object signature breaks recursive enum comparisons
+    // across independent DOM declarations; calls retain the precise overload.
+    extract<M extends ExtractMap, T extends AnyNode>(this: Cheerio<T>, map: M): Record<string, unknown>;
+    extract<M extends ExtractMap>(this: Cheerio<any>, map: any): any { return extract.call(this as any, map) as ExtractedMap<M>; }
+}
+Object.defineProperty(Cheerio.prototype, 'cheerio', { value: '[cheerio object]', writable: true, configurable: true });
+export interface Cheerio<T = AnyNode> extends AttributeMethods<T> {
+}
+installAttributes(Cheerio);
+
+/** @internal */
+export const nativeExtractionMethods = Object.freeze({
+    make: Cheerio.prototype._make,
+    find: Cheerio.prototype._findBySelector,
+    prop: Cheerio.prototype.prop,
+    extract: Cheerio.prototype.extract,
+});

package/src/slim.ts

@@ -0,0 +1,12 @@
+import { load as loadNative, contains, merge } from './index.js';
+import type { CheerioAPI, CheerioOptions, LoadContent } from './types.js';
+
+export { contains, merge };
+export { dom } from './index.js';
+export type * from './types.js';
+export type { Cheerio } from './selection.js';
+
+/** Parser-compatible slim entry point, backed by the native fragment parser. */
+export function load(content: LoadContent, options?: CheerioOptions | null, _isDocument?: boolean): CheerioAPI {
+  return loadNative(content, { ...options, _useHtmlParser2: true }, false);
+}