@homeostate/core 0.0.0 → 0.1.2

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @homeostate/core
+
+## 0.1.2
+
+### Patch Changes
+
+- 30abf27: Remove draft release warnings, update docs links
+
+## 0.1.1
+
+### Patch Changes
+
+- 8bd452e: Init release

package/README.md

@@ -1,24 +1,51 @@
 # @homeostate/core
 
-> **Draft / placeholder release.** `0.0.0` reserves the name while the API is still
-> being designed. Nothing here is stable — do not depend on it yet.
-
-State-manager agnostic sync engine between a store adapter and a [Yjs](https://github.com/yjs/yjs) document.
+State-manager and CRDT-backend agnostic sync engine. It keeps a store, reached through a
+`StoreAdapter`, in sync with a `CrdtBackend` such as
+[`@homeostate/crdt-yjs`](https://github.com/mixedrays/homeostate/tree/main/packages/crdt-yjs),
+[`@homeostate/crdt-loro`](https://github.com/mixedrays/homeostate/tree/main/packages/crdt-loro), or
+[`@homeostate/crdt-automerge`](https://github.com/mixedrays/homeostate/tree/main/packages/crdt-automerge).
 
 ## Install
 
 ```bash
-npm install @homeostate/core yjs
+npm install @homeostate/core @homeostate/crdt-yjs yjs
 ```
 
-`yjs` is a peer dependency.
+`@homeostate/core` has no runtime dependencies; pick a backend package for the CRDT library
+you use.
 
 ## Usage
 
 ```ts
-import { createSyncEngine } from '@homeostate/core';
+import { createSyncEngine } from "@homeostate/core";
+import { createYjsBackend } from "@homeostate/crdt-yjs";
+
+const engine = createSyncEngine(createYjsBackend(doc, "shared"), adapter, {
+  seed: "if-empty",
+});
+engine.connect();
 ```
 
+`createMemoryBackend()` is a plain-JSON backend without replication, meant for tests.
+`getChanges` is exported so a backend can turn a `write(next)` into fine-grained operations.
+
+## Connecting
+
+`connect()` reconciles the store and the backend per key, over the view the `filter` allows:
+
+- A key the backend holds wins over the store's value, so a peer joining a populated room
+  adopts it rather than overwriting it.
+- A synced key the backend does not hold stays in the store. With the default
+  `seed: 'if-empty'` those keys are written into the backend in one write; with
+  `seed: 'never'` they are left to the next local change.
+- Keys the `filter` excludes are never read into the store and never written out.
+
+Afterwards the backend owns the synced document: each local change replaces it with the
+store's filtered state, and a key removed from the backend is removed from the store. A
+reconnect adopts the backend again, so edits made while disconnected are dropped unless
+they are still in the store's local-only keys.
+
 See the [repository](https://github.com/mixedrays/homeostate) for the full workspace,
 store adapters, and a runnable playground.
 

package/THIRD_PARTY_NOTICES.md

@@ -30,4 +30,4 @@ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-```
+```

package/dist/apply.d.ts

@@ -0,0 +1,37 @@
+import { type Change } from "./change.js";
+/**
+ * How one store writes into its containers. `applyChanges` decides *what* to write; an
+ * implementation of this decides *how*, so the same edit script drives a MobX observable
+ * tree, a Valtio proxy, or a plain object.
+ *
+ * Every method receives a container that already lives in the store, never a copy.
+ */
+export interface ApplyOps {
+    /** Assign `value` at `key`, creating the property if the target is a record. */
+    set(target: object, key: string | number, value: unknown): void;
+    /** Remove the record property `key`. */
+    remove(target: object, key: string): void;
+    /** `Array.prototype.splice`: drop `deleteCount` elements at `index`, then add `inserted`. */
+    splice(target: unknown[], index: number, deleteCount: number, inserted: unknown[]): void;
+}
+/**
+ * Revises `value` by the character-level edit script `changes`, which is what `getChanges`
+ * returns for two strings. Each index addresses the string as revised by the steps before it.
+ */
+export declare const applyStringChanges: (value: string, changes: Change[]) => string;
+/**
+ * Applies `changes` to `target` in place, mutating only the paths the edit script names.
+ * Everything else keeps its identity, which is what fine-grained stores react to.
+ *
+ * `changes` must be `getChanges(before, after)` where `before` describes the shape `target`
+ * currently holds — an adapter gets that by diffing against the snapshot it last handed out.
+ * A `PENDING` step carries no replacement value, so it can only be followed by recursing into
+ * the container already there; a target that does not mirror `before` leaves such a step
+ * unapplied rather than writing something wrong.
+ *
+ * @param target The container to mutate — a record, or an array for a positional edit script.
+ * @param changes The edit script to apply, in order.
+ * @param ops How this store writes; see {@link ApplyOps}.
+ */
+export declare const applyChanges: (target: object, changes: Change[], ops: ApplyOps) => void;
+//# sourceMappingURL=apply.d.ts.map

package/dist/apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../src/apply.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAItD;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB,gFAAgF;IAChF,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAChE,wCAAwC;IACxC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1C,6FAA6F;IAC7F,MAAM,CACJ,MAAM,EAAE,OAAO,EAAE,EACjB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,OAAO,EAAE,GAClB,IAAI,CAAC;CACT;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,MAAM,EAAE,SAAS,MAAM,EAAE,KAAG,MAQ3D,CAAC;AAEZ;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,GACvB,QAAQ,MAAM,EACd,SAAS,MAAM,EAAE,EACjB,KAAK,QAAQ,KACZ,IA6BF,CAAC"}

package/dist/apply.js

@@ -0,0 +1,58 @@
+import { ChangeType } from "./change.js";
+/**
+ * Revises `value` by the character-level edit script `changes`, which is what `getChanges`
+ * returns for two strings. Each index addresses the string as revised by the steps before it.
+ */
+export const applyStringChanges = (value, changes) => changes.reduce((revised, [type, index, inserted]) => {
+    const at = index;
+    if (type === ChangeType.INSERT)
+        return revised.slice(0, at) + inserted + revised.slice(at);
+    if (type === ChangeType.DELETE)
+        return revised.slice(0, at) + revised.slice(at + 1);
+    return revised;
+}, value);
+/**
+ * Applies `changes` to `target` in place, mutating only the paths the edit script names.
+ * Everything else keeps its identity, which is what fine-grained stores react to.
+ *
+ * `changes` must be `getChanges(before, after)` where `before` describes the shape `target`
+ * currently holds — an adapter gets that by diffing against the snapshot it last handed out.
+ * A `PENDING` step carries no replacement value, so it can only be followed by recursing into
+ * the container already there; a target that does not mirror `before` leaves such a step
+ * unapplied rather than writing something wrong.
+ *
+ * @param target The container to mutate — a record, or an array for a positional edit script.
+ * @param changes The edit script to apply, in order.
+ * @param ops How this store writes; see {@link ApplyOps}.
+ */
+export const applyChanges = (target, changes, ops) => {
+    const array = Array.isArray(target) ? target : null;
+    for (const [type, key, value] of changes) {
+        switch (type) {
+            case ChangeType.PENDING: {
+                const child = target[key];
+                if (typeof child === "string")
+                    ops.set(target, key, applyStringChanges(child, value));
+                else if (child !== null && typeof child === "object")
+                    applyChanges(child, value, ops);
+                break;
+            }
+            case ChangeType.DELETE:
+                if (array)
+                    ops.splice(array, key, 1, []);
+                else
+                    ops.remove(target, key);
+                break;
+            case ChangeType.INSERT:
+                if (array)
+                    ops.splice(array, key, 0, [value]);
+                else
+                    ops.set(target, key, value);
+                break;
+            case ChangeType.UPDATE:
+                ops.set(target, key, value);
+                break;
+        }
+    }
+};
+//# sourceMappingURL=apply.js.map

package/dist/apply.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.js","sourceRoot":"","sources":["../src/apply.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAe,MAAM,aAAa,CAAC;AAyBtD;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,KAAa,EAAE,OAAiB,EAAU,EAAE,CAC7E,OAAO,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,QAAQ,CAAC,EAAE,EAAE;IAClD,MAAM,EAAE,GAAG,KAAe,CAAC;IAC3B,IAAI,IAAI,KAAK,UAAU,CAAC,MAAM;QAC5B,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAI,QAAmB,GAAG,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACzE,IAAI,IAAI,KAAK,UAAU,CAAC,MAAM;QAC5B,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;IACtD,OAAO,OAAO,CAAC;AACjB,CAAC,EAAE,KAAK,CAAC,CAAC;AAEZ;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAC1B,MAAc,EACd,OAAiB,EACjB,GAAa,EACP,EAAE;IACR,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAE,MAAoB,CAAC,CAAC,CAAC,IAAI,CAAC;IAEnE,KAAK,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,IAAI,OAAO,EAAE,CAAC;QACzC,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;gBACxB,MAAM,KAAK,GAAI,MAAgB,CAAC,GAAa,CAAC,CAAC;gBAC/C,IAAI,OAAO,KAAK,KAAK,QAAQ;oBAC3B,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,EAAE,kBAAkB,CAAC,KAAK,EAAE,KAAiB,CAAC,CAAC,CAAC;qBAChE,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;oBAClD,YAAY,CAAC,KAAK,EAAE,KAAiB,EAAE,GAAG,CAAC,CAAC;gBAC9C,MAAM;YACR,CAAC;YAED,KAAK,UAAU,CAAC,MAAM;gBACpB,IAAI,KAAK;oBAAE,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,GAAa,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;;oBAC9C,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,GAAa,CAAC,CAAC;gBACvC,MAAM;YAER,KAAK,UAAU,CAAC,MAAM;gBACpB,IAAI,KAAK;oBAAE,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,GAAa,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;;oBACnD,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;gBACjC,MAAM;YAER,KAAK,UAAU,CAAC,MAAM;gBACpB,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;gBAC5B,MAAM;QACV,CAAC;IACH,CAAC;AACH,CAAC,CAAC"}

package/dist/change.d.ts

@@ -2,8 +2,6 @@
  * Describes the change that needs to be made.
  */
 export declare enum ChangeType {
-    /** No change. */
-    NONE = "none",
     /** A value was inserted. */
     INSERT = "insert",
     /** A value was replaced. */
@@ -14,7 +12,12 @@ export declare enum ChangeType {
     PENDING = "pending"
 }
 /**
- * A record that documents a change to an entry in an array or object.
+ * One step in turning a container into another: `[type, key, value]`.
+ *
+ * Steps apply in order. A numeric key addresses the array or string as revised by the
+ * steps before it, so appliers never sort or clamp. `value` is the inserted or replacing
+ * value (a string insert may carry several characters), `undefined` for a delete, and the
+ * nested `Change[]` for a pending entry.
  */
 export type Change = [ChangeType, string | number, unknown];
 //# sourceMappingURL=change.d.ts.map

package/dist/change.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"change.d.ts","sourceRoot":"","sources":["../src/change.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,UAAU;IACpB,iBAAiB;IACjB,IAAI,SAAS;IACb,4BAA4B;IAC5B,MAAM,WAAW;IACjB,4BAA4B;IAC5B,MAAM,WAAW;IACjB,2BAA2B;IAC3B,MAAM,WAAW;IACjB,uEAAuE;IACvE,OAAO,YAAY;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,CAAC"}
+{"version":3,"file":"change.d.ts","sourceRoot":"","sources":["../src/change.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,UAAU;IACpB,4BAA4B;IAC5B,MAAM,WAAW;IACjB,4BAA4B;IAC5B,MAAM,WAAW;IACjB,2BAA2B;IAC3B,MAAM,WAAW;IACjB,uEAAuE;IACvE,OAAO,YAAY;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,CAAC"}

package/dist/change.js

@@ -3,8 +3,6 @@
  */
 export var ChangeType;
 (function (ChangeType) {
-    /** No change. */
-    ChangeType["NONE"] = "none";
     /** A value was inserted. */
     ChangeType["INSERT"] = "insert";
     /** A value was replaced. */

package/dist/change.js.map

@@ -1 +1 @@
-{"version":3,"file":"change.js","sourceRoot":"","sources":["../src/change.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAN,IAAY,UAWX;AAXD,WAAY,UAAU;IACpB,iBAAiB;IACjB,2BAAa,CAAA;IACb,4BAA4B;IAC5B,+BAAiB,CAAA;IACjB,4BAA4B;IAC5B,+BAAiB,CAAA;IACjB,2BAA2B;IAC3B,+BAAiB,CAAA;IACjB,uEAAuE;IACvE,iCAAmB,CAAA;AACrB,CAAC,EAXW,UAAU,KAAV,UAAU,QAWrB"}
+{"version":3,"file":"change.js","sourceRoot":"","sources":["../src/change.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAN,IAAY,UASX;AATD,WAAY,UAAU;IACpB,4BAA4B;IAC5B,+BAAiB,CAAA;IACjB,4BAA4B;IAC5B,+BAAiB,CAAA;IACjB,2BAA2B;IAC3B,+BAAiB,CAAA;IACjB,uEAAuE;IACvE,iCAAmB,CAAA;AACrB,CAAC,EATW,UAAU,KAAV,UAAU,QASrB"}

package/dist/diff.d.ts

@@ -1,5 +1,4 @@
-import { type Change } from './change.js';
-type Diffable = Record<string, unknown> | Array<unknown> | string;
+import { type Change } from "./change.js";
+export type Diffable = Record<string, unknown> | Array<unknown> | string;
 export declare const getChanges: (a: Diffable, b: Diffable) => Change[];
-export {};
 //# sourceMappingURL=diff.d.ts.map

package/dist/diff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../src/diff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAEtD,KAAK,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC;AAYlE,eAAO,MAAM,UAAU,GAAI,GAAG,QAAQ,EAAE,GAAG,QAAQ,KAAG,MAAM,EAK3D,CAAC"}
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../src/diff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAEtD,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC;AAmCzE,eAAO,MAAM,UAAU,GAAI,GAAG,QAAQ,EAAE,GAAG,QAAQ,KAAG,MAAM,EAK3D,CAAC"}

package/dist/diff.js

@@ -1,202 +1,192 @@
-import { ChangeType } from './change.js';
-const isDiffable = (v) => isArray(v) || isString(v) || (v !== null && typeof v === 'object');
-const isArray = (d) => d instanceof Array;
-const isString = (d) => typeof d === 'string';
-const isRecord = (d) => !isArray(d) && !isString(d);
+import { ChangeType } from "./change.js";
+const isArray = (value) => Array.isArray(value);
+const isString = (value) => typeof value === "string";
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const isDiffable = (value) => isArray(value) || isString(value) || isRecord(value);
+const isSameKind = (a, b) => isString(a) ? isString(b) : isArray(a) ? isArray(b) : isRecord(b);
+const nestedChanges = (a, b) => isDiffable(a) && isDiffable(b) && isSameKind(a, b) ? getChanges(a, b) : null;
+const deepEqual = (a, b) => {
+    if (a === b)
+        return true;
+    if (isArray(a) && isArray(b))
+        return (a.length === b.length && a.every((value, i) => deepEqual(value, b[i])));
+    if (isRecord(a) && isRecord(b)) {
+        const keys = Object.keys(a);
+        return (keys.length === Object.keys(b).length &&
+            keys.every((key) => key in b && deepEqual(a[key], b[key])));
+    }
+    return false;
+};
 export const getChanges = (a, b) => {
     if (isString(a) && isString(b))
         return getStringChanges(a, b);
-    else if (isArray(a) && isArray(b))
+    if (isArray(a) && isArray(b))
         return getArrayChanges(a, b);
-    else if (isRecord(a) && isRecord(b))
+    if (isRecord(a) && isRecord(b))
         return getRecordChanges(a, b);
-    else
-        return [];
+    return [];
+};
+const sharesCharacter = (a, b) => {
+    const characters = new Set(a);
+    for (const character of b)
+        if (characters.has(character))
+            return true;
+    return false;
 };
 const getStringChanges = (a, b) => {
     if (a === b)
         return [];
-    else if (a.length === 0) {
-        return b
-            .split('')
-            .map((character, index) => [ChangeType.INSERT, index, character]);
-    }
-    else if (b.length === 0) {
-        return a.split('').map(() => [ChangeType.DELETE, 0, undefined]);
+    if (!sharesCharacter(a, b)) {
+        const deletes = Array.from(a, () => [
+            ChangeType.DELETE,
+            0,
+            undefined,
+        ]);
+        return b.length === 0 ? deletes : [...deletes, [ChangeType.INSERT, 0, b]];
     }
-    else if (!hasCommonSubsequence(a, b)) {
-        const deletes = a
-            .split('')
-            .map(() => [ChangeType.DELETE, 0, undefined]);
-        const inserts = b
-            .split('')
-            .map((character, index) => [ChangeType.INSERT, index, character]);
-        return deletes.concat(inserts);
-    }
-    else {
-        const m = a.length, n = b.length;
-        const reverse = m >= n;
-        return reverse ? _diffText(b, a, reverse) : _diffText(a, b, reverse);
+    const changes = [];
+    let index = 0;
+    for (const { step, b: position } of editScript(a, b, (x, y) => x === y)) {
+        if (step === "eq")
+            index++;
+        else if (step === "del")
+            changes.push([ChangeType.DELETE, index, undefined]);
+        else {
+            const last = changes.length > 0 ? changes[changes.length - 1] : undefined;
+            if (last !== undefined &&
+                last[0] === ChangeType.INSERT &&
+                last[1] + last[2].length === index) {
+                last[2] = last[2] + b[position];
+            }
+            else
+                changes.push([ChangeType.INSERT, index, b[position]]);
+            index++;
+        }
     }
+    return changes;
 };
 const getArrayChanges = (a, b) => {
-    const changeList = [];
-    let finalIndices = 0;
-    let bOffset = 0;
-    for (let index = 0; index < a.length; index++) {
-        const value = a[index];
-        const bIndex = index + bOffset;
-        if (b[bIndex] === undefined)
-            changeList.push([ChangeType.DELETE, index, undefined]);
-        else if (isDiffable(value) && isDiffable(b[bIndex])) {
-            const currentDiff = getChanges(value, b[bIndex]);
-            const nextDiff = typeof b[bIndex + 1] === 'undefined'
-                ? []
-                : getChanges(value, b[bIndex + 1]);
-            if (typeof b[bIndex + 1] !== 'undefined' && nextDiff.length === 0) {
-                changeList.push([ChangeType.INSERT, index, b[bIndex]]);
-                finalIndices += 2;
-                bOffset++;
-            }
-            else if (currentDiff.length !== 0) {
-                changeList.push([ChangeType.PENDING, index, currentDiff]);
-                finalIndices++;
-            }
-            else
-                finalIndices++;
+    const changes = [];
+    let index = 0;
+    let deleted = [];
+    let inserted = [];
+    const flush = () => {
+        const pairs = Math.min(deleted.length, inserted.length);
+        for (let i = 0; i < pairs; i++) {
+            const next = b[inserted[i]];
+            const nested = nestedChanges(a[deleted[i]], next);
+            if (nested === null)
+                changes.push([ChangeType.UPDATE, index, next]);
+            else if (nested.length > 0)
+                changes.push([ChangeType.PENDING, index, nested]);
+            index++;
         }
-        else if (value !== b[bIndex] && value === b[bIndex + 1]) {
-            changeList.push([ChangeType.INSERT, bIndex, b[bIndex]]);
-            finalIndices += 2;
-            bOffset++;
+        for (let i = pairs; i < deleted.length; i++)
+            changes.push([ChangeType.DELETE, index, undefined]);
+        for (let i = pairs; i < inserted.length; i++) {
+            changes.push([ChangeType.INSERT, index, b[inserted[i]]]);
+            index++;
         }
-        else if (value !== b[bIndex] && value !== b[bIndex + 1]) {
-            changeList.push([ChangeType.UPDATE, bIndex, b[bIndex]]);
-            finalIndices++;
+        deleted = [];
+        inserted = [];
+    };
+    for (const { step, a: from, b: to } of editScript(a, b, deepEqual)) {
+        if (step === "del")
+            deleted.push(from);
+        else if (step === "ins")
+            inserted.push(to);
+        else {
+            flush();
+            index++;
         }
-        else
-            finalIndices++;
-    }
-    if (finalIndices < b.length) {
-        b.slice(a.length).forEach((value, index) => changeList.push([ChangeType.INSERT, finalIndices + index, value]));
     }
-    return changeList;
+    flush();
+    return changes;
 };
 const getRecordChanges = (a, b) => {
-    const changeList = [];
-    Object.entries(a).forEach(([property, value]) => {
-        if (!(property in b) && !(value instanceof Function))
-            changeList.push([ChangeType.DELETE, property, undefined]);
-    });
-    Object.entries(b).forEach(([property, value]) => {
+    const changes = [];
+    for (const property of Object.keys(a))
+        if (!(property in b))
+            changes.push([ChangeType.DELETE, property, undefined]);
+    for (const [property, value] of Object.entries(b)) {
         if (!(property in a))
-            changeList.push([ChangeType.INSERT, property, value]);
-        else if (isDiffable(a[property]) && isDiffable(value)) {
-            const d = getChanges(a[property], value);
-            if (d.length !== 0)
-                changeList.push([ChangeType.PENDING, property, d]);
+            changes.push([ChangeType.INSERT, property, value]);
+        else {
+            const nested = nestedChanges(a[property], value);
+            if (nested === null) {
+                if (a[property] !== value)
+                    changes.push([ChangeType.UPDATE, property, value]);
+            }
+            else if (nested.length > 0)
+                changes.push([ChangeType.PENDING, property, nested]);
         }
-        else if (a[property] !== value)
-            changeList.push([ChangeType.UPDATE, property, value]);
-    });
-    return changeList;
-};
-const hasCommonSubsequence = (a, b) => {
-    const alphabetOfA = a.split('');
-    const alphabetOfB = b.split('');
-    let hasCommonSubsequence = false;
-    for (const c of alphabetOfA)
-        hasCommonSubsequence = hasCommonSubsequence || alphabetOfB.includes(c);
-    return hasCommonSubsequence;
+    }
+    return changes;
 };
 /**
- * An adaptation of Wu et al. O(NP) text diff. (See docs/text-diff)
- *
- * Credit to [this JavaScript implementation](https://github.com/cubicdaiya/onp/blob/master/javascript/onp.js).
- *
- * @param a The old string to transform.
- * @param b The new string to transform to.
- * @param isReversed Whether or not a or b have been swapped.
- * @returns A list of changes that that turn a into b.
+ * Shortest edit script from `a` to `b` by Wu et al.'s O(NP) algorithm. Adapted from
+ * https://github.com/cubicdaiya/onp/blob/master/javascript/onp.js.
  */
-const _diffText = (a, b, isReversed) => {
-    const m = a.length, n = b.length;
-    const offset = m;
+const editScript = (a, b, equal) => {
+    const swapped = a.length > b.length;
+    const s = swapped ? b : a;
+    const t = swapped ? a : b;
+    const m = s.length;
+    const n = t.length;
     const delta = n - m;
-    const size = m + n + 1;
-    const frontierPoints = [];
-    for (let i = 0; i < size; i++)
-        frontierPoints[i] = -1;
-    const path = [];
-    for (let i = 0; i < size; i++)
-        path[i] = -1;
-    const pathPositions = [];
-    const snake = (k, p, q) => {
-        let y = Math.max(p, q);
+    const offset = m + 1;
+    const furthest = new Array(m + n + 3).fill(-1);
+    const pointAt = new Array(m + n + 3).fill(-1);
+    const points = [];
+    const snake = (k) => {
+        const fromBelow = furthest[k + offset - 1] + 1;
+        const fromAbove = furthest[k + offset + 1];
+        let y = Math.max(fromBelow, fromAbove);
         let x = y - k;
-        while (x < m && y < n && a[x] === b[y]) {
+        while (x < m && y < n && equal(s[x], t[y])) {
             x++;
             y++;
         }
-        path[k + offset] = pathPositions.length;
-        pathPositions[pathPositions.length] = {
-            x: x,
-            y: y,
-            k: p > q ? path[k + offset - 1] : path[k + offset + 1],
-        };
-        return y;
+        furthest[k + offset] = y;
+        pointAt[k + offset] = points.length;
+        points.push({
+            x,
+            y,
+            prev: fromBelow > fromAbove
+                ? pointAt[k + offset - 1]
+                : pointAt[k + offset + 1],
+        });
     };
-    let p = -1;
-    do {
-        p++;
-        for (let k = -p; k < delta; k++) {
-            frontierPoints[k + offset] = snake(k, frontierPoints[k + offset - 1] + 1, frontierPoints[k + offset + 1]);
+    for (let p = 0; furthest[delta + offset] !== n; p++) {
+        for (let k = -p; k < delta; k++)
+            snake(k);
+        for (let k = delta + p; k > delta; k--)
+            snake(k);
+        snake(delta);
+    }
+    const path = [];
+    for (let i = pointAt[delta + offset]; i !== -1; i = points[i].prev)
+        path.push(points[i]);
+    const ops = [];
+    let x = 0;
+    let y = 0;
+    const op = (step) => swapped ? { step, a: y, b: x } : { step, a: x, b: y };
+    for (let i = path.length - 1; i >= 0; i--) {
+        const end = path[i];
+        if (end.y - end.x > y - x) {
+            ops.push(op(swapped ? "del" : "ins"));
+            y++;
         }
-        for (let k = delta + p; k > delta; k--) {
-            frontierPoints[k + offset] = snake(k, frontierPoints[k + offset - 1] + 1, frontierPoints[k + offset + 1]);
+        else if (end.y - end.x < y - x) {
+            ops.push(op(swapped ? "ins" : "del"));
+            x++;
         }
-        frontierPoints[delta + offset] = snake(delta, frontierPoints[delta + offset - 1] + 1, frontierPoints[delta + offset + 1]);
-    } while (frontierPoints[delta + offset] !== n);
-    let k = path[delta + offset];
-    const editPath = [];
-    while (k !== -1) {
-        editPath[editPath.length] = {
-            x: pathPositions[k].x,
-            y: pathPositions[k].y,
-        };
-        k = pathPositions[k].k;
-    }
-    const changeList = [];
-    let x = 0, y = 0, index = -1;
-    for (let i = editPath.length - 1; i >= 0; i--) {
-        while (x <= editPath[i].x || y <= editPath[i].y) {
-            if (editPath[i].y - editPath[i].x > y - x) {
-                if (isReversed) {
-                    changeList[changeList.length] = [ChangeType.DELETE, index, undefined];
-                }
-                else {
-                    changeList[changeList.length] = [ChangeType.INSERT, index, b[y - 1]];
-                    index++;
-                }
-                y++;
-            }
-            else if (editPath[i].y - editPath[i].x < y - x) {
-                if (isReversed) {
-                    changeList[changeList.length] = [ChangeType.INSERT, index, a[x - 1]];
-                    index++;
-                }
-                else {
-                    changeList[changeList.length] = [ChangeType.DELETE, index, undefined];
-                }
-                x++;
-            }
-            else {
-                x++;
-                y++;
-                index++;
-            }
+        while (x < end.x) {
+            ops.push(op("eq"));
+            x++;
+            y++;
         }
     }
-    return changeList;
+    return ops;
 };
 //# sourceMappingURL=diff.js.map