lib0 0.2.115-3 → 0.2.115-5

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-b4e49016.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-8d110bf4.cjs');
 var patience = require('./patience.cjs');
+var prng = require('./prng-aa81e812.cjs');
 require('./set-5b47859e.cjs');
-require('./environment-90227ead.cjs');
+require('./environment-98bcf64f.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,16 +1031,17 @@ class Delta {
    * @return {boolean}
    */
   equals (other) {
-    return this[traits.EqualityTraitSymbol](other)
+    return this[equality.EqualityTraitSymbol](other)
   }
 
   /**
    * @param {any} other
    * @return {boolean}
    */
-  [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
+  [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
   }
 
   /**
@@ -1170,8 +1168,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>}
  */
@@ -1435,7 +1433,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)) {
@@ -1445,12 +1443,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
@@ -1532,6 +1532,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;
@@ -1742,17 +1743,135 @@ 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) {
+    // @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(this.children, child.clone());
+    }
+    // @ts-ignore
+    return this
+  }
 }
 
+/**
+ * @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 (!$name.check(o.name, err)) {
+      err?.extend('Delta.name', $name.toString(), o.name, 'Constructor match failed');
+    } 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>]
@@ -1771,7 +1890,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>>}
    */
@@ -1827,6 +1946,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>}
@@ -1887,12 +2035,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
  */
 
@@ -1912,12 +2060,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
  */
 
@@ -2017,29 +2165,73 @@ const diff = (d1, d2) => {
        * @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();
+        // @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));
+        /**
+         * @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(a, b));
+              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);
+        }
       };
-      diffAndApply(d, ops1.slice(change.index, change.index + change.remove.length), ops2.slice(change.index + currIndexOffset2, change.insert.length));
+      diffAndApply(d, ops1.slice(change.index, change.index + change.remove.length), ops2.slice(change.index + currIndexOffset2, 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)) {
+        /* c8 ignore else */
         if ($insertOp.check(attr2)) {
           d.set(attr2.key, attr2.value);
         } else {
+          /* c8 ignore next 2 */
           error.unexpectedCase();
         }
       }
@@ -2050,9 +2242,11 @@ const diff = (d1, d2) => {
       }
     }
   }
-  return /** @type {D} */ (d.done())
+  return /** @type {D} */ (d.done(false))
 };
 
+exports.$$delta = $$delta;
+exports.$Delta = $Delta;
 exports.$anyOp = $anyOp;
 exports.$array = $array;
 exports.$attribution = $attribution;
@@ -2079,6 +2273,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;
@@ -2086,5 +2281,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