@bgx4k3p/huly-mcp-server 2.2.4 → 2.2.5

package/node_modules/msgpackr/unpack.js

@@ -29,13 +29,6 @@ var sequentialMode = false
 var inlineObjectReadThreshold = 2
 var readStruct, onLoadedStructures, onSaveState
 var BlockedFunction // we use search and replace to change the next call to BlockedFunction to avoid CSP issues for
-// no-eval build
-try {
-	new Function('')
-} catch(error) {
-	// if eval variants are not supported, do not create inline object readers ever
-	inlineObjectReadThreshold = Infinity
-}
 
 export class Unpackr {
 	constructor(options) {
@@ -508,11 +501,18 @@ function createStructureReader(structure, firstId) {
 	function readObject() {
 		// This initial function is quick to instantiate, but runs slower. After several iterations pay the cost to build the faster function
 		if (readObject.count++ > inlineObjectReadThreshold) {
-			let readObject = structure.read = (new Function('r', 'return function(){return ' + (currentUnpackr.freezeData ? 'Object.freeze' : '') +
-				'({' + structure.map(key => key === '__proto__' ? '__proto_:r()' : validName.test(key) ? key + ':r()' : ('[' + JSON.stringify(key) + ']:r()')).join(',') + '})}'))(read)
+			let optimizedReadObject
+			try {
+				optimizedReadObject = structure.read = (new Function('r', 'return function(){return ' + (currentUnpackr.freezeData ? 'Object.freeze' : '') +
+					'({' + structure.map(key => key === '__proto__' ? '__proto_:r()' : validName.test(key) ? key + ':r()' : ('[' + JSON.stringify(key) + ']:r()')).join(',') + '})}'))(read)
+			} catch(error) {
+				// in CF workers, the new Function call could begin to fail at any point in time
+				inlineObjectReadThreshold = Infinity // disable going forward
+				return readObject(); // recursively try again
+			}
 			if (structure.highByte === 0)
 				structure.read = createSecondByteReader(firstId, structure.read)
-			return readObject() // second byte is already read, if there is one so immediately read object
+			return optimizedReadObject() // second byte is already read, if there is one so immediately read object
 		}
 		let object = {}
 		for (let i = 0, l = structure.length; i < l; i++) {
@@ -621,26 +621,45 @@ function readStringJS(length) {
 		} else if ((byte1 & 0xe0) === 0xc0) {
 			// 2 bytes
 			const byte2 = src[position++] & 0x3f
-			units.push(((byte1 & 0x1f) << 6) | byte2)
+			const codePoint = ((byte1 & 0x1f) << 6) | byte2
+			// Reject overlong encoding: 2-byte sequences must encode values >= 0x80
+			if (codePoint < 0x80) {
+				units.push(0xFFFD) // replacement character
+			} else {
+				units.push(codePoint)
+			}
 		} else if ((byte1 & 0xf0) === 0xe0) {
 			// 3 bytes
 			const byte2 = src[position++] & 0x3f
 			const byte3 = src[position++] & 0x3f
-			units.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3)
+			const codePoint = ((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3
+			// Reject overlong encoding: 3-byte sequences must encode values >= 0x800
+			// Also reject surrogates (0xD800-0xDFFF)
+			if (codePoint < 0x800 || (codePoint >= 0xD800 && codePoint <= 0xDFFF)) {
+				units.push(0xFFFD) // replacement character
+			} else {
+				units.push(codePoint)
+			}
 		} else if ((byte1 & 0xf8) === 0xf0) {
 			// 4 bytes
 			const byte2 = src[position++] & 0x3f
 			const byte3 = src[position++] & 0x3f
 			const byte4 = src[position++] & 0x3f
 			let unit = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4
-			if (unit > 0xffff) {
+			// Reject overlong encoding: 4-byte sequences must encode values >= 0x10000
+			// Also reject values > 0x10FFFF (maximum valid Unicode)
+			if (unit < 0x10000 || unit > 0x10FFFF) {
+				units.push(0xFFFD) // replacement character
+			} else if (unit > 0xffff) {
 				unit -= 0x10000
 				units.push(((unit >>> 10) & 0x3ff) | 0xd800)
 				unit = 0xdc00 | (unit & 0x3ff)
+				units.push(unit)
+			} else {
+				units.push(unit)
 			}
-			units.push(unit)
 		} else {
-			units.push(byte1)
+			units.push(0xFFFD) // replacement character for invalid lead byte
 		}
 
 		if (units.length >= 0x1000) {
@@ -1013,7 +1032,7 @@ currentExtensions[0x42] = data => {
 			if (length <= 40) {
 				let out = view.getBigUint64(start)
 				for (let i = start + 8; i < end; i += 8) {
-					out <<= BigInt(64n)
+					out <<= BigInt(64)
 					out |= view.getBigUint64(i)
 				}
 				return out

package/node_modules/prosemirror-changeset/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 2.4.1 (2026-04-14)
+
+### Bug fixes
+
+Fix a bug that would cause change simplification to sometimes expand changes over non-word characters.
+
+## 2.4.0 (2026-02-14)
+
+### New features
+
+`Change` objects can now be serialized to and deserialized from JSON, and `ChangeSet.create` allows you to pass in a set of changes.
+
 ## 2.3.1 (2025-05-28)
 
 ### Bug fixes

package/node_modules/prosemirror-changeset/README.md

@@ -7,7 +7,7 @@ in order to do such change tracking in a halfway performant way during
 live editing.
 
 This code is licensed under an [MIT
-licence](https://github.com/ProseMirror/prosemirror-changeset/blob/master/LICENSE).
+licence](https://code.haverbeke.berlin/prosemirror/prosemirror-changeset/src/branch/main/LICENSE).
 
 ## Programming interface
 
@@ -43,11 +43,17 @@ A replaced range with metadata associated with it.
    Data associated with the inserted content. Length adds up to
    `this.toB - this.fromB`.
 
+ * **`toJSON`**`() → ChangeJSON`\
+   Returns a JSON-serializeable object to represent this change.
+
  * `static `**`merge`**`<Data>(x: readonly Change[], y: readonly Change[], combine: fn(dataA: Data, dataB: Data) → Data) → readonly Change[]`\
    This merges two changesets (the end document of x should be the
    start document of y) into a single one spanning the start of x to
    the end of y.
 
+ * `static `**`fromJSON`**`<Data>(json: ChangeJSON) → Change`\
+   Deserialize a change from JSON format.
+
 
 ### class Span`<Data = any>`
 
@@ -96,7 +102,7 @@ partially undo themselves by comparing their content.
    make sure the method is called on the old set and passed the new
    set. The returned positions will be in new document coordinates.
 
- * `static `**`create`**`<Data = any>(doc: Node, combine?: fn(dataA: Data, dataB: Data) → Data = (a, b) => a === b ? a : null as any, tokenEncoder?: TokenEncoder = DefaultEncoder) → ChangeSet`\
+ * `static `**`create`**`<Data = any>(doc: Node, combine?: fn(dataA: Data, dataB: Data) → Data = (a, b) => a === b ? a : null as any, tokenEncoder?: TokenEncoder = DefaultEncoder, changes?: readonly Change[] = []) → ChangeSet`\
    Create a changeset with the given base object and configuration.
 
    The `combine` function is used to compare and combine metadata—it
@@ -108,6 +114,11 @@ partially undo themselves by comparing their content.
    changes. The default is to just compare nodes by name and text
    by character, ignoring marks and attributes.
 
+   To serialize a change set, you can store its document and
+   change array as JSON, and then pass the deserialized (via
+   [`Change.fromJSON`](#changes.Change^fromJSON)) set of changes
+   as fourth argument to `create` to recreate the set.
+
 
  * **`simplifyChanges`**`(changes: readonly Change[], doc: Node) → Change[]`\
    Simplifies a set of changes for presentation. This makes the
@@ -144,3 +155,21 @@ performance.
    Compare the given tokens. Should return true when they count as
    equal.
 
+
+### type ChangeJSON`<Data>`
+
+JSON-serialized form of a change.
+
+ * **`fromA`**`: number`
+
+ * **`toA`**`: number`
+
+ * **`fromB`**`: number`
+
+ * **`toB`**`: number`
+
+ * **`deleted`**`: readonly {length: number, data: Data}[]`
+
+ * **`inserted`**`: readonly {length: number, data: Data}[]`
+
+

package/node_modules/prosemirror-changeset/dist/index.cjs

@@ -210,6 +210,11 @@ var Change = function () {
       if (startA == 0 && startB == 0 && endA == this.toA - this.fromA && endB == this.toB - this.fromB) return this;
       return new Change(this.fromA + startA, this.fromA + endA, this.fromB + startB, this.fromB + endB, Span.slice(this.deleted, startA, endA), Span.slice(this.inserted, startB, endB));
     }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return this;
+    }
   }], [{
     key: "merge",
     value: function merge(x, y, combine) {
@@ -276,6 +281,15 @@ var Change = function () {
         }
       }
     }
+  }, {
+    key: "fromJSON",
+    value: function fromJSON(json) {
+      return new Change(json.fromA, json.toA, json.fromB, json.toB, json.deleted.map(function (d) {
+        return new Span(d.length, d.data);
+      }), json.inserted.map(function (d) {
+        return new Span(d.length, d.data);
+      }));
+    }
   }]);
   return Change;
 }();
@@ -285,7 +299,7 @@ try {
 } catch (_) {}
 var nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/;
 function isLetter(code) {
-  if (code < 128) return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 79 && code <= 122;
+  if (code < 128) return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
   var ch = String.fromCharCode(code);
   if (letter) return letter.test(ch);
   return ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch);
@@ -507,11 +521,12 @@ var ChangeSet = function () {
         return a === b ? a : null;
       };
       var tokenEncoder = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DefaultEncoder;
+      var changes = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
       return new ChangeSet({
         combine: combine,
         doc: doc,
         encoder: tokenEncoder
-      }, []);
+      }, changes);
     }
   }]);
   return ChangeSet;

package/node_modules/prosemirror-changeset/dist/index.d.cts

@@ -50,7 +50,32 @@ declare class Change<Data = any> {
     the end of y.
     */
     static merge<Data>(x: readonly Change<Data>[], y: readonly Change<Data>[], combine: (dataA: Data, dataB: Data) => Data): readonly Change<Data>[];
+    /**
+    Deserialize a change from JSON format.
+    */
+    static fromJSON<Data>(json: ChangeJSON<Data>): Change<Data>;
+    /**
+    Returns a JSON-serializeable object to represent this change.
+    */
+    toJSON(): ChangeJSON<Data>;
 }
+/**
+JSON-serialized form of a change.
+*/
+type ChangeJSON<Data> = {
+    fromA: number;
+    toA: number;
+    fromB: number;
+    toB: number;
+    deleted: readonly {
+        length: number;
+        data: Data;
+    }[];
+    inserted: readonly {
+        length: number;
+        data: Data;
+    }[];
+};
 
 /**
 A token encoder can be passed when creating a `ChangeSet` in order
@@ -149,8 +174,13 @@ declare class ChangeSet<Data = any> {
     serialized and compared when diffing the content produced by
     changes. The default is to just compare nodes by name and text
     by character, ignoring marks and attributes.
+    
+    To serialize a change set, you can store its document and
+    change array as JSON, and then pass the deserialized (via
+    [`Change.fromJSON`](https://prosemirror.net/docs/ref/#changes.Change^fromJSON)) set of changes
+    as fourth argument to `create` to recreate the set.
     */
-    static create<Data = any>(doc: Node, combine?: (dataA: Data, dataB: Data) => Data, tokenEncoder?: TokenEncoder<any>): ChangeSet<Data>;
+    static create<Data = any>(doc: Node, combine?: (dataA: Data, dataB: Data) => Data, tokenEncoder?: TokenEncoder<any>, changes?: readonly Change<Data>[]): ChangeSet<Data>;
 }
 
-export { Change, ChangeSet, Span, type TokenEncoder, simplifyChanges };
+export { Change, type ChangeJSON, ChangeSet, Span, type TokenEncoder, simplifyChanges };

package/node_modules/prosemirror-changeset/dist/index.d.ts

@@ -50,7 +50,32 @@ declare class Change<Data = any> {
     the end of y.
     */
     static merge<Data>(x: readonly Change<Data>[], y: readonly Change<Data>[], combine: (dataA: Data, dataB: Data) => Data): readonly Change<Data>[];
+    /**
+    Deserialize a change from JSON format.
+    */
+    static fromJSON<Data>(json: ChangeJSON<Data>): Change<Data>;
+    /**
+    Returns a JSON-serializeable object to represent this change.
+    */
+    toJSON(): ChangeJSON<Data>;
 }
+/**
+JSON-serialized form of a change.
+*/
+type ChangeJSON<Data> = {
+    fromA: number;
+    toA: number;
+    fromB: number;
+    toB: number;
+    deleted: readonly {
+        length: number;
+        data: Data;
+    }[];
+    inserted: readonly {
+        length: number;
+        data: Data;
+    }[];
+};
 
 /**
 A token encoder can be passed when creating a `ChangeSet` in order
@@ -149,8 +174,13 @@ declare class ChangeSet<Data = any> {
     serialized and compared when diffing the content produced by
     changes. The default is to just compare nodes by name and text
     by character, ignoring marks and attributes.
+    
+    To serialize a change set, you can store its document and
+    change array as JSON, and then pass the deserialized (via
+    [`Change.fromJSON`](https://prosemirror.net/docs/ref/#changes.Change^fromJSON)) set of changes
+    as fourth argument to `create` to recreate the set.
     */
-    static create<Data = any>(doc: Node, combine?: (dataA: Data, dataB: Data) => Data, tokenEncoder?: TokenEncoder<any>): ChangeSet<Data>;
+    static create<Data = any>(doc: Node, combine?: (dataA: Data, dataB: Data) => Data, tokenEncoder?: TokenEncoder<any>, changes?: readonly Change<Data>[]): ChangeSet<Data>;
 }
 
-export { Change, ChangeSet, Span, type TokenEncoder, simplifyChanges };
+export { Change, type ChangeJSON, ChangeSet, Span, type TokenEncoder, simplifyChanges };

package/node_modules/prosemirror-changeset/dist/index.js

@@ -350,6 +350,16 @@ class Change {
             }
         }
     }
+    /**
+    Deserialize a change from JSON format.
+    */
+    static fromJSON(json) {
+        return new Change(json.fromA, json.toA, json.fromB, json.toB, json.deleted.map(d => new Span(d.length, d.data)), json.inserted.map(d => new Span(d.length, d.data)));
+    }
+    /**
+    Returns a JSON-serializeable object to represent this change.
+    */
+    toJSON() { return this; }
 }
 
 let letter;
@@ -364,7 +374,7 @@ catch (_) { }
 const nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/;
 function isLetter(code) {
     if (code < 128)
-        return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 79 && code <= 122;
+        return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
     let ch = String.fromCharCode(code);
     if (letter)
         return letter.test(ch);
@@ -646,9 +656,14 @@ class ChangeSet {
     serialized and compared when diffing the content produced by
     changes. The default is to just compare nodes by name and text
     by character, ignoring marks and attributes.
+    
+    To serialize a change set, you can store its document and
+    change array as JSON, and then pass the deserialized (via
+    [`Change.fromJSON`](https://prosemirror.net/docs/ref/#changes.Change^fromJSON)) set of changes
+    as fourth argument to `create` to recreate the set.
     */
-    static create(doc, combine = (a, b) => a === b ? a : null, tokenEncoder = DefaultEncoder) {
-        return new ChangeSet({ combine, doc, encoder: tokenEncoder }, []);
+    static create(doc, combine = (a, b) => a === b ? a : null, tokenEncoder = DefaultEncoder, changes = []) {
+        return new ChangeSet({ combine, doc, encoder: tokenEncoder }, changes);
     }
 }
 /**

package/node_modules/prosemirror-changeset/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prosemirror-changeset",
-  "version": "2.3.1",
+  "version": "2.4.1",
   "description": "Distills a series of editing steps into deleted and added ranges",
   "type": "module",
   "main": "dist/index.cjs",
@@ -21,7 +21,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git://github.com/prosemirror/prosemirror-changeset.git"
+    "url": "git+https://code.haverbeke.berlin/prosemirror/prosemirror-changeset.git"
   },
   "dependencies": {
     "prosemirror-transform": "^1.0.0"

package/node_modules/prosemirror-changeset/src/README.md

@@ -7,7 +7,7 @@ in order to do such change tracking in a halfway performant way during
 live editing.
 
 This code is licensed under an [MIT
-licence](https://github.com/ProseMirror/prosemirror-changeset/blob/master/LICENSE).
+licence](https://code.haverbeke.berlin/prosemirror/prosemirror-changeset/src/branch/main/LICENSE).
 
 ## Programming interface
 
@@ -27,4 +27,6 @@ it was made, or the step data necessary to invert it again.
 
 @simplifyChanges
 
-@TokenEncoder
+@TokenEncoder
+
+@ChangeJSON

package/node_modules/prosemirror-changeset/src/change.ts

@@ -168,4 +168,22 @@ export class Change<Data = any> {
       }
     }
   }
+
+  /// Deserialize a change from JSON format.
+  static fromJSON<Data>(json: ChangeJSON<Data>) {
+    return new Change(json.fromA, json.toA, json.fromB, json.toB,
+                      json.deleted.map(d => new Span(d.length, d.data)),
+                      json.inserted.map(d => new Span(d.length, d.data)))
+  }
+
+  /// Returns a JSON-serializeable object to represent this change.
+  toJSON(): ChangeJSON<Data> { return this }
+}
+
+/// JSON-serialized form of a change.
+export type ChangeJSON<Data> = {
+  fromA: number, toA: number,
+  fromB: number, toB: number,
+  deleted: readonly {length: number, data: Data}[],
+  inserted: readonly {length: number, data: Data}[]
 }

package/node_modules/prosemirror-changeset/src/changeset.ts

@@ -1,8 +1,8 @@
 import {Node} from "prosemirror-model"
 import {StepMap} from "prosemirror-transform"
 import {computeDiff, TokenEncoder, DefaultEncoder} from "./diff"
-import {Change, Span} from "./change"
-export {Change, Span}
+import {Change, Span, ChangeJSON} from "./change"
+export {Change, Span, ChangeJSON}
 export {simplifyChanges} from "./simplify"
 export {TokenEncoder}
 
@@ -146,12 +146,18 @@ export class ChangeSet<Data = any> {
   /// serialized and compared when diffing the content produced by
   /// changes. The default is to just compare nodes by name and text
   /// by character, ignoring marks and attributes.
+  ///
+  /// To serialize a change set, you can store its document and
+  /// change array as JSON, and then pass the deserialized (via
+  /// [`Change.fromJSON`](#changes.Change^fromJSON)) set of changes
+  /// as fourth argument to `create` to recreate the set.
   static create<Data = any>(
     doc: Node,
     combine: (dataA: Data, dataB: Data) => Data = (a, b) => a === b ? a : null as any,
-    tokenEncoder: TokenEncoder<any> = DefaultEncoder
+    tokenEncoder: TokenEncoder<any> = DefaultEncoder,
+    changes: readonly Change<Data>[] = []
   ) {
-    return new ChangeSet({combine, doc, encoder: tokenEncoder}, [])
+    return new ChangeSet({combine, doc, encoder: tokenEncoder}, changes)
   }
 
   /// Exported for testing @internal

package/node_modules/prosemirror-changeset/src/simplify.ts

@@ -12,7 +12,7 @@ const nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u304
 
 function isLetter(code: number) {
   if (code < 128)
-    return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 79 && code <= 122
+    return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122
   let ch = String.fromCharCode(code)
   if (letter) return letter.test(ch)
   return ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch)

package/node_modules/prosemirror-changeset/test/test-simplify.ts

@@ -25,6 +25,9 @@ describe("simplifyChanges", () => {
   it("doesn't expand across non-word text", () => test(
     [[7, 10]], doc(p("one two ----- four")), [[5, 10]]))
 
+  it("doesn't expand replacements across bracket characters", () => test(
+    [[7, 10]], doc(p("one two [SFX] four")), [[5, 10]]))
+
   it("treats leaf nodes as non-words", () => test(
     [[2, 3], [6, 7]], doc(p("one", img(), "two")), [[2, 3], [6, 7]]))
 

package/node_modules/prosemirror-gapcursor/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 1.4.1 (2026-03-10)
+
+### Bug fixes
+
+Make sure no gap cursors are created inside inline nodes with content.
+
 ## 1.4.0 (2025-10-15)
 
 ### New features

package/node_modules/prosemirror-gapcursor/dist/index.cjs

@@ -63,7 +63,7 @@ var GapCursor = function (_prosemirrorState$Sel) {
     key: "valid",
     value: function valid($pos) {
       var parent = $pos.parent;
-      if (parent.isTextblock || !closedBefore($pos) || !closedAfter($pos)) return false;
+      if (parent.inlineContent || !closedBefore($pos) || !closedAfter($pos)) return false;
       var override = parent.type.spec.allowGapCursor;
       if (override != null) return override;
       var deflt = parent.contentMatchAt($pos.index()).defaultType;

package/node_modules/prosemirror-gapcursor/dist/index.js

@@ -42,7 +42,7 @@ class GapCursor extends Selection {
     */
     static valid($pos) {
         let parent = $pos.parent;
-        if (parent.isTextblock || !closedBefore($pos) || !closedAfter($pos))
+        if (parent.inlineContent || !closedBefore($pos) || !closedAfter($pos))
             return false;
         let override = parent.type.spec.allowGapCursor;
         if (override != null)

package/node_modules/prosemirror-gapcursor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prosemirror-gapcursor",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "ProseMirror plugin for cursors at normally impossible-to-reach positions",
   "type": "module",
   "main": "dist/index.cjs",
@@ -37,6 +37,7 @@
     "@prosemirror/buildhelper": "^0.1.5"
   },
   "scripts": {
-    "prepare": "pm-buildhelper src/index.ts"
+    "prepare": "pm-buildhelper src/index.ts",
+    "test": "pm-runtests"
   }
 }

package/node_modules/prosemirror-gapcursor/src/gapcursor.ts

@@ -37,7 +37,7 @@ export class GapCursor extends Selection {
   /// @internal
   static valid($pos: ResolvedPos) {
     let parent = $pos.parent
-    if (parent.isTextblock || !closedBefore($pos) || !closedAfter($pos)) return false
+    if (parent.inlineContent || !closedBefore($pos) || !closedAfter($pos)) return false
     let override = parent.type.spec.allowGapCursor
     if (override != null) return override
     let deflt = parent.contentMatchAt($pos.index()).defaultType

package/node_modules/prosemirror-markdown/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 1.13.4 (2026-02-04)
+
+### Bug fixes
+
+Fix a regression that caused the serializer to crash when a block ends in a hard break.
+
+## 1.13.3 (2026-01-20)
+
+### Bug fixes
+
+Properly move trailing whitespace out of marks when they end in a hard break node.
+
 ## 1.13.2 (2025-03-18)
 
 ### Bug fixes

package/node_modules/prosemirror-markdown/dist/index.cjs

@@ -840,7 +840,7 @@ var MarkdownSerializerState = function () {
         }
         if (node && node.isText && marks.some(function (mark) {
           var info = _this2.getMark(mark.type.name);
-          return info && info.expelEnclosingWhitespace && (index == parent.childCount - 1 || !mark.isInSet(parent.child(index + 1).marks));
+          return info && info.expelEnclosingWhitespace && !_this2.isMarkAhead(parent, index + 1, mark);
         })) {
           var _exec3 = /^(.*?)(\s*)$/m.exec(node.text),
             _exec4 = _slicedToArray(_exec3, 3),
@@ -945,6 +945,16 @@ var MarkdownSerializerState = function () {
         trailing: (text.match(/(\s+)$/) || [undefined])[0]
       };
     }
+  }, {
+    key: "isMarkAhead",
+    value: function isMarkAhead(parent, index, mark) {
+      for (;; index++) {
+        if (index >= parent.childCount) return false;
+        var next = parent.child(index);
+        if (next.type.name != this.options.hardBreakNodeName) return mark.isInSet(next.marks);
+        index++;
+      }
+    }
   }]);
   return MarkdownSerializerState;
 }();

package/node_modules/prosemirror-markdown/dist/index.js

@@ -716,8 +716,7 @@ class MarkdownSerializerState {
             }
             if (node && node.isText && marks.some(mark => {
                 let info = this.getMark(mark.type.name);
-                return info && info.expelEnclosingWhitespace &&
-                    (index == parent.childCount - 1 || !mark.isInSet(parent.child(index + 1).marks));
+                return info && info.expelEnclosingWhitespace && !this.isMarkAhead(parent, index + 1, mark);
             })) {
                 let [_, rest, trail] = /^(.*?)(\s*)$/m.exec(node.text);
                 if (trail) {
@@ -861,6 +860,19 @@ class MarkdownSerializerState {
             trailing: (text.match(/(\s+)$/) || [undefined])[0]
         };
     }
+    /**
+    @internal
+    */
+    isMarkAhead(parent, index, mark) {
+        for (;; index++) {
+            if (index >= parent.childCount)
+                return false;
+            let next = parent.child(index);
+            if (next.type.name != this.options.hardBreakNodeName)
+                return mark.isInSet(next.marks);
+            index++;
+        }
+    }
 }
 
 export { MarkdownParser, MarkdownSerializer, MarkdownSerializerState, defaultMarkdownParser, defaultMarkdownSerializer, schema };

package/node_modules/prosemirror-markdown/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prosemirror-markdown",
-  "version": "1.13.2",
+  "version": "1.13.4",
   "description": "ProseMirror Markdown integration",
   "type": "module",
   "main": "dist/index.cjs",

package/node_modules/prosemirror-markdown/src/to_markdown.ts

@@ -151,7 +151,7 @@ export const defaultMarkdownSerializer = new MarkdownSerializer({
 })
 
 function backticksFor(node: Node, side: number) {
-  let ticks = /`+/g, m, len = 0
+  let ticks = /`+/g, m: RegExpExecArray | null, len = 0
   if (node.isText) while (m = ticks.exec(node.text!)) len = Math.max(len, m[0].length)
   let result = len > 0 && side > 0 ? " `" : "`"
   for (let i = 0; i < len; i++) result += "`"
@@ -330,8 +330,7 @@ export class MarkdownSerializerState {
       }
       if (node && node.isText && marks.some(mark => {
         let info = this.getMark(mark.type.name)
-        return info && info.expelEnclosingWhitespace &&
-          (index == parent.childCount - 1 || !mark.isInSet(parent.child(index + 1).marks))
+        return info && info.expelEnclosingWhitespace && !this.isMarkAhead(parent, index + 1, mark)
       })) {
         let [_, rest, trail] = /^(.*?)(\s*)$/m.exec(node.text!)!
         if (trail) {
@@ -471,4 +470,14 @@ export class MarkdownSerializerState {
       trailing: (text.match(/(\s+)$/) || [undefined])[0]
     }
   }
+
+  /// @internal
+  isMarkAhead(parent: Node, index: number, mark: Mark) {
+    for (;; index++) {
+      if (index >= parent.childCount) return false
+      let next = parent.child(index)
+      if (next.type.name != this.options.hardBreakNodeName) return mark.isInSet(next.marks)
+      index++
+    }
+  }
 }