satteri 0.10.5 → 0.11.3

package/dist/hast/hast-reader.js

@@ -1,10 +1,7 @@
-import { restorePhantomSpaces } from "../phantom.js";
-import { readPosition } from "../wire-read.js";
-import { MDX_ATTR_BOOLEAN_PROP, MDX_ATTR_LITERAL_PROP, MDX_ATTR_EXPRESSION_PROP, MDX_ATTR_SPREAD, } from "../op-stream.js";
-import { decodeElementProp } from "./element-props.js";
-import { PoolOffsets } from "../string-pool.js";
+import { ArenaReader } from "../arena-reader.js";
+import { FIELD, KIND_HAST, W_CHILDREN_COUNT, W_CHILDREN_START, W_DATA_LEN, W_DATA_OFFSET, W_PARENT, W_START_OFFSET, } from "../generated/arena-layout.js";
+import { decodeMdxJsxAttr } from "../mdx-attr.js";
 import { NAME_TO_TYPE } from "./generated/node-types.js";
-import { ARENA_MAGIC, KIND_HAST, FIELD, HEADER } from "../generated/arena-layout.js";
 export const HAST_ROOT = NAME_TO_TYPE.root;
 export const HAST_ELEMENT = NAME_TO_TYPE.element;
 export const HAST_TEXT = NAME_TO_TYPE.text;
@@ -16,315 +13,129 @@ export const HAST_MDX_FLOW_EXPRESSION = NAME_TO_TYPE.mdxFlowExpression;
 export const HAST_MDX_ESM = NAME_TO_TYPE.mdxjsEsm;
 export const HAST_MDX_TEXT_EXPRESSION = NAME_TO_TYPE.mdxTextExpression;
 export class HastReader {
-    #view;
-    #header;
-    #textDecoder;
-    #stringPoolCache = null;
-    #poolChecked = false;
-    #poolOffsets = null;
+    #arena;
+    // Typed arrays avoid DataView getter overhead in unoptimized V8 tiers.
+    #u8;
+    #u32;
+    #nodesB;
+    #nodesW;
+    #strideB;
+    #strideW;
+    #childrenW;
+    #typeDataB;
     constructor(buffer) {
-        if (buffer instanceof Uint8Array) {
-            this.#view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        }
-        else {
-            this.#view = new DataView(buffer);
-        }
-        this.#textDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
-        this.#header = this.#readHeader();
-    }
-    #readHeader() {
-        const v = this.#view;
-        const magic = v.getUint32(HEADER.magic, true);
-        if (magic !== ARENA_MAGIC) {
-            throw new Error(`Invalid HAST buffer: bad magic 0x${magic.toString(16)}`);
-        }
-        const kind = v.getUint32(HEADER.kind, true);
-        if (kind !== KIND_HAST) {
-            throw new Error(`HastReader was handed a buffer of kind ${kind} (expected ${KIND_HAST}). ` +
-                `MDAST and HAST node types overlap; reading the wrong kind decodes garbage.`);
-        }
-        return {
-            nodeStructSize: v.getUint32(HEADER.node_struct_size, true),
-            nodeCount: v.getUint32(HEADER.node_count, true),
-            nodesOffset: v.getUint32(HEADER.nodes_offset, true),
-            childrenCount: v.getUint32(HEADER.children_count, true),
-            childrenOffset: v.getUint32(HEADER.children_offset, true),
-            typeDataLen: v.getUint32(HEADER.type_data_len, true),
-            typeDataOffset: v.getUint32(HEADER.type_data_offset, true),
-            stringPoolLen: v.getUint32(HEADER.string_pool_len, true),
-            stringPoolOffset: v.getUint32(HEADER.string_pool_offset, true),
-            nodeDataCount: v.getUint32(HEADER.node_data_count, true),
-            nodeDataOffset: v.getUint32(HEADER.node_data_offset, true),
-        };
-    }
-    #nodeDataTable = null;
-    /**
-     * Per-node JSON `data` blob (set via `Arena::set_node_data` on the Rust
-     * side). Returns `null` when the node has no entry. Lazy-builds a
-     * `Map<id, string>` on first call so a materialization pass on a
-     * data-heavy tree stays O(nodes) rather than O(nodes × entries).
-     */
+        const arena = new ArenaReader(buffer, KIND_HAST);
+        this.#arena = arena;
+        this.#u8 = arena.u8;
+        this.#u32 = arena.u32;
+        const header = arena.header;
+        this.#nodesB = header.nodesOffset;
+        this.#nodesW = header.nodesOffset >> 2;
+        this.#strideB = header.nodeStructSize;
+        this.#strideW = header.nodeStructSize >> 2;
+        this.#childrenW = header.childrenOffset >> 2;
+        this.#typeDataB = header.typeDataOffset;
+    }
+    /** @internal Memoized wire view for the fused decoder. */
+    getWire() {
+        return this.#arena.getWire();
+    }
+    /** Per-node JSON data, or null when absent. */
     getNodeData(nodeId) {
-        if (this.#header.nodeDataCount === 0)
-            return null;
-        if (this.#nodeDataTable === null) {
-            this.#nodeDataTable = new Map();
-            const v = this.#view;
-            let pos = this.#header.nodeDataOffset;
-            for (let i = 0; i < this.#header.nodeDataCount; i++) {
-                const id = v.getUint32(pos, true);
-                pos += 4;
-                const len = v.getUint32(pos, true);
-                pos += 4;
-                const slice = new Uint8Array(this.#view.buffer, this.#view.byteOffset + pos, len);
-                this.#nodeDataTable.set(id, this.#textDecoder.decode(slice));
-                pos += len;
-            }
-        }
-        return this.#nodeDataTable.get(nodeId) ?? null;
+        return this.#arena.getNodeData(nodeId);
+    }
+    /** @internal null when no node carries data. */
+    getNodeDataTable() {
+        return this.#arena.getNodeDataTable();
     }
     get nodeCount() {
-        return this.#header.nodeCount;
+        return this.#arena.header.nodeCount;
     }
     get header() {
-        return { ...this.#header };
+        return { ...this.#arena.header };
     }
-    /** The full string pool (original input + interning heap). Not the document
-     * source as written; for that, read `ctx.source` from a plugin. */
+    /** Full string pool, including interned strings; use ctx.source for the original document. */
     getStringPool() {
-        if (this.#stringPoolCache === null) {
-            const { stringPoolOffset, stringPoolLen } = this.#header;
-            const bytes = new Uint8Array(this.#view.buffer, this.#view.byteOffset + stringPoolOffset, stringPoolLen);
-            this.#stringPoolCache = this.#textDecoder.decode(bytes);
-        }
-        return this.#stringPoolCache;
+        return this.#arena.getStringPool();
     }
-    /** Read a substring from the string pool by byte offset and length. */
+    /** Wire string refs use UTF-16 units, so substring preserves their offsets. */
     getString(offset, len) {
-        if (len === 0)
-            return "";
-        const pool = this.getStringPool();
-        if (!this.#poolChecked) {
-            this.#poolChecked = true;
-            const { stringPoolOffset, stringPoolLen } = this.#header;
-            const extraBytes = stringPoolLen - pool.length;
-            if (extraBytes > 0) {
-                const bytes = new Uint8Array(this.#view.buffer, this.#view.byteOffset + stringPoolOffset, stringPoolLen);
-                this.#poolOffsets = new PoolOffsets(bytes, extraBytes);
-            }
-        }
-        // An all-ASCII pool has byte offsets equal to its UTF-16 indices.
-        const offsets = this.#poolOffsets;
-        return offsets === null
-            ? pool.substring(offset, offset + len)
-            : offsets.slice(pool, offset, len);
+        return this.#arena.getString(offset, len);
     }
-    /** Get position data for a node. */
+    /** A zero start line marks a synthesized node with no source range (unist
+     *  lines are 1-based), surfaced as `undefined`. */
     getPosition(nodeId) {
-        const base = this.#header.nodesOffset + nodeId * this.#header.nodeStructSize;
-        return readPosition(this.#view, base + FIELD.start_offset);
+        const u32 = this.#u32;
+        const b = this.#nodesW + nodeId * this.#strideW + W_START_OFFSET;
+        const startLine = u32[b + 2] ?? 0;
+        if (startLine === 0)
+            return undefined;
+        return {
+            start: { offset: u32[b] ?? 0, line: startLine, column: u32[b + 3] ?? 0 },
+            end: { offset: u32[b + 1] ?? 0, line: u32[b + 4] ?? 0, column: u32[b + 5] ?? 0 },
+        };
     }
     /** Get the node_type byte for a given node ID. */
     getNodeType(nodeId) {
-        const { nodesOffset, nodeStructSize } = this.#header;
-        return this.#view.getUint8(nodesOffset + nodeId * nodeStructSize + FIELD.node_type);
+        return this.#u8[this.#nodesB + nodeId * this.#strideB + FIELD.node_type] ?? 0;
     }
     /** Get the parent id for a given node (0xffffffff at the root). */
     getParentId(nodeId) {
-        const { nodesOffset, nodeStructSize } = this.#header;
-        return this.#view.getUint32(nodesOffset + nodeId * nodeStructSize + FIELD.parent, true);
+        return this.#u32[this.#nodesW + nodeId * this.#strideW + W_PARENT] ?? 0;
+    }
+    getChildrenCount(nodeId) {
+        return this.#u32[this.#nodesW + nodeId * this.#strideW + W_CHILDREN_COUNT] ?? 0;
     }
-    /** Get child node IDs for a given node. */
     getChildIds(nodeId) {
-        const base = this.#header.nodesOffset + nodeId * this.#header.nodeStructSize;
-        const v = this.#view;
-        const childrenStart = v.getUint32(base + FIELD.children_start, true);
-        const childrenCount = v.getUint32(base + FIELD.children_count, true);
+        const u32 = this.#u32;
+        const w = this.#nodesW + nodeId * this.#strideW;
+        const childrenStart = u32[w + W_CHILDREN_START] ?? 0;
+        const childrenCount = u32[w + W_CHILDREN_COUNT] ?? 0;
         if (childrenCount === 0)
             return [];
-        const { childrenOffset } = this.#header;
+        const base = this.#childrenW + childrenStart;
         const ids = [];
         for (let i = 0; i < childrenCount; i++) {
-            ids.push(v.getUint32(childrenOffset + (childrenStart + i) * 4, true));
+            ids.push(u32[base + i] ?? 0);
         }
         return ids;
     }
-    /** Push child node IDs directly onto a stack array (reverse order for depth-first). */
-    pushChildIds(nodeId, stack) {
-        const base = this.#header.nodesOffset + nodeId * this.#header.nodeStructSize;
-        const v = this.#view;
-        const childrenStart = v.getUint32(base + FIELD.children_start, true);
-        const childrenCount = v.getUint32(base + FIELD.children_count, true);
-        if (childrenCount === 0)
-            return;
-        const { childrenOffset } = this.#header;
-        for (let i = childrenCount - 1; i >= 0; i--) {
-            stack.push(v.getUint32(childrenOffset + (childrenStart + i) * 4, true));
-        }
-    }
     /** Get the raw type_data bytes for a node. */
     getTypeData(nodeId) {
-        const base = this.#header.nodesOffset + nodeId * this.#header.nodeStructSize;
-        const v = this.#view;
-        const dataOffset = v.getUint32(base + FIELD.data_offset, true);
-        const dataLen = v.getUint32(base + FIELD.data_len, true);
+        const u32 = this.#u32;
+        const w = this.#nodesW + nodeId * this.#strideW;
+        const dataOffset = u32[w + W_DATA_OFFSET] ?? 0;
+        const dataLen = u32[w + W_DATA_LEN] ?? 0;
         if (dataLen === 0)
             return new Uint8Array(0);
-        return new Uint8Array(this.#view.buffer, this.#view.byteOffset + this.#header.typeDataOffset + dataOffset, dataLen);
+        const start = this.#typeDataB + dataOffset;
+        return this.#u8.subarray(start, start + dataLen);
     }
-    /** Read a StringRef (offset: u32 LE, len: u32 LE) from a byte array at byteOffset. */
-    #readStringRef(data, byteOffset) {
-        const at = data.byteOffset - this.#view.byteOffset + byteOffset;
-        return {
-            offset: this.#view.getUint32(at, true),
-            len: this.#view.getUint32(at + 4, true),
-        };
-    }
-    /**
-     * Get element data for a HAST_ELEMENT node.
-     *
-     * Element type_data layout:
-     *   [tag_name: StringRef(8B)][prop_count: u32(4B)][_pad: u32(4B)] = 16-byte header
-     *   then prop_count * 20 bytes:
-     *     [name: StringRef(8B)][value_type: u8(1B)][_pad: [u8;3](3B)][value: StringRef(8B)]
-     */
     /** Byte position of a node's `type_data`, relative to this reader's view, or
      *  `-1` when the node stores fewer than `min` bytes. */
     #typeDataAt(nodeId, min) {
-        const base = this.#header.nodesOffset + nodeId * this.#header.nodeStructSize;
-        const v = this.#view;
-        if (v.getUint32(base + FIELD.data_len, true) < min)
+        const u32 = this.#u32;
+        const w = this.#nodesW + nodeId * this.#strideW;
+        if ((u32[w + W_DATA_LEN] ?? 0) < min)
             return -1;
-        return this.#header.typeDataOffset + v.getUint32(base + FIELD.data_offset, true);
-    }
-    #stringAt(at) {
-        return this.getString(this.#view.getUint32(at, true), this.#view.getUint32(at + 4, true));
+        return this.#typeDataB + (u32[w + W_DATA_OFFSET] ?? 0);
     }
-    /** @internal Both element fields in one pass; the per-field accessors below
-     *  each re-resolve the node's `type_data` position. */
-    readElementInto(nodeId, node) {
+    /** A zero-length element name represents an MDX fragment. */
+    getMdxJsxElementData(nodeId) {
         const at = this.#typeDataAt(nodeId, 16);
         if (at === -1) {
-            node.tagName = "";
-            node.properties = {};
-            return;
-        }
-        const v = this.#view;
-        node.tagName = this.#stringAt(at);
-        const count = v.getUint32(at + 8, true);
-        const properties = {};
-        for (let i = 0; i < count; i++) {
-            const base = at + 16 + i * 20;
-            properties[this.#stringAt(base)] = decodeElementProp(v.getUint8(base + 8), this.#stringAt(base + 12));
-        }
-        node.properties = properties;
-    }
-    /** Element `tagName`, `properties` count, and the i-th property, read without
-     *  building the intermediate views and records `getElementData` allocates. */
-    getElementTagName(nodeId) {
-        const at = this.#typeDataAt(nodeId, 16);
-        return at === -1 ? "" : this.#stringAt(at);
-    }
-    getElementPropCount(nodeId) {
-        const at = this.#typeDataAt(nodeId, 16);
-        return at === -1 ? 0 : this.#view.getUint32(at + 8, true);
-    }
-    getElementPropName(nodeId, index) {
-        const at = this.#typeDataAt(nodeId, 16);
-        return at === -1 ? "" : this.#stringAt(at + 16 + index * 20);
-    }
-    getElementPropValue(nodeId, index) {
-        const at = this.#typeDataAt(nodeId, 16);
-        if (at === -1)
-            return "";
-        const base = at + 16 + index * 20;
-        return decodeElementProp(this.#view.getUint8(base + 8), this.#stringAt(base + 12));
-    }
-    getElementData(nodeId) {
-        const data = this.getTypeData(nodeId);
-        if (data.length < 16) {
-            return { tagName: "", properties: [] };
-        }
-        const tagRef = this.#readStringRef(data, 0);
-        const tagName = this.getString(tagRef.offset, tagRef.len);
-        const view = new DataView(data.buffer, data.byteOffset + 8);
-        const propCount = view.getUint32(0, true);
-        const properties = [];
-        for (let i = 0; i < propCount; i++) {
-            const base = 16 + i * 20;
-            const nameRef = this.#readStringRef(data, base);
-            const name = this.getString(nameRef.offset, nameRef.len);
-            const valueType = data[base + 8];
-            const valueRef = this.#readStringRef(data, base + 12);
-            const valueStr = this.getString(valueRef.offset, valueRef.len);
-            properties.push({ name, value: decodeElementProp(valueType, valueStr) });
-        }
-        return { tagName, properties };
-    }
-    /**
-     * Get MDX JSX element data: name and attributes.
-     *
-     * MDX JSX element type_data layout:
-     *   [name: StringRef(8B)][attr_count: u32(4B)][_pad: u32(4B)] = 16-byte header
-     *   then attr_count * 20 bytes:
-     *     [kind: u8(1B)][_pad: [u8;3](3B)][name: StringRef(8B)][value: StringRef(8B)]
-     */
-    getMdxJsxElementData(nodeId) {
-        const data = this.getTypeData(nodeId);
-        if (data.length < 16) {
             return { name: null, attributes: [] };
         }
-        const nameRef = this.#readStringRef(data, 0);
-        const name = nameRef.len > 0 ? this.getString(nameRef.offset, nameRef.len) : null;
-        const view = new DataView(data.buffer, data.byteOffset + 8);
-        const attrCount = view.getUint32(0, true);
+        const u32 = this.#u32;
+        const w = at >> 2;
+        const nameLen = u32[w + 1] ?? 0;
+        const name = nameLen > 0 ? this.getString(u32[w] ?? 0, nameLen) : null;
+        const attrCount = u32[w + 2] ?? 0;
         const attributes = [];
         for (let i = 0; i < attrCount; i++) {
-            const base = 16 + i * 20;
-            const kind = data[base];
-            const attrNameRef = this.#readStringRef(data, base + 4);
-            const attrValueRef = this.#readStringRef(data, base + 12);
-            switch (kind) {
-                case MDX_ATTR_BOOLEAN_PROP:
-                    attributes.push({
-                        type: "mdxJsxAttribute",
-                        name: this.getString(attrNameRef.offset, attrNameRef.len),
-                        value: null,
-                    });
-                    break;
-                case MDX_ATTR_LITERAL_PROP:
-                    attributes.push({
-                        type: "mdxJsxAttribute",
-                        name: this.getString(attrNameRef.offset, attrNameRef.len),
-                        value: this.getString(attrValueRef.offset, attrValueRef.len),
-                    });
-                    break;
-                case MDX_ATTR_EXPRESSION_PROP:
-                    attributes.push({
-                        type: "mdxJsxAttribute",
-                        name: this.getString(attrNameRef.offset, attrNameRef.len),
-                        value: {
-                            type: "mdxJsxAttributeValueExpression",
-                            value: restorePhantomSpaces(this.getString(attrValueRef.offset, attrValueRef.len)),
-                        },
-                    });
-                    break;
-                case MDX_ATTR_SPREAD:
-                    attributes.push({
-                        type: "mdxJsxExpressionAttribute",
-                        value: restorePhantomSpaces(this.getString(attrValueRef.offset, attrValueRef.len)),
-                    });
-                    break;
-            }
+            const base = w + 4 + i * 5;
+            attributes.push(decodeMdxJsxAttr(this.#u8[base << 2] ?? 0, this.getString(u32[base + 1] ?? 0, u32[base + 2] ?? 0), this.getString(u32[base + 3] ?? 0, u32[base + 4] ?? 0)));
         }
         return { name, attributes };
     }
-    /**
-     * Get the string value for HAST_TEXT, HAST_COMMENT, or HAST_RAW nodes.
-     * These store a single StringRef (8 bytes) as their type_data.
-     */
-    getTextValue(nodeId) {
-        const at = this.#typeDataAt(nodeId, 8);
-        return at === -1 ? "" : this.#stringAt(at);
-    }
 }

package/dist/hast/hast-visitor.d.ts

@@ -1,18 +1,17 @@
-import { type HastNode } from "./hast-materializer.js";
-import type { HastRaw, Data, SourceFormat } from "../types.js";
-import type { Element, Text, Comment, Doctype, Parents as HastParents, Root as HastRoot } from "hast";
 import type { Program } from "estree-jsx";
-import type { MdxJsxFlowElementHast, MdxJsxTextElementHast } from "../mdx-types.js";
-import type { MdxFlowExpressionHast, MdxTextExpressionHast } from "../mdx-types.js";
-import type { MdxjsEsmHast } from "../mdx-types.js";
-import { type PluginOptions } from "../visitor-shared.js";
+import type { Comment, Doctype, Element, Parents as HastParents, Root as HastRoot, Text } from "hast";
+import type { MdxFlowExpressionHast, MdxjsEsmHast, MdxJsxFlowElementHast, MdxJsxTextElementHast, MdxTextExpressionHast } from "../mdx-types.js";
+import type { Data, HastRaw, SourceFormat } from "../types.js";
+import { type HastNode } from "./hast-materializer.js";
 import type { HastHandle } from "../handles.js";
+import { type PluginOptions, type SettableFieldKey } from "../visitor-shared.js";
 export type { HastHandle };
 /** ESTree-compatible Program node returned by `parseExpression()`. */
 export type EstreeProgram = Program;
 export interface HastDiagnostic {
     message: string;
     nodeId?: number | undefined;
+    position?: HastNode["position"] | undefined;
     severity: "error" | "warning" | "info";
 }
 export interface HastVisitorContext {
@@ -61,6 +60,20 @@ export interface HastVisitorContext {
     insertChildAt(node: Readonly<HastNode>, index: number, childNode: HastContent | HastContent[]): void;
     /** Remove the `index`-th child of `node`; a no-op when there is no such child. */
     removeChildAt(node: Readonly<HastNode>, index: number): void;
+    /** Replace a supported field on the node, including scalars and structured fields. */
+    setField<N extends HastNode, K extends SettableFieldKey<N>>(node: Readonly<N>, key: K, value: Exclude<N[K], undefined>): void;
+    /** `children` is structural and every parent accepts it, including node-type unions. */
+    setField(node: Readonly<HastNode>, key: "children", value: readonly HastContent[]): void;
+    /** `data` is an open per-node bag serialized to JSON. `null` clears it. */
+    setField(node: Readonly<HastNode>, key: "data", value: Record<string, unknown> | null): void;
+    /** Set one entry in an MDX JSX element's `attributes`. */
+    setAttribute(node: Readonly<HastNode>, name: string, value: unknown): void;
+    /**
+     * Set one entry in a hast element's `properties`.
+     *
+     * Using this for node fields or MDX JSX attributes is deprecated; use
+     * `setField` or `setAttribute` respectively.
+     */
     setProperty(node: Readonly<HastNode>, key: string, value: unknown): void;
     /** Collect the concatenated text of all descendant text nodes (like DOM textContent). */
     textContent(node: Readonly<HastNode>): string;
@@ -102,12 +115,19 @@ export interface RawHtmlHastContent {
     /** @deprecated Use the equivalent `{ raw }`. */
     rawHtml: string;
 }
+/**
+ * Encode a standalone HAST tree as an op-stream document: one `root` wrapping
+ * `nodes`, which Rust replays into an arena of its own and serializes. The
+ * bytes are handed to `use` because they are a view into a pooled buffer,
+ * valid only until it is released.
+ */
+export declare function encodeHastDocument<T>(nodes: readonly HastNode[], use: (ops: Uint8Array) => T): T;
 /** A filtered visitor: Rust filters by tag/component name, only matched nodes cross the boundary. */
 export interface HastFilteredVisitor<N extends HastNode = HastNode> {
     filter: string[];
     visit(node: Readonly<N>, ctx: HastVisitorContext): HastNode | void | Promise<HastNode | void>;
 }
-type HastVisitorFn<N extends HastNode = HastNode> = (node: Readonly<N>, ctx: HastVisitorContext) => HastNode | void | Promise<HastNode | void>;
+export type HastVisitorFn<N extends HastNode = HastNode> = (node: Readonly<N>, ctx: HastVisitorContext) => HastNode | void | Promise<HastNode | void>;
 export type HastHookFn = (root: Readonly<HastRoot>, ctx: HastVisitorContext) => void | Promise<void>;
 export interface HastVisitorInstance {
     /** Plugin-level configuration (e.g. `{ position: true }` to read positions). */
@@ -149,14 +169,7 @@ export declare function resolveSubscriptions(plugin: HastVisitorInstance): Resol
  * Promise of that count if any visitor is async.
  */
 export declare function visitHastHandle(handle: HastHandle, plugin: HastVisitorInstance, subs: ResolvedSubscription[], source: string | (() => string), fileURL: URL | undefined, data?: Data, sourceFormat?: SourceFormat, diagnostics?: HastDiagnostic[]): number | Promise<number>;
-/** Run a HAST visitor, build the command buffer, but do NOT apply it. Returns
- *  the merged commands so the caller can choose how to dispatch: either via
- *  `applyCommandsToHandle` (intermediate plugins in a chain) or via a fused
- *  NAPI call like `applyCommandsAndRenderHandle` (final plugin, saves one
- *  apply + one render + one drop crossing). Empty result means no mutations.
- */
 export declare function visitHastHandleCollect(handle: HastHandle, plugin: HastVisitorInstance, subs: ResolvedSubscription[], source: string | (() => string), fileURL: URL | undefined, data?: Data, sourceFormat?: SourceFormat, diagnostics?: HastDiagnostic[]): Uint8Array | Promise<Uint8Array>;
-/** Its own pass so the caller can apply what `before` queued before the
- *  visitors walk, and the visitors' mutations before `after` reads the tree. */
+/** Hooks run in separate passes so each sees mutations from the preceding pass. */
 export declare function visitHastHookCollect(handle: HastHandle, plugin: HastVisitorInstance, hook: HastHookFn, source: string | (() => string), fileURL: URL | undefined, data?: Data, sourceFormat?: SourceFormat, diagnostics?: HastDiagnostic[]): Uint8Array | Promise<Uint8Array>;
 export declare function visitHastHook(handle: HastHandle, plugin: HastVisitorInstance, hook: HastHookFn, source: string | (() => string), fileURL: URL | undefined, data?: Data, sourceFormat?: SourceFormat, diagnostics?: HastDiagnostic[]): number | Promise<number>;