lib0 0.2.115-4 → 0.2.115-6

package/dist/t2.cjs

@@ -1,932 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var d2 = require('./d2.cjs');
-var schema = require('./schema.cjs');
-var error = require('./error-0c1f634f.cjs');
-require('./list.cjs');
-require('./function-e7d18feb.cjs');
-require('./array-78849c95.cjs');
-require('./set-5b47859e.cjs');
-require('./object-18980796.cjs');
-require('./traits.cjs');
-require('./math-96d5e8c4.cjs');
-require('./rabin.cjs');
-require('./buffer-7f6fa8fa.cjs');
-require('./string-fddc5f8b.cjs');
-require('./environment-90227ead.cjs');
-require('./map-24d263c0.cjs');
-require('./conditions-f5c0c102.cjs');
-require('./storage.cjs');
-require('./encoding-1a745c43.cjs');
-require('./number-1fb57bba.cjs');
-require('./binary-ac8e39e2.cjs');
-require('./decoding-76e75827.cjs');
-require('./patience.cjs');
-
-/* eslint-disable */
-
-/**
- * Creates a transformer template after receiving schema for DeltaA.
- *
- * @template {delta.DeltaAny} DeltaA
- * @typedef {<DA extends DeltaA> ($deltaA: s.Schema<DA>) => Template<any,DA,any>} TransformerFactory
- */
-
-/**
- * @template {TransformerFactory<any>} T
- * @template {delta.DeltaAny} DeltaA
- * @typedef {T extends (($deltaA: s.Schema<DeltaA>) => Template<any,DeltaA,infer DeltaB>) ? DeltaB : never } DeltaBFromTransformerFactory
- */
-
-/**
- * @template {delta.DeltaAny|null} [DeltaA=delta.DeltaAny|null]
- * @template {delta.DeltaAny|null} [DeltaB=delta.DeltaAny|null]
- * @typedef {{ a: DeltaA, b: DeltaB }} TransformResult
- */
-
-/**
- * @template {s.Unwrap<delta.$delta>|null} DeltaA
- * @template {s.Unwrap<delta.$delta>|null} DeltaB
- * @param {DeltaA} a
- * @param {DeltaB} b
- * @return {TransformResult<DeltaA,DeltaB>}
- */
-const transformResult = (a, b) => ({ a, b });
-const transformResultEmpty = transformResult(null, null);
-
-/**
- * @template {any} State
- * @template {delta.DeltaAny} DeltaA
- * @template {delta.DeltaAny} DeltaB
- * @typedef {object} TransformerDef
- * @property {s.Schema<DeltaA>} TransformerDef.$in
- * @property {s.Schema<DeltaB>} TransformerDef.$out
- * @property {function (this: Template<State,DeltaA,DeltaB>): State} TransformerDef.state
- * @property {(deltaIn:NoInfer<DeltaA>,s:NoInfer<State>) => TransformResult<NoInfer<DeltaA>?,NoInfer<DeltaB>?>} TransformerDef.applyA
- * @property {(deltaOut:NoInfer<DeltaB>,s:NoInfer<State>) => TransformResult<NoInfer<DeltaA>?,NoInfer<DeltaB>?>} TransformerDef.applyB
- */
-
-/**
- * A Delta Transformer ensures that it keeps two sources A and B in-sync, even if they use a
- * different update format.
- *
- * @template {any} State
- * @template {delta.DeltaAny} DeltaA
- * @template {delta.DeltaAny} DeltaB
- */
-class Transformer {
-  /**
-   * @param {Template<State,DeltaA,DeltaB>} t
-   * @param {State} s
-   */
-  constructor (t, s) {
-    this.t = t;
-    this._state = s;
-    /**
-     * Pending a op, for internal use only
-     * @type {DeltaA?}
-     */
-    this._pa = null;
-    /**
-     * Pending a op, for internal use only
-     * @type {DeltaB?}
-     */
-    this._pb = null;
-    /**
-     * Whether this transformer value has been initially consumebd by the parent transformer.
-     */
-    this._init = false;
-    /**
-     * @type {Transformer<any,any,any>?}
-     */
-    this.parent = null;
-  }
-
-  /**
-   * @param {DeltaA} deltaA
-   * @return {TransformResult<DeltaA?,DeltaB?>}
-   */
-  applyA (deltaA) {
-    return this.t._applyA(deltaA, this._state)
-  }
-
-  /**
-   * @param {DeltaB} deltaB
-   * @return {TransformResult<DeltaA?,DeltaB?>}
-   */
-  applyB (deltaB) {
-    return this.t._applyB(deltaB, this._state)
-  }
-}
-
-/**
- * @param {Array<Transformer<any,delta.DeltaAny,delta.DeltaAny>>} trs
- * @param {TransformResult} output
- * @return {boolean}
- */
-const _forwardPipe = (trs, output) => {
-  let again = false;
-  for (let i = 0; i < trs.length; i++) {
-    const tr = trs[i];
-    if (tr._pa === null) continue
-    const { a, b } = tr.applyA(tr._pa);
-    tr._pa = null;
-    if (a !== null) {
-      if (i === 0) {
-        output.a = d2.mergeDeltas(output.a, a);
-      } else {
-        // need to interate back to integrate the produced backwards-change
-        again = true;
-        trs[i - 1]._pb = a;
-      }
-    }
-    if (b !== null) {
-      if (i === trs.length - 1) {
-        output.b = d2.mergeDeltas(output.b, b);
-      } else {
-        trs[i + 1]._pa = b;
-      }
-    }
-  }
-  return again
-};
-
-/**
- * @param {Array<Transformer<any,delta.DeltaAny,delta.DeltaAny>>} trs
- * @param {TransformResult} output
- * @return {boolean}
- */
-const _backwardPipe = (trs, output) => {
-  let again = false;
-  for (let i = trs.length - 1; i >= 0; i--) {
-    const tr = trs[i];
-    if (tr._pb === null) continue
-    const { a, b } = tr.applyA(tr._pb);
-    tr._pb = null;
-    if (a !== null) {
-      if (i === 0) {
-        output.a = d2.mergeDeltas(output.a, a);
-      } else {
-        // need to interate back to integrate the produced backwards-change
-        trs[i - 1]._pb = a;
-      }
-    }
-    if (b !== null) {
-      if (i === trs.length - 1) {
-        output.b = d2.mergeDeltas(output.b, b);
-      } else {
-        // need to interate back to integrate the produced backwards-change
-        again = true;
-        trs[i + 1]._pa = a;
-      }
-    }
-  }
-  return again
-};
-
-/**
- * @template State
- * @template {delta.DeltaAny} DeltaA
- * @template {delta.DeltaAny} DeltaB
- */
-class Template {
-  /**
-   * @param {TransformerDef<State,DeltaA,DeltaB>} def
-   */
-  constructor ({ $in, $out, state, applyA, applyB }) {
-    /**
-     * @type {s.Schema<DeltaA>}
-     */
-    this.$in = $in;
-    /**
-     * @type {s.Schema<DeltaB>}
-     */
-    this.$out = $out;
-    /**
-     * @type {() => State}
-     */
-    this._state = state;
-    /**
-     * @type {typeof applyA}
-     */
-    this._applyA = applyA;
-    /**
-     * @type {typeof applyB}
-     */
-    this._applyB = applyB;
-    /**
-     * Cache for stateless transformers.
-     *
-     * @type {Transformer<State,DeltaA,DeltaB>?}
-     */
-    this._tr = null;
-  }
-
-  /**
-   * @template {delta.DeltaAny} R
-   * @param {($d: s.Schema<DeltaB>) => Template<any,DeltaB,R>} t
-   * @return {Template<any,DeltaA,R>}
-   */
-  pipe (t) {
-    /**
-     * @type {TransformerPipeTemplate<any,any>}
-     */
-    const tpipe = new TransformerPipeTemplate();
-    tpipe.templates.push(this, t(this.$out));
-    return tpipe
-  }
-
-  init () {
-    if (this._tr != null) return this._tr
-    // reuse stateless transformers
-    const s = this._state();
-    if (s === null) {
-      return (this._tr = new Transformer(this, s))
-    }
-    return new Transformer(this, s)
-  }
-}
-
-/**
- * @template {delta.DeltaAny} DeltaA
- * @template {delta.DeltaAny} DeltaB
- * @param {s.Schema<DeltaA>} $deltaA
- * @param {s.Schema<DeltaB>} $deltaB
- * @return {s.Schema<Template<any,DeltaA,DeltaB>>}
- */
-const $template = ($deltaA, $deltaB) => /** @type {s.Schema<Template<any,any,any>>} */ (schema.$instanceOf(Template, o => o.$in.extends($deltaA) && o.$out.extends($deltaB)));
-const $templateAny = /** @type {s.Schema<Template<any,any,any>>} */ (schema.$instanceOf(Template));
-
-/**
- * @template {delta.DeltaAny} DeltaA
- * @template {delta.DeltaAny} DeltaB
- * @typedef {Template<any,DeltaA,DeltaB>|(
- *     DeltaB extends delta.Map<infer MKV>
- *       ? (MKV|DeltaB)
- *       : (DeltaB extends delta.Array<infer MArr> ? (MArr|DeltaB) : DeltaB))
- * } MaybeFixedTemplate
- */
-
-/**
- * @template X
- * @typedef {X extends Template<any,any,infer D> ? (D extends delta.Value<infer V> ? V : D) : X} UnwrapTemplateForArray
- */
-
-/**
- * @template {any} MaybeFixed
- * @typedef {MaybeFixed extends Template<any,any,any>
- *   ? MaybeFixed
- *   : Template<any,any,
- *     MaybeFixed extends delta.AbstractDelta
- *       ? MaybeFixed
- *       : (MaybeFixed extends Array<any>
- *         ? delta.Array<UnwrapTemplateForArray<MaybeFixed[number]>>
- *         : (MaybeFixed extends {[key:string]:any} ? delta.Map<MaybeFixed> : never))
- *   >
- * } MaybeFixedTemplateToTemplate
- */
-
-/**
- * @template MaybeFixed
- * @param {MaybeFixed} maybeFixed
- * @return {MaybeFixed extends Template<any,any,delta.Delta> ? (Extract<MaybeFixed,Template<any,any,any>>) : Template<any,any,MaybeFixed extends delta.Delta ? Extract<MaybeFixed,delta.Delta> : delta.Array<MaybeFixed[keyof MaybeFixed]>>}
- */
-const maybeFixedToTemplate = maybeFixed => $templateAny.check(maybeFixed)
-  ? /** @type {any} */ (maybeFixed)
-  : (d2.$delta.check(maybeFixed)
-      ? /** @type {any} */ (fixed(maybeFixed))
-      : (schema.$arrayAny.check(maybeFixed)
-          ? /** @type {any} */ (fixed(d2.array().insert(maybeFixed).done()))
-          : (schema.$objectAny.check(maybeFixed) ? /** @type {any} */ (fixed(d2.map().setMany(maybeFixed).done())) : error.unexpectedCase())
-        )
-    );
-
-/**
- * @template {delta.AbstractDelta} DeltaA
- * @template {Template<any,DeltaA,any>} Tr
- * @param {s.Schema<DeltaA>} _$deltaA
- * @param {Tr} transformer
- * @return {<DA extends DeltaA>($d:s.Schema<DA>) => Tr extends Template<any,any,infer DeltaB> ? Template<any,DA,DeltaB> : never}
- */
-const transformStatic = (_$deltaA, transformer) => () => /** @type {any} */ (transformer);
-
-/**
- * @template {delta.AbstractDelta} DeltaA
- * @template {<DA extends DeltaA> ($deltaA: s.Schema<DA>) => Template<any,DA,any>} TF
- * @param {s.Schema<DeltaA>} _$deltaA
- * @param {TF} transformerFactory
- * @return {TF}
- */
-const transform = (_$deltaA, transformerFactory) => transformerFactory;
-
-/**
- * @type {TransformerDef<any,any,any>}
- */
-const pipeTemplateDef = {
-  $in: schema.$any,
-  $out: schema.$any,
-  state: function () { return /** @type {TransformerPipeTemplate<any,any>} */ (/** @type {unknown} */ (this)).templates.map(t => t.init()) },
-  applyA: (dchange, trs) => {
-    const output = transformResult(null, null);
-    let again = true;
-    trs[0]._pa = dchange;
-    while (again) {
-      // apply forwards
-      again = _forwardPipe(trs, output);
-      // iterate back
-      if (again) {
-        again = _backwardPipe(trs, output);
-      }
-    }
-    return output
-  },
-  applyB: (dchange, trs) => {
-    const output = transformResult(null, null);
-    let again = true;
-    trs[trs.length - 1]._pb = dchange;
-    while (again) {
-      // iterate back
-      again = _backwardPipe(trs, output);
-      // apply forwards
-      if (again) {
-        again = _forwardPipe(trs, output);
-      }
-    }
-    return output
-  }
-};
-
-/**
- * @todo just have something like "previousTemplate" to implement pipe. This can be assembled when
- * init the template.
- * @template {s.Unwrap<typeof delta.$delta>} DeltaA
- * @template {s.Unwrap<typeof delta.$delta>} DeltaB
- * @extends {Template<any,DeltaA,DeltaB>}
- */
-class TransformerPipeTemplate extends Template {
-  constructor () {
-    super(pipeTemplateDef);
-    /**
-     * @type {Array<Template<any,DeltaA,DeltaB>>}
-     */
-    this.templates = [];
-  }
-
-  /**
-   * @template {delta.AbstractDelta} R
-   * @param {($d: s.Schema<DeltaB>) => Template<any,DeltaB,R>} t
-   * @return {Template<any,DeltaA,R>}
-   */
-  pipe (t) {
-    /**
-     * @type {TransformerPipeTemplate<any,any>}
-     */
-    const tpipe = new TransformerPipeTemplate();
-    tpipe.templates = this.templates.slice();
-    tpipe.templates.push(t(this.$out));
-    return /** @type {any} */ (tpipe)
-  }
-}
-
-/**
- * @template {delta.AbstractDelta} DeltaA
- * @template {delta.AbstractDelta} DeltaB
- * @template {delta.AbstractDelta} DeltaC
- * @param {($s: s.Schema<DeltaA>) => Template<any,DeltaA,DeltaB>} t1
- * @param {($s: s.Schema<DeltaB>) => Template<any,DeltaB,DeltaC>} t2
- * @return {($d: s.Schema<DeltaA>) => Template<any,DeltaA,DeltaC>}
- */
-const pipe = (t1, t2) => ($d) => {
-  /**
-   * @type {TransformerPipeTemplate<any,any>}
-   */
-  const tpipe = new TransformerPipeTemplate();
-  const t1t = t1($d);
-  tpipe.templates.push(t1t, t2(t1t.$out));
-  return tpipe
-};
-
-/**
- * @template {any} State
- * @template {s.Unwrap<typeof delta.$delta>} DeltaIn
- * @template {s.Unwrap<typeof delta.$delta>} DeltaOut
- * @param {TransformerDef<State,DeltaIn,DeltaOut>} def
- * @return {Template<State,DeltaIn,DeltaOut>}
- */
-const template = def => new Template(/** @type {any} */ (def));
-
-/**
- * @template FixedContent
- * @param {FixedContent} fixedContent
- * @return {Template<any,any,FixedContent extends delta.AbstractDelta ? FixedContent : delta.Value<FixedContent>>}
- */
-const fixed = fixedContent => {
-  const staticDelta = d2.$delta.check(fixedContent) ? fixedContent : undefined().set(fixedContent).done();
-  return template({
-    $in: schema.$any,
-    $out: schema.$any,
-    state: () => ({ e: false }),
-    applyA: (_d, s) => {
-      if (!s.e) {
-        s.e = true;
-        return transformResult(null, staticDelta)
-      }
-      return transformResultEmpty
-    },
-    applyB: () => {
-      // @todo should reverse the change and give back
-      error.unexpectedCase();
-    }
-  })
-};
-
-/**
- * @template MaybeTemplate
- * @typedef {[MaybeTemplate] extends [Template<any,any,any>] ? MaybeTemplate : Template<any,any,
- *   [MaybeTemplate] extends [delta.AbstractDelta] ? MaybeTemplate : delta.Value<MaybeTemplate>
- * >} AnyToTemplate
- */
-
-/**
- * @template {{ [key: string]: any }} MaybeTemplateMap
- * @typedef {{ [K in keyof MaybeTemplateMap]: AnyToTemplate<MaybeTemplateMap[K]> }} AnyMapToTemplate
- */
-
-/**
- * @template {Array<any>} MaybeTemplateArray
- * @typedef {{ [K in keyof MaybeTemplateArray]: AnyToTemplate<MaybeTemplateArray[K]> }} AnyArrayToTemplate
- */
-
-/**
- * @template {{ [key:string]: any }} T
- * @typedef {Template<
- *   any,
- *   AnyMapToTemplate<T>[keyof T] extends Template<any, infer DeltaA,any> ? DeltaA : never,
- *   delta.Map<{ [K in keyof T]: AnyToTemplate<T[K]> extends Template<any, any, infer DeltaB>
- *     ? (DeltaB extends delta.Value<infer V> ? V : DeltaB) : AnyToTemplate<T[K]> }>
- *  >} MapDefToTemplate
- */
-
-/**
- * @template {{ [key:string]: any }} T
- * @param {T} definition
- * @return {MapDefToTemplate<T> extends Template<any,infer A,infer B> ? Template<any,A,B> : never}
- */
-const map = (definition) => {
-  /**
-   * @type {{ [key:string]: Template<any,any,any> }}
-   */
-  const def = {};
-  for (const key in definition) {
-    const d = definition[key];
-    def[key] = $templateAny.check(d) ? d : fixed(d);
-  }
-  return template({
-    $in: schema.$any,
-    $out: schema.$any,
-    state: () => {
-      const mapState = /** @type {{ [key: string]: Transformer<any,any,any> }} */ ({});
-      for (const key in def) {
-        mapState[key] = def[key].init();
-      }
-      return /** @type {{ [key in keyof T]: T extends Template<any,infer SDIn, infer SDOut> ? Transformer<any, SDIn, SDOut>: never }} */ (mapState)
-    },
-    applyA: (d, state) => {
-      return _applyMapOpHelper(state, [{ d, src: null }])
-    },
-    applyB: (d, state) => {
-      schema.assert(d, undefined);
-      /**
-       * @type {Array<{ d: delta.AbstractDelta, src: Transformer<any,any,any>? }>}
-       */
-      const reverseAChanges = [];
-      d.forEach(op => {
-        if (d2.$deleteOp.check(op)) {
-          error.unexpectedCase();
-        }
-        const src = state[op.key];
-        // src expects a delta value
-        const res = src.applyB(d2.$modifyOp.check(op) ? undefined().modify(op.value) : undefined().set(op.value));
-        src._pa = res.a;
-        src._pb = res.b;
-        if (res.a != null) {
-          reverseAChanges.push({ d: res.a, src });
-        }
-      });
-      return _applyMapOpHelper(state, reverseAChanges)
-    }
-  })
-};
-
-/**
- * @param {{ [key: string]: Transformer<any, any, any> }} state
- * @param {Array<{ d: delta.AbstractDelta, src: Transformer<any,any,any>? }>} reverseAChanges
- * @return {TransformResult<delta.AbstractDelta?,delta.Map<any>?>}
- */
-const _applyMapOpHelper = (state, reverseAChanges) => {
-  /**
-     * @type {TransformResult<delta.AbstractDelta?,delta.Map<any>?>}
-     */
-  const applyResult = transformResult(null, null);
-  while (reverseAChanges.length > 0) {
-    /**
-     * @type {Array<{ d: delta.AbstractDelta, src: Transformer<any,any,any>? }>}
-     */
-    let nextReverseAChanges = [];
-    for (const key in state) {
-      const s = state[key];
-      let transformPriority = false; // false until own is found
-      for (let i = 0; i < reverseAChanges.length; i++) {
-        // changes are applied in reverseAChanges order.
-        // rebase against all concurrent (the op stored on transformer), then apply
-        const r = reverseAChanges[i];
-        if (r.src === s) {
-          transformPriority = true; // own has less priority, concurrent is applied with higher prio
-          continue // don't apply own
-        }
-        let rd = r.d;
-        if (s._pa != null) {
-          rd = rd.clone();
-          rd.rebase(s._pa, transformPriority);
-        }
-        const res = s.applyA(rd);
-        s._pa = res.a;
-        s._pb = d2.mergeDeltas(s._pb, res.b);
-        if (res.a != null) {
-          nextReverseAChanges.push({ d: res.a, src: s });
-        }
-      }
-    }
-    // merge changes for output
-    for (let i = 0; i < reverseAChanges.length; i++) {
-      const rc = reverseAChanges[i];
-      if (rc.src != null) { // don't apply received deltas
-        applyResult.a = d2.mergeDeltas(applyResult.a, rc.d);
-      }
-    }
-    reverseAChanges = nextReverseAChanges;
-    nextReverseAChanges = [];
-  }
-  // accumulate b changes stored on transformers
-  const bRes = d2.map();
-  for (const key in state) {
-    const s = state[key];
-    if (s._pb) {
-      if (s._init) {
-        bRes.modify(key, s._pb);
-      } else {
-        s._init = true;
-        bRes.set(key, s._pb);
-      }
-    }
-  }
-  if (bRes._changes.size > 0) {
-    // opt values (iff delta is of type DeltaValue, map the change to the map)
-    bRes._changes.forEach((change, key) => {
-      if (undefined(change.value)) {
-        const changeOp = change.value.change;
-        if (d2.$insertOp.check(changeOp) || d2.$modifyOp.check(changeOp)) {
-          bRes.set(key, changeOp.value);
-        } else if (d2.$deleteOp.check(changeOp)) {
-          bRes.delete(key);
-        } else {
-          error.unexpectedCase();
-        }
-      }
-    });
-    applyResult.b = bRes;
-  }
-  return applyResult
-};
-
-/**
- * @todo This is similar to dt.map. Consider the similarities and try to merge them.
- *
- * @template {Array<any>} T
- * @param {T} definition
- * @return {Template<
- *   any,
- *   AnyArrayToTemplate<T>[number] extends Template<any, infer DeltaA, any> ? DeltaA : never,
- *   delta.Array<AnyArrayToTemplate<T>[number] extends Template<any, any, infer DeltaB> ? delta.ValueUnwrap<DeltaB> : never>
- * >}
- */
-const array = (definition) => {
-  /**
-   * @type {Array<Template<any,any,any>>}
-   */
-  const def = [];
-  for (let i = 0; i < definition.length; i++) {
-    const d = definition[i];
-    def[i] = $templateAny.check(d) ? d : fixed(d);
-  }
-  return /** @type {any} */ (template({
-    $in: schema.$any,
-    $out: undefined,
-    state: () => {
-      const arrState = /** @type {Transformer<any,any,any>[]} */ ([]);
-      for (let i = 0; i < def.length; i++) {
-        arrState[i] = def[i].init();
-      }
-      return /** @type {(T extends Template<any,infer SDIn, infer SDOut> ? Transformer<any, SDIn, SDOut>: never)[]} */ (arrState)
-    },
-    applyA: (d, state) => {
-      return _applyArrayOpHelper(state, [{ d, src: null }])
-    },
-    applyB: (d, state) => {
-      schema.assert(d, undefined);
-      /**
-       * @type {Array<{ d: delta.AbstractDelta, src: Transformer<any,any,any>? }>}
-       */
-      const reverseAChanges = [];
-      d.forEach((op, index) => {
-        if (d2.$deleteOp.check(op) || d2.$insertOp.check(op)) {
-          error.unexpectedCase();
-        } else if (d2.$modifyOp.check(op)) {
-          const src = state[index];
-          const res = src.applyB(op.modify);
-          src._pa = res.a;
-          src._pb = res.b;
-          if (res.a != null) {
-            reverseAChanges.push({ d: res.a, src });
-          }
-        }
-      });
-      return _applyArrayOpHelper(state, reverseAChanges)
-    }
-  }))
-};
-
-/**
- * @param {Transformer<any, any, any>[]} state
- * @param {Array<{ d: delta.AbstractDelta, src: Transformer<any,any,any>? }>} reverseAChanges
- * @return {TransformResult<delta.AbstractDelta?,delta.Array<any>?>}
- */
-const _applyArrayOpHelper = (state, reverseAChanges) => {
-  /**
-     * @type {TransformResult<delta.AbstractDelta?,delta.Array<any>?>}
-     */
-  const applyResult = transformResult(null, null);
-  while (reverseAChanges.length > 0) {
-    /**
-     * @type {Array<{ d: delta.AbstractDelta, src: Transformer<any,any,any>? }>}
-     */
-    let nextReverseAChanges = [];
-    for (let i = 0; i < state.length; i++) {
-      const s = state[i];
-      let transformPriority = false; // false until own is found
-      for (let i = 0; i < reverseAChanges.length; i++) {
-        // changes are applied in reverseAChanges order.
-        // rebase against all concurrent (the op stored on transformer), then apply
-        const r = reverseAChanges[i];
-        if (r.src === s) {
-          transformPriority = true; // own has less priority, concurrent is applied with higher prio
-          continue // don't apply own
-        }
-        let rd = r.d;
-        if (s._pa != null) {
-          rd = rd.clone();
-          rd.rebase(s._pa, transformPriority);
-        }
-        const res = s.applyA(rd);
-        s._pa = res.a;
-        s._pb = d2.mergeDeltas(s._pb, res.b);
-        if (res.a != null) {
-          nextReverseAChanges.push({ d: res.a, src: s });
-        }
-      }
-    }
-    // merge changes for output
-    for (let i = 0; i < nextReverseAChanges.length; i++) {
-      applyResult.a = d2.mergeDeltas(applyResult.a, nextReverseAChanges[i].d);
-    }
-    reverseAChanges = nextReverseAChanges;
-    nextReverseAChanges = [];
-  }
-  // accumulate b changes stored on transformers
-  const bRes = d2.array();
-  let performedChange = false;
-  for (let i = 0; i < state.length; i++) {
-    const s = state[i];
-    let spb = s._pb;
-    if (spb) {
-      if (undefined(spb)) {
-        spb = spb.get();
-      }
-      if (s._init) {
-        bRes.modify(spb);
-      } else {
-        s._init = true;
-        bRes.insert([spb]);
-      }
-      performedChange = true;
-    } else {
-      bRes.retain(1);
-    }
-  }
-  if (performedChange) {
-    applyResult.b = bRes.done();
-  }
-  return applyResult
-};
-
-/**
- * @param {TransformResult<delta.AbstractDelta?, delta.Node<any,any,any>>} res
- * @param {{ attrs: Transformer<any,any,any>, children: Transformer<any,any,any> }} state
- * @param {delta.AbstractDelta?} nextAAttrs apply this in reverse!
- * @param {delta.AbstractDelta?} nextAChildren
- */
-const _nodeApplyA = (res, state, nextAAttrs, nextAChildren) => {
-  while (nextAAttrs != null || nextAChildren != null) {
-    const resChildren = nextAChildren && state.children.applyA(nextAChildren);
-    const resAttrs = (nextAAttrs || resChildren?.a) ? state.attrs.applyA(d2.mergeDeltas(nextAAttrs, resChildren?.a)) : null;
-    nextAChildren = resAttrs?.a;
-    nextAAttrs = null;
-    res.a = d2.mergeDeltas(d2.mergeDeltas(res.a, resChildren?.a), resAttrs?.a);
-    resChildren?.b && res.b.children.apply(resChildren.b);
-    resAttrs?.b && res.b.attributes.apply(resAttrs.b);
-  }
-};
-
-/**
- * @template {{ [key:string]: any } | Template<any,any,delta.Map<any>>} T
- * @typedef {T extends Template<any,any,any> ? T : MapDefToTemplate<T>} MapOrMapDefToTemplate
- */
-
-/**
- * @template {string} NodeName
- * @template {{ [key:string]:any } | Template<any,any,delta.Map<{[key:string]:any}>>} Attrs - accepts map or map definition
- * @template {Template<any,any,delta.Array<any,any>> | Array<any>} Children
- * @param {NodeName} name
- * @param {Attrs} attributes
- * @param {Children} children
- * @return {Template<
- *   any,
- *   MapOrMapDefToTemplate<Attrs> extends Template<any, infer A, any> ? A : never,
- *   delta.Node<
- *     NodeName,
- *     MapOrMapDefToTemplate<Attrs> extends Template<any,any,delta.Map<infer M>> ? M : never,
- *     MaybeFixedTemplateToTemplate<Children> extends Template<any,any,delta.Array<infer BChildren,any>> ? BChildren : never,
- *     any
- *   >
- * >}
- */
-const node = (name, attributes, children) => {
-  const attrs = /** @type {Template<any,any,delta.Map<any>>} */ ($templateAny.check(attributes) ? attributes : map(attributes));
-  const childs = /** @type {Template<any,any,delta.Array<any>>} */ (maybeFixedToTemplate(children));
-  // @todo this should be properly inferred
-  return /** @type {any} */ (template({
-    $in: schema.$any,
-    $out: undefined(schema.$literal(name), schema.$any, schema.$any),
-    state: () => ({
-      attrs: attrs.init(),
-      children: childs.init()
-    }),
-    applyA: (d, state) => {
-      const res = transformResult(null, /** @type {delta.Node<NodeName,any,any,any>} */ (undefined(name)));
-      _nodeApplyA(res, state, d, d);
-      return res
-    },
-    applyB: (d, state) => {
-      schema.assert(d, undefined);
-      const res = transformResult(null, /** @type {delta.Node<NodeName,any,any,any>} */ (undefined(name)));
-      const childrenRes = d.children.ops.length === 0 ? transformResultEmpty : state.children.applyB(/** @type {delta.Array<any,any>} */(d.children));
-      const attrsRes = d.attributes._changes.size === 0 ? transformResultEmpty : state.attrs.applyB(d.attributes);
-      attrsRes.b && res.b.attributes.apply(attrsRes.b);
-      childrenRes.b && res.b.children.apply(/** @type {delta.Array<any,false>} */ (childrenRes.b));
-      res.a = d2.mergeDeltas(attrsRes.a, childrenRes.a);
-      _nodeApplyA(res, state, childrenRes.a, attrsRes.a);
-      return res
-    }
-  }))
-};
-
-/**
- * @template {{[k:string]:any}} KV
- * @typedef {delta.Map<KV> | delta.Node<any,KV,any,any>} _FollowPath
- */
-
-/**
- * @template {any} D
- * @template {string[]} Path
- * @typedef {Path extends []
- *   ? D
- *   : Path extends [infer P, ...infer PRest]
- *     ? (
- *       P extends string ? (D extends _AttrDeltaType<{ [K in P]: infer V }> ? QueryFollowPath<V,PRest extends string[] ? PRest : never> : never) : never
- *     )
- *     : never
- * } QueryFollowPath
- */
-
-/**
- * @template {{[k:string]:any}} Attrs
- * @typedef {delta.Map<Partial<Attrs>> | delta.Node<any,Partial<Attrs>,any,any>} _AttrDeltaType
- */
-
-/**
- * @template {Array<string>} Path
- * @typedef {Path extends [infer P, ...infer PRest] ? (_AttrDeltaType<{ [K in (P extends string ? P : any)]: PathToDelta<PRest extends Array<string> ? PRest : any> }>) : any} PathToDelta
- */
-
-/**
- * @template {Array<string>} Path
- * @param {Path} path
- * @return {<DA extends PathToDelta<Path>>($in: s.Schema<DA>) => Template<any, DA, delta.Value<QueryFollowPath<DA,Path>>>}
- */
-const query = (...path) => transformStatic(schema.$any, template({
-  $in: d2.$delta,
-  $out: undefined,
-  state: () => null,
-  applyA: d => {
-    d = undefined(d) ? d.attributes : d;
-    let cd = /** @type {delta.Map<any>?} */ (undefined(d));
-    let overwritten = false;
-    for (let i = 0; i < path.length && cd != null; i++) {
-      if (undefined(cd)) {
-        const c = cd.get(path[i]);
-        if (d2.$insertOp.check(c)) {
-          overwritten = true;
-          cd = c.value;
-        } else if (d2.$deleteOp.check(c)) {
-          overwritten = true;
-          cd = null;
-          break
-        } else if (d2.$modifyOp.check(c)) {
-          cd = c.value;
-        }
-      } else {
-        cd = null;
-      }
-    }
-    const dv = undefined();
-    if (overwritten) {
-      // @todo implement some kind of "ValueDelta" with insert, delete, modify ops. dmap is supposed
-      // to automatically translate this.
-      if (cd == null) {
-        dv.delete();
-      } else {
-        dv.set(cd);
-      }
-    } else {
-      dv.modify(cd);
-    }
-    return transformResult(null, dv)
-  },
-  applyB: (d) => {
-    const dop = d.change;
-    let resD = d2.map();
-    let i = path.length - 1;
-    const p = path[i];
-    if (d2.$modifyOp.check(dop)) {
-      resD.modify(p, dop.value);
-    } else if (d2.$insertOp.check(dop)) {
-      resD.set(p, dop.value);
-    } else if (d2.$deleteOp.check(dop)) {
-      resD.delete(p);
-    }
-    for (i--; i >= 0; i--) {
-      const tmpDmap = d2.map();
-      tmpDmap.modify(p, resD);
-      resD = tmpDmap;
-    }
-    return /** @type {TransformResult<any,null>} */ (transformResult(resD, null))
-  }
-}));
-
-/**
- * @template {delta.AbstractDelta} Delta
- * @param {s.Schema<Delta>} $in
- * @return {Template<null,Delta,Delta>}
- */
-const id = $in => template({
-  $in,
-  $out: $in,
-  state: () => null,
-  applyA: d => {
-    return transformResult(null, d)
-  },
-  applyB: d => {
-    return transformResult(d, null)
-  }
-});
-
-exports.$template = $template;
-exports.$templateAny = $templateAny;
-exports.Template = Template;
-exports.Transformer = Transformer;
-exports.array = array;
-exports.fixed = fixed;
-exports.id = id;
-exports.map = map;
-exports.maybeFixedToTemplate = maybeFixedToTemplate;
-exports.node = node;
-exports.pipe = pipe;
-exports.query = query;
-exports.template = template;
-exports.transform = transform;
-exports.transformResult = transformResult;
-exports.transformResultEmpty = transformResultEmpty;
-exports.transformStatic = transformStatic;
-//# sourceMappingURL=t2.cjs.map