kei-lisp-plugin-graphics 1.0.0

package/dist/index.js

@@ -0,0 +1,1086 @@
+import { Cons, InterpretedSymbol } from "kei-lisp";
+//#region src/GraphicsPlugin/index.ts
+/**
+* @class
+* @classdesc Canvas2D drawing plugin for the kei-lisp interpreter. Implements
+*            the `KeiLispPlugin` contract (`name` / `has` / `apply`) and
+*            exposes 43 `g…` Lisp functions that proxy to a 2D rendering
+*            context.
+* @author Keisuke Ikeda
+* @this {GraphicsPlugin}
+*/
+var GraphicsPlugin = class GraphicsPlugin extends Object {
+	/**
+	* Dispatch map from a Lisp function name (InterpretedSymbol) to the name of
+	* the GraphicsPlugin method that implements it.
+	*/
+	static buildInFunctions = GraphicsPlugin.setup();
+	/**
+	* Plugin identifier, used for diagnostics.
+	*/
+	name = "graphics";
+	canvas;
+	ctx;
+	isOpen;
+	/**
+	* Constructor.
+	* @constructor
+	* @param canvas - the canvas to draw to
+	*/
+	constructor(canvas) {
+		super();
+		this.canvas = canvas;
+		this.ctx = canvas.getContext("2d");
+		this.isOpen = false;
+	}
+	/**
+	* Returns true if this plugin handles the given symbol.
+	* @param aSymbol - the call symbol
+	* @return true if `apply` should be called
+	*/
+	has(aSymbol) {
+		return GraphicsPlugin.buildInFunctions.has(aSymbol);
+	}
+	/**
+	* Dispatches the given symbol to the matching `g…` method.
+	* @param aSymbol - the call symbol
+	* @param args - the evaluated argument list
+	* @param _ctx - the interpreter context (unused by this plugin)
+	* @return the method's result, or `Cons.nil` if dispatch fails
+	*/
+	apply(aSymbol, args, _ctx) {
+		return this.selectProcedure(aSymbol, args);
+	}
+	/**
+	* Resolves the procedure name and invokes the matching method.
+	* @param procedure - the Lisp symbol
+	* @param args - the evaluated argument list
+	* @return the method's result, or `Cons.nil` if not registered
+	*/
+	selectProcedure(procedure, args) {
+		if (GraphicsPlugin.buildInFunctions.has(procedure)) return this.buildInFunction(procedure, args);
+		this._print(`I could find no procedure description for ${String(procedure)}`);
+		return Cons.nil;
+	}
+	/**
+	* Looks up and invokes the JS method that implements the given Lisp symbol.
+	* Throws `TypeError` when the dispatch table points to a method that does
+	* not exist on the instance — this matches the legacy behavior, where the
+	* Ramda `R.invoker(1, methodName)(args, this)` call would surface the same
+	* error by attempting to call `undefined`.
+	* @param procedure - the Lisp symbol
+	* @param args - the evaluated argument list
+	* @return the method's result
+	*/
+	buildInFunction(procedure, args) {
+		const methodName = GraphicsPlugin.buildInFunctions.get(procedure);
+		const method = this[methodName];
+		if (typeof method !== "function") throw new TypeError(`${this.constructor.name} does not have a method named "${methodName}"`);
+		return method.call(this, args);
+	}
+	/**
+	* 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 ctx 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;
+	}
+	/**
+	* Writes a diagnostic line directly 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,
+	* so the same call reaches the user via the host's normal output channel.
+	* @param line - the line to write
+	*/
+	_print(line) {
+		process.stderr.write(line + "\n");
+	}
+	gAlpha(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 1 && Cons.isNumber(args.car)) {
+				const aNumber = args.car <= 0 ? 0 : args.car >= 1 ? 1 : args.car;
+				this.ctx.globalAlpha = aNumber;
+				this.ctx.save();
+				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;
+	}
+	gArc(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 6) {
+				const a0 = args.car;
+				const cdr1 = args.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 aFlag = a5 >= 0;
+					this.ctx.arc(a0, a1, a2, Math.PI / 180 * a3, Math.PI / 180 * a4, aFlag);
+					this.ctx.save();
+					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;
+	}
+	gArcTo(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 5) {
+				const a0 = args.car;
+				const cdr1 = args.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);
+					this.ctx.save();
+					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;
+	}
+	gBezCurveTo(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 6) {
+				const a0 = args.car;
+				const cdr1 = args.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);
+					this.ctx.save();
+					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;
+	}
+	gClear() {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			this.ctx.fillStyle = "#ffffff";
+			this.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
+			this.ctx.fillStyle = "#000000";
+			this.ctx.save();
+			return InterpretedSymbol.of("t");
+		} catch {
+			this._print("Can not clear.");
+			return Cons.nil;
+		}
+		this._print("The canvas is closed and cannot be executed.");
+		return Cons.nil;
+	}
+	gClose() {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) 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;
+		}
+		this._print("The canvas has already been closed.");
+		return Cons.nil;
+	}
+	gColor(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() >= 1) {
+				const aColor = this.selectColor(args);
+				this.ctx.fillStyle = aColor;
+				this.ctx.strokeStyle = aColor;
+				this.ctx.save();
+				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;
+	}
+	gFill() {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			this.ctx.fill();
+			this.ctx.save();
+			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(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() >= 1) {
+				const aColor = this.selectColor(args);
+				this.ctx.fillStyle = aColor;
+				this.ctx.save();
+				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;
+	}
+	gFillRect(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 4) {
+				const a0 = args.car;
+				const cdr1 = args.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);
+					this.ctx.save();
+					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;
+	}
+	gFillText(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 3) {
+				const a0 = args.car;
+				const cdr1 = args.cdr;
+				const a1 = cdr1.car;
+				const a2 = cdr1.cdr.car;
+				if (Cons.isString(a0) && Cons.isNumber(a1) && Cons.isNumber(a2)) {
+					this.ctx.fillText(a0, a1, a2);
+					this.ctx.save();
+					return InterpretedSymbol.of("t");
+				}
+			}
+			this._print("Can not draw fill text.");
+			return Cons.nil;
+		} catch {
+			this._print("Can not draw fill text.");
+			return Cons.nil;
+		}
+		this._print("The canvas is closed and cannot be executed.");
+		return Cons.nil;
+	}
+	gFillTri(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 6) {
+				const a0 = args.car;
+				const cdr1 = args.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();
+					this.ctx.save();
+					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;
+	}
+	gFinishPath() {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			this.ctx.closePath();
+			this.ctx.save();
+			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(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			const len = args.length();
+			if (len === 3) {
+				const a0 = args.car;
+				const cdr1 = args.cdr;
+				const a1 = cdr1.car;
+				const a2 = cdr1.cdr.car;
+				if (Cons.isString(a0) && Cons.isNumber(a1) && Cons.isNumber(a2)) {
+					const ctx = this.ctx;
+					const anImage = new Image();
+					anImage.src = a0;
+					anImage.onload = () => {
+						ctx.drawImage(anImage, a1, a2);
+					};
+					ctx.save();
+					return InterpretedSymbol.of("t");
+				}
+			} else if (len === 5) {
+				const a0 = args.car;
+				const cdr1 = args.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.isString(a0) && Cons.isNumber(a1) && Cons.isNumber(a2) && Cons.isNumber(a3) && Cons.isNumber(a4)) {
+					const ctx = this.ctx;
+					const anImage = new Image();
+					anImage.src = a0;
+					anImage.onload = () => {
+						ctx.drawImage(anImage, a1, a2, a3, a4);
+					};
+					ctx.save();
+					return InterpretedSymbol.of("t");
+				}
+			}
+			this._print("Can not draw Image.");
+			return Cons.nil;
+		} catch {
+			this._print("Can not draw Image.");
+			return Cons.nil;
+		}
+		this._print("The canvas is closed and cannot be executed.");
+		return Cons.nil;
+	}
+	gLineTo(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 2) {
+				const a0 = args.car;
+				const a1 = args.cdr.car;
+				if (Cons.isNumber(a0) && Cons.isNumber(a1)) {
+					this.ctx.lineTo(a0, a1);
+					this.ctx.save();
+					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;
+	}
+	gLineCap(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 1 && Cons.isNumber(args.car)) {
+				const aString = args.car === 0 ? "butt" : args.car > 0 ? "round" : "square";
+				this.ctx.lineCap = aString;
+				this.ctx.save();
+				return InterpretedSymbol.of("t");
+			}
+			this._print("Can not set line cap.");
+			return Cons.nil;
+		} catch {
+			this._print("Can not set line cap.");
+			return Cons.nil;
+		}
+		this._print("The canvas is closed and cannot be executed.");
+		return Cons.nil;
+	}
+	gLineJoin(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 1 && Cons.isNumber(args.car)) {
+				const aString = args.car === 0 ? "miter" : args.car > 0 ? "round" : "bevel";
+				this.ctx.lineJoin = aString;
+				this.ctx.save();
+				return InterpretedSymbol.of("t");
+			}
+			this._print("Can not set line join.");
+			return Cons.nil;
+		} catch {
+			this._print("Can not set line join.");
+			return Cons.nil;
+		}
+		this._print("The canvas is closed and cannot be executed.");
+		return Cons.nil;
+	}
+	gLineWidth(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 1 && Cons.isNumber(args.car)) {
+				const aNumber = args.car <= 0 ? 1 : args.car;
+				this.ctx.lineWidth = aNumber;
+				this.ctx.save();
+				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;
+	}
+	gMoveTo(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 2) {
+				const a0 = args.car;
+				const a1 = args.cdr.car;
+				if (Cons.isNumber(a0) && Cons.isNumber(a1)) {
+					this.ctx.moveTo(a0, a1);
+					this.ctx.save();
+					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;
+	}
+	gOpen() {
+		if (!this.checkSupport()) return Cons.nil;
+		if (!this.isOpen) try {
+			this.isOpen = true;
+			this.ctx.fillStyle = "#ffffff";
+			this.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
+			this.ctx.fillStyle = "#000000";
+			this.ctx.save();
+			this._print("canvas size, width : 600 height : 300");
+			return InterpretedSymbol.of("t");
+		} catch {
+			this._print("Can not open.");
+			return Cons.nil;
+		}
+		this._print("The canvas has already been opened.");
+		return Cons.nil;
+	}
+	gPattern(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 2) {
+				const a0 = args.car;
+				const a1 = args.cdr.car;
+				if (Cons.isString(a0) && Cons.isNumber(a1)) {
+					const aString = a1 === 0 ? "repeat" : a1 > 0 ? "repeat-x" : "repeat-y";
+					const ctx = this.ctx;
+					const anImage = new Image();
+					anImage.src = a0;
+					anImage.onload = () => {
+						ctx.fillStyle = ctx.createPattern(anImage, aString);
+					};
+					ctx.save();
+					return InterpretedSymbol.of("t");
+				}
+			}
+			this._print("Can not set pattern.");
+			return Cons.nil;
+		} catch {
+			this._print("Can not set pattern.");
+			return Cons.nil;
+		}
+		this._print("The canvas is closed and cannot be executed.");
+		return Cons.nil;
+	}
+	gQuadCurveTo(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 4) {
+				const a0 = args.car;
+				const cdr1 = args.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);
+					this.ctx.save();
+					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;
+	}
+	gSaveJpeg() {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			const anImage = new Image();
+			anImage.crossOrigin = "Anonymous";
+			anImage.src = this.canvas.toDataURL("image/jpeg");
+			const link = document.createElement("a");
+			link.href = anImage.src;
+			link.download = "canvas";
+			document.body.append(link);
+			link.click();
+			link.remove();
+			return InterpretedSymbol.of("t");
+		} catch {
+			this._print("Can not save jpeg.  If you are using an image in the canvas, you can't save jpeg.");
+			return Cons.nil;
+		}
+		this._print("The canvas is closed and cannot be executed.");
+		return Cons.nil;
+	}
+	gSavePng() {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			const anImage = new Image();
+			anImage.crossOrigin = "Anonymous";
+			anImage.src = this.canvas.toDataURL("image/png");
+			const link = document.createElement("a");
+			link.href = anImage.src;
+			link.download = "canvas";
+			document.body.append(link);
+			link.click();
+			link.remove();
+			return InterpretedSymbol.of("t");
+		} catch {
+			this._print("Can not save png. If you are using an image in the canvas, you can't save png.");
+			return Cons.nil;
+		}
+		this._print("The canvas is closed and cannot be executed.");
+		return Cons.nil;
+	}
+	gScale(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 2) {
+				const a0 = args.car;
+				const a1 = args.cdr.car;
+				if (Cons.isNumber(a0) && Cons.isNumber(a1)) {
+					this.ctx.scale(a0, a1);
+					this.ctx.save();
+					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;
+	}
+	gShadowBlur(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) {
+			if (args.length() === 1 && Cons.isNumber(args.car)) {
+				this.ctx.Blur = args.car;
+				this.ctx.save();
+				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;
+	}
+	gShadowColor(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 1) {
+				const aColor = this.selectColor(args);
+				this.ctx.shadowColor = aColor;
+				this.ctx.save();
+				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;
+	}
+	gShadowOffsetX(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) {
+			if (args.length() === 1 && Cons.isNumber(args.car)) {
+				this.ctx.shadowOffsetX = args.car;
+				this.ctx.save();
+				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;
+	}
+	gShadowOffsetY(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) {
+			if (args.length() === 1 && Cons.isNumber(args.car)) {
+				this.ctx.shadowOffsetY = args.car;
+				this.ctx.save();
+				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;
+	}
+	gSleep(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) {
+			const sleep = (ms) => {
+				const time = Date.now() + ms;
+				while (Date.now() < time);
+			};
+			if (args.length() === 1 && Cons.isNumber(args.car)) {
+				sleep(args.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;
+	}
+	gStartPath() {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			this.ctx.beginPath();
+			this.ctx.save();
+			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();
+			this.ctx.save();
+			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(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() >= 1) {
+				const aColor = this.selectColor(args);
+				this.ctx.strokeStyle = aColor;
+				this.ctx.save();
+				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;
+	}
+	gStrokeRect(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 4) {
+				const a0 = args.car;
+				const cdr1 = args.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);
+					this.ctx.save();
+					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;
+	}
+	gStrokeText(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 3) {
+				const a0 = args.car;
+				const cdr1 = args.cdr;
+				const a1 = cdr1.car;
+				const a2 = cdr1.cdr.car;
+				if (Cons.isString(a0) && Cons.isNumber(a1) && Cons.isNumber(a2)) {
+					this.ctx.strokeText(a0, a1, a2);
+					this.ctx.save();
+					return InterpretedSymbol.of("t");
+				}
+			}
+			this._print("Can not draw fill text.");
+			return Cons.nil;
+		} catch {
+			this._print("Can not draw fill text.");
+			return Cons.nil;
+		}
+		this._print("The canvas is closed and cannot be executed.");
+		return Cons.nil;
+	}
+	gStrokeTri(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 6) {
+				const a0 = args.car;
+				const cdr1 = args.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();
+					this.ctx.save();
+					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;
+	}
+	gTextAlign(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 1 && Cons.isString(args.car)) {
+				this.ctx.textAlign = args.car;
+				this.ctx.save();
+				return InterpretedSymbol.of("t");
+			}
+			this._print("Can not set text align.");
+			return Cons.nil;
+		} catch {
+			this._print("Can not set text align.");
+			return Cons.nil;
+		}
+		this._print("The canvas is closed and cannot be executed.");
+		return Cons.nil;
+	}
+	gTextBaseline(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 1 && Cons.isString(args.car)) {
+				this.ctx.textBaseline = args.car;
+				this.ctx.save();
+				return InterpretedSymbol.of("t");
+			}
+			this._print("Can not set text baseline.");
+			return Cons.nil;
+		} catch {
+			this._print("Can not set text baseline.");
+			return Cons.nil;
+		}
+		this._print("The canvas is closed and cannot be executed.");
+		return Cons.nil;
+	}
+	gTextDirection(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 1 && Cons.isNumber(args.car)) {
+				const aString = args.car === 0 ? "inherit" : args.car > 0 ? "rtl" : "ltr";
+				this.ctx.direction = aString;
+				this.ctx.save();
+				return InterpretedSymbol.of("t");
+			}
+			this._print("Can not set text direction.");
+			return Cons.nil;
+		} catch {
+			this._print("Can not set text direction.");
+			return Cons.nil;
+		}
+		this._print("The canvas is closed and cannot be executed.");
+		return Cons.nil;
+	}
+	gTextFont(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 1 && Cons.isString(args.car)) {
+				this.ctx.font = args.car;
+				this.ctx.save();
+				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;
+	}
+	gTranslate(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 2) {
+				const a0 = args.car;
+				const a1 = args.cdr.car;
+				if (Cons.isNumber(a0) && Cons.isNumber(a1)) {
+					this.ctx.translate(a0, a1);
+					this.ctx.save();
+					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;
+	}
+	gRect(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 4) {
+				const a0 = args.car;
+				const cdr1 = args.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);
+					this.ctx.save();
+					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;
+	}
+	gRotate(args) {
+		if (!this.checkSupport()) return Cons.nil;
+		if (this.isOpen) try {
+			if (args.length() === 1 && Cons.isNumber(args.car)) {
+				this.ctx.rotate(Math.PI / 180 * args.car);
+				this.ctx.save();
+				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;
+	}
+	/**
+	* 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).
+	* @param args - the argument Cons to parse
+	* @return CSS color string
+	*/
+	selectColor(args) {
+		let aColor = "black";
+		const len = args.length();
+		const a0 = args.car;
+		if (len === 1 && Cons.isString(a0)) aColor = a0;
+		else if (len === 3) {
+			const cdr1 = args.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})`;
+			else this._print("Can not set color. set color \"black\".");
+		} else if (len === 4) {
+			const cdr1 = args.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)) aColor = `rgba(${a0}, ${a1}, ${a2}, ${a3})`;
+			else this._print("Can not set color. set color \"black\".");
+		} else this._print("Can not set color. set color \"black\".");
+		return aColor;
+	}
+	/**
+	* Builds the dispatch table.
+	* @return the dispatch table
+	*/
+	static setup() {
+		const aTable = /* @__PURE__ */ new Map();
+		aTable.set(InterpretedSymbol.of("galpha"), "gAlpha");
+		aTable.set(InterpretedSymbol.of("garc"), "gArc");
+		aTable.set(InterpretedSymbol.of("garc-to"), "gArcTo");
+		aTable.set(InterpretedSymbol.of("gbezcurve-to"), "gBezCurveTo");
+		aTable.set(InterpretedSymbol.of("gclear"), "gClear");
+		aTable.set(InterpretedSymbol.of("gclose"), "gClose");
+		aTable.set(InterpretedSymbol.of("gcolor"), "gColor");
+		aTable.set(InterpretedSymbol.of("gfill"), "gFill");
+		aTable.set(InterpretedSymbol.of("gfill-color"), "gFillColor");
+		aTable.set(InterpretedSymbol.of("gfill-rect"), "gFillRect");
+		aTable.set(InterpretedSymbol.of("gfill-text"), "gFillText");
+		aTable.set(InterpretedSymbol.of("gfill-tri"), "gFillTri");
+		aTable.set(InterpretedSymbol.of("gfinish-path"), "gFinishPath");
+		aTable.set(InterpretedSymbol.of("gimage"), "gImage");
+		aTable.set(InterpretedSymbol.of("gmove-to"), "gMoveTo");
+		aTable.set(InterpretedSymbol.of("gline-to"), "gLineTo");
+		aTable.set(InterpretedSymbol.of("gline-cap"), "gLineCap");
+		aTable.set(InterpretedSymbol.of("gline-join"), "gLineJoin");
+		aTable.set(InterpretedSymbol.of("gline-width"), "gLineWidth");
+		aTable.set(InterpretedSymbol.of("gopen"), "gOpen");
+		aTable.set(InterpretedSymbol.of("gpattern"), "gPattern");
+		aTable.set(InterpretedSymbol.of("gquadcurve-to"), "gQuadCurveTo");
+		aTable.set(InterpretedSymbol.of("gsave-jpeg"), "gSaveJpeg");
+		aTable.set(InterpretedSymbol.of("gsave-png"), "gSavePng");
+		aTable.set(InterpretedSymbol.of("gscale"), "gScale");
+		aTable.set(InterpretedSymbol.of("gshadow-blur"), "gShadowBlur");
+		aTable.set(InterpretedSymbol.of("gshadow-color"), "gShadowColor");
+		aTable.set(InterpretedSymbol.of("gshadow-offsetx"), "gShadowOffsetX");
+		aTable.set(InterpretedSymbol.of("gshadow-offsety"), "gShadowOffsetY");
+		aTable.set(InterpretedSymbol.of("gsleep"), "gSleep");
+		aTable.set(InterpretedSymbol.of("gstart-path"), "gStartPath");
+		aTable.set(InterpretedSymbol.of("gstroke"), "gStroke");
+		aTable.set(InterpretedSymbol.of("gstroke-color"), "gStrokeColor");
+		aTable.set(InterpretedSymbol.of("gstroke-rect"), "gStrokeRect");
+		aTable.set(InterpretedSymbol.of("gstroke-text"), "gStrokeText");
+		aTable.set(InterpretedSymbol.of("gstroke-tri"), "gStrokeTri");
+		aTable.set(InterpretedSymbol.of("gtext-align"), "gTextAlign");
+		aTable.set(InterpretedSymbol.of("gtext-dire"), "gTextDirection");
+		aTable.set(InterpretedSymbol.of("gtext-font"), "gTextFont");
+		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");
+		return aTable;
+	}
+};
+//#endregion
+//#region src/index.ts
+/**
+* Creates a Canvas2D drawing plugin bound to the given canvas. Register it on
+* a `LispInterpreter` via `interpreter.use(plugin)` to make the `g…` drawing
+* primitives callable from Lisp source.
+* @param options - the canvas to draw to
+* @return a KeiLispPlugin that handles the `g…` symbols
+*/
+function createGraphicsPlugin(options) {
+	return new GraphicsPlugin(options.canvas);
+}
+//#endregion
+export { GraphicsPlugin, createGraphicsPlugin };
+
+//# sourceMappingURL=index.js.map