satteri 0.8.0 → 0.8.1

package/dist/command-buffer.d.ts

@@ -52,6 +52,8 @@ export declare class CommandBuffer {
     }): void;
     /** Write a REPLACE command with a pre-serialized JSON payload. */
     replaceRawJson(nodeId: number, json: string): void;
+    /** Replace a node's child list (Root-wrapped `json`) while keeping the node. */
+    setChildren(nodeId: number, json: string): void;
     /** Write any structural command with a pre-serialized JSON payload. */
     insertBeforeRawJson(nodeId: number, json: string): void;
     insertAfterRawJson(nodeId: number, json: string): void;

package/dist/command-buffer.js

@@ -17,6 +17,7 @@ const CMD_APPEND_CHILD = 0x08;
 const CMD_WRAP = 0x09;
 const CMD_REPLACE = 0x0b;
 const CMD_SET_PROPERTY = 0x0c;
+const CMD_SET_CHILDREN = 0x0d;
 // Payload types (0x10+, distinct range from commands)
 const PAYLOAD_RAW_MARKDOWN = 0x10;
 const PAYLOAD_RAW_HTML = 0x11;
@@ -119,6 +120,10 @@ export class CommandBuffer {
     replaceRawJson(nodeId, json) {
         this.writeRawJsonCommand(CMD_REPLACE, nodeId, json);
     }
+    /** Replace a node's child list (Root-wrapped `json`) while keeping the node. */
+    setChildren(nodeId, json) {
+        this.writeRawJsonCommand(CMD_SET_CHILDREN, nodeId, json);
+    }
     /** Write any structural command with a pre-serialized JSON payload. */
     insertBeforeRawJson(nodeId, json) {
         this.writeRawJsonCommand(CMD_INSERT_BEFORE, nodeId, json);

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

@@ -23,16 +23,20 @@ export interface HastVisitorContext {
     readonly fileURL: URL | undefined;
     removeNode(node: Readonly<HastNode>): void;
     replaceNode(node: Readonly<HastNode>, newNode: HastNode): void;
-    insertBefore(node: Readonly<HastNode>, newNode: HastNode): void;
-    insertAfter(node: Readonly<HastNode>, newNode: HastNode): void;
+    insertBefore(node: Readonly<HastNode>, newNode: HastNode | HastNode[]): void;
+    insertAfter(node: Readonly<HastNode>, newNode: HastNode | HastNode[]): void;
     /**
      * Wrap `node` in `parentNode`, making it `parentNode`'s first child. Any
      * children `parentNode` declares are kept after it, so a `div` with an anchor
      * child wraps a heading as `div > [heading, anchor]`.
      */
     wrapNode(node: Readonly<HastNode>, parentNode: HastNode): void;
-    prependChild(node: Readonly<HastNode>, childNode: HastNode): void;
-    appendChild(node: Readonly<HastNode>, childNode: HastNode): void;
+    prependChild(node: Readonly<HastNode>, childNode: HastNode | HastNode[]): void;
+    appendChild(node: Readonly<HastNode>, childNode: HastNode | HastNode[]): void;
+    /** Insert one node or an array at `index`; clamps (`0` or less prepends, past the end appends). */
+    insertChildAt(node: Readonly<HastNode>, index: number, childNode: HastNode | HastNode[]): void;
+    /** Remove the `index`-th child of `node`; a no-op when there is no such child. */
+    removeChildAt(node: Readonly<HastNode>, index: number): void;
     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;

package/dist/hast/hast-visitor.js

@@ -58,6 +58,9 @@ function markHastNode(node, isRoot) {
 function nid(node) {
     return nodeIdMap.get(node) ?? node._nodeId;
 }
+function asArray(value) {
+    return Array.isArray(value) ? value : [value];
+}
 class HastVisitorContextImpl {
     #commandBuffer = new CommandBuffer();
     #diagnostics = [];
@@ -85,22 +88,62 @@ class HastVisitorContextImpl {
         this.#pendingNodes.set(id, newNode);
     }
     insertBefore(node, newNode) {
-        this.#commandBuffer.insertBeforeRawJson(nid(node), JSON.stringify(markHast(newNode)));
+        const id = nid(node);
+        for (const n of asArray(newNode)) {
+            this.#commandBuffer.insertBeforeRawJson(id, JSON.stringify(markHast(n)));
+        }
     }
     insertAfter(node, newNode) {
-        this.#commandBuffer.insertAfterRawJson(nid(node), JSON.stringify(markHast(newNode)));
+        const id = nid(node);
+        for (const n of asArray(newNode)) {
+            this.#commandBuffer.insertAfterRawJson(id, JSON.stringify(markHast(n)));
+        }
     }
     wrapNode(node, parentNode) {
         this.#commandBuffer.wrapNodeRawJson(nid(node), JSON.stringify(markHast(parentNode)));
     }
     prependChild(node, childNode) {
-        this.#commandBuffer.prependChildRawJson(nid(node), JSON.stringify(markHast(childNode)));
+        const id = nid(node);
+        for (const n of asArray(childNode)) {
+            this.#commandBuffer.prependChildRawJson(id, JSON.stringify(markHast(n)));
+        }
     }
     appendChild(node, childNode) {
-        this.#commandBuffer.appendChildRawJson(nid(node), JSON.stringify(markHast(childNode)));
+        const id = nid(node);
+        for (const n of asArray(childNode)) {
+            this.#commandBuffer.appendChildRawJson(id, JSON.stringify(markHast(n)));
+        }
+    }
+    insertChildAt(node, index, childNode) {
+        const children = "children" in node ? node.children : [];
+        if (index <= 0 || children.length === 0) {
+            this.prependChild(node, childNode);
+        }
+        else if (index >= children.length) {
+            this.appendChild(node, childNode);
+        }
+        else {
+            this.insertBefore(children[index], childNode);
+        }
+    }
+    removeChildAt(node, index) {
+        const child = "children" in node ? node.children[index] : undefined;
+        if (child)
+            this.removeNode(child);
     }
     setProperty(node, key, value) {
         const id = nid(node);
+        if (key === "children") {
+            // children is structural: set-children keeps the node and swaps only its
+            // child list (reused children keep their id).
+            const wrapper = {
+                _hast: true,
+                type: "root",
+                children: value.map((child) => markHastNode(child, false)),
+            };
+            this.#commandBuffer.setChildren(id, JSON.stringify(wrapper));
+            return;
+        }
         if (key === "data") {
             this.#commandBuffer.setProperty(id, key, value != null ? JSON.stringify(value) : null);
             return;

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

@@ -22,15 +22,19 @@ export declare class MdastVisitorContext {
     constructor(handle: MdastHandle, getSource: () => string, fileURL: URL | undefined);
     get source(): string;
     removeNode(node: Readonly<MdastNode>): void;
-    insertBefore(node: Readonly<MdastNode>, newNode: MdastNode): void;
-    insertAfter(node: Readonly<MdastNode>, newNode: MdastNode): void;
+    insertBefore(node: Readonly<MdastNode>, newNode: MdastNode | MdastNode[]): void;
+    insertAfter(node: Readonly<MdastNode>, newNode: MdastNode | MdastNode[]): void;
     /**
      * Wrap `node` in `parentNode`, making it `parentNode`'s first child. Any
      * children `parentNode` declares are kept after it.
      */
     wrapNode(node: Readonly<MdastNode>, parentNode: MdastNode): void;
-    prependChild(node: Readonly<MdastNode>, childNode: MdastNode): void;
-    appendChild(node: Readonly<MdastNode>, childNode: MdastNode): void;
+    prependChild(node: Readonly<MdastNode>, childNode: MdastNode | MdastNode[]): void;
+    appendChild(node: Readonly<MdastNode>, childNode: MdastNode | MdastNode[]): void;
+    /** Insert one node or an array at `index`; clamps (`0` or less prepends, past the end appends). */
+    insertChildAt(node: Readonly<MdastNode>, index: number, childNode: MdastNode | MdastNode[]): void;
+    /** Remove the `index`-th child of `node`; a no-op when there is no such child. */
+    removeChildAt(node: Readonly<MdastNode>, index: number): void;
     replaceNode(node: Readonly<MdastNode>, newNode: MdastNode): void;
     setProperty<N extends MdastNode, K extends keyof N & string>(node: Readonly<N>, key: K, value: N[K]): void;
     /** Collect the concatenated text of all descendant text nodes (like mdast-util-to-string). */

package/dist/mdast/mdast-visitor.js

@@ -55,6 +55,9 @@ const mdastNodeIdMap = new WeakMap();
 function nid(node) {
     return mdastNodeIdMap.get(node) ?? node._nodeId;
 }
+function asArray(value) {
+    return Array.isArray(value) ? value : [value];
+}
 export class MdastVisitorContext {
     #commandBuffer = new CommandBuffer();
     #diagnostics = [];
@@ -80,10 +83,14 @@ export class MdastVisitorContext {
         this.#commandBuffer.removeNode(nid(node));
     }
     insertBefore(node, newNode) {
-        this.#commandBuffer.insertBefore(nid(node), newNode);
+        const id = nid(node);
+        for (const n of asArray(newNode))
+            this.#commandBuffer.insertBefore(id, n);
     }
     insertAfter(node, newNode) {
-        this.#commandBuffer.insertAfter(nid(node), newNode);
+        const id = nid(node);
+        for (const n of asArray(newNode))
+            this.#commandBuffer.insertAfter(id, n);
     }
     /**
      * Wrap `node` in `parentNode`, making it `parentNode`'s first child. Any
@@ -93,15 +100,45 @@ export class MdastVisitorContext {
         this.#commandBuffer.wrapNode(nid(node), parentNode);
     }
     prependChild(node, childNode) {
-        this.#commandBuffer.prependChild(nid(node), childNode);
+        const id = nid(node);
+        for (const n of asArray(childNode))
+            this.#commandBuffer.prependChild(id, n);
     }
     appendChild(node, childNode) {
-        this.#commandBuffer.appendChild(nid(node), childNode);
+        const id = nid(node);
+        for (const n of asArray(childNode))
+            this.#commandBuffer.appendChild(id, n);
+    }
+    /** Insert one node or an array at `index`; clamps (`0` or less prepends, past the end appends). */
+    insertChildAt(node, index, childNode) {
+        const children = "children" in node ? node.children : [];
+        if (index <= 0 || children.length === 0) {
+            this.prependChild(node, childNode);
+        }
+        else if (index >= children.length) {
+            this.appendChild(node, childNode);
+        }
+        else {
+            this.insertBefore(children[index], childNode);
+        }
+    }
+    /** Remove the `index`-th child of `node`; a no-op when there is no such child. */
+    removeChildAt(node, index) {
+        const child = "children" in node ? node.children[index] : undefined;
+        if (child)
+            this.removeNode(child);
     }
     replaceNode(node, newNode) {
         this.#commandBuffer.replace(nid(node), newNode);
     }
     setProperty(node, key, value) {
+        if (key === "children") {
+            // children is structural: set-children keeps the node and swaps only its
+            // child list (reused children keep their id).
+            const wrapper = refifyReusedNodes({ type: "root", children: value }, true);
+            this.#commandBuffer.setChildren(nid(node), JSON.stringify(wrapper));
+            return;
+        }
         if (key === "data") {
             // data is stored as JSON in the arena, serialize it for the command buffer
             this.#commandBuffer.setProperty(nid(node), key, value != null ? JSON.stringify(value) : null);
@@ -396,11 +433,18 @@ function readMdastMatchedNode(view, buf, dataOffset, nodeId, nodeType, resolver)
             node.label = rstr(buf, pos, labelLen);
             pos += labelLen;
             const kind = buf[pos];
+            pos += 1;
             // Only link/image references carry `referenceType`; the mdast spec
             // defines it for those two, not for `footnoteReference`.
             if (nodeType !== 20) {
                 node.referenceType = ["shortcut", "collapsed", "full"][kind] ?? "shortcut";
             }
+            // imageReference also carries `alt` (the serializer appends it).
+            if (nodeType === 18) {
+                const altLen = ru16(view, pos);
+                pos += 2;
+                node.alt = rstr(buf, pos, altLen);
+            }
             break;
         }
         case 19: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "satteri",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "High-performance Markdown and MDX processing",
   "repository": {
     "type": "git",
@@ -80,11 +80,11 @@
     ]
   },
   "optionalDependencies": {
-    "@bruits/satteri-linux-x64-gnu": "0.8.0",
-    "@bruits/satteri-darwin-x64": "0.8.0",
-    "@bruits/satteri-darwin-arm64": "0.8.0",
-    "@bruits/satteri-win32-x64-msvc": "0.8.0",
-    "@bruits/satteri-wasm32-wasi": "0.8.0"
+    "@bruits/satteri-linux-x64-gnu": "0.8.1",
+    "@bruits/satteri-darwin-x64": "0.8.1",
+    "@bruits/satteri-darwin-arm64": "0.8.1",
+    "@bruits/satteri-win32-x64-msvc": "0.8.1",
+    "@bruits/satteri-wasm32-wasi": "0.8.1"
   },
   "scripts": {
     "build:binary:wasm": "napi build --manifest-path ../../crates/satteri-napi-binding/Cargo.toml --output-dir . --platform --release --esm --strip --target wasm32-wasip1-threads",