@creationix/rex 0.3.1 → 0.4.1

package/rexc-interpreter.ts

@@ -4,48 +4,50 @@ const DIGITS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_
 const digitMap = new Map<string, number>(Array.from(DIGITS).map((char, index) => [char, index]));
 
 const OPCODES = {
-	do: 0,
-	add: 1,
-	sub: 2,
-	mul: 3,
-	div: 4,
-	eq: 5,
-	neq: 6,
-	lt: 7,
-	lte: 8,
-	gt: 9,
-	gte: 10,
-	and: 11,
-	or: 12,
-	xor: 13,
-	not: 14,
-	boolean: 15,
-	number: 16,
-	string: 17,
-	array: 18,
-	object: 19,
-	mod: 20,
-	neg: 21,
+	do: "",
+	add: "ad",
+	sub: "sb",
+	mul: "ml",
+	div: "dv",
+	eq: "eq",
+	neq: "nq",
+	lt: "lt",
+	lte: "le",
+	gt: "gt",
+	gte: "ge",
+	and: "an",
+	or: "or",
+	xor: "xr",
+	not: "nt",
+	boolean: "bt",
+	number: "nm",
+	string: "st",
+	array: "ar",
+	object: "ob",
+	mod: "md",
+	neg: "ng",
+	range: "rn",
+	size: "sz",
 } as const;
 
 export type RexcContext = {
 	vars?: Record<string, unknown>;
-	refs?: Partial<Record<number, unknown>>;
+	refs?: Record<string, unknown>;
 	self?: unknown;
 	selfStack?: unknown[];
-	opcodes?: Partial<Record<number, (args: unknown[], state: RexcRuntimeState) => unknown>>;
+	opcodes?: Record<string, (args: unknown[], state: RexcRuntimeState) => unknown>;
 	/** Maximum loop iterations before the interpreter throws. */
 	gasLimit?: number;
 };
 
 export type RexcRuntimeState = {
 	vars: Record<string, unknown>;
-	refs: Record<number, unknown>;
+	refs: Record<string, unknown>;
 };
 
 type LoopControl = { kind: "break" | "continue"; depth: number };
 
-type OpcodeMarker = { __opcode: number };
+type OpcodeMarker = { __opcode: string };
 
 function decodePrefix(text: string, start: number, end: number): number {
 	let value = 0;
@@ -64,7 +66,7 @@ function decodeZigzag(value: number): number {
 function isValueStart(char: string | undefined): boolean {
 	if (!char) return false;
 	if (digitMap.has(char)) return true;
-	return "+*:%$@'^~=([{,?!|&><;".includes(char);
+	return "+*:%$@'^~=/([{,?!|&><;".includes(char);
 }
 
 function isDefined(value: unknown): boolean {
@@ -76,7 +78,6 @@ class CursorInterpreter {
 	private pos = 0;
 	private readonly state: RexcRuntimeState;
 	private readonly selfStack: unknown[];
-	private readonly opcodeMarkers: OpcodeMarker[];
 	private readonly pointerCache = new Map<number, unknown>();
 	private readonly gasLimit: number;
 	private gas = 0;
@@ -96,31 +97,26 @@ class CursorInterpreter {
 		this.state = {
 			vars: ctx.vars ?? {},
 			refs: {
-				0: ctx.refs?.[0],
-				1: ctx.refs?.[1] ?? true,
-				2: ctx.refs?.[2] ?? false,
-				3: ctx.refs?.[3] ?? null,
-				4: ctx.refs?.[4] ?? undefined,
-				5: ctx.refs?.[5] ?? NaN,
-				6: ctx.refs?.[6] ?? Infinity,
-				7: ctx.refs?.[7] ?? -Infinity,
+				tr: true,
+				fl: false,
+				nl: null,
+				un: undefined,
+				nan: NaN,
+				inf: Infinity,
+				nif: -Infinity,
+				...ctx.refs,
 			},
 		};
 		this.selfStack = ctx.selfStack && ctx.selfStack.length > 0 ? [...ctx.selfStack] : [initialSelf];
 		this.gasLimit = ctx.gasLimit ?? 0;
-		this.opcodeMarkers = Array.from({ length: 256 }, (_, id) => ({ __opcode: id }));
-		for (const [idText, value] of Object.entries(ctx.refs ?? {})) {
-			const id = Number(idText);
-			if (Number.isInteger(id)) this.state.refs[id] = value;
-		}
 		if (ctx.opcodes) {
-			for (const [idText, op] of Object.entries(ctx.opcodes)) {
-				if (op) this.customOpcodes.set(Number(idText), op);
+			for (const [key, op] of Object.entries(ctx.opcodes)) {
+				if (op) this.customOpcodes.set(key, op);
 			}
 		}
 	}
 
-	private readonly customOpcodes = new Map<number, (args: unknown[], state: RexcRuntimeState) => unknown>();
+	private readonly customOpcodes = new Map<string, (args: unknown[], state: RexcRuntimeState) => unknown>();
 
 	private readSelf(depthPrefix: number): unknown {
 		const depth = depthPrefix + 1;
@@ -176,6 +172,20 @@ class CursorInterpreter {
 		return { start, end, value: decodePrefix(this.text, start, end), raw: this.text.slice(start, end) };
 	}
 
+	private advanceByBytes(start: number, byteCount: number): number {
+		if (byteCount <= 0) return start;
+		let bytes = 0;
+		let index = start;
+		for (const char of this.text.slice(start)) {
+			const charBytes = Buffer.byteLength(char);
+			if (bytes + charBytes > byteCount) break;
+			bytes += charBytes;
+			index += char.length;
+			if (bytes === byteCount) return index;
+		}
+		throw new Error("String container overflows input");
+	}
+
 	private ensure(char: string) {
 		if (this.text[this.pos] !== char) throw new Error(`Expected '${char}' at ${this.pos}`);
 		this.pos += 1;
@@ -217,35 +227,34 @@ class CursorInterpreter {
 				const power = decodeZigzag(prefix.value);
 				const significand = this.evalValue();
 				if (typeof significand !== "number") throw new Error("Decimal significand must be numeric");
-				return significand * 10 ** power;
+				return parseFloat(`${significand}e${power}`);
 			}
 			case ":":
 				this.pos += 1;
 				return prefix.raw;
 			case "%":
 				this.pos += 1;
-				return this.opcodeMarkers[prefix.value] ?? { __opcode: prefix.value };
+				return { __opcode: prefix.raw } satisfies OpcodeMarker;
 			case "@":
 				this.pos += 1;
 				return this.readSelf(prefix.value);
 			case "'":
 				this.pos += 1;
-				return this.state.refs[prefix.value];
+				return this.state.refs[prefix.raw];
 			case "$":
 				this.pos += 1;
 				return this.state.vars[prefix.raw];
 			case ",": {
 				this.pos += 1;
 				const start = this.pos;
-				const end = start + prefix.value;
-				if (end > this.text.length) throw new Error("String container overflows input");
+				const end = this.advanceByBytes(start, prefix.value);
 				const value = this.text.slice(start, end);
 				this.pos = end;
 				return value;
 			}
 			case "^": {
 				this.pos += 1;
-				const target = this.pos + prefix.value;
+				const target = this.advanceByBytes(this.pos, prefix.value);
 				if (this.pointerCache.has(target)) return this.pointerCache.get(target);
 				const save = this.pos;
 				this.pos = target;
@@ -261,6 +270,14 @@ class CursorInterpreter {
 				this.writePlace(place, value);
 				return value;
 			}
+			case "/": {
+				this.pos += 1;
+				const place = this.readPlace();
+				const oldValue = this.readPlaceValue(place);
+				const newValue = this.evalValue();
+				this.writePlace(place, newValue);
+				return oldValue;
+			}
 			case "~": {
 				this.pos += 1;
 				const place = this.readPlace();
@@ -288,7 +305,7 @@ class CursorInterpreter {
 			case "<":
 				return this.evalLoopLike(tag);
 			case "#":
-				return this.evalWhileLoop();
+				return this.evalWhileLike();
 			default:
 				throw new Error(`Unexpected tag '${tag}' at ${this.pos}`);
 		}
@@ -311,7 +328,7 @@ class CursorInterpreter {
 		this.ensure(")");
 
 		if (typeof callee === "object" && callee && "__opcode" in callee) {
-			return this.applyOpcode((callee as OpcodeMarker).__opcode, args);
+			return this.applyOpcode((callee as OpcodeMarker).__opcode as string, args);
 		}
 		return this.navigate(callee, args);
 	}
@@ -498,13 +515,10 @@ class CursorInterpreter {
 			if (keysOnly) return entries.map(([key]) => ({ key, value: key }));
 			return entries.map(([key, value]) => ({ key, value }));
 		}
-		if (typeof iterable === "number" && Number.isFinite(iterable) && iterable > 0) {
-			const out: Array<{ key: unknown; value: unknown }> = [];
-			for (let index = 0; index < Math.floor(iterable); index += 1) {
-				if (keysOnly) out.push({ key: index, value: index });
-				else out.push({ key: index, value: index + 1 });
-			}
-			return out;
+		if (typeof iterable === "string") {
+			const entries = Array.from(iterable);
+			if (keysOnly) return entries.map((_value, index) => ({ key: index, value: index }));
+			return entries.map((value, index) => ({ key: index, value }));
 		}
 		return [];
 	}
@@ -551,9 +565,12 @@ class CursorInterpreter {
 		return last;
 	}
 
-	private evalWhileLoop(): unknown {
+	private evalWhileLike(): unknown {
 		this.pos += 1; // skip '#'
-		this.ensure("(");
+		const open = this.text[this.pos];
+		if (!open || !"([{".includes(open)) throw new Error(`Expected opener after '#' at ${this.pos}`);
+		const close = open === "(" ? ")" : open === "[" ? "]" : "}";
+		this.pos += 1;
 
 		const condStart = this.pos;
 
@@ -561,18 +578,23 @@ class CursorInterpreter {
 		const condValue = this.evalValue();
 		const bodyStart = this.pos;
 
-		// Skip past the body to find the closing paren
-		const bodyValueCount = 1;
+		// Skip past body values to find the closing bracket
+		const bodyValueCount = open === "{" ? 2 : 1;
 		let cursor = bodyStart;
 		for (let index = 0; index < bodyValueCount; index += 1) {
 			cursor = this.skipValueFrom(cursor);
 		}
 		const bodyEnd = cursor;
 		this.pos = bodyEnd;
-		this.ensure(")");
+		this.ensure(close);
 		const afterClose = this.pos;
 
-		// Now iterate
+		if (open === "[") return this.evalWhileArrayComprehension(condStart, bodyStart, bodyEnd, afterClose, condValue);
+		if (open === "{") return this.evalWhileObjectComprehension(condStart, bodyStart, bodyEnd, afterClose, condValue);
+		return this.evalWhileLoop(condStart, bodyStart, bodyEnd, afterClose, condValue);
+	}
+
+	private evalWhileLoop(condStart: number, bodyStart: number, bodyEnd: number, afterClose: number, condValue: unknown): unknown {
 		let last: unknown = undefined;
 		let currentCond = condValue;
 		while (isDefined(currentCond)) {
@@ -588,7 +610,6 @@ class CursorInterpreter {
 				last = undefined;
 			}
 
-			// Re-evaluate condition
 			currentCond = this.evalBodySlice(condStart, bodyStart);
 		}
 
@@ -596,6 +617,60 @@ class CursorInterpreter {
 		return last;
 	}
 
+	private evalWhileArrayComprehension(condStart: number, bodyStart: number, bodyEnd: number, afterClose: number, condValue: unknown): unknown[] | LoopControl {
+		const out: unknown[] = [];
+		let currentCond = condValue;
+		while (isDefined(currentCond)) {
+			this.tick();
+			this.selfStack.push(currentCond);
+			const value = this.evalBodySlice(bodyStart, bodyEnd);
+			this.selfStack.pop();
+
+			const control = this.handleLoopControl(value);
+			if (control) {
+				if (control.depth > 1) return { kind: control.kind, depth: control.depth - 1 } satisfies LoopControl;
+				if (control.kind === "break") break;
+				currentCond = this.evalBodySlice(condStart, bodyStart);
+				continue;
+			}
+			if (isDefined(value)) out.push(value);
+
+			currentCond = this.evalBodySlice(condStart, bodyStart);
+		}
+
+		this.pos = afterClose;
+		return out;
+	}
+
+	private evalWhileObjectComprehension(condStart: number, bodyStart: number, bodyEnd: number, afterClose: number, condValue: unknown): Record<string, unknown> | LoopControl {
+		const result: Record<string, unknown> = {};
+		let currentCond = condValue;
+		while (isDefined(currentCond)) {
+			this.tick();
+			this.selfStack.push(currentCond);
+			const save = this.pos;
+			this.pos = bodyStart;
+			const key = this.evalValue();
+			const value = this.evalValue();
+			this.pos = save;
+			this.selfStack.pop();
+
+			const control = this.handleLoopControl(value);
+			if (control) {
+				if (control.depth > 1) return { kind: control.kind, depth: control.depth - 1 } satisfies LoopControl;
+				if (control.kind === "break") break;
+				currentCond = this.evalBodySlice(condStart, bodyStart);
+				continue;
+			}
+			if (isDefined(value)) result[String(key)] = value;
+
+			currentCond = this.evalBodySlice(condStart, bodyStart);
+		}
+
+		this.pos = afterClose;
+		return result;
+	}
+
 	private evalArrayComprehension(iterable: unknown, varA: string | undefined, varB: string | undefined, bodyStart: number, bodyEnd: number, keysOnly: boolean): unknown[] | LoopControl {
 		const items = this.iterate(iterable, keysOnly);
 		const out: unknown[] = [];
@@ -654,7 +729,7 @@ class CursorInterpreter {
 		return out;
 	}
 
-	private applyOpcode(id: number, args: unknown[]): unknown {
+	private applyOpcode(id: string, args: unknown[]): unknown {
 		const custom = this.customOpcodes.get(id);
 		if (custom) return custom(args, this.state);
 		switch (id) {
@@ -724,6 +799,22 @@ class CursorInterpreter {
 				return Array.isArray(args[0]) ? args[0] : undefined;
 			case OPCODES.object:
 				return args[0] && typeof args[0] === "object" && !Array.isArray(args[0]) ? args[0] : undefined;
+			case OPCODES.range: {
+				const from = Number(args[0]);
+				const to = Number(args[1]);
+				const step = to >= from ? 1 : -1;
+				const out: number[] = [];
+				for (let v = from; step > 0 ? v <= to : v >= to; v += step)
+					out.push(v);
+				return out;
+			}
+			case OPCODES.size: {
+				const target = args[0];
+				if (Array.isArray(target)) return target.length;
+				if (typeof target === "string") return Array.from(target).length;
+				if (target && typeof target === "object") return Object.keys(target as Record<string, unknown>).length;
+				return undefined;
+			}
 			default:
 				throw new Error(`Unknown opcode ${id}`);
 		}
@@ -733,12 +824,55 @@ class CursorInterpreter {
 		let current = base;
 		for (const key of keys) {
 			if (current === undefined || current === null) return undefined;
-			current = (current as Record<string, unknown>)[String(key)];
+			current = this.readProperty(current, key);
+			if (current === undefined) return undefined;
 		}
 		return current;
 	}
 
-	private readPlace(): { root: string | number; keys: unknown[]; isRef: boolean } {
+	private readProperty(target: unknown, key: unknown): unknown {
+		const index = this.parseIndexKey(key);
+		if (Array.isArray(target)) {
+			if (index === undefined) return undefined;
+			return target[index];
+		}
+		if (typeof target === "string") {
+			if (index === undefined) return undefined;
+			return Array.from(target)[index];
+		}
+		if (this.isPlainObject(target)) {
+			const prop = String(key);
+			if (!Object.prototype.hasOwnProperty.call(target as Record<string, unknown>, prop)) return undefined;
+			return (target as Record<string, unknown>)[prop];
+		}
+		return undefined;
+	}
+
+	private canWriteProperty(target: unknown, key: unknown): { kind: "array"; index: number } | { kind: "object" } | undefined {
+		const index = this.parseIndexKey(key);
+		if (Array.isArray(target)) {
+			if (index === undefined) return undefined;
+			return { kind: "array", index };
+		}
+		if (this.isPlainObject(target)) return { kind: "object" };
+		return undefined;
+	}
+
+	private parseIndexKey(key: unknown): number | undefined {
+		if (typeof key === "number" && Number.isInteger(key) && key >= 0) return key;
+		if (typeof key !== "string" || key.length === 0) return undefined;
+		if (!/^(0|[1-9]\d*)$/.test(key)) return undefined;
+		const index = Number(key);
+		return Number.isSafeInteger(index) ? index : undefined;
+	}
+
+	private isPlainObject(value: unknown): value is Record<string, unknown> {
+		if (!value || typeof value !== "object") return false;
+		const proto = Object.getPrototypeOf(value);
+		return proto === Object.prototype || proto === null;
+	}
+
+	private readPlace(): { root: string; keys: unknown[]; isRef: boolean } {
 		this.skipNonCode();
 		const direct = this.readRootVarOrRefIfPresent();
 		if (direct) {
@@ -784,7 +918,7 @@ class CursorInterpreter {
 		throw new Error(`Invalid place at ${this.pos}`);
 	}
 
-	private readRootVarOrRefIfPresent(): { root: string | number; isRef: boolean } | undefined {
+	private readRootVarOrRefIfPresent(): { root: string; isRef: boolean } | undefined {
 		const save = this.pos;
 		const prefix = this.readPrefix();
 		const tag = this.text[this.pos];
@@ -794,14 +928,14 @@ class CursorInterpreter {
 		}
 		this.pos += 1;
 		return {
-			root: tag === "$" ? prefix.raw : prefix.value,
+			root: prefix.raw,
 			isRef: tag === "'",
 		};
 	}
 
-	private writePlace(place: { root: string | number; keys: unknown[]; isRef: boolean }, value: unknown) {
+	private writePlace(place: { root: string; keys: unknown[]; isRef: boolean }, value: unknown) {
 		const rootTable = place.isRef ? this.state.refs : this.state.vars;
-		const rootKey = String(place.root);
+		const rootKey = place.root;
 		if (place.keys.length === 0) {
 			rootTable[rootKey] = value;
 			return;
@@ -812,17 +946,44 @@ class CursorInterpreter {
 			rootTable[rootKey] = target;
 		}
 		for (let index = 0; index < place.keys.length - 1; index += 1) {
-			const key = String(place.keys[index]);
-			const next = (target as Record<string, unknown>)[key];
-			if (!next || typeof next !== "object") (target as Record<string, unknown>)[key] = {};
-			target = (target as Record<string, unknown>)[key];
+			const key = place.keys[index];
+			const access = this.canWriteProperty(target, key);
+			if (!access) return;
+			if (access.kind === "array") {
+				const next = (target as unknown[])[access.index];
+				if (!next || typeof next !== "object") (target as unknown[])[access.index] = {};
+				target = (target as unknown[])[access.index] as Record<string, unknown>;
+				continue;
+			}
+			const prop = String(key);
+			const next = (target as Record<string, unknown>)[prop];
+			if (!next || typeof next !== "object") (target as Record<string, unknown>)[prop] = {};
+			target = (target as Record<string, unknown>)[prop];
 		}
-		(target as Record<string, unknown>)[String(place.keys[place.keys.length - 1])] = value;
+		const lastKey = place.keys[place.keys.length - 1];
+		const access = this.canWriteProperty(target, lastKey);
+		if (!access) return;
+		if (access.kind === "array") {
+			(target as unknown[])[access.index] = value;
+			return;
+		}
+		(target as Record<string, unknown>)[String(lastKey)] = value;
+	}
+
+	private readPlaceValue(place: { root: string; keys: unknown[]; isRef: boolean }): unknown {
+		const rootTable = place.isRef ? this.state.refs : this.state.vars;
+		let current: unknown = rootTable[place.root];
+		for (const key of place.keys) {
+			if (current === undefined || current === null) return undefined;
+			current = this.readProperty(current, key);
+			if (current === undefined) return undefined;
+		}
+		return current;
 	}
 
-	private deletePlace(place: { root: string | number; keys: unknown[]; isRef: boolean }) {
+	private deletePlace(place: { root: string; keys: unknown[]; isRef: boolean }) {
 		const rootTable = place.isRef ? this.state.refs : this.state.vars;
-		const rootKey = String(place.root);
+		const rootKey = place.root;
 		if (place.keys.length === 0) {
 			delete rootTable[rootKey];
 			return;
@@ -830,10 +991,25 @@ class CursorInterpreter {
 		let target = rootTable[rootKey];
 		if (!target || typeof target !== "object") return;
 		for (let index = 0; index < place.keys.length - 1; index += 1) {
-			target = (target as Record<string, unknown>)[String(place.keys[index])];
+			const key = place.keys[index];
+			const access = this.canWriteProperty(target, key);
+			if (!access) return;
+			if (access.kind === "array") {
+				target = (target as unknown[])[access.index];
+				if (!target || typeof target !== "object") return;
+				continue;
+			}
+			target = (target as Record<string, unknown>)[String(key)];
 			if (!target || typeof target !== "object") return;
 		}
-		delete (target as Record<string, unknown>)[String(place.keys[place.keys.length - 1])];
+		const lastKey = place.keys[place.keys.length - 1];
+		const access = this.canWriteProperty(target, lastKey);
+		if (!access) return;
+		if (access.kind === "array") {
+			delete (target as unknown[])[access.index];
+			return;
+		}
+		delete (target as Record<string, unknown>)[String(lastKey)];
 	}
 
 	private skipValue() {
@@ -852,12 +1028,12 @@ class CursorInterpreter {
 		}
 
 		if (tag === ",") {
-			this.pos += 1 + prefix.value;
+			this.pos = this.advanceByBytes(this.pos + 1, prefix.value);
 			const end = this.pos;
 			this.pos = save;
 			return end;
 		}
-		if (tag === "=") {
+		if (tag === "=" || tag === "/") {
 			this.pos += 1;
 			this.skipValue();
 			this.skipValue();
@@ -892,7 +1068,8 @@ class CursorInterpreter {
 		if (opener && "([{".includes(opener)) {
 			const close = opener === "(" ? ")" : opener === "[" ? "]" : "}";
 			if (prefix.value > 0) {
-				this.pos += 1 + prefix.value + 1;
+				const bodyEnd = this.advanceByBytes(this.pos + 1, prefix.value);
+				this.pos = bodyEnd + 1;
 				const end = this.pos;
 				this.pos = save;
 				return end;