lib0 1.0.0-rc.1 → 1.0.0-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lib0",
-  "version": "1.0.0-rc.1",
+  "version": "1.0.0-rc.2",
   "description": "",
   "sideEffects": false,
   "type": "module",
@@ -282,7 +282,7 @@
     "test:bundle": "esbuild bundle.test.js --bundle --outfile=dist/bundle.test.js --analyze --minify && wc -c dist/bundle.test.js",
     "trace-deopt": "clear && node --trace-deopt src/test.js",
     "trace-opt": "clear && node --trace-opt src/test.js",
-    "lint": "standard && tsc",
+    "lint": "tsc && standard",
     "gendocs": "node ./bin/gendocs.js",
     "np": "np --test-script dist",
     "version": "npm run clean && npm run dist && git add README.md",

package/src/delta/delta.js

@@ -317,7 +317,7 @@ export class InsertOp extends list.ListNode {
 }
 
 /**
- * @template {DeltaConf} [DConf={}]
+ * @template {DeltaConf} [Conf={}]
  */
 export class DeleteOp extends list.ListNode {
   /**
@@ -327,7 +327,7 @@ export class DeleteOp extends list.ListNode {
     super()
     this.delete = len
     /**
-     * @type {Delta<DConf>?}
+     * @type {Delta<Conf>?}
      */
     this.prevValue = null
     /**
@@ -666,13 +666,13 @@ export class SetAttrOp {
 
   toJSON () {
     const v = this.value
-    const prevValue = this.prevValue
     const attribution = this.attribution
     return object.assign({
-      type: this.type,
-      value: $deltaAny.check(v) ? v.toJSON() : v
-    }, attribution != null ? { attribution } : {}, prevValue !== undefined ? { prevValue } : {})
-  }
+        type: this.type,
+        value: $deltaAny.check(v) ? v.toJSON() : v
+      },
+      attribution != null ? { attribution } : {}
+    )}
 
   /**
    * @param {SetAttrOp<V>} other
@@ -738,9 +738,12 @@ export class DeleteAttrOp {
    */
   toJSON () {
     const {
-      type, attribution, prevValue
+      type, attribution,
     } = this
-    return object.assign({ type }, attribution != null ? { attribution } : {}, prevValue !== undefined ? { prevValue } : {})
+    return object.assign(
+      { type },
+      attribution != null ? { attribution } : {}
+    )
   }
 
   /**
@@ -880,7 +883,7 @@ export const $modifyAttrOpWith = $content => s.$custom(o => $modifyAttrOp.check(
  * @template {{[Key in string|number]: any}} Attrs
  * @template {string|number} Key
  * @template {any} Val
- * @typedef {{ [K in (Key | keyof Attrs)]: (unknown extends Attrs[K] ? never : Attrs[K]) | (Key extends K ? Val : never) }} AddToAttrs
+ * @typedef {{ [K in (Key | keyof Attrs)]: (unknown extends Attrs[K] ? never : Attrs[K]) | (Key extends K ? Val : never) } & {}} AddToAttrs
  */
 
 /**
@@ -903,72 +906,68 @@ export const $modifyAttrOpWith = $content => s.$custom(o => $modifyAttrOp.check(
  * @property {fingerprintTrait.Fingerprintable} [DeltaConf.children=never]
  * @property {boolean} [DeltaConf.text=never]
  * @property {{[K:string|number]:fingerprintTrait.Fingerprintable}} [DeltaConf.attrs={}]
- * @property {boolean} [DeltaConf.fixed=never]
  * @property {boolean} [DeltaConf.recursiveChildren=false]
  * @property {boolean} [DeltaConf.recursiveAttrs=false]
  */
 
 /**
- * @template {DeltaConf} DConf
- * @typedef {DConf extends {name:infer Name} ? (unknown extends Name ? any : (Exclude<Name,undefined>)) : any} DeltaConfGetName
- */
-
-/**
- * @template {DeltaConf} DConf
- * @typedef {(DConf extends {children:infer Children} ? (unknown extends Children ? any : Children) : never) | (DConf extends {recursiveChildren:true} ? Delta<DConf> : never)} DeltaConfGetChildren
+ * @template {DeltaConf} Conf
+ * @typedef {Conf extends {name:infer Name} ? (unknown extends Name ? any : (Exclude<Name,undefined>)) : any} DeltaConfGetName
  */
 
 /**
- * @template {DeltaConf} DConf
- * @typedef {DConf extends {fixed:true} ? DeltaConfGetChildren<DConf> : any } DeltaConfGetAllowedChildren
+ * @template {DeltaConf} Conf
+ * @typedef {(Conf extends {children:infer Children} ? (unknown extends Children ? any : Children) : never) | (Conf extends {recursiveChildren:true} ? Delta<Conf> : never)} DeltaConfGetChildren
  */
 
 /**
- * @template {DeltaConf} DConf
- * @typedef {0 extends (1 & DConf) ? string : (DConf extends {text:true} ? string : never)} DeltaConfGetText
+ * @template {DeltaConf} Conf
+ * @template {boolean} FixedConf
+ * @typedef {FixedConf extends true ? DeltaConfGetChildren<Conf> : any } DeltaConfGetAllowedChildren
  */
 
 /**
- * @template {DeltaConf} DConf
- * @typedef {import('../ts.js').TypeIsAny<DConf, {[K:string|number]:any}, (DConf extends {attrs:infer Attrs} ? (Attrs extends undefined ? {} : Attrs) : {})>} DeltaConfGetAttrs
+ * @template {DeltaConf} Conf
+ * @typedef {0 extends (1 & Conf) ? string : (Conf extends {text:true} ? string : never)} DeltaConfGetText
  */
 
 /**
- * @template {DeltaConf} DConf
- * @typedef {DConf extends {fixed:true} ? DeltaConfGetAttrs<DConf> : {[K:string|number]:any}} DeltaConfGetAllowedAttrs
+ * @template {DeltaConf} Conf
+ * @typedef {import('../ts.js').TypeIsAny<Conf, {[K:string|number]:any}, (Conf extends {attrs:infer Attrs} ? (Attrs extends undefined ? {} : Attrs) : {})>} DeltaConfGetAttrs
  */
 
 /**
- * @template {DeltaConf} DConf
- * @typedef {0 extends (1 & DConf) ? true : (DConf extends { fixed: true } ? true : false)} DeltaConfGetFixed
+ * @template {DeltaConf} Conf
+ * @template {boolean} FixedConf
+ * @typedef {FixedConf extends true ? DeltaConfGetAttrs<Conf> : {[K:string|number]:any}} DeltaConfGetAllowedAttrs
  */
 
 /**
- * @template {DeltaConf} DConf
- * @typedef {DConf extends {recursiveChildren:true} ? true : false} DeltaConfGetRecursiveChildren
+ * @template {DeltaConf} Conf
+ * @typedef {Conf extends {recursiveChildren:true} ? true : false} DeltaConfGetRecursiveChildren
  */
 
 /**
- * @template {DeltaConf} DConf
- * @typedef {DConf extends {recursiveAttrs:true} ? true : false} DeltaConfigGetRecursiveAttrs
+ * @template {DeltaConf} Conf
+ * @typedef {Conf extends {recursiveAttrs:true} ? true : false} DeltaConfigGetRecursiveAttrs
  */
 
 /**
  * Transform Delta(Builder) to a normal delta.
  *
  * @template V
- * @typedef {V extends never ? never : (import('../ts.js').TypeIsAny<V,any,V extends Delta<infer DConf> ? Delta<DConf> : V>)} _SanifyDelta
+ * @typedef {V extends never ? never : (import('../ts.js').TypeIsAny<V,any,V extends Delta<infer Conf> ? Delta<Conf> : V>)} _SanifyDelta
  */
 
 /**
- * @template {DeltaConf} DConf
- * @typedef {import('../ts.js').Prettify<{[K in keyof DConf]: K extends 'attrs' ? import('../ts.js').Prettify<{ [KA in keyof DConf[K]]: _SanifyDelta<DConf[K][KA]> },1> : (K extends 'children' ? _SanifyDelta<DConf[K]> : DConf[K]) }, 1>} PrettifyDeltaConf
+ * @template {DeltaConf} Conf
+ * @typedef {import('../ts.js').Prettify<{[K in keyof Conf]: K extends 'attrs' ? import('../ts.js').Prettify<{ [KA in keyof Conf[K]]: _SanifyDelta<Conf[K][KA]> },1> : (K extends 'children' ? _SanifyDelta<Conf[K]> : Conf[K]) }, 1>} PrettifyDeltaConf
  */
 
 /**
  * @template {DeltaConf} D1
- * @template {DeltaConf} D2
- * @typedef {import('../ts.js').TypeIsAny<D1, any, PrettifyDeltaConf<{[K in (keyof D1|keyof D2)]: K extends keyof D2 ? D2[K] : (K extends keyof D1 ? D1[K] : never)}>>} DeltaConfOverwrite
+ * @template D2
+ * @typedef {(import('../ts.js').TypeIsAny<D1, any, PrettifyDeltaConf<{[K in (keyof D1|keyof D2)]: K extends keyof D2 ? D2[K] : (K extends keyof D1 ? D1[K] : never)}>> & {}) extends infer DC extends DeltaConf ? DC : never} DeltaConfOverwrite
  */
 
 /**
@@ -1019,12 +1018,12 @@ class DeltaData {
 }
 
 /**
- * @template {DeltaConf} [DConf={}]
+ * @template {DeltaConf} [Conf={}]
  * @extends {DeltaData<
- *   DeltaConfGetName<DConf>,
- *   DeltaConfGetAttrs<DConf>,
- *   DeltaConfGetChildren<DConf>,
- *   DConf extends {text:true} ? true : false
+ *   DeltaConfGetName<Conf>,
+ *   DeltaConfGetAttrs<Conf>,
+ *   DeltaConfGetChildren<Conf>,
+ *   Conf extends {text:true} ? true : false
  * >}
  */
 export class Delta extends DeltaData {
@@ -1137,7 +1136,7 @@ export class Delta extends DeltaData {
    * formats&attributions). In the future, there might be additional merge operations that can be
    * performed to result in smaller deltas. Set `markAsDone=false` to only perform the cleanup.
    *
-   * @return {Delta<DConf>}
+   * @return {Delta<Conf>}
    */
   done (markAsDone = true) {
     if (!this.isDone) {
@@ -1153,12 +1152,12 @@ export class Delta extends DeltaData {
 }
 
 /**
- * @template {DeltaConf} DConf
- * @param {Delta<DConf>} d
+ * @template {DeltaConf} Conf
+ * @param {Delta<Conf>} d
  * @param {number} start
  * @param {number} end
  * @param {ChildrenOpAny?} currNode - start slicing at this node (instead of d.children.start)
- * @return {DeltaBuilder<DConf>}
+ * @return {DeltaBuilder<Conf>}
  */
 export const slice = (d, start = 0, end = d.childCnt, currNode = d.children.start) => {
   const cpy = /** @type {DeltaAny} */ (new DeltaBuilder(d.name, d.$schema))
@@ -1204,7 +1203,7 @@ export const slice = (d, start = 0, end = d.childCnt, currNode = d.children.star
 /**
  * @template {DeltaAny} D
  * @param {D} d
- * @return {D extends Delta<infer DConf> ? DeltaBuilder<DConf> : never}
+ * @return {D extends Delta<infer Conf> ? DeltaBuilder<Conf> : never}
  */
 export const clone = d => /** @type {any} */ (slice(d, 0, d.childCnt))
 
@@ -1256,13 +1255,14 @@ const modDeltaCheck = d => {
 }
 
 /**
- * @template {DeltaConf} [DConf={}]
- * @extends {Delta<DConf>}
+ * @template {DeltaConf} [Conf={}]
+ * @template {boolean} [FixedConf=false]
+ * @extends {Delta<Conf>}
  */
 export class DeltaBuilder extends Delta {
   /**
    * @param {string?} name
-   * @param {s.Schema<Delta<DConf>>?} $schema
+   * @param {s.Schema<Delta<Conf>>?} $schema
    */
   constructor (name, $schema) {
     super(name, $schema)
@@ -1335,14 +1335,14 @@ export class DeltaBuilder extends Delta {
   }
 
   /**
-   * @template {(DConf extends {fixed:true} ? never : (Array<any>|string)) | (DeltaConfGetChildren<DConf> extends infer Children ? (Children extends never ? never : Array<Children>) : never) | DeltaConfGetText<DConf>} NewContent
+   * @template {(FixedConf extends true ? never : (Array<any>|string)) | (DeltaConfGetChildren<Conf> extends infer Children ? (Children extends never ? never : Array<Children>) : never) | DeltaConfGetText<Conf>} NewContent
    * @param {NewContent} insert
    * @param {FormattingAttributes?} [formatting]
    * @param {Attribution?} [attribution]
-   * @return {DeltaBuilder<DConf extends {fixed: true} ? DConf : DeltaConfOverwrite<DConf,
+   * @return {DeltaBuilder<FixedConf extends true ? Conf : DeltaConfOverwrite<Conf,
    * (Exclude<NewContent,string> extends never ? {} : {
-   *   children: Exclude<NewContent,string>[number]|DeltaConfGetChildren<DConf>
-   * }) & (Extract<NewContent,string> extends never ? {} : { text: true })>>}
+   *   children: Exclude<NewContent,string>[number]|DeltaConfGetChildren<Conf>
+   * }) & (Extract<NewContent,string> extends never ? {} : { text: true })>, FixedConf>}
    */
   insert (insert, formatting = null, attribution = null) {
     modDeltaCheck(this)
@@ -1374,11 +1374,11 @@ export class DeltaBuilder extends Delta {
   }
 
   /**
-   * @template {Extract<DeltaConfGetAllowedChildren<DConf>,Delta>} NewContent
+   * @template {Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>,Delta>} NewContent
    * @param {NewContent} modify
    * @param {FormattingAttributes?} formatting
    * @param {Attribution?} attribution
-   * @return {DeltaBuilder<DeltaConfOverwrite<DConf, {children: DeltaConfGetChildren<DConf>|NewContent}>>}
+   * @return {DeltaBuilder<DeltaConfOverwrite<Conf, {children: DeltaConfGetChildren<Conf>|NewContent}>, FixedConf>}
    */
   modify (modify, formatting = null, attribution = null) {
     modDeltaCheck(this)
@@ -1425,13 +1425,13 @@ export class DeltaBuilder extends Delta {
   }
 
   /**
-   * @template {keyof DeltaConfGetAllowedAttrs<DConf>} Key
-   * @template {DeltaConfGetAllowedAttrs<DConf>[Key]} Val
+   * @template {Extract<keyof DeltaConfGetAllowedAttrs<Conf, FixedConf>,string|number>} Key
+   * @template {DeltaConfGetAllowedAttrs<Conf, FixedConf>[Key]} Val
    * @param {Key} key
    * @param {Val} val
    * @param {Attribution?} attribution
    * @param {Val|undefined} [prevValue]
-   * @return {DeltaBuilder<DeltaConfOverwrite<DConf,{attrs:AddToAttrs<DeltaConfGetAttrs<DConf>,Key,Val>}>>}
+   * @return {DeltaBuilder<DeltaConfOverwrite<Conf,{attrs:AddToAttrs<DeltaConfGetAttrs<Conf>,Key,Val>}>, FixedConf>}
    */
   setAttr (key, val, attribution = null, prevValue) {
     modDeltaCheck(this)
@@ -1442,13 +1442,13 @@ export class DeltaBuilder extends Delta {
   }
 
   /**
-   * @template {DeltaConfGetAllowedAttrs<DConf>} NewAttrs
+   * @template {DeltaConfGetAllowedAttrs<Conf, FixedConf>} NewAttrs
    * @param {NewAttrs} attrs
    * @param {Attribution?} attribution
    * @return {DeltaBuilder<DeltaConfOverwrite<
-   *   DConf,
-   *   { attrs: MergeAttrs<DeltaConfGetAttrs<DConf>,NewAttrs> }
-   *   >>
+   *   Conf,
+   *   { attrs: MergeAttrs<DeltaConfGetAttrs<Conf>,NewAttrs> }
+   *   >, FixedConf>
    * }
    */
   setAttrs (attrs, attribution = null) {
@@ -1460,13 +1460,13 @@ export class DeltaBuilder extends Delta {
   }
 
   /**
-   * @template {keyof DeltaConfGetAllowedAttrs<DConf>} Key
+   * @template {Extract<keyof DeltaConfGetAllowedAttrs<Conf, FixedConf>,string|number>} Key
    * @param {Key} key
    * @param {Attribution?} attribution
    * @param {any} [prevValue]
-   * @return {DeltaBuilder<DeltaConfOverwrite<DConf, {
-   *   attrs: AddToAttrs<DeltaConfGetAttrs<DConf>,Key,never>
-   * }>>}
+   * @return {DeltaBuilder<DeltaConfOverwrite<Conf, {
+   *   attrs: AddToAttrs<DeltaConfGetAttrs<Conf>,Key,never>
+   * }>, FixedConf>}
    */
   deleteAttr (key, attribution = null, prevValue) {
     modDeltaCheck(this)
@@ -1477,11 +1477,11 @@ export class DeltaBuilder extends Delta {
   }
 
   /**
-   * @template {DeltaConfGetAllowedAttrs<DConf> extends infer As ? { [K in keyof As]: Extract<As[K],DeltaAny> extends never ? never : K }[keyof As] : never} Key
-   * @template {Extract<DeltaConfGetAllowedAttrs<DConf>[Key],DeltaAny>} D
+   * @template {DeltaConfGetAllowedAttrs<Conf, FixedConf> extends infer As ? { [K in keyof As]: Extract<As[K],DeltaAny> extends never ? never : K }[keyof As] : never} Key
+   * @template {Extract<DeltaConfGetAllowedAttrs<Conf, FixedConf>[Key],DeltaAny>} D
    * @param {Key} key
    * @param {D} modify
-   * @return {DeltaBuilder<DeltaConfOverwrite<DConf,{attrs:AddToAttrs<DeltaConfGetAttrs<DConf>,Key,D>}>>}
+   * @return {DeltaBuilder<DeltaConfOverwrite<Conf,{attrs:AddToAttrs<DeltaConfGetAttrs<Conf>,Key,D>}>, FixedConf>}
    */
   modifyAttr (key, modify) {
     modDeltaCheck(this)
@@ -1490,7 +1490,7 @@ export class DeltaBuilder extends Delta {
   }
 
   /**
-   * @param {Delta<DConf>} other
+   * @param {Delta<Conf>} other
    */
   apply (other) {
     modDeltaCheck(this)
@@ -1848,15 +1848,13 @@ export class DeltaBuilder extends Delta {
    *
    *     delta.create().insert('a').append(delta.create().insert('b')) // => insert "ab"
    *
-   * @todo on fixed deltas this should not extend
-   *
    * @template {DeltaConf} OtherDeltaConf
    * @param {Delta<OtherDeltaConf>} other
-   * @return {DeltaBuilder<DeltaConfOverwrite<
-   *   DConf,
-   *   (DeltaConfGetChildren<OtherDeltaConf> extends never ? {} : { children: DeltaConfGetChildren<DConf> | DeltaConfGetChildren<OtherDeltaConf> })
+   * @return {DeltaBuilder<FixedConf extends true ? Conf : DeltaConfOverwrite<
+   *   Conf,
+   *   (DeltaConfGetChildren<OtherDeltaConf> extends never ? {} : { children: DeltaConfGetChildren<Conf> | DeltaConfGetChildren<OtherDeltaConf> })
    *   & (DeltaConfGetText<OtherDeltaConf> extends string ? { text: true } : never)
-   * >>}
+   * >, FixedConf>}
    */
   append (other) {
     const children = this.children
@@ -1894,8 +1892,8 @@ const updateOpFormat = (op, formatUpdate) => {
 }
 
 /**
- * @template {DeltaConf} DConf
- * @extends {s.Schema<Delta<DConf>>}
+ * @template {DeltaConf} Conf
+ * @extends {s.Schema<Delta<Conf>>}
  */
 export class $Delta extends s.Schema {
   /**
@@ -1915,11 +1913,11 @@ export class $Delta extends s.Schema {
     }
     /**
      * @type {{
-     *   $name: s.Schema<DeltaConfGetName<DConf>>,
-     *   $attrs: s.Schema<DeltaConfGetAttrs<DConf>>,
-     *   $children: s.Schema<DeltaConfGetChildren<DConf>>,
-     *   hasText: DeltaConfGetText<DConf>
-     *   recursiveChildren: DeltaConfGetRecursiveChildren<DConf>,
+     *   $name: s.Schema<DeltaConfGetName<Conf>>,
+     *   $attrs: s.Schema<DeltaConfGetAttrs<Conf>>,
+     *   $children: s.Schema<DeltaConfGetChildren<Conf>>,
+     *   hasText: DeltaConfGetText<Conf>
+     *   recursiveChildren: DeltaConfGetRecursiveChildren<Conf>,
      *   $formats: s.Schema<{[K:string]:any}>
      * }}
      */
@@ -1929,7 +1927,7 @@ export class $Delta extends s.Schema {
   /**
    * @param {any} o
    * @param {s.ValidationError} [err]
-   * @return {o is Delta<DConf>}
+   * @return {o is Delta<Conf>}
    */
   check (o, err = undefined) {
     const { $name, $attrs, $children, hasText, $formats } = this.shape
@@ -1962,13 +1960,11 @@ export class $Delta extends s.Schema {
  * @param {HasText} [opts.text] Whether this delta contains text using `textOp`
  * @param {Formats} [opts.formats]
  * @param {RecursiveChildren} [opts.recursiveChildren]
- * @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<{
- *   name: NodeName,
- *   attrs: Attrs,
- *   children: Children,
- *   text: HasText,
- *   recursiveChildren: RecursiveChildren
- * }>> : never}
+ * @return {[s.ReadSchemaUnwrapped<NodeNameSchema>,s.ReadSchemaUnwrapped<AttrsSchema>,s.ReadSchemaUnwrapped<ChildrenSchema>] extends [infer NodeName, infer Attrs, infer Children] ? s.Schema<Delta<PrettifyDeltaConf<(import('../ts.js').TypeIsAny<NodeName, {}, { name: NodeName }> &
+ *   ({} extends Attrs ? {} : { attrs: Attrs }) &
+ *   ([Children] extends [never] ? {} : { children: Children }) &
+ *   (HasText extends false ? {} : { text: HasText }) &
+ *   (RecursiveChildren extends false ? {} : { recursiveChildren: RecursiveChildren })) extends infer DC extends DeltaConf ? DC : never>>> : never}
  */
 export const $delta = ({ name, attrs, children, text, formats, recursiveChildren: recursive }) => /** @type {any} */ (new $Delta(
   /** @type {any} */ (name == null ? s.$any : s.$(name)),
@@ -1981,55 +1977,6 @@ export const $delta = ({ name, attrs, children, text, formats, recursiveChildren
 
 export const $$delta = /* @__PURE__ */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>]
- * @template {boolean} [HasText=false]
- * @template {boolean} [Recursive=false]
- * @param {object} opts
- * @param {NodeNameSchema?} [opts.name]
- * @param {AttrsSchema?} [opts.attrs]
- * @param {ChildrenSchema?} [opts.children]
- * @param {HasText} [opts.text]
- * @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, recursive }) => {
-  /**
-   * @type {s.Schema<Array<any>>}
-   */
-  let $arrContent = children == null ? s.$never : s.$array(s.$(children))
-  const $name = name == null ? s.$any : s.$(name)
-  const $attrsPartial = attrs == null ? s.$object({}) : (s.$$record.check(attrs) ? attrs : /** @type {any} */ (s.$(attrs)).partial)
-  const $d = s.$custom(d => {
-    if (
-      !$deltaAny.check(d) ||
-      !$name.check(d.name) ||
-      object.some(d.attrs,
-        (op, k) => $setAttrOp.check(op) && !$attrsPartial.check({ [k]: op.value })
-      )
-    ) return false
-    for (const op of d.children) {
-      if ((!text && $textOp.check(op)) || ($insertOp.check(op) && !$arrContent.check(op.insert))) {
-        return false
-      }
-    }
-    return true
-  })
-  if (recursive) {
-    $arrContent = children == null ? s.$array($d) : s.$array(s.$(children), $d)
-  }
-  return /** @type {any} */ ($d)
-}
-
 export const $deltaAny = /** @type {s.Schema<DeltaAny>} */ (/* @__PURE__ */s.$type('delta'))
 export const $deltaBuilderAny = /** @type {s.Schema<DeltaBuilderAny>} */ (/* @__PURE__ */s.$custom(o => $deltaAny.check(o) && !o.isDone))
 
@@ -2060,10 +2007,10 @@ export const mergeDeltas = (a, b) => {
 }
 
 /**
- * @template {DeltaConf} DConf
+ * @template {DeltaConf} Conf
  * @param {prng.PRNG} gen
- * @param {s.Schema<Delta<DConf>>} $d
- * @return {DeltaBuilder<DConf>}
+ * @param {s.Schema<Delta<Conf>>} $d
+ * @return {DeltaBuilder<Conf>}
  */
 export const random = (gen, $d) => {
   const { $name, $attrs, $children, hasText, $formats: $formats_ } = /** @type {$Delta<any>} */ (/** @type {any} */ ($d)).shape
@@ -2100,17 +2047,17 @@ export const random = (gen, $d) => {
  */
 /**
  * @template {string} NodeName
- * @template {s.Schema<DeltaAny>} Schema
+ * @template {DeltaConf} Conf
  * @overload
  * @param {NodeName} nodeName
- * @param {Schema} schema
- * @return {Schema extends s.Schema<Delta<infer DConf>> ? DeltaBuilder<DeltaConfOverwrite<DConf, {fixed:true}>> : never}
+ * @param {s.Schema<Delta<Conf>>} schema
+ * @return {DeltaBuilder<Conf, true>}
  */
 /**
  * @template {s.Schema<DeltaAny>} Schema
  * @overload
  * @param {Schema} schema
- * @return {Schema extends s.Schema<Delta<infer DConf>> ? DeltaBuilder<DeltaConfOverwrite<DConf, {fixed:true}>> : never}
+ * @return {Schema extends s.Schema<Delta<infer Conf>> ? DeltaBuilder<Conf, true> : never}
  */
 /**
  * @template {string|null} NodeName
@@ -2149,7 +2096,7 @@ export const create = (nodeNameOrSchema, attrsOrSchema, children) => {
  * @template {Array<any>|string} [Children=never]
  * @overload
  * @param {NodeName} nodeName
- * @param {...Array<Children>} [children]
+ * @param {...Array<Children>} children
  * @return {DeltaBuilder<{
  *   name: NodeName,
  *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
@@ -2159,7 +2106,7 @@ export const create = (nodeNameOrSchema, attrsOrSchema, children) => {
 /**
  * @template {Array<any>|string} [Children=never]
  * @overload
- * @param {...Array<Children>} [children]
+ * @param {...Array<Children>} children
  * @return {DeltaBuilder<{
  *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
  *   text: Extract<Children,string> extends never ? false : true
@@ -2170,7 +2117,7 @@ export const create = (nodeNameOrSchema, attrsOrSchema, children) => {
  * @template {Array<any>|string} [Children=never]
  * @overload
  * @param {Attrs} attrs
- * @param {...Array<Children>} [children]
+ * @param {...Array<Children>} children
  * @return {DeltaBuilder<{
  *   attrs: Attrs extends null ? {} : Attrs,
  *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
@@ -2184,7 +2131,7 @@ export const create = (nodeNameOrSchema, attrsOrSchema, children) => {
  * @overload
  * @param {NodeName} nodeName
  * @param {Attrs} attrs
- * @param {...Array<Children>} [children]
+ * @param {...Array<Children>} children
  * @return {DeltaBuilder<{
  *   name: NodeName,
  *   attrs: Attrs extends null ? {} : Attrs,
@@ -2210,10 +2157,10 @@ export const from = (...args) => {
 }
 
 /**
- * @template {DeltaConf} DConf
- * @param {Delta<DConf>} d1
- * @param {NoInfer<Delta<DConf>>} d2
- * @return {DeltaBuilder<DConf>}
+ * @template {DeltaConf} Conf
+ * @param {Delta<Conf>} d1
+ * @param {NoInfer<Delta<Conf>>} d2
+ * @return {DeltaBuilder<Conf>}
  */
 export const diff = (d1, d2) => {
   /**

package/src/environment.js

@@ -84,14 +84,13 @@ export const hasParam = (name) => computeParams().has(name)
  */
 /* c8 ignore next 2 */
 /* @__NO_SIDE_EFFECTS__ */
-export const getParam = (name, defaultVal) =>
-  computeParams().get(name) || defaultVal
+export const getParam = (name, defaultVal) => computeParams().get(name) || defaultVal
 
 /**
  * @param {string} name
  * @return {string|null}
  */
-/* c8 ignore next 4 */
+/* c8 ignore next 5 */
 /* @__NO_SIDE_EFFECTS__ */
 export const getVariable = (name) =>
   isNode