lib0 0.2.115-4 → 0.2.115-6

package/dist/{d2.cjs → delta.cjs}

@@ -3,19 +3,21 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var list = require('./list.cjs');
-var object = require('./object-18980796.cjs');
-var traits = require('./traits.cjs');
+var object = require('./object-dec41ef9.cjs');
+var equality = require('./equality.cjs');
+var fingerprint = require('./fingerprint.cjs');
 var array$1 = require('./array-78849c95.cjs');
-var _function = require('./function-e7d18feb.cjs');
+var _function = require('./function-618aa640.cjs');
 var schema = require('./schema.cjs');
 var error = require('./error-0c1f634f.cjs');
 var math = require('./math-96d5e8c4.cjs');
 var rabin = require('./rabin.cjs');
 var encoding = require('./encoding-1a745c43.cjs');
-var buffer = require('./buffer-7f6fa8fa.cjs');
+var buffer = require('./buffer-54360f21.cjs');
 var patience = require('./patience.cjs');
+var prng = require('./prng-96eef52a.cjs');
 require('./set-5b47859e.cjs');
-require('./environment-90227ead.cjs');
+require('./environment-ae4f6f15.cjs');
 require('./map-24d263c0.cjs');
 require('./string-fddc5f8b.cjs');
 require('./conditions-f5c0c102.cjs');
@@ -116,10 +118,6 @@ const _cloneAttrs = attrs => attrs == null ? attrs : { ...attrs };
  */
 const _markMaybeDeltaAsDone = maybeDelta => $deltaAny.check(maybeDelta) ? /** @type {MaybeDelta} */ (maybeDelta.done()) : maybeDelta;
 
-/**
- * @typedef {unknown & DeltaAny} Q
- */
-
 class TextOp extends list.ListNode {
   /**
    * @param {string} insert
@@ -198,7 +196,7 @@ class TextOp extends list.ListNode {
   /**
    * @param {TextOp} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equality.EqualityTraitSymbol] (other) {
     return _function.equalityDeep(this.insert, other.insert) && _function.equalityDeep(this.format, other.format) && _function.equalityDeep(this.attribution, other.attribution)
   }
 
@@ -211,7 +209,7 @@ class TextOp extends list.ListNode {
 }
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} ArrayContent
+ * @template {fingerprintTrait.Fingerprintable} ArrayContent
  */
 class InsertOp extends list.ListNode {
   /**
@@ -286,13 +284,7 @@ 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, fingerprint.fingerprint(ins));
       });
       encoding.writeAny(encoder, this.format);
     })))
@@ -321,7 +313,7 @@ class InsertOp extends list.ListNode {
   /**
    * @param {InsertOp<ArrayContent>} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equality.EqualityTraitSymbol] (other) {
     return _function.equalityDeep(this.insert, other.insert) && _function.equalityDeep(this.format, other.format) && _function.equalityDeep(this.attribution, other.attribution)
   }
 
@@ -334,7 +326,7 @@ class InsertOp extends list.ListNode {
 }
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} [Children=never]
+ * @template {fingerprintTrait.Fingerprintable} [Children=never]
  * @template {string} [Text=never]
  */
 class DeleteOp extends list.ListNode {
@@ -395,7 +387,7 @@ class DeleteOp extends list.ListNode {
   /**
    * @param {DeleteOp} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equality.EqualityTraitSymbol] (other) {
     return this.delete === other.delete
   }
 
@@ -476,7 +468,7 @@ class RetainOp extends list.ListNode {
   /**
    * @param {RetainOp} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equality.EqualityTraitSymbol] (other) {
     return this.retain === other.retain && _function.equalityDeep(this.format, other.format) && _function.equalityDeep(this.attribution, other.attribution)
   }
 
@@ -576,8 +568,8 @@ class ModifyOp extends list.ListNode {
   /**
    * @param {ModifyOp<any>} other
    */
-  [traits.EqualityTraitSymbol] (other) {
-    return this.value[traits.EqualityTraitSymbol](other.value) && _function.equalityDeep(this.format, other.format) && _function.equalityDeep(this.attribution, other.attribution)
+  [equality.EqualityTraitSymbol] (other) {
+    return this.value[equality.EqualityTraitSymbol](other.value) && _function.equalityDeep(this.format, other.format) && _function.equalityDeep(this.attribution, other.attribution)
   }
 
   /**
@@ -589,7 +581,7 @@ class ModifyOp extends list.ListNode {
 }
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} V
+ * @template {fingerprintTrait.Fingerprintable} V
  * @template {string|number} [K=any]
  */
 class AttrInsertOp {
@@ -674,7 +666,7 @@ class AttrInsertOp {
   /**
    * @param {AttrInsertOp<V>} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equality.EqualityTraitSymbol] (other) {
     return this.key === other.key && _function.equalityDeep(this.value, other.value) && _function.equalityDeep(this.attribution, other.attribution)
   }
 
@@ -739,7 +731,7 @@ class AttrDeleteOp {
   /**
    * @param {AttrDeleteOp<V>} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equality.EqualityTraitSymbol] (other) {
     return this.key === other.key && _function.equalityDeep(this.attribution, other.attribution)
   }
 
@@ -813,8 +805,8 @@ class AttrModifyOp {
   /**
    * @param {AttrModifyOp<Modifier>} other
    */
-  [traits.EqualityTraitSymbol] (other) {
-    return this.key === other.key && this.value[traits.EqualityTraitSymbol](other.value)
+  [equality.EqualityTraitSymbol] (other) {
+    return this.key === other.key && this.value[equality.EqualityTraitSymbol](other.value)
   }
 
   /**
@@ -836,7 +828,7 @@ const $deleteOp = schema.$custom(o => o != null && (o.constructor === DeleteOp |
 const $insertOp = schema.$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>>}
  */
@@ -917,8 +909,8 @@ const $anyOp = schema.$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]
  */
 class Delta {
@@ -969,6 +961,7 @@ 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>}
@@ -998,6 +991,10 @@ class Delta {
     })))
   }
 
+  [fingerprint.FingerprintTraitSymbol] () {
+    return this.fingerprint
+  }
+
   isEmpty () {
     return object.isEmpty(this.attrs) && list.isEmpty(this.children)
   }
@@ -1034,23 +1031,30 @@ class Delta {
    * @return {boolean}
    */
   equals (other) {
-    return this[traits.EqualityTraitSymbol](other)
+    return this[equality.EqualityTraitSymbol](other)
   }
 
   /**
    * @param {any} other
    * @return {boolean}
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equality.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 && _function.equalityDeep(this.attrs, other.attrs) && _function.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));
@@ -1117,7 +1121,7 @@ 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}
  */
 const clone = d => /** @type {any} */ (d.slice(0, d.childCnt));
 
@@ -1171,8 +1175,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>}
  */
@@ -1436,7 +1440,7 @@ 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)) {
@@ -1446,12 +1450,14 @@ 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
@@ -1483,26 +1489,50 @@ 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) => _function.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;
@@ -1533,6 +1563,7 @@ 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;
@@ -1743,17 +1774,159 @@ 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>>}
+ */
+class $Delta extends schema.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 = schema.$$object.check($attrs) ? $attrs.partial : $attrs;
+    if (recursive) {
+      // @ts-ignore
+      $children = schema.$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}
+ */
+const $delta = ({ name, attrs, children, text, formats, recursive }) => /** @type {any} */ (new $Delta(
+  name == null ? schema.$any : schema.$(name),
+  /** @type {any} */ (attrs == null ? schema.$object({}) : schema.$(attrs)),
+  /** @type {any} */ (children == null ? schema.$never : schema.$(children)),
+  text ?? false,
+  formats == null ? schema.$any : schema.$(formats),
+  recursive ?? false
+));
+
+const $$delta = schema.$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>]
@@ -1772,7 +1945,7 @@ class DeltaBuilder extends Delta {
  *     HasText extends true ? string : never
  * >> : never}
  */
-const $delta = ({ name, attrs, children, text, recursive }) => {
+const _$delta = ({ name, attrs, children, text, recursive }) => {
   /**
    * @type {s.Schema<Array<any>>}
    */
@@ -1804,6 +1977,11 @@ const $delta = ({ name, attrs, children, text, recursive }) => {
  */
 const $deltaAny = /** @type {any} */ (schema.$instanceOf(Delta));
 
+/**
+ * @type {s.Schema<DeltaBuilderAny>}
+ */
+const $deltaBuilderAny = /** @type {any} */ (schema.$instanceOf(DeltaBuilder));
+
 /**
  * Helper function to merge attribution and attributes. The latter input "wins".
  *
@@ -1811,7 +1989,9 @@ const $deltaAny = /** @type {any} */ (schema.$instanceOf(Delta));
  * @param {T | null} a
  * @param {T | null} b
  */
-const mergeAttrs = (a, b) => object.isEmpty(a) ? b : (object.isEmpty(b) ? a : object.assign({}, a, b));
+const mergeAttrs = (a, b) => object.isEmpty(a)
+  ? (object.isEmpty(b) ? null : b)
+  : (object.isEmpty(b) ? a : object.assign({}, a, b));
 
 /**
  * @template {DeltaAny|null} D
@@ -1828,6 +2008,35 @@ 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}
+ */
+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 = schema.$$any.check($name) ? create($deltaAny) : create(schema.random(gen, $name), $deltaAny);
+  const $formats = schema.$$any.check($formats_) ? schema.$null : $formats_;
+  prng.bool(gen) && d.setMany(schema.random(gen, $attrs));
+  for (let i = prng.uint32(gen, 0, 5); i > 0; i--) {
+    if (hasText && prng.bool(gen)) {
+      d.insert(prng.word(gen), schema.random(gen, $formats));
+    } else if (!schema.$$never.check($children)) {
+      /**
+       * @type {Array<any>}
+       */
+      const ins = [];
+      let insN = prng.int32(gen, 0, 5);
+      while (insN--) {
+        ins.push(schema.random(gen, $children));
+      }
+      d.insert(ins, schema.random(gen, $formats));
+    }
+  }
+  return /** @type {any} */ (d)
+};
+
 /**
  * @overload
  * @return {DeltaBuilder<any,{},never,never,null>}
@@ -1888,12 +2097,12 @@ 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
  */
 
@@ -1913,12 +2122,12 @@ const $textOnly = $text();
 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
  */
 
@@ -1964,7 +2173,7 @@ const map = $schema => /** @type {any} */ (create(/** @type {any} */ ($schema)))
  * @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}
  */
 const diff = (d1, d2) => {
   /**
@@ -2015,32 +2224,136 @@ 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 => schema.$string.check(c) ? c : fingerprint.fingerprint(c));
+        const shouldContentFingerprinted = shouldContent.map(c => schema.$string.check(c) ? c : fingerprint.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(schema.$string.check(a) ? a : [a]);
+              cdii++;
+            } else {
+              d.delete(1);
+              cdri++;
+            }
           }
-        });
+          for (; cdii < cd.insert.length; cdii++) {
+            const a = cd.insert[cdii];
+            d.insert(schema.$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 (_function.equalityDeep(shouldOp.format, isFormat)) {
+                formattingDiff.retain(minForward);
+              } else {
+                /**
+                 * @type {FormattingAttributes}
+                 */
+                const fupdate = {};
+                shouldOp.format != null && object.forEach(shouldOp.format, (v, k) => {
+                  if (!_function.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();
         }
       }
@@ -2051,15 +2364,18 @@ const diff = (d1, d2) => {
       }
     }
   }
-  return /** @type {D} */ (d.done())
+  return /** @type {any} */ (d.done(false))
 };
 
+exports.$$delta = $$delta;
+exports.$Delta = $Delta;
 exports.$anyOp = $anyOp;
 exports.$array = $array;
 exports.$attribution = $attribution;
 exports.$deleteOp = $deleteOp;
 exports.$delta = $delta;
 exports.$deltaAny = $deltaAny;
+exports.$deltaBuilderAny = $deltaBuilderAny;
 exports.$deltaMapChangeJson = $deltaMapChangeJson;
 exports.$insertOp = $insertOp;
 exports.$insertOpWith = $insertOpWith;
@@ -2080,6 +2396,7 @@ exports.InsertOp = InsertOp;
 exports.ModifyOp = ModifyOp;
 exports.RetainOp = RetainOp;
 exports.TextOp = TextOp;
+exports._$delta = _$delta;
 exports.array = array;
 exports.clone = clone;
 exports.create = create;
@@ -2087,5 +2404,6 @@ exports.diff = diff;
 exports.map = map;
 exports.mergeAttrs = mergeAttrs;
 exports.mergeDeltas = mergeDeltas;
+exports.random = random;
 exports.text = text;
-//# sourceMappingURL=d2.cjs.map
+//# sourceMappingURL=delta.cjs.map