lib0 0.2.112 → 0.2.115-0

package/dist/aes-gcm.cjs

@@ -2,17 +2,17 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var encoding = require('./encoding-1acb59c4.cjs');
-var decoding = require('./decoding-2b136346.cjs');
+var encoding = require('./encoding-7f85922c.cjs');
+var decoding = require('./decoding-50b9ce38.cjs');
 var webcrypto = require('lib0/webcrypto');
-var string = require('./string-b2827a90.cjs');
+var string = require('./string-fddc5f8b.cjs');
 var common = require('./common.cjs');
-require('./math-08e068f9.cjs');
-require('./number-466d8922.cjs');
+require('./math-96d5e8c4.cjs');
+require('./number-1fb57bba.cjs');
 require('./binary-ac8e39e2.cjs');
 require('./array-78849c95.cjs');
 require('./set-5b47859e.cjs');
-require('./error-8582d695.cjs');
+require('./error-0c1f634f.cjs');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -49,7 +49,7 @@ const defaultUsages = ['encrypt', 'decrypt'];
 
 /**
  * @param {CryptoKey} key
- * @param {Uint8Array} data
+ * @param {Uint8Array<ArrayBuffer>} data
  */
 const encrypt = (key, data) => {
   const iv = webcrypto__namespace.getRandomValues(new Uint8Array(16)); // 92bit is enough. 128bit is recommended if space is not an issue.
@@ -75,7 +75,7 @@ const encrypt = (key, data) => {
  * Decrypt some data using AES-GCM method.
  *
  * @param {CryptoKey} key
- * @param {Uint8Array} data
+ * @param {Uint8Array<ArrayBuffer>} data
  * @return {PromiseLike<Uint8Array>} decrypted buffer
  */
 const decrypt = (key, data) => {
@@ -114,7 +114,7 @@ const importKeyJwk = (jwk, { usages, extractable = false } = {}) => {
 /**
  * Only suited for importing public keys.
  *
- * @param {Uint8Array} raw
+ * @param {Uint8Array<ArrayBuffer>} raw
  * @param {Object} opts
  * @param {Usages} [opts.usages]
  * @param {boolean} [opts.extractable]
@@ -123,7 +123,7 @@ const importKeyRaw = (raw, { usages = defaultUsages, extractable = false } = {})
   webcrypto__namespace.subtle.importKey('raw', raw, aesAlgDef, extractable, /** @type {Usages} */ (usages));
 
 /**
- * @param {Uint8Array | string} data
+ * @param {Uint8Array<ArrayBuffer> | string} data
  */
 /* c8 ignore next */
 const toBinary = data => typeof data === 'string' ? string.encodeUtf8(data) : data;
@@ -133,8 +133,8 @@ const toBinary = data => typeof data === 'string' ? string.encodeUtf8(data) : da
  *
  * Derive an symmetric key using the Password-Based-Key-Derivation-Function-2.
  *
- * @param {Uint8Array|string} secret
- * @param {Uint8Array|string} salt
+ * @param {Uint8Array<ArrayBuffer>|string} secret
+ * @param {Uint8Array<ArrayBuffer>|string} salt
  * @param {Object} opts
  * @param {boolean} [opts.extractable]
  * @param {Usages} [opts.usages]

package/dist/aes-gcm.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"aes-gcm.cjs","sources":["../crypto/aes-gcm.js"],"sourcesContent":["/**\n * AES-GCM is a symmetric key for encryption\n */\n\nimport * as encoding from '../encoding.js'\nimport * as decoding from '../decoding.js'\nimport * as webcrypto from 'lib0/webcrypto'\nimport * as string from '../string.js'\nexport { exportKeyJwk, exportKeyRaw } from './common.js'\n\n/**\n * @typedef {Array<'encrypt'|'decrypt'>} Usages\n */\n\n/**\n * @type {Usages}\n */\nconst defaultUsages = ['encrypt', 'decrypt']\n\n/**\n * @param {CryptoKey} key\n * @param {Uint8Array} data\n */\nexport const encrypt = (key, data) => {\n  const iv = webcrypto.getRandomValues(new Uint8Array(16)) // 92bit is enough. 128bit is recommended if space is not an issue.\n  return webcrypto.subtle.encrypt(\n    {\n      name: 'AES-GCM',\n      iv\n    },\n    key,\n    data\n  ).then(cipher => {\n    const encryptedDataEncoder = encoding.createEncoder()\n    // iv may be sent in the clear to the other peers\n    encoding.writeUint8Array(encryptedDataEncoder, iv)\n    encoding.writeVarUint8Array(encryptedDataEncoder, new Uint8Array(cipher))\n    return encoding.toUint8Array(encryptedDataEncoder)\n  })\n}\n\n/**\n * @experimental The API is not final!\n *\n * Decrypt some data using AES-GCM method.\n *\n * @param {CryptoKey} key\n * @param {Uint8Array} data\n * @return {PromiseLike<Uint8Array>} decrypted buffer\n */\nexport const decrypt = (key, data) => {\n  const dataDecoder = decoding.createDecoder(data)\n  const iv = decoding.readUint8Array(dataDecoder, 16)\n  const cipher = decoding.readVarUint8Array(dataDecoder)\n  return webcrypto.subtle.decrypt(\n    {\n      name: 'AES-GCM',\n      iv\n    },\n    key,\n    cipher\n  ).then(data => new Uint8Array(data))\n}\n\nconst aesAlgDef = {\n  name: 'AES-GCM',\n  length: 256\n}\n\n/**\n * @param {any} jwk\n * @param {Object} opts\n * @param {Usages} [opts.usages]\n * @param {boolean} [opts.extractable]\n */\nexport const importKeyJwk = (jwk, { usages, extractable = false } = {}) => {\n  if (usages == null) {\n    /* c8 ignore next */\n    usages = jwk.key_ops || defaultUsages\n  }\n  return webcrypto.subtle.importKey('jwk', jwk, 'AES-GCM', extractable, /** @type {Usages} */ (usages))\n}\n\n/**\n * Only suited for importing public keys.\n *\n * @param {Uint8Array} raw\n * @param {Object} opts\n * @param {Usages} [opts.usages]\n * @param {boolean} [opts.extractable]\n */\nexport const importKeyRaw = (raw, { usages = defaultUsages, extractable = false } = {}) =>\n  webcrypto.subtle.importKey('raw', raw, aesAlgDef, extractable, /** @type {Usages} */ (usages))\n\n/**\n * @param {Uint8Array | string} data\n */\n/* c8 ignore next */\nconst toBinary = data => typeof data === 'string' ? string.encodeUtf8(data) : data\n\n/**\n * @experimental The API is not final!\n *\n * Derive an symmetric key using the Password-Based-Key-Derivation-Function-2.\n *\n * @param {Uint8Array|string} secret\n * @param {Uint8Array|string} salt\n * @param {Object} opts\n * @param {boolean} [opts.extractable]\n * @param {Usages} [opts.usages]\n */\nexport const deriveKey = (secret, salt, { extractable = false, usages = defaultUsages } = {}) =>\n  webcrypto.subtle.importKey(\n    'raw',\n    toBinary(secret),\n    'PBKDF2',\n    false,\n    ['deriveKey']\n  ).then(keyMaterial =>\n    webcrypto.subtle.deriveKey(\n      {\n        name: 'PBKDF2',\n        salt: toBinary(salt), // NIST recommends at least 64 bits\n        iterations: 600000, // OWASP recommends 600k iterations\n        hash: 'SHA-256'\n      },\n      keyMaterial,\n      aesAlgDef,\n      extractable,\n      usages\n    )\n  )\n"],"names":["webcrypto","encoding.createEncoder","encoding.writeUint8Array","encoding.writeVarUint8Array","encoding.toUint8Array","decoding.createDecoder","decoding.readUint8Array","decoding.readVarUint8Array","string.encodeUtf8"],"mappings":"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"}
+{"version":3,"file":"aes-gcm.cjs","sources":["../crypto/aes-gcm.js"],"sourcesContent":["/**\n * AES-GCM is a symmetric key for encryption\n */\n\nimport * as encoding from '../encoding.js'\nimport * as decoding from '../decoding.js'\nimport * as webcrypto from 'lib0/webcrypto'\nimport * as string from '../string.js'\nexport { exportKeyJwk, exportKeyRaw } from './common.js'\n\n/**\n * @typedef {Array<'encrypt'|'decrypt'>} Usages\n */\n\n/**\n * @type {Usages}\n */\nconst defaultUsages = ['encrypt', 'decrypt']\n\n/**\n * @param {CryptoKey} key\n * @param {Uint8Array<ArrayBuffer>} data\n */\nexport const encrypt = (key, data) => {\n  const iv = webcrypto.getRandomValues(new Uint8Array(16)) // 92bit is enough. 128bit is recommended if space is not an issue.\n  return webcrypto.subtle.encrypt(\n    {\n      name: 'AES-GCM',\n      iv\n    },\n    key,\n    data\n  ).then(cipher => {\n    const encryptedDataEncoder = encoding.createEncoder()\n    // iv may be sent in the clear to the other peers\n    encoding.writeUint8Array(encryptedDataEncoder, iv)\n    encoding.writeVarUint8Array(encryptedDataEncoder, new Uint8Array(cipher))\n    return encoding.toUint8Array(encryptedDataEncoder)\n  })\n}\n\n/**\n * @experimental The API is not final!\n *\n * Decrypt some data using AES-GCM method.\n *\n * @param {CryptoKey} key\n * @param {Uint8Array<ArrayBuffer>} data\n * @return {PromiseLike<Uint8Array>} decrypted buffer\n */\nexport const decrypt = (key, data) => {\n  const dataDecoder = decoding.createDecoder(data)\n  const iv = decoding.readUint8Array(dataDecoder, 16)\n  const cipher = decoding.readVarUint8Array(dataDecoder)\n  return webcrypto.subtle.decrypt(\n    {\n      name: 'AES-GCM',\n      iv\n    },\n    key,\n    cipher\n  ).then(data => new Uint8Array(data))\n}\n\nconst aesAlgDef = {\n  name: 'AES-GCM',\n  length: 256\n}\n\n/**\n * @param {any} jwk\n * @param {Object} opts\n * @param {Usages} [opts.usages]\n * @param {boolean} [opts.extractable]\n */\nexport const importKeyJwk = (jwk, { usages, extractable = false } = {}) => {\n  if (usages == null) {\n    /* c8 ignore next */\n    usages = jwk.key_ops || defaultUsages\n  }\n  return webcrypto.subtle.importKey('jwk', jwk, 'AES-GCM', extractable, /** @type {Usages} */ (usages))\n}\n\n/**\n * Only suited for importing public keys.\n *\n * @param {Uint8Array<ArrayBuffer>} raw\n * @param {Object} opts\n * @param {Usages} [opts.usages]\n * @param {boolean} [opts.extractable]\n */\nexport const importKeyRaw = (raw, { usages = defaultUsages, extractable = false } = {}) =>\n  webcrypto.subtle.importKey('raw', raw, aesAlgDef, extractable, /** @type {Usages} */ (usages))\n\n/**\n * @param {Uint8Array<ArrayBuffer> | string} data\n */\n/* c8 ignore next */\nconst toBinary = data => typeof data === 'string' ? string.encodeUtf8(data) : data\n\n/**\n * @experimental The API is not final!\n *\n * Derive an symmetric key using the Password-Based-Key-Derivation-Function-2.\n *\n * @param {Uint8Array<ArrayBuffer>|string} secret\n * @param {Uint8Array<ArrayBuffer>|string} salt\n * @param {Object} opts\n * @param {boolean} [opts.extractable]\n * @param {Usages} [opts.usages]\n */\nexport const deriveKey = (secret, salt, { extractable = false, usages = defaultUsages } = {}) =>\n  webcrypto.subtle.importKey(\n    'raw',\n    toBinary(secret),\n    'PBKDF2',\n    false,\n    ['deriveKey']\n  ).then(keyMaterial =>\n    webcrypto.subtle.deriveKey(\n      {\n        name: 'PBKDF2',\n        salt: toBinary(salt), // NIST recommends at least 64 bits\n        iterations: 600000, // OWASP recommends 600k iterations\n        hash: 'SHA-256'\n      },\n      keyMaterial,\n      aesAlgDef,\n      extractable,\n      usages\n    )\n  )\n"],"names":["webcrypto","encoding.createEncoder","encoding.writeUint8Array","encoding.writeVarUint8Array","encoding.toUint8Array","decoding.createDecoder","decoding.readUint8Array","decoding.readVarUint8Array","string.encodeUtf8"],"mappings":"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"}

package/dist/array.cjs

@@ -2,25 +2,68 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var schema = require('./schema.cjs');
+var abstractArray = require('./abstract-array.cjs');
+var ops = require('./ops.cjs');
+require('./object-18980796.cjs');
+require('./traits.cjs');
+require('./array-78849c95.cjs');
 require('./set-5b47859e.cjs');
-var array = require('./array-78849c95.cjs');
+require('./error-0c1f634f.cjs');
+require('./environment-90227ead.cjs');
+require('./map-24d263c0.cjs');
+require('./string-fddc5f8b.cjs');
+require('./conditions-f5c0c102.cjs');
+require('./storage.cjs');
+require('./function-e7d18feb.cjs');
+require('./abstract.cjs');
+require('./math-96d5e8c4.cjs');
+require('./list.cjs');
 
+/**
+ * @template ArrayContent
+ * @template {boolean} [WithText=false]
+ * @extends AbstractDeltaArrayBuilder<'array', import('./ops.js').DeltaArrayOps<ArrayContent,WithText>>
+ */
+class DeltaArray extends abstractArray.AbstractDeltaArrayBuilder {
+  /**
+   * @param {s.Schema<ArrayContent>} $insert
+   * @param {WithText} withText
+   */
+  constructor ($insert, withText) {
+    super('array', $insert);
+    this.withText = withText;
+  }
+}
 
+/**
+ * @template ArrayContent
+ * @template {boolean} [WithText=false]
+ * @param {s.Schema<ArrayContent>} $insert
+ * @param {WithText} [withText]
+ * @return {s.Schema<DeltaArray<ArrayContent, WithText>>}
+ */
+const $array = ($insert, withText) => /** @type {any} */ (schema.$instanceOf(abstractArray.AbstractDeltaArrayBuilder, o => o.type === 'array' && o.ops.every(op => {
+  if (ops.$textOp.check(op)) return !!withText
+  if (ops.$insertOp.check(op)) return op.insert.every(opi => $insert.check(opi))
+  return true
+})));
+/**
+ * @type {s.Schema<DeltaArray<any,any>>}
+ */
+const $arrayAny = /** @type {any} */ (schema.$instanceOf(abstractArray.AbstractDeltaArrayBuilder, o => o.type === 'array'));
 
-exports.appendTo = array.appendTo;
-exports.bubblesortItem = array.bubblesortItem;
-exports.copy = array.copy;
-exports.create = array.create;
-exports.equalFlat = array.equalFlat;
-exports.every = array.every;
-exports.flatten = array.flatten;
-exports.fold = array.fold;
-exports.from = array.from;
-exports.isArray = array.isArray;
-exports.last = array.last;
-exports.map = array.map;
-exports.some = array.some;
-exports.unfold = array.unfold;
-exports.unique = array.unique;
-exports.uniqueBy = array.uniqueBy;
+/**
+ * @template [V=any]
+ * @template {boolean} [WithText=any]
+ * @param {s.Schema<V>} $insert
+ * @param {WithText} [withText]
+ * @return {DeltaArray<V,WithText>}
+ */
+const array = ($insert = schema.$any, withText) => /** @type {DeltaArray<V,WithText>} */ (new DeltaArray($insert, withText ?? true));
+
+exports.$array = $array;
+exports.$arrayAny = $arrayAny;
+exports.DeltaArray = DeltaArray;
+exports.array = array;
 //# sourceMappingURL=array.cjs.map

package/dist/array.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"array.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"array.cjs","sources":["../delta/array.js"],"sourcesContent":["import * as s from '../schema.js'\nimport { AbstractDeltaArrayBuilder } from './abstract-array.js'\nimport * as ops from './ops.js'\n\n/**\n * @template ArrayContent\n * @template {boolean} [WithText=false]\n * @extends AbstractDeltaArrayBuilder<'array', import('./ops.js').DeltaArrayOps<ArrayContent,WithText>>\n */\nexport class DeltaArray extends AbstractDeltaArrayBuilder {\n  /**\n   * @param {s.Schema<ArrayContent>} $insert\n   * @param {WithText} withText\n   */\n  constructor ($insert, withText) {\n    super('array', $insert)\n    this.withText = withText\n  }\n}\n\n/**\n * @template ArrayContent\n * @template {boolean} [WithText=false]\n * @param {s.Schema<ArrayContent>} $insert\n * @param {WithText} [withText]\n * @return {s.Schema<DeltaArray<ArrayContent, WithText>>}\n */\nexport const $array = ($insert, withText) => /** @type {any} */ (s.$instanceOf(AbstractDeltaArrayBuilder, o => o.type === 'array' && o.ops.every(op => {\n  if (ops.$textOp.check(op)) return !!withText\n  if (ops.$insertOp.check(op)) return op.insert.every(opi => $insert.check(opi))\n  return true\n})))\n/**\n * @type {s.Schema<DeltaArray<any,any>>}\n */\nexport const $arrayAny = /** @type {any} */ (s.$instanceOf(AbstractDeltaArrayBuilder, o => o.type === 'array'))\n\n/**\n * @template [V=any]\n * @template {boolean} [WithText=any]\n * @param {s.Schema<V>} $insert\n * @param {WithText} [withText]\n * @return {DeltaArray<V,WithText>}\n */\nexport const array = ($insert = s.$any, withText) => /** @type {DeltaArray<V,WithText>} */ (new DeltaArray($insert, withText ?? true))\n"],"names":["AbstractDeltaArrayBuilder","s.$instanceOf","ops.$textOp","ops.$insertOp","s.$any"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAIA;AACA;AACA;AACA;AACA;AACO,MAAM,UAAU,SAASA,uCAAyB,CAAC;AAC1D;AACA;AACA;AACA;AACA,EAAE,WAAW,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE;AAClC,IAAI,KAAK,CAAC,OAAO,EAAE,OAAO,EAAC;AAC3B,IAAI,IAAI,CAAC,QAAQ,GAAG,SAAQ;AAC5B,GAAG;AACH,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,MAAM,GAAG,CAAC,OAAO,EAAE,QAAQ,yBAAyBC,kBAAa,CAACD,uCAAyB,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,OAAO,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,IAAI;AACvJ,EAAE,IAAIE,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,QAAQ;AAC9C,EAAE,IAAIC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AAChF,EAAE,OAAO,IAAI;AACb,CAAC,CAAC,CAAC,EAAC;AACJ;AACA;AACA;AACY,MAAC,SAAS,uBAAuBF,kBAAa,CAACD,uCAAyB,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC,EAAC;AAC/G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,KAAK,GAAG,CAAC,OAAO,GAAGI,WAAM,EAAE,QAAQ,4CAA4C,IAAI,UAAU,CAAC,OAAO,EAAE,QAAQ,IAAI,IAAI,CAAC;;;;;;;"}

package/dist/array2.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('./set-5b47859e.cjs');
+var array = require('./array-78849c95.cjs');
+
+
+
+exports.appendTo = array.appendTo;
+exports.bubblesortItem = array.bubblesortItem;
+exports.copy = array.copy;
+exports.create = array.create;
+exports.equalFlat = array.equalFlat;
+exports.every = array.every;
+exports.flatten = array.flatten;
+exports.fold = array.fold;
+exports.from = array.from;
+exports.isArray = array.isArray;
+exports.last = array.last;
+exports.map = array.map;
+exports.some = array.some;
+exports.unfold = array.unfold;
+exports.unique = array.unique;
+exports.uniqueBy = array.uniqueBy;
+//# sourceMappingURL=array2.cjs.map

package/dist/array2.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"array2.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/binding.cjs

@@ -0,0 +1,398 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var observable = require('./observable.cjs');
+var ops = require('./ops.cjs');
+require('./abstract.cjs');
+require('./array.cjs');
+var node = require('./node.cjs');
+require('./map.cjs');
+require('./text.cjs');
+require('./value.cjs');
+require('./transformer.cjs');
+var dom = require('./dom-2b123630.cjs');
+var set = require('./set-5b47859e.cjs');
+var map = require('./map-24d263c0.cjs');
+var error = require('./error-0c1f634f.cjs');
+var math = require('./math-96d5e8c4.cjs');
+var mutex = require('./mutex-63f09c81.cjs');
+var schema = require('./schema.cjs');
+require('./array-78849c95.cjs');
+require('./object-18980796.cjs');
+require('./traits.cjs');
+require('./function-e7d18feb.cjs');
+require('./list.cjs');
+require('./environment-90227ead.cjs');
+require('./string-fddc5f8b.cjs');
+require('./conditions-f5c0c102.cjs');
+require('./storage.cjs');
+require('./abstract-array.cjs');
+require('./pair-ab022bc3.cjs');
+
+/* global MutationObserver */
+
+/**
+ * @template T
+ * @typedef {import('../schema.js').Schema<T>} Schema
+ */
+
+/**
+ * @template {delta.AbstractDelta} DeltaA
+ * @template {delta.AbstractDelta} DeltaB
+ */
+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 = mutex.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
+ */
+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 observable.ObservableV2 {
+  /**
+   * @param {Schema<Delta>} $delta
+   */
+  constructor ($delta) {
+    super();
+    this.$delta = $delta;
+    /**
+     * @type {Delta?}
+     */
+    this.state = null;
+    this._mux = mutex.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
+ */
+const deltaRDT = $delta => new DeltaRDT($delta);
+
+/**
+ * @param {Node} domNode
+ */
+const domToDelta = domNode => {
+  if (dom.$element.check(domNode)) {
+    const d = node.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 (node.$nodeAny.check(d)) {
+    const n = dom.element(d.name);
+    d.attributes.forEach(change => {
+      if (ops.$insertOp.check(change)) {
+        n.setAttribute(change.key, change.value);
+      }
+    });
+    d.children.forEach(child => {
+      if (ops.$insertOp.check(child)) {
+        n.append(...child.insert.map(deltaToDom));
+      } else if (ops.$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 (ops.$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 (ops.$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 (ops.$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 (ops.$modifyOp.check(change)) {
+      applyDeltaToDom(dom.$element.cast(child), change.modify);
+    } else if (ops.$textOp.check(change)) {
+      el.insertBefore(dom.text(change.insert), child);
+    } else {
+      error.unexpectedCase();
+    }
+  });
+};
+
+const $domDelta = node.$node(schema.$string, schema.$record(schema.$string, schema.$string), schema.$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$1 => map.setIfUndefined(changedNodes, node$1, () => ({ removedBefore: map.create(), added: set.create(), modified: 0, d: node.node(node$1.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 observable.ObservableV2 {
+  /**
+   * @param {Element} observedNode
+   */
+  constructor (observedNode) {
+    super();
+    this.observedNode = observedNode;
+    this._mux = mutex.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
+ */
+const domRDT = dom => new DomRDT(dom);
+
+exports.$domDelta = $domDelta;
+exports.Binding = Binding;
+exports.bind = bind;
+exports.deltaRDT = deltaRDT;
+exports.domRDT = domRDT;
+//# sourceMappingURL=binding.cjs.map