@dra2020/baseclient 1.0.0

package/lib/ot-js/otarray.ts

@@ -0,0 +1,1168 @@
+import * as OT from "./ottypes";
+
+const TestUnitSize: number = 4;
+let TestCounter: number = 0;
+
+// Array Ops
+export const OpInsert: number = 1;
+export const OpDelete: number = 2;
+export const OpRetain: number = 3;
+export const OpCursor: number = 4;	// 2nd arg is 0/1 for start/end of region, 3rd arg is clientID
+export const OpSet: number = 5;
+export const OpTmpRetain: number = 6;
+
+// Op, Len, Data
+export type OTSingleArrayEdit = [number, number, any];
+export type OTEdits = OTSingleArrayEdit[];
+
+enum OTalignEdgesType { AlignForCompose, AlignForTransform };
+
+// Set of interfaces that operates on the underlying array-like value type.
+// If more efficient, can modify the initial argument and simply return it.
+// Alternatively, can create new instance and return it (string works this way since
+// underlying type is immutable).
+// This is used for the array-like specialization of IOTInterface
+export interface IOTArrayLikeOperations
+{
+	underlyingTypeName(): string;
+
+	// Return empty instance
+	empty(): any;
+
+	// Insert new instance at position specified
+	insert(t: any, pos: number, tInsert: any): any;				// Can modify input
+
+	// Delete part of instance
+	delete(t: any, pos: number, len: number): any;				// Can modify input
+
+	// Set value of part of instance
+	set(t: any, pos: number, tSet: any): any;					// Can modify input
+
+	// append to instance (insert at end)
+	append(t: any, tAppend: any): any;							// Can modify input
+
+	// Take substring of instance
+	substr(t: any, pos: number, len: number): any;				// Can modify input
+
+	// Take substring of provided base value type and set
+	substrOf(t: any, pos: number, len: number, tsub: any): any;	// Cannot modify input
+
+	// Construct an instance N long
+	constructN(n: number): any;
+
+	// Test for equality
+	equal(t1: any, t2: any): boolean;
+
+	// copy an instance
+	copy(t: any): any;											// Need to do deep copy if T is mutable.
+
+	// Return length of instance
+	length(t: any): number;
+};
+
+// Operates on a single "OTSingleArrayEdit", parameterized by an object that manipulates the underlying
+// array-like value stored as the third property of the 3-element edit object.
+export class OTSingleArrayEditor
+{
+	raw: IOTArrayLikeOperations;
+
+	constructor(raw: IOTArrayLikeOperations)
+		{
+			this.raw = raw;
+		}
+
+	copy(a: OTSingleArrayEdit): OTSingleArrayEdit 		// If a[2] is mutable, need to override and do deep copy
+		{ return [ a[0], a[1], this.raw.copy(a[2]) ]; }
+
+	// Static Predicates for MoveAction
+	isDelete(a: OTSingleArrayEdit): boolean { return a[0] == OpDelete; }
+	isNotDelete(a: OTSingleArrayEdit): boolean { return a[0] != OpDelete; }
+	isCursor(a: OTSingleArrayEdit): boolean { return a[0] == OpCursor; }
+	isNotCursor(a: OTSingleArrayEdit): boolean { return a[0] != OpCursor; }
+	isTmpRetain(a: OTSingleArrayEdit): boolean { return a[0] == OpTmpRetain; }
+	isNotTmpRetainOrDelete(a: OTSingleArrayEdit): boolean { return (a[0] != OpTmpRetain && a[0] != OpDelete); }
+	isTmpRetainOrDelete(a: OTSingleArrayEdit): boolean { return (a[0] == OpTmpRetain || a[0] == OpDelete); }
+
+	// Other static predicates
+	isIgnore(a: OTSingleArrayEdit): boolean { return a[0] < 0; }
+	isNoOp(a: OTSingleArrayEdit): boolean { return a[1] === 0 && a[0] != OpCursor; }
+	isEqual(a1: OTSingleArrayEdit, a2: OTSingleArrayEdit) { return a1[0] == a2[0] && a1[1] == a2[1] && this.raw.equal(a1[2], a2[2]); }
+
+	// Helpers
+	appendValue(a: OTSingleArrayEdit, s: any): void
+		{ a[2] = this.raw.append(a[2], s); a[1] = a[1] + this.raw.length(s); }
+	empty(a: OTSingleArrayEdit): void { a[0] = OpCursor; a[1] = 0; a[2] = this.raw.empty(); }
+	setIgnore(a: OTSingleArrayEdit): void { if (a[0] > 0) a[0] = - a[0]; }
+	substr(aIn: OTSingleArrayEdit, pos: number, len: number): void
+		{
+			let sSource: any = aIn[2];
+			if (len > 0 && pos+len <= this.raw.length(sSource))
+				aIn[2] = this.raw.substr(sSource, pos, len);
+			aIn[1] = len;
+		}
+	substrFromRaw(aIn: OTSingleArrayEdit, pos: number, len: number, s: any): void
+		{
+			let sSource: any = s;
+			if (len > 0 && pos+len <= this.raw.length(sSource))
+				aIn[2] = this.raw.substr(sSource, pos, len);
+			aIn[1] = len;
+		}
+	copyWithSubstr(aIn: OTSingleArrayEdit, pos: number, len: number): OTSingleArrayEdit
+		{
+			let aOut: OTSingleArrayEdit = this.copy(aIn);
+			this.substr(aOut, pos, len);
+			return aOut;
+		}
+};
+
+export class OTStringOperations implements IOTArrayLikeOperations
+{
+	underlyingTypeName(): string { return 'string'; }
+	empty(): any { return ''; }
+	insert(a: any, pos: number, aInsert: any): any
+		{
+			let s: string = a as string;
+			let sInsert: string = aInsert as string;
+			return s.substr(0, pos) + sInsert + s.substr(pos);
+		}
+	delete(a: any, pos: number, len: number): any
+		{
+			let s: string = a as string;
+			return s.substr(0, pos) + s.substr(pos+len);
+		}
+	set(a: any, pos: number, aSet: any): any
+		{
+			let s: string = a as string;
+			let sSet: string = aSet as string;
+			return s.substr(0, pos) + sSet + s.substr(pos+sSet.length);
+		}
+	append(a: any, aAppend: any): any
+		{
+			let s: string = a as string;
+			let sAppend: string = aAppend as string;
+			return s + sAppend;
+		}
+	substr(a: any, pos: number, len: number): any					// Can modify source
+		{
+			let s: string = a as string;
+			return s.substr(pos, len);
+		}
+	substrOf(a: any, pos: number, len: number, aSub: any): any			// Copies from tsub argument
+		{
+			// a unused if not updated with return value contents
+			let sSub: string = aSub as string;
+			return sSub.substr(pos, len);
+		}
+	constructN(n: number): any
+		{
+			let x = ' ';
+			let s = '';
+			for (;;)
+			{
+				if (n & 1)
+					s += x;
+				n >>= 1;
+				if (n)
+					x += x;
+				else
+					break;
+			}
+			return s;
+		}
+	equal(a1: any, a2: any): boolean
+		{
+			let s1: string = a1 as string;
+			let s2: string = a2 as string;
+			return s1 === s2;
+		}
+	copy(a: any): any { return a; }
+	length(a: any): number { return a.length; }
+};
+
+export class OTArrayOperations implements IOTArrayLikeOperations
+{
+	underlyingTypeName(): string { return 'array'; }
+	empty(): any { return []; }
+	insert(a: any, pos: number, aInsert: any): any
+		{
+			let arr: Array<any> = a as Array<any>;
+			let arrInsert: Array<any> = aInsert as Array<any>;
+			let arrReturn = Array(arr.length + arrInsert.length);
+			let i: number, j: number;
+			for (i = 0; i < pos; i++)
+				arrReturn[i] = arr[i];
+			for (j = 0; j < arrInsert.length; j++)
+				arrReturn[i+j] = arrInsert[j];
+			for (i = pos; i < arr.length; i++)
+				arrReturn[i+j] = arr[i];
+			return arrReturn;
+		}
+	delete(a: any, pos: number, len: number): any
+		{
+			let arr: Array<any> = a as Array<any>;
+			arr.splice(pos, len);
+			return arr;
+		}
+	set(a: any, pos: number, aSet: any): any
+		{
+			let arr: Array<any> = a as Array<any>;
+			let arrSet: Array<any> = aSet as Array<any>;
+			for (let i: number = 0; i < arrSet.length; i++)
+				arr[i+pos] = arrSet[i];
+			return arr;
+		}
+	append(a: any, aAppend: any): any
+		{
+			let arr: Array<any> = a as Array<any>;
+			let arrAppend: Array<any> = aAppend as Array<any>;
+			return arr.concat(arrAppend);
+		}
+	substr(a: any, pos: number, len: number): any					// Can modify source
+		{
+			let arr: Array<any> = a as Array<any>;
+			return arr.slice(pos, pos+len);
+		}
+	substrOf(a: any, pos: number, len: number, aSub: any): any			// Copies from tsub argument
+		{
+			// a unused if not updated with return value contents
+			let arrSub: Array<any> = aSub as Array<any>;
+			return arrSub.slice(pos, pos+len);
+		}
+	constructN(n: number): any
+		{
+			return new Array(n);
+		}
+	equal(a1: any, a2: any): boolean
+		{
+			let arr1: Array<any> = a1 as Array<any>;
+			let arr2: Array<any> = a2 as Array<any>;
+			if (arr1.length != arr2.length)
+				return false;
+			for (let i: number = 0; i < arr1.length; i++)
+				if (arr1[i] !== arr2[i])
+					return false;
+			return true;
+		}
+	copy(a: any): any
+		{
+			let arr: Array<any> = a as Array<any>;
+			let arrRet = new Array(arr.length);
+			for (let i: number = 0; i < arr.length; i++)
+				arrRet[i] = arr[i];
+			return arrRet;
+		}
+	length(a: any): number
+		{
+			return a.length;
+		}
+};
+
+export class OTArrayLikeResource extends OT.OTResourceBase
+{
+	editor: OTSingleArrayEditor;
+
+	constructor(ed: OTSingleArrayEditor, rname: string)
+		{
+			super(rname, ed.raw.underlyingTypeName());
+			this.editor = ed;
+		}
+
+	copy(): OTArrayLikeResource
+		{
+			return null;	// Needs to be overridden
+		}
+
+	moveEdits(newA: OTEdits, iStart: number, iEnd?: number, pred?: (a: OTSingleArrayEdit) => boolean)
+		{
+			if (iEnd == undefined)
+				iEnd = this.edits.length - 1;
+
+			for (; iStart <= iEnd; iStart++)
+			{
+				let a: OTSingleArrayEdit = this.edits[iStart];
+				if (!this.editor.isIgnore(a) && (pred == undefined || pred(a)))
+					newA.push(a);
+			}
+		}
+
+	equal(rhs: OTArrayLikeResource): boolean
+		{
+			if (this.length != rhs.length)
+				return false;
+			for (let i: number = 0; i < this.length; i++)
+				if (! this.editor.isEqual(this.edits[i], rhs.edits[i]))
+					return false;
+			return true;
+		}
+
+	// Function: OTArrayLikeResource::effectivelyEqual
+	//
+	// Description:
+	//	A looser definition than operator==. Returns true if two actions would result in the
+	//	same final string. This ignores no-ops like OpCursor and allows different orderings of
+	//	inserts and deletes at the same location.
+	//
+	//  Played around with different algorithms, but the simplest is probably just to apply
+	//	the two actions and see if I get the same final string. Came up with an interesting
+	//	algorithm of walking through comparing hashes, but that was not robust to operations
+	//	being split into fragments and interposed with alternate ops (OpCursor or interleaving of Ins/Del)
+	//	that still leave the string the same. If unhappy with this approach (which scales with size
+	//	of string to edit rather than complexity of the edit), the other approach would be to canonicalize
+	//	the edit operations (including removing cursor operations and normalizing order of deletes).
+	//	(Added that version of the algorithm under #ifdef). Could also dynamically choose approach based
+	//	on relative size of arrays.
+	//
+	effectivelyEqual(rhs: OTArrayLikeResource): boolean
+		{
+			// Exactly equal is always effectively equal
+			if (this.equal(rhs))
+				return true;
+
+			if (this.originalLength() != rhs.originalLength())
+				return false;
+
+			// Preferred algorithm
+			let s: any = this.editor.raw.constructN(this.originalLength());
+
+			let sL: any = this.apply(s);
+			let sR: any = rhs.apply(s);
+			return sL === sR;
+
+			// Alternate algorithm (see above)
+			//let aL: OTArrayLikeResource = this.copy();
+			//let aR: OTArrayLikeResource = rhs.copy();
+
+			//aL.fullyCoalesce();
+			//aR.fullyCoalesce();
+			//return aL.equal(aR);
+		}
+
+	basesConsistent(rhs: OTArrayLikeResource): void
+		{
+			if (this.originalLength() != rhs.originalLength())
+			{
+				console.log("Logic Failure: transform: Bases Inconsistent.");
+				throw("Logic Failure: transform: Bases Inconsistent.");
+			}
+		}
+
+	originalLength(): number
+		{
+			let len: number = 0;
+
+			for (let i: number = 0; i < this.length; i++)
+			{
+				let a: OTSingleArrayEdit = this.edits[i];
+				if (a[0] == OpRetain || a[0] == OpDelete || a[0] == OpSet)
+					len += a[1];
+			}
+			return len;
+		}
+
+	finalLength(): number
+		{
+			let len: number = 0;
+
+			for (let i: number = 0; i < this.length; i++)
+			{
+				let a: OTSingleArrayEdit = this.edits[i];
+				if (a[0] == OpRetain || a[0] == OpInsert || a[0] == OpSet)
+					len += a[1];
+			}
+			return len;
+		}
+
+	apply(aValue: any): any
+		{
+			if (aValue == null)
+				aValue = this.editor.raw.empty();
+			let pos: number = 0;
+			for (let i: number = 0; i < this.length; i++)
+			{
+				let a: OTSingleArrayEdit = this.edits[i];
+
+				switch (a[0])
+				{
+					case OpRetain:
+						pos += a[1];
+						break;
+					case OpCursor:
+						break;
+					case OpDelete:
+						aValue = this.editor.raw.delete(aValue, pos, a[1]);
+						break;
+					case OpInsert:
+						aValue = this.editor.raw.insert(aValue, pos, a[2]);
+						pos += a[1];
+						break;
+					case OpSet:
+						aValue = this.editor.raw.set(aValue, pos, a[2]);
+						pos += a[1];
+						break;
+				}
+			}
+			return aValue;
+		}
+
+	coalesce(bDeleteCursor: boolean = false): void
+		{
+			if (this.length == 0)
+				return;
+
+			// coalesce adjoining actions and delete no-ops
+			let newA: OTEdits = [];
+			let aLast: OTSingleArrayEdit;
+			for (let i: number = 0; i < this.length; i++)
+			{
+				let aNext: OTSingleArrayEdit = this.edits[i];
+				if (this.editor.isNoOp(aNext) || (bDeleteCursor && aNext[0] == OpCursor))
+					continue;
+
+				if (newA.length > 0 && aNext[0] == aLast[0])
+				{
+					if (aNext[0] == OpInsert || aNext[0] == OpSet)
+						this.editor.appendValue(aLast, aNext[2]);
+					else
+						aLast[1] += aNext[1];
+				}
+				else
+				{
+					newA.push(aNext);
+					aLast = aNext;
+				}
+			}
+
+			this.edits = newA;
+		}
+
+	// Function: fullyCoalesce
+	//
+	// Description:
+	//	Heavier duty version of coalesce that fully normalizes so that two actions that result in same
+	//	final edit are exactly the same. This normalizes order of insert/deletes and deletes OpCursor,
+	//	and then does coalesce.
+	//
+	fullyCoalesce(): void
+		{
+			// TODO
+			this.coalesce(true);
+		}
+
+	// Function: Invert
+	//
+	// Description:
+	//	Given an action, convert it to its inverse (action + inverse) = identity (retain(n)).
+	//
+	//	Note that in order to compute the inverse, you need the input state (e.g. because in order to invert
+	//	OpDelete, you need to know the deleted characters.
+	//
+	invert(sInput: any): void
+		{
+			let pos: number = 0;	// Tracks position in input string.
+
+			for (let i: number = 0; i < this.length; i++)
+			{
+				let a: OTSingleArrayEdit = this.edits[i];
+
+				switch (a[0])
+				{
+					case OpCursor:
+						break;
+					case OpRetain:
+						pos += a[1];
+						break;
+					case OpInsert:
+						a[2] = '';
+						a[0] = OpDelete;
+						break;
+					case OpDelete:
+						a[2] = this.editor.copyWithSubstr(sInput, pos, a[1]);
+						a[0] = OpInsert;
+						pos += a[1];
+						break;
+					case OpSet:
+						a[2] = this.editor.copyWithSubstr(sInput, pos, a[1]);
+						pos += a[1];
+						break;
+				}
+			}
+		}
+
+	// Function: alignEdges
+	//
+	// Description:
+	//	Slice up this action sequence so its edges align with the action sequence I am going to
+	//	process it with. The processing (compose or transform) determines which actions Slice
+	//	takes into account when moving the parallel counters forward. When processing for
+	//	compose, deletes in rhs can be ignored. When processing for transform, inserts in both
+	//	lhs and rhs can be ignored.
+	//	
+
+	alignEdges(rhs: OTArrayLikeResource, st: OTalignEdgesType): void
+		{
+			let posR: number = 0;
+			let posL: number = 0;
+			let iL: number = 0;
+			let newA: OTEdits = [];
+			let aAfter: OTSingleArrayEdit = undefined;
+			let aL: OTSingleArrayEdit = undefined;
+
+			for (let iR: number = 0; iR < rhs.length; iR++)
+			{
+				let aR: OTSingleArrayEdit = rhs.edits[iR];
+
+				switch (aR[0])
+				{
+					case OpCursor:
+						break;
+					case OpInsert:
+						break;
+					case OpDelete:
+						posR += aR[1];
+						break;
+					case OpSet:
+						posR += aR[1];
+						break;
+					case OpRetain:
+						posR += aR[1];
+						break;
+				}
+
+				// Advance iL/posL to equal to posR
+				while (posL < posR && (aAfter != undefined || iL < this.length))
+				{
+					if (aAfter == undefined)
+					{
+						aL = this.edits[iL];
+						newA.push(aL);
+						iL++;
+					}
+					else
+					{
+						aL = aAfter;
+					}
+
+					switch (aL[0])
+					{
+						case OpCursor:
+							break;
+						case OpInsert:
+							if (st == OTalignEdgesType.AlignForCompose) posL += aL[1];
+							break;
+						case OpDelete:
+							if (st == OTalignEdgesType.AlignForTransform) posL += aL[1];
+							break;
+						case OpSet:
+							posL += aL[1];
+							break;
+						case OpRetain:
+							posL += aL[1];
+							break;
+					}
+
+					// Split this one if it spans boundary
+					if (posL > posR)
+					{
+						let nRight: number = posL - posR;
+						let nLeft: number = aL[1] - nRight;
+
+						aAfter = this.editor.copyWithSubstr(aL, nLeft, nRight);
+						this.editor.substr(aL, 0, nLeft);
+						newA.push(aAfter);
+						posL = posR;
+					}
+					else
+						aAfter = undefined;
+				}
+			}
+
+			// Append any we missed
+			this.moveEdits(newA, iL);
+
+			this.edits = newA;
+		}
+	
+	getCursorCache(): any
+		{
+			let cursorCache: any = { };
+
+			for (let i: number = 0; i < this.length; i++)
+			{
+				let a: OTSingleArrayEdit = this.edits[i];
+
+				if (a[0] == OpCursor && a[2] != null)
+					cursorCache[a[2]] = '';
+			}
+			return cursorCache;
+		}
+
+	// Function: compose
+	//
+	// Description:
+	//	compose the current action with the action passed in. This alters the current action.
+	//
+	//	Basic structure is to walk through the RHS list of actions, processing each one in turn.
+	//	That then drives the walk through the left hand side and the necessary edits. I use
+	//	"posR" and "posL" to work through equivalent positions in the two strings being edited.
+	//	Deletions in the LHS don't effect posL because they don't show up in the input string to RHS.
+	//	Similarly, insertions in the RHS don't effect posR since they have no equivalent string location
+	//	in the LHS.	(Note transform follows similar structure but different logic for how posR and posL
+	//	track each other since in that case they are effectively referencing the same input string.)
+	//
+	compose(rhs: OTArrayLikeResource): void
+		{
+			let cursorCache: any = rhs.getCursorCache();
+
+			if (this.length == 0)
+			{
+				this.edits = rhs.edits.map(this.editor.copy, this.editor);
+				return;
+			}
+			else if (rhs.edits.length == 0)
+				return;
+
+			if (this.finalLength() != rhs.originalLength())
+			{
+				console.log("Logic Failure: compose: Bases Inconsistent.");
+				throw("Logic Failure: compose: Bases Inconsistent.");
+			}
+
+			// Break overlapping segments before start to simplify logic below.
+			this.alignEdges(rhs, OTalignEdgesType.AlignForCompose);
+
+			// Iterate with parallel position markers in two arrays
+			let posR: number = 0;
+			let posL: number = 0;
+			let iL: number = 0;
+			let bDone: boolean;
+			let newA: OTSingleArrayEdit[] = [];
+
+			for (let iR: number = 0; iR < rhs.length; iR++)
+			{
+				let aR: OTSingleArrayEdit = rhs.edits[iR];
+
+				switch (aR[0])
+				{
+					case OpRetain:
+						posR += aR[1];
+						break;
+
+					case OpSet:
+					case OpDelete:
+					case OpInsert:
+					case OpCursor:
+						// Advance to cursor location
+						bDone = false;
+						while (!bDone && iL < this.length)
+						{
+							let aL: OTSingleArrayEdit = this.edits[iL];
+
+							switch (aL[0])
+							{
+								case OpCursor:
+									// Only copy old cursor locations if they aren't empty and aren't duplicated in this rhs.
+									if (aL[2] != '' && cursorCache[aL[2]] === undefined)
+										newA.push(aL);
+									iL++;
+									break;
+								case OpSet:
+								case OpRetain:
+								case OpInsert:
+									if (posL == posR)
+										bDone = true;
+									else
+									{
+										posL += aL[1];
+										newA.push(aL);
+										iL++;
+									}
+									break;
+								case OpDelete:
+									newA.push(aL);
+									iL++;	// Move past since deletes are not referenced by RHS
+									break;
+							}
+						}
+
+						if (aR[0] == OpDelete)
+						{
+							// Remove sequence of cursor, insert, retains, sets, replaced by delete.
+							// Note that insert/delete cancel each other out, so there is a bit of complexity there.
+							let nChange: number = aR[1];
+							let nRemain: number = aR[1];
+							for (; nChange > 0 && iL < this.length; iL++)
+							{
+								let aL: OTSingleArrayEdit = this.edits[iL];
+
+								switch (aL[0])
+								{
+									case OpCursor:
+										// Only copy old cursor locations if they aren't empty and aren't duplicated in this rhs.
+										if (aL[2] != '' && cursorCache[aL[2]] === undefined)
+											newA.push(aL);
+										break;
+									case OpDelete:
+										newA.push(aL);
+										break;
+									case OpSet:
+									case OpRetain:
+									case OpInsert:
+										nRemain -= aL[0] == OpInsert ? aL[1] : 0;
+										nChange -= aL[1];
+										// Don't copy into new array
+										break;
+								}
+							}
+
+							// Now add in the delete
+							if (nRemain > 0)
+								newA.push([ OpDelete, nRemain, '' ]);
+						}
+						else if (aR[0] == OpSet)
+						{
+							// Process sequence of cursor, insert, retains, sets
+							let nChange: number = aR[1];
+							for (; nChange > 0 && iL < this.length; iL++)
+							{
+								let aL: OTSingleArrayEdit = this.edits[iL];
+								let opL: number = OpInsert;
+
+								switch (aL[0])
+								{
+									case OpCursor:
+										// Only copy old cursor locations if they aren't empty and aren't duplicated in this rhs.
+										if (aL[2] != '' && cursorCache[aL[2]] === undefined)
+											newA.push(aL);
+										break;
+									case OpDelete:
+										newA.push(aL);
+										break;
+									case OpSet:
+									case OpRetain:
+										opL = OpSet;
+										// fallthrough
+									case OpInsert:
+										// A Set composed with Insert becomes Insert of Set content
+										this.editor.substrFromRaw(aL, aR[1]-nChange, aL[1], aR[2]);
+										aL[0] = opL;
+										nChange -= aL[1];
+										newA.push(aL);
+										break;
+								}
+							}
+						}
+						else // cursor, insert
+						{
+							// Add in the RHS operation at proper location
+							newA.push(this.editor.copy(aR));
+						}
+						break;
+				}
+			}
+
+			// copy any remaining actions, excluding cursors duplicated in rhs
+			this.moveEdits(newA, iL, this.length-1,
+				function (e: OTSingleArrayEdit)
+					{ return (e[0] != OpCursor) || (e[2] != '' && cursorCache[e[2]] === undefined) } );
+
+			this.edits = newA;
+
+			this.coalesce();
+		}
+
+	performTransformReorder(bForceRetainBeforeInsert: boolean, newA: OTEdits, iBegin: number, iEnd: number): void
+		{
+			if (iBegin < 0 || iBegin > iEnd) return;
+			if (bForceRetainBeforeInsert)
+			{
+				this.moveEdits(newA, iBegin, iEnd, this.editor.isTmpRetainOrDelete);
+				this.moveEdits(newA, iBegin, iEnd, this.editor.isNotTmpRetainOrDelete);	// Is Insert or Cursor
+			}
+			else
+			{
+				this.moveEdits(newA, iBegin, iEnd, this.editor.isNotTmpRetainOrDelete);	// Is Insert or Cursor
+				this.moveEdits(newA, iBegin, iEnd, this.editor.isTmpRetainOrDelete);
+			}
+		}
+
+	// Function: normalizeNewRetainsAfterTransform
+	//
+	// Description:
+	//	Helper function for transform() that does a post-processing pass to ensure that all
+	//	Retains are properly ordered with respect to Inserts that occur at the same location
+	//	(either before or after, depending on whether we are transforming based on server or client side).
+	//	This ensures that the transform process is not sensitive to precise ordering of Inserts and
+	//	Retains (since that ordering doesn't actually change the semantics of the edit performed and
+	//	therefore should not result in a difference in processing here). And yes, it's a subtle issue
+	//	that may not actually occur in real edits produced by some particular editor but does arise when
+	//	testing against randomly generated edit streams.
+	//
+	//	A side consequence is also normalizing the ordering of inserts and deletes which also doesn't
+	//	change the semantics of the edit but ensures we properly detect conflicting insertions.
+	//
+	//	The way to think of this algorithm is that Set's and Retains (pre-existing, not new TmpRetains) form
+	//	hard boundaries in the ordering. The series of Cursor/TmpRetain/Insert/Deletes between Sets and Retains
+	//	are re-ordered by this algorithm. TmpRetain's get pushed to the front or the back depending on the bForce
+	//	flag passed in (which reflects which operation had precedence).
+	//
+	normalizeNewRetainsAfterTransform(bForceRetainBeforeInsert: boolean): void
+		{
+			if (this.length == 0)
+				return;
+
+			let i: number = 0;
+			let newA: OTSingleArrayEdit[] = [];
+			let iLastEdge: number = 0;
+
+			// Normalize ordering for newly insert retains so they are properly ordered
+			// with respect to inserts occurring at the same location.
+			for (i = 0; i < this.length; i++)
+			{
+				let a: OTSingleArrayEdit = this.edits[i];
+				if (a[0] == OpSet || a[0] == OpRetain)
+				{
+					this.performTransformReorder(bForceRetainBeforeInsert, newA, iLastEdge, i-1);
+					newA.push(a);
+					iLastEdge = i+1;
+				}
+			}
+			this.performTransformReorder(bForceRetainBeforeInsert, newA, iLastEdge, this.length-1);
+
+			// One last time to switch TmpRetain to Retain
+			for (i = 0; i < newA.length; i++)
+				if ((newA[i])[0] == OpTmpRetain)
+					(newA[i])[0] = OpRetain;
+			this.edits = newA;
+		}
+
+	transform(prior: OTArrayLikeResource, bPriorIsService: boolean): void
+		{
+			if (this.length == 0 || prior.length == 0)
+				return;
+
+			// Validate
+			this.basesConsistent(prior);
+
+			// Break overlapping segments before start to simplify logic below.
+			this.alignEdges(prior, OTalignEdgesType.AlignForTransform);
+
+			let posR: number = 0; // These walk in parallel across the consistent base strings (only retains, sets and deletes count)
+			let posL: number = 0;
+			let iL: number = 0;
+			let bDone: boolean;
+			let newA: OTEdits = [];
+
+			for (let iR: number = 0; iR < prior.length; iR++)
+			{
+				let aR: OTSingleArrayEdit = prior.edits[iR];
+
+				switch (aR[0])
+				{
+					case OpCursor:
+						// No-op
+						break;
+					case OpInsert:
+						{
+						// Converts to a retain.
+						// Need to find spot to insert retain. After loop, iL will contain location
+						for (; iL < this.length; iL++)
+						{
+							if (posR == posL)
+								break;
+
+							let aL: OTSingleArrayEdit = this.edits[iL];
+							if (this.editor.isIgnore(aL))
+								continue;
+							if (aL[0] != OpCursor && aL[0] != OpInsert)
+								posL += aL[1];
+							newA.push(aL);
+						}
+						let nRetain: number = aR[1];
+						newA.push([ OpTmpRetain, nRetain, '' ]);
+						posR += nRetain;
+						posL += nRetain;
+						}
+						break;
+					case OpSet:
+						// Somewhat unintuitively, if prior is *not* service, then it will actually get applied *after*
+						// the service instance of OpSet and so should take precedence. Therefore if prior is not service,
+						// we need to go through and convert "OpSets" that overlap to be this content. If prior is service,
+						// we can just treat them as "retains" since they have no effect on our operations.
+						if (bPriorIsService)
+							posR += aR[1];
+						else
+						{
+							let nRemaining: number = aR[1];
+							while (nRemaining > 0 && iL < this.length)
+							{
+								let aL: OTSingleArrayEdit = this.edits[iL];
+								if (this.editor.isIgnore(aL))
+								{
+									iL++;
+									continue;
+								}
+								let valL: number = aL[1];
+
+								if (aL[0] == OpCursor || aL[0] == OpInsert)
+								{
+									iL++;
+									newA.push(aL);
+								}
+								else
+								{
+									if (posR >= posL+valL)
+									{
+										// Not there yet
+										posL += valL;
+										iL++;
+										newA.push(aL);
+									}
+									else
+									{
+										if (aL[0] == OpDelete || aL[0] == OpRetain)
+										{
+											if (valL <= nRemaining)
+											{
+												posR += valL;
+												posL += valL;
+												nRemaining -= valL;
+												iL++;
+												newA.push(aL);
+											}
+											else
+											{
+												// Not subsumed, but means that I didn't encounter an OpSet
+												posR += nRemaining;
+												nRemaining = 0;
+											}
+										}
+										else // OpSet
+										{
+											if (aL[1] <= nRemaining)
+											{
+												posR += valL;
+												posL += valL;
+												this.editor.substrFromRaw(aL, aR[1] - nRemaining, valL, aR[2]);
+												nRemaining -= valL;
+												iL++;
+												newA.push(aL);
+											}
+											else
+											{
+												// don't advance posL or iL because we will re-process the left over
+												// part for the next action. Simply edit the data in place.
+												// Set [0, nRemaining] of aL.Data to [aR[1]-nRemaining, nRemaining]
+												//aL.Data.delete(0, nRemaining);
+												//aL.Data.InsertValue(0, aR.Data, aR[1]-nRemaining, nRemaining);
+												aL[2] = aR[2].substr(aR[1] - nRemaining) + aL[2].substr(nRemaining);
+												posR += nRemaining;
+												nRemaining = 0;
+											}
+										}
+									}
+								}
+							}
+						}
+						break;
+					case OpDelete:
+						{
+						let nRemaining: number = aR[1];
+						let nDelay: number = 0;
+						let iDelay: number;
+
+						// Retains, sets and deletes are subsumed by prior deletes
+						for (; nRemaining > 0 && iL < this.length; iL++)
+						{
+							let aL: OTSingleArrayEdit = this.edits[iL];
+							if (this.editor.isIgnore(aL))
+							{
+								if (nDelay > 0)
+									nDelay++;
+								continue;
+							}
+
+							if (aL[0] == OpCursor || aL[0] == OpInsert)
+							{
+								if (nDelay == 0)
+									iDelay = iL;
+								nDelay++;
+							}
+							else
+							{
+								if (posR >= posL+aL[1])
+								{
+									// Go ahead and push any delayed actions
+									for (let j: number = iDelay; nDelay > 0; nDelay--, j++)
+									{
+										let aD: OTSingleArrayEdit = this.edits[j];
+										if (! this.editor.isIgnore(aD))
+											newA.push(aD);
+									}
+
+									// Prior to the deleted content
+									posL += aL[1];
+									newA.push(aL);
+								}
+								else
+								{
+									// Retain/set/delete is fully subsumed.
+									posR += aL[1];
+									posL += aL[1];
+									nRemaining -= aL[1];
+									this.editor.setIgnore(aL);
+									if (nDelay > 0)
+										nDelay++;
+								}
+							}
+						}
+
+						// We want to reprocess any trailing insert/cursors so we recognize conflicting inserts even when
+						// deletes intervene.
+						if (nDelay > 0)
+							iL = iDelay;
+						}
+						break;
+					case OpRetain:
+						// Just advance cursor
+						posR += aR[1];
+						break;
+				}
+			}
+
+			this.moveEdits(newA, iL);
+			this.edits = newA;
+			this.normalizeNewRetainsAfterTransform(bPriorIsService);
+			this.coalesce();
+		}
+
+	//
+	// Function: generateRandom
+	//
+	// Description:
+	//	Generate action containing a sequence of retain, insert, delete, cursor with the initial
+	//	state of the string being nInitial. Make sure I always generate at least one insert or delete.
+	//	Always operate in units of 4 (.123).
+	//
+	generateRandom(nInitial: number, clientID: string): void
+		{
+			// Ensure clean start
+			this.empty();
+
+			// Setup randomizer
+			let nOps: number = 0;
+			let nLen: number;
+			let nBound: number;
+			let s: any;
+
+			while (nInitial > 0 || nOps == 0)
+			{
+				let op: number = randomWithinRange(0, 4);
+
+				nBound = nInitial / TestUnitSize;
+				if (nInitial == 0 && (op == OpDelete || op == OpRetain || op == OpSet))
+					continue;
+				switch (op)
+				{
+					case OpInsert:
+						nOps++;
+						nLen = randomWithinRange(1, 5);
+						s = this.editor.raw.empty();
+						for (let i: number = 0; i < nLen; i++)
+							s = this.editor.raw.append(s, counterValue(this.editor.raw, TestCounter++));
+						nLen *= TestUnitSize;
+						this.edits.push([ OpInsert, nLen, s ]);
+						break;
+					case OpDelete:
+						nOps++;
+						nLen = randomWithinRange(1, nBound > 3 ? nBound / 3 : nBound);
+						nLen *= TestUnitSize;
+						nInitial -= nLen;
+						this.edits.push([ OpDelete, nLen, this.editor.raw.empty() ]);
+						break;
+					case OpCursor:
+						this.edits.push([ OpCursor, 0, clientID ]);
+						break;
+					case OpRetain:
+						nLen = randomWithinRange(1, nBound);
+						nLen *= TestUnitSize;
+						nInitial -= nLen;
+						this.edits.push([ OpRetain, nLen, this.editor.raw.empty() ]);
+						break;
+					case OpSet:
+						nLen = 1;
+						s = this.editor.raw.empty();
+						for (let i: number = 0; i < nLen; i++)
+							this.editor.raw.append(s, counterValue(this.editor.raw, TestCounter++));
+						nLen *= TestUnitSize;
+						nInitial -= nLen;
+						this.edits.push([ OpSet, nLen, s ]);
+						break;
+				}
+			}
+
+			// Most importantly ensures canonical ordering of inserts and deletes.
+			this.coalesce();
+		}
+}
+
+export class OTStringResource extends OTArrayLikeResource
+{
+	static _editor: OTSingleArrayEditor = new OTSingleArrayEditor(new OTStringOperations());
+	constructor(rname: string)
+		{
+			super(OTStringResource._editor, rname);
+		}
+	static factory(rname: string): OTStringResource { return new OTStringResource(rname); }
+	copy(): OTStringResource
+		{
+			let copy: OTStringResource = new OTStringResource(this.resourceName);
+			copy.edits = this.edits.map(copy.editor.copy, copy.editor);
+			return copy;
+		}
+}
+
+export class OTArrayResource extends OTArrayLikeResource
+{
+	static _editor: OTSingleArrayEditor = new OTSingleArrayEditor(new OTArrayOperations());
+	constructor(rname: string)
+		{
+			super(OTArrayResource._editor, rname);
+		}
+	static factory(rname: string): OTArrayResource { return new OTArrayResource(rname); }
+
+	copy(): OTArrayResource
+		{
+			let copy: OTArrayResource = new OTArrayResource(this.resourceName);
+			copy.edits = this.edits.map(copy.editor.copy, copy.editor);
+			return copy;
+		}
+}
+
+function randomWithinRange(nMin: number, nMax: number): number
+{
+	return nMin + Math.floor(Math.random() * (nMax - nMin + 1));
+}
+
+function counterValue(ops: IOTArrayLikeOperations, c: number): any
+{
+	switch (ops.underlyingTypeName())
+	{
+		case 'string':
+			{
+				let a: string[] = new Array(TestUnitSize);
+				a[0] = '.';
+				for (let j: number = 1; j < TestUnitSize; j++, c = Math.floor(c / 10))
+					a[TestUnitSize - j] = "" + (c % 10);
+				return a.join('');
+			}
+		case 'array':
+			{
+				let a: number[] = new Array(TestUnitSize);
+				for (let i: number = 0; i < TestUnitSize; i++, c += 0.1)
+					a[i] = c;
+				return a;
+			}
+		default:
+			throw "counterValue: Unexpected underlying array-like type."
+	}
+}