kei-lisp 2.0.0

package/dist/cli.cjs

@@ -0,0 +1,3051 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/tsup@8.5.1_postcss@8.5.14_typescript@5.9.3_yaml@2.8.4/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// package.json
+var package_default = {
+  name: "kei-lisp",
+  version: "2.0.0",
+  description: "A Lisp interpreter implemented in TypeScript",
+  author: "Keisuke Ikeda",
+  license: "MIT",
+  type: "module",
+  sideEffects: false,
+  keywords: [
+    "lisp",
+    "interpreter",
+    "typescript",
+    "repl",
+    "functional-programming",
+    "cli"
+  ],
+  homepage: "https://github.com/ike-keichan/kei-lisp#readme",
+  bugs: {
+    url: "https://github.com/ike-keichan/kei-lisp/issues"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/ike-keichan/kei-lisp.git"
+  },
+  main: "./dist/index.js",
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/index.d.ts",
+        default: "./dist/index.js"
+      },
+      require: {
+        types: "./dist/index.d.cts",
+        default: "./dist/index.cjs"
+      }
+    }
+  },
+  types: "./dist/index.d.ts",
+  bin: {
+    "kei-lisp": "./dist/cli.cjs"
+  },
+  files: [
+    "dist/"
+  ],
+  scripts: {
+    prepare: "pnpm build",
+    prepublishOnly: "pnpm check && pnpm test",
+    build: "tsup",
+    start: "node dist/cli.cjs",
+    test: "vitest run",
+    "test:watch": "vitest",
+    doc: "typedoc",
+    check: "run-s check:*",
+    "check:format": 'prettier "./src/**/*.ts" "./examples/**/*.ts" --check',
+    "check:format-config": 'prettier "./*.{js,mjs,json,md}" "./docs/**/*.md" "./.github/**/*.yml" "./configs/**/*.mjs" --check',
+    "check:lint": 'eslint "./src/**/*.ts" "./examples/**/*.ts"',
+    "check:lint-config": 'eslint ./*.{js,mjs} "./configs/**/*.mjs"',
+    "check:spell": 'cspell "./src/**/*.ts" "./examples/**/*.ts"',
+    "check:spell-config": 'cspell "./*.{js,mjs,json,md}" "./docs/**/*.md" "./.github/**/*.yml" "./configs/**/*.mjs"',
+    fix: "run-s fix:*",
+    "fix:format": 'prettier "./src/**/*.ts" "./examples/**/*.ts" --write',
+    "fix:format-config": 'prettier "./*.{js,mjs,json,md}" "./docs/**/*.md" "./.github/**/*.yml" "./configs/**/*.mjs" --write',
+    "fix:lint": 'eslint "./src/**/*.ts" "./examples/**/*.ts" --fix',
+    "fix:lint-config": 'eslint ./*.{js,mjs} "./configs/**/*.mjs" --fix'
+  },
+  devDependencies: {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.6.0",
+    "@vitest/eslint-plugin": "^1.6.16",
+    cspell: "^9.8.0",
+    eslint: "^10.3.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import-x": "^4.16.2",
+    "eslint-plugin-n": "^17.24.0",
+    "eslint-plugin-security": "^4.0.0",
+    "eslint-plugin-sonarjs": "^4.0.3",
+    "eslint-plugin-unicorn": "^63.0.0",
+    "eslint-plugin-unused-imports": "^4.4.1",
+    globals: "^16.5.0",
+    "npm-run-all": "^4.1.5",
+    prettier: "^3.8.3",
+    tsup: "^8.5.1",
+    typedoc: "^0.28.19",
+    typescript: "^5.9.3",
+    "typescript-eslint": "^8.59.2",
+    vitest: "^4.1.5"
+  },
+  engines: {
+    node: ">=24.0.0"
+  },
+  packageManager: "pnpm@10.33.3"
+};
+
+// src/LispInterpreter/index.ts
+var import_node_module = require("module");
+
+// src/runtime/Table/index.ts
+var Table = class _Table extends Map {
+  source;
+  root;
+  /**
+   * Constructor.
+   * @param aTable the environment in which this environment was created
+   */
+  constructor(aTable = null) {
+    super();
+    this.source = aTable;
+    this.root = aTable == null ? true : false;
+  }
+  /**
+   * Clones this Table and returns the clone.
+   */
+  clone() {
+    const aTable = new _Table(this);
+    for (const key of this.keys()) {
+      const value = Cons.cloneValue(this.get(key));
+      if (value == null) {
+        throw new Error("RuntimeException!");
+      }
+      aTable.set(key, value);
+    }
+    return aTable;
+  }
+  /**
+   * Returns whether anything is bound to the given property (key).
+   */
+  has(aSymbol) {
+    if (super.has(aSymbol)) {
+      return true;
+    }
+    if (this.isRoot()) {
+      return false;
+    }
+    return this.source.has(aSymbol);
+  }
+  /**
+   * Returns whether this instance equals the given object.
+   */
+  equals(anObject) {
+    return Map.prototype.equals(anObject);
+  }
+  /**
+   * Returns the value bound to the given interpreted symbol.
+   */
+  get(aSymbol) {
+    if (super.has(aSymbol)) {
+      return super.get(aSymbol);
+    }
+    if (this.isRoot()) {
+      return null;
+    }
+    return this.source.get(aSymbol);
+  }
+  /**
+   * Returns whether this instance is the root of the environment chain.
+   */
+  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.
+   */
+  setIfExist(aSymbol, anObject) {
+    if (super.has(aSymbol)) {
+      this.set(aSymbol, anObject);
+      return anObject;
+    }
+    if (this.isRoot()) {
+      return null;
+    }
+    return this.source.setIfExist(aSymbol, anObject);
+  }
+  /**
+   * Sets whether this instance is the root of its environment chain.
+   */
+  setRoot(aBoolean) {
+    this.root = aBoolean;
+    return null;
+  }
+  /**
+   * Sets the parent environment.
+   */
+  setSource(aTable) {
+    this.source = aTable;
+    return null;
+  }
+  /**
+   * Returns a formatted string representation of this instance.
+   */
+  toString() {
+    return "#<Environment>";
+  }
+};
+
+// src/value/InterpretedSymbol/index.ts
+var InterpretedSymbol = class _InterpretedSymbol {
+  /**
+   * Table that stores InterpretedSymbol instances (lazily initialized to avoid a circular dependency).
+   */
+  static #intern = null;
+  static get table() {
+    this.#intern ??= new Table();
+    return this.#intern;
+  }
+  name;
+  /**
+   * Constructor.
+   * @param name printed name
+   */
+  constructor(name = "null") {
+    this.name = name;
+  }
+  /**
+   * Compares this interpreted symbol with the given one by printed name.
+   * @param aSymbol the symbol to compare against
+   * @return the difference in string length
+   */
+  compareTo(aSymbol) {
+    const left = this.name.codePointAt(0) ?? 0;
+    const right = aSymbol.name.codePointAt(0) ?? 0;
+    let aNumber = left < right ? aSymbol.name.length - left : left - aSymbol.name.length;
+    aNumber = left === right ? 0 : aNumber;
+    return aNumber;
+  }
+  /**
+   * Returns whether this symbol equals the given object.
+   */
+  equals(anObject) {
+    return this === anObject;
+  }
+  /**
+   * Returns the same interpreted symbol for a given printed name.
+   * @param aString printed name
+   */
+  static of(aString) {
+    let aSymbol = this.table.get(aString);
+    if (aSymbol == null) {
+      aSymbol = new _InterpretedSymbol(aString);
+      this.table.set(aString, aSymbol);
+    }
+    return aSymbol;
+  }
+  /**
+   * Returns the string representation of this symbol.
+   */
+  toString() {
+    return this.name;
+  }
+};
+
+// src/value/Loop/index.ts
+var Loop = class {
+  aCons;
+  length;
+  index;
+  /**
+   * Constructor.
+   * @param aCons the Cons to iterate over
+   */
+  constructor(aCons) {
+    this.aCons = aCons;
+    this.length = aCons.length();
+    this.index = 1;
+  }
+  /**
+   * Returns this instance.
+   */
+  iterator() {
+    return this;
+  }
+  /**
+   * Returns whether a next element exists.
+   */
+  hasNext() {
+    return this.index <= this.length;
+  }
+  /**
+   * Returns the next element.
+   */
+  next() {
+    const anObject = this.aCons.nth(this.index);
+    this.remove();
+    return anObject;
+  }
+  /**
+   * Implementation of the iterable protocol.
+   * Enables iteration with for...of and similar constructs.
+   */
+  [Symbol.iterator]() {
+    return {
+      next: () => {
+        if (this.index <= this.length) {
+          const nextValue = this.aCons.nth(this.index);
+          this.remove();
+          return { value: nextValue, done: false };
+        }
+        return { done: true };
+      }
+    };
+  }
+  /**
+   * Implementation of the async iterable protocol.
+   * Enables iteration with for await...of and similar constructs.
+   */
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.index <= this.length) {
+          const nextValue = this.aCons.nth(this.index);
+          this.remove();
+          return Promise.resolve({ value: nextValue, done: false });
+        }
+        return Promise.resolve({ done: true });
+      }
+    };
+  }
+  /**
+   * Advances to the next element.
+   */
+  remove() {
+    this.index++;
+    return null;
+  }
+};
+
+// src/parser/IntStream/index.ts
+var IntStream = class {
+  /**
+   * Builds and returns an array of consecutive integers from start to afterEnd (exclusive).
+   */
+  static range(start, afterEnd) {
+    const end = afterEnd - 1;
+    return this.rangeClosed(start, end);
+  }
+  /**
+   * Builds and returns an array of consecutive integers from start to end (inclusive).
+   */
+  static rangeClosed(start, end) {
+    const range = end - start + 1;
+    return Array.from({ length: range }, () => start++);
+  }
+};
+
+// src/parser/NextState/index.ts
+var NextState = class {
+  automaton = null;
+  nextState;
+  method;
+  methodName;
+  /**
+   * Constructor.
+   */
+  constructor(aNumber, aString) {
+    this.nextState = aNumber;
+    this.method = null;
+    this.methodName = aString;
+  }
+  /**
+   * Invokes the method corresponding to the input character and returns the resulting token number.
+   */
+  next(anAutomaton) {
+    this.automaton = anAutomaton;
+    if (this.methodName == null) {
+      return Number(this.nextState);
+    }
+    if (this.method == null) {
+      try {
+        this.method = this.automaton[this.methodName];
+      } catch {
+        throw new Error("Not Found Method: " + this.methodName);
+      }
+    }
+    let aNumber = -1;
+    try {
+      if (this.nextState != null) {
+        aNumber = this.nextState;
+      }
+      const anObject = this.automaton[this.methodName]();
+      if (anObject != null) {
+        aNumber = Number(anObject);
+      }
+    } catch {
+      throw new Error("Not Invoke Method: " + this.methodName);
+    }
+    return aNumber;
+  }
+};
+
+// src/parser/Parser/index.ts
+var PEEKCOUNT = 10;
+var SYNTAX_ERROR = "Syntax Error!";
+var Parser = class _Parser {
+  stream;
+  token;
+  tokenString;
+  states;
+  state;
+  nexts;
+  /**
+   * Constructor.
+   * @param aString the string to parse
+   */
+  constructor(aString) {
+    this.stream = aString[Symbol.iterator]();
+    this.token = null;
+    this.tokenString = "";
+    this.states = /* @__PURE__ */ new Map();
+    this.state = 0;
+    this.nexts = Array.from({ length: PEEKCOUNT + 1 }, () => null);
+    this.initializeStateTransitionTable();
+    let count = 0;
+    while (count++ < PEEKCOUNT) {
+      this.nextChar();
+    }
+  }
+  /**
+   * Returns whether this is the last element.
+   */
+  atEnd() {
+    return this.peekChar() == null;
+  }
+  /**
+   * Concatenates the current character into the token string.
+   */
+  concatCharacter() {
+    this.tokenString = this.tokenString.concat(String(this.nexts[0]));
+    return null;
+  }
+  /**
+   * Parses a single character of the input string.
+   */
+  input(aCharacter = this.nextChar()) {
+    const inputs = this.states.get(this.state);
+    const codePoint = aCharacter.codePointAt(0) ?? 0;
+    const aNumber = inputs.has(String(codePoint)) ? inputs.get(String(codePoint)).next(this) : inputs.get(String(128)).next(this);
+    if (aNumber < 0) {
+      throw new Error(SYNTAX_ERROR);
+    }
+    this.state = aNumber;
+    return this.token;
+  }
+  /**
+   * Returns the next character to be parsed from the input string.
+   */
+  nextChar() {
+    let aCharacter = null;
+    try {
+      const aNumber = this.stream.next().value?.codePointAt(0) ?? -1;
+      if (aNumber >= 0) {
+        aCharacter = String.fromCodePoint(aNumber);
+      }
+    } catch {
+      throw new Error("Read Error!");
+    }
+    let count = 0;
+    while (count < PEEKCOUNT) {
+      this.nexts[count] = this.nexts[count + 1];
+      count++;
+    }
+    this.nexts[count] = aCharacter;
+    return this.nexts[0];
+  }
+  /**
+   * Determines and returns the next token.
+   */
+  nextToken() {
+    this.token = null;
+    let token = null;
+    while (!this.atEnd()) {
+      if (this.state === 0 && token != null) {
+        break;
+      }
+      token = this.input();
+    }
+    if (this.atEnd() && this.state !== 0) {
+      throw new Error(SYNTAX_ERROR);
+    }
+    this.tokenString = "";
+    return token;
+  }
+  /**
+   * Instantiates and returns a NextState.
+   */
+  nextState(aNumber, aString) {
+    return new NextState(aNumber, aString);
+  }
+  /**
+   * Parses the given string and returns the result.
+   */
+  static parse(aString) {
+    return new _Parser(aString).nextToken();
+  }
+  /**
+   * Returns the next character if one exists.
+   */
+  peekChar(aNumber = 1) {
+    if (aNumber > this.nexts.length) {
+      throw new Error("Read Error!");
+    }
+    return this.nexts[aNumber];
+  }
+  /**
+   * Concatenates characters; invoked from NextState.
+   */
+  concat() {
+    this.concatCharacter();
+    return null;
+  }
+  /**
+   * Concatenates the current character after translating common escape sequences
+   * (`\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`).
+   */
+  escapeConcat() {
+    const c = String(this.nexts[0]);
+    const map = {
+      n: "\n",
+      t: "	",
+      r: "\r",
+      "\\": "\\",
+      '"': '"'
+    };
+    this.tokenString = this.tokenString.concat(map[c] ?? c);
+    return null;
+  }
+  /**
+   * Returns the token number for a Number-type (double-precision floating point: pseudo-Double); invoked from NextState.
+   */
+  doubleToken() {
+    this.concat();
+    if (this.rightParen()) {
+      this.tokenToDouble();
+      return 0;
+    }
+    return 3;
+  }
+  /**
+   * Returns the token number for a Number-type (double-precision floating point: pseudo-Double); invoked from NextState.
+   */
+  doubleTokenAUX() {
+    this.concat();
+    if (this.rightParen()) {
+      this.tokenToDouble();
+      return 0;
+    }
+    return 5;
+  }
+  /**
+   * Returns the token number for a Number-type (integer: pseudo-Integer); invoked from NextState.
+   */
+  integerToken() {
+    this.concat();
+    if (this.rightParen()) {
+      this.tokenToInteger();
+      return 0;
+    }
+    return 2;
+  }
+  /**
+   * Converts the token into a list (Cons) and returns the token number for a list (Cons); invoked from NextState.
+   */
+  parseList() {
+    this.skippingSpaces();
+    if (this.rightParen()) {
+      this.nextChar();
+      this.token = Cons.nil;
+    } else {
+      this.token = this.parseListAUX();
+    }
+    return 0;
+  }
+  /**
+   * Helper that converts the token into a list (Cons); invoked from NextState.
+   */
+  parseListAUX() {
+    this.skippingSpaces();
+    if (this.peekChar() === ";") {
+      while (this.peekChar() !== "\n" && this.peekChar() != null) {
+        this.nextChar();
+      }
+      this.nextChar();
+      this.skippingSpaces();
+    }
+    if (this.rightParen()) {
+      this.nextChar();
+      return Cons.nil;
+    } else if (this.peekChar() === ".") {
+      this.nextChar();
+      this.state = 0;
+      const cdr = this.nextToken();
+      this.skippingSpaces();
+      if (!this.rightParen()) {
+        throw new Error(SYNTAX_ERROR);
+      }
+      this.nextChar();
+      return cdr;
+    } else {
+      this.state = 0;
+      return new Cons(this.nextToken(), this.parseListAUX());
+    }
+  }
+  /**
+   * Recognizes a quote, wraps the token into a list (Cons), and returns the token number; invoked from NextState.
+   */
+  quote() {
+    const anObject = new Cons(this.nextToken(), Cons.nil);
+    this.token = new Cons(InterpretedSymbol.of("quote"), anObject);
+    return 0;
+  }
+  /**
+   * Returns the token number for a quote or for a 0-origin String-type (pseudo-Character); invoked from NextState.
+   */
+  quoteOrChar() {
+    let aNumber = this.peekChar() === "\\" ? 3 : 2;
+    aNumber = this.peekChar(aNumber) === "'" ? 11 : this.quote();
+    return aNumber;
+  }
+  /**
+   * Detects a right parenthesis (')', ']', '}') and returns the result; invoked from NextState.
+   */
+  rightParen() {
+    return this.peekChar() === ")" || this.peekChar() === "]" || this.peekChar() === "}";
+  }
+  /**
+   * Returns the token number for a sign symbol ('+', '-'); invoked from NextState.
+   */
+  sign() {
+    this.concat();
+    if (this.rightParen()) {
+      this.tokenToSymbol();
+      return 0;
+    }
+    return 7;
+  }
+  /**
+   * Skips whitespace; invoked from NextState.
+   */
+  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();
+    }
+    return null;
+  }
+  /**
+   * Returns the token number for an InterpretedSymbol; invoked from NextState.
+   */
+  symbolToken() {
+    this.concat();
+    if (this.rightParen()) {
+      this.tokenToSymbol();
+      return 0;
+    }
+    return 8;
+  }
+  /**
+   * Converts the token into a 0-origin String-type (pseudo-Character); invoked from NextState.
+   */
+  tokenToCharacter() {
+    this.token = this.tokenString.charAt(0);
+    return null;
+  }
+  /**
+   * Converts the token into a Number-type (double-precision floating point: pseudo-Double); invoked from NextState.
+   */
+  tokenToDouble() {
+    this.token = Number(this.tokenString);
+    return null;
+  }
+  /**
+   * Converts the token into a Number-type (double-precision floating point: pseudo-Double); invoked from NextState.
+   */
+  tokenToDoubleAUX() {
+    this.concat();
+    this.token = Number(this.tokenString);
+    return null;
+  }
+  /**
+   * Converts the token into a Number-type (integer: pseudo-Integer); invoked from NextState.
+   */
+  tokenToInteger() {
+    const aCharacter = this.tokenString[0];
+    if (aCharacter === "+") {
+      this.tokenString = this.tokenString.slice(1);
+    }
+    this.token = Number(this.tokenString);
+    return null;
+  }
+  /**
+   * Converts the token into a String-type; invoked from NextState.
+   */
+  tokenToString() {
+    this.token = this.tokenString;
+    return null;
+  }
+  /**
+   * Converts the token into an InterpretedSymbol; invoked from NextState.
+   */
+  tokenToSymbol() {
+    this.token = InterpretedSymbol.of(this.tokenString);
+    if (this.token === InterpretedSymbol.of("nil")) {
+      this.token = Cons.nil;
+    }
+    return null;
+  }
+  /**
+   * Builds the lookup table that maps character codes to their corresponding methods (tokens).
+   */
+  initializeStateTransitionTable() {
+    let aTable = /* @__PURE__ */ new Map();
+    for (const index of IntStream.rangeClosed(0, 8))
+      aTable.set(String(index), this.nextState(-1, null));
+    for (const index of IntStream.rangeClosed(9, 13))
+      aTable.set(String(index), this.nextState(0, null));
+    for (const index of IntStream.rangeClosed(14, 31))
+      aTable.set(String(index), this.nextState(-1, null));
+    aTable.set(String(32), this.nextState(0, null));
+    aTable.set(String(33), this.nextState(8, "symbolToken"));
+    aTable.set(String(34), this.nextState(9, null));
+    aTable.set(String(35), this.nextState(8, "symbolToken"));
+    aTable.set(String(36), this.nextState(8, "symbolToken"));
+    aTable.set(String(37), this.nextState(8, "symbolToken"));
+    aTable.set(String(38), this.nextState(8, "symbolToken"));
+    aTable.set(String(39), this.nextState(-1, "quoteOrChar"));
+    aTable.set(String(40), this.nextState(-1, "parseList"));
+    aTable.set(String(41), this.nextState(-1, null));
+    aTable.set(String(42), this.nextState(8, "symbolToken"));
+    aTable.set(String(43), this.nextState(7, "sign"));
+    aTable.set(String(44), this.nextState(8, "symbolToken"));
+    aTable.set(String(45), this.nextState(7, "sign"));
+    aTable.set(String(46), this.nextState(-1, null));
+    aTable.set(String(47), this.nextState(8, "symbolToken"));
+    for (const index of IntStream.rangeClosed(48, 57))
+      aTable.set(String(index), this.nextState(2, "integerToken"));
+    for (const index of IntStream.rangeClosed(58, 90))
+      aTable.set(String(index), this.nextState(8, "symbolToken"));
+    aTable.set(String(59), this.nextState(1, null));
+    aTable.set(String(91), this.nextState(-1, "parseList"));
+    aTable.set(String(92), this.nextState(-1, null));
+    aTable.set(String(93), this.nextState(-1, null));
+    aTable.set(String(94), this.nextState(8, "symbolToken"));
+    aTable.set(String(95), this.nextState(8, "symbolToken"));
+    aTable.set(String(96), this.nextState(0, "quote"));
+    for (const index of IntStream.rangeClosed(97, 122))
+      aTable.set(String(index), this.nextState(8, "symbolToken"));
+    aTable.set(String(123), this.nextState(-1, "parseList"));
+    aTable.set(String(124), this.nextState(8, "symbolToken"));
+    aTable.set(String(125), this.nextState(-1, null));
+    aTable.set(String(126), this.nextState(8, "symbolToken"));
+    aTable.set(String(127), this.nextState(-1, null));
+    aTable.set(String(128), this.nextState(-1, null));
+    this.states.set(0, aTable);
+    aTable = /* @__PURE__ */ new Map();
+    for (const index of IntStream.rangeClosed(0, 8))
+      aTable.set(String(index), this.nextState(-1, null));
+    aTable.set(String(10), this.nextState(0, null));
+    aTable.set(String(13), this.nextState(0, null));
+    for (const index of IntStream.rangeClosed(14, 31))
+      aTable.set(String(index), this.nextState(-1, null));
+    aTable.set(String(127), this.nextState(-1, null));
+    aTable.set(String(128), this.nextState(1, null));
+    this.states.set(1, aTable);
+    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(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"));
+    aTable.set(String(101), this.nextState(4, "concat"));
+    aTable.set(String(128), this.nextState(-1, null));
+    this.states.set(2, aTable);
+    aTable = /* @__PURE__ */ new Map();
+    for (const index of IntStream.rangeClosed(9, 13))
+      aTable.set(String(index), this.nextState(0, "tokenToDouble"));
+    aTable.set(String(32), this.nextState(0, "tokenToDouble"));
+    for (const index of IntStream.rangeClosed(48, 57))
+      aTable.set(String(index), this.nextState(3, "doubleToken"));
+    aTable.set(String(68), this.nextState(0, "tokenToDoubleAUX"));
+    aTable.set(String(69), this.nextState(4, "concat"));
+    aTable.set(String(100), this.nextState(0, "tokenToDoubleAUX"));
+    aTable.set(String(101), this.nextState(4, "concat"));
+    aTable.set(String(128), this.nextState(-1, null));
+    this.states.set(3, aTable);
+    aTable = /* @__PURE__ */ new Map();
+    aTable.set(String(43), this.nextState(6, "concat"));
+    aTable.set(String(45), this.nextState(6, "concat"));
+    for (const index of IntStream.rangeClosed(48, 57))
+      aTable.set(String(index), this.nextState(5, "doubleTokenAUX"));
+    aTable.set(String(128), this.nextState(-1, null));
+    this.states.set(4, aTable);
+    aTable = /* @__PURE__ */ new Map();
+    for (const index of IntStream.rangeClosed(9, 13))
+      aTable.set(String(index), this.nextState(0, "tokenToDouble"));
+    aTable.set(String(32), this.nextState(0, "tokenToDouble"));
+    for (const index of IntStream.rangeClosed(48, 57))
+      aTable.set(String(index), this.nextState(5, "doubleTokenAUX"));
+    aTable.set(String(128), this.nextState(-1, null));
+    this.states.set(5, aTable);
+    aTable = /* @__PURE__ */ new Map();
+    for (const index of IntStream.rangeClosed(48, 57))
+      aTable.set(String(index), this.nextState(5, "doubleTokenAUX"));
+    aTable.set(String(128), this.nextState(-1, null));
+    this.states.set(6, aTable);
+    aTable = /* @__PURE__ */ new Map();
+    for (const index of IntStream.rangeClosed(9, 13))
+      aTable.set(String(index), this.nextState(0, "tokenToSymbol"));
+    aTable.set(String(32), this.nextState(0, "tokenToSymbol"));
+    aTable.set(String(33), this.nextState(8, "symbolToken"));
+    for (const index of IntStream.rangeClosed(35, 38))
+      aTable.set(String(index), this.nextState(8, "symbolToken"));
+    for (const index of IntStream.rangeClosed(42, 45))
+      aTable.set(String(index), this.nextState(8, "symbolToken"));
+    aTable.set(String(47), this.nextState(8, "symbolToken"));
+    for (const index of IntStream.rangeClosed(48, 57))
+      aTable.set(String(index), this.nextState(2, "integerToken"));
+    for (const index of IntStream.rangeClosed(58, 90))
+      aTable.set(String(index), this.nextState(8, "symbolToken"));
+    aTable.set(String(94), this.nextState(8, "symbolToken"));
+    aTable.set(String(95), this.nextState(8, "symbolToken"));
+    for (const index of IntStream.rangeClosed(97, 122))
+      aTable.set(String(index), this.nextState(8, "symbolToken"));
+    aTable.set(String(124), this.nextState(8, "symbolToken"));
+    aTable.set(String(126), this.nextState(8, "symbolToken"));
+    aTable.set(String(128), this.nextState(-1, null));
+    this.states.set(7, aTable);
+    aTable = /* @__PURE__ */ new Map();
+    for (const index of IntStream.rangeClosed(9, 13))
+      aTable.set(String(index), this.nextState(0, "tokenToSymbol"));
+    aTable.set(String(32), this.nextState(0, "tokenToSymbol"));
+    aTable.set(String(33), this.nextState(8, "symbolToken"));
+    for (const index of IntStream.rangeClosed(35, 38))
+      aTable.set(String(index), this.nextState(8, "symbolToken"));
+    for (const index of IntStream.rangeClosed(42, 45))
+      aTable.set(String(index), this.nextState(8, "symbolToken"));
+    aTable.set(String(47), this.nextState(8, "symbolToken"));
+    for (const index of IntStream.rangeClosed(48, 57))
+      aTable.set(String(index), this.nextState(8, "symbolToken"));
+    for (const index of IntStream.rangeClosed(58, 90))
+      aTable.set(String(index), this.nextState(8, "symbolToken"));
+    aTable.set(String(94), this.nextState(8, "symbolToken"));
+    aTable.set(String(95), this.nextState(8, "symbolToken"));
+    for (const index of IntStream.rangeClosed(97, 122))
+      aTable.set(String(index), this.nextState(8, "symbolToken"));
+    aTable.set(String(124), this.nextState(8, "symbolToken"));
+    aTable.set(String(126), this.nextState(8, "symbolToken"));
+    aTable.set(String(128), this.nextState(-1, null));
+    this.states.set(8, aTable);
+    aTable = /* @__PURE__ */ new Map();
+    for (const index of IntStream.rangeClosed(0, 31))
+      aTable.set(String(index), this.nextState(-1, null));
+    aTable.set(String(34), this.nextState(0, "tokenToString"));
+    aTable.set(String(92), this.nextState(10, null));
+    aTable.set(String(127), this.nextState(-1, null));
+    aTable.set(String(128), this.nextState(9, "concat"));
+    this.states.set(9, aTable);
+    aTable = /* @__PURE__ */ new Map();
+    for (const index of IntStream.rangeClosed(0, 31))
+      aTable.set(String(index), this.nextState(-1, null));
+    aTable.set(String(127), this.nextState(-1, null));
+    aTable.set(String(128), this.nextState(9, "escapeConcat"));
+    this.states.set(10, aTable);
+    aTable = /* @__PURE__ */ new Map();
+    for (const index of IntStream.rangeClosed(32, 38))
+      aTable.set(String(index), this.nextState(12, "concat"));
+    for (const index of IntStream.rangeClosed(40, 91))
+      aTable.set(String(index), this.nextState(12, "concat"));
+    aTable.set(String(92), this.nextState(13, null));
+    for (const index of IntStream.rangeClosed(93, 126))
+      aTable.set(String(index), this.nextState(12, "concat"));
+    aTable.set(String(128), this.nextState(-1, null));
+    this.states.set(11, aTable);
+    aTable = /* @__PURE__ */ new Map();
+    aTable.set(String(39), this.nextState(0, "tokenToCharacter"));
+    aTable.set(String(128), this.nextState(-1, null));
+    this.states.set(12, aTable);
+    aTable = /* @__PURE__ */ new Map();
+    for (const index of IntStream.rangeClosed(32, 38))
+      aTable.set(String(index), this.nextState(12, "concat"));
+    for (const index of IntStream.rangeClosed(40, 126))
+      aTable.set(String(index), this.nextState(12, "concat"));
+    aTable.set(String(128), this.nextState(-1, null));
+    this.states.set(13, aTable);
+    return null;
+  }
+};
+
+// src/value/Cons/index.ts
+var Cons = class _Cons {
+  static nil = new _Cons();
+  car;
+  cdr;
+  /**
+   * Constructor.
+   * @constructor
+   * @param car the car; defaults to nil when no argument is given.
+   * @param cdr the cdr; defaults to nil when no argument is given.
+   */
+  constructor(car = _Cons.nil, cdr = _Cons.nil) {
+    this.car = car;
+    this.cdr = cdr;
+  }
+  /**
+   * Appends the given element to the end of this Cons.
+   * @param anObject the object to append
+   * @return the Cons with the element appended
+   */
+  add(anObject) {
+    const aCons = new _Cons(anObject, _Cons.nil);
+    return this.nconc(aCons);
+  }
+  /**
+   * Clones this Cons and returns the clone.
+   * @return the cloned Cons
+   */
+  clone() {
+    return new _Cons(_Cons.cloneValue(this.car), _Cons.cloneValue(this.cdr));
+  }
+  /**
+   * Clones the given value (a Cons element) and returns the clone.
+   * @param value a Cons element
+   * @return the cloned element
+   */
+  static cloneValue(value) {
+    if (_Cons.isCons(value)) {
+      return value.clone();
+    }
+    if (_Cons.isNil(value)) {
+      return _Cons.nil;
+    }
+    if (_Cons.isNumber(value)) {
+      return value;
+    }
+    if (_Cons.isString(value)) {
+      return value;
+    }
+    if (_Cons.isSymbol(value)) {
+      return value;
+    }
+    if (_Cons.isTable(value)) {
+      return value;
+    }
+    return value;
+  }
+  /**
+   * Returns whether this Cons equals the given object.
+   * @param anObject the object to compare against
+   * @return a boolean
+   */
+  equals(anObject) {
+    if (_Cons.isCons(anObject)) {
+      return this.equalsAUX(this, anObject);
+    }
+    return false;
+  }
+  /**
+   * Returns whether both arguments are Cons cells and are equal.
+   * @param left the object to compare
+   * @param right the object to compare
+   * @return a boolean
+   */
+  equalsAUX(left, right) {
+    if (left === right) {
+      return true;
+    }
+    if (!(_Cons.isCons(left) && _Cons.isCons(right))) {
+      return false;
+    }
+    if (this.equalsAUX(left.car, right.car)) {
+      return this.equalsAUX(left.cdr, right.cdr);
+    }
+    return false;
+  }
+  /**
+   * Returns whether the given argument is an Atom.
+   */
+  static isAtom(anObject) {
+    return _Cons.isNotCons(anObject);
+  }
+  /**
+   * Returns whether the given argument is a Cons.
+   */
+  static isCons(anObject) {
+    return anObject !== _Cons.nil && anObject instanceof _Cons;
+  }
+  /**
+   * Returns whether the given argument is a List.
+   */
+  static isList(anObject) {
+    return _Cons.isNil(anObject) || _Cons.isCons(anObject);
+  }
+  /**
+   * Returns whether the given argument is Nil.
+   */
+  static isNil(anObject) {
+    return anObject === _Cons.nil;
+  }
+  /**
+   * Returns whether the given argument is not a Cons.
+   */
+  static isNotCons(anObject) {
+    return !_Cons.isCons(anObject);
+  }
+  /**
+   * Returns whether the given argument is not a List.
+   */
+  static isNotList(anObject) {
+    return !_Cons.isList(anObject);
+  }
+  /**
+   * Returns whether the given argument is not Nil.
+   */
+  static isNotNil(anObject) {
+    return !_Cons.isNil(anObject);
+  }
+  /**
+   * Returns whether the given argument is not an interpreted symbol.
+   */
+  static isNotSymbol(anObject) {
+    return !_Cons.isSymbol(anObject);
+  }
+  /**
+   * Returns whether the given argument is a number.
+   */
+  static isNumber(anObject) {
+    return typeof anObject === "number";
+  }
+  /**
+   * Returns whether the given argument is a string.
+   */
+  static isString(anObject) {
+    return typeof anObject === "string";
+  }
+  /**
+   * Returns whether the given argument is an interpreted symbol.
+   */
+  static isSymbol(anObject) {
+    return anObject instanceof InterpretedSymbol;
+  }
+  /**
+   * Returns whether the given argument is an environment.
+   */
+  static isTable(anObject) {
+    return anObject instanceof Table;
+  }
+  /**
+   * Returns the last cell of this Cons.
+   * @return this Cons's last cell
+   */
+  last() {
+    let theCons = new _Cons(_Cons.nil, this);
+    let aCons = this;
+    while (_Cons.isCons(aCons)) {
+      if (!_Cons.isCons(aCons.cdr)) {
+        break;
+      }
+      theCons = theCons.cdr;
+      aCons = aCons.cdr;
+    }
+    return aCons;
+  }
+  /**
+   * Returns an iterator over this Cons.
+   * @return an iterator over this Cons
+   */
+  loop() {
+    return new Loop(this);
+  }
+  /**
+   * Returns the length (depth) of this Cons.
+   * @return the length (depth) of this Cons
+   */
+  length() {
+    let count = 0;
+    let aCons = this;
+    while (_Cons.isCons(aCons)) {
+      count++;
+      aCons = aCons.cdr;
+    }
+    return count;
+  }
+  /**
+   * Concatenates the given Cons and returns this Cons.
+   * @param aCons the Cons to concatenate
+   * @return this Cons
+   */
+  nconc(aCons) {
+    this.last().setCdr(aCons);
+    return this;
+  }
+  /**
+   * Returns the nth element of this Cons.
+   * @param aNumber the index to retrieve
+   * @return the element at the given index
+   */
+  nth(aNumber) {
+    if (aNumber <= 0) {
+      return _Cons.nil;
+    }
+    let count = 1;
+    let aCons = this;
+    while (_Cons.isCons(aCons)) {
+      if (count >= aNumber) {
+        return aCons.car;
+      }
+      count++;
+      aCons = aCons.cdr;
+    }
+    return _Cons.nil;
+  }
+  /**
+   * Lexes the given string into a Cons and returns it.
+   * @param aString the string to lex
+   */
+  static parse(aString) {
+    return Parser.parse(aString);
+  }
+  /**
+   * Sets the car.
+   */
+  setCar(anObject) {
+    this.car = anObject;
+    return null;
+  }
+  /**
+   * Sets the cdr.
+   */
+  setCdr(anObject) {
+    this.cdr = anObject;
+    return null;
+  }
+  /**
+   * Sets both the car and the cdr.
+   */
+  setCons(car, cdr) {
+    this.car = car;
+    this.cdr = cdr;
+    return this;
+  }
+  /**
+   * Returns a formatted string representation of this Cons.
+   */
+  toString() {
+    let aString = "";
+    if (_Cons.isNil(this)) {
+      aString += _Cons.toString(_Cons.nil);
+    } else {
+      aString += "(" + _Cons.toString(this.car);
+      if (_Cons.isNil(this.cdr)) {
+        aString += ")";
+      } else if (this.cdr instanceof _Cons) {
+        let aCons = this.cdr;
+        while (_Cons.isCons(aCons)) {
+          const head = aCons.car;
+          if (!(head instanceof Table)) {
+            aString += " " + _Cons.toString(head);
+          }
+          aCons = aCons.cdr;
+        }
+        aString += _Cons.isNil(aCons) ? ")" : " . " + _Cons.toString(aCons) + ")";
+      } else {
+        aString += " . " + _Cons.toString(this.cdr) + ")";
+      }
+    }
+    return aString;
+  }
+  /**
+   * Returns a formatted string representation of the given object.
+   * @param anObject the object to format
+   */
+  static toString(anObject) {
+    return _Cons.isNil(anObject) ? "nil" : anObject.toString();
+  }
+};
+
+// src/runtime/Evaluator/index.ts
+var import_node_v8 = __toESM(require("v8"), 1);
+var import_node_vm = __toESM(require("vm"), 1);
+
+// src/constants/index.ts
+var cannotApply = (fn, value) => `Can not apply "${fn}" to "${String(value)}"`;
+var notSymbol = (value) => `"${String(value)}" is not symbol`;
+var noBinding = (symbol) => `I could find no variable binding for ${String(symbol)}`;
+var noProcedure = (procedure) => `I could find no procedure description for ${String(procedure)}`;
+var argumentNotSymbol = (position) => `arguments ${String(position)} is not symbol.`;
+var SIZES_DO_NOT_MATCH = "sizes do not match.";
+var SIZE_DO_NOT_MATCH = "size do not match.";
+
+// src/runtime/Applier/index.ts
+var SELECT_PRINT_FUNCTION_NOT_DEFINED = "selectPrintFunction is not defined";
+var Applier = class _Applier {
+  static buildInFunctions = _Applier.setup();
+  static #generateNumber = 0;
+  environment;
+  streamManager;
+  depth;
+  constructor(aTable, aStreamManager, aNumber) {
+    this.environment = new Table(aTable);
+    this.streamManager = aStreamManager;
+    this.depth = aNumber;
+  }
+  abs(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return Math.abs(args2.car);
+    }
+    console.error(cannotApply("abs", args2.car));
+    return Cons.nil;
+  }
+  add(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return this.add_Number(args2.car, args2.cdr);
+    }
+    console.error(cannotApply("add", args2.car));
+    return Cons.nil;
+  }
+  add_Number(init, args2) {
+    let result = init;
+    let aCons = args2;
+    while (Cons.isNotNil(aCons)) {
+      const each = aCons.car;
+      if (Cons.isNumber(each)) {
+        result = result + each;
+      } else {
+        console.error(cannotApply("add", each));
+        return Cons.nil;
+      }
+      aCons = aCons.cdr;
+    }
+    return result;
+  }
+  static apply(procedure, args2, environment, aStreamManager, depth) {
+    return new _Applier(environment, aStreamManager, depth).apply(procedure, args2);
+  }
+  apply(procedure, args2) {
+    if (Cons.isSymbol(procedure)) {
+      return this.selectProcedure(procedure, args2);
+    }
+    return this.entrustEvaluator(procedure, args2);
+  }
+  assoc(args2) {
+    const target = args2.car;
+    if (Cons.isNotCons(args2.nth(2))) {
+      return Cons.nil;
+    }
+    const aCons = args2.nth(2);
+    for (const each of aCons.loop()) {
+      if (Cons.isNotCons(each)) {
+        console.error(cannotApply("assoc", each));
+      }
+      const eachCons = each;
+      const key = eachCons.car;
+      if (this.equal_(new Cons(target, new Cons(key, Cons.nil))) === InterpretedSymbol.of("t")) {
+        return eachCons;
+      }
+    }
+    return Cons.nil;
+  }
+  atom_(args2) {
+    if (Cons.isAtom(args2.car)) {
+      return InterpretedSymbol.of("t");
+    }
+    return Cons.nil;
+  }
+  binding(parameter, args2) {
+    if (Cons.isNil(parameter)) {
+      return null;
+    }
+    let aCons = parameter;
+    let theCons = args2;
+    while (Cons.isNotNil(aCons)) {
+      try {
+        this.environment.set(aCons.car, theCons.car);
+      } catch {
+        console.error(SIZES_DO_NOT_MATCH);
+        return null;
+      }
+      if (Cons.isNotCons(aCons.cdr)) {
+        break;
+      }
+      aCons = aCons.cdr;
+      theCons = theCons.cdr;
+    }
+    if (Cons.isNotList(aCons.cdr) && Cons.isNotNil(aCons.cdr)) {
+      try {
+        this.environment.set(aCons.cdr, theCons.cdr);
+      } catch {
+        console.error(SIZES_DO_NOT_MATCH);
+        return null;
+      }
+    } else if (Cons.isNotNil(aCons.cdr)) {
+      throw new ReferenceError("aList is not defined");
+    }
+    return null;
+  }
+  buildInFunction(procedure, args2) {
+    if (this.isSpy(procedure)) {
+      this.spyPrint(this.streamManager.spyStream(procedure), new Cons(procedure, args2).toString());
+      this.setDepth(this.depth + 1);
+    }
+    const methodName = _Applier.buildInFunctions.get(procedure);
+    const target = this;
+    const fn = target[methodName];
+    if (typeof fn !== "function") {
+      throw new TypeError(`${this.constructor.name} does not have a method named "${methodName}"`);
+    }
+    const answer = fn.apply(target, [args2]);
+    if (this.isSpy(procedure)) {
+      this.setDepth(this.depth - 1);
+      this.spyPrint(
+        this.streamManager.spyStream(procedure),
+        String(answer) + " <== " + new Cons(procedure, args2).toString()
+      );
+    }
+    return answer;
+  }
+  car(args2) {
+    return args2.car.car;
+  }
+  cdr(args2) {
+    return args2.car.cdr;
+  }
+  character_(args2) {
+    if (Cons.isString(args2.car) && args2.car.length === 1) {
+      return InterpretedSymbol.of("t");
+    }
+    return Cons.nil;
+  }
+  cons(args2) {
+    return new Cons(args2.car, args2.nth(2));
+  }
+  cons_(args2) {
+    if (Cons.isCons(args2.car)) {
+      return InterpretedSymbol.of("t");
+    }
+    return Cons.nil;
+  }
+  copy(args2) {
+    return Cons.cloneValue(args2.car);
+  }
+  cos(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return Math.cos(args2.car);
+    }
+    throw new ReferenceError(SELECT_PRINT_FUNCTION_NOT_DEFINED);
+  }
+  divide(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return this.divide_Number(args2.car, args2.cdr);
+    }
+    console.error(cannotApply("divide", args2.car));
+    return Cons.nil;
+  }
+  divide_Number(init, args2) {
+    let result = init;
+    let aCons = args2;
+    while (Cons.isNotNil(aCons)) {
+      const each = aCons.car;
+      if (Cons.isNumber(each)) {
+        result = result / each;
+      } else {
+        console.error(cannotApply("divide", each));
+        return Cons.nil;
+      }
+      aCons = aCons.cdr;
+    }
+    return result;
+  }
+  entrustEvaluator(procedure, args2) {
+    let anObject = Cons.nil;
+    let aCons = procedure.cdr;
+    this.binding(aCons.car, args2);
+    aCons = aCons.cdr;
+    for (const each of aCons.loop()) {
+      if (each instanceof Table) {
+        break;
+      }
+      anObject = Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+    }
+    return anObject;
+  }
+  // NOTE: Implements Common Lisp's eq as JS strict identity (===). Symbols are eq because
+  //       InterpretedSymbol.of interns by name; numbers / strings are eq because JS primitive
+  //       equality is by value; Cons / Table / other objects are eq only when they are the same
+  //       reference. Edge cases: NaN is never eq to itself (matches IEEE 754 and most CL
+  //       implementations); +0 and -0 are eq (CL leaves this implementation-defined).
+  eq_(args2) {
+    const first = args2.car;
+    const second = args2.nth(2);
+    if (first === second) {
+      return InterpretedSymbol.of("t");
+    }
+    return Cons.nil;
+  }
+  equal_(args2) {
+    const first = args2.car;
+    const second = args2.nth(2);
+    if (this.eq_(args2) === InterpretedSymbol.of("t")) {
+      return InterpretedSymbol.of("t");
+    }
+    if (Cons.isCons(first) && Cons.isCons(second)) {
+      if (first.equals(second)) {
+        return InterpretedSymbol.of("t");
+      }
+      if (second.equals(first)) {
+        return InterpretedSymbol.of("t");
+      }
+    }
+    return Cons.nil;
+  }
+  exp(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return Math.exp(args2.car);
+    }
+    throw new ReferenceError(SELECT_PRINT_FUNCTION_NOT_DEFINED);
+  }
+  format(args2) {
+    if (!Cons.isString(args2.car)) {
+      console.error(cannotApply("format", args2.car));
+    }
+    const aCons = args2.cdr;
+    const format = this.format_AUX(String(args2.car), aCons);
+    process.stdout.write(String(format));
+    return Cons.nil;
+  }
+  format_AUX(format, aCons) {
+    let theCons = aCons;
+    let index = 0;
+    let state = 0;
+    let buffer = "";
+    let token = "";
+    while (index < format.length) {
+      const aCharacter = format[index];
+      switch (state) {
+        case 0: {
+          if (aCharacter === "~") {
+            state = 1;
+          } else {
+            buffer += aCharacter;
+          }
+          break;
+        }
+        case 1: {
+          switch (aCharacter) {
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7":
+            case "8":
+            case "9": {
+              token += aCharacter;
+              state = 2;
+              break;
+            }
+            case "a": {
+              buffer += theCons.car.toString();
+              theCons = theCons.cdr;
+              state = 0;
+              break;
+            }
+            case "%": {
+              buffer += "\n";
+              state = 0;
+              break;
+            }
+            case "-": {
+              state = 3;
+              break;
+            }
+            default: {
+              buffer += "~";
+              buffer += aCharacter;
+              state = 0;
+            }
+          }
+          break;
+        }
+        case 2: {
+          switch (aCharacter) {
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7":
+            case "8":
+            case "9": {
+              token += aCharacter;
+              state = 2;
+              break;
+            }
+            case "a": {
+              const size = Number(token);
+              token = "";
+              if (Cons.isNil(theCons)) {
+                console.error(SIZE_DO_NOT_MATCH);
+                return void 0;
+              }
+              let value = theCons.car.toString();
+              theCons = theCons.cdr;
+              while (value.length < size) {
+                value += " ";
+              }
+              buffer += value;
+              state = 0;
+              break;
+            }
+            default: {
+              buffer += "~";
+              buffer += token + aCharacter;
+              token = "";
+              state = 0;
+            }
+          }
+          break;
+        }
+        case 3: {
+          switch (aCharacter) {
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7":
+            case "8":
+            case "9": {
+              token += aCharacter;
+              state = 3;
+              break;
+            }
+            case "a": {
+              const size = Number(token);
+              token = "";
+              if (Cons.isNil(theCons)) {
+                console.error(SIZE_DO_NOT_MATCH);
+                return void 0;
+              }
+              const value = theCons.car.toString();
+              theCons = theCons.cdr;
+              let spaces = "";
+              while (value.length + spaces.length < size) {
+                spaces += " ";
+              }
+              buffer += spaces + value;
+              state = 0;
+              break;
+            }
+            default: {
+              buffer += "~";
+              buffer += "-";
+              buffer += token + aCharacter;
+              token = "";
+              state = 0;
+            }
+          }
+          break;
+        }
+        default: {
+          console.error("Error!");
+        }
+      }
+      index++;
+    }
+    if (Cons.isNotNil(theCons)) {
+      console.error(SIZE_DO_NOT_MATCH);
+      return void 0;
+    }
+    return buffer;
+  }
+  // NOTE: Common Lisp's floatp is a type-tag predicate (integer vs float), but JS has only one
+  //       numeric type (double). The original chose to interpret floatp as a range check
+  //       "is this number representable in IEEE 32-bit (single-precision) float?" rather than a
+  //       type-tag check. Following the original semantics. Revisit if numeric types are split
+  //       in a future revision.
+  float_(args2) {
+    if (Cons.isNumber(args2.car) && -34e37 <= args2.car && args2.car <= 34e37) {
+      return InterpretedSymbol.of("t");
+    }
+    return Cons.nil;
+  }
+  gensym() {
+    const aSymbol = InterpretedSymbol.of("id" + String(_Applier.#generateNumber));
+    _Applier.incrementGenerateNumber();
+    return aSymbol;
+  }
+  getStream(anObject) {
+    if (typeof anObject === "string") {
+      return process.out;
+    }
+    return this.streamManager.getStream();
+  }
+  greaterThan(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return this.greaterThan_Number(args2.car, args2.cdr);
+    }
+    console.error(cannotApply(">", args2.car));
+    return Cons.nil;
+  }
+  greaterThan_Number(init, args2) {
+    let leftValue = init;
+    let aCons = args2;
+    let aBoolean;
+    while (Cons.isNotNil(aCons)) {
+      const rightValue = aCons.car;
+      if (Cons.isNumber(rightValue)) {
+        aBoolean = leftValue > rightValue;
+      } else {
+        console.error(cannotApply(">", rightValue));
+        return Cons.nil;
+      }
+      if (!aBoolean) {
+        return Cons.nil;
+      }
+      leftValue = rightValue;
+      aCons = aCons.cdr;
+    }
+    return InterpretedSymbol.of("t");
+  }
+  greaterThanOrEqual(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return this.greaterThanOrEqual_Number(args2.car, args2.cdr);
+    }
+    console.error(cannotApply(">=", args2.car));
+    return Cons.nil;
+  }
+  greaterThanOrEqual_Number(init, args2) {
+    let leftValue = init;
+    let aCons = args2;
+    let aBoolean;
+    while (Cons.isNotNil(aCons)) {
+      const rightValue = aCons.car;
+      if (Cons.isNumber(rightValue)) {
+        aBoolean = leftValue >= rightValue;
+      } else {
+        console.error(cannotApply(">=", rightValue));
+        return Cons.nil;
+      }
+      if (!aBoolean) {
+        return Cons.nil;
+      }
+      leftValue = rightValue;
+      aCons = aCons.cdr;
+    }
+    return InterpretedSymbol.of("t");
+  }
+  static incrementGenerateNumber() {
+    _Applier.#generateNumber++;
+    return null;
+  }
+  indent() {
+    let index = 0;
+    let aString = "";
+    while (index++ < this.depth) {
+      aString += "| ";
+    }
+    return aString;
+  }
+  integer_(args2) {
+    if (Cons.isNumber(args2.car) && Number.isInteger(args2.car)) {
+      return InterpretedSymbol.of("t");
+    }
+    return Cons.nil;
+  }
+  isSpy(aSymbol) {
+    return this.streamManager.isSpy(aSymbol);
+  }
+  last(args2) {
+    if (Cons.isNotCons(args2)) {
+      return Cons.nil;
+    }
+    const aCons = args2.car;
+    return aCons.last();
+  }
+  lessThan(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return this.lessThan_Number(args2.car, args2.cdr);
+    }
+    console.error(cannotApply("<", args2.car));
+    return Cons.nil;
+  }
+  lessThan_Number(init, args2) {
+    let leftValue = init;
+    let aCons = args2;
+    let aBoolean;
+    while (Cons.isNotNil(aCons)) {
+      const rightValue = aCons.car;
+      if (Cons.isNumber(rightValue)) {
+        aBoolean = leftValue < rightValue;
+      } else {
+        console.error(cannotApply("<", rightValue));
+        return Cons.nil;
+      }
+      if (!aBoolean) {
+        return Cons.nil;
+      }
+      leftValue = rightValue;
+      aCons = aCons.cdr;
+    }
+    return InterpretedSymbol.of("t");
+  }
+  lessThanOrEqual(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return this.lessThanOrEqual_Number(args2.car, args2.cdr);
+    }
+    console.error(cannotApply("<=", args2.car));
+    return Cons.nil;
+  }
+  lessThanOrEqual_Number(init, args2) {
+    let leftValue = init;
+    let aCons = args2;
+    let aBoolean;
+    while (Cons.isNotNil(aCons)) {
+      const rightValue = aCons.car;
+      if (Cons.isNumber(rightValue)) {
+        aBoolean = leftValue <= rightValue;
+      } else {
+        console.error(cannotApply("<=", rightValue));
+        return Cons.nil;
+      }
+      if (!aBoolean) {
+        return Cons.nil;
+      }
+      leftValue = rightValue;
+      aCons = aCons.cdr;
+    }
+    return InterpretedSymbol.of("t");
+  }
+  list(args2) {
+    if (Cons.isNil(args2)) {
+      return Cons.nil;
+    }
+    return new Cons(args2.car, this.list(args2.cdr));
+  }
+  list_(args2) {
+    if (Cons.isList(args2.car)) {
+      return InterpretedSymbol.of("t");
+    }
+    return Cons.nil;
+  }
+  mapcar(args2) {
+    const aCons = new Cons(Cons.nil, Cons.nil);
+    const procedure = args2.car;
+    const parameters = args2.nth(2);
+    const options = args2.cdr.cdr;
+    let theCons = aCons;
+    let index = 1;
+    for (const each of parameters.loop()) {
+      const argumentsCons = new Cons(Cons.nil, Cons.nil);
+      let temporaryCons = argumentsCons;
+      if (Cons.isNotNil(each)) {
+        for (const arg of options.loop()) {
+          if (Cons.isNotCons(arg)) {
+            throw new ReferenceError("consol is not defined");
+          }
+          temporaryCons.setCdr(new Cons(arg.nth(index), Cons.nil));
+          temporaryCons = temporaryCons.cdr;
+        }
+      }
+      argumentsCons.setCar(each);
+      const anObject = _Applier.apply(
+        procedure,
+        argumentsCons,
+        this.environment,
+        this.streamManager,
+        this.depth
+      );
+      theCons.setCdr(new Cons(anObject, Cons.nil));
+      theCons = theCons.cdr;
+      index++;
+    }
+    return aCons.cdr;
+  }
+  member(args2) {
+    let aSymbol = InterpretedSymbol.of("equal?");
+    if (Cons.isNotNil(args2.nth(3))) {
+      aSymbol = args2.nth(3);
+    }
+    if (Cons.isNotCons(args2.nth(2))) {
+      return Cons.nil;
+    }
+    let aCons = args2.nth(2);
+    while (Cons.isCons(aCons)) {
+      let anObject = null;
+      if (aSymbol === InterpretedSymbol.of("eq?")) {
+        anObject = this.eq_(new Cons(args2.car, new Cons(aCons.car, Cons.nil)));
+      }
+      if (aSymbol === InterpretedSymbol.of("equal?")) {
+        anObject = this.equal_(new Cons(args2.car, new Cons(aCons.car, Cons.nil)));
+      }
+      if (anObject == null) {
+        console.error(cannotApply("member", aSymbol));
+      }
+      if (anObject === InterpretedSymbol.of("t")) {
+        return aCons;
+      }
+      aCons = aCons.cdr;
+    }
+    return Cons.nil;
+  }
+  memq(args2) {
+    if (this.member(args2) === Cons.nil) {
+      return Cons.nil;
+    }
+    return InterpretedSymbol.of("t");
+  }
+  mod(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return this.mod_Number(args2.car, args2.cdr);
+    }
+    console.error(cannotApply("mod", args2.car));
+    return Cons.nil;
+  }
+  mod_Number(init, args2) {
+    let result = init;
+    let aCons = args2;
+    while (Cons.isNotNil(aCons)) {
+      const each = aCons.car;
+      if (Cons.isNumber(each)) {
+        result = result % each;
+      } else {
+        console.error(cannotApply("mod", each));
+        return Cons.nil;
+      }
+      aCons = aCons.cdr;
+    }
+    return result;
+  }
+  multiply(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return this.multiply_Number(args2.car, args2.cdr);
+    }
+    console.error(cannotApply("multiply", args2.car));
+    return Cons.nil;
+  }
+  multiply_Number(init, args2) {
+    let result = init;
+    let aCons = args2;
+    while (Cons.isNotNil(aCons)) {
+      const each = aCons.car;
+      if (Cons.isNumber(each)) {
+        result = result * each;
+      } else {
+        console.error(cannotApply("multiply", each));
+        return Cons.nil;
+      }
+      aCons = aCons.cdr;
+    }
+    return result;
+  }
+  napier() {
+    return Math.E;
+  }
+  neq(args2) {
+    if (this.eq_(args2) === InterpretedSymbol.of("t")) {
+      return Cons.nil;
+    }
+    return InterpretedSymbol.of("t");
+  }
+  nequal(args2) {
+    if (this.equal_(args2) === InterpretedSymbol.of("t")) {
+      return Cons.nil;
+    }
+    return InterpretedSymbol.of("t");
+  }
+  nth(args2) {
+    if (!Number.isInteger(args2.car)) {
+      return Cons.nil;
+    }
+    const index = args2.car;
+    const aCons = args2.nth(2);
+    return aCons.nth(index);
+  }
+  null_(args2) {
+    if (Cons.isNil(args2.car)) {
+      return InterpretedSymbol.of("t");
+    }
+    return Cons.nil;
+  }
+  // NOTE: Lisp's numberp and doublep are originally distinct predicates, but because JS has only
+  //       one numeric type (double), we share a single implementation. In Applier.setup() both
+  //       Lisp function names numberp / doublep map to this method. Split into separate methods if
+  //       a future revision introduces additional numeric types such as BigInt.
+  number_(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return InterpretedSymbol.of("t");
+    }
+    return Cons.nil;
+  }
+  pi() {
+    return Math.PI;
+  }
+  random() {
+    return Math.random();
+  }
+  round(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return Math.round(args2.car);
+    }
+    throw new ReferenceError(SELECT_PRINT_FUNCTION_NOT_DEFINED);
+  }
+  selectProcedure(procedure, args2) {
+    if (_Applier.buildInFunctions.has(procedure)) {
+      return this.buildInFunction(procedure, args2);
+    }
+    if (this.environment.has(procedure)) {
+      return this.userFunction(procedure, args2);
+    }
+    console.error(noProcedure(procedure));
+    return Cons.nil;
+  }
+  setDepth(aNumber) {
+    this.depth = aNumber;
+    return null;
+  }
+  static setup() {
+    try {
+      const entries = [
+        ["abs", "abs"],
+        ["add", "add"],
+        ["assoc", "assoc"],
+        ["atom", "atom_"],
+        ["car", "car"],
+        ["cdr", "cdr"],
+        ["characterp", "character_"],
+        ["cons", "cons"],
+        ["consp", "cons_"],
+        ["copy", "copy"],
+        ["cos", "cos"],
+        ["floatp", "float_"],
+        ["divide", "divide"],
+        ["doublep", "number_"],
+        ["eq", "eq_"],
+        ["equal", "equal_"],
+        ["exp", "exp"],
+        ["format", "format"],
+        ["gensym", "gensym"],
+        ["integerp", "integer_"],
+        ["last", "last"],
+        ["list", "list"],
+        ["listp", "list_"],
+        ["mapcar", "mapcar"],
+        ["member", "member"],
+        ["memq", "memq"],
+        ["mod", "mod"],
+        ["multiply", "multiply"],
+        ["napier", "napier"],
+        ["neq", "neq"],
+        ["nequal", "nequal"],
+        ["nth", "nth"],
+        ["null", "null_"],
+        ["numberp", "number_"],
+        ["pi", "pi"],
+        ["random", "random"],
+        ["round", "round"],
+        ["sin", "sin"],
+        ["sqrt", "sqrt"],
+        ["subtract", "subtract"],
+        ["stringp", "string_"],
+        ["symbolp", "symbol_"],
+        ["tan", "tan"],
+        ["+", "add"],
+        ["-", "subtract"],
+        ["*", "multiply"],
+        ["/", "divide"],
+        ["//", "mod"],
+        ["==", "eq_"],
+        ["=", "equal_"],
+        ["~~", "neq"],
+        ["~=", "nequal"],
+        ["<", "lessThan"],
+        ["<=", "lessThanOrEqual"],
+        [">", "greaterThan"],
+        [">=", "greaterThanOrEqual"]
+      ];
+      return new Map(entries.map(([key, value]) => [InterpretedSymbol.of(key), value]));
+    } catch {
+      throw new Error("NullPointerException (Applier, initialize)");
+    }
+  }
+  sin(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return Math.sin(args2.car);
+    }
+    throw new ReferenceError(SELECT_PRINT_FUNCTION_NOT_DEFINED);
+  }
+  // NOTE: Lisp's trace/spy writes the call line to a designated output stream. The original
+  //       implementation logged the stream object itself rather than writing to it (a bug that
+  //       went unnoticed because trace/spy is rarely exercised). We now write the indented line
+  //       to the given WritableStream, falling back to stdout when the argument is a string
+  //       descriptor (stored by `(spy fn "label")`) or null.
+  spyPrint(aStream, line) {
+    const target = aStream != null && typeof aStream === "object" && "write" in aStream ? aStream : process.stdout;
+    target.write(this.indent() + line + "\n");
+    return null;
+  }
+  sqrt(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return Math.sqrt(args2.car);
+    }
+    throw new ReferenceError(SELECT_PRINT_FUNCTION_NOT_DEFINED);
+  }
+  string_(args2) {
+    if (Cons.isString(args2.car)) {
+      return InterpretedSymbol.of("t");
+    }
+    return Cons.nil;
+  }
+  subtract(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return this.subtract_Number(args2.car, args2.cdr);
+    }
+    console.error(cannotApply("subtract", args2.car));
+    return Cons.nil;
+  }
+  subtract_Number(init, args2) {
+    let result = init;
+    let aCons = args2;
+    while (Cons.isNotNil(aCons)) {
+      const each = aCons.car;
+      if (Cons.isNumber(each)) {
+        result = result - each;
+      } else {
+        console.error(cannotApply("subtract", each));
+        return Cons.nil;
+      }
+      aCons = aCons.cdr;
+    }
+    return result;
+  }
+  symbol_(args2) {
+    if (Cons.isSymbol(args2.car)) {
+      return InterpretedSymbol.of("t");
+    }
+    return Cons.nil;
+  }
+  tan(args2) {
+    if (Cons.isNumber(args2.car)) {
+      return Math.tan(args2.car);
+    }
+    throw new ReferenceError(SELECT_PRINT_FUNCTION_NOT_DEFINED);
+  }
+  userFunction(procedure, args2) {
+    if (this.isSpy(procedure)) {
+      this.spyPrint(this.streamManager.spyStream(procedure), new Cons(procedure, args2).toString());
+      this.setDepth(this.depth + 1);
+    }
+    const lambda = this.environment.get(procedure);
+    const theEnvironment = lambda.last().car;
+    const answer = _Applier.apply(lambda, args2, theEnvironment, this.streamManager, this.depth);
+    if (this.isSpy(procedure)) {
+      this.setDepth(this.depth - 1);
+      this.spyPrint(
+        this.streamManager.spyStream(procedure),
+        String(answer) + " <== " + new Cons(procedure, args2).toString()
+      );
+    }
+    return answer;
+  }
+};
+
+// src/runtime/ExitError/index.ts
+var ExitError = class extends Error {
+  /**
+   * Constructor.
+   * @constructor
+   */
+  constructor() {
+    super("Exit");
+    this.name = "ExitError";
+  }
+};
+
+// src/runtime/StreamManager/index.ts
+var StreamManager = class {
+  isTrace = false;
+  streamTable;
+  spyTable;
+  traceStream;
+  constructor() {
+    this.streamTable = /* @__PURE__ */ new Map();
+    this.spyTable = /* @__PURE__ */ new Map();
+    this.traceStream = null;
+    this.initialize();
+  }
+  getStream() {
+    let aPrintStream = null;
+    if (this.isTrace) {
+      return this.traceStream();
+    }
+    const filePath = process.env["HOME"];
+    if (this.streamTable.has(filePath)) {
+      aPrintStream = this.streamTable.get(filePath) ?? null;
+    }
+    return aPrintStream;
+  }
+  /**
+   * Initializes the instance variables.
+   */
+  initialize() {
+    this.streamTable.set("default", process.stdout);
+    this.streamTable.set("stdout", process.stdout);
+    this.streamTable.set("stderr", process.stderr);
+    return null;
+  }
+  isSpy(aSymbol) {
+    if (this.isTrace) {
+      return true;
+    }
+    if (aSymbol != null && this.spyTable_().has(aSymbol)) {
+      return true;
+    }
+    return false;
+  }
+  noSpy(aSymbol) {
+    if (this.spyTable_().has(aSymbol)) {
+      this.spyTable_().delete(aSymbol);
+    }
+    return null;
+  }
+  noTrace() {
+    this.setIsTrace(false);
+    this.spyTable.clear();
+    return null;
+  }
+  setIsTrace(aBoolean) {
+    this.isTrace = aBoolean;
+    return null;
+  }
+  setTraceStream(aStream) {
+    this.traceStream = aStream;
+    return null;
+  }
+  spy(aSymbol, aString) {
+    const aPrintStream = this.getStream();
+    if (aPrintStream != null) {
+      this.spyTable_().set(aSymbol, aString);
+    }
+    return null;
+  }
+  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.");
+  }
+  spyTable_() {
+    const aTable = /* @__PURE__ */ new Map();
+    for (const [key, value] of this.spyTable) {
+      aTable.set(key, value);
+    }
+    return aTable;
+  }
+  trace() {
+    this.noTrace();
+    const aPrintStream = this.getStream();
+    this.setTraceStream(aPrintStream);
+    this.setIsTrace(true);
+    return null;
+  }
+};
+
+// src/runtime/Evaluator/index.ts
+var cachedGc = null;
+var triggerGc = () => {
+  if (cachedGc == null) {
+    import_node_v8.default.setFlagsFromString("--expose_gc");
+    cachedGc = import_node_vm.default.runInNewContext("gc");
+  }
+  cachedGc();
+};
+var Evaluator = class _Evaluator {
+  static buildInFunctions = _Evaluator.setup();
+  environment;
+  streamManager;
+  depth;
+  constructor(aTable, aStreamManager, aNumber) {
+    this.environment = aTable;
+    this.streamManager = aStreamManager;
+    this.depth = aNumber;
+  }
+  and(aCons) {
+    for (const each of aCons.loop()) {
+      const anObject = _Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+      if (Cons.isNil(anObject)) {
+        return Cons.nil;
+      }
+    }
+    return InterpretedSymbol.of("t");
+  }
+  apply_lisp(aCons) {
+    const procedure = _Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
+    const args2 = _Evaluator.eval(aCons.nth(2), this.environment, this.streamManager, this.depth);
+    let aTable = this.environment;
+    if (procedure instanceof Cons && procedure.last().car instanceof Table) {
+      aTable = procedure.last().car;
+    }
+    return Applier.apply(procedure, args2, aTable, this.streamManager, this.depth);
+  }
+  bind(aCons) {
+    if (Cons.isNotSymbol(aCons.car)) {
+      console.error(cannotApply("bind", aCons.car));
+      return Cons.nil;
+    }
+    const aSymbol = aCons.car;
+    if (!this.environment.has(aSymbol)) {
+      return Cons.nil;
+    }
+    return this.bindAUX(aSymbol);
+  }
+  bindAUX(aSymbol) {
+    let aTable = this.environment;
+    let anObject = aTable.get(aSymbol);
+    let count = 1;
+    while (aTable != null) {
+      if (!aTable.has(aSymbol)) {
+        break;
+      }
+      const theObject = aTable.get(aSymbol);
+      if (theObject != anObject) {
+        count++;
+        anObject = theObject;
+      }
+      aTable = aTable.source;
+    }
+    return count;
+  }
+  binding(parameters, aTable) {
+    for (const each of parameters.loop()) {
+      const theCons = each;
+      let key = null;
+      if (Cons.isSymbol(theCons.car)) {
+        key = theCons.car;
+      } else {
+        console.error(notSymbol(theCons.car));
+      }
+      const value = _Evaluator.eval(theCons.nth(2), aTable, this.streamManager, this.depth);
+      aTable.set(key, value);
+    }
+    return null;
+  }
+  bindingParallel(parameters, aTable) {
+    const theTable = /* @__PURE__ */ new Map();
+    for (const each of parameters.loop()) {
+      const theCons = each;
+      let key = null;
+      if (Cons.isSymbol(theCons.car)) {
+        key = theCons.car;
+      } else {
+        console.error(notSymbol(theCons.car));
+      }
+      const value = _Evaluator.eval(theCons.nth(2), aTable, this.streamManager, this.depth);
+      theTable.set(key, value);
+    }
+    for (const [key, value] of theTable) {
+      aTable.set(key, value);
+    }
+    return null;
+  }
+  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
+    );
+    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);
+    }
+    return anObject;
+  }
+  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);
+    this.environment.set(variable, lambda);
+    return variable;
+  }
+  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))) {
+      const theTable = /* @__PURE__ */ new Map();
+      for (const each of expressions.loop()) {
+        _Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+      }
+      for (const each of parameters.loop()) {
+        const theCons = each;
+        if (Cons.isNotSymbol(theCons.car)) {
+          console.error(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
+          );
+          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);
+  }
+  doList(aCons) {
+    const parameter = aCons.car;
+    const theCons = aCons.cdr;
+    const args2 = _Evaluator.eval(
+      parameter.nth(2),
+      this.environment,
+      this.streamManager,
+      this.depth
+    );
+    for (const element of args2.loop()) {
+      this.environment.set(parameter.car, element);
+      for (const each of theCons.loop()) {
+        _Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+      }
+    }
+    return _Evaluator.eval(parameter.nth(3), this.environment, this.streamManager, this.depth);
+  }
+  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);
+      }
+      for (const each of parameters.loop()) {
+        const theCons = each;
+        if (Cons.isNotSymbol(theCons.car)) {
+          console.error(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
+          );
+          this.environment.set(key, value);
+        }
+      }
+    }
+    return _Evaluator.eval(bool.nth(2), this.environment, this.streamManager, this.depth);
+  }
+  entrustApplier(form) {
+    const aCons = form.cdr;
+    let args2 = new Cons(Cons.nil, Cons.nil);
+    const procedure = form.car;
+    let aSymbol = null;
+    if (Cons.isSymbol(procedure)) {
+      aSymbol = procedure;
+    }
+    if (this.isSpy(aSymbol)) {
+      this.spyPrint(this.streamManager.spyStream(aSymbol), form.toString());
+      this.setDepth(this.depth + 1);
+    }
+    for (const each of aCons.loop()) {
+      if (each instanceof Table) {
+        break;
+      }
+      args2.add(_Evaluator.eval(each, this.environment, this.streamManager, this.depth));
+    }
+    if (this.isSpy(aSymbol)) {
+      this.setDepth(this.depth - 1);
+    }
+    args2 = args2.cdr;
+    return Applier.apply(procedure, args2, this.environment, this.streamManager, this.depth);
+  }
+  static eval(form, environment, aStreamManager = new StreamManager(), depth = 1) {
+    return new _Evaluator(environment, aStreamManager, depth).eval(form);
+  }
+  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);
+    }
+    return this.entrustApplier(formCons);
+  }
+  eval_lisp(aCons) {
+    return _Evaluator.eval(
+      _Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth),
+      this.environment,
+      this.streamManager,
+      this.depth
+    );
+  }
+  evaluateSymbol(aSymbol) {
+    let answer = Cons.nil;
+    if (this.environment.has(aSymbol)) {
+      if (this.isSpy(aSymbol)) {
+        this.spyPrint(this.streamManager.spyStream(aSymbol), aSymbol.toString());
+        this.setDepth(this.depth + 1);
+      }
+      answer = this.environment.get(aSymbol);
+      if (answer instanceof Cons && answer.cdr instanceof Table) {
+        answer = answer.car;
+      }
+      if (this.isSpy(aSymbol)) {
+        this.setDepth(this.depth - 1);
+        this.spyPrint(
+          this.streamManager.spyStream(aSymbol),
+          String(answer) + " <== " + String(aSymbol)
+        );
+      }
+    } else {
+      console.error(noBinding(aSymbol));
+    }
+    return answer;
+  }
+  exit() {
+    console.log("Bye!");
+    throw new ExitError();
+  }
+  gc() {
+    triggerGc();
+    return InterpretedSymbol.of("t");
+  }
+  if_(aCons) {
+    const bool = _Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
+    const anObject = Cons.isNil(bool) ? aCons.nth(3) : aCons.nth(2);
+    return _Evaluator.eval(anObject, this.environment, this.streamManager, this.depth);
+  }
+  indent() {
+    let index = 0;
+    let aString = "";
+    while (index++ < this.depth) {
+      aString += "| ";
+    }
+    return aString;
+  }
+  isSpy(aSymbol) {
+    if (aSymbol == null) {
+      return false;
+    }
+    return this.streamManager.isSpy(aSymbol);
+  }
+  lambda(args2) {
+    const aCons = Cons.cloneValue(args2);
+    const theCons = aCons.cdr;
+    theCons.setCdr(new Cons(this.environment, Cons.nil));
+    return new Cons(InterpretedSymbol.of("lambda"), aCons);
+  }
+  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);
+    }
+    return anObject;
+  }
+  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);
+    }
+    return anObject;
+  }
+  not(aCons) {
+    if (Cons.isNil(_Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth))) {
+      return InterpretedSymbol.of("t");
+    }
+    return Cons.nil;
+  }
+  notrace() {
+    this.streamManager.noTrace();
+    return InterpretedSymbol.of("t");
+  }
+  or(aCons) {
+    for (const each of aCons.loop()) {
+      const anObject = _Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+      if (Cons.isNotNil(anObject)) {
+        return InterpretedSymbol.of("t");
+      }
+    }
+    return Cons.nil;
+  }
+  pop_(aCons) {
+    if (Cons.isNotSymbol(aCons.car)) {
+      console.error(argumentNotSymbol(1));
+    }
+    const aSymbol = aCons.car;
+    const anObject = _Evaluator.eval(aSymbol, this.environment, this.streamManager, this.depth);
+    if (Cons.isNotCons(anObject)) {
+      return Cons.nil;
+    }
+    const consObject = anObject;
+    this.environment.setIfExist(aSymbol, consObject.cdr);
+    return consObject.car;
+  }
+  progn(aCons) {
+    let anObject = Cons.nil;
+    for (const each of aCons.loop()) {
+      anObject = _Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+    }
+    return anObject;
+  }
+  princ(aCons) {
+    const anObject = _Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
+    process.stdout.write(String(anObject));
+    return anObject;
+  }
+  print(aCons) {
+    const anObject = _Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
+    process.stdout.write(String(anObject) + "\n");
+    return anObject;
+  }
+  push_(aCons) {
+    let anObject = _Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
+    if (Cons.isNotSymbol(aCons.nth(2))) {
+      console.error(argumentNotSymbol(2));
+    }
+    const aSymbol = aCons.nth(2);
+    anObject = new Cons(
+      anObject,
+      _Evaluator.eval(aSymbol, this.environment, this.streamManager, this.depth)
+    );
+    this.environment.setIfExist(aSymbol, anObject);
+    return anObject;
+  }
+  quote(aCons) {
+    return aCons.car;
+  }
+  rplaca(args2) {
+    let anObject = _Evaluator.eval(args2.car, this.environment, this.streamManager, this.depth);
+    if (Cons.isNotCons(anObject)) {
+      console.error(cannotApply("set-car!", anObject));
+      return Cons.nil;
+    }
+    const aCons = anObject;
+    anObject = _Evaluator.eval(args2.nth(2), this.environment, this.streamManager, this.depth);
+    aCons.setCar(anObject);
+    return _Evaluator.eval(args2.car, this.environment, this.streamManager, this.depth);
+  }
+  rplacd(args2) {
+    let anObject = _Evaluator.eval(args2.car, this.environment, this.streamManager, this.depth);
+    if (Cons.isNotCons(anObject)) {
+      console.error(cannotApply("set-cdr!", anObject));
+      return Cons.nil;
+    }
+    const aCons = anObject;
+    anObject = _Evaluator.eval(args2.nth(2), this.environment, this.streamManager, this.depth);
+    aCons.setCdr(anObject);
+    return _Evaluator.eval(args2.car, this.environment, this.streamManager, this.depth);
+  }
+  setq(args2) {
+    let anObject = Cons.nil;
+    const anIterator = args2.loop();
+    const index = -1;
+    while (anIterator.hasNext()) {
+      let key = null;
+      if (Cons.isSymbol(args2.nth(index + 2))) {
+        key = anIterator.next();
+      } else {
+        console.error(notSymbol(args2.car));
+      }
+      if (!anIterator.hasNext()) {
+        console.error(SIZES_DO_NOT_MATCH);
+      }
+      anObject = _Evaluator.eval(
+        anIterator.next(),
+        this.environment,
+        this.streamManager,
+        this.depth
+      );
+      this.environment.set(key, anObject);
+    }
+    return anObject;
+  }
+  set_allq(args2) {
+    let anObject = Cons.nil;
+    const anIterator = args2.loop();
+    const index = -1;
+    while (anIterator.hasNext()) {
+      let key = null;
+      if (Cons.isSymbol(args2.nth(index + 2))) {
+        key = anIterator.next();
+      } else {
+        console.error(notSymbol(args2.car));
+      }
+      anObject = _Evaluator.eval(
+        anIterator.next(),
+        this.environment,
+        this.streamManager,
+        this.depth
+      );
+      this.environment.setIfExist(key, anObject);
+    }
+    return anObject;
+  }
+  setDepth(aNumber) {
+    this.depth = aNumber;
+    return null;
+  }
+  static setup() {
+    try {
+      const entries = [
+        ["and", "and"],
+        ["apply", "apply_lisp"],
+        ["bind", "bind"],
+        ["cond", "cond"],
+        ["defun", "defun"],
+        ["do", "do_"],
+        ["dolist", "doList"],
+        ["do*", "doStar"],
+        ["eval", "eval_lisp"],
+        ["exit", "exit"],
+        ["gc", "gc"],
+        ["if", "if_"],
+        ["lambda", "lambda"],
+        ["let", "let"],
+        ["let*", "letStar"],
+        ["not", "not"],
+        ["notrace", "notrace"],
+        ["or", "or"],
+        ["pop", "pop_"],
+        ["progn", "progn"],
+        ["princ", "princ"],
+        ["print", "print"],
+        ["push", "push_"],
+        ["quote", "quote"],
+        ["rplaca", "rplaca"],
+        ["rplacd", "rplacd"],
+        ["setq", "setq"],
+        ["set-allq", "set_allq"],
+        ["terpri", "terpri"],
+        ["time", "time"],
+        ["trace", "trace"],
+        ["unless", "unless"],
+        ["when", "when"]
+      ];
+      return new Map(entries.map(([key, value]) => [InterpretedSymbol.of(key), value]));
+    } catch {
+      throw new Error("NullPointerException (Evaluator, initialize)");
+    }
+  }
+  specialForm(form) {
+    const aSymbol = form.car;
+    if (this.isSpy(aSymbol)) {
+      this.spyPrint(this.streamManager.spyStream(aSymbol), form.toString());
+      this.setDepth(this.depth + 1);
+    }
+    const aCons = form.cdr;
+    const methodName = _Evaluator.buildInFunctions.get(aSymbol);
+    const target = this;
+    const fn = target[methodName];
+    if (typeof fn !== "function") {
+      throw new TypeError(`${this.constructor.name} does not have a method named "${methodName}"`);
+    }
+    const answer = fn.apply(target, [aCons]);
+    if (this.isSpy(aSymbol)) {
+      this.setDepth(this.depth - 1);
+      this.spyPrint(
+        this.streamManager.spyStream(aSymbol),
+        String(answer) + " <== " + String(aSymbol)
+      );
+    }
+    return answer;
+  }
+  // NOTE: Lisp's trace/spy writes the call line to a designated output stream. The original
+  //       implementation logged the stream object itself rather than writing to it (a bug that
+  //       went unnoticed because trace/spy is rarely exercised). We now write the indented line
+  //       to the given WritableStream, falling back to stdout when the argument is a string
+  //       descriptor (stored by `(spy fn "label")`) or null.
+  spyPrint(aStream, line) {
+    const target = aStream != null && typeof aStream === "object" && "write" in aStream ? aStream : process.stdout;
+    target.write(this.indent() + line + "\n");
+    return null;
+  }
+  terpri() {
+    process.stdout.write("\n");
+    return InterpretedSymbol.of("t");
+  }
+  time(aCons) {
+    const start = process.hrtime();
+    _Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
+    const end = process.hrtime(start);
+    return end[1] / 1e6;
+  }
+  trace() {
+    this.streamManager.trace();
+    return InterpretedSymbol.of("t");
+  }
+  unless(aCons) {
+    let anObject = Cons.nil;
+    const theCons = aCons.cdr;
+    const flag = _Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
+    if (Cons.isNotNil(flag)) {
+      return Cons.nil;
+    }
+    for (const each of theCons.loop()) {
+      anObject = _Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+    }
+    return anObject;
+  }
+  when(aCons) {
+    let anObject = Cons.nil;
+    const theCons = aCons.cdr;
+    const flag = _Evaluator.eval(aCons.car, this.environment, this.streamManager, this.depth);
+    if (Cons.isNil(flag)) {
+      return Cons.nil;
+    }
+    for (const each of theCons.loop()) {
+      anObject = _Evaluator.eval(each, this.environment, this.streamManager, this.depth);
+    }
+    return anObject;
+  }
+};
+
+// src/LispInterpreter/index.ts
+var require2 = (0, import_node_module.createRequire)(importMetaUrl);
+var LispInterpreter = class {
+  root;
+  streamManager;
+  rl;
+  constructor() {
+    this.root = this.initializeTable();
+    this.streamManager = new StreamManager();
+    const readline = require2("node:readline");
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: ">> "
+    });
+  }
+  /**
+   * Starts the interpreter.
+   */
+  run() {
+    let aCons = new Cons();
+    let aString = "";
+    let leftParentheses = 0;
+    let exitedViaLisp = false;
+    this.rl.prompt();
+    this.rl.on("line", (line) => {
+      line += " ";
+      for (const aCharacter of line) {
+        if (aCharacter === "(") {
+          leftParentheses++;
+        }
+        if (aCharacter === ")") {
+          leftParentheses--;
+        }
+        aString += aCharacter;
+      }
+      if (leftParentheses <= 0) {
+        aCons = this.parse(aString);
+        try {
+          for (const each of aCons.loop()) {
+            process.stdout.write(this.eval(each).toString() + "\n");
+          }
+        } catch (error) {
+          if (error instanceof ExitError) {
+            exitedViaLisp = true;
+            this.rl.close();
+            return;
+          }
+          console.error("*** can not eval " + aCons.toString() + " ***");
+          process.stdout.write(Cons.nil.toString() + "\n");
+        }
+        leftParentheses = 0;
+        aString = "";
+        this.rl.prompt();
+      }
+    }).on("close", () => {
+      if (!exitedViaLisp) {
+        console.log("\nBye!");
+      }
+    });
+    return null;
+  }
+  /**
+   * Evaluates the given list and returns the evaluation result.
+   */
+  eval(aCons) {
+    try {
+      return Evaluator.eval(aCons, this.root, this.streamManager);
+    } catch (error) {
+      if (error instanceof ExitError) throw error;
+      console.error("*** can not eval " + aCons.toString() + " ***");
+      return Cons.nil;
+    }
+  }
+  /**
+   * Parses the source string, evaluates every expression it contains, and returns the results as an array.
+   */
+  evalAll(source) {
+    const ast = this.parse(source);
+    const results = [];
+    if (Cons.isCons(ast)) {
+      for (const expr of ast.loop()) {
+        results.push(this.eval(expr));
+      }
+    }
+    return results;
+  }
+  /**
+   * Parses and evaluates the source string and returns the value of the last expression.
+   */
+  evalString(source) {
+    const results = this.evalAll(source);
+    return results.length === 0 ? Cons.nil : results.at(-1) ?? Cons.nil;
+  }
+  /**
+   * Parses the given string into a list and returns it.
+   */
+  parse(aString) {
+    try {
+      return Cons.parse("(" + aString + "\n);");
+    } catch {
+      console.error("*** can not parse " + aString.replaceAll("\n", "") + " ***");
+      return Cons.nil;
+    }
+  }
+  /**
+   * Sets the given environment as the root of the environment chain.
+   */
+  setRoot(environment) {
+    if (environment instanceof Table) {
+      environment.setRoot(true);
+      this.root = environment;
+    }
+    return null;
+  }
+  /**
+   * Initializes the environment table.
+   */
+  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",
+      "+",
+      "-",
+      "*",
+      "/",
+      "//",
+      "=",
+      "==",
+      "~=",
+      "~~",
+      "<",
+      "<=",
+      ">",
+      ">="
+    );
+    for (const each of aList) {
+      const aSymbol = InterpretedSymbol.of(each);
+      aTable.set(aSymbol, aSymbol);
+    }
+    let aString;
+    let aCons;
+    aString = "(lambda (list1 list2) (cond ((null (listp list1)) nil) ((null (listp list2)) nil) ((null list1) list2) (t (cons (car list1) (append (cdr list1) list2)))))";
+    aCons = Cons.parse(aString);
+    aCons.last().setCdr(new Cons(aTable, Cons.nil));
+    aTable.set(InterpretedSymbol.of("append"), aCons);
+    aString = "(lambda (l n) (cond ((<= (length l) n) nil) (t (cons (car l) (butlast (cdr l) n)))))";
+    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));
+    aTable.set(InterpretedSymbol.of("nthcdr"), aCons);
+    aString = "(lambda (l) (cond ((null (listp l)) l) ((null l) '()) (t (append (reverse (cdr l)) (list (car l))))))";
+    aCons = Cons.parse(aString);
+    aCons.last().setCdr(new Cons(aTable, Cons.nil));
+    aTable.set(InterpretedSymbol.of("reverse"), aCons);
+    aTable.set(InterpretedSymbol.of("t"), InterpretedSymbol.of("t"));
+    return aTable;
+  }
+};
+
+// src/cli.ts
+var HELP_MESSAGE = `Usage: kei-lisp [options]
+
+Options:
+  -v, --version  Show version number
+  -h, --help     Show help`;
+var args = process.argv.slice(2);
+if (args.includes("--version") || args.includes("-v")) {
+  console.log(`kei-lisp v${package_default.version}`);
+} else if (args.includes("--help") || args.includes("-h")) {
+  console.log(HELP_MESSAGE);
+} else if (args.length > 0) {
+  console.error(`kei-lisp: unknown argument: ${args[0]}`);
+  console.error(HELP_MESSAGE);
+  process.exitCode = 1;
+} else {
+  new LispInterpreter().run();
+}