kei-lisp 2.1.0 → 2.2.0

package/dist/index.cjs

@@ -34,10 +34,17 @@ let node_module = require("node:module");
 * @this {Table}
 */
 var Table = class Table extends Map {
+	/**
+	* The enclosing (parent) environment, or null when this is the root.
+	*/
 	source;
+	/**
+	* Whether this environment is the root of its chain.
+	*/
 	root;
 	/**
 	* Constructor.
+	* @constructor
 	* @param aTable the environment in which this environment was created
 	*/
 	constructor(aTable = null) {
@@ -47,6 +54,7 @@ var Table = class Table extends Map {
 	}
 	/**
 	* Clones this Table and returns the clone.
+	* @return the cloned Table
 	*/
 	clone() {
 		const aTable = new Table(this);
@@ -59,6 +67,8 @@ var Table = class Table extends Map {
 	}
 	/**
 	* Returns whether anything is bound to the given property (key).
+	* @param aSymbol the symbol to look up
+	* @return true if a binding exists in this scope or any enclosing scope
 	*/
 	has(aSymbol) {
 		if (super.has(aSymbol)) return true;
@@ -67,12 +77,16 @@ var Table = class Table extends Map {
 	}
 	/**
 	* Returns whether this instance equals the given object.
+	* @param anObject the object to compare against
+	* @return true when the underlying Map.equals would return true
 	*/
 	equals(anObject) {
 		return Map.prototype.equals(anObject);
 	}
 	/**
-	* Returns the value bound to the given interpreted symbol.
+	* Returns the value bound to the given interpreted symbol, walking up the scope chain.
+	* @param aSymbol the symbol to look up
+	* @return the bound value, or null when no binding exists
 	*/
 	get(aSymbol) {
 		if (super.has(aSymbol)) return super.get(aSymbol);
@@ -81,13 +95,16 @@ var Table = class Table extends Map {
 	}
 	/**
 	* Returns whether this instance is the root of the environment chain.
+	* @return true if this is the root environment
 	*/
 	isRoot() {
 		return this.root;
 	}
 	/**
-	* Reassigns the symbol bound in the innermost scope (equivalent to Common Lisp's setq).
-	* If a binding exists in the current scope, update it and return; otherwise recurse into the parent scope.
+	* Reassigns the symbol bound in the innermost scope (equivalent to Common Lisp's setq). If a binding exists in the current scope, update it and return; otherwise recurse into the parent scope.
+	* @param aSymbol the symbol to update
+	* @param anObject the new bound value
+	* @return the new bound value, or null when no enclosing scope has a binding
 	*/
 	setIfExist(aSymbol, anObject) {
 		if (super.has(aSymbol)) {
@@ -99,6 +116,8 @@ var Table = class Table extends Map {
 	}
 	/**
 	* Sets whether this instance is the root of its environment chain.
+	* @param aBoolean the new root flag
+	* @return null
 	*/
 	setRoot(aBoolean) {
 		this.root = aBoolean;
@@ -106,6 +125,8 @@ var Table = class Table extends Map {
 	}
 	/**
 	* Sets the parent environment.
+	* @param aTable the new parent environment (or null)
+	* @return null
 	*/
 	setSource(aTable) {
 		this.source = aTable;
@@ -113,6 +134,7 @@ var Table = class Table extends Map {
 	}
 	/**
 	* Returns a formatted string representation of this instance.
+	* @return the formatted string
 	*/
 	toString() {
 		return "#<Environment>";
@@ -126,21 +148,30 @@ var Table = class Table extends Map {
 * @author Keisuke Ikeda
 * @this {InterpretedSymbol}
 */
-var InterpretedSymbol = class InterpretedSymbol {
+var InterpretedSymbol = class InterpretedSymbol extends Object {
 	/**
 	* Table that stores InterpretedSymbol instances (lazily initialized to avoid a circular dependency).
 	*/
 	static #intern = null;
+	/**
+	* Lazy accessor for the intern table that holds every InterpretedSymbol instance.
+	* @return the intern Table (created on first access)
+	*/
 	static get table() {
 		this.#intern ??= new Table();
 		return this.#intern;
 	}
+	/**
+	* The printed name of this symbol.
+	*/
 	name;
 	/**
 	* Constructor.
+	* @constructor
 	* @param name printed name
 	*/
 	constructor(name = "null") {
+		super();
 		this.name = name;
 	}
 	/**
@@ -157,6 +188,8 @@ var InterpretedSymbol = class InterpretedSymbol {
 	}
 	/**
 	* Returns whether this symbol equals the given object.
+	* @param anObject the object to compare against
+	* @return true when identity-equal (since intern guarantees uniqueness)
 	*/
 	equals(anObject) {
 		return this === anObject;
@@ -164,6 +197,7 @@ var InterpretedSymbol = class InterpretedSymbol {
 	/**
 	* Returns the same interpreted symbol for a given printed name.
 	* @param aString printed name
+	* @return the canonical InterpretedSymbol for that name
 	*/
 	static of(aString) {
 		let aSymbol = this.table.get(aString);
@@ -175,6 +209,7 @@ var InterpretedSymbol = class InterpretedSymbol {
 	}
 	/**
 	* Returns the string representation of this symbol.
+	* @return the printed name
 	*/
 	toString() {
 		return this.name;
@@ -188,33 +223,47 @@ var InterpretedSymbol = class InterpretedSymbol {
 * @author Keisuke Ikeda
 * @this {Loop}
 */
-var Loop = class {
+var Loop = class extends Object {
+	/**
+	* The Cons being iterated over.
+	*/
 	aCons;
+	/**
+	* The number of elements in the underlying Cons (computed once at construction time).
+	*/
 	length;
+	/**
+	* The 1-based index of the next element to return.
+	*/
 	index;
 	/**
 	* Constructor.
+	* @constructor
 	* @param aCons the Cons to iterate over
 	*/
 	constructor(aCons) {
+		super();
 		this.aCons = aCons;
 		this.length = aCons.length();
 		this.index = 1;
 	}
 	/**
-	* Returns this instance.
+	* Returns this instance so it can be used as its own iterator.
+	* @return this Loop instance
 	*/
 	iterator() {
 		return this;
 	}
 	/**
 	* Returns whether a next element exists.
+	* @return true if there is at least one more element
 	*/
 	hasNext() {
 		return this.index <= this.length;
 	}
 	/**
-	* Returns the next element.
+	* Returns the next element and advances the cursor.
+	* @return the element at the current index
 	*/
 	next() {
 		const anObject = this.aCons.nth(this.index);
@@ -222,8 +271,8 @@ var Loop = class {
 		return anObject;
 	}
 	/**
-	* Implementation of the iterable protocol.
-	* Enables iteration with for...of and similar constructs.
+	* Implementation of the iterable protocol. Enables iteration with for...of and similar constructs.
+	* @return an iterator over the Cons elements
 	*/
 	[Symbol.iterator]() {
 		return { next: () => {
@@ -239,8 +288,8 @@ var Loop = class {
 		} };
 	}
 	/**
-	* Implementation of the async iterable protocol.
-	* Enables iteration with for await...of and similar constructs.
+	* Implementation of the async iterable protocol. Enables iteration with for await...of and similar constructs.
+	* @return an async iterator over the Cons elements
 	*/
 	[Symbol.asyncIterator]() {
 		return { next: () => {
@@ -256,7 +305,8 @@ var Loop = class {
 		} };
 	}
 	/**
-	* Advances to the next element.
+	* Advances the cursor to the next element.
+	* @return null
 	*/
 	remove() {
 		this.index++;
@@ -271,9 +321,12 @@ var Loop = class {
 * @author Keisuke Ikeda
 * @this {IntStream}
 */
-var IntStream = class {
+var IntStream = class extends Object {
 	/**
 	* Builds and returns an array of consecutive integers from start to afterEnd (exclusive).
+	* @param start the first integer (inclusive)
+	* @param afterEnd the integer one past the last value to include
+	* @return the array of integers in [start, afterEnd)
 	*/
 	static range(start, afterEnd) {
 		const end = afterEnd - 1;
@@ -281,6 +334,9 @@ var IntStream = class {
 	}
 	/**
 	* Builds and returns an array of consecutive integers from start to end (inclusive).
+	* @param start the first integer (inclusive)
+	* @param end the last integer (inclusive)
+	* @return the array of integers in [start, end]
 	*/
 	static rangeClosed(start, end) {
 		const range = end - start + 1;
@@ -333,21 +389,39 @@ var ParseError = class extends KeiLispError {
 * @author Keisuke Ikeda
 * @this {NextState}
 */
-var NextState = class {
+var NextState = class extends Object {
+	/**
+	* The parser whose method will be invoked. Set on each call to `next`.
+	*/
 	automaton = null;
+	/**
+	* The fallback state number returned when no method is configured (or as the initial value).
+	*/
 	nextState;
+	/**
+	* Cached reference to the resolved method (kept as `unknown` because lookup happens by name).
+	*/
 	method;
+	/**
+	* The name of the parser method to invoke, or null if only `nextState` should be returned.
+	*/
 	methodName;
 	/**
 	* Constructor.
+	* @constructor
+	* @param aNumber the fallback state number (or null)
+	* @param aString the parser method name to invoke (or null)
 	*/
 	constructor(aNumber, aString) {
+		super();
 		this.nextState = aNumber;
 		this.method = null;
 		this.methodName = aString;
 	}
 	/**
 	* Invokes the method corresponding to the input character and returns the resulting token number.
+	* @param anAutomaton the parser to invoke the method on
+	* @return the next state number
 	*/
 	next(anAutomaton) {
 		this.automaton = anAutomaton;
@@ -379,18 +453,38 @@ const SYNTAX_ERROR = "Syntax Error!";
 * @author Keisuke Ikeda
 * @this {Parser}
 */
-var Parser = class Parser {
+var Parser = class Parser extends Object {
+	/**
+	* Iterator over the input source characters.
+	*/
 	stream;
+	/**
+	* The most recently produced parse token (a value or sub-Cons).
+	*/
 	token;
+	/**
+	* The accumulator for the current literal being read (number, symbol, string).
+	*/
 	tokenString;
+	/**
+	* The state transition table: current state -> (input code point string -> NextState).
+	*/
 	states;
+	/**
+	* The current automaton state number.
+	*/
 	state;
+	/**
+	* The look-ahead buffer of characters (size `PEEKCOUNT + 1`).
+	*/
 	nexts;
 	/**
 	* Constructor.
+	* @constructor
 	* @param aString the string to parse
 	*/
 	constructor(aString) {
+		super();
 		this.stream = aString[Symbol.iterator]();
 		this.token = null;
 		this.tokenString = "";
@@ -403,12 +497,14 @@ var Parser = class Parser {
 	}
 	/**
 	* Returns whether this is the last element.
+	* @return true if there are no more characters to read
 	*/
 	atEnd() {
 		return this.peekChar() == null;
 	}
 	/**
 	* Concatenates the current character into the token string.
+	* @return null
 	*/
 	concatCharacter() {
 		this.tokenString = this.tokenString.concat(String(this.nexts[0]));
@@ -416,6 +512,8 @@ var Parser = class Parser {
 	}
 	/**
 	* Parses a single character of the input string.
+	* @param aCharacter the character to feed into the automaton; defaults to the next character
+	* @return the token produced so far (may be null if still accumulating)
 	*/
 	input(aCharacter = this.nextChar()) {
 		const inputs = this.states.get(this.state);
@@ -427,6 +525,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Returns the next character to be parsed from the input string.
+	* @return the next character, or null at end of input
 	*/
 	nextChar() {
 		let aCharacter = null;
@@ -446,6 +545,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Determines and returns the next token.
+	* @return the next parsed token
 	*/
 	nextToken() {
 		this.token = null;
@@ -460,18 +560,25 @@ var Parser = class Parser {
 	}
 	/**
 	* Instantiates and returns a NextState.
+	* @param aNumber the fallback state number (or null)
+	* @param aString the parser method name (or null)
+	* @return the new NextState
 	*/
 	nextState(aNumber, aString) {
 		return new NextState(aNumber, aString);
 	}
 	/**
 	* Parses the given string and returns the result.
+	* @param aString the source string
+	* @return the parsed value
 	*/
 	static parse(aString) {
 		return new Parser(aString).nextToken();
 	}
 	/**
 	* Returns the next character if one exists.
+	* @param aNumber 1-based offset into the look-ahead buffer
+	* @return the character at that offset, or null if not present
 	*/
 	peekChar(aNumber = 1) {
 		if (aNumber > this.nexts.length) throw new ParseError("Read Error!");
@@ -479,6 +586,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Concatenates characters; invoked from NextState.
+	* @return null
 	*/
 	concat() {
 		this.concatCharacter();
@@ -489,6 +597,7 @@ var Parser = class Parser {
 	* (`\n`, `\t`, `\r`, `\\`, `\"`) into their actual characters. Invoked from NextState
 	* inside a string literal after a backslash. Unknown escapes pass through as the
 	* literal character (e.g. `\x` becomes `x`).
+	* @return null
 	*/
 	escapeConcat() {
 		const c = String(this.nexts[0]);
@@ -504,6 +613,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Returns the token number for a Number-type (double-precision floating point: pseudo-Double); invoked from NextState.
+	* @return the next state number (3, or 0 when the literal is complete)
 	*/
 	doubleToken() {
 		this.concat();
@@ -515,6 +625,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Returns the token number for a Number-type (double-precision floating point: pseudo-Double); invoked from NextState.
+	* @return the next state number (5, or 0 when the literal is complete)
 	*/
 	doubleTokenAUX() {
 		this.concat();
@@ -526,6 +637,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Returns the token number for a Number-type (integer: pseudo-Integer); invoked from NextState.
+	* @return the next state number (2, or 0 when the literal is complete)
 	*/
 	integerToken() {
 		this.concat();
@@ -537,6 +649,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Converts the token into a list (Cons) and returns the token number for a list (Cons); invoked from NextState.
+	* @return 0
 	*/
 	parseList() {
 		this.skippingSpaces();
@@ -548,6 +661,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Helper that converts the token into a list (Cons); invoked from NextState.
+	* @return the parsed Cons (or its cdr in dotted-pair form)
 	*/
 	parseListAUX() {
 		this.skippingSpaces();
@@ -574,6 +688,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Recognizes a quote, wraps the token into a list (Cons), and returns the token number; invoked from NextState.
+	* @return 0
 	*/
 	quote() {
 		const anObject = new Cons(this.nextToken(), Cons.nil);
@@ -582,6 +697,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Returns the token number for a quote or for a 0-origin String-type (pseudo-Character); invoked from NextState.
+	* @return the next state number
 	*/
 	quoteOrChar() {
 		let aNumber = this.peekChar() === "\\" ? 3 : 2;
@@ -590,12 +706,14 @@ var Parser = class Parser {
 	}
 	/**
 	* Detects a right parenthesis (')', ']', '}') and returns the result; invoked from NextState.
+	* @return true when the next character is any right paren
 	*/
 	rightParen() {
 		return this.peekChar() === ")" || this.peekChar() === "]" || this.peekChar() === "}";
 	}
 	/**
 	* Returns the token number for a sign symbol ('+', '-'); invoked from NextState.
+	* @return the next state number (7, or 0 when the literal is complete)
 	*/
 	sign() {
 		this.concat();
@@ -607,6 +725,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Skips whitespace; invoked from NextState.
+	* @return null
 	*/
 	skippingSpaces() {
 		while (this.nexts[1] === String.fromCodePoint(9) || this.nexts[1] === String.fromCodePoint(10) || this.nexts[1] === String.fromCodePoint(11) || this.nexts[1] === String.fromCodePoint(12) || this.nexts[1] === String.fromCodePoint(13) || this.nexts[1] === String.fromCodePoint(32)) this.nextChar();
@@ -614,6 +733,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Returns the token number for an InterpretedSymbol; invoked from NextState.
+	* @return the next state number (8, or 0 when the literal is complete)
 	*/
 	symbolToken() {
 		this.concat();
@@ -625,6 +745,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Converts the token into a 0-origin String-type (pseudo-Character); invoked from NextState.
+	* @return null
 	*/
 	tokenToCharacter() {
 		this.token = this.tokenString.charAt(0);
@@ -632,6 +753,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Converts the token into a Number-type (double-precision floating point: pseudo-Double); invoked from NextState.
+	* @return null
 	*/
 	tokenToDouble() {
 		this.token = Number(this.tokenString);
@@ -639,6 +761,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Converts the token into a Number-type (double-precision floating point: pseudo-Double); invoked from NextState.
+	* @return null
 	*/
 	tokenToDoubleAUX() {
 		this.concat();
@@ -647,6 +770,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Converts the token into a Number-type (integer: pseudo-Integer); invoked from NextState.
+	* @return null
 	*/
 	tokenToInteger() {
 		if (this.tokenString[0] === "+") this.tokenString = this.tokenString.slice(1);
@@ -655,6 +779,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Converts the token into a String-type; invoked from NextState.
+	* @return null
 	*/
 	tokenToString() {
 		this.token = this.tokenString;
@@ -662,6 +787,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Converts the token into an InterpretedSymbol; invoked from NextState.
+	* @return null
 	*/
 	tokenToSymbol() {
 		this.token = InterpretedSymbol.of(this.tokenString);
@@ -670,6 +796,7 @@ var Parser = class Parser {
 	}
 	/**
 	* Builds the lookup table that maps character codes to their corresponding methods (tokens).
+	* @return null
 	*/
 	initializeStateTransitionTable() {
 		let aTable = /* @__PURE__ */ new Map();
@@ -720,6 +847,8 @@ var Parser = class Parser {
 		aTable = /* @__PURE__ */ new Map();
 		for (const index of IntStream.rangeClosed(9, 13)) aTable.set(String(index), this.nextState(0, "tokenToInteger"));
 		aTable.set(String(32), this.nextState(0, "tokenToInteger"));
+		aTable.set(String(43), this.nextState(8, "symbolToken"));
+		aTable.set(String(45), this.nextState(8, "symbolToken"));
 		aTable.set(String(46), this.nextState(3, "doubleToken"));
 		for (const index of IntStream.rangeClosed(48, 57)) aTable.set(String(index), this.nextState(2, "integerToken"));
 		aTable.set(String(69), this.nextState(4, "concat"));
@@ -823,9 +952,18 @@ var Parser = class Parser {
 * @author Keisuke Ikeda
 * @this {Cons}
 */
-var Cons = class Cons {
+var Cons = class Cons extends Object {
+	/**
+	* The shared empty-list sentinel. A Cons whose car and cdr are both itself, representing Lisp `nil`.
+	*/
 	static nil = new Cons();
+	/**
+	* The head element of this Cons cell.
+	*/
 	car;
+	/**
+	* The tail of this Cons cell (typically another Cons or nil).
+	*/
 	cdr;
 	/**
 	* Constructor.
@@ -834,6 +972,7 @@ var Cons = class Cons {
 	* @param cdr the cdr; defaults to nil when no argument is given.
 	*/
 	constructor(car = Cons.nil, cdr = Cons.nil) {
+		super();
 		this.car = car;
 		this.cdr = cdr;
 	}
@@ -1119,6 +1258,7 @@ const SIZE_DO_NOT_MATCH = "size do not match.";
 //#endregion
 //#region src/runtime/Applier/index.ts
 const SELECT_PRINT_FUNCTION_NOT_DEFINED = "selectPrintFunction is not defined";
+const toCodePoints = (s) => [...s];
 /**
 * Class that mimics Lisp's universal function Apply.
 * @class
@@ -1126,25 +1266,67 @@ const SELECT_PRINT_FUNCTION_NOT_DEFINED = "selectPrintFunction is not defined";
 * @author Keisuke Ikeda
 * @this {Applier}
 */
-var Applier = class Applier {
+var Applier = class Applier extends Object {
+	/**
+	* Dispatch map from a Lisp function name (InterpretedSymbol) to the name of the Applier method that implements it.
+	*/
 	static buildInFunctions = Applier.setup();
 	static #generateNumber = 0;
+	/**
+	* The environment (variable bindings) used while applying procedures.
+	*/
 	environment;
+	/**
+	* The stream manager used for I/O and spy output.
+	*/
 	streamManager;
+	/**
+	* The current recursion depth, used for spy indentation.
+	*/
 	depth;
-	constructor(aTable, aStreamManager, aNumber) {
+	/**
+	* Registered plugins forwarded back into Evaluator on recursive evaluation (e.g. `entrustEvaluator`).
+	*/
+	plugins;
+	/**
+	* Constructor.
+	* @constructor
+	* @param aTable the parent environment to extend
+	* @param aStreamManager the stream manager for I/O
+	* @param aNumber the initial recursion depth
+	* @param plugins the plugin chain to forward when re-entering the Evaluator
+	*/
+	constructor(aTable, aStreamManager, aNumber, plugins = []) {
+		super();
 		this.environment = new Table(aTable);
 		this.streamManager = aStreamManager;
 		this.depth = aNumber;
+		this.plugins = plugins;
 	}
+	/**
+	* Implementation of the Lisp `abs` function. Returns the absolute value of the given number.
+	* @param args the argument Cons containing the target number
+	* @return the absolute value
+	*/
 	abs(args) {
 		if (Cons.isNumber(args.car)) return Math.abs(args.car);
 		throw new EvalError(cannotApply("abs", args.car));
 	}
+	/**
+	* Implementation of the Lisp `+` / `add` function. Returns the sum of the given numbers.
+	* @param args the argument Cons containing the numbers to add
+	* @return the sum of the arguments
+	*/
 	add(args) {
 		if (Cons.isNumber(args.car)) return this.add_Number(args.car, args.cdr);
 		throw new EvalError(cannotApply("add", args.car));
 	}
+	/**
+	* Helper that accumulates the sum starting from an initial number and the remaining argument list.
+	* @param init the initial number
+	* @param args the remaining numbers to add
+	* @return the sum of init and all remaining numbers
+	*/
 	add_Number(init, args) {
 		let result = init;
 		let aCons = args;
@@ -1156,13 +1338,34 @@ var Applier = class Applier {
 		}
 		return result;
 	}
-	static apply(procedure, args, environment, aStreamManager, depth) {
-		return new Applier(environment, aStreamManager, depth).apply(procedure, args);
+	/**
+	* Static entry point that instantiates an Applier and applies the given procedure to the arguments.
+	* @param procedure the procedure to apply (a symbol or a lambda Cons)
+	* @param args the argument list
+	* @param environment the environment to use
+	* @param aStreamManager the stream manager for I/O
+	* @param depth the current recursion depth
+	* @param plugins the plugin chain to forward when re-entering the Evaluator
+	* @return the result of applying the procedure
+	*/
+	static apply(procedure, args, environment, aStreamManager, depth, plugins = []) {
+		return new Applier(environment, aStreamManager, depth, plugins).apply(procedure, args);
 	}
+	/**
+	* Applies the given procedure to the given arguments.
+	* @param procedure the procedure to apply (a symbol or a lambda Cons)
+	* @param args the argument list
+	* @return the result of applying the procedure
+	*/
 	apply(procedure, args) {
 		if (Cons.isSymbol(procedure)) return this.selectProcedure(procedure, args);
 		return this.entrustEvaluator(procedure, args);
 	}
+	/**
+	* Implementation of the Lisp `assoc` function. Looks up an association in an association list.
+	* @param args the argument Cons containing the key and the association list
+	* @return the matching pair, or nil if no match was found
+	*/
 	assoc(args) {
 		const target = args.car;
 		if (Cons.isNotCons(args.nth(2))) return Cons.nil;
@@ -1175,10 +1378,20 @@ var Applier = class Applier {
 		}
 		return Cons.nil;
 	}
+	/**
+	* Implementation of the Lisp `atom` predicate. Returns t if the argument is an atom, otherwise nil.
+	* @param args the argument Cons containing the value to test
+	* @return t if atom, nil otherwise
+	*/
 	atom_(args) {
 		if (Cons.isAtom(args.car)) return InterpretedSymbol.of("t");
 		return Cons.nil;
 	}
+	/**
+	* Binds the given parameter symbols to the corresponding argument values in this environment.
+	* @param parameter the parameter list (a Cons of symbols, possibly dotted)
+	* @param args the argument list to bind to the parameters
+	*/
 	binding(parameter, args) {
 		if (Cons.isNil(parameter)) return null;
 		let aCons = parameter;
@@ -1201,6 +1414,12 @@ var Applier = class Applier {
 		else if (Cons.isNotNil(aCons.cdr)) throw new ReferenceError("aList is not defined");
 		return null;
 	}
+	/**
+	* Invokes the built-in method associated with the given procedure symbol.
+	* @param procedure the symbol naming the built-in function
+	* @param args the argument list
+	* @return the result of the built-in function
+	*/
 	buildInFunction(procedure, args) {
 		if (this.isSpy(procedure)) {
 			this.spyPrint(this.streamManager.spyStream(procedure), new Cons(procedure, args).toString());
@@ -1217,34 +1436,80 @@ var Applier = class Applier {
 		}
 		return answer;
 	}
+	/**
+	* Implementation of the Lisp `car` function. Returns the car of the given Cons.
+	* @param args the argument Cons containing the target Cons
+	* @return the car of the target
+	*/
 	car(args) {
 		return args.car.car;
 	}
+	/**
+	* Implementation of the Lisp `cdr` function. Returns the cdr of the given Cons.
+	* @param args the argument Cons containing the target Cons
+	* @return the cdr of the target
+	*/
 	cdr(args) {
 		return args.car.cdr;
 	}
+	/**
+	* Implementation of the Lisp `characterp` predicate. Returns t if the argument is a single-character string.
+	* @param args the argument Cons containing the value to test
+	* @return t if a character, nil otherwise
+	*/
 	character_(args) {
 		if (Cons.isString(args.car) && args.car.length === 1) return InterpretedSymbol.of("t");
 		return Cons.nil;
 	}
+	/**
+	* Implementation of the Lisp `cons` function. Constructs a new Cons from the given car and cdr.
+	* @param args the argument Cons containing the car and cdr
+	* @return the newly constructed Cons
+	*/
 	cons(args) {
 		return new Cons(args.car, args.nth(2));
 	}
+	/**
+	* Implementation of the Lisp `consp` predicate. Returns t if the argument is a Cons, otherwise nil.
+	* @param args the argument Cons containing the value to test
+	* @return t if a Cons, nil otherwise
+	*/
 	cons_(args) {
 		if (Cons.isCons(args.car)) return InterpretedSymbol.of("t");
 		return Cons.nil;
 	}
+	/**
+	* Implementation of the Lisp `copy` function. Returns a deep clone of the given value.
+	* @param args the argument Cons containing the value to copy
+	* @return the cloned value
+	*/
 	copy(args) {
 		return Cons.cloneValue(args.car);
 	}
+	/**
+	* Implementation of the Lisp `cos` function. Returns the cosine of the given number.
+	* @param args the argument Cons containing the angle in radians
+	* @return the cosine of the argument
+	*/
 	cos(args) {
 		if (Cons.isNumber(args.car)) return Math.cos(args.car);
 		throw new ReferenceError(SELECT_PRINT_FUNCTION_NOT_DEFINED);
 	}
+	/**
+	* Implementation of the Lisp `/` / `divide` function. Returns the quotient of the given numbers.
+	* @param args the argument Cons containing the numbers to divide
+	* @return the quotient of the arguments
+	*/
 	divide(args) {
 		if (Cons.isNumber(args.car)) return this.divide_Number(args.car, args.cdr);
 		throw new EvalError(cannotApply("divide", args.car));
 	}
+	/**
+	* Helper that accumulates the quotient starting from an initial number and the remaining argument list.
+	* @param init the initial number (numerator)
+	* @param args the remaining numbers to divide by
+	* @return the quotient of init divided by all remaining numbers
+	*/
 	divide_Number(init, args) {
 		let result = init;
 		let aCons = args;
@@ -1256,6 +1521,12 @@ var Applier = class Applier {
 		}
 		return result;
 	}
+	/**
+	* Delegates evaluation of a lambda body to the Evaluator after binding its parameters.
+	* @param procedure the lambda Cons to apply
+	* @param args the argument list to bind to the lambda's parameters
+	* @return the result of evaluating the lambda body
+	*/
 	entrustEvaluator(procedure, args) {
 		let anObject = Cons.nil;
 		let aCons = procedure.cdr;
@@ -1263,14 +1534,24 @@ var Applier = class Applier {
 		aCons = aCons.cdr;
 		for (const each of aCons.loop()) {
 			if (each instanceof Table) break;
-			anObject = Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+			anObject = Evaluator.eval(each, this.environment, this.streamManager, this.depth, this.plugins);
 		}
 		return anObject;
 	}
+	/**
+	* Implementation of the Lisp `eq` predicate. Returns t when both arguments are identical (JS `===`).
+	* @param args the argument Cons containing the two values to compare
+	* @return t when identical, nil otherwise
+	*/
 	eq_(args) {
 		if (args.car === args.nth(2)) return InterpretedSymbol.of("t");
 		return Cons.nil;
 	}
+	/**
+	* Implementation of the Lisp `equal` / `=` predicate. Returns t when both arguments are structurally equal.
+	* @param args the argument Cons containing the two values to compare
+	* @return t when equal, nil otherwise
+	*/
 	equal_(args) {
 		const first = args.car;
 		const second = args.nth(2);
@@ -1281,10 +1562,20 @@ var Applier = class Applier {
 		}
 		return Cons.nil;
 	}
+	/**
+	* Implementation of the Lisp `exp` function. Returns e raised to the given power.
+	* @param args the argument Cons containing the exponent
+	* @return e raised to the given power
+	*/
 	exp(args) {
 		if (Cons.isNumber(args.car)) return Math.exp(args.car);
 		throw new ReferenceError(SELECT_PRINT_FUNCTION_NOT_DEFINED);
 	}
+	/**
+	* Implementation of the Lisp `format` function. Writes a formatted string to standard output.
+	* @param args the argument Cons containing the format string followed by its arguments
+	* @return nil
+	*/
 	format(args) {
 		if (!Cons.isString(args.car)) throw new EvalError(cannotApply("format", args.car));
 		const aCons = args.cdr;
@@ -1292,6 +1583,12 @@ var Applier = class Applier {
 		process.stdout.write(String(format));
 		return Cons.nil;
 	}
+	/**
+	* Helper that expands the given format string with the supplied arguments.
+	* @param format the format string containing directives such as `~a`, `~%`, and width specifiers
+	* @param aCons the argument list to interpolate into the directives
+	* @return the formatted string
+	*/
 	format_AUX(format, aCons) {
 		let theCons = aCons;
 		let index = 0;
@@ -1413,23 +1710,48 @@ var Applier = class Applier {
 		if (Cons.isNotNil(theCons)) throw new EvalError(SIZE_DO_NOT_MATCH);
 		return buffer;
 	}
+	/**
+	* Implementation of the Lisp `floatp` predicate. Returns t if the argument is a number representable as IEEE 32-bit float.
+	* @param args the argument Cons containing the value to test
+	* @return t if a float, nil otherwise
+	*/
 	float_(args) {
 		if (Cons.isNumber(args.car) && -34e37 <= args.car && args.car <= 34e37) return InterpretedSymbol.of("t");
 		return Cons.nil;
 	}
+	/**
+	* Implementation of the Lisp `gensym` function. Generates a fresh, unique symbol.
+	* @return a new, unique InterpretedSymbol
+	*/
 	gensym() {
 		const aSymbol = InterpretedSymbol.of("id" + String(Applier.#generateNumber));
 		Applier.incrementGenerateNumber();
 		return aSymbol;
 	}
+	/**
+	* Returns the appropriate stream for the given object.
+	* @param anObject the object used to select the stream
+	* @return the selected stream
+	*/
 	getStream(anObject) {
 		if (typeof anObject === "string") return process.out;
 		return this.streamManager.getStream();
 	}
+	/**
+	* Implementation of the Lisp `>` / `greaterThan` predicate. Returns t when arguments are in strictly decreasing order.
+	* @param args the argument Cons containing the numbers to compare
+	* @return t when each is greater than the next, nil otherwise
+	*/
 	greaterThan(args) {
 		if (Cons.isNumber(args.car)) return this.greaterThan_Number(args.car, args.cdr);
 		throw new EvalError(cannotApply(">", args.car));
 	}
+	/**
+	* Helper that checks `>` ordering starting from an initial number against the remaining argument list.
+	* @param init the initial number on the left side of the first comparison
+	* @param args the remaining numbers to compare against
+	* @return t when strictly decreasing, nil otherwise
+	*/
 	greaterThan_Number(init, args) {
 		let leftValue = init;
 		let aCons = args;
@@ -1444,10 +1766,21 @@ var Applier = class Applier {
 		}
 		return InterpretedSymbol.of("t");
 	}
+	/**
+	* Implementation of the Lisp `>=` / `greaterThanOrEqual` predicate. Returns t when arguments are in non-increasing order.
+	* @param args the argument Cons containing the numbers to compare
+	* @return t when each is greater than or equal to the next, nil otherwise
+	*/
 	greaterThanOrEqual(args) {
 		if (Cons.isNumber(args.car)) return this.greaterThanOrEqual_Number(args.car, args.cdr);
 		throw new EvalError(cannotApply(">=", args.car));
 	}
+	/**
+	* Helper that checks `>=` ordering starting from an initial number against the remaining argument list.
+	* @param init the initial number on the left side of the first comparison
+	* @param args the remaining numbers to compare against
+	* @return t when non-increasing, nil otherwise
+	*/
 	greaterThanOrEqual_Number(init, args) {
 		let leftValue = init;
 		let aCons = args;
@@ -1462,31 +1795,441 @@ var Applier = class Applier {
 		}
 		return InterpretedSymbol.of("t");
 	}
+	/**
+	* Increments the internal counter used by `gensym` to ensure uniqueness.
+	*/
 	static incrementGenerateNumber() {
 		Applier.#generateNumber++;
 		return null;
 	}
+	/**
+	* Returns a string of indentation used as a prefix for spy output, based on the current depth.
+	* @return the indentation string
+	*/
 	indent() {
 		let index = 0;
 		let aString = "";
 		while (index++ < this.depth) aString += "| ";
 		return aString;
 	}
+	/**
+	* Implementation of the Lisp `integerp` predicate. Returns t if the argument is an integer.
+	* @param args the argument Cons containing the value to test
+	* @return t if an integer, nil otherwise
+	*/
 	integer_(args) {
 		if (Cons.isNumber(args.car) && Number.isInteger(args.car)) return InterpretedSymbol.of("t");
 		return Cons.nil;
 	}
+	/**
+	* Implementation of the Lisp `evenp` predicate. Returns t if the argument is an even integer.
+	* @param args the argument Cons containing the value to test
+	* @return t if even, nil otherwise
+	*/
+	even_(args) {
+		if (Cons.isNumber(args.car) && Number.isInteger(args.car) && args.car % 2 === 0) return InterpretedSymbol.of("t");
+		return Cons.nil;
+	}
+	/**
+	* Implementation of the Lisp `oddp` predicate. Returns t if the argument is an odd integer.
+	* @param args the argument Cons containing the value to test
+	* @return t if odd, nil otherwise
+	*/
+	odd_(args) {
+		if (Cons.isNumber(args.car) && Number.isInteger(args.car) && args.car % 2 !== 0) return InterpretedSymbol.of("t");
+		return Cons.nil;
+	}
+	/**
+	* Implementation of the Lisp `zerop` predicate. Returns t if the argument equals zero.
+	* @param args the argument Cons containing the value to test
+	* @return t if zero, nil otherwise
+	*/
+	zero_(args) {
+		if (Cons.isNumber(args.car) && args.car === 0) return InterpretedSymbol.of("t");
+		return Cons.nil;
+	}
+	/**
+	* Implementation of the Lisp `plusp` predicate. Returns t if the argument is strictly positive.
+	* @param args the argument Cons containing the value to test
+	* @return t if positive, nil otherwise
+	*/
+	plus_(args) {
+		if (Cons.isNumber(args.car) && args.car > 0) return InterpretedSymbol.of("t");
+		return Cons.nil;
+	}
+	/**
+	* Implementation of the Lisp `minusp` predicate. Returns t if the argument is strictly negative.
+	* @param args the argument Cons containing the value to test
+	* @return t if negative, nil otherwise
+	*/
+	minus_(args) {
+		if (Cons.isNumber(args.car) && args.car < 0) return InterpretedSymbol.of("t");
+		return Cons.nil;
+	}
+	/**
+	* Implementation of the Lisp `1+` function. Returns the argument incremented by one.
+	* @param args the argument Cons containing the target number
+	* @return the argument plus one
+	*/
+	oneplus(args) {
+		if (Cons.isNumber(args.car)) return args.car + 1;
+		throw new EvalError(cannotApply("1+", args.car));
+	}
+	/**
+	* Implementation of the Lisp `1-` function. Returns the argument decremented by one.
+	* @param args the argument Cons containing the target number
+	* @return the argument minus one
+	*/
+	oneminus(args) {
+		if (Cons.isNumber(args.car)) return args.car - 1;
+		throw new EvalError(cannotApply("1-", args.car));
+	}
+	/**
+	* Implementation of the Lisp `expt` function. Returns the base raised to the exponent.
+	* @param args the argument Cons containing the base followed by the exponent
+	* @return base raised to the exponent
+	*/
+	expt(args) {
+		const base = args.car;
+		const exponent = args.nth(2);
+		if (Cons.isNumber(base) && Cons.isNumber(exponent)) return Math.pow(base, exponent);
+		throw new EvalError(cannotApply("expt", base));
+	}
+	/**
+	* Implementation of the Lisp `truncate` function. Returns the integer part of the given number.
+	* @param args the argument Cons containing the target number
+	* @return the truncated integer
+	*/
+	truncate(args) {
+		if (Cons.isNumber(args.car)) return Math.trunc(args.car);
+		throw new EvalError(cannotApply("truncate", args.car));
+	}
+	/**
+	* Implementation of the Lisp `floor` function. Returns the largest integer not greater than the given number.
+	* @param args the argument Cons containing the target number
+	* @return the floor of the argument
+	*/
+	floor(args) {
+		if (Cons.isNumber(args.car)) return Math.floor(args.car);
+		throw new EvalError(cannotApply("floor", args.car));
+	}
+	/**
+	* Implementation of the Lisp `ceiling` function. Returns the smallest integer not less than the given number.
+	* @param args the argument Cons containing the target number
+	* @return the ceiling of the argument
+	*/
+	ceiling(args) {
+		if (Cons.isNumber(args.car)) return Math.ceil(args.car);
+		throw new EvalError(cannotApply("ceiling", args.car));
+	}
+	/**
+	* Implementation of the Lisp `min` function. Returns the minimum of the given numbers.
+	* @param args the argument Cons containing the numbers to compare
+	* @return the smallest number
+	*/
+	min(args) {
+		const values = [];
+		for (const each of args.loop()) {
+			if (!Cons.isNumber(each)) throw new EvalError(cannotApply("min", each));
+			values.push(each);
+		}
+		if (values.length === 0) throw new EvalError("min requires at least one argument");
+		return Math.min(...values);
+	}
+	/**
+	* Implementation of the Lisp `max` function. Returns the maximum of the given numbers.
+	* @param args the argument Cons containing the numbers to compare
+	* @return the largest number
+	*/
+	max(args) {
+		const values = [];
+		for (const each of args.loop()) {
+			if (!Cons.isNumber(each)) throw new EvalError(cannotApply("max", each));
+			values.push(each);
+		}
+		if (values.length === 0) throw new EvalError("max requires at least one argument");
+		return Math.max(...values);
+	}
+	/**
+	* Implementation of the Lisp `length` function. Returns the length of a list or string.
+	* @param args the argument Cons containing the target sequence
+	* @return the length of the sequence
+	*/
+	length(args) {
+		const target = args.car;
+		if (Cons.isString(target)) return toCodePoints(target).length;
+		if (Cons.isCons(target)) return target.length();
+		if (Cons.isNil(target)) return 0;
+		throw new EvalError(cannotApply("length", target));
+	}
+	/**
+	* Implementation of the Lisp `string-upcase` function. Returns the upper-cased form of the given string.
+	* @param args the argument Cons containing the target string
+	* @return the upper-cased string
+	*/
+	stringUpcase(args) {
+		if (Cons.isString(args.car)) return args.car.toUpperCase();
+		throw new EvalError(cannotApply("string-upcase", args.car));
+	}
+	/**
+	* Implementation of the Lisp `string-downcase` function. Returns the lower-cased form of the given string.
+	* @param args the argument Cons containing the target string
+	* @return the lower-cased string
+	*/
+	stringDowncase(args) {
+		if (Cons.isString(args.car)) return args.car.toLowerCase();
+		throw new EvalError(cannotApply("string-downcase", args.car));
+	}
+	/**
+	* Implementation of the Lisp `string-trim` function. Returns the given string with surrounding whitespace removed.
+	* @param args the argument Cons containing the target string
+	* @return the trimmed string
+	*/
+	stringTrim(args) {
+		if (Cons.isString(args.car)) return args.car.trim();
+		throw new EvalError(cannotApply("string-trim", args.car));
+	}
+	/**
+	* Implementation of the Lisp `substring` function. Returns a portion of the given string between start and end (in code points).
+	* @param args the argument Cons containing the target string, start index, and optional end index
+	* @return the requested substring
+	*/
+	substring(args) {
+		const target = args.car;
+		const start = args.nth(2);
+		const end = args.nth(3);
+		if (!Cons.isString(target)) throw new EvalError(cannotApply("substring", target));
+		if (!Cons.isNumber(start)) throw new EvalError(cannotApply("substring", start));
+		const chars = toCodePoints(target);
+		if (Cons.isNil(end)) return chars.slice(start).join("");
+		if (!Cons.isNumber(end)) throw new EvalError(cannotApply("substring", end));
+		return chars.slice(start, end).join("");
+	}
+	/**
+	* Implementation of the Lisp `concatenate` function. Returns the concatenation of all the given strings.
+	* @param args the argument Cons containing the strings to concatenate
+	* @return the concatenated string
+	*/
+	concatenate(args) {
+		let result = "";
+		for (const each of args.loop()) {
+			if (!Cons.isString(each)) throw new EvalError(cannotApply("concatenate", each));
+			result += each;
+		}
+		return result;
+	}
+	/**
+	* Implementation of the Lisp `elt` function. Returns the element at the given index of a string or list.
+	* @param args the argument Cons containing the target sequence and the index
+	* @return the element at the given index
+	*/
+	elt(args) {
+		const target = args.car;
+		const index = args.nth(2);
+		if (!Cons.isNumber(index)) throw new EvalError(cannotApply("elt", index));
+		if (Cons.isString(target)) {
+			const chars = toCodePoints(target);
+			if (index < 0 || index >= chars.length) throw new EvalError(`elt: index ${String(index)} out of range`);
+			return chars[index];
+		}
+		if (Cons.isCons(target)) {
+			if (index < 0 || index >= target.length()) throw new EvalError(`elt: index ${String(index)} out of range`);
+			return target.nth(index + 1);
+		}
+		throw new EvalError(cannotApply("elt", target));
+	}
+	/**
+	* Implementation of the Lisp `subseq` function. Returns a subsequence of a string or list between start and end.
+	* @param args the argument Cons containing the target sequence, start index, and optional end index
+	* @return the requested subsequence
+	*/
+	subseq(args) {
+		const target = args.car;
+		const start = args.nth(2);
+		const end = args.nth(3);
+		if (!Cons.isNumber(start)) throw new EvalError(cannotApply("subseq", start));
+		if (Cons.isString(target)) {
+			const chars = toCodePoints(target);
+			if (Cons.isNil(end)) return chars.slice(start).join("");
+			if (!Cons.isNumber(end)) throw new EvalError(cannotApply("subseq", end));
+			return chars.slice(start, end).join("");
+		}
+		if (Cons.isCons(target)) {
+			const stop = Cons.isNil(end) ? target.length() : end;
+			if (!Cons.isNumber(stop)) throw new EvalError(cannotApply("subseq", end));
+			let result = Cons.nil;
+			for (let i = stop - 1; i >= start; i--) result = new Cons(target.nth(i + 1), result);
+			return result;
+		}
+		throw new EvalError(cannotApply("subseq", target));
+	}
+	/**
+	* Implementation of the Lisp `count` function. Counts the occurrences of an item within a string or list.
+	* @param args the argument Cons containing the item and the target sequence
+	* @return the number of occurrences
+	*/
+	count(args) {
+		const item = args.car;
+		const target = args.nth(2);
+		let n = 0;
+		if (Cons.isString(target)) {
+			if (!Cons.isString(item) || item.length !== 1) return 0;
+			for (const ch of target) if (ch === item) n++;
+			return n;
+		}
+		if (Cons.isCons(target) || Cons.isNil(target)) {
+			const list = Cons.isNil(target) ? Cons.nil : target;
+			if (Cons.isCons(list)) {
+				for (const each of list.loop()) if (each === item) n++;
+			}
+			return n;
+		}
+		throw new EvalError(cannotApply("count", target));
+	}
+	/**
+	* Implementation of the Lisp `reduce` function. Combines the elements of a list using a binary procedure.
+	* @param args the argument Cons containing the procedure, the list, and an optional initial value
+	* @return the result of folding the procedure over the list
+	*/
+	reduce(args) {
+		const procedure = args.car;
+		const list = args.nth(2);
+		const hasInit = args.length() >= 3;
+		const init = args.nth(3);
+		if (Cons.isNil(list)) {
+			if (hasInit) return init;
+			return Applier.apply(procedure, Cons.nil, this.environment, this.streamManager, this.depth);
+		}
+		if (!Cons.isCons(list)) throw new EvalError(cannotApply("reduce", list));
+		const iter = list.loop();
+		let acc;
+		if (hasInit) acc = init;
+		else {
+			if (!iter.hasNext()) return Applier.apply(procedure, Cons.nil, this.environment, this.streamManager, this.depth);
+			acc = iter.next();
+		}
+		while (iter.hasNext()) {
+			const next = iter.next();
+			acc = Applier.apply(procedure, new Cons(acc, new Cons(next, Cons.nil)), this.environment, this.streamManager, this.depth);
+		}
+		return acc;
+	}
+	/**
+	* Implementation of the Lisp `every` function. Returns t when the predicate holds for every element of the list.
+	* @param args the argument Cons containing the predicate and the list
+	* @return t when the predicate holds for every element, nil otherwise
+	*/
+	every(args) {
+		const procedure = args.car;
+		const list = args.nth(2);
+		if (Cons.isNil(list)) return InterpretedSymbol.of("t");
+		if (!Cons.isCons(list)) throw new EvalError(cannotApply("every", list));
+		for (const each of list.loop()) {
+			const result = Applier.apply(procedure, new Cons(each, Cons.nil), this.environment, this.streamManager, this.depth);
+			if (Cons.isNil(result)) return Cons.nil;
+		}
+		return InterpretedSymbol.of("t");
+	}
+	/**
+	* Implementation of the Lisp `some` function. Returns the first non-nil predicate result, or nil if all are nil.
+	* @param args the argument Cons containing the predicate and the list
+	* @return the first non-nil result, or nil
+	*/
+	some(args) {
+		const procedure = args.car;
+		const list = args.nth(2);
+		if (Cons.isNil(list)) return Cons.nil;
+		if (!Cons.isCons(list)) throw new EvalError(cannotApply("some", list));
+		for (const each of list.loop()) {
+			const result = Applier.apply(procedure, new Cons(each, Cons.nil), this.environment, this.streamManager, this.depth);
+			if (Cons.isNotNil(result)) return result;
+		}
+		return Cons.nil;
+	}
+	/**
+	* Implementation of the Lisp `find` function. Returns the first element of the list that matches the given item.
+	* @param args the argument Cons containing the item and the list
+	* @return the matching element, or nil if none found
+	*/
+	find(args) {
+		const item = args.car;
+		const list = args.nth(2);
+		if (Cons.isNil(list)) return Cons.nil;
+		if (!Cons.isCons(list)) throw new EvalError(cannotApply("find", list));
+		for (const each of list.loop()) if (this.eq_(new Cons(item, new Cons(each, Cons.nil))) === InterpretedSymbol.of("t")) return each;
+		return Cons.nil;
+	}
+	/**
+	* Implementation of the Lisp `mapcan` function. Applies the procedure to each element and concatenates the resulting lists.
+	* @param args the argument Cons containing the procedure and the list
+	* @return the concatenation of the per-element results
+	*/
+	mapcan(args) {
+		const procedure = args.car;
+		const list = args.nth(2);
+		if (Cons.isNil(list)) return Cons.nil;
+		if (!Cons.isCons(list)) throw new EvalError(cannotApply("mapcan", list));
+		const collected = [];
+		for (const each of list.loop()) {
+			const part = Applier.apply(procedure, new Cons(each, Cons.nil), this.environment, this.streamManager, this.depth);
+			if (Cons.isCons(part)) for (const x of part.loop()) collected.push(x);
+		}
+		let result = Cons.nil;
+		for (let i = collected.length - 1; i >= 0; i--) result = new Cons(collected[i], result);
+		return result;
+	}
+	/**
+	* Implementation of the Lisp `sort` function. Returns a new list sorted by the given comparison predicate.
+	* @param args the argument Cons containing the list and the comparison predicate
+	* @return the sorted list
+	*/
+	sort(args) {
+		const list = args.car;
+		const procedure = args.nth(2);
+		if (Cons.isNil(list)) return Cons.nil;
+		if (!Cons.isCons(list)) throw new EvalError(cannotApply("sort", list));
+		const items = [];
+		for (const each of list.loop()) items.push(each);
+		items.sort((a, b) => {
+			const result = Applier.apply(procedure, new Cons(a, new Cons(b, Cons.nil)), this.environment, this.streamManager, this.depth);
+			return Cons.isNil(result) ? 1 : -1;
+		});
+		let result = Cons.nil;
+		for (let i = items.length - 1; i >= 0; i--) result = new Cons(items[i], result);
+		return result;
+	}
+	/**
+	* Returns whether the given symbol is currently being spied on.
+	* @param aSymbol the symbol to check
+	* @return true if spied on, false otherwise
+	*/
 	isSpy(aSymbol) {
 		return this.streamManager.isSpy(aSymbol);
 	}
+	/**
+	* Implementation of the Lisp `last` function. Returns the last cell of the given list.
+	* @param args the argument Cons containing the target list
+	* @return the last cell of the list
+	*/
 	last(args) {
 		if (Cons.isNotCons(args)) return Cons.nil;
 		return args.car.last();
 	}
+	/**
+	* Implementation of the Lisp `<` / `lessThan` predicate. Returns t when arguments are in strictly increasing order.
+	* @param args the argument Cons containing the numbers to compare
+	* @return t when each is less than the next, nil otherwise
+	*/
 	lessThan(args) {
 		if (Cons.isNumber(args.car)) return this.lessThan_Number(args.car, args.cdr);
 		throw new EvalError(cannotApply("<", args.car));
 	}
+	/**
+	* Helper that checks `<` ordering starting from an initial number against the remaining argument list.
+	* @param init the initial number on the left side of the first comparison
+	* @param args the remaining numbers to compare against
+	* @return t when strictly increasing, nil otherwise
+	*/
 	lessThan_Number(init, args) {
 		let leftValue = init;
 		let aCons = args;
@@ -1501,10 +2244,21 @@ var Applier = class Applier {
 		}
 		return InterpretedSymbol.of("t");
 	}
+	/**
+	* Implementation of the Lisp `<=` / `lessThanOrEqual` predicate. Returns t when arguments are in non-decreasing order.
+	* @param args the argument Cons containing the numbers to compare
+	* @return t when each is less than or equal to the next, nil otherwise
+	*/
 	lessThanOrEqual(args) {
 		if (Cons.isNumber(args.car)) return this.lessThanOrEqual_Number(args.car, args.cdr);
 		throw new EvalError(cannotApply("<=", args.car));
 	}
+	/**
+	* Helper that checks `<=` ordering starting from an initial number against the remaining argument list.
+	* @param init the initial number on the left side of the first comparison
+	* @param args the remaining numbers to compare against
+	* @return t when non-decreasing, nil otherwise
+	*/
 	lessThanOrEqual_Number(init, args) {
 		let leftValue = init;
 		let aCons = args;
@@ -1519,14 +2273,29 @@ var Applier = class Applier {
 		}
 		return InterpretedSymbol.of("t");
 	}
+	/**
+	* Implementation of the Lisp `list` function. Returns a list of the given arguments.
+	* @param args the argument list
+	* @return a Cons list of the arguments
+	*/
 	list(args) {
 		if (Cons.isNil(args)) return Cons.nil;
 		return new Cons(args.car, this.list(args.cdr));
 	}
+	/**
+	* Implementation of the Lisp `listp` predicate. Returns t if the argument is a list (Cons or nil).
+	* @param args the argument Cons containing the value to test
+	* @return t if a list, nil otherwise
+	*/
 	list_(args) {
 		if (Cons.isList(args.car)) return InterpretedSymbol.of("t");
 		return Cons.nil;
 	}
+	/**
+	* Implementation of the Lisp `mapcar` function. Applies the procedure to each tuple of corresponding elements.
+	* @param args the argument Cons containing the procedure followed by one or more lists
+	* @return the list of results
+	*/
 	mapcar(args) {
 		const aCons = new Cons(Cons.nil, Cons.nil);
 		const procedure = args.car;
@@ -1550,6 +2319,11 @@ var Applier = class Applier {
 		}
 		return aCons.cdr;
 	}
+	/**
+	* Implementation of the Lisp `member` function. Returns the sublist whose car matches the given item.
+	* @param args the argument Cons containing the item, the list, and an optional comparator symbol
+	* @return the matching sublist, or nil if not found
+	*/
 	member(args) {
 		let aSymbol = InterpretedSymbol.of("equal?");
 		if (Cons.isNotNil(args.nth(3))) aSymbol = args.nth(3);
@@ -1565,14 +2339,30 @@ var Applier = class Applier {
 		}
 		return Cons.nil;
 	}
+	/**
+	* Implementation of the Lisp `memq` predicate. Returns t when `member` finds a match, nil otherwise.
+	* @param args the argument Cons forwarded to `member`
+	* @return t when found, nil otherwise
+	*/
 	memq(args) {
 		if (this.member(args) === Cons.nil) return Cons.nil;
 		return InterpretedSymbol.of("t");
 	}
+	/**
+	* Implementation of the Lisp `mod` / `//` function. Returns the remainder of dividing the arguments in sequence.
+	* @param args the argument Cons containing the numbers
+	* @return the modulo result
+	*/
 	mod(args) {
 		if (Cons.isNumber(args.car)) return this.mod_Number(args.car, args.cdr);
 		throw new EvalError(cannotApply("mod", args.car));
 	}
+	/**
+	* Helper that accumulates the modulo starting from an initial number and the remaining argument list.
+	* @param init the initial number
+	* @param args the remaining numbers to mod by
+	* @return the remainder after taking modulo with each of the remaining numbers
+	*/
 	mod_Number(init, args) {
 		let result = init;
 		let aCons = args;
@@ -1584,10 +2374,21 @@ var Applier = class Applier {
 		}
 		return result;
 	}
+	/**
+	* Implementation of the Lisp `*` / `multiply` function. Returns the product of the given numbers.
+	* @param args the argument Cons containing the numbers to multiply
+	* @return the product of the arguments
+	*/
 	multiply(args) {
 		if (Cons.isNumber(args.car)) return this.multiply_Number(args.car, args.cdr);
 		throw new EvalError(cannotApply("multiply", args.car));
 	}
+	/**
+	* Helper that accumulates the product starting from an initial number and the remaining argument list.
+	* @param init the initial number
+	* @param args the remaining numbers to multiply
+	* @return the product of init and all remaining numbers
+	*/
 	multiply_Number(init, args) {
 		let result = init;
 		let aCons = args;
@@ -1599,49 +2400,105 @@ var Applier = class Applier {
 		}
 		return result;
 	}
+	/**
+	* Implementation of the Lisp `napier` function. Returns Napier's constant (e).
+	* @return Math.E
+	*/
 	napier() {
 		return Math.E;
 	}
+	/**
+	* Implementation of the Lisp `neq` / `~~` predicate. The negation of `eq`.
+	* @param args the argument Cons forwarded to `eq_`
+	* @return nil when eq, t otherwise
+	*/
 	neq(args) {
 		if (this.eq_(args) === InterpretedSymbol.of("t")) return Cons.nil;
 		return InterpretedSymbol.of("t");
 	}
+	/**
+	* Implementation of the Lisp `nequal` / `~=` predicate. The negation of `equal`.
+	* @param args the argument Cons forwarded to `equal_`
+	* @return nil when equal, t otherwise
+	*/
 	nequal(args) {
 		if (this.equal_(args) === InterpretedSymbol.of("t")) return Cons.nil;
 		return InterpretedSymbol.of("t");
 	}
+	/**
+	* Implementation of the Lisp `nth` function. Returns the nth element of a list.
+	* @param args the argument Cons containing the index and the list
+	* @return the element at the given index
+	*/
 	nth(args) {
 		if (!Number.isInteger(args.car)) return Cons.nil;
 		const index = args.car;
 		return args.nth(2).nth(index);
 	}
+	/**
+	* Implementation of the Lisp `null` predicate. Returns t if the argument is nil, otherwise nil.
+	* @param args the argument Cons containing the value to test
+	* @return t if nil, nil otherwise
+	*/
 	null_(args) {
 		if (Cons.isNil(args.car)) return InterpretedSymbol.of("t");
 		return Cons.nil;
 	}
+	/**
+	* Implementation of the Lisp `numberp` / `doublep` predicate. Returns t if the argument is a number.
+	* @param args the argument Cons containing the value to test
+	* @return t if a number, nil otherwise
+	*/
 	number_(args) {
 		if (Cons.isNumber(args.car)) return InterpretedSymbol.of("t");
 		return Cons.nil;
 	}
+	/**
+	* Implementation of the Lisp `pi` function. Returns the mathematical constant pi.
+	* @return Math.PI
+	*/
 	pi() {
 		return Math.PI;
 	}
+	/**
+	* Implementation of the Lisp `random` function. Returns a pseudo-random number in [0, 1).
+	* @return a random number in [0, 1)
+	*/
 	random() {
 		return Math.random();
 	}
+	/**
+	* Implementation of the Lisp `round` function. Returns the given number rounded to the nearest integer.
+	* @param args the argument Cons containing the target number
+	* @return the rounded integer
+	*/
 	round(args) {
 		if (Cons.isNumber(args.car)) return Math.round(args.car);
 		throw new ReferenceError(SELECT_PRINT_FUNCTION_NOT_DEFINED);
 	}
+	/**
+	* Dispatches the call to either a built-in function or a user-defined function based on the symbol.
+	* @param procedure the symbol naming the function
+	* @param args the argument list
+	* @return the result of the dispatched function
+	*/
 	selectProcedure(procedure, args) {
 		if (Applier.buildInFunctions.has(procedure)) return this.buildInFunction(procedure, args);
 		if (this.environment.has(procedure)) return this.userFunction(procedure, args);
 		throw new EvalError(noProcedure(procedure));
 	}
+	/**
+	* Sets the current recursion depth.
+	* @param aNumber the new depth value
+	*/
 	setDepth(aNumber) {
 		this.depth = aNumber;
 		return null;
 	}
+	/**
+	* Builds and returns the Lisp-name to method-name dispatch map.
+	* @return a Map associating each Lisp function name (as an InterpretedSymbol) with the corresponding Applier method name
+	*/
 	static setup() {
 		try {
 			return new Map([
@@ -1655,22 +2512,36 @@ var Applier = class Applier {
 				["cons", "cons"],
 				["consp", "cons_"],
 				["copy", "copy"],
+				["ceiling", "ceiling"],
 				["cos", "cos"],
 				["floatp", "float_"],
+				["floor", "floor"],
 				["divide", "divide"],
 				["doublep", "number_"],
 				["eq", "eq_"],
 				["equal", "equal_"],
+				["evenp", "even_"],
+				["every", "every"],
 				["exp", "exp"],
+				["expt", "expt"],
+				["find", "find"],
 				["format", "format"],
 				["gensym", "gensym"],
 				["integerp", "integer_"],
+				["concatenate", "concatenate"],
+				["count", "count"],
+				["elt", "elt"],
 				["last", "last"],
+				["length", "length"],
 				["list", "list"],
 				["listp", "list_"],
+				["mapcan", "mapcan"],
 				["mapcar", "mapcar"],
+				["max", "max"],
 				["member", "member"],
 				["memq", "memq"],
+				["min", "min"],
+				["minusp", "minus_"],
 				["mod", "mod"],
 				["multiply", "multiply"],
 				["napier", "napier"],
@@ -1679,15 +2550,29 @@ var Applier = class Applier {
 				["nth", "nth"],
 				["null", "null_"],
 				["numberp", "number_"],
+				["oddp", "odd_"],
 				["pi", "pi"],
+				["plusp", "plus_"],
 				["random", "random"],
+				["reduce", "reduce"],
 				["round", "round"],
 				["sin", "sin"],
+				["some", "some"],
+				["sort", "sort"],
 				["sqrt", "sqrt"],
-				["subtract", "subtract"],
+				["string-downcase", "stringDowncase"],
+				["string-trim", "stringTrim"],
+				["string-upcase", "stringUpcase"],
 				["stringp", "string_"],
+				["subseq", "subseq"],
+				["substring", "substring"],
+				["subtract", "subtract"],
 				["symbolp", "symbol_"],
 				["tan", "tan"],
+				["truncate", "truncate"],
+				["zerop", "zero_"],
+				["1+", "oneplus"],
+				["1-", "oneminus"],
 				["+", "add"],
 				["-", "subtract"],
 				["*", "multiply"],
@@ -1706,26 +2591,57 @@ var Applier = class Applier {
 			throw new Error("NullPointerException (Applier, initialize)");
 		}
 	}
+	/**
+	* Implementation of the Lisp `sin` function. Returns the sine of the given number.
+	* @param args the argument Cons containing the angle in radians
+	* @return the sine of the argument
+	*/
 	sin(args) {
 		if (Cons.isNumber(args.car)) return Math.sin(args.car);
 		throw new ReferenceError(SELECT_PRINT_FUNCTION_NOT_DEFINED);
 	}
+	/**
+	* Writes a single line of spy output (with indentation) to the given stream.
+	* @param aStream the stream to write to, or null/string to fall back to process.stdout
+	* @param line the line to write
+	*/
 	spyPrint(aStream, line) {
 		(aStream != null && typeof aStream === "object" && "write" in aStream ? aStream : process.stdout).write(this.indent() + line + "\n");
 		return null;
 	}
+	/**
+	* Implementation of the Lisp `sqrt` function. Returns the square root of the given number.
+	* @param args the argument Cons containing the target number
+	* @return the square root of the argument
+	*/
 	sqrt(args) {
 		if (Cons.isNumber(args.car)) return Math.sqrt(args.car);
 		throw new ReferenceError(SELECT_PRINT_FUNCTION_NOT_DEFINED);
 	}
+	/**
+	* Implementation of the Lisp `stringp` predicate. Returns t if the argument is a string.
+	* @param args the argument Cons containing the value to test
+	* @return t if a string, nil otherwise
+	*/
 	string_(args) {
 		if (Cons.isString(args.car)) return InterpretedSymbol.of("t");
 		return Cons.nil;
 	}
+	/**
+	* Implementation of the Lisp `-` / `subtract` function. Returns the difference of the given numbers.
+	* @param args the argument Cons containing the numbers to subtract
+	* @return the difference of the arguments
+	*/
 	subtract(args) {
 		if (Cons.isNumber(args.car)) return this.subtract_Number(args.car, args.cdr);
 		throw new EvalError(cannotApply("subtract", args.car));
 	}
+	/**
+	* Helper that accumulates the difference starting from an initial number and the remaining argument list.
+	* @param init the initial number
+	* @param args the remaining numbers to subtract
+	* @return init with all remaining numbers subtracted
+	*/
 	subtract_Number(init, args) {
 		let result = init;
 		let aCons = args;
@@ -1737,14 +2653,30 @@ var Applier = class Applier {
 		}
 		return result;
 	}
+	/**
+	* Implementation of the Lisp `symbolp` predicate. Returns t if the argument is an interpreted symbol.
+	* @param args the argument Cons containing the value to test
+	* @return t if a symbol, nil otherwise
+	*/
 	symbol_(args) {
 		if (Cons.isSymbol(args.car)) return InterpretedSymbol.of("t");
 		return Cons.nil;
 	}
+	/**
+	* Implementation of the Lisp `tan` function. Returns the tangent of the given number.
+	* @param args the argument Cons containing the angle in radians
+	* @return the tangent of the argument
+	*/
 	tan(args) {
 		if (Cons.isNumber(args.car)) return Math.tan(args.car);
 		throw new ReferenceError(SELECT_PRINT_FUNCTION_NOT_DEFINED);
 	}
+	/**
+	* Invokes a user-defined function (lambda) bound in the environment under the given symbol.
+	* @param procedure the symbol naming the user function
+	* @param args the argument list
+	* @return the result of evaluating the user function
+	*/
 	userFunction(procedure, args) {
 		if (this.isSpy(procedure)) {
 			this.spyPrint(this.streamManager.spyStream(procedure), new Cons(procedure, args).toString());
@@ -1782,21 +2714,42 @@ var ExitError = class extends Error {
 //#region src/runtime/StreamManager/index.ts
 /**
 * @class
-* @classdesc
+* @classdesc Manages output streams (stdout / stderr / spy / trace) used by the interpreter.
 * @author Keisuke Ikeda
 * @this {StreamManager}
 */
-var StreamManager = class {
+var StreamManager = class extends Object {
+	/**
+	* Whether tracing is currently enabled.
+	*/
 	isTrace = false;
+	/**
+	* Map from a named stream key (e.g. "default", "stdout", "stderr") to a WritableStream.
+	*/
 	streamTable;
+	/**
+	* Map from a spied symbol to the stream key used for that symbol's output.
+	*/
 	spyTable;
+	/**
+	* The stream that receives trace output while tracing is on.
+	*/
 	traceStream;
+	/**
+	* Constructor.
+	* @constructor
+	*/
 	constructor() {
+		super();
 		this.streamTable = /* @__PURE__ */ new Map();
 		this.spyTable = /* @__PURE__ */ new Map();
 		this.traceStream = null;
 		this.initialize();
 	}
+	/**
+	* Returns the currently selected output stream (trace stream when tracing, otherwise the default).
+	* @return the active stream, or null when none is available
+	*/
 	getStream() {
 		let aPrintStream = null;
 		if (this.isTrace) return this.traceStream();
@@ -1806,6 +2759,7 @@ var StreamManager = class {
 	}
 	/**
 	* Initializes the instance variables.
+	* @return null
 	*/
 	initialize() {
 		this.streamTable.set("default", process.stdout);
@@ -1813,42 +2767,85 @@ var StreamManager = class {
 		this.streamTable.set("stderr", process.stderr);
 		return null;
 	}
+	/**
+	* Returns whether the given symbol is being spied (or whether tracing is on, in which case every symbol is "spied").
+	* @param aSymbol the symbol to check, or null
+	* @return true if the symbol is spied or tracing is on
+	*/
 	isSpy(aSymbol) {
 		if (this.isTrace) return true;
 		if (aSymbol != null && this.spyTable_().has(aSymbol)) return true;
 		return false;
 	}
+	/**
+	* Removes the given symbol from the spy table.
+	* @param aSymbol the symbol to stop spying
+	* @return null
+	*/
 	noSpy(aSymbol) {
 		if (this.spyTable_().has(aSymbol)) this.spyTable_().delete(aSymbol);
 		return null;
 	}
+	/**
+	* Turns tracing off and clears the spy table.
+	* @return null
+	*/
 	noTrace() {
 		this.setIsTrace(false);
 		this.spyTable.clear();
 		return null;
 	}
+	/**
+	* Sets the tracing flag.
+	* @param aBoolean the new value for the tracing flag
+	* @return null
+	*/
 	setIsTrace(aBoolean) {
 		this.isTrace = aBoolean;
 		return null;
 	}
+	/**
+	* Sets the trace output stream.
+	* @param aStream the stream to send trace output to
+	* @return null
+	*/
 	setTraceStream(aStream) {
 		this.traceStream = aStream;
 		return null;
 	}
+	/**
+	* Registers the given symbol as spied with the given stream key.
+	* @param aSymbol the symbol to spy on
+	* @param aString the stream key (e.g. "default")
+	* @return null
+	*/
 	spy(aSymbol, aString) {
 		if (this.getStream() != null) this.spyTable_().set(aSymbol, aString);
 		return null;
 	}
+	/**
+	* Returns the stream (or stream-key string) used for the given symbol's spy output.
+	* @param aSymbol the symbol whose spy stream is requested, or null
+	* @return the trace stream, the registered key string, or throws if none is found
+	*/
 	spyStream(aSymbol) {
 		if (this.isTrace) return this.traceStream;
 		if (aSymbol != null && this.spyTable_().has(aSymbol)) return this.spyTable_().get(aSymbol);
 		throw new Error("Stream is not found.");
 	}
+	/**
+	* Returns a copy of the spy table (defensive copy so callers do not mutate the internal map).
+	* @return a new map containing the same entries as the internal spy table
+	*/
 	spyTable_() {
 		const aTable = /* @__PURE__ */ new Map();
 		for (const [key, value] of this.spyTable) aTable.set(key, value);
 		return aTable;
 	}
+	/**
+	* Turns tracing on, routing trace output to the currently active stream.
+	* @return null
+	*/
 	trace() {
 		this.noTrace();
 		const aPrintStream = this.getStream();
@@ -1873,36 +2870,81 @@ const triggerGc = () => {
 * @author Keisuke Ikeda
 * @this {Evaluator}
 */
-var Evaluator = class Evaluator {
+var Evaluator = class Evaluator extends Object {
+	/**
+	* Lisp-name to method-name dispatch map for special forms.
+	*/
 	static buildInFunctions = Evaluator.setup();
+	/**
+	* The variable binding environment used during evaluation.
+	*/
 	environment;
+	/**
+	* The stream manager used for trace and spy output.
+	*/
 	streamManager;
+	/**
+	* The current call depth, used for indenting trace/spy output.
+	*/
 	depth;
-	constructor(aTable, aStreamManager, aNumber) {
+	/**
+	* Registered plugins consulted by `eval` when no special form matches.
+	*/
+	plugins;
+	/**
+	* Constructor.
+	* @param aTable the variable binding environment
+	* @param aStreamManager the stream manager for trace and spy output
+	* @param aNumber the initial call depth
+	* @param plugins the plugin chain consulted before falling through to Applier
+	*/
+	constructor(aTable, aStreamManager, aNumber, plugins = []) {
+		super();
 		this.environment = aTable;
 		this.streamManager = aStreamManager;
 		this.depth = aNumber;
+		this.plugins = plugins;
 	}
+	/**
+	* Implementation of the Lisp `and` special form.
+	* @param aCons the argument Cons containing the expressions to evaluate
+	* @return nil if any expression evaluates to nil, otherwise t
+	*/
 	and(aCons) {
 		for (const each of aCons.loop()) {
-			const anObject = Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+			const anObject = Evaluator.eval(each, this.environment, this.streamManager, this.depth, this.plugins);
 			if (Cons.isNil(anObject)) return Cons.nil;
 		}
 		return InterpretedSymbol.of("t");
 	}
+	/**
+	* Implementation of the Lisp `apply` special form.
+	* @param aCons the argument Cons containing the procedure and its argument list
+	* @return the result of applying the procedure to the arguments
+	*/
 	apply_lisp(aCons) {
-		const procedure = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
-		const args = Evaluator.eval(aCons.nth(2), this.environment, this.streamManager, this.depth);
+		const procedure = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth, this.plugins);
+		const args = Evaluator.eval(aCons.nth(2), this.environment, this.streamManager, this.depth, this.plugins);
 		let aTable = this.environment;
 		if (procedure instanceof Cons && procedure.last().car instanceof Table) aTable = procedure.last().car;
-		return Applier.apply(procedure, args, aTable, this.streamManager, this.depth);
+		return Applier.apply(procedure, args, aTable, this.streamManager, this.depth, this.plugins);
 	}
+	/**
+	* Implementation of the Lisp `bind` special form.
+	* @param aCons the argument Cons whose car is the symbol to look up
+	* @return the binding count for the symbol, or nil if unbound
+	*/
 	bind(aCons) {
 		if (Cons.isNotSymbol(aCons.car)) throw new EvalError(cannotApply("bind", aCons.car));
 		const aSymbol = aCons.car;
 		if (!this.environment.has(aSymbol)) return Cons.nil;
 		return this.bindAUX(aSymbol);
 	}
+	/**
+	* Counts the number of distinct bindings for the given symbol along the environment chain.
+	* @param aSymbol the symbol whose bindings are inspected
+	* @return the number of distinct bindings found
+	*/
 	bindAUX(aSymbol) {
 		let aTable = this.environment;
 		let anObject = aTable.get(aSymbol);
@@ -1918,98 +2960,138 @@ var Evaluator = class Evaluator {
 		}
 		return count;
 	}
+	/**
+	* Sequentially evaluates and binds each (symbol value) pair into the given table; used by let*.
+	* @param parameters the Cons of (symbol value) pairs to bind
+	* @param aTable the table into which the bindings are written
+	*/
 	binding(parameters, aTable) {
 		for (const each of parameters.loop()) {
 			const theCons = each;
 			if (Cons.isNotSymbol(theCons.car)) throw new EvalError(notSymbol(theCons.car));
 			const key = theCons.car;
-			const value = Evaluator.eval(theCons.nth(2), aTable, this.streamManager, this.depth);
+			const value = Evaluator.eval(theCons.nth(2), aTable, this.streamManager, this.depth, this.plugins);
 			aTable.set(key, value);
 		}
 		return null;
 	}
+	/**
+	* Evaluates all (symbol value) pairs first and then writes them into the given table in parallel; used by let.
+	* @param parameters the Cons of (symbol value) pairs to bind
+	* @param aTable the table into which the bindings are written
+	*/
 	bindingParallel(parameters, aTable) {
 		const theTable = /* @__PURE__ */ new Map();
 		for (const each of parameters.loop()) {
 			const theCons = each;
 			if (Cons.isNotSymbol(theCons.car)) throw new EvalError(notSymbol(theCons.car));
 			const key = theCons.car;
-			const value = Evaluator.eval(theCons.nth(2), aTable, this.streamManager, this.depth);
+			const value = Evaluator.eval(theCons.nth(2), aTable, this.streamManager, this.depth, this.plugins);
 			theTable.set(key, value);
 		}
 		for (const [key, value] of theTable) aTable.set(key, value);
 		return null;
 	}
+	/**
+	* Implementation of the Lisp `cond` special form.
+	* @param aCons the argument Cons of (test consequent...) clauses
+	* @return the result of the first clause whose test is non-nil, or nil
+	*/
 	cond(aCons) {
 		if (Cons.isNil(aCons)) return Cons.nil;
 		const consCell = aCons;
 		const clause = consCell.car;
-		let anObject = Evaluator.eval(clause.car, this.environment, this.streamManager, this.depth);
+		let anObject = Evaluator.eval(clause.car, this.environment, this.streamManager, this.depth, this.plugins);
 		if (Cons.isNil(anObject)) return this.cond(consCell.cdr);
 		const consequent = clause.cdr;
-		for (const each of consequent.loop()) anObject = Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+		for (const each of consequent.loop()) anObject = Evaluator.eval(each, this.environment, this.streamManager, this.depth, this.plugins);
 		return anObject;
 	}
+	/**
+	* Implementation of the Lisp `defun` special form.
+	* @param aCons the argument Cons containing the function name, parameter list, and body
+	* @return the function name symbol
+	*/
 	defun(aCons) {
 		const variable = aCons.car;
 		let lambda = aCons.cdr;
 		lambda = aCons.length() === 2 ? lambda.car : new Cons(InterpretedSymbol.of("lambda"), lambda);
-		lambda = Evaluator.eval(lambda, new Table(this.environment), this.streamManager, this.depth);
+		lambda = Evaluator.eval(lambda, new Table(this.environment), this.streamManager, this.depth, this.plugins);
 		this.environment.set(variable, lambda);
 		return variable;
 	}
+	/**
+	* Implementation of the Lisp `do` special form (parallel binding update).
+	* @param aCons the argument Cons containing bindings, termination clause, and body
+	* @return the value of the termination clause's result form
+	*/
 	do_(aCons) {
 		const parameters = aCons.car;
 		const bool = aCons.nth(2);
 		const expressions = aCons.cdr.cdr;
 		this.bindingParallel(parameters, this.environment);
 		if (Cons.isNil(bool)) bool.setCar(Cons.nil);
-		while (Cons.isNil(Evaluator.eval(bool.car, this.environment, this.streamManager, this.depth))) {
+		while (Cons.isNil(Evaluator.eval(bool.car, this.environment, this.streamManager, this.depth, this.plugins))) {
 			const theTable = /* @__PURE__ */ new Map();
-			for (const each of expressions.loop()) Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+			for (const each of expressions.loop()) Evaluator.eval(each, this.environment, this.streamManager, this.depth, this.plugins);
 			for (const each of parameters.loop()) {
 				const theCons = each;
 				if (Cons.isNotSymbol(theCons.car)) throw new EvalError(notSymbol(theCons.car));
 				const key = theCons.car;
 				if (Cons.isNotNil(theCons.nth(3))) {
-					const value = Evaluator.eval(theCons.nth(3), this.environment, this.streamManager, this.depth);
+					const value = Evaluator.eval(theCons.nth(3), this.environment, this.streamManager, this.depth, this.plugins);
 					theTable.set(key, value);
 				}
 			}
 			for (const [key, value] of theTable) this.environment.set(key, value);
 		}
-		return Evaluator.eval(bool.nth(2), this.environment, this.streamManager, this.depth);
+		return Evaluator.eval(bool.nth(2), this.environment, this.streamManager, this.depth, this.plugins);
 	}
+	/**
+	* Implementation of the Lisp `dolist` special form.
+	* @param aCons the argument Cons containing the binding clause and body
+	* @return the value of the result form
+	*/
 	doList(aCons) {
 		const parameter = aCons.car;
 		const theCons = aCons.cdr;
-		const args = Evaluator.eval(parameter.nth(2), this.environment, this.streamManager, this.depth);
+		const args = Evaluator.eval(parameter.nth(2), this.environment, this.streamManager, this.depth, this.plugins);
 		for (const element of args.loop()) {
 			this.environment.set(parameter.car, element);
-			for (const each of theCons.loop()) Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+			for (const each of theCons.loop()) Evaluator.eval(each, this.environment, this.streamManager, this.depth, this.plugins);
 		}
-		return Evaluator.eval(parameter.nth(3), this.environment, this.streamManager, this.depth);
+		return Evaluator.eval(parameter.nth(3), this.environment, this.streamManager, this.depth, this.plugins);
 	}
+	/**
+	* Implementation of the Lisp `do*` special form (sequential binding update).
+	* @param aCons the argument Cons containing bindings, termination clause, and body
+	* @return the value of the termination clause's result form
+	*/
 	doStar(aCons) {
 		const parameters = aCons.car;
 		const bool = aCons.nth(2);
 		const expressions = aCons.cdr.cdr;
 		this.binding(parameters, this.environment);
 		if (Cons.isNil(bool)) bool.setCar(Cons.nil);
-		while (Cons.isNil(Evaluator.eval(bool.car, this.environment, this.streamManager, this.depth))) {
-			for (const each of expressions.loop()) Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+		while (Cons.isNil(Evaluator.eval(bool.car, this.environment, this.streamManager, this.depth, this.plugins))) {
+			for (const each of expressions.loop()) Evaluator.eval(each, this.environment, this.streamManager, this.depth, this.plugins);
 			for (const each of parameters.loop()) {
 				const theCons = each;
 				if (Cons.isNotSymbol(theCons.car)) throw new EvalError(notSymbol(theCons.car));
 				const key = theCons.car;
 				if (Cons.isNotNil(theCons.nth(3))) {
-					const value = Evaluator.eval(theCons.nth(3), this.environment, this.streamManager, this.depth);
+					const value = Evaluator.eval(theCons.nth(3), this.environment, this.streamManager, this.depth, this.plugins);
 					this.environment.set(key, value);
 				}
 			}
 		}
-		return Evaluator.eval(bool.nth(2), this.environment, this.streamManager, this.depth);
+		return Evaluator.eval(bool.nth(2), this.environment, this.streamManager, this.depth, this.plugins);
 	}
+	/**
+	* Evaluates a procedure call by delegating to the Applier after evaluating each argument.
+	* @param form the call form whose car is the procedure and whose cdr is the argument list
+	* @return the result of applying the procedure
+	*/
 	entrustApplier(form) {
 		const aCons = form.cdr;
 		let args = new Cons(Cons.nil, Cons.nil);
@@ -2022,25 +3104,84 @@ var Evaluator = class Evaluator {
 		}
 		for (const each of aCons.loop()) {
 			if (each instanceof Table) break;
-			args.add(Evaluator.eval(each, this.environment, this.streamManager, this.depth));
+			args.add(Evaluator.eval(each, this.environment, this.streamManager, this.depth, this.plugins));
 		}
 		if (this.isSpy(aSymbol)) this.setDepth(this.depth - 1);
 		args = args.cdr;
-		return Applier.apply(procedure, args, this.environment, this.streamManager, this.depth);
+		return Applier.apply(procedure, args, this.environment, this.streamManager, this.depth, this.plugins);
 	}
-	static eval(form, environment, aStreamManager = new StreamManager(), depth = 1) {
-		return new Evaluator(environment, aStreamManager, depth).eval(form);
+	/**
+	* Evaluates the given form in the given environment.
+	* @param form the form to evaluate
+	* @param environment the variable binding environment
+	* @param aStreamManager the stream manager for trace and spy output
+	* @param depth the current call depth
+	* @param plugins the plugin chain consulted before falling through to Applier
+	* @return the evaluation result
+	*/
+	static eval(form, environment, aStreamManager = new StreamManager(), depth = 1, plugins = []) {
+		return new Evaluator(environment, aStreamManager, depth, plugins).eval(form);
 	}
+	/**
+	* Evaluates the given form using this Evaluator's environment.
+	* @param form the form to evaluate
+	* @return the evaluation result
+	*/
 	eval(form) {
 		if (Cons.isSymbol(form)) return this.evaluateSymbol(form);
 		if (Cons.isNil(form) || Cons.isNotList(form)) return form;
 		const formCons = form;
 		if (Cons.isSymbol(formCons.car) && Evaluator.buildInFunctions.has(formCons.car)) return this.specialForm(formCons);
+		if (Cons.isSymbol(formCons.car) && this.plugins.length > 0) {
+			const symbol = formCons.car;
+			const plugin = this.plugins.find((p) => p.has(symbol));
+			if (plugin !== void 0) return this.entrustPlugin(plugin, formCons);
+		}
 		return this.entrustApplier(formCons);
 	}
+	/**
+	* Evaluates the argument list (the same way `entrustApplier` does), then
+	* delegates the call to the matched plugin with a context that allows
+	* recursive evaluation.
+	* @param plugin the plugin that claimed the call symbol
+	* @param form the call form whose car is the symbol and whose cdr is the argument list
+	* @return the result returned by the plugin
+	*/
+	entrustPlugin(plugin, form) {
+		const aCons = form.cdr;
+		let args = new Cons(Cons.nil, Cons.nil);
+		const symbol = form.car;
+		if (this.isSpy(symbol)) {
+			this.spyPrint(this.streamManager.spyStream(symbol), form.toString());
+			this.setDepth(this.depth + 1);
+		}
+		for (const each of aCons.loop()) {
+			if (each instanceof Table) break;
+			args.add(Evaluator.eval(each, this.environment, this.streamManager, this.depth, this.plugins));
+		}
+		if (this.isSpy(symbol)) this.setDepth(this.depth - 1);
+		args = args.cdr;
+		const ctx = {
+			environment: this.environment,
+			streamManager: this.streamManager,
+			depth: this.depth,
+			eval: (subForm) => Evaluator.eval(subForm, this.environment, this.streamManager, this.depth, this.plugins)
+		};
+		return plugin.apply(symbol, args, ctx);
+	}
+	/**
+	* Implementation of the Lisp `eval` special form.
+	* @param aCons the argument Cons whose car is the form to evaluate twice
+	* @return the result of evaluating the form
+	*/
 	eval_lisp(aCons) {
-		return Evaluator.eval(Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth), this.environment, this.streamManager, this.depth);
+		return Evaluator.eval(Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth, this.plugins), this.environment, this.streamManager, this.depth, this.plugins);
 	}
+	/**
+	* Resolves the value bound to the given symbol in the current environment.
+	* @param aSymbol the symbol to resolve
+	* @return the value bound to the symbol
+	*/
 	evaluateSymbol(aSymbol) {
 		if (!this.environment.has(aSymbol)) throw new EvalError(noBinding(aSymbol));
 		if (this.isSpy(aSymbol)) {
@@ -2055,10 +3196,17 @@ var Evaluator = class Evaluator {
 		}
 		return answer;
 	}
+	/**
+	* Implementation of the Lisp `exit` special form; terminates the REPL by throwing an ExitError.
+	*/
 	exit() {
 		console.log("Bye!");
 		throw new ExitError();
 	}
+	/**
+	* Implementation of the Lisp `gc` special form; triggers garbage collection and returns memory usage.
+	* @return an association list of memory usage statistics
+	*/
 	gc() {
 		triggerGc();
 		const usage = process.memoryUsage();
@@ -2072,110 +3220,198 @@ var Evaluator = class Evaluator {
 		for (const entry of entries) result = new Cons(entry, result);
 		return result;
 	}
+	/**
+	* Implementation of the Lisp `if` special form.
+	* @param aCons the argument Cons containing the test, then-form, and else-form
+	* @return the result of evaluating the selected branch
+	*/
 	if_(aCons) {
-		const bool = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
+		const bool = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth, this.plugins);
 		const anObject = Cons.isNil(bool) ? aCons.nth(3) : aCons.nth(2);
-		return Evaluator.eval(anObject, this.environment, this.streamManager, this.depth);
+		return Evaluator.eval(anObject, this.environment, this.streamManager, this.depth, this.plugins);
 	}
+	/**
+	* Returns the indentation string used for trace and spy output at the current depth.
+	* @return the indentation string
+	*/
 	indent() {
 		let index = 0;
 		let aString = "";
 		while (index++ < this.depth) aString += "| ";
 		return aString;
 	}
+	/**
+	* Returns whether the given symbol is currently being spied on.
+	* @param aSymbol the symbol to check
+	* @return a boolean
+	*/
 	isSpy(aSymbol) {
 		if (aSymbol == null) return false;
 		return this.streamManager.isSpy(aSymbol);
 	}
+	/**
+	* Implementation of the Lisp `lambda` special form; captures the current environment as a closure.
+	* @param args the argument Cons containing the parameter list and body
+	* @return a lambda form with the captured environment appended
+	*/
 	lambda(args) {
 		const aCons = Cons.cloneValue(args);
 		aCons.cdr.setCdr(new Cons(this.environment, Cons.nil));
 		return new Cons(InterpretedSymbol.of("lambda"), aCons);
 	}
+	/**
+	* Implementation of the Lisp `let` special form (parallel binding).
+	* @param aCons the argument Cons containing bindings and body
+	* @return the value of the last body form
+	*/
 	let(aCons) {
 		const aTable = new Table(this.environment);
 		const parameters = aCons.car;
 		const forms = aCons.cdr;
 		let anObject = Cons.nil;
 		this.bindingParallel(parameters, aTable);
-		for (const each of forms.loop()) anObject = Evaluator.eval(each, aTable, this.streamManager, this.depth);
+		for (const each of forms.loop()) anObject = Evaluator.eval(each, aTable, this.streamManager, this.depth, this.plugins);
 		return anObject;
 	}
+	/**
+	* Implementation of the Lisp `let*` special form (sequential binding).
+	* @param aCons the argument Cons containing bindings and body
+	* @return the value of the last body form
+	*/
 	letStar(aCons) {
 		const aTable = new Table(this.environment);
 		const parameters = aCons.car;
 		const forms = aCons.cdr;
 		let anObject = Cons.nil;
 		this.binding(parameters, aTable);
-		for (const each of forms.loop()) anObject = Evaluator.eval(each, aTable, this.streamManager, this.depth);
+		for (const each of forms.loop()) anObject = Evaluator.eval(each, aTable, this.streamManager, this.depth, this.plugins);
 		return anObject;
 	}
+	/**
+	* Implementation of the Lisp `not` special form.
+	* @param aCons the argument Cons whose car is the expression to negate
+	* @return t if the expression evaluates to nil, otherwise nil
+	*/
 	not(aCons) {
-		if (Cons.isNil(Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth))) return InterpretedSymbol.of("t");
+		if (Cons.isNil(Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth, this.plugins))) return InterpretedSymbol.of("t");
 		return Cons.nil;
 	}
+	/**
+	* Implementation of the Lisp `notrace` special form; disables tracing.
+	* @return the symbol t
+	*/
 	notrace() {
 		this.streamManager.noTrace();
 		return InterpretedSymbol.of("t");
 	}
+	/**
+	* Implementation of the Lisp `or` special form.
+	* @param aCons the argument Cons containing the expressions to evaluate
+	* @return t if any expression evaluates to non-nil, otherwise nil
+	*/
 	or(aCons) {
 		for (const each of aCons.loop()) {
-			const anObject = Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+			const anObject = Evaluator.eval(each, this.environment, this.streamManager, this.depth, this.plugins);
 			if (Cons.isNotNil(anObject)) return InterpretedSymbol.of("t");
 		}
 		return Cons.nil;
 	}
+	/**
+	* Implementation of the Lisp `pop` special form.
+	* @param aCons the argument Cons whose car is the symbol bound to a list
+	* @return the popped element, or nil if the binding is not a Cons
+	*/
 	pop_(aCons) {
 		if (Cons.isNotSymbol(aCons.car)) throw new EvalError(argumentNotSymbol(1));
 		const aSymbol = aCons.car;
-		const anObject = Evaluator.eval(aSymbol, this.environment, this.streamManager, this.depth);
+		const anObject = Evaluator.eval(aSymbol, this.environment, this.streamManager, this.depth, this.plugins);
 		if (Cons.isNotCons(anObject)) return Cons.nil;
 		const consObject = anObject;
 		this.environment.setIfExist(aSymbol, consObject.cdr);
 		return consObject.car;
 	}
+	/**
+	* Implementation of the Lisp `progn` special form.
+	* @param aCons the argument Cons containing the body expressions
+	* @return the value of the last body form, or nil if there are none
+	*/
 	progn(aCons) {
 		let anObject = Cons.nil;
-		for (const each of aCons.loop()) anObject = Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+		for (const each of aCons.loop()) anObject = Evaluator.eval(each, this.environment, this.streamManager, this.depth, this.plugins);
 		return anObject;
 	}
+	/**
+	* Implementation of the Lisp `princ` special form; writes the evaluated argument without a trailing newline.
+	* @param aCons the argument Cons whose car is the expression to print
+	* @return the printed value
+	*/
 	princ(aCons) {
-		const anObject = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
+		const anObject = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth, this.plugins);
 		process.stdout.write(String(anObject));
 		return anObject;
 	}
+	/**
+	* Implementation of the Lisp `print` special form; writes the evaluated argument followed by a newline.
+	* @param aCons the argument Cons whose car is the expression to print
+	* @return the printed value
+	*/
 	print(aCons) {
-		const anObject = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
+		const anObject = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth, this.plugins);
 		process.stdout.write(String(anObject) + "\n");
 		return anObject;
 	}
+	/**
+	* Implementation of the Lisp `push` special form.
+	* @param aCons the argument Cons containing the value to push and the target symbol
+	* @return the new Cons stored in the symbol
+	*/
 	push_(aCons) {
-		let anObject = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
+		let anObject = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth, this.plugins);
 		if (Cons.isNotSymbol(aCons.nth(2))) throw new EvalError(argumentNotSymbol(2));
 		const aSymbol = aCons.nth(2);
-		anObject = new Cons(anObject, Evaluator.eval(aSymbol, this.environment, this.streamManager, this.depth));
+		anObject = new Cons(anObject, Evaluator.eval(aSymbol, this.environment, this.streamManager, this.depth, this.plugins));
 		this.environment.setIfExist(aSymbol, anObject);
 		return anObject;
 	}
+	/**
+	* Implementation of the Lisp `quote` special form.
+	* @param aCons the argument Cons whose car is the form to return unevaluated
+	* @return the quoted form
+	*/
 	quote(aCons) {
 		return aCons.car;
 	}
+	/**
+	* Implementation of the Lisp `rplaca` special form; destructively replaces the car of a Cons.
+	* @param args the argument Cons containing the target Cons expression and the new car value
+	* @return the modified Cons
+	*/
 	rplaca(args) {
-		let anObject = Evaluator.eval(args.car, this.environment, this.streamManager, this.depth);
+		let anObject = Evaluator.eval(args.car, this.environment, this.streamManager, this.depth, this.plugins);
 		if (Cons.isNotCons(anObject)) throw new EvalError(cannotApply("set-car!", anObject));
 		const aCons = anObject;
-		anObject = Evaluator.eval(args.nth(2), this.environment, this.streamManager, this.depth);
+		anObject = Evaluator.eval(args.nth(2), this.environment, this.streamManager, this.depth, this.plugins);
 		aCons.setCar(anObject);
-		return Evaluator.eval(args.car, this.environment, this.streamManager, this.depth);
+		return Evaluator.eval(args.car, this.environment, this.streamManager, this.depth, this.plugins);
 	}
+	/**
+	* Implementation of the Lisp `rplacd` special form; destructively replaces the cdr of a Cons.
+	* @param args the argument Cons containing the target Cons expression and the new cdr value
+	* @return the modified Cons
+	*/
 	rplacd(args) {
-		let anObject = Evaluator.eval(args.car, this.environment, this.streamManager, this.depth);
+		let anObject = Evaluator.eval(args.car, this.environment, this.streamManager, this.depth, this.plugins);
 		if (Cons.isNotCons(anObject)) throw new EvalError(cannotApply("set-cdr!", anObject));
 		const aCons = anObject;
-		anObject = Evaluator.eval(args.nth(2), this.environment, this.streamManager, this.depth);
+		anObject = Evaluator.eval(args.nth(2), this.environment, this.streamManager, this.depth, this.plugins);
 		aCons.setCdr(anObject);
-		return Evaluator.eval(args.car, this.environment, this.streamManager, this.depth);
+		return Evaluator.eval(args.car, this.environment, this.streamManager, this.depth, this.plugins);
 	}
+	/**
+	* Implementation of the Lisp `setq` special form; assigns values in the local environment.
+	* @param args the argument Cons containing alternating (symbol value) pairs
+	* @return the last assigned value
+	*/
 	setq(args) {
 		let anObject = Cons.nil;
 		const anIterator = args.loop();
@@ -2183,26 +3419,39 @@ var Evaluator = class Evaluator {
 			if (!Cons.isSymbol(args.nth(1))) throw new EvalError(notSymbol(args.car));
 			const key = anIterator.next();
 			if (!anIterator.hasNext()) throw new EvalError(SIZES_DO_NOT_MATCH);
-			anObject = Evaluator.eval(anIterator.next(), this.environment, this.streamManager, this.depth);
+			anObject = Evaluator.eval(anIterator.next(), this.environment, this.streamManager, this.depth, this.plugins);
 			this.environment.set(key, anObject);
 		}
 		return anObject;
 	}
+	/**
+	* Implementation of the Lisp `set-allq` special form; assigns values in the binding's owning scope.
+	* @param args the argument Cons containing alternating (symbol value) pairs
+	* @return the last assigned value
+	*/
 	set_allq(args) {
 		let anObject = Cons.nil;
 		const anIterator = args.loop();
 		while (anIterator.hasNext()) {
 			if (!Cons.isSymbol(args.nth(1))) throw new EvalError(notSymbol(args.car));
 			const key = anIterator.next();
-			anObject = Evaluator.eval(anIterator.next(), this.environment, this.streamManager, this.depth);
+			anObject = Evaluator.eval(anIterator.next(), this.environment, this.streamManager, this.depth, this.plugins);
 			this.environment.setIfExist(key, anObject);
 		}
 		return anObject;
 	}
+	/**
+	* Sets the current call depth used for trace and spy indentation.
+	* @param aNumber the new depth
+	*/
 	setDepth(aNumber) {
 		this.depth = aNumber;
 		return null;
 	}
+	/**
+	* Builds and returns the Lisp-name to method-name dispatch map for special forms.
+	* @return the dispatch map
+	*/
 	static setup() {
 		try {
 			return new Map([
@@ -2244,6 +3493,11 @@ var Evaluator = class Evaluator {
 			throw new Error("NullPointerException (Evaluator, initialize)");
 		}
 	}
+	/**
+	* Dispatches a special-form call to the corresponding method via the build-in dispatch map.
+	* @param form the form whose car is the special-form symbol
+	* @return the result of the special-form method
+	*/
 	specialForm(form) {
 		const aSymbol = form.car;
 		if (this.isSpy(aSymbol)) {
@@ -2262,37 +3516,65 @@ var Evaluator = class Evaluator {
 		}
 		return answer;
 	}
+	/**
+	* Writes a trace/spy line to the given stream (or stdout) with the current indentation.
+	* @param aStream the destination stream, or null/string to fall back to stdout
+	* @param line the line to write
+	*/
 	spyPrint(aStream, line) {
 		(aStream != null && typeof aStream === "object" && "write" in aStream ? aStream : process.stdout).write(this.indent() + line + "\n");
 		return null;
 	}
+	/**
+	* Implementation of the Lisp `terpri` special form; writes a newline to stdout.
+	* @return the symbol t
+	*/
 	terpri() {
 		process.stdout.write("\n");
 		return InterpretedSymbol.of("t");
 	}
+	/**
+	* Implementation of the Lisp `time` special form; measures evaluation time in milliseconds.
+	* @param aCons the argument Cons whose car is the form to time
+	* @return the elapsed time in milliseconds
+	*/
 	time(aCons) {
 		const start = process.hrtime();
-		Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
+		Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth, this.plugins);
 		return process.hrtime(start)[1] / 1e6;
 	}
+	/**
+	* Implementation of the Lisp `trace` special form; enables tracing.
+	* @return the symbol t
+	*/
 	trace() {
 		this.streamManager.trace();
 		return InterpretedSymbol.of("t");
 	}
+	/**
+	* Implementation of the Lisp `unless` special form.
+	* @param aCons the argument Cons containing the test and body
+	* @return the value of the last body form if the test is nil, otherwise nil
+	*/
 	unless(aCons) {
 		let anObject = Cons.nil;
 		const theCons = aCons.cdr;
-		const flag = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
+		const flag = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth, this.plugins);
 		if (Cons.isNotNil(flag)) return Cons.nil;
-		for (const each of theCons.loop()) anObject = Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+		for (const each of theCons.loop()) anObject = Evaluator.eval(each, this.environment, this.streamManager, this.depth, this.plugins);
 		return anObject;
 	}
+	/**
+	* Implementation of the Lisp `when` special form.
+	* @param aCons the argument Cons containing the test and body
+	* @return the value of the last body form if the test is non-nil, otherwise nil
+	*/
 	when(aCons) {
 		let anObject = Cons.nil;
 		const theCons = aCons.cdr;
-		const flag = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
+		const flag = Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth, this.plugins);
 		if (Cons.isNil(flag)) return Cons.nil;
-		for (const each of theCons.loop()) anObject = Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+		for (const each of theCons.loop()) anObject = Evaluator.eval(each, this.environment, this.streamManager, this.depth, this.plugins);
 		return anObject;
 	}
 };
@@ -2304,23 +3586,54 @@ var Evaluator = class Evaluator {
 * @author Keisuke Ikeda
 * @this {LispInterpreter}
 */
-var LispInterpreter = class {
+var LispInterpreter = class extends Object {
+	/**
+	* The root (top-level) environment table, pre-populated with built-in symbols.
+	*/
 	root;
+	/**
+	* The stream manager that owns the interpreter's output / spy streams.
+	*/
 	streamManager;
+	/**
+	* Registered plugins consulted by the evaluator on every call. See `use`.
+	*/
+	plugins;
+	/**
+	* Constructor.
+	* @constructor
+	*/
 	constructor() {
+		super();
 		this.root = this.initializeTable();
 		this.streamManager = new StreamManager();
+		this.plugins = [];
+	}
+	/**
+	* Registers a plugin. Subsequent `eval` calls will consult the plugin chain
+	* (in registration order, first match wins) when no special form matches a
+	* symbol, before falling through to the Applier built-ins.
+	* @param plugin the plugin to register
+	* @return this interpreter, for chaining
+	*/
+	use(plugin) {
+		this.plugins.push(plugin);
+		return this;
 	}
 	/**
 	* Evaluates the given expression and returns the result. Throws `ParseError`,
 	* `EvalError`, or `ExitError` on failure; library users are expected to catch
 	* these (see the `KeiLispError` base class for the parse/eval family).
+	* @param aCons the expression to evaluate
+	* @return the evaluation result
 	*/
 	eval(aCons) {
-		return Evaluator.eval(aCons, this.root, this.streamManager);
+		return Evaluator.eval(aCons, this.root, this.streamManager, 1, this.plugins);
 	}
 	/**
 	* Parses the source string, evaluates every expression it contains, and returns the results as an array.
+	* @param source the Lisp source string
+	* @return the array of evaluation results, one per top-level expression
 	*/
 	evalAll(source) {
 		const ast = this.parse(source);
@@ -2330,6 +3643,8 @@ var LispInterpreter = class {
 	}
 	/**
 	* Parses and evaluates the source string and returns the value of the last expression.
+	* @param source the Lisp source string
+	* @return the value of the last expression, or `Cons.nil` for empty input
 	*/
 	evalString(source) {
 		const results = this.evalAll(source);
@@ -2340,12 +3655,16 @@ var LispInterpreter = class {
 	* it. The result is always a `Cons` (possibly `Cons.nil` for empty input)
 	* because the source is wrapped in an outer list before parsing. Throws
 	* `ParseError` if the source cannot be parsed.
+	* @param aString the Lisp source string
+	* @return a Cons containing the parsed top-level expressions
 	*/
 	parse(aString) {
 		return Cons.parse("(" + aString + "\n);");
 	}
 	/**
 	* Sets the given environment as the root of the environment chain.
+	* @param environment the environment table to install as root
+	* @return null
 	*/
 	setRoot(environment) {
 		if (environment instanceof Table) {
@@ -2355,13 +3674,14 @@ var LispInterpreter = class {
 		return null;
 	}
 	/**
-	* Initializes the environment table.
+	* Builds the root environment table by pre-registering every built-in symbol and the small set of bootstrap lambdas (append / butlast / nthcdr / reverse).
+	* @return the freshly initialized root environment
 	*/
 	initializeTable() {
 		const aList = [];
 		const aTable = new Table();
 		aTable.setRoot(true);
-		aList.push("abs", "add", "and", "apply", "assoc", "atom", "bind", "car", "cdr", "characterp", "cond", "cons", "consp", "copy", "cos", "floatp", "defun", "divide", "do", "do*", "dolist", "doublep", "eq", "equal", "exit", "exp", "gc", "gensym", "if", "integerp", "lambda", "let", "let*", "last", "list", "listp", "mapcar", "member", "memq", "mod", "multiply", "napier", "neq", "nequal", "not", "notrace", "nth", "null", "numberp", "or", "pi", "pop", "progn", "printc", "print", "push", "quote", "random", "reload", "round", "rplaca", "rplacd", "setq", "set-allq", "sin", "sqrt", "subtract", "stringp", "symbolp", "tan", "terpri", "time", "trace", "unless", "when", "+", "-", "*", "/", "//", "=", "==", "~=", "~~", "<", "<=", ">", ">=");
+		aList.push("abs", "add", "and", "apply", "assoc", "atom", "bind", "car", "cdr", "characterp", "cond", "ceiling", "concatenate", "cons", "consp", "copy", "cos", "count", "floatp", "floor", "defun", "divide", "do", "do*", "dolist", "doublep", "elt", "eq", "equal", "eval", "evenp", "every", "exit", "exp", "expt", "find", "format", "gc", "gensym", "if", "integerp", "lambda", "let", "let*", "last", "length", "list", "listp", "mapcan", "mapcar", "max", "member", "memq", "min", "minusp", "mod", "multiply", "napier", "neq", "nequal", "not", "notrace", "nth", "null", "numberp", "oddp", "or", "pi", "plusp", "pop", "princ", "print", "progn", "push", "quote", "random", "reduce", "round", "rplaca", "rplacd", "setq", "set-allq", "sin", "some", "sort", "sqrt", "string-downcase", "string-trim", "string-upcase", "stringp", "subseq", "substring", "subtract", "symbolp", "tan", "terpri", "time", "trace", "truncate", "unless", "when", "zerop", "1+", "1-", "+", "-", "*", "/", "//", "=", "==", "~=", "~~", "<", "<=", ">", ">=");
 		for (const each of aList) {
 			const aSymbol = InterpretedSymbol.of(each);
 			aTable.set(aSymbol, aSymbol);
@@ -2376,10 +3696,6 @@ var LispInterpreter = class {
 		aCons = Cons.parse(aString);
 		aCons.last().setCdr(new Cons(aTable, Cons.nil));
 		aTable.set(InterpretedSymbol.of("butlast"), aCons);
-		aString = "(lambda (l) (cond ((null (listp l)) nil) ((null l) 0) (t (+ 1 (length (cdr l))))))";
-		aCons = Cons.parse(aString);
-		aCons.last().setCdr(new Cons(aTable, Cons.nil));
-		aTable.set(InterpretedSymbol.of("length"), aCons);
 		aString = "(lambda (n l) (cond ((> n (length l)) nil) ((= 0 n) l) (t (nthcdr (- n 1) (cdr l)))))";
 		aCons = Cons.parse(aString);
 		aCons.last().setCdr(new Cons(aTable, Cons.nil));
@@ -2401,10 +3717,22 @@ const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__
 * @author Keisuke Ikeda
 * @this {Repl}
 */
-var Repl = class {
+var Repl = class extends Object {
+	/**
+	* The underlying interpreter used to parse and evaluate user input.
+	*/
 	interpreter;
+	/**
+	* The Node.js readline interface that supplies prompt I/O.
+	*/
 	rl;
+	/**
+	* Constructor.
+	* @constructor
+	* @param interpreter the interpreter to evaluate input against (defaults to a fresh one)
+	*/
 	constructor(interpreter = new LispInterpreter()) {
+		super();
 		this.interpreter = interpreter;
 		const readline = require$1("node:readline");
 		this.rl = readline.createInterface({
@@ -2415,6 +3743,7 @@ var Repl = class {
 	}
 	/**
 	* Starts the REPL loop.
+	* @return void
 	*/
 	run() {
 		let aString = "";
@@ -2455,11 +3784,14 @@ var Repl = class {
 //#endregion
 exports.Cons = Cons;
 exports.EvalError = EvalError;
+exports.Evaluator = Evaluator;
 exports.ExitError = ExitError;
 exports.InterpretedSymbol = InterpretedSymbol;
 exports.KeiLispError = KeiLispError;
 exports.LispInterpreter = LispInterpreter;
 exports.ParseError = ParseError;
 exports.Repl = Repl;
+exports.StreamManager = StreamManager;
+exports.Table = Table;
 
 //# sourceMappingURL=index.cjs.map