lib0 0.2.115-0 → 0.2.115-1

package/delta/d2.js

@@ -3,7 +3,6 @@
  */
 
 import * as list from '../list.js'
-import * as map_ from '../map.js'
 import * as object from '../object.js'
 import * as traits from '../traits.js'
 import * as arr from '../array.js'
@@ -52,11 +51,11 @@ export const $attribution = s.$object({
  */
 
 /**
- * @typedef {{ insert: string|Array<any>, format?: { [key: string]: any }, attribution?: Attribution } | { delete: number } | { retain: number, format?: { [key:string]: any }, attribution?: Attribution } | { modify: object }} DeltaListOpJSON
+ * @typedef {{ type: 'insert', insert: string|Array<any>, format?: { [key: string]: any }, attribution?: Attribution } | { delete: number } | { type: 'retain', retain: number, format?: { [key:string]: any }, attribution?: Attribution } | { type: 'modify', value: object }} DeltaListOpJSON
  */
 
 /**
- * @typedef {{ type: 'insert', value: any, prevValue?: any, attribution?: Attribution } | { type: 'delete', prevValue?: any, attribution?: Attribution } | { type: 'modify', modify: DeltaJSON }} DeltaAttrOpJSON
+ * @typedef {{ type: 'insert', value: any, prevValue?: any, attribution?: Attribution } | { type: 'delete', prevValue?: any, attribution?: Attribution } | { type: 'modify', value: DeltaJSON }} DeltaAttrOpJSON
  */
 
 /**
@@ -64,7 +63,7 @@ export const $attribution = s.$object({
  */
 export const $deltaMapChangeJson = s.$union(
   s.$object({ type: s.$literal('insert'), value: s.$any, prevValue: s.$any.optional, attribution: $attribution.optional }),
-  s.$object({ type: s.$literal('modify'), modify: s.$any }),
+  s.$object({ type: s.$literal('modify'), value: s.$any }),
   s.$object({ type: s.$literal('delete'), prevValue: s.$any.optional, attribution: $attribution.optional })
 )
 
@@ -120,7 +119,7 @@ export class TextOp extends list.ListNode {
    */
   toJSON () {
     const { insert, format, attribution } = this
-    return object.assign({ insert }, format != null ? { format } : ({}), attribution != null ? { attribution } : ({}))
+    return object.assign(/** @type {{type: 'insert', insert: string}} */ ({ type: 'insert', insert }), format != null ? { format } : ({}), attribution != null ? { attribution } : ({}))
   }
 
   /**
@@ -180,7 +179,7 @@ export class InsertOp extends list.ListNode {
    */
   toJSON () {
     const { insert, format, attribution } = this
-    return object.assign({ insert: insert.map(ins => $deltaAny.check(ins) ? ins.toJSON() : ins) }, format ? { format } : ({}), attribution != null ? { attribution } : ({}))
+    return object.assign({ type: /** @type {'insert'} */ ('insert'), insert: insert.map(ins => $deltaAny.check(ins) ? ins.toJSON() : ins) }, format ? { format } : ({}), attribution != null ? { attribution } : ({}))
   }
 
   /**
@@ -286,7 +285,7 @@ export class RetainOp extends list.ListNode {
    */
   toJSON () {
     const { retain, format, attribution } = this
-    return object.assign({ retain }, format ? { format } : {}, attribution != null ? { attribution } : {})
+    return object.assign({ type: /** @type {'retain'} */ ('retain'), retain }, format ? { format } : {}, attribution != null ? { attribution } : {})
   }
 
   /**
@@ -314,7 +313,7 @@ export class ModifyOp extends list.ListNode {
    */
   constructor (delta, format, attribution) {
     super()
-    this.modify = delta
+    this.value = delta
     this.format = format
     this.attribution = attribution
   }
@@ -343,28 +342,28 @@ export class ModifyOp extends list.ListNode {
    * @return {DeltaListOpJSON}
    */
   toJSON () {
-    const { modify, attribution, format } = this
-    return object.assign({ modify: modify.toJSON() }, format ? { format } : {}, attribution != null ? { attribution } : {})
+    const { value, attribution, format } = this
+    return object.assign({ type: /** @type {'modify'} */ ('modify'), value: value.toJSON() }, format ? { format } : {}, attribution != null ? { attribution } : {})
   }
 
   /**
    * @param {ModifyOp<any>} other
    */
   [traits.EqualityTraitSymbol] (other) {
-    return this.modify[traits.EqualityTraitSymbol](other.modify) && fun.equalityDeep(this.format, other.format) && fun.equalityDeep(this.attribution, other.attribution)
+    return this.value[traits.EqualityTraitSymbol](other.value) && fun.equalityDeep(this.format, other.format) && fun.equalityDeep(this.attribution, other.attribution)
   }
 
   /**
    * @return {ModifyOp<DTypes>}
    */
   clone () {
-    return new ModifyOp(this.modify.clone(), _cloneAttrs(this.format), _cloneAttrs(this.attribution))
+    return new ModifyOp(this.value.clone(), _cloneAttrs(this.format), _cloneAttrs(this.attribution))
   }
 }
 
 /**
  * @template V
- * @template [K=string]
+ * @template {string|number|symbol} [K=any]
  */
 export class MapInsertOp {
   /**
@@ -471,7 +470,7 @@ export class MapDeleteOp {
 }
 
 /**
- * @template {Delta} Modifier
+ * @template {DeltaAny} Modifier
  * @template [K=string]
  */
 export class MapModifyOp {
@@ -501,7 +500,7 @@ export class MapModifyOp {
   toJSON () {
     return {
       type: this.type,
-      modify: this.value.toJSON()
+      value: this.value.toJSON()
     }
   }
 
@@ -558,14 +557,14 @@ export const $retainOp = s.$constructedBy(RetainOp)
 export const $modifyOp = s.$custom(o => o != null && (o.constructor === MapModifyOp || o.constructor === ModifyOp))
 
 /**
- * @template {Delta} Modify
+ * @template {DeltaAny} Modify
  * @param {s.Schema<Modify>} $content
  * @return {s.Schema<MapModifyOp<Modify> | ModifyOp<Modify>>}
  */
 export const $modifyOpWith = $content => s.$custom(o =>
   o != null && (
     (o.constructor === MapModifyOp && $content.check(/** @type {MapModifyOp<Modify>} */ (o).value)) ||
-      (o.constructor === ModifyOp && $content.check(/** @type {ModifyOp<Modify>} */ (o).modify))
+      (o.constructor === ModifyOp && $content.check(/** @type {ModifyOp<Modify>} */ (o).value))
   )
 )
 
@@ -602,11 +601,27 @@ export const $anyOp = s.$union($insertOp, $deleteOp, $textOp, $modifyOp)
  * @typedef {_AnyToNull<Schema> extends null ? Delta<any,{[key:string|number|symbol]:any},any,string> : (Schema extends s.Schema<infer D> ? D : never)} AllowedDeltaFromSchema
  */
 
+/**
+ * @typedef {Delta<any,{ [k:string]: 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
+ */
+export 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}} [out Attrs={}]
- * @template {any} [out Children=never]
- * @template {string|never} [out Text=never]
+ * @template {{[key:string|number|symbol]:any}} [Attrs={}]
+ * @template {any} [Children=never]
+ * @template {string|never} [Text=never]
  * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
  */
 export class Delta {
@@ -618,27 +633,26 @@ export class Delta {
     this.name = name || null
     this.$schema = $schema || null
     /**
-     * @type {Map<keyof Attrs, { [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]?: 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]> }}
      */
-    this.attrs = map_.create()
+    this.attrs = /** @type {any} */ ({
+      * [Symbol.iterator] () {
+        for (const k in this) {
+          yield this[k]
+        }
+      }
+    })
+
     /**
      * @type {list.List<
      *   RetainOp
      *   | DeleteOp
      *   | (Text extends never ? never : TextOp)
      *   | (Children extends never ? never : InsertOp<Children>)
-     *   | (Delta extends Children ? ModifyOp<Extract<Children,Delta>> : never)
+     *   | (Delta extends Children ? ModifyOp<Extract<Children,Delta<any,any,any,any,any>>> : never)
      * >}
      */
     this.children = /** @type {any} */ (list.create())
-    /**
-     * @type {FormattingAttributes?}
-     */
-    this.usedAttributes = null
-    /**
-     * @type {Attribution?}
-     */
-    this.usedAttribution = null
     /**
      * @type {any}
      */
@@ -646,7 +660,7 @@ export class Delta {
   }
 
   isEmpty () {
-    return this.attrs.size === 0 && list.isEmpty(this.children)
+    return object.isEmpty(this.attrs) && list.isEmpty(this.children)
   }
 
   /**
@@ -661,7 +675,7 @@ export class Delta {
      * @type {any}
      */
     const children = []
-    this.attrs.forEach(attr => {
+    forEachAttr(this, attr => {
       attrs[attr.key] = attr.toJSON()
     })
     this.children.forEach(val => {
@@ -687,13 +701,13 @@ export class Delta {
    */
   clone () {
     /**
-     * @type {Delta<any,{[k:string|number|symbol]:any},any,any>}
+     * @type {Delta<any,Attrs,any,any,any>}
      */
-    const d = new Delta(/** @type {any} */ (this.name), this.$schema)
+    const d = new DeltaBuilder(/** @type {any} */ (this.name), this.$schema)
     d.origin = this.origin
-    this.attrs.forEach(op => {
-      d.attrs.set(op.key, /** @type {any} */ (op))
-    })
+    for (const op of this.attrs) {
+      d.attrs[op.key] = /** @type {any} */ (op)
+    }
     this.children.forEach(op => {
       list.pushEnd(d.children, op.clone())
     })
@@ -707,6 +721,32 @@ export class Delta {
   [traits.EqualityTraitSymbol] (other) {
     return this.name === other.name && fun.equalityDeep(this.attrs, other.attrs) && fun.equalityDeep(this.children, other.children)
   }
+}
+
+/**
+ * @template {string} [NodeName=any]
+ * @template {{[key:string|number|symbol]:any}} [Attrs={}]
+ * @template {any} [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>}
+ */
+export class DeltaBuilder extends Delta {
+  /**
+   * @param {NodeName} [name]
+   * @param {Schema} [$schema]
+   */
+  constructor (name, $schema) {
+    super(name, $schema)
+    /**
+     * @type {FormattingAttributes?}
+     */
+    this.usedAttributes = null
+    /**
+     * @type {Attribution?}
+     */
+    this.usedAttribution = null
+  }
 
   /**
    * @param {Attribution?} attribution
@@ -767,7 +807,7 @@ export class Delta {
    * @param {NewContent} insert
    * @param {FormattingAttributes?} [formatting]
    * @param {Attribution?} [attribution]
-   * @return {Delta<
+   * @return {DeltaBuilder<
    *   NodeName,
    *   Attrs,
    *   Exclude<NewContent,string>[number]|Children,
@@ -804,7 +844,7 @@ export class Delta {
    * @param {NewContent} modify
    * @param {FormattingAttributes?} formatting
    * @param {Attribution?} attribution
-   * @return {Delta<
+   * @return {DeltaBuilder<
    *   NodeName,
    *   Attrs,
    *   Exclude<NewContent,string>[number]|Children,
@@ -838,7 +878,6 @@ export class Delta {
 
   /**
    * @param {number} len
-   * @return {this}
    */
   delete (len) {
     const lastOp = /** @type {DeleteOp|InsertOp<any>} */ (this.children.end)
@@ -857,7 +896,7 @@ export class Delta {
    * @param {Val} val
    * @param {Attribution?} attribution
    * @param {Val|undefined} [prevValue]
-   * @return {Delta<
+   * @return {DeltaBuilder<
    *   NodeName,
    *   { [K in keyof AddToAttrs<Attrs,Key,Val>]: AddToAttrs<Attrs,Key,Val>[K]  },
    *   Children,
@@ -866,7 +905,7 @@ export class Delta {
    * >}
    */
   set (key, val, attribution = null, prevValue) {
-    this.attrs.set(key, /** @type {any} */ (new MapInsertOp(key, val, prevValue, mergeAttrs(this.usedAttribution, attribution))))
+    this.attrs[key] = /** @type {any} */ (new MapInsertOp(key, val, prevValue, mergeAttrs(this.usedAttribution, attribution)))
     return /** @type {any} */ (this)
   }
 
@@ -874,7 +913,7 @@ export class Delta {
    * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,infer Attrs,any,any,any> ? Attrs : never} NewAttrs
    * @param {NewAttrs} attrs
    * @param {Attribution?} attribution
-   * @return {Delta<
+   * @return {DeltaBuilder<
    *   NodeName,
    *   { [K in keyof MergeAttrs<Attrs,NewAttrs>]: MergeAttrs<Attrs,NewAttrs>[K] },
    *   Children,
@@ -894,7 +933,7 @@ export class Delta {
    * @param {Key} key
    * @param {Attribution?} attribution
    * @param {any} [prevValue]
-   * @return {Delta<
+   * @return {DeltaBuilder<
    *   NodeName,
    *   { [K in keyof AddToAttrs<Attrs,Key,never>]: AddToAttrs<Attrs,Key,never>[K] },
    *   Children,
@@ -903,8 +942,8 @@ export class Delta {
    * >}
    */
   unset (key, attribution = null, prevValue) {
-    this.attrs.set(key, /** @type {any} */ (new MapDeleteOp(key, prevValue, mergeAttrs(this.usedAttribution, attribution))))
-    return this
+    this.attrs[key] = /** @type {any} */ (new MapDeleteOp(key, prevValue, mergeAttrs(this.usedAttribution, attribution)))
+    return /** @type {any} */ (this)
   }
 
   /**
@@ -912,7 +951,7 @@ export class Delta {
    * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,infer As,any,any,any> ? Extract<As[Key],Delta<any,any,any,any,any>> : never} D
    * @param {Key} key
    * @param {D} modify
-   * @return {Delta<
+   * @return {DeltaBuilder<
    *   NodeName,
    *   { [K in keyof AddToAttrs<Attrs,Key,D>]: AddToAttrs<Attrs,Key,D>[K]  },
    *   Children,
@@ -921,29 +960,27 @@ export class Delta {
    * >}
    */
   update (key, modify) {
-    this.attrs.set(key, /** @type {any} */ (new MapModifyOp(key, modify)))
+    this.attrs[key] = /** @type {any} */ (new MapModifyOp(key, modify))
     return /** @type {any} */ (this)
   }
 
   /**
-   * @param {Delta<NodeName,Partial<Attrs>,Children,Text,any>} other
-   * @return {this}
+   * @param {Delta<NodeName,Attrs,Children,Text,any>} other
    */
   apply (other) {
     this.$schema?.expect(other)
-    // apply attrs
-    ;/** @type {Delta<NodeName,Attrs,Children,Text,any>} */ (/** @type {any} */ (other)).attrs.forEach(op => {
-      const c = this.attrs.get(op.key)
+    forEachAttr(/** @type {Delta<NodeName,Attrs,Children,Text,any>} */ (/** @type {any} */ (other)), op => {
+      const c = this.attrs[op.key]
       if ($modifyOp.check(op)) {
         if ($deltaAny.check(c?.value)) {
-          /** @type {Delta} */ (c.value).apply(op.value)
+          /** @type {DeltaBuilder} */ (c.value).apply(op.value)
         } else {
           // then this is a simple modify
-          this.attrs.set(op.key, /** @type {any} */ (op))
+          this.attrs[op.key] = /** @type {any} */ (op)
         }
       } else {
         /** @type {MapInsertOp<any>} */ (op).prevValue = c?.value
-        this.attrs.set(op.key, /** @type {any} */ (op))
+        this.attrs[op.key] = /** @type {any} */ (op)
       }
     })
     // apply children
@@ -1022,14 +1059,14 @@ export class Delta {
           return
         }
         if ($modifyOp.check(opsI)) {
-          opsI.modify.apply(op.modify)
+          /** @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()
           }
-          d.apply(op.modify)
+          /** @type {any} */ (d).apply(op.value)
         } else if ($retainOp.check(opsI)) {
           if (offset > 0) {
             const cpy = opsI.clone()
@@ -1074,30 +1111,33 @@ export class Delta {
      * - delete vs delete ⇒ current delete op is removed because item has already been deleted
      * - modify vs modify ⇒ rebase using priority
      */
-    this.attrs.forEach(op => {
+    forEachAttr(this, op => {
       if ($insertOp.check(op)) {
-        if ($insertOp.check(other.attrs.get(op.key)) && !priority) {
-          this.attrs.delete(op.key)
+        if ($insertOp.check(other.attrs[op.key]) && !priority) {
+          delete this.attrs[op.key]
         }
       } else if ($deleteOp.check(op)) {
-        const otherOp = other.attrs.get(op.key)
+        const otherOp = other.attrs[/** @type {any} */ (op.key)]
         if ($insertOp.check(otherOp)) {
-          this.attrs.delete(otherOp.key)
+          delete this.attrs[otherOp.key]
         }
       } else if ($modifyOp.check(op)) {
-        const otherOp = other.attrs.get(op.key)
+        const otherOp = other.attrs[/** @type {any} */ (op.key)]
         if (otherOp == null) {
           // nop
         } else if ($modifyOp.check(otherOp)) {
           op.value.rebase(otherOp.value, priority)
         } else {
-          this.attrs.delete(otherOp.key)
+          delete this.attrs[otherOp.key]
         }
       }
     })
     return this
   }
 
+  /**
+   * @return {Delta<NodeName,Attrs,Children,Text,Schema>}
+   */
   done () {
     const cs = this.children
     for (let end = cs.end; end !== null && $retainOp.check(end) && end.format == null; end = cs.end) {
@@ -1112,7 +1152,7 @@ export class Delta {
  * @template {{ [key: string|number|symbol]: any }} [Attrs={}]
  * @template {any} [Children=never]
  * @template {string|never} [Text=never]
- * @typedef {Delta<NodeName,Attrs,Children|RecursiveDelta<NodeName,Attrs,Children>,Text>} RecursiveDelta
+ * @typedef {Delta<NodeName,Attrs,Children|Delta<NodeName,Attrs,Children,Text>|RecursiveDelta<NodeName,Attrs,Children,Text>,Text>} RecursiveDelta
  */
 
 /**
@@ -1144,8 +1184,8 @@ export const $delta = ({ name, attrs, children, hasText, recursive }) => {
   const $d = s.$instanceOf(Delta, /** @param {Delta<any,any,any,any,any>} d */ d => {
     if (
       !name.check(d.name) ||
-      Array.from(d.attrs.entries()).some(
-        ([k, op]) => $insertOp.check(op) && !$attrsPartial.check({ [k]: op.value })
+      object.some(d.attrs,
+        (op, k) => $insertOp.check(op) && !$attrsPartial.check({ [k]: op.value })
       )
     ) return false
     for (const op of d.children) {
@@ -1161,7 +1201,10 @@ export const $delta = ({ name, attrs, children, hasText, recursive }) => {
   return /** @type {any} */ ($d)
 }
 
-export const $deltaAny = s.$instanceOf(Delta)
+/**
+ * @type {s.Schema<DeltaAny>}
+ */
+export const $deltaAny = /** @type {any} */ (s.$instanceOf(Delta))
 
 /**
  * Helper function to merge attribution and attributes. The latter input "wins".
@@ -1173,7 +1216,7 @@ export const $deltaAny = s.$instanceOf(Delta)
 export const mergeAttrs = (a, b) => object.isEmpty(a) ? b : (object.isEmpty(b) ? a : object.assign({}, a, b))
 
 /**
- * @template {Delta?} D
+ * @template {DeltaBuilder?} D
  * @param {D} a
  * @param {D} b
  * @return {D}
@@ -1189,62 +1232,58 @@ export const mergeDeltas = (a, b) => {
 
 /**
  * @overload
- * @return {Delta<any,{},never,never,null>}
+ * @return {DeltaBuilder<any,{},never,never,null>}
  */
 /**
  * @template {string} NodeName
  * @overload
  * @param {NodeName} nodeName
- * @return {Delta<NodeName,{},never,never,null>}
+ * @return {DeltaBuilder<NodeName,{},never,never,null>}
  */
 /**
  * @template {string} NodeName
- * @template {s.Schema<Delta<any,any,any,any,any>>} Schema
+ * @template {s.Schema<DeltaAny>} Schema
  * @overload
  * @param {NodeName} nodeName
  * @param {Schema} schema
- * @return {Schema extends s.Schema<Delta<infer N,infer Attrs,infer Children,infer Text,any>> ? Delta<NodeName,Attrs,Children,Text,Schema> : never}
+ * @return {Schema extends s.Schema<Delta<infer N,infer Attrs,infer Children,infer Text,any>> ? DeltaBuilder<NodeName,Attrs,Children,Text,Schema> : never}
  */
 /**
- * @template {s.Schema<Delta<any,any,any,any,any>>} Schema
+ * @template {s.Schema<DeltaAny>} Schema
  * @overload
  * @param {Schema} schema
- * @return {Schema extends s.Schema<Delta<infer N,infer Attrs,infer Children,infer Text,any>> ? Delta<N,Attrs,Children,Text,Schema> : never}
+ * @return {Schema extends s.Schema<Delta<infer N,infer Attrs,infer Children,infer Text,any>> ? DeltaBuilder<N,Attrs,Children,Text,Schema> : never}
  */
 /**
  * @template {string|null} NodeName
  * @template {{[k:string|number|symbol]:any}|null} Attrs
- * @template {Array<Array<any>|string>} Children
+ * @template {Array<any>|string} Children
  * @overload
  * @param {NodeName} nodeName
  * @param {Attrs} attrs
- * @param {...Children} children
- * @return {Delta<
+ * @param {Children} [children]
+ * @return {DeltaBuilder<
  *   NodeName extends null ? any : NodeName,
  *   Attrs extends null ? {} : Attrs,
- *   Extract<Children[number],Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
- *   Extract<Children[number],string>,
+ *   Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
+ *   Extract<Children,string>,
  *   null
  * >}
  */
 /**
- * @param {string|s.Schema<Delta<any,any,any,any,any>>} [nodeNameOrSchema]
- * @param {{[K:string|number|symbol]:any}|s.Schema<Delta<any,any,any,any,any>>} [attrsOrSchema]
- * @param {Array<Array<any>|string>} children
- * @return {Delta<any,any,any,any,any>}
+ * @param {string|s.Schema<DeltaAny>} [nodeNameOrSchema]
+ * @param {{[K:string|number|symbol]:any}|s.Schema<DeltaAny>} [attrsOrSchema]
+ * @param {(Array<any>|string)} [children]
+ * @return {DeltaBuilder<any,any,any,any,any>}
  */
-export const create = (nodeNameOrSchema, attrsOrSchema, ...children) => {
+export const create = (nodeNameOrSchema, attrsOrSchema, children) => {
   const nodeName = /** @type {any} */ (s.$string.check(nodeNameOrSchema) ? nodeNameOrSchema : null)
   const schema = /** @type {any} */ (s.$$schema.check(nodeNameOrSchema) ? nodeNameOrSchema : (s.$$schema.check(attrsOrSchema) ? attrsOrSchema : null))
-  const d = /** @type {Delta<any,any,any,string,null>} */ (new Delta(nodeName, schema))
+  const d = /** @type {DeltaBuilder<any,any,any,string,null>} */ (new DeltaBuilder(nodeName, schema))
   if (s.$objectAny.check(attrsOrSchema)) {
     d.setMany(attrsOrSchema)
   }
-  if (s.$arrayAny.check(children)) {
-    children.forEach(v => {
-      d.insert(v)
-    })
-  }
+  children && d.insert(children)
   return d
 }
 
@@ -1255,6 +1294,11 @@ export const create = (nodeNameOrSchema, attrsOrSchema, ...children) => {
  * @typedef {Delta<any,{},Embeds,string>} TextDelta
  */
 
+/**
+ * @template [Embeds=never]
+ * @typedef {DeltaBuilder<any,{},Embeds,string>} TextDeltaBuilder
+ */
+
 /**
  * @template {Array<s.Schema<any>>} [$Embeds=any]
  * @param {$Embeds} $embeds
@@ -1266,7 +1310,7 @@ export const $textOnly = $text()
 /**
  * @template {s.Schema<Delta<any,{},any,any,null>>} [Schema=s.Schema<Delta<any,{},never,string,null>>]
  * @param {Schema} [$schema]
- * @return {Schema extends s.Schema<Delta<infer N,infer Attrs,infer Children,infer Text,any>> ? Delta<N,Attrs,Children,Text,Schema> : never}
+ * @return {Schema extends s.Schema<Delta<infer N,infer Attrs,infer Children,infer Text,any>> ? DeltaBuilder<N,Attrs,Children,Text,Schema> : never}
  */
 export const text = $schema => /** @type {any} */ (create($schema || $textOnly))
 
@@ -1275,6 +1319,11 @@ export const text = $schema => /** @type {any} */ (create($schema || $textOnly))
  * @typedef {Delta<any,{},Children,never>} ArrayDelta
  */
 
+/**
+ * @template {any} Children
+ * @typedef {DeltaBuilder<any,{},Children,never>} ArrayDeltaBuilder
+ */
+
 /**
  * @template {s.Schema<any>} $Children
  * @param {$Children} [$children]
@@ -1285,7 +1334,7 @@ export const $array = $children => $delta({ children: $children })
 /**
  * @template {s.Schema<ArrayDelta<any>>} [$Schema=never]
  * @param {$Schema} $schema
- * @return {$Schema extends never ? ArrayDelta<never> : Delta<any,{},never,never,$Schema>}
+ * @return {$Schema extends never ? ArrayDeltaBuilder<never> : DeltaBuilder<any,{},never,never,$Schema>}
  */
 export const array = $schema => /** @type {any} */ ($schema ? create($schema) : create())
 
@@ -1294,6 +1343,11 @@ export const array = $schema => /** @type {any} */ ($schema ? create($schema) :
  * @typedef {Delta<any,Attrs,never,never>} MapDelta
  */
 
+/**
+ * @template {{ [K: string|number|symbol]: any }} Attrs
+ * @typedef {DeltaBuilder<any,Attrs,never,never>} MapDeltaBuilder
+ */
+
 /**
  * @template {{ [K: string|number|symbol]: any }} $Attrs
  * @param {s.Schema<$Attrs>} $attrs
@@ -1304,6 +1358,6 @@ export const $map = $attrs => /** @type {any} */ ($delta({ attrs: $attrs }))
 /**
  * @template {s.Schema<MapDelta<any>>|undefined} [$Schema=undefined]
  * @param {$Schema} [$schema]
- * @return {$Schema extends s.Schema<MapDelta<infer Attrs>> ? Delta<any,Attrs,never,never,$Schema> : MapDelta<{}>}
+ * @return {$Schema extends s.Schema<MapDelta<infer Attrs>> ? DeltaBuilder<any,Attrs,never,never,$Schema> : MapDeltaBuilder<{}>}
  */
 export const map = $schema => /** @type {any} */ (create(/** @type {any} */ ($schema)))

package/delta/d2.test.d.ts

@@ -1,4 +1,5 @@
 export function testDeltaBasics(): void;
+export function testAssignability(): void;
 export function testText(): void;
 export function testDelta(_tc: t.TestCase): void;
 export function testDeltaMerging(_tc: t.TestCase): void;

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

@@ -1 +1 @@
-{"version":3,"file":"d2.test.d.ts","sourceRoot":"","sources":["d2.test.js"],"names":[],"mappings":"AAMO,wCA4BN;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,QAgCpB;AAKM,wCAFI,CAAC,CAAC,QAAQ,QA2CpB;AAKM,kCAFI,CAAC,CAAC,QAAQ,QAoDpB;AAKM,gDAFI,CAAC,CAAC,QAAQ,QAoEpB;AAKM,mCAFI,CAAC,CAAC,QAAQ,QAwBpB;AAEM,0CAkBN;mBAtYkB,cAAc"}
+{"version":3,"file":"d2.test.d.ts","sourceRoot":"","sources":["d2.test.js"],"names":[],"mappings":"AAMO,wCA2BN;AAKM,0CA0HN;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,QAoDpB;AAKM,gDAFI,CAAC,CAAC,QAAQ,QAoEpB;AAKM,mCAFI,CAAC,CAAC,QAAQ,QAiCpB;AAEM,0CAoBN;mBA3gBkB,cAAc"}

package/diff.d.ts

@@ -18,7 +18,7 @@ export function simpleDiffStringWithCursor(a: string, b: string, cursor: number)
  * a === b // values match
  * ```
  */
-export type SimpleDiff<T extends string> = {
+export type SimpleDiff<T extends string | Array<any>> = {
     /**
      * The index where changes were applied
      */

package/diff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["diff.js"],"names":[],"mappings":"AAyCO,oCAJI,MAAM,KACN,MAAM,GACL,UAAU,CAAC,MAAM,CAAC,CAoB7B;AAlBM,8BAJI,MAAM,KACN,MAAM,GACL,UAAU,CAAC,MAAM,CAAC,CAoB7B;AAuBM,gCAPM,CAAC,KAEH,KAAK,CAAC,CAAC,CAAC,KACR,KAAK,CAAC,CAAC,CAAC,YACR,CAAS,IAAC,EAAD,CAAC,EAAE,IAAC,EAAD,CAAC,KAAE,OAAO,GACrB,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAgB/B;AASM,8CAJI,MAAM,KACN,MAAM,UACN,MAAM;;;;EAyChB;;;;;;;;;;;;;uBA5HqB,CAAC,SAAV,MAAQ;;;;;;;;;;;;;YAKP,CAAC"}
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["diff.js"],"names":[],"mappings":"AAyCO,oCAJI,MAAM,KACN,MAAM,GACL,UAAU,CAAC,MAAM,CAAC,CAoB7B;AAlBM,8BAJI,MAAM,KACN,MAAM,GACL,UAAU,CAAC,MAAM,CAAC,CAoB7B;AAuBM,gCAPM,CAAC,KAEH,KAAK,CAAC,CAAC,CAAC,KACR,KAAK,CAAC,CAAC,CAAC,YACR,CAAS,IAAC,EAAD,CAAC,EAAE,IAAC,EAAD,CAAC,KAAE,OAAO,GACrB,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAgB/B;AASM,8CAJI,MAAM,KACN,MAAM,UACN,MAAM;;;;EAyChB;;;;;;;;;;;;;uBA5HgC,CAAC,SAApB,MAAM,GAAC,KAAK,CAAC,GAAG,CAAE;;;;;;;;;;;;;YAKlB,CAAC"}

package/diff.js

@@ -18,7 +18,7 @@ import { equalityStrict } from './function.js'
  * a === b // values match
  * ```
  *
- * @template {string} T
+ * @template {string|Array<any>} T
  * @typedef {Object} SimpleDiff
  * @property {Number} index The index where changes were applied
  * @property {Number} remove The number of characters to delete starting

package/dist/component.cjs

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var dom = require('./dom-2b123630.cjs');
-var diff = require('./diff-f0776c15.cjs');
+var diff = require('./diff-1832cb43.cjs');
 var object = require('./object-18980796.cjs');
 var json = require('./json-092190a1.cjs');
 var string = require('./string-fddc5f8b.cjs');