lib0 0.2.112 → 0.2.115-0

package/delta/d2.test.d.ts

@@ -0,0 +1,15 @@
+export function testDeltaBasics(): 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;
+import * as t from 'lib0/testing';
+//# sourceMappingURL=d2.test.d.ts.map

package/delta/d2.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"d2.test.d.ts","sourceRoot":"","sources":["d2.test.js"],"names":[],"mappings":"AAMO,wCA4BN;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,QAgCpB;AAKM,wCAFI,CAAC,CAAC,QAAQ,QA2CpB;AAKM,kCAFI,CAAC,CAAC,QAAQ,QAoDpB;AAKM,gDAFI,CAAC,CAAC,QAAQ,QAoEpB;AAKM,mCAFI,CAAC,CAAC,QAAQ,QAwBpB;AAEM,0CAkBN;mBAtYkB,cAAc"}

package/delta/index.d.ts

@@ -0,0 +1,14 @@
+export type Text = import("./text.js").DeltaText<any>;
+export type Delta = Array<any> | import("./node.js").DeltaNode<string, any, any, any>;
+export type RecursiveNode<NodeName extends string, Attributes extends {
+    [key: string]: any;
+}, Children, WithText extends boolean> = import("./node.js").RecursiveDeltaNode<NodeName, Attributes, Children, WithText>;
+export type ValueUnwrap<V> = V extends import("./value.js").DeltaValue<infer X> ? X : V;
+export { TextOp, InsertOp, DeleteOp, ModifyOp, RetainOp, MapInsertOp, MapDeleteOp, MapModifyOp, $textOp, $insertOp, $insertOpWith, $deleteOp, $modifyOp, $modifyOpWith, $anyOp } from "./ops.js";
+export { $delta, $$delta, AbstractDelta, mergeDeltas } from "./abstract.js";
+export { array, $array, $arrayAny, DeltaArray as Array } from "./array.js";
+export { node, $node, $nodeAny, DeltaNode as Node } from "./node.js";
+export { map, $map, $mapAny, $mapJson, DeltaMap as Map } from "./map.js";
+export { text, $text, $textAny, DeltaTextBuilder as TextBuilder } from "./text.js";
+export { value, $value, $valueAny, DeltaValue as Value, DeltaValueBuilder as ValueBuilder } from "./value.js";
+//# sourceMappingURL=index.d.ts.map

package/delta/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"mBAoDa,OAAO,WAAW,EAAE,SAAS,CAAC,GAAG,CAAC;oBAIlC,KAAK,CAAC,GAAG,CAAC,GAAG,OAAO,WAAW,EAAE,SAAS,CAAC,MAAM,EAAC,GAAG,EAAC,GAAG,EAAC,GAAG,CAAC;0BAIrD,QAAQ,SAAjB,MAAQ,EACgB,UAAU,SAAlC;IAAG,CAAC,GAAG,EAAC,MAAM,GAAG,GAAG,CAAA;CAAG,EACvB,QAAQ,EACE,QAAQ,SAAlB,OAAS,IACT,OAAO,WAAW,EAAE,kBAAkB,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC;wBAYhF,CAAC,IACD,CAAC,SAAS,OAAO,YAAY,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC"}

package/delta/index.js

@@ -0,0 +1,79 @@
+export {
+  TextOp,
+  InsertOp,
+  DeleteOp,
+  ModifyOp,
+  RetainOp,
+  MapInsertOp,
+  MapDeleteOp,
+  MapModifyOp,
+  $textOp,
+  $insertOp,
+  $insertOpWith,
+  $deleteOp,
+  $modifyOp,
+  $modifyOpWith,
+  $anyOp
+} from './ops.js'
+
+export { $delta, $$delta, AbstractDelta, mergeDeltas } from './abstract.js'
+
+// delta array
+export {
+  array,
+  $array,
+  $arrayAny,
+  DeltaArray as Array
+} from './array.js'
+
+export {
+  node,
+  $node,
+  $nodeAny,
+  DeltaNode as Node
+} from './node.js'
+
+// delta map
+export {
+  map,
+  $map,
+  $mapAny,
+  $mapJson,
+  DeltaMap as Map
+} from './map.js'
+
+export {
+  text,
+  $text,
+  $textAny,
+  DeltaTextBuilder as TextBuilder
+} from './text.js'
+
+/**
+ * @typedef {import('./text.js').DeltaText<any>} Text
+ */
+
+/**
+ * @typedef {Array<any> | import('./node.js').DeltaNode<string,any,any,any> } Delta
+ */
+
+/**
+ * @template {string} NodeName
+ * @template {{ [key:string]: any }} Attributes
+ * @template Children
+ * @template {boolean} WithText
+ * @typedef {import('./node.js').RecursiveDeltaNode<NodeName, Attributes, Children, WithText>} RecursiveNode
+ */
+
+export {
+  value,
+  $value,
+  $valueAny,
+  DeltaValue as Value,
+  DeltaValueBuilder as ValueBuilder
+} from './value.js'
+
+/**
+ * @template V
+ * @typedef {V extends import('./value.js').DeltaValue<infer X> ? X : V} ValueUnwrap
+ */

package/delta/map.d.ts

@@ -0,0 +1,230 @@
+export const $mapJson: s.Schema<{
+    [x: string]: ({
+        attribution?: ({
+            insert?: string[] | undefined;
+            insertAt?: number | undefined;
+            delete?: string[] | undefined;
+            deleteAt?: number | undefined;
+            attributes?: {
+                [x: string]: string[];
+            } | undefined;
+            attributesAt?: number | undefined;
+        } & {}) | null | undefined;
+    } & {
+        type: "insert";
+        value: any;
+    }) | ({} & {
+        type: "modify";
+        value: any;
+    }) | ({
+        attribution?: ({
+            insert?: string[] | undefined;
+            insertAt?: number | undefined;
+            delete?: string[] | undefined;
+            deleteAt?: number | undefined;
+            attributes?: {
+                [x: string]: string[];
+            } | undefined;
+            attributesAt?: number | undefined;
+        } & {}) | null | undefined;
+    } & {
+        type: "delete";
+    });
+}>;
+/**
+ * @template {{ [key:string]: ops.DeltaMapOps }} OPS
+ * @typedef {{ [K in keyof OPS]: (Extract<OPS[K],ops.MapInsertOp<any>> extends ops.MapInsertOp<infer V,any> ? ops.MapInsertOp<V, K> : never) | (Extract<OPS[K],ops.MapDeleteOp<any>> extends ops.MapDeleteOp<infer V,any> ? ops.MapDeleteOp<V,K> : never) | (Extract<OPS[K],ops.MapModifyOp<any>> extends ops.MapModifyOp<infer V,any> ? (ops.MapModifyOp<V,K>&OPS[K]) : never) }[keyof OPS]} KeyedOps */
+/**
+ * @template {{ [key: string]: any }} [Vals={[key:string]:any}]
+ * @extends AbstractDelta
+ */
+export class DeltaMap<Vals extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}> extends AbstractDelta {
+    /**
+     * @param {s.Schema<Vals>} $vals
+     */
+    constructor($vals: s.Schema<Vals>);
+    $vals: s.Schema<Partial<s.$ObjectToType<{
+        [key: string]: s.Schema<any>;
+        [key: number]: s.Schema<any>;
+        [key: symbol]: s.Schema<any>;
+    }>>> | s.Schema<Vals>;
+    /**
+     * @type {gmap.GlobalMap<any,ops.DeltaMapOps>}
+     */
+    _changes: gmap.GlobalMap<any, ops.DeltaMapOps>;
+    /**
+     * @type {import('./abstract.js').Attribution?}
+     */
+    usedAttribution: import("./abstract.js").Attribution | null;
+    /**
+     *
+     * Iterate through the changes. There are two approches to iterate through changes. The
+     * following two examples achieve the same thing:
+     *
+     * @example
+     *   d.forEach(op => {
+     *     if (op instanceof dmap.MapInsertOp) {
+     *       console.log('content inserted:', op.key, op.value)
+     *     } else if (op instanceof dmap.MapDeleteOp) {
+     *       console.log('content deleted:', op.key, op.prevValue)
+     *     } else if (op instanceof delta.MapModifyOp) {
+     *       console.log('content was modified:', op.key, op.)
+     *       op.modify
+     *     }
+     *   })
+     *
+     * The second approach doesn't require instanceof checks.
+     *
+     * @example
+     *   d.forEach(null,
+     *     (insertOp) => insertOp.insert,
+     *     (retainOp) => insertOp.retain
+     *     (deleteOp) => insertOp.delete
+     *     (modifyOp) => insertOp.modify
+     *   )
+     *
+     * @template {Vals} ValsX
+     * @param {null|((op:KeyedOps<MapOpsFromValues<ValsX>>)=>void)} changeHandler
+     * @param {null|((insertOp:Extract<KeyedOps<MapOpsFromValues<ValsX>>,ops.MapInsertOp<any,any>>)=>void)} insertHandler
+     * @param {null|((deleteOp:Extract<KeyedOps<MapOpsFromValues<ValsX>>,ops.MapDeleteOp<any,any>>)=>void)} deleteHandler
+     * @param {null|((modifyOp:Extract<KeyedOps<MapOpsFromValues<ValsX>>,ops.MapModifyOp<any,any>>)=>void)} modifyHandler
+     */
+    forEach<ValsX extends Vals>(changeHandler?: null | ((op: KeyedOps<MapOpsFromValues<ValsX>>) => void), insertHandler?: null | ((insertOp: Extract<KeyedOps<MapOpsFromValues<ValsX>>, ops.MapInsertOp<any, any>>) => void), deleteHandler?: null | ((deleteOp: Extract<KeyedOps<MapOpsFromValues<ValsX>>, ops.MapDeleteOp<any, any>>) => void), modifyHandler?: null | ((modifyOp: Extract<KeyedOps<MapOpsFromValues<ValsX>>, ops.MapModifyOp<any, any>>) => void)): void;
+    /**
+     * @template {keyof Vals} K
+     * @param {K} key
+     * @return {MapOpsFromValues<Vals>[K] | undefined}
+     */
+    get<K extends keyof Vals>(key: K): MapOpsFromValues<Vals>[K] | undefined;
+    /**
+     * @param {keyof Vals} key
+     */
+    has(key: keyof Vals): boolean;
+    /**
+     * @param {DeltaMap<any>} other
+     * @return {boolean}
+     */
+    equals(other: DeltaMap<any>): boolean;
+    get size(): number;
+    /**
+     * @return {s.Unwrap<$mapJson>}
+     */
+    toJSON(): s.Unwrap<s.Schema<{
+        [x: string]: ({
+            attribution?: ({
+                insert?: string[] | undefined;
+                insertAt?: number | undefined;
+                delete?: string[] | undefined;
+                deleteAt?: number | undefined;
+                attributes?: {
+                    [x: string]: string[];
+                } | undefined;
+                attributesAt?: number | undefined;
+            } & {}) | null | undefined;
+        } & {
+            type: "insert";
+            value: any;
+        }) | ({} & {
+            type: "modify";
+            value: any;
+        }) | ({
+            attribution?: ({
+                insert?: string[] | undefined;
+                insertAt?: number | undefined;
+                delete?: string[] | undefined;
+                deleteAt?: number | undefined;
+                attributes?: {
+                    [x: string]: string[];
+                } | undefined;
+                attributesAt?: number | undefined;
+            } & {}) | null | undefined;
+        } & {
+            type: "delete";
+        });
+    }>>;
+    /**
+     * @template {keyof Vals} K
+     * @param {K} key
+     * @param {Extract<Vals[K], AbstractDelta>} delta
+     */
+    modify<K extends keyof Vals>(key: K, delta: Extract<Vals[K], AbstractDelta>): this;
+    /**
+     * @template {keyof Vals} K
+     * @param {K} key
+     * @param {Vals[K]} newVal
+     * @param {Vals[K]|undefined} prevValue
+     * @param {import('./abstract.js').Attribution?} attribution
+     */
+    set<K extends keyof Vals>(key: K, newVal: Vals[K], prevValue?: Vals[K] | undefined, attribution?: import("./abstract.js").Attribution | null): this;
+    /**
+     * @param {Partial<Vals>} kv
+     * @param {import('./abstract.js').Attribution?} attribution
+     */
+    setMany(kv: Partial<Vals>, attribution?: import("./abstract.js").Attribution | null): this;
+    /**
+     * @template {keyof Vals} K
+     * @param {K} key
+     * @param {Vals[K]|undefined} prevValue
+     * @param {import('./abstract.js').Attribution?} attribution
+     */
+    delete<K extends keyof Vals>(key: K, prevValue?: Vals[K] | undefined, attribution?: import("./abstract.js").Attribution | null): this;
+    /**
+     * @param {import('./abstract.js').Attribution?} attribution
+     */
+    useAttribution(attribution: import("./abstract.js").Attribution | null): this;
+    /**
+     *
+     * - insert vs delete ⇒ insert takes precedence
+     * - insert vs modify ⇒ insert takes precedence
+     * - insert vs insert ⇒ priority decides
+     * - delete vs modify ⇒ delete takes precedence
+     * - delete vs delete ⇒ current delete op is removed because item has already been deleted
+     * - modify vs modify ⇒ rebase using priority
+     *
+     * @param {DeltaMap<Vals>} other
+     * @param {boolean} priority
+     */
+    rebase(other: DeltaMap<Vals>, priority: boolean): void;
+    /**
+     * @param {DeltaMap<Partial<Vals>>} other
+     */
+    apply(other: DeltaMap<Partial<Vals>>): void;
+    /**
+     * @return {this}
+     */
+    clone(): this;
+    done(): DeltaMap<Vals>;
+    /**
+     * @param {DeltaMap<Partial<Vals>>} other
+     */
+    [traits.EqualityTraitSymbol](other: DeltaMap<Partial<Vals>>): boolean;
+}
+export function map<$Vals extends s.Schema<{
+    [key: string]: any;
+}> | {
+    [key: string]: s.Schema<any>;
+} = s.Schema<{
+    [key: string]: any;
+}>>($vals?: $Vals): DeltaMap<$Vals extends s.Schema<infer $V> ? $V : (s._ObjectDefToSchema<$Vals> extends s.Schema<infer $V> ? $V : never)>;
+export function $map<Vals extends {
+    [key: string]: any;
+}>($vals: s.Schema<Vals>): s.Schema<DeltaMap<Vals>>;
+export const $mapAny: s.Schema<DeltaMap<{
+    [key: string]: any;
+}>>;
+export type KeyedOps<OPS extends {
+    [key: string]: ops.DeltaMapOps;
+}> = { [K in keyof OPS]: (Extract<OPS[K], ops.MapInsertOp<any>> extends ops.MapInsertOp<infer V, any> ? ops.MapInsertOp<V, K> : never) | (Extract<OPS[K], ops.MapDeleteOp<any>> extends ops.MapDeleteOp<infer V, any> ? ops.MapDeleteOp<V, K> : never) | (Extract<OPS[K], ops.MapModifyOp<any>> extends ops.MapModifyOp<infer V, any> ? (ops.MapModifyOp<V, K> & OPS[K]) : never); }[keyof OPS];
+export type MapOpsFromValues<Vals extends {
+    [key: string]: any;
+}> = { [K in keyof Vals]: Vals[K] extends DeltaMap<infer DM> ? ops.MapInsertOp<Vals[K]> | ops.MapDeleteOp<Vals[K]> | ops.MapModifyOp<DeltaMap<DM>> : (ops.MapInsertOp<Exclude<Vals[K], undefined>> | ops.MapDeleteOp<Exclude<Vals[K], undefined>>); };
+import * as s from '../schema.js';
+import { AbstractDelta } from './abstract.js';
+import * as gmap from '../map.js';
+import * as ops from './ops.js';
+import * as traits from '../traits.js';
+//# sourceMappingURL=map.d.ts.map

package/delta/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["map.js"],"names":[],"mappings":"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"}

package/delta/map.js

@@ -0,0 +1,304 @@
+import * as gmap from '../map.js'
+import * as fun from '../function.js'
+import * as traits from '../traits.js'
+import * as s from '../schema.js'
+import * as ops from './ops.js'
+import { AbstractDelta, mergeAttrs, $delta } from './abstract.js'
+
+export const $mapJson = s.$record(s.$string, ops.$deltaMapChangeJson)
+
+/**
+ * @template {{ [key:string]: ops.DeltaMapOps }} OPS
+ * @typedef {{ [K in keyof OPS]: (Extract<OPS[K],ops.MapInsertOp<any>> extends ops.MapInsertOp<infer V,any> ? ops.MapInsertOp<V, K> : never) | (Extract<OPS[K],ops.MapDeleteOp<any>> extends ops.MapDeleteOp<infer V,any> ? ops.MapDeleteOp<V,K> : never) | (Extract<OPS[K],ops.MapModifyOp<any>> extends ops.MapModifyOp<infer V,any> ? (ops.MapModifyOp<V,K>&OPS[K]) : never) }[keyof OPS]} KeyedOps */
+
+/**
+ * @template {{ [key: string]: any }} [Vals={[key:string]:any}]
+ * @extends AbstractDelta
+ */
+export class DeltaMap extends AbstractDelta {
+  /**
+   * @param {s.Schema<Vals>} $vals
+   */
+  constructor ($vals) {
+    super()
+    this.$vals = s.$$object.check($vals) ? $vals.partial : $vals
+    /**
+     * @type {gmap.GlobalMap<any,ops.DeltaMapOps>}
+     */
+    this._changes = gmap.create()
+    /**
+     * @type {import('./abstract.js').Attribution?}
+     */
+    this.usedAttribution = null
+  }
+
+  isEmpty () {
+    return this._changes.size === 0
+  }
+
+  /**
+   *
+   * Iterate through the changes. There are two approches to iterate through changes. The
+   * following two examples achieve the same thing:
+   *
+   * @example
+   *   d.forEach(op => {
+   *     if (op instanceof dmap.MapInsertOp) {
+   *       console.log('content inserted:', op.key, op.value)
+   *     } else if (op instanceof dmap.MapDeleteOp) {
+   *       console.log('content deleted:', op.key, op.prevValue)
+   *     } else if (op instanceof delta.MapModifyOp) {
+   *       console.log('content was modified:', op.key, op.)
+   *       op.modify
+   *     }
+   *   })
+   *
+   * The second approach doesn't require instanceof checks.
+   *
+   * @example
+   *   d.forEach(null,
+   *     (insertOp) => insertOp.insert,
+   *     (retainOp) => insertOp.retain
+   *     (deleteOp) => insertOp.delete
+   *     (modifyOp) => insertOp.modify
+   *   )
+   *
+   * @template {Vals} ValsX
+   * @param {null|((op:KeyedOps<MapOpsFromValues<ValsX>>)=>void)} changeHandler
+   * @param {null|((insertOp:Extract<KeyedOps<MapOpsFromValues<ValsX>>,ops.MapInsertOp<any,any>>)=>void)} insertHandler
+   * @param {null|((deleteOp:Extract<KeyedOps<MapOpsFromValues<ValsX>>,ops.MapDeleteOp<any,any>>)=>void)} deleteHandler
+   * @param {null|((modifyOp:Extract<KeyedOps<MapOpsFromValues<ValsX>>,ops.MapModifyOp<any,any>>)=>void)} modifyHandler
+   */
+  forEach (changeHandler = null, insertHandler = null, deleteHandler = null, modifyHandler = null) {
+    this._changes.forEach((change) => {
+      changeHandler?.(/** @type {any} */ (change))
+      switch (change.constructor) {
+        case ops.MapDeleteOp:
+          deleteHandler?.(/** @type {any} */ (change))
+          break
+        case ops.MapInsertOp:
+          insertHandler?.(/** @type {any} */ (change))
+          break
+        case ops.MapModifyOp:
+          modifyHandler?.(/** @type {any} */ (change))
+          break
+      }
+    })
+  }
+
+  /**
+   * @template {keyof Vals} K
+   * @param {K} key
+   * @return {MapOpsFromValues<Vals>[K] | undefined}
+   */
+  get (key) {
+    return /** @type {(MapOpsFromValues<Vals>[K] & { key:K })|undefined} */ (this._changes.get(key))
+  }
+
+  /**
+   * @param {keyof Vals} key
+   */
+  has (key) {
+    return this._changes.has(key)
+  }
+
+  /**
+   * @param {DeltaMap<any>} other
+   * @return {boolean}
+   */
+  equals (other) {
+    return this[traits.EqualityTraitSymbol](other)
+  }
+
+  get size () {
+    return this._changes.size
+  }
+
+  /**
+   * @return {s.Unwrap<$mapJson>}
+   */
+  toJSON () {
+    /**
+     * @type {s.Unwrap<$mapJson>}
+     */
+    const changes = {}
+    this._changes.forEach((change, key) => {
+      changes[/** @type {string} */ (key)] = change.toJSON()
+    })
+    return changes
+  }
+
+  /**
+   * @template {keyof Vals} K
+   * @param {K} key
+   * @param {Extract<Vals[K], AbstractDelta>} delta
+   */
+  modify (key, delta) {
+    this._changes.set(key, /** @type {any} */ (new ops.MapModifyOp(key, valsKeySchema(this.$vals, key).cast(delta))))
+    return this
+  }
+
+  /**
+   * @template {keyof Vals} K
+   * @param {K} key
+   * @param {Vals[K]} newVal
+   * @param {Vals[K]|undefined} prevValue
+   * @param {import('./abstract.js').Attribution?} attribution
+   */
+  set (key, newVal, prevValue = undefined, attribution = null) {
+    const mergedAttribution = mergeAttrs(this.usedAttribution, attribution)
+    const $v = valsKeySchema(this.$vals, key)
+    this._changes.set(key, /** @type {any} */ (new ops.MapInsertOp(key, $v.cast(newVal), prevValue && $v.cast(prevValue), mergedAttribution)))
+    return this
+  }
+
+  /**
+   * @param {Partial<Vals>} kv
+   * @param {import('./abstract.js').Attribution?} attribution
+   */
+  setMany (kv, attribution = null) {
+    for (const key in kv) {
+      this.set(key, /** @type {Vals[any]} */ (kv[key]), undefined, attribution)
+    }
+    return this
+  }
+
+  /**
+   * @template {keyof Vals} K
+   * @param {K} key
+   * @param {Vals[K]|undefined} prevValue
+   * @param {import('./abstract.js').Attribution?} attribution
+   */
+  delete (key, prevValue = undefined, attribution = null) {
+    const mergedAttribution = mergeAttrs(this.usedAttribution, attribution)
+    this._changes.set(key, /** @type {any} */ (new ops.MapDeleteOp(key, prevValue === undefined ? prevValue : valsKeySchema(this.$vals, key).cast(prevValue), mergedAttribution)))
+    return this
+  }
+
+  /**
+   * @param {import('./abstract.js').Attribution?} attribution
+   */
+  useAttribution (attribution) {
+    this.usedAttribution = attribution
+    return this
+  }
+
+  /**
+   *
+   * - insert vs delete ⇒ insert takes precedence
+   * - insert vs modify ⇒ insert takes precedence
+   * - insert vs insert ⇒ priority decides
+   * - delete vs modify ⇒ delete takes precedence
+   * - delete vs delete ⇒ current delete op is removed because item has already been deleted
+   * - modify vs modify ⇒ rebase using priority
+   *
+   * @param {DeltaMap<Vals>} other
+   * @param {boolean} priority
+   */
+  rebase (other, priority) {
+    this.forEach(null,
+      insertOp => {
+        if (other.get(insertOp.key)?.constructor === ops.MapInsertOp && !priority) {
+          this._changes.delete(insertOp.key)
+        }
+      },
+      deleteOp => {
+        const otherOp = other.get(deleteOp.key)
+        if (otherOp?.constructor === ops.MapInsertOp) {
+          this._changes.delete(otherOp.key)
+        }
+      },
+      modifyOp => {
+        const otherOp = other.get(modifyOp.key)
+        if (otherOp == null) {
+          // nop
+        } else if (otherOp.constructor === ops.MapModifyOp) {
+          modifyOp.value.rebase(otherOp.value, priority)
+        } else {
+          this._changes.delete(otherOp.key)
+        }
+      }
+    )
+  }
+
+  /**
+   * @param {DeltaMap<Partial<Vals>>} other
+   */
+  apply (other) {
+    /** @type {DeltaMap<Vals>} */ (other).forEach(op => {
+      const c = this._changes.get(op.key)
+      if (ops.$modifyOp.check(op)) {
+        if ($delta.check(c?.value)) {
+          /** @type {DeltaMap<any>} */ (c.value).apply(op.value)
+        } else {
+          // then this is a simple modify
+          this._changes.set(op.key, /** @type {any} */ (op))
+        }
+      } else {
+        op.prevValue = c?.value
+        this._changes.set(op.key, /** @type {any} */ (op))
+      }
+    }
+    )
+  }
+
+  /**
+   * @return {this}
+   */
+  clone () {
+    const d = /** @type {this} */ (new DeltaMap(this.$vals))
+    this.forEach(change => {
+      d._changes.set(change.key, /** @type {any} */ (change))
+    })
+    d.origin = this.origin
+    d.isDiff = this.isDiff
+    return d
+  }
+
+  done () {
+    return /** @type {DeltaMap<Vals>} */ (this)
+  }
+
+  /**
+   * @param {DeltaMap<Partial<Vals>>} other
+   */
+  [traits.EqualityTraitSymbol] (other) {
+    return fun.equalityDeep(this._changes, other._changes)
+  }
+}
+
+/**
+ * @template {s.Schema<{ [Key:string]: ops.DeltaMapOps }>} OPS
+ * @template {keyof s.Unwrap<OPS>} K
+ * @param {OPS} $ops
+ * @param {K} k
+ * @return {s.Schema<s.Unwrap<OPS>[K]>}
+ */
+const valsKeySchema = ($ops, k) => s.$$object.check($ops) ? ($ops.shape[k] || s.$never) : ((s.$$record.check($ops) && $ops.shape.keys.check(k)) ? ($ops.shape.values) : s.$never)
+
+/**
+ * @template {{ [key:string]: any }} Vals
+ * @typedef {{ [K in keyof Vals]: Vals[K] extends DeltaMap<infer DM> ? ops.MapInsertOp<Vals[K]>|ops.MapDeleteOp<Vals[K]>|ops.MapModifyOp<DeltaMap<DM>> : (ops.MapInsertOp<Exclude<Vals[K],undefined>>|ops.MapDeleteOp<Exclude<Vals[K],undefined>>) }} MapOpsFromValues
+ */
+
+/**
+ * Create a new DeltaMap, optionally supply a schema.
+ *
+ * @template {s.Schema<{ [key:string]: any }> | { [key:string]: s.Schema<any> }} [$Vals=s.Schema<{ [key:string]: any }>]
+ * @param {$Vals} $vals
+ * @return {DeltaMap<$Vals extends s.Schema<infer $V> ? $V : (s._ObjectDefToSchema<$Vals> extends s.Schema<infer $V> ? $V : never)>}
+ */
+export const map = ($vals = /** @type {any} */ (s.$record(s.$string, s.$any))) => /** @type {any} */ (new DeltaMap(/** @type {any} */ (s.$$schema.check($vals) ? $vals : s.$object($vals))))
+
+/**
+ * @template {{ [key:string]: any }} Vals
+ * @param {s.Schema<Vals>} $vals
+ * @return {s.Schema<DeltaMap<Vals>>}
+ */
+export const $map = $vals => {
+  const $valsPartial = s.$$object.check($vals) ? $vals.partial : $vals
+  return /** @type {any} */ (s.$instanceOf(DeltaMap, o => Array.from(o._changes.entries()).every(([k, op]) =>
+    !ops.$insertOp.check(op) || $valsPartial.check({ [k]: op.value })
+  )))
+}
+export const $mapAny = s.$instanceOf(DeltaMap)