kei-lisp-plugin-graphics 3.0.1 → 4.0.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { Cons, InterpretedSymbol } from "kei-lisp";
+import { Cons, EvalError, InterpretedSymbol, Numeric } from "kei-lisp";
 //#region src/GraphicsPlugin/index.ts
 const LINE_CAPS = /* @__PURE__ */ new Set([
 	"butt",
@@ -99,8 +99,15 @@ const COMPOSITE_OPERATIONS = /* @__PURE__ */ new Set([
 * @class
 * @classdesc Canvas2D drawing plugin for the kei-lisp interpreter. Implements
 *            the `KeiLispPlugin` contract (`name` / `has` / `apply`) and
-*            exposes 75 `g…` Lisp functions (plus two deprecated aliases)
-*            that proxy to a 2D rendering context.
+*            exposes 75 `g…` Lisp functions that proxy to a 2D rendering
+*            context. Failures (wrong arity,
+*            type mismatch, closed canvas, canvas-level errors) signal an
+*            `EvalError` that Lisp callers can intercept with
+*            `(handler-case … (eval-error (e) …))`. Two exceptions still go
+*            to `process.stderr` as diagnostics: asynchronous work (image
+*            loading, OffscreenCanvas file writes), which fails after the
+*            call has returned, and `selectColor`'s best-effort color
+*            parsing, which falls back to black instead of failing.
 * @author Keisuke Ikeda
 */
 var GraphicsPlugin = class GraphicsPlugin {
@@ -163,8 +170,6 @@ var GraphicsPlugin = class GraphicsPlugin {
 		aTable.set(InterpretedSymbol.of("gtext-direction"), "gTextDirection");
 		aTable.set(InterpretedSymbol.of("gtext-font"), "gTextFont");
 		aTable.set(InterpretedSymbol.of("gtext-baseline"), "gTextBaseline");
-		aTable.set(InterpretedSymbol.of("gtext-dire"), "gTextDirection");
-		aTable.set(InterpretedSymbol.of("gtext-line"), "gTextBaseline");
 		aTable.set(InterpretedSymbol.of("gtranslate"), "gTranslate");
 		aTable.set(InterpretedSymbol.of("grect"), "gRect");
 		aTable.set(InterpretedSymbol.of("grotate"), "gRotate");
@@ -228,11 +233,13 @@ var GraphicsPlugin = class GraphicsPlugin {
 	/**
 	* Writes a diagnostic line to `process.stderr`, matching the convention
 	* used by kei-lisp itself (`Applier.format` writes to `process.stdout`).
-	* In a Node runtime this hits the real stderr; in a browser kei-lisp host
-	* (e.g. kei-lisp-web) the host typically swaps `process.stderr.write` for
-	* a sink that routes to the REPL output panel. In a plain browser with no
-	* `process` shim at all, the line falls back to `console.error` instead of
-	* throwing.
+	* Used only where an `EvalError` cannot reach the caller: asynchronous
+	* work (image loading), best-effort color parsing, and the informational
+	* line printed by `gopen`. In a Node runtime this hits the real stderr; in
+	* a browser kei-lisp host (e.g. kei-lisp-web) the host typically swaps
+	* `process.stderr.write` for a sink that routes to the REPL output panel.
+	* In a plain browser with no `process` shim at all, the line falls back to
+	* `console.error` instead of throwing.
 	* @param line - the line to write
 	*/
 	#print(line) {
@@ -246,7 +253,9 @@ var GraphicsPlugin = class GraphicsPlugin {
 	/**
 	* Resolves an image for the given source and runs `draw` with it —
 	* synchronously when the image is already loaded, on its `load` event
-	* otherwise. A load failure prints a diagnostic once.
+	* otherwise. A load failure prints a diagnostic once (the failure happens
+	* asynchronously, after the calling `g…` function has already returned, so
+	* it cannot signal an `EvalError`).
 	* @param source - the image URL / data URI
 	* @param draw - the drawing action to run once the image is available
 	*/
@@ -269,26 +278,37 @@ var GraphicsPlugin = class GraphicsPlugin {
 		});
 	}
 	/**
-	* Shared guard-and-dispatch skeleton for the newer `g…` methods: checks the
-	* context and the open flag, runs `body`, and converts both a `null` return
-	* and a thrown exception into `failureMessage` + `Cons.nil`.
-	* @param failureMessage - the diagnostic printed when `body` fails
+	* Returns the 2D context, signaling an `EvalError` when the canvas exposes
+	* no usable context or has not been opened with `gopen`.
+	* @return the 2D rendering context
+	*/
+	#requireOpenContext() {
+		if (this.ctx === null) throw new EvalError("Unable to initialize canvas. The browser or machine may not support it.");
+		if (!this.isOpen) throw new EvalError("The canvas is closed and cannot be executed.");
+		return this.ctx;
+	}
+	/**
+	* Shared guard-and-dispatch skeleton for the `g…` methods: requires an
+	* open canvas context, runs `body`, and signals an `EvalError` carrying
+	* `failureMessage` when `body` returns `null` (bad arguments) or throws a
+	* canvas-level error. The error propagates through the evaluator, where
+	* Lisp callers can intercept it with
+	* `(handler-case … (eval-error (e) …))`.
+	* @param failureMessage - the message of the signaled `EvalError`
 	* @param body - the drawing action; returns the Lisp result, or `null` on
 	*               bad arguments
-	* @return the body's result, or `Cons.nil` on failure
+	* @return the body's result
 	*/
 	#execute(failureMessage, body) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (!this.isOpen) {
-			this.#print("The canvas is closed and cannot be executed.");
-			return Cons.nil;
-		}
+		const context = this.#requireOpenContext();
+		let result;
 		try {
-			const result = body(this.ctx);
-			if (result !== null) return result;
-		} catch {}
-		this.#print(failureMessage);
-		return Cons.nil;
+			result = body(context);
+		} catch (error) {
+			throw error instanceof EvalError ? error : new EvalError(failureMessage);
+		}
+		if (result === null) throw new EvalError(failureMessage);
+		return result;
 	}
 	/**
 	* Reads a single string argument and validates it against an allowlist.
@@ -302,7 +322,9 @@ var GraphicsPlugin = class GraphicsPlugin {
 		return allowed.has(arguments_.car) ? arguments_.car : null;
 	}
 	/**
-	* Reads exactly `count` numbers from the argument list.
+	* Reads exactly `count` numbers from the argument list. kei-lisp v3
+	* evaluates integers to `bigint` and exact division to `Rational`, so each
+	* value is converted to a JS float for the Canvas 2D API.
 	* @param arguments_ - the evaluated argument list
 	* @param count - the expected argument count
 	* @return the numbers, or `null` on wrong arity or a non-number argument
@@ -313,7 +335,7 @@ var GraphicsPlugin = class GraphicsPlugin {
 		let rest = arguments_;
 		for (let index = 0; index < count; index++) {
 			if (!Cons.isNumber(rest.car)) return null;
-			values.push(rest.car);
+			values.push(Numeric.toFloat(rest.car));
 			rest = rest.cdr;
 		}
 		return values;
@@ -358,7 +380,7 @@ var GraphicsPlugin = class GraphicsPlugin {
 			const offset = stops[index];
 			const color = stops[index + 1];
 			if (!Cons.isNumber(offset) || !Cons.isString(color)) return false;
-			gradient.addColorStop(offset, color);
+			gradient.addColorStop(Numeric.toFloat(offset), color);
 		}
 		return true;
 	}
@@ -383,13 +405,10 @@ var GraphicsPlugin = class GraphicsPlugin {
 	* no `document` — those callers must pass a file path instead.
 	* @param mimeType - the image MIME type to encode
 	* @param label - the format name used in diagnostics ("jpeg" / "png")
-	* @return `t` on success, `Cons.nil` otherwise
+	* @return `t` on success
 	*/
 	#downloadCanvas(mimeType, label) {
-		if (typeof document === "undefined" || !("toDataURL" in this.canvas)) {
-			this.#print(`Can not save ${label}. Browser download needs a DOM and an HTMLCanvasElement; pass a file path to save on Node.js.`);
-			return Cons.nil;
-		}
+		if (typeof document === "undefined" || !("toDataURL" in this.canvas)) throw new EvalError(`Can not save ${label}. Browser download needs a DOM and an HTMLCanvasElement; pass a file path to save on Node.js.`);
 		try {
 			const link = document.createElement("a");
 			link.href = this.canvas.toDataURL(mimeType);
@@ -399,8 +418,7 @@ var GraphicsPlugin = class GraphicsPlugin {
 			link.remove();
 			return InterpretedSymbol.of("t");
 		} catch {
-			this.#print(`Can not save ${label}. If you are using an image in the canvas, you can't save ${label}.`);
-			return Cons.nil;
+			throw new EvalError(`Can not save ${label}. If you are using an image in the canvas, you can't save ${label}.`);
 		}
 	}
 	/**
@@ -413,14 +431,12 @@ var GraphicsPlugin = class GraphicsPlugin {
 	* @param path - the destination file path
 	* @param mimeType - the image MIME type to encode
 	* @param label - the format name used in diagnostics ("jpeg" / "png")
-	* @return `t` on success, `Cons.nil` otherwise
+	* @return `t` on success
 	*/
 	#writeCanvasToFile(path, mimeType, label) {
-		const fs = typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("node:fs") : void 0;
-		if (fs === void 0) {
-			this.#print(`Can not save ${label}. Saving to a file path requires Node.js.`);
-			return Cons.nil;
-		}
+		const getBuiltinModule = globalThis.process?.getBuiltinModule;
+		const fs = typeof getBuiltinModule === "function" ? getBuiltinModule("node:fs") : void 0;
+		if (fs === void 0) throw new EvalError(`Can not save ${label}. Saving to a file path requires Node.js.`);
 		try {
 			if ("toDataURL" in this.canvas) {
 				const dataUrl = this.canvas.toDataURL(mimeType);
@@ -430,11 +446,12 @@ var GraphicsPlugin = class GraphicsPlugin {
 			}
 			this.canvas.convertToBlob({ type: mimeType }).then(async (blob) => {
 				fs.writeFileSync(path, new Uint8Array(await blob.arrayBuffer()));
+			}).catch(() => {
+				this.#print(`Can not save ${label}.`);
 			});
 			return InterpretedSymbol.of("t");
 		} catch {
-			this.#print(`Can not save ${label}.`);
-			return Cons.nil;
+			throw new EvalError(`Can not save ${label}.`);
 		}
 	}
 	/**
@@ -450,127 +467,45 @@ var GraphicsPlugin = class GraphicsPlugin {
 	* @param aSymbol - the call symbol
 	* @param arguments_ - the evaluated argument list
 	* @param _context - the interpreter context (unused by this plugin)
-	* @return the method's result, or `Cons.nil` if dispatch fails
+	* @return the method's result
 	*/
 	apply(aSymbol, arguments_, _context) {
 		const methodName = GraphicsPlugin.#builtInFunctions.get(aSymbol);
-		if (methodName === void 0) {
-			this.#print(`I could find no procedure description for ${String(aSymbol)}`);
-			return Cons.nil;
-		}
+		if (methodName === void 0) throw new EvalError(`I could find no procedure description for ${String(aSymbol)}`);
 		return this[methodName].call(this, arguments_);
 	}
-	/**
-	* Checks whether the canvas exposes a usable 2D context, and narrows
-	* `this.ctx` to non-null for the caller when it returns true.
-	* @return type predicate — true when context is non-null
-	*/
-	checkSupport() {
-		if (this.ctx === null) {
-			this.#print("Unable to initialize canvas. The browser or machine may not support it.");
-			return false;
-		}
-		return true;
-	}
 	gAlpha(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 1 && Cons.isNumber(arguments_.car)) {
-				const aNumber = arguments_.car <= 0 ? 0 : arguments_.car >= 1 ? 1 : arguments_.car;
-				this.ctx.globalAlpha = aNumber;
-				return InterpretedSymbol.of("t");
-			}
-			this.#print("Can not set alpha.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not set alpha.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not set alpha.", (context) => {
+			const a = this.#numbers(arguments_, 1);
+			if (a === null) return null;
+			context.globalAlpha = a[0] <= 0 ? 0 : a[0] >= 1 ? 1 : a[0];
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gArc(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 6) {
-				const a0 = arguments_.car;
-				const cdr1 = arguments_.cdr;
-				const a1 = cdr1.car;
-				const cdr2 = cdr1.cdr;
-				const a2 = cdr2.car;
-				const cdr3 = cdr2.cdr;
-				const a3 = cdr3.car;
-				const cdr4 = cdr3.cdr;
-				const a4 = cdr4.car;
-				const a5 = cdr4.cdr.car;
-				if (Cons.isNumber(a0) && Cons.isNumber(a1) && Cons.isNumber(a2) && Cons.isNumber(a3) && Cons.isNumber(a4) && Cons.isNumber(a5)) {
-					const isAFlag = a5 >= 0;
-					this.ctx.arc(a0, a1, a2, Math.PI / 180 * a3, Math.PI / 180 * a4, isAFlag);
-					return InterpretedSymbol.of("t");
-				}
-			}
-			this.#print("Can not draw arc.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not draw arc.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not draw arc.", (context) => {
+			const a = this.#numbers(arguments_, 6);
+			if (a === null) return null;
+			const isAFlag = a[5] >= 0;
+			context.arc(a[0], a[1], a[2], Math.PI / 180 * a[3], Math.PI / 180 * a[4], isAFlag);
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gArcTo(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 5) {
-				const a0 = arguments_.car;
-				const cdr1 = arguments_.cdr;
-				const a1 = cdr1.car;
-				const cdr2 = cdr1.cdr;
-				const a2 = cdr2.car;
-				const cdr3 = cdr2.cdr;
-				const a3 = cdr3.car;
-				const a4 = cdr3.cdr.car;
-				if (Cons.isNumber(a0) && Cons.isNumber(a1) && Cons.isNumber(a2) && Cons.isNumber(a3) && Cons.isNumber(a4)) {
-					this.ctx.arcTo(a0, a1, a2, a3, a4);
-					return InterpretedSymbol.of("t");
-				}
-			}
-			this.#print("Can not draw arc to.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not draw arc to.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not draw arc to.", (context) => {
+			const a = this.#numbers(arguments_, 5);
+			if (a === null) return null;
+			context.arcTo(a[0], a[1], a[2], a[3], a[4]);
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gBezCurveTo(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 6) {
-				const a0 = arguments_.car;
-				const cdr1 = arguments_.cdr;
-				const a1 = cdr1.car;
-				const cdr2 = cdr1.cdr;
-				const a2 = cdr2.car;
-				const cdr3 = cdr2.cdr;
-				const a3 = cdr3.car;
-				const cdr4 = cdr3.cdr;
-				const a4 = cdr4.car;
-				const a5 = cdr4.cdr.car;
-				if (Cons.isNumber(a0) && Cons.isNumber(a1) && Cons.isNumber(a2) && Cons.isNumber(a3) && Cons.isNumber(a4) && Cons.isNumber(a5)) {
-					this.ctx.bezierCurveTo(a0, a1, a2, a3, a4, a5);
-					return InterpretedSymbol.of("t");
-				}
-			}
-			this.#print("Can not draw bezier curve.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not draw bezier curve.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not draw bezier curve.", (context) => {
+			const a = this.#numbers(arguments_, 6);
+			if (a === null) return null;
+			context.bezierCurveTo(a[0], a[1], a[2], a[3], a[4], a[5]);
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gClear(arguments_) {
 		return this.#execute("Can not clear.", (context) => {
@@ -582,89 +517,48 @@ var GraphicsPlugin = class GraphicsPlugin {
 			return InterpretedSymbol.of("t");
 		});
 	}
-	gClose() {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
+	gClose(arguments_ = Cons.nil) {
+		if (this.ctx === null) throw new EvalError("Unable to initialize canvas. The browser or machine may not support it.");
+		if (arguments_.length() !== 0) throw new EvalError("Can not close.");
+		if (!this.isOpen) throw new EvalError("The canvas has already been closed.");
+		try {
 			this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
-			this.isOpen = false;
-			return InterpretedSymbol.of("t");
 		} catch {
-			this.#print("Can not close.");
-			return Cons.nil;
+			throw new EvalError("Can not close.");
 		}
-		this.#print("The canvas has already been closed.");
-		return Cons.nil;
+		this.isOpen = false;
+		return InterpretedSymbol.of("t");
 	}
 	gColor(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() >= 1) {
-				const aColor = this.selectColor(arguments_);
-				this.ctx.fillStyle = aColor;
-				this.ctx.strokeStyle = aColor;
-				return InterpretedSymbol.of("t");
-			}
-			this.#print("Can not set color.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not set color.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not set color.", (context) => {
+			if (arguments_.length() < 1) return null;
+			const aColor = this.selectColor(arguments_);
+			context.fillStyle = aColor;
+			context.strokeStyle = aColor;
+			return InterpretedSymbol.of("t");
+		});
 	}
-	gFill() {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			this.ctx.fill();
+	gFill(arguments_ = Cons.nil) {
+		return this.#execute("Can not fill.", (context) => {
+			if (arguments_.length() !== 0) return null;
+			context.fill();
 			return InterpretedSymbol.of("t");
-		} catch {
-			this.#print("Can not fill.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		});
 	}
 	gFillColor(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() >= 1) {
-				const aColor = this.selectColor(arguments_);
-				this.ctx.fillStyle = aColor;
-				return InterpretedSymbol.of("t");
-			}
-			this.#print("Can not set fill color.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not set fill color.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not set fill color.", (context) => {
+			if (arguments_.length() < 1) return null;
+			context.fillStyle = this.selectColor(arguments_);
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gFillRect(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 4) {
-				const a0 = arguments_.car;
-				const cdr1 = arguments_.cdr;
-				const a1 = cdr1.car;
-				const cdr2 = cdr1.cdr;
-				const a2 = cdr2.car;
-				const a3 = cdr2.cdr.car;
-				if (Cons.isNumber(a0) && Cons.isNumber(a1) && Cons.isNumber(a2) && Cons.isNumber(a3)) {
-					this.ctx.fillRect(a0, a1, a2, a3);
-					return InterpretedSymbol.of("t");
-				}
-			}
-			this.#print("Can not draw fill rectangle.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not draw fill rectangle.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not draw fill rectangle.", (context) => {
+			const a = this.#numbers(arguments_, 4);
+			if (a === null) return null;
+			context.fillRect(a[0], a[1], a[2], a[3]);
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gFillText(arguments_) {
 		return this.#execute("Can not draw fill text.", (context) => {
@@ -674,54 +568,29 @@ var GraphicsPlugin = class GraphicsPlugin {
 			if (!Cons.isString(a0) || !Cons.isNumber(a1) || !Cons.isNumber(a2)) return null;
 			if (length_ === 4) {
 				if (!Cons.isNumber(a3)) return null;
-				context.fillText(a0, a1, a2, a3);
-			} else context.fillText(a0, a1, a2);
+				context.fillText(a0, Numeric.toFloat(a1), Numeric.toFloat(a2), Numeric.toFloat(a3));
+			} else context.fillText(a0, Numeric.toFloat(a1), Numeric.toFloat(a2));
 			return InterpretedSymbol.of("t");
 		});
 	}
 	gFillTri(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 6) {
-				const a0 = arguments_.car;
-				const cdr1 = arguments_.cdr;
-				const a1 = cdr1.car;
-				const cdr2 = cdr1.cdr;
-				const a2 = cdr2.car;
-				const cdr3 = cdr2.cdr;
-				const a3 = cdr3.car;
-				const cdr4 = cdr3.cdr;
-				const a4 = cdr4.car;
-				const a5 = cdr4.cdr.car;
-				if (Cons.isNumber(a0) && Cons.isNumber(a1) && Cons.isNumber(a2) && Cons.isNumber(a3) && Cons.isNumber(a4) && Cons.isNumber(a5)) {
-					this.ctx.beginPath();
-					this.ctx.moveTo(a0, a1);
-					this.ctx.lineTo(a2, a3);
-					this.ctx.lineTo(a4, a5);
-					this.ctx.fill();
-					return InterpretedSymbol.of("t");
-				}
-			}
-			this.#print("Can not draw fill triangle.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not draw fill triangle.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not draw fill triangle.", (context) => {
+			const a = this.#numbers(arguments_, 6);
+			if (a === null) return null;
+			context.beginPath();
+			context.moveTo(a[0], a[1]);
+			context.lineTo(a[2], a[3]);
+			context.lineTo(a[4], a[5]);
+			context.fill();
+			return InterpretedSymbol.of("t");
+		});
 	}
-	gFinishPath() {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			this.ctx.closePath();
+	gFinishPath(arguments_ = Cons.nil) {
+		return this.#execute("Can not finish path.", (context) => {
+			if (arguments_.length() !== 0) return null;
+			context.closePath();
 			return InterpretedSymbol.of("t");
-		} catch {
-			this.#print("Can not finish path.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		});
 	}
 	gImage(arguments_) {
 		return this.#execute("Can not draw Image.", (context) => {
@@ -732,33 +601,21 @@ var GraphicsPlugin = class GraphicsPlugin {
 			if (length_ === 5) {
 				if (!Cons.isNumber(a3) || !Cons.isNumber(a4)) return null;
 				this.#withImage(a0, (image) => {
-					context.drawImage(image, a1, a2, a3, a4);
+					context.drawImage(image, Numeric.toFloat(a1), Numeric.toFloat(a2), Numeric.toFloat(a3), Numeric.toFloat(a4));
 				});
 			} else this.#withImage(a0, (image) => {
-				context.drawImage(image, a1, a2);
+				context.drawImage(image, Numeric.toFloat(a1), Numeric.toFloat(a2));
 			});
 			return InterpretedSymbol.of("t");
 		});
 	}
 	gLineTo(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 2) {
-				const a0 = arguments_.car;
-				const a1 = arguments_.cdr.car;
-				if (Cons.isNumber(a0) && Cons.isNumber(a1)) {
-					this.ctx.lineTo(a0, a1);
-					return InterpretedSymbol.of("t");
-				}
-			}
-			this.#print("Can not draw line to");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not draw line to");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not draw line to", (context) => {
+			const a = this.#numbers(arguments_, 2);
+			if (a === null) return null;
+			context.lineTo(a[0], a[1]);
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gLineCap(arguments_) {
 		return this.#execute("Can not set line cap. Expected \"butt\" / \"round\" / \"square\".", (context) => {
@@ -777,57 +634,35 @@ var GraphicsPlugin = class GraphicsPlugin {
 		});
 	}
 	gLineWidth(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 1 && Cons.isNumber(arguments_.car)) {
-				const aNumber = arguments_.car <= 0 ? 1 : arguments_.car;
-				this.ctx.lineWidth = aNumber;
-				return InterpretedSymbol.of("t");
-			}
-			this.#print("Can not set line width.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not set line width.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not set line width.", (context) => {
+			const a = this.#numbers(arguments_, 1);
+			if (a === null) return null;
+			context.lineWidth = a[0] <= 0 ? 1 : a[0];
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gMoveTo(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 2) {
-				const a0 = arguments_.car;
-				const a1 = arguments_.cdr.car;
-				if (Cons.isNumber(a0) && Cons.isNumber(a1)) {
-					this.ctx.moveTo(a0, a1);
-					return InterpretedSymbol.of("t");
-				}
-			}
-			this.#print("Can not move");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not move");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not move", (context) => {
+			const a = this.#numbers(arguments_, 2);
+			if (a === null) return null;
+			context.moveTo(a[0], a[1]);
+			return InterpretedSymbol.of("t");
+		});
 	}
-	gOpen() {
-		if (!this.checkSupport()) return Cons.nil;
-		if (!this.isOpen) try {
-			this.isOpen = true;
+	gOpen(arguments_ = Cons.nil) {
+		if (this.ctx === null) throw new EvalError("Unable to initialize canvas. The browser or machine may not support it.");
+		if (arguments_.length() !== 0) throw new EvalError("Can not open.");
+		if (this.isOpen) throw new EvalError("The canvas has already been opened.");
+		try {
 			this.ctx.fillStyle = "#ffffff";
 			this.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
 			this.ctx.fillStyle = "#000000";
-			this.#print(`canvas size, width : ${this.canvas.width} height : ${this.canvas.height}`);
-			return InterpretedSymbol.of("t");
 		} catch {
-			this.#print("Can not open.");
-			return Cons.nil;
+			throw new EvalError("Can not open.");
 		}
-		this.#print("The canvas has already been opened.");
-		return Cons.nil;
+		this.isOpen = true;
+		this.#print(`canvas size, width : ${this.canvas.width} height : ${this.canvas.height}`);
+		return InterpretedSymbol.of("t");
 	}
 	gPattern(arguments_) {
 		return this.#execute("Can not set pattern. Expected an image source and a repetition (\"repeat\" / \"repeat-x\" / \"repeat-y\" / \"no-repeat\").", (context) => {
@@ -846,28 +681,12 @@ var GraphicsPlugin = class GraphicsPlugin {
 		});
 	}
 	gQuadCurveTo(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 4) {
-				const a0 = arguments_.car;
-				const cdr1 = arguments_.cdr;
-				const a1 = cdr1.car;
-				const cdr2 = cdr1.cdr;
-				const a2 = cdr2.car;
-				const a3 = cdr2.cdr.car;
-				if (Cons.isNumber(a0) && Cons.isNumber(a1) && Cons.isNumber(a2) && Cons.isNumber(a3)) {
-					this.ctx.quadraticCurveTo(a0, a1, a2, a3);
-					return InterpretedSymbol.of("t");
-				}
-			}
-			this.#print("Can not draw quadratic curve.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not draw quadratic curve.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not draw quadratic curve.", (context) => {
+			const a = this.#numbers(arguments_, 4);
+			if (a === null) return null;
+			context.quadraticCurveTo(a[0], a[1], a[2], a[3]);
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gSaveJpeg(arguments_) {
 		return this.saveCanvas(arguments_, "image/jpeg", "jpeg");
@@ -882,177 +701,91 @@ var GraphicsPlugin = class GraphicsPlugin {
 	* @param arguments_ - the evaluated argument list (empty, or one path string)
 	* @param mimeType - the image MIME type to encode
 	* @param label - the format name used in diagnostics ("jpeg" / "png")
-	* @return `t` on success, `Cons.nil` otherwise
+	* @return `t` on success
 	*/
 	saveCanvas(arguments_, mimeType, label) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) {
-			const length_ = arguments_.length();
-			if (length_ === 0) return this.#downloadCanvas(mimeType, label);
-			if (length_ === 1 && Cons.isString(arguments_.car)) return this.#writeCanvasToFile(arguments_.car, mimeType, label);
-			this.#print(`Can not save ${label}.`);
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		this.#requireOpenContext();
+		const length_ = arguments_.length();
+		if (length_ === 0) return this.#downloadCanvas(mimeType, label);
+		if (length_ === 1 && Cons.isString(arguments_.car)) return this.#writeCanvasToFile(arguments_.car, mimeType, label);
+		throw new EvalError(`Can not save ${label}.`);
 	}
 	gScale(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 2) {
-				const a0 = arguments_.car;
-				const a1 = arguments_.cdr.car;
-				if (Cons.isNumber(a0) && Cons.isNumber(a1)) {
-					this.ctx.scale(a0, a1);
-					return InterpretedSymbol.of("t");
-				}
-			}
-			this.#print("Can not scale.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not scale.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not scale.", (context) => {
+			const a = this.#numbers(arguments_, 2);
+			if (a === null) return null;
+			context.scale(a[0], a[1]);
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gShadowBlur(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) {
-			if (arguments_.length() === 1 && Cons.isNumber(arguments_.car)) {
-				this.ctx.shadowBlur = arguments_.car;
-				return InterpretedSymbol.of("t");
-			}
-			this.#print("Can not set shadow blur.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not set shadow blur.", (context) => {
+			const a = this.#numbers(arguments_, 1);
+			if (a === null) return null;
+			context.shadowBlur = a[0];
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gShadowColor(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 1) {
-				const aColor = this.selectColor(arguments_);
-				this.ctx.shadowColor = aColor;
-				return InterpretedSymbol.of("t");
-			}
-			this.#print("Can not set shadow color.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not set shadow color.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not set shadow color.", (context) => {
+			if (arguments_.length() < 1) return null;
+			context.shadowColor = this.selectColor(arguments_);
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gShadowOffsetX(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) {
-			if (arguments_.length() === 1 && Cons.isNumber(arguments_.car)) {
-				this.ctx.shadowOffsetX = arguments_.car;
-				return InterpretedSymbol.of("t");
-			}
-			this.#print("Can not set shadow offsetX.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not set shadow offsetX.", (context) => {
+			const a = this.#numbers(arguments_, 1);
+			if (a === null) return null;
+			context.shadowOffsetX = a[0];
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gShadowOffsetY(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) {
-			if (arguments_.length() === 1 && Cons.isNumber(arguments_.car)) {
-				this.ctx.shadowOffsetY = arguments_.car;
-				return InterpretedSymbol.of("t");
-			}
-			this.#print("Can not set shadow offsetY.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not set shadow offsetY.", (context) => {
+			const a = this.#numbers(arguments_, 1);
+			if (a === null) return null;
+			context.shadowOffsetY = a[0];
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gSleep(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) {
-			const sleep = (ms) => {
-				const time = Date.now() + ms;
-				while (Date.now() < time);
-			};
-			if (arguments_.length() === 1 && Cons.isNumber(arguments_.car)) {
-				sleep(arguments_.car);
-				return InterpretedSymbol.of("t");
-			}
-			this.#print("Can not sleep");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not sleep", () => {
+			const a = this.#numbers(arguments_, 1);
+			if (a === null) return null;
+			const time = Date.now() + a[0];
+			while (Date.now() < time);
+			return InterpretedSymbol.of("t");
+		});
 	}
-	gStartPath() {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			this.ctx.beginPath();
+	gStartPath(arguments_ = Cons.nil) {
+		return this.#execute("Can not start path.", (context) => {
+			if (arguments_.length() !== 0) return null;
+			context.beginPath();
 			return InterpretedSymbol.of("t");
-		} catch {
-			this.#print("Can not start path.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		});
 	}
-	gStroke() {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			this.ctx.stroke();
+	gStroke(arguments_ = Cons.nil) {
+		return this.#execute("Can not stroke.", (context) => {
+			if (arguments_.length() !== 0) return null;
+			context.stroke();
 			return InterpretedSymbol.of("t");
-		} catch {
-			this.#print("Can not stroke.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		});
 	}
 	gStrokeColor(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() >= 1) {
-				const aColor = this.selectColor(arguments_);
-				this.ctx.strokeStyle = aColor;
-				return InterpretedSymbol.of("t");
-			}
-			this.#print("Can not set stroke color");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not set stroke color");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not set stroke color", (context) => {
+			if (arguments_.length() < 1) return null;
+			context.strokeStyle = this.selectColor(arguments_);
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gStrokeRect(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 4) {
-				const a0 = arguments_.car;
-				const cdr1 = arguments_.cdr;
-				const a1 = cdr1.car;
-				const cdr2 = cdr1.cdr;
-				const a2 = cdr2.car;
-				const a3 = cdr2.cdr.car;
-				if (Cons.isNumber(a0) && Cons.isNumber(a1) && Cons.isNumber(a2) && Cons.isNumber(a3)) {
-					this.ctx.strokeRect(a0, a1, a2, a3);
-					return InterpretedSymbol.of("t");
-				}
-			}
-			this.#print("Can not draw stroke rectangle.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not draw stroke rectangle.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not draw stroke rectangle.", (context) => {
+			const a = this.#numbers(arguments_, 4);
+			if (a === null) return null;
+			context.strokeRect(a[0], a[1], a[2], a[3]);
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gStrokeText(arguments_) {
 		return this.#execute("Can not draw stroke text.", (context) => {
@@ -1062,43 +795,23 @@ var GraphicsPlugin = class GraphicsPlugin {
 			if (!Cons.isString(a0) || !Cons.isNumber(a1) || !Cons.isNumber(a2)) return null;
 			if (length_ === 4) {
 				if (!Cons.isNumber(a3)) return null;
-				context.strokeText(a0, a1, a2, a3);
-			} else context.strokeText(a0, a1, a2);
+				context.strokeText(a0, Numeric.toFloat(a1), Numeric.toFloat(a2), Numeric.toFloat(a3));
+			} else context.strokeText(a0, Numeric.toFloat(a1), Numeric.toFloat(a2));
 			return InterpretedSymbol.of("t");
 		});
 	}
 	gStrokeTri(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 6) {
-				const a0 = arguments_.car;
-				const cdr1 = arguments_.cdr;
-				const a1 = cdr1.car;
-				const cdr2 = cdr1.cdr;
-				const a2 = cdr2.car;
-				const cdr3 = cdr2.cdr;
-				const a3 = cdr3.car;
-				const cdr4 = cdr3.cdr;
-				const a4 = cdr4.car;
-				const a5 = cdr4.cdr.car;
-				if (Cons.isNumber(a0) && Cons.isNumber(a1) && Cons.isNumber(a2) && Cons.isNumber(a3) && Cons.isNumber(a4) && Cons.isNumber(a5)) {
-					this.ctx.beginPath();
-					this.ctx.moveTo(a0, a1);
-					this.ctx.lineTo(a2, a3);
-					this.ctx.lineTo(a4, a5);
-					this.ctx.closePath();
-					this.ctx.stroke();
-					return InterpretedSymbol.of("t");
-				}
-			}
-			this.#print("Can not draw stroke triangle.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not draw stroke triangle.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not draw stroke triangle.", (context) => {
+			const a = this.#numbers(arguments_, 6);
+			if (a === null) return null;
+			context.beginPath();
+			context.moveTo(a[0], a[1]);
+			context.lineTo(a[2], a[3]);
+			context.lineTo(a[4], a[5]);
+			context.closePath();
+			context.stroke();
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gTextAlign(arguments_) {
 		return this.#execute("Can not set text align. Expected \"left\" / \"right\" / \"center\" / \"start\" / \"end\".", (context) => {
@@ -1125,80 +838,35 @@ var GraphicsPlugin = class GraphicsPlugin {
 		});
 	}
 	gTextFont(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 1 && Cons.isString(arguments_.car)) {
-				this.ctx.font = arguments_.car;
-				return InterpretedSymbol.of("t");
-			}
-			this.#print("Can not set text font.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not set text font.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not set text font.", (context) => {
+			if (arguments_.length() !== 1 || !Cons.isString(arguments_.car)) return null;
+			context.font = arguments_.car;
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gTranslate(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 2) {
-				const a0 = arguments_.car;
-				const a1 = arguments_.cdr.car;
-				if (Cons.isNumber(a0) && Cons.isNumber(a1)) {
-					this.ctx.translate(a0, a1);
-					return InterpretedSymbol.of("t");
-				}
-			}
-			this.#print("Can not translate.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not translate.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not translate.", (context) => {
+			const a = this.#numbers(arguments_, 2);
+			if (a === null) return null;
+			context.translate(a[0], a[1]);
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gRect(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 4) {
-				const a0 = arguments_.car;
-				const cdr1 = arguments_.cdr;
-				const a1 = cdr1.car;
-				const cdr2 = cdr1.cdr;
-				const a2 = cdr2.car;
-				const a3 = cdr2.cdr.car;
-				if (Cons.isNumber(a0) && Cons.isNumber(a1) && Cons.isNumber(a2) && Cons.isNumber(a3)) {
-					this.ctx.rect(a0, a1, a2, a3);
-					return InterpretedSymbol.of("t");
-				}
-			}
-			this.#print("Can not draw rectangle.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not draw rectangle.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not draw rectangle.", (context) => {
+			const a = this.#numbers(arguments_, 4);
+			if (a === null) return null;
+			context.rect(a[0], a[1], a[2], a[3]);
+			return InterpretedSymbol.of("t");
+		});
 	}
 	gRotate(arguments_) {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			if (arguments_.length() === 1 && Cons.isNumber(arguments_.car)) {
-				this.ctx.rotate(Math.PI / 180 * arguments_.car);
-				return InterpretedSymbol.of("t");
-			}
-			this.#print("Can not rotate.");
-			return Cons.nil;
-		} catch {
-			this.#print("Can not rotate.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		return this.#execute("Can not rotate.", (context) => {
+			const a = this.#numbers(arguments_, 1);
+			if (a === null) return null;
+			context.rotate(Math.PI / 180 * a[0]);
+			return InterpretedSymbol.of("t");
+		});
 	}
 	/**
 	* Pushes the current drawing state (styles, transform, clip) onto the
@@ -1206,36 +874,26 @@ var GraphicsPlugin = class GraphicsPlugin {
 	* state explicitly. Replaces the legacy per-method `context.save()` calls, which
 	* pushed state on every draw with no matching `restore()` and grew the stack
 	* unbounded.
-	* @return `t` on success, `Cons.nil` otherwise
+	* @return `t` on success
 	*/
-	gSave() {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			this.ctx.save();
+	gSave(arguments_ = Cons.nil) {
+		return this.#execute("Can not save.", (context) => {
+			if (arguments_.length() !== 0) return null;
+			context.save();
 			return InterpretedSymbol.of("t");
-		} catch {
-			this.#print("Can not save.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		});
 	}
 	/**
 	* Pops the most recently saved drawing state off the context's state stack.
 	* Pairs with `gSave`. Popping an empty stack is a no-op per the Canvas spec.
-	* @return `t` on success, `Cons.nil` otherwise
+	* @return `t` on success
 	*/
-	gRestore() {
-		if (!this.checkSupport()) return Cons.nil;
-		if (this.isOpen) try {
-			this.ctx.restore();
+	gRestore(arguments_ = Cons.nil) {
+		return this.#execute("Can not restore.", (context) => {
+			if (arguments_.length() !== 0) return null;
+			context.restore();
 			return InterpretedSymbol.of("t");
-		} catch {
-			this.#print("Can not restore.");
-			return Cons.nil;
-		}
-		this.#print("The canvas is closed and cannot be executed.");
-		return Cons.nil;
+		});
 	}
 	gEllipse(arguments_) {
 		return this.#execute("Can not draw ellipse.", (context) => {
@@ -1257,6 +915,7 @@ var GraphicsPlugin = class GraphicsPlugin {
 		return this.#execute("Can not set line dash.", (context) => {
 			const segments = this.#numbers(arguments_, arguments_.length());
 			if (segments === null) return null;
+			if (segments.some((segment) => !Number.isFinite(segment) || segment < 0)) return null;
 			context.setLineDash(segments);
 			return InterpretedSymbol.of("t");
 		});
@@ -1277,8 +936,9 @@ var GraphicsPlugin = class GraphicsPlugin {
 			return InterpretedSymbol.of("t");
 		});
 	}
-	gClip() {
+	gClip(arguments_ = Cons.nil) {
 		return this.#execute("Can not clip.", (context) => {
+			if (arguments_.length() !== 0) return null;
 			context.clip();
 			return InterpretedSymbol.of("t");
 		});
@@ -1313,8 +973,9 @@ var GraphicsPlugin = class GraphicsPlugin {
 			return InterpretedSymbol.of("t");
 		});
 	}
-	gResetTransform() {
+	gResetTransform(arguments_ = Cons.nil) {
 		return this.#execute("Can not reset transform.", (context) => {
+			if (arguments_.length() !== 0) return null;
 			context.resetTransform();
 			return InterpretedSymbol.of("t");
 		});
@@ -1406,17 +1067,18 @@ var GraphicsPlugin = class GraphicsPlugin {
 			return InterpretedSymbol.of("t");
 		});
 	}
-	gReset() {
+	gReset(arguments_ = Cons.nil) {
 		return this.#execute("Can not reset.", (context) => {
+			if (arguments_.length() !== 0) return null;
 			context.reset();
 			return InterpretedSymbol.of("t");
 		});
 	}
-	gWidth() {
-		return this.#execute("Can not get width.", () => this.canvas.width);
+	gWidth(arguments_ = Cons.nil) {
+		return this.#execute("Can not get width.", () => arguments_.length() === 0 ? BigInt(this.canvas.width) : null);
 	}
-	gHeight() {
-		return this.#execute("Can not get height.", () => this.canvas.height);
+	gHeight(arguments_ = Cons.nil) {
+		return this.#execute("Can not get height.", () => arguments_.length() === 0 ? BigInt(this.canvas.height) : null);
 	}
 	gPixel(arguments_) {
 		return this.#execute("Can not read pixel.", (context) => {
@@ -1424,10 +1086,10 @@ var GraphicsPlugin = class GraphicsPlugin {
 			if (a === null) return null;
 			const data = context.getImageData(a[0], a[1], 1, 1).data;
 			return this.#toList([
-				data[0],
-				data[1],
-				data[2],
-				data[3]
+				BigInt(data[0]),
+				BigInt(data[1]),
+				BigInt(data[2]),
+				BigInt(data[3])
 			]);
 		});
 	}
@@ -1448,27 +1110,28 @@ var GraphicsPlugin = class GraphicsPlugin {
 		return this.#execute("Can not set linear gradient.", (context) => {
 			const [x0, y0, x1, y1, ...stops] = this.#listValues(arguments_);
 			if (stops.length < 2 || !Cons.isNumber(x0) || !Cons.isNumber(y0) || !Cons.isNumber(x1) || !Cons.isNumber(y1)) return null;
-			return this.#installGradient(context, context.createLinearGradient(x0, y0, x1, y1), stops);
+			return this.#installGradient(context, context.createLinearGradient(Numeric.toFloat(x0), Numeric.toFloat(y0), Numeric.toFloat(x1), Numeric.toFloat(y1)), stops);
 		});
 	}
 	gRadialGradient(arguments_) {
 		return this.#execute("Can not set radial gradient.", (context) => {
 			const [x0, y0, r0, x1, y1, r1, ...stops] = this.#listValues(arguments_);
 			if (stops.length < 2 || !Cons.isNumber(x0) || !Cons.isNumber(y0) || !Cons.isNumber(r0) || !Cons.isNumber(x1) || !Cons.isNumber(y1) || !Cons.isNumber(r1)) return null;
-			return this.#installGradient(context, context.createRadialGradient(x0, y0, r0, x1, y1, r1), stops);
+			return this.#installGradient(context, context.createRadialGradient(Numeric.toFloat(x0), Numeric.toFloat(y0), Numeric.toFloat(r0), Numeric.toFloat(x1), Numeric.toFloat(y1), Numeric.toFloat(r1)), stops);
 		});
 	}
 	gConicGradient(arguments_) {
 		return this.#execute("Can not set conic gradient.", (context) => {
 			const [angle, x, y, ...stops] = this.#listValues(arguments_);
 			if (stops.length < 2 || !Cons.isNumber(angle) || !Cons.isNumber(x) || !Cons.isNumber(y)) return null;
-			return this.#installGradient(context, context.createConicGradient(Math.PI / 180 * angle, x, y), stops);
+			return this.#installGradient(context, context.createConicGradient(Math.PI / 180 * Numeric.toFloat(angle), Numeric.toFloat(x), Numeric.toFloat(y)), stops);
 		});
 	}
 	/**
 	* Parses a color spec from the head of the argument Cons. Accepts
 	* (1 string), (3 numbers — rgb), or (4 numbers — rgba); falls back to
-	* `'black'` on anything else (legacy behavior).
+	* `'black'` on anything else (legacy behavior — a best-effort color parse
+	* that prints a diagnostic instead of signaling an error).
 	* @param arguments_ - the argument Cons to parse
 	* @return CSS color string
 	*/
@@ -1481,7 +1144,7 @@ var GraphicsPlugin = class GraphicsPlugin {
 			const cdr1 = arguments_.cdr;
 			const a1 = cdr1.car;
 			const a2 = cdr1.cdr.car;
-			if (Cons.isNumber(a0) && Cons.isNumber(a1) && Cons.isNumber(a2)) aColor = `rgb(${a0}, ${a1}, ${a2})`;
+			if (Cons.isNumber(a0) && Cons.isNumber(a1) && Cons.isNumber(a2)) aColor = `rgb(${Numeric.toFloat(a0)}, ${Numeric.toFloat(a1)}, ${Numeric.toFloat(a2)})`;
 			else this.#print("Can not set color. set color \"black\".");
 		} else if (length_ === 4) {
 			const cdr1 = arguments_.cdr;
@@ -1489,7 +1152,7 @@ var GraphicsPlugin = class GraphicsPlugin {
 			const cdr2 = cdr1.cdr;
 			const a2 = cdr2.car;
 			const a3 = cdr2.cdr.car;
-			if (Cons.isNumber(a0) && Cons.isNumber(a1) && Cons.isNumber(a2) && Cons.isNumber(a3)) aColor = `rgba(${a0}, ${a1}, ${a2}, ${a3})`;
+			if (Cons.isNumber(a0) && Cons.isNumber(a1) && Cons.isNumber(a2) && Cons.isNumber(a3)) aColor = `rgba(${Numeric.toFloat(a0)}, ${Numeric.toFloat(a1)}, ${Numeric.toFloat(a2)}, ${Numeric.toFloat(a3)})`;
 			else this.#print("Can not set color. set color \"black\".");
 		} else this.#print("Can not set color. set color \"black\".");
 		return aColor;