edytor 6.0.0 → 7.0.0

package/dist/crdt/vendor/yjs/UPSTREAM.md

@@ -33,7 +33,7 @@ is no longer a dependency of any kind: `tests/packed-consumer/smoke.js` and
 ## Layout
 
 ```text
-src/        upstream src/, plus patches YP1 (import specifiers), YP4, YP5, YP7, YP8 (pruning), YP9–YP15, YP16 (no delta layer), YP17 (one update encoding), YP18 (no undo manager), YP19 (only what edytor calls), YP20 (hold records), YP21 (claim items), YP22 (move records), YP23 (a block set's trim), YP24 (a string table per update), YP25 (paired marks written in parts), YP26 (a client table per update), YP27 (the parent kind in the info byte), YP28 (large integers in content values), YP29 (a collected mark or claim keeps its class) and YP30 (a transaction's `beforeCommit`)
+src/        upstream src/, plus patches YP1 (import specifiers), YP4, YP5, YP7, YP8 (pruning), YP9–YP15, YP16 (no delta layer), YP17 (one update encoding), YP18 (no undo manager), YP19 (only what edytor calls), YP20 (hold records), YP21 (claim items), YP22 (move records), YP23 (a block set's trim), YP24 (a string table per update), YP25 (paired marks written in parts), YP26 (a client table per update), YP27 (the parent kind in the info byte), YP28 (large integers in content values), YP29 (a collected mark or claim keeps its class), YP30 (a transaction's `beforeCommit`), YP31 (a hold inside a nested node holds nothing), YP32 (a delete that proposes), YP33 (one transaction log) and YP34 (an update read at an earlier state)
 global.d.ts upstream global.d.ts, plus patches YP1, YP8 and YP19
 dts/        generated TypeScript declarations (not upstream source — see below)
 LICENSE     upstream MIT license, verbatim
@@ -1022,7 +1022,8 @@ Patch (new code delimited by `// YP20 begin` / `// YP20 end`, edits marked `// Y
   text a room lost is stored and acknowledged at once. A GC struct takes
   nothing. An item that starts or stops being held (and is not removed)
   moves its parent's length, drops its search markers, joins
-  `transaction.changed` and is logged in `transaction.holds`
+  `transaction.changed` and is logged in `transaction.holds` (since YP33:
+  `transaction.log`, kind 1)
   (`client, clock, ±len`, in order: the index's edits).
 - **`YNode#delete(index, length, into, fresh)`**: with `into` (the records
   list) the live units are held by one record appended there instead of
@@ -1038,7 +1039,8 @@ Edytor side: a text delete passes the records list (`crdt/text/model.ts`
 copies the record (never the text), an undo of typing holds the typed text,
 a dropped step removes what this writer's records of it hold
 (`hist.delete-marks.release`); the purge removes what a record older than
-the horizon holds; the index folds `transaction.holds`. Removed:
+the horizon holds; the index folds `transaction.holds` (since YP33, the one
+`transaction.log`). Removed:
 `bindCrdt(Y).doc.keepCopies`, `PurgeReport.records`, the restoration
 records root, the engine object's `ContentAny`.
 
@@ -1172,7 +1174,8 @@ Patch (new code delimited by `// YP22 begin` / `// YP22 end`, edits marked `// Y
   pending holds only. A
   unit that starts or stops being moved (and is not gone) moves
   its home sequence's length and drops its search markers; one whose mover
-  changed is logged in `transaction.moves` (`client, clock, len`, in
+  changed is logged in `transaction.moves` (since YP33: `transaction.log`,
+  kind 2; `client, clock, len`, in
   order), and its home and its new mover's sequences are marked changed.
 - **`doc._clock`** (was YP13's `_markClock`): the greatest Lamport
   timestamp of a mark or a move this document integrated; a local mark or
@@ -1537,7 +1540,7 @@ Patch (new code delimited by `// YP31 begin` / `// YP31 end`, edits marked `// Y
   records list, `textdel`). `ContentHold#integrate` and `ContentHold#delete`
   hold and release only then; inside a nested node's sequence the record is
   a list of ids: it moves no length, waits in no `pendingHolds`, logs
-  nothing in `transaction.holds`, and its delete (an undo, a reviewer's
+  nothing in `transaction.holds` (YP33: `transaction.log`), and its delete (an undo, a reviewer's
   withdrawal, its node's delete) releases nothing. `YNode#hold(ids)` on a
   nested node appends one such list entry.
 
@@ -1598,6 +1601,99 @@ schedules with the index's self-checks on), `suggesting-input.test.tsx`
 (typing over a selection, a paste, Backspace and Delete over struck text),
 the YP20 rows, the upstream suite unchanged.
 
+### YP33 — one log of what a transaction did to items (`src/utils/Transaction.js`, `src/structs/Item.js`)
+
+Reason: edytor's index folds each transaction into its derived facts (rows,
+streams, slots, placements) once at commit and, for read-your-writes, over
+the part of an open transaction a read has not folded. The engine logged
+the holds (YP20, `transaction.holds`) and the mover changes (YP22,
+`transaction.moves`) in order, but the inserts and removals only as id sets,
+so the fold reconstructed them: it kept, per open transaction, copies of the
+insert and delete sets and diffed them at every read, walked both sets'
+structs again for the texts and again for the sequences, and decided by set
+membership which edits cancelled within a fold (about 1.6 KB minified in
+every app, `makeEditIndex` and `syncPending` in `crdt/text/index/build.ts`).
+The engine now logs the edits in the same log as the holds and the moves,
+and the fold reads one log from a cursor. In memory only: nothing encoded,
+no schema change.
+
+Patch (new code delimited by `// YP33 begin` / `// YP33 end`, edits marked `// YP33`):
+
+- **`transaction.log`** (replaces YP20's `holds` and YP22's `moves`): per
+  run of one writer's items `kind, client, clock, len`, in the order the
+  transaction did them; an item that continues the last entry (its kind,
+  its client, the next clock, its sign) extends it, so a bulk insert or
+  delete is a few entries, as the id sets' ranges were. Kind 0, an edit:
+  `Item#integrate` logs `+length` before its content integrates (a node's
+  children follow it; nothing for an item integrated removed, a
+  `ContentDeleted`), `Item#delete` `-length`; kind 1,
+  a hold record's change of visibility (YP20's entries, unchanged: a held
+  item removed logs its give-back, so an item's kinds 0 and 1 sum to its
+  visibility change); kind 2, a mover change (YP22's entries, unchanged).
+- **`logItem(tr, kind, item, len, mark)`** (`Item.js`): the one writer (it
+  extends a run's entry), which also marks the parent changed (it replaces
+  `logHold` and `Item#delete`'s `addChangedTypeToTransaction`; `logMove`
+  calls it). `Item#integrate` logs with `mark` false and keeps its own
+  mark, after its content, so `transaction.changed` keeps its order.
+
+The insert and delete sets, `transaction.changed` and every upstream path
+are untouched: the log is a list the engine appends to and never reads.
+
+Edytor side: the fold keeps one number per open transaction (the length of
+its log a read folded and that entry's last length then, so the units the
+engine added to it since are folded too), reads each entry's structs once
+(`walkRange`, the walk `walkIdSet` now runs per range) and replays the units each item showed
+or hid in order, so an edit made and undone within one fold moves the row
+by nothing; the sequences read kind 0 as their slots and records written and
+removed, kind 2 as their units whose mover changed. Removed: the copied and
+diffed id sets, the watermark, the second and third walks, the membership
+tests, the incomplete-walk fallback.
+
+Measured (`scripts/bundle-size.mjs`, own minified): minimal 425,374 →
+424,034 (−1,340 B; gzip −290), every plugin 675,230 → 673,890 (−1,340),
+`edytor/export` unchanged; the engine's share +106 B (one log writer, which
+extends a run's entry). A first version logged one entry per item: the
+fold walked them one by one where the id sets gave it ranges, and a 5,000
+block construction and a 40-block range delete got slower (`bench/scale.js`);
+the runs bring both back.
+
+Oracle: `src/tests/crdt/yp33-log.test.ts` (edits, holds and a removed held
+item's give-back, a move, a remote update with an item integrated removed),
+the YP20, YP22 and YP31 rows reading their entries of the log, the index's
+self-checks after every fold (they rebuild from the replicated state and
+never read the log), the fold's counters (`foldedStructs`, the scale rows),
+the random corpus, the upstream suite unchanged.
+
+### YP34 — an update read at an earlier state (`src/utils/encoding.js`, `src/index.js`)
+
+Reason: a re-seed's rebase (`room.reseed.rebase`, `crdt/reseed.ts`) gets an
+offline client's whole old document and must split it into the part the
+room held at the cut (the client's base) and the rest (its unsaved edits).
+`diffUpdate(update, sv)` gives the rest; nothing gave the base, and edytor
+has no access to the lazy struct reader and writer it would need (they are
+not exported). The engine now gives the counterpart. Encoding unchanged, no
+schema change.
+
+Patch (new code delimited by `// YP34 begin` / `// YP34 end`, edits marked `// YP34`):
+
+- **`clipUpdate(update, sv, ds)`**: the structs of `update` under the state
+  vector `sv` (a struct that crosses it is cut there, through the content's
+  `offsetEnd`; a skip is written only where a later struct of its client
+  follows it), and the deletes of `update` that the id set `ds` also holds
+  (`intersectSets`). Exported from `src/index.js`, not from edytor's engine
+  object (`crdt/engine.js`): only the room calls it, so apps keep none of it.
+
+Deleted content a document collected cannot come back (a collecting
+document writes it as deleted); edytor's text deletes are hold records
+(YP20), which keep it.
+
+Measured: vendored execution lines +30; the app bundle unchanged (the
+engine object does not hold it).
+
+Oracle: `src/tests/crdt/yp34-clip.test.ts` (an update read at an earlier
+state, its later deletes left out; a run cut at the state vector), the
+re-seed rows (`src/tests/crdt/reseed/`), the upstream suite unchanged.
+
 ## Generated declarations (`dts/`)
 
 `svelte-package` copies JS verbatim but emits no `.d.ts` for JS inputs, so

package/dist/crdt/vendor/yjs/dts/index.d.ts

@@ -11,7 +11,7 @@ export { GC } from "./structs/GC.js";
 export { Skip } from "./structs/Skip.js";
 export type ContentIds = import("./utils/ids.js").ContentIds;
 export { IdSet, createDeleteSetFromStructStore, diffIdSet, createIdSet, mergeIdSets, insertIntoIdSet, iterateStructsByIdSet, readIdSet, writeIdSet, intersectSets } from "./utils/ids.js";
-export { applyUpdate, encodeStateAsUpdate, encodeStateVector, decodeStateVector, diffUpdate, mergeUpdates } from "./utils/encoding.js";
+export { applyUpdate, encodeStateAsUpdate, encodeStateVector, decodeStateVector, diffUpdate, clipUpdate, mergeUpdates } from "./utils/encoding.js";
 export { ID, createID, compareIDs, findRootTypeKey } from "./utils/ID.js";
 export { idAtIndex, indexOfId } from "./utils/positions.js";
 export { findIndexSS, getItemCleanStart, getItemCleanEnd, isKeptReplaced } from "./utils/transaction-helpers.js";

package/dist/crdt/vendor/yjs/dts/utils/Transaction.d.ts

@@ -31,18 +31,18 @@ export class Transaction {
      */
     insertSet: import("./ids.js").IdSet;
     /**
-     * YP20: the visibility changes hold records made, in order: per item,
-     * `client, clock, len` (`len > 0`: shown, `< 0`: hidden; an item removed
-     * while held is logged shown, as the delete set counts it hidden).
+     * What the transaction did to items, in order: per run of one writer's
+     * items `kind, client, clock, len` (an item that continues the last entry
+     * extends it). Kind 0, an edit: integrated (`len > 0`, before its content
+     * integrates; an item integrated removed logs none) or removed (`len < 0`);
+     * kind 1, a hold record's
+     * (YP20): shown (`len > 0`) or hidden (`< 0`; an item removed while held
+     * is logged shown, so an item's kinds 0 and 1 sum to its visibility
+     * change); kind 2, its mover changed (YP22: a move record integrated or
+     * deleted, a moved unit removed).
      * @type {Array<number>}
      */
-    holds: Array<number>;
-    /**
-     * YP22: the units whose mover changed (a move record integrated or
-     * deleted, a moved unit removed), in order: per item `client, clock, len`.
-     * @type {Array<number>}
-     */
-    moves: Array<number>;
+    log: Array<number>;
     /**
      * All types that were directly modified (property added or child
      * inserted/deleted). New types are not included in this Set.

package/dist/crdt/vendor/yjs/dts/utils/encoding.d.ts

@@ -5,6 +5,7 @@ export function writeStateAsUpdate(encoder: UpdateEncoder, doc: Doc, targetState
 export function encodeStateAsUpdate(doc: Doc, encodedTargetStateVector?: Uint8Array): Uint8Array<ArrayBuffer>;
 export function mergeUpdates(updates: Array<Uint8Array<ArrayBuffer>>): Uint8Array<ArrayBuffer>;
 export function diffUpdate(update: Uint8Array, sv: Uint8Array): Uint8Array<ArrayBuffer>;
+export function clipUpdate(update: Uint8Array, sv: Uint8Array, ds: import("./ids.js").IdSet): Uint8Array<ArrayBuffer>;
 export function decodeStateVector(decodedState: Uint8Array): Map<number, number>;
 export function encodeStateVector(doc: Doc | Map<number, number>): Uint8Array<ArrayBuffer>;
 import { UpdateEncoder } from './UpdateEncoder.js';

package/dist/crdt/vendor/yjs/src/index.js

@@ -7,7 +7,7 @@ export { IdSet, createDeleteSetFromStructStore, diffIdSet, createIdSet, mergeIdS
 export { Doc } from './utils/Doc.js'
 export { UpdateDecoder } from './utils/UpdateDecoder.js'
 export { UpdateEncoder } from './utils/UpdateEncoder.js'
-export { applyUpdate, encodeStateAsUpdate, encodeStateVector, decodeStateVector, diffUpdate, mergeUpdates } from './utils/encoding.js'
+export { applyUpdate, encodeStateAsUpdate, encodeStateVector, decodeStateVector, diffUpdate, clipUpdate, mergeUpdates } from './utils/encoding.js' // YP34: clipUpdate
 export { ID, createID, compareIDs, findRootTypeKey } from './utils/ID.js'
 export { isParentOf } from './utils/isParentOf.js'
 export { idAtIndex, indexOfId } from './utils/positions.js' // YP19

package/dist/crdt/vendor/yjs/src/structs/Item.js

@@ -308,6 +308,8 @@ export class Item extends AbstractStruct {
       }
       addStructToIdSet(transaction.insertSet, this)
       transaction.doc.store.add(this)
+      // YP33: log the units it shows before its content integrates (a node's children follow it)
+      logItem(transaction, 0, this, this.content.constructor === ContentDeleted ? 0 : this.length, false)
       this.content.integrate(transaction, this)
       // add parent to transaction.changed
       addChangedTypeToTransaction(transaction, /** @type {YNode} */ (this.parent), this.parentSub)
@@ -393,7 +395,7 @@ export class Item extends AbstractStruct {
       // adjust the length of parent
       if (this.holds > 0) {
         // YP20: already hidden — the delete set counts it again, the log gives it back
-        logHold(transaction, this, this.length)
+        logItem(transaction, 1, this, this.length) // YP33
       } else if (this.movers !== null) {
         // YP22: hidden at home already; its mover shows it no more (`gone`)
         logMove(transaction, this, this.mover)
@@ -411,7 +413,7 @@ export class Item extends AbstractStruct {
       }
       this.markDeleted()
       transaction.deleteSet.add(this.id.client, this.id.clock, this.length)
-      addChangedTypeToTransaction(transaction, parent, this.parentSub)
+      logItem(transaction, 0, this, -this.length) // YP33
       // YP14: a node a concurrent value replaced keeps its subtree (the document asked)
       if (!isKeptReplaced(this)) this.content.delete(transaction, this) // YP22: a move record drops itself from its units' movers
     }
@@ -929,26 +931,36 @@ export class ContentDeleted {
 }
 
 // YP20 begin (edytor fork: hold records — see UPSTREAM.md YP20)
+// YP33 begin (edytor fork: one log of what a transaction did to items — see UPSTREAM.md YP33)
 /**
- * Log that a hold changed `item`'s visibility (`len > 0`: shown, `< 0`:
- * hidden) in `tr.holds`, in order, and its parent as changed.
+ * Log `len` units of `item` as `kind` (0 an edit, 1 a hold, 2 a move) in
+ * `tr.log`, in order, and (unless `mark` is false) its parent as changed.
+ * An entry the last one continues (its kind, its client, the next clock, its
+ * sign) extends it, so a run of one writer's items is one entry; `len` 0
+ * logs none.
  *
  * @param {Transaction} tr
+ * @param {number} kind
  * @param {Item} item
  * @param {number} len
+ * @param {boolean} [mark]
  */
-const logHold = (tr, item, len) => {
-  tr.holds.push(item.id.client, item.id.clock, len)
-  addChangedTypeToTransaction(tr, /** @type {YNode} */ (item.parent), item.parentSub)
+const logItem = (tr, kind, item, len, mark = true) => {
+  const log = tr.log
+  const n = log.length
+  const { client, clock } = item.id
+  if (log[n - 4] === kind && log[n - 3] === client && log[n - 2] + math.abs(log[n - 1]) === clock && log[n - 1] * len > 0) log[n - 1] += len
+  else if (len !== 0) log.push(kind, client, clock, len)
+  if (mark) addChangedTypeToTransaction(tr, /** @type {YNode} */ (item.parent), item.parentSub)
 }
+// YP33 end
 
 /**
  * Add `delta` (1, or -1: release) of a hold record (`record` null: `holds`)
  * or of the move record `record` (its `movers`, YP22; a record never moves a
  * record) to `item`. An item that is not removed and starts or stops being
  * hidden moves its parent's length and drops its search markers; a hold that
- * does is logged (`tr.holds`), and so is a unit whose mover changed
- * (`tr.moves`).
+ * does is logged (`tr.log`, YP33), and so is a unit whose mover changed.
  *
  * @param {Transaction} tr
  * @param {Item} item
@@ -976,7 +988,7 @@ const holdItem = (tr, item, delta, record) => {
     if (item.countable && item.parentSub === null) parent._length += len
     // the indices the search markers counted moved (a held delete moves them itself)
     if (parent._searchMarker) parent._searchMarker.length = 0
-    if (record === null) logHold(tr, item, len)
+    if (record === null) logItem(tr, 1, item, len) // YP33
   }
   const after = item.mover
   if (before !== after) {
@@ -1223,15 +1235,14 @@ const stronger = (a, b) =>
 
 /**
  * Log that `item`'s mover changed (or it left its mover: removed) in
- * `tr.moves`, in order, and its home and its new mover's sequences as changed.
+ * `tr.log` (YP33), and its home and its new mover's sequences as changed.
  *
  * @param {Transaction} tr
  * @param {Item} item
  * @param {Item|null} mover
  */
 const logMove = (tr, item, mover) => {
-  tr.moves.push(item.id.client, item.id.clock, item.length)
-  addChangedTypeToTransaction(tr, /** @type {YNode} */ (item.parent), item.parentSub)
+  logItem(tr, 2, item, item.length) // YP33
   if (mover !== null) addChangedTypeToTransaction(tr, /** @type {YNode} */ (mover.parent), null)
 }
 

package/dist/crdt/vendor/yjs/src/utils/Transaction.js

@@ -40,19 +40,21 @@ export class Transaction {
      * Describes the set of inserted items by ids
      */
     this.insertSet = createIdSet()
+    // YP33 begin (edytor fork: one log of what the transaction did to items — see UPSTREAM.md YP33)
     /**
-     * YP20: the visibility changes hold records made, in order: per item,
-     * `client, clock, len` (`len > 0`: shown, `< 0`: hidden; an item removed
-     * while held is logged shown, as the delete set counts it hidden).
+     * What the transaction did to items, in order: per run of one writer's
+     * items `kind, client, clock, len` (an item that continues the last entry
+     * extends it). Kind 0, an edit: integrated (`len > 0`, before its content
+     * integrates; an item integrated removed logs none) or removed (`len < 0`);
+     * kind 1, a hold record's
+     * (YP20): shown (`len > 0`) or hidden (`< 0`; an item removed while held
+     * is logged shown, so an item's kinds 0 and 1 sum to its visibility
+     * change); kind 2, its mover changed (YP22: a move record integrated or
+     * deleted, a moved unit removed).
      * @type {Array<number>}
      */
-    this.holds = []
-    /**
-     * YP22: the units whose mover changed (a move record integrated or
-     * deleted, a moved unit removed), in order: per item `client, clock, len`.
-     * @type {Array<number>}
-     */
-    this.moves = []
+    this.log = []
+    // YP33 end
     /**
      * All types that were directly modified (property added or child
      * inserted/deleted). New types are not included in this Set.

package/dist/crdt/vendor/yjs/src/utils/encoding.js

@@ -22,7 +22,7 @@ import * as array from 'lib0-v14/array'
 
 import { getStateVector, StructStore } from './StructStore.js'
 import { getItemCleanStart, getItemCleanEnd } from './transaction-helpers.js'
-import { createIdSet, IdRange, readAndApplyDeleteSet, readIdSet, mergeIdSets, writeIdSet } from './ids.js'
+import { createIdSet, IdRange, readAndApplyDeleteSet, readIdSet, mergeIdSets, writeIdSet, intersectSets } from './ids.js' // YP34: intersectSets
 import { createID, ID } from './ID.js'
 import { UpdateDecoder } from './UpdateDecoder.js'
 import { UpdateEncoder } from './UpdateEncoder.js'
@@ -469,6 +469,47 @@ export const diffUpdate = (update, sv) => {
   return encoder.toUint8Array()
 }
 
+// YP34 begin
+/**
+ * The part of `update` that the state vector `sv` covers, with only the
+ * deletes `ds` also holds: `update` as it read at an earlier state (the
+ * counterpart of `diffUpdate`). A struct that crosses the state vector is
+ * cut at it; a skip is written only where a later struct of its client
+ * follows it.
+ *
+ * @param {Uint8Array} update
+ * @param {Uint8Array} sv
+ * @param {import('./ids.js').IdSet} ds
+ */
+export const clipUpdate = (update, sv, ds) => {
+  const state = decodeStateVector(sv)
+  const encoder = new UpdateEncoder()
+  const lazyStructWriter = new LazyStructWriter(encoder)
+  const decoder = new UpdateDecoder(decoding.createDecoder(update))
+  const reader = new LazyStructReader(decoder, false)
+  /** @type {Array<Skip>} */
+  let skips = []
+  let client = -1
+  for (let curr = reader.curr; curr !== null; curr = reader.next()) {
+    if (curr.id.client !== client) [client, skips] = [curr.id.client, []]
+    const svClock = state.get(client) || 0
+    if (curr.id.clock >= svClock) continue
+    if (curr.constructor === Skip) {
+      skips.push(/** @type {Skip} */ (curr))
+      continue
+    }
+    if (lazyStructWriter.written > 0 && lazyStructWriter.currClient === client) {
+      for (const skip of skips) writeStructToLazyStructWriter(lazyStructWriter, skip, 0, 0)
+    }
+    skips = []
+    writeStructToLazyStructWriter(lazyStructWriter, curr, 0, math.max(curr.id.clock + curr.length - svClock, 0))
+  }
+  finishLazyStructWriting(lazyStructWriter)
+  writeIdSet(encoder, intersectSets(readIdSet(decoder), ds))
+  return encoder.toUint8Array()
+}
+// YP34 end
+
 /**
  * Read decodedState and return State as Map.
  *

package/dist/index.d.ts

@@ -25,7 +25,7 @@
  * This module re-exports the `.svelte` component, so it requires a
  * bundler that understands Svelte (vite-plugin-svelte).
  */
-export { default as Edytor } from './components/Edytor.svelte';
+export { default as Edytor } from './components/EdytorRoot.svelte';
 export { useEdytor } from './edytor.svelte.js';
 /** The editor instance plugins, hotkeys and `bind:edytor` receive (`Edytor` names the component). */
 export type { Edytor as EdytorInstance, EdytorDocData } from './edytor.svelte.js';

package/dist/index.js

@@ -26,7 +26,7 @@
  * bundler that understands Svelte (vite-plugin-svelte).
  */
 // ── The editor ─────────────────────────────────────────────────────────
-export { default as Edytor } from './components/Edytor.svelte';
+export { default as Edytor } from './components/EdytorRoot.svelte';
 export { useEdytor } from './edytor.svelte.js';
 export { Block } from './block/block.svelte.js';
 export { InlineBlock } from './block/inlineBlock.svelte.js';

package/dist/selection/selection.svelte.d.ts

@@ -34,7 +34,7 @@ export type Caret = {
  * order), comparing boundary points — a focus on an ancestor element of the
  * anchor (`(textElement, childCount)`) is after it.
  */
-export declare const isBackward: (selection: {
+export declare const isBackward: ({ anchorNode, anchorOffset, focusNode, focusOffset }: {
     anchorNode: Node | null;
     anchorOffset: number;
     focusNode: Node | null;