rusteerio 1.1.1 → 1.1.3

package/src/router.ts

@@ -78,6 +78,8 @@ export interface DocumentState {
   collectionRetries: number;
   /** Whether a collection was due but the document left the pending list; its next use schedules it again. */
   isCollectionEvicted: boolean;
+  /** Whether the native document holds a snapshot built while parsing, valid until the first write. */
+  hasPreparedSnapshot: boolean;
   leases: Set<Lease>;
   /** Lease count at which released leases are swept. */
   leaseSweepSize: number;
@@ -218,7 +220,7 @@ export function stateFor(raw: NativeDocument, options: CheerioOptions = {}): Doc
     raw: raw as ManagedNativeDocument, base: index * STRIDE, space: registry.space, options, rootLocal: undefined, routed: undefined,
     // Sized up front: node objects are cached out of order, and regrowing a holey array is costly.
     generation: 0, records: [], bulk: 0, snapshotSize: 0, stale: new Set(), views: new Array(baseline), looseViews: new Map(), looseViewLimit: minimumLooseViewLimit, weakViews: new Map(), baseline,
-    leases: new Set(), leaseSweepSize: 64, data: new Map(), isExposed: false, hasChildLists: false, collectionRetries: 0, isCollectionEvicted: false,
+    leases: new Set(), leaseSweepSize: 64, data: new Map(), isExposed: false, hasChildLists: false, collectionRetries: 0, isCollectionEvicted: false, hasPreparedSnapshot: false,
   };
   holder[stateKey] = state;
   return state;
@@ -382,7 +384,7 @@ function readRecord(state: DocumentState, local: number): NativeNodeRecord | nul
     // An unchanged small document is read throughout; after a write, often only a few nodes are.
     const firstSnapshotRead = state.generation === 0 ? size / 100 : 1 + size / 100;
     if (reads >= Math.min(minimumReadsBeforeSnapshot, firstSnapshotRead)) {
-      const snapshot = new NodeSnapshot(state.raw.snapshot());
+      const snapshot = new NodeSnapshot(takePreparedSnapshot(state, true) ?? state.raw.snapshot());
       state.snapshotSize = snapshot.size;
       state.bulk = snapshot;
       const record = snapshot.record(local);
@@ -392,12 +394,69 @@ function readRecord(state: DocumentState, local: number): NativeNodeRecord | nul
   return rawOperation(state.raw, 'node', { id: local });
 }
 
+/**
+ * Lets a routed document nothing has read or changed yet use the snapshot
+ * its native document built while parsing, when its reads first need one.
+ */
+export function usePreparedSnapshot(document: NativeDocument): void {
+  if (!(document instanceof RoutedDocument)) return;
+  const state = document.state;
+  state.hasPreparedSnapshot = state.generation === 0 && state.bulk === 0;
+}
+
+function takePreparedSnapshot(state: DocumentState, isWanted: boolean): NativeSnapshot | undefined {
+  if (!state.hasPreparedSnapshot) return undefined;
+  state.hasPreparedSnapshot = false;
+  return state.raw.takePreparedSnapshot?.(isWanted) ?? undefined;
+}
+
 /** The current snapshot when it holds `local` exactly, so its fields can be read without a record. */
 export function plainSnapshot(state: DocumentState, local: number): NodeSnapshot | undefined {
   const bulk = state.bulk;
   return bulk instanceof NodeSnapshot && !(state.stale.size && state.stale.has(local)) && bulk.isPlain(local) ? bulk : undefined;
 }
 
+/**
+ * The current snapshot when it holds `local`'s type, name, links and
+ * children. Those are kept for every node, also one whose large text or
+ * attributes must be read individually.
+ */
+export function structureSnapshot(state: DocumentState, local: number): NodeSnapshot | undefined {
+  const bulk = state.bulk;
+  return bulk instanceof NodeSnapshot && !(state.stale.size && state.stale.has(local)) && bulk.isPresent(local) ? bulk : undefined;
+}
+
+/** Nodes a JavaScript `text()` reads before leaving larger subtrees to the native engine. */
+const snapshotTextBudget = 256;
+
+/**
+ * The text of a small subtree read from the snapshot, as the native `text`
+ * concatenates it, or `undefined` to ask the native engine. Text too large
+ * for the snapshot is read once per snapshot, so repeated reads do not copy
+ * it out of the native tree again.
+ */
+function textFromSnapshot(state: DocumentState, local: number): string | undefined {
+  let text = '';
+  const stack = [local];
+  for (let visited = 0; stack.length; visited++) {
+    const node = stack.pop()!;
+    const snapshot = structureSnapshot(state, node);
+    if (!snapshot || visited === snapshotTextBudget) return undefined;
+    if (snapshot.isTextAt(node)) {
+      text += snapshot.dataOf(node) ?? largeText(state, snapshot, node);
+      continue;
+    }
+    for (let index = snapshot.childCount(node) - 1; index >= 0; index--) stack.push(snapshot.childAt(node, index));
+  }
+  return text;
+}
+
+function largeText(state: DocumentState, snapshot: NodeSnapshot, local: number): string {
+  let text = snapshot.largeTexts.get(local);
+  if (text === undefined) snapshot.largeTexts.set(local, text = state.raw.text([local]));
+  return text;
+}
+
 /** A string attribute of an element, read like the native `attr` lookup. */
 export function attributeAt(state: DocumentState, local: number, name: string): string | undefined {
   const snapshot = plainSnapshot(state, local);
@@ -409,6 +468,7 @@ export function attributeAt(state: DocumentState, local: number, name: string):
 
 /** Starts a new generation: cached records may no longer match the arena. */
 export function invalidate(state: DocumentState): void {
+  takePreparedSnapshot(state, false);
   state.generation++;
   state.records = [];
   state.bulk = 0;
@@ -417,9 +477,13 @@ export function invalidate(state: DocumentState): void {
 
 /** Discards the records of nodes a write changed without touching the tree's shape. */
 function invalidateNodes(state: DocumentState, locals: number[]): void {
+  takePreparedSnapshot(state, false);
   const isSnapshot = state.bulk instanceof NodeSnapshot;
+  const { records } = state;
   for (const local of locals) {
-    state.records[local] = undefined;
+    // Writing past the end would grow the cache with holes, which V8 turns
+    // into a slow dictionary for far indexes.
+    if (records[local] !== undefined) records[local] = undefined;
     if (isSnapshot) state.stale.add(local);
   }
 }
@@ -652,7 +716,14 @@ export class RoutedDocument implements NativeDocument {
     const found = group.state === this.state ? group.state.raw.select(selector, group.locals) : this.call<number[]>(group.state, 'select', { selector, contexts: group.locals });
     return this.globals(group.state, found);
   }
-  text(ids: number[]): string { return this.groups(ids).map((group) => group.state.raw.text(group.locals)).join(''); }
+  text(ids: number[]): string {
+    if (ids.length === 1) {
+      const state = this.owner(ids[0]);
+      const text = textFromSnapshot(state, ids[0] - state.base);
+      if (text !== undefined) return text;
+    }
+    return this.groups(ids).map((group) => group.state.raw.text(group.locals)).join('');
+  }
   innerHtml(id: number): string {
     const state = this.owner(id);
     const local = id - state.base;
@@ -717,9 +788,14 @@ export class RoutedDocument implements NativeDocument {
         return this.globals(state, inserted);
       }
       const result: number[] = [];
+      const isBesideTarget = args.position === 'before' || args.position === 'after';
       for (let index = 0; index < targets.length; index++) {
         const target = this.owner(targets[index]);
         const targetLocal = targets[index] - target.base;
+        // As the native insert, skip targets that cannot receive nodes before
+        // moving any there: the nodes would leave their document for nothing.
+        const record = recordAt(target, targetLocal);
+        if (!record || !parentTypes.has(record.type) || (isBesideTarget && record.parent == null)) continue;
         const local = this.moveInto(target, nodes, index + 1 < targets.length);
         const inserted = this.call<number[]>(target, command, { ...args, targetIds: [targetLocal], nodeIds: local });
         result.push(...this.globals(target, inserted));

package/src/selection.ts

@@ -483,26 +483,27 @@ export class Cheerio<T = AnyNode> implements ArrayLike<T>, Iterable<T> {
     [Symbol.iterator](): Iterator<T>;
     [Symbol.iterator](): IterableIterator<T> { return this._items()[Symbol.iterator](); }
     /** @internal */ _insert(position: string, content: any[]): this {
+        if (typeof content[0] !== 'function') {
+            // The native insert skips targets that cannot hold children, and
+            // only the last listed target receives the nodes themselves.
+            const ids = this.ids;
+            if (ids.length) this.op('insert', { targetIds: ids, nodeIds: this._domIds(content), position });
+            return 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;
+        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;
     }
     append<T extends AnyNode>(this: Cheerio<T>, ...elems: [
         (this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>

package/src/snapshot.ts

@@ -87,8 +87,12 @@ export class NodeSnapshot {
   private readonly text: string;
   private readonly isEncoded: boolean;
   private readonly names: (string | undefined)[] = [];
+  /** Per interned type: 1 for element types, 2 for root, 3 for text, 0 otherwise. */
+  private readonly typeKinds: (number | undefined)[] = [];
   /** Node object constructors by interned type, resolved once per snapshot. */
   viewConstructors: unknown = undefined;
+  /** Text nodes too large for the arrays, read individually while this snapshot is current. */
+  readonly largeTexts = new Map<number, string>();
 
   constructor(raw: NativeSnapshot) {
     const { data } = raw;
@@ -189,6 +193,39 @@ export class NodeSnapshot {
     return this.nodes[local * STRIDE + 4];
   }
 
+  /** Whether a node is an element: a tag, script or style. */
+  isElementAt(local: number): boolean {
+    return this.typeKind(local) === 1;
+  }
+
+  isRootAt(local: number): boolean {
+    return this.typeKind(local) === 2;
+  }
+
+  isTextAt(local: number): boolean {
+    return this.typeKind(local) === 3;
+  }
+
+  /** Whether a node's record adds fields stored as JSON, such as source locations. */
+  hasExtraFields(local: number): boolean {
+    return this.nodes[local * STRIDE + 14] !== 0;
+  }
+
+  /** Whether the slot holds a node, rather than one a collection released. */
+  isPresent(local: number): boolean {
+    return local < this.size && (this.nodes[local * STRIDE + 10] & RELEASED) === 0;
+  }
+
+  private typeKind(local: number): number {
+    const reference = this.nodes[local * STRIDE];
+    let kind = this.typeKinds[reference];
+    if (kind === undefined) {
+      const type = this.name(reference);
+      kind = this.typeKinds[reference] = type === 'tag' || type === 'script' || type === 'style' ? 1 : type === 'root' ? 2 : type === 'text' ? 3 : 0;
+    }
+    return kind;
+  }
+
   /** The interned reference of a node's type, comparable across nodes of this snapshot. */
   typeReference(local: number): number {
     return this.nodes[local * STRIDE];

package/src/transport.ts

@@ -106,7 +106,7 @@ export function wrapNativeBinding(binding: NativeBinding): NativeBinding {
   if (raw.NativeHookStream) wrapped.NativeHookStream = wrapConstructor(raw.NativeHookStream, ([isDocument, options, bridge]) => [isDocument, encodeOptions(options), wrapBridge(bridge)], wrapStream);
   if (raw.parseWithTreeAdapter) wrapped.parseWithTreeAdapter = (source: string, isDocument: boolean, options: string, bridge: (request: string) => string) => invoke(() => raw.parseWithTreeAdapter(encodeString(source), isDocument, encodeOptions(options), wrapBridge(bridge)));
   if (raw.parseAsync) wrapped.parseAsync = (source, isDocument, options) => invoke(() => raw.parseAsync!(encodeString(source), isDocument, encodeOptions(options)));
-  if (raw.parseManyAsync) wrapped.parseManyAsync = (sources, isDocument, threads, options) => invoke(() => raw.parseManyAsync!(sources.map(encodeString), isDocument, threads, encodeOptions(options)));
+  if (raw.parseManyAsync) wrapped.parseManyAsync = (sources, isDocument, threads, options, plans) => invoke(() => raw.parseManyAsync!(sources.map(encodeString), isDocument, threads, encodeOptions(options), plans === undefined ? undefined : encodeJson(plans)));
   if (raw.extractPlanManyAsync) wrapped.extractPlanManyAsync = async (sources, plan, threads, options) => decodeJson(await invoke(() => raw.extractPlanManyAsync!(sources.map(encodeString), encodeJson(plan), threads, encodeOptions(options))));
   if (raw.extractManyAsync) wrapped.extractManyAsync = async (sources, queries, threads, isDocument, options) => decodeJson(await invoke(() => raw.extractManyAsync!(sources.map(encodeString), queries.map((query) => ({ ...query, key: encodeString(query.key), selector: encodeString(query.selector), ...(query.attr === undefined ? {} : { attr: encodeString(query.attr) }) })), threads, isDocument, encodeOptions(options))));
   return wrapped;