lib0 0.2.112 → 0.2.115-0

package/dist/transformer.cjs

@@ -0,0 +1,930 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var error = require('./error-0c1f634f.cjs');
+var ops = require('./ops.cjs');
+var abstract = require('./abstract.cjs');
+var array$1 = require('./array.cjs');
+var node$1 = require('./node.cjs');
+var map$1 = require('./map.cjs');
+require('./text.cjs');
+var value = require('./value.cjs');
+var schema = require('./schema.cjs');
+require('./object-18980796.cjs');
+require('./traits.cjs');
+require('./function-e7d18feb.cjs');
+require('./array-78849c95.cjs');
+require('./set-5b47859e.cjs');
+require('./list.cjs');
+require('./environment-90227ead.cjs');
+require('./map-24d263c0.cjs');
+require('./string-fddc5f8b.cjs');
+require('./conditions-f5c0c102.cjs');
+require('./storage.cjs');
+require('./abstract-array.cjs');
+require('./math-96d5e8c4.cjs');
+
+/**
+ * Creates a transformer template after receiving schema for DeltaA.
+ *
+ * @template {delta.AbstractDelta} DeltaA
+ * @typedef {<DA extends DeltaA> ($deltaA: s.Schema<DA>) => Template<any,DA,any>} TransformerFactory
+ */
+
+/**
+ * @template {TransformerFactory<any>} T
+ * @template {delta.AbstractDelta} DeltaA
+ * @typedef {T extends (($deltaA: s.Schema<DeltaA>) => Template<any,DeltaA,infer DeltaB>) ? DeltaB : never } DeltaBFromTransformerFactory
+ */
+
+/**
+ * @template {s.Unwrap<delta.$delta>|null} [DeltaA=s.Unwrap<delta.$delta>|null]
+ * @template {s.Unwrap<delta.$delta>|null} [DeltaB=s.Unwrap<delta.$delta>|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 {s.Unwrap<delta.$delta>} DeltaA
+ * @template {s.Unwrap<delta.$delta>} 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 {s.Unwrap<typeof delta.$delta>} DeltaA
+ * @template {s.Unwrap<typeof delta.$delta>} 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.AbstractDelta,delta.AbstractDelta>>} 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 = abstract.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 = abstract.mergeDeltas(output.b, b);
+      } else {
+        trs[i + 1]._pa = b;
+      }
+    }
+  }
+  return again
+};
+
+/**
+ * @param {Array<Transformer<any,delta.AbstractDelta,delta.AbstractDelta>>} 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 = abstract.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 = abstract.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 {s.Unwrap<typeof delta.$delta>} DeltaA
+ * @template {s.Unwrap<typeof delta.$delta>} 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.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.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.AbstractDelta} DeltaA
+ * @template {delta.AbstractDelta} 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.AbstractDelta} DeltaA
+ * @template {delta.AbstractDelta} 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)
+  : (abstract.$delta.check(maybeFixed)
+      ? /** @type {any} */ (fixed(maybeFixed))
+      : (schema.$arrayAny.check(maybeFixed)
+          ? /** @type {any} */ (fixed(array$1.array().insert(maybeFixed).done()))
+          : (schema.$objectAny.check(maybeFixed) ? /** @type {any} */ (fixed(map$1.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 = abstract.$delta.check(fixedContent) ? fixedContent : value.value().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, map$1.$mapAny);
+      /**
+       * @type {Array<{ d: delta.AbstractDelta, src: Transformer<any,any,any>? }>}
+       */
+      const reverseAChanges = [];
+      d.forEach(op => {
+        if (ops.$deleteOp.check(op)) {
+          error.unexpectedCase();
+        }
+        const src = state[op.key];
+        // src expects a delta value
+        const res = src.applyB(ops.$modifyOp.check(op) ? value.value().modify(op.value) : value.value().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 = abstract.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 = abstract.mergeDeltas(applyResult.a, rc.d);
+      }
+    }
+    reverseAChanges = nextReverseAChanges;
+    nextReverseAChanges = [];
+  }
+  // accumulate b changes stored on transformers
+  const bRes = map$1.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 (value.$valueAny.check(change.value)) {
+        const changeOp = change.value.change;
+        if (ops.$insertOp.check(changeOp) || ops.$modifyOp.check(changeOp)) {
+          bRes.set(key, changeOp.value);
+        } else if (ops.$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: array$1.$arrayAny,
+    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, array$1.$arrayAny);
+      /**
+       * @type {Array<{ d: delta.AbstractDelta, src: Transformer<any,any,any>? }>}
+       */
+      const reverseAChanges = [];
+      d.forEach((op, index) => {
+        if (ops.$deleteOp.check(op) || ops.$insertOp.check(op)) {
+          error.unexpectedCase();
+        } else if (ops.$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 = abstract.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 = abstract.mergeDeltas(applyResult.a, nextReverseAChanges[i].d);
+    }
+    reverseAChanges = nextReverseAChanges;
+    nextReverseAChanges = [];
+  }
+  // accumulate b changes stored on transformers
+  const bRes = array$1.array();
+  let performedChange = false;
+  for (let i = 0; i < state.length; i++) {
+    const s = state[i];
+    let spb = s._pb;
+    if (spb) {
+      if (value.$valueAny.check(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(abstract.mergeDeltas(nextAAttrs, resChildren?.a)) : null;
+    nextAChildren = resAttrs?.a;
+    nextAAttrs = null;
+    res.a = abstract.mergeDeltas(abstract.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: node$1.$node(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>} */ (node$1.node(name)));
+      _nodeApplyA(res, state, d, d);
+      return res
+    },
+    applyB: (d, state) => {
+      schema.assert(d, node$1.$nodeAny);
+      const res = transformResult(null, /** @type {delta.Node<NodeName,any,any,any>} */ (node$1.node(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 = abstract.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: abstract.$delta,
+  $out: value.$valueAny,
+  state: () => null,
+  applyA: d => {
+    d = node$1.$nodeAny.check(d) ? d.attributes : d;
+    let cd = /** @type {delta.Map<any>?} */ (map$1.$mapAny.cast(d));
+    let overwritten = false;
+    for (let i = 0; i < path.length && cd != null; i++) {
+      if (map$1.$mapAny.check(cd)) {
+        const c = cd.get(path[i]);
+        if (ops.$insertOp.check(c)) {
+          overwritten = true;
+          cd = c.value;
+        } else if (ops.$deleteOp.check(c)) {
+          overwritten = true;
+          cd = null;
+          break
+        } else if (ops.$modifyOp.check(c)) {
+          cd = c.value;
+        }
+      } else {
+        cd = null;
+      }
+    }
+    const dv = value.value();
+    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 = map$1.map();
+    let i = path.length - 1;
+    const p = path[i];
+    if (ops.$modifyOp.check(dop)) {
+      resD.modify(p, dop.value);
+    } else if (ops.$insertOp.check(dop)) {
+      resD.set(p, dop.value);
+    } else if (ops.$deleteOp.check(dop)) {
+      resD.delete(p);
+    }
+    for (i--; i >= 0; i--) {
+      const tmpDmap = map$1.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=transformer.cjs.map