lib0 0.2.115-4 → 0.2.115-6

package/delta/{d2.js → delta.js}

@@ -10,7 +10,8 @@
 
 import * as list from '../list.js'
 import * as object from '../object.js'
-import * as traits from '../traits.js'
+import * as equalityTrait from '../trait/equality.js'
+import * as fingerprintTrait from '../trait/fingerprint.js'
 import * as arr from '../array.js'
 import * as fun from '../function.js'
 import * as s from '../schema.js'
@@ -20,6 +21,7 @@ import * as rabin from '../hash/rabin.js'
 import * as encoding from '../encoding.js'
 import * as buffer from '../buffer.js'
 import * as patience from '../diff/patience.js'
+import * as prng from '../prng.js'
 
 /**
  * @typedef {{
@@ -103,10 +105,6 @@ const _cloneAttrs = attrs => attrs == null ? attrs : { ...attrs }
  */
 const _markMaybeDeltaAsDone = maybeDelta => $deltaAny.check(maybeDelta) ? /** @type {MaybeDelta} */ (maybeDelta.done()) : maybeDelta
 
-/**
- * @typedef {unknown & DeltaAny} Q
- */
-
 export class TextOp extends list.ListNode {
   /**
    * @param {string} insert
@@ -185,7 +183,7 @@ export class TextOp extends list.ListNode {
   /**
    * @param {TextOp} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equalityTrait.EqualityTraitSymbol] (other) {
     return fun.equalityDeep(this.insert, other.insert) && fun.equalityDeep(this.format, other.format) && fun.equalityDeep(this.attribution, other.attribution)
   }
 
@@ -198,7 +196,7 @@ export class TextOp extends list.ListNode {
 }
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} ArrayContent
+ * @template {fingerprintTrait.Fingerprintable} ArrayContent
  */
 export class InsertOp extends list.ListNode {
   /**
@@ -273,13 +271,7 @@ export class InsertOp extends list.ListNode {
       encoding.writeVarUint(encoder, 1) // insertOp type: 1
       encoding.writeVarUint(encoder, this.insert.length)
       this.insert.forEach(ins => {
-        if ($deltaAny.check(ins)) {
-          encoding.writeUint8(encoder, 0)
-          encoding.writeVarString(encoder, ins.fingerprint)
-        } else {
-          encoding.writeUint8(encoder, 1)
-          encoding.writeAny(encoder, ins)
-        }
+        encoding.writeVarString(encoder, fingerprintTrait.fingerprint(ins))
       })
       encoding.writeAny(encoder, this.format)
     })))
@@ -308,7 +300,7 @@ export class InsertOp extends list.ListNode {
   /**
    * @param {InsertOp<ArrayContent>} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equalityTrait.EqualityTraitSymbol] (other) {
     return fun.equalityDeep(this.insert, other.insert) && fun.equalityDeep(this.format, other.format) && fun.equalityDeep(this.attribution, other.attribution)
   }
 
@@ -321,7 +313,7 @@ export class InsertOp extends list.ListNode {
 }
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} [Children=never]
+ * @template {fingerprintTrait.Fingerprintable} [Children=never]
  * @template {string} [Text=never]
  */
 export class DeleteOp extends list.ListNode {
@@ -382,7 +374,7 @@ export class DeleteOp extends list.ListNode {
   /**
    * @param {DeleteOp} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equalityTrait.EqualityTraitSymbol] (other) {
     return this.delete === other.delete
   }
 
@@ -463,7 +455,7 @@ export class RetainOp extends list.ListNode {
   /**
    * @param {RetainOp} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equalityTrait.EqualityTraitSymbol] (other) {
     return this.retain === other.retain && fun.equalityDeep(this.format, other.format) && fun.equalityDeep(this.attribution, other.attribution)
   }
 
@@ -563,8 +555,8 @@ export class ModifyOp extends list.ListNode {
   /**
    * @param {ModifyOp<any>} other
    */
-  [traits.EqualityTraitSymbol] (other) {
-    return this.value[traits.EqualityTraitSymbol](other.value) && fun.equalityDeep(this.format, other.format) && fun.equalityDeep(this.attribution, other.attribution)
+  [equalityTrait.EqualityTraitSymbol] (other) {
+    return this.value[equalityTrait.EqualityTraitSymbol](other.value) && fun.equalityDeep(this.format, other.format) && fun.equalityDeep(this.attribution, other.attribution)
   }
 
   /**
@@ -576,7 +568,7 @@ export class ModifyOp extends list.ListNode {
 }
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} V
+ * @template {fingerprintTrait.Fingerprintable} V
  * @template {string|number} [K=any]
  */
 export class AttrInsertOp {
@@ -661,7 +653,7 @@ export class AttrInsertOp {
   /**
    * @param {AttrInsertOp<V>} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equalityTrait.EqualityTraitSymbol] (other) {
     return this.key === other.key && fun.equalityDeep(this.value, other.value) && fun.equalityDeep(this.attribution, other.attribution)
   }
 
@@ -726,7 +718,7 @@ export class AttrDeleteOp {
   /**
    * @param {AttrDeleteOp<V>} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equalityTrait.EqualityTraitSymbol] (other) {
     return this.key === other.key && fun.equalityDeep(this.attribution, other.attribution)
   }
 
@@ -800,8 +792,8 @@ export class AttrModifyOp {
   /**
    * @param {AttrModifyOp<Modifier>} other
    */
-  [traits.EqualityTraitSymbol] (other) {
-    return this.key === other.key && this.value[traits.EqualityTraitSymbol](other.value)
+  [equalityTrait.EqualityTraitSymbol] (other) {
+    return this.key === other.key && this.value[equalityTrait.EqualityTraitSymbol](other.value)
   }
 
   /**
@@ -823,7 +815,7 @@ export const $deleteOp = s.$custom(o => o != null && (o.constructor === DeleteOp
 export const $insertOp = s.$custom(o => o != null && (o.constructor === AttrInsertOp || o.constructor === InsertOp))
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} Content
+ * @template {fingerprintTrait.Fingerprintable} Content
  * @param {s.Schema<Content>} $content
  * @return {s.Schema<AttrInsertOp<Content> | InsertOp<Content>>}
  */
@@ -904,8 +896,8 @@ export const $anyOp = s.$union($insertOp, $deleteOp, $textOp, $modifyOp)
 /**
  * @template {string} [NodeName=any]
  * @template {{[k:string|number]:any}} [Attrs={}]
- * @template {encoding.AnyEncodable|DeltaAny|never} [Children=never]
- * @template {string|never} [Text=never]
+ * @template {fingerprintTrait.Fingerprintable} [Children=never]
+ * @template {string} [Text=never]
  * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
  */
 export class Delta {
@@ -956,6 +948,7 @@ export class Delta {
    */
   get fingerprint () {
     return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeUint32(encoder, 0xf2ae5680) // "magic number" that ensures that different types of content don't yield the same fingerprint
       encoding.writeAny(encoder, this.name)
       /**
        * @type {Array<number|string>}
@@ -985,6 +978,10 @@ export class Delta {
     })))
   }
 
+  [fingerprintTrait.FingerprintTraitSymbol] () {
+    return this.fingerprint
+  }
+
   isEmpty () {
     return object.isEmpty(this.attrs) && list.isEmpty(this.children)
   }
@@ -1021,23 +1018,30 @@ export class Delta {
    * @return {boolean}
    */
   equals (other) {
-    return this[traits.EqualityTraitSymbol](other)
+    return this[equalityTrait.EqualityTraitSymbol](other)
   }
 
   /**
    * @param {any} other
    * @return {boolean}
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equalityTrait.EqualityTraitSymbol] (other) {
     // @todo it is only necessary to compare finrerprints OR do a deep equality check (remove
     // childCnt as well)
     return this.name === other.name && fun.equalityDeep(this.attrs, other.attrs) && fun.equalityDeep(this.children, other.children) && this.childCnt === other.childCnt
   }
 
+  /**
+   * @return {DeltaBuilder<NodeName,Attrs,Children,Text,Schema>}
+   */
+  clone () {
+    return this.slice(0, this.childCnt)
+  }
+
   /**
    * @param {number} start
    * @param {number} end
-   * @return {Delta<NodeName,Attrs,Children,Text,Schema>}
+   * @return {DeltaBuilder<NodeName,Attrs,Children,Text,Schema>}
    */
   slice (start = 0, end = this.childCnt) {
     const cpy = /** @type {DeltaAny} */ (new DeltaBuilder(/** @type {any} */ (this.name), this.$schema))
@@ -1104,7 +1108,7 @@ export class Delta {
 /**
  * @template {DeltaAny} D
  * @param {D} d
- * @return {D extends Delta<infer NodeName,infer Attrs,infer Children,infer Text,infer Schema> ? DeltaBuilder<NodeName,Attrs,Children,Text,Schema> : never}
+ * @return {D extends DeltaBuilder<infer NodeName,infer Attrs,infer Children,infer Text,infer Schema> ? DeltaBuilder<NodeName,Attrs,Children,Text,Schema> : never}
  */
 export const clone = d => /** @type {any} */ (d.slice(0, d.childCnt))
 
@@ -1158,8 +1162,8 @@ const modDeltaCheck = d => {
 /**
  * @template {string} [NodeName=any]
  * @template {{[key:string|number]:any}} [Attrs={}]
- * @template {encoding.AnyEncodable|DeltaAny|never} [Children=never]
- * @template {string|never} [Text=never]
+ * @template {fingerprintTrait.Fingerprintable} [Children=never]
+ * @template {string} [Text=never]
  * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
  * @extends {Delta<NodeName,Attrs,Children,Text,Schema>}
  */
@@ -1423,7 +1427,7 @@ export class DeltaBuilder extends Delta {
     modDeltaCheck(this)
     this.$schema?.expect(other)
     // apply attrs
-    for (let op of other.attrs) {
+    for (const op of other.attrs) {
       const c = /** @type {AttrInsertOp<any,any>|AttrDeleteOp<any>|AttrModifyOp<any,any>} */ (this.attrs[op.key])
       if ($modifyOp.check(op)) {
         if ($deltaAny.check(c?.value)) {
@@ -1433,12 +1437,14 @@ export class DeltaBuilder extends Delta {
           // @ts-ignore
           this.attrs[op.key] = op.clone()
         }
-      } else {
-        op = /** @type {any} */ (op.clone())
+      } else if ($insertOp.check(op)) {
         // @ts-ignore
         op.prevValue = c?.value
         // @ts-ignore
-        this.attrs[op.key] = op
+        this.attrs[op.key] = op.clone()
+      } else if ($deleteOp.check(op)) {
+        op.prevValue = c?.value
+        delete this.attrs[op.key]
       }
     }
     // apply children
@@ -1470,26 +1476,50 @@ export class DeltaBuilder extends Delta {
         if (offset === 0) {
           list.insertBetween(this.children, opsI == null ? this.children.end : opsI.prev, opsI, scheduleForMerge(op.clone()))
         } else {
+          // @todo inmplement "splitHelper" and "insertHelper" - I'm splitting all the time and
+          // forget to update opsI
           if (opsI == null) error.unexpectedCase()
           const cpy = scheduleForMerge(opsI.clone(offset))
           opsI._splice(offset, opsI.length - offset)
           list.insertBetween(this.children, opsI, opsI.next || null, cpy)
           list.insertBetween(this.children, opsI, cpy || null, scheduleForMerge(op.clone()))
+          opsI = cpy
           offset = 0
         }
         this.childCnt += op.insert.length
       } else if ($retainOp.check(op)) {
-        let skipLen = op.length
-        while (opsI != null && opsI.length - offset <= skipLen) {
-          skipLen -= opsI.length - offset
+        let retainLen = op.length
+
+        if (offset > 0 && opsI != null && op.format != null && !$deleteOp.check(opsI) && !object.every(op.format, (v, k) => fun.equalityDeep(v, /** @type {InsertOp<any>|RetainOp|ModifyOp} */ (opsI).format?.[k] || null))) {
+          // need to split current op
+          const cpy = scheduleForMerge(opsI.clone(offset))
+          opsI._splice(offset, opsI.length - offset)
+          list.insertBetween(this.children, opsI, opsI.next || null, cpy)
+          opsI = cpy
+          offset = 0
+        }
+
+        while (opsI != null && opsI.length - offset <= retainLen) {
+          op.format != null && updateOpFormat(opsI, op.format)
+          retainLen -= opsI.length - offset
           opsI = opsI?.next || null
           offset = 0
         }
+
         if (opsI != null) {
-          offset += skipLen
-        } else {
-          list.pushEnd(this.children, scheduleForMerge(new RetainOp(skipLen, op.format, op.attribution)))
-          this.childCnt += skipLen
+          if (op.format != null && retainLen > 0) {
+            // split current op and apply format
+            const cpy = scheduleForMerge(opsI.clone(retainLen))
+            opsI._splice(retainLen, opsI.length - retainLen)
+            list.insertBetween(this.children, opsI, opsI.next || null, cpy)
+            updateOpFormat(opsI, op.format)
+            opsI = cpy
+          } else {
+            offset += retainLen
+          }
+        } else if (retainLen > 0) {
+          list.pushEnd(this.children, scheduleForMerge(new RetainOp(retainLen, op.format, op.attribution)))
+          this.childCnt += retainLen
         }
       } else if ($deleteOp.check(op)) {
         let remainingLen = op.delete
@@ -1520,6 +1550,7 @@ export class DeltaBuilder extends Delta {
               offset = 0
               scheduleForMerge(opsI.next)
               list.remove(this.children, opsI)
+              opsI = opsI.next
             } else if (offset === 0) {
               // case 2
               offset = 0
@@ -1734,17 +1765,159 @@ export class DeltaBuilder extends Delta {
     console.info('method rebaseOnInverse unimplemented')
     return this
   }
+
+  /**
+   * Append child ops from one op to the other.
+   *
+   *     delta.create().insert('a').append(delta.create().insert('b')) // => insert "ab"
+   *
+   * @template {DeltaAny} OtherDelta
+   * @param {OtherDelta} other
+   * @return {CastToDelta<OtherDelta> extends Delta<any,any,infer OtherChildren,infer OtherText,any> ? DeltaBuilder<NodeName,Attrs,Children|OtherChildren,Text|OtherText,Schema> : never}
+   */
+  append (other) {
+    const children = this.children
+    const prevLast = children.end
+    // @todo Investigate. Above is a typescript issue. It is necessary to cast OtherDelta to a Delta first before
+    // inferring type, otherwise Children will contain Text.
+    for (const child of other.children) {
+      list.pushEnd(children, child.clone())
+    }
+    this.childCnt += other.childCnt
+    prevLast?.next && tryMergeWithPrev(children, prevLast.next)
+    // @ts-ignore
+    return this
+  }
 }
 
+/**
+ * @param {ChildrenOpAny} op
+ * @param {{[k:string]:any}} formatUpdate
+ */
+const updateOpFormat = (op, formatUpdate) => {
+  if (!$deleteOp.check(op)) {
+    // apply formatting attributes
+    for (const k in formatUpdate) {
+      const v = formatUpdate[k]
+      if (v != null || $retainOp.check(op)) {
+        // never modify formats
+        /** @type {any} */ (op).format = object.assign({}, op.format, { [k]: v })
+      } else if (op.format != null) {
+        const { [k]: _, ...rest } = op.format
+        ;/** @type {any} */ (op).format = rest
+      }
+    }
+  }
+}
+
+/**
+ * @template {DeltaAny} D
+ * @typedef {D extends DeltaBuilder<infer N,infer Attrs,infer Children,infer Text,infer Schema> ? Delta<N,Attrs,Children,Text,Schema> : D} CastToDelta
+ */
+
 /**
  * @template {string} NodeName
  * @template {{ [key: string|number]: any }} [Attrs={}]
- * @template {encoding.AnyEncodable|DeltaAny|never} [Children=never]
+ * @template {fingerprintTrait.Fingerprintable|never} [Children=never]
  * @template {string|never} [Text=never]
  * @typedef {Delta<NodeName,Attrs,Children|Delta<NodeName,Attrs,Children,Text>|RecursiveDelta<NodeName,Attrs,Children,Text>,Text>} RecursiveDelta
  */
 
 /**
+ * @template {string} Name
+ * @template {{[k:string|number]:any}} Attrs
+ * @template {fingerprintTrait.Fingerprintable} Children
+ * @template {boolean} HasText
+ * @template {{ [k:string]:any }} Formats
+ * @template {boolean} Recursive
+ * @extends {s.Schema<Delta<
+ *   Name,
+ *   Attrs,
+ *   Children|(Recursive extends true ? RecursiveDelta<Name,Attrs,Children,HasText extends true ? string : never> : never),
+ *   HasText extends true ? string : never,
+ *   any>>}
+ */
+export class $Delta extends s.Schema {
+  /**
+   * @param {s.Schema<Name>} $name
+   * @param {s.Schema<Attrs>} $attrs
+   * @param {s.Schema<Children>} $children
+   * @param {HasText} hasText
+   * @param {s.Schema<Formats>} $formats
+   * @param {Recursive} recursive
+   */
+  constructor ($name, $attrs, $children, hasText, $formats, recursive) {
+    super()
+    const $attrsPartial = s.$$object.check($attrs) ? $attrs.partial : $attrs
+    if (recursive) {
+      // @ts-ignore
+      $children = s.$union($children, this)
+    }
+    this.shape = { $name, $attrs: $attrsPartial, $children, hasText, $formats }
+  }
+
+  /**
+   * @param {any} o
+   * @param {s.ValidationError} [err]
+   * @return {o is Delta<
+   *   Name,
+   *   Attrs,
+   *   Children|(Recursive extends true ? RecursiveDelta<Name,Attrs,Children,HasText extends true ? string : never> : never),
+   *   HasText extends true ? string : never,
+   *   any>}
+   */
+  check (o, err = undefined) {
+    const { $name, $attrs, $children, hasText, $formats } = this.shape
+    if (!(o instanceof Delta)) {
+      err?.extend(null, 'Delta', o?.constructor.name, 'Constructor match failed')
+    } else if (o.name != null && !$name.check(o.name, err)) {
+      err?.extend('Delta.name', $name.toString(), o.name, 'Unexpected node name')
+    } else if (list.toArray(o.children).some(c => (!hasText && $textOp.check(c)) || (hasText && $textOp.check(c) && c.format != null && !$formats.check(c.format)) || ($insertOp.check(c) && !c.insert.every(ins => $children.check(ins))))) {
+      err?.extend('Delta.children', '', '', 'Children don\'t match the schema')
+    } else if (object.some(o.attrs, (op, k) => $insertOp.check(op) && !$attrs.check({ [k]: op.value }, err))) {
+      err?.extend('Delta.attrs', '', '', 'Attrs don\'t match the schema')
+    } else {
+      return true
+    }
+    return false
+  }
+}
+
+/**
+ * @template {s.Schema<string>|string|Array<string>} [NodeNameSchema=s.Schema<any>]
+ * @template {s.Schema<{ [key: string|number]: any }>|{ [key:string|number]:any }} [AttrsSchema=s.Schema<{}>]
+ * @template {any} [ChildrenSchema=s.Schema<never>]
+ * @template {boolean} [HasText=false]
+ * @template {boolean} [Recursive=false]
+ * @template {{ [k:string]:any }} [Formats={[k:string]:any}]
+ * @param {object} opts
+ * @param {NodeNameSchema?} [opts.name]
+ * @param {AttrsSchema?} [opts.attrs] What key-value pairs are included.
+ * @param {ChildrenSchema?} [opts.children] The type of content in `insertOp`
+ * @param {HasText} [opts.text] Whether this delta contains text using `textOp`
+ * @param {Formats} [opts.formats]
+ * @param {Recursive} [opts.recursive]
+ * @return {[s.Unwrap<s.ReadSchema<NodeNameSchema>>,s.Unwrap<s.ReadSchema<AttrsSchema>>,s.Unwrap<s.ReadSchema<ChildrenSchema>>] extends [infer NodeName, infer Attrs, infer Children] ? s.Schema<Delta<
+ *     NodeName,
+ *     Attrs,
+ *     Children|(Recursive extends true ? RecursiveDelta<NodeName,Attrs,Children,HasText extends true ? string : never> : never),
+ *     HasText extends true ? string : never
+ * >> : never}
+ */
+export const $delta = ({ name, attrs, children, text, formats, recursive }) => /** @type {any} */ (new $Delta(
+  name == null ? s.$any : s.$(name),
+  /** @type {any} */ (attrs == null ? s.$object({}) : s.$(attrs)),
+  /** @type {any} */ (children == null ? s.$never : s.$(children)),
+  text ?? false,
+  formats == null ? s.$any : s.$(formats),
+  recursive ?? false
+))
+
+export const $$delta = s.$constructedBy($Delta)
+
+/**
+ * @todo remove this
+ *
  * @template {s.Schema<string>|string|Array<string>} [NodeNameSchema=s.Schema<any>]
  * @template {s.Schema<{ [key: string|number]: any }>|{ [key:string|number]:any }} [AttrsSchema=s.Schema<{}>]
  * @template {any} [ChildrenSchema=s.Schema<never>]
@@ -1763,7 +1936,7 @@ export class DeltaBuilder extends Delta {
  *     HasText extends true ? string : never
  * >> : never}
  */
-export const $delta = ({ name, attrs, children, text, recursive }) => {
+export const _$delta = ({ name, attrs, children, text, recursive }) => {
   /**
    * @type {s.Schema<Array<any>>}
    */
@@ -1795,6 +1968,11 @@ export const $delta = ({ name, attrs, children, text, recursive }) => {
  */
 export const $deltaAny = /** @type {any} */ (s.$instanceOf(Delta))
 
+/**
+ * @type {s.Schema<DeltaBuilderAny>}
+ */
+export const $deltaBuilderAny = /** @type {any} */ (s.$instanceOf(DeltaBuilder))
+
 /**
  * Helper function to merge attribution and attributes. The latter input "wins".
  *
@@ -1802,7 +1980,9 @@ export const $deltaAny = /** @type {any} */ (s.$instanceOf(Delta))
  * @param {T | null} a
  * @param {T | null} b
  */
-export const mergeAttrs = (a, b) => object.isEmpty(a) ? b : (object.isEmpty(b) ? a : object.assign({}, a, b))
+export const mergeAttrs = (a, b) => object.isEmpty(a)
+  ? (object.isEmpty(b) ? null : b)
+  : (object.isEmpty(b) ? a : object.assign({}, a, b))
 
 /**
  * @template {DeltaAny|null} D
@@ -1819,6 +1999,35 @@ export const mergeDeltas = (a, b) => {
   return a == null ? b : (a || null)
 }
 
+/**
+ * @template {DeltaAny} D
+ * @param {prng.PRNG} gen
+ * @param {s.Schema<D>} $d
+ * @return {D extends Delta<infer NodeName,infer Attrs,infer Children,infer Text,infer Schema> ? DeltaBuilder<NodeName,Attrs,Children,Text,Schema> : never}
+ */
+export const random = (gen, $d) => {
+  const { $name, $attrs, $children, hasText, $formats: $formats_ } = /** @type {$Delta<any,any,any,boolean,any,any>} */ (/** @type {any} */ ($d)).shape
+  const d = s.$$any.check($name) ? create($deltaAny) : create(s.random(gen, $name), $deltaAny)
+  const $formats = s.$$any.check($formats_) ? s.$null : $formats_
+  prng.bool(gen) && d.setMany(s.random(gen, $attrs))
+  for (let i = prng.uint32(gen, 0, 5); i > 0; i--) {
+    if (hasText && prng.bool(gen)) {
+      d.insert(prng.word(gen), s.random(gen, $formats))
+    } else if (!s.$$never.check($children)) {
+      /**
+       * @type {Array<any>}
+       */
+      const ins = []
+      let insN = prng.int32(gen, 0, 5)
+      while (insN--) {
+        ins.push(s.random(gen, $children))
+      }
+      d.insert(ins, s.random(gen, $formats))
+    }
+  }
+  return /** @type {any} */ (d)
+}
+
 /**
  * @overload
  * @return {DeltaBuilder<any,{},never,never,null>}
@@ -1879,12 +2088,12 @@ export const create = (nodeNameOrSchema, attrsOrSchema, children) => {
 // DELTA TEXT
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} [Embeds=never]
+ * @template {fingerprintTrait.Fingerprintable} [Embeds=never]
  * @typedef {Delta<any,{},Embeds,string>} TextDelta
  */
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} [Embeds=never]
+ * @template {fingerprintTrait.Fingerprintable} [Embeds=never]
  * @typedef {DeltaBuilder<any,{},Embeds,string>} TextDeltaBuilder
  */
 
@@ -1904,12 +2113,12 @@ export const $textOnly = $text()
 export const text = $schema => /** @type {any} */ (create($schema || $textOnly))
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} Children
+ * @template {fingerprintTrait.Fingerprintable} Children
  * @typedef {Delta<any,{},Children,never>} ArrayDelta
  */
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} Children
+ * @template {fingerprintTrait.Fingerprintable} Children
  * @typedef {DeltaBuilder<any,{},Children,never>} ArrayDeltaBuilder
  */
 
@@ -1955,7 +2164,7 @@ export const map = $schema => /** @type {any} */ (create(/** @type {any} */ ($sc
  * @template {DeltaAny} D
  * @param {D} d1
  * @param {NoInfer<D>} d2
- * @return {D}
+ * @return {D extends Delta<infer N,infer Attrs,infer Children,infer Text,any> ? DeltaBuilder<N,Attrs,Children,Text,null> : never}
  */
 export const diff = (d1, d2) => {
   /**
@@ -2006,32 +2215,136 @@ export const diff = (d1, d2) => {
       d.retain(change.index - lastIndex1)
       // insert minimal diff at curred position in d
       /**
-       * @param {DeltaBuilderAny} d
+       *
+       * @todo it would be better if these would be slices of delta (an actual delta)
+       *
        * @param {ChildrenOpAny[]} opsIs
        * @param {ChildrenOpAny[]} opsShould
-       *
        */
-      const diffAndApply = (d, opsIs, opsShould) => {
-        // naive implementation
-        d.delete(opsIs.reduce((currLen, op) => currLen + op.length, 0))
-        opsShould.forEach(newIns => {
-          if ($insertOp.check(newIns) || $textOp.check(newIns)) {
-            d.insert(newIns.insert)
-          } else {
-            error.unexpectedCase()
+      const diffAndApply = (opsIs, opsShould) => {
+        const d = create()
+        // @todo unoptimized implementation. Convert content to array and diff that based on
+        // generated fingerprints. We probably could do better and cache more information.
+        // - benchmark
+        // - cache fingerprints in ops
+        /**
+         * @type {Array<string|DeltaAny|fingerprintTrait.Fingerprintable>}
+         */
+        const isContent = opsIs.flatMap(op => $insertOp.check(op) ? op.insert : ($textOp.check(op) ? op.insert.split('') : error.unexpectedCase()))
+        /**
+         * @type {Array<string|DeltaAny|fingerprintTrait.Fingerprintable>}
+         */
+        const shouldContent = opsShould.flatMap(op => $insertOp.check(op) ? op.insert : ($textOp.check(op) ? op.insert.split('') : error.unexpectedCase()))
+        const isContentFingerprinted = isContent.map(c => s.$string.check(c) ? c : fingerprintTrait.fingerprint(c))
+        const shouldContentFingerprinted = shouldContent.map(c => s.$string.check(c) ? c : fingerprintTrait.fingerprint(c))
+        const hasFormatting = opsIs.some(op => !$deleteOp.check(op) && op.format != null) || opsShould.some(op => !$deleteOp.check(op) && op.format != null)
+        /**
+         * @type {{ index: number, insert: Array<string|DeltaAny|fingerprintTrait.Fingerprintable>, remove: Array<string|DeltaAny|fingerprintTrait.Fingerprintable> }[]}
+         */
+        const cdiff = patience.diff(isContentFingerprinted, shouldContentFingerprinted)
+        // overwrite fingerprinted content with actual content
+        for (let i = 0, adj = 0; i < cdiff.length; i++) {
+          const cd = cdiff[i]
+          cd.remove = isContent.slice(cd.index, cd.index + cd.remove.length)
+          cd.insert = shouldContent.slice(cd.index + adj, cd.index + adj + cd.insert.length)
+          adj += cd.remove.length - cd.insert.length
+        }
+        for (let i = 0, lastIndex = 0; i < cdiff.length; i++) {
+          const cd = cdiff[i]
+          d.retain(cd.index - lastIndex)
+          let cdii = 0
+          let cdri = 0
+          // try to match as much content as possible, preferring to skip over non-deltas
+          for (; cdii < cd.insert.length && cdri < cd.remove.length;) {
+            const a = cd.insert[cdii]
+            const b = cd.remove[cdri]
+            if ($deltaAny.check(a) && $deltaAny.check(b) && a.name === b.name) {
+              d.modify(diff(b, a))
+              cdii++
+              cdri++
+            } else if ($deltaAny.check(b)) {
+              d.insert(s.$string.check(a) ? a : [a])
+              cdii++
+            } else {
+              d.delete(1)
+              cdri++
+            }
           }
-        })
+          for (; cdii < cd.insert.length; cdii++) {
+            const a = cd.insert[cdii]
+            d.insert(s.$string.check(a) ? a : [a])
+          }
+          d.delete(cd.remove.length - cdri)
+        }
+        // create the diff for formatting
+        if (hasFormatting) {
+          const formattingDiff = create()
+          // update opsIs with content diff. then we can figure out the formatting diff.
+          const isUpdated = create()
+          // copy opsIs to fresh delta
+          opsIs.forEach(op => {
+            isUpdated.childCnt += op.length
+            list.pushEnd(isUpdated.children, op.clone())
+          })
+          isUpdated.apply(d)
+          let shouldI = 0
+          let shouldOffset = 0
+          let isOp = isUpdated.children.start
+          let isOffset = 0
+          while (shouldI < opsShould.length && isOp != null) {
+            const shouldOp = opsShould[shouldI]
+            if (!$deleteOp.check(shouldOp) && !$deleteOp.check(isOp)) {
+              const isFormat = isOp.format
+              const minForward = math.min(shouldOp.length - shouldOffset, isOp.length - isOffset)
+              shouldOffset += minForward
+              isOffset += minForward
+              if (fun.equalityDeep(shouldOp.format, isFormat)) {
+                formattingDiff.retain(minForward)
+              } else {
+                /**
+                 * @type {FormattingAttributes}
+                 */
+                const fupdate = {}
+                shouldOp.format != null && object.forEach(shouldOp.format, (v, k) => {
+                  if (!fun.equalityDeep(v, isFormat?.[k] || null)) {
+                    fupdate[k] = v
+                  }
+                })
+                isFormat && object.forEach(isFormat, (_, k) => {
+                  if (shouldOp?.format?.[k] === undefined) {
+                    fupdate[k] = null
+                  }
+                })
+                formattingDiff.retain(minForward, fupdate)
+              }
+              // update offset and iterators
+              if (shouldOffset >= shouldOp.length) {
+                shouldI++
+                shouldOffset = 0
+              }
+              if (isOffset >= isOp.length) {
+                isOp = isOp.next
+                isOffset = 0
+              }
+            }
+          }
+          d.apply(formattingDiff)
+        }
+        return d
       }
-      diffAndApply(d, ops1.slice(change.index, change.index + change.remove.length), ops2.slice(change.index + currIndexOffset2, change.insert.length))
+      const subd = diffAndApply(ops1.slice(change.index, change.index + change.remove.length), ops2.slice(change.index + currIndexOffset2, change.index + currIndexOffset2 + change.insert.length))
+      d.append(subd)
       lastIndex1 = change.index + change.remove.length
       currIndexOffset2 += change.insert.length - change.remove.length
     }
     for (const attr2 of d2.attrs) {
       const attr1 = d1.attrs[attr2.key]
       if (attr1 == null || (attr1.fingerprint !== attr2.fingerprint)) {
+        /* c8 ignore else */
         if ($insertOp.check(attr2)) {
           d.set(attr2.key, attr2.value)
         } else {
+          /* c8 ignore next 2 */
           error.unexpectedCase()
         }
       }
@@ -2042,5 +2355,5 @@ export const diff = (d1, d2) => {
       }
     }
   }
-  return /** @type {D} */ (d.done())
+  return /** @type {any} */ (d.done(false))
 }