leaflet.pub
a tool for shared writing and social publishing
use wasm yjs in push handler
awarm.space
+6647
-2
public/wasm/ywasm_bg.wasm
public/wasm/ywasm_bg.wasm
This is a binary file and will not be displayed.
+2
-2
src/replicache/cachedServerMutationContext.ts
+2
-2
src/replicache/cachedServerMutationContext.ts
···
7
7
import { Attribute, Attributes, FilterAttributes } from "./attributes";
8
8
import { v7 } from "uuid";
9
9
import * as base64 from "base64-js";
10
-
import * as Y from "yjs";
10
+
import * as Y from "src/ywasm";
11
11
import { DeepReadonly } from "replicache";
12
12
13
13
type WriteCacheEntry =
···
186
186
if (values.length > 0) {
187
187
let existingFact = await scanIndex.eav(f.entity, f.attribute);
188
188
if (existingFact[0]) values.push(existingFact[0].data.value);
189
-
let updateBytes = Y.mergeUpdates(
189
+
let updateBytes = Y.mergeUpdatesV1(
190
190
values.map((v) => base64.toByteArray(v)),
191
191
);
192
192
data.value = base64.fromByteArray(updateBytes);
+23
src/ywasm/LICENSE
+23
src/ywasm/LICENSE
···
1
+
The MIT License (MIT)
2
+
3
+
Copyright (c) 2020
4
+
- Kevin Jahns <kevin.jahns@pm.me>.
5
+
- Bartosz Sypytkowski <b.sypytkowski@gmail.com>.
6
+
7
+
Permission is hereby granted, free of charge, to any person obtaining a copy
8
+
of this software and associated documentation files (the "Software"), to deal
9
+
in the Software without restriction, including without limitation the rights
10
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11
+
copies of the Software, and to permit persons to whom the Software is
12
+
furnished to do so, subject to the following conditions:
13
+
14
+
The above copyright notice and this permission notice shall be included in all
15
+
copies or substantial portions of the Software.
16
+
17
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23
+
SOFTWARE.
+36
src/ywasm/README.md
+36
src/ywasm/README.md
···
1
+
# Ywasm
2
+
3
+
This project is a wrapper around [Yrs](../yrs/README.md) and targets Web Assembly bindings.
4
+
5
+
It's a library used on collaborative document editing using Conflict-free Replicated Data Types.
6
+
This enables to provide a shared document editing experience on a client devices without explicit requirement for hosting a single server - CRDTs can resolve potential update conflicts on their own with no central authority - as well as provide first-class offline editing capabilities, where document replicas are modified without having connection to each other, and then synchronize automatically once such connection is enabled.
7
+
8
+
## [Documentation](https://docs.rs/ywasm/)
9
+
10
+
## Example
11
+
12
+
```js
13
+
import * as Y from 'ywasm';
14
+
15
+
const doc = new Y.YDoc()
16
+
const text = doc.getText('name')
17
+
18
+
// append text to our collaborative document
19
+
text.insert(0, 'hello world', { bold: true })
20
+
21
+
// simulate update with remote peer
22
+
const remoteDoc = new Y.YDoc()
23
+
const remoteText = remoteDoc.getText('name')
24
+
25
+
// in order to exchange data with other documents
26
+
// we first need to create a state vector
27
+
const remoteSV = Y.encodeStateVector(remoteDoc)
28
+
// now compute a differential update based on remote document's state vector
29
+
const update = Y.encodeStateAsUpdate(doc, remoteSV)
30
+
// both update and state vector are serializable, we can pass them over the wire
31
+
// now apply update to a remote document
32
+
Y.applyUpdate(remoteDoc, update)
33
+
34
+
const str = remoteText.toString()
35
+
console.log(str)
36
+
```
+27
src/ywasm/package.json
+27
src/ywasm/package.json
···
1
+
{
2
+
"name": "ywasm",
3
+
"collaborators": [
4
+
"Kevin Jahns <kevin.jahns@protonmail.com>",
5
+
"Bartosz Sypytkowski <b.sypytkowski@gmail.com>"
6
+
],
7
+
"description": "High performance implementation of the Yjs CRDT",
8
+
"version": "0.24.0",
9
+
"license": "MIT",
10
+
"repository": {
11
+
"type": "git",
12
+
"url": "https://github.com/yjs/y-crdt/"
13
+
},
14
+
"files": [
15
+
"ywasm_bg.wasm",
16
+
"ywasm.js",
17
+
"ywasm.d.ts"
18
+
],
19
+
"main": "ywasm.js",
20
+
"homepage": "https://github.com/yjs/y-crdt/",
21
+
"types": "ywasm.d.ts",
22
+
"keywords": [
23
+
"crdt",
24
+
"wasm",
25
+
"yrs"
26
+
]
27
+
}
+1537
src/ywasm/ywasm.d.ts
+1537
src/ywasm/ywasm.d.ts
···
1
+
/* tslint:disable */
2
+
/* eslint-disable */
3
+
/**
4
+
* When called will call console log errors whenever internal panic is called from within
5
+
* WebAssembly module.
6
+
*/
7
+
export function setPanicHook(): void;
8
+
/**
9
+
* Encodes a state vector of a given ywasm document into its binary representation using lib0 v1
10
+
* encoding. State vector is a compact representation of updates performed on a given document and
11
+
* can be used by `encode_state_as_update` on remote peer to generate a delta update payload to
12
+
* synchronize changes between peers.
13
+
*
14
+
* Example:
15
+
*
16
+
* ```javascript
17
+
* import {YDoc, encodeStateVector, encodeStateAsUpdate, applyUpdate} from 'ywasm'
18
+
*
19
+
* /// document on machine A
20
+
* const localDoc = new YDoc()
21
+
* const localSV = encodeStateVector(localDoc)
22
+
*
23
+
* // document on machine B
24
+
* const remoteDoc = new YDoc()
25
+
* const remoteDelta = encodeStateAsUpdate(remoteDoc, localSV)
26
+
*
27
+
* applyUpdate(localDoc, remoteDelta)
28
+
* ```
29
+
*/
30
+
export function encodeStateVector(doc: YDoc): Uint8Array;
31
+
/**
32
+
* Returns a string dump representation of a given `update` encoded using lib0 v1 encoding.
33
+
*/
34
+
export function debugUpdateV1(update: Uint8Array): string;
35
+
/**
36
+
* Returns a string dump representation of a given `update` encoded using lib0 v2 encoding.
37
+
*/
38
+
export function debugUpdateV2(update: Uint8Array): string;
39
+
/**
40
+
* Merges a sequence of updates (encoded using lib0 v1 encoding) together, producing another
41
+
* update (also lib0 v1 encoded) in the result. Returned binary is a combination of all input
42
+
* `updates`, compressed.
43
+
*
44
+
* Returns an error whenever any of the input updates couldn't be decoded.
45
+
*/
46
+
export function mergeUpdatesV1(updates: Array<any>): Uint8Array;
47
+
/**
48
+
* Merges a sequence of updates (encoded using lib0 v2 encoding) together, producing another
49
+
* update (also lib0 v2 encoded) in the result. Returned binary is a combination of all input
50
+
* `updates`, compressed.
51
+
*
52
+
* Returns an error whenever any of the input updates couldn't be decoded.
53
+
*/
54
+
export function mergeUpdatesV2(updates: Array<any>): Uint8Array;
55
+
/**
56
+
* Encodes all updates that have happened since a given version `vector` into a compact delta
57
+
* representation using lib0 v1 encoding. If `vector` parameter has not been provided, generated
58
+
* delta payload will contain all changes of a current ywasm document, working effectivelly as its
59
+
* state snapshot.
60
+
*
61
+
* Example:
62
+
*
63
+
* ```javascript
64
+
* import {YDoc, encodeStateVector, encodeStateAsUpdate, applyUpdate} from 'ywasm'
65
+
*
66
+
* /// document on machine A
67
+
* const localDoc = new YDoc()
68
+
* const localSV = encodeStateVector(localDoc)
69
+
*
70
+
* // document on machine B
71
+
* const remoteDoc = new YDoc()
72
+
* const remoteDelta = encodeStateAsUpdate(remoteDoc, localSV)
73
+
*
74
+
* applyUpdate(localDoc, remoteDelta)
75
+
* ```
76
+
*/
77
+
export function encodeStateAsUpdate(doc: YDoc, vector?: Uint8Array | null): Uint8Array;
78
+
/**
79
+
* Encodes all updates that have happened since a given version `vector` into a compact delta
80
+
* representation using lib0 v2 encoding. If `vector` parameter has not been provided, generated
81
+
* delta payload will contain all changes of a current ywasm document, working effectivelly as its
82
+
* state snapshot.
83
+
*
84
+
* Example:
85
+
*
86
+
* ```javascript
87
+
* import {YDoc, encodeStateVector, encodeStateAsUpdate, applyUpdate} from 'ywasm'
88
+
*
89
+
* /// document on machine A
90
+
* const localDoc = new YDoc()
91
+
* const localSV = encodeStateVector(localDoc)
92
+
*
93
+
* // document on machine B
94
+
* const remoteDoc = new YDoc()
95
+
* const remoteDelta = encodeStateAsUpdateV2(remoteDoc, localSV)
96
+
*
97
+
* applyUpdate(localDoc, remoteDelta)
98
+
* ```
99
+
*/
100
+
export function encodeStateAsUpdateV2(doc: YDoc, vector?: Uint8Array | null): Uint8Array;
101
+
/**
102
+
* Applies delta update generated by the remote document replica to a current document. This
103
+
* method assumes that a payload maintains lib0 v1 encoding format.
104
+
*
105
+
* Example:
106
+
*
107
+
* ```javascript
108
+
* import {YDoc, encodeStateVector, encodeStateAsUpdate, applyUpdate} from 'ywasm'
109
+
*
110
+
* /// document on machine A
111
+
* const localDoc = new YDoc()
112
+
* const localSV = encodeStateVector(localDoc)
113
+
*
114
+
* // document on machine B
115
+
* const remoteDoc = new YDoc()
116
+
* const remoteDelta = encodeStateAsUpdate(remoteDoc, localSV)
117
+
*
118
+
* applyUpdateV2(localDoc, remoteDelta)
119
+
* ```
120
+
*/
121
+
export function applyUpdate(doc: YDoc, update: Uint8Array, origin: any): void;
122
+
/**
123
+
* Applies delta update generated by the remote document replica to a current document. This
124
+
* method assumes that a payload maintains lib0 v2 encoding format.
125
+
*
126
+
* Example:
127
+
*
128
+
* ```javascript
129
+
* import {YDoc, encodeStateVector, encodeStateAsUpdate, applyUpdate} from 'ywasm'
130
+
*
131
+
* /// document on machine A
132
+
* const localDoc = new YDoc()
133
+
* const localSV = encodeStateVector(localDoc)
134
+
*
135
+
* // document on machine B
136
+
* const remoteDoc = new YDoc()
137
+
* const remoteDelta = encodeStateAsUpdateV2(remoteDoc, localSV)
138
+
*
139
+
* applyUpdateV2(localDoc, remoteDelta)
140
+
* ```
141
+
*/
142
+
export function applyUpdateV2(doc: YDoc, update: Uint8Array, origin: any): void;
143
+
export function snapshot(doc: YDoc): any;
144
+
export function equalSnapshots(snap1: any, snap2: any): boolean;
145
+
export function encodeSnapshotV1(snapshot: any): Uint8Array;
146
+
export function encodeSnapshotV2(snapshot: any): Uint8Array;
147
+
export function decodeSnapshotV2(snapshot: Uint8Array): any;
148
+
export function decodeSnapshotV1(snapshot: Uint8Array): any;
149
+
export function encodeStateFromSnapshotV1(doc: YDoc, snapshot: any): Uint8Array;
150
+
export function encodeStateFromSnapshotV2(doc: YDoc, snapshot: any): Uint8Array;
151
+
/**
152
+
* Retrieves a sticky index corresponding to a given human-readable `index` pointing into
153
+
* the shared `ytype`. Unlike standard indexes sticky indexes enables to track
154
+
* the location inside of a shared y-types, even in the face of concurrent updates.
155
+
*
156
+
* If association is >= 0, the resulting position will point to location **after** the referenced index.
157
+
* If association is < 0, the resulting position will point to location **before** the referenced index.
158
+
*/
159
+
export function createRelativePositionFromTypeIndex(ytype: any, index: number, assoc: number, txn: YTransaction | undefined): any;
160
+
/**
161
+
* Converts a sticky index (see: `createStickyIndexFromType`) into an object
162
+
* containing human-readable index.
163
+
*/
164
+
export function createAbsolutePositionFromRelativePosition(rpos: any, doc: YDoc): any;
165
+
/**
166
+
* Serializes sticky index created by `createStickyIndexFromType` into a binary
167
+
* payload.
168
+
*/
169
+
export function encodeRelativePosition(rpos: any): Uint8Array;
170
+
/**
171
+
* Deserializes sticky index serialized previously by `encodeStickyIndex`.
172
+
*/
173
+
export function decodeRelativePosition(bin: Uint8Array): any;
174
+
export function compareRelativePositions(a: any, b: any): boolean;
175
+
export function removeAwarenessStates(awareness: Awareness, clients: BigUint64Array): void;
176
+
export function encodeAwarenessUpdate(awareness: Awareness, clients: any): Uint8Array;
177
+
export function modifyAwarenessUpdate(update: Uint8Array, modify: Function): Uint8Array;
178
+
export function applyAwarenessUpdate(awareness: Awareness, update: Uint8Array, _origin: any): void;
179
+
export class Awareness {
180
+
free(): void;
181
+
constructor(doc: YDoc);
182
+
destroy(): void;
183
+
getLocalState(): any;
184
+
setLocalState(state: any): void;
185
+
setLocalStateField(key: string, value: any): void;
186
+
getStates(): Map<any, any>;
187
+
on(event: string, callback: Function): void;
188
+
off(event: string, callback: Function): boolean;
189
+
readonly doc: YDoc;
190
+
readonly meta: Map<any, any>;
191
+
}
192
+
/**
193
+
* A collection used to store data in an indexed sequence structure. This type is internally
194
+
* implemented as a double linked list, which may squash values inserted directly one after another
195
+
* into single list node upon transaction commit.
196
+
*
197
+
* Reading a root-level type as an YArray means treating its sequence components as a list, where
198
+
* every countable element becomes an individual entity:
199
+
*
200
+
* - JSON-like primitives (booleans, numbers, strings, JSON maps, arrays etc.) are counted
201
+
* individually.
202
+
* - Text chunks inserted by [Text] data structure: each character becomes an element of an
203
+
* array.
204
+
* - Embedded and binary values: they count as a single element even though they correspond of
205
+
* multiple bytes.
206
+
*
207
+
* Like all Yrs shared data types, YArray is resistant to the problem of interleaving (situation
208
+
* when elements inserted one after another may interleave with other peers concurrent inserts
209
+
* after merging all updates together). In case of Yrs conflict resolution is solved by using
210
+
* unique document id to determine correct and consistent ordering.
211
+
*/
212
+
export class YArray {
213
+
free(): void;
214
+
/**
215
+
* Creates a new preliminary instance of a `YArray` shared data type, with its state
216
+
* initialized to provided parameter.
217
+
*
218
+
* Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.
219
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
220
+
* document store and cannot be nested again: attempt to do so will result in an exception.
221
+
*/
222
+
constructor(items?: any[] | null);
223
+
/**
224
+
* Checks if current YArray reference is alive and has not been deleted by its parent collection.
225
+
* This method only works on already integrated shared types and will return false is current
226
+
* type is preliminary (has not been integrated into document).
227
+
*/
228
+
alive(txn: YTransaction): boolean;
229
+
/**
230
+
* Returns a number of elements stored within this instance of `YArray`.
231
+
*/
232
+
length(txn: YTransaction | undefined): number;
233
+
/**
234
+
* Converts an underlying contents of this `YArray` instance into their JSON representation.
235
+
*/
236
+
toJson(txn: YTransaction | undefined): any;
237
+
/**
238
+
* Inserts a given range of `items` into this `YArray` instance, starting at given `index`.
239
+
*/
240
+
insert(index: number, items: any[], txn: YTransaction | undefined): void;
241
+
/**
242
+
* Appends a range of `items` at the end of this `YArray` instance.
243
+
*/
244
+
push(items: any[], txn: YTransaction | undefined): void;
245
+
/**
246
+
* Deletes a range of items of given `length` from current `YArray` instance,
247
+
* starting from given `index`.
248
+
*/
249
+
delete(index: number, length: number | null | undefined, txn: YTransaction | undefined): void;
250
+
/**
251
+
* Moves element found at `source` index into `target` index position.
252
+
*/
253
+
move(source: number, target: number, txn: YTransaction | undefined): void;
254
+
/**
255
+
* Returns an element stored under given `index`.
256
+
*/
257
+
get(index: number, txn: YTransaction | undefined): any;
258
+
quote(lower: number | null | undefined, upper: number | null | undefined, lower_open: boolean | null | undefined, upper_open: boolean | null | undefined, txn: YTransaction | undefined): YWeakLink;
259
+
/**
260
+
* Returns an iterator that can be used to traverse over the values stored withing this
261
+
* instance of `YArray`.
262
+
*
263
+
* Example:
264
+
*
265
+
* ```javascript
266
+
* import YDoc from 'ywasm'
267
+
*
268
+
* /// document on machine A
269
+
* const doc = new YDoc()
270
+
* const array = doc.getArray('name')
271
+
* const txn = doc.beginTransaction()
272
+
* try {
273
+
* array.push(txn, ['hello', 'world'])
274
+
* for (let item of array.values(txn)) {
275
+
* console.log(item)
276
+
* }
277
+
* } finally {
278
+
* txn.free()
279
+
* }
280
+
* ```
281
+
*/
282
+
values(txn: YTransaction | undefined): any;
283
+
/**
284
+
* Subscribes to all operations happening over this instance of `YArray`. All changes are
285
+
* batched and eventually triggered during transaction commit phase.
286
+
*/
287
+
observe(callback: Function): void;
288
+
unobserve(callback: Function): boolean;
289
+
/**
290
+
* Subscribes to all operations happening over this Y shared type, as well as events in
291
+
* shared types stored within this one. All changes are batched and eventually triggered
292
+
* during transaction commit phase.
293
+
*/
294
+
observeDeep(callback: Function): void;
295
+
unobserveDeep(callback: Function): boolean;
296
+
readonly type: number;
297
+
/**
298
+
* Gets unique logical identifier of this type, shared across peers collaborating on the same
299
+
* document.
300
+
*/
301
+
readonly id: any;
302
+
/**
303
+
* Returns true if this is a preliminary instance of `YArray`.
304
+
*
305
+
* Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.
306
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
307
+
* document store and cannot be nested again: attempt to do so will result in an exception.
308
+
*/
309
+
readonly prelim: boolean;
310
+
}
311
+
/**
312
+
* Event generated by `YArray.observe` method. Emitted during transaction commit phase.
313
+
*/
314
+
export class YArrayEvent {
315
+
private constructor();
316
+
free(): void;
317
+
/**
318
+
* Returns an array of keys and indexes creating a path from root type down to current instance
319
+
* of shared type (accessible via `target` getter).
320
+
*/
321
+
path(): any;
322
+
/**
323
+
* Returns a current shared type instance, that current event changes refer to.
324
+
*/
325
+
readonly target: any;
326
+
readonly origin: any;
327
+
/**
328
+
* Returns a list of text changes made over corresponding `YArray` collection within
329
+
* bounds of current transaction. These changes follow a format:
330
+
*
331
+
* - { insert: any[] }
332
+
* - { delete: number }
333
+
* - { retain: number }
334
+
*/
335
+
readonly delta: any;
336
+
}
337
+
/**
338
+
* A ywasm document type. Documents are most important units of collaborative resources management.
339
+
* All shared collections live within a scope of their corresponding documents. All updates are
340
+
* generated on per-document basis (rather than individual shared type). All operations on shared
341
+
* collections happen via [YTransaction], which lifetime is also bound to a document.
342
+
*
343
+
* Document manages so-called root types, which are top-level shared types definitions (as opposed
344
+
* to recursively nested types).
345
+
*
346
+
* A basic workflow sample:
347
+
*
348
+
* ```javascript
349
+
* import YDoc from 'ywasm'
350
+
*
351
+
* const doc = new YDoc()
352
+
* const txn = doc.beginTransaction()
353
+
* try {
354
+
* const text = txn.getText('name')
355
+
* text.push(txn, 'hello world')
356
+
* const output = text.toString(txn)
357
+
* console.log(output)
358
+
* } finally {
359
+
* txn.free()
360
+
* }
361
+
* ```
362
+
*/
363
+
export class YDoc {
364
+
free(): void;
365
+
/**
366
+
* Creates a new ywasm document. If `id` parameter was passed it will be used as this document
367
+
* globally unique identifier (it's up to caller to ensure that requirement). Otherwise it will
368
+
* be assigned a randomly generated number.
369
+
*/
370
+
constructor(options: any);
371
+
/**
372
+
* Returns a new transaction for this document. Ywasm shared data types execute their
373
+
* operations in a context of a given transaction. Each document can have only one active
374
+
* transaction at the time - subsequent attempts will cause exception to be thrown.
375
+
*
376
+
* Transactions started with `doc.beginTransaction` can be released using `transaction.free`
377
+
* method.
378
+
*
379
+
* Example:
380
+
*
381
+
* ```javascript
382
+
* import YDoc from 'ywasm'
383
+
*
384
+
* // helper function used to simplify transaction
385
+
* // create/release cycle
386
+
* YDoc.prototype.transact = callback => {
387
+
* const txn = this.transaction()
388
+
* try {
389
+
* return callback(txn)
390
+
* } finally {
391
+
* txn.free()
392
+
* }
393
+
* }
394
+
*
395
+
* const doc = new YDoc()
396
+
* const text = doc.getText('name')
397
+
* doc.transact(txn => text.insert(txn, 0, 'hello world'))
398
+
* ```
399
+
*/
400
+
beginTransaction(origin: any): YTransaction;
401
+
/**
402
+
* Returns a `YText` shared data type, that's accessible for subsequent accesses using given
403
+
* `name`.
404
+
*
405
+
* If there was no instance with this name before, it will be created and then returned.
406
+
*
407
+
* If there was an instance with this name, but it was of different type, it will be projected
408
+
* onto `YText` instance.
409
+
*/
410
+
getText(name: string): YText;
411
+
/**
412
+
* Returns a `YArray` shared data type, that's accessible for subsequent accesses using given
413
+
* `name`.
414
+
*
415
+
* If there was no instance with this name before, it will be created and then returned.
416
+
*
417
+
* If there was an instance with this name, but it was of different type, it will be projected
418
+
* onto `YArray` instance.
419
+
*/
420
+
getArray(name: string): YArray;
421
+
/**
422
+
* Returns a `YMap` shared data type, that's accessible for subsequent accesses using given
423
+
* `name`.
424
+
*
425
+
* If there was no instance with this name before, it will be created and then returned.
426
+
*
427
+
* If there was an instance with this name, but it was of different type, it will be projected
428
+
* onto `YMap` instance.
429
+
*/
430
+
getMap(name: string): YMap;
431
+
/**
432
+
* Returns a `YXmlFragment` shared data type, that's accessible for subsequent accesses using
433
+
* given `name`.
434
+
*
435
+
* If there was no instance with this name before, it will be created and then returned.
436
+
*
437
+
* If there was an instance with this name, but it was of different type, it will be projected
438
+
* onto `YXmlFragment` instance.
439
+
*/
440
+
getXmlFragment(name: string): YXmlFragment;
441
+
on(event: string, callback: Function): void;
442
+
off(event: string, callback: Function): boolean;
443
+
/**
444
+
* Notify the parent document that you request to load data into this subdocument
445
+
* (if it is a subdocument).
446
+
*/
447
+
load(parent_txn: YTransaction | undefined): void;
448
+
/**
449
+
* Emit `onDestroy` event and unregister all event handlers.
450
+
*/
451
+
destroy(parent_txn: YTransaction | undefined): void;
452
+
/**
453
+
* Returns a list of sub-documents existings within the scope of this document.
454
+
*/
455
+
getSubdocs(txn: YTransaction | undefined): Array<any>;
456
+
/**
457
+
* Returns a list of unique identifiers of the sub-documents existings within the scope of
458
+
* this document.
459
+
*/
460
+
getSubdocGuids(txn: YTransaction | undefined): Set<any>;
461
+
/**
462
+
* Returns a list of all root-level replicated collections, together with their types.
463
+
* These collections can then be accessed via `getMap`/`getText` etc. methods.
464
+
*
465
+
* Example:
466
+
* ```js
467
+
* import * as Y from 'ywasm'
468
+
*
469
+
* const doc = new Y.YDoc()
470
+
* const ymap = doc.getMap('a')
471
+
* const yarray = doc.getArray('b')
472
+
* const ytext = doc.getText('c')
473
+
* const yxml = doc.getXmlFragment('d')
474
+
*
475
+
* const roots = doc.roots() // [['a',ymap], ['b',yarray], ['c',ytext], ['d',yxml]]
476
+
* ```
477
+
*/
478
+
roots(txn: YTransaction | undefined): Array<any>;
479
+
/**
480
+
* Evaluates a JSON path expression (see: https://en.wikipedia.org/wiki/JSONPath) on
481
+
* the document and returns an array of values matching that query.
482
+
*
483
+
* Currently, this method supports the following syntax:
484
+
* - `$` - root object
485
+
* - `@` - current object
486
+
* - `.field` or `['field']` - member accessor
487
+
* - `[1]` - array index (also supports negative indices)
488
+
* - `.*` or `[*]` - wildcard (matches all members of an object or array)
489
+
* - `..` - recursive descent (matches all descendants not only direct children)
490
+
* - `[start:end:step]` - array slice operator (requires positive integer arguments)
491
+
* - `['a', 'b', 'c']` - union operator (returns an array of values for each query)
492
+
* - `[1, -1, 3]` - multiple indices operator (returns an array of values for each index)
493
+
*
494
+
* At the moment, JSON Path does not support filter predicates.
495
+
*/
496
+
selectAll(json_path: string): Array<any>;
497
+
/**
498
+
* Evaluates a JSON path expression (see: https://en.wikipedia.org/wiki/JSONPath) on
499
+
* the document and returns first value matching that query.
500
+
*
501
+
* Currently, this method supports the following syntax:
502
+
* - `$` - root object
503
+
* - `@` - current object
504
+
* - `.field` or `['field']` - member accessor
505
+
* - `[1]` - array index (also supports negative indices)
506
+
* - `.*` or `[*]` - wildcard (matches all members of an object or array)
507
+
* - `..` - recursive descent (matches all descendants not only direct children)
508
+
* - `[start:end:step]` - array slice operator (requires positive integer arguments)
509
+
* - `['a', 'b', 'c']` - union operator (returns an array of values for each query)
510
+
* - `[1, -1, 3]` - multiple indices operator (returns an array of values for each index)
511
+
*
512
+
* At the moment, JSON Path does not support filter predicates.
513
+
*/
514
+
selectOne(json_path: string): any;
515
+
readonly type: number;
516
+
/**
517
+
* Checks if a document is a preliminary type. It returns false, if current document
518
+
* is already a sub-document of another document.
519
+
*/
520
+
readonly prelim: boolean;
521
+
/**
522
+
* Returns a parent document of this document or null if current document is not sub-document.
523
+
*/
524
+
readonly parentDoc: YDoc | undefined;
525
+
/**
526
+
* Gets unique peer identifier of this `YDoc` instance.
527
+
*/
528
+
readonly id: number;
529
+
/**
530
+
* Gets globally unique identifier of this `YDoc` instance.
531
+
*/
532
+
readonly guid: string;
533
+
readonly shouldLoad: boolean;
534
+
readonly autoLoad: boolean;
535
+
}
536
+
/**
537
+
* Collection used to store key-value entries in an unordered manner. Keys are always represented
538
+
* as UTF-8 strings. Values can be any value type supported by Yrs: JSON-like primitives as well as
539
+
* shared data types.
540
+
*
541
+
* In terms of conflict resolution, [Map] uses logical last-write-wins principle, meaning the past
542
+
* updates are automatically overridden and discarded by newer ones, while concurrent updates made
543
+
* by different peers are resolved into a single value using document id seniority to establish
544
+
* order.
545
+
*/
546
+
export class YMap {
547
+
free(): void;
548
+
/**
549
+
* Creates a new preliminary instance of a `YMap` shared data type, with its state
550
+
* initialized to provided parameter.
551
+
*
552
+
* Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.
553
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
554
+
* document store and cannot be nested again: attempt to do so will result in an exception.
555
+
*/
556
+
constructor(init?: object | null);
557
+
/**
558
+
* Checks if current YMap reference is alive and has not been deleted by its parent collection.
559
+
* This method only works on already integrated shared types and will return false is current
560
+
* type is preliminary (has not been integrated into document).
561
+
*/
562
+
alive(txn: YTransaction): boolean;
563
+
/**
564
+
* Returns a number of entries stored within this instance of `YMap`.
565
+
*/
566
+
length(txn: YTransaction | undefined): number;
567
+
/**
568
+
* Converts contents of this `YMap` instance into a JSON representation.
569
+
*/
570
+
toJson(txn: YTransaction | undefined): any;
571
+
/**
572
+
* Sets a given `key`-`value` entry within this instance of `YMap`. If another entry was
573
+
* already stored under given `key`, it will be overridden with new `value`.
574
+
*/
575
+
set(key: string, value: any, txn: YTransaction | undefined): void;
576
+
/**
577
+
* Removes an entry identified by a given `key` from this instance of `YMap`, if such exists.
578
+
*/
579
+
delete(key: string, txn: YTransaction | undefined): void;
580
+
/**
581
+
* Returns value of an entry stored under given `key` within this instance of `YMap`,
582
+
* or `undefined` if no such entry existed.
583
+
*/
584
+
get(key: string, txn: YTransaction | undefined): any;
585
+
link(key: string, txn: YTransaction | undefined): any;
586
+
/**
587
+
* Returns an iterator that can be used to traverse over all entries stored within this
588
+
* instance of `YMap`. Order of entry is not specified.
589
+
*
590
+
* Example:
591
+
*
592
+
* ```javascript
593
+
* import YDoc from 'ywasm'
594
+
*
595
+
* /// document on machine A
596
+
* const doc = new YDoc()
597
+
* const map = doc.getMap('name')
598
+
* const txn = doc.beginTransaction()
599
+
* try {
600
+
* map.set(txn, 'key1', 'value1')
601
+
* map.set(txn, 'key2', true)
602
+
*
603
+
* for (let [key, value] of map.entries(txn)) {
604
+
* console.log(key, value)
605
+
* }
606
+
* } finally {
607
+
* txn.free()
608
+
* }
609
+
* ```
610
+
*/
611
+
entries(txn: YTransaction | undefined): any;
612
+
/**
613
+
* Subscribes to all operations happening over this instance of `YMap`. All changes are
614
+
* batched and eventually triggered during transaction commit phase.
615
+
*/
616
+
observe(callback: Function): void;
617
+
/**
618
+
* Unsubscribes a callback previously subscribed with `observe` method.
619
+
*/
620
+
unobserve(callback: Function): boolean;
621
+
/**
622
+
* Subscribes to all operations happening over this Y shared type, as well as events in
623
+
* shared types stored within this one. All changes are batched and eventually triggered
624
+
* during transaction commit phase.
625
+
*/
626
+
observeDeep(callback: Function): void;
627
+
/**
628
+
* Unsubscribes a callback previously subscribed with `observeDeep` method.
629
+
*/
630
+
unobserveDeep(callback: Function): boolean;
631
+
readonly type: number;
632
+
/**
633
+
* Gets unique logical identifier of this type, shared across peers collaborating on the same
634
+
* document.
635
+
*/
636
+
readonly id: any;
637
+
/**
638
+
* Returns true if this is a preliminary instance of `YMap`.
639
+
*
640
+
* Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.
641
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
642
+
* document store and cannot be nested again: attempt to do so will result in an exception.
643
+
*/
644
+
readonly prelim: boolean;
645
+
}
646
+
/**
647
+
* Event generated by `YMap.observe` method. Emitted during transaction commit phase.
648
+
*/
649
+
export class YMapEvent {
650
+
private constructor();
651
+
free(): void;
652
+
/**
653
+
* Returns an array of keys and indexes creating a path from root type down to current instance
654
+
* of shared type (accessible via `target` getter).
655
+
*/
656
+
path(): any;
657
+
readonly origin: any;
658
+
/**
659
+
* Returns a current shared type instance, that current event changes refer to.
660
+
*/
661
+
readonly target: any;
662
+
/**
663
+
* Returns a list of key-value changes made over corresponding `YMap` collection within
664
+
* bounds of current transaction. These changes follow a format:
665
+
*
666
+
* - { action: 'add'|'update'|'delete', oldValue: any|undefined, newValue: any|undefined }
667
+
*/
668
+
readonly keys: any;
669
+
}
670
+
export class YSubdocsEvent {
671
+
private constructor();
672
+
free(): void;
673
+
readonly added: Array<any>;
674
+
readonly removed: Array<any>;
675
+
readonly loaded: Array<any>;
676
+
}
677
+
/**
678
+
* A shared data type used for collaborative text editing. It enables multiple users to add and
679
+
* remove chunks of text in efficient manner. This type is internally represented as a mutable
680
+
* double-linked list of text chunks - an optimization occurs during `YTransaction.commit`, which
681
+
* allows to squash multiple consecutively inserted characters together as a single chunk of text
682
+
* even between transaction boundaries in order to preserve more efficient memory model.
683
+
*
684
+
* `YText` structure internally uses UTF-8 encoding and its length is described in a number of
685
+
* bytes rather than individual characters (a single UTF-8 code point can consist of many bytes).
686
+
*
687
+
* Like all Yrs shared data types, `YText` is resistant to the problem of interleaving (situation
688
+
* when characters inserted one after another may interleave with other peers concurrent inserts
689
+
* after merging all updates together). In case of Yrs conflict resolution is solved by using
690
+
* unique document id to determine correct and consistent ordering.
691
+
*/
692
+
export class YText {
693
+
free(): void;
694
+
/**
695
+
* Creates a new preliminary instance of a `YText` shared data type, with its state initialized
696
+
* to provided parameter.
697
+
*
698
+
* Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.
699
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
700
+
* document store and cannot be nested again: attempt to do so will result in an exception.
701
+
*/
702
+
constructor(init?: string | null);
703
+
/**
704
+
* Checks if current YArray reference is alive and has not been deleted by its parent collection.
705
+
* This method only works on already integrated shared types and will return false is current
706
+
* type is preliminary (has not been integrated into document).
707
+
*/
708
+
alive(txn: YTransaction): boolean;
709
+
/**
710
+
* Returns length of an underlying string stored in this `YText` instance,
711
+
* understood as a number of UTF-8 encoded bytes.
712
+
*/
713
+
length(txn: YTransaction | undefined): number;
714
+
/**
715
+
* Returns an underlying shared string stored in this data type.
716
+
*/
717
+
toString(txn: YTransaction | undefined): string;
718
+
/**
719
+
* Returns an underlying shared string stored in this data type.
720
+
*/
721
+
toJson(txn: YTransaction | undefined): any;
722
+
/**
723
+
* Inserts a given `chunk` of text into this `YText` instance, starting at a given `index`.
724
+
*
725
+
* Optional object with defined `attributes` will be used to wrap provided text `chunk`
726
+
* with a formatting blocks.`attributes` are only supported for a `YText` instance which
727
+
* already has been integrated into document store.
728
+
*/
729
+
insert(index: number, chunk: string, attributes: any, txn: YTransaction | undefined): void;
730
+
/**
731
+
* Inserts a given `embed` object into this `YText` instance, starting at a given `index`.
732
+
*
733
+
* Optional object with defined `attributes` will be used to wrap provided `embed`
734
+
* with a formatting blocks.`attributes` are only supported for a `YText` instance which
735
+
* already has been integrated into document store.
736
+
*/
737
+
insertEmbed(index: number, embed: any, attributes: any, txn: YTransaction | undefined): void;
738
+
/**
739
+
* Wraps an existing piece of text within a range described by `index`-`length` parameters with
740
+
* formatting blocks containing provided `attributes` metadata. This method only works for
741
+
* `YText` instances that already have been integrated into document store.
742
+
*/
743
+
format(index: number, length: number, attributes: any, txn: YTransaction | undefined): void;
744
+
/**
745
+
* Appends a given `chunk` of text at the end of current `YText` instance.
746
+
*
747
+
* Optional object with defined `attributes` will be used to wrap provided text `chunk`
748
+
* with a formatting blocks.`attributes` are only supported for a `YText` instance which
749
+
* already has been integrated into document store.
750
+
*/
751
+
push(chunk: string, attributes: any, txn: YTransaction | undefined): void;
752
+
/**
753
+
* Deletes a specified range of characters, starting at a given `index`.
754
+
* Both `index` and `length` are counted in terms of a number of UTF-8 character bytes.
755
+
*/
756
+
delete(index: number, length: number, txn: YTransaction | undefined): void;
757
+
quote(lower: number | null | undefined, upper: number | null | undefined, lower_open: boolean | null | undefined, upper_open: boolean | null | undefined, txn: YTransaction | undefined): YWeakLink;
758
+
/**
759
+
* Returns the Delta representation of this YText type.
760
+
*/
761
+
toDelta(snapshot: any, prev_snapshot: any, compute_ychange: Function | null | undefined, txn: YTransaction | undefined): Array<any>;
762
+
applyDelta(delta: Array<any>, txn: YTransaction | undefined): void;
763
+
/**
764
+
* Subscribes to all operations happening over this instance of `YText`. All changes are
765
+
* batched and eventually triggered during transaction commit phase.
766
+
*/
767
+
observe(callback: Function): void;
768
+
/**
769
+
* Unsubscribes a callback previously subscribed with `observe` method.
770
+
*/
771
+
unobserve(callback: Function): boolean;
772
+
/**
773
+
* Subscribes to all operations happening over this Y shared type, as well as events in
774
+
* shared types stored within this one. All changes are batched and eventually triggered
775
+
* during transaction commit phase.
776
+
*/
777
+
observeDeep(callback: Function): void;
778
+
/**
779
+
* Unsubscribes a callback previously subscribed with `observeDeep` method.
780
+
*/
781
+
unobserveDeep(callback: Function): boolean;
782
+
readonly type: number;
783
+
/**
784
+
* Gets unique logical identifier of this type, shared across peers collaborating on the same
785
+
* document.
786
+
*/
787
+
readonly id: any;
788
+
/**
789
+
* Returns true if this is a preliminary instance of `YArray`.
790
+
*
791
+
* Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.
792
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
793
+
* document store and cannot be nested again: attempt to do so will result in an exception.
794
+
*/
795
+
readonly prelim: boolean;
796
+
}
797
+
/**
798
+
* Event generated by `YYText.observe` method. Emitted during transaction commit phase.
799
+
*/
800
+
export class YTextEvent {
801
+
private constructor();
802
+
free(): void;
803
+
/**
804
+
* Returns an array of keys and indexes creating a path from root type down to current instance
805
+
* of shared type (accessible via `target` getter).
806
+
*/
807
+
path(): any;
808
+
/**
809
+
* Returns a current shared type instance, that current event changes refer to.
810
+
*/
811
+
readonly target: any;
812
+
readonly origin: any;
813
+
/**
814
+
* Returns a list of text changes made over corresponding `YText` collection within
815
+
* bounds of current transaction. These changes follow a format:
816
+
*
817
+
* - { insert: string, attributes: any|undefined }
818
+
* - { delete: number }
819
+
* - { retain: number, attributes: any|undefined }
820
+
*/
821
+
readonly delta: any;
822
+
}
823
+
export class YTransaction {
824
+
private constructor();
825
+
free(): void;
826
+
/**
827
+
* Given a logical identifier of the collection (obtained via `YText.id`, `YArray.id` etc.),
828
+
* attempts to return an instance of that collection in the scope of current document.
829
+
*
830
+
* Returns `undefined` if an instance was not defined locally, haven't been integrated or
831
+
* has been deleted.
832
+
*/
833
+
get(id: any): any;
834
+
/**
835
+
* Triggers a post-update series of operations without `free`ing the transaction. This includes
836
+
* compaction and optimization of internal representation of updates, triggering events etc.
837
+
* ywasm transactions are auto-committed when they are `free`d.
838
+
*/
839
+
commit(): void;
840
+
/**
841
+
* Encodes a state vector of a given transaction document into its binary representation using
842
+
* lib0 v1 encoding. State vector is a compact representation of updates performed on a given
843
+
* document and can be used by `encode_state_as_update` on remote peer to generate a delta
844
+
* update payload to synchronize changes between peers.
845
+
*
846
+
* Example:
847
+
*
848
+
* ```javascript
849
+
* import YDoc from 'ywasm'
850
+
*
851
+
* /// document on machine A
852
+
* const localDoc = new YDoc()
853
+
* const localTxn = localDoc.beginTransaction()
854
+
*
855
+
* // document on machine B
856
+
* const remoteDoc = new YDoc()
857
+
* const remoteTxn = localDoc.beginTransaction()
858
+
*
859
+
* try {
860
+
* const localSV = localTxn.stateVectorV1()
861
+
* const remoteDelta = remoteTxn.diffV1(localSv)
862
+
* localTxn.applyV1(remoteDelta)
863
+
* } finally {
864
+
* localTxn.free()
865
+
* remoteTxn.free()
866
+
* }
867
+
* ```
868
+
*/
869
+
stateVectorV1(): Uint8Array;
870
+
/**
871
+
* Encodes all updates that have happened since a given version `vector` into a compact delta
872
+
* representation using lib0 v1 encoding. If `vector` parameter has not been provided, generated
873
+
* delta payload will contain all changes of a current ywasm document, working effectively as
874
+
* its state snapshot.
875
+
*
876
+
* Example:
877
+
*
878
+
* ```javascript
879
+
* import YDoc from 'ywasm'
880
+
*
881
+
* /// document on machine A
882
+
* const localDoc = new YDoc()
883
+
* const localTxn = localDoc.beginTransaction()
884
+
*
885
+
* // document on machine B
886
+
* const remoteDoc = new YDoc()
887
+
* const remoteTxn = localDoc.beginTransaction()
888
+
*
889
+
* try {
890
+
* const localSV = localTxn.stateVectorV1()
891
+
* const remoteDelta = remoteTxn.diffV1(localSv)
892
+
* localTxn.applyV1(remoteDelta)
893
+
* } finally {
894
+
* localTxn.free()
895
+
* remoteTxn.free()
896
+
* }
897
+
* ```
898
+
*/
899
+
diffV1(vector?: Uint8Array | null): Uint8Array;
900
+
/**
901
+
* Encodes all updates that have happened since a given version `vector` into a compact delta
902
+
* representation using lib0 v1 encoding. If `vector` parameter has not been provided, generated
903
+
* delta payload will contain all changes of a current ywasm document, working effectively as
904
+
* its state snapshot.
905
+
*
906
+
* Example:
907
+
*
908
+
* ```javascript
909
+
* import YDoc from 'ywasm'
910
+
*
911
+
* /// document on machine A
912
+
* const localDoc = new YDoc()
913
+
* const localTxn = localDoc.beginTransaction()
914
+
*
915
+
* // document on machine B
916
+
* const remoteDoc = new YDoc()
917
+
* const remoteTxn = localDoc.beginTransaction()
918
+
*
919
+
* try {
920
+
* const localSV = localTxn.stateVectorV1()
921
+
* const remoteDelta = remoteTxn.diffV2(localSv)
922
+
* localTxn.applyV2(remoteDelta)
923
+
* } finally {
924
+
* localTxn.free()
925
+
* remoteTxn.free()
926
+
* }
927
+
* ```
928
+
*/
929
+
diffV2(vector?: Uint8Array | null): Uint8Array;
930
+
/**
931
+
* Applies delta update generated by the remote document replica to a current transaction's
932
+
* document. This method assumes that a payload maintains lib0 v1 encoding format.
933
+
*
934
+
* Example:
935
+
*
936
+
* ```javascript
937
+
* import YDoc from 'ywasm'
938
+
*
939
+
* /// document on machine A
940
+
* const localDoc = new YDoc()
941
+
* const localTxn = localDoc.beginTransaction()
942
+
*
943
+
* // document on machine B
944
+
* const remoteDoc = new YDoc()
945
+
* const remoteTxn = localDoc.beginTransaction()
946
+
*
947
+
* try {
948
+
* const localSV = localTxn.stateVectorV1()
949
+
* const remoteDelta = remoteTxn.diffV1(localSv)
950
+
* localTxn.applyV1(remoteDelta)
951
+
* } finally {
952
+
* localTxn.free()
953
+
* remoteTxn.free()
954
+
* }
955
+
* ```
956
+
*/
957
+
applyV1(diff: Uint8Array): void;
958
+
/**
959
+
* Applies delta update generated by the remote document replica to a current transaction's
960
+
* document. This method assumes that a payload maintains lib0 v2 encoding format.
961
+
*
962
+
* Example:
963
+
*
964
+
* ```javascript
965
+
* import YDoc from 'ywasm'
966
+
*
967
+
* /// document on machine A
968
+
* const localDoc = new YDoc()
969
+
* const localTxn = localDoc.beginTransaction()
970
+
*
971
+
* // document on machine B
972
+
* const remoteDoc = new YDoc()
973
+
* const remoteTxn = localDoc.beginTransaction()
974
+
*
975
+
* try {
976
+
* const localSV = localTxn.stateVectorV1()
977
+
* const remoteDelta = remoteTxn.diffV2(localSv)
978
+
* localTxn.applyV2(remoteDelta)
979
+
* } finally {
980
+
* localTxn.free()
981
+
* remoteTxn.free()
982
+
* }
983
+
* ```
984
+
*/
985
+
applyV2(diff: Uint8Array): void;
986
+
encodeUpdate(): Uint8Array;
987
+
encodeUpdateV2(): Uint8Array;
988
+
/**
989
+
* Force garbage collection of the deleted elements, regardless of a parent doc was created
990
+
* with `gc` option turned on or off.
991
+
*/
992
+
gc(): void;
993
+
/**
994
+
* Evaluates a JSON path expression (see: https://en.wikipedia.org/wiki/JSONPath) on
995
+
* the document and returns an array of values matching that query.
996
+
*
997
+
* Currently, this method supports the following syntax:
998
+
* - `$` - root object
999
+
* - `@` - current object
1000
+
* - `.field` or `['field']` - member accessor
1001
+
* - `[1]` - array index (also supports negative indices)
1002
+
* - `.*` or `[*]` - wildcard (matches all members of an object or array)
1003
+
* - `..` - recursive descent (matches all descendants not only direct children)
1004
+
* - `[start:end:step]` - array slice operator (requires positive integer arguments)
1005
+
* - `['a', 'b', 'c']` - union operator (returns an array of values for each query)
1006
+
* - `[1, -1, 3]` - multiple indices operator (returns an array of values for each index)
1007
+
*
1008
+
* At the moment, JSON Path does not support filter predicates.
1009
+
*/
1010
+
selectAll(json_path: string): Array<any>;
1011
+
/**
1012
+
* Evaluates a JSON path expression (see: https://en.wikipedia.org/wiki/JSONPath) on
1013
+
* the document and returns first value matching that query.
1014
+
*
1015
+
* Currently, this method supports the following syntax:
1016
+
* - `$` - root object
1017
+
* - `@` - current object
1018
+
* - `.field` or `['field']` - member accessor
1019
+
* - `[1]` - array index (also supports negative indices)
1020
+
* - `.*` or `[*]` - wildcard (matches all members of an object or array)
1021
+
* - `..` - recursive descent (matches all descendants not only direct children)
1022
+
* - `[start:end:step]` - array slice operator (requires positive integer arguments)
1023
+
* - `['a', 'b', 'c']` - union operator (returns an array of values for each query)
1024
+
* - `[1, -1, 3]` - multiple indices operator (returns an array of values for each index)
1025
+
*
1026
+
* At the moment, JSON Path does not support filter predicates.
1027
+
*/
1028
+
selectOne(json_path: string): any;
1029
+
/**
1030
+
* Returns state vector describing the state of the document
1031
+
* at the moment when the transaction began.
1032
+
*/
1033
+
readonly beforeState: Map<any, any>;
1034
+
/**
1035
+
* Returns state vector describing the current state of
1036
+
* the document.
1037
+
*/
1038
+
readonly afterState: Map<any, any>;
1039
+
readonly pendingStructs: any;
1040
+
/**
1041
+
* Returns a unapplied delete set, that was received in one of the previous remote updates.
1042
+
* This DeleteSet is waiting for a missing updates to arrive in order to be applied.
1043
+
*/
1044
+
readonly pendingDeleteSet: Map<any, any> | undefined;
1045
+
/**
1046
+
* Returns a delete set containing information about
1047
+
* all blocks removed as part of a current transaction.
1048
+
*/
1049
+
readonly deleteSet: Map<any, any>;
1050
+
readonly origin: any;
1051
+
}
1052
+
export class YUndoEvent {
1053
+
private constructor();
1054
+
free(): void;
1055
+
readonly origin: any;
1056
+
readonly kind: any;
1057
+
meta: any;
1058
+
}
1059
+
export class YUndoManager {
1060
+
free(): void;
1061
+
constructor(doc: YDoc, scope: any, options: any);
1062
+
addToScope(ytypes: Array<any>): void;
1063
+
addTrackedOrigin(origin: any): void;
1064
+
removeTrackedOrigin(origin: any): void;
1065
+
clear(): void;
1066
+
stopCapturing(): void;
1067
+
undo(): void;
1068
+
redo(): void;
1069
+
on(event: string, callback: Function): void;
1070
+
off(event: string, callback: Function): boolean;
1071
+
readonly canUndo: boolean;
1072
+
readonly canRedo: boolean;
1073
+
}
1074
+
export class YWeakLink {
1075
+
private constructor();
1076
+
free(): void;
1077
+
/**
1078
+
* Checks if current YWeakLink reference is alive and has not been deleted by its parent collection.
1079
+
* This method only works on already integrated shared types and will return false is current
1080
+
* type is preliminary (has not been integrated into document).
1081
+
*/
1082
+
alive(txn: YTransaction): boolean;
1083
+
deref(txn: YTransaction | undefined): any;
1084
+
unquote(txn: YTransaction | undefined): Array<any>;
1085
+
toString(txn: YTransaction | undefined): string;
1086
+
/**
1087
+
* Subscribes to all operations happening over this instance of `YMap`. All changes are
1088
+
* batched and eventually triggered during transaction commit phase.
1089
+
*/
1090
+
observe(callback: Function): void;
1091
+
/**
1092
+
* Unsubscribes a callback previously subscribed with `observe` method.
1093
+
*/
1094
+
unobserve(callback: Function): boolean;
1095
+
/**
1096
+
* Subscribes to all operations happening over this Y shared type, as well as events in
1097
+
* shared types stored within this one. All changes are batched and eventually triggered
1098
+
* during transaction commit phase.
1099
+
*/
1100
+
observeDeep(callback: Function): void;
1101
+
/**
1102
+
* Unsubscribes a callback previously subscribed with `observeDeep` method.
1103
+
*/
1104
+
unobserveDeep(callback: Function): boolean;
1105
+
/**
1106
+
* Returns true if this is a preliminary instance of `YWeakLink`.
1107
+
*
1108
+
* Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.
1109
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
1110
+
* document store and cannot be nested again: attempt to do so will result in an exception.
1111
+
*/
1112
+
readonly prelim: boolean;
1113
+
readonly type: number;
1114
+
/**
1115
+
* Gets unique logical identifier of this type, shared across peers collaborating on the same
1116
+
* document.
1117
+
*/
1118
+
readonly id: any;
1119
+
}
1120
+
/**
1121
+
* Event generated by `YXmlElement.observe` method. Emitted during transaction commit phase.
1122
+
*/
1123
+
export class YWeakLinkEvent {
1124
+
private constructor();
1125
+
free(): void;
1126
+
/**
1127
+
* Returns an array of keys and indexes creating a path from root type down to current instance
1128
+
* of shared type (accessible via `target` getter).
1129
+
*/
1130
+
path(): any;
1131
+
readonly origin: any;
1132
+
/**
1133
+
* Returns a current shared type instance, that current event changes refer to.
1134
+
*/
1135
+
readonly target: any;
1136
+
}
1137
+
/**
1138
+
* XML element data type. It represents an XML node, which can contain key-value attributes
1139
+
* (interpreted as strings) as well as other nested XML elements or rich text (represented by
1140
+
* `YXmlText` type).
1141
+
*
1142
+
* In terms of conflict resolution, `YXmlElement` uses following rules:
1143
+
*
1144
+
* - Attribute updates use logical last-write-wins principle, meaning the past updates are
1145
+
* automatically overridden and discarded by newer ones, while concurrent updates made by
1146
+
* different peers are resolved into a single value using document id seniority to establish
1147
+
* an order.
1148
+
* - Child node insertion uses sequencing rules from other Yrs collections - elements are inserted
1149
+
* using interleave-resistant algorithm, where order of concurrent inserts at the same index
1150
+
* is established using peer's document id seniority.
1151
+
*/
1152
+
export class YXmlElement {
1153
+
free(): void;
1154
+
constructor(name: string, attributes: any, children: any);
1155
+
/**
1156
+
* Checks if current shared type reference is alive and has not been deleted by its parent collection.
1157
+
* This method only works on already integrated shared types and will return false is current
1158
+
* type is preliminary (has not been integrated into document).
1159
+
*/
1160
+
alive(txn: YTransaction): boolean;
1161
+
/**
1162
+
* Returns a tag name of this XML node.
1163
+
*/
1164
+
name(txn: YTransaction | undefined): string;
1165
+
/**
1166
+
* Returns a number of child XML nodes stored within this `YXMlElement` instance.
1167
+
*/
1168
+
length(txn: YTransaction | undefined): number;
1169
+
insert(index: number, xml_node: any, txn: YTransaction | undefined): void;
1170
+
push(xml_node: any, txn: YTransaction | undefined): void;
1171
+
delete(index: number, length: number | null | undefined, txn: YTransaction | undefined): void;
1172
+
/**
1173
+
* Returns a first child of this XML node.
1174
+
* It can be either `YXmlElement`, `YXmlText` or `undefined` if current node has not children.
1175
+
*/
1176
+
firstChild(txn: YTransaction | undefined): any;
1177
+
/**
1178
+
* Returns a next XML sibling node of this XMl node.
1179
+
* It can be either `YXmlElement`, `YXmlText` or `undefined` if current node is a last child of
1180
+
* parent XML node.
1181
+
*/
1182
+
nextSibling(txn: YTransaction | undefined): any;
1183
+
/**
1184
+
* Returns a previous XML sibling node of this XMl node.
1185
+
* It can be either `YXmlElement`, `YXmlText` or `undefined` if current node is a first child
1186
+
* of parent XML node.
1187
+
*/
1188
+
prevSibling(txn: YTransaction | undefined): any;
1189
+
/**
1190
+
* Returns a parent `YXmlElement` node or `undefined` if current node has no parent assigned.
1191
+
*/
1192
+
parent(txn: YTransaction | undefined): any;
1193
+
/**
1194
+
* Returns a string representation of this XML node.
1195
+
*/
1196
+
toString(txn: YTransaction | undefined): string;
1197
+
/**
1198
+
* Sets a `name` and `value` as new attribute for this XML node. If an attribute with the same
1199
+
* `name` already existed on that node, its value with be overridden with a provided one.
1200
+
* This method accepts any JavaScript value, not just strings.
1201
+
*/
1202
+
setAttribute(name: string, value: any, txn: YTransaction | undefined): void;
1203
+
/**
1204
+
* Returns a value of an attribute given its `name` as any JS value. If no attribute with such name existed,
1205
+
* `undefined` will be returned.
1206
+
*/
1207
+
getAttribute(name: string, txn: YTransaction | undefined): any;
1208
+
/**
1209
+
* Removes an attribute from this XML node, given its `name`.
1210
+
*/
1211
+
removeAttribute(name: string, txn: YTransaction | undefined): void;
1212
+
/**
1213
+
* Returns an iterator that enables to traverse over all attributes of this XML node in
1214
+
* unspecified order. This method returns attribute values as their original JS values,
1215
+
* not just as strings.
1216
+
*/
1217
+
attributes(txn: YTransaction | undefined): any;
1218
+
/**
1219
+
* Returns an iterator that enables a deep traversal of this XML node - starting from first
1220
+
* child over this XML node successors using depth-first strategy.
1221
+
*/
1222
+
treeWalker(txn: YTransaction | undefined): Array<any>;
1223
+
/**
1224
+
* Subscribes to all operations happening over this instance of `YXmlElement`. All changes are
1225
+
* batched and eventually triggered during transaction commit phase.
1226
+
*/
1227
+
observe(callback: Function): void;
1228
+
/**
1229
+
* Unsubscribes a callback previously subscribed with `observe` method.
1230
+
*/
1231
+
unobserve(callback: Function): boolean;
1232
+
/**
1233
+
* Subscribes to all operations happening over this Y shared type, as well as events in
1234
+
* shared types stored within this one. All changes are batched and eventually triggered
1235
+
* during transaction commit phase.
1236
+
*/
1237
+
observeDeep(callback: Function): void;
1238
+
/**
1239
+
* Unsubscribes a callback previously subscribed with `observeDeep` method.
1240
+
*/
1241
+
unobserveDeep(callback: Function): boolean;
1242
+
readonly type: number;
1243
+
/**
1244
+
* Gets unique logical identifier of this type, shared across peers collaborating on the same
1245
+
* document.
1246
+
*/
1247
+
readonly id: any;
1248
+
/**
1249
+
* Returns true if this is a preliminary instance of `YXmlElement`.
1250
+
*
1251
+
* Preliminary instances can be nested into other shared data types.
1252
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
1253
+
* document store and cannot be nested again: attempt to do so will result in an exception.
1254
+
*/
1255
+
readonly prelim: boolean;
1256
+
}
1257
+
/**
1258
+
* Event generated by `YXmlElement.observe` method. Emitted during transaction commit phase.
1259
+
*/
1260
+
export class YXmlEvent {
1261
+
private constructor();
1262
+
free(): void;
1263
+
/**
1264
+
* Returns an array of keys and indexes creating a path from root type down to current instance
1265
+
* of shared type (accessible via `target` getter).
1266
+
*/
1267
+
path(): any;
1268
+
/**
1269
+
* Returns a current shared type instance, that current event changes refer to.
1270
+
*/
1271
+
readonly target: any;
1272
+
readonly origin: any;
1273
+
/**
1274
+
* Returns a list of attribute changes made over corresponding `YXmlText` collection within
1275
+
* bounds of current transaction. These changes follow a format:
1276
+
*
1277
+
* - { action: 'add'|'update'|'delete', oldValue: string|undefined, newValue: string|undefined }
1278
+
*/
1279
+
readonly keys: any;
1280
+
/**
1281
+
* Returns a list of XML child node changes made over corresponding `YXmlElement` collection
1282
+
* within bounds of current transaction. These changes follow a format:
1283
+
*
1284
+
* - { insert: (YXmlText|YXmlElement)[] }
1285
+
* - { delete: number }
1286
+
* - { retain: number }
1287
+
*/
1288
+
readonly delta: any;
1289
+
}
1290
+
/**
1291
+
* Represents a list of `YXmlElement` and `YXmlText` types.
1292
+
* A `YXmlFragment` is similar to a `YXmlElement`, but it does not have a
1293
+
* nodeName and it does not have attributes. Though it can be bound to a DOM
1294
+
* element - in this case the attributes and the nodeName are not shared
1295
+
*/
1296
+
export class YXmlFragment {
1297
+
free(): void;
1298
+
constructor(children: any[]);
1299
+
/**
1300
+
* Checks if current shared type reference is alive and has not been deleted by its parent collection.
1301
+
* This method only works on already integrated shared types and will return false is current
1302
+
* type is preliminary (has not been integrated into document).
1303
+
*/
1304
+
alive(txn: YTransaction): boolean;
1305
+
/**
1306
+
* Returns a number of child XML nodes stored within this `YXMlElement` instance.
1307
+
*/
1308
+
length(txn: YTransaction | undefined): number;
1309
+
insert(index: number, xml_node: any, txn: YTransaction | undefined): void;
1310
+
push(xml_node: any, txn: YTransaction | undefined): void;
1311
+
delete(index: number, length: number | null | undefined, txn: YTransaction | undefined): void;
1312
+
/**
1313
+
* Returns a first child of this XML node.
1314
+
* It can be either `YXmlElement`, `YXmlText` or `undefined` if current node has not children.
1315
+
*/
1316
+
firstChild(txn: YTransaction | undefined): any;
1317
+
/**
1318
+
* Returns a string representation of this XML node.
1319
+
*/
1320
+
toString(txn: YTransaction | undefined): string;
1321
+
/**
1322
+
* Returns an iterator that enables a deep traversal of this XML node - starting from first
1323
+
* child over this XML node successors using depth-first strategy.
1324
+
*/
1325
+
treeWalker(txn: YTransaction | undefined): Array<any>;
1326
+
/**
1327
+
* Subscribes to all operations happening over this instance of `YXmlFragment`. All changes are
1328
+
* batched and eventually triggered during transaction commit phase.
1329
+
*/
1330
+
observe(callback: Function): void;
1331
+
/**
1332
+
* Unsubscribes a callback previously subscribed with `observe` method.
1333
+
*/
1334
+
unobserve(callback: Function): boolean;
1335
+
/**
1336
+
* Subscribes to all operations happening over this Y shared type, as well as events in
1337
+
* shared types stored within this one. All changes are batched and eventually triggered
1338
+
* during transaction commit phase.
1339
+
*/
1340
+
observeDeep(callback: Function): void;
1341
+
/**
1342
+
* Unsubscribes a callback previously subscribed with `observeDeep` method.
1343
+
*/
1344
+
unobserveDeep(callback: Function): boolean;
1345
+
readonly type: number;
1346
+
/**
1347
+
* Gets unique logical identifier of this type, shared across peers collaborating on the same
1348
+
* document.
1349
+
*/
1350
+
readonly id: any;
1351
+
/**
1352
+
* Returns true if this is a preliminary instance of `YXmlFragment`.
1353
+
*
1354
+
* Preliminary instances can be nested into other shared data types.
1355
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
1356
+
* document store and cannot be nested again: attempt to do so will result in an exception.
1357
+
*/
1358
+
readonly prelim: boolean;
1359
+
}
1360
+
/**
1361
+
* A shared data type used for collaborative text editing, that can be used in a context of
1362
+
* `YXmlElement` nodee. It enables multiple users to add and remove chunks of text in efficient
1363
+
* manner. This type is internally represented as a mutable double-linked list of text chunks
1364
+
* - an optimization occurs during `YTransaction.commit`, which allows to squash multiple
1365
+
* consecutively inserted characters together as a single chunk of text even between transaction
1366
+
* boundaries in order to preserve more efficient memory model.
1367
+
*
1368
+
* Just like `YXmlElement`, `YXmlText` can be marked with extra metadata in form of attributes.
1369
+
*
1370
+
* `YXmlText` structure internally uses UTF-8 encoding and its length is described in a number of
1371
+
* bytes rather than individual characters (a single UTF-8 code point can consist of many bytes).
1372
+
*
1373
+
* Like all Yrs shared data types, `YXmlText` is resistant to the problem of interleaving (situation
1374
+
* when characters inserted one after another may interleave with other peers concurrent inserts
1375
+
* after merging all updates together). In case of Yrs conflict resolution is solved by using
1376
+
* unique document id to determine correct and consistent ordering.
1377
+
*/
1378
+
export class YXmlText {
1379
+
free(): void;
1380
+
constructor(text: string | null | undefined, attributes: any);
1381
+
/**
1382
+
* Checks if current shared type reference is alive and has not been deleted by its parent collection.
1383
+
* This method only works on already integrated shared types and will return false is current
1384
+
* type is preliminary (has not been integrated into document).
1385
+
*/
1386
+
alive(txn: YTransaction): boolean;
1387
+
/**
1388
+
* Returns length of an underlying string stored in this `YXmlText` instance,
1389
+
* understood as a number of UTF-8 encoded bytes.
1390
+
*/
1391
+
length(txn: YTransaction | undefined): number;
1392
+
/**
1393
+
* Inserts a given `chunk` of text into this `YXmlText` instance, starting at a given `index`.
1394
+
*
1395
+
* Optional object with defined `attributes` will be used to wrap provided text `chunk`
1396
+
* with a formatting blocks.
1397
+
*/
1398
+
insert(index: number, chunk: string, attributes: any, txn: YTransaction | undefined): void;
1399
+
/**
1400
+
* Formats text within bounds specified by `index` and `len` with a given formatting
1401
+
* attributes.
1402
+
*/
1403
+
format(index: number, length: number, attributes: any, txn: YTransaction | undefined): void;
1404
+
quote(lower: number | null | undefined, upper: number | null | undefined, lower_open: boolean | null | undefined, upper_open: boolean | null | undefined, txn: YTransaction | undefined): YWeakLink;
1405
+
/**
1406
+
* Returns the Delta representation of this YXmlText type.
1407
+
*/
1408
+
toDelta(snapshot: any, prev_snapshot: any, compute_ychange: Function | null | undefined, txn: YTransaction | undefined): Array<any>;
1409
+
/**
1410
+
* Inserts a given `embed` object into this `YXmlText` instance, starting at a given `index`.
1411
+
*
1412
+
* Optional object with defined `attributes` will be used to wrap provided `embed`
1413
+
* with a formatting blocks.`attributes` are only supported for a `YXmlText` instance which
1414
+
* already has been integrated into document store.
1415
+
*/
1416
+
insertEmbed(index: number, embed: any, attributes: any, txn: YTransaction | undefined): void;
1417
+
/**
1418
+
* Appends a given `chunk` of text at the end of `YXmlText` instance.
1419
+
*
1420
+
* Optional object with defined `attributes` will be used to wrap provided text `chunk`
1421
+
* with a formatting blocks.
1422
+
*/
1423
+
push(chunk: string, attributes: any, txn: YTransaction | undefined): void;
1424
+
applyDelta(delta: Array<any>, txn: YTransaction | undefined): void;
1425
+
/**
1426
+
* Deletes a specified range of characters, starting at a given `index`.
1427
+
* Both `index` and `length` are counted in terms of a number of UTF-8 character bytes.
1428
+
*/
1429
+
delete(index: number, length: number, txn: YTransaction | undefined): void;
1430
+
/**
1431
+
* Returns a next XML sibling node of this XMl node.
1432
+
* It can be either `YXmlElement`, `YXmlText` or `undefined` if current node is a last child of
1433
+
* parent XML node.
1434
+
*/
1435
+
nextSibling(txn: YTransaction | undefined): any;
1436
+
/**
1437
+
* Returns a previous XML sibling node of this XMl node.
1438
+
* It can be either `YXmlElement`, `YXmlText` or `undefined` if current node is a first child
1439
+
* of parent XML node.
1440
+
*/
1441
+
prevSibling(txn: YTransaction | undefined): any;
1442
+
/**
1443
+
* Returns a parent `YXmlElement` node or `undefined` if current node has no parent assigned.
1444
+
*/
1445
+
parent(txn: YTransaction | undefined): any;
1446
+
/**
1447
+
* Returns an underlying string stored in this `YXmlText` instance.
1448
+
*/
1449
+
toString(txn: YTransaction | undefined): string;
1450
+
/**
1451
+
* Sets a `name` and `value` as new attribute for this XML node. If an attribute with the same
1452
+
* `name` already existed on that node, its value with be overridden with a provided one.
1453
+
* This method accepts any JavaScript value, not just strings.
1454
+
*/
1455
+
setAttribute(name: string, value: any, txn: YTransaction | undefined): void;
1456
+
/**
1457
+
* Returns a value of an attribute given its `name` as any JS value. If no attribute with such name existed,
1458
+
* `undefined` will be returned.
1459
+
*/
1460
+
getAttribute(name: string, txn: YTransaction | undefined): any;
1461
+
/**
1462
+
* Removes an attribute from this XML node, given its `name`.
1463
+
*/
1464
+
removeAttribute(name: string, txn: YTransaction | undefined): void;
1465
+
/**
1466
+
* Returns an iterator that enables to traverse over all attributes of this XML node in
1467
+
* unspecified order. This method returns attribute values as their original JS values,
1468
+
* not just as strings.
1469
+
*/
1470
+
attributes(txn: YTransaction | undefined): any;
1471
+
/**
1472
+
* Subscribes to all operations happening over this instance of `YXmlText`. All changes are
1473
+
* batched and eventually triggered during transaction commit phase.
1474
+
*/
1475
+
observe(callback: Function): void;
1476
+
/**
1477
+
* Unsubscribes a callback previously subscribed with `observe` method.
1478
+
*/
1479
+
unobserve(callback: Function): boolean;
1480
+
/**
1481
+
* Subscribes to all operations happening over this Y shared type, as well as events in
1482
+
* shared types stored within this one. All changes are batched and eventually triggered
1483
+
* during transaction commit phase.
1484
+
*/
1485
+
observeDeep(callback: Function): void;
1486
+
/**
1487
+
* Unsubscribes a callback previously subscribed with `observe` method.
1488
+
*/
1489
+
unobserveDeep(callback: Function): boolean;
1490
+
readonly type: number;
1491
+
/**
1492
+
* Gets unique logical identifier of this type, shared across peers collaborating on the same
1493
+
* document.
1494
+
*/
1495
+
readonly id: any;
1496
+
/**
1497
+
* Returns true if this is a preliminary instance of `YXmlText`.
1498
+
*
1499
+
* Preliminary instances can be nested into other shared data types.
1500
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
1501
+
* document store and cannot be nested again: attempt to do so will result in an exception.
1502
+
*/
1503
+
readonly prelim: boolean;
1504
+
}
1505
+
/**
1506
+
* Event generated by `YXmlText.observe` method. Emitted during transaction commit phase.
1507
+
*/
1508
+
export class YXmlTextEvent {
1509
+
private constructor();
1510
+
free(): void;
1511
+
/**
1512
+
* Returns an array of keys and indexes creating a path from root type down to current instance
1513
+
* of shared type (accessible via `target` getter).
1514
+
*/
1515
+
path(): any;
1516
+
/**
1517
+
* Returns a current shared type instance, that current event changes refer to.
1518
+
*/
1519
+
readonly target: any;
1520
+
readonly origin: any;
1521
+
/**
1522
+
* Returns a list of text changes made over corresponding `YText` collection within
1523
+
* bounds of current transaction. These changes follow a format:
1524
+
*
1525
+
* - { insert: string, attributes: any|undefined }
1526
+
* - { delete: number }
1527
+
* - { retain: number, attributes: any|undefined }
1528
+
*/
1529
+
readonly delta: any;
1530
+
/**
1531
+
* Returns a list of attribute changes made over corresponding `YXmlText` collection within
1532
+
* bounds of current transaction. These changes follow a format:
1533
+
*
1534
+
* - { action: 'add'|'update'|'delete', oldValue: string|undefined, newValue: string|undefined }
1535
+
*/
1536
+
readonly keys: any;
1537
+
}
+5022
src/ywasm/ywasm.js
+5022
src/ywasm/ywasm.js
···
1
+
let imports = {};
2
+
imports["__wbindgen_placeholder__"] = module.exports;
3
+
let wasm;
4
+
const { TextDecoder, TextEncoder } = require(`util`);
5
+
6
+
function addToExternrefTable0(obj) {
7
+
const idx = wasm.__externref_table_alloc();
8
+
wasm.__wbindgen_export_2.set(idx, obj);
9
+
return idx;
10
+
}
11
+
12
+
function handleError(f, args) {
13
+
try {
14
+
return f.apply(this, args);
15
+
} catch (e) {
16
+
const idx = addToExternrefTable0(e);
17
+
wasm.__wbindgen_exn_store(idx);
18
+
}
19
+
}
20
+
21
+
let cachedTextDecoder = new TextDecoder("utf-8", {
22
+
ignoreBOM: true,
23
+
fatal: true,
24
+
});
25
+
26
+
cachedTextDecoder.decode();
27
+
28
+
let cachedUint8ArrayMemory0 = null;
29
+
30
+
function getUint8ArrayMemory0() {
31
+
if (
32
+
cachedUint8ArrayMemory0 === null ||
33
+
cachedUint8ArrayMemory0.byteLength === 0
34
+
) {
35
+
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
36
+
}
37
+
return cachedUint8ArrayMemory0;
38
+
}
39
+
40
+
function getStringFromWasm0(ptr, len) {
41
+
ptr = ptr >>> 0;
42
+
return cachedTextDecoder.decode(
43
+
getUint8ArrayMemory0().subarray(ptr, ptr + len),
44
+
);
45
+
}
46
+
47
+
let WASM_VECTOR_LEN = 0;
48
+
49
+
let cachedTextEncoder = new TextEncoder("utf-8");
50
+
51
+
const encodeString =
52
+
typeof cachedTextEncoder.encodeInto === "function"
53
+
? function (arg, view) {
54
+
return cachedTextEncoder.encodeInto(arg, view);
55
+
}
56
+
: function (arg, view) {
57
+
const buf = cachedTextEncoder.encode(arg);
58
+
view.set(buf);
59
+
return {
60
+
read: arg.length,
61
+
written: buf.length,
62
+
};
63
+
};
64
+
65
+
function passStringToWasm0(arg, malloc, realloc) {
66
+
if (realloc === undefined) {
67
+
const buf = cachedTextEncoder.encode(arg);
68
+
const ptr = malloc(buf.length, 1) >>> 0;
69
+
getUint8ArrayMemory0()
70
+
.subarray(ptr, ptr + buf.length)
71
+
.set(buf);
72
+
WASM_VECTOR_LEN = buf.length;
73
+
return ptr;
74
+
}
75
+
76
+
let len = arg.length;
77
+
let ptr = malloc(len, 1) >>> 0;
78
+
79
+
const mem = getUint8ArrayMemory0();
80
+
81
+
let offset = 0;
82
+
83
+
for (; offset < len; offset++) {
84
+
const code = arg.charCodeAt(offset);
85
+
if (code > 0x7f) break;
86
+
mem[ptr + offset] = code;
87
+
}
88
+
89
+
if (offset !== len) {
90
+
if (offset !== 0) {
91
+
arg = arg.slice(offset);
92
+
}
93
+
ptr = realloc(ptr, len, (len = offset + arg.length * 3), 1) >>> 0;
94
+
const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
95
+
const ret = encodeString(arg, view);
96
+
97
+
offset += ret.written;
98
+
ptr = realloc(ptr, len, offset, 1) >>> 0;
99
+
}
100
+
101
+
WASM_VECTOR_LEN = offset;
102
+
return ptr;
103
+
}
104
+
105
+
let cachedDataViewMemory0 = null;
106
+
107
+
function getDataViewMemory0() {
108
+
if (
109
+
cachedDataViewMemory0 === null ||
110
+
cachedDataViewMemory0.buffer.detached === true ||
111
+
(cachedDataViewMemory0.buffer.detached === undefined &&
112
+
cachedDataViewMemory0.buffer !== wasm.memory.buffer)
113
+
) {
114
+
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
115
+
}
116
+
return cachedDataViewMemory0;
117
+
}
118
+
119
+
function isLikeNone(x) {
120
+
return x === undefined || x === null;
121
+
}
122
+
123
+
function debugString(val) {
124
+
// primitive types
125
+
const type = typeof val;
126
+
if (type == "number" || type == "boolean" || val == null) {
127
+
return `${val}`;
128
+
}
129
+
if (type == "string") {
130
+
return `"${val}"`;
131
+
}
132
+
if (type == "symbol") {
133
+
const description = val.description;
134
+
if (description == null) {
135
+
return "Symbol";
136
+
} else {
137
+
return `Symbol(${description})`;
138
+
}
139
+
}
140
+
if (type == "function") {
141
+
const name = val.name;
142
+
if (typeof name == "string" && name.length > 0) {
143
+
return `Function(${name})`;
144
+
} else {
145
+
return "Function";
146
+
}
147
+
}
148
+
// objects
149
+
if (Array.isArray(val)) {
150
+
const length = val.length;
151
+
let debug = "[";
152
+
if (length > 0) {
153
+
debug += debugString(val[0]);
154
+
}
155
+
for (let i = 1; i < length; i++) {
156
+
debug += ", " + debugString(val[i]);
157
+
}
158
+
debug += "]";
159
+
return debug;
160
+
}
161
+
// Test for built-in
162
+
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
163
+
let className;
164
+
if (builtInMatches && builtInMatches.length > 1) {
165
+
className = builtInMatches[1];
166
+
} else {
167
+
// Failed to match the standard '[object ClassName]'
168
+
return toString.call(val);
169
+
}
170
+
if (className == "Object") {
171
+
// we're a user defined class or Object
172
+
// JSON.stringify avoids problems with cycles, and is generally much
173
+
// easier than looping through ownProperties of `val`.
174
+
try {
175
+
return "Object(" + JSON.stringify(val) + ")";
176
+
} catch (_) {
177
+
return "Object";
178
+
}
179
+
}
180
+
// errors
181
+
if (val instanceof Error) {
182
+
return `${val.name}: ${val.message}\n${val.stack}`;
183
+
}
184
+
// TODO we could test for more things here, like `Set`s and `Map`s.
185
+
return className;
186
+
}
187
+
188
+
function takeFromExternrefTable0(idx) {
189
+
const value = wasm.__wbindgen_export_2.get(idx);
190
+
wasm.__externref_table_dealloc(idx);
191
+
return value;
192
+
}
193
+
194
+
function _assertClass(instance, klass) {
195
+
if (!(instance instanceof klass)) {
196
+
throw new Error(`expected instance of ${klass.name}`);
197
+
}
198
+
}
199
+
200
+
function passArrayJsValueToWasm0(array, malloc) {
201
+
const ptr = malloc(array.length * 4, 4) >>> 0;
202
+
for (let i = 0; i < array.length; i++) {
203
+
const add = addToExternrefTable0(array[i]);
204
+
getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
205
+
}
206
+
WASM_VECTOR_LEN = array.length;
207
+
return ptr;
208
+
}
209
+
/**
210
+
* When called will call console log errors whenever internal panic is called from within
211
+
* WebAssembly module.
212
+
*/
213
+
module.exports.setPanicHook = function () {
214
+
wasm.setPanicHook();
215
+
};
216
+
217
+
/**
218
+
* Encodes a state vector of a given ywasm document into its binary representation using lib0 v1
219
+
* encoding. State vector is a compact representation of updates performed on a given document and
220
+
* can be used by `encode_state_as_update` on remote peer to generate a delta update payload to
221
+
* synchronize changes between peers.
222
+
*
223
+
* Example:
224
+
*
225
+
* ```javascript
226
+
* import {YDoc, encodeStateVector, encodeStateAsUpdate, applyUpdate} from 'ywasm'
227
+
*
228
+
* /// document on machine A
229
+
* const localDoc = new YDoc()
230
+
* const localSV = encodeStateVector(localDoc)
231
+
*
232
+
* // document on machine B
233
+
* const remoteDoc = new YDoc()
234
+
* const remoteDelta = encodeStateAsUpdate(remoteDoc, localSV)
235
+
*
236
+
* applyUpdate(localDoc, remoteDelta)
237
+
* ```
238
+
* @param {YDoc} doc
239
+
* @returns {Uint8Array}
240
+
*/
241
+
module.exports.encodeStateVector = function (doc) {
242
+
_assertClass(doc, YDoc);
243
+
const ret = wasm.encodeStateVector(doc.__wbg_ptr);
244
+
if (ret[2]) {
245
+
throw takeFromExternrefTable0(ret[1]);
246
+
}
247
+
return takeFromExternrefTable0(ret[0]);
248
+
};
249
+
250
+
/**
251
+
* Returns a string dump representation of a given `update` encoded using lib0 v1 encoding.
252
+
* @param {Uint8Array} update
253
+
* @returns {string}
254
+
*/
255
+
module.exports.debugUpdateV1 = function (update) {
256
+
let deferred2_0;
257
+
let deferred2_1;
258
+
try {
259
+
const ret = wasm.debugUpdateV1(update);
260
+
var ptr1 = ret[0];
261
+
var len1 = ret[1];
262
+
if (ret[3]) {
263
+
ptr1 = 0;
264
+
len1 = 0;
265
+
throw takeFromExternrefTable0(ret[2]);
266
+
}
267
+
deferred2_0 = ptr1;
268
+
deferred2_1 = len1;
269
+
return getStringFromWasm0(ptr1, len1);
270
+
} finally {
271
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
272
+
}
273
+
};
274
+
275
+
/**
276
+
* Returns a string dump representation of a given `update` encoded using lib0 v2 encoding.
277
+
* @param {Uint8Array} update
278
+
* @returns {string}
279
+
*/
280
+
module.exports.debugUpdateV2 = function (update) {
281
+
let deferred2_0;
282
+
let deferred2_1;
283
+
try {
284
+
const ret = wasm.debugUpdateV2(update);
285
+
var ptr1 = ret[0];
286
+
var len1 = ret[1];
287
+
if (ret[3]) {
288
+
ptr1 = 0;
289
+
len1 = 0;
290
+
throw takeFromExternrefTable0(ret[2]);
291
+
}
292
+
deferred2_0 = ptr1;
293
+
deferred2_1 = len1;
294
+
return getStringFromWasm0(ptr1, len1);
295
+
} finally {
296
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
297
+
}
298
+
};
299
+
300
+
/**
301
+
* Merges a sequence of updates (encoded using lib0 v1 encoding) together, producing another
302
+
* update (also lib0 v1 encoded) in the result. Returned binary is a combination of all input
303
+
* `updates`, compressed.
304
+
*
305
+
* Returns an error whenever any of the input updates couldn't be decoded.
306
+
* @param {Array<any>} updates
307
+
* @returns {Uint8Array}
308
+
*/
309
+
module.exports.mergeUpdatesV1 = function (updates) {
310
+
const ret = wasm.mergeUpdatesV1(updates);
311
+
if (ret[2]) {
312
+
throw takeFromExternrefTable0(ret[1]);
313
+
}
314
+
return takeFromExternrefTable0(ret[0]);
315
+
};
316
+
317
+
/**
318
+
* Merges a sequence of updates (encoded using lib0 v2 encoding) together, producing another
319
+
* update (also lib0 v2 encoded) in the result. Returned binary is a combination of all input
320
+
* `updates`, compressed.
321
+
*
322
+
* Returns an error whenever any of the input updates couldn't be decoded.
323
+
* @param {Array<any>} updates
324
+
* @returns {Uint8Array}
325
+
*/
326
+
module.exports.mergeUpdatesV2 = function (updates) {
327
+
const ret = wasm.mergeUpdatesV2(updates);
328
+
if (ret[2]) {
329
+
throw takeFromExternrefTable0(ret[1]);
330
+
}
331
+
return takeFromExternrefTable0(ret[0]);
332
+
};
333
+
334
+
/**
335
+
* Encodes all updates that have happened since a given version `vector` into a compact delta
336
+
* representation using lib0 v1 encoding. If `vector` parameter has not been provided, generated
337
+
* delta payload will contain all changes of a current ywasm document, working effectivelly as its
338
+
* state snapshot.
339
+
*
340
+
* Example:
341
+
*
342
+
* ```javascript
343
+
* import {YDoc, encodeStateVector, encodeStateAsUpdate, applyUpdate} from 'ywasm'
344
+
*
345
+
* /// document on machine A
346
+
* const localDoc = new YDoc()
347
+
* const localSV = encodeStateVector(localDoc)
348
+
*
349
+
* // document on machine B
350
+
* const remoteDoc = new YDoc()
351
+
* const remoteDelta = encodeStateAsUpdate(remoteDoc, localSV)
352
+
*
353
+
* applyUpdate(localDoc, remoteDelta)
354
+
* ```
355
+
* @param {YDoc} doc
356
+
* @param {Uint8Array | null} [vector]
357
+
* @returns {Uint8Array}
358
+
*/
359
+
module.exports.encodeStateAsUpdate = function (doc, vector) {
360
+
_assertClass(doc, YDoc);
361
+
const ret = wasm.encodeStateAsUpdate(
362
+
doc.__wbg_ptr,
363
+
isLikeNone(vector) ? 0 : addToExternrefTable0(vector),
364
+
);
365
+
if (ret[2]) {
366
+
throw takeFromExternrefTable0(ret[1]);
367
+
}
368
+
return takeFromExternrefTable0(ret[0]);
369
+
};
370
+
371
+
/**
372
+
* Encodes all updates that have happened since a given version `vector` into a compact delta
373
+
* representation using lib0 v2 encoding. If `vector` parameter has not been provided, generated
374
+
* delta payload will contain all changes of a current ywasm document, working effectivelly as its
375
+
* state snapshot.
376
+
*
377
+
* Example:
378
+
*
379
+
* ```javascript
380
+
* import {YDoc, encodeStateVector, encodeStateAsUpdate, applyUpdate} from 'ywasm'
381
+
*
382
+
* /// document on machine A
383
+
* const localDoc = new YDoc()
384
+
* const localSV = encodeStateVector(localDoc)
385
+
*
386
+
* // document on machine B
387
+
* const remoteDoc = new YDoc()
388
+
* const remoteDelta = encodeStateAsUpdateV2(remoteDoc, localSV)
389
+
*
390
+
* applyUpdate(localDoc, remoteDelta)
391
+
* ```
392
+
* @param {YDoc} doc
393
+
* @param {Uint8Array | null} [vector]
394
+
* @returns {Uint8Array}
395
+
*/
396
+
module.exports.encodeStateAsUpdateV2 = function (doc, vector) {
397
+
_assertClass(doc, YDoc);
398
+
const ret = wasm.encodeStateAsUpdateV2(
399
+
doc.__wbg_ptr,
400
+
isLikeNone(vector) ? 0 : addToExternrefTable0(vector),
401
+
);
402
+
if (ret[2]) {
403
+
throw takeFromExternrefTable0(ret[1]);
404
+
}
405
+
return takeFromExternrefTable0(ret[0]);
406
+
};
407
+
408
+
/**
409
+
* Applies delta update generated by the remote document replica to a current document. This
410
+
* method assumes that a payload maintains lib0 v1 encoding format.
411
+
*
412
+
* Example:
413
+
*
414
+
* ```javascript
415
+
* import {YDoc, encodeStateVector, encodeStateAsUpdate, applyUpdate} from 'ywasm'
416
+
*
417
+
* /// document on machine A
418
+
* const localDoc = new YDoc()
419
+
* const localSV = encodeStateVector(localDoc)
420
+
*
421
+
* // document on machine B
422
+
* const remoteDoc = new YDoc()
423
+
* const remoteDelta = encodeStateAsUpdate(remoteDoc, localSV)
424
+
*
425
+
* applyUpdateV2(localDoc, remoteDelta)
426
+
* ```
427
+
* @param {YDoc} doc
428
+
* @param {Uint8Array} update
429
+
* @param {any} origin
430
+
*/
431
+
module.exports.applyUpdate = function (doc, update, origin) {
432
+
_assertClass(doc, YDoc);
433
+
const ret = wasm.applyUpdate(doc.__wbg_ptr, update, origin);
434
+
if (ret[1]) {
435
+
throw takeFromExternrefTable0(ret[0]);
436
+
}
437
+
};
438
+
439
+
/**
440
+
* Applies delta update generated by the remote document replica to a current document. This
441
+
* method assumes that a payload maintains lib0 v2 encoding format.
442
+
*
443
+
* Example:
444
+
*
445
+
* ```javascript
446
+
* import {YDoc, encodeStateVector, encodeStateAsUpdate, applyUpdate} from 'ywasm'
447
+
*
448
+
* /// document on machine A
449
+
* const localDoc = new YDoc()
450
+
* const localSV = encodeStateVector(localDoc)
451
+
*
452
+
* // document on machine B
453
+
* const remoteDoc = new YDoc()
454
+
* const remoteDelta = encodeStateAsUpdateV2(remoteDoc, localSV)
455
+
*
456
+
* applyUpdateV2(localDoc, remoteDelta)
457
+
* ```
458
+
* @param {YDoc} doc
459
+
* @param {Uint8Array} update
460
+
* @param {any} origin
461
+
*/
462
+
module.exports.applyUpdateV2 = function (doc, update, origin) {
463
+
_assertClass(doc, YDoc);
464
+
const ret = wasm.applyUpdateV2(doc.__wbg_ptr, update, origin);
465
+
if (ret[1]) {
466
+
throw takeFromExternrefTable0(ret[0]);
467
+
}
468
+
};
469
+
470
+
/**
471
+
* @param {YDoc} doc
472
+
* @returns {any}
473
+
*/
474
+
module.exports.snapshot = function (doc) {
475
+
_assertClass(doc, YDoc);
476
+
const ret = wasm.snapshot(doc.__wbg_ptr);
477
+
if (ret[2]) {
478
+
throw takeFromExternrefTable0(ret[1]);
479
+
}
480
+
return takeFromExternrefTable0(ret[0]);
481
+
};
482
+
483
+
/**
484
+
* @param {any} snap1
485
+
* @param {any} snap2
486
+
* @returns {boolean}
487
+
*/
488
+
module.exports.equalSnapshots = function (snap1, snap2) {
489
+
const ret = wasm.equalSnapshots(snap1, snap2);
490
+
return ret !== 0;
491
+
};
492
+
493
+
function getArrayU8FromWasm0(ptr, len) {
494
+
ptr = ptr >>> 0;
495
+
return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
496
+
}
497
+
/**
498
+
* @param {any} snapshot
499
+
* @returns {Uint8Array}
500
+
*/
501
+
module.exports.encodeSnapshotV1 = function (snapshot) {
502
+
const ret = wasm.encodeSnapshotV1(snapshot);
503
+
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
504
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
505
+
return v1;
506
+
};
507
+
508
+
/**
509
+
* @param {any} snapshot
510
+
* @returns {Uint8Array}
511
+
*/
512
+
module.exports.encodeSnapshotV2 = function (snapshot) {
513
+
const ret = wasm.encodeSnapshotV2(snapshot);
514
+
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
515
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
516
+
return v1;
517
+
};
518
+
519
+
function passArray8ToWasm0(arg, malloc) {
520
+
const ptr = malloc(arg.length * 1, 1) >>> 0;
521
+
getUint8ArrayMemory0().set(arg, ptr / 1);
522
+
WASM_VECTOR_LEN = arg.length;
523
+
return ptr;
524
+
}
525
+
/**
526
+
* @param {Uint8Array} snapshot
527
+
* @returns {any}
528
+
*/
529
+
module.exports.decodeSnapshotV2 = function (snapshot) {
530
+
const ptr0 = passArray8ToWasm0(snapshot, wasm.__wbindgen_malloc);
531
+
const len0 = WASM_VECTOR_LEN;
532
+
const ret = wasm.decodeSnapshotV2(ptr0, len0);
533
+
if (ret[2]) {
534
+
throw takeFromExternrefTable0(ret[1]);
535
+
}
536
+
return takeFromExternrefTable0(ret[0]);
537
+
};
538
+
539
+
/**
540
+
* @param {Uint8Array} snapshot
541
+
* @returns {any}
542
+
*/
543
+
module.exports.decodeSnapshotV1 = function (snapshot) {
544
+
const ptr0 = passArray8ToWasm0(snapshot, wasm.__wbindgen_malloc);
545
+
const len0 = WASM_VECTOR_LEN;
546
+
const ret = wasm.decodeSnapshotV1(ptr0, len0);
547
+
if (ret[2]) {
548
+
throw takeFromExternrefTable0(ret[1]);
549
+
}
550
+
return takeFromExternrefTable0(ret[0]);
551
+
};
552
+
553
+
/**
554
+
* @param {YDoc} doc
555
+
* @param {any} snapshot
556
+
* @returns {Uint8Array}
557
+
*/
558
+
module.exports.encodeStateFromSnapshotV1 = function (doc, snapshot) {
559
+
_assertClass(doc, YDoc);
560
+
const ret = wasm.encodeStateFromSnapshotV1(doc.__wbg_ptr, snapshot);
561
+
if (ret[3]) {
562
+
throw takeFromExternrefTable0(ret[2]);
563
+
}
564
+
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
565
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
566
+
return v1;
567
+
};
568
+
569
+
/**
570
+
* @param {YDoc} doc
571
+
* @param {any} snapshot
572
+
* @returns {Uint8Array}
573
+
*/
574
+
module.exports.encodeStateFromSnapshotV2 = function (doc, snapshot) {
575
+
_assertClass(doc, YDoc);
576
+
const ret = wasm.encodeStateFromSnapshotV2(doc.__wbg_ptr, snapshot);
577
+
if (ret[3]) {
578
+
throw takeFromExternrefTable0(ret[2]);
579
+
}
580
+
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
581
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
582
+
return v1;
583
+
};
584
+
585
+
/**
586
+
* Retrieves a sticky index corresponding to a given human-readable `index` pointing into
587
+
* the shared `ytype`. Unlike standard indexes sticky indexes enables to track
588
+
* the location inside of a shared y-types, even in the face of concurrent updates.
589
+
*
590
+
* If association is >= 0, the resulting position will point to location **after** the referenced index.
591
+
* If association is < 0, the resulting position will point to location **before** the referenced index.
592
+
* @param {any} ytype
593
+
* @param {number} index
594
+
* @param {number} assoc
595
+
* @param {YTransaction | undefined} txn
596
+
* @returns {any}
597
+
*/
598
+
module.exports.createRelativePositionFromTypeIndex = function (
599
+
ytype,
600
+
index,
601
+
assoc,
602
+
txn,
603
+
) {
604
+
const ret = wasm.createRelativePositionFromTypeIndex(
605
+
ytype,
606
+
index,
607
+
assoc,
608
+
txn,
609
+
);
610
+
if (ret[2]) {
611
+
throw takeFromExternrefTable0(ret[1]);
612
+
}
613
+
return takeFromExternrefTable0(ret[0]);
614
+
};
615
+
616
+
/**
617
+
* Converts a sticky index (see: `createStickyIndexFromType`) into an object
618
+
* containing human-readable index.
619
+
* @param {any} rpos
620
+
* @param {YDoc} doc
621
+
* @returns {any}
622
+
*/
623
+
module.exports.createAbsolutePositionFromRelativePosition = function (
624
+
rpos,
625
+
doc,
626
+
) {
627
+
_assertClass(doc, YDoc);
628
+
const ret = wasm.createAbsolutePositionFromRelativePosition(
629
+
rpos,
630
+
doc.__wbg_ptr,
631
+
);
632
+
if (ret[2]) {
633
+
throw takeFromExternrefTable0(ret[1]);
634
+
}
635
+
return takeFromExternrefTable0(ret[0]);
636
+
};
637
+
638
+
/**
639
+
* Serializes sticky index created by `createStickyIndexFromType` into a binary
640
+
* payload.
641
+
* @param {any} rpos
642
+
* @returns {Uint8Array}
643
+
*/
644
+
module.exports.encodeRelativePosition = function (rpos) {
645
+
const ret = wasm.encodeRelativePosition(rpos);
646
+
if (ret[2]) {
647
+
throw takeFromExternrefTable0(ret[1]);
648
+
}
649
+
return takeFromExternrefTable0(ret[0]);
650
+
};
651
+
652
+
/**
653
+
* Deserializes sticky index serialized previously by `encodeStickyIndex`.
654
+
* @param {Uint8Array} bin
655
+
* @returns {any}
656
+
*/
657
+
module.exports.decodeRelativePosition = function (bin) {
658
+
const ret = wasm.decodeRelativePosition(bin);
659
+
if (ret[2]) {
660
+
throw takeFromExternrefTable0(ret[1]);
661
+
}
662
+
return takeFromExternrefTable0(ret[0]);
663
+
};
664
+
665
+
/**
666
+
* @param {any} a
667
+
* @param {any} b
668
+
* @returns {boolean}
669
+
*/
670
+
module.exports.compareRelativePositions = function (a, b) {
671
+
const ret = wasm.compareRelativePositions(a, b);
672
+
return ret !== 0;
673
+
};
674
+
675
+
let cachedBigUint64ArrayMemory0 = null;
676
+
677
+
function getBigUint64ArrayMemory0() {
678
+
if (
679
+
cachedBigUint64ArrayMemory0 === null ||
680
+
cachedBigUint64ArrayMemory0.byteLength === 0
681
+
) {
682
+
cachedBigUint64ArrayMemory0 = new BigUint64Array(wasm.memory.buffer);
683
+
}
684
+
return cachedBigUint64ArrayMemory0;
685
+
}
686
+
687
+
function passArray64ToWasm0(arg, malloc) {
688
+
const ptr = malloc(arg.length * 8, 8) >>> 0;
689
+
getBigUint64ArrayMemory0().set(arg, ptr / 8);
690
+
WASM_VECTOR_LEN = arg.length;
691
+
return ptr;
692
+
}
693
+
/**
694
+
* @param {Awareness} awareness
695
+
* @param {BigUint64Array} clients
696
+
*/
697
+
module.exports.removeAwarenessStates = function (awareness, clients) {
698
+
_assertClass(awareness, Awareness);
699
+
const ptr0 = passArray64ToWasm0(clients, wasm.__wbindgen_malloc);
700
+
const len0 = WASM_VECTOR_LEN;
701
+
const ret = wasm.removeAwarenessStates(awareness.__wbg_ptr, ptr0, len0);
702
+
if (ret[1]) {
703
+
throw takeFromExternrefTable0(ret[0]);
704
+
}
705
+
};
706
+
707
+
/**
708
+
* @param {Awareness} awareness
709
+
* @param {any} clients
710
+
* @returns {Uint8Array}
711
+
*/
712
+
module.exports.encodeAwarenessUpdate = function (awareness, clients) {
713
+
_assertClass(awareness, Awareness);
714
+
const ret = wasm.encodeAwarenessUpdate(awareness.__wbg_ptr, clients);
715
+
if (ret[2]) {
716
+
throw takeFromExternrefTable0(ret[1]);
717
+
}
718
+
return takeFromExternrefTable0(ret[0]);
719
+
};
720
+
721
+
/**
722
+
* @param {Uint8Array} update
723
+
* @param {Function} modify
724
+
* @returns {Uint8Array}
725
+
*/
726
+
module.exports.modifyAwarenessUpdate = function (update, modify) {
727
+
const ret = wasm.modifyAwarenessUpdate(update, modify);
728
+
if (ret[2]) {
729
+
throw takeFromExternrefTable0(ret[1]);
730
+
}
731
+
return takeFromExternrefTable0(ret[0]);
732
+
};
733
+
734
+
/**
735
+
* @param {Awareness} awareness
736
+
* @param {Uint8Array} update
737
+
* @param {any} _origin
738
+
*/
739
+
module.exports.applyAwarenessUpdate = function (awareness, update, _origin) {
740
+
_assertClass(awareness, Awareness);
741
+
const ret = wasm.applyAwarenessUpdate(awareness.__wbg_ptr, update, _origin);
742
+
if (ret[1]) {
743
+
throw takeFromExternrefTable0(ret[0]);
744
+
}
745
+
};
746
+
747
+
const AwarenessFinalization =
748
+
typeof FinalizationRegistry === "undefined"
749
+
? { register: () => {}, unregister: () => {} }
750
+
: new FinalizationRegistry((ptr) =>
751
+
wasm.__wbg_awareness_free(ptr >>> 0, 1),
752
+
);
753
+
754
+
class Awareness {
755
+
__destroy_into_raw() {
756
+
const ptr = this.__wbg_ptr;
757
+
this.__wbg_ptr = 0;
758
+
AwarenessFinalization.unregister(this);
759
+
return ptr;
760
+
}
761
+
762
+
free() {
763
+
const ptr = this.__destroy_into_raw();
764
+
wasm.__wbg_awareness_free(ptr, 0);
765
+
}
766
+
/**
767
+
* @param {YDoc} doc
768
+
*/
769
+
constructor(doc) {
770
+
_assertClass(doc, YDoc);
771
+
var ptr0 = doc.__destroy_into_raw();
772
+
const ret = wasm.awareness_new(ptr0);
773
+
this.__wbg_ptr = ret >>> 0;
774
+
AwarenessFinalization.register(this, this.__wbg_ptr, this);
775
+
return this;
776
+
}
777
+
/**
778
+
* @returns {YDoc}
779
+
*/
780
+
get doc() {
781
+
const ret = wasm.awareness_doc(this.__wbg_ptr);
782
+
return YDoc.__wrap(ret);
783
+
}
784
+
/**
785
+
* @returns {Map<any, any>}
786
+
*/
787
+
get meta() {
788
+
const ret = wasm.awareness_meta(this.__wbg_ptr);
789
+
if (ret[2]) {
790
+
throw takeFromExternrefTable0(ret[1]);
791
+
}
792
+
return takeFromExternrefTable0(ret[0]);
793
+
}
794
+
destroy() {
795
+
wasm.awareness_destroy(this.__wbg_ptr);
796
+
}
797
+
/**
798
+
* @returns {any}
799
+
*/
800
+
getLocalState() {
801
+
const ret = wasm.awareness_getLocalState(this.__wbg_ptr);
802
+
if (ret[2]) {
803
+
throw takeFromExternrefTable0(ret[1]);
804
+
}
805
+
return takeFromExternrefTable0(ret[0]);
806
+
}
807
+
/**
808
+
* @param {any} state
809
+
*/
810
+
setLocalState(state) {
811
+
const ret = wasm.awareness_setLocalState(this.__wbg_ptr, state);
812
+
if (ret[1]) {
813
+
throw takeFromExternrefTable0(ret[0]);
814
+
}
815
+
}
816
+
/**
817
+
* @param {string} key
818
+
* @param {any} value
819
+
*/
820
+
setLocalStateField(key, value) {
821
+
const ptr0 = passStringToWasm0(
822
+
key,
823
+
wasm.__wbindgen_malloc,
824
+
wasm.__wbindgen_realloc,
825
+
);
826
+
const len0 = WASM_VECTOR_LEN;
827
+
const ret = wasm.awareness_setLocalStateField(
828
+
this.__wbg_ptr,
829
+
ptr0,
830
+
len0,
831
+
value,
832
+
);
833
+
if (ret[1]) {
834
+
throw takeFromExternrefTable0(ret[0]);
835
+
}
836
+
}
837
+
/**
838
+
* @returns {Map<any, any>}
839
+
*/
840
+
getStates() {
841
+
const ret = wasm.awareness_getStates(this.__wbg_ptr);
842
+
if (ret[2]) {
843
+
throw takeFromExternrefTable0(ret[1]);
844
+
}
845
+
return takeFromExternrefTable0(ret[0]);
846
+
}
847
+
/**
848
+
* @param {string} event
849
+
* @param {Function} callback
850
+
*/
851
+
on(event, callback) {
852
+
const ptr0 = passStringToWasm0(
853
+
event,
854
+
wasm.__wbindgen_malloc,
855
+
wasm.__wbindgen_realloc,
856
+
);
857
+
const len0 = WASM_VECTOR_LEN;
858
+
const ret = wasm.awareness_on(this.__wbg_ptr, ptr0, len0, callback);
859
+
if (ret[1]) {
860
+
throw takeFromExternrefTable0(ret[0]);
861
+
}
862
+
}
863
+
/**
864
+
* @param {string} event
865
+
* @param {Function} callback
866
+
* @returns {boolean}
867
+
*/
868
+
off(event, callback) {
869
+
const ptr0 = passStringToWasm0(
870
+
event,
871
+
wasm.__wbindgen_malloc,
872
+
wasm.__wbindgen_realloc,
873
+
);
874
+
const len0 = WASM_VECTOR_LEN;
875
+
const ret = wasm.awareness_off(this.__wbg_ptr, ptr0, len0, callback);
876
+
if (ret[2]) {
877
+
throw takeFromExternrefTable0(ret[1]);
878
+
}
879
+
return ret[0] !== 0;
880
+
}
881
+
}
882
+
module.exports.Awareness = Awareness;
883
+
884
+
const YArrayFinalization =
885
+
typeof FinalizationRegistry === "undefined"
886
+
? { register: () => {}, unregister: () => {} }
887
+
: new FinalizationRegistry((ptr) => wasm.__wbg_yarray_free(ptr >>> 0, 1));
888
+
/**
889
+
* A collection used to store data in an indexed sequence structure. This type is internally
890
+
* implemented as a double linked list, which may squash values inserted directly one after another
891
+
* into single list node upon transaction commit.
892
+
*
893
+
* Reading a root-level type as an YArray means treating its sequence components as a list, where
894
+
* every countable element becomes an individual entity:
895
+
*
896
+
* - JSON-like primitives (booleans, numbers, strings, JSON maps, arrays etc.) are counted
897
+
* individually.
898
+
* - Text chunks inserted by [Text] data structure: each character becomes an element of an
899
+
* array.
900
+
* - Embedded and binary values: they count as a single element even though they correspond of
901
+
* multiple bytes.
902
+
*
903
+
* Like all Yrs shared data types, YArray is resistant to the problem of interleaving (situation
904
+
* when elements inserted one after another may interleave with other peers concurrent inserts
905
+
* after merging all updates together). In case of Yrs conflict resolution is solved by using
906
+
* unique document id to determine correct and consistent ordering.
907
+
*/
908
+
class YArray {
909
+
static __wrap(ptr) {
910
+
ptr = ptr >>> 0;
911
+
const obj = Object.create(YArray.prototype);
912
+
obj.__wbg_ptr = ptr;
913
+
YArrayFinalization.register(obj, obj.__wbg_ptr, obj);
914
+
return obj;
915
+
}
916
+
917
+
__destroy_into_raw() {
918
+
const ptr = this.__wbg_ptr;
919
+
this.__wbg_ptr = 0;
920
+
YArrayFinalization.unregister(this);
921
+
return ptr;
922
+
}
923
+
924
+
free() {
925
+
const ptr = this.__destroy_into_raw();
926
+
wasm.__wbg_yarray_free(ptr, 0);
927
+
}
928
+
/**
929
+
* Creates a new preliminary instance of a `YArray` shared data type, with its state
930
+
* initialized to provided parameter.
931
+
*
932
+
* Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.
933
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
934
+
* document store and cannot be nested again: attempt to do so will result in an exception.
935
+
* @param {any[] | null} [items]
936
+
*/
937
+
constructor(items) {
938
+
var ptr0 = isLikeNone(items)
939
+
? 0
940
+
: passArrayJsValueToWasm0(items, wasm.__wbindgen_malloc);
941
+
var len0 = WASM_VECTOR_LEN;
942
+
const ret = wasm.yarray_new(ptr0, len0);
943
+
this.__wbg_ptr = ret >>> 0;
944
+
YArrayFinalization.register(this, this.__wbg_ptr, this);
945
+
return this;
946
+
}
947
+
/**
948
+
* @returns {number}
949
+
*/
950
+
get type() {
951
+
const ret = wasm.yarray_type(this.__wbg_ptr);
952
+
return ret;
953
+
}
954
+
/**
955
+
* Gets unique logical identifier of this type, shared across peers collaborating on the same
956
+
* document.
957
+
* @returns {any}
958
+
*/
959
+
get id() {
960
+
const ret = wasm.yarray_id(this.__wbg_ptr);
961
+
if (ret[2]) {
962
+
throw takeFromExternrefTable0(ret[1]);
963
+
}
964
+
return takeFromExternrefTable0(ret[0]);
965
+
}
966
+
/**
967
+
* Returns true if this is a preliminary instance of `YArray`.
968
+
*
969
+
* Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.
970
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
971
+
* document store and cannot be nested again: attempt to do so will result in an exception.
972
+
* @returns {boolean}
973
+
*/
974
+
get prelim() {
975
+
const ret = wasm.yarray_prelim(this.__wbg_ptr);
976
+
return ret !== 0;
977
+
}
978
+
/**
979
+
* Checks if current YArray reference is alive and has not been deleted by its parent collection.
980
+
* This method only works on already integrated shared types and will return false is current
981
+
* type is preliminary (has not been integrated into document).
982
+
* @param {YTransaction} txn
983
+
* @returns {boolean}
984
+
*/
985
+
alive(txn) {
986
+
_assertClass(txn, YTransaction);
987
+
const ret = wasm.yarray_alive(this.__wbg_ptr, txn.__wbg_ptr);
988
+
return ret !== 0;
989
+
}
990
+
/**
991
+
* Returns a number of elements stored within this instance of `YArray`.
992
+
* @param {YTransaction | undefined} txn
993
+
* @returns {number}
994
+
*/
995
+
length(txn) {
996
+
const ret = wasm.yarray_length(this.__wbg_ptr, txn);
997
+
if (ret[2]) {
998
+
throw takeFromExternrefTable0(ret[1]);
999
+
}
1000
+
return ret[0] >>> 0;
1001
+
}
1002
+
/**
1003
+
* Converts an underlying contents of this `YArray` instance into their JSON representation.
1004
+
* @param {YTransaction | undefined} txn
1005
+
* @returns {any}
1006
+
*/
1007
+
toJson(txn) {
1008
+
const ret = wasm.yarray_toJson(this.__wbg_ptr, txn);
1009
+
if (ret[2]) {
1010
+
throw takeFromExternrefTable0(ret[1]);
1011
+
}
1012
+
return takeFromExternrefTable0(ret[0]);
1013
+
}
1014
+
/**
1015
+
* Inserts a given range of `items` into this `YArray` instance, starting at given `index`.
1016
+
* @param {number} index
1017
+
* @param {any[]} items
1018
+
* @param {YTransaction | undefined} txn
1019
+
*/
1020
+
insert(index, items, txn) {
1021
+
const ptr0 = passArrayJsValueToWasm0(items, wasm.__wbindgen_malloc);
1022
+
const len0 = WASM_VECTOR_LEN;
1023
+
const ret = wasm.yarray_insert(this.__wbg_ptr, index, ptr0, len0, txn);
1024
+
if (ret[1]) {
1025
+
throw takeFromExternrefTable0(ret[0]);
1026
+
}
1027
+
}
1028
+
/**
1029
+
* Appends a range of `items` at the end of this `YArray` instance.
1030
+
* @param {any[]} items
1031
+
* @param {YTransaction | undefined} txn
1032
+
*/
1033
+
push(items, txn) {
1034
+
const ptr0 = passArrayJsValueToWasm0(items, wasm.__wbindgen_malloc);
1035
+
const len0 = WASM_VECTOR_LEN;
1036
+
const ret = wasm.yarray_push(this.__wbg_ptr, ptr0, len0, txn);
1037
+
if (ret[1]) {
1038
+
throw takeFromExternrefTable0(ret[0]);
1039
+
}
1040
+
}
1041
+
/**
1042
+
* Deletes a range of items of given `length` from current `YArray` instance,
1043
+
* starting from given `index`.
1044
+
* @param {number} index
1045
+
* @param {number | null | undefined} length
1046
+
* @param {YTransaction | undefined} txn
1047
+
*/
1048
+
delete(index, length, txn) {
1049
+
const ret = wasm.yarray_delete(
1050
+
this.__wbg_ptr,
1051
+
index,
1052
+
isLikeNone(length) ? 0x100000001 : length >>> 0,
1053
+
txn,
1054
+
);
1055
+
if (ret[1]) {
1056
+
throw takeFromExternrefTable0(ret[0]);
1057
+
}
1058
+
}
1059
+
/**
1060
+
* Moves element found at `source` index into `target` index position.
1061
+
* @param {number} source
1062
+
* @param {number} target
1063
+
* @param {YTransaction | undefined} txn
1064
+
*/
1065
+
move(source, target, txn) {
1066
+
const ret = wasm.yarray_move(this.__wbg_ptr, source, target, txn);
1067
+
if (ret[1]) {
1068
+
throw takeFromExternrefTable0(ret[0]);
1069
+
}
1070
+
}
1071
+
/**
1072
+
* Returns an element stored under given `index`.
1073
+
* @param {number} index
1074
+
* @param {YTransaction | undefined} txn
1075
+
* @returns {any}
1076
+
*/
1077
+
get(index, txn) {
1078
+
const ret = wasm.yarray_get(this.__wbg_ptr, index, txn);
1079
+
if (ret[2]) {
1080
+
throw takeFromExternrefTable0(ret[1]);
1081
+
}
1082
+
return takeFromExternrefTable0(ret[0]);
1083
+
}
1084
+
/**
1085
+
* @param {number | null | undefined} lower
1086
+
* @param {number | null | undefined} upper
1087
+
* @param {boolean | null | undefined} lower_open
1088
+
* @param {boolean | null | undefined} upper_open
1089
+
* @param {YTransaction | undefined} txn
1090
+
* @returns {YWeakLink}
1091
+
*/
1092
+
quote(lower, upper, lower_open, upper_open, txn) {
1093
+
const ret = wasm.yarray_quote(
1094
+
this.__wbg_ptr,
1095
+
isLikeNone(lower) ? 0x100000001 : lower >>> 0,
1096
+
isLikeNone(upper) ? 0x100000001 : upper >>> 0,
1097
+
isLikeNone(lower_open) ? 0xffffff : lower_open ? 1 : 0,
1098
+
isLikeNone(upper_open) ? 0xffffff : upper_open ? 1 : 0,
1099
+
txn,
1100
+
);
1101
+
if (ret[2]) {
1102
+
throw takeFromExternrefTable0(ret[1]);
1103
+
}
1104
+
return YWeakLink.__wrap(ret[0]);
1105
+
}
1106
+
/**
1107
+
* Returns an iterator that can be used to traverse over the values stored withing this
1108
+
* instance of `YArray`.
1109
+
*
1110
+
* Example:
1111
+
*
1112
+
* ```javascript
1113
+
* import YDoc from 'ywasm'
1114
+
*
1115
+
* /// document on machine A
1116
+
* const doc = new YDoc()
1117
+
* const array = doc.getArray('name')
1118
+
* const txn = doc.beginTransaction()
1119
+
* try {
1120
+
* array.push(txn, ['hello', 'world'])
1121
+
* for (let item of array.values(txn)) {
1122
+
* console.log(item)
1123
+
* }
1124
+
* } finally {
1125
+
* txn.free()
1126
+
* }
1127
+
* ```
1128
+
* @param {YTransaction | undefined} txn
1129
+
* @returns {any}
1130
+
*/
1131
+
values(txn) {
1132
+
const ret = wasm.yarray_values(this.__wbg_ptr, txn);
1133
+
if (ret[2]) {
1134
+
throw takeFromExternrefTable0(ret[1]);
1135
+
}
1136
+
return takeFromExternrefTable0(ret[0]);
1137
+
}
1138
+
/**
1139
+
* Subscribes to all operations happening over this instance of `YArray`. All changes are
1140
+
* batched and eventually triggered during transaction commit phase.
1141
+
* @param {Function} callback
1142
+
*/
1143
+
observe(callback) {
1144
+
const ret = wasm.yarray_observe(this.__wbg_ptr, callback);
1145
+
if (ret[1]) {
1146
+
throw takeFromExternrefTable0(ret[0]);
1147
+
}
1148
+
}
1149
+
/**
1150
+
* @param {Function} callback
1151
+
* @returns {boolean}
1152
+
*/
1153
+
unobserve(callback) {
1154
+
const ret = wasm.yarray_unobserve(this.__wbg_ptr, callback);
1155
+
if (ret[2]) {
1156
+
throw takeFromExternrefTable0(ret[1]);
1157
+
}
1158
+
return ret[0] !== 0;
1159
+
}
1160
+
/**
1161
+
* Subscribes to all operations happening over this Y shared type, as well as events in
1162
+
* shared types stored within this one. All changes are batched and eventually triggered
1163
+
* during transaction commit phase.
1164
+
* @param {Function} callback
1165
+
*/
1166
+
observeDeep(callback) {
1167
+
const ret = wasm.yarray_observeDeep(this.__wbg_ptr, callback);
1168
+
if (ret[1]) {
1169
+
throw takeFromExternrefTable0(ret[0]);
1170
+
}
1171
+
}
1172
+
/**
1173
+
* @param {Function} callback
1174
+
* @returns {boolean}
1175
+
*/
1176
+
unobserveDeep(callback) {
1177
+
const ret = wasm.yarray_unobserveDeep(this.__wbg_ptr, callback);
1178
+
if (ret[2]) {
1179
+
throw takeFromExternrefTable0(ret[1]);
1180
+
}
1181
+
return ret[0] !== 0;
1182
+
}
1183
+
}
1184
+
module.exports.YArray = YArray;
1185
+
1186
+
const YArrayEventFinalization =
1187
+
typeof FinalizationRegistry === "undefined"
1188
+
? { register: () => {}, unregister: () => {} }
1189
+
: new FinalizationRegistry((ptr) =>
1190
+
wasm.__wbg_yarrayevent_free(ptr >>> 0, 1),
1191
+
);
1192
+
/**
1193
+
* Event generated by `YArray.observe` method. Emitted during transaction commit phase.
1194
+
*/
1195
+
class YArrayEvent {
1196
+
static __wrap(ptr) {
1197
+
ptr = ptr >>> 0;
1198
+
const obj = Object.create(YArrayEvent.prototype);
1199
+
obj.__wbg_ptr = ptr;
1200
+
YArrayEventFinalization.register(obj, obj.__wbg_ptr, obj);
1201
+
return obj;
1202
+
}
1203
+
1204
+
__destroy_into_raw() {
1205
+
const ptr = this.__wbg_ptr;
1206
+
this.__wbg_ptr = 0;
1207
+
YArrayEventFinalization.unregister(this);
1208
+
return ptr;
1209
+
}
1210
+
1211
+
free() {
1212
+
const ptr = this.__destroy_into_raw();
1213
+
wasm.__wbg_yarrayevent_free(ptr, 0);
1214
+
}
1215
+
/**
1216
+
* Returns an array of keys and indexes creating a path from root type down to current instance
1217
+
* of shared type (accessible via `target` getter).
1218
+
* @returns {any}
1219
+
*/
1220
+
path() {
1221
+
const ret = wasm.yarrayevent_path(this.__wbg_ptr);
1222
+
return ret;
1223
+
}
1224
+
/**
1225
+
* Returns a current shared type instance, that current event changes refer to.
1226
+
* @returns {any}
1227
+
*/
1228
+
get target() {
1229
+
const ret = wasm.yarrayevent_target(this.__wbg_ptr);
1230
+
return ret;
1231
+
}
1232
+
/**
1233
+
* @returns {any}
1234
+
*/
1235
+
get origin() {
1236
+
const ret = wasm.yarrayevent_origin(this.__wbg_ptr);
1237
+
return ret;
1238
+
}
1239
+
/**
1240
+
* Returns a list of text changes made over corresponding `YArray` collection within
1241
+
* bounds of current transaction. These changes follow a format:
1242
+
*
1243
+
* - { insert: any[] }
1244
+
* - { delete: number }
1245
+
* - { retain: number }
1246
+
* @returns {any}
1247
+
*/
1248
+
get delta() {
1249
+
const ret = wasm.yarrayevent_delta(this.__wbg_ptr);
1250
+
return ret;
1251
+
}
1252
+
}
1253
+
module.exports.YArrayEvent = YArrayEvent;
1254
+
1255
+
const YDocFinalization =
1256
+
typeof FinalizationRegistry === "undefined"
1257
+
? { register: () => {}, unregister: () => {} }
1258
+
: new FinalizationRegistry((ptr) => wasm.__wbg_ydoc_free(ptr >>> 0, 1));
1259
+
/**
1260
+
* A ywasm document type. Documents are most important units of collaborative resources management.
1261
+
* All shared collections live within a scope of their corresponding documents. All updates are
1262
+
* generated on per-document basis (rather than individual shared type). All operations on shared
1263
+
* collections happen via [YTransaction], which lifetime is also bound to a document.
1264
+
*
1265
+
* Document manages so-called root types, which are top-level shared types definitions (as opposed
1266
+
* to recursively nested types).
1267
+
*
1268
+
* A basic workflow sample:
1269
+
*
1270
+
* ```javascript
1271
+
* import YDoc from 'ywasm'
1272
+
*
1273
+
* const doc = new YDoc()
1274
+
* const txn = doc.beginTransaction()
1275
+
* try {
1276
+
* const text = txn.getText('name')
1277
+
* text.push(txn, 'hello world')
1278
+
* const output = text.toString(txn)
1279
+
* console.log(output)
1280
+
* } finally {
1281
+
* txn.free()
1282
+
* }
1283
+
* ```
1284
+
*/
1285
+
class YDoc {
1286
+
static __wrap(ptr) {
1287
+
ptr = ptr >>> 0;
1288
+
const obj = Object.create(YDoc.prototype);
1289
+
obj.__wbg_ptr = ptr;
1290
+
YDocFinalization.register(obj, obj.__wbg_ptr, obj);
1291
+
return obj;
1292
+
}
1293
+
1294
+
__destroy_into_raw() {
1295
+
const ptr = this.__wbg_ptr;
1296
+
this.__wbg_ptr = 0;
1297
+
YDocFinalization.unregister(this);
1298
+
return ptr;
1299
+
}
1300
+
1301
+
free() {
1302
+
const ptr = this.__destroy_into_raw();
1303
+
wasm.__wbg_ydoc_free(ptr, 0);
1304
+
}
1305
+
/**
1306
+
* Creates a new ywasm document. If `id` parameter was passed it will be used as this document
1307
+
* globally unique identifier (it's up to caller to ensure that requirement). Otherwise it will
1308
+
* be assigned a randomly generated number.
1309
+
* @param {any} options
1310
+
*/
1311
+
constructor(options) {
1312
+
const ret = wasm.ydoc_new(options);
1313
+
if (ret[2]) {
1314
+
throw takeFromExternrefTable0(ret[1]);
1315
+
}
1316
+
this.__wbg_ptr = ret[0] >>> 0;
1317
+
YDocFinalization.register(this, this.__wbg_ptr, this);
1318
+
return this;
1319
+
}
1320
+
/**
1321
+
* @returns {number}
1322
+
*/
1323
+
get type() {
1324
+
const ret = wasm.ydoc_type(this.__wbg_ptr);
1325
+
return ret;
1326
+
}
1327
+
/**
1328
+
* Checks if a document is a preliminary type. It returns false, if current document
1329
+
* is already a sub-document of another document.
1330
+
* @returns {boolean}
1331
+
*/
1332
+
get prelim() {
1333
+
const ret = wasm.ydoc_prelim(this.__wbg_ptr);
1334
+
return ret !== 0;
1335
+
}
1336
+
/**
1337
+
* Returns a parent document of this document or null if current document is not sub-document.
1338
+
* @returns {YDoc | undefined}
1339
+
*/
1340
+
get parentDoc() {
1341
+
const ret = wasm.ydoc_parentDoc(this.__wbg_ptr);
1342
+
return ret === 0 ? undefined : YDoc.__wrap(ret);
1343
+
}
1344
+
/**
1345
+
* Gets unique peer identifier of this `YDoc` instance.
1346
+
* @returns {number}
1347
+
*/
1348
+
get id() {
1349
+
const ret = wasm.ydoc_id(this.__wbg_ptr);
1350
+
return ret;
1351
+
}
1352
+
/**
1353
+
* Gets globally unique identifier of this `YDoc` instance.
1354
+
* @returns {string}
1355
+
*/
1356
+
get guid() {
1357
+
let deferred1_0;
1358
+
let deferred1_1;
1359
+
try {
1360
+
const ret = wasm.ydoc_guid(this.__wbg_ptr);
1361
+
deferred1_0 = ret[0];
1362
+
deferred1_1 = ret[1];
1363
+
return getStringFromWasm0(ret[0], ret[1]);
1364
+
} finally {
1365
+
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1366
+
}
1367
+
}
1368
+
/**
1369
+
* @returns {boolean}
1370
+
*/
1371
+
get shouldLoad() {
1372
+
const ret = wasm.ydoc_shouldLoad(this.__wbg_ptr);
1373
+
return ret !== 0;
1374
+
}
1375
+
/**
1376
+
* @returns {boolean}
1377
+
*/
1378
+
get autoLoad() {
1379
+
const ret = wasm.ydoc_autoLoad(this.__wbg_ptr);
1380
+
return ret !== 0;
1381
+
}
1382
+
/**
1383
+
* Returns a new transaction for this document. Ywasm shared data types execute their
1384
+
* operations in a context of a given transaction. Each document can have only one active
1385
+
* transaction at the time - subsequent attempts will cause exception to be thrown.
1386
+
*
1387
+
* Transactions started with `doc.beginTransaction` can be released using `transaction.free`
1388
+
* method.
1389
+
*
1390
+
* Example:
1391
+
*
1392
+
* ```javascript
1393
+
* import YDoc from 'ywasm'
1394
+
*
1395
+
* // helper function used to simplify transaction
1396
+
* // create/release cycle
1397
+
* YDoc.prototype.transact = callback => {
1398
+
* const txn = this.transaction()
1399
+
* try {
1400
+
* return callback(txn)
1401
+
* } finally {
1402
+
* txn.free()
1403
+
* }
1404
+
* }
1405
+
*
1406
+
* const doc = new YDoc()
1407
+
* const text = doc.getText('name')
1408
+
* doc.transact(txn => text.insert(txn, 0, 'hello world'))
1409
+
* ```
1410
+
* @param {any} origin
1411
+
* @returns {YTransaction}
1412
+
*/
1413
+
beginTransaction(origin) {
1414
+
const ret = wasm.ydoc_beginTransaction(this.__wbg_ptr, origin);
1415
+
return YTransaction.__wrap(ret);
1416
+
}
1417
+
/**
1418
+
* Returns a `YText` shared data type, that's accessible for subsequent accesses using given
1419
+
* `name`.
1420
+
*
1421
+
* If there was no instance with this name before, it will be created and then returned.
1422
+
*
1423
+
* If there was an instance with this name, but it was of different type, it will be projected
1424
+
* onto `YText` instance.
1425
+
* @param {string} name
1426
+
* @returns {YText}
1427
+
*/
1428
+
getText(name) {
1429
+
const ptr0 = passStringToWasm0(
1430
+
name,
1431
+
wasm.__wbindgen_malloc,
1432
+
wasm.__wbindgen_realloc,
1433
+
);
1434
+
const len0 = WASM_VECTOR_LEN;
1435
+
const ret = wasm.ydoc_getText(this.__wbg_ptr, ptr0, len0);
1436
+
return YText.__wrap(ret);
1437
+
}
1438
+
/**
1439
+
* Returns a `YArray` shared data type, that's accessible for subsequent accesses using given
1440
+
* `name`.
1441
+
*
1442
+
* If there was no instance with this name before, it will be created and then returned.
1443
+
*
1444
+
* If there was an instance with this name, but it was of different type, it will be projected
1445
+
* onto `YArray` instance.
1446
+
* @param {string} name
1447
+
* @returns {YArray}
1448
+
*/
1449
+
getArray(name) {
1450
+
const ptr0 = passStringToWasm0(
1451
+
name,
1452
+
wasm.__wbindgen_malloc,
1453
+
wasm.__wbindgen_realloc,
1454
+
);
1455
+
const len0 = WASM_VECTOR_LEN;
1456
+
const ret = wasm.ydoc_getArray(this.__wbg_ptr, ptr0, len0);
1457
+
return YArray.__wrap(ret);
1458
+
}
1459
+
/**
1460
+
* Returns a `YMap` shared data type, that's accessible for subsequent accesses using given
1461
+
* `name`.
1462
+
*
1463
+
* If there was no instance with this name before, it will be created and then returned.
1464
+
*
1465
+
* If there was an instance with this name, but it was of different type, it will be projected
1466
+
* onto `YMap` instance.
1467
+
* @param {string} name
1468
+
* @returns {YMap}
1469
+
*/
1470
+
getMap(name) {
1471
+
const ptr0 = passStringToWasm0(
1472
+
name,
1473
+
wasm.__wbindgen_malloc,
1474
+
wasm.__wbindgen_realloc,
1475
+
);
1476
+
const len0 = WASM_VECTOR_LEN;
1477
+
const ret = wasm.ydoc_getMap(this.__wbg_ptr, ptr0, len0);
1478
+
return YMap.__wrap(ret);
1479
+
}
1480
+
/**
1481
+
* Returns a `YXmlFragment` shared data type, that's accessible for subsequent accesses using
1482
+
* given `name`.
1483
+
*
1484
+
* If there was no instance with this name before, it will be created and then returned.
1485
+
*
1486
+
* If there was an instance with this name, but it was of different type, it will be projected
1487
+
* onto `YXmlFragment` instance.
1488
+
* @param {string} name
1489
+
* @returns {YXmlFragment}
1490
+
*/
1491
+
getXmlFragment(name) {
1492
+
const ptr0 = passStringToWasm0(
1493
+
name,
1494
+
wasm.__wbindgen_malloc,
1495
+
wasm.__wbindgen_realloc,
1496
+
);
1497
+
const len0 = WASM_VECTOR_LEN;
1498
+
const ret = wasm.ydoc_getXmlFragment(this.__wbg_ptr, ptr0, len0);
1499
+
return YXmlFragment.__wrap(ret);
1500
+
}
1501
+
/**
1502
+
* @param {string} event
1503
+
* @param {Function} callback
1504
+
*/
1505
+
on(event, callback) {
1506
+
const ptr0 = passStringToWasm0(
1507
+
event,
1508
+
wasm.__wbindgen_malloc,
1509
+
wasm.__wbindgen_realloc,
1510
+
);
1511
+
const len0 = WASM_VECTOR_LEN;
1512
+
const ret = wasm.ydoc_on(this.__wbg_ptr, ptr0, len0, callback);
1513
+
if (ret[1]) {
1514
+
throw takeFromExternrefTable0(ret[0]);
1515
+
}
1516
+
}
1517
+
/**
1518
+
* @param {string} event
1519
+
* @param {Function} callback
1520
+
* @returns {boolean}
1521
+
*/
1522
+
off(event, callback) {
1523
+
const ptr0 = passStringToWasm0(
1524
+
event,
1525
+
wasm.__wbindgen_malloc,
1526
+
wasm.__wbindgen_realloc,
1527
+
);
1528
+
const len0 = WASM_VECTOR_LEN;
1529
+
const ret = wasm.ydoc_off(this.__wbg_ptr, ptr0, len0, callback);
1530
+
if (ret[2]) {
1531
+
throw takeFromExternrefTable0(ret[1]);
1532
+
}
1533
+
return ret[0] !== 0;
1534
+
}
1535
+
/**
1536
+
* Notify the parent document that you request to load data into this subdocument
1537
+
* (if it is a subdocument).
1538
+
* @param {YTransaction | undefined} parent_txn
1539
+
*/
1540
+
load(parent_txn) {
1541
+
const ret = wasm.ydoc_load(this.__wbg_ptr, parent_txn);
1542
+
if (ret[1]) {
1543
+
throw takeFromExternrefTable0(ret[0]);
1544
+
}
1545
+
}
1546
+
/**
1547
+
* Emit `onDestroy` event and unregister all event handlers.
1548
+
* @param {YTransaction | undefined} parent_txn
1549
+
*/
1550
+
destroy(parent_txn) {
1551
+
const ret = wasm.ydoc_destroy(this.__wbg_ptr, parent_txn);
1552
+
if (ret[1]) {
1553
+
throw takeFromExternrefTable0(ret[0]);
1554
+
}
1555
+
}
1556
+
/**
1557
+
* Returns a list of sub-documents existings within the scope of this document.
1558
+
* @param {YTransaction | undefined} txn
1559
+
* @returns {Array<any>}
1560
+
*/
1561
+
getSubdocs(txn) {
1562
+
const ret = wasm.ydoc_getSubdocs(this.__wbg_ptr, txn);
1563
+
if (ret[2]) {
1564
+
throw takeFromExternrefTable0(ret[1]);
1565
+
}
1566
+
return takeFromExternrefTable0(ret[0]);
1567
+
}
1568
+
/**
1569
+
* Returns a list of unique identifiers of the sub-documents existings within the scope of
1570
+
* this document.
1571
+
* @param {YTransaction | undefined} txn
1572
+
* @returns {Set<any>}
1573
+
*/
1574
+
getSubdocGuids(txn) {
1575
+
const ret = wasm.ydoc_getSubdocGuids(this.__wbg_ptr, txn);
1576
+
if (ret[2]) {
1577
+
throw takeFromExternrefTable0(ret[1]);
1578
+
}
1579
+
return takeFromExternrefTable0(ret[0]);
1580
+
}
1581
+
/**
1582
+
* Returns a list of all root-level replicated collections, together with their types.
1583
+
* These collections can then be accessed via `getMap`/`getText` etc. methods.
1584
+
*
1585
+
* Example:
1586
+
* ```js
1587
+
* import * as Y from 'ywasm'
1588
+
*
1589
+
* const doc = new Y.YDoc()
1590
+
* const ymap = doc.getMap('a')
1591
+
* const yarray = doc.getArray('b')
1592
+
* const ytext = doc.getText('c')
1593
+
* const yxml = doc.getXmlFragment('d')
1594
+
*
1595
+
* const roots = doc.roots() // [['a',ymap], ['b',yarray], ['c',ytext], ['d',yxml]]
1596
+
* ```
1597
+
* @param {YTransaction | undefined} txn
1598
+
* @returns {Array<any>}
1599
+
*/
1600
+
roots(txn) {
1601
+
const ret = wasm.ydoc_roots(this.__wbg_ptr, txn);
1602
+
if (ret[2]) {
1603
+
throw takeFromExternrefTable0(ret[1]);
1604
+
}
1605
+
return takeFromExternrefTable0(ret[0]);
1606
+
}
1607
+
/**
1608
+
* Evaluates a JSON path expression (see: https://en.wikipedia.org/wiki/JSONPath) on
1609
+
* the document and returns an array of values matching that query.
1610
+
*
1611
+
* Currently, this method supports the following syntax:
1612
+
* - `$` - root object
1613
+
* - `@` - current object
1614
+
* - `.field` or `['field']` - member accessor
1615
+
* - `[1]` - array index (also supports negative indices)
1616
+
* - `.*` or `[*]` - wildcard (matches all members of an object or array)
1617
+
* - `..` - recursive descent (matches all descendants not only direct children)
1618
+
* - `[start:end:step]` - array slice operator (requires positive integer arguments)
1619
+
* - `['a', 'b', 'c']` - union operator (returns an array of values for each query)
1620
+
* - `[1, -1, 3]` - multiple indices operator (returns an array of values for each index)
1621
+
*
1622
+
* At the moment, JSON Path does not support filter predicates.
1623
+
* @param {string} json_path
1624
+
* @returns {Array<any>}
1625
+
*/
1626
+
selectAll(json_path) {
1627
+
const ptr0 = passStringToWasm0(
1628
+
json_path,
1629
+
wasm.__wbindgen_malloc,
1630
+
wasm.__wbindgen_realloc,
1631
+
);
1632
+
const len0 = WASM_VECTOR_LEN;
1633
+
const ret = wasm.ydoc_selectAll(this.__wbg_ptr, ptr0, len0);
1634
+
if (ret[2]) {
1635
+
throw takeFromExternrefTable0(ret[1]);
1636
+
}
1637
+
return takeFromExternrefTable0(ret[0]);
1638
+
}
1639
+
/**
1640
+
* Evaluates a JSON path expression (see: https://en.wikipedia.org/wiki/JSONPath) on
1641
+
* the document and returns first value matching that query.
1642
+
*
1643
+
* Currently, this method supports the following syntax:
1644
+
* - `$` - root object
1645
+
* - `@` - current object
1646
+
* - `.field` or `['field']` - member accessor
1647
+
* - `[1]` - array index (also supports negative indices)
1648
+
* - `.*` or `[*]` - wildcard (matches all members of an object or array)
1649
+
* - `..` - recursive descent (matches all descendants not only direct children)
1650
+
* - `[start:end:step]` - array slice operator (requires positive integer arguments)
1651
+
* - `['a', 'b', 'c']` - union operator (returns an array of values for each query)
1652
+
* - `[1, -1, 3]` - multiple indices operator (returns an array of values for each index)
1653
+
*
1654
+
* At the moment, JSON Path does not support filter predicates.
1655
+
* @param {string} json_path
1656
+
* @returns {any}
1657
+
*/
1658
+
selectOne(json_path) {
1659
+
const ptr0 = passStringToWasm0(
1660
+
json_path,
1661
+
wasm.__wbindgen_malloc,
1662
+
wasm.__wbindgen_realloc,
1663
+
);
1664
+
const len0 = WASM_VECTOR_LEN;
1665
+
const ret = wasm.ydoc_selectOne(this.__wbg_ptr, ptr0, len0);
1666
+
if (ret[2]) {
1667
+
throw takeFromExternrefTable0(ret[1]);
1668
+
}
1669
+
return takeFromExternrefTable0(ret[0]);
1670
+
}
1671
+
}
1672
+
module.exports.YDoc = YDoc;
1673
+
1674
+
const YMapFinalization =
1675
+
typeof FinalizationRegistry === "undefined"
1676
+
? { register: () => {}, unregister: () => {} }
1677
+
: new FinalizationRegistry((ptr) => wasm.__wbg_ymap_free(ptr >>> 0, 1));
1678
+
/**
1679
+
* Collection used to store key-value entries in an unordered manner. Keys are always represented
1680
+
* as UTF-8 strings. Values can be any value type supported by Yrs: JSON-like primitives as well as
1681
+
* shared data types.
1682
+
*
1683
+
* In terms of conflict resolution, [Map] uses logical last-write-wins principle, meaning the past
1684
+
* updates are automatically overridden and discarded by newer ones, while concurrent updates made
1685
+
* by different peers are resolved into a single value using document id seniority to establish
1686
+
* order.
1687
+
*/
1688
+
class YMap {
1689
+
static __wrap(ptr) {
1690
+
ptr = ptr >>> 0;
1691
+
const obj = Object.create(YMap.prototype);
1692
+
obj.__wbg_ptr = ptr;
1693
+
YMapFinalization.register(obj, obj.__wbg_ptr, obj);
1694
+
return obj;
1695
+
}
1696
+
1697
+
__destroy_into_raw() {
1698
+
const ptr = this.__wbg_ptr;
1699
+
this.__wbg_ptr = 0;
1700
+
YMapFinalization.unregister(this);
1701
+
return ptr;
1702
+
}
1703
+
1704
+
free() {
1705
+
const ptr = this.__destroy_into_raw();
1706
+
wasm.__wbg_ymap_free(ptr, 0);
1707
+
}
1708
+
/**
1709
+
* Creates a new preliminary instance of a `YMap` shared data type, with its state
1710
+
* initialized to provided parameter.
1711
+
*
1712
+
* Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.
1713
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
1714
+
* document store and cannot be nested again: attempt to do so will result in an exception.
1715
+
* @param {object | null} [init]
1716
+
*/
1717
+
constructor(init) {
1718
+
const ret = wasm.ymap_new(
1719
+
isLikeNone(init) ? 0 : addToExternrefTable0(init),
1720
+
);
1721
+
this.__wbg_ptr = ret >>> 0;
1722
+
YMapFinalization.register(this, this.__wbg_ptr, this);
1723
+
return this;
1724
+
}
1725
+
/**
1726
+
* @returns {number}
1727
+
*/
1728
+
get type() {
1729
+
const ret = wasm.ymap_type(this.__wbg_ptr);
1730
+
return ret;
1731
+
}
1732
+
/**
1733
+
* Gets unique logical identifier of this type, shared across peers collaborating on the same
1734
+
* document.
1735
+
* @returns {any}
1736
+
*/
1737
+
get id() {
1738
+
const ret = wasm.ymap_id(this.__wbg_ptr);
1739
+
if (ret[2]) {
1740
+
throw takeFromExternrefTable0(ret[1]);
1741
+
}
1742
+
return takeFromExternrefTable0(ret[0]);
1743
+
}
1744
+
/**
1745
+
* Returns true if this is a preliminary instance of `YMap`.
1746
+
*
1747
+
* Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.
1748
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
1749
+
* document store and cannot be nested again: attempt to do so will result in an exception.
1750
+
* @returns {boolean}
1751
+
*/
1752
+
get prelim() {
1753
+
const ret = wasm.ymap_prelim(this.__wbg_ptr);
1754
+
return ret !== 0;
1755
+
}
1756
+
/**
1757
+
* Checks if current YMap reference is alive and has not been deleted by its parent collection.
1758
+
* This method only works on already integrated shared types and will return false is current
1759
+
* type is preliminary (has not been integrated into document).
1760
+
* @param {YTransaction} txn
1761
+
* @returns {boolean}
1762
+
*/
1763
+
alive(txn) {
1764
+
_assertClass(txn, YTransaction);
1765
+
const ret = wasm.ymap_alive(this.__wbg_ptr, txn.__wbg_ptr);
1766
+
return ret !== 0;
1767
+
}
1768
+
/**
1769
+
* Returns a number of entries stored within this instance of `YMap`.
1770
+
* @param {YTransaction | undefined} txn
1771
+
* @returns {number}
1772
+
*/
1773
+
length(txn) {
1774
+
const ret = wasm.ymap_length(this.__wbg_ptr, txn);
1775
+
if (ret[2]) {
1776
+
throw takeFromExternrefTable0(ret[1]);
1777
+
}
1778
+
return ret[0] >>> 0;
1779
+
}
1780
+
/**
1781
+
* Converts contents of this `YMap` instance into a JSON representation.
1782
+
* @param {YTransaction | undefined} txn
1783
+
* @returns {any}
1784
+
*/
1785
+
toJson(txn) {
1786
+
const ret = wasm.ymap_toJson(this.__wbg_ptr, txn);
1787
+
if (ret[2]) {
1788
+
throw takeFromExternrefTable0(ret[1]);
1789
+
}
1790
+
return takeFromExternrefTable0(ret[0]);
1791
+
}
1792
+
/**
1793
+
* Sets a given `key`-`value` entry within this instance of `YMap`. If another entry was
1794
+
* already stored under given `key`, it will be overridden with new `value`.
1795
+
* @param {string} key
1796
+
* @param {any} value
1797
+
* @param {YTransaction | undefined} txn
1798
+
*/
1799
+
set(key, value, txn) {
1800
+
const ptr0 = passStringToWasm0(
1801
+
key,
1802
+
wasm.__wbindgen_malloc,
1803
+
wasm.__wbindgen_realloc,
1804
+
);
1805
+
const len0 = WASM_VECTOR_LEN;
1806
+
const ret = wasm.ymap_set(this.__wbg_ptr, ptr0, len0, value, txn);
1807
+
if (ret[1]) {
1808
+
throw takeFromExternrefTable0(ret[0]);
1809
+
}
1810
+
}
1811
+
/**
1812
+
* Removes an entry identified by a given `key` from this instance of `YMap`, if such exists.
1813
+
* @param {string} key
1814
+
* @param {YTransaction | undefined} txn
1815
+
*/
1816
+
delete(key, txn) {
1817
+
const ptr0 = passStringToWasm0(
1818
+
key,
1819
+
wasm.__wbindgen_malloc,
1820
+
wasm.__wbindgen_realloc,
1821
+
);
1822
+
const len0 = WASM_VECTOR_LEN;
1823
+
const ret = wasm.ymap_delete(this.__wbg_ptr, ptr0, len0, txn);
1824
+
if (ret[1]) {
1825
+
throw takeFromExternrefTable0(ret[0]);
1826
+
}
1827
+
}
1828
+
/**
1829
+
* Returns value of an entry stored under given `key` within this instance of `YMap`,
1830
+
* or `undefined` if no such entry existed.
1831
+
* @param {string} key
1832
+
* @param {YTransaction | undefined} txn
1833
+
* @returns {any}
1834
+
*/
1835
+
get(key, txn) {
1836
+
const ptr0 = passStringToWasm0(
1837
+
key,
1838
+
wasm.__wbindgen_malloc,
1839
+
wasm.__wbindgen_realloc,
1840
+
);
1841
+
const len0 = WASM_VECTOR_LEN;
1842
+
const ret = wasm.ymap_get(this.__wbg_ptr, ptr0, len0, txn);
1843
+
if (ret[2]) {
1844
+
throw takeFromExternrefTable0(ret[1]);
1845
+
}
1846
+
return takeFromExternrefTable0(ret[0]);
1847
+
}
1848
+
/**
1849
+
* @param {string} key
1850
+
* @param {YTransaction | undefined} txn
1851
+
* @returns {any}
1852
+
*/
1853
+
link(key, txn) {
1854
+
const ptr0 = passStringToWasm0(
1855
+
key,
1856
+
wasm.__wbindgen_malloc,
1857
+
wasm.__wbindgen_realloc,
1858
+
);
1859
+
const len0 = WASM_VECTOR_LEN;
1860
+
const ret = wasm.ymap_link(this.__wbg_ptr, ptr0, len0, txn);
1861
+
if (ret[2]) {
1862
+
throw takeFromExternrefTable0(ret[1]);
1863
+
}
1864
+
return takeFromExternrefTable0(ret[0]);
1865
+
}
1866
+
/**
1867
+
* Returns an iterator that can be used to traverse over all entries stored within this
1868
+
* instance of `YMap`. Order of entry is not specified.
1869
+
*
1870
+
* Example:
1871
+
*
1872
+
* ```javascript
1873
+
* import YDoc from 'ywasm'
1874
+
*
1875
+
* /// document on machine A
1876
+
* const doc = new YDoc()
1877
+
* const map = doc.getMap('name')
1878
+
* const txn = doc.beginTransaction()
1879
+
* try {
1880
+
* map.set(txn, 'key1', 'value1')
1881
+
* map.set(txn, 'key2', true)
1882
+
*
1883
+
* for (let [key, value] of map.entries(txn)) {
1884
+
* console.log(key, value)
1885
+
* }
1886
+
* } finally {
1887
+
* txn.free()
1888
+
* }
1889
+
* ```
1890
+
* @param {YTransaction | undefined} txn
1891
+
* @returns {any}
1892
+
*/
1893
+
entries(txn) {
1894
+
const ret = wasm.ymap_entries(this.__wbg_ptr, txn);
1895
+
if (ret[2]) {
1896
+
throw takeFromExternrefTable0(ret[1]);
1897
+
}
1898
+
return takeFromExternrefTable0(ret[0]);
1899
+
}
1900
+
/**
1901
+
* Subscribes to all operations happening over this instance of `YMap`. All changes are
1902
+
* batched and eventually triggered during transaction commit phase.
1903
+
* @param {Function} callback
1904
+
*/
1905
+
observe(callback) {
1906
+
const ret = wasm.ymap_observe(this.__wbg_ptr, callback);
1907
+
if (ret[1]) {
1908
+
throw takeFromExternrefTable0(ret[0]);
1909
+
}
1910
+
}
1911
+
/**
1912
+
* Unsubscribes a callback previously subscribed with `observe` method.
1913
+
* @param {Function} callback
1914
+
* @returns {boolean}
1915
+
*/
1916
+
unobserve(callback) {
1917
+
const ret = wasm.ymap_unobserve(this.__wbg_ptr, callback);
1918
+
if (ret[2]) {
1919
+
throw takeFromExternrefTable0(ret[1]);
1920
+
}
1921
+
return ret[0] !== 0;
1922
+
}
1923
+
/**
1924
+
* Subscribes to all operations happening over this Y shared type, as well as events in
1925
+
* shared types stored within this one. All changes are batched and eventually triggered
1926
+
* during transaction commit phase.
1927
+
* @param {Function} callback
1928
+
*/
1929
+
observeDeep(callback) {
1930
+
const ret = wasm.ymap_observeDeep(this.__wbg_ptr, callback);
1931
+
if (ret[1]) {
1932
+
throw takeFromExternrefTable0(ret[0]);
1933
+
}
1934
+
}
1935
+
/**
1936
+
* Unsubscribes a callback previously subscribed with `observeDeep` method.
1937
+
* @param {Function} callback
1938
+
* @returns {boolean}
1939
+
*/
1940
+
unobserveDeep(callback) {
1941
+
const ret = wasm.ymap_unobserveDeep(this.__wbg_ptr, callback);
1942
+
if (ret[2]) {
1943
+
throw takeFromExternrefTable0(ret[1]);
1944
+
}
1945
+
return ret[0] !== 0;
1946
+
}
1947
+
}
1948
+
module.exports.YMap = YMap;
1949
+
1950
+
const YMapEventFinalization =
1951
+
typeof FinalizationRegistry === "undefined"
1952
+
? { register: () => {}, unregister: () => {} }
1953
+
: new FinalizationRegistry((ptr) =>
1954
+
wasm.__wbg_ymapevent_free(ptr >>> 0, 1),
1955
+
);
1956
+
/**
1957
+
* Event generated by `YMap.observe` method. Emitted during transaction commit phase.
1958
+
*/
1959
+
class YMapEvent {
1960
+
static __wrap(ptr) {
1961
+
ptr = ptr >>> 0;
1962
+
const obj = Object.create(YMapEvent.prototype);
1963
+
obj.__wbg_ptr = ptr;
1964
+
YMapEventFinalization.register(obj, obj.__wbg_ptr, obj);
1965
+
return obj;
1966
+
}
1967
+
1968
+
__destroy_into_raw() {
1969
+
const ptr = this.__wbg_ptr;
1970
+
this.__wbg_ptr = 0;
1971
+
YMapEventFinalization.unregister(this);
1972
+
return ptr;
1973
+
}
1974
+
1975
+
free() {
1976
+
const ptr = this.__destroy_into_raw();
1977
+
wasm.__wbg_ymapevent_free(ptr, 0);
1978
+
}
1979
+
/**
1980
+
* @returns {any}
1981
+
*/
1982
+
get origin() {
1983
+
const ret = wasm.ymapevent_origin(this.__wbg_ptr);
1984
+
return ret;
1985
+
}
1986
+
/**
1987
+
* Returns an array of keys and indexes creating a path from root type down to current instance
1988
+
* of shared type (accessible via `target` getter).
1989
+
* @returns {any}
1990
+
*/
1991
+
path() {
1992
+
const ret = wasm.ymapevent_path(this.__wbg_ptr);
1993
+
return ret;
1994
+
}
1995
+
/**
1996
+
* Returns a current shared type instance, that current event changes refer to.
1997
+
* @returns {any}
1998
+
*/
1999
+
get target() {
2000
+
const ret = wasm.ymapevent_target(this.__wbg_ptr);
2001
+
return ret;
2002
+
}
2003
+
/**
2004
+
* Returns a list of key-value changes made over corresponding `YMap` collection within
2005
+
* bounds of current transaction. These changes follow a format:
2006
+
*
2007
+
* - { action: 'add'|'update'|'delete', oldValue: any|undefined, newValue: any|undefined }
2008
+
* @returns {any}
2009
+
*/
2010
+
get keys() {
2011
+
const ret = wasm.ymapevent_keys(this.__wbg_ptr);
2012
+
if (ret[2]) {
2013
+
throw takeFromExternrefTable0(ret[1]);
2014
+
}
2015
+
return takeFromExternrefTable0(ret[0]);
2016
+
}
2017
+
}
2018
+
module.exports.YMapEvent = YMapEvent;
2019
+
2020
+
const YSubdocsEventFinalization =
2021
+
typeof FinalizationRegistry === "undefined"
2022
+
? { register: () => {}, unregister: () => {} }
2023
+
: new FinalizationRegistry((ptr) =>
2024
+
wasm.__wbg_ysubdocsevent_free(ptr >>> 0, 1),
2025
+
);
2026
+
2027
+
class YSubdocsEvent {
2028
+
static __wrap(ptr) {
2029
+
ptr = ptr >>> 0;
2030
+
const obj = Object.create(YSubdocsEvent.prototype);
2031
+
obj.__wbg_ptr = ptr;
2032
+
YSubdocsEventFinalization.register(obj, obj.__wbg_ptr, obj);
2033
+
return obj;
2034
+
}
2035
+
2036
+
__destroy_into_raw() {
2037
+
const ptr = this.__wbg_ptr;
2038
+
this.__wbg_ptr = 0;
2039
+
YSubdocsEventFinalization.unregister(this);
2040
+
return ptr;
2041
+
}
2042
+
2043
+
free() {
2044
+
const ptr = this.__destroy_into_raw();
2045
+
wasm.__wbg_ysubdocsevent_free(ptr, 0);
2046
+
}
2047
+
/**
2048
+
* @returns {Array<any>}
2049
+
*/
2050
+
get added() {
2051
+
const ret = wasm.ysubdocsevent_added(this.__wbg_ptr);
2052
+
return ret;
2053
+
}
2054
+
/**
2055
+
* @returns {Array<any>}
2056
+
*/
2057
+
get removed() {
2058
+
const ret = wasm.ysubdocsevent_removed(this.__wbg_ptr);
2059
+
return ret;
2060
+
}
2061
+
/**
2062
+
* @returns {Array<any>}
2063
+
*/
2064
+
get loaded() {
2065
+
const ret = wasm.ysubdocsevent_loaded(this.__wbg_ptr);
2066
+
return ret;
2067
+
}
2068
+
}
2069
+
module.exports.YSubdocsEvent = YSubdocsEvent;
2070
+
2071
+
const YTextFinalization =
2072
+
typeof FinalizationRegistry === "undefined"
2073
+
? { register: () => {}, unregister: () => {} }
2074
+
: new FinalizationRegistry((ptr) => wasm.__wbg_ytext_free(ptr >>> 0, 1));
2075
+
/**
2076
+
* A shared data type used for collaborative text editing. It enables multiple users to add and
2077
+
* remove chunks of text in efficient manner. This type is internally represented as a mutable
2078
+
* double-linked list of text chunks - an optimization occurs during `YTransaction.commit`, which
2079
+
* allows to squash multiple consecutively inserted characters together as a single chunk of text
2080
+
* even between transaction boundaries in order to preserve more efficient memory model.
2081
+
*
2082
+
* `YText` structure internally uses UTF-8 encoding and its length is described in a number of
2083
+
* bytes rather than individual characters (a single UTF-8 code point can consist of many bytes).
2084
+
*
2085
+
* Like all Yrs shared data types, `YText` is resistant to the problem of interleaving (situation
2086
+
* when characters inserted one after another may interleave with other peers concurrent inserts
2087
+
* after merging all updates together). In case of Yrs conflict resolution is solved by using
2088
+
* unique document id to determine correct and consistent ordering.
2089
+
*/
2090
+
class YText {
2091
+
static __wrap(ptr) {
2092
+
ptr = ptr >>> 0;
2093
+
const obj = Object.create(YText.prototype);
2094
+
obj.__wbg_ptr = ptr;
2095
+
YTextFinalization.register(obj, obj.__wbg_ptr, obj);
2096
+
return obj;
2097
+
}
2098
+
2099
+
__destroy_into_raw() {
2100
+
const ptr = this.__wbg_ptr;
2101
+
this.__wbg_ptr = 0;
2102
+
YTextFinalization.unregister(this);
2103
+
return ptr;
2104
+
}
2105
+
2106
+
free() {
2107
+
const ptr = this.__destroy_into_raw();
2108
+
wasm.__wbg_ytext_free(ptr, 0);
2109
+
}
2110
+
/**
2111
+
* Creates a new preliminary instance of a `YText` shared data type, with its state initialized
2112
+
* to provided parameter.
2113
+
*
2114
+
* Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.
2115
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
2116
+
* document store and cannot be nested again: attempt to do so will result in an exception.
2117
+
* @param {string | null} [init]
2118
+
*/
2119
+
constructor(init) {
2120
+
var ptr0 = isLikeNone(init)
2121
+
? 0
2122
+
: passStringToWasm0(
2123
+
init,
2124
+
wasm.__wbindgen_malloc,
2125
+
wasm.__wbindgen_realloc,
2126
+
);
2127
+
var len0 = WASM_VECTOR_LEN;
2128
+
const ret = wasm.ytext_new(ptr0, len0);
2129
+
this.__wbg_ptr = ret >>> 0;
2130
+
YTextFinalization.register(this, this.__wbg_ptr, this);
2131
+
return this;
2132
+
}
2133
+
/**
2134
+
* @returns {number}
2135
+
*/
2136
+
get type() {
2137
+
const ret = wasm.ytext_type(this.__wbg_ptr);
2138
+
return ret;
2139
+
}
2140
+
/**
2141
+
* Gets unique logical identifier of this type, shared across peers collaborating on the same
2142
+
* document.
2143
+
* @returns {any}
2144
+
*/
2145
+
get id() {
2146
+
const ret = wasm.ytext_id(this.__wbg_ptr);
2147
+
if (ret[2]) {
2148
+
throw takeFromExternrefTable0(ret[1]);
2149
+
}
2150
+
return takeFromExternrefTable0(ret[0]);
2151
+
}
2152
+
/**
2153
+
* Returns true if this is a preliminary instance of `YArray`.
2154
+
*
2155
+
* Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.
2156
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
2157
+
* document store and cannot be nested again: attempt to do so will result in an exception.
2158
+
* @returns {boolean}
2159
+
*/
2160
+
get prelim() {
2161
+
const ret = wasm.ytext_prelim(this.__wbg_ptr);
2162
+
return ret !== 0;
2163
+
}
2164
+
/**
2165
+
* Checks if current YArray reference is alive and has not been deleted by its parent collection.
2166
+
* This method only works on already integrated shared types and will return false is current
2167
+
* type is preliminary (has not been integrated into document).
2168
+
* @param {YTransaction} txn
2169
+
* @returns {boolean}
2170
+
*/
2171
+
alive(txn) {
2172
+
_assertClass(txn, YTransaction);
2173
+
const ret = wasm.ytext_alive(this.__wbg_ptr, txn.__wbg_ptr);
2174
+
return ret !== 0;
2175
+
}
2176
+
/**
2177
+
* Returns length of an underlying string stored in this `YText` instance,
2178
+
* understood as a number of UTF-8 encoded bytes.
2179
+
* @param {YTransaction | undefined} txn
2180
+
* @returns {number}
2181
+
*/
2182
+
length(txn) {
2183
+
const ret = wasm.ytext_length(this.__wbg_ptr, txn);
2184
+
if (ret[2]) {
2185
+
throw takeFromExternrefTable0(ret[1]);
2186
+
}
2187
+
return ret[0] >>> 0;
2188
+
}
2189
+
/**
2190
+
* Returns an underlying shared string stored in this data type.
2191
+
* @param {YTransaction | undefined} txn
2192
+
* @returns {string}
2193
+
*/
2194
+
toString(txn) {
2195
+
let deferred2_0;
2196
+
let deferred2_1;
2197
+
try {
2198
+
const ret = wasm.ytext_toString(this.__wbg_ptr, txn);
2199
+
var ptr1 = ret[0];
2200
+
var len1 = ret[1];
2201
+
if (ret[3]) {
2202
+
ptr1 = 0;
2203
+
len1 = 0;
2204
+
throw takeFromExternrefTable0(ret[2]);
2205
+
}
2206
+
deferred2_0 = ptr1;
2207
+
deferred2_1 = len1;
2208
+
return getStringFromWasm0(ptr1, len1);
2209
+
} finally {
2210
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
2211
+
}
2212
+
}
2213
+
/**
2214
+
* Returns an underlying shared string stored in this data type.
2215
+
* @param {YTransaction | undefined} txn
2216
+
* @returns {any}
2217
+
*/
2218
+
toJson(txn) {
2219
+
const ret = wasm.ytext_toJson(this.__wbg_ptr, txn);
2220
+
if (ret[2]) {
2221
+
throw takeFromExternrefTable0(ret[1]);
2222
+
}
2223
+
return takeFromExternrefTable0(ret[0]);
2224
+
}
2225
+
/**
2226
+
* Inserts a given `chunk` of text into this `YText` instance, starting at a given `index`.
2227
+
*
2228
+
* Optional object with defined `attributes` will be used to wrap provided text `chunk`
2229
+
* with a formatting blocks.`attributes` are only supported for a `YText` instance which
2230
+
* already has been integrated into document store.
2231
+
* @param {number} index
2232
+
* @param {string} chunk
2233
+
* @param {any} attributes
2234
+
* @param {YTransaction | undefined} txn
2235
+
*/
2236
+
insert(index, chunk, attributes, txn) {
2237
+
const ptr0 = passStringToWasm0(
2238
+
chunk,
2239
+
wasm.__wbindgen_malloc,
2240
+
wasm.__wbindgen_realloc,
2241
+
);
2242
+
const len0 = WASM_VECTOR_LEN;
2243
+
const ret = wasm.ytext_insert(
2244
+
this.__wbg_ptr,
2245
+
index,
2246
+
ptr0,
2247
+
len0,
2248
+
attributes,
2249
+
txn,
2250
+
);
2251
+
if (ret[1]) {
2252
+
throw takeFromExternrefTable0(ret[0]);
2253
+
}
2254
+
}
2255
+
/**
2256
+
* Inserts a given `embed` object into this `YText` instance, starting at a given `index`.
2257
+
*
2258
+
* Optional object with defined `attributes` will be used to wrap provided `embed`
2259
+
* with a formatting blocks.`attributes` are only supported for a `YText` instance which
2260
+
* already has been integrated into document store.
2261
+
* @param {number} index
2262
+
* @param {any} embed
2263
+
* @param {any} attributes
2264
+
* @param {YTransaction | undefined} txn
2265
+
*/
2266
+
insertEmbed(index, embed, attributes, txn) {
2267
+
const ret = wasm.ytext_insertEmbed(
2268
+
this.__wbg_ptr,
2269
+
index,
2270
+
embed,
2271
+
attributes,
2272
+
txn,
2273
+
);
2274
+
if (ret[1]) {
2275
+
throw takeFromExternrefTable0(ret[0]);
2276
+
}
2277
+
}
2278
+
/**
2279
+
* Wraps an existing piece of text within a range described by `index`-`length` parameters with
2280
+
* formatting blocks containing provided `attributes` metadata. This method only works for
2281
+
* `YText` instances that already have been integrated into document store.
2282
+
* @param {number} index
2283
+
* @param {number} length
2284
+
* @param {any} attributes
2285
+
* @param {YTransaction | undefined} txn
2286
+
*/
2287
+
format(index, length, attributes, txn) {
2288
+
const ret = wasm.ytext_format(
2289
+
this.__wbg_ptr,
2290
+
index,
2291
+
length,
2292
+
attributes,
2293
+
txn,
2294
+
);
2295
+
if (ret[1]) {
2296
+
throw takeFromExternrefTable0(ret[0]);
2297
+
}
2298
+
}
2299
+
/**
2300
+
* Appends a given `chunk` of text at the end of current `YText` instance.
2301
+
*
2302
+
* Optional object with defined `attributes` will be used to wrap provided text `chunk`
2303
+
* with a formatting blocks.`attributes` are only supported for a `YText` instance which
2304
+
* already has been integrated into document store.
2305
+
* @param {string} chunk
2306
+
* @param {any} attributes
2307
+
* @param {YTransaction | undefined} txn
2308
+
*/
2309
+
push(chunk, attributes, txn) {
2310
+
const ptr0 = passStringToWasm0(
2311
+
chunk,
2312
+
wasm.__wbindgen_malloc,
2313
+
wasm.__wbindgen_realloc,
2314
+
);
2315
+
const len0 = WASM_VECTOR_LEN;
2316
+
const ret = wasm.ytext_push(this.__wbg_ptr, ptr0, len0, attributes, txn);
2317
+
if (ret[1]) {
2318
+
throw takeFromExternrefTable0(ret[0]);
2319
+
}
2320
+
}
2321
+
/**
2322
+
* Deletes a specified range of characters, starting at a given `index`.
2323
+
* Both `index` and `length` are counted in terms of a number of UTF-8 character bytes.
2324
+
* @param {number} index
2325
+
* @param {number} length
2326
+
* @param {YTransaction | undefined} txn
2327
+
*/
2328
+
delete(index, length, txn) {
2329
+
const ret = wasm.ytext_delete(this.__wbg_ptr, index, length, txn);
2330
+
if (ret[1]) {
2331
+
throw takeFromExternrefTable0(ret[0]);
2332
+
}
2333
+
}
2334
+
/**
2335
+
* @param {number | null | undefined} lower
2336
+
* @param {number | null | undefined} upper
2337
+
* @param {boolean | null | undefined} lower_open
2338
+
* @param {boolean | null | undefined} upper_open
2339
+
* @param {YTransaction | undefined} txn
2340
+
* @returns {YWeakLink}
2341
+
*/
2342
+
quote(lower, upper, lower_open, upper_open, txn) {
2343
+
const ret = wasm.ytext_quote(
2344
+
this.__wbg_ptr,
2345
+
isLikeNone(lower) ? 0x100000001 : lower >>> 0,
2346
+
isLikeNone(upper) ? 0x100000001 : upper >>> 0,
2347
+
isLikeNone(lower_open) ? 0xffffff : lower_open ? 1 : 0,
2348
+
isLikeNone(upper_open) ? 0xffffff : upper_open ? 1 : 0,
2349
+
txn,
2350
+
);
2351
+
if (ret[2]) {
2352
+
throw takeFromExternrefTable0(ret[1]);
2353
+
}
2354
+
return YWeakLink.__wrap(ret[0]);
2355
+
}
2356
+
/**
2357
+
* Returns the Delta representation of this YText type.
2358
+
* @param {any} snapshot
2359
+
* @param {any} prev_snapshot
2360
+
* @param {Function | null | undefined} compute_ychange
2361
+
* @param {YTransaction | undefined} txn
2362
+
* @returns {Array<any>}
2363
+
*/
2364
+
toDelta(snapshot, prev_snapshot, compute_ychange, txn) {
2365
+
const ret = wasm.ytext_toDelta(
2366
+
this.__wbg_ptr,
2367
+
snapshot,
2368
+
prev_snapshot,
2369
+
isLikeNone(compute_ychange) ? 0 : addToExternrefTable0(compute_ychange),
2370
+
txn,
2371
+
);
2372
+
if (ret[2]) {
2373
+
throw takeFromExternrefTable0(ret[1]);
2374
+
}
2375
+
return takeFromExternrefTable0(ret[0]);
2376
+
}
2377
+
/**
2378
+
* @param {Array<any>} delta
2379
+
* @param {YTransaction | undefined} txn
2380
+
*/
2381
+
applyDelta(delta, txn) {
2382
+
const ret = wasm.ytext_applyDelta(this.__wbg_ptr, delta, txn);
2383
+
if (ret[1]) {
2384
+
throw takeFromExternrefTable0(ret[0]);
2385
+
}
2386
+
}
2387
+
/**
2388
+
* Subscribes to all operations happening over this instance of `YText`. All changes are
2389
+
* batched and eventually triggered during transaction commit phase.
2390
+
* @param {Function} callback
2391
+
*/
2392
+
observe(callback) {
2393
+
const ret = wasm.ytext_observe(this.__wbg_ptr, callback);
2394
+
if (ret[1]) {
2395
+
throw takeFromExternrefTable0(ret[0]);
2396
+
}
2397
+
}
2398
+
/**
2399
+
* Unsubscribes a callback previously subscribed with `observe` method.
2400
+
* @param {Function} callback
2401
+
* @returns {boolean}
2402
+
*/
2403
+
unobserve(callback) {
2404
+
const ret = wasm.ytext_unobserve(this.__wbg_ptr, callback);
2405
+
if (ret[2]) {
2406
+
throw takeFromExternrefTable0(ret[1]);
2407
+
}
2408
+
return ret[0] !== 0;
2409
+
}
2410
+
/**
2411
+
* Subscribes to all operations happening over this Y shared type, as well as events in
2412
+
* shared types stored within this one. All changes are batched and eventually triggered
2413
+
* during transaction commit phase.
2414
+
* @param {Function} callback
2415
+
*/
2416
+
observeDeep(callback) {
2417
+
const ret = wasm.ytext_observeDeep(this.__wbg_ptr, callback);
2418
+
if (ret[1]) {
2419
+
throw takeFromExternrefTable0(ret[0]);
2420
+
}
2421
+
}
2422
+
/**
2423
+
* Unsubscribes a callback previously subscribed with `observeDeep` method.
2424
+
* @param {Function} callback
2425
+
* @returns {boolean}
2426
+
*/
2427
+
unobserveDeep(callback) {
2428
+
const ret = wasm.ytext_unobserveDeep(this.__wbg_ptr, callback);
2429
+
if (ret[2]) {
2430
+
throw takeFromExternrefTable0(ret[1]);
2431
+
}
2432
+
return ret[0] !== 0;
2433
+
}
2434
+
}
2435
+
module.exports.YText = YText;
2436
+
2437
+
const YTextEventFinalization =
2438
+
typeof FinalizationRegistry === "undefined"
2439
+
? { register: () => {}, unregister: () => {} }
2440
+
: new FinalizationRegistry((ptr) =>
2441
+
wasm.__wbg_ytextevent_free(ptr >>> 0, 1),
2442
+
);
2443
+
/**
2444
+
* Event generated by `YYText.observe` method. Emitted during transaction commit phase.
2445
+
*/
2446
+
class YTextEvent {
2447
+
static __wrap(ptr) {
2448
+
ptr = ptr >>> 0;
2449
+
const obj = Object.create(YTextEvent.prototype);
2450
+
obj.__wbg_ptr = ptr;
2451
+
YTextEventFinalization.register(obj, obj.__wbg_ptr, obj);
2452
+
return obj;
2453
+
}
2454
+
2455
+
__destroy_into_raw() {
2456
+
const ptr = this.__wbg_ptr;
2457
+
this.__wbg_ptr = 0;
2458
+
YTextEventFinalization.unregister(this);
2459
+
return ptr;
2460
+
}
2461
+
2462
+
free() {
2463
+
const ptr = this.__destroy_into_raw();
2464
+
wasm.__wbg_ytextevent_free(ptr, 0);
2465
+
}
2466
+
/**
2467
+
* Returns an array of keys and indexes creating a path from root type down to current instance
2468
+
* of shared type (accessible via `target` getter).
2469
+
* @returns {any}
2470
+
*/
2471
+
path() {
2472
+
const ret = wasm.ytextevent_path(this.__wbg_ptr);
2473
+
return ret;
2474
+
}
2475
+
/**
2476
+
* Returns a current shared type instance, that current event changes refer to.
2477
+
* @returns {any}
2478
+
*/
2479
+
get target() {
2480
+
const ret = wasm.ytextevent_target(this.__wbg_ptr);
2481
+
return ret;
2482
+
}
2483
+
/**
2484
+
* @returns {any}
2485
+
*/
2486
+
get origin() {
2487
+
const ret = wasm.ytextevent_origin(this.__wbg_ptr);
2488
+
return ret;
2489
+
}
2490
+
/**
2491
+
* Returns a list of text changes made over corresponding `YText` collection within
2492
+
* bounds of current transaction. These changes follow a format:
2493
+
*
2494
+
* - { insert: string, attributes: any|undefined }
2495
+
* - { delete: number }
2496
+
* - { retain: number, attributes: any|undefined }
2497
+
* @returns {any}
2498
+
*/
2499
+
get delta() {
2500
+
const ret = wasm.ytextevent_delta(this.__wbg_ptr);
2501
+
if (ret[2]) {
2502
+
throw takeFromExternrefTable0(ret[1]);
2503
+
}
2504
+
return takeFromExternrefTable0(ret[0]);
2505
+
}
2506
+
}
2507
+
module.exports.YTextEvent = YTextEvent;
2508
+
2509
+
const YTransactionFinalization =
2510
+
typeof FinalizationRegistry === "undefined"
2511
+
? { register: () => {}, unregister: () => {} }
2512
+
: new FinalizationRegistry((ptr) =>
2513
+
wasm.__wbg_ytransaction_free(ptr >>> 0, 1),
2514
+
);
2515
+
2516
+
class YTransaction {
2517
+
static __wrap(ptr) {
2518
+
ptr = ptr >>> 0;
2519
+
const obj = Object.create(YTransaction.prototype);
2520
+
obj.__wbg_ptr = ptr;
2521
+
YTransactionFinalization.register(obj, obj.__wbg_ptr, obj);
2522
+
return obj;
2523
+
}
2524
+
2525
+
__destroy_into_raw() {
2526
+
const ptr = this.__wbg_ptr;
2527
+
this.__wbg_ptr = 0;
2528
+
YTransactionFinalization.unregister(this);
2529
+
return ptr;
2530
+
}
2531
+
2532
+
free() {
2533
+
const ptr = this.__destroy_into_raw();
2534
+
wasm.__wbg_ytransaction_free(ptr, 0);
2535
+
}
2536
+
/**
2537
+
* Returns state vector describing the state of the document
2538
+
* at the moment when the transaction began.
2539
+
* @returns {Map<any, any>}
2540
+
*/
2541
+
get beforeState() {
2542
+
const ret = wasm.ytransaction_beforeState(this.__wbg_ptr);
2543
+
return ret;
2544
+
}
2545
+
/**
2546
+
* Returns state vector describing the current state of
2547
+
* the document.
2548
+
* @returns {Map<any, any>}
2549
+
*/
2550
+
get afterState() {
2551
+
const ret = wasm.ytransaction_afterState(this.__wbg_ptr);
2552
+
return ret;
2553
+
}
2554
+
/**
2555
+
* @returns {any}
2556
+
*/
2557
+
get pendingStructs() {
2558
+
const ret = wasm.ytransaction_pendingStructs(this.__wbg_ptr);
2559
+
if (ret[2]) {
2560
+
throw takeFromExternrefTable0(ret[1]);
2561
+
}
2562
+
return takeFromExternrefTable0(ret[0]);
2563
+
}
2564
+
/**
2565
+
* Returns a unapplied delete set, that was received in one of the previous remote updates.
2566
+
* This DeleteSet is waiting for a missing updates to arrive in order to be applied.
2567
+
* @returns {Map<any, any> | undefined}
2568
+
*/
2569
+
get pendingDeleteSet() {
2570
+
const ret = wasm.ytransaction_pendingDeleteSet(this.__wbg_ptr);
2571
+
return ret;
2572
+
}
2573
+
/**
2574
+
* Returns a delete set containing information about
2575
+
* all blocks removed as part of a current transaction.
2576
+
* @returns {Map<any, any>}
2577
+
*/
2578
+
get deleteSet() {
2579
+
const ret = wasm.ytransaction_deleteSet(this.__wbg_ptr);
2580
+
return ret;
2581
+
}
2582
+
/**
2583
+
* @returns {any}
2584
+
*/
2585
+
get origin() {
2586
+
const ret = wasm.ytransaction_origin(this.__wbg_ptr);
2587
+
return ret;
2588
+
}
2589
+
/**
2590
+
* Given a logical identifier of the collection (obtained via `YText.id`, `YArray.id` etc.),
2591
+
* attempts to return an instance of that collection in the scope of current document.
2592
+
*
2593
+
* Returns `undefined` if an instance was not defined locally, haven't been integrated or
2594
+
* has been deleted.
2595
+
* @param {any} id
2596
+
* @returns {any}
2597
+
*/
2598
+
get(id) {
2599
+
const ret = wasm.ytransaction_get(this.__wbg_ptr, id);
2600
+
if (ret[2]) {
2601
+
throw takeFromExternrefTable0(ret[1]);
2602
+
}
2603
+
return takeFromExternrefTable0(ret[0]);
2604
+
}
2605
+
/**
2606
+
* Triggers a post-update series of operations without `free`ing the transaction. This includes
2607
+
* compaction and optimization of internal representation of updates, triggering events etc.
2608
+
* ywasm transactions are auto-committed when they are `free`d.
2609
+
*/
2610
+
commit() {
2611
+
const ret = wasm.ytransaction_commit(this.__wbg_ptr);
2612
+
if (ret[1]) {
2613
+
throw takeFromExternrefTable0(ret[0]);
2614
+
}
2615
+
}
2616
+
/**
2617
+
* Encodes a state vector of a given transaction document into its binary representation using
2618
+
* lib0 v1 encoding. State vector is a compact representation of updates performed on a given
2619
+
* document and can be used by `encode_state_as_update` on remote peer to generate a delta
2620
+
* update payload to synchronize changes between peers.
2621
+
*
2622
+
* Example:
2623
+
*
2624
+
* ```javascript
2625
+
* import YDoc from 'ywasm'
2626
+
*
2627
+
* /// document on machine A
2628
+
* const localDoc = new YDoc()
2629
+
* const localTxn = localDoc.beginTransaction()
2630
+
*
2631
+
* // document on machine B
2632
+
* const remoteDoc = new YDoc()
2633
+
* const remoteTxn = localDoc.beginTransaction()
2634
+
*
2635
+
* try {
2636
+
* const localSV = localTxn.stateVectorV1()
2637
+
* const remoteDelta = remoteTxn.diffV1(localSv)
2638
+
* localTxn.applyV1(remoteDelta)
2639
+
* } finally {
2640
+
* localTxn.free()
2641
+
* remoteTxn.free()
2642
+
* }
2643
+
* ```
2644
+
* @returns {Uint8Array}
2645
+
*/
2646
+
stateVectorV1() {
2647
+
const ret = wasm.ytransaction_stateVectorV1(this.__wbg_ptr);
2648
+
return ret;
2649
+
}
2650
+
/**
2651
+
* Encodes all updates that have happened since a given version `vector` into a compact delta
2652
+
* representation using lib0 v1 encoding. If `vector` parameter has not been provided, generated
2653
+
* delta payload will contain all changes of a current ywasm document, working effectively as
2654
+
* its state snapshot.
2655
+
*
2656
+
* Example:
2657
+
*
2658
+
* ```javascript
2659
+
* import YDoc from 'ywasm'
2660
+
*
2661
+
* /// document on machine A
2662
+
* const localDoc = new YDoc()
2663
+
* const localTxn = localDoc.beginTransaction()
2664
+
*
2665
+
* // document on machine B
2666
+
* const remoteDoc = new YDoc()
2667
+
* const remoteTxn = localDoc.beginTransaction()
2668
+
*
2669
+
* try {
2670
+
* const localSV = localTxn.stateVectorV1()
2671
+
* const remoteDelta = remoteTxn.diffV1(localSv)
2672
+
* localTxn.applyV1(remoteDelta)
2673
+
* } finally {
2674
+
* localTxn.free()
2675
+
* remoteTxn.free()
2676
+
* }
2677
+
* ```
2678
+
* @param {Uint8Array | null} [vector]
2679
+
* @returns {Uint8Array}
2680
+
*/
2681
+
diffV1(vector) {
2682
+
const ret = wasm.ytransaction_diffV1(
2683
+
this.__wbg_ptr,
2684
+
isLikeNone(vector) ? 0 : addToExternrefTable0(vector),
2685
+
);
2686
+
if (ret[2]) {
2687
+
throw takeFromExternrefTable0(ret[1]);
2688
+
}
2689
+
return takeFromExternrefTable0(ret[0]);
2690
+
}
2691
+
/**
2692
+
* Encodes all updates that have happened since a given version `vector` into a compact delta
2693
+
* representation using lib0 v1 encoding. If `vector` parameter has not been provided, generated
2694
+
* delta payload will contain all changes of a current ywasm document, working effectively as
2695
+
* its state snapshot.
2696
+
*
2697
+
* Example:
2698
+
*
2699
+
* ```javascript
2700
+
* import YDoc from 'ywasm'
2701
+
*
2702
+
* /// document on machine A
2703
+
* const localDoc = new YDoc()
2704
+
* const localTxn = localDoc.beginTransaction()
2705
+
*
2706
+
* // document on machine B
2707
+
* const remoteDoc = new YDoc()
2708
+
* const remoteTxn = localDoc.beginTransaction()
2709
+
*
2710
+
* try {
2711
+
* const localSV = localTxn.stateVectorV1()
2712
+
* const remoteDelta = remoteTxn.diffV2(localSv)
2713
+
* localTxn.applyV2(remoteDelta)
2714
+
* } finally {
2715
+
* localTxn.free()
2716
+
* remoteTxn.free()
2717
+
* }
2718
+
* ```
2719
+
* @param {Uint8Array | null} [vector]
2720
+
* @returns {Uint8Array}
2721
+
*/
2722
+
diffV2(vector) {
2723
+
const ret = wasm.ytransaction_diffV2(
2724
+
this.__wbg_ptr,
2725
+
isLikeNone(vector) ? 0 : addToExternrefTable0(vector),
2726
+
);
2727
+
if (ret[2]) {
2728
+
throw takeFromExternrefTable0(ret[1]);
2729
+
}
2730
+
return takeFromExternrefTable0(ret[0]);
2731
+
}
2732
+
/**
2733
+
* Applies delta update generated by the remote document replica to a current transaction's
2734
+
* document. This method assumes that a payload maintains lib0 v1 encoding format.
2735
+
*
2736
+
* Example:
2737
+
*
2738
+
* ```javascript
2739
+
* import YDoc from 'ywasm'
2740
+
*
2741
+
* /// document on machine A
2742
+
* const localDoc = new YDoc()
2743
+
* const localTxn = localDoc.beginTransaction()
2744
+
*
2745
+
* // document on machine B
2746
+
* const remoteDoc = new YDoc()
2747
+
* const remoteTxn = localDoc.beginTransaction()
2748
+
*
2749
+
* try {
2750
+
* const localSV = localTxn.stateVectorV1()
2751
+
* const remoteDelta = remoteTxn.diffV1(localSv)
2752
+
* localTxn.applyV1(remoteDelta)
2753
+
* } finally {
2754
+
* localTxn.free()
2755
+
* remoteTxn.free()
2756
+
* }
2757
+
* ```
2758
+
* @param {Uint8Array} diff
2759
+
*/
2760
+
applyV1(diff) {
2761
+
const ret = wasm.ytransaction_applyV1(this.__wbg_ptr, diff);
2762
+
if (ret[1]) {
2763
+
throw takeFromExternrefTable0(ret[0]);
2764
+
}
2765
+
}
2766
+
/**
2767
+
* Applies delta update generated by the remote document replica to a current transaction's
2768
+
* document. This method assumes that a payload maintains lib0 v2 encoding format.
2769
+
*
2770
+
* Example:
2771
+
*
2772
+
* ```javascript
2773
+
* import YDoc from 'ywasm'
2774
+
*
2775
+
* /// document on machine A
2776
+
* const localDoc = new YDoc()
2777
+
* const localTxn = localDoc.beginTransaction()
2778
+
*
2779
+
* // document on machine B
2780
+
* const remoteDoc = new YDoc()
2781
+
* const remoteTxn = localDoc.beginTransaction()
2782
+
*
2783
+
* try {
2784
+
* const localSV = localTxn.stateVectorV1()
2785
+
* const remoteDelta = remoteTxn.diffV2(localSv)
2786
+
* localTxn.applyV2(remoteDelta)
2787
+
* } finally {
2788
+
* localTxn.free()
2789
+
* remoteTxn.free()
2790
+
* }
2791
+
* ```
2792
+
* @param {Uint8Array} diff
2793
+
*/
2794
+
applyV2(diff) {
2795
+
const ret = wasm.ytransaction_applyV2(this.__wbg_ptr, diff);
2796
+
if (ret[1]) {
2797
+
throw takeFromExternrefTable0(ret[0]);
2798
+
}
2799
+
}
2800
+
/**
2801
+
* @returns {Uint8Array}
2802
+
*/
2803
+
encodeUpdate() {
2804
+
const ret = wasm.ytransaction_encodeUpdate(this.__wbg_ptr);
2805
+
return ret;
2806
+
}
2807
+
/**
2808
+
* @returns {Uint8Array}
2809
+
*/
2810
+
encodeUpdateV2() {
2811
+
const ret = wasm.ytransaction_encodeUpdateV2(this.__wbg_ptr);
2812
+
return ret;
2813
+
}
2814
+
/**
2815
+
* Force garbage collection of the deleted elements, regardless of a parent doc was created
2816
+
* with `gc` option turned on or off.
2817
+
*/
2818
+
gc() {
2819
+
const ret = wasm.ytransaction_gc(this.__wbg_ptr);
2820
+
if (ret[1]) {
2821
+
throw takeFromExternrefTable0(ret[0]);
2822
+
}
2823
+
}
2824
+
/**
2825
+
* Evaluates a JSON path expression (see: https://en.wikipedia.org/wiki/JSONPath) on
2826
+
* the document and returns an array of values matching that query.
2827
+
*
2828
+
* Currently, this method supports the following syntax:
2829
+
* - `$` - root object
2830
+
* - `@` - current object
2831
+
* - `.field` or `['field']` - member accessor
2832
+
* - `[1]` - array index (also supports negative indices)
2833
+
* - `.*` or `[*]` - wildcard (matches all members of an object or array)
2834
+
* - `..` - recursive descent (matches all descendants not only direct children)
2835
+
* - `[start:end:step]` - array slice operator (requires positive integer arguments)
2836
+
* - `['a', 'b', 'c']` - union operator (returns an array of values for each query)
2837
+
* - `[1, -1, 3]` - multiple indices operator (returns an array of values for each index)
2838
+
*
2839
+
* At the moment, JSON Path does not support filter predicates.
2840
+
* @param {string} json_path
2841
+
* @returns {Array<any>}
2842
+
*/
2843
+
selectAll(json_path) {
2844
+
const ptr0 = passStringToWasm0(
2845
+
json_path,
2846
+
wasm.__wbindgen_malloc,
2847
+
wasm.__wbindgen_realloc,
2848
+
);
2849
+
const len0 = WASM_VECTOR_LEN;
2850
+
const ret = wasm.ytransaction_selectAll(this.__wbg_ptr, ptr0, len0);
2851
+
if (ret[2]) {
2852
+
throw takeFromExternrefTable0(ret[1]);
2853
+
}
2854
+
return takeFromExternrefTable0(ret[0]);
2855
+
}
2856
+
/**
2857
+
* Evaluates a JSON path expression (see: https://en.wikipedia.org/wiki/JSONPath) on
2858
+
* the document and returns first value matching that query.
2859
+
*
2860
+
* Currently, this method supports the following syntax:
2861
+
* - `$` - root object
2862
+
* - `@` - current object
2863
+
* - `.field` or `['field']` - member accessor
2864
+
* - `[1]` - array index (also supports negative indices)
2865
+
* - `.*` or `[*]` - wildcard (matches all members of an object or array)
2866
+
* - `..` - recursive descent (matches all descendants not only direct children)
2867
+
* - `[start:end:step]` - array slice operator (requires positive integer arguments)
2868
+
* - `['a', 'b', 'c']` - union operator (returns an array of values for each query)
2869
+
* - `[1, -1, 3]` - multiple indices operator (returns an array of values for each index)
2870
+
*
2871
+
* At the moment, JSON Path does not support filter predicates.
2872
+
* @param {string} json_path
2873
+
* @returns {any}
2874
+
*/
2875
+
selectOne(json_path) {
2876
+
const ptr0 = passStringToWasm0(
2877
+
json_path,
2878
+
wasm.__wbindgen_malloc,
2879
+
wasm.__wbindgen_realloc,
2880
+
);
2881
+
const len0 = WASM_VECTOR_LEN;
2882
+
const ret = wasm.ytransaction_selectOne(this.__wbg_ptr, ptr0, len0);
2883
+
if (ret[2]) {
2884
+
throw takeFromExternrefTable0(ret[1]);
2885
+
}
2886
+
return takeFromExternrefTable0(ret[0]);
2887
+
}
2888
+
}
2889
+
module.exports.YTransaction = YTransaction;
2890
+
2891
+
const YUndoEventFinalization =
2892
+
typeof FinalizationRegistry === "undefined"
2893
+
? { register: () => {}, unregister: () => {} }
2894
+
: new FinalizationRegistry((ptr) =>
2895
+
wasm.__wbg_yundoevent_free(ptr >>> 0, 1),
2896
+
);
2897
+
2898
+
class YUndoEvent {
2899
+
static __wrap(ptr) {
2900
+
ptr = ptr >>> 0;
2901
+
const obj = Object.create(YUndoEvent.prototype);
2902
+
obj.__wbg_ptr = ptr;
2903
+
YUndoEventFinalization.register(obj, obj.__wbg_ptr, obj);
2904
+
return obj;
2905
+
}
2906
+
2907
+
__destroy_into_raw() {
2908
+
const ptr = this.__wbg_ptr;
2909
+
this.__wbg_ptr = 0;
2910
+
YUndoEventFinalization.unregister(this);
2911
+
return ptr;
2912
+
}
2913
+
2914
+
free() {
2915
+
const ptr = this.__destroy_into_raw();
2916
+
wasm.__wbg_yundoevent_free(ptr, 0);
2917
+
}
2918
+
/**
2919
+
* @returns {any}
2920
+
*/
2921
+
get origin() {
2922
+
const ret = wasm.yundoevent_origin(this.__wbg_ptr);
2923
+
return ret;
2924
+
}
2925
+
/**
2926
+
* @returns {any}
2927
+
*/
2928
+
get kind() {
2929
+
const ret = wasm.yundoevent_kind(this.__wbg_ptr);
2930
+
return ret;
2931
+
}
2932
+
/**
2933
+
* @returns {any}
2934
+
*/
2935
+
get meta() {
2936
+
const ret = wasm.yundoevent_meta(this.__wbg_ptr);
2937
+
return ret;
2938
+
}
2939
+
/**
2940
+
* @param {any} value
2941
+
*/
2942
+
set meta(value) {
2943
+
wasm.yundoevent_set_meta(this.__wbg_ptr, value);
2944
+
}
2945
+
}
2946
+
module.exports.YUndoEvent = YUndoEvent;
2947
+
2948
+
const YUndoManagerFinalization =
2949
+
typeof FinalizationRegistry === "undefined"
2950
+
? { register: () => {}, unregister: () => {} }
2951
+
: new FinalizationRegistry((ptr) =>
2952
+
wasm.__wbg_yundomanager_free(ptr >>> 0, 1),
2953
+
);
2954
+
2955
+
class YUndoManager {
2956
+
__destroy_into_raw() {
2957
+
const ptr = this.__wbg_ptr;
2958
+
this.__wbg_ptr = 0;
2959
+
YUndoManagerFinalization.unregister(this);
2960
+
return ptr;
2961
+
}
2962
+
2963
+
free() {
2964
+
const ptr = this.__destroy_into_raw();
2965
+
wasm.__wbg_yundomanager_free(ptr, 0);
2966
+
}
2967
+
/**
2968
+
* @param {YDoc} doc
2969
+
* @param {any} scope
2970
+
* @param {any} options
2971
+
*/
2972
+
constructor(doc, scope, options) {
2973
+
_assertClass(doc, YDoc);
2974
+
const ret = wasm.yundomanager_new(doc.__wbg_ptr, scope, options);
2975
+
if (ret[2]) {
2976
+
throw takeFromExternrefTable0(ret[1]);
2977
+
}
2978
+
this.__wbg_ptr = ret[0] >>> 0;
2979
+
YUndoManagerFinalization.register(this, this.__wbg_ptr, this);
2980
+
return this;
2981
+
}
2982
+
/**
2983
+
* @param {Array<any>} ytypes
2984
+
*/
2985
+
addToScope(ytypes) {
2986
+
const ret = wasm.yundomanager_addToScope(this.__wbg_ptr, ytypes);
2987
+
if (ret[1]) {
2988
+
throw takeFromExternrefTable0(ret[0]);
2989
+
}
2990
+
}
2991
+
/**
2992
+
* @param {any} origin
2993
+
*/
2994
+
addTrackedOrigin(origin) {
2995
+
wasm.yundomanager_addTrackedOrigin(this.__wbg_ptr, origin);
2996
+
}
2997
+
/**
2998
+
* @param {any} origin
2999
+
*/
3000
+
removeTrackedOrigin(origin) {
3001
+
wasm.yundomanager_removeTrackedOrigin(this.__wbg_ptr, origin);
3002
+
}
3003
+
clear() {
3004
+
wasm.yundomanager_clear(this.__wbg_ptr);
3005
+
}
3006
+
stopCapturing() {
3007
+
wasm.yundomanager_stopCapturing(this.__wbg_ptr);
3008
+
}
3009
+
undo() {
3010
+
const ret = wasm.yundomanager_undo(this.__wbg_ptr);
3011
+
if (ret[1]) {
3012
+
throw takeFromExternrefTable0(ret[0]);
3013
+
}
3014
+
}
3015
+
redo() {
3016
+
const ret = wasm.yundomanager_redo(this.__wbg_ptr);
3017
+
if (ret[1]) {
3018
+
throw takeFromExternrefTable0(ret[0]);
3019
+
}
3020
+
}
3021
+
/**
3022
+
* @returns {boolean}
3023
+
*/
3024
+
get canUndo() {
3025
+
const ret = wasm.yundomanager_canUndo(this.__wbg_ptr);
3026
+
return ret !== 0;
3027
+
}
3028
+
/**
3029
+
* @returns {boolean}
3030
+
*/
3031
+
get canRedo() {
3032
+
const ret = wasm.yundomanager_canRedo(this.__wbg_ptr);
3033
+
return ret !== 0;
3034
+
}
3035
+
/**
3036
+
* @param {string} event
3037
+
* @param {Function} callback
3038
+
*/
3039
+
on(event, callback) {
3040
+
const ptr0 = passStringToWasm0(
3041
+
event,
3042
+
wasm.__wbindgen_malloc,
3043
+
wasm.__wbindgen_realloc,
3044
+
);
3045
+
const len0 = WASM_VECTOR_LEN;
3046
+
const ret = wasm.yundomanager_on(this.__wbg_ptr, ptr0, len0, callback);
3047
+
if (ret[1]) {
3048
+
throw takeFromExternrefTable0(ret[0]);
3049
+
}
3050
+
}
3051
+
/**
3052
+
* @param {string} event
3053
+
* @param {Function} callback
3054
+
* @returns {boolean}
3055
+
*/
3056
+
off(event, callback) {
3057
+
const ptr0 = passStringToWasm0(
3058
+
event,
3059
+
wasm.__wbindgen_malloc,
3060
+
wasm.__wbindgen_realloc,
3061
+
);
3062
+
const len0 = WASM_VECTOR_LEN;
3063
+
const ret = wasm.yundomanager_off(this.__wbg_ptr, ptr0, len0, callback);
3064
+
if (ret[2]) {
3065
+
throw takeFromExternrefTable0(ret[1]);
3066
+
}
3067
+
return ret[0] !== 0;
3068
+
}
3069
+
}
3070
+
module.exports.YUndoManager = YUndoManager;
3071
+
3072
+
const YWeakLinkFinalization =
3073
+
typeof FinalizationRegistry === "undefined"
3074
+
? { register: () => {}, unregister: () => {} }
3075
+
: new FinalizationRegistry((ptr) =>
3076
+
wasm.__wbg_yweaklink_free(ptr >>> 0, 1),
3077
+
);
3078
+
3079
+
class YWeakLink {
3080
+
static __wrap(ptr) {
3081
+
ptr = ptr >>> 0;
3082
+
const obj = Object.create(YWeakLink.prototype);
3083
+
obj.__wbg_ptr = ptr;
3084
+
YWeakLinkFinalization.register(obj, obj.__wbg_ptr, obj);
3085
+
return obj;
3086
+
}
3087
+
3088
+
__destroy_into_raw() {
3089
+
const ptr = this.__wbg_ptr;
3090
+
this.__wbg_ptr = 0;
3091
+
YWeakLinkFinalization.unregister(this);
3092
+
return ptr;
3093
+
}
3094
+
3095
+
free() {
3096
+
const ptr = this.__destroy_into_raw();
3097
+
wasm.__wbg_yweaklink_free(ptr, 0);
3098
+
}
3099
+
/**
3100
+
* Returns true if this is a preliminary instance of `YWeakLink`.
3101
+
*
3102
+
* Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.
3103
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
3104
+
* document store and cannot be nested again: attempt to do so will result in an exception.
3105
+
* @returns {boolean}
3106
+
*/
3107
+
get prelim() {
3108
+
const ret = wasm.yweaklink_prelim(this.__wbg_ptr);
3109
+
return ret !== 0;
3110
+
}
3111
+
/**
3112
+
* @returns {number}
3113
+
*/
3114
+
get type() {
3115
+
const ret = wasm.yweaklink_type(this.__wbg_ptr);
3116
+
return ret;
3117
+
}
3118
+
/**
3119
+
* Gets unique logical identifier of this type, shared across peers collaborating on the same
3120
+
* document.
3121
+
* @returns {any}
3122
+
*/
3123
+
get id() {
3124
+
const ret = wasm.yweaklink_id(this.__wbg_ptr);
3125
+
if (ret[2]) {
3126
+
throw takeFromExternrefTable0(ret[1]);
3127
+
}
3128
+
return takeFromExternrefTable0(ret[0]);
3129
+
}
3130
+
/**
3131
+
* Checks if current YWeakLink reference is alive and has not been deleted by its parent collection.
3132
+
* This method only works on already integrated shared types and will return false is current
3133
+
* type is preliminary (has not been integrated into document).
3134
+
* @param {YTransaction} txn
3135
+
* @returns {boolean}
3136
+
*/
3137
+
alive(txn) {
3138
+
_assertClass(txn, YTransaction);
3139
+
const ret = wasm.yweaklink_alive(this.__wbg_ptr, txn.__wbg_ptr);
3140
+
return ret !== 0;
3141
+
}
3142
+
/**
3143
+
* @param {YTransaction | undefined} txn
3144
+
* @returns {any}
3145
+
*/
3146
+
deref(txn) {
3147
+
const ret = wasm.yweaklink_deref(this.__wbg_ptr, txn);
3148
+
if (ret[2]) {
3149
+
throw takeFromExternrefTable0(ret[1]);
3150
+
}
3151
+
return takeFromExternrefTable0(ret[0]);
3152
+
}
3153
+
/**
3154
+
* @param {YTransaction | undefined} txn
3155
+
* @returns {Array<any>}
3156
+
*/
3157
+
unquote(txn) {
3158
+
const ret = wasm.yweaklink_unquote(this.__wbg_ptr, txn);
3159
+
if (ret[2]) {
3160
+
throw takeFromExternrefTable0(ret[1]);
3161
+
}
3162
+
return takeFromExternrefTable0(ret[0]);
3163
+
}
3164
+
/**
3165
+
* @param {YTransaction | undefined} txn
3166
+
* @returns {string}
3167
+
*/
3168
+
toString(txn) {
3169
+
let deferred2_0;
3170
+
let deferred2_1;
3171
+
try {
3172
+
const ret = wasm.yweaklink_toString(this.__wbg_ptr, txn);
3173
+
var ptr1 = ret[0];
3174
+
var len1 = ret[1];
3175
+
if (ret[3]) {
3176
+
ptr1 = 0;
3177
+
len1 = 0;
3178
+
throw takeFromExternrefTable0(ret[2]);
3179
+
}
3180
+
deferred2_0 = ptr1;
3181
+
deferred2_1 = len1;
3182
+
return getStringFromWasm0(ptr1, len1);
3183
+
} finally {
3184
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
3185
+
}
3186
+
}
3187
+
/**
3188
+
* Subscribes to all operations happening over this instance of `YMap`. All changes are
3189
+
* batched and eventually triggered during transaction commit phase.
3190
+
* @param {Function} callback
3191
+
*/
3192
+
observe(callback) {
3193
+
const ret = wasm.yweaklink_observe(this.__wbg_ptr, callback);
3194
+
if (ret[1]) {
3195
+
throw takeFromExternrefTable0(ret[0]);
3196
+
}
3197
+
}
3198
+
/**
3199
+
* Unsubscribes a callback previously subscribed with `observe` method.
3200
+
* @param {Function} callback
3201
+
* @returns {boolean}
3202
+
*/
3203
+
unobserve(callback) {
3204
+
const ret = wasm.yweaklink_unobserve(this.__wbg_ptr, callback);
3205
+
if (ret[2]) {
3206
+
throw takeFromExternrefTable0(ret[1]);
3207
+
}
3208
+
return ret[0] !== 0;
3209
+
}
3210
+
/**
3211
+
* Subscribes to all operations happening over this Y shared type, as well as events in
3212
+
* shared types stored within this one. All changes are batched and eventually triggered
3213
+
* during transaction commit phase.
3214
+
* @param {Function} callback
3215
+
*/
3216
+
observeDeep(callback) {
3217
+
const ret = wasm.yweaklink_observeDeep(this.__wbg_ptr, callback);
3218
+
if (ret[1]) {
3219
+
throw takeFromExternrefTable0(ret[0]);
3220
+
}
3221
+
}
3222
+
/**
3223
+
* Unsubscribes a callback previously subscribed with `observeDeep` method.
3224
+
* @param {Function} callback
3225
+
* @returns {boolean}
3226
+
*/
3227
+
unobserveDeep(callback) {
3228
+
const ret = wasm.yweaklink_unobserveDeep(this.__wbg_ptr, callback);
3229
+
if (ret[2]) {
3230
+
throw takeFromExternrefTable0(ret[1]);
3231
+
}
3232
+
return ret[0] !== 0;
3233
+
}
3234
+
}
3235
+
module.exports.YWeakLink = YWeakLink;
3236
+
3237
+
const YWeakLinkEventFinalization =
3238
+
typeof FinalizationRegistry === "undefined"
3239
+
? { register: () => {}, unregister: () => {} }
3240
+
: new FinalizationRegistry((ptr) =>
3241
+
wasm.__wbg_yweaklinkevent_free(ptr >>> 0, 1),
3242
+
);
3243
+
/**
3244
+
* Event generated by `YXmlElement.observe` method. Emitted during transaction commit phase.
3245
+
*/
3246
+
class YWeakLinkEvent {
3247
+
static __wrap(ptr) {
3248
+
ptr = ptr >>> 0;
3249
+
const obj = Object.create(YWeakLinkEvent.prototype);
3250
+
obj.__wbg_ptr = ptr;
3251
+
YWeakLinkEventFinalization.register(obj, obj.__wbg_ptr, obj);
3252
+
return obj;
3253
+
}
3254
+
3255
+
__destroy_into_raw() {
3256
+
const ptr = this.__wbg_ptr;
3257
+
this.__wbg_ptr = 0;
3258
+
YWeakLinkEventFinalization.unregister(this);
3259
+
return ptr;
3260
+
}
3261
+
3262
+
free() {
3263
+
const ptr = this.__destroy_into_raw();
3264
+
wasm.__wbg_yweaklinkevent_free(ptr, 0);
3265
+
}
3266
+
/**
3267
+
* @returns {any}
3268
+
*/
3269
+
get origin() {
3270
+
const ret = wasm.yweaklinkevent_origin(this.__wbg_ptr);
3271
+
return ret;
3272
+
}
3273
+
/**
3274
+
* Returns a current shared type instance, that current event changes refer to.
3275
+
* @returns {any}
3276
+
*/
3277
+
get target() {
3278
+
const ret = wasm.yweaklinkevent_target(this.__wbg_ptr);
3279
+
return ret;
3280
+
}
3281
+
/**
3282
+
* Returns an array of keys and indexes creating a path from root type down to current instance
3283
+
* of shared type (accessible via `target` getter).
3284
+
* @returns {any}
3285
+
*/
3286
+
path() {
3287
+
const ret = wasm.yweaklinkevent_path(this.__wbg_ptr);
3288
+
return ret;
3289
+
}
3290
+
}
3291
+
module.exports.YWeakLinkEvent = YWeakLinkEvent;
3292
+
3293
+
const YXmlElementFinalization =
3294
+
typeof FinalizationRegistry === "undefined"
3295
+
? { register: () => {}, unregister: () => {} }
3296
+
: new FinalizationRegistry((ptr) =>
3297
+
wasm.__wbg_yxmlelement_free(ptr >>> 0, 1),
3298
+
);
3299
+
/**
3300
+
* XML element data type. It represents an XML node, which can contain key-value attributes
3301
+
* (interpreted as strings) as well as other nested XML elements or rich text (represented by
3302
+
* `YXmlText` type).
3303
+
*
3304
+
* In terms of conflict resolution, `YXmlElement` uses following rules:
3305
+
*
3306
+
* - Attribute updates use logical last-write-wins principle, meaning the past updates are
3307
+
* automatically overridden and discarded by newer ones, while concurrent updates made by
3308
+
* different peers are resolved into a single value using document id seniority to establish
3309
+
* an order.
3310
+
* - Child node insertion uses sequencing rules from other Yrs collections - elements are inserted
3311
+
* using interleave-resistant algorithm, where order of concurrent inserts at the same index
3312
+
* is established using peer's document id seniority.
3313
+
*/
3314
+
class YXmlElement {
3315
+
static __wrap(ptr) {
3316
+
ptr = ptr >>> 0;
3317
+
const obj = Object.create(YXmlElement.prototype);
3318
+
obj.__wbg_ptr = ptr;
3319
+
YXmlElementFinalization.register(obj, obj.__wbg_ptr, obj);
3320
+
return obj;
3321
+
}
3322
+
3323
+
__destroy_into_raw() {
3324
+
const ptr = this.__wbg_ptr;
3325
+
this.__wbg_ptr = 0;
3326
+
YXmlElementFinalization.unregister(this);
3327
+
return ptr;
3328
+
}
3329
+
3330
+
free() {
3331
+
const ptr = this.__destroy_into_raw();
3332
+
wasm.__wbg_yxmlelement_free(ptr, 0);
3333
+
}
3334
+
/**
3335
+
* @param {string} name
3336
+
* @param {any} attributes
3337
+
* @param {any} children
3338
+
*/
3339
+
constructor(name, attributes, children) {
3340
+
const ptr0 = passStringToWasm0(
3341
+
name,
3342
+
wasm.__wbindgen_malloc,
3343
+
wasm.__wbindgen_realloc,
3344
+
);
3345
+
const len0 = WASM_VECTOR_LEN;
3346
+
const ret = wasm.yxmlelement_new(ptr0, len0, attributes, children);
3347
+
if (ret[2]) {
3348
+
throw takeFromExternrefTable0(ret[1]);
3349
+
}
3350
+
this.__wbg_ptr = ret[0] >>> 0;
3351
+
YXmlElementFinalization.register(this, this.__wbg_ptr, this);
3352
+
return this;
3353
+
}
3354
+
/**
3355
+
* @returns {number}
3356
+
*/
3357
+
get type() {
3358
+
const ret = wasm.yxmlelement_type(this.__wbg_ptr);
3359
+
return ret;
3360
+
}
3361
+
/**
3362
+
* Gets unique logical identifier of this type, shared across peers collaborating on the same
3363
+
* document.
3364
+
* @returns {any}
3365
+
*/
3366
+
get id() {
3367
+
const ret = wasm.yxmlelement_id(this.__wbg_ptr);
3368
+
if (ret[2]) {
3369
+
throw takeFromExternrefTable0(ret[1]);
3370
+
}
3371
+
return takeFromExternrefTable0(ret[0]);
3372
+
}
3373
+
/**
3374
+
* Returns true if this is a preliminary instance of `YXmlElement`.
3375
+
*
3376
+
* Preliminary instances can be nested into other shared data types.
3377
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
3378
+
* document store and cannot be nested again: attempt to do so will result in an exception.
3379
+
* @returns {boolean}
3380
+
*/
3381
+
get prelim() {
3382
+
const ret = wasm.yxmlelement_prelim(this.__wbg_ptr);
3383
+
return ret !== 0;
3384
+
}
3385
+
/**
3386
+
* Checks if current shared type reference is alive and has not been deleted by its parent collection.
3387
+
* This method only works on already integrated shared types and will return false is current
3388
+
* type is preliminary (has not been integrated into document).
3389
+
* @param {YTransaction} txn
3390
+
* @returns {boolean}
3391
+
*/
3392
+
alive(txn) {
3393
+
_assertClass(txn, YTransaction);
3394
+
const ret = wasm.yxmlelement_alive(this.__wbg_ptr, txn.__wbg_ptr);
3395
+
return ret !== 0;
3396
+
}
3397
+
/**
3398
+
* Returns a tag name of this XML node.
3399
+
* @param {YTransaction | undefined} txn
3400
+
* @returns {string}
3401
+
*/
3402
+
name(txn) {
3403
+
let deferred2_0;
3404
+
let deferred2_1;
3405
+
try {
3406
+
const ret = wasm.yxmlelement_name(this.__wbg_ptr, txn);
3407
+
var ptr1 = ret[0];
3408
+
var len1 = ret[1];
3409
+
if (ret[3]) {
3410
+
ptr1 = 0;
3411
+
len1 = 0;
3412
+
throw takeFromExternrefTable0(ret[2]);
3413
+
}
3414
+
deferred2_0 = ptr1;
3415
+
deferred2_1 = len1;
3416
+
return getStringFromWasm0(ptr1, len1);
3417
+
} finally {
3418
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
3419
+
}
3420
+
}
3421
+
/**
3422
+
* Returns a number of child XML nodes stored within this `YXMlElement` instance.
3423
+
* @param {YTransaction | undefined} txn
3424
+
* @returns {number}
3425
+
*/
3426
+
length(txn) {
3427
+
const ret = wasm.yxmlelement_length(this.__wbg_ptr, txn);
3428
+
if (ret[2]) {
3429
+
throw takeFromExternrefTable0(ret[1]);
3430
+
}
3431
+
return ret[0] >>> 0;
3432
+
}
3433
+
/**
3434
+
* @param {number} index
3435
+
* @param {any} xml_node
3436
+
* @param {YTransaction | undefined} txn
3437
+
*/
3438
+
insert(index, xml_node, txn) {
3439
+
const ret = wasm.yxmlelement_insert(this.__wbg_ptr, index, xml_node, txn);
3440
+
if (ret[1]) {
3441
+
throw takeFromExternrefTable0(ret[0]);
3442
+
}
3443
+
}
3444
+
/**
3445
+
* @param {any} xml_node
3446
+
* @param {YTransaction | undefined} txn
3447
+
*/
3448
+
push(xml_node, txn) {
3449
+
const ret = wasm.yxmlelement_push(this.__wbg_ptr, xml_node, txn);
3450
+
if (ret[1]) {
3451
+
throw takeFromExternrefTable0(ret[0]);
3452
+
}
3453
+
}
3454
+
/**
3455
+
* @param {number} index
3456
+
* @param {number | null | undefined} length
3457
+
* @param {YTransaction | undefined} txn
3458
+
*/
3459
+
delete(index, length, txn) {
3460
+
const ret = wasm.yxmlelement_delete(
3461
+
this.__wbg_ptr,
3462
+
index,
3463
+
isLikeNone(length) ? 0x100000001 : length >>> 0,
3464
+
txn,
3465
+
);
3466
+
if (ret[1]) {
3467
+
throw takeFromExternrefTable0(ret[0]);
3468
+
}
3469
+
}
3470
+
/**
3471
+
* Returns a first child of this XML node.
3472
+
* It can be either `YXmlElement`, `YXmlText` or `undefined` if current node has not children.
3473
+
* @param {YTransaction | undefined} txn
3474
+
* @returns {any}
3475
+
*/
3476
+
firstChild(txn) {
3477
+
const ret = wasm.yxmlelement_firstChild(this.__wbg_ptr, txn);
3478
+
if (ret[2]) {
3479
+
throw takeFromExternrefTable0(ret[1]);
3480
+
}
3481
+
return takeFromExternrefTable0(ret[0]);
3482
+
}
3483
+
/**
3484
+
* Returns a next XML sibling node of this XMl node.
3485
+
* It can be either `YXmlElement`, `YXmlText` or `undefined` if current node is a last child of
3486
+
* parent XML node.
3487
+
* @param {YTransaction | undefined} txn
3488
+
* @returns {any}
3489
+
*/
3490
+
nextSibling(txn) {
3491
+
const ret = wasm.yxmlelement_nextSibling(this.__wbg_ptr, txn);
3492
+
if (ret[2]) {
3493
+
throw takeFromExternrefTable0(ret[1]);
3494
+
}
3495
+
return takeFromExternrefTable0(ret[0]);
3496
+
}
3497
+
/**
3498
+
* Returns a previous XML sibling node of this XMl node.
3499
+
* It can be either `YXmlElement`, `YXmlText` or `undefined` if current node is a first child
3500
+
* of parent XML node.
3501
+
* @param {YTransaction | undefined} txn
3502
+
* @returns {any}
3503
+
*/
3504
+
prevSibling(txn) {
3505
+
const ret = wasm.yxmlelement_prevSibling(this.__wbg_ptr, txn);
3506
+
if (ret[2]) {
3507
+
throw takeFromExternrefTable0(ret[1]);
3508
+
}
3509
+
return takeFromExternrefTable0(ret[0]);
3510
+
}
3511
+
/**
3512
+
* Returns a parent `YXmlElement` node or `undefined` if current node has no parent assigned.
3513
+
* @param {YTransaction | undefined} txn
3514
+
* @returns {any}
3515
+
*/
3516
+
parent(txn) {
3517
+
const ret = wasm.yxmlelement_parent(this.__wbg_ptr, txn);
3518
+
if (ret[2]) {
3519
+
throw takeFromExternrefTable0(ret[1]);
3520
+
}
3521
+
return takeFromExternrefTable0(ret[0]);
3522
+
}
3523
+
/**
3524
+
* Returns a string representation of this XML node.
3525
+
* @param {YTransaction | undefined} txn
3526
+
* @returns {string}
3527
+
*/
3528
+
toString(txn) {
3529
+
let deferred2_0;
3530
+
let deferred2_1;
3531
+
try {
3532
+
const ret = wasm.yxmlelement_toString(this.__wbg_ptr, txn);
3533
+
var ptr1 = ret[0];
3534
+
var len1 = ret[1];
3535
+
if (ret[3]) {
3536
+
ptr1 = 0;
3537
+
len1 = 0;
3538
+
throw takeFromExternrefTable0(ret[2]);
3539
+
}
3540
+
deferred2_0 = ptr1;
3541
+
deferred2_1 = len1;
3542
+
return getStringFromWasm0(ptr1, len1);
3543
+
} finally {
3544
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
3545
+
}
3546
+
}
3547
+
/**
3548
+
* Sets a `name` and `value` as new attribute for this XML node. If an attribute with the same
3549
+
* `name` already existed on that node, its value with be overridden with a provided one.
3550
+
* This method accepts any JavaScript value, not just strings.
3551
+
* @param {string} name
3552
+
* @param {any} value
3553
+
* @param {YTransaction | undefined} txn
3554
+
*/
3555
+
setAttribute(name, value, txn) {
3556
+
const ptr0 = passStringToWasm0(
3557
+
name,
3558
+
wasm.__wbindgen_malloc,
3559
+
wasm.__wbindgen_realloc,
3560
+
);
3561
+
const len0 = WASM_VECTOR_LEN;
3562
+
const ret = wasm.yxmlelement_setAttribute(
3563
+
this.__wbg_ptr,
3564
+
ptr0,
3565
+
len0,
3566
+
value,
3567
+
txn,
3568
+
);
3569
+
if (ret[1]) {
3570
+
throw takeFromExternrefTable0(ret[0]);
3571
+
}
3572
+
}
3573
+
/**
3574
+
* Returns a value of an attribute given its `name` as any JS value. If no attribute with such name existed,
3575
+
* `undefined` will be returned.
3576
+
* @param {string} name
3577
+
* @param {YTransaction | undefined} txn
3578
+
* @returns {any}
3579
+
*/
3580
+
getAttribute(name, txn) {
3581
+
const ptr0 = passStringToWasm0(
3582
+
name,
3583
+
wasm.__wbindgen_malloc,
3584
+
wasm.__wbindgen_realloc,
3585
+
);
3586
+
const len0 = WASM_VECTOR_LEN;
3587
+
const ret = wasm.yxmlelement_getAttribute(this.__wbg_ptr, ptr0, len0, txn);
3588
+
if (ret[2]) {
3589
+
throw takeFromExternrefTable0(ret[1]);
3590
+
}
3591
+
return takeFromExternrefTable0(ret[0]);
3592
+
}
3593
+
/**
3594
+
* Removes an attribute from this XML node, given its `name`.
3595
+
* @param {string} name
3596
+
* @param {YTransaction | undefined} txn
3597
+
*/
3598
+
removeAttribute(name, txn) {
3599
+
const ptr0 = passStringToWasm0(
3600
+
name,
3601
+
wasm.__wbindgen_malloc,
3602
+
wasm.__wbindgen_realloc,
3603
+
);
3604
+
const len0 = WASM_VECTOR_LEN;
3605
+
const ret = wasm.yxmlelement_removeAttribute(
3606
+
this.__wbg_ptr,
3607
+
ptr0,
3608
+
len0,
3609
+
txn,
3610
+
);
3611
+
if (ret[1]) {
3612
+
throw takeFromExternrefTable0(ret[0]);
3613
+
}
3614
+
}
3615
+
/**
3616
+
* Returns an iterator that enables to traverse over all attributes of this XML node in
3617
+
* unspecified order. This method returns attribute values as their original JS values,
3618
+
* not just as strings.
3619
+
* @param {YTransaction | undefined} txn
3620
+
* @returns {any}
3621
+
*/
3622
+
attributes(txn) {
3623
+
const ret = wasm.yxmlelement_attributes(this.__wbg_ptr, txn);
3624
+
if (ret[2]) {
3625
+
throw takeFromExternrefTable0(ret[1]);
3626
+
}
3627
+
return takeFromExternrefTable0(ret[0]);
3628
+
}
3629
+
/**
3630
+
* Returns an iterator that enables a deep traversal of this XML node - starting from first
3631
+
* child over this XML node successors using depth-first strategy.
3632
+
* @param {YTransaction | undefined} txn
3633
+
* @returns {Array<any>}
3634
+
*/
3635
+
treeWalker(txn) {
3636
+
const ret = wasm.yxmlelement_treeWalker(this.__wbg_ptr, txn);
3637
+
if (ret[2]) {
3638
+
throw takeFromExternrefTable0(ret[1]);
3639
+
}
3640
+
return takeFromExternrefTable0(ret[0]);
3641
+
}
3642
+
/**
3643
+
* Subscribes to all operations happening over this instance of `YXmlElement`. All changes are
3644
+
* batched and eventually triggered during transaction commit phase.
3645
+
* @param {Function} callback
3646
+
*/
3647
+
observe(callback) {
3648
+
const ret = wasm.yxmlelement_observe(this.__wbg_ptr, callback);
3649
+
if (ret[1]) {
3650
+
throw takeFromExternrefTable0(ret[0]);
3651
+
}
3652
+
}
3653
+
/**
3654
+
* Unsubscribes a callback previously subscribed with `observe` method.
3655
+
* @param {Function} callback
3656
+
* @returns {boolean}
3657
+
*/
3658
+
unobserve(callback) {
3659
+
const ret = wasm.yxmlelement_unobserve(this.__wbg_ptr, callback);
3660
+
if (ret[2]) {
3661
+
throw takeFromExternrefTable0(ret[1]);
3662
+
}
3663
+
return ret[0] !== 0;
3664
+
}
3665
+
/**
3666
+
* Subscribes to all operations happening over this Y shared type, as well as events in
3667
+
* shared types stored within this one. All changes are batched and eventually triggered
3668
+
* during transaction commit phase.
3669
+
* @param {Function} callback
3670
+
*/
3671
+
observeDeep(callback) {
3672
+
const ret = wasm.yxmlelement_observeDeep(this.__wbg_ptr, callback);
3673
+
if (ret[1]) {
3674
+
throw takeFromExternrefTable0(ret[0]);
3675
+
}
3676
+
}
3677
+
/**
3678
+
* Unsubscribes a callback previously subscribed with `observeDeep` method.
3679
+
* @param {Function} callback
3680
+
* @returns {boolean}
3681
+
*/
3682
+
unobserveDeep(callback) {
3683
+
const ret = wasm.yxmlelement_unobserveDeep(this.__wbg_ptr, callback);
3684
+
if (ret[2]) {
3685
+
throw takeFromExternrefTable0(ret[1]);
3686
+
}
3687
+
return ret[0] !== 0;
3688
+
}
3689
+
}
3690
+
module.exports.YXmlElement = YXmlElement;
3691
+
3692
+
const YXmlEventFinalization =
3693
+
typeof FinalizationRegistry === "undefined"
3694
+
? { register: () => {}, unregister: () => {} }
3695
+
: new FinalizationRegistry((ptr) =>
3696
+
wasm.__wbg_yxmlevent_free(ptr >>> 0, 1),
3697
+
);
3698
+
/**
3699
+
* Event generated by `YXmlElement.observe` method. Emitted during transaction commit phase.
3700
+
*/
3701
+
class YXmlEvent {
3702
+
static __wrap(ptr) {
3703
+
ptr = ptr >>> 0;
3704
+
const obj = Object.create(YXmlEvent.prototype);
3705
+
obj.__wbg_ptr = ptr;
3706
+
YXmlEventFinalization.register(obj, obj.__wbg_ptr, obj);
3707
+
return obj;
3708
+
}
3709
+
3710
+
__destroy_into_raw() {
3711
+
const ptr = this.__wbg_ptr;
3712
+
this.__wbg_ptr = 0;
3713
+
YXmlEventFinalization.unregister(this);
3714
+
return ptr;
3715
+
}
3716
+
3717
+
free() {
3718
+
const ptr = this.__destroy_into_raw();
3719
+
wasm.__wbg_yxmlevent_free(ptr, 0);
3720
+
}
3721
+
/**
3722
+
* Returns an array of keys and indexes creating a path from root type down to current instance
3723
+
* of shared type (accessible via `target` getter).
3724
+
* @returns {any}
3725
+
*/
3726
+
path() {
3727
+
const ret = wasm.yxmlevent_path(this.__wbg_ptr);
3728
+
return ret;
3729
+
}
3730
+
/**
3731
+
* Returns a current shared type instance, that current event changes refer to.
3732
+
* @returns {any}
3733
+
*/
3734
+
get target() {
3735
+
const ret = wasm.yxmlevent_target(this.__wbg_ptr);
3736
+
return ret;
3737
+
}
3738
+
/**
3739
+
* @returns {any}
3740
+
*/
3741
+
get origin() {
3742
+
const ret = wasm.yxmlevent_origin(this.__wbg_ptr);
3743
+
return ret;
3744
+
}
3745
+
/**
3746
+
* Returns a list of attribute changes made over corresponding `YXmlText` collection within
3747
+
* bounds of current transaction. These changes follow a format:
3748
+
*
3749
+
* - { action: 'add'|'update'|'delete', oldValue: string|undefined, newValue: string|undefined }
3750
+
* @returns {any}
3751
+
*/
3752
+
get keys() {
3753
+
const ret = wasm.yxmlevent_keys(this.__wbg_ptr);
3754
+
if (ret[2]) {
3755
+
throw takeFromExternrefTable0(ret[1]);
3756
+
}
3757
+
return takeFromExternrefTable0(ret[0]);
3758
+
}
3759
+
/**
3760
+
* Returns a list of XML child node changes made over corresponding `YXmlElement` collection
3761
+
* within bounds of current transaction. These changes follow a format:
3762
+
*
3763
+
* - { insert: (YXmlText|YXmlElement)[] }
3764
+
* - { delete: number }
3765
+
* - { retain: number }
3766
+
* @returns {any}
3767
+
*/
3768
+
get delta() {
3769
+
const ret = wasm.yxmlevent_delta(this.__wbg_ptr);
3770
+
return ret;
3771
+
}
3772
+
}
3773
+
module.exports.YXmlEvent = YXmlEvent;
3774
+
3775
+
const YXmlFragmentFinalization =
3776
+
typeof FinalizationRegistry === "undefined"
3777
+
? { register: () => {}, unregister: () => {} }
3778
+
: new FinalizationRegistry((ptr) =>
3779
+
wasm.__wbg_yxmlfragment_free(ptr >>> 0, 1),
3780
+
);
3781
+
/**
3782
+
* Represents a list of `YXmlElement` and `YXmlText` types.
3783
+
* A `YXmlFragment` is similar to a `YXmlElement`, but it does not have a
3784
+
* nodeName and it does not have attributes. Though it can be bound to a DOM
3785
+
* element - in this case the attributes and the nodeName are not shared
3786
+
*/
3787
+
class YXmlFragment {
3788
+
static __wrap(ptr) {
3789
+
ptr = ptr >>> 0;
3790
+
const obj = Object.create(YXmlFragment.prototype);
3791
+
obj.__wbg_ptr = ptr;
3792
+
YXmlFragmentFinalization.register(obj, obj.__wbg_ptr, obj);
3793
+
return obj;
3794
+
}
3795
+
3796
+
__destroy_into_raw() {
3797
+
const ptr = this.__wbg_ptr;
3798
+
this.__wbg_ptr = 0;
3799
+
YXmlFragmentFinalization.unregister(this);
3800
+
return ptr;
3801
+
}
3802
+
3803
+
free() {
3804
+
const ptr = this.__destroy_into_raw();
3805
+
wasm.__wbg_yxmlfragment_free(ptr, 0);
3806
+
}
3807
+
/**
3808
+
* @param {any[]} children
3809
+
*/
3810
+
constructor(children) {
3811
+
const ptr0 = passArrayJsValueToWasm0(children, wasm.__wbindgen_malloc);
3812
+
const len0 = WASM_VECTOR_LEN;
3813
+
const ret = wasm.yxmlfragment_new(ptr0, len0);
3814
+
if (ret[2]) {
3815
+
throw takeFromExternrefTable0(ret[1]);
3816
+
}
3817
+
this.__wbg_ptr = ret[0] >>> 0;
3818
+
YXmlFragmentFinalization.register(this, this.__wbg_ptr, this);
3819
+
return this;
3820
+
}
3821
+
/**
3822
+
* @returns {number}
3823
+
*/
3824
+
get type() {
3825
+
const ret = wasm.yxmlfragment_type(this.__wbg_ptr);
3826
+
return ret;
3827
+
}
3828
+
/**
3829
+
* Gets unique logical identifier of this type, shared across peers collaborating on the same
3830
+
* document.
3831
+
* @returns {any}
3832
+
*/
3833
+
get id() {
3834
+
const ret = wasm.yxmlfragment_id(this.__wbg_ptr);
3835
+
if (ret[2]) {
3836
+
throw takeFromExternrefTable0(ret[1]);
3837
+
}
3838
+
return takeFromExternrefTable0(ret[0]);
3839
+
}
3840
+
/**
3841
+
* Returns true if this is a preliminary instance of `YXmlFragment`.
3842
+
*
3843
+
* Preliminary instances can be nested into other shared data types.
3844
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
3845
+
* document store and cannot be nested again: attempt to do so will result in an exception.
3846
+
* @returns {boolean}
3847
+
*/
3848
+
get prelim() {
3849
+
const ret = wasm.yxmlfragment_prelim(this.__wbg_ptr);
3850
+
return ret !== 0;
3851
+
}
3852
+
/**
3853
+
* Checks if current shared type reference is alive and has not been deleted by its parent collection.
3854
+
* This method only works on already integrated shared types and will return false is current
3855
+
* type is preliminary (has not been integrated into document).
3856
+
* @param {YTransaction} txn
3857
+
* @returns {boolean}
3858
+
*/
3859
+
alive(txn) {
3860
+
_assertClass(txn, YTransaction);
3861
+
const ret = wasm.yxmlfragment_alive(this.__wbg_ptr, txn.__wbg_ptr);
3862
+
return ret !== 0;
3863
+
}
3864
+
/**
3865
+
* Returns a number of child XML nodes stored within this `YXMlElement` instance.
3866
+
* @param {YTransaction | undefined} txn
3867
+
* @returns {number}
3868
+
*/
3869
+
length(txn) {
3870
+
const ret = wasm.yxmlfragment_length(this.__wbg_ptr, txn);
3871
+
if (ret[2]) {
3872
+
throw takeFromExternrefTable0(ret[1]);
3873
+
}
3874
+
return ret[0] >>> 0;
3875
+
}
3876
+
/**
3877
+
* @param {number} index
3878
+
* @param {any} xml_node
3879
+
* @param {YTransaction | undefined} txn
3880
+
*/
3881
+
insert(index, xml_node, txn) {
3882
+
const ret = wasm.yxmlfragment_insert(this.__wbg_ptr, index, xml_node, txn);
3883
+
if (ret[1]) {
3884
+
throw takeFromExternrefTable0(ret[0]);
3885
+
}
3886
+
}
3887
+
/**
3888
+
* @param {any} xml_node
3889
+
* @param {YTransaction | undefined} txn
3890
+
*/
3891
+
push(xml_node, txn) {
3892
+
const ret = wasm.yxmlfragment_push(this.__wbg_ptr, xml_node, txn);
3893
+
if (ret[1]) {
3894
+
throw takeFromExternrefTable0(ret[0]);
3895
+
}
3896
+
}
3897
+
/**
3898
+
* @param {number} index
3899
+
* @param {number | null | undefined} length
3900
+
* @param {YTransaction | undefined} txn
3901
+
*/
3902
+
delete(index, length, txn) {
3903
+
const ret = wasm.yxmlfragment_delete(
3904
+
this.__wbg_ptr,
3905
+
index,
3906
+
isLikeNone(length) ? 0x100000001 : length >>> 0,
3907
+
txn,
3908
+
);
3909
+
if (ret[1]) {
3910
+
throw takeFromExternrefTable0(ret[0]);
3911
+
}
3912
+
}
3913
+
/**
3914
+
* Returns a first child of this XML node.
3915
+
* It can be either `YXmlElement`, `YXmlText` or `undefined` if current node has not children.
3916
+
* @param {YTransaction | undefined} txn
3917
+
* @returns {any}
3918
+
*/
3919
+
firstChild(txn) {
3920
+
const ret = wasm.yxmlfragment_firstChild(this.__wbg_ptr, txn);
3921
+
if (ret[2]) {
3922
+
throw takeFromExternrefTable0(ret[1]);
3923
+
}
3924
+
return takeFromExternrefTable0(ret[0]);
3925
+
}
3926
+
/**
3927
+
* Returns a string representation of this XML node.
3928
+
* @param {YTransaction | undefined} txn
3929
+
* @returns {string}
3930
+
*/
3931
+
toString(txn) {
3932
+
let deferred2_0;
3933
+
let deferred2_1;
3934
+
try {
3935
+
const ret = wasm.yxmlfragment_toString(this.__wbg_ptr, txn);
3936
+
var ptr1 = ret[0];
3937
+
var len1 = ret[1];
3938
+
if (ret[3]) {
3939
+
ptr1 = 0;
3940
+
len1 = 0;
3941
+
throw takeFromExternrefTable0(ret[2]);
3942
+
}
3943
+
deferred2_0 = ptr1;
3944
+
deferred2_1 = len1;
3945
+
return getStringFromWasm0(ptr1, len1);
3946
+
} finally {
3947
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
3948
+
}
3949
+
}
3950
+
/**
3951
+
* Returns an iterator that enables a deep traversal of this XML node - starting from first
3952
+
* child over this XML node successors using depth-first strategy.
3953
+
* @param {YTransaction | undefined} txn
3954
+
* @returns {Array<any>}
3955
+
*/
3956
+
treeWalker(txn) {
3957
+
const ret = wasm.yxmlfragment_treeWalker(this.__wbg_ptr, txn);
3958
+
if (ret[2]) {
3959
+
throw takeFromExternrefTable0(ret[1]);
3960
+
}
3961
+
return takeFromExternrefTable0(ret[0]);
3962
+
}
3963
+
/**
3964
+
* Subscribes to all operations happening over this instance of `YXmlFragment`. All changes are
3965
+
* batched and eventually triggered during transaction commit phase.
3966
+
* @param {Function} callback
3967
+
*/
3968
+
observe(callback) {
3969
+
const ret = wasm.yxmlfragment_observe(this.__wbg_ptr, callback);
3970
+
if (ret[1]) {
3971
+
throw takeFromExternrefTable0(ret[0]);
3972
+
}
3973
+
}
3974
+
/**
3975
+
* Unsubscribes a callback previously subscribed with `observe` method.
3976
+
* @param {Function} callback
3977
+
* @returns {boolean}
3978
+
*/
3979
+
unobserve(callback) {
3980
+
const ret = wasm.yxmlfragment_unobserve(this.__wbg_ptr, callback);
3981
+
if (ret[2]) {
3982
+
throw takeFromExternrefTable0(ret[1]);
3983
+
}
3984
+
return ret[0] !== 0;
3985
+
}
3986
+
/**
3987
+
* Subscribes to all operations happening over this Y shared type, as well as events in
3988
+
* shared types stored within this one. All changes are batched and eventually triggered
3989
+
* during transaction commit phase.
3990
+
* @param {Function} callback
3991
+
*/
3992
+
observeDeep(callback) {
3993
+
const ret = wasm.yxmlfragment_observeDeep(this.__wbg_ptr, callback);
3994
+
if (ret[1]) {
3995
+
throw takeFromExternrefTable0(ret[0]);
3996
+
}
3997
+
}
3998
+
/**
3999
+
* Unsubscribes a callback previously subscribed with `observeDeep` method.
4000
+
* @param {Function} callback
4001
+
* @returns {boolean}
4002
+
*/
4003
+
unobserveDeep(callback) {
4004
+
const ret = wasm.yxmlfragment_unobserveDeep(this.__wbg_ptr, callback);
4005
+
if (ret[2]) {
4006
+
throw takeFromExternrefTable0(ret[1]);
4007
+
}
4008
+
return ret[0] !== 0;
4009
+
}
4010
+
}
4011
+
module.exports.YXmlFragment = YXmlFragment;
4012
+
4013
+
const YXmlTextFinalization =
4014
+
typeof FinalizationRegistry === "undefined"
4015
+
? { register: () => {}, unregister: () => {} }
4016
+
: new FinalizationRegistry((ptr) => wasm.__wbg_yxmltext_free(ptr >>> 0, 1));
4017
+
/**
4018
+
* A shared data type used for collaborative text editing, that can be used in a context of
4019
+
* `YXmlElement` nodee. It enables multiple users to add and remove chunks of text in efficient
4020
+
* manner. This type is internally represented as a mutable double-linked list of text chunks
4021
+
* - an optimization occurs during `YTransaction.commit`, which allows to squash multiple
4022
+
* consecutively inserted characters together as a single chunk of text even between transaction
4023
+
* boundaries in order to preserve more efficient memory model.
4024
+
*
4025
+
* Just like `YXmlElement`, `YXmlText` can be marked with extra metadata in form of attributes.
4026
+
*
4027
+
* `YXmlText` structure internally uses UTF-8 encoding and its length is described in a number of
4028
+
* bytes rather than individual characters (a single UTF-8 code point can consist of many bytes).
4029
+
*
4030
+
* Like all Yrs shared data types, `YXmlText` is resistant to the problem of interleaving (situation
4031
+
* when characters inserted one after another may interleave with other peers concurrent inserts
4032
+
* after merging all updates together). In case of Yrs conflict resolution is solved by using
4033
+
* unique document id to determine correct and consistent ordering.
4034
+
*/
4035
+
class YXmlText {
4036
+
static __wrap(ptr) {
4037
+
ptr = ptr >>> 0;
4038
+
const obj = Object.create(YXmlText.prototype);
4039
+
obj.__wbg_ptr = ptr;
4040
+
YXmlTextFinalization.register(obj, obj.__wbg_ptr, obj);
4041
+
return obj;
4042
+
}
4043
+
4044
+
__destroy_into_raw() {
4045
+
const ptr = this.__wbg_ptr;
4046
+
this.__wbg_ptr = 0;
4047
+
YXmlTextFinalization.unregister(this);
4048
+
return ptr;
4049
+
}
4050
+
4051
+
free() {
4052
+
const ptr = this.__destroy_into_raw();
4053
+
wasm.__wbg_yxmltext_free(ptr, 0);
4054
+
}
4055
+
/**
4056
+
* @param {string | null | undefined} text
4057
+
* @param {any} attributes
4058
+
*/
4059
+
constructor(text, attributes) {
4060
+
var ptr0 = isLikeNone(text)
4061
+
? 0
4062
+
: passStringToWasm0(
4063
+
text,
4064
+
wasm.__wbindgen_malloc,
4065
+
wasm.__wbindgen_realloc,
4066
+
);
4067
+
var len0 = WASM_VECTOR_LEN;
4068
+
const ret = wasm.yxmltext_new(ptr0, len0, attributes);
4069
+
if (ret[2]) {
4070
+
throw takeFromExternrefTable0(ret[1]);
4071
+
}
4072
+
this.__wbg_ptr = ret[0] >>> 0;
4073
+
YXmlTextFinalization.register(this, this.__wbg_ptr, this);
4074
+
return this;
4075
+
}
4076
+
/**
4077
+
* @returns {number}
4078
+
*/
4079
+
get type() {
4080
+
const ret = wasm.yxmltext_type(this.__wbg_ptr);
4081
+
return ret;
4082
+
}
4083
+
/**
4084
+
* Gets unique logical identifier of this type, shared across peers collaborating on the same
4085
+
* document.
4086
+
* @returns {any}
4087
+
*/
4088
+
get id() {
4089
+
const ret = wasm.yxmltext_id(this.__wbg_ptr);
4090
+
if (ret[2]) {
4091
+
throw takeFromExternrefTable0(ret[1]);
4092
+
}
4093
+
return takeFromExternrefTable0(ret[0]);
4094
+
}
4095
+
/**
4096
+
* Returns true if this is a preliminary instance of `YXmlText`.
4097
+
*
4098
+
* Preliminary instances can be nested into other shared data types.
4099
+
* Once a preliminary instance has been inserted this way, it becomes integrated into ywasm
4100
+
* document store and cannot be nested again: attempt to do so will result in an exception.
4101
+
* @returns {boolean}
4102
+
*/
4103
+
get prelim() {
4104
+
const ret = wasm.yxmltext_prelim(this.__wbg_ptr);
4105
+
return ret !== 0;
4106
+
}
4107
+
/**
4108
+
* Checks if current shared type reference is alive and has not been deleted by its parent collection.
4109
+
* This method only works on already integrated shared types and will return false is current
4110
+
* type is preliminary (has not been integrated into document).
4111
+
* @param {YTransaction} txn
4112
+
* @returns {boolean}
4113
+
*/
4114
+
alive(txn) {
4115
+
_assertClass(txn, YTransaction);
4116
+
const ret = wasm.yxmltext_alive(this.__wbg_ptr, txn.__wbg_ptr);
4117
+
return ret !== 0;
4118
+
}
4119
+
/**
4120
+
* Returns length of an underlying string stored in this `YXmlText` instance,
4121
+
* understood as a number of UTF-8 encoded bytes.
4122
+
* @param {YTransaction | undefined} txn
4123
+
* @returns {number}
4124
+
*/
4125
+
length(txn) {
4126
+
const ret = wasm.yxmltext_length(this.__wbg_ptr, txn);
4127
+
if (ret[2]) {
4128
+
throw takeFromExternrefTable0(ret[1]);
4129
+
}
4130
+
return ret[0] >>> 0;
4131
+
}
4132
+
/**
4133
+
* Inserts a given `chunk` of text into this `YXmlText` instance, starting at a given `index`.
4134
+
*
4135
+
* Optional object with defined `attributes` will be used to wrap provided text `chunk`
4136
+
* with a formatting blocks.
4137
+
* @param {number} index
4138
+
* @param {string} chunk
4139
+
* @param {any} attributes
4140
+
* @param {YTransaction | undefined} txn
4141
+
*/
4142
+
insert(index, chunk, attributes, txn) {
4143
+
const ptr0 = passStringToWasm0(
4144
+
chunk,
4145
+
wasm.__wbindgen_malloc,
4146
+
wasm.__wbindgen_realloc,
4147
+
);
4148
+
const len0 = WASM_VECTOR_LEN;
4149
+
const ret = wasm.yxmltext_insert(
4150
+
this.__wbg_ptr,
4151
+
index,
4152
+
ptr0,
4153
+
len0,
4154
+
attributes,
4155
+
txn,
4156
+
);
4157
+
if (ret[1]) {
4158
+
throw takeFromExternrefTable0(ret[0]);
4159
+
}
4160
+
}
4161
+
/**
4162
+
* Formats text within bounds specified by `index` and `len` with a given formatting
4163
+
* attributes.
4164
+
* @param {number} index
4165
+
* @param {number} length
4166
+
* @param {any} attributes
4167
+
* @param {YTransaction | undefined} txn
4168
+
*/
4169
+
format(index, length, attributes, txn) {
4170
+
const ret = wasm.yxmltext_format(
4171
+
this.__wbg_ptr,
4172
+
index,
4173
+
length,
4174
+
attributes,
4175
+
txn,
4176
+
);
4177
+
if (ret[1]) {
4178
+
throw takeFromExternrefTable0(ret[0]);
4179
+
}
4180
+
}
4181
+
/**
4182
+
* @param {number | null | undefined} lower
4183
+
* @param {number | null | undefined} upper
4184
+
* @param {boolean | null | undefined} lower_open
4185
+
* @param {boolean | null | undefined} upper_open
4186
+
* @param {YTransaction | undefined} txn
4187
+
* @returns {YWeakLink}
4188
+
*/
4189
+
quote(lower, upper, lower_open, upper_open, txn) {
4190
+
const ret = wasm.yxmltext_quote(
4191
+
this.__wbg_ptr,
4192
+
isLikeNone(lower) ? 0x100000001 : lower >>> 0,
4193
+
isLikeNone(upper) ? 0x100000001 : upper >>> 0,
4194
+
isLikeNone(lower_open) ? 0xffffff : lower_open ? 1 : 0,
4195
+
isLikeNone(upper_open) ? 0xffffff : upper_open ? 1 : 0,
4196
+
txn,
4197
+
);
4198
+
if (ret[2]) {
4199
+
throw takeFromExternrefTable0(ret[1]);
4200
+
}
4201
+
return YWeakLink.__wrap(ret[0]);
4202
+
}
4203
+
/**
4204
+
* Returns the Delta representation of this YXmlText type.
4205
+
* @param {any} snapshot
4206
+
* @param {any} prev_snapshot
4207
+
* @param {Function | null | undefined} compute_ychange
4208
+
* @param {YTransaction | undefined} txn
4209
+
* @returns {Array<any>}
4210
+
*/
4211
+
toDelta(snapshot, prev_snapshot, compute_ychange, txn) {
4212
+
const ret = wasm.yxmltext_toDelta(
4213
+
this.__wbg_ptr,
4214
+
snapshot,
4215
+
prev_snapshot,
4216
+
isLikeNone(compute_ychange) ? 0 : addToExternrefTable0(compute_ychange),
4217
+
txn,
4218
+
);
4219
+
if (ret[2]) {
4220
+
throw takeFromExternrefTable0(ret[1]);
4221
+
}
4222
+
return takeFromExternrefTable0(ret[0]);
4223
+
}
4224
+
/**
4225
+
* Inserts a given `embed` object into this `YXmlText` instance, starting at a given `index`.
4226
+
*
4227
+
* Optional object with defined `attributes` will be used to wrap provided `embed`
4228
+
* with a formatting blocks.`attributes` are only supported for a `YXmlText` instance which
4229
+
* already has been integrated into document store.
4230
+
* @param {number} index
4231
+
* @param {any} embed
4232
+
* @param {any} attributes
4233
+
* @param {YTransaction | undefined} txn
4234
+
*/
4235
+
insertEmbed(index, embed, attributes, txn) {
4236
+
const ret = wasm.yxmltext_insertEmbed(
4237
+
this.__wbg_ptr,
4238
+
index,
4239
+
embed,
4240
+
attributes,
4241
+
txn,
4242
+
);
4243
+
if (ret[1]) {
4244
+
throw takeFromExternrefTable0(ret[0]);
4245
+
}
4246
+
}
4247
+
/**
4248
+
* Appends a given `chunk` of text at the end of `YXmlText` instance.
4249
+
*
4250
+
* Optional object with defined `attributes` will be used to wrap provided text `chunk`
4251
+
* with a formatting blocks.
4252
+
* @param {string} chunk
4253
+
* @param {any} attributes
4254
+
* @param {YTransaction | undefined} txn
4255
+
*/
4256
+
push(chunk, attributes, txn) {
4257
+
const ptr0 = passStringToWasm0(
4258
+
chunk,
4259
+
wasm.__wbindgen_malloc,
4260
+
wasm.__wbindgen_realloc,
4261
+
);
4262
+
const len0 = WASM_VECTOR_LEN;
4263
+
const ret = wasm.yxmltext_push(this.__wbg_ptr, ptr0, len0, attributes, txn);
4264
+
if (ret[1]) {
4265
+
throw takeFromExternrefTable0(ret[0]);
4266
+
}
4267
+
}
4268
+
/**
4269
+
* @param {Array<any>} delta
4270
+
* @param {YTransaction | undefined} txn
4271
+
*/
4272
+
applyDelta(delta, txn) {
4273
+
const ret = wasm.yxmltext_applyDelta(this.__wbg_ptr, delta, txn);
4274
+
if (ret[1]) {
4275
+
throw takeFromExternrefTable0(ret[0]);
4276
+
}
4277
+
}
4278
+
/**
4279
+
* Deletes a specified range of characters, starting at a given `index`.
4280
+
* Both `index` and `length` are counted in terms of a number of UTF-8 character bytes.
4281
+
* @param {number} index
4282
+
* @param {number} length
4283
+
* @param {YTransaction | undefined} txn
4284
+
*/
4285
+
delete(index, length, txn) {
4286
+
const ret = wasm.yxmltext_delete(this.__wbg_ptr, index, length, txn);
4287
+
if (ret[1]) {
4288
+
throw takeFromExternrefTable0(ret[0]);
4289
+
}
4290
+
}
4291
+
/**
4292
+
* Returns a next XML sibling node of this XMl node.
4293
+
* It can be either `YXmlElement`, `YXmlText` or `undefined` if current node is a last child of
4294
+
* parent XML node.
4295
+
* @param {YTransaction | undefined} txn
4296
+
* @returns {any}
4297
+
*/
4298
+
nextSibling(txn) {
4299
+
const ret = wasm.yxmltext_nextSibling(this.__wbg_ptr, txn);
4300
+
if (ret[2]) {
4301
+
throw takeFromExternrefTable0(ret[1]);
4302
+
}
4303
+
return takeFromExternrefTable0(ret[0]);
4304
+
}
4305
+
/**
4306
+
* Returns a previous XML sibling node of this XMl node.
4307
+
* It can be either `YXmlElement`, `YXmlText` or `undefined` if current node is a first child
4308
+
* of parent XML node.
4309
+
* @param {YTransaction | undefined} txn
4310
+
* @returns {any}
4311
+
*/
4312
+
prevSibling(txn) {
4313
+
const ret = wasm.yxmltext_prevSibling(this.__wbg_ptr, txn);
4314
+
if (ret[2]) {
4315
+
throw takeFromExternrefTable0(ret[1]);
4316
+
}
4317
+
return takeFromExternrefTable0(ret[0]);
4318
+
}
4319
+
/**
4320
+
* Returns a parent `YXmlElement` node or `undefined` if current node has no parent assigned.
4321
+
* @param {YTransaction | undefined} txn
4322
+
* @returns {any}
4323
+
*/
4324
+
parent(txn) {
4325
+
const ret = wasm.yxmltext_parent(this.__wbg_ptr, txn);
4326
+
if (ret[2]) {
4327
+
throw takeFromExternrefTable0(ret[1]);
4328
+
}
4329
+
return takeFromExternrefTable0(ret[0]);
4330
+
}
4331
+
/**
4332
+
* Returns an underlying string stored in this `YXmlText` instance.
4333
+
* @param {YTransaction | undefined} txn
4334
+
* @returns {string}
4335
+
*/
4336
+
toString(txn) {
4337
+
let deferred2_0;
4338
+
let deferred2_1;
4339
+
try {
4340
+
const ret = wasm.yxmltext_toString(this.__wbg_ptr, txn);
4341
+
var ptr1 = ret[0];
4342
+
var len1 = ret[1];
4343
+
if (ret[3]) {
4344
+
ptr1 = 0;
4345
+
len1 = 0;
4346
+
throw takeFromExternrefTable0(ret[2]);
4347
+
}
4348
+
deferred2_0 = ptr1;
4349
+
deferred2_1 = len1;
4350
+
return getStringFromWasm0(ptr1, len1);
4351
+
} finally {
4352
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
4353
+
}
4354
+
}
4355
+
/**
4356
+
* Sets a `name` and `value` as new attribute for this XML node. If an attribute with the same
4357
+
* `name` already existed on that node, its value with be overridden with a provided one.
4358
+
* This method accepts any JavaScript value, not just strings.
4359
+
* @param {string} name
4360
+
* @param {any} value
4361
+
* @param {YTransaction | undefined} txn
4362
+
*/
4363
+
setAttribute(name, value, txn) {
4364
+
const ptr0 = passStringToWasm0(
4365
+
name,
4366
+
wasm.__wbindgen_malloc,
4367
+
wasm.__wbindgen_realloc,
4368
+
);
4369
+
const len0 = WASM_VECTOR_LEN;
4370
+
const ret = wasm.yxmltext_setAttribute(
4371
+
this.__wbg_ptr,
4372
+
ptr0,
4373
+
len0,
4374
+
value,
4375
+
txn,
4376
+
);
4377
+
if (ret[1]) {
4378
+
throw takeFromExternrefTable0(ret[0]);
4379
+
}
4380
+
}
4381
+
/**
4382
+
* Returns a value of an attribute given its `name` as any JS value. If no attribute with such name existed,
4383
+
* `undefined` will be returned.
4384
+
* @param {string} name
4385
+
* @param {YTransaction | undefined} txn
4386
+
* @returns {any}
4387
+
*/
4388
+
getAttribute(name, txn) {
4389
+
const ptr0 = passStringToWasm0(
4390
+
name,
4391
+
wasm.__wbindgen_malloc,
4392
+
wasm.__wbindgen_realloc,
4393
+
);
4394
+
const len0 = WASM_VECTOR_LEN;
4395
+
const ret = wasm.yxmltext_getAttribute(this.__wbg_ptr, ptr0, len0, txn);
4396
+
if (ret[2]) {
4397
+
throw takeFromExternrefTable0(ret[1]);
4398
+
}
4399
+
return takeFromExternrefTable0(ret[0]);
4400
+
}
4401
+
/**
4402
+
* Removes an attribute from this XML node, given its `name`.
4403
+
* @param {string} name
4404
+
* @param {YTransaction | undefined} txn
4405
+
*/
4406
+
removeAttribute(name, txn) {
4407
+
const ptr0 = passStringToWasm0(
4408
+
name,
4409
+
wasm.__wbindgen_malloc,
4410
+
wasm.__wbindgen_realloc,
4411
+
);
4412
+
const len0 = WASM_VECTOR_LEN;
4413
+
const ret = wasm.yxmltext_removeAttribute(this.__wbg_ptr, ptr0, len0, txn);
4414
+
if (ret[1]) {
4415
+
throw takeFromExternrefTable0(ret[0]);
4416
+
}
4417
+
}
4418
+
/**
4419
+
* Returns an iterator that enables to traverse over all attributes of this XML node in
4420
+
* unspecified order. This method returns attribute values as their original JS values,
4421
+
* not just as strings.
4422
+
* @param {YTransaction | undefined} txn
4423
+
* @returns {any}
4424
+
*/
4425
+
attributes(txn) {
4426
+
const ret = wasm.yxmltext_attributes(this.__wbg_ptr, txn);
4427
+
if (ret[2]) {
4428
+
throw takeFromExternrefTable0(ret[1]);
4429
+
}
4430
+
return takeFromExternrefTable0(ret[0]);
4431
+
}
4432
+
/**
4433
+
* Subscribes to all operations happening over this instance of `YXmlText`. All changes are
4434
+
* batched and eventually triggered during transaction commit phase.
4435
+
* @param {Function} callback
4436
+
*/
4437
+
observe(callback) {
4438
+
const ret = wasm.yxmltext_observe(this.__wbg_ptr, callback);
4439
+
if (ret[1]) {
4440
+
throw takeFromExternrefTable0(ret[0]);
4441
+
}
4442
+
}
4443
+
/**
4444
+
* Unsubscribes a callback previously subscribed with `observe` method.
4445
+
* @param {Function} callback
4446
+
* @returns {boolean}
4447
+
*/
4448
+
unobserve(callback) {
4449
+
const ret = wasm.yxmltext_unobserve(this.__wbg_ptr, callback);
4450
+
if (ret[2]) {
4451
+
throw takeFromExternrefTable0(ret[1]);
4452
+
}
4453
+
return ret[0] !== 0;
4454
+
}
4455
+
/**
4456
+
* Subscribes to all operations happening over this Y shared type, as well as events in
4457
+
* shared types stored within this one. All changes are batched and eventually triggered
4458
+
* during transaction commit phase.
4459
+
* @param {Function} callback
4460
+
*/
4461
+
observeDeep(callback) {
4462
+
const ret = wasm.yxmltext_observeDeep(this.__wbg_ptr, callback);
4463
+
if (ret[1]) {
4464
+
throw takeFromExternrefTable0(ret[0]);
4465
+
}
4466
+
}
4467
+
/**
4468
+
* Unsubscribes a callback previously subscribed with `observe` method.
4469
+
* @param {Function} callback
4470
+
* @returns {boolean}
4471
+
*/
4472
+
unobserveDeep(callback) {
4473
+
const ret = wasm.yxmltext_unobserveDeep(this.__wbg_ptr, callback);
4474
+
if (ret[2]) {
4475
+
throw takeFromExternrefTable0(ret[1]);
4476
+
}
4477
+
return ret[0] !== 0;
4478
+
}
4479
+
}
4480
+
module.exports.YXmlText = YXmlText;
4481
+
4482
+
const YXmlTextEventFinalization =
4483
+
typeof FinalizationRegistry === "undefined"
4484
+
? { register: () => {}, unregister: () => {} }
4485
+
: new FinalizationRegistry((ptr) =>
4486
+
wasm.__wbg_yxmltextevent_free(ptr >>> 0, 1),
4487
+
);
4488
+
/**
4489
+
* Event generated by `YXmlText.observe` method. Emitted during transaction commit phase.
4490
+
*/
4491
+
class YXmlTextEvent {
4492
+
static __wrap(ptr) {
4493
+
ptr = ptr >>> 0;
4494
+
const obj = Object.create(YXmlTextEvent.prototype);
4495
+
obj.__wbg_ptr = ptr;
4496
+
YXmlTextEventFinalization.register(obj, obj.__wbg_ptr, obj);
4497
+
return obj;
4498
+
}
4499
+
4500
+
__destroy_into_raw() {
4501
+
const ptr = this.__wbg_ptr;
4502
+
this.__wbg_ptr = 0;
4503
+
YXmlTextEventFinalization.unregister(this);
4504
+
return ptr;
4505
+
}
4506
+
4507
+
free() {
4508
+
const ptr = this.__destroy_into_raw();
4509
+
wasm.__wbg_yxmltextevent_free(ptr, 0);
4510
+
}
4511
+
/**
4512
+
* Returns an array of keys and indexes creating a path from root type down to current instance
4513
+
* of shared type (accessible via `target` getter).
4514
+
* @returns {any}
4515
+
*/
4516
+
path() {
4517
+
const ret = wasm.yxmltextevent_path(this.__wbg_ptr);
4518
+
return ret;
4519
+
}
4520
+
/**
4521
+
* Returns a current shared type instance, that current event changes refer to.
4522
+
* @returns {any}
4523
+
*/
4524
+
get target() {
4525
+
const ret = wasm.yxmltextevent_target(this.__wbg_ptr);
4526
+
return ret;
4527
+
}
4528
+
/**
4529
+
* @returns {any}
4530
+
*/
4531
+
get origin() {
4532
+
const ret = wasm.yxmltextevent_origin(this.__wbg_ptr);
4533
+
return ret;
4534
+
}
4535
+
/**
4536
+
* Returns a list of text changes made over corresponding `YText` collection within
4537
+
* bounds of current transaction. These changes follow a format:
4538
+
*
4539
+
* - { insert: string, attributes: any|undefined }
4540
+
* - { delete: number }
4541
+
* - { retain: number, attributes: any|undefined }
4542
+
* @returns {any}
4543
+
*/
4544
+
get delta() {
4545
+
const ret = wasm.yxmltextevent_delta(this.__wbg_ptr);
4546
+
if (ret[2]) {
4547
+
throw takeFromExternrefTable0(ret[1]);
4548
+
}
4549
+
return takeFromExternrefTable0(ret[0]);
4550
+
}
4551
+
/**
4552
+
* Returns a list of attribute changes made over corresponding `YXmlText` collection within
4553
+
* bounds of current transaction. These changes follow a format:
4554
+
*
4555
+
* - { action: 'add'|'update'|'delete', oldValue: string|undefined, newValue: string|undefined }
4556
+
* @returns {any}
4557
+
*/
4558
+
get keys() {
4559
+
const ret = wasm.yxmltextevent_keys(this.__wbg_ptr);
4560
+
if (ret[2]) {
4561
+
throw takeFromExternrefTable0(ret[1]);
4562
+
}
4563
+
return takeFromExternrefTable0(ret[0]);
4564
+
}
4565
+
}
4566
+
module.exports.YXmlTextEvent = YXmlTextEvent;
4567
+
4568
+
module.exports.__wbg_buffer_609cc3eee51ed158 = function (arg0) {
4569
+
const ret = arg0.buffer;
4570
+
return ret;
4571
+
};
4572
+
4573
+
module.exports.__wbg_call_672a4d21634d4a24 = function () {
4574
+
return handleError(function (arg0, arg1) {
4575
+
const ret = arg0.call(arg1);
4576
+
return ret;
4577
+
}, arguments);
4578
+
};
4579
+
4580
+
module.exports.__wbg_call_7cccdd69e0791ae2 = function () {
4581
+
return handleError(function (arg0, arg1, arg2) {
4582
+
const ret = arg0.call(arg1, arg2);
4583
+
return ret;
4584
+
}, arguments);
4585
+
};
4586
+
4587
+
module.exports.__wbg_call_833bed5770ea2041 = function () {
4588
+
return handleError(function (arg0, arg1, arg2, arg3) {
4589
+
const ret = arg0.call(arg1, arg2, arg3);
4590
+
return ret;
4591
+
}, arguments);
4592
+
};
4593
+
4594
+
module.exports.__wbg_crypto_574e78ad8b13b65f = function (arg0) {
4595
+
const ret = arg0.crypto;
4596
+
return ret;
4597
+
};
4598
+
4599
+
module.exports.__wbg_entries_3265d4158b33e5dc = function (arg0) {
4600
+
const ret = Object.entries(arg0);
4601
+
return ret;
4602
+
};
4603
+
4604
+
module.exports.__wbg_error_7534b8e9a36f1ab4 = function (arg0, arg1) {
4605
+
let deferred0_0;
4606
+
let deferred0_1;
4607
+
try {
4608
+
deferred0_0 = arg0;
4609
+
deferred0_1 = arg1;
4610
+
console.error(getStringFromWasm0(arg0, arg1));
4611
+
} finally {
4612
+
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
4613
+
}
4614
+
};
4615
+
4616
+
module.exports.__wbg_from_2a5d3e218e67aa85 = function (arg0) {
4617
+
const ret = Array.from(arg0);
4618
+
return ret;
4619
+
};
4620
+
4621
+
module.exports.__wbg_getRandomValues_b8f5dbd5f3995a9e = function () {
4622
+
return handleError(function (arg0, arg1) {
4623
+
arg0.getRandomValues(arg1);
4624
+
}, arguments);
4625
+
};
4626
+
4627
+
module.exports.__wbg_get_67b2ba62fc30de12 = function () {
4628
+
return handleError(function (arg0, arg1) {
4629
+
const ret = Reflect.get(arg0, arg1);
4630
+
return ret;
4631
+
}, arguments);
4632
+
};
4633
+
4634
+
module.exports.__wbg_get_b9b93047fe3cf45b = function (arg0, arg1) {
4635
+
const ret = arg0[arg1 >>> 0];
4636
+
return ret;
4637
+
};
4638
+
4639
+
module.exports.__wbg_isArray_a1eab7e0d067391b = function (arg0) {
4640
+
const ret = Array.isArray(arg0);
4641
+
return ret;
4642
+
};
4643
+
4644
+
module.exports.__wbg_length_a446193dc22c12f8 = function (arg0) {
4645
+
const ret = arg0.length;
4646
+
return ret;
4647
+
};
4648
+
4649
+
module.exports.__wbg_length_e2d2a49132c1b256 = function (arg0) {
4650
+
const ret = arg0.length;
4651
+
return ret;
4652
+
};
4653
+
4654
+
module.exports.__wbg_msCrypto_a61aeb35a24c1329 = function (arg0) {
4655
+
const ret = arg0.msCrypto;
4656
+
return ret;
4657
+
};
4658
+
4659
+
module.exports.__wbg_new_405e22f390576ce2 = function () {
4660
+
const ret = new Object();
4661
+
return ret;
4662
+
};
4663
+
4664
+
module.exports.__wbg_new_5e0be73521bc8c17 = function () {
4665
+
const ret = new Map();
4666
+
return ret;
4667
+
};
4668
+
4669
+
module.exports.__wbg_new_78feb108b6472713 = function () {
4670
+
const ret = new Array();
4671
+
return ret;
4672
+
};
4673
+
4674
+
module.exports.__wbg_new_8a6f238a6ece86ea = function () {
4675
+
const ret = new Error();
4676
+
return ret;
4677
+
};
4678
+
4679
+
module.exports.__wbg_new_a12002a7f91c75be = function (arg0) {
4680
+
const ret = new Uint8Array(arg0);
4681
+
return ret;
4682
+
};
4683
+
4684
+
module.exports.__wbg_new_a239edaa1dc2968f = function (arg0) {
4685
+
const ret = new Set(arg0);
4686
+
return ret;
4687
+
};
4688
+
4689
+
module.exports.__wbg_newnoargs_105ed471475aaf50 = function (arg0, arg1) {
4690
+
const ret = new Function(getStringFromWasm0(arg0, arg1));
4691
+
return ret;
4692
+
};
4693
+
4694
+
module.exports.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = function (
4695
+
arg0,
4696
+
arg1,
4697
+
arg2,
4698
+
) {
4699
+
const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
4700
+
return ret;
4701
+
};
4702
+
4703
+
module.exports.__wbg_newwithlength_a381634e90c276d4 = function (arg0) {
4704
+
const ret = new Uint8Array(arg0 >>> 0);
4705
+
return ret;
4706
+
};
4707
+
4708
+
module.exports.__wbg_node_905d3e251edff8a2 = function (arg0) {
4709
+
const ret = arg0.node;
4710
+
return ret;
4711
+
};
4712
+
4713
+
module.exports.__wbg_now_807e54c39636c349 = function () {
4714
+
const ret = Date.now();
4715
+
return ret;
4716
+
};
4717
+
4718
+
module.exports.__wbg_parse_def2e24ef1252aff = function () {
4719
+
return handleError(function (arg0, arg1) {
4720
+
const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
4721
+
return ret;
4722
+
}, arguments);
4723
+
};
4724
+
4725
+
module.exports.__wbg_process_dc0fbacc7c1c06f7 = function (arg0) {
4726
+
const ret = arg0.process;
4727
+
return ret;
4728
+
};
4729
+
4730
+
module.exports.__wbg_push_737cfc8c1432c2c6 = function (arg0, arg1) {
4731
+
const ret = arg0.push(arg1);
4732
+
return ret;
4733
+
};
4734
+
4735
+
module.exports.__wbg_randomFillSync_ac0988aba3254290 = function () {
4736
+
return handleError(function (arg0, arg1) {
4737
+
arg0.randomFillSync(arg1);
4738
+
}, arguments);
4739
+
};
4740
+
4741
+
module.exports.__wbg_require_60cc747a6bc5215a = function () {
4742
+
return handleError(function () {
4743
+
const ret = module.require;
4744
+
return ret;
4745
+
}, arguments);
4746
+
};
4747
+
4748
+
module.exports.__wbg_set_65595bdd868b3009 = function (arg0, arg1, arg2) {
4749
+
arg0.set(arg1, arg2 >>> 0);
4750
+
};
4751
+
4752
+
module.exports.__wbg_set_8fc6bf8a5b1071d1 = function (arg0, arg1, arg2) {
4753
+
const ret = arg0.set(arg1, arg2);
4754
+
return ret;
4755
+
};
4756
+
4757
+
module.exports.__wbg_set_bb8cecf6a62b9f46 = function () {
4758
+
return handleError(function (arg0, arg1, arg2) {
4759
+
const ret = Reflect.set(arg0, arg1, arg2);
4760
+
return ret;
4761
+
}, arguments);
4762
+
};
4763
+
4764
+
module.exports.__wbg_stack_0ed75d68575b0f3c = function (arg0, arg1) {
4765
+
const ret = arg1.stack;
4766
+
const ptr1 = passStringToWasm0(
4767
+
ret,
4768
+
wasm.__wbindgen_malloc,
4769
+
wasm.__wbindgen_realloc,
4770
+
);
4771
+
const len1 = WASM_VECTOR_LEN;
4772
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
4773
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
4774
+
};
4775
+
4776
+
module.exports.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function () {
4777
+
const ret = typeof global === "undefined" ? null : global;
4778
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4779
+
};
4780
+
4781
+
module.exports.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 =
4782
+
function () {
4783
+
const ret = typeof globalThis === "undefined" ? null : globalThis;
4784
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4785
+
};
4786
+
4787
+
module.exports.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function () {
4788
+
const ret = typeof self === "undefined" ? null : self;
4789
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4790
+
};
4791
+
4792
+
module.exports.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function () {
4793
+
const ret = typeof window === "undefined" ? null : window;
4794
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4795
+
};
4796
+
4797
+
module.exports.__wbg_stringify_f7ed6987935b4a24 = function () {
4798
+
return handleError(function (arg0) {
4799
+
const ret = JSON.stringify(arg0);
4800
+
return ret;
4801
+
}, arguments);
4802
+
};
4803
+
4804
+
module.exports.__wbg_subarray_aa9065fa9dc5df96 = function (arg0, arg1, arg2) {
4805
+
const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
4806
+
return ret;
4807
+
};
4808
+
4809
+
module.exports.__wbg_versions_c01dfd4722a88165 = function (arg0) {
4810
+
const ret = arg0.versions;
4811
+
return ret;
4812
+
};
4813
+
4814
+
module.exports.__wbg_yarray_new = function (arg0) {
4815
+
const ret = YArray.__wrap(arg0);
4816
+
return ret;
4817
+
};
4818
+
4819
+
module.exports.__wbg_yarrayevent_new = function (arg0) {
4820
+
const ret = YArrayEvent.__wrap(arg0);
4821
+
return ret;
4822
+
};
4823
+
4824
+
module.exports.__wbg_ydoc_new = function (arg0) {
4825
+
const ret = YDoc.__wrap(arg0);
4826
+
return ret;
4827
+
};
4828
+
4829
+
module.exports.__wbg_ymap_new = function (arg0) {
4830
+
const ret = YMap.__wrap(arg0);
4831
+
return ret;
4832
+
};
4833
+
4834
+
module.exports.__wbg_ymapevent_new = function (arg0) {
4835
+
const ret = YMapEvent.__wrap(arg0);
4836
+
return ret;
4837
+
};
4838
+
4839
+
module.exports.__wbg_ysubdocsevent_new = function (arg0) {
4840
+
const ret = YSubdocsEvent.__wrap(arg0);
4841
+
return ret;
4842
+
};
4843
+
4844
+
module.exports.__wbg_ytext_new = function (arg0) {
4845
+
const ret = YText.__wrap(arg0);
4846
+
return ret;
4847
+
};
4848
+
4849
+
module.exports.__wbg_ytextevent_new = function (arg0) {
4850
+
const ret = YTextEvent.__wrap(arg0);
4851
+
return ret;
4852
+
};
4853
+
4854
+
module.exports.__wbg_ytransaction_new = function (arg0) {
4855
+
const ret = YTransaction.__wrap(arg0);
4856
+
return ret;
4857
+
};
4858
+
4859
+
module.exports.__wbg_yundoevent_new = function (arg0) {
4860
+
const ret = YUndoEvent.__wrap(arg0);
4861
+
return ret;
4862
+
};
4863
+
4864
+
module.exports.__wbg_yweaklink_new = function (arg0) {
4865
+
const ret = YWeakLink.__wrap(arg0);
4866
+
return ret;
4867
+
};
4868
+
4869
+
module.exports.__wbg_yweaklinkevent_new = function (arg0) {
4870
+
const ret = YWeakLinkEvent.__wrap(arg0);
4871
+
return ret;
4872
+
};
4873
+
4874
+
module.exports.__wbg_yxmlelement_new = function (arg0) {
4875
+
const ret = YXmlElement.__wrap(arg0);
4876
+
return ret;
4877
+
};
4878
+
4879
+
module.exports.__wbg_yxmlevent_new = function (arg0) {
4880
+
const ret = YXmlEvent.__wrap(arg0);
4881
+
return ret;
4882
+
};
4883
+
4884
+
module.exports.__wbg_yxmlfragment_new = function (arg0) {
4885
+
const ret = YXmlFragment.__wrap(arg0);
4886
+
return ret;
4887
+
};
4888
+
4889
+
module.exports.__wbg_yxmltext_new = function (arg0) {
4890
+
const ret = YXmlText.__wrap(arg0);
4891
+
return ret;
4892
+
};
4893
+
4894
+
module.exports.__wbg_yxmltextevent_new = function (arg0) {
4895
+
const ret = YXmlTextEvent.__wrap(arg0);
4896
+
return ret;
4897
+
};
4898
+
4899
+
module.exports.__wbindgen_bigint_from_i64 = function (arg0) {
4900
+
const ret = arg0;
4901
+
return ret;
4902
+
};
4903
+
4904
+
module.exports.__wbindgen_bigint_from_u64 = function (arg0) {
4905
+
const ret = BigInt.asUintN(64, arg0);
4906
+
return ret;
4907
+
};
4908
+
4909
+
module.exports.__wbindgen_boolean_get = function (arg0) {
4910
+
const v = arg0;
4911
+
const ret = typeof v === "boolean" ? (v ? 1 : 0) : 2;
4912
+
return ret;
4913
+
};
4914
+
4915
+
module.exports.__wbindgen_debug_string = function (arg0, arg1) {
4916
+
const ret = debugString(arg1);
4917
+
const ptr1 = passStringToWasm0(
4918
+
ret,
4919
+
wasm.__wbindgen_malloc,
4920
+
wasm.__wbindgen_realloc,
4921
+
);
4922
+
const len1 = WASM_VECTOR_LEN;
4923
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
4924
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
4925
+
};
4926
+
4927
+
module.exports.__wbindgen_init_externref_table = function () {
4928
+
const table = wasm.__wbindgen_export_2;
4929
+
const offset = table.grow(4);
4930
+
table.set(0, undefined);
4931
+
table.set(offset + 0, undefined);
4932
+
table.set(offset + 1, null);
4933
+
table.set(offset + 2, true);
4934
+
table.set(offset + 3, false);
4935
+
};
4936
+
4937
+
module.exports.__wbindgen_is_bigint = function (arg0) {
4938
+
const ret = typeof arg0 === "bigint";
4939
+
return ret;
4940
+
};
4941
+
4942
+
module.exports.__wbindgen_is_function = function (arg0) {
4943
+
const ret = typeof arg0 === "function";
4944
+
return ret;
4945
+
};
4946
+
4947
+
module.exports.__wbindgen_is_null = function (arg0) {
4948
+
const ret = arg0 === null;
4949
+
return ret;
4950
+
};
4951
+
4952
+
module.exports.__wbindgen_is_object = function (arg0) {
4953
+
const val = arg0;
4954
+
const ret = typeof val === "object" && val !== null;
4955
+
return ret;
4956
+
};
4957
+
4958
+
module.exports.__wbindgen_is_string = function (arg0) {
4959
+
const ret = typeof arg0 === "string";
4960
+
return ret;
4961
+
};
4962
+
4963
+
module.exports.__wbindgen_is_undefined = function (arg0) {
4964
+
const ret = arg0 === undefined;
4965
+
return ret;
4966
+
};
4967
+
4968
+
module.exports.__wbindgen_memory = function () {
4969
+
const ret = wasm.memory;
4970
+
return ret;
4971
+
};
4972
+
4973
+
module.exports.__wbindgen_number_get = function (arg0, arg1) {
4974
+
const obj = arg1;
4975
+
const ret = typeof obj === "number" ? obj : undefined;
4976
+
getDataViewMemory0().setFloat64(
4977
+
arg0 + 8 * 1,
4978
+
isLikeNone(ret) ? 0 : ret,
4979
+
true,
4980
+
);
4981
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
4982
+
};
4983
+
4984
+
module.exports.__wbindgen_number_new = function (arg0) {
4985
+
const ret = arg0;
4986
+
return ret;
4987
+
};
4988
+
4989
+
module.exports.__wbindgen_string_get = function (arg0, arg1) {
4990
+
const obj = arg1;
4991
+
const ret = typeof obj === "string" ? obj : undefined;
4992
+
var ptr1 = isLikeNone(ret)
4993
+
? 0
4994
+
: passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
4995
+
var len1 = WASM_VECTOR_LEN;
4996
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
4997
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
4998
+
};
4999
+
5000
+
module.exports.__wbindgen_string_new = function (arg0, arg1) {
5001
+
const ret = getStringFromWasm0(arg0, arg1);
5002
+
return ret;
5003
+
};
5004
+
5005
+
module.exports.__wbindgen_throw = function (arg0, arg1) {
5006
+
throw new Error(getStringFromWasm0(arg0, arg1));
5007
+
};
5008
+
5009
+
const path = require("path").join(
5010
+
process.cwd(),
5011
+
"public",
5012
+
"wasm",
5013
+
"ywasm_bg.wasm",
5014
+
);
5015
+
const bytes = require("fs").readFileSync(path);
5016
+
5017
+
const wasmModule = new WebAssembly.Module(bytes);
5018
+
const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
5019
+
wasm = wasmInstance.exports;
5020
+
module.exports.__wasm = wasm;
5021
+
5022
+
wasm.__wbindgen_start();