lib0 0.2.115-4 → 0.2.115-5

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

@@ -10,7 +10,8 @@
 
 import * as list from '../list.js'
 import * as object from '../object.js'
-import * as traits from '../traits.js'
+import * as equalityTrait from '../trait/equality.js'
+import * as fingerprintTrait from '../trait/fingerprint.js'
 import * as arr from '../array.js'
 import * as fun from '../function.js'
 import * as s from '../schema.js'
@@ -20,6 +21,7 @@ import * as rabin from '../hash/rabin.js'
 import * as encoding from '../encoding.js'
 import * as buffer from '../buffer.js'
 import * as patience from '../diff/patience.js'
+import * as prng from '../prng.js'
 
 /**
  * @typedef {{
@@ -103,10 +105,6 @@ const _cloneAttrs = attrs => attrs == null ? attrs : { ...attrs }
  */
 const _markMaybeDeltaAsDone = maybeDelta => $deltaAny.check(maybeDelta) ? /** @type {MaybeDelta} */ (maybeDelta.done()) : maybeDelta
 
-/**
- * @typedef {unknown & DeltaAny} Q
- */
-
 export class TextOp extends list.ListNode {
   /**
    * @param {string} insert
@@ -185,7 +183,7 @@ export class TextOp extends list.ListNode {
   /**
    * @param {TextOp} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equalityTrait.EqualityTraitSymbol] (other) {
     return fun.equalityDeep(this.insert, other.insert) && fun.equalityDeep(this.format, other.format) && fun.equalityDeep(this.attribution, other.attribution)
   }
 
@@ -198,7 +196,7 @@ export class TextOp extends list.ListNode {
 }
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} ArrayContent
+ * @template {fingerprintTrait.Fingerprintable} ArrayContent
  */
 export class InsertOp extends list.ListNode {
   /**
@@ -273,13 +271,7 @@ export class InsertOp extends list.ListNode {
       encoding.writeVarUint(encoder, 1) // insertOp type: 1
       encoding.writeVarUint(encoder, this.insert.length)
       this.insert.forEach(ins => {
-        if ($deltaAny.check(ins)) {
-          encoding.writeUint8(encoder, 0)
-          encoding.writeVarString(encoder, ins.fingerprint)
-        } else {
-          encoding.writeUint8(encoder, 1)
-          encoding.writeAny(encoder, ins)
-        }
+        encoding.writeVarString(encoder, fingerprintTrait.fingerprint(ins))
       })
       encoding.writeAny(encoder, this.format)
     })))
@@ -308,7 +300,7 @@ export class InsertOp extends list.ListNode {
   /**
    * @param {InsertOp<ArrayContent>} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equalityTrait.EqualityTraitSymbol] (other) {
     return fun.equalityDeep(this.insert, other.insert) && fun.equalityDeep(this.format, other.format) && fun.equalityDeep(this.attribution, other.attribution)
   }
 
@@ -321,7 +313,7 @@ export class InsertOp extends list.ListNode {
 }
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} [Children=never]
+ * @template {fingerprintTrait.Fingerprintable} [Children=never]
  * @template {string} [Text=never]
  */
 export class DeleteOp extends list.ListNode {
@@ -382,7 +374,7 @@ export class DeleteOp extends list.ListNode {
   /**
    * @param {DeleteOp} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equalityTrait.EqualityTraitSymbol] (other) {
     return this.delete === other.delete
   }
 
@@ -463,7 +455,7 @@ export class RetainOp extends list.ListNode {
   /**
    * @param {RetainOp} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equalityTrait.EqualityTraitSymbol] (other) {
     return this.retain === other.retain && fun.equalityDeep(this.format, other.format) && fun.equalityDeep(this.attribution, other.attribution)
   }
 
@@ -563,8 +555,8 @@ export class ModifyOp extends list.ListNode {
   /**
    * @param {ModifyOp<any>} other
    */
-  [traits.EqualityTraitSymbol] (other) {
-    return this.value[traits.EqualityTraitSymbol](other.value) && fun.equalityDeep(this.format, other.format) && fun.equalityDeep(this.attribution, other.attribution)
+  [equalityTrait.EqualityTraitSymbol] (other) {
+    return this.value[equalityTrait.EqualityTraitSymbol](other.value) && fun.equalityDeep(this.format, other.format) && fun.equalityDeep(this.attribution, other.attribution)
   }
 
   /**
@@ -576,7 +568,7 @@ export class ModifyOp extends list.ListNode {
 }
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} V
+ * @template {fingerprintTrait.Fingerprintable} V
  * @template {string|number} [K=any]
  */
 export class AttrInsertOp {
@@ -661,7 +653,7 @@ export class AttrInsertOp {
   /**
    * @param {AttrInsertOp<V>} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equalityTrait.EqualityTraitSymbol] (other) {
     return this.key === other.key && fun.equalityDeep(this.value, other.value) && fun.equalityDeep(this.attribution, other.attribution)
   }
 
@@ -726,7 +718,7 @@ export class AttrDeleteOp {
   /**
    * @param {AttrDeleteOp<V>} other
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equalityTrait.EqualityTraitSymbol] (other) {
     return this.key === other.key && fun.equalityDeep(this.attribution, other.attribution)
   }
 
@@ -800,8 +792,8 @@ export class AttrModifyOp {
   /**
    * @param {AttrModifyOp<Modifier>} other
    */
-  [traits.EqualityTraitSymbol] (other) {
-    return this.key === other.key && this.value[traits.EqualityTraitSymbol](other.value)
+  [equalityTrait.EqualityTraitSymbol] (other) {
+    return this.key === other.key && this.value[equalityTrait.EqualityTraitSymbol](other.value)
   }
 
   /**
@@ -823,7 +815,7 @@ export const $deleteOp = s.$custom(o => o != null && (o.constructor === DeleteOp
 export const $insertOp = s.$custom(o => o != null && (o.constructor === AttrInsertOp || o.constructor === InsertOp))
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} Content
+ * @template {fingerprintTrait.Fingerprintable} Content
  * @param {s.Schema<Content>} $content
  * @return {s.Schema<AttrInsertOp<Content> | InsertOp<Content>>}
  */
@@ -904,8 +896,8 @@ export const $anyOp = s.$union($insertOp, $deleteOp, $textOp, $modifyOp)
 /**
  * @template {string} [NodeName=any]
  * @template {{[k:string|number]:any}} [Attrs={}]
- * @template {encoding.AnyEncodable|DeltaAny|never} [Children=never]
- * @template {string|never} [Text=never]
+ * @template {fingerprintTrait.Fingerprintable} [Children=never]
+ * @template {string} [Text=never]
  * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
  */
 export class Delta {
@@ -956,6 +948,7 @@ export class Delta {
    */
   get fingerprint () {
     return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeUint32(encoder, 0xf2ae5680) // "magic number" that ensures that different types of content don't yield the same fingerprint
       encoding.writeAny(encoder, this.name)
       /**
        * @type {Array<number|string>}
@@ -985,6 +978,10 @@ export class Delta {
     })))
   }
 
+  [fingerprintTrait.FingerprintTraitSymbol] () {
+    return this.fingerprint
+  }
+
   isEmpty () {
     return object.isEmpty(this.attrs) && list.isEmpty(this.children)
   }
@@ -1021,14 +1018,14 @@ export class Delta {
    * @return {boolean}
    */
   equals (other) {
-    return this[traits.EqualityTraitSymbol](other)
+    return this[equalityTrait.EqualityTraitSymbol](other)
   }
 
   /**
    * @param {any} other
    * @return {boolean}
    */
-  [traits.EqualityTraitSymbol] (other) {
+  [equalityTrait.EqualityTraitSymbol] (other) {
     // @todo it is only necessary to compare finrerprints OR do a deep equality check (remove
     // childCnt as well)
     return this.name === other.name && fun.equalityDeep(this.attrs, other.attrs) && fun.equalityDeep(this.children, other.children) && this.childCnt === other.childCnt
@@ -1158,8 +1155,8 @@ const modDeltaCheck = d => {
 /**
  * @template {string} [NodeName=any]
  * @template {{[key:string|number]:any}} [Attrs={}]
- * @template {encoding.AnyEncodable|DeltaAny|never} [Children=never]
- * @template {string|never} [Text=never]
+ * @template {fingerprintTrait.Fingerprintable} [Children=never]
+ * @template {string} [Text=never]
  * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
  * @extends {Delta<NodeName,Attrs,Children,Text,Schema>}
  */
@@ -1423,7 +1420,7 @@ export class DeltaBuilder extends Delta {
     modDeltaCheck(this)
     this.$schema?.expect(other)
     // apply attrs
-    for (let op of other.attrs) {
+    for (const op of other.attrs) {
       const c = /** @type {AttrInsertOp<any,any>|AttrDeleteOp<any>|AttrModifyOp<any,any>} */ (this.attrs[op.key])
       if ($modifyOp.check(op)) {
         if ($deltaAny.check(c?.value)) {
@@ -1433,12 +1430,14 @@ export class DeltaBuilder extends Delta {
           // @ts-ignore
           this.attrs[op.key] = op.clone()
         }
-      } else {
-        op = /** @type {any} */ (op.clone())
+      } else if ($insertOp.check(op)) {
         // @ts-ignore
         op.prevValue = c?.value
         // @ts-ignore
-        this.attrs[op.key] = op
+        this.attrs[op.key] = op.clone()
+      } else if ($deleteOp.check(op)) {
+        op.prevValue = c?.value
+        delete this.attrs[op.key]
       }
     }
     // apply children
@@ -1520,6 +1519,7 @@ export class DeltaBuilder extends Delta {
               offset = 0
               scheduleForMerge(opsI.next)
               list.remove(this.children, opsI)
+              opsI = opsI.next
             } else if (offset === 0) {
               // case 2
               offset = 0
@@ -1734,17 +1734,135 @@ export class DeltaBuilder extends Delta {
     console.info('method rebaseOnInverse unimplemented')
     return this
   }
+
+  /**
+   * Append child ops from one op to the other.
+   *
+   *     delta.create().insert('a').append(delta.create().insert('b')) // => insert "ab"
+   *
+   * @template {DeltaAny} OtherDelta
+   * @param {OtherDelta} other
+   * @return {CastToDelta<OtherDelta> extends Delta<any,any,infer OtherChildren,infer OtherText,any> ? DeltaBuilder<NodeName,Attrs,Children|OtherChildren,Text|OtherText,Schema> : never}
+   */
+  append (other) {
+    // @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>>}
+ */
+export class $Delta extends s.Schema {
+  /**
+   * @param {s.Schema<Name>} $name
+   * @param {s.Schema<Attrs>} $attrs
+   * @param {s.Schema<Children>} $children
+   * @param {HasText} hasText
+   * @param {s.Schema<Formats>} $formats
+   * @param {Recursive} recursive
+   */
+  constructor ($name, $attrs, $children, hasText, $formats, recursive) {
+    super()
+    const $attrsPartial = s.$$object.check($attrs) ? $attrs.partial : $attrs
+    if (recursive) {
+      // @ts-ignore
+      $children = s.$union($children, this)
+    }
+    this.shape = { $name, $attrs: $attrsPartial, $children, hasText, $formats }
+  }
+
+  /**
+   * @param {any} o
+   * @param {s.ValidationError} [err]
+   * @return {o is Delta<
+   *   Name,
+   *   Attrs,
+   *   Children|(Recursive extends true ? RecursiveDelta<Name,Attrs,Children,HasText extends true ? string : never> : never),
+   *   HasText extends true ? string : never,
+   *   any>}
+   */
+  check (o, err = undefined) {
+    const { $name, $attrs, $children, hasText, $formats } = this.shape
+    if (!(o instanceof Delta)) {
+      err?.extend(null, 'Delta', o?.constructor.name, 'Constructor match failed')
+    } else if (!$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}
+ */
+export const $delta = ({ name, attrs, children, text, formats, recursive }) => /** @type {any} */ (new $Delta(
+  name == null ? s.$any : s.$(name),
+  /** @type {any} */ (attrs == null ? s.$object({}) : s.$(attrs)),
+  /** @type {any} */ (children == null ? s.$never : s.$(children)),
+  text ?? false,
+  formats == null ? s.$any : s.$(formats),
+  recursive ?? false
+))
+
+export const $$delta = s.$constructedBy($Delta)
+
+/**
+ * @todo remove this
+ *
  * @template {s.Schema<string>|string|Array<string>} [NodeNameSchema=s.Schema<any>]
  * @template {s.Schema<{ [key: string|number]: any }>|{ [key:string|number]:any }} [AttrsSchema=s.Schema<{}>]
  * @template {any} [ChildrenSchema=s.Schema<never>]
@@ -1763,7 +1881,7 @@ export class DeltaBuilder extends Delta {
  *     HasText extends true ? string : never
  * >> : never}
  */
-export const $delta = ({ name, attrs, children, text, recursive }) => {
+export const _$delta = ({ name, attrs, children, text, recursive }) => {
   /**
    * @type {s.Schema<Array<any>>}
    */
@@ -1819,6 +1937,35 @@ export const mergeDeltas = (a, b) => {
   return a == null ? b : (a || null)
 }
 
+/**
+ * @template {DeltaAny} D
+ * @param {prng.PRNG} gen
+ * @param {s.Schema<D>} $d
+ * @return {D extends Delta<infer NodeName,infer Attrs,infer Children,infer Text,infer Schema> ? DeltaBuilder<NodeName,Attrs,Children,Text,Schema> : never}
+ */
+export const random = (gen, $d) => {
+  const { $name, $attrs, $children, hasText, $formats: $formats_ } = /** @type {$Delta<any,any,any,boolean,any,any>} */ (/** @type {any} */ ($d)).shape
+  const d = s.$$any.check($name) ? create($deltaAny) : create(s.random(gen, $name), $deltaAny)
+  const $formats = s.$$any.check($formats_) ? s.$null : $formats_
+  prng.bool(gen) && d.setMany(s.random(gen, $attrs))
+  for (let i = prng.uint32(gen, 0, 5); i > 0; i--) {
+    if (hasText && prng.bool(gen)) {
+      d.insert(prng.word(gen), s.random(gen, $formats))
+    } else if (!s.$$never.check($children)) {
+      /**
+       * @type {Array<any>}
+       */
+      const ins = []
+      let insN = prng.int32(gen, 0, 5)
+      while (insN--) {
+        ins.push(s.random(gen, $children))
+      }
+      d.insert(ins, s.random(gen, $formats))
+    }
+  }
+  return /** @type {any} */ (d)
+}
+
 /**
  * @overload
  * @return {DeltaBuilder<any,{},never,never,null>}
@@ -1879,12 +2026,12 @@ export const create = (nodeNameOrSchema, attrsOrSchema, children) => {
 // DELTA TEXT
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} [Embeds=never]
+ * @template {fingerprintTrait.Fingerprintable} [Embeds=never]
  * @typedef {Delta<any,{},Embeds,string>} TextDelta
  */
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} [Embeds=never]
+ * @template {fingerprintTrait.Fingerprintable} [Embeds=never]
  * @typedef {DeltaBuilder<any,{},Embeds,string>} TextDeltaBuilder
  */
 
@@ -1904,12 +2051,12 @@ export const $textOnly = $text()
 export const text = $schema => /** @type {any} */ (create($schema || $textOnly))
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} Children
+ * @template {fingerprintTrait.Fingerprintable} Children
  * @typedef {Delta<any,{},Children,never>} ArrayDelta
  */
 
 /**
- * @template {encoding.AnyEncodable|DeltaAny} Children
+ * @template {fingerprintTrait.Fingerprintable} Children
  * @typedef {DeltaBuilder<any,{},Children,never>} ArrayDeltaBuilder
  */
 
@@ -2009,29 +2156,73 @@ export 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 => s.$string.check(c) ? c : fingerprintTrait.fingerprint(c))
+        const shouldContentFingerprinted = shouldContent.map(c => s.$string.check(c) ? c : fingerprintTrait.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(s.$string.check(a) ? a : [a])
+              cdii++
+            } else {
+              d.delete(1)
+              cdri++
+            }
           }
-        })
+          for (; cdii < cd.insert.length; cdii++) {
+            const a = cd.insert[cdii]
+            d.insert(s.$string.check(a) ? a : [a])
+          }
+          d.delete(cd.remove.length - cdri)
+        }
       }
-      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()
         }
       }
@@ -2042,5 +2233,5 @@ export const diff = (d1, d2) => {
       }
     }
   }
-  return /** @type {D} */ (d.done())
+  return /** @type {D} */ (d.done(false))
 }

package/delta/{d2.test.d.ts → delta.test.d.ts}

@@ -1,6 +1,7 @@
 export function testDeltaBasicApi(_tc: t.TestCase): void;
 export function testDeltaValues(_tc: t.TestCase): void;
 export function testDeltaBasicCases(): void;
+export function testDeltaArrayBasics(): void;
 export function testAssignability(): void;
 export function testText(): void;
 export function testDelta(_tc: t.TestCase): void;
@@ -16,6 +17,10 @@ export function testNodeDelta(_tc: t.TestCase): void;
 export function testRecursiveNode(): void;
 export function testSimplifiedDeltaSchemaDefinition(): void;
 export function testDiffing(): void;
+export function testDiffingCommonPreSuffix(): void;
 export function testSlice(): void;
+export function testRepeatRandomListDiff(tc: t.TestCase): void;
+export function testRepeatRandomMapDiff(tc: t.TestCase): void;
+export function testDeltaAppend(tc: t.TestCase): void;
 import * as t from 'lib0/testing';
-//# sourceMappingURL=d2.test.d.ts.map
+//# sourceMappingURL=delta.test.d.ts.map

package/delta/delta.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delta.test.d.ts","sourceRoot":"","sources":["delta.test.js"],"names":[],"mappings":"AAqCO,uCAFI,CAAC,CAAC,QAAQ,QAWpB;AAYM,qCAFI,CAAC,CAAC,QAAQ,QAwBpB;AAEM,4CA2BN;AAEM,6CAMN;AAKM,0CAkJN;AAEM,iCAWN;AAKM,+BAFI,CAAC,CAAC,QAAQ,QAKpB;AAKM,sCAFI,CAAC,CAAC,QAAQ,QAYpB;AAKM,uCAFI,CAAC,CAAC,QAAQ,QAuBpB;AAKM,wCAFI,CAAC,CAAC,QAAQ,QAsBpB;AAEM,sCAaN;AAKM,wCAFI,CAAC,CAAC,QAAQ,QA4BpB;AAKM,wCAFI,CAAC,CAAC,QAAQ,QA2CpB;AAKM,kCAFI,CAAC,CAAC,QAAQ,QAqDpB;AAKM,gDAFI,CAAC,CAAC,QAAQ,QAoEpB;AAKM,mCAFI,CAAC,CAAC,QAAQ,QAiCpB;AAEM,0CAmBN;AAEM,4DAIN;AAEM,oCAMN;AAEM,mDAMN;AAEM,kCAGN;AAKM,6CAFI,CAAC,CAAC,QAAQ,QAWpB;AAKM,4CAFI,CAAC,CAAC,QAAQ,QAWpB;AAKM,oCAFI,CAAC,CAAC,QAAQ,QAQpB;mBAzrBkB,cAAc"}

package/delta/t3.test.d.ts

@@ -15,5 +15,5 @@ export type Transform<DeltaA extends delta.Delta, DeltaB extends delta.Delta> =
     applyA: (da: DeltaA) => TransformResult<DeltaA, DeltaB>;
     applyB: (db: DeltaB) => TransformResult<DeltaA, DeltaB>;
 };
-import * as delta from './d2.js';
+import * as delta from './delta.js';
 //# sourceMappingURL=t3.test.d.ts.map

package/delta/t3.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"t3.test.d.ts","sourceRoot":"","sources":["t3.test.js"],"names":[],"mappings":"AAoBO,gCAN4B,MAAM,SAA3B,KAAK,CAAC,YAAY,OAAE,EACC,MAAM,SAA3B,KAAK,CAAC,YAAY,OAAE,KACvB,MAAM,KACN,MAAM,GACL,eAAe,CAAC,MAAM,OAAC,EAAC,MAAM,OAAC,CAAC,CAEO;AACnD,+DAA+D;4BAbnC,MAAM,SAApB,KAAK,CAAC,KAAK,OAAE,EACC,MAAM,SAApB,KAAK,CAAC,KAAK,OAAE,IACd;IAAE,CAAC,EAAE,MAAM,OAAC,CAAC;IAAC,CAAC,EAAE,MAAM,OAAC,CAAA;CAAE;6BAiBT,MAAM,SAAtB,KAAK,CAAC,QAAS,EACC,MAAM,SAAtB,KAAK,CAAC,QAAS,IAChB,CAAC,CAAC,EAAC;IAAC,CAAC,EAAC,MAAM,OAAC,CAAC;IAAA,CAAC,EAAC,MAAM,OAAC,CAAA;CAAC,KAAG,CAAC;IAAC,CAAC,EAAC,MAAM,OAAC,CAAC;IAAA,CAAC,EAAC,MAAM,OAAC,CAAA;CAAC,CAAC;sBA2GpC,MAAM,SAAnB,KAAK,CAAC,KAAM,EACC,MAAM,SAAnB,KAAK,CAAC,KAAM,IACb;IAAE,MAAM,EAAE,CAAC,EAAE,EAAC,MAAM,KAAG,eAAe,CAAC,MAAM,EAAC,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,CAAC,EAAE,EAAC,MAAM,KAAG,eAAe,CAAC,MAAM,EAAC,MAAM,CAAC,CAAA;CAAE;uBAvIlG,SAAS"}
+{"version":3,"file":"t3.test.d.ts","sourceRoot":"","sources":["t3.test.js"],"names":[],"mappings":"AAoBO,gCAN4B,MAAM,SAA3B,KAAK,CAAC,YAAY,OAAE,EACC,MAAM,SAA3B,KAAK,CAAC,YAAY,OAAE,KACvB,MAAM,KACN,MAAM,GACL,eAAe,CAAC,MAAM,OAAC,EAAC,MAAM,OAAC,CAAC,CAEO;AACnD,+DAA+D;4BAbnC,MAAM,SAApB,KAAK,CAAC,KAAK,OAAE,EACC,MAAM,SAApB,KAAK,CAAC,KAAK,OAAE,IACd;IAAE,CAAC,EAAE,MAAM,OAAC,CAAC;IAAC,CAAC,EAAE,MAAM,OAAC,CAAA;CAAE;6BAiBT,MAAM,SAAtB,KAAK,CAAC,QAAS,EACC,MAAM,SAAtB,KAAK,CAAC,QAAS,IAChB,CAAC,CAAC,EAAC;IAAC,CAAC,EAAC,MAAM,OAAC,CAAC;IAAA,CAAC,EAAC,MAAM,OAAC,CAAA;CAAC,KAAG,CAAC;IAAC,CAAC,EAAC,MAAM,OAAC,CAAC;IAAA,CAAC,EAAC,MAAM,OAAC,CAAA;CAAC,CAAC;sBA2GpC,MAAM,SAAnB,KAAK,CAAC,KAAM,EACC,MAAM,SAAnB,KAAK,CAAC,KAAM,IACb;IAAE,MAAM,EAAE,CAAC,EAAE,EAAC,MAAM,KAAG,eAAe,CAAC,MAAM,EAAC,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,CAAC,EAAE,EAAC,MAAM,KAAG,eAAe,CAAC,MAAM,EAAC,MAAM,CAAC,CAAA;CAAE;uBAvIlG,YAAY"}

package/dist/array.cjs

@@ -2,68 +2,25 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var schema = require('./schema.cjs');
-var abstractArray = require('./abstract-array.cjs');
-var ops = require('./ops.cjs');
-require('./object-18980796.cjs');
-require('./traits.cjs');
-require('./array-78849c95.cjs');
 require('./set-5b47859e.cjs');
-require('./error-0c1f634f.cjs');
-require('./environment-90227ead.cjs');
-require('./map-24d263c0.cjs');
-require('./string-fddc5f8b.cjs');
-require('./conditions-f5c0c102.cjs');
-require('./storage.cjs');
-require('./function-e7d18feb.cjs');
-require('./abstract.cjs');
-require('./math-96d5e8c4.cjs');
-require('./list.cjs');
+var array = require('./array-78849c95.cjs');
 
-/**
- * @template ArrayContent
- * @template {boolean} [WithText=false]
- * @extends AbstractDeltaArrayBuilder<'array', import('./ops.js').DeltaArrayOps<ArrayContent,WithText>>
- */
-class DeltaArray extends abstractArray.AbstractDeltaArrayBuilder {
-  /**
-   * @param {s.Schema<ArrayContent>} $insert
-   * @param {WithText} withText
-   */
-  constructor ($insert, withText) {
-    super('array', $insert);
-    this.withText = withText;
-  }
-}
 
-/**
- * @template ArrayContent
- * @template {boolean} [WithText=false]
- * @param {s.Schema<ArrayContent>} $insert
- * @param {WithText} [withText]
- * @return {s.Schema<DeltaArray<ArrayContent, WithText>>}
- */
-const $array = ($insert, withText) => /** @type {any} */ (schema.$instanceOf(abstractArray.AbstractDeltaArrayBuilder, o => o.type === 'array' && o.ops.every(op => {
-  if (ops.$textOp.check(op)) return !!withText
-  if (ops.$insertOp.check(op)) return op.insert.every(opi => $insert.check(opi))
-  return true
-})));
-/**
- * @type {s.Schema<DeltaArray<any,any>>}
- */
-const $arrayAny = /** @type {any} */ (schema.$instanceOf(abstractArray.AbstractDeltaArrayBuilder, o => o.type === 'array'));
 
-/**
- * @template [V=any]
- * @template {boolean} [WithText=any]
- * @param {s.Schema<V>} $insert
- * @param {WithText} [withText]
- * @return {DeltaArray<V,WithText>}
- */
-const array = ($insert = schema.$any, withText) => /** @type {DeltaArray<V,WithText>} */ (new DeltaArray($insert, withText ?? true));
-
-exports.$array = $array;
-exports.$arrayAny = $arrayAny;
-exports.DeltaArray = DeltaArray;
-exports.array = array;
+exports.appendTo = array.appendTo;
+exports.bubblesortItem = array.bubblesortItem;
+exports.copy = array.copy;
+exports.create = array.create;
+exports.equalFlat = array.equalFlat;
+exports.every = array.every;
+exports.flatten = array.flatten;
+exports.fold = array.fold;
+exports.from = array.from;
+exports.isArray = array.isArray;
+exports.last = array.last;
+exports.map = array.map;
+exports.some = array.some;
+exports.unfold = array.unfold;
+exports.unique = array.unique;
+exports.uniqueBy = array.uniqueBy;
 //# sourceMappingURL=array.cjs.map

package/dist/array.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"array.cjs","sources":["../delta/array.js"],"sourcesContent":["import * as s from '../schema.js'\nimport { AbstractDeltaArrayBuilder } from './abstract-array.js'\nimport * as ops from './ops.js'\n\n/**\n * @template ArrayContent\n * @template {boolean} [WithText=false]\n * @extends AbstractDeltaArrayBuilder<'array', import('./ops.js').DeltaArrayOps<ArrayContent,WithText>>\n */\nexport class DeltaArray extends AbstractDeltaArrayBuilder {\n  /**\n   * @param {s.Schema<ArrayContent>} $insert\n   * @param {WithText} withText\n   */\n  constructor ($insert, withText) {\n    super('array', $insert)\n    this.withText = withText\n  }\n}\n\n/**\n * @template ArrayContent\n * @template {boolean} [WithText=false]\n * @param {s.Schema<ArrayContent>} $insert\n * @param {WithText} [withText]\n * @return {s.Schema<DeltaArray<ArrayContent, WithText>>}\n */\nexport const $array = ($insert, withText) => /** @type {any} */ (s.$instanceOf(AbstractDeltaArrayBuilder, o => o.type === 'array' && o.ops.every(op => {\n  if (ops.$textOp.check(op)) return !!withText\n  if (ops.$insertOp.check(op)) return op.insert.every(opi => $insert.check(opi))\n  return true\n})))\n/**\n * @type {s.Schema<DeltaArray<any,any>>}\n */\nexport const $arrayAny = /** @type {any} */ (s.$instanceOf(AbstractDeltaArrayBuilder, o => o.type === 'array'))\n\n/**\n * @template [V=any]\n * @template {boolean} [WithText=any]\n * @param {s.Schema<V>} $insert\n * @param {WithText} [withText]\n * @return {DeltaArray<V,WithText>}\n */\nexport const array = ($insert = s.$any, withText) => /** @type {DeltaArray<V,WithText>} */ (new DeltaArray($insert, withText ?? true))\n"],"names":["AbstractDeltaArrayBuilder","s.$instanceOf","ops.$textOp","ops.$insertOp","s.$any"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAIA;AACA;AACA;AACA;AACA;AACO,MAAM,UAAU,SAASA,uCAAyB,CAAC;AAC1D;AACA;AACA;AACA;AACA,EAAE,WAAW,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE;AAClC,IAAI,KAAK,CAAC,OAAO,EAAE,OAAO,EAAC;AAC3B,IAAI,IAAI,CAAC,QAAQ,GAAG,SAAQ;AAC5B,GAAG;AACH,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,MAAM,GAAG,CAAC,OAAO,EAAE,QAAQ,yBAAyBC,kBAAa,CAACD,uCAAyB,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,OAAO,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,IAAI;AACvJ,EAAE,IAAIE,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,QAAQ;AAC9C,EAAE,IAAIC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AAChF,EAAE,OAAO,IAAI;AACb,CAAC,CAAC,CAAC,EAAC;AACJ;AACA;AACA;AACY,MAAC,SAAS,uBAAuBF,kBAAa,CAACD,uCAAyB,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC,EAAC;AAC/G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,KAAK,GAAG,CAAC,OAAO,GAAGI,WAAM,EAAE,QAAQ,4CAA4C,IAAI,UAAU,CAAC,OAAO,EAAE,QAAQ,IAAI,IAAI,CAAC;;;;;;;"}
+{"version":3,"file":"array.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;"}