Error implements the Error interface

Apply applies the specified change on the object and returns the updated value.

Append a sequence of operations. If the operation IDs already exist, those operations are ignored but do not generate an error.

New returns a new Stream

Next returns the change and the next stream. If no further changes exist, it returns nil for both. All related stream instances are guaranateed to con

NewText initializes a new rich text value

Append adds a change on top of the current change. If the current change has a Next, this is merged with the next and applied to the Next instead. T

Count should noly be called on collection-like objects such as the Before/After fields of a Splice. It returns the size of the collection.

Slice should only be called on collection-like objects such as the Before/After fields of a Splice. Note that unlike Go's slice notation, the argument

Close releases all resources. Any ongoing calls should not be canceled unless the caller cancels them via the context.

GetSince returns all operations with version atleast equal to the specified parameter. If the number of operations is larger than the limit, it is tru

Format converts any value to HTML

Substream creates a child stream The sequence of keys are used as paths into the logical value and work for both array indices and object-like keys.

Merge takes the current change and another change that were both applied to the same virtual JSON and returns transformed versions such that: c + oth

Merge updates the caret index based on the change. Note that it always returns a nil change as there is no way for a change to affect the caret.

SetAttribute returns a change which when applied would set all the attributes in the range [offset, offset+count] to the provided value.

Merge takes a change and returns an Ref that reflects the effect of the change. If the change affects the item specified by the Ref, it returns a mod

Get returns the current value or nil if there is no value available.

Simplify converts a change to a simpler form if possible

ApplyCollection is just strongly typed Apply

Apply implements changes.Value

Merge implements Ref.Merge

Eval evaluates a value within a particular scope Values of type CallExpr evaluate to the corresponding call. All other values are simply the same va

Revert returns the opposite effect of the current change. If applied directly after the current change it should undo the effect of the current change

Items returns the seq as an array

Push pushes all local change up to any remote stream. Does nothing if not connected to a remote stream

Elem returns a field version of the element

Pull pulls all changes from a remote stream. Does nothing if not connected to a remote stream

Equal tests if two refs are the same.

Latest returns the latest stream instance and the set of changes that have taken place until then

MemStore returns an in-memory implementation of the Store interface

ReverseAppend is just like Append except ReverseMerge is used instead of Merge. ReverseAppend is used to when a remote change is being appended -- wi

Apply implements changes.Value:Apply

LessOrd returns true if a < b

Set creates or updates the value for a key

NextOrd returns the next ordinal. Less(key, next(key)) is guaranteed to always be true

PlainText returns the plain text version of the rich text.

Transform creates a new stream where changes are modified before being appended or before being fetched. Both next and append are optional. Note tha

Transformed takes a store of raw operations and converts them to a transformed version that can be applied in sequence. The transformed Store only mo

Apply applies the change and returns the updated value Note: deleting an element via changes.Replace simply replaces it with nil. It does not actual

FormatBuilder converts any value to HTML If a formatter is provided, it is used for embedded objects

ID is the unique identifier for the operation. It should be of any type that can be compared for equality

Normalize ensures that distance is always positive

Parent is the ID of the local operation this particular operation is based upon. If this operaiton is based upon an operation that has a version at t

Polled implements a low-latency in memory poller. Any append will effectively trigger any pending polls to return. It can be used to wrap a store tha

ReverseMerge is used when a "known" change type is merged with a custom type: move.Merge(myType) The known type has no way of figuring out how to me

Basis is the last "stored" operation (i.e. with non-negative version) that has been factored in before the current operation. Example: If a client m

Concat joins two rich text values

NullCache implements ops.Cache but does not save anything

ApplyTo allows custom change types to implement a method to apply their changes onto known "values". This allows Value implementations to be written

Diff implemnets Differ.Diff for standard types

NewEmbed creates a text with an embedded object (such as data.link)

Append proxies the Append call over to the url

Apply implements changes.Value

Branch returns a new stream based on the provided stream. All changes made on the branch are only merged upstream when Push is called explicitly and a

Changes is the changes associated with this operation. It can be nil.

ColIDs returns all the column IDs sorted in order

Iterate calls the provided function for each Entry in the heap in descending order of Rank value.

Register registers the values with all the default codecs

RowIDs returns all the row IDs sorted in order

Version is the index of the operation in the sequential store. For operations that have not yet been stored (such as client operations), this must be

Apply applies the change and returns the updated value

BetweenOrd returns keys between the two provided keys.

Latest returns the latest non-nil entry in the stream

MapIndex maps a particular index to the new location of the index after the move