atom.io 0.40.10 → 0.41.0

package/src/transceivers/o-list/o-list.ts

@@ -1,8 +1,13 @@
-import type { Fn, Transceiver, TransceiverMode } from "atom.io/internal"
-import { Subject } from "atom.io/internal"
+import type {
+	Enumeration,
+	Fn,
+	Transceiver,
+	TransceiverMode,
+} from "atom.io/internal"
+import { enumeration, packValue, Subject, unpackValue } from "atom.io/internal"
 import type { primitive } from "atom.io/json"
 
-type ArrayMutations = Exclude<keyof Array<any>, keyof ReadonlyArray<any>>
+export type ArrayMutations = Exclude<keyof Array<any>, keyof ReadonlyArray<any>>
 export type ArrayUpdate<P extends primitive> =
 	| {
 			type: `copyWithin`
@@ -48,9 +53,9 @@ export type ArrayUpdate<P extends primitive> =
 	| {
 			type: `splice`
 			start: number
-			deleteCount?: number
-			items?: readonly P[]
-			deleted?: readonly P[]
+			deleteCount: number
+			items: readonly P[]
+			deleted: readonly P[]
 	  }
 	| {
 			type: `truncate`
@@ -62,6 +67,193 @@ true satisfies ArrayMutations extends OListUpdateType
 	? true
 	: Exclude<ArrayMutations, OListUpdateType>
 
+export type PackedArrayUpdate<P extends primitive> = string & {
+	update?: ArrayUpdate<P>
+	type?: P
+}
+
+const ARRAY_UPDATES = [
+	// virtual methods
+	`set`,
+	`truncate`,
+	`extend`,
+	// actual methods
+	`pop`,
+	`push`,
+	`shift`,
+	`unshift`,
+	`copyWithin`,
+	`fill`,
+	`splice`,
+	`reverse`,
+	`sort`,
+] as const
+true satisfies ArrayUpdate<any>[`type`] extends (typeof ARRAY_UPDATES)[number]
+	? true
+	: Exclude<ArrayUpdate<any>[`type`], (typeof ARRAY_UPDATES)[number]>
+
+export const ARRAY_UPDATE_ENUM: Enumeration<typeof ARRAY_UPDATES> =
+	enumeration(ARRAY_UPDATES)
+
+export function packArrayUpdate<P extends primitive>(
+	update: ArrayUpdate<P>,
+): PackedArrayUpdate<P> {
+	let packed = ARRAY_UPDATE_ENUM[update.type] + `\u001F`
+	switch (update.type) {
+		case `set`:
+			packed += update.index + `\u001E` + packValue(update.next)
+			if (update.prev !== undefined) {
+				packed += `\u001E` + packValue(update.prev)
+			}
+			return packed
+		case `truncate`:
+			return (
+				packed +
+				update.length +
+				`\u001E` +
+				update.items.map(packValue).join(`\u001E`)
+			)
+		case `extend`:
+			return packed + update.next + `\u001E` + update.prev
+		case `pop`:
+		case `shift`:
+			if (update.value !== undefined) {
+				packed += packValue(update.value)
+			}
+			return packed
+		case `push`:
+		case `unshift`:
+			return packed + update.items.map(packValue).join(`\u001E`)
+		case `copyWithin`:
+			packed += update.target + `\u001E` + update.start
+			if (update.end !== undefined) {
+				packed += `\u001E` + update.end
+			}
+			packed += `\u001E\u001E` + update.prev.map(packValue).join(`\u001E`)
+			return packed
+		case `fill`:
+			packed += packValue(update.value)
+			if (update.start !== undefined) {
+				packed += `\u001E` + update.start
+			}
+			if (update.end !== undefined) {
+				packed += `\u001E` + update.end
+			}
+			packed += `\u001E\u001E` + update.prev.map(packValue).join(`\u001E`)
+			return packed
+		case `splice`:
+			return (
+				packed +
+				update.start +
+				`\u001E\u001E` +
+				update.deleteCount +
+				`\u001E\u001E` +
+				update.items.map(packValue).join(`\u001E`) +
+				`\u001E\u001E` +
+				update.deleted.map(packValue).join(`\u001E`)
+			)
+		case `reverse`:
+			return packed
+		case `sort`:
+			return (
+				packed +
+				update.next.map(packValue).join(`\u001E`) +
+				`\u001E\u001E` +
+				update.prev.map(packValue).join(`\u001E`)
+			)
+	}
+}
+
+export function unpackArrayUpdate<P extends primitive>(
+	packed: PackedArrayUpdate<P>,
+): ArrayUpdate<P> {
+	const [head, tail] = packed.split(`\u001F`) as [
+		Extract<keyof typeof ARRAY_UPDATE_ENUM, number>,
+		string,
+	]
+	const type = ARRAY_UPDATE_ENUM[head]
+	switch (type) {
+		case `set`: {
+			const [i, n, p] = tail.split(`\u001E`)
+			const index = +i
+			const next = unpackValue(n) as P
+			if (p === undefined) {
+				return { type, index, next }
+			}
+			const prev = unpackValue(p) as P
+			return { type, index, next, prev }
+		}
+		case `truncate`: {
+			const [l, ...i] = tail.split(`\u001E`)
+			const length = +l
+			const items = i.map(unpackValue) as P[]
+			return { type, length, items }
+		}
+		case `extend`: {
+			const [n, p] = tail.split(`\u001E`)
+			const next = +n
+			const prev = +p
+			return { type, next, prev }
+		}
+		case `pop`:
+		case `shift`:
+			if (tail !== ``) {
+				const value = unpackValue(tail) as P
+				return { type, value }
+			}
+			return { type }
+		case `push`:
+		case `unshift`: {
+			const items = tail.split(`\u001E`).map(unpackValue) as P[]
+			return { type, items }
+		}
+		case `copyWithin`: {
+			const [numbers, data] = tail.split(`\u001E\u001E`)
+			const prev = data ? (data.split(`\u001E`).map(unpackValue) as P[]) : []
+			const [t, s, e] = numbers.split(`\u001E`)
+			const target = +t
+			const start = +s
+			if (e === undefined) {
+				return { type, target, start, prev }
+			}
+			const end = +e
+			return { type, target, start, prev, end }
+		}
+		case `fill`: {
+			const [numbers, data] = tail.split(`\u001E\u001E`)
+			const prev = data ? (data.split(`\u001E`).map(unpackValue) as P[]) : []
+			const [v, s, e] = numbers.split(`\u001E`)
+			const value = unpackValue(v) as P
+			if (s === undefined && e === undefined) {
+				return { type, value, prev }
+			}
+			const start = +s
+			if (e === undefined) {
+				return { type, value, prev, start }
+			}
+			const end = +e
+			return { type, value, prev, start, end }
+		}
+		case `splice`: {
+			const [s, c, i, d] = tail.split(`\u001E\u001E`)
+
+			const start = +s
+			const deleteCount = +c
+			const items = i ? (i.split(`\u001E`).map(unpackValue) as P[]) : []
+			const deleted = d ? (d.split(`\u001E`).map(unpackValue) as P[]) : []
+			return { type, start, deleteCount, items, deleted }
+		}
+		case `reverse`:
+			return { type }
+		case `sort`: {
+			const [n, p] = tail.split(`\u001E\u001E`)
+			const next = n ? (n.split(`\u001E`).map(unpackValue) as P[]) : []
+			const prev = p ? (p.split(`\u001E`).map(unpackValue) as P[]) : []
+			return { type, next, prev }
+		}
+	}
+}
+
 export type ArrayMutationHandler = {
 	[K in Exclude<OListUpdateType, `extend` | `set` | `truncate`>]: Fn
 }
@@ -69,13 +261,11 @@ export type ArrayMutationHandler = {
 export class OList<P extends primitive>
 	extends Array<P>
 	implements
-		Transceiver<ReadonlyArray<P>, ArrayUpdate<P>, ReadonlyArray<P>>,
+		Transceiver<ReadonlyArray<P>, PackedArrayUpdate<P>, ReadonlyArray<P>>,
 		ArrayMutationHandler
 {
 	public mode: TransceiverMode = `record`
-	public readonly subject: Subject<ArrayUpdate<P>> = new Subject<
-		ArrayUpdate<P>
-	>()
+	public readonly subject: Subject<PackedArrayUpdate<P>> = new Subject()
 
 	public readonly READONLY_VIEW: ReadonlyArray<P> = this
 
@@ -198,6 +388,27 @@ export class OList<P extends primitive>
 		return this
 	}
 
+	public fill(value: P, start?: number, end?: number): this {
+		if (this.mode === `record`) {
+			this.mode = `playback`
+			const prev = this.slice(start, end)
+			super.fill(value, start, end)
+			if (start === undefined) {
+				this.emit({ type: `fill`, value, prev })
+			} else {
+				if (end === undefined) {
+					this.emit({ type: `fill`, value, start, prev })
+				} else {
+					this.emit({ type: `fill`, value, start, end, prev })
+				}
+			}
+			this.mode = `record`
+		} else {
+			super.fill(value, start, end)
+		}
+		return this
+	}
+
 	public sort(compareFn?: (a: P, b: P) => number): this {
 		if (this.mode === `record`) {
 			this.mode = `playback`
@@ -256,13 +467,13 @@ export class OList<P extends primitive>
 
 	public subscribe(
 		key: string,
-		fn: (update: ArrayUpdate<P>) => void,
+		fn: (update: PackedArrayUpdate<P>) => void,
 	): () => void {
 		return this.subject.subscribe(key, fn)
 	}
 
 	public emit(update: ArrayUpdate<P>): void {
-		this.subject.next(update)
+		this.subject.next(packArrayUpdate(update))
 	}
 
 	private doStep(update: ArrayUpdate<P>): void {
@@ -296,11 +507,7 @@ export class OList<P extends primitive>
 				this.length = update.next.length
 				break
 			case `splice`:
-				if (update.deleteCount !== undefined && update.items) {
-					this.splice(update.start, update.deleteCount, ...update.items)
-				} else {
-					this.splice(update.start)
-				}
+				this.splice(update.start, update.deleteCount, ...update.items)
 				break
 			case `truncate`:
 				this.length = update.length
@@ -314,9 +521,10 @@ export class OList<P extends primitive>
 		}
 	}
 
-	public do(update: ArrayUpdate<P>): null {
+	public do(update: PackedArrayUpdate<P>): null {
 		this.mode = `playback`
-		this.doStep(update)
+		const unpacked = unpackArrayUpdate(update)
+		this.doStep(unpacked)
 		this.mode = `record`
 		return null
 	}
@@ -378,15 +586,7 @@ export class OList<P extends primitive>
 				}
 				break
 			case `splice`:
-				if (update.deleted) {
-					if (update.items) {
-						this.splice(update.start, update.items.length, ...update.deleted)
-					} else {
-						this.splice(update.start, 0, ...update.deleted)
-					}
-				} else if (update.items) {
-					this.splice(update.start, update.items.length)
-				}
+				this.splice(update.start, update.items.length, ...update.deleted)
 				break
 			case `truncate`:
 				this.push(...update.items)
@@ -403,9 +603,10 @@ export class OList<P extends primitive>
 		}
 	}
 
-	public undo(update: ArrayUpdate<P>): number | null {
+	public undo(update: PackedArrayUpdate<P>): number | null {
 		this.mode = `playback`
-		this.undoStep(update)
+		const unpacked = unpackArrayUpdate(update)
+		this.undoStep(unpacked)
 		this.mode = `record`
 		return null
 	}

package/src/transceivers/set-rtx/set-rtx.ts

@@ -4,11 +4,11 @@ import type { Json, primitive } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 export type SetUpdateType = `add` | `clear` | `del` | `tx`
-export type SetUpdate = `${SetUpdateType}:${string}`
-export type NumberedSetUpdate = `${number | `*`}=${SetUpdate}`
+export type SetUpdateString = `${SetUpdateType}:${string}`
+export type NumberedSetUpdateString = `${number | `*`}=${SetUpdateString}`
 
 export interface SetRTXView<P extends primitive> extends ReadonlySet<P> {
-	readonly cache: ReadonlyArray<NumberedSetUpdate | null>
+	readonly cache: ReadonlyArray<NumberedSetUpdateString | null>
 	readonly cacheLimit: number
 	readonly cacheIdx: number
 	readonly cacheUpdateNumber: number
@@ -16,7 +16,7 @@ export interface SetRTXView<P extends primitive> extends ReadonlySet<P> {
 
 export interface SetRTXJson<P extends primitive> extends Json.Object {
 	members: P[]
-	cache: (NumberedSetUpdate | null)[]
+	cache: (NumberedSetUpdateString | null)[]
 	cacheLimit: number
 	cacheIdx: number
 	cacheUpdateNumber: number
@@ -24,13 +24,14 @@ export interface SetRTXJson<P extends primitive> extends Json.Object {
 export class SetRTX<P extends primitive>
 	extends Set<P>
 	implements
-		Transceiver<SetRTXView<P>, NumberedSetUpdate, SetRTXJson<P>>,
+		Transceiver<SetRTXView<P>, NumberedSetUpdateString, SetRTXJson<P>>,
 		Lineage
 {
 	public mode: TransceiverMode = `record`
-	public readonly subject: Subject<SetUpdate> = new Subject<SetUpdate>()
+	public readonly subject: Subject<SetUpdateString> =
+		new Subject<SetUpdateString>()
 	public cacheLimit = 0
-	public cache: (NumberedSetUpdate | null)[] = []
+	public cache: (NumberedSetUpdateString | null)[] = []
 	public cacheIdx = -1
 	public cacheUpdateNumber = -1
 
@@ -100,7 +101,7 @@ export class SetRTX<P extends primitive>
 
 	public readonly parent: SetRTX<P> | null = null
 	public child: SetRTX<P> | null = null
-	public transactionUpdates: SetUpdate[] | null = null
+	public transactionUpdates: SetUpdateString[] | null = null
 	public transaction(run: (child: SetRTX<P>) => boolean): void {
 		this.mode = `transaction`
 		this.transactionUpdates = []
@@ -134,24 +135,24 @@ export class SetRTX<P extends primitive>
 
 	protected _subscribe(
 		key: string,
-		fn: (update: SetUpdate) => void,
+		fn: (update: SetUpdateString) => void,
 	): () => void {
 		return this.subject.subscribe(key, fn)
 	}
 	public subscribe(
 		key: string,
-		fn: (update: NumberedSetUpdate) => void,
+		fn: (update: NumberedSetUpdateString) => void,
 	): () => void {
 		return this.subject.subscribe(key, (update) => {
 			fn(`${this.cacheUpdateNumber}=${update}`)
 		})
 	}
 
-	public emit(update: SetUpdate): void {
+	public emit(update: SetUpdateString): void {
 		this.subject.next(update)
 	}
 
-	private doStep(update: SetUpdate): void {
+	private doStep(update: SetUpdateString): void {
 		const typeValueBreak = update.indexOf(`:`)
 		const type = update.substring(0, typeValueBreak) as SetUpdateType
 		const value = update.substring(typeValueBreak + 1)
@@ -167,17 +168,17 @@ export class SetRTX<P extends primitive>
 				break
 			case `tx`:
 				for (const subUpdate of value.split(`;`)) {
-					this.doStep(subUpdate as SetUpdate)
+					this.doStep(subUpdate as SetUpdateString)
 				}
 		}
 	}
 
-	public getUpdateNumber(update: NumberedSetUpdate): number {
+	public getUpdateNumber(update: NumberedSetUpdateString): number {
 		const breakpoint = update.indexOf(`=`)
 		return Number(update.substring(0, breakpoint))
 	}
 
-	public do(update: NumberedSetUpdate): number | `OUT_OF_RANGE` | null {
+	public do(update: NumberedSetUpdateString): number | `OUT_OF_RANGE` | null {
 		const breakpoint = update.indexOf(`=`)
 		const updateNumber = Number(update.substring(0, breakpoint))
 		const eventOffset = updateNumber - this.cacheUpdateNumber
@@ -185,7 +186,7 @@ export class SetRTX<P extends primitive>
 		if (isFuture || Number.isNaN(eventOffset)) {
 			if (eventOffset === 1 || Number.isNaN(eventOffset)) {
 				this.mode = `playback`
-				const innerUpdate = update.substring(breakpoint + 1) as SetUpdate
+				const innerUpdate = update.substring(breakpoint + 1) as SetUpdateString
 				this.doStep(innerUpdate)
 				this.mode = `record`
 				this.cacheUpdateNumber = updateNumber
@@ -211,7 +212,7 @@ export class SetRTX<P extends primitive>
 				this.undo(u)
 				done = this.cacheIdx === eventIdx - 1
 			}
-			const innerUpdate = update.substring(breakpoint + 1) as SetUpdate
+			const innerUpdate = update.substring(breakpoint + 1) as SetUpdateString
 			this.doStep(innerUpdate)
 			this.mode = `record`
 			this.cacheUpdateNumber = updateNumber
@@ -220,7 +221,7 @@ export class SetRTX<P extends primitive>
 		return `OUT_OF_RANGE`
 	}
 
-	public undoStep(update: SetUpdate): void {
+	public undoStep(update: SetUpdateString): void {
 		const breakpoint = update.indexOf(`:`)
 		const type = update.substring(0, breakpoint) as SetUpdateType
 		const value = update.substring(breakpoint + 1)
@@ -237,7 +238,7 @@ export class SetRTX<P extends primitive>
 				break
 			}
 			case `tx`: {
-				const updates = value.split(`;`) as SetUpdate[]
+				const updates = value.split(`;`) as SetUpdateString[]
 				for (let i = updates.length - 1; i >= 0; i--) {
 					this.undoStep(updates[i])
 				}
@@ -245,12 +246,12 @@ export class SetRTX<P extends primitive>
 		}
 	}
 
-	public undo(update: NumberedSetUpdate): number | null {
+	public undo(update: NumberedSetUpdateString): number | null {
 		const breakpoint = update.indexOf(`=`)
 		const updateNumber = Number(update.substring(0, breakpoint))
 		if (updateNumber === this.cacheUpdateNumber) {
 			this.mode = `playback`
-			const innerUpdate = update.substring(breakpoint + 1) as SetUpdate
+			const innerUpdate = update.substring(breakpoint + 1) as SetUpdateString
 			this.undoStep(innerUpdate)
 			this.mode = `record`
 			this.cacheUpdateNumber--

package/src/transceivers/u-list/u-list.ts

@@ -1,24 +1,68 @@
-import type { Transceiver, TransceiverMode } from "atom.io/internal"
-import { Subject } from "atom.io/internal"
-import type { Json, primitive, stringified } from "atom.io/json"
-import { stringifyJson } from "atom.io/json"
-
-export type UListUpdateType = `add` | `clear` | `del`
-export type UListUpdate<P extends primitive> =
-	| `${`add` | `del`}:${stringified<P>}`
-	| `clear:${stringified<P[]>}`
-
-export interface UListJson<P extends primitive> extends Json.Object {
-	members: P[]
+import type {
+	Enumeration,
+	Fn,
+	Transceiver,
+	TransceiverMode,
+} from "atom.io/internal"
+import { enumeration, packValue, Subject, unpackValue } from "atom.io/internal"
+import type { primitive } from "atom.io/json"
+
+export type SetMutations = Exclude<
+	keyof Set<any>,
+	symbol | keyof ReadonlySet<any>
+>
+export type SetUpdate<P extends primitive> =
+	| {
+			type: `add` | `delete`
+			value: P
+	  }
+	| {
+			type: `clear`
+			values: P[]
+	  }
+export type UListUpdateType = SetUpdate<any>[`type`]
+true satisfies SetMutations extends UListUpdateType
+	? true
+	: Exclude<SetMutations, UListUpdateType>
+
+export type PackedSetUpdate<P extends primitive> = string & {
+	update?: SetUpdate<P>
+}
+
+export const SET_UPDATE_ENUM: Enumeration<[`add`, `delete`, `clear`]> =
+	enumeration([`add`, `delete`, `clear`] as const)
+
+export function packSetUpdate<P extends primitive>(
+	update: SetUpdate<P>,
+): PackedSetUpdate<P> {
+	const head = SET_UPDATE_ENUM[update.type] + `\u001F`
+	if (update.type === `clear`) {
+		return head + update.values.map(packValue).join(`\u001E`)
+	}
+	return head + packValue(update.value)
+}
+export function unpackSetUpdate<P extends primitive>(
+	packed: PackedSetUpdate<P>,
+): SetUpdate<P> {
+	const [type, tail] = packed.split(`\u001F`) as [0 | 1 | 2, string]
+	const head = SET_UPDATE_ENUM[type]
+	if (head === `clear`) {
+		const values = tail.split(`\u001E`).map(unpackValue) as P[]
+		return { type: `clear`, values }
+	}
+	return { type: head, value: unpackValue(tail) as P }
 }
+
+export type SetMutationHandler = { [K in UListUpdateType]: Fn }
+
 export class UList<P extends primitive>
 	extends Set<P>
-	implements Transceiver<ReadonlySet<P>, UListUpdate<P>, UListJson<P>>
+	implements
+		Transceiver<ReadonlySet<P>, PackedSetUpdate<P>, ReadonlyArray<P>>,
+		SetMutationHandler
 {
 	public mode: TransceiverMode = `record`
-	public readonly subject: Subject<UListUpdate<P>> = new Subject<
-		UListUpdate<P>
-	>()
+	public readonly subject: Subject<PackedSetUpdate<P>> = new Subject()
 
 	public constructor(values?: Iterable<P>) {
 		super(values)
@@ -28,20 +72,18 @@ export class UList<P extends primitive>
 
 	public readonly READONLY_VIEW: ReadonlySet<P> = this
 
-	public toJSON(): UListJson<P> {
-		return {
-			members: [...this],
-		}
+	public toJSON(): ReadonlyArray<P> {
+		return [...this]
 	}
 
-	public static fromJSON<P extends primitive>(json: UListJson<P>): UList<P> {
-		return new UList<P>(json.members)
+	public static fromJSON<P extends primitive>(json: ReadonlyArray<P>): UList<P> {
+		return new UList<P>(json)
 	}
 
 	public add(value: P): this {
 		const result = super.add(value)
 		if (this.mode === `record`) {
-			this.emit(`add:${stringifyJson<P>(value)}`)
+			this.emit({ type: `add`, value })
 		}
 		return result
 	}
@@ -50,73 +92,61 @@ export class UList<P extends primitive>
 		const capturedContents = this.mode === `record` ? [...this] : null
 		super.clear()
 		if (capturedContents) {
-			this.emit(`clear:${stringifyJson(capturedContents)}`)
+			this.emit({ type: `clear`, values: capturedContents })
 		}
 	}
 
 	public delete(value: P): boolean {
 		const result = super.delete(value)
 		if (this.mode === `record`) {
-			this.emit(`del:${stringifyJson<P>(value)}`)
+			this.emit({ type: `delete`, value })
 		}
 		return result
 	}
 
 	public subscribe(
 		key: string,
-		fn: (update: UListUpdate<P>) => void,
+		fn: (update: PackedSetUpdate<P>) => void,
 	): () => void {
 		return this.subject.subscribe(key, fn)
 	}
 
-	public emit(update: UListUpdate<P>): void {
-		this.subject.next(update)
+	public emit(update: SetUpdate<P>): void {
+		this.subject.next(packSetUpdate(update))
 	}
 
-	private doStep(update: UListUpdate<P>): void {
-		const typeValueBreak = update.indexOf(`:`)
-		const type = update.substring(0, typeValueBreak) as UListUpdateType
-		const value = update.substring(typeValueBreak + 1)
-		switch (type) {
+	public do(packed: PackedSetUpdate<P>): null {
+		this.mode = `playback`
+		const update = unpackSetUpdate(packed)
+		switch (update.type) {
 			case `add`:
-				this.add(JSON.parse(value))
+				this.add(update.value)
 				break
-			case `del`:
-				this.delete(JSON.parse(value))
+			case `delete`:
+				this.delete(update.value)
 				break
 			case `clear`:
 				this.clear()
 		}
-	}
-
-	public do(update: UListUpdate<P>): null {
-		this.mode = `playback`
-		this.doStep(update)
 		this.mode = `record`
 		return null
 	}
 
-	public undoStep(update: UListUpdate<P>): void {
-		const breakpoint = update.indexOf(`:`)
-		const type = update.substring(0, breakpoint) as UListUpdateType
-		const value = update.substring(breakpoint + 1)
-		switch (type) {
+	public undo(packed: PackedSetUpdate<P>): number | null {
+		const update = unpackSetUpdate(packed)
+		this.mode = `playback`
+		switch (update.type) {
 			case `add`:
-				this.delete(JSON.parse(value))
+				this.delete(update.value)
 				break
-			case `del`:
-				this.add(JSON.parse(value))
+			case `delete`:
+				this.add(update.value)
 				break
 			case `clear`: {
-				const values = JSON.parse(value) as P[]
+				const values = update.values
 				for (const v of values) this.add(v)
 			}
 		}
-	}
-
-	public undo(update: UListUpdate<P>): number | null {
-		this.mode = `playback`
-		this.undoStep(update)
 		this.mode = `record`
 		return null
 	}