lib0 0.2.115-0 → 0.2.115-1

package/dist/d2.cjs

@@ -3,7 +3,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var list = require('./list.cjs');
-var map$1 = require('./map-24d263c0.cjs');
 var object = require('./object-18980796.cjs');
 var traits = require('./traits.cjs');
 var array$1 = require('./array-78849c95.cjs');
@@ -13,6 +12,7 @@ var error = require('./error-0c1f634f.cjs');
 var math = require('./math-96d5e8c4.cjs');
 require('./set-5b47859e.cjs');
 require('./environment-90227ead.cjs');
+require('./map-24d263c0.cjs');
 require('./string-fddc5f8b.cjs');
 require('./conditions-f5c0c102.cjs');
 require('./storage.cjs');
@@ -61,11 +61,11 @@ const $attribution = schema.$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
  */
 
 /**
@@ -73,7 +73,7 @@ const $attribution = schema.$object({
  */
 const $deltaMapChangeJson = schema.$union(
   schema.$object({ type: schema.$literal('insert'), value: schema.$any, prevValue: schema.$any.optional, attribution: $attribution.optional }),
-  schema.$object({ type: schema.$literal('modify'), modify: schema.$any }),
+  schema.$object({ type: schema.$literal('modify'), value: schema.$any }),
   schema.$object({ type: schema.$literal('delete'), prevValue: schema.$any.optional, attribution: $attribution.optional })
 );
 
@@ -129,7 +129,7 @@ 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 } : ({}))
   }
 
   /**
@@ -189,7 +189,7 @@ 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 } : ({}))
   }
 
   /**
@@ -295,7 +295,7 @@ 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 } : {})
   }
 
   /**
@@ -323,7 +323,7 @@ class ModifyOp extends list.ListNode {
    */
   constructor (delta, format, attribution) {
     super();
-    this.modify = delta;
+    this.value = delta;
     this.format = format;
     this.attribution = attribution;
   }
@@ -352,28 +352,28 @@ 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) && _function.equalityDeep(this.format, other.format) && _function.equalityDeep(this.attribution, other.attribution)
+    return this.value[traits.EqualityTraitSymbol](other.value) && _function.equalityDeep(this.format, other.format) && _function.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]
  */
 class MapInsertOp {
   /**
@@ -480,7 +480,7 @@ class MapDeleteOp {
 }
 
 /**
- * @template {Delta} Modifier
+ * @template {DeltaAny} Modifier
  * @template [K=string]
  */
 class MapModifyOp {
@@ -510,7 +510,7 @@ class MapModifyOp {
   toJSON () {
     return {
       type: this.type,
-      modify: this.value.toJSON()
+      value: this.value.toJSON()
     }
   }
 
@@ -567,14 +567,14 @@ const $retainOp = schema.$constructedBy(RetainOp);
 const $modifyOp = schema.$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>>}
  */
 const $modifyOpWith = $content => schema.$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))
   )
 );
 
@@ -611,11 +611,27 @@ const $anyOp = schema.$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
+ */
+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]
  */
 class Delta {
@@ -627,27 +643,26 @@ 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$1.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}
      */
@@ -655,7 +670,7 @@ class Delta {
   }
 
   isEmpty () {
-    return this.attrs.size === 0 && list.isEmpty(this.children)
+    return object.isEmpty(this.attrs) && list.isEmpty(this.children)
   }
 
   /**
@@ -670,7 +685,7 @@ class Delta {
      * @type {any}
      */
     const children = [];
-    this.attrs.forEach(attr => {
+    forEachAttr(this, attr => {
       attrs[attr.key] = attr.toJSON();
     });
     this.children.forEach(val => {
@@ -696,13 +711,13 @@ 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());
     });
@@ -716,6 +731,32 @@ class Delta {
   [traits.EqualityTraitSymbol] (other) {
     return this.name === other.name && _function.equalityDeep(this.attrs, other.attrs) && _function.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>}
+ */
+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
@@ -776,7 +817,7 @@ class Delta {
    * @param {NewContent} insert
    * @param {FormattingAttributes?} [formatting]
    * @param {Attribution?} [attribution]
-   * @return {Delta<
+   * @return {DeltaBuilder<
    *   NodeName,
    *   Attrs,
    *   Exclude<NewContent,string>[number]|Children,
@@ -813,7 +854,7 @@ class Delta {
    * @param {NewContent} modify
    * @param {FormattingAttributes?} formatting
    * @param {Attribution?} attribution
-   * @return {Delta<
+   * @return {DeltaBuilder<
    *   NodeName,
    *   Attrs,
    *   Exclude<NewContent,string>[number]|Children,
@@ -847,7 +888,6 @@ class Delta {
 
   /**
    * @param {number} len
-   * @return {this}
    */
   delete (len) {
     const lastOp = /** @type {DeleteOp|InsertOp<any>} */ (this.children.end);
@@ -866,7 +906,7 @@ 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,
@@ -875,7 +915,7 @@ 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)
   }
 
@@ -883,7 +923,7 @@ 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,
@@ -903,7 +943,7 @@ 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,
@@ -912,8 +952,8 @@ 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)
   }
 
   /**
@@ -921,7 +961,7 @@ 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,
@@ -930,29 +970,27 @@ 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);
+    this.$schema?.expect(other);
+    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
@@ -1031,14 +1069,14 @@ 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();
@@ -1081,28 +1119,31 @@ 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) ; 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) {
@@ -1117,7 +1158,7 @@ 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
  */
 
 /**
@@ -1149,8 +1190,8 @@ const $delta = ({ name, attrs, children, hasText, recursive }) => {
   const $d = schema.$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) {
@@ -1166,7 +1207,10 @@ const $delta = ({ name, attrs, children, hasText, recursive }) => {
   return /** @type {any} */ ($d)
 };
 
-const $deltaAny = schema.$instanceOf(Delta);
+/**
+ * @type {s.Schema<DeltaAny>}
+ */
+const $deltaAny = /** @type {any} */ (schema.$instanceOf(Delta));
 
 /**
  * Helper function to merge attribution and attributes. The latter input "wins".
@@ -1178,7 +1222,7 @@ const $deltaAny = schema.$instanceOf(Delta);
 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}
@@ -1194,62 +1238,58 @@ 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>}
  */
-const create = (nodeNameOrSchema, attrsOrSchema, ...children) => {
+const create = (nodeNameOrSchema, attrsOrSchema, children) => {
   const nodeName = /** @type {any} */ (schema.$string.check(nodeNameOrSchema) ? nodeNameOrSchema : null);
   const schema$1 = /** @type {any} */ (schema.$$schema.check(nodeNameOrSchema) ? nodeNameOrSchema : (schema.$$schema.check(attrsOrSchema) ? attrsOrSchema : null));
-  const d = /** @type {Delta<any,any,any,string,null>} */ (new Delta(nodeName, schema$1));
+  const d = /** @type {DeltaBuilder<any,any,any,string,null>} */ (new DeltaBuilder(nodeName, schema$1));
   if (schema.$objectAny.check(attrsOrSchema)) {
     d.setMany(attrsOrSchema);
   }
-  if (schema.$arrayAny.check(children)) {
-    children.forEach(v => {
-      d.insert(v);
-    });
-  }
+  children && d.insert(children);
   return d
 };
 
@@ -1260,6 +1300,11 @@ 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
@@ -1271,7 +1316,7 @@ 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}
  */
 const text = $schema => /** @type {any} */ (create($schema || $textOnly));
 
@@ -1280,6 +1325,11 @@ 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]
@@ -1290,7 +1340,7 @@ 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>}
  */
 const array = $schema => /** @type {any} */ ($schema ? create($schema) : create());
 
@@ -1299,6 +1349,11 @@ const array = $schema => /** @type {any} */ ($schema ? create($schema) : create(
  * @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
@@ -1309,7 +1364,7 @@ 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<{}>}
  */
 const map = $schema => /** @type {any} */ (create(/** @type {any} */ ($schema)));
 
@@ -1331,6 +1386,7 @@ exports.$textOnly = $textOnly;
 exports.$textOp = $textOp;
 exports.DeleteOp = DeleteOp;
 exports.Delta = Delta;
+exports.DeltaBuilder = DeltaBuilder;
 exports.InsertOp = InsertOp;
 exports.MapDeleteOp = MapDeleteOp;
 exports.MapInsertOp = MapInsertOp;
@@ -1340,6 +1396,7 @@ exports.RetainOp = RetainOp;
 exports.TextOp = TextOp;
 exports.array = array;
 exports.create = create;
+exports.forEachAttr = forEachAttr;
 exports.map = map;
 exports.mergeAttrs = mergeAttrs;
 exports.mergeDeltas = mergeDeltas;