lib0

export function map<ARR extends ArrayLike<any>, MAPPER extends (arg0: ARR extends ArrayLike<infer T_1> ? T_1 : never, arg1: number, arg2: ARR) => any>(arr: ARR, mapper: MAPPER): MAPPER extends (...args: any[]) => infer M ? M : never[]

bubblesortItem

decl

export function bubblesortItem<T_1>(arr: T_1[], i: number, compareFn: (a: T_1, b: T_1) => number): number

from

decl

Transforms something array-like to an actual Array.

less

@function —

@template —

@param —

@return —

export const from: {

<T_1>(arrayLike: ArrayLike<T_1>): T_1[];

<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];

<T_1>(iterable: Iterable<T_1> | ArrayLike<T_1>): T_1[];

<T_1, U>(iterable: Iterable<T_1> | ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];

} = ...

isArray

decl

export const isArray: (arg: any) => arg is any[] = ...

}

binary

decl

Binary data constants.

export * as binary from {

BIT1

decl

n-th bit activated.

less

conditions

decl

export * as conditions from {

undefinedToNull

decl

decl

A Decoder handles the decoding of an Uint8Array.

less

@template —

export class Decoder<Buf extends ArrayBufferLike = ArrayBufferLike> {

@param — Binary data to decode

constructor(uint8Array: Uint8Array<Buf>)

Decoding target.

less

@type —

arr: Uint8Array<Buf>;

Current decoding position.

less

@type —

pos: number;

}

Referenced by

RleDecoder

decl

T must not be null.

less

@template —

export class RleDecoder<T> extends Decoder<ArrayBufferLike> {

@param —

less

@param —

constructor(uint8Array: Uint8Array, reader: (arg0: Decoder) => T)

The reader

reader: (arg0: Decoder) => T;

Current state

less

@type —

s: T | null;

read(): T;

}

IntDiffDecoder

decl

export class IntDiffDecoder extends Decoder<ArrayBufferLike> {

@param —

less

@param —

constructor(uint8Array: Uint8Array, start: number)

Current state

less

@type —

s: number;

@return —

read(): number;

}

RleIntDiffDecoder

decl

export class RleIntDiffDecoder extends Decoder<ArrayBufferLike> {

@param —

less

@param —

constructor(uint8Array: Uint8Array, start: number)

Current state

less

@type —

s: number;

@return —

read(): number;

}

UintOptRleDecoder

decl

export class UintOptRleDecoder extends Decoder<ArrayBufferLike> {

@param —

constructor(uint8Array: Uint8Array)

@type —

s: number;

read(): number;

}

Referenced by

StringDecoder

IncUintOptRleDecoder

decl

export class IncUintOptRleDecoder extends Decoder<ArrayBufferLike> {

@param —

constructor(uint8Array: Uint8Array)

@type —

s: number;

read(): number;

}

IntDiffOptRleDecoder

decl

export class IntDiffOptRleDecoder extends Decoder<ArrayBufferLike> {

@param —

constructor(uint8Array: Uint8Array)

@type —

s: number;

diff: number;

@return —

read(): number;

}

StringDecoder

decl

export class StringDecoder {

@param —

constructor(uint8Array: Uint8Array)

decoder: UintOptRleDecoder;

str: string;

@type —

spos: number;

@return —

remove: number;

insert: string;

}

SimpleDiff

decl

A SimpleDiff describes a change on a String.

less

console.log(a) // the old value
console.log(b) // the updated value
// Apply changes of diff (pseudocode)
a.remove(diff.index, diff.remove) // Remove `diff.remove` characters
a.insert(diff.index, diff.insert) // Insert `diff.insert`
a === b // values match

export type SimpleDiff<T extends string | any[]> = {

The index where changes were applied

index: number;

The number of characters to delete starting at index.

remove: number;

The new text to insert at index after applying

insert: T;

}

Referenced by

simpleDiffString
simpleDiff
simpleDiffArray

decl

export const domParser: DOMParser = ...

$element

decl

@type —

export const $element: Schema<Element> = ...

$text

decl

decl

@type —

cpos: number;

cbuf: Uint8Array<ArrayBuffer>;

@type —

bufs: Uint8Array[];

}

Referenced by

RleEncoder

decl

Now come a few stateful encoder that have their own classes.

less

Basic Run Length Encoder - a basic compression implementation.

Encodes [1,1,1,7] to [1,3,7,1] (3 times 1, 1 time 7). This encoder might do more harm than good if there are a lot of values that are not repeated.

It was originally used for image compression. Cool .. article http://csbruce.com/cbm/transactor/pdfs/trans_v7_i06.pdf

@note — T must not be null!

@template —

export class RleEncoder<T> extends Encoder {

@param —

constructor(writer: (arg0: Encoder, arg1: T) => void)

The writer

w: (arg0: Encoder, arg1: T) => void;

Current state

less

@type —

s: T | null;

@param —

write(v: T): void;

}

IntDiffEncoder

decl

Basic diff decoder using variable length encoding.

less

Encodes the values [3, 1100, 1101, 1050, 0] to [3, 1097, 1, -51, -1050] using writeVarInt.

export class IntDiffEncoder extends Encoder {

@param —

constructor(start: number)

Current state

less

@type —

s: number;

@param —

write(v: number): void;

}

RleIntDiffEncoder

decl

A combination of IntDiffEncoder and RleEncoder.

less

Basically first writes the IntDiffEncoder and then counts duplicate diffs using RleEncoding.

Encodes the values [1,1,1,2,3,4,5,6] as [1,1,0,2,1,5] (RLE([1,0,0,1,1,1,1,1]) ⇒ RleIntDiff[1,1,0,2,1,5])

export class RleIntDiffEncoder extends Encoder {

@param —

constructor(start: number)

Current state

less

@type —

s: number;

@param —

write(v: number): void;

}

UintOptRleEncoder

decl

Optimized Rle encoder that does not suffer from the mentioned problem of the basic Rle encoder.

less

Internally uses VarInt encoder to write unsigned integers. If the input occurs multiple times, we write write it as a negative number. The UintOptRleDecoder then understands that it needs to read a count.

Encodes [1,2,3,3,3] as [1,2,-3,3] (once 1, once 2, three times 3)

export class UintOptRleEncoder {

encoder: Encoder;

@type —

s: number;

@param —

write(v: number): void;

Flush the encoded state and transform this to a Uint8Array.

less

Note that this should only be called once.

toUint8Array(): Uint8Array<ArrayBuffer>;

}

Referenced by

StringEncoder

IncUintOptRleEncoder

decl

Increasing Uint Optimized RLE Encoder

less

The RLE encoder counts the number of same occurences of the same value. The IncUintOptRle encoder counts if the value increases. I.e. 7, 8, 9, 10 will be encoded as [-7, 4]. 1, 3, 5 will be encoded as [1, 3, 5].

export class IncUintOptRleEncoder {

encoder: Encoder;

@type —

s: number;

@param —

write(v: number): void;

Flush the encoded state and transform this to a Uint8Array.

less

Note that this should only be called once.

toUint8Array(): Uint8Array<ArrayBuffer>;

}

IntDiffOptRleEncoder

decl

A combination of the IntDiffEncoder and the UintOptRleEncoder.

less

The count approach is similar to the UintDiffOptRleEncoder, but instead of using the negative bitflag, it encodes in the LSB whether a count is to be read. Therefore this Encoder only supports 31 bit integers!

Encodes [1, 2, 3, 2] as [3, 1, 6, -1] (more specifically [(1 << 1) | 1, (3 << 0) | 0, -1])

Internally uses variable length encoding. Contrary to normal UintVar encoding, the first byte contains:

1 bit that denotes whether the next value is a count (LSB)
1 bit that denotes whether this value is negative (MSB - 1)
1 bit that denotes whether to continue reading the variable length integer (MSB)

Therefore, only five bits remain to encode diff ranges.

Use this Encoder only when appropriate. In most cases, this is probably a bad idea.

export class IntDiffOptRleEncoder {

encoder: Encoder;

@type —

s: number;

diff: number;

@param —

write(v: number): void;

Flush the encoded state and transform this to a Uint8Array.

less

Note that this should only be called once.

toUint8Array(): Uint8Array<ArrayBuffer>;

}

StringEncoder

decl

Optimized String Encoder.

less

Encoding many small strings in a simple Encoder is not very efficient. The function call to decode a string takes some time and creates references that must be eventually deleted. In practice, when decoding several million small strings, the GC will kick in more and more often to collect orphaned string objects (or maybe there is another reason?).

This string encoder solves the above problem. All strings are concatenated and written as a single string using a single encoding call.

The lengths are encoded using a UintOptRleEncoder.

export class StringEncoder {

@type —

sarr: string[];

s: string;

lensE: UintOptRleEncoder;

@param —

write(string: string): void;

toUint8Array(): Uint8Array<ArrayBuffer>;

}

AnyEncodableArray

decl

export type AnyEncodableArray = AnyEncodable[]

Referenced by

AnyEncodable

AnyEncodable

decl

export type AnyEncodable = undefined | null | number | bigint | boolean | string | {

[key: string]: AnyEncodable;

} | AnyEncodableArray | Uint8Array

Referenced by

writeAny
AnyEncodableArray
Fingerprintable

Color is enabled by default if the terminal supports it.

less

Explicitly enable color using --color parameter Disable color using --no-color parameter or using NO_COLOR=1 environment variable. FORCE_COLOR=1 enables color and takes precedence over all.

new (timeoutId: number): {

_: number;

destroy(): void;

};

} = ...

TimeoutObject

decl

export type TimeoutObject = {

destroy: Function;

}

Referenced by

timeout
interval
animationFrame
idleCallback

iterate

decl

iterateKeys

Value

v: any;

}

Referenced by

getAllKeysValues

}

iterator

decl

export * as iterator from {

mapIterator

decl

export function mapIterator<T, R>(iterator: Iterator<T>, f: (arg0: T) => R): IterableIterator<R>

createIterator

decl

export function createIterator<T>(next: () => IteratorResult<T>): IterableIterator<T>

decl

Transform JavaScript object to JSON.

less

@param —

@return —

export const stringify: {

(value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;

(value: any, replacer?: (number | string)[] | null, space?: string | number): string;

} = ...

parse

decl

Parse JSON object.

less

@param —

@return —

decl

decl

decl

export const parseInt: (string: string, radix?: number) => number = ...

decl

export function isEmpty(obj: Object | null | undefined): boolean

every

decl

export function every<T extends {

[key: string | number | symbol]: any;

}>(obj: T, f: (v: T[keyof T], k: keyof T) => boolean): boolean

hasProperty

decl

export function hasProperty(obj: any, key: string | number | symbol): boolean

equalFlat

decl

export function equalFlat(a: {

[key: string]: any;

}, b: {

decl

@param —

export const keys: {

(o: object): string[];

(o: {}): string[];

} = ...

values

decl

@template —

less

@param —

@return —

export const values: {

<T>(o: {

[key: string]: T;

} | ArrayLike<T>): T[];

(o: {}): any[];

} = ...

freeze

decl

Make an object immutable. This hurts performance and is usually not needed if you perform good coding practices.

export const freeze: {

<T extends Function>(f: T): T;

<T extends {

[key: string]: U | null | undefined | object;

}, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>;

<T>(o: T): Readonly<T>;

} = ...

}

pair

decl

@param —

less

@param —

constructor(left: L, right: R)

left: L;

right: R;

}

Referenced by

setAttributes
addEventListeners
removeEventListeners
element
pairToStyleString
pairsToStyleString
create
createReversed
forEach
map

This is a variant of xoroshiro128plus - the fastest full-period generator passing BigCrush without systematic failures.

less

This implementation follows the idea of the original xoroshiro128plus implementation, but is optimized for the JavaScript runtime. I.e.

The operations are performed on 32bit integers (the original implementation works with 64bit values).
The initial 128bit state is computed based on a 32bit seed and Xorshift32.
This implementation returns two 32bit values based on the 64bit value that is computed by xoroshiro128plus. Caution: The last addition step works slightly different than in the original implementation - the add carry of the first 32bit addition is not carried over to the last 32bit.

Reference implementation

class Xoroshiro128plus {

@param — Unsigned 32 bit number

constructor(seed: number)

seed: number;

state: Uint32Array<ArrayBuffer>;

_fresh: boolean;

@return — Float/Double in [0,1)

next(): number;

}

Referenced by

DefaultPRNG

generatorNext

decl

Description of the function

export type generatorNext = () => number

Referenced by

PRNG

PRNG

decl

A random type generator.

export type PRNG = {

Generate new number

next: generatorNext;

}

Referenced by

random
create
bool
int53
uint53
int32
uint32
int31
real53
char
letter
word
utf16Rune
utf16String
oneOf
uint8Array
uint16Array
uint32Array
TestCase
random

@param —

@return —

export const all: {

<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;

<T extends readonly unknown[] | []>(values: T): Promise<{

-readonly [P in keyof T]: Awaited<T[P]>;

}>;

} = ...

PromiseResolve

decl

export type PromiseResolve<T> = (result?: T | PromiseLike<T> | undefined) => any

Referenced by

create

}

set

decl

export * as set from {

create

decl

export function create(): Set<any>

toArray

decl

export function toArray<T>(set: Set<T>): T[]

first

decl

export function first<T>(set: Set<T>): T | undefined

from

decl

export function from<T>(entries: Iterable<T>): Set<T>

}

sort

decl

export * as sort from {

_insertionSort

decl

export function _insertionSort<T>(arr: T[], lo: number, hi: number, compare: (arg0: T, arg1: T) => number): void

insertionSort

decl

export function insertionSort<T>(arr: T[], compare: (arg0: T, arg1: T) => number): void

quicksort

decl

export function quicksort<T>(arr: T[], compare: (arg0: T, arg1: T) => number): void

}

statistics

decl

export * as statistics from {

decl

export function isSymbol(s: any): boolean

create

decl

Return fresh symbol.

export const create: SymbolConstructor = ...

}

time

decl

export * as time from {

getDate

decl

export function getDate(): Date

humanizeDuration

decl

export function humanizeDuration(d: number): string

getUnixTime

decl

Return current unix time.

less

@return —

export const getUnixTime: () => number = ...

}

tree

decl

export * as tree from {

Tree

decl

This is a Red Black Tree implementation

less

@template —

export class Tree<K, V> {

root: any;

length: number;

@param —

findNext(id: K): V;

@param —

findPrev(id: K): V;

@param —

findNodeWithLowerBound(from: K): any;

@param —

findNodeWithUpperBound(to: K): any;

@return —

findSmallestNode(): V;

@param —

less

@return —

findWithLowerBound(from: K): V;

@param —

less

@return —

findWithUpperBound(to: K): V;

@param —

less

@param —

iterate(from: K, to: any, f: (arg0: V) => void): void;

@param —

less

@return —

find(id: K): V | null;

@param —

less

@return —

findNode(id: K): N<V> | null;

@param —

delete(id: K): void;

_fixDelete(n: any): void;

put(v: any): any;

_fixInsert(n: any): void;

}

Unexported symbols referenced here

N

decl

@template —

class N<V> {

A created node is always red!

less

@param —

constructor(val: V)

val: V;

color: boolean;

_left: any;

_right: any;

_parent: any;

isRed(): boolean;

isBlack(): boolean;

redden(): this;

blacken(): this;

get grandparent(): any;

get parent(): any;

get sibling(): any;

set left(n: any);

get left(): any;

set right(n: any);

get right(): any;

rotateLeft(tree: any): void;

next(): any;

prev(): any;

rotateRight(tree: any): void;

getUncle(): any;

}

Referenced by

Tree

}

websocket

decl

export * as websocket from {

WebsocketClient

decl

@deprecated —

less

@extends —

export class WebsocketClient extends Observable<string> {

@param —

less

@param —

constructor(url: string, { binaryType }?: {

binaryType?: "arraybuffer" | "blob" | null | undefined;

})

url: string;

@type —

ws: WebSocket | null;

binaryType: "arraybuffer" | "blob" | null;

connected: boolean;

connecting: boolean;

unsuccessfulReconnects: number;

lastMessageReceived: number;

Whether to connect to other peers or not

less

@type —

shouldConnect: boolean;

_checkInterval: Timeout;

@param —

send(message: any): void;

disconnect(): void;

decl

bubblesortItem

decl

export function bubblesortItem<T_1>(arr: T_1[], i: number, compareFn: (a: T_1, b: T_1) => number): number

from

decl

Transforms something array-like to an actual Array.

less

@function —

@template —

@param —

@return —

export const from: {

<T_1>(arrayLike: ArrayLike<T_1>): T_1[];

<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];

<T_1>(iterable: Iterable<T_1> | ArrayLike<T_1>): T_1[];

<T_1, U>(iterable: Iterable<T_1> | ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];

} = ...

isArray

decl

export const isArray: (arg: any) => arg is any[] = ...

}

binary

decl

Binary data constants.

module "binary" {

BIT1

decl

n-th bit activated.

less

export class Cache<K, V> {

@param —

constructor(timeout: number)

timeout: number;

@type —

_q: List<Entry<K, V>>;

@type —

_map: Map<K, Entry<K, V>>;

}

Referenced by

removeStale
set
get
refreshTimeout
getAsync
remove
setIfUndefined
create

Unexported symbols referenced here

Entry

decl

@template —

less

@implements —

class Entry<K, V> implements ListNode {

@param —

less

@param —

constructor(key: K, val: V | Promise<V>)

@type —

prev: this | null;

@type —

next: this | null;

created: number;

val: V | Promise<V>;

key: K;

}

Referenced by

Cache

@type —

export const registry: CustomElementRegistry = ...

Lib0Component

decl

@template —

export class Lib0Component<S> extends HTMLElement {

@param —

constructor(state?: S)

@type —

state: S | null;

@type —

_internal: any;

@param —

less

@param — Force that the state is rerendered even if state didn't change

setState(_state: S, _forceStateUpdate?: boolean): void;

@param —

updateState(_stateUpdate: any): void;

}

Referenced by

createComponent
CONF

CONF

decl

export type CONF<S> = {

Template for the shadow dom.

template?: string | null | undefined;

shadow dom style. Is only used when CONF.template is defined

style?: string | undefined;

Initial component state.

state?: S | undefined;

Called when the state changes.

onStateChange?: ((arg0: S, arg1: S | null, arg2: Lib0Component<S>) => void) | undefined;

maps from CSS-selector to transformer function. The first element that matches the CSS-selector receives state updates via the transformer function.

childStates?: {

[key: string]: (arg0: any, arg1: any) => Object;

} | undefined;

attrs-keys and state-keys should be camelCase, but the DOM uses kebap-case. I.e. attrs = { myAttr: 4 } is represeted as <my-elem my-attr="4" /> in the DOM

attrs?: {

[key: string]: "string" | "number" | "json" | "bool";

} | undefined;

Maps from dom-event-name to event listener.

listeners?: {

[key: string]: (arg0: CustomEvent, arg1: Lib0Component<any>) => boolean | void;

} | undefined;

Fill slots automatically when state changes. Maps from slot-name to slot-html.

slots?: ((arg0: S, arg1: S, arg2: Lib0Component<S>) => {

[key: string]: string;

}) | undefined;

}

Referenced by

createComponent

}

conditions

decl

module "conditions" {

undefinedToNull

decl

export function undefinedToNull<T>(v: T | null | undefined): T | null

}

lib0/crypto/jwt

decl

module "lib0/crypto/jwt" {

encodeJwt

decl

export function encodeJwt(privateKey: CryptoKey, payload: Object): PromiseLike<string>

verifyJwt

decl

export function verifyJwt(publicKey: CryptoKey, jwt: string): Promise<{

header: any;

payload: any;

unsafeDecode

decl

export function unsafeDecode(jwt: string): {

header: any;

decl

export type Usages = "encrypt" | "decrypt"[]

Referenced by

importKeyJwk
importKeyRaw
deriveKey

exportKeyJwk

decl

export function exportKeyJwk(key: CryptoKey): Promise<JsonWebKey>

exportKeyRaw

decl

}> | {

[key: string | number]: any;

} = Schema<{}>, ChildrenSchema extends unknown = Schema<never>, HasText extends boolean = false, Recursive extends boolean = false, Formats extends {

[key: string]: any;

} = {

[key: string]: any;

}>({ name, attrs, children, text, formats, recursive }: {

name?: NodeNameSchema | null | undefined;

attrs?: AttrsSchema | null | undefined;

children?: ChildrenSchema | null | undefined;

text?: HasText | undefined;

formats?: Formats | undefined;

recursive?: Recursive | undefined;

}): [Unwrap<ReadSchema<NodeNameSchema>>, Unwrap<ReadSchema<AttrsSchema>>, Unwrap<ReadSchema<ChildrenSchema>>] extends [infer NodeName_1, infer Attrs_1, infer Children_1] ? Schema<Delta<NodeName_1, Attrs_1, Children_1 | (Recursive extends true ? RecursiveDelta<NodeName_1, Attrs_1, Children_1, HasText extends true ? string : never> : never), HasText extends true ? string : never>> : never

_$delta

decl

export function _$delta<NodeNameSchema extends Schema<string> | string | string[] = Schema<any>, AttrsSchema extends Schema<{

[key: string | number]: any;

}> | {

[key: string | number]: any;

} = Schema<{}>, ChildrenSchema extends unknown = Schema<never>, HasText extends boolean = false, Recursive extends boolean = false>({ name, attrs, children, text, recursive }: {

name?: NodeNameSchema | null | undefined;

attrs?: AttrsSchema | null | undefined;

children?: ChildrenSchema | null | undefined;

text?: HasText | undefined;

recursive?: Recursive | undefined;

mergeAttrs

decl

export function mergeAttrs<T extends {

[key: string]: any;

}>(a: T | null, b: T | null): T | null

mergeDeltas

decl

export function mergeDeltas<D extends DeltaAny | null>(a: D, b: D): D

random

decl

export function random<D extends DeltaAny>(gen: PRNG, $d: Schema<D>): D extends Delta<infer NodeName_1, infer Attrs_1, infer Children_1, infer Text, infer Schema_1> ? DeltaBuilder<NodeName_1, Attrs_1, Children_1, Text, Schema_1> : never

create

decl decl decl decl decl

@overload —

export function create(): DeltaBuilder<any, {}, never, never, null>

@template —

less

@overload —

export function create<NodeName extends string>(nodeName: NodeName): DeltaBuilder<NodeName, {}, never, never, null>

@template —

less

@template —

@overload —

export function create<NodeName extends string, Schema extends Schema<DeltaAny>>(nodeName: NodeName, schema: Schema): Schema extends Schema<Delta<infer N, infer Attrs_1, infer Children_1, infer Text, any>> ? DeltaBuilder<NodeName, Attrs_1, Children_1, Text, Schema> : never

@template —

less

@overload —

export function create<Schema extends Schema<DeltaAny>>(schema: Schema): Schema extends Schema<Delta<infer N, infer Attrs_1, infer Children_1, infer Text, any>> ? DeltaBuilder<N, Attrs_1, Children_1, Text, Schema> : never

@template —

less

@template —

@overload —

export function create<NodeName extends string, Attrs extends {

@type —

export const $deltaMapChangeJson: Schema<DeltaAttrOpJSON> = ...

TextOp

decl

export class TextOp extends ListNode {

@param —

less

@param —

constructor(insert: string, format: FormattingAttributes | null, attribution: Attribution | null)

@readonly —

less

@type —

readonly insert: string;

@readonly —

less

@type —

readonly format: FormattingAttributes | null;

attribution: Attribution | null;

@type —

_fingerprint: string | null;

@param —

_updateInsert(newVal: string): void;

get type(): "insert";

get length(): number;

get fingerprint(): string;

Remove a part of the operation (similar to Array.splice)

less

@param —

_splice(offset: number, len: number): this;

@return —

toJSON(): DeltaListOpJSON;

@return —

clone(start?: number, end?: number): TextOp;

@param —

[equalityTrait.EqualityTraitSymbol](other: TextOp): boolean;

}

Referenced by

$textOp
$anyOp
Delta
DeltaOps
ChildrenOpAny

InsertOp

decl

@template —

export class InsertOp<ArrayContent extends Fingerprintable> extends ListNode {

@param —

less

@param —

constructor(insert: ArrayContent[], format: FormattingAttributes | null, attribution: Attribution | null)

@readonly —

less

@type —

readonly insert: ArrayContent[];

@readonly —

less

@type —

readonly format: FormattingAttributes | null;

@readonly —

less

@type —

readonly attribution: Attribution | null;

@type —

_fingerprint: string | null;

@param —

_updateInsert(newVal: ArrayContent): void;

get type(): "insert";

get length(): number;

@param —

less

@return —

_modValue(i: number): Extract<ArrayContent, DeltaAny>;

get fingerprint(): string;

Remove a part of the operation (similar to Array.splice)

less

@param —

_splice(offset: number, len: number): this;

@return —

toJSON(): DeltaListOpJSON;

@return —

clone(start?: number, end?: number): InsertOp<ArrayContent>;

@param —

[equalityTrait.EqualityTraitSymbol](other: InsertOp<ArrayContent>): boolean;

}

Referenced by

$insertOpWith
$insertOp
$anyOp
Delta
DeltaOps
ChildrenOpAny

DeleteOp

decl

@template —

less

@template —

export class DeleteOp<Children extends Fingerprintable = never, Text extends string = never> extends ListNode {

@param —

constructor(len: number)

delete: number;

@type —

prevValue: (Children | Text) extends never ? null : (Delta<any, {}, Children, Text> | null);

@type —

_fingerprint: string | null;

get type(): "delete";

get length(): number;

get fingerprint(): string;

Remove a part of the operation (similar to Array.splice)

less

@param —

_splice(_offset: number, len: number): this;

@return —

toJSON(): DeltaListOpJSON;

clone(start?: number, end?: number): DeleteOp<never, never>;

@param —

[equalityTrait.EqualityTraitSymbol](other: DeleteOp): boolean;

}

Referenced by

$deleteOp
$anyOp
Delta
DeltaOps
ChildrenOpAny

RetainOp

decl

export class RetainOp extends ListNode {

@param —

less

@param —

constructor(retain: number, format: FormattingAttributes | null, attribution: Attribution | null)

@readonly —

less

@type —

readonly retain: number;

@readonly —

less

@type —

readonly format: FormattingAttributes | null;

@readonly —

less

@type —

readonly attribution: Attribution | null;

@type —

_fingerprint: string | null;

get type(): "retain";

get length(): number;

get fingerprint(): string;

Remove a part of the operation (similar to Array.splice)

less

@param —

_splice(_offset: number, len: number): this;

@return —

toJSON(): DeltaListOpJSON;

clone(start?: number, end?: number): RetainOp;

@param —

[equalityTrait.EqualityTraitSymbol](other: RetainOp): boolean;

}

Referenced by

$retainOp
Delta
ChildrenOpAny

ModifyOp

decl

Delta that can be applied on a YType Embed

less

@template —

export class ModifyOp<DTypes extends DeltaAny = DeltaAny> extends ListNode {

@param —

less

@param —

constructor(delta: DTypes, format: FormattingAttributes | null, attribution: Attribution | null)

@readonly —

less

@type —

readonly value: DTypes;

@readonly —

less

@type —

readonly format: FormattingAttributes | null;

@readonly —

less

@type —

readonly attribution: Attribution | null;

@type —

_fingerprint: string | null;

get type(): "modify";

get length(): number;

get _modValue(): DeltaBuilderAny;

get fingerprint(): string;

Remove a part of the operation (similar to Array.splice)

less

@param —

_splice(_offset: number, _len: number): this;

@return —

toJSON(): DeltaListOpJSON;

@return —

clone(): ModifyOp<DTypes>;

@param —

[equalityTrait.EqualityTraitSymbol](other: ModifyOp<any>): boolean;

}

Referenced by

$modifyOpWith
$modifyOp
$anyOp
Delta
DeltaOps
ChildrenOpAny

AttrInsertOp

decl

@template —

less

@template —

export class AttrInsertOp<V extends Fingerprintable, K extends string | number = any> {

@param —

less

@param —

constructor(key: K, value: V, prevValue: V | undefined, attribution: Attribution | null)

@readonly —

less

@type —

readonly key: K;

@readonly —

less

@type —

readonly value: V;

@readonly —

less

@type —

readonly prevValue: V | undefined;

@readonly —

less

@type —

readonly attribution: Attribution | null;

@type —

_fingerprint: string | null;

get type(): "insert";

get _modValue(): DeltaBuilderAny;

get fingerprint(): string;

toJSON(): {

type: "insert";

value: V | DeltaJSON;

} & (({

attribution: Attribution;

} | {

attribution?: undefined;

}) & ({

prevValue: V & {};

} | {

prevValue?: undefined;

}));

@return —

clone(): AttrInsertOp<V, K>;

@param —

[equalityTrait.EqualityTraitSymbol](other: AttrInsertOp<V>): boolean;

}

Referenced by

$insertOpWith
$insertOp
$anyOp
Delta
DeltaOps
AttrOpAny

AttrDeleteOp

decl

@template —

less

@template —

export class AttrDeleteOp<V, K extends string | number = string> {

@param —

less

@param —

constructor(key: K, prevValue: V | undefined, attribution: Attribution | null)

@type —

key: K;

@type —

prevValue: V | undefined;

attribution: Attribution | null;

@type —

_fingerprint: string | null;

get value(): undefined;

get type(): "delete";

get fingerprint(): string;

@return —

toJSON(): DeltaAttrOpJSON;

clone(): AttrDeleteOp<V, K>;

@param —

[equalityTrait.EqualityTraitSymbol](other: AttrDeleteOp<V>): boolean;

}

Referenced by

$deleteOp
$anyOp
Delta
DeltaOps
AttrOpAny

AttrModifyOp

decl

@template —

less

@template —

export class AttrModifyOp<Modifier extends DeltaAny = DeltaAny, K extends string | number = string> {

@param —

less

@param —

constructor(key: K, delta: Modifier)

@readonly —

less

@type —

readonly key: K;

@readonly —

less

@type —

readonly value: Modifier;

@type —

_fingerprint: string | null;

get type(): "modify";

get fingerprint(): string;

get _modValue(): DeltaBuilder;

@return —

toJSON(): DeltaAttrOpJSON;

@return —

clone(): AttrModifyOp<Modifier, K>;

@param —

[equalityTrait.EqualityTraitSymbol](other: AttrModifyOp<Modifier>): boolean;

}

Referenced by

$modifyOpWith
$modifyOp
$anyOp
Delta
DeltaOps
AttrOpAny

@template —

less

@template —

@typedef —

@template —

@typedef —

@template —

@typedef —

@template —

@typedef —

@template —

@typedef —

@template —

export class Delta<NodeName extends string = any, Attrs extends {

[key: string | number]: any;

} = {}, Children extends Fingerprintable = never, Text extends string = never, Schema extends Schema<Delta<any, any, any, any, any>> | null = any> {

@param —

less

@param —

constructor(name?: NodeName, $schema?: Schema)

$schema: NonNullable<Schema> | null;

@type —

attrs: {

[K in keyof Attrs]?: K extends string | number ? (AttrInsertOp<Attrs[K], K> | AttrDeleteOp<Attrs[K], K> | (Delta extends Attrs[K] ? AttrModifyOp<Extract<Attrs[K], DeltaAny>, K> : never)) : never;

} & {

[Symbol.iterator]: () => Iterator<{

[K in keyof Attrs]: K extends string | number ? (AttrInsertOp<Attrs[K], K> | AttrDeleteOp<Attrs[K], K> | (Delta extends Attrs[K] ? AttrModifyOp<Extract<Attrs[K], DeltaAny>, K> : never)) : never;

}[keyof Attrs]>;

};

@type —

children: List<RetainOp | DeleteOp | (Text extends never ? never : TextOp) | (Children extends never ? never : InsertOp<Children>) | (Delta extends Children ? ModifyOp<Extract<Children, Delta<any, any, any, any, any>>> : never)>;

childCnt: number;

@type —

origin: any;

@type —

_fingerprint: string | null;

isDone: boolean;

get fingerprint(): string;

isEmpty(): boolean;

@return —

toJSON(): DeltaJSON;

@param —

less

@return —

equals(other: Delta<any, any, any, any, any>): boolean;

@return —

clone(): DeltaBuilder<NodeName, Attrs, Children, Text, Schema>;

@param —

less

@param —

@return —

slice(start?: number, end?: number): DeltaBuilder<NodeName, Attrs, Children, Text, Schema>;

Mark this delta as done and perform some cleanup (e.g. remove appended retains without formats&attributions). In the future, there might be additional merge operations that can be performed to result in smaller deltas. Set markAsDone=false to only perform the cleanup.

less

@return —

done(markAsDone?: boolean): Delta<NodeName, Attrs, Children, Text, Schema>;

[fingerprintTrait.FingerprintTraitSymbol](): string;

@param —

less

@return —

[equalityTrait.EqualityTraitSymbol](other: any): boolean;

}

Referenced by

$delta
_$delta
random
create
text
diff
DeleteOp
DeltaBuilder
$Delta
AllowedDeltaFromSchema
DeltaAny
CastToDelta
RecursiveDelta
TextDelta
ArrayDelta
MapDelta

DeltaBuilder

decl

@template —

less

@template —

@extends —

export class DeltaBuilder<NodeName extends string = any, Attrs extends {

[key: string | number]: any;

} = {}, Children extends Fingerprintable = never, Text extends string = never, Schema extends Schema<Delta<any, any, any, any, any>> | null = any> extends Delta<NodeName, Attrs, Children, Text, Schema> {

@type —

usedAttributes: FormattingAttributes | null;

@type —

usedAttribution: Attribution | null;

@param —

useAttribution(attribution: Attribution | null): this;

@param —

less

@return —

useAttributes(attributes: FormattingAttributes | null): this;

@param —

less

@param —

updateUsedAttributes(name: string, value: any): this;

@template —

less

@param —

updateUsedAttribution<NAME extends keyof Attribution>(name: NAME, value: Attribution[NAME] | null): this;

@template —

less

@param —

@return —

insert<NewContent extends AllowedDeltaFromSchema<Schema> extends Delta<any, any, infer Children_1, infer Text_1, infer Schema_1> ? ((Children_1 extends never ? never : Children_1[]) | Text_1) : never>(insert: NewContent, formatting?: FormattingAttributes | null, attribution?: Attribution | null): DeltaBuilder<NodeName, Attrs, Exclude<NewContent, string>[number] | Children, (Extract<NewContent, string> | Text) extends never ? never : string, Schema>;

@template —

less

@param —

@return —

modify<NewContent extends AllowedDeltaFromSchema<Schema> extends Delta<any, any, infer Children_1, any, any> ? Extract<Children_1, Delta<any, any, any, any, any>> : never>(modify: NewContent, formatting?: FormattingAttributes | null, attribution?: Attribution | null): DeltaBuilder<NodeName, Attrs, Exclude<NewContent, string>[number] | Children, (Extract<NewContent, string> | Text) extends string ? string : never, Schema>;

@param —

less

@param —

retain(len: number, format?: FormattingAttributes | null, attribution?: Attribution | null): this;

@param —

delete(len: number): this;

@template —

less

@template —

@param —

@return —

set<Key extends AllowedDeltaFromSchema<Schema> extends Delta<any, infer Attrs_1, any, any, any> ? (keyof Attrs_1) : never, Val extends AllowedDeltaFromSchema<Schema> extends Delta<any, infer Attrs_1, any, any, any> ? (Attrs_1[Key]) : never>(key: Key, val: Val, attribution?: Attribution | null, prevValue?: Val | undefined): DeltaBuilder<NodeName, {

[K in keyof AddToAttrs<Attrs, Key, Val>]: AddToAttrs<Attrs, Key, Val>[K];

}, Children, Text, Schema>;

@template —

less

@param —

@return —

setMany<NewAttrs extends AllowedDeltaFromSchema<Schema> extends Delta<any, infer Attrs_1, any, any, any> ? Attrs_1 : never>(attrs: NewAttrs, attribution?: Attribution | null): DeltaBuilder<NodeName, {

[K in keyof MergeAttrs<Attrs, NewAttrs>]: MergeAttrs<Attrs, NewAttrs>[K];

}, Children, Text, Schema>;

@template —

less

@param —

@return —

unset<Key extends AllowedDeltaFromSchema<Schema> extends Delta<any, infer As, any, any, any> ? keyof As : never>(key: Key, attribution?: Attribution | null, prevValue?: any): DeltaBuilder<NodeName, {

[K in keyof AddToAttrs<Attrs, Key, never>]: AddToAttrs<Attrs, Key, never>[K];

}, Children, Text, Schema>;

@template —

less

@template —

@param —

@return —

update<Key extends AllowedDeltaFromSchema<Schema> extends Delta<any, infer As, any, any, any> ? {

[K in keyof As]: Extract<As[K], Delta<any, any, any, any, any>> extends never ? never : K;

}[keyof As] : never, D extends AllowedDeltaFromSchema<Schema> extends Delta<any, infer As, any, any, any> ? Extract<As[Key], Delta<any, any, any, any, any>> : never>(key: Key, modify: D): DeltaBuilder<NodeName, {

[K in keyof AddToAttrs<Attrs, Key, D>]: AddToAttrs<Attrs, Key, D>[K];

}, Children, Text, Schema>;

@param —

apply(other: Delta<NodeName, Attrs, Children, Text, any>): this;

@param —

less

@param —

rebase(other: DeltaAny, priority: boolean): this;

Same as doing delta.rebase(other.inverse()), without creating a temporary delta.

less

@param —

rebaseOnInverse(other: DeltaAny, priority: boolean): this;

Append child ops from one op to the other.

less

delta.create().insert('a').append(delta.create().insert('b')) // => insert "ab"

@template —

@param —

@return —

append<OtherDelta extends DeltaAny>(other: OtherDelta): CastToDelta<OtherDelta> extends Delta<any, any, infer OtherChildren, infer OtherText, any> ? DeltaBuilder<NodeName, Attrs, Children | OtherChildren, Text | OtherText, Schema> : never;

}

Referenced by

clone
random
create
text
array
map
diff
Delta
DeltaBuilderAny
CastToDelta
TextDeltaBuilder
ArrayDeltaBuilder
MapDeltaBuilder

$Delta

decl

@template —

less

@typedef —

@template —

@typedef —

@template —

@extends —

export class $Delta<Name extends string, Attrs extends {

[key: string | number]: any;

}, Children extends Fingerprintable, HasText extends boolean, Formats extends {

[key: string]: any;

}, Recursive extends boolean> extends Schema<Delta<Name, Attrs, Children | (Recursive extends true ? RecursiveDelta<Name, Attrs, Children, HasText extends true ? string : never> : never), HasText extends true ? string : never, any>> {

@param —

less

@param —

constructor($name: Schema<Name>, $attrs: Schema<Attrs>, $children: Schema<Children>, hasText: HasText, $formats: Schema<Formats>, recursive: Recursive)

shape: {

$name: Schema<Name>;

$attrs: Schema<Attrs> | Schema<Partial<$ObjectToType<{

[key: string]: Schema<any>;

[key: number]: Schema<any>;

[key: symbol]: Schema<any>;

}>>>;

$children: Schema<Children>;

hasText: HasText;

$formats: Schema<Formats>;

};

}

Referenced by

$$delta

$$delta

decl

export const $$delta: Schema<$Delta<string, {

[key: string]: any;

[key: number]: any;

}, Fingerprintable, boolean, {

[key: string]: any;

}, boolean>> = ...

$deltaAny

decl

@type —

export const $deltaAny: Schema<DeltaAny> = ...

$deltaBuilderAny

decl

@type —

export const $deltaBuilderAny: Schema<DeltaBuilderAny> = ...

$textOnly

decl

export const $textOnly: Schema<TextDelta<unknown>> = ...

Attribution

decl

export type Attribution = {

insert?: string[];

insertAt?: number;

delete?: string[];

deleteAt?: number;

format?: Record<string, string[]>;

formatAt?: number;

}

Referenced by

$attribution
TextOp
InsertOp
RetainOp
ModifyOp
AttrInsertOp
AttrDeleteOp
DeltaBuilder
DeltaListOpJSON
DeltaAttrOpJSON

DeltaOps

decl

FormattingAttributes

decl

export type FormattingAttributes = {

[key: string]: any;

}

Referenced by

TextOp
InsertOp
RetainOp
ModifyOp
DeltaBuilder

DeltaJSON

decl

export type DeltaJSON = {

type: "delta";

name?: string;

attrs?: {

[Key in string | number]: DeltaAttrOpJSON;

};

children?: DeltaListOpJSON[];

}

Referenced by

AttrInsertOp
Delta
DeltaAttrOpJSON

DeltaListOpJSON

decl

export type DeltaListOpJSON = {

type: "insert";

insert: string | any[];

format?: {

[key: string]: any;

};

attribution?: Attribution;

} | {

delete: number;

} | {

type: "retain";

retain: number;

format?: {

[key: string]: any;

};

attribution?: Attribution;

} | {

type: "modify";

value: object;

}

Referenced by

TextOp
InsertOp
DeleteOp
RetainOp
ModifyOp
DeltaJSON

DeltaAttrOpJSON

decl

export type DeltaAttrOpJSON = {

type: "insert";

value: any;

prevValue?: any;

attribution?: Attribution;

} | {

type: "delete";

prevValue?: any;

attribution?: Attribution;

} | {

type: "modify";

value: DeltaJSON;

}

Referenced by

$deltaMapChangeJson
AttrDeleteOp
AttrModifyOp
DeltaJSON

ChildrenOpAny

decl

export type ChildrenOpAny = TextOp | InsertOp<any> | DeleteOp | RetainOp | ModifyOp<any>

Referenced by

_OpAny

AttrOpAny

decl

export type AttrOpAny = AttrInsertOp<any> | AttrDeleteOp<any> | AttrModifyOp

Referenced by

_OpAny

_OpAny

decl

export type _OpAny = ChildrenOpAny | AttrOpAny

MergeListArrays

decl

export type MergeListArrays<C1 extends any[] | string, C2 extends any[] | string> = Extract<C1 | C2, any[]> extends never ? never : ((Extract<C1 | C2, any[]> extends infer AC1[] ? (unknown extends AC1 ? never : AC1) : never)[])

AddToAttrs

decl

export type AddToAttrs<Attrs_1 extends {

[Key in string | number]: any;

}, Key extends string | number, Val extends unknown> = {

[K in (Key | keyof Attrs_1)]: (unknown extends Attrs_1[K] ? never : Attrs_1[K]) | (Key extends K ? Val : never);

}

Referenced by

DeltaBuilder

MergeAttrs

decl

export type MergeAttrs<Attrs_1 extends {

[Key in string | number | symbol]: any;

}, NewAttrs extends {

[Key in string | number | symbol]: any;

}> = {

[K in (keyof NewAttrs | keyof Attrs_1)]: (unknown extends Attrs_1[K] ? never : Attrs_1[K]) | (unknown extends NewAttrs[K] ? never : NewAttrs[K]);

}

Referenced by

DeltaBuilder

_AnyToNull

decl

export type _AnyToNull<X> = 0 extends (1 & X) ? null : X

Referenced by

$text
AllowedDeltaFromSchema

AllowedDeltaFromSchema

decl

export type AllowedDeltaFromSchema<Schema_1 extends Schema<Delta<any, any, any, any, any>> | null> = _AnyToNull<Schema_1> extends null ? Delta<any, {

[key: string | number]: any;

}, any, string> : (Schema_1 extends Schema<infer D> ? D : never)

Referenced by

DeltaBuilder

DeltaAny

decl

export type DeltaAny = Delta<any, {

[key: string | number]: any;

}, any, any, any>

Referenced by

$modifyOpWith
clone
mergeDeltas
random
create
diff
InsertOp
ModifyOp
AttrModifyOp
$anyOp
Delta
DeltaBuilder
$deltaAny
DeltaOps
CastToDelta

DeltaBuilderAny

decl

export type DeltaBuilderAny = DeltaBuilder<any, {

[key: string | number]: any;

}, any, any, any>

Referenced by

$deltaBuilderAny

CastToDelta

decl

export type CastToDelta<D extends DeltaAny> = D extends DeltaBuilder<infer N, infer Attrs_1, infer Children_1, infer Text, infer Schema_1> ? Delta<N, Attrs_1, Children_1, Text, Schema_1> : D

Referenced by

DeltaBuilder

RecursiveDelta

decl

export type RecursiveDelta<NodeName_1 extends string, Attrs_1 extends {

[key: string | number]: any;

} = {}, Children_1 extends Fingerprintable | never = never, Text extends string | never = never> = Delta<NodeName_1, Attrs_1, Children_1 | Delta<NodeName_1, Attrs_1, Children_1, Text> | RecursiveDelta<NodeName_1, Attrs_1, Children_1, Text>, Text>

Referenced by

$delta
_$delta
$Delta

TextDelta

decl

export type TextDelta<Embeds extends Fingerprintable = never> = Delta<any, {}, Embeds, string>

Referenced by

$text
$textOnly

TextDeltaBuilder

decl

export type TextDeltaBuilder<Embeds extends Fingerprintable = never> = DeltaBuilder<any, {}, Embeds, string>

ArrayDelta

decl

export type ArrayDelta<Children_1 extends Fingerprintable> = Delta<any, {}, Children_1, never>

Referenced by

$array
array

ArrayDeltaBuilder

decl

export type ArrayDeltaBuilder<Children_1 extends Fingerprintable> = DeltaBuilder<any, {}, Children_1, never>

Referenced by

array

MapDelta

decl

export type MapDelta<Attrs_1 extends {

[key: string | number]: any;

}> = Delta<any, Attrs_1, never, never>

Referenced by

$map
map

MapDeltaBuilder

decl

export type MapDeltaBuilder<Attrs_1 extends {

[key: string | number]: any;

}> = DeltaBuilder<any, Attrs_1, never, never>

decl

export type Usages = "sign" | "verify"[]

Referenced by

generateKeyPair
importKeyJwk
importKeyRaw

export {

exportKeyJwk,

exportKeyRaw,

decl

export function importKeyJwk(jwk: any, { extractable, usages }?: {

extractable?: boolean | undefined;

usages?: Usages | undefined;

}): Promise<CryptoKey>

export {

exportKeyJwk,

} from "lib0/crypto/aes-gcm"

Usages

decl

export type Usages = "encrypt" | "decrypt"[]

Referenced by

generateKeyPair
importKeyJwk

export class RabinEncoder {

@param — assert(m[0] === 1)

constructor(m: Uint8Array)

m: Uint8Array<ArrayBufferLike>;

blen: number;

bs: Uint8Array<ArrayBuffer>;

cache: Uint8Array<ArrayBuffer>;

This describes the position of the most significant byte (starts with 0 and increases with shift)

bpos: number;

@param —

write(byte: number): void;

getFingerprint(): Uint8Array<ArrayBuffer>;

}

lib0/hash/sha256

decl

module "lib0/hash/sha256" {

digest

decl

decl

A Decoder handles the decoding of an Uint8Array.

less

@template —

export class Decoder<Buf extends ArrayBufferLike = ArrayBufferLike> {

@param — Binary data to decode

constructor(uint8Array: Uint8Array<Buf>)

Decoding target.

less

@type —

arr: Uint8Array<Buf>;

Current decoding position.

less

@type —

pos: number;

}

Referenced by

RleDecoder

decl

T must not be null.

less

@template —

export class RleDecoder<T> extends Decoder<ArrayBufferLike> {

@param —

less

@param —

constructor(uint8Array: Uint8Array, reader: (arg0: Decoder) => T)

The reader

reader: (arg0: Decoder) => T;

Current state

less

@type —

s: T | null;

read(): T;

}

IntDiffDecoder

decl

export class IntDiffDecoder extends Decoder<ArrayBufferLike> {

@param —

less

@param —

constructor(uint8Array: Uint8Array, start: number)

Current state

less

@type —

s: number;

@return —

read(): number;

}

RleIntDiffDecoder

decl

export class RleIntDiffDecoder extends Decoder<ArrayBufferLike> {

@param —

less

@param —

constructor(uint8Array: Uint8Array, start: number)

Current state

less

@type —

s: number;

@return —

read(): number;

}

UintOptRleDecoder

decl

export class UintOptRleDecoder extends Decoder<ArrayBufferLike> {

@param —

constructor(uint8Array: Uint8Array)

@type —

s: number;

read(): number;

}

Referenced by

StringDecoder

IncUintOptRleDecoder

decl

export class IncUintOptRleDecoder extends Decoder<ArrayBufferLike> {

@param —

constructor(uint8Array: Uint8Array)

@type —

s: number;

read(): number;

}

IntDiffOptRleDecoder

decl

export class IntDiffOptRleDecoder extends Decoder<ArrayBufferLike> {

@param —

constructor(uint8Array: Uint8Array)

@type —

s: number;

diff: number;

@return —

read(): number;

}

StringDecoder

decl

export class StringDecoder {

@param —

constructor(uint8Array: Uint8Array)

decoder: UintOptRleDecoder;

str: string;

@type —

spos: number;

decl

export function diffAuto(a: string, b: string): {

insert: string;

remove: string;

index: number;

remove: number;

insert: string;

}

SimpleDiff

decl

A SimpleDiff describes a change on a String.

less

console.log(a) // the old value
console.log(b) // the updated value
// Apply changes of diff (pseudocode)
a.remove(diff.index, diff.remove) // Remove `diff.remove` characters
a.insert(diff.index, diff.insert) // Insert `diff.insert`
a === b // values match

export type SimpleDiff<T extends string | any[]> = {

The index where changes were applied

index: number;

The number of characters to delete starting at index.

remove: number;

The new text to insert at index after applying

insert: T;

}

Referenced by

simpleDiffString
simpleDiff
simpleDiffArray

decl

export const domParser: DOMParser = ...

$element

decl

@type —

export const $element: Schema<Element> = ...

$text

decl

decl

@type —

cpos: number;

cbuf: Uint8Array<ArrayBuffer>;

@type —

bufs: Uint8Array[];

}

Referenced by

RleEncoder

decl

Now come a few stateful encoder that have their own classes.

less

Basic Run Length Encoder - a basic compression implementation.

Encodes [1,1,1,7] to [1,3,7,1] (3 times 1, 1 time 7). This encoder might do more harm than good if there are a lot of values that are not repeated.

It was originally used for image compression. Cool .. article http://csbruce.com/cbm/transactor/pdfs/trans_v7_i06.pdf

@note — T must not be null!

@template —

export class RleEncoder<T> extends Encoder {

@param —

constructor(writer: (arg0: Encoder, arg1: T) => void)

The writer

w: (arg0: Encoder, arg1: T) => void;

Current state

less

@type —

s: T | null;

@param —

write(v: T): void;

}

IntDiffEncoder

decl

Basic diff decoder using variable length encoding.

less

Encodes the values [3, 1100, 1101, 1050, 0] to [3, 1097, 1, -51, -1050] using writeVarInt.

export class IntDiffEncoder extends Encoder {

@param —

constructor(start: number)

Current state

less

@type —

s: number;

@param —

write(v: number): void;

}

RleIntDiffEncoder

decl

A combination of IntDiffEncoder and RleEncoder.

less

Basically first writes the IntDiffEncoder and then counts duplicate diffs using RleEncoding.

Encodes the values [1,1,1,2,3,4,5,6] as [1,1,0,2,1,5] (RLE([1,0,0,1,1,1,1,1]) ⇒ RleIntDiff[1,1,0,2,1,5])

export class RleIntDiffEncoder extends Encoder {

@param —

constructor(start: number)

Current state

less

@type —

s: number;

@param —

write(v: number): void;

}

UintOptRleEncoder

decl

Optimized Rle encoder that does not suffer from the mentioned problem of the basic Rle encoder.

less

Encodes [1,2,3,3,3] as [1,2,-3,3] (once 1, once 2, three times 3)

export class UintOptRleEncoder {

encoder: Encoder;

@type —

s: number;

@param —

write(v: number): void;

Flush the encoded state and transform this to a Uint8Array.

less

Note that this should only be called once.

toUint8Array(): Uint8Array<ArrayBuffer>;

}

Referenced by

StringEncoder

IncUintOptRleEncoder

decl

Increasing Uint Optimized RLE Encoder

less

export class IncUintOptRleEncoder {

encoder: Encoder;

@type —

s: number;

@param —

write(v: number): void;

Flush the encoded state and transform this to a Uint8Array.

less

Note that this should only be called once.

toUint8Array(): Uint8Array<ArrayBuffer>;

}

IntDiffOptRleEncoder

decl

A combination of the IntDiffEncoder and the UintOptRleEncoder.

less

Encodes [1, 2, 3, 2] as [3, 1, 6, -1] (more specifically [(1 << 1) | 1, (3 << 0) | 0, -1])

Internally uses variable length encoding. Contrary to normal UintVar encoding, the first byte contains:

1 bit that denotes whether the next value is a count (LSB)
1 bit that denotes whether this value is negative (MSB - 1)
1 bit that denotes whether to continue reading the variable length integer (MSB)

Therefore, only five bits remain to encode diff ranges.

Use this Encoder only when appropriate. In most cases, this is probably a bad idea.

export class IntDiffOptRleEncoder {

encoder: Encoder;

@type —

s: number;

diff: number;

@param —

write(v: number): void;

Flush the encoded state and transform this to a Uint8Array.

less

Note that this should only be called once.

toUint8Array(): Uint8Array<ArrayBuffer>;

}

StringEncoder

decl

Optimized String Encoder.

less

This string encoder solves the above problem. All strings are concatenated and written as a single string using a single encoding call.

The lengths are encoded using a UintOptRleEncoder.

export class StringEncoder {

@type —

sarr: string[];

s: string;

lensE: UintOptRleEncoder;

@param —

write(string: string): void;

toUint8Array(): Uint8Array<ArrayBuffer>;

}

AnyEncodableArray

decl

export type AnyEncodableArray = AnyEncodable[]

Referenced by

AnyEncodable

AnyEncodable

decl

export type AnyEncodable = undefined | null | number | bigint | boolean | string | {

[key: string]: AnyEncodable;

} | AnyEncodableArray | Uint8Array

Referenced by

writeAny
AnyEncodableArray
Fingerprintable

Color is enabled by default if the terminal supports it.

less

Explicitly enable color using --color parameter Disable color using --no-color parameter or using NO_COLOR=1 environment variable. FORCE_COLOR=1 enables color and takes precedence over all.

new (timeoutId: number): {

_: number;

destroy(): void;

};

} = ...

TimeoutObject

decl

export type TimeoutObject = {

destroy: Function;

}

Referenced by

timeout
interval
animationFrame
idleCallback

iterate

decl

iterateKeys

Value

v: any;

}

Referenced by

getAllKeysValues

}

iterator

decl

module "iterator" {

mapIterator

decl

export function mapIterator<T, R>(iterator: Iterator<T>, f: (arg0: T) => R): IterableIterator<R>

createIterator

decl

export function createIterator<T>(next: () => IteratorResult<T>): IterableIterator<T>

decl

Transform JavaScript object to JSON.

less

@param —

@return —

export const stringify: {

(value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;

(value: any, replacer?: (number | string)[] | null, space?: string | number): string;

} = ...

parse

decl

Parse JSON object.

less

@param —

@return —

next: this | null;

@type —

prev: this | null;

}

Referenced by

TextOp
InsertOp
DeleteOp
RetainOp
ModifyOp
create
isEmpty
remove
removeNode
insertBetween
replace
pushEnd
pushFront
popFront
popEnd
map
toArray
forEach
List
Entry

List

decl

@template —

export class List<N extends ListNode> {

@type —

start: N | null;

@type —

end: N | null;

len: number;

toArray(): N[];

@param —

forEach(f: (arg0: N) => any): void;

@template —

less

@param —

@return —

map<M>(f: (arg0: N) => M): M[];

[Symbol.iterator](): Generator<N, void, unknown>;

@param —

[equalityTrait.EqualityTraitSymbol](other: List<any>): boolean;

}

Referenced by

Cache
Delta
create
isEmpty
remove
removeNode
insertBetween
replace
pushEnd
pushFront
popFront
popEnd
map
toArray
forEach

dom: Element;

@type —

ccontainer: Element;

depth: number;

@param —

less

@param —

group(args: string | Symbol | Object | number[], collapsed?: boolean): void;

@param —

groupCollapsed(args: string | Symbol | Object | number[]): void;

groupEnd(): void;

@param —

print(args: string | Symbol | Object | number[]): void;

@param —

printError(err: Error): void;

@param —

less

@param —

printImg(url: string, height: number): void;

@param —

printDom(node: Node): void;

destroy(): void;

}

Referenced by

createVConsole

export {

RED,

export const UNCOLOR: symbol = ...

}

map

decl

module "map" {

create

decl

export function create(): Map<any, any>

copy

decl

export function copy<K, V>(m: Map<K, V>): Map<K, V>

setIfUndefined

decl

map

decl

export function map<K, V, R>(m: Map<K, V>, f: (arg0: V, arg1: K) => R): R[]

any

decl

export function any<K, V>(m: Map<K, V>, f: (arg0: V, arg1: K) => boolean): boolean

decl

mutex

decl

module "mutex" {

createMutex

decl

export function createMutex(): import("mutex").mutex

mutex

decl

export type mutex = (cb: () => void, elseCb?: (() => void) | undefined) => any

Referenced by

createMutex

export const parseInt: (string: string, radix?: number) => number = ...

decl

export function isEmpty(obj: Object | null | undefined): boolean

every

decl

export function every<T extends {

[key: string | number | symbol]: any;

}>(obj: T, f: (v: T[keyof T], k: keyof T) => boolean): boolean

hasProperty

decl

export function hasProperty(obj: any, key: string | number | symbol): boolean

equalFlat

decl

export function equalFlat(a: {

[key: string]: any;

}, b: {

decl

@param —

export const keys: {

(o: object): string[];

(o: {}): string[];

} = ...

values

decl

@template —

less

@param —

@return —

export const values: {

<T>(o: {

[key: string]: T;

} | ArrayLike<T>): T[];

(o: {}): any[];

} = ...

freeze

decl

Make an object immutable. This hurts performance and is usually not needed if you perform good coding practices.

export const freeze: {

<T extends Function>(f: T): T;

<T extends {

[key: string]: U | null | undefined | object;

}, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>;

<T>(o: T): Readonly<T>;

} = ...

}

lib0/observable

decl

module "lib0/observable" {

ObservableV2

decl

Handles named events.

less

@experimental — This is basically a (better typed) duplicate of Observable, which will replace Observable in the next release.

@template —

export class ObservableV2<EVENTS extends {

[key in keyof EVENTS]: (...args: any[]) => void;

}> {

Some desc.

less

@type —

_observers: Map<string, Set<any>>;

@template —

less

@param —

on<NAME extends keyof EVENTS & string>(name: NAME, f: EVENTS[NAME]): EVENTS[NAME];

@template —

less

@param —

once<NAME extends keyof EVENTS & string>(name: NAME, f: EVENTS[NAME]): void;

@template —

less

@param —

off<NAME extends keyof EVENTS & string>(name: NAME, f: EVENTS[NAME]): void;

Emit a named event. All registered event listeners that listen to the specified name will receive the event.

less

@todo — This should catch exceptions

@template —

@param — The event name.

@param — The arguments that are applied to the event listener.

emit<NAME extends keyof EVENTS & string>(name: NAME, args: Parameters<EVENTS[NAME]>): void;

destroy(): void;

}

Observable

decl

Handles named events.

less

@deprecated —

@template —

export class Observable<N> {

Some desc.

less

@type —

_observers: Map<N, any>;

@param —

less

@param —

on(name: N, f: Function): void;

@param —

less

@param —

once(name: N, f: Function): void;

@param —

less

@param —

off(name: N, f: Function): void;

Emit a named event. All registered event listeners that listen to the specified name will receive the event.

less

@todo — This should catch exceptions

@param — The event name.

@param — The arguments that are applied to the event listener.

emit(name: N, args: any[]): void;

destroy(): void;

}

Referenced by

WebsocketClient

}

pair

decl

@param —

less

@param —

constructor(left: L, right: R)

left: L;

right: R;

}

Referenced by

setAttributes
addEventListeners
removeEventListeners
element
pairToStyleString
pairsToStyleString
create
createReversed
forEach
map

This is a variant of xoroshiro128plus - the fastest full-period generator passing BigCrush without systematic failures.

less

This implementation follows the idea of the original xoroshiro128plus implementation, but is optimized for the JavaScript runtime. I.e.

The operations are performed on 32bit integers (the original implementation works with 64bit values).
The initial 128bit state is computed based on a 32bit seed and Xorshift32.
This implementation returns two 32bit values based on the 64bit value that is computed by xoroshiro128plus. Caution: The last addition step works slightly different than in the original implementation - the add carry of the first 32bit addition is not carried over to the last 32bit.

Reference implementation

class Xoroshiro128plus {

@param — Unsigned 32 bit number

constructor(seed: number)

seed: number;

state: Uint32Array<ArrayBuffer>;

_fresh: boolean;

@return — Float/Double in [0,1)

next(): number;

}

Referenced by

DefaultPRNG

generatorNext

decl

Description of the function

export type generatorNext = () => number

Referenced by

PRNG

PRNG

decl

A random type generator.

export type PRNG = {

Generate new number

next: generatorNext;

}

Referenced by

random
create
bool
int53
uint53
int32
uint32
int31
real53
char
letter
word
utf16Rune
utf16String
oneOf
uint8Array
uint16Array
uint32Array
TestCase
random

@param —

@return —

export const all: {

<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;

<T extends readonly unknown[] | []>(values: T): Promise<{

-readonly [P in keyof T]: Awaited<T[P]>;

}>;

} = ...

PromiseResolve

decl

export type PromiseResolve<T> = (result?: T | PromiseLike<T> | undefined) => any

Referenced by

create

export class QueueNode {

@type —

next: QueueNode | null;

}

Referenced by

create
dequeue
QueueValue
Queue

QueueValue

decl

@template —

export class QueueValue<V> extends QueueNode {

@param —

constructor(v: V)

v: V;

}

Queue

decl

@template —

export class Queue<N extends QueueNode> {

@type —

start: N | null;

@type —

end: N | null;

}

Referenced by

create
isEmpty
enqueue
dequeue

sort

decl

module "sort" {

_insertionSort

decl

export function _insertionSort<T>(arr: T[], lo: number, hi: number, compare: (arg0: T, arg1: T) => number): void

insertionSort

decl

export function insertionSort<T>(arr: T[], compare: (arg0: T, arg1: T) => number): void

quicksort

decl

export function quicksort<T>(arr: T[], compare: (arg0: T, arg1: T) => number): void

}

statistics

This is basically localStorage in browser, or a polyfill in nodejs

export const varStorage: any = ...

}

string

decl

decl

The largest utf16 character. Corresponds to Uint8Array([255, 255]) or charcodeof(2x2^8)

export const MAX_UTF16_CHARACTER: string = ...

decl

export function isSymbol(s: any): boolean

create

decl

Return fresh symbol.

export const create: SymbolConstructor = ...

}

lib0/traits

decl

module "lib0/traits" {

equals

decl

export function equals<T extends EqualityTrait>(a: NoInfer<T>, b: T): boolean

EqualityTraitSymbol

decl

export const EqualityTraitSymbol: unique symbol = ...

EqualityTrait

decl

export type EqualityTrait = {

[EqualityTraitSymbol]: (other: EqualityTrait) => boolean;

}

Referenced by

equals
Schema

fingerprint

decl

export function fingerprint(a: Fingerprintable): string

FingerprintTraitSymbol

decl

export const FingerprintTraitSymbol: unique symbol = ...

Fingerprintable

decl

When implementing this trait, it is recommended to write some sort of "magic number" first to ensure that different types of objects don't have the same fingerprint.

less

The recommended pracice is to generate a random u32 number as your magic number. e.g. using console.log(random.uint32().toString(16))

export type Fingerprintable = {

[FingerprintTraitSymbol]: () => string;

} | AnyEncodable

Referenced by

$insertOpWith
InsertOp
DeleteOp
AttrInsertOp
Delta
DeltaBuilder
$Delta
$$delta
RecursiveDelta
TextDelta
TextDeltaBuilder
ArrayDelta
ArrayDeltaBuilder
fingerprint

decl

export class TestCase {

@param —

less

@param —

constructor(moduleName: string, testName: string)

@type —

moduleName: string;

@type —

testName: string;

This type can store custom information related to the TestCase

less

@type —

meta: Map<string, any>;

_seed: number | null;

_prng: PRNG | null;

resetSeed(): void;

get seed(): number;

get prng(): prng.PRNG;

}

Referenced by

run
runTests

repetitionTime

decl

export const repetitionTime: number = ...

printDom

decl

export const printDom: (_createNode: () => Node) => void = ...

printCanvas

decl

export const printCanvas: (canvas: HTMLCanvasElement, height: number) => void = ...

}

time

decl

module "time" {

getDate

decl

export function getDate(): Date

humanizeDuration

decl

export function humanizeDuration(d: number): string

getUnixTime

decl

Return current unix time.

less

@return —

export const getUnixTime: () => number = ...

}

tree

decl

module "tree" {

Tree

decl

This is a Red Black Tree implementation

less

@template —

export class Tree<K, V> {

root: any;

length: number;

@param —

findNext(id: K): V;

@param —

findPrev(id: K): V;

@param —

findNodeWithLowerBound(from: K): any;

@param —

findNodeWithUpperBound(to: K): any;

@return —

findSmallestNode(): V;

@param —

less

@return —

findWithLowerBound(from: K): V;

@param —

less

@return —

findWithUpperBound(to: K): V;

@param —

less

@param —

iterate(from: K, to: any, f: (arg0: V) => void): void;

@param —

less

@return —

find(id: K): V | null;

@param —

less

@return —

findNode(id: K): N<V> | null;

@param —

delete(id: K): void;

_fixDelete(n: any): void;

put(v: any): any;

_fixInsert(n: any): void;

}

Unexported symbols referenced here

N

decl

@template —

class N<V> {

A created node is always red!

less

@param —

constructor(val: V)

val: V;

color: boolean;

_left: any;

_right: any;

_parent: any;

isRed(): boolean;

isBlack(): boolean;

redden(): this;

blacken(): this;

get grandparent(): any;

get parent(): any;

get sibling(): any;

set left(n: any);

get left(): any;

set right(n: any);

get right(): any;

rotateLeft(tree: any): void;

next(): any;

prev(): any;

rotateRight(tree: any): void;

getUncle(): any;

}

Referenced by

Tree

}

lib0/url

decl

module "lib0/url" {

decodeQueryParams

decl

export function decodeQueryParams(url: string): {

[key: string]: string;

}

encodeQueryParams

decl

export function encodeQueryParams(params: {

[key: string]: string;

}): string

}

websocket

decl

module "websocket" {

WebsocketClient

decl

@deprecated —

less

@extends —

export class WebsocketClient extends Observable<string> {

@param —

less

@param —

constructor(url: string, { binaryType }?: {

binaryType?: "arraybuffer" | "blob" | null | undefined;

})

url: string;

@type —

ws: WebSocket | null;

binaryType: "arraybuffer" | "blob" | null;

connected: boolean;

connecting: boolean;

unsuccessfulReconnects: number;

lastMessageReceived: number;

Whether to connect to other peers or not

less

@type —

shouldConnect: boolean;

decl

export function $object<S extends {

[key: string | symbol | number]: Schema<any>;

}>(def: S): _ObjectDefToSchema<S> extends Schema<infer S_1> ? Schema<{

less

@type —

_rerrs: {

path: string | null;

expected: string;

has: string;

message: string | null;

}[];

@param —

less

@param —

extend(path: string | null, expected: string, has: string, message?: string | null): void;

toString(): string;

}

Referenced by

Schema
$ConstructedBy
$Custom
$Object
$Record
$Tuple
$Array
$InstanceOf
$Lambda

Schema

decl

@template —

less

@implements —

export class Schema<T> implements EqualityTrait {

If true, the more things are added to the shape the more objects this schema will accept (e.g. union). By default, the more objects are added, the the fewer objects this schema will accept.

less

@protected —

static _dilutes: boolean;

@param —

extends(other: Schema<any>): boolean;

Overwrite this when necessary. By default, we only check the shape property which every shape should have.

less

@param —

equals(other: Schema<any>): boolean;

Use schema.validate(obj) with a typed parameter that is already of typed to be an instance of Schema. Validate will check the structure of the parameter and return true iff the instance really is an instance of Schema.

less

@param —

@return —

validate(o: T): boolean;

Similar to validate, but this method accepts untyped parameters.

less

@param —

@return —

check(_o: any, _err?: ValidationError): _o is T;

get nullable(): Schema<T | null>;

get optional(): $Optional<Schema<T>>;

Cast a variable to a specific type. Returns the casted value, or throws an exception otherwise. Use this if you know that the type is of a specific type and you just want to convince the type system.

less

Do not rely on these error messages! Performs an assertion check only if not in a production environment.

@template —

@param —

@return —

cast<OO>(o: OO): Extract<OO, T> extends never ? T : (OO extends never[] ? T : Extract<OO, T>);

EXPECTO PATRONUM!! 🪄 This function protects against type errors. Though it may not work in the real world.

less

"After all this time?" "Always." - Snape, talking about type safety

Ensures that a variable is a a specific type. Returns the value, or throws an exception if the assertion check failed. Use this if you know that the type is of a specific type and you just want to convince the type system.

Can be useful when defining lambdas: s.lambda(s.$number, s.$void).expect((n) => n + 1)

Do not rely on these error messages! Performs an assertion check if not in a production environment.

@param —

@return —

expect(o: T): T extends T ? T : never;

[schemaSymbol](): boolean;

@param —

[equalityTraits.EqualityTraitSymbol](other: object): boolean;

}

Referenced by

$insertOpWith
$modifyOpWith
$delta
_$delta
random
create
$text
text
$array
array
$map
map
$attribution
$deltaMapChangeJson
$deleteOp
$insertOp
$textOp
$retainOp
$modifyOp
$anyOp
Delta
DeltaBuilder
$Delta
$$delta
$deltaAny
$deltaBuilderAny
$textOnly
DeltaOps
AllowedDeltaFromSchema
$fragment
$element
$text
$node
$custom
$stringTemplate
$object
$record
$tuple
$array
$instanceOf
$lambda
$intersect
$ConstructedBy
$$constructedBy
$Custom
$$custom
$Literal
$$literal
$StringTemplate
$$stringTemplate
$$optional
$never
$$never
$Object
$$object
$objectAny
$Record
$$record
$Tuple
$$tuple
$Array
$$array
$arrayAny
$InstanceOf
$$instanceOf
$$schema
$Lambda
$$lambda
$function
$Intersection
$$intersect
$Union
$$union
$any
$$any
$bigint
$$bigint
$symbol
$$symbol
$number
$$number
$string
$$string
$boolean
$$boolean
$undefined
$$undefined
$void
$$void
$null
$$null
$uint8Array
$$uint8Array
$primitive
$json
assert
PatternMatcher
Unwrap
TypeOf
UnwrapArray
CastToSchema
CastStringTemplateArgsToTemplate
$ObjectToType
_ObjectDefToSchema
_LArgsToLambdaDef
ReadSchemaOld
ReadSchema
Q
Pattern
$Optional
$Never

$ConstructedBy

decl

@template —

less

@typedef —

@template —

@extends —

export class $ConstructedBy<C extends (new (...args: any[]) => any) | ((...args: any[]) => any)> extends Schema<Instance<C>> {

@param —

less

@param —

constructor(c: C, check: ((o: Instance<C>) => boolean) | null)

shape: C;

_c: ((o: Instance<C>) => boolean) | null;

@param —

less

@param —

@return — o

check(o: any, err?: ValidationError): o is C extends ((...args: any[]) => infer T) ? T : (C extends (new (...args: any[]) => any) ? InstanceType<C> : never);

}

Referenced by

$constructedBy
$$constructedBy

$$constructedBy

decl

export const $$constructedBy: Schema<$ConstructedBy<(new (...args: any[]) => any) | ((...args: any[]) => any)>> = ...

$Custom

decl

Check custom properties on any object. You may want to overwrite the generated Schema.

less

@extends —

export class $Custom extends Schema<any> {

@param —

constructor(check: (o: any) => boolean)

@type —

shape: (o: any) => boolean;

@param —

less

@param —

@return —

check(o: any, err: ValidationError): o is any;

}

Referenced by

$$custom

$$custom

decl

export const $$custom: Schema<$Custom> = ...

$Literal

decl

@template —

less

@extends —

export class $Literal<T extends Primitive> extends Schema<T> {

@param —

constructor(literals: T[])

shape: T[];

}

Referenced by

$literal
$$literal

$$literal

decl

export const $$literal: Schema<$Literal<Primitive>> = ...

$StringTemplate

decl

@template —

less

@extends —

export class $StringTemplate<T extends string | Schema<string | number>[]> extends Schema<CastStringTemplateArgsToTemplate<T>> {

@param —

constructor(shape: T)

shape: T;

_r: RegExp;

}

Referenced by

$stringTemplate
$$stringTemplate

$$stringTemplate

decl

export const $$stringTemplate: Schema<$StringTemplate<(string | Schema<string | number>)[]>> = ...

$$optional

decl

export const $$optional: Schema<$Optional<Schema<any>>> = ...

Unexported symbols referenced here

$Optional

decl

@template —

less

@extends —

class $Optional<S extends Schema<any>> extends Schema<Unwrap<S> | undefined> {

@param —

constructor(shape: S)

shape: S;

get [isOptionalSymbol](): boolean;

}

Referenced by

$$optional
$ObjectToType
_ObjectDefToSchema

$never

decl

@type —

export const $never: Schema<never> = ...

$$never

decl

export const $$never: Schema<$Never> = ...

Unexported symbols referenced here

$Never

decl

@extends —

class $Never extends Schema<never> {

constructor()

}

Referenced by

$$never

$Object

decl

@template —

less

@typedef —

@template —

@extends —

export class $Object<S extends {

[key: string | symbol | number]: Schema<any>;

}> extends Schema<$ObjectToType<S>> {

@param —

less

@param —

constructor(shape: S, partial?: boolean)

@type —

shape: S;

_isPartial: boolean;

get partial(): Schema<Partial<$ObjectToType<S>>>;

@param —

less

@param —

@return —

check(o: any, err: ValidationError): o is $ObjectToType<S>;

}

Referenced by

$$object

$$object

decl

export const $$object: Schema<$Object<{

[key: string]: Schema<any>;

[key: number]: Schema<any>;

[key: symbol]: Schema<any>;

}>> = ...

$objectAny

decl

@type —

export const $objectAny: Schema<{

[key: string]: any;

}> = ...

$Record

decl

@template —

less

@template —

@extends —

export class $Record<Keys extends Schema<string | number | symbol>, Values extends Schema<any>> extends Schema<{

[key in Unwrap<Keys>]: Unwrap<Values>;

}> {

@param —

less

@param —

constructor(keys: Keys, values: Values)

shape: {

keys: Keys;

values: Values;

};

@param —

less

@param —

@return —

check(o: any, err: ValidationError): o is {

[key_1 in Unwrap<Keys>]: Unwrap<Values>;

};

}

Referenced by

$record
$$record

$$record

decl

export const $$record: Schema<$Record<Schema<string | number | symbol>, Schema<any>>> = ...

$Tuple

decl

@template —

less

@extends —

export class $Tuple<S extends Schema<any>[]> extends Schema<{

[Key in keyof S]: S[Key] extends Schema<infer Type> ? Type : never;

}> {

@param —

constructor(shape: S)

shape: S;

@param —

less

@param —

@return —

check(o: any, err: ValidationError): o is {

[K in keyof S]: S[K] extends Schema<infer Type> ? Type : never;

};

}

Referenced by

$tuple
$$tuple

$$tuple

decl

export const $$tuple: Schema<$Tuple<Schema<any>[]>> = ...

$Array

decl

@template —

less

@extends —

export class $Array<S extends Schema<any>> extends Schema<(S extends Schema<infer T> ? T : never)[]> {

@param —

constructor(v: S[])

@type —

shape: Schema<S extends Schema<infer T_1> ? T_1 : never>;

@param —

less

@param —

@return — o

check(o: any, err?: ValidationError): o is S extends Schema<infer T_1> ? T_1 : never[];

}

Referenced by

$$array

$$array

decl

export const $$array: Schema<$Array<Schema<any>>> = ...

$arrayAny

decl

@type —

export const $arrayAny: Schema<any[]> = ...

$InstanceOf

decl

@template —

less

@extends —

export class $InstanceOf<T> extends Schema<T> {

@param —

less

@param —

constructor(constructor: new (...args: any) => T, check: ((o: T) => boolean) | null)

shape: new (...args: any) => T;

_c: ((o: T) => boolean) | null;

@param —

less

@param —

@return —

check(o: any, err: ValidationError): o is T;

}

Referenced by

$$instanceOf

$$instanceOf

decl

export const $$instanceOf: Schema<$InstanceOf<unknown>> = ...

$$schema

decl

export const $$schema: Schema<Schema<unknown>> = ...

$Lambda

decl

@template —

less

@typedef —

@template —

@extends —

export class $Lambda<Args extends Schema<any>[]> extends Schema<_LArgsToLambdaDef<Args>> {

@param —

constructor(args: Args)

len: number;

args: Schema<any[]>;

res: Schema<any>;

@param —

less

@param —

@return —

check(f: any, err: ValidationError): f is _LArgsToLambdaDef<Args>;

}

Referenced by

$$lambda

$$lambda

decl

export const $$lambda: Schema<$Lambda<Schema<any>[]>> = ...

$function

decl

@type —

export const $function: Schema<Function> = ...

$Intersection

decl

@template —

less

@extends —

export class $Intersection<T extends Schema<any>[]> extends Schema<Intersect<UnwrapArray<T>>> {

@param —

constructor(v: T)

@type —

shape: T;

}

Referenced by

$intersect
$$intersect

$$intersect

decl

export const $$intersect: Schema<$Intersection<Schema<any>[]>> = ...

$Union

decl

@template —

less

@extends —

export class $Union<S> extends Schema<S> {

@param —

constructor(v: Schema<S>[])

shape: Schema<S>[];

}

Referenced by

$union
$$union

decl

export const $$null: Schema<Schema<null>> = ...

$uint8Array

decl

export const $uint8Array: Schema<Uint8Array<ArrayBuffer>> = ...

$$uint8Array

decl

export const $$uint8Array: Schema<Schema<Uint8Array>> = ...

$primitive

decl

@type —

export const $primitive: Schema<Primitive> = ...

$json

decl

@typedef —

less

@typedef —

@type —

export const $json: Schema<null | number | string | boolean | JSON[] | {

[key: string]: JSON;

}> = ...

assert

decl

Assert that a variable is of this specific type. The assertion check is only performed in non-production environments.

less

@type —

export const assert: <T>(o: any, schema: Schema<T>) => asserts o is T = ...

PatternMatcher

decl

@template —

less

@template —

@typedef —

@template —

@typedef —

@todo — move this to separate library

@template —

export class PatternMatcher<State extends unknown = undefined, Patterns extends Pattern<any, any> = never> {

@param —

constructor($state?: Schema<State>)

@type —

patterns: Patterns[];

$state: Schema<State> | undefined;

@template —

less

@template —

@param —

@return —

if<P, R>(pattern: P, handler: (o: NoInfer<Unwrap<ReadSchema<P>>>, s: State) => R): PatternMatcher<State, Patterns | Pattern<Unwrap<ReadSchema<P>>, R>>;

@template —

less

@param —

else<R>(h: (o: any, s: State) => R): PatternMatcher<State, Patterns | Pattern<any, R>>;

@return —

done(): State extends undefined ? <In extends Unwrap<Patterns["if"]>>(o: In, state?: undefined) => PatternMatchResult<Patterns, In> : <In extends Unwrap<Patterns["if"]>>(o: In, state: State) => PatternMatchResult<Patterns, In>;

}

Referenced by

match

Primitive

decl

Referenced by

$literal
$Literal
$$literal
$primitive
JSON

AnyObject

decl

export type AnyObject = {

[key: string | number | symbol]: any;

}

Unwrap

decl

export type Unwrap<T> = T extends Schema<infer X> ? X : T

Referenced by

$delta
_$delta
$array
DeltaOps
$lambda
$union
match
random
$Record
PatternMatcher
CastStringTemplateArgsToTemplate
_LArgsToLambdaDef
ReadSchemaOld
ReadSchema
$Optional

TypeOf

decl

export type TypeOf<T> = T extends Schema<infer X> ? X : T

UnwrapArray

decl

export type UnwrapArray<T extends readonly unknown[]> = T extends readonly [Schema<infer First>, ...infer Rest] ? [First, ...UnwrapArray<Rest>] : []

Referenced by

$lambda
$Intersection
_LArgsToLambdaDef

CastToSchema

decl

export type CastToSchema<T> = T extends Schema<infer S> ? Schema<S> : never

Referenced by

$constructedBy
$literal
$stringTemplate
$record
$tuple
$intersect
$union

TupleLast

decl

export type TupleLast<Arr extends unknown[]> = Arr extends [...unknown[], infer L] ? L : never

Referenced by

$lambda
_LArgsToLambdaDef

TuplePop

decl

export type TuplePop<Arr extends unknown[]> = Arr extends [...infer Fs, unknown] ? Fs : never

Referenced by

$lambda
_LArgsToLambdaDef

Intersect

decl

export type Intersect<T extends readonly unknown[]> = T extends [] ? {} : T extends [infer First] ? First : T extends [infer First, ...infer Rest] ? First & Intersect<Rest> : never

Referenced by

$Intersection

Instance

decl

export type Instance<Constr extends (new (...args: any[]) => any) | ((...args: any[]) => any)> = Constr extends ((...args: any[]) => infer T) ? T : (Constr extends (new (...args: any[]) => any) ? InstanceType<Constr> : never)

Referenced by

$constructedBy
$ConstructedBy

CastStringTemplateArgsToTemplate

decl

export type CastStringTemplateArgsToTemplate<Ts extends string | Schema<string | number>[]> = Ts extends [] ? `` LiteralType : (Ts extends [infer T] ? (Unwrap<T> extends (string | number) ? Unwrap<T> : never) : (Ts extends [infer T1, ...infer Rest] ? `${Unwrap<T1> extends (string | number) ? Unwrap<T1> : never}${Rest extends string | Schema<string | number>[] ? CastStringTemplateArgsToTemplate<Rest> : never}` : never))

Referenced by

$StringTemplate

$ObjectToType

decl

export type $ObjectToType<S extends {

[key: string | symbol | number]: Schema<any>;

}> = {

[Key in keyof S as S[Key] extends $Optional<Schema<any>> ? Key : never]?: S[Key] extends $Optional<Schema<infer Type>> ? Type : never;

} & {

[Key in keyof S as S[Key] extends $Optional<Schema<any>> ? never : Key]: S[Key] extends Schema<infer Type> ? Type : never;

}

Referenced by

$Delta
$Object

_ObjectDefToSchema

decl

export type _ObjectDefToSchema<S> = Schema<{

[Key in keyof S as S[Key] extends $Optional<Schema<any>> ? Key : never]?: S[Key] extends $Optional<Schema<infer Type>> ? Type : never;

} & {

[Key in keyof S as S[Key] extends $Optional<Schema<any>> ? never : Key]: S[Key] extends Schema<infer Type> ? Type : never;

Referenced by

$object
ReadSchemaOld
ReadSchema

_LArgsToLambdaDef

decl

export type _LArgsToLambdaDef<Args extends Schema<any>[]> = (...args: UnwrapArray<TuplePop<Args>>) => Unwrap<TupleLast<Args>>

Referenced by

$Lambda

JSONArray

decl

export type JSONArray = JSON[]

Referenced by

JSON

JSON

decl

export type JSON = Primitive | JSONArray | {

[key: string]: JSON;

}

Referenced by

$json
JSONArray

ReadSchemaOld

decl

export type ReadSchemaOld<IN extends unknown> = IN extends Schema<any> ? IN : (IN extends string | number | boolean | null ? Schema<IN> : (IN extends new (...args: any[]) => any ? Schema<InstanceType<IN>> : (IN extends any[] ? Schema<{

[K in keyof IN]: Unwrap<ReadSchema<IN[K]>>;

}[number]> : (IN extends object ? (_ObjectDefToSchema<{

[K in keyof IN]: ReadSchema<IN[K]>;

}> extends Schema<infer S> ? Schema<{

[K in keyof S]: S[K];

}> : never) : never))))

ReadSchema

decl

export type ReadSchema<IN extends unknown> = [Extract<IN, Schema<any>>, Extract<IN, string | number | boolean | null>, Extract<IN, new (...args: any[]) => any>, Extract<IN, any[]>, Extract<Exclude<IN, Schema<any> | string | number | boolean | null | (new (...args: any[]) => any) | any[]>, object>] extends [infer Schemas, infer Primitives, infer Constructors, infer Arrs, infer Obj] ? Schema<(Schemas extends Schema<infer S> ? S : never) | Primitives | (Constructors extends new (...args: any[]) => any ? InstanceType<Constructors> : never) | (Arrs extends any[] ? {

[K in keyof Arrs]: Unwrap<ReadSchema<Arrs[K]>>;

}[number] : never) | (Obj extends object ? Unwrap<(_ObjectDefToSchema<{

[K in keyof Obj]: ReadSchema<Obj[K]>;

}> extends Schema<infer S> ? Schema<{

[K in keyof S]: S[K];

}> : never)> : never)> : never

Referenced by

$delta
_$delta
$array
$union
$
match
random
PatternMatcher
ReadSchemaOld
Q

Q

decl

export type Q = ReadSchema<{

x: 42;

} | {

y: 99;

} | Schema<string> | [1, 2, {}]>

Pattern

decl

export type Pattern<In, Out> = {

if: Schema<In>;

h: (o: In, state?: any) => Out;

}

Referenced by

PatternMatcher
PatternMatchResult

PatternMatchResult

decl

export type PatternMatchResult<P extends Pattern<any, any>, In> = ReturnType<Extract<P, Pattern<In extends number ? number : (In extends string ? string : In), any>>["h"]>

Referenced by

PatternMatcher

}