@y/y 14.0.0-16

package/dist/src/utils/IdMap.d.ts

@@ -0,0 +1,161 @@
+/**
+ * @todo rename this to `Attribute`
+ * @template V
+ */
+export class AttributionItem<V> {
+    /**
+     * @param {string} name
+     * @param {V} val
+     */
+    constructor(name: string, val: V);
+    name: string;
+    val: V;
+    hash(): string;
+}
+export function createAttributionItem<V>(name: string, val: V): AttributionItem<V>;
+export function idmapAttrsEqual<T_1>(a: Array<T_1>, b: Array<T_1>): boolean;
+/**
+ * @template Attrs
+ */
+export class AttrRange<Attrs> {
+    /**
+     * @param {number} clock
+     * @param {number} len
+     * @param {Array<AttributionItem<Attrs>>} attrs
+     */
+    constructor(clock: number, len: number, attrs: Array<AttributionItem<Attrs>>);
+    /**
+     * @readonly
+     */
+    readonly clock: number;
+    /**
+     * @readonly
+     */
+    readonly len: number;
+    /**
+     * @readonly
+     */
+    readonly attrs: AttributionItem<Attrs>[];
+    /**
+     * @param {number} clock
+     * @param {number} len
+     */
+    copyWith(clock: number, len: number): AttrRange<Attrs>;
+}
+export function createMaybeAttrRange<Attrs>(clock: number, len: number, attrs: Array<AttributionItem<Attrs>> | null): MaybeAttrRange<Attrs>;
+/**
+ * Whenever this is instantiated, it must receive a fresh array of ops, not something copied.
+ *
+ * @template Attrs
+ */
+export class AttrRanges<Attrs> {
+    /**
+     * @param {Array<AttrRange<Attrs>>} ids
+     */
+    constructor(ids: Array<AttrRange<Attrs>>);
+    sorted: boolean;
+    /**
+     * @private
+     */
+    private _ids;
+    copy(): AttrRanges<Attrs>;
+    /**
+     * @param {number} clock
+     * @param {number} length
+     * @param {Array<AttributionItem<Attrs>>} attrs
+     */
+    add(clock: number, length: number, attrs: Array<AttributionItem<Attrs>>): void;
+    /**
+     * Return the list of id ranges, sorted and merged.
+     */
+    getIds(): AttrRange<Attrs>[];
+}
+export function mergeIdMaps<T_1>(ams: Array<IdMap<T_1>>): IdMap<T_1>;
+export function createIdMapFromIdSet(idset: IdSet, attrs: Array<AttributionItem<any>>): IdMap<any>;
+/**
+ * @template Attrs
+ */
+export class IdMap<Attrs> {
+    /**
+     * @type {Map<number,AttrRanges<Attrs>>}
+     */
+    clients: Map<number, AttrRanges<Attrs>>;
+    /**
+     * @type {Map<string, AttributionItem<Attrs>>}
+     */
+    attrsH: Map<string, AttributionItem<Attrs>>;
+    /**
+     * @type {Set<AttributionItem<Attrs>>}
+     */
+    attrs: Set<AttributionItem<Attrs>>;
+    /**
+     * @param {(attrRange:AttrRange<Attrs>, client:number) => void} f
+     */
+    forEach(f: (attrRange: AttrRange<Attrs>, client: number) => void): void;
+    /**
+     * @param {ID} id
+     * @return {boolean}
+     */
+    hasId(id: ID): boolean;
+    /**
+     * @param {number} client
+     * @param {number} clock
+     * @return {boolean}
+     */
+    has(client: number, clock: number): boolean;
+    /**
+     * Return attributions for a slice of ids.
+     *
+     * @param {ID} id
+     * @param {number} len
+     * @return {Array<MaybeAttrRange<Attrs>>}
+     */
+    sliceId(id: ID, len: number): Array<MaybeAttrRange<Attrs>>;
+    /**
+     * Return attributions for a slice of ids.
+     *
+     * @param {number} client
+     * @param {number} clock
+     * @param {number} len
+     * @return {Array<MaybeAttrRange<Attrs>>}
+     */
+    slice(client: number, clock: number, len: number): Array<MaybeAttrRange<Attrs>>;
+    /**
+     * @param {number} client
+     * @param {number} clock
+     * @param {number} len
+     * @param {Array<AttributionItem<Attrs>>} attrs
+     */
+    add(client: number, clock: number, len: number, attrs: Array<AttributionItem<Attrs>>): void;
+    /**
+     * @param {number} client
+     * @param {number} clock
+     * @param {number} len
+     */
+    delete(client: number, clock: number, len: number): void;
+}
+export function writeIdMap<Attr>(encoder: IdSetEncoderV1 | IdSetEncoderV2, idmap: IdMap<Attr>): void;
+export function encodeIdMap(idmap: IdMap<any>): Uint8Array<ArrayBuffer>;
+export function readIdMap(decoder: DSDecoderV1 | DSDecoderV2): IdMap<any>;
+export function decodeIdMap(data: Uint8Array): IdMap<any>;
+export function createIdMap(): IdMap<any>;
+/**
+ * @template T
+ * @param {IdMap<T>} dest
+ * @param {IdMap<T>} src
+ */
+export const insertIntoIdMap: <S extends IdSet | IdMap<any>>(dest: S, src: S) => void;
+export function diffIdMap<ISet extends IdMap<any>>(set: ISet, exclude: IdSet | IdMap<any>): ISet;
+export const intersectMaps: <SetA extends IdSet | IdMap<any>, SetB extends IdSet | IdMap<any>>(setA: SetA, setB: SetB) => SetA extends IdMap<infer A> ? (SetB extends IdMap<infer B> ? IdMap<A | B> : IdMap<A>) : IdSet;
+export type MaybeAttrRange<Attrs> = {
+    clock: number;
+    len: number;
+    attrs: Array<AttributionItem<Attrs>> | null;
+};
+import { IdSet } from '../internals.js';
+import { ID } from '../internals.js';
+import { IdSetEncoderV1 } from '../internals.js';
+import { IdSetEncoderV2 } from '../internals.js';
+import { DSDecoderV1 } from '../internals.js';
+import { DSDecoderV2 } from '../internals.js';
+//# sourceMappingURL=IdMap.d.ts.map

package/dist/src/utils/IdMap.d.ts.map

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

package/dist/src/utils/IdSet.d.ts

@@ -0,0 +1,163 @@
+export class IdRange {
+    /**
+     * @param {number} clock
+     * @param {number} len
+     */
+    constructor(clock: number, len: number);
+    /**
+     * @type {number}
+     */
+    clock: number;
+    /**
+     * @type {number}
+     */
+    len: number;
+    /**
+     * @param {number} clock
+     * @param {number} len
+     */
+    copyWith(clock: number, len: number): IdRange;
+    /**
+     * Helper method making this compatible with IdMap.
+     *
+     * @return {Array<import('./IdMap.js').AttributionItem<any>>}
+     */
+    get attrs(): Array<import("./IdMap.js").AttributionItem<any>>;
+}
+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
+     */
+    constructor(ids: Array<IdRange>);
+    sorted: boolean;
+    /**
+     * A typical use-case for IdSet is to append data. We heavily optimize this case by allowing the
+     * last item to be mutated ef it isn't used currently.
+     * This flag is true if the last item was exposed to the outside.
+     */
+    _lastIsUsed: boolean;
+    /**
+     * @private
+     */
+    private _ids;
+    copy(): IdRanges;
+    /**
+     * @param {number} clock
+     * @param {number} length
+     */
+    add(clock: number, length: number): void;
+    /**
+     * Return the list of immutable id ranges, sorted and merged.
+     */
+    getIds(): IdRange[];
+}
+/**
+ * @implements {traits.EqualityTrait}
+ */
+export class IdSet implements traits.EqualityTrait {
+    /**
+     * @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}
+     */
+    hasId(id: ID): boolean;
+    /**
+     * @param {number} client
+     * @param {number} clock
+     */
+    has(client: number, clock: number): boolean;
+    /**
+     * 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
+     * @param {number} len
+     */
+    add(client: number, clock: number, len: number): void;
+    /**
+     * @param {number} client
+     * @param {number} clock
+     * @param {number} len
+     */
+    delete(client: number, clock: number, len: number): void;
+    /**
+     * @param {any} other
+     */
+    [traits.EqualityTraitSymbol](other: any): boolean;
+}
+export function _deleteRangeFromIdSet(set: IdSet | IdMap<any>, client: number, clock: number, len: number): void;
+export function iterateStructsByIdSet(transaction: Transaction, ds: IdSet, f: (arg0: GC | Item) => void): void;
+export function findIndexInIdRanges(dis: Array<IdRange>, clock: number): number | null;
+export function findRangeStartInIdRanges(dis: Array<IdRange>, clock: number): number | null;
+export function mergeIdSets(idSets: Array<IdSet>): IdSet;
+export function _insertIntoIdSet<S extends IdSet | IdMap<any>>(dest: S, src: S): void;
+export function insertIntoIdSet<S extends IdSet | IdMap<any>>(dest: S, src: S): void;
+export function _diffSet<Set extends IdSet | IdMap<any>>(set: Set, exclude: IdSet | IdMap<any>): Set;
+/**
+ * Remove all ranges from `exclude` from `idSet`. The result is a fresh IdSet containing all ranges from `idSet` that are not
+ * in `exclude`.
+ *
+ * @type {(idSet: IdSet, exclude: IdSet|IdMap<any>) => IdSet}
+ */
+export const diffIdSet: (idSet: IdSet, exclude: IdSet | IdMap<any>) => IdSet;
+export function _intersectSets<SetA extends IdSet | IdMap<any>, SetB extends IdSet | IdMap<any>>(setA: SetA, setB: SetB): SetA extends IdMap<infer A> ? (SetB extends IdMap<infer B> ? IdMap<A | B> : IdMap<A>) : IdSet;
+export function intersectSets<SetA extends IdSet | IdMap<any>, SetB extends IdSet | IdMap<any>>(setA: SetA, setB: SetB): SetA extends IdMap<infer A> ? (SetB extends IdMap<infer B> ? IdMap<A | B> : IdMap<A>) : IdSet;
+export function addToIdSet(idSet: IdSet, client: number, clock: number, length: number): void;
+export function addStructToIdSet(idSet: IdSet, struct: AbstractStruct): void;
+export function createIdSet(): IdSet;
+export function createDeleteSetFromStructStore(ss: StructStore): IdSet;
+export function _createInsertSliceFromStructs(structs: Array<GC | Item>, filterDeleted: boolean): IdRange[];
+export function createInsertSetFromStructStore(ss: import("../internals.js").StructStore, filterDeleted: boolean): IdSet;
+export function writeIdSet(encoder: IdSetEncoderV1 | IdSetEncoderV2, idSet: IdSet): void;
+export function readIdSet(decoder: DSDecoderV1 | DSDecoderV2): IdSet;
+export function readAndApplyDeleteSet(decoder: DSDecoderV1 | DSDecoderV2, transaction: Transaction, store: StructStore): Uint8Array<ArrayBuffer> | null;
+export function equalIdSets(ds1: IdSet, ds2: IdSet): boolean;
+import * as traits from 'lib0/traits';
+import { ID } from '../internals.js';
+import { IdMap } from '../internals.js';
+import { Transaction } from '../internals.js';
+import { GC } from '../internals.js';
+import { Item } from '../internals.js';
+import { AbstractStruct } from '../internals.js';
+import { StructStore } from '../internals.js';
+import { IdSetEncoderV1 } from '../internals.js';
+import { IdSetEncoderV2 } from '../internals.js';
+import { DSDecoderV1 } from '../internals.js';
+import { DSDecoderV2 } from '../internals.js';
+//# sourceMappingURL=IdSet.d.ts.map

package/dist/src/utils/IdSet.d.ts.map

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

package/dist/src/utils/RelativePosition.d.ts

@@ -0,0 +1,91 @@
+/**
+ * A relative position is based on the Yjs model and is not affected by document changes.
+ * E.g. If you place a relative position before a certain character, it will always point to this character.
+ * If you place a relative position at the end of a type, it will always point to the end of the type.
+ *
+ * A numeric position is often unsuited for user selections, because it does not change when content is inserted
+ * before or after.
+ *
+ * ```Insert(0, 'x')('a|bc') = 'xa|bc'``` Where | is the relative position.
+ *
+ * One of the properties must be defined.
+ *
+ * @example
+ *   // Current cursor position is at position 10
+ *   const relativePosition = createRelativePositionFromIndex(yText, 10)
+ *   // modify yText
+ *   yText.insert(0, 'abc')
+ *   yText.delete(3, 10)
+ *   // Compute the cursor position
+ *   const absolutePosition = createAbsolutePositionFromRelativePosition(y, relativePosition)
+ *   absolutePosition.type === yText // => true
+ *   console.log('cursor location is ' + absolutePosition.index) // => cursor location is 3
+ *
+ */
+export class RelativePosition {
+    /**
+     * @param {ID|null} type
+     * @param {string|null} tname
+     * @param {ID|null} item
+     * @param {number} assoc
+     */
+    constructor(type: ID | null, tname: string | null, item: ID | null, assoc?: number);
+    /**
+     * @type {ID|null}
+     */
+    type: ID | null;
+    /**
+     * @type {string|null}
+     */
+    tname: string | null;
+    /**
+     * @type {ID | null}
+     */
+    item: ID | null;
+    /**
+     * A relative position is associated to a specific character. By default
+     * assoc >= 0, the relative position is associated to the character
+     * after the meant position.
+     * I.e. position 1 in 'ab' is associated to character 'b'.
+     *
+     * If assoc < 0, then the relative position is associated to the character
+     * before the meant position.
+     *
+     * @type {number}
+     */
+    assoc: number;
+}
+export function relativePositionToJSON(rpos: RelativePosition): any;
+export function createRelativePositionFromJSON(json: any): RelativePosition;
+export class AbsolutePosition {
+    /**
+     * @param {AbstractType<any>} type
+     * @param {number} index
+     * @param {number} [assoc]
+     */
+    constructor(type: AbstractType<any>, index: number, assoc?: number);
+    /**
+     * @type {AbstractType<any>}
+     */
+    type: AbstractType<any>;
+    /**
+     * @type {number}
+     */
+    index: number;
+    assoc: number;
+}
+export function createAbsolutePosition(type: AbstractType<any>, index: number, assoc?: number): AbsolutePosition;
+export function createRelativePosition(type: AbstractType<any>, item: ID | null, assoc?: number): RelativePosition;
+export function createRelativePositionFromTypeIndex(type: AbstractType, index: number, assoc?: number, attributionManager?: import("../utils/AttributionManager.js").AbstractAttributionManager): RelativePosition;
+export function writeRelativePosition(encoder: encoding.Encoder, rpos: RelativePosition): encoding.Encoder;
+export function encodeRelativePosition(rpos: RelativePosition): Uint8Array;
+export function readRelativePosition(decoder: decoding.Decoder): RelativePosition;
+export function decodeRelativePosition(uint8Array: Uint8Array): RelativePosition;
+export function createAbsolutePositionFromRelativePosition(rpos: RelativePosition, doc: Doc, followUndoneDeletions?: boolean, attributionManager?: import("../utils/AttributionManager.js").AbstractAttributionManager): AbsolutePosition | null;
+export function compareRelativePositions(a: RelativePosition | null, b: RelativePosition | null): boolean;
+import { ID } from '../internals.js';
+import { AbstractType } from '../internals.js';
+import * as encoding from 'lib0/encoding';
+import * as decoding from 'lib0/decoding';
+import { Doc } from '../internals.js';
+//# sourceMappingURL=RelativePosition.d.ts.map

package/dist/src/utils/RelativePosition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RelativePosition.d.ts","sourceRoot":"","sources":["../../../src/utils/RelativePosition.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACE;;;;;OAKG;IACH,kBALW,EAAE,GAAC,IAAI,SACP,MAAM,GAAC,IAAI,QACX,EAAE,GAAC,IAAI,UACP,MAAM,EA2BhB;IAxBC;;OAEG;IACH,MAFU,EAAE,GAAC,IAAI,CAED;IAChB;;OAEG;IACH,OAFU,MAAM,GAAC,IAAI,CAEH;IAClB;;OAEG;IACH,MAFU,EAAE,GAAG,IAAI,CAEH;IAChB;;;;;;;;;;OAUG;IACH,OAFU,MAAM,CAEE;CAErB;AAMM,6CAHI,gBAAgB,GACf,GAAG,CAiBd;AAQM,qDALI,GAAG,GACF,gBAAgB,CAIuP;AAEnR;IACE;;;;OAIG;IACH,kBAJW,YAAY,CAAC,GAAG,CAAC,SACjB,MAAM,UACN,MAAM,EAYhB;IATC;;OAEG;IACH,MAFU,YAAY,CAAC,GAAG,CAAC,CAEX;IAChB;;OAEG;IACH,OAFU,MAAM,CAEE;IAClB,cAAkB;CAErB;AASM,6CANI,YAAY,CAAC,GAAG,CAAC,SACjB,MAAM,UACN,MAAM,oBAIyF;AASnG,6CANI,YAAY,CAAC,GAAG,CAAC,QACjB,EAAE,GAAC,IAAI,UACP,MAAM,oBAahB;AAaM,0DARI,YAAY,SACZ,MAAM,UACN,MAAM,uBACN,OAAO,gCAAgC,EAAE,0BAA0B,GAClE,gBAAgB,CA2B3B;AAQM,+CALI,QAAQ,CAAC,OAAO,QAChB,gBAAgB,oBAsB1B;AAMM,6CAHI,gBAAgB,GACf,UAAU,CAMrB;AAQM,8CALI,QAAQ,CAAC,OAAO,GACf,gBAAgB,CAwB3B;AAMM,mDAHI,UAAU,GACT,gBAAgB,CAEgF;AAiCrG,iEARI,gBAAgB,OAChB,GAAG,0BACH,OAAO,uBACP,OAAO,gCAAgC,EAAE,0BAA0B,GAClE,gBAAgB,GAAC,IAAI,CAuDhC;AASM,4CANI,gBAAgB,GAAC,IAAI,KACrB,gBAAgB,GAAC,IAAI,GACpB,OAAO,CAMlB;mBAnVM,iBAAiB;6BAAjB,iBAAiB;0BAEE,eAAe;0BACf,eAAe;oBAHlC,iBAAiB"}

package/dist/src/utils/Snapshot.d.ts

@@ -0,0 +1,40 @@
+export class Snapshot {
+    /**
+     * @param {IdSet} ds
+     * @param {Map<number,number>} sv state map
+     */
+    constructor(ds: IdSet, sv: Map<number, number>);
+    /**
+     * @type {IdSet}
+     */
+    ds: IdSet;
+    /**
+     * State Map
+     * @type {Map<number,number>}
+     */
+    sv: Map<number, number>;
+}
+export function equalSnapshots(snap1: Snapshot, snap2: Snapshot): boolean;
+export function encodeSnapshotV2(snapshot: Snapshot, encoder?: IdSetEncoderV1 | IdSetEncoderV2): Uint8Array;
+export function encodeSnapshot(snapshot: Snapshot): Uint8Array;
+export function decodeSnapshotV2(buf: Uint8Array, decoder?: DSDecoderV1 | DSDecoderV2): Snapshot;
+export function decodeSnapshot(buf: Uint8Array): Snapshot;
+export function createSnapshot(ds: IdSet, sm: Map<number, number>): Snapshot;
+export const emptySnapshot: Snapshot;
+export function snapshot(doc: Doc): Snapshot;
+export function isVisible(item: Item, snapshot: Snapshot | undefined): boolean;
+export function splitSnapshotAffectedStructs(transaction: Transaction, snapshot: Snapshot): void;
+export function createDocFromSnapshot(originDoc: Doc, snapshot: Snapshot, newDoc?: Doc): Doc;
+export function snapshotContainsUpdateV2(snapshot: Snapshot, update: Uint8Array, YDecoder?: typeof UpdateDecoderV2 | typeof UpdateDecoderV1): boolean;
+export function snapshotContainsUpdate(snapshot: Snapshot, update: Uint8Array): boolean;
+import { IdSet } from '../internals.js';
+import { IdSetEncoderV1 } from '../internals.js';
+import { IdSetEncoderV2 } from '../internals.js';
+import { DSDecoderV1 } from '../internals.js';
+import { DSDecoderV2 } from '../internals.js';
+import { Doc } from '../internals.js';
+import { Item } from '../internals.js';
+import { Transaction } from '../internals.js';
+import { UpdateDecoderV2 } from '../internals.js';
+import { UpdateDecoderV1 } from '../internals.js';
+//# sourceMappingURL=Snapshot.d.ts.map

package/dist/src/utils/Snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Snapshot.d.ts","sourceRoot":"","sources":["../../../src/utils/Snapshot.js"],"names":[],"mappings":"AA0BA;IACE;;;OAGG;IACH,gBAHW,KAAK,MACL,GAAG,CAAC,MAAM,EAAC,MAAM,CAAC,EAY5B;IATC;;OAEG;IACH,IAFU,KAAK,CAEH;IACZ;;;OAGG;IACH,IAFU,GAAG,CAAC,MAAM,EAAC,MAAM,CAAC,CAEhB;CAEf;AAOM,sCAJI,QAAQ,SACR,QAAQ,GACP,OAAO,CAclB;AAOM,2CAJI,QAAQ,YACR,cAAc,GAAG,cAAc,GAC9B,UAAU,CAMrB;AAMM,yCAHI,QAAQ,GACP,UAAU,CAEoE;AAOnF,sCAJI,UAAU,YACV,WAAW,GAAG,WAAW,GACxB,QAAQ,CAInB;AAMM,oCAHI,UAAU,GACT,QAAQ,CAEoF;AAOjG,mCAJI,KAAK,MACL,GAAG,CAAC,MAAM,EAAC,MAAM,CAAC,GACjB,QAAQ,CAE0C;AAE9D,qCAAqE;AAM9D,8BAHI,GAAG,GACF,QAAQ,CAE+F;AAS5G,gCANI,IAAI,YACJ,QAAQ,GAAC,SAAS,WAO+F;AAMrH,0DAHI,WAAW,YACX,QAAQ,QAelB;AAgBM,iDALI,GAAG,YACH,QAAQ,WACR,GAAG,GACF,GAAG,CA0Cd;AAOM,mDAJI,QAAQ,UACR,UAAU,aACV,OAAO,eAAe,GAAG,OAAO,eAAe,WAczD;AAMM,iDAHI,QAAQ,UACR,UAAU,WAEkG;sBAxMhH,iBAAiB;+BAAjB,iBAAiB;+BAAjB,iBAAiB;4BAAjB,iBAAiB;4BAAjB,iBAAiB;oBAAjB,iBAAiB;qBAAjB,iBAAiB;4BAAjB,iBAAiB;gCAAjB,iBAAiB;gCAAjB,iBAAiB"}

package/dist/src/utils/StructSet.d.ts

@@ -0,0 +1,27 @@
+export function readStructSet(decoder: UpdateDecoderV1 | UpdateDecoderV2, doc: Doc): StructSet;
+export function removeRangesFromStructSet(ss: StructSet, exclude: IdSet): void;
+export class StructSet {
+    /**
+     * @type {Map<number, StructRange>}
+     */
+    clients: Map<number, StructRange>;
+}
+import { UpdateDecoderV1 } from '../internals.js';
+import { UpdateDecoderV2 } from '../internals.js';
+import { Doc } from '../internals.js';
+import { IdSet } from '../internals.js';
+declare class StructRange {
+    /**
+     * @param {Array<Item|GC>} refs
+     */
+    constructor(refs: Array<Item | GC>);
+    i: number;
+    /**
+     * @type {Array<Item | GC>}
+     */
+    refs: Array<Item | GC>;
+}
+import { Item } from '../internals.js';
+import { GC } from '../internals.js';
+export {};
+//# sourceMappingURL=StructSet.d.ts.map

package/dist/src/utils/StructSet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StructSet.d.ts","sourceRoot":"","sources":["../../../src/utils/StructSet.js"],"names":[],"mappings":"AAoBO,uCAPI,eAAe,GAAG,eAAe,OACjC,GAAG,GACF,SAAS,CA6DpB;AAQM,8CAHI,SAAS,WACT,KAAK,QAgCf;AAeD;IAEI;;OAEG;IACH,SAFU,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAEP;CAE9B;gCAlIM,iBAAiB;gCAAjB,iBAAiB;oBAAjB,iBAAiB;sBAAjB,iBAAiB;AA8GxB;IACE;;OAEG;IACH,kBAFW,KAAK,CAAC,IAAI,GAAC,EAAE,CAAC,EAQxB;IALC,UAAU;IACV;;OAEG;IACH,MAFU,KAAK,CAAC,IAAI,GAAG,EAAE,CAAC,CAEV;CAEnB;qBAzHM,iBAAiB;mBAAjB,iBAAiB"}

package/dist/src/utils/StructStore.d.ts

@@ -0,0 +1,41 @@
+export class StructStore {
+    /**
+     * @type {Map<number,Array<GC|Item>>}
+     */
+    clients: Map<number, Array<GC | Item>>;
+    /**
+     * @type {null | { missing: Map<number, number>, update: Uint8Array<ArrayBuffer> }}
+     */
+    pendingStructs: null | {
+        missing: Map<number, number>;
+        update: Uint8Array<ArrayBuffer>;
+    };
+    /**
+     * @type {null | Uint8Array<ArrayBuffer>}
+     */
+    pendingDs: null | Uint8Array<ArrayBuffer>;
+    skips: import("./IdSet.js").IdSet;
+    get ds(): import("./IdSet.js").IdSet;
+}
+export function getStateVector(store: StructStore): Map<number, number>;
+export function getState(store: StructStore, client: number): number;
+export function integrityCheck(store: StructStore): void;
+export function addStruct(store: StructStore, struct: GC | Item): void;
+export function findIndexSS(structs: Array<Item | GC>, clock: number): number;
+export function find(store: StructStore, id: ID): GC | Item;
+/**
+ * Expects that id is actually in store. This function throws or is an infinite loop otherwise.
+ * @private
+ * @function
+ */
+export const getItem: (arg0: StructStore, arg1: ID) => Item;
+export function findIndexCleanStart(transaction: Transaction | null, structs: Array<Item | GC>, clock: number): number;
+export function getItemCleanStart(transaction: Transaction, id: ID): Item;
+export function getItemCleanEnd(transaction: Transaction, store: StructStore, id: ID): Item;
+export function replaceStruct(tr: Transaction, struct: GC | Item, newStruct: GC | Item): void;
+export function iterateStructs(transaction: Transaction, structs: Array<Item | GC>, clockStart: number, len: number, f: (arg0: GC | Item) => void): void;
+import { GC } from '../internals.js';
+import { Item } from '../internals.js';
+import { ID } from '../internals.js';
+import { Transaction } from '../internals.js';
+//# sourceMappingURL=StructStore.d.ts.map

package/dist/src/utils/StructStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StructStore.d.ts","sourceRoot":"","sources":["../../../src/utils/StructStore.js"],"names":[],"mappings":"AAcA;IAEI;;OAEG;IACH,SAFU,GAAG,CAAC,MAAM,EAAC,KAAK,CAAC,EAAE,GAAC,IAAI,CAAC,CAAC,CAEZ;IAExB;;OAEG;IACH,gBAFU,IAAI,GAAG;QAAE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,CAAA;KAAE,CAExD;IAC1B;;OAEG;IACH,WAFU,IAAI,GAAG,UAAU,CAAC,WAAW,CAAC,CAEnB;IACrB,kCAA0B;IAG5B,qCAEC;CACF;AAYM,sCANI,WAAW,GACV,GAAG,CAAC,MAAM,EAAC,MAAM,CAAC,CAe7B;AAUM,gCAPI,WAAW,UACX,MAAM,GACL,MAAM,CAYjB;AAQM,sCALI,WAAW,QAerB;AASM,iCANI,WAAW,UACX,EAAE,GAAC,IAAI,QA8BjB;AAWM,qCAPI,KAAK,CAAC,IAAI,GAAC,EAAE,CAAC,SACd,MAAM,GACL,MAAM,CAiCjB;AAYM,4BAPI,WAAW,MACX,EAAE,GACD,EAAE,GAAC,IAAI,CAYlB;AAED;;;;GAIG;AACH,sBAAkC,CAAS,IAAW,EAAX,WAAW,EAAC,IAAE,EAAF,EAAE,KAAE,IAAI,CAAW;AAOnE,iDAJI,WAAW,OAAC,WACZ,KAAK,CAAC,IAAI,GAAC,EAAE,CAAC,SACd,MAAM,UAUhB;AAYM,+CAPI,WAAW,MACX,EAAE,GACD,IAAI,CAQf;AAaM,6CARI,WAAW,SACX,WAAW,MACX,EAAE,GACD,IAAI,CAiBf;AAWM,kCAPI,WAAW,UACX,EAAE,GAAC,IAAI,aACP,EAAE,GAAC,IAAI,QASjB;AAaM,4CARI,WAAW,WACX,KAAK,CAAC,IAAI,GAAC,EAAE,CAAC,cACd,MAAM,OACN,MAAM,KACN,CAAS,IAAO,EAAP,EAAE,GAAC,IAAI,KAAE,IAAI,QAkBhC;mBAvRM,iBAAiB;qBAAjB,iBAAiB;mBAAjB,iBAAiB;4BAAjB,iBAAiB"}