npm - fez-lisp - Versions diffs - 1.0.51 → 1.0.52 - Mend

fez-lisp 1.0.51 → 1.0.52

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/index.js +3 -3
package/package.json +1 -1
package/src/compiler.js +1 -1
package/src/evaluator.js +43 -0
package/src/interpreter.js +1129 -34
package/src/parser.js +1 -1
package/src/utils.js +2 -2
package/src/tokeniser.js +0 -1145
/package/src/{enums.js → keywords.js} +0 -0

package/src/tokeniser.js DELETED Viewed

@@ -1,1145 +0,0 @@
-import std from '../lib/baked/std.js'
-import { TYPE, VALUE, WORD, KEYWORDS, APPLY } from './enums.js'
-import { evaluate, isAtom } from './interpreter.js'
-import { LISP } from './parser.js'
-import {
-  isEqual,
-  isEqualTypes,
-  isForbiddenVariableName,
-  stringifyArgs
-} from './utils.js'
-const keywords = {
-  [KEYWORDS.CONCATENATION]: (args, env) => {
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.CONCATENATION
-        }), expected > 1 but got ${args.length}. (${
-          KEYWORDS.CONCATENATION
-        } ${stringifyArgs(args)})`
-      )
-    const operands = args.map((x) => evaluate(x, env))
-    if (operands.some((x) => typeof x !== 'string'))
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.CONCATENATION}) are (${
-          KEYWORDS.STRING_TYPE
-        }) (${KEYWORDS.CONCATENATION} ${stringifyArgs(args)})`
-      )
-    return operands.reduce((a, b) => a + b, '')
-  },
-  [KEYWORDS.REMAINDER_OF_DIVISION]: (args, env) => {
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.REMAINDER_OF_DIVISION
-        }), expected > 1 but got ${args.length}. (${
-          KEYWORDS.REMAINDER_OF_DIVISION
-        } ${stringifyArgs(args)})`
-      )
-    const [a, b] = args.map((x) => evaluate(x, env))
-    if (typeof a !== 'number' || typeof b !== 'number')
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.REMAINDER_OF_DIVISION}) are (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.REMAINDER_OF_DIVISION} ${stringifyArgs(args)})`
-      )
-    if (b === 0)
-      throw new TypeError(
-        `Second argument of (${
-          KEYWORDS.REMAINDER_OF_DIVISION
-        }) can't be a (0) (division by 0 is not allowed) (${
-          KEYWORDS.REMAINDER_OF_DIVISION
-        } ${stringifyArgs(args)})`
-      )
-    return a % b
-  },
-  [KEYWORDS.DIVISION]: (args, env) => {
-    if (!args.length) return 0
-    if (args.length === 1) {
-      const number = evaluate(args[0], env)
-      if (typeof number !== 'number')
-        throw new TypeError(
-          `Arguments of (${KEYWORDS.DIVISION}) is not a (${
-            KEYWORDS.NUMBER_TYPE
-          }) (${KEYWORDS.DIVISION} ${stringifyArgs(args)})`
-        )
-      if (number === 0)
-        throw new TypeError(
-          `Argument of (${
-            KEYWORDS.DIVISION
-          }) can't be a (0) (division by 0 is not allowed) (${
-            KEYWORDS.DIVISION
-          } ${stringifyArgs(args)})`
-        )
-      return 1 / number
-    }
-    const operands = args.map((x) => evaluate(x, env))
-    if (operands.some((x) => typeof x !== 'number'))
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.DIVISION}) are (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.DIVISION} ${stringifyArgs(args)})`
-      )
-    if (operands.slice(1).some((x) => x === 0))
-      throw new TypeError(
-        `Argument of (${
-          KEYWORDS.DIVISION
-        }) can't be a (0) (division by 0 is not allowed) (${
-          KEYWORDS.DIVISION
-        } ${stringifyArgs(args)})`
-      )
-    return operands.reduce((a, b) => a / b)
-  },
-  [KEYWORDS.ARRAY_OR_STRING_LENGTH]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.ARRAY_OR_STRING_LENGTH
-        }) (= 1 required) (${KEYWORDS.ARRAY_OR_STRING_LENGTH} ${stringifyArgs(
-          args
-        )})`
-      )
-    const array = evaluate(args[0], env)
-    if (!(Array.isArray(array) || typeof array === 'string'))
-      throw new TypeError(
-        `First argument of (${
-          KEYWORDS.ARRAY_OR_STRING_LENGTH
-        }) must be an (or ${KEYWORDS.ARRAY_TYPE} ${KEYWORDS.STRING_TYPE}) (${
-          KEYWORDS.ARRAY_OR_STRING_LENGTH
-        } ${stringifyArgs(args)})`
-      )
-    return array.length
-  },
-  [KEYWORDS.IS_ARRAY]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.IS_ARRAY
-        }) (= 1 required) (${KEYWORDS.IS_ARRAY} ${stringifyArgs(args)})`
-      )
-    const array = evaluate(args[0], env)
-    return +Array.isArray(array)
-  },
-  [KEYWORDS.IS_NUMBER]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.IS_NUMBER
-        }) (= 1 required) (${KEYWORDS.IS_NUMBER} ${stringifyArgs(args)})`
-      )
-    return +(typeof evaluate(args[0], env) === 'number')
-  },
-  [KEYWORDS.IS_STRING]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.IS_STRING
-        }) (= 1 required) (${KEYWORDS.IS_STRING} ${stringifyArgs(args)})`
-      )
-    return +(typeof evaluate(args[0], env) === 'string')
-  },
-  [KEYWORDS.IS_FUNCTION]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.IS_FUNCTION
-        }) (= 1 required) (${KEYWORDS.IS_FUNCTION} ${stringifyArgs(args)})`
-      )
-    return +(typeof evaluate(args[0], env) === 'function')
-  },
-  [KEYWORDS.ADDITION]: (args, env) => {
-    if (!args.length) return 0 // identity
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.ADDITION
-        }), expected (or (> 1) (= 0)) but got ${args.length}. (${
-          KEYWORDS.ADDITION
-        } ${stringifyArgs(args)})`
-      )
-    const operands = args.map((x) => evaluate(x, env))
-    if (operands.some((x) => typeof x !== 'number'))
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.ADDITION}) are (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.ADDITION} ${stringifyArgs(args)})`
-      )
-    return operands.reduce((a, b) => a + b)
-  },
-  [KEYWORDS.MULTIPLICATION]: (args, env) => {
-    if (!args.length) return 1 // identity
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${KEYWORDS.MULTIPLICATION}), expected (or (> 1) (= 0)) but got ${args.length}.`
-      )
-    const operands = args.map((x) => evaluate(x, env))
-    if (operands.some((x) => typeof x !== 'number'))
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.MULTIPLICATION}) are (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.MULTIPLICATION} ${stringifyArgs(args)})`
-      )
-    return operands.reduce((a, b) => a * b)
-  },
-  [KEYWORDS.SUBTRACTION]: (args, env) => {
-    if (!args.length)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.SUBTRACTION
-        }), expected >= 1 but got ${args.length}. (${
-          KEYWORDS.SUBTRACTION
-        } ${stringifyArgs(args)})`
-      )
-    const operands = args.map((x) => evaluate(x, env))
-    if (operands.some((x) => typeof x !== 'number'))
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.SUBTRACTION}) are (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.SUBTRACTION} ${stringifyArgs(args)})`
-      )
-    return args.length === 1 ? -operands[0] : operands.reduce((a, b) => a - b)
-  },
-  [KEYWORDS.IF]: (args, env) => {
-    if (args.length !== 3)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.IF
-        }), expected (= 3) but got ${args.length} (${
-          KEYWORDS.IF
-        } ${stringifyArgs(args)})`
-      )
-    return evaluate(args[0], env)
-      ? evaluate(args[1], env)
-      : evaluate(args[2], env)
-  },
-  [KEYWORDS.UNLESS]: (args, env) => {
-    if (args.length !== 3)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.UNLESS
-        }), expected (= 3)  but got ${args.length} (${
-          KEYWORDS.UNLESS
-        } ${stringifyArgs(args)})`
-      )
-    return evaluate(args[0], env)
-      ? evaluate(args[2], env)
-      : evaluate(args[1], env)
-  },
-  [KEYWORDS.WHEN]: (args, env) => {
-    if (args.length !== 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.WHEN
-        }), expected 2 but got ${args.length} (${KEYWORDS.WHEN} ${stringifyArgs(
-          args
-        )})`
-      )
-    return evaluate(args[0], env) ? evaluate(args[1], env) : 0
-  },
-  [KEYWORDS.OTHERWISE]: (args, env) => {
-    if (args.length !== 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.OTHERWISE
-        }), expected 2 but got ${args.length} (${
-          KEYWORDS.OTHERWISE
-        } ${stringifyArgs(args)})`
-      )
-    return evaluate(args[0], env) ? 0 : evaluate(args[1], env)
-  },
-  [KEYWORDS.CONDITION]: (args, env) => {
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.CONDITION
-        }), expected (> 2 required) but got ${args.length} (${
-          KEYWORDS.CONDITION
-        } ${stringifyArgs(args)})`
-      )
-    for (let i = 0; i < args.length; i += 2)
-      if (evaluate(args[i], env)) return evaluate(args[i + 1], env)
-    return 0
-  },
-  [KEYWORDS.ARRAY_TYPE]: (args, env) => {
-    if (!args.length) return []
-    const isCapacity =
-      args.length === 2 && args[1][TYPE] === WORD && args[1][VALUE] === 'length'
-    if (isCapacity) {
-      if (args.length !== 2)
-        throw new RangeError(
-          `Invalid number of arguments for (${
-            KEYWORDS.ARRAY_TYPE
-          }) (= 2 required) (${KEYWORDS.ARRAY_TYPE} ${stringifyArgs(args)})`
-        )
-      const N = evaluate(args[0], env)
-      if (!Number.isInteger(N))
-        throw new TypeError(
-          `Size argument for (${KEYWORDS.ARRAY_TYPE}) has to be an (32 bit ${
-            KEYWORDS.NUMBER_TYPE
-          }) (${KEYWORDS.ARRAY_TYPE} ${stringifyArgs(args)})`
-        )
-      return new Array(N).fill(0)
-    }
-    return args.map((x) => evaluate(x, env))
-  },
-  [KEYWORDS.IS_ATOM]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.IS_ATOM
-        }) (= 1 required) (${KEYWORDS.IS_ATOM} ${stringifyArgs(args)})`
-      )
-    return isAtom(args[0], env)
-  },
-  [KEYWORDS.FIRST_ARRAY]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.FIRST_ARRAY
-        }) (= 1 required) (${KEYWORDS.FIRST_ARRAY} ${stringifyArgs(args)})`
-      )
-    const array = evaluate(args[0], env)
-    if (!Array.isArray(array))
-      throw new TypeError(
-        `Argument of (${KEYWORDS.FIRST_ARRAY}) must be an (${
-          KEYWORDS.ARRAY_TYPE
-        }) (${KEYWORDS.FIRST_ARRAY} ${stringifyArgs(args)})`
-      )
-    if (array.length === 0)
-      throw new RangeError(
-        `Argument of (${KEYWORDS.FIRST_ARRAY}) is an empty (${
-          KEYWORDS.ARRAY_TYPE
-        }) (${KEYWORDS.FIRST_ARRAY} ${stringifyArgs(args)})`
-      )
-    const value = array.at(0)
-    if (value == undefined)
-      throw new RangeError(
-        `Trying to get a null value in (${KEYWORDS.ARRAY_TYPE}) at (${
-          KEYWORDS.FIRST_ARRAY
-        }) (${KEYWORDS.FIRST_ARRAY} ${stringifyArgs(args)})`
-      )
-    return value
-  },
-  [KEYWORDS.REST_ARRAY]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.REST_ARRAY
-        }) (= 1 required) (${KEYWORDS.REST_ARRAY} ${stringifyArgs(args)})`
-      )
-    const array = evaluate(args[0], env)
-    if (!Array.isArray(array))
-      throw new TypeError(
-        `Argument of (${KEYWORDS.REST_ARRAY}) must be an (${
-          KEYWORDS.ARRAY_TYPE
-        }) (${KEYWORDS.REST_ARRAY} ${stringifyArgs(args)})`
-      )
-    if (array.length === 0)
-      throw new RangeError(
-        `Argument of (${KEYWORDS.REST_ARRAY}) is an empty (${
-          KEYWORDS.ARRAY_TYPE
-        }) (${KEYWORDS.REST_ARRAY} ${stringifyArgs(args)})`
-      )
-    return array.slice(1)
-  },
-  [KEYWORDS.GET_ARRAY]: (args, env) => {
-    if (args.length !== 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.GET_ARRAY
-        }) (= 2 required) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
-      )
-    const array = evaluate(args[0], env)
-    if (!Array.isArray(array))
-      throw new TypeError(
-        `First argument of (${KEYWORDS.GET_ARRAY}) must be an (${
-          KEYWORDS.ARRAY_TYPE
-        })) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
-      )
-    if (array.length === 0)
-      throw new RangeError(
-        `First argument of (${KEYWORDS.GET_ARRAY}) is an empty (${
-          KEYWORDS.ARRAY_TYPE
-        })) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)}))`
-      )
-    const index = evaluate(args[1], env)
-    if (!Number.isInteger(index))
-      throw new TypeError(
-        `Second argument of (${KEYWORDS.GET_ARRAY}) must be an (32 bit ${
-          KEYWORDS.NUMBER_TYPE
-        }) (${index}) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
-      )
-    if (index > array.length - 1 || index * -1 > array.length)
-      throw new RangeError(
-        `Second argument of (${KEYWORDS.GET_ARRAY}) is outside of (${
-          KEYWORDS.ARRAY_TYPE
-        }) bounds (${index}) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
-      )
-    const value = array.at(index)
-    if (value == undefined)
-      throw new RangeError(
-        `Trying to get a null value in (${KEYWORDS.ARRAY_TYPE}) at (${
-          KEYWORDS.GET_ARRAY
-        }) (${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
-      )
-    return value
-  },
-  [KEYWORDS.BLOCK]: (args, env) => {
-    if (!args.length)
-      throw new RangeError(
-        `Invalid number of arguments to (${KEYWORDS.BLOCK}) (>= 1 required) (${
-          KEYWORDS.BLOCK
-        } ${stringifyArgs(args)})`
-      )
-    return args.reduce((_, x) => evaluate(x, env), 0)
-  },
-  [KEYWORDS.ANONYMOUS_FUNCTION]: (args, env) => {
-    const params = args.slice(0, -1)
-    const body = args.at(-1)
-    return (props = [], scope) => {
-      if (props.length !== params.length)
-        throw new RangeError(
-          `Incorrect number of arguments for (${
-            KEYWORDS.ANONYMOUS_FUNCTION
-          } ${params.map((x) => x[VALUE]).join(' ')}) are provided. (expects ${
-            params.length
-          } but got ${props.length}) (${
-            KEYWORDS.ANONYMOUS_FUNCTION
-          } ${stringifyArgs(args)})`
-        )
-      const localEnv = Object.create(env)
-      for (let i = 0; i < props.length; ++i) {
-        Object.defineProperty(localEnv, params[i][VALUE], {
-          value: evaluate(props[i], scope),
-          writable: true
-        })
-      }
-      return evaluate(body, localEnv)
-    }
-  },
-  [KEYWORDS.NOT]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments for (${KEYWORDS.NOT}) (= 1 required) (${
-          KEYWORDS.NOT
-        } ${stringifyArgs(args)})`
-      )
-    return +!evaluate(args[0], env)
-  },
-  [KEYWORDS.EQUAL]: (args, env) => {
-    if (args.length !== 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${KEYWORDS.EQUAL}) (= 2 required) (${
-          KEYWORDS.EQUAL
-        } ${stringifyArgs(args)})`
-      )
-    const a = evaluate(args[0], env)
-    const b = evaluate(args[1], env)
-    if (typeof a !== 'number')
-      throw new TypeError(
-        `Invalid use of (${KEYWORDS.EQUAL}), first arguments are not an ${
-          KEYWORDS.NUMBER_TYPE
-        } (${KEYWORDS.EQUAL} ${stringifyArgs(args)})`
-      )
-    if (typeof b !== 'number')
-      throw new TypeError(
-        `Invalid use of (${KEYWORDS.EQUAL}), second argument are not an ${
-          KEYWORDS.NUMBER_TYPE
-        } (${KEYWORDS.EQUAL} ${stringifyArgs(args)})`
-      )
-    return +(a === b)
-  },
-  [KEYWORDS.LESS_THAN]: (args, env) => {
-    if (args.length !== 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.LESS_THAN
-        }) (= 2 required) (${KEYWORDS.LESS_THAN} ${stringifyArgs(args)})`
-      )
-    const a = evaluate(args[0], env)
-    const b = evaluate(args[1], env)
-    if (typeof a !== 'number')
-      throw new TypeError(
-        `Invalid use of (${KEYWORDS.LESS_THAN}), first arguments are not an ${
-          KEYWORDS.NUMBER_TYPE
-        } (${KEYWORDS.LESS_THAN} ${stringifyArgs(args)})`
-      )
-    if (typeof b !== 'number')
-      throw new TypeError(
-        `Invalid use of (${KEYWORDS.LESS_THAN}), second argument are not an ${
-          KEYWORDS.NUMBER_TYPE
-        } (${KEYWORDS.LESS_THAN} ${stringifyArgs(args)})`
-      )
-    return +(a < b)
-  },
-  [KEYWORDS.GREATHER_THAN]: (args, env) => {
-    if (args.length !== 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.GREATHER_THAN
-        }) (= 2 required) (${KEYWORDS.GREATHER_THAN} ${stringifyArgs(args)})`
-      )
-    const a = evaluate(args[0], env)
-    const b = evaluate(args[1], env)
-    if (typeof a !== 'number')
-      throw new TypeError(
-        `Invalid use of (${
-          KEYWORDS.GREATHER_THAN
-        }), first arguments are not an ${KEYWORDS.NUMBER_TYPE} (${
-          KEYWORDS.GREATHER_THAN
-        } ${stringifyArgs(args)})`
-      )
-    if (typeof b !== 'number')
-      throw new TypeError(
-        `Invalid use of (${
-          KEYWORDS.GREATHER_THAN
-        }), second argument are not an ${KEYWORDS.NUMBER_TYPE} (${
-          KEYWORDS.GREATHER_THAN
-        } ${stringifyArgs(args)})`
-      )
-    return +(a > b)
-  },
-  [KEYWORDS.GREATHER_THAN_OR_EQUAL]: (args, env) => {
-    if (args.length !== 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.GREATHER_THAN_OR_EQUAL
-        }) (= 2 required) (${KEYWORDS.GREATHER_THAN_OR_EQUAL} ${stringifyArgs(
-          args
-        )})`
-      )
-    const a = evaluate(args[0], env)
-    const b = evaluate(args[1], env)
-    if (typeof a !== 'number')
-      throw new TypeError(
-        `Invalid use of (${
-          KEYWORDS.GREATHER_THAN_OR_EQUAL
-        }), first arguments are not an ${KEYWORDS.NUMBER_TYPE} (${
-          KEYWORDS.GREATHER_THAN_OR_EQUAL
-        } ${stringifyArgs(args)})`
-      )
-    if (typeof b !== 'number')
-      throw new TypeError(
-        `Invalid use of (${
-          KEYWORDS.GREATHER_THAN_OR_EQUAL
-        }), second argument are not an ${KEYWORDS.NUMBER_TYPE} (${
-          KEYWORDS.GREATHER_THAN_OR_EQUAL
-        } ${stringifyArgs(args)})`
-      )
-    return +(a >= b)
-  },
-  [KEYWORDS.LESS_THAN_OR_EQUAL]: (args, env) => {
-    if (args.length !== 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.LESS_THAN_OR_EQUAL
-        }) (= 2 required) (${KEYWORDS.LESS_THAN_OR_EQUAL} ${stringifyArgs(
-          args
-        )})`
-      )
-    const a = evaluate(args[0], env)
-    const b = evaluate(args[1], env)
-    if (typeof a !== 'number')
-      throw new TypeError(
-        `Invalid use of (${
-          KEYWORDS.LESS_THAN_OR_EQUAL
-        }), first arguments are not an ${KEYWORDS.NUMBER_TYPE} (${
-          KEYWORDS.LESS_THAN_OR_EQUAL
-        } ${stringifyArgs(args)})`
-      )
-    if (typeof b !== 'number')
-      throw new TypeError(
-        `Invalid use of (${
-          KEYWORDS.LESS_THAN_OR_EQUAL
-        }), second argument are not an ${KEYWORDS.NUMBER_TYPE} (${
-          KEYWORDS.LESS_THAN_OR_EQUAL
-        } ${stringifyArgs(args)})`
-      )
-    return +(a <= b)
-  },
-  [KEYWORDS.AND]: (args, env) => {
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${KEYWORDS.AND}) (>= 2 required) (${
-          KEYWORDS.AND
-        } ${stringifyArgs(args)})`
-      )
-    let circuit
-    for (let i = 0; i < args.length - 1; ++i) {
-      circuit = evaluate(args[i], env)
-      if (circuit) continue
-      else return circuit
-    }
-    return evaluate(args.at(-1), env)
-  },
-  [KEYWORDS.OR]: (args, env) => {
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${KEYWORDS.OR}) (>= 2 required) (${
-          KEYWORDS.OR
-        } ${stringifyArgs(args)})`
-      )
-    let circuit
-    for (let i = 0; i < args.length - 1; ++i) {
-      circuit = evaluate(args[i], env)
-      if (circuit) return circuit
-      else continue
-    }
-    return evaluate(args.at(-1), env)
-  },
-  [KEYWORDS.CALL_FUNCTION]: (args, env) => {
-    if (!args.length)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.CALL_FUNCTION
-        }) (>= 1 required) (${KEYWORDS.CALL_FUNCTION} ${stringifyArgs(args)})`
-      )
-    const [first, ...rest] = args
-    if (first[TYPE] === WORD && first[VALUE] in keywords)
-      throw new TypeError(
-        `Following argument of (${
-          KEYWORDS.CALL_FUNCTION
-        }) must not be an reserved word (${
-          KEYWORDS.CALL_FUNCTION
-        } ${stringifyArgs(args)})`
-      )
-    const apply = evaluate(first, env)
-    if (typeof apply !== 'function')
-      throw new TypeError(
-        `First argument of (${KEYWORDS.CALL_FUNCTION}) must be a (${
-          KEYWORDS.ANONYMOUS_FUNCTION
-        }) (${KEYWORDS.CALL_FUNCTION} ${stringifyArgs(args)})`
-      )
-    return apply(rest, env)
-  },
-  [KEYWORDS.DEFINE_VARIABLE]: (args, env) => {
-    if (args.length !== 2)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.DEFINE_VARIABLE
-        }) (= 2 required) (${KEYWORDS.DEFINE_VARIABLE} ${stringifyArgs(args)})`
-      )
-    let name
-    const word = args[0]
-    if (word[TYPE] !== WORD)
-      throw new SyntaxError(
-        `First argument of (${KEYWORDS.DEFINE_VARIABLE}) must be word but got ${
-          word[TYPE]
-        } (${KEYWORDS.DEFINE_VARIABLE} ${stringifyArgs(args)})`
-      )
-    else if (isForbiddenVariableName(word[VALUE]))
-      throw new ReferenceError(
-        `Variable name ${word[VALUE]} is forbidden at (${
-          KEYWORDS.DEFINE_VARIABLE
-        } ${stringifyArgs(args)})`
-      )
-    name = word[VALUE]
-    Object.defineProperty(env, name, {
-      value: evaluate(args[1], env),
-      writable: false
-    })
-    return env[name]
-  },
-  [KEYWORDS.STRING_TYPE]: () => '',
-  [KEYWORDS.NUMBER_TYPE]: () => 0,
-  [KEYWORDS.BOOLEAN_TYPE]: () => 1,
-  [KEYWORDS.CAST_TYPE]: (args, env) => {
-    if (args.length !== 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${KEYWORDS.CAST_TYPE}) ${args.length}`
-      )
-    const type = args[1][VALUE]
-    const value = evaluate(args[0], env)
-    if (value == undefined)
-      throw ReferenceError(
-        `Trying to access undefined value at (${KEYWORDS.CAST_TYPE})`
-      )
-    if (args.length === 2) {
-      switch (type) {
-        case KEYWORDS.NUMBER_TYPE: {
-          const num = Number(value)
-          if (isNaN(num))
-            throw new TypeError(
-              `Attempting to convert Not a ${
-                KEYWORDS.NUMBER_TYPE
-              } ("${value}") to a ${KEYWORDS.NUMBER_TYPE} at (${
-                KEYWORDS.CAST_TYPE
-              }) (${KEYWORDS.CAST_TYPE} ${stringifyArgs(args)})`
-            )
-          return num
-        }
-        case KEYWORDS.STRING_TYPE:
-          return value.toString()
-        case KEYWORDS.BOOLEAN_TYPE:
-          return +!!value
-        case KEYWORDS.ARRAY_TYPE: {
-          if (typeof value === 'number')
-            return [...Number(value).toString()].map(Number)
-          else if (typeof value[Symbol.iterator] !== 'function')
-            throw new TypeError(
-              `Arguments are not iterable for ${KEYWORDS.ARRAY_TYPE} at (${
-                KEYWORDS.CAST_TYPE
-              }) (${KEYWORDS.CAST_TYPE} ${stringifyArgs(args)})`
-            )
-          return [...value]
-        }
-        case KEYWORDS.CHAR_TYPE: {
-          const index = evaluate(args[0], env)
-          if (!Number.isInteger(index) || index < 0)
-            throw new TypeError(
-              `Arguments are not (+ ${KEYWORDS.NUMBER_TYPE}) for ${
-                KEYWORDS.CHAR_TYPE
-              } at (${KEYWORDS.CAST_TYPE}) (${
-                KEYWORDS.CAST_TYPE
-              } ${stringifyArgs(args)})`
-            )
-          return String.fromCharCode(index)
-        }
-        case KEYWORDS.CHAR_CODE_TYPE: {
-          const string = evaluate(args[0], env)
-          if (typeof string !== 'string')
-            throw new TypeError(
-              `Argument is not (${KEYWORDS.STRING_TYPE}) for ${
-                KEYWORDS.CHAR_CODE_TYPE
-              } at (${KEYWORDS.CAST_TYPE}) (${
-                KEYWORDS.CAST_TYPE
-              } ${stringifyArgs(args)})`
-            )
-          if (string.length !== 1)
-            throw new RangeError(
-              `Argument is not of (= (length ${KEYWORDS.STRING_TYPE}) 1) for ${
-                KEYWORDS.CHAR_CODE_TYPE
-              } at (${KEYWORDS.CAST_TYPE}) (${
-                KEYWORDS.CAST_TYPE
-              } ${stringifyArgs(args)})`
-            )
-          return string.charCodeAt(0)
-        }
-        default:
-          throw new TypeError(
-            `Can only cast (or ${KEYWORDS.NUMBER_TYPE} ${
-              KEYWORDS.STRING_TYPE
-            } ${KEYWORDS.ARRAY_TYPE} ${KEYWORDS.BOOLEAN_TYPE} ${
-              KEYWORDS.CHAR_TYPE
-            } ${KEYWORDS.CHAR_CODE_TYPE}) at (${KEYWORDS.CAST_TYPE}) (${
-              KEYWORDS.CAST_TYPE
-            } ${stringifyArgs(args)})`
-          )
-      }
-    }
-  },
-  [KEYWORDS.BITWISE_AND]: (args, env) => {
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.BITWISE_AND
-        }) (>= 2 required). (${KEYWORDS.BITWISE_AND} ${stringifyArgs(args)})`
-      )
-    const operands = args.map((a) => evaluate(a, env))
-    if (operands.some((x) => typeof x !== 'number'))
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.BITWISE_AND}) are ${
-          KEYWORDS.NUMBER_TYPE
-        } (${KEYWORDS.BITWISE_AND} ${stringifyArgs(args)})`
-      )
-    return operands.reduce((acc, x) => acc & x)
-  },
-  [KEYWORDS.BITWISE_NOT]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.BITWISE_NOT
-        }) (= 1 required). (${KEYWORDS.BITWISE_NOT} ${stringifyArgs(args)})`
-      )
-    const operand = evaluate(args[0], env)
-    if (typeof operand !== 'number')
-      throw new TypeError(
-        `Argument of (${KEYWORDS.BITWISE_NOT}) is not a (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.BITWISE_NOT} ${stringifyArgs(args)})`
-      )
-    return ~operand
-  },
-  [KEYWORDS.BITWISE_OR]: (args, env) => {
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.BITWISE_OR
-        }) (>= 2 required). (${KEYWORDS.BITWISE_OR} ${stringifyArgs(args)})`
-      )
-    const operands = args.map((a) => evaluate(a, env))
-    if (operands.some((x) => typeof x !== 'number'))
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.BITWISE_OR}) are (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.BITWISE_OR} ${stringifyArgs(args)})`
-      )
-    return operands.reduce((acc, x) => acc | x)
-  },
-  [KEYWORDS.BITWISE_XOR]: (args, env) => {
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.BITWISE_XOR
-        }) (>= 2 required). (${KEYWORDS.BITWISE_XOR} ${stringifyArgs(args)})`
-      )
-    const operands = args.map((a) => evaluate(a, env))
-    if (operands.some((x) => typeof x !== 'number'))
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.BITWISE_XOR}) are (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.BITWISE_XOR} ${stringifyArgs(args)})`
-      )
-    return operands.reduce((acc, x) => acc ^ x)
-  },
-  [KEYWORDS.BITWISE_LEFT_SHIFT]: (args, env) => {
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.BITWISE_LEFT_SHIFT
-        }) (>= 2 required). (${KEYWORDS.BITWISE_LEFT_SHIFT} ${stringifyArgs(
-          args
-        )})`
-      )
-    const operands = args.map((a) => evaluate(a, env))
-    if (operands.some((x) => typeof x !== 'number'))
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.BITWISE_LEFT_SHIFT}) are (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.BITWISE_LEFT_SHIFT} ${stringifyArgs(args)})`
-      )
-    return operands.reduce((acc, x) => acc << x)
-  },
-  [KEYWORDS.BITWISE_RIGHT_SHIFT]: (args, env) => {
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.BITWISE_RIGHT_SHIFT
-        }) (>= 2 required). (${KEYWORDS.BITWISE_RIGHT_SHIFT} ${stringifyArgs(
-          args
-        )})`
-      )
-    const operands = args.map((a) => evaluate(a, env))
-    if (operands.some((x) => typeof x !== 'number'))
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.BITWISE_RIGHT_SHIFT}) are (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.BITWISE_RIGHT_SHIFT} ${stringifyArgs(args)})`
-      )
-    return operands.reduce((acc, x) => acc >> x)
-  },
-  [KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT]: (args, env) => {
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
-        }) (>= 2 required). (${
-          KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
-        } ${stringifyArgs(args)})`
-      )
-    const operands = args.map((a) => evaluate(a, env))
-    if (operands.some((x) => typeof x !== 'number'))
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT}) are (${
-          KEYWORDS.NUMBER_TYPE
-        }) (${KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT} ${stringifyArgs(args)})`
-      )
-    return operands.reduce((acc, x) => acc >>> x)
-  },
-  [KEYWORDS.PIPE]: (args, env) => {
-    if (args.length < 1)
-      throw new RangeError(
-        `Invalid number of arguments to (${KEYWORDS.PIPE}) (>= 1 required). (${
-          KEYWORDS.PIPE
-        } ${stringifyArgs(args)})`
-      )
-    let inp = args[0]
-    for (let i = 1; i < args.length; ++i) {
-      if (!args[i].length || args[i][0][TYPE] !== APPLY)
-        throw new TypeError(
-          `Argument at position (${i}) of (${
-            KEYWORDS.PIPE
-          }) is not an invoked (${KEYWORDS.ANONYMOUS_FUNCTION}). (${
-            KEYWORDS.PIPE
-          } ${stringifyArgs(args)})`
-        )
-      const [first, ...rest] = args[i]
-      const arr = [first, inp, ...rest]
-      inp = arr
-    }
-    return evaluate(inp, env)
-  },
-  [KEYWORDS.MERGE]: (args, env) => {
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments to (${KEYWORDS.MERGE}) (>= 2 required). (${
-          KEYWORDS.MERGE
-        } ${stringifyArgs(args)})`
-      )
-    const arrays = args.map((arg) => evaluate(arg, env))
-    if (arrays.some((maybe) => !Array.isArray(maybe)))
-      throw new TypeError(
-        `Arguments of (${KEYWORDS.MERGE}) must be (${KEYWORDS.ARRAY_TYPE}) (${
-          KEYWORDS.MERGE
-        } ${stringifyArgs(args)})`
-      )
-    return arrays.reduce((a, b) => a.concat(b), [])
-  },
-  [KEYWORDS.CONS]: (args, env) => {
-    if (args.length !== 2)
-      throw new RangeError(
-        `Invalid number of arguments to (${KEYWORDS.CONS}) (= 2 required). (${
-          KEYWORDS.CONS
-        } ${stringifyArgs(args)})`
-      )
-    const array = evaluate(args[0], env)
-    if (!Array.isArray(array))
-      throw new TypeError(
-        `First Argument of (${KEYWORDS.CONS}) must be (${
-          KEYWORDS.ARRAY_TYPE
-        }) (${KEYWORDS.CONS} ${stringifyArgs(args)})`
-      )
-    const other = evaluate(args[1], env)
-    if (!Array.isArray(other))
-      throw new TypeError(
-        `Second Argument of (${KEYWORDS.CONS}) must be (${
-          KEYWORDS.ARRAY_TYPE
-        }) (${KEYWORDS.CONS} ${stringifyArgs(args)})`
-      )
-    return array.concat(other)
-  },
-  [KEYWORDS.IMMUTABLE_FUNCTION]: (args, env) => {
-    if (!args.length)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.IMMUTABLE_FUNCTION
-        }) (>= 2 required). (${KEYWORDS.IMMUTABLE_FUNCTION} ${stringifyArgs(
-          args
-        )})`
-      )
-    const [definition, ...functionArgs] = args
-    const token = definition[VALUE]
-    if (!(token in keywords))
-      throw new ReferenceError(
-        `There is no such keyword ${token} at (${
-          KEYWORDS.IMMUTABLE_FUNCTION
-        } ${stringifyArgs(args)})`
-      )
-    const params = functionArgs.slice(0, -1)
-    const body = functionArgs.at(-1)
-    return (props = [], scope) => {
-      if (props.length !== params.length)
-        throw new RangeError(
-          `Incorrect number of arguments for (${KEYWORDS.IMMUTABLE_FUNCTION} ${
-            KEYWORDS.ANONYMOUS_FUNCTION
-          } ${params.map((x) => x[VALUE]).join(' ')}) are provided. (expects ${
-            params.length
-          } but got ${props.length}) (${KEYWORDS.IMMUTABLE_FUNCTION} ${
-            KEYWORDS.ANONYMOUS_FUNCTION
-          } ${stringifyArgs(args)})`
-        )
-      const localEnv = Object.create({ ...keywords })
-      for (let i = 0; i < props.length; ++i) {
-        Object.defineProperty(localEnv, params[i][VALUE], {
-          value: evaluate(props[i], scope),
-          writable: true
-        })
-      }
-      return evaluate(body, localEnv)
-    }
-  },
-  [KEYWORDS.TAIL_CALLS_OPTIMISED_RECURSIVE_FUNCTION]: (args, env) => {
-    if (!args.length)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.TAIL_CALLS_OPTIMISED_RECURSIVE_FUNCTION
-        }) (>= 2 required). (${
-          KEYWORDS.TAIL_CALLS_OPTIMISED_RECURSIVE_FUNCTION
-        } ${stringifyArgs(args)})`
-      )
-    // TODO: Add validation for TCO recursion
-    return keywords[KEYWORDS.DEFINE_VARIABLE](args, env)
-  },
-  [KEYWORDS.TEST_CASE]: (args, env) => {
-    if (args.length !== 3)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.TEST_CASE
-        }) (= 3 required) (${KEYWORDS.TEST_CASE} ${stringifyArgs(args)})`
-      )
-    const description = evaluate(args[0], env)
-    const a = evaluate(args[1], env)
-    const b = evaluate(args[2], env)
-    return !isEqualTypes(a, b) || !isEqual(a, b)
-      ? [0, description, stringifyArgs([args[1]]), b, a]
-      : [1, description, stringifyArgs([args[1]]), a]
-  },
-  [KEYWORDS.TEST_BED]: (args, env) => {
-    let tests = []
-    try {
-      if (
-        args.some(
-          ([[type, car]]) => !(type === APPLY && car === KEYWORDS.TEST_CASE)
-        )
-      )
-        throw new TypeError(
-          `Arguments of (${KEYWORDS.TEST_BED}) must be (${
-            KEYWORDS.TEST_CASE
-          }) (${KEYWORDS.TEST_BED} ${stringifyArgs(args)})`
-        )
-      tests = args.map((x) => evaluate(x, env))
-      tests.forEach(([state, describe, ...rest]) =>
-        !state
-          ? console.log(
-              '\x1b[31m',
-              `${describe} Failed:\n`,
-              `${rest[0]} => ${LISP.stringify(rest[1])} != ${LISP.stringify(
-                rest[2]
-              )}`,
-              '\n',
-              '\x1b[0m'
-            )
-          : console.log(
-              '\x1b[32m',
-              `${describe} Passed:\n`,
-              `${rest[0]} => ${LISP.stringify(rest[1])}`,
-              '\n',
-              '\x1b[0m'
-            )
-      )
-    } catch (err) {
-      console.log('\x1b[31m', 'Tests failed: \n', err.toString())
-    }
-    const result = !tests.length || tests.some(([t]) => !t)
-    result
-      ? console.log('\x1b[31m', 'Some tests failed!', '\n', '\x1b[0m')
-      : console.log('\x1b[32m', 'All tests passed!', '\n', '\x1b[0m')
-    return +!result
-  },
-  [KEYWORDS.SET_ARRAY]: (args, env) => {
-    if (args.length !== 2 && args.length !== 3)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.SET_ARRAY
-        }) (or 2 3) required (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
-      )
-    const array = evaluate(args[0], env)
-    if (!Array.isArray(array))
-      throw new TypeError(
-        `First argument of (${KEYWORDS.SET_ARRAY}) must be an (${
-          KEYWORDS.ARRAY_TYPE
-        }) but got (${array}) (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
-      )
-    const index = evaluate(args[1], env)
-    if (!Number.isInteger(index))
-      throw new TypeError(
-        `Second argument of (${KEYWORDS.SET_ARRAY}) must be an (${
-          KEYWORDS.NUMBER_TYPE
-        } integer) (${index}) (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
-      )
-    if (index > array.length)
-      throw new RangeError(
-        `Second argument of (${KEYWORDS.SET_ARRAY}) is outside of the (${
-          KEYWORDS.ARRAY_TYPE
-        }) bounds (index ${index} bounds ${array.length}) (${
-          KEYWORDS.SET_ARRAY
-        } ${stringifyArgs(args)})`
-      )
-    if (index < 0) {
-      if (args.length !== 2)
-        throw new RangeError(
-          `Invalid number of arguments for (${
-            KEYWORDS.SET_ARRAY
-          }) (if (< index 0) then 2 required) (${
-            KEYWORDS.SET_ARRAY
-          } ${stringifyArgs(args)})`
-        )
-      if (index * -1 > array.length)
-        throw new RangeError(
-          `Second argument of (${KEYWORDS.SET_ARRAY}) is outside of the (${
-            KEYWORDS.ARRAY_TYPE
-          }) bounds (index ${index} bounds ${array.length}) (${
-            KEYWORDS.SET_ARRAY
-          } ${stringifyArgs(args)})`
-        )
-      const target = array.length + index
-      while (array.length !== target) array.pop()
-    } else {
-      if (args.length !== 3)
-        throw new RangeError(
-          `Invalid number of arguments for (${
-            KEYWORDS.SET_ARRAY
-          }) (if (>= index 0) then 3 required) (${
-            KEYWORDS.SET_ARRAY
-          } ${stringifyArgs(args)})`
-        )
-      const value = evaluate(args[2], env)
-      if (value == undefined)
-        throw new RangeError(
-          `Trying to set a null value in (${KEYWORDS.ARRAY_TYPE}) at (${
-            KEYWORDS.SET_ARRAY
-          }). (${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
-        )
-      array[index] = value
-    }
-    return array
-  },
-  [KEYWORDS.LOG]: (args, env) => {
-    if (!args.length)
-      throw new RangeError(
-        `Invalid number of arguments to (${KEYWORDS.LOG}) (>= 1 required) (${
-          KEYWORDS.LOG
-        } ${stringifyArgs(args)})`
-      )
-    const expressions = args.map((x) => evaluate(x, env))
-    console.log(...expressions)
-    return expressions.at(-1)
-  },
-  [KEYWORDS.CLEAR_CONSOLE]: (args) => {
-    if (args.length)
-      throw new RangeError(
-        `Invalid number of arguments to (${
-          KEYWORDS.CLEAR_CONSOLE
-        }) (= 0 required) (${KEYWORDS.CLEAR_CONSOLE} ${stringifyArgs(args)})`
-      )
-    console.clear()
-    return 0
-  }
-}
-keywords[KEYWORDS.NOT_COMPILED_BLOCK] = keywords[KEYWORDS.BLOCK]
-keywords[KEYWORDS.DOC] = (args, env) => {
-  if (args.length !== 1)
-    throw new RangeError(
-      `Invalid number of arguments to (${KEYWORDS.DOC}) (= 1 required) (${
-        KEYWORDS.DOC
-      } ${stringifyArgs(args)})`
-    )
-  const lib = evaluate(args[0], env)
-  const kw = Object.keys(env).map((x) => [x])
-  const standard = std.map(([_, [_0, name], [_1, ...arg]]) => {
-    const args = arg
-      .slice(0, -1)
-      .map((x) => x[VALUE])
-      .filter((x) => x !== 'lambda')
-    return [name, ...args]
-  })
-  const all = [...kw, ...standard]
-  switch (lib) {
-    case '*':
-      return all.map((x) => `(${x.join(' ')})`)
-    case 'keywords':
-      return kw.map((x) => `(${x.join(' ')})`)
-    case 'std':
-      return standard.map((x) => `(${x.join(' ')})`)
-    default:
-      return all
-        .filter((name) => name[0].includes(lib))
-        .map((x) => `(${x.join(' ')})`)
-  }
-}
-export { keywords }