implemented frontend including separate message system; started to implement backend

yjs-poll/node_modules/lib0/delta/binding.d.ts

@@ -0,0 +1,107 @@
+/**
+ * @template T
+ * @typedef {import('../schema.js').Schema<T>} Schema
+ */
+/**
+ * @template {delta.AbstractDelta} DeltaA
+ * @template {delta.AbstractDelta} DeltaB
+ */
+export class Binding<DeltaA extends delta.AbstractDelta, DeltaB extends delta.AbstractDelta> {
+    /**
+     * @param {RDT<DeltaA>} a
+     * @param {RDT<DeltaB>} b
+     * @param {dt.Template<any,DeltaA,DeltaB>} template
+     */
+    constructor(a: RDT<DeltaA>, b: RDT<DeltaB>, template: dt.Template<any, DeltaA, DeltaB>);
+    /**
+     * @type {dt.Transformer<any,DeltaA,DeltaB>}
+     */
+    t: dt.Transformer<any, DeltaA, DeltaB>;
+    a: RDT<DeltaA>;
+    b: RDT<DeltaB>;
+    _mux: mux.mutex;
+    _achanged: (delta: DeltaA) => void;
+    _bchanged: (delta: DeltaB) => void;
+    destroy: () => void;
+}
+export function bind<DeltaA extends delta.AbstractDelta, Transformer extends dt.Template<any, DeltaA, any>>(a: RDT<DeltaA>, b: RDT<Transformer extends dt.Template<any, DeltaA, infer DeltaB> ? DeltaB : never>, template: dt.Template<any, DeltaA, any>): Binding<DeltaA, Transformer extends dt.Template<any, DeltaA, infer DeltaB> ? DeltaB : never>;
+export function deltaRDT<Delta extends delta.AbstractDelta>($delta: Schema<Delta>): DeltaRDT<Delta>;
+export const $domDelta: any;
+export function domRDT(dom: Element): DomRDT<delta.RecursiveNode<string, {
+    [key: string]: string;
+}, never, true>>;
+export type Schema<T> = import("../schema.js").Schema<T>;
+/**
+ * Abstract Interface for a delta-based Replicated Data Type.
+ */
+export type RDT<Delta extends delta.AbstractDelta> = ObservableV2<{
+    "change": (delta: Delta) => void;
+    "destroy": (rdt: RDT<Delta>) => void;
+}> & {
+    update: (delta: Delta) => any;
+    destroy: () => void;
+};
+export type DomDelta = delta.RecursiveNode<string, {
+    [key: string]: string;
+}, never, true>;
+import * as delta from './delta.js';
+import * as dt from './t3.test.js';
+import * as mux from '../mutex.js';
+/**
+ * @template {delta.AbstractDelta} Delta
+ * @implements RDT<Delta>
+ * @extends {ObservableV2<{ change: (delta: Delta) => void, 'destroy': (rdt:DeltaRDT<Delta>)=>void }>}
+ */
+declare class DeltaRDT<Delta extends delta.AbstractDelta> extends ObservableV2<{
+    change: (delta: Delta) => void;
+    destroy: (rdt: DeltaRDT<Delta>) => void;
+}> implements RDT<Delta> {
+    /**
+     * @param {Schema<Delta>} $delta
+     */
+    constructor($delta: Schema<Delta>);
+    $delta: s.Schema<Delta>;
+    /**
+     * @type {Delta?}
+     */
+    state: Delta | null;
+    _mux: mux.mutex;
+    /**
+     * @param {Delta} delta
+     */
+    update: (delta: Delta) => any;
+}
+/**
+ * @typedef {delta.RecursiveNode<string, { [key:string]: string }, never, true>} DomDelta
+ */
+/**
+ * @template {DomDelta} [D=DomDelta]
+ * @implements RDT<D>
+ * @extends {ObservableV2<{ change: (delta: D)=>void, destroy: (rdt:DomRDT<D>)=>void }>}>}
+ */
+declare class DomRDT<D extends DomDelta = delta.RecursiveNode<string, {
+    [key: string]: string;
+}, never, true>> extends ObservableV2<{
+    change: (delta: D) => void;
+    destroy: (rdt: DomRDT<D>) => void;
+}> implements RDT<D> {
+    /**
+     * @param {Element} observedNode
+     */
+    constructor(observedNode: Element);
+    observedNode: Element;
+    _mux: mux.mutex;
+    observer: MutationObserver;
+    /**
+     * @param {MutationRecord[]} mutations
+     */
+    _mutationHandler: (mutations: MutationRecord[]) => any;
+    /**
+     * @param {D} delta
+     */
+    update: (delta: D) => void;
+}
+import { ObservableV2 } from '../observable.js';
+import * as s from '../schema.js';
+export {};
+//# sourceMappingURL=binding.d.ts.map

yjs-poll/node_modules/lib0/delta/binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding.d.ts","sourceRoot":"","sources":["binding.js"],"names":[],"mappings":"AAeA;;;GAGG;AAEH;;;GAGG;AACH,qBAHmC,MAAM,SAA3B,KAAK,CAAC,aAAc,EACC,MAAM,SAA3B,KAAK,CAAC,aAAc;IAGhC;;;;OAIG;IACH,eAJW,GAAG,CAAC,MAAM,CAAC,KACX,GAAG,CAAC,MAAM,CAAC,YACX,EAAE,CAAC,QAAQ,CAAC,GAAG,EAAC,MAAM,EAAC,MAAM,CAAC,EA4BxC;IAzBC;;OAEG;IACH,GAFU,EAAE,CAAC,WAAW,CAAC,GAAG,EAAC,MAAM,EAAC,MAAM,CAAC,CAEnB;IACxB,eAAU;IACV,eAAU;IACV,gBAA6B;IAC7B,8BAgCoD,IAAI,CAxBrD;IACH,8BAuBoD,IAAI,CAfrD;IAGL,oBAKC;CACF;AAgBM,qBAN4B,MAAM,SAA3B,KAAK,CAAC,aAAc,EACS,WAAW,SAAxC,EAAE,CAAC,QAAQ,CAAC,GAAG,EAAC,MAAM,EAAC,GAAG,CAAE,KAC/B,GAAG,CAAC,MAAM,CAAC,KACX,GAAG,CAAC,WAAW,SAAS,EAAE,CAAC,QAAQ,CAAC,GAAG,EAAC,MAAM,EAAC,MAAM,MAAM,CAAC,GAAG,MAAM,GAAG,KAAK,CAAC,YAC9E,EAAE,CAAC,QAAQ,CAAC,GAAG,EAAC,MAAM,EAAC,GAAG,CAAC,sEAD0B,MAAM,oBAGH;AA2C5D,yBAH4B,KAAK,SAA1B,KAAK,CAAC,aAAc,UACvB,MAAM,CAAC,KAAK,CAAC,mBAE8B;AAkGtD,4BAA+H;AAsJxH,4BAFI,OAAO;;iBAE0B;mBAnW/B,CAAC,IACD,OAAO,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC;;;;gBAoDV,KAAK,SAA1B,KAAK,CAAC,aAAc,IACrB,YAAY,CAAC;IAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAAC,SAAS,EAAE,CAAC,GAAG,EAAC,GAAG,CAAC,KAAK,CAAC,KAAG,IAAI,CAAA;CAAE,CAAC,GAAG;IAAE,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,GAAG,CAAC;IAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE;uBAkP9I,KAAK,CAAC,aAAa,CAAC,MAAM,EAAE;IAAE,CAAC,GAAG,EAAC,MAAM,GAAG,MAAM,CAAA;CAAE,EAAE,KAAK,EAAE,IAAI,CAAC;uBAnTxD,YAAY;oBACf,cAAc;qBAMb,aAAa;AAsElC;;;;GAIG;AACH,uBAJmC,KAAK,SAA1B,KAAK,CAAC,aAAc;YAEE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI;aAAa,CAAC,GAAG,EAAC,QAAQ,CAAC,KAAK,CAAC,KAAG,IAAI;cADnF,GAAG,CAAC,KAAK;IAItB;;OAEG;IACH,oBAFW,MAAM,CAAC,KAAK,CAAC,EAUvB;IANC,wBAAoB;IACpB;;OAEG;IACH,OAFU,KAAK,OAAC,CAEC;IACjB,gBAA6B;IAG/B;;OAEG;IACH,SAAS,OAFE,KAEG,SAOZ;CAMH;AAkMD;;GAEG;AAEH;;;;GAIG;AACH,qBAJyB,CAAC,SAAZ,QAAS;;;YAEa,CAAC,KAAK,EAAE,CAAC,KAAG,IAAI;aAAW,CAAC,GAAG,EAAC,MAAM,CAAC,CAAC,CAAC,KAAG,IAAI;cADrE,GAAG,CAAC,CAAC;IAIlB;;OAEG;IACH,0BAFW,OAAO,EAajB;IATC,sBAAgC;IAChC,gBAA6B;IAC7B,2BAA2D;IAS7D;;OAEG;IACH,mBAAmB,WAFR,cAAc,EAEG,SAGxB;IAEJ;;OAEG;IACH,SAAS,OAFE,CAEG,UAWb;CAOF;6BA1W4B,kBAAkB;mBAS5B,cAAc"}

yjs-poll/node_modules/lib0/delta/binding.js

@@ -0,0 +1,372 @@
+/* eslint-disable */
+// @ts-nocheck
+// @todo remove all @ts-nocheck and eslint-disable
+/* global MutationObserver */
+import { ObservableV2 } from '../observable.js'
+import * as delta from './delta.js'
+import * as dt from './t3.test.js' // eslint-disable-line
+import * as dom from '../dom.js'
+import * as set from '../set.js'
+import * as map from '../map.js'
+import * as error from '../error.js'
+import * as math from '../math.js'
+import * as mux from '../mutex.js'
+import * as s from '../schema.js'
+
+/**
+ * @template T
+ * @typedef {import('../schema.js').Schema<T>} Schema
+ */
+
+/**
+ * @template {delta.AbstractDelta} DeltaA
+ * @template {delta.AbstractDelta} DeltaB
+ */
+export class Binding {
+  /**
+   * @param {RDT<DeltaA>} a
+   * @param {RDT<DeltaB>} b
+   * @param {dt.Template<any,DeltaA,DeltaB>} template
+   */
+  constructor (a, b, template) {
+    /**
+     * @type {dt.Transformer<any,DeltaA,DeltaB>}
+     */
+    this.t = template.init()
+    this.a = a
+    this.b = b
+    this._mux = mux.createMutex()
+    this._achanged = this.a.on('change', d => this._mux(() => {
+      const tres = this.t.applyA(d)
+      if (tres.a) {
+        a.update(tres.a)
+      }
+      if (tres.b) {
+        b.update(tres.b)
+      }
+    }))
+    this._bchanged = this.b.on('change', d => this._mux(() => {
+      const tres = this.t.applyB(d)
+      if (tres.b) {
+        this.b.update(tres.b)
+      }
+      if (tres.a) {
+        a.update(tres.a)
+      }
+    }))
+  }
+
+  destroy = () => {
+    this.a.off('destroy', this.destroy)
+    this.b.off('destroy', this.destroy)
+    this.a.off('change', this._achanged)
+    this.b.off('change', this._bchanged)
+  }
+}
+
+/**
+ * Abstract Interface for a delta-based Replicated Data Type.
+ *
+ * @template {delta.AbstractDelta} Delta
+ * @typedef {ObservableV2<{ 'change': (delta: Delta) => void, 'destroy': (rdt:RDT<Delta>)=>void }> & { update: (delta: Delta) => any, destroy: () => void }} RDT
+ */
+
+/**
+ * @template {delta.AbstractDelta} DeltaA
+ * @template {dt.Template<any,DeltaA,any>} Transformer
+ * @param {RDT<DeltaA>} a
+ * @param {RDT<Transformer extends dt.Template<any,DeltaA,infer DeltaB> ? DeltaB : never>} b
+ * @param {dt.Template<any,DeltaA,any>} template
+ */
+export const bind = (a, b, template) => new Binding(a, b, template)
+
+/**
+ * @template {delta.AbstractDelta} Delta
+ * @implements RDT<Delta>
+ * @extends {ObservableV2<{ change: (delta: Delta) => void, 'destroy': (rdt:DeltaRDT<Delta>)=>void }>}
+ */
+class DeltaRDT extends ObservableV2 {
+  /**
+   * @param {Schema<Delta>} $delta
+   */
+  constructor ($delta) {
+    super()
+    this.$delta = $delta
+    /**
+     * @type {Delta?}
+     */
+    this.state = null
+    this._mux = mux.createMutex()
+  }
+
+  /**
+   * @param {Delta} delta
+   */
+  update = delta => delta.isEmpty() || this._mux(() => {
+    if (this.state != null) {
+      this.state.apply(delta)
+    } else {
+      this.state = delta
+    }
+    this.emit('change', [delta])
+  })
+
+  destroy () {
+    this.emit('destroy', [this])
+    super.destroy()
+  }
+}
+
+/**
+ * @template {delta.AbstractDelta} Delta
+ * @param {Schema<Delta>} $delta
+ */
+export const deltaRDT = $delta => new DeltaRDT($delta)
+
+/**
+ * @param {Node} domNode
+ */
+const domToDelta = domNode => {
+  if (dom.$element.check(domNode)) {
+    const d = delta.node(domNode.nodeName.toLowerCase())
+    for (let i = 0; i < domNode.attributes.length; i++) {
+      const attr = /** @type {Attr} */ (domNode.attributes.item(i))
+      d.attributes.set(attr.nodeName, attr.value)
+    }
+    domNode.childNodes.forEach(child => {
+      d.children.insert(dom.$text.check(child) ? child.textContent : [domToDelta(child)])
+    })
+    return d
+  }
+  error.unexpectedCase()
+}
+
+/**
+ * @param {DomDelta} d
+ */
+const deltaToDom = d => {
+  if (delta.$nodeAny.check(d)) {
+    const n = dom.element(d.name)
+    d.attributes.forEach(change => {
+      if (delta.$insertOp.check(change)) {
+        n.setAttribute(change.key, change.value)
+      }
+    })
+    d.children.forEach(child => {
+      if (delta.$insertOp.check(child)) {
+        n.append(...child.insert.map(deltaToDom))
+      } else if (delta.$textOp.check(child)) {
+        n.append(dom.text(child.insert))
+      }
+    })
+    return n
+  }
+  error.unexpectedCase()
+}
+
+/**
+ * @param {Element} el
+ * @param {delta.Node<string,any,any,any>} d
+ */
+const applyDeltaToDom = (el, d) => {
+  d.attributes.forEach(change => {
+    if (delta.$deleteOp.check(change)) {
+      el.removeAttribute(change.key)
+    } else {
+      el.setAttribute(change.key, change.value)
+    }
+  })
+  let childIndex = 0
+  let childOffset = 0
+  d.children.forEach(change => {
+    let child = el.childNodes[childIndex] || null
+    if (delta.$deleteOp.check(change)) {
+      let len = change.length
+      while (len > 0) {
+        if (dom.$element.check(child)) {
+          child.remove()
+          len--
+        } else if (dom.$text.check(child)) {
+          const childLen = child.length
+          if (childOffset === 0 && childLen <= len) {
+            child.remove()
+            len -= childLen
+          } else {
+            const spliceLen = math.min(len, childLen - childOffset)
+            child.deleteData(childOffset, spliceLen)
+            if (child.length <= childOffset) {
+              childOffset = 0
+              childIndex++
+            }
+          }
+        }
+      }
+    } else if (delta.$insertOp.check(change)) {
+      if (childOffset > 0) {
+        const tchild = dom.$text.cast(child)
+        child = tchild.splitText(childOffset)
+        childIndex++
+        childOffset = 0
+      }
+      el.insertBefore(dom.fragment(change.insert.map(deltaToDom)), child)
+    } else if (delta.$modifyOp.check(change)) {
+      applyDeltaToDom(dom.$element.cast(child), change.modify)
+    } else if (delta.$textOp.check(change)) {
+      el.insertBefore(dom.text(change.insert), child)
+    } else {
+      error.unexpectedCase()
+    }
+  })
+}
+
+export const $domDelta = delta.$node(s.$string, s.$record(s.$string, s.$string), s.$never, { recursive: true, withText: true })
+
+/**
+ * @param {Element} observedNode
+ * @param {MutationRecord[]} mutations
+ * @param {any} origin assign this origin to the generated delta
+ */
+const _mutationsToDelta = (observedNode, mutations, origin) => {
+  /**
+   * @typedef {{ removedBefore: Map<Node?,number>, added: Set<Node>, modified: number, d: delta.Node }} ChangedNodeInfo
+   */
+  /**
+   * Compute all deltas without recursion.
+   *
+   * 1. mark all changed parents in parentsChanged
+   * 2. fill out necessary information for each changed parent ()
+   */
+  //
+  /**
+   * @type {Map<Node,ChangedNodeInfo>}
+   */
+  const changedNodes = map.create()
+  /**
+   * @param {Node} node
+   * @return {ChangedNodeInfo}
+   */
+  const getChangedNodeInfo = node => map.setIfUndefined(changedNodes, node, () => ({ removedBefore: map.create(), added: set.create(), modified: 0, d: delta.node(node.nodeName.toLowerCase()) }))
+  const observedNodeInfo = getChangedNodeInfo(observedNode)
+  mutations.forEach(mutation => {
+    const target = /** @type {HTMLElement} */ (mutation.target)
+    const parent = target.parentNode
+    const attrName = /** @type {string} */ (mutation.attributeName)
+    const newVal = target.getAttribute(attrName)
+    const info = getChangedNodeInfo(target)
+    const d = info.d
+    // go up the tree and mark that a child has been modified
+    for (let changedParent = parent; changedParent != null && getChangedNodeInfo(changedParent).modified++ > 1 && changedParent !== observedNode; changedParent = changedParent.parentNode) {
+      // nop
+    }
+    switch (mutation.type) {
+      case 'attributes': {
+        const attrs = /** @type {delta.Node<any,any,any>} */ (d).attributes
+        if (newVal == null) {
+          attrs.delete(attrName)
+        } else {
+          attrs.set(/** @type {string} */ (attrName), newVal)
+        }
+        break
+      }
+      case 'characterData': {
+        error.methodUnimplemented()
+        break
+      }
+      case 'childList': {
+        const targetInfo = getChangedNodeInfo(target)
+        mutation.addedNodes.forEach(node => {
+          targetInfo.added.add(node)
+        })
+        const removed = mutation.removedNodes.length
+        if (removed > 0) {
+          // @todo this can't work because next can be null
+          targetInfo.removedBefore.set(mutation.nextSibling, removed)
+        }
+        break
+      }
+    }
+  })
+  changedNodes.forEach((info, node) => {
+    const numOfChildChanges = info.modified + info.removedBefore.size + info.added.size
+    const d = /** @type {delta.Node<any,any,any>} */ (info.d)
+    if (numOfChildChanges > 0) {
+      node.childNodes.forEach(nchild => {
+        if (info.removedBefore.has(nchild)) { // can happen separately
+          d.children.delete(/** @type {number} */ (info.removedBefore.get(nchild)))
+        }
+        if (info.added.has(nchild)) {
+          d.children.insert(dom.$text.check(nchild) ? nchild.textContent : [domToDelta(nchild)])
+        } else if (changedNodes.has(nchild)) {
+          d.children.modify(getChangedNodeInfo(nchild).d)
+        }
+      })
+      // remove items to the end, if necessary
+      d.children.delete(info.removedBefore.get(null) ?? 0)
+    }
+    d.done()
+  })
+  observedNodeInfo.d.origin = origin
+  return observedNodeInfo.d
+}
+
+/**
+ * @typedef {delta.RecursiveNode<string, { [key:string]: string }, never, true>} DomDelta
+ */
+
+/**
+ * @template {DomDelta} [D=DomDelta]
+ * @implements RDT<D>
+ * @extends {ObservableV2<{ change: (delta: D)=>void, destroy: (rdt:DomRDT<D>)=>void }>}>}
+ */
+class DomRDT extends ObservableV2 {
+  /**
+   * @param {Element} observedNode
+   */
+  constructor (observedNode) {
+    super()
+    this.observedNode = observedNode
+    this._mux = mux.createMutex()
+    this.observer = new MutationObserver(this._mutationHandler)
+    this.observer.observe(observedNode, {
+      subtree: true,
+      childList: true,
+      attributes: true,
+      characterDataOldValue: true
+    })
+  }
+
+  /**
+   * @param {MutationRecord[]} mutations
+   */
+  _mutationHandler = mutations =>
+    mutations.length > 0 && this._mux(() => {
+      this.emit('change', [/** @type {D} */(_mutationsToDelta(this.observedNode, mutations, this))])
+    })
+
+  /**
+   * @param {D} delta
+   */
+  update = delta => {
+    if (delta.origin !== this) {
+      // @todo the retrieved changes must be transformed agains the updated changes. need a proper
+      // transaction system
+      this._mutationHandler(this.observer.takeRecords())
+      this._mux(() => {
+        applyDeltaToDom(this.observedNode, delta)
+        const mutations = this.observer.takeRecords()
+        this.emit('change', [/** @type {D} */(_mutationsToDelta(this.observedNode, mutations, delta.origin))])
+      })
+    }
+  }
+
+  destroy () {
+    this.emit('destroy', [this])
+    super.destroy()
+    this.observer.disconnect()
+  }
+}
+
+/**
+ * @param {Element} dom
+ */
+export const domRDT = dom => new DomRDT(dom)

yjs-poll/node_modules/lib0/delta/binding.test.d.ts

@@ -0,0 +1,5 @@
+export function testBinding(): void;
+export function testDomBindingBasics(): void;
+export function testDomBindingBackAndForth(): void;
+export function testDataToDom(): void;
+//# sourceMappingURL=binding.test.d.ts.map

yjs-poll/node_modules/lib0/delta/binding.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding.test.d.ts","sourceRoot":"","sources":["binding.test.js"],"names":[],"mappings":"AAUO,oCAcN;AAEM,6CAcN;AAEM,mDAkCN;AAEM,sCAiBN"}

yjs-poll/node_modules/lib0/delta/delta-pitch.test.d.ts

@@ -0,0 +1,5 @@
+export function testDeltaBasics(_tc: t.TestCase): void;
+export function testDeltaBasicSchema(_tc: t.TestCase): void;
+export function testDeltaValues(_tc: t.TestCase): void;
+import * as t from 'lib0/testing';
+//# sourceMappingURL=delta-pitch.test.d.ts.map

yjs-poll/node_modules/lib0/delta/delta-pitch.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delta-pitch.test.d.ts","sourceRoot":"","sources":["delta-pitch.test.js"],"names":[],"mappings":"AAmCO,qCAFI,CAAC,CAAC,QAAQ,QAWpB;AAmBM,0CAFI,CAAC,CAAC,QAAQ,QAWpB;AAYM,qCAFI,CAAC,CAAC,QAAQ,QAwBpB;mBAzGkB,cAAc"}

yjs-poll/node_modules/lib0/delta/delta.test.d.ts

@@ -0,0 +1,29 @@
+export function testDeltaBasicApi(_tc: t.TestCase): void;
+export function testDeltaValues(_tc: t.TestCase): void;
+export function testDeltaBasicCases(): void;
+export function testDeltaArrayBasics(): void;
+export function testAssignability(): void;
+export function testText(): void;
+export function testDelta(_tc: t.TestCase): void;
+export function testDeltaMerging(_tc: t.TestCase): void;
+export function testUseAttributes(_tc: t.TestCase): void;
+export function testUseAttribution(_tc: t.TestCase): void;
+export function testMapTyping(): void;
+export function testMapDeltaBasics(_tc: t.TestCase): void;
+export function testMapDeltaModify(_tc: t.TestCase): void;
+export function testMapDelta(_tc: t.TestCase): void;
+export function testRepeatRebaseMergeDeltas(tc: t.TestCase): void;
+export function testNodeDelta(_tc: t.TestCase): void;
+export function testRecursiveNode(): void;
+export function testSimplifiedDeltaSchemaDefinition(): void;
+export function testDiffing(): void;
+export function testDiffingCommonPreSuffix(): void;
+export function testSlice(): void;
+export function testRepeatRandomListDiff(tc: t.TestCase): void;
+export function testRepeatRandomMapDiff(tc: t.TestCase): void;
+export function testDeltaAppend(_tc: t.TestCase): void;
+export function testDeltaDiffWithFormatting(): void;
+export function testDeltaDiffWithFormatting2(): void;
+export function testDeltaDiffIssue1(): void;
+import * as t from 'lib0/testing';
+//# sourceMappingURL=delta.test.d.ts.map

yjs-poll/node_modules/lib0/delta/delta.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delta.test.d.ts","sourceRoot":"","sources":["delta.test.js"],"names":[],"mappings":"AAqCO,uCAFI,CAAC,CAAC,QAAQ,QAWpB;AAYM,qCAFI,CAAC,CAAC,QAAQ,QAwBpB;AAEM,4CA2BN;AAEM,6CAMN;AAKM,0CAkJN;AAEM,iCAWN;AAKM,+BAFI,CAAC,CAAC,QAAQ,QAKpB;AAKM,sCAFI,CAAC,CAAC,QAAQ,QAYpB;AAKM,uCAFI,CAAC,CAAC,QAAQ,QAuBpB;AAKM,wCAFI,CAAC,CAAC,QAAQ,QAsBpB;AAEM,sCAaN;AAKM,wCAFI,CAAC,CAAC,QAAQ,QA4BpB;AAKM,wCAFI,CAAC,CAAC,QAAQ,QA2CpB;AAKM,kCAFI,CAAC,CAAC,QAAQ,QAqDpB;AAKM,gDAFI,CAAC,CAAC,QAAQ,QAoEpB;AAKM,mCAFI,CAAC,CAAC,QAAQ,QAiCpB;AAEM,0CAmBN;AAEM,4DAIN;AAEM,oCAMN;AAEM,mDAMN;AAEM,kCAGN;AAKM,6CAFI,CAAC,CAAC,QAAQ,QAWpB;AAKM,4CAFI,CAAC,CAAC,QAAQ,QAWpB;AAKM,qCAFI,CAAC,CAAC,QAAQ,QAQpB;AAEM,oDAKN;AAEM,qDAKN;AAEM,4CAQN;mBAjtBkB,cAAc"}

yjs-poll/node_modules/lib0/delta/readme.md

@@ -0,0 +1,129 @@
+# Deltas
+
+- Enable you to efficiently represent changes on all kinds of data structures.
+- Support schemas
+- Support OT-style conflict resolution `delta2.apply(delta1.rebase(delta2, true)) === delta1.apply(delta2.rebase(delta1, false))`
+- nice typings
+
+## Delta for Map-like structures
+
+```javascript
+// define schema
+const $d = delta.$delta(s.$any, { attr1: s.$string, attr2: s.$number })
+const d = delta.create($d)
+
+
+// create an update
+const update = delta.create().set('attr1', 'val1').set('attr2', 42)
+d.apply(update)
+
+// In case  of an invalid update
+const update2 = delta.create().set('attr1', 42)
+// it is possible to check an update beforehand
+$d.check(update2) // => false
+// and you also get type errors
+d.apply(update2) // type error: expected 'attr1' to be of type string
+```
+
+## Delta for Text-like structures
+
+Text-like deltas work similarly to [Quill Deltas]{https://quilljs.com/docs/delta}
+
+```javascript
+// define schema
+const $d = delta.$delta(s.$any, null, s.$string)
+const d = delta.create($d).insert('hello world')
+
+// create an update
+const update = delta.create().retain(11).insert('!')
+d.apply(update)
+
+// In case  of an invalid update
+const update2 = delta.create().insert([{ some: 'object' }])
+// it is possible to check an update beforehando
+$d.check(update2) // => false
+// and you also get type errors
+d.apply(update2) // type error: unexpected attribute 'attr1'
+```
+
+## Delta for Array-like structures
+
+```javascript
+// define schema
+const $d = delta.$delta(s.$any, null, s.$array(s.object({ some: s.$string }, s.$string)))
+const d = delta.create($d).insert(['hello world'])
+
+// create an update
+const update = delta.create().retain(1).insert({ some: 'object' })
+d.apply(update)
+
+// In case  of an invalid update
+const update2 = delta.create().insert([{ unknown: 'prop' }])
+// it is possible to check an update beforehando
+$d.check(update2) // => false
+// and you also get type errors
+d.apply(update2) // type error: { unknown: 'prop' } is not assignable to { some: string }
+```
+
+## Delta for Node-like structures (similar to XML,Trees with named nodes)
+
+```javascript
+// define schema for a 'p'|'h1' node that may contain text or other instances of itself
+const $d = delta.$delta(s.$literal('div', 'p', 'h1'), { style: s.$string }, s.$string, true))
+const d = delta.create('div', $d)
+
+// create an update - insert paragraph into the <div>
+const update = delta.create().insert([delta.create('p', { style: 'bold: true' }, 'hello world')])
+d.apply(update)
+
+// modify the paragraph by deleting the text 'world' and appending '!'
+d.apply(delta.create().modify(
+  delta.create().retain(6).delete(5).insert('!')
+))
+```
+
+# Transformers
+
+We often have two different data structures that we want to sync. There might be
+slight differences between those data structures. I.e. we might have a Yjs data
+structure containing the following content:
+
+```javascript
+/**
+ * { 
+ *   headline: {{ headline }},
+ *   content: {{ content }}
+ * }
+ */
+const $data = s.$delta(null, { headline: s.$string, content: s.$string })
+```
+
+A typical scenario is that we want to sync that to the dom and back. "two-way bindings"
+- When the Yjs struucture updates, we want to sync the changes to the dom.
+- When the dom is updated (because the dom is a `contenteditable` editor), we
+want to sync back the changes to the yjs structure.
+
+Now, the dom might look like this:
+
+```javascript
+/**
+ * <div>
+ *   <h1 style='some custom style'>{{headline}}</h1>
+ *   <span>dturianed</span>
+ *   <p>{{content}}</p>
+ * </div>
+ */
+```
+
+We can achieve automattic back-and-forth transformations with delta
+transformers:
+
+```javascript
+const Λdata = Λ.transform($data, $d =>
+    Λ.delta('div', {}, [
+        Λ.delta('h1', { style: 'bold:true' }, [Λ.query('headline')($d)], []),
+        Λ.delta('p', null, [Λ.query('content')($d)])
+    ])
+)
+```
+

yjs-poll/node_modules/lib0/delta/t3.test.d.ts

@@ -0,0 +1,19 @@
+export function transformResult<DeltaA extends delta.DeltaBuilder | null, DeltaB extends delta.DeltaBuilder | null>(a: DeltaA, b: DeltaB): TransformResult<DeltaA | null, DeltaB | null>;
+export const transformResultEmpty: TransformResult<null, null>;
+export type TransformResult<DeltaA extends delta.Delta | null, DeltaB extends delta.Delta | null> = {
+    a: DeltaA | null;
+    b: DeltaB | null;
+};
+export type DeltaTransformer<DeltaA extends delta.DeltaAny, DeltaB extends delta.DeltaAny> = (t: {
+    a: DeltaA | null;
+    b: DeltaB | null;
+}) => ({
+    a: DeltaA | null;
+    b: DeltaB | null;
+});
+export type Transform<DeltaA extends delta.Delta, DeltaB extends delta.Delta> = {
+    applyA: (da: DeltaA) => TransformResult<DeltaA, DeltaB>;
+    applyB: (db: DeltaB) => TransformResult<DeltaA, DeltaB>;
+};
+import * as delta from './delta.js';
+//# sourceMappingURL=t3.test.d.ts.map

yjs-poll/node_modules/lib0/delta/t3.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"t3.test.d.ts","sourceRoot":"","sources":["t3.test.js"],"names":[],"mappings":"AAoBO,gCAN4B,MAAM,SAA3B,KAAK,CAAC,YAAY,OAAE,EACC,MAAM,SAA3B,KAAK,CAAC,YAAY,OAAE,KACvB,MAAM,KACN,MAAM,GACL,eAAe,CAAC,MAAM,OAAC,EAAC,MAAM,OAAC,CAAC,CAEO;AACnD,+DAA+D;4BAbnC,MAAM,SAApB,KAAK,CAAC,KAAK,OAAE,EACC,MAAM,SAApB,KAAK,CAAC,KAAK,OAAE,IACd;IAAE,CAAC,EAAE,MAAM,OAAC,CAAC;IAAC,CAAC,EAAE,MAAM,OAAC,CAAA;CAAE;6BAiBT,MAAM,SAAtB,KAAK,CAAC,QAAS,EACC,MAAM,SAAtB,KAAK,CAAC,QAAS,IAChB,CAAC,CAAC,EAAC;IAAC,CAAC,EAAC,MAAM,OAAC,CAAC;IAAA,CAAC,EAAC,MAAM,OAAC,CAAA;CAAC,KAAG,CAAC;IAAC,CAAC,EAAC,MAAM,OAAC,CAAC;IAAA,CAAC,EAAC,MAAM,OAAC,CAAA;CAAC,CAAC;sBA2GpC,MAAM,SAAnB,KAAK,CAAC,KAAM,EACC,MAAM,SAAnB,KAAK,CAAC,KAAM,IACb;IAAE,MAAM,EAAE,CAAC,EAAE,EAAC,MAAM,KAAG,eAAe,CAAC,MAAM,EAAC,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,CAAC,EAAE,EAAC,MAAM,KAAG,eAAe,CAAC,MAAM,EAAC,MAAM,CAAC,CAAA;CAAE;uBAvIlG,YAAY"}