rusteerio 1.0.1 → 1.1.1

package/native/vendor/html5ever-0.35.0/src/tokenizer/char_ref/mod.rs

@@ -20,6 +20,10 @@ use self::State::*;
 pub(super) use self::Status::*;
 
 //§ tokenizing-character-references
+/// Longest reference body plus semicolon that `resolve_terminated_reference`
+/// looks for; the longest named reference has 32 characters.
+const MAXIMUM_TERMINATED_REFERENCE_LENGTH: usize = 40;
+
 pub(super) struct CharRef {
     /// The resulting character(s)
     pub(super) chars: [char; 2],
@@ -136,6 +140,9 @@ impl CharRefTokenizer {
         tokenizer: &Tokenizer<Sink>,
         input: &BufferQueue,
     ) -> Status {
+        if let Some(status) = self.resolve_terminated_reference(tokenizer, input) {
+            return status;
+        }
         match tokenizer.peek(input) {
             Some('a'..='z' | 'A'..='Z' | '0'..='9') => {
                 self.state = Named;
@@ -152,6 +159,78 @@ impl CharRefTokenizer {
         }
     }
 
+    /// Resolves a reference that ends with a semicolon within the next input
+    /// chunk in one step. Stepping character by character costs a state
+    /// machine round trip and a table lookup per character, which dominates
+    /// pages full of references such as `&nbsp;`. Any other input takes the
+    /// character states, which reach the same result for these references.
+    fn resolve_terminated_reference<Sink: TokenSink>(
+        &mut self,
+        tokenizer: &Tokenizer<Sink>,
+        input: &BufferQueue,
+    ) -> Option<Status> {
+        if tokenizer.reconsume.get() {
+            return None;
+        }
+        let mut chunk = input.peek_front_chunk_mut()?;
+        let bytes = chunk.as_bytes();
+        let semicolon = bytes
+            .iter()
+            .take(MAXIMUM_TERMINATED_REFERENCE_LENGTH)
+            .position(|&byte| byte == b';')?;
+        let body = &bytes[..semicolon];
+        let resolved = match body {
+            [b'#', b'x' | b'X', digits @ ..] => self.accumulate_number(digits, 16),
+            [b'#', digits @ ..] => self.accumulate_number(digits, 10),
+            [first, ..] if first.is_ascii_alphabetic() && body.iter().all(u8::is_ascii_alphanumeric) => {
+                match data::NAMED_ENTITIES.get(&chunk[..=semicolon]) {
+                    Some(&(first, second)) if first != 0 => {
+                        self.result = Some(CharRef {
+                            chars: [from_u32(first).unwrap(), from_u32(second).unwrap()],
+                            num_chars: if second == 0 { 1 } else { 2 },
+                        });
+                        true
+                    },
+                    _ => false,
+                }
+            },
+            _ => false,
+        };
+        if !resolved {
+            return None;
+        }
+        chunk.pop_front(semicolon as u32 + 1);
+        let is_chunk_consumed = chunk.is_empty();
+        drop(chunk);
+        if is_chunk_consumed {
+            input.pop_front();
+        }
+        tokenizer.ignore_lf.set(false);
+        if self.result.is_some() {
+            return Some(Done);
+        }
+        Some(self.finish_numeric(tokenizer))
+    }
+
+    /// Accumulates `digits` as `do_numeric` does, if they are all digits.
+    fn accumulate_number(&mut self, digits: &[u8], base: u32) -> bool {
+        let is_number = !digits.is_empty()
+            && digits
+                .iter()
+                .all(|&digit| char::from(digit).is_digit(base));
+        if !is_number {
+            return false;
+        }
+        for &digit in digits {
+            self.num = self.num.wrapping_mul(base);
+            if self.num > 0x10FFFF {
+                self.num_too_big = true;
+            }
+            self.num = self.num.wrapping_add(char::from(digit).to_digit(base).unwrap());
+        }
+        true
+    }
+
     fn do_octothorpe<Sink: TokenSink>(
         &mut self,
         tokenizer: &Tokenizer<Sink>,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rusteerio",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Cheerio-compatible HTML processing with a Rust engine and parallel, non-blocking extraction",
   "license": "MIT",
   "repository": {
@@ -97,6 +97,8 @@
     "test:package": "node scripts/test-package.mjs",
     "bench:engine": "node bench/engine.mjs",
     "bench:fair": "node --expose-gc bench/fair.mjs",
+    "bench:operations": "node bench/operations.mjs",
+    "bench:gate": "node bench/gate.mjs",
     "release:check": "node scripts/check-release.mjs",
     "notices:generate": "node scripts/generate-notices.mjs",
     "notices:check": "node scripts/generate-notices.mjs --check"

package/src/attributes.ts

@@ -1,7 +1,8 @@
-import type { AnyNode, Element, SerializedField } from './types.js';
+import type { AnyNode, CheerioOptions, Element, SerializedField } from './types.js';
 import type { Cheerio } from './selection.js';
 import type { NativeDocument } from './native.js';
 import { getNode, hydrateLocation, importNodes, nodeRecord } from './nodes.js';
+import { attributeAt, DOCUMENT, plainSnapshot, recordAt, VIEW_LOCAL, VIEW_SELF, VIEW_STATE, type DocumentState } from './router.js';
 
 export interface StyleProp {
   length: number;
@@ -44,21 +45,55 @@ export interface AttributeMethods<T = AnyNode> {
 
 type Selection = Cheerio<AnyNode>;
 type DataRecord = Record<string, unknown>;
-type DataCache = Map<number, WeakRef<DataRecord>>;
 type DataDocument = NativeDocument & {
-  nodeSpace?: object;
   retainNodeData?: (id: number, data: DataRecord) => void;
   nodeData?: (id: number) => DataRecord | undefined;
   nodeDataOperation?: (id: number) => (command: string, args: unknown) => unknown;
 };
-const dataObjects = new WeakMap<object, DataCache>();
-const dataFinalizer = new FinalizationRegistry<{ cache: WeakRef<DataCache>; id: number; reference: WeakRef<DataRecord> }>(({ cache, id, reference }) => {
-  const records = cache.deref();
-  if (records?.get(id) === reference) records.delete(id);
-});
+
+const elementTypes = new Set(['tag', 'script', 'style']);
+/** Boolean attributes read as their name in HTML, matched case-insensitively as Cheerio does. */
+const booleanAttribute = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i;
+
+const absent = Symbol('absent');
+const deferred = Symbol('deferred');
+
+/**
+ * Reads an attribute of the selection's first node, as Cheerio reads it from
+ * `this[0]`, from cached records; `deferred` leaves the read to the native
+ * `attr` operation and `absent` means there is no such attribute.
+ */
+function readAttribute(selection: Selection, name: string): string | typeof absent | typeof deferred {
+  const node = selection[0] as unknown as Record<string | symbol, unknown> | null | undefined;
+  if (typeof node !== 'object' || node === null) return absent;
+  const state = node[VIEW_STATE] as DocumentState | undefined;
+  if (state === undefined || node[VIEW_SELF] !== node) return typeof node.type === 'string' ? deferred : absent;
+  const local = node[VIEW_LOCAL] as number;
+  const snapshot = plainSnapshot(state, local);
+  const record = snapshot ? undefined : recordAt(state, local);
+  const type = snapshot ? snapshot.typeOf(local) : record?.type;
+  if (type === undefined || !elementTypes.has(type)) return absent;
+  const value = attributeAt(state, local, name);
+  if (value === undefined) {
+    // Snapshot attributes are all strings; a record may hold another value, which the native read interprets.
+    const attributes = record?.attribs as Record<string, unknown> | undefined;
+    if (attributes && Object.hasOwn(attributes, name)) return deferred;
+    return name === 'value' ? deferred : absent;
+  }
+  const options = selection.options ?? {};
+  const isXml = options.xmlMode ?? (options.xml === true || (typeof options.xml === 'object' && options.xml !== null));
+  return !isXml && booleanAttribute.test(name) ? name : value;
+}
+
+/** Writes one attribute through the routed document's typed path when it has one. */
+function setAttribute(selection: Selection, ids: number[], name: string, value: string | null): void {
+  const document = selection[DOCUMENT] as NativeDocument & { setAttribute?(ids: number[], name: string, value: string | null): void };
+  if (document.setAttribute) document.setAttribute(ids, name, value);
+  else selection.op('attr', { ids, name, value });
+}
 
 function isElement(selection: Selection, id: number): boolean {
-  return ['tag', 'script', 'style'].includes(nodeRecord(selection._document, id)?.type);
+  return ['tag', 'script', 'style'].includes(nodeRecord(selection[DOCUMENT], id)?.type);
 }
 
 function nativeValue(value: unknown): unknown {
@@ -84,20 +119,12 @@ function hydrateValue(value: any): any {
 }
 
 function dataObject(selection: Selection, id: number): Record<string, unknown> {
-  // Routed documents share a stable handle space. Moving a native node between
-  // documents therefore preserves data identities and callback references.
-  const document = selection._document as DataDocument;
-  const cacheKey = document.nodeSpace ?? document;
-  let documents = dataObjects.get(cacheKey);
-  if (!documents) dataObjects.set(cacheKey, documents = new Map());
-  const existingReference = documents.get(id);
-  let data = existingReference?.deref() ?? document.nodeData?.(id);
+  // The router stores data per node and carries it along when a node moves
+  // between documents, preserving data identities and callback references.
+  const document = selection[DOCUMENT] as DataDocument;
+  let data = document.nodeData?.(id);
   if (!data) {
-    const documentReference = new WeakRef(document);
-    const dispatch = document.nodeDataOperation?.(id) ?? ((command: string, args: unknown) => {
-      const document = documentReference.deref();
-      return document ? JSON.parse(document.op(command, JSON.stringify(args))) : undefined;
-    });
+    const dispatch = document.nodeDataOperation?.(id) ?? ((command: string, args: unknown) => JSON.parse(document.op(command, JSON.stringify(args))));
     const target: Record<string, unknown> = {};
     data = new Proxy(target, {
       set(object, name, value) {
@@ -116,29 +143,27 @@ function dataObject(selection: Selection, id: number): Record<string, unknown> {
         return true;
       },
     });
-    const node = getNode(selection._document, id);
-    // JS data can contain callbacks, cycles, and object identities. The DOM and
-    // parsed data values live in Rust; this handle preserves those JS values.
-    Object.defineProperty(node, 'data', { configurable: true, enumerable: true, get: () => data, set: (value: Record<string, unknown>) => { for (const key of Object.keys(data!)) delete data![key]; for (const key of Object.keys(value ?? {})) data![key] = value[key]; } });
+    document.retainNodeData?.(id, data);
   }
-  if (existingReference?.deref() !== data) {
-    const reference = new WeakRef(data);
-    documents.set(id, reference);
-    dataFinalizer.register(data, { cache: new WeakRef(documents), id, reference });
+  const node = getNode(selection[DOCUMENT], id);
+  // JS data can contain callbacks, cycles, and object identities. The DOM and
+  // parsed data values live in Rust; the node exposes the JS values.
+  if (!Object.hasOwn(node, 'data')) {
+    const values = data;
+    Object.defineProperty(node, 'data', { configurable: true, enumerable: true, get: () => values, set: (value: Record<string, unknown>) => { for (const key of Object.keys(values)) delete values[key]; for (const key of Object.keys(value ?? {})) values[key] = value[key]; } });
   }
-  document.retainNodeData?.(id, data);
   return data;
 }
 
 function property(selection: Selection, id: number, name: string, raw = false): any {
   const result = selection.op('prop', { ids: [id], name, ...(raw ? { raw: true } : {}) });
   if (name === 'sourceCodeLocation') return hydrateLocation(result);
-  return result?.__nativeNodeProperty ? (getNode(selection._document, id) as any)[result.__nativeNodeProperty] : result === null ? undefined : result;
+  return result?.__nativeNodeProperty ? (getNode(selection[DOCUMENT], id) as any)[result.__nativeNodeProperty] : result === null ? undefined : result;
 }
 
 function propertyValue(selection: Selection, name: string, value: any): any {
-  if (name === 'children' || name === 'childNodes') return importNodes(selection._document, value);
-  if (['parent', 'parentNode', 'prev', 'previousSibling', 'next', 'nextSibling'].includes(name)) return value == null ? null : importNodes(selection._document, [value])[0] ?? null;
+  if (name === 'children' || name === 'childNodes') return importNodes(selection[DOCUMENT], value);
+  if (['parent', 'parentNode', 'prev', 'previousSibling', 'next', 'nextSibling'].includes(name)) return value == null ? null : importNodes(selection[DOCUMENT], [value])[0] ?? null;
   return value;
 }
 
@@ -148,22 +173,27 @@ function attr(this: Selection, name?: any, value?: any): any {
       if (typeof name !== 'string') throw new Error('Bad combination of arguments.');
       this.ids.forEach((id, index) => {
         if (!isElement(this, id)) return;
-        const node = getNode(this._document, id) as Element;
+        const node = getNode(this[DOCUMENT], id) as Element;
         const current = node.attribs[name];
         const next = value.call(node, index, current);
-        this.op('attr', { ids: [id], name, value: next === null ? null : String(next) });
+        setAttribute(this, [id], name, next === null ? null : String(next));
       });
     } else if (typeof name === 'object') {
-      for (const key of Object.keys(name)) this.op('attr', { ids: this.ids, name: key, value: name[key] === null ? null : String(name[key]) });
+      for (const key of Object.keys(name)) setAttribute(this, this.ids, key, name[key] === null ? null : String(name[key]));
     } else {
-      this.op('attr', { ids: this.ids, name, value: value === null ? null : String(value) });
+      setAttribute(this, this.ids, name, value === null ? null : String(value));
     }
     return this;
   }
   if (arguments.length > 1) return this;
+  if (typeof name === 'string') {
+    const cached = readAttribute(this, name);
+    if (cached === absent) return undefined;
+    if (cached !== deferred) return cached;
+  }
   const result = this.op('attr', { ids: this.ids, ...(typeof name === 'string' ? { name } : {}) });
   if (result === null) return undefined;
-  return !name && this.ids.length ? (getNode(this._document, this.ids[0]) as Element).attribs : result;
+  return !name && this.ids.length ? (getNode(this[DOCUMENT], this.ids[0]) as Element).attribs : result;
 }
 
 function prop(this: Selection, name: any, value?: any): any {
@@ -173,7 +203,7 @@ function prop(this: Selection, name: any, value?: any): any {
       if (typeof name === 'object') throw new TypeError('Bad combination of arguments.');
       this.ids.forEach((id, index) => {
         if (!isElement(this, id)) return;
-        const next = value.call(getNode(this._document, id), index, property(this, id, name, true));
+        const next = value.call(getNode(this[DOCUMENT], id), index, property(this, id, name, true));
         this.op('prop', { ids: [id], name, value: propertyValue(this, name, next) });
       });
     } else if (typeof name === 'object') {
@@ -218,7 +248,7 @@ function css(this: Selection, name?: any, value?: any): any {
           for (const id of this.ids) {
             if (!isElement(this, id)) continue;
             const current = this.op('css', { ids: [id], name: key }) ?? undefined;
-            const next = name[key].call(getNode(this._document, id), propertyIndex, current);
+            const next = name[key].call(getNode(this[DOCUMENT], id), propertyIndex, current);
             this.op('css', { ids: [id], name: key, value: next == null ? null : String(next) });
           }
         } else this.op('css', { ids: this.ids, name: key, value: name[key] == null ? null : String(name[key]) });
@@ -227,7 +257,7 @@ function css(this: Selection, name?: any, value?: any): any {
       this.ids.forEach((id, index) => {
         if (!isElement(this, id)) return;
         const current = this.op('css', { ids: [id], name }) ?? undefined;
-        const next = value.call(getNode(this._document, id), index, current);
+        const next = value.call(getNode(this[DOCUMENT], id), index, current);
         this.op('css', { ids: [id], name, value: next == null ? null : String(next) });
       });
     } else if (typeof name === 'string') this.op('css', { ids: this.ids, name, value: value == null ? null : String(value) });
@@ -241,7 +271,7 @@ function classMethod(command: 'addClass' | 'removeClass' | 'toggleClass') {
     if (typeof name === 'function') {
       this.ids.forEach((id, index) => {
         if (!isElement(this, id)) return;
-        const node = getNode(this._document, id) as Element;
+        const node = getNode(this[DOCUMENT], id) as Element;
         const next = command === 'toggleClass'
           ? name.call(node, index, node.attribs.class ?? '', state)
           : name.call(node, index, node.attribs.class ?? '');
@@ -257,7 +287,11 @@ function classMethod(command: 'addClass' | 'removeClass' | 'toggleClass') {
 export function installAttributes(CheerioClass: { prototype: object }): void {
   Object.assign(CheerioClass.prototype, {
     attr, prop, data, css,
-    removeAttr(this: Selection, name: string) { this.op('removeAttr', { ids: this.ids, name }); return this; },
+    removeAttr(this: Selection, name: string) {
+      const ids = this.ids;
+      for (const single of String(name).split(/\s+/)) if (single) setAttribute(this, ids, single, null);
+      return this;
+    },
     hasClass(this: Selection, name: string) { return this.op<boolean>('hasClass', { ids: this.ids, name }); },
     addClass: classMethod('addClass'), removeClass: classMethod('removeClass'), toggleClass: classMethod('toggleClass'),
     val(this: Selection, value?: unknown) {

package/src/codec.ts

@@ -48,7 +48,6 @@ export function decodeString(value: string): string {
 
 // Transform JSON string tokens rather than the whole JSON text: JSON.stringify
 // escapes lone surrogates, while a literal backslash-u sequence is plain data.
-const stringToken = /"(?:[^"\\]|\\[\s\S])*"/g;
 const encodeJsonCandidate = /[\ud800-\ue800]|\\u(?:d[89a-f][\da-f]{2}|e[0-8][\da-f]{2})/i;
 const escapedJsonCandidate = /\\u(?:d[89a-f][\da-f]{2}|e[0-8][\da-f]{2})/i;
 const decodeJsonCandidate = /[\ue000-\ue800]|\\ue[0-8][\da-f]{2}/i;
@@ -56,11 +55,31 @@ const decodeJsonCandidate = /[\ue000-\ue800]|\\ue[0-8][\da-f]{2}/i;
 export function encodeJson(value: string): string {
   if (!encodeJsonCandidate.test(value)) return value;
   if (isWellFormed?.call(value) && !encoded.test(value) && !escapedJsonCandidate.test(value)) return value;
-  return value.replace(stringToken, (token) => JSON.stringify(encodeString(JSON.parse(token))));
+  return mapJsonStrings(value, encodeString);
 }
 
 export function decodeJson(value: string): string {
-  return decodeJsonCandidate.test(value) ? value.replace(stringToken, (token) => JSON.stringify(decodeString(JSON.parse(token)))) : value;
+  return decodeJsonCandidate.test(value) ? mapJsonStrings(value, decodeString) : value;
+}
+
+/**
+ * Replaces every string token of the JSON text `json` with `transform` of its
+ * value, in one left-to-right pass. A regular expression scanning for tokens
+ * retries from every quote of an unterminated token, which is quadratic.
+ */
+function mapJsonStrings(json: string, transform: (value: string) => string): string {
+  const parts: string[] = [];
+  let copied = 0;
+  let quote = json.indexOf('"');
+  while (quote !== -1) {
+    let end = quote + 1;
+    while (end < json.length && json.charCodeAt(end) !== 0x22) end += json.charCodeAt(end) === 0x5c ? 2 : 1;
+    if (end >= json.length) break;
+    parts.push(json.slice(copied, quote), JSON.stringify(transform(JSON.parse(json.slice(quote, end + 1)))));
+    copied = end + 1;
+    quote = json.indexOf('"', copied);
+  }
+  return copied === 0 ? json : parts.join('') + json.slice(copied);
 }
 
 /** Private parser protocol flag, appended without deserializing large options. */

package/src/extract.ts

@@ -1,6 +1,7 @@
 import { Cheerio, nativeExtractionMethods } from './selection.js';
 import { types } from 'node:util';
 import { compileExtractPlan, hydrateExtractResult } from './extract-plan.js';
+import { writeCount } from './router.js';
 import type { AnyNode, Element, ExtractMap, ExtractedMap, ExtractDescriptor } from './types.js';
 
 export interface ExtractMethods<T = AnyNode> {
@@ -51,12 +52,14 @@ export function extract<M extends ExtractMap>(this: Cheerio<AnyNode>, map: M): E
     const selector = typeof descriptor === 'string' ? descriptor : descriptor.selector;
     const value = typeof descriptor === 'string' ? 'textContent' : descriptor.value ?? 'textContent';
     const selection = this._findBySelector(selector, all ? Infinity : 1);
+    const rows = typeof value === 'object' ? nativeRows(this, key, all, selector, value) : undefined;
     const read = (index: number) => {
       if (typeof value === 'function') return value(selection[index] as Element, key, result);
       const scope = this._make === nativeExtractionMethods.make
         ? this._fromIds([selection.ids[index]])
         : this._make(selection[index]);
-      return typeof value === 'string' ? scope.prop(value) : scope.extract(value);
+      if (typeof value === 'string') return scope.prop(value);
+      return rows ? completeRow(scope, value, rows, index) : scope.extract(value);
     };
     let extracted: unknown;
     if (all) {
@@ -74,6 +77,84 @@ export function extract<M extends ExtractMap>(this: Cheerio<AnyNode>, map: M): E
   return result as ExtractedMap<M>;
 }
 
+/** Fields of each row that the native engine extracts, for every row in one call. */
+interface NativeRows { keys: Set<string>; rows: Record<string, unknown>[]; writes: number }
+
+/**
+ * For a nested map with callbacks, extracts the fields the native engine can
+ * for every matched element in one call, instead of one call per element;
+ * the remaining fields are then filled in map order, so each callback sees
+ * exactly the fields before it, as in Cheerio.
+ */
+function nativeRows(scope: Cheerio<AnyNode>, key: string, all: boolean, selector: string, map: ExtractMap): NativeRows | undefined {
+  const keys = plainKeys(map);
+  if (!keys || scope._make !== nativeExtractionMethods.make || scope._findBySelector !== nativeExtractionMethods.find || scope.prop !== nativeExtractionMethods.prop || scope.extract !== nativeExtractionMethods.extract) return undefined;
+  const subset: ExtractMap = Object.create(null);
+  const nativeKeys = new Set<string>();
+  for (const name of keys) {
+    const slot = Object.getOwnPropertyDescriptor(map, name);
+    if (!slot || !slot.enumerable || !('value' in slot)) continue;
+    const single: ExtractMap = Object.create(null);
+    Object.defineProperty(single, name, { value: slot.value, enumerable: true, configurable: true });
+    if (!compileExtractPlan(single, scope.options)) continue;
+    Object.defineProperty(subset, name, { value: slot.value, enumerable: true, configurable: true });
+    nativeKeys.add(name);
+  }
+  if (!nativeKeys.size || nativeKeys.size === keys.length) return undefined;
+  const outer: ExtractMap = Object.create(null);
+  Object.defineProperty(outer, key, { value: all ? [{ selector, value: subset }] : { selector, value: subset }, enumerable: true, configurable: true });
+  const plan = compileExtractPlan(outer, scope.options);
+  if (!plan) return undefined;
+  const writes = writeCount();
+  const values = scope.op<Record<string, unknown>>('extractPlan', { ids: scope.ids, plan });
+  hydrateExtractResult(values, plan.entries);
+  const extracted = values[key];
+  const rows = (all ? extracted : extracted === undefined ? [] : [extracted]) as Record<string, unknown>[];
+  return Array.isArray(rows) ? { keys: nativeKeys, rows, writes } : undefined;
+}
+
+/**
+ * Builds row `index` of a nested map from its native fields and the scope's
+ * JavaScript fields. Native fields extracted before a callback changed any
+ * document are extracted again, as extracting row by row would see them.
+ */
+function completeRow(scope: Cheerio<AnyNode>, map: ExtractMap, rows: NativeRows, index: number): Record<string, unknown> {
+  const row: Record<string, unknown> = {};
+  const native = rows.rows[index] ?? {};
+  for (const name in map) {
+    if (rows.keys.has(name) && writeCount() === rows.writes) { row[name] = native[name]; continue; }
+    const entry: ExtractMap = Object.create(null);
+    Object.defineProperty(entry, name, { value: map[name], enumerable: true, configurable: true });
+    fillEntries(scope, entry, row);
+  }
+  return row;
+}
+
+/** Extracts `map`'s entries into `result`, which callbacks receive as built so far. */
+function fillEntries(scope: Cheerio<AnyNode>, map: ExtractMap, result: Record<string, unknown>): void {
+  for (const key in map) {
+    const entry = map[key];
+    const all = Array.isArray(entry);
+    const descriptor = (all ? entry[0] : entry) as string | ExtractDescriptor;
+    const selector = typeof descriptor === 'string' ? descriptor : descriptor.selector;
+    const value = typeof descriptor === 'string' ? 'textContent' : descriptor.value ?? 'textContent';
+    const selection = scope._findBySelector(selector, all ? Infinity : 1);
+    const read = (index: number) => {
+      if (typeof value === 'function') return value(selection[index] as Element, key, result);
+      const child = scope._make === nativeExtractionMethods.make ? scope._fromIds([selection.ids[index]]) : scope._make(selection[index]);
+      return typeof value === 'string' ? child.prop(value) : child.extract(value);
+    };
+    if (all) {
+      const values: unknown[] = [];
+      for (let index = 0; index < selection.length; index += 1) {
+        const extracted = read(index);
+        if (extracted != null) values.push(...(Array.isArray(extracted) ? extracted : [extracted]));
+      }
+      result[key] = values;
+    } else result[key] = selection.length ? read(0) : undefined;
+  }
+}
+
 export function installExtract(CheerioClass: { prototype: object }): void {
   Object.assign(CheerioClass.prototype, { extract });
 }
@@ -104,6 +185,7 @@ export async function extractCooperatively<M extends ExtractMap>(selection: Chee
       const selector = typeof descriptor === 'string' ? descriptor : descriptor.selector;
       const value = typeof descriptor === 'string' ? 'textContent' : descriptor.value ?? 'textContent';
       const found = scope._findBySelector(selector, all ? Infinity : 1);
+      const rows = typeof value === 'object' ? nativeRows(scope, key, all, selector, value) : undefined;
       const output: unknown[] = [];
       let single: unknown;
       const count = all ? found.length : Math.min(found.length, 1);
@@ -117,7 +199,9 @@ export async function extractCooperatively<M extends ExtractMap>(selection: Chee
           const child = scope._make === nativeExtractionMethods.make
             ? scope._fromIds([found.ids[index]])
             : scope._make(found[index]);
-          extracted = typeof value === 'string' ? child.prop(value) : child.extract === nativeExtractionMethods.extract ? (await walk(child, value)).value : child.extract(value);
+          extracted = typeof value === 'string' ? child.prop(value)
+            : rows ? completeRow(child, value, rows, index)
+            : child.extract === nativeExtractionMethods.extract ? (await walk(child, value)).value : child.extract(value);
         }
         if (all) { if (extracted != null) output.push(...(Array.isArray(extracted) ? extracted : [extracted])); }
         else single = extracted;