edytor 3.0.0 → 4.0.0

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

@@ -25,6 +25,8 @@ declare type ContentAny = import('./structs/Item.js').ContentAny
 declare type ContentFormat = import('./structs/Item.js').ContentFormat
 declare type ContentDeleted = import('./structs/Item.js').ContentDeleted
 declare type ContentString = import('./structs/Item.js').ContentString
+declare type ContentHold = import('./structs/Item.js').ContentHold
+declare type ContentMove = import('./structs/Item.js').ContentMove
 
 
 // @todo the below should have a separate Y/[mod] export

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

@@ -17,4 +17,4 @@ export { idAtIndex, indexOfId } from "./utils/positions.js";
 export { findIndexSS, getItemCleanStart, getItemCleanEnd, isKeptReplaced } from "./utils/transaction-helpers.js";
 export { Transaction, transact } from "./utils/Transaction.js";
 export { redoItem, keepItem } from "./utils/redo.js";
-export { Item, followRedone, ContentBinary, ContentDeleted, ContentFormat, ContentAny, ContentString, ContentType } from "./structs/Item.js";
+export { Item, followRedone, ContentBinary, ContentDeleted, ContentFormat, ContentAny, ContentString, ContentType, ContentMove } from "./structs/Item.js";

package/dist/crdt/vendor/yjs/dts/structs/AbstractStruct.d.ts

@@ -10,6 +10,13 @@ export class AbstractStruct {
      * @type {boolean}
      */
     get deleted(): boolean;
+    /**
+     * Whether the engine deleted this struct (YP20: an item can be hidden without
+     * being removed; a GC struct is removed, a Skip is not).
+     *
+     * @type {boolean}
+     */
+    get removed(): boolean;
     /**
      * Merge this struct with the item to the right.
      * This method is already assuming that `this.id.clock + this.length === this.id.clock`.

package/dist/crdt/vendor/yjs/dts/structs/Item.d.ts

@@ -67,6 +67,21 @@ export class Item extends AbstractStruct {
      * @type {number} byte
      */
     info: number;
+    /**
+     * YP20: how many live hold records (`ContentHold`) name this item. A
+     * held item reads as deleted; the count is local, never encoded (each
+     * replica counts the records it integrated).
+     * @type {number}
+     */
+    holds: number;
+    /**
+     * YP22: the live move records (`ContentMove`) naming this item, the
+     * strongest first — the greatest `(priority, client, clock)` — or `null`.
+     * The first is its mover: the item shows there, hidden at home. Local,
+     * never encoded.
+     * @type {Array<Item>|null}
+     */
+    movers: Array<Item> | null;
     /**
      * This is used to mark the item as an indexed fast-search marker
      *
@@ -80,6 +95,18 @@ export class Item extends AbstractStruct {
      */
     get keep(): boolean;
     get countable(): boolean;
+    /**
+     * Whether this item shows nowhere: removed or held (YP22; a moved item
+     * shows at its mover).
+     * @type {Boolean}
+     */
+    get gone(): boolean;
+    /**
+     * YP22: the live move record this item shows at (the strongest of
+     * `movers`), or `null` at home.
+     * @type {Item|null}
+     */
+    get mover(): Item | null;
     markDeleted(): void;
     /**
      * Computes the last content address of this Item.
@@ -110,7 +137,7 @@ export class Item extends AbstractStruct {
      * @return {Item}
      */
     split(transaction: Transaction | null, diff: number): Item;
-    get ref(): 2 | 1 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    get ref(): 2 | 1 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 12 | 13;
     /**
      * @type {true}
      */
@@ -159,8 +186,9 @@ export class AbstractContent {
     integrate(_transaction: Transaction, _item: Item): void;
     /**
      * @param {Transaction} _transaction
+     * @param {Item} [_item] the item deleted (YP22: a move record reads it)
      */
-    delete(_transaction: Transaction): void;
+    delete(_transaction: Transaction, _item?: Item): void;
     /**
      * @param {Transaction} _transaction
      */
@@ -169,12 +197,13 @@ export class AbstractContent {
      * @param {UpdateEncoder} _encoder
      * @param {number} _offset
      * @param {number} _offsetEnd
+     * @param {Item} [_item] the item written (YP25: a format item reads its id)
      */
-    write(_encoder: UpdateEncoder, _offset: number, _offsetEnd: number): void;
+    write(_encoder: UpdateEncoder, _offset: number, _offsetEnd: number, _item?: Item): void;
     /**
-     * @return {1|2|3|4|5|6|7|8|9}
+     * @return {1|2|3|4|5|6|7|8|9|11|12|13}
      */
-    getRef(): 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    getRef(): 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 12 | 13;
 }
 export class ContentAny {
     /**
@@ -294,9 +323,19 @@ export class ContentBinary {
 export class ContentDeleted {
     /**
      * @param {number} len
+     * @param {number} [cls] YP29: a collected mark's or claim's sort class
      */
-    constructor(len: number);
+    constructor(len: number, cls?: number);
     len: number;
+    /**
+     * YP29: what a collected paired mark item or claim item keeps, for each
+     * of its units: its sort class (`markClass`: `0` a left-side mark, `2` a
+     * right-side one, `3` a claim), which orders concurrent inserts at its
+     * origin on every replica (`undefined`: none, any other deleted content).
+     *
+     * @type {number|undefined}
+     */
+    cls: number | undefined;
     /**
      * @return {number}
      */
@@ -343,13 +382,157 @@ export class ContentDeleted {
      */
     write(encoder: UpdateEncoder, offset: number, offsetEnd: number): void;
     /**
-     * @return {1}
+     * @return {1|13}
      */
-    getRef(): 1;
+    getRef(): 1 | 13;
 }
 /**
- * @private
+ * A hold record: one unit per held id range (`client, clock, len`). While the
+ * record is live, the items it names read as deleted; deleting the record
+ * shows them again (an undo), unless another live record holds them. A record
+ * integrates at once; what it names that has not arrived takes its hold when
+ * it does (`applyPending`).
  */
+export class ContentHold {
+    /**
+     * @param {Array<number>} ids
+     */
+    constructor(ids: Array<number>);
+    ids: number[];
+    /**
+     * @return {number}
+     */
+    getLength(): number;
+    /**
+     * @return {Array<any>}
+     */
+    getContent(): Array<any>;
+    /**
+     * @return {boolean}
+     */
+    isCountable(): boolean;
+    /**
+     * @return {ContentHold}
+     */
+    copy(): ContentHold;
+    /**
+     * @param {number} offset
+     * @return {ContentHold}
+     */
+    splice(offset: number): ContentHold;
+    /**
+     * @param {ContentHold} right
+     * @return {boolean}
+     */
+    mergeWith(right: ContentHold): boolean;
+    /**
+     * @param {Transaction} transaction
+     * @param {Item} _item
+     */
+    integrate(transaction: Transaction, _item: Item): void;
+    /**
+     * @param {Transaction} transaction
+     */
+    delete(transaction: Transaction): void;
+    /**
+     * @param {Transaction} _tr
+     */
+    gc(_tr: Transaction): void;
+    /**
+     * @param {UpdateEncoder} encoder
+     * @param {number} offset
+     * @param {number} offsetEnd
+     */
+    write(encoder: UpdateEncoder, offset: number, offsetEnd: number): void;
+    /**
+     * @return {11}
+     */
+    getRef(): 11;
+}
+export function applyPending(tr: Transaction, clients: Array<number>): void;
+/**
+ * A move record: one countable unit at its destination, naming the units
+ * it moves (`client, clock, len` ranges, in the order they show) with a
+ * Lamport `priority`, a `side` (`0`: it stands after what precedes it,
+ * `1`: before what follows it — its sort class among the items of one
+ * origin, `markClass`), and for the sort of two records at one origin
+ * (`utils/marks.js` `sourceOrder`) the chain of units it stands at (`at`:
+ * the home slots from the root sequence down to that unit, else the first
+ * unit it names) and its `part` there. While the record is live, each named unit shows at
+ * the record that wins its movers and is hidden at home; deleting the
+ * record (an undo) hands the unit to the next record, else home. A record
+ * waits for the units it names as an item waits for its origin
+ * (`getMissing`), so two records at one origin sort by their units' home
+ * order on every replica (`sourceOrder`). Immutable once written, so
+ * replicas converge in any order. The record's item is the one integrating
+ * or deleting it (it is what the units' `movers` hold).
+ */
+export class ContentMove {
+    /**
+     * @param {number} priority
+     * @param {number} side
+     * @param {Array<number>} ids
+     * @param {number} [part] the writer's order among the records standing at one unit (0–7)
+     * @param {Array<ID>|null} [at] the chain the record stands at, outermost first (`null`: the first unit it names)
+     */
+    constructor(priority: number, side: number, ids: Array<number>, part?: number, at?: Array<ID> | null);
+    priority: number;
+    side: number;
+    ids: number[];
+    part: number;
+    at: ID[] | null;
+    /**
+     * @return {number}
+     */
+    getLength(): number;
+    /**
+     * @return {Array<any>}
+     */
+    getContent(): Array<any>;
+    /**
+     * @return {boolean}
+     */
+    isCountable(): boolean;
+    /**
+     * @return {ContentMove}
+     */
+    copy(): ContentMove;
+    /**
+     * @param {number} _offset
+     * @return {ContentMove}
+     */
+    splice(_offset: number): ContentMove;
+    /**
+     * @param {ContentMove} _right
+     * @return {boolean}
+     */
+    mergeWith(_right: ContentMove): boolean;
+    /**
+     * @param {Transaction} transaction
+     * @param {Item} item
+     */
+    integrate(transaction: Transaction, item: Item): void;
+    /**
+     * @param {Transaction} transaction
+     * @param {Item} item
+     */
+    delete(transaction: Transaction, item: Item): void;
+    /**
+     * @param {Transaction} _tr
+     */
+    gc(_tr: Transaction): void;
+    /**
+     * @param {UpdateEncoder} encoder
+     * @param {number} _offset
+     * @param {number} _offsetEnd
+     */
+    write(encoder: UpdateEncoder, _offset: number, _offsetEnd: number): void;
+    /**
+     * @return {12}
+     */
+    getRef(): 12;
+}
+export function readFormatValue(decoder: UpdateDecoder, key: string, id: ID): any;
 export class ContentFormat {
     /**
      * @param {string} key
@@ -401,8 +584,9 @@ export class ContentFormat {
      * @param {UpdateEncoder} encoder
      * @param {number} _offset
      * @param {number} _offsetEnd
+     * @param {Item} [item] YP25: the item, whose id a mark's operation id usually is
      */
-    write(encoder: UpdateEncoder, _offset: number, _offsetEnd: number): void;
+    write(encoder: UpdateEncoder, _offset: number, _offsetEnd: number, item?: Item): void;
     /**
      * @return {6}
      */

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

@@ -9,6 +9,7 @@
  * @property {function(Uint8Array<ArrayBuffer>, any, Doc, Transaction):void} DocEvents.update
  * @property {function(Doc):void} DocEvents.beforeAllTransactions
  * @property {function(Transaction, Doc):void} DocEvents.beforeTransaction
+ * @property {function(Transaction, Doc):void} DocEvents.beforeCommit
  * @property {function(Transaction, Doc):void} DocEvents.commit
  * @property {function(Transaction, Doc):void} DocEvents.afterTransaction
  * @property {function(Doc, Array<Transaction>):void} DocEvents.afterAllTransactions
@@ -41,11 +42,12 @@ export class Doc extends ObservableV2<DocEvents> {
     keepReplaced: ((item: import("../structs/Item.js").Item) => boolean) | null;
     clientID: number;
     /**
-     * YP13: the greatest Lamport timestamp of a paired mark this document
-     * integrated (see `utils/marks.js`).
+     * YP13, YP22: the greatest Lamport timestamp of a paired mark or a move
+     * record this document integrated (see `utils/marks.js`,
+     * `structs/Item.js` `ContentMove`); the next one it writes takes `_clock + 1`.
      * @type {number}
      */
-    _markClock: number;
+    _clock: number;
     /**
      * @type {Map<string, YNode>}
      */
@@ -97,6 +99,7 @@ export type DocEvents = {
     update: (arg0: Uint8Array<ArrayBuffer>, arg1: any, arg2: Doc, arg3: Transaction) => void;
     beforeAllTransactions: (arg0: Doc) => void;
     beforeTransaction: (arg0: Transaction, arg1: Doc) => void;
+    beforeCommit: (arg0: Transaction, arg1: Doc) => void;
     commit: (arg0: Transaction, arg1: Doc) => void;
     afterTransaction: (arg0: Transaction, arg1: Doc) => void;
     afterAllTransactions: (arg0: Doc, arg1: Array<Transaction>) => void;

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

@@ -14,6 +14,11 @@ export class StructStore {
      * @type {null | Uint8Array<ArrayBuffer>}
      */
     pendingDs: null | Uint8Array<ArrayBuffer>;
+    /**
+     * YP20: holds whose items have not arrived, `client → [clock, len, delta, …]`.
+     * @type {Map<number, Array<number>>|null}
+     */
+    pendingHolds: Map<number, Array<number>> | null;
     skips: import("./ids.js").IdSet;
     get ds(): import("./ids.js").IdSet;
     /**
@@ -21,13 +26,6 @@ export class StructStore {
      * @function
      */
     add(struct: GC | Item | Skip): void;
-    /**
-     * Expects that id is actually in store. This function throws or is an infinite loop otherwise.
-     *
-     * @param {ID} id
-     * @return {GC|Item}
-     */
-    get(id: ID): GC | Item;
     /**
      * Expects that id is actually in store. This function throws or is an infinite loop otherwise.
      *
@@ -45,17 +43,6 @@ export class StructStore {
      * @function
      */
     public getClock(client: number): number;
-    /**
-     * Perform a binary search on a sorted array
-     * @param {ID} id
-     * @return {{ structs: Array<GC|Item|Skip>, index: number }}
-     *
-     * @function
-     */
-    getIndex(id: ID): {
-        structs: Array<GC | Item | Skip>;
-        index: number;
-    };
 }
 export function getStateVector(store: StructStore): Map<number, number>;
 import { Skip } from '../structs/Skip.js';

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

@@ -5,7 +5,8 @@ export const generateNewClientId: typeof random.uint53;
  * minimize the number of messages sent.
  *
  * YP19: a commit is told through the document's events (`commit`, then
- * `afterTransaction`); nodes have no observers.
+ * `afterTransaction`); nodes have no observers. YP30: `beforeCommit` runs
+ * before them, inside the transaction.
  *
  * @public
  */
@@ -29,6 +30,19 @@ export class Transaction {
      * Describes the set of inserted items by ids
      */
     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).
+     * @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>;
     /**
      * 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/UpdateDecoder.d.ts

@@ -9,6 +9,12 @@ export class IdSetDecoder {
     private dsCurrVal;
     restDecoder: decoding.Decoder<ArrayBufferLike>;
     resetDsCurVal(): void;
+    /**
+     * YP26: the client of a delete set's ranges.
+     *
+     * @return {number}
+     */
+    readDsClient(): number;
     /**
      * @return {number}
      */
@@ -26,15 +32,18 @@ export class UpdateDecoder extends IdSetDecoder {
      * @type {Array<string>}
      */
     keys: Array<string>;
-    keyClockDecoder: decoding.IntDiffOptRleDecoder;
+    keyClockDecoder: decoding.UintOptRleDecoder;
     clientDecoder: decoding.UintOptRleDecoder;
     leftClockDecoder: decoding.IntDiffOptRleDecoder;
     rightClockDecoder: decoding.IntDiffOptRleDecoder;
     infoDecoder: decoding.RleDecoder<number>;
     stringDecoder: decoding.StringDecoder;
-    parentInfoDecoder: decoding.RleDecoder<number>;
     typeRefDecoder: decoding.UintOptRleDecoder;
     lenDecoder: decoding.UintOptRleDecoder;
+    /**
+     * @type {Array<number>}
+     */
+    clients: Array<number>;
     /**
      * @return {ID}
      */
@@ -46,6 +55,9 @@ export class UpdateDecoder extends IdSetDecoder {
     /**
      * Read the next client id.
      * Use this in favor of readID whenever possible to reduce the number of objects created.
+     * YP26: an index in the update's client table (a new one's id follows it).
+     *
+     * @return {number}
      */
     readClient(): number;
     /**
@@ -56,10 +68,6 @@ export class UpdateDecoder extends IdSetDecoder {
      * @return {string}
      */
     readString(): string;
-    /**
-     * @return {boolean}
-     */
-    readParentInfo(): boolean;
     /**
      * @return {number} An unsigned 8-bit integer
      */

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

@@ -1,8 +1,19 @@
+/**
+ * The update encoding this fork writes and reads, in upstream's reserved
+ * feature-flag varuint (upstream writes `0`): `1`, a string table per update.
+ */
+export const UPDATE_ENCODING: 1;
 export class IdSetEncoder {
     restEncoder: encoding.Encoder;
     dsCurrVal: number;
     toUint8Array(): Uint8Array<ArrayBuffer>;
     resetIdSetCurVal(): void;
+    /**
+     * YP26: the client of a delete set's ranges.
+     *
+     * @param {number} client
+     */
+    writeDsClient(client: number): void;
     /**
      * @param {number} clock
      */
@@ -24,15 +35,28 @@ export class UpdateEncoder extends IdSetEncoder {
      * @type {number}
      */
     keyClock: number;
-    keyClockEncoder: encoding.IntDiffOptRleEncoder;
+    keyClockEncoder: encoding.UintOptRleEncoder;
     clientEncoder: encoding.UintOptRleEncoder;
     leftClockEncoder: encoding.IntDiffOptRleEncoder;
     rightClockEncoder: encoding.IntDiffOptRleEncoder;
     infoEncoder: encoding.RleEncoder<number>;
     stringEncoder: encoding.StringEncoder;
-    parentInfoEncoder: encoding.RleEncoder<number>;
     typeRefEncoder: encoding.UintOptRleEncoder;
     lenEncoder: encoding.UintOptRleEncoder;
+    /**
+     * Each client's index, in first-use order.
+     *
+     * @type {Map<number,number>}
+     */
+    clientTable: Map<number, number>;
+    /**
+     * YP26: write `client` to the client column as its index in the update's
+     * client table, in first-use order: a new client's index (the table's
+     * size) is followed by its id, once.
+     *
+     * @param {number} client
+     */
+    clientIndex(client: number): void;
     /**
      * @param {ID} id
      */
@@ -53,10 +77,6 @@ export class UpdateEncoder extends IdSetEncoder {
      * @param {string} s
      */
     writeString(s: string): void;
-    /**
-     * @param {boolean} isYKey
-     */
-    writeParentInfo(isYKey: boolean): void;
     /**
      * @param {number} info An unsigned 8-bit integer
      */
@@ -85,6 +105,13 @@ export class UpdateEncoder extends IdSetEncoder {
      *
      * We cache these keys in a Map and refer to them via a unique number.
      *
+     * YP24: the cache is on (upstream left it off for decoders older than its
+     * own), and every map key, root name and string of a content value goes
+     * through it: an update writes each distinct string once. The key column
+     * says `0` for a new string (the next in the string column) and the index
+     * of a known one plus one, so a key repeated block after block is the same
+     * small number every time.
+     *
      * @param {string} key
      */
     writeKey(key: string): void;

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

@@ -21,27 +21,6 @@ export class IdRange {
      */
     copyWith(clock: number, len: number): IdRange;
 }
-export class MaybeIdRange {
-    /**
-     * @param {number} clock
-     * @param {number} len
-     * @param {boolean} exists
-     */
-    constructor(clock: number, len: number, exists: boolean);
-    /**
-     * @type {number}
-     */
-    clock: number;
-    /**
-     * @type {number}
-     */
-    len: number;
-    /**
-     * @type {boolean}
-     */
-    exists: boolean;
-}
-export function createMaybeIdRange(clock: number, len: number, exists: boolean): MaybeIdRange;
 export class IdRanges {
     /**
      * @param {Array<IdRange>} ids
@@ -69,19 +48,12 @@ export class IdRanges {
      */
     getIds(): IdRange[];
 }
-/**
- * @implements {traits.EqualityTrait}
- */
-export class IdSet implements traits.EqualityTrait {
+export class IdSet {
     /**
      * @type {Map<number,IdRanges>}
      */
     clients: Map<number, IdRanges>;
     isEmpty(): boolean;
-    /**
-     * @param {(idrange:IdRange, client:number) => void} f
-     */
-    forEach(f: (idrange: IdRange, client: number) => void): void;
     /**
      * @param {ID} id
      * @return {boolean}
@@ -102,37 +74,6 @@ export class IdSet implements traits.EqualityTrait {
      * @return {boolean}
      */
     intersects(client: number, clock: number, len: number): boolean;
-    /**
-     * Whether the entire range `[clock, clock+len)` of `client` is contained in this set.
-     * Allocation-free (binary search). Because `getIds()` returns maximal, merged ranges, full
-     * coverage of a range implies it lies within a single range.
-     *
-     * @param {number} client
-     * @param {number} clock
-     * @param {number} len
-     * @return {boolean}
-     */
-    covers(client: number, clock: number, len: number): boolean;
-    /**
-     * Total number of ids in `[clock, clock+len)` of `client` contained in this set.
-     * Allocation-free (binary search + linear scan of the overlapping ranges). Equivalent to
-     * `slice(client, clock, len).reduce((s, r) => r.exists ? s + r.len : s, 0)` without allocating.
-     *
-     * @param {number} client
-     * @param {number} clock
-     * @param {number} len
-     * @return {number}
-     */
-    coveredLength(client: number, clock: number, len: number): number;
-    /**
-     * Return slices of ids that exist in this idset.
-     *
-     * @param {number} client
-     * @param {number} clock
-     * @param {number} len
-     * @return {Array<MaybeIdRange>}
-     */
-    slice(client: number, clock: number, len: number): Array<MaybeIdRange>;
     /**
      * @param {number} client
      * @param {number} clock
@@ -145,10 +86,6 @@ export class IdSet implements traits.EqualityTrait {
      * @param {number} len
      */
     delete(client: number, clock: number, len: number): void;
-    /**
-     * @param {any} other
-     */
-    [traits.EqualityTraitSymbol](other: any): boolean;
 }
 export function _deleteRangeFromIdSet(set: IdSet, client: number, clock: number, len: number): void;
 export function iterateStructsByIdSet(transaction: Transaction, ds: IdSet, f: (arg0: GC | Item) => void): void;
@@ -179,4 +116,3 @@ export type ContentIds = {
     inserts: IdSet;
     deletes: IdSet;
 };
-import * as traits from 'lib0-v14/traits';

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

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import('./Transaction.js').Transaction} Transaction
+ */
 /**
  * Paired marks — an edytor fork addition (UPSTREAM.md YP13), not upstream source.
  *
@@ -80,4 +83,6 @@ export function foldPaired(formats: Map<string, any>, content: {
 }): boolean;
 export function formatValue(value: any): any;
 export function markClass(item: any): number;
-export function sortsBefore(o: any, item: any): boolean;
+export function sequenceOrder(x: any, y: any): number;
+export function sortsBefore(o: any, item: any, tr: Transaction): boolean;
+export type Transaction = import("./Transaction.js").Transaction;