@openclaw/discord 2026.10.5 → 2026.10.10-beta.2

package/node_modules/mdast-util-from-markdown/dev/lib/index.js

@@ -97,6 +97,8 @@ export function fromMarkdown(value, encoding, options) {
 function compiler(options) {
   /** @type {Config} */
   const config = {
+    afterExit: [],
+    beforeEnter: [],
     transforms: [],
     canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],
     enter: {
@@ -212,7 +214,7 @@ function compiler(options) {
    */
   function compile(events) {
     /** @type {Root} */
-    let tree = {type: 'root', children: []}
+    let tree = {type: 'root', children: [], position: undefined}
     /** @type {Omit<CompileContext, 'sliceSerialize'>} */
     const context = {
       stack: [tree],
@@ -226,36 +228,56 @@ function compiler(options) {
     }
     /** @type {Array<number>} */
     const listStack = []
+    /** @type {Array<Event>} */
+    const prepared = []
     let index = -1
 
+    // Add `listItem` tokens and infer spread.
+    // Each list is prepared while it is last in `prepared`, so nothing shifts.
     while (++index < events.length) {
-      // We preprocess lists to add `listItem` tokens, and to infer whether
-      // items the list itself are spread out.
+      prepared.push(events[index])
+
       if (
         events[index][1].type === types.listOrdered ||
         events[index][1].type === types.listUnordered
       ) {
         if (events[index][0] === 'enter') {
-          listStack.push(index)
+          listStack.push(prepared.length - 1)
         } else {
           const tail = listStack.pop()
           assert(typeof tail === 'number', 'expected list to be open')
-          index = prepareList(events, tail, index)
+          prepareList(prepared, tail)
         }
       }
     }
 
+    events = prepared
+
     index = -1
 
     while (++index < events.length) {
       const handler = config[events[index][0]]
 
+      if (events[index][0] === 'enter' && config.beforeEnter.length > 0) {
+        callListeners(
+          config.beforeEnter,
+          {...context, sliceSerialize: events[index][2].sliceSerialize},
+          events[index][1]
+        )
+      }
+
       if (own.call(handler, events[index][1].type)) {
+        // Note: spread first, V8 has optimizations for object shape cloning.
         handler[events[index][1].type].call(
-          Object.assign(
-            {sliceSerialize: events[index][2].sliceSerialize},
-            context
-          ),
+          {...context, sliceSerialize: events[index][2].sliceSerialize},
+          events[index][1]
+        )
+      }
+
+      if (events[index][0] === 'exit' && config.afterExit.length > 0) {
+        callListeners(
+          config.afterExit,
+          {...context, sliceSerialize: events[index][2].sliceSerialize},
           events[index][1]
         )
       }
@@ -289,13 +311,33 @@ function compiler(options) {
     return tree
   }
 
+  /**
+   * @param {Array<Handle>} listeners
+   *   Listeners.
+   * @param {CompileContext} context
+   *   Context.
+   * @param {Token} token
+   *   Token.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  function callListeners(listeners, context, token) {
+    let index = -1
+
+    while (++index < listeners.length) {
+      listeners[index].call(context, token)
+    }
+  }
+
   /**
    * @param {Array<Event>} events
+   *   Events, ending with the list to prepare.
    * @param {number} start
-   * @param {number} length
-   * @returns {number}
+   *   Index of the list enter.
+   * @returns {undefined}
    */
-  function prepareList(events, start, length) {
+  function prepareList(events, start) {
+    const end = events.length - 1
     let index = start - 1
     let containerBalance = -1
     let listSpread = false
@@ -307,8 +349,15 @@ function compiler(options) {
     let firstBlankLineIndex
     /** @type {boolean | undefined} */
     let atMarker
+    /**
+     * `listItem` events to insert before the event at `at`, in walk order.
+     * Merged in after the walk, as inserting while walking would shift the
+     * rest of the list once per item.
+     * @type {Array<{at: number, event: Event}>}
+     */
+    const insertions = []
 
-    while (++index <= length) {
+    while (++index <= end) {
       const event = events[index]
 
       switch (event[1].type) {
@@ -413,9 +462,10 @@ function compiler(options) {
             lineIndex ? events[lineIndex][1].start : event[1].end
           )
 
-          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]])
-          index++
-          length++
+          insertions.push({
+            at: lineIndex || index,
+            event: ['exit', listItem, event[2]]
+          })
         }
 
         // Create a new list item.
@@ -429,17 +479,34 @@ function compiler(options) {
             end: undefined
           }
           listItem = item
-          events.splice(index, 0, ['enter', item, event[2]])
-          index++
-          length++
+          insertions.push({at: index, event: ['enter', item, event[2]]})
           firstBlankLineIndex = undefined
           atMarker = true
         }
       }
     }
 
+    // The list is at the end of `events`: take it off, then push it back with
+    // the insertions merged in.
+    // Nothing follows the list, so nothing shifts.
+    const listEvents = events.splice(start)
+    let insertion = 0
+    index = -1
+
+    while (++index < listEvents.length) {
+      while (
+        insertion < insertions.length &&
+        insertions[insertion].at === start + index
+      ) {
+        events.push(insertions[insertion++].event)
+      }
+
+      events.push(listEvents[index])
+    }
+
+    assert(insertion === insertions.length, 'expected insertions to be merged')
+
     events[start][1]._spread = listSpread
-    return length
   }
 
   /**
@@ -530,7 +597,9 @@ function compiler(options) {
           stringifyPosition({start: token.start, end: token.end}) +
           '): it’s not open'
       )
-    } else if (open[0].type !== token.type) {
+    }
+
+    if (open[0].type !== token.type) {
       if (onExitError) {
         onExitError.call(this, token, open[0])
       } else {
@@ -1137,19 +1206,31 @@ function compiler(options) {
   // Creaters.
   //
 
+  // Each node factory pre-declares `position` as undefined as the trailing
+  // property. enter() patches it to a real value, but the property already
+  // exists, so V8 sees a single hidden class for each node type from
+  // construction through the rest of the pipeline. Without the pre-declare,
+  // each node took a hidden-class transition when enter() added position.
+
   /** @returns {Blockquote} */
   function blockQuote() {
-    return {type: 'blockquote', children: []}
+    return {type: 'blockquote', children: [], position: undefined}
   }
 
   /** @returns {Code} */
   function codeFlow() {
-    return {type: 'code', lang: null, meta: null, value: ''}
+    return {
+      type: 'code',
+      lang: null,
+      meta: null,
+      value: '',
+      position: undefined
+    }
   }
 
   /** @returns {InlineCode} */
   function codeText() {
-    return {type: 'inlineCode', value: ''}
+    return {type: 'inlineCode', value: '', position: undefined}
   }
 
   /** @returns {Definition} */
@@ -1159,13 +1240,14 @@ function compiler(options) {
       identifier: '',
       label: null,
       title: null,
-      url: ''
+      url: '',
+      position: undefined
     }
   }
 
   /** @returns {Emphasis} */
   function emphasis() {
-    return {type: 'emphasis', children: []}
+    return {type: 'emphasis', children: [], position: undefined}
   }
 
   /** @returns {Heading} */
@@ -1174,28 +1256,41 @@ function compiler(options) {
       type: 'heading',
       // @ts-expect-error `depth` will be set later.
       depth: 0,
-      children: []
+      children: [],
+      position: undefined
     }
   }
 
   /** @returns {Break} */
   function hardBreak() {
-    return {type: 'break'}
+    return {type: 'break', position: undefined}
   }
 
   /** @returns {Html} */
   function html() {
-    return {type: 'html', value: ''}
+    return {type: 'html', value: '', position: undefined}
   }
 
   /** @returns {Image} */
   function image() {
-    return {type: 'image', title: null, url: '', alt: null}
+    return {
+      type: 'image',
+      title: null,
+      url: '',
+      alt: null,
+      position: undefined
+    }
   }
 
   /** @returns {Link} */
   function link() {
-    return {type: 'link', title: null, url: '', children: []}
+    return {
+      type: 'link',
+      title: null,
+      url: '',
+      children: [],
+      position: undefined
+    }
   }
 
   /**
@@ -1208,7 +1303,8 @@ function compiler(options) {
       ordered: token.type === 'listOrdered',
       start: null,
       spread: token._spread,
-      children: []
+      children: [],
+      position: undefined
     }
   }
 
@@ -1221,28 +1317,29 @@ function compiler(options) {
       type: 'listItem',
       spread: token._spread,
       checked: null,
-      children: []
+      children: [],
+      position: undefined
     }
   }
 
   /** @returns {Paragraph} */
   function paragraph() {
-    return {type: 'paragraph', children: []}
+    return {type: 'paragraph', children: [], position: undefined}
   }
 
   /** @returns {Strong} */
   function strong() {
-    return {type: 'strong', children: []}
+    return {type: 'strong', children: [], position: undefined}
   }
 
   /** @returns {Text} */
   function text() {
-    return {type: 'text', value: ''}
+    return {type: 'text', value: '', position: undefined}
   }
 
   /** @returns {ThematicBreak} */
   function thematicBreak() {
-    return {type: 'thematicBreak'}
+    return {type: 'thematicBreak', position: undefined}
   }
 }
 
@@ -1307,6 +1404,16 @@ function extension(combined, extension) {
           break
         }
 
+        case 'afterExit':
+        case 'beforeEnter': {
+          const right = extension[key]
+          if (right) {
+            combined[key].push(right)
+          }
+
+          break
+        }
+
         case 'enter':
         case 'exit': {
           const right = extension[key]
@@ -1336,13 +1443,13 @@ function defaultOnError(left, right) {
         stringifyPosition({start: right.start, end: right.end}) +
         ') is open'
     )
-  } else {
-    throw new Error(
-      'Cannot close document, a token (`' +
-        right.type +
-        '`, ' +
-        stringifyPosition({start: right.start, end: right.end}) +
-        ') is still open'
-    )
   }
+
+  throw new Error(
+    'Cannot close document, a token (`' +
+      right.type +
+      '`, ' +
+      stringifyPosition({start: right.start, end: right.end}) +
+      ') is still open'
+  )
 }

package/node_modules/mdast-util-from-markdown/dev/lib/types.d.ts

@@ -159,6 +159,14 @@ export interface CompileData {
  * We have our defaults, but extensions will add more.
  */
 export interface Config {
+  /**
+   * Listeners called for every token, after closing handles.
+   */
+  afterExit: Array<Handle>
+  /**
+   * Listeners called for every token, before opening handles.
+   */
+  beforeEnter: Array<Handle>
   /**
    * Token types where line endings are used.
    */
@@ -179,8 +187,26 @@ export interface Config {
 
 /**
  * Change how markdown tokens from micromark are turned into mdast.
+ *
+ * ###### Notes
+ *
+ * Handles (`enter`, `exit`) create the tree;
+ * a later handle for a token type from an extension overwrites earlier ones.
+ * Listeners (`afterExit`, `beforeEnter`) observe all tokens including unhandled
+ * ones.
+ * The point of listeners is that they *do not* interfere with handling,
+ * potentially changed by extensions.
+ * Don’t modify unexpected things!
  */
 export interface Extension {
+  /**
+   * Listener called for every token, after closing handles.
+   */
+  afterExit?: Handle | null | undefined
+  /**
+   * Listener called for every token, before opening handles.
+   */
+  beforeEnter?: Handle | null | undefined
   /**
    * Token types where line endings are used.
    */