lib0 0.2.115-1 → 0.2.115-3

package/dist/d2.cjs

@@ -10,15 +10,28 @@ var _function = require('./function-e7d18feb.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 patience = require('./patience.cjs');
 require('./set-5b47859e.cjs');
 require('./environment-90227ead.cjs');
 require('./map-24d263c0.cjs');
 require('./string-fddc5f8b.cjs');
 require('./conditions-f5c0c102.cjs');
 require('./storage.cjs');
+require('./number-1fb57bba.cjs');
+require('./binary-ac8e39e2.cjs');
+require('./decoding-76e75827.cjs');
 
 /**
  * @beta this API is about to change
+ *
+ * ## Mutability
+ *
+ * Deltas are mutable by default. But references are often shared, by marking a Delta as "done". You
+ * may only modify deltas by applying other deltas to them. Casting a Delta to a DeltaBuilder
+ * manually, will likely modify "shared" state.
  */
 
 /**
@@ -54,8 +67,9 @@ const $attribution = schema.$object({
 
 /**
  * @typedef {{
- *   name?: string
- *   attrs?: { [Key in string|number|symbol]: DeltaAttrOpJSON },
+ *   type: 'delta',
+ *   name?: string,
+ *   attrs?: { [Key in string|number]: DeltaAttrOpJSON },
  *   children?: Array<DeltaListOpJSON>
  * }} DeltaJSON
  */
@@ -68,6 +82,18 @@ const $attribution = schema.$object({
  * @typedef {{ type: 'insert', value: any, prevValue?: any, attribution?: Attribution } | { type: 'delete', prevValue?: any, attribution?: Attribution } | { type: 'modify', value: DeltaJSON }} DeltaAttrOpJSON
  */
 
+/**
+ * @typedef {TextOp|InsertOp<any>|DeleteOp|RetainOp|ModifyOp<any>} ChildrenOpAny
+ */
+
+/**
+ * @typedef {AttrInsertOp<any>|AttrDeleteOp<any>|AttrModifyOp} AttrOpAny
+ */
+
+/**
+ * @typedef {ChildrenOpAny|AttrOpAny} _OpAny
+ */
+
 /**
  * @type {s.Schema<DeltaAttrOpJSON>}
  */
@@ -88,7 +114,11 @@ const _cloneAttrs = attrs => attrs == null ? attrs : { ...attrs };
  * @param {MaybeDelta} maybeDelta
  * @return {MaybeDelta}
  */
-const _cloneMaybeDelta = maybeDelta => $deltaAny.check(maybeDelta) ? maybeDelta.clone() : maybeDelta;
+const _markMaybeDeltaAsDone = maybeDelta => $deltaAny.check(maybeDelta) ? /** @type {MaybeDelta} */ (maybeDelta.done()) : maybeDelta;
+
+/**
+ * @typedef {unknown & DeltaAny} Q
+ */
 
 class TextOp extends list.ListNode {
   /**
@@ -98,9 +128,31 @@ class TextOp extends list.ListNode {
    */
   constructor (insert, format, attribution) {
     super();
+    // Whenever this is modified, make sure to clear _fingerprint
+    /**
+     * @readonly
+     * @type {string}
+     */
     this.insert = insert;
+    /**
+     * @readonly
+     * @type {FormattingAttributes|null}
+     */
     this.format = format;
     this.attribution = attribution;
+    /**
+     * @type {string?}
+     */
+    this._fingerprint = null;
+  }
+
+  /**
+   * @param {string} newVal
+   */
+  _updateInsert (newVal) {
+    // @ts-ignore
+    this.insert = newVal;
+    this._fingerprint = null;
   }
 
   /**
@@ -114,6 +166,14 @@ class TextOp extends list.ListNode {
     return this.insert.length
   }
 
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeVarUint(encoder, 0); // textOp type: 0
+      encoding.writeVarString(encoder, this.insert);
+      encoding.writeAny(encoder, this.format);
+    })))
+  }
+
   /**
    * Remove a part of the operation (similar to Array.splice)
    *
@@ -121,7 +181,10 @@ class TextOp extends list.ListNode {
    * @param {number} len
    */
   _splice (offset, len) {
+    this._fingerprint = null;
+    // @ts-ignore
     this.insert = this.insert.slice(0, offset) + this.insert.slice(offset + len);
+    return this
   }
 
   /**
@@ -142,13 +205,13 @@ class TextOp extends list.ListNode {
   /**
    * @return {TextOp}
    */
-  clone () {
-    return new TextOp(this.insert, _cloneAttrs(this.format), _cloneAttrs(this.attribution))
+  clone (start = 0, end = this.length) {
+    return new TextOp(this.insert.slice(start, end), _cloneAttrs(this.format), _cloneAttrs(this.attribution))
   }
 }
 
 /**
- * @template ArrayContent
+ * @template {encoding.AnyEncodable|DeltaAny} ArrayContent
  */
 class InsertOp extends list.ListNode {
   /**
@@ -158,9 +221,34 @@ class InsertOp extends list.ListNode {
    */
   constructor (insert, format, attribution) {
     super();
+    /**
+     * @readonly
+     * @type {Array<ArrayContent>}
+     */
     this.insert = insert;
+    /**
+     * @readonly
+     * @type {FormattingAttributes?}
+     */
     this.format = format;
+    /**
+     * @readonly
+     * @type {Attribution?}
+     */
     this.attribution = attribution;
+    /**
+     * @type {string?}
+     */
+    this._fingerprint = null;
+  }
+
+  /**
+   * @param {ArrayContent} newVal
+   */
+  _updateInsert (newVal) {
+    // @ts-ignore
+    this.insert = newVal;
+    this._fingerprint = null;
   }
 
   /**
@@ -174,6 +262,42 @@ class InsertOp extends list.ListNode {
     return this.insert.length
   }
 
+  /**
+   * @param {number} i
+   * @return {Extract<ArrayContent,DeltaAny>}
+   */
+  _modValue (i) {
+    /**
+     * @type {any}
+     */
+    let d = this.insert[i];
+    this._fingerprint = null;
+    $deltaAny.expect(d);
+    if (d.isDone) {
+      // @ts-ignore
+      this.insert[i] = (d = clone(d));
+      return d
+    }
+    return d
+  }
+
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      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.writeAny(encoder, this.format);
+    })))
+  }
+
   /**
    * Remove a part of the operation (similar to Array.splice)
    *
@@ -181,7 +305,9 @@ class InsertOp extends list.ListNode {
    * @param {number} len
    */
   _splice (offset, len) {
+    this._fingerprint = null;
     this.insert.splice(offset, len);
+    return this
   }
 
   /**
@@ -202,11 +328,15 @@ class InsertOp extends list.ListNode {
   /**
    * @return {InsertOp<ArrayContent>}
    */
-  clone () {
-    return new InsertOp(this.insert.slice(), _cloneAttrs(this.format), _cloneAttrs(this.attribution))
+  clone (start = 0, end = this.length) {
+    return new InsertOp(this.insert.slice(start, end).map(_markMaybeDeltaAsDone), _cloneAttrs(this.format), _cloneAttrs(this.attribution))
   }
 }
 
+/**
+ * @template {encoding.AnyEncodable|DeltaAny} [Children=never]
+ * @template {string} [Text=never]
+ */
 class DeleteOp extends list.ListNode {
   /**
    * @param {number} len
@@ -214,6 +344,14 @@ class DeleteOp extends list.ListNode {
   constructor (len) {
     super();
     this.delete = len;
+    /**
+     * @type {(Children|Text) extends never ? null : (Delta<any,{},Children,Text>?)}
+     */
+    this.prevValue = null;
+    /**
+     * @type {string|null}
+     */
+    this._fingerprint = null;
   }
 
   /**
@@ -227,6 +365,13 @@ class DeleteOp extends list.ListNode {
     return 0
   }
 
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeVarUint(encoder, 2); // deleteOp type: 2
+      encoding.writeVarUint(encoder, this.delete);
+    })))
+  }
+
   /**
    * Remove a part of the operation (similar to Array.splice)
    *
@@ -234,7 +379,10 @@ class DeleteOp extends list.ListNode {
    * @param {number} len
    */
   _splice (_offset, len) {
+    this.prevValue = /** @type {any} */ (this.prevValue?.slice(_offset, len) || null);
+    this._fingerprint = null;
     this.delete -= len;
+    return this
   }
 
   /**
@@ -251,8 +399,8 @@ class DeleteOp extends list.ListNode {
     return this.delete === other.delete
   }
 
-  clone () {
-    return new DeleteOp(this.delete)
+  clone (start = 0, end = this.delete) {
+    return new DeleteOp(end - start)
   }
 }
 
@@ -264,9 +412,25 @@ class RetainOp extends list.ListNode {
    */
   constructor (retain, format, attribution) {
     super();
+    /**
+     * @readonly
+     * @type {number}
+     */
     this.retain = retain;
+    /**
+     * @readonly
+     * @type {FormattingAttributes?}
+     */
     this.format = format;
+    /**
+     * @readonly
+     * @type {Attribution?}
+     */
     this.attribution = attribution;
+    /**
+     * @type {string|null}
+     */
+    this._fingerprint = null;
   }
 
   /**
@@ -280,6 +444,14 @@ class RetainOp extends list.ListNode {
     return this.retain
   }
 
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeVarUint(encoder, 3); // retainOp type: 3
+      encoding.writeVarUint(encoder, this.retain);
+      encoding.writeAny(encoder, this.format);
+    })))
+  }
+
   /**
    * Remove a part of the operation (similar to Array.splice)
    *
@@ -287,7 +459,10 @@ class RetainOp extends list.ListNode {
    * @param {number} len
    */
   _splice (_offset, len) {
+    // @ts-ignore
     this.retain -= len;
+    this._fingerprint = null;
+    return this
   }
 
   /**
@@ -305,15 +480,15 @@ class RetainOp extends list.ListNode {
     return this.retain === other.retain && _function.equalityDeep(this.format, other.format) && _function.equalityDeep(this.attribution, other.attribution)
   }
 
-  clone () {
-    return new RetainOp(this.retain, _cloneAttrs(this.format), _cloneAttrs(this.attribution))
+  clone (start = 0, end = this.retain) {
+    return new RetainOp(end - start, _cloneAttrs(this.format), _cloneAttrs(this.attribution))
   }
 }
 
 /**
  * Delta that can be applied on a YType Embed
  *
- * @template {Delta<any,any,any,any,any>} DTypes
+ * @template {DeltaAny} [DTypes=DeltaAny]
  */
 class ModifyOp extends list.ListNode {
   /**
@@ -323,9 +498,25 @@ class ModifyOp extends list.ListNode {
    */
   constructor (delta, format, attribution) {
     super();
+    /**
+     * @readonly
+     * @type {DTypes}
+     */
     this.value = delta;
+    /**
+     * @readonly
+     * @type {FormattingAttributes?}
+     */
     this.format = format;
+    /**
+     * @readonly
+     * @type {Attribution?}
+     */
     this.attribution = attribution;
+    /**
+     * @type {string|null}
+     */
+    this._fingerprint = null;
   }
 
   /**
@@ -339,6 +530,31 @@ class ModifyOp extends list.ListNode {
     return 1
   }
 
+  /**
+   * @type {DeltaBuilderAny}
+   */
+  get _modValue () {
+    /**
+     * @type {any}
+     */
+    const d = this.value;
+    this._fingerprint = null;
+    if (d.isDone) {
+      // @ts-ignore
+      return (this.value = clone(d))
+    }
+    return d
+  }
+
+  get fingerprint () {
+    // don't cache fingerprint because we don't know when delta changes
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeVarUint(encoder, 4); // modifyOp type: 4
+      encoding.writeVarString(encoder, this.value.fingerprint);
+      encoding.writeAny(encoder, this.format);
+    })))
+  }
+
   /**
    * Remove a part of the operation (similar to Array.splice)
    *
@@ -346,6 +562,7 @@ class ModifyOp extends list.ListNode {
    * @param {number} _len
    */
   _splice (_offset, _len) {
+    return this
   }
 
   /**
@@ -367,15 +584,15 @@ class ModifyOp extends list.ListNode {
    * @return {ModifyOp<DTypes>}
    */
   clone () {
-    return new ModifyOp(this.value.clone(), _cloneAttrs(this.format), _cloneAttrs(this.attribution))
+    return new ModifyOp(/** @type {DTypes} */ (this.value.done()), _cloneAttrs(this.format), _cloneAttrs(this.attribution))
   }
 }
 
 /**
- * @template V
- * @template {string|number|symbol} [K=any]
+ * @template {encoding.AnyEncodable|DeltaAny} V
+ * @template {string|number} [K=any]
  */
-class MapInsertOp {
+class AttrInsertOp {
   /**
    * @param {K} key
    * @param {V} value
@@ -384,18 +601,29 @@ class MapInsertOp {
    */
   constructor (key, value, prevValue, attribution) {
     /**
+     * @readonly
      * @type {K}
      */
     this.key = key;
     /**
+     * @readonly
      * @type {V}
      */
     this.value = value;
     /**
+     * @readonly
      * @type {V|undefined}
      */
     this.prevValue = prevValue;
+    /**
+     * @readonly
+     * @type {Attribution?}
+     */
     this.attribution = attribution;
+    /**
+     * @type {string|null}
+     */
+    this._fingerprint = null;
   }
 
   /**
@@ -403,6 +631,36 @@ class MapInsertOp {
    */
   get type () { return 'insert' }
 
+  /**
+   * @type {DeltaBuilderAny}
+   */
+  get _modValue () {
+    /**
+     * @type {any}
+     */
+    const v = this.value;
+    this._fingerprint = null;
+    if ($deltaAny.check(v) && v.isDone) {
+      // @ts-ignore
+      return (this.value = clone(v))
+    }
+    return v
+  }
+
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeVarUint(encoder, 5); // map insert type: 5
+      encoding.writeAny(encoder, this.key);
+      if ($deltaAny.check(this.value)) {
+        encoding.writeUint8(encoder, 0);
+        encoding.writeVarString(encoder, this.value.fingerprint);
+      } else {
+        encoding.writeUint8(encoder, 1);
+        encoding.writeAny(encoder, this.value);
+      }
+    })))
+  }
+
   toJSON () {
     const v = this.value;
     const prevValue = this.prevValue;
@@ -414,25 +672,25 @@ class MapInsertOp {
   }
 
   /**
-   * @param {MapInsertOp<V>} other
+   * @param {AttrInsertOp<V>} other
    */
   [traits.EqualityTraitSymbol] (other) {
     return this.key === other.key && _function.equalityDeep(this.value, other.value) && _function.equalityDeep(this.attribution, other.attribution)
   }
 
   /**
-   * @return {MapInsertOp<V,K>}
+   * @return {AttrInsertOp<V,K>}
    */
   clone () {
-    return new MapInsertOp(this.key, _cloneMaybeDelta(this.value), _cloneMaybeDelta(this.prevValue), _cloneAttrs(this.attribution))
+    return new AttrInsertOp(this.key, _markMaybeDeltaAsDone(this.value), _markMaybeDeltaAsDone(this.prevValue), _cloneAttrs(this.attribution))
   }
 }
 
 /**
  * @template V
- * @template [K=string]
+ * @template {string|number} [K=string]
  */
-class MapDeleteOp {
+class AttrDeleteOp {
   /**
    * @param {K} key
    * @param {V|undefined} prevValue
@@ -448,6 +706,10 @@ class MapDeleteOp {
      */
     this.prevValue = prevValue;
     this.attribution = attribution;
+    /**
+     * @type {string|null}
+     */
+    this._fingerprint = null;
   }
 
   get value () { return undefined }
@@ -457,6 +719,13 @@ class MapDeleteOp {
    */
   get type () { return 'delete' }
 
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeVarUint(encoder, 6); // map delete type: 6
+      encoding.writeAny(encoder, this.key);
+    })))
+  }
+
   /**
    * @return {DeltaAttrOpJSON}
    */
@@ -468,35 +737,41 @@ class MapDeleteOp {
   }
 
   /**
-   * @param {MapDeleteOp<V>} other
+   * @param {AttrDeleteOp<V>} other
    */
   [traits.EqualityTraitSymbol] (other) {
     return this.key === other.key && _function.equalityDeep(this.attribution, other.attribution)
   }
 
   clone () {
-    return new MapDeleteOp(this.key, _cloneMaybeDelta(this.prevValue), _cloneAttrs(this.attribution))
+    return new AttrDeleteOp(this.key, _markMaybeDeltaAsDone(this.prevValue), _cloneAttrs(this.attribution))
   }
 }
 
 /**
- * @template {DeltaAny} Modifier
- * @template [K=string]
+ * @template {DeltaAny} [Modifier=DeltaAny]
+ * @template {string|number} [K=string]
  */
-class MapModifyOp {
+class AttrModifyOp {
   /**
    * @param {K} key
    * @param {Modifier} delta
    */
   constructor (key, delta) {
     /**
+     * @readonly
      * @type {K}
      */
     this.key = key;
     /**
+     * @readonly
      * @type {Modifier}
      */
     this.value = delta;
+    /**
+     * @type {string|null}
+     */
+    this._fingerprint = null;
   }
 
   /**
@@ -504,6 +779,27 @@ class MapModifyOp {
    */
   get type () { return 'modify' }
 
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeVarUint(encoder, 7); // map modify type: 7
+      encoding.writeAny(encoder, this.key);
+      encoding.writeVarString(encoder, this.value.fingerprint);
+    })))
+  }
+
+  /**
+   * @return {DeltaBuilder}
+   */
+  get _modValue () {
+    this._fingerprint = null;
+    if (this.value.isDone) {
+      // @ts-ignore
+      this.value = /** @type {any} */ (clone(this.value));
+    }
+    // @ts-ignore
+    return this.value
+  }
+
   /**
    * @return {DeltaAttrOpJSON}
    */
@@ -515,38 +811,38 @@ class MapModifyOp {
   }
 
   /**
-   * @param {MapModifyOp<Modifier>} other
+   * @param {AttrModifyOp<Modifier>} other
    */
   [traits.EqualityTraitSymbol] (other) {
     return this.key === other.key && this.value[traits.EqualityTraitSymbol](other.value)
   }
 
   /**
-   * @return {MapModifyOp<Modifier,K>}
+   * @return {AttrModifyOp<Modifier,K>}
    */
   clone () {
-    return new MapModifyOp(this.key, this.value.clone())
+    return new AttrModifyOp(this.key, /** @type {Modifier} */ (this.value.done()))
   }
 }
 
 /**
- * @type {s.Schema<MapDeleteOp<any> | DeleteOp>}
+ * @type {s.Schema<AttrDeleteOp<any> | DeleteOp>}
  */
-const $deleteOp = schema.$custom(o => o != null && (o.constructor === DeleteOp || o.constructor === MapDeleteOp));
+const $deleteOp = schema.$custom(o => o != null && (o.constructor === DeleteOp || o.constructor === AttrDeleteOp));
 
 /**
- * @type {s.Schema<MapInsertOp<any> | InsertOp<any>>}
+ * @type {s.Schema<AttrInsertOp<any> | InsertOp<any>>}
  */
-const $insertOp = schema.$custom(o => o != null && (o.constructor === MapInsertOp || o.constructor === InsertOp));
+const $insertOp = schema.$custom(o => o != null && (o.constructor === AttrInsertOp || o.constructor === InsertOp));
 
 /**
- * @template Content
+ * @template {encoding.AnyEncodable|DeltaAny} Content
  * @param {s.Schema<Content>} $content
- * @return {s.Schema<MapInsertOp<Content> | InsertOp<Content>>}
+ * @return {s.Schema<AttrInsertOp<Content> | InsertOp<Content>>}
  */
 const $insertOpWith = $content => schema.$custom(o =>
   o != null && (
-    (o.constructor === MapInsertOp && $content.check(/** @type {MapInsertOp<Content>} */ (o).value)) ||
+    (o.constructor === AttrInsertOp && $content.check(/** @type {AttrInsertOp<Content>} */ (o).value)) ||
       (o.constructor === InsertOp && /** @type {InsertOp<Content>} */ (o).insert.every(ins => $content.check(ins)))
   )
 );
@@ -562,18 +858,18 @@ const $textOp = schema.$constructedBy(TextOp);
 const $retainOp = schema.$constructedBy(RetainOp);
 
 /**
- * @type {s.Schema<MapModifyOp<any> | ModifyOp<any>>}
+ * @type {s.Schema<AttrModifyOp | ModifyOp>}
  */
-const $modifyOp = schema.$custom(o => o != null && (o.constructor === MapModifyOp || o.constructor === ModifyOp));
+const $modifyOp = schema.$custom(o => o != null && (o.constructor === AttrModifyOp || o.constructor === ModifyOp));
 
 /**
  * @template {DeltaAny} Modify
  * @param {s.Schema<Modify>} $content
- * @return {s.Schema<MapModifyOp<Modify> | ModifyOp<Modify>>}
+ * @return {s.Schema<AttrModifyOp<Modify> | ModifyOp<Modify>>}
  */
 const $modifyOpWith = $content => schema.$custom(o =>
   o != null && (
-    (o.constructor === MapModifyOp && $content.check(/** @type {MapModifyOp<Modify>} */ (o).value)) ||
+    (o.constructor === AttrModifyOp && $content.check(/** @type {AttrModifyOp<Modify>} */ (o).value)) ||
       (o.constructor === ModifyOp && $content.check(/** @type {ModifyOp<Modify>} */ (o).value))
   )
 );
@@ -589,8 +885,8 @@ const $anyOp = schema.$union($insertOp, $deleteOp, $textOp, $modifyOp);
  */
 
 /**
- * @template {{[Key in string|number|symbol]: any}} Attrs
- * @template {string|number|symbol} Key
+ * @template {{[Key in string|number]: any}} Attrs
+ * @template {string|number} Key
  * @template {any} Val
  * @typedef {{ [K in (Key | keyof Attrs)]: (unknown extends Attrs[K] ? never : Attrs[K]) | (Key extends K ? Val : never) }} AddToAttrs
  */
@@ -608,29 +904,20 @@ const $anyOp = schema.$union($insertOp, $deleteOp, $textOp, $modifyOp);
 
 /**
  * @template {s.Schema<Delta<any,any,any,any,any>>|null} Schema
- * @typedef {_AnyToNull<Schema> extends null ? Delta<any,{[key:string|number|symbol]:any},any,string> : (Schema extends s.Schema<infer D> ? D : never)} AllowedDeltaFromSchema
+ * @typedef {_AnyToNull<Schema> extends null ? Delta<any,{[key:string|number]:any},any,string> : (Schema extends s.Schema<infer D> ? D : never)} AllowedDeltaFromSchema
  */
 
 /**
- * @typedef {Delta<any,{ [k:string]: any },any,any,any>} DeltaAny
+ * @typedef {Delta<any,{ [k:string|number]: any },any,any,any>} DeltaAny
  */
-
-// note: simply copy the values from Delta.attrs as the parameter of the function
 /**
- * @template {{[key:string|number|symbol]:any}} [Attrs={}]
- * @param {Delta<any,Attrs,any,any,any>} d
- * @param {(v:{ [K in keyof Attrs]: MapInsertOp<Attrs[K],K>|MapDeleteOp<Attrs[K],K>|(Delta extends Attrs[K] ? MapModifyOp<Extract<Attrs[K],Delta>,K> : never) }[keyof Attrs])=>any} handler
+ * @typedef {DeltaBuilder<any,{ [k:string|number]: any },any,any,any>} DeltaBuilderAny
  */
-const forEachAttr = (d, handler) => {
-  for (const k in d.attrs) {
-    handler(/** @type {any} */ (d.attrs[k]));
-  }
-};
 
 /**
  * @template {string} [NodeName=any]
- * @template {{[key:string|number|symbol]:any}} [Attrs={}]
- * @template {any} [Children=never]
+ * @template {{[k:string|number]:any}} [Attrs={}]
+ * @template {encoding.AnyEncodable|DeltaAny|never} [Children=never]
  * @template {string|never} [Text=never]
  * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
  */
@@ -643,7 +930,9 @@ class Delta {
     this.name = name || null;
     this.$schema = $schema || null;
     /**
-     * @type {{ [K in keyof Attrs]?: MapInsertOp<Attrs[K],K>|MapDeleteOp<Attrs[K],K>|(Delta extends Attrs[K] ? MapModifyOp<Extract<Attrs[K],Delta>,K> : never) } & { [Symbol.iterator]: () => Iterator<{ [K in keyof Attrs]: MapInsertOp<Attrs[K],K>|MapDeleteOp<Attrs[K],K>|(Delta extends Attrs[K] ? MapModifyOp<Extract<Attrs[K],Delta>,K> : never) }[keyof Attrs]> }}
+     * @type {{ [K in keyof Attrs]?: K extends string|number ? (AttrInsertOp<Attrs[K],K>|AttrDeleteOp<Attrs[K],K>|(Delta extends Attrs[K] ? AttrModifyOp<Extract<Attrs[K],DeltaAny>,K> : never)) : never }
+     *   & { [Symbol.iterator]: () => Iterator<{ [K in keyof Attrs]: K extends string|number ? (AttrInsertOp<Attrs[K],K>|AttrDeleteOp<Attrs[K],K>|(Delta extends Attrs[K] ? AttrModifyOp<Extract<Attrs[K],DeltaAny>,K> : never)) : never }[keyof Attrs]> }
+     * }
      */
     this.attrs = /** @type {any} */ ({
       * [Symbol.iterator] () {
@@ -663,10 +952,50 @@ class Delta {
      * >}
      */
     this.children = /** @type {any} */ (list.create());
+    this.childCnt = 0;
     /**
      * @type {any}
      */
     this.origin = null;
+    /**
+     * @type {string|null}
+     */
+    this._fingerprint = null;
+    this.isDone = false;
+  }
+
+  /**
+   * @type {string}
+   */
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeAny(encoder, this.name);
+      /**
+       * @type {Array<number|string>}
+       */
+      const keys = [];
+      for (const attr of this.attrs) {
+        keys.push(attr.key);
+      }
+      keys.sort((a, b) => {
+        const aIsString = schema.$string.check(a);
+        const bIsString = schema.$string.check(b);
+        // numbers first
+        // in ascending order
+        return (aIsString && bIsString)
+          ? a.localeCompare(b)
+          : (aIsString ? 1 : (bIsString ? -1 : (a - b)))
+      });
+      encoding.writeVarUint(encoder, keys.length);
+      for (const key of keys) {
+        encoding.writeVarString(encoder, /** @type {any} */ (this.attrs[/** @type {keyof Attrs} */ (key)]).fingerprint);
+      }
+      encoding.writeVarUint(encoder, this.children.len);
+      for (const child of this.children) {
+        encoding.writeVarString(encoder, child.fingerprint);
+      }
+      return buffer.toBase64(rabin.fingerprint(rabin.StandardIrreducible128, encoding.toUint8Array(encoder)))
+    })))
   }
 
   isEmpty () {
@@ -677,6 +1006,7 @@ class Delta {
    * @return {DeltaJSON}
    */
   toJSON () {
+    const name = this.name;
     /**
      * @type {any}
      */
@@ -685,14 +1015,15 @@ class Delta {
      * @type {any}
      */
     const children = [];
-    forEachAttr(this, attr => {
+    for (const attr of this.attrs) {
       attrs[attr.key] = attr.toJSON();
-    });
+    }
     this.children.forEach(val => {
       children.push(val.toJSON());
     });
     return object.assign(
-      (this.name != null ? { name: this.name } : {}),
+      { type: /** @type {'delta'} */ ('delta') },
+      (name != null ? { name } : {}),
       (object.isEmpty(attrs) ? {} : { attrs }),
       (children.length > 0 ? { children } : {})
     )
@@ -707,36 +1038,139 @@ class Delta {
   }
 
   /**
-   * @return {this}
+   * @param {any} other
+   * @return {boolean}
    */
-  clone () {
+  [traits.EqualityTraitSymbol] (other) {
+    // @todo it is only necessary to compare finrerprints OR do a deep equality check
+    return this.name === other.name && _function.equalityDeep(this.attrs, other.attrs) && _function.equalityDeep(this.children, other.children) && this.childCnt === other.childCnt && this.fingerprint === other.fingerprint
+  }
+
+  /**
+   * @param {number} start
+   * @param {number} end
+   * @return {Delta<NodeName,Attrs,Children,Text,Schema>}
+   */
+  slice (start = 0, end = this.childCnt) {
+    const cpy = /** @type {DeltaAny} */ (new DeltaBuilder(/** @type {any} */ (this.name), this.$schema));
+    cpy.origin = this.origin;
+    // copy attrs
+    for (const op of this.attrs) {
+      cpy.attrs[op.key] = /** @type {any} */ (op.clone());
+    }
+    // copy children
+    const slicedLen = end - start;
+    let remainingLen = slicedLen;
     /**
-     * @type {Delta<any,Attrs,any,any,any>}
+     * @type {ChildrenOpAny?}
      */
-    const d = new DeltaBuilder(/** @type {any} */ (this.name), this.$schema);
-    d.origin = this.origin;
-    for (const op of this.attrs) {
-      d.attrs[op.key] = /** @type {any} */ (op);
+    let currNode = this.children.start;
+    let currNodeOffset = 0;
+    while (start > 0 && currNode != null) {
+      if (currNode.length <= start) {
+        start -= currNode.length;
+        currNode = currNode.next;
+      } else {
+        currNodeOffset = start;
+        start = 0;
+      }
     }
-    this.children.forEach(op => {
-      list.pushEnd(d.children, op.clone());
-    });
-    return /** @type {any} */ (d)
+    if (currNodeOffset > 0 && currNode) {
+      const ncpy = currNode.clone(currNodeOffset, currNodeOffset + math.min(remainingLen, currNode.length - currNodeOffset));
+      list.pushEnd(cpy.children, ncpy);
+      remainingLen -= ncpy.length;
+      currNode = currNode.next;
+    }
+    while (currNode != null && currNode.length <= remainingLen) {
+      list.pushEnd(cpy.children, currNode.clone());
+      currNode = currNode.next;
+    }
+    if (currNode != null && remainingLen > 0) {
+      list.pushEnd(cpy.children, currNode.clone(0, remainingLen));
+    }
+    cpy.childCnt = slicedLen - remainingLen;
+    // @ts-ignore
+    return cpy
   }
 
   /**
-   * @param {any} other
-   * @return {boolean}
+   * Mark this delta as done and perform some cleanup (e.g. remove appended retains without
+   * formats&attributions). In the future, there might be additional merge operations that can be
+   * performed to result in smaller deltas. Set `markAsDone=false` to only perform the cleanup.
+   *
+   * @return {Delta<NodeName,Attrs,Children,Text,Schema>}
    */
-  [traits.EqualityTraitSymbol] (other) {
-    return this.name === other.name && _function.equalityDeep(this.attrs, other.attrs) && _function.equalityDeep(this.children, other.children)
+  done (markAsDone = true) {
+    if (!this.isDone) {
+      this.isDone = markAsDone;
+      const cs = this.children;
+      for (let end = cs.end; end !== null && $retainOp.check(end) && end.format == null && end.attribution == null; end = cs.end) {
+        this.childCnt -= end.length;
+        list.popEnd(cs);
+      }
+    }
+    return this
   }
 }
 
+/**
+ * @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}
+ */
+const clone = d => /** @type {any} */ (d.slice(0, d.childCnt));
+
+/**
+ * Try merging this op with the previous op
+ * @param {list.List<any>} parent
+ * @param {InsertOp<any>|RetainOp|DeleteOp|TextOp|ModifyOp<any>} op
+ */
+const tryMergeWithPrev = (parent, op) => {
+  const prevOp = op.prev;
+  if (
+    prevOp?.constructor !== op.constructor ||
+    (
+      (!$deleteOp.check(op) && !$modifyOp.check(op)) && (!_function.equalityDeep(op.format, /** @type {InsertOp<any>} */ (prevOp).format) || !_function.equalityDeep(op.attribution, /** @type {InsertOp<any>} */ (prevOp).attribution))
+    )
+  ) {
+    // constructor mismatch or format/attribution mismatch
+    return
+  }
+  // can be merged
+  if ($insertOp.check(op)) {
+    /** @type {InsertOp<any>} */ (prevOp).insert.push(...op.insert);
+  } else if ($retainOp.check(op)) {
+    // @ts-ignore
+    /** @type {RetainOp} */ (prevOp).retain += op.retain;
+  } else if ($deleteOp.check(op)) {
+    /** @type {DeleteOp} */ (prevOp).delete += op.delete;
+  } else if ($textOp.check(op)) {
+    /** @type {TextOp} */ (prevOp)._updateInsert(/** @type {TextOp} */ (prevOp).insert + op.insert);
+  } else {
+    error.unexpectedCase();
+  }
+  list.remove(parent, op);
+};
+
+/**
+ * Ensures that the delta can be edited. clears _fingerprint cache.
+ *
+ * @param {any} d
+ */
+const modDeltaCheck = d => {
+  if (d.isDone) {
+    /**
+     * You tried to modify a delta after it has been marked as "done".
+     */
+    throw error.create("Readonly Delta can't be modified")
+  }
+  d._fingerprint = null;
+};
+
 /**
  * @template {string} [NodeName=any]
- * @template {{[key:string|number|symbol]:any}} [Attrs={}]
- * @template {any} [Children=never]
+ * @template {{[key:string|number]:any}} [Attrs={}]
+ * @template {encoding.AnyEncodable|DeltaAny|never} [Children=never]
  * @template {string|never} [Text=never]
  * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
  * @extends {Delta<NodeName,Attrs,Children,Text,Schema>}
@@ -762,6 +1196,7 @@ class DeltaBuilder extends Delta {
    * @param {Attribution?} attribution
    */
   useAttribution (attribution) {
+    modDeltaCheck(this);
     this.usedAttribution = attribution;
     return this
   }
@@ -771,6 +1206,7 @@ class DeltaBuilder extends Delta {
    * @return {this}
    */
   useAttributes (attributes) {
+    modDeltaCheck(this);
     this.usedAttributes = attributes;
     return this
   }
@@ -780,6 +1216,7 @@ class DeltaBuilder extends Delta {
    * @param {any} value
    */
   updateUsedAttributes (name, value) {
+    modDeltaCheck(this);
     if (value == null) {
       this.usedAttributes = object.assign({}, this.usedAttributes);
       delete this.usedAttributes?.[name];
@@ -799,6 +1236,7 @@ class DeltaBuilder extends Delta {
    * @param {Attribution[NAME]?} value
    */
   updateUsedAttribution (name, value) {
+    modDeltaCheck(this);
     if (value == null) {
       this.usedAttribution = object.assign({}, this.usedAttribution);
       delete this.usedAttribution?.[name];
@@ -821,11 +1259,12 @@ class DeltaBuilder extends Delta {
    *   NodeName,
    *   Attrs,
    *   Exclude<NewContent,string>[number]|Children,
-   *   (Extract<NewContent,string>|Text) extends string ? string : never,
+   *   (Extract<NewContent,string>|Text) extends never ? never : string,
    *   Schema
    * >}
    */
   insert (insert, formatting = null, attribution = null) {
+    modDeltaCheck(this);
     const mergedAttributes = mergeAttrs(this.usedAttributes, formatting);
     const mergedAttribution = mergeAttrs(this.usedAttribution, attribution);
     /**
@@ -835,16 +1274,20 @@ class DeltaBuilder extends Delta {
     const end = this.children.end;
     if (schema.$string.check(insert)) {
       if ($textOp.check(end) && checkMergedEquals(end)) {
-        end.insert += insert;
+        end._updateInsert(end.insert + insert);
       } else if (insert.length > 0) {
         list.pushEnd(this.children, new TextOp(insert, object.isEmpty(mergedAttributes) ? null : mergedAttributes, object.isEmpty(mergedAttribution) ? null : mergedAttribution));
       }
+      this.childCnt += insert.length;
     } else if (array$1.isArray(insert)) {
       if ($insertOp.check(end) && checkMergedEquals(end)) {
+        // @ts-ignore
         end.insert.push(...insert);
+        end._fingerprint = null;
       } else if (insert.length > 0) {
         list.pushEnd(this.children, new InsertOp(insert, object.isEmpty(mergedAttributes) ? null : mergedAttributes, object.isEmpty(mergedAttribution) ? null : mergedAttribution));
       }
+      this.childCnt += insert.length;
     }
     return /** @type {any} */ (this)
   }
@@ -863,9 +1306,11 @@ class DeltaBuilder extends Delta {
    * >}
    */
   modify (modify, formatting = null, attribution = null) {
+    modDeltaCheck(this);
     const mergedAttributes = mergeAttrs(this.usedAttributes, formatting);
     const mergedAttribution = mergeAttrs(this.usedAttribution, attribution);
     list.pushEnd(this.children, new ModifyOp(modify, object.isEmpty(mergedAttributes) ? null : mergedAttributes, object.isEmpty(mergedAttribution) ? null : mergedAttribution));
+    this.childCnt += 1;
     return /** @type {any} */ (this)
   }
 
@@ -875,14 +1320,17 @@ class DeltaBuilder extends Delta {
    * @param {Attribution?} [attribution]
    */
   retain (len, format = null, attribution = null) {
+    modDeltaCheck(this);
     const mergedFormats = mergeAttrs(this.usedAttributes, format);
     const mergedAttribution = mergeAttrs(this.usedAttribution, attribution);
     const lastOp = /** @type {RetainOp|InsertOp<any>} */ (this.children.end);
     if (lastOp instanceof RetainOp && _function.equalityDeep(mergedFormats, lastOp.format) && _function.equalityDeep(mergedAttribution, lastOp.attribution)) {
+      // @ts-ignore
       lastOp.retain += len;
     } else if (len > 0) {
       list.pushEnd(this.children, new RetainOp(len, mergedFormats, mergedAttribution));
     }
+    this.childCnt += len;
     return this
   }
 
@@ -890,12 +1338,14 @@ class DeltaBuilder extends Delta {
    * @param {number} len
    */
   delete (len) {
+    modDeltaCheck(this);
     const lastOp = /** @type {DeleteOp|InsertOp<any>} */ (this.children.end);
     if (lastOp instanceof DeleteOp) {
       lastOp.delete += len;
     } else if (len > 0) {
       list.pushEnd(this.children, new DeleteOp(len));
     }
+    this.childCnt += len;
     return this
   }
 
@@ -915,7 +1365,8 @@ class DeltaBuilder extends Delta {
    * >}
    */
   set (key, val, attribution = null, prevValue) {
-    this.attrs[key] = /** @type {any} */ (new MapInsertOp(key, val, prevValue, mergeAttrs(this.usedAttribution, attribution)));
+    modDeltaCheck(this);
+    this.attrs[key] = /** @type {any} */ (new AttrInsertOp(key, val, prevValue, mergeAttrs(this.usedAttribution, attribution)));
     return /** @type {any} */ (this)
   }
 
@@ -932,6 +1383,7 @@ class DeltaBuilder extends Delta {
    * >}
    */
   setMany (attrs, attribution = null) {
+    modDeltaCheck(this);
     for (const k in attrs) {
       this.set(/** @type {any} */ (k), attrs[k], attribution);
     }
@@ -952,7 +1404,8 @@ class DeltaBuilder extends Delta {
    * >}
    */
   unset (key, attribution = null, prevValue) {
-    this.attrs[key] = /** @type {any} */ (new MapDeleteOp(key, prevValue, mergeAttrs(this.usedAttribution, attribution)));
+    modDeltaCheck(this);
+    this.attrs[key] = /** @type {any} */ (new AttrDeleteOp(key, prevValue, mergeAttrs(this.usedAttribution, attribution)));
     return /** @type {any} */ (this)
   }
 
@@ -970,7 +1423,8 @@ class DeltaBuilder extends Delta {
    * >}
    */
   update (key, modify) {
-    this.attrs[key] = /** @type {any} */ (new MapModifyOp(key, modify));
+    modDeltaCheck(this);
+    this.attrs[key] = /** @type {any} */ (new AttrModifyOp(key, modify));
     return /** @type {any} */ (this)
   }
 
@@ -978,37 +1432,64 @@ class DeltaBuilder extends Delta {
    * @param {Delta<NodeName,Attrs,Children,Text,any>} other
    */
   apply (other) {
+    modDeltaCheck(this);
     this.$schema?.expect(other);
-    forEachAttr(/** @type {Delta<NodeName,Attrs,Children,Text,any>} */ (/** @type {any} */ (other)), op => {
-      const c = this.attrs[op.key];
+    // apply attrs
+    for (let 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)) {
-          /** @type {DeltaBuilder} */ (c.value).apply(op.value);
+          c._modValue.apply(op.value);
         } else {
           // then this is a simple modify
-          this.attrs[op.key] = /** @type {any} */ (op);
+          // @ts-ignore
+          this.attrs[op.key] = op.clone();
         }
       } else {
-        /** @type {MapInsertOp<any>} */ (op).prevValue = c?.value;
-        this.attrs[op.key] = /** @type {any} */ (op);
+        op = /** @type {any} */ (op.clone());
+        // @ts-ignore
+        op.prevValue = c?.value;
+        // @ts-ignore
+        this.attrs[op.key] = op;
       }
-    });
+    }
     // apply children
+    /**
+     * @type {ChildrenOpAny?}
+     */
     let opsI = this.children.start;
     let offset = 0;
+    /**
+     * At the end, we will try to merge this op, and op.next op with their respective previous op.
+     *
+     * Hence, anytime an op is cloned, deleted, or inserted (anytime list.* api is used) we must add
+     * an op to maybeMergeable.
+     *
+     * @type {Array<InsertOp<any>|RetainOp|DeleteOp|TextOp|ModifyOp<any>>}
+     */
+    const maybeMergeable = [];
+    /**
+     * @template {InsertOp<any>|RetainOp|DeleteOp|TextOp|ModifyOp<any>|null} OP
+     * @param {OP} op
+     * @return {OP}
+     */
+    const scheduleForMerge = op => {
+      op && maybeMergeable.push(op);
+      return op
+    };
     other.children.forEach(op => {
       if ($textOp.check(op) || $insertOp.check(op)) {
         if (offset === 0) {
-          list.insertBetween(this.children, opsI == null ? this.children.end : opsI.prev, opsI, op.clone());
+          list.insertBetween(this.children, opsI == null ? this.children.end : opsI.prev, opsI, scheduleForMerge(op.clone()));
         } else {
           if (opsI == null) error.unexpectedCase();
-          const cpy = opsI.clone();
-          cpy._splice(0, offset);
+          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, op);
+          list.insertBetween(this.children, opsI, cpy || null, scheduleForMerge(op.clone()));
           offset = 0;
         }
+        this.childCnt += op.insert.length;
       } else if ($retainOp.check(op)) {
         let skipLen = op.length;
         while (opsI != null && opsI.length - offset <= skipLen) {
@@ -1019,13 +1500,15 @@ class DeltaBuilder extends Delta {
         if (opsI != null) {
           offset += skipLen;
         } else {
-          list.pushEnd(this.children, new RetainOp(skipLen, op.format, op.attribution));
+          list.pushEnd(this.children, scheduleForMerge(new RetainOp(skipLen, op.format, op.attribution)));
+          this.childCnt += skipLen;
         }
       } else if ($deleteOp.check(op)) {
         let remainingLen = op.delete;
         while (remainingLen > 0) {
           if (opsI == null) {
-            list.pushEnd(this.children, new DeleteOp(remainingLen));
+            list.pushEnd(this.children, scheduleForMerge(new DeleteOp(remainingLen)));
+            this.childCnt += remainingLen;
             break
           } else if (opsI instanceof DeleteOp) {
             const delLen = opsI.length - offset;
@@ -1043,9 +1526,11 @@ class DeltaBuilder extends Delta {
             // case3: delete some part of end
             // case4: delete some part of center
             const delLen = math.min(opsI.length - offset, remainingLen);
+            this.childCnt -= delLen;
             if (opsI.length === delLen) {
               // case 1
               offset = 0;
+              scheduleForMerge(opsI.next);
               list.remove(this.children, opsI);
             } else if (offset === 0) {
               // case 2
@@ -1066,32 +1551,26 @@ class DeltaBuilder extends Delta {
       } else if ($modifyOp.check(op)) {
         if (opsI == null) {
           list.pushEnd(this.children, op.clone());
+          this.childCnt += 1;
           return
         }
         if ($modifyOp.check(opsI)) {
-          /** @type {any} */ (opsI.value).apply(op.value);
-        } else if ($textOp.check(opsI) || $insertOp.check(opsI)) {
-          const d = opsI.insert[offset];
-          if (!$deltaAny.check(d)) {
-            // probably incompatible delta. can only modify deltas
-            error.unexpectedCase();
-          }
-          /** @type {any} */ (d).apply(op.value);
+          opsI._modValue.apply(op.value);
+        } else if ($insertOp.check(opsI)) {
+          opsI._modValue(offset).apply(op.value);
         } else if ($retainOp.check(opsI)) {
           if (offset > 0) {
-            const cpy = opsI.clone();
-            cpy._splice(offset, opsI.length - offset); // skipped len
+            const cpy = scheduleForMerge(opsI.clone(0, offset)); // skipped len
             opsI._splice(0, offset); // new remainder
             list.insertBetween(this.children, opsI.prev, opsI, cpy); // insert skipped len
             offset = 0;
           }
-          // not deleting opsI, because current idea is that modify should not
-          // advance content
-          list.insertBetween(this.children, opsI.prev, opsI, op.clone()); // insert skipped len
+          list.insertBetween(this.children, opsI.prev, opsI, scheduleForMerge(op.clone())); // insert skipped len
           if (opsI.length === 1) {
             list.remove(this.children, opsI);
           } else {
             opsI._splice(0, 1);
+            scheduleForMerge(opsI);
           }
         } else if ($deleteOp.check(opsI)) ; else {
           error.unexpectedCase();
@@ -1100,15 +1579,22 @@ class DeltaBuilder extends Delta {
         error.unexpectedCase();
       }
     });
+    maybeMergeable.forEach(op => {
+      // check if this is still integrated
+      if (op.prev?.next === op) {
+        tryMergeWithPrev(this.children, op);
+        op.next && tryMergeWithPrev(this.children, op.next);
+      }
+    });
     return this
   }
 
   /**
-   * @param {Delta<any,any,any,any,any>} other
+   * @param {DeltaAny} other
    * @param {boolean} priority
    */
   rebase (other, priority) {
-    // @todo rebase children
+    modDeltaCheck(this);
     /**
      * Rebase attributes
      *
@@ -1119,7 +1605,7 @@ class DeltaBuilder extends Delta {
      * - delete vs delete ⇒ current delete op is removed because item has already been deleted
      * - modify vs modify ⇒ rebase using priority
      */
-    forEachAttr(this, op => {
+    for (const op of this.attrs) {
       if ($insertOp.check(op)) {
         if ($insertOp.check(other.attrs[op.key]) && !priority) {
           delete this.attrs[op.key];
@@ -1132,77 +1618,182 @@ class DeltaBuilder extends Delta {
       } else if ($modifyOp.check(op)) {
         const otherOp = other.attrs[/** @type {any} */ (op.key)];
         if (otherOp == null) ; else if ($modifyOp.check(otherOp)) {
-          op.value.rebase(otherOp.value, priority);
+          op._modValue.rebase(otherOp.value, priority);
         } else {
           delete this.attrs[otherOp.key];
         }
       }
-    });
+    }
+    /**
+     * Rebase children.
+     *
+     * Precedence: insert with higher priority comes first. Op with less priority is transformed to
+     * be inserted later.
+     *
+     * @todo always check if inser OR text
+     */
+    /**
+     * @type {ChildrenOpAny?}
+     */
+    let currChild = this.children.start;
+    let currOffset = 0;
+    /**
+     * @type {ChildrenOpAny?}
+     */
+    let otherChild = other.children.start;
+    let otherOffset = 0;
+    while (currChild != null && otherChild != null) {
+      if ($insertOp.check(currChild) || $textOp.check(currChild)) {
+        /**
+         * Transforming *insert*. If other is..
+         * - insert: transform based on priority
+         * - retain/delete/modify: transform next op against other
+         */
+        if ($insertOp.check(otherChild) || $modifyOp.check(otherChild) || $textOp.check(otherChild)) {
+          if (!priority) {
+            list.insertBetween(this.children, currChild.prev, currChild, new RetainOp(otherChild.length, null, null));
+            this.childCnt += otherChild.length;
+            // curr is transformed against other, transform curr against next
+            otherOffset = otherChild.length;
+          } else {
+            // curr stays as is, transform next op
+            currOffset = currChild.length;
+          }
+        } else { // otherChild = delete | retain | modify - curr stays as is, transform next op
+          currOffset = currChild.length;
+        }
+      } else if ($modifyOp.check(currChild)) {
+        /**
+         * Transforming *modify*. If other is..
+         * - insert: adjust position
+         * - modify: rebase curr modify on other modify
+         * - delete: remove modify
+         * - retain: adjust offset
+         */
+        if ($insertOp.check(otherChild) || $textOp.check(otherChild)) {
+          // @todo: with all list changes (retain insertions, removal), try to merge the surrounding
+          // ops later
+          list.insertBetween(this.children, currChild.prev, currChild, new RetainOp(otherChild.length, null, null));
+          this.childCnt += otherChild.length;
+          // curr is transformed against other, transform curr against next
+          otherOffset = otherChild.length;
+        } else {
+          if ($modifyOp.check(otherChild)) {
+            /** @type {any} */ (currChild.value).rebase(otherChild, priority);
+          } else if ($deleteOp.check(otherChild)) {
+            list.remove(this.children, currChild);
+            this.childCnt -= 1;
+          }
+          currOffset += 1;
+          otherOffset += 1;
+        }
+      } else { // DeleteOp | RetainOp
+        const maxCommonLen = math.min(currChild.length - currOffset, otherChild.length - otherOffset);
+        /**
+         * Transforming *retain* OR *delete*. If other is..
+         * - retain / modify: adjust offsets
+         * - delete: shorten curr op
+         * - insert: split curr op and insert retain
+         */
+        if ($retainOp.check(otherChild) || $modifyOp.check(otherChild)) {
+          currOffset += maxCommonLen;
+          otherOffset += maxCommonLen;
+        } else if ($deleteOp.check(otherChild)) {
+          if ($retainOp.check(currChild)) {
+            // @ts-ignore
+            currChild.retain -= maxCommonLen;
+          } else if ($deleteOp.check(currChild)) {
+            currChild.delete -= maxCommonLen;
+          }
+          this.childCnt -= maxCommonLen;
+        } else { // insert/text.check(currOp)
+          if (currOffset > 0) {
+            const leftPart = currChild.clone(currOffset);
+            list.insertBetween(this.children, currChild.prev, currChild, leftPart);
+            currChild._splice(currOffset, currChild.length - currOffset);
+            currOffset = 0;
+          }
+          list.insertBetween(this.children, currChild.prev, currChild, new RetainOp(otherChild.length, null, null));
+          this.childCnt += otherChild.length;
+          otherOffset = otherChild.length;
+        }
+      }
+      if (currOffset >= currChild.length) {
+        currChild = currChild.next;
+        currOffset = 0;
+      }
+      if (otherOffset >= otherChild.length) {
+        otherChild = otherChild.next;
+        otherOffset = 0;
+      }
+    }
     return this
   }
 
   /**
-   * @return {Delta<NodeName,Attrs,Children,Text,Schema>}
+   * Same as doing `delta.rebase(other.inverse())`, without creating a temporary delta.
+   *
+   * @param {DeltaAny} other
+   * @param {boolean} priority
    */
-  done () {
-    const cs = this.children;
-    for (let end = cs.end; end !== null && $retainOp.check(end) && end.format == null; end = cs.end) {
-      list.popEnd(cs);
-    }
+  rebaseOnInverse (other, priority) {
+    modDeltaCheck(this);
+    // @todo
+    console.info('method rebaseOnInverse unimplemented');
     return this
   }
 }
 
 /**
  * @template {string} NodeName
- * @template {{ [key: string|number|symbol]: any }} [Attrs={}]
- * @template {any} [Children=never]
+ * @template {{ [key: string|number]: any }} [Attrs={}]
+ * @template {encoding.AnyEncodable|DeltaAny|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} [NodeName=any]
- * @template {{ [key: string|number|symbol]: any }} [Attrs={}]
- * @template {any} [Children=never]
+ * @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]
  * @param {object} opts
- * @param {s.Schema<NodeName>?} [opts.name]
- * @param {s.Schema<Attrs>?} [opts.attrs]
- * @param {s.Schema<Children>?} [opts.children]
- * @param {HasText} [opts.hasText]
+ * @param {NodeNameSchema?} [opts.name]
+ * @param {AttrsSchema?} [opts.attrs]
+ * @param {ChildrenSchema?} [opts.children]
+ * @param {HasText} [opts.text]
  * @param {Recursive} [opts.recursive]
- * @return {s.Schema<Delta<
+ * @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, hasText, recursive }) => {
-  name = name == null ? schema.$any : name;
+const $delta = ({ name, attrs, children, text, recursive }) => {
   /**
    * @type {s.Schema<Array<any>>}
    */
-  let $arrContent = children == null ? schema.$never : schema.$array(children);
-  const $attrsPartial = attrs == null ? schema.$object({}) : (schema.$$object.check(attrs) ? attrs.partial : attrs);
+  let $arrContent = children == null ? schema.$never : schema.$array(schema.$(children));
+  const $name = name == null ? schema.$any : schema.$(name);
+  const $attrsPartial = attrs == null ? schema.$object({}) : (schema.$$record.check(attrs) ? attrs : /** @type {any} */ (schema.$(attrs)).partial);
   const $d = schema.$instanceOf(Delta, /** @param {Delta<any,any,any,any,any>} d */ d => {
     if (
-      !name.check(d.name) ||
+      !$name.check(d.name) ||
       object.some(d.attrs,
         (op, k) => $insertOp.check(op) && !$attrsPartial.check({ [k]: op.value })
       )
     ) return false
     for (const op of d.children) {
-      if ((!hasText && $textOp.check(op)) || ($insertOp.check(op) && !$arrContent.check(op.insert))) {
+      if ((!text && $textOp.check(op)) || ($insertOp.check(op) && !$arrContent.check(op.insert))) {
         return false
       }
     }
     return true
   });
   if (recursive) {
-    $arrContent = children == null ? schema.$array($d) : schema.$array(children, $d);
+    $arrContent = children == null ? schema.$array($d) : schema.$array(schema.$(children), $d);
   }
   return /** @type {any} */ ($d)
 };
@@ -1222,16 +1813,16 @@ const $deltaAny = /** @type {any} */ (schema.$instanceOf(Delta));
 const mergeAttrs = (a, b) => object.isEmpty(a) ? b : (object.isEmpty(b) ? a : object.assign({}, a, b));
 
 /**
- * @template {DeltaBuilder?} D
+ * @template {DeltaAny|null} D
  * @param {D} a
  * @param {D} b
  * @return {D}
  */
 const mergeDeltas = (a, b) => {
   if (a != null && b != null) {
-    const c = /** @type {Exclude<D,null>} */ (a.clone());
+    const c = clone(a);
     c.apply(b);
-    return c
+    return /** @type {any} */ (c)
   }
   return a == null ? b : (a || null)
 };
@@ -1262,8 +1853,8 @@ const mergeDeltas = (a, b) => {
  */
 /**
  * @template {string|null} NodeName
- * @template {{[k:string|number|symbol]:any}|null} Attrs
- * @template {Array<any>|string} Children
+ * @template {{[k:string|number]:any}|null} Attrs
+ * @template {Array<any>|string} [Children=never]
  * @overload
  * @param {NodeName} nodeName
  * @param {Attrs} attrs
@@ -1278,7 +1869,7 @@ const mergeDeltas = (a, b) => {
  */
 /**
  * @param {string|s.Schema<DeltaAny>} [nodeNameOrSchema]
- * @param {{[K:string|number|symbol]:any}|s.Schema<DeltaAny>} [attrsOrSchema]
+ * @param {{[K:string|number]:any}|s.Schema<DeltaAny>} [attrsOrSchema]
  * @param {(Array<any>|string)} [children]
  * @return {DeltaBuilder<any,any,any,any,any>}
  */
@@ -1296,12 +1887,12 @@ const create = (nodeNameOrSchema, attrsOrSchema, children) => {
 // DELTA TEXT
 
 /**
- * @template [Embeds=never]
+ * @template {encoding.AnyEncodable|DeltaAny} [Embeds=never]
  * @typedef {Delta<any,{},Embeds,string>} TextDelta
  */
 
 /**
- * @template [Embeds=never]
+ * @template {encoding.AnyEncodable|DeltaAny} [Embeds=never]
  * @typedef {DeltaBuilder<any,{},Embeds,string>} TextDeltaBuilder
  */
 
@@ -1310,7 +1901,7 @@ const create = (nodeNameOrSchema, attrsOrSchema, children) => {
  * @param {$Embeds} $embeds
  * @return {s.Schema<TextDelta<_AnyToNull<$Embeds> extends null ? never : ($Embeds extends Array<s.Schema<infer $C>> ? $C : never)>>}
  */
-const $text = (...$embeds) => /** @type {any} */ ($delta({ children: schema.$union(...$embeds), hasText: true }));
+const $text = (...$embeds) => /** @type {any} */ ($delta({ children: schema.$union(...$embeds), text: true }));
 const $textOnly = $text();
 
 /**
@@ -1321,21 +1912,21 @@ const $textOnly = $text();
 const text = $schema => /** @type {any} */ (create($schema || $textOnly));
 
 /**
- * @template {any} Children
+ * @template {encoding.AnyEncodable|DeltaAny} Children
  * @typedef {Delta<any,{},Children,never>} ArrayDelta
  */
 
 /**
- * @template {any} Children
+ * @template {encoding.AnyEncodable|DeltaAny} Children
  * @typedef {DeltaBuilder<any,{},Children,never>} ArrayDeltaBuilder
  */
 
 /**
- * @template {s.Schema<any>} $Children
+ * @template {any|s.Schema<any>} $Children
  * @param {$Children} [$children]
- * @return {s.Schema<ArrayDelta<$Children>>}
+ * @return {s.Schema<ArrayDelta<s.Unwrap<s.ReadSchema<$Children>>>>}
  */
-const $array = $children => $delta({ children: $children });
+const $array = $children => /** @type {any} */ ($delta({ children: $children }));
 
 /**
  * @template {s.Schema<ArrayDelta<any>>} [$Schema=never]
@@ -1345,17 +1936,17 @@ const $array = $children => $delta({ children: $children });
 const array = $schema => /** @type {any} */ ($schema ? create($schema) : create());
 
 /**
- * @template {{ [K: string|number|symbol]: any }} Attrs
+ * @template {{ [K: string|number]: any }} Attrs
  * @typedef {Delta<any,Attrs,never,never>} MapDelta
  */
 
 /**
- * @template {{ [K: string|number|symbol]: any }} Attrs
+ * @template {{ [K: string|number]: any }} Attrs
  * @typedef {DeltaBuilder<any,Attrs,never,never>} MapDeltaBuilder
  */
 
 /**
- * @template {{ [K: string|number|symbol]: any }} $Attrs
+ * @template {{ [K: string|number]: any }} $Attrs
  * @param {s.Schema<$Attrs>} $attrs
  * @return {s.Schema<MapDelta<$Attrs>>}
  */
@@ -1368,6 +1959,100 @@ const $map = $attrs => /** @type {any} */ ($delta({ attrs: $attrs }));
  */
 const map = $schema => /** @type {any} */ (create(/** @type {any} */ ($schema)));
 
+/**
+ * @template {DeltaAny} D
+ * @param {D} d1
+ * @param {NoInfer<D>} d2
+ * @return {D}
+ */
+const diff = (d1, d2) => {
+  /**
+   * @type {DeltaBuilderAny}
+   */
+  const d = create();
+  if (d1.fingerprint !== d2.fingerprint) {
+    let left1 = d1.children.start;
+    let left2 = d2.children.start;
+    let right1 = d1.children.end;
+    let right2 = d2.children.end;
+    let commonPrefixOffset = 0;
+    // perform a patience sort
+    // 1) remove common prefix and suffix
+    while (left1 != null && left1.fingerprint === left2?.fingerprint) {
+      if (!$deleteOp.check(left1)) {
+        commonPrefixOffset += left1.length;
+      }
+      left1 = left1.next;
+      left2 = left2.next;
+    }
+    while (right1 !== null && right1 !== left1 && right1.fingerprint === right2?.fingerprint) {
+      right1 = right1.prev;
+      right2 = right2.prev;
+    }
+    /**
+     * @type {Array<ChildrenOpAny>}
+     */
+    const ops1 = [];
+    /**
+     * @type {Array<ChildrenOpAny>}
+     */
+    const ops2 = [];
+    while (left1 !== null && left1 !== right1?.next) {
+      ops1.push(left1);
+      left1 = left1.next;
+    }
+    while (left2 !== null && left2 !== right2?.next) {
+      ops2.push(left2);
+      left2 = left2.next;
+    }
+    const fprints1 = ops1.map(op => op.fingerprint);
+    const fprints2 = ops2.map(op => op.fingerprint);
+    const changeset = patience.diff(fprints1, fprints2);
+    d.retain(commonPrefixOffset);
+    for (let i = 0, lastIndex1 = 0, currIndexOffset2 = 0; i < changeset.length; i++) {
+      const change = changeset[i];
+      d.retain(change.index - lastIndex1);
+      // insert minimal diff at curred position in d
+      /**
+       * @param {DeltaBuilderAny} d
+       * @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();
+          }
+        });
+      };
+      diffAndApply(d, ops1.slice(change.index, change.index + change.remove.length), ops2.slice(change.index + currIndexOffset2, change.insert.length));
+      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)) {
+        if ($insertOp.check(attr2)) {
+          d.set(attr2.key, attr2.value);
+        } else {
+          error.unexpectedCase();
+        }
+      }
+    }
+    for (const attr1 of d1.attrs) {
+      if (d2.attrs[attr1.key] == null) {
+        d.unset(attr1.key);
+      }
+    }
+  }
+  return /** @type {D} */ (d.done())
+};
+
 exports.$anyOp = $anyOp;
 exports.$array = $array;
 exports.$attribution = $attribution;
@@ -1384,19 +2069,20 @@ exports.$retainOp = $retainOp;
 exports.$text = $text;
 exports.$textOnly = $textOnly;
 exports.$textOp = $textOp;
+exports.AttrDeleteOp = AttrDeleteOp;
+exports.AttrInsertOp = AttrInsertOp;
+exports.AttrModifyOp = AttrModifyOp;
 exports.DeleteOp = DeleteOp;
 exports.Delta = Delta;
 exports.DeltaBuilder = DeltaBuilder;
 exports.InsertOp = InsertOp;
-exports.MapDeleteOp = MapDeleteOp;
-exports.MapInsertOp = MapInsertOp;
-exports.MapModifyOp = MapModifyOp;
 exports.ModifyOp = ModifyOp;
 exports.RetainOp = RetainOp;
 exports.TextOp = TextOp;
 exports.array = array;
+exports.clone = clone;
 exports.create = create;
-exports.forEachAttr = forEachAttr;
+exports.diff = diff;
 exports.map = map;
 exports.mergeAttrs = mergeAttrs;
 exports.mergeDeltas = mergeDeltas;